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, 255, 113, 0, // 19: decode to C_UNIMP using decoder 0
38 // 19: } else try {
39 OPC_CheckPredicate, 0, // 23: check predicate 0
40 OPC_Decode, 189, 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, 231, 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, 232, 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, 187, 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, 244, 113, 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, 197, 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, 190, 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, 198, 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, 219, 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, 217, 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, 220, 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, 210, 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, 248, 113, 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, 226, 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, 247, 113, 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, 227, 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, 228, 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, 223, 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, 224, 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, 225, 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, 188, 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, 218, 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, 211, 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, 209, 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, 215, 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, 214, 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, 235, 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, 242, 113, 17, // 299: decode to C_SH using decoder 17
180 // 299: }
181 // 299: } // switch Inst[12:10]
182 // 299: }
183 1, 161, 1, // 303: case 0x1: {
184 OPC_SwitchField, 10, 2, // 306: switch Inst[11:10] {
185 0, 6, // 309: case 0x0: {
186 OPC_CheckPredicate, 0, // 311: check predicate 0
187 OPC_Decode, 246, 113, 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, 245, 113, 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, 193, 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, 249, 113, 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, 250, 113, 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, 128, 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, 191, 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, 234, 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, 229, 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, 192, 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, 129, 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, 240, 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, 130, 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, 241, 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, 131, 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, 233, 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, 208, 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, 230, 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, 196, 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, 207, 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, 186, 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, 201, 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, 205, 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, 202, 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, 251, 113, 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, 194, 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, 252, 113, 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, 236, 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, 195, 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, 237, 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, 199, 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, 203, 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, 206, 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, 200, 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, 204, 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 DecoderTableXqccmp16[103] = {
390 16, // 0: BitWidth 16
391 OPC_SwitchField, 10, 6, // 1: switch Inst[15:10] {
392 43, 27, // 4: case 0x2b: {
393 OPC_SwitchField, 5, 2, // 6: switch Inst[6:5] {
394 1, 10, // 9: case 0x1: {
395 OPC_CheckPredicate, 10, // 11: check predicate 10
396 OPC_CheckField, 0, 2, 2, // 13: check Inst[1:0] == 0x2
397 OPC_Decode, 166, 122, 33, // 17: decode to QC_CM_MVSA01 using decoder 33
398 // 17: }
399 3, 0, // 21: case 0x3: {
400 OPC_CheckPredicate, 10, // 23: check predicate 10
401 OPC_CheckField, 0, 2, 2, // 25: check Inst[1:0] == 0x2
402 OPC_Decode, 165, 122, 33, // 29: decode to QC_CM_MVA01S using decoder 33
403 // 29: }
404 // 29: } // switch Inst[6:5]
405 // 29: }
406 46, 39, // 33: case 0x2e: {
407 OPC_SwitchField, 8, 2, // 35: switch Inst[9:8] {
408 0, 10, // 38: case 0x0: {
409 OPC_CheckPredicate, 10, // 40: check predicate 10
410 OPC_CheckField, 0, 2, 2, // 42: check Inst[1:0] == 0x2
411 OPC_Decode, 170, 122, 34, // 46: decode to QC_CM_PUSH using decoder 34
412 // 46: }
413 1, 10, // 50: case 0x1: {
414 OPC_CheckPredicate, 10, // 52: check predicate 10
415 OPC_CheckField, 0, 2, 2, // 54: check Inst[1:0] == 0x2
416 OPC_Decode, 171, 122, 35, // 58: decode to QC_CM_PUSHFP using decoder 35
417 // 58: }
418 2, 0, // 62: case 0x2: {
419 OPC_CheckPredicate, 10, // 64: check predicate 10
420 OPC_CheckField, 0, 2, 2, // 66: check Inst[1:0] == 0x2
421 OPC_Decode, 167, 122, 34, // 70: decode to QC_CM_POP using decoder 34
422 // 70: }
423 // 70: } // switch Inst[9:8]
424 // 70: }
425 47, 0, // 74: case 0x2f: {
426 OPC_SwitchField, 8, 2, // 76: switch Inst[9:8] {
427 0, 10, // 79: case 0x0: {
428 OPC_CheckPredicate, 10, // 81: check predicate 10
429 OPC_CheckField, 0, 2, 2, // 83: check Inst[1:0] == 0x2
430 OPC_Decode, 169, 122, 34, // 87: decode to QC_CM_POPRETZ using decoder 34
431 // 87: }
432 2, 0, // 91: case 0x2: {
433 OPC_CheckPredicate, 10, // 93: check predicate 10
434 OPC_CheckField, 0, 2, 2, // 95: check Inst[1:0] == 0x2
435 OPC_Decode, 168, 122, 34, // 99: decode to QC_CM_POPRET using decoder 34
436 // 99: }
437 // 99: } // switch Inst[9:8]
438 // 99: }
439 // 99: } // switch Inst[15:10]
440};
441static const uint8_t DecoderTableXqccmt16[27] = {
442 16, // 0: BitWidth 16
443 OPC_CheckField, 0, 2, 2, // 1: check Inst[1:0] == 0x2
444 OPC_CheckField, 10, 6, 40, // 5: check Inst[15:10] == 0x28
445 OPC_Scope, 10, // 9: try {
446 OPC_CheckField, 7, 3, 0, // 11: check Inst[9:7] == 0x0
447 OPC_CheckPredicate, 11, // 15: check predicate 11
448 OPC_Decode, 164, 122, 36, // 17: decode to QC_CM_JT using decoder 36
449 // 17: } else try {
450 OPC_CheckPredicate, 11, // 21: check predicate 11
451 OPC_Decode, 163, 122, 37, // 23: decode to QC_CM_JALT using decoder 37
452 // 23: }
453};
454static const uint8_t DecoderTableXqci16[234] = {
455 16, // 0: BitWidth 16
456 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
457 0, 119, // 4: case 0x0: {
458 OPC_CheckField, 0, 2, 2, // 6: check Inst[1:0] == 0x2
459 OPC_CheckField, 12, 1, 1, // 10: check Inst[12] == 0x1
460 OPC_Scope, 66, // 14: try {
461 OPC_SwitchField, 2, 10, // 16: switch Inst[11:2] {
462 132, 4, 6, // 19: case 0x204: {
463 OPC_CheckPredicate, 12, // 22: check predicate 12
464 OPC_Decode, 185, 122, 0, // 24: decode to QC_C_MIENTER using decoder 0
465 // 24: }
466 164, 4, 6, // 28: case 0x224: {
467 OPC_CheckPredicate, 12, // 31: check predicate 12
468 OPC_Decode, 186, 122, 0, // 33: decode to QC_C_MIENTER_NEST using decoder 0
469 // 33: }
470 196, 4, 6, // 37: case 0x244: {
471 OPC_CheckPredicate, 12, // 40: check predicate 12
472 OPC_Decode, 189, 122, 0, // 42: decode to QC_C_MRET using decoder 0
473 // 42: }
474 228, 4, 6, // 46: case 0x264: {
475 OPC_CheckPredicate, 12, // 49: check predicate 12
476 OPC_Decode, 188, 122, 0, // 51: decode to QC_C_MNRET using decoder 0
477 // 51: }
478 132, 5, 6, // 55: case 0x284: {
479 OPC_CheckPredicate, 12, // 58: check predicate 12
480 OPC_Decode, 187, 122, 0, // 60: decode to QC_C_MILEAVERET using decoder 0
481 // 60: }
482 196, 5, 6, // 64: case 0x2c4: {
483 OPC_CheckPredicate, 12, // 67: check predicate 12
484 OPC_Decode, 180, 122, 0, // 69: decode to QC_C_DI using decoder 0
485 // 69: }
486 228, 5, 0, // 73: case 0x2e4: {
487 OPC_CheckPredicate, 12, // 76: check predicate 12
488 OPC_Decode, 182, 122, 0, // 78: decode to QC_C_EI using decoder 0
489 // 78: }
490 // 78: } // switch Inst[11:2]
491 OPC_Scope, 35, // 82: } else try {
492 OPC_SwitchField, 2, 5, // 84: switch Inst[6:2] {
493 0, 6, // 87: case 0x0: {
494 OPC_CheckPredicate, 12, // 89: check predicate 12
495 OPC_Decode, 181, 122, 22, // 91: decode to QC_C_DIR using decoder 22
496 // 91: }
497 1, 6, // 95: case 0x1: {
498 OPC_CheckPredicate, 12, // 97: check predicate 12
499 OPC_Decode, 183, 122, 22, // 99: decode to QC_C_EIR using decoder 22
500 // 99: }
501 2, 6, // 103: case 0x2: {
502 OPC_CheckPredicate, 12, // 105: check predicate 12
503 OPC_Decode, 192, 122, 22, // 107: decode to QC_C_SETINT using decoder 22
504 // 107: }
505 3, 0, // 111: case 0x3: {
506 OPC_CheckPredicate, 12, // 113: check predicate 12
507 OPC_Decode, 179, 122, 22, // 115: decode to QC_C_CLRINT using decoder 22
508 // 115: }
509 // 115: } // switch Inst[6:2]
510 // 115: } else try {
511 OPC_CheckPredicate, 13, // 119: check predicate 13
512 OPC_Decode, 184, 122, 38, // 121: decode to QC_C_EXTU using decoder 38
513 // 121: }
514 // 121: }
515 1, 10, // 125: case 0x1: {
516 OPC_CheckPredicate, 14, // 127: check predicate 14
517 OPC_CheckField, 0, 2, 2, // 129: check Inst[1:0] == 0x2
518 OPC_Decode, 190, 122, 39, // 133: decode to QC_C_MULIADD using decoder 39
519 // 133: }
520 4, 75, // 137: case 0x4: {
521 OPC_SwitchField, 10, 3, // 139: switch Inst[12:10] {
522 0, 10, // 142: case 0x0: {
523 OPC_CheckPredicate, 15, // 144: check predicate 15
524 OPC_CheckField, 0, 7, 1, // 146: check Inst[6:0] == 0x1
525 OPC_Decode, 193, 122, 40, // 150: decode to QC_C_SYNC using decoder 40
526 // 150: }
527 1, 10, // 154: case 0x1: {
528 OPC_CheckPredicate, 15, // 156: check predicate 15
529 OPC_CheckField, 0, 7, 1, // 158: check Inst[6:0] == 0x1
530 OPC_Decode, 194, 122, 40, // 162: decode to QC_C_SYNCR using decoder 40
531 // 162: }
532 4, 22, // 166: case 0x4: {
533 OPC_CheckField, 0, 2, 1, // 168: check Inst[1:0] == 0x1
534 OPC_Scope, 10, // 172: try {
535 OPC_CheckField, 2, 5, 0, // 174: check Inst[6:2] == 0x0
536 OPC_CheckPredicate, 15, // 178: check predicate 15
537 OPC_Decode, 195, 122, 40, // 180: decode to QC_C_SYNCWF using decoder 40
538 // 180: } else try {
539 OPC_CheckPredicate, 13, // 184: check predicate 13
540 OPC_Decode, 177, 122, 41, // 186: decode to QC_C_BEXTI using decoder 41
541 // 186: }
542 // 186: }
543 5, 0, // 190: case 0x5: {
544 OPC_CheckField, 0, 2, 1, // 192: check Inst[1:0] == 0x1
545 OPC_Scope, 10, // 196: try {
546 OPC_CheckField, 2, 5, 0, // 198: check Inst[6:2] == 0x0
547 OPC_CheckPredicate, 15, // 202: check predicate 15
548 OPC_Decode, 196, 122, 40, // 204: decode to QC_C_SYNCWL using decoder 40
549 // 204: } else try {
550 OPC_CheckPredicate, 13, // 208: check predicate 13
551 OPC_Decode, 178, 122, 41, // 210: decode to QC_C_BSETI using decoder 41
552 // 210: }
553 // 210: }
554 // 210: } // switch Inst[12:10]
555 // 210: }
556 5, 0, // 214: case 0x5: {
557 OPC_CheckPredicate, 16, // 216: check predicate 16
558 OPC_CheckField, 10, 3, 3, // 218: check Inst[12:10] == 0x3
559 OPC_CheckField, 5, 2, 0, // 222: check Inst[6:5] == 0x0
560 OPC_CheckField, 0, 2, 2, // 226: check Inst[1:0] == 0x2
561 OPC_Decode, 191, 122, 42, // 230: decode to QC_C_MVEQZ using decoder 42
562 // 230: }
563 // 230: } // switch Inst[15:13]
564};
565static const uint8_t DecoderTableXwchc16[115] = {
566 16, // 0: BitWidth 16
567 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
568 1, 19, // 4: case 0x1: {
569 OPC_SwitchField, 0, 2, // 6: switch Inst[1:0] {
570 0, 6, // 9: case 0x0: {
571 OPC_CheckPredicate, 17, // 11: check predicate 17
572 OPC_Decode, 180, 123, 43, // 13: decode to QK_C_LBU using decoder 43
573 // 13: }
574 2, 0, // 17: case 0x2: {
575 OPC_CheckPredicate, 17, // 19: check predicate 17
576 OPC_Decode, 182, 123, 44, // 21: decode to QK_C_LHU using decoder 44
577 // 21: }
578 // 21: } // switch Inst[1:0]
579 // 21: }
580 4, 67, // 25: case 0x4: {
581 OPC_SwitchField, 5, 2, // 27: switch Inst[6:5] {
582 0, 14, // 30: case 0x0: {
583 OPC_CheckPredicate, 17, // 32: check predicate 17
584 OPC_CheckField, 11, 2, 0, // 34: check Inst[12:11] == 0x0
585 OPC_CheckField, 0, 2, 0, // 38: check Inst[1:0] == 0x0
586 OPC_Decode, 181, 123, 45, // 42: decode to QK_C_LBUSP using decoder 45
587 // 42: }
588 1, 14, // 46: case 0x1: {
589 OPC_CheckPredicate, 17, // 48: check predicate 17
590 OPC_CheckField, 11, 2, 0, // 50: check Inst[12:11] == 0x0
591 OPC_CheckField, 0, 2, 0, // 54: check Inst[1:0] == 0x0
592 OPC_Decode, 183, 123, 46, // 58: decode to QK_C_LHUSP using decoder 46
593 // 58: }
594 2, 14, // 62: case 0x2: {
595 OPC_CheckPredicate, 17, // 64: check predicate 17
596 OPC_CheckField, 11, 2, 0, // 66: check Inst[12:11] == 0x0
597 OPC_CheckField, 0, 2, 0, // 70: check Inst[1:0] == 0x0
598 OPC_Decode, 185, 123, 45, // 74: decode to QK_C_SBSP using decoder 45
599 // 74: }
600 3, 0, // 78: case 0x3: {
601 OPC_CheckPredicate, 17, // 80: check predicate 17
602 OPC_CheckField, 11, 2, 0, // 82: check Inst[12:11] == 0x0
603 OPC_CheckField, 0, 2, 0, // 86: check Inst[1:0] == 0x0
604 OPC_Decode, 187, 123, 46, // 90: decode to QK_C_SHSP using decoder 46
605 // 90: }
606 // 90: } // switch Inst[6:5]
607 // 90: }
608 5, 0, // 94: case 0x5: {
609 OPC_SwitchField, 0, 2, // 96: switch Inst[1:0] {
610 0, 6, // 99: case 0x0: {
611 OPC_CheckPredicate, 17, // 101: check predicate 17
612 OPC_Decode, 184, 123, 43, // 103: decode to QK_C_SB using decoder 43
613 // 103: }
614 2, 0, // 107: case 0x2: {
615 OPC_CheckPredicate, 17, // 109: check predicate 17
616 OPC_Decode, 186, 123, 44, // 111: decode to QK_C_SH using decoder 44
617 // 111: }
618 // 111: } // switch Inst[1:0]
619 // 111: }
620 // 111: } // switch Inst[15:13]
621};
622static const uint8_t DecoderTableZcOverlap16[162] = {
623 16, // 0: BitWidth 16
624 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
625 3, 19, // 4: case 0x3: {
626 OPC_SwitchField, 0, 2, // 6: switch Inst[1:0] {
627 0, 6, // 9: case 0x0: {
628 OPC_CheckPredicate, 18, // 11: check predicate 18
629 OPC_Decode, 213, 113, 47, // 13: decode to C_LD_RV32 using decoder 47
630 // 13: }
631 2, 0, // 17: case 0x2: {
632 OPC_CheckPredicate, 18, // 19: check predicate 18
633 OPC_Decode, 212, 113, 48, // 21: decode to C_LDSP_RV32 using decoder 48
634 // 21: }
635 // 21: } // switch Inst[1:0]
636 // 21: }
637 5, 114, // 25: case 0x5: {
638 OPC_SwitchField, 10, 3, // 27: switch Inst[12:10] {
639 0, 22, // 30: case 0x0: {
640 OPC_CheckField, 0, 2, 2, // 32: check Inst[1:0] == 0x2
641 OPC_Scope, 10, // 36: try {
642 OPC_CheckField, 7, 3, 0, // 38: check Inst[9:7] == 0x0
643 OPC_CheckPredicate, 19, // 42: check predicate 19
644 OPC_Decode, 239, 110, 36, // 44: decode to CM_JT using decoder 36
645 // 44: } else try {
646 OPC_CheckPredicate, 19, // 48: check predicate 19
647 OPC_Decode, 238, 110, 37, // 50: decode to CM_JALT using decoder 37
648 // 50: }
649 // 50: }
650 3, 27, // 54: case 0x3: {
651 OPC_SwitchField, 5, 2, // 56: switch Inst[6:5] {
652 1, 10, // 59: case 0x1: {
653 OPC_CheckPredicate, 20, // 61: check predicate 20
654 OPC_CheckField, 0, 2, 2, // 63: check Inst[1:0] == 0x2
655 OPC_Decode, 241, 110, 33, // 67: decode to CM_MVSA01 using decoder 33
656 // 67: }
657 3, 0, // 71: case 0x3: {
658 OPC_CheckPredicate, 20, // 73: check predicate 20
659 OPC_CheckField, 0, 2, 2, // 75: check Inst[1:0] == 0x2
660 OPC_Decode, 240, 110, 33, // 79: decode to CM_MVA01S using decoder 33
661 // 79: }
662 // 79: } // switch Inst[6:5]
663 // 79: }
664 6, 27, // 83: case 0x6: {
665 OPC_SwitchField, 8, 2, // 85: switch Inst[9:8] {
666 0, 10, // 88: case 0x0: {
667 OPC_CheckPredicate, 20, // 90: check predicate 20
668 OPC_CheckField, 0, 2, 2, // 92: check Inst[1:0] == 0x2
669 OPC_Decode, 245, 110, 34, // 96: decode to CM_PUSH using decoder 34
670 // 96: }
671 2, 0, // 100: case 0x2: {
672 OPC_CheckPredicate, 20, // 102: check predicate 20
673 OPC_CheckField, 0, 2, 2, // 104: check Inst[1:0] == 0x2
674 OPC_Decode, 242, 110, 34, // 108: decode to CM_POP using decoder 34
675 // 108: }
676 // 108: } // switch Inst[9:8]
677 // 108: }
678 7, 0, // 112: case 0x7: {
679 OPC_SwitchField, 8, 2, // 114: switch Inst[9:8] {
680 0, 10, // 117: case 0x0: {
681 OPC_CheckPredicate, 20, // 119: check predicate 20
682 OPC_CheckField, 0, 2, 2, // 121: check Inst[1:0] == 0x2
683 OPC_Decode, 244, 110, 34, // 125: decode to CM_POPRETZ using decoder 34
684 // 125: }
685 2, 0, // 129: case 0x2: {
686 OPC_CheckPredicate, 20, // 131: check predicate 20
687 OPC_CheckField, 0, 2, 2, // 133: check Inst[1:0] == 0x2
688 OPC_Decode, 243, 110, 34, // 137: decode to CM_POPRET using decoder 34
689 // 137: }
690 // 137: } // switch Inst[9:8]
691 // 137: }
692 // 137: } // switch Inst[12:10]
693 // 137: }
694 7, 0, // 141: case 0x7: {
695 OPC_SwitchField, 0, 2, // 143: switch Inst[1:0] {
696 0, 6, // 146: case 0x0: {
697 OPC_CheckPredicate, 18, // 148: check predicate 18
698 OPC_Decode, 239, 113, 47, // 150: decode to C_SD_RV32 using decoder 47
699 // 150: }
700 2, 0, // 154: case 0x2: {
701 OPC_CheckPredicate, 18, // 156: check predicate 18
702 OPC_Decode, 238, 113, 49, // 158: decode to C_SDSP_RV32 using decoder 49
703 // 158: }
704 // 158: } // switch Inst[1:0]
705 // 158: }
706 // 158: } // switch Inst[15:13]
707};
708// Handling 50 cases.
709template <typename InsnType>
710static std::enable_if_t<InsnBitWidth<InsnType> == 16, DecodeStatus>
711decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
712 DecodeComplete = true;
713 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
714 TmpType tmp;
715 switch (Idx) {
716 default: llvm_unreachable("Invalid decoder index!");
717 case 0:
718 return S;
719 case 1:
720 tmp = fieldFromInstruction(insn, 2, 3);
721 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
722 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
723 return MCDisassembler::Fail;
724 tmp = 0x0;
725 tmp |= fieldFromInstruction(insn, 5, 1) << 3;
726 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
727 tmp |= fieldFromInstruction(insn, 7, 4) << 6;
728 tmp |= fieldFromInstruction(insn, 11, 2) << 4;
729 if (!Check(S, decodeUImmNonZeroOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
730 return S;
731 case 2:
732 tmp = 0x0;
733 tmp |= fieldFromInstruction(insn, 2, 5);
734 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
735 if (!Check(S, decodeSImmNonZeroOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
736 return S;
737 case 3:
738 tmp = fieldFromInstruction(insn, 7, 5);
739 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
740 tmp = fieldFromInstruction(insn, 7, 5);
741 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
742 tmp = 0x0;
743 tmp |= fieldFromInstruction(insn, 2, 5);
744 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
745 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
746 return S;
747 case 4:
748 tmp = fieldFromInstruction(insn, 7, 5);
749 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
750 tmp = fieldFromInstruction(insn, 7, 5);
751 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
752 tmp = 0x0;
753 tmp |= fieldFromInstruction(insn, 2, 5);
754 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
755 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
756 return S;
757 case 5:
758 tmp = fieldFromInstruction(insn, 2, 3);
759 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F8_D, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
760 tmp = fieldFromInstruction(insn, 7, 3);
761 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
762 tmp = 0x0;
763 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
764 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
765 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
766 return S;
767 case 6:
768 tmp = fieldFromInstruction(insn, 7, 5);
769 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
770 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
771 return MCDisassembler::Fail;
772 tmp = 0x0;
773 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
774 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
775 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
776 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
777 return S;
778 case 7:
779 tmp = fieldFromInstruction(insn, 2, 3);
780 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
781 tmp = fieldFromInstruction(insn, 7, 3);
782 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
783 tmp = 0x0;
784 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
785 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
786 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
787 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
788 return S;
789 case 8:
790 tmp = fieldFromInstruction(insn, 7, 5);
791 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
792 tmp = 0x0;
793 tmp |= fieldFromInstruction(insn, 2, 5);
794 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
795 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
796 return S;
797 case 9:
798 tmp = fieldFromInstruction(insn, 7, 5);
799 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
800 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
801 return MCDisassembler::Fail;
802 tmp = 0x0;
803 tmp |= fieldFromInstruction(insn, 2, 2) << 6;
804 tmp |= fieldFromInstruction(insn, 4, 3) << 2;
805 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
806 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
807 return S;
808 case 10:
809 tmp = fieldFromInstruction(insn, 2, 3);
810 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
811 tmp = fieldFromInstruction(insn, 7, 3);
812 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
813 tmp = 0x0;
814 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
815 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
816 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
817 return S;
818 case 11:
819 tmp = 0x1;
820 if (!Check(S, DecodeSingleRegister<RISCV::X1, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
821 return S;
822 case 12:
823 tmp = 0x5;
824 if (!Check(S, DecodeSingleRegister<RISCV::X5, 5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
825 return S;
826 case 13:
827 tmp = 0x2;
828 if (!Check(S, DecodeSingleRegister<RISCV::X2, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
829 tmp = 0x2;
830 if (!Check(S, DecodeSingleRegister<RISCV::X2, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
831 tmp = 0x0;
832 tmp |= fieldFromInstruction(insn, 2, 1) << 5;
833 tmp |= fieldFromInstruction(insn, 3, 2) << 7;
834 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
835 tmp |= fieldFromInstruction(insn, 6, 1) << 4;
836 tmp |= fieldFromInstruction(insn, 12, 1) << 9;
837 if (!Check(S, decodeSImmNonZeroOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
838 return S;
839 case 14:
840 tmp = fieldFromInstruction(insn, 7, 5);
841 if (!Check(S, DecodeGPRNoX2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
842 tmp = 0x0;
843 tmp |= fieldFromInstruction(insn, 2, 5);
844 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
845 if (!Check(S, decodeCLUIImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
846 return S;
847 case 15:
848 tmp = fieldFromInstruction(insn, 7, 5);
849 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
850 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
851 return MCDisassembler::Fail;
852 tmp = 0x0;
853 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
854 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
855 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
856 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
857 return S;
858 case 16:
859 tmp = fieldFromInstruction(insn, 2, 3);
860 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
861 tmp = fieldFromInstruction(insn, 7, 3);
862 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
863 tmp = 0x0;
864 tmp |= fieldFromInstruction(insn, 5, 1) << 1;
865 tmp |= fieldFromInstruction(insn, 6, 1);
866 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
867 return S;
868 case 17:
869 tmp = fieldFromInstruction(insn, 2, 3);
870 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
871 tmp = fieldFromInstruction(insn, 7, 3);
872 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
873 tmp = fieldFromInstruction(insn, 5, 1) << 1;
874 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
875 return S;
876 case 18:
877 tmp = fieldFromInstruction(insn, 7, 3);
878 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
879 tmp = fieldFromInstruction(insn, 7, 3);
880 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
881 tmp = 0x0;
882 tmp |= fieldFromInstruction(insn, 2, 5);
883 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
884 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
885 return S;
886 case 19:
887 tmp = fieldFromInstruction(insn, 7, 3);
888 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
889 tmp = fieldFromInstruction(insn, 7, 3);
890 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
891 tmp = 0x0;
892 tmp |= fieldFromInstruction(insn, 2, 5);
893 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
894 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
895 return S;
896 case 20:
897 tmp = fieldFromInstruction(insn, 7, 3);
898 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
899 tmp = fieldFromInstruction(insn, 7, 3);
900 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
901 tmp = fieldFromInstruction(insn, 2, 3);
902 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
903 return S;
904 case 21:
905 tmp = fieldFromInstruction(insn, 7, 3);
906 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
907 tmp = fieldFromInstruction(insn, 7, 3);
908 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
909 return S;
910 case 22:
911 tmp = fieldFromInstruction(insn, 7, 5);
912 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
913 return S;
914 case 23:
915 tmp = fieldFromInstruction(insn, 7, 5);
916 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
917 tmp = fieldFromInstruction(insn, 2, 5);
918 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
919 return S;
920 case 24:
921 tmp = fieldFromInstruction(insn, 7, 5);
922 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
923 tmp = fieldFromInstruction(insn, 7, 5);
924 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
925 tmp = fieldFromInstruction(insn, 2, 5);
926 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
927 return S;
928 case 25:
929 tmp = 0x0;
930 tmp |= fieldFromInstruction(insn, 2, 1) << 4;
931 tmp |= fieldFromInstruction(insn, 3, 3);
932 tmp |= fieldFromInstruction(insn, 6, 1) << 6;
933 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
934 tmp |= fieldFromInstruction(insn, 8, 1) << 9;
935 tmp |= fieldFromInstruction(insn, 9, 2) << 7;
936 tmp |= fieldFromInstruction(insn, 11, 1) << 3;
937 tmp |= fieldFromInstruction(insn, 12, 1) << 10;
938 if (!Check(S, decodeSImmOperandAndLslN<12, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
939 return S;
940 case 26:
941 tmp = fieldFromInstruction(insn, 2, 5);
942 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
943 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
944 return MCDisassembler::Fail;
945 tmp = 0x0;
946 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
947 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
948 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
949 return S;
950 case 27:
951 tmp = fieldFromInstruction(insn, 7, 3);
952 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
953 tmp = 0x0;
954 tmp |= fieldFromInstruction(insn, 2, 1) << 4;
955 tmp |= fieldFromInstruction(insn, 3, 2);
956 tmp |= fieldFromInstruction(insn, 5, 2) << 5;
957 tmp |= fieldFromInstruction(insn, 10, 2) << 2;
958 tmp |= fieldFromInstruction(insn, 12, 1) << 7;
959 if (!Check(S, decodeSImmOperandAndLslN<9, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
960 return S;
961 case 28:
962 tmp = fieldFromInstruction(insn, 2, 5);
963 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
964 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
965 return MCDisassembler::Fail;
966 tmp = 0x0;
967 tmp |= fieldFromInstruction(insn, 7, 2) << 6;
968 tmp |= fieldFromInstruction(insn, 9, 4) << 2;
969 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
970 return S;
971 case 29:
972 tmp = fieldFromInstruction(insn, 2, 5);
973 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
974 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
975 return MCDisassembler::Fail;
976 tmp = 0x0;
977 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
978 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
979 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
980 return S;
981 case 30:
982 tmp = fieldFromInstruction(insn, 2, 3);
983 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F8_F, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
984 tmp = fieldFromInstruction(insn, 7, 3);
985 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
986 tmp = 0x0;
987 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
988 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
989 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
990 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
991 return S;
992 case 31:
993 tmp = fieldFromInstruction(insn, 7, 5);
994 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
995 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
996 return MCDisassembler::Fail;
997 tmp = 0x0;
998 tmp |= fieldFromInstruction(insn, 2, 2) << 6;
999 tmp |= fieldFromInstruction(insn, 4, 3) << 2;
1000 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
1001 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1002 return S;
1003 case 32:
1004 tmp = fieldFromInstruction(insn, 2, 5);
1005 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1006 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
1007 return MCDisassembler::Fail;
1008 tmp = 0x0;
1009 tmp |= fieldFromInstruction(insn, 7, 2) << 6;
1010 tmp |= fieldFromInstruction(insn, 9, 4) << 2;
1011 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1012 return S;
1013 case 33:
1014 tmp = fieldFromInstruction(insn, 7, 3);
1015 if (!Check(S, DecodeGPRS07RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1016 tmp = fieldFromInstruction(insn, 2, 3);
1017 if (!Check(S, DecodeGPRS07RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1018 return S;
1019 case 34:
1020 tmp = fieldFromInstruction(insn, 4, 4);
1021 if (!Check(S, decodeZcmpRlist(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1022 tmp = fieldFromInstruction(insn, 2, 2) << 4;
1023 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
1024 return S;
1025 case 35:
1026 tmp = fieldFromInstruction(insn, 4, 4);
1027 if (!Check(S, decodeXqccmpRlistS0(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1028 tmp = fieldFromInstruction(insn, 2, 2) << 4;
1029 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
1030 return S;
1031 case 36:
1032 tmp = fieldFromInstruction(insn, 2, 5);
1033 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1034 return S;
1035 case 37:
1036 tmp = fieldFromInstruction(insn, 2, 8);
1037 if (!Check(S, decodeUImmOperand<8, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1038 return S;
1039 case 38:
1040 tmp = fieldFromInstruction(insn, 7, 5);
1041 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1042 tmp = fieldFromInstruction(insn, 7, 5);
1043 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1044 tmp = fieldFromInstruction(insn, 2, 5);
1045 if (!Check(S, decodeUImmPlus1Operand<5, 6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1046 return S;
1047 case 39:
1048 tmp = fieldFromInstruction(insn, 2, 3);
1049 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1050 tmp = fieldFromInstruction(insn, 2, 3);
1051 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1052 tmp = fieldFromInstruction(insn, 7, 3);
1053 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1054 tmp = 0x0;
1055 tmp |= fieldFromInstruction(insn, 5, 1) << 4;
1056 tmp |= fieldFromInstruction(insn, 6, 1);
1057 tmp |= fieldFromInstruction(insn, 10, 3) << 1;
1058 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1059 return S;
1060 case 40:
1061 tmp = fieldFromInstruction(insn, 7, 3);
1062 if (!Check(S, decodeUImmSlistOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1063 return S;
1064 case 41:
1065 tmp = fieldFromInstruction(insn, 7, 3);
1066 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1067 tmp = fieldFromInstruction(insn, 7, 3);
1068 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1069 tmp = fieldFromInstruction(insn, 2, 5);
1070 if (!Check(S, decodeUImmLog2XLenNonZeroOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1071 return S;
1072 case 42:
1073 tmp = fieldFromInstruction(insn, 2, 3);
1074 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1075 tmp = fieldFromInstruction(insn, 2, 3);
1076 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1077 tmp = fieldFromInstruction(insn, 7, 3);
1078 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1079 return S;
1080 case 43:
1081 tmp = fieldFromInstruction(insn, 2, 3);
1082 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1083 tmp = fieldFromInstruction(insn, 7, 3);
1084 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1085 tmp = 0x0;
1086 tmp |= fieldFromInstruction(insn, 5, 2) << 1;
1087 tmp |= fieldFromInstruction(insn, 10, 2) << 3;
1088 tmp |= fieldFromInstruction(insn, 12, 1);
1089 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1090 return S;
1091 case 44:
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 tmp = 0x0;
1097 tmp |= fieldFromInstruction(insn, 5, 2) << 1;
1098 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1099 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1100 return S;
1101 case 45:
1102 tmp = fieldFromInstruction(insn, 2, 3);
1103 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1104 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
1105 return MCDisassembler::Fail;
1106 tmp = fieldFromInstruction(insn, 7, 4);
1107 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1108 return S;
1109 case 46:
1110 tmp = fieldFromInstruction(insn, 2, 3);
1111 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1112 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
1113 return MCDisassembler::Fail;
1114 tmp = 0x0;
1115 tmp |= fieldFromInstruction(insn, 7, 1) << 4;
1116 tmp |= fieldFromInstruction(insn, 8, 3) << 1;
1117 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1118 return S;
1119 case 47:
1120 tmp = fieldFromInstruction(insn, 2, 3);
1121 if (!Check(S, DecodeGPRPairCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1122 tmp = fieldFromInstruction(insn, 7, 3);
1123 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1124 tmp = 0x0;
1125 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
1126 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1127 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1128 return S;
1129 case 48:
1130 tmp = fieldFromInstruction(insn, 7, 5);
1131 if (!Check(S, DecodeGPRPairNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1132 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
1133 return MCDisassembler::Fail;
1134 tmp = 0x0;
1135 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
1136 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
1137 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
1138 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1139 return S;
1140 case 49:
1141 tmp = fieldFromInstruction(insn, 2, 5);
1142 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1143 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
1144 return MCDisassembler::Fail;
1145 tmp = 0x0;
1146 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
1147 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1148 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1149 return S;
1150 }
1151}
1152static const uint8_t DecoderTable32[20919] = {
1153 32, // 0: BitWidth 32
1154 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
1155 3, 49, // 4: case 0x3: {
1156 OPC_SwitchField, 12, 3, // 6: switch Inst[14:12] {
1157 0, 4, // 9: case 0x0: {
1158 OPC_Decode, 208, 116, 0, // 11: decode to LB using decoder 0
1159 // 11: }
1160 1, 4, // 15: case 0x1: {
1161 OPC_Decode, 216, 116, 0, // 17: decode to LH using decoder 0
1162 // 17: }
1163 2, 4, // 21: case 0x2: {
1164 OPC_Decode, 230, 116, 0, // 23: decode to LW using decoder 0
1165 // 23: }
1166 3, 6, // 27: case 0x3: {
1167 OPC_CheckPredicate, 21, // 29: check predicate 21
1168 OPC_Decode, 212, 116, 0, // 31: decode to LD using decoder 0
1169 // 31: }
1170 4, 4, // 35: case 0x4: {
1171 OPC_Decode, 209, 116, 0, // 37: decode to LBU using decoder 0
1172 // 37: }
1173 5, 4, // 41: case 0x5: {
1174 OPC_Decode, 217, 116, 0, // 43: decode to LHU using decoder 0
1175 // 43: }
1176 6, 0, // 47: case 0x6: {
1177 OPC_CheckPredicate, 21, // 49: check predicate 21
1178 OPC_Decode, 231, 116, 0, // 51: decode to LWU using decoder 0
1179 // 51: }
1180 // 51: } // switch Inst[14:12]
1181 // 51: }
1182 7, 183, 14, // 55: case 0x7: {
1183 OPC_SwitchField, 12, 3, // 58: switch Inst[14:12] {
1184 0, 194, 3, // 61: case 0x0: {
1185 OPC_SwitchField, 26, 6, // 64: switch Inst[31:26] {
1186 0, 43, // 67: case 0x0: {
1187 OPC_SwitchField, 20, 5, // 69: switch Inst[24:20] {
1188 0, 6, // 72: case 0x0: {
1189 OPC_CheckPredicate, 22, // 74: check predicate 22
1190 OPC_Decode, 208, 127, 1, // 76: decode to VLE8_V using decoder 1
1191 // 76: }
1192 8, 10, // 80: case 0x8: {
1193 OPC_CheckPredicate, 22, // 82: check predicate 22
1194 OPC_CheckField, 25, 1, 1, // 84: check Inst[25] == 0x1
1195 OPC_Decode, 188, 127, 2, // 88: decode to VL1RE8_V using decoder 2
1196 // 88: }
1197 11, 10, // 92: case 0xb: {
1198 OPC_CheckPredicate, 22, // 94: check predicate 22
1199 OPC_CheckField, 25, 1, 1, // 96: check Inst[25] == 0x1
1200 OPC_Decode, 209, 127, 2, // 100: decode to VLM_V using decoder 2
1201 // 100: }
1202 16, 0, // 104: case 0x10: {
1203 OPC_CheckPredicate, 22, // 106: check predicate 22
1204 OPC_Decode, 207, 127, 1, // 108: decode to VLE8FF_V using decoder 1
1205 // 108: }
1206 // 108: } // switch Inst[24:20]
1207 // 108: }
1208 1, 7, // 112: case 0x1: {
1209 OPC_CheckPredicate, 22, // 114: check predicate 22
1210 OPC_Decode, 205, 128, 1, 3, // 116: decode to VLUXEI8_V using decoder 3
1211 // 116: }
1212 2, 6, // 121: case 0x2: {
1213 OPC_CheckPredicate, 22, // 123: check predicate 22
1214 OPC_Decode, 245, 127, 4, // 125: decode to VLSE8_V using decoder 4
1215 // 125: }
1216 3, 6, // 129: case 0x3: {
1217 OPC_CheckPredicate, 22, // 131: check predicate 22
1218 OPC_Decode, 213, 127, 3, // 133: decode to VLOXEI8_V using decoder 3
1219 // 133: }
1220 8, 31, // 137: case 0x8: {
1221 OPC_SwitchField, 20, 5, // 139: switch Inst[24:20] {
1222 0, 6, // 142: case 0x0: {
1223 OPC_CheckPredicate, 22, // 144: check predicate 22
1224 OPC_Decode, 253, 127, 1, // 146: decode to VLSEG2E8_V using decoder 1
1225 // 146: }
1226 8, 10, // 150: case 0x8: {
1227 OPC_CheckPredicate, 22, // 152: check predicate 22
1228 OPC_CheckField, 25, 1, 1, // 154: check Inst[25] == 0x1
1229 OPC_Decode, 192, 127, 5, // 158: decode to VL2RE8_V using decoder 5
1230 // 158: }
1231 16, 0, // 162: case 0x10: {
1232 OPC_CheckPredicate, 22, // 164: check predicate 22
1233 OPC_Decode, 252, 127, 1, // 166: decode to VLSEG2E8FF_V using decoder 1
1234 // 166: }
1235 // 166: } // switch Inst[24:20]
1236 // 166: }
1237 9, 7, // 170: case 0x9: {
1238 OPC_CheckPredicate, 22, // 172: check predicate 22
1239 OPC_Decode, 209, 128, 1, 3, // 174: decode to VLUXSEG2EI8_V using decoder 3
1240 // 174: }
1241 10, 7, // 179: case 0xa: {
1242 OPC_CheckPredicate, 22, // 181: check predicate 22
1243 OPC_Decode, 177, 128, 1, 4, // 183: decode to VLSSEG2E8_V using decoder 4
1244 // 183: }
1245 11, 6, // 188: case 0xb: {
1246 OPC_CheckPredicate, 22, // 190: check predicate 22
1247 OPC_Decode, 217, 127, 3, // 192: decode to VLOXSEG2EI8_V using decoder 3
1248 // 192: }
1249 16, 21, // 196: case 0x10: {
1250 OPC_SwitchField, 20, 5, // 198: switch Inst[24:20] {
1251 0, 7, // 201: case 0x0: {
1252 OPC_CheckPredicate, 22, // 203: check predicate 22
1253 OPC_Decode, 133, 128, 1, 1, // 205: decode to VLSEG3E8_V using decoder 1
1254 // 205: }
1255 16, 0, // 210: case 0x10: {
1256 OPC_CheckPredicate, 22, // 212: check predicate 22
1257 OPC_Decode, 132, 128, 1, 1, // 214: decode to VLSEG3E8FF_V using decoder 1
1258 // 214: }
1259 // 214: } // switch Inst[24:20]
1260 // 214: }
1261 17, 7, // 219: case 0x11: {
1262 OPC_CheckPredicate, 22, // 221: check predicate 22
1263 OPC_Decode, 213, 128, 1, 3, // 223: decode to VLUXSEG3EI8_V using decoder 3
1264 // 223: }
1265 18, 7, // 228: case 0x12: {
1266 OPC_CheckPredicate, 22, // 230: check predicate 22
1267 OPC_Decode, 181, 128, 1, 4, // 232: decode to VLSSEG3E8_V using decoder 4
1268 // 232: }
1269 19, 6, // 237: case 0x13: {
1270 OPC_CheckPredicate, 22, // 239: check predicate 22
1271 OPC_Decode, 221, 127, 3, // 241: decode to VLOXSEG3EI8_V using decoder 3
1272 // 241: }
1273 24, 33, // 245: case 0x18: {
1274 OPC_SwitchField, 20, 5, // 247: switch Inst[24:20] {
1275 0, 7, // 250: case 0x0: {
1276 OPC_CheckPredicate, 22, // 252: check predicate 22
1277 OPC_Decode, 141, 128, 1, 1, // 254: decode to VLSEG4E8_V using decoder 1
1278 // 254: }
1279 8, 10, // 259: case 0x8: {
1280 OPC_CheckPredicate, 22, // 261: check predicate 22
1281 OPC_CheckField, 25, 1, 1, // 263: check Inst[25] == 0x1
1282 OPC_Decode, 196, 127, 6, // 267: decode to VL4RE8_V using decoder 6
1283 // 267: }
1284 16, 0, // 271: case 0x10: {
1285 OPC_CheckPredicate, 22, // 273: check predicate 22
1286 OPC_Decode, 140, 128, 1, 1, // 275: decode to VLSEG4E8FF_V using decoder 1
1287 // 275: }
1288 // 275: } // switch Inst[24:20]
1289 // 275: }
1290 25, 7, // 280: case 0x19: {
1291 OPC_CheckPredicate, 22, // 282: check predicate 22
1292 OPC_Decode, 217, 128, 1, 3, // 284: decode to VLUXSEG4EI8_V using decoder 3
1293 // 284: }
1294 26, 7, // 289: case 0x1a: {
1295 OPC_CheckPredicate, 22, // 291: check predicate 22
1296 OPC_Decode, 185, 128, 1, 4, // 293: decode to VLSSEG4E8_V using decoder 4
1297 // 293: }
1298 27, 6, // 298: case 0x1b: {
1299 OPC_CheckPredicate, 22, // 300: check predicate 22
1300 OPC_Decode, 225, 127, 3, // 302: decode to VLOXSEG4EI8_V using decoder 3
1301 // 302: }
1302 32, 21, // 306: case 0x20: {
1303 OPC_SwitchField, 20, 5, // 308: switch Inst[24:20] {
1304 0, 7, // 311: case 0x0: {
1305 OPC_CheckPredicate, 22, // 313: check predicate 22
1306 OPC_Decode, 149, 128, 1, 1, // 315: decode to VLSEG5E8_V using decoder 1
1307 // 315: }
1308 16, 0, // 320: case 0x10: {
1309 OPC_CheckPredicate, 22, // 322: check predicate 22
1310 OPC_Decode, 148, 128, 1, 1, // 324: decode to VLSEG5E8FF_V using decoder 1
1311 // 324: }
1312 // 324: } // switch Inst[24:20]
1313 // 324: }
1314 33, 7, // 329: case 0x21: {
1315 OPC_CheckPredicate, 22, // 331: check predicate 22
1316 OPC_Decode, 221, 128, 1, 3, // 333: decode to VLUXSEG5EI8_V using decoder 3
1317 // 333: }
1318 34, 7, // 338: case 0x22: {
1319 OPC_CheckPredicate, 22, // 340: check predicate 22
1320 OPC_Decode, 189, 128, 1, 4, // 342: decode to VLSSEG5E8_V using decoder 4
1321 // 342: }
1322 35, 6, // 347: case 0x23: {
1323 OPC_CheckPredicate, 22, // 349: check predicate 22
1324 OPC_Decode, 229, 127, 3, // 351: decode to VLOXSEG5EI8_V using decoder 3
1325 // 351: }
1326 40, 21, // 355: case 0x28: {
1327 OPC_SwitchField, 20, 5, // 357: switch Inst[24:20] {
1328 0, 7, // 360: case 0x0: {
1329 OPC_CheckPredicate, 22, // 362: check predicate 22
1330 OPC_Decode, 157, 128, 1, 1, // 364: decode to VLSEG6E8_V using decoder 1
1331 // 364: }
1332 16, 0, // 369: case 0x10: {
1333 OPC_CheckPredicate, 22, // 371: check predicate 22
1334 OPC_Decode, 156, 128, 1, 1, // 373: decode to VLSEG6E8FF_V using decoder 1
1335 // 373: }
1336 // 373: } // switch Inst[24:20]
1337 // 373: }
1338 41, 7, // 378: case 0x29: {
1339 OPC_CheckPredicate, 22, // 380: check predicate 22
1340 OPC_Decode, 225, 128, 1, 3, // 382: decode to VLUXSEG6EI8_V using decoder 3
1341 // 382: }
1342 42, 7, // 387: case 0x2a: {
1343 OPC_CheckPredicate, 22, // 389: check predicate 22
1344 OPC_Decode, 193, 128, 1, 4, // 391: decode to VLSSEG6E8_V using decoder 4
1345 // 391: }
1346 43, 6, // 396: case 0x2b: {
1347 OPC_CheckPredicate, 22, // 398: check predicate 22
1348 OPC_Decode, 233, 127, 3, // 400: decode to VLOXSEG6EI8_V using decoder 3
1349 // 400: }
1350 48, 21, // 404: case 0x30: {
1351 OPC_SwitchField, 20, 5, // 406: switch Inst[24:20] {
1352 0, 7, // 409: case 0x0: {
1353 OPC_CheckPredicate, 22, // 411: check predicate 22
1354 OPC_Decode, 165, 128, 1, 1, // 413: decode to VLSEG7E8_V using decoder 1
1355 // 413: }
1356 16, 0, // 418: case 0x10: {
1357 OPC_CheckPredicate, 22, // 420: check predicate 22
1358 OPC_Decode, 164, 128, 1, 1, // 422: decode to VLSEG7E8FF_V using decoder 1
1359 // 422: }
1360 // 422: } // switch Inst[24:20]
1361 // 422: }
1362 49, 7, // 427: case 0x31: {
1363 OPC_CheckPredicate, 22, // 429: check predicate 22
1364 OPC_Decode, 229, 128, 1, 3, // 431: decode to VLUXSEG7EI8_V using decoder 3
1365 // 431: }
1366 50, 7, // 436: case 0x32: {
1367 OPC_CheckPredicate, 22, // 438: check predicate 22
1368 OPC_Decode, 197, 128, 1, 4, // 440: decode to VLSSEG7E8_V using decoder 4
1369 // 440: }
1370 51, 6, // 445: case 0x33: {
1371 OPC_CheckPredicate, 22, // 447: check predicate 22
1372 OPC_Decode, 237, 127, 3, // 449: decode to VLOXSEG7EI8_V using decoder 3
1373 // 449: }
1374 56, 33, // 453: case 0x38: {
1375 OPC_SwitchField, 20, 5, // 455: switch Inst[24:20] {
1376 0, 7, // 458: case 0x0: {
1377 OPC_CheckPredicate, 22, // 460: check predicate 22
1378 OPC_Decode, 173, 128, 1, 1, // 462: decode to VLSEG8E8_V using decoder 1
1379 // 462: }
1380 8, 10, // 467: case 0x8: {
1381 OPC_CheckPredicate, 22, // 469: check predicate 22
1382 OPC_CheckField, 25, 1, 1, // 471: check Inst[25] == 0x1
1383 OPC_Decode, 200, 127, 7, // 475: decode to VL8RE8_V using decoder 7
1384 // 475: }
1385 16, 0, // 479: case 0x10: {
1386 OPC_CheckPredicate, 22, // 481: check predicate 22
1387 OPC_Decode, 172, 128, 1, 1, // 483: decode to VLSEG8E8FF_V using decoder 1
1388 // 483: }
1389 // 483: } // switch Inst[24:20]
1390 // 483: }
1391 57, 7, // 488: case 0x39: {
1392 OPC_CheckPredicate, 22, // 490: check predicate 22
1393 OPC_Decode, 233, 128, 1, 3, // 492: decode to VLUXSEG8EI8_V using decoder 3
1394 // 492: }
1395 58, 7, // 497: case 0x3a: {
1396 OPC_CheckPredicate, 22, // 499: check predicate 22
1397 OPC_Decode, 201, 128, 1, 4, // 501: decode to VLSSEG8E8_V using decoder 4
1398 // 501: }
1399 59, 0, // 506: case 0x3b: {
1400 OPC_CheckPredicate, 22, // 508: check predicate 22
1401 OPC_Decode, 241, 127, 3, // 510: decode to VLOXSEG8EI8_V using decoder 3
1402 // 510: }
1403 // 510: } // switch Inst[31:26]
1404 // 510: }
1405 1, 6, // 514: case 0x1: {
1406 OPC_CheckPredicate, 23, // 516: check predicate 23
1407 OPC_Decode, 144, 115, 8, // 518: decode to FLH using decoder 8
1408 // 518: }
1409 2, 6, // 522: case 0x2: {
1410 OPC_CheckPredicate, 24, // 524: check predicate 24
1411 OPC_Decode, 162, 115, 9, // 526: decode to FLW using decoder 9
1412 // 526: }
1413 3, 6, // 530: case 0x3: {
1414 OPC_CheckPredicate, 25, // 532: check predicate 25
1415 OPC_Decode, 131, 115, 10, // 534: decode to FLD using decoder 10
1416 // 534: }
1417 4, 6, // 538: case 0x4: {
1418 OPC_CheckPredicate, 26, // 540: check predicate 26
1419 OPC_Decode, 149, 115, 11, // 542: decode to FLQ using decoder 11
1420 // 542: }
1421 5, 180, 3, // 546: case 0x5: {
1422 OPC_SwitchField, 26, 6, // 549: switch Inst[31:26] {
1423 0, 31, // 552: case 0x0: {
1424 OPC_SwitchField, 20, 5, // 554: switch Inst[24:20] {
1425 0, 6, // 557: case 0x0: {
1426 OPC_CheckPredicate, 22, // 559: check predicate 22
1427 OPC_Decode, 202, 127, 1, // 561: decode to VLE16_V using decoder 1
1428 // 561: }
1429 8, 10, // 565: case 0x8: {
1430 OPC_CheckPredicate, 22, // 567: check predicate 22
1431 OPC_CheckField, 25, 1, 1, // 569: check Inst[25] == 0x1
1432 OPC_Decode, 185, 127, 2, // 573: decode to VL1RE16_V using decoder 2
1433 // 573: }
1434 16, 0, // 577: case 0x10: {
1435 OPC_CheckPredicate, 22, // 579: check predicate 22
1436 OPC_Decode, 201, 127, 1, // 581: decode to VLE16FF_V using decoder 1
1437 // 581: }
1438 // 581: } // switch Inst[24:20]
1439 // 581: }
1440 1, 7, // 585: case 0x1: {
1441 OPC_CheckPredicate, 22, // 587: check predicate 22
1442 OPC_Decode, 202, 128, 1, 3, // 589: decode to VLUXEI16_V using decoder 3
1443 // 589: }
1444 2, 6, // 594: case 0x2: {
1445 OPC_CheckPredicate, 22, // 596: check predicate 22
1446 OPC_Decode, 242, 127, 4, // 598: decode to VLSE16_V using decoder 4
1447 // 598: }
1448 3, 6, // 602: case 0x3: {
1449 OPC_CheckPredicate, 22, // 604: check predicate 22
1450 OPC_Decode, 210, 127, 3, // 606: decode to VLOXEI16_V using decoder 3
1451 // 606: }
1452 8, 31, // 610: case 0x8: {
1453 OPC_SwitchField, 20, 5, // 612: switch Inst[24:20] {
1454 0, 6, // 615: case 0x0: {
1455 OPC_CheckPredicate, 22, // 617: check predicate 22
1456 OPC_Decode, 247, 127, 1, // 619: decode to VLSEG2E16_V using decoder 1
1457 // 619: }
1458 8, 10, // 623: case 0x8: {
1459 OPC_CheckPredicate, 22, // 625: check predicate 22
1460 OPC_CheckField, 25, 1, 1, // 627: check Inst[25] == 0x1
1461 OPC_Decode, 189, 127, 5, // 631: decode to VL2RE16_V using decoder 5
1462 // 631: }
1463 16, 0, // 635: case 0x10: {
1464 OPC_CheckPredicate, 22, // 637: check predicate 22
1465 OPC_Decode, 246, 127, 1, // 639: decode to VLSEG2E16FF_V using decoder 1
1466 // 639: }
1467 // 639: } // switch Inst[24:20]
1468 // 639: }
1469 9, 7, // 643: case 0x9: {
1470 OPC_CheckPredicate, 22, // 645: check predicate 22
1471 OPC_Decode, 206, 128, 1, 3, // 647: decode to VLUXSEG2EI16_V using decoder 3
1472 // 647: }
1473 10, 7, // 652: case 0xa: {
1474 OPC_CheckPredicate, 22, // 654: check predicate 22
1475 OPC_Decode, 174, 128, 1, 4, // 656: decode to VLSSEG2E16_V using decoder 4
1476 // 656: }
1477 11, 6, // 661: case 0xb: {
1478 OPC_CheckPredicate, 22, // 663: check predicate 22
1479 OPC_Decode, 214, 127, 3, // 665: decode to VLOXSEG2EI16_V using decoder 3
1480 // 665: }
1481 16, 19, // 669: case 0x10: {
1482 OPC_SwitchField, 20, 5, // 671: switch Inst[24:20] {
1483 0, 6, // 674: case 0x0: {
1484 OPC_CheckPredicate, 22, // 676: check predicate 22
1485 OPC_Decode, 255, 127, 1, // 678: decode to VLSEG3E16_V using decoder 1
1486 // 678: }
1487 16, 0, // 682: case 0x10: {
1488 OPC_CheckPredicate, 22, // 684: check predicate 22
1489 OPC_Decode, 254, 127, 1, // 686: decode to VLSEG3E16FF_V using decoder 1
1490 // 686: }
1491 // 686: } // switch Inst[24:20]
1492 // 686: }
1493 17, 7, // 690: case 0x11: {
1494 OPC_CheckPredicate, 22, // 692: check predicate 22
1495 OPC_Decode, 210, 128, 1, 3, // 694: decode to VLUXSEG3EI16_V using decoder 3
1496 // 694: }
1497 18, 7, // 699: case 0x12: {
1498 OPC_CheckPredicate, 22, // 701: check predicate 22
1499 OPC_Decode, 178, 128, 1, 4, // 703: decode to VLSSEG3E16_V using decoder 4
1500 // 703: }
1501 19, 6, // 708: case 0x13: {
1502 OPC_CheckPredicate, 22, // 710: check predicate 22
1503 OPC_Decode, 218, 127, 3, // 712: decode to VLOXSEG3EI16_V using decoder 3
1504 // 712: }
1505 24, 33, // 716: case 0x18: {
1506 OPC_SwitchField, 20, 5, // 718: switch Inst[24:20] {
1507 0, 7, // 721: case 0x0: {
1508 OPC_CheckPredicate, 22, // 723: check predicate 22
1509 OPC_Decode, 135, 128, 1, 1, // 725: decode to VLSEG4E16_V using decoder 1
1510 // 725: }
1511 8, 10, // 730: case 0x8: {
1512 OPC_CheckPredicate, 22, // 732: check predicate 22
1513 OPC_CheckField, 25, 1, 1, // 734: check Inst[25] == 0x1
1514 OPC_Decode, 193, 127, 6, // 738: decode to VL4RE16_V using decoder 6
1515 // 738: }
1516 16, 0, // 742: case 0x10: {
1517 OPC_CheckPredicate, 22, // 744: check predicate 22
1518 OPC_Decode, 134, 128, 1, 1, // 746: decode to VLSEG4E16FF_V using decoder 1
1519 // 746: }
1520 // 746: } // switch Inst[24:20]
1521 // 746: }
1522 25, 7, // 751: case 0x19: {
1523 OPC_CheckPredicate, 22, // 753: check predicate 22
1524 OPC_Decode, 214, 128, 1, 3, // 755: decode to VLUXSEG4EI16_V using decoder 3
1525 // 755: }
1526 26, 7, // 760: case 0x1a: {
1527 OPC_CheckPredicate, 22, // 762: check predicate 22
1528 OPC_Decode, 182, 128, 1, 4, // 764: decode to VLSSEG4E16_V using decoder 4
1529 // 764: }
1530 27, 6, // 769: case 0x1b: {
1531 OPC_CheckPredicate, 22, // 771: check predicate 22
1532 OPC_Decode, 222, 127, 3, // 773: decode to VLOXSEG4EI16_V using decoder 3
1533 // 773: }
1534 32, 21, // 777: case 0x20: {
1535 OPC_SwitchField, 20, 5, // 779: switch Inst[24:20] {
1536 0, 7, // 782: case 0x0: {
1537 OPC_CheckPredicate, 22, // 784: check predicate 22
1538 OPC_Decode, 143, 128, 1, 1, // 786: decode to VLSEG5E16_V using decoder 1
1539 // 786: }
1540 16, 0, // 791: case 0x10: {
1541 OPC_CheckPredicate, 22, // 793: check predicate 22
1542 OPC_Decode, 142, 128, 1, 1, // 795: decode to VLSEG5E16FF_V using decoder 1
1543 // 795: }
1544 // 795: } // switch Inst[24:20]
1545 // 795: }
1546 33, 7, // 800: case 0x21: {
1547 OPC_CheckPredicate, 22, // 802: check predicate 22
1548 OPC_Decode, 218, 128, 1, 3, // 804: decode to VLUXSEG5EI16_V using decoder 3
1549 // 804: }
1550 34, 7, // 809: case 0x22: {
1551 OPC_CheckPredicate, 22, // 811: check predicate 22
1552 OPC_Decode, 186, 128, 1, 4, // 813: decode to VLSSEG5E16_V using decoder 4
1553 // 813: }
1554 35, 6, // 818: case 0x23: {
1555 OPC_CheckPredicate, 22, // 820: check predicate 22
1556 OPC_Decode, 226, 127, 3, // 822: decode to VLOXSEG5EI16_V using decoder 3
1557 // 822: }
1558 40, 21, // 826: case 0x28: {
1559 OPC_SwitchField, 20, 5, // 828: switch Inst[24:20] {
1560 0, 7, // 831: case 0x0: {
1561 OPC_CheckPredicate, 22, // 833: check predicate 22
1562 OPC_Decode, 151, 128, 1, 1, // 835: decode to VLSEG6E16_V using decoder 1
1563 // 835: }
1564 16, 0, // 840: case 0x10: {
1565 OPC_CheckPredicate, 22, // 842: check predicate 22
1566 OPC_Decode, 150, 128, 1, 1, // 844: decode to VLSEG6E16FF_V using decoder 1
1567 // 844: }
1568 // 844: } // switch Inst[24:20]
1569 // 844: }
1570 41, 7, // 849: case 0x29: {
1571 OPC_CheckPredicate, 22, // 851: check predicate 22
1572 OPC_Decode, 222, 128, 1, 3, // 853: decode to VLUXSEG6EI16_V using decoder 3
1573 // 853: }
1574 42, 7, // 858: case 0x2a: {
1575 OPC_CheckPredicate, 22, // 860: check predicate 22
1576 OPC_Decode, 190, 128, 1, 4, // 862: decode to VLSSEG6E16_V using decoder 4
1577 // 862: }
1578 43, 6, // 867: case 0x2b: {
1579 OPC_CheckPredicate, 22, // 869: check predicate 22
1580 OPC_Decode, 230, 127, 3, // 871: decode to VLOXSEG6EI16_V using decoder 3
1581 // 871: }
1582 48, 21, // 875: case 0x30: {
1583 OPC_SwitchField, 20, 5, // 877: switch Inst[24:20] {
1584 0, 7, // 880: case 0x0: {
1585 OPC_CheckPredicate, 22, // 882: check predicate 22
1586 OPC_Decode, 159, 128, 1, 1, // 884: decode to VLSEG7E16_V using decoder 1
1587 // 884: }
1588 16, 0, // 889: case 0x10: {
1589 OPC_CheckPredicate, 22, // 891: check predicate 22
1590 OPC_Decode, 158, 128, 1, 1, // 893: decode to VLSEG7E16FF_V using decoder 1
1591 // 893: }
1592 // 893: } // switch Inst[24:20]
1593 // 893: }
1594 49, 7, // 898: case 0x31: {
1595 OPC_CheckPredicate, 22, // 900: check predicate 22
1596 OPC_Decode, 226, 128, 1, 3, // 902: decode to VLUXSEG7EI16_V using decoder 3
1597 // 902: }
1598 50, 7, // 907: case 0x32: {
1599 OPC_CheckPredicate, 22, // 909: check predicate 22
1600 OPC_Decode, 194, 128, 1, 4, // 911: decode to VLSSEG7E16_V using decoder 4
1601 // 911: }
1602 51, 6, // 916: case 0x33: {
1603 OPC_CheckPredicate, 22, // 918: check predicate 22
1604 OPC_Decode, 234, 127, 3, // 920: decode to VLOXSEG7EI16_V using decoder 3
1605 // 920: }
1606 56, 33, // 924: case 0x38: {
1607 OPC_SwitchField, 20, 5, // 926: switch Inst[24:20] {
1608 0, 7, // 929: case 0x0: {
1609 OPC_CheckPredicate, 22, // 931: check predicate 22
1610 OPC_Decode, 167, 128, 1, 1, // 933: decode to VLSEG8E16_V using decoder 1
1611 // 933: }
1612 8, 10, // 938: case 0x8: {
1613 OPC_CheckPredicate, 22, // 940: check predicate 22
1614 OPC_CheckField, 25, 1, 1, // 942: check Inst[25] == 0x1
1615 OPC_Decode, 197, 127, 7, // 946: decode to VL8RE16_V using decoder 7
1616 // 946: }
1617 16, 0, // 950: case 0x10: {
1618 OPC_CheckPredicate, 22, // 952: check predicate 22
1619 OPC_Decode, 166, 128, 1, 1, // 954: decode to VLSEG8E16FF_V using decoder 1
1620 // 954: }
1621 // 954: } // switch Inst[24:20]
1622 // 954: }
1623 57, 7, // 959: case 0x39: {
1624 OPC_CheckPredicate, 22, // 961: check predicate 22
1625 OPC_Decode, 230, 128, 1, 3, // 963: decode to VLUXSEG8EI16_V using decoder 3
1626 // 963: }
1627 58, 7, // 968: case 0x3a: {
1628 OPC_CheckPredicate, 22, // 970: check predicate 22
1629 OPC_Decode, 198, 128, 1, 4, // 972: decode to VLSSEG8E16_V using decoder 4
1630 // 972: }
1631 59, 0, // 977: case 0x3b: {
1632 OPC_CheckPredicate, 22, // 979: check predicate 22
1633 OPC_Decode, 238, 127, 3, // 981: decode to VLOXSEG8EI16_V using decoder 3
1634 // 981: }
1635 // 981: } // switch Inst[31:26]
1636 // 981: }
1637 6, 182, 3, // 985: case 0x6: {
1638 OPC_SwitchField, 26, 6, // 988: switch Inst[31:26] {
1639 0, 31, // 991: case 0x0: {
1640 OPC_SwitchField, 20, 5, // 993: switch Inst[24:20] {
1641 0, 6, // 996: case 0x0: {
1642 OPC_CheckPredicate, 22, // 998: check predicate 22
1643 OPC_Decode, 204, 127, 1, // 1000: decode to VLE32_V using decoder 1
1644 // 1000: }
1645 8, 10, // 1004: case 0x8: {
1646 OPC_CheckPredicate, 22, // 1006: check predicate 22
1647 OPC_CheckField, 25, 1, 1, // 1008: check Inst[25] == 0x1
1648 OPC_Decode, 186, 127, 2, // 1012: decode to VL1RE32_V using decoder 2
1649 // 1012: }
1650 16, 0, // 1016: case 0x10: {
1651 OPC_CheckPredicate, 22, // 1018: check predicate 22
1652 OPC_Decode, 203, 127, 1, // 1020: decode to VLE32FF_V using decoder 1
1653 // 1020: }
1654 // 1020: } // switch Inst[24:20]
1655 // 1020: }
1656 1, 7, // 1024: case 0x1: {
1657 OPC_CheckPredicate, 22, // 1026: check predicate 22
1658 OPC_Decode, 203, 128, 1, 3, // 1028: decode to VLUXEI32_V using decoder 3
1659 // 1028: }
1660 2, 6, // 1033: case 0x2: {
1661 OPC_CheckPredicate, 22, // 1035: check predicate 22
1662 OPC_Decode, 243, 127, 4, // 1037: decode to VLSE32_V using decoder 4
1663 // 1037: }
1664 3, 6, // 1041: case 0x3: {
1665 OPC_CheckPredicate, 22, // 1043: check predicate 22
1666 OPC_Decode, 211, 127, 3, // 1045: decode to VLOXEI32_V using decoder 3
1667 // 1045: }
1668 8, 31, // 1049: case 0x8: {
1669 OPC_SwitchField, 20, 5, // 1051: switch Inst[24:20] {
1670 0, 6, // 1054: case 0x0: {
1671 OPC_CheckPredicate, 22, // 1056: check predicate 22
1672 OPC_Decode, 249, 127, 1, // 1058: decode to VLSEG2E32_V using decoder 1
1673 // 1058: }
1674 8, 10, // 1062: case 0x8: {
1675 OPC_CheckPredicate, 22, // 1064: check predicate 22
1676 OPC_CheckField, 25, 1, 1, // 1066: check Inst[25] == 0x1
1677 OPC_Decode, 190, 127, 5, // 1070: decode to VL2RE32_V using decoder 5
1678 // 1070: }
1679 16, 0, // 1074: case 0x10: {
1680 OPC_CheckPredicate, 22, // 1076: check predicate 22
1681 OPC_Decode, 248, 127, 1, // 1078: decode to VLSEG2E32FF_V using decoder 1
1682 // 1078: }
1683 // 1078: } // switch Inst[24:20]
1684 // 1078: }
1685 9, 7, // 1082: case 0x9: {
1686 OPC_CheckPredicate, 22, // 1084: check predicate 22
1687 OPC_Decode, 207, 128, 1, 3, // 1086: decode to VLUXSEG2EI32_V using decoder 3
1688 // 1086: }
1689 10, 7, // 1091: case 0xa: {
1690 OPC_CheckPredicate, 22, // 1093: check predicate 22
1691 OPC_Decode, 175, 128, 1, 4, // 1095: decode to VLSSEG2E32_V using decoder 4
1692 // 1095: }
1693 11, 6, // 1100: case 0xb: {
1694 OPC_CheckPredicate, 22, // 1102: check predicate 22
1695 OPC_Decode, 215, 127, 3, // 1104: decode to VLOXSEG2EI32_V using decoder 3
1696 // 1104: }
1697 16, 21, // 1108: case 0x10: {
1698 OPC_SwitchField, 20, 5, // 1110: switch Inst[24:20] {
1699 0, 7, // 1113: case 0x0: {
1700 OPC_CheckPredicate, 22, // 1115: check predicate 22
1701 OPC_Decode, 129, 128, 1, 1, // 1117: decode to VLSEG3E32_V using decoder 1
1702 // 1117: }
1703 16, 0, // 1122: case 0x10: {
1704 OPC_CheckPredicate, 22, // 1124: check predicate 22
1705 OPC_Decode, 128, 128, 1, 1, // 1126: decode to VLSEG3E32FF_V using decoder 1
1706 // 1126: }
1707 // 1126: } // switch Inst[24:20]
1708 // 1126: }
1709 17, 7, // 1131: case 0x11: {
1710 OPC_CheckPredicate, 22, // 1133: check predicate 22
1711 OPC_Decode, 211, 128, 1, 3, // 1135: decode to VLUXSEG3EI32_V using decoder 3
1712 // 1135: }
1713 18, 7, // 1140: case 0x12: {
1714 OPC_CheckPredicate, 22, // 1142: check predicate 22
1715 OPC_Decode, 179, 128, 1, 4, // 1144: decode to VLSSEG3E32_V using decoder 4
1716 // 1144: }
1717 19, 6, // 1149: case 0x13: {
1718 OPC_CheckPredicate, 22, // 1151: check predicate 22
1719 OPC_Decode, 219, 127, 3, // 1153: decode to VLOXSEG3EI32_V using decoder 3
1720 // 1153: }
1721 24, 33, // 1157: case 0x18: {
1722 OPC_SwitchField, 20, 5, // 1159: switch Inst[24:20] {
1723 0, 7, // 1162: case 0x0: {
1724 OPC_CheckPredicate, 22, // 1164: check predicate 22
1725 OPC_Decode, 137, 128, 1, 1, // 1166: decode to VLSEG4E32_V using decoder 1
1726 // 1166: }
1727 8, 10, // 1171: case 0x8: {
1728 OPC_CheckPredicate, 22, // 1173: check predicate 22
1729 OPC_CheckField, 25, 1, 1, // 1175: check Inst[25] == 0x1
1730 OPC_Decode, 194, 127, 6, // 1179: decode to VL4RE32_V using decoder 6
1731 // 1179: }
1732 16, 0, // 1183: case 0x10: {
1733 OPC_CheckPredicate, 22, // 1185: check predicate 22
1734 OPC_Decode, 136, 128, 1, 1, // 1187: decode to VLSEG4E32FF_V using decoder 1
1735 // 1187: }
1736 // 1187: } // switch Inst[24:20]
1737 // 1187: }
1738 25, 7, // 1192: case 0x19: {
1739 OPC_CheckPredicate, 22, // 1194: check predicate 22
1740 OPC_Decode, 215, 128, 1, 3, // 1196: decode to VLUXSEG4EI32_V using decoder 3
1741 // 1196: }
1742 26, 7, // 1201: case 0x1a: {
1743 OPC_CheckPredicate, 22, // 1203: check predicate 22
1744 OPC_Decode, 183, 128, 1, 4, // 1205: decode to VLSSEG4E32_V using decoder 4
1745 // 1205: }
1746 27, 6, // 1210: case 0x1b: {
1747 OPC_CheckPredicate, 22, // 1212: check predicate 22
1748 OPC_Decode, 223, 127, 3, // 1214: decode to VLOXSEG4EI32_V using decoder 3
1749 // 1214: }
1750 32, 21, // 1218: case 0x20: {
1751 OPC_SwitchField, 20, 5, // 1220: switch Inst[24:20] {
1752 0, 7, // 1223: case 0x0: {
1753 OPC_CheckPredicate, 22, // 1225: check predicate 22
1754 OPC_Decode, 145, 128, 1, 1, // 1227: decode to VLSEG5E32_V using decoder 1
1755 // 1227: }
1756 16, 0, // 1232: case 0x10: {
1757 OPC_CheckPredicate, 22, // 1234: check predicate 22
1758 OPC_Decode, 144, 128, 1, 1, // 1236: decode to VLSEG5E32FF_V using decoder 1
1759 // 1236: }
1760 // 1236: } // switch Inst[24:20]
1761 // 1236: }
1762 33, 7, // 1241: case 0x21: {
1763 OPC_CheckPredicate, 22, // 1243: check predicate 22
1764 OPC_Decode, 219, 128, 1, 3, // 1245: decode to VLUXSEG5EI32_V using decoder 3
1765 // 1245: }
1766 34, 7, // 1250: case 0x22: {
1767 OPC_CheckPredicate, 22, // 1252: check predicate 22
1768 OPC_Decode, 187, 128, 1, 4, // 1254: decode to VLSSEG5E32_V using decoder 4
1769 // 1254: }
1770 35, 6, // 1259: case 0x23: {
1771 OPC_CheckPredicate, 22, // 1261: check predicate 22
1772 OPC_Decode, 227, 127, 3, // 1263: decode to VLOXSEG5EI32_V using decoder 3
1773 // 1263: }
1774 40, 21, // 1267: case 0x28: {
1775 OPC_SwitchField, 20, 5, // 1269: switch Inst[24:20] {
1776 0, 7, // 1272: case 0x0: {
1777 OPC_CheckPredicate, 22, // 1274: check predicate 22
1778 OPC_Decode, 153, 128, 1, 1, // 1276: decode to VLSEG6E32_V using decoder 1
1779 // 1276: }
1780 16, 0, // 1281: case 0x10: {
1781 OPC_CheckPredicate, 22, // 1283: check predicate 22
1782 OPC_Decode, 152, 128, 1, 1, // 1285: decode to VLSEG6E32FF_V using decoder 1
1783 // 1285: }
1784 // 1285: } // switch Inst[24:20]
1785 // 1285: }
1786 41, 7, // 1290: case 0x29: {
1787 OPC_CheckPredicate, 22, // 1292: check predicate 22
1788 OPC_Decode, 223, 128, 1, 3, // 1294: decode to VLUXSEG6EI32_V using decoder 3
1789 // 1294: }
1790 42, 7, // 1299: case 0x2a: {
1791 OPC_CheckPredicate, 22, // 1301: check predicate 22
1792 OPC_Decode, 191, 128, 1, 4, // 1303: decode to VLSSEG6E32_V using decoder 4
1793 // 1303: }
1794 43, 6, // 1308: case 0x2b: {
1795 OPC_CheckPredicate, 22, // 1310: check predicate 22
1796 OPC_Decode, 231, 127, 3, // 1312: decode to VLOXSEG6EI32_V using decoder 3
1797 // 1312: }
1798 48, 21, // 1316: case 0x30: {
1799 OPC_SwitchField, 20, 5, // 1318: switch Inst[24:20] {
1800 0, 7, // 1321: case 0x0: {
1801 OPC_CheckPredicate, 22, // 1323: check predicate 22
1802 OPC_Decode, 161, 128, 1, 1, // 1325: decode to VLSEG7E32_V using decoder 1
1803 // 1325: }
1804 16, 0, // 1330: case 0x10: {
1805 OPC_CheckPredicate, 22, // 1332: check predicate 22
1806 OPC_Decode, 160, 128, 1, 1, // 1334: decode to VLSEG7E32FF_V using decoder 1
1807 // 1334: }
1808 // 1334: } // switch Inst[24:20]
1809 // 1334: }
1810 49, 7, // 1339: case 0x31: {
1811 OPC_CheckPredicate, 22, // 1341: check predicate 22
1812 OPC_Decode, 227, 128, 1, 3, // 1343: decode to VLUXSEG7EI32_V using decoder 3
1813 // 1343: }
1814 50, 7, // 1348: case 0x32: {
1815 OPC_CheckPredicate, 22, // 1350: check predicate 22
1816 OPC_Decode, 195, 128, 1, 4, // 1352: decode to VLSSEG7E32_V using decoder 4
1817 // 1352: }
1818 51, 6, // 1357: case 0x33: {
1819 OPC_CheckPredicate, 22, // 1359: check predicate 22
1820 OPC_Decode, 235, 127, 3, // 1361: decode to VLOXSEG7EI32_V using decoder 3
1821 // 1361: }
1822 56, 33, // 1365: case 0x38: {
1823 OPC_SwitchField, 20, 5, // 1367: switch Inst[24:20] {
1824 0, 7, // 1370: case 0x0: {
1825 OPC_CheckPredicate, 22, // 1372: check predicate 22
1826 OPC_Decode, 169, 128, 1, 1, // 1374: decode to VLSEG8E32_V using decoder 1
1827 // 1374: }
1828 8, 10, // 1379: case 0x8: {
1829 OPC_CheckPredicate, 22, // 1381: check predicate 22
1830 OPC_CheckField, 25, 1, 1, // 1383: check Inst[25] == 0x1
1831 OPC_Decode, 198, 127, 7, // 1387: decode to VL8RE32_V using decoder 7
1832 // 1387: }
1833 16, 0, // 1391: case 0x10: {
1834 OPC_CheckPredicate, 22, // 1393: check predicate 22
1835 OPC_Decode, 168, 128, 1, 1, // 1395: decode to VLSEG8E32FF_V using decoder 1
1836 // 1395: }
1837 // 1395: } // switch Inst[24:20]
1838 // 1395: }
1839 57, 7, // 1400: case 0x39: {
1840 OPC_CheckPredicate, 22, // 1402: check predicate 22
1841 OPC_Decode, 231, 128, 1, 3, // 1404: decode to VLUXSEG8EI32_V using decoder 3
1842 // 1404: }
1843 58, 7, // 1409: case 0x3a: {
1844 OPC_CheckPredicate, 22, // 1411: check predicate 22
1845 OPC_Decode, 199, 128, 1, 4, // 1413: decode to VLSSEG8E32_V using decoder 4
1846 // 1413: }
1847 59, 0, // 1418: case 0x3b: {
1848 OPC_CheckPredicate, 22, // 1420: check predicate 22
1849 OPC_Decode, 239, 127, 3, // 1422: decode to VLOXSEG8EI32_V using decoder 3
1850 // 1422: }
1851 // 1422: } // switch Inst[31:26]
1852 // 1422: }
1853 7, 0, // 1426: case 0x7: {
1854 OPC_SwitchField, 26, 3, // 1428: switch Inst[28:26] {
1855 0, 231, 1, // 1431: case 0x0: {
1856 OPC_SwitchField, 29, 3, // 1434: switch Inst[31:29] {
1857 0, 31, // 1437: case 0x0: {
1858 OPC_SwitchField, 20, 5, // 1439: switch Inst[24:20] {
1859 0, 6, // 1442: case 0x0: {
1860 OPC_CheckPredicate, 27, // 1444: check predicate 27
1861 OPC_Decode, 206, 127, 1, // 1446: decode to VLE64_V using decoder 1
1862 // 1446: }
1863 8, 10, // 1450: case 0x8: {
1864 OPC_CheckPredicate, 27, // 1452: check predicate 27
1865 OPC_CheckField, 25, 1, 1, // 1454: check Inst[25] == 0x1
1866 OPC_Decode, 187, 127, 2, // 1458: decode to VL1RE64_V using decoder 2
1867 // 1458: }
1868 16, 0, // 1462: case 0x10: {
1869 OPC_CheckPredicate, 27, // 1464: check predicate 27
1870 OPC_Decode, 205, 127, 1, // 1466: decode to VLE64FF_V using decoder 1
1871 // 1466: }
1872 // 1466: } // switch Inst[24:20]
1873 // 1466: }
1874 1, 31, // 1470: case 0x1: {
1875 OPC_SwitchField, 20, 5, // 1472: switch Inst[24:20] {
1876 0, 6, // 1475: case 0x0: {
1877 OPC_CheckPredicate, 27, // 1477: check predicate 27
1878 OPC_Decode, 251, 127, 1, // 1479: decode to VLSEG2E64_V using decoder 1
1879 // 1479: }
1880 8, 10, // 1483: case 0x8: {
1881 OPC_CheckPredicate, 27, // 1485: check predicate 27
1882 OPC_CheckField, 25, 1, 1, // 1487: check Inst[25] == 0x1
1883 OPC_Decode, 191, 127, 5, // 1491: decode to VL2RE64_V using decoder 5
1884 // 1491: }
1885 16, 0, // 1495: case 0x10: {
1886 OPC_CheckPredicate, 27, // 1497: check predicate 27
1887 OPC_Decode, 250, 127, 1, // 1499: decode to VLSEG2E64FF_V using decoder 1
1888 // 1499: }
1889 // 1499: } // switch Inst[24:20]
1890 // 1499: }
1891 2, 21, // 1503: case 0x2: {
1892 OPC_SwitchField, 20, 5, // 1505: switch Inst[24:20] {
1893 0, 7, // 1508: case 0x0: {
1894 OPC_CheckPredicate, 27, // 1510: check predicate 27
1895 OPC_Decode, 131, 128, 1, 1, // 1512: decode to VLSEG3E64_V using decoder 1
1896 // 1512: }
1897 16, 0, // 1517: case 0x10: {
1898 OPC_CheckPredicate, 27, // 1519: check predicate 27
1899 OPC_Decode, 130, 128, 1, 1, // 1521: decode to VLSEG3E64FF_V using decoder 1
1900 // 1521: }
1901 // 1521: } // switch Inst[24:20]
1902 // 1521: }
1903 3, 33, // 1526: case 0x3: {
1904 OPC_SwitchField, 20, 5, // 1528: switch Inst[24:20] {
1905 0, 7, // 1531: case 0x0: {
1906 OPC_CheckPredicate, 27, // 1533: check predicate 27
1907 OPC_Decode, 139, 128, 1, 1, // 1535: decode to VLSEG4E64_V using decoder 1
1908 // 1535: }
1909 8, 10, // 1540: case 0x8: {
1910 OPC_CheckPredicate, 27, // 1542: check predicate 27
1911 OPC_CheckField, 25, 1, 1, // 1544: check Inst[25] == 0x1
1912 OPC_Decode, 195, 127, 6, // 1548: decode to VL4RE64_V using decoder 6
1913 // 1548: }
1914 16, 0, // 1552: case 0x10: {
1915 OPC_CheckPredicate, 27, // 1554: check predicate 27
1916 OPC_Decode, 138, 128, 1, 1, // 1556: decode to VLSEG4E64FF_V using decoder 1
1917 // 1556: }
1918 // 1556: } // switch Inst[24:20]
1919 // 1556: }
1920 4, 21, // 1561: case 0x4: {
1921 OPC_SwitchField, 20, 5, // 1563: switch Inst[24:20] {
1922 0, 7, // 1566: case 0x0: {
1923 OPC_CheckPredicate, 27, // 1568: check predicate 27
1924 OPC_Decode, 147, 128, 1, 1, // 1570: decode to VLSEG5E64_V using decoder 1
1925 // 1570: }
1926 16, 0, // 1575: case 0x10: {
1927 OPC_CheckPredicate, 27, // 1577: check predicate 27
1928 OPC_Decode, 146, 128, 1, 1, // 1579: decode to VLSEG5E64FF_V using decoder 1
1929 // 1579: }
1930 // 1579: } // switch Inst[24:20]
1931 // 1579: }
1932 5, 21, // 1584: case 0x5: {
1933 OPC_SwitchField, 20, 5, // 1586: switch Inst[24:20] {
1934 0, 7, // 1589: case 0x0: {
1935 OPC_CheckPredicate, 27, // 1591: check predicate 27
1936 OPC_Decode, 155, 128, 1, 1, // 1593: decode to VLSEG6E64_V using decoder 1
1937 // 1593: }
1938 16, 0, // 1598: case 0x10: {
1939 OPC_CheckPredicate, 27, // 1600: check predicate 27
1940 OPC_Decode, 154, 128, 1, 1, // 1602: decode to VLSEG6E64FF_V using decoder 1
1941 // 1602: }
1942 // 1602: } // switch Inst[24:20]
1943 // 1602: }
1944 6, 21, // 1607: case 0x6: {
1945 OPC_SwitchField, 20, 5, // 1609: switch Inst[24:20] {
1946 0, 7, // 1612: case 0x0: {
1947 OPC_CheckPredicate, 27, // 1614: check predicate 27
1948 OPC_Decode, 163, 128, 1, 1, // 1616: decode to VLSEG7E64_V using decoder 1
1949 // 1616: }
1950 16, 0, // 1621: case 0x10: {
1951 OPC_CheckPredicate, 27, // 1623: check predicate 27
1952 OPC_Decode, 162, 128, 1, 1, // 1625: decode to VLSEG7E64FF_V using decoder 1
1953 // 1625: }
1954 // 1625: } // switch Inst[24:20]
1955 // 1625: }
1956 7, 0, // 1630: case 0x7: {
1957 OPC_SwitchField, 20, 5, // 1632: switch Inst[24:20] {
1958 0, 7, // 1635: case 0x0: {
1959 OPC_CheckPredicate, 27, // 1637: check predicate 27
1960 OPC_Decode, 171, 128, 1, 1, // 1639: decode to VLSEG8E64_V using decoder 1
1961 // 1639: }
1962 8, 10, // 1644: case 0x8: {
1963 OPC_CheckPredicate, 27, // 1646: check predicate 27
1964 OPC_CheckField, 25, 1, 1, // 1648: check Inst[25] == 0x1
1965 OPC_Decode, 199, 127, 7, // 1652: decode to VL8RE64_V using decoder 7
1966 // 1652: }
1967 16, 0, // 1656: case 0x10: {
1968 OPC_CheckPredicate, 27, // 1658: check predicate 27
1969 OPC_Decode, 170, 128, 1, 1, // 1660: decode to VLSEG8E64FF_V using decoder 1
1970 // 1660: }
1971 // 1660: } // switch Inst[24:20]
1972 // 1660: }
1973 // 1660: } // switch Inst[31:29]
1974 // 1660: }
1975 1, 75, // 1665: case 0x1: {
1976 OPC_SwitchField, 29, 3, // 1667: switch Inst[31:29] {
1977 0, 7, // 1670: case 0x0: {
1978 OPC_CheckPredicate, 28, // 1672: check predicate 28
1979 OPC_Decode, 204, 128, 1, 3, // 1674: decode to VLUXEI64_V using decoder 3
1980 // 1674: }
1981 1, 7, // 1679: case 0x1: {
1982 OPC_CheckPredicate, 29, // 1681: check predicate 29
1983 OPC_Decode, 208, 128, 1, 3, // 1683: decode to VLUXSEG2EI64_V using decoder 3
1984 // 1683: }
1985 2, 7, // 1688: case 0x2: {
1986 OPC_CheckPredicate, 29, // 1690: check predicate 29
1987 OPC_Decode, 212, 128, 1, 3, // 1692: decode to VLUXSEG3EI64_V using decoder 3
1988 // 1692: }
1989 3, 7, // 1697: case 0x3: {
1990 OPC_CheckPredicate, 29, // 1699: check predicate 29
1991 OPC_Decode, 216, 128, 1, 3, // 1701: decode to VLUXSEG4EI64_V using decoder 3
1992 // 1701: }
1993 4, 7, // 1706: case 0x4: {
1994 OPC_CheckPredicate, 29, // 1708: check predicate 29
1995 OPC_Decode, 220, 128, 1, 3, // 1710: decode to VLUXSEG5EI64_V using decoder 3
1996 // 1710: }
1997 5, 7, // 1715: case 0x5: {
1998 OPC_CheckPredicate, 29, // 1717: check predicate 29
1999 OPC_Decode, 224, 128, 1, 3, // 1719: decode to VLUXSEG6EI64_V using decoder 3
2000 // 1719: }
2001 6, 7, // 1724: case 0x6: {
2002 OPC_CheckPredicate, 29, // 1726: check predicate 29
2003 OPC_Decode, 228, 128, 1, 3, // 1728: decode to VLUXSEG7EI64_V using decoder 3
2004 // 1728: }
2005 7, 0, // 1733: case 0x7: {
2006 OPC_CheckPredicate, 29, // 1735: check predicate 29
2007 OPC_Decode, 232, 128, 1, 3, // 1737: decode to VLUXSEG8EI64_V using decoder 3
2008 // 1737: }
2009 // 1737: } // switch Inst[31:29]
2010 // 1737: }
2011 2, 74, // 1742: case 0x2: {
2012 OPC_SwitchField, 29, 3, // 1744: switch Inst[31:29] {
2013 0, 6, // 1747: case 0x0: {
2014 OPC_CheckPredicate, 27, // 1749: check predicate 27
2015 OPC_Decode, 244, 127, 4, // 1751: decode to VLSE64_V using decoder 4
2016 // 1751: }
2017 1, 7, // 1755: case 0x1: {
2018 OPC_CheckPredicate, 27, // 1757: check predicate 27
2019 OPC_Decode, 176, 128, 1, 4, // 1759: decode to VLSSEG2E64_V using decoder 4
2020 // 1759: }
2021 2, 7, // 1764: case 0x2: {
2022 OPC_CheckPredicate, 27, // 1766: check predicate 27
2023 OPC_Decode, 180, 128, 1, 4, // 1768: decode to VLSSEG3E64_V using decoder 4
2024 // 1768: }
2025 3, 7, // 1773: case 0x3: {
2026 OPC_CheckPredicate, 27, // 1775: check predicate 27
2027 OPC_Decode, 184, 128, 1, 4, // 1777: decode to VLSSEG4E64_V using decoder 4
2028 // 1777: }
2029 4, 7, // 1782: case 0x4: {
2030 OPC_CheckPredicate, 27, // 1784: check predicate 27
2031 OPC_Decode, 188, 128, 1, 4, // 1786: decode to VLSSEG5E64_V using decoder 4
2032 // 1786: }
2033 5, 7, // 1791: case 0x5: {
2034 OPC_CheckPredicate, 27, // 1793: check predicate 27
2035 OPC_Decode, 192, 128, 1, 4, // 1795: decode to VLSSEG6E64_V using decoder 4
2036 // 1795: }
2037 6, 7, // 1800: case 0x6: {
2038 OPC_CheckPredicate, 27, // 1802: check predicate 27
2039 OPC_Decode, 196, 128, 1, 4, // 1804: decode to VLSSEG7E64_V using decoder 4
2040 // 1804: }
2041 7, 0, // 1809: case 0x7: {
2042 OPC_CheckPredicate, 27, // 1811: check predicate 27
2043 OPC_Decode, 200, 128, 1, 4, // 1813: decode to VLSSEG8E64_V using decoder 4
2044 // 1813: }
2045 // 1813: } // switch Inst[31:29]
2046 // 1813: }
2047 3, 67, // 1818: case 0x3: {
2048 OPC_SwitchField, 29, 3, // 1820: switch Inst[31:29] {
2049 0, 6, // 1823: case 0x0: {
2050 OPC_CheckPredicate, 28, // 1825: check predicate 28
2051 OPC_Decode, 212, 127, 3, // 1827: decode to VLOXEI64_V using decoder 3
2052 // 1827: }
2053 1, 6, // 1831: case 0x1: {
2054 OPC_CheckPredicate, 29, // 1833: check predicate 29
2055 OPC_Decode, 216, 127, 3, // 1835: decode to VLOXSEG2EI64_V using decoder 3
2056 // 1835: }
2057 2, 6, // 1839: case 0x2: {
2058 OPC_CheckPredicate, 29, // 1841: check predicate 29
2059 OPC_Decode, 220, 127, 3, // 1843: decode to VLOXSEG3EI64_V using decoder 3
2060 // 1843: }
2061 3, 6, // 1847: case 0x3: {
2062 OPC_CheckPredicate, 29, // 1849: check predicate 29
2063 OPC_Decode, 224, 127, 3, // 1851: decode to VLOXSEG4EI64_V using decoder 3
2064 // 1851: }
2065 4, 6, // 1855: case 0x4: {
2066 OPC_CheckPredicate, 29, // 1857: check predicate 29
2067 OPC_Decode, 228, 127, 3, // 1859: decode to VLOXSEG5EI64_V using decoder 3
2068 // 1859: }
2069 5, 6, // 1863: case 0x5: {
2070 OPC_CheckPredicate, 29, // 1865: check predicate 29
2071 OPC_Decode, 232, 127, 3, // 1867: decode to VLOXSEG6EI64_V using decoder 3
2072 // 1867: }
2073 6, 6, // 1871: case 0x6: {
2074 OPC_CheckPredicate, 29, // 1873: check predicate 29
2075 OPC_Decode, 236, 127, 3, // 1875: decode to VLOXSEG7EI64_V using decoder 3
2076 // 1875: }
2077 7, 0, // 1879: case 0x7: {
2078 OPC_CheckPredicate, 29, // 1881: check predicate 29
2079 OPC_Decode, 240, 127, 3, // 1883: decode to VLOXSEG8EI64_V using decoder 3
2080 // 1883: }
2081 // 1883: } // switch Inst[31:29]
2082 // 1883: }
2083 4, 7, // 1887: case 0x4: {
2084 OPC_CheckPredicate, 30, // 1889: check predicate 30
2085 OPC_Decode, 195, 129, 1, 12, // 1891: decode to VMTL_V using decoder 12
2086 // 1891: }
2087 5, 0, // 1896: case 0x5: {
2088 OPC_CheckPredicate, 31, // 1898: check predicate 31
2089 OPC_Decode, 197, 129, 1, 12, // 1900: decode to VMTTL_V using decoder 12
2090 // 1900: }
2091 // 1900: } // switch Inst[28:26]
2092 // 1900: }
2093 // 1900: } // switch Inst[14:12]
2094 // 1900: }
2095 15, 76, // 1905: case 0xf: {
2096 OPC_SwitchField, 7, 8, // 1907: switch Inst[14:7] {
2097 0, 24, // 1910: case 0x0: {
2098 OPC_SwitchField, 28, 4, // 1912: switch Inst[31:28] {
2099 0, 8, // 1915: case 0x0: {
2100 OPC_CheckField, 15, 5, 0, // 1917: check Inst[19:15] == 0x0
2101 OPC_Decode, 248, 114, 13, // 1921: decode to FENCE using decoder 13
2102 // 1921: }
2103 8, 0, // 1925: case 0x8: {
2104 OPC_CheckField, 15, 13, 224, 12, // 1927: check Inst[27:15] == 0x660
2105 OPC_Decode, 250, 114, 14, // 1932: decode to FENCE_TSO using decoder 14
2106 // 1932: }
2107 // 1932: } // switch Inst[31:28]
2108 // 1932: }
2109 32, 8, // 1936: case 0x20: {
2110 OPC_CheckField, 15, 17, 0, // 1938: check Inst[31:15] == 0x0
2111 OPC_Decode, 249, 114, 14, // 1942: decode to FENCE_I using decoder 14
2112 // 1942: }
2113 64, 0, // 1946: case 0x40: {
2114 OPC_SwitchField, 20, 12, // 1948: switch Inst[31:20] {
2115 0, 6, // 1951: case 0x0: {
2116 OPC_CheckPredicate, 32, // 1953: check predicate 32
2117 OPC_Decode, 229, 110, 15, // 1955: decode to CBO_INVAL using decoder 15
2118 // 1955: }
2119 1, 6, // 1959: case 0x1: {
2120 OPC_CheckPredicate, 32, // 1961: check predicate 32
2121 OPC_Decode, 227, 110, 15, // 1963: decode to CBO_CLEAN using decoder 15
2122 // 1963: }
2123 2, 6, // 1967: case 0x2: {
2124 OPC_CheckPredicate, 32, // 1969: check predicate 32
2125 OPC_Decode, 228, 110, 15, // 1971: decode to CBO_FLUSH using decoder 15
2126 // 1971: }
2127 4, 0, // 1975: case 0x4: {
2128 OPC_CheckPredicate, 33, // 1977: check predicate 33
2129 OPC_Decode, 230, 110, 15, // 1979: decode to CBO_ZERO using decoder 15
2130 // 1979: }
2131 // 1979: } // switch Inst[31:20]
2132 // 1979: }
2133 // 1979: } // switch Inst[14:7]
2134 // 1979: }
2135 19, 149, 3, // 1983: case 0x13: {
2136 OPC_SwitchField, 12, 3, // 1986: switch Inst[14:12] {
2137 0, 4, // 1989: case 0x0: {
2138 OPC_Decode, 192, 107, 0, // 1991: decode to ADDI using decoder 0
2139 // 1991: }
2140 1, 217, 1, // 1995: case 0x1: {
2141 OPC_SwitchField, 26, 6, // 1998: switch Inst[31:26] {
2142 0, 4, // 2001: case 0x0: {
2143 OPC_Decode, 201, 124, 16, // 2003: decode to SLLI using decoder 16
2144 // 2003: }
2145 2, 11, // 2007: case 0x2: {
2146 OPC_CheckPredicate, 34, // 2009: check predicate 34
2147 OPC_CheckField, 20, 6, 15, // 2011: check Inst[25:20] == 0xf
2148 OPC_Decode, 175, 132, 1, 17, // 2015: decode to ZIP_RV32 using decoder 17
2149 // 2015: }
2150 4, 83, // 2020: case 0x4: {
2151 OPC_SwitchField, 20, 6, // 2022: switch Inst[25:20] {
2152 0, 6, // 2025: case 0x0: {
2153 OPC_CheckPredicate, 35, // 2027: check predicate 35
2154 OPC_Decode, 180, 124, 17, // 2029: decode to SHA256SUM0 using decoder 17
2155 // 2029: }
2156 1, 6, // 2033: case 0x1: {
2157 OPC_CheckPredicate, 35, // 2035: check predicate 35
2158 OPC_Decode, 181, 124, 17, // 2037: decode to SHA256SUM1 using decoder 17
2159 // 2037: }
2160 2, 6, // 2041: case 0x2: {
2161 OPC_CheckPredicate, 35, // 2043: check predicate 35
2162 OPC_Decode, 178, 124, 17, // 2045: decode to SHA256SIG0 using decoder 17
2163 // 2045: }
2164 3, 6, // 2049: case 0x3: {
2165 OPC_CheckPredicate, 35, // 2051: check predicate 35
2166 OPC_Decode, 179, 124, 17, // 2053: decode to SHA256SIG1 using decoder 17
2167 // 2053: }
2168 4, 6, // 2057: case 0x4: {
2169 OPC_CheckPredicate, 36, // 2059: check predicate 36
2170 OPC_Decode, 188, 124, 17, // 2061: decode to SHA512SUM0 using decoder 17
2171 // 2061: }
2172 5, 6, // 2065: case 0x5: {
2173 OPC_CheckPredicate, 36, // 2067: check predicate 36
2174 OPC_Decode, 190, 124, 17, // 2069: decode to SHA512SUM1 using decoder 17
2175 // 2069: }
2176 6, 6, // 2073: case 0x6: {
2177 OPC_CheckPredicate, 36, // 2075: check predicate 36
2178 OPC_Decode, 182, 124, 17, // 2077: decode to SHA512SIG0 using decoder 17
2179 // 2077: }
2180 7, 6, // 2081: case 0x7: {
2181 OPC_CheckPredicate, 36, // 2083: check predicate 36
2182 OPC_Decode, 185, 124, 17, // 2085: decode to SHA512SIG1 using decoder 17
2183 // 2085: }
2184 8, 6, // 2089: case 0x8: {
2185 OPC_CheckPredicate, 37, // 2091: check predicate 37
2186 OPC_Decode, 210, 124, 17, // 2093: decode to SM3P0 using decoder 17
2187 // 2093: }
2188 9, 0, // 2097: case 0x9: {
2189 OPC_CheckPredicate, 37, // 2099: check predicate 37
2190 OPC_Decode, 211, 124, 17, // 2101: decode to SM3P1 using decoder 17
2191 // 2101: }
2192 // 2101: } // switch Inst[25:20]
2193 // 2101: }
2194 10, 6, // 2105: case 0xa: {
2195 OPC_CheckPredicate, 38, // 2107: check predicate 38
2196 OPC_Decode, 226, 110, 16, // 2109: decode to BSETI using decoder 16
2197 // 2109: }
2198 12, 23, // 2113: case 0xc: {
2199 OPC_SwitchField, 24, 2, // 2115: switch Inst[25:24] {
2200 0, 10, // 2118: case 0x0: {
2201 OPC_CheckPredicate, 39, // 2120: check predicate 39
2202 OPC_CheckField, 20, 4, 0, // 2122: check Inst[23:20] == 0x0
2203 OPC_Decode, 204, 107, 17, // 2126: decode to AES64IM using decoder 17
2204 // 2126: }
2205 1, 0, // 2130: case 0x1: {
2206 OPC_CheckPredicate, 40, // 2132: check predicate 40
2207 OPC_Decode, 205, 107, 18, // 2134: decode to AES64KS1I using decoder 18
2208 // 2134: }
2209 // 2134: } // switch Inst[25:24]
2210 // 2134: }
2211 18, 6, // 2138: case 0x12: {
2212 OPC_CheckPredicate, 38, // 2140: check predicate 38
2213 OPC_Decode, 211, 110, 16, // 2142: decode to BCLRI using decoder 16
2214 // 2142: }
2215 24, 59, // 2146: case 0x18: {
2216 OPC_SwitchField, 20, 6, // 2148: switch Inst[25:20] {
2217 0, 6, // 2151: case 0x0: {
2218 OPC_CheckPredicate, 41, // 2153: check predicate 41
2219 OPC_Decode, 236, 110, 17, // 2155: decode to CLZ using decoder 17
2220 // 2155: }
2221 1, 6, // 2159: case 0x1: {
2222 OPC_CheckPredicate, 41, // 2161: check predicate 41
2223 OPC_Decode, 254, 110, 17, // 2163: decode to CTZ using decoder 17
2224 // 2163: }
2225 2, 6, // 2167: case 0x2: {
2226 OPC_CheckPredicate, 41, // 2169: check predicate 41
2227 OPC_Decode, 246, 110, 17, // 2171: decode to CPOP using decoder 17
2228 // 2171: }
2229 3, 6, // 2175: case 0x3: {
2230 OPC_CheckPredicate, 42, // 2177: check predicate 42
2231 OPC_Decode, 234, 110, 17, // 2179: decode to CLS using decoder 17
2232 // 2179: }
2233 4, 6, // 2183: case 0x4: {
2234 OPC_CheckPredicate, 41, // 2185: check predicate 41
2235 OPC_Decode, 225, 123, 17, // 2187: decode to SEXT_B using decoder 17
2236 // 2187: }
2237 5, 6, // 2191: case 0x5: {
2238 OPC_CheckPredicate, 41, // 2193: check predicate 41
2239 OPC_Decode, 226, 123, 17, // 2195: decode to SEXT_H using decoder 17
2240 // 2195: }
2241 7, 0, // 2199: case 0x7: {
2242 OPC_CheckPredicate, 42, // 2201: check predicate 42
2243 OPC_Decode, 188, 107, 17, // 2203: decode to ABS using decoder 17
2244 // 2203: }
2245 // 2203: } // switch Inst[25:20]
2246 // 2203: }
2247 26, 0, // 2207: case 0x1a: {
2248 OPC_CheckPredicate, 38, // 2209: check predicate 38
2249 OPC_Decode, 219, 110, 16, // 2211: decode to BINVI using decoder 16
2250 // 2211: }
2251 // 2211: } // switch Inst[31:26]
2252 // 2211: }
2253 2, 4, // 2215: case 0x2: {
2254 OPC_Decode, 206, 124, 0, // 2217: decode to SLTI using decoder 0
2255 // 2217: }
2256 3, 4, // 2221: case 0x3: {
2257 OPC_Decode, 207, 124, 0, // 2223: decode to SLTIU using decoder 0
2258 // 2223: }
2259 4, 5, // 2227: case 0x4: {
2260 OPC_Decode, 147, 132, 1, 0, // 2229: decode to XORI using decoder 0
2261 // 2229: }
2262 5, 108, // 2234: case 0x5: {
2263 OPC_SwitchField, 26, 6, // 2236: switch Inst[31:26] {
2264 0, 4, // 2239: case 0x0: {
2265 OPC_Decode, 238, 124, 16, // 2241: decode to SRLI using decoder 16
2266 // 2241: }
2267 2, 10, // 2245: case 0x2: {
2268 OPC_CheckPredicate, 34, // 2247: check predicate 34
2269 OPC_CheckField, 20, 6, 15, // 2249: check Inst[25:20] == 0xf
2270 OPC_Decode, 255, 125, 17, // 2253: decode to UNZIP_RV32 using decoder 17
2271 // 2253: }
2272 10, 10, // 2257: case 0xa: {
2273 OPC_CheckPredicate, 41, // 2259: check predicate 41
2274 OPC_CheckField, 20, 6, 7, // 2261: check Inst[25:20] == 0x7
2275 OPC_Decode, 194, 118, 17, // 2265: decode to ORC_B using decoder 17
2276 // 2265: }
2277 16, 4, // 2269: case 0x10: {
2278 OPC_Decode, 231, 124, 16, // 2271: decode to SRAI using decoder 16
2279 // 2271: }
2280 18, 6, // 2275: case 0x12: {
2281 OPC_CheckPredicate, 38, // 2277: check predicate 38
2282 OPC_Decode, 215, 110, 16, // 2279: decode to BEXTI using decoder 16
2283 // 2279: }
2284 24, 6, // 2283: case 0x18: {
2285 OPC_CheckPredicate, 43, // 2285: check predicate 43
2286 OPC_Decode, 200, 123, 16, // 2287: decode to RORI using decoder 16
2287 // 2287: }
2288 26, 0, // 2291: case 0x1a: {
2289 OPC_SwitchField, 20, 6, // 2293: switch Inst[25:20] {
2290 7, 6, // 2296: case 0x7: {
2291 OPC_CheckPredicate, 44, // 2298: check predicate 44
2292 OPC_Decode, 224, 110, 17, // 2300: decode to BREV8 using decoder 17
2293 // 2300: }
2294 24, 6, // 2304: case 0x18: {
2295 OPC_CheckPredicate, 45, // 2306: check predicate 45
2296 OPC_Decode, 193, 123, 17, // 2308: decode to REV8_RV32 using decoder 17
2297 // 2308: }
2298 31, 6, // 2312: case 0x1f: {
2299 OPC_CheckPredicate, 46, // 2314: check predicate 46
2300 OPC_Decode, 195, 123, 17, // 2316: decode to REV_RV32 using decoder 17
2301 // 2316: }
2302 48, 6, // 2320: case 0x30: {
2303 OPC_CheckPredicate, 47, // 2322: check predicate 47
2304 OPC_Decode, 192, 123, 17, // 2324: decode to REV16_RV64 using decoder 17
2305 // 2324: }
2306 56, 6, // 2328: case 0x38: {
2307 OPC_CheckPredicate, 48, // 2330: check predicate 48
2308 OPC_Decode, 194, 123, 17, // 2332: decode to REV8_RV64 using decoder 17
2309 // 2332: }
2310 63, 0, // 2336: case 0x3f: {
2311 OPC_CheckPredicate, 47, // 2338: check predicate 47
2312 OPC_Decode, 196, 123, 17, // 2340: decode to REV_RV64 using decoder 17
2313 // 2340: }
2314 // 2340: } // switch Inst[25:20]
2315 // 2340: }
2316 // 2340: } // switch Inst[31:26]
2317 // 2340: }
2318 6, 39, // 2344: case 0x6: {
2319 OPC_Scope, 33, // 2346: try {
2320 OPC_SwitchField, 20, 5, // 2348: switch Inst[24:20] {
2321 0, 8, // 2351: case 0x0: {
2322 OPC_CheckField, 7, 5, 0, // 2353: check Inst[11:7] == 0x0
2323 OPC_Decode, 247, 120, 19, // 2357: decode to PREFETCH_I using decoder 19
2324 // 2357: }
2325 1, 8, // 2361: case 0x1: {
2326 OPC_CheckField, 7, 5, 0, // 2363: check Inst[11:7] == 0x0
2327 OPC_Decode, 248, 120, 19, // 2367: decode to PREFETCH_R using decoder 19
2328 // 2367: }
2329 3, 0, // 2371: case 0x3: {
2330 OPC_CheckField, 7, 5, 0, // 2373: check Inst[11:7] == 0x0
2331 OPC_Decode, 249, 120, 19, // 2377: decode to PREFETCH_W using decoder 19
2332 // 2377: }
2333 // 2377: } // switch Inst[24:20]
2334 // 2377: } else try {
2335 OPC_Decode, 195, 118, 0, // 2381: decode to ORI using decoder 0
2336 // 2381: }
2337 // 2381: }
2338 7, 0, // 2385: case 0x7: {
2339 OPC_Decode, 205, 110, 0, // 2387: decode to ANDI using decoder 0
2340 // 2387: }
2341 // 2387: } // switch Inst[14:12]
2342 // 2387: }
2343 23, 4, // 2391: case 0x17: {
2344 OPC_Decode, 209, 110, 20, // 2393: decode to AUIPC using decoder 20
2345 // 2393: }
2346 27, 195, 35, // 2397: case 0x1b: {
2347 OPC_SwitchField, 12, 3, // 2400: switch Inst[14:12] {
2348 0, 6, // 2403: case 0x0: {
2349 OPC_CheckPredicate, 21, // 2405: check predicate 21
2350 OPC_Decode, 193, 107, 0, // 2407: decode to ADDIW using decoder 0
2351 // 2407: }
2352 1, 68, // 2411: case 0x1: {
2353 OPC_SwitchField, 26, 6, // 2413: switch Inst[31:26] {
2354 0, 10, // 2416: case 0x0: {
2355 OPC_CheckPredicate, 21, // 2418: check predicate 21
2356 OPC_CheckField, 25, 1, 0, // 2420: check Inst[25] == 0x0
2357 OPC_Decode, 202, 124, 21, // 2424: decode to SLLIW using decoder 21
2358 // 2424: }
2359 2, 6, // 2428: case 0x2: {
2360 OPC_CheckPredicate, 49, // 2430: check predicate 49
2361 OPC_Decode, 203, 124, 16, // 2432: decode to SLLI_UW using decoder 16
2362 // 2432: }
2363 24, 0, // 2436: case 0x18: {
2364 OPC_SwitchField, 20, 6, // 2438: switch Inst[25:20] {
2365 0, 6, // 2441: case 0x0: {
2366 OPC_CheckPredicate, 50, // 2443: check predicate 50
2367 OPC_Decode, 237, 110, 17, // 2445: decode to CLZW using decoder 17
2368 // 2445: }
2369 1, 6, // 2449: case 0x1: {
2370 OPC_CheckPredicate, 50, // 2451: check predicate 50
2371 OPC_Decode, 255, 110, 17, // 2453: decode to CTZW using decoder 17
2372 // 2453: }
2373 2, 6, // 2457: case 0x2: {
2374 OPC_CheckPredicate, 50, // 2459: check predicate 50
2375 OPC_Decode, 247, 110, 17, // 2461: decode to CPOPW using decoder 17
2376 // 2461: }
2377 3, 6, // 2465: case 0x3: {
2378 OPC_CheckPredicate, 47, // 2467: check predicate 47
2379 OPC_Decode, 235, 110, 17, // 2469: decode to CLSW using decoder 17
2380 // 2469: }
2381 7, 0, // 2473: case 0x7: {
2382 OPC_CheckPredicate, 47, // 2475: check predicate 47
2383 OPC_Decode, 189, 107, 17, // 2477: decode to ABSW using decoder 17
2384 // 2477: }
2385 // 2477: } // switch Inst[25:20]
2386 // 2477: }
2387 // 2477: } // switch Inst[31:26]
2388 // 2477: }
2389 2, 209, 10, // 2481: case 0x2: {
2390 OPC_SwitchField, 26, 6, // 2484: switch Inst[31:26] {
2391 0, 50, // 2487: case 0x0: {
2392 OPC_SwitchField, 7, 1, // 2489: switch Inst[7] {
2393 0, 23, // 2492: case 0x0: {
2394 OPC_SwitchField, 25, 1, // 2494: switch Inst[25] {
2395 0, 10, // 2497: case 0x0: {
2396 OPC_CheckPredicate, 46, // 2499: check predicate 46
2397 OPC_CheckField, 24, 1, 1, // 2501: check Inst[24] == 0x1
2398 OPC_Decode, 140, 122, 22, // 2505: decode to PWSLLI_B using decoder 22
2399 // 2505: }
2400 1, 0, // 2509: case 0x1: {
2401 OPC_CheckPredicate, 46, // 2511: check predicate 46
2402 OPC_Decode, 141, 122, 23, // 2513: decode to PWSLLI_H using decoder 23
2403 // 2513: }
2404 // 2513: } // switch Inst[25]
2405 // 2513: }
2406 1, 0, // 2517: case 0x1: {
2407 OPC_SwitchField, 25, 1, // 2519: switch Inst[25] {
2408 0, 6, // 2522: case 0x0: {
2409 OPC_CheckPredicate, 46, // 2524: check predicate 46
2410 OPC_Decode, 254, 121, 24, // 2526: decode to PWADD_H using decoder 24
2411 // 2526: }
2412 1, 0, // 2530: case 0x1: {
2413 OPC_CheckPredicate, 46, // 2532: check predicate 46
2414 OPC_Decode, 250, 131, 1, 24, // 2534: decode to WADD using decoder 24
2415 // 2534: }
2416 // 2534: } // switch Inst[25]
2417 // 2534: }
2418 // 2534: } // switch Inst[7]
2419 // 2534: }
2420 1, 33, // 2539: case 0x1: {
2421 OPC_SwitchField, 7, 1, // 2541: switch Inst[7] {
2422 0, 7, // 2544: case 0x0: {
2423 OPC_CheckPredicate, 46, // 2546: check predicate 46
2424 OPC_Decode, 138, 132, 1, 25, // 2548: decode to WSLLI using decoder 25
2425 // 2548: }
2426 1, 0, // 2553: case 0x1: {
2427 OPC_SwitchField, 25, 1, // 2555: switch Inst[25] {
2428 0, 6, // 2558: case 0x0: {
2429 OPC_CheckPredicate, 46, // 2560: check predicate 46
2430 OPC_Decode, 253, 121, 24, // 2562: decode to PWADD_B using decoder 24
2431 // 2562: }
2432 1, 0, // 2566: case 0x1: {
2433 OPC_CheckPredicate, 46, // 2568: check predicate 46
2434 OPC_Decode, 168, 119, 24, // 2570: decode to PM2WADD_H using decoder 24
2435 // 2570: }
2436 // 2570: } // switch Inst[25]
2437 // 2570: }
2438 // 2570: } // switch Inst[7]
2439 // 2570: }
2440 2, 46, // 2574: case 0x2: {
2441 OPC_SwitchField, 7, 1, // 2576: switch Inst[7] {
2442 0, 19, // 2579: case 0x0: {
2443 OPC_SwitchField, 25, 1, // 2581: switch Inst[25] {
2444 0, 6, // 2584: case 0x0: {
2445 OPC_CheckPredicate, 46, // 2586: check predicate 46
2446 OPC_Decode, 142, 122, 24, // 2588: decode to PWSLL_BS using decoder 24
2447 // 2588: }
2448 1, 0, // 2592: case 0x1: {
2449 OPC_CheckPredicate, 46, // 2594: check predicate 46
2450 OPC_Decode, 143, 122, 24, // 2596: decode to PWSLL_HS using decoder 24
2451 // 2596: }
2452 // 2596: } // switch Inst[25]
2453 // 2596: }
2454 1, 0, // 2600: case 0x1: {
2455 OPC_SwitchField, 25, 1, // 2602: switch Inst[25] {
2456 0, 6, // 2605: case 0x0: {
2457 OPC_CheckPredicate, 46, // 2607: check predicate 46
2458 OPC_Decode, 250, 121, 26, // 2609: decode to PWADDA_H using decoder 26
2459 // 2609: }
2460 1, 0, // 2613: case 0x1: {
2461 OPC_CheckPredicate, 46, // 2615: check predicate 46
2462 OPC_Decode, 251, 131, 1, 26, // 2617: decode to WADDA using decoder 26
2463 // 2617: }
2464 // 2617: } // switch Inst[25]
2465 // 2617: }
2466 // 2617: } // switch Inst[7]
2467 // 2617: }
2468 3, 37, // 2622: case 0x3: {
2469 OPC_SwitchField, 7, 1, // 2624: switch Inst[7] {
2470 0, 11, // 2627: case 0x0: {
2471 OPC_CheckPredicate, 46, // 2629: check predicate 46
2472 OPC_CheckField, 25, 1, 1, // 2631: check Inst[25] == 0x1
2473 OPC_Decode, 137, 132, 1, 24, // 2635: decode to WSLL using decoder 24
2474 // 2635: }
2475 1, 0, // 2640: case 0x1: {
2476 OPC_SwitchField, 25, 1, // 2642: switch Inst[25] {
2477 0, 6, // 2645: case 0x0: {
2478 OPC_CheckPredicate, 46, // 2647: check predicate 46
2479 OPC_Decode, 249, 121, 26, // 2649: decode to PWADDA_B using decoder 26
2480 // 2649: }
2481 1, 0, // 2653: case 0x1: {
2482 OPC_CheckPredicate, 46, // 2655: check predicate 46
2483 OPC_Decode, 164, 119, 26, // 2657: decode to PM2WADDA_H using decoder 26
2484 // 2657: }
2485 // 2657: } // switch Inst[25]
2486 // 2657: }
2487 // 2657: } // switch Inst[7]
2488 // 2657: }
2489 4, 28, // 2661: case 0x4: {
2490 OPC_SwitchField, 25, 1, // 2663: switch Inst[25] {
2491 0, 10, // 2666: case 0x0: {
2492 OPC_CheckPredicate, 46, // 2668: check predicate 46
2493 OPC_CheckField, 7, 1, 1, // 2670: check Inst[7] == 0x1
2494 OPC_Decode, 252, 121, 24, // 2674: decode to PWADDU_H using decoder 24
2495 // 2674: }
2496 1, 0, // 2678: case 0x1: {
2497 OPC_CheckPredicate, 46, // 2680: check predicate 46
2498 OPC_CheckField, 7, 1, 1, // 2682: check Inst[7] == 0x1
2499 OPC_Decode, 253, 131, 1, 24, // 2686: decode to WADDU using decoder 24
2500 // 2686: }
2501 // 2686: } // switch Inst[25]
2502 // 2686: }
2503 5, 27, // 2691: case 0x5: {
2504 OPC_SwitchField, 25, 1, // 2693: switch Inst[25] {
2505 0, 10, // 2696: case 0x0: {
2506 OPC_CheckPredicate, 46, // 2698: check predicate 46
2507 OPC_CheckField, 7, 1, 1, // 2700: check Inst[7] == 0x1
2508 OPC_Decode, 251, 121, 24, // 2704: decode to PWADDU_B using decoder 24
2509 // 2704: }
2510 1, 0, // 2708: case 0x1: {
2511 OPC_CheckPredicate, 46, // 2710: check predicate 46
2512 OPC_CheckField, 7, 1, 1, // 2712: check Inst[7] == 0x1
2513 OPC_Decode, 169, 119, 24, // 2716: decode to PM2WADD_HX using decoder 24
2514 // 2716: }
2515 // 2716: } // switch Inst[25]
2516 // 2716: }
2517 6, 28, // 2720: case 0x6: {
2518 OPC_SwitchField, 25, 1, // 2722: switch Inst[25] {
2519 0, 10, // 2725: case 0x0: {
2520 OPC_CheckPredicate, 46, // 2727: check predicate 46
2521 OPC_CheckField, 7, 1, 1, // 2729: check Inst[7] == 0x1
2522 OPC_Decode, 248, 121, 26, // 2733: decode to PWADDAU_H using decoder 26
2523 // 2733: }
2524 1, 0, // 2737: case 0x1: {
2525 OPC_CheckPredicate, 46, // 2739: check predicate 46
2526 OPC_CheckField, 7, 1, 1, // 2741: check Inst[7] == 0x1
2527 OPC_Decode, 252, 131, 1, 26, // 2745: decode to WADDAU using decoder 26
2528 // 2745: }
2529 // 2745: } // switch Inst[25]
2530 // 2745: }
2531 7, 27, // 2750: case 0x7: {
2532 OPC_SwitchField, 25, 1, // 2752: switch Inst[25] {
2533 0, 10, // 2755: case 0x0: {
2534 OPC_CheckPredicate, 46, // 2757: check predicate 46
2535 OPC_CheckField, 7, 1, 1, // 2759: check Inst[7] == 0x1
2536 OPC_Decode, 247, 121, 26, // 2763: decode to PWADDAU_B using decoder 26
2537 // 2763: }
2538 1, 0, // 2767: case 0x1: {
2539 OPC_CheckPredicate, 46, // 2769: check predicate 46
2540 OPC_CheckField, 7, 1, 1, // 2771: check Inst[7] == 0x1
2541 OPC_Decode, 165, 119, 26, // 2775: decode to PM2WADDA_HX using decoder 26
2542 // 2775: }
2543 // 2775: } // switch Inst[25]
2544 // 2775: }
2545 8, 28, // 2779: case 0x8: {
2546 OPC_SwitchField, 25, 1, // 2781: switch Inst[25] {
2547 0, 10, // 2784: case 0x0: {
2548 OPC_CheckPredicate, 46, // 2786: check predicate 46
2549 OPC_CheckField, 7, 1, 1, // 2788: check Inst[7] == 0x1
2550 OPC_Decode, 135, 122, 24, // 2792: decode to PWMUL_H using decoder 24
2551 // 2792: }
2552 1, 0, // 2796: case 0x1: {
2553 OPC_CheckPredicate, 46, // 2798: check predicate 46
2554 OPC_CheckField, 7, 1, 1, // 2800: check Inst[7] == 0x1
2555 OPC_Decode, 130, 132, 1, 24, // 2804: decode to WMUL using decoder 24
2556 // 2804: }
2557 // 2804: } // switch Inst[25]
2558 // 2804: }
2559 9, 27, // 2809: case 0x9: {
2560 OPC_SwitchField, 25, 1, // 2811: switch Inst[25] {
2561 0, 10, // 2814: case 0x0: {
2562 OPC_CheckPredicate, 46, // 2816: check predicate 46
2563 OPC_CheckField, 7, 1, 1, // 2818: check Inst[7] == 0x1
2564 OPC_Decode, 134, 122, 24, // 2822: decode to PWMUL_B using decoder 24
2565 // 2822: }
2566 1, 0, // 2826: case 0x1: {
2567 OPC_CheckPredicate, 46, // 2828: check predicate 46
2568 OPC_CheckField, 7, 1, 1, // 2830: check Inst[7] == 0x1
2569 OPC_Decode, 167, 119, 24, // 2834: decode to PM2WADDU_H using decoder 24
2570 // 2834: }
2571 // 2834: } // switch Inst[25]
2572 // 2834: }
2573 10, 28, // 2838: case 0xa: {
2574 OPC_SwitchField, 25, 1, // 2840: switch Inst[25] {
2575 0, 10, // 2843: case 0x0: {
2576 OPC_CheckPredicate, 46, // 2845: check predicate 46
2577 OPC_CheckField, 7, 1, 1, // 2847: check Inst[7] == 0x1
2578 OPC_Decode, 129, 122, 26, // 2851: decode to PWMACC_H using decoder 26
2579 // 2851: }
2580 1, 0, // 2855: case 0x1: {
2581 OPC_CheckPredicate, 46, // 2857: check predicate 46
2582 OPC_CheckField, 7, 1, 1, // 2859: check Inst[7] == 0x1
2583 OPC_Decode, 255, 131, 1, 26, // 2863: decode to WMACC using decoder 26
2584 // 2863: }
2585 // 2863: } // switch Inst[25]
2586 // 2863: }
2587 11, 14, // 2868: case 0xb: {
2588 OPC_CheckPredicate, 46, // 2870: check predicate 46
2589 OPC_CheckField, 25, 1, 1, // 2872: check Inst[25] == 0x1
2590 OPC_CheckField, 7, 1, 1, // 2876: check Inst[7] == 0x1
2591 OPC_Decode, 163, 119, 26, // 2880: decode to PM2WADDAU_H using decoder 26
2592 // 2880: }
2593 12, 37, // 2884: case 0xc: {
2594 OPC_SwitchField, 7, 1, // 2886: switch Inst[7] {
2595 0, 10, // 2889: case 0x0: {
2596 OPC_CheckPredicate, 46, // 2891: check predicate 46
2597 OPC_CheckField, 25, 1, 0, // 2893: check Inst[25] == 0x0
2598 OPC_Decode, 130, 119, 27, // 2897: decode to PLI_DH using decoder 27
2599 // 2897: }
2600 1, 0, // 2901: case 0x1: {
2601 OPC_SwitchField, 25, 1, // 2903: switch Inst[25] {
2602 0, 6, // 2906: case 0x0: {
2603 OPC_CheckPredicate, 46, // 2908: check predicate 46
2604 OPC_Decode, 133, 122, 24, // 2910: decode to PWMULU_H using decoder 24
2605 // 2910: }
2606 1, 0, // 2914: case 0x1: {
2607 OPC_CheckPredicate, 46, // 2916: check predicate 46
2608 OPC_Decode, 132, 132, 1, 24, // 2918: decode to WMULU using decoder 24
2609 // 2918: }
2610 // 2918: } // switch Inst[25]
2611 // 2918: }
2612 // 2918: } // switch Inst[7]
2613 // 2918: }
2614 13, 31, // 2923: case 0xd: {
2615 OPC_SwitchField, 7, 1, // 2925: switch Inst[7] {
2616 0, 14, // 2928: case 0x0: {
2617 OPC_CheckPredicate, 46, // 2930: check predicate 46
2618 OPC_CheckField, 24, 2, 0, // 2932: check Inst[25:24] == 0x0
2619 OPC_CheckField, 15, 1, 0, // 2936: check Inst[15] == 0x0
2620 OPC_Decode, 129, 119, 28, // 2940: decode to PLI_DB using decoder 28
2621 // 2940: }
2622 1, 0, // 2944: case 0x1: {
2623 OPC_CheckPredicate, 46, // 2946: check predicate 46
2624 OPC_CheckField, 25, 1, 0, // 2948: check Inst[25] == 0x0
2625 OPC_Decode, 132, 122, 24, // 2952: decode to PWMULU_B using decoder 24
2626 // 2952: }
2627 // 2952: } // switch Inst[7]
2628 // 2952: }
2629 14, 28, // 2956: case 0xe: {
2630 OPC_SwitchField, 25, 1, // 2958: switch Inst[25] {
2631 0, 10, // 2961: case 0x0: {
2632 OPC_CheckPredicate, 46, // 2963: check predicate 46
2633 OPC_CheckField, 7, 1, 1, // 2965: check Inst[7] == 0x1
2634 OPC_Decode, 128, 122, 26, // 2969: decode to PWMACCU_H using decoder 26
2635 // 2969: }
2636 1, 0, // 2973: case 0x1: {
2637 OPC_CheckPredicate, 46, // 2975: check predicate 46
2638 OPC_CheckField, 7, 1, 1, // 2977: check Inst[7] == 0x1
2639 OPC_Decode, 129, 132, 1, 26, // 2981: decode to WMACCU using decoder 26
2640 // 2981: }
2641 // 2981: } // switch Inst[25]
2642 // 2981: }
2643 16, 50, // 2986: case 0x10: {
2644 OPC_SwitchField, 7, 1, // 2988: switch Inst[7] {
2645 0, 23, // 2991: case 0x0: {
2646 OPC_SwitchField, 25, 1, // 2993: switch Inst[25] {
2647 0, 10, // 2996: case 0x0: {
2648 OPC_CheckPredicate, 46, // 2998: check predicate 46
2649 OPC_CheckField, 24, 1, 1, // 3000: check Inst[24] == 0x1
2650 OPC_Decode, 136, 122, 22, // 3004: decode to PWSLAI_B using decoder 22
2651 // 3004: }
2652 1, 0, // 3008: case 0x1: {
2653 OPC_CheckPredicate, 46, // 3010: check predicate 46
2654 OPC_Decode, 137, 122, 23, // 3012: decode to PWSLAI_H using decoder 23
2655 // 3012: }
2656 // 3012: } // switch Inst[25]
2657 // 3012: }
2658 1, 0, // 3016: case 0x1: {
2659 OPC_SwitchField, 25, 1, // 3018: switch Inst[25] {
2660 0, 6, // 3021: case 0x0: {
2661 OPC_CheckPredicate, 46, // 3023: check predicate 46
2662 OPC_Decode, 151, 122, 24, // 3025: decode to PWSUB_H using decoder 24
2663 // 3025: }
2664 1, 0, // 3029: case 0x1: {
2665 OPC_CheckPredicate, 46, // 3031: check predicate 46
2666 OPC_Decode, 139, 132, 1, 24, // 3033: decode to WSUB using decoder 24
2667 // 3033: }
2668 // 3033: } // switch Inst[25]
2669 // 3033: }
2670 // 3033: } // switch Inst[7]
2671 // 3033: }
2672 17, 33, // 3038: case 0x11: {
2673 OPC_SwitchField, 7, 1, // 3040: switch Inst[7] {
2674 0, 7, // 3043: case 0x0: {
2675 OPC_CheckPredicate, 46, // 3045: check predicate 46
2676 OPC_Decode, 136, 132, 1, 25, // 3047: decode to WSLAI using decoder 25
2677 // 3047: }
2678 1, 0, // 3052: case 0x1: {
2679 OPC_SwitchField, 25, 1, // 3054: switch Inst[25] {
2680 0, 6, // 3057: case 0x0: {
2681 OPC_CheckPredicate, 46, // 3059: check predicate 46
2682 OPC_Decode, 150, 122, 24, // 3061: decode to PWSUB_B using decoder 24
2683 // 3061: }
2684 1, 0, // 3065: case 0x1: {
2685 OPC_CheckPredicate, 46, // 3067: check predicate 46
2686 OPC_Decode, 172, 119, 24, // 3069: decode to PM2WSUB_H using decoder 24
2687 // 3069: }
2688 // 3069: } // switch Inst[25]
2689 // 3069: }
2690 // 3069: } // switch Inst[7]
2691 // 3069: }
2692 18, 46, // 3073: case 0x12: {
2693 OPC_SwitchField, 7, 1, // 3075: switch Inst[7] {
2694 0, 19, // 3078: case 0x0: {
2695 OPC_SwitchField, 25, 1, // 3080: switch Inst[25] {
2696 0, 6, // 3083: case 0x0: {
2697 OPC_CheckPredicate, 46, // 3085: check predicate 46
2698 OPC_Decode, 138, 122, 24, // 3087: decode to PWSLA_BS using decoder 24
2699 // 3087: }
2700 1, 0, // 3091: case 0x1: {
2701 OPC_CheckPredicate, 46, // 3093: check predicate 46
2702 OPC_Decode, 139, 122, 24, // 3095: decode to PWSLA_HS using decoder 24
2703 // 3095: }
2704 // 3095: } // switch Inst[25]
2705 // 3095: }
2706 1, 0, // 3099: case 0x1: {
2707 OPC_SwitchField, 25, 1, // 3101: switch Inst[25] {
2708 0, 6, // 3104: case 0x0: {
2709 OPC_CheckPredicate, 46, // 3106: check predicate 46
2710 OPC_Decode, 147, 122, 26, // 3108: decode to PWSUBA_H using decoder 26
2711 // 3108: }
2712 1, 0, // 3112: case 0x1: {
2713 OPC_CheckPredicate, 46, // 3114: check predicate 46
2714 OPC_Decode, 140, 132, 1, 26, // 3116: decode to WSUBA using decoder 26
2715 // 3116: }
2716 // 3116: } // switch Inst[25]
2717 // 3116: }
2718 // 3116: } // switch Inst[7]
2719 // 3116: }
2720 19, 37, // 3121: case 0x13: {
2721 OPC_SwitchField, 7, 1, // 3123: switch Inst[7] {
2722 0, 11, // 3126: case 0x0: {
2723 OPC_CheckPredicate, 46, // 3128: check predicate 46
2724 OPC_CheckField, 25, 1, 1, // 3130: check Inst[25] == 0x1
2725 OPC_Decode, 135, 132, 1, 24, // 3134: decode to WSLA using decoder 24
2726 // 3134: }
2727 1, 0, // 3139: case 0x1: {
2728 OPC_SwitchField, 25, 1, // 3141: switch Inst[25] {
2729 0, 6, // 3144: case 0x0: {
2730 OPC_CheckPredicate, 46, // 3146: check predicate 46
2731 OPC_Decode, 146, 122, 26, // 3148: decode to PWSUBA_B using decoder 26
2732 // 3148: }
2733 1, 0, // 3152: case 0x1: {
2734 OPC_CheckPredicate, 46, // 3154: check predicate 46
2735 OPC_Decode, 170, 119, 26, // 3156: decode to PM2WSUBA_H using decoder 26
2736 // 3156: }
2737 // 3156: } // switch Inst[25]
2738 // 3156: }
2739 // 3156: } // switch Inst[7]
2740 // 3156: }
2741 20, 28, // 3160: case 0x14: {
2742 OPC_SwitchField, 25, 1, // 3162: switch Inst[25] {
2743 0, 10, // 3165: case 0x0: {
2744 OPC_CheckPredicate, 46, // 3167: check predicate 46
2745 OPC_CheckField, 7, 1, 1, // 3169: check Inst[7] == 0x1
2746 OPC_Decode, 149, 122, 24, // 3173: decode to PWSUBU_H using decoder 24
2747 // 3173: }
2748 1, 0, // 3177: case 0x1: {
2749 OPC_CheckPredicate, 46, // 3179: check predicate 46
2750 OPC_CheckField, 7, 1, 1, // 3181: check Inst[7] == 0x1
2751 OPC_Decode, 142, 132, 1, 24, // 3185: decode to WSUBU using decoder 24
2752 // 3185: }
2753 // 3185: } // switch Inst[25]
2754 // 3185: }
2755 21, 27, // 3190: case 0x15: {
2756 OPC_SwitchField, 25, 1, // 3192: switch Inst[25] {
2757 0, 10, // 3195: case 0x0: {
2758 OPC_CheckPredicate, 46, // 3197: check predicate 46
2759 OPC_CheckField, 7, 1, 1, // 3199: check Inst[7] == 0x1
2760 OPC_Decode, 148, 122, 24, // 3203: decode to PWSUBU_B using decoder 24
2761 // 3203: }
2762 1, 0, // 3207: case 0x1: {
2763 OPC_CheckPredicate, 46, // 3209: check predicate 46
2764 OPC_CheckField, 7, 1, 1, // 3211: check Inst[7] == 0x1
2765 OPC_Decode, 173, 119, 24, // 3215: decode to PM2WSUB_HX using decoder 24
2766 // 3215: }
2767 // 3215: } // switch Inst[25]
2768 // 3215: }
2769 22, 28, // 3219: case 0x16: {
2770 OPC_SwitchField, 25, 1, // 3221: switch Inst[25] {
2771 0, 10, // 3224: case 0x0: {
2772 OPC_CheckPredicate, 46, // 3226: check predicate 46
2773 OPC_CheckField, 7, 1, 1, // 3228: check Inst[7] == 0x1
2774 OPC_Decode, 145, 122, 26, // 3232: decode to PWSUBAU_H using decoder 26
2775 // 3232: }
2776 1, 0, // 3236: case 0x1: {
2777 OPC_CheckPredicate, 46, // 3238: check predicate 46
2778 OPC_CheckField, 7, 1, 1, // 3240: check Inst[7] == 0x1
2779 OPC_Decode, 141, 132, 1, 26, // 3244: decode to WSUBAU using decoder 26
2780 // 3244: }
2781 // 3244: } // switch Inst[25]
2782 // 3244: }
2783 23, 27, // 3249: case 0x17: {
2784 OPC_SwitchField, 25, 1, // 3251: switch Inst[25] {
2785 0, 10, // 3254: case 0x0: {
2786 OPC_CheckPredicate, 46, // 3256: check predicate 46
2787 OPC_CheckField, 7, 1, 1, // 3258: check Inst[7] == 0x1
2788 OPC_Decode, 144, 122, 26, // 3262: decode to PWSUBAU_B using decoder 26
2789 // 3262: }
2790 1, 0, // 3266: case 0x1: {
2791 OPC_CheckPredicate, 46, // 3268: check predicate 46
2792 OPC_CheckField, 7, 1, 1, // 3270: check Inst[7] == 0x1
2793 OPC_Decode, 171, 119, 26, // 3274: decode to PM2WSUBA_HX using decoder 26
2794 // 3274: }
2795 // 3274: } // switch Inst[25]
2796 // 3274: }
2797 24, 28, // 3278: case 0x18: {
2798 OPC_SwitchField, 25, 1, // 3280: switch Inst[25] {
2799 0, 10, // 3283: case 0x0: {
2800 OPC_CheckPredicate, 46, // 3285: check predicate 46
2801 OPC_CheckField, 7, 1, 1, // 3287: check Inst[7] == 0x1
2802 OPC_Decode, 131, 122, 24, // 3291: decode to PWMULSU_H using decoder 24
2803 // 3291: }
2804 1, 0, // 3295: case 0x1: {
2805 OPC_CheckPredicate, 46, // 3297: check predicate 46
2806 OPC_CheckField, 7, 1, 1, // 3299: check Inst[7] == 0x1
2807 OPC_Decode, 131, 132, 1, 24, // 3303: decode to WMULSU using decoder 24
2808 // 3303: }
2809 // 3303: } // switch Inst[25]
2810 // 3303: }
2811 25, 27, // 3308: case 0x19: {
2812 OPC_SwitchField, 25, 1, // 3310: switch Inst[25] {
2813 0, 10, // 3313: case 0x0: {
2814 OPC_CheckPredicate, 46, // 3315: check predicate 46
2815 OPC_CheckField, 7, 1, 1, // 3317: check Inst[7] == 0x1
2816 OPC_Decode, 130, 122, 24, // 3321: decode to PWMULSU_B using decoder 24
2817 // 3321: }
2818 1, 0, // 3325: case 0x1: {
2819 OPC_CheckPredicate, 46, // 3327: check predicate 46
2820 OPC_CheckField, 7, 1, 1, // 3329: check Inst[7] == 0x1
2821 OPC_Decode, 166, 119, 24, // 3333: decode to PM2WADDSU_H using decoder 24
2822 // 3333: }
2823 // 3333: } // switch Inst[25]
2824 // 3333: }
2825 26, 28, // 3337: case 0x1a: {
2826 OPC_SwitchField, 25, 1, // 3339: switch Inst[25] {
2827 0, 10, // 3342: case 0x0: {
2828 OPC_CheckPredicate, 46, // 3344: check predicate 46
2829 OPC_CheckField, 7, 1, 1, // 3346: check Inst[7] == 0x1
2830 OPC_Decode, 255, 121, 26, // 3350: decode to PWMACCSU_H using decoder 26
2831 // 3350: }
2832 1, 0, // 3354: case 0x1: {
2833 OPC_CheckPredicate, 46, // 3356: check predicate 46
2834 OPC_CheckField, 7, 1, 1, // 3358: check Inst[7] == 0x1
2835 OPC_Decode, 128, 132, 1, 26, // 3362: decode to WMACCSU using decoder 26
2836 // 3362: }
2837 // 3362: } // switch Inst[25]
2838 // 3362: }
2839 27, 14, // 3367: case 0x1b: {
2840 OPC_CheckPredicate, 46, // 3369: check predicate 46
2841 OPC_CheckField, 25, 1, 1, // 3371: check Inst[25] == 0x1
2842 OPC_CheckField, 7, 1, 1, // 3375: check Inst[7] == 0x1
2843 OPC_Decode, 162, 119, 26, // 3379: decode to PM2WADDASU_H using decoder 26
2844 // 3379: }
2845 28, 14, // 3383: case 0x1c: {
2846 OPC_CheckPredicate, 46, // 3385: check predicate 46
2847 OPC_CheckField, 25, 1, 0, // 3387: check Inst[25] == 0x0
2848 OPC_CheckField, 7, 1, 0, // 3391: check Inst[7] == 0x0
2849 OPC_Decode, 133, 119, 29, // 3395: decode to PLUI_DH using decoder 29
2850 // 3395: }
2851 30, 47, // 3399: case 0x1e: {
2852 OPC_SwitchField, 7, 1, // 3401: switch Inst[7] {
2853 0, 21, // 3404: case 0x0: {
2854 OPC_SwitchField, 25, 1, // 3406: switch Inst[25] {
2855 0, 7, // 3409: case 0x0: {
2856 OPC_CheckPredicate, 46, // 3411: check predicate 46
2857 OPC_Decode, 144, 132, 1, 24, // 3413: decode to WZIP8P using decoder 24
2858 // 3413: }
2859 1, 0, // 3418: case 0x1: {
2860 OPC_CheckPredicate, 46, // 3420: check predicate 46
2861 OPC_Decode, 143, 132, 1, 24, // 3422: decode to WZIP16P using decoder 24
2862 // 3422: }
2863 // 3422: } // switch Inst[25]
2864 // 3422: }
2865 1, 0, // 3427: case 0x1: {
2866 OPC_SwitchField, 25, 1, // 3429: switch Inst[25] {
2867 0, 6, // 3432: case 0x0: {
2868 OPC_CheckPredicate, 46, // 3434: check predicate 46
2869 OPC_Decode, 253, 119, 26, // 3436: decode to PMQWACC_H using decoder 26
2870 // 3436: }
2871 1, 0, // 3440: case 0x1: {
2872 OPC_CheckPredicate, 46, // 3442: check predicate 46
2873 OPC_Decode, 223, 117, 26, // 3444: decode to MQWACC using decoder 26
2874 // 3444: }
2875 // 3444: } // switch Inst[25]
2876 // 3444: }
2877 // 3444: } // switch Inst[7]
2878 // 3444: }
2879 31, 27, // 3448: case 0x1f: {
2880 OPC_SwitchField, 25, 1, // 3450: switch Inst[25] {
2881 0, 10, // 3453: case 0x0: {
2882 OPC_CheckPredicate, 46, // 3455: check predicate 46
2883 OPC_CheckField, 7, 1, 1, // 3457: check Inst[7] == 0x1
2884 OPC_Decode, 252, 119, 26, // 3461: decode to PMQRWACC_H using decoder 26
2885 // 3461: }
2886 1, 0, // 3465: case 0x1: {
2887 OPC_CheckPredicate, 46, // 3467: check predicate 46
2888 OPC_CheckField, 7, 1, 1, // 3469: check Inst[7] == 0x1
2889 OPC_Decode, 222, 117, 26, // 3473: decode to MQRWACC using decoder 26
2890 // 3473: }
2891 // 3473: } // switch Inst[25]
2892 // 3473: }
2893 32, 36, // 3477: case 0x20: {
2894 OPC_SwitchField, 25, 1, // 3479: switch Inst[25] {
2895 0, 23, // 3482: case 0x0: {
2896 OPC_SwitchField, 24, 1, // 3484: switch Inst[24] {
2897 0, 10, // 3487: case 0x0: {
2898 OPC_CheckPredicate, 42, // 3489: check predicate 42
2899 OPC_CheckField, 23, 1, 1, // 3491: check Inst[23] == 0x1
2900 OPC_Decode, 158, 121, 30, // 3495: decode to PSLLI_B using decoder 30
2901 // 3495: }
2902 1, 0, // 3499: case 0x1: {
2903 OPC_CheckPredicate, 42, // 3501: check predicate 42
2904 OPC_Decode, 162, 121, 18, // 3503: decode to PSLLI_H using decoder 18
2905 // 3503: }
2906 // 3503: } // switch Inst[24]
2907 // 3503: }
2908 1, 0, // 3507: case 0x1: {
2909 OPC_CheckPredicate, 47, // 3509: check predicate 47
2910 OPC_Decode, 163, 121, 21, // 3511: decode to PSLLI_W using decoder 21
2911 // 3511: }
2912 // 3511: } // switch Inst[25]
2913 // 3511: }
2914 34, 19, // 3515: case 0x22: {
2915 OPC_SwitchField, 25, 1, // 3517: switch Inst[25] {
2916 0, 6, // 3520: case 0x0: {
2917 OPC_CheckPredicate, 42, // 3522: check predicate 42
2918 OPC_Decode, 168, 121, 31, // 3524: decode to PSLL_HS using decoder 31
2919 // 3524: }
2920 1, 0, // 3528: case 0x1: {
2921 OPC_CheckPredicate, 47, // 3530: check predicate 47
2922 OPC_Decode, 169, 121, 31, // 3532: decode to PSLL_WS using decoder 31
2923 // 3532: }
2924 // 3532: } // switch Inst[25]
2925 // 3532: }
2926 35, 10, // 3536: case 0x23: {
2927 OPC_CheckPredicate, 42, // 3538: check predicate 42
2928 OPC_CheckField, 25, 1, 0, // 3540: check Inst[25] == 0x0
2929 OPC_Decode, 164, 121, 31, // 3544: decode to PSLL_BS using decoder 31
2930 // 3544: }
2931 38, 19, // 3548: case 0x26: {
2932 OPC_SwitchField, 25, 1, // 3550: switch Inst[25] {
2933 0, 6, // 3553: case 0x0: {
2934 OPC_CheckPredicate, 42, // 3555: check predicate 42
2935 OPC_Decode, 235, 118, 31, // 3557: decode to PADD_HS using decoder 31
2936 // 3557: }
2937 1, 0, // 3561: case 0x1: {
2938 OPC_CheckPredicate, 47, // 3563: check predicate 47
2939 OPC_Decode, 237, 118, 31, // 3565: decode to PADD_WS using decoder 31
2940 // 3565: }
2941 // 3565: } // switch Inst[25]
2942 // 3565: }
2943 39, 10, // 3569: case 0x27: {
2944 OPC_CheckPredicate, 42, // 3571: check predicate 42
2945 OPC_CheckField, 25, 1, 0, // 3573: check Inst[25] == 0x0
2946 OPC_Decode, 227, 118, 31, // 3577: decode to PADD_BS using decoder 31
2947 // 3577: }
2948 42, 19, // 3581: case 0x2a: {
2949 OPC_SwitchField, 25, 1, // 3583: switch Inst[25] {
2950 0, 6, // 3586: case 0x0: {
2951 OPC_CheckPredicate, 42, // 3588: check predicate 42
2952 OPC_Decode, 219, 121, 31, // 3590: decode to PSSHL_HS using decoder 31
2953 // 3590: }
2954 1, 0, // 3594: case 0x1: {
2955 OPC_CheckPredicate, 47, // 3596: check predicate 47
2956 OPC_Decode, 220, 121, 31, // 3598: decode to PSSHL_WS using decoder 31
2957 // 3598: }
2958 // 3598: } // switch Inst[25]
2959 // 3598: }
2960 43, 10, // 3602: case 0x2b: {
2961 OPC_CheckPredicate, 47, // 3604: check predicate 47
2962 OPC_CheckField, 25, 1, 1, // 3606: check Inst[25] == 0x1
2963 OPC_Decode, 193, 124, 31, // 3610: decode to SHL using decoder 31
2964 // 3610: }
2965 44, 19, // 3614: case 0x2c: {
2966 OPC_SwitchField, 25, 1, // 3616: switch Inst[25] {
2967 0, 6, // 3619: case 0x0: {
2968 OPC_CheckPredicate, 42, // 3621: check predicate 42
2969 OPC_Decode, 131, 119, 32, // 3623: decode to PLI_H using decoder 32
2970 // 3623: }
2971 1, 0, // 3627: case 0x1: {
2972 OPC_CheckPredicate, 47, // 3629: check predicate 47
2973 OPC_Decode, 132, 119, 32, // 3631: decode to PLI_W using decoder 32
2974 // 3631: }
2975 // 3631: } // switch Inst[25]
2976 // 3631: }
2977 45, 14, // 3635: case 0x2d: {
2978 OPC_CheckPredicate, 42, // 3637: check predicate 42
2979 OPC_CheckField, 24, 2, 0, // 3639: check Inst[25:24] == 0x0
2980 OPC_CheckField, 15, 1, 0, // 3643: check Inst[15] == 0x0
2981 OPC_Decode, 128, 119, 33, // 3647: decode to PLI_B using decoder 33
2982 // 3647: }
2983 46, 19, // 3651: case 0x2e: {
2984 OPC_SwitchField, 25, 1, // 3653: switch Inst[25] {
2985 0, 6, // 3656: case 0x0: {
2986 OPC_CheckPredicate, 42, // 3658: check predicate 42
2987 OPC_Decode, 215, 121, 31, // 3660: decode to PSSHLR_HS using decoder 31
2988 // 3660: }
2989 1, 0, // 3664: case 0x1: {
2990 OPC_CheckPredicate, 47, // 3666: check predicate 47
2991 OPC_Decode, 216, 121, 31, // 3668: decode to PSSHLR_WS using decoder 31
2992 // 3668: }
2993 // 3668: } // switch Inst[25]
2994 // 3668: }
2995 47, 10, // 3672: case 0x2f: {
2996 OPC_CheckPredicate, 47, // 3674: check predicate 47
2997 OPC_CheckField, 25, 1, 1, // 3676: check Inst[25] == 0x1
2998 OPC_Decode, 194, 124, 31, // 3680: decode to SHLR using decoder 31
2999 // 3680: }
3000 52, 23, // 3684: case 0x34: {
3001 OPC_SwitchField, 25, 1, // 3686: switch Inst[25] {
3002 0, 10, // 3689: case 0x0: {
3003 OPC_CheckPredicate, 42, // 3691: check predicate 42
3004 OPC_CheckField, 24, 1, 1, // 3693: check Inst[24] == 0x1
3005 OPC_Decode, 223, 121, 18, // 3697: decode to PSSLAI_H using decoder 18
3006 // 3697: }
3007 1, 0, // 3701: case 0x1: {
3008 OPC_CheckPredicate, 47, // 3703: check predicate 47
3009 OPC_Decode, 224, 121, 21, // 3705: decode to PSSLAI_W using decoder 21
3010 // 3705: }
3011 // 3705: } // switch Inst[25]
3012 // 3705: }
3013 56, 35, // 3709: case 0x38: {
3014 OPC_SwitchField, 20, 6, // 3711: switch Inst[25:20] {
3015 4, 6, // 3714: case 0x4: {
3016 OPC_CheckPredicate, 42, // 3716: check predicate 42
3017 OPC_Decode, 151, 121, 17, // 3718: decode to PSEXT_H_B using decoder 17
3018 // 3718: }
3019 7, 6, // 3722: case 0x7: {
3020 OPC_CheckPredicate, 42, // 3724: check predicate 42
3021 OPC_Decode, 253, 120, 17, // 3726: decode to PSABS_H using decoder 17
3022 // 3726: }
3023 36, 6, // 3730: case 0x24: {
3024 OPC_CheckPredicate, 47, // 3732: check predicate 47
3025 OPC_Decode, 152, 121, 17, // 3734: decode to PSEXT_W_B using decoder 17
3026 // 3734: }
3027 37, 0, // 3738: case 0x25: {
3028 OPC_CheckPredicate, 47, // 3740: check predicate 47
3029 OPC_Decode, 153, 121, 17, // 3742: decode to PSEXT_W_H using decoder 17
3030 // 3742: }
3031 // 3742: } // switch Inst[25:20]
3032 // 3742: }
3033 57, 10, // 3746: case 0x39: {
3034 OPC_CheckPredicate, 42, // 3748: check predicate 42
3035 OPC_CheckField, 20, 6, 7, // 3750: check Inst[25:20] == 0x7
3036 OPC_Decode, 250, 120, 17, // 3754: decode to PSABS_B using decoder 17
3037 // 3754: }
3038 58, 19, // 3758: case 0x3a: {
3039 OPC_SwitchField, 25, 1, // 3760: switch Inst[25] {
3040 0, 6, // 3763: case 0x0: {
3041 OPC_CheckPredicate, 42, // 3765: check predicate 42
3042 OPC_Decode, 211, 121, 31, // 3767: decode to PSSHA_HS using decoder 31
3043 // 3767: }
3044 1, 0, // 3771: case 0x1: {
3045 OPC_CheckPredicate, 47, // 3773: check predicate 47
3046 OPC_Decode, 212, 121, 31, // 3775: decode to PSSHA_WS using decoder 31
3047 // 3775: }
3048 // 3775: } // switch Inst[25]
3049 // 3775: }
3050 59, 10, // 3779: case 0x3b: {
3051 OPC_CheckPredicate, 47, // 3781: check predicate 47
3052 OPC_CheckField, 25, 1, 1, // 3783: check Inst[25] == 0x1
3053 OPC_Decode, 177, 124, 31, // 3787: decode to SHA using decoder 31
3054 // 3787: }
3055 60, 19, // 3791: case 0x3c: {
3056 OPC_SwitchField, 25, 1, // 3793: switch Inst[25] {
3057 0, 6, // 3796: case 0x0: {
3058 OPC_CheckPredicate, 42, // 3798: check predicate 42
3059 OPC_Decode, 134, 119, 34, // 3800: decode to PLUI_H using decoder 34
3060 // 3800: }
3061 1, 0, // 3804: case 0x1: {
3062 OPC_CheckPredicate, 47, // 3806: check predicate 47
3063 OPC_Decode, 135, 119, 34, // 3808: decode to PLUI_W using decoder 34
3064 // 3808: }
3065 // 3808: } // switch Inst[25]
3066 // 3808: }
3067 62, 19, // 3812: case 0x3e: {
3068 OPC_SwitchField, 25, 1, // 3814: switch Inst[25] {
3069 0, 6, // 3817: case 0x0: {
3070 OPC_CheckPredicate, 42, // 3819: check predicate 42
3071 OPC_Decode, 207, 121, 31, // 3821: decode to PSSHAR_HS using decoder 31
3072 // 3821: }
3073 1, 0, // 3825: case 0x1: {
3074 OPC_CheckPredicate, 47, // 3827: check predicate 47
3075 OPC_Decode, 208, 121, 31, // 3829: decode to PSSHAR_WS using decoder 31
3076 // 3829: }
3077 // 3829: } // switch Inst[25]
3078 // 3829: }
3079 63, 0, // 3833: case 0x3f: {
3080 OPC_CheckPredicate, 47, // 3835: check predicate 47
3081 OPC_CheckField, 25, 1, 1, // 3837: check Inst[25] == 0x1
3082 OPC_Decode, 192, 124, 31, // 3841: decode to SHAR using decoder 31
3083 // 3841: }
3084 // 3841: } // switch Inst[31:26]
3085 // 3841: }
3086 4, 226, 7, // 3845: case 0x4: {
3087 OPC_SwitchField, 26, 6, // 3848: switch Inst[31:26] {
3088 0, 31, // 3851: case 0x0: {
3089 OPC_SwitchField, 25, 1, // 3853: switch Inst[25] {
3090 0, 14, // 3856: case 0x0: {
3091 OPC_CheckPredicate, 46, // 3858: check predicate 46
3092 OPC_CheckField, 24, 1, 1, // 3860: check Inst[24] == 0x1
3093 OPC_CheckField, 15, 1, 1, // 3864: check Inst[15] == 0x1
3094 OPC_Decode, 214, 120, 35, // 3868: decode to PNSRLI_B using decoder 35
3095 // 3868: }
3096 1, 0, // 3872: case 0x1: {
3097 OPC_CheckPredicate, 46, // 3874: check predicate 46
3098 OPC_CheckField, 15, 1, 1, // 3876: check Inst[15] == 0x1
3099 OPC_Decode, 215, 120, 36, // 3880: decode to PNSRLI_H using decoder 36
3100 // 3880: }
3101 // 3880: } // switch Inst[25]
3102 // 3880: }
3103 1, 10, // 3884: case 0x1: {
3104 OPC_CheckPredicate, 46, // 3886: check predicate 46
3105 OPC_CheckField, 15, 1, 1, // 3888: check Inst[15] == 0x1
3106 OPC_Decode, 192, 118, 37, // 3892: decode to NSRLI using decoder 37
3107 // 3892: }
3108 2, 27, // 3896: case 0x2: {
3109 OPC_SwitchField, 25, 1, // 3898: switch Inst[25] {
3110 0, 10, // 3901: case 0x0: {
3111 OPC_CheckPredicate, 46, // 3903: check predicate 46
3112 OPC_CheckField, 15, 1, 1, // 3905: check Inst[15] == 0x1
3113 OPC_Decode, 216, 120, 38, // 3909: decode to PNSRL_BS using decoder 38
3114 // 3909: }
3115 1, 0, // 3913: case 0x1: {
3116 OPC_CheckPredicate, 46, // 3915: check predicate 46
3117 OPC_CheckField, 15, 1, 1, // 3917: check Inst[15] == 0x1
3118 OPC_Decode, 217, 120, 38, // 3921: decode to PNSRL_HS using decoder 38
3119 // 3921: }
3120 // 3921: } // switch Inst[25]
3121 // 3921: }
3122 3, 14, // 3925: case 0x3: {
3123 OPC_CheckPredicate, 46, // 3927: check predicate 46
3124 OPC_CheckField, 25, 1, 1, // 3929: check Inst[25] == 0x1
3125 OPC_CheckField, 15, 1, 1, // 3933: check Inst[15] == 0x1
3126 OPC_Decode, 191, 118, 38, // 3937: decode to NSRL using decoder 38
3127 // 3937: }
3128 6, 14, // 3941: case 0x6: {
3129 OPC_CheckPredicate, 46, // 3943: check predicate 46
3130 OPC_CheckField, 25, 1, 0, // 3945: check Inst[25] == 0x0
3131 OPC_CheckField, 15, 1, 0, // 3949: check Inst[15] == 0x0
3132 OPC_Decode, 244, 120, 38, // 3953: decode to PREDSUM_DHS using decoder 38
3133 // 3953: }
3134 7, 14, // 3957: case 0x7: {
3135 OPC_CheckPredicate, 46, // 3959: check predicate 46
3136 OPC_CheckField, 25, 1, 0, // 3961: check Inst[25] == 0x0
3137 OPC_CheckField, 15, 1, 0, // 3965: check Inst[15] == 0x0
3138 OPC_Decode, 243, 120, 38, // 3969: decode to PREDSUM_DBS using decoder 38
3139 // 3969: }
3140 8, 31, // 3973: case 0x8: {
3141 OPC_SwitchField, 25, 1, // 3975: switch Inst[25] {
3142 0, 14, // 3978: case 0x0: {
3143 OPC_CheckPredicate, 46, // 3980: check predicate 46
3144 OPC_CheckField, 24, 1, 1, // 3982: check Inst[24] == 0x1
3145 OPC_CheckField, 15, 1, 1, // 3986: check Inst[15] == 0x1
3146 OPC_Decode, 184, 120, 35, // 3990: decode to PNCLIPIU_B using decoder 35
3147 // 3990: }
3148 1, 0, // 3994: case 0x1: {
3149 OPC_CheckPredicate, 46, // 3996: check predicate 46
3150 OPC_CheckField, 15, 1, 1, // 3998: check Inst[15] == 0x1
3151 OPC_Decode, 185, 120, 36, // 4002: decode to PNCLIPIU_H using decoder 36
3152 // 4002: }
3153 // 4002: } // switch Inst[25]
3154 // 4002: }
3155 9, 10, // 4006: case 0x9: {
3156 OPC_CheckPredicate, 46, // 4008: check predicate 46
3157 OPC_CheckField, 15, 1, 1, // 4010: check Inst[15] == 0x1
3158 OPC_Decode, 134, 118, 37, // 4014: decode to NCLIPIU using decoder 37
3159 // 4014: }
3160 10, 27, // 4018: case 0xa: {
3161 OPC_SwitchField, 25, 1, // 4020: switch Inst[25] {
3162 0, 10, // 4023: case 0x0: {
3163 OPC_CheckPredicate, 46, // 4025: check predicate 46
3164 OPC_CheckField, 15, 1, 1, // 4027: check Inst[15] == 0x1
3165 OPC_Decode, 202, 120, 38, // 4031: decode to PNCLIPU_BS using decoder 38
3166 // 4031: }
3167 1, 0, // 4035: case 0x1: {
3168 OPC_CheckPredicate, 46, // 4037: check predicate 46
3169 OPC_CheckField, 15, 1, 1, // 4039: check Inst[15] == 0x1
3170 OPC_Decode, 203, 120, 38, // 4043: decode to PNCLIPU_HS using decoder 38
3171 // 4043: }
3172 // 4043: } // switch Inst[25]
3173 // 4043: }
3174 11, 14, // 4047: case 0xb: {
3175 OPC_CheckPredicate, 46, // 4049: check predicate 46
3176 OPC_CheckField, 25, 1, 1, // 4051: check Inst[25] == 0x1
3177 OPC_CheckField, 15, 1, 1, // 4055: check Inst[15] == 0x1
3178 OPC_Decode, 139, 118, 38, // 4059: decode to NCLIPU using decoder 38
3179 // 4059: }
3180 12, 31, // 4063: case 0xc: {
3181 OPC_SwitchField, 25, 1, // 4065: switch Inst[25] {
3182 0, 14, // 4068: case 0x0: {
3183 OPC_CheckPredicate, 46, // 4070: check predicate 46
3184 OPC_CheckField, 24, 1, 1, // 4072: check Inst[24] == 0x1
3185 OPC_CheckField, 15, 1, 1, // 4076: check Inst[15] == 0x1
3186 OPC_Decode, 191, 120, 35, // 4080: decode to PNCLIPRIU_B using decoder 35
3187 // 4080: }
3188 1, 0, // 4084: case 0x1: {
3189 OPC_CheckPredicate, 46, // 4086: check predicate 46
3190 OPC_CheckField, 15, 1, 1, // 4088: check Inst[15] == 0x1
3191 OPC_Decode, 192, 120, 36, // 4092: decode to PNCLIPRIU_H using decoder 36
3192 // 4092: }
3193 // 4092: } // switch Inst[25]
3194 // 4092: }
3195 13, 10, // 4096: case 0xd: {
3196 OPC_CheckPredicate, 46, // 4098: check predicate 46
3197 OPC_CheckField, 15, 1, 1, // 4100: check Inst[15] == 0x1
3198 OPC_Decode, 137, 118, 37, // 4104: decode to NCLIPRIU using decoder 37
3199 // 4104: }
3200 14, 36, // 4108: case 0xe: {
3201 OPC_SwitchField, 15, 1, // 4110: switch Inst[15] {
3202 0, 10, // 4113: case 0x0: {
3203 OPC_CheckPredicate, 46, // 4115: check predicate 46
3204 OPC_CheckField, 25, 1, 0, // 4117: check Inst[25] == 0x0
3205 OPC_Decode, 239, 120, 38, // 4121: decode to PREDSUMU_DHS using decoder 38
3206 // 4121: }
3207 1, 0, // 4125: case 0x1: {
3208 OPC_SwitchField, 25, 1, // 4127: switch Inst[25] {
3209 0, 6, // 4130: case 0x0: {
3210 OPC_CheckPredicate, 46, // 4132: check predicate 46
3211 OPC_Decode, 195, 120, 38, // 4134: decode to PNCLIPRU_BS using decoder 38
3212 // 4134: }
3213 1, 0, // 4138: case 0x1: {
3214 OPC_CheckPredicate, 46, // 4140: check predicate 46
3215 OPC_Decode, 196, 120, 38, // 4142: decode to PNCLIPRU_HS using decoder 38
3216 // 4142: }
3217 // 4142: } // switch Inst[25]
3218 // 4142: }
3219 // 4142: } // switch Inst[15]
3220 // 4142: }
3221 15, 27, // 4146: case 0xf: {
3222 OPC_SwitchField, 15, 1, // 4148: switch Inst[15] {
3223 0, 10, // 4151: case 0x0: {
3224 OPC_CheckPredicate, 46, // 4153: check predicate 46
3225 OPC_CheckField, 25, 1, 0, // 4155: check Inst[25] == 0x0
3226 OPC_Decode, 238, 120, 38, // 4159: decode to PREDSUMU_DBS using decoder 38
3227 // 4159: }
3228 1, 0, // 4163: case 0x1: {
3229 OPC_CheckPredicate, 46, // 4165: check predicate 46
3230 OPC_CheckField, 25, 1, 1, // 4167: check Inst[25] == 0x1
3231 OPC_Decode, 138, 118, 38, // 4171: decode to NCLIPRU using decoder 38
3232 // 4171: }
3233 // 4171: } // switch Inst[15]
3234 // 4171: }
3235 16, 31, // 4175: case 0x10: {
3236 OPC_SwitchField, 25, 1, // 4177: switch Inst[25] {
3237 0, 14, // 4180: case 0x0: {
3238 OPC_CheckPredicate, 46, // 4182: check predicate 46
3239 OPC_CheckField, 24, 1, 1, // 4184: check Inst[24] == 0x1
3240 OPC_CheckField, 15, 1, 1, // 4188: check Inst[15] == 0x1
3241 OPC_Decode, 206, 120, 35, // 4192: decode to PNSRAI_B using decoder 35
3242 // 4192: }
3243 1, 0, // 4196: case 0x1: {
3244 OPC_CheckPredicate, 46, // 4198: check predicate 46
3245 OPC_CheckField, 15, 1, 1, // 4200: check Inst[15] == 0x1
3246 OPC_Decode, 207, 120, 36, // 4204: decode to PNSRAI_H using decoder 36
3247 // 4204: }
3248 // 4204: } // switch Inst[25]
3249 // 4204: }
3250 17, 10, // 4208: case 0x11: {
3251 OPC_CheckPredicate, 46, // 4210: check predicate 46
3252 OPC_CheckField, 15, 1, 1, // 4212: check Inst[15] == 0x1
3253 OPC_Decode, 188, 118, 37, // 4216: decode to NSRAI using decoder 37
3254 // 4216: }
3255 18, 27, // 4220: case 0x12: {
3256 OPC_SwitchField, 25, 1, // 4222: switch Inst[25] {
3257 0, 10, // 4225: case 0x0: {
3258 OPC_CheckPredicate, 46, // 4227: check predicate 46
3259 OPC_CheckField, 15, 1, 1, // 4229: check Inst[15] == 0x1
3260 OPC_Decode, 212, 120, 38, // 4233: decode to PNSRA_BS using decoder 38
3261 // 4233: }
3262 1, 0, // 4237: case 0x1: {
3263 OPC_CheckPredicate, 46, // 4239: check predicate 46
3264 OPC_CheckField, 15, 1, 1, // 4241: check Inst[15] == 0x1
3265 OPC_Decode, 213, 120, 38, // 4245: decode to PNSRA_HS using decoder 38
3266 // 4245: }
3267 // 4245: } // switch Inst[25]
3268 // 4245: }
3269 19, 14, // 4249: case 0x13: {
3270 OPC_CheckPredicate, 46, // 4251: check predicate 46
3271 OPC_CheckField, 25, 1, 1, // 4253: check Inst[25] == 0x1
3272 OPC_CheckField, 15, 1, 1, // 4257: check Inst[15] == 0x1
3273 OPC_Decode, 187, 118, 38, // 4261: decode to NSRA using decoder 38
3274 // 4261: }
3275 20, 31, // 4265: case 0x14: {
3276 OPC_SwitchField, 25, 1, // 4267: switch Inst[25] {
3277 0, 14, // 4270: case 0x0: {
3278 OPC_CheckPredicate, 46, // 4272: check predicate 46
3279 OPC_CheckField, 24, 1, 1, // 4274: check Inst[24] == 0x1
3280 OPC_CheckField, 15, 1, 1, // 4278: check Inst[15] == 0x1
3281 OPC_Decode, 208, 120, 35, // 4282: decode to PNSRARI_B using decoder 35
3282 // 4282: }
3283 1, 0, // 4286: case 0x1: {
3284 OPC_CheckPredicate, 46, // 4288: check predicate 46
3285 OPC_CheckField, 15, 1, 1, // 4290: check Inst[15] == 0x1
3286 OPC_Decode, 209, 120, 36, // 4294: decode to PNSRARI_H using decoder 36
3287 // 4294: }
3288 // 4294: } // switch Inst[25]
3289 // 4294: }
3290 21, 10, // 4298: case 0x15: {
3291 OPC_CheckPredicate, 46, // 4300: check predicate 46
3292 OPC_CheckField, 15, 1, 1, // 4302: check Inst[15] == 0x1
3293 OPC_Decode, 190, 118, 37, // 4306: decode to NSRARI using decoder 37
3294 // 4306: }
3295 22, 27, // 4310: case 0x16: {
3296 OPC_SwitchField, 25, 1, // 4312: switch Inst[25] {
3297 0, 10, // 4315: case 0x0: {
3298 OPC_CheckPredicate, 46, // 4317: check predicate 46
3299 OPC_CheckField, 15, 1, 1, // 4319: check Inst[15] == 0x1
3300 OPC_Decode, 210, 120, 38, // 4323: decode to PNSRAR_BS using decoder 38
3301 // 4323: }
3302 1, 0, // 4327: case 0x1: {
3303 OPC_CheckPredicate, 46, // 4329: check predicate 46
3304 OPC_CheckField, 15, 1, 1, // 4331: check Inst[15] == 0x1
3305 OPC_Decode, 211, 120, 38, // 4335: decode to PNSRAR_HS using decoder 38
3306 // 4335: }
3307 // 4335: } // switch Inst[25]
3308 // 4335: }
3309 23, 14, // 4339: case 0x17: {
3310 OPC_CheckPredicate, 46, // 4341: check predicate 46
3311 OPC_CheckField, 25, 1, 1, // 4343: check Inst[25] == 0x1
3312 OPC_CheckField, 15, 1, 1, // 4347: check Inst[15] == 0x1
3313 OPC_Decode, 189, 118, 38, // 4351: decode to NSRAR using decoder 38
3314 // 4351: }
3315 24, 31, // 4355: case 0x18: {
3316 OPC_SwitchField, 25, 1, // 4357: switch Inst[25] {
3317 0, 14, // 4360: case 0x0: {
3318 OPC_CheckPredicate, 46, // 4362: check predicate 46
3319 OPC_CheckField, 24, 1, 1, // 4364: check Inst[24] == 0x1
3320 OPC_CheckField, 15, 1, 1, // 4368: check Inst[15] == 0x1
3321 OPC_Decode, 186, 120, 35, // 4372: decode to PNCLIPI_B using decoder 35
3322 // 4372: }
3323 1, 0, // 4376: case 0x1: {
3324 OPC_CheckPredicate, 46, // 4378: check predicate 46
3325 OPC_CheckField, 15, 1, 1, // 4380: check Inst[15] == 0x1
3326 OPC_Decode, 187, 120, 36, // 4384: decode to PNCLIPI_H using decoder 36
3327 // 4384: }
3328 // 4384: } // switch Inst[25]
3329 // 4384: }
3330 25, 10, // 4388: case 0x19: {
3331 OPC_CheckPredicate, 46, // 4390: check predicate 46
3332 OPC_CheckField, 15, 1, 1, // 4392: check Inst[15] == 0x1
3333 OPC_Decode, 133, 118, 37, // 4396: decode to NCLIPI using decoder 37
3334 // 4396: }
3335 26, 27, // 4400: case 0x1a: {
3336 OPC_SwitchField, 25, 1, // 4402: switch Inst[25] {
3337 0, 10, // 4405: case 0x0: {
3338 OPC_CheckPredicate, 46, // 4407: check predicate 46
3339 OPC_CheckField, 15, 1, 1, // 4409: check Inst[15] == 0x1
3340 OPC_Decode, 204, 120, 38, // 4413: decode to PNCLIP_BS using decoder 38
3341 // 4413: }
3342 1, 0, // 4417: case 0x1: {
3343 OPC_CheckPredicate, 46, // 4419: check predicate 46
3344 OPC_CheckField, 15, 1, 1, // 4421: check Inst[15] == 0x1
3345 OPC_Decode, 205, 120, 38, // 4425: decode to PNCLIP_HS using decoder 38
3346 // 4425: }
3347 // 4425: } // switch Inst[25]
3348 // 4425: }
3349 27, 14, // 4429: case 0x1b: {
3350 OPC_CheckPredicate, 46, // 4431: check predicate 46
3351 OPC_CheckField, 25, 1, 1, // 4433: check Inst[25] == 0x1
3352 OPC_CheckField, 15, 1, 1, // 4437: check Inst[15] == 0x1
3353 OPC_Decode, 132, 118, 38, // 4441: decode to NCLIP using decoder 38
3354 // 4441: }
3355 28, 31, // 4445: case 0x1c: {
3356 OPC_SwitchField, 25, 1, // 4447: switch Inst[25] {
3357 0, 14, // 4450: case 0x0: {
3358 OPC_CheckPredicate, 46, // 4452: check predicate 46
3359 OPC_CheckField, 24, 1, 1, // 4454: check Inst[24] == 0x1
3360 OPC_CheckField, 15, 1, 1, // 4458: check Inst[15] == 0x1
3361 OPC_Decode, 193, 120, 35, // 4462: decode to PNCLIPRI_B using decoder 35
3362 // 4462: }
3363 1, 0, // 4466: case 0x1: {
3364 OPC_CheckPredicate, 46, // 4468: check predicate 46
3365 OPC_CheckField, 15, 1, 1, // 4470: check Inst[15] == 0x1
3366 OPC_Decode, 194, 120, 36, // 4474: decode to PNCLIPRI_H using decoder 36
3367 // 4474: }
3368 // 4474: } // switch Inst[25]
3369 // 4474: }
3370 29, 10, // 4478: case 0x1d: {
3371 OPC_CheckPredicate, 46, // 4480: check predicate 46
3372 OPC_CheckField, 15, 1, 1, // 4482: check Inst[15] == 0x1
3373 OPC_Decode, 136, 118, 37, // 4486: decode to NCLIPRI using decoder 37
3374 // 4486: }
3375 30, 27, // 4490: case 0x1e: {
3376 OPC_SwitchField, 25, 1, // 4492: switch Inst[25] {
3377 0, 10, // 4495: case 0x0: {
3378 OPC_CheckPredicate, 46, // 4497: check predicate 46
3379 OPC_CheckField, 15, 1, 1, // 4499: check Inst[15] == 0x1
3380 OPC_Decode, 197, 120, 38, // 4503: decode to PNCLIPR_BS using decoder 38
3381 // 4503: }
3382 1, 0, // 4507: case 0x1: {
3383 OPC_CheckPredicate, 46, // 4509: check predicate 46
3384 OPC_CheckField, 15, 1, 1, // 4511: check Inst[15] == 0x1
3385 OPC_Decode, 198, 120, 38, // 4515: decode to PNCLIPR_HS using decoder 38
3386 // 4515: }
3387 // 4515: } // switch Inst[25]
3388 // 4515: }
3389 31, 14, // 4519: case 0x1f: {
3390 OPC_CheckPredicate, 46, // 4521: check predicate 46
3391 OPC_CheckField, 25, 1, 1, // 4523: check Inst[25] == 0x1
3392 OPC_CheckField, 15, 1, 1, // 4527: check Inst[15] == 0x1
3393 OPC_Decode, 135, 118, 38, // 4531: decode to NCLIPR using decoder 38
3394 // 4531: }
3395 32, 36, // 4535: case 0x20: {
3396 OPC_SwitchField, 25, 1, // 4537: switch Inst[25] {
3397 0, 23, // 4540: case 0x0: {
3398 OPC_SwitchField, 24, 1, // 4542: switch Inst[24] {
3399 0, 10, // 4545: case 0x0: {
3400 OPC_CheckPredicate, 42, // 4547: check predicate 42
3401 OPC_CheckField, 23, 1, 1, // 4549: check Inst[23] == 0x1
3402 OPC_Decode, 186, 121, 30, // 4553: decode to PSRLI_B using decoder 30
3403 // 4553: }
3404 1, 0, // 4557: case 0x1: {
3405 OPC_CheckPredicate, 42, // 4559: check predicate 42
3406 OPC_Decode, 190, 121, 18, // 4561: decode to PSRLI_H using decoder 18
3407 // 4561: }
3408 // 4561: } // switch Inst[24]
3409 // 4561: }
3410 1, 0, // 4565: case 0x1: {
3411 OPC_CheckPredicate, 47, // 4567: check predicate 47
3412 OPC_Decode, 191, 121, 21, // 4569: decode to PSRLI_W using decoder 21
3413 // 4569: }
3414 // 4569: } // switch Inst[25]
3415 // 4569: }
3416 34, 19, // 4573: case 0x22: {
3417 OPC_SwitchField, 25, 1, // 4575: switch Inst[25] {
3418 0, 6, // 4578: case 0x0: {
3419 OPC_CheckPredicate, 42, // 4580: check predicate 42
3420 OPC_Decode, 196, 121, 31, // 4582: decode to PSRL_HS using decoder 31
3421 // 4582: }
3422 1, 0, // 4586: case 0x1: {
3423 OPC_CheckPredicate, 47, // 4588: check predicate 47
3424 OPC_Decode, 197, 121, 31, // 4590: decode to PSRL_WS using decoder 31
3425 // 4590: }
3426 // 4590: } // switch Inst[25]
3427 // 4590: }
3428 35, 10, // 4594: case 0x23: {
3429 OPC_CheckPredicate, 42, // 4596: check predicate 42
3430 OPC_CheckField, 25, 1, 0, // 4598: check Inst[25] == 0x0
3431 OPC_Decode, 192, 121, 31, // 4602: decode to PSRL_BS using decoder 31
3432 // 4602: }
3433 38, 19, // 4606: case 0x26: {
3434 OPC_SwitchField, 25, 1, // 4608: switch Inst[25] {
3435 0, 6, // 4611: case 0x0: {
3436 OPC_CheckPredicate, 42, // 4613: check predicate 42
3437 OPC_Decode, 245, 120, 31, // 4615: decode to PREDSUM_HS using decoder 31
3438 // 4615: }
3439 1, 0, // 4619: case 0x1: {
3440 OPC_CheckPredicate, 47, // 4621: check predicate 47
3441 OPC_Decode, 246, 120, 31, // 4623: decode to PREDSUM_WS using decoder 31
3442 // 4623: }
3443 // 4623: } // switch Inst[25]
3444 // 4623: }
3445 39, 10, // 4627: case 0x27: {
3446 OPC_CheckPredicate, 42, // 4629: check predicate 42
3447 OPC_CheckField, 25, 1, 0, // 4631: check Inst[25] == 0x0
3448 OPC_Decode, 242, 120, 31, // 4635: decode to PREDSUM_BS using decoder 31
3449 // 4635: }
3450 40, 23, // 4639: case 0x28: {
3451 OPC_SwitchField, 25, 1, // 4641: switch Inst[25] {
3452 0, 10, // 4644: case 0x0: {
3453 OPC_CheckPredicate, 42, // 4646: check predicate 42
3454 OPC_CheckField, 24, 1, 1, // 4648: check Inst[24] == 0x1
3455 OPC_Decode, 245, 121, 18, // 4652: decode to PUSATI_H using decoder 18
3456 // 4652: }
3457 1, 0, // 4656: case 0x1: {
3458 OPC_CheckPredicate, 47, // 4658: check predicate 47
3459 OPC_Decode, 246, 121, 21, // 4660: decode to PUSATI_W using decoder 21
3460 // 4660: }
3461 // 4660: } // switch Inst[25]
3462 // 4660: }
3463 41, 6, // 4664: case 0x29: {
3464 OPC_CheckPredicate, 47, // 4666: check predicate 47
3465 OPC_Decode, 129, 126, 39, // 4668: decode to USATI_RV64 using decoder 39
3466 // 4668: }
3467 46, 19, // 4672: case 0x2e: {
3468 OPC_SwitchField, 25, 1, // 4674: switch Inst[25] {
3469 0, 6, // 4677: case 0x0: {
3470 OPC_CheckPredicate, 42, // 4679: check predicate 42
3471 OPC_Decode, 240, 120, 31, // 4681: decode to PREDSUMU_HS using decoder 31
3472 // 4681: }
3473 1, 0, // 4685: case 0x1: {
3474 OPC_CheckPredicate, 47, // 4687: check predicate 47
3475 OPC_Decode, 241, 120, 31, // 4689: decode to PREDSUMU_WS using decoder 31
3476 // 4689: }
3477 // 4689: } // switch Inst[25]
3478 // 4689: }
3479 47, 10, // 4693: case 0x2f: {
3480 OPC_CheckPredicate, 42, // 4695: check predicate 42
3481 OPC_CheckField, 25, 1, 0, // 4697: check Inst[25] == 0x0
3482 OPC_Decode, 237, 120, 31, // 4701: decode to PREDSUMU_BS using decoder 31
3483 // 4701: }
3484 48, 36, // 4705: case 0x30: {
3485 OPC_SwitchField, 25, 1, // 4707: switch Inst[25] {
3486 0, 23, // 4710: case 0x0: {
3487 OPC_SwitchField, 24, 1, // 4712: switch Inst[24] {
3488 0, 10, // 4715: case 0x0: {
3489 OPC_CheckPredicate, 42, // 4717: check predicate 42
3490 OPC_CheckField, 23, 1, 1, // 4719: check Inst[23] == 0x1
3491 OPC_Decode, 170, 121, 30, // 4723: decode to PSRAI_B using decoder 30
3492 // 4723: }
3493 1, 0, // 4727: case 0x1: {
3494 OPC_CheckPredicate, 42, // 4729: check predicate 42
3495 OPC_Decode, 174, 121, 18, // 4731: decode to PSRAI_H using decoder 18
3496 // 4731: }
3497 // 4731: } // switch Inst[24]
3498 // 4731: }
3499 1, 0, // 4735: case 0x1: {
3500 OPC_CheckPredicate, 47, // 4737: check predicate 47
3501 OPC_Decode, 175, 121, 21, // 4739: decode to PSRAI_W using decoder 21
3502 // 4739: }
3503 // 4739: } // switch Inst[25]
3504 // 4739: }
3505 50, 19, // 4743: case 0x32: {
3506 OPC_SwitchField, 25, 1, // 4745: switch Inst[25] {
3507 0, 6, // 4748: case 0x0: {
3508 OPC_CheckPredicate, 42, // 4750: check predicate 42
3509 OPC_Decode, 184, 121, 31, // 4752: decode to PSRA_HS using decoder 31
3510 // 4752: }
3511 1, 0, // 4756: case 0x1: {
3512 OPC_CheckPredicate, 47, // 4758: check predicate 47
3513 OPC_Decode, 185, 121, 31, // 4760: decode to PSRA_WS using decoder 31
3514 // 4760: }
3515 // 4760: } // switch Inst[25]
3516 // 4760: }
3517 51, 10, // 4764: case 0x33: {
3518 OPC_CheckPredicate, 42, // 4766: check predicate 42
3519 OPC_CheckField, 25, 1, 0, // 4768: check Inst[25] == 0x0
3520 OPC_Decode, 180, 121, 31, // 4772: decode to PSRA_BS using decoder 31
3521 // 4772: }
3522 52, 23, // 4776: case 0x34: {
3523 OPC_SwitchField, 25, 1, // 4778: switch Inst[25] {
3524 0, 10, // 4781: case 0x0: {
3525 OPC_CheckPredicate, 42, // 4783: check predicate 42
3526 OPC_CheckField, 24, 1, 1, // 4785: check Inst[24] == 0x1
3527 OPC_Decode, 178, 121, 18, // 4789: decode to PSRARI_H using decoder 18
3528 // 4789: }
3529 1, 0, // 4793: case 0x1: {
3530 OPC_CheckPredicate, 47, // 4795: check predicate 47
3531 OPC_Decode, 179, 121, 21, // 4797: decode to PSRARI_W using decoder 21
3532 // 4797: }
3533 // 4797: } // switch Inst[25]
3534 // 4797: }
3535 53, 6, // 4801: case 0x35: {
3536 OPC_CheckPredicate, 47, // 4803: check predicate 47
3537 OPC_Decode, 234, 124, 39, // 4805: decode to SRARI_RV64 using decoder 39
3538 // 4805: }
3539 56, 23, // 4809: case 0x38: {
3540 OPC_SwitchField, 25, 1, // 4811: switch Inst[25] {
3541 0, 10, // 4814: case 0x0: {
3542 OPC_CheckPredicate, 42, // 4816: check predicate 42
3543 OPC_CheckField, 24, 1, 1, // 4818: check Inst[24] == 0x1
3544 OPC_Decode, 143, 121, 40, // 4822: decode to PSATI_H using decoder 40
3545 // 4822: }
3546 1, 0, // 4826: case 0x1: {
3547 OPC_CheckPredicate, 47, // 4828: check predicate 47
3548 OPC_Decode, 144, 121, 41, // 4830: decode to PSATI_W using decoder 41
3549 // 4830: }
3550 // 4830: } // switch Inst[25]
3551 // 4830: }
3552 57, 0, // 4834: case 0x39: {
3553 OPC_CheckPredicate, 47, // 4836: check predicate 47
3554 OPC_Decode, 206, 123, 42, // 4838: decode to SATI_RV64 using decoder 42
3555 // 4838: }
3556 // 4838: } // switch Inst[31:26]
3557 // 4838: }
3558 5, 27, // 4842: case 0x5: {
3559 OPC_SwitchField, 25, 7, // 4844: switch Inst[31:25] {
3560 0, 6, // 4847: case 0x0: {
3561 OPC_CheckPredicate, 21, // 4849: check predicate 21
3562 OPC_Decode, 239, 124, 21, // 4851: decode to SRLIW using decoder 21
3563 // 4851: }
3564 32, 6, // 4855: case 0x20: {
3565 OPC_CheckPredicate, 21, // 4857: check predicate 21
3566 OPC_Decode, 232, 124, 21, // 4859: decode to SRAIW using decoder 21
3567 // 4859: }
3568 48, 0, // 4863: case 0x30: {
3569 OPC_CheckPredicate, 48, // 4865: check predicate 48
3570 OPC_Decode, 201, 123, 21, // 4867: decode to RORIW using decoder 21
3571 // 4867: }
3572 // 4867: } // switch Inst[31:25]
3573 // 4867: }
3574 6, 0, // 4871: case 0x6: {
3575 OPC_SwitchField, 25, 7, // 4873: switch Inst[31:25] {
3576 0, 69, // 4876: case 0x0: {
3577 OPC_SwitchField, 15, 1, // 4878: switch Inst[15] {
3578 0, 31, // 4881: case 0x0: {
3579 OPC_SwitchField, 24, 1, // 4883: switch Inst[24] {
3580 0, 14, // 4886: case 0x0: {
3581 OPC_CheckPredicate, 46, // 4888: check predicate 46
3582 OPC_CheckField, 23, 1, 1, // 4890: check Inst[23] == 0x1
3583 OPC_CheckField, 7, 1, 0, // 4894: check Inst[7] == 0x0
3584 OPC_Decode, 159, 121, 43, // 4898: decode to PSLLI_DB using decoder 43
3585 // 4898: }
3586 1, 0, // 4902: case 0x1: {
3587 OPC_CheckPredicate, 46, // 4904: check predicate 46
3588 OPC_CheckField, 7, 1, 0, // 4906: check Inst[7] == 0x0
3589 OPC_Decode, 160, 121, 44, // 4910: decode to PSLLI_DH using decoder 44
3590 // 4910: }
3591 // 4910: } // switch Inst[24]
3592 // 4910: }
3593 1, 0, // 4914: case 0x1: {
3594 OPC_SwitchField, 24, 1, // 4916: switch Inst[24] {
3595 0, 14, // 4919: case 0x0: {
3596 OPC_CheckPredicate, 46, // 4921: check predicate 46
3597 OPC_CheckField, 23, 1, 1, // 4923: check Inst[23] == 0x1
3598 OPC_CheckField, 7, 1, 0, // 4927: check Inst[7] == 0x0
3599 OPC_Decode, 187, 121, 43, // 4931: decode to PSRLI_DB using decoder 43
3600 // 4931: }
3601 1, 0, // 4935: case 0x1: {
3602 OPC_CheckPredicate, 46, // 4937: check predicate 46
3603 OPC_CheckField, 7, 1, 0, // 4939: check Inst[7] == 0x0
3604 OPC_Decode, 188, 121, 44, // 4943: decode to PSRLI_DH using decoder 44
3605 // 4943: }
3606 // 4943: } // switch Inst[24]
3607 // 4943: }
3608 // 4943: } // switch Inst[15]
3609 // 4943: }
3610 1, 27, // 4947: case 0x1: {
3611 OPC_SwitchField, 15, 1, // 4949: switch Inst[15] {
3612 0, 10, // 4952: case 0x0: {
3613 OPC_CheckPredicate, 46, // 4954: check predicate 46
3614 OPC_CheckField, 7, 1, 0, // 4956: check Inst[7] == 0x0
3615 OPC_Decode, 161, 121, 45, // 4960: decode to PSLLI_DW using decoder 45
3616 // 4960: }
3617 1, 0, // 4964: case 0x1: {
3618 OPC_CheckPredicate, 46, // 4966: check predicate 46
3619 OPC_CheckField, 7, 1, 0, // 4968: check Inst[7] == 0x0
3620 OPC_Decode, 189, 121, 45, // 4972: decode to PSRLI_DW using decoder 45
3621 // 4972: }
3622 // 4972: } // switch Inst[15]
3623 // 4972: }
3624 4, 27, // 4976: case 0x4: {
3625 OPC_SwitchField, 15, 1, // 4978: switch Inst[15] {
3626 0, 10, // 4981: case 0x0: {
3627 OPC_CheckPredicate, 46, // 4983: check predicate 46
3628 OPC_CheckField, 7, 1, 0, // 4985: check Inst[7] == 0x0
3629 OPC_Decode, 166, 121, 46, // 4989: decode to PSLL_DHS using decoder 46
3630 // 4989: }
3631 1, 0, // 4993: case 0x1: {
3632 OPC_CheckPredicate, 46, // 4995: check predicate 46
3633 OPC_CheckField, 7, 1, 0, // 4997: check Inst[7] == 0x0
3634 OPC_Decode, 194, 121, 46, // 5001: decode to PSRL_DHS using decoder 46
3635 // 5001: }
3636 // 5001: } // switch Inst[15]
3637 // 5001: }
3638 5, 27, // 5005: case 0x5: {
3639 OPC_SwitchField, 15, 1, // 5007: switch Inst[15] {
3640 0, 10, // 5010: case 0x0: {
3641 OPC_CheckPredicate, 46, // 5012: check predicate 46
3642 OPC_CheckField, 7, 1, 0, // 5014: check Inst[7] == 0x0
3643 OPC_Decode, 167, 121, 46, // 5018: decode to PSLL_DWS using decoder 46
3644 // 5018: }
3645 1, 0, // 5022: case 0x1: {
3646 OPC_CheckPredicate, 46, // 5024: check predicate 46
3647 OPC_CheckField, 7, 1, 0, // 5026: check Inst[7] == 0x0
3648 OPC_Decode, 195, 121, 46, // 5030: decode to PSRL_DWS using decoder 46
3649 // 5030: }
3650 // 5030: } // switch Inst[15]
3651 // 5030: }
3652 6, 27, // 5034: case 0x6: {
3653 OPC_SwitchField, 15, 1, // 5036: switch Inst[15] {
3654 0, 10, // 5039: case 0x0: {
3655 OPC_CheckPredicate, 46, // 5041: check predicate 46
3656 OPC_CheckField, 7, 1, 0, // 5043: check Inst[7] == 0x0
3657 OPC_Decode, 165, 121, 46, // 5047: decode to PSLL_DBS using decoder 46
3658 // 5047: }
3659 1, 0, // 5051: case 0x1: {
3660 OPC_CheckPredicate, 46, // 5053: check predicate 46
3661 OPC_CheckField, 7, 1, 0, // 5055: check Inst[7] == 0x0
3662 OPC_Decode, 193, 121, 46, // 5059: decode to PSRL_DBS using decoder 46
3663 // 5059: }
3664 // 5059: } // switch Inst[15]
3665 // 5059: }
3666 12, 14, // 5063: case 0xc: {
3667 OPC_CheckPredicate, 46, // 5065: check predicate 46
3668 OPC_CheckField, 15, 1, 0, // 5067: check Inst[15] == 0x0
3669 OPC_CheckField, 7, 1, 0, // 5071: check Inst[7] == 0x0
3670 OPC_Decode, 231, 118, 46, // 5075: decode to PADD_DHS using decoder 46
3671 // 5075: }
3672 13, 14, // 5079: case 0xd: {
3673 OPC_CheckPredicate, 46, // 5081: check predicate 46
3674 OPC_CheckField, 15, 1, 0, // 5083: check Inst[15] == 0x0
3675 OPC_CheckField, 7, 1, 0, // 5087: check Inst[7] == 0x0
3676 OPC_Decode, 233, 118, 46, // 5091: decode to PADD_DWS using decoder 46
3677 // 5091: }
3678 14, 14, // 5095: case 0xe: {
3679 OPC_CheckPredicate, 46, // 5097: check predicate 46
3680 OPC_CheckField, 15, 1, 0, // 5099: check Inst[15] == 0x0
3681 OPC_CheckField, 7, 1, 0, // 5103: check Inst[7] == 0x0
3682 OPC_Decode, 229, 118, 46, // 5107: decode to PADD_DBS using decoder 46
3683 // 5107: }
3684 16, 18, // 5111: case 0x10: {
3685 OPC_CheckPredicate, 46, // 5113: check predicate 46
3686 OPC_CheckField, 24, 1, 1, // 5115: check Inst[24] == 0x1
3687 OPC_CheckField, 15, 1, 1, // 5119: check Inst[15] == 0x1
3688 OPC_CheckField, 7, 1, 0, // 5123: check Inst[7] == 0x0
3689 OPC_Decode, 243, 121, 44, // 5127: decode to PUSATI_DH using decoder 44
3690 // 5127: }
3691 17, 14, // 5131: case 0x11: {
3692 OPC_CheckPredicate, 46, // 5133: check predicate 46
3693 OPC_CheckField, 15, 1, 1, // 5135: check Inst[15] == 0x1
3694 OPC_CheckField, 7, 1, 0, // 5139: check Inst[7] == 0x0
3695 OPC_Decode, 244, 121, 45, // 5143: decode to PUSATI_DW using decoder 45
3696 // 5143: }
3697 20, 14, // 5147: case 0x14: {
3698 OPC_CheckPredicate, 46, // 5149: check predicate 46
3699 OPC_CheckField, 15, 1, 0, // 5151: check Inst[15] == 0x0
3700 OPC_CheckField, 7, 1, 0, // 5155: check Inst[7] == 0x0
3701 OPC_Decode, 217, 121, 46, // 5159: decode to PSSHL_DHS using decoder 46
3702 // 5159: }
3703 21, 14, // 5163: case 0x15: {
3704 OPC_CheckPredicate, 46, // 5165: check predicate 46
3705 OPC_CheckField, 15, 1, 0, // 5167: check Inst[15] == 0x0
3706 OPC_CheckField, 7, 1, 0, // 5171: check Inst[7] == 0x0
3707 OPC_Decode, 218, 121, 46, // 5175: decode to PSSHL_DWS using decoder 46
3708 // 5175: }
3709 28, 14, // 5179: case 0x1c: {
3710 OPC_CheckPredicate, 46, // 5181: check predicate 46
3711 OPC_CheckField, 15, 1, 0, // 5183: check Inst[15] == 0x0
3712 OPC_CheckField, 7, 1, 0, // 5187: check Inst[7] == 0x0
3713 OPC_Decode, 213, 121, 46, // 5191: decode to PSSHLR_DHS using decoder 46
3714 // 5191: }
3715 29, 14, // 5195: case 0x1d: {
3716 OPC_CheckPredicate, 46, // 5197: check predicate 46
3717 OPC_CheckField, 15, 1, 0, // 5199: check Inst[15] == 0x0
3718 OPC_CheckField, 7, 1, 0, // 5203: check Inst[7] == 0x0
3719 OPC_Decode, 214, 121, 46, // 5207: decode to PSSHLR_DWS using decoder 46
3720 // 5207: }
3721 32, 39, // 5211: case 0x20: {
3722 OPC_SwitchField, 24, 1, // 5213: switch Inst[24] {
3723 0, 18, // 5216: case 0x0: {
3724 OPC_CheckPredicate, 46, // 5218: check predicate 46
3725 OPC_CheckField, 23, 1, 1, // 5220: check Inst[23] == 0x1
3726 OPC_CheckField, 15, 1, 1, // 5224: check Inst[15] == 0x1
3727 OPC_CheckField, 7, 1, 0, // 5228: check Inst[7] == 0x0
3728 OPC_Decode, 171, 121, 43, // 5232: decode to PSRAI_DB using decoder 43
3729 // 5232: }
3730 1, 0, // 5236: case 0x1: {
3731 OPC_CheckPredicate, 46, // 5238: check predicate 46
3732 OPC_CheckField, 15, 1, 1, // 5240: check Inst[15] == 0x1
3733 OPC_CheckField, 7, 1, 0, // 5244: check Inst[7] == 0x0
3734 OPC_Decode, 172, 121, 44, // 5248: decode to PSRAI_DH using decoder 44
3735 // 5248: }
3736 // 5248: } // switch Inst[24]
3737 // 5248: }
3738 33, 14, // 5252: case 0x21: {
3739 OPC_CheckPredicate, 46, // 5254: check predicate 46
3740 OPC_CheckField, 15, 1, 1, // 5256: check Inst[15] == 0x1
3741 OPC_CheckField, 7, 1, 0, // 5260: check Inst[7] == 0x0
3742 OPC_Decode, 173, 121, 45, // 5264: decode to PSRAI_DW using decoder 45
3743 // 5264: }
3744 36, 14, // 5268: case 0x24: {
3745 OPC_CheckPredicate, 46, // 5270: check predicate 46
3746 OPC_CheckField, 15, 1, 1, // 5272: check Inst[15] == 0x1
3747 OPC_CheckField, 7, 1, 0, // 5276: check Inst[7] == 0x0
3748 OPC_Decode, 182, 121, 46, // 5280: decode to PSRA_DHS using decoder 46
3749 // 5280: }
3750 37, 14, // 5284: case 0x25: {
3751 OPC_CheckPredicate, 46, // 5286: check predicate 46
3752 OPC_CheckField, 15, 1, 1, // 5288: check Inst[15] == 0x1
3753 OPC_CheckField, 7, 1, 0, // 5292: check Inst[7] == 0x0
3754 OPC_Decode, 183, 121, 46, // 5296: decode to PSRA_DWS using decoder 46
3755 // 5296: }
3756 38, 14, // 5300: case 0x26: {
3757 OPC_CheckPredicate, 46, // 5302: check predicate 46
3758 OPC_CheckField, 15, 1, 1, // 5304: check Inst[15] == 0x1
3759 OPC_CheckField, 7, 1, 0, // 5308: check Inst[7] == 0x0
3760 OPC_Decode, 181, 121, 46, // 5312: decode to PSRA_DBS using decoder 46
3761 // 5312: }
3762 40, 35, // 5316: case 0x28: {
3763 OPC_SwitchField, 15, 1, // 5318: switch Inst[15] {
3764 0, 14, // 5321: case 0x0: {
3765 OPC_CheckPredicate, 46, // 5323: check predicate 46
3766 OPC_CheckField, 24, 1, 1, // 5325: check Inst[24] == 0x1
3767 OPC_CheckField, 7, 1, 0, // 5329: check Inst[7] == 0x0
3768 OPC_Decode, 221, 121, 44, // 5333: decode to PSSLAI_DH using decoder 44
3769 // 5333: }
3770 1, 0, // 5337: case 0x1: {
3771 OPC_CheckPredicate, 46, // 5339: check predicate 46
3772 OPC_CheckField, 24, 1, 1, // 5341: check Inst[24] == 0x1
3773 OPC_CheckField, 7, 1, 0, // 5345: check Inst[7] == 0x0
3774 OPC_Decode, 176, 121, 44, // 5349: decode to PSRARI_DH using decoder 44
3775 // 5349: }
3776 // 5349: } // switch Inst[15]
3777 // 5349: }
3778 41, 27, // 5353: case 0x29: {
3779 OPC_SwitchField, 15, 1, // 5355: switch Inst[15] {
3780 0, 10, // 5358: case 0x0: {
3781 OPC_CheckPredicate, 46, // 5360: check predicate 46
3782 OPC_CheckField, 7, 1, 0, // 5362: check Inst[7] == 0x0
3783 OPC_Decode, 222, 121, 45, // 5366: decode to PSSLAI_DW using decoder 45
3784 // 5366: }
3785 1, 0, // 5370: case 0x1: {
3786 OPC_CheckPredicate, 46, // 5372: check predicate 46
3787 OPC_CheckField, 7, 1, 0, // 5374: check Inst[7] == 0x0
3788 OPC_Decode, 177, 121, 45, // 5378: decode to PSRARI_DW using decoder 45
3789 // 5378: }
3790 // 5378: } // switch Inst[15]
3791 // 5378: }
3792 48, 48, // 5382: case 0x30: {
3793 OPC_SwitchField, 15, 1, // 5384: switch Inst[15] {
3794 0, 27, // 5387: case 0x0: {
3795 OPC_SwitchField, 20, 5, // 5389: switch Inst[24:20] {
3796 4, 10, // 5392: case 0x4: {
3797 OPC_CheckPredicate, 46, // 5394: check predicate 46
3798 OPC_CheckField, 7, 1, 0, // 5396: check Inst[7] == 0x0
3799 OPC_Decode, 148, 121, 47, // 5400: decode to PSEXT_DH_B using decoder 47
3800 // 5400: }
3801 7, 0, // 5404: case 0x7: {
3802 OPC_CheckPredicate, 46, // 5406: check predicate 46
3803 OPC_CheckField, 7, 1, 0, // 5408: check Inst[7] == 0x0
3804 OPC_Decode, 252, 120, 47, // 5412: decode to PSABS_DH using decoder 47
3805 // 5412: }
3806 // 5412: } // switch Inst[24:20]
3807 // 5412: }
3808 1, 0, // 5416: case 0x1: {
3809 OPC_CheckPredicate, 46, // 5418: check predicate 46
3810 OPC_CheckField, 24, 1, 1, // 5420: check Inst[24] == 0x1
3811 OPC_CheckField, 7, 1, 0, // 5424: check Inst[7] == 0x0
3812 OPC_Decode, 141, 121, 48, // 5428: decode to PSATI_DH using decoder 48
3813 // 5428: }
3814 // 5428: } // switch Inst[15]
3815 // 5428: }
3816 49, 44, // 5432: case 0x31: {
3817 OPC_SwitchField, 15, 1, // 5434: switch Inst[15] {
3818 0, 27, // 5437: case 0x0: {
3819 OPC_SwitchField, 20, 5, // 5439: switch Inst[24:20] {
3820 4, 10, // 5442: case 0x4: {
3821 OPC_CheckPredicate, 46, // 5444: check predicate 46
3822 OPC_CheckField, 7, 1, 0, // 5446: check Inst[7] == 0x0
3823 OPC_Decode, 149, 121, 47, // 5450: decode to PSEXT_DW_B using decoder 47
3824 // 5450: }
3825 5, 0, // 5454: case 0x5: {
3826 OPC_CheckPredicate, 46, // 5456: check predicate 46
3827 OPC_CheckField, 7, 1, 0, // 5458: check Inst[7] == 0x0
3828 OPC_Decode, 150, 121, 47, // 5462: decode to PSEXT_DW_H using decoder 47
3829 // 5462: }
3830 // 5462: } // switch Inst[24:20]
3831 // 5462: }
3832 1, 0, // 5466: case 0x1: {
3833 OPC_CheckPredicate, 46, // 5468: check predicate 46
3834 OPC_CheckField, 7, 1, 0, // 5470: check Inst[7] == 0x0
3835 OPC_Decode, 142, 121, 49, // 5474: decode to PSATI_DW using decoder 49
3836 // 5474: }
3837 // 5474: } // switch Inst[15]
3838 // 5474: }
3839 50, 18, // 5478: case 0x32: {
3840 OPC_CheckPredicate, 46, // 5480: check predicate 46
3841 OPC_CheckField, 20, 5, 7, // 5482: check Inst[24:20] == 0x7
3842 OPC_CheckField, 15, 1, 0, // 5486: check Inst[15] == 0x0
3843 OPC_CheckField, 7, 1, 0, // 5490: check Inst[7] == 0x0
3844 OPC_Decode, 251, 120, 47, // 5494: decode to PSABS_DB using decoder 47
3845 // 5494: }
3846 52, 14, // 5498: case 0x34: {
3847 OPC_CheckPredicate, 46, // 5500: check predicate 46
3848 OPC_CheckField, 15, 1, 0, // 5502: check Inst[15] == 0x0
3849 OPC_CheckField, 7, 1, 0, // 5506: check Inst[7] == 0x0
3850 OPC_Decode, 209, 121, 46, // 5510: decode to PSSHA_DHS using decoder 46
3851 // 5510: }
3852 53, 14, // 5514: case 0x35: {
3853 OPC_CheckPredicate, 46, // 5516: check predicate 46
3854 OPC_CheckField, 15, 1, 0, // 5518: check Inst[15] == 0x0
3855 OPC_CheckField, 7, 1, 0, // 5522: check Inst[7] == 0x0
3856 OPC_Decode, 210, 121, 46, // 5526: decode to PSSHA_DWS using decoder 46
3857 // 5526: }
3858 60, 14, // 5530: case 0x3c: {
3859 OPC_CheckPredicate, 46, // 5532: check predicate 46
3860 OPC_CheckField, 15, 1, 0, // 5534: check Inst[15] == 0x0
3861 OPC_CheckField, 7, 1, 0, // 5538: check Inst[7] == 0x0
3862 OPC_Decode, 205, 121, 46, // 5542: decode to PSSHAR_DHS using decoder 46
3863 // 5542: }
3864 61, 14, // 5546: case 0x3d: {
3865 OPC_CheckPredicate, 46, // 5548: check predicate 46
3866 OPC_CheckField, 15, 1, 0, // 5550: check Inst[15] == 0x0
3867 OPC_CheckField, 7, 1, 0, // 5554: check Inst[7] == 0x0
3868 OPC_Decode, 206, 121, 46, // 5558: decode to PSSHAR_DWS using decoder 46
3869 // 5558: }
3870 64, 48, // 5562: case 0x40: {
3871 OPC_SwitchField, 15, 1, // 5564: switch Inst[15] {
3872 0, 14, // 5567: case 0x0: {
3873 OPC_CheckPredicate, 46, // 5569: check predicate 46
3874 OPC_CheckField, 20, 1, 0, // 5571: check Inst[20] == 0x0
3875 OPC_CheckField, 7, 1, 0, // 5575: check Inst[7] == 0x0
3876 OPC_Decode, 230, 118, 50, // 5579: decode to PADD_DH using decoder 50
3877 // 5579: }
3878 1, 0, // 5583: case 0x1: {
3879 OPC_SwitchField, 20, 1, // 5585: switch Inst[20] {
3880 0, 10, // 5588: case 0x0: {
3881 OPC_CheckPredicate, 46, // 5590: check predicate 46
3882 OPC_CheckField, 7, 1, 0, // 5592: check Inst[7] == 0x0
3883 OPC_Decode, 224, 120, 50, // 5596: decode to PPAIRE_DB using decoder 50
3884 // 5596: }
3885 1, 0, // 5600: case 0x1: {
3886 OPC_CheckPredicate, 46, // 5602: check predicate 46
3887 OPC_CheckField, 7, 1, 0, // 5604: check Inst[7] == 0x0
3888 OPC_Decode, 253, 118, 50, // 5608: decode to PAS_DHX using decoder 50
3889 // 5608: }
3890 // 5608: } // switch Inst[20]
3891 // 5608: }
3892 // 5608: } // switch Inst[15]
3893 // 5608: }
3894 65, 35, // 5612: case 0x41: {
3895 OPC_SwitchField, 15, 1, // 5614: switch Inst[15] {
3896 0, 14, // 5617: case 0x0: {
3897 OPC_CheckPredicate, 46, // 5619: check predicate 46
3898 OPC_CheckField, 20, 1, 0, // 5621: check Inst[20] == 0x0
3899 OPC_CheckField, 7, 1, 0, // 5625: check Inst[7] == 0x0
3900 OPC_Decode, 232, 118, 50, // 5629: decode to PADD_DW using decoder 50
3901 // 5629: }
3902 1, 0, // 5633: case 0x1: {
3903 OPC_CheckPredicate, 46, // 5635: check predicate 46
3904 OPC_CheckField, 20, 1, 0, // 5637: check Inst[20] == 0x0
3905 OPC_CheckField, 7, 1, 0, // 5641: check Inst[7] == 0x0
3906 OPC_Decode, 225, 120, 50, // 5645: decode to PPAIRE_DH using decoder 50
3907 // 5645: }
3908 // 5645: } // switch Inst[15]
3909 // 5645: }
3910 66, 35, // 5649: case 0x42: {
3911 OPC_SwitchField, 15, 1, // 5651: switch Inst[15] {
3912 0, 14, // 5654: case 0x0: {
3913 OPC_CheckPredicate, 46, // 5656: check predicate 46
3914 OPC_CheckField, 20, 1, 0, // 5658: check Inst[20] == 0x0
3915 OPC_CheckField, 7, 1, 0, // 5662: check Inst[7] == 0x0
3916 OPC_Decode, 228, 118, 50, // 5666: decode to PADD_DB using decoder 50
3917 // 5666: }
3918 1, 0, // 5670: case 0x1: {
3919 OPC_CheckPredicate, 46, // 5672: check predicate 46
3920 OPC_CheckField, 20, 1, 1, // 5674: check Inst[20] == 0x1
3921 OPC_CheckField, 7, 1, 0, // 5678: check Inst[7] == 0x0
3922 OPC_Decode, 145, 121, 50, // 5682: decode to PSA_DHX using decoder 50
3923 // 5682: }
3924 // 5682: } // switch Inst[15]
3925 // 5682: }
3926 67, 18, // 5686: case 0x43: {
3927 OPC_CheckPredicate, 46, // 5688: check predicate 46
3928 OPC_CheckField, 20, 1, 0, // 5690: check Inst[20] == 0x0
3929 OPC_CheckField, 15, 1, 0, // 5694: check Inst[15] == 0x0
3930 OPC_CheckField, 7, 1, 0, // 5698: check Inst[7] == 0x0
3931 OPC_Decode, 191, 107, 50, // 5702: decode to ADDD using decoder 50
3932 // 5702: }
3933 72, 48, // 5706: case 0x48: {
3934 OPC_SwitchField, 15, 1, // 5708: switch Inst[15] {
3935 0, 14, // 5711: case 0x0: {
3936 OPC_CheckPredicate, 46, // 5713: check predicate 46
3937 OPC_CheckField, 20, 1, 0, // 5715: check Inst[20] == 0x0
3938 OPC_CheckField, 7, 1, 0, // 5719: check Inst[7] == 0x0
3939 OPC_Decode, 134, 121, 50, // 5723: decode to PSADD_DH using decoder 50
3940 // 5723: }
3941 1, 0, // 5727: case 0x1: {
3942 OPC_SwitchField, 20, 1, // 5729: switch Inst[20] {
3943 0, 10, // 5732: case 0x0: {
3944 OPC_CheckPredicate, 46, // 5734: check predicate 46
3945 OPC_CheckField, 7, 1, 0, // 5736: check Inst[7] == 0x0
3946 OPC_Decode, 219, 120, 50, // 5740: decode to PPAIREO_DB using decoder 50
3947 // 5740: }
3948 1, 0, // 5744: case 0x1: {
3949 OPC_CheckPredicate, 46, // 5746: check predicate 46
3950 OPC_CheckField, 7, 1, 0, // 5748: check Inst[7] == 0x0
3951 OPC_Decode, 138, 121, 50, // 5752: decode to PSAS_DHX using decoder 50
3952 // 5752: }
3953 // 5752: } // switch Inst[20]
3954 // 5752: }
3955 // 5752: } // switch Inst[15]
3956 // 5752: }
3957 73, 35, // 5756: case 0x49: {
3958 OPC_SwitchField, 15, 1, // 5758: switch Inst[15] {
3959 0, 14, // 5761: case 0x0: {
3960 OPC_CheckPredicate, 46, // 5763: check predicate 46
3961 OPC_CheckField, 20, 1, 0, // 5765: check Inst[20] == 0x0
3962 OPC_CheckField, 7, 1, 0, // 5769: check Inst[7] == 0x0
3963 OPC_Decode, 135, 121, 50, // 5773: decode to PSADD_DW using decoder 50
3964 // 5773: }
3965 1, 0, // 5777: case 0x1: {
3966 OPC_CheckPredicate, 46, // 5779: check predicate 46
3967 OPC_CheckField, 20, 1, 0, // 5781: check Inst[20] == 0x0
3968 OPC_CheckField, 7, 1, 0, // 5785: check Inst[7] == 0x0
3969 OPC_Decode, 220, 120, 50, // 5789: decode to PPAIREO_DH using decoder 50
3970 // 5789: }
3971 // 5789: } // switch Inst[15]
3972 // 5789: }
3973 74, 35, // 5793: case 0x4a: {
3974 OPC_SwitchField, 15, 1, // 5795: switch Inst[15] {
3975 0, 14, // 5798: case 0x0: {
3976 OPC_CheckPredicate, 46, // 5800: check predicate 46
3977 OPC_CheckField, 20, 1, 0, // 5802: check Inst[20] == 0x0
3978 OPC_CheckField, 7, 1, 0, // 5806: check Inst[7] == 0x0
3979 OPC_Decode, 133, 121, 50, // 5810: decode to PSADD_DB using decoder 50
3980 // 5810: }
3981 1, 0, // 5814: case 0x1: {
3982 OPC_CheckPredicate, 46, // 5816: check predicate 46
3983 OPC_CheckField, 20, 1, 1, // 5818: check Inst[20] == 0x1
3984 OPC_CheckField, 7, 1, 0, // 5822: check Inst[7] == 0x0
3985 OPC_Decode, 198, 121, 50, // 5826: decode to PSSA_DHX using decoder 50
3986 // 5826: }
3987 // 5826: } // switch Inst[15]
3988 // 5826: }
3989 76, 35, // 5830: case 0x4c: {
3990 OPC_SwitchField, 15, 1, // 5832: switch Inst[15] {
3991 0, 14, // 5835: case 0x0: {
3992 OPC_CheckPredicate, 46, // 5837: check predicate 46
3993 OPC_CheckField, 20, 1, 0, // 5839: check Inst[20] == 0x0
3994 OPC_CheckField, 7, 1, 0, // 5843: check Inst[7] == 0x0
3995 OPC_Decode, 205, 118, 50, // 5847: decode to PAADD_DH using decoder 50
3996 // 5847: }
3997 1, 0, // 5851: case 0x1: {
3998 OPC_CheckPredicate, 46, // 5853: check predicate 46
3999 OPC_CheckField, 20, 1, 1, // 5855: check Inst[20] == 0x1
4000 OPC_CheckField, 7, 1, 0, // 5859: check Inst[7] == 0x0
4001 OPC_Decode, 209, 118, 50, // 5863: decode to PAAS_DHX using decoder 50
4002 // 5863: }
4003 // 5863: } // switch Inst[15]
4004 // 5863: }
4005 77, 18, // 5867: case 0x4d: {
4006 OPC_CheckPredicate, 46, // 5869: check predicate 46
4007 OPC_CheckField, 20, 1, 0, // 5871: check Inst[20] == 0x0
4008 OPC_CheckField, 15, 1, 0, // 5875: check Inst[15] == 0x0
4009 OPC_CheckField, 7, 1, 0, // 5879: check Inst[7] == 0x0
4010 OPC_Decode, 206, 118, 50, // 5883: decode to PAADD_DW using decoder 50
4011 // 5883: }
4012 78, 35, // 5887: case 0x4e: {
4013 OPC_SwitchField, 15, 1, // 5889: switch Inst[15] {
4014 0, 14, // 5892: case 0x0: {
4015 OPC_CheckPredicate, 46, // 5894: check predicate 46
4016 OPC_CheckField, 20, 1, 0, // 5896: check Inst[20] == 0x0
4017 OPC_CheckField, 7, 1, 0, // 5900: check Inst[7] == 0x0
4018 OPC_Decode, 204, 118, 50, // 5904: decode to PAADD_DB using decoder 50
4019 // 5904: }
4020 1, 0, // 5908: case 0x1: {
4021 OPC_CheckPredicate, 46, // 5910: check predicate 46
4022 OPC_CheckField, 20, 1, 1, // 5912: check Inst[20] == 0x1
4023 OPC_CheckField, 7, 1, 0, // 5916: check Inst[7] == 0x0
4024 OPC_Decode, 238, 118, 50, // 5920: decode to PASA_DHX using decoder 50
4025 // 5920: }
4026 // 5920: } // switch Inst[15]
4027 // 5920: }
4028 80, 35, // 5924: case 0x50: {
4029 OPC_SwitchField, 15, 1, // 5926: switch Inst[15] {
4030 0, 14, // 5929: case 0x0: {
4031 OPC_CheckPredicate, 46, // 5931: check predicate 46
4032 OPC_CheckField, 20, 1, 1, // 5933: check Inst[20] == 0x1
4033 OPC_CheckField, 7, 1, 0, // 5937: check Inst[7] == 0x0
4034 OPC_Decode, 154, 121, 50, // 5941: decode to PSH1ADD_DH using decoder 50
4035 // 5941: }
4036 1, 0, // 5945: case 0x1: {
4037 OPC_CheckPredicate, 46, // 5947: check predicate 46
4038 OPC_CheckField, 20, 1, 0, // 5949: check Inst[20] == 0x0
4039 OPC_CheckField, 7, 1, 0, // 5953: check Inst[7] == 0x0
4040 OPC_Decode, 228, 120, 50, // 5957: decode to PPAIROE_DB using decoder 50
4041 // 5957: }
4042 // 5957: } // switch Inst[15]
4043 // 5957: }
4044 81, 35, // 5961: case 0x51: {
4045 OPC_SwitchField, 15, 1, // 5963: switch Inst[15] {
4046 0, 14, // 5966: case 0x0: {
4047 OPC_CheckPredicate, 46, // 5968: check predicate 46
4048 OPC_CheckField, 20, 1, 1, // 5970: check Inst[20] == 0x1
4049 OPC_CheckField, 7, 1, 0, // 5974: check Inst[7] == 0x0
4050 OPC_Decode, 155, 121, 50, // 5978: decode to PSH1ADD_DW using decoder 50
4051 // 5978: }
4052 1, 0, // 5982: case 0x1: {
4053 OPC_CheckPredicate, 46, // 5984: check predicate 46
4054 OPC_CheckField, 20, 1, 0, // 5986: check Inst[20] == 0x0
4055 OPC_CheckField, 7, 1, 0, // 5990: check Inst[7] == 0x0
4056 OPC_Decode, 229, 120, 50, // 5994: decode to PPAIROE_DH using decoder 50
4057 // 5994: }
4058 // 5994: } // switch Inst[15]
4059 // 5994: }
4060 88, 48, // 5998: case 0x58: {
4061 OPC_SwitchField, 15, 1, // 6000: switch Inst[15] {
4062 0, 27, // 6003: case 0x0: {
4063 OPC_SwitchField, 20, 1, // 6005: switch Inst[20] {
4064 0, 10, // 6008: case 0x0: {
4065 OPC_CheckPredicate, 46, // 6010: check predicate 46
4066 OPC_CheckField, 7, 1, 0, // 6012: check Inst[7] == 0x0
4067 OPC_Decode, 128, 121, 50, // 6016: decode to PSADDU_DH using decoder 50
4068 // 6016: }
4069 1, 0, // 6020: case 0x1: {
4070 OPC_CheckPredicate, 46, // 6022: check predicate 46
4071 OPC_CheckField, 7, 1, 0, // 6024: check Inst[7] == 0x0
4072 OPC_Decode, 201, 121, 50, // 6028: decode to PSSH1SADD_DH using decoder 50
4073 // 6028: }
4074 // 6028: } // switch Inst[20]
4075 // 6028: }
4076 1, 0, // 6032: case 0x1: {
4077 OPC_CheckPredicate, 46, // 6034: check predicate 46
4078 OPC_CheckField, 20, 1, 0, // 6036: check Inst[20] == 0x0
4079 OPC_CheckField, 7, 1, 0, // 6040: check Inst[7] == 0x0
4080 OPC_Decode, 233, 120, 50, // 6044: decode to PPAIRO_DB using decoder 50
4081 // 6044: }
4082 // 6044: } // switch Inst[15]
4083 // 6044: }
4084 89, 48, // 6048: case 0x59: {
4085 OPC_SwitchField, 15, 1, // 6050: switch Inst[15] {
4086 0, 27, // 6053: case 0x0: {
4087 OPC_SwitchField, 20, 1, // 6055: switch Inst[20] {
4088 0, 10, // 6058: case 0x0: {
4089 OPC_CheckPredicate, 46, // 6060: check predicate 46
4090 OPC_CheckField, 7, 1, 0, // 6062: check Inst[7] == 0x0
4091 OPC_Decode, 129, 121, 50, // 6066: decode to PSADDU_DW using decoder 50
4092 // 6066: }
4093 1, 0, // 6070: case 0x1: {
4094 OPC_CheckPredicate, 46, // 6072: check predicate 46
4095 OPC_CheckField, 7, 1, 0, // 6074: check Inst[7] == 0x0
4096 OPC_Decode, 202, 121, 50, // 6078: decode to PSSH1SADD_DW using decoder 50
4097 // 6078: }
4098 // 6078: } // switch Inst[20]
4099 // 6078: }
4100 1, 0, // 6082: case 0x1: {
4101 OPC_CheckPredicate, 46, // 6084: check predicate 46
4102 OPC_CheckField, 20, 1, 0, // 6086: check Inst[20] == 0x0
4103 OPC_CheckField, 7, 1, 0, // 6090: check Inst[7] == 0x0
4104 OPC_Decode, 234, 120, 50, // 6094: decode to PPAIRO_DH using decoder 50
4105 // 6094: }
4106 // 6094: } // switch Inst[15]
4107 // 6094: }
4108 90, 18, // 6098: case 0x5a: {
4109 OPC_CheckPredicate, 46, // 6100: check predicate 46
4110 OPC_CheckField, 20, 1, 0, // 6102: check Inst[20] == 0x0
4111 OPC_CheckField, 15, 1, 0, // 6106: check Inst[15] == 0x0
4112 OPC_CheckField, 7, 1, 0, // 6110: check Inst[7] == 0x0
4113 OPC_Decode, 255, 120, 50, // 6114: decode to PSADDU_DB using decoder 50
4114 // 6114: }
4115 92, 18, // 6118: case 0x5c: {
4116 OPC_CheckPredicate, 46, // 6120: check predicate 46
4117 OPC_CheckField, 20, 1, 0, // 6122: check Inst[20] == 0x0
4118 OPC_CheckField, 15, 1, 0, // 6126: check Inst[15] == 0x0
4119 OPC_CheckField, 7, 1, 0, // 6130: check Inst[7] == 0x0
4120 OPC_Decode, 199, 118, 50, // 6134: decode to PAADDU_DH using decoder 50
4121 // 6134: }
4122 93, 18, // 6138: case 0x5d: {
4123 OPC_CheckPredicate, 46, // 6140: check predicate 46
4124 OPC_CheckField, 20, 1, 0, // 6142: check Inst[20] == 0x0
4125 OPC_CheckField, 15, 1, 0, // 6146: check Inst[15] == 0x0
4126 OPC_CheckField, 7, 1, 0, // 6150: check Inst[7] == 0x0
4127 OPC_Decode, 200, 118, 50, // 6154: decode to PAADDU_DW using decoder 50
4128 // 6154: }
4129 94, 18, // 6158: case 0x5e: {
4130 OPC_CheckPredicate, 46, // 6160: check predicate 46
4131 OPC_CheckField, 20, 1, 0, // 6162: check Inst[20] == 0x0
4132 OPC_CheckField, 15, 1, 0, // 6166: check Inst[15] == 0x0
4133 OPC_CheckField, 7, 1, 0, // 6170: check Inst[7] == 0x0
4134 OPC_Decode, 198, 118, 50, // 6174: decode to PAADDU_DB using decoder 50
4135 // 6174: }
4136 96, 35, // 6178: case 0x60: {
4137 OPC_SwitchField, 15, 1, // 6180: switch Inst[15] {
4138 0, 14, // 6183: case 0x0: {
4139 OPC_CheckPredicate, 46, // 6185: check predicate 46
4140 OPC_CheckField, 20, 1, 0, // 6187: check Inst[20] == 0x0
4141 OPC_CheckField, 7, 1, 0, // 6191: check Inst[7] == 0x0
4142 OPC_Decode, 239, 121, 50, // 6195: decode to PSUB_DH using decoder 50
4143 // 6195: }
4144 1, 0, // 6199: case 0x1: {
4145 OPC_CheckPredicate, 46, // 6201: check predicate 46
4146 OPC_CheckField, 20, 1, 1, // 6203: check Inst[20] == 0x1
4147 OPC_CheckField, 7, 1, 0, // 6207: check Inst[7] == 0x0
4148 OPC_Decode, 128, 120, 50, // 6211: decode to PMSEQ_DH using decoder 50
4149 // 6211: }
4150 // 6211: } // switch Inst[15]
4151 // 6211: }
4152 97, 35, // 6215: case 0x61: {
4153 OPC_SwitchField, 15, 1, // 6217: switch Inst[15] {
4154 0, 14, // 6220: case 0x0: {
4155 OPC_CheckPredicate, 46, // 6222: check predicate 46
4156 OPC_CheckField, 20, 1, 0, // 6224: check Inst[20] == 0x0
4157 OPC_CheckField, 7, 1, 0, // 6228: check Inst[7] == 0x0
4158 OPC_Decode, 240, 121, 50, // 6232: decode to PSUB_DW using decoder 50
4159 // 6232: }
4160 1, 0, // 6236: case 0x1: {
4161 OPC_CheckPredicate, 46, // 6238: check predicate 46
4162 OPC_CheckField, 20, 1, 1, // 6240: check Inst[20] == 0x1
4163 OPC_CheckField, 7, 1, 0, // 6244: check Inst[7] == 0x0
4164 OPC_Decode, 129, 120, 50, // 6248: decode to PMSEQ_DW using decoder 50
4165 // 6248: }
4166 // 6248: } // switch Inst[15]
4167 // 6248: }
4168 98, 35, // 6252: case 0x62: {
4169 OPC_SwitchField, 15, 1, // 6254: switch Inst[15] {
4170 0, 14, // 6257: case 0x0: {
4171 OPC_CheckPredicate, 46, // 6259: check predicate 46
4172 OPC_CheckField, 20, 1, 0, // 6261: check Inst[20] == 0x0
4173 OPC_CheckField, 7, 1, 0, // 6265: check Inst[7] == 0x0
4174 OPC_Decode, 238, 121, 50, // 6269: decode to PSUB_DB using decoder 50
4175 // 6269: }
4176 1, 0, // 6273: case 0x1: {
4177 OPC_CheckPredicate, 46, // 6275: check predicate 46
4178 OPC_CheckField, 20, 1, 1, // 6277: check Inst[20] == 0x1
4179 OPC_CheckField, 7, 1, 0, // 6281: check Inst[7] == 0x0
4180 OPC_Decode, 255, 119, 50, // 6285: decode to PMSEQ_DB using decoder 50
4181 // 6285: }
4182 // 6285: } // switch Inst[15]
4183 // 6285: }
4184 99, 18, // 6289: case 0x63: {
4185 OPC_CheckPredicate, 46, // 6291: check predicate 46
4186 OPC_CheckField, 20, 1, 0, // 6293: check Inst[20] == 0x0
4187 OPC_CheckField, 15, 1, 0, // 6297: check Inst[15] == 0x0
4188 OPC_CheckField, 7, 1, 0, // 6301: check Inst[7] == 0x0
4189 OPC_Decode, 135, 125, 50, // 6305: decode to SUBD using decoder 50
4190 // 6305: }
4191 100, 18, // 6309: case 0x64: {
4192 OPC_CheckPredicate, 46, // 6311: check predicate 46
4193 OPC_CheckField, 20, 1, 0, // 6313: check Inst[20] == 0x0
4194 OPC_CheckField, 15, 1, 0, // 6317: check Inst[15] == 0x0
4195 OPC_CheckField, 7, 1, 0, // 6321: check Inst[7] == 0x0
4196 OPC_Decode, 220, 118, 50, // 6325: decode to PABD_DH using decoder 50
4197 // 6325: }
4198 102, 18, // 6329: case 0x66: {
4199 OPC_CheckPredicate, 46, // 6331: check predicate 46
4200 OPC_CheckField, 20, 1, 0, // 6333: check Inst[20] == 0x0
4201 OPC_CheckField, 15, 1, 0, // 6337: check Inst[15] == 0x0
4202 OPC_CheckField, 7, 1, 0, // 6341: check Inst[7] == 0x0
4203 OPC_Decode, 219, 118, 50, // 6345: decode to PABD_DB using decoder 50
4204 // 6345: }
4205 104, 35, // 6349: case 0x68: {
4206 OPC_SwitchField, 15, 1, // 6351: switch Inst[15] {
4207 0, 14, // 6354: case 0x0: {
4208 OPC_CheckPredicate, 46, // 6356: check predicate 46
4209 OPC_CheckField, 20, 1, 0, // 6358: check Inst[20] == 0x0
4210 OPC_CheckField, 7, 1, 0, // 6362: check Inst[7] == 0x0
4211 OPC_Decode, 233, 121, 50, // 6366: decode to PSSUB_DH using decoder 50
4212 // 6366: }
4213 1, 0, // 6370: case 0x1: {
4214 OPC_CheckPredicate, 46, // 6372: check predicate 46
4215 OPC_CheckField, 20, 1, 1, // 6374: check Inst[20] == 0x1
4216 OPC_CheckField, 7, 1, 0, // 6378: check Inst[7] == 0x0
4217 OPC_Decode, 140, 120, 50, // 6382: decode to PMSLT_DH using decoder 50
4218 // 6382: }
4219 // 6382: } // switch Inst[15]
4220 // 6382: }
4221 105, 35, // 6386: case 0x69: {
4222 OPC_SwitchField, 15, 1, // 6388: switch Inst[15] {
4223 0, 14, // 6391: case 0x0: {
4224 OPC_CheckPredicate, 46, // 6393: check predicate 46
4225 OPC_CheckField, 20, 1, 0, // 6395: check Inst[20] == 0x0
4226 OPC_CheckField, 7, 1, 0, // 6399: check Inst[7] == 0x0
4227 OPC_Decode, 234, 121, 50, // 6403: decode to PSSUB_DW using decoder 50
4228 // 6403: }
4229 1, 0, // 6407: case 0x1: {
4230 OPC_CheckPredicate, 46, // 6409: check predicate 46
4231 OPC_CheckField, 20, 1, 1, // 6411: check Inst[20] == 0x1
4232 OPC_CheckField, 7, 1, 0, // 6415: check Inst[7] == 0x0
4233 OPC_Decode, 141, 120, 50, // 6419: decode to PMSLT_DW using decoder 50
4234 // 6419: }
4235 // 6419: } // switch Inst[15]
4236 // 6419: }
4237 106, 35, // 6423: case 0x6a: {
4238 OPC_SwitchField, 15, 1, // 6425: switch Inst[15] {
4239 0, 14, // 6428: case 0x0: {
4240 OPC_CheckPredicate, 46, // 6430: check predicate 46
4241 OPC_CheckField, 20, 1, 0, // 6432: check Inst[20] == 0x0
4242 OPC_CheckField, 7, 1, 0, // 6436: check Inst[7] == 0x0
4243 OPC_Decode, 232, 121, 50, // 6440: decode to PSSUB_DB using decoder 50
4244 // 6440: }
4245 1, 0, // 6444: case 0x1: {
4246 OPC_CheckPredicate, 46, // 6446: check predicate 46
4247 OPC_CheckField, 20, 1, 1, // 6448: check Inst[20] == 0x1
4248 OPC_CheckField, 7, 1, 0, // 6452: check Inst[7] == 0x0
4249 OPC_Decode, 139, 120, 50, // 6456: decode to PMSLT_DB using decoder 50
4250 // 6456: }
4251 // 6456: } // switch Inst[15]
4252 // 6456: }
4253 108, 35, // 6460: case 0x6c: {
4254 OPC_SwitchField, 15, 1, // 6462: switch Inst[15] {
4255 0, 14, // 6465: case 0x0: {
4256 OPC_CheckPredicate, 46, // 6467: check predicate 46
4257 OPC_CheckField, 20, 1, 0, // 6469: check Inst[20] == 0x0
4258 OPC_CheckField, 7, 1, 0, // 6473: check Inst[7] == 0x0
4259 OPC_Decode, 249, 118, 50, // 6477: decode to PASUB_DH using decoder 50
4260 // 6477: }
4261 1, 0, // 6481: case 0x1: {
4262 OPC_CheckPredicate, 46, // 6483: check predicate 46
4263 OPC_CheckField, 20, 1, 1, // 6485: check Inst[20] == 0x1
4264 OPC_CheckField, 7, 1, 0, // 6489: check Inst[7] == 0x0
4265 OPC_Decode, 134, 120, 50, // 6493: decode to PMSLTU_DH using decoder 50
4266 // 6493: }
4267 // 6493: } // switch Inst[15]
4268 // 6493: }
4269 109, 35, // 6497: case 0x6d: {
4270 OPC_SwitchField, 15, 1, // 6499: switch Inst[15] {
4271 0, 14, // 6502: case 0x0: {
4272 OPC_CheckPredicate, 46, // 6504: check predicate 46
4273 OPC_CheckField, 20, 1, 0, // 6506: check Inst[20] == 0x0
4274 OPC_CheckField, 7, 1, 0, // 6510: check Inst[7] == 0x0
4275 OPC_Decode, 250, 118, 50, // 6514: decode to PASUB_DW using decoder 50
4276 // 6514: }
4277 1, 0, // 6518: case 0x1: {
4278 OPC_CheckPredicate, 46, // 6520: check predicate 46
4279 OPC_CheckField, 20, 1, 1, // 6522: check Inst[20] == 0x1
4280 OPC_CheckField, 7, 1, 0, // 6526: check Inst[7] == 0x0
4281 OPC_Decode, 135, 120, 50, // 6530: decode to PMSLTU_DW using decoder 50
4282 // 6530: }
4283 // 6530: } // switch Inst[15]
4284 // 6530: }
4285 110, 35, // 6534: case 0x6e: {
4286 OPC_SwitchField, 15, 1, // 6536: switch Inst[15] {
4287 0, 14, // 6539: case 0x0: {
4288 OPC_CheckPredicate, 46, // 6541: check predicate 46
4289 OPC_CheckField, 20, 1, 0, // 6543: check Inst[20] == 0x0
4290 OPC_CheckField, 7, 1, 0, // 6547: check Inst[7] == 0x0
4291 OPC_Decode, 248, 118, 50, // 6551: decode to PASUB_DB using decoder 50
4292 // 6551: }
4293 1, 0, // 6555: case 0x1: {
4294 OPC_CheckPredicate, 46, // 6557: check predicate 46
4295 OPC_CheckField, 20, 1, 1, // 6559: check Inst[20] == 0x1
4296 OPC_CheckField, 7, 1, 0, // 6563: check Inst[7] == 0x0
4297 OPC_Decode, 133, 120, 50, // 6567: decode to PMSLTU_DB using decoder 50
4298 // 6567: }
4299 // 6567: } // switch Inst[15]
4300 // 6567: }
4301 112, 18, // 6571: case 0x70: {
4302 OPC_CheckPredicate, 46, // 6573: check predicate 46
4303 OPC_CheckField, 20, 1, 1, // 6575: check Inst[20] == 0x1
4304 OPC_CheckField, 15, 1, 1, // 6579: check Inst[15] == 0x1
4305 OPC_CheckField, 7, 1, 0, // 6583: check Inst[7] == 0x0
4306 OPC_Decode, 234, 119, 50, // 6587: decode to PMIN_DH using decoder 50
4307 // 6587: }
4308 113, 18, // 6591: case 0x71: {
4309 OPC_CheckPredicate, 46, // 6593: check predicate 46
4310 OPC_CheckField, 20, 1, 1, // 6595: check Inst[20] == 0x1
4311 OPC_CheckField, 15, 1, 1, // 6599: check Inst[15] == 0x1
4312 OPC_CheckField, 7, 1, 0, // 6603: check Inst[7] == 0x0
4313 OPC_Decode, 235, 119, 50, // 6607: decode to PMIN_DW using decoder 50
4314 // 6607: }
4315 114, 18, // 6611: case 0x72: {
4316 OPC_CheckPredicate, 46, // 6613: check predicate 46
4317 OPC_CheckField, 20, 1, 1, // 6615: check Inst[20] == 0x1
4318 OPC_CheckField, 15, 1, 1, // 6619: check Inst[15] == 0x1
4319 OPC_CheckField, 7, 1, 0, // 6623: check Inst[7] == 0x0
4320 OPC_Decode, 233, 119, 50, // 6627: decode to PMIN_DB using decoder 50
4321 // 6627: }
4322 116, 35, // 6631: case 0x74: {
4323 OPC_SwitchField, 15, 1, // 6633: switch Inst[15] {
4324 0, 14, // 6636: case 0x0: {
4325 OPC_CheckPredicate, 46, // 6638: check predicate 46
4326 OPC_CheckField, 20, 1, 0, // 6640: check Inst[20] == 0x0
4327 OPC_CheckField, 7, 1, 0, // 6644: check Inst[7] == 0x0
4328 OPC_Decode, 216, 118, 50, // 6648: decode to PABDU_DH using decoder 50
4329 // 6648: }
4330 1, 0, // 6652: case 0x1: {
4331 OPC_CheckPredicate, 46, // 6654: check predicate 46
4332 OPC_CheckField, 20, 1, 1, // 6656: check Inst[20] == 0x1
4333 OPC_CheckField, 7, 1, 0, // 6660: check Inst[7] == 0x0
4334 OPC_Decode, 228, 119, 50, // 6664: decode to PMINU_DH using decoder 50
4335 // 6664: }
4336 // 6664: } // switch Inst[15]
4337 // 6664: }
4338 117, 18, // 6668: case 0x75: {
4339 OPC_CheckPredicate, 46, // 6670: check predicate 46
4340 OPC_CheckField, 20, 1, 1, // 6672: check Inst[20] == 0x1
4341 OPC_CheckField, 15, 1, 1, // 6676: check Inst[15] == 0x1
4342 OPC_CheckField, 7, 1, 0, // 6680: check Inst[7] == 0x0
4343 OPC_Decode, 229, 119, 50, // 6684: decode to PMINU_DW using decoder 50
4344 // 6684: }
4345 118, 35, // 6688: case 0x76: {
4346 OPC_SwitchField, 15, 1, // 6690: switch Inst[15] {
4347 0, 14, // 6693: case 0x0: {
4348 OPC_CheckPredicate, 46, // 6695: check predicate 46
4349 OPC_CheckField, 20, 1, 0, // 6697: check Inst[20] == 0x0
4350 OPC_CheckField, 7, 1, 0, // 6701: check Inst[7] == 0x0
4351 OPC_Decode, 215, 118, 50, // 6705: decode to PABDU_DB using decoder 50
4352 // 6705: }
4353 1, 0, // 6709: case 0x1: {
4354 OPC_CheckPredicate, 46, // 6711: check predicate 46
4355 OPC_CheckField, 20, 1, 1, // 6713: check Inst[20] == 0x1
4356 OPC_CheckField, 7, 1, 0, // 6717: check Inst[7] == 0x0
4357 OPC_Decode, 227, 119, 50, // 6721: decode to PMINU_DB using decoder 50
4358 // 6721: }
4359 // 6721: } // switch Inst[15]
4360 // 6721: }
4361 120, 35, // 6725: case 0x78: {
4362 OPC_SwitchField, 15, 1, // 6727: switch Inst[15] {
4363 0, 14, // 6730: case 0x0: {
4364 OPC_CheckPredicate, 46, // 6732: check predicate 46
4365 OPC_CheckField, 20, 1, 0, // 6734: check Inst[20] == 0x0
4366 OPC_CheckField, 7, 1, 0, // 6738: check Inst[7] == 0x0
4367 OPC_Decode, 227, 121, 50, // 6742: decode to PSSUBU_DH using decoder 50
4368 // 6742: }
4369 1, 0, // 6746: case 0x1: {
4370 OPC_CheckPredicate, 46, // 6748: check predicate 46
4371 OPC_CheckField, 20, 1, 1, // 6750: check Inst[20] == 0x1
4372 OPC_CheckField, 7, 1, 0, // 6754: check Inst[7] == 0x0
4373 OPC_Decode, 202, 119, 50, // 6758: decode to PMAX_DH using decoder 50
4374 // 6758: }
4375 // 6758: } // switch Inst[15]
4376 // 6758: }
4377 121, 35, // 6762: case 0x79: {
4378 OPC_SwitchField, 15, 1, // 6764: switch Inst[15] {
4379 0, 14, // 6767: case 0x0: {
4380 OPC_CheckPredicate, 46, // 6769: check predicate 46
4381 OPC_CheckField, 20, 1, 0, // 6771: check Inst[20] == 0x0
4382 OPC_CheckField, 7, 1, 0, // 6775: check Inst[7] == 0x0
4383 OPC_Decode, 228, 121, 50, // 6779: decode to PSSUBU_DW using decoder 50
4384 // 6779: }
4385 1, 0, // 6783: case 0x1: {
4386 OPC_CheckPredicate, 46, // 6785: check predicate 46
4387 OPC_CheckField, 20, 1, 1, // 6787: check Inst[20] == 0x1
4388 OPC_CheckField, 7, 1, 0, // 6791: check Inst[7] == 0x0
4389 OPC_Decode, 203, 119, 50, // 6795: decode to PMAX_DW using decoder 50
4390 // 6795: }
4391 // 6795: } // switch Inst[15]
4392 // 6795: }
4393 122, 35, // 6799: case 0x7a: {
4394 OPC_SwitchField, 15, 1, // 6801: switch Inst[15] {
4395 0, 14, // 6804: case 0x0: {
4396 OPC_CheckPredicate, 46, // 6806: check predicate 46
4397 OPC_CheckField, 20, 1, 0, // 6808: check Inst[20] == 0x0
4398 OPC_CheckField, 7, 1, 0, // 6812: check Inst[7] == 0x0
4399 OPC_Decode, 226, 121, 50, // 6816: decode to PSSUBU_DB using decoder 50
4400 // 6816: }
4401 1, 0, // 6820: case 0x1: {
4402 OPC_CheckPredicate, 46, // 6822: check predicate 46
4403 OPC_CheckField, 20, 1, 1, // 6824: check Inst[20] == 0x1
4404 OPC_CheckField, 7, 1, 0, // 6828: check Inst[7] == 0x0
4405 OPC_Decode, 201, 119, 50, // 6832: decode to PMAX_DB using decoder 50
4406 // 6832: }
4407 // 6832: } // switch Inst[15]
4408 // 6832: }
4409 124, 35, // 6836: case 0x7c: {
4410 OPC_SwitchField, 15, 1, // 6838: switch Inst[15] {
4411 0, 14, // 6841: case 0x0: {
4412 OPC_CheckPredicate, 46, // 6843: check predicate 46
4413 OPC_CheckField, 20, 1, 0, // 6845: check Inst[20] == 0x0
4414 OPC_CheckField, 7, 1, 0, // 6849: check Inst[7] == 0x0
4415 OPC_Decode, 243, 118, 50, // 6853: decode to PASUBU_DH using decoder 50
4416 // 6853: }
4417 1, 0, // 6857: case 0x1: {
4418 OPC_CheckPredicate, 46, // 6859: check predicate 46
4419 OPC_CheckField, 20, 1, 1, // 6861: check Inst[20] == 0x1
4420 OPC_CheckField, 7, 1, 0, // 6865: check Inst[7] == 0x0
4421 OPC_Decode, 196, 119, 50, // 6869: decode to PMAXU_DH using decoder 50
4422 // 6869: }
4423 // 6869: } // switch Inst[15]
4424 // 6869: }
4425 125, 35, // 6873: case 0x7d: {
4426 OPC_SwitchField, 15, 1, // 6875: switch Inst[15] {
4427 0, 14, // 6878: case 0x0: {
4428 OPC_CheckPredicate, 46, // 6880: check predicate 46
4429 OPC_CheckField, 20, 1, 0, // 6882: check Inst[20] == 0x0
4430 OPC_CheckField, 7, 1, 0, // 6886: check Inst[7] == 0x0
4431 OPC_Decode, 244, 118, 50, // 6890: decode to PASUBU_DW using decoder 50
4432 // 6890: }
4433 1, 0, // 6894: case 0x1: {
4434 OPC_CheckPredicate, 46, // 6896: check predicate 46
4435 OPC_CheckField, 20, 1, 1, // 6898: check Inst[20] == 0x1
4436 OPC_CheckField, 7, 1, 0, // 6902: check Inst[7] == 0x0
4437 OPC_Decode, 197, 119, 50, // 6906: decode to PMAXU_DW using decoder 50
4438 // 6906: }
4439 // 6906: } // switch Inst[15]
4440 // 6906: }
4441 126, 0, // 6910: case 0x7e: {
4442 OPC_SwitchField, 15, 1, // 6912: switch Inst[15] {
4443 0, 14, // 6915: case 0x0: {
4444 OPC_CheckPredicate, 46, // 6917: check predicate 46
4445 OPC_CheckField, 20, 1, 0, // 6919: check Inst[20] == 0x0
4446 OPC_CheckField, 7, 1, 0, // 6923: check Inst[7] == 0x0
4447 OPC_Decode, 242, 118, 50, // 6927: decode to PASUBU_DB using decoder 50
4448 // 6927: }
4449 1, 0, // 6931: case 0x1: {
4450 OPC_CheckPredicate, 46, // 6933: check predicate 46
4451 OPC_CheckField, 20, 1, 1, // 6935: check Inst[20] == 0x1
4452 OPC_CheckField, 7, 1, 0, // 6939: check Inst[7] == 0x0
4453 OPC_Decode, 195, 119, 50, // 6943: decode to PMAXU_DB using decoder 50
4454 // 6943: }
4455 // 6943: } // switch Inst[15]
4456 // 6943: }
4457 // 6943: } // switch Inst[31:25]
4458 // 6943: }
4459 // 6943: } // switch Inst[14:12]
4460 // 6943: }
4461 35, 29, // 6947: case 0x23: {
4462 OPC_SwitchField, 12, 3, // 6949: switch Inst[14:12] {
4463 0, 4, // 6952: case 0x0: {
4464 OPC_Decode, 207, 123, 51, // 6954: decode to SB using decoder 51
4465 // 6954: }
4466 1, 4, // 6958: case 0x1: {
4467 OPC_Decode, 170, 124, 51, // 6960: decode to SH using decoder 51
4468 // 6960: }
4469 2, 4, // 6964: case 0x2: {
4470 OPC_Decode, 137, 125, 51, // 6966: decode to SW using decoder 51
4471 // 6966: }
4472 3, 0, // 6970: case 0x3: {
4473 OPC_CheckPredicate, 21, // 6972: check predicate 21
4474 OPC_Decode, 221, 123, 51, // 6974: decode to SD using decoder 51
4475 // 6974: }
4476 // 6974: } // switch Inst[14:12]
4477 // 6974: }
4478 39, 165, 11, // 6978: case 0x27: {
4479 OPC_SwitchField, 12, 3, // 6981: switch Inst[14:12] {
4480 0, 136, 3, // 6984: case 0x0: {
4481 OPC_SwitchField, 26, 6, // 6987: switch Inst[31:26] {
4482 0, 38, // 6990: case 0x0: {
4483 OPC_SwitchField, 20, 5, // 6992: switch Inst[24:20] {
4484 0, 7, // 6995: case 0x0: {
4485 OPC_CheckPredicate, 22, // 6997: check predicate 22
4486 OPC_Decode, 160, 130, 1, 1, // 6999: decode to VSE8_V using decoder 1
4487 // 6999: }
4488 8, 11, // 7004: case 0x8: {
4489 OPC_CheckPredicate, 22, // 7006: check predicate 22
4490 OPC_CheckField, 25, 1, 1, // 7008: check Inst[25] == 0x1
4491 OPC_Decode, 145, 130, 1, 2, // 7012: decode to VS1R_V using decoder 2
4492 // 7012: }
4493 11, 0, // 7017: case 0xb: {
4494 OPC_CheckPredicate, 22, // 7019: check predicate 22
4495 OPC_CheckField, 25, 1, 1, // 7021: check Inst[25] == 0x1
4496 OPC_Decode, 186, 130, 1, 2, // 7025: decode to VSM_V using decoder 2
4497 // 7025: }
4498 // 7025: } // switch Inst[24:20]
4499 // 7025: }
4500 1, 7, // 7030: case 0x1: {
4501 OPC_CheckPredicate, 22, // 7032: check predicate 22
4502 OPC_Decode, 172, 131, 1, 3, // 7034: decode to VSUXEI8_V using decoder 3
4503 // 7034: }
4504 2, 7, // 7039: case 0x2: {
4505 OPC_CheckPredicate, 22, // 7041: check predicate 22
4506 OPC_Decode, 228, 130, 1, 4, // 7043: decode to VSSE8_V using decoder 4
4507 // 7043: }
4508 3, 7, // 7048: case 0x3: {
4509 OPC_CheckPredicate, 22, // 7050: check predicate 22
4510 OPC_Decode, 190, 130, 1, 3, // 7052: decode to VSOXEI8_V using decoder 3
4511 // 7052: }
4512 8, 25, // 7057: case 0x8: {
4513 OPC_SwitchField, 20, 5, // 7059: switch Inst[24:20] {
4514 0, 7, // 7062: case 0x0: {
4515 OPC_CheckPredicate, 22, // 7064: check predicate 22
4516 OPC_Decode, 232, 130, 1, 1, // 7066: decode to VSSEG2E8_V using decoder 1
4517 // 7066: }
4518 8, 0, // 7071: case 0x8: {
4519 OPC_CheckPredicate, 22, // 7073: check predicate 22
4520 OPC_CheckField, 25, 1, 1, // 7075: check Inst[25] == 0x1
4521 OPC_Decode, 146, 130, 1, 5, // 7079: decode to VS2R_V using decoder 5
4522 // 7079: }
4523 // 7079: } // switch Inst[24:20]
4524 // 7079: }
4525 9, 7, // 7084: case 0x9: {
4526 OPC_CheckPredicate, 22, // 7086: check predicate 22
4527 OPC_Decode, 176, 131, 1, 3, // 7088: decode to VSUXSEG2EI8_V using decoder 3
4528 // 7088: }
4529 10, 7, // 7093: case 0xa: {
4530 OPC_CheckPredicate, 22, // 7095: check predicate 22
4531 OPC_Decode, 138, 131, 1, 4, // 7097: decode to VSSSEG2E8_V using decoder 4
4532 // 7097: }
4533 11, 7, // 7102: case 0xb: {
4534 OPC_CheckPredicate, 22, // 7104: check predicate 22
4535 OPC_Decode, 194, 130, 1, 3, // 7106: decode to VSOXSEG2EI8_V using decoder 3
4536 // 7106: }
4537 16, 11, // 7111: case 0x10: {
4538 OPC_CheckPredicate, 22, // 7113: check predicate 22
4539 OPC_CheckField, 20, 5, 0, // 7115: check Inst[24:20] == 0x0
4540 OPC_Decode, 236, 130, 1, 1, // 7119: decode to VSSEG3E8_V using decoder 1
4541 // 7119: }
4542 17, 7, // 7124: case 0x11: {
4543 OPC_CheckPredicate, 22, // 7126: check predicate 22
4544 OPC_Decode, 180, 131, 1, 3, // 7128: decode to VSUXSEG3EI8_V using decoder 3
4545 // 7128: }
4546 18, 7, // 7133: case 0x12: {
4547 OPC_CheckPredicate, 22, // 7135: check predicate 22
4548 OPC_Decode, 142, 131, 1, 4, // 7137: decode to VSSSEG3E8_V using decoder 4
4549 // 7137: }
4550 19, 7, // 7142: case 0x13: {
4551 OPC_CheckPredicate, 22, // 7144: check predicate 22
4552 OPC_Decode, 198, 130, 1, 3, // 7146: decode to VSOXSEG3EI8_V using decoder 3
4553 // 7146: }
4554 24, 25, // 7151: case 0x18: {
4555 OPC_SwitchField, 20, 5, // 7153: switch Inst[24:20] {
4556 0, 7, // 7156: case 0x0: {
4557 OPC_CheckPredicate, 22, // 7158: check predicate 22
4558 OPC_Decode, 240, 130, 1, 1, // 7160: decode to VSSEG4E8_V using decoder 1
4559 // 7160: }
4560 8, 0, // 7165: case 0x8: {
4561 OPC_CheckPredicate, 22, // 7167: check predicate 22
4562 OPC_CheckField, 25, 1, 1, // 7169: check Inst[25] == 0x1
4563 OPC_Decode, 147, 130, 1, 6, // 7173: decode to VS4R_V using decoder 6
4564 // 7173: }
4565 // 7173: } // switch Inst[24:20]
4566 // 7173: }
4567 25, 7, // 7178: case 0x19: {
4568 OPC_CheckPredicate, 22, // 7180: check predicate 22
4569 OPC_Decode, 184, 131, 1, 3, // 7182: decode to VSUXSEG4EI8_V using decoder 3
4570 // 7182: }
4571 26, 7, // 7187: case 0x1a: {
4572 OPC_CheckPredicate, 22, // 7189: check predicate 22
4573 OPC_Decode, 146, 131, 1, 4, // 7191: decode to VSSSEG4E8_V using decoder 4
4574 // 7191: }
4575 27, 7, // 7196: case 0x1b: {
4576 OPC_CheckPredicate, 22, // 7198: check predicate 22
4577 OPC_Decode, 202, 130, 1, 3, // 7200: decode to VSOXSEG4EI8_V using decoder 3
4578 // 7200: }
4579 32, 11, // 7205: case 0x20: {
4580 OPC_CheckPredicate, 22, // 7207: check predicate 22
4581 OPC_CheckField, 20, 5, 0, // 7209: check Inst[24:20] == 0x0
4582 OPC_Decode, 244, 130, 1, 1, // 7213: decode to VSSEG5E8_V using decoder 1
4583 // 7213: }
4584 33, 7, // 7218: case 0x21: {
4585 OPC_CheckPredicate, 22, // 7220: check predicate 22
4586 OPC_Decode, 188, 131, 1, 3, // 7222: decode to VSUXSEG5EI8_V using decoder 3
4587 // 7222: }
4588 34, 7, // 7227: case 0x22: {
4589 OPC_CheckPredicate, 22, // 7229: check predicate 22
4590 OPC_Decode, 150, 131, 1, 4, // 7231: decode to VSSSEG5E8_V using decoder 4
4591 // 7231: }
4592 35, 7, // 7236: case 0x23: {
4593 OPC_CheckPredicate, 22, // 7238: check predicate 22
4594 OPC_Decode, 206, 130, 1, 3, // 7240: decode to VSOXSEG5EI8_V using decoder 3
4595 // 7240: }
4596 40, 11, // 7245: case 0x28: {
4597 OPC_CheckPredicate, 22, // 7247: check predicate 22
4598 OPC_CheckField, 20, 5, 0, // 7249: check Inst[24:20] == 0x0
4599 OPC_Decode, 248, 130, 1, 1, // 7253: decode to VSSEG6E8_V using decoder 1
4600 // 7253: }
4601 41, 7, // 7258: case 0x29: {
4602 OPC_CheckPredicate, 22, // 7260: check predicate 22
4603 OPC_Decode, 192, 131, 1, 3, // 7262: decode to VSUXSEG6EI8_V using decoder 3
4604 // 7262: }
4605 42, 7, // 7267: case 0x2a: {
4606 OPC_CheckPredicate, 22, // 7269: check predicate 22
4607 OPC_Decode, 154, 131, 1, 4, // 7271: decode to VSSSEG6E8_V using decoder 4
4608 // 7271: }
4609 43, 7, // 7276: case 0x2b: {
4610 OPC_CheckPredicate, 22, // 7278: check predicate 22
4611 OPC_Decode, 210, 130, 1, 3, // 7280: decode to VSOXSEG6EI8_V using decoder 3
4612 // 7280: }
4613 48, 11, // 7285: case 0x30: {
4614 OPC_CheckPredicate, 22, // 7287: check predicate 22
4615 OPC_CheckField, 20, 5, 0, // 7289: check Inst[24:20] == 0x0
4616 OPC_Decode, 252, 130, 1, 1, // 7293: decode to VSSEG7E8_V using decoder 1
4617 // 7293: }
4618 49, 7, // 7298: case 0x31: {
4619 OPC_CheckPredicate, 22, // 7300: check predicate 22
4620 OPC_Decode, 196, 131, 1, 3, // 7302: decode to VSUXSEG7EI8_V using decoder 3
4621 // 7302: }
4622 50, 7, // 7307: case 0x32: {
4623 OPC_CheckPredicate, 22, // 7309: check predicate 22
4624 OPC_Decode, 158, 131, 1, 4, // 7311: decode to VSSSEG7E8_V using decoder 4
4625 // 7311: }
4626 51, 7, // 7316: case 0x33: {
4627 OPC_CheckPredicate, 22, // 7318: check predicate 22
4628 OPC_Decode, 214, 130, 1, 3, // 7320: decode to VSOXSEG7EI8_V using decoder 3
4629 // 7320: }
4630 56, 25, // 7325: case 0x38: {
4631 OPC_SwitchField, 20, 5, // 7327: switch Inst[24:20] {
4632 0, 7, // 7330: case 0x0: {
4633 OPC_CheckPredicate, 22, // 7332: check predicate 22
4634 OPC_Decode, 128, 131, 1, 1, // 7334: decode to VSSEG8E8_V using decoder 1
4635 // 7334: }
4636 8, 0, // 7339: case 0x8: {
4637 OPC_CheckPredicate, 22, // 7341: check predicate 22
4638 OPC_CheckField, 25, 1, 1, // 7343: check Inst[25] == 0x1
4639 OPC_Decode, 148, 130, 1, 7, // 7347: decode to VS8R_V using decoder 7
4640 // 7347: }
4641 // 7347: } // switch Inst[24:20]
4642 // 7347: }
4643 57, 7, // 7352: case 0x39: {
4644 OPC_CheckPredicate, 22, // 7354: check predicate 22
4645 OPC_Decode, 200, 131, 1, 3, // 7356: decode to VSUXSEG8EI8_V using decoder 3
4646 // 7356: }
4647 58, 7, // 7361: case 0x3a: {
4648 OPC_CheckPredicate, 22, // 7363: check predicate 22
4649 OPC_Decode, 162, 131, 1, 4, // 7365: decode to VSSSEG8E8_V using decoder 4
4650 // 7365: }
4651 59, 0, // 7370: case 0x3b: {
4652 OPC_CheckPredicate, 22, // 7372: check predicate 22
4653 OPC_Decode, 218, 130, 1, 3, // 7374: decode to VSOXSEG8EI8_V using decoder 3
4654 // 7374: }
4655 // 7374: } // switch Inst[31:26]
4656 // 7374: }
4657 1, 6, // 7379: case 0x1: {
4658 OPC_CheckPredicate, 23, // 7381: check predicate 23
4659 OPC_Decode, 143, 116, 52, // 7383: decode to FSH using decoder 52
4660 // 7383: }
4661 2, 6, // 7387: case 0x2: {
4662 OPC_CheckPredicate, 24, // 7389: check predicate 24
4663 OPC_Decode, 161, 116, 53, // 7391: decode to FSW using decoder 53
4664 // 7391: }
4665 3, 6, // 7395: case 0x3: {
4666 OPC_CheckPredicate, 25, // 7397: check predicate 25
4667 OPC_Decode, 246, 115, 54, // 7399: decode to FSD using decoder 54
4668 // 7399: }
4669 4, 6, // 7403: case 0x4: {
4670 OPC_CheckPredicate, 26, // 7405: check predicate 26
4671 OPC_Decode, 144, 116, 55, // 7407: decode to FSQ using decoder 55
4672 // 7407: }
4673 5, 195, 2, // 7411: case 0x5: {
4674 OPC_SwitchField, 26, 6, // 7414: switch Inst[31:26] {
4675 0, 11, // 7417: case 0x0: {
4676 OPC_CheckPredicate, 22, // 7419: check predicate 22
4677 OPC_CheckField, 20, 5, 0, // 7421: check Inst[24:20] == 0x0
4678 OPC_Decode, 157, 130, 1, 1, // 7425: decode to VSE16_V using decoder 1
4679 // 7425: }
4680 1, 7, // 7430: case 0x1: {
4681 OPC_CheckPredicate, 22, // 7432: check predicate 22
4682 OPC_Decode, 169, 131, 1, 3, // 7434: decode to VSUXEI16_V using decoder 3
4683 // 7434: }
4684 2, 7, // 7439: case 0x2: {
4685 OPC_CheckPredicate, 22, // 7441: check predicate 22
4686 OPC_Decode, 225, 130, 1, 4, // 7443: decode to VSSE16_V using decoder 4
4687 // 7443: }
4688 3, 7, // 7448: case 0x3: {
4689 OPC_CheckPredicate, 22, // 7450: check predicate 22
4690 OPC_Decode, 187, 130, 1, 3, // 7452: decode to VSOXEI16_V using decoder 3
4691 // 7452: }
4692 8, 11, // 7457: case 0x8: {
4693 OPC_CheckPredicate, 22, // 7459: check predicate 22
4694 OPC_CheckField, 20, 5, 0, // 7461: check Inst[24:20] == 0x0
4695 OPC_Decode, 229, 130, 1, 1, // 7465: decode to VSSEG2E16_V using decoder 1
4696 // 7465: }
4697 9, 7, // 7470: case 0x9: {
4698 OPC_CheckPredicate, 22, // 7472: check predicate 22
4699 OPC_Decode, 173, 131, 1, 3, // 7474: decode to VSUXSEG2EI16_V using decoder 3
4700 // 7474: }
4701 10, 7, // 7479: case 0xa: {
4702 OPC_CheckPredicate, 22, // 7481: check predicate 22
4703 OPC_Decode, 135, 131, 1, 4, // 7483: decode to VSSSEG2E16_V using decoder 4
4704 // 7483: }
4705 11, 7, // 7488: case 0xb: {
4706 OPC_CheckPredicate, 22, // 7490: check predicate 22
4707 OPC_Decode, 191, 130, 1, 3, // 7492: decode to VSOXSEG2EI16_V using decoder 3
4708 // 7492: }
4709 16, 11, // 7497: case 0x10: {
4710 OPC_CheckPredicate, 22, // 7499: check predicate 22
4711 OPC_CheckField, 20, 5, 0, // 7501: check Inst[24:20] == 0x0
4712 OPC_Decode, 233, 130, 1, 1, // 7505: decode to VSSEG3E16_V using decoder 1
4713 // 7505: }
4714 17, 7, // 7510: case 0x11: {
4715 OPC_CheckPredicate, 22, // 7512: check predicate 22
4716 OPC_Decode, 177, 131, 1, 3, // 7514: decode to VSUXSEG3EI16_V using decoder 3
4717 // 7514: }
4718 18, 7, // 7519: case 0x12: {
4719 OPC_CheckPredicate, 22, // 7521: check predicate 22
4720 OPC_Decode, 139, 131, 1, 4, // 7523: decode to VSSSEG3E16_V using decoder 4
4721 // 7523: }
4722 19, 7, // 7528: case 0x13: {
4723 OPC_CheckPredicate, 22, // 7530: check predicate 22
4724 OPC_Decode, 195, 130, 1, 3, // 7532: decode to VSOXSEG3EI16_V using decoder 3
4725 // 7532: }
4726 24, 11, // 7537: case 0x18: {
4727 OPC_CheckPredicate, 22, // 7539: check predicate 22
4728 OPC_CheckField, 20, 5, 0, // 7541: check Inst[24:20] == 0x0
4729 OPC_Decode, 237, 130, 1, 1, // 7545: decode to VSSEG4E16_V using decoder 1
4730 // 7545: }
4731 25, 7, // 7550: case 0x19: {
4732 OPC_CheckPredicate, 22, // 7552: check predicate 22
4733 OPC_Decode, 181, 131, 1, 3, // 7554: decode to VSUXSEG4EI16_V using decoder 3
4734 // 7554: }
4735 26, 7, // 7559: case 0x1a: {
4736 OPC_CheckPredicate, 22, // 7561: check predicate 22
4737 OPC_Decode, 143, 131, 1, 4, // 7563: decode to VSSSEG4E16_V using decoder 4
4738 // 7563: }
4739 27, 7, // 7568: case 0x1b: {
4740 OPC_CheckPredicate, 22, // 7570: check predicate 22
4741 OPC_Decode, 199, 130, 1, 3, // 7572: decode to VSOXSEG4EI16_V using decoder 3
4742 // 7572: }
4743 32, 11, // 7577: case 0x20: {
4744 OPC_CheckPredicate, 22, // 7579: check predicate 22
4745 OPC_CheckField, 20, 5, 0, // 7581: check Inst[24:20] == 0x0
4746 OPC_Decode, 241, 130, 1, 1, // 7585: decode to VSSEG5E16_V using decoder 1
4747 // 7585: }
4748 33, 7, // 7590: case 0x21: {
4749 OPC_CheckPredicate, 22, // 7592: check predicate 22
4750 OPC_Decode, 185, 131, 1, 3, // 7594: decode to VSUXSEG5EI16_V using decoder 3
4751 // 7594: }
4752 34, 7, // 7599: case 0x22: {
4753 OPC_CheckPredicate, 22, // 7601: check predicate 22
4754 OPC_Decode, 147, 131, 1, 4, // 7603: decode to VSSSEG5E16_V using decoder 4
4755 // 7603: }
4756 35, 7, // 7608: case 0x23: {
4757 OPC_CheckPredicate, 22, // 7610: check predicate 22
4758 OPC_Decode, 203, 130, 1, 3, // 7612: decode to VSOXSEG5EI16_V using decoder 3
4759 // 7612: }
4760 40, 11, // 7617: case 0x28: {
4761 OPC_CheckPredicate, 22, // 7619: check predicate 22
4762 OPC_CheckField, 20, 5, 0, // 7621: check Inst[24:20] == 0x0
4763 OPC_Decode, 245, 130, 1, 1, // 7625: decode to VSSEG6E16_V using decoder 1
4764 // 7625: }
4765 41, 7, // 7630: case 0x29: {
4766 OPC_CheckPredicate, 22, // 7632: check predicate 22
4767 OPC_Decode, 189, 131, 1, 3, // 7634: decode to VSUXSEG6EI16_V using decoder 3
4768 // 7634: }
4769 42, 7, // 7639: case 0x2a: {
4770 OPC_CheckPredicate, 22, // 7641: check predicate 22
4771 OPC_Decode, 151, 131, 1, 4, // 7643: decode to VSSSEG6E16_V using decoder 4
4772 // 7643: }
4773 43, 7, // 7648: case 0x2b: {
4774 OPC_CheckPredicate, 22, // 7650: check predicate 22
4775 OPC_Decode, 207, 130, 1, 3, // 7652: decode to VSOXSEG6EI16_V using decoder 3
4776 // 7652: }
4777 48, 11, // 7657: case 0x30: {
4778 OPC_CheckPredicate, 22, // 7659: check predicate 22
4779 OPC_CheckField, 20, 5, 0, // 7661: check Inst[24:20] == 0x0
4780 OPC_Decode, 249, 130, 1, 1, // 7665: decode to VSSEG7E16_V using decoder 1
4781 // 7665: }
4782 49, 7, // 7670: case 0x31: {
4783 OPC_CheckPredicate, 22, // 7672: check predicate 22
4784 OPC_Decode, 193, 131, 1, 3, // 7674: decode to VSUXSEG7EI16_V using decoder 3
4785 // 7674: }
4786 50, 7, // 7679: case 0x32: {
4787 OPC_CheckPredicate, 22, // 7681: check predicate 22
4788 OPC_Decode, 155, 131, 1, 4, // 7683: decode to VSSSEG7E16_V using decoder 4
4789 // 7683: }
4790 51, 7, // 7688: case 0x33: {
4791 OPC_CheckPredicate, 22, // 7690: check predicate 22
4792 OPC_Decode, 211, 130, 1, 3, // 7692: decode to VSOXSEG7EI16_V using decoder 3
4793 // 7692: }
4794 56, 11, // 7697: case 0x38: {
4795 OPC_CheckPredicate, 22, // 7699: check predicate 22
4796 OPC_CheckField, 20, 5, 0, // 7701: check Inst[24:20] == 0x0
4797 OPC_Decode, 253, 130, 1, 1, // 7705: decode to VSSEG8E16_V using decoder 1
4798 // 7705: }
4799 57, 7, // 7710: case 0x39: {
4800 OPC_CheckPredicate, 22, // 7712: check predicate 22
4801 OPC_Decode, 197, 131, 1, 3, // 7714: decode to VSUXSEG8EI16_V using decoder 3
4802 // 7714: }
4803 58, 7, // 7719: case 0x3a: {
4804 OPC_CheckPredicate, 22, // 7721: check predicate 22
4805 OPC_Decode, 159, 131, 1, 4, // 7723: decode to VSSSEG8E16_V using decoder 4
4806 // 7723: }
4807 59, 0, // 7728: case 0x3b: {
4808 OPC_CheckPredicate, 22, // 7730: check predicate 22
4809 OPC_Decode, 215, 130, 1, 3, // 7732: decode to VSOXSEG8EI16_V using decoder 3
4810 // 7732: }
4811 // 7732: } // switch Inst[31:26]
4812 // 7732: }
4813 6, 195, 2, // 7737: case 0x6: {
4814 OPC_SwitchField, 26, 6, // 7740: switch Inst[31:26] {
4815 0, 11, // 7743: case 0x0: {
4816 OPC_CheckPredicate, 22, // 7745: check predicate 22
4817 OPC_CheckField, 20, 5, 0, // 7747: check Inst[24:20] == 0x0
4818 OPC_Decode, 158, 130, 1, 1, // 7751: decode to VSE32_V using decoder 1
4819 // 7751: }
4820 1, 7, // 7756: case 0x1: {
4821 OPC_CheckPredicate, 22, // 7758: check predicate 22
4822 OPC_Decode, 170, 131, 1, 3, // 7760: decode to VSUXEI32_V using decoder 3
4823 // 7760: }
4824 2, 7, // 7765: case 0x2: {
4825 OPC_CheckPredicate, 22, // 7767: check predicate 22
4826 OPC_Decode, 226, 130, 1, 4, // 7769: decode to VSSE32_V using decoder 4
4827 // 7769: }
4828 3, 7, // 7774: case 0x3: {
4829 OPC_CheckPredicate, 22, // 7776: check predicate 22
4830 OPC_Decode, 188, 130, 1, 3, // 7778: decode to VSOXEI32_V using decoder 3
4831 // 7778: }
4832 8, 11, // 7783: case 0x8: {
4833 OPC_CheckPredicate, 22, // 7785: check predicate 22
4834 OPC_CheckField, 20, 5, 0, // 7787: check Inst[24:20] == 0x0
4835 OPC_Decode, 230, 130, 1, 1, // 7791: decode to VSSEG2E32_V using decoder 1
4836 // 7791: }
4837 9, 7, // 7796: case 0x9: {
4838 OPC_CheckPredicate, 22, // 7798: check predicate 22
4839 OPC_Decode, 174, 131, 1, 3, // 7800: decode to VSUXSEG2EI32_V using decoder 3
4840 // 7800: }
4841 10, 7, // 7805: case 0xa: {
4842 OPC_CheckPredicate, 22, // 7807: check predicate 22
4843 OPC_Decode, 136, 131, 1, 4, // 7809: decode to VSSSEG2E32_V using decoder 4
4844 // 7809: }
4845 11, 7, // 7814: case 0xb: {
4846 OPC_CheckPredicate, 22, // 7816: check predicate 22
4847 OPC_Decode, 192, 130, 1, 3, // 7818: decode to VSOXSEG2EI32_V using decoder 3
4848 // 7818: }
4849 16, 11, // 7823: case 0x10: {
4850 OPC_CheckPredicate, 22, // 7825: check predicate 22
4851 OPC_CheckField, 20, 5, 0, // 7827: check Inst[24:20] == 0x0
4852 OPC_Decode, 234, 130, 1, 1, // 7831: decode to VSSEG3E32_V using decoder 1
4853 // 7831: }
4854 17, 7, // 7836: case 0x11: {
4855 OPC_CheckPredicate, 22, // 7838: check predicate 22
4856 OPC_Decode, 178, 131, 1, 3, // 7840: decode to VSUXSEG3EI32_V using decoder 3
4857 // 7840: }
4858 18, 7, // 7845: case 0x12: {
4859 OPC_CheckPredicate, 22, // 7847: check predicate 22
4860 OPC_Decode, 140, 131, 1, 4, // 7849: decode to VSSSEG3E32_V using decoder 4
4861 // 7849: }
4862 19, 7, // 7854: case 0x13: {
4863 OPC_CheckPredicate, 22, // 7856: check predicate 22
4864 OPC_Decode, 196, 130, 1, 3, // 7858: decode to VSOXSEG3EI32_V using decoder 3
4865 // 7858: }
4866 24, 11, // 7863: case 0x18: {
4867 OPC_CheckPredicate, 22, // 7865: check predicate 22
4868 OPC_CheckField, 20, 5, 0, // 7867: check Inst[24:20] == 0x0
4869 OPC_Decode, 238, 130, 1, 1, // 7871: decode to VSSEG4E32_V using decoder 1
4870 // 7871: }
4871 25, 7, // 7876: case 0x19: {
4872 OPC_CheckPredicate, 22, // 7878: check predicate 22
4873 OPC_Decode, 182, 131, 1, 3, // 7880: decode to VSUXSEG4EI32_V using decoder 3
4874 // 7880: }
4875 26, 7, // 7885: case 0x1a: {
4876 OPC_CheckPredicate, 22, // 7887: check predicate 22
4877 OPC_Decode, 144, 131, 1, 4, // 7889: decode to VSSSEG4E32_V using decoder 4
4878 // 7889: }
4879 27, 7, // 7894: case 0x1b: {
4880 OPC_CheckPredicate, 22, // 7896: check predicate 22
4881 OPC_Decode, 200, 130, 1, 3, // 7898: decode to VSOXSEG4EI32_V using decoder 3
4882 // 7898: }
4883 32, 11, // 7903: case 0x20: {
4884 OPC_CheckPredicate, 22, // 7905: check predicate 22
4885 OPC_CheckField, 20, 5, 0, // 7907: check Inst[24:20] == 0x0
4886 OPC_Decode, 242, 130, 1, 1, // 7911: decode to VSSEG5E32_V using decoder 1
4887 // 7911: }
4888 33, 7, // 7916: case 0x21: {
4889 OPC_CheckPredicate, 22, // 7918: check predicate 22
4890 OPC_Decode, 186, 131, 1, 3, // 7920: decode to VSUXSEG5EI32_V using decoder 3
4891 // 7920: }
4892 34, 7, // 7925: case 0x22: {
4893 OPC_CheckPredicate, 22, // 7927: check predicate 22
4894 OPC_Decode, 148, 131, 1, 4, // 7929: decode to VSSSEG5E32_V using decoder 4
4895 // 7929: }
4896 35, 7, // 7934: case 0x23: {
4897 OPC_CheckPredicate, 22, // 7936: check predicate 22
4898 OPC_Decode, 204, 130, 1, 3, // 7938: decode to VSOXSEG5EI32_V using decoder 3
4899 // 7938: }
4900 40, 11, // 7943: case 0x28: {
4901 OPC_CheckPredicate, 22, // 7945: check predicate 22
4902 OPC_CheckField, 20, 5, 0, // 7947: check Inst[24:20] == 0x0
4903 OPC_Decode, 246, 130, 1, 1, // 7951: decode to VSSEG6E32_V using decoder 1
4904 // 7951: }
4905 41, 7, // 7956: case 0x29: {
4906 OPC_CheckPredicate, 22, // 7958: check predicate 22
4907 OPC_Decode, 190, 131, 1, 3, // 7960: decode to VSUXSEG6EI32_V using decoder 3
4908 // 7960: }
4909 42, 7, // 7965: case 0x2a: {
4910 OPC_CheckPredicate, 22, // 7967: check predicate 22
4911 OPC_Decode, 152, 131, 1, 4, // 7969: decode to VSSSEG6E32_V using decoder 4
4912 // 7969: }
4913 43, 7, // 7974: case 0x2b: {
4914 OPC_CheckPredicate, 22, // 7976: check predicate 22
4915 OPC_Decode, 208, 130, 1, 3, // 7978: decode to VSOXSEG6EI32_V using decoder 3
4916 // 7978: }
4917 48, 11, // 7983: case 0x30: {
4918 OPC_CheckPredicate, 22, // 7985: check predicate 22
4919 OPC_CheckField, 20, 5, 0, // 7987: check Inst[24:20] == 0x0
4920 OPC_Decode, 250, 130, 1, 1, // 7991: decode to VSSEG7E32_V using decoder 1
4921 // 7991: }
4922 49, 7, // 7996: case 0x31: {
4923 OPC_CheckPredicate, 22, // 7998: check predicate 22
4924 OPC_Decode, 194, 131, 1, 3, // 8000: decode to VSUXSEG7EI32_V using decoder 3
4925 // 8000: }
4926 50, 7, // 8005: case 0x32: {
4927 OPC_CheckPredicate, 22, // 8007: check predicate 22
4928 OPC_Decode, 156, 131, 1, 4, // 8009: decode to VSSSEG7E32_V using decoder 4
4929 // 8009: }
4930 51, 7, // 8014: case 0x33: {
4931 OPC_CheckPredicate, 22, // 8016: check predicate 22
4932 OPC_Decode, 212, 130, 1, 3, // 8018: decode to VSOXSEG7EI32_V using decoder 3
4933 // 8018: }
4934 56, 11, // 8023: case 0x38: {
4935 OPC_CheckPredicate, 22, // 8025: check predicate 22
4936 OPC_CheckField, 20, 5, 0, // 8027: check Inst[24:20] == 0x0
4937 OPC_Decode, 254, 130, 1, 1, // 8031: decode to VSSEG8E32_V using decoder 1
4938 // 8031: }
4939 57, 7, // 8036: case 0x39: {
4940 OPC_CheckPredicate, 22, // 8038: check predicate 22
4941 OPC_Decode, 198, 131, 1, 3, // 8040: decode to VSUXSEG8EI32_V using decoder 3
4942 // 8040: }
4943 58, 7, // 8045: case 0x3a: {
4944 OPC_CheckPredicate, 22, // 8047: check predicate 22
4945 OPC_Decode, 160, 131, 1, 4, // 8049: decode to VSSSEG8E32_V using decoder 4
4946 // 8049: }
4947 59, 0, // 8054: case 0x3b: {
4948 OPC_CheckPredicate, 22, // 8056: check predicate 22
4949 OPC_Decode, 216, 130, 1, 3, // 8058: decode to VSOXSEG8EI32_V using decoder 3
4950 // 8058: }
4951 // 8058: } // switch Inst[31:26]
4952 // 8058: }
4953 7, 0, // 8063: case 0x7: {
4954 OPC_SwitchField, 26, 3, // 8065: switch Inst[28:26] {
4955 0, 107, // 8068: case 0x0: {
4956 OPC_SwitchField, 29, 3, // 8070: switch Inst[31:29] {
4957 0, 11, // 8073: case 0x0: {
4958 OPC_CheckPredicate, 27, // 8075: check predicate 27
4959 OPC_CheckField, 20, 5, 0, // 8077: check Inst[24:20] == 0x0
4960 OPC_Decode, 159, 130, 1, 1, // 8081: decode to VSE64_V using decoder 1
4961 // 8081: }
4962 1, 11, // 8086: case 0x1: {
4963 OPC_CheckPredicate, 27, // 8088: check predicate 27
4964 OPC_CheckField, 20, 5, 0, // 8090: check Inst[24:20] == 0x0
4965 OPC_Decode, 231, 130, 1, 1, // 8094: decode to VSSEG2E64_V using decoder 1
4966 // 8094: }
4967 2, 11, // 8099: case 0x2: {
4968 OPC_CheckPredicate, 27, // 8101: check predicate 27
4969 OPC_CheckField, 20, 5, 0, // 8103: check Inst[24:20] == 0x0
4970 OPC_Decode, 235, 130, 1, 1, // 8107: decode to VSSEG3E64_V using decoder 1
4971 // 8107: }
4972 3, 11, // 8112: case 0x3: {
4973 OPC_CheckPredicate, 27, // 8114: check predicate 27
4974 OPC_CheckField, 20, 5, 0, // 8116: check Inst[24:20] == 0x0
4975 OPC_Decode, 239, 130, 1, 1, // 8120: decode to VSSEG4E64_V using decoder 1
4976 // 8120: }
4977 4, 11, // 8125: case 0x4: {
4978 OPC_CheckPredicate, 27, // 8127: check predicate 27
4979 OPC_CheckField, 20, 5, 0, // 8129: check Inst[24:20] == 0x0
4980 OPC_Decode, 243, 130, 1, 1, // 8133: decode to VSSEG5E64_V using decoder 1
4981 // 8133: }
4982 5, 11, // 8138: case 0x5: {
4983 OPC_CheckPredicate, 27, // 8140: check predicate 27
4984 OPC_CheckField, 20, 5, 0, // 8142: check Inst[24:20] == 0x0
4985 OPC_Decode, 247, 130, 1, 1, // 8146: decode to VSSEG6E64_V using decoder 1
4986 // 8146: }
4987 6, 11, // 8151: case 0x6: {
4988 OPC_CheckPredicate, 27, // 8153: check predicate 27
4989 OPC_CheckField, 20, 5, 0, // 8155: check Inst[24:20] == 0x0
4990 OPC_Decode, 251, 130, 1, 1, // 8159: decode to VSSEG7E64_V using decoder 1
4991 // 8159: }
4992 7, 0, // 8164: case 0x7: {
4993 OPC_CheckPredicate, 27, // 8166: check predicate 27
4994 OPC_CheckField, 20, 5, 0, // 8168: check Inst[24:20] == 0x0
4995 OPC_Decode, 255, 130, 1, 1, // 8172: decode to VSSEG8E64_V using decoder 1
4996 // 8172: }
4997 // 8172: } // switch Inst[31:29]
4998 // 8172: }
4999 1, 75, // 8177: case 0x1: {
5000 OPC_SwitchField, 29, 3, // 8179: switch Inst[31:29] {
5001 0, 7, // 8182: case 0x0: {
5002 OPC_CheckPredicate, 28, // 8184: check predicate 28
5003 OPC_Decode, 171, 131, 1, 3, // 8186: decode to VSUXEI64_V using decoder 3
5004 // 8186: }
5005 1, 7, // 8191: case 0x1: {
5006 OPC_CheckPredicate, 29, // 8193: check predicate 29
5007 OPC_Decode, 175, 131, 1, 3, // 8195: decode to VSUXSEG2EI64_V using decoder 3
5008 // 8195: }
5009 2, 7, // 8200: case 0x2: {
5010 OPC_CheckPredicate, 29, // 8202: check predicate 29
5011 OPC_Decode, 179, 131, 1, 3, // 8204: decode to VSUXSEG3EI64_V using decoder 3
5012 // 8204: }
5013 3, 7, // 8209: case 0x3: {
5014 OPC_CheckPredicate, 29, // 8211: check predicate 29
5015 OPC_Decode, 183, 131, 1, 3, // 8213: decode to VSUXSEG4EI64_V using decoder 3
5016 // 8213: }
5017 4, 7, // 8218: case 0x4: {
5018 OPC_CheckPredicate, 29, // 8220: check predicate 29
5019 OPC_Decode, 187, 131, 1, 3, // 8222: decode to VSUXSEG5EI64_V using decoder 3
5020 // 8222: }
5021 5, 7, // 8227: case 0x5: {
5022 OPC_CheckPredicate, 29, // 8229: check predicate 29
5023 OPC_Decode, 191, 131, 1, 3, // 8231: decode to VSUXSEG6EI64_V using decoder 3
5024 // 8231: }
5025 6, 7, // 8236: case 0x6: {
5026 OPC_CheckPredicate, 29, // 8238: check predicate 29
5027 OPC_Decode, 195, 131, 1, 3, // 8240: decode to VSUXSEG7EI64_V using decoder 3
5028 // 8240: }
5029 7, 0, // 8245: case 0x7: {
5030 OPC_CheckPredicate, 29, // 8247: check predicate 29
5031 OPC_Decode, 199, 131, 1, 3, // 8249: decode to VSUXSEG8EI64_V using decoder 3
5032 // 8249: }
5033 // 8249: } // switch Inst[31:29]
5034 // 8249: }
5035 2, 75, // 8254: case 0x2: {
5036 OPC_SwitchField, 29, 3, // 8256: switch Inst[31:29] {
5037 0, 7, // 8259: case 0x0: {
5038 OPC_CheckPredicate, 27, // 8261: check predicate 27
5039 OPC_Decode, 227, 130, 1, 4, // 8263: decode to VSSE64_V using decoder 4
5040 // 8263: }
5041 1, 7, // 8268: case 0x1: {
5042 OPC_CheckPredicate, 27, // 8270: check predicate 27
5043 OPC_Decode, 137, 131, 1, 4, // 8272: decode to VSSSEG2E64_V using decoder 4
5044 // 8272: }
5045 2, 7, // 8277: case 0x2: {
5046 OPC_CheckPredicate, 27, // 8279: check predicate 27
5047 OPC_Decode, 141, 131, 1, 4, // 8281: decode to VSSSEG3E64_V using decoder 4
5048 // 8281: }
5049 3, 7, // 8286: case 0x3: {
5050 OPC_CheckPredicate, 27, // 8288: check predicate 27
5051 OPC_Decode, 145, 131, 1, 4, // 8290: decode to VSSSEG4E64_V using decoder 4
5052 // 8290: }
5053 4, 7, // 8295: case 0x4: {
5054 OPC_CheckPredicate, 27, // 8297: check predicate 27
5055 OPC_Decode, 149, 131, 1, 4, // 8299: decode to VSSSEG5E64_V using decoder 4
5056 // 8299: }
5057 5, 7, // 8304: case 0x5: {
5058 OPC_CheckPredicate, 27, // 8306: check predicate 27
5059 OPC_Decode, 153, 131, 1, 4, // 8308: decode to VSSSEG6E64_V using decoder 4
5060 // 8308: }
5061 6, 7, // 8313: case 0x6: {
5062 OPC_CheckPredicate, 27, // 8315: check predicate 27
5063 OPC_Decode, 157, 131, 1, 4, // 8317: decode to VSSSEG7E64_V using decoder 4
5064 // 8317: }
5065 7, 0, // 8322: case 0x7: {
5066 OPC_CheckPredicate, 27, // 8324: check predicate 27
5067 OPC_Decode, 161, 131, 1, 4, // 8326: decode to VSSSEG8E64_V using decoder 4
5068 // 8326: }
5069 // 8326: } // switch Inst[31:29]
5070 // 8326: }
5071 3, 75, // 8331: case 0x3: {
5072 OPC_SwitchField, 29, 3, // 8333: switch Inst[31:29] {
5073 0, 7, // 8336: case 0x0: {
5074 OPC_CheckPredicate, 28, // 8338: check predicate 28
5075 OPC_Decode, 189, 130, 1, 3, // 8340: decode to VSOXEI64_V using decoder 3
5076 // 8340: }
5077 1, 7, // 8345: case 0x1: {
5078 OPC_CheckPredicate, 29, // 8347: check predicate 29
5079 OPC_Decode, 193, 130, 1, 3, // 8349: decode to VSOXSEG2EI64_V using decoder 3
5080 // 8349: }
5081 2, 7, // 8354: case 0x2: {
5082 OPC_CheckPredicate, 29, // 8356: check predicate 29
5083 OPC_Decode, 197, 130, 1, 3, // 8358: decode to VSOXSEG3EI64_V using decoder 3
5084 // 8358: }
5085 3, 7, // 8363: case 0x3: {
5086 OPC_CheckPredicate, 29, // 8365: check predicate 29
5087 OPC_Decode, 201, 130, 1, 3, // 8367: decode to VSOXSEG4EI64_V using decoder 3
5088 // 8367: }
5089 4, 7, // 8372: case 0x4: {
5090 OPC_CheckPredicate, 29, // 8374: check predicate 29
5091 OPC_Decode, 205, 130, 1, 3, // 8376: decode to VSOXSEG5EI64_V using decoder 3
5092 // 8376: }
5093 5, 7, // 8381: case 0x5: {
5094 OPC_CheckPredicate, 29, // 8383: check predicate 29
5095 OPC_Decode, 209, 130, 1, 3, // 8385: decode to VSOXSEG6EI64_V using decoder 3
5096 // 8385: }
5097 6, 7, // 8390: case 0x6: {
5098 OPC_CheckPredicate, 29, // 8392: check predicate 29
5099 OPC_Decode, 213, 130, 1, 3, // 8394: decode to VSOXSEG7EI64_V using decoder 3
5100 // 8394: }
5101 7, 0, // 8399: case 0x7: {
5102 OPC_CheckPredicate, 29, // 8401: check predicate 29
5103 OPC_Decode, 217, 130, 1, 3, // 8403: decode to VSOXSEG8EI64_V using decoder 3
5104 // 8403: }
5105 // 8403: } // switch Inst[31:29]
5106 // 8403: }
5107 4, 7, // 8408: case 0x4: {
5108 OPC_CheckPredicate, 30, // 8410: check predicate 30
5109 OPC_Decode, 196, 129, 1, 12, // 8412: decode to VMTS_V using decoder 12
5110 // 8412: }
5111 5, 0, // 8417: case 0x5: {
5112 OPC_CheckPredicate, 31, // 8419: check predicate 31
5113 OPC_Decode, 198, 129, 1, 12, // 8421: decode to VMTTS_V using decoder 12
5114 // 8421: }
5115 // 8421: } // switch Inst[28:26]
5116 // 8421: }
5117 // 8421: } // switch Inst[14:12]
5118 // 8421: }
5119 47, 226, 16, // 8426: case 0x2f: {
5120 OPC_SwitchField, 25, 7, // 8429: switch Inst[31:25] {
5121 0, 35, // 8432: case 0x0: {
5122 OPC_SwitchField, 12, 3, // 8434: switch Inst[14:12] {
5123 0, 6, // 8437: case 0x0: {
5124 OPC_CheckPredicate, 51, // 8439: check predicate 51
5125 OPC_Decode, 164, 109, 56, // 8441: decode to AMOADD_B using decoder 56
5126 // 8441: }
5127 1, 6, // 8445: case 0x1: {
5128 OPC_CheckPredicate, 51, // 8447: check predicate 51
5129 OPC_Decode, 172, 109, 56, // 8449: decode to AMOADD_H using decoder 56
5130 // 8449: }
5131 2, 6, // 8453: case 0x2: {
5132 OPC_CheckPredicate, 52, // 8455: check predicate 52
5133 OPC_Decode, 176, 109, 56, // 8457: decode to AMOADD_W using decoder 56
5134 // 8457: }
5135 3, 0, // 8461: case 0x3: {
5136 OPC_CheckPredicate, 53, // 8463: check predicate 53
5137 OPC_Decode, 168, 109, 56, // 8465: decode to AMOADD_D using decoder 56
5138 // 8465: }
5139 // 8465: } // switch Inst[14:12]
5140 // 8465: }
5141 1, 35, // 8469: case 0x1: {
5142 OPC_SwitchField, 12, 3, // 8471: switch Inst[14:12] {
5143 0, 6, // 8474: case 0x0: {
5144 OPC_CheckPredicate, 51, // 8476: check predicate 51
5145 OPC_Decode, 167, 109, 56, // 8478: decode to AMOADD_B_RL using decoder 56
5146 // 8478: }
5147 1, 6, // 8482: case 0x1: {
5148 OPC_CheckPredicate, 51, // 8484: check predicate 51
5149 OPC_Decode, 175, 109, 56, // 8486: decode to AMOADD_H_RL using decoder 56
5150 // 8486: }
5151 2, 6, // 8490: case 0x2: {
5152 OPC_CheckPredicate, 52, // 8492: check predicate 52
5153 OPC_Decode, 179, 109, 56, // 8494: decode to AMOADD_W_RL using decoder 56
5154 // 8494: }
5155 3, 0, // 8498: case 0x3: {
5156 OPC_CheckPredicate, 53, // 8500: check predicate 53
5157 OPC_Decode, 171, 109, 56, // 8502: decode to AMOADD_D_RL using decoder 56
5158 // 8502: }
5159 // 8502: } // switch Inst[14:12]
5160 // 8502: }
5161 2, 35, // 8506: case 0x2: {
5162 OPC_SwitchField, 12, 3, // 8508: switch Inst[14:12] {
5163 0, 6, // 8511: case 0x0: {
5164 OPC_CheckPredicate, 51, // 8513: check predicate 51
5165 OPC_Decode, 165, 109, 56, // 8515: decode to AMOADD_B_AQ using decoder 56
5166 // 8515: }
5167 1, 6, // 8519: case 0x1: {
5168 OPC_CheckPredicate, 51, // 8521: check predicate 51
5169 OPC_Decode, 173, 109, 56, // 8523: decode to AMOADD_H_AQ using decoder 56
5170 // 8523: }
5171 2, 6, // 8527: case 0x2: {
5172 OPC_CheckPredicate, 52, // 8529: check predicate 52
5173 OPC_Decode, 177, 109, 56, // 8531: decode to AMOADD_W_AQ using decoder 56
5174 // 8531: }
5175 3, 0, // 8535: case 0x3: {
5176 OPC_CheckPredicate, 53, // 8537: check predicate 53
5177 OPC_Decode, 169, 109, 56, // 8539: decode to AMOADD_D_AQ using decoder 56
5178 // 8539: }
5179 // 8539: } // switch Inst[14:12]
5180 // 8539: }
5181 3, 35, // 8543: case 0x3: {
5182 OPC_SwitchField, 12, 3, // 8545: switch Inst[14:12] {
5183 0, 6, // 8548: case 0x0: {
5184 OPC_CheckPredicate, 51, // 8550: check predicate 51
5185 OPC_Decode, 166, 109, 56, // 8552: decode to AMOADD_B_AQRL using decoder 56
5186 // 8552: }
5187 1, 6, // 8556: case 0x1: {
5188 OPC_CheckPredicate, 51, // 8558: check predicate 51
5189 OPC_Decode, 174, 109, 56, // 8560: decode to AMOADD_H_AQRL using decoder 56
5190 // 8560: }
5191 2, 6, // 8564: case 0x2: {
5192 OPC_CheckPredicate, 52, // 8566: check predicate 52
5193 OPC_Decode, 178, 109, 56, // 8568: decode to AMOADD_W_AQRL using decoder 56
5194 // 8568: }
5195 3, 0, // 8572: case 0x3: {
5196 OPC_CheckPredicate, 53, // 8574: check predicate 53
5197 OPC_Decode, 170, 109, 56, // 8576: decode to AMOADD_D_AQRL using decoder 56
5198 // 8576: }
5199 // 8576: } // switch Inst[14:12]
5200 // 8576: }
5201 4, 35, // 8580: case 0x4: {
5202 OPC_SwitchField, 12, 3, // 8582: switch Inst[14:12] {
5203 0, 6, // 8585: case 0x0: {
5204 OPC_CheckPredicate, 51, // 8587: check predicate 51
5205 OPC_Decode, 172, 110, 56, // 8589: decode to AMOSWAP_B using decoder 56
5206 // 8589: }
5207 1, 6, // 8593: case 0x1: {
5208 OPC_CheckPredicate, 51, // 8595: check predicate 51
5209 OPC_Decode, 180, 110, 56, // 8597: decode to AMOSWAP_H using decoder 56
5210 // 8597: }
5211 2, 6, // 8601: case 0x2: {
5212 OPC_CheckPredicate, 52, // 8603: check predicate 52
5213 OPC_Decode, 184, 110, 56, // 8605: decode to AMOSWAP_W using decoder 56
5214 // 8605: }
5215 3, 0, // 8609: case 0x3: {
5216 OPC_CheckPredicate, 53, // 8611: check predicate 53
5217 OPC_Decode, 176, 110, 56, // 8613: decode to AMOSWAP_D using decoder 56
5218 // 8613: }
5219 // 8613: } // switch Inst[14:12]
5220 // 8613: }
5221 5, 35, // 8617: case 0x5: {
5222 OPC_SwitchField, 12, 3, // 8619: switch Inst[14:12] {
5223 0, 6, // 8622: case 0x0: {
5224 OPC_CheckPredicate, 51, // 8624: check predicate 51
5225 OPC_Decode, 175, 110, 56, // 8626: decode to AMOSWAP_B_RL using decoder 56
5226 // 8626: }
5227 1, 6, // 8630: case 0x1: {
5228 OPC_CheckPredicate, 51, // 8632: check predicate 51
5229 OPC_Decode, 183, 110, 56, // 8634: decode to AMOSWAP_H_RL using decoder 56
5230 // 8634: }
5231 2, 6, // 8638: case 0x2: {
5232 OPC_CheckPredicate, 52, // 8640: check predicate 52
5233 OPC_Decode, 187, 110, 56, // 8642: decode to AMOSWAP_W_RL using decoder 56
5234 // 8642: }
5235 3, 0, // 8646: case 0x3: {
5236 OPC_CheckPredicate, 53, // 8648: check predicate 53
5237 OPC_Decode, 179, 110, 56, // 8650: decode to AMOSWAP_D_RL using decoder 56
5238 // 8650: }
5239 // 8650: } // switch Inst[14:12]
5240 // 8650: }
5241 6, 35, // 8654: case 0x6: {
5242 OPC_SwitchField, 12, 3, // 8656: switch Inst[14:12] {
5243 0, 6, // 8659: case 0x0: {
5244 OPC_CheckPredicate, 51, // 8661: check predicate 51
5245 OPC_Decode, 173, 110, 56, // 8663: decode to AMOSWAP_B_AQ using decoder 56
5246 // 8663: }
5247 1, 6, // 8667: case 0x1: {
5248 OPC_CheckPredicate, 51, // 8669: check predicate 51
5249 OPC_Decode, 181, 110, 56, // 8671: decode to AMOSWAP_H_AQ using decoder 56
5250 // 8671: }
5251 2, 6, // 8675: case 0x2: {
5252 OPC_CheckPredicate, 52, // 8677: check predicate 52
5253 OPC_Decode, 185, 110, 56, // 8679: decode to AMOSWAP_W_AQ using decoder 56
5254 // 8679: }
5255 3, 0, // 8683: case 0x3: {
5256 OPC_CheckPredicate, 53, // 8685: check predicate 53
5257 OPC_Decode, 177, 110, 56, // 8687: decode to AMOSWAP_D_AQ using decoder 56
5258 // 8687: }
5259 // 8687: } // switch Inst[14:12]
5260 // 8687: }
5261 7, 35, // 8691: case 0x7: {
5262 OPC_SwitchField, 12, 3, // 8693: switch Inst[14:12] {
5263 0, 6, // 8696: case 0x0: {
5264 OPC_CheckPredicate, 51, // 8698: check predicate 51
5265 OPC_Decode, 174, 110, 56, // 8700: decode to AMOSWAP_B_AQRL using decoder 56
5266 // 8700: }
5267 1, 6, // 8704: case 0x1: {
5268 OPC_CheckPredicate, 51, // 8706: check predicate 51
5269 OPC_Decode, 182, 110, 56, // 8708: decode to AMOSWAP_H_AQRL using decoder 56
5270 // 8708: }
5271 2, 6, // 8712: case 0x2: {
5272 OPC_CheckPredicate, 52, // 8714: check predicate 52
5273 OPC_Decode, 186, 110, 56, // 8716: decode to AMOSWAP_W_AQRL using decoder 56
5274 // 8716: }
5275 3, 0, // 8720: case 0x3: {
5276 OPC_CheckPredicate, 53, // 8722: check predicate 53
5277 OPC_Decode, 178, 110, 56, // 8724: decode to AMOSWAP_D_AQRL using decoder 56
5278 // 8724: }
5279 // 8724: } // switch Inst[14:12]
5280 // 8724: }
5281 8, 27, // 8728: case 0x8: {
5282 OPC_SwitchField, 12, 3, // 8730: switch Inst[14:12] {
5283 2, 10, // 8733: case 0x2: {
5284 OPC_CheckPredicate, 54, // 8735: check predicate 54
5285 OPC_CheckField, 20, 5, 0, // 8737: check Inst[24:20] == 0x0
5286 OPC_Decode, 225, 116, 17, // 8741: decode to LR_W using decoder 17
5287 // 8741: }
5288 3, 0, // 8745: case 0x3: {
5289 OPC_CheckPredicate, 55, // 8747: check predicate 55
5290 OPC_CheckField, 20, 5, 0, // 8749: check Inst[24:20] == 0x0
5291 OPC_Decode, 221, 116, 17, // 8753: decode to LR_D using decoder 17
5292 // 8753: }
5293 // 8753: } // switch Inst[14:12]
5294 // 8753: }
5295 9, 27, // 8757: case 0x9: {
5296 OPC_SwitchField, 12, 3, // 8759: switch Inst[14:12] {
5297 2, 10, // 8762: case 0x2: {
5298 OPC_CheckPredicate, 54, // 8764: check predicate 54
5299 OPC_CheckField, 20, 5, 0, // 8766: check Inst[24:20] == 0x0
5300 OPC_Decode, 228, 116, 17, // 8770: decode to LR_W_RL using decoder 17
5301 // 8770: }
5302 3, 0, // 8774: case 0x3: {
5303 OPC_CheckPredicate, 55, // 8776: check predicate 55
5304 OPC_CheckField, 20, 5, 0, // 8778: check Inst[24:20] == 0x0
5305 OPC_Decode, 224, 116, 17, // 8782: decode to LR_D_RL using decoder 17
5306 // 8782: }
5307 // 8782: } // switch Inst[14:12]
5308 // 8782: }
5309 10, 27, // 8786: case 0xa: {
5310 OPC_SwitchField, 12, 3, // 8788: switch Inst[14:12] {
5311 2, 10, // 8791: case 0x2: {
5312 OPC_CheckPredicate, 54, // 8793: check predicate 54
5313 OPC_CheckField, 20, 5, 0, // 8795: check Inst[24:20] == 0x0
5314 OPC_Decode, 226, 116, 17, // 8799: decode to LR_W_AQ using decoder 17
5315 // 8799: }
5316 3, 0, // 8803: case 0x3: {
5317 OPC_CheckPredicate, 55, // 8805: check predicate 55
5318 OPC_CheckField, 20, 5, 0, // 8807: check Inst[24:20] == 0x0
5319 OPC_Decode, 222, 116, 17, // 8811: decode to LR_D_AQ using decoder 17
5320 // 8811: }
5321 // 8811: } // switch Inst[14:12]
5322 // 8811: }
5323 11, 27, // 8815: case 0xb: {
5324 OPC_SwitchField, 12, 3, // 8817: switch Inst[14:12] {
5325 2, 10, // 8820: case 0x2: {
5326 OPC_CheckPredicate, 54, // 8822: check predicate 54
5327 OPC_CheckField, 20, 5, 0, // 8824: check Inst[24:20] == 0x0
5328 OPC_Decode, 227, 116, 17, // 8828: decode to LR_W_AQRL using decoder 17
5329 // 8828: }
5330 3, 0, // 8832: case 0x3: {
5331 OPC_CheckPredicate, 55, // 8834: check predicate 55
5332 OPC_CheckField, 20, 5, 0, // 8836: check Inst[24:20] == 0x0
5333 OPC_Decode, 223, 116, 17, // 8840: decode to LR_D_AQRL using decoder 17
5334 // 8840: }
5335 // 8840: } // switch Inst[14:12]
5336 // 8840: }
5337 12, 19, // 8844: case 0xc: {
5338 OPC_SwitchField, 12, 3, // 8846: switch Inst[14:12] {
5339 2, 6, // 8849: case 0x2: {
5340 OPC_CheckPredicate, 54, // 8851: check predicate 54
5341 OPC_Decode, 217, 123, 56, // 8853: decode to SC_W using decoder 56
5342 // 8853: }
5343 3, 0, // 8857: case 0x3: {
5344 OPC_CheckPredicate, 55, // 8859: check predicate 55
5345 OPC_Decode, 213, 123, 56, // 8861: decode to SC_D using decoder 56
5346 // 8861: }
5347 // 8861: } // switch Inst[14:12]
5348 // 8861: }
5349 13, 19, // 8865: case 0xd: {
5350 OPC_SwitchField, 12, 3, // 8867: switch Inst[14:12] {
5351 2, 6, // 8870: case 0x2: {
5352 OPC_CheckPredicate, 54, // 8872: check predicate 54
5353 OPC_Decode, 220, 123, 56, // 8874: decode to SC_W_RL using decoder 56
5354 // 8874: }
5355 3, 0, // 8878: case 0x3: {
5356 OPC_CheckPredicate, 55, // 8880: check predicate 55
5357 OPC_Decode, 216, 123, 56, // 8882: decode to SC_D_RL using decoder 56
5358 // 8882: }
5359 // 8882: } // switch Inst[14:12]
5360 // 8882: }
5361 14, 19, // 8886: case 0xe: {
5362 OPC_SwitchField, 12, 3, // 8888: switch Inst[14:12] {
5363 2, 6, // 8891: case 0x2: {
5364 OPC_CheckPredicate, 54, // 8893: check predicate 54
5365 OPC_Decode, 218, 123, 56, // 8895: decode to SC_W_AQ using decoder 56
5366 // 8895: }
5367 3, 0, // 8899: case 0x3: {
5368 OPC_CheckPredicate, 55, // 8901: check predicate 55
5369 OPC_Decode, 214, 123, 56, // 8903: decode to SC_D_AQ using decoder 56
5370 // 8903: }
5371 // 8903: } // switch Inst[14:12]
5372 // 8903: }
5373 15, 19, // 8907: case 0xf: {
5374 OPC_SwitchField, 12, 3, // 8909: switch Inst[14:12] {
5375 2, 6, // 8912: case 0x2: {
5376 OPC_CheckPredicate, 54, // 8914: check predicate 54
5377 OPC_Decode, 219, 123, 56, // 8916: decode to SC_W_AQRL using decoder 56
5378 // 8916: }
5379 3, 0, // 8920: case 0x3: {
5380 OPC_CheckPredicate, 55, // 8922: check predicate 55
5381 OPC_Decode, 215, 123, 56, // 8924: decode to SC_D_AQRL using decoder 56
5382 // 8924: }
5383 // 8924: } // switch Inst[14:12]
5384 // 8924: }
5385 16, 35, // 8928: case 0x10: {
5386 OPC_SwitchField, 12, 3, // 8930: switch Inst[14:12] {
5387 0, 6, // 8933: case 0x0: {
5388 OPC_CheckPredicate, 51, // 8935: check predicate 51
5389 OPC_Decode, 188, 110, 56, // 8937: decode to AMOXOR_B using decoder 56
5390 // 8937: }
5391 1, 6, // 8941: case 0x1: {
5392 OPC_CheckPredicate, 51, // 8943: check predicate 51
5393 OPC_Decode, 196, 110, 56, // 8945: decode to AMOXOR_H using decoder 56
5394 // 8945: }
5395 2, 6, // 8949: case 0x2: {
5396 OPC_CheckPredicate, 52, // 8951: check predicate 52
5397 OPC_Decode, 200, 110, 56, // 8953: decode to AMOXOR_W using decoder 56
5398 // 8953: }
5399 3, 0, // 8957: case 0x3: {
5400 OPC_CheckPredicate, 53, // 8959: check predicate 53
5401 OPC_Decode, 192, 110, 56, // 8961: decode to AMOXOR_D using decoder 56
5402 // 8961: }
5403 // 8961: } // switch Inst[14:12]
5404 // 8961: }
5405 17, 35, // 8965: case 0x11: {
5406 OPC_SwitchField, 12, 3, // 8967: switch Inst[14:12] {
5407 0, 6, // 8970: case 0x0: {
5408 OPC_CheckPredicate, 51, // 8972: check predicate 51
5409 OPC_Decode, 191, 110, 56, // 8974: decode to AMOXOR_B_RL using decoder 56
5410 // 8974: }
5411 1, 6, // 8978: case 0x1: {
5412 OPC_CheckPredicate, 51, // 8980: check predicate 51
5413 OPC_Decode, 199, 110, 56, // 8982: decode to AMOXOR_H_RL using decoder 56
5414 // 8982: }
5415 2, 6, // 8986: case 0x2: {
5416 OPC_CheckPredicate, 52, // 8988: check predicate 52
5417 OPC_Decode, 203, 110, 56, // 8990: decode to AMOXOR_W_RL using decoder 56
5418 // 8990: }
5419 3, 0, // 8994: case 0x3: {
5420 OPC_CheckPredicate, 53, // 8996: check predicate 53
5421 OPC_Decode, 195, 110, 56, // 8998: decode to AMOXOR_D_RL using decoder 56
5422 // 8998: }
5423 // 8998: } // switch Inst[14:12]
5424 // 8998: }
5425 18, 35, // 9002: case 0x12: {
5426 OPC_SwitchField, 12, 3, // 9004: switch Inst[14:12] {
5427 0, 6, // 9007: case 0x0: {
5428 OPC_CheckPredicate, 51, // 9009: check predicate 51
5429 OPC_Decode, 189, 110, 56, // 9011: decode to AMOXOR_B_AQ using decoder 56
5430 // 9011: }
5431 1, 6, // 9015: case 0x1: {
5432 OPC_CheckPredicate, 51, // 9017: check predicate 51
5433 OPC_Decode, 197, 110, 56, // 9019: decode to AMOXOR_H_AQ using decoder 56
5434 // 9019: }
5435 2, 6, // 9023: case 0x2: {
5436 OPC_CheckPredicate, 52, // 9025: check predicate 52
5437 OPC_Decode, 201, 110, 56, // 9027: decode to AMOXOR_W_AQ using decoder 56
5438 // 9027: }
5439 3, 0, // 9031: case 0x3: {
5440 OPC_CheckPredicate, 53, // 9033: check predicate 53
5441 OPC_Decode, 193, 110, 56, // 9035: decode to AMOXOR_D_AQ using decoder 56
5442 // 9035: }
5443 // 9035: } // switch Inst[14:12]
5444 // 9035: }
5445 19, 35, // 9039: case 0x13: {
5446 OPC_SwitchField, 12, 3, // 9041: switch Inst[14:12] {
5447 0, 6, // 9044: case 0x0: {
5448 OPC_CheckPredicate, 51, // 9046: check predicate 51
5449 OPC_Decode, 190, 110, 56, // 9048: decode to AMOXOR_B_AQRL using decoder 56
5450 // 9048: }
5451 1, 6, // 9052: case 0x1: {
5452 OPC_CheckPredicate, 51, // 9054: check predicate 51
5453 OPC_Decode, 198, 110, 56, // 9056: decode to AMOXOR_H_AQRL using decoder 56
5454 // 9056: }
5455 2, 6, // 9060: case 0x2: {
5456 OPC_CheckPredicate, 52, // 9062: check predicate 52
5457 OPC_Decode, 202, 110, 56, // 9064: decode to AMOXOR_W_AQRL using decoder 56
5458 // 9064: }
5459 3, 0, // 9068: case 0x3: {
5460 OPC_CheckPredicate, 53, // 9070: check predicate 53
5461 OPC_Decode, 194, 110, 56, // 9072: decode to AMOXOR_D_AQRL using decoder 56
5462 // 9072: }
5463 // 9072: } // switch Inst[14:12]
5464 // 9072: }
5465 20, 43, // 9076: case 0x14: {
5466 OPC_SwitchField, 12, 3, // 9078: switch Inst[14:12] {
5467 0, 6, // 9081: case 0x0: {
5468 OPC_CheckPredicate, 56, // 9083: check predicate 56
5469 OPC_Decode, 196, 109, 57, // 9085: decode to AMOCAS_B using decoder 57
5470 // 9085: }
5471 1, 6, // 9089: case 0x1: {
5472 OPC_CheckPredicate, 56, // 9091: check predicate 56
5473 OPC_Decode, 208, 109, 57, // 9093: decode to AMOCAS_H using decoder 57
5474 // 9093: }
5475 2, 6, // 9097: case 0x2: {
5476 OPC_CheckPredicate, 57, // 9099: check predicate 57
5477 OPC_Decode, 216, 109, 57, // 9101: decode to AMOCAS_W using decoder 57
5478 // 9101: }
5479 3, 6, // 9105: case 0x3: {
5480 OPC_CheckPredicate, 58, // 9107: check predicate 58
5481 OPC_Decode, 204, 109, 57, // 9109: decode to AMOCAS_D_RV64 using decoder 57
5482 // 9109: }
5483 4, 0, // 9113: case 0x4: {
5484 OPC_CheckPredicate, 58, // 9115: check predicate 58
5485 OPC_Decode, 212, 109, 58, // 9117: decode to AMOCAS_Q using decoder 58
5486 // 9117: }
5487 // 9117: } // switch Inst[14:12]
5488 // 9117: }
5489 21, 43, // 9121: case 0x15: {
5490 OPC_SwitchField, 12, 3, // 9123: switch Inst[14:12] {
5491 0, 6, // 9126: case 0x0: {
5492 OPC_CheckPredicate, 56, // 9128: check predicate 56
5493 OPC_Decode, 199, 109, 57, // 9130: decode to AMOCAS_B_RL using decoder 57
5494 // 9130: }
5495 1, 6, // 9134: case 0x1: {
5496 OPC_CheckPredicate, 56, // 9136: check predicate 56
5497 OPC_Decode, 211, 109, 57, // 9138: decode to AMOCAS_H_RL using decoder 57
5498 // 9138: }
5499 2, 6, // 9142: case 0x2: {
5500 OPC_CheckPredicate, 57, // 9144: check predicate 57
5501 OPC_Decode, 219, 109, 57, // 9146: decode to AMOCAS_W_RL using decoder 57
5502 // 9146: }
5503 3, 6, // 9150: case 0x3: {
5504 OPC_CheckPredicate, 58, // 9152: check predicate 58
5505 OPC_Decode, 207, 109, 57, // 9154: decode to AMOCAS_D_RV64_RL using decoder 57
5506 // 9154: }
5507 4, 0, // 9158: case 0x4: {
5508 OPC_CheckPredicate, 58, // 9160: check predicate 58
5509 OPC_Decode, 215, 109, 58, // 9162: decode to AMOCAS_Q_RL using decoder 58
5510 // 9162: }
5511 // 9162: } // switch Inst[14:12]
5512 // 9162: }
5513 22, 43, // 9166: case 0x16: {
5514 OPC_SwitchField, 12, 3, // 9168: switch Inst[14:12] {
5515 0, 6, // 9171: case 0x0: {
5516 OPC_CheckPredicate, 56, // 9173: check predicate 56
5517 OPC_Decode, 197, 109, 57, // 9175: decode to AMOCAS_B_AQ using decoder 57
5518 // 9175: }
5519 1, 6, // 9179: case 0x1: {
5520 OPC_CheckPredicate, 56, // 9181: check predicate 56
5521 OPC_Decode, 209, 109, 57, // 9183: decode to AMOCAS_H_AQ using decoder 57
5522 // 9183: }
5523 2, 6, // 9187: case 0x2: {
5524 OPC_CheckPredicate, 57, // 9189: check predicate 57
5525 OPC_Decode, 217, 109, 57, // 9191: decode to AMOCAS_W_AQ using decoder 57
5526 // 9191: }
5527 3, 6, // 9195: case 0x3: {
5528 OPC_CheckPredicate, 58, // 9197: check predicate 58
5529 OPC_Decode, 205, 109, 57, // 9199: decode to AMOCAS_D_RV64_AQ using decoder 57
5530 // 9199: }
5531 4, 0, // 9203: case 0x4: {
5532 OPC_CheckPredicate, 58, // 9205: check predicate 58
5533 OPC_Decode, 213, 109, 58, // 9207: decode to AMOCAS_Q_AQ using decoder 58
5534 // 9207: }
5535 // 9207: } // switch Inst[14:12]
5536 // 9207: }
5537 23, 43, // 9211: case 0x17: {
5538 OPC_SwitchField, 12, 3, // 9213: switch Inst[14:12] {
5539 0, 6, // 9216: case 0x0: {
5540 OPC_CheckPredicate, 56, // 9218: check predicate 56
5541 OPC_Decode, 198, 109, 57, // 9220: decode to AMOCAS_B_AQRL using decoder 57
5542 // 9220: }
5543 1, 6, // 9224: case 0x1: {
5544 OPC_CheckPredicate, 56, // 9226: check predicate 56
5545 OPC_Decode, 210, 109, 57, // 9228: decode to AMOCAS_H_AQRL using decoder 57
5546 // 9228: }
5547 2, 6, // 9232: case 0x2: {
5548 OPC_CheckPredicate, 57, // 9234: check predicate 57
5549 OPC_Decode, 218, 109, 57, // 9236: decode to AMOCAS_W_AQRL using decoder 57
5550 // 9236: }
5551 3, 6, // 9240: case 0x3: {
5552 OPC_CheckPredicate, 58, // 9242: check predicate 58
5553 OPC_Decode, 206, 109, 57, // 9244: decode to AMOCAS_D_RV64_AQRL using decoder 57
5554 // 9244: }
5555 4, 0, // 9248: case 0x4: {
5556 OPC_CheckPredicate, 58, // 9250: check predicate 58
5557 OPC_Decode, 214, 109, 58, // 9252: decode to AMOCAS_Q_AQRL using decoder 58
5558 // 9252: }
5559 // 9252: } // switch Inst[14:12]
5560 // 9252: }
5561 26, 51, // 9256: case 0x1a: {
5562 OPC_SwitchField, 12, 3, // 9258: switch Inst[14:12] {
5563 0, 10, // 9261: case 0x0: {
5564 OPC_CheckPredicate, 59, // 9263: check predicate 59
5565 OPC_CheckField, 20, 5, 0, // 9265: check Inst[24:20] == 0x0
5566 OPC_Decode, 210, 116, 17, // 9269: decode to LB_AQ using decoder 17
5567 // 9269: }
5568 1, 10, // 9273: case 0x1: {
5569 OPC_CheckPredicate, 59, // 9275: check predicate 59
5570 OPC_CheckField, 20, 5, 0, // 9277: check Inst[24:20] == 0x0
5571 OPC_Decode, 218, 116, 17, // 9281: decode to LH_AQ using decoder 17
5572 // 9281: }
5573 2, 10, // 9285: case 0x2: {
5574 OPC_CheckPredicate, 59, // 9287: check predicate 59
5575 OPC_CheckField, 20, 5, 0, // 9289: check Inst[24:20] == 0x0
5576 OPC_Decode, 232, 116, 17, // 9293: decode to LW_AQ using decoder 17
5577 // 9293: }
5578 3, 0, // 9297: case 0x3: {
5579 OPC_CheckPredicate, 60, // 9299: check predicate 60
5580 OPC_CheckField, 20, 5, 0, // 9301: check Inst[24:20] == 0x0
5581 OPC_Decode, 213, 116, 17, // 9305: decode to LD_AQ using decoder 17
5582 // 9305: }
5583 // 9305: } // switch Inst[14:12]
5584 // 9305: }
5585 27, 51, // 9309: case 0x1b: {
5586 OPC_SwitchField, 12, 3, // 9311: switch Inst[14:12] {
5587 0, 10, // 9314: case 0x0: {
5588 OPC_CheckPredicate, 59, // 9316: check predicate 59
5589 OPC_CheckField, 20, 5, 0, // 9318: check Inst[24:20] == 0x0
5590 OPC_Decode, 211, 116, 17, // 9322: decode to LB_AQRL using decoder 17
5591 // 9322: }
5592 1, 10, // 9326: case 0x1: {
5593 OPC_CheckPredicate, 59, // 9328: check predicate 59
5594 OPC_CheckField, 20, 5, 0, // 9330: check Inst[24:20] == 0x0
5595 OPC_Decode, 219, 116, 17, // 9334: decode to LH_AQRL using decoder 17
5596 // 9334: }
5597 2, 10, // 9338: case 0x2: {
5598 OPC_CheckPredicate, 59, // 9340: check predicate 59
5599 OPC_CheckField, 20, 5, 0, // 9342: check Inst[24:20] == 0x0
5600 OPC_Decode, 233, 116, 17, // 9346: decode to LW_AQRL using decoder 17
5601 // 9346: }
5602 3, 0, // 9350: case 0x3: {
5603 OPC_CheckPredicate, 60, // 9352: check predicate 60
5604 OPC_CheckField, 20, 5, 0, // 9354: check Inst[24:20] == 0x0
5605 OPC_Decode, 214, 116, 17, // 9358: decode to LD_AQRL using decoder 17
5606 // 9358: }
5607 // 9358: } // switch Inst[14:12]
5608 // 9358: }
5609 29, 35, // 9362: case 0x1d: {
5610 OPC_SwitchField, 7, 8, // 9364: switch Inst[14:7] {
5611 0, 6, // 9367: case 0x0: {
5612 OPC_CheckPredicate, 59, // 9369: check predicate 59
5613 OPC_Decode, 209, 123, 59, // 9371: decode to SB_RL using decoder 59
5614 // 9371: }
5615 32, 6, // 9375: case 0x20: {
5616 OPC_CheckPredicate, 59, // 9377: check predicate 59
5617 OPC_Decode, 197, 124, 59, // 9379: decode to SH_RL using decoder 59
5618 // 9379: }
5619 64, 6, // 9383: case 0x40: {
5620 OPC_CheckPredicate, 59, // 9385: check predicate 59
5621 OPC_Decode, 140, 125, 59, // 9387: decode to SW_RL using decoder 59
5622 // 9387: }
5623 96, 0, // 9391: case 0x60: {
5624 OPC_CheckPredicate, 60, // 9393: check predicate 60
5625 OPC_Decode, 223, 123, 59, // 9395: decode to SD_RL using decoder 59
5626 // 9395: }
5627 // 9395: } // switch Inst[14:7]
5628 // 9395: }
5629 31, 35, // 9399: case 0x1f: {
5630 OPC_SwitchField, 7, 8, // 9401: switch Inst[14:7] {
5631 0, 6, // 9404: case 0x0: {
5632 OPC_CheckPredicate, 59, // 9406: check predicate 59
5633 OPC_Decode, 208, 123, 59, // 9408: decode to SB_AQRL using decoder 59
5634 // 9408: }
5635 32, 6, // 9412: case 0x20: {
5636 OPC_CheckPredicate, 59, // 9414: check predicate 59
5637 OPC_Decode, 195, 124, 59, // 9416: decode to SH_AQRL using decoder 59
5638 // 9416: }
5639 64, 6, // 9420: case 0x40: {
5640 OPC_CheckPredicate, 59, // 9422: check predicate 59
5641 OPC_Decode, 138, 125, 59, // 9424: decode to SW_AQRL using decoder 59
5642 // 9424: }
5643 96, 0, // 9428: case 0x60: {
5644 OPC_CheckPredicate, 60, // 9430: check predicate 60
5645 OPC_Decode, 222, 123, 59, // 9432: decode to SD_AQRL using decoder 59
5646 // 9432: }
5647 // 9432: } // switch Inst[14:7]
5648 // 9432: }
5649 32, 35, // 9436: case 0x20: {
5650 OPC_SwitchField, 12, 3, // 9438: switch Inst[14:12] {
5651 0, 6, // 9441: case 0x0: {
5652 OPC_CheckPredicate, 51, // 9443: check predicate 51
5653 OPC_Decode, 156, 110, 56, // 9445: decode to AMOOR_B using decoder 56
5654 // 9445: }
5655 1, 6, // 9449: case 0x1: {
5656 OPC_CheckPredicate, 51, // 9451: check predicate 51
5657 OPC_Decode, 164, 110, 56, // 9453: decode to AMOOR_H using decoder 56
5658 // 9453: }
5659 2, 6, // 9457: case 0x2: {
5660 OPC_CheckPredicate, 52, // 9459: check predicate 52
5661 OPC_Decode, 168, 110, 56, // 9461: decode to AMOOR_W using decoder 56
5662 // 9461: }
5663 3, 0, // 9465: case 0x3: {
5664 OPC_CheckPredicate, 53, // 9467: check predicate 53
5665 OPC_Decode, 160, 110, 56, // 9469: decode to AMOOR_D using decoder 56
5666 // 9469: }
5667 // 9469: } // switch Inst[14:12]
5668 // 9469: }
5669 33, 35, // 9473: case 0x21: {
5670 OPC_SwitchField, 12, 3, // 9475: switch Inst[14:12] {
5671 0, 6, // 9478: case 0x0: {
5672 OPC_CheckPredicate, 51, // 9480: check predicate 51
5673 OPC_Decode, 159, 110, 56, // 9482: decode to AMOOR_B_RL using decoder 56
5674 // 9482: }
5675 1, 6, // 9486: case 0x1: {
5676 OPC_CheckPredicate, 51, // 9488: check predicate 51
5677 OPC_Decode, 167, 110, 56, // 9490: decode to AMOOR_H_RL using decoder 56
5678 // 9490: }
5679 2, 6, // 9494: case 0x2: {
5680 OPC_CheckPredicate, 52, // 9496: check predicate 52
5681 OPC_Decode, 171, 110, 56, // 9498: decode to AMOOR_W_RL using decoder 56
5682 // 9498: }
5683 3, 0, // 9502: case 0x3: {
5684 OPC_CheckPredicate, 53, // 9504: check predicate 53
5685 OPC_Decode, 163, 110, 56, // 9506: decode to AMOOR_D_RL using decoder 56
5686 // 9506: }
5687 // 9506: } // switch Inst[14:12]
5688 // 9506: }
5689 34, 35, // 9510: case 0x22: {
5690 OPC_SwitchField, 12, 3, // 9512: switch Inst[14:12] {
5691 0, 6, // 9515: case 0x0: {
5692 OPC_CheckPredicate, 51, // 9517: check predicate 51
5693 OPC_Decode, 157, 110, 56, // 9519: decode to AMOOR_B_AQ using decoder 56
5694 // 9519: }
5695 1, 6, // 9523: case 0x1: {
5696 OPC_CheckPredicate, 51, // 9525: check predicate 51
5697 OPC_Decode, 165, 110, 56, // 9527: decode to AMOOR_H_AQ using decoder 56
5698 // 9527: }
5699 2, 6, // 9531: case 0x2: {
5700 OPC_CheckPredicate, 52, // 9533: check predicate 52
5701 OPC_Decode, 169, 110, 56, // 9535: decode to AMOOR_W_AQ using decoder 56
5702 // 9535: }
5703 3, 0, // 9539: case 0x3: {
5704 OPC_CheckPredicate, 53, // 9541: check predicate 53
5705 OPC_Decode, 161, 110, 56, // 9543: decode to AMOOR_D_AQ using decoder 56
5706 // 9543: }
5707 // 9543: } // switch Inst[14:12]
5708 // 9543: }
5709 35, 35, // 9547: case 0x23: {
5710 OPC_SwitchField, 12, 3, // 9549: switch Inst[14:12] {
5711 0, 6, // 9552: case 0x0: {
5712 OPC_CheckPredicate, 51, // 9554: check predicate 51
5713 OPC_Decode, 158, 110, 56, // 9556: decode to AMOOR_B_AQRL using decoder 56
5714 // 9556: }
5715 1, 6, // 9560: case 0x1: {
5716 OPC_CheckPredicate, 51, // 9562: check predicate 51
5717 OPC_Decode, 166, 110, 56, // 9564: decode to AMOOR_H_AQRL using decoder 56
5718 // 9564: }
5719 2, 6, // 9568: case 0x2: {
5720 OPC_CheckPredicate, 52, // 9570: check predicate 52
5721 OPC_Decode, 170, 110, 56, // 9572: decode to AMOOR_W_AQRL using decoder 56
5722 // 9572: }
5723 3, 0, // 9576: case 0x3: {
5724 OPC_CheckPredicate, 53, // 9578: check predicate 53
5725 OPC_Decode, 162, 110, 56, // 9580: decode to AMOOR_D_AQRL using decoder 56
5726 // 9580: }
5727 // 9580: } // switch Inst[14:12]
5728 // 9580: }
5729 36, 19, // 9584: case 0x24: {
5730 OPC_SwitchField, 12, 3, // 9586: switch Inst[14:12] {
5731 2, 6, // 9589: case 0x2: {
5732 OPC_CheckPredicate, 61, // 9591: check predicate 61
5733 OPC_Decode, 247, 124, 56, // 9593: decode to SSAMOSWAP_W using decoder 56
5734 // 9593: }
5735 3, 0, // 9597: case 0x3: {
5736 OPC_CheckPredicate, 62, // 9599: check predicate 62
5737 OPC_Decode, 243, 124, 56, // 9601: decode to SSAMOSWAP_D using decoder 56
5738 // 9601: }
5739 // 9601: } // switch Inst[14:12]
5740 // 9601: }
5741 37, 19, // 9605: case 0x25: {
5742 OPC_SwitchField, 12, 3, // 9607: switch Inst[14:12] {
5743 2, 6, // 9610: case 0x2: {
5744 OPC_CheckPredicate, 61, // 9612: check predicate 61
5745 OPC_Decode, 250, 124, 56, // 9614: decode to SSAMOSWAP_W_RL using decoder 56
5746 // 9614: }
5747 3, 0, // 9618: case 0x3: {
5748 OPC_CheckPredicate, 62, // 9620: check predicate 62
5749 OPC_Decode, 246, 124, 56, // 9622: decode to SSAMOSWAP_D_RL using decoder 56
5750 // 9622: }
5751 // 9622: } // switch Inst[14:12]
5752 // 9622: }
5753 38, 19, // 9626: case 0x26: {
5754 OPC_SwitchField, 12, 3, // 9628: switch Inst[14:12] {
5755 2, 6, // 9631: case 0x2: {
5756 OPC_CheckPredicate, 61, // 9633: check predicate 61
5757 OPC_Decode, 248, 124, 56, // 9635: decode to SSAMOSWAP_W_AQ using decoder 56
5758 // 9635: }
5759 3, 0, // 9639: case 0x3: {
5760 OPC_CheckPredicate, 62, // 9641: check predicate 62
5761 OPC_Decode, 244, 124, 56, // 9643: decode to SSAMOSWAP_D_AQ using decoder 56
5762 // 9643: }
5763 // 9643: } // switch Inst[14:12]
5764 // 9643: }
5765 39, 19, // 9647: case 0x27: {
5766 OPC_SwitchField, 12, 3, // 9649: switch Inst[14:12] {
5767 2, 6, // 9652: case 0x2: {
5768 OPC_CheckPredicate, 61, // 9654: check predicate 61
5769 OPC_Decode, 249, 124, 56, // 9656: decode to SSAMOSWAP_W_AQRL using decoder 56
5770 // 9656: }
5771 3, 0, // 9660: case 0x3: {
5772 OPC_CheckPredicate, 62, // 9662: check predicate 62
5773 OPC_Decode, 245, 124, 56, // 9664: decode to SSAMOSWAP_D_AQRL using decoder 56
5774 // 9664: }
5775 // 9664: } // switch Inst[14:12]
5776 // 9664: }
5777 48, 35, // 9668: case 0x30: {
5778 OPC_SwitchField, 12, 3, // 9670: switch Inst[14:12] {
5779 0, 6, // 9673: case 0x0: {
5780 OPC_CheckPredicate, 51, // 9675: check predicate 51
5781 OPC_Decode, 180, 109, 56, // 9677: decode to AMOAND_B using decoder 56
5782 // 9677: }
5783 1, 6, // 9681: case 0x1: {
5784 OPC_CheckPredicate, 51, // 9683: check predicate 51
5785 OPC_Decode, 188, 109, 56, // 9685: decode to AMOAND_H using decoder 56
5786 // 9685: }
5787 2, 6, // 9689: case 0x2: {
5788 OPC_CheckPredicate, 52, // 9691: check predicate 52
5789 OPC_Decode, 192, 109, 56, // 9693: decode to AMOAND_W using decoder 56
5790 // 9693: }
5791 3, 0, // 9697: case 0x3: {
5792 OPC_CheckPredicate, 53, // 9699: check predicate 53
5793 OPC_Decode, 184, 109, 56, // 9701: decode to AMOAND_D using decoder 56
5794 // 9701: }
5795 // 9701: } // switch Inst[14:12]
5796 // 9701: }
5797 49, 35, // 9705: case 0x31: {
5798 OPC_SwitchField, 12, 3, // 9707: switch Inst[14:12] {
5799 0, 6, // 9710: case 0x0: {
5800 OPC_CheckPredicate, 51, // 9712: check predicate 51
5801 OPC_Decode, 183, 109, 56, // 9714: decode to AMOAND_B_RL using decoder 56
5802 // 9714: }
5803 1, 6, // 9718: case 0x1: {
5804 OPC_CheckPredicate, 51, // 9720: check predicate 51
5805 OPC_Decode, 191, 109, 56, // 9722: decode to AMOAND_H_RL using decoder 56
5806 // 9722: }
5807 2, 6, // 9726: case 0x2: {
5808 OPC_CheckPredicate, 52, // 9728: check predicate 52
5809 OPC_Decode, 195, 109, 56, // 9730: decode to AMOAND_W_RL using decoder 56
5810 // 9730: }
5811 3, 0, // 9734: case 0x3: {
5812 OPC_CheckPredicate, 53, // 9736: check predicate 53
5813 OPC_Decode, 187, 109, 56, // 9738: decode to AMOAND_D_RL using decoder 56
5814 // 9738: }
5815 // 9738: } // switch Inst[14:12]
5816 // 9738: }
5817 50, 35, // 9742: case 0x32: {
5818 OPC_SwitchField, 12, 3, // 9744: switch Inst[14:12] {
5819 0, 6, // 9747: case 0x0: {
5820 OPC_CheckPredicate, 51, // 9749: check predicate 51
5821 OPC_Decode, 181, 109, 56, // 9751: decode to AMOAND_B_AQ using decoder 56
5822 // 9751: }
5823 1, 6, // 9755: case 0x1: {
5824 OPC_CheckPredicate, 51, // 9757: check predicate 51
5825 OPC_Decode, 189, 109, 56, // 9759: decode to AMOAND_H_AQ using decoder 56
5826 // 9759: }
5827 2, 6, // 9763: case 0x2: {
5828 OPC_CheckPredicate, 52, // 9765: check predicate 52
5829 OPC_Decode, 193, 109, 56, // 9767: decode to AMOAND_W_AQ using decoder 56
5830 // 9767: }
5831 3, 0, // 9771: case 0x3: {
5832 OPC_CheckPredicate, 53, // 9773: check predicate 53
5833 OPC_Decode, 185, 109, 56, // 9775: decode to AMOAND_D_AQ using decoder 56
5834 // 9775: }
5835 // 9775: } // switch Inst[14:12]
5836 // 9775: }
5837 51, 35, // 9779: case 0x33: {
5838 OPC_SwitchField, 12, 3, // 9781: switch Inst[14:12] {
5839 0, 6, // 9784: case 0x0: {
5840 OPC_CheckPredicate, 51, // 9786: check predicate 51
5841 OPC_Decode, 182, 109, 56, // 9788: decode to AMOAND_B_AQRL using decoder 56
5842 // 9788: }
5843 1, 6, // 9792: case 0x1: {
5844 OPC_CheckPredicate, 51, // 9794: check predicate 51
5845 OPC_Decode, 190, 109, 56, // 9796: decode to AMOAND_H_AQRL using decoder 56
5846 // 9796: }
5847 2, 6, // 9800: case 0x2: {
5848 OPC_CheckPredicate, 52, // 9802: check predicate 52
5849 OPC_Decode, 194, 109, 56, // 9804: decode to AMOAND_W_AQRL using decoder 56
5850 // 9804: }
5851 3, 0, // 9808: case 0x3: {
5852 OPC_CheckPredicate, 53, // 9810: check predicate 53
5853 OPC_Decode, 186, 109, 56, // 9812: decode to AMOAND_D_AQRL using decoder 56
5854 // 9812: }
5855 // 9812: } // switch Inst[14:12]
5856 // 9812: }
5857 64, 35, // 9816: case 0x40: {
5858 OPC_SwitchField, 12, 3, // 9818: switch Inst[14:12] {
5859 0, 6, // 9821: case 0x0: {
5860 OPC_CheckPredicate, 51, // 9823: check predicate 51
5861 OPC_Decode, 140, 110, 56, // 9825: decode to AMOMIN_B using decoder 56
5862 // 9825: }
5863 1, 6, // 9829: case 0x1: {
5864 OPC_CheckPredicate, 51, // 9831: check predicate 51
5865 OPC_Decode, 148, 110, 56, // 9833: decode to AMOMIN_H using decoder 56
5866 // 9833: }
5867 2, 6, // 9837: case 0x2: {
5868 OPC_CheckPredicate, 52, // 9839: check predicate 52
5869 OPC_Decode, 152, 110, 56, // 9841: decode to AMOMIN_W using decoder 56
5870 // 9841: }
5871 3, 0, // 9845: case 0x3: {
5872 OPC_CheckPredicate, 53, // 9847: check predicate 53
5873 OPC_Decode, 144, 110, 56, // 9849: decode to AMOMIN_D using decoder 56
5874 // 9849: }
5875 // 9849: } // switch Inst[14:12]
5876 // 9849: }
5877 65, 35, // 9853: case 0x41: {
5878 OPC_SwitchField, 12, 3, // 9855: switch Inst[14:12] {
5879 0, 6, // 9858: case 0x0: {
5880 OPC_CheckPredicate, 51, // 9860: check predicate 51
5881 OPC_Decode, 143, 110, 56, // 9862: decode to AMOMIN_B_RL using decoder 56
5882 // 9862: }
5883 1, 6, // 9866: case 0x1: {
5884 OPC_CheckPredicate, 51, // 9868: check predicate 51
5885 OPC_Decode, 151, 110, 56, // 9870: decode to AMOMIN_H_RL using decoder 56
5886 // 9870: }
5887 2, 6, // 9874: case 0x2: {
5888 OPC_CheckPredicate, 52, // 9876: check predicate 52
5889 OPC_Decode, 155, 110, 56, // 9878: decode to AMOMIN_W_RL using decoder 56
5890 // 9878: }
5891 3, 0, // 9882: case 0x3: {
5892 OPC_CheckPredicate, 53, // 9884: check predicate 53
5893 OPC_Decode, 147, 110, 56, // 9886: decode to AMOMIN_D_RL using decoder 56
5894 // 9886: }
5895 // 9886: } // switch Inst[14:12]
5896 // 9886: }
5897 66, 35, // 9890: case 0x42: {
5898 OPC_SwitchField, 12, 3, // 9892: switch Inst[14:12] {
5899 0, 6, // 9895: case 0x0: {
5900 OPC_CheckPredicate, 51, // 9897: check predicate 51
5901 OPC_Decode, 141, 110, 56, // 9899: decode to AMOMIN_B_AQ using decoder 56
5902 // 9899: }
5903 1, 6, // 9903: case 0x1: {
5904 OPC_CheckPredicate, 51, // 9905: check predicate 51
5905 OPC_Decode, 149, 110, 56, // 9907: decode to AMOMIN_H_AQ using decoder 56
5906 // 9907: }
5907 2, 6, // 9911: case 0x2: {
5908 OPC_CheckPredicate, 52, // 9913: check predicate 52
5909 OPC_Decode, 153, 110, 56, // 9915: decode to AMOMIN_W_AQ using decoder 56
5910 // 9915: }
5911 3, 0, // 9919: case 0x3: {
5912 OPC_CheckPredicate, 53, // 9921: check predicate 53
5913 OPC_Decode, 145, 110, 56, // 9923: decode to AMOMIN_D_AQ using decoder 56
5914 // 9923: }
5915 // 9923: } // switch Inst[14:12]
5916 // 9923: }
5917 67, 35, // 9927: case 0x43: {
5918 OPC_SwitchField, 12, 3, // 9929: switch Inst[14:12] {
5919 0, 6, // 9932: case 0x0: {
5920 OPC_CheckPredicate, 51, // 9934: check predicate 51
5921 OPC_Decode, 142, 110, 56, // 9936: decode to AMOMIN_B_AQRL using decoder 56
5922 // 9936: }
5923 1, 6, // 9940: case 0x1: {
5924 OPC_CheckPredicate, 51, // 9942: check predicate 51
5925 OPC_Decode, 150, 110, 56, // 9944: decode to AMOMIN_H_AQRL using decoder 56
5926 // 9944: }
5927 2, 6, // 9948: case 0x2: {
5928 OPC_CheckPredicate, 52, // 9950: check predicate 52
5929 OPC_Decode, 154, 110, 56, // 9952: decode to AMOMIN_W_AQRL using decoder 56
5930 // 9952: }
5931 3, 0, // 9956: case 0x3: {
5932 OPC_CheckPredicate, 53, // 9958: check predicate 53
5933 OPC_Decode, 146, 110, 56, // 9960: decode to AMOMIN_D_AQRL using decoder 56
5934 // 9960: }
5935 // 9960: } // switch Inst[14:12]
5936 // 9960: }
5937 72, 43, // 9964: case 0x48: {
5938 OPC_SwitchField, 12, 3, // 9966: switch Inst[14:12] {
5939 1, 6, // 9969: case 0x1: {
5940 OPC_CheckPredicate, 63, // 9971: check predicate 63
5941 OPC_Decode, 236, 116, 56, // 9973: decode to LXH using decoder 56
5942 // 9973: }
5943 2, 6, // 9977: case 0x2: {
5944 OPC_CheckPredicate, 63, // 9979: check predicate 63
5945 OPC_Decode, 252, 116, 56, // 9981: decode to LXW using decoder 56
5946 // 9981: }
5947 3, 6, // 9985: case 0x3: {
5948 OPC_CheckPredicate, 64, // 9987: check predicate 64
5949 OPC_Decode, 235, 116, 56, // 9989: decode to LXD using decoder 56
5950 // 9989: }
5951 5, 6, // 9993: case 0x5: {
5952 OPC_CheckPredicate, 63, // 9995: check predicate 63
5953 OPC_Decode, 237, 116, 56, // 9997: decode to LXHU using decoder 56
5954 // 9997: }
5955 6, 0, // 10001: case 0x6: {
5956 OPC_CheckPredicate, 64, // 10003: check predicate 64
5957 OPC_Decode, 253, 116, 56, // 10005: decode to LXWU using decoder 56
5958 // 10005: }
5959 // 10005: } // switch Inst[14:12]
5960 // 10005: }
5961 80, 35, // 10009: case 0x50: {
5962 OPC_SwitchField, 12, 3, // 10011: switch Inst[14:12] {
5963 0, 6, // 10014: case 0x0: {
5964 OPC_CheckPredicate, 51, // 10016: check predicate 51
5965 OPC_Decode, 236, 109, 56, // 10018: decode to AMOMAX_B using decoder 56
5966 // 10018: }
5967 1, 6, // 10022: case 0x1: {
5968 OPC_CheckPredicate, 51, // 10024: check predicate 51
5969 OPC_Decode, 244, 109, 56, // 10026: decode to AMOMAX_H using decoder 56
5970 // 10026: }
5971 2, 6, // 10030: case 0x2: {
5972 OPC_CheckPredicate, 52, // 10032: check predicate 52
5973 OPC_Decode, 248, 109, 56, // 10034: decode to AMOMAX_W using decoder 56
5974 // 10034: }
5975 3, 0, // 10038: case 0x3: {
5976 OPC_CheckPredicate, 53, // 10040: check predicate 53
5977 OPC_Decode, 240, 109, 56, // 10042: decode to AMOMAX_D using decoder 56
5978 // 10042: }
5979 // 10042: } // switch Inst[14:12]
5980 // 10042: }
5981 81, 35, // 10046: case 0x51: {
5982 OPC_SwitchField, 12, 3, // 10048: switch Inst[14:12] {
5983 0, 6, // 10051: case 0x0: {
5984 OPC_CheckPredicate, 51, // 10053: check predicate 51
5985 OPC_Decode, 239, 109, 56, // 10055: decode to AMOMAX_B_RL using decoder 56
5986 // 10055: }
5987 1, 6, // 10059: case 0x1: {
5988 OPC_CheckPredicate, 51, // 10061: check predicate 51
5989 OPC_Decode, 247, 109, 56, // 10063: decode to AMOMAX_H_RL using decoder 56
5990 // 10063: }
5991 2, 6, // 10067: case 0x2: {
5992 OPC_CheckPredicate, 52, // 10069: check predicate 52
5993 OPC_Decode, 251, 109, 56, // 10071: decode to AMOMAX_W_RL using decoder 56
5994 // 10071: }
5995 3, 0, // 10075: case 0x3: {
5996 OPC_CheckPredicate, 53, // 10077: check predicate 53
5997 OPC_Decode, 243, 109, 56, // 10079: decode to AMOMAX_D_RL using decoder 56
5998 // 10079: }
5999 // 10079: } // switch Inst[14:12]
6000 // 10079: }
6001 82, 35, // 10083: case 0x52: {
6002 OPC_SwitchField, 12, 3, // 10085: switch Inst[14:12] {
6003 0, 6, // 10088: case 0x0: {
6004 OPC_CheckPredicate, 51, // 10090: check predicate 51
6005 OPC_Decode, 237, 109, 56, // 10092: decode to AMOMAX_B_AQ using decoder 56
6006 // 10092: }
6007 1, 6, // 10096: case 0x1: {
6008 OPC_CheckPredicate, 51, // 10098: check predicate 51
6009 OPC_Decode, 245, 109, 56, // 10100: decode to AMOMAX_H_AQ using decoder 56
6010 // 10100: }
6011 2, 6, // 10104: case 0x2: {
6012 OPC_CheckPredicate, 52, // 10106: check predicate 52
6013 OPC_Decode, 249, 109, 56, // 10108: decode to AMOMAX_W_AQ using decoder 56
6014 // 10108: }
6015 3, 0, // 10112: case 0x3: {
6016 OPC_CheckPredicate, 53, // 10114: check predicate 53
6017 OPC_Decode, 241, 109, 56, // 10116: decode to AMOMAX_D_AQ using decoder 56
6018 // 10116: }
6019 // 10116: } // switch Inst[14:12]
6020 // 10116: }
6021 83, 35, // 10120: case 0x53: {
6022 OPC_SwitchField, 12, 3, // 10122: switch Inst[14:12] {
6023 0, 6, // 10125: case 0x0: {
6024 OPC_CheckPredicate, 51, // 10127: check predicate 51
6025 OPC_Decode, 238, 109, 56, // 10129: decode to AMOMAX_B_AQRL using decoder 56
6026 // 10129: }
6027 1, 6, // 10133: case 0x1: {
6028 OPC_CheckPredicate, 51, // 10135: check predicate 51
6029 OPC_Decode, 246, 109, 56, // 10137: decode to AMOMAX_H_AQRL using decoder 56
6030 // 10137: }
6031 2, 6, // 10141: case 0x2: {
6032 OPC_CheckPredicate, 52, // 10143: check predicate 52
6033 OPC_Decode, 250, 109, 56, // 10145: decode to AMOMAX_W_AQRL using decoder 56
6034 // 10145: }
6035 3, 0, // 10149: case 0x3: {
6036 OPC_CheckPredicate, 53, // 10151: check predicate 53
6037 OPC_Decode, 242, 109, 56, // 10153: decode to AMOMAX_D_AQRL using decoder 56
6038 // 10153: }
6039 // 10153: } // switch Inst[14:12]
6040 // 10153: }
6041 96, 35, // 10157: case 0x60: {
6042 OPC_SwitchField, 12, 3, // 10159: switch Inst[14:12] {
6043 0, 6, // 10162: case 0x0: {
6044 OPC_CheckPredicate, 51, // 10164: check predicate 51
6045 OPC_Decode, 252, 109, 56, // 10166: decode to AMOMINU_B using decoder 56
6046 // 10166: }
6047 1, 6, // 10170: case 0x1: {
6048 OPC_CheckPredicate, 51, // 10172: check predicate 51
6049 OPC_Decode, 132, 110, 56, // 10174: decode to AMOMINU_H using decoder 56
6050 // 10174: }
6051 2, 6, // 10178: case 0x2: {
6052 OPC_CheckPredicate, 52, // 10180: check predicate 52
6053 OPC_Decode, 136, 110, 56, // 10182: decode to AMOMINU_W using decoder 56
6054 // 10182: }
6055 3, 0, // 10186: case 0x3: {
6056 OPC_CheckPredicate, 53, // 10188: check predicate 53
6057 OPC_Decode, 128, 110, 56, // 10190: decode to AMOMINU_D using decoder 56
6058 // 10190: }
6059 // 10190: } // switch Inst[14:12]
6060 // 10190: }
6061 97, 35, // 10194: case 0x61: {
6062 OPC_SwitchField, 12, 3, // 10196: switch Inst[14:12] {
6063 0, 6, // 10199: case 0x0: {
6064 OPC_CheckPredicate, 51, // 10201: check predicate 51
6065 OPC_Decode, 255, 109, 56, // 10203: decode to AMOMINU_B_RL using decoder 56
6066 // 10203: }
6067 1, 6, // 10207: case 0x1: {
6068 OPC_CheckPredicate, 51, // 10209: check predicate 51
6069 OPC_Decode, 135, 110, 56, // 10211: decode to AMOMINU_H_RL using decoder 56
6070 // 10211: }
6071 2, 6, // 10215: case 0x2: {
6072 OPC_CheckPredicate, 52, // 10217: check predicate 52
6073 OPC_Decode, 139, 110, 56, // 10219: decode to AMOMINU_W_RL using decoder 56
6074 // 10219: }
6075 3, 0, // 10223: case 0x3: {
6076 OPC_CheckPredicate, 53, // 10225: check predicate 53
6077 OPC_Decode, 131, 110, 56, // 10227: decode to AMOMINU_D_RL using decoder 56
6078 // 10227: }
6079 // 10227: } // switch Inst[14:12]
6080 // 10227: }
6081 98, 35, // 10231: case 0x62: {
6082 OPC_SwitchField, 12, 3, // 10233: switch Inst[14:12] {
6083 0, 6, // 10236: case 0x0: {
6084 OPC_CheckPredicate, 51, // 10238: check predicate 51
6085 OPC_Decode, 253, 109, 56, // 10240: decode to AMOMINU_B_AQ using decoder 56
6086 // 10240: }
6087 1, 6, // 10244: case 0x1: {
6088 OPC_CheckPredicate, 51, // 10246: check predicate 51
6089 OPC_Decode, 133, 110, 56, // 10248: decode to AMOMINU_H_AQ using decoder 56
6090 // 10248: }
6091 2, 6, // 10252: case 0x2: {
6092 OPC_CheckPredicate, 52, // 10254: check predicate 52
6093 OPC_Decode, 137, 110, 56, // 10256: decode to AMOMINU_W_AQ using decoder 56
6094 // 10256: }
6095 3, 0, // 10260: case 0x3: {
6096 OPC_CheckPredicate, 53, // 10262: check predicate 53
6097 OPC_Decode, 129, 110, 56, // 10264: decode to AMOMINU_D_AQ using decoder 56
6098 // 10264: }
6099 // 10264: } // switch Inst[14:12]
6100 // 10264: }
6101 99, 35, // 10268: case 0x63: {
6102 OPC_SwitchField, 12, 3, // 10270: switch Inst[14:12] {
6103 0, 6, // 10273: case 0x0: {
6104 OPC_CheckPredicate, 51, // 10275: check predicate 51
6105 OPC_Decode, 254, 109, 56, // 10277: decode to AMOMINU_B_AQRL using decoder 56
6106 // 10277: }
6107 1, 6, // 10281: case 0x1: {
6108 OPC_CheckPredicate, 51, // 10283: check predicate 51
6109 OPC_Decode, 134, 110, 56, // 10285: decode to AMOMINU_H_AQRL using decoder 56
6110 // 10285: }
6111 2, 6, // 10289: case 0x2: {
6112 OPC_CheckPredicate, 52, // 10291: check predicate 52
6113 OPC_Decode, 138, 110, 56, // 10293: decode to AMOMINU_W_AQRL using decoder 56
6114 // 10293: }
6115 3, 0, // 10297: case 0x3: {
6116 OPC_CheckPredicate, 53, // 10299: check predicate 53
6117 OPC_Decode, 130, 110, 56, // 10301: decode to AMOMINU_D_AQRL using decoder 56
6118 // 10301: }
6119 // 10301: } // switch Inst[14:12]
6120 // 10301: }
6121 104, 59, // 10305: case 0x68: {
6122 OPC_SwitchField, 12, 3, // 10307: switch Inst[14:12] {
6123 0, 6, // 10310: case 0x0: {
6124 OPC_CheckPredicate, 63, // 10312: check predicate 63
6125 OPC_Decode, 238, 116, 56, // 10314: decode to LXSB using decoder 56
6126 // 10314: }
6127 1, 6, // 10318: case 0x1: {
6128 OPC_CheckPredicate, 63, // 10320: check predicate 63
6129 OPC_Decode, 241, 116, 56, // 10322: decode to LXSH using decoder 56
6130 // 10322: }
6131 2, 6, // 10326: case 0x2: {
6132 OPC_CheckPredicate, 63, // 10328: check predicate 63
6133 OPC_Decode, 250, 116, 56, // 10330: decode to LXSW using decoder 56
6134 // 10330: }
6135 3, 6, // 10334: case 0x3: {
6136 OPC_CheckPredicate, 64, // 10336: check predicate 64
6137 OPC_Decode, 240, 116, 56, // 10338: decode to LXSD using decoder 56
6138 // 10338: }
6139 4, 6, // 10342: case 0x4: {
6140 OPC_CheckPredicate, 63, // 10344: check predicate 63
6141 OPC_Decode, 239, 116, 56, // 10346: decode to LXSBU using decoder 56
6142 // 10346: }
6143 5, 6, // 10350: case 0x5: {
6144 OPC_CheckPredicate, 63, // 10352: check predicate 63
6145 OPC_Decode, 242, 116, 56, // 10354: decode to LXSHU using decoder 56
6146 // 10354: }
6147 6, 0, // 10358: case 0x6: {
6148 OPC_CheckPredicate, 64, // 10360: check predicate 64
6149 OPC_Decode, 251, 116, 56, // 10362: decode to LXSWU using decoder 56
6150 // 10362: }
6151 // 10362: } // switch Inst[14:12]
6152 // 10362: }
6153 112, 35, // 10366: case 0x70: {
6154 OPC_SwitchField, 12, 3, // 10368: switch Inst[14:12] {
6155 0, 6, // 10371: case 0x0: {
6156 OPC_CheckPredicate, 51, // 10373: check predicate 51
6157 OPC_Decode, 220, 109, 56, // 10375: decode to AMOMAXU_B using decoder 56
6158 // 10375: }
6159 1, 6, // 10379: case 0x1: {
6160 OPC_CheckPredicate, 51, // 10381: check predicate 51
6161 OPC_Decode, 228, 109, 56, // 10383: decode to AMOMAXU_H using decoder 56
6162 // 10383: }
6163 2, 6, // 10387: case 0x2: {
6164 OPC_CheckPredicate, 52, // 10389: check predicate 52
6165 OPC_Decode, 232, 109, 56, // 10391: decode to AMOMAXU_W using decoder 56
6166 // 10391: }
6167 3, 0, // 10395: case 0x3: {
6168 OPC_CheckPredicate, 53, // 10397: check predicate 53
6169 OPC_Decode, 224, 109, 56, // 10399: decode to AMOMAXU_D using decoder 56
6170 // 10399: }
6171 // 10399: } // switch Inst[14:12]
6172 // 10399: }
6173 113, 35, // 10403: case 0x71: {
6174 OPC_SwitchField, 12, 3, // 10405: switch Inst[14:12] {
6175 0, 6, // 10408: case 0x0: {
6176 OPC_CheckPredicate, 51, // 10410: check predicate 51
6177 OPC_Decode, 223, 109, 56, // 10412: decode to AMOMAXU_B_RL using decoder 56
6178 // 10412: }
6179 1, 6, // 10416: case 0x1: {
6180 OPC_CheckPredicate, 51, // 10418: check predicate 51
6181 OPC_Decode, 231, 109, 56, // 10420: decode to AMOMAXU_H_RL using decoder 56
6182 // 10420: }
6183 2, 6, // 10424: case 0x2: {
6184 OPC_CheckPredicate, 52, // 10426: check predicate 52
6185 OPC_Decode, 235, 109, 56, // 10428: decode to AMOMAXU_W_RL using decoder 56
6186 // 10428: }
6187 3, 0, // 10432: case 0x3: {
6188 OPC_CheckPredicate, 53, // 10434: check predicate 53
6189 OPC_Decode, 227, 109, 56, // 10436: decode to AMOMAXU_D_RL using decoder 56
6190 // 10436: }
6191 // 10436: } // switch Inst[14:12]
6192 // 10436: }
6193 114, 35, // 10440: case 0x72: {
6194 OPC_SwitchField, 12, 3, // 10442: switch Inst[14:12] {
6195 0, 6, // 10445: case 0x0: {
6196 OPC_CheckPredicate, 51, // 10447: check predicate 51
6197 OPC_Decode, 221, 109, 56, // 10449: decode to AMOMAXU_B_AQ using decoder 56
6198 // 10449: }
6199 1, 6, // 10453: case 0x1: {
6200 OPC_CheckPredicate, 51, // 10455: check predicate 51
6201 OPC_Decode, 229, 109, 56, // 10457: decode to AMOMAXU_H_AQ using decoder 56
6202 // 10457: }
6203 2, 6, // 10461: case 0x2: {
6204 OPC_CheckPredicate, 52, // 10463: check predicate 52
6205 OPC_Decode, 233, 109, 56, // 10465: decode to AMOMAXU_W_AQ using decoder 56
6206 // 10465: }
6207 3, 0, // 10469: case 0x3: {
6208 OPC_CheckPredicate, 53, // 10471: check predicate 53
6209 OPC_Decode, 225, 109, 56, // 10473: decode to AMOMAXU_D_AQ using decoder 56
6210 // 10473: }
6211 // 10473: } // switch Inst[14:12]
6212 // 10473: }
6213 115, 35, // 10477: case 0x73: {
6214 OPC_SwitchField, 12, 3, // 10479: switch Inst[14:12] {
6215 0, 6, // 10482: case 0x0: {
6216 OPC_CheckPredicate, 51, // 10484: check predicate 51
6217 OPC_Decode, 222, 109, 56, // 10486: decode to AMOMAXU_B_AQRL using decoder 56
6218 // 10486: }
6219 1, 6, // 10490: case 0x1: {
6220 OPC_CheckPredicate, 51, // 10492: check predicate 51
6221 OPC_Decode, 230, 109, 56, // 10494: decode to AMOMAXU_H_AQRL using decoder 56
6222 // 10494: }
6223 2, 6, // 10498: case 0x2: {
6224 OPC_CheckPredicate, 52, // 10500: check predicate 52
6225 OPC_Decode, 234, 109, 56, // 10502: decode to AMOMAXU_W_AQRL using decoder 56
6226 // 10502: }
6227 3, 0, // 10506: case 0x3: {
6228 OPC_CheckPredicate, 53, // 10508: check predicate 53
6229 OPC_Decode, 226, 109, 56, // 10510: decode to AMOMAXU_D_AQRL using decoder 56
6230 // 10510: }
6231 // 10510: } // switch Inst[14:12]
6232 // 10510: }
6233 120, 0, // 10514: case 0x78: {
6234 OPC_SwitchField, 12, 3, // 10516: switch Inst[14:12] {
6235 0, 6, // 10519: case 0x0: {
6236 OPC_CheckPredicate, 64, // 10521: check predicate 64
6237 OPC_Decode, 243, 116, 56, // 10523: decode to LXSUWB using decoder 56
6238 // 10523: }
6239 1, 6, // 10527: case 0x1: {
6240 OPC_CheckPredicate, 64, // 10529: check predicate 64
6241 OPC_Decode, 246, 116, 56, // 10531: decode to LXSUWH using decoder 56
6242 // 10531: }
6243 2, 6, // 10535: case 0x2: {
6244 OPC_CheckPredicate, 64, // 10537: check predicate 64
6245 OPC_Decode, 248, 116, 56, // 10539: decode to LXSUWW using decoder 56
6246 // 10539: }
6247 3, 6, // 10543: case 0x3: {
6248 OPC_CheckPredicate, 64, // 10545: check predicate 64
6249 OPC_Decode, 245, 116, 56, // 10547: decode to LXSUWD using decoder 56
6250 // 10547: }
6251 4, 6, // 10551: case 0x4: {
6252 OPC_CheckPredicate, 64, // 10553: check predicate 64
6253 OPC_Decode, 244, 116, 56, // 10555: decode to LXSUWBU using decoder 56
6254 // 10555: }
6255 5, 6, // 10559: case 0x5: {
6256 OPC_CheckPredicate, 64, // 10561: check predicate 64
6257 OPC_Decode, 247, 116, 56, // 10563: decode to LXSUWHU using decoder 56
6258 // 10563: }
6259 6, 0, // 10567: case 0x6: {
6260 OPC_CheckPredicate, 64, // 10569: check predicate 64
6261 OPC_Decode, 249, 116, 56, // 10571: decode to LXSUWWU using decoder 56
6262 // 10571: }
6263 // 10571: } // switch Inst[14:12]
6264 // 10571: }
6265 // 10571: } // switch Inst[31:25]
6266 // 10571: }
6267 51, 138, 6, // 10575: case 0x33: {
6268 OPC_SwitchField, 25, 5, // 10578: switch Inst[29:25] {
6269 0, 126, // 10581: case 0x0: {
6270 OPC_SwitchField, 12, 3, // 10583: switch Inst[14:12] {
6271 0, 15, // 10586: case 0x0: {
6272 OPC_SwitchField, 30, 2, // 10588: switch Inst[31:30] {
6273 0, 4, // 10591: case 0x0: {
6274 OPC_Decode, 190, 107, 31, // 10593: decode to ADD using decoder 31
6275 // 10593: }
6276 1, 0, // 10597: case 0x1: {
6277 OPC_Decode, 134, 125, 31, // 10599: decode to SUB using decoder 31
6278 // 10599: }
6279 // 10599: } // switch Inst[31:30]
6280 // 10599: }
6281 1, 8, // 10603: case 0x1: {
6282 OPC_CheckField, 30, 2, 0, // 10605: check Inst[31:30] == 0x0
6283 OPC_Decode, 200, 124, 31, // 10609: decode to SLL using decoder 31
6284 // 10609: }
6285 2, 8, // 10613: case 0x2: {
6286 OPC_CheckField, 30, 2, 0, // 10615: check Inst[31:30] == 0x0
6287 OPC_Decode, 205, 124, 31, // 10619: decode to SLT using decoder 31
6288 // 10619: }
6289 3, 8, // 10623: case 0x3: {
6290 OPC_CheckField, 30, 2, 0, // 10625: check Inst[31:30] == 0x0
6291 OPC_Decode, 208, 124, 31, // 10629: decode to SLTU using decoder 31
6292 // 10629: }
6293 4, 19, // 10633: case 0x4: {
6294 OPC_SwitchField, 30, 2, // 10635: switch Inst[31:30] {
6295 0, 5, // 10638: case 0x0: {
6296 OPC_Decode, 146, 132, 1, 31, // 10640: decode to XOR using decoder 31
6297 // 10640: }
6298 1, 0, // 10645: case 0x1: {
6299 OPC_CheckPredicate, 43, // 10647: check predicate 43
6300 OPC_Decode, 145, 132, 1, 31, // 10649: decode to XNOR using decoder 31
6301 // 10649: }
6302 // 10649: } // switch Inst[31:30]
6303 // 10649: }
6304 5, 15, // 10654: case 0x5: {
6305 OPC_SwitchField, 30, 2, // 10656: switch Inst[31:30] {
6306 0, 4, // 10659: case 0x0: {
6307 OPC_Decode, 237, 124, 31, // 10661: decode to SRL using decoder 31
6308 // 10661: }
6309 1, 0, // 10665: case 0x1: {
6310 OPC_Decode, 230, 124, 31, // 10667: decode to SRA using decoder 31
6311 // 10667: }
6312 // 10667: } // switch Inst[31:30]
6313 // 10667: }
6314 6, 17, // 10671: case 0x6: {
6315 OPC_SwitchField, 30, 2, // 10673: switch Inst[31:30] {
6316 0, 4, // 10676: case 0x0: {
6317 OPC_Decode, 193, 118, 31, // 10678: decode to OR using decoder 31
6318 // 10678: }
6319 1, 0, // 10682: case 0x1: {
6320 OPC_CheckPredicate, 43, // 10684: check predicate 43
6321 OPC_Decode, 196, 118, 31, // 10686: decode to ORN using decoder 31
6322 // 10686: }
6323 // 10686: } // switch Inst[31:30]
6324 // 10686: }
6325 7, 0, // 10690: case 0x7: {
6326 OPC_SwitchField, 30, 2, // 10692: switch Inst[31:30] {
6327 0, 4, // 10695: case 0x0: {
6328 OPC_Decode, 204, 110, 31, // 10697: decode to AND using decoder 31
6329 // 10697: }
6330 1, 0, // 10701: case 0x1: {
6331 OPC_CheckPredicate, 43, // 10703: check predicate 43
6332 OPC_Decode, 206, 110, 31, // 10705: decode to ANDN using decoder 31
6333 // 10705: }
6334 // 10705: } // switch Inst[31:30]
6335 // 10705: }
6336 // 10705: } // switch Inst[14:12]
6337 // 10705: }
6338 1, 99, // 10709: case 0x1: {
6339 OPC_SwitchField, 12, 3, // 10711: switch Inst[14:12] {
6340 0, 10, // 10714: case 0x0: {
6341 OPC_CheckPredicate, 65, // 10716: check predicate 65
6342 OPC_CheckField, 30, 2, 0, // 10718: check Inst[31:30] == 0x0
6343 OPC_Decode, 228, 117, 31, // 10722: decode to MUL using decoder 31
6344 // 10722: }
6345 1, 10, // 10726: case 0x1: {
6346 OPC_CheckPredicate, 65, // 10728: check predicate 65
6347 OPC_CheckField, 30, 2, 0, // 10730: check Inst[31:30] == 0x0
6348 OPC_Decode, 229, 117, 31, // 10734: decode to MULH using decoder 31
6349 // 10734: }
6350 2, 10, // 10738: case 0x2: {
6351 OPC_CheckPredicate, 65, // 10740: check predicate 65
6352 OPC_CheckField, 30, 2, 0, // 10742: check Inst[31:30] == 0x0
6353 OPC_Decode, 233, 117, 31, // 10746: decode to MULHSU using decoder 31
6354 // 10746: }
6355 3, 10, // 10750: case 0x3: {
6356 OPC_CheckPredicate, 65, // 10752: check predicate 65
6357 OPC_CheckField, 30, 2, 0, // 10754: check Inst[31:30] == 0x0
6358 OPC_Decode, 236, 117, 31, // 10758: decode to MULHU using decoder 31
6359 // 10758: }
6360 4, 10, // 10762: case 0x4: {
6361 OPC_CheckPredicate, 66, // 10764: check predicate 66
6362 OPC_CheckField, 30, 2, 0, // 10766: check Inst[31:30] == 0x0
6363 OPC_Decode, 132, 114, 31, // 10770: decode to DIV using decoder 31
6364 // 10770: }
6365 5, 10, // 10774: case 0x5: {
6366 OPC_CheckPredicate, 66, // 10776: check predicate 66
6367 OPC_CheckField, 30, 2, 0, // 10778: check Inst[31:30] == 0x0
6368 OPC_Decode, 133, 114, 31, // 10782: decode to DIVU using decoder 31
6369 // 10782: }
6370 6, 10, // 10786: case 0x6: {
6371 OPC_CheckPredicate, 66, // 10788: check predicate 66
6372 OPC_CheckField, 30, 2, 0, // 10790: check Inst[31:30] == 0x0
6373 OPC_Decode, 188, 123, 31, // 10794: decode to REM using decoder 31
6374 // 10794: }
6375 7, 0, // 10798: case 0x7: {
6376 OPC_CheckPredicate, 66, // 10800: check predicate 66
6377 OPC_CheckField, 30, 2, 0, // 10802: check Inst[31:30] == 0x0
6378 OPC_Decode, 189, 123, 31, // 10806: decode to REMU using decoder 31
6379 // 10806: }
6380 // 10806: } // switch Inst[14:12]
6381 // 10806: }
6382 4, 64, // 10810: case 0x4: {
6383 OPC_SwitchField, 12, 3, // 10812: switch Inst[14:12] {
6384 1, 10, // 10815: case 0x1: {
6385 OPC_CheckPredicate, 38, // 10817: check predicate 38
6386 OPC_CheckField, 30, 2, 1, // 10819: check Inst[31:30] == 0x1
6387 OPC_Decode, 210, 110, 31, // 10823: decode to BCLR using decoder 31
6388 // 10823: }
6389 4, 23, // 10827: case 0x4: {
6390 OPC_CheckField, 30, 2, 0, // 10829: check Inst[31:30] == 0x0
6391 OPC_Scope, 11, // 10833: try {
6392 OPC_CheckField, 20, 5, 0, // 10835: check Inst[24:20] == 0x0
6393 OPC_CheckPredicate, 45, // 10839: check predicate 45
6394 OPC_Decode, 169, 132, 1, 17, // 10841: decode to ZEXT_H_RV32 using decoder 17
6395 // 10841: } else try {
6396 OPC_CheckPredicate, 67, // 10846: check predicate 67
6397 OPC_Decode, 222, 118, 31, // 10848: decode to PACK using decoder 31
6398 // 10848: }
6399 // 10848: }
6400 5, 10, // 10852: case 0x5: {
6401 OPC_CheckPredicate, 38, // 10854: check predicate 38
6402 OPC_CheckField, 30, 2, 1, // 10856: check Inst[31:30] == 0x1
6403 OPC_Decode, 214, 110, 31, // 10860: decode to BEXT using decoder 31
6404 // 10860: }
6405 7, 0, // 10864: case 0x7: {
6406 OPC_CheckPredicate, 44, // 10866: check predicate 44
6407 OPC_CheckField, 30, 2, 0, // 10868: check Inst[31:30] == 0x0
6408 OPC_Decode, 223, 118, 31, // 10872: decode to PACKH using decoder 31
6409 // 10872: }
6410 // 10872: } // switch Inst[14:12]
6411 // 10872: }
6412 5, 87, // 10876: case 0x5: {
6413 OPC_SwitchField, 12, 3, // 10878: switch Inst[14:12] {
6414 1, 10, // 10881: case 0x1: {
6415 OPC_CheckPredicate, 68, // 10883: check predicate 68
6416 OPC_CheckField, 30, 2, 0, // 10885: check Inst[31:30] == 0x0
6417 OPC_Decode, 231, 110, 31, // 10889: decode to CLMUL using decoder 31
6418 // 10889: }
6419 2, 10, // 10893: case 0x2: {
6420 OPC_CheckPredicate, 69, // 10895: check predicate 69
6421 OPC_CheckField, 30, 2, 0, // 10897: check Inst[31:30] == 0x0
6422 OPC_Decode, 233, 110, 31, // 10901: decode to CLMULR using decoder 31
6423 // 10901: }
6424 3, 10, // 10905: case 0x3: {
6425 OPC_CheckPredicate, 68, // 10907: check predicate 68
6426 OPC_CheckField, 30, 2, 0, // 10909: check Inst[31:30] == 0x0
6427 OPC_Decode, 232, 110, 31, // 10913: decode to CLMULH using decoder 31
6428 // 10913: }
6429 4, 10, // 10917: case 0x4: {
6430 OPC_CheckPredicate, 41, // 10919: check predicate 41
6431 OPC_CheckField, 30, 2, 0, // 10921: check Inst[31:30] == 0x0
6432 OPC_Decode, 157, 117, 31, // 10925: decode to MIN using decoder 31
6433 // 10925: }
6434 5, 10, // 10929: case 0x5: {
6435 OPC_CheckPredicate, 41, // 10931: check predicate 41
6436 OPC_CheckField, 30, 2, 0, // 10933: check Inst[31:30] == 0x0
6437 OPC_Decode, 158, 117, 31, // 10937: decode to MINU using decoder 31
6438 // 10937: }
6439 6, 10, // 10941: case 0x6: {
6440 OPC_CheckPredicate, 41, // 10943: check predicate 41
6441 OPC_CheckField, 30, 2, 0, // 10945: check Inst[31:30] == 0x0
6442 OPC_Decode, 142, 117, 31, // 10949: decode to MAX using decoder 31
6443 // 10949: }
6444 7, 0, // 10953: case 0x7: {
6445 OPC_CheckPredicate, 41, // 10955: check predicate 41
6446 OPC_CheckField, 30, 2, 0, // 10957: check Inst[31:30] == 0x0
6447 OPC_Decode, 143, 117, 31, // 10961: decode to MAXU using decoder 31
6448 // 10961: }
6449 // 10961: } // switch Inst[14:12]
6450 // 10961: }
6451 7, 27, // 10965: case 0x7: {
6452 OPC_SwitchField, 12, 3, // 10967: switch Inst[14:12] {
6453 5, 10, // 10970: case 0x5: {
6454 OPC_CheckPredicate, 70, // 10972: check predicate 70
6455 OPC_CheckField, 30, 2, 0, // 10974: check Inst[31:30] == 0x0
6456 OPC_Decode, 184, 113, 31, // 10978: decode to CZERO_EQZ using decoder 31
6457 // 10978: }
6458 7, 0, // 10982: case 0x7: {
6459 OPC_CheckPredicate, 70, // 10984: check predicate 70
6460 OPC_CheckField, 30, 2, 0, // 10986: check Inst[31:30] == 0x0
6461 OPC_Decode, 185, 113, 31, // 10990: decode to CZERO_NEZ using decoder 31
6462 // 10990: }
6463 // 10990: } // switch Inst[14:12]
6464 // 10990: }
6465 8, 14, // 10994: case 0x8: {
6466 OPC_CheckPredicate, 71, // 10996: check predicate 71
6467 OPC_CheckField, 30, 2, 1, // 10998: check Inst[31:30] == 0x1
6468 OPC_CheckField, 12, 3, 0, // 11002: check Inst[14:12] == 0x0
6469 OPC_Decode, 189, 124, 31, // 11006: decode to SHA512SUM0R using decoder 31
6470 // 11006: }
6471 9, 14, // 11010: case 0x9: {
6472 OPC_CheckPredicate, 71, // 11012: check predicate 71
6473 OPC_CheckField, 30, 2, 1, // 11014: check Inst[31:30] == 0x1
6474 OPC_CheckField, 12, 3, 0, // 11018: check Inst[14:12] == 0x0
6475 OPC_Decode, 191, 124, 31, // 11022: decode to SHA512SUM1R using decoder 31
6476 // 11022: }
6477 10, 14, // 11026: case 0xa: {
6478 OPC_CheckPredicate, 71, // 11028: check predicate 71
6479 OPC_CheckField, 30, 2, 1, // 11030: check Inst[31:30] == 0x1
6480 OPC_CheckField, 12, 3, 0, // 11034: check Inst[14:12] == 0x0
6481 OPC_Decode, 184, 124, 31, // 11038: decode to SHA512SIG0L using decoder 31
6482 // 11038: }
6483 11, 14, // 11042: case 0xb: {
6484 OPC_CheckPredicate, 71, // 11044: check predicate 71
6485 OPC_CheckField, 30, 2, 1, // 11046: check Inst[31:30] == 0x1
6486 OPC_CheckField, 12, 3, 0, // 11050: check Inst[14:12] == 0x0
6487 OPC_Decode, 187, 124, 31, // 11054: decode to SHA512SIG1L using decoder 31
6488 // 11054: }
6489 14, 14, // 11058: case 0xe: {
6490 OPC_CheckPredicate, 71, // 11060: check predicate 71
6491 OPC_CheckField, 30, 2, 1, // 11062: check Inst[31:30] == 0x1
6492 OPC_CheckField, 12, 3, 0, // 11066: check Inst[14:12] == 0x0
6493 OPC_Decode, 183, 124, 31, // 11070: decode to SHA512SIG0H using decoder 31
6494 // 11070: }
6495 15, 14, // 11074: case 0xf: {
6496 OPC_CheckPredicate, 71, // 11076: check predicate 71
6497 OPC_CheckField, 30, 2, 1, // 11078: check Inst[31:30] == 0x1
6498 OPC_CheckField, 12, 3, 0, // 11082: check Inst[14:12] == 0x0
6499 OPC_Decode, 186, 124, 31, // 11086: decode to SHA512SIG1H using decoder 31
6500 // 11086: }
6501 16, 63, // 11090: case 0x10: {
6502 OPC_SwitchField, 12, 3, // 11092: switch Inst[14:12] {
6503 1, 10, // 11095: case 0x1: {
6504 OPC_CheckPredicate, 43, // 11097: check predicate 43
6505 OPC_CheckField, 30, 2, 1, // 11099: check Inst[31:30] == 0x1
6506 OPC_Decode, 197, 123, 31, // 11103: decode to ROL using decoder 31
6507 // 11103: }
6508 2, 10, // 11107: case 0x2: {
6509 OPC_CheckPredicate, 72, // 11109: check predicate 72
6510 OPC_CheckField, 30, 2, 0, // 11111: check Inst[31:30] == 0x0
6511 OPC_Decode, 171, 124, 31, // 11115: decode to SH1ADD using decoder 31
6512 // 11115: }
6513 4, 10, // 11119: case 0x4: {
6514 OPC_CheckPredicate, 72, // 11121: check predicate 72
6515 OPC_CheckField, 30, 2, 0, // 11123: check Inst[31:30] == 0x0
6516 OPC_Decode, 173, 124, 31, // 11127: decode to SH2ADD using decoder 31
6517 // 11127: }
6518 5, 10, // 11131: case 0x5: {
6519 OPC_CheckPredicate, 43, // 11133: check predicate 43
6520 OPC_CheckField, 30, 2, 1, // 11135: check Inst[31:30] == 0x1
6521 OPC_Decode, 199, 123, 31, // 11139: decode to ROR using decoder 31
6522 // 11139: }
6523 6, 0, // 11143: case 0x6: {
6524 OPC_CheckPredicate, 72, // 11145: check predicate 72
6525 OPC_CheckField, 30, 2, 0, // 11147: check Inst[31:30] == 0x0
6526 OPC_Decode, 175, 124, 31, // 11151: decode to SH3ADD using decoder 31
6527 // 11151: }
6528 // 11151: } // switch Inst[14:12]
6529 // 11151: }
6530 17, 10, // 11155: case 0x11: {
6531 OPC_CheckPredicate, 73, // 11157: check predicate 73
6532 OPC_CheckField, 12, 3, 0, // 11159: check Inst[14:12] == 0x0
6533 OPC_Decode, 198, 107, 60, // 11163: decode to AES32ESI using decoder 60
6534 // 11163: }
6535 19, 10, // 11167: case 0x13: {
6536 OPC_CheckPredicate, 73, // 11169: check predicate 73
6537 OPC_CheckField, 12, 3, 0, // 11171: check Inst[14:12] == 0x0
6538 OPC_Decode, 199, 107, 60, // 11175: decode to AES32ESMI using decoder 60
6539 // 11175: }
6540 20, 50, // 11179: case 0x14: {
6541 OPC_SwitchField, 12, 3, // 11181: switch Inst[14:12] {
6542 1, 19, // 11184: case 0x1: {
6543 OPC_SwitchField, 30, 2, // 11186: switch Inst[31:30] {
6544 0, 6, // 11189: case 0x0: {
6545 OPC_CheckPredicate, 38, // 11191: check predicate 38
6546 OPC_Decode, 225, 110, 31, // 11193: decode to BSET using decoder 31
6547 // 11193: }
6548 1, 0, // 11197: case 0x1: {
6549 OPC_CheckPredicate, 38, // 11199: check predicate 38
6550 OPC_Decode, 218, 110, 31, // 11201: decode to BINV using decoder 31
6551 // 11201: }
6552 // 11201: } // switch Inst[31:30]
6553 // 11201: }
6554 2, 11, // 11205: case 0x2: {
6555 OPC_CheckPredicate, 74, // 11207: check predicate 74
6556 OPC_CheckField, 30, 2, 0, // 11209: check Inst[31:30] == 0x0
6557 OPC_Decode, 148, 132, 1, 31, // 11213: decode to XPERM4 using decoder 31
6558 // 11213: }
6559 4, 0, // 11218: case 0x4: {
6560 OPC_CheckPredicate, 74, // 11220: check predicate 74
6561 OPC_CheckField, 30, 2, 0, // 11222: check Inst[31:30] == 0x0
6562 OPC_Decode, 149, 132, 1, 31, // 11226: decode to XPERM8 using decoder 31
6563 // 11226: }
6564 // 11226: } // switch Inst[14:12]
6565 // 11226: }
6566 21, 10, // 11231: case 0x15: {
6567 OPC_CheckPredicate, 75, // 11233: check predicate 75
6568 OPC_CheckField, 12, 3, 0, // 11235: check Inst[14:12] == 0x0
6569 OPC_Decode, 196, 107, 60, // 11239: decode to AES32DSI using decoder 60
6570 // 11239: }
6571 23, 10, // 11243: case 0x17: {
6572 OPC_CheckPredicate, 75, // 11245: check predicate 75
6573 OPC_CheckField, 12, 3, 0, // 11247: check Inst[14:12] == 0x0
6574 OPC_Decode, 197, 107, 60, // 11251: decode to AES32DSMI using decoder 60
6575 // 11251: }
6576 24, 10, // 11255: case 0x18: {
6577 OPC_CheckPredicate, 76, // 11257: check predicate 76
6578 OPC_CheckField, 12, 3, 0, // 11259: check Inst[14:12] == 0x0
6579 OPC_Decode, 212, 124, 60, // 11263: decode to SM4ED using decoder 60
6580 // 11263: }
6581 25, 14, // 11267: case 0x19: {
6582 OPC_CheckPredicate, 77, // 11269: check predicate 77
6583 OPC_CheckField, 30, 2, 0, // 11271: check Inst[31:30] == 0x0
6584 OPC_CheckField, 12, 3, 0, // 11275: check Inst[14:12] == 0x0
6585 OPC_Decode, 202, 107, 31, // 11279: decode to AES64ES using decoder 31
6586 // 11279: }
6587 26, 10, // 11283: case 0x1a: {
6588 OPC_CheckPredicate, 76, // 11285: check predicate 76
6589 OPC_CheckField, 12, 3, 0, // 11287: check Inst[14:12] == 0x0
6590 OPC_Decode, 213, 124, 60, // 11291: decode to SM4KS using decoder 60
6591 // 11291: }
6592 27, 14, // 11295: case 0x1b: {
6593 OPC_CheckPredicate, 77, // 11297: check predicate 77
6594 OPC_CheckField, 30, 2, 0, // 11299: check Inst[31:30] == 0x0
6595 OPC_CheckField, 12, 3, 0, // 11303: check Inst[14:12] == 0x0
6596 OPC_Decode, 203, 107, 31, // 11307: decode to AES64ESM using decoder 31
6597 // 11307: }
6598 29, 14, // 11311: case 0x1d: {
6599 OPC_CheckPredicate, 39, // 11313: check predicate 39
6600 OPC_CheckField, 30, 2, 0, // 11315: check Inst[31:30] == 0x0
6601 OPC_CheckField, 12, 3, 0, // 11319: check Inst[14:12] == 0x0
6602 OPC_Decode, 200, 107, 31, // 11323: decode to AES64DS using decoder 31
6603 // 11323: }
6604 31, 0, // 11327: case 0x1f: {
6605 OPC_SwitchField, 30, 2, // 11329: switch Inst[31:30] {
6606 0, 10, // 11332: case 0x0: {
6607 OPC_CheckPredicate, 39, // 11334: check predicate 39
6608 OPC_CheckField, 12, 3, 0, // 11336: check Inst[14:12] == 0x0
6609 OPC_Decode, 201, 107, 31, // 11340: decode to AES64DSM using decoder 31
6610 // 11340: }
6611 1, 0, // 11344: case 0x1: {
6612 OPC_CheckPredicate, 40, // 11346: check predicate 40
6613 OPC_CheckField, 12, 3, 0, // 11348: check Inst[14:12] == 0x0
6614 OPC_Decode, 206, 107, 31, // 11352: decode to AES64KS2 using decoder 31
6615 // 11352: }
6616 // 11352: } // switch Inst[31:30]
6617 // 11352: }
6618 // 11352: } // switch Inst[29:25]
6619 // 11352: }
6620 55, 4, // 11356: case 0x37: {
6621 OPC_Decode, 229, 116, 20, // 11358: decode to LUI using decoder 20
6622 // 11358: }
6623 59, 155, 19, // 11362: case 0x3b: {
6624 OPC_SwitchField, 25, 7, // 11365: switch Inst[31:25] {
6625 0, 27, // 11368: case 0x0: {
6626 OPC_SwitchField, 12, 3, // 11370: switch Inst[14:12] {
6627 0, 6, // 11373: case 0x0: {
6628 OPC_CheckPredicate, 21, // 11375: check predicate 21
6629 OPC_Decode, 194, 107, 31, // 11377: decode to ADDW using decoder 31
6630 // 11377: }
6631 1, 6, // 11381: case 0x1: {
6632 OPC_CheckPredicate, 21, // 11383: check predicate 21
6633 OPC_Decode, 204, 124, 31, // 11385: decode to SLLW using decoder 31
6634 // 11385: }
6635 5, 0, // 11389: case 0x5: {
6636 OPC_CheckPredicate, 21, // 11391: check predicate 21
6637 OPC_Decode, 241, 124, 31, // 11393: decode to SRLW using decoder 31
6638 // 11393: }
6639 // 11393: } // switch Inst[14:12]
6640 // 11393: }
6641 1, 43, // 11397: case 0x1: {
6642 OPC_SwitchField, 12, 3, // 11399: switch Inst[14:12] {
6643 0, 6, // 11402: case 0x0: {
6644 OPC_CheckPredicate, 78, // 11404: check predicate 78
6645 OPC_Decode, 251, 117, 31, // 11406: decode to MULW using decoder 31
6646 // 11406: }
6647 4, 6, // 11410: case 0x4: {
6648 OPC_CheckPredicate, 79, // 11412: check predicate 79
6649 OPC_Decode, 135, 114, 31, // 11414: decode to DIVW using decoder 31
6650 // 11414: }
6651 5, 6, // 11418: case 0x5: {
6652 OPC_CheckPredicate, 79, // 11420: check predicate 79
6653 OPC_Decode, 134, 114, 31, // 11422: decode to DIVUW using decoder 31
6654 // 11422: }
6655 6, 6, // 11426: case 0x6: {
6656 OPC_CheckPredicate, 79, // 11428: check predicate 79
6657 OPC_Decode, 191, 123, 31, // 11430: decode to REMW using decoder 31
6658 // 11430: }
6659 7, 0, // 11434: case 0x7: {
6660 OPC_CheckPredicate, 79, // 11436: check predicate 79
6661 OPC_Decode, 190, 123, 31, // 11438: decode to REMUW using decoder 31
6662 // 11438: }
6663 // 11438: } // switch Inst[14:12]
6664 // 11438: }
6665 4, 32, // 11442: case 0x4: {
6666 OPC_SwitchField, 12, 3, // 11444: switch Inst[14:12] {
6667 0, 6, // 11447: case 0x0: {
6668 OPC_CheckPredicate, 49, // 11449: check predicate 49
6669 OPC_Decode, 195, 107, 31, // 11451: decode to ADD_UW using decoder 31
6670 // 11451: }
6671 4, 0, // 11455: case 0x4: {
6672 OPC_Scope, 11, // 11457: try {
6673 OPC_CheckField, 20, 5, 0, // 11459: check Inst[24:20] == 0x0
6674 OPC_CheckPredicate, 48, // 11463: check predicate 48
6675 OPC_Decode, 170, 132, 1, 17, // 11465: decode to ZEXT_H_RV64 using decoder 17
6676 // 11465: } else try {
6677 OPC_CheckPredicate, 80, // 11470: check predicate 80
6678 OPC_Decode, 224, 118, 31, // 11472: decode to PACKW using decoder 31
6679 // 11472: }
6680 // 11472: }
6681 // 11472: } // switch Inst[14:12]
6682 // 11472: }
6683 16, 27, // 11476: case 0x10: {
6684 OPC_SwitchField, 12, 3, // 11478: switch Inst[14:12] {
6685 2, 6, // 11481: case 0x2: {
6686 OPC_CheckPredicate, 49, // 11483: check predicate 49
6687 OPC_Decode, 172, 124, 31, // 11485: decode to SH1ADD_UW using decoder 31
6688 // 11485: }
6689 4, 6, // 11489: case 0x4: {
6690 OPC_CheckPredicate, 49, // 11491: check predicate 49
6691 OPC_Decode, 174, 124, 31, // 11493: decode to SH2ADD_UW using decoder 31
6692 // 11493: }
6693 6, 0, // 11497: case 0x6: {
6694 OPC_CheckPredicate, 49, // 11499: check predicate 49
6695 OPC_Decode, 176, 124, 31, // 11501: decode to SH3ADD_UW using decoder 31
6696 // 11501: }
6697 // 11501: } // switch Inst[14:12]
6698 // 11501: }
6699 32, 19, // 11505: case 0x20: {
6700 OPC_SwitchField, 12, 3, // 11507: switch Inst[14:12] {
6701 0, 6, // 11510: case 0x0: {
6702 OPC_CheckPredicate, 21, // 11512: check predicate 21
6703 OPC_Decode, 136, 125, 31, // 11514: decode to SUBW using decoder 31
6704 // 11514: }
6705 5, 0, // 11518: case 0x5: {
6706 OPC_CheckPredicate, 21, // 11520: check predicate 21
6707 OPC_Decode, 235, 124, 31, // 11522: decode to SRAW using decoder 31
6708 // 11522: }
6709 // 11522: } // switch Inst[14:12]
6710 // 11522: }
6711 48, 19, // 11526: case 0x30: {
6712 OPC_SwitchField, 12, 3, // 11528: switch Inst[14:12] {
6713 1, 6, // 11531: case 0x1: {
6714 OPC_CheckPredicate, 48, // 11533: check predicate 48
6715 OPC_Decode, 198, 123, 31, // 11535: decode to ROLW using decoder 31
6716 // 11535: }
6717 5, 0, // 11539: case 0x5: {
6718 OPC_CheckPredicate, 48, // 11541: check predicate 48
6719 OPC_Decode, 202, 123, 31, // 11543: decode to RORW using decoder 31
6720 // 11543: }
6721 // 11543: } // switch Inst[14:12]
6722 // 11543: }
6723 64, 59, // 11547: case 0x40: {
6724 OPC_SwitchField, 12, 3, // 11549: switch Inst[14:12] {
6725 0, 6, // 11552: case 0x0: {
6726 OPC_CheckPredicate, 42, // 11554: check predicate 42
6727 OPC_Decode, 234, 118, 31, // 11556: decode to PADD_H using decoder 31
6728 // 11556: }
6729 2, 6, // 11560: case 0x2: {
6730 OPC_CheckPredicate, 47, // 11562: check predicate 47
6731 OPC_Decode, 199, 120, 31, // 11564: decode to PNCLIPUP_B using decoder 31
6732 // 11564: }
6733 3, 6, // 11568: case 0x3: {
6734 OPC_CheckPredicate, 42, // 11570: check predicate 42
6735 OPC_Decode, 178, 120, 31, // 11572: decode to PMUL_H_B00 using decoder 31
6736 // 11572: }
6737 4, 6, // 11576: case 0x4: {
6738 OPC_CheckPredicate, 42, // 11578: check predicate 42
6739 OPC_Decode, 223, 120, 31, // 11580: decode to PPAIRE_B using decoder 31
6740 // 11580: }
6741 5, 6, // 11584: case 0x5: {
6742 OPC_CheckPredicate, 42, // 11586: check predicate 42
6743 OPC_Decode, 148, 119, 31, // 11588: decode to PM2ADD_H using decoder 31
6744 // 11588: }
6745 6, 6, // 11592: case 0x6: {
6746 OPC_CheckPredicate, 42, // 11594: check predicate 42
6747 OPC_Decode, 254, 118, 31, // 11596: decode to PAS_HX using decoder 31
6748 // 11596: }
6749 7, 0, // 11600: case 0x7: {
6750 OPC_CheckPredicate, 42, // 11602: check predicate 42
6751 OPC_Decode, 158, 120, 31, // 11604: decode to PMULH_H using decoder 31
6752 // 11604: }
6753 // 11604: } // switch Inst[14:12]
6754 // 11604: }
6755 65, 59, // 11608: case 0x41: {
6756 OPC_SwitchField, 12, 3, // 11610: switch Inst[14:12] {
6757 0, 6, // 11613: case 0x0: {
6758 OPC_CheckPredicate, 47, // 11615: check predicate 47
6759 OPC_Decode, 236, 118, 31, // 11617: decode to PADD_W using decoder 31
6760 // 11617: }
6761 2, 6, // 11621: case 0x2: {
6762 OPC_CheckPredicate, 47, // 11623: check predicate 47
6763 OPC_Decode, 200, 120, 31, // 11625: decode to PNCLIPUP_H using decoder 31
6764 // 11625: }
6765 3, 6, // 11629: case 0x3: {
6766 OPC_CheckPredicate, 47, // 11631: check predicate 47
6767 OPC_Decode, 181, 120, 31, // 11633: decode to PMUL_W_H00 using decoder 31
6768 // 11633: }
6769 4, 6, // 11637: case 0x4: {
6770 OPC_CheckPredicate, 47, // 11639: check predicate 47
6771 OPC_Decode, 226, 120, 31, // 11641: decode to PPAIRE_H using decoder 31
6772 // 11641: }
6773 5, 6, // 11645: case 0x5: {
6774 OPC_CheckPredicate, 47, // 11647: check predicate 47
6775 OPC_Decode, 150, 119, 31, // 11649: decode to PM2ADD_W using decoder 31
6776 // 11649: }
6777 6, 6, // 11653: case 0x6: {
6778 OPC_CheckPredicate, 47, // 11655: check predicate 47
6779 OPC_Decode, 255, 118, 31, // 11657: decode to PAS_WX using decoder 31
6780 // 11657: }
6781 7, 0, // 11661: case 0x7: {
6782 OPC_CheckPredicate, 47, // 11663: check predicate 47
6783 OPC_Decode, 161, 120, 31, // 11665: decode to PMULH_W using decoder 31
6784 // 11665: }
6785 // 11665: } // switch Inst[14:12]
6786 // 11665: }
6787 66, 35, // 11669: case 0x42: {
6788 OPC_SwitchField, 12, 3, // 11671: switch Inst[14:12] {
6789 0, 6, // 11674: case 0x0: {
6790 OPC_CheckPredicate, 42, // 11676: check predicate 42
6791 OPC_Decode, 226, 118, 31, // 11678: decode to PADD_B using decoder 31
6792 // 11678: }
6793 5, 6, // 11682: case 0x5: {
6794 OPC_CheckPredicate, 42, // 11684: check predicate 42
6795 OPC_Decode, 184, 119, 31, // 11686: decode to PM4ADD_B using decoder 31
6796 // 11686: }
6797 6, 6, // 11690: case 0x6: {
6798 OPC_CheckPredicate, 42, // 11692: check predicate 42
6799 OPC_Decode, 146, 121, 31, // 11694: decode to PSA_HX using decoder 31
6800 // 11694: }
6801 7, 0, // 11698: case 0x7: {
6802 OPC_CheckPredicate, 42, // 11700: check predicate 42
6803 OPC_Decode, 148, 120, 31, // 11702: decode to PMULHR_H using decoder 31
6804 // 11702: }
6805 // 11702: } // switch Inst[14:12]
6806 // 11702: }
6807 67, 43, // 11706: case 0x43: {
6808 OPC_SwitchField, 12, 3, // 11708: switch Inst[14:12] {
6809 2, 6, // 11711: case 0x2: {
6810 OPC_CheckPredicate, 47, // 11713: check predicate 47
6811 OPC_Decode, 201, 120, 31, // 11715: decode to PNCLIPUP_W using decoder 31
6812 // 11715: }
6813 3, 6, // 11719: case 0x3: {
6814 OPC_CheckPredicate, 47, // 11721: check predicate 47
6815 OPC_Decode, 255, 117, 31, // 11723: decode to MUL_W00 using decoder 31
6816 // 11723: }
6817 5, 6, // 11727: case 0x5: {
6818 OPC_CheckPredicate, 47, // 11729: check predicate 47
6819 OPC_Decode, 185, 119, 31, // 11731: decode to PM4ADD_H using decoder 31
6820 // 11731: }
6821 6, 6, // 11735: case 0x6: {
6822 OPC_CheckPredicate, 47, // 11737: check predicate 47
6823 OPC_Decode, 147, 121, 31, // 11739: decode to PSA_WX using decoder 31
6824 // 11739: }
6825 7, 0, // 11743: case 0x7: {
6826 OPC_CheckPredicate, 47, // 11745: check predicate 47
6827 OPC_Decode, 149, 120, 31, // 11747: decode to PMULHR_W using decoder 31
6828 // 11747: }
6829 // 11747: } // switch Inst[14:12]
6830 // 11747: }
6831 68, 19, // 11751: case 0x44: {
6832 OPC_SwitchField, 12, 3, // 11753: switch Inst[14:12] {
6833 5, 6, // 11756: case 0x5: {
6834 OPC_CheckPredicate, 42, // 11758: check predicate 42
6835 OPC_Decode, 140, 119, 61, // 11760: decode to PM2ADDA_H using decoder 61
6836 // 11760: }
6837 7, 0, // 11764: case 0x7: {
6838 OPC_CheckPredicate, 42, // 11766: check predicate 42
6839 OPC_Decode, 214, 119, 61, // 11768: decode to PMHACC_H using decoder 61
6840 // 11768: }
6841 // 11768: } // switch Inst[14:12]
6842 // 11768: }
6843 69, 27, // 11772: case 0x45: {
6844 OPC_SwitchField, 12, 3, // 11774: switch Inst[14:12] {
6845 3, 6, // 11777: case 0x3: {
6846 OPC_CheckPredicate, 47, // 11779: check predicate 47
6847 OPC_Decode, 191, 119, 61, // 11781: decode to PMACC_W_H00 using decoder 61
6848 // 11781: }
6849 5, 6, // 11785: case 0x5: {
6850 OPC_CheckPredicate, 47, // 11787: check predicate 47
6851 OPC_Decode, 142, 119, 61, // 11789: decode to PM2ADDA_W using decoder 61
6852 // 11789: }
6853 7, 0, // 11793: case 0x7: {
6854 OPC_CheckPredicate, 47, // 11795: check predicate 47
6855 OPC_Decode, 217, 119, 61, // 11797: decode to PMHACC_W using decoder 61
6856 // 11797: }
6857 // 11797: } // switch Inst[14:12]
6858 // 11797: }
6859 70, 19, // 11801: case 0x46: {
6860 OPC_SwitchField, 12, 3, // 11803: switch Inst[14:12] {
6861 5, 6, // 11806: case 0x5: {
6862 OPC_CheckPredicate, 42, // 11808: check predicate 42
6863 OPC_Decode, 178, 119, 61, // 11810: decode to PM4ADDA_B using decoder 61
6864 // 11810: }
6865 7, 0, // 11814: case 0x7: {
6866 OPC_CheckPredicate, 42, // 11816: check predicate 42
6867 OPC_Decode, 224, 119, 61, // 11818: decode to PMHRACC_H using decoder 61
6868 // 11818: }
6869 // 11818: } // switch Inst[14:12]
6870 // 11818: }
6871 71, 35, // 11822: case 0x47: {
6872 OPC_SwitchField, 12, 3, // 11824: switch Inst[14:12] {
6873 1, 6, // 11827: case 0x1: {
6874 OPC_CheckPredicate, 42, // 11829: check predicate 42
6875 OPC_Decode, 209, 124, 61, // 11831: decode to SLX using decoder 61
6876 // 11831: }
6877 3, 6, // 11835: case 0x3: {
6878 OPC_CheckPredicate, 47, // 11837: check predicate 47
6879 OPC_Decode, 139, 117, 61, // 11839: decode to MACC_W00 using decoder 61
6880 // 11839: }
6881 5, 6, // 11843: case 0x5: {
6882 OPC_CheckPredicate, 47, // 11845: check predicate 47
6883 OPC_Decode, 179, 119, 61, // 11847: decode to PM4ADDA_H using decoder 61
6884 // 11847: }
6885 7, 0, // 11851: case 0x7: {
6886 OPC_CheckPredicate, 47, // 11853: check predicate 47
6887 OPC_Decode, 225, 119, 61, // 11855: decode to PMHRACC_W using decoder 61
6888 // 11855: }
6889 // 11855: } // switch Inst[14:12]
6890 // 11855: }
6891 72, 59, // 11859: case 0x48: {
6892 OPC_SwitchField, 12, 3, // 11861: switch Inst[14:12] {
6893 0, 6, // 11864: case 0x0: {
6894 OPC_CheckPredicate, 42, // 11866: check predicate 42
6895 OPC_Decode, 136, 121, 31, // 11868: decode to PSADD_H using decoder 31
6896 // 11868: }
6897 1, 6, // 11872: case 0x1: {
6898 OPC_CheckPredicate, 42, // 11874: check predicate 42
6899 OPC_Decode, 179, 120, 31, // 11876: decode to PMUL_H_B01 using decoder 31
6900 // 11876: }
6901 3, 6, // 11880: case 0x3: {
6902 OPC_CheckPredicate, 42, // 11882: check predicate 42
6903 OPC_Decode, 180, 120, 31, // 11884: decode to PMUL_H_B11 using decoder 31
6904 // 11884: }
6905 4, 6, // 11888: case 0x4: {
6906 OPC_CheckPredicate, 42, // 11890: check predicate 42
6907 OPC_Decode, 218, 120, 31, // 11892: decode to PPAIREO_B using decoder 31
6908 // 11892: }
6909 5, 6, // 11896: case 0x5: {
6910 OPC_CheckPredicate, 42, // 11898: check predicate 42
6911 OPC_Decode, 149, 119, 31, // 11900: decode to PM2ADD_HX using decoder 31
6912 // 11900: }
6913 6, 6, // 11904: case 0x6: {
6914 OPC_CheckPredicate, 42, // 11906: check predicate 42
6915 OPC_Decode, 139, 121, 31, // 11908: decode to PSAS_HX using decoder 31
6916 // 11908: }
6917 7, 0, // 11912: case 0x7: {
6918 OPC_CheckPredicate, 42, // 11914: check predicate 42
6919 OPC_Decode, 156, 120, 31, // 11916: decode to PMULHU_H using decoder 31
6920 // 11916: }
6921 // 11916: } // switch Inst[14:12]
6922 // 11916: }
6923 73, 59, // 11920: case 0x49: {
6924 OPC_SwitchField, 12, 3, // 11922: switch Inst[14:12] {
6925 0, 6, // 11925: case 0x0: {
6926 OPC_CheckPredicate, 47, // 11927: check predicate 47
6927 OPC_Decode, 137, 121, 31, // 11929: decode to PSADD_W using decoder 31
6928 // 11929: }
6929 1, 6, // 11933: case 0x1: {
6930 OPC_CheckPredicate, 47, // 11935: check predicate 47
6931 OPC_Decode, 182, 120, 31, // 11937: decode to PMUL_W_H01 using decoder 31
6932 // 11937: }
6933 3, 6, // 11941: case 0x3: {
6934 OPC_CheckPredicate, 47, // 11943: check predicate 47
6935 OPC_Decode, 183, 120, 31, // 11945: decode to PMUL_W_H11 using decoder 31
6936 // 11945: }
6937 4, 6, // 11949: case 0x4: {
6938 OPC_CheckPredicate, 42, // 11951: check predicate 42
6939 OPC_Decode, 221, 120, 31, // 11953: decode to PPAIREO_H using decoder 31
6940 // 11953: }
6941 5, 6, // 11957: case 0x5: {
6942 OPC_CheckPredicate, 47, // 11959: check predicate 47
6943 OPC_Decode, 151, 119, 31, // 11961: decode to PM2ADD_WX using decoder 31
6944 // 11961: }
6945 6, 6, // 11965: case 0x6: {
6946 OPC_CheckPredicate, 47, // 11967: check predicate 47
6947 OPC_Decode, 140, 121, 31, // 11969: decode to PSAS_WX using decoder 31
6948 // 11969: }
6949 7, 0, // 11973: case 0x7: {
6950 OPC_CheckPredicate, 47, // 11975: check predicate 47
6951 OPC_Decode, 157, 120, 31, // 11977: decode to PMULHU_W using decoder 31
6952 // 11977: }
6953 // 11977: } // switch Inst[14:12]
6954 // 11977: }
6955 74, 27, // 11981: case 0x4a: {
6956 OPC_SwitchField, 12, 3, // 11983: switch Inst[14:12] {
6957 0, 6, // 11986: case 0x0: {
6958 OPC_CheckPredicate, 42, // 11988: check predicate 42
6959 OPC_Decode, 132, 121, 31, // 11990: decode to PSADD_B using decoder 31
6960 // 11990: }
6961 6, 6, // 11994: case 0x6: {
6962 OPC_CheckPredicate, 42, // 11996: check predicate 42
6963 OPC_Decode, 199, 121, 31, // 11998: decode to PSSA_HX using decoder 31
6964 // 11998: }
6965 7, 0, // 12002: case 0x7: {
6966 OPC_CheckPredicate, 42, // 12004: check predicate 42
6967 OPC_Decode, 146, 120, 31, // 12006: decode to PMULHRU_H using decoder 31
6968 // 12006: }
6969 // 12006: } // switch Inst[14:12]
6970 // 12006: }
6971 75, 43, // 12010: case 0x4b: {
6972 OPC_SwitchField, 12, 3, // 12012: switch Inst[14:12] {
6973 1, 6, // 12015: case 0x1: {
6974 OPC_CheckPredicate, 47, // 12017: check predicate 47
6975 OPC_Decode, 128, 118, 31, // 12019: decode to MUL_W01 using decoder 31
6976 // 12019: }
6977 3, 6, // 12023: case 0x3: {
6978 OPC_CheckPredicate, 47, // 12025: check predicate 47
6979 OPC_Decode, 129, 118, 31, // 12027: decode to MUL_W11 using decoder 31
6980 // 12027: }
6981 4, 6, // 12031: case 0x4: {
6982 OPC_CheckPredicate, 47, // 12033: check predicate 47
6983 OPC_Decode, 222, 120, 31, // 12035: decode to PPAIREO_W using decoder 31
6984 // 12035: }
6985 6, 6, // 12039: case 0x6: {
6986 OPC_CheckPredicate, 47, // 12041: check predicate 47
6987 OPC_Decode, 200, 121, 31, // 12043: decode to PSSA_WX using decoder 31
6988 // 12043: }
6989 7, 0, // 12047: case 0x7: {
6990 OPC_CheckPredicate, 47, // 12049: check predicate 47
6991 OPC_Decode, 147, 120, 31, // 12051: decode to PMULHRU_W using decoder 31
6992 // 12051: }
6993 // 12051: } // switch Inst[14:12]
6994 // 12051: }
6995 76, 35, // 12055: case 0x4c: {
6996 OPC_SwitchField, 12, 3, // 12057: switch Inst[14:12] {
6997 0, 6, // 12060: case 0x0: {
6998 OPC_CheckPredicate, 42, // 12062: check predicate 42
6999 OPC_Decode, 207, 118, 31, // 12064: decode to PAADD_H using decoder 31
7000 // 12064: }
7001 5, 6, // 12068: case 0x5: {
7002 OPC_CheckPredicate, 42, // 12070: check predicate 42
7003 OPC_Decode, 141, 119, 61, // 12072: decode to PM2ADDA_HX using decoder 61
7004 // 12072: }
7005 6, 6, // 12076: case 0x6: {
7006 OPC_CheckPredicate, 42, // 12078: check predicate 42
7007 OPC_Decode, 210, 118, 31, // 12080: decode to PAAS_HX using decoder 31
7008 // 12080: }
7009 7, 0, // 12084: case 0x7: {
7010 OPC_CheckPredicate, 42, // 12086: check predicate 42
7011 OPC_Decode, 212, 119, 61, // 12088: decode to PMHACCU_H using decoder 61
7012 // 12088: }
7013 // 12088: } // switch Inst[14:12]
7014 // 12088: }
7015 77, 51, // 12092: case 0x4d: {
7016 OPC_SwitchField, 12, 3, // 12094: switch Inst[14:12] {
7017 0, 6, // 12097: case 0x0: {
7018 OPC_CheckPredicate, 47, // 12099: check predicate 47
7019 OPC_Decode, 208, 118, 31, // 12101: decode to PAADD_W using decoder 31
7020 // 12101: }
7021 1, 6, // 12105: case 0x1: {
7022 OPC_CheckPredicate, 47, // 12107: check predicate 47
7023 OPC_Decode, 192, 119, 61, // 12109: decode to PMACC_W_H01 using decoder 61
7024 // 12109: }
7025 3, 6, // 12113: case 0x3: {
7026 OPC_CheckPredicate, 47, // 12115: check predicate 47
7027 OPC_Decode, 193, 119, 61, // 12117: decode to PMACC_W_H11 using decoder 61
7028 // 12117: }
7029 5, 6, // 12121: case 0x5: {
7030 OPC_CheckPredicate, 47, // 12123: check predicate 47
7031 OPC_Decode, 143, 119, 61, // 12125: decode to PM2ADDA_WX using decoder 61
7032 // 12125: }
7033 6, 6, // 12129: case 0x6: {
7034 OPC_CheckPredicate, 47, // 12131: check predicate 47
7035 OPC_Decode, 211, 118, 31, // 12133: decode to PAAS_WX using decoder 31
7036 // 12133: }
7037 7, 0, // 12137: case 0x7: {
7038 OPC_CheckPredicate, 47, // 12139: check predicate 47
7039 OPC_Decode, 213, 119, 61, // 12141: decode to PMHACCU_W using decoder 61
7040 // 12141: }
7041 // 12141: } // switch Inst[14:12]
7042 // 12141: }
7043 78, 27, // 12145: case 0x4e: {
7044 OPC_SwitchField, 12, 3, // 12147: switch Inst[14:12] {
7045 0, 6, // 12150: case 0x0: {
7046 OPC_CheckPredicate, 42, // 12152: check predicate 42
7047 OPC_Decode, 203, 118, 31, // 12154: decode to PAADD_B using decoder 31
7048 // 12154: }
7049 6, 6, // 12158: case 0x6: {
7050 OPC_CheckPredicate, 42, // 12160: check predicate 42
7051 OPC_Decode, 239, 118, 31, // 12162: decode to PASA_HX using decoder 31
7052 // 12162: }
7053 7, 0, // 12166: case 0x7: {
7054 OPC_CheckPredicate, 42, // 12168: check predicate 42
7055 OPC_Decode, 222, 119, 61, // 12170: decode to PMHRACCU_H using decoder 61
7056 // 12170: }
7057 // 12170: } // switch Inst[14:12]
7058 // 12170: }
7059 79, 35, // 12174: case 0x4f: {
7060 OPC_SwitchField, 12, 3, // 12176: switch Inst[14:12] {
7061 1, 6, // 12179: case 0x1: {
7062 OPC_CheckPredicate, 47, // 12181: check predicate 47
7063 OPC_Decode, 140, 117, 61, // 12183: decode to MACC_W01 using decoder 61
7064 // 12183: }
7065 3, 6, // 12187: case 0x3: {
7066 OPC_CheckPredicate, 47, // 12189: check predicate 47
7067 OPC_Decode, 141, 117, 61, // 12191: decode to MACC_W11 using decoder 61
7068 // 12191: }
7069 6, 6, // 12195: case 0x6: {
7070 OPC_CheckPredicate, 47, // 12197: check predicate 47
7071 OPC_Decode, 240, 118, 31, // 12199: decode to PASA_WX using decoder 31
7072 // 12199: }
7073 7, 0, // 12203: case 0x7: {
7074 OPC_CheckPredicate, 47, // 12205: check predicate 47
7075 OPC_Decode, 223, 119, 61, // 12207: decode to PMHRACCU_W using decoder 61
7076 // 12207: }
7077 // 12207: } // switch Inst[14:12]
7078 // 12207: }
7079 80, 43, // 12211: case 0x50: {
7080 OPC_SwitchField, 12, 3, // 12213: switch Inst[14:12] {
7081 2, 6, // 12216: case 0x2: {
7082 OPC_CheckPredicate, 42, // 12218: check predicate 42
7083 OPC_Decode, 156, 121, 31, // 12220: decode to PSH1ADD_H using decoder 31
7084 // 12220: }
7085 3, 6, // 12224: case 0x3: {
7086 OPC_CheckPredicate, 42, // 12226: check predicate 42
7087 OPC_Decode, 172, 120, 31, // 12228: decode to PMULU_H_B00 using decoder 31
7088 // 12228: }
7089 4, 6, // 12232: case 0x4: {
7090 OPC_CheckPredicate, 42, // 12234: check predicate 42
7091 OPC_Decode, 227, 120, 31, // 12236: decode to PPAIROE_B using decoder 31
7092 // 12236: }
7093 5, 6, // 12240: case 0x5: {
7094 OPC_CheckPredicate, 42, // 12242: check predicate 42
7095 OPC_Decode, 146, 119, 31, // 12244: decode to PM2ADDU_H using decoder 31
7096 // 12244: }
7097 7, 0, // 12248: case 0x7: {
7098 OPC_CheckPredicate, 42, // 12250: check predicate 42
7099 OPC_Decode, 159, 120, 31, // 12252: decode to PMULH_H_B0 using decoder 31
7100 // 12252: }
7101 // 12252: } // switch Inst[14:12]
7102 // 12252: }
7103 81, 43, // 12256: case 0x51: {
7104 OPC_SwitchField, 12, 3, // 12258: switch Inst[14:12] {
7105 2, 6, // 12261: case 0x2: {
7106 OPC_CheckPredicate, 47, // 12263: check predicate 47
7107 OPC_Decode, 157, 121, 31, // 12265: decode to PSH1ADD_W using decoder 31
7108 // 12265: }
7109 3, 6, // 12269: case 0x3: {
7110 OPC_CheckPredicate, 47, // 12271: check predicate 47
7111 OPC_Decode, 175, 120, 31, // 12273: decode to PMULU_W_H00 using decoder 31
7112 // 12273: }
7113 4, 6, // 12277: case 0x4: {
7114 OPC_CheckPredicate, 42, // 12279: check predicate 42
7115 OPC_Decode, 230, 120, 31, // 12281: decode to PPAIROE_H using decoder 31
7116 // 12281: }
7117 5, 6, // 12285: case 0x5: {
7118 OPC_CheckPredicate, 47, // 12287: check predicate 47
7119 OPC_Decode, 147, 119, 31, // 12289: decode to PM2ADDU_W using decoder 31
7120 // 12289: }
7121 7, 0, // 12293: case 0x7: {
7122 OPC_CheckPredicate, 47, // 12295: check predicate 47
7123 OPC_Decode, 162, 120, 31, // 12297: decode to PMULH_W_H0 using decoder 31
7124 // 12297: }
7125 // 12297: } // switch Inst[14:12]
7126 // 12297: }
7127 82, 19, // 12301: case 0x52: {
7128 OPC_SwitchField, 12, 3, // 12303: switch Inst[14:12] {
7129 5, 6, // 12306: case 0x5: {
7130 OPC_CheckPredicate, 42, // 12308: check predicate 42
7131 OPC_Decode, 182, 119, 31, // 12310: decode to PM4ADDU_B using decoder 31
7132 // 12310: }
7133 7, 0, // 12314: case 0x7: {
7134 OPC_CheckPredicate, 42, // 12316: check predicate 42
7135 OPC_Decode, 151, 120, 31, // 12318: decode to PMULHSU_H_B0 using decoder 31
7136 // 12318: }
7137 // 12318: } // switch Inst[14:12]
7138 // 12318: }
7139 83, 35, // 12322: case 0x53: {
7140 OPC_SwitchField, 12, 3, // 12324: switch Inst[14:12] {
7141 3, 6, // 12327: case 0x3: {
7142 OPC_CheckPredicate, 47, // 12329: check predicate 47
7143 OPC_Decode, 248, 117, 31, // 12331: decode to MULU_W00 using decoder 31
7144 // 12331: }
7145 4, 6, // 12335: case 0x4: {
7146 OPC_CheckPredicate, 47, // 12337: check predicate 47
7147 OPC_Decode, 231, 120, 31, // 12339: decode to PPAIROE_W using decoder 31
7148 // 12339: }
7149 5, 6, // 12343: case 0x5: {
7150 OPC_CheckPredicate, 47, // 12345: check predicate 47
7151 OPC_Decode, 183, 119, 31, // 12347: decode to PM4ADDU_H using decoder 31
7152 // 12347: }
7153 7, 0, // 12351: case 0x7: {
7154 OPC_CheckPredicate, 47, // 12353: check predicate 47
7155 OPC_Decode, 154, 120, 31, // 12355: decode to PMULHSU_W_H0 using decoder 31
7156 // 12355: }
7157 // 12355: } // switch Inst[14:12]
7158 // 12355: }
7159 84, 27, // 12359: case 0x54: {
7160 OPC_SwitchField, 12, 3, // 12361: switch Inst[14:12] {
7161 1, 6, // 12364: case 0x1: {
7162 OPC_CheckPredicate, 42, // 12366: check predicate 42
7163 OPC_Decode, 130, 118, 61, // 12368: decode to MVM using decoder 61
7164 // 12368: }
7165 5, 6, // 12372: case 0x5: {
7166 OPC_CheckPredicate, 42, // 12374: check predicate 42
7167 OPC_Decode, 138, 119, 61, // 12376: decode to PM2ADDAU_H using decoder 61
7168 // 12376: }
7169 7, 0, // 12380: case 0x7: {
7170 OPC_CheckPredicate, 42, // 12382: check predicate 42
7171 OPC_Decode, 215, 119, 61, // 12384: decode to PMHACC_H_B0 using decoder 61
7172 // 12384: }
7173 // 12384: } // switch Inst[14:12]
7174 // 12384: }
7175 85, 35, // 12388: case 0x55: {
7176 OPC_SwitchField, 12, 3, // 12390: switch Inst[14:12] {
7177 1, 6, // 12393: case 0x1: {
7178 OPC_CheckPredicate, 42, // 12395: check predicate 42
7179 OPC_Decode, 131, 118, 61, // 12397: decode to MVMN using decoder 61
7180 // 12397: }
7181 3, 6, // 12401: case 0x3: {
7182 OPC_CheckPredicate, 47, // 12403: check predicate 47
7183 OPC_Decode, 188, 119, 61, // 12405: decode to PMACCU_W_H00 using decoder 61
7184 // 12405: }
7185 5, 6, // 12409: case 0x5: {
7186 OPC_CheckPredicate, 47, // 12411: check predicate 47
7187 OPC_Decode, 139, 119, 61, // 12413: decode to PM2ADDAU_W using decoder 61
7188 // 12413: }
7189 7, 0, // 12417: case 0x7: {
7190 OPC_CheckPredicate, 47, // 12419: check predicate 47
7191 OPC_Decode, 218, 119, 61, // 12421: decode to PMHACC_W_H0 using decoder 61
7192 // 12421: }
7193 // 12421: } // switch Inst[14:12]
7194 // 12421: }
7195 86, 27, // 12425: case 0x56: {
7196 OPC_SwitchField, 12, 3, // 12427: switch Inst[14:12] {
7197 1, 6, // 12430: case 0x1: {
7198 OPC_CheckPredicate, 42, // 12432: check predicate 42
7199 OPC_Decode, 146, 117, 61, // 12434: decode to MERGE using decoder 61
7200 // 12434: }
7201 5, 6, // 12438: case 0x5: {
7202 OPC_CheckPredicate, 42, // 12440: check predicate 42
7203 OPC_Decode, 176, 119, 61, // 12442: decode to PM4ADDAU_B using decoder 61
7204 // 12442: }
7205 7, 0, // 12446: case 0x7: {
7206 OPC_CheckPredicate, 42, // 12448: check predicate 42
7207 OPC_Decode, 207, 119, 61, // 12450: decode to PMHACCSU_H_B0 using decoder 61
7208 // 12450: }
7209 // 12450: } // switch Inst[14:12]
7210 // 12450: }
7211 87, 35, // 12454: case 0x57: {
7212 OPC_SwitchField, 12, 3, // 12456: switch Inst[14:12] {
7213 1, 6, // 12459: case 0x1: {
7214 OPC_CheckPredicate, 42, // 12461: check predicate 42
7215 OPC_Decode, 242, 124, 61, // 12463: decode to SRX using decoder 61
7216 // 12463: }
7217 3, 6, // 12467: case 0x3: {
7218 OPC_CheckPredicate, 47, // 12469: check predicate 47
7219 OPC_Decode, 133, 117, 61, // 12471: decode to MACCU_W00 using decoder 61
7220 // 12471: }
7221 5, 6, // 12475: case 0x5: {
7222 OPC_CheckPredicate, 47, // 12477: check predicate 47
7223 OPC_Decode, 177, 119, 61, // 12479: decode to PM4ADDAU_H using decoder 61
7224 // 12479: }
7225 7, 0, // 12483: case 0x7: {
7226 OPC_CheckPredicate, 47, // 12485: check predicate 47
7227 OPC_Decode, 210, 119, 61, // 12487: decode to PMHACCSU_W_H0 using decoder 61
7228 // 12487: }
7229 // 12487: } // switch Inst[14:12]
7230 // 12487: }
7231 88, 59, // 12491: case 0x58: {
7232 OPC_SwitchField, 12, 3, // 12493: switch Inst[14:12] {
7233 0, 6, // 12496: case 0x0: {
7234 OPC_CheckPredicate, 42, // 12498: check predicate 42
7235 OPC_Decode, 130, 121, 31, // 12500: decode to PSADDU_H using decoder 31
7236 // 12500: }
7237 1, 6, // 12504: case 0x1: {
7238 OPC_CheckPredicate, 42, // 12506: check predicate 42
7239 OPC_Decode, 173, 120, 31, // 12508: decode to PMULU_H_B01 using decoder 31
7240 // 12508: }
7241 2, 6, // 12512: case 0x2: {
7242 OPC_CheckPredicate, 42, // 12514: check predicate 42
7243 OPC_Decode, 203, 121, 31, // 12516: decode to PSSH1SADD_H using decoder 31
7244 // 12516: }
7245 3, 6, // 12520: case 0x3: {
7246 OPC_CheckPredicate, 42, // 12522: check predicate 42
7247 OPC_Decode, 174, 120, 31, // 12524: decode to PMULU_H_B11 using decoder 31
7248 // 12524: }
7249 4, 6, // 12528: case 0x4: {
7250 OPC_CheckPredicate, 42, // 12530: check predicate 42
7251 OPC_Decode, 232, 120, 31, // 12532: decode to PPAIRO_B using decoder 31
7252 // 12532: }
7253 5, 6, // 12536: case 0x5: {
7254 OPC_CheckPredicate, 42, // 12538: check predicate 42
7255 OPC_Decode, 240, 119, 31, // 12540: decode to PMQ2ADD_H using decoder 31
7256 // 12540: }
7257 7, 0, // 12544: case 0x7: {
7258 OPC_CheckPredicate, 42, // 12546: check predicate 42
7259 OPC_Decode, 160, 120, 31, // 12548: decode to PMULH_H_B1 using decoder 31
7260 // 12548: }
7261 // 12548: } // switch Inst[14:12]
7262 // 12548: }
7263 89, 59, // 12552: case 0x59: {
7264 OPC_SwitchField, 12, 3, // 12554: switch Inst[14:12] {
7265 0, 6, // 12557: case 0x0: {
7266 OPC_CheckPredicate, 47, // 12559: check predicate 47
7267 OPC_Decode, 131, 121, 31, // 12561: decode to PSADDU_W using decoder 31
7268 // 12561: }
7269 1, 6, // 12565: case 0x1: {
7270 OPC_CheckPredicate, 47, // 12567: check predicate 47
7271 OPC_Decode, 176, 120, 31, // 12569: decode to PMULU_W_H01 using decoder 31
7272 // 12569: }
7273 2, 6, // 12573: case 0x2: {
7274 OPC_CheckPredicate, 47, // 12575: check predicate 47
7275 OPC_Decode, 204, 121, 31, // 12577: decode to PSSH1SADD_W using decoder 31
7276 // 12577: }
7277 3, 6, // 12581: case 0x3: {
7278 OPC_CheckPredicate, 47, // 12583: check predicate 47
7279 OPC_Decode, 177, 120, 31, // 12585: decode to PMULU_W_H11 using decoder 31
7280 // 12585: }
7281 4, 6, // 12589: case 0x4: {
7282 OPC_CheckPredicate, 42, // 12591: check predicate 42
7283 OPC_Decode, 235, 120, 31, // 12593: decode to PPAIRO_H using decoder 31
7284 // 12593: }
7285 5, 6, // 12597: case 0x5: {
7286 OPC_CheckPredicate, 47, // 12599: check predicate 47
7287 OPC_Decode, 241, 119, 31, // 12601: decode to PMQ2ADD_W using decoder 31
7288 // 12601: }
7289 7, 0, // 12605: case 0x7: {
7290 OPC_CheckPredicate, 47, // 12607: check predicate 47
7291 OPC_Decode, 163, 120, 31, // 12609: decode to PMULH_W_H1 using decoder 31
7292 // 12609: }
7293 // 12609: } // switch Inst[14:12]
7294 // 12609: }
7295 90, 35, // 12613: case 0x5a: {
7296 OPC_SwitchField, 12, 3, // 12615: switch Inst[14:12] {
7297 0, 6, // 12618: case 0x0: {
7298 OPC_CheckPredicate, 42, // 12620: check predicate 42
7299 OPC_Decode, 254, 120, 31, // 12622: decode to PSADDU_B using decoder 31
7300 // 12622: }
7301 1, 6, // 12626: case 0x1: {
7302 OPC_CheckPredicate, 42, // 12628: check predicate 42
7303 OPC_Decode, 213, 118, 31, // 12630: decode to PABDSUMU_B using decoder 31
7304 // 12630: }
7305 5, 6, // 12634: case 0x5: {
7306 OPC_CheckPredicate, 42, // 12636: check predicate 42
7307 OPC_Decode, 247, 119, 31, // 12638: decode to PMQR2ADD_H using decoder 31
7308 // 12638: }
7309 7, 0, // 12642: case 0x7: {
7310 OPC_CheckPredicate, 42, // 12644: check predicate 42
7311 OPC_Decode, 152, 120, 31, // 12646: decode to PMULHSU_H_B1 using decoder 31
7312 // 12646: }
7313 // 12646: } // switch Inst[14:12]
7314 // 12646: }
7315 91, 43, // 12650: case 0x5b: {
7316 OPC_SwitchField, 12, 3, // 12652: switch Inst[14:12] {
7317 1, 6, // 12655: case 0x1: {
7318 OPC_CheckPredicate, 47, // 12657: check predicate 47
7319 OPC_Decode, 249, 117, 31, // 12659: decode to MULU_W01 using decoder 31
7320 // 12659: }
7321 3, 6, // 12663: case 0x3: {
7322 OPC_CheckPredicate, 47, // 12665: check predicate 47
7323 OPC_Decode, 250, 117, 31, // 12667: decode to MULU_W11 using decoder 31
7324 // 12667: }
7325 4, 6, // 12671: case 0x4: {
7326 OPC_CheckPredicate, 47, // 12673: check predicate 47
7327 OPC_Decode, 236, 120, 31, // 12675: decode to PPAIRO_W using decoder 31
7328 // 12675: }
7329 5, 6, // 12679: case 0x5: {
7330 OPC_CheckPredicate, 47, // 12681: check predicate 47
7331 OPC_Decode, 248, 119, 31, // 12683: decode to PMQR2ADD_W using decoder 31
7332 // 12683: }
7333 7, 0, // 12687: case 0x7: {
7334 OPC_CheckPredicate, 47, // 12689: check predicate 47
7335 OPC_Decode, 155, 120, 31, // 12691: decode to PMULHSU_W_H1 using decoder 31
7336 // 12691: }
7337 // 12691: } // switch Inst[14:12]
7338 // 12691: }
7339 92, 27, // 12695: case 0x5c: {
7340 OPC_SwitchField, 12, 3, // 12697: switch Inst[14:12] {
7341 0, 6, // 12700: case 0x0: {
7342 OPC_CheckPredicate, 42, // 12702: check predicate 42
7343 OPC_Decode, 201, 118, 31, // 12704: decode to PAADDU_H using decoder 31
7344 // 12704: }
7345 5, 6, // 12708: case 0x5: {
7346 OPC_CheckPredicate, 42, // 12710: check predicate 42
7347 OPC_Decode, 238, 119, 61, // 12712: decode to PMQ2ADDA_H using decoder 61
7348 // 12712: }
7349 7, 0, // 12716: case 0x7: {
7350 OPC_CheckPredicate, 42, // 12718: check predicate 42
7351 OPC_Decode, 216, 119, 61, // 12720: decode to PMHACC_H_B1 using decoder 61
7352 // 12720: }
7353 // 12720: } // switch Inst[14:12]
7354 // 12720: }
7355 93, 43, // 12724: case 0x5d: {
7356 OPC_SwitchField, 12, 3, // 12726: switch Inst[14:12] {
7357 0, 6, // 12729: case 0x0: {
7358 OPC_CheckPredicate, 47, // 12731: check predicate 47
7359 OPC_Decode, 202, 118, 31, // 12733: decode to PAADDU_W using decoder 31
7360 // 12733: }
7361 1, 6, // 12737: case 0x1: {
7362 OPC_CheckPredicate, 47, // 12739: check predicate 47
7363 OPC_Decode, 189, 119, 61, // 12741: decode to PMACCU_W_H01 using decoder 61
7364 // 12741: }
7365 3, 6, // 12745: case 0x3: {
7366 OPC_CheckPredicate, 47, // 12747: check predicate 47
7367 OPC_Decode, 190, 119, 61, // 12749: decode to PMACCU_W_H11 using decoder 61
7368 // 12749: }
7369 5, 6, // 12753: case 0x5: {
7370 OPC_CheckPredicate, 47, // 12755: check predicate 47
7371 OPC_Decode, 239, 119, 61, // 12757: decode to PMQ2ADDA_W using decoder 61
7372 // 12757: }
7373 7, 0, // 12761: case 0x7: {
7374 OPC_CheckPredicate, 47, // 12763: check predicate 47
7375 OPC_Decode, 219, 119, 61, // 12765: decode to PMHACC_W_H1 using decoder 61
7376 // 12765: }
7377 // 12765: } // switch Inst[14:12]
7378 // 12765: }
7379 94, 35, // 12769: case 0x5e: {
7380 OPC_SwitchField, 12, 3, // 12771: switch Inst[14:12] {
7381 0, 6, // 12774: case 0x0: {
7382 OPC_CheckPredicate, 42, // 12776: check predicate 42
7383 OPC_Decode, 197, 118, 31, // 12778: decode to PAADDU_B using decoder 31
7384 // 12778: }
7385 1, 6, // 12782: case 0x1: {
7386 OPC_CheckPredicate, 42, // 12784: check predicate 42
7387 OPC_Decode, 212, 118, 61, // 12786: decode to PABDSUMAU_B using decoder 61
7388 // 12786: }
7389 5, 6, // 12790: case 0x5: {
7390 OPC_CheckPredicate, 42, // 12792: check predicate 42
7391 OPC_Decode, 245, 119, 61, // 12794: decode to PMQR2ADDA_H using decoder 61
7392 // 12794: }
7393 7, 0, // 12798: case 0x7: {
7394 OPC_CheckPredicate, 42, // 12800: check predicate 42
7395 OPC_Decode, 208, 119, 61, // 12802: decode to PMHACCSU_H_B1 using decoder 61
7396 // 12802: }
7397 // 12802: } // switch Inst[14:12]
7398 // 12802: }
7399 95, 35, // 12806: case 0x5f: {
7400 OPC_SwitchField, 12, 3, // 12808: switch Inst[14:12] {
7401 1, 6, // 12811: case 0x1: {
7402 OPC_CheckPredicate, 47, // 12813: check predicate 47
7403 OPC_Decode, 134, 117, 61, // 12815: decode to MACCU_W01 using decoder 61
7404 // 12815: }
7405 3, 6, // 12819: case 0x3: {
7406 OPC_CheckPredicate, 47, // 12821: check predicate 47
7407 OPC_Decode, 135, 117, 61, // 12823: decode to MACCU_W11 using decoder 61
7408 // 12823: }
7409 5, 6, // 12827: case 0x5: {
7410 OPC_CheckPredicate, 47, // 12829: check predicate 47
7411 OPC_Decode, 246, 119, 61, // 12831: decode to PMQR2ADDA_W using decoder 61
7412 // 12831: }
7413 7, 0, // 12835: case 0x7: {
7414 OPC_CheckPredicate, 47, // 12837: check predicate 47
7415 OPC_Decode, 211, 119, 61, // 12839: decode to PMHACCSU_W_H1 using decoder 61
7416 // 12839: }
7417 // 12839: } // switch Inst[14:12]
7418 // 12839: }
7419 96, 43, // 12843: case 0x60: {
7420 OPC_SwitchField, 12, 3, // 12845: switch Inst[14:12] {
7421 0, 6, // 12848: case 0x0: {
7422 OPC_CheckPredicate, 42, // 12850: check predicate 42
7423 OPC_Decode, 241, 121, 31, // 12852: decode to PSUB_H using decoder 31
7424 // 12852: }
7425 2, 6, // 12856: case 0x2: {
7426 OPC_CheckPredicate, 47, // 12858: check predicate 47
7427 OPC_Decode, 188, 120, 31, // 12860: decode to PNCLIPP_B using decoder 31
7428 // 12860: }
7429 5, 6, // 12864: case 0x5: {
7430 OPC_CheckPredicate, 42, // 12866: check predicate 42
7431 OPC_Decode, 158, 119, 31, // 12868: decode to PM2SUB_H using decoder 31
7432 // 12868: }
7433 6, 6, // 12872: case 0x6: {
7434 OPC_CheckPredicate, 42, // 12874: check predicate 42
7435 OPC_Decode, 130, 120, 31, // 12876: decode to PMSEQ_H using decoder 31
7436 // 12876: }
7437 7, 0, // 12880: case 0x7: {
7438 OPC_CheckPredicate, 42, // 12882: check predicate 42
7439 OPC_Decode, 150, 120, 31, // 12884: decode to PMULHSU_H using decoder 31
7440 // 12884: }
7441 // 12884: } // switch Inst[14:12]
7442 // 12884: }
7443 97, 43, // 12888: case 0x61: {
7444 OPC_SwitchField, 12, 3, // 12890: switch Inst[14:12] {
7445 0, 6, // 12893: case 0x0: {
7446 OPC_CheckPredicate, 47, // 12895: check predicate 47
7447 OPC_Decode, 242, 121, 31, // 12897: decode to PSUB_W using decoder 31
7448 // 12897: }
7449 2, 6, // 12901: case 0x2: {
7450 OPC_CheckPredicate, 47, // 12903: check predicate 47
7451 OPC_Decode, 189, 120, 31, // 12905: decode to PNCLIPP_H using decoder 31
7452 // 12905: }
7453 5, 6, // 12909: case 0x5: {
7454 OPC_CheckPredicate, 47, // 12911: check predicate 47
7455 OPC_Decode, 160, 119, 31, // 12913: decode to PM2SUB_W using decoder 31
7456 // 12913: }
7457 6, 6, // 12917: case 0x6: {
7458 OPC_CheckPredicate, 47, // 12919: check predicate 47
7459 OPC_Decode, 131, 120, 31, // 12921: decode to PMSEQ_W using decoder 31
7460 // 12921: }
7461 7, 0, // 12925: case 0x7: {
7462 OPC_CheckPredicate, 47, // 12927: check predicate 47
7463 OPC_Decode, 153, 120, 31, // 12929: decode to PMULHSU_W using decoder 31
7464 // 12929: }
7465 // 12929: } // switch Inst[14:12]
7466 // 12929: }
7467 98, 35, // 12933: case 0x62: {
7468 OPC_SwitchField, 12, 3, // 12935: switch Inst[14:12] {
7469 0, 6, // 12938: case 0x0: {
7470 OPC_CheckPredicate, 42, // 12940: check predicate 42
7471 OPC_Decode, 237, 121, 31, // 12942: decode to PSUB_B using decoder 31
7472 // 12942: }
7473 5, 6, // 12946: case 0x5: {
7474 OPC_CheckPredicate, 42, // 12948: check predicate 42
7475 OPC_Decode, 152, 119, 31, // 12950: decode to PM2SADD_H using decoder 31
7476 // 12950: }
7477 6, 6, // 12954: case 0x6: {
7478 OPC_CheckPredicate, 42, // 12956: check predicate 42
7479 OPC_Decode, 254, 119, 31, // 12958: decode to PMSEQ_B using decoder 31
7480 // 12958: }
7481 7, 0, // 12962: case 0x7: {
7482 OPC_CheckPredicate, 42, // 12964: check predicate 42
7483 OPC_Decode, 144, 120, 31, // 12966: decode to PMULHRSU_H using decoder 31
7484 // 12966: }
7485 // 12966: } // switch Inst[14:12]
7486 // 12966: }
7487 99, 19, // 12970: case 0x63: {
7488 OPC_SwitchField, 12, 3, // 12972: switch Inst[14:12] {
7489 2, 6, // 12975: case 0x2: {
7490 OPC_CheckPredicate, 47, // 12977: check predicate 47
7491 OPC_Decode, 190, 120, 31, // 12979: decode to PNCLIPP_W using decoder 31
7492 // 12979: }
7493 7, 0, // 12983: case 0x7: {
7494 OPC_CheckPredicate, 47, // 12985: check predicate 47
7495 OPC_Decode, 145, 120, 31, // 12987: decode to PMULHRSU_W using decoder 31
7496 // 12987: }
7497 // 12987: } // switch Inst[14:12]
7498 // 12987: }
7499 100, 27, // 12991: case 0x64: {
7500 OPC_SwitchField, 12, 3, // 12993: switch Inst[14:12] {
7501 0, 6, // 12996: case 0x0: {
7502 OPC_CheckPredicate, 42, // 12998: check predicate 42
7503 OPC_Decode, 221, 118, 31, // 13000: decode to PABD_H using decoder 31
7504 // 13000: }
7505 5, 6, // 13004: case 0x5: {
7506 OPC_CheckPredicate, 42, // 13006: check predicate 42
7507 OPC_Decode, 154, 119, 61, // 13008: decode to PM2SUBA_H using decoder 61
7508 // 13008: }
7509 7, 0, // 13012: case 0x7: {
7510 OPC_CheckPredicate, 42, // 13014: check predicate 42
7511 OPC_Decode, 206, 119, 61, // 13016: decode to PMHACCSU_H using decoder 61
7512 // 13016: }
7513 // 13016: } // switch Inst[14:12]
7514 // 13016: }
7515 101, 19, // 13020: case 0x65: {
7516 OPC_SwitchField, 12, 3, // 13022: switch Inst[14:12] {
7517 5, 6, // 13025: case 0x5: {
7518 OPC_CheckPredicate, 47, // 13027: check predicate 47
7519 OPC_Decode, 156, 119, 61, // 13029: decode to PM2SUBA_W using decoder 61
7520 // 13029: }
7521 7, 0, // 13033: case 0x7: {
7522 OPC_CheckPredicate, 47, // 13035: check predicate 47
7523 OPC_Decode, 209, 119, 61, // 13037: decode to PMHACCSU_W using decoder 61
7524 // 13037: }
7525 // 13037: } // switch Inst[14:12]
7526 // 13037: }
7527 102, 19, // 13041: case 0x66: {
7528 OPC_SwitchField, 12, 3, // 13043: switch Inst[14:12] {
7529 0, 6, // 13046: case 0x0: {
7530 OPC_CheckPredicate, 42, // 13048: check predicate 42
7531 OPC_Decode, 218, 118, 31, // 13050: decode to PABD_B using decoder 31
7532 // 13050: }
7533 7, 0, // 13054: case 0x7: {
7534 OPC_CheckPredicate, 42, // 13056: check predicate 42
7535 OPC_Decode, 220, 119, 61, // 13058: decode to PMHRACCSU_H using decoder 61
7536 // 13058: }
7537 // 13058: } // switch Inst[14:12]
7538 // 13058: }
7539 103, 10, // 13062: case 0x67: {
7540 OPC_CheckPredicate, 47, // 13064: check predicate 47
7541 OPC_CheckField, 12, 3, 7, // 13066: check Inst[14:12] == 0x7
7542 OPC_Decode, 221, 119, 61, // 13070: decode to PMHRACCSU_W using decoder 61
7543 // 13070: }
7544 104, 35, // 13074: case 0x68: {
7545 OPC_SwitchField, 12, 3, // 13076: switch Inst[14:12] {
7546 0, 6, // 13079: case 0x0: {
7547 OPC_CheckPredicate, 42, // 13081: check predicate 42
7548 OPC_Decode, 235, 121, 31, // 13083: decode to PSSUB_H using decoder 31
7549 // 13083: }
7550 5, 6, // 13087: case 0x5: {
7551 OPC_CheckPredicate, 42, // 13089: check predicate 42
7552 OPC_Decode, 159, 119, 31, // 13091: decode to PM2SUB_HX using decoder 31
7553 // 13091: }
7554 6, 6, // 13095: case 0x6: {
7555 OPC_CheckPredicate, 42, // 13097: check predicate 42
7556 OPC_Decode, 142, 120, 31, // 13099: decode to PMSLT_H using decoder 31
7557 // 13099: }
7558 7, 0, // 13103: case 0x7: {
7559 OPC_CheckPredicate, 42, // 13105: check predicate 42
7560 OPC_Decode, 166, 120, 31, // 13107: decode to PMULQ_H using decoder 31
7561 // 13107: }
7562 // 13107: } // switch Inst[14:12]
7563 // 13107: }
7564 105, 35, // 13111: case 0x69: {
7565 OPC_SwitchField, 12, 3, // 13113: switch Inst[14:12] {
7566 0, 6, // 13116: case 0x0: {
7567 OPC_CheckPredicate, 47, // 13118: check predicate 47
7568 OPC_Decode, 236, 121, 31, // 13120: decode to PSSUB_W using decoder 31
7569 // 13120: }
7570 5, 6, // 13124: case 0x5: {
7571 OPC_CheckPredicate, 47, // 13126: check predicate 47
7572 OPC_Decode, 161, 119, 31, // 13128: decode to PM2SUB_WX using decoder 31
7573 // 13128: }
7574 6, 6, // 13132: case 0x6: {
7575 OPC_CheckPredicate, 47, // 13134: check predicate 47
7576 OPC_Decode, 143, 120, 31, // 13136: decode to PMSLT_W using decoder 31
7577 // 13136: }
7578 7, 0, // 13140: case 0x7: {
7579 OPC_CheckPredicate, 47, // 13142: check predicate 47
7580 OPC_Decode, 167, 120, 31, // 13144: decode to PMULQ_W using decoder 31
7581 // 13144: }
7582 // 13144: } // switch Inst[14:12]
7583 // 13144: }
7584 106, 35, // 13148: case 0x6a: {
7585 OPC_SwitchField, 12, 3, // 13150: switch Inst[14:12] {
7586 0, 6, // 13153: case 0x0: {
7587 OPC_CheckPredicate, 42, // 13155: check predicate 42
7588 OPC_Decode, 231, 121, 31, // 13157: decode to PSSUB_B using decoder 31
7589 // 13157: }
7590 5, 6, // 13161: case 0x5: {
7591 OPC_CheckPredicate, 42, // 13163: check predicate 42
7592 OPC_Decode, 153, 119, 31, // 13165: decode to PM2SADD_HX using decoder 31
7593 // 13165: }
7594 6, 6, // 13169: case 0x6: {
7595 OPC_CheckPredicate, 42, // 13171: check predicate 42
7596 OPC_Decode, 138, 120, 31, // 13173: decode to PMSLT_B using decoder 31
7597 // 13173: }
7598 7, 0, // 13177: case 0x7: {
7599 OPC_CheckPredicate, 42, // 13179: check predicate 42
7600 OPC_Decode, 164, 120, 31, // 13181: decode to PMULQR_H using decoder 31
7601 // 13181: }
7602 // 13181: } // switch Inst[14:12]
7603 // 13181: }
7604 107, 10, // 13185: case 0x6b: {
7605 OPC_CheckPredicate, 47, // 13187: check predicate 47
7606 OPC_CheckField, 12, 3, 7, // 13189: check Inst[14:12] == 0x7
7607 OPC_Decode, 165, 120, 31, // 13193: decode to PMULQR_W using decoder 31
7608 // 13193: }
7609 108, 27, // 13197: case 0x6c: {
7610 OPC_SwitchField, 12, 3, // 13199: switch Inst[14:12] {
7611 0, 6, // 13202: case 0x0: {
7612 OPC_CheckPredicate, 42, // 13204: check predicate 42
7613 OPC_Decode, 251, 118, 31, // 13206: decode to PASUB_H using decoder 31
7614 // 13206: }
7615 5, 6, // 13210: case 0x5: {
7616 OPC_CheckPredicate, 42, // 13212: check predicate 42
7617 OPC_Decode, 155, 119, 61, // 13214: decode to PM2SUBA_HX using decoder 61
7618 // 13214: }
7619 6, 0, // 13218: case 0x6: {
7620 OPC_CheckPredicate, 42, // 13220: check predicate 42
7621 OPC_Decode, 136, 120, 31, // 13222: decode to PMSLTU_H using decoder 31
7622 // 13222: }
7623 // 13222: } // switch Inst[14:12]
7624 // 13222: }
7625 109, 27, // 13226: case 0x6d: {
7626 OPC_SwitchField, 12, 3, // 13228: switch Inst[14:12] {
7627 0, 6, // 13231: case 0x0: {
7628 OPC_CheckPredicate, 47, // 13233: check predicate 47
7629 OPC_Decode, 252, 118, 31, // 13235: decode to PASUB_W using decoder 31
7630 // 13235: }
7631 5, 6, // 13239: case 0x5: {
7632 OPC_CheckPredicate, 47, // 13241: check predicate 47
7633 OPC_Decode, 157, 119, 61, // 13243: decode to PM2SUBA_WX using decoder 61
7634 // 13243: }
7635 6, 0, // 13247: case 0x6: {
7636 OPC_CheckPredicate, 47, // 13249: check predicate 47
7637 OPC_Decode, 137, 120, 31, // 13251: decode to PMSLTU_W using decoder 31
7638 // 13251: }
7639 // 13251: } // switch Inst[14:12]
7640 // 13251: }
7641 110, 19, // 13255: case 0x6e: {
7642 OPC_SwitchField, 12, 3, // 13257: switch Inst[14:12] {
7643 0, 6, // 13260: case 0x0: {
7644 OPC_CheckPredicate, 42, // 13262: check predicate 42
7645 OPC_Decode, 247, 118, 31, // 13264: decode to PASUB_B using decoder 31
7646 // 13264: }
7647 6, 0, // 13268: case 0x6: {
7648 OPC_CheckPredicate, 42, // 13270: check predicate 42
7649 OPC_Decode, 132, 120, 31, // 13272: decode to PMSLTU_B using decoder 31
7650 // 13272: }
7651 // 13272: } // switch Inst[14:12]
7652 // 13272: }
7653 112, 35, // 13276: case 0x70: {
7654 OPC_SwitchField, 12, 3, // 13278: switch Inst[14:12] {
7655 2, 6, // 13281: case 0x2: {
7656 OPC_CheckPredicate, 47, // 13283: check predicate 47
7657 OPC_Decode, 254, 125, 31, // 13285: decode to UNZIP8P using decoder 31
7658 // 13285: }
7659 3, 6, // 13289: case 0x3: {
7660 OPC_CheckPredicate, 42, // 13291: check predicate 42
7661 OPC_Decode, 168, 120, 31, // 13293: decode to PMULSU_H_B00 using decoder 31
7662 // 13293: }
7663 5, 6, // 13297: case 0x5: {
7664 OPC_CheckPredicate, 42, // 13299: check predicate 42
7665 OPC_Decode, 144, 119, 31, // 13301: decode to PM2ADDSU_H using decoder 31
7666 // 13301: }
7667 6, 0, // 13305: case 0x6: {
7668 OPC_CheckPredicate, 42, // 13307: check predicate 42
7669 OPC_Decode, 236, 119, 31, // 13309: decode to PMIN_H using decoder 31
7670 // 13309: }
7671 // 13309: } // switch Inst[14:12]
7672 // 13309: }
7673 113, 35, // 13313: case 0x71: {
7674 OPC_SwitchField, 12, 3, // 13315: switch Inst[14:12] {
7675 2, 6, // 13318: case 0x2: {
7676 OPC_CheckPredicate, 47, // 13320: check predicate 47
7677 OPC_Decode, 252, 125, 31, // 13322: decode to UNZIP16P using decoder 31
7678 // 13322: }
7679 3, 6, // 13326: case 0x3: {
7680 OPC_CheckPredicate, 47, // 13328: check predicate 47
7681 OPC_Decode, 170, 120, 31, // 13330: decode to PMULSU_W_H00 using decoder 31
7682 // 13330: }
7683 5, 6, // 13334: case 0x5: {
7684 OPC_CheckPredicate, 47, // 13336: check predicate 47
7685 OPC_Decode, 145, 119, 31, // 13338: decode to PM2ADDSU_W using decoder 31
7686 // 13338: }
7687 6, 0, // 13342: case 0x6: {
7688 OPC_CheckPredicate, 47, // 13344: check predicate 47
7689 OPC_Decode, 237, 119, 31, // 13346: decode to PMIN_W using decoder 31
7690 // 13346: }
7691 // 13346: } // switch Inst[14:12]
7692 // 13346: }
7693 114, 27, // 13350: case 0x72: {
7694 OPC_SwitchField, 12, 3, // 13352: switch Inst[14:12] {
7695 2, 6, // 13355: case 0x2: {
7696 OPC_CheckPredicate, 47, // 13357: check predicate 47
7697 OPC_Decode, 253, 125, 31, // 13359: decode to UNZIP8HP using decoder 31
7698 // 13359: }
7699 5, 6, // 13363: case 0x5: {
7700 OPC_CheckPredicate, 42, // 13365: check predicate 42
7701 OPC_Decode, 180, 119, 31, // 13367: decode to PM4ADDSU_B using decoder 31
7702 // 13367: }
7703 6, 0, // 13371: case 0x6: {
7704 OPC_CheckPredicate, 42, // 13373: check predicate 42
7705 OPC_Decode, 232, 119, 31, // 13375: decode to PMIN_B using decoder 31
7706 // 13375: }
7707 // 13375: } // switch Inst[14:12]
7708 // 13375: }
7709 115, 27, // 13379: case 0x73: {
7710 OPC_SwitchField, 12, 3, // 13381: switch Inst[14:12] {
7711 2, 6, // 13384: case 0x2: {
7712 OPC_CheckPredicate, 47, // 13386: check predicate 47
7713 OPC_Decode, 251, 125, 31, // 13388: decode to UNZIP16HP using decoder 31
7714 // 13388: }
7715 3, 6, // 13392: case 0x3: {
7716 OPC_CheckPredicate, 47, // 13394: check predicate 47
7717 OPC_Decode, 243, 117, 31, // 13396: decode to MULSU_W00 using decoder 31
7718 // 13396: }
7719 5, 0, // 13400: case 0x5: {
7720 OPC_CheckPredicate, 47, // 13402: check predicate 47
7721 OPC_Decode, 181, 119, 31, // 13404: decode to PM4ADDSU_H using decoder 31
7722 // 13404: }
7723 // 13404: } // switch Inst[14:12]
7724 // 13404: }
7725 116, 35, // 13408: case 0x74: {
7726 OPC_SwitchField, 12, 3, // 13410: switch Inst[14:12] {
7727 0, 6, // 13413: case 0x0: {
7728 OPC_CheckPredicate, 42, // 13415: check predicate 42
7729 OPC_Decode, 217, 118, 31, // 13417: decode to PABDU_H using decoder 31
7730 // 13417: }
7731 5, 6, // 13421: case 0x5: {
7732 OPC_CheckPredicate, 42, // 13423: check predicate 42
7733 OPC_Decode, 136, 119, 61, // 13425: decode to PM2ADDASU_H using decoder 61
7734 // 13425: }
7735 6, 6, // 13429: case 0x6: {
7736 OPC_CheckPredicate, 42, // 13431: check predicate 42
7737 OPC_Decode, 230, 119, 31, // 13433: decode to PMINU_H using decoder 31
7738 // 13433: }
7739 7, 0, // 13437: case 0x7: {
7740 OPC_CheckPredicate, 47, // 13439: check predicate 47
7741 OPC_Decode, 242, 119, 61, // 13441: decode to PMQACC_W_H00 using decoder 61
7742 // 13441: }
7743 // 13441: } // switch Inst[14:12]
7744 // 13441: }
7745 117, 35, // 13445: case 0x75: {
7746 OPC_SwitchField, 12, 3, // 13447: switch Inst[14:12] {
7747 3, 6, // 13450: case 0x3: {
7748 OPC_CheckPredicate, 47, // 13452: check predicate 47
7749 OPC_Decode, 186, 119, 61, // 13454: decode to PMACCSU_W_H00 using decoder 61
7750 // 13454: }
7751 5, 6, // 13458: case 0x5: {
7752 OPC_CheckPredicate, 47, // 13460: check predicate 47
7753 OPC_Decode, 137, 119, 61, // 13462: decode to PM2ADDASU_W using decoder 61
7754 // 13462: }
7755 6, 6, // 13466: case 0x6: {
7756 OPC_CheckPredicate, 47, // 13468: check predicate 47
7757 OPC_Decode, 231, 119, 31, // 13470: decode to PMINU_W using decoder 31
7758 // 13470: }
7759 7, 0, // 13474: case 0x7: {
7760 OPC_CheckPredicate, 47, // 13476: check predicate 47
7761 OPC_Decode, 213, 117, 61, // 13478: decode to MQACC_W00 using decoder 61
7762 // 13478: }
7763 // 13478: } // switch Inst[14:12]
7764 // 13478: }
7765 118, 35, // 13482: case 0x76: {
7766 OPC_SwitchField, 12, 3, // 13484: switch Inst[14:12] {
7767 0, 6, // 13487: case 0x0: {
7768 OPC_CheckPredicate, 42, // 13489: check predicate 42
7769 OPC_Decode, 214, 118, 31, // 13491: decode to PABDU_B using decoder 31
7770 // 13491: }
7771 5, 6, // 13495: case 0x5: {
7772 OPC_CheckPredicate, 42, // 13497: check predicate 42
7773 OPC_Decode, 174, 119, 61, // 13499: decode to PM4ADDASU_B using decoder 61
7774 // 13499: }
7775 6, 6, // 13503: case 0x6: {
7776 OPC_CheckPredicate, 42, // 13505: check predicate 42
7777 OPC_Decode, 226, 119, 31, // 13507: decode to PMINU_B using decoder 31
7778 // 13507: }
7779 7, 0, // 13511: case 0x7: {
7780 OPC_CheckPredicate, 47, // 13513: check predicate 47
7781 OPC_Decode, 249, 119, 61, // 13515: decode to PMQRACC_W_H00 using decoder 61
7782 // 13515: }
7783 // 13515: } // switch Inst[14:12]
7784 // 13515: }
7785 119, 27, // 13519: case 0x77: {
7786 OPC_SwitchField, 12, 3, // 13521: switch Inst[14:12] {
7787 3, 6, // 13524: case 0x3: {
7788 OPC_CheckPredicate, 47, // 13526: check predicate 47
7789 OPC_Decode, 128, 117, 61, // 13528: decode to MACCSU_W00 using decoder 61
7790 // 13528: }
7791 5, 6, // 13532: case 0x5: {
7792 OPC_CheckPredicate, 47, // 13534: check predicate 47
7793 OPC_Decode, 175, 119, 61, // 13536: decode to PM4ADDASU_H using decoder 61
7794 // 13536: }
7795 7, 0, // 13540: case 0x7: {
7796 OPC_CheckPredicate, 47, // 13542: check predicate 47
7797 OPC_Decode, 219, 117, 61, // 13544: decode to MQRACC_W00 using decoder 61
7798 // 13544: }
7799 // 13544: } // switch Inst[14:12]
7800 // 13544: }
7801 120, 36, // 13548: case 0x78: {
7802 OPC_SwitchField, 12, 3, // 13550: switch Inst[14:12] {
7803 0, 6, // 13553: case 0x0: {
7804 OPC_CheckPredicate, 42, // 13555: check predicate 42
7805 OPC_Decode, 229, 121, 31, // 13557: decode to PSSUBU_H using decoder 31
7806 // 13557: }
7807 2, 7, // 13561: case 0x2: {
7808 OPC_CheckPredicate, 47, // 13563: check predicate 47
7809 OPC_Decode, 174, 132, 1, 31, // 13565: decode to ZIP8P using decoder 31
7810 // 13565: }
7811 3, 6, // 13570: case 0x3: {
7812 OPC_CheckPredicate, 42, // 13572: check predicate 42
7813 OPC_Decode, 169, 120, 31, // 13574: decode to PMULSU_H_B11 using decoder 31
7814 // 13574: }
7815 6, 0, // 13578: case 0x6: {
7816 OPC_CheckPredicate, 42, // 13580: check predicate 42
7817 OPC_Decode, 204, 119, 31, // 13582: decode to PMAX_H using decoder 31
7818 // 13582: }
7819 // 13582: } // switch Inst[14:12]
7820 // 13582: }
7821 121, 36, // 13586: case 0x79: {
7822 OPC_SwitchField, 12, 3, // 13588: switch Inst[14:12] {
7823 0, 6, // 13591: case 0x0: {
7824 OPC_CheckPredicate, 47, // 13593: check predicate 47
7825 OPC_Decode, 230, 121, 31, // 13595: decode to PSSUBU_W using decoder 31
7826 // 13595: }
7827 2, 7, // 13599: case 0x2: {
7828 OPC_CheckPredicate, 47, // 13601: check predicate 47
7829 OPC_Decode, 172, 132, 1, 31, // 13603: decode to ZIP16P using decoder 31
7830 // 13603: }
7831 3, 6, // 13608: case 0x3: {
7832 OPC_CheckPredicate, 47, // 13610: check predicate 47
7833 OPC_Decode, 171, 120, 31, // 13612: decode to PMULSU_W_H11 using decoder 31
7834 // 13612: }
7835 6, 0, // 13616: case 0x6: {
7836 OPC_CheckPredicate, 47, // 13618: check predicate 47
7837 OPC_Decode, 205, 119, 31, // 13620: decode to PMAX_W using decoder 31
7838 // 13620: }
7839 // 13620: } // switch Inst[14:12]
7840 // 13620: }
7841 122, 28, // 13624: case 0x7a: {
7842 OPC_SwitchField, 12, 3, // 13626: switch Inst[14:12] {
7843 0, 6, // 13629: case 0x0: {
7844 OPC_CheckPredicate, 42, // 13631: check predicate 42
7845 OPC_Decode, 225, 121, 31, // 13633: decode to PSSUBU_B using decoder 31
7846 // 13633: }
7847 2, 7, // 13637: case 0x2: {
7848 OPC_CheckPredicate, 47, // 13639: check predicate 47
7849 OPC_Decode, 173, 132, 1, 31, // 13641: decode to ZIP8HP using decoder 31
7850 // 13641: }
7851 6, 0, // 13646: case 0x6: {
7852 OPC_CheckPredicate, 42, // 13648: check predicate 42
7853 OPC_Decode, 200, 119, 31, // 13650: decode to PMAX_B using decoder 31
7854 // 13650: }
7855 // 13650: } // switch Inst[14:12]
7856 // 13650: }
7857 123, 20, // 13654: case 0x7b: {
7858 OPC_SwitchField, 12, 3, // 13656: switch Inst[14:12] {
7859 2, 7, // 13659: case 0x2: {
7860 OPC_CheckPredicate, 47, // 13661: check predicate 47
7861 OPC_Decode, 171, 132, 1, 31, // 13663: decode to ZIP16HP using decoder 31
7862 // 13663: }
7863 3, 0, // 13668: case 0x3: {
7864 OPC_CheckPredicate, 47, // 13670: check predicate 47
7865 OPC_Decode, 244, 117, 31, // 13672: decode to MULSU_W11 using decoder 31
7866 // 13672: }
7867 // 13672: } // switch Inst[14:12]
7868 // 13672: }
7869 124, 35, // 13676: case 0x7c: {
7870 OPC_SwitchField, 12, 3, // 13678: switch Inst[14:12] {
7871 0, 6, // 13681: case 0x0: {
7872 OPC_CheckPredicate, 42, // 13683: check predicate 42
7873 OPC_Decode, 245, 118, 31, // 13685: decode to PASUBU_H using decoder 31
7874 // 13685: }
7875 5, 6, // 13689: case 0x5: {
7876 OPC_CheckPredicate, 47, // 13691: check predicate 47
7877 OPC_Decode, 243, 119, 61, // 13693: decode to PMQACC_W_H01 using decoder 61
7878 // 13693: }
7879 6, 6, // 13697: case 0x6: {
7880 OPC_CheckPredicate, 42, // 13699: check predicate 42
7881 OPC_Decode, 198, 119, 31, // 13701: decode to PMAXU_H using decoder 31
7882 // 13701: }
7883 7, 0, // 13705: case 0x7: {
7884 OPC_CheckPredicate, 47, // 13707: check predicate 47
7885 OPC_Decode, 244, 119, 61, // 13709: decode to PMQACC_W_H11 using decoder 61
7886 // 13709: }
7887 // 13709: } // switch Inst[14:12]
7888 // 13709: }
7889 125, 43, // 13713: case 0x7d: {
7890 OPC_SwitchField, 12, 3, // 13715: switch Inst[14:12] {
7891 0, 6, // 13718: case 0x0: {
7892 OPC_CheckPredicate, 47, // 13720: check predicate 47
7893 OPC_Decode, 246, 118, 31, // 13722: decode to PASUBU_W using decoder 31
7894 // 13722: }
7895 3, 6, // 13726: case 0x3: {
7896 OPC_CheckPredicate, 47, // 13728: check predicate 47
7897 OPC_Decode, 187, 119, 61, // 13730: decode to PMACCSU_W_H11 using decoder 61
7898 // 13730: }
7899 5, 6, // 13734: case 0x5: {
7900 OPC_CheckPredicate, 47, // 13736: check predicate 47
7901 OPC_Decode, 214, 117, 61, // 13738: decode to MQACC_W01 using decoder 61
7902 // 13738: }
7903 6, 6, // 13742: case 0x6: {
7904 OPC_CheckPredicate, 47, // 13744: check predicate 47
7905 OPC_Decode, 199, 119, 31, // 13746: decode to PMAXU_W using decoder 31
7906 // 13746: }
7907 7, 0, // 13750: case 0x7: {
7908 OPC_CheckPredicate, 47, // 13752: check predicate 47
7909 OPC_Decode, 215, 117, 61, // 13754: decode to MQACC_W11 using decoder 61
7910 // 13754: }
7911 // 13754: } // switch Inst[14:12]
7912 // 13754: }
7913 126, 35, // 13758: case 0x7e: {
7914 OPC_SwitchField, 12, 3, // 13760: switch Inst[14:12] {
7915 0, 6, // 13763: case 0x0: {
7916 OPC_CheckPredicate, 42, // 13765: check predicate 42
7917 OPC_Decode, 241, 118, 31, // 13767: decode to PASUBU_B using decoder 31
7918 // 13767: }
7919 5, 6, // 13771: case 0x5: {
7920 OPC_CheckPredicate, 47, // 13773: check predicate 47
7921 OPC_Decode, 250, 119, 61, // 13775: decode to PMQRACC_W_H01 using decoder 61
7922 // 13775: }
7923 6, 6, // 13779: case 0x6: {
7924 OPC_CheckPredicate, 42, // 13781: check predicate 42
7925 OPC_Decode, 194, 119, 31, // 13783: decode to PMAXU_B using decoder 31
7926 // 13783: }
7927 7, 0, // 13787: case 0x7: {
7928 OPC_CheckPredicate, 47, // 13789: check predicate 47
7929 OPC_Decode, 251, 119, 61, // 13791: decode to PMQRACC_W_H11 using decoder 61
7930 // 13791: }
7931 // 13791: } // switch Inst[14:12]
7932 // 13791: }
7933 127, 0, // 13795: case 0x7f: {
7934 OPC_SwitchField, 12, 3, // 13797: switch Inst[14:12] {
7935 3, 6, // 13800: case 0x3: {
7936 OPC_CheckPredicate, 47, // 13802: check predicate 47
7937 OPC_Decode, 129, 117, 61, // 13804: decode to MACCSU_W11 using decoder 61
7938 // 13804: }
7939 5, 6, // 13808: case 0x5: {
7940 OPC_CheckPredicate, 47, // 13810: check predicate 47
7941 OPC_Decode, 220, 117, 61, // 13812: decode to MQRACC_W01 using decoder 61
7942 // 13812: }
7943 7, 0, // 13816: case 0x7: {
7944 OPC_CheckPredicate, 47, // 13818: check predicate 47
7945 OPC_Decode, 221, 117, 61, // 13820: decode to MQRACC_W11 using decoder 61
7946 // 13820: }
7947 // 13820: } // switch Inst[14:12]
7948 // 13820: }
7949 // 13820: } // switch Inst[31:25]
7950 // 13820: }
7951 67, 35, // 13824: case 0x43: {
7952 OPC_SwitchField, 25, 2, // 13826: switch Inst[26:25] {
7953 0, 6, // 13829: case 0x0: {
7954 OPC_CheckPredicate, 24, // 13831: check predicate 24
7955 OPC_Decode, 169, 115, 62, // 13833: decode to FMADD_S using decoder 62
7956 // 13833: }
7957 1, 6, // 13837: case 0x1: {
7958 OPC_CheckPredicate, 25, // 13839: check predicate 25
7959 OPC_Decode, 163, 115, 63, // 13841: decode to FMADD_D using decoder 63
7960 // 13841: }
7961 2, 6, // 13845: case 0x2: {
7962 OPC_CheckPredicate, 81, // 13847: check predicate 81
7963 OPC_Decode, 166, 115, 64, // 13849: decode to FMADD_H using decoder 64
7964 // 13849: }
7965 3, 0, // 13853: case 0x3: {
7966 OPC_CheckPredicate, 26, // 13855: check predicate 26
7967 OPC_Decode, 168, 115, 65, // 13857: decode to FMADD_Q using decoder 65
7968 // 13857: }
7969 // 13857: } // switch Inst[26:25]
7970 // 13857: }
7971 71, 35, // 13861: case 0x47: {
7972 OPC_SwitchField, 25, 2, // 13863: switch Inst[26:25] {
7973 0, 6, // 13866: case 0x0: {
7974 OPC_CheckPredicate, 24, // 13868: check predicate 24
7975 OPC_Decode, 201, 115, 62, // 13870: decode to FMSUB_S using decoder 62
7976 // 13870: }
7977 1, 6, // 13874: case 0x1: {
7978 OPC_CheckPredicate, 25, // 13876: check predicate 25
7979 OPC_Decode, 195, 115, 63, // 13878: decode to FMSUB_D using decoder 63
7980 // 13878: }
7981 2, 6, // 13882: case 0x2: {
7982 OPC_CheckPredicate, 81, // 13884: check predicate 81
7983 OPC_Decode, 198, 115, 64, // 13886: decode to FMSUB_H using decoder 64
7984 // 13886: }
7985 3, 0, // 13890: case 0x3: {
7986 OPC_CheckPredicate, 26, // 13892: check predicate 26
7987 OPC_Decode, 200, 115, 65, // 13894: decode to FMSUB_Q using decoder 65
7988 // 13894: }
7989 // 13894: } // switch Inst[26:25]
7990 // 13894: }
7991 75, 35, // 13898: case 0x4b: {
7992 OPC_SwitchField, 25, 2, // 13900: switch Inst[26:25] {
7993 0, 6, // 13903: case 0x0: {
7994 OPC_CheckPredicate, 24, // 13905: check predicate 24
7995 OPC_Decode, 236, 115, 62, // 13907: decode to FNMSUB_S using decoder 62
7996 // 13907: }
7997 1, 6, // 13911: case 0x1: {
7998 OPC_CheckPredicate, 25, // 13913: check predicate 25
7999 OPC_Decode, 230, 115, 63, // 13915: decode to FNMSUB_D using decoder 63
8000 // 13915: }
8001 2, 6, // 13919: case 0x2: {
8002 OPC_CheckPredicate, 81, // 13921: check predicate 81
8003 OPC_Decode, 233, 115, 64, // 13923: decode to FNMSUB_H using decoder 64
8004 // 13923: }
8005 3, 0, // 13927: case 0x3: {
8006 OPC_CheckPredicate, 26, // 13929: check predicate 26
8007 OPC_Decode, 235, 115, 65, // 13931: decode to FNMSUB_Q using decoder 65
8008 // 13931: }
8009 // 13931: } // switch Inst[26:25]
8010 // 13931: }
8011 79, 35, // 13935: case 0x4f: {
8012 OPC_SwitchField, 25, 2, // 13937: switch Inst[26:25] {
8013 0, 6, // 13940: case 0x0: {
8014 OPC_CheckPredicate, 24, // 13942: check predicate 24
8015 OPC_Decode, 228, 115, 62, // 13944: decode to FNMADD_S using decoder 62
8016 // 13944: }
8017 1, 6, // 13948: case 0x1: {
8018 OPC_CheckPredicate, 25, // 13950: check predicate 25
8019 OPC_Decode, 222, 115, 63, // 13952: decode to FNMADD_D using decoder 63
8020 // 13952: }
8021 2, 6, // 13956: case 0x2: {
8022 OPC_CheckPredicate, 81, // 13958: check predicate 81
8023 OPC_Decode, 225, 115, 64, // 13960: decode to FNMADD_H using decoder 64
8024 // 13960: }
8025 3, 0, // 13964: case 0x3: {
8026 OPC_CheckPredicate, 26, // 13966: check predicate 26
8027 OPC_Decode, 227, 115, 65, // 13968: decode to FNMADD_Q using decoder 65
8028 // 13968: }
8029 // 13968: } // switch Inst[26:25]
8030 // 13968: }
8031 83, 227, 10, // 13972: case 0x53: {
8032 OPC_SwitchField, 25, 7, // 13975: switch Inst[31:25] {
8033 0, 6, // 13978: case 0x0: {
8034 OPC_CheckPredicate, 24, // 13980: check predicate 24
8035 OPC_Decode, 145, 114, 66, // 13982: decode to FADD_S using decoder 66
8036 // 13982: }
8037 1, 6, // 13986: case 0x1: {
8038 OPC_CheckPredicate, 25, // 13988: check predicate 25
8039 OPC_Decode, 139, 114, 67, // 13990: decode to FADD_D using decoder 67
8040 // 13990: }
8041 2, 6, // 13994: case 0x2: {
8042 OPC_CheckPredicate, 81, // 13996: check predicate 81
8043 OPC_Decode, 142, 114, 68, // 13998: decode to FADD_H using decoder 68
8044 // 13998: }
8045 3, 6, // 14002: case 0x3: {
8046 OPC_CheckPredicate, 26, // 14004: check predicate 26
8047 OPC_Decode, 144, 114, 69, // 14006: decode to FADD_Q using decoder 69
8048 // 14006: }
8049 4, 6, // 14010: case 0x4: {
8050 OPC_CheckPredicate, 24, // 14012: check predicate 24
8051 OPC_Decode, 159, 116, 66, // 14014: decode to FSUB_S using decoder 66
8052 // 14014: }
8053 5, 6, // 14018: case 0x5: {
8054 OPC_CheckPredicate, 25, // 14020: check predicate 25
8055 OPC_Decode, 153, 116, 67, // 14022: decode to FSUB_D using decoder 67
8056 // 14022: }
8057 6, 6, // 14026: case 0x6: {
8058 OPC_CheckPredicate, 81, // 14028: check predicate 81
8059 OPC_Decode, 156, 116, 68, // 14030: decode to FSUB_H using decoder 68
8060 // 14030: }
8061 7, 6, // 14034: case 0x7: {
8062 OPC_CheckPredicate, 26, // 14036: check predicate 26
8063 OPC_Decode, 158, 116, 69, // 14038: decode to FSUB_Q using decoder 69
8064 // 14038: }
8065 8, 6, // 14042: case 0x8: {
8066 OPC_CheckPredicate, 24, // 14044: check predicate 24
8067 OPC_Decode, 209, 115, 66, // 14046: decode to FMUL_S using decoder 66
8068 // 14046: }
8069 9, 6, // 14050: case 0x9: {
8070 OPC_CheckPredicate, 25, // 14052: check predicate 25
8071 OPC_Decode, 203, 115, 67, // 14054: decode to FMUL_D using decoder 67
8072 // 14054: }
8073 10, 6, // 14058: case 0xa: {
8074 OPC_CheckPredicate, 81, // 14060: check predicate 81
8075 OPC_Decode, 206, 115, 68, // 14062: decode to FMUL_H using decoder 68
8076 // 14062: }
8077 11, 6, // 14066: case 0xb: {
8078 OPC_CheckPredicate, 26, // 14068: check predicate 26
8079 OPC_Decode, 208, 115, 69, // 14070: decode to FMUL_Q using decoder 69
8080 // 14070: }
8081 12, 6, // 14074: case 0xc: {
8082 OPC_CheckPredicate, 24, // 14076: check predicate 24
8083 OPC_Decode, 246, 114, 66, // 14078: decode to FDIV_S using decoder 66
8084 // 14078: }
8085 13, 6, // 14082: case 0xd: {
8086 OPC_CheckPredicate, 25, // 14084: check predicate 25
8087 OPC_Decode, 240, 114, 67, // 14086: decode to FDIV_D using decoder 67
8088 // 14086: }
8089 14, 6, // 14090: case 0xe: {
8090 OPC_CheckPredicate, 81, // 14092: check predicate 81
8091 OPC_Decode, 243, 114, 68, // 14094: decode to FDIV_H using decoder 68
8092 // 14094: }
8093 15, 6, // 14098: case 0xf: {
8094 OPC_CheckPredicate, 26, // 14100: check predicate 26
8095 OPC_Decode, 245, 114, 69, // 14102: decode to FDIV_Q using decoder 69
8096 // 14102: }
8097 16, 27, // 14106: case 0x10: {
8098 OPC_SwitchField, 12, 3, // 14108: switch Inst[14:12] {
8099 0, 6, // 14111: case 0x0: {
8100 OPC_CheckPredicate, 24, // 14113: check predicate 24
8101 OPC_Decode, 141, 116, 70, // 14115: decode to FSGNJ_S using decoder 70
8102 // 14115: }
8103 1, 6, // 14119: case 0x1: {
8104 OPC_CheckPredicate, 24, // 14121: check predicate 24
8105 OPC_Decode, 253, 115, 70, // 14123: decode to FSGNJN_S using decoder 70
8106 // 14123: }
8107 2, 0, // 14127: case 0x2: {
8108 OPC_CheckPredicate, 24, // 14129: check predicate 24
8109 OPC_Decode, 133, 116, 70, // 14131: decode to FSGNJX_S using decoder 70
8110 // 14131: }
8111 // 14131: } // switch Inst[14:12]
8112 // 14131: }
8113 17, 27, // 14135: case 0x11: {
8114 OPC_SwitchField, 12, 3, // 14137: switch Inst[14:12] {
8115 0, 6, // 14140: case 0x0: {
8116 OPC_CheckPredicate, 25, // 14142: check predicate 25
8117 OPC_Decode, 135, 116, 71, // 14144: decode to FSGNJ_D using decoder 71
8118 // 14144: }
8119 1, 6, // 14148: case 0x1: {
8120 OPC_CheckPredicate, 25, // 14150: check predicate 25
8121 OPC_Decode, 247, 115, 71, // 14152: decode to FSGNJN_D using decoder 71
8122 // 14152: }
8123 2, 0, // 14156: case 0x2: {
8124 OPC_CheckPredicate, 25, // 14158: check predicate 25
8125 OPC_Decode, 255, 115, 71, // 14160: decode to FSGNJX_D using decoder 71
8126 // 14160: }
8127 // 14160: } // switch Inst[14:12]
8128 // 14160: }
8129 18, 27, // 14164: case 0x12: {
8130 OPC_SwitchField, 12, 3, // 14166: switch Inst[14:12] {
8131 0, 6, // 14169: case 0x0: {
8132 OPC_CheckPredicate, 81, // 14171: check predicate 81
8133 OPC_Decode, 138, 116, 72, // 14173: decode to FSGNJ_H using decoder 72
8134 // 14173: }
8135 1, 6, // 14177: case 0x1: {
8136 OPC_CheckPredicate, 81, // 14179: check predicate 81
8137 OPC_Decode, 250, 115, 72, // 14181: decode to FSGNJN_H using decoder 72
8138 // 14181: }
8139 2, 0, // 14185: case 0x2: {
8140 OPC_CheckPredicate, 81, // 14187: check predicate 81
8141 OPC_Decode, 130, 116, 72, // 14189: decode to FSGNJX_H using decoder 72
8142 // 14189: }
8143 // 14189: } // switch Inst[14:12]
8144 // 14189: }
8145 19, 27, // 14193: case 0x13: {
8146 OPC_SwitchField, 12, 3, // 14195: switch Inst[14:12] {
8147 0, 6, // 14198: case 0x0: {
8148 OPC_CheckPredicate, 26, // 14200: check predicate 26
8149 OPC_Decode, 140, 116, 73, // 14202: decode to FSGNJ_Q using decoder 73
8150 // 14202: }
8151 1, 6, // 14206: case 0x1: {
8152 OPC_CheckPredicate, 26, // 14208: check predicate 26
8153 OPC_Decode, 252, 115, 73, // 14210: decode to FSGNJN_Q using decoder 73
8154 // 14210: }
8155 2, 0, // 14214: case 0x2: {
8156 OPC_CheckPredicate, 26, // 14216: check predicate 26
8157 OPC_Decode, 132, 116, 73, // 14218: decode to FSGNJX_Q using decoder 73
8158 // 14218: }
8159 // 14218: } // switch Inst[14:12]
8160 // 14218: }
8161 20, 35, // 14222: case 0x14: {
8162 OPC_SwitchField, 12, 3, // 14224: switch Inst[14:12] {
8163 0, 6, // 14227: case 0x0: {
8164 OPC_CheckPredicate, 24, // 14229: check predicate 24
8165 OPC_Decode, 193, 115, 70, // 14231: decode to FMIN_S using decoder 70
8166 // 14231: }
8167 1, 6, // 14235: case 0x1: {
8168 OPC_CheckPredicate, 24, // 14237: check predicate 24
8169 OPC_Decode, 181, 115, 70, // 14239: decode to FMAX_S using decoder 70
8170 // 14239: }
8171 2, 6, // 14243: case 0x2: {
8172 OPC_CheckPredicate, 82, // 14245: check predicate 82
8173 OPC_Decode, 186, 115, 70, // 14247: decode to FMINM_S using decoder 70
8174 // 14247: }
8175 3, 0, // 14251: case 0x3: {
8176 OPC_CheckPredicate, 82, // 14253: check predicate 82
8177 OPC_Decode, 174, 115, 70, // 14255: decode to FMAXM_S using decoder 70
8178 // 14255: }
8179 // 14255: } // switch Inst[14:12]
8180 // 14255: }
8181 21, 35, // 14259: case 0x15: {
8182 OPC_SwitchField, 12, 3, // 14261: switch Inst[14:12] {
8183 0, 6, // 14264: case 0x0: {
8184 OPC_CheckPredicate, 25, // 14266: check predicate 25
8185 OPC_Decode, 187, 115, 71, // 14268: decode to FMIN_D using decoder 71
8186 // 14268: }
8187 1, 6, // 14272: case 0x1: {
8188 OPC_CheckPredicate, 25, // 14274: check predicate 25
8189 OPC_Decode, 175, 115, 71, // 14276: decode to FMAX_D using decoder 71
8190 // 14276: }
8191 2, 6, // 14280: case 0x2: {
8192 OPC_CheckPredicate, 83, // 14282: check predicate 83
8193 OPC_Decode, 183, 115, 71, // 14284: decode to FMINM_D using decoder 71
8194 // 14284: }
8195 3, 0, // 14288: case 0x3: {
8196 OPC_CheckPredicate, 83, // 14290: check predicate 83
8197 OPC_Decode, 171, 115, 71, // 14292: decode to FMAXM_D using decoder 71
8198 // 14292: }
8199 // 14292: } // switch Inst[14:12]
8200 // 14292: }
8201 22, 35, // 14296: case 0x16: {
8202 OPC_SwitchField, 12, 3, // 14298: switch Inst[14:12] {
8203 0, 6, // 14301: case 0x0: {
8204 OPC_CheckPredicate, 81, // 14303: check predicate 81
8205 OPC_Decode, 190, 115, 72, // 14305: decode to FMIN_H using decoder 72
8206 // 14305: }
8207 1, 6, // 14309: case 0x1: {
8208 OPC_CheckPredicate, 81, // 14311: check predicate 81
8209 OPC_Decode, 178, 115, 72, // 14313: decode to FMAX_H using decoder 72
8210 // 14313: }
8211 2, 6, // 14317: case 0x2: {
8212 OPC_CheckPredicate, 84, // 14319: check predicate 84
8213 OPC_Decode, 184, 115, 72, // 14321: decode to FMINM_H using decoder 72
8214 // 14321: }
8215 3, 0, // 14325: case 0x3: {
8216 OPC_CheckPredicate, 84, // 14327: check predicate 84
8217 OPC_Decode, 172, 115, 72, // 14329: decode to FMAXM_H using decoder 72
8218 // 14329: }
8219 // 14329: } // switch Inst[14:12]
8220 // 14329: }
8221 23, 35, // 14333: case 0x17: {
8222 OPC_SwitchField, 12, 3, // 14335: switch Inst[14:12] {
8223 0, 6, // 14338: case 0x0: {
8224 OPC_CheckPredicate, 26, // 14340: check predicate 26
8225 OPC_Decode, 192, 115, 73, // 14342: decode to FMIN_Q using decoder 73
8226 // 14342: }
8227 1, 6, // 14346: case 0x1: {
8228 OPC_CheckPredicate, 26, // 14348: check predicate 26
8229 OPC_Decode, 180, 115, 73, // 14350: decode to FMAX_Q using decoder 73
8230 // 14350: }
8231 2, 6, // 14354: case 0x2: {
8232 OPC_CheckPredicate, 85, // 14356: check predicate 85
8233 OPC_Decode, 185, 115, 73, // 14358: decode to FMINM_Q using decoder 73
8234 // 14358: }
8235 3, 0, // 14362: case 0x3: {
8236 OPC_CheckPredicate, 85, // 14364: check predicate 85
8237 OPC_Decode, 173, 115, 73, // 14366: decode to FMAXM_Q using decoder 73
8238 // 14366: }
8239 // 14366: } // switch Inst[14:12]
8240 // 14366: }
8241 32, 51, // 14370: case 0x20: {
8242 OPC_SwitchField, 20, 5, // 14372: switch Inst[24:20] {
8243 1, 6, // 14375: case 0x1: {
8244 OPC_CheckPredicate, 25, // 14377: check predicate 25
8245 OPC_Decode, 210, 114, 74, // 14379: decode to FCVT_S_D using decoder 74
8246 // 14379: }
8247 2, 6, // 14383: case 0x2: {
8248 OPC_CheckPredicate, 86, // 14385: check predicate 86
8249 OPC_Decode, 213, 114, 75, // 14387: decode to FCVT_S_H using decoder 75
8250 // 14387: }
8251 3, 6, // 14391: case 0x3: {
8252 OPC_CheckPredicate, 26, // 14393: check predicate 26
8253 OPC_Decode, 219, 114, 76, // 14395: decode to FCVT_S_Q using decoder 76
8254 // 14395: }
8255 4, 6, // 14399: case 0x4: {
8256 OPC_CheckPredicate, 82, // 14401: check predicate 82
8257 OPC_Decode, 245, 115, 77, // 14403: decode to FROUND_S using decoder 77
8258 // 14403: }
8259 5, 6, // 14407: case 0x5: {
8260 OPC_CheckPredicate, 82, // 14409: check predicate 82
8261 OPC_Decode, 241, 115, 77, // 14411: decode to FROUNDNX_S using decoder 77
8262 // 14411: }
8263 6, 0, // 14415: case 0x6: {
8264 OPC_CheckPredicate, 87, // 14417: check predicate 87
8265 OPC_Decode, 209, 114, 75, // 14419: decode to FCVT_S_BF16 using decoder 75
8266 // 14419: }
8267 // 14419: } // switch Inst[24:20]
8268 // 14419: }
8269 33, 43, // 14423: case 0x21: {
8270 OPC_SwitchField, 20, 5, // 14425: switch Inst[24:20] {
8271 0, 6, // 14428: case 0x0: {
8272 OPC_CheckPredicate, 25, // 14430: check predicate 25
8273 OPC_Decode, 165, 114, 78, // 14432: decode to FCVT_D_S using decoder 78
8274 // 14432: }
8275 2, 6, // 14436: case 0x2: {
8276 OPC_CheckPredicate, 88, // 14438: check predicate 88
8277 OPC_Decode, 157, 114, 79, // 14440: decode to FCVT_D_H using decoder 79
8278 // 14440: }
8279 3, 6, // 14444: case 0x3: {
8280 OPC_CheckPredicate, 26, // 14446: check predicate 26
8281 OPC_Decode, 164, 114, 80, // 14448: decode to FCVT_D_Q using decoder 80
8282 // 14448: }
8283 4, 6, // 14452: case 0x4: {
8284 OPC_CheckPredicate, 83, // 14454: check predicate 83
8285 OPC_Decode, 242, 115, 81, // 14456: decode to FROUND_D using decoder 81
8286 // 14456: }
8287 5, 0, // 14460: case 0x5: {
8288 OPC_CheckPredicate, 83, // 14462: check predicate 83
8289 OPC_Decode, 238, 115, 81, // 14464: decode to FROUNDNX_D using decoder 81
8290 // 14464: }
8291 // 14464: } // switch Inst[24:20]
8292 // 14464: }
8293 34, 51, // 14468: case 0x22: {
8294 OPC_SwitchField, 20, 5, // 14470: switch Inst[24:20] {
8295 0, 6, // 14473: case 0x0: {
8296 OPC_CheckPredicate, 86, // 14475: check predicate 86
8297 OPC_Decode, 182, 114, 82, // 14477: decode to FCVT_H_S using decoder 82
8298 // 14477: }
8299 1, 6, // 14481: case 0x1: {
8300 OPC_CheckPredicate, 88, // 14483: check predicate 88
8301 OPC_Decode, 174, 114, 83, // 14485: decode to FCVT_H_D using decoder 83
8302 // 14485: }
8303 3, 6, // 14489: case 0x3: {
8304 OPC_CheckPredicate, 89, // 14491: check predicate 89
8305 OPC_Decode, 181, 114, 84, // 14493: decode to FCVT_H_Q using decoder 84
8306 // 14493: }
8307 4, 6, // 14497: case 0x4: {
8308 OPC_CheckPredicate, 84, // 14499: check predicate 84
8309 OPC_Decode, 243, 115, 85, // 14501: decode to FROUND_H using decoder 85
8310 // 14501: }
8311 5, 6, // 14505: case 0x5: {
8312 OPC_CheckPredicate, 84, // 14507: check predicate 84
8313 OPC_Decode, 239, 115, 85, // 14509: decode to FROUNDNX_H using decoder 85
8314 // 14509: }
8315 8, 0, // 14513: case 0x8: {
8316 OPC_CheckPredicate, 87, // 14515: check predicate 87
8317 OPC_Decode, 156, 114, 82, // 14517: decode to FCVT_BF16_S using decoder 82
8318 // 14517: }
8319 // 14517: } // switch Inst[24:20]
8320 // 14517: }
8321 35, 43, // 14521: case 0x23: {
8322 OPC_SwitchField, 20, 5, // 14523: switch Inst[24:20] {
8323 0, 6, // 14526: case 0x0: {
8324 OPC_CheckPredicate, 26, // 14528: check predicate 26
8325 OPC_Decode, 206, 114, 86, // 14530: decode to FCVT_Q_S using decoder 86
8326 // 14530: }
8327 1, 6, // 14534: case 0x1: {
8328 OPC_CheckPredicate, 26, // 14536: check predicate 26
8329 OPC_Decode, 202, 114, 87, // 14538: decode to FCVT_Q_D using decoder 87
8330 // 14538: }
8331 2, 6, // 14542: case 0x2: {
8332 OPC_CheckPredicate, 89, // 14544: check predicate 89
8333 OPC_Decode, 203, 114, 88, // 14546: decode to FCVT_Q_H using decoder 88
8334 // 14546: }
8335 4, 6, // 14550: case 0x4: {
8336 OPC_CheckPredicate, 85, // 14552: check predicate 85
8337 OPC_Decode, 244, 115, 89, // 14554: decode to FROUND_Q using decoder 89
8338 // 14554: }
8339 5, 0, // 14558: case 0x5: {
8340 OPC_CheckPredicate, 85, // 14560: check predicate 85
8341 OPC_Decode, 240, 115, 89, // 14562: decode to FROUNDNX_Q using decoder 89
8342 // 14562: }
8343 // 14562: } // switch Inst[24:20]
8344 // 14562: }
8345 44, 10, // 14566: case 0x2c: {
8346 OPC_CheckPredicate, 24, // 14568: check predicate 24
8347 OPC_CheckField, 20, 5, 0, // 14570: check Inst[24:20] == 0x0
8348 OPC_Decode, 151, 116, 77, // 14574: decode to FSQRT_S using decoder 77
8349 // 14574: }
8350 45, 10, // 14578: case 0x2d: {
8351 OPC_CheckPredicate, 25, // 14580: check predicate 25
8352 OPC_CheckField, 20, 5, 0, // 14582: check Inst[24:20] == 0x0
8353 OPC_Decode, 145, 116, 81, // 14586: decode to FSQRT_D using decoder 81
8354 // 14586: }
8355 46, 10, // 14590: case 0x2e: {
8356 OPC_CheckPredicate, 81, // 14592: check predicate 81
8357 OPC_CheckField, 20, 5, 0, // 14594: check Inst[24:20] == 0x0
8358 OPC_Decode, 148, 116, 85, // 14598: decode to FSQRT_H using decoder 85
8359 // 14598: }
8360 47, 10, // 14602: case 0x2f: {
8361 OPC_CheckPredicate, 26, // 14604: check predicate 26
8362 OPC_CheckField, 20, 5, 0, // 14606: check Inst[24:20] == 0x0
8363 OPC_Decode, 150, 116, 89, // 14610: decode to FSQRT_Q using decoder 89
8364 // 14610: }
8365 80, 43, // 14614: case 0x50: {
8366 OPC_SwitchField, 12, 3, // 14616: switch Inst[14:12] {
8367 0, 6, // 14619: case 0x0: {
8368 OPC_CheckPredicate, 24, // 14621: check predicate 24
8369 OPC_Decode, 142, 115, 90, // 14623: decode to FLE_S using decoder 90
8370 // 14623: }
8371 1, 6, // 14627: case 0x1: {
8372 OPC_CheckPredicate, 24, // 14629: check predicate 24
8373 OPC_Decode, 160, 115, 90, // 14631: decode to FLT_S using decoder 90
8374 // 14631: }
8375 2, 6, // 14635: case 0x2: {
8376 OPC_CheckPredicate, 24, // 14637: check predicate 24
8377 OPC_Decode, 129, 115, 90, // 14639: decode to FEQ_S using decoder 90
8378 // 14639: }
8379 4, 6, // 14643: case 0x4: {
8380 OPC_CheckPredicate, 82, // 14645: check predicate 82
8381 OPC_Decode, 135, 115, 90, // 14647: decode to FLEQ_S using decoder 90
8382 // 14647: }
8383 5, 0, // 14651: case 0x5: {
8384 OPC_CheckPredicate, 82, // 14653: check predicate 82
8385 OPC_Decode, 153, 115, 90, // 14655: decode to FLTQ_S using decoder 90
8386 // 14655: }
8387 // 14655: } // switch Inst[14:12]
8388 // 14655: }
8389 81, 43, // 14659: case 0x51: {
8390 OPC_SwitchField, 12, 3, // 14661: switch Inst[14:12] {
8391 0, 6, // 14664: case 0x0: {
8392 OPC_CheckPredicate, 25, // 14666: check predicate 25
8393 OPC_Decode, 136, 115, 91, // 14668: decode to FLE_D using decoder 91
8394 // 14668: }
8395 1, 6, // 14672: case 0x1: {
8396 OPC_CheckPredicate, 25, // 14674: check predicate 25
8397 OPC_Decode, 154, 115, 91, // 14676: decode to FLT_D using decoder 91
8398 // 14676: }
8399 2, 6, // 14680: case 0x2: {
8400 OPC_CheckPredicate, 25, // 14682: check predicate 25
8401 OPC_Decode, 251, 114, 91, // 14684: decode to FEQ_D using decoder 91
8402 // 14684: }
8403 4, 6, // 14688: case 0x4: {
8404 OPC_CheckPredicate, 83, // 14690: check predicate 83
8405 OPC_Decode, 132, 115, 91, // 14692: decode to FLEQ_D using decoder 91
8406 // 14692: }
8407 5, 0, // 14696: case 0x5: {
8408 OPC_CheckPredicate, 83, // 14698: check predicate 83
8409 OPC_Decode, 150, 115, 91, // 14700: decode to FLTQ_D using decoder 91
8410 // 14700: }
8411 // 14700: } // switch Inst[14:12]
8412 // 14700: }
8413 82, 43, // 14704: case 0x52: {
8414 OPC_SwitchField, 12, 3, // 14706: switch Inst[14:12] {
8415 0, 6, // 14709: case 0x0: {
8416 OPC_CheckPredicate, 81, // 14711: check predicate 81
8417 OPC_Decode, 139, 115, 92, // 14713: decode to FLE_H using decoder 92
8418 // 14713: }
8419 1, 6, // 14717: case 0x1: {
8420 OPC_CheckPredicate, 81, // 14719: check predicate 81
8421 OPC_Decode, 157, 115, 92, // 14721: decode to FLT_H using decoder 92
8422 // 14721: }
8423 2, 6, // 14725: case 0x2: {
8424 OPC_CheckPredicate, 81, // 14727: check predicate 81
8425 OPC_Decode, 254, 114, 92, // 14729: decode to FEQ_H using decoder 92
8426 // 14729: }
8427 4, 6, // 14733: case 0x4: {
8428 OPC_CheckPredicate, 84, // 14735: check predicate 84
8429 OPC_Decode, 133, 115, 92, // 14737: decode to FLEQ_H using decoder 92
8430 // 14737: }
8431 5, 0, // 14741: case 0x5: {
8432 OPC_CheckPredicate, 84, // 14743: check predicate 84
8433 OPC_Decode, 151, 115, 92, // 14745: decode to FLTQ_H using decoder 92
8434 // 14745: }
8435 // 14745: } // switch Inst[14:12]
8436 // 14745: }
8437 83, 43, // 14749: case 0x53: {
8438 OPC_SwitchField, 12, 3, // 14751: switch Inst[14:12] {
8439 0, 6, // 14754: case 0x0: {
8440 OPC_CheckPredicate, 26, // 14756: check predicate 26
8441 OPC_Decode, 141, 115, 93, // 14758: decode to FLE_Q using decoder 93
8442 // 14758: }
8443 1, 6, // 14762: case 0x1: {
8444 OPC_CheckPredicate, 26, // 14764: check predicate 26
8445 OPC_Decode, 159, 115, 93, // 14766: decode to FLT_Q using decoder 93
8446 // 14766: }
8447 2, 6, // 14770: case 0x2: {
8448 OPC_CheckPredicate, 26, // 14772: check predicate 26
8449 OPC_Decode, 128, 115, 93, // 14774: decode to FEQ_Q using decoder 93
8450 // 14774: }
8451 4, 6, // 14778: case 0x4: {
8452 OPC_CheckPredicate, 85, // 14780: check predicate 85
8453 OPC_Decode, 134, 115, 93, // 14782: decode to FLEQ_Q using decoder 93
8454 // 14782: }
8455 5, 0, // 14786: case 0x5: {
8456 OPC_CheckPredicate, 85, // 14788: check predicate 85
8457 OPC_Decode, 152, 115, 93, // 14790: decode to FLTQ_Q using decoder 93
8458 // 14790: }
8459 // 14790: } // switch Inst[14:12]
8460 // 14790: }
8461 89, 10, // 14794: case 0x59: {
8462 OPC_CheckPredicate, 90, // 14796: check predicate 90
8463 OPC_CheckField, 12, 3, 0, // 14798: check Inst[14:12] == 0x0
8464 OPC_Decode, 213, 115, 94, // 14802: decode to FMVP_D_X using decoder 94
8465 // 14802: }
8466 91, 10, // 14806: case 0x5b: {
8467 OPC_CheckPredicate, 91, // 14808: check predicate 91
8468 OPC_CheckField, 12, 3, 0, // 14810: check Inst[14:12] == 0x0
8469 OPC_Decode, 214, 115, 95, // 14814: decode to FMVP_Q_X using decoder 95
8470 // 14814: }
8471 96, 35, // 14818: case 0x60: {
8472 OPC_SwitchField, 20, 5, // 14820: switch Inst[24:20] {
8473 0, 6, // 14823: case 0x0: {
8474 OPC_CheckPredicate, 24, // 14825: check predicate 24
8475 OPC_Decode, 238, 114, 96, // 14827: decode to FCVT_W_S using decoder 96
8476 // 14827: }
8477 1, 6, // 14831: case 0x1: {
8478 OPC_CheckPredicate, 24, // 14833: check predicate 24
8479 OPC_Decode, 230, 114, 96, // 14835: decode to FCVT_WU_S using decoder 96
8480 // 14835: }
8481 2, 6, // 14839: case 0x2: {
8482 OPC_CheckPredicate, 92, // 14841: check predicate 92
8483 OPC_Decode, 200, 114, 96, // 14843: decode to FCVT_L_S using decoder 96
8484 // 14843: }
8485 3, 0, // 14847: case 0x3: {
8486 OPC_CheckPredicate, 92, // 14849: check predicate 92
8487 OPC_Decode, 193, 114, 96, // 14851: decode to FCVT_LU_S using decoder 96
8488 // 14851: }
8489 // 14851: } // switch Inst[24:20]
8490 // 14851: }
8491 97, 47, // 14855: case 0x61: {
8492 OPC_SwitchField, 20, 5, // 14857: switch Inst[24:20] {
8493 0, 6, // 14860: case 0x0: {
8494 OPC_CheckPredicate, 25, // 14862: check predicate 25
8495 OPC_Decode, 232, 114, 97, // 14864: decode to FCVT_W_D using decoder 97
8496 // 14864: }
8497 1, 6, // 14868: case 0x1: {
8498 OPC_CheckPredicate, 25, // 14870: check predicate 25
8499 OPC_Decode, 224, 114, 97, // 14872: decode to FCVT_WU_D using decoder 97
8500 // 14872: }
8501 2, 6, // 14876: case 0x2: {
8502 OPC_CheckPredicate, 93, // 14878: check predicate 93
8503 OPC_Decode, 195, 114, 97, // 14880: decode to FCVT_L_D using decoder 97
8504 // 14880: }
8505 3, 6, // 14884: case 0x3: {
8506 OPC_CheckPredicate, 93, // 14886: check predicate 93
8507 OPC_Decode, 188, 114, 97, // 14888: decode to FCVT_LU_D using decoder 97
8508 // 14888: }
8509 8, 0, // 14892: case 0x8: {
8510 OPC_CheckPredicate, 83, // 14894: check predicate 83
8511 OPC_CheckField, 12, 3, 1, // 14896: check Inst[14:12] == 0x1
8512 OPC_Decode, 155, 114, 98, // 14900: decode to FCVTMOD_W_D using decoder 98
8513 // 14900: }
8514 // 14900: } // switch Inst[24:20]
8515 // 14900: }
8516 98, 35, // 14904: case 0x62: {
8517 OPC_SwitchField, 20, 5, // 14906: switch Inst[24:20] {
8518 0, 6, // 14909: case 0x0: {
8519 OPC_CheckPredicate, 81, // 14911: check predicate 81
8520 OPC_Decode, 235, 114, 99, // 14913: decode to FCVT_W_H using decoder 99
8521 // 14913: }
8522 1, 6, // 14917: case 0x1: {
8523 OPC_CheckPredicate, 81, // 14919: check predicate 81
8524 OPC_Decode, 227, 114, 99, // 14921: decode to FCVT_WU_H using decoder 99
8525 // 14921: }
8526 2, 6, // 14925: case 0x2: {
8527 OPC_CheckPredicate, 94, // 14927: check predicate 94
8528 OPC_Decode, 197, 114, 99, // 14929: decode to FCVT_L_H using decoder 99
8529 // 14929: }
8530 3, 0, // 14933: case 0x3: {
8531 OPC_CheckPredicate, 94, // 14935: check predicate 94
8532 OPC_Decode, 190, 114, 99, // 14937: decode to FCVT_LU_H using decoder 99
8533 // 14937: }
8534 // 14937: } // switch Inst[24:20]
8535 // 14937: }
8536 99, 35, // 14941: case 0x63: {
8537 OPC_SwitchField, 20, 5, // 14943: switch Inst[24:20] {
8538 0, 6, // 14946: case 0x0: {
8539 OPC_CheckPredicate, 26, // 14948: check predicate 26
8540 OPC_Decode, 237, 114, 100, // 14950: decode to FCVT_W_Q using decoder 100
8541 // 14950: }
8542 1, 6, // 14954: case 0x1: {
8543 OPC_CheckPredicate, 26, // 14956: check predicate 26
8544 OPC_Decode, 229, 114, 100, // 14958: decode to FCVT_WU_Q using decoder 100
8545 // 14958: }
8546 2, 6, // 14962: case 0x2: {
8547 OPC_CheckPredicate, 95, // 14964: check predicate 95
8548 OPC_Decode, 199, 114, 100, // 14966: decode to FCVT_L_Q using decoder 100
8549 // 14966: }
8550 3, 0, // 14970: case 0x3: {
8551 OPC_CheckPredicate, 95, // 14972: check predicate 95
8552 OPC_Decode, 192, 114, 100, // 14974: decode to FCVT_LU_Q using decoder 100
8553 // 14974: }
8554 // 14974: } // switch Inst[24:20]
8555 // 14974: }
8556 104, 35, // 14978: case 0x68: {
8557 OPC_SwitchField, 20, 5, // 14980: switch Inst[24:20] {
8558 0, 6, // 14983: case 0x0: {
8559 OPC_CheckPredicate, 24, // 14985: check predicate 24
8560 OPC_Decode, 220, 114, 101, // 14987: decode to FCVT_S_W using decoder 101
8561 // 14987: }
8562 1, 6, // 14991: case 0x1: {
8563 OPC_CheckPredicate, 24, // 14993: check predicate 24
8564 OPC_Decode, 221, 114, 101, // 14995: decode to FCVT_S_WU using decoder 101
8565 // 14995: }
8566 2, 6, // 14999: case 0x2: {
8567 OPC_CheckPredicate, 92, // 15001: check predicate 92
8568 OPC_Decode, 215, 114, 101, // 15003: decode to FCVT_S_L using decoder 101
8569 // 15003: }
8570 3, 0, // 15007: case 0x3: {
8571 OPC_CheckPredicate, 92, // 15009: check predicate 92
8572 OPC_Decode, 216, 114, 101, // 15011: decode to FCVT_S_LU using decoder 101
8573 // 15011: }
8574 // 15011: } // switch Inst[24:20]
8575 // 15011: }
8576 105, 35, // 15015: case 0x69: {
8577 OPC_SwitchField, 20, 5, // 15017: switch Inst[24:20] {
8578 0, 6, // 15020: case 0x0: {
8579 OPC_CheckPredicate, 25, // 15022: check predicate 25
8580 OPC_Decode, 168, 114, 102, // 15024: decode to FCVT_D_W using decoder 102
8581 // 15024: }
8582 1, 6, // 15028: case 0x1: {
8583 OPC_CheckPredicate, 25, // 15030: check predicate 25
8584 OPC_Decode, 169, 114, 102, // 15032: decode to FCVT_D_WU using decoder 102
8585 // 15032: }
8586 2, 6, // 15036: case 0x2: {
8587 OPC_CheckPredicate, 93, // 15038: check predicate 93
8588 OPC_Decode, 160, 114, 102, // 15040: decode to FCVT_D_L using decoder 102
8589 // 15040: }
8590 3, 0, // 15044: case 0x3: {
8591 OPC_CheckPredicate, 93, // 15046: check predicate 93
8592 OPC_Decode, 161, 114, 102, // 15048: decode to FCVT_D_LU using decoder 102
8593 // 15048: }
8594 // 15048: } // switch Inst[24:20]
8595 // 15048: }
8596 106, 35, // 15052: case 0x6a: {
8597 OPC_SwitchField, 20, 5, // 15054: switch Inst[24:20] {
8598 0, 6, // 15057: case 0x0: {
8599 OPC_CheckPredicate, 81, // 15059: check predicate 81
8600 OPC_Decode, 184, 114, 103, // 15061: decode to FCVT_H_W using decoder 103
8601 // 15061: }
8602 1, 6, // 15065: case 0x1: {
8603 OPC_CheckPredicate, 81, // 15067: check predicate 81
8604 OPC_Decode, 185, 114, 103, // 15069: decode to FCVT_H_WU using decoder 103
8605 // 15069: }
8606 2, 6, // 15073: case 0x2: {
8607 OPC_CheckPredicate, 94, // 15075: check predicate 94
8608 OPC_Decode, 177, 114, 103, // 15077: decode to FCVT_H_L using decoder 103
8609 // 15077: }
8610 3, 0, // 15081: case 0x3: {
8611 OPC_CheckPredicate, 94, // 15083: check predicate 94
8612 OPC_Decode, 178, 114, 103, // 15085: decode to FCVT_H_LU using decoder 103
8613 // 15085: }
8614 // 15085: } // switch Inst[24:20]
8615 // 15085: }
8616 107, 35, // 15089: case 0x6b: {
8617 OPC_SwitchField, 20, 5, // 15091: switch Inst[24:20] {
8618 0, 6, // 15094: case 0x0: {
8619 OPC_CheckPredicate, 26, // 15096: check predicate 26
8620 OPC_Decode, 207, 114, 104, // 15098: decode to FCVT_Q_W using decoder 104
8621 // 15098: }
8622 1, 6, // 15102: case 0x1: {
8623 OPC_CheckPredicate, 26, // 15104: check predicate 26
8624 OPC_Decode, 208, 114, 104, // 15106: decode to FCVT_Q_WU using decoder 104
8625 // 15106: }
8626 2, 6, // 15110: case 0x2: {
8627 OPC_CheckPredicate, 95, // 15112: check predicate 95
8628 OPC_Decode, 204, 114, 104, // 15114: decode to FCVT_Q_L using decoder 104
8629 // 15114: }
8630 3, 0, // 15118: case 0x3: {
8631 OPC_CheckPredicate, 95, // 15120: check predicate 95
8632 OPC_Decode, 205, 114, 104, // 15122: decode to FCVT_Q_LU using decoder 104
8633 // 15122: }
8634 // 15122: } // switch Inst[24:20]
8635 // 15122: }
8636 112, 27, // 15126: case 0x70: {
8637 OPC_SwitchField, 12, 3, // 15128: switch Inst[14:12] {
8638 0, 10, // 15131: case 0x0: {
8639 OPC_CheckPredicate, 24, // 15133: check predicate 24
8640 OPC_CheckField, 20, 5, 0, // 15135: check Inst[24:20] == 0x0
8641 OPC_Decode, 220, 115, 105, // 15139: decode to FMV_X_W using decoder 105
8642 // 15139: }
8643 1, 0, // 15143: case 0x1: {
8644 OPC_CheckPredicate, 24, // 15145: check predicate 24
8645 OPC_CheckField, 20, 5, 0, // 15147: check Inst[24:20] == 0x0
8646 OPC_Decode, 153, 114, 105, // 15151: decode to FCLASS_S using decoder 105
8647 // 15151: }
8648 // 15151: } // switch Inst[14:12]
8649 // 15151: }
8650 113, 36, // 15155: case 0x71: {
8651 OPC_SwitchField, 12, 3, // 15157: switch Inst[14:12] {
8652 0, 19, // 15160: case 0x0: {
8653 OPC_SwitchField, 20, 5, // 15162: switch Inst[24:20] {
8654 0, 6, // 15165: case 0x0: {
8655 OPC_CheckPredicate, 93, // 15167: check predicate 93
8656 OPC_Decode, 218, 115, 106, // 15169: decode to FMV_X_D using decoder 106
8657 // 15169: }
8658 1, 0, // 15173: case 0x1: {
8659 OPC_CheckPredicate, 90, // 15175: check predicate 90
8660 OPC_Decode, 211, 115, 106, // 15177: decode to FMVH_X_D using decoder 106
8661 // 15177: }
8662 // 15177: } // switch Inst[24:20]
8663 // 15177: }
8664 1, 0, // 15181: case 0x1: {
8665 OPC_CheckPredicate, 25, // 15183: check predicate 25
8666 OPC_CheckField, 20, 5, 0, // 15185: check Inst[24:20] == 0x0
8667 OPC_Decode, 147, 114, 106, // 15189: decode to FCLASS_D using decoder 106
8668 // 15189: }
8669 // 15189: } // switch Inst[14:12]
8670 // 15189: }
8671 114, 27, // 15193: case 0x72: {
8672 OPC_SwitchField, 12, 3, // 15195: switch Inst[14:12] {
8673 0, 10, // 15198: case 0x0: {
8674 OPC_CheckPredicate, 23, // 15200: check predicate 23
8675 OPC_CheckField, 20, 5, 0, // 15202: check Inst[24:20] == 0x0
8676 OPC_Decode, 219, 115, 107, // 15206: decode to FMV_X_H using decoder 107
8677 // 15206: }
8678 1, 0, // 15210: case 0x1: {
8679 OPC_CheckPredicate, 81, // 15212: check predicate 81
8680 OPC_CheckField, 20, 5, 0, // 15214: check Inst[24:20] == 0x0
8681 OPC_Decode, 150, 114, 107, // 15218: decode to FCLASS_H using decoder 107
8682 // 15218: }
8683 // 15218: } // switch Inst[14:12]
8684 // 15218: }
8685 115, 27, // 15222: case 0x73: {
8686 OPC_SwitchField, 12, 3, // 15224: switch Inst[14:12] {
8687 0, 10, // 15227: case 0x0: {
8688 OPC_CheckPredicate, 91, // 15229: check predicate 91
8689 OPC_CheckField, 20, 5, 1, // 15231: check Inst[24:20] == 0x1
8690 OPC_Decode, 212, 115, 108, // 15235: decode to FMVH_X_Q using decoder 108
8691 // 15235: }
8692 1, 0, // 15239: case 0x1: {
8693 OPC_CheckPredicate, 26, // 15241: check predicate 26
8694 OPC_CheckField, 20, 5, 0, // 15243: check Inst[24:20] == 0x0
8695 OPC_Decode, 152, 114, 108, // 15247: decode to FCLASS_Q using decoder 108
8696 // 15247: }
8697 // 15247: } // switch Inst[14:12]
8698 // 15247: }
8699 120, 27, // 15251: case 0x78: {
8700 OPC_SwitchField, 20, 5, // 15253: switch Inst[24:20] {
8701 0, 10, // 15256: case 0x0: {
8702 OPC_CheckPredicate, 24, // 15258: check predicate 24
8703 OPC_CheckField, 12, 3, 0, // 15260: check Inst[14:12] == 0x0
8704 OPC_Decode, 217, 115, 109, // 15264: decode to FMV_W_X using decoder 109
8705 // 15264: }
8706 1, 0, // 15268: case 0x1: {
8707 OPC_CheckPredicate, 82, // 15270: check predicate 82
8708 OPC_CheckField, 12, 3, 0, // 15272: check Inst[14:12] == 0x0
8709 OPC_Decode, 148, 115, 110, // 15276: decode to FLI_S using decoder 110
8710 // 15276: }
8711 // 15276: } // switch Inst[24:20]
8712 // 15276: }
8713 121, 27, // 15280: case 0x79: {
8714 OPC_SwitchField, 20, 5, // 15282: switch Inst[24:20] {
8715 0, 10, // 15285: case 0x0: {
8716 OPC_CheckPredicate, 93, // 15287: check predicate 93
8717 OPC_CheckField, 12, 3, 0, // 15289: check Inst[14:12] == 0x0
8718 OPC_Decode, 215, 115, 111, // 15293: decode to FMV_D_X using decoder 111
8719 // 15293: }
8720 1, 0, // 15297: case 0x1: {
8721 OPC_CheckPredicate, 83, // 15299: check predicate 83
8722 OPC_CheckField, 12, 3, 0, // 15301: check Inst[14:12] == 0x0
8723 OPC_Decode, 145, 115, 112, // 15305: decode to FLI_D using decoder 112
8724 // 15305: }
8725 // 15305: } // switch Inst[24:20]
8726 // 15305: }
8727 122, 27, // 15309: case 0x7a: {
8728 OPC_SwitchField, 20, 5, // 15311: switch Inst[24:20] {
8729 0, 10, // 15314: case 0x0: {
8730 OPC_CheckPredicate, 23, // 15316: check predicate 23
8731 OPC_CheckField, 12, 3, 0, // 15318: check Inst[14:12] == 0x0
8732 OPC_Decode, 216, 115, 113, // 15322: decode to FMV_H_X using decoder 113
8733 // 15322: }
8734 1, 0, // 15326: case 0x1: {
8735 OPC_CheckPredicate, 96, // 15328: check predicate 96
8736 OPC_CheckField, 12, 3, 0, // 15330: check Inst[14:12] == 0x0
8737 OPC_Decode, 146, 115, 114, // 15334: decode to FLI_H using decoder 114
8738 // 15334: }
8739 // 15334: } // switch Inst[24:20]
8740 // 15334: }
8741 123, 0, // 15338: case 0x7b: {
8742 OPC_CheckPredicate, 85, // 15340: check predicate 85
8743 OPC_CheckField, 20, 5, 1, // 15342: check Inst[24:20] == 0x1
8744 OPC_CheckField, 12, 3, 0, // 15346: check Inst[14:12] == 0x0
8745 OPC_Decode, 147, 115, 115, // 15350: decode to FLI_Q using decoder 115
8746 // 15350: }
8747 // 15350: } // switch Inst[31:25]
8748 // 15350: }
8749 87, 196, 29, // 15354: case 0x57: {
8750 OPC_SwitchField, 12, 3, // 15357: switch Inst[14:12] {
8751 0, 152, 4, // 15360: case 0x0: {
8752 OPC_SwitchField, 26, 6, // 15363: switch Inst[31:26] {
8753 0, 6, // 15366: case 0x0: {
8754 OPC_CheckPredicate, 22, // 15368: check predicate 22
8755 OPC_Decode, 143, 126, 116, // 15370: decode to VADD_VV using decoder 116
8756 // 15370: }
8757 1, 6, // 15374: case 0x1: {
8758 OPC_CheckPredicate, 97, // 15376: check predicate 97
8759 OPC_Decode, 156, 126, 116, // 15378: decode to VANDN_VV using decoder 116
8760 // 15378: }
8761 2, 7, // 15382: case 0x2: {
8762 OPC_CheckPredicate, 22, // 15384: check predicate 22
8763 OPC_Decode, 167, 131, 1, 116, // 15386: decode to VSUB_VV using decoder 116
8764 // 15386: }
8765 4, 7, // 15391: case 0x4: {
8766 OPC_CheckPredicate, 22, // 15393: check predicate 22
8767 OPC_Decode, 159, 129, 1, 116, // 15395: decode to VMINU_VV using decoder 116
8768 // 15395: }
8769 5, 7, // 15400: case 0x5: {
8770 OPC_CheckPredicate, 22, // 15402: check predicate 22
8771 OPC_Decode, 161, 129, 1, 116, // 15404: decode to VMIN_VV using decoder 116
8772 // 15404: }
8773 6, 7, // 15409: case 0x6: {
8774 OPC_CheckPredicate, 22, // 15411: check predicate 22
8775 OPC_Decode, 142, 129, 1, 116, // 15413: decode to VMAXU_VV using decoder 116
8776 // 15413: }
8777 7, 7, // 15418: case 0x7: {
8778 OPC_CheckPredicate, 22, // 15420: check predicate 22
8779 OPC_Decode, 144, 129, 1, 116, // 15422: decode to VMAX_VV using decoder 116
8780 // 15422: }
8781 9, 6, // 15427: case 0x9: {
8782 OPC_CheckPredicate, 22, // 15429: check predicate 22
8783 OPC_Decode, 159, 126, 116, // 15431: decode to VAND_VV using decoder 116
8784 // 15431: }
8785 10, 7, // 15435: case 0xa: {
8786 OPC_CheckPredicate, 22, // 15437: check predicate 22
8787 OPC_Decode, 239, 129, 1, 116, // 15439: decode to VOR_VV using decoder 116
8788 // 15439: }
8789 11, 7, // 15444: case 0xb: {
8790 OPC_CheckPredicate, 22, // 15446: check predicate 22
8791 OPC_Decode, 244, 131, 1, 116, // 15448: decode to VXOR_VV using decoder 116
8792 // 15448: }
8793 12, 7, // 15453: case 0xc: {
8794 OPC_CheckPredicate, 22, // 15455: check predicate 22
8795 OPC_Decode, 136, 130, 1, 116, // 15457: decode to VRGATHER_VV using decoder 116
8796 // 15457: }
8797 14, 7, // 15462: case 0xe: {
8798 OPC_CheckPredicate, 22, // 15464: check predicate 22
8799 OPC_Decode, 134, 130, 1, 116, // 15466: decode to VRGATHEREI16_VV using decoder 116
8800 // 15466: }
8801 15, 7, // 15471: case 0xf: {
8802 OPC_CheckPredicate, 98, // 15473: check predicate 98
8803 OPC_Decode, 242, 129, 1, 116, // 15475: decode to VPAIRE_VV using decoder 116
8804 // 15475: }
8805 16, 10, // 15480: case 0x10: {
8806 OPC_CheckPredicate, 22, // 15482: check predicate 22
8807 OPC_CheckField, 25, 1, 0, // 15484: check Inst[25] == 0x0
8808 OPC_Decode, 140, 126, 117, // 15488: decode to VADC_VVM using decoder 117
8809 // 15488: }
8810 17, 21, // 15492: case 0x11: {
8811 OPC_SwitchField, 25, 1, // 15494: switch Inst[25] {
8812 0, 7, // 15497: case 0x0: {
8813 OPC_CheckPredicate, 22, // 15499: check predicate 22
8814 OPC_Decode, 239, 128, 1, 117, // 15501: decode to VMADC_VVM using decoder 117
8815 // 15501: }
8816 1, 0, // 15506: case 0x1: {
8817 OPC_CheckPredicate, 22, // 15508: check predicate 22
8818 OPC_Decode, 238, 128, 1, 118, // 15510: decode to VMADC_VV using decoder 118
8819 // 15510: }
8820 // 15510: } // switch Inst[25]
8821 // 15510: }
8822 18, 11, // 15515: case 0x12: {
8823 OPC_CheckPredicate, 22, // 15517: check predicate 22
8824 OPC_CheckField, 25, 1, 0, // 15519: check Inst[25] == 0x0
8825 OPC_Decode, 155, 130, 1, 117, // 15523: decode to VSBC_VVM using decoder 117
8826 // 15523: }
8827 19, 21, // 15528: case 0x13: {
8828 OPC_SwitchField, 25, 1, // 15530: switch Inst[25] {
8829 0, 7, // 15533: case 0x0: {
8830 OPC_CheckPredicate, 22, // 15535: check predicate 22
8831 OPC_Decode, 169, 129, 1, 117, // 15537: decode to VMSBC_VVM using decoder 117
8832 // 15537: }
8833 1, 0, // 15542: case 0x1: {
8834 OPC_CheckPredicate, 22, // 15544: check predicate 22
8835 OPC_Decode, 168, 129, 1, 118, // 15546: decode to VMSBC_VV using decoder 118
8836 // 15546: }
8837 // 15546: } // switch Inst[25]
8838 // 15546: }
8839 20, 7, // 15551: case 0x14: {
8840 OPC_CheckPredicate, 97, // 15553: check predicate 97
8841 OPC_Decode, 141, 130, 1, 116, // 15555: decode to VROR_VV using decoder 116
8842 // 15555: }
8843 21, 7, // 15560: case 0x15: {
8844 OPC_CheckPredicate, 97, // 15562: check predicate 97
8845 OPC_Decode, 138, 130, 1, 116, // 15564: decode to VROL_VV using decoder 116
8846 // 15564: }
8847 23, 25, // 15569: case 0x17: {
8848 OPC_SwitchField, 25, 1, // 15571: switch Inst[25] {
8849 0, 7, // 15574: case 0x0: {
8850 OPC_CheckPredicate, 22, // 15576: check predicate 22
8851 OPC_Decode, 147, 129, 1, 117, // 15578: decode to VMERGE_VVM using decoder 117
8852 // 15578: }
8853 1, 0, // 15583: case 0x1: {
8854 OPC_CheckPredicate, 22, // 15585: check predicate 22
8855 OPC_CheckField, 20, 5, 0, // 15587: check Inst[24:20] == 0x0
8856 OPC_Decode, 213, 129, 1, 119, // 15591: decode to VMV_V_V using decoder 119
8857 // 15591: }
8858 // 15591: } // switch Inst[25]
8859 // 15591: }
8860 24, 7, // 15596: case 0x18: {
8861 OPC_CheckPredicate, 22, // 15598: check predicate 22
8862 OPC_Decode, 174, 129, 1, 116, // 15600: decode to VMSEQ_VV using decoder 116
8863 // 15600: }
8864 25, 7, // 15605: case 0x19: {
8865 OPC_CheckPredicate, 22, // 15607: check predicate 22
8866 OPC_Decode, 192, 129, 1, 116, // 15609: decode to VMSNE_VV using decoder 116
8867 // 15609: }
8868 26, 7, // 15614: case 0x1a: {
8869 OPC_CheckPredicate, 22, // 15616: check predicate 22
8870 OPC_Decode, 187, 129, 1, 116, // 15618: decode to VMSLTU_VV using decoder 116
8871 // 15618: }
8872 27, 7, // 15623: case 0x1b: {
8873 OPC_CheckPredicate, 22, // 15625: check predicate 22
8874 OPC_Decode, 189, 129, 1, 116, // 15627: decode to VMSLT_VV using decoder 116
8875 // 15627: }
8876 28, 7, // 15632: case 0x1c: {
8877 OPC_CheckPredicate, 22, // 15634: check predicate 22
8878 OPC_Decode, 182, 129, 1, 116, // 15636: decode to VMSLEU_VV using decoder 116
8879 // 15636: }
8880 29, 7, // 15641: case 0x1d: {
8881 OPC_CheckPredicate, 22, // 15643: check predicate 22
8882 OPC_Decode, 185, 129, 1, 116, // 15645: decode to VMSLE_VV using decoder 116
8883 // 15645: }
8884 32, 7, // 15650: case 0x20: {
8885 OPC_CheckPredicate, 22, // 15652: check predicate 22
8886 OPC_Decode, 150, 130, 1, 116, // 15654: decode to VSADDU_VV using decoder 116
8887 // 15654: }
8888 33, 7, // 15659: case 0x21: {
8889 OPC_CheckPredicate, 22, // 15661: check predicate 22
8890 OPC_Decode, 153, 130, 1, 116, // 15663: decode to VSADD_VV using decoder 116
8891 // 15663: }
8892 34, 7, // 15668: case 0x22: {
8893 OPC_CheckPredicate, 22, // 15670: check predicate 22
8894 OPC_Decode, 163, 131, 1, 116, // 15672: decode to VSSUBU_VV using decoder 116
8895 // 15672: }
8896 35, 7, // 15677: case 0x23: {
8897 OPC_CheckPredicate, 22, // 15679: check predicate 22
8898 OPC_Decode, 165, 131, 1, 116, // 15681: decode to VSSUB_VV using decoder 116
8899 // 15681: }
8900 37, 7, // 15686: case 0x25: {
8901 OPC_CheckPredicate, 22, // 15688: check predicate 22
8902 OPC_Decode, 177, 130, 1, 116, // 15690: decode to VSLL_VV using decoder 116
8903 // 15690: }
8904 39, 7, // 15695: case 0x27: {
8905 OPC_CheckPredicate, 22, // 15697: check predicate 22
8906 OPC_Decode, 184, 130, 1, 116, // 15699: decode to VSMUL_VV using decoder 116
8907 // 15699: }
8908 40, 7, // 15704: case 0x28: {
8909 OPC_CheckPredicate, 22, // 15706: check predicate 22
8910 OPC_Decode, 223, 130, 1, 116, // 15708: decode to VSRL_VV using decoder 116
8911 // 15708: }
8912 41, 7, // 15713: case 0x29: {
8913 OPC_CheckPredicate, 22, // 15715: check predicate 22
8914 OPC_Decode, 220, 130, 1, 116, // 15717: decode to VSRA_VV using decoder 116
8915 // 15717: }
8916 42, 7, // 15722: case 0x2a: {
8917 OPC_CheckPredicate, 22, // 15724: check predicate 22
8918 OPC_Decode, 133, 131, 1, 116, // 15726: decode to VSSRL_VV using decoder 116
8919 // 15726: }
8920 43, 7, // 15731: case 0x2b: {
8921 OPC_CheckPredicate, 22, // 15733: check predicate 22
8922 OPC_Decode, 130, 131, 1, 116, // 15735: decode to VSSRA_VV using decoder 116
8923 // 15735: }
8924 44, 7, // 15740: case 0x2c: {
8925 OPC_CheckPredicate, 22, // 15742: check predicate 22
8926 OPC_Decode, 236, 129, 1, 116, // 15744: decode to VNSRL_WV using decoder 116
8927 // 15744: }
8928 45, 7, // 15749: case 0x2d: {
8929 OPC_CheckPredicate, 22, // 15751: check predicate 22
8930 OPC_Decode, 233, 129, 1, 116, // 15753: decode to VNSRA_WV using decoder 116
8931 // 15753: }
8932 46, 7, // 15758: case 0x2e: {
8933 OPC_CheckPredicate, 22, // 15760: check predicate 22
8934 OPC_Decode, 219, 129, 1, 116, // 15762: decode to VNCLIPU_WV using decoder 116
8935 // 15762: }
8936 47, 7, // 15767: case 0x2f: {
8937 OPC_CheckPredicate, 22, // 15769: check predicate 22
8938 OPC_Decode, 222, 129, 1, 116, // 15771: decode to VNCLIP_WV using decoder 116
8939 // 15771: }
8940 48, 7, // 15776: case 0x30: {
8941 OPC_CheckPredicate, 22, // 15778: check predicate 22
8942 OPC_Decode, 230, 131, 1, 116, // 15780: decode to VWREDSUMU_VS using decoder 116
8943 // 15780: }
8944 49, 7, // 15785: case 0x31: {
8945 OPC_CheckPredicate, 22, // 15787: check predicate 22
8946 OPC_Decode, 231, 131, 1, 116, // 15789: decode to VWREDSUM_VS using decoder 116
8947 // 15789: }
8948 53, 7, // 15794: case 0x35: {
8949 OPC_CheckPredicate, 99, // 15796: check predicate 99
8950 OPC_Decode, 233, 131, 1, 116, // 15798: decode to VWSLL_VV using decoder 116
8951 // 15798: }
8952 56, 11, // 15803: case 0x38: {
8953 OPC_CheckPredicate, 100, // 15805: check predicate 100
8954 OPC_CheckField, 25, 1, 1, // 15807: check Inst[25] == 0x1
8955 OPC_Decode, 163, 129, 1, 120, // 15811: decode to VMMACC_VV using decoder 120
8956 // 15811: }
8957 57, 20, // 15816: case 0x39: {
8958 OPC_SwitchField, 25, 1, // 15818: switch Inst[25] {
8959 0, 6, // 15821: case 0x0: {
8960 OPC_CheckPredicate, 101, // 15823: check predicate 101
8961 OPC_Decode, 154, 127, 121, // 15825: decode to VFWIMMACC_VV using decoder 121
8962 // 15825: }
8963 1, 0, // 15829: case 0x1: {
8964 OPC_CheckPredicate, 100, // 15831: check predicate 100
8965 OPC_Decode, 223, 131, 1, 120, // 15833: decode to VWMMACC_VV using decoder 120
8966 // 15833: }
8967 // 15833: } // switch Inst[25]
8968 // 15833: }
8969 58, 20, // 15838: case 0x3a: {
8970 OPC_SwitchField, 25, 1, // 15840: switch Inst[25] {
8971 0, 6, // 15843: case 0x0: {
8972 OPC_CheckPredicate, 101, // 15845: check predicate 101
8973 OPC_Decode, 242, 126, 121, // 15847: decode to VFQIMMACC_VV using decoder 121
8974 // 15847: }
8975 1, 0, // 15851: case 0x1: {
8976 OPC_CheckPredicate, 100, // 15853: check predicate 100
8977 OPC_Decode, 244, 129, 1, 120, // 15855: decode to VQMMACC_VV using decoder 120
8978 // 15855: }
8979 // 15855: } // switch Inst[25]
8980 // 15855: }
8981 59, 19, // 15860: case 0x3b: {
8982 OPC_SwitchField, 25, 1, // 15862: switch Inst[25] {
8983 0, 6, // 15865: case 0x0: {
8984 OPC_CheckPredicate, 101, // 15867: check predicate 101
8985 OPC_Decode, 187, 126, 121, // 15869: decode to VF8WIMMACC_VV using decoder 121
8986 // 15869: }
8987 1, 0, // 15873: case 0x1: {
8988 OPC_CheckPredicate, 100, // 15875: check predicate 100
8989 OPC_Decode, 130, 126, 120, // 15877: decode to V8WMMACC_VV using decoder 120
8990 // 15877: }
8991 // 15877: } // switch Inst[25]
8992 // 15877: }
8993 61, 7, // 15881: case 0x3d: {
8994 OPC_CheckPredicate, 102, // 15883: check predicate 102
8995 OPC_Decode, 206, 131, 1, 122, // 15885: decode to VWABDA_VV using decoder 122
8996 // 15885: }
8997 62, 0, // 15890: case 0x3e: {
8998 OPC_CheckPredicate, 102, // 15892: check predicate 102
8999 OPC_Decode, 204, 131, 1, 122, // 15894: decode to VWABDAU_VV using decoder 122
9000 // 15894: }
9001 // 15894: } // switch Inst[31:26]
9002 // 15894: }
9003 1, 133, 5, // 15899: case 0x1: {
9004 OPC_SwitchField, 26, 6, // 15902: switch Inst[31:26] {
9005 0, 6, // 15905: case 0x0: {
9006 OPC_CheckPredicate, 103, // 15907: check predicate 103
9007 OPC_Decode, 191, 126, 116, // 15909: decode to VFADD_VV using decoder 116
9008 // 15909: }
9009 1, 6, // 15913: case 0x1: {
9010 OPC_CheckPredicate, 103, // 15915: check predicate 103
9011 OPC_Decode, 254, 126, 116, // 15917: decode to VFREDUSUM_VS using decoder 116
9012 // 15917: }
9013 2, 6, // 15921: case 0x2: {
9014 OPC_CheckPredicate, 103, // 15923: check predicate 103
9015 OPC_Decode, 139, 127, 116, // 15925: decode to VFSUB_VV using decoder 116
9016 // 15925: }
9017 3, 6, // 15929: case 0x3: {
9018 OPC_CheckPredicate, 103, // 15931: check predicate 103
9019 OPC_Decode, 253, 126, 116, // 15933: decode to VFREDOSUM_VS using decoder 116
9020 // 15933: }
9021 4, 6, // 15937: case 0x4: {
9022 OPC_CheckPredicate, 103, // 15939: check predicate 103
9023 OPC_Decode, 211, 126, 116, // 15941: decode to VFMIN_VV using decoder 116
9024 // 15941: }
9025 5, 6, // 15945: case 0x5: {
9026 OPC_CheckPredicate, 103, // 15947: check predicate 103
9027 OPC_Decode, 252, 126, 116, // 15949: decode to VFREDMIN_VS using decoder 116
9028 // 15949: }
9029 6, 6, // 15953: case 0x6: {
9030 OPC_CheckPredicate, 103, // 15955: check predicate 103
9031 OPC_Decode, 208, 126, 116, // 15957: decode to VFMAX_VV using decoder 116
9032 // 15957: }
9033 7, 6, // 15961: case 0x7: {
9034 OPC_CheckPredicate, 103, // 15963: check predicate 103
9035 OPC_Decode, 251, 126, 116, // 15965: decode to VFREDMAX_VS using decoder 116
9036 // 15965: }
9037 8, 6, // 15969: case 0x8: {
9038 OPC_CheckPredicate, 103, // 15971: check predicate 103
9039 OPC_Decode, 134, 127, 116, // 15973: decode to VFSGNJ_VV using decoder 116
9040 // 15973: }
9041 9, 6, // 15977: case 0x9: {
9042 OPC_CheckPredicate, 103, // 15979: check predicate 103
9043 OPC_Decode, 130, 127, 116, // 15981: decode to VFSGNJN_VV using decoder 116
9044 // 15981: }
9045 10, 6, // 15985: case 0xa: {
9046 OPC_CheckPredicate, 103, // 15987: check predicate 103
9047 OPC_Decode, 132, 127, 116, // 15989: decode to VFSGNJX_VV using decoder 116
9048 // 15989: }
9049 16, 14, // 15993: case 0x10: {
9050 OPC_CheckPredicate, 103, // 15995: check predicate 103
9051 OPC_CheckField, 25, 1, 1, // 15997: check Inst[25] == 0x1
9052 OPC_CheckField, 15, 5, 0, // 16001: check Inst[19:15] == 0x0
9053 OPC_Decode, 219, 126, 123, // 16005: decode to VFMV_F_S using decoder 123
9054 // 16005: }
9055 18, 211, 1, // 16009: case 0x12: {
9056 OPC_SwitchField, 15, 5, // 16012: switch Inst[19:15] {
9057 0, 6, // 16015: case 0x0: {
9058 OPC_CheckPredicate, 103, // 16017: check predicate 103
9059 OPC_Decode, 198, 126, 124, // 16019: decode to VFCVT_XU_F_V using decoder 124
9060 // 16019: }
9061 1, 6, // 16023: case 0x1: {
9062 OPC_CheckPredicate, 103, // 16025: check predicate 103
9063 OPC_Decode, 199, 126, 124, // 16027: decode to VFCVT_X_F_V using decoder 124
9064 // 16027: }
9065 2, 6, // 16031: case 0x2: {
9066 OPC_CheckPredicate, 103, // 16033: check predicate 103
9067 OPC_Decode, 194, 126, 124, // 16035: decode to VFCVT_F_XU_V using decoder 124
9068 // 16035: }
9069 3, 6, // 16039: case 0x3: {
9070 OPC_CheckPredicate, 103, // 16041: check predicate 103
9071 OPC_Decode, 195, 126, 124, // 16043: decode to VFCVT_F_X_V using decoder 124
9072 // 16043: }
9073 6, 6, // 16047: case 0x6: {
9074 OPC_CheckPredicate, 103, // 16049: check predicate 103
9075 OPC_Decode, 196, 126, 124, // 16051: decode to VFCVT_RTZ_XU_F_V using decoder 124
9076 // 16051: }
9077 7, 6, // 16055: case 0x7: {
9078 OPC_CheckPredicate, 103, // 16057: check predicate 103
9079 OPC_Decode, 197, 126, 124, // 16059: decode to VFCVT_RTZ_X_F_V using decoder 124
9080 // 16059: }
9081 8, 6, // 16063: case 0x8: {
9082 OPC_CheckPredicate, 103, // 16065: check predicate 103
9083 OPC_Decode, 151, 127, 124, // 16067: decode to VFWCVT_XU_F_V using decoder 124
9084 // 16067: }
9085 9, 6, // 16071: case 0x9: {
9086 OPC_CheckPredicate, 103, // 16073: check predicate 103
9087 OPC_Decode, 152, 127, 124, // 16075: decode to VFWCVT_X_F_V using decoder 124
9088 // 16075: }
9089 10, 6, // 16079: case 0xa: {
9090 OPC_CheckPredicate, 103, // 16081: check predicate 103
9091 OPC_Decode, 147, 127, 124, // 16083: decode to VFWCVT_F_XU_V using decoder 124
9092 // 16083: }
9093 11, 6, // 16087: case 0xb: {
9094 OPC_CheckPredicate, 103, // 16089: check predicate 103
9095 OPC_Decode, 148, 127, 124, // 16091: decode to VFWCVT_F_X_V using decoder 124
9096 // 16091: }
9097 12, 6, // 16095: case 0xc: {
9098 OPC_CheckPredicate, 103, // 16097: check predicate 103
9099 OPC_Decode, 146, 127, 124, // 16099: decode to VFWCVT_F_F_V using decoder 124
9100 // 16099: }
9101 13, 6, // 16103: case 0xd: {
9102 OPC_CheckPredicate, 104, // 16105: check predicate 104
9103 OPC_Decode, 145, 127, 124, // 16107: decode to VFWCVTBF16_F_F_V using decoder 124
9104 // 16107: }
9105 14, 6, // 16111: case 0xe: {
9106 OPC_CheckPredicate, 103, // 16113: check predicate 103
9107 OPC_Decode, 149, 127, 124, // 16115: decode to VFWCVT_RTZ_XU_F_V using decoder 124
9108 // 16115: }
9109 15, 6, // 16119: case 0xf: {
9110 OPC_CheckPredicate, 103, // 16121: check predicate 103
9111 OPC_Decode, 150, 127, 124, // 16123: decode to VFWCVT_RTZ_X_F_V using decoder 124
9112 // 16123: }
9113 16, 6, // 16127: case 0x10: {
9114 OPC_CheckPredicate, 103, // 16129: check predicate 103
9115 OPC_Decode, 232, 126, 124, // 16131: decode to VFNCVT_XU_F_W using decoder 124
9116 // 16131: }
9117 17, 6, // 16135: case 0x11: {
9118 OPC_CheckPredicate, 103, // 16137: check predicate 103
9119 OPC_Decode, 233, 126, 124, // 16139: decode to VFNCVT_X_F_W using decoder 124
9120 // 16139: }
9121 18, 6, // 16143: case 0x12: {
9122 OPC_CheckPredicate, 103, // 16145: check predicate 103
9123 OPC_Decode, 226, 126, 124, // 16147: decode to VFNCVT_F_XU_W using decoder 124
9124 // 16147: }
9125 19, 6, // 16151: case 0x13: {
9126 OPC_CheckPredicate, 103, // 16153: check predicate 103
9127 OPC_Decode, 227, 126, 124, // 16155: decode to VFNCVT_F_X_W using decoder 124
9128 // 16155: }
9129 20, 6, // 16159: case 0x14: {
9130 OPC_CheckPredicate, 103, // 16161: check predicate 103
9131 OPC_Decode, 225, 126, 124, // 16163: decode to VFNCVT_F_F_W using decoder 124
9132 // 16163: }
9133 21, 6, // 16167: case 0x15: {
9134 OPC_CheckPredicate, 103, // 16169: check predicate 103
9135 OPC_Decode, 228, 126, 124, // 16171: decode to VFNCVT_ROD_F_F_W using decoder 124
9136 // 16171: }
9137 22, 6, // 16175: case 0x16: {
9138 OPC_CheckPredicate, 103, // 16177: check predicate 103
9139 OPC_Decode, 229, 126, 124, // 16179: decode to VFNCVT_RTZ_XU_F_W using decoder 124
9140 // 16179: }
9141 23, 6, // 16183: case 0x17: {
9142 OPC_CheckPredicate, 103, // 16185: check predicate 103
9143 OPC_Decode, 230, 126, 124, // 16187: decode to VFNCVT_RTZ_X_F_W using decoder 124
9144 // 16187: }
9145 25, 6, // 16191: case 0x19: {
9146 OPC_CheckPredicate, 105, // 16193: check predicate 105
9147 OPC_Decode, 224, 126, 124, // 16195: decode to VFNCVT_F_F_Q using decoder 124
9148 // 16195: }
9149 27, 6, // 16199: case 0x1b: {
9150 OPC_CheckPredicate, 105, // 16201: check predicate 105
9151 OPC_Decode, 231, 126, 124, // 16203: decode to VFNCVT_SAT_F_F_Q using decoder 124
9152 // 16203: }
9153 29, 6, // 16207: case 0x1d: {
9154 OPC_CheckPredicate, 104, // 16209: check predicate 104
9155 OPC_Decode, 222, 126, 124, // 16211: decode to VFNCVTBF16_F_F_W using decoder 124
9156 // 16211: }
9157 31, 0, // 16215: case 0x1f: {
9158 OPC_CheckPredicate, 105, // 16217: check predicate 105
9159 OPC_Decode, 223, 126, 124, // 16219: decode to VFNCVTBF16_SAT_F_F_W using decoder 124
9160 // 16219: }
9161 // 16219: } // switch Inst[19:15]
9162 // 16219: }
9163 19, 35, // 16223: case 0x13: {
9164 OPC_SwitchField, 15, 5, // 16225: switch Inst[19:15] {
9165 0, 6, // 16228: case 0x0: {
9166 OPC_CheckPredicate, 103, // 16230: check predicate 103
9167 OPC_Decode, 137, 127, 124, // 16232: decode to VFSQRT_V using decoder 124
9168 // 16232: }
9169 4, 6, // 16236: case 0x4: {
9170 OPC_CheckPredicate, 103, // 16238: check predicate 103
9171 OPC_Decode, 255, 126, 124, // 16240: decode to VFRSQRT7_V using decoder 124
9172 // 16240: }
9173 5, 6, // 16244: case 0x5: {
9174 OPC_CheckPredicate, 103, // 16246: check predicate 103
9175 OPC_Decode, 250, 126, 124, // 16248: decode to VFREC7_V using decoder 124
9176 // 16248: }
9177 16, 0, // 16252: case 0x10: {
9178 OPC_CheckPredicate, 103, // 16254: check predicate 103
9179 OPC_Decode, 193, 126, 124, // 16256: decode to VFCLASS_V using decoder 124
9180 // 16256: }
9181 // 16256: } // switch Inst[19:15]
9182 // 16256: }
9183 20, 10, // 16260: case 0x14: {
9184 OPC_CheckPredicate, 101, // 16262: check predicate 101
9185 OPC_CheckField, 25, 1, 1, // 16264: check Inst[25] == 0x1
9186 OPC_Decode, 212, 126, 120, // 16268: decode to VFMMACC_VV using decoder 120
9187 // 16268: }
9188 21, 19, // 16272: case 0x15: {
9189 OPC_SwitchField, 25, 1, // 16274: switch Inst[25] {
9190 0, 6, // 16277: case 0x0: {
9191 OPC_CheckPredicate, 101, // 16279: check predicate 101
9192 OPC_Decode, 164, 127, 121, // 16281: decode to VFWMMACC_VV_SCALE using decoder 121
9193 // 16281: }
9194 1, 0, // 16285: case 0x1: {
9195 OPC_CheckPredicate, 101, // 16287: check predicate 101
9196 OPC_Decode, 163, 127, 120, // 16289: decode to VFWMMACC_VV using decoder 120
9197 // 16289: }
9198 // 16289: } // switch Inst[25]
9199 // 16289: }
9200 22, 19, // 16293: case 0x16: {
9201 OPC_SwitchField, 25, 1, // 16295: switch Inst[25] {
9202 0, 6, // 16298: case 0x0: {
9203 OPC_CheckPredicate, 101, // 16300: check predicate 101
9204 OPC_Decode, 244, 126, 121, // 16302: decode to VFQMMACC_VV_SCALE using decoder 121
9205 // 16302: }
9206 1, 0, // 16306: case 0x1: {
9207 OPC_CheckPredicate, 101, // 16308: check predicate 101
9208 OPC_Decode, 243, 126, 120, // 16310: decode to VFQMMACC_VV using decoder 120
9209 // 16310: }
9210 // 16310: } // switch Inst[25]
9211 // 16310: }
9212 23, 19, // 16314: case 0x17: {
9213 OPC_SwitchField, 25, 1, // 16316: switch Inst[25] {
9214 0, 6, // 16319: case 0x0: {
9215 OPC_CheckPredicate, 101, // 16321: check predicate 101
9216 OPC_Decode, 189, 126, 121, // 16323: decode to VF8WMMACC_VV_SCALE using decoder 121
9217 // 16323: }
9218 1, 0, // 16327: case 0x1: {
9219 OPC_CheckPredicate, 101, // 16329: check predicate 101
9220 OPC_Decode, 188, 126, 120, // 16331: decode to VF8WMMACC_VV using decoder 120
9221 // 16331: }
9222 // 16331: } // switch Inst[25]
9223 // 16331: }
9224 24, 7, // 16335: case 0x18: {
9225 OPC_CheckPredicate, 103, // 16337: check predicate 103
9226 OPC_Decode, 150, 129, 1, 116, // 16339: decode to VMFEQ_VV using decoder 116
9227 // 16339: }
9228 25, 7, // 16344: case 0x19: {
9229 OPC_CheckPredicate, 103, // 16346: check predicate 103
9230 OPC_Decode, 154, 129, 1, 116, // 16348: decode to VMFLE_VV using decoder 116
9231 // 16348: }
9232 27, 7, // 16353: case 0x1b: {
9233 OPC_CheckPredicate, 103, // 16355: check predicate 103
9234 OPC_Decode, 156, 129, 1, 116, // 16357: decode to VMFLT_VV using decoder 116
9235 // 16357: }
9236 28, 7, // 16362: case 0x1c: {
9237 OPC_CheckPredicate, 103, // 16364: check predicate 103
9238 OPC_Decode, 158, 129, 1, 116, // 16366: decode to VMFNE_VV using decoder 116
9239 // 16366: }
9240 32, 6, // 16371: case 0x20: {
9241 OPC_CheckPredicate, 103, // 16373: check predicate 103
9242 OPC_Decode, 201, 126, 116, // 16375: decode to VFDIV_VV using decoder 116
9243 // 16375: }
9244 36, 6, // 16379: case 0x24: {
9245 OPC_CheckPredicate, 103, // 16381: check predicate 103
9246 OPC_Decode, 218, 126, 116, // 16383: decode to VFMUL_VV using decoder 116
9247 // 16383: }
9248 40, 6, // 16387: case 0x28: {
9249 OPC_CheckPredicate, 103, // 16389: check predicate 103
9250 OPC_Decode, 206, 126, 125, // 16391: decode to VFMADD_VV using decoder 125
9251 // 16391: }
9252 41, 6, // 16395: case 0x29: {
9253 OPC_CheckPredicate, 103, // 16397: check predicate 103
9254 OPC_Decode, 237, 126, 125, // 16399: decode to VFNMADD_VV using decoder 125
9255 // 16399: }
9256 42, 6, // 16403: case 0x2a: {
9257 OPC_CheckPredicate, 103, // 16405: check predicate 103
9258 OPC_Decode, 216, 126, 125, // 16407: decode to VFMSUB_VV using decoder 125
9259 // 16407: }
9260 43, 6, // 16411: case 0x2b: {
9261 OPC_CheckPredicate, 103, // 16413: check predicate 103
9262 OPC_Decode, 241, 126, 125, // 16415: decode to VFNMSUB_VV using decoder 125
9263 // 16415: }
9264 44, 6, // 16419: case 0x2c: {
9265 OPC_CheckPredicate, 103, // 16421: check predicate 103
9266 OPC_Decode, 204, 126, 125, // 16423: decode to VFMACC_VV using decoder 125
9267 // 16423: }
9268 45, 6, // 16427: case 0x2d: {
9269 OPC_CheckPredicate, 103, // 16429: check predicate 103
9270 OPC_Decode, 235, 126, 125, // 16431: decode to VFNMACC_VV using decoder 125
9271 // 16431: }
9272 46, 6, // 16435: case 0x2e: {
9273 OPC_CheckPredicate, 103, // 16437: check predicate 103
9274 OPC_Decode, 214, 126, 125, // 16439: decode to VFMSAC_VV using decoder 125
9275 // 16439: }
9276 47, 6, // 16443: case 0x2f: {
9277 OPC_CheckPredicate, 103, // 16445: check predicate 103
9278 OPC_Decode, 239, 126, 125, // 16447: decode to VFNMSAC_VV using decoder 125
9279 // 16447: }
9280 48, 6, // 16451: case 0x30: {
9281 OPC_CheckPredicate, 103, // 16453: check predicate 103
9282 OPC_Decode, 141, 127, 116, // 16455: decode to VFWADD_VV using decoder 116
9283 // 16455: }
9284 49, 6, // 16459: case 0x31: {
9285 OPC_CheckPredicate, 103, // 16461: check predicate 103
9286 OPC_Decode, 174, 127, 116, // 16463: decode to VFWREDUSUM_VS using decoder 116
9287 // 16463: }
9288 50, 6, // 16467: case 0x32: {
9289 OPC_CheckPredicate, 103, // 16469: check predicate 103
9290 OPC_Decode, 176, 127, 116, // 16471: decode to VFWSUB_VV using decoder 116
9291 // 16471: }
9292 51, 6, // 16475: case 0x33: {
9293 OPC_CheckPredicate, 103, // 16477: check predicate 103
9294 OPC_Decode, 173, 127, 116, // 16479: decode to VFWREDOSUM_VS using decoder 116
9295 // 16479: }
9296 52, 6, // 16483: case 0x34: {
9297 OPC_CheckPredicate, 103, // 16485: check predicate 103
9298 OPC_Decode, 143, 127, 116, // 16487: decode to VFWADD_WV using decoder 116
9299 // 16487: }
9300 54, 6, // 16491: case 0x36: {
9301 OPC_CheckPredicate, 103, // 16493: check predicate 103
9302 OPC_Decode, 178, 127, 116, // 16495: decode to VFWSUB_WV using decoder 116
9303 // 16495: }
9304 56, 6, // 16499: case 0x38: {
9305 OPC_CheckPredicate, 103, // 16501: check predicate 103
9306 OPC_Decode, 168, 127, 116, // 16503: decode to VFWMUL_VV using decoder 116
9307 // 16503: }
9308 59, 6, // 16507: case 0x3b: {
9309 OPC_CheckPredicate, 106, // 16509: check predicate 106
9310 OPC_Decode, 156, 127, 125, // 16511: decode to VFWMACCBF16_VV using decoder 125
9311 // 16511: }
9312 60, 6, // 16515: case 0x3c: {
9313 OPC_CheckPredicate, 103, // 16517: check predicate 103
9314 OPC_Decode, 158, 127, 125, // 16519: decode to VFWMACC_VV using decoder 125
9315 // 16519: }
9316 61, 6, // 16523: case 0x3d: {
9317 OPC_CheckPredicate, 103, // 16525: check predicate 103
9318 OPC_Decode, 170, 127, 125, // 16527: decode to VFWNMACC_VV using decoder 125
9319 // 16527: }
9320 62, 6, // 16531: case 0x3e: {
9321 OPC_CheckPredicate, 103, // 16533: check predicate 103
9322 OPC_Decode, 166, 127, 125, // 16535: decode to VFWMSAC_VV using decoder 125
9323 // 16535: }
9324 63, 0, // 16539: case 0x3f: {
9325 OPC_CheckPredicate, 103, // 16541: check predicate 103
9326 OPC_Decode, 172, 127, 125, // 16543: decode to VFWNMSAC_VV using decoder 125
9327 // 16543: }
9328 // 16543: } // switch Inst[31:26]
9329 // 16543: }
9330 2, 241, 5, // 16547: case 0x2: {
9331 OPC_SwitchField, 26, 6, // 16550: switch Inst[31:26] {
9332 0, 7, // 16553: case 0x0: {
9333 OPC_CheckPredicate, 22, // 16555: check predicate 22
9334 OPC_Decode, 255, 129, 1, 116, // 16557: decode to VREDSUM_VS using decoder 116
9335 // 16557: }
9336 1, 7, // 16562: case 0x1: {
9337 OPC_CheckPredicate, 22, // 16564: check predicate 22
9338 OPC_Decode, 249, 129, 1, 116, // 16566: decode to VREDAND_VS using decoder 116
9339 // 16566: }
9340 2, 7, // 16571: case 0x2: {
9341 OPC_CheckPredicate, 22, // 16573: check predicate 22
9342 OPC_Decode, 254, 129, 1, 116, // 16575: decode to VREDOR_VS using decoder 116
9343 // 16575: }
9344 3, 7, // 16580: case 0x3: {
9345 OPC_CheckPredicate, 22, // 16582: check predicate 22
9346 OPC_Decode, 128, 130, 1, 116, // 16584: decode to VREDXOR_VS using decoder 116
9347 // 16584: }
9348 4, 7, // 16589: case 0x4: {
9349 OPC_CheckPredicate, 22, // 16591: check predicate 22
9350 OPC_Decode, 252, 129, 1, 116, // 16593: decode to VREDMINU_VS using decoder 116
9351 // 16593: }
9352 5, 7, // 16598: case 0x5: {
9353 OPC_CheckPredicate, 22, // 16600: check predicate 22
9354 OPC_Decode, 253, 129, 1, 116, // 16602: decode to VREDMIN_VS using decoder 116
9355 // 16602: }
9356 6, 7, // 16607: case 0x6: {
9357 OPC_CheckPredicate, 22, // 16609: check predicate 22
9358 OPC_Decode, 250, 129, 1, 116, // 16611: decode to VREDMAXU_VS using decoder 116
9359 // 16611: }
9360 7, 7, // 16616: case 0x7: {
9361 OPC_CheckPredicate, 22, // 16618: check predicate 22
9362 OPC_Decode, 251, 129, 1, 116, // 16620: decode to VREDMAX_VS using decoder 116
9363 // 16620: }
9364 8, 6, // 16625: case 0x8: {
9365 OPC_CheckPredicate, 22, // 16627: check predicate 22
9366 OPC_Decode, 131, 126, 116, // 16629: decode to VAADDU_VV using decoder 116
9367 // 16629: }
9368 9, 6, // 16633: case 0x9: {
9369 OPC_CheckPredicate, 22, // 16635: check predicate 22
9370 OPC_Decode, 133, 126, 116, // 16637: decode to VAADD_VV using decoder 116
9371 // 16637: }
9372 10, 6, // 16641: case 0xa: {
9373 OPC_CheckPredicate, 22, // 16643: check predicate 22
9374 OPC_Decode, 161, 126, 116, // 16645: decode to VASUBU_VV using decoder 116
9375 // 16645: }
9376 11, 6, // 16649: case 0xb: {
9377 OPC_CheckPredicate, 22, // 16651: check predicate 22
9378 OPC_Decode, 163, 126, 116, // 16653: decode to VASUB_VV using decoder 116
9379 // 16653: }
9380 12, 6, // 16657: case 0xc: {
9381 OPC_CheckPredicate, 107, // 16659: check predicate 107
9382 OPC_Decode, 169, 126, 116, // 16661: decode to VCLMUL_VV using decoder 116
9383 // 16661: }
9384 13, 6, // 16665: case 0xd: {
9385 OPC_CheckPredicate, 107, // 16667: check predicate 107
9386 OPC_Decode, 167, 126, 116, // 16669: decode to VCLMULH_VV using decoder 116
9387 // 16669: }
9388 15, 7, // 16673: case 0xf: {
9389 OPC_CheckPredicate, 98, // 16675: check predicate 98
9390 OPC_Decode, 243, 129, 1, 116, // 16677: decode to VPAIRO_VV using decoder 116
9391 // 16677: }
9392 16, 32, // 16682: case 0x10: {
9393 OPC_SwitchField, 15, 5, // 16684: switch Inst[19:15] {
9394 0, 11, // 16687: case 0x0: {
9395 OPC_CheckPredicate, 22, // 16689: check predicate 22
9396 OPC_CheckField, 25, 1, 1, // 16691: check Inst[25] == 0x1
9397 OPC_Decode, 215, 129, 1, 126, // 16695: decode to VMV_X_S using decoder 126
9398 // 16695: }
9399 16, 6, // 16700: case 0x10: {
9400 OPC_CheckPredicate, 22, // 16702: check predicate 22
9401 OPC_Decode, 173, 126, 127, // 16704: decode to VCPOP_M using decoder 127
9402 // 16704: }
9403 17, 0, // 16708: case 0x11: {
9404 OPC_CheckPredicate, 22, // 16710: check predicate 22
9405 OPC_Decode, 202, 126, 127, // 16712: decode to VFIRST_M using decoder 127
9406 // 16712: }
9407 // 16712: } // switch Inst[19:15]
9408 // 16712: }
9409 18, 134, 1, // 16716: case 0x12: {
9410 OPC_SwitchField, 15, 5, // 16719: switch Inst[19:15] {
9411 2, 7, // 16722: case 0x2: {
9412 OPC_CheckPredicate, 22, // 16724: check predicate 22
9413 OPC_Decode, 248, 131, 1, 124, // 16726: decode to VZEXT_VF8 using decoder 124
9414 // 16726: }
9415 3, 7, // 16731: case 0x3: {
9416 OPC_CheckPredicate, 22, // 16733: check predicate 22
9417 OPC_Decode, 166, 130, 1, 124, // 16735: decode to VSEXT_VF8 using decoder 124
9418 // 16735: }
9419 4, 7, // 16740: case 0x4: {
9420 OPC_CheckPredicate, 22, // 16742: check predicate 22
9421 OPC_Decode, 247, 131, 1, 124, // 16744: decode to VZEXT_VF4 using decoder 124
9422 // 16744: }
9423 5, 7, // 16749: case 0x5: {
9424 OPC_CheckPredicate, 22, // 16751: check predicate 22
9425 OPC_Decode, 165, 130, 1, 124, // 16753: decode to VSEXT_VF4 using decoder 124
9426 // 16753: }
9427 6, 7, // 16758: case 0x6: {
9428 OPC_CheckPredicate, 22, // 16760: check predicate 22
9429 OPC_Decode, 246, 131, 1, 124, // 16762: decode to VZEXT_VF2 using decoder 124
9430 // 16762: }
9431 7, 7, // 16767: case 0x7: {
9432 OPC_CheckPredicate, 22, // 16769: check predicate 22
9433 OPC_Decode, 164, 130, 1, 124, // 16771: decode to VSEXT_VF2 using decoder 124
9434 // 16771: }
9435 8, 6, // 16776: case 0x8: {
9436 OPC_CheckPredicate, 97, // 16778: check predicate 97
9437 OPC_Decode, 165, 126, 124, // 16780: decode to VBREV8_V using decoder 124
9438 // 16780: }
9439 9, 7, // 16784: case 0x9: {
9440 OPC_CheckPredicate, 97, // 16786: check predicate 97
9441 OPC_Decode, 133, 130, 1, 124, // 16788: decode to VREV8_V using decoder 124
9442 // 16788: }
9443 10, 6, // 16793: case 0xa: {
9444 OPC_CheckPredicate, 99, // 16795: check predicate 99
9445 OPC_Decode, 166, 126, 124, // 16797: decode to VBREV_V using decoder 124
9446 // 16797: }
9447 11, 12, // 16801: case 0xb: {
9448 OPC_CheckPredicate, 98, // 16803: check predicate 98
9449 OPC_CheckField, 25, 1, 1, // 16805: check Inst[25] == 0x1
9450 OPC_Decode, 201, 131, 1, 128, 1, // 16809: decode to VUNZIPE_V using decoder 128
9451 // 16809: }
9452 12, 6, // 16815: case 0xc: {
9453 OPC_CheckPredicate, 99, // 16817: check predicate 99
9454 OPC_Decode, 171, 126, 124, // 16819: decode to VCLZ_V using decoder 124
9455 // 16819: }
9456 13, 6, // 16823: case 0xd: {
9457 OPC_CheckPredicate, 99, // 16825: check predicate 99
9458 OPC_Decode, 175, 126, 124, // 16827: decode to VCTZ_V using decoder 124
9459 // 16827: }
9460 14, 6, // 16831: case 0xe: {
9461 OPC_CheckPredicate, 99, // 16833: check predicate 99
9462 OPC_Decode, 174, 126, 124, // 16835: decode to VCPOP_V using decoder 124
9463 // 16835: }
9464 15, 0, // 16839: case 0xf: {
9465 OPC_CheckPredicate, 98, // 16841: check predicate 98
9466 OPC_CheckField, 25, 1, 1, // 16843: check Inst[25] == 0x1
9467 OPC_Decode, 202, 131, 1, 128, 1, // 16847: decode to VUNZIPO_V using decoder 128
9468 // 16847: }
9469 // 16847: } // switch Inst[19:15]
9470 // 16847: }
9471 20, 51, // 16853: case 0x14: {
9472 OPC_SwitchField, 15, 5, // 16855: switch Inst[19:15] {
9473 1, 7, // 16858: case 0x1: {
9474 OPC_CheckPredicate, 22, // 16860: check predicate 22
9475 OPC_Decode, 172, 129, 1, 124, // 16862: decode to VMSBF_M using decoder 124
9476 // 16862: }
9477 2, 7, // 16867: case 0x2: {
9478 OPC_CheckPredicate, 22, // 16869: check predicate 22
9479 OPC_Decode, 194, 129, 1, 124, // 16871: decode to VMSOF_M using decoder 124
9480 // 16871: }
9481 3, 7, // 16876: case 0x3: {
9482 OPC_CheckPredicate, 22, // 16878: check predicate 22
9483 OPC_Decode, 180, 129, 1, 124, // 16880: decode to VMSIF_M using decoder 124
9484 // 16880: }
9485 16, 6, // 16885: case 0x10: {
9486 OPC_CheckPredicate, 22, // 16887: check predicate 22
9487 OPC_Decode, 184, 127, 124, // 16889: decode to VIOTA_M using decoder 124
9488 // 16889: }
9489 17, 0, // 16893: case 0x11: {
9490 OPC_CheckPredicate, 22, // 16895: check predicate 22
9491 OPC_CheckField, 20, 5, 0, // 16897: check Inst[24:20] == 0x0
9492 OPC_Decode, 183, 127, 129, 1, // 16901: decode to VID_V using decoder 129
9493 // 16901: }
9494 // 16901: } // switch Inst[19:15]
9495 // 16901: }
9496 21, 6, // 16906: case 0x15: {
9497 OPC_CheckPredicate, 102, // 16908: check predicate 102
9498 OPC_Decode, 137, 126, 116, // 16910: decode to VABD_VV using decoder 116
9499 // 16910: }
9500 22, 6, // 16914: case 0x16: {
9501 OPC_CheckPredicate, 102, // 16916: check predicate 102
9502 OPC_Decode, 135, 126, 116, // 16918: decode to VABDU_VV using decoder 116
9503 // 16918: }
9504 23, 10, // 16922: case 0x17: {
9505 OPC_CheckPredicate, 22, // 16924: check predicate 22
9506 OPC_CheckField, 25, 1, 1, // 16926: check Inst[25] == 0x1
9507 OPC_Decode, 172, 126, 118, // 16930: decode to VCOMPRESS_VM using decoder 118
9508 // 16930: }
9509 24, 11, // 16934: case 0x18: {
9510 OPC_CheckPredicate, 22, // 16936: check predicate 22
9511 OPC_CheckField, 25, 1, 1, // 16938: check Inst[25] == 0x1
9512 OPC_Decode, 140, 129, 1, 118, // 16942: decode to VMANDN_MM using decoder 118
9513 // 16942: }
9514 25, 11, // 16947: case 0x19: {
9515 OPC_CheckPredicate, 22, // 16949: check predicate 22
9516 OPC_CheckField, 25, 1, 1, // 16951: check Inst[25] == 0x1
9517 OPC_Decode, 141, 129, 1, 118, // 16955: decode to VMAND_MM using decoder 118
9518 // 16955: }
9519 26, 11, // 16960: case 0x1a: {
9520 OPC_CheckPredicate, 22, // 16962: check predicate 22
9521 OPC_CheckField, 25, 1, 1, // 16964: check Inst[25] == 0x1
9522 OPC_Decode, 167, 129, 1, 118, // 16968: decode to VMOR_MM using decoder 118
9523 // 16968: }
9524 27, 11, // 16973: case 0x1b: {
9525 OPC_CheckPredicate, 22, // 16975: check predicate 22
9526 OPC_CheckField, 25, 1, 1, // 16977: check Inst[25] == 0x1
9527 OPC_Decode, 217, 129, 1, 118, // 16981: decode to VMXOR_MM using decoder 118
9528 // 16981: }
9529 28, 11, // 16986: case 0x1c: {
9530 OPC_CheckPredicate, 22, // 16988: check predicate 22
9531 OPC_CheckField, 25, 1, 1, // 16990: check Inst[25] == 0x1
9532 OPC_Decode, 166, 129, 1, 118, // 16994: decode to VMORN_MM using decoder 118
9533 // 16994: }
9534 29, 11, // 16999: case 0x1d: {
9535 OPC_CheckPredicate, 22, // 17001: check predicate 22
9536 OPC_CheckField, 25, 1, 1, // 17003: check Inst[25] == 0x1
9537 OPC_Decode, 164, 129, 1, 118, // 17007: decode to VMNAND_MM using decoder 118
9538 // 17007: }
9539 30, 11, // 17012: case 0x1e: {
9540 OPC_CheckPredicate, 22, // 17014: check predicate 22
9541 OPC_CheckField, 25, 1, 1, // 17016: check Inst[25] == 0x1
9542 OPC_Decode, 165, 129, 1, 118, // 17020: decode to VMNOR_MM using decoder 118
9543 // 17020: }
9544 31, 11, // 17025: case 0x1f: {
9545 OPC_CheckPredicate, 22, // 17027: check predicate 22
9546 OPC_CheckField, 25, 1, 1, // 17029: check Inst[25] == 0x1
9547 OPC_Decode, 216, 129, 1, 118, // 17033: decode to VMXNOR_MM using decoder 118
9548 // 17033: }
9549 32, 6, // 17038: case 0x20: {
9550 OPC_CheckPredicate, 22, // 17040: check predicate 22
9551 OPC_Decode, 176, 126, 116, // 17042: decode to VDIVU_VV using decoder 116
9552 // 17042: }
9553 33, 6, // 17046: case 0x21: {
9554 OPC_CheckPredicate, 22, // 17048: check predicate 22
9555 OPC_Decode, 178, 126, 116, // 17050: decode to VDIV_VV using decoder 116
9556 // 17050: }
9557 34, 7, // 17054: case 0x22: {
9558 OPC_CheckPredicate, 22, // 17056: check predicate 22
9559 OPC_Decode, 129, 130, 1, 116, // 17058: decode to VREMU_VV using decoder 116
9560 // 17058: }
9561 35, 7, // 17063: case 0x23: {
9562 OPC_CheckPredicate, 22, // 17065: check predicate 22
9563 OPC_Decode, 131, 130, 1, 116, // 17067: decode to VREM_VV using decoder 116
9564 // 17067: }
9565 36, 7, // 17072: case 0x24: {
9566 OPC_CheckPredicate, 22, // 17074: check predicate 22
9567 OPC_Decode, 201, 129, 1, 116, // 17076: decode to VMULHU_VV using decoder 116
9568 // 17076: }
9569 37, 7, // 17081: case 0x25: {
9570 OPC_CheckPredicate, 22, // 17083: check predicate 22
9571 OPC_Decode, 205, 129, 1, 116, // 17085: decode to VMUL_VV using decoder 116
9572 // 17085: }
9573 38, 7, // 17090: case 0x26: {
9574 OPC_CheckPredicate, 22, // 17092: check predicate 22
9575 OPC_Decode, 199, 129, 1, 116, // 17094: decode to VMULHSU_VV using decoder 116
9576 // 17094: }
9577 39, 7, // 17099: case 0x27: {
9578 OPC_CheckPredicate, 22, // 17101: check predicate 22
9579 OPC_Decode, 203, 129, 1, 116, // 17103: decode to VMULH_VV using decoder 116
9580 // 17103: }
9581 40, 6, // 17108: case 0x28: {
9582 OPC_CheckPredicate, 108, // 17110: check predicate 108
9583 OPC_Decode, 183, 126, 122, // 17112: decode to VDOT4AU_VV using decoder 122
9584 // 17112: }
9585 41, 7, // 17116: case 0x29: {
9586 OPC_CheckPredicate, 22, // 17118: check predicate 22
9587 OPC_Decode, 242, 128, 1, 125, // 17120: decode to VMADD_VV using decoder 125
9588 // 17120: }
9589 42, 6, // 17125: case 0x2a: {
9590 OPC_CheckPredicate, 108, // 17127: check predicate 108
9591 OPC_Decode, 180, 126, 122, // 17129: decode to VDOT4ASU_VV using decoder 122
9592 // 17129: }
9593 43, 7, // 17133: case 0x2b: {
9594 OPC_CheckPredicate, 22, // 17135: check predicate 22
9595 OPC_Decode, 226, 129, 1, 125, // 17137: decode to VNMSUB_VV using decoder 125
9596 // 17137: }
9597 44, 6, // 17142: case 0x2c: {
9598 OPC_CheckPredicate, 108, // 17144: check predicate 108
9599 OPC_Decode, 185, 126, 122, // 17146: decode to VDOT4A_VV using decoder 122
9600 // 17146: }
9601 45, 7, // 17150: case 0x2d: {
9602 OPC_CheckPredicate, 22, // 17152: check predicate 22
9603 OPC_Decode, 234, 128, 1, 125, // 17154: decode to VMACC_VV using decoder 125
9604 // 17154: }
9605 47, 7, // 17159: case 0x2f: {
9606 OPC_CheckPredicate, 22, // 17161: check predicate 22
9607 OPC_Decode, 224, 129, 1, 125, // 17163: decode to VNMSAC_VV using decoder 125
9608 // 17163: }
9609 48, 7, // 17168: case 0x30: {
9610 OPC_CheckPredicate, 22, // 17170: check predicate 22
9611 OPC_Decode, 208, 131, 1, 116, // 17172: decode to VWADDU_VV using decoder 116
9612 // 17172: }
9613 49, 7, // 17177: case 0x31: {
9614 OPC_CheckPredicate, 22, // 17179: check predicate 22
9615 OPC_Decode, 212, 131, 1, 116, // 17181: decode to VWADD_VV using decoder 116
9616 // 17181: }
9617 50, 7, // 17186: case 0x32: {
9618 OPC_CheckPredicate, 22, // 17188: check predicate 22
9619 OPC_Decode, 235, 131, 1, 116, // 17190: decode to VWSUBU_VV using decoder 116
9620 // 17190: }
9621 51, 7, // 17195: case 0x33: {
9622 OPC_CheckPredicate, 22, // 17197: check predicate 22
9623 OPC_Decode, 239, 131, 1, 116, // 17199: decode to VWSUB_VV using decoder 116
9624 // 17199: }
9625 52, 7, // 17204: case 0x34: {
9626 OPC_CheckPredicate, 22, // 17206: check predicate 22
9627 OPC_Decode, 210, 131, 1, 116, // 17208: decode to VWADDU_WV using decoder 116
9628 // 17208: }
9629 53, 7, // 17213: case 0x35: {
9630 OPC_CheckPredicate, 22, // 17215: check predicate 22
9631 OPC_Decode, 214, 131, 1, 116, // 17217: decode to VWADD_WV using decoder 116
9632 // 17217: }
9633 54, 7, // 17222: case 0x36: {
9634 OPC_CheckPredicate, 22, // 17224: check predicate 22
9635 OPC_Decode, 237, 131, 1, 116, // 17226: decode to VWSUBU_WV using decoder 116
9636 // 17226: }
9637 55, 7, // 17231: case 0x37: {
9638 OPC_CheckPredicate, 22, // 17233: check predicate 22
9639 OPC_Decode, 241, 131, 1, 116, // 17235: decode to VWSUB_WV using decoder 116
9640 // 17235: }
9641 56, 7, // 17240: case 0x38: {
9642 OPC_CheckPredicate, 22, // 17242: check predicate 22
9643 OPC_Decode, 226, 131, 1, 116, // 17244: decode to VWMULU_VV using decoder 116
9644 // 17244: }
9645 58, 7, // 17249: case 0x3a: {
9646 OPC_CheckPredicate, 22, // 17251: check predicate 22
9647 OPC_Decode, 224, 131, 1, 116, // 17253: decode to VWMULSU_VV using decoder 116
9648 // 17253: }
9649 59, 7, // 17258: case 0x3b: {
9650 OPC_CheckPredicate, 22, // 17260: check predicate 22
9651 OPC_Decode, 228, 131, 1, 116, // 17262: decode to VWMUL_VV using decoder 116
9652 // 17262: }
9653 60, 7, // 17267: case 0x3c: {
9654 OPC_CheckPredicate, 22, // 17269: check predicate 22
9655 OPC_Decode, 219, 131, 1, 125, // 17271: decode to VWMACCU_VV using decoder 125
9656 // 17271: }
9657 61, 7, // 17276: case 0x3d: {
9658 OPC_CheckPredicate, 22, // 17278: check predicate 22
9659 OPC_Decode, 221, 131, 1, 125, // 17280: decode to VWMACC_VV using decoder 125
9660 // 17280: }
9661 62, 7, // 17285: case 0x3e: {
9662 OPC_CheckPredicate, 98, // 17287: check predicate 98
9663 OPC_Decode, 249, 131, 1, 116, // 17289: decode to VZIP_VV using decoder 116
9664 // 17289: }
9665 63, 0, // 17294: case 0x3f: {
9666 OPC_CheckPredicate, 22, // 17296: check predicate 22
9667 OPC_Decode, 216, 131, 1, 125, // 17298: decode to VWMACCSU_VV using decoder 125
9668 // 17298: }
9669 // 17298: } // switch Inst[31:26]
9670 // 17298: }
9671 3, 213, 3, // 17303: case 0x3: {
9672 OPC_SwitchField, 27, 5, // 17306: switch Inst[31:27] {
9673 0, 11, // 17309: case 0x0: {
9674 OPC_CheckPredicate, 22, // 17311: check predicate 22
9675 OPC_CheckField, 26, 1, 0, // 17313: check Inst[26] == 0x0
9676 OPC_Decode, 142, 126, 130, 1, // 17317: decode to VADD_VI using decoder 130
9677 // 17317: }
9678 1, 12, // 17322: case 0x1: {
9679 OPC_CheckPredicate, 22, // 17324: check predicate 22
9680 OPC_CheckField, 26, 1, 1, // 17326: check Inst[26] == 0x1
9681 OPC_Decode, 143, 130, 1, 130, 1, // 17330: decode to VRSUB_VI using decoder 130
9682 // 17330: }
9683 4, 11, // 17336: case 0x4: {
9684 OPC_CheckPredicate, 22, // 17338: check predicate 22
9685 OPC_CheckField, 26, 1, 1, // 17340: check Inst[26] == 0x1
9686 OPC_Decode, 158, 126, 130, 1, // 17344: decode to VAND_VI using decoder 130
9687 // 17344: }
9688 5, 23, // 17349: case 0x5: {
9689 OPC_SwitchField, 26, 1, // 17351: switch Inst[26] {
9690 0, 8, // 17354: case 0x0: {
9691 OPC_CheckPredicate, 22, // 17356: check predicate 22
9692 OPC_Decode, 238, 129, 1, 130, 1, // 17358: decode to VOR_VI using decoder 130
9693 // 17358: }
9694 1, 0, // 17364: case 0x1: {
9695 OPC_CheckPredicate, 22, // 17366: check predicate 22
9696 OPC_Decode, 243, 131, 1, 130, 1, // 17368: decode to VXOR_VI using decoder 130
9697 // 17368: }
9698 // 17368: } // switch Inst[26]
9699 // 17368: }
9700 6, 12, // 17374: case 0x6: {
9701 OPC_CheckPredicate, 22, // 17376: check predicate 22
9702 OPC_CheckField, 26, 1, 0, // 17378: check Inst[26] == 0x0
9703 OPC_Decode, 135, 130, 1, 131, 1, // 17382: decode to VRGATHER_VI using decoder 131
9704 // 17382: }
9705 7, 23, // 17388: case 0x7: {
9706 OPC_SwitchField, 26, 1, // 17390: switch Inst[26] {
9707 0, 8, // 17393: case 0x0: {
9708 OPC_CheckPredicate, 22, // 17395: check predicate 22
9709 OPC_Decode, 174, 130, 1, 131, 1, // 17397: decode to VSLIDEUP_VI using decoder 131
9710 // 17397: }
9711 1, 0, // 17403: case 0x1: {
9712 OPC_CheckPredicate, 22, // 17405: check predicate 22
9713 OPC_Decode, 172, 130, 1, 131, 1, // 17407: decode to VSLIDEDOWN_VI using decoder 131
9714 // 17407: }
9715 // 17407: } // switch Inst[26]
9716 // 17407: }
9717 8, 32, // 17413: case 0x8: {
9718 OPC_SwitchField, 25, 2, // 17415: switch Inst[26:25] {
9719 0, 7, // 17418: case 0x0: {
9720 OPC_CheckPredicate, 22, // 17420: check predicate 22
9721 OPC_Decode, 139, 126, 132, 1, // 17422: decode to VADC_VIM using decoder 132
9722 // 17422: }
9723 2, 8, // 17427: case 0x2: {
9724 OPC_CheckPredicate, 22, // 17429: check predicate 22
9725 OPC_Decode, 237, 128, 1, 132, 1, // 17431: decode to VMADC_VIM using decoder 132
9726 // 17431: }
9727 3, 0, // 17437: case 0x3: {
9728 OPC_CheckPredicate, 22, // 17439: check predicate 22
9729 OPC_Decode, 236, 128, 1, 133, 1, // 17441: decode to VMADC_VI using decoder 133
9730 // 17441: }
9731 // 17441: } // switch Inst[26:25]
9732 // 17441: }
9733 10, 8, // 17447: case 0xa: {
9734 OPC_CheckPredicate, 97, // 17449: check predicate 97
9735 OPC_Decode, 140, 130, 1, 134, 1, // 17451: decode to VROR_VI using decoder 134
9736 // 17451: }
9737 11, 27, // 17457: case 0xb: {
9738 OPC_SwitchField, 25, 2, // 17459: switch Inst[26:25] {
9739 2, 8, // 17462: case 0x2: {
9740 OPC_CheckPredicate, 22, // 17464: check predicate 22
9741 OPC_Decode, 146, 129, 1, 132, 1, // 17466: decode to VMERGE_VIM using decoder 132
9742 // 17466: }
9743 3, 0, // 17472: case 0x3: {
9744 OPC_CheckPredicate, 22, // 17474: check predicate 22
9745 OPC_CheckField, 20, 5, 0, // 17476: check Inst[24:20] == 0x0
9746 OPC_Decode, 212, 129, 1, 135, 1, // 17480: decode to VMV_V_I using decoder 135
9747 // 17480: }
9748 // 17480: } // switch Inst[26:25]
9749 // 17480: }
9750 12, 23, // 17486: case 0xc: {
9751 OPC_SwitchField, 26, 1, // 17488: switch Inst[26] {
9752 0, 8, // 17491: case 0x0: {
9753 OPC_CheckPredicate, 22, // 17493: check predicate 22
9754 OPC_Decode, 173, 129, 1, 130, 1, // 17495: decode to VMSEQ_VI using decoder 130
9755 // 17495: }
9756 1, 0, // 17501: case 0x1: {
9757 OPC_CheckPredicate, 22, // 17503: check predicate 22
9758 OPC_Decode, 191, 129, 1, 130, 1, // 17505: decode to VMSNE_VI using decoder 130
9759 // 17505: }
9760 // 17505: } // switch Inst[26]
9761 // 17505: }
9762 14, 23, // 17511: case 0xe: {
9763 OPC_SwitchField, 26, 1, // 17513: switch Inst[26] {
9764 0, 8, // 17516: case 0x0: {
9765 OPC_CheckPredicate, 22, // 17518: check predicate 22
9766 OPC_Decode, 181, 129, 1, 130, 1, // 17520: decode to VMSLEU_VI using decoder 130
9767 // 17520: }
9768 1, 0, // 17526: case 0x1: {
9769 OPC_CheckPredicate, 22, // 17528: check predicate 22
9770 OPC_Decode, 184, 129, 1, 130, 1, // 17530: decode to VMSLE_VI using decoder 130
9771 // 17530: }
9772 // 17530: } // switch Inst[26]
9773 // 17530: }
9774 15, 23, // 17536: case 0xf: {
9775 OPC_SwitchField, 26, 1, // 17538: switch Inst[26] {
9776 0, 8, // 17541: case 0x0: {
9777 OPC_CheckPredicate, 22, // 17543: check predicate 22
9778 OPC_Decode, 176, 129, 1, 130, 1, // 17545: decode to VMSGTU_VI using decoder 130
9779 // 17545: }
9780 1, 0, // 17551: case 0x1: {
9781 OPC_CheckPredicate, 22, // 17553: check predicate 22
9782 OPC_Decode, 178, 129, 1, 130, 1, // 17555: decode to VMSGT_VI using decoder 130
9783 // 17555: }
9784 // 17555: } // switch Inst[26]
9785 // 17555: }
9786 16, 23, // 17561: case 0x10: {
9787 OPC_SwitchField, 26, 1, // 17563: switch Inst[26] {
9788 0, 8, // 17566: case 0x0: {
9789 OPC_CheckPredicate, 22, // 17568: check predicate 22
9790 OPC_Decode, 149, 130, 1, 130, 1, // 17570: decode to VSADDU_VI using decoder 130
9791 // 17570: }
9792 1, 0, // 17576: case 0x1: {
9793 OPC_CheckPredicate, 22, // 17578: check predicate 22
9794 OPC_Decode, 152, 130, 1, 130, 1, // 17580: decode to VSADD_VI using decoder 130
9795 // 17580: }
9796 // 17580: } // switch Inst[26]
9797 // 17580: }
9798 18, 12, // 17586: case 0x12: {
9799 OPC_CheckPredicate, 22, // 17588: check predicate 22
9800 OPC_CheckField, 26, 1, 1, // 17590: check Inst[26] == 0x1
9801 OPC_Decode, 176, 130, 1, 131, 1, // 17594: decode to VSLL_VI using decoder 131
9802 // 17594: }
9803 19, 59, // 17600: case 0x13: {
9804 OPC_SwitchField, 15, 5, // 17602: switch Inst[19:15] {
9805 0, 12, // 17605: case 0x0: {
9806 OPC_CheckPredicate, 22, // 17607: check predicate 22
9807 OPC_CheckField, 25, 2, 3, // 17609: check Inst[26:25] == 0x3
9808 OPC_Decode, 207, 129, 1, 128, 1, // 17613: decode to VMV1R_V using decoder 128
9809 // 17613: }
9810 1, 12, // 17619: case 0x1: {
9811 OPC_CheckPredicate, 22, // 17621: check predicate 22
9812 OPC_CheckField, 25, 2, 3, // 17623: check Inst[26:25] == 0x3
9813 OPC_Decode, 208, 129, 1, 136, 1, // 17627: decode to VMV2R_V using decoder 136
9814 // 17627: }
9815 3, 12, // 17633: case 0x3: {
9816 OPC_CheckPredicate, 22, // 17635: check predicate 22
9817 OPC_CheckField, 25, 2, 3, // 17637: check Inst[26:25] == 0x3
9818 OPC_Decode, 209, 129, 1, 137, 1, // 17641: decode to VMV4R_V using decoder 137
9819 // 17641: }
9820 7, 0, // 17647: case 0x7: {
9821 OPC_CheckPredicate, 22, // 17649: check predicate 22
9822 OPC_CheckField, 25, 2, 3, // 17651: check Inst[26:25] == 0x3
9823 OPC_Decode, 210, 129, 1, 138, 1, // 17655: decode to VMV8R_V using decoder 138
9824 // 17655: }
9825 // 17655: } // switch Inst[19:15]
9826 // 17655: }
9827 20, 23, // 17661: case 0x14: {
9828 OPC_SwitchField, 26, 1, // 17663: switch Inst[26] {
9829 0, 8, // 17666: case 0x0: {
9830 OPC_CheckPredicate, 22, // 17668: check predicate 22
9831 OPC_Decode, 222, 130, 1, 131, 1, // 17670: decode to VSRL_VI using decoder 131
9832 // 17670: }
9833 1, 0, // 17676: case 0x1: {
9834 OPC_CheckPredicate, 22, // 17678: check predicate 22
9835 OPC_Decode, 219, 130, 1, 131, 1, // 17680: decode to VSRA_VI using decoder 131
9836 // 17680: }
9837 // 17680: } // switch Inst[26]
9838 // 17680: }
9839 21, 23, // 17686: case 0x15: {
9840 OPC_SwitchField, 26, 1, // 17688: switch Inst[26] {
9841 0, 8, // 17691: case 0x0: {
9842 OPC_CheckPredicate, 22, // 17693: check predicate 22
9843 OPC_Decode, 132, 131, 1, 131, 1, // 17695: decode to VSSRL_VI using decoder 131
9844 // 17695: }
9845 1, 0, // 17701: case 0x1: {
9846 OPC_CheckPredicate, 22, // 17703: check predicate 22
9847 OPC_Decode, 129, 131, 1, 131, 1, // 17705: decode to VSSRA_VI using decoder 131
9848 // 17705: }
9849 // 17705: } // switch Inst[26]
9850 // 17705: }
9851 22, 23, // 17711: case 0x16: {
9852 OPC_SwitchField, 26, 1, // 17713: switch Inst[26] {
9853 0, 8, // 17716: case 0x0: {
9854 OPC_CheckPredicate, 22, // 17718: check predicate 22
9855 OPC_Decode, 235, 129, 1, 131, 1, // 17720: decode to VNSRL_WI using decoder 131
9856 // 17720: }
9857 1, 0, // 17726: case 0x1: {
9858 OPC_CheckPredicate, 22, // 17728: check predicate 22
9859 OPC_Decode, 232, 129, 1, 131, 1, // 17730: decode to VNSRA_WI using decoder 131
9860 // 17730: }
9861 // 17730: } // switch Inst[26]
9862 // 17730: }
9863 23, 23, // 17736: case 0x17: {
9864 OPC_SwitchField, 26, 1, // 17738: switch Inst[26] {
9865 0, 8, // 17741: case 0x0: {
9866 OPC_CheckPredicate, 22, // 17743: check predicate 22
9867 OPC_Decode, 218, 129, 1, 131, 1, // 17745: decode to VNCLIPU_WI using decoder 131
9868 // 17745: }
9869 1, 0, // 17751: case 0x1: {
9870 OPC_CheckPredicate, 22, // 17753: check predicate 22
9871 OPC_Decode, 221, 129, 1, 131, 1, // 17755: decode to VNCLIP_WI using decoder 131
9872 // 17755: }
9873 // 17755: } // switch Inst[26]
9874 // 17755: }
9875 26, 0, // 17761: case 0x1a: {
9876 OPC_CheckPredicate, 99, // 17763: check predicate 99
9877 OPC_CheckField, 26, 1, 1, // 17765: check Inst[26] == 0x1
9878 OPC_Decode, 232, 131, 1, 131, 1, // 17769: decode to VWSLL_VI using decoder 131
9879 // 17769: }
9880 // 17769: } // switch Inst[31:27]
9881 // 17769: }
9882 4, 131, 4, // 17775: case 0x4: {
9883 OPC_SwitchField, 26, 6, // 17778: switch Inst[31:26] {
9884 0, 7, // 17781: case 0x0: {
9885 OPC_CheckPredicate, 22, // 17783: check predicate 22
9886 OPC_Decode, 144, 126, 139, 1, // 17785: decode to VADD_VX using decoder 139
9887 // 17785: }
9888 1, 7, // 17790: case 0x1: {
9889 OPC_CheckPredicate, 97, // 17792: check predicate 97
9890 OPC_Decode, 157, 126, 139, 1, // 17794: decode to VANDN_VX using decoder 139
9891 // 17794: }
9892 2, 8, // 17799: case 0x2: {
9893 OPC_CheckPredicate, 22, // 17801: check predicate 22
9894 OPC_Decode, 168, 131, 1, 139, 1, // 17803: decode to VSUB_VX using decoder 139
9895 // 17803: }
9896 3, 8, // 17809: case 0x3: {
9897 OPC_CheckPredicate, 22, // 17811: check predicate 22
9898 OPC_Decode, 144, 130, 1, 139, 1, // 17813: decode to VRSUB_VX using decoder 139
9899 // 17813: }
9900 4, 8, // 17819: case 0x4: {
9901 OPC_CheckPredicate, 22, // 17821: check predicate 22
9902 OPC_Decode, 160, 129, 1, 139, 1, // 17823: decode to VMINU_VX using decoder 139
9903 // 17823: }
9904 5, 8, // 17829: case 0x5: {
9905 OPC_CheckPredicate, 22, // 17831: check predicate 22
9906 OPC_Decode, 162, 129, 1, 139, 1, // 17833: decode to VMIN_VX using decoder 139
9907 // 17833: }
9908 6, 8, // 17839: case 0x6: {
9909 OPC_CheckPredicate, 22, // 17841: check predicate 22
9910 OPC_Decode, 143, 129, 1, 139, 1, // 17843: decode to VMAXU_VX using decoder 139
9911 // 17843: }
9912 7, 8, // 17849: case 0x7: {
9913 OPC_CheckPredicate, 22, // 17851: check predicate 22
9914 OPC_Decode, 145, 129, 1, 139, 1, // 17853: decode to VMAX_VX using decoder 139
9915 // 17853: }
9916 9, 7, // 17859: case 0x9: {
9917 OPC_CheckPredicate, 22, // 17861: check predicate 22
9918 OPC_Decode, 160, 126, 139, 1, // 17863: decode to VAND_VX using decoder 139
9919 // 17863: }
9920 10, 8, // 17868: case 0xa: {
9921 OPC_CheckPredicate, 22, // 17870: check predicate 22
9922 OPC_Decode, 240, 129, 1, 139, 1, // 17872: decode to VOR_VX using decoder 139
9923 // 17872: }
9924 11, 8, // 17878: case 0xb: {
9925 OPC_CheckPredicate, 22, // 17880: check predicate 22
9926 OPC_Decode, 245, 131, 1, 139, 1, // 17882: decode to VXOR_VX using decoder 139
9927 // 17882: }
9928 12, 8, // 17888: case 0xc: {
9929 OPC_CheckPredicate, 22, // 17890: check predicate 22
9930 OPC_Decode, 137, 130, 1, 139, 1, // 17892: decode to VRGATHER_VX using decoder 139
9931 // 17892: }
9932 14, 8, // 17898: case 0xe: {
9933 OPC_CheckPredicate, 22, // 17900: check predicate 22
9934 OPC_Decode, 175, 130, 1, 139, 1, // 17902: decode to VSLIDEUP_VX using decoder 139
9935 // 17902: }
9936 15, 8, // 17908: case 0xf: {
9937 OPC_CheckPredicate, 22, // 17910: check predicate 22
9938 OPC_Decode, 173, 130, 1, 139, 1, // 17912: decode to VSLIDEDOWN_VX using decoder 139
9939 // 17912: }
9940 16, 11, // 17918: case 0x10: {
9941 OPC_CheckPredicate, 22, // 17920: check predicate 22
9942 OPC_CheckField, 25, 1, 0, // 17922: check Inst[25] == 0x0
9943 OPC_Decode, 141, 126, 140, 1, // 17926: decode to VADC_VXM using decoder 140
9944 // 17926: }
9945 17, 23, // 17931: case 0x11: {
9946 OPC_SwitchField, 25, 1, // 17933: switch Inst[25] {
9947 0, 8, // 17936: case 0x0: {
9948 OPC_CheckPredicate, 22, // 17938: check predicate 22
9949 OPC_Decode, 241, 128, 1, 140, 1, // 17940: decode to VMADC_VXM using decoder 140
9950 // 17940: }
9951 1, 0, // 17946: case 0x1: {
9952 OPC_CheckPredicate, 22, // 17948: check predicate 22
9953 OPC_Decode, 240, 128, 1, 141, 1, // 17950: decode to VMADC_VX using decoder 141
9954 // 17950: }
9955 // 17950: } // switch Inst[25]
9956 // 17950: }
9957 18, 12, // 17956: case 0x12: {
9958 OPC_CheckPredicate, 22, // 17958: check predicate 22
9959 OPC_CheckField, 25, 1, 0, // 17960: check Inst[25] == 0x0
9960 OPC_Decode, 156, 130, 1, 140, 1, // 17964: decode to VSBC_VXM using decoder 140
9961 // 17964: }
9962 19, 23, // 17970: case 0x13: {
9963 OPC_SwitchField, 25, 1, // 17972: switch Inst[25] {
9964 0, 8, // 17975: case 0x0: {
9965 OPC_CheckPredicate, 22, // 17977: check predicate 22
9966 OPC_Decode, 171, 129, 1, 140, 1, // 17979: decode to VMSBC_VXM using decoder 140
9967 // 17979: }
9968 1, 0, // 17985: case 0x1: {
9969 OPC_CheckPredicate, 22, // 17987: check predicate 22
9970 OPC_Decode, 170, 129, 1, 141, 1, // 17989: decode to VMSBC_VX using decoder 141
9971 // 17989: }
9972 // 17989: } // switch Inst[25]
9973 // 17989: }
9974 20, 8, // 17995: case 0x14: {
9975 OPC_CheckPredicate, 97, // 17997: check predicate 97
9976 OPC_Decode, 142, 130, 1, 139, 1, // 17999: decode to VROR_VX using decoder 139
9977 // 17999: }
9978 21, 8, // 18005: case 0x15: {
9979 OPC_CheckPredicate, 97, // 18007: check predicate 97
9980 OPC_Decode, 139, 130, 1, 139, 1, // 18009: decode to VROL_VX using decoder 139
9981 // 18009: }
9982 23, 26, // 18015: case 0x17: {
9983 OPC_SwitchField, 25, 1, // 18017: switch Inst[25] {
9984 0, 8, // 18020: case 0x0: {
9985 OPC_CheckPredicate, 22, // 18022: check predicate 22
9986 OPC_Decode, 148, 129, 1, 140, 1, // 18024: decode to VMERGE_VXM using decoder 140
9987 // 18024: }
9988 1, 0, // 18030: case 0x1: {
9989 OPC_CheckPredicate, 22, // 18032: check predicate 22
9990 OPC_CheckField, 20, 5, 0, // 18034: check Inst[24:20] == 0x0
9991 OPC_Decode, 214, 129, 1, 2, // 18038: decode to VMV_V_X using decoder 2
9992 // 18038: }
9993 // 18038: } // switch Inst[25]
9994 // 18038: }
9995 24, 8, // 18043: case 0x18: {
9996 OPC_CheckPredicate, 22, // 18045: check predicate 22
9997 OPC_Decode, 175, 129, 1, 139, 1, // 18047: decode to VMSEQ_VX using decoder 139
9998 // 18047: }
9999 25, 8, // 18053: case 0x19: {
10000 OPC_CheckPredicate, 22, // 18055: check predicate 22
10001 OPC_Decode, 193, 129, 1, 139, 1, // 18057: decode to VMSNE_VX using decoder 139
10002 // 18057: }
10003 26, 8, // 18063: case 0x1a: {
10004 OPC_CheckPredicate, 22, // 18065: check predicate 22
10005 OPC_Decode, 188, 129, 1, 139, 1, // 18067: decode to VMSLTU_VX using decoder 139
10006 // 18067: }
10007 27, 8, // 18073: case 0x1b: {
10008 OPC_CheckPredicate, 22, // 18075: check predicate 22
10009 OPC_Decode, 190, 129, 1, 139, 1, // 18077: decode to VMSLT_VX using decoder 139
10010 // 18077: }
10011 28, 8, // 18083: case 0x1c: {
10012 OPC_CheckPredicate, 22, // 18085: check predicate 22
10013 OPC_Decode, 183, 129, 1, 139, 1, // 18087: decode to VMSLEU_VX using decoder 139
10014 // 18087: }
10015 29, 8, // 18093: case 0x1d: {
10016 OPC_CheckPredicate, 22, // 18095: check predicate 22
10017 OPC_Decode, 186, 129, 1, 139, 1, // 18097: decode to VMSLE_VX using decoder 139
10018 // 18097: }
10019 30, 8, // 18103: case 0x1e: {
10020 OPC_CheckPredicate, 22, // 18105: check predicate 22
10021 OPC_Decode, 177, 129, 1, 139, 1, // 18107: decode to VMSGTU_VX using decoder 139
10022 // 18107: }
10023 31, 8, // 18113: case 0x1f: {
10024 OPC_CheckPredicate, 22, // 18115: check predicate 22
10025 OPC_Decode, 179, 129, 1, 139, 1, // 18117: decode to VMSGT_VX using decoder 139
10026 // 18117: }
10027 32, 8, // 18123: case 0x20: {
10028 OPC_CheckPredicate, 22, // 18125: check predicate 22
10029 OPC_Decode, 151, 130, 1, 139, 1, // 18127: decode to VSADDU_VX using decoder 139
10030 // 18127: }
10031 33, 8, // 18133: case 0x21: {
10032 OPC_CheckPredicate, 22, // 18135: check predicate 22
10033 OPC_Decode, 154, 130, 1, 139, 1, // 18137: decode to VSADD_VX using decoder 139
10034 // 18137: }
10035 34, 8, // 18143: case 0x22: {
10036 OPC_CheckPredicate, 22, // 18145: check predicate 22
10037 OPC_Decode, 164, 131, 1, 139, 1, // 18147: decode to VSSUBU_VX using decoder 139
10038 // 18147: }
10039 35, 8, // 18153: case 0x23: {
10040 OPC_CheckPredicate, 22, // 18155: check predicate 22
10041 OPC_Decode, 166, 131, 1, 139, 1, // 18157: decode to VSSUB_VX using decoder 139
10042 // 18157: }
10043 37, 8, // 18163: case 0x25: {
10044 OPC_CheckPredicate, 22, // 18165: check predicate 22
10045 OPC_Decode, 178, 130, 1, 139, 1, // 18167: decode to VSLL_VX using decoder 139
10046 // 18167: }
10047 39, 8, // 18173: case 0x27: {
10048 OPC_CheckPredicate, 22, // 18175: check predicate 22
10049 OPC_Decode, 185, 130, 1, 139, 1, // 18177: decode to VSMUL_VX using decoder 139
10050 // 18177: }
10051 40, 8, // 18183: case 0x28: {
10052 OPC_CheckPredicate, 22, // 18185: check predicate 22
10053 OPC_Decode, 224, 130, 1, 139, 1, // 18187: decode to VSRL_VX using decoder 139
10054 // 18187: }
10055 41, 8, // 18193: case 0x29: {
10056 OPC_CheckPredicate, 22, // 18195: check predicate 22
10057 OPC_Decode, 221, 130, 1, 139, 1, // 18197: decode to VSRA_VX using decoder 139
10058 // 18197: }
10059 42, 8, // 18203: case 0x2a: {
10060 OPC_CheckPredicate, 22, // 18205: check predicate 22
10061 OPC_Decode, 134, 131, 1, 139, 1, // 18207: decode to VSSRL_VX using decoder 139
10062 // 18207: }
10063 43, 8, // 18213: case 0x2b: {
10064 OPC_CheckPredicate, 22, // 18215: check predicate 22
10065 OPC_Decode, 131, 131, 1, 139, 1, // 18217: decode to VSSRA_VX using decoder 139
10066 // 18217: }
10067 44, 8, // 18223: case 0x2c: {
10068 OPC_CheckPredicate, 22, // 18225: check predicate 22
10069 OPC_Decode, 237, 129, 1, 139, 1, // 18227: decode to VNSRL_WX using decoder 139
10070 // 18227: }
10071 45, 8, // 18233: case 0x2d: {
10072 OPC_CheckPredicate, 22, // 18235: check predicate 22
10073 OPC_Decode, 234, 129, 1, 139, 1, // 18237: decode to VNSRA_WX using decoder 139
10074 // 18237: }
10075 46, 8, // 18243: case 0x2e: {
10076 OPC_CheckPredicate, 22, // 18245: check predicate 22
10077 OPC_Decode, 220, 129, 1, 139, 1, // 18247: decode to VNCLIPU_WX using decoder 139
10078 // 18247: }
10079 47, 8, // 18253: case 0x2f: {
10080 OPC_CheckPredicate, 22, // 18255: check predicate 22
10081 OPC_Decode, 223, 129, 1, 139, 1, // 18257: decode to VNCLIP_WX using decoder 139
10082 // 18257: }
10083 53, 8, // 18263: case 0x35: {
10084 OPC_CheckPredicate, 99, // 18265: check predicate 99
10085 OPC_Decode, 234, 131, 1, 139, 1, // 18267: decode to VWSLL_VX using decoder 139
10086 // 18267: }
10087 61, 8, // 18273: case 0x3d: {
10088 OPC_CheckPredicate, 102, // 18275: check predicate 102
10089 OPC_Decode, 207, 131, 1, 142, 1, // 18277: decode to VWABDA_VX using decoder 142
10090 // 18277: }
10091 62, 0, // 18283: case 0x3e: {
10092 OPC_CheckPredicate, 102, // 18285: check predicate 102
10093 OPC_Decode, 205, 131, 1, 142, 1, // 18287: decode to VWABDAU_VX using decoder 142
10094 // 18287: }
10095 // 18287: } // switch Inst[31:26]
10096 // 18287: }
10097 5, 254, 2, // 18293: case 0x5: {
10098 OPC_SwitchField, 26, 6, // 18296: switch Inst[31:26] {
10099 0, 7, // 18299: case 0x0: {
10100 OPC_CheckPredicate, 103, // 18301: check predicate 103
10101 OPC_Decode, 190, 126, 143, 1, // 18303: decode to VFADD_VF using decoder 143
10102 // 18303: }
10103 2, 7, // 18308: case 0x2: {
10104 OPC_CheckPredicate, 103, // 18310: check predicate 103
10105 OPC_Decode, 138, 127, 143, 1, // 18312: decode to VFSUB_VF using decoder 143
10106 // 18312: }
10107 4, 7, // 18317: case 0x4: {
10108 OPC_CheckPredicate, 103, // 18319: check predicate 103
10109 OPC_Decode, 210, 126, 143, 1, // 18321: decode to VFMIN_VF using decoder 143
10110 // 18321: }
10111 6, 7, // 18326: case 0x6: {
10112 OPC_CheckPredicate, 103, // 18328: check predicate 103
10113 OPC_Decode, 207, 126, 143, 1, // 18330: decode to VFMAX_VF using decoder 143
10114 // 18330: }
10115 8, 7, // 18335: case 0x8: {
10116 OPC_CheckPredicate, 103, // 18337: check predicate 103
10117 OPC_Decode, 133, 127, 143, 1, // 18339: decode to VFSGNJ_VF using decoder 143
10118 // 18339: }
10119 9, 7, // 18344: case 0x9: {
10120 OPC_CheckPredicate, 103, // 18346: check predicate 103
10121 OPC_Decode, 129, 127, 143, 1, // 18348: decode to VFSGNJN_VF using decoder 143
10122 // 18348: }
10123 10, 7, // 18353: case 0xa: {
10124 OPC_CheckPredicate, 103, // 18355: check predicate 103
10125 OPC_Decode, 131, 127, 143, 1, // 18357: decode to VFSGNJX_VF using decoder 143
10126 // 18357: }
10127 14, 7, // 18362: case 0xe: {
10128 OPC_CheckPredicate, 103, // 18364: check predicate 103
10129 OPC_Decode, 136, 127, 143, 1, // 18366: decode to VFSLIDE1UP_VF using decoder 143
10130 // 18366: }
10131 15, 7, // 18371: case 0xf: {
10132 OPC_CheckPredicate, 103, // 18373: check predicate 103
10133 OPC_Decode, 135, 127, 143, 1, // 18375: decode to VFSLIDE1DOWN_VF using decoder 143
10134 // 18375: }
10135 16, 11, // 18380: case 0x10: {
10136 OPC_CheckPredicate, 103, // 18382: check predicate 103
10137 OPC_CheckField, 20, 6, 32, // 18384: check Inst[25:20] == 0x20
10138 OPC_Decode, 220, 126, 144, 1, // 18388: decode to VFMV_S_F using decoder 144
10139 // 18388: }
10140 23, 25, // 18393: case 0x17: {
10141 OPC_SwitchField, 25, 1, // 18395: switch Inst[25] {
10142 0, 7, // 18398: case 0x0: {
10143 OPC_CheckPredicate, 103, // 18400: check predicate 103
10144 OPC_Decode, 209, 126, 145, 1, // 18402: decode to VFMERGE_VFM using decoder 145
10145 // 18402: }
10146 1, 0, // 18407: case 0x1: {
10147 OPC_CheckPredicate, 103, // 18409: check predicate 103
10148 OPC_CheckField, 20, 5, 0, // 18411: check Inst[24:20] == 0x0
10149 OPC_Decode, 221, 126, 146, 1, // 18415: decode to VFMV_V_F using decoder 146
10150 // 18415: }
10151 // 18415: } // switch Inst[25]
10152 // 18415: }
10153 24, 8, // 18420: case 0x18: {
10154 OPC_CheckPredicate, 103, // 18422: check predicate 103
10155 OPC_Decode, 149, 129, 1, 143, 1, // 18424: decode to VMFEQ_VF using decoder 143
10156 // 18424: }
10157 25, 8, // 18430: case 0x19: {
10158 OPC_CheckPredicate, 103, // 18432: check predicate 103
10159 OPC_Decode, 153, 129, 1, 143, 1, // 18434: decode to VMFLE_VF using decoder 143
10160 // 18434: }
10161 27, 8, // 18440: case 0x1b: {
10162 OPC_CheckPredicate, 103, // 18442: check predicate 103
10163 OPC_Decode, 155, 129, 1, 143, 1, // 18444: decode to VMFLT_VF using decoder 143
10164 // 18444: }
10165 28, 8, // 18450: case 0x1c: {
10166 OPC_CheckPredicate, 103, // 18452: check predicate 103
10167 OPC_Decode, 157, 129, 1, 143, 1, // 18454: decode to VMFNE_VF using decoder 143
10168 // 18454: }
10169 29, 8, // 18460: case 0x1d: {
10170 OPC_CheckPredicate, 103, // 18462: check predicate 103
10171 OPC_Decode, 152, 129, 1, 143, 1, // 18464: decode to VMFGT_VF using decoder 143
10172 // 18464: }
10173 31, 8, // 18470: case 0x1f: {
10174 OPC_CheckPredicate, 103, // 18472: check predicate 103
10175 OPC_Decode, 151, 129, 1, 143, 1, // 18474: decode to VMFGE_VF using decoder 143
10176 // 18474: }
10177 32, 7, // 18480: case 0x20: {
10178 OPC_CheckPredicate, 103, // 18482: check predicate 103
10179 OPC_Decode, 200, 126, 143, 1, // 18484: decode to VFDIV_VF using decoder 143
10180 // 18484: }
10181 33, 7, // 18489: case 0x21: {
10182 OPC_CheckPredicate, 103, // 18491: check predicate 103
10183 OPC_Decode, 249, 126, 143, 1, // 18493: decode to VFRDIV_VF using decoder 143
10184 // 18493: }
10185 36, 7, // 18498: case 0x24: {
10186 OPC_CheckPredicate, 103, // 18500: check predicate 103
10187 OPC_Decode, 217, 126, 143, 1, // 18502: decode to VFMUL_VF using decoder 143
10188 // 18502: }
10189 39, 7, // 18507: case 0x27: {
10190 OPC_CheckPredicate, 103, // 18509: check predicate 103
10191 OPC_Decode, 128, 127, 143, 1, // 18511: decode to VFRSUB_VF using decoder 143
10192 // 18511: }
10193 40, 7, // 18516: case 0x28: {
10194 OPC_CheckPredicate, 103, // 18518: check predicate 103
10195 OPC_Decode, 205, 126, 147, 1, // 18520: decode to VFMADD_VF using decoder 147
10196 // 18520: }
10197 41, 7, // 18525: case 0x29: {
10198 OPC_CheckPredicate, 103, // 18527: check predicate 103
10199 OPC_Decode, 236, 126, 147, 1, // 18529: decode to VFNMADD_VF using decoder 147
10200 // 18529: }
10201 42, 7, // 18534: case 0x2a: {
10202 OPC_CheckPredicate, 103, // 18536: check predicate 103
10203 OPC_Decode, 215, 126, 147, 1, // 18538: decode to VFMSUB_VF using decoder 147
10204 // 18538: }
10205 43, 7, // 18543: case 0x2b: {
10206 OPC_CheckPredicate, 103, // 18545: check predicate 103
10207 OPC_Decode, 240, 126, 147, 1, // 18547: decode to VFNMSUB_VF using decoder 147
10208 // 18547: }
10209 44, 7, // 18552: case 0x2c: {
10210 OPC_CheckPredicate, 103, // 18554: check predicate 103
10211 OPC_Decode, 203, 126, 147, 1, // 18556: decode to VFMACC_VF using decoder 147
10212 // 18556: }
10213 45, 7, // 18561: case 0x2d: {
10214 OPC_CheckPredicate, 103, // 18563: check predicate 103
10215 OPC_Decode, 234, 126, 147, 1, // 18565: decode to VFNMACC_VF using decoder 147
10216 // 18565: }
10217 46, 7, // 18570: case 0x2e: {
10218 OPC_CheckPredicate, 103, // 18572: check predicate 103
10219 OPC_Decode, 213, 126, 147, 1, // 18574: decode to VFMSAC_VF using decoder 147
10220 // 18574: }
10221 47, 7, // 18579: case 0x2f: {
10222 OPC_CheckPredicate, 103, // 18581: check predicate 103
10223 OPC_Decode, 238, 126, 147, 1, // 18583: decode to VFNMSAC_VF using decoder 147
10224 // 18583: }
10225 48, 7, // 18588: case 0x30: {
10226 OPC_CheckPredicate, 103, // 18590: check predicate 103
10227 OPC_Decode, 140, 127, 143, 1, // 18592: decode to VFWADD_VF using decoder 143
10228 // 18592: }
10229 50, 7, // 18597: case 0x32: {
10230 OPC_CheckPredicate, 103, // 18599: check predicate 103
10231 OPC_Decode, 175, 127, 143, 1, // 18601: decode to VFWSUB_VF using decoder 143
10232 // 18601: }
10233 52, 7, // 18606: case 0x34: {
10234 OPC_CheckPredicate, 103, // 18608: check predicate 103
10235 OPC_Decode, 142, 127, 143, 1, // 18610: decode to VFWADD_WF using decoder 143
10236 // 18610: }
10237 54, 7, // 18615: case 0x36: {
10238 OPC_CheckPredicate, 103, // 18617: check predicate 103
10239 OPC_Decode, 177, 127, 143, 1, // 18619: decode to VFWSUB_WF using decoder 143
10240 // 18619: }
10241 56, 7, // 18624: case 0x38: {
10242 OPC_CheckPredicate, 103, // 18626: check predicate 103
10243 OPC_Decode, 167, 127, 143, 1, // 18628: decode to VFWMUL_VF using decoder 143
10244 // 18628: }
10245 59, 7, // 18633: case 0x3b: {
10246 OPC_CheckPredicate, 106, // 18635: check predicate 106
10247 OPC_Decode, 155, 127, 147, 1, // 18637: decode to VFWMACCBF16_VF using decoder 147
10248 // 18637: }
10249 60, 7, // 18642: case 0x3c: {
10250 OPC_CheckPredicate, 103, // 18644: check predicate 103
10251 OPC_Decode, 157, 127, 147, 1, // 18646: decode to VFWMACC_VF using decoder 147
10252 // 18646: }
10253 61, 7, // 18651: case 0x3d: {
10254 OPC_CheckPredicate, 103, // 18653: check predicate 103
10255 OPC_Decode, 169, 127, 147, 1, // 18655: decode to VFWNMACC_VF using decoder 147
10256 // 18655: }
10257 62, 7, // 18660: case 0x3e: {
10258 OPC_CheckPredicate, 103, // 18662: check predicate 103
10259 OPC_Decode, 165, 127, 147, 1, // 18664: decode to VFWMSAC_VF using decoder 147
10260 // 18664: }
10261 63, 0, // 18669: case 0x3f: {
10262 OPC_CheckPredicate, 103, // 18671: check predicate 103
10263 OPC_Decode, 171, 127, 147, 1, // 18673: decode to VFWNMSAC_VF using decoder 147
10264 // 18673: }
10265 // 18673: } // switch Inst[31:26]
10266 // 18673: }
10267 6, 157, 3, // 18678: case 0x6: {
10268 OPC_SwitchField, 26, 6, // 18681: switch Inst[31:26] {
10269 8, 7, // 18684: case 0x8: {
10270 OPC_CheckPredicate, 22, // 18686: check predicate 22
10271 OPC_Decode, 132, 126, 139, 1, // 18688: decode to VAADDU_VX using decoder 139
10272 // 18688: }
10273 9, 7, // 18693: case 0x9: {
10274 OPC_CheckPredicate, 22, // 18695: check predicate 22
10275 OPC_Decode, 134, 126, 139, 1, // 18697: decode to VAADD_VX using decoder 139
10276 // 18697: }
10277 10, 7, // 18702: case 0xa: {
10278 OPC_CheckPredicate, 22, // 18704: check predicate 22
10279 OPC_Decode, 162, 126, 139, 1, // 18706: decode to VASUBU_VX using decoder 139
10280 // 18706: }
10281 11, 7, // 18711: case 0xb: {
10282 OPC_CheckPredicate, 22, // 18713: check predicate 22
10283 OPC_Decode, 164, 126, 139, 1, // 18715: decode to VASUB_VX using decoder 139
10284 // 18715: }
10285 12, 7, // 18720: case 0xc: {
10286 OPC_CheckPredicate, 107, // 18722: check predicate 107
10287 OPC_Decode, 170, 126, 139, 1, // 18724: decode to VCLMUL_VX using decoder 139
10288 // 18724: }
10289 13, 7, // 18729: case 0xd: {
10290 OPC_CheckPredicate, 107, // 18731: check predicate 107
10291 OPC_Decode, 168, 126, 139, 1, // 18733: decode to VCLMULH_VX using decoder 139
10292 // 18733: }
10293 14, 8, // 18738: case 0xe: {
10294 OPC_CheckPredicate, 22, // 18740: check predicate 22
10295 OPC_Decode, 171, 130, 1, 139, 1, // 18742: decode to VSLIDE1UP_VX using decoder 139
10296 // 18742: }
10297 15, 8, // 18748: case 0xf: {
10298 OPC_CheckPredicate, 22, // 18750: check predicate 22
10299 OPC_Decode, 170, 130, 1, 139, 1, // 18752: decode to VSLIDE1DOWN_VX using decoder 139
10300 // 18752: }
10301 16, 12, // 18758: case 0x10: {
10302 OPC_CheckPredicate, 22, // 18760: check predicate 22
10303 OPC_CheckField, 20, 6, 32, // 18762: check Inst[25:20] == 0x20
10304 OPC_Decode, 211, 129, 1, 148, 1, // 18766: decode to VMV_S_X using decoder 148
10305 // 18766: }
10306 21, 7, // 18772: case 0x15: {
10307 OPC_CheckPredicate, 102, // 18774: check predicate 102
10308 OPC_Decode, 138, 126, 139, 1, // 18776: decode to VABD_VX using decoder 139
10309 // 18776: }
10310 22, 7, // 18781: case 0x16: {
10311 OPC_CheckPredicate, 102, // 18783: check predicate 102
10312 OPC_Decode, 136, 126, 139, 1, // 18785: decode to VABDU_VX using decoder 139
10313 // 18785: }
10314 32, 7, // 18790: case 0x20: {
10315 OPC_CheckPredicate, 22, // 18792: check predicate 22
10316 OPC_Decode, 177, 126, 139, 1, // 18794: decode to VDIVU_VX using decoder 139
10317 // 18794: }
10318 33, 7, // 18799: case 0x21: {
10319 OPC_CheckPredicate, 22, // 18801: check predicate 22
10320 OPC_Decode, 179, 126, 139, 1, // 18803: decode to VDIV_VX using decoder 139
10321 // 18803: }
10322 34, 8, // 18808: case 0x22: {
10323 OPC_CheckPredicate, 22, // 18810: check predicate 22
10324 OPC_Decode, 130, 130, 1, 139, 1, // 18812: decode to VREMU_VX using decoder 139
10325 // 18812: }
10326 35, 8, // 18818: case 0x23: {
10327 OPC_CheckPredicate, 22, // 18820: check predicate 22
10328 OPC_Decode, 132, 130, 1, 139, 1, // 18822: decode to VREM_VX using decoder 139
10329 // 18822: }
10330 36, 8, // 18828: case 0x24: {
10331 OPC_CheckPredicate, 22, // 18830: check predicate 22
10332 OPC_Decode, 202, 129, 1, 139, 1, // 18832: decode to VMULHU_VX using decoder 139
10333 // 18832: }
10334 37, 8, // 18838: case 0x25: {
10335 OPC_CheckPredicate, 22, // 18840: check predicate 22
10336 OPC_Decode, 206, 129, 1, 139, 1, // 18842: decode to VMUL_VX using decoder 139
10337 // 18842: }
10338 38, 8, // 18848: case 0x26: {
10339 OPC_CheckPredicate, 22, // 18850: check predicate 22
10340 OPC_Decode, 200, 129, 1, 139, 1, // 18852: decode to VMULHSU_VX using decoder 139
10341 // 18852: }
10342 39, 8, // 18858: case 0x27: {
10343 OPC_CheckPredicate, 22, // 18860: check predicate 22
10344 OPC_Decode, 204, 129, 1, 139, 1, // 18862: decode to VMULH_VX using decoder 139
10345 // 18862: }
10346 40, 7, // 18868: case 0x28: {
10347 OPC_CheckPredicate, 108, // 18870: check predicate 108
10348 OPC_Decode, 184, 126, 142, 1, // 18872: decode to VDOT4AU_VX using decoder 142
10349 // 18872: }
10350 41, 8, // 18877: case 0x29: {
10351 OPC_CheckPredicate, 22, // 18879: check predicate 22
10352 OPC_Decode, 243, 128, 1, 149, 1, // 18881: decode to VMADD_VX using decoder 149
10353 // 18881: }
10354 42, 7, // 18887: case 0x2a: {
10355 OPC_CheckPredicate, 108, // 18889: check predicate 108
10356 OPC_Decode, 181, 126, 142, 1, // 18891: decode to VDOT4ASU_VX using decoder 142
10357 // 18891: }
10358 43, 8, // 18896: case 0x2b: {
10359 OPC_CheckPredicate, 22, // 18898: check predicate 22
10360 OPC_Decode, 227, 129, 1, 149, 1, // 18900: decode to VNMSUB_VX using decoder 149
10361 // 18900: }
10362 44, 7, // 18906: case 0x2c: {
10363 OPC_CheckPredicate, 108, // 18908: check predicate 108
10364 OPC_Decode, 186, 126, 142, 1, // 18910: decode to VDOT4A_VX using decoder 142
10365 // 18910: }
10366 45, 8, // 18915: case 0x2d: {
10367 OPC_CheckPredicate, 22, // 18917: check predicate 22
10368 OPC_Decode, 235, 128, 1, 149, 1, // 18919: decode to VMACC_VX using decoder 149
10369 // 18919: }
10370 46, 7, // 18925: case 0x2e: {
10371 OPC_CheckPredicate, 108, // 18927: check predicate 108
10372 OPC_Decode, 182, 126, 142, 1, // 18929: decode to VDOT4AUS_VX using decoder 142
10373 // 18929: }
10374 47, 8, // 18934: case 0x2f: {
10375 OPC_CheckPredicate, 22, // 18936: check predicate 22
10376 OPC_Decode, 225, 129, 1, 149, 1, // 18938: decode to VNMSAC_VX using decoder 149
10377 // 18938: }
10378 48, 8, // 18944: case 0x30: {
10379 OPC_CheckPredicate, 22, // 18946: check predicate 22
10380 OPC_Decode, 209, 131, 1, 139, 1, // 18948: decode to VWADDU_VX using decoder 139
10381 // 18948: }
10382 49, 8, // 18954: case 0x31: {
10383 OPC_CheckPredicate, 22, // 18956: check predicate 22
10384 OPC_Decode, 213, 131, 1, 139, 1, // 18958: decode to VWADD_VX using decoder 139
10385 // 18958: }
10386 50, 8, // 18964: case 0x32: {
10387 OPC_CheckPredicate, 22, // 18966: check predicate 22
10388 OPC_Decode, 236, 131, 1, 139, 1, // 18968: decode to VWSUBU_VX using decoder 139
10389 // 18968: }
10390 51, 8, // 18974: case 0x33: {
10391 OPC_CheckPredicate, 22, // 18976: check predicate 22
10392 OPC_Decode, 240, 131, 1, 139, 1, // 18978: decode to VWSUB_VX using decoder 139
10393 // 18978: }
10394 52, 8, // 18984: case 0x34: {
10395 OPC_CheckPredicate, 22, // 18986: check predicate 22
10396 OPC_Decode, 211, 131, 1, 139, 1, // 18988: decode to VWADDU_WX using decoder 139
10397 // 18988: }
10398 53, 8, // 18994: case 0x35: {
10399 OPC_CheckPredicate, 22, // 18996: check predicate 22
10400 OPC_Decode, 215, 131, 1, 139, 1, // 18998: decode to VWADD_WX using decoder 139
10401 // 18998: }
10402 54, 8, // 19004: case 0x36: {
10403 OPC_CheckPredicate, 22, // 19006: check predicate 22
10404 OPC_Decode, 238, 131, 1, 139, 1, // 19008: decode to VWSUBU_WX using decoder 139
10405 // 19008: }
10406 55, 8, // 19014: case 0x37: {
10407 OPC_CheckPredicate, 22, // 19016: check predicate 22
10408 OPC_Decode, 242, 131, 1, 139, 1, // 19018: decode to VWSUB_WX using decoder 139
10409 // 19018: }
10410 56, 8, // 19024: case 0x38: {
10411 OPC_CheckPredicate, 22, // 19026: check predicate 22
10412 OPC_Decode, 227, 131, 1, 139, 1, // 19028: decode to VWMULU_VX using decoder 139
10413 // 19028: }
10414 58, 8, // 19034: case 0x3a: {
10415 OPC_CheckPredicate, 22, // 19036: check predicate 22
10416 OPC_Decode, 225, 131, 1, 139, 1, // 19038: decode to VWMULSU_VX using decoder 139
10417 // 19038: }
10418 59, 8, // 19044: case 0x3b: {
10419 OPC_CheckPredicate, 22, // 19046: check predicate 22
10420 OPC_Decode, 229, 131, 1, 139, 1, // 19048: decode to VWMUL_VX using decoder 139
10421 // 19048: }
10422 60, 8, // 19054: case 0x3c: {
10423 OPC_CheckPredicate, 22, // 19056: check predicate 22
10424 OPC_Decode, 220, 131, 1, 149, 1, // 19058: decode to VWMACCU_VX using decoder 149
10425 // 19058: }
10426 61, 8, // 19064: case 0x3d: {
10427 OPC_CheckPredicate, 22, // 19066: check predicate 22
10428 OPC_Decode, 222, 131, 1, 149, 1, // 19068: decode to VWMACC_VX using decoder 149
10429 // 19068: }
10430 62, 8, // 19074: case 0x3e: {
10431 OPC_CheckPredicate, 22, // 19076: check predicate 22
10432 OPC_Decode, 218, 131, 1, 149, 1, // 19078: decode to VWMACCUS_VX using decoder 149
10433 // 19078: }
10434 63, 0, // 19084: case 0x3f: {
10435 OPC_CheckPredicate, 22, // 19086: check predicate 22
10436 OPC_Decode, 217, 131, 1, 149, 1, // 19088: decode to VWMACCSU_VX using decoder 149
10437 // 19088: }
10438 // 19088: } // switch Inst[31:26]
10439 // 19088: }
10440 7, 0, // 19094: case 0x7: {
10441 OPC_SwitchField, 31, 1, // 19096: switch Inst[31] {
10442 0, 8, // 19099: case 0x0: {
10443 OPC_CheckPredicate, 22, // 19101: check predicate 22
10444 OPC_Decode, 163, 130, 1, 150, 1, // 19103: decode to VSETVLI using decoder 150
10445 // 19103: }
10446 1, 0, // 19109: case 0x1: {
10447 OPC_SwitchField, 30, 1, // 19111: switch Inst[30] {
10448 0, 11, // 19114: case 0x0: {
10449 OPC_CheckPredicate, 22, // 19116: check predicate 22
10450 OPC_CheckField, 25, 5, 0, // 19118: check Inst[29:25] == 0x0
10451 OPC_Decode, 162, 130, 1, 31, // 19122: decode to VSETVL using decoder 31
10452 // 19122: }
10453 1, 0, // 19127: case 0x1: {
10454 OPC_CheckPredicate, 22, // 19129: check predicate 22
10455 OPC_Decode, 161, 130, 1, 151, 1, // 19131: decode to VSETIVLI using decoder 151
10456 // 19131: }
10457 // 19131: } // switch Inst[30]
10458 // 19131: }
10459 // 19131: } // switch Inst[31]
10460 // 19131: }
10461 // 19131: } // switch Inst[14:12]
10462 // 19131: }
10463 99, 63, // 19137: case 0x63: {
10464 OPC_SwitchField, 12, 3, // 19139: switch Inst[14:12] {
10465 0, 5, // 19142: case 0x0: {
10466 OPC_Decode, 212, 110, 152, 1, // 19144: decode to BEQ using decoder 152
10467 // 19144: }
10468 1, 5, // 19149: case 0x1: {
10469 OPC_Decode, 222, 110, 152, 1, // 19151: decode to BNE using decoder 152
10470 // 19151: }
10471 2, 7, // 19156: case 0x2: {
10472 OPC_CheckPredicate, 109, // 19158: check predicate 109
10473 OPC_Decode, 213, 110, 153, 1, // 19160: decode to BEQI using decoder 153
10474 // 19160: }
10475 3, 7, // 19165: case 0x3: {
10476 OPC_CheckPredicate, 109, // 19167: check predicate 109
10477 OPC_Decode, 223, 110, 153, 1, // 19169: decode to BNEI using decoder 153
10478 // 19169: }
10479 4, 5, // 19174: case 0x4: {
10480 OPC_Decode, 220, 110, 152, 1, // 19176: decode to BLT using decoder 152
10481 // 19176: }
10482 5, 5, // 19181: case 0x5: {
10483 OPC_Decode, 216, 110, 152, 1, // 19183: decode to BGE using decoder 152
10484 // 19183: }
10485 6, 5, // 19188: case 0x6: {
10486 OPC_Decode, 221, 110, 152, 1, // 19190: decode to BLTU using decoder 152
10487 // 19190: }
10488 7, 0, // 19195: case 0x7: {
10489 OPC_Decode, 217, 110, 152, 1, // 19197: decode to BGEU using decoder 152
10490 // 19197: }
10491 // 19197: } // switch Inst[14:12]
10492 // 19197: }
10493 103, 8, // 19202: case 0x67: {
10494 OPC_CheckField, 12, 3, 0, // 19204: check Inst[14:12] == 0x0
10495 OPC_Decode, 207, 116, 0, // 19208: decode to JALR using decoder 0
10496 // 19208: }
10497 111, 5, // 19212: case 0x6f: {
10498 OPC_Decode, 206, 116, 154, 1, // 19214: decode to JAL using decoder 154
10499 // 19214: }
10500 115, 173, 7, // 19219: case 0x73: {
10501 OPC_SwitchField, 12, 3, // 19222: switch Inst[14:12] {
10502 0, 201, 2, // 19225: case 0x0: {
10503 OPC_SwitchField, 25, 7, // 19228: switch Inst[31:25] {
10504 0, 51, // 19231: case 0x0: {
10505 OPC_SwitchField, 15, 10, // 19233: switch Inst[24:15] {
10506 0, 8, // 19236: case 0x0: {
10507 OPC_CheckField, 7, 5, 0, // 19238: check Inst[11:7] == 0x0
10508 OPC_Decode, 138, 114, 14, // 19242: decode to ECALL using decoder 14
10509 // 19242: }
10510 32, 8, // 19246: case 0x20: {
10511 OPC_CheckField, 7, 5, 0, // 19248: check Inst[11:7] == 0x0
10512 OPC_Decode, 137, 114, 14, // 19252: decode to EBREAK using decoder 14
10513 // 19252: }
10514 160, 3, 11, // 19256: case 0x1a0: {
10515 OPC_CheckPredicate, 110, // 19259: check predicate 110
10516 OPC_CheckField, 7, 5, 0, // 19261: check Inst[11:7] == 0x0
10517 OPC_Decode, 133, 132, 1, 14, // 19265: decode to WRS_NTO using decoder 14
10518 // 19265: }
10519 160, 7, 0, // 19270: case 0x3a0: {
10520 OPC_CheckPredicate, 110, // 19273: check predicate 110
10521 OPC_CheckField, 7, 5, 0, // 19275: check Inst[11:7] == 0x0
10522 OPC_Decode, 134, 132, 1, 14, // 19279: decode to WRS_STO using decoder 14
10523 // 19279: }
10524 // 19279: } // switch Inst[24:15]
10525 // 19279: }
10526 8, 82, // 19284: case 0x8: {
10527 OPC_SwitchField, 20, 5, // 19286: switch Inst[24:20] {
10528 2, 12, // 19289: case 0x2: {
10529 OPC_CheckField, 15, 5, 0, // 19291: check Inst[19:15] == 0x0
10530 OPC_CheckField, 7, 5, 0, // 19295: check Inst[11:7] == 0x0
10531 OPC_Decode, 236, 124, 14, // 19299: decode to SRET using decoder 14
10532 // 19299: }
10533 4, 14, // 19303: case 0x4: {
10534 OPC_CheckPredicate, 111, // 19305: check predicate 111
10535 OPC_CheckField, 15, 5, 0, // 19307: check Inst[19:15] == 0x0
10536 OPC_CheckField, 7, 5, 0, // 19311: check Inst[11:7] == 0x0
10537 OPC_Decode, 212, 123, 14, // 19315: decode to SCTRCLR using decoder 14
10538 // 19315: }
10539 5, 13, // 19319: case 0x5: {
10540 OPC_CheckField, 15, 5, 0, // 19321: check Inst[19:15] == 0x0
10541 OPC_CheckField, 7, 5, 0, // 19325: check Inst[11:7] == 0x0
10542 OPC_Decode, 254, 131, 1, 14, // 19329: decode to WFI using decoder 14
10543 // 19329: }
10544 8, 14, // 19334: case 0x8: {
10545 OPC_CheckPredicate, 112, // 19336: check predicate 112
10546 OPC_CheckField, 15, 5, 0, // 19338: check Inst[19:15] == 0x0
10547 OPC_CheckField, 7, 5, 0, // 19342: check Inst[11:7] == 0x0
10548 OPC_Decode, 199, 124, 14, // 19346: decode to SIPOPRET using decoder 14
10549 // 19346: }
10550 9, 7, // 19350: case 0x9: {
10551 OPC_CheckPredicate, 113, // 19352: check predicate 113
10552 OPC_Decode, 211, 123, 155, 1, // 19354: decode to SCSPSPUSH using decoder 155
10553 // 19354: }
10554 12, 0, // 19359: case 0xc: {
10555 OPC_CheckPredicate, 113, // 19361: check predicate 113
10556 OPC_Decode, 210, 123, 155, 1, // 19363: decode to SCSPSPOP using decoder 155
10557 // 19363: }
10558 // 19363: } // switch Inst[24:20]
10559 // 19363: }
10560 9, 9, // 19368: case 0x9: {
10561 OPC_CheckField, 7, 5, 0, // 19370: check Inst[11:7] == 0x0
10562 OPC_Decode, 228, 123, 156, 1, // 19374: decode to SFENCE_VMA using decoder 156
10563 // 19374: }
10564 11, 11, // 19379: case 0xb: {
10565 OPC_CheckPredicate, 114, // 19381: check predicate 114
10566 OPC_CheckField, 7, 5, 0, // 19383: check Inst[11:7] == 0x0
10567 OPC_Decode, 198, 124, 156, 1, // 19387: decode to SINVAL_VMA using decoder 156
10568 // 19387: }
10569 12, 27, // 19392: case 0xc: {
10570 OPC_SwitchField, 15, 10, // 19394: switch Inst[24:15] {
10571 0, 10, // 19397: case 0x0: {
10572 OPC_CheckPredicate, 114, // 19399: check predicate 114
10573 OPC_CheckField, 7, 5, 0, // 19401: check Inst[11:7] == 0x0
10574 OPC_Decode, 229, 123, 14, // 19405: decode to SFENCE_W_INVAL using decoder 14
10575 // 19405: }
10576 32, 0, // 19409: case 0x20: {
10577 OPC_CheckPredicate, 114, // 19411: check predicate 114
10578 OPC_CheckField, 7, 5, 0, // 19413: check Inst[11:7] == 0x0
10579 OPC_Decode, 227, 123, 14, // 19417: decode to SFENCE_INVAL_IR using decoder 14
10580 // 19417: }
10581 // 19417: } // switch Inst[24:15]
10582 // 19417: }
10583 17, 11, // 19421: case 0x11: {
10584 OPC_CheckPredicate, 115, // 19423: check predicate 115
10585 OPC_CheckField, 7, 5, 0, // 19425: check Inst[11:7] == 0x0
10586 OPC_Decode, 163, 116, 156, 1, // 19429: decode to HFENCE_VVMA using decoder 156
10587 // 19429: }
10588 19, 11, // 19434: case 0x13: {
10589 OPC_CheckPredicate, 116, // 19436: check predicate 116
10590 OPC_CheckField, 7, 5, 0, // 19438: check Inst[11:7] == 0x0
10591 OPC_Decode, 165, 116, 156, 1, // 19442: decode to HINVAL_VVMA using decoder 156
10592 // 19442: }
10593 24, 51, // 19447: case 0x18: {
10594 OPC_SwitchField, 20, 5, // 19449: switch Inst[24:20] {
10595 2, 12, // 19452: case 0x2: {
10596 OPC_CheckField, 15, 5, 0, // 19454: check Inst[19:15] == 0x0
10597 OPC_CheckField, 7, 5, 0, // 19458: check Inst[11:7] == 0x0
10598 OPC_Decode, 224, 117, 14, // 19462: decode to MRET using decoder 14
10599 // 19462: }
10600 8, 14, // 19466: case 0x8: {
10601 OPC_CheckPredicate, 117, // 19468: check predicate 117
10602 OPC_CheckField, 15, 5, 0, // 19470: check Inst[19:15] == 0x0
10603 OPC_CheckField, 7, 5, 0, // 19474: check Inst[11:7] == 0x0
10604 OPC_Decode, 159, 117, 14, // 19478: decode to MIPOPRET using decoder 14
10605 // 19478: }
10606 9, 7, // 19482: case 0x9: {
10607 OPC_CheckPredicate, 118, // 19484: check predicate 118
10608 OPC_Decode, 145, 117, 155, 1, // 19486: decode to MCSPSPUSH using decoder 155
10609 // 19486: }
10610 12, 0, // 19491: case 0xc: {
10611 OPC_CheckPredicate, 118, // 19493: check predicate 118
10612 OPC_Decode, 144, 117, 155, 1, // 19495: decode to MCSPSPOP using decoder 155
10613 // 19495: }
10614 // 19495: } // switch Inst[24:20]
10615 // 19495: }
10616 49, 11, // 19500: case 0x31: {
10617 OPC_CheckPredicate, 115, // 19502: check predicate 115
10618 OPC_CheckField, 7, 5, 0, // 19504: check Inst[11:7] == 0x0
10619 OPC_Decode, 162, 116, 156, 1, // 19508: decode to HFENCE_GVMA using decoder 156
10620 // 19508: }
10621 51, 11, // 19513: case 0x33: {
10622 OPC_CheckPredicate, 116, // 19515: check predicate 116
10623 OPC_CheckField, 7, 5, 0, // 19517: check Inst[11:7] == 0x0
10624 OPC_Decode, 164, 116, 156, 1, // 19521: decode to HINVAL_GVMA using decoder 156
10625 // 19521: }
10626 56, 14, // 19526: case 0x38: {
10627 OPC_CheckPredicate, 119, // 19528: check predicate 119
10628 OPC_CheckField, 15, 10, 64, // 19530: check Inst[24:15] == 0x40
10629 OPC_CheckField, 7, 5, 0, // 19534: check Inst[11:7] == 0x0
10630 OPC_Decode, 169, 117, 14, // 19538: decode to MNRET using decoder 14
10631 // 19538: }
10632 61, 0, // 19542: case 0x3d: {
10633 OPC_CheckField, 15, 10, 192, 4, // 19544: check Inst[24:15] == 0x240
10634 OPC_CheckField, 7, 5, 0, // 19549: check Inst[11:7] == 0x0
10635 OPC_Decode, 136, 114, 14, // 19553: decode to DRET using decoder 14
10636 // 19553: }
10637 // 19553: } // switch Inst[31:25]
10638 // 19553: }
10639 1, 21, // 19557: case 0x1: {
10640 OPC_Scope, 14, // 19559: try {
10641 OPC_CheckField, 7, 5, 0, // 19561: check Inst[11:7] == 0x0
10642 OPC_CheckField, 15, 17, 128, 128, 6, // 19565: check Inst[31:15] == 0x18000
10643 OPC_Decode, 250, 125, 14, // 19571: decode to UNIMP using decoder 14
10644 // 19571: } else try {
10645 OPC_Decode, 252, 110, 157, 1, // 19575: decode to CSRRW using decoder 157
10646 // 19575: }
10647 // 19575: }
10648 2, 5, // 19580: case 0x2: {
10649 OPC_Decode, 250, 110, 157, 1, // 19582: decode to CSRRS using decoder 157
10650 // 19582: }
10651 3, 5, // 19587: case 0x3: {
10652 OPC_Decode, 248, 110, 157, 1, // 19589: decode to CSRRC using decoder 157
10653 // 19589: }
10654 4, 161, 4, // 19594: case 0x4: {
10655 OPC_SwitchField, 25, 7, // 19597: switch Inst[31:25] {
10656 48, 19, // 19600: case 0x30: {
10657 OPC_SwitchField, 20, 5, // 19602: switch Inst[24:20] {
10658 0, 6, // 19605: case 0x0: {
10659 OPC_CheckPredicate, 115, // 19607: check predicate 115
10660 OPC_Decode, 168, 116, 17, // 19609: decode to HLV_B using decoder 17
10661 // 19609: }
10662 1, 0, // 19613: case 0x1: {
10663 OPC_CheckPredicate, 115, // 19615: check predicate 115
10664 OPC_Decode, 169, 116, 17, // 19617: decode to HLV_BU using decoder 17
10665 // 19617: }
10666 // 19617: } // switch Inst[24:20]
10667 // 19617: }
10668 49, 10, // 19621: case 0x31: {
10669 OPC_CheckPredicate, 115, // 19623: check predicate 115
10670 OPC_CheckField, 7, 5, 0, // 19625: check Inst[11:7] == 0x0
10671 OPC_Decode, 175, 116, 59, // 19629: decode to HSV_B using decoder 59
10672 // 19629: }
10673 50, 27, // 19633: case 0x32: {
10674 OPC_SwitchField, 20, 5, // 19635: switch Inst[24:20] {
10675 0, 6, // 19638: case 0x0: {
10676 OPC_CheckPredicate, 115, // 19640: check predicate 115
10677 OPC_Decode, 171, 116, 17, // 19642: decode to HLV_H using decoder 17
10678 // 19642: }
10679 1, 6, // 19646: case 0x1: {
10680 OPC_CheckPredicate, 115, // 19648: check predicate 115
10681 OPC_Decode, 172, 116, 17, // 19650: decode to HLV_HU using decoder 17
10682 // 19650: }
10683 3, 0, // 19654: case 0x3: {
10684 OPC_CheckPredicate, 115, // 19656: check predicate 115
10685 OPC_Decode, 166, 116, 17, // 19658: decode to HLVX_HU using decoder 17
10686 // 19658: }
10687 // 19658: } // switch Inst[24:20]
10688 // 19658: }
10689 51, 10, // 19662: case 0x33: {
10690 OPC_CheckPredicate, 115, // 19664: check predicate 115
10691 OPC_CheckField, 7, 5, 0, // 19666: check Inst[11:7] == 0x0
10692 OPC_Decode, 177, 116, 59, // 19670: decode to HSV_H using decoder 59
10693 // 19670: }
10694 52, 27, // 19674: case 0x34: {
10695 OPC_SwitchField, 20, 5, // 19676: switch Inst[24:20] {
10696 0, 6, // 19679: case 0x0: {
10697 OPC_CheckPredicate, 115, // 19681: check predicate 115
10698 OPC_Decode, 173, 116, 17, // 19683: decode to HLV_W using decoder 17
10699 // 19683: }
10700 1, 6, // 19687: case 0x1: {
10701 OPC_CheckPredicate, 120, // 19689: check predicate 120
10702 OPC_Decode, 174, 116, 17, // 19691: decode to HLV_WU using decoder 17
10703 // 19691: }
10704 3, 0, // 19695: case 0x3: {
10705 OPC_CheckPredicate, 115, // 19697: check predicate 115
10706 OPC_Decode, 167, 116, 17, // 19699: decode to HLVX_WU using decoder 17
10707 // 19699: }
10708 // 19699: } // switch Inst[24:20]
10709 // 19699: }
10710 53, 10, // 19703: case 0x35: {
10711 OPC_CheckPredicate, 115, // 19705: check predicate 115
10712 OPC_CheckField, 7, 5, 0, // 19707: check Inst[11:7] == 0x0
10713 OPC_Decode, 178, 116, 59, // 19711: decode to HSV_W using decoder 59
10714 // 19711: }
10715 54, 10, // 19715: case 0x36: {
10716 OPC_CheckPredicate, 120, // 19717: check predicate 120
10717 OPC_CheckField, 20, 5, 0, // 19719: check Inst[24:20] == 0x0
10718 OPC_Decode, 170, 116, 17, // 19723: decode to HLV_D using decoder 17
10719 // 19723: }
10720 55, 10, // 19727: case 0x37: {
10721 OPC_CheckPredicate, 120, // 19729: check predicate 120
10722 OPC_CheckField, 7, 5, 0, // 19731: check Inst[11:7] == 0x0
10723 OPC_Decode, 176, 116, 59, // 19735: decode to HSV_D using decoder 59
10724 // 19735: }
10725 64, 35, // 19739: case 0x40: {
10726 OPC_SwitchField, 20, 5, // 19741: switch Inst[24:20] {
10727 28, 6, // 19744: case 0x1c: {
10728 OPC_CheckPredicate, 121, // 19746: check predicate 121
10729 OPC_Decode, 178, 117, 17, // 19748: decode to MOP_R_0 using decoder 17
10730 // 19748: }
10731 29, 6, // 19752: case 0x1d: {
10732 OPC_CheckPredicate, 121, // 19754: check predicate 121
10733 OPC_Decode, 179, 117, 17, // 19756: decode to MOP_R_1 using decoder 17
10734 // 19756: }
10735 30, 6, // 19760: case 0x1e: {
10736 OPC_CheckPredicate, 121, // 19762: check predicate 121
10737 OPC_Decode, 190, 117, 17, // 19764: decode to MOP_R_2 using decoder 17
10738 // 19764: }
10739 31, 0, // 19768: case 0x1f: {
10740 OPC_CheckPredicate, 121, // 19770: check predicate 121
10741 OPC_Decode, 201, 117, 17, // 19772: decode to MOP_R_3 using decoder 17
10742 // 19772: }
10743 // 19772: } // switch Inst[24:20]
10744 // 19772: }
10745 65, 6, // 19776: case 0x41: {
10746 OPC_CheckPredicate, 121, // 19778: check predicate 121
10747 OPC_Decode, 170, 117, 31, // 19780: decode to MOP_RR_0 using decoder 31
10748 // 19780: }
10749 66, 35, // 19784: case 0x42: {
10750 OPC_SwitchField, 20, 5, // 19786: switch Inst[24:20] {
10751 28, 6, // 19789: case 0x1c: {
10752 OPC_CheckPredicate, 121, // 19791: check predicate 121
10753 OPC_Decode, 204, 117, 17, // 19793: decode to MOP_R_4 using decoder 17
10754 // 19793: }
10755 29, 6, // 19797: case 0x1d: {
10756 OPC_CheckPredicate, 121, // 19799: check predicate 121
10757 OPC_Decode, 205, 117, 17, // 19801: decode to MOP_R_5 using decoder 17
10758 // 19801: }
10759 30, 6, // 19805: case 0x1e: {
10760 OPC_CheckPredicate, 121, // 19807: check predicate 121
10761 OPC_Decode, 206, 117, 17, // 19809: decode to MOP_R_6 using decoder 17
10762 // 19809: }
10763 31, 0, // 19813: case 0x1f: {
10764 OPC_CheckPredicate, 121, // 19815: check predicate 121
10765 OPC_Decode, 207, 117, 17, // 19817: decode to MOP_R_7 using decoder 17
10766 // 19817: }
10767 // 19817: } // switch Inst[24:20]
10768 // 19817: }
10769 67, 6, // 19821: case 0x43: {
10770 OPC_CheckPredicate, 121, // 19823: check predicate 121
10771 OPC_Decode, 171, 117, 31, // 19825: decode to MOP_RR_1 using decoder 31
10772 // 19825: }
10773 68, 35, // 19829: case 0x44: {
10774 OPC_SwitchField, 20, 5, // 19831: switch Inst[24:20] {
10775 28, 6, // 19834: case 0x1c: {
10776 OPC_CheckPredicate, 121, // 19836: check predicate 121
10777 OPC_Decode, 208, 117, 17, // 19838: decode to MOP_R_8 using decoder 17
10778 // 19838: }
10779 29, 6, // 19842: case 0x1d: {
10780 OPC_CheckPredicate, 121, // 19844: check predicate 121
10781 OPC_Decode, 209, 117, 17, // 19846: decode to MOP_R_9 using decoder 17
10782 // 19846: }
10783 30, 6, // 19850: case 0x1e: {
10784 OPC_CheckPredicate, 121, // 19852: check predicate 121
10785 OPC_Decode, 180, 117, 17, // 19854: decode to MOP_R_10 using decoder 17
10786 // 19854: }
10787 31, 0, // 19858: case 0x1f: {
10788 OPC_CheckPredicate, 121, // 19860: check predicate 121
10789 OPC_Decode, 181, 117, 17, // 19862: decode to MOP_R_11 using decoder 17
10790 // 19862: }
10791 // 19862: } // switch Inst[24:20]
10792 // 19862: }
10793 69, 6, // 19866: case 0x45: {
10794 OPC_CheckPredicate, 121, // 19868: check predicate 121
10795 OPC_Decode, 172, 117, 31, // 19870: decode to MOP_RR_2 using decoder 31
10796 // 19870: }
10797 70, 35, // 19874: case 0x46: {
10798 OPC_SwitchField, 20, 5, // 19876: switch Inst[24:20] {
10799 28, 6, // 19879: case 0x1c: {
10800 OPC_CheckPredicate, 121, // 19881: check predicate 121
10801 OPC_Decode, 182, 117, 17, // 19883: decode to MOP_R_12 using decoder 17
10802 // 19883: }
10803 29, 6, // 19887: case 0x1d: {
10804 OPC_CheckPredicate, 121, // 19889: check predicate 121
10805 OPC_Decode, 183, 117, 17, // 19891: decode to MOP_R_13 using decoder 17
10806 // 19891: }
10807 30, 6, // 19895: case 0x1e: {
10808 OPC_CheckPredicate, 121, // 19897: check predicate 121
10809 OPC_Decode, 184, 117, 17, // 19899: decode to MOP_R_14 using decoder 17
10810 // 19899: }
10811 31, 0, // 19903: case 0x1f: {
10812 OPC_CheckPredicate, 121, // 19905: check predicate 121
10813 OPC_Decode, 185, 117, 17, // 19907: decode to MOP_R_15 using decoder 17
10814 // 19907: }
10815 // 19907: } // switch Inst[24:20]
10816 // 19907: }
10817 71, 6, // 19911: case 0x47: {
10818 OPC_CheckPredicate, 121, // 19913: check predicate 121
10819 OPC_Decode, 173, 117, 31, // 19915: decode to MOP_RR_3 using decoder 31
10820 // 19915: }
10821 96, 35, // 19919: case 0x60: {
10822 OPC_SwitchField, 20, 5, // 19921: switch Inst[24:20] {
10823 28, 6, // 19924: case 0x1c: {
10824 OPC_CheckPredicate, 121, // 19926: check predicate 121
10825 OPC_Decode, 186, 117, 17, // 19928: decode to MOP_R_16 using decoder 17
10826 // 19928: }
10827 29, 6, // 19932: case 0x1d: {
10828 OPC_CheckPredicate, 121, // 19934: check predicate 121
10829 OPC_Decode, 187, 117, 17, // 19936: decode to MOP_R_17 using decoder 17
10830 // 19936: }
10831 30, 6, // 19940: case 0x1e: {
10832 OPC_CheckPredicate, 121, // 19942: check predicate 121
10833 OPC_Decode, 188, 117, 17, // 19944: decode to MOP_R_18 using decoder 17
10834 // 19944: }
10835 31, 0, // 19948: case 0x1f: {
10836 OPC_CheckPredicate, 121, // 19950: check predicate 121
10837 OPC_Decode, 189, 117, 17, // 19952: decode to MOP_R_19 using decoder 17
10838 // 19952: }
10839 // 19952: } // switch Inst[24:20]
10840 // 19952: }
10841 97, 6, // 19956: case 0x61: {
10842 OPC_CheckPredicate, 121, // 19958: check predicate 121
10843 OPC_Decode, 174, 117, 31, // 19960: decode to MOP_RR_4 using decoder 31
10844 // 19960: }
10845 98, 35, // 19964: case 0x62: {
10846 OPC_SwitchField, 20, 5, // 19966: switch Inst[24:20] {
10847 28, 6, // 19969: case 0x1c: {
10848 OPC_CheckPredicate, 121, // 19971: check predicate 121
10849 OPC_Decode, 191, 117, 17, // 19973: decode to MOP_R_20 using decoder 17
10850 // 19973: }
10851 29, 6, // 19977: case 0x1d: {
10852 OPC_CheckPredicate, 121, // 19979: check predicate 121
10853 OPC_Decode, 192, 117, 17, // 19981: decode to MOP_R_21 using decoder 17
10854 // 19981: }
10855 30, 6, // 19985: case 0x1e: {
10856 OPC_CheckPredicate, 121, // 19987: check predicate 121
10857 OPC_Decode, 193, 117, 17, // 19989: decode to MOP_R_22 using decoder 17
10858 // 19989: }
10859 31, 0, // 19993: case 0x1f: {
10860 OPC_CheckPredicate, 121, // 19995: check predicate 121
10861 OPC_Decode, 194, 117, 17, // 19997: decode to MOP_R_23 using decoder 17
10862 // 19997: }
10863 // 19997: } // switch Inst[24:20]
10864 // 19997: }
10865 99, 6, // 20001: case 0x63: {
10866 OPC_CheckPredicate, 121, // 20003: check predicate 121
10867 OPC_Decode, 175, 117, 31, // 20005: decode to MOP_RR_5 using decoder 31
10868 // 20005: }
10869 100, 35, // 20009: case 0x64: {
10870 OPC_SwitchField, 20, 5, // 20011: switch Inst[24:20] {
10871 28, 6, // 20014: case 0x1c: {
10872 OPC_CheckPredicate, 121, // 20016: check predicate 121
10873 OPC_Decode, 195, 117, 17, // 20018: decode to MOP_R_24 using decoder 17
10874 // 20018: }
10875 29, 6, // 20022: case 0x1d: {
10876 OPC_CheckPredicate, 121, // 20024: check predicate 121
10877 OPC_Decode, 196, 117, 17, // 20026: decode to MOP_R_25 using decoder 17
10878 // 20026: }
10879 30, 6, // 20030: case 0x1e: {
10880 OPC_CheckPredicate, 121, // 20032: check predicate 121
10881 OPC_Decode, 197, 117, 17, // 20034: decode to MOP_R_26 using decoder 17
10882 // 20034: }
10883 31, 0, // 20038: case 0x1f: {
10884 OPC_CheckPredicate, 121, // 20040: check predicate 121
10885 OPC_Decode, 198, 117, 17, // 20042: decode to MOP_R_27 using decoder 17
10886 // 20042: }
10887 // 20042: } // switch Inst[24:20]
10888 // 20042: }
10889 101, 6, // 20046: case 0x65: {
10890 OPC_CheckPredicate, 121, // 20048: check predicate 121
10891 OPC_Decode, 176, 117, 31, // 20050: decode to MOP_RR_6 using decoder 31
10892 // 20050: }
10893 102, 61, // 20054: case 0x66: {
10894 OPC_SwitchField, 20, 5, // 20056: switch Inst[24:20] {
10895 28, 32, // 20059: case 0x1c: {
10896 OPC_Scope, 11, // 20061: try {
10897 OPC_CheckField, 7, 5, 0, // 20063: check Inst[11:7] == 0x0
10898 OPC_CheckPredicate, 121, // 20067: check predicate 121
10899 OPC_Decode, 129, 125, 158, 1, // 20069: decode to SSPOPCHK using decoder 158
10900 OPC_Scope, 11, // 20074: } else try {
10901 OPC_CheckField, 15, 5, 0, // 20076: check Inst[19:15] == 0x0
10902 OPC_CheckPredicate, 121, // 20080: check predicate 121
10903 OPC_Decode, 131, 125, 159, 1, // 20082: decode to SSRDP using decoder 159
10904 // 20082: } else try {
10905 OPC_CheckPredicate, 121, // 20087: check predicate 121
10906 OPC_Decode, 199, 117, 17, // 20089: decode to MOP_R_28 using decoder 17
10907 // 20089: }
10908 // 20089: }
10909 29, 6, // 20093: case 0x1d: {
10910 OPC_CheckPredicate, 121, // 20095: check predicate 121
10911 OPC_Decode, 200, 117, 17, // 20097: decode to MOP_R_29 using decoder 17
10912 // 20097: }
10913 30, 6, // 20101: case 0x1e: {
10914 OPC_CheckPredicate, 121, // 20103: check predicate 121
10915 OPC_Decode, 202, 117, 17, // 20105: decode to MOP_R_30 using decoder 17
10916 // 20105: }
10917 31, 0, // 20109: case 0x1f: {
10918 OPC_CheckPredicate, 121, // 20111: check predicate 121
10919 OPC_Decode, 203, 117, 17, // 20113: decode to MOP_R_31 using decoder 17
10920 // 20113: }
10921 // 20113: } // switch Inst[24:20]
10922 // 20113: }
10923 103, 0, // 20117: case 0x67: {
10924 OPC_Scope, 15, // 20119: try {
10925 OPC_CheckField, 7, 5, 0, // 20121: check Inst[11:7] == 0x0
10926 OPC_CheckPredicate, 121, // 20125: check predicate 121
10927 OPC_CheckField, 15, 5, 0, // 20127: check Inst[19:15] == 0x0
10928 OPC_Decode, 130, 125, 160, 1, // 20131: decode to SSPUSH using decoder 160
10929 // 20131: } else try {
10930 OPC_CheckPredicate, 121, // 20136: check predicate 121
10931 OPC_Decode, 177, 117, 31, // 20138: decode to MOP_RR_7 using decoder 31
10932 // 20138: }
10933 // 20138: }
10934 // 20138: } // switch Inst[31:25]
10935 // 20138: }
10936 5, 5, // 20142: case 0x5: {
10937 OPC_Decode, 253, 110, 161, 1, // 20144: decode to CSRRWI using decoder 161
10938 // 20144: }
10939 6, 5, // 20149: case 0x6: {
10940 OPC_Decode, 251, 110, 161, 1, // 20151: decode to CSRRSI using decoder 161
10941 // 20151: }
10942 7, 0, // 20156: case 0x7: {
10943 OPC_Decode, 249, 110, 161, 1, // 20158: decode to CSRRCI using decoder 161
10944 // 20158: }
10945 // 20158: } // switch Inst[14:12]
10946 // 20158: }
10947 119, 236, 3, // 20163: case 0x77: {
10948 OPC_SwitchField, 26, 6, // 20166: switch Inst[31:26] {
10949 32, 15, // 20169: case 0x20: {
10950 OPC_CheckPredicate, 122, // 20171: check predicate 122
10951 OPC_CheckField, 25, 1, 1, // 20173: check Inst[25] == 0x1
10952 OPC_CheckField, 12, 3, 2, // 20177: check Inst[14:12] == 0x2
10953 OPC_Decode, 180, 130, 1, 118, // 20181: decode to VSM3ME_VV using decoder 118
10954 // 20181: }
10955 33, 16, // 20186: case 0x21: {
10956 OPC_CheckPredicate, 123, // 20188: check predicate 123
10957 OPC_CheckField, 25, 1, 1, // 20190: check Inst[25] == 0x1
10958 OPC_CheckField, 12, 3, 2, // 20194: check Inst[14:12] == 0x2
10959 OPC_Decode, 181, 130, 1, 162, 1, // 20198: decode to VSM4K_VI using decoder 162
10960 // 20198: }
10961 34, 15, // 20204: case 0x22: {
10962 OPC_CheckPredicate, 124, // 20206: check predicate 124
10963 OPC_CheckField, 25, 1, 1, // 20208: check Inst[25] == 0x1
10964 OPC_CheckField, 12, 3, 2, // 20212: check Inst[14:12] == 0x2
10965 OPC_Decode, 153, 126, 162, 1, // 20216: decode to VAESKF1_VI using decoder 162
10966 // 20216: }
10967 35, 15, // 20221: case 0x23: {
10968 OPC_CheckPredicate, 125, // 20223: check predicate 125
10969 OPC_CheckField, 25, 1, 1, // 20225: check Inst[25] == 0x1
10970 OPC_CheckField, 12, 3, 2, // 20229: check Inst[14:12] == 0x2
10971 OPC_Decode, 179, 127, 163, 1, // 20233: decode to VGHSH_VS using decoder 163
10972 // 20233: }
10973 36, 10, // 20238: case 0x24: {
10974 OPC_CheckPredicate, 126, // 20240: check predicate 126
10975 OPC_CheckField, 12, 3, 1, // 20242: check Inst[14:12] == 0x1
10976 OPC_Decode, 153, 127, 122, // 20246: decode to VFWDOTA_VV using decoder 122
10977 // 20246: }
10978 38, 21, // 20250: case 0x26: {
10979 OPC_SwitchField, 12, 3, // 20252: switch Inst[14:12] {
10980 0, 7, // 20255: case 0x0: {
10981 OPC_CheckPredicate, 127, // 20257: check predicate 127
10982 OPC_Decode, 248, 129, 1, 122, // 20259: decode to VQWDOTAU_VV using decoder 122
10983 // 20259: }
10984 1, 0, // 20264: case 0x1: {
10985 OPC_CheckPredicate, 128, 1, // 20266: check predicate 128
10986 OPC_Decode, 248, 126, 122, // 20269: decode to VFQWDOTA_VV using decoder 122
10987 // 20269: }
10988 // 20269: } // switch Inst[14:12]
10989 // 20269: }
10990 39, 21, // 20273: case 0x27: {
10991 OPC_SwitchField, 12, 3, // 20275: switch Inst[14:12] {
10992 0, 7, // 20278: case 0x0: {
10993 OPC_CheckPredicate, 127, // 20280: check predicate 127
10994 OPC_Decode, 247, 129, 1, 122, // 20282: decode to VQWDOTAS_VV using decoder 122
10995 // 20282: }
10996 1, 0, // 20287: case 0x1: {
10997 OPC_CheckPredicate, 128, 1, // 20289: check predicate 128
10998 OPC_Decode, 247, 126, 122, // 20292: decode to VFQWDOTA_ALT_VV using decoder 122
10999 // 20292: }
11000 // 20292: } // switch Inst[14:12]
11001 // 20292: }
11002 40, 85, // 20296: case 0x28: {
11003 OPC_SwitchField, 12, 8, // 20298: switch Inst[19:12] {
11004 2, 11, // 20301: case 0x2: {
11005 OPC_CheckPredicate, 124, // 20303: check predicate 124
11006 OPC_CheckField, 25, 1, 1, // 20305: check Inst[25] == 0x1
11007 OPC_Decode, 148, 126, 164, 1, // 20309: decode to VAESDM_VV using decoder 164
11008 // 20309: }
11009 10, 11, // 20314: case 0xa: {
11010 OPC_CheckPredicate, 124, // 20316: check predicate 124
11011 OPC_CheckField, 25, 1, 1, // 20318: check Inst[25] == 0x1
11012 OPC_Decode, 146, 126, 164, 1, // 20322: decode to VAESDF_VV using decoder 164
11013 // 20322: }
11014 18, 11, // 20327: case 0x12: {
11015 OPC_CheckPredicate, 124, // 20329: check predicate 124
11016 OPC_CheckField, 25, 1, 1, // 20331: check Inst[25] == 0x1
11017 OPC_Decode, 152, 126, 164, 1, // 20335: decode to VAESEM_VV using decoder 164
11018 // 20335: }
11019 26, 11, // 20340: case 0x1a: {
11020 OPC_CheckPredicate, 124, // 20342: check predicate 124
11021 OPC_CheckField, 25, 1, 1, // 20344: check Inst[25] == 0x1
11022 OPC_Decode, 150, 126, 164, 1, // 20348: decode to VAESEF_VV using decoder 164
11023 // 20348: }
11024 130, 1, 12, // 20353: case 0x82: {
11025 OPC_CheckPredicate, 123, // 20356: check predicate 123
11026 OPC_CheckField, 25, 1, 1, // 20358: check Inst[25] == 0x1
11027 OPC_Decode, 183, 130, 1, 164, 1, // 20362: decode to VSM4R_VV using decoder 164
11028 // 20362: }
11029 138, 1, 0, // 20368: case 0x8a: {
11030 OPC_CheckPredicate, 129, 1, // 20371: check predicate 129
11031 OPC_CheckField, 25, 1, 1, // 20374: check Inst[25] == 0x1
11032 OPC_Decode, 182, 127, 164, 1, // 20378: decode to VGMUL_VV using decoder 164
11033 // 20378: }
11034 // 20378: } // switch Inst[19:12]
11035 // 20378: }
11036 41, 97, // 20383: case 0x29: {
11037 OPC_SwitchField, 12, 8, // 20385: switch Inst[19:12] {
11038 2, 11, // 20388: case 0x2: {
11039 OPC_CheckPredicate, 124, // 20390: check predicate 124
11040 OPC_CheckField, 25, 1, 1, // 20392: check Inst[25] == 0x1
11041 OPC_Decode, 147, 126, 164, 1, // 20396: decode to VAESDM_VS using decoder 164
11042 // 20396: }
11043 10, 11, // 20401: case 0xa: {
11044 OPC_CheckPredicate, 124, // 20403: check predicate 124
11045 OPC_CheckField, 25, 1, 1, // 20405: check Inst[25] == 0x1
11046 OPC_Decode, 145, 126, 164, 1, // 20409: decode to VAESDF_VS using decoder 164
11047 // 20409: }
11048 18, 11, // 20414: case 0x12: {
11049 OPC_CheckPredicate, 124, // 20416: check predicate 124
11050 OPC_CheckField, 25, 1, 1, // 20418: check Inst[25] == 0x1
11051 OPC_Decode, 151, 126, 164, 1, // 20422: decode to VAESEM_VS using decoder 164
11052 // 20422: }
11053 26, 11, // 20427: case 0x1a: {
11054 OPC_CheckPredicate, 124, // 20429: check predicate 124
11055 OPC_CheckField, 25, 1, 1, // 20431: check Inst[25] == 0x1
11056 OPC_Decode, 149, 126, 164, 1, // 20435: decode to VAESEF_VS using decoder 164
11057 // 20435: }
11058 58, 11, // 20440: case 0x3a: {
11059 OPC_CheckPredicate, 124, // 20442: check predicate 124
11060 OPC_CheckField, 25, 1, 1, // 20444: check Inst[25] == 0x1
11061 OPC_Decode, 155, 126, 164, 1, // 20448: decode to VAESZ_VS using decoder 164
11062 // 20448: }
11063 130, 1, 12, // 20453: case 0x82: {
11064 OPC_CheckPredicate, 123, // 20456: check predicate 123
11065 OPC_CheckField, 25, 1, 1, // 20458: check Inst[25] == 0x1
11066 OPC_Decode, 182, 130, 1, 164, 1, // 20462: decode to VSM4R_VS using decoder 164
11067 // 20462: }
11068 138, 1, 0, // 20468: case 0x8a: {
11069 OPC_CheckPredicate, 125, // 20471: check predicate 125
11070 OPC_CheckField, 25, 1, 1, // 20473: check Inst[25] == 0x1
11071 OPC_Decode, 181, 127, 164, 1, // 20477: decode to VGMUL_VS using decoder 164
11072 // 20477: }
11073 // 20477: } // switch Inst[19:12]
11074 // 20477: }
11075 42, 15, // 20482: case 0x2a: {
11076 OPC_CheckPredicate, 124, // 20484: check predicate 124
11077 OPC_CheckField, 25, 1, 1, // 20486: check Inst[25] == 0x1
11078 OPC_CheckField, 12, 3, 2, // 20490: check Inst[14:12] == 0x2
11079 OPC_Decode, 154, 126, 165, 1, // 20494: decode to VAESKF2_VI using decoder 165
11080 // 20494: }
11081 43, 27, // 20499: case 0x2b: {
11082 OPC_SwitchField, 12, 3, // 20501: switch Inst[14:12] {
11083 1, 8, // 20504: case 0x1: {
11084 OPC_CheckPredicate, 130, 1, // 20506: check predicate 130
11085 OPC_Decode, 192, 126, 166, 1, // 20509: decode to VFBDOTA_VV using decoder 166
11086 // 20509: }
11087 2, 0, // 20514: case 0x2: {
11088 OPC_CheckPredicate, 122, // 20516: check predicate 122
11089 OPC_CheckField, 25, 1, 1, // 20518: check Inst[25] == 0x1
11090 OPC_Decode, 179, 130, 1, 165, 1, // 20522: decode to VSM3C_VI using decoder 165
11091 // 20522: }
11092 // 20522: } // switch Inst[14:12]
11093 // 20522: }
11094 44, 27, // 20528: case 0x2c: {
11095 OPC_SwitchField, 12, 3, // 20530: switch Inst[14:12] {
11096 1, 8, // 20533: case 0x1: {
11097 OPC_CheckPredicate, 131, 1, // 20535: check predicate 131
11098 OPC_Decode, 144, 127, 166, 1, // 20538: decode to VFWBDOTA_VV using decoder 166
11099 // 20538: }
11100 2, 0, // 20543: case 0x2: {
11101 OPC_CheckPredicate, 129, 1, // 20545: check predicate 129
11102 OPC_CheckField, 25, 1, 1, // 20548: check Inst[25] == 0x1
11103 OPC_Decode, 180, 127, 163, 1, // 20552: decode to VGHSH_VV using decoder 163
11104 // 20552: }
11105 // 20552: } // switch Inst[14:12]
11106 // 20552: }
11107 45, 17, // 20557: case 0x2d: {
11108 OPC_CheckPredicate, 132, 1, // 20559: check predicate 132
11109 OPC_CheckField, 25, 1, 1, // 20562: check Inst[25] == 0x1
11110 OPC_CheckField, 12, 3, 2, // 20566: check Inst[14:12] == 0x2
11111 OPC_Decode, 169, 130, 1, 163, 1, // 20570: decode to VSHA2MS_VV using decoder 163
11112 // 20570: }
11113 46, 39, // 20576: case 0x2e: {
11114 OPC_SwitchField, 12, 3, // 20578: switch Inst[14:12] {
11115 0, 9, // 20581: case 0x0: {
11116 OPC_CheckPredicate, 133, 1, // 20583: check predicate 133
11117 OPC_Decode, 246, 129, 1, 166, 1, // 20586: decode to VQWBDOTAU_VV using decoder 166
11118 // 20586: }
11119 1, 8, // 20592: case 0x1: {
11120 OPC_CheckPredicate, 134, 1, // 20594: check predicate 134
11121 OPC_Decode, 246, 126, 166, 1, // 20597: decode to VFQWBDOTA_VV using decoder 166
11122 // 20597: }
11123 2, 0, // 20602: case 0x2: {
11124 OPC_CheckPredicate, 132, 1, // 20604: check predicate 132
11125 OPC_CheckField, 25, 1, 1, // 20607: check Inst[25] == 0x1
11126 OPC_Decode, 167, 130, 1, 163, 1, // 20611: decode to VSHA2CH_VV using decoder 163
11127 // 20611: }
11128 // 20611: } // switch Inst[14:12]
11129 // 20611: }
11130 47, 0, // 20617: case 0x2f: {
11131 OPC_SwitchField, 12, 3, // 20619: switch Inst[14:12] {
11132 0, 9, // 20622: case 0x0: {
11133 OPC_CheckPredicate, 133, 1, // 20624: check predicate 133
11134 OPC_Decode, 245, 129, 1, 166, 1, // 20627: decode to VQWBDOTAS_VV using decoder 166
11135 // 20627: }
11136 1, 8, // 20633: case 0x1: {
11137 OPC_CheckPredicate, 134, 1, // 20635: check predicate 134
11138 OPC_Decode, 245, 126, 166, 1, // 20638: decode to VFQWBDOTA_ALT_VV using decoder 166
11139 // 20638: }
11140 2, 0, // 20643: case 0x2: {
11141 OPC_CheckPredicate, 132, 1, // 20645: check predicate 132
11142 OPC_CheckField, 25, 1, 1, // 20648: check Inst[25] == 0x1
11143 OPC_Decode, 168, 130, 1, 163, 1, // 20652: decode to VSHA2CL_VV using decoder 163
11144 // 20652: }
11145 // 20652: } // switch Inst[14:12]
11146 // 20652: }
11147 // 20652: } // switch Inst[31:26]
11148 // 20652: }
11149 123, 0, // 20658: case 0x7b: {
11150 OPC_SwitchField, 12, 3, // 20660: switch Inst[14:12] {
11151 0, 212, 1, // 20663: case 0x0: {
11152 OPC_SwitchField, 25, 7, // 20666: switch Inst[31:25] {
11153 1, 8, // 20669: case 0x1: {
11154 OPC_CheckPredicate, 135, 1, // 20671: check predicate 135
11155 OPC_Decode, 225, 118, 167, 1, // 20674: decode to PACKY using decoder 167
11156 // 20674: }
11157 3, 24, // 20679: case 0x3: {
11158 OPC_Scope, 13, // 20681: try {
11159 OPC_CheckField, 20, 5, 0, // 20683: check Inst[24:20] == 0x0
11160 OPC_CheckPredicate, 135, 1, // 20687: check predicate 135
11161 OPC_Decode, 161, 132, 1, 168, 1, // 20690: decode to YMV using decoder 168
11162 // 20690: } else try {
11163 OPC_CheckPredicate, 135, 1, // 20696: check predicate 135
11164 OPC_Decode, 150, 132, 1, 169, 1, // 20699: decode to YADD using decoder 169
11165 // 20699: }
11166 // 20699: }
11167 6, 9, // 20705: case 0x6: {
11168 OPC_CheckPredicate, 135, 1, // 20707: check predicate 135
11169 OPC_Decode, 159, 132, 1, 170, 1, // 20710: decode to YEQ using decoder 170
11170 // 20710: }
11171 7, 9, // 20716: case 0x7: {
11172 OPC_CheckPredicate, 135, 1, // 20718: check predicate 135
11173 OPC_Decode, 165, 132, 1, 171, 1, // 20721: decode to YSUNSEAL using decoder 171
11174 // 20721: }
11175 11, 9, // 20727: case 0xb: {
11176 OPC_CheckPredicate, 135, 1, // 20729: check predicate 135
11177 OPC_Decode, 152, 132, 1, 167, 1, // 20732: decode to YADDRW using decoder 167
11178 // 20732: }
11179 14, 9, // 20738: case 0xe: {
11180 OPC_CheckPredicate, 135, 1, // 20740: check predicate 135
11181 OPC_Decode, 164, 132, 1, 170, 1, // 20743: decode to YSS using decoder 170
11182 // 20743: }
11183 15, 9, // 20749: case 0xf: {
11184 OPC_CheckPredicate, 135, 1, // 20751: check predicate 135
11185 OPC_Decode, 155, 132, 1, 171, 1, // 20754: decode to YBLD using decoder 171
11186 // 20754: }
11187 19, 9, // 20760: case 0x13: {
11188 OPC_CheckPredicate, 135, 1, // 20762: check predicate 135
11189 OPC_Decode, 162, 132, 1, 167, 1, // 20765: decode to YPERMC using decoder 167
11190 // 20765: }
11191 27, 9, // 20771: case 0x1b: {
11192 OPC_CheckPredicate, 135, 1, // 20773: check predicate 135
11193 OPC_Decode, 157, 132, 1, 167, 1, // 20776: decode to YBNDSW using decoder 167
11194 // 20776: }
11195 35, 9, // 20782: case 0x23: {
11196 OPC_CheckPredicate, 135, 1, // 20784: check predicate 135
11197 OPC_Decode, 156, 132, 1, 167, 1, // 20787: decode to YBNDSRW using decoder 167
11198 // 20787: }
11199 120, 12, // 20793: case 0x78: {
11200 OPC_CheckPredicate, 135, 1, // 20795: check predicate 135
11201 OPC_CheckField, 20, 5, 0, // 20798: check Inst[24:20] == 0x0
11202 OPC_Decode, 153, 132, 1, 17, // 20802: decode to YAMASK using decoder 17
11203 // 20802: }
11204 122, 0, // 20807: case 0x7a: {
11205 OPC_SwitchField, 20, 5, // 20809: switch Inst[24:20] {
11206 0, 9, // 20812: case 0x0: {
11207 OPC_CheckPredicate, 135, 1, // 20814: check predicate 135
11208 OPC_Decode, 154, 132, 1, 172, 1, // 20817: decode to YBASER using decoder 172
11209 // 20817: }
11210 1, 9, // 20823: case 0x1: {
11211 OPC_CheckPredicate, 135, 1, // 20825: check predicate 135
11212 OPC_Decode, 163, 132, 1, 172, 1, // 20828: decode to YPERMR using decoder 172
11213 // 20828: }
11214 2, 9, // 20834: case 0x2: {
11215 OPC_CheckPredicate, 135, 1, // 20836: check predicate 135
11216 OPC_Decode, 167, 132, 1, 172, 1, // 20839: decode to YTOPR using decoder 172
11217 // 20839: }
11218 3, 9, // 20845: case 0x3: {
11219 OPC_CheckPredicate, 135, 1, // 20847: check predicate 135
11220 OPC_Decode, 160, 132, 1, 172, 1, // 20850: decode to YLENR using decoder 172
11221 // 20850: }
11222 4, 9, // 20856: case 0x4: {
11223 OPC_CheckPredicate, 135, 1, // 20858: check predicate 135
11224 OPC_Decode, 166, 132, 1, 172, 1, // 20861: decode to YTAGR using decoder 172
11225 // 20861: }
11226 5, 0, // 20867: case 0x5: {
11227 OPC_CheckPredicate, 135, 1, // 20869: check predicate 135
11228 OPC_Decode, 168, 132, 1, 172, 1, // 20872: decode to YTYPER using decoder 172
11229 // 20872: }
11230 // 20872: } // switch Inst[24:20]
11231 // 20872: }
11232 // 20872: } // switch Inst[31:25]
11233 // 20872: }
11234 4, 9, // 20878: case 0x4: {
11235 OPC_CheckPredicate, 135, 1, // 20880: check predicate 135
11236 OPC_Decode, 151, 132, 1, 173, 1, // 20883: decode to YADDI using decoder 173
11237 // 20883: }
11238 5, 0, // 20889: case 0x5: {
11239 OPC_SwitchField, 29, 3, // 20891: switch Inst[31:29] {
11240 0, 12, // 20894: case 0x0: {
11241 OPC_CheckPredicate, 135, 1, // 20896: check predicate 135
11242 OPC_CheckField, 27, 2, 0, // 20899: check Inst[28:27] == 0x0
11243 OPC_Decode, 240, 124, 174, 1, // 20903: decode to SRLIY using decoder 174
11244 // 20903: }
11245 7, 0, // 20908: case 0x7: {
11246 OPC_CheckPredicate, 135, 1, // 20910: check predicate 135
11247 OPC_Decode, 158, 132, 1, 175, 1, // 20913: decode to YBNDSWI using decoder 175
11248 // 20913: }
11249 // 20913: } // switch Inst[31:29]
11250 // 20913: }
11251 // 20913: } // switch Inst[14:12]
11252 // 20913: }
11253 // 20913: } // switch Inst[6:0]
11254};
11255static const uint8_t DecoderTableRV32Only32[795] = {
11256 32, // 0: BitWidth 32
11257 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
11258 0, 99, // 4: case 0x0: {
11259 OPC_SwitchField, 25, 7, // 6: switch Inst[31:25] {
11260 73, 10, // 9: case 0x49: {
11261 OPC_CheckPredicate, 46, // 11: check predicate 46
11262 OPC_CheckField, 0, 7, 59, // 13: check Inst[6:0] == 0x3b
11263 OPC_Decode, 203, 123, 31, // 17: decode to SADD using decoder 31
11264 // 17: }
11265 77, 10, // 21: case 0x4d: {
11266 OPC_CheckPredicate, 46, // 23: check predicate 46
11267 OPC_CheckField, 0, 7, 59, // 25: check Inst[6:0] == 0x3b
11268 OPC_Decode, 186, 107, 31, // 29: decode to AADD using decoder 31
11269 // 29: }
11270 89, 10, // 33: case 0x59: {
11271 OPC_CheckPredicate, 46, // 35: check predicate 46
11272 OPC_CheckField, 0, 7, 59, // 37: check Inst[6:0] == 0x3b
11273 OPC_Decode, 204, 123, 31, // 41: decode to SADDU using decoder 31
11274 // 41: }
11275 93, 10, // 45: case 0x5d: {
11276 OPC_CheckPredicate, 46, // 47: check predicate 46
11277 OPC_CheckField, 0, 7, 59, // 49: check Inst[6:0] == 0x3b
11278 OPC_Decode, 187, 107, 31, // 53: decode to AADDU using decoder 31
11279 // 53: }
11280 105, 10, // 57: case 0x69: {
11281 OPC_CheckPredicate, 46, // 59: check predicate 46
11282 OPC_CheckField, 0, 7, 59, // 61: check Inst[6:0] == 0x3b
11283 OPC_Decode, 132, 125, 31, // 65: decode to SSUB using decoder 31
11284 // 65: }
11285 109, 10, // 69: case 0x6d: {
11286 OPC_CheckPredicate, 46, // 71: check predicate 46
11287 OPC_CheckField, 0, 7, 59, // 73: check Inst[6:0] == 0x3b
11288 OPC_Decode, 207, 110, 31, // 77: decode to ASUB using decoder 31
11289 // 77: }
11290 121, 10, // 81: case 0x79: {
11291 OPC_CheckPredicate, 46, // 83: check predicate 46
11292 OPC_CheckField, 0, 7, 59, // 85: check Inst[6:0] == 0x3b
11293 OPC_Decode, 133, 125, 31, // 89: decode to SSUBU using decoder 31
11294 // 89: }
11295 125, 0, // 93: case 0x7d: {
11296 OPC_CheckPredicate, 46, // 95: check predicate 46
11297 OPC_CheckField, 0, 7, 59, // 97: check Inst[6:0] == 0x3b
11298 OPC_Decode, 208, 110, 31, // 101: decode to ASUBU using decoder 31
11299 // 101: }
11300 // 101: } // switch Inst[31:25]
11301 // 101: }
11302 1, 51, // 105: case 0x1: {
11303 OPC_SwitchField, 25, 7, // 107: switch Inst[31:25] {
11304 73, 10, // 110: case 0x49: {
11305 OPC_CheckPredicate, 46, // 112: check predicate 46
11306 OPC_CheckField, 0, 7, 59, // 114: check Inst[6:0] == 0x3b
11307 OPC_Decode, 253, 117, 31, // 118: decode to MUL_H01 using decoder 31
11308 // 118: }
11309 77, 10, // 122: case 0x4d: {
11310 OPC_CheckPredicate, 46, // 124: check predicate 46
11311 OPC_CheckField, 0, 7, 59, // 126: check Inst[6:0] == 0x3b
11312 OPC_Decode, 137, 117, 61, // 130: decode to MACC_H01 using decoder 61
11313 // 130: }
11314 89, 10, // 134: case 0x59: {
11315 OPC_CheckPredicate, 46, // 136: check predicate 46
11316 OPC_CheckField, 0, 7, 59, // 138: check Inst[6:0] == 0x3b
11317 OPC_Decode, 246, 117, 31, // 142: decode to MULU_H01 using decoder 31
11318 // 142: }
11319 93, 0, // 146: case 0x5d: {
11320 OPC_CheckPredicate, 46, // 148: check predicate 46
11321 OPC_CheckField, 0, 7, 59, // 150: check Inst[6:0] == 0x3b
11322 OPC_Decode, 131, 117, 61, // 154: decode to MACCU_H01 using decoder 61
11323 // 154: }
11324 // 154: } // switch Inst[31:25]
11325 // 154: }
11326 2, 75, // 158: case 0x2: {
11327 OPC_SwitchField, 25, 7, // 160: switch Inst[31:25] {
11328 85, 10, // 163: case 0x55: {
11329 OPC_CheckPredicate, 46, // 165: check predicate 46
11330 OPC_CheckField, 0, 7, 27, // 167: check Inst[6:0] == 0x1b
11331 OPC_Decode, 254, 124, 31, // 171: decode to SSHL using decoder 31
11332 // 171: }
11333 89, 10, // 175: case 0x59: {
11334 OPC_CheckPredicate, 46, // 177: check predicate 46
11335 OPC_CheckField, 0, 7, 59, // 179: check Inst[6:0] == 0x3b
11336 OPC_Decode, 251, 124, 31, // 183: decode to SSH1SADD using decoder 31
11337 // 183: }
11338 93, 10, // 187: case 0x5d: {
11339 OPC_CheckPredicate, 46, // 189: check predicate 46
11340 OPC_CheckField, 0, 7, 27, // 191: check Inst[6:0] == 0x1b
11341 OPC_Decode, 255, 124, 31, // 195: decode to SSHLR using decoder 31
11342 // 195: }
11343 105, 10, // 199: case 0x69: {
11344 OPC_CheckPredicate, 46, // 201: check predicate 46
11345 OPC_CheckField, 0, 7, 27, // 203: check Inst[6:0] == 0x1b
11346 OPC_Decode, 128, 125, 21, // 207: decode to SSLAI using decoder 21
11347 // 207: }
11348 117, 10, // 211: case 0x75: {
11349 OPC_CheckPredicate, 46, // 213: check predicate 46
11350 OPC_CheckField, 0, 7, 27, // 215: check Inst[6:0] == 0x1b
11351 OPC_Decode, 252, 124, 31, // 219: decode to SSHA using decoder 31
11352 // 219: }
11353 125, 0, // 223: case 0x7d: {
11354 OPC_CheckPredicate, 46, // 225: check predicate 46
11355 OPC_CheckField, 0, 7, 27, // 227: check Inst[6:0] == 0x1b
11356 OPC_Decode, 253, 124, 31, // 231: decode to SSHAR using decoder 31
11357 // 231: }
11358 // 231: } // switch Inst[31:25]
11359 // 231: }
11360 3, 165, 1, // 235: case 0x3: {
11361 OPC_SwitchField, 0, 7, // 238: switch Inst[6:0] {
11362 3, 8, // 241: case 0x3: {
11363 OPC_CheckPredicate, 136, 1, // 243: check predicate 136
11364 OPC_Decode, 215, 116, 176, 1, // 246: decode to LD_RV32 using decoder 176
11365 // 246: }
11366 35, 8, // 251: case 0x23: {
11367 OPC_CheckPredicate, 136, 1, // 253: check predicate 136
11368 OPC_Decode, 224, 123, 177, 1, // 256: decode to SD_RV32 using decoder 177
11369 // 256: }
11370 47, 39, // 261: case 0x2f: {
11371 OPC_SwitchField, 25, 7, // 263: switch Inst[31:25] {
11372 20, 7, // 266: case 0x14: {
11373 OPC_CheckPredicate, 137, 1, // 268: check predicate 137
11374 OPC_Decode, 200, 109, 58, // 271: decode to AMOCAS_D_RV32 using decoder 58
11375 // 271: }
11376 21, 7, // 275: case 0x15: {
11377 OPC_CheckPredicate, 137, 1, // 277: check predicate 137
11378 OPC_Decode, 203, 109, 58, // 280: decode to AMOCAS_D_RV32_RL using decoder 58
11379 // 280: }
11380 22, 7, // 284: case 0x16: {
11381 OPC_CheckPredicate, 137, 1, // 286: check predicate 137
11382 OPC_Decode, 201, 109, 58, // 289: decode to AMOCAS_D_RV32_AQ using decoder 58
11383 // 289: }
11384 23, 0, // 293: case 0x17: {
11385 OPC_CheckPredicate, 137, 1, // 295: check predicate 137
11386 OPC_Decode, 202, 109, 58, // 298: decode to AMOCAS_D_RV32_AQRL using decoder 58
11387 // 298: }
11388 // 298: } // switch Inst[31:25]
11389 // 298: }
11390 59, 0, // 302: case 0x3b: {
11391 OPC_SwitchField, 25, 7, // 304: switch Inst[31:25] {
11392 65, 6, // 307: case 0x41: {
11393 OPC_CheckPredicate, 46, // 309: check predicate 46
11394 OPC_Decode, 252, 117, 31, // 311: decode to MUL_H00 using decoder 31
11395 // 311: }
11396 69, 6, // 315: case 0x45: {
11397 OPC_CheckPredicate, 46, // 317: check predicate 46
11398 OPC_Decode, 136, 117, 61, // 319: decode to MACC_H00 using decoder 61
11399 // 319: }
11400 73, 6, // 323: case 0x49: {
11401 OPC_CheckPredicate, 46, // 325: check predicate 46
11402 OPC_Decode, 254, 117, 31, // 327: decode to MUL_H11 using decoder 31
11403 // 327: }
11404 77, 6, // 331: case 0x4d: {
11405 OPC_CheckPredicate, 46, // 333: check predicate 46
11406 OPC_Decode, 138, 117, 61, // 335: decode to MACC_H11 using decoder 61
11407 // 335: }
11408 81, 6, // 339: case 0x51: {
11409 OPC_CheckPredicate, 46, // 341: check predicate 46
11410 OPC_Decode, 245, 117, 31, // 343: decode to MULU_H00 using decoder 31
11411 // 343: }
11412 85, 6, // 347: case 0x55: {
11413 OPC_CheckPredicate, 46, // 349: check predicate 46
11414 OPC_Decode, 130, 117, 61, // 351: decode to MACCU_H00 using decoder 61
11415 // 351: }
11416 89, 6, // 355: case 0x59: {
11417 OPC_CheckPredicate, 46, // 357: check predicate 46
11418 OPC_Decode, 247, 117, 31, // 359: decode to MULU_H11 using decoder 31
11419 // 359: }
11420 93, 6, // 363: case 0x5d: {
11421 OPC_CheckPredicate, 46, // 365: check predicate 46
11422 OPC_Decode, 132, 117, 61, // 367: decode to MACCU_H11 using decoder 61
11423 // 367: }
11424 113, 6, // 371: case 0x71: {
11425 OPC_CheckPredicate, 46, // 373: check predicate 46
11426 OPC_Decode, 241, 117, 31, // 375: decode to MULSU_H00 using decoder 31
11427 // 375: }
11428 117, 6, // 379: case 0x75: {
11429 OPC_CheckPredicate, 46, // 381: check predicate 46
11430 OPC_Decode, 254, 116, 61, // 383: decode to MACCSU_H00 using decoder 61
11431 // 383: }
11432 121, 6, // 387: case 0x79: {
11433 OPC_CheckPredicate, 46, // 389: check predicate 46
11434 OPC_Decode, 242, 117, 31, // 391: decode to MULSU_H11 using decoder 31
11435 // 391: }
11436 125, 0, // 395: case 0x7d: {
11437 OPC_CheckPredicate, 46, // 397: check predicate 46
11438 OPC_Decode, 255, 116, 61, // 399: decode to MACCSU_H11 using decoder 61
11439 // 399: }
11440 // 399: } // switch Inst[31:25]
11441 // 399: }
11442 // 399: } // switch Inst[6:0]
11443 // 399: }
11444 4, 39, // 403: case 0x4: {
11445 OPC_SwitchField, 25, 7, // 405: switch Inst[31:25] {
11446 81, 10, // 408: case 0x51: {
11447 OPC_CheckPredicate, 46, // 410: check predicate 46
11448 OPC_CheckField, 0, 7, 27, // 412: check Inst[6:0] == 0x1b
11449 OPC_Decode, 128, 126, 21, // 416: decode to USATI_RV32 using decoder 21
11450 // 416: }
11451 105, 10, // 420: case 0x69: {
11452 OPC_CheckPredicate, 46, // 422: check predicate 46
11453 OPC_CheckField, 0, 7, 27, // 424: check Inst[6:0] == 0x1b
11454 OPC_Decode, 233, 124, 21, // 428: decode to SRARI_RV32 using decoder 21
11455 // 428: }
11456 113, 0, // 432: case 0x71: {
11457 OPC_CheckPredicate, 46, // 434: check predicate 46
11458 OPC_CheckField, 0, 7, 27, // 436: check Inst[6:0] == 0x1b
11459 OPC_Decode, 205, 123, 41, // 440: decode to SATI_RV32 using decoder 41
11460 // 440: }
11461 // 440: } // switch Inst[31:25]
11462 // 440: }
11463 5, 27, // 444: case 0x5: {
11464 OPC_SwitchField, 25, 7, // 446: switch Inst[31:25] {
11465 124, 10, // 449: case 0x7c: {
11466 OPC_CheckPredicate, 46, // 451: check predicate 46
11467 OPC_CheckField, 0, 7, 59, // 453: check Inst[6:0] == 0x3b
11468 OPC_Decode, 211, 117, 61, // 457: decode to MQACC_H01 using decoder 61
11469 // 457: }
11470 126, 0, // 461: case 0x7e: {
11471 OPC_CheckPredicate, 46, // 463: check predicate 46
11472 OPC_CheckField, 0, 7, 59, // 465: check Inst[6:0] == 0x3b
11473 OPC_Decode, 217, 117, 61, // 469: decode to MQRACC_H01 using decoder 61
11474 // 469: }
11475 // 469: } // switch Inst[31:25]
11476 // 469: }
11477 6, 39, // 473: case 0x6: {
11478 OPC_SwitchField, 25, 7, // 475: switch Inst[31:25] {
11479 97, 10, // 478: case 0x61: {
11480 OPC_CheckPredicate, 46, // 480: check predicate 46
11481 OPC_CheckField, 0, 7, 59, // 482: check Inst[6:0] == 0x3b
11482 OPC_Decode, 225, 117, 31, // 486: decode to MSEQ using decoder 31
11483 // 486: }
11484 105, 10, // 490: case 0x69: {
11485 OPC_CheckPredicate, 46, // 492: check predicate 46
11486 OPC_CheckField, 0, 7, 59, // 494: check Inst[6:0] == 0x3b
11487 OPC_Decode, 226, 117, 31, // 498: decode to MSLT using decoder 31
11488 // 498: }
11489 109, 0, // 502: case 0x6d: {
11490 OPC_CheckPredicate, 46, // 504: check predicate 46
11491 OPC_CheckField, 0, 7, 59, // 506: check Inst[6:0] == 0x3b
11492 OPC_Decode, 227, 117, 31, // 510: decode to MSLTU using decoder 31
11493 // 510: }
11494 // 510: } // switch Inst[31:25]
11495 // 510: }
11496 7, 0, // 514: case 0x7: {
11497 OPC_SwitchField, 25, 7, // 516: switch Inst[31:25] {
11498 67, 10, // 519: case 0x43: {
11499 OPC_CheckPredicate, 46, // 521: check predicate 46
11500 OPC_CheckField, 0, 7, 59, // 523: check Inst[6:0] == 0x3b
11501 OPC_Decode, 230, 117, 31, // 527: decode to MULHR using decoder 31
11502 // 527: }
11503 69, 10, // 531: case 0x45: {
11504 OPC_CheckPredicate, 46, // 533: check predicate 46
11505 OPC_CheckField, 0, 7, 59, // 535: check Inst[6:0] == 0x3b
11506 OPC_Decode, 147, 117, 61, // 539: decode to MHACC using decoder 61
11507 // 539: }
11508 71, 10, // 543: case 0x47: {
11509 OPC_CheckPredicate, 46, // 545: check predicate 46
11510 OPC_CheckField, 0, 7, 59, // 547: check Inst[6:0] == 0x3b
11511 OPC_Decode, 154, 117, 61, // 551: decode to MHRACC using decoder 61
11512 // 551: }
11513 75, 10, // 555: case 0x4b: {
11514 OPC_CheckPredicate, 46, // 557: check predicate 46
11515 OPC_CheckField, 0, 7, 59, // 559: check Inst[6:0] == 0x3b
11516 OPC_Decode, 232, 117, 31, // 563: decode to MULHRU using decoder 31
11517 // 563: }
11518 77, 10, // 567: case 0x4d: {
11519 OPC_CheckPredicate, 46, // 569: check predicate 46
11520 OPC_CheckField, 0, 7, 59, // 571: check Inst[6:0] == 0x3b
11521 OPC_Decode, 151, 117, 61, // 575: decode to MHACCU using decoder 61
11522 // 575: }
11523 79, 10, // 579: case 0x4f: {
11524 OPC_CheckPredicate, 46, // 581: check predicate 46
11525 OPC_CheckField, 0, 7, 59, // 583: check Inst[6:0] == 0x3b
11526 OPC_Decode, 156, 117, 61, // 587: decode to MHRACCU using decoder 61
11527 // 587: }
11528 81, 10, // 591: case 0x51: {
11529 OPC_CheckPredicate, 46, // 593: check predicate 46
11530 OPC_CheckField, 0, 7, 59, // 595: check Inst[6:0] == 0x3b
11531 OPC_Decode, 237, 117, 31, // 599: decode to MULH_H0 using decoder 31
11532 // 599: }
11533 83, 10, // 603: case 0x53: {
11534 OPC_CheckPredicate, 46, // 605: check predicate 46
11535 OPC_CheckField, 0, 7, 59, // 607: check Inst[6:0] == 0x3b
11536 OPC_Decode, 234, 117, 31, // 611: decode to MULHSU_H0 using decoder 31
11537 // 611: }
11538 85, 10, // 615: case 0x55: {
11539 OPC_CheckPredicate, 46, // 617: check predicate 46
11540 OPC_CheckField, 0, 7, 59, // 619: check Inst[6:0] == 0x3b
11541 OPC_Decode, 152, 117, 61, // 623: decode to MHACC_H0 using decoder 61
11542 // 623: }
11543 87, 10, // 627: case 0x57: {
11544 OPC_CheckPredicate, 46, // 629: check predicate 46
11545 OPC_CheckField, 0, 7, 59, // 631: check Inst[6:0] == 0x3b
11546 OPC_Decode, 149, 117, 61, // 635: decode to MHACCSU_H0 using decoder 61
11547 // 635: }
11548 89, 10, // 639: case 0x59: {
11549 OPC_CheckPredicate, 46, // 641: check predicate 46
11550 OPC_CheckField, 0, 7, 59, // 643: check Inst[6:0] == 0x3b
11551 OPC_Decode, 238, 117, 31, // 647: decode to MULH_H1 using decoder 31
11552 // 647: }
11553 91, 10, // 651: case 0x5b: {
11554 OPC_CheckPredicate, 46, // 653: check predicate 46
11555 OPC_CheckField, 0, 7, 59, // 655: check Inst[6:0] == 0x3b
11556 OPC_Decode, 235, 117, 31, // 659: decode to MULHSU_H1 using decoder 31
11557 // 659: }
11558 93, 10, // 663: case 0x5d: {
11559 OPC_CheckPredicate, 46, // 665: check predicate 46
11560 OPC_CheckField, 0, 7, 59, // 667: check Inst[6:0] == 0x3b
11561 OPC_Decode, 153, 117, 61, // 671: decode to MHACC_H1 using decoder 61
11562 // 671: }
11563 95, 10, // 675: case 0x5f: {
11564 OPC_CheckPredicate, 46, // 677: check predicate 46
11565 OPC_CheckField, 0, 7, 59, // 679: check Inst[6:0] == 0x3b
11566 OPC_Decode, 150, 117, 61, // 683: decode to MHACCSU_H1 using decoder 61
11567 // 683: }
11568 99, 10, // 687: case 0x63: {
11569 OPC_CheckPredicate, 46, // 689: check predicate 46
11570 OPC_CheckField, 0, 7, 59, // 691: check Inst[6:0] == 0x3b
11571 OPC_Decode, 231, 117, 31, // 695: decode to MULHRSU using decoder 31
11572 // 695: }
11573 101, 10, // 699: case 0x65: {
11574 OPC_CheckPredicate, 46, // 701: check predicate 46
11575 OPC_CheckField, 0, 7, 59, // 703: check Inst[6:0] == 0x3b
11576 OPC_Decode, 148, 117, 61, // 707: decode to MHACCSU using decoder 61
11577 // 707: }
11578 103, 10, // 711: case 0x67: {
11579 OPC_CheckPredicate, 46, // 713: check predicate 46
11580 OPC_CheckField, 0, 7, 59, // 715: check Inst[6:0] == 0x3b
11581 OPC_Decode, 155, 117, 61, // 719: decode to MHRACCSU using decoder 61
11582 // 719: }
11583 105, 10, // 723: case 0x69: {
11584 OPC_CheckPredicate, 46, // 725: check predicate 46
11585 OPC_CheckField, 0, 7, 59, // 727: check Inst[6:0] == 0x3b
11586 OPC_Decode, 239, 117, 31, // 731: decode to MULQ using decoder 31
11587 // 731: }
11588 107, 10, // 735: case 0x6b: {
11589 OPC_CheckPredicate, 46, // 737: check predicate 46
11590 OPC_CheckField, 0, 7, 59, // 739: check Inst[6:0] == 0x3b
11591 OPC_Decode, 240, 117, 31, // 743: decode to MULQR using decoder 31
11592 // 743: }
11593 116, 10, // 747: case 0x74: {
11594 OPC_CheckPredicate, 46, // 749: check predicate 46
11595 OPC_CheckField, 0, 7, 59, // 751: check Inst[6:0] == 0x3b
11596 OPC_Decode, 210, 117, 61, // 755: decode to MQACC_H00 using decoder 61
11597 // 755: }
11598 118, 10, // 759: case 0x76: {
11599 OPC_CheckPredicate, 46, // 761: check predicate 46
11600 OPC_CheckField, 0, 7, 59, // 763: check Inst[6:0] == 0x3b
11601 OPC_Decode, 216, 117, 61, // 767: decode to MQRACC_H00 using decoder 61
11602 // 767: }
11603 124, 10, // 771: case 0x7c: {
11604 OPC_CheckPredicate, 46, // 773: check predicate 46
11605 OPC_CheckField, 0, 7, 59, // 775: check Inst[6:0] == 0x3b
11606 OPC_Decode, 212, 117, 61, // 779: decode to MQACC_H11 using decoder 61
11607 // 779: }
11608 126, 0, // 783: case 0x7e: {
11609 OPC_CheckPredicate, 46, // 785: check predicate 46
11610 OPC_CheckField, 0, 7, 59, // 787: check Inst[6:0] == 0x3b
11611 OPC_Decode, 218, 117, 61, // 791: decode to MQRACC_H11 using decoder 61
11612 // 791: }
11613 // 791: } // switch Inst[31:25]
11614 // 791: }
11615 // 791: } // switch Inst[14:12]
11616};
11617static const uint8_t DecoderTableXAIF32[2612] = {
11618 32, // 0: BitWidth 32
11619 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
11620 7, 12, // 4: case 0x7: {
11621 OPC_CheckPredicate, 138, 1, // 6: check predicate 138
11622 OPC_CheckField, 12, 3, 5, // 9: check Inst[14:12] == 0x5
11623 OPC_Decode, 208, 108, 178, 1, // 13: decode to AIF_FLQ2 using decoder 178
11624 // 13: }
11625 11, 195, 4, // 18: case 0xb: {
11626 OPC_SwitchField, 12, 3, // 21: switch Inst[14:12] {
11627 0, 8, // 24: case 0x0: {
11628 OPC_CheckPredicate, 138, 1, // 26: check predicate 138
11629 OPC_Decode, 154, 108, 178, 1, // 29: decode to AIF_FBC_PS using decoder 178
11630 // 29: }
11631 1, 123, // 34: case 0x1: {
11632 OPC_SwitchField, 25, 7, // 36: switch Inst[31:25] {
11633 4, 8, // 39: case 0x4: {
11634 OPC_CheckPredicate, 138, 1, // 41: check predicate 138
11635 OPC_Decode, 192, 108, 179, 1, // 44: decode to AIF_FG32B_PS using decoder 179
11636 // 44: }
11637 8, 8, // 49: case 0x8: {
11638 OPC_CheckPredicate, 138, 1, // 51: check predicate 138
11639 OPC_Decode, 193, 108, 179, 1, // 54: decode to AIF_FG32H_PS using decoder 179
11640 // 54: }
11641 16, 8, // 59: case 0x10: {
11642 OPC_CheckPredicate, 138, 1, // 61: check predicate 138
11643 OPC_Decode, 194, 108, 179, 1, // 64: decode to AIF_FG32W_PS using decoder 179
11644 // 64: }
11645 36, 8, // 69: case 0x24: {
11646 OPC_CheckPredicate, 138, 1, // 71: check predicate 138
11647 OPC_Decode, 197, 108, 180, 1, // 74: decode to AIF_FGB_PS using decoder 180
11648 // 74: }
11649 40, 8, // 79: case 0x28: {
11650 OPC_CheckPredicate, 138, 1, // 81: check predicate 138
11651 OPC_Decode, 200, 108, 180, 1, // 84: decode to AIF_FGH_PS using decoder 180
11652 // 84: }
11653 48, 8, // 89: case 0x30: {
11654 OPC_CheckPredicate, 138, 1, // 91: check predicate 138
11655 OPC_Decode, 203, 108, 180, 1, // 94: decode to AIF_FGW_PS using decoder 180
11656 // 94: }
11657 68, 8, // 99: case 0x44: {
11658 OPC_CheckPredicate, 138, 1, // 101: check predicate 138
11659 OPC_Decode, 245, 108, 179, 1, // 104: decode to AIF_FSC32B_PS using decoder 179
11660 // 104: }
11661 72, 8, // 109: case 0x48: {
11662 OPC_CheckPredicate, 138, 1, // 111: check predicate 138
11663 OPC_Decode, 246, 108, 179, 1, // 114: decode to AIF_FSC32H_PS using decoder 179
11664 // 114: }
11665 80, 8, // 119: case 0x50: {
11666 OPC_CheckPredicate, 138, 1, // 121: check predicate 138
11667 OPC_Decode, 247, 108, 179, 1, // 124: decode to AIF_FSC32W_PS using decoder 179
11668 // 124: }
11669 100, 8, // 129: case 0x64: {
11670 OPC_CheckPredicate, 138, 1, // 131: check predicate 138
11671 OPC_Decode, 250, 108, 180, 1, // 134: decode to AIF_FSCB_PS using decoder 180
11672 // 134: }
11673 104, 8, // 139: case 0x68: {
11674 OPC_CheckPredicate, 138, 1, // 141: check predicate 138
11675 OPC_Decode, 253, 108, 180, 1, // 144: decode to AIF_FSCH_PS using decoder 180
11676 // 144: }
11677 112, 0, // 149: case 0x70: {
11678 OPC_CheckPredicate, 138, 1, // 151: check predicate 138
11679 OPC_Decode, 128, 109, 180, 1, // 154: decode to AIF_FSCW_PS using decoder 180
11680 // 154: }
11681 // 154: } // switch Inst[31:25]
11682 // 154: }
11683 2, 8, // 159: case 0x2: {
11684 OPC_CheckPredicate, 138, 1, // 161: check predicate 138
11685 OPC_Decode, 216, 108, 178, 1, // 164: decode to AIF_FLW_PS using decoder 178
11686 // 164: }
11687 3, 12, // 169: case 0x3: {
11688 OPC_CheckPredicate, 138, 1, // 171: check predicate 138
11689 OPC_CheckField, 20, 12, 0, // 174: check Inst[31:20] == 0x0
11690 OPC_Decode, 153, 108, 181, 1, // 178: decode to AIF_FBCX_PS using decoder 181
11691 // 178: }
11692 4, 223, 1, // 183: case 0x4: {
11693 OPC_SwitchField, 25, 7, // 186: switch Inst[31:25] {
11694 3, 8, // 189: case 0x3: {
11695 OPC_CheckPredicate, 138, 1, // 191: check predicate 138
11696 OPC_Decode, 128, 108, 180, 1, // 194: decode to AIF_FAMOADDL_PI using decoder 180
11697 // 194: }
11698 7, 8, // 199: case 0x7: {
11699 OPC_CheckPredicate, 138, 1, // 201: check predicate 138
11700 OPC_Decode, 146, 108, 180, 1, // 204: decode to AIF_FAMOSWAPL_PI using decoder 180
11701 // 204: }
11702 11, 8, // 209: case 0xb: {
11703 OPC_CheckPredicate, 138, 1, // 211: check predicate 138
11704 OPC_Decode, 130, 108, 180, 1, // 214: decode to AIF_FAMOANDL_PI using decoder 180
11705 // 214: }
11706 15, 8, // 219: case 0xf: {
11707 OPC_CheckPredicate, 138, 1, // 221: check predicate 138
11708 OPC_Decode, 144, 108, 180, 1, // 224: decode to AIF_FAMOORL_PI using decoder 180
11709 // 224: }
11710 19, 8, // 229: case 0x13: {
11711 OPC_CheckPredicate, 138, 1, // 231: check predicate 138
11712 OPC_Decode, 148, 108, 180, 1, // 234: decode to AIF_FAMOXORL_PI using decoder 180
11713 // 234: }
11714 20, 8, // 239: case 0x14: {
11715 OPC_CheckPredicate, 138, 1, // 241: check predicate 138
11716 OPC_Decode, 134, 108, 180, 1, // 244: decode to AIF_FAMOMAXL_PS using decoder 180
11717 // 244: }
11718 23, 8, // 249: case 0x17: {
11719 OPC_CheckPredicate, 138, 1, // 251: check predicate 138
11720 OPC_Decode, 139, 108, 180, 1, // 254: decode to AIF_FAMOMINL_PI using decoder 180
11721 // 254: }
11722 24, 8, // 259: case 0x18: {
11723 OPC_CheckPredicate, 138, 1, // 261: check predicate 138
11724 OPC_Decode, 140, 108, 180, 1, // 264: decode to AIF_FAMOMINL_PS using decoder 180
11725 // 264: }
11726 27, 8, // 269: case 0x1b: {
11727 OPC_CheckPredicate, 138, 1, // 271: check predicate 138
11728 OPC_Decode, 133, 108, 180, 1, // 274: decode to AIF_FAMOMAXL_PI using decoder 180
11729 // 274: }
11730 31, 8, // 279: case 0x1f: {
11731 OPC_CheckPredicate, 138, 1, // 281: check predicate 138
11732 OPC_Decode, 142, 108, 180, 1, // 284: decode to AIF_FAMOMINUL_PI using decoder 180
11733 // 284: }
11734 35, 8, // 289: case 0x23: {
11735 OPC_CheckPredicate, 138, 1, // 291: check predicate 138
11736 OPC_Decode, 136, 108, 180, 1, // 294: decode to AIF_FAMOMAXUL_PI using decoder 180
11737 // 294: }
11738 67, 8, // 299: case 0x43: {
11739 OPC_CheckPredicate, 138, 1, // 301: check predicate 138
11740 OPC_Decode, 255, 107, 180, 1, // 304: decode to AIF_FAMOADDG_PI using decoder 180
11741 // 304: }
11742 71, 8, // 309: case 0x47: {
11743 OPC_CheckPredicate, 138, 1, // 311: check predicate 138
11744 OPC_Decode, 145, 108, 180, 1, // 314: decode to AIF_FAMOSWAPG_PI using decoder 180
11745 // 314: }
11746 75, 8, // 319: case 0x4b: {
11747 OPC_CheckPredicate, 138, 1, // 321: check predicate 138
11748 OPC_Decode, 129, 108, 180, 1, // 324: decode to AIF_FAMOANDG_PI using decoder 180
11749 // 324: }
11750 79, 8, // 329: case 0x4f: {
11751 OPC_CheckPredicate, 138, 1, // 331: check predicate 138
11752 OPC_Decode, 143, 108, 180, 1, // 334: decode to AIF_FAMOORG_PI using decoder 180
11753 // 334: }
11754 83, 8, // 339: case 0x53: {
11755 OPC_CheckPredicate, 138, 1, // 341: check predicate 138
11756 OPC_Decode, 147, 108, 180, 1, // 344: decode to AIF_FAMOXORG_PI using decoder 180
11757 // 344: }
11758 84, 8, // 349: case 0x54: {
11759 OPC_CheckPredicate, 138, 1, // 351: check predicate 138
11760 OPC_Decode, 132, 108, 180, 1, // 354: decode to AIF_FAMOMAXG_PS using decoder 180
11761 // 354: }
11762 87, 8, // 359: case 0x57: {
11763 OPC_CheckPredicate, 138, 1, // 361: check predicate 138
11764 OPC_Decode, 137, 108, 180, 1, // 364: decode to AIF_FAMOMING_PI using decoder 180
11765 // 364: }
11766 88, 8, // 369: case 0x58: {
11767 OPC_CheckPredicate, 138, 1, // 371: check predicate 138
11768 OPC_Decode, 138, 108, 180, 1, // 374: decode to AIF_FAMOMING_PS using decoder 180
11769 // 374: }
11770 91, 8, // 379: case 0x5b: {
11771 OPC_CheckPredicate, 138, 1, // 381: check predicate 138
11772 OPC_Decode, 131, 108, 180, 1, // 384: decode to AIF_FAMOMAXG_PI using decoder 180
11773 // 384: }
11774 95, 8, // 389: case 0x5f: {
11775 OPC_CheckPredicate, 138, 1, // 391: check predicate 138
11776 OPC_Decode, 141, 108, 180, 1, // 394: decode to AIF_FAMOMINUG_PI using decoder 180
11777 // 394: }
11778 99, 0, // 399: case 0x63: {
11779 OPC_CheckPredicate, 138, 1, // 401: check predicate 138
11780 OPC_Decode, 135, 108, 180, 1, // 404: decode to AIF_FAMOMAXUG_PI using decoder 180
11781 // 404: }
11782 // 404: } // switch Inst[31:25]
11783 // 404: }
11784 6, 8, // 409: case 0x6: {
11785 OPC_CheckPredicate, 138, 1, // 411: check predicate 138
11786 OPC_Decode, 147, 109, 182, 1, // 414: decode to AIF_FSW_PS using decoder 182
11787 // 414: }
11788 7, 0, // 419: case 0x7: {
11789 OPC_SwitchField, 25, 7, // 421: switch Inst[31:25] {
11790 8, 12, // 424: case 0x8: {
11791 OPC_CheckPredicate, 138, 1, // 426: check predicate 138
11792 OPC_CheckField, 20, 5, 0, // 429: check Inst[24:20] == 0x0
11793 OPC_Decode, 215, 108, 181, 1, // 433: decode to AIF_FLWL_PS using decoder 181
11794 // 433: }
11795 9, 12, // 438: case 0x9: {
11796 OPC_CheckPredicate, 138, 1, // 440: check predicate 138
11797 OPC_CheckField, 20, 5, 0, // 443: check Inst[24:20] == 0x0
11798 OPC_Decode, 214, 108, 181, 1, // 447: decode to AIF_FLWG_PS using decoder 181
11799 // 447: }
11800 40, 12, // 452: case 0x28: {
11801 OPC_CheckPredicate, 138, 1, // 454: check predicate 138
11802 OPC_CheckField, 20, 5, 0, // 457: check Inst[24:20] == 0x0
11803 OPC_Decode, 146, 109, 181, 1, // 461: decode to AIF_FSWL_PS using decoder 181
11804 // 461: }
11805 41, 12, // 466: case 0x29: {
11806 OPC_CheckPredicate, 138, 1, // 468: check predicate 138
11807 OPC_CheckField, 20, 5, 0, // 471: check Inst[24:20] == 0x0
11808 OPC_Decode, 144, 109, 181, 1, // 475: decode to AIF_FSWG_PS using decoder 181
11809 // 475: }
11810 64, 8, // 480: case 0x40: {
11811 OPC_CheckPredicate, 138, 1, // 482: check predicate 138
11812 OPC_Decode, 196, 108, 180, 1, // 485: decode to AIF_FGBL_PS using decoder 180
11813 // 485: }
11814 65, 8, // 490: case 0x41: {
11815 OPC_CheckPredicate, 138, 1, // 492: check predicate 138
11816 OPC_Decode, 195, 108, 180, 1, // 495: decode to AIF_FGBG_PS using decoder 180
11817 // 495: }
11818 68, 8, // 500: case 0x44: {
11819 OPC_CheckPredicate, 138, 1, // 502: check predicate 138
11820 OPC_Decode, 199, 108, 180, 1, // 505: decode to AIF_FGHL_PS using decoder 180
11821 // 505: }
11822 69, 8, // 510: case 0x45: {
11823 OPC_CheckPredicate, 138, 1, // 512: check predicate 138
11824 OPC_Decode, 198, 108, 180, 1, // 515: decode to AIF_FGHG_PS using decoder 180
11825 // 515: }
11826 72, 8, // 520: case 0x48: {
11827 OPC_CheckPredicate, 138, 1, // 522: check predicate 138
11828 OPC_Decode, 202, 108, 180, 1, // 525: decode to AIF_FGWL_PS using decoder 180
11829 // 525: }
11830 73, 8, // 530: case 0x49: {
11831 OPC_CheckPredicate, 138, 1, // 532: check predicate 138
11832 OPC_Decode, 201, 108, 180, 1, // 535: decode to AIF_FGWG_PS using decoder 180
11833 // 535: }
11834 96, 8, // 540: case 0x60: {
11835 OPC_CheckPredicate, 138, 1, // 542: check predicate 138
11836 OPC_Decode, 249, 108, 180, 1, // 545: decode to AIF_FSCBL_PS using decoder 180
11837 // 545: }
11838 97, 8, // 550: case 0x61: {
11839 OPC_CheckPredicate, 138, 1, // 552: check predicate 138
11840 OPC_Decode, 248, 108, 180, 1, // 555: decode to AIF_FSCBG_PS using decoder 180
11841 // 555: }
11842 100, 8, // 560: case 0x64: {
11843 OPC_CheckPredicate, 138, 1, // 562: check predicate 138
11844 OPC_Decode, 252, 108, 180, 1, // 565: decode to AIF_FSCHL_PS using decoder 180
11845 // 565: }
11846 101, 8, // 570: case 0x65: {
11847 OPC_CheckPredicate, 138, 1, // 572: check predicate 138
11848 OPC_Decode, 251, 108, 180, 1, // 575: decode to AIF_FSCHG_PS using decoder 180
11849 // 575: }
11850 104, 8, // 580: case 0x68: {
11851 OPC_CheckPredicate, 138, 1, // 582: check predicate 138
11852 OPC_Decode, 255, 108, 180, 1, // 585: decode to AIF_FSCWL_PS using decoder 180
11853 // 585: }
11854 105, 0, // 590: case 0x69: {
11855 OPC_CheckPredicate, 138, 1, // 592: check predicate 138
11856 OPC_Decode, 254, 108, 180, 1, // 595: decode to AIF_FSCWG_PS using decoder 180
11857 // 595: }
11858 // 595: } // switch Inst[31:25]
11859 // 595: }
11860 // 595: } // switch Inst[14:12]
11861 // 595: }
11862 31, 8, // 600: case 0x1f: {
11863 OPC_CheckPredicate, 138, 1, // 602: check predicate 138
11864 OPC_Decode, 152, 108, 183, 1, // 605: decode to AIF_FBCI_PS using decoder 183
11865 // 605: }
11866 39, 12, // 610: case 0x27: {
11867 OPC_CheckPredicate, 138, 1, // 612: check predicate 138
11868 OPC_CheckField, 12, 3, 5, // 615: check Inst[14:12] == 0x5
11869 OPC_Decode, 136, 109, 182, 1, // 619: decode to AIF_FSQ2 using decoder 182
11870 // 619: }
11871 59, 149, 4, // 624: case 0x3b: {
11872 OPC_SwitchField, 25, 7, // 627: switch Inst[31:25] {
11873 0, 21, // 630: case 0x0: {
11874 OPC_SwitchField, 12, 3, // 632: switch Inst[14:12] {
11875 2, 7, // 635: case 0x2: {
11876 OPC_CheckPredicate, 138, 1, // 637: check predicate 138
11877 OPC_Decode, 210, 107, 56, // 640: decode to AIF_AMOADDL_W using decoder 56
11878 // 640: }
11879 3, 0, // 644: case 0x3: {
11880 OPC_CheckPredicate, 138, 1, // 646: check predicate 138
11881 OPC_Decode, 209, 107, 56, // 649: decode to AIF_AMOADDL_D using decoder 56
11882 // 649: }
11883 // 649: } // switch Inst[14:12]
11884 // 649: }
11885 1, 21, // 653: case 0x1: {
11886 OPC_SwitchField, 12, 3, // 655: switch Inst[14:12] {
11887 2, 7, // 658: case 0x2: {
11888 OPC_CheckPredicate, 138, 1, // 660: check predicate 138
11889 OPC_Decode, 208, 107, 56, // 663: decode to AIF_AMOADDG_W using decoder 56
11890 // 663: }
11891 3, 0, // 667: case 0x3: {
11892 OPC_CheckPredicate, 138, 1, // 669: check predicate 138
11893 OPC_Decode, 207, 107, 56, // 672: decode to AIF_AMOADDG_D using decoder 56
11894 // 672: }
11895 // 672: } // switch Inst[14:12]
11896 // 672: }
11897 4, 21, // 676: case 0x4: {
11898 OPC_SwitchField, 12, 3, // 678: switch Inst[14:12] {
11899 2, 7, // 681: case 0x2: {
11900 OPC_CheckPredicate, 138, 1, // 683: check predicate 138
11901 OPC_Decode, 242, 107, 56, // 686: decode to AIF_AMOSWAPL_W using decoder 56
11902 // 686: }
11903 3, 0, // 690: case 0x3: {
11904 OPC_CheckPredicate, 138, 1, // 692: check predicate 138
11905 OPC_Decode, 241, 107, 56, // 695: decode to AIF_AMOSWAPL_D using decoder 56
11906 // 695: }
11907 // 695: } // switch Inst[14:12]
11908 // 695: }
11909 5, 21, // 699: case 0x5: {
11910 OPC_SwitchField, 12, 3, // 701: switch Inst[14:12] {
11911 2, 7, // 704: case 0x2: {
11912 OPC_CheckPredicate, 138, 1, // 706: check predicate 138
11913 OPC_Decode, 240, 107, 56, // 709: decode to AIF_AMOSWAPG_W using decoder 56
11914 // 709: }
11915 3, 0, // 713: case 0x3: {
11916 OPC_CheckPredicate, 138, 1, // 715: check predicate 138
11917 OPC_Decode, 239, 107, 56, // 718: decode to AIF_AMOSWAPG_D using decoder 56
11918 // 718: }
11919 // 718: } // switch Inst[14:12]
11920 // 718: }
11921 8, 11, // 722: case 0x8: {
11922 OPC_CheckPredicate, 138, 1, // 724: check predicate 138
11923 OPC_CheckField, 7, 8, 96, // 727: check Inst[14:7] == 0x60
11924 OPC_Decode, 161, 109, 59, // 731: decode to AIF_SBL using decoder 59
11925 // 731: }
11926 9, 11, // 735: case 0x9: {
11927 OPC_CheckPredicate, 138, 1, // 737: check predicate 138
11928 OPC_CheckField, 7, 8, 96, // 740: check Inst[14:7] == 0x60
11929 OPC_Decode, 160, 109, 59, // 744: decode to AIF_SBG using decoder 59
11930 // 744: }
11931 12, 11, // 748: case 0xc: {
11932 OPC_CheckPredicate, 138, 1, // 750: check predicate 138
11933 OPC_CheckField, 7, 8, 96, // 753: check Inst[14:7] == 0x60
11934 OPC_Decode, 163, 109, 59, // 757: decode to AIF_SHL using decoder 59
11935 // 757: }
11936 13, 11, // 761: case 0xd: {
11937 OPC_CheckPredicate, 138, 1, // 763: check predicate 138
11938 OPC_CheckField, 7, 8, 96, // 766: check Inst[14:7] == 0x60
11939 OPC_Decode, 162, 109, 59, // 770: decode to AIF_SHG using decoder 59
11940 // 770: }
11941 16, 21, // 774: case 0x10: {
11942 OPC_SwitchField, 12, 3, // 776: switch Inst[14:12] {
11943 2, 7, // 779: case 0x2: {
11944 OPC_CheckPredicate, 138, 1, // 781: check predicate 138
11945 OPC_Decode, 246, 107, 56, // 784: decode to AIF_AMOXORL_W using decoder 56
11946 // 784: }
11947 3, 0, // 788: case 0x3: {
11948 OPC_CheckPredicate, 138, 1, // 790: check predicate 138
11949 OPC_Decode, 245, 107, 56, // 793: decode to AIF_AMOXORL_D using decoder 56
11950 // 793: }
11951 // 793: } // switch Inst[14:12]
11952 // 793: }
11953 17, 21, // 797: case 0x11: {
11954 OPC_SwitchField, 12, 3, // 799: switch Inst[14:12] {
11955 2, 7, // 802: case 0x2: {
11956 OPC_CheckPredicate, 138, 1, // 804: check predicate 138
11957 OPC_Decode, 244, 107, 56, // 807: decode to AIF_AMOXORG_W using decoder 56
11958 // 807: }
11959 3, 0, // 811: case 0x3: {
11960 OPC_CheckPredicate, 138, 1, // 813: check predicate 138
11961 OPC_Decode, 243, 107, 56, // 816: decode to AIF_AMOXORG_D using decoder 56
11962 // 816: }
11963 // 816: } // switch Inst[14:12]
11964 // 816: }
11965 32, 21, // 820: case 0x20: {
11966 OPC_SwitchField, 12, 3, // 822: switch Inst[14:12] {
11967 2, 7, // 825: case 0x2: {
11968 OPC_CheckPredicate, 138, 1, // 827: check predicate 138
11969 OPC_Decode, 238, 107, 56, // 830: decode to AIF_AMOORL_W using decoder 56
11970 // 830: }
11971 3, 0, // 834: case 0x3: {
11972 OPC_CheckPredicate, 138, 1, // 836: check predicate 138
11973 OPC_Decode, 237, 107, 56, // 839: decode to AIF_AMOORL_D using decoder 56
11974 // 839: }
11975 // 839: } // switch Inst[14:12]
11976 // 839: }
11977 33, 21, // 843: case 0x21: {
11978 OPC_SwitchField, 12, 3, // 845: switch Inst[14:12] {
11979 2, 7, // 848: case 0x2: {
11980 OPC_CheckPredicate, 138, 1, // 850: check predicate 138
11981 OPC_Decode, 236, 107, 56, // 853: decode to AIF_AMOORG_W using decoder 56
11982 // 853: }
11983 3, 0, // 857: case 0x3: {
11984 OPC_CheckPredicate, 138, 1, // 859: check predicate 138
11985 OPC_Decode, 235, 107, 56, // 862: decode to AIF_AMOORG_D using decoder 56
11986 // 862: }
11987 // 862: } // switch Inst[14:12]
11988 // 862: }
11989 48, 21, // 866: case 0x30: {
11990 OPC_SwitchField, 12, 3, // 868: switch Inst[14:12] {
11991 2, 7, // 871: case 0x2: {
11992 OPC_CheckPredicate, 138, 1, // 873: check predicate 138
11993 OPC_Decode, 214, 107, 56, // 876: decode to AIF_AMOANDL_W using decoder 56
11994 // 876: }
11995 3, 0, // 880: case 0x3: {
11996 OPC_CheckPredicate, 138, 1, // 882: check predicate 138
11997 OPC_Decode, 213, 107, 56, // 885: decode to AIF_AMOANDL_D using decoder 56
11998 // 885: }
11999 // 885: } // switch Inst[14:12]
12000 // 885: }
12001 49, 21, // 889: case 0x31: {
12002 OPC_SwitchField, 12, 3, // 891: switch Inst[14:12] {
12003 2, 7, // 894: case 0x2: {
12004 OPC_CheckPredicate, 138, 1, // 896: check predicate 138
12005 OPC_Decode, 212, 107, 56, // 899: decode to AIF_AMOANDG_W using decoder 56
12006 // 899: }
12007 3, 0, // 903: case 0x3: {
12008 OPC_CheckPredicate, 138, 1, // 905: check predicate 138
12009 OPC_Decode, 211, 107, 56, // 908: decode to AIF_AMOANDG_D using decoder 56
12010 // 908: }
12011 // 908: } // switch Inst[14:12]
12012 // 908: }
12013 64, 39, // 912: case 0x40: {
12014 OPC_SwitchField, 12, 3, // 914: switch Inst[14:12] {
12015 2, 7, // 917: case 0x2: {
12016 OPC_CheckPredicate, 138, 1, // 919: check predicate 138
12017 OPC_Decode, 230, 107, 56, // 922: decode to AIF_AMOMINL_W using decoder 56
12018 // 922: }
12019 3, 7, // 926: case 0x3: {
12020 OPC_CheckPredicate, 138, 1, // 928: check predicate 138
12021 OPC_Decode, 229, 107, 56, // 931: decode to AIF_AMOMINL_D using decoder 56
12022 // 931: }
12023 6, 7, // 935: case 0x6: {
12024 OPC_CheckPredicate, 138, 1, // 937: check predicate 138
12025 OPC_Decode, 159, 109, 31, // 940: decode to AIF_PACKB using decoder 31
12026 // 940: }
12027 7, 0, // 944: case 0x7: {
12028 OPC_CheckPredicate, 138, 1, // 946: check predicate 138
12029 OPC_Decode, 247, 107, 31, // 949: decode to AIF_BITMIXB using decoder 31
12030 // 949: }
12031 // 949: } // switch Inst[14:12]
12032 // 949: }
12033 65, 21, // 953: case 0x41: {
12034 OPC_SwitchField, 12, 3, // 955: switch Inst[14:12] {
12035 2, 7, // 958: case 0x2: {
12036 OPC_CheckPredicate, 138, 1, // 960: check predicate 138
12037 OPC_Decode, 228, 107, 56, // 963: decode to AIF_AMOMING_W using decoder 56
12038 // 963: }
12039 3, 0, // 967: case 0x3: {
12040 OPC_CheckPredicate, 138, 1, // 969: check predicate 138
12041 OPC_Decode, 227, 107, 56, // 972: decode to AIF_AMOMING_D using decoder 56
12042 // 972: }
12043 // 972: } // switch Inst[14:12]
12044 // 972: }
12045 80, 21, // 976: case 0x50: {
12046 OPC_SwitchField, 12, 3, // 978: switch Inst[14:12] {
12047 2, 7, // 981: case 0x2: {
12048 OPC_CheckPredicate, 138, 1, // 983: check predicate 138
12049 OPC_Decode, 222, 107, 56, // 986: decode to AIF_AMOMAXL_W using decoder 56
12050 // 986: }
12051 3, 0, // 990: case 0x3: {
12052 OPC_CheckPredicate, 138, 1, // 992: check predicate 138
12053 OPC_Decode, 221, 107, 56, // 995: decode to AIF_AMOMAXL_D using decoder 56
12054 // 995: }
12055 // 995: } // switch Inst[14:12]
12056 // 995: }
12057 81, 21, // 999: case 0x51: {
12058 OPC_SwitchField, 12, 3, // 1001: switch Inst[14:12] {
12059 2, 7, // 1004: case 0x2: {
12060 OPC_CheckPredicate, 138, 1, // 1006: check predicate 138
12061 OPC_Decode, 220, 107, 56, // 1009: decode to AIF_AMOMAXG_W using decoder 56
12062 // 1009: }
12063 3, 0, // 1013: case 0x3: {
12064 OPC_CheckPredicate, 138, 1, // 1015: check predicate 138
12065 OPC_Decode, 219, 107, 56, // 1018: decode to AIF_AMOMAXG_D using decoder 56
12066 // 1018: }
12067 // 1018: } // switch Inst[14:12]
12068 // 1018: }
12069 96, 21, // 1022: case 0x60: {
12070 OPC_SwitchField, 12, 3, // 1024: switch Inst[14:12] {
12071 2, 7, // 1027: case 0x2: {
12072 OPC_CheckPredicate, 138, 1, // 1029: check predicate 138
12073 OPC_Decode, 234, 107, 56, // 1032: decode to AIF_AMOMINUL_W using decoder 56
12074 // 1032: }
12075 3, 0, // 1036: case 0x3: {
12076 OPC_CheckPredicate, 138, 1, // 1038: check predicate 138
12077 OPC_Decode, 233, 107, 56, // 1041: decode to AIF_AMOMINUL_D using decoder 56
12078 // 1041: }
12079 // 1041: } // switch Inst[14:12]
12080 // 1041: }
12081 97, 21, // 1045: case 0x61: {
12082 OPC_SwitchField, 12, 3, // 1047: switch Inst[14:12] {
12083 2, 7, // 1050: case 0x2: {
12084 OPC_CheckPredicate, 138, 1, // 1052: check predicate 138
12085 OPC_Decode, 232, 107, 56, // 1055: decode to AIF_AMOMINUG_W using decoder 56
12086 // 1055: }
12087 3, 0, // 1059: case 0x3: {
12088 OPC_CheckPredicate, 138, 1, // 1061: check predicate 138
12089 OPC_Decode, 231, 107, 56, // 1064: decode to AIF_AMOMINUG_D using decoder 56
12090 // 1064: }
12091 // 1064: } // switch Inst[14:12]
12092 // 1064: }
12093 112, 21, // 1068: case 0x70: {
12094 OPC_SwitchField, 12, 3, // 1070: switch Inst[14:12] {
12095 2, 7, // 1073: case 0x2: {
12096 OPC_CheckPredicate, 138, 1, // 1075: check predicate 138
12097 OPC_Decode, 226, 107, 56, // 1078: decode to AIF_AMOMAXUL_W using decoder 56
12098 // 1078: }
12099 3, 0, // 1082: case 0x3: {
12100 OPC_CheckPredicate, 138, 1, // 1084: check predicate 138
12101 OPC_Decode, 225, 107, 56, // 1087: decode to AIF_AMOMAXUL_D using decoder 56
12102 // 1087: }
12103 // 1087: } // switch Inst[14:12]
12104 // 1087: }
12105 113, 21, // 1091: case 0x71: {
12106 OPC_SwitchField, 12, 3, // 1093: switch Inst[14:12] {
12107 2, 7, // 1096: case 0x2: {
12108 OPC_CheckPredicate, 138, 1, // 1098: check predicate 138
12109 OPC_Decode, 224, 107, 56, // 1101: decode to AIF_AMOMAXUG_W using decoder 56
12110 // 1101: }
12111 3, 0, // 1105: case 0x3: {
12112 OPC_CheckPredicate, 138, 1, // 1107: check predicate 138
12113 OPC_Decode, 223, 107, 56, // 1110: decode to AIF_AMOMAXUG_D using decoder 56
12114 // 1110: }
12115 // 1110: } // switch Inst[14:12]
12116 // 1110: }
12117 120, 21, // 1114: case 0x78: {
12118 OPC_SwitchField, 12, 3, // 1116: switch Inst[14:12] {
12119 2, 7, // 1119: case 0x2: {
12120 OPC_CheckPredicate, 138, 1, // 1121: check predicate 138
12121 OPC_Decode, 218, 107, 56, // 1124: decode to AIF_AMOCMPSWAPL_W using decoder 56
12122 // 1124: }
12123 3, 0, // 1128: case 0x3: {
12124 OPC_CheckPredicate, 138, 1, // 1130: check predicate 138
12125 OPC_Decode, 217, 107, 56, // 1133: decode to AIF_AMOCMPSWAPL_D using decoder 56
12126 // 1133: }
12127 // 1133: } // switch Inst[14:12]
12128 // 1133: }
12129 121, 0, // 1137: case 0x79: {
12130 OPC_SwitchField, 12, 3, // 1139: switch Inst[14:12] {
12131 2, 7, // 1142: case 0x2: {
12132 OPC_CheckPredicate, 138, 1, // 1144: check predicate 138
12133 OPC_Decode, 216, 107, 56, // 1147: decode to AIF_AMOCMPSWAPG_W using decoder 56
12134 // 1147: }
12135 3, 0, // 1151: case 0x3: {
12136 OPC_CheckPredicate, 138, 1, // 1153: check predicate 138
12137 OPC_Decode, 215, 107, 56, // 1156: decode to AIF_AMOCMPSWAPG_D using decoder 56
12138 // 1156: }
12139 // 1156: } // switch Inst[14:12]
12140 // 1156: }
12141 // 1156: } // switch Inst[31:25]
12142 // 1156: }
12143 63, 45, // 1160: case 0x3f: {
12144 OPC_SwitchField, 12, 3, // 1162: switch Inst[14:12] {
12145 0, 12, // 1165: case 0x0: {
12146 OPC_CheckPredicate, 138, 1, // 1167: check predicate 138
12147 OPC_CheckField, 25, 2, 2, // 1170: check Inst[26:25] == 0x2
12148 OPC_Decode, 252, 107, 184, 1, // 1174: decode to AIF_FADDI_PI using decoder 184
12149 // 1174: }
12150 1, 12, // 1179: case 0x1: {
12151 OPC_CheckPredicate, 138, 1, // 1181: check predicate 138
12152 OPC_CheckField, 25, 2, 2, // 1184: check Inst[26:25] == 0x2
12153 OPC_Decode, 149, 108, 184, 1, // 1188: decode to AIF_FANDI_PI using decoder 184
12154 // 1188: }
12155 2, 0, // 1193: case 0x2: {
12156 OPC_CheckPredicate, 138, 1, // 1195: check predicate 138
12157 OPC_CheckField, 25, 2, 2, // 1198: check Inst[26:25] == 0x2
12158 OPC_Decode, 157, 108, 185, 1, // 1202: decode to AIF_FCMOV_PS using decoder 185
12159 // 1202: }
12160 // 1202: } // switch Inst[14:12]
12161 // 1202: }
12162 91, 43, // 1207: case 0x5b: {
12163 OPC_SwitchField, 25, 2, // 1209: switch Inst[26:25] {
12164 0, 8, // 1212: case 0x0: {
12165 OPC_CheckPredicate, 138, 1, // 1214: check predicate 138
12166 OPC_Decode, 217, 108, 186, 1, // 1217: decode to AIF_FMADD_PS using decoder 186
12167 // 1217: }
12168 1, 8, // 1222: case 0x1: {
12169 OPC_CheckPredicate, 138, 1, // 1224: check predicate 138
12170 OPC_Decode, 224, 108, 186, 1, // 1227: decode to AIF_FMSUB_PS using decoder 186
12171 // 1227: }
12172 2, 8, // 1232: case 0x2: {
12173 OPC_CheckPredicate, 138, 1, // 1234: check predicate 138
12174 OPC_Decode, 232, 108, 186, 1, // 1237: decode to AIF_FNMSUB_PS using decoder 186
12175 // 1237: }
12176 3, 0, // 1242: case 0x3: {
12177 OPC_CheckPredicate, 138, 1, // 1244: check predicate 138
12178 OPC_Decode, 231, 108, 186, 1, // 1247: decode to AIF_FNMADD_PS using decoder 186
12179 // 1247: }
12180 // 1247: } // switch Inst[26:25]
12181 // 1247: }
12182 95, 8, // 1252: case 0x5f: {
12183 OPC_CheckPredicate, 138, 1, // 1254: check predicate 138
12184 OPC_Decode, 151, 108, 183, 1, // 1257: decode to AIF_FBCI_PI using decoder 183
12185 // 1257: }
12186 119, 16, // 1262: case 0x77: {
12187 OPC_CheckPredicate, 138, 1, // 1264: check predicate 138
12188 OPC_CheckField, 25, 7, 0, // 1267: check Inst[31:25] == 0x0
12189 OPC_CheckField, 12, 3, 0, // 1271: check Inst[14:12] == 0x0
12190 OPC_Decode, 156, 108, 187, 1, // 1275: decode to AIF_FCMOVM_PS using decoder 187
12191 // 1275: }
12192 123, 0, // 1280: case 0x7b: {
12193 OPC_SwitchField, 25, 7, // 1282: switch Inst[31:25] {
12194 0, 8, // 1285: case 0x0: {
12195 OPC_CheckPredicate, 138, 1, // 1287: check predicate 138
12196 OPC_Decode, 254, 107, 188, 1, // 1290: decode to AIF_FADD_PS using decoder 188
12197 // 1290: }
12198 3, 102, // 1295: case 0x3: {
12199 OPC_SwitchField, 12, 3, // 1297: switch Inst[14:12] {
12200 0, 8, // 1300: case 0x0: {
12201 OPC_CheckPredicate, 138, 1, // 1302: check predicate 138
12202 OPC_Decode, 253, 107, 187, 1, // 1305: decode to AIF_FADD_PI using decoder 187
12203 // 1305: }
12204 1, 8, // 1310: case 0x1: {
12205 OPC_CheckPredicate, 138, 1, // 1312: check predicate 138
12206 OPC_Decode, 135, 109, 187, 1, // 1315: decode to AIF_FSLL_PI using decoder 187
12207 // 1315: }
12208 2, 12, // 1320: case 0x2: {
12209 OPC_CheckPredicate, 138, 1, // 1322: check predicate 138
12210 OPC_CheckField, 20, 5, 0, // 1325: check Inst[24:20] == 0x0
12211 OPC_Decode, 233, 108, 189, 1, // 1329: decode to AIF_FNOT_PI using decoder 189
12212 // 1329: }
12213 3, 23, // 1334: case 0x3: {
12214 OPC_SwitchField, 20, 5, // 1336: switch Inst[24:20] {
12215 0, 8, // 1339: case 0x0: {
12216 OPC_CheckPredicate, 138, 1, // 1341: check predicate 138
12217 OPC_Decode, 243, 108, 189, 1, // 1344: decode to AIF_FSAT8_PI using decoder 189
12218 // 1344: }
12219 1, 0, // 1349: case 0x1: {
12220 OPC_CheckPredicate, 138, 1, // 1351: check predicate 138
12221 OPC_Decode, 244, 108, 189, 1, // 1354: decode to AIF_FSATU8_PI using decoder 189
12222 // 1354: }
12223 // 1354: } // switch Inst[24:20]
12224 // 1354: }
12225 4, 8, // 1359: case 0x4: {
12226 OPC_CheckPredicate, 138, 1, // 1361: check predicate 138
12227 OPC_Decode, 148, 109, 187, 1, // 1364: decode to AIF_FXOR_PI using decoder 187
12228 // 1364: }
12229 5, 8, // 1369: case 0x5: {
12230 OPC_CheckPredicate, 138, 1, // 1371: check predicate 138
12231 OPC_Decode, 141, 109, 187, 1, // 1374: decode to AIF_FSRL_PI using decoder 187
12232 // 1374: }
12233 6, 8, // 1379: case 0x6: {
12234 OPC_CheckPredicate, 138, 1, // 1381: check predicate 138
12235 OPC_Decode, 234, 108, 187, 1, // 1384: decode to AIF_FOR_PI using decoder 187
12236 // 1384: }
12237 7, 0, // 1389: case 0x7: {
12238 OPC_CheckPredicate, 138, 1, // 1391: check predicate 138
12239 OPC_Decode, 150, 108, 187, 1, // 1394: decode to AIF_FAND_PI using decoder 187
12240 // 1394: }
12241 // 1394: } // switch Inst[14:12]
12242 // 1394: }
12243 4, 8, // 1399: case 0x4: {
12244 OPC_CheckPredicate, 138, 1, // 1401: check predicate 138
12245 OPC_Decode, 143, 109, 188, 1, // 1404: decode to AIF_FSUB_PS using decoder 188
12246 // 1404: }
12247 7, 23, // 1409: case 0x7: {
12248 OPC_SwitchField, 12, 3, // 1411: switch Inst[14:12] {
12249 0, 8, // 1414: case 0x0: {
12250 OPC_CheckPredicate, 138, 1, // 1416: check predicate 138
12251 OPC_Decode, 142, 109, 187, 1, // 1419: decode to AIF_FSUB_PI using decoder 187
12252 // 1419: }
12253 5, 0, // 1424: case 0x5: {
12254 OPC_CheckPredicate, 138, 1, // 1426: check predicate 138
12255 OPC_Decode, 139, 109, 187, 1, // 1429: decode to AIF_FSRA_PI using decoder 187
12256 // 1429: }
12257 // 1429: } // switch Inst[14:12]
12258 // 1429: }
12259 8, 8, // 1434: case 0x8: {
12260 OPC_CheckPredicate, 138, 1, // 1436: check predicate 138
12261 OPC_Decode, 228, 108, 188, 1, // 1439: decode to AIF_FMUL_PS using decoder 188
12262 // 1439: }
12263 11, 33, // 1444: case 0xb: {
12264 OPC_SwitchField, 12, 3, // 1446: switch Inst[14:12] {
12265 0, 8, // 1449: case 0x0: {
12266 OPC_CheckPredicate, 138, 1, // 1451: check predicate 138
12267 OPC_Decode, 227, 108, 187, 1, // 1454: decode to AIF_FMUL_PI using decoder 187
12268 // 1454: }
12269 1, 8, // 1459: case 0x1: {
12270 OPC_CheckPredicate, 138, 1, // 1461: check predicate 138
12271 OPC_Decode, 226, 108, 187, 1, // 1464: decode to AIF_FMULH_PI using decoder 187
12272 // 1464: }
12273 2, 0, // 1469: case 0x2: {
12274 OPC_CheckPredicate, 138, 1, // 1471: check predicate 138
12275 OPC_Decode, 225, 108, 187, 1, // 1474: decode to AIF_FMULHU_PI using decoder 187
12276 // 1474: }
12277 // 1474: } // switch Inst[14:12]
12278 // 1474: }
12279 12, 8, // 1479: case 0xc: {
12280 OPC_CheckPredicate, 138, 1, // 1481: check predicate 138
12281 OPC_Decode, 186, 108, 188, 1, // 1484: decode to AIF_FDIV_PS using decoder 188
12282 // 1484: }
12283 15, 43, // 1489: case 0xf: {
12284 OPC_SwitchField, 12, 3, // 1491: switch Inst[14:12] {
12285 0, 8, // 1494: case 0x0: {
12286 OPC_CheckPredicate, 138, 1, // 1496: check predicate 138
12287 OPC_Decode, 185, 108, 187, 1, // 1499: decode to AIF_FDIV_PI using decoder 187
12288 // 1499: }
12289 1, 8, // 1504: case 0x1: {
12290 OPC_CheckPredicate, 138, 1, // 1506: check predicate 138
12291 OPC_Decode, 184, 108, 187, 1, // 1509: decode to AIF_FDIVU_PI using decoder 187
12292 // 1509: }
12293 2, 8, // 1514: case 0x2: {
12294 OPC_CheckPredicate, 138, 1, // 1516: check predicate 138
12295 OPC_Decode, 240, 108, 187, 1, // 1519: decode to AIF_FREM_PI using decoder 187
12296 // 1519: }
12297 3, 0, // 1524: case 0x3: {
12298 OPC_CheckPredicate, 138, 1, // 1526: check predicate 138
12299 OPC_Decode, 239, 108, 187, 1, // 1529: decode to AIF_FREMU_PI using decoder 187
12300 // 1529: }
12301 // 1529: } // switch Inst[14:12]
12302 // 1529: }
12303 16, 33, // 1534: case 0x10: {
12304 OPC_SwitchField, 12, 3, // 1536: switch Inst[14:12] {
12305 0, 8, // 1539: case 0x0: {
12306 OPC_CheckPredicate, 138, 1, // 1541: check predicate 138
12307 OPC_Decode, 132, 109, 187, 1, // 1544: decode to AIF_FSGNJ_PS using decoder 187
12308 // 1544: }
12309 1, 8, // 1549: case 0x1: {
12310 OPC_CheckPredicate, 138, 1, // 1551: check predicate 138
12311 OPC_Decode, 130, 109, 187, 1, // 1554: decode to AIF_FSGNJN_PS using decoder 187
12312 // 1554: }
12313 2, 0, // 1559: case 0x2: {
12314 OPC_CheckPredicate, 138, 1, // 1561: check predicate 138
12315 OPC_Decode, 131, 109, 187, 1, // 1564: decode to AIF_FSGNJX_PS using decoder 187
12316 // 1564: }
12317 // 1564: } // switch Inst[14:12]
12318 // 1564: }
12319 19, 31, // 1569: case 0x13: {
12320 OPC_SwitchField, 12, 3, // 1571: switch Inst[14:12] {
12321 0, 12, // 1574: case 0x0: {
12322 OPC_CheckPredicate, 138, 1, // 1576: check predicate 138
12323 OPC_CheckField, 20, 5, 0, // 1579: check Inst[24:20] == 0x0
12324 OPC_Decode, 235, 108, 189, 1, // 1583: decode to AIF_FPACKREPB_PI using decoder 189
12325 // 1583: }
12326 1, 0, // 1588: case 0x1: {
12327 OPC_CheckPredicate, 138, 1, // 1590: check predicate 138
12328 OPC_CheckField, 20, 5, 0, // 1593: check Inst[24:20] == 0x0
12329 OPC_Decode, 236, 108, 189, 1, // 1597: decode to AIF_FPACKREPH_PI using decoder 189
12330 // 1597: }
12331 // 1597: } // switch Inst[14:12]
12332 // 1597: }
12333 20, 23, // 1602: case 0x14: {
12334 OPC_SwitchField, 12, 3, // 1604: switch Inst[14:12] {
12335 0, 8, // 1607: case 0x0: {
12336 OPC_CheckPredicate, 138, 1, // 1609: check predicate 138
12337 OPC_Decode, 223, 108, 187, 1, // 1612: decode to AIF_FMIN_PS using decoder 187
12338 // 1612: }
12339 1, 0, // 1617: case 0x1: {
12340 OPC_CheckPredicate, 138, 1, // 1619: check predicate 138
12341 OPC_Decode, 220, 108, 187, 1, // 1622: decode to AIF_FMAX_PS using decoder 187
12342 // 1622: }
12343 // 1622: } // switch Inst[14:12]
12344 // 1622: }
12345 23, 43, // 1627: case 0x17: {
12346 OPC_SwitchField, 12, 3, // 1629: switch Inst[14:12] {
12347 0, 8, // 1632: case 0x0: {
12348 OPC_CheckPredicate, 138, 1, // 1634: check predicate 138
12349 OPC_Decode, 222, 108, 187, 1, // 1637: decode to AIF_FMIN_PI using decoder 187
12350 // 1637: }
12351 1, 8, // 1642: case 0x1: {
12352 OPC_CheckPredicate, 138, 1, // 1644: check predicate 138
12353 OPC_Decode, 219, 108, 187, 1, // 1647: decode to AIF_FMAX_PI using decoder 187
12354 // 1647: }
12355 2, 8, // 1652: case 0x2: {
12356 OPC_CheckPredicate, 138, 1, // 1654: check predicate 138
12357 OPC_Decode, 221, 108, 187, 1, // 1657: decode to AIF_FMINU_PI using decoder 187
12358 // 1657: }
12359 3, 0, // 1662: case 0x3: {
12360 OPC_CheckPredicate, 138, 1, // 1664: check predicate 138
12361 OPC_Decode, 218, 108, 187, 1, // 1667: decode to AIF_FMAXU_PI using decoder 187
12362 // 1667: }
12363 // 1667: } // switch Inst[14:12]
12364 // 1667: }
12365 24, 12, // 1672: case 0x18: {
12366 OPC_CheckPredicate, 138, 1, // 1674: check predicate 138
12367 OPC_CheckField, 12, 3, 0, // 1677: check Inst[14:12] == 0x0
12368 OPC_Decode, 237, 108, 187, 1, // 1681: decode to AIF_FRCP_FIX_RAST using decoder 187
12369 // 1681: }
12370 31, 12, // 1686: case 0x1f: {
12371 OPC_CheckPredicate, 138, 1, // 1688: check predicate 138
12372 OPC_CheckField, 12, 3, 0, // 1691: check Inst[14:12] == 0x0
12373 OPC_Decode, 209, 108, 190, 1, // 1695: decode to AIF_FLTM_PI using decoder 190
12374 // 1695: }
12375 39, 33, // 1700: case 0x27: {
12376 OPC_SwitchField, 12, 3, // 1702: switch Inst[14:12] {
12377 1, 8, // 1705: case 0x1: {
12378 OPC_CheckPredicate, 138, 1, // 1707: check predicate 138
12379 OPC_Decode, 134, 109, 191, 1, // 1710: decode to AIF_FSLLI_PI using decoder 191
12380 // 1710: }
12381 5, 8, // 1715: case 0x5: {
12382 OPC_CheckPredicate, 138, 1, // 1717: check predicate 138
12383 OPC_Decode, 140, 109, 191, 1, // 1720: decode to AIF_FSRLI_PI using decoder 191
12384 // 1720: }
12385 7, 0, // 1725: case 0x7: {
12386 OPC_CheckPredicate, 138, 1, // 1727: check predicate 138
12387 OPC_Decode, 138, 109, 191, 1, // 1730: decode to AIF_FSRAI_PI using decoder 191
12388 // 1730: }
12389 // 1730: } // switch Inst[14:12]
12390 // 1730: }
12391 41, 16, // 1735: case 0x29: {
12392 OPC_CheckPredicate, 138, 1, // 1737: check predicate 138
12393 OPC_CheckField, 18, 7, 0, // 1740: check Inst[24:18] == 0x0
12394 OPC_CheckField, 12, 3, 0, // 1744: check Inst[14:12] == 0x0
12395 OPC_Decode, 152, 109, 192, 1, // 1748: decode to AIF_MASKPOPC using decoder 192
12396 // 1748: }
12397 42, 16, // 1753: case 0x2a: {
12398 OPC_CheckPredicate, 138, 1, // 1755: check predicate 138
12399 OPC_CheckField, 18, 7, 0, // 1758: check Inst[24:18] == 0x0
12400 OPC_CheckField, 12, 3, 0, // 1762: check Inst[14:12] == 0x0
12401 OPC_Decode, 153, 109, 192, 1, // 1766: decode to AIF_MASKPOPCZ using decoder 192
12402 // 1766: }
12403 43, 12, // 1771: case 0x2b: {
12404 OPC_CheckPredicate, 138, 1, // 1773: check predicate 138
12405 OPC_CheckField, 10, 2, 0, // 1776: check Inst[11:10] == 0x0
12406 OPC_Decode, 158, 109, 193, 1, // 1780: decode to AIF_MOV_M_X using decoder 193
12407 // 1780: }
12408 44, 111, // 1785: case 0x2c: {
12409 OPC_SwitchField, 20, 5, // 1787: switch Inst[24:20] {
12410 0, 12, // 1790: case 0x0: {
12411 OPC_CheckPredicate, 138, 1, // 1792: check predicate 138
12412 OPC_CheckField, 12, 3, 0, // 1795: check Inst[14:12] == 0x0
12413 OPC_Decode, 137, 109, 189, 1, // 1799: decode to AIF_FSQRT_PS using decoder 189
12414 // 1799: }
12415 1, 8, // 1804: case 0x1: {
12416 OPC_CheckPredicate, 138, 1, // 1806: check predicate 138
12417 OPC_Decode, 241, 108, 194, 1, // 1809: decode to AIF_FROUND_PS using decoder 194
12418 // 1809: }
12419 2, 12, // 1814: case 0x2: {
12420 OPC_CheckPredicate, 138, 1, // 1816: check predicate 138
12421 OPC_CheckField, 12, 3, 0, // 1819: check Inst[14:12] == 0x0
12422 OPC_Decode, 191, 108, 189, 1, // 1823: decode to AIF_FFRC_PS using decoder 189
12423 // 1823: }
12424 3, 12, // 1828: case 0x3: {
12425 OPC_CheckPredicate, 138, 1, // 1830: check predicate 138
12426 OPC_CheckField, 12, 3, 0, // 1833: check Inst[14:12] == 0x0
12427 OPC_Decode, 207, 108, 189, 1, // 1837: decode to AIF_FLOG_PS using decoder 189
12428 // 1837: }
12429 4, 12, // 1842: case 0x4: {
12430 OPC_CheckPredicate, 138, 1, // 1844: check predicate 138
12431 OPC_CheckField, 12, 3, 0, // 1847: check Inst[14:12] == 0x0
12432 OPC_Decode, 190, 108, 189, 1, // 1851: decode to AIF_FEXP_PS using decoder 189
12433 // 1851: }
12434 6, 12, // 1856: case 0x6: {
12435 OPC_CheckPredicate, 138, 1, // 1858: check predicate 138
12436 OPC_CheckField, 12, 3, 0, // 1861: check Inst[14:12] == 0x0
12437 OPC_Decode, 133, 109, 189, 1, // 1865: decode to AIF_FSIN_PS using decoder 189
12438 // 1865: }
12439 7, 12, // 1870: case 0x7: {
12440 OPC_CheckPredicate, 138, 1, // 1872: check predicate 138
12441 OPC_CheckField, 12, 3, 0, // 1875: check Inst[14:12] == 0x0
12442 OPC_Decode, 238, 108, 189, 1, // 1879: decode to AIF_FRCP_PS using decoder 189
12443 // 1879: }
12444 8, 0, // 1884: case 0x8: {
12445 OPC_CheckPredicate, 138, 1, // 1886: check predicate 138
12446 OPC_CheckField, 12, 3, 0, // 1889: check Inst[14:12] == 0x0
12447 OPC_Decode, 242, 108, 189, 1, // 1893: decode to AIF_FRSQ_PS using decoder 189
12448 // 1893: }
12449 // 1893: } // switch Inst[24:20]
12450 // 1893: }
12451 47, 12, // 1898: case 0x2f: {
12452 OPC_CheckPredicate, 138, 1, // 1900: check predicate 138
12453 OPC_CheckField, 12, 3, 0, // 1903: check Inst[14:12] == 0x0
12454 OPC_Decode, 154, 109, 195, 1, // 1907: decode to AIF_MASKPOPC_ET_RAST using decoder 195
12455 // 1907: }
12456 51, 71, // 1912: case 0x33: {
12457 OPC_SwitchField, 10, 5, // 1914: switch Inst[14:10] {
12458 8, 12, // 1917: case 0x8: {
12459 OPC_CheckPredicate, 138, 1, // 1919: check predicate 138
12460 OPC_CheckField, 18, 7, 0, // 1922: check Inst[24:18] == 0x0
12461 OPC_Decode, 150, 109, 196, 1, // 1926: decode to AIF_MASKNOT using decoder 196
12462 // 1926: }
12463 16, 16, // 1931: case 0x10: {
12464 OPC_CheckPredicate, 138, 1, // 1933: check predicate 138
12465 OPC_CheckField, 23, 2, 0, // 1936: check Inst[24:23] == 0x0
12466 OPC_CheckField, 18, 2, 0, // 1940: check Inst[19:18] == 0x0
12467 OPC_Decode, 155, 109, 197, 1, // 1944: decode to AIF_MASKXOR using decoder 197
12468 // 1944: }
12469 24, 16, // 1949: case 0x18: {
12470 OPC_CheckPredicate, 138, 1, // 1951: check predicate 138
12471 OPC_CheckField, 23, 2, 0, // 1954: check Inst[24:23] == 0x0
12472 OPC_CheckField, 18, 2, 0, // 1958: check Inst[19:18] == 0x0
12473 OPC_Decode, 151, 109, 197, 1, // 1962: decode to AIF_MASKOR using decoder 197
12474 // 1962: }
12475 28, 0, // 1967: case 0x1c: {
12476 OPC_CheckPredicate, 138, 1, // 1969: check predicate 138
12477 OPC_CheckField, 23, 2, 0, // 1972: check Inst[24:23] == 0x0
12478 OPC_CheckField, 18, 2, 0, // 1976: check Inst[19:18] == 0x0
12479 OPC_Decode, 149, 109, 197, 1, // 1980: decode to AIF_MASKAND using decoder 197
12480 // 1980: }
12481 // 1980: } // switch Inst[14:10]
12482 // 1980: }
12483 68, 43, // 1985: case 0x44: {
12484 OPC_SwitchField, 12, 3, // 1987: switch Inst[14:12] {
12485 0, 8, // 1990: case 0x0: {
12486 OPC_CheckPredicate, 138, 1, // 1992: check predicate 138
12487 OPC_Decode, 249, 107, 187, 1, // 1995: decode to AIF_CUBEFACE_PS using decoder 187
12488 // 1995: }
12489 1, 8, // 2000: case 0x1: {
12490 OPC_CheckPredicate, 138, 1, // 2002: check predicate 138
12491 OPC_Decode, 248, 107, 187, 1, // 2005: decode to AIF_CUBEFACEIDX_PS using decoder 187
12492 // 2005: }
12493 2, 8, // 2010: case 0x2: {
12494 OPC_CheckPredicate, 138, 1, // 2012: check predicate 138
12495 OPC_Decode, 250, 107, 187, 1, // 2015: decode to AIF_CUBESGNSC_PS using decoder 187
12496 // 2015: }
12497 3, 0, // 2020: case 0x3: {
12498 OPC_CheckPredicate, 138, 1, // 2022: check predicate 138
12499 OPC_Decode, 251, 107, 187, 1, // 2025: decode to AIF_CUBESGNTC_PS using decoder 187
12500 // 2025: }
12501 // 2025: } // switch Inst[14:12]
12502 // 2025: }
12503 80, 63, // 2030: case 0x50: {
12504 OPC_SwitchField, 12, 3, // 2032: switch Inst[14:12] {
12505 0, 8, // 2035: case 0x0: {
12506 OPC_CheckPredicate, 138, 1, // 2037: check predicate 138
12507 OPC_Decode, 206, 108, 187, 1, // 2040: decode to AIF_FLE_PS using decoder 187
12508 // 2040: }
12509 1, 8, // 2045: case 0x1: {
12510 OPC_CheckPredicate, 138, 1, // 2047: check predicate 138
12511 OPC_Decode, 213, 108, 187, 1, // 2050: decode to AIF_FLT_PS using decoder 187
12512 // 2050: }
12513 2, 8, // 2055: case 0x2: {
12514 OPC_CheckPredicate, 138, 1, // 2057: check predicate 138
12515 OPC_Decode, 189, 108, 187, 1, // 2060: decode to AIF_FEQ_PS using decoder 187
12516 // 2060: }
12517 4, 8, // 2065: case 0x4: {
12518 OPC_CheckPredicate, 138, 1, // 2067: check predicate 138
12519 OPC_Decode, 204, 108, 190, 1, // 2070: decode to AIF_FLEM_PS using decoder 190
12520 // 2070: }
12521 5, 8, // 2075: case 0x5: {
12522 OPC_CheckPredicate, 138, 1, // 2077: check predicate 138
12523 OPC_Decode, 210, 108, 190, 1, // 2080: decode to AIF_FLTM_PS using decoder 190
12524 // 2080: }
12525 6, 0, // 2085: case 0x6: {
12526 OPC_CheckPredicate, 138, 1, // 2087: check predicate 138
12527 OPC_Decode, 187, 108, 190, 1, // 2090: decode to AIF_FEQM_PS using decoder 190
12528 // 2090: }
12529 // 2090: } // switch Inst[14:12]
12530 // 2090: }
12531 83, 57, // 2095: case 0x53: {
12532 OPC_SwitchField, 12, 3, // 2097: switch Inst[14:12] {
12533 0, 8, // 2100: case 0x0: {
12534 OPC_CheckPredicate, 138, 1, // 2102: check predicate 138
12535 OPC_Decode, 205, 108, 187, 1, // 2105: decode to AIF_FLE_PI using decoder 187
12536 // 2105: }
12537 1, 8, // 2110: case 0x1: {
12538 OPC_CheckPredicate, 138, 1, // 2112: check predicate 138
12539 OPC_Decode, 212, 108, 187, 1, // 2115: decode to AIF_FLT_PI using decoder 187
12540 // 2115: }
12541 2, 8, // 2120: case 0x2: {
12542 OPC_CheckPredicate, 138, 1, // 2122: check predicate 138
12543 OPC_Decode, 188, 108, 187, 1, // 2125: decode to AIF_FEQ_PI using decoder 187
12544 // 2125: }
12545 3, 8, // 2130: case 0x3: {
12546 OPC_CheckPredicate, 138, 1, // 2132: check predicate 138
12547 OPC_Decode, 211, 108, 187, 1, // 2135: decode to AIF_FLTU_PI using decoder 187
12548 // 2135: }
12549 4, 0, // 2140: case 0x4: {
12550 OPC_CheckPredicate, 138, 1, // 2142: check predicate 138
12551 OPC_CheckField, 20, 5, 0, // 2145: check Inst[24:20] == 0x0
12552 OPC_Decode, 129, 109, 198, 1, // 2149: decode to AIF_FSETM_PI using decoder 198
12553 // 2149: }
12554 // 2149: } // switch Inst[14:12]
12555 // 2149: }
12556 96, 37, // 2154: case 0x60: {
12557 OPC_SwitchField, 20, 5, // 2156: switch Inst[24:20] {
12558 0, 8, // 2159: case 0x0: {
12559 OPC_CheckPredicate, 138, 1, // 2161: check predicate 138
12560 OPC_Decode, 175, 108, 194, 1, // 2164: decode to AIF_FCVT_PW_PS using decoder 194
12561 // 2164: }
12562 1, 8, // 2169: case 0x1: {
12563 OPC_CheckPredicate, 138, 1, // 2171: check predicate 138
12564 OPC_Decode, 174, 108, 194, 1, // 2174: decode to AIF_FCVT_PWU_PS using decoder 194
12565 // 2174: }
12566 2, 0, // 2179: case 0x2: {
12567 OPC_CheckPredicate, 138, 1, // 2181: check predicate 138
12568 OPC_CheckField, 12, 3, 0, // 2184: check Inst[14:12] == 0x0
12569 OPC_Decode, 176, 108, 189, 1, // 2188: decode to AIF_FCVT_RAST_PS using decoder 189
12570 // 2188: }
12571 // 2188: } // switch Inst[24:20]
12572 // 2188: }
12573 104, 177, 1, // 2193: case 0x68: {
12574 OPC_SwitchField, 20, 5, // 2196: switch Inst[24:20] {
12575 0, 8, // 2199: case 0x0: {
12576 OPC_CheckPredicate, 138, 1, // 2201: check predicate 138
12577 OPC_Decode, 164, 108, 194, 1, // 2204: decode to AIF_FCVT_PS_PW using decoder 194
12578 // 2204: }
12579 1, 8, // 2209: case 0x1: {
12580 OPC_CheckPredicate, 138, 1, // 2211: check predicate 138
12581 OPC_Decode, 165, 108, 194, 1, // 2214: decode to AIF_FCVT_PS_PWU using decoder 194
12582 // 2214: }
12583 2, 12, // 2219: case 0x2: {
12584 OPC_CheckPredicate, 138, 1, // 2221: check predicate 138
12585 OPC_CheckField, 12, 3, 0, // 2224: check Inst[14:12] == 0x0
12586 OPC_Decode, 166, 108, 189, 1, // 2228: decode to AIF_FCVT_PS_RAST using decoder 189
12587 // 2228: }
12588 8, 12, // 2233: case 0x8: {
12589 OPC_CheckPredicate, 138, 1, // 2235: check predicate 138
12590 OPC_CheckField, 12, 3, 0, // 2238: check Inst[14:12] == 0x0
12591 OPC_Decode, 161, 108, 189, 1, // 2242: decode to AIF_FCVT_PS_F10 using decoder 189
12592 // 2242: }
12593 9, 12, // 2247: case 0x9: {
12594 OPC_CheckPredicate, 138, 1, // 2249: check predicate 138
12595 OPC_CheckField, 12, 3, 0, // 2252: check Inst[14:12] == 0x0
12596 OPC_Decode, 162, 108, 189, 1, // 2256: decode to AIF_FCVT_PS_F11 using decoder 189
12597 // 2256: }
12598 10, 12, // 2261: case 0xa: {
12599 OPC_CheckPredicate, 138, 1, // 2263: check predicate 138
12600 OPC_CheckField, 12, 3, 0, // 2266: check Inst[14:12] == 0x0
12601 OPC_Decode, 163, 108, 189, 1, // 2270: decode to AIF_FCVT_PS_F16 using decoder 189
12602 // 2270: }
12603 16, 12, // 2275: case 0x10: {
12604 OPC_CheckPredicate, 138, 1, // 2277: check predicate 138
12605 OPC_CheckField, 12, 3, 0, // 2280: check Inst[14:12] == 0x0
12606 OPC_Decode, 172, 108, 189, 1, // 2284: decode to AIF_FCVT_PS_UN24 using decoder 189
12607 // 2284: }
12608 17, 12, // 2289: case 0x11: {
12609 OPC_CheckPredicate, 138, 1, // 2291: check predicate 138
12610 OPC_CheckField, 12, 3, 0, // 2294: check Inst[14:12] == 0x0
12611 OPC_Decode, 170, 108, 189, 1, // 2298: decode to AIF_FCVT_PS_UN16 using decoder 189
12612 // 2298: }
12613 18, 12, // 2303: case 0x12: {
12614 OPC_CheckPredicate, 138, 1, // 2305: check predicate 138
12615 OPC_CheckField, 12, 3, 0, // 2308: check Inst[14:12] == 0x0
12616 OPC_Decode, 169, 108, 189, 1, // 2312: decode to AIF_FCVT_PS_UN10 using decoder 189
12617 // 2312: }
12618 19, 12, // 2317: case 0x13: {
12619 OPC_CheckPredicate, 138, 1, // 2319: check predicate 138
12620 OPC_CheckField, 12, 3, 0, // 2322: check Inst[14:12] == 0x0
12621 OPC_Decode, 173, 108, 189, 1, // 2326: decode to AIF_FCVT_PS_UN8 using decoder 189
12622 // 2326: }
12623 23, 12, // 2331: case 0x17: {
12624 OPC_CheckPredicate, 138, 1, // 2333: check predicate 138
12625 OPC_CheckField, 12, 3, 0, // 2336: check Inst[14:12] == 0x0
12626 OPC_Decode, 171, 108, 189, 1, // 2340: decode to AIF_FCVT_PS_UN2 using decoder 189
12627 // 2340: }
12628 25, 12, // 2345: case 0x19: {
12629 OPC_CheckPredicate, 138, 1, // 2347: check predicate 138
12630 OPC_CheckField, 12, 3, 0, // 2350: check Inst[14:12] == 0x0
12631 OPC_Decode, 167, 108, 189, 1, // 2354: decode to AIF_FCVT_PS_SN16 using decoder 189
12632 // 2354: }
12633 27, 0, // 2359: case 0x1b: {
12634 OPC_CheckPredicate, 138, 1, // 2361: check predicate 138
12635 OPC_CheckField, 12, 3, 0, // 2364: check Inst[14:12] == 0x0
12636 OPC_Decode, 168, 108, 189, 1, // 2368: decode to AIF_FCVT_PS_SN8 using decoder 189
12637 // 2368: }
12638 // 2368: } // switch Inst[24:20]
12639 // 2368: }
12640 107, 34, // 2373: case 0x6b: {
12641 OPC_SwitchField, 12, 3, // 2375: switch Inst[14:12] {
12642 0, 12, // 2378: case 0x0: {
12643 OPC_CheckPredicate, 138, 1, // 2380: check predicate 138
12644 OPC_CheckField, 15, 10, 0, // 2383: check Inst[24:15] == 0x0
12645 OPC_Decode, 157, 109, 199, 1, // 2387: decode to AIF_MOVA_X_M using decoder 199
12646 // 2387: }
12647 1, 0, // 2392: case 0x1: {
12648 OPC_CheckPredicate, 138, 1, // 2394: check predicate 138
12649 OPC_CheckField, 20, 5, 0, // 2397: check Inst[24:20] == 0x0
12650 OPC_CheckField, 7, 5, 0, // 2401: check Inst[11:7] == 0x0
12651 OPC_Decode, 156, 109, 15, // 2405: decode to AIF_MOVA_M_X using decoder 15
12652 // 2405: }
12653 // 2405: } // switch Inst[14:12]
12654 // 2405: }
12655 108, 143, 1, // 2409: case 0x6c: {
12656 OPC_SwitchField, 20, 5, // 2412: switch Inst[24:20] {
12657 8, 12, // 2415: case 0x8: {
12658 OPC_CheckPredicate, 138, 1, // 2417: check predicate 138
12659 OPC_CheckField, 12, 3, 0, // 2420: check Inst[14:12] == 0x0
12660 OPC_Decode, 159, 108, 189, 1, // 2424: decode to AIF_FCVT_F11_PS using decoder 189
12661 // 2424: }
12662 9, 12, // 2429: case 0x9: {
12663 OPC_CheckPredicate, 138, 1, // 2431: check predicate 138
12664 OPC_CheckField, 12, 3, 0, // 2434: check Inst[14:12] == 0x0
12665 OPC_Decode, 160, 108, 189, 1, // 2438: decode to AIF_FCVT_F16_PS using decoder 189
12666 // 2438: }
12667 11, 12, // 2443: case 0xb: {
12668 OPC_CheckPredicate, 138, 1, // 2445: check predicate 138
12669 OPC_CheckField, 12, 3, 0, // 2448: check Inst[14:12] == 0x0
12670 OPC_Decode, 158, 108, 189, 1, // 2452: decode to AIF_FCVT_F10_PS using decoder 189
12671 // 2452: }
12672 16, 12, // 2457: case 0x10: {
12673 OPC_CheckPredicate, 138, 1, // 2459: check predicate 138
12674 OPC_CheckField, 12, 3, 0, // 2462: check Inst[14:12] == 0x0
12675 OPC_Decode, 181, 108, 189, 1, // 2466: decode to AIF_FCVT_UN24_PS using decoder 189
12676 // 2466: }
12677 17, 12, // 2471: case 0x11: {
12678 OPC_CheckPredicate, 138, 1, // 2473: check predicate 138
12679 OPC_CheckField, 12, 3, 0, // 2476: check Inst[14:12] == 0x0
12680 OPC_Decode, 180, 108, 189, 1, // 2480: decode to AIF_FCVT_UN16_PS using decoder 189
12681 // 2480: }
12682 18, 12, // 2485: case 0x12: {
12683 OPC_CheckPredicate, 138, 1, // 2487: check predicate 138
12684 OPC_CheckField, 12, 3, 0, // 2490: check Inst[14:12] == 0x0
12685 OPC_Decode, 179, 108, 189, 1, // 2494: decode to AIF_FCVT_UN10_PS using decoder 189
12686 // 2494: }
12687 19, 12, // 2499: case 0x13: {
12688 OPC_CheckPredicate, 138, 1, // 2501: check predicate 138
12689 OPC_CheckField, 12, 3, 0, // 2504: check Inst[14:12] == 0x0
12690 OPC_Decode, 183, 108, 189, 1, // 2508: decode to AIF_FCVT_UN8_PS using decoder 189
12691 // 2508: }
12692 23, 12, // 2513: case 0x17: {
12693 OPC_CheckPredicate, 138, 1, // 2515: check predicate 138
12694 OPC_CheckField, 12, 3, 0, // 2518: check Inst[14:12] == 0x0
12695 OPC_Decode, 182, 108, 189, 1, // 2522: decode to AIF_FCVT_UN2_PS using decoder 189
12696 // 2522: }
12697 25, 12, // 2527: case 0x19: {
12698 OPC_CheckPredicate, 138, 1, // 2529: check predicate 138
12699 OPC_CheckField, 12, 3, 0, // 2532: check Inst[14:12] == 0x0
12700 OPC_Decode, 177, 108, 189, 1, // 2536: decode to AIF_FCVT_SN16_PS using decoder 189
12701 // 2536: }
12702 27, 0, // 2541: case 0x1b: {
12703 OPC_CheckPredicate, 138, 1, // 2543: check predicate 138
12704 OPC_CheckField, 12, 3, 0, // 2546: check Inst[14:12] == 0x0
12705 OPC_Decode, 178, 108, 189, 1, // 2550: decode to AIF_FCVT_SN8_PS using decoder 189
12706 // 2550: }
12707 // 2550: } // switch Inst[24:20]
12708 // 2550: }
12709 112, 45, // 2555: case 0x70: {
12710 OPC_SwitchField, 12, 3, // 2557: switch Inst[14:12] {
12711 0, 12, // 2560: case 0x0: {
12712 OPC_CheckPredicate, 138, 1, // 2562: check predicate 138
12713 OPC_CheckField, 23, 2, 0, // 2565: check Inst[24:23] == 0x0
12714 OPC_Decode, 230, 108, 200, 1, // 2569: decode to AIF_FMVZ_X_PS using decoder 200
12715 // 2569: }
12716 1, 12, // 2574: case 0x1: {
12717 OPC_CheckPredicate, 138, 1, // 2576: check predicate 138
12718 OPC_CheckField, 20, 5, 0, // 2579: check Inst[24:20] == 0x0
12719 OPC_Decode, 155, 108, 189, 1, // 2583: decode to AIF_FCLASS_PS using decoder 189
12720 // 2583: }
12721 2, 0, // 2588: case 0x2: {
12722 OPC_CheckPredicate, 138, 1, // 2590: check predicate 138
12723 OPC_CheckField, 23, 2, 0, // 2593: check Inst[24:23] == 0x0
12724 OPC_Decode, 229, 108, 200, 1, // 2597: decode to AIF_FMVS_X_PS using decoder 200
12725 // 2597: }
12726 // 2597: } // switch Inst[14:12]
12727 // 2597: }
12728 115, 0, // 2602: case 0x73: {
12729 OPC_CheckPredicate, 138, 1, // 2604: check predicate 138
12730 OPC_Decode, 145, 109, 201, 1, // 2607: decode to AIF_FSWIZZ_PS using decoder 201
12731 // 2607: }
12732 // 2607: } // switch Inst[31:25]
12733 // 2607: }
12734 // 2607: } // switch Inst[6:0]
12735};
12736static const uint8_t DecoderTableXAndes32[612] = {
12737 32, // 0: BitWidth 32
12738 OPC_SwitchField, 12, 2, // 1: switch Inst[13:12] {
12739 0, 150, 3, // 4: case 0x0: {
12740 OPC_SwitchField, 0, 7, // 7: switch Inst[6:0] {
12741 11, 8, // 10: case 0xb: {
12742 OPC_CheckPredicate, 139, 1, // 12: check predicate 139
12743 OPC_Decode, 155, 118, 202, 1, // 15: decode to NDS_LBGP using decoder 202
12744 // 15: }
12745 43, 23, // 20: case 0x2b: {
12746 OPC_SwitchField, 14, 1, // 22: switch Inst[14] {
12747 0, 8, // 25: case 0x0: {
12748 OPC_CheckPredicate, 139, 1, // 27: check predicate 139
12749 OPC_Decode, 171, 118, 203, 1, // 30: decode to NDS_SHGP using decoder 203
12750 // 30: }
12751 1, 0, // 35: case 0x1: {
12752 OPC_CheckPredicate, 139, 1, // 37: check predicate 139
12753 OPC_Decode, 172, 118, 204, 1, // 40: decode to NDS_SWGP using decoder 204
12754 // 40: }
12755 // 40: } // switch Inst[14]
12756 // 40: }
12757 91, 0, // 45: case 0x5b: {
12758 OPC_SwitchField, 26, 6, // 47: switch Inst[31:26] {
12759 0, 95, // 50: case 0x0: {
12760 OPC_SwitchField, 14, 6, // 52: switch Inst[19:14] {
12761 1, 12, // 55: case 0x1: {
12762 OPC_CheckPredicate, 140, 1, // 57: check predicate 140
12763 OPC_CheckField, 25, 1, 0, // 60: check Inst[25] == 0x0
12764 OPC_Decode, 183, 118, 128, 1, // 64: decode to NDS_VFWCVT_S_BF16 using decoder 128
12765 // 64: }
12766 3, 12, // 69: case 0x3: {
12767 OPC_CheckPredicate, 140, 1, // 71: check predicate 140
12768 OPC_CheckField, 25, 1, 0, // 74: check Inst[25] == 0x0
12769 OPC_Decode, 176, 118, 128, 1, // 78: decode to NDS_VFNCVT_BF16_S using decoder 128
12770 // 78: }
12771 5, 12, // 83: case 0x5: {
12772 OPC_CheckPredicate, 141, 1, // 85: check predicate 141
12773 OPC_CheckField, 25, 1, 0, // 88: check Inst[25] == 0x0
12774 OPC_Decode, 148, 118, 205, 1, // 92: decode to NDS_FCVT_S_BF16 using decoder 205
12775 // 92: }
12776 7, 12, // 97: case 0x7: {
12777 OPC_CheckPredicate, 141, 1, // 99: check predicate 141
12778 OPC_CheckField, 25, 1, 0, // 102: check Inst[25] == 0x0
12779 OPC_Decode, 147, 118, 206, 1, // 106: decode to NDS_FCVT_BF16_S using decoder 206
12780 // 106: }
12781 9, 7, // 111: case 0x9: {
12782 OPC_CheckPredicate, 142, 1, // 113: check predicate 142
12783 OPC_Decode, 181, 118, 124, // 116: decode to NDS_VFWCVT_F_N using decoder 124
12784 // 116: }
12785 11, 7, // 120: case 0xb: {
12786 OPC_CheckPredicate, 142, 1, // 122: check predicate 142
12787 OPC_Decode, 182, 118, 124, // 125: decode to NDS_VFWCVT_F_NU using decoder 124
12788 // 125: }
12789 13, 7, // 129: case 0xd: {
12790 OPC_CheckPredicate, 142, 1, // 131: check predicate 142
12791 OPC_Decode, 179, 118, 124, // 134: decode to NDS_VFWCVT_F_B using decoder 124
12792 // 134: }
12793 15, 0, // 138: case 0xf: {
12794 OPC_CheckPredicate, 142, 1, // 140: check predicate 142
12795 OPC_Decode, 180, 118, 124, // 143: decode to NDS_VFWCVT_F_BU using decoder 124
12796 // 143: }
12797 // 143: } // switch Inst[19:14]
12798 // 143: }
12799 1, 46, // 147: case 0x1: {
12800 OPC_SwitchField, 20, 5, // 149: switch Inst[24:20] {
12801 0, 15, // 152: case 0x0: {
12802 OPC_CheckPredicate, 142, 1, // 154: check predicate 142
12803 OPC_CheckField, 25, 1, 1, // 157: check Inst[25] == 0x1
12804 OPC_CheckField, 14, 1, 1, // 161: check Inst[14] == 0x1
12805 OPC_Decode, 184, 118, 2, // 165: decode to NDS_VLE4_V using decoder 2
12806 // 165: }
12807 2, 11, // 169: case 0x2: {
12808 OPC_CheckPredicate, 143, 1, // 171: check predicate 143
12809 OPC_CheckField, 14, 1, 1, // 174: check Inst[14] == 0x1
12810 OPC_Decode, 185, 118, 1, // 178: decode to NDS_VLN8_V using decoder 1
12811 // 178: }
12812 3, 0, // 182: case 0x3: {
12813 OPC_CheckPredicate, 143, 1, // 184: check predicate 143
12814 OPC_CheckField, 14, 1, 1, // 187: check Inst[14] == 0x1
12815 OPC_Decode, 186, 118, 1, // 191: decode to NDS_VLNU8_V using decoder 1
12816 // 191: }
12817 // 191: } // switch Inst[24:20]
12818 // 191: }
12819 2, 26, // 195: case 0x2: {
12820 OPC_SwitchField, 14, 1, // 197: switch Inst[14] {
12821 0, 11, // 200: case 0x0: {
12822 OPC_CheckPredicate, 139, 1, // 202: check predicate 139
12823 OPC_CheckField, 25, 1, 1, // 205: check Inst[25] == 0x1
12824 OPC_Decode, 161, 118, 56, // 209: decode to NDS_LEA_H using decoder 56
12825 // 209: }
12826 1, 0, // 213: case 0x1: {
12827 OPC_CheckPredicate, 144, 1, // 215: check predicate 144
12828 OPC_Decode, 178, 118, 143, 1, // 218: decode to NDS_VFPMADT_VF using decoder 143
12829 // 218: }
12830 // 218: } // switch Inst[14]
12831 // 218: }
12832 3, 36, // 223: case 0x3: {
12833 OPC_SwitchField, 14, 1, // 225: switch Inst[14] {
12834 0, 21, // 228: case 0x0: {
12835 OPC_SwitchField, 25, 1, // 230: switch Inst[25] {
12836 0, 7, // 233: case 0x0: {
12837 OPC_CheckPredicate, 139, 1, // 235: check predicate 139
12838 OPC_Decode, 163, 118, 56, // 238: decode to NDS_LEA_W using decoder 56
12839 // 238: }
12840 1, 0, // 242: case 0x1: {
12841 OPC_CheckPredicate, 139, 1, // 244: check predicate 139
12842 OPC_Decode, 159, 118, 56, // 247: decode to NDS_LEA_D using decoder 56
12843 // 247: }
12844 // 247: } // switch Inst[25]
12845 // 247: }
12846 1, 0, // 251: case 0x1: {
12847 OPC_CheckPredicate, 144, 1, // 253: check predicate 144
12848 OPC_Decode, 177, 118, 143, 1, // 256: decode to NDS_VFPMADB_VF using decoder 143
12849 // 256: }
12850 // 256: } // switch Inst[14]
12851 // 256: }
12852 4, 36, // 261: case 0x4: {
12853 OPC_SwitchField, 14, 1, // 263: switch Inst[14] {
12854 0, 21, // 266: case 0x0: {
12855 OPC_SwitchField, 25, 1, // 268: switch Inst[25] {
12856 0, 7, // 271: case 0x0: {
12857 OPC_CheckPredicate, 145, 1, // 273: check predicate 145
12858 OPC_Decode, 158, 118, 56, // 276: decode to NDS_LEA_B_ZE using decoder 56
12859 // 276: }
12860 1, 0, // 280: case 0x1: {
12861 OPC_CheckPredicate, 145, 1, // 282: check predicate 145
12862 OPC_Decode, 162, 118, 56, // 285: decode to NDS_LEA_H_ZE using decoder 56
12863 // 285: }
12864 // 285: } // switch Inst[25]
12865 // 285: }
12866 1, 0, // 289: case 0x1: {
12867 OPC_CheckPredicate, 146, 1, // 291: check predicate 146
12868 OPC_Decode, 174, 118, 207, 1, // 294: decode to NDS_VD4DOTS_VV using decoder 207
12869 // 294: }
12870 // 294: } // switch Inst[14]
12871 // 294: }
12872 5, 36, // 299: case 0x5: {
12873 OPC_SwitchField, 14, 1, // 301: switch Inst[14] {
12874 0, 21, // 304: case 0x0: {
12875 OPC_SwitchField, 25, 1, // 306: switch Inst[25] {
12876 0, 7, // 309: case 0x0: {
12877 OPC_CheckPredicate, 145, 1, // 311: check predicate 145
12878 OPC_Decode, 164, 118, 56, // 314: decode to NDS_LEA_W_ZE using decoder 56
12879 // 314: }
12880 1, 0, // 318: case 0x1: {
12881 OPC_CheckPredicate, 145, 1, // 320: check predicate 145
12882 OPC_Decode, 160, 118, 56, // 323: decode to NDS_LEA_D_ZE using decoder 56
12883 // 323: }
12884 // 323: } // switch Inst[25]
12885 // 323: }
12886 1, 0, // 327: case 0x1: {
12887 OPC_CheckPredicate, 146, 1, // 329: check predicate 146
12888 OPC_Decode, 173, 118, 207, 1, // 332: decode to NDS_VD4DOTSU_VV using decoder 207
12889 // 332: }
12890 // 332: } // switch Inst[14]
12891 // 332: }
12892 7, 12, // 337: case 0x7: {
12893 OPC_CheckPredicate, 146, 1, // 339: check predicate 146
12894 OPC_CheckField, 14, 1, 1, // 342: check Inst[14] == 0x1
12895 OPC_Decode, 175, 118, 207, 1, // 346: decode to NDS_VD4DOTU_VV using decoder 207
12896 // 346: }
12897 8, 29, // 351: case 0x8: {
12898 OPC_SwitchField, 25, 1, // 353: switch Inst[25] {
12899 0, 11, // 356: case 0x0: {
12900 OPC_CheckPredicate, 139, 1, // 358: check predicate 139
12901 OPC_CheckField, 14, 1, 0, // 361: check Inst[14] == 0x0
12902 OPC_Decode, 149, 118, 31, // 365: decode to NDS_FFB using decoder 31
12903 // 365: }
12904 1, 0, // 369: case 0x1: {
12905 OPC_CheckPredicate, 139, 1, // 371: check predicate 139
12906 OPC_CheckField, 14, 1, 0, // 374: check Inst[14] == 0x0
12907 OPC_Decode, 151, 118, 31, // 378: decode to NDS_FFZMISM using decoder 31
12908 // 378: }
12909 // 378: } // switch Inst[25]
12910 // 378: }
12911 9, 0, // 382: case 0x9: {
12912 OPC_SwitchField, 25, 1, // 384: switch Inst[25] {
12913 0, 11, // 387: case 0x0: {
12914 OPC_CheckPredicate, 139, 1, // 389: check predicate 139
12915 OPC_CheckField, 14, 1, 0, // 392: check Inst[14] == 0x0
12916 OPC_Decode, 150, 118, 31, // 396: decode to NDS_FFMISM using decoder 31
12917 // 396: }
12918 1, 0, // 400: case 0x1: {
12919 OPC_CheckPredicate, 139, 1, // 402: check predicate 139
12920 OPC_CheckField, 14, 1, 0, // 405: check Inst[14] == 0x0
12921 OPC_Decode, 152, 118, 31, // 409: decode to NDS_FLMISM using decoder 31
12922 // 409: }
12923 // 409: } // switch Inst[25]
12924 // 409: }
12925 // 409: } // switch Inst[31:26]
12926 // 409: }
12927 // 409: } // switch Inst[6:0]
12928 // 409: }
12929 1, 52, // 413: case 0x1: {
12930 OPC_SwitchField, 0, 7, // 415: switch Inst[6:0] {
12931 11, 8, // 418: case 0xb: {
12932 OPC_CheckPredicate, 139, 1, // 420: check predicate 139
12933 OPC_Decode, 140, 118, 202, 1, // 423: decode to NDS_ADDIGP using decoder 202
12934 // 423: }
12935 43, 23, // 428: case 0x2b: {
12936 OPC_SwitchField, 14, 1, // 430: switch Inst[14] {
12937 0, 8, // 433: case 0x0: {
12938 OPC_CheckPredicate, 139, 1, // 435: check predicate 139
12939 OPC_Decode, 165, 118, 208, 1, // 438: decode to NDS_LHGP using decoder 208
12940 // 438: }
12941 1, 0, // 443: case 0x1: {
12942 OPC_CheckPredicate, 139, 1, // 445: check predicate 139
12943 OPC_Decode, 166, 118, 208, 1, // 448: decode to NDS_LHUGP using decoder 208
12944 // 448: }
12945 // 448: } // switch Inst[14]
12946 // 448: }
12947 91, 0, // 453: case 0x5b: {
12948 OPC_CheckPredicate, 139, 1, // 455: check predicate 139
12949 OPC_CheckField, 14, 1, 1, // 458: check Inst[14] == 0x1
12950 OPC_Decode, 143, 118, 209, 1, // 462: decode to NDS_BEQC using decoder 209
12951 // 462: }
12952 // 462: } // switch Inst[6:0]
12953 // 462: }
12954 2, 63, // 467: case 0x2: {
12955 OPC_SwitchField, 0, 7, // 469: switch Inst[6:0] {
12956 11, 8, // 472: case 0xb: {
12957 OPC_CheckPredicate, 139, 1, // 474: check predicate 139
12958 OPC_Decode, 156, 118, 202, 1, // 477: decode to NDS_LBUGP using decoder 202
12959 // 477: }
12960 43, 23, // 482: case 0x2b: {
12961 OPC_SwitchField, 14, 1, // 484: switch Inst[14] {
12962 0, 8, // 487: case 0x0: {
12963 OPC_CheckPredicate, 139, 1, // 489: check predicate 139
12964 OPC_Decode, 167, 118, 210, 1, // 492: decode to NDS_LWGP using decoder 210
12965 // 492: }
12966 1, 0, // 497: case 0x1: {
12967 OPC_CheckPredicate, 145, 1, // 499: check predicate 145
12968 OPC_Decode, 168, 118, 210, 1, // 502: decode to NDS_LWUGP using decoder 210
12969 // 502: }
12970 // 502: } // switch Inst[14]
12971 // 502: }
12972 91, 0, // 507: case 0x5b: {
12973 OPC_SwitchField, 14, 1, // 509: switch Inst[14] {
12974 0, 8, // 512: case 0x0: {
12975 OPC_CheckPredicate, 139, 1, // 514: check predicate 139
12976 OPC_Decode, 145, 118, 211, 1, // 517: decode to NDS_BFOZ using decoder 211
12977 // 517: }
12978 1, 0, // 522: case 0x1: {
12979 OPC_CheckPredicate, 139, 1, // 524: check predicate 139
12980 OPC_Decode, 146, 118, 209, 1, // 527: decode to NDS_BNEC using decoder 209
12981 // 527: }
12982 // 527: } // switch Inst[14]
12983 // 527: }
12984 // 527: } // switch Inst[6:0]
12985 // 527: }
12986 3, 0, // 532: case 0x3: {
12987 OPC_SwitchField, 0, 7, // 534: switch Inst[6:0] {
12988 11, 8, // 537: case 0xb: {
12989 OPC_CheckPredicate, 139, 1, // 539: check predicate 139
12990 OPC_Decode, 169, 118, 212, 1, // 542: decode to NDS_SBGP using decoder 212
12991 // 542: }
12992 43, 23, // 547: case 0x2b: {
12993 OPC_SwitchField, 14, 1, // 549: switch Inst[14] {
12994 0, 8, // 552: case 0x0: {
12995 OPC_CheckPredicate, 145, 1, // 554: check predicate 145
12996 OPC_Decode, 157, 118, 213, 1, // 557: decode to NDS_LDGP using decoder 213
12997 // 557: }
12998 1, 0, // 562: case 0x1: {
12999 OPC_CheckPredicate, 145, 1, // 564: check predicate 145
13000 OPC_Decode, 170, 118, 214, 1, // 567: decode to NDS_SDGP using decoder 214
13001 // 567: }
13002 // 567: } // switch Inst[14]
13003 // 567: }
13004 91, 0, // 572: case 0x5b: {
13005 OPC_SwitchField, 14, 1, // 574: switch Inst[14] {
13006 0, 8, // 577: case 0x0: {
13007 OPC_CheckPredicate, 139, 1, // 579: check predicate 139
13008 OPC_Decode, 144, 118, 211, 1, // 582: decode to NDS_BFOS using decoder 211
13009 // 582: }
13010 1, 0, // 587: case 0x1: {
13011 OPC_SwitchField, 30, 1, // 589: switch Inst[30] {
13012 0, 8, // 592: case 0x0: {
13013 OPC_CheckPredicate, 139, 1, // 594: check predicate 139
13014 OPC_Decode, 141, 118, 215, 1, // 597: decode to NDS_BBC using decoder 215
13015 // 597: }
13016 1, 0, // 602: case 0x1: {
13017 OPC_CheckPredicate, 139, 1, // 604: check predicate 139
13018 OPC_Decode, 142, 118, 215, 1, // 607: decode to NDS_BBS using decoder 215
13019 // 607: }
13020 // 607: } // switch Inst[30]
13021 // 607: }
13022 // 607: } // switch Inst[14]
13023 // 607: }
13024 // 607: } // switch Inst[6:0]
13025 // 607: }
13026 // 607: } // switch Inst[13:12]
13027};
13028static const uint8_t DecoderTableXCV32[3680] = {
13029 32, // 0: BitWidth 32
13030 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
13031 0, 190, 4, // 4: case 0x0: {
13032 OPC_SwitchField, 0, 7, // 7: switch Inst[6:0] {
13033 11, 8, // 10: case 0xb: {
13034 OPC_CheckPredicate, 147, 1, // 12: check predicate 147
13035 OPC_Decode, 160, 112, 216, 1, // 15: decode to CV_LB_ri_inc using decoder 216
13036 // 15: }
13037 43, 8, // 20: case 0x2b: {
13038 OPC_CheckPredicate, 147, 1, // 22: check predicate 147
13039 OPC_Decode, 229, 112, 217, 1, // 25: decode to CV_SB_ri_inc using decoder 217
13040 // 25: }
13041 91, 33, // 30: case 0x5b: {
13042 OPC_SwitchField, 30, 2, // 32: switch Inst[31:30] {
13043 0, 8, // 35: case 0x0: {
13044 OPC_CheckPredicate, 148, 1, // 37: check predicate 148
13045 OPC_Decode, 143, 112, 218, 1, // 40: decode to CV_EXTRACT using decoder 218
13046 // 40: }
13047 1, 8, // 45: case 0x1: {
13048 OPC_CheckPredicate, 148, 1, // 47: check predicate 148
13049 OPC_Decode, 145, 112, 218, 1, // 50: decode to CV_EXTRACTU using decoder 218
13050 // 50: }
13051 2, 0, // 55: case 0x2: {
13052 OPC_CheckPredicate, 148, 1, // 57: check predicate 148
13053 OPC_Decode, 153, 112, 219, 1, // 60: decode to CV_INSERT using decoder 219
13054 // 60: }
13055 // 60: } // switch Inst[31:30]
13056 // 60: }
13057 123, 0, // 65: case 0x7b: {
13058 OPC_SwitchField, 26, 6, // 67: switch Inst[31:26] {
13059 0, 11, // 70: case 0x0: {
13060 OPC_CheckPredicate, 149, 1, // 72: check predicate 149
13061 OPC_CheckField, 25, 1, 0, // 75: check Inst[25] == 0x0
13062 OPC_Decode, 143, 111, 31, // 79: decode to CV_ADD_H using decoder 31
13063 // 79: }
13064 1, 11, // 83: case 0x1: {
13065 OPC_CheckPredicate, 149, 1, // 85: check predicate 149
13066 OPC_CheckField, 25, 1, 0, // 88: check Inst[25] == 0x0
13067 OPC_Decode, 179, 111, 31, // 92: decode to CV_CMPEQ_H using decoder 31
13068 // 92: }
13069 2, 11, // 96: case 0x2: {
13070 OPC_CheckPredicate, 149, 1, // 98: check predicate 149
13071 OPC_CheckField, 25, 1, 0, // 101: check Inst[25] == 0x0
13072 OPC_Decode, 170, 113, 31, // 105: decode to CV_SUB_H using decoder 31
13073 // 105: }
13074 3, 11, // 109: case 0x3: {
13075 OPC_CheckPredicate, 149, 1, // 111: check predicate 149
13076 OPC_CheckField, 25, 1, 0, // 114: check Inst[25] == 0x0
13077 OPC_Decode, 233, 111, 31, // 118: decode to CV_CMPNE_H using decoder 31
13078 // 118: }
13079 4, 11, // 122: case 0x4: {
13080 OPC_CheckPredicate, 149, 1, // 124: check predicate 149
13081 OPC_CheckField, 25, 1, 0, // 127: check Inst[25] == 0x0
13082 OPC_Decode, 161, 111, 31, // 131: decode to CV_AVG_H using decoder 31
13083 // 131: }
13084 5, 11, // 135: case 0x5: {
13085 OPC_CheckPredicate, 149, 1, // 137: check predicate 149
13086 OPC_CheckField, 25, 1, 0, // 140: check Inst[25] == 0x0
13087 OPC_Decode, 203, 111, 31, // 144: decode to CV_CMPGT_H using decoder 31
13088 // 144: }
13089 6, 11, // 148: case 0x6: {
13090 OPC_CheckPredicate, 149, 1, // 150: check predicate 149
13091 OPC_CheckField, 25, 1, 0, // 153: check Inst[25] == 0x0
13092 OPC_Decode, 155, 111, 31, // 157: decode to CV_AVGU_H using decoder 31
13093 // 157: }
13094 7, 11, // 161: case 0x7: {
13095 OPC_CheckPredicate, 149, 1, // 163: check predicate 149
13096 OPC_CheckField, 25, 1, 0, // 166: check Inst[25] == 0x0
13097 OPC_Decode, 191, 111, 31, // 170: decode to CV_CMPGE_H using decoder 31
13098 // 170: }
13099 8, 11, // 174: case 0x8: {
13100 OPC_CheckPredicate, 149, 1, // 176: check predicate 149
13101 OPC_CheckField, 25, 1, 0, // 179: check Inst[25] == 0x0
13102 OPC_Decode, 204, 112, 31, // 183: decode to CV_MIN_H using decoder 31
13103 // 183: }
13104 9, 11, // 187: case 0x9: {
13105 OPC_CheckPredicate, 149, 1, // 189: check predicate 149
13106 OPC_CheckField, 25, 1, 0, // 192: check Inst[25] == 0x0
13107 OPC_Decode, 227, 111, 31, // 196: decode to CV_CMPLT_H using decoder 31
13108 // 196: }
13109 10, 11, // 200: case 0xa: {
13110 OPC_CheckPredicate, 149, 1, // 202: check predicate 149
13111 OPC_CheckField, 25, 1, 0, // 205: check Inst[25] == 0x0
13112 OPC_Decode, 198, 112, 31, // 209: decode to CV_MINU_H using decoder 31
13113 // 209: }
13114 11, 11, // 213: case 0xb: {
13115 OPC_CheckPredicate, 149, 1, // 215: check predicate 149
13116 OPC_CheckField, 25, 1, 0, // 218: check Inst[25] == 0x0
13117 OPC_Decode, 215, 111, 31, // 222: decode to CV_CMPLE_H using decoder 31
13118 // 222: }
13119 12, 11, // 226: case 0xc: {
13120 OPC_CheckPredicate, 149, 1, // 228: check predicate 149
13121 OPC_CheckField, 25, 1, 0, // 231: check Inst[25] == 0x0
13122 OPC_Decode, 190, 112, 31, // 235: decode to CV_MAX_H using decoder 31
13123 // 235: }
13124 13, 11, // 239: case 0xd: {
13125 OPC_CheckPredicate, 149, 1, // 241: check predicate 149
13126 OPC_CheckField, 25, 1, 0, // 244: check Inst[25] == 0x0
13127 OPC_Decode, 197, 111, 31, // 248: decode to CV_CMPGTU_H using decoder 31
13128 // 248: }
13129 14, 11, // 252: case 0xe: {
13130 OPC_CheckPredicate, 149, 1, // 254: check predicate 149
13131 OPC_CheckField, 25, 1, 0, // 257: check Inst[25] == 0x0
13132 OPC_Decode, 184, 112, 31, // 261: decode to CV_MAXU_H using decoder 31
13133 // 261: }
13134 15, 11, // 265: case 0xf: {
13135 OPC_CheckPredicate, 149, 1, // 267: check predicate 149
13136 OPC_CheckField, 25, 1, 0, // 270: check Inst[25] == 0x0
13137 OPC_Decode, 185, 111, 31, // 274: decode to CV_CMPGEU_H using decoder 31
13138 // 274: }
13139 16, 11, // 278: case 0x10: {
13140 OPC_CheckPredicate, 149, 1, // 280: check predicate 149
13141 OPC_CheckField, 25, 1, 0, // 283: check Inst[25] == 0x0
13142 OPC_Decode, 149, 113, 31, // 287: decode to CV_SRL_H using decoder 31
13143 // 287: }
13144 17, 11, // 291: case 0x11: {
13145 OPC_CheckPredicate, 149, 1, // 293: check predicate 149
13146 OPC_CheckField, 25, 1, 0, // 296: check Inst[25] == 0x0
13147 OPC_Decode, 221, 111, 31, // 300: decode to CV_CMPLTU_H using decoder 31
13148 // 300: }
13149 18, 11, // 304: case 0x12: {
13150 OPC_CheckPredicate, 149, 1, // 306: check predicate 149
13151 OPC_CheckField, 25, 1, 0, // 309: check Inst[25] == 0x0
13152 OPC_Decode, 143, 113, 31, // 313: decode to CV_SRA_H using decoder 31
13153 // 313: }
13154 19, 11, // 317: case 0x13: {
13155 OPC_CheckPredicate, 149, 1, // 319: check predicate 149
13156 OPC_CheckField, 25, 1, 0, // 322: check Inst[25] == 0x0
13157 OPC_Decode, 209, 111, 31, // 326: decode to CV_CMPLEU_H using decoder 31
13158 // 326: }
13159 20, 11, // 330: case 0x14: {
13160 OPC_CheckPredicate, 149, 1, // 332: check predicate 149
13161 OPC_CheckField, 25, 1, 0, // 335: check Inst[25] == 0x0
13162 OPC_Decode, 137, 113, 31, // 339: decode to CV_SLL_H using decoder 31
13163 // 339: }
13164 21, 21, // 343: case 0x15: {
13165 OPC_SwitchField, 25, 1, // 345: switch Inst[25] {
13166 0, 7, // 348: case 0x0: {
13167 OPC_CheckPredicate, 149, 1, // 350: check predicate 149
13168 OPC_Decode, 244, 111, 61, // 353: decode to CV_CPLXMUL_R using decoder 61
13169 // 353: }
13170 1, 0, // 357: case 0x1: {
13171 OPC_CheckPredicate, 149, 1, // 359: check predicate 149
13172 OPC_Decode, 240, 111, 61, // 362: decode to CV_CPLXMUL_I using decoder 61
13173 // 362: }
13174 // 362: } // switch Inst[25]
13175 // 362: }
13176 22, 11, // 366: case 0x16: {
13177 OPC_CheckPredicate, 149, 1, // 368: check predicate 149
13178 OPC_CheckField, 25, 1, 0, // 371: check Inst[25] == 0x0
13179 OPC_Decode, 219, 112, 31, // 375: decode to CV_OR_H using decoder 31
13180 // 375: }
13181 23, 11, // 379: case 0x17: {
13182 OPC_CheckPredicate, 149, 1, // 381: check predicate 149
13183 OPC_CheckField, 20, 6, 0, // 384: check Inst[25:20] == 0x0
13184 OPC_Decode, 239, 111, 17, // 388: decode to CV_CPLXCONJ using decoder 17
13185 // 388: }
13186 24, 11, // 392: case 0x18: {
13187 OPC_CheckPredicate, 149, 1, // 394: check predicate 149
13188 OPC_CheckField, 25, 1, 0, // 397: check Inst[25] == 0x0
13189 OPC_Decode, 179, 113, 31, // 401: decode to CV_XOR_H using decoder 31
13190 // 401: }
13191 25, 11, // 405: case 0x19: {
13192 OPC_CheckPredicate, 149, 1, // 407: check predicate 149
13193 OPC_CheckField, 25, 1, 0, // 410: check Inst[25] == 0x0
13194 OPC_Decode, 158, 113, 31, // 414: decode to CV_SUBROTMJ using decoder 31
13195 // 414: }
13196 26, 11, // 418: case 0x1a: {
13197 OPC_CheckPredicate, 149, 1, // 420: check predicate 149
13198 OPC_CheckField, 25, 1, 0, // 423: check Inst[25] == 0x0
13199 OPC_Decode, 149, 111, 31, // 427: decode to CV_AND_H using decoder 31
13200 // 427: }
13201 28, 11, // 431: case 0x1c: {
13202 OPC_CheckPredicate, 149, 1, // 433: check predicate 149
13203 OPC_CheckField, 20, 6, 0, // 436: check Inst[25:20] == 0x0
13204 OPC_Decode, 130, 111, 17, // 440: decode to CV_ABS_H using decoder 17
13205 // 440: }
13206 32, 11, // 444: case 0x20: {
13207 OPC_CheckPredicate, 149, 1, // 446: check predicate 149
13208 OPC_CheckField, 25, 1, 0, // 449: check Inst[25] == 0x0
13209 OPC_Decode, 255, 111, 31, // 453: decode to CV_DOTUP_H using decoder 31
13210 // 453: }
13211 34, 11, // 457: case 0x22: {
13212 OPC_CheckPredicate, 149, 1, // 459: check predicate 149
13213 OPC_CheckField, 25, 1, 0, // 462: check Inst[25] == 0x0
13214 OPC_Decode, 133, 112, 31, // 466: decode to CV_DOTUSP_H using decoder 31
13215 // 466: }
13216 36, 11, // 470: case 0x24: {
13217 OPC_CheckPredicate, 149, 1, // 472: check predicate 149
13218 OPC_CheckField, 25, 1, 0, // 475: check Inst[25] == 0x0
13219 OPC_Decode, 249, 111, 31, // 479: decode to CV_DOTSP_H using decoder 31
13220 // 479: }
13221 38, 11, // 483: case 0x26: {
13222 OPC_CheckPredicate, 149, 1, // 485: check predicate 149
13223 OPC_CheckField, 25, 1, 0, // 488: check Inst[25] == 0x0
13224 OPC_Decode, 239, 112, 61, // 492: decode to CV_SDOTUP_H using decoder 61
13225 // 492: }
13226 40, 11, // 496: case 0x28: {
13227 OPC_CheckPredicate, 149, 1, // 498: check predicate 149
13228 OPC_CheckField, 25, 1, 0, // 501: check Inst[25] == 0x0
13229 OPC_Decode, 245, 112, 61, // 505: decode to CV_SDOTUSP_H using decoder 61
13230 // 505: }
13231 42, 11, // 509: case 0x2a: {
13232 OPC_CheckPredicate, 149, 1, // 511: check predicate 149
13233 OPC_CheckField, 25, 1, 0, // 514: check Inst[25] == 0x0
13234 OPC_Decode, 233, 112, 61, // 518: decode to CV_SDOTSP_H using decoder 61
13235 // 518: }
13236 46, 8, // 522: case 0x2e: {
13237 OPC_CheckPredicate, 149, 1, // 524: check predicate 149
13238 OPC_Decode, 150, 112, 220, 1, // 527: decode to CV_EXTRACT_H using decoder 220
13239 // 527: }
13240 48, 11, // 532: case 0x30: {
13241 OPC_CheckPredicate, 149, 1, // 534: check predicate 149
13242 OPC_CheckField, 25, 1, 0, // 537: check Inst[25] == 0x0
13243 OPC_Decode, 129, 113, 31, // 541: decode to CV_SHUFFLE_H using decoder 31
13244 // 541: }
13245 56, 11, // 545: case 0x38: {
13246 OPC_CheckPredicate, 149, 1, // 547: check predicate 149
13247 OPC_CheckField, 25, 1, 0, // 550: check Inst[25] == 0x0
13248 OPC_Decode, 251, 112, 61, // 554: decode to CV_SHUFFLE2_H using decoder 61
13249 // 554: }
13250 60, 0, // 558: case 0x3c: {
13251 OPC_SwitchField, 25, 1, // 560: switch Inst[25] {
13252 0, 7, // 563: case 0x0: {
13253 OPC_CheckPredicate, 149, 1, // 565: check predicate 149
13254 OPC_Decode, 224, 112, 31, // 568: decode to CV_PACK using decoder 31
13255 // 568: }
13256 1, 0, // 572: case 0x1: {
13257 OPC_CheckPredicate, 149, 1, // 574: check predicate 149
13258 OPC_Decode, 227, 112, 31, // 577: decode to CV_PACK_H using decoder 31
13259 // 577: }
13260 // 577: } // switch Inst[25]
13261 // 577: }
13262 // 577: } // switch Inst[31:26]
13263 // 577: }
13264 // 577: } // switch Inst[6:0]
13265 // 577: }
13266 1, 141, 4, // 581: case 0x1: {
13267 OPC_SwitchField, 0, 7, // 584: switch Inst[6:0] {
13268 11, 8, // 587: case 0xb: {
13269 OPC_CheckPredicate, 147, 1, // 589: check predicate 147
13270 OPC_Decode, 166, 112, 216, 1, // 592: decode to CV_LH_ri_inc using decoder 216
13271 // 592: }
13272 43, 8, // 597: case 0x2b: {
13273 OPC_CheckPredicate, 147, 1, // 599: check predicate 147
13274 OPC_Decode, 131, 113, 217, 1, // 602: decode to CV_SH_ri_inc using decoder 217
13275 // 602: }
13276 91, 33, // 607: case 0x5b: {
13277 OPC_SwitchField, 30, 2, // 609: switch Inst[31:30] {
13278 0, 8, // 612: case 0x0: {
13279 OPC_CheckPredicate, 148, 1, // 614: check predicate 148
13280 OPC_Decode, 166, 111, 218, 1, // 617: decode to CV_BCLR using decoder 218
13281 // 617: }
13282 1, 8, // 622: case 0x1: {
13283 OPC_CheckPredicate, 148, 1, // 624: check predicate 148
13284 OPC_Decode, 171, 111, 218, 1, // 627: decode to CV_BSET using decoder 218
13285 // 627: }
13286 3, 0, // 632: case 0x3: {
13287 OPC_CheckPredicate, 148, 1, // 634: check predicate 148
13288 OPC_Decode, 169, 111, 221, 1, // 637: decode to CV_BITREV using decoder 221
13289 // 637: }
13290 // 637: } // switch Inst[31:30]
13291 // 637: }
13292 123, 0, // 642: case 0x7b: {
13293 OPC_SwitchField, 26, 6, // 644: switch Inst[31:26] {
13294 0, 11, // 647: case 0x0: {
13295 OPC_CheckPredicate, 149, 1, // 649: check predicate 149
13296 OPC_CheckField, 25, 1, 0, // 652: check Inst[25] == 0x0
13297 OPC_Decode, 139, 111, 31, // 656: decode to CV_ADD_B using decoder 31
13298 // 656: }
13299 1, 11, // 660: case 0x1: {
13300 OPC_CheckPredicate, 149, 1, // 662: check predicate 149
13301 OPC_CheckField, 25, 1, 0, // 665: check Inst[25] == 0x0
13302 OPC_Decode, 178, 111, 31, // 669: decode to CV_CMPEQ_B using decoder 31
13303 // 669: }
13304 2, 11, // 673: case 0x2: {
13305 OPC_CheckPredicate, 149, 1, // 675: check predicate 149
13306 OPC_CheckField, 25, 1, 0, // 678: check Inst[25] == 0x0
13307 OPC_Decode, 166, 113, 31, // 682: decode to CV_SUB_B using decoder 31
13308 // 682: }
13309 3, 11, // 686: case 0x3: {
13310 OPC_CheckPredicate, 149, 1, // 688: check predicate 149
13311 OPC_CheckField, 25, 1, 0, // 691: check Inst[25] == 0x0
13312 OPC_Decode, 232, 111, 31, // 695: decode to CV_CMPNE_B using decoder 31
13313 // 695: }
13314 4, 11, // 699: case 0x4: {
13315 OPC_CheckPredicate, 149, 1, // 701: check predicate 149
13316 OPC_CheckField, 25, 1, 0, // 704: check Inst[25] == 0x0
13317 OPC_Decode, 160, 111, 31, // 708: decode to CV_AVG_B using decoder 31
13318 // 708: }
13319 5, 11, // 712: case 0x5: {
13320 OPC_CheckPredicate, 149, 1, // 714: check predicate 149
13321 OPC_CheckField, 25, 1, 0, // 717: check Inst[25] == 0x0
13322 OPC_Decode, 202, 111, 31, // 721: decode to CV_CMPGT_B using decoder 31
13323 // 721: }
13324 6, 11, // 725: case 0x6: {
13325 OPC_CheckPredicate, 149, 1, // 727: check predicate 149
13326 OPC_CheckField, 25, 1, 0, // 730: check Inst[25] == 0x0
13327 OPC_Decode, 154, 111, 31, // 734: decode to CV_AVGU_B using decoder 31
13328 // 734: }
13329 7, 11, // 738: case 0x7: {
13330 OPC_CheckPredicate, 149, 1, // 740: check predicate 149
13331 OPC_CheckField, 25, 1, 0, // 743: check Inst[25] == 0x0
13332 OPC_Decode, 190, 111, 31, // 747: decode to CV_CMPGE_B using decoder 31
13333 // 747: }
13334 8, 11, // 751: case 0x8: {
13335 OPC_CheckPredicate, 149, 1, // 753: check predicate 149
13336 OPC_CheckField, 25, 1, 0, // 756: check Inst[25] == 0x0
13337 OPC_Decode, 203, 112, 31, // 760: decode to CV_MIN_B using decoder 31
13338 // 760: }
13339 9, 11, // 764: case 0x9: {
13340 OPC_CheckPredicate, 149, 1, // 766: check predicate 149
13341 OPC_CheckField, 25, 1, 0, // 769: check Inst[25] == 0x0
13342 OPC_Decode, 226, 111, 31, // 773: decode to CV_CMPLT_B using decoder 31
13343 // 773: }
13344 10, 11, // 777: case 0xa: {
13345 OPC_CheckPredicate, 149, 1, // 779: check predicate 149
13346 OPC_CheckField, 25, 1, 0, // 782: check Inst[25] == 0x0
13347 OPC_Decode, 197, 112, 31, // 786: decode to CV_MINU_B using decoder 31
13348 // 786: }
13349 11, 11, // 790: case 0xb: {
13350 OPC_CheckPredicate, 149, 1, // 792: check predicate 149
13351 OPC_CheckField, 25, 1, 0, // 795: check Inst[25] == 0x0
13352 OPC_Decode, 214, 111, 31, // 799: decode to CV_CMPLE_B using decoder 31
13353 // 799: }
13354 12, 11, // 803: case 0xc: {
13355 OPC_CheckPredicate, 149, 1, // 805: check predicate 149
13356 OPC_CheckField, 25, 1, 0, // 808: check Inst[25] == 0x0
13357 OPC_Decode, 189, 112, 31, // 812: decode to CV_MAX_B using decoder 31
13358 // 812: }
13359 13, 11, // 816: case 0xd: {
13360 OPC_CheckPredicate, 149, 1, // 818: check predicate 149
13361 OPC_CheckField, 25, 1, 0, // 821: check Inst[25] == 0x0
13362 OPC_Decode, 196, 111, 31, // 825: decode to CV_CMPGTU_B using decoder 31
13363 // 825: }
13364 14, 11, // 829: case 0xe: {
13365 OPC_CheckPredicate, 149, 1, // 831: check predicate 149
13366 OPC_CheckField, 25, 1, 0, // 834: check Inst[25] == 0x0
13367 OPC_Decode, 183, 112, 31, // 838: decode to CV_MAXU_B using decoder 31
13368 // 838: }
13369 15, 11, // 842: case 0xf: {
13370 OPC_CheckPredicate, 149, 1, // 844: check predicate 149
13371 OPC_CheckField, 25, 1, 0, // 847: check Inst[25] == 0x0
13372 OPC_Decode, 184, 111, 31, // 851: decode to CV_CMPGEU_B using decoder 31
13373 // 851: }
13374 16, 11, // 855: case 0x10: {
13375 OPC_CheckPredicate, 149, 1, // 857: check predicate 149
13376 OPC_CheckField, 25, 1, 0, // 860: check Inst[25] == 0x0
13377 OPC_Decode, 148, 113, 31, // 864: decode to CV_SRL_B using decoder 31
13378 // 864: }
13379 17, 11, // 868: case 0x11: {
13380 OPC_CheckPredicate, 149, 1, // 870: check predicate 149
13381 OPC_CheckField, 25, 1, 0, // 873: check Inst[25] == 0x0
13382 OPC_Decode, 220, 111, 31, // 877: decode to CV_CMPLTU_B using decoder 31
13383 // 877: }
13384 18, 11, // 881: case 0x12: {
13385 OPC_CheckPredicate, 149, 1, // 883: check predicate 149
13386 OPC_CheckField, 25, 1, 0, // 886: check Inst[25] == 0x0
13387 OPC_Decode, 142, 113, 31, // 890: decode to CV_SRA_B using decoder 31
13388 // 890: }
13389 19, 11, // 894: case 0x13: {
13390 OPC_CheckPredicate, 149, 1, // 896: check predicate 149
13391 OPC_CheckField, 25, 1, 0, // 899: check Inst[25] == 0x0
13392 OPC_Decode, 208, 111, 31, // 903: decode to CV_CMPLEU_B using decoder 31
13393 // 903: }
13394 20, 11, // 907: case 0x14: {
13395 OPC_CheckPredicate, 149, 1, // 909: check predicate 149
13396 OPC_CheckField, 25, 1, 0, // 912: check Inst[25] == 0x0
13397 OPC_Decode, 136, 113, 31, // 916: decode to CV_SLL_B using decoder 31
13398 // 916: }
13399 22, 11, // 920: case 0x16: {
13400 OPC_CheckPredicate, 149, 1, // 922: check predicate 149
13401 OPC_CheckField, 25, 1, 0, // 925: check Inst[25] == 0x0
13402 OPC_Decode, 218, 112, 31, // 929: decode to CV_OR_B using decoder 31
13403 // 929: }
13404 24, 11, // 933: case 0x18: {
13405 OPC_CheckPredicate, 149, 1, // 935: check predicate 149
13406 OPC_CheckField, 25, 1, 0, // 938: check Inst[25] == 0x0
13407 OPC_Decode, 178, 113, 31, // 942: decode to CV_XOR_B using decoder 31
13408 // 942: }
13409 26, 11, // 946: case 0x1a: {
13410 OPC_CheckPredicate, 149, 1, // 948: check predicate 149
13411 OPC_CheckField, 25, 1, 0, // 951: check Inst[25] == 0x0
13412 OPC_Decode, 148, 111, 31, // 955: decode to CV_AND_B using decoder 31
13413 // 955: }
13414 28, 11, // 959: case 0x1c: {
13415 OPC_CheckPredicate, 149, 1, // 961: check predicate 149
13416 OPC_CheckField, 20, 6, 0, // 964: check Inst[25:20] == 0x0
13417 OPC_Decode, 129, 111, 17, // 968: decode to CV_ABS_B using decoder 17
13418 // 968: }
13419 32, 11, // 972: case 0x20: {
13420 OPC_CheckPredicate, 149, 1, // 974: check predicate 149
13421 OPC_CheckField, 25, 1, 0, // 977: check Inst[25] == 0x0
13422 OPC_Decode, 254, 111, 31, // 981: decode to CV_DOTUP_B using decoder 31
13423 // 981: }
13424 34, 11, // 985: case 0x22: {
13425 OPC_CheckPredicate, 149, 1, // 987: check predicate 149
13426 OPC_CheckField, 25, 1, 0, // 990: check Inst[25] == 0x0
13427 OPC_Decode, 132, 112, 31, // 994: decode to CV_DOTUSP_B using decoder 31
13428 // 994: }
13429 36, 11, // 998: case 0x24: {
13430 OPC_CheckPredicate, 149, 1, // 1000: check predicate 149
13431 OPC_CheckField, 25, 1, 0, // 1003: check Inst[25] == 0x0
13432 OPC_Decode, 248, 111, 31, // 1007: decode to CV_DOTSP_B using decoder 31
13433 // 1007: }
13434 38, 11, // 1011: case 0x26: {
13435 OPC_CheckPredicate, 149, 1, // 1013: check predicate 149
13436 OPC_CheckField, 25, 1, 0, // 1016: check Inst[25] == 0x0
13437 OPC_Decode, 238, 112, 61, // 1020: decode to CV_SDOTUP_B using decoder 61
13438 // 1020: }
13439 40, 11, // 1024: case 0x28: {
13440 OPC_CheckPredicate, 149, 1, // 1026: check predicate 149
13441 OPC_CheckField, 25, 1, 0, // 1029: check Inst[25] == 0x0
13442 OPC_Decode, 244, 112, 61, // 1033: decode to CV_SDOTUSP_B using decoder 61
13443 // 1033: }
13444 42, 11, // 1037: case 0x2a: {
13445 OPC_CheckPredicate, 149, 1, // 1039: check predicate 149
13446 OPC_CheckField, 25, 1, 0, // 1042: check Inst[25] == 0x0
13447 OPC_Decode, 232, 112, 61, // 1046: decode to CV_SDOTSP_B using decoder 61
13448 // 1046: }
13449 46, 8, // 1050: case 0x2e: {
13450 OPC_CheckPredicate, 149, 1, // 1052: check predicate 149
13451 OPC_Decode, 149, 112, 220, 1, // 1055: decode to CV_EXTRACT_B using decoder 220
13452 // 1055: }
13453 48, 11, // 1060: case 0x30: {
13454 OPC_CheckPredicate, 149, 1, // 1062: check predicate 149
13455 OPC_CheckField, 25, 1, 0, // 1065: check Inst[25] == 0x0
13456 OPC_Decode, 128, 113, 31, // 1069: decode to CV_SHUFFLE_B using decoder 31
13457 // 1069: }
13458 56, 11, // 1073: case 0x38: {
13459 OPC_CheckPredicate, 149, 1, // 1075: check predicate 149
13460 OPC_CheckField, 25, 1, 0, // 1078: check Inst[25] == 0x0
13461 OPC_Decode, 250, 112, 61, // 1082: decode to CV_SHUFFLE2_B using decoder 61
13462 // 1082: }
13463 62, 0, // 1086: case 0x3e: {
13464 OPC_SwitchField, 25, 1, // 1088: switch Inst[25] {
13465 0, 7, // 1091: case 0x0: {
13466 OPC_CheckPredicate, 149, 1, // 1093: check predicate 149
13467 OPC_Decode, 226, 112, 61, // 1096: decode to CV_PACKLO_B using decoder 61
13468 // 1096: }
13469 1, 0, // 1100: case 0x1: {
13470 OPC_CheckPredicate, 149, 1, // 1102: check predicate 149
13471 OPC_Decode, 225, 112, 61, // 1105: decode to CV_PACKHI_B using decoder 61
13472 // 1105: }
13473 // 1105: } // switch Inst[25]
13474 // 1105: }
13475 // 1105: } // switch Inst[31:26]
13476 // 1105: }
13477 // 1105: } // switch Inst[6:0]
13478 // 1105: }
13479 2, 145, 1, // 1109: case 0x2: {
13480 OPC_SwitchField, 0, 7, // 1112: switch Inst[6:0] {
13481 11, 8, // 1115: case 0xb: {
13482 OPC_CheckPredicate, 147, 1, // 1117: check predicate 147
13483 OPC_Decode, 169, 112, 216, 1, // 1120: decode to CV_LW_ri_inc using decoder 216
13484 // 1120: }
13485 43, 8, // 1125: case 0x2b: {
13486 OPC_CheckPredicate, 147, 1, // 1127: check predicate 147
13487 OPC_Decode, 175, 113, 217, 1, // 1130: decode to CV_SW_ri_inc using decoder 217
13488 // 1130: }
13489 91, 43, // 1135: case 0x5b: {
13490 OPC_SwitchField, 30, 2, // 1137: switch Inst[31:30] {
13491 0, 8, // 1140: case 0x0: {
13492 OPC_CheckPredicate, 150, 1, // 1142: check predicate 150
13493 OPC_Decode, 131, 111, 222, 1, // 1145: decode to CV_ADDN using decoder 222
13494 // 1145: }
13495 1, 8, // 1150: case 0x1: {
13496 OPC_CheckPredicate, 150, 1, // 1152: check predicate 150
13497 OPC_Decode, 135, 111, 222, 1, // 1155: decode to CV_ADDUN using decoder 222
13498 // 1155: }
13499 2, 8, // 1160: case 0x2: {
13500 OPC_CheckPredicate, 150, 1, // 1162: check predicate 150
13501 OPC_Decode, 133, 111, 222, 1, // 1165: decode to CV_ADDRN using decoder 222
13502 // 1165: }
13503 3, 0, // 1170: case 0x3: {
13504 OPC_CheckPredicate, 150, 1, // 1172: check predicate 150
13505 OPC_Decode, 137, 111, 222, 1, // 1175: decode to CV_ADDURN using decoder 222
13506 // 1175: }
13507 // 1175: } // switch Inst[31:30]
13508 // 1175: }
13509 123, 0, // 1180: case 0x7b: {
13510 OPC_SwitchField, 26, 6, // 1182: switch Inst[31:26] {
13511 21, 21, // 1185: case 0x15: {
13512 OPC_SwitchField, 25, 1, // 1187: switch Inst[25] {
13513 0, 7, // 1190: case 0x0: {
13514 OPC_CheckPredicate, 149, 1, // 1192: check predicate 149
13515 OPC_Decode, 245, 111, 61, // 1195: decode to CV_CPLXMUL_R_DIV2 using decoder 61
13516 // 1195: }
13517 1, 0, // 1199: case 0x1: {
13518 OPC_CheckPredicate, 149, 1, // 1201: check predicate 149
13519 OPC_Decode, 241, 111, 61, // 1204: decode to CV_CPLXMUL_I_DIV2 using decoder 61
13520 // 1204: }
13521 // 1204: } // switch Inst[25]
13522 // 1204: }
13523 25, 11, // 1208: case 0x19: {
13524 OPC_CheckPredicate, 149, 1, // 1210: check predicate 149
13525 OPC_CheckField, 25, 1, 0, // 1213: check Inst[25] == 0x0
13526 OPC_Decode, 159, 113, 31, // 1217: decode to CV_SUBROTMJ_DIV2 using decoder 31
13527 // 1217: }
13528 27, 11, // 1221: case 0x1b: {
13529 OPC_CheckPredicate, 149, 1, // 1223: check predicate 149
13530 OPC_CheckField, 25, 1, 0, // 1226: check Inst[25] == 0x0
13531 OPC_Decode, 140, 111, 31, // 1230: decode to CV_ADD_DIV2 using decoder 31
13532 // 1230: }
13533 29, 11, // 1234: case 0x1d: {
13534 OPC_CheckPredicate, 149, 1, // 1236: check predicate 149
13535 OPC_CheckField, 25, 1, 0, // 1239: check Inst[25] == 0x0
13536 OPC_Decode, 167, 113, 31, // 1243: decode to CV_SUB_DIV2 using decoder 31
13537 // 1243: }
13538 46, 0, // 1247: case 0x2e: {
13539 OPC_CheckPredicate, 149, 1, // 1249: check predicate 149
13540 OPC_Decode, 148, 112, 220, 1, // 1252: decode to CV_EXTRACTU_H using decoder 220
13541 // 1252: }
13542 // 1252: } // switch Inst[31:26]
13543 // 1252: }
13544 // 1252: } // switch Inst[6:0]
13545 // 1252: }
13546 3, 199, 4, // 1257: case 0x3: {
13547 OPC_SwitchField, 0, 7, // 1260: switch Inst[6:0] {
13548 11, 7, // 1263: case 0xb: {
13549 OPC_CheckPredicate, 151, 1, // 1265: check predicate 151
13550 OPC_Decode, 138, 112, 0, // 1268: decode to CV_ELW using decoder 0
13551 // 1268: }
13552 43, 253, 3, // 1272: case 0x2b: {
13553 OPC_SwitchField, 25, 7, // 1275: switch Inst[31:25] {
13554 0, 8, // 1278: case 0x0: {
13555 OPC_CheckPredicate, 147, 1, // 1280: check predicate 147
13556 OPC_Decode, 162, 112, 223, 1, // 1283: decode to CV_LB_rr_inc using decoder 223
13557 // 1283: }
13558 1, 8, // 1288: case 0x1: {
13559 OPC_CheckPredicate, 147, 1, // 1290: check predicate 147
13560 OPC_Decode, 168, 112, 223, 1, // 1293: decode to CV_LH_rr_inc using decoder 223
13561 // 1293: }
13562 2, 8, // 1298: case 0x2: {
13563 OPC_CheckPredicate, 147, 1, // 1300: check predicate 147
13564 OPC_Decode, 171, 112, 223, 1, // 1303: decode to CV_LW_rr_inc using decoder 223
13565 // 1303: }
13566 4, 7, // 1308: case 0x4: {
13567 OPC_CheckPredicate, 147, 1, // 1310: check predicate 147
13568 OPC_Decode, 161, 112, 31, // 1313: decode to CV_LB_rr using decoder 31
13569 // 1313: }
13570 5, 7, // 1317: case 0x5: {
13571 OPC_CheckPredicate, 147, 1, // 1319: check predicate 147
13572 OPC_Decode, 167, 112, 31, // 1322: decode to CV_LH_rr using decoder 31
13573 // 1322: }
13574 6, 7, // 1326: case 0x6: {
13575 OPC_CheckPredicate, 147, 1, // 1328: check predicate 147
13576 OPC_Decode, 170, 112, 31, // 1331: decode to CV_LW_rr using decoder 31
13577 // 1331: }
13578 8, 8, // 1335: case 0x8: {
13579 OPC_CheckPredicate, 147, 1, // 1337: check predicate 147
13580 OPC_Decode, 159, 112, 223, 1, // 1340: decode to CV_LBU_rr_inc using decoder 223
13581 // 1340: }
13582 9, 8, // 1345: case 0x9: {
13583 OPC_CheckPredicate, 147, 1, // 1347: check predicate 147
13584 OPC_Decode, 165, 112, 223, 1, // 1350: decode to CV_LHU_rr_inc using decoder 223
13585 // 1350: }
13586 12, 7, // 1355: case 0xc: {
13587 OPC_CheckPredicate, 147, 1, // 1357: check predicate 147
13588 OPC_Decode, 158, 112, 31, // 1360: decode to CV_LBU_rr using decoder 31
13589 // 1360: }
13590 13, 7, // 1364: case 0xd: {
13591 OPC_CheckPredicate, 147, 1, // 1366: check predicate 147
13592 OPC_Decode, 164, 112, 31, // 1369: decode to CV_LHU_rr using decoder 31
13593 // 1369: }
13594 16, 8, // 1373: case 0x10: {
13595 OPC_CheckPredicate, 147, 1, // 1375: check predicate 147
13596 OPC_Decode, 231, 112, 224, 1, // 1378: decode to CV_SB_rr_inc using decoder 224
13597 // 1378: }
13598 17, 8, // 1383: case 0x11: {
13599 OPC_CheckPredicate, 147, 1, // 1385: check predicate 147
13600 OPC_Decode, 133, 113, 224, 1, // 1388: decode to CV_SH_rr_inc using decoder 224
13601 // 1388: }
13602 18, 8, // 1393: case 0x12: {
13603 OPC_CheckPredicate, 147, 1, // 1395: check predicate 147
13604 OPC_Decode, 177, 113, 224, 1, // 1398: decode to CV_SW_rr_inc using decoder 224
13605 // 1398: }
13606 20, 8, // 1403: case 0x14: {
13607 OPC_CheckPredicate, 147, 1, // 1405: check predicate 147
13608 OPC_Decode, 230, 112, 225, 1, // 1408: decode to CV_SB_rr using decoder 225
13609 // 1408: }
13610 21, 8, // 1413: case 0x15: {
13611 OPC_CheckPredicate, 147, 1, // 1415: check predicate 147
13612 OPC_Decode, 132, 113, 225, 1, // 1418: decode to CV_SH_rr using decoder 225
13613 // 1418: }
13614 22, 8, // 1423: case 0x16: {
13615 OPC_CheckPredicate, 147, 1, // 1425: check predicate 147
13616 OPC_Decode, 176, 113, 225, 1, // 1428: decode to CV_SW_rr using decoder 225
13617 // 1428: }
13618 24, 7, // 1433: case 0x18: {
13619 OPC_CheckPredicate, 148, 1, // 1435: check predicate 148
13620 OPC_Decode, 144, 112, 31, // 1438: decode to CV_EXTRACTR using decoder 31
13621 // 1438: }
13622 25, 7, // 1442: case 0x19: {
13623 OPC_CheckPredicate, 148, 1, // 1444: check predicate 148
13624 OPC_Decode, 146, 112, 31, // 1447: decode to CV_EXTRACTUR using decoder 31
13625 // 1447: }
13626 26, 7, // 1451: case 0x1a: {
13627 OPC_CheckPredicate, 148, 1, // 1453: check predicate 148
13628 OPC_Decode, 154, 112, 61, // 1456: decode to CV_INSERTR using decoder 61
13629 // 1456: }
13630 28, 7, // 1460: case 0x1c: {
13631 OPC_CheckPredicate, 148, 1, // 1462: check predicate 148
13632 OPC_Decode, 167, 111, 31, // 1465: decode to CV_BCLRR using decoder 31
13633 // 1465: }
13634 29, 7, // 1469: case 0x1d: {
13635 OPC_CheckPredicate, 148, 1, // 1471: check predicate 148
13636 OPC_Decode, 172, 111, 31, // 1474: decode to CV_BSETR using decoder 31
13637 // 1474: }
13638 32, 7, // 1478: case 0x20: {
13639 OPC_CheckPredicate, 148, 1, // 1480: check predicate 148
13640 OPC_Decode, 228, 112, 31, // 1483: decode to CV_ROR using decoder 31
13641 // 1483: }
13642 33, 11, // 1487: case 0x21: {
13643 OPC_CheckPredicate, 148, 1, // 1489: check predicate 148
13644 OPC_CheckField, 20, 5, 0, // 1492: check Inst[24:20] == 0x0
13645 OPC_Decode, 151, 112, 17, // 1496: decode to CV_FF1 using decoder 17
13646 // 1496: }
13647 34, 11, // 1500: case 0x22: {
13648 OPC_CheckPredicate, 148, 1, // 1502: check predicate 148
13649 OPC_CheckField, 20, 5, 0, // 1505: check Inst[24:20] == 0x0
13650 OPC_Decode, 152, 112, 17, // 1509: decode to CV_FL1 using decoder 17
13651 // 1509: }
13652 35, 11, // 1513: case 0x23: {
13653 OPC_CheckPredicate, 148, 1, // 1515: check predicate 148
13654 OPC_CheckField, 20, 5, 0, // 1518: check Inst[24:20] == 0x0
13655 OPC_Decode, 173, 111, 17, // 1522: decode to CV_CLB using decoder 17
13656 // 1522: }
13657 36, 11, // 1526: case 0x24: {
13658 OPC_CheckPredicate, 148, 1, // 1528: check predicate 148
13659 OPC_CheckField, 20, 5, 0, // 1531: check Inst[24:20] == 0x0
13660 OPC_Decode, 238, 111, 17, // 1535: decode to CV_CNT using decoder 17
13661 // 1535: }
13662 40, 11, // 1539: case 0x28: {
13663 OPC_CheckPredicate, 150, 1, // 1541: check predicate 150
13664 OPC_CheckField, 20, 5, 0, // 1544: check Inst[24:20] == 0x0
13665 OPC_Decode, 128, 111, 17, // 1548: decode to CV_ABS using decoder 17
13666 // 1548: }
13667 41, 7, // 1552: case 0x29: {
13668 OPC_CheckPredicate, 150, 1, // 1554: check predicate 150
13669 OPC_Decode, 134, 113, 31, // 1557: decode to CV_SLE using decoder 31
13670 // 1557: }
13671 42, 7, // 1561: case 0x2a: {
13672 OPC_CheckPredicate, 150, 1, // 1563: check predicate 150
13673 OPC_Decode, 135, 113, 31, // 1566: decode to CV_SLEU using decoder 31
13674 // 1566: }
13675 43, 7, // 1570: case 0x2b: {
13676 OPC_CheckPredicate, 150, 1, // 1572: check predicate 150
13677 OPC_Decode, 195, 112, 31, // 1575: decode to CV_MIN using decoder 31
13678 // 1575: }
13679 44, 7, // 1579: case 0x2c: {
13680 OPC_CheckPredicate, 150, 1, // 1581: check predicate 150
13681 OPC_Decode, 196, 112, 31, // 1584: decode to CV_MINU using decoder 31
13682 // 1584: }
13683 45, 7, // 1588: case 0x2d: {
13684 OPC_CheckPredicate, 150, 1, // 1590: check predicate 150
13685 OPC_Decode, 181, 112, 31, // 1593: decode to CV_MAX using decoder 31
13686 // 1593: }
13687 46, 7, // 1597: case 0x2e: {
13688 OPC_CheckPredicate, 150, 1, // 1599: check predicate 150
13689 OPC_Decode, 182, 112, 31, // 1602: decode to CV_MAXU using decoder 31
13690 // 1602: }
13691 48, 11, // 1606: case 0x30: {
13692 OPC_CheckPredicate, 150, 1, // 1608: check predicate 150
13693 OPC_CheckField, 20, 5, 0, // 1611: check Inst[24:20] == 0x0
13694 OPC_Decode, 141, 112, 17, // 1615: decode to CV_EXTHS using decoder 17
13695 // 1615: }
13696 49, 11, // 1619: case 0x31: {
13697 OPC_CheckPredicate, 150, 1, // 1621: check predicate 150
13698 OPC_CheckField, 20, 5, 0, // 1624: check Inst[24:20] == 0x0
13699 OPC_Decode, 142, 112, 17, // 1628: decode to CV_EXTHZ using decoder 17
13700 // 1628: }
13701 50, 11, // 1632: case 0x32: {
13702 OPC_CheckPredicate, 150, 1, // 1634: check predicate 150
13703 OPC_CheckField, 20, 5, 0, // 1637: check Inst[24:20] == 0x0
13704 OPC_Decode, 139, 112, 17, // 1641: decode to CV_EXTBS using decoder 17
13705 // 1641: }
13706 51, 11, // 1645: case 0x33: {
13707 OPC_CheckPredicate, 150, 1, // 1647: check predicate 150
13708 OPC_CheckField, 20, 5, 0, // 1650: check Inst[24:20] == 0x0
13709 OPC_Decode, 140, 112, 17, // 1654: decode to CV_EXTBZ using decoder 17
13710 // 1654: }
13711 56, 7, // 1658: case 0x38: {
13712 OPC_CheckPredicate, 150, 1, // 1660: check predicate 150
13713 OPC_Decode, 174, 111, 21, // 1663: decode to CV_CLIP using decoder 21
13714 // 1663: }
13715 57, 7, // 1667: case 0x39: {
13716 OPC_CheckPredicate, 150, 1, // 1669: check predicate 150
13717 OPC_Decode, 176, 111, 21, // 1672: decode to CV_CLIPU using decoder 21
13718 // 1672: }
13719 58, 7, // 1676: case 0x3a: {
13720 OPC_CheckPredicate, 150, 1, // 1678: check predicate 150
13721 OPC_Decode, 175, 111, 31, // 1681: decode to CV_CLIPR using decoder 31
13722 // 1681: }
13723 59, 7, // 1685: case 0x3b: {
13724 OPC_CheckPredicate, 150, 1, // 1687: check predicate 150
13725 OPC_Decode, 177, 111, 31, // 1690: decode to CV_CLIPUR using decoder 31
13726 // 1690: }
13727 64, 7, // 1694: case 0x40: {
13728 OPC_CheckPredicate, 150, 1, // 1696: check predicate 150
13729 OPC_Decode, 132, 111, 61, // 1699: decode to CV_ADDNR using decoder 61
13730 // 1699: }
13731 65, 7, // 1703: case 0x41: {
13732 OPC_CheckPredicate, 150, 1, // 1705: check predicate 150
13733 OPC_Decode, 136, 111, 61, // 1708: decode to CV_ADDUNR using decoder 61
13734 // 1708: }
13735 66, 7, // 1712: case 0x42: {
13736 OPC_CheckPredicate, 150, 1, // 1714: check predicate 150
13737 OPC_Decode, 134, 111, 61, // 1717: decode to CV_ADDRNR using decoder 61
13738 // 1717: }
13739 67, 7, // 1721: case 0x43: {
13740 OPC_CheckPredicate, 150, 1, // 1723: check predicate 150
13741 OPC_Decode, 138, 111, 61, // 1726: decode to CV_ADDURNR using decoder 61
13742 // 1726: }
13743 68, 7, // 1730: case 0x44: {
13744 OPC_CheckPredicate, 150, 1, // 1732: check predicate 150
13745 OPC_Decode, 155, 113, 61, // 1735: decode to CV_SUBNR using decoder 61
13746 // 1735: }
13747 69, 7, // 1739: case 0x45: {
13748 OPC_CheckPredicate, 150, 1, // 1741: check predicate 150
13749 OPC_Decode, 163, 113, 61, // 1744: decode to CV_SUBUNR using decoder 61
13750 // 1744: }
13751 70, 7, // 1748: case 0x46: {
13752 OPC_CheckPredicate, 150, 1, // 1750: check predicate 150
13753 OPC_Decode, 157, 113, 61, // 1753: decode to CV_SUBRNR using decoder 61
13754 // 1753: }
13755 71, 7, // 1757: case 0x47: {
13756 OPC_CheckPredicate, 150, 1, // 1759: check predicate 150
13757 OPC_Decode, 165, 113, 61, // 1762: decode to CV_SUBURNR using decoder 61
13758 // 1762: }
13759 72, 7, // 1766: case 0x48: {
13760 OPC_CheckPredicate, 152, 1, // 1768: check predicate 152
13761 OPC_Decode, 172, 112, 61, // 1771: decode to CV_MAC using decoder 61
13762 // 1771: }
13763 73, 0, // 1775: case 0x49: {
13764 OPC_CheckPredicate, 152, 1, // 1777: check predicate 152
13765 OPC_Decode, 209, 112, 61, // 1780: decode to CV_MSU using decoder 61
13766 // 1780: }
13767 // 1780: } // switch Inst[31:25]
13768 // 1780: }
13769 91, 43, // 1784: case 0x5b: {
13770 OPC_SwitchField, 30, 2, // 1786: switch Inst[31:30] {
13771 0, 8, // 1789: case 0x0: {
13772 OPC_CheckPredicate, 150, 1, // 1791: check predicate 150
13773 OPC_Decode, 154, 113, 222, 1, // 1794: decode to CV_SUBN using decoder 222
13774 // 1794: }
13775 1, 8, // 1799: case 0x1: {
13776 OPC_CheckPredicate, 150, 1, // 1801: check predicate 150
13777 OPC_Decode, 162, 113, 222, 1, // 1804: decode to CV_SUBUN using decoder 222
13778 // 1804: }
13779 2, 8, // 1809: case 0x2: {
13780 OPC_CheckPredicate, 150, 1, // 1811: check predicate 150
13781 OPC_Decode, 156, 113, 222, 1, // 1814: decode to CV_SUBRN using decoder 222
13782 // 1814: }
13783 3, 0, // 1819: case 0x3: {
13784 OPC_CheckPredicate, 150, 1, // 1821: check predicate 150
13785 OPC_Decode, 164, 113, 222, 1, // 1824: decode to CV_SUBURN using decoder 222
13786 // 1824: }
13787 // 1824: } // switch Inst[31:30]
13788 // 1824: }
13789 123, 0, // 1829: case 0x7b: {
13790 OPC_CheckPredicate, 149, 1, // 1831: check predicate 149
13791 OPC_CheckField, 26, 6, 46, // 1834: check Inst[31:26] == 0x2e
13792 OPC_Decode, 147, 112, 220, 1, // 1838: decode to CV_EXTRACTU_B using decoder 220
13793 // 1838: }
13794 // 1838: } // switch Inst[6:0]
13795 // 1838: }
13796 4, 141, 4, // 1843: case 0x4: {
13797 OPC_SwitchField, 0, 7, // 1846: switch Inst[6:0] {
13798 11, 8, // 1849: case 0xb: {
13799 OPC_CheckPredicate, 147, 1, // 1851: check predicate 147
13800 OPC_Decode, 157, 112, 216, 1, // 1854: decode to CV_LBU_ri_inc using decoder 216
13801 // 1854: }
13802 91, 43, // 1859: case 0x5b: {
13803 OPC_SwitchField, 30, 2, // 1861: switch Inst[31:30] {
13804 0, 8, // 1864: case 0x0: {
13805 OPC_CheckPredicate, 152, 1, // 1866: check predicate 152
13806 OPC_Decode, 214, 112, 222, 1, // 1869: decode to CV_MULSN using decoder 222
13807 // 1869: }
13808 1, 8, // 1874: case 0x1: {
13809 OPC_CheckPredicate, 152, 1, // 1876: check predicate 152
13810 OPC_Decode, 210, 112, 222, 1, // 1879: decode to CV_MULHHSN using decoder 222
13811 // 1879: }
13812 2, 8, // 1884: case 0x2: {
13813 OPC_CheckPredicate, 152, 1, // 1886: check predicate 152
13814 OPC_Decode, 215, 112, 222, 1, // 1889: decode to CV_MULSRN using decoder 222
13815 // 1889: }
13816 3, 0, // 1894: case 0x3: {
13817 OPC_CheckPredicate, 152, 1, // 1896: check predicate 152
13818 OPC_Decode, 211, 112, 222, 1, // 1899: decode to CV_MULHHSRN using decoder 222
13819 // 1899: }
13820 // 1899: } // switch Inst[31:30]
13821 // 1899: }
13822 123, 0, // 1904: case 0x7b: {
13823 OPC_SwitchField, 26, 6, // 1906: switch Inst[31:26] {
13824 0, 11, // 1909: case 0x0: {
13825 OPC_CheckPredicate, 149, 1, // 1911: check predicate 149
13826 OPC_CheckField, 25, 1, 0, // 1914: check Inst[25] == 0x0
13827 OPC_Decode, 147, 111, 31, // 1918: decode to CV_ADD_SC_H using decoder 31
13828 // 1918: }
13829 1, 11, // 1922: case 0x1: {
13830 OPC_CheckPredicate, 149, 1, // 1924: check predicate 149
13831 OPC_CheckField, 25, 1, 0, // 1927: check Inst[25] == 0x0
13832 OPC_Decode, 183, 111, 31, // 1931: decode to CV_CMPEQ_SC_H using decoder 31
13833 // 1931: }
13834 2, 11, // 1935: case 0x2: {
13835 OPC_CheckPredicate, 149, 1, // 1937: check predicate 149
13836 OPC_CheckField, 25, 1, 0, // 1940: check Inst[25] == 0x0
13837 OPC_Decode, 174, 113, 31, // 1944: decode to CV_SUB_SC_H using decoder 31
13838 // 1944: }
13839 3, 11, // 1948: case 0x3: {
13840 OPC_CheckPredicate, 149, 1, // 1950: check predicate 149
13841 OPC_CheckField, 25, 1, 0, // 1953: check Inst[25] == 0x0
13842 OPC_Decode, 237, 111, 31, // 1957: decode to CV_CMPNE_SC_H using decoder 31
13843 // 1957: }
13844 4, 11, // 1961: case 0x4: {
13845 OPC_CheckPredicate, 149, 1, // 1963: check predicate 149
13846 OPC_CheckField, 25, 1, 0, // 1966: check Inst[25] == 0x0
13847 OPC_Decode, 165, 111, 31, // 1970: decode to CV_AVG_SC_H using decoder 31
13848 // 1970: }
13849 5, 11, // 1974: case 0x5: {
13850 OPC_CheckPredicate, 149, 1, // 1976: check predicate 149
13851 OPC_CheckField, 25, 1, 0, // 1979: check Inst[25] == 0x0
13852 OPC_Decode, 207, 111, 31, // 1983: decode to CV_CMPGT_SC_H using decoder 31
13853 // 1983: }
13854 6, 11, // 1987: case 0x6: {
13855 OPC_CheckPredicate, 149, 1, // 1989: check predicate 149
13856 OPC_CheckField, 25, 1, 0, // 1992: check Inst[25] == 0x0
13857 OPC_Decode, 159, 111, 31, // 1996: decode to CV_AVGU_SC_H using decoder 31
13858 // 1996: }
13859 7, 11, // 2000: case 0x7: {
13860 OPC_CheckPredicate, 149, 1, // 2002: check predicate 149
13861 OPC_CheckField, 25, 1, 0, // 2005: check Inst[25] == 0x0
13862 OPC_Decode, 195, 111, 31, // 2009: decode to CV_CMPGE_SC_H using decoder 31
13863 // 2009: }
13864 8, 11, // 2013: case 0x8: {
13865 OPC_CheckPredicate, 149, 1, // 2015: check predicate 149
13866 OPC_CheckField, 25, 1, 0, // 2018: check Inst[25] == 0x0
13867 OPC_Decode, 208, 112, 31, // 2022: decode to CV_MIN_SC_H using decoder 31
13868 // 2022: }
13869 9, 11, // 2026: case 0x9: {
13870 OPC_CheckPredicate, 149, 1, // 2028: check predicate 149
13871 OPC_CheckField, 25, 1, 0, // 2031: check Inst[25] == 0x0
13872 OPC_Decode, 231, 111, 31, // 2035: decode to CV_CMPLT_SC_H using decoder 31
13873 // 2035: }
13874 10, 11, // 2039: case 0xa: {
13875 OPC_CheckPredicate, 149, 1, // 2041: check predicate 149
13876 OPC_CheckField, 25, 1, 0, // 2044: check Inst[25] == 0x0
13877 OPC_Decode, 202, 112, 31, // 2048: decode to CV_MINU_SC_H using decoder 31
13878 // 2048: }
13879 11, 11, // 2052: case 0xb: {
13880 OPC_CheckPredicate, 149, 1, // 2054: check predicate 149
13881 OPC_CheckField, 25, 1, 0, // 2057: check Inst[25] == 0x0
13882 OPC_Decode, 219, 111, 31, // 2061: decode to CV_CMPLE_SC_H using decoder 31
13883 // 2061: }
13884 12, 11, // 2065: case 0xc: {
13885 OPC_CheckPredicate, 149, 1, // 2067: check predicate 149
13886 OPC_CheckField, 25, 1, 0, // 2070: check Inst[25] == 0x0
13887 OPC_Decode, 194, 112, 31, // 2074: decode to CV_MAX_SC_H using decoder 31
13888 // 2074: }
13889 13, 11, // 2078: case 0xd: {
13890 OPC_CheckPredicate, 149, 1, // 2080: check predicate 149
13891 OPC_CheckField, 25, 1, 0, // 2083: check Inst[25] == 0x0
13892 OPC_Decode, 201, 111, 31, // 2087: decode to CV_CMPGTU_SC_H using decoder 31
13893 // 2087: }
13894 14, 11, // 2091: case 0xe: {
13895 OPC_CheckPredicate, 149, 1, // 2093: check predicate 149
13896 OPC_CheckField, 25, 1, 0, // 2096: check Inst[25] == 0x0
13897 OPC_Decode, 188, 112, 31, // 2100: decode to CV_MAXU_SC_H using decoder 31
13898 // 2100: }
13899 15, 11, // 2104: case 0xf: {
13900 OPC_CheckPredicate, 149, 1, // 2106: check predicate 149
13901 OPC_CheckField, 25, 1, 0, // 2109: check Inst[25] == 0x0
13902 OPC_Decode, 189, 111, 31, // 2113: decode to CV_CMPGEU_SC_H using decoder 31
13903 // 2113: }
13904 16, 11, // 2117: case 0x10: {
13905 OPC_CheckPredicate, 149, 1, // 2119: check predicate 149
13906 OPC_CheckField, 25, 1, 0, // 2122: check Inst[25] == 0x0
13907 OPC_Decode, 153, 113, 31, // 2126: decode to CV_SRL_SC_H using decoder 31
13908 // 2126: }
13909 17, 11, // 2130: case 0x11: {
13910 OPC_CheckPredicate, 149, 1, // 2132: check predicate 149
13911 OPC_CheckField, 25, 1, 0, // 2135: check Inst[25] == 0x0
13912 OPC_Decode, 225, 111, 31, // 2139: decode to CV_CMPLTU_SC_H using decoder 31
13913 // 2139: }
13914 18, 11, // 2143: case 0x12: {
13915 OPC_CheckPredicate, 149, 1, // 2145: check predicate 149
13916 OPC_CheckField, 25, 1, 0, // 2148: check Inst[25] == 0x0
13917 OPC_Decode, 147, 113, 31, // 2152: decode to CV_SRA_SC_H using decoder 31
13918 // 2152: }
13919 19, 11, // 2156: case 0x13: {
13920 OPC_CheckPredicate, 149, 1, // 2158: check predicate 149
13921 OPC_CheckField, 25, 1, 0, // 2161: check Inst[25] == 0x0
13922 OPC_Decode, 213, 111, 31, // 2165: decode to CV_CMPLEU_SC_H using decoder 31
13923 // 2165: }
13924 20, 11, // 2169: case 0x14: {
13925 OPC_CheckPredicate, 149, 1, // 2171: check predicate 149
13926 OPC_CheckField, 25, 1, 0, // 2174: check Inst[25] == 0x0
13927 OPC_Decode, 141, 113, 31, // 2178: decode to CV_SLL_SC_H using decoder 31
13928 // 2178: }
13929 21, 21, // 2182: case 0x15: {
13930 OPC_SwitchField, 25, 1, // 2184: switch Inst[25] {
13931 0, 7, // 2187: case 0x0: {
13932 OPC_CheckPredicate, 149, 1, // 2189: check predicate 149
13933 OPC_Decode, 246, 111, 61, // 2192: decode to CV_CPLXMUL_R_DIV4 using decoder 61
13934 // 2192: }
13935 1, 0, // 2196: case 0x1: {
13936 OPC_CheckPredicate, 149, 1, // 2198: check predicate 149
13937 OPC_Decode, 242, 111, 61, // 2201: decode to CV_CPLXMUL_I_DIV4 using decoder 61
13938 // 2201: }
13939 // 2201: } // switch Inst[25]
13940 // 2201: }
13941 22, 11, // 2205: case 0x16: {
13942 OPC_CheckPredicate, 149, 1, // 2207: check predicate 149
13943 OPC_CheckField, 25, 1, 0, // 2210: check Inst[25] == 0x0
13944 OPC_Decode, 223, 112, 31, // 2214: decode to CV_OR_SC_H using decoder 31
13945 // 2214: }
13946 24, 11, // 2218: case 0x18: {
13947 OPC_CheckPredicate, 149, 1, // 2220: check predicate 149
13948 OPC_CheckField, 25, 1, 0, // 2223: check Inst[25] == 0x0
13949 OPC_Decode, 183, 113, 31, // 2227: decode to CV_XOR_SC_H using decoder 31
13950 // 2227: }
13951 25, 11, // 2231: case 0x19: {
13952 OPC_CheckPredicate, 149, 1, // 2233: check predicate 149
13953 OPC_CheckField, 25, 1, 0, // 2236: check Inst[25] == 0x0
13954 OPC_Decode, 160, 113, 31, // 2240: decode to CV_SUBROTMJ_DIV4 using decoder 31
13955 // 2240: }
13956 26, 11, // 2244: case 0x1a: {
13957 OPC_CheckPredicate, 149, 1, // 2246: check predicate 149
13958 OPC_CheckField, 25, 1, 0, // 2249: check Inst[25] == 0x0
13959 OPC_Decode, 153, 111, 31, // 2253: decode to CV_AND_SC_H using decoder 31
13960 // 2253: }
13961 27, 11, // 2257: case 0x1b: {
13962 OPC_CheckPredicate, 149, 1, // 2259: check predicate 149
13963 OPC_CheckField, 25, 1, 0, // 2262: check Inst[25] == 0x0
13964 OPC_Decode, 141, 111, 31, // 2266: decode to CV_ADD_DIV4 using decoder 31
13965 // 2266: }
13966 29, 11, // 2270: case 0x1d: {
13967 OPC_CheckPredicate, 149, 1, // 2272: check predicate 149
13968 OPC_CheckField, 25, 1, 0, // 2275: check Inst[25] == 0x0
13969 OPC_Decode, 168, 113, 31, // 2279: decode to CV_SUB_DIV4 using decoder 31
13970 // 2279: }
13971 32, 11, // 2283: case 0x20: {
13972 OPC_CheckPredicate, 149, 1, // 2285: check predicate 149
13973 OPC_CheckField, 25, 1, 0, // 2288: check Inst[25] == 0x0
13974 OPC_Decode, 131, 112, 31, // 2292: decode to CV_DOTUP_SC_H using decoder 31
13975 // 2292: }
13976 34, 11, // 2296: case 0x22: {
13977 OPC_CheckPredicate, 149, 1, // 2298: check predicate 149
13978 OPC_CheckField, 25, 1, 0, // 2301: check Inst[25] == 0x0
13979 OPC_Decode, 137, 112, 31, // 2305: decode to CV_DOTUSP_SC_H using decoder 31
13980 // 2305: }
13981 36, 11, // 2309: case 0x24: {
13982 OPC_CheckPredicate, 149, 1, // 2311: check predicate 149
13983 OPC_CheckField, 25, 1, 0, // 2314: check Inst[25] == 0x0
13984 OPC_Decode, 253, 111, 31, // 2318: decode to CV_DOTSP_SC_H using decoder 31
13985 // 2318: }
13986 38, 11, // 2322: case 0x26: {
13987 OPC_CheckPredicate, 149, 1, // 2324: check predicate 149
13988 OPC_CheckField, 25, 1, 0, // 2327: check Inst[25] == 0x0
13989 OPC_Decode, 243, 112, 61, // 2331: decode to CV_SDOTUP_SC_H using decoder 61
13990 // 2331: }
13991 40, 11, // 2335: case 0x28: {
13992 OPC_CheckPredicate, 149, 1, // 2337: check predicate 149
13993 OPC_CheckField, 25, 1, 0, // 2340: check Inst[25] == 0x0
13994 OPC_Decode, 249, 112, 61, // 2344: decode to CV_SDOTUSP_SC_H using decoder 61
13995 // 2344: }
13996 42, 11, // 2348: case 0x2a: {
13997 OPC_CheckPredicate, 149, 1, // 2350: check predicate 149
13998 OPC_CheckField, 25, 1, 0, // 2353: check Inst[25] == 0x0
13999 OPC_Decode, 237, 112, 61, // 2357: decode to CV_SDOTSP_SC_H using decoder 61
14000 // 2357: }
14001 46, 0, // 2361: case 0x2e: {
14002 OPC_CheckPredicate, 149, 1, // 2363: check predicate 149
14003 OPC_Decode, 156, 112, 226, 1, // 2366: decode to CV_INSERT_H using decoder 226
14004 // 2366: }
14005 // 2366: } // switch Inst[31:26]
14006 // 2366: }
14007 // 2366: } // switch Inst[6:0]
14008 // 2366: }
14009 5, 207, 3, // 2371: case 0x5: {
14010 OPC_SwitchField, 0, 7, // 2374: switch Inst[6:0] {
14011 11, 8, // 2377: case 0xb: {
14012 OPC_CheckPredicate, 147, 1, // 2379: check predicate 147
14013 OPC_Decode, 163, 112, 216, 1, // 2382: decode to CV_LHU_ri_inc using decoder 216
14014 // 2382: }
14015 91, 43, // 2387: case 0x5b: {
14016 OPC_SwitchField, 30, 2, // 2389: switch Inst[31:30] {
14017 0, 8, // 2392: case 0x0: {
14018 OPC_CheckPredicate, 152, 1, // 2394: check predicate 152
14019 OPC_Decode, 216, 112, 222, 1, // 2397: decode to CV_MULUN using decoder 222
14020 // 2397: }
14021 1, 8, // 2402: case 0x1: {
14022 OPC_CheckPredicate, 152, 1, // 2404: check predicate 152
14023 OPC_Decode, 212, 112, 222, 1, // 2407: decode to CV_MULHHUN using decoder 222
14024 // 2407: }
14025 2, 8, // 2412: case 0x2: {
14026 OPC_CheckPredicate, 152, 1, // 2414: check predicate 152
14027 OPC_Decode, 217, 112, 222, 1, // 2417: decode to CV_MULURN using decoder 222
14028 // 2417: }
14029 3, 0, // 2422: case 0x3: {
14030 OPC_CheckPredicate, 152, 1, // 2424: check predicate 152
14031 OPC_Decode, 213, 112, 222, 1, // 2427: decode to CV_MULHHURN using decoder 222
14032 // 2427: }
14033 // 2427: } // switch Inst[31:30]
14034 // 2427: }
14035 123, 0, // 2432: case 0x7b: {
14036 OPC_SwitchField, 26, 6, // 2434: switch Inst[31:26] {
14037 0, 11, // 2437: case 0x0: {
14038 OPC_CheckPredicate, 149, 1, // 2439: check predicate 149
14039 OPC_CheckField, 25, 1, 0, // 2442: check Inst[25] == 0x0
14040 OPC_Decode, 146, 111, 31, // 2446: decode to CV_ADD_SC_B using decoder 31
14041 // 2446: }
14042 1, 11, // 2450: case 0x1: {
14043 OPC_CheckPredicate, 149, 1, // 2452: check predicate 149
14044 OPC_CheckField, 25, 1, 0, // 2455: check Inst[25] == 0x0
14045 OPC_Decode, 182, 111, 31, // 2459: decode to CV_CMPEQ_SC_B using decoder 31
14046 // 2459: }
14047 2, 11, // 2463: case 0x2: {
14048 OPC_CheckPredicate, 149, 1, // 2465: check predicate 149
14049 OPC_CheckField, 25, 1, 0, // 2468: check Inst[25] == 0x0
14050 OPC_Decode, 173, 113, 31, // 2472: decode to CV_SUB_SC_B using decoder 31
14051 // 2472: }
14052 3, 11, // 2476: case 0x3: {
14053 OPC_CheckPredicate, 149, 1, // 2478: check predicate 149
14054 OPC_CheckField, 25, 1, 0, // 2481: check Inst[25] == 0x0
14055 OPC_Decode, 236, 111, 31, // 2485: decode to CV_CMPNE_SC_B using decoder 31
14056 // 2485: }
14057 4, 11, // 2489: case 0x4: {
14058 OPC_CheckPredicate, 149, 1, // 2491: check predicate 149
14059 OPC_CheckField, 25, 1, 0, // 2494: check Inst[25] == 0x0
14060 OPC_Decode, 164, 111, 31, // 2498: decode to CV_AVG_SC_B using decoder 31
14061 // 2498: }
14062 5, 11, // 2502: case 0x5: {
14063 OPC_CheckPredicate, 149, 1, // 2504: check predicate 149
14064 OPC_CheckField, 25, 1, 0, // 2507: check Inst[25] == 0x0
14065 OPC_Decode, 206, 111, 31, // 2511: decode to CV_CMPGT_SC_B using decoder 31
14066 // 2511: }
14067 6, 11, // 2515: case 0x6: {
14068 OPC_CheckPredicate, 149, 1, // 2517: check predicate 149
14069 OPC_CheckField, 25, 1, 0, // 2520: check Inst[25] == 0x0
14070 OPC_Decode, 158, 111, 31, // 2524: decode to CV_AVGU_SC_B using decoder 31
14071 // 2524: }
14072 7, 11, // 2528: case 0x7: {
14073 OPC_CheckPredicate, 149, 1, // 2530: check predicate 149
14074 OPC_CheckField, 25, 1, 0, // 2533: check Inst[25] == 0x0
14075 OPC_Decode, 194, 111, 31, // 2537: decode to CV_CMPGE_SC_B using decoder 31
14076 // 2537: }
14077 8, 11, // 2541: case 0x8: {
14078 OPC_CheckPredicate, 149, 1, // 2543: check predicate 149
14079 OPC_CheckField, 25, 1, 0, // 2546: check Inst[25] == 0x0
14080 OPC_Decode, 207, 112, 31, // 2550: decode to CV_MIN_SC_B using decoder 31
14081 // 2550: }
14082 9, 11, // 2554: case 0x9: {
14083 OPC_CheckPredicate, 149, 1, // 2556: check predicate 149
14084 OPC_CheckField, 25, 1, 0, // 2559: check Inst[25] == 0x0
14085 OPC_Decode, 230, 111, 31, // 2563: decode to CV_CMPLT_SC_B using decoder 31
14086 // 2563: }
14087 10, 11, // 2567: case 0xa: {
14088 OPC_CheckPredicate, 149, 1, // 2569: check predicate 149
14089 OPC_CheckField, 25, 1, 0, // 2572: check Inst[25] == 0x0
14090 OPC_Decode, 201, 112, 31, // 2576: decode to CV_MINU_SC_B using decoder 31
14091 // 2576: }
14092 11, 11, // 2580: case 0xb: {
14093 OPC_CheckPredicate, 149, 1, // 2582: check predicate 149
14094 OPC_CheckField, 25, 1, 0, // 2585: check Inst[25] == 0x0
14095 OPC_Decode, 218, 111, 31, // 2589: decode to CV_CMPLE_SC_B using decoder 31
14096 // 2589: }
14097 12, 11, // 2593: case 0xc: {
14098 OPC_CheckPredicate, 149, 1, // 2595: check predicate 149
14099 OPC_CheckField, 25, 1, 0, // 2598: check Inst[25] == 0x0
14100 OPC_Decode, 193, 112, 31, // 2602: decode to CV_MAX_SC_B using decoder 31
14101 // 2602: }
14102 13, 11, // 2606: case 0xd: {
14103 OPC_CheckPredicate, 149, 1, // 2608: check predicate 149
14104 OPC_CheckField, 25, 1, 0, // 2611: check Inst[25] == 0x0
14105 OPC_Decode, 200, 111, 31, // 2615: decode to CV_CMPGTU_SC_B using decoder 31
14106 // 2615: }
14107 14, 11, // 2619: case 0xe: {
14108 OPC_CheckPredicate, 149, 1, // 2621: check predicate 149
14109 OPC_CheckField, 25, 1, 0, // 2624: check Inst[25] == 0x0
14110 OPC_Decode, 187, 112, 31, // 2628: decode to CV_MAXU_SC_B using decoder 31
14111 // 2628: }
14112 15, 11, // 2632: case 0xf: {
14113 OPC_CheckPredicate, 149, 1, // 2634: check predicate 149
14114 OPC_CheckField, 25, 1, 0, // 2637: check Inst[25] == 0x0
14115 OPC_Decode, 188, 111, 31, // 2641: decode to CV_CMPGEU_SC_B using decoder 31
14116 // 2641: }
14117 16, 11, // 2645: case 0x10: {
14118 OPC_CheckPredicate, 149, 1, // 2647: check predicate 149
14119 OPC_CheckField, 25, 1, 0, // 2650: check Inst[25] == 0x0
14120 OPC_Decode, 152, 113, 31, // 2654: decode to CV_SRL_SC_B using decoder 31
14121 // 2654: }
14122 17, 11, // 2658: case 0x11: {
14123 OPC_CheckPredicate, 149, 1, // 2660: check predicate 149
14124 OPC_CheckField, 25, 1, 0, // 2663: check Inst[25] == 0x0
14125 OPC_Decode, 224, 111, 31, // 2667: decode to CV_CMPLTU_SC_B using decoder 31
14126 // 2667: }
14127 18, 11, // 2671: case 0x12: {
14128 OPC_CheckPredicate, 149, 1, // 2673: check predicate 149
14129 OPC_CheckField, 25, 1, 0, // 2676: check Inst[25] == 0x0
14130 OPC_Decode, 146, 113, 31, // 2680: decode to CV_SRA_SC_B using decoder 31
14131 // 2680: }
14132 19, 11, // 2684: case 0x13: {
14133 OPC_CheckPredicate, 149, 1, // 2686: check predicate 149
14134 OPC_CheckField, 25, 1, 0, // 2689: check Inst[25] == 0x0
14135 OPC_Decode, 212, 111, 31, // 2693: decode to CV_CMPLEU_SC_B using decoder 31
14136 // 2693: }
14137 20, 11, // 2697: case 0x14: {
14138 OPC_CheckPredicate, 149, 1, // 2699: check predicate 149
14139 OPC_CheckField, 25, 1, 0, // 2702: check Inst[25] == 0x0
14140 OPC_Decode, 140, 113, 31, // 2706: decode to CV_SLL_SC_B using decoder 31
14141 // 2706: }
14142 22, 11, // 2710: case 0x16: {
14143 OPC_CheckPredicate, 149, 1, // 2712: check predicate 149
14144 OPC_CheckField, 25, 1, 0, // 2715: check Inst[25] == 0x0
14145 OPC_Decode, 222, 112, 31, // 2719: decode to CV_OR_SC_B using decoder 31
14146 // 2719: }
14147 24, 11, // 2723: case 0x18: {
14148 OPC_CheckPredicate, 149, 1, // 2725: check predicate 149
14149 OPC_CheckField, 25, 1, 0, // 2728: check Inst[25] == 0x0
14150 OPC_Decode, 182, 113, 31, // 2732: decode to CV_XOR_SC_B using decoder 31
14151 // 2732: }
14152 26, 11, // 2736: case 0x1a: {
14153 OPC_CheckPredicate, 149, 1, // 2738: check predicate 149
14154 OPC_CheckField, 25, 1, 0, // 2741: check Inst[25] == 0x0
14155 OPC_Decode, 152, 111, 31, // 2745: decode to CV_AND_SC_B using decoder 31
14156 // 2745: }
14157 32, 11, // 2749: case 0x20: {
14158 OPC_CheckPredicate, 149, 1, // 2751: check predicate 149
14159 OPC_CheckField, 25, 1, 0, // 2754: check Inst[25] == 0x0
14160 OPC_Decode, 130, 112, 31, // 2758: decode to CV_DOTUP_SC_B using decoder 31
14161 // 2758: }
14162 34, 11, // 2762: case 0x22: {
14163 OPC_CheckPredicate, 149, 1, // 2764: check predicate 149
14164 OPC_CheckField, 25, 1, 0, // 2767: check Inst[25] == 0x0
14165 OPC_Decode, 136, 112, 31, // 2771: decode to CV_DOTUSP_SC_B using decoder 31
14166 // 2771: }
14167 36, 11, // 2775: case 0x24: {
14168 OPC_CheckPredicate, 149, 1, // 2777: check predicate 149
14169 OPC_CheckField, 25, 1, 0, // 2780: check Inst[25] == 0x0
14170 OPC_Decode, 252, 111, 31, // 2784: decode to CV_DOTSP_SC_B using decoder 31
14171 // 2784: }
14172 38, 11, // 2788: case 0x26: {
14173 OPC_CheckPredicate, 149, 1, // 2790: check predicate 149
14174 OPC_CheckField, 25, 1, 0, // 2793: check Inst[25] == 0x0
14175 OPC_Decode, 242, 112, 61, // 2797: decode to CV_SDOTUP_SC_B using decoder 61
14176 // 2797: }
14177 40, 11, // 2801: case 0x28: {
14178 OPC_CheckPredicate, 149, 1, // 2803: check predicate 149
14179 OPC_CheckField, 25, 1, 0, // 2806: check Inst[25] == 0x0
14180 OPC_Decode, 248, 112, 61, // 2810: decode to CV_SDOTUSP_SC_B using decoder 61
14181 // 2810: }
14182 42, 11, // 2814: case 0x2a: {
14183 OPC_CheckPredicate, 149, 1, // 2816: check predicate 149
14184 OPC_CheckField, 25, 1, 0, // 2819: check Inst[25] == 0x0
14185 OPC_Decode, 236, 112, 61, // 2823: decode to CV_SDOTSP_SC_B using decoder 61
14186 // 2823: }
14187 46, 0, // 2827: case 0x2e: {
14188 OPC_CheckPredicate, 149, 1, // 2829: check predicate 149
14189 OPC_Decode, 155, 112, 226, 1, // 2832: decode to CV_INSERT_B using decoder 226
14190 // 2832: }
14191 // 2832: } // switch Inst[31:26]
14192 // 2832: }
14193 // 2832: } // switch Inst[6:0]
14194 // 2832: }
14195 6, 179, 3, // 2837: case 0x6: {
14196 OPC_SwitchField, 0, 7, // 2840: switch Inst[6:0] {
14197 11, 8, // 2843: case 0xb: {
14198 OPC_CheckPredicate, 153, 1, // 2845: check predicate 153
14199 OPC_Decode, 168, 111, 227, 1, // 2848: decode to CV_BEQIMM using decoder 227
14200 // 2848: }
14201 91, 43, // 2853: case 0x5b: {
14202 OPC_SwitchField, 30, 2, // 2855: switch Inst[31:30] {
14203 0, 8, // 2858: case 0x0: {
14204 OPC_CheckPredicate, 152, 1, // 2860: check predicate 152
14205 OPC_Decode, 177, 112, 228, 1, // 2863: decode to CV_MACSN using decoder 228
14206 // 2863: }
14207 1, 8, // 2868: case 0x1: {
14208 OPC_CheckPredicate, 152, 1, // 2870: check predicate 152
14209 OPC_Decode, 173, 112, 228, 1, // 2873: decode to CV_MACHHSN using decoder 228
14210 // 2873: }
14211 2, 8, // 2878: case 0x2: {
14212 OPC_CheckPredicate, 152, 1, // 2880: check predicate 152
14213 OPC_Decode, 178, 112, 228, 1, // 2883: decode to CV_MACSRN using decoder 228
14214 // 2883: }
14215 3, 0, // 2888: case 0x3: {
14216 OPC_CheckPredicate, 152, 1, // 2890: check predicate 152
14217 OPC_Decode, 174, 112, 228, 1, // 2893: decode to CV_MACHHSRN using decoder 228
14218 // 2893: }
14219 // 2893: } // switch Inst[31:30]
14220 // 2893: }
14221 123, 0, // 2898: case 0x7b: {
14222 OPC_SwitchField, 26, 6, // 2900: switch Inst[31:26] {
14223 0, 8, // 2903: case 0x0: {
14224 OPC_CheckPredicate, 149, 1, // 2905: check predicate 149
14225 OPC_Decode, 145, 111, 229, 1, // 2908: decode to CV_ADD_SCI_H using decoder 229
14226 // 2908: }
14227 1, 8, // 2913: case 0x1: {
14228 OPC_CheckPredicate, 149, 1, // 2915: check predicate 149
14229 OPC_Decode, 181, 111, 229, 1, // 2918: decode to CV_CMPEQ_SCI_H using decoder 229
14230 // 2918: }
14231 2, 8, // 2923: case 0x2: {
14232 OPC_CheckPredicate, 149, 1, // 2925: check predicate 149
14233 OPC_Decode, 172, 113, 229, 1, // 2928: decode to CV_SUB_SCI_H using decoder 229
14234 // 2928: }
14235 3, 8, // 2933: case 0x3: {
14236 OPC_CheckPredicate, 149, 1, // 2935: check predicate 149
14237 OPC_Decode, 235, 111, 229, 1, // 2938: decode to CV_CMPNE_SCI_H using decoder 229
14238 // 2938: }
14239 4, 8, // 2943: case 0x4: {
14240 OPC_CheckPredicate, 149, 1, // 2945: check predicate 149
14241 OPC_Decode, 163, 111, 229, 1, // 2948: decode to CV_AVG_SCI_H using decoder 229
14242 // 2948: }
14243 5, 8, // 2953: case 0x5: {
14244 OPC_CheckPredicate, 149, 1, // 2955: check predicate 149
14245 OPC_Decode, 205, 111, 229, 1, // 2958: decode to CV_CMPGT_SCI_H using decoder 229
14246 // 2958: }
14247 6, 8, // 2963: case 0x6: {
14248 OPC_CheckPredicate, 149, 1, // 2965: check predicate 149
14249 OPC_Decode, 157, 111, 220, 1, // 2968: decode to CV_AVGU_SCI_H using decoder 220
14250 // 2968: }
14251 7, 8, // 2973: case 0x7: {
14252 OPC_CheckPredicate, 149, 1, // 2975: check predicate 149
14253 OPC_Decode, 193, 111, 229, 1, // 2978: decode to CV_CMPGE_SCI_H using decoder 229
14254 // 2978: }
14255 8, 8, // 2983: case 0x8: {
14256 OPC_CheckPredicate, 149, 1, // 2985: check predicate 149
14257 OPC_Decode, 206, 112, 229, 1, // 2988: decode to CV_MIN_SCI_H using decoder 229
14258 // 2988: }
14259 9, 8, // 2993: case 0x9: {
14260 OPC_CheckPredicate, 149, 1, // 2995: check predicate 149
14261 OPC_Decode, 229, 111, 229, 1, // 2998: decode to CV_CMPLT_SCI_H using decoder 229
14262 // 2998: }
14263 10, 8, // 3003: case 0xa: {
14264 OPC_CheckPredicate, 149, 1, // 3005: check predicate 149
14265 OPC_Decode, 200, 112, 220, 1, // 3008: decode to CV_MINU_SCI_H using decoder 220
14266 // 3008: }
14267 11, 8, // 3013: case 0xb: {
14268 OPC_CheckPredicate, 149, 1, // 3015: check predicate 149
14269 OPC_Decode, 217, 111, 229, 1, // 3018: decode to CV_CMPLE_SCI_H using decoder 229
14270 // 3018: }
14271 12, 8, // 3023: case 0xc: {
14272 OPC_CheckPredicate, 149, 1, // 3025: check predicate 149
14273 OPC_Decode, 192, 112, 229, 1, // 3028: decode to CV_MAX_SCI_H using decoder 229
14274 // 3028: }
14275 13, 8, // 3033: case 0xd: {
14276 OPC_CheckPredicate, 149, 1, // 3035: check predicate 149
14277 OPC_Decode, 199, 111, 220, 1, // 3038: decode to CV_CMPGTU_SCI_H using decoder 220
14278 // 3038: }
14279 14, 8, // 3043: case 0xe: {
14280 OPC_CheckPredicate, 149, 1, // 3045: check predicate 149
14281 OPC_Decode, 186, 112, 220, 1, // 3048: decode to CV_MAXU_SCI_H using decoder 220
14282 // 3048: }
14283 15, 8, // 3053: case 0xf: {
14284 OPC_CheckPredicate, 149, 1, // 3055: check predicate 149
14285 OPC_Decode, 187, 111, 220, 1, // 3058: decode to CV_CMPGEU_SCI_H using decoder 220
14286 // 3058: }
14287 16, 8, // 3063: case 0x10: {
14288 OPC_CheckPredicate, 149, 1, // 3065: check predicate 149
14289 OPC_Decode, 151, 113, 230, 1, // 3068: decode to CV_SRL_SCI_H using decoder 230
14290 // 3068: }
14291 17, 8, // 3073: case 0x11: {
14292 OPC_CheckPredicate, 149, 1, // 3075: check predicate 149
14293 OPC_Decode, 223, 111, 220, 1, // 3078: decode to CV_CMPLTU_SCI_H using decoder 220
14294 // 3078: }
14295 18, 8, // 3083: case 0x12: {
14296 OPC_CheckPredicate, 149, 1, // 3085: check predicate 149
14297 OPC_Decode, 145, 113, 230, 1, // 3088: decode to CV_SRA_SCI_H using decoder 230
14298 // 3088: }
14299 19, 8, // 3093: case 0x13: {
14300 OPC_CheckPredicate, 149, 1, // 3095: check predicate 149
14301 OPC_Decode, 211, 111, 220, 1, // 3098: decode to CV_CMPLEU_SCI_H using decoder 220
14302 // 3098: }
14303 20, 8, // 3103: case 0x14: {
14304 OPC_CheckPredicate, 149, 1, // 3105: check predicate 149
14305 OPC_Decode, 139, 113, 230, 1, // 3108: decode to CV_SLL_SCI_H using decoder 230
14306 // 3108: }
14307 21, 21, // 3113: case 0x15: {
14308 OPC_SwitchField, 25, 1, // 3115: switch Inst[25] {
14309 0, 7, // 3118: case 0x0: {
14310 OPC_CheckPredicate, 149, 1, // 3120: check predicate 149
14311 OPC_Decode, 247, 111, 61, // 3123: decode to CV_CPLXMUL_R_DIV8 using decoder 61
14312 // 3123: }
14313 1, 0, // 3127: case 0x1: {
14314 OPC_CheckPredicate, 149, 1, // 3129: check predicate 149
14315 OPC_Decode, 243, 111, 61, // 3132: decode to CV_CPLXMUL_I_DIV8 using decoder 61
14316 // 3132: }
14317 // 3132: } // switch Inst[25]
14318 // 3132: }
14319 22, 8, // 3136: case 0x16: {
14320 OPC_CheckPredicate, 149, 1, // 3138: check predicate 149
14321 OPC_Decode, 221, 112, 229, 1, // 3141: decode to CV_OR_SCI_H using decoder 229
14322 // 3141: }
14323 24, 8, // 3146: case 0x18: {
14324 OPC_CheckPredicate, 149, 1, // 3148: check predicate 149
14325 OPC_Decode, 181, 113, 229, 1, // 3151: decode to CV_XOR_SCI_H using decoder 229
14326 // 3151: }
14327 25, 11, // 3156: case 0x19: {
14328 OPC_CheckPredicate, 149, 1, // 3158: check predicate 149
14329 OPC_CheckField, 25, 1, 0, // 3161: check Inst[25] == 0x0
14330 OPC_Decode, 161, 113, 31, // 3165: decode to CV_SUBROTMJ_DIV8 using decoder 31
14331 // 3165: }
14332 26, 8, // 3169: case 0x1a: {
14333 OPC_CheckPredicate, 149, 1, // 3171: check predicate 149
14334 OPC_Decode, 151, 111, 229, 1, // 3174: decode to CV_AND_SCI_H using decoder 229
14335 // 3174: }
14336 27, 11, // 3179: case 0x1b: {
14337 OPC_CheckPredicate, 149, 1, // 3181: check predicate 149
14338 OPC_CheckField, 25, 1, 0, // 3184: check Inst[25] == 0x0
14339 OPC_Decode, 142, 111, 31, // 3188: decode to CV_ADD_DIV8 using decoder 31
14340 // 3188: }
14341 29, 11, // 3192: case 0x1d: {
14342 OPC_CheckPredicate, 149, 1, // 3194: check predicate 149
14343 OPC_CheckField, 25, 1, 0, // 3197: check Inst[25] == 0x0
14344 OPC_Decode, 169, 113, 31, // 3201: decode to CV_SUB_DIV8 using decoder 31
14345 // 3201: }
14346 32, 8, // 3205: case 0x20: {
14347 OPC_CheckPredicate, 149, 1, // 3207: check predicate 149
14348 OPC_Decode, 129, 112, 220, 1, // 3210: decode to CV_DOTUP_SCI_H using decoder 220
14349 // 3210: }
14350 34, 8, // 3215: case 0x22: {
14351 OPC_CheckPredicate, 149, 1, // 3217: check predicate 149
14352 OPC_Decode, 135, 112, 229, 1, // 3220: decode to CV_DOTUSP_SCI_H using decoder 229
14353 // 3220: }
14354 36, 8, // 3225: case 0x24: {
14355 OPC_CheckPredicate, 149, 1, // 3227: check predicate 149
14356 OPC_Decode, 251, 111, 229, 1, // 3230: decode to CV_DOTSP_SCI_H using decoder 229
14357 // 3230: }
14358 38, 8, // 3235: case 0x26: {
14359 OPC_CheckPredicate, 149, 1, // 3237: check predicate 149
14360 OPC_Decode, 241, 112, 226, 1, // 3240: decode to CV_SDOTUP_SCI_H using decoder 226
14361 // 3240: }
14362 40, 8, // 3245: case 0x28: {
14363 OPC_CheckPredicate, 149, 1, // 3247: check predicate 149
14364 OPC_Decode, 247, 112, 231, 1, // 3250: decode to CV_SDOTUSP_SCI_H using decoder 231
14365 // 3250: }
14366 42, 8, // 3255: case 0x2a: {
14367 OPC_CheckPredicate, 149, 1, // 3257: check predicate 149
14368 OPC_Decode, 235, 112, 231, 1, // 3260: decode to CV_SDOTSP_SCI_H using decoder 231
14369 // 3260: }
14370 48, 0, // 3265: case 0x30: {
14371 OPC_CheckPredicate, 149, 1, // 3267: check predicate 149
14372 OPC_Decode, 130, 113, 220, 1, // 3270: decode to CV_SHUFFLE_SCI_H using decoder 220
14373 // 3270: }
14374 // 3270: } // switch Inst[31:26]
14375 // 3270: }
14376 // 3270: } // switch Inst[6:0]
14377 // 3270: }
14378 7, 0, // 3275: case 0x7: {
14379 OPC_SwitchField, 0, 7, // 3277: switch Inst[6:0] {
14380 11, 8, // 3280: case 0xb: {
14381 OPC_CheckPredicate, 153, 1, // 3282: check predicate 153
14382 OPC_Decode, 170, 111, 227, 1, // 3285: decode to CV_BNEIMM using decoder 227
14383 // 3285: }
14384 91, 43, // 3290: case 0x5b: {
14385 OPC_SwitchField, 30, 2, // 3292: switch Inst[31:30] {
14386 0, 8, // 3295: case 0x0: {
14387 OPC_CheckPredicate, 152, 1, // 3297: check predicate 152
14388 OPC_Decode, 179, 112, 228, 1, // 3300: decode to CV_MACUN using decoder 228
14389 // 3300: }
14390 1, 8, // 3305: case 0x1: {
14391 OPC_CheckPredicate, 152, 1, // 3307: check predicate 152
14392 OPC_Decode, 175, 112, 228, 1, // 3310: decode to CV_MACHHUN using decoder 228
14393 // 3310: }
14394 2, 8, // 3315: case 0x2: {
14395 OPC_CheckPredicate, 152, 1, // 3317: check predicate 152
14396 OPC_Decode, 180, 112, 228, 1, // 3320: decode to CV_MACURN using decoder 228
14397 // 3320: }
14398 3, 0, // 3325: case 0x3: {
14399 OPC_CheckPredicate, 152, 1, // 3327: check predicate 152
14400 OPC_Decode, 176, 112, 228, 1, // 3330: decode to CV_MACHHURN using decoder 228
14401 // 3330: }
14402 // 3330: } // switch Inst[31:30]
14403 // 3330: }
14404 123, 0, // 3335: case 0x7b: {
14405 OPC_SwitchField, 26, 6, // 3337: switch Inst[31:26] {
14406 0, 8, // 3340: case 0x0: {
14407 OPC_CheckPredicate, 149, 1, // 3342: check predicate 149
14408 OPC_Decode, 144, 111, 229, 1, // 3345: decode to CV_ADD_SCI_B using decoder 229
14409 // 3345: }
14410 1, 8, // 3350: case 0x1: {
14411 OPC_CheckPredicate, 149, 1, // 3352: check predicate 149
14412 OPC_Decode, 180, 111, 229, 1, // 3355: decode to CV_CMPEQ_SCI_B using decoder 229
14413 // 3355: }
14414 2, 8, // 3360: case 0x2: {
14415 OPC_CheckPredicate, 149, 1, // 3362: check predicate 149
14416 OPC_Decode, 171, 113, 229, 1, // 3365: decode to CV_SUB_SCI_B using decoder 229
14417 // 3365: }
14418 3, 8, // 3370: case 0x3: {
14419 OPC_CheckPredicate, 149, 1, // 3372: check predicate 149
14420 OPC_Decode, 234, 111, 229, 1, // 3375: decode to CV_CMPNE_SCI_B using decoder 229
14421 // 3375: }
14422 4, 8, // 3380: case 0x4: {
14423 OPC_CheckPredicate, 149, 1, // 3382: check predicate 149
14424 OPC_Decode, 162, 111, 229, 1, // 3385: decode to CV_AVG_SCI_B using decoder 229
14425 // 3385: }
14426 5, 8, // 3390: case 0x5: {
14427 OPC_CheckPredicate, 149, 1, // 3392: check predicate 149
14428 OPC_Decode, 204, 111, 229, 1, // 3395: decode to CV_CMPGT_SCI_B using decoder 229
14429 // 3395: }
14430 6, 8, // 3400: case 0x6: {
14431 OPC_CheckPredicate, 149, 1, // 3402: check predicate 149
14432 OPC_Decode, 156, 111, 220, 1, // 3405: decode to CV_AVGU_SCI_B using decoder 220
14433 // 3405: }
14434 7, 8, // 3410: case 0x7: {
14435 OPC_CheckPredicate, 149, 1, // 3412: check predicate 149
14436 OPC_Decode, 192, 111, 229, 1, // 3415: decode to CV_CMPGE_SCI_B using decoder 229
14437 // 3415: }
14438 8, 8, // 3420: case 0x8: {
14439 OPC_CheckPredicate, 149, 1, // 3422: check predicate 149
14440 OPC_Decode, 205, 112, 229, 1, // 3425: decode to CV_MIN_SCI_B using decoder 229
14441 // 3425: }
14442 9, 8, // 3430: case 0x9: {
14443 OPC_CheckPredicate, 149, 1, // 3432: check predicate 149
14444 OPC_Decode, 228, 111, 229, 1, // 3435: decode to CV_CMPLT_SCI_B using decoder 229
14445 // 3435: }
14446 10, 8, // 3440: case 0xa: {
14447 OPC_CheckPredicate, 149, 1, // 3442: check predicate 149
14448 OPC_Decode, 199, 112, 220, 1, // 3445: decode to CV_MINU_SCI_B using decoder 220
14449 // 3445: }
14450 11, 8, // 3450: case 0xb: {
14451 OPC_CheckPredicate, 149, 1, // 3452: check predicate 149
14452 OPC_Decode, 216, 111, 229, 1, // 3455: decode to CV_CMPLE_SCI_B using decoder 229
14453 // 3455: }
14454 12, 8, // 3460: case 0xc: {
14455 OPC_CheckPredicate, 149, 1, // 3462: check predicate 149
14456 OPC_Decode, 191, 112, 229, 1, // 3465: decode to CV_MAX_SCI_B using decoder 229
14457 // 3465: }
14458 13, 8, // 3470: case 0xd: {
14459 OPC_CheckPredicate, 149, 1, // 3472: check predicate 149
14460 OPC_Decode, 198, 111, 220, 1, // 3475: decode to CV_CMPGTU_SCI_B using decoder 220
14461 // 3475: }
14462 14, 8, // 3480: case 0xe: {
14463 OPC_CheckPredicate, 149, 1, // 3482: check predicate 149
14464 OPC_Decode, 185, 112, 220, 1, // 3485: decode to CV_MAXU_SCI_B using decoder 220
14465 // 3485: }
14466 15, 8, // 3490: case 0xf: {
14467 OPC_CheckPredicate, 149, 1, // 3492: check predicate 149
14468 OPC_Decode, 186, 111, 220, 1, // 3495: decode to CV_CMPGEU_SCI_B using decoder 220
14469 // 3495: }
14470 16, 8, // 3500: case 0x10: {
14471 OPC_CheckPredicate, 149, 1, // 3502: check predicate 149
14472 OPC_Decode, 150, 113, 232, 1, // 3505: decode to CV_SRL_SCI_B using decoder 232
14473 // 3505: }
14474 17, 8, // 3510: case 0x11: {
14475 OPC_CheckPredicate, 149, 1, // 3512: check predicate 149
14476 OPC_Decode, 222, 111, 220, 1, // 3515: decode to CV_CMPLTU_SCI_B using decoder 220
14477 // 3515: }
14478 18, 8, // 3520: case 0x12: {
14479 OPC_CheckPredicate, 149, 1, // 3522: check predicate 149
14480 OPC_Decode, 144, 113, 232, 1, // 3525: decode to CV_SRA_SCI_B using decoder 232
14481 // 3525: }
14482 19, 8, // 3530: case 0x13: {
14483 OPC_CheckPredicate, 149, 1, // 3532: check predicate 149
14484 OPC_Decode, 210, 111, 220, 1, // 3535: decode to CV_CMPLEU_SCI_B using decoder 220
14485 // 3535: }
14486 20, 8, // 3540: case 0x14: {
14487 OPC_CheckPredicate, 149, 1, // 3542: check predicate 149
14488 OPC_Decode, 138, 113, 232, 1, // 3545: decode to CV_SLL_SCI_B using decoder 232
14489 // 3545: }
14490 22, 8, // 3550: case 0x16: {
14491 OPC_CheckPredicate, 149, 1, // 3552: check predicate 149
14492 OPC_Decode, 220, 112, 229, 1, // 3555: decode to CV_OR_SCI_B using decoder 229
14493 // 3555: }
14494 24, 8, // 3560: case 0x18: {
14495 OPC_CheckPredicate, 149, 1, // 3562: check predicate 149
14496 OPC_Decode, 180, 113, 229, 1, // 3565: decode to CV_XOR_SCI_B using decoder 229
14497 // 3565: }
14498 26, 8, // 3570: case 0x1a: {
14499 OPC_CheckPredicate, 149, 1, // 3572: check predicate 149
14500 OPC_Decode, 150, 111, 229, 1, // 3575: decode to CV_AND_SCI_B using decoder 229
14501 // 3575: }
14502 32, 8, // 3580: case 0x20: {
14503 OPC_CheckPredicate, 149, 1, // 3582: check predicate 149
14504 OPC_Decode, 128, 112, 220, 1, // 3585: decode to CV_DOTUP_SCI_B using decoder 220
14505 // 3585: }
14506 34, 8, // 3590: case 0x22: {
14507 OPC_CheckPredicate, 149, 1, // 3592: check predicate 149
14508 OPC_Decode, 134, 112, 229, 1, // 3595: decode to CV_DOTUSP_SCI_B using decoder 229
14509 // 3595: }
14510 36, 8, // 3600: case 0x24: {
14511 OPC_CheckPredicate, 149, 1, // 3602: check predicate 149
14512 OPC_Decode, 250, 111, 229, 1, // 3605: decode to CV_DOTSP_SCI_B using decoder 229
14513 // 3605: }
14514 38, 8, // 3610: case 0x26: {
14515 OPC_CheckPredicate, 149, 1, // 3612: check predicate 149
14516 OPC_Decode, 240, 112, 226, 1, // 3615: decode to CV_SDOTUP_SCI_B using decoder 226
14517 // 3615: }
14518 40, 8, // 3620: case 0x28: {
14519 OPC_CheckPredicate, 149, 1, // 3622: check predicate 149
14520 OPC_Decode, 246, 112, 231, 1, // 3625: decode to CV_SDOTUSP_SCI_B using decoder 231
14521 // 3625: }
14522 42, 8, // 3630: case 0x2a: {
14523 OPC_CheckPredicate, 149, 1, // 3632: check predicate 149
14524 OPC_Decode, 234, 112, 231, 1, // 3635: decode to CV_SDOTSP_SCI_B using decoder 231
14525 // 3635: }
14526 48, 8, // 3640: case 0x30: {
14527 OPC_CheckPredicate, 149, 1, // 3642: check predicate 149
14528 OPC_Decode, 252, 112, 220, 1, // 3645: decode to CV_SHUFFLEI0_SCI_B using decoder 220
14529 // 3645: }
14530 50, 8, // 3650: case 0x32: {
14531 OPC_CheckPredicate, 149, 1, // 3652: check predicate 149
14532 OPC_Decode, 253, 112, 220, 1, // 3655: decode to CV_SHUFFLEI1_SCI_B using decoder 220
14533 // 3655: }
14534 52, 8, // 3660: case 0x34: {
14535 OPC_CheckPredicate, 149, 1, // 3662: check predicate 149
14536 OPC_Decode, 254, 112, 220, 1, // 3665: decode to CV_SHUFFLEI2_SCI_B using decoder 220
14537 // 3665: }
14538 54, 0, // 3670: case 0x36: {
14539 OPC_CheckPredicate, 149, 1, // 3672: check predicate 149
14540 OPC_Decode, 255, 112, 220, 1, // 3675: decode to CV_SHUFFLEI3_SCI_B using decoder 220
14541 // 3675: }
14542 // 3675: } // switch Inst[31:26]
14543 // 3675: }
14544 // 3675: } // switch Inst[6:0]
14545 // 3675: }
14546 // 3675: } // switch Inst[14:12]
14547};
14548static const uint8_t DecoderTableXMIPS32[152] = {
14549 32, // 0: BitWidth 32
14550 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
14551 0, 16, // 4: case 0x0: {
14552 OPC_CheckPredicate, 154, 1, // 6: check predicate 154
14553 OPC_CheckField, 29, 3, 0, // 9: check Inst[31:29] == 0x0
14554 OPC_CheckField, 0, 7, 11, // 13: check Inst[6:0] == 0xb
14555 OPC_Decode, 166, 117, 233, 1, // 17: decode to MIPS_PREF using decoder 233
14556 // 17: }
14557 1, 43, // 22: case 0x1: {
14558 OPC_SwitchField, 15, 17, // 24: switch Inst[31:15] {
14559 32, 11, // 27: case 0x20: {
14560 OPC_CheckPredicate, 155, 1, // 29: check predicate 155
14561 OPC_CheckField, 0, 12, 19, // 32: check Inst[11:0] == 0x13
14562 OPC_Decode, 162, 117, 14, // 36: decode to MIPS_IHB using decoder 14
14563 // 36: }
14564 96, 11, // 40: case 0x60: {
14565 OPC_CheckPredicate, 155, 1, // 42: check predicate 155
14566 OPC_CheckField, 0, 12, 19, // 45: check Inst[11:0] == 0x13
14567 OPC_Decode, 161, 117, 14, // 49: decode to MIPS_EHB using decoder 14
14568 // 49: }
14569 160, 1, 0, // 53: case 0xa0: {
14570 OPC_CheckPredicate, 155, 1, // 56: check predicate 155
14571 OPC_CheckField, 0, 12, 19, // 59: check Inst[11:0] == 0x13
14572 OPC_Decode, 165, 117, 14, // 63: decode to MIPS_PAUSE using decoder 14
14573 // 63: }
14574 // 63: } // switch Inst[31:15]
14575 // 63: }
14576 3, 16, // 67: case 0x3: {
14577 OPC_CheckPredicate, 156, 1, // 69: check predicate 156
14578 OPC_CheckField, 25, 2, 3, // 72: check Inst[26:25] == 0x3
14579 OPC_CheckField, 0, 7, 11, // 76: check Inst[6:0] == 0xb
14580 OPC_Decode, 160, 117, 234, 1, // 80: decode to MIPS_CCMOV using decoder 234
14581 // 80: }
14582 4, 35, // 85: case 0x4: {
14583 OPC_SwitchField, 20, 2, // 87: switch Inst[21:20] {
14584 0, 16, // 90: case 0x0: {
14585 OPC_CheckPredicate, 157, 1, // 92: check predicate 157
14586 OPC_CheckField, 22, 1, 0, // 95: check Inst[22] == 0x0
14587 OPC_CheckField, 0, 7, 11, // 99: check Inst[6:0] == 0xb
14588 OPC_Decode, 163, 117, 235, 1, // 103: decode to MIPS_LDP using decoder 235
14589 // 103: }
14590 1, 0, // 108: case 0x1: {
14591 OPC_CheckPredicate, 157, 1, // 110: check predicate 157
14592 OPC_CheckField, 0, 7, 11, // 113: check Inst[6:0] == 0xb
14593 OPC_Decode, 164, 117, 236, 1, // 117: decode to MIPS_LWP using decoder 236
14594 // 117: }
14595 // 117: } // switch Inst[21:20]
14596 // 117: }
14597 5, 0, // 122: case 0x5: {
14598 OPC_SwitchField, 0, 9, // 124: switch Inst[8:0] {
14599 11, 12, // 127: case 0xb: {
14600 OPC_CheckPredicate, 157, 1, // 129: check predicate 157
14601 OPC_CheckField, 9, 1, 0, // 132: check Inst[9] == 0x0
14602 OPC_Decode, 167, 117, 237, 1, // 136: decode to MIPS_SDP using decoder 237
14603 // 136: }
14604 139, 1, 0, // 141: case 0x8b: {
14605 OPC_CheckPredicate, 157, 1, // 144: check predicate 157
14606 OPC_Decode, 168, 117, 238, 1, // 147: decode to MIPS_SWP using decoder 238
14607 // 147: }
14608 // 147: } // switch Inst[8:0]
14609 // 147: }
14610 // 147: } // switch Inst[14:12]
14611};
14612static const uint8_t DecoderTableXSMT32[994] = {
14613 32, // 0: BitWidth 32
14614 OPC_SwitchField, 26, 3, // 1: switch Inst[28:26] {
14615 0, 232, 1, // 4: case 0x0: {
14616 OPC_SwitchField, 14, 1, // 7: switch Inst[14] {
14617 0, 183, 1, // 10: case 0x0: {
14618 OPC_SwitchField, 31, 1, // 13: switch Inst[31] {
14619 0, 41, // 16: case 0x0: {
14620 OPC_SwitchField, 29, 2, // 18: switch Inst[30:29] {
14621 2, 17, // 21: case 0x2: {
14622 OPC_CheckPredicate, 158, 1, // 23: check predicate 158
14623 OPC_CheckField, 25, 1, 1, // 26: check Inst[25] == 0x1
14624 OPC_CheckField, 0, 7, 43, // 30: check Inst[6:0] == 0x2b
14625 OPC_Decode, 228, 129, 1, 239, 1, // 34: decode to VNPACK4_VV using decoder 239
14626 // 34: }
14627 3, 0, // 40: case 0x3: {
14628 OPC_CheckPredicate, 158, 1, // 42: check predicate 158
14629 OPC_CheckField, 25, 1, 1, // 45: check Inst[25] == 0x1
14630 OPC_CheckField, 0, 7, 43, // 49: check Inst[6:0] == 0x2b
14631 OPC_Decode, 229, 129, 1, 239, 1, // 53: decode to VNPACK_VV using decoder 239
14632 // 53: }
14633 // 53: } // switch Inst[30:29]
14634 // 53: }
14635 1, 0, // 59: case 0x1: {
14636 OPC_SwitchField, 12, 2, // 61: switch Inst[13:12] {
14637 0, 31, // 64: case 0x0: {
14638 OPC_CheckField, 0, 7, 43, // 66: check Inst[6:0] == 0x2b
14639 OPC_CheckField, 25, 1, 1, // 70: check Inst[25] == 0x1
14640 OPC_Scope, 12, // 74: try {
14641 OPC_CheckField, 29, 2, 3, // 76: check Inst[30:29] == 0x3
14642 OPC_CheckPredicate, 159, 1, // 80: check predicate 159
14643 OPC_Decode, 228, 124, 240, 1, // 83: decode to SMT_VMADOTU using decoder 240
14644 // 83: } else try {
14645 OPC_CheckPredicate, 158, 1, // 88: check predicate 158
14646 OPC_Decode, 132, 129, 1, 241, 1, // 91: decode to VMADOTU using decoder 241
14647 // 91: }
14648 // 91: }
14649 1, 31, // 97: case 0x1: {
14650 OPC_CheckField, 0, 7, 43, // 99: check Inst[6:0] == 0x2b
14651 OPC_CheckField, 25, 1, 1, // 103: check Inst[25] == 0x1
14652 OPC_Scope, 12, // 107: try {
14653 OPC_CheckField, 29, 2, 3, // 109: check Inst[30:29] == 0x3
14654 OPC_CheckPredicate, 159, 1, // 113: check predicate 159
14655 OPC_Decode, 229, 124, 240, 1, // 116: decode to SMT_VMADOTUS using decoder 240
14656 // 116: } else try {
14657 OPC_CheckPredicate, 158, 1, // 121: check predicate 158
14658 OPC_Decode, 133, 129, 1, 241, 1, // 124: decode to VMADOTUS using decoder 241
14659 // 124: }
14660 // 124: }
14661 2, 31, // 130: case 0x2: {
14662 OPC_CheckField, 0, 7, 43, // 132: check Inst[6:0] == 0x2b
14663 OPC_CheckField, 25, 1, 1, // 136: check Inst[25] == 0x1
14664 OPC_Scope, 12, // 140: try {
14665 OPC_CheckField, 29, 2, 3, // 142: check Inst[30:29] == 0x3
14666 OPC_CheckPredicate, 159, 1, // 146: check predicate 159
14667 OPC_Decode, 227, 124, 240, 1, // 149: decode to SMT_VMADOTSU using decoder 240
14668 // 149: } else try {
14669 OPC_CheckPredicate, 158, 1, // 154: check predicate 158
14670 OPC_Decode, 129, 129, 1, 241, 1, // 157: decode to VMADOTSU using decoder 241
14671 // 157: }
14672 // 157: }
14673 3, 0, // 163: case 0x3: {
14674 OPC_CheckField, 0, 7, 43, // 165: check Inst[6:0] == 0x2b
14675 OPC_CheckField, 25, 1, 1, // 169: check Inst[25] == 0x1
14676 OPC_Scope, 12, // 173: try {
14677 OPC_CheckField, 29, 2, 3, // 175: check Inst[30:29] == 0x3
14678 OPC_CheckPredicate, 159, 1, // 179: check predicate 159
14679 OPC_Decode, 214, 124, 240, 1, // 182: decode to SMT_VMADOT using decoder 240
14680 // 182: } else try {
14681 OPC_CheckPredicate, 158, 1, // 187: check predicate 158
14682 OPC_Decode, 244, 128, 1, 241, 1, // 190: decode to VMADOT using decoder 241
14683 // 190: }
14684 // 190: }
14685 // 190: } // switch Inst[13:12]
14686 // 190: }
14687 // 190: } // switch Inst[31]
14688 // 190: }
14689 1, 0, // 196: case 0x1: {
14690 OPC_SwitchField, 29, 3, // 198: switch Inst[31:29] {
14691 2, 17, // 201: case 0x2: {
14692 OPC_CheckPredicate, 158, 1, // 203: check predicate 158
14693 OPC_CheckField, 25, 1, 1, // 206: check Inst[25] == 0x1
14694 OPC_CheckField, 0, 7, 43, // 210: check Inst[6:0] == 0x2b
14695 OPC_Decode, 230, 129, 1, 239, 1, // 214: decode to VNSPACK4_VV using decoder 239
14696 // 214: }
14697 3, 0, // 220: case 0x3: {
14698 OPC_CheckPredicate, 158, 1, // 222: check predicate 158
14699 OPC_CheckField, 25, 1, 1, // 225: check Inst[25] == 0x1
14700 OPC_CheckField, 0, 7, 43, // 229: check Inst[6:0] == 0x2b
14701 OPC_Decode, 231, 129, 1, 239, 1, // 233: decode to VNSPACK_VV using decoder 239
14702 // 233: }
14703 // 233: } // switch Inst[31:29]
14704 // 233: }
14705 // 233: } // switch Inst[14]
14706 // 233: }
14707 1, 246, 3, // 239: case 0x1: {
14708 OPC_SwitchField, 14, 1, // 242: switch Inst[14] {
14709 0, 187, 2, // 245: case 0x0: {
14710 OPC_SwitchField, 31, 1, // 248: switch Inst[31] {
14711 0, 21, // 251: case 0x0: {
14712 OPC_CheckPredicate, 158, 1, // 253: check predicate 158
14713 OPC_CheckField, 29, 2, 3, // 256: check Inst[30:29] == 0x3
14714 OPC_CheckField, 25, 1, 1, // 260: check Inst[25] == 0x1
14715 OPC_CheckField, 0, 7, 43, // 264: check Inst[6:0] == 0x2b
14716 OPC_Decode, 241, 129, 1, 242, 1, // 268: decode to VPACK_VV using decoder 242
14717 // 268: }
14718 1, 0, // 274: case 0x1: {
14719 OPC_SwitchField, 12, 2, // 276: switch Inst[13:12] {
14720 0, 69, // 279: case 0x0: {
14721 OPC_SwitchField, 15, 1, // 281: switch Inst[15] {
14722 0, 31, // 284: case 0x0: {
14723 OPC_CheckField, 0, 7, 43, // 286: check Inst[6:0] == 0x2b
14724 OPC_CheckField, 25, 1, 1, // 290: check Inst[25] == 0x1
14725 OPC_Scope, 12, // 294: try {
14726 OPC_CheckField, 29, 2, 3, // 296: check Inst[30:29] == 0x3
14727 OPC_CheckPredicate, 159, 1, // 300: check predicate 159
14728 OPC_Decode, 217, 124, 243, 1, // 303: decode to SMT_VMADOT1U using decoder 243
14729 // 303: } else try {
14730 OPC_CheckPredicate, 158, 1, // 308: check predicate 158
14731 OPC_Decode, 247, 128, 1, 244, 1, // 311: decode to VMADOT1U using decoder 244
14732 // 311: }
14733 // 311: }
14734 1, 0, // 317: case 0x1: {
14735 OPC_CheckField, 0, 7, 43, // 319: check Inst[6:0] == 0x2b
14736 OPC_CheckField, 25, 1, 1, // 323: check Inst[25] == 0x1
14737 OPC_Scope, 12, // 327: try {
14738 OPC_CheckField, 29, 2, 3, // 329: check Inst[30:29] == 0x3
14739 OPC_CheckPredicate, 159, 1, // 333: check predicate 159
14740 OPC_Decode, 225, 124, 243, 1, // 336: decode to SMT_VMADOT3U using decoder 243
14741 // 336: } else try {
14742 OPC_CheckPredicate, 158, 1, // 341: check predicate 158
14743 OPC_Decode, 255, 128, 1, 244, 1, // 344: decode to VMADOT3U using decoder 244
14744 // 344: }
14745 // 344: }
14746 // 344: } // switch Inst[15]
14747 // 344: }
14748 1, 69, // 350: case 0x1: {
14749 OPC_SwitchField, 15, 1, // 352: switch Inst[15] {
14750 0, 31, // 355: case 0x0: {
14751 OPC_CheckField, 0, 7, 43, // 357: check Inst[6:0] == 0x2b
14752 OPC_CheckField, 25, 1, 1, // 361: check Inst[25] == 0x1
14753 OPC_Scope, 12, // 365: try {
14754 OPC_CheckField, 29, 2, 3, // 367: check Inst[30:29] == 0x3
14755 OPC_CheckPredicate, 159, 1, // 371: check predicate 159
14756 OPC_Decode, 218, 124, 243, 1, // 374: decode to SMT_VMADOT1US using decoder 243
14757 // 374: } else try {
14758 OPC_CheckPredicate, 158, 1, // 379: check predicate 158
14759 OPC_Decode, 248, 128, 1, 244, 1, // 382: decode to VMADOT1US using decoder 244
14760 // 382: }
14761 // 382: }
14762 1, 0, // 388: case 0x1: {
14763 OPC_CheckField, 0, 7, 43, // 390: check Inst[6:0] == 0x2b
14764 OPC_CheckField, 25, 1, 1, // 394: check Inst[25] == 0x1
14765 OPC_Scope, 12, // 398: try {
14766 OPC_CheckField, 29, 2, 3, // 400: check Inst[30:29] == 0x3
14767 OPC_CheckPredicate, 159, 1, // 404: check predicate 159
14768 OPC_Decode, 226, 124, 243, 1, // 407: decode to SMT_VMADOT3US using decoder 243
14769 // 407: } else try {
14770 OPC_CheckPredicate, 158, 1, // 412: check predicate 158
14771 OPC_Decode, 128, 129, 1, 244, 1, // 415: decode to VMADOT3US using decoder 244
14772 // 415: }
14773 // 415: }
14774 // 415: } // switch Inst[15]
14775 // 415: }
14776 2, 69, // 421: case 0x2: {
14777 OPC_SwitchField, 15, 1, // 423: switch Inst[15] {
14778 0, 31, // 426: case 0x0: {
14779 OPC_CheckField, 0, 7, 43, // 428: check Inst[6:0] == 0x2b
14780 OPC_CheckField, 25, 1, 1, // 432: check Inst[25] == 0x1
14781 OPC_Scope, 12, // 436: try {
14782 OPC_CheckField, 29, 2, 3, // 438: check Inst[30:29] == 0x3
14783 OPC_CheckPredicate, 159, 1, // 442: check predicate 159
14784 OPC_Decode, 216, 124, 243, 1, // 445: decode to SMT_VMADOT1SU using decoder 243
14785 // 445: } else try {
14786 OPC_CheckPredicate, 158, 1, // 450: check predicate 158
14787 OPC_Decode, 246, 128, 1, 244, 1, // 453: decode to VMADOT1SU using decoder 244
14788 // 453: }
14789 // 453: }
14790 1, 0, // 459: case 0x1: {
14791 OPC_CheckField, 0, 7, 43, // 461: check Inst[6:0] == 0x2b
14792 OPC_CheckField, 25, 1, 1, // 465: check Inst[25] == 0x1
14793 OPC_Scope, 12, // 469: try {
14794 OPC_CheckField, 29, 2, 3, // 471: check Inst[30:29] == 0x3
14795 OPC_CheckPredicate, 159, 1, // 475: check predicate 159
14796 OPC_Decode, 224, 124, 243, 1, // 478: decode to SMT_VMADOT3SU using decoder 243
14797 // 478: } else try {
14798 OPC_CheckPredicate, 158, 1, // 483: check predicate 158
14799 OPC_Decode, 254, 128, 1, 244, 1, // 486: decode to VMADOT3SU using decoder 244
14800 // 486: }
14801 // 486: }
14802 // 486: } // switch Inst[15]
14803 // 486: }
14804 3, 0, // 492: case 0x3: {
14805 OPC_SwitchField, 15, 1, // 494: switch Inst[15] {
14806 0, 31, // 497: case 0x0: {
14807 OPC_CheckField, 0, 7, 43, // 499: check Inst[6:0] == 0x2b
14808 OPC_CheckField, 25, 1, 1, // 503: check Inst[25] == 0x1
14809 OPC_Scope, 12, // 507: try {
14810 OPC_CheckField, 29, 2, 3, // 509: check Inst[30:29] == 0x3
14811 OPC_CheckPredicate, 159, 1, // 513: check predicate 159
14812 OPC_Decode, 215, 124, 243, 1, // 516: decode to SMT_VMADOT1 using decoder 243
14813 // 516: } else try {
14814 OPC_CheckPredicate, 158, 1, // 521: check predicate 158
14815 OPC_Decode, 245, 128, 1, 244, 1, // 524: decode to VMADOT1 using decoder 244
14816 // 524: }
14817 // 524: }
14818 1, 0, // 530: case 0x1: {
14819 OPC_CheckField, 0, 7, 43, // 532: check Inst[6:0] == 0x2b
14820 OPC_CheckField, 25, 1, 1, // 536: check Inst[25] == 0x1
14821 OPC_Scope, 12, // 540: try {
14822 OPC_CheckField, 29, 2, 3, // 542: check Inst[30:29] == 0x3
14823 OPC_CheckPredicate, 159, 1, // 546: check predicate 159
14824 OPC_Decode, 223, 124, 243, 1, // 549: decode to SMT_VMADOT3 using decoder 243
14825 // 549: } else try {
14826 OPC_CheckPredicate, 158, 1, // 554: check predicate 158
14827 OPC_Decode, 253, 128, 1, 244, 1, // 557: decode to VMADOT3 using decoder 244
14828 // 557: }
14829 // 557: }
14830 // 557: } // switch Inst[15]
14831 // 557: }
14832 // 557: } // switch Inst[13:12]
14833 // 557: }
14834 // 557: } // switch Inst[31]
14835 // 557: }
14836 1, 0, // 563: case 0x1: {
14837 OPC_SwitchField, 31, 1, // 565: switch Inst[31] {
14838 0, 21, // 568: case 0x0: {
14839 OPC_CheckPredicate, 158, 1, // 570: check predicate 158
14840 OPC_CheckField, 29, 2, 3, // 573: check Inst[30:29] == 0x3
14841 OPC_CheckField, 25, 1, 1, // 577: check Inst[25] == 0x1
14842 OPC_CheckField, 0, 7, 43, // 581: check Inst[6:0] == 0x2b
14843 OPC_Decode, 203, 131, 1, 242, 1, // 585: decode to VUPACK_VV using decoder 242
14844 // 585: }
14845 1, 0, // 591: case 0x1: {
14846 OPC_SwitchField, 12, 2, // 593: switch Inst[13:12] {
14847 0, 35, // 596: case 0x0: {
14848 OPC_CheckField, 0, 7, 43, // 598: check Inst[6:0] == 0x2b
14849 OPC_CheckField, 15, 1, 0, // 602: check Inst[15] == 0x0
14850 OPC_CheckField, 25, 1, 1, // 606: check Inst[25] == 0x1
14851 OPC_Scope, 12, // 610: try {
14852 OPC_CheckField, 29, 2, 3, // 612: check Inst[30:29] == 0x3
14853 OPC_CheckPredicate, 159, 1, // 616: check predicate 159
14854 OPC_Decode, 221, 124, 243, 1, // 619: decode to SMT_VMADOT2U using decoder 243
14855 // 619: } else try {
14856 OPC_CheckPredicate, 158, 1, // 624: check predicate 158
14857 OPC_Decode, 251, 128, 1, 244, 1, // 627: decode to VMADOT2U using decoder 244
14858 // 627: }
14859 // 627: }
14860 1, 35, // 633: case 0x1: {
14861 OPC_CheckField, 0, 7, 43, // 635: check Inst[6:0] == 0x2b
14862 OPC_CheckField, 15, 1, 0, // 639: check Inst[15] == 0x0
14863 OPC_CheckField, 25, 1, 1, // 643: check Inst[25] == 0x1
14864 OPC_Scope, 12, // 647: try {
14865 OPC_CheckField, 29, 2, 3, // 649: check Inst[30:29] == 0x3
14866 OPC_CheckPredicate, 159, 1, // 653: check predicate 159
14867 OPC_Decode, 222, 124, 243, 1, // 656: decode to SMT_VMADOT2US using decoder 243
14868 // 656: } else try {
14869 OPC_CheckPredicate, 158, 1, // 661: check predicate 158
14870 OPC_Decode, 252, 128, 1, 244, 1, // 664: decode to VMADOT2US using decoder 244
14871 // 664: }
14872 // 664: }
14873 2, 35, // 670: case 0x2: {
14874 OPC_CheckField, 0, 7, 43, // 672: check Inst[6:0] == 0x2b
14875 OPC_CheckField, 15, 1, 0, // 676: check Inst[15] == 0x0
14876 OPC_CheckField, 25, 1, 1, // 680: check Inst[25] == 0x1
14877 OPC_Scope, 12, // 684: try {
14878 OPC_CheckField, 29, 2, 3, // 686: check Inst[30:29] == 0x3
14879 OPC_CheckPredicate, 159, 1, // 690: check predicate 159
14880 OPC_Decode, 220, 124, 243, 1, // 693: decode to SMT_VMADOT2SU using decoder 243
14881 // 693: } else try {
14882 OPC_CheckPredicate, 158, 1, // 698: check predicate 158
14883 OPC_Decode, 250, 128, 1, 244, 1, // 701: decode to VMADOT2SU using decoder 244
14884 // 701: }
14885 // 701: }
14886 3, 0, // 707: case 0x3: {
14887 OPC_CheckField, 0, 7, 43, // 709: check Inst[6:0] == 0x2b
14888 OPC_CheckField, 15, 1, 0, // 713: check Inst[15] == 0x0
14889 OPC_CheckField, 25, 1, 1, // 717: check Inst[25] == 0x1
14890 OPC_Scope, 12, // 721: try {
14891 OPC_CheckField, 29, 2, 3, // 723: check Inst[30:29] == 0x3
14892 OPC_CheckPredicate, 159, 1, // 727: check predicate 159
14893 OPC_Decode, 219, 124, 243, 1, // 730: decode to SMT_VMADOT2 using decoder 243
14894 // 730: } else try {
14895 OPC_CheckPredicate, 158, 1, // 735: check predicate 158
14896 OPC_Decode, 249, 128, 1, 244, 1, // 738: decode to VMADOT2 using decoder 244
14897 // 738: }
14898 // 738: }
14899 // 738: } // switch Inst[13:12]
14900 // 738: }
14901 // 738: } // switch Inst[31]
14902 // 738: }
14903 // 738: } // switch Inst[14]
14904 // 738: }
14905 2, 79, // 744: case 0x2: {
14906 OPC_SwitchField, 12, 3, // 746: switch Inst[14:12] {
14907 0, 17, // 749: case 0x0: {
14908 OPC_CheckPredicate, 158, 1, // 751: check predicate 158
14909 OPC_CheckField, 31, 1, 1, // 754: check Inst[31] == 0x1
14910 OPC_CheckField, 0, 7, 43, // 758: check Inst[6:0] == 0x2b
14911 OPC_Decode, 137, 129, 1, 245, 1, // 762: decode to VMADOTU_SP using decoder 245
14912 // 762: }
14913 1, 17, // 768: case 0x1: {
14914 OPC_CheckPredicate, 158, 1, // 770: check predicate 158
14915 OPC_CheckField, 31, 1, 1, // 773: check Inst[31] == 0x1
14916 OPC_CheckField, 0, 7, 43, // 777: check Inst[6:0] == 0x2b
14917 OPC_Decode, 135, 129, 1, 245, 1, // 781: decode to VMADOTUS_SP using decoder 245
14918 // 781: }
14919 2, 17, // 787: case 0x2: {
14920 OPC_CheckPredicate, 158, 1, // 789: check predicate 158
14921 OPC_CheckField, 31, 1, 1, // 792: check Inst[31] == 0x1
14922 OPC_CheckField, 0, 7, 43, // 796: check Inst[6:0] == 0x2b
14923 OPC_Decode, 131, 129, 1, 245, 1, // 800: decode to VMADOTSU_SP using decoder 245
14924 // 800: }
14925 3, 0, // 806: case 0x3: {
14926 OPC_CheckPredicate, 158, 1, // 808: check predicate 158
14927 OPC_CheckField, 31, 1, 1, // 811: check Inst[31] == 0x1
14928 OPC_CheckField, 0, 7, 43, // 815: check Inst[6:0] == 0x2b
14929 OPC_Decode, 139, 129, 1, 245, 1, // 819: decode to VMADOT_SP using decoder 245
14930 // 819: }
14931 // 819: } // switch Inst[14:12]
14932 // 819: }
14933 3, 17, // 825: case 0x3: {
14934 OPC_CheckPredicate, 158, 1, // 827: check predicate 158
14935 OPC_CheckField, 31, 1, 1, // 830: check Inst[31] == 0x1
14936 OPC_CheckField, 0, 7, 43, // 834: check Inst[6:0] == 0x2b
14937 OPC_Decode, 136, 129, 1, 246, 1, // 838: decode to VMADOTU_HP using decoder 246
14938 // 838: }
14939 4, 17, // 844: case 0x4: {
14940 OPC_CheckPredicate, 158, 1, // 846: check predicate 158
14941 OPC_CheckField, 31, 1, 1, // 849: check Inst[31] == 0x1
14942 OPC_CheckField, 0, 7, 43, // 853: check Inst[6:0] == 0x2b
14943 OPC_Decode, 138, 129, 1, 246, 1, // 857: decode to VMADOT_HP using decoder 246
14944 // 857: }
14945 5, 17, // 863: case 0x5: {
14946 OPC_CheckPredicate, 158, 1, // 865: check predicate 158
14947 OPC_CheckField, 31, 1, 1, // 868: check Inst[31] == 0x1
14948 OPC_CheckField, 0, 7, 43, // 872: check Inst[6:0] == 0x2b
14949 OPC_Decode, 130, 129, 1, 246, 1, // 876: decode to VMADOTSU_HP using decoder 246
14950 // 876: }
14951 6, 17, // 882: case 0x6: {
14952 OPC_CheckPredicate, 158, 1, // 884: check predicate 158
14953 OPC_CheckField, 31, 1, 1, // 887: check Inst[31] == 0x1
14954 OPC_CheckField, 0, 7, 43, // 891: check Inst[6:0] == 0x2b
14955 OPC_Decode, 134, 129, 1, 246, 1, // 895: decode to VMADOTUS_HP using decoder 246
14956 // 895: }
14957 7, 0, // 901: case 0x7: {
14958 OPC_SwitchField, 12, 3, // 903: switch Inst[14:12] {
14959 4, 20, // 906: case 0x4: {
14960 OPC_CheckPredicate, 158, 1, // 908: check predicate 158
14961 OPC_CheckField, 29, 3, 4, // 911: check Inst[31:29] == 0x4
14962 OPC_CheckField, 25, 1, 1, // 915: check Inst[25] == 0x1
14963 OPC_CheckField, 0, 7, 43, // 919: check Inst[6:0] == 0x2b
14964 OPC_Decode, 159, 127, 240, 1, // 923: decode to VFWMADOT using decoder 240
14965 // 923: }
14966 5, 20, // 928: case 0x5: {
14967 OPC_CheckPredicate, 158, 1, // 930: check predicate 158
14968 OPC_CheckField, 29, 3, 4, // 933: check Inst[31:29] == 0x4
14969 OPC_CheckField, 25, 1, 1, // 937: check Inst[25] == 0x1
14970 OPC_CheckField, 0, 7, 43, // 941: check Inst[6:0] == 0x2b
14971 OPC_Decode, 160, 127, 247, 1, // 945: decode to VFWMADOT1 using decoder 247
14972 // 945: }
14973 6, 20, // 950: case 0x6: {
14974 OPC_CheckPredicate, 158, 1, // 952: check predicate 158
14975 OPC_CheckField, 29, 3, 4, // 955: check Inst[31:29] == 0x4
14976 OPC_CheckField, 25, 1, 1, // 959: check Inst[25] == 0x1
14977 OPC_CheckField, 0, 7, 43, // 963: check Inst[6:0] == 0x2b
14978 OPC_Decode, 161, 127, 247, 1, // 967: decode to VFWMADOT2 using decoder 247
14979 // 967: }
14980 7, 0, // 972: case 0x7: {
14981 OPC_CheckPredicate, 158, 1, // 974: check predicate 158
14982 OPC_CheckField, 29, 3, 4, // 977: check Inst[31:29] == 0x4
14983 OPC_CheckField, 25, 1, 1, // 981: check Inst[25] == 0x1
14984 OPC_CheckField, 0, 7, 43, // 985: check Inst[6:0] == 0x2b
14985 OPC_Decode, 162, 127, 247, 1, // 989: decode to VFWMADOT3 using decoder 247
14986 // 989: }
14987 // 989: } // switch Inst[14:12]
14988 // 989: }
14989 // 989: } // switch Inst[28:26]
14990};
14991static const uint8_t DecoderTableXSfcease32[16] = {
14992 32, // 0: BitWidth 32
14993 OPC_CheckPredicate, 160, 1, // 1: check predicate 160
14994 OPC_CheckField, 0, 32, 243, 128, 192, 130, 3,
14995 // 4: check Inst[31:0] == 0x30500073
14996 OPC_Decode, 231, 123, 14, // 12: decode to SF_CEASE using decoder 14
14997};
14998static const uint8_t DecoderTableXSfsystem32[32] = {
14999 32, // 0: BitWidth 32
15000 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
15001 192, 31, 11, // 4: case 0xfc0: {
15002 OPC_CheckPredicate, 161, 1, // 7: check predicate 161
15003 OPC_CheckField, 0, 15, 115, // 10: check Inst[14:0] == 0x73
15004 OPC_Decode, 232, 123, 15, // 14: decode to SF_CFLUSH_D_L1 using decoder 15
15005 // 14: }
15006 194, 31, 0, // 18: case 0xfc2: {
15007 OPC_CheckPredicate, 162, 1, // 21: check predicate 162
15008 OPC_CheckField, 0, 15, 115, // 24: check Inst[14:0] == 0x73
15009 OPC_Decode, 230, 123, 15, // 28: decode to SF_CDISCARD_D_L1 using decoder 15
15010 // 28: }
15011 // 28: } // switch Inst[31:20]
15012};
15013static const uint8_t DecoderTableXSfvector32[1129] = {
15014 32, // 0: BitWidth 32
15015 OPC_SwitchField, 28, 4, // 1: switch Inst[31:28] {
15016 0, 69, // 4: case 0x0: {
15017 OPC_SwitchField, 12, 3, // 6: switch Inst[14:12] {
15018 3, 31, // 9: case 0x3: {
15019 OPC_SwitchField, 25, 1, // 11: switch Inst[25] {
15020 0, 12, // 14: case 0x0: {
15021 OPC_CheckPredicate, 163, 1, // 16: check predicate 163
15022 OPC_CheckField, 0, 7, 91, // 19: check Inst[6:0] == 0x5b
15023 OPC_Decode, 255, 123, 248, 1, // 23: decode to SF_VC_V_I using decoder 248
15024 // 23: }
15025 1, 0, // 28: case 0x1: {
15026 OPC_CheckPredicate, 163, 1, // 30: check predicate 163
15027 OPC_CheckField, 0, 7, 91, // 33: check Inst[6:0] == 0x5b
15028 OPC_Decode, 245, 123, 249, 1, // 37: decode to SF_VC_I using decoder 249
15029 // 37: }
15030 // 37: } // switch Inst[25]
15031 // 37: }
15032 4, 0, // 42: case 0x4: {
15033 OPC_SwitchField, 25, 1, // 44: switch Inst[25] {
15034 0, 12, // 47: case 0x0: {
15035 OPC_CheckPredicate, 163, 1, // 49: check predicate 163
15036 OPC_CheckField, 0, 7, 91, // 52: check Inst[6:0] == 0x5b
15037 OPC_Decode, 134, 124, 250, 1, // 56: decode to SF_VC_V_X using decoder 250
15038 // 56: }
15039 1, 0, // 61: case 0x1: {
15040 OPC_CheckPredicate, 163, 1, // 63: check predicate 163
15041 OPC_CheckField, 0, 7, 91, // 66: check Inst[6:0] == 0x5b
15042 OPC_Decode, 138, 124, 251, 1, // 70: decode to SF_VC_X using decoder 251
15043 // 70: }
15044 // 70: } // switch Inst[25]
15045 // 70: }
15046 // 70: } // switch Inst[14:12]
15047 // 70: }
15048 1, 33, // 75: case 0x1: {
15049 OPC_SwitchField, 0, 15, // 77: switch Inst[14:0] {
15050 135, 224, 1, 11, // 80: case 0x7007: {
15051 OPC_CheckPredicate, 164, 1, // 84: check predicate 164
15052 OPC_CheckField, 25, 3, 1, // 87: check Inst[27:25] == 0x1
15053 OPC_Decode, 150, 124, 59, // 91: decode to SF_VLTE8 using decoder 59
15054 // 91: }
15055 167, 224, 1, 0, // 95: case 0x7027: {
15056 OPC_CheckPredicate, 164, 1, // 99: check predicate 164
15057 OPC_CheckField, 25, 3, 1, // 102: check Inst[27:25] == 0x1
15058 OPC_Decode, 165, 124, 59, // 106: decode to SF_VSTE8 using decoder 59
15059 // 106: }
15060 // 106: } // switch Inst[14:0]
15061 // 106: }
15062 2, 143, 1, // 110: case 0x2: {
15063 OPC_SwitchField, 12, 3, // 113: switch Inst[14:12] {
15064 0, 31, // 116: case 0x0: {
15065 OPC_SwitchField, 25, 1, // 118: switch Inst[25] {
15066 0, 12, // 121: case 0x0: {
15067 OPC_CheckPredicate, 163, 1, // 123: check predicate 163
15068 OPC_CheckField, 0, 7, 91, // 126: check Inst[6:0] == 0x5b
15069 OPC_Decode, 131, 124, 252, 1, // 130: decode to SF_VC_V_VV using decoder 252
15070 // 130: }
15071 1, 0, // 135: case 0x1: {
15072 OPC_CheckPredicate, 163, 1, // 137: check predicate 163
15073 OPC_CheckField, 0, 7, 91, // 140: check Inst[6:0] == 0x5b
15074 OPC_Decode, 249, 123, 253, 1, // 144: decode to SF_VC_VV using decoder 253
15075 // 144: }
15076 // 144: } // switch Inst[25]
15077 // 144: }
15078 3, 31, // 149: case 0x3: {
15079 OPC_SwitchField, 25, 1, // 151: switch Inst[25] {
15080 0, 12, // 154: case 0x0: {
15081 OPC_CheckPredicate, 163, 1, // 156: check predicate 163
15082 OPC_CheckField, 0, 7, 91, // 159: check Inst[6:0] == 0x5b
15083 OPC_Decode, 128, 124, 254, 1, // 163: decode to SF_VC_V_IV using decoder 254
15084 // 163: }
15085 1, 0, // 168: case 0x1: {
15086 OPC_CheckPredicate, 163, 1, // 170: check predicate 163
15087 OPC_CheckField, 0, 7, 91, // 173: check Inst[6:0] == 0x5b
15088 OPC_Decode, 246, 123, 255, 1, // 177: decode to SF_VC_IV using decoder 255
15089 // 177: }
15090 // 177: } // switch Inst[25]
15091 // 177: }
15092 4, 31, // 182: case 0x4: {
15093 OPC_SwitchField, 25, 1, // 184: switch Inst[25] {
15094 0, 12, // 187: case 0x0: {
15095 OPC_CheckPredicate, 163, 1, // 189: check predicate 163
15096 OPC_CheckField, 0, 7, 91, // 192: check Inst[6:0] == 0x5b
15097 OPC_Decode, 135, 124, 128, 2, // 196: decode to SF_VC_V_XV using decoder 256
15098 // 196: }
15099 1, 0, // 201: case 0x1: {
15100 OPC_CheckPredicate, 163, 1, // 203: check predicate 163
15101 OPC_CheckField, 0, 7, 91, // 206: check Inst[6:0] == 0x5b
15102 OPC_Decode, 139, 124, 129, 2, // 210: decode to SF_VC_XV using decoder 257
15103 // 210: }
15104 // 210: } // switch Inst[25]
15105 // 210: }
15106 5, 0, // 215: case 0x5: {
15107 OPC_SwitchField, 25, 1, // 217: switch Inst[25] {
15108 0, 16, // 220: case 0x0: {
15109 OPC_CheckPredicate, 163, 1, // 222: check predicate 163
15110 OPC_CheckField, 27, 1, 1, // 225: check Inst[27] == 0x1
15111 OPC_CheckField, 0, 7, 91, // 229: check Inst[6:0] == 0x5b
15112 OPC_Decode, 252, 123, 130, 2, // 233: decode to SF_VC_V_FV using decoder 258
15113 // 233: }
15114 1, 0, // 238: case 0x1: {
15115 OPC_CheckPredicate, 163, 1, // 240: check predicate 163
15116 OPC_CheckField, 27, 1, 1, // 243: check Inst[27] == 0x1
15117 OPC_CheckField, 0, 7, 91, // 247: check Inst[6:0] == 0x5b
15118 OPC_Decode, 242, 123, 131, 2, // 251: decode to SF_VC_FV using decoder 259
15119 // 251: }
15120 // 251: } // switch Inst[25]
15121 // 251: }
15122 // 251: } // switch Inst[14:12]
15123 // 251: }
15124 3, 33, // 256: case 0x3: {
15125 OPC_SwitchField, 0, 15, // 258: switch Inst[14:0] {
15126 135, 224, 1, 11, // 261: case 0x7007: {
15127 OPC_CheckPredicate, 164, 1, // 265: check predicate 164
15128 OPC_CheckField, 25, 3, 1, // 268: check Inst[27:25] == 0x1
15129 OPC_Decode, 147, 124, 59, // 272: decode to SF_VLTE16 using decoder 59
15130 // 272: }
15131 167, 224, 1, 0, // 276: case 0x7027: {
15132 OPC_CheckPredicate, 164, 1, // 280: check predicate 164
15133 OPC_CheckField, 25, 3, 1, // 283: check Inst[27:25] == 0x1
15134 OPC_Decode, 162, 124, 59, // 287: decode to SF_VSTE16 using decoder 59
15135 // 287: }
15136 // 287: } // switch Inst[14:0]
15137 // 287: }
15138 4, 95, // 291: case 0x4: {
15139 OPC_SwitchField, 12, 3, // 293: switch Inst[14:12] {
15140 1, 37, // 296: case 0x1: {
15141 OPC_SwitchField, 15, 5, // 298: switch Inst[19:15] {
15142 6, 15, // 301: case 0x6: {
15143 OPC_CheckPredicate, 165, 1, // 303: check predicate 165
15144 OPC_CheckField, 26, 2, 3, // 306: check Inst[27:26] == 0x3
15145 OPC_CheckField, 0, 7, 87, // 310: check Inst[6:0] == 0x57
15146 OPC_Decode, 142, 124, 124, // 314: decode to SF_VFEXPA_V using decoder 124
15147 // 314: }
15148 7, 0, // 318: case 0x7: {
15149 OPC_CheckPredicate, 166, 1, // 320: check predicate 166
15150 OPC_CheckField, 26, 2, 3, // 323: check Inst[27:26] == 0x3
15151 OPC_CheckField, 0, 7, 87, // 327: check Inst[6:0] == 0x57
15152 OPC_Decode, 143, 124, 124, // 331: decode to SF_VFEXP_V using decoder 124
15153 // 331: }
15154 // 331: } // switch Inst[19:15]
15155 // 331: }
15156 6, 0, // 335: case 0x6: {
15157 OPC_SwitchField, 20, 8, // 337: switch Inst[27:20] {
15158 60, 15, // 340: case 0x3c: {
15159 OPC_CheckPredicate, 164, 1, // 342: check predicate 164
15160 OPC_CheckField, 15, 5, 0, // 345: check Inst[19:15] == 0x0
15161 OPC_CheckField, 0, 12, 87, // 349: check Inst[11:0] == 0x57
15162 OPC_Decode, 166, 124, 14, // 353: decode to SF_VTDISCARD using decoder 14
15163 // 353: }
15164 62, 16, // 357: case 0x3e: {
15165 OPC_CheckPredicate, 164, 1, // 359: check predicate 164
15166 OPC_CheckField, 15, 5, 0, // 362: check Inst[19:15] == 0x0
15167 OPC_CheckField, 0, 8, 87, // 366: check Inst[7:0] == 0x57
15168 OPC_Decode, 169, 124, 132, 2, // 370: decode to SF_VTZERO_T using decoder 260
15169 // 370: }
15170 63, 0, // 375: case 0x3f: {
15171 OPC_CheckPredicate, 164, 1, // 377: check predicate 164
15172 OPC_CheckField, 0, 7, 87, // 380: check Inst[6:0] == 0x57
15173 OPC_Decode, 168, 124, 2, // 384: decode to SF_VTMV_V_T using decoder 2
15174 // 384: }
15175 // 384: } // switch Inst[27:20]
15176 // 384: }
15177 // 384: } // switch Inst[14:12]
15178 // 384: }
15179 5, 49, // 388: case 0x5: {
15180 OPC_SwitchField, 0, 15, // 390: switch Inst[14:0] {
15181 215, 192, 1, 12, // 393: case 0x6057: {
15182 OPC_CheckPredicate, 164, 1, // 397: check predicate 164
15183 OPC_CheckField, 25, 3, 7, // 400: check Inst[27:25] == 0x7
15184 OPC_Decode, 167, 124, 133, 2, // 404: decode to SF_VTMV_T_V using decoder 261
15185 // 404: }
15186 135, 224, 1, 11, // 409: case 0x7007: {
15187 OPC_CheckPredicate, 164, 1, // 413: check predicate 164
15188 OPC_CheckField, 25, 3, 1, // 416: check Inst[27:25] == 0x1
15189 OPC_Decode, 148, 124, 59, // 420: decode to SF_VLTE32 using decoder 59
15190 // 420: }
15191 167, 224, 1, 0, // 424: case 0x7027: {
15192 OPC_CheckPredicate, 164, 1, // 428: check predicate 164
15193 OPC_CheckField, 25, 3, 1, // 431: check Inst[27:25] == 0x1
15194 OPC_Decode, 163, 124, 59, // 435: decode to SF_VSTE32 using decoder 59
15195 // 435: }
15196 // 435: } // switch Inst[14:0]
15197 // 435: }
15198 7, 33, // 439: case 0x7: {
15199 OPC_SwitchField, 0, 15, // 441: switch Inst[14:0] {
15200 135, 224, 1, 11, // 444: case 0x7007: {
15201 OPC_CheckPredicate, 164, 1, // 448: check predicate 164
15202 OPC_CheckField, 25, 3, 1, // 451: check Inst[27:25] == 0x1
15203 OPC_Decode, 149, 124, 59, // 455: decode to SF_VLTE64 using decoder 59
15204 // 455: }
15205 167, 224, 1, 0, // 459: case 0x7027: {
15206 OPC_CheckPredicate, 164, 1, // 463: check predicate 164
15207 OPC_CheckField, 25, 3, 1, // 466: check Inst[27:25] == 0x1
15208 OPC_Decode, 164, 124, 59, // 470: decode to SF_VSTE64 using decoder 59
15209 // 470: }
15210 // 470: } // switch Inst[14:0]
15211 // 470: }
15212 8, 95, // 474: case 0x8: {
15213 OPC_SwitchField, 26, 2, // 476: switch Inst[27:26] {
15214 1, 54, // 479: case 0x1: {
15215 OPC_SwitchField, 20, 6, // 481: switch Inst[25:20] {
15216 0, 15, // 484: case 0x0: {
15217 OPC_CheckPredicate, 164, 1, // 486: check predicate 164
15218 OPC_CheckField, 12, 3, 7, // 489: check Inst[14:12] == 0x7
15219 OPC_CheckField, 0, 7, 87, // 493: check Inst[6:0] == 0x57
15220 OPC_Decode, 161, 124, 17, // 497: decode to SF_VSETTN using decoder 17
15221 // 497: }
15222 1, 15, // 501: case 0x1: {
15223 OPC_CheckPredicate, 164, 1, // 503: check predicate 164
15224 OPC_CheckField, 12, 3, 7, // 506: check Inst[14:12] == 0x7
15225 OPC_CheckField, 0, 7, 87, // 510: check Inst[6:0] == 0x57
15226 OPC_Decode, 160, 124, 17, // 514: decode to SF_VSETTM using decoder 17
15227 // 514: }
15228 2, 0, // 518: case 0x2: {
15229 OPC_CheckPredicate, 164, 1, // 520: check predicate 164
15230 OPC_CheckField, 12, 3, 7, // 523: check Inst[14:12] == 0x7
15231 OPC_CheckField, 0, 7, 87, // 527: check Inst[6:0] == 0x57
15232 OPC_Decode, 159, 124, 17, // 531: decode to SF_VSETTK using decoder 17
15233 // 531: }
15234 // 531: } // switch Inst[25:20]
15235 // 531: }
15236 2, 16, // 535: case 0x2: {
15237 OPC_CheckPredicate, 167, 1, // 537: check predicate 167
15238 OPC_CheckField, 12, 3, 5, // 540: check Inst[14:12] == 0x5
15239 OPC_CheckField, 0, 7, 91, // 544: check Inst[6:0] == 0x5b
15240 OPC_Decode, 144, 124, 143, 1, // 548: decode to SF_VFNRCLIP_XU_F_QF using decoder 143
15241 // 548: }
15242 3, 0, // 553: case 0x3: {
15243 OPC_CheckPredicate, 167, 1, // 555: check predicate 167
15244 OPC_CheckField, 12, 3, 5, // 558: check Inst[14:12] == 0x5
15245 OPC_CheckField, 0, 7, 91, // 562: check Inst[6:0] == 0x5b
15246 OPC_Decode, 145, 124, 143, 1, // 566: decode to SF_VFNRCLIP_X_F_QF using decoder 143
15247 // 566: }
15248 // 566: } // switch Inst[27:26]
15249 // 566: }
15250 10, 143, 1, // 571: case 0xa: {
15251 OPC_SwitchField, 12, 3, // 574: switch Inst[14:12] {
15252 0, 31, // 577: case 0x0: {
15253 OPC_SwitchField, 25, 1, // 579: switch Inst[25] {
15254 0, 12, // 582: case 0x0: {
15255 OPC_CheckPredicate, 163, 1, // 584: check predicate 163
15256 OPC_CheckField, 0, 7, 91, // 587: check Inst[6:0] == 0x5b
15257 OPC_Decode, 132, 124, 134, 2, // 591: decode to SF_VC_V_VVV using decoder 262
15258 // 591: }
15259 1, 0, // 596: case 0x1: {
15260 OPC_CheckPredicate, 163, 1, // 598: check predicate 163
15261 OPC_CheckField, 0, 7, 91, // 601: check Inst[6:0] == 0x5b
15262 OPC_Decode, 250, 123, 135, 2, // 605: decode to SF_VC_VVV using decoder 263
15263 // 605: }
15264 // 605: } // switch Inst[25]
15265 // 605: }
15266 3, 31, // 610: case 0x3: {
15267 OPC_SwitchField, 25, 1, // 612: switch Inst[25] {
15268 0, 12, // 615: case 0x0: {
15269 OPC_CheckPredicate, 163, 1, // 617: check predicate 163
15270 OPC_CheckField, 0, 7, 91, // 620: check Inst[6:0] == 0x5b
15271 OPC_Decode, 129, 124, 136, 2, // 624: decode to SF_VC_V_IVV using decoder 264
15272 // 624: }
15273 1, 0, // 629: case 0x1: {
15274 OPC_CheckPredicate, 163, 1, // 631: check predicate 163
15275 OPC_CheckField, 0, 7, 91, // 634: check Inst[6:0] == 0x5b
15276 OPC_Decode, 247, 123, 137, 2, // 638: decode to SF_VC_IVV using decoder 265
15277 // 638: }
15278 // 638: } // switch Inst[25]
15279 // 638: }
15280 4, 31, // 643: case 0x4: {
15281 OPC_SwitchField, 25, 1, // 645: switch Inst[25] {
15282 0, 12, // 648: case 0x0: {
15283 OPC_CheckPredicate, 163, 1, // 650: check predicate 163
15284 OPC_CheckField, 0, 7, 91, // 653: check Inst[6:0] == 0x5b
15285 OPC_Decode, 136, 124, 138, 2, // 657: decode to SF_VC_V_XVV using decoder 266
15286 // 657: }
15287 1, 0, // 662: case 0x1: {
15288 OPC_CheckPredicate, 163, 1, // 664: check predicate 163
15289 OPC_CheckField, 0, 7, 91, // 667: check Inst[6:0] == 0x5b
15290 OPC_Decode, 140, 124, 139, 2, // 671: decode to SF_VC_XVV using decoder 267
15291 // 671: }
15292 // 671: } // switch Inst[25]
15293 // 671: }
15294 5, 0, // 676: case 0x5: {
15295 OPC_SwitchField, 25, 1, // 678: switch Inst[25] {
15296 0, 16, // 681: case 0x0: {
15297 OPC_CheckPredicate, 163, 1, // 683: check predicate 163
15298 OPC_CheckField, 27, 1, 1, // 686: check Inst[27] == 0x1
15299 OPC_CheckField, 0, 7, 91, // 690: check Inst[6:0] == 0x5b
15300 OPC_Decode, 253, 123, 140, 2, // 694: decode to SF_VC_V_FVV using decoder 268
15301 // 694: }
15302 1, 0, // 699: case 0x1: {
15303 OPC_CheckPredicate, 163, 1, // 701: check predicate 163
15304 OPC_CheckField, 27, 1, 1, // 704: check Inst[27] == 0x1
15305 OPC_CheckField, 0, 7, 91, // 708: check Inst[6:0] == 0x5b
15306 OPC_Decode, 243, 123, 141, 2, // 712: decode to SF_VC_FVV using decoder 269
15307 // 712: }
15308 // 712: } // switch Inst[25]
15309 // 712: }
15310 // 712: } // switch Inst[14:12]
15311 // 712: }
15312 11, 71, // 717: case 0xb: {
15313 OPC_SwitchField, 25, 3, // 719: switch Inst[27:25] {
15314 1, 15, // 722: case 0x1: {
15315 OPC_CheckPredicate, 168, 1, // 724: check predicate 168
15316 OPC_CheckField, 12, 3, 2, // 727: check Inst[14:12] == 0x2
15317 OPC_CheckField, 0, 7, 91, // 731: check Inst[6:0] == 0x5b
15318 OPC_Decode, 155, 124, 120, // 735: decode to SF_VQMACCU_2x8x2 using decoder 120
15319 // 735: }
15320 3, 15, // 739: case 0x3: {
15321 OPC_CheckPredicate, 168, 1, // 741: check predicate 168
15322 OPC_CheckField, 12, 3, 2, // 744: check Inst[14:12] == 0x2
15323 OPC_CheckField, 0, 7, 91, // 748: check Inst[6:0] == 0x5b
15324 OPC_Decode, 157, 124, 120, // 752: decode to SF_VQMACC_2x8x2 using decoder 120
15325 // 752: }
15326 5, 15, // 756: case 0x5: {
15327 OPC_CheckPredicate, 168, 1, // 758: check predicate 168
15328 OPC_CheckField, 12, 3, 2, // 761: check Inst[14:12] == 0x2
15329 OPC_CheckField, 0, 7, 91, // 765: check Inst[6:0] == 0x5b
15330 OPC_Decode, 153, 124, 120, // 769: decode to SF_VQMACCUS_2x8x2 using decoder 120
15331 // 769: }
15332 7, 0, // 773: case 0x7: {
15333 OPC_CheckPredicate, 168, 1, // 775: check predicate 168
15334 OPC_CheckField, 12, 3, 2, // 778: check Inst[14:12] == 0x2
15335 OPC_CheckField, 0, 7, 91, // 782: check Inst[6:0] == 0x5b
15336 OPC_Decode, 151, 124, 120, // 786: decode to SF_VQMACCSU_2x8x2 using decoder 120
15337 // 786: }
15338 // 786: } // switch Inst[27:25]
15339 // 786: }
15340 15, 0, // 790: case 0xf: {
15341 OPC_SwitchField, 12, 3, // 792: switch Inst[14:12] {
15342 0, 83, // 795: case 0x0: {
15343 OPC_SwitchField, 0, 7, // 797: switch Inst[6:0] {
15344 91, 23, // 800: case 0x5b: {
15345 OPC_SwitchField, 25, 1, // 802: switch Inst[25] {
15346 0, 8, // 805: case 0x0: {
15347 OPC_CheckPredicate, 163, 1, // 807: check predicate 163
15348 OPC_Decode, 133, 124, 134, 2, // 810: decode to SF_VC_V_VVW using decoder 262
15349 // 810: }
15350 1, 0, // 815: case 0x1: {
15351 OPC_CheckPredicate, 163, 1, // 817: check predicate 163
15352 OPC_Decode, 251, 123, 135, 2, // 820: decode to SF_VC_VVW using decoder 263
15353 // 820: }
15354 // 820: } // switch Inst[25]
15355 // 820: }
15356 119, 0, // 825: case 0x77: {
15357 OPC_SwitchField, 7, 3, // 827: switch Inst[9:7] {
15358 0, 23, // 830: case 0x0: {
15359 OPC_SwitchField, 25, 3, // 832: switch Inst[27:25] {
15360 1, 8, // 835: case 0x1: {
15361 OPC_CheckPredicate, 169, 1, // 837: check predicate 169
15362 OPC_Decode, 241, 123, 142, 2, // 840: decode to SF_MM_U_U using decoder 270
15363 // 840: }
15364 3, 0, // 845: case 0x3: {
15365 OPC_CheckPredicate, 169, 1, // 847: check predicate 169
15366 OPC_Decode, 239, 123, 142, 2, // 850: decode to SF_MM_S_U using decoder 270
15367 // 850: }
15368 // 850: } // switch Inst[27:25]
15369 // 850: }
15370 1, 0, // 855: case 0x1: {
15371 OPC_SwitchField, 25, 3, // 857: switch Inst[27:25] {
15372 1, 8, // 860: case 0x1: {
15373 OPC_CheckPredicate, 169, 1, // 862: check predicate 169
15374 OPC_Decode, 240, 123, 142, 2, // 865: decode to SF_MM_U_S using decoder 270
15375 // 865: }
15376 3, 0, // 870: case 0x3: {
15377 OPC_CheckPredicate, 169, 1, // 872: check predicate 169
15378 OPC_Decode, 238, 123, 142, 2, // 875: decode to SF_MM_S_S using decoder 270
15379 // 875: }
15380 // 875: } // switch Inst[27:25]
15381 // 875: }
15382 // 875: } // switch Inst[9:7]
15383 // 875: }
15384 // 875: } // switch Inst[6:0]
15385 // 875: }
15386 1, 83, // 880: case 0x1: {
15387 OPC_SwitchField, 25, 3, // 882: switch Inst[27:25] {
15388 1, 26, // 885: case 0x1: {
15389 OPC_SwitchField, 0, 7, // 887: switch Inst[6:0] {
15390 91, 7, // 890: case 0x5b: {
15391 OPC_CheckPredicate, 170, 1, // 892: check predicate 170
15392 OPC_Decode, 146, 124, 120, // 895: decode to SF_VFWMACC_4x4x4 using decoder 120
15393 // 895: }
15394 119, 0, // 899: case 0x77: {
15395 OPC_CheckPredicate, 171, 1, // 901: check predicate 171
15396 OPC_CheckField, 7, 2, 0, // 904: check Inst[8:7] == 0x0
15397 OPC_Decode, 237, 123, 143, 2, // 908: decode to SF_MM_F_F using decoder 271
15398 // 908: }
15399 // 908: } // switch Inst[6:0]
15400 // 908: }
15401 5, 24, // 913: case 0x5: {
15402 OPC_SwitchField, 0, 10, // 915: switch Inst[9:0] {
15403 119, 8, // 918: case 0x77: {
15404 OPC_CheckPredicate, 172, 1, // 920: check predicate 172
15405 OPC_Decode, 236, 123, 142, 2, // 923: decode to SF_MM_E5M2_E5M2 using decoder 270
15406 // 923: }
15407 247, 1, 0, // 928: case 0xf7: {
15408 OPC_CheckPredicate, 172, 1, // 931: check predicate 172
15409 OPC_Decode, 235, 123, 142, 2, // 934: decode to SF_MM_E5M2_E4M3 using decoder 270
15410 // 934: }
15411 // 934: } // switch Inst[9:0]
15412 // 934: }
15413 7, 0, // 939: case 0x7: {
15414 OPC_SwitchField, 0, 10, // 941: switch Inst[9:0] {
15415 119, 8, // 944: case 0x77: {
15416 OPC_CheckPredicate, 172, 1, // 946: check predicate 172
15417 OPC_Decode, 234, 123, 142, 2, // 949: decode to SF_MM_E4M3_E5M2 using decoder 270
15418 // 949: }
15419 247, 1, 0, // 954: case 0xf7: {
15420 OPC_CheckPredicate, 172, 1, // 957: check predicate 172
15421 OPC_Decode, 233, 123, 142, 2, // 960: decode to SF_MM_E4M3_E4M3 using decoder 270
15422 // 960: }
15423 // 960: } // switch Inst[9:0]
15424 // 960: }
15425 // 960: } // switch Inst[27:25]
15426 // 960: }
15427 2, 55, // 965: case 0x2: {
15428 OPC_SwitchField, 25, 3, // 967: switch Inst[27:25] {
15429 1, 11, // 970: case 0x1: {
15430 OPC_CheckPredicate, 173, 1, // 972: check predicate 173
15431 OPC_CheckField, 0, 7, 91, // 975: check Inst[6:0] == 0x5b
15432 OPC_Decode, 156, 124, 120, // 979: decode to SF_VQMACCU_4x8x4 using decoder 120
15433 // 979: }
15434 3, 11, // 983: case 0x3: {
15435 OPC_CheckPredicate, 173, 1, // 985: check predicate 173
15436 OPC_CheckField, 0, 7, 91, // 988: check Inst[6:0] == 0x5b
15437 OPC_Decode, 158, 124, 120, // 992: decode to SF_VQMACC_4x8x4 using decoder 120
15438 // 992: }
15439 5, 11, // 996: case 0x5: {
15440 OPC_CheckPredicate, 173, 1, // 998: check predicate 173
15441 OPC_CheckField, 0, 7, 91, // 1001: check Inst[6:0] == 0x5b
15442 OPC_Decode, 154, 124, 120, // 1005: decode to SF_VQMACCUS_4x8x4 using decoder 120
15443 // 1005: }
15444 7, 0, // 1009: case 0x7: {
15445 OPC_CheckPredicate, 173, 1, // 1011: check predicate 173
15446 OPC_CheckField, 0, 7, 91, // 1014: check Inst[6:0] == 0x5b
15447 OPC_Decode, 152, 124, 120, // 1018: decode to SF_VQMACCSU_4x8x4 using decoder 120
15448 // 1018: }
15449 // 1018: } // switch Inst[27:25]
15450 // 1018: }
15451 3, 31, // 1022: case 0x3: {
15452 OPC_SwitchField, 25, 1, // 1024: switch Inst[25] {
15453 0, 12, // 1027: case 0x0: {
15454 OPC_CheckPredicate, 163, 1, // 1029: check predicate 163
15455 OPC_CheckField, 0, 7, 91, // 1032: check Inst[6:0] == 0x5b
15456 OPC_Decode, 130, 124, 136, 2, // 1036: decode to SF_VC_V_IVW using decoder 264
15457 // 1036: }
15458 1, 0, // 1041: case 0x1: {
15459 OPC_CheckPredicate, 163, 1, // 1043: check predicate 163
15460 OPC_CheckField, 0, 7, 91, // 1046: check Inst[6:0] == 0x5b
15461 OPC_Decode, 248, 123, 137, 2, // 1050: decode to SF_VC_IVW using decoder 265
15462 // 1050: }
15463 // 1050: } // switch Inst[25]
15464 // 1050: }
15465 4, 31, // 1055: case 0x4: {
15466 OPC_SwitchField, 25, 1, // 1057: switch Inst[25] {
15467 0, 12, // 1060: case 0x0: {
15468 OPC_CheckPredicate, 163, 1, // 1062: check predicate 163
15469 OPC_CheckField, 0, 7, 91, // 1065: check Inst[6:0] == 0x5b
15470 OPC_Decode, 137, 124, 138, 2, // 1069: decode to SF_VC_V_XVW using decoder 266
15471 // 1069: }
15472 1, 0, // 1074: case 0x1: {
15473 OPC_CheckPredicate, 163, 1, // 1076: check predicate 163
15474 OPC_CheckField, 0, 7, 91, // 1079: check Inst[6:0] == 0x5b
15475 OPC_Decode, 141, 124, 139, 2, // 1083: decode to SF_VC_XVW using decoder 267
15476 // 1083: }
15477 // 1083: } // switch Inst[25]
15478 // 1083: }
15479 5, 0, // 1088: case 0x5: {
15480 OPC_SwitchField, 25, 1, // 1090: switch Inst[25] {
15481 0, 16, // 1093: case 0x0: {
15482 OPC_CheckPredicate, 163, 1, // 1095: check predicate 163
15483 OPC_CheckField, 27, 1, 1, // 1098: check Inst[27] == 0x1
15484 OPC_CheckField, 0, 7, 91, // 1102: check Inst[6:0] == 0x5b
15485 OPC_Decode, 254, 123, 140, 2, // 1106: decode to SF_VC_V_FVW using decoder 268
15486 // 1106: }
15487 1, 0, // 1111: case 0x1: {
15488 OPC_CheckPredicate, 163, 1, // 1113: check predicate 163
15489 OPC_CheckField, 27, 1, 1, // 1116: check Inst[27] == 0x1
15490 OPC_CheckField, 0, 7, 91, // 1120: check Inst[6:0] == 0x5b
15491 OPC_Decode, 244, 123, 141, 2, // 1124: decode to SF_VC_FVW using decoder 269
15492 // 1124: }
15493 // 1124: } // switch Inst[25]
15494 // 1124: }
15495 // 1124: } // switch Inst[14:12]
15496 // 1124: }
15497 // 1124: } // switch Inst[31:28]
15498};
15499static const uint8_t DecoderTableXTHead32[1598] = {
15500 32, // 0: BitWidth 32
15501 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
15502 0, 235, 2, // 4: case 0x0: {
15503 OPC_SwitchField, 25, 7, // 7: switch Inst[31:25] {
15504 0, 168, 1, // 10: case 0x0: {
15505 OPC_SwitchField, 15, 10, // 13: switch Inst[24:15] {
15506 32, 11, // 16: case 0x20: {
15507 OPC_CheckPredicate, 174, 1, // 18: check predicate 174
15508 OPC_CheckField, 0, 12, 11, // 21: check Inst[11:0] == 0xb
15509 OPC_Decode, 142, 125, 14, // 25: decode to TH_DCACHE_CALL using decoder 14
15510 // 25: }
15511 64, 11, // 29: case 0x40: {
15512 OPC_CheckPredicate, 174, 1, // 31: check predicate 174
15513 OPC_CheckField, 0, 12, 11, // 34: check Inst[11:0] == 0xb
15514 OPC_Decode, 152, 125, 14, // 38: decode to TH_DCACHE_IALL using decoder 14
15515 // 38: }
15516 96, 11, // 42: case 0x60: {
15517 OPC_CheckPredicate, 174, 1, // 44: check predicate 174
15518 OPC_CheckField, 0, 12, 11, // 47: check Inst[11:0] == 0xb
15519 OPC_Decode, 143, 125, 14, // 51: decode to TH_DCACHE_CIALL using decoder 14
15520 // 51: }
15521 128, 4, 11, // 55: case 0x200: {
15522 OPC_CheckPredicate, 174, 1, // 58: check predicate 174
15523 OPC_CheckField, 0, 12, 11, // 61: check Inst[11:0] == 0xb
15524 OPC_Decode, 168, 125, 14, // 65: decode to TH_ICACHE_IALL using decoder 14
15525 // 65: }
15526 160, 4, 11, // 69: case 0x220: {
15527 OPC_CheckPredicate, 174, 1, // 72: check predicate 174
15528 OPC_CheckField, 0, 12, 11, // 75: check Inst[11:0] == 0xb
15529 OPC_Decode, 169, 125, 14, // 79: decode to TH_ICACHE_IALLS using decoder 14
15530 // 79: }
15531 160, 5, 11, // 83: case 0x2a0: {
15532 OPC_CheckPredicate, 174, 1, // 86: check predicate 174
15533 OPC_CheckField, 0, 12, 11, // 89: check Inst[11:0] == 0xb
15534 OPC_Decode, 172, 125, 14, // 93: decode to TH_L2CACHE_CALL using decoder 14
15535 // 93: }
15536 192, 5, 11, // 97: case 0x2c0: {
15537 OPC_CheckPredicate, 174, 1, // 100: check predicate 174
15538 OPC_CheckField, 0, 12, 11, // 103: check Inst[11:0] == 0xb
15539 OPC_Decode, 174, 125, 14, // 107: decode to TH_L2CACHE_IALL using decoder 14
15540 // 107: }
15541 224, 5, 11, // 111: case 0x2e0: {
15542 OPC_CheckPredicate, 174, 1, // 114: check predicate 174
15543 OPC_CheckField, 0, 12, 11, // 117: check Inst[11:0] == 0xb
15544 OPC_Decode, 173, 125, 14, // 121: decode to TH_L2CACHE_CIALL using decoder 14
15545 // 121: }
15546 128, 6, 11, // 125: case 0x300: {
15547 OPC_CheckPredicate, 175, 1, // 128: check predicate 175
15548 OPC_CheckField, 0, 12, 11, // 131: check Inst[11:0] == 0xb
15549 OPC_Decode, 237, 125, 14, // 135: decode to TH_SYNC using decoder 14
15550 // 135: }
15551 160, 6, 11, // 139: case 0x320: {
15552 OPC_CheckPredicate, 175, 1, // 142: check predicate 175
15553 OPC_CheckField, 0, 12, 11, // 145: check Inst[11:0] == 0xb
15554 OPC_Decode, 240, 125, 14, // 149: decode to TH_SYNC_S using decoder 14
15555 // 149: }
15556 192, 6, 11, // 153: case 0x340: {
15557 OPC_CheckPredicate, 175, 1, // 156: check predicate 175
15558 OPC_CheckField, 0, 12, 11, // 159: check Inst[11:0] == 0xb
15559 OPC_Decode, 238, 125, 14, // 163: decode to TH_SYNC_I using decoder 14
15560 // 163: }
15561 224, 6, 0, // 167: case 0x360: {
15562 OPC_CheckPredicate, 175, 1, // 170: check predicate 175
15563 OPC_CheckField, 0, 12, 11, // 173: check Inst[11:0] == 0xb
15564 OPC_Decode, 239, 125, 14, // 177: decode to TH_SYNC_IS using decoder 14
15565 // 177: }
15566 // 177: } // switch Inst[24:15]
15567 // 177: }
15568 1, 172, 1, // 181: case 0x1: {
15569 OPC_SwitchField, 20, 5, // 184: switch Inst[24:20] {
15570 1, 11, // 187: case 0x1: {
15571 OPC_CheckPredicate, 174, 1, // 189: check predicate 174
15572 OPC_CheckField, 0, 12, 11, // 192: check Inst[11:0] == 0xb
15573 OPC_Decode, 149, 125, 15, // 196: decode to TH_DCACHE_CSW using decoder 15
15574 // 196: }
15575 2, 11, // 200: case 0x2: {
15576 OPC_CheckPredicate, 174, 1, // 202: check predicate 174
15577 OPC_CheckField, 0, 12, 11, // 205: check Inst[11:0] == 0xb
15578 OPC_Decode, 154, 125, 15, // 209: decode to TH_DCACHE_ISW using decoder 15
15579 // 209: }
15580 3, 11, // 213: case 0x3: {
15581 OPC_CheckPredicate, 174, 1, // 215: check predicate 174
15582 OPC_CheckField, 0, 12, 11, // 218: check Inst[11:0] == 0xb
15583 OPC_Decode, 145, 125, 15, // 222: decode to TH_DCACHE_CISW using decoder 15
15584 // 222: }
15585 4, 11, // 226: case 0x4: {
15586 OPC_CheckPredicate, 174, 1, // 228: check predicate 174
15587 OPC_CheckField, 0, 12, 11, // 231: check Inst[11:0] == 0xb
15588 OPC_Decode, 151, 125, 15, // 235: decode to TH_DCACHE_CVAL1 using decoder 15
15589 // 235: }
15590 5, 11, // 239: case 0x5: {
15591 OPC_CheckPredicate, 174, 1, // 241: check predicate 174
15592 OPC_CheckField, 0, 12, 11, // 244: check Inst[11:0] == 0xb
15593 OPC_Decode, 150, 125, 15, // 248: decode to TH_DCACHE_CVA using decoder 15
15594 // 248: }
15595 6, 11, // 252: case 0x6: {
15596 OPC_CheckPredicate, 174, 1, // 254: check predicate 174
15597 OPC_CheckField, 0, 12, 11, // 257: check Inst[11:0] == 0xb
15598 OPC_Decode, 155, 125, 15, // 261: decode to TH_DCACHE_IVA using decoder 15
15599 // 261: }
15600 7, 11, // 265: case 0x7: {
15601 OPC_CheckPredicate, 174, 1, // 267: check predicate 174
15602 OPC_CheckField, 0, 12, 11, // 270: check Inst[11:0] == 0xb
15603 OPC_Decode, 146, 125, 15, // 274: decode to TH_DCACHE_CIVA using decoder 15
15604 // 274: }
15605 8, 11, // 278: case 0x8: {
15606 OPC_CheckPredicate, 174, 1, // 280: check predicate 174
15607 OPC_CheckField, 0, 12, 11, // 283: check Inst[11:0] == 0xb
15608 OPC_Decode, 148, 125, 15, // 287: decode to TH_DCACHE_CPAL1 using decoder 15
15609 // 287: }
15610 9, 11, // 291: case 0x9: {
15611 OPC_CheckPredicate, 174, 1, // 293: check predicate 174
15612 OPC_CheckField, 0, 12, 11, // 296: check Inst[11:0] == 0xb
15613 OPC_Decode, 147, 125, 15, // 300: decode to TH_DCACHE_CPA using decoder 15
15614 // 300: }
15615 10, 11, // 304: case 0xa: {
15616 OPC_CheckPredicate, 174, 1, // 306: check predicate 174
15617 OPC_CheckField, 0, 12, 11, // 309: check Inst[11:0] == 0xb
15618 OPC_Decode, 153, 125, 15, // 313: decode to TH_DCACHE_IPA using decoder 15
15619 // 313: }
15620 11, 11, // 317: case 0xb: {
15621 OPC_CheckPredicate, 174, 1, // 319: check predicate 174
15622 OPC_CheckField, 0, 12, 11, // 322: check Inst[11:0] == 0xb
15623 OPC_Decode, 144, 125, 15, // 326: decode to TH_DCACHE_CIPA using decoder 15
15624 // 326: }
15625 16, 11, // 330: case 0x10: {
15626 OPC_CheckPredicate, 174, 1, // 332: check predicate 174
15627 OPC_CheckField, 0, 12, 11, // 335: check Inst[11:0] == 0xb
15628 OPC_Decode, 171, 125, 15, // 339: decode to TH_ICACHE_IVA using decoder 15
15629 // 339: }
15630 24, 0, // 343: case 0x18: {
15631 OPC_CheckPredicate, 174, 1, // 345: check predicate 174
15632 OPC_CheckField, 0, 12, 11, // 348: check Inst[11:0] == 0xb
15633 OPC_Decode, 170, 125, 15, // 352: decode to TH_ICACHE_IPA using decoder 15
15634 // 352: }
15635 // 352: } // switch Inst[24:20]
15636 // 352: }
15637 2, 0, // 356: case 0x2: {
15638 OPC_CheckPredicate, 175, 1, // 358: check predicate 175
15639 OPC_CheckField, 0, 12, 11, // 361: check Inst[11:0] == 0xb
15640 OPC_Decode, 221, 125, 156, 1, // 365: decode to TH_SFENCE_VMAS using decoder 156
15641 // 365: }
15642 // 365: } // switch Inst[31:25]
15643 // 365: }
15644 1, 134, 2, // 370: case 0x1: {
15645 OPC_SwitchField, 27, 5, // 373: switch Inst[31:27] {
15646 0, 12, // 376: case 0x0: {
15647 OPC_CheckPredicate, 176, 1, // 378: check predicate 176
15648 OPC_CheckField, 0, 7, 11, // 381: check Inst[6:0] == 0xb
15649 OPC_Decode, 141, 125, 144, 2, // 385: decode to TH_ADDSL using decoder 272
15650 // 385: }
15651 2, 33, // 390: case 0x2: {
15652 OPC_SwitchField, 26, 1, // 392: switch Inst[26] {
15653 0, 11, // 395: case 0x0: {
15654 OPC_CheckPredicate, 177, 1, // 397: check predicate 177
15655 OPC_CheckField, 0, 7, 11, // 400: check Inst[6:0] == 0xb
15656 OPC_Decode, 227, 125, 16, // 404: decode to TH_SRRI using decoder 16
15657 // 404: }
15658 1, 0, // 408: case 0x1: {
15659 OPC_CheckPredicate, 178, 1, // 410: check predicate 178
15660 OPC_CheckField, 25, 1, 0, // 413: check Inst[25] == 0x0
15661 OPC_CheckField, 0, 7, 11, // 417: check Inst[6:0] == 0xb
15662 OPC_Decode, 228, 125, 21, // 421: decode to TH_SRRIW using decoder 21
15663 // 421: }
15664 // 421: } // switch Inst[26]
15665 // 421: }
15666 4, 55, // 425: case 0x4: {
15667 OPC_SwitchField, 25, 2, // 427: switch Inst[26:25] {
15668 0, 11, // 430: case 0x0: {
15669 OPC_CheckPredicate, 179, 1, // 432: check predicate 179
15670 OPC_CheckField, 0, 7, 11, // 435: check Inst[6:0] == 0xb
15671 OPC_Decode, 206, 125, 61, // 439: decode to TH_MULA using decoder 61
15672 // 439: }
15673 1, 11, // 443: case 0x1: {
15674 OPC_CheckPredicate, 179, 1, // 445: check predicate 179
15675 OPC_CheckField, 0, 7, 11, // 448: check Inst[6:0] == 0xb
15676 OPC_Decode, 209, 125, 61, // 452: decode to TH_MULS using decoder 61
15677 // 452: }
15678 2, 11, // 456: case 0x2: {
15679 OPC_CheckPredicate, 180, 1, // 458: check predicate 180
15680 OPC_CheckField, 0, 7, 11, // 461: check Inst[6:0] == 0xb
15681 OPC_Decode, 208, 125, 61, // 465: decode to TH_MULAW using decoder 61
15682 // 465: }
15683 3, 0, // 469: case 0x3: {
15684 OPC_CheckPredicate, 180, 1, // 471: check predicate 180
15685 OPC_CheckField, 0, 7, 11, // 474: check Inst[6:0] == 0xb
15686 OPC_Decode, 211, 125, 61, // 478: decode to TH_MULSW using decoder 61
15687 // 478: }
15688 // 478: } // switch Inst[26:25]
15689 // 478: }
15690 5, 29, // 482: case 0x5: {
15691 OPC_SwitchField, 25, 2, // 484: switch Inst[26:25] {
15692 0, 11, // 487: case 0x0: {
15693 OPC_CheckPredicate, 179, 1, // 489: check predicate 179
15694 OPC_CheckField, 0, 7, 11, // 492: check Inst[6:0] == 0xb
15695 OPC_Decode, 207, 125, 61, // 496: decode to TH_MULAH using decoder 61
15696 // 496: }
15697 1, 0, // 500: case 0x1: {
15698 OPC_CheckPredicate, 179, 1, // 502: check predicate 179
15699 OPC_CheckField, 0, 7, 11, // 505: check Inst[6:0] == 0xb
15700 OPC_Decode, 210, 125, 61, // 509: decode to TH_MULSH using decoder 61
15701 // 509: }
15702 // 509: } // switch Inst[26:25]
15703 // 509: }
15704 8, 29, // 513: case 0x8: {
15705 OPC_SwitchField, 25, 2, // 515: switch Inst[26:25] {
15706 0, 11, // 518: case 0x0: {
15707 OPC_CheckPredicate, 181, 1, // 520: check predicate 181
15708 OPC_CheckField, 0, 7, 11, // 523: check Inst[6:0] == 0xb
15709 OPC_Decode, 212, 125, 61, // 527: decode to TH_MVEQZ using decoder 61
15710 // 527: }
15711 1, 0, // 531: case 0x1: {
15712 OPC_CheckPredicate, 181, 1, // 533: check predicate 181
15713 OPC_CheckField, 0, 7, 11, // 536: check Inst[6:0] == 0xb
15714 OPC_Decode, 213, 125, 61, // 540: decode to TH_MVNEZ using decoder 61
15715 // 540: }
15716 // 540: } // switch Inst[26:25]
15717 // 540: }
15718 16, 55, // 544: case 0x10: {
15719 OPC_SwitchField, 20, 7, // 546: switch Inst[26:20] {
15720 0, 11, // 549: case 0x0: {
15721 OPC_CheckPredicate, 177, 1, // 551: check predicate 177
15722 OPC_CheckField, 0, 7, 11, // 554: check Inst[6:0] == 0xb
15723 OPC_Decode, 242, 125, 17, // 558: decode to TH_TSTNBZ using decoder 17
15724 // 558: }
15725 32, 11, // 562: case 0x20: {
15726 OPC_CheckPredicate, 177, 1, // 564: check predicate 177
15727 OPC_CheckField, 0, 7, 11, // 567: check Inst[6:0] == 0xb
15728 OPC_Decode, 214, 125, 17, // 571: decode to TH_REV using decoder 17
15729 // 571: }
15730 64, 11, // 575: case 0x40: {
15731 OPC_CheckPredicate, 177, 1, // 577: check predicate 177
15732 OPC_CheckField, 0, 7, 11, // 580: check Inst[6:0] == 0xb
15733 OPC_Decode, 158, 125, 17, // 584: decode to TH_FF0 using decoder 17
15734 // 584: }
15735 96, 0, // 588: case 0x60: {
15736 OPC_CheckPredicate, 177, 1, // 590: check predicate 177
15737 OPC_CheckField, 0, 7, 11, // 593: check Inst[6:0] == 0xb
15738 OPC_Decode, 159, 125, 17, // 597: decode to TH_FF1 using decoder 17
15739 // 597: }
15740 // 597: } // switch Inst[26:20]
15741 // 597: }
15742 17, 15, // 601: case 0x11: {
15743 OPC_CheckPredicate, 182, 1, // 603: check predicate 182
15744 OPC_CheckField, 26, 1, 0, // 606: check Inst[26] == 0x0
15745 OPC_CheckField, 0, 7, 11, // 610: check Inst[6:0] == 0xb
15746 OPC_Decode, 241, 125, 16, // 614: decode to TH_TST using decoder 16
15747 // 614: }
15748 18, 0, // 618: case 0x12: {
15749 OPC_CheckPredicate, 178, 1, // 620: check predicate 178
15750 OPC_CheckField, 20, 7, 0, // 623: check Inst[26:20] == 0x0
15751 OPC_CheckField, 0, 7, 11, // 627: check Inst[6:0] == 0xb
15752 OPC_Decode, 215, 125, 17, // 631: decode to TH_REVW using decoder 17
15753 // 631: }
15754 // 631: } // switch Inst[31:27]
15755 // 631: }
15756 2, 12, // 635: case 0x2: {
15757 OPC_CheckPredicate, 177, 1, // 637: check predicate 177
15758 OPC_CheckField, 0, 7, 11, // 640: check Inst[6:0] == 0xb
15759 OPC_Decode, 156, 125, 211, 1, // 644: decode to TH_EXT using decoder 211
15760 // 644: }
15761 3, 12, // 649: case 0x3: {
15762 OPC_CheckPredicate, 177, 1, // 651: check predicate 177
15763 OPC_CheckField, 0, 7, 11, // 654: check Inst[6:0] == 0xb
15764 OPC_Decode, 157, 125, 211, 1, // 658: decode to TH_EXTU using decoder 211
15765 // 658: }
15766 4, 181, 3, // 663: case 0x4: {
15767 OPC_SwitchField, 27, 5, // 666: switch Inst[31:27] {
15768 0, 12, // 669: case 0x0: {
15769 OPC_CheckPredicate, 183, 1, // 671: check predicate 183
15770 OPC_CheckField, 0, 7, 11, // 674: check Inst[6:0] == 0xb
15771 OPC_Decode, 186, 125, 144, 2, // 678: decode to TH_LRB using decoder 272
15772 // 678: }
15773 1, 12, // 683: case 0x1: {
15774 OPC_CheckPredicate, 183, 1, // 685: check predicate 183
15775 OPC_CheckField, 0, 7, 11, // 688: check Inst[6:0] == 0xb
15776 OPC_Decode, 176, 125, 145, 2, // 692: decode to TH_LBIB using decoder 273
15777 // 692: }
15778 2, 12, // 697: case 0x2: {
15779 OPC_CheckPredicate, 183, 1, // 699: check predicate 183
15780 OPC_CheckField, 0, 7, 11, // 702: check Inst[6:0] == 0xb
15781 OPC_Decode, 193, 125, 144, 2, // 706: decode to TH_LURB using decoder 272
15782 // 706: }
15783 3, 12, // 711: case 0x3: {
15784 OPC_CheckPredicate, 183, 1, // 713: check predicate 183
15785 OPC_CheckField, 0, 7, 11, // 716: check Inst[6:0] == 0xb
15786 OPC_Decode, 175, 125, 145, 2, // 720: decode to TH_LBIA using decoder 273
15787 // 720: }
15788 4, 12, // 725: case 0x4: {
15789 OPC_CheckPredicate, 183, 1, // 727: check predicate 183
15790 OPC_CheckField, 0, 7, 11, // 730: check Inst[6:0] == 0xb
15791 OPC_Decode, 189, 125, 144, 2, // 734: decode to TH_LRH using decoder 272
15792 // 734: }
15793 5, 12, // 739: case 0x5: {
15794 OPC_CheckPredicate, 183, 1, // 741: check predicate 183
15795 OPC_CheckField, 0, 7, 11, // 744: check Inst[6:0] == 0xb
15796 OPC_Decode, 183, 125, 145, 2, // 748: decode to TH_LHIB using decoder 273
15797 // 748: }
15798 6, 12, // 753: case 0x6: {
15799 OPC_CheckPredicate, 183, 1, // 755: check predicate 183
15800 OPC_CheckField, 0, 7, 11, // 758: check Inst[6:0] == 0xb
15801 OPC_Decode, 196, 125, 144, 2, // 762: decode to TH_LURH using decoder 272
15802 // 762: }
15803 7, 12, // 767: case 0x7: {
15804 OPC_CheckPredicate, 183, 1, // 769: check predicate 183
15805 OPC_CheckField, 0, 7, 11, // 772: check Inst[6:0] == 0xb
15806 OPC_Decode, 182, 125, 145, 2, // 776: decode to TH_LHIA using decoder 273
15807 // 776: }
15808 8, 12, // 781: case 0x8: {
15809 OPC_CheckPredicate, 183, 1, // 783: check predicate 183
15810 OPC_CheckField, 0, 7, 11, // 786: check Inst[6:0] == 0xb
15811 OPC_Decode, 191, 125, 144, 2, // 790: decode to TH_LRW using decoder 272
15812 // 790: }
15813 9, 12, // 795: case 0x9: {
15814 OPC_CheckPredicate, 183, 1, // 797: check predicate 183
15815 OPC_CheckField, 0, 7, 11, // 800: check Inst[6:0] == 0xb
15816 OPC_Decode, 202, 125, 145, 2, // 804: decode to TH_LWIB using decoder 273
15817 // 804: }
15818 10, 12, // 809: case 0xa: {
15819 OPC_CheckPredicate, 183, 1, // 811: check predicate 183
15820 OPC_CheckField, 0, 7, 11, // 814: check Inst[6:0] == 0xb
15821 OPC_Decode, 198, 125, 144, 2, // 818: decode to TH_LURW using decoder 272
15822 // 818: }
15823 11, 12, // 823: case 0xb: {
15824 OPC_CheckPredicate, 183, 1, // 825: check predicate 183
15825 OPC_CheckField, 0, 7, 11, // 828: check Inst[6:0] == 0xb
15826 OPC_Decode, 201, 125, 145, 2, // 832: decode to TH_LWIA using decoder 273
15827 // 832: }
15828 12, 12, // 837: case 0xc: {
15829 OPC_CheckPredicate, 184, 1, // 839: check predicate 184
15830 OPC_CheckField, 0, 7, 11, // 842: check Inst[6:0] == 0xb
15831 OPC_Decode, 188, 125, 144, 2, // 846: decode to TH_LRD using decoder 272
15832 // 846: }
15833 13, 12, // 851: case 0xd: {
15834 OPC_CheckPredicate, 184, 1, // 853: check predicate 184
15835 OPC_CheckField, 0, 7, 11, // 856: check Inst[6:0] == 0xb
15836 OPC_Decode, 181, 125, 145, 2, // 860: decode to TH_LDIB using decoder 273
15837 // 860: }
15838 14, 12, // 865: case 0xe: {
15839 OPC_CheckPredicate, 184, 1, // 867: check predicate 184
15840 OPC_CheckField, 0, 7, 11, // 870: check Inst[6:0] == 0xb
15841 OPC_Decode, 195, 125, 144, 2, // 874: decode to TH_LURD using decoder 272
15842 // 874: }
15843 15, 12, // 879: case 0xf: {
15844 OPC_CheckPredicate, 184, 1, // 881: check predicate 184
15845 OPC_CheckField, 0, 7, 11, // 884: check Inst[6:0] == 0xb
15846 OPC_Decode, 180, 125, 145, 2, // 888: decode to TH_LDIA using decoder 273
15847 // 888: }
15848 16, 12, // 893: case 0x10: {
15849 OPC_CheckPredicate, 183, 1, // 895: check predicate 183
15850 OPC_CheckField, 0, 7, 11, // 898: check Inst[6:0] == 0xb
15851 OPC_Decode, 187, 125, 144, 2, // 902: decode to TH_LRBU using decoder 272
15852 // 902: }
15853 17, 12, // 907: case 0x11: {
15854 OPC_CheckPredicate, 183, 1, // 909: check predicate 183
15855 OPC_CheckField, 0, 7, 11, // 912: check Inst[6:0] == 0xb
15856 OPC_Decode, 178, 125, 145, 2, // 916: decode to TH_LBUIB using decoder 273
15857 // 916: }
15858 18, 12, // 921: case 0x12: {
15859 OPC_CheckPredicate, 183, 1, // 923: check predicate 183
15860 OPC_CheckField, 0, 7, 11, // 926: check Inst[6:0] == 0xb
15861 OPC_Decode, 194, 125, 144, 2, // 930: decode to TH_LURBU using decoder 272
15862 // 930: }
15863 19, 12, // 935: case 0x13: {
15864 OPC_CheckPredicate, 183, 1, // 937: check predicate 183
15865 OPC_CheckField, 0, 7, 11, // 940: check Inst[6:0] == 0xb
15866 OPC_Decode, 177, 125, 145, 2, // 944: decode to TH_LBUIA using decoder 273
15867 // 944: }
15868 20, 12, // 949: case 0x14: {
15869 OPC_CheckPredicate, 183, 1, // 951: check predicate 183
15870 OPC_CheckField, 0, 7, 11, // 954: check Inst[6:0] == 0xb
15871 OPC_Decode, 190, 125, 144, 2, // 958: decode to TH_LRHU using decoder 272
15872 // 958: }
15873 21, 12, // 963: case 0x15: {
15874 OPC_CheckPredicate, 183, 1, // 965: check predicate 183
15875 OPC_CheckField, 0, 7, 11, // 968: check Inst[6:0] == 0xb
15876 OPC_Decode, 185, 125, 145, 2, // 972: decode to TH_LHUIB using decoder 273
15877 // 972: }
15878 22, 12, // 977: case 0x16: {
15879 OPC_CheckPredicate, 183, 1, // 979: check predicate 183
15880 OPC_CheckField, 0, 7, 11, // 982: check Inst[6:0] == 0xb
15881 OPC_Decode, 197, 125, 144, 2, // 986: decode to TH_LURHU using decoder 272
15882 // 986: }
15883 23, 12, // 991: case 0x17: {
15884 OPC_CheckPredicate, 183, 1, // 993: check predicate 183
15885 OPC_CheckField, 0, 7, 11, // 996: check Inst[6:0] == 0xb
15886 OPC_Decode, 184, 125, 145, 2, // 1000: decode to TH_LHUIA using decoder 273
15887 // 1000: }
15888 24, 12, // 1005: case 0x18: {
15889 OPC_CheckPredicate, 184, 1, // 1007: check predicate 184
15890 OPC_CheckField, 0, 7, 11, // 1010: check Inst[6:0] == 0xb
15891 OPC_Decode, 192, 125, 144, 2, // 1014: decode to TH_LRWU using decoder 272
15892 // 1014: }
15893 25, 12, // 1019: case 0x19: {
15894 OPC_CheckPredicate, 184, 1, // 1021: check predicate 184
15895 OPC_CheckField, 0, 7, 11, // 1024: check Inst[6:0] == 0xb
15896 OPC_Decode, 205, 125, 145, 2, // 1028: decode to TH_LWUIB using decoder 273
15897 // 1028: }
15898 26, 12, // 1033: case 0x1a: {
15899 OPC_CheckPredicate, 184, 1, // 1035: check predicate 184
15900 OPC_CheckField, 0, 7, 11, // 1038: check Inst[6:0] == 0xb
15901 OPC_Decode, 199, 125, 144, 2, // 1042: decode to TH_LURWU using decoder 272
15902 // 1042: }
15903 27, 12, // 1047: case 0x1b: {
15904 OPC_CheckPredicate, 184, 1, // 1049: check predicate 184
15905 OPC_CheckField, 0, 7, 11, // 1052: check Inst[6:0] == 0xb
15906 OPC_Decode, 204, 125, 145, 2, // 1056: decode to TH_LWUIA using decoder 273
15907 // 1056: }
15908 28, 12, // 1061: case 0x1c: {
15909 OPC_CheckPredicate, 185, 1, // 1063: check predicate 185
15910 OPC_CheckField, 0, 7, 11, // 1066: check Inst[6:0] == 0xb
15911 OPC_Decode, 200, 125, 146, 2, // 1070: decode to TH_LWD using decoder 274
15912 // 1070: }
15913 30, 12, // 1075: case 0x1e: {
15914 OPC_CheckPredicate, 185, 1, // 1077: check predicate 185
15915 OPC_CheckField, 0, 7, 11, // 1080: check Inst[6:0] == 0xb
15916 OPC_Decode, 203, 125, 146, 2, // 1084: decode to TH_LWUD using decoder 274
15917 // 1084: }
15918 31, 0, // 1089: case 0x1f: {
15919 OPC_CheckPredicate, 186, 1, // 1091: check predicate 186
15920 OPC_CheckField, 0, 7, 11, // 1094: check Inst[6:0] == 0xb
15921 OPC_Decode, 179, 125, 147, 2, // 1098: decode to TH_LDD using decoder 275
15922 // 1098: }
15923 // 1098: } // switch Inst[31:27]
15924 // 1098: }
15925 5, 255, 1, // 1103: case 0x5: {
15926 OPC_SwitchField, 27, 5, // 1106: switch Inst[31:27] {
15927 0, 12, // 1109: case 0x0: {
15928 OPC_CheckPredicate, 183, 1, // 1111: check predicate 183
15929 OPC_CheckField, 0, 7, 11, // 1114: check Inst[6:0] == 0xb
15930 OPC_Decode, 224, 125, 144, 2, // 1118: decode to TH_SRB using decoder 272
15931 // 1118: }
15932 1, 12, // 1123: case 0x1: {
15933 OPC_CheckPredicate, 183, 1, // 1125: check predicate 183
15934 OPC_CheckField, 0, 7, 11, // 1128: check Inst[6:0] == 0xb
15935 OPC_Decode, 217, 125, 148, 2, // 1132: decode to TH_SBIB using decoder 276
15936 // 1132: }
15937 2, 12, // 1137: case 0x2: {
15938 OPC_CheckPredicate, 183, 1, // 1139: check predicate 183
15939 OPC_CheckField, 0, 7, 11, // 1142: check Inst[6:0] == 0xb
15940 OPC_Decode, 230, 125, 144, 2, // 1146: decode to TH_SURB using decoder 272
15941 // 1146: }
15942 3, 12, // 1151: case 0x3: {
15943 OPC_CheckPredicate, 183, 1, // 1153: check predicate 183
15944 OPC_CheckField, 0, 7, 11, // 1156: check Inst[6:0] == 0xb
15945 OPC_Decode, 216, 125, 148, 2, // 1160: decode to TH_SBIA using decoder 276
15946 // 1160: }
15947 4, 12, // 1165: case 0x4: {
15948 OPC_CheckPredicate, 183, 1, // 1167: check predicate 183
15949 OPC_CheckField, 0, 7, 11, // 1170: check Inst[6:0] == 0xb
15950 OPC_Decode, 226, 125, 144, 2, // 1174: decode to TH_SRH using decoder 272
15951 // 1174: }
15952 5, 12, // 1179: case 0x5: {
15953 OPC_CheckPredicate, 183, 1, // 1181: check predicate 183
15954 OPC_CheckField, 0, 7, 11, // 1184: check Inst[6:0] == 0xb
15955 OPC_Decode, 223, 125, 148, 2, // 1188: decode to TH_SHIB using decoder 276
15956 // 1188: }
15957 6, 12, // 1193: case 0x6: {
15958 OPC_CheckPredicate, 183, 1, // 1195: check predicate 183
15959 OPC_CheckField, 0, 7, 11, // 1198: check Inst[6:0] == 0xb
15960 OPC_Decode, 232, 125, 144, 2, // 1202: decode to TH_SURH using decoder 272
15961 // 1202: }
15962 7, 12, // 1207: case 0x7: {
15963 OPC_CheckPredicate, 183, 1, // 1209: check predicate 183
15964 OPC_CheckField, 0, 7, 11, // 1212: check Inst[6:0] == 0xb
15965 OPC_Decode, 222, 125, 148, 2, // 1216: decode to TH_SHIA using decoder 276
15966 // 1216: }
15967 8, 12, // 1221: case 0x8: {
15968 OPC_CheckPredicate, 183, 1, // 1223: check predicate 183
15969 OPC_CheckField, 0, 7, 11, // 1226: check Inst[6:0] == 0xb
15970 OPC_Decode, 229, 125, 144, 2, // 1230: decode to TH_SRW using decoder 272
15971 // 1230: }
15972 9, 12, // 1235: case 0x9: {
15973 OPC_CheckPredicate, 183, 1, // 1237: check predicate 183
15974 OPC_CheckField, 0, 7, 11, // 1240: check Inst[6:0] == 0xb
15975 OPC_Decode, 236, 125, 148, 2, // 1244: decode to TH_SWIB using decoder 276
15976 // 1244: }
15977 10, 12, // 1249: case 0xa: {
15978 OPC_CheckPredicate, 183, 1, // 1251: check predicate 183
15979 OPC_CheckField, 0, 7, 11, // 1254: check Inst[6:0] == 0xb
15980 OPC_Decode, 233, 125, 144, 2, // 1258: decode to TH_SURW using decoder 272
15981 // 1258: }
15982 11, 12, // 1263: case 0xb: {
15983 OPC_CheckPredicate, 183, 1, // 1265: check predicate 183
15984 OPC_CheckField, 0, 7, 11, // 1268: check Inst[6:0] == 0xb
15985 OPC_Decode, 235, 125, 148, 2, // 1272: decode to TH_SWIA using decoder 276
15986 // 1272: }
15987 12, 12, // 1277: case 0xc: {
15988 OPC_CheckPredicate, 184, 1, // 1279: check predicate 184
15989 OPC_CheckField, 0, 7, 11, // 1282: check Inst[6:0] == 0xb
15990 OPC_Decode, 225, 125, 144, 2, // 1286: decode to TH_SRD using decoder 272
15991 // 1286: }
15992 13, 12, // 1291: case 0xd: {
15993 OPC_CheckPredicate, 184, 1, // 1293: check predicate 184
15994 OPC_CheckField, 0, 7, 11, // 1296: check Inst[6:0] == 0xb
15995 OPC_Decode, 220, 125, 148, 2, // 1300: decode to TH_SDIB using decoder 276
15996 // 1300: }
15997 14, 12, // 1305: case 0xe: {
15998 OPC_CheckPredicate, 184, 1, // 1307: check predicate 184
15999 OPC_CheckField, 0, 7, 11, // 1310: check Inst[6:0] == 0xb
16000 OPC_Decode, 231, 125, 144, 2, // 1314: decode to TH_SURD using decoder 272
16001 // 1314: }
16002 15, 12, // 1319: case 0xf: {
16003 OPC_CheckPredicate, 184, 1, // 1321: check predicate 184
16004 OPC_CheckField, 0, 7, 11, // 1324: check Inst[6:0] == 0xb
16005 OPC_Decode, 219, 125, 148, 2, // 1328: decode to TH_SDIA using decoder 276
16006 // 1328: }
16007 28, 12, // 1333: case 0x1c: {
16008 OPC_CheckPredicate, 185, 1, // 1335: check predicate 185
16009 OPC_CheckField, 0, 7, 11, // 1338: check Inst[6:0] == 0xb
16010 OPC_Decode, 234, 125, 146, 2, // 1342: decode to TH_SWD using decoder 274
16011 // 1342: }
16012 31, 0, // 1347: case 0x1f: {
16013 OPC_CheckPredicate, 186, 1, // 1349: check predicate 186
16014 OPC_CheckField, 0, 7, 11, // 1352: check Inst[6:0] == 0xb
16015 OPC_Decode, 218, 125, 147, 2, // 1356: decode to TH_SDD using decoder 275
16016 // 1356: }
16017 // 1356: } // switch Inst[31:27]
16018 // 1356: }
16019 6, 173, 1, // 1361: case 0x6: {
16020 OPC_SwitchField, 27, 5, // 1364: switch Inst[31:27] {
16021 8, 12, // 1367: case 0x8: {
16022 OPC_CheckPredicate, 187, 1, // 1369: check predicate 187
16023 OPC_CheckField, 0, 7, 11, // 1372: check Inst[6:0] == 0xb
16024 OPC_Decode, 161, 125, 149, 2, // 1376: decode to TH_FLRW using decoder 277
16025 // 1376: }
16026 10, 12, // 1381: case 0xa: {
16027 OPC_CheckPredicate, 188, 1, // 1383: check predicate 188
16028 OPC_CheckField, 0, 7, 11, // 1386: check Inst[6:0] == 0xb
16029 OPC_Decode, 163, 125, 149, 2, // 1390: decode to TH_FLURW using decoder 277
16030 // 1390: }
16031 12, 12, // 1395: case 0xc: {
16032 OPC_CheckPredicate, 189, 1, // 1397: check predicate 189
16033 OPC_CheckField, 0, 7, 11, // 1400: check Inst[6:0] == 0xb
16034 OPC_Decode, 160, 125, 150, 2, // 1404: decode to TH_FLRD using decoder 278
16035 // 1404: }
16036 14, 12, // 1409: case 0xe: {
16037 OPC_CheckPredicate, 190, 1, // 1411: check predicate 190
16038 OPC_CheckField, 0, 7, 11, // 1414: check Inst[6:0] == 0xb
16039 OPC_Decode, 162, 125, 150, 2, // 1418: decode to TH_FLURD using decoder 278
16040 // 1418: }
16041 16, 30, // 1423: case 0x10: {
16042 OPC_SwitchField, 26, 1, // 1425: switch Inst[26] {
16043 0, 11, // 1428: case 0x0: {
16044 OPC_CheckPredicate, 191, 1, // 1430: check predicate 191
16045 OPC_CheckField, 0, 7, 11, // 1433: check Inst[6:0] == 0xb
16046 OPC_Decode, 248, 125, 125, // 1437: decode to TH_VMAQA_VV using decoder 125
16047 // 1437: }
16048 1, 0, // 1441: case 0x1: {
16049 OPC_CheckPredicate, 191, 1, // 1443: check predicate 191
16050 OPC_CheckField, 0, 7, 11, // 1446: check Inst[6:0] == 0xb
16051 OPC_Decode, 249, 125, 149, 1, // 1450: decode to TH_VMAQA_VX using decoder 149
16052 // 1450: }
16053 // 1450: } // switch Inst[26]
16054 // 1450: }
16055 17, 30, // 1455: case 0x11: {
16056 OPC_SwitchField, 26, 1, // 1457: switch Inst[26] {
16057 0, 11, // 1460: case 0x0: {
16058 OPC_CheckPredicate, 191, 1, // 1462: check predicate 191
16059 OPC_CheckField, 0, 7, 11, // 1465: check Inst[6:0] == 0xb
16060 OPC_Decode, 246, 125, 125, // 1469: decode to TH_VMAQAU_VV using decoder 125
16061 // 1469: }
16062 1, 0, // 1473: case 0x1: {
16063 OPC_CheckPredicate, 191, 1, // 1475: check predicate 191
16064 OPC_CheckField, 0, 7, 11, // 1478: check Inst[6:0] == 0xb
16065 OPC_Decode, 247, 125, 149, 1, // 1482: decode to TH_VMAQAU_VX using decoder 149
16066 // 1482: }
16067 // 1482: } // switch Inst[26]
16068 // 1482: }
16069 18, 30, // 1487: case 0x12: {
16070 OPC_SwitchField, 26, 1, // 1489: switch Inst[26] {
16071 0, 11, // 1492: case 0x0: {
16072 OPC_CheckPredicate, 191, 1, // 1494: check predicate 191
16073 OPC_CheckField, 0, 7, 11, // 1497: check Inst[6:0] == 0xb
16074 OPC_Decode, 243, 125, 125, // 1501: decode to TH_VMAQASU_VV using decoder 125
16075 // 1501: }
16076 1, 0, // 1505: case 0x1: {
16077 OPC_CheckPredicate, 191, 1, // 1507: check predicate 191
16078 OPC_CheckField, 0, 7, 11, // 1510: check Inst[6:0] == 0xb
16079 OPC_Decode, 244, 125, 149, 1, // 1514: decode to TH_VMAQASU_VX using decoder 149
16080 // 1514: }
16081 // 1514: } // switch Inst[26]
16082 // 1514: }
16083 19, 0, // 1519: case 0x13: {
16084 OPC_CheckPredicate, 191, 1, // 1521: check predicate 191
16085 OPC_CheckField, 26, 1, 1, // 1524: check Inst[26] == 0x1
16086 OPC_CheckField, 0, 7, 11, // 1528: check Inst[6:0] == 0xb
16087 OPC_Decode, 245, 125, 149, 1, // 1532: decode to TH_VMAQAUS_VX using decoder 149
16088 // 1532: }
16089 // 1532: } // switch Inst[31:27]
16090 // 1532: }
16091 7, 0, // 1537: case 0x7: {
16092 OPC_SwitchField, 27, 5, // 1539: switch Inst[31:27] {
16093 8, 12, // 1542: case 0x8: {
16094 OPC_CheckPredicate, 187, 1, // 1544: check predicate 187
16095 OPC_CheckField, 0, 7, 11, // 1547: check Inst[6:0] == 0xb
16096 OPC_Decode, 165, 125, 149, 2, // 1551: decode to TH_FSRW using decoder 277
16097 // 1551: }
16098 10, 12, // 1556: case 0xa: {
16099 OPC_CheckPredicate, 188, 1, // 1558: check predicate 188
16100 OPC_CheckField, 0, 7, 11, // 1561: check Inst[6:0] == 0xb
16101 OPC_Decode, 167, 125, 149, 2, // 1565: decode to TH_FSURW using decoder 277
16102 // 1565: }
16103 12, 12, // 1570: case 0xc: {
16104 OPC_CheckPredicate, 189, 1, // 1572: check predicate 189
16105 OPC_CheckField, 0, 7, 11, // 1575: check Inst[6:0] == 0xb
16106 OPC_Decode, 164, 125, 150, 2, // 1579: decode to TH_FSRD using decoder 278
16107 // 1579: }
16108 14, 0, // 1584: case 0xe: {
16109 OPC_CheckPredicate, 190, 1, // 1586: check predicate 190
16110 OPC_CheckField, 0, 7, 11, // 1589: check Inst[6:0] == 0xb
16111 OPC_Decode, 166, 125, 150, 2, // 1593: decode to TH_FSURD using decoder 278
16112 // 1593: }
16113 // 1593: } // switch Inst[31:27]
16114 // 1593: }
16115 // 1593: } // switch Inst[14:12]
16116};
16117static const uint8_t DecoderTableXqci32[1203] = {
16118 32, // 0: BitWidth 32
16119 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16120 11, 143, 4, // 4: case 0xb: {
16121 OPC_SwitchField, 12, 3, // 7: switch Inst[14:12] {
16122 0, 22, // 10: case 0x0: {
16123 OPC_SwitchField, 31, 1, // 12: switch Inst[31] {
16124 0, 8, // 15: case 0x0: {
16125 OPC_CheckPredicate, 192, 1, // 17: check predicate 192
16126 OPC_Decode, 179, 123, 151, 2, // 20: decode to QC_WRAPI using decoder 279
16127 // 20: }
16128 1, 0, // 25: case 0x1: {
16129 OPC_CheckPredicate, 13, // 27: check predicate 13
16130 OPC_Decode, 241, 122, 152, 2, // 29: decode to QC_INSBRI using decoder 280
16131 // 29: }
16132 // 29: } // switch Inst[31]
16133 // 29: }
16134 1, 30, // 34: case 0x1: {
16135 OPC_SwitchField, 30, 2, // 36: switch Inst[31:30] {
16136 0, 7, // 39: case 0x0: {
16137 OPC_CheckPredicate, 13, // 41: check predicate 13
16138 OPC_Decode, 237, 122, 153, 2, // 43: decode to QC_INSBI using decoder 281
16139 // 43: }
16140 1, 7, // 48: case 0x1: {
16141 OPC_CheckPredicate, 13, // 50: check predicate 13
16142 OPC_Decode, 234, 122, 154, 2, // 52: decode to QC_INSB using decoder 282
16143 // 52: }
16144 2, 0, // 57: case 0x2: {
16145 OPC_CheckPredicate, 13, // 59: check predicate 13
16146 OPC_Decode, 235, 122, 154, 2, // 61: decode to QC_INSBH using decoder 282
16147 // 61: }
16148 // 61: } // switch Inst[31:30]
16149 // 61: }
16150 2, 39, // 66: case 0x2: {
16151 OPC_SwitchField, 30, 2, // 68: switch Inst[31:30] {
16152 0, 7, // 71: case 0x0: {
16153 OPC_CheckPredicate, 13, // 73: check predicate 13
16154 OPC_Decode, 208, 122, 155, 2, // 75: decode to QC_EXTU using decoder 283
16155 // 75: }
16156 1, 7, // 80: case 0x1: {
16157 OPC_CheckPredicate, 13, // 82: check predicate 13
16158 OPC_Decode, 199, 122, 155, 2, // 84: decode to QC_EXT using decoder 283
16159 // 84: }
16160 2, 7, // 89: case 0x2: {
16161 OPC_CheckPredicate, 13, // 91: check predicate 13
16162 OPC_Decode, 204, 122, 156, 2, // 93: decode to QC_EXTDU using decoder 284
16163 // 93: }
16164 3, 0, // 98: case 0x3: {
16165 OPC_CheckPredicate, 13, // 100: check predicate 13
16166 OPC_Decode, 200, 122, 156, 2, // 102: decode to QC_EXTD using decoder 284
16167 // 102: }
16168 // 102: } // switch Inst[31:30]
16169 // 102: }
16170 3, 183, 2, // 107: case 0x3: {
16171 OPC_SwitchField, 30, 2, // 110: switch Inst[31:30] {
16172 0, 168, 2, // 113: case 0x0: {
16173 OPC_SwitchField, 25, 5, // 116: switch Inst[29:25] {
16174 0, 20, // 119: case 0x0: {
16175 OPC_Scope, 11, // 121: try {
16176 OPC_CheckField, 20, 5, 0, // 123: check Inst[24:20] == 0x0
16177 OPC_CheckPredicate, 13, // 127: check predicate 13
16178 OPC_Decode, 172, 122, 157, 2, // 129: decode to QC_COMPRESS2 using decoder 285
16179 // 129: } else try {
16180 OPC_CheckPredicate, 13, // 134: check predicate 13
16181 OPC_Decode, 240, 122, 158, 2, // 136: decode to QC_INSBR using decoder 286
16182 // 136: }
16183 // 136: }
16184 1, 20, // 141: case 0x1: {
16185 OPC_Scope, 11, // 143: try {
16186 OPC_CheckField, 20, 5, 0, // 145: check Inst[24:20] == 0x0
16187 OPC_CheckPredicate, 13, // 149: check predicate 13
16188 OPC_Decode, 173, 122, 157, 2, // 151: decode to QC_COMPRESS3 using decoder 285
16189 // 151: } else try {
16190 OPC_CheckPredicate, 13, // 156: check predicate 13
16191 OPC_Decode, 236, 122, 158, 2, // 158: decode to QC_INSBHR using decoder 286
16192 // 158: }
16193 // 158: }
16194 2, 20, // 163: case 0x2: {
16195 OPC_Scope, 11, // 165: try {
16196 OPC_CheckField, 20, 5, 0, // 167: check Inst[24:20] == 0x0
16197 OPC_CheckPredicate, 13, // 171: check predicate 13
16198 OPC_Decode, 197, 122, 157, 2, // 173: decode to QC_EXPAND2 using decoder 285
16199 // 173: } else try {
16200 OPC_CheckPredicate, 13, // 178: check predicate 13
16201 OPC_Decode, 238, 122, 158, 2, // 180: decode to QC_INSBPR using decoder 286
16202 // 180: }
16203 // 180: }
16204 3, 20, // 185: case 0x3: {
16205 OPC_Scope, 11, // 187: try {
16206 OPC_CheckField, 20, 5, 0, // 189: check Inst[24:20] == 0x0
16207 OPC_CheckPredicate, 13, // 193: check predicate 13
16208 OPC_Decode, 198, 122, 157, 2, // 195: decode to QC_EXPAND3 using decoder 285
16209 // 195: } else try {
16210 OPC_CheckPredicate, 13, // 200: check predicate 13
16211 OPC_Decode, 239, 122, 158, 2, // 202: decode to QC_INSBPRH using decoder 286
16212 // 202: }
16213 // 202: }
16214 4, 20, // 207: case 0x4: {
16215 OPC_Scope, 11, // 209: try {
16216 OPC_CheckField, 20, 5, 0, // 211: check Inst[24:20] == 0x0
16217 OPC_CheckPredicate, 13, // 215: check predicate 13
16218 OPC_Decode, 161, 122, 157, 2, // 217: decode to QC_CLO using decoder 285
16219 // 217: } else try {
16220 OPC_CheckPredicate, 13, // 222: check predicate 13
16221 OPC_Decode, 207, 122, 159, 2, // 224: decode to QC_EXTDUR using decoder 287
16222 // 224: }
16223 // 224: }
16224 5, 20, // 229: case 0x5: {
16225 OPC_Scope, 11, // 231: try {
16226 OPC_CheckField, 20, 5, 0, // 233: check Inst[24:20] == 0x0
16227 OPC_CheckPredicate, 13, // 237: check predicate 13
16228 OPC_Decode, 176, 122, 157, 2, // 239: decode to QC_CTO using decoder 285
16229 // 239: } else try {
16230 OPC_CheckPredicate, 13, // 244: check predicate 13
16231 OPC_Decode, 203, 122, 159, 2, // 246: decode to QC_EXTDR using decoder 287
16232 // 246: }
16233 // 246: }
16234 6, 20, // 251: case 0x6: {
16235 OPC_Scope, 11, // 253: try {
16236 OPC_CheckField, 20, 5, 0, // 255: check Inst[24:20] == 0x0
16237 OPC_CheckPredicate, 13, // 259: check predicate 13
16238 OPC_Decode, 160, 122, 157, 2, // 261: decode to QC_BREV32 using decoder 285
16239 // 261: } else try {
16240 OPC_CheckPredicate, 13, // 266: check predicate 13
16241 OPC_Decode, 205, 122, 159, 2, // 268: decode to QC_EXTDUPR using decoder 287
16242 // 268: }
16243 // 268: }
16244 7, 21, // 273: case 0x7: {
16245 OPC_Scope, 12, // 275: try {
16246 OPC_CheckField, 20, 5, 0, // 277: check Inst[24:20] == 0x0
16247 OPC_CheckPredicate, 192, 1, // 281: check predicate 192
16248 OPC_Decode, 148, 123, 157, 2, // 284: decode to QC_NORM using decoder 285
16249 // 284: } else try {
16250 OPC_CheckPredicate, 13, // 289: check predicate 13
16251 OPC_Decode, 206, 122, 159, 2, // 291: decode to QC_EXTDUPRH using decoder 287
16252 // 291: }
16253 // 291: }
16254 8, 21, // 296: case 0x8: {
16255 OPC_Scope, 12, // 298: try {
16256 OPC_CheckField, 20, 5, 0, // 300: check Inst[24:20] == 0x0
16257 OPC_CheckPredicate, 192, 1, // 304: check predicate 192
16258 OPC_Decode, 150, 123, 157, 2, // 307: decode to QC_NORMU using decoder 285
16259 // 307: } else try {
16260 OPC_CheckPredicate, 13, // 312: check predicate 13
16261 OPC_Decode, 201, 122, 159, 2, // 314: decode to QC_EXTDPR using decoder 287
16262 // 314: }
16263 // 314: }
16264 9, 21, // 319: case 0x9: {
16265 OPC_Scope, 12, // 321: try {
16266 OPC_CheckField, 20, 5, 0, // 323: check Inst[24:20] == 0x0
16267 OPC_CheckPredicate, 192, 1, // 327: check predicate 192
16268 OPC_Decode, 149, 123, 157, 2, // 330: decode to QC_NORMEU using decoder 285
16269 // 330: } else try {
16270 OPC_CheckPredicate, 13, // 335: check predicate 13
16271 OPC_Decode, 202, 122, 159, 2, // 337: decode to QC_EXTDPRH using decoder 287
16272 // 337: }
16273 // 337: }
16274 10, 8, // 342: case 0xa: {
16275 OPC_CheckPredicate, 192, 1, // 344: check predicate 192
16276 OPC_Decode, 165, 123, 160, 2, // 347: decode to QC_SHLSAT using decoder 288
16277 // 347: }
16278 12, 8, // 352: case 0xc: {
16279 OPC_CheckPredicate, 192, 1, // 354: check predicate 192
16280 OPC_Decode, 166, 123, 160, 2, // 357: decode to QC_SHLUSAT using decoder 288
16281 // 357: }
16282 14, 8, // 362: case 0xe: {
16283 OPC_CheckPredicate, 192, 1, // 364: check predicate 192
16284 OPC_Decode, 152, 122, 160, 2, // 367: decode to QC_ADDSAT using decoder 288
16285 // 367: }
16286 15, 8, // 372: case 0xf: {
16287 OPC_CheckPredicate, 192, 1, // 374: check predicate 192
16288 OPC_Decode, 153, 122, 160, 2, // 377: decode to QC_ADDUSAT using decoder 288
16289 // 377: }
16290 16, 8, // 382: case 0x10: {
16291 OPC_CheckPredicate, 192, 1, // 384: check predicate 192
16292 OPC_Decode, 170, 123, 160, 2, // 387: decode to QC_SUBSAT using decoder 288
16293 // 387: }
16294 17, 8, // 392: case 0x11: {
16295 OPC_CheckPredicate, 192, 1, // 394: check predicate 192
16296 OPC_Decode, 171, 123, 160, 2, // 397: decode to QC_SUBUSAT using decoder 288
16297 // 397: }
16298 18, 0, // 402: case 0x12: {
16299 OPC_CheckPredicate, 192, 1, // 404: check predicate 192
16300 OPC_Decode, 178, 123, 161, 2, // 407: decode to QC_WRAP using decoder 289
16301 // 407: }
16302 // 407: } // switch Inst[29:25]
16303 // 407: }
16304 1, 0, // 412: case 0x1: {
16305 OPC_CheckPredicate, 14, // 414: check predicate 14
16306 OPC_Decode, 164, 123, 162, 2, // 416: decode to QC_SHLADD using decoder 290
16307 // 416: }
16308 // 416: } // switch Inst[31:30]
16309 // 416: }
16310 4, 8, // 421: case 0x4: {
16311 OPC_CheckPredicate, 193, 1, // 423: check predicate 193
16312 OPC_Decode, 151, 123, 163, 2, // 426: decode to QC_OUTW using decoder 291
16313 // 426: }
16314 5, 8, // 431: case 0x5: {
16315 OPC_CheckPredicate, 193, 1, // 433: check predicate 193
16316 OPC_Decode, 242, 122, 164, 2, // 436: decode to QC_INW using decoder 292
16317 // 436: }
16318 6, 7, // 441: case 0x6: {
16319 OPC_CheckPredicate, 14, // 443: check predicate 14
16320 OPC_Decode, 135, 123, 165, 2, // 445: decode to QC_MULIADD using decoder 293
16321 // 445: }
16322 7, 0, // 450: case 0x7: {
16323 OPC_SwitchField, 30, 2, // 452: switch Inst[31:30] {
16324 0, 8, // 455: case 0x0: {
16325 OPC_CheckPredicate, 194, 1, // 457: check predicate 194
16326 OPC_Decode, 133, 123, 166, 2, // 460: decode to QC_LWM using decoder 294
16327 // 460: }
16328 1, 8, // 465: case 0x1: {
16329 OPC_CheckPredicate, 194, 1, // 467: check predicate 194
16330 OPC_Decode, 134, 123, 167, 2, // 470: decode to QC_LWMI using decoder 295
16331 // 470: }
16332 2, 43, // 475: case 0x2: {
16333 OPC_SwitchField, 28, 2, // 477: switch Inst[29:28] {
16334 0, 8, // 480: case 0x0: {
16335 OPC_CheckPredicate, 195, 1, // 482: check predicate 195
16336 OPC_Decode, 128, 123, 168, 2, // 485: decode to QC_LRB using decoder 296
16337 // 485: }
16338 1, 8, // 490: case 0x1: {
16339 OPC_CheckPredicate, 195, 1, // 492: check predicate 195
16340 OPC_Decode, 130, 123, 168, 2, // 495: decode to QC_LRH using decoder 296
16341 // 495: }
16342 2, 8, // 500: case 0x2: {
16343 OPC_CheckPredicate, 195, 1, // 502: check predicate 195
16344 OPC_Decode, 132, 123, 168, 2, // 505: decode to QC_LRW using decoder 296
16345 // 505: }
16346 3, 0, // 510: case 0x3: {
16347 OPC_CheckPredicate, 195, 1, // 512: check predicate 195
16348 OPC_Decode, 129, 123, 168, 2, // 515: decode to QC_LRBU using decoder 296
16349 // 515: }
16350 // 515: } // switch Inst[29:28]
16351 // 515: }
16352 3, 0, // 520: case 0x3: {
16353 OPC_CheckPredicate, 195, 1, // 522: check predicate 195
16354 OPC_CheckField, 28, 2, 0, // 525: check Inst[29:28] == 0x0
16355 OPC_Decode, 131, 123, 168, 2, // 529: decode to QC_LRHU using decoder 296
16356 // 529: }
16357 // 529: } // switch Inst[31:30]
16358 // 529: }
16359 // 529: } // switch Inst[14:12]
16360 // 529: }
16361 19, 82, // 534: case 0x13: {
16362 OPC_SwitchField, 28, 4, // 536: switch Inst[31:28] {
16363 1, 15, // 539: case 0x1: {
16364 OPC_CheckPredicate, 15, // 541: check predicate 15
16365 OPC_CheckField, 25, 3, 0, // 543: check Inst[27:25] == 0x0
16366 OPC_CheckField, 7, 13, 96, // 547: check Inst[19:7] == 0x60
16367 OPC_Decode, 174, 123, 169, 2, // 551: decode to QC_SYNC using decoder 297
16368 // 551: }
16369 2, 15, // 556: case 0x2: {
16370 OPC_CheckPredicate, 15, // 558: check predicate 15
16371 OPC_CheckField, 25, 3, 0, // 560: check Inst[27:25] == 0x0
16372 OPC_CheckField, 7, 13, 96, // 564: check Inst[19:7] == 0x60
16373 OPC_Decode, 175, 123, 169, 2, // 568: decode to QC_SYNCR using decoder 297
16374 // 568: }
16375 4, 26, // 573: case 0x4: {
16376 OPC_SwitchField, 7, 13, // 575: switch Inst[19:7] {
16377 64, 8, // 578: case 0x40: {
16378 OPC_CheckPredicate, 196, 1, // 580: check predicate 196
16379 OPC_Decode, 152, 123, 170, 2, // 583: decode to QC_PPUTCI using decoder 298
16380 // 583: }
16381 96, 0, // 588: case 0x60: {
16382 OPC_CheckPredicate, 15, // 590: check predicate 15
16383 OPC_CheckField, 25, 3, 0, // 592: check Inst[27:25] == 0x0
16384 OPC_Decode, 176, 123, 169, 2, // 596: decode to QC_SYNCWF using decoder 297
16385 // 596: }
16386 // 596: } // switch Inst[19:7]
16387 // 596: }
16388 8, 0, // 601: case 0x8: {
16389 OPC_CheckPredicate, 15, // 603: check predicate 15
16390 OPC_CheckField, 25, 3, 0, // 605: check Inst[27:25] == 0x0
16391 OPC_CheckField, 7, 13, 96, // 609: check Inst[19:7] == 0x60
16392 OPC_Decode, 177, 123, 169, 2, // 613: decode to QC_SYNCWL using decoder 297
16393 // 613: }
16394 // 613: } // switch Inst[31:28]
16395 // 613: }
16396 27, 8, // 618: case 0x1b: {
16397 OPC_CheckPredicate, 197, 1, // 620: check predicate 197
16398 OPC_Decode, 243, 122, 171, 2, // 623: decode to QC_LI using decoder 299
16399 // 623: }
16400 43, 95, // 628: case 0x2b: {
16401 OPC_SwitchField, 30, 2, // 630: switch Inst[31:30] {
16402 0, 12, // 633: case 0x0: {
16403 OPC_CheckPredicate, 194, 1, // 635: check predicate 194
16404 OPC_CheckField, 12, 3, 7, // 638: check Inst[14:12] == 0x7
16405 OPC_Decode, 172, 123, 166, 2, // 642: decode to QC_SWM using decoder 294
16406 // 642: }
16407 1, 12, // 647: case 0x1: {
16408 OPC_CheckPredicate, 194, 1, // 649: check predicate 194
16409 OPC_CheckField, 12, 3, 7, // 652: check Inst[14:12] == 0x7
16410 OPC_Decode, 173, 123, 167, 2, // 656: decode to QC_SWMI using decoder 295
16411 // 656: }
16412 2, 12, // 661: case 0x2: {
16413 OPC_CheckPredicate, 194, 1, // 663: check predicate 194
16414 OPC_CheckField, 12, 3, 7, // 666: check Inst[14:12] == 0x7
16415 OPC_Decode, 162, 123, 172, 2, // 670: decode to QC_SETWM using decoder 300
16416 // 670: }
16417 3, 0, // 675: case 0x3: {
16418 OPC_SwitchField, 12, 3, // 677: switch Inst[14:12] {
16419 6, 33, // 680: case 0x6: {
16420 OPC_SwitchField, 28, 2, // 682: switch Inst[29:28] {
16421 1, 8, // 685: case 0x1: {
16422 OPC_CheckPredicate, 195, 1, // 687: check predicate 195
16423 OPC_Decode, 167, 123, 168, 2, // 690: decode to QC_SRB using decoder 296
16424 // 690: }
16425 2, 8, // 695: case 0x2: {
16426 OPC_CheckPredicate, 195, 1, // 697: check predicate 195
16427 OPC_Decode, 168, 123, 168, 2, // 700: decode to QC_SRH using decoder 296
16428 // 700: }
16429 3, 0, // 705: case 0x3: {
16430 OPC_CheckPredicate, 195, 1, // 707: check predicate 195
16431 OPC_Decode, 169, 123, 168, 2, // 710: decode to QC_SRW using decoder 296
16432 // 710: }
16433 // 710: } // switch Inst[29:28]
16434 // 710: }
16435 7, 0, // 715: case 0x7: {
16436 OPC_CheckPredicate, 194, 1, // 717: check predicate 194
16437 OPC_Decode, 163, 123, 173, 2, // 720: decode to QC_SETWMI using decoder 301
16438 // 720: }
16439 // 720: } // switch Inst[14:12]
16440 // 720: }
16441 // 720: } // switch Inst[31:30]
16442 // 720: }
16443 91, 223, 2, // 725: case 0x5b: {
16444 OPC_SwitchField, 12, 3, // 728: switch Inst[14:12] {
16445 0, 41, // 731: case 0x0: {
16446 OPC_SwitchField, 25, 2, // 733: switch Inst[26:25] {
16447 0, 7, // 736: case 0x0: {
16448 OPC_CheckPredicate, 16, // 738: check predicate 16
16449 OPC_Decode, 136, 123, 174, 2, // 740: decode to QC_MVEQ using decoder 302
16450 // 740: }
16451 1, 8, // 745: case 0x1: {
16452 OPC_CheckPredicate, 198, 1, // 747: check predicate 198
16453 OPC_Decode, 244, 122, 175, 2, // 750: decode to QC_LIEQ using decoder 303
16454 // 750: }
16455 2, 7, // 755: case 0x2: {
16456 OPC_CheckPredicate, 16, // 757: check predicate 16
16457 OPC_Decode, 137, 123, 176, 2, // 759: decode to QC_MVEQI using decoder 304
16458 // 759: }
16459 3, 0, // 764: case 0x3: {
16460 OPC_CheckPredicate, 198, 1, // 766: check predicate 198
16461 OPC_Decode, 245, 122, 177, 2, // 769: decode to QC_LIEQI using decoder 305
16462 // 769: }
16463 // 769: } // switch Inst[26:25]
16464 // 769: }
16465 1, 41, // 774: case 0x1: {
16466 OPC_SwitchField, 25, 2, // 776: switch Inst[26:25] {
16467 0, 7, // 779: case 0x0: {
16468 OPC_CheckPredicate, 16, // 781: check predicate 16
16469 OPC_Decode, 146, 123, 174, 2, // 783: decode to QC_MVNE using decoder 302
16470 // 783: }
16471 1, 8, // 788: case 0x1: {
16472 OPC_CheckPredicate, 198, 1, // 790: check predicate 198
16473 OPC_Decode, 254, 122, 175, 2, // 793: decode to QC_LINE using decoder 303
16474 // 793: }
16475 2, 7, // 798: case 0x2: {
16476 OPC_CheckPredicate, 16, // 800: check predicate 16
16477 OPC_Decode, 147, 123, 176, 2, // 802: decode to QC_MVNEI using decoder 304
16478 // 802: }
16479 3, 0, // 807: case 0x3: {
16480 OPC_CheckPredicate, 198, 1, // 809: check predicate 198
16481 OPC_Decode, 255, 122, 177, 2, // 812: decode to QC_LINEI using decoder 305
16482 // 812: }
16483 // 812: } // switch Inst[26:25]
16484 // 812: }
16485 2, 43, // 817: case 0x2: {
16486 OPC_SwitchField, 25, 2, // 819: switch Inst[26:25] {
16487 0, 8, // 822: case 0x0: {
16488 OPC_CheckPredicate, 199, 1, // 824: check predicate 199
16489 OPC_Decode, 156, 123, 177, 2, // 827: decode to QC_SELECTIIEQ using decoder 305
16490 // 827: }
16491 1, 8, // 832: case 0x1: {
16492 OPC_CheckPredicate, 199, 1, // 834: check predicate 199
16493 OPC_Decode, 154, 123, 175, 2, // 837: decode to QC_SELECTIEQ using decoder 303
16494 // 837: }
16495 2, 8, // 842: case 0x2: {
16496 OPC_CheckPredicate, 199, 1, // 844: check predicate 199
16497 OPC_Decode, 153, 123, 178, 2, // 847: decode to QC_SELECTEQI using decoder 306
16498 // 847: }
16499 3, 0, // 852: case 0x3: {
16500 OPC_CheckPredicate, 199, 1, // 854: check predicate 199
16501 OPC_Decode, 155, 123, 179, 2, // 857: decode to QC_SELECTIEQI using decoder 307
16502 // 857: }
16503 // 857: } // switch Inst[26:25]
16504 // 857: }
16505 3, 43, // 862: case 0x3: {
16506 OPC_SwitchField, 25, 2, // 864: switch Inst[26:25] {
16507 0, 8, // 867: case 0x0: {
16508 OPC_CheckPredicate, 199, 1, // 869: check predicate 199
16509 OPC_Decode, 157, 123, 177, 2, // 872: decode to QC_SELECTIINE using decoder 305
16510 // 872: }
16511 1, 8, // 877: case 0x1: {
16512 OPC_CheckPredicate, 199, 1, // 879: check predicate 199
16513 OPC_Decode, 158, 123, 175, 2, // 882: decode to QC_SELECTINE using decoder 303
16514 // 882: }
16515 2, 8, // 887: case 0x2: {
16516 OPC_CheckPredicate, 199, 1, // 889: check predicate 199
16517 OPC_Decode, 160, 123, 178, 2, // 892: decode to QC_SELECTNEI using decoder 306
16518 // 892: }
16519 3, 0, // 897: case 0x3: {
16520 OPC_CheckPredicate, 199, 1, // 899: check predicate 199
16521 OPC_Decode, 159, 123, 179, 2, // 902: decode to QC_SELECTINEI using decoder 307
16522 // 902: }
16523 // 902: } // switch Inst[26:25]
16524 // 902: }
16525 4, 41, // 907: case 0x4: {
16526 OPC_SwitchField, 25, 2, // 909: switch Inst[26:25] {
16527 0, 7, // 912: case 0x0: {
16528 OPC_CheckPredicate, 16, // 914: check predicate 16
16529 OPC_Decode, 142, 123, 174, 2, // 916: decode to QC_MVLT using decoder 302
16530 // 916: }
16531 1, 8, // 921: case 0x1: {
16532 OPC_CheckPredicate, 198, 1, // 923: check predicate 198
16533 OPC_Decode, 250, 122, 175, 2, // 926: decode to QC_LILT using decoder 303
16534 // 926: }
16535 2, 7, // 931: case 0x2: {
16536 OPC_CheckPredicate, 16, // 933: check predicate 16
16537 OPC_Decode, 143, 123, 176, 2, // 935: decode to QC_MVLTI using decoder 304
16538 // 935: }
16539 3, 0, // 940: case 0x3: {
16540 OPC_CheckPredicate, 198, 1, // 942: check predicate 198
16541 OPC_Decode, 251, 122, 177, 2, // 945: decode to QC_LILTI using decoder 305
16542 // 945: }
16543 // 945: } // switch Inst[26:25]
16544 // 945: }
16545 5, 41, // 950: case 0x5: {
16546 OPC_SwitchField, 25, 2, // 952: switch Inst[26:25] {
16547 0, 7, // 955: case 0x0: {
16548 OPC_CheckPredicate, 16, // 957: check predicate 16
16549 OPC_Decode, 138, 123, 174, 2, // 959: decode to QC_MVGE using decoder 302
16550 // 959: }
16551 1, 8, // 964: case 0x1: {
16552 OPC_CheckPredicate, 198, 1, // 966: check predicate 198
16553 OPC_Decode, 246, 122, 175, 2, // 969: decode to QC_LIGE using decoder 303
16554 // 969: }
16555 2, 7, // 974: case 0x2: {
16556 OPC_CheckPredicate, 16, // 976: check predicate 16
16557 OPC_Decode, 139, 123, 176, 2, // 978: decode to QC_MVGEI using decoder 304
16558 // 978: }
16559 3, 0, // 983: case 0x3: {
16560 OPC_CheckPredicate, 198, 1, // 985: check predicate 198
16561 OPC_Decode, 247, 122, 177, 2, // 988: decode to QC_LIGEI using decoder 305
16562 // 988: }
16563 // 988: } // switch Inst[26:25]
16564 // 988: }
16565 6, 41, // 993: case 0x6: {
16566 OPC_SwitchField, 25, 2, // 995: switch Inst[26:25] {
16567 0, 7, // 998: case 0x0: {
16568 OPC_CheckPredicate, 16, // 1000: check predicate 16
16569 OPC_Decode, 144, 123, 174, 2, // 1002: decode to QC_MVLTU using decoder 302
16570 // 1002: }
16571 1, 8, // 1007: case 0x1: {
16572 OPC_CheckPredicate, 198, 1, // 1009: check predicate 198
16573 OPC_Decode, 252, 122, 175, 2, // 1012: decode to QC_LILTU using decoder 303
16574 // 1012: }
16575 2, 7, // 1017: case 0x2: {
16576 OPC_CheckPredicate, 16, // 1019: check predicate 16
16577 OPC_Decode, 145, 123, 180, 2, // 1021: decode to QC_MVLTUI using decoder 308
16578 // 1021: }
16579 3, 0, // 1026: case 0x3: {
16580 OPC_CheckPredicate, 198, 1, // 1028: check predicate 198
16581 OPC_Decode, 253, 122, 181, 2, // 1031: decode to QC_LILTUI using decoder 309
16582 // 1031: }
16583 // 1031: } // switch Inst[26:25]
16584 // 1031: }
16585 7, 0, // 1036: case 0x7: {
16586 OPC_SwitchField, 25, 2, // 1038: switch Inst[26:25] {
16587 0, 7, // 1041: case 0x0: {
16588 OPC_CheckPredicate, 16, // 1043: check predicate 16
16589 OPC_Decode, 140, 123, 174, 2, // 1045: decode to QC_MVGEU using decoder 302
16590 // 1045: }
16591 1, 8, // 1050: case 0x1: {
16592 OPC_CheckPredicate, 198, 1, // 1052: check predicate 198
16593 OPC_Decode, 248, 122, 175, 2, // 1055: decode to QC_LIGEU using decoder 303
16594 // 1055: }
16595 2, 7, // 1060: case 0x2: {
16596 OPC_CheckPredicate, 16, // 1062: check predicate 16
16597 OPC_Decode, 141, 123, 180, 2, // 1064: decode to QC_MVGEUI using decoder 308
16598 // 1064: }
16599 3, 0, // 1069: case 0x3: {
16600 OPC_CheckPredicate, 198, 1, // 1071: check predicate 198
16601 OPC_Decode, 249, 122, 181, 2, // 1074: decode to QC_LIGEUI using decoder 309
16602 // 1074: }
16603 // 1074: } // switch Inst[26:25]
16604 // 1074: }
16605 // 1074: } // switch Inst[14:12]
16606 // 1074: }
16607 115, 57, // 1079: case 0x73: {
16608 OPC_SwitchField, 25, 7, // 1081: switch Inst[31:25] {
16609 70, 12, // 1084: case 0x46: {
16610 OPC_CheckPredicate, 200, 1, // 1086: check predicate 200
16611 OPC_CheckField, 12, 3, 0, // 1089: check Inst[14:12] == 0x0
16612 OPC_Decode, 174, 122, 182, 2, // 1093: decode to QC_CSRRWR using decoder 310
16613 // 1093: }
16614 71, 12, // 1098: case 0x47: {
16615 OPC_CheckPredicate, 200, 1, // 1100: check predicate 200
16616 OPC_CheckField, 12, 3, 0, // 1103: check Inst[14:12] == 0x0
16617 OPC_Decode, 175, 122, 183, 2, // 1107: decode to QC_CSRRWRI using decoder 311
16618 // 1107: }
16619 102, 11, // 1112: case 0x66: {
16620 OPC_CheckPredicate, 12, // 1114: check predicate 12
16621 OPC_CheckField, 7, 8, 0, // 1116: check Inst[14:7] == 0x0
16622 OPC_Decode, 161, 123, 184, 2, // 1120: decode to QC_SETINTI using decoder 312
16623 // 1120: }
16624 103, 0, // 1125: case 0x67: {
16625 OPC_CheckPredicate, 12, // 1127: check predicate 12
16626 OPC_CheckField, 7, 8, 0, // 1129: check Inst[14:7] == 0x0
16627 OPC_Decode, 162, 122, 184, 2, // 1133: decode to QC_CLRINTI using decoder 312
16628 // 1133: }
16629 // 1133: } // switch Inst[31:25]
16630 // 1133: }
16631 123, 0, // 1138: case 0x7b: {
16632 OPC_SwitchField, 12, 3, // 1140: switch Inst[14:12] {
16633 0, 8, // 1143: case 0x0: {
16634 OPC_CheckPredicate, 201, 1, // 1145: check predicate 201
16635 OPC_Decode, 154, 122, 185, 2, // 1148: decode to QC_BEQI using decoder 313
16636 // 1148: }
16637 1, 8, // 1153: case 0x1: {
16638 OPC_CheckPredicate, 201, 1, // 1155: check predicate 201
16639 OPC_Decode, 159, 122, 185, 2, // 1158: decode to QC_BNEI using decoder 313
16640 // 1158: }
16641 4, 8, // 1163: case 0x4: {
16642 OPC_CheckPredicate, 201, 1, // 1165: check predicate 201
16643 OPC_Decode, 157, 122, 185, 2, // 1168: decode to QC_BLTI using decoder 313
16644 // 1168: }
16645 5, 8, // 1173: case 0x5: {
16646 OPC_CheckPredicate, 201, 1, // 1175: check predicate 201
16647 OPC_Decode, 155, 122, 185, 2, // 1178: decode to QC_BGEI using decoder 313
16648 // 1178: }
16649 6, 8, // 1183: case 0x6: {
16650 OPC_CheckPredicate, 201, 1, // 1185: check predicate 201
16651 OPC_Decode, 158, 122, 186, 2, // 1188: decode to QC_BLTUI using decoder 314
16652 // 1188: }
16653 7, 0, // 1193: case 0x7: {
16654 OPC_CheckPredicate, 201, 1, // 1195: check predicate 201
16655 OPC_Decode, 156, 122, 186, 2, // 1198: decode to QC_BGEUI using decoder 314
16656 // 1198: }
16657 // 1198: } // switch Inst[14:12]
16658 // 1198: }
16659 // 1198: } // switch Inst[6:0]
16660};
16661static const uint8_t DecoderTableZdinxGPRPairRV3232[34] = {
16662 32, // 0: BitWidth 32
16663 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
16664 162, 8, 12, // 4: case 0x422: {
16665 OPC_CheckPredicate, 202, 1, // 7: check predicate 202
16666 OPC_CheckField, 0, 7, 83, // 10: check Inst[6:0] == 0x53
16667 OPC_Decode, 158, 114, 187, 2, // 14: decode to FCVT_D_H_IN32X using decoder 315
16668 // 14: }
16669 193, 8, 0, // 19: case 0x441: {
16670 OPC_CheckPredicate, 202, 1, // 22: check predicate 202
16671 OPC_CheckField, 0, 7, 83, // 25: check Inst[6:0] == 0x53
16672 OPC_Decode, 175, 114, 188, 2, // 29: decode to FCVT_H_D_IN32X using decoder 316
16673 // 29: }
16674 // 29: } // switch Inst[31:20]
16675};
16676static const uint8_t DecoderTableZdinxRV32Only32[310] = {
16677 32, // 0: BitWidth 32
16678 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16679 67, 12, // 4: case 0x43: {
16680 OPC_CheckPredicate, 203, 1, // 6: check predicate 203
16681 OPC_CheckField, 25, 2, 1, // 9: check Inst[26:25] == 0x1
16682 OPC_Decode, 164, 115, 189, 2, // 13: decode to FMADD_D_IN32X using decoder 317
16683 // 13: }
16684 71, 12, // 18: case 0x47: {
16685 OPC_CheckPredicate, 203, 1, // 20: check predicate 203
16686 OPC_CheckField, 25, 2, 1, // 23: check Inst[26:25] == 0x1
16687 OPC_Decode, 196, 115, 189, 2, // 27: decode to FMSUB_D_IN32X using decoder 317
16688 // 27: }
16689 75, 12, // 32: case 0x4b: {
16690 OPC_CheckPredicate, 203, 1, // 34: check predicate 203
16691 OPC_CheckField, 25, 2, 1, // 37: check Inst[26:25] == 0x1
16692 OPC_Decode, 231, 115, 189, 2, // 41: decode to FNMSUB_D_IN32X using decoder 317
16693 // 41: }
16694 79, 12, // 46: case 0x4f: {
16695 OPC_CheckPredicate, 203, 1, // 48: check predicate 203
16696 OPC_CheckField, 25, 2, 1, // 51: check Inst[26:25] == 0x1
16697 OPC_Decode, 223, 115, 189, 2, // 55: decode to FNMADD_D_IN32X using decoder 317
16698 // 55: }
16699 83, 0, // 60: case 0x53: {
16700 OPC_SwitchField, 25, 7, // 62: switch Inst[31:25] {
16701 1, 8, // 65: case 0x1: {
16702 OPC_CheckPredicate, 203, 1, // 67: check predicate 203
16703 OPC_Decode, 140, 114, 190, 2, // 70: decode to FADD_D_IN32X using decoder 318
16704 // 70: }
16705 5, 8, // 75: case 0x5: {
16706 OPC_CheckPredicate, 203, 1, // 77: check predicate 203
16707 OPC_Decode, 154, 116, 190, 2, // 80: decode to FSUB_D_IN32X using decoder 318
16708 // 80: }
16709 9, 8, // 85: case 0x9: {
16710 OPC_CheckPredicate, 203, 1, // 87: check predicate 203
16711 OPC_Decode, 204, 115, 190, 2, // 90: decode to FMUL_D_IN32X using decoder 318
16712 // 90: }
16713 13, 8, // 95: case 0xd: {
16714 OPC_CheckPredicate, 203, 1, // 97: check predicate 203
16715 OPC_Decode, 241, 114, 190, 2, // 100: decode to FDIV_D_IN32X using decoder 318
16716 // 100: }
16717 17, 33, // 105: case 0x11: {
16718 OPC_SwitchField, 12, 3, // 107: switch Inst[14:12] {
16719 0, 8, // 110: case 0x0: {
16720 OPC_CheckPredicate, 203, 1, // 112: check predicate 203
16721 OPC_Decode, 136, 116, 191, 2, // 115: decode to FSGNJ_D_IN32X using decoder 319
16722 // 115: }
16723 1, 8, // 120: case 0x1: {
16724 OPC_CheckPredicate, 203, 1, // 122: check predicate 203
16725 OPC_Decode, 248, 115, 191, 2, // 125: decode to FSGNJN_D_IN32X using decoder 319
16726 // 125: }
16727 2, 0, // 130: case 0x2: {
16728 OPC_CheckPredicate, 203, 1, // 132: check predicate 203
16729 OPC_Decode, 128, 116, 191, 2, // 135: decode to FSGNJX_D_IN32X using decoder 319
16730 // 135: }
16731 // 135: } // switch Inst[14:12]
16732 // 135: }
16733 21, 23, // 140: case 0x15: {
16734 OPC_SwitchField, 12, 3, // 142: switch Inst[14:12] {
16735 0, 8, // 145: case 0x0: {
16736 OPC_CheckPredicate, 203, 1, // 147: check predicate 203
16737 OPC_Decode, 188, 115, 191, 2, // 150: decode to FMIN_D_IN32X using decoder 319
16738 // 150: }
16739 1, 0, // 155: case 0x1: {
16740 OPC_CheckPredicate, 203, 1, // 157: check predicate 203
16741 OPC_Decode, 176, 115, 191, 2, // 160: decode to FMAX_D_IN32X using decoder 319
16742 // 160: }
16743 // 160: } // switch Inst[14:12]
16744 // 160: }
16745 32, 12, // 165: case 0x20: {
16746 OPC_CheckPredicate, 203, 1, // 167: check predicate 203
16747 OPC_CheckField, 20, 5, 1, // 170: check Inst[24:20] == 0x1
16748 OPC_Decode, 211, 114, 192, 2, // 174: decode to FCVT_S_D_IN32X using decoder 320
16749 // 174: }
16750 33, 12, // 179: case 0x21: {
16751 OPC_CheckPredicate, 203, 1, // 181: check predicate 203
16752 OPC_CheckField, 20, 5, 0, // 184: check Inst[24:20] == 0x0
16753 OPC_Decode, 166, 114, 193, 2, // 188: decode to FCVT_D_S_IN32X using decoder 321
16754 // 188: }
16755 45, 12, // 193: case 0x2d: {
16756 OPC_CheckPredicate, 203, 1, // 195: check predicate 203
16757 OPC_CheckField, 20, 5, 0, // 198: check Inst[24:20] == 0x0
16758 OPC_Decode, 146, 116, 194, 2, // 202: decode to FSQRT_D_IN32X using decoder 322
16759 // 202: }
16760 81, 33, // 207: case 0x51: {
16761 OPC_SwitchField, 12, 3, // 209: switch Inst[14:12] {
16762 0, 8, // 212: case 0x0: {
16763 OPC_CheckPredicate, 203, 1, // 214: check predicate 203
16764 OPC_Decode, 137, 115, 195, 2, // 217: decode to FLE_D_IN32X using decoder 323
16765 // 217: }
16766 1, 8, // 222: case 0x1: {
16767 OPC_CheckPredicate, 203, 1, // 224: check predicate 203
16768 OPC_Decode, 155, 115, 195, 2, // 227: decode to FLT_D_IN32X using decoder 323
16769 // 227: }
16770 2, 0, // 232: case 0x2: {
16771 OPC_CheckPredicate, 203, 1, // 234: check predicate 203
16772 OPC_Decode, 252, 114, 195, 2, // 237: decode to FEQ_D_IN32X using decoder 323
16773 // 237: }
16774 // 237: } // switch Inst[14:12]
16775 // 237: }
16776 97, 23, // 242: case 0x61: {
16777 OPC_SwitchField, 20, 5, // 244: switch Inst[24:20] {
16778 0, 8, // 247: case 0x0: {
16779 OPC_CheckPredicate, 203, 1, // 249: check predicate 203
16780 OPC_Decode, 233, 114, 196, 2, // 252: decode to FCVT_W_D_IN32X using decoder 324
16781 // 252: }
16782 1, 0, // 257: case 0x1: {
16783 OPC_CheckPredicate, 203, 1, // 259: check predicate 203
16784 OPC_Decode, 225, 114, 196, 2, // 262: decode to FCVT_WU_D_IN32X using decoder 324
16785 // 262: }
16786 // 262: } // switch Inst[24:20]
16787 // 262: }
16788 105, 23, // 267: case 0x69: {
16789 OPC_SwitchField, 20, 5, // 269: switch Inst[24:20] {
16790 0, 8, // 272: case 0x0: {
16791 OPC_CheckPredicate, 203, 1, // 274: check predicate 203
16792 OPC_Decode, 172, 114, 197, 2, // 277: decode to FCVT_D_W_IN32X using decoder 325
16793 // 277: }
16794 1, 0, // 282: case 0x1: {
16795 OPC_CheckPredicate, 203, 1, // 284: check predicate 203
16796 OPC_Decode, 170, 114, 197, 2, // 287: decode to FCVT_D_WU_IN32X using decoder 325
16797 // 287: }
16798 // 287: } // switch Inst[24:20]
16799 // 287: }
16800 113, 0, // 292: case 0x71: {
16801 OPC_CheckPredicate, 203, 1, // 294: check predicate 203
16802 OPC_CheckField, 20, 5, 0, // 297: check Inst[24:20] == 0x0
16803 OPC_CheckField, 12, 3, 1, // 301: check Inst[14:12] == 0x1
16804 OPC_Decode, 148, 114, 198, 2, // 305: decode to FCLASS_D_IN32X using decoder 326
16805 // 305: }
16806 // 305: } // switch Inst[31:25]
16807 // 305: }
16808 // 305: } // switch Inst[6:0]
16809};
16810static const uint8_t DecoderTableZfinx32[986] = {
16811 32, // 0: BitWidth 32
16812 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16813 67, 33, // 4: case 0x43: {
16814 OPC_SwitchField, 25, 2, // 6: switch Inst[26:25] {
16815 0, 8, // 9: case 0x0: {
16816 OPC_CheckPredicate, 204, 1, // 11: check predicate 204
16817 OPC_Decode, 170, 115, 199, 2, // 14: decode to FMADD_S_INX using decoder 327
16818 // 14: }
16819 1, 8, // 19: case 0x1: {
16820 OPC_CheckPredicate, 205, 1, // 21: check predicate 205
16821 OPC_Decode, 165, 115, 200, 2, // 24: decode to FMADD_D_INX using decoder 328
16822 // 24: }
16823 2, 0, // 29: case 0x2: {
16824 OPC_CheckPredicate, 206, 1, // 31: check predicate 206
16825 OPC_Decode, 167, 115, 201, 2, // 34: decode to FMADD_H_INX using decoder 329
16826 // 34: }
16827 // 34: } // switch Inst[26:25]
16828 // 34: }
16829 71, 33, // 39: case 0x47: {
16830 OPC_SwitchField, 25, 2, // 41: switch Inst[26:25] {
16831 0, 8, // 44: case 0x0: {
16832 OPC_CheckPredicate, 204, 1, // 46: check predicate 204
16833 OPC_Decode, 202, 115, 199, 2, // 49: decode to FMSUB_S_INX using decoder 327
16834 // 49: }
16835 1, 8, // 54: case 0x1: {
16836 OPC_CheckPredicate, 205, 1, // 56: check predicate 205
16837 OPC_Decode, 197, 115, 200, 2, // 59: decode to FMSUB_D_INX using decoder 328
16838 // 59: }
16839 2, 0, // 64: case 0x2: {
16840 OPC_CheckPredicate, 206, 1, // 66: check predicate 206
16841 OPC_Decode, 199, 115, 201, 2, // 69: decode to FMSUB_H_INX using decoder 329
16842 // 69: }
16843 // 69: } // switch Inst[26:25]
16844 // 69: }
16845 75, 33, // 74: case 0x4b: {
16846 OPC_SwitchField, 25, 2, // 76: switch Inst[26:25] {
16847 0, 8, // 79: case 0x0: {
16848 OPC_CheckPredicate, 204, 1, // 81: check predicate 204
16849 OPC_Decode, 237, 115, 199, 2, // 84: decode to FNMSUB_S_INX using decoder 327
16850 // 84: }
16851 1, 8, // 89: case 0x1: {
16852 OPC_CheckPredicate, 205, 1, // 91: check predicate 205
16853 OPC_Decode, 232, 115, 200, 2, // 94: decode to FNMSUB_D_INX using decoder 328
16854 // 94: }
16855 2, 0, // 99: case 0x2: {
16856 OPC_CheckPredicate, 206, 1, // 101: check predicate 206
16857 OPC_Decode, 234, 115, 201, 2, // 104: decode to FNMSUB_H_INX using decoder 329
16858 // 104: }
16859 // 104: } // switch Inst[26:25]
16860 // 104: }
16861 79, 33, // 109: case 0x4f: {
16862 OPC_SwitchField, 25, 2, // 111: switch Inst[26:25] {
16863 0, 8, // 114: case 0x0: {
16864 OPC_CheckPredicate, 204, 1, // 116: check predicate 204
16865 OPC_Decode, 229, 115, 199, 2, // 119: decode to FNMADD_S_INX using decoder 327
16866 // 119: }
16867 1, 8, // 124: case 0x1: {
16868 OPC_CheckPredicate, 205, 1, // 126: check predicate 205
16869 OPC_Decode, 224, 115, 200, 2, // 129: decode to FNMADD_D_INX using decoder 328
16870 // 129: }
16871 2, 0, // 134: case 0x2: {
16872 OPC_CheckPredicate, 206, 1, // 136: check predicate 206
16873 OPC_Decode, 226, 115, 201, 2, // 139: decode to FNMADD_H_INX using decoder 329
16874 // 139: }
16875 // 139: } // switch Inst[26:25]
16876 // 139: }
16877 83, 0, // 144: case 0x53: {
16878 OPC_SwitchField, 25, 7, // 146: switch Inst[31:25] {
16879 0, 8, // 149: case 0x0: {
16880 OPC_CheckPredicate, 204, 1, // 151: check predicate 204
16881 OPC_Decode, 146, 114, 202, 2, // 154: decode to FADD_S_INX using decoder 330
16882 // 154: }
16883 1, 8, // 159: case 0x1: {
16884 OPC_CheckPredicate, 205, 1, // 161: check predicate 205
16885 OPC_Decode, 141, 114, 203, 2, // 164: decode to FADD_D_INX using decoder 331
16886 // 164: }
16887 2, 8, // 169: case 0x2: {
16888 OPC_CheckPredicate, 206, 1, // 171: check predicate 206
16889 OPC_Decode, 143, 114, 204, 2, // 174: decode to FADD_H_INX using decoder 332
16890 // 174: }
16891 4, 8, // 179: case 0x4: {
16892 OPC_CheckPredicate, 204, 1, // 181: check predicate 204
16893 OPC_Decode, 160, 116, 202, 2, // 184: decode to FSUB_S_INX using decoder 330
16894 // 184: }
16895 5, 8, // 189: case 0x5: {
16896 OPC_CheckPredicate, 205, 1, // 191: check predicate 205
16897 OPC_Decode, 155, 116, 203, 2, // 194: decode to FSUB_D_INX using decoder 331
16898 // 194: }
16899 6, 8, // 199: case 0x6: {
16900 OPC_CheckPredicate, 206, 1, // 201: check predicate 206
16901 OPC_Decode, 157, 116, 204, 2, // 204: decode to FSUB_H_INX using decoder 332
16902 // 204: }
16903 8, 8, // 209: case 0x8: {
16904 OPC_CheckPredicate, 204, 1, // 211: check predicate 204
16905 OPC_Decode, 210, 115, 202, 2, // 214: decode to FMUL_S_INX using decoder 330
16906 // 214: }
16907 9, 8, // 219: case 0x9: {
16908 OPC_CheckPredicate, 205, 1, // 221: check predicate 205
16909 OPC_Decode, 205, 115, 203, 2, // 224: decode to FMUL_D_INX using decoder 331
16910 // 224: }
16911 10, 8, // 229: case 0xa: {
16912 OPC_CheckPredicate, 206, 1, // 231: check predicate 206
16913 OPC_Decode, 207, 115, 204, 2, // 234: decode to FMUL_H_INX using decoder 332
16914 // 234: }
16915 12, 8, // 239: case 0xc: {
16916 OPC_CheckPredicate, 204, 1, // 241: check predicate 204
16917 OPC_Decode, 247, 114, 202, 2, // 244: decode to FDIV_S_INX using decoder 330
16918 // 244: }
16919 13, 8, // 249: case 0xd: {
16920 OPC_CheckPredicate, 205, 1, // 251: check predicate 205
16921 OPC_Decode, 242, 114, 203, 2, // 254: decode to FDIV_D_INX using decoder 331
16922 // 254: }
16923 14, 8, // 259: case 0xe: {
16924 OPC_CheckPredicate, 206, 1, // 261: check predicate 206
16925 OPC_Decode, 244, 114, 204, 2, // 264: decode to FDIV_H_INX using decoder 332
16926 // 264: }
16927 16, 33, // 269: case 0x10: {
16928 OPC_SwitchField, 12, 3, // 271: switch Inst[14:12] {
16929 0, 8, // 274: case 0x0: {
16930 OPC_CheckPredicate, 204, 1, // 276: check predicate 204
16931 OPC_Decode, 142, 116, 205, 2, // 279: decode to FSGNJ_S_INX using decoder 333
16932 // 279: }
16933 1, 8, // 284: case 0x1: {
16934 OPC_CheckPredicate, 204, 1, // 286: check predicate 204
16935 OPC_Decode, 254, 115, 205, 2, // 289: decode to FSGNJN_S_INX using decoder 333
16936 // 289: }
16937 2, 0, // 294: case 0x2: {
16938 OPC_CheckPredicate, 204, 1, // 296: check predicate 204
16939 OPC_Decode, 134, 116, 205, 2, // 299: decode to FSGNJX_S_INX using decoder 333
16940 // 299: }
16941 // 299: } // switch Inst[14:12]
16942 // 299: }
16943 17, 30, // 304: case 0x11: {
16944 OPC_SwitchField, 12, 3, // 306: switch Inst[14:12] {
16945 0, 7, // 309: case 0x0: {
16946 OPC_CheckPredicate, 205, 1, // 311: check predicate 205
16947 OPC_Decode, 137, 116, 31, // 314: decode to FSGNJ_D_INX using decoder 31
16948 // 314: }
16949 1, 7, // 318: case 0x1: {
16950 OPC_CheckPredicate, 205, 1, // 320: check predicate 205
16951 OPC_Decode, 249, 115, 31, // 323: decode to FSGNJN_D_INX using decoder 31
16952 // 323: }
16953 2, 0, // 327: case 0x2: {
16954 OPC_CheckPredicate, 205, 1, // 329: check predicate 205
16955 OPC_Decode, 129, 116, 31, // 332: decode to FSGNJX_D_INX using decoder 31
16956 // 332: }
16957 // 332: } // switch Inst[14:12]
16958 // 332: }
16959 18, 33, // 336: case 0x12: {
16960 OPC_SwitchField, 12, 3, // 338: switch Inst[14:12] {
16961 0, 8, // 341: case 0x0: {
16962 OPC_CheckPredicate, 206, 1, // 343: check predicate 206
16963 OPC_Decode, 139, 116, 206, 2, // 346: decode to FSGNJ_H_INX using decoder 334
16964 // 346: }
16965 1, 8, // 351: case 0x1: {
16966 OPC_CheckPredicate, 206, 1, // 353: check predicate 206
16967 OPC_Decode, 251, 115, 206, 2, // 356: decode to FSGNJN_H_INX using decoder 334
16968 // 356: }
16969 2, 0, // 361: case 0x2: {
16970 OPC_CheckPredicate, 206, 1, // 363: check predicate 206
16971 OPC_Decode, 131, 116, 206, 2, // 366: decode to FSGNJX_H_INX using decoder 334
16972 // 366: }
16973 // 366: } // switch Inst[14:12]
16974 // 366: }
16975 20, 23, // 371: case 0x14: {
16976 OPC_SwitchField, 12, 3, // 373: switch Inst[14:12] {
16977 0, 8, // 376: case 0x0: {
16978 OPC_CheckPredicate, 204, 1, // 378: check predicate 204
16979 OPC_Decode, 194, 115, 205, 2, // 381: decode to FMIN_S_INX using decoder 333
16980 // 381: }
16981 1, 0, // 386: case 0x1: {
16982 OPC_CheckPredicate, 204, 1, // 388: check predicate 204
16983 OPC_Decode, 182, 115, 205, 2, // 391: decode to FMAX_S_INX using decoder 333
16984 // 391: }
16985 // 391: } // switch Inst[14:12]
16986 // 391: }
16987 21, 21, // 396: case 0x15: {
16988 OPC_SwitchField, 12, 3, // 398: switch Inst[14:12] {
16989 0, 7, // 401: case 0x0: {
16990 OPC_CheckPredicate, 205, 1, // 403: check predicate 205
16991 OPC_Decode, 189, 115, 31, // 406: decode to FMIN_D_INX using decoder 31
16992 // 406: }
16993 1, 0, // 410: case 0x1: {
16994 OPC_CheckPredicate, 205, 1, // 412: check predicate 205
16995 OPC_Decode, 177, 115, 31, // 415: decode to FMAX_D_INX using decoder 31
16996 // 415: }
16997 // 415: } // switch Inst[14:12]
16998 // 415: }
16999 22, 23, // 419: case 0x16: {
17000 OPC_SwitchField, 12, 3, // 421: switch Inst[14:12] {
17001 0, 8, // 424: case 0x0: {
17002 OPC_CheckPredicate, 206, 1, // 426: check predicate 206
17003 OPC_Decode, 191, 115, 206, 2, // 429: decode to FMIN_H_INX using decoder 334
17004 // 429: }
17005 1, 0, // 434: case 0x1: {
17006 OPC_CheckPredicate, 206, 1, // 436: check predicate 206
17007 OPC_Decode, 179, 115, 206, 2, // 439: decode to FMAX_H_INX using decoder 334
17008 // 439: }
17009 // 439: } // switch Inst[14:12]
17010 // 439: }
17011 32, 23, // 444: case 0x20: {
17012 OPC_SwitchField, 20, 5, // 446: switch Inst[24:20] {
17013 1, 8, // 449: case 0x1: {
17014 OPC_CheckPredicate, 205, 1, // 451: check predicate 205
17015 OPC_Decode, 212, 114, 207, 2, // 454: decode to FCVT_S_D_INX using decoder 335
17016 // 454: }
17017 2, 0, // 459: case 0x2: {
17018 OPC_CheckPredicate, 207, 1, // 461: check predicate 207
17019 OPC_Decode, 214, 114, 208, 2, // 464: decode to FCVT_S_H_INX using decoder 336
17020 // 464: }
17021 // 464: } // switch Inst[24:20]
17022 // 464: }
17023 33, 23, // 469: case 0x21: {
17024 OPC_SwitchField, 20, 5, // 471: switch Inst[24:20] {
17025 0, 8, // 474: case 0x0: {
17026 OPC_CheckPredicate, 205, 1, // 476: check predicate 205
17027 OPC_Decode, 167, 114, 209, 2, // 479: decode to FCVT_D_S_INX using decoder 337
17028 // 479: }
17029 2, 0, // 484: case 0x2: {
17030 OPC_CheckPredicate, 208, 1, // 486: check predicate 208
17031 OPC_Decode, 159, 114, 210, 2, // 489: decode to FCVT_D_H_INX using decoder 338
17032 // 489: }
17033 // 489: } // switch Inst[24:20]
17034 // 489: }
17035 34, 23, // 494: case 0x22: {
17036 OPC_SwitchField, 20, 5, // 496: switch Inst[24:20] {
17037 0, 8, // 499: case 0x0: {
17038 OPC_CheckPredicate, 207, 1, // 501: check predicate 207
17039 OPC_Decode, 183, 114, 211, 2, // 504: decode to FCVT_H_S_INX using decoder 339
17040 // 504: }
17041 1, 0, // 509: case 0x1: {
17042 OPC_CheckPredicate, 208, 1, // 511: check predicate 208
17043 OPC_Decode, 176, 114, 212, 2, // 514: decode to FCVT_H_D_INX using decoder 340
17044 // 514: }
17045 // 514: } // switch Inst[24:20]
17046 // 514: }
17047 44, 12, // 519: case 0x2c: {
17048 OPC_CheckPredicate, 204, 1, // 521: check predicate 204
17049 OPC_CheckField, 20, 5, 0, // 524: check Inst[24:20] == 0x0
17050 OPC_Decode, 152, 116, 213, 2, // 528: decode to FSQRT_S_INX using decoder 341
17051 // 528: }
17052 45, 12, // 533: case 0x2d: {
17053 OPC_CheckPredicate, 205, 1, // 535: check predicate 205
17054 OPC_CheckField, 20, 5, 0, // 538: check Inst[24:20] == 0x0
17055 OPC_Decode, 147, 116, 214, 2, // 542: decode to FSQRT_D_INX using decoder 342
17056 // 542: }
17057 46, 12, // 547: case 0x2e: {
17058 OPC_CheckPredicate, 206, 1, // 549: check predicate 206
17059 OPC_CheckField, 20, 5, 0, // 552: check Inst[24:20] == 0x0
17060 OPC_Decode, 149, 116, 215, 2, // 556: decode to FSQRT_H_INX using decoder 343
17061 // 556: }
17062 80, 33, // 561: case 0x50: {
17063 OPC_SwitchField, 12, 3, // 563: switch Inst[14:12] {
17064 0, 8, // 566: case 0x0: {
17065 OPC_CheckPredicate, 204, 1, // 568: check predicate 204
17066 OPC_Decode, 143, 115, 216, 2, // 571: decode to FLE_S_INX using decoder 344
17067 // 571: }
17068 1, 8, // 576: case 0x1: {
17069 OPC_CheckPredicate, 204, 1, // 578: check predicate 204
17070 OPC_Decode, 161, 115, 216, 2, // 581: decode to FLT_S_INX using decoder 344
17071 // 581: }
17072 2, 0, // 586: case 0x2: {
17073 OPC_CheckPredicate, 204, 1, // 588: check predicate 204
17074 OPC_Decode, 130, 115, 216, 2, // 591: decode to FEQ_S_INX using decoder 344
17075 // 591: }
17076 // 591: } // switch Inst[14:12]
17077 // 591: }
17078 81, 30, // 596: case 0x51: {
17079 OPC_SwitchField, 12, 3, // 598: switch Inst[14:12] {
17080 0, 7, // 601: case 0x0: {
17081 OPC_CheckPredicate, 205, 1, // 603: check predicate 205
17082 OPC_Decode, 138, 115, 31, // 606: decode to FLE_D_INX using decoder 31
17083 // 606: }
17084 1, 7, // 610: case 0x1: {
17085 OPC_CheckPredicate, 205, 1, // 612: check predicate 205
17086 OPC_Decode, 156, 115, 31, // 615: decode to FLT_D_INX using decoder 31
17087 // 615: }
17088 2, 0, // 619: case 0x2: {
17089 OPC_CheckPredicate, 205, 1, // 621: check predicate 205
17090 OPC_Decode, 253, 114, 31, // 624: decode to FEQ_D_INX using decoder 31
17091 // 624: }
17092 // 624: } // switch Inst[14:12]
17093 // 624: }
17094 82, 33, // 628: case 0x52: {
17095 OPC_SwitchField, 12, 3, // 630: switch Inst[14:12] {
17096 0, 8, // 633: case 0x0: {
17097 OPC_CheckPredicate, 206, 1, // 635: check predicate 206
17098 OPC_Decode, 140, 115, 217, 2, // 638: decode to FLE_H_INX using decoder 345
17099 // 638: }
17100 1, 8, // 643: case 0x1: {
17101 OPC_CheckPredicate, 206, 1, // 645: check predicate 206
17102 OPC_Decode, 158, 115, 217, 2, // 648: decode to FLT_H_INX using decoder 345
17103 // 648: }
17104 2, 0, // 653: case 0x2: {
17105 OPC_CheckPredicate, 206, 1, // 655: check predicate 206
17106 OPC_Decode, 255, 114, 217, 2, // 658: decode to FEQ_H_INX using decoder 345
17107 // 658: }
17108 // 658: } // switch Inst[14:12]
17109 // 658: }
17110 96, 43, // 663: case 0x60: {
17111 OPC_SwitchField, 20, 5, // 665: switch Inst[24:20] {
17112 0, 8, // 668: case 0x0: {
17113 OPC_CheckPredicate, 204, 1, // 670: check predicate 204
17114 OPC_Decode, 239, 114, 209, 2, // 673: decode to FCVT_W_S_INX using decoder 337
17115 // 673: }
17116 1, 8, // 678: case 0x1: {
17117 OPC_CheckPredicate, 204, 1, // 680: check predicate 204
17118 OPC_Decode, 231, 114, 209, 2, // 683: decode to FCVT_WU_S_INX using decoder 337
17119 // 683: }
17120 2, 8, // 688: case 0x2: {
17121 OPC_CheckPredicate, 209, 1, // 690: check predicate 209
17122 OPC_Decode, 201, 114, 209, 2, // 693: decode to FCVT_L_S_INX using decoder 337
17123 // 693: }
17124 3, 0, // 698: case 0x3: {
17125 OPC_CheckPredicate, 209, 1, // 700: check predicate 209
17126 OPC_Decode, 194, 114, 209, 2, // 703: decode to FCVT_LU_S_INX using decoder 337
17127 // 703: }
17128 // 703: } // switch Inst[24:20]
17129 // 703: }
17130 97, 43, // 708: case 0x61: {
17131 OPC_SwitchField, 20, 5, // 710: switch Inst[24:20] {
17132 0, 8, // 713: case 0x0: {
17133 OPC_CheckPredicate, 205, 1, // 715: check predicate 205
17134 OPC_Decode, 234, 114, 214, 2, // 718: decode to FCVT_W_D_INX using decoder 342
17135 // 718: }
17136 1, 8, // 723: case 0x1: {
17137 OPC_CheckPredicate, 205, 1, // 725: check predicate 205
17138 OPC_Decode, 226, 114, 214, 2, // 728: decode to FCVT_WU_D_INX using decoder 342
17139 // 728: }
17140 2, 8, // 733: case 0x2: {
17141 OPC_CheckPredicate, 210, 1, // 735: check predicate 210
17142 OPC_Decode, 196, 114, 214, 2, // 738: decode to FCVT_L_D_INX using decoder 342
17143 // 738: }
17144 3, 0, // 743: case 0x3: {
17145 OPC_CheckPredicate, 210, 1, // 745: check predicate 210
17146 OPC_Decode, 189, 114, 214, 2, // 748: decode to FCVT_LU_D_INX using decoder 342
17147 // 748: }
17148 // 748: } // switch Inst[24:20]
17149 // 748: }
17150 98, 43, // 753: case 0x62: {
17151 OPC_SwitchField, 20, 5, // 755: switch Inst[24:20] {
17152 0, 8, // 758: case 0x0: {
17153 OPC_CheckPredicate, 206, 1, // 760: check predicate 206
17154 OPC_Decode, 236, 114, 210, 2, // 763: decode to FCVT_W_H_INX using decoder 338
17155 // 763: }
17156 1, 8, // 768: case 0x1: {
17157 OPC_CheckPredicate, 206, 1, // 770: check predicate 206
17158 OPC_Decode, 228, 114, 210, 2, // 773: decode to FCVT_WU_H_INX using decoder 338
17159 // 773: }
17160 2, 8, // 778: case 0x2: {
17161 OPC_CheckPredicate, 211, 1, // 780: check predicate 211
17162 OPC_Decode, 198, 114, 210, 2, // 783: decode to FCVT_L_H_INX using decoder 338
17163 // 783: }
17164 3, 0, // 788: case 0x3: {
17165 OPC_CheckPredicate, 211, 1, // 790: check predicate 211
17166 OPC_Decode, 191, 114, 210, 2, // 793: decode to FCVT_LU_H_INX using decoder 338
17167 // 793: }
17168 // 793: } // switch Inst[24:20]
17169 // 793: }
17170 104, 43, // 798: case 0x68: {
17171 OPC_SwitchField, 20, 5, // 800: switch Inst[24:20] {
17172 0, 8, // 803: case 0x0: {
17173 OPC_CheckPredicate, 204, 1, // 805: check predicate 204
17174 OPC_Decode, 223, 114, 207, 2, // 808: decode to FCVT_S_W_INX using decoder 335
17175 // 808: }
17176 1, 8, // 813: case 0x1: {
17177 OPC_CheckPredicate, 204, 1, // 815: check predicate 204
17178 OPC_Decode, 222, 114, 207, 2, // 818: decode to FCVT_S_WU_INX using decoder 335
17179 // 818: }
17180 2, 8, // 823: case 0x2: {
17181 OPC_CheckPredicate, 209, 1, // 825: check predicate 209
17182 OPC_Decode, 218, 114, 207, 2, // 828: decode to FCVT_S_L_INX using decoder 335
17183 // 828: }
17184 3, 0, // 833: case 0x3: {
17185 OPC_CheckPredicate, 209, 1, // 835: check predicate 209
17186 OPC_Decode, 217, 114, 207, 2, // 838: decode to FCVT_S_LU_INX using decoder 335
17187 // 838: }
17188 // 838: } // switch Inst[24:20]
17189 // 838: }
17190 105, 43, // 843: case 0x69: {
17191 OPC_SwitchField, 20, 5, // 845: switch Inst[24:20] {
17192 0, 8, // 848: case 0x0: {
17193 OPC_CheckPredicate, 205, 1, // 850: check predicate 205
17194 OPC_Decode, 173, 114, 214, 2, // 853: decode to FCVT_D_W_INX using decoder 342
17195 // 853: }
17196 1, 8, // 858: case 0x1: {
17197 OPC_CheckPredicate, 205, 1, // 860: check predicate 205
17198 OPC_Decode, 171, 114, 214, 2, // 863: decode to FCVT_D_WU_INX using decoder 342
17199 // 863: }
17200 2, 8, // 868: case 0x2: {
17201 OPC_CheckPredicate, 210, 1, // 870: check predicate 210
17202 OPC_Decode, 163, 114, 214, 2, // 873: decode to FCVT_D_L_INX using decoder 342
17203 // 873: }
17204 3, 0, // 878: case 0x3: {
17205 OPC_CheckPredicate, 210, 1, // 880: check predicate 210
17206 OPC_Decode, 162, 114, 214, 2, // 883: decode to FCVT_D_LU_INX using decoder 342
17207 // 883: }
17208 // 883: } // switch Inst[24:20]
17209 // 883: }
17210 106, 43, // 888: case 0x6a: {
17211 OPC_SwitchField, 20, 5, // 890: switch Inst[24:20] {
17212 0, 8, // 893: case 0x0: {
17213 OPC_CheckPredicate, 206, 1, // 895: check predicate 206
17214 OPC_Decode, 187, 114, 212, 2, // 898: decode to FCVT_H_W_INX using decoder 340
17215 // 898: }
17216 1, 8, // 903: case 0x1: {
17217 OPC_CheckPredicate, 206, 1, // 905: check predicate 206
17218 OPC_Decode, 186, 114, 212, 2, // 908: decode to FCVT_H_WU_INX using decoder 340
17219 // 908: }
17220 2, 8, // 913: case 0x2: {
17221 OPC_CheckPredicate, 211, 1, // 915: check predicate 211
17222 OPC_Decode, 180, 114, 212, 2, // 918: decode to FCVT_H_L_INX using decoder 340
17223 // 918: }
17224 3, 0, // 923: case 0x3: {
17225 OPC_CheckPredicate, 211, 1, // 925: check predicate 211
17226 OPC_Decode, 179, 114, 212, 2, // 928: decode to FCVT_H_LU_INX using decoder 340
17227 // 928: }
17228 // 928: } // switch Inst[24:20]
17229 // 928: }
17230 112, 16, // 933: case 0x70: {
17231 OPC_CheckPredicate, 204, 1, // 935: check predicate 204
17232 OPC_CheckField, 20, 5, 0, // 938: check Inst[24:20] == 0x0
17233 OPC_CheckField, 12, 3, 1, // 942: check Inst[14:12] == 0x1
17234 OPC_Decode, 154, 114, 218, 2, // 946: decode to FCLASS_S_INX using decoder 346
17235 // 946: }
17236 113, 15, // 951: case 0x71: {
17237 OPC_CheckPredicate, 205, 1, // 953: check predicate 205
17238 OPC_CheckField, 20, 5, 0, // 956: check Inst[24:20] == 0x0
17239 OPC_CheckField, 12, 3, 1, // 960: check Inst[14:12] == 0x1
17240 OPC_Decode, 149, 114, 17, // 964: decode to FCLASS_D_INX using decoder 17
17241 // 964: }
17242 114, 0, // 968: case 0x72: {
17243 OPC_CheckPredicate, 206, 1, // 970: check predicate 206
17244 OPC_CheckField, 20, 5, 0, // 973: check Inst[24:20] == 0x0
17245 OPC_CheckField, 12, 3, 1, // 977: check Inst[14:12] == 0x1
17246 OPC_Decode, 151, 114, 219, 2, // 981: decode to FCLASS_H_INX using decoder 347
17247 // 981: }
17248 // 981: } // switch Inst[31:25]
17249 // 981: }
17250 // 981: } // switch Inst[6:0]
17251};
17252// Handling 348 cases.
17253template <typename InsnType>
17254static std::enable_if_t<InsnBitWidth<InsnType> == 32, DecodeStatus>
17255decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
17256 DecodeComplete = true;
17257 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
17258 TmpType tmp;
17259 switch (Idx) {
17260 default: llvm_unreachable("Invalid decoder index!");
17261 case 0:
17262 tmp = fieldFromInstruction(insn, 7, 5);
17263 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17264 tmp = fieldFromInstruction(insn, 15, 5);
17265 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17266 tmp = fieldFromInstruction(insn, 20, 12);
17267 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17268 return S;
17269 case 1:
17270 tmp = fieldFromInstruction(insn, 7, 5);
17271 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17272 tmp = fieldFromInstruction(insn, 15, 5);
17273 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17274 tmp = fieldFromInstruction(insn, 25, 1);
17275 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17276 return S;
17277 case 2:
17278 tmp = fieldFromInstruction(insn, 7, 5);
17279 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(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 return S;
17283 case 3:
17284 tmp = fieldFromInstruction(insn, 7, 5);
17285 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17286 tmp = fieldFromInstruction(insn, 15, 5);
17287 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17288 tmp = fieldFromInstruction(insn, 20, 5);
17289 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(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 4:
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 tmp = fieldFromInstruction(insn, 20, 5);
17299 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17300 tmp = fieldFromInstruction(insn, 25, 1);
17301 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17302 return S;
17303 case 5:
17304 tmp = fieldFromInstruction(insn, 7, 5);
17305 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17306 tmp = fieldFromInstruction(insn, 15, 5);
17307 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17308 return S;
17309 case 6:
17310 tmp = fieldFromInstruction(insn, 7, 5);
17311 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(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 return S;
17315 case 7:
17316 tmp = fieldFromInstruction(insn, 7, 5);
17317 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17318 tmp = fieldFromInstruction(insn, 15, 5);
17319 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17320 return S;
17321 case 8:
17322 tmp = fieldFromInstruction(insn, 7, 5);
17323 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17324 tmp = fieldFromInstruction(insn, 15, 5);
17325 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17326 tmp = fieldFromInstruction(insn, 20, 12);
17327 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17328 return S;
17329 case 9:
17330 tmp = fieldFromInstruction(insn, 7, 5);
17331 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17332 tmp = fieldFromInstruction(insn, 15, 5);
17333 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17334 tmp = fieldFromInstruction(insn, 20, 12);
17335 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17336 return S;
17337 case 10:
17338 tmp = fieldFromInstruction(insn, 7, 5);
17339 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 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 11:
17346 tmp = fieldFromInstruction(insn, 7, 5);
17347 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 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 12:
17354 tmp = fieldFromInstruction(insn, 7, 5);
17355 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 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, 5);
17359 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17360 tmp = fieldFromInstruction(insn, 29, 3);
17361 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17362 tmp = fieldFromInstruction(insn, 25, 1);
17363 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17364 return S;
17365 case 13:
17366 tmp = fieldFromInstruction(insn, 24, 4);
17367 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17368 tmp = fieldFromInstruction(insn, 20, 4);
17369 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17370 return S;
17371 case 14:
17372 return S;
17373 case 15:
17374 tmp = fieldFromInstruction(insn, 15, 5);
17375 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17376 return S;
17377 case 16:
17378 tmp = fieldFromInstruction(insn, 7, 5);
17379 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17380 tmp = fieldFromInstruction(insn, 15, 5);
17381 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17382 tmp = fieldFromInstruction(insn, 20, 6);
17383 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17384 return S;
17385 case 17:
17386 tmp = fieldFromInstruction(insn, 7, 5);
17387 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17388 tmp = fieldFromInstruction(insn, 15, 5);
17389 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17390 return S;
17391 case 18:
17392 tmp = fieldFromInstruction(insn, 7, 5);
17393 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17394 tmp = fieldFromInstruction(insn, 15, 5);
17395 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17396 tmp = fieldFromInstruction(insn, 20, 4);
17397 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17398 return S;
17399 case 19:
17400 tmp = fieldFromInstruction(insn, 15, 5);
17401 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17402 tmp = fieldFromInstruction(insn, 25, 7) << 5;
17403 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17404 return S;
17405 case 20:
17406 tmp = fieldFromInstruction(insn, 7, 5);
17407 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17408 tmp = fieldFromInstruction(insn, 12, 20);
17409 if (!Check(S, decodeUImm20Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17410 return S;
17411 case 21:
17412 tmp = fieldFromInstruction(insn, 7, 5);
17413 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17414 tmp = fieldFromInstruction(insn, 15, 5);
17415 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17416 tmp = fieldFromInstruction(insn, 20, 5);
17417 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17418 return S;
17419 case 22:
17420 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17421 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17422 tmp = fieldFromInstruction(insn, 15, 5);
17423 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17424 tmp = fieldFromInstruction(insn, 20, 4);
17425 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17426 return S;
17427 case 23:
17428 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17429 if (!Check(S, DecodeGPRPairRegisterClass(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 24:
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, 5);
17441 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17442 return S;
17443 case 25:
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, 6);
17449 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17450 return S;
17451 case 26:
17452 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17453 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17454 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17455 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17456 tmp = fieldFromInstruction(insn, 15, 5);
17457 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17458 tmp = fieldFromInstruction(insn, 20, 5);
17459 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17460 return S;
17461 case 27:
17462 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17463 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17464 tmp = 0x0;
17465 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
17466 tmp |= fieldFromInstruction(insn, 16, 9);
17467 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17468 return S;
17469 case 28:
17470 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17471 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17472 tmp = fieldFromInstruction(insn, 16, 8);
17473 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17474 return S;
17475 case 29:
17476 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17477 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17478 tmp = 0x0;
17479 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
17480 tmp |= fieldFromInstruction(insn, 24, 1);
17481 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17482 return S;
17483 case 30:
17484 tmp = fieldFromInstruction(insn, 7, 5);
17485 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17486 tmp = fieldFromInstruction(insn, 15, 5);
17487 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17488 tmp = fieldFromInstruction(insn, 20, 3);
17489 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17490 return S;
17491 case 31:
17492 tmp = fieldFromInstruction(insn, 7, 5);
17493 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17494 tmp = fieldFromInstruction(insn, 15, 5);
17495 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17496 tmp = fieldFromInstruction(insn, 20, 5);
17497 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17498 return S;
17499 case 32:
17500 tmp = fieldFromInstruction(insn, 7, 5);
17501 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17502 tmp = 0x0;
17503 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
17504 tmp |= fieldFromInstruction(insn, 16, 9);
17505 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17506 return S;
17507 case 33:
17508 tmp = fieldFromInstruction(insn, 7, 5);
17509 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17510 tmp = fieldFromInstruction(insn, 16, 8);
17511 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17512 return S;
17513 case 34:
17514 tmp = fieldFromInstruction(insn, 7, 5);
17515 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17516 tmp = 0x0;
17517 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
17518 tmp |= fieldFromInstruction(insn, 24, 1);
17519 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17520 return S;
17521 case 35:
17522 tmp = fieldFromInstruction(insn, 7, 5);
17523 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17524 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17525 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17526 tmp = fieldFromInstruction(insn, 20, 4);
17527 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17528 return S;
17529 case 36:
17530 tmp = fieldFromInstruction(insn, 7, 5);
17531 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17532 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17533 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17534 tmp = fieldFromInstruction(insn, 20, 5);
17535 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17536 return S;
17537 case 37:
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, 6);
17543 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17544 return S;
17545 case 38:
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, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17552 return S;
17553 case 39:
17554 tmp = fieldFromInstruction(insn, 7, 5);
17555 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17556 tmp = fieldFromInstruction(insn, 15, 5);
17557 if (!Check(S, DecodeGPRRegisterClass(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 40:
17562 tmp = fieldFromInstruction(insn, 7, 5);
17563 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17564 tmp = fieldFromInstruction(insn, 15, 5);
17565 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17566 tmp = fieldFromInstruction(insn, 20, 4);
17567 if (!Check(S, decodeUImmPlus1Operand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17568 return S;
17569 case 41:
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, 5);
17575 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17576 return S;
17577 case 42:
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, 6);
17583 if (!Check(S, decodeUImmPlus1Operand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17584 return S;
17585 case 43:
17586 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17587 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17588 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17589 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17590 tmp = fieldFromInstruction(insn, 20, 3);
17591 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17592 return S;
17593 case 44:
17594 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17595 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17596 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17597 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17598 tmp = fieldFromInstruction(insn, 20, 4);
17599 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17600 return S;
17601 case 45:
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, 5);
17607 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17608 return S;
17609 case 46:
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, 5);
17615 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17616 return S;
17617 case 47:
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 return S;
17623 case 48:
17624 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17625 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17626 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17627 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17628 tmp = fieldFromInstruction(insn, 20, 4);
17629 if (!Check(S, decodeUImmPlus1Operand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17630 return S;
17631 case 49:
17632 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17633 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17634 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17635 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17636 tmp = fieldFromInstruction(insn, 20, 5);
17637 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17638 return S;
17639 case 50:
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, 21, 4) << 1;
17645 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17646 return S;
17647 case 51:
17648 tmp = fieldFromInstruction(insn, 20, 5);
17649 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17650 tmp = fieldFromInstruction(insn, 15, 5);
17651 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17652 tmp = 0x0;
17653 tmp |= fieldFromInstruction(insn, 7, 5);
17654 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17655 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17656 return S;
17657 case 52:
17658 tmp = fieldFromInstruction(insn, 20, 5);
17659 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17660 tmp = fieldFromInstruction(insn, 15, 5);
17661 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17662 tmp = 0x0;
17663 tmp |= fieldFromInstruction(insn, 7, 5);
17664 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17665 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17666 return S;
17667 case 53:
17668 tmp = fieldFromInstruction(insn, 20, 5);
17669 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17670 tmp = fieldFromInstruction(insn, 15, 5);
17671 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17672 tmp = 0x0;
17673 tmp |= fieldFromInstruction(insn, 7, 5);
17674 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17675 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17676 return S;
17677 case 54:
17678 tmp = fieldFromInstruction(insn, 20, 5);
17679 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17680 tmp = fieldFromInstruction(insn, 15, 5);
17681 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17682 tmp = 0x0;
17683 tmp |= fieldFromInstruction(insn, 7, 5);
17684 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17685 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17686 return S;
17687 case 55:
17688 tmp = fieldFromInstruction(insn, 20, 5);
17689 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17690 tmp = fieldFromInstruction(insn, 15, 5);
17691 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17692 tmp = 0x0;
17693 tmp |= fieldFromInstruction(insn, 7, 5);
17694 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17695 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17696 return S;
17697 case 56:
17698 tmp = fieldFromInstruction(insn, 7, 5);
17699 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17700 tmp = fieldFromInstruction(insn, 20, 5);
17701 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17702 tmp = fieldFromInstruction(insn, 15, 5);
17703 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17704 return S;
17705 case 57:
17706 tmp = fieldFromInstruction(insn, 7, 5);
17707 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17708 tmp = fieldFromInstruction(insn, 7, 5);
17709 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17710 tmp = fieldFromInstruction(insn, 20, 5);
17711 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17712 tmp = fieldFromInstruction(insn, 15, 5);
17713 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17714 return S;
17715 case 58:
17716 tmp = fieldFromInstruction(insn, 7, 5);
17717 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17718 tmp = fieldFromInstruction(insn, 7, 5);
17719 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17720 tmp = fieldFromInstruction(insn, 20, 5);
17721 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17722 tmp = fieldFromInstruction(insn, 15, 5);
17723 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17724 return S;
17725 case 59:
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 60:
17732 tmp = fieldFromInstruction(insn, 7, 5);
17733 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17734 tmp = fieldFromInstruction(insn, 15, 5);
17735 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17736 tmp = fieldFromInstruction(insn, 20, 5);
17737 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17738 tmp = fieldFromInstruction(insn, 30, 2);
17739 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17740 return S;
17741 case 61:
17742 tmp = fieldFromInstruction(insn, 7, 5);
17743 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17744 tmp = fieldFromInstruction(insn, 7, 5);
17745 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17746 tmp = fieldFromInstruction(insn, 15, 5);
17747 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17748 tmp = fieldFromInstruction(insn, 20, 5);
17749 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17750 return S;
17751 case 62:
17752 tmp = fieldFromInstruction(insn, 7, 5);
17753 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17754 tmp = fieldFromInstruction(insn, 15, 5);
17755 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17756 tmp = fieldFromInstruction(insn, 20, 5);
17757 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17758 tmp = fieldFromInstruction(insn, 27, 5);
17759 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17760 tmp = fieldFromInstruction(insn, 12, 3);
17761 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17762 return S;
17763 case 63:
17764 tmp = fieldFromInstruction(insn, 7, 5);
17765 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17766 tmp = fieldFromInstruction(insn, 15, 5);
17767 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17768 tmp = fieldFromInstruction(insn, 20, 5);
17769 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17770 tmp = fieldFromInstruction(insn, 27, 5);
17771 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17772 tmp = fieldFromInstruction(insn, 12, 3);
17773 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17774 return S;
17775 case 64:
17776 tmp = fieldFromInstruction(insn, 7, 5);
17777 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17778 tmp = fieldFromInstruction(insn, 15, 5);
17779 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17780 tmp = fieldFromInstruction(insn, 20, 5);
17781 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17782 tmp = fieldFromInstruction(insn, 27, 5);
17783 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17784 tmp = fieldFromInstruction(insn, 12, 3);
17785 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17786 return S;
17787 case 65:
17788 tmp = fieldFromInstruction(insn, 7, 5);
17789 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17790 tmp = fieldFromInstruction(insn, 15, 5);
17791 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17792 tmp = fieldFromInstruction(insn, 20, 5);
17793 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17794 tmp = fieldFromInstruction(insn, 27, 5);
17795 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17796 tmp = fieldFromInstruction(insn, 12, 3);
17797 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17798 return S;
17799 case 66:
17800 tmp = fieldFromInstruction(insn, 7, 5);
17801 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17802 tmp = fieldFromInstruction(insn, 15, 5);
17803 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17804 tmp = fieldFromInstruction(insn, 20, 5);
17805 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17806 tmp = fieldFromInstruction(insn, 12, 3);
17807 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17808 return S;
17809 case 67:
17810 tmp = fieldFromInstruction(insn, 7, 5);
17811 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17812 tmp = fieldFromInstruction(insn, 15, 5);
17813 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17814 tmp = fieldFromInstruction(insn, 20, 5);
17815 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17816 tmp = fieldFromInstruction(insn, 12, 3);
17817 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17818 return S;
17819 case 68:
17820 tmp = fieldFromInstruction(insn, 7, 5);
17821 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17822 tmp = fieldFromInstruction(insn, 15, 5);
17823 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17824 tmp = fieldFromInstruction(insn, 20, 5);
17825 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17826 tmp = fieldFromInstruction(insn, 12, 3);
17827 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17828 return S;
17829 case 69:
17830 tmp = fieldFromInstruction(insn, 7, 5);
17831 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17832 tmp = fieldFromInstruction(insn, 15, 5);
17833 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17834 tmp = fieldFromInstruction(insn, 20, 5);
17835 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17836 tmp = fieldFromInstruction(insn, 12, 3);
17837 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17838 return S;
17839 case 70:
17840 tmp = fieldFromInstruction(insn, 7, 5);
17841 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17842 tmp = fieldFromInstruction(insn, 15, 5);
17843 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17844 tmp = fieldFromInstruction(insn, 20, 5);
17845 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17846 return S;
17847 case 71:
17848 tmp = fieldFromInstruction(insn, 7, 5);
17849 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17850 tmp = fieldFromInstruction(insn, 15, 5);
17851 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17852 tmp = fieldFromInstruction(insn, 20, 5);
17853 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17854 return S;
17855 case 72:
17856 tmp = fieldFromInstruction(insn, 7, 5);
17857 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17858 tmp = fieldFromInstruction(insn, 15, 5);
17859 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17860 tmp = fieldFromInstruction(insn, 20, 5);
17861 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17862 return S;
17863 case 73:
17864 tmp = fieldFromInstruction(insn, 7, 5);
17865 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17866 tmp = fieldFromInstruction(insn, 15, 5);
17867 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17868 tmp = fieldFromInstruction(insn, 20, 5);
17869 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17870 return S;
17871 case 74:
17872 tmp = fieldFromInstruction(insn, 7, 5);
17873 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17874 tmp = fieldFromInstruction(insn, 15, 5);
17875 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17876 tmp = fieldFromInstruction(insn, 12, 3);
17877 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17878 return S;
17879 case 75:
17880 tmp = fieldFromInstruction(insn, 7, 5);
17881 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17882 tmp = fieldFromInstruction(insn, 15, 5);
17883 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17884 tmp = fieldFromInstruction(insn, 12, 3);
17885 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17886 return S;
17887 case 76:
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_Q, 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 77:
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_F, 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 78:
17904 tmp = fieldFromInstruction(insn, 7, 5);
17905 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17906 tmp = fieldFromInstruction(insn, 15, 5);
17907 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 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 79:
17912 tmp = fieldFromInstruction(insn, 7, 5);
17913 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17914 tmp = fieldFromInstruction(insn, 15, 5);
17915 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 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 80:
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_Q, 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 81:
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_D, 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 82:
17936 tmp = fieldFromInstruction(insn, 7, 5);
17937 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17938 tmp = fieldFromInstruction(insn, 15, 5);
17939 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 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 83:
17944 tmp = fieldFromInstruction(insn, 7, 5);
17945 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 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 84:
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_Q, 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 85:
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_H, 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 86:
17968 tmp = fieldFromInstruction(insn, 7, 5);
17969 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17970 tmp = fieldFromInstruction(insn, 15, 5);
17971 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 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 87:
17976 tmp = fieldFromInstruction(insn, 7, 5);
17977 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17978 tmp = fieldFromInstruction(insn, 15, 5);
17979 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 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 88:
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_H, 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 89:
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_Q, 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 90:
18000 tmp = fieldFromInstruction(insn, 7, 5);
18001 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18002 tmp = fieldFromInstruction(insn, 15, 5);
18003 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18004 tmp = fieldFromInstruction(insn, 20, 5);
18005 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18006 return S;
18007 case 91:
18008 tmp = fieldFromInstruction(insn, 7, 5);
18009 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18010 tmp = fieldFromInstruction(insn, 15, 5);
18011 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18012 tmp = fieldFromInstruction(insn, 20, 5);
18013 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18014 return S;
18015 case 92:
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_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18020 tmp = fieldFromInstruction(insn, 20, 5);
18021 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18022 return S;
18023 case 93:
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_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18028 tmp = fieldFromInstruction(insn, 20, 5);
18029 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18030 return S;
18031 case 94:
18032 tmp = fieldFromInstruction(insn, 7, 5);
18033 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18034 tmp = fieldFromInstruction(insn, 15, 5);
18035 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18036 tmp = fieldFromInstruction(insn, 20, 5);
18037 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18038 return S;
18039 case 95:
18040 tmp = fieldFromInstruction(insn, 7, 5);
18041 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18042 tmp = fieldFromInstruction(insn, 15, 5);
18043 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18044 tmp = fieldFromInstruction(insn, 20, 5);
18045 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18046 return S;
18047 case 96:
18048 tmp = fieldFromInstruction(insn, 7, 5);
18049 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18050 tmp = fieldFromInstruction(insn, 15, 5);
18051 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18052 tmp = fieldFromInstruction(insn, 12, 3);
18053 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18054 return S;
18055 case 97:
18056 tmp = fieldFromInstruction(insn, 7, 5);
18057 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18058 tmp = fieldFromInstruction(insn, 15, 5);
18059 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18060 tmp = fieldFromInstruction(insn, 12, 3);
18061 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18062 return S;
18063 case 98:
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_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18068 tmp = 0x1;
18069 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18070 return S;
18071 case 99:
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_H, 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 100:
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_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18084 tmp = fieldFromInstruction(insn, 12, 3);
18085 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18086 return S;
18087 case 101:
18088 tmp = fieldFromInstruction(insn, 7, 5);
18089 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18090 tmp = fieldFromInstruction(insn, 15, 5);
18091 if (!Check(S, DecodeGPRRegisterClass(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 102:
18096 tmp = fieldFromInstruction(insn, 7, 5);
18097 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18098 tmp = fieldFromInstruction(insn, 15, 5);
18099 if (!Check(S, DecodeGPRRegisterClass(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 103:
18104 tmp = fieldFromInstruction(insn, 7, 5);
18105 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 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 104:
18112 tmp = fieldFromInstruction(insn, 7, 5);
18113 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 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 105:
18120 tmp = fieldFromInstruction(insn, 7, 5);
18121 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18122 tmp = fieldFromInstruction(insn, 15, 5);
18123 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18124 return S;
18125 case 106:
18126 tmp = fieldFromInstruction(insn, 7, 5);
18127 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18128 tmp = fieldFromInstruction(insn, 15, 5);
18129 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18130 return S;
18131 case 107:
18132 tmp = fieldFromInstruction(insn, 7, 5);
18133 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18134 tmp = fieldFromInstruction(insn, 15, 5);
18135 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18136 return S;
18137 case 108:
18138 tmp = fieldFromInstruction(insn, 7, 5);
18139 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18140 tmp = fieldFromInstruction(insn, 15, 5);
18141 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18142 return S;
18143 case 109:
18144 tmp = fieldFromInstruction(insn, 7, 5);
18145 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18146 tmp = fieldFromInstruction(insn, 15, 5);
18147 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18148 return S;
18149 case 110:
18150 tmp = fieldFromInstruction(insn, 7, 5);
18151 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18152 tmp = fieldFromInstruction(insn, 15, 5);
18153 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18154 return S;
18155 case 111:
18156 tmp = fieldFromInstruction(insn, 7, 5);
18157 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18158 tmp = fieldFromInstruction(insn, 15, 5);
18159 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18160 return S;
18161 case 112:
18162 tmp = fieldFromInstruction(insn, 7, 5);
18163 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18164 tmp = fieldFromInstruction(insn, 15, 5);
18165 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18166 return S;
18167 case 113:
18168 tmp = fieldFromInstruction(insn, 7, 5);
18169 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18170 tmp = fieldFromInstruction(insn, 15, 5);
18171 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18172 return S;
18173 case 114:
18174 tmp = fieldFromInstruction(insn, 7, 5);
18175 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18176 tmp = fieldFromInstruction(insn, 15, 5);
18177 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18178 return S;
18179 case 115:
18180 tmp = fieldFromInstruction(insn, 7, 5);
18181 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18182 tmp = fieldFromInstruction(insn, 15, 5);
18183 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18184 return S;
18185 case 116:
18186 tmp = fieldFromInstruction(insn, 7, 5);
18187 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18188 tmp = fieldFromInstruction(insn, 20, 5);
18189 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18190 tmp = fieldFromInstruction(insn, 15, 5);
18191 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18192 tmp = fieldFromInstruction(insn, 25, 1);
18193 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18194 return S;
18195 case 117:
18196 tmp = fieldFromInstruction(insn, 7, 5);
18197 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18198 tmp = fieldFromInstruction(insn, 20, 5);
18199 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18200 tmp = fieldFromInstruction(insn, 15, 5);
18201 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18202 tmp = 0x0;
18203 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18204 return S;
18205 case 118:
18206 tmp = fieldFromInstruction(insn, 7, 5);
18207 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18208 tmp = fieldFromInstruction(insn, 20, 5);
18209 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18210 tmp = fieldFromInstruction(insn, 15, 5);
18211 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18212 return S;
18213 case 119:
18214 tmp = fieldFromInstruction(insn, 7, 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 return S;
18219 case 120:
18220 tmp = fieldFromInstruction(insn, 7, 5);
18221 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
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, 15, 5);
18225 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18226 tmp = fieldFromInstruction(insn, 20, 5);
18227 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18228 return S;
18229 case 121:
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, 7, 5);
18233 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18234 tmp = fieldFromInstruction(insn, 15, 5);
18235 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18236 tmp = fieldFromInstruction(insn, 20, 5);
18237 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18238 tmp = 0x0;
18239 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18240 return S;
18241 case 122:
18242 tmp = fieldFromInstruction(insn, 7, 5);
18243 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18244 tmp = fieldFromInstruction(insn, 7, 5);
18245 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18246 tmp = fieldFromInstruction(insn, 20, 5);
18247 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18248 tmp = fieldFromInstruction(insn, 15, 5);
18249 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18250 tmp = fieldFromInstruction(insn, 25, 1);
18251 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18252 return S;
18253 case 123:
18254 tmp = fieldFromInstruction(insn, 7, 5);
18255 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18256 tmp = fieldFromInstruction(insn, 20, 5);
18257 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18258 return S;
18259 case 124:
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, 25, 1);
18265 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18266 return S;
18267 case 125:
18268 tmp = fieldFromInstruction(insn, 7, 5);
18269 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18270 tmp = fieldFromInstruction(insn, 7, 5);
18271 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18272 tmp = fieldFromInstruction(insn, 15, 5);
18273 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18274 tmp = fieldFromInstruction(insn, 20, 5);
18275 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18276 tmp = fieldFromInstruction(insn, 25, 1);
18277 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18278 return S;
18279 case 126:
18280 tmp = fieldFromInstruction(insn, 7, 5);
18281 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18282 tmp = fieldFromInstruction(insn, 20, 5);
18283 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18284 return S;
18285 case 127:
18286 tmp = fieldFromInstruction(insn, 7, 5);
18287 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18288 tmp = fieldFromInstruction(insn, 20, 5);
18289 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18290 tmp = fieldFromInstruction(insn, 25, 1);
18291 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18292 return S;
18293 case 128:
18294 tmp = fieldFromInstruction(insn, 7, 5);
18295 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18296 tmp = fieldFromInstruction(insn, 20, 5);
18297 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18298 return S;
18299 case 129:
18300 tmp = fieldFromInstruction(insn, 7, 5);
18301 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18302 tmp = fieldFromInstruction(insn, 25, 1);
18303 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18304 return S;
18305 case 130:
18306 tmp = fieldFromInstruction(insn, 7, 5);
18307 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18308 tmp = fieldFromInstruction(insn, 20, 5);
18309 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18310 tmp = fieldFromInstruction(insn, 15, 5);
18311 if (!Check(S, decodeSImmOperand<5>(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 131:
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, decodeUImmOperand<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 132:
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, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18332 tmp = 0x0;
18333 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18334 return S;
18335 case 133:
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 return S;
18343 case 134:
18344 tmp = fieldFromInstruction(insn, 7, 5);
18345 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18346 tmp = fieldFromInstruction(insn, 20, 5);
18347 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18348 tmp = 0x0;
18349 tmp |= fieldFromInstruction(insn, 15, 5);
18350 tmp |= fieldFromInstruction(insn, 26, 1) << 5;
18351 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18352 tmp = fieldFromInstruction(insn, 25, 1);
18353 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18354 return S;
18355 case 135:
18356 tmp = fieldFromInstruction(insn, 7, 5);
18357 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18358 tmp = fieldFromInstruction(insn, 15, 5);
18359 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18360 return S;
18361 case 136:
18362 tmp = fieldFromInstruction(insn, 7, 5);
18363 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18364 tmp = fieldFromInstruction(insn, 20, 5);
18365 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18366 return S;
18367 case 137:
18368 tmp = fieldFromInstruction(insn, 7, 5);
18369 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18370 tmp = fieldFromInstruction(insn, 20, 5);
18371 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18372 return S;
18373 case 138:
18374 tmp = fieldFromInstruction(insn, 7, 5);
18375 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18376 tmp = fieldFromInstruction(insn, 20, 5);
18377 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18378 return S;
18379 case 139:
18380 tmp = fieldFromInstruction(insn, 7, 5);
18381 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18382 tmp = fieldFromInstruction(insn, 20, 5);
18383 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18384 tmp = fieldFromInstruction(insn, 15, 5);
18385 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18386 tmp = fieldFromInstruction(insn, 25, 1);
18387 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18388 return S;
18389 case 140:
18390 tmp = fieldFromInstruction(insn, 7, 5);
18391 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18392 tmp = fieldFromInstruction(insn, 20, 5);
18393 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18394 tmp = fieldFromInstruction(insn, 15, 5);
18395 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18396 tmp = 0x0;
18397 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18398 return S;
18399 case 141:
18400 tmp = fieldFromInstruction(insn, 7, 5);
18401 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18402 tmp = fieldFromInstruction(insn, 20, 5);
18403 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18404 tmp = fieldFromInstruction(insn, 15, 5);
18405 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18406 return S;
18407 case 142:
18408 tmp = fieldFromInstruction(insn, 7, 5);
18409 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18410 tmp = fieldFromInstruction(insn, 7, 5);
18411 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18412 tmp = fieldFromInstruction(insn, 20, 5);
18413 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18414 tmp = fieldFromInstruction(insn, 15, 5);
18415 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18416 tmp = fieldFromInstruction(insn, 25, 1);
18417 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18418 return S;
18419 case 143:
18420 tmp = fieldFromInstruction(insn, 7, 5);
18421 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18422 tmp = fieldFromInstruction(insn, 20, 5);
18423 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18424 tmp = fieldFromInstruction(insn, 15, 5);
18425 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18426 tmp = fieldFromInstruction(insn, 25, 1);
18427 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18428 return S;
18429 case 144:
18430 tmp = fieldFromInstruction(insn, 7, 5);
18431 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18432 tmp = fieldFromInstruction(insn, 7, 5);
18433 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18434 tmp = fieldFromInstruction(insn, 15, 5);
18435 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18436 return S;
18437 case 145:
18438 tmp = fieldFromInstruction(insn, 7, 5);
18439 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18440 tmp = fieldFromInstruction(insn, 20, 5);
18441 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18442 tmp = fieldFromInstruction(insn, 15, 5);
18443 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18444 tmp = 0x0;
18445 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18446 return S;
18447 case 146:
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 147:
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, 7, 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 = fieldFromInstruction(insn, 20, 5);
18461 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18462 tmp = fieldFromInstruction(insn, 25, 1);
18463 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18464 return S;
18465 case 148:
18466 tmp = fieldFromInstruction(insn, 7, 5);
18467 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18468 tmp = fieldFromInstruction(insn, 7, 5);
18469 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18470 tmp = fieldFromInstruction(insn, 15, 5);
18471 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18472 return S;
18473 case 149:
18474 tmp = fieldFromInstruction(insn, 7, 5);
18475 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18476 tmp = fieldFromInstruction(insn, 7, 5);
18477 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18478 tmp = fieldFromInstruction(insn, 15, 5);
18479 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18480 tmp = fieldFromInstruction(insn, 20, 5);
18481 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18482 tmp = fieldFromInstruction(insn, 25, 1);
18483 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18484 return S;
18485 case 150:
18486 tmp = fieldFromInstruction(insn, 7, 5);
18487 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18488 tmp = fieldFromInstruction(insn, 15, 5);
18489 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18490 tmp = fieldFromInstruction(insn, 20, 11);
18491 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18492 return S;
18493 case 151:
18494 tmp = fieldFromInstruction(insn, 7, 5);
18495 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18496 tmp = fieldFromInstruction(insn, 15, 5);
18497 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18498 tmp = fieldFromInstruction(insn, 20, 10);
18499 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18500 return S;
18501 case 152:
18502 tmp = fieldFromInstruction(insn, 15, 5);
18503 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18504 tmp = fieldFromInstruction(insn, 20, 5);
18505 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18506 tmp = 0x0;
18507 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18508 tmp |= fieldFromInstruction(insn, 8, 4);
18509 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18510 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18511 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18512 return S;
18513 case 153:
18514 tmp = fieldFromInstruction(insn, 15, 5);
18515 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18516 tmp = fieldFromInstruction(insn, 20, 5);
18517 if (!Check(S, decodeImmZibiOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18518 tmp = 0x0;
18519 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18520 tmp |= fieldFromInstruction(insn, 8, 4);
18521 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18522 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18523 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18524 return S;
18525 case 154:
18526 tmp = fieldFromInstruction(insn, 7, 5);
18527 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18528 tmp = 0x0;
18529 tmp |= fieldFromInstruction(insn, 12, 8) << 11;
18530 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
18531 tmp |= fieldFromInstruction(insn, 21, 10);
18532 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
18533 if (!Check(S, decodeSImmOperandAndLslN<21, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18534 return S;
18535 case 155:
18536 tmp = fieldFromInstruction(insn, 7, 5);
18537 if (!Check(S, DecodeSingleRegister<RISCV::X2, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18538 tmp = fieldFromInstruction(insn, 15, 5);
18539 if (!Check(S, DecodeSingleRegister<RISCV::X2, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18540 return S;
18541 case 156:
18542 tmp = fieldFromInstruction(insn, 15, 5);
18543 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18544 tmp = fieldFromInstruction(insn, 20, 5);
18545 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18546 return S;
18547 case 157:
18548 tmp = fieldFromInstruction(insn, 7, 5);
18549 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18550 tmp = fieldFromInstruction(insn, 20, 12);
18551 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18552 tmp = fieldFromInstruction(insn, 15, 5);
18553 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18554 return S;
18555 case 158:
18556 tmp = fieldFromInstruction(insn, 15, 5);
18557 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
18558 return S;
18559 case 159:
18560 tmp = fieldFromInstruction(insn, 7, 5);
18561 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
18562 return S;
18563 case 160:
18564 tmp = fieldFromInstruction(insn, 20, 5);
18565 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
18566 return S;
18567 case 161:
18568 tmp = fieldFromInstruction(insn, 7, 5);
18569 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18570 tmp = fieldFromInstruction(insn, 20, 12);
18571 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18572 tmp = fieldFromInstruction(insn, 15, 5);
18573 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18574 return S;
18575 case 162:
18576 tmp = fieldFromInstruction(insn, 7, 5);
18577 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18578 tmp = fieldFromInstruction(insn, 20, 5);
18579 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18580 tmp = fieldFromInstruction(insn, 15, 5);
18581 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18582 return S;
18583 case 163:
18584 tmp = fieldFromInstruction(insn, 7, 5);
18585 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18586 tmp = fieldFromInstruction(insn, 7, 5);
18587 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18588 tmp = fieldFromInstruction(insn, 20, 5);
18589 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18590 tmp = fieldFromInstruction(insn, 15, 5);
18591 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18592 return S;
18593 case 164:
18594 tmp = fieldFromInstruction(insn, 7, 5);
18595 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18596 tmp = fieldFromInstruction(insn, 7, 5);
18597 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18598 tmp = fieldFromInstruction(insn, 20, 5);
18599 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18600 return S;
18601 case 165:
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, 7, 5);
18605 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18606 tmp = fieldFromInstruction(insn, 20, 5);
18607 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18608 tmp = fieldFromInstruction(insn, 15, 5);
18609 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18610 return S;
18611 case 166:
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, 7, 5);
18615 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18616 tmp = fieldFromInstruction(insn, 23, 2) << 3;
18617 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18618 tmp = fieldFromInstruction(insn, 15, 5);
18619 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18620 tmp = fieldFromInstruction(insn, 20, 3) << 3;
18621 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18622 tmp = fieldFromInstruction(insn, 25, 1);
18623 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18624 return S;
18625 case 167:
18626 tmp = fieldFromInstruction(insn, 7, 5);
18627 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18628 tmp = fieldFromInstruction(insn, 15, 5);
18629 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18630 tmp = fieldFromInstruction(insn, 20, 5);
18631 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18632 return S;
18633 case 168:
18634 tmp = fieldFromInstruction(insn, 7, 5);
18635 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18636 tmp = fieldFromInstruction(insn, 15, 5);
18637 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18638 return S;
18639 case 169:
18640 tmp = fieldFromInstruction(insn, 7, 5);
18641 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18642 tmp = fieldFromInstruction(insn, 15, 5);
18643 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18644 tmp = fieldFromInstruction(insn, 20, 5);
18645 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18646 return S;
18647 case 170:
18648 tmp = fieldFromInstruction(insn, 7, 5);
18649 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18650 tmp = fieldFromInstruction(insn, 15, 5);
18651 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18652 tmp = fieldFromInstruction(insn, 20, 5);
18653 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18654 return S;
18655 case 171:
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, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18662 return S;
18663 case 172:
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 return S;
18669 case 173:
18670 tmp = fieldFromInstruction(insn, 7, 5);
18671 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18672 tmp = fieldFromInstruction(insn, 15, 5);
18673 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18674 tmp = fieldFromInstruction(insn, 20, 12);
18675 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18676 return S;
18677 case 174:
18678 tmp = fieldFromInstruction(insn, 7, 5);
18679 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18680 tmp = fieldFromInstruction(insn, 15, 5);
18681 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18682 tmp = fieldFromInstruction(insn, 20, 7);
18683 if (!Check(S, decodeUImm7EqXLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18684 return S;
18685 case 175:
18686 tmp = fieldFromInstruction(insn, 7, 5);
18687 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18688 tmp = fieldFromInstruction(insn, 15, 5);
18689 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18690 tmp = fieldFromInstruction(insn, 20, 9);
18691 if (!Check(S, DecodeYBNDSWImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18692 return S;
18693 case 176:
18694 tmp = fieldFromInstruction(insn, 7, 5);
18695 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18696 tmp = fieldFromInstruction(insn, 15, 5);
18697 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18698 tmp = fieldFromInstruction(insn, 20, 12);
18699 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18700 return S;
18701 case 177:
18702 tmp = fieldFromInstruction(insn, 20, 5);
18703 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18704 tmp = fieldFromInstruction(insn, 15, 5);
18705 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18706 tmp = 0x0;
18707 tmp |= fieldFromInstruction(insn, 7, 5);
18708 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18709 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18710 return S;
18711 case 178:
18712 tmp = fieldFromInstruction(insn, 7, 5);
18713 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18714 tmp = fieldFromInstruction(insn, 20, 12);
18715 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18716 tmp = fieldFromInstruction(insn, 15, 5);
18717 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18718 return S;
18719 case 179:
18720 tmp = fieldFromInstruction(insn, 7, 5);
18721 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18722 tmp = fieldFromInstruction(insn, 15, 5);
18723 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18724 tmp = fieldFromInstruction(insn, 20, 5);
18725 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18726 return S;
18727 case 180:
18728 tmp = fieldFromInstruction(insn, 7, 5);
18729 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18730 tmp = fieldFromInstruction(insn, 15, 5);
18731 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18732 tmp = fieldFromInstruction(insn, 20, 5);
18733 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18734 return S;
18735 case 181:
18736 tmp = fieldFromInstruction(insn, 7, 5);
18737 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(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 182:
18742 tmp = fieldFromInstruction(insn, 20, 5);
18743 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18744 tmp = 0x0;
18745 tmp |= fieldFromInstruction(insn, 7, 5);
18746 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18747 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18748 tmp = fieldFromInstruction(insn, 15, 5);
18749 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18750 return S;
18751 case 183:
18752 tmp = fieldFromInstruction(insn, 7, 5);
18753 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18754 tmp = fieldFromInstruction(insn, 12, 20);
18755 if (!Check(S, decodeUImm20Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18756 return S;
18757 case 184:
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, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18762 tmp = 0x0;
18763 tmp |= fieldFromInstruction(insn, 20, 5);
18764 tmp |= fieldFromInstruction(insn, 27, 5) << 5;
18765 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18766 return S;
18767 case 185:
18768 tmp = fieldFromInstruction(insn, 7, 5);
18769 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18770 tmp = fieldFromInstruction(insn, 15, 5);
18771 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18772 tmp = fieldFromInstruction(insn, 20, 5);
18773 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18774 tmp = fieldFromInstruction(insn, 27, 5);
18775 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18776 return S;
18777 case 186:
18778 tmp = fieldFromInstruction(insn, 7, 5);
18779 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18780 tmp = fieldFromInstruction(insn, 15, 5);
18781 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18782 tmp = fieldFromInstruction(insn, 20, 5);
18783 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18784 tmp = fieldFromInstruction(insn, 27, 5);
18785 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18786 tmp = fieldFromInstruction(insn, 12, 3);
18787 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18788 return S;
18789 case 187:
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 return S;
18797 case 188:
18798 tmp = fieldFromInstruction(insn, 7, 5);
18799 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18800 tmp = fieldFromInstruction(insn, 15, 5);
18801 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18802 tmp = fieldFromInstruction(insn, 20, 5);
18803 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18804 tmp = fieldFromInstruction(insn, 12, 3);
18805 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18806 return S;
18807 case 189:
18808 tmp = fieldFromInstruction(insn, 7, 5);
18809 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18810 tmp = fieldFromInstruction(insn, 15, 5);
18811 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18812 return S;
18813 case 190:
18814 tmp = fieldFromInstruction(insn, 7, 5);
18815 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18816 tmp = fieldFromInstruction(insn, 15, 5);
18817 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18818 tmp = fieldFromInstruction(insn, 20, 5);
18819 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18820 return S;
18821 case 191:
18822 tmp = fieldFromInstruction(insn, 7, 5);
18823 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18824 tmp = fieldFromInstruction(insn, 15, 5);
18825 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18826 tmp = fieldFromInstruction(insn, 20, 5);
18827 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18828 return S;
18829 case 192:
18830 tmp = fieldFromInstruction(insn, 7, 5);
18831 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18832 tmp = fieldFromInstruction(insn, 15, 3);
18833 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18834 return S;
18835 case 193:
18836 tmp = fieldFromInstruction(insn, 7, 3);
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, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18840 tmp = 0x0;
18841 tmp |= fieldFromInstruction(insn, 12, 3);
18842 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18843 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18844 return S;
18845 case 194:
18846 tmp = fieldFromInstruction(insn, 7, 5);
18847 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18848 tmp = fieldFromInstruction(insn, 15, 5);
18849 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18850 tmp = fieldFromInstruction(insn, 12, 3);
18851 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18852 return S;
18853 case 195:
18854 tmp = fieldFromInstruction(insn, 7, 5);
18855 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18856 tmp = fieldFromInstruction(insn, 15, 3);
18857 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18858 tmp = fieldFromInstruction(insn, 20, 3);
18859 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18860 tmp = 0x0;
18861 tmp |= fieldFromInstruction(insn, 18, 2);
18862 tmp |= fieldFromInstruction(insn, 23, 2) << 2;
18863 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18864 return S;
18865 case 196:
18866 tmp = fieldFromInstruction(insn, 7, 3);
18867 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18868 tmp = fieldFromInstruction(insn, 15, 3);
18869 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18870 return S;
18871 case 197:
18872 tmp = fieldFromInstruction(insn, 7, 3);
18873 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18874 tmp = fieldFromInstruction(insn, 15, 3);
18875 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18876 tmp = fieldFromInstruction(insn, 20, 3);
18877 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18878 return S;
18879 case 198:
18880 tmp = fieldFromInstruction(insn, 7, 5);
18881 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18882 tmp = fieldFromInstruction(insn, 15, 5);
18883 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18884 return S;
18885 case 199:
18886 tmp = fieldFromInstruction(insn, 7, 5);
18887 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18888 return S;
18889 case 200:
18890 tmp = fieldFromInstruction(insn, 7, 5);
18891 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18892 tmp = fieldFromInstruction(insn, 15, 5);
18893 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18894 tmp = fieldFromInstruction(insn, 20, 3);
18895 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18896 return S;
18897 case 201:
18898 tmp = fieldFromInstruction(insn, 7, 5);
18899 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18900 tmp = fieldFromInstruction(insn, 15, 5);
18901 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18902 tmp = 0x0;
18903 tmp |= fieldFromInstruction(insn, 12, 3);
18904 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18905 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18906 return S;
18907 case 202:
18908 tmp = fieldFromInstruction(insn, 7, 5);
18909 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18910 tmp = 0x0;
18911 tmp |= fieldFromInstruction(insn, 14, 1);
18912 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
18913 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
18914 tmp |= fieldFromInstruction(insn, 20, 1) << 11;
18915 tmp |= fieldFromInstruction(insn, 21, 10) << 1;
18916 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
18917 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18918 return S;
18919 case 203:
18920 tmp = fieldFromInstruction(insn, 20, 5);
18921 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18922 tmp = 0x0;
18923 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18924 tmp |= fieldFromInstruction(insn, 8, 4);
18925 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
18926 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
18927 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18928 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18929 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18930 return S;
18931 case 204:
18932 tmp = fieldFromInstruction(insn, 20, 5);
18933 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18934 tmp = 0x0;
18935 tmp |= fieldFromInstruction(insn, 7, 1) << 9;
18936 tmp |= fieldFromInstruction(insn, 8, 1) << 15;
18937 tmp |= fieldFromInstruction(insn, 9, 3);
18938 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
18939 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
18940 tmp |= fieldFromInstruction(insn, 25, 6) << 3;
18941 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18942 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18943 return S;
18944 case 205:
18945 tmp = fieldFromInstruction(insn, 7, 5);
18946 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18947 tmp = fieldFromInstruction(insn, 20, 5);
18948 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18949 return S;
18950 case 206:
18951 tmp = fieldFromInstruction(insn, 7, 5);
18952 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18953 tmp = fieldFromInstruction(insn, 20, 5);
18954 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18955 return S;
18956 case 207:
18957 tmp = fieldFromInstruction(insn, 7, 5);
18958 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18959 tmp = fieldFromInstruction(insn, 15, 5);
18960 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18961 tmp = fieldFromInstruction(insn, 20, 5);
18962 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18963 tmp = fieldFromInstruction(insn, 25, 1);
18964 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18965 return S;
18966 case 208:
18967 tmp = fieldFromInstruction(insn, 7, 5);
18968 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18969 tmp = 0x0;
18970 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
18971 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
18972 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
18973 tmp |= fieldFromInstruction(insn, 21, 10);
18974 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18975 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18976 return S;
18977 case 209:
18978 tmp = fieldFromInstruction(insn, 15, 5);
18979 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18980 tmp = 0x0;
18981 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
18982 tmp |= fieldFromInstruction(insn, 20, 5);
18983 tmp |= fieldFromInstruction(insn, 30, 1) << 6;
18984 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18985 tmp = 0x0;
18986 tmp |= fieldFromInstruction(insn, 8, 4);
18987 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
18988 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
18989 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18990 return S;
18991 case 210:
18992 tmp = fieldFromInstruction(insn, 7, 5);
18993 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18994 tmp = 0x0;
18995 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
18996 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
18997 tmp |= fieldFromInstruction(insn, 20, 1) << 9;
18998 tmp |= fieldFromInstruction(insn, 21, 1) << 15;
18999 tmp |= fieldFromInstruction(insn, 22, 9);
19000 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
19001 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19002 return S;
19003 case 211:
19004 tmp = fieldFromInstruction(insn, 7, 5);
19005 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19006 tmp = fieldFromInstruction(insn, 15, 5);
19007 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19008 tmp = fieldFromInstruction(insn, 26, 6);
19009 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19010 tmp = fieldFromInstruction(insn, 20, 6);
19011 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19012 return S;
19013 case 212:
19014 tmp = fieldFromInstruction(insn, 20, 5);
19015 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19016 tmp = 0x0;
19017 tmp |= fieldFromInstruction(insn, 7, 1) << 11;
19018 tmp |= fieldFromInstruction(insn, 8, 4) << 1;
19019 tmp |= fieldFromInstruction(insn, 14, 1);
19020 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
19021 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
19022 tmp |= fieldFromInstruction(insn, 25, 6) << 5;
19023 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
19024 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19025 return S;
19026 case 213:
19027 tmp = fieldFromInstruction(insn, 7, 5);
19028 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19029 tmp = 0x0;
19030 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
19031 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
19032 tmp |= fieldFromInstruction(insn, 20, 1) << 8;
19033 tmp |= fieldFromInstruction(insn, 21, 2) << 14;
19034 tmp |= fieldFromInstruction(insn, 23, 8);
19035 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
19036 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19037 return S;
19038 case 214:
19039 tmp = fieldFromInstruction(insn, 20, 5);
19040 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19041 tmp = 0x0;
19042 tmp |= fieldFromInstruction(insn, 7, 1) << 8;
19043 tmp |= fieldFromInstruction(insn, 8, 2) << 14;
19044 tmp |= fieldFromInstruction(insn, 10, 2);
19045 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
19046 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
19047 tmp |= fieldFromInstruction(insn, 25, 6) << 2;
19048 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
19049 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19050 return S;
19051 case 215:
19052 tmp = fieldFromInstruction(insn, 15, 5);
19053 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19054 tmp = 0x0;
19055 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
19056 tmp |= fieldFromInstruction(insn, 20, 5);
19057 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19058 tmp = 0x0;
19059 tmp |= fieldFromInstruction(insn, 8, 4);
19060 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
19061 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
19062 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19063 return S;
19064 case 216:
19065 tmp = fieldFromInstruction(insn, 7, 5);
19066 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19067 tmp = fieldFromInstruction(insn, 15, 5);
19068 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19069 tmp = fieldFromInstruction(insn, 15, 5);
19070 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19071 tmp = fieldFromInstruction(insn, 20, 12);
19072 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19073 return S;
19074 case 217:
19075 tmp = fieldFromInstruction(insn, 15, 5);
19076 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19077 tmp = fieldFromInstruction(insn, 20, 5);
19078 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19079 tmp = fieldFromInstruction(insn, 15, 5);
19080 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19081 tmp = 0x0;
19082 tmp |= fieldFromInstruction(insn, 7, 5);
19083 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
19084 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19085 return S;
19086 case 218:
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, 25, 5);
19092 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19093 tmp = fieldFromInstruction(insn, 20, 5);
19094 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19095 return S;
19096 case 219:
19097 tmp = fieldFromInstruction(insn, 7, 5);
19098 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19099 tmp = fieldFromInstruction(insn, 7, 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 = fieldFromInstruction(insn, 25, 5);
19104 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19105 tmp = fieldFromInstruction(insn, 20, 5);
19106 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19107 return S;
19108 case 220:
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 = 0x0;
19114 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19115 tmp |= fieldFromInstruction(insn, 25, 1);
19116 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19117 return S;
19118 case 221:
19119 tmp = fieldFromInstruction(insn, 7, 5);
19120 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19121 tmp = fieldFromInstruction(insn, 15, 5);
19122 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19123 tmp = fieldFromInstruction(insn, 25, 5);
19124 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19125 tmp = fieldFromInstruction(insn, 20, 5);
19126 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19127 return S;
19128 case 222:
19129 tmp = fieldFromInstruction(insn, 7, 5);
19130 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19131 tmp = fieldFromInstruction(insn, 15, 5);
19132 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19133 tmp = fieldFromInstruction(insn, 20, 5);
19134 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19135 tmp = fieldFromInstruction(insn, 25, 5);
19136 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19137 return S;
19138 case 223:
19139 tmp = fieldFromInstruction(insn, 7, 5);
19140 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19141 tmp = fieldFromInstruction(insn, 15, 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, 20, 5);
19146 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19147 return S;
19148 case 224:
19149 tmp = fieldFromInstruction(insn, 15, 5);
19150 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19151 tmp = fieldFromInstruction(insn, 20, 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 = fieldFromInstruction(insn, 7, 5);
19156 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19157 return S;
19158 case 225:
19159 tmp = fieldFromInstruction(insn, 20, 5);
19160 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19161 tmp = fieldFromInstruction(insn, 15, 5);
19162 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19163 tmp = fieldFromInstruction(insn, 7, 5);
19164 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19165 return S;
19166 case 226:
19167 tmp = fieldFromInstruction(insn, 7, 5);
19168 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19169 tmp = fieldFromInstruction(insn, 7, 5);
19170 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19171 tmp = fieldFromInstruction(insn, 15, 5);
19172 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19173 tmp = 0x0;
19174 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19175 tmp |= fieldFromInstruction(insn, 25, 1);
19176 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19177 return S;
19178 case 227:
19179 tmp = fieldFromInstruction(insn, 15, 5);
19180 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19181 tmp = fieldFromInstruction(insn, 20, 5);
19182 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19183 tmp = 0x0;
19184 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19185 tmp |= fieldFromInstruction(insn, 8, 4);
19186 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19187 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19188 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19189 return S;
19190 case 228:
19191 tmp = fieldFromInstruction(insn, 7, 5);
19192 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19193 tmp = fieldFromInstruction(insn, 7, 5);
19194 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19195 tmp = fieldFromInstruction(insn, 15, 5);
19196 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19197 tmp = fieldFromInstruction(insn, 20, 5);
19198 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19199 tmp = fieldFromInstruction(insn, 25, 5);
19200 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19201 return S;
19202 case 229:
19203 tmp = fieldFromInstruction(insn, 7, 5);
19204 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19205 tmp = fieldFromInstruction(insn, 15, 5);
19206 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19207 tmp = 0x0;
19208 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19209 tmp |= fieldFromInstruction(insn, 25, 1);
19210 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19211 return S;
19212 case 230:
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<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19221 return S;
19222 case 231:
19223 tmp = fieldFromInstruction(insn, 7, 5);
19224 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19225 tmp = fieldFromInstruction(insn, 7, 5);
19226 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19227 tmp = fieldFromInstruction(insn, 15, 5);
19228 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19229 tmp = 0x0;
19230 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19231 tmp |= fieldFromInstruction(insn, 25, 1);
19232 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19233 return S;
19234 case 232:
19235 tmp = fieldFromInstruction(insn, 7, 5);
19236 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19237 tmp = fieldFromInstruction(insn, 15, 5);
19238 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19239 tmp = 0x0;
19240 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19241 tmp |= fieldFromInstruction(insn, 25, 1);
19242 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19243 return S;
19244 case 233:
19245 tmp = fieldFromInstruction(insn, 15, 5);
19246 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19247 tmp = fieldFromInstruction(insn, 20, 9);
19248 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19249 tmp = fieldFromInstruction(insn, 7, 5);
19250 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19251 return S;
19252 case 234:
19253 tmp = fieldFromInstruction(insn, 7, 5);
19254 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19255 tmp = fieldFromInstruction(insn, 15, 5);
19256 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19257 tmp = fieldFromInstruction(insn, 20, 5);
19258 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19259 tmp = fieldFromInstruction(insn, 27, 5);
19260 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19261 return S;
19262 case 235:
19263 tmp = fieldFromInstruction(insn, 7, 5);
19264 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19265 tmp = fieldFromInstruction(insn, 27, 5);
19266 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19267 tmp = fieldFromInstruction(insn, 15, 5);
19268 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19269 tmp = fieldFromInstruction(insn, 23, 4) << 3;
19270 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19271 return S;
19272 case 236:
19273 tmp = fieldFromInstruction(insn, 7, 5);
19274 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19275 tmp = fieldFromInstruction(insn, 27, 5);
19276 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19277 tmp = fieldFromInstruction(insn, 15, 5);
19278 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19279 tmp = fieldFromInstruction(insn, 22, 5) << 2;
19280 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19281 return S;
19282 case 237:
19283 tmp = fieldFromInstruction(insn, 20, 5);
19284 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19285 tmp = fieldFromInstruction(insn, 27, 5);
19286 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19287 tmp = fieldFromInstruction(insn, 15, 5);
19288 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19289 tmp = 0x0;
19290 tmp |= fieldFromInstruction(insn, 10, 2) << 3;
19291 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
19292 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19293 return S;
19294 case 238:
19295 tmp = fieldFromInstruction(insn, 20, 5);
19296 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19297 tmp = fieldFromInstruction(insn, 27, 5);
19298 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19299 tmp = fieldFromInstruction(insn, 15, 5);
19300 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19301 tmp = 0x0;
19302 tmp |= fieldFromInstruction(insn, 9, 3) << 2;
19303 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
19304 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19305 return S;
19306 case 239:
19307 tmp = fieldFromInstruction(insn, 7, 5);
19308 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19309 tmp = fieldFromInstruction(insn, 15, 5);
19310 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19311 tmp = fieldFromInstruction(insn, 20, 5);
19312 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19313 tmp = fieldFromInstruction(insn, 12, 2);
19314 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19315 return S;
19316 case 240:
19317 tmp = fieldFromInstruction(insn, 7, 5);
19318 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19319 tmp = fieldFromInstruction(insn, 7, 5);
19320 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19321 tmp = fieldFromInstruction(insn, 15, 5);
19322 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19323 tmp = fieldFromInstruction(insn, 20, 5);
19324 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19325 return S;
19326 case 241:
19327 tmp = fieldFromInstruction(insn, 7, 5);
19328 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19329 tmp = fieldFromInstruction(insn, 7, 5);
19330 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19331 tmp = fieldFromInstruction(insn, 15, 5);
19332 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19333 tmp = fieldFromInstruction(insn, 20, 5);
19334 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19335 tmp = fieldFromInstruction(insn, 29, 2);
19336 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19337 return S;
19338 case 242:
19339 tmp = fieldFromInstruction(insn, 7, 5);
19340 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19341 tmp = fieldFromInstruction(insn, 15, 5);
19342 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19343 tmp = fieldFromInstruction(insn, 20, 5);
19344 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19345 tmp = fieldFromInstruction(insn, 12, 2);
19346 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19347 return S;
19348 case 243:
19349 tmp = fieldFromInstruction(insn, 7, 5);
19350 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19351 tmp = fieldFromInstruction(insn, 7, 5);
19352 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19353 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19354 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19355 tmp = fieldFromInstruction(insn, 20, 5);
19356 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19357 return S;
19358 case 244:
19359 tmp = fieldFromInstruction(insn, 7, 5);
19360 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19361 tmp = fieldFromInstruction(insn, 7, 5);
19362 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19363 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19364 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19365 tmp = fieldFromInstruction(insn, 20, 5);
19366 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19367 tmp = fieldFromInstruction(insn, 29, 2);
19368 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19369 return S;
19370 case 245:
19371 tmp = fieldFromInstruction(insn, 8, 4) << 1;
19372 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19373 tmp = fieldFromInstruction(insn, 8, 4) << 1;
19374 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19375 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19376 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(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, 25, 1);
19380 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19381 tmp = 0x0;
19382 tmp |= fieldFromInstruction(insn, 7, 1);
19383 tmp |= fieldFromInstruction(insn, 15, 1) << 1;
19384 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19385 tmp = fieldFromInstruction(insn, 29, 2);
19386 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19387 return S;
19388 case 246:
19389 tmp = fieldFromInstruction(insn, 7, 5);
19390 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19391 tmp = fieldFromInstruction(insn, 7, 5);
19392 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19393 tmp = fieldFromInstruction(insn, 15, 5);
19394 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19395 tmp = fieldFromInstruction(insn, 20, 5);
19396 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19397 tmp = fieldFromInstruction(insn, 25, 1);
19398 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19399 tmp = fieldFromInstruction(insn, 12, 3);
19400 if (!Check(S, decodeUImmOperand<3>(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, 7, 5);
19408 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19409 tmp = fieldFromInstruction(insn, 15, 5);
19410 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19411 tmp = fieldFromInstruction(insn, 20, 5);
19412 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19413 return S;
19414 case 248:
19415 tmp = fieldFromInstruction(insn, 7, 5);
19416 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19417 tmp = fieldFromInstruction(insn, 26, 2);
19418 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19419 tmp = fieldFromInstruction(insn, 20, 5);
19420 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19421 tmp = fieldFromInstruction(insn, 15, 5);
19422 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19423 return S;
19424 case 249:
19425 tmp = fieldFromInstruction(insn, 26, 2);
19426 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19427 tmp = fieldFromInstruction(insn, 20, 5);
19428 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19429 tmp = fieldFromInstruction(insn, 7, 5);
19430 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19431 tmp = fieldFromInstruction(insn, 15, 5);
19432 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19433 return S;
19434 case 250:
19435 tmp = fieldFromInstruction(insn, 7, 5);
19436 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19437 tmp = fieldFromInstruction(insn, 26, 2);
19438 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19439 tmp = fieldFromInstruction(insn, 20, 5);
19440 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19441 tmp = fieldFromInstruction(insn, 15, 5);
19442 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19443 return S;
19444 case 251:
19445 tmp = fieldFromInstruction(insn, 26, 2);
19446 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19447 tmp = fieldFromInstruction(insn, 20, 5);
19448 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19449 tmp = fieldFromInstruction(insn, 7, 5);
19450 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19451 tmp = fieldFromInstruction(insn, 15, 5);
19452 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19453 return S;
19454 case 252:
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, 26, 2);
19458 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19459 tmp = fieldFromInstruction(insn, 20, 5);
19460 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19461 tmp = fieldFromInstruction(insn, 15, 5);
19462 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19463 return S;
19464 case 253:
19465 tmp = fieldFromInstruction(insn, 26, 2);
19466 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19467 tmp = fieldFromInstruction(insn, 7, 5);
19468 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19469 tmp = fieldFromInstruction(insn, 20, 5);
19470 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19471 tmp = fieldFromInstruction(insn, 15, 5);
19472 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19473 return S;
19474 case 254:
19475 tmp = fieldFromInstruction(insn, 7, 5);
19476 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19477 tmp = fieldFromInstruction(insn, 26, 2);
19478 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19479 tmp = fieldFromInstruction(insn, 20, 5);
19480 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19481 tmp = fieldFromInstruction(insn, 15, 5);
19482 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19483 return S;
19484 case 255:
19485 tmp = fieldFromInstruction(insn, 26, 2);
19486 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19487 tmp = fieldFromInstruction(insn, 7, 5);
19488 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19489 tmp = fieldFromInstruction(insn, 20, 5);
19490 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19491 tmp = fieldFromInstruction(insn, 15, 5);
19492 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19493 return S;
19494 case 256:
19495 tmp = fieldFromInstruction(insn, 7, 5);
19496 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19497 tmp = fieldFromInstruction(insn, 26, 2);
19498 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19499 tmp = fieldFromInstruction(insn, 20, 5);
19500 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19501 tmp = fieldFromInstruction(insn, 15, 5);
19502 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19503 return S;
19504 case 257:
19505 tmp = fieldFromInstruction(insn, 26, 2);
19506 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19507 tmp = fieldFromInstruction(insn, 7, 5);
19508 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19509 tmp = fieldFromInstruction(insn, 20, 5);
19510 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19511 tmp = fieldFromInstruction(insn, 15, 5);
19512 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19513 return S;
19514 case 258:
19515 tmp = fieldFromInstruction(insn, 7, 5);
19516 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19517 tmp = fieldFromInstruction(insn, 26, 1);
19518 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19519 tmp = fieldFromInstruction(insn, 20, 5);
19520 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19521 tmp = fieldFromInstruction(insn, 15, 5);
19522 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19523 return S;
19524 case 259:
19525 tmp = fieldFromInstruction(insn, 26, 1);
19526 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19527 tmp = fieldFromInstruction(insn, 7, 5);
19528 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19529 tmp = fieldFromInstruction(insn, 20, 5);
19530 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19531 tmp = fieldFromInstruction(insn, 15, 5);
19532 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19533 return S;
19534 case 260:
19535 tmp = fieldFromInstruction(insn, 8, 4);
19536 if (!Check(S, DecodeSimpleRegisterClass<RISCV::T0, 16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19537 return S;
19538 case 261:
19539 tmp = fieldFromInstruction(insn, 15, 5);
19540 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19541 tmp = fieldFromInstruction(insn, 20, 5);
19542 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19543 return S;
19544 case 262:
19545 tmp = fieldFromInstruction(insn, 7, 5);
19546 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19547 tmp = fieldFromInstruction(insn, 26, 2);
19548 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19549 tmp = fieldFromInstruction(insn, 7, 5);
19550 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19551 tmp = fieldFromInstruction(insn, 20, 5);
19552 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19553 tmp = fieldFromInstruction(insn, 15, 5);
19554 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19555 return S;
19556 case 263:
19557 tmp = fieldFromInstruction(insn, 26, 2);
19558 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19559 tmp = fieldFromInstruction(insn, 7, 5);
19560 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19561 tmp = fieldFromInstruction(insn, 20, 5);
19562 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19563 tmp = fieldFromInstruction(insn, 15, 5);
19564 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19565 return S;
19566 case 264:
19567 tmp = fieldFromInstruction(insn, 7, 5);
19568 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19569 tmp = fieldFromInstruction(insn, 26, 2);
19570 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19571 tmp = fieldFromInstruction(insn, 7, 5);
19572 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19573 tmp = fieldFromInstruction(insn, 20, 5);
19574 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19575 tmp = fieldFromInstruction(insn, 15, 5);
19576 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19577 return S;
19578 case 265:
19579 tmp = fieldFromInstruction(insn, 26, 2);
19580 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
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, 20, 5);
19584 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19585 tmp = fieldFromInstruction(insn, 15, 5);
19586 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19587 return S;
19588 case 266:
19589 tmp = fieldFromInstruction(insn, 7, 5);
19590 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19591 tmp = fieldFromInstruction(insn, 26, 2);
19592 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19593 tmp = fieldFromInstruction(insn, 7, 5);
19594 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(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, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19599 return S;
19600 case 267:
19601 tmp = fieldFromInstruction(insn, 26, 2);
19602 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19603 tmp = fieldFromInstruction(insn, 7, 5);
19604 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19605 tmp = fieldFromInstruction(insn, 20, 5);
19606 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19607 tmp = fieldFromInstruction(insn, 15, 5);
19608 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19609 return S;
19610 case 268:
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, 1);
19614 if (!Check(S, decodeUImmOperand<1>(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::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19621 return S;
19622 case 269:
19623 tmp = fieldFromInstruction(insn, 26, 1);
19624 if (!Check(S, decodeUImmOperand<1>(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::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19631 return S;
19632 case 270:
19633 tmp = fieldFromInstruction(insn, 10, 2) << 2;
19634 if (!Check(S, DecodeTRM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19635 tmp = fieldFromInstruction(insn, 20, 5);
19636 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19637 tmp = fieldFromInstruction(insn, 15, 5);
19638 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19639 return S;
19640 case 271:
19641 tmp = fieldFromInstruction(insn, 9, 3) << 1;
19642 if (!Check(S, DecodeTRM2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19643 tmp = fieldFromInstruction(insn, 20, 5);
19644 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19645 tmp = fieldFromInstruction(insn, 15, 5);
19646 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19647 return S;
19648 case 272:
19649 tmp = fieldFromInstruction(insn, 7, 5);
19650 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19651 tmp = fieldFromInstruction(insn, 15, 5);
19652 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19653 tmp = fieldFromInstruction(insn, 20, 5);
19654 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19655 tmp = fieldFromInstruction(insn, 25, 2);
19656 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19657 return S;
19658 case 273:
19659 tmp = fieldFromInstruction(insn, 7, 5);
19660 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19661 tmp = fieldFromInstruction(insn, 15, 5);
19662 if (!Check(S, DecodeGPRRegisterClass(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 tmp = fieldFromInstruction(insn, 20, 5);
19666 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19667 tmp = fieldFromInstruction(insn, 25, 2);
19668 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19669 return S;
19670 case 274:
19671 tmp = fieldFromInstruction(insn, 7, 5);
19672 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19673 tmp = fieldFromInstruction(insn, 20, 5);
19674 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19675 tmp = fieldFromInstruction(insn, 15, 5);
19676 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19677 tmp = fieldFromInstruction(insn, 25, 2);
19678 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19679 if (!Check(Out&: S, In: decodeFixedImmOperand<3>(Inst&: MI, Decoder)))
19680 return MCDisassembler::Fail;
19681 return S;
19682 case 275:
19683 tmp = fieldFromInstruction(insn, 7, 5);
19684 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19685 tmp = fieldFromInstruction(insn, 20, 5);
19686 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19687 tmp = fieldFromInstruction(insn, 15, 5);
19688 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19689 tmp = fieldFromInstruction(insn, 25, 2);
19690 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19691 if (!Check(Out&: S, In: decodeFixedImmOperand<4>(Inst&: MI, Decoder)))
19692 return MCDisassembler::Fail;
19693 return S;
19694 case 276:
19695 tmp = fieldFromInstruction(insn, 15, 5);
19696 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19697 tmp = fieldFromInstruction(insn, 7, 5);
19698 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19699 tmp = fieldFromInstruction(insn, 15, 5);
19700 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19701 tmp = fieldFromInstruction(insn, 20, 5);
19702 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19703 tmp = fieldFromInstruction(insn, 25, 2);
19704 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19705 return S;
19706 case 277:
19707 tmp = fieldFromInstruction(insn, 7, 5);
19708 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19709 tmp = fieldFromInstruction(insn, 15, 5);
19710 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19711 tmp = fieldFromInstruction(insn, 20, 5);
19712 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19713 tmp = fieldFromInstruction(insn, 25, 2);
19714 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19715 return S;
19716 case 278:
19717 tmp = fieldFromInstruction(insn, 7, 5);
19718 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19719 tmp = fieldFromInstruction(insn, 15, 5);
19720 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19721 tmp = fieldFromInstruction(insn, 20, 5);
19722 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19723 tmp = fieldFromInstruction(insn, 25, 2);
19724 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19725 return S;
19726 case 279:
19727 tmp = fieldFromInstruction(insn, 7, 5);
19728 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19729 tmp = fieldFromInstruction(insn, 15, 5);
19730 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19731 tmp = fieldFromInstruction(insn, 20, 11);
19732 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19733 return S;
19734 case 280:
19735 tmp = fieldFromInstruction(insn, 7, 5);
19736 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19737 tmp = fieldFromInstruction(insn, 7, 5);
19738 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19739 tmp = fieldFromInstruction(insn, 15, 5);
19740 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19741 tmp = fieldFromInstruction(insn, 20, 11);
19742 if (!Check(S, decodeSImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19743 return S;
19744 case 281:
19745 tmp = fieldFromInstruction(insn, 7, 5);
19746 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19747 tmp = fieldFromInstruction(insn, 7, 5);
19748 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19749 tmp = fieldFromInstruction(insn, 15, 5);
19750 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19751 tmp = fieldFromInstruction(insn, 25, 5);
19752 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19753 tmp = fieldFromInstruction(insn, 20, 5);
19754 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19755 return S;
19756 case 282:
19757 tmp = fieldFromInstruction(insn, 7, 5);
19758 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19759 tmp = fieldFromInstruction(insn, 7, 5);
19760 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19761 tmp = fieldFromInstruction(insn, 15, 5);
19762 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19763 tmp = fieldFromInstruction(insn, 25, 5);
19764 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19765 tmp = fieldFromInstruction(insn, 20, 5);
19766 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19767 return S;
19768 case 283:
19769 tmp = fieldFromInstruction(insn, 7, 5);
19770 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19771 tmp = fieldFromInstruction(insn, 15, 5);
19772 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19773 tmp = fieldFromInstruction(insn, 25, 5);
19774 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19775 tmp = fieldFromInstruction(insn, 20, 5);
19776 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19777 return S;
19778 case 284:
19779 tmp = fieldFromInstruction(insn, 7, 5);
19780 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19781 tmp = fieldFromInstruction(insn, 15, 5);
19782 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19783 tmp = fieldFromInstruction(insn, 25, 5);
19784 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19785 tmp = fieldFromInstruction(insn, 20, 5);
19786 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19787 return S;
19788 case 285:
19789 tmp = fieldFromInstruction(insn, 7, 5);
19790 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19791 tmp = fieldFromInstruction(insn, 15, 5);
19792 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19793 return S;
19794 case 286:
19795 tmp = fieldFromInstruction(insn, 7, 5);
19796 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19797 tmp = fieldFromInstruction(insn, 7, 5);
19798 if (!Check(S, DecodeGPRNoX0RegisterClass(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, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19803 return S;
19804 case 287:
19805 tmp = fieldFromInstruction(insn, 7, 5);
19806 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19807 tmp = fieldFromInstruction(insn, 15, 5);
19808 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19809 tmp = fieldFromInstruction(insn, 20, 5);
19810 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19811 return S;
19812 case 288:
19813 tmp = fieldFromInstruction(insn, 7, 5);
19814 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19815 tmp = fieldFromInstruction(insn, 15, 5);
19816 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19817 tmp = fieldFromInstruction(insn, 20, 5);
19818 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19819 return S;
19820 case 289:
19821 tmp = fieldFromInstruction(insn, 7, 5);
19822 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19823 tmp = fieldFromInstruction(insn, 15, 5);
19824 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19825 tmp = fieldFromInstruction(insn, 20, 5);
19826 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19827 return S;
19828 case 290:
19829 tmp = fieldFromInstruction(insn, 7, 5);
19830 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19831 tmp = fieldFromInstruction(insn, 15, 5);
19832 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19833 tmp = fieldFromInstruction(insn, 20, 5);
19834 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19835 tmp = fieldFromInstruction(insn, 25, 5);
19836 if (!Check(S, decodeUImmOperand<5, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19837 return S;
19838 case 291:
19839 tmp = fieldFromInstruction(insn, 7, 5);
19840 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19841 tmp = fieldFromInstruction(insn, 15, 5);
19842 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19843 tmp = fieldFromInstruction(insn, 20, 12) << 2;
19844 if (!Check(S, decodeUImmOperand<14>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19845 return S;
19846 case 292:
19847 tmp = fieldFromInstruction(insn, 7, 5);
19848 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19849 tmp = fieldFromInstruction(insn, 15, 5);
19850 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19851 tmp = fieldFromInstruction(insn, 20, 12) << 2;
19852 if (!Check(S, decodeUImmOperand<14>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19853 return S;
19854 case 293:
19855 tmp = fieldFromInstruction(insn, 7, 5);
19856 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19857 tmp = fieldFromInstruction(insn, 7, 5);
19858 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19859 tmp = fieldFromInstruction(insn, 15, 5);
19860 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19861 tmp = fieldFromInstruction(insn, 20, 12);
19862 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19863 return S;
19864 case 294:
19865 tmp = fieldFromInstruction(insn, 7, 5);
19866 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19867 tmp = fieldFromInstruction(insn, 15, 5);
19868 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19869 tmp = fieldFromInstruction(insn, 20, 5);
19870 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19871 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19872 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19873 return S;
19874 case 295:
19875 tmp = fieldFromInstruction(insn, 7, 5);
19876 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19877 tmp = fieldFromInstruction(insn, 15, 5);
19878 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19879 tmp = fieldFromInstruction(insn, 20, 5);
19880 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19881 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19882 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19883 return S;
19884 case 296:
19885 tmp = fieldFromInstruction(insn, 7, 5);
19886 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19887 tmp = fieldFromInstruction(insn, 15, 5);
19888 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19889 tmp = fieldFromInstruction(insn, 20, 5);
19890 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19891 tmp = fieldFromInstruction(insn, 25, 3);
19892 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19893 return S;
19894 case 297:
19895 tmp = fieldFromInstruction(insn, 20, 5);
19896 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19897 return S;
19898 case 298:
19899 tmp = fieldFromInstruction(insn, 20, 8);
19900 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19901 return S;
19902 case 299:
19903 tmp = fieldFromInstruction(insn, 7, 5);
19904 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19905 tmp = 0x0;
19906 tmp |= fieldFromInstruction(insn, 12, 4) << 15;
19907 tmp |= fieldFromInstruction(insn, 16, 15);
19908 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
19909 if (!Check(S, decodeSImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19910 return S;
19911 case 300:
19912 tmp = fieldFromInstruction(insn, 7, 5);
19913 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19914 tmp = fieldFromInstruction(insn, 15, 5);
19915 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19916 tmp = fieldFromInstruction(insn, 20, 5);
19917 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19918 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19919 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19920 return S;
19921 case 301:
19922 tmp = fieldFromInstruction(insn, 7, 5);
19923 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19924 tmp = fieldFromInstruction(insn, 15, 5);
19925 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19926 tmp = fieldFromInstruction(insn, 20, 5);
19927 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19928 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19929 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19930 return S;
19931 case 302:
19932 tmp = fieldFromInstruction(insn, 7, 5);
19933 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19934 tmp = fieldFromInstruction(insn, 7, 5);
19935 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19936 tmp = fieldFromInstruction(insn, 15, 5);
19937 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19938 tmp = fieldFromInstruction(insn, 20, 5);
19939 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19940 tmp = fieldFromInstruction(insn, 27, 5);
19941 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19942 return S;
19943 case 303:
19944 tmp = fieldFromInstruction(insn, 7, 5);
19945 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19946 tmp = fieldFromInstruction(insn, 7, 5);
19947 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19948 tmp = fieldFromInstruction(insn, 15, 5);
19949 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19950 tmp = fieldFromInstruction(insn, 20, 5);
19951 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19952 tmp = fieldFromInstruction(insn, 27, 5);
19953 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19954 return S;
19955 case 304:
19956 tmp = fieldFromInstruction(insn, 7, 5);
19957 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19958 tmp = fieldFromInstruction(insn, 7, 5);
19959 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19960 tmp = fieldFromInstruction(insn, 15, 5);
19961 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19962 tmp = fieldFromInstruction(insn, 20, 5);
19963 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19964 tmp = fieldFromInstruction(insn, 27, 5);
19965 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19966 return S;
19967 case 305:
19968 tmp = fieldFromInstruction(insn, 7, 5);
19969 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19970 tmp = fieldFromInstruction(insn, 7, 5);
19971 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19972 tmp = fieldFromInstruction(insn, 15, 5);
19973 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19974 tmp = fieldFromInstruction(insn, 20, 5);
19975 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19976 tmp = fieldFromInstruction(insn, 27, 5);
19977 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19978 return S;
19979 case 306:
19980 tmp = fieldFromInstruction(insn, 7, 5);
19981 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19982 tmp = fieldFromInstruction(insn, 7, 5);
19983 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19984 tmp = fieldFromInstruction(insn, 15, 5);
19985 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19986 tmp = fieldFromInstruction(insn, 20, 5);
19987 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19988 tmp = fieldFromInstruction(insn, 27, 5);
19989 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19990 return S;
19991 case 307:
19992 tmp = fieldFromInstruction(insn, 7, 5);
19993 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19994 tmp = fieldFromInstruction(insn, 7, 5);
19995 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19996 tmp = fieldFromInstruction(insn, 15, 5);
19997 if (!Check(S, decodeSImmOperand<5>(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, 27, 5);
20001 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20002 return S;
20003 case 308:
20004 tmp = fieldFromInstruction(insn, 7, 5);
20005 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20006 tmp = fieldFromInstruction(insn, 7, 5);
20007 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20008 tmp = fieldFromInstruction(insn, 15, 5);
20009 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20010 tmp = fieldFromInstruction(insn, 20, 5);
20011 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20012 tmp = fieldFromInstruction(insn, 27, 5);
20013 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20014 return S;
20015 case 309:
20016 tmp = fieldFromInstruction(insn, 7, 5);
20017 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20018 tmp = fieldFromInstruction(insn, 7, 5);
20019 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20020 tmp = fieldFromInstruction(insn, 15, 5);
20021 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20022 tmp = fieldFromInstruction(insn, 20, 5);
20023 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20024 tmp = fieldFromInstruction(insn, 27, 5);
20025 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20026 return S;
20027 case 310:
20028 tmp = fieldFromInstruction(insn, 7, 5);
20029 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20030 tmp = fieldFromInstruction(insn, 15, 5);
20031 if (!Check(S, DecodeGPRRegisterClass(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 return S;
20035 case 311:
20036 tmp = fieldFromInstruction(insn, 7, 5);
20037 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20038 tmp = fieldFromInstruction(insn, 15, 5);
20039 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20040 tmp = fieldFromInstruction(insn, 20, 5);
20041 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20042 return S;
20043 case 312:
20044 tmp = fieldFromInstruction(insn, 15, 10);
20045 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20046 return S;
20047 case 313:
20048 tmp = fieldFromInstruction(insn, 15, 5);
20049 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20050 tmp = fieldFromInstruction(insn, 20, 5);
20051 if (!Check(S, decodeSImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20052 tmp = 0x0;
20053 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20054 tmp |= fieldFromInstruction(insn, 8, 4);
20055 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20056 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20057 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20058 return S;
20059 case 314:
20060 tmp = fieldFromInstruction(insn, 15, 5);
20061 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20062 tmp = fieldFromInstruction(insn, 20, 5);
20063 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20064 tmp = 0x0;
20065 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20066 tmp |= fieldFromInstruction(insn, 8, 4);
20067 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20068 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20069 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20070 return S;
20071 case 315:
20072 tmp = fieldFromInstruction(insn, 7, 5);
20073 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20074 tmp = fieldFromInstruction(insn, 15, 5);
20075 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20076 tmp = fieldFromInstruction(insn, 12, 3);
20077 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20078 return S;
20079 case 316:
20080 tmp = fieldFromInstruction(insn, 7, 5);
20081 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20082 tmp = fieldFromInstruction(insn, 15, 5);
20083 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20084 tmp = fieldFromInstruction(insn, 12, 3);
20085 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20086 return S;
20087 case 317:
20088 tmp = fieldFromInstruction(insn, 7, 5);
20089 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20090 tmp = fieldFromInstruction(insn, 15, 5);
20091 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20092 tmp = fieldFromInstruction(insn, 20, 5);
20093 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20094 tmp = fieldFromInstruction(insn, 27, 5);
20095 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20096 tmp = fieldFromInstruction(insn, 12, 3);
20097 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20098 return S;
20099 case 318:
20100 tmp = fieldFromInstruction(insn, 7, 5);
20101 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20102 tmp = fieldFromInstruction(insn, 15, 5);
20103 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20104 tmp = fieldFromInstruction(insn, 20, 5);
20105 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20106 tmp = fieldFromInstruction(insn, 12, 3);
20107 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20108 return S;
20109 case 319:
20110 tmp = fieldFromInstruction(insn, 7, 5);
20111 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20112 tmp = fieldFromInstruction(insn, 15, 5);
20113 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20114 tmp = fieldFromInstruction(insn, 20, 5);
20115 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20116 return S;
20117 case 320:
20118 tmp = fieldFromInstruction(insn, 7, 5);
20119 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20120 tmp = fieldFromInstruction(insn, 15, 5);
20121 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20122 tmp = fieldFromInstruction(insn, 12, 3);
20123 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20124 return S;
20125 case 321:
20126 tmp = fieldFromInstruction(insn, 7, 5);
20127 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20128 tmp = fieldFromInstruction(insn, 15, 5);
20129 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20130 tmp = fieldFromInstruction(insn, 12, 3);
20131 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20132 return S;
20133 case 322:
20134 tmp = fieldFromInstruction(insn, 7, 5);
20135 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20136 tmp = fieldFromInstruction(insn, 15, 5);
20137 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20138 tmp = fieldFromInstruction(insn, 12, 3);
20139 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20140 return S;
20141 case 323:
20142 tmp = fieldFromInstruction(insn, 7, 5);
20143 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20144 tmp = fieldFromInstruction(insn, 15, 5);
20145 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20146 tmp = fieldFromInstruction(insn, 20, 5);
20147 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20148 return S;
20149 case 324:
20150 tmp = fieldFromInstruction(insn, 7, 5);
20151 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20152 tmp = fieldFromInstruction(insn, 15, 5);
20153 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20154 tmp = fieldFromInstruction(insn, 12, 3);
20155 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20156 return S;
20157 case 325:
20158 tmp = fieldFromInstruction(insn, 7, 5);
20159 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20160 tmp = fieldFromInstruction(insn, 15, 5);
20161 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20162 tmp = fieldFromInstruction(insn, 12, 3);
20163 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20164 return S;
20165 case 326:
20166 tmp = fieldFromInstruction(insn, 7, 5);
20167 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20168 tmp = fieldFromInstruction(insn, 15, 5);
20169 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20170 return S;
20171 case 327:
20172 tmp = fieldFromInstruction(insn, 7, 5);
20173 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20174 tmp = fieldFromInstruction(insn, 15, 5);
20175 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20176 tmp = fieldFromInstruction(insn, 20, 5);
20177 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20178 tmp = fieldFromInstruction(insn, 27, 5);
20179 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20180 tmp = fieldFromInstruction(insn, 12, 3);
20181 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20182 return S;
20183 case 328:
20184 tmp = fieldFromInstruction(insn, 7, 5);
20185 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20186 tmp = fieldFromInstruction(insn, 15, 5);
20187 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20188 tmp = fieldFromInstruction(insn, 20, 5);
20189 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20190 tmp = fieldFromInstruction(insn, 27, 5);
20191 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20192 tmp = fieldFromInstruction(insn, 12, 3);
20193 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20194 return S;
20195 case 329:
20196 tmp = fieldFromInstruction(insn, 7, 5);
20197 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20198 tmp = fieldFromInstruction(insn, 15, 5);
20199 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20200 tmp = fieldFromInstruction(insn, 20, 5);
20201 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20202 tmp = fieldFromInstruction(insn, 27, 5);
20203 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(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 330:
20208 tmp = fieldFromInstruction(insn, 7, 5);
20209 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(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, 20, 5);
20213 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20214 tmp = fieldFromInstruction(insn, 12, 3);
20215 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20216 return S;
20217 case 331:
20218 tmp = fieldFromInstruction(insn, 7, 5);
20219 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20220 tmp = fieldFromInstruction(insn, 15, 5);
20221 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20222 tmp = fieldFromInstruction(insn, 20, 5);
20223 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20224 tmp = fieldFromInstruction(insn, 12, 3);
20225 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20226 return S;
20227 case 332:
20228 tmp = fieldFromInstruction(insn, 7, 5);
20229 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20230 tmp = fieldFromInstruction(insn, 15, 5);
20231 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20232 tmp = fieldFromInstruction(insn, 20, 5);
20233 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20234 tmp = fieldFromInstruction(insn, 12, 3);
20235 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20236 return S;
20237 case 333:
20238 tmp = fieldFromInstruction(insn, 7, 5);
20239 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20240 tmp = fieldFromInstruction(insn, 15, 5);
20241 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20242 tmp = fieldFromInstruction(insn, 20, 5);
20243 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20244 return S;
20245 case 334:
20246 tmp = fieldFromInstruction(insn, 7, 5);
20247 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20248 tmp = fieldFromInstruction(insn, 15, 5);
20249 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20250 tmp = fieldFromInstruction(insn, 20, 5);
20251 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20252 return S;
20253 case 335:
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, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20258 tmp = fieldFromInstruction(insn, 12, 3);
20259 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20260 return S;
20261 case 336:
20262 tmp = fieldFromInstruction(insn, 7, 5);
20263 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20264 tmp = fieldFromInstruction(insn, 15, 5);
20265 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20266 tmp = fieldFromInstruction(insn, 12, 3);
20267 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20268 return S;
20269 case 337:
20270 tmp = fieldFromInstruction(insn, 7, 5);
20271 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20272 tmp = fieldFromInstruction(insn, 15, 5);
20273 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(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 338:
20278 tmp = fieldFromInstruction(insn, 7, 5);
20279 if (!Check(S, DecodeGPRRegisterClass(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, 12, 3);
20283 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20284 return S;
20285 case 339:
20286 tmp = fieldFromInstruction(insn, 7, 5);
20287 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20288 tmp = fieldFromInstruction(insn, 15, 5);
20289 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20290 tmp = fieldFromInstruction(insn, 12, 3);
20291 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20292 return S;
20293 case 340:
20294 tmp = fieldFromInstruction(insn, 7, 5);
20295 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20296 tmp = fieldFromInstruction(insn, 15, 5);
20297 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20298 tmp = fieldFromInstruction(insn, 12, 3);
20299 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20300 return S;
20301 case 341:
20302 tmp = fieldFromInstruction(insn, 7, 5);
20303 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20304 tmp = fieldFromInstruction(insn, 15, 5);
20305 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(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 342:
20310 tmp = fieldFromInstruction(insn, 7, 5);
20311 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20312 tmp = fieldFromInstruction(insn, 15, 5);
20313 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20314 tmp = fieldFromInstruction(insn, 12, 3);
20315 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20316 return S;
20317 case 343:
20318 tmp = fieldFromInstruction(insn, 7, 5);
20319 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20320 tmp = fieldFromInstruction(insn, 15, 5);
20321 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20322 tmp = fieldFromInstruction(insn, 12, 3);
20323 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20324 return S;
20325 case 344:
20326 tmp = fieldFromInstruction(insn, 7, 5);
20327 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20328 tmp = fieldFromInstruction(insn, 15, 5);
20329 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20330 tmp = fieldFromInstruction(insn, 20, 5);
20331 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20332 return S;
20333 case 345:
20334 tmp = fieldFromInstruction(insn, 7, 5);
20335 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20336 tmp = fieldFromInstruction(insn, 15, 5);
20337 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20338 tmp = fieldFromInstruction(insn, 20, 5);
20339 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20340 return S;
20341 case 346:
20342 tmp = fieldFromInstruction(insn, 7, 5);
20343 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20344 tmp = fieldFromInstruction(insn, 15, 5);
20345 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20346 return S;
20347 case 347:
20348 tmp = fieldFromInstruction(insn, 7, 5);
20349 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20350 tmp = fieldFromInstruction(insn, 15, 5);
20351 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20352 return S;
20353 }
20354}
20355static const uint8_t DecoderTableXqci48[368] = {
20356 48, // 0: BitWidth 48
20357 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
20358 0, 15, // 4: case 0x0: {
20359 OPC_CheckPredicate, 197, 1, // 6: check predicate 197
20360 OPC_CheckField, 15, 1, 0, // 9: check Inst[15] == 0x0
20361 OPC_CheckField, 0, 7, 31, // 13: check Inst[6:0] == 0x1f
20362 OPC_Decode, 225, 122, 0, // 17: decode to QC_E_LI using decoder 0
20363 // 17: }
20364 1, 29, // 21: case 0x1: {
20365 OPC_SwitchField, 15, 1, // 23: switch Inst[15] {
20366 0, 11, // 26: case 0x0: {
20367 OPC_CheckPredicate, 212, 1, // 28: check predicate 212
20368 OPC_CheckField, 0, 7, 31, // 31: check Inst[6:0] == 0x1f
20369 OPC_Decode, 232, 122, 1, // 35: decode to QC_E_XORAI using decoder 1
20370 // 35: }
20371 1, 0, // 39: case 0x1: {
20372 OPC_CheckPredicate, 212, 1, // 41: check predicate 212
20373 OPC_CheckField, 0, 7, 31, // 44: check Inst[6:0] == 0x1f
20374 OPC_Decode, 227, 122, 1, // 48: decode to QC_E_ORAI using decoder 1
20375 // 48: }
20376 // 48: } // switch Inst[15]
20377 // 48: }
20378 2, 29, // 52: case 0x2: {
20379 OPC_SwitchField, 15, 1, // 54: switch Inst[15] {
20380 0, 11, // 57: case 0x0: {
20381 OPC_CheckPredicate, 212, 1, // 59: check predicate 212
20382 OPC_CheckField, 0, 7, 31, // 62: check Inst[6:0] == 0x1f
20383 OPC_Decode, 209, 122, 1, // 66: decode to QC_E_ADDAI using decoder 1
20384 // 66: }
20385 1, 0, // 70: case 0x1: {
20386 OPC_CheckPredicate, 212, 1, // 72: check predicate 212
20387 OPC_CheckField, 0, 7, 31, // 75: check Inst[6:0] == 0x1f
20388 OPC_Decode, 211, 122, 1, // 79: decode to QC_E_ANDAI using decoder 1
20389 // 79: }
20390 // 79: } // switch Inst[15]
20391 // 79: }
20392 3, 55, // 83: case 0x3: {
20393 OPC_SwitchField, 30, 2, // 85: switch Inst[31:30] {
20394 0, 11, // 88: case 0x0: {
20395 OPC_CheckPredicate, 212, 1, // 90: check predicate 212
20396 OPC_CheckField, 0, 7, 31, // 93: check Inst[6:0] == 0x1f
20397 OPC_Decode, 233, 122, 2, // 97: decode to QC_E_XORI using decoder 2
20398 // 97: }
20399 1, 11, // 101: case 0x1: {
20400 OPC_CheckPredicate, 212, 1, // 103: check predicate 212
20401 OPC_CheckField, 0, 7, 31, // 106: check Inst[6:0] == 0x1f
20402 OPC_Decode, 228, 122, 2, // 110: decode to QC_E_ORI using decoder 2
20403 // 110: }
20404 2, 11, // 114: case 0x2: {
20405 OPC_CheckPredicate, 212, 1, // 116: check predicate 212
20406 OPC_CheckField, 0, 7, 31, // 119: check Inst[6:0] == 0x1f
20407 OPC_Decode, 210, 122, 2, // 123: decode to QC_E_ADDI using decoder 2
20408 // 123: }
20409 3, 0, // 127: case 0x3: {
20410 OPC_CheckPredicate, 212, 1, // 129: check predicate 212
20411 OPC_CheckField, 0, 7, 31, // 132: check Inst[6:0] == 0x1f
20412 OPC_Decode, 212, 122, 2, // 136: decode to QC_E_ANDI using decoder 2
20413 // 136: }
20414 // 136: } // switch Inst[31:30]
20415 // 136: }
20416 4, 112, // 140: case 0x4: {
20417 OPC_SwitchField, 20, 5, // 142: switch Inst[24:20] {
20418 0, 29, // 145: case 0x0: {
20419 OPC_SwitchField, 15, 2, // 147: switch Inst[16:15] {
20420 0, 11, // 150: case 0x0: {
20421 OPC_CheckPredicate, 213, 1, // 152: check predicate 213
20422 OPC_CheckField, 0, 7, 31, // 155: check Inst[6:0] == 0x1f
20423 OPC_Decode, 219, 122, 3, // 159: decode to QC_E_J using decoder 3
20424 // 159: }
20425 1, 0, // 163: case 0x1: {
20426 OPC_CheckPredicate, 213, 1, // 165: check predicate 213
20427 OPC_CheckField, 0, 7, 31, // 168: check Inst[6:0] == 0x1f
20428 OPC_Decode, 220, 122, 3, // 172: decode to QC_E_JAL using decoder 3
20429 // 172: }
20430 // 172: } // switch Inst[16:15]
20431 // 172: }
20432 24, 11, // 176: case 0x18: {
20433 OPC_CheckPredicate, 201, 1, // 178: check predicate 201
20434 OPC_CheckField, 0, 7, 31, // 181: check Inst[6:0] == 0x1f
20435 OPC_Decode, 213, 122, 4, // 185: decode to QC_E_BEQI using decoder 4
20436 // 185: }
20437 25, 11, // 189: case 0x19: {
20438 OPC_CheckPredicate, 201, 1, // 191: check predicate 201
20439 OPC_CheckField, 0, 7, 31, // 194: check Inst[6:0] == 0x1f
20440 OPC_Decode, 218, 122, 4, // 198: decode to QC_E_BNEI using decoder 4
20441 // 198: }
20442 28, 11, // 202: case 0x1c: {
20443 OPC_CheckPredicate, 201, 1, // 204: check predicate 201
20444 OPC_CheckField, 0, 7, 31, // 207: check Inst[6:0] == 0x1f
20445 OPC_Decode, 216, 122, 4, // 211: decode to QC_E_BLTI using decoder 4
20446 // 211: }
20447 29, 11, // 215: case 0x1d: {
20448 OPC_CheckPredicate, 201, 1, // 217: check predicate 201
20449 OPC_CheckField, 0, 7, 31, // 220: check Inst[6:0] == 0x1f
20450 OPC_Decode, 214, 122, 4, // 224: decode to QC_E_BGEI using decoder 4
20451 // 224: }
20452 30, 11, // 228: case 0x1e: {
20453 OPC_CheckPredicate, 201, 1, // 230: check predicate 201
20454 OPC_CheckField, 0, 7, 31, // 233: check Inst[6:0] == 0x1f
20455 OPC_Decode, 217, 122, 5, // 237: decode to QC_E_BLTUI using decoder 5
20456 // 237: }
20457 31, 0, // 241: case 0x1f: {
20458 OPC_CheckPredicate, 201, 1, // 243: check predicate 201
20459 OPC_CheckField, 0, 7, 31, // 246: check Inst[6:0] == 0x1f
20460 OPC_Decode, 215, 122, 5, // 250: decode to QC_E_BGEUI using decoder 5
20461 // 250: }
20462 // 250: } // switch Inst[24:20]
20463 // 250: }
20464 5, 55, // 254: case 0x5: {
20465 OPC_SwitchField, 30, 2, // 256: switch Inst[31:30] {
20466 0, 11, // 259: case 0x0: {
20467 OPC_CheckPredicate, 214, 1, // 261: check predicate 214
20468 OPC_CheckField, 0, 7, 31, // 264: check Inst[6:0] == 0x1f
20469 OPC_Decode, 221, 122, 6, // 268: decode to QC_E_LB using decoder 6
20470 // 268: }
20471 1, 11, // 272: case 0x1: {
20472 OPC_CheckPredicate, 214, 1, // 274: check predicate 214
20473 OPC_CheckField, 0, 7, 31, // 277: check Inst[6:0] == 0x1f
20474 OPC_Decode, 222, 122, 6, // 281: decode to QC_E_LBU using decoder 6
20475 // 281: }
20476 2, 11, // 285: case 0x2: {
20477 OPC_CheckPredicate, 214, 1, // 287: check predicate 214
20478 OPC_CheckField, 0, 7, 31, // 290: check Inst[6:0] == 0x1f
20479 OPC_Decode, 223, 122, 6, // 294: decode to QC_E_LH using decoder 6
20480 // 294: }
20481 3, 0, // 298: case 0x3: {
20482 OPC_CheckPredicate, 214, 1, // 300: check predicate 214
20483 OPC_CheckField, 0, 7, 31, // 303: check Inst[6:0] == 0x1f
20484 OPC_Decode, 224, 122, 6, // 307: decode to QC_E_LHU using decoder 6
20485 // 307: }
20486 // 307: } // switch Inst[31:30]
20487 // 307: }
20488 6, 0, // 311: case 0x6: {
20489 OPC_SwitchField, 30, 2, // 313: switch Inst[31:30] {
20490 0, 11, // 316: case 0x0: {
20491 OPC_CheckPredicate, 214, 1, // 318: check predicate 214
20492 OPC_CheckField, 0, 7, 31, // 321: check Inst[6:0] == 0x1f
20493 OPC_Decode, 226, 122, 6, // 325: decode to QC_E_LW using decoder 6
20494 // 325: }
20495 1, 11, // 329: case 0x1: {
20496 OPC_CheckPredicate, 214, 1, // 331: check predicate 214
20497 OPC_CheckField, 0, 7, 31, // 334: check Inst[6:0] == 0x1f
20498 OPC_Decode, 229, 122, 7, // 338: decode to QC_E_SB using decoder 7
20499 // 338: }
20500 2, 11, // 342: case 0x2: {
20501 OPC_CheckPredicate, 214, 1, // 344: check predicate 214
20502 OPC_CheckField, 0, 7, 31, // 347: check Inst[6:0] == 0x1f
20503 OPC_Decode, 230, 122, 7, // 351: decode to QC_E_SH using decoder 7
20504 // 351: }
20505 3, 0, // 355: case 0x3: {
20506 OPC_CheckPredicate, 214, 1, // 357: check predicate 214
20507 OPC_CheckField, 0, 7, 31, // 360: check Inst[6:0] == 0x1f
20508 OPC_Decode, 231, 122, 7, // 364: decode to QC_E_SW using decoder 7
20509 // 364: }
20510 // 364: } // switch Inst[31:30]
20511 // 364: }
20512 // 364: } // switch Inst[14:12]
20513};
20514// Handling 8 cases.
20515template <typename InsnType>
20516static std::enable_if_t<InsnBitWidth<InsnType> == 48, DecodeStatus>
20517decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
20518 DecodeComplete = true;
20519 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
20520 TmpType tmp;
20521 switch (Idx) {
20522 default: llvm_unreachable("Invalid decoder index!");
20523 case 0:
20524 tmp = fieldFromInstruction(insn, 7, 5);
20525 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20526 tmp = fieldFromInstruction(insn, 16, 32);
20527 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20528 return S;
20529 case 1:
20530 tmp = fieldFromInstruction(insn, 7, 5);
20531 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20532 tmp = fieldFromInstruction(insn, 7, 5);
20533 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20534 tmp = fieldFromInstruction(insn, 16, 32);
20535 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20536 return S;
20537 case 2:
20538 tmp = fieldFromInstruction(insn, 7, 5);
20539 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20540 tmp = fieldFromInstruction(insn, 15, 5);
20541 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20542 tmp = 0x0;
20543 tmp |= fieldFromInstruction(insn, 20, 10);
20544 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20545 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20546 return S;
20547 case 3:
20548 tmp = 0x0;
20549 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20550 tmp |= fieldFromInstruction(insn, 8, 4);
20551 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
20552 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20553 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20554 tmp |= fieldFromInstruction(insn, 32, 16) << 15;
20555 if (!Check(S, decodeSImmOperandAndLslN<32, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20556 return S;
20557 case 4:
20558 tmp = fieldFromInstruction(insn, 15, 5);
20559 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20560 tmp = fieldFromInstruction(insn, 32, 16);
20561 if (!Check(S, decodeSImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20562 tmp = 0x0;
20563 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20564 tmp |= fieldFromInstruction(insn, 8, 4);
20565 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20566 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20567 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20568 return S;
20569 case 5:
20570 tmp = fieldFromInstruction(insn, 15, 5);
20571 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20572 tmp = fieldFromInstruction(insn, 32, 16);
20573 if (!Check(S, decodeUImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20574 tmp = 0x0;
20575 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20576 tmp |= fieldFromInstruction(insn, 8, 4);
20577 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20578 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20579 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20580 return S;
20581 case 6:
20582 tmp = fieldFromInstruction(insn, 7, 5);
20583 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20584 tmp = fieldFromInstruction(insn, 15, 5);
20585 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20586 tmp = 0x0;
20587 tmp |= fieldFromInstruction(insn, 20, 10);
20588 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20589 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20590 return S;
20591 case 7:
20592 tmp = fieldFromInstruction(insn, 20, 5);
20593 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20594 tmp = fieldFromInstruction(insn, 15, 5);
20595 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20596 tmp = 0x0;
20597 tmp |= fieldFromInstruction(insn, 7, 5);
20598 tmp |= fieldFromInstruction(insn, 25, 5) << 5;
20599 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20600 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20601 return S;
20602 }
20603}
20604static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) {
20605 switch (Idx) {
20606 default: llvm_unreachable("Invalid index!");
20607 case 0:
20608 return FB[RISCV::FeatureStdExtZca];
20609 case 1:
20610 return FB[RISCV::FeatureStdExtZcd];
20611 case 2:
20612 return FB[RISCV::FeatureStdExtZca] && FB[RISCV::Feature64Bit];
20613 case 3:
20614 return FB[RISCV::FeatureStdExtZcmop];
20615 case 4:
20616 return FB[RISCV::FeatureStdExtZcb];
20617 case 5:
20618 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZmmul];
20619 case 6:
20620 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZbb];
20621 case 7:
20622 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
20623 case 8:
20624 return FB[RISCV::FeatureStdExtZcf] && !(FB[RISCV::Feature64Bit]);
20625 case 9:
20626 return FB[RISCV::FeatureStdExtZca] && !(FB[RISCV::Feature64Bit]);
20627 case 10:
20628 return FB[RISCV::FeatureVendorXqccmp];
20629 case 11:
20630 return FB[RISCV::FeatureVendorXqccmt];
20631 case 12:
20632 return FB[RISCV::FeatureVendorXqciint] && !(FB[RISCV::Feature64Bit]);
20633 case 13:
20634 return FB[RISCV::FeatureVendorXqcibm] && !(FB[RISCV::Feature64Bit]);
20635 case 14:
20636 return FB[RISCV::FeatureVendorXqciac] && !(FB[RISCV::Feature64Bit]);
20637 case 15:
20638 return FB[RISCV::FeatureVendorXqcisync] && !(FB[RISCV::Feature64Bit]);
20639 case 16:
20640 return FB[RISCV::FeatureVendorXqcicm] && !(FB[RISCV::Feature64Bit]);
20641 case 17:
20642 return FB[RISCV::FeatureVendorXwchc];
20643 case 18:
20644 return FB[RISCV::FeatureStdExtZclsd] && !(FB[RISCV::Feature64Bit]);
20645 case 19:
20646 return FB[RISCV::FeatureStdExtZcmt];
20647 case 20:
20648 return FB[RISCV::FeatureStdExtZcmp];
20649 case 21:
20650 return FB[RISCV::Feature64Bit];
20651 case 22:
20652 return FB[RISCV::FeatureStdExtZve32x];
20653 case 23:
20654 return FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZfhmin] || FB[RISCV::FeatureStdExtZfbfmin];
20655 case 24:
20656 return FB[RISCV::FeatureStdExtF];
20657 case 25:
20658 return FB[RISCV::FeatureStdExtD];
20659 case 26:
20660 return FB[RISCV::FeatureStdExtQ];
20661 case 27:
20662 return FB[RISCV::FeatureStdExtZve64x];
20663 case 28:
20664 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtZve64x];
20665 case 29:
20666 return FB[RISCV::FeatureStdExtZve64x] && FB[RISCV::Feature64Bit];
20667 case 30:
20668 return FB[RISCV::FeatureStdExtZvvmtls];
20669 case 31:
20670 return FB[RISCV::FeatureStdExtZvvmttls];
20671 case 32:
20672 return FB[RISCV::FeatureStdExtZicbom];
20673 case 33:
20674 return FB[RISCV::FeatureStdExtZicboz];
20675 case 34:
20676 return FB[RISCV::FeatureStdExtZbkb] && !(FB[RISCV::Feature64Bit]);
20677 case 35:
20678 return FB[RISCV::FeatureStdExtZknh];
20679 case 36:
20680 return FB[RISCV::FeatureStdExtZknh] && FB[RISCV::Feature64Bit];
20681 case 37:
20682 return FB[RISCV::FeatureStdExtZksh];
20683 case 38:
20684 return FB[RISCV::FeatureStdExtZbs];
20685 case 39:
20686 return FB[RISCV::FeatureStdExtZknd] && FB[RISCV::Feature64Bit];
20687 case 40:
20688 return (FB[RISCV::FeatureStdExtZknd] || FB[RISCV::FeatureStdExtZkne]) && FB[RISCV::Feature64Bit];
20689 case 41:
20690 return FB[RISCV::FeatureStdExtZbb];
20691 case 42:
20692 return FB[RISCV::FeatureStdExtP];
20693 case 43:
20694 return FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb];
20695 case 44:
20696 return FB[RISCV::FeatureStdExtZbkb];
20697 case 45:
20698 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && !(FB[RISCV::Feature64Bit]);
20699 case 46:
20700 return FB[RISCV::FeatureStdExtP] && !(FB[RISCV::Feature64Bit]);
20701 case 47:
20702 return FB[RISCV::FeatureStdExtP] && FB[RISCV::Feature64Bit];
20703 case 48:
20704 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && FB[RISCV::Feature64Bit];
20705 case 49:
20706 return FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
20707 case 50:
20708 return FB[RISCV::FeatureStdExtZbb] && FB[RISCV::Feature64Bit];
20709 case 51:
20710 return FB[RISCV::FeatureStdExtZabha];
20711 case 52:
20712 return FB[RISCV::FeatureStdExtZaamo];
20713 case 53:
20714 return FB[RISCV::FeatureStdExtZaamo] && FB[RISCV::Feature64Bit];
20715 case 54:
20716 return FB[RISCV::FeatureStdExtZalrsc];
20717 case 55:
20718 return FB[RISCV::FeatureStdExtZalrsc] && FB[RISCV::Feature64Bit];
20719 case 56:
20720 return FB[RISCV::FeatureStdExtZabha] && FB[RISCV::FeatureStdExtZacas];
20721 case 57:
20722 return FB[RISCV::FeatureStdExtZacas];
20723 case 58:
20724 return FB[RISCV::FeatureStdExtZacas] && FB[RISCV::Feature64Bit];
20725 case 59:
20726 return FB[RISCV::FeatureStdExtZalasr];
20727 case 60:
20728 return FB[RISCV::FeatureStdExtZalasr] && FB[RISCV::Feature64Bit];
20729 case 61:
20730 return FB[RISCV::FeatureStdExtZicfiss];
20731 case 62:
20732 return FB[RISCV::FeatureStdExtZicfiss] && FB[RISCV::Feature64Bit];
20733 case 63:
20734 return FB[RISCV::FeatureStdExtZilx];
20735 case 64:
20736 return FB[RISCV::FeatureStdExtZilx] && FB[RISCV::Feature64Bit];
20737 case 65:
20738 return FB[RISCV::FeatureStdExtZmmul];
20739 case 66:
20740 return FB[RISCV::FeatureStdExtM];
20741 case 67:
20742 return FB[RISCV::FeatureStdExtZbkb] || FB[RISCV::FeatureStdExtP];
20743 case 68:
20744 return FB[RISCV::FeatureStdExtZbkc];
20745 case 69:
20746 return FB[RISCV::FeatureStdExtZbc];
20747 case 70:
20748 return FB[RISCV::FeatureStdExtZicond];
20749 case 71:
20750 return FB[RISCV::FeatureStdExtZknh] && !(FB[RISCV::Feature64Bit]);
20751 case 72:
20752 return FB[RISCV::FeatureStdExtZba];
20753 case 73:
20754 return FB[RISCV::FeatureStdExtZkne] && !(FB[RISCV::Feature64Bit]);
20755 case 74:
20756 return FB[RISCV::FeatureStdExtZbkx];
20757 case 75:
20758 return FB[RISCV::FeatureStdExtZknd] && !(FB[RISCV::Feature64Bit]);
20759 case 76:
20760 return FB[RISCV::FeatureStdExtZksed];
20761 case 77:
20762 return FB[RISCV::FeatureStdExtZkne] && FB[RISCV::Feature64Bit];
20763 case 78:
20764 return FB[RISCV::FeatureStdExtZmmul] && FB[RISCV::Feature64Bit];
20765 case 79:
20766 return FB[RISCV::FeatureStdExtM] && FB[RISCV::Feature64Bit];
20767 case 80:
20768 return FB[RISCV::FeatureStdExtZbkb] && FB[RISCV::Feature64Bit];
20769 case 81:
20770 return FB[RISCV::FeatureStdExtZfh];
20771 case 82:
20772 return FB[RISCV::FeatureStdExtZfa];
20773 case 83:
20774 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD];
20775 case 84:
20776 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtZfh];
20777 case 85:
20778 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ];
20779 case 86:
20780 return FB[RISCV::FeatureStdExtZfhmin];
20781 case 87:
20782 return FB[RISCV::FeatureStdExtZfbfmin];
20783 case 88:
20784 return FB[RISCV::FeatureStdExtZfhmin] && FB[RISCV::FeatureStdExtD];
20785 case 89:
20786 return FB[RISCV::FeatureStdExtZfhmin] && FB[RISCV::FeatureStdExtQ];
20787 case 90:
20788 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD] && !(FB[RISCV::Feature64Bit]);
20789 case 91:
20790 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
20791 case 92:
20792 return FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
20793 case 93:
20794 return FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
20795 case 94:
20796 return FB[RISCV::FeatureStdExtZfh] && FB[RISCV::Feature64Bit];
20797 case 95:
20798 return FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
20799 case 96:
20800 return FB[RISCV::FeatureStdExtZfa] && (FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZvfh]);
20801 case 97:
20802 return FB[RISCV::FeatureStdExtZvkb];
20803 case 98:
20804 return FB[RISCV::FeatureStdExtZvzip];
20805 case 99:
20806 return FB[RISCV::FeatureStdExtZvbb];
20807 case 100:
20808 return FB[RISCV::FeatureStdExtZvvmm];
20809 case 101:
20810 return FB[RISCV::FeatureStdExtZvvfmm];
20811 case 102:
20812 return FB[RISCV::FeatureStdExtZvabd];
20813 case 103:
20814 return FB[RISCV::FeatureStdExtZve32f];
20815 case 104:
20816 return FB[RISCV::FeatureStdExtZvfbfmin] || FB[RISCV::FeatureStdExtZvfofp8min];
20817 case 105:
20818 return FB[RISCV::FeatureStdExtZvfofp8min];
20819 case 106:
20820 return FB[RISCV::FeatureStdExtZvfbfwma];
20821 case 107:
20822 return FB[RISCV::FeatureStdExtZvbc] || FB[RISCV::FeatureStdExtZvbc32e];
20823 case 108:
20824 return FB[RISCV::FeatureStdExtZvdot4a8i];
20825 case 109:
20826 return FB[RISCV::FeatureStdExtZibi];
20827 case 110:
20828 return FB[RISCV::FeatureStdExtZawrs];
20829 case 111:
20830 return FB[RISCV::FeatureStdExtSmctr] || FB[RISCV::FeatureStdExtSsctr];
20831 case 112:
20832 return FB[RISCV::FeatureStdExtSsip];
20833 case 113:
20834 return FB[RISCV::FeatureStdExtSscsps];
20835 case 114:
20836 return FB[RISCV::FeatureStdExtSvinval];
20837 case 115:
20838 return FB[RISCV::FeatureStdExtH];
20839 case 116:
20840 return FB[RISCV::FeatureStdExtSvinval] && FB[RISCV::FeatureStdExtH];
20841 case 117:
20842 return FB[RISCV::FeatureStdExtSmip];
20843 case 118:
20844 return FB[RISCV::FeatureStdExtSmcsps];
20845 case 119:
20846 return FB[RISCV::FeatureStdExtSmrnmi];
20847 case 120:
20848 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtH];
20849 case 121:
20850 return FB[RISCV::FeatureStdExtZimop];
20851 case 122:
20852 return FB[RISCV::FeatureStdExtZvksh];
20853 case 123:
20854 return FB[RISCV::FeatureStdExtZvksed];
20855 case 124:
20856 return FB[RISCV::FeatureStdExtZvkned];
20857 case 125:
20858 return FB[RISCV::FeatureStdExtZvkgs];
20859 case 126:
20860 return FB[RISCV::FeatureStdExtZvfwdota16bf];
20861 case 127:
20862 return FB[RISCV::FeatureStdExtZvqwdota8i] || FB[RISCV::FeatureStdExtZvqwdota16i];
20863 case 128:
20864 return FB[RISCV::FeatureStdExtZvfqwdota8f];
20865 case 129:
20866 return FB[RISCV::FeatureStdExtZvkg];
20867 case 130:
20868 return FB[RISCV::FeatureStdExtZvfbdota32f];
20869 case 131:
20870 return FB[RISCV::FeatureStdExtZvfwbdota16bf];
20871 case 132:
20872 return FB[RISCV::FeatureStdExtZvknha];
20873 case 133:
20874 return FB[RISCV::FeatureStdExtZvqwbdota8i] || FB[RISCV::FeatureStdExtZvqwbdota16i];
20875 case 134:
20876 return FB[RISCV::FeatureStdExtZvfqwbdota8f];
20877 case 135:
20878 return FB[RISCV::FeatureStdExtY];
20879 case 136:
20880 return FB[RISCV::FeatureStdExtZilsd] && !(FB[RISCV::Feature64Bit]);
20881 case 137:
20882 return FB[RISCV::FeatureStdExtZacas] && !(FB[RISCV::Feature64Bit]);
20883 case 138:
20884 return FB[RISCV::FeatureVendorXAIFET];
20885 case 139:
20886 return FB[RISCV::FeatureVendorXAndesPerf];
20887 case 140:
20888 return FB[RISCV::FeatureVendorXAndesVBFHCvt];
20889 case 141:
20890 return FB[RISCV::FeatureVendorXAndesBFHCvt];
20891 case 142:
20892 return FB[RISCV::FeatureVendorXAndesVSIntH];
20893 case 143:
20894 return FB[RISCV::FeatureVendorXAndesVSIntLoad];
20895 case 144:
20896 return FB[RISCV::FeatureVendorXAndesVPackFPH];
20897 case 145:
20898 return FB[RISCV::FeatureVendorXAndesPerf] && FB[RISCV::Feature64Bit];
20899 case 146:
20900 return FB[RISCV::FeatureVendorXAndesVDot];
20901 case 147:
20902 return FB[RISCV::FeatureVendorXCVmem] && !(FB[RISCV::Feature64Bit]);
20903 case 148:
20904 return FB[RISCV::FeatureVendorXCVbitmanip] && !(FB[RISCV::Feature64Bit]);
20905 case 149:
20906 return FB[RISCV::FeatureVendorXCVsimd] && !(FB[RISCV::Feature64Bit]);
20907 case 150:
20908 return FB[RISCV::FeatureVendorXCValu] && !(FB[RISCV::Feature64Bit]);
20909 case 151:
20910 return FB[RISCV::FeatureVendorXCVelw] && !(FB[RISCV::Feature64Bit]);
20911 case 152:
20912 return FB[RISCV::FeatureVendorXCVmac] && !(FB[RISCV::Feature64Bit]);
20913 case 153:
20914 return FB[RISCV::FeatureVendorXCVbi] && !(FB[RISCV::Feature64Bit]);
20915 case 154:
20916 return FB[RISCV::FeatureVendorXMIPSCBOP];
20917 case 155:
20918 return FB[RISCV::FeatureVendorXMIPSEXECTL];
20919 case 156:
20920 return FB[RISCV::FeatureVendorXMIPSCMov];
20921 case 157:
20922 return FB[RISCV::FeatureVendorXMIPSLSP];
20923 case 158:
20924 return FB[RISCV::FeatureVendorXSMTVDotII] && FB[RISCV::Feature64Bit];
20925 case 159:
20926 return FB[RISCV::FeatureVendorXSMTVDot] && FB[RISCV::Feature64Bit];
20927 case 160:
20928 return FB[RISCV::FeatureVendorXSfcease];
20929 case 161:
20930 return FB[RISCV::FeatureVendorXSiFivecflushdlone];
20931 case 162:
20932 return FB[RISCV::FeatureVendorXSiFivecdiscarddlone];
20933 case 163:
20934 return FB[RISCV::FeatureVendorXSfvcp];
20935 case 164:
20936 return FB[RISCV::FeatureVendorXSfmmbase];
20937 case 165:
20938 return FB[RISCV::FeatureVendorXSfvfexpa];
20939 case 166:
20940 return FB[RISCV::FeatureVendorXSfvfbfexp16e] || FB[RISCV::FeatureVendorXSfvfexp16e] || FB[RISCV::FeatureVendorXSfvfexp32e];
20941 case 167:
20942 return FB[RISCV::FeatureVendorXSfvfnrclipxfqf];
20943 case 168:
20944 return FB[RISCV::FeatureVendorXSfvqmaccdod];
20945 case 169:
20946 return FB[RISCV::FeatureVendorXSfmm32a8i];
20947 case 170:
20948 return FB[RISCV::FeatureVendorXSfvfwmaccqqq];
20949 case 171:
20950 return FB[RISCV::FeatureVendorXSfmm32a16f] || FB[RISCV::FeatureVendorXSfmm32a32f] || FB[RISCV::FeatureVendorXSfmm64a64f];
20951 case 172:
20952 return FB[RISCV::FeatureVendorXSfmm32a8f];
20953 case 173:
20954 return FB[RISCV::FeatureVendorXSfvqmaccqoq];
20955 case 174:
20956 return FB[RISCV::FeatureVendorXTHeadCmo];
20957 case 175:
20958 return FB[RISCV::FeatureVendorXTHeadSync];
20959 case 176:
20960 return FB[RISCV::FeatureVendorXTHeadBa];
20961 case 177:
20962 return FB[RISCV::FeatureVendorXTHeadBb];
20963 case 178:
20964 return FB[RISCV::FeatureVendorXTHeadBb] && FB[RISCV::Feature64Bit];
20965 case 179:
20966 return FB[RISCV::FeatureVendorXTHeadMac];
20967 case 180:
20968 return FB[RISCV::FeatureVendorXTHeadMac] && FB[RISCV::Feature64Bit];
20969 case 181:
20970 return FB[RISCV::FeatureVendorXTHeadCondMov];
20971 case 182:
20972 return FB[RISCV::FeatureVendorXTHeadBs];
20973 case 183:
20974 return FB[RISCV::FeatureVendorXTHeadMemIdx];
20975 case 184:
20976 return FB[RISCV::FeatureVendorXTHeadMemIdx] && FB[RISCV::Feature64Bit];
20977 case 185:
20978 return FB[RISCV::FeatureVendorXTHeadMemPair];
20979 case 186:
20980 return FB[RISCV::FeatureVendorXTHeadMemPair] && FB[RISCV::Feature64Bit];
20981 case 187:
20982 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF];
20983 case 188:
20984 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
20985 case 189:
20986 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD];
20987 case 190:
20988 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
20989 case 191:
20990 return FB[RISCV::FeatureVendorXTHeadVdot];
20991 case 192:
20992 return FB[RISCV::FeatureVendorXqcia] && !(FB[RISCV::Feature64Bit]);
20993 case 193:
20994 return FB[RISCV::FeatureVendorXqciio] && !(FB[RISCV::Feature64Bit]);
20995 case 194:
20996 return FB[RISCV::FeatureVendorXqcilsm] && !(FB[RISCV::Feature64Bit]);
20997 case 195:
20998 return FB[RISCV::FeatureVendorXqcisls] && !(FB[RISCV::Feature64Bit]);
20999 case 196:
21000 return FB[RISCV::FeatureVendorXqcisim] && !(FB[RISCV::Feature64Bit]);
21001 case 197:
21002 return FB[RISCV::FeatureVendorXqcili] && !(FB[RISCV::Feature64Bit]);
21003 case 198:
21004 return FB[RISCV::FeatureVendorXqcicli] && !(FB[RISCV::Feature64Bit]);
21005 case 199:
21006 return FB[RISCV::FeatureVendorXqcics] && !(FB[RISCV::Feature64Bit]);
21007 case 200:
21008 return FB[RISCV::FeatureVendorXqcicsr] && !(FB[RISCV::Feature64Bit]);
21009 case 201:
21010 return FB[RISCV::FeatureVendorXqcibi] && !(FB[RISCV::Feature64Bit]);
21011 case 202:
21012 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && !(FB[RISCV::Feature64Bit]);
21013 case 203:
21014 return FB[RISCV::FeatureStdExtZdinx] && !(FB[RISCV::Feature64Bit]);
21015 case 204:
21016 return FB[RISCV::FeatureStdExtZfinx];
21017 case 205:
21018 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
21019 case 206:
21020 return FB[RISCV::FeatureStdExtZhinx];
21021 case 207:
21022 return FB[RISCV::FeatureStdExtZhinxmin];
21023 case 208:
21024 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
21025 case 209:
21026 return FB[RISCV::FeatureStdExtZfinx] && FB[RISCV::Feature64Bit];
21027 case 210:
21028 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit] && FB[RISCV::Feature64Bit];
21029 case 211:
21030 return FB[RISCV::FeatureStdExtZhinx] && FB[RISCV::Feature64Bit];
21031 case 212:
21032 return FB[RISCV::FeatureVendorXqcilia] && !(FB[RISCV::Feature64Bit]);
21033 case 213:
21034 return FB[RISCV::FeatureVendorXqcilb] && !(FB[RISCV::Feature64Bit]);
21035 case 214:
21036 return FB[RISCV::FeatureVendorXqcilo] && !(FB[RISCV::Feature64Bit]);
21037 }
21038}
21039
21040
21041template <typename InsnType>
21042static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
21043 InsnType insn, uint64_t Address,
21044 const MCDisassembler *DisAsm,
21045 const MCSubtargetInfo &STI) {
21046 const FeatureBitset &Bits = STI.getFeatureBits();
21047 const uint8_t *Ptr = DecodeTable;
21048
21049 [[maybe_unused]] uint32_t BitWidth = decodeULEB128AndIncUnsafe(p&: Ptr);
21050 assert(InsnBitWidth<InsnType> == BitWidth &&
21051 "Table and instruction bitwidth mismatch");
21052
21053 SmallVector<const uint8_t *, 8> ScopeStack;
21054 DecodeStatus S = MCDisassembler::Success;
21055 while (true) {
21056 ptrdiff_t Loc = Ptr - DecodeTable;
21057 const uint8_t DecoderOp = *Ptr++;
21058 switch (DecoderOp) {
21059 default:
21060 errs() << Loc << ": Unexpected decode table opcode: "
21061 << (int)DecoderOp << '\n';
21062 return MCDisassembler::Fail;
21063 case OPC_Scope: {
21064 unsigned NumToSkip = decodeULEB128AndIncUnsafe(p&: Ptr);
21065 const uint8_t *SkipTo = Ptr + NumToSkip;
21066 ScopeStack.push_back(Elt: SkipTo);
21067 LLVM_DEBUG(dbgs() << Loc << ": OPC_Scope(" << SkipTo - DecodeTable
21068 << ")\n");
21069 continue;
21070 }
21071 case OPC_SwitchField: {
21072 // Decode the start value.
21073 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
21074 unsigned Len = *Ptr++;
21075 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
21076 uint64_t CaseValue;
21077 unsigned CaseSize;
21078 while (true) {
21079 CaseValue = decodeULEB128AndIncUnsafe(p&: Ptr);
21080 CaseSize = decodeULEB128AndIncUnsafe(p&: Ptr);
21081 if (FieldValue == CaseValue || !CaseSize)
21082 break;
21083 Ptr += CaseSize;
21084 }
21085 if (FieldValue == CaseValue) {
21086 LLVM_DEBUG(dbgs() << Loc << ": OPC_SwitchField(" << Start << ", " << Len
21087 << "): " << FieldValue << '\n');
21088 continue;
21089 }
21090 break;
21091 }
21092 case OPC_CheckField: {
21093 // Decode the start value.
21094 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
21095 unsigned Len = *Ptr;
21096 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
21097 // Decode the field value.
21098 unsigned PtrLen = 0;
21099 uint64_t ExpectedValue = decodeULEB128(p: ++Ptr, n: &PtrLen);
21100 Ptr += PtrLen;
21101 bool Failed = ExpectedValue != FieldValue;
21102
21103 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckField(" << Start << ", " << Len
21104 << ", " << ExpectedValue << "): FieldValue = "
21105 << FieldValue << ", ExpectedValue = " << ExpectedValue
21106 << ": " << (Failed ? "FAIL, " : "PASS\n"););
21107 if (!Failed)
21108 continue;
21109 break;
21110 }
21111 case OPC_CheckPredicate: {
21112 // Decode the Predicate Index value.
21113 unsigned PIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
21114 // Check the predicate.
21115 bool Failed = !checkDecoderPredicate(Idx: PIdx, FB: Bits);
21116
21117 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckPredicate(" << PIdx << "): "
21118 << (Failed ? "FAIL, " : "PASS\n"););
21119 if (!Failed)
21120 continue;
21121 break;
21122 }
21123 case OPC_Decode: {
21124 // Decode the Opcode value.
21125 unsigned Opc = decodeULEB128AndIncUnsafe(p&: Ptr);
21126 unsigned DecodeIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
21127
21128 MI.clear();
21129 MI.setOpcode(Opc);
21130 bool DecodeComplete;
21131 S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm,
21132 DecodeComplete);
21133 LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc
21134 << ", using decoder " << DecodeIdx << ": "
21135 << (S ? "PASS, " : "FAIL, "));
21136
21137 if (DecodeComplete) {
21138 LLVM_DEBUG(dbgs() << "decoding complete\n");
21139 return S;
21140 }
21141 assert(S == MCDisassembler::Fail);
21142 // Reset decode status. This also drops a SoftFail status that could be
21143 // set before the decode attempt.
21144 S = MCDisassembler::Success;
21145 break;
21146 }
21147 }
21148 if (ScopeStack.empty()) {
21149 LLVM_DEBUG(dbgs() << "returning Fail\n");
21150 return MCDisassembler::Fail;
21151 }
21152 Ptr = ScopeStack.pop_back_val();
21153 LLVM_DEBUG(dbgs() << "continuing at " << Ptr - DecodeTable << '\n');
21154 }
21155 llvm_unreachable("bogosity detected in disassembler state machine!");
21156}
21157
21158
21159} // namespace
21160