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[594] = {
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, 222, 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, 156, 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, 198, 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, 199, 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, 154, 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, 211, 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, 164, 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, 157, 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, 165, 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, 186, 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, 184, 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, 187, 113, 9, // 123: decode to C_LWSP using decoder 9
92 // 123: }
93 // 123: } // switch Inst[1:0]
94 // 123: }
95 3, 97, // 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, 177, 113, 10, // 136: decode to C_LD using decoder 10
100 // 136: }
101 1, 76, // 140: case 0x1: {
102 OPC_Scope, 56, // 142: try {
103 OPC_SwitchField, 2, 11, // 144: switch Inst[12:2] {
104 96, 6, // 147: case 0x60: {
105 OPC_CheckPredicate, 3, // 149: check predicate 3
106 OPC_Decode, 193, 113, 0, // 151: decode to C_MOP_3 using decoder 0
107 // 151: }
108 224, 1, 6, // 155: case 0xe0: {
109 OPC_CheckPredicate, 3, // 158: check predicate 3
110 OPC_Decode, 194, 113, 0, // 160: decode to C_MOP_7 using decoder 0
111 // 160: }
112 160, 2, 6, // 164: case 0x120: {
113 OPC_CheckPredicate, 3, // 167: check predicate 3
114 OPC_Decode, 195, 113, 0, // 169: decode to C_MOP_9 using decoder 0
115 // 169: }
116 224, 2, 6, // 173: case 0x160: {
117 OPC_CheckPredicate, 3, // 176: check predicate 3
118 OPC_Decode, 190, 113, 0, // 178: decode to C_MOP_11 using decoder 0
119 // 178: }
120 160, 3, 6, // 182: case 0x1a0: {
121 OPC_CheckPredicate, 3, // 185: check predicate 3
122 OPC_Decode, 191, 113, 0, // 187: decode to C_MOP_13 using decoder 0
123 // 187: }
124 224, 3, 0, // 191: case 0x1e0: {
125 OPC_CheckPredicate, 3, // 194: check predicate 3
126 OPC_Decode, 192, 113, 0, // 196: decode to C_MOP_15 using decoder 0
127 // 196: }
128 // 196: } // switch Inst[12:2]
129 OPC_Scope, 10, // 200: } else try {
130 OPC_CheckField, 7, 5, 2, // 202: check Inst[11:7] == 0x2
131 OPC_CheckPredicate, 0, // 206: check predicate 0
132 OPC_Decode, 155, 113, 11, // 208: decode to C_ADDI16SP using decoder 11
133 // 208: } else try {
134 OPC_CheckPredicate, 0, // 212: check predicate 0
135 OPC_Decode, 185, 113, 12, // 214: decode to C_LUI using decoder 12
136 // 214: }
137 // 214: }
138 2, 0, // 218: case 0x2: {
139 OPC_CheckPredicate, 2, // 220: check predicate 2
140 OPC_Decode, 178, 113, 13, // 222: decode to C_LDSP using decoder 13
141 // 222: }
142 // 222: } // switch Inst[1:0]
143 // 222: }
144 4, 150, 2, // 226: case 0x4: {
145 OPC_SwitchField, 0, 2, // 229: switch Inst[1:0] {
146 0, 52, // 232: case 0x0: {
147 OPC_SwitchField, 10, 3, // 234: switch Inst[12:10] {
148 0, 6, // 237: case 0x0: {
149 OPC_CheckPredicate, 4, // 239: check predicate 4
150 OPC_Decode, 176, 113, 14, // 241: decode to C_LBU using decoder 14
151 // 241: }
152 1, 19, // 245: case 0x1: {
153 OPC_SwitchField, 6, 1, // 247: switch Inst[6] {
154 0, 6, // 250: case 0x0: {
155 OPC_CheckPredicate, 4, // 252: check predicate 4
156 OPC_Decode, 182, 113, 15, // 254: decode to C_LHU using decoder 15
157 // 254: }
158 1, 0, // 258: case 0x1: {
159 OPC_CheckPredicate, 4, // 260: check predicate 4
160 OPC_Decode, 181, 113, 15, // 262: decode to C_LH using decoder 15
161 // 262: }
162 // 262: } // switch Inst[6]
163 // 262: }
164 2, 6, // 266: case 0x2: {
165 OPC_CheckPredicate, 4, // 268: check predicate 4
166 OPC_Decode, 202, 113, 14, // 270: decode to C_SB using decoder 14
167 // 270: }
168 3, 0, // 274: case 0x3: {
169 OPC_CheckPredicate, 4, // 276: check predicate 4
170 OPC_CheckField, 6, 1, 0, // 278: check Inst[6] == 0x0
171 OPC_Decode, 209, 113, 15, // 282: decode to C_SH using decoder 15
172 // 282: }
173 // 282: } // switch Inst[12:10]
174 // 282: }
175 1, 161, 1, // 286: case 0x1: {
176 OPC_SwitchField, 10, 2, // 289: switch Inst[11:10] {
177 0, 6, // 292: case 0x0: {
178 OPC_CheckPredicate, 0, // 294: check predicate 0
179 OPC_Decode, 213, 113, 16, // 296: decode to C_SRLI using decoder 16
180 // 296: }
181 1, 6, // 300: case 0x1: {
182 OPC_CheckPredicate, 0, // 302: check predicate 0
183 OPC_Decode, 212, 113, 16, // 304: decode to C_SRAI using decoder 16
184 // 304: }
185 2, 6, // 308: case 0x2: {
186 OPC_CheckPredicate, 0, // 310: check predicate 0
187 OPC_Decode, 160, 113, 17, // 312: decode to C_ANDI using decoder 17
188 // 312: }
189 3, 0, // 316: case 0x3: {
190 OPC_SwitchField, 5, 2, // 318: switch Inst[6:5] {
191 0, 19, // 321: case 0x0: {
192 OPC_SwitchField, 12, 1, // 323: switch Inst[12] {
193 0, 6, // 326: case 0x0: {
194 OPC_CheckPredicate, 0, // 328: check predicate 0
195 OPC_Decode, 216, 113, 18, // 330: decode to C_SUB using decoder 18
196 // 330: }
197 1, 0, // 334: case 0x1: {
198 OPC_CheckPredicate, 2, // 336: check predicate 2
199 OPC_Decode, 217, 113, 18, // 338: decode to C_SUBW using decoder 18
200 // 338: }
201 // 338: } // switch Inst[12]
202 // 338: }
203 1, 19, // 342: case 0x1: {
204 OPC_SwitchField, 12, 1, // 344: switch Inst[12] {
205 0, 6, // 347: case 0x0: {
206 OPC_CheckPredicate, 0, // 349: check predicate 0
207 OPC_Decode, 223, 113, 18, // 351: decode to C_XOR using decoder 18
208 // 351: }
209 1, 0, // 355: case 0x1: {
210 OPC_CheckPredicate, 2, // 357: check predicate 2
211 OPC_Decode, 158, 113, 18, // 359: decode to C_ADDW using decoder 18
212 // 359: }
213 // 359: } // switch Inst[12]
214 // 359: }
215 2, 19, // 363: case 0x2: {
216 OPC_SwitchField, 12, 1, // 365: switch Inst[12] {
217 0, 6, // 368: case 0x0: {
218 OPC_CheckPredicate, 0, // 370: check predicate 0
219 OPC_Decode, 201, 113, 18, // 372: decode to C_OR using decoder 18
220 // 372: }
221 1, 0, // 376: case 0x1: {
222 OPC_CheckPredicate, 5, // 378: check predicate 5
223 OPC_Decode, 196, 113, 18, // 380: decode to C_MUL using decoder 18
224 // 380: }
225 // 380: } // switch Inst[12]
226 // 380: }
227 3, 0, // 384: case 0x3: {
228 OPC_SwitchField, 12, 1, // 386: switch Inst[12] {
229 0, 6, // 389: case 0x0: {
230 OPC_CheckPredicate, 0, // 391: check predicate 0
231 OPC_Decode, 159, 113, 18, // 393: decode to C_AND using decoder 18
232 // 393: }
233 1, 0, // 397: case 0x1: {
234 OPC_SwitchField, 2, 3, // 399: switch Inst[4:2] {
235 0, 6, // 402: case 0x0: {
236 OPC_CheckPredicate, 4, // 404: check predicate 4
237 OPC_Decode, 224, 113, 19, // 406: decode to C_ZEXT_B using decoder 19
238 // 406: }
239 1, 6, // 410: case 0x1: {
240 OPC_CheckPredicate, 6, // 412: check predicate 6
241 OPC_Decode, 207, 113, 19, // 414: decode to C_SEXT_B using decoder 19
242 // 414: }
243 2, 6, // 418: case 0x2: {
244 OPC_CheckPredicate, 6, // 420: check predicate 6
245 OPC_Decode, 225, 113, 19, // 422: decode to C_ZEXT_H using decoder 19
246 // 422: }
247 3, 6, // 426: case 0x3: {
248 OPC_CheckPredicate, 6, // 428: check predicate 6
249 OPC_Decode, 208, 113, 19, // 430: decode to C_SEXT_H using decoder 19
250 // 430: }
251 4, 6, // 434: case 0x4: {
252 OPC_CheckPredicate, 7, // 436: check predicate 7
253 OPC_Decode, 226, 113, 19, // 438: decode to C_ZEXT_W using decoder 19
254 // 438: }
255 5, 0, // 442: case 0x5: {
256 OPC_CheckPredicate, 4, // 444: check predicate 4
257 OPC_Decode, 200, 113, 19, // 446: decode to C_NOT using decoder 19
258 // 446: }
259 // 446: } // switch Inst[4:2]
260 // 446: }
261 // 446: } // switch Inst[12]
262 // 446: }
263 // 446: } // switch Inst[6:5]
264 // 446: }
265 // 446: } // switch Inst[11:10]
266 // 446: }
267 2, 0, // 450: case 0x2: {
268 OPC_SwitchField, 12, 1, // 452: switch Inst[12] {
269 0, 18, // 455: case 0x0: {
270 OPC_Scope, 10, // 457: try {
271 OPC_CheckField, 2, 5, 0, // 459: check Inst[6:2] == 0x0
272 OPC_CheckPredicate, 0, // 463: check predicate 0
273 OPC_Decode, 175, 113, 20, // 465: decode to C_JR using decoder 20
274 // 465: } else try {
275 OPC_CheckPredicate, 0, // 469: check predicate 0
276 OPC_Decode, 197, 113, 21, // 471: decode to C_MV using decoder 21
277 // 471: }
278 // 471: }
279 1, 0, // 475: case 0x1: {
280 OPC_Scope, 10, // 477: try {
281 OPC_CheckField, 2, 10, 0, // 479: check Inst[11:2] == 0x0
282 OPC_CheckPredicate, 0, // 483: check predicate 0
283 OPC_Decode, 163, 113, 0, // 485: decode to C_EBREAK using decoder 0
284 OPC_Scope, 10, // 489: } else try {
285 OPC_CheckField, 2, 5, 0, // 491: check Inst[6:2] == 0x0
286 OPC_CheckPredicate, 0, // 495: check predicate 0
287 OPC_Decode, 174, 113, 20, // 497: decode to C_JALR using decoder 20
288 // 497: } else try {
289 OPC_CheckPredicate, 0, // 501: check predicate 0
290 OPC_Decode, 153, 113, 22, // 503: decode to C_ADD using decoder 22
291 // 503: }
292 // 503: }
293 // 503: } // switch Inst[12]
294 // 503: }
295 // 503: } // switch Inst[1:0]
296 // 503: }
297 5, 27, // 507: case 0x5: {
298 OPC_SwitchField, 0, 2, // 509: switch Inst[1:0] {
299 0, 6, // 512: case 0x0: {
300 OPC_CheckPredicate, 1, // 514: check predicate 1
301 OPC_Decode, 168, 113, 5, // 516: decode to C_FSD using decoder 5
302 // 516: }
303 1, 6, // 520: case 0x1: {
304 OPC_CheckPredicate, 0, // 522: check predicate 0
305 OPC_Decode, 172, 113, 23, // 524: decode to C_J using decoder 23
306 // 524: }
307 2, 0, // 528: case 0x2: {
308 OPC_CheckPredicate, 1, // 530: check predicate 1
309 OPC_Decode, 169, 113, 24, // 532: decode to C_FSDSP using decoder 24
310 // 532: }
311 // 532: } // switch Inst[1:0]
312 // 532: }
313 6, 27, // 536: case 0x6: {
314 OPC_SwitchField, 0, 2, // 538: switch Inst[1:0] {
315 0, 6, // 541: case 0x0: {
316 OPC_CheckPredicate, 0, // 543: check predicate 0
317 OPC_Decode, 218, 113, 7, // 545: decode to C_SW using decoder 7
318 // 545: }
319 1, 6, // 549: case 0x1: {
320 OPC_CheckPredicate, 0, // 551: check predicate 0
321 OPC_Decode, 161, 113, 25, // 553: decode to C_BEQZ using decoder 25
322 // 553: }
323 2, 0, // 557: case 0x2: {
324 OPC_CheckPredicate, 0, // 559: check predicate 0
325 OPC_Decode, 219, 113, 26, // 561: decode to C_SWSP using decoder 26
326 // 561: }
327 // 561: } // switch Inst[1:0]
328 // 561: }
329 7, 0, // 565: case 0x7: {
330 OPC_SwitchField, 0, 2, // 567: switch Inst[1:0] {
331 0, 6, // 570: case 0x0: {
332 OPC_CheckPredicate, 2, // 572: check predicate 2
333 OPC_Decode, 203, 113, 10, // 574: decode to C_SD using decoder 10
334 // 574: }
335 1, 6, // 578: case 0x1: {
336 OPC_CheckPredicate, 0, // 580: check predicate 0
337 OPC_Decode, 162, 113, 25, // 582: decode to C_BNEZ using decoder 25
338 // 582: }
339 2, 0, // 586: case 0x2: {
340 OPC_CheckPredicate, 2, // 588: check predicate 2
341 OPC_Decode, 204, 113, 27, // 590: decode to C_SDSP using decoder 27
342 // 590: }
343 // 590: } // switch Inst[1:0]
344 // 590: }
345 // 590: } // switch Inst[15:13]
346};
347static const uint8_t DecoderTableRV32Only16[58] = {
348 16, // 0: BitWidth 16
349 OPC_SwitchField, 0, 2, // 1: switch Inst[1:0] {
350 0, 19, // 4: case 0x0: {
351 OPC_SwitchField, 13, 3, // 6: switch Inst[15:13] {
352 3, 6, // 9: case 0x3: {
353 OPC_CheckPredicate, 8, // 11: check predicate 8
354 OPC_Decode, 166, 113, 28, // 13: decode to C_FLW using decoder 28
355 // 13: }
356 7, 0, // 17: case 0x7: {
357 OPC_CheckPredicate, 8, // 19: check predicate 8
358 OPC_Decode, 170, 113, 28, // 21: decode to C_FSW using decoder 28
359 // 21: }
360 // 21: } // switch Inst[15:13]
361 // 21: }
362 1, 10, // 25: case 0x1: {
363 OPC_CheckPredicate, 9, // 27: check predicate 9
364 OPC_CheckField, 13, 3, 1, // 29: check Inst[15:13] == 0x1
365 OPC_Decode, 173, 113, 23, // 33: decode to C_JAL using decoder 23
366 // 33: }
367 2, 0, // 37: case 0x2: {
368 OPC_SwitchField, 13, 3, // 39: switch Inst[15:13] {
369 3, 6, // 42: case 0x3: {
370 OPC_CheckPredicate, 8, // 44: check predicate 8
371 OPC_Decode, 167, 113, 29, // 46: decode to C_FLWSP using decoder 29
372 // 46: }
373 7, 0, // 50: case 0x7: {
374 OPC_CheckPredicate, 8, // 52: check predicate 8
375 OPC_Decode, 171, 113, 30, // 54: decode to C_FSWSP using decoder 30
376 // 54: }
377 // 54: } // switch Inst[15:13]
378 // 54: }
379 // 54: } // switch Inst[1:0]
380};
381static const uint8_t DecoderTableXqccmp16[103] = {
382 16, // 0: BitWidth 16
383 OPC_SwitchField, 10, 6, // 1: switch Inst[15:10] {
384 43, 27, // 4: case 0x2b: {
385 OPC_SwitchField, 5, 2, // 6: switch Inst[6:5] {
386 1, 10, // 9: case 0x1: {
387 OPC_CheckPredicate, 10, // 11: check predicate 10
388 OPC_CheckField, 0, 2, 2, // 13: check Inst[1:0] == 0x2
389 OPC_Decode, 237, 121, 31, // 17: decode to QC_CM_MVSA01 using decoder 31
390 // 17: }
391 3, 0, // 21: case 0x3: {
392 OPC_CheckPredicate, 10, // 23: check predicate 10
393 OPC_CheckField, 0, 2, 2, // 25: check Inst[1:0] == 0x2
394 OPC_Decode, 236, 121, 31, // 29: decode to QC_CM_MVA01S using decoder 31
395 // 29: }
396 // 29: } // switch Inst[6:5]
397 // 29: }
398 46, 39, // 33: case 0x2e: {
399 OPC_SwitchField, 8, 2, // 35: switch Inst[9:8] {
400 0, 10, // 38: case 0x0: {
401 OPC_CheckPredicate, 10, // 40: check predicate 10
402 OPC_CheckField, 0, 2, 2, // 42: check Inst[1:0] == 0x2
403 OPC_Decode, 241, 121, 32, // 46: decode to QC_CM_PUSH using decoder 32
404 // 46: }
405 1, 10, // 50: case 0x1: {
406 OPC_CheckPredicate, 10, // 52: check predicate 10
407 OPC_CheckField, 0, 2, 2, // 54: check Inst[1:0] == 0x2
408 OPC_Decode, 242, 121, 33, // 58: decode to QC_CM_PUSHFP using decoder 33
409 // 58: }
410 2, 0, // 62: case 0x2: {
411 OPC_CheckPredicate, 10, // 64: check predicate 10
412 OPC_CheckField, 0, 2, 2, // 66: check Inst[1:0] == 0x2
413 OPC_Decode, 238, 121, 32, // 70: decode to QC_CM_POP using decoder 32
414 // 70: }
415 // 70: } // switch Inst[9:8]
416 // 70: }
417 47, 0, // 74: case 0x2f: {
418 OPC_SwitchField, 8, 2, // 76: switch Inst[9:8] {
419 0, 10, // 79: case 0x0: {
420 OPC_CheckPredicate, 10, // 81: check predicate 10
421 OPC_CheckField, 0, 2, 2, // 83: check Inst[1:0] == 0x2
422 OPC_Decode, 240, 121, 32, // 87: decode to QC_CM_POPRETZ using decoder 32
423 // 87: }
424 2, 0, // 91: case 0x2: {
425 OPC_CheckPredicate, 10, // 93: check predicate 10
426 OPC_CheckField, 0, 2, 2, // 95: check Inst[1:0] == 0x2
427 OPC_Decode, 239, 121, 32, // 99: decode to QC_CM_POPRET using decoder 32
428 // 99: }
429 // 99: } // switch Inst[9:8]
430 // 99: }
431 // 99: } // switch Inst[15:10]
432};
433static const uint8_t DecoderTableXqccmt16[27] = {
434 16, // 0: BitWidth 16
435 OPC_CheckField, 0, 2, 2, // 1: check Inst[1:0] == 0x2
436 OPC_CheckField, 10, 6, 40, // 5: check Inst[15:10] == 0x28
437 OPC_Scope, 10, // 9: try {
438 OPC_CheckField, 7, 3, 0, // 11: check Inst[9:7] == 0x0
439 OPC_CheckPredicate, 11, // 15: check predicate 11
440 OPC_Decode, 235, 121, 34, // 17: decode to QC_CM_JT using decoder 34
441 // 17: } else try {
442 OPC_CheckPredicate, 11, // 21: check predicate 11
443 OPC_Decode, 234, 121, 35, // 23: decode to QC_CM_JALT using decoder 35
444 // 23: }
445};
446static const uint8_t DecoderTableXqci16[234] = {
447 16, // 0: BitWidth 16
448 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
449 0, 119, // 4: case 0x0: {
450 OPC_CheckField, 0, 2, 2, // 6: check Inst[1:0] == 0x2
451 OPC_CheckField, 12, 1, 1, // 10: check Inst[12] == 0x1
452 OPC_Scope, 66, // 14: try {
453 OPC_SwitchField, 2, 10, // 16: switch Inst[11:2] {
454 132, 4, 6, // 19: case 0x204: {
455 OPC_CheckPredicate, 12, // 22: check predicate 12
456 OPC_Decode, 128, 122, 0, // 24: decode to QC_C_MIENTER using decoder 0
457 // 24: }
458 164, 4, 6, // 28: case 0x224: {
459 OPC_CheckPredicate, 12, // 31: check predicate 12
460 OPC_Decode, 129, 122, 0, // 33: decode to QC_C_MIENTER_NEST using decoder 0
461 // 33: }
462 196, 4, 6, // 37: case 0x244: {
463 OPC_CheckPredicate, 12, // 40: check predicate 12
464 OPC_Decode, 132, 122, 0, // 42: decode to QC_C_MRET using decoder 0
465 // 42: }
466 228, 4, 6, // 46: case 0x264: {
467 OPC_CheckPredicate, 12, // 49: check predicate 12
468 OPC_Decode, 131, 122, 0, // 51: decode to QC_C_MNRET using decoder 0
469 // 51: }
470 132, 5, 6, // 55: case 0x284: {
471 OPC_CheckPredicate, 12, // 58: check predicate 12
472 OPC_Decode, 130, 122, 0, // 60: decode to QC_C_MILEAVERET using decoder 0
473 // 60: }
474 196, 5, 6, // 64: case 0x2c4: {
475 OPC_CheckPredicate, 12, // 67: check predicate 12
476 OPC_Decode, 251, 121, 0, // 69: decode to QC_C_DI using decoder 0
477 // 69: }
478 228, 5, 0, // 73: case 0x2e4: {
479 OPC_CheckPredicate, 12, // 76: check predicate 12
480 OPC_Decode, 253, 121, 0, // 78: decode to QC_C_EI using decoder 0
481 // 78: }
482 // 78: } // switch Inst[11:2]
483 OPC_Scope, 35, // 82: } else try {
484 OPC_SwitchField, 2, 5, // 84: switch Inst[6:2] {
485 0, 6, // 87: case 0x0: {
486 OPC_CheckPredicate, 12, // 89: check predicate 12
487 OPC_Decode, 252, 121, 20, // 91: decode to QC_C_DIR using decoder 20
488 // 91: }
489 1, 6, // 95: case 0x1: {
490 OPC_CheckPredicate, 12, // 97: check predicate 12
491 OPC_Decode, 254, 121, 20, // 99: decode to QC_C_EIR using decoder 20
492 // 99: }
493 2, 6, // 103: case 0x2: {
494 OPC_CheckPredicate, 12, // 105: check predicate 12
495 OPC_Decode, 135, 122, 20, // 107: decode to QC_C_SETINT using decoder 20
496 // 107: }
497 3, 0, // 111: case 0x3: {
498 OPC_CheckPredicate, 12, // 113: check predicate 12
499 OPC_Decode, 250, 121, 20, // 115: decode to QC_C_CLRINT using decoder 20
500 // 115: }
501 // 115: } // switch Inst[6:2]
502 // 115: } else try {
503 OPC_CheckPredicate, 13, // 119: check predicate 13
504 OPC_Decode, 255, 121, 36, // 121: decode to QC_C_EXTU using decoder 36
505 // 121: }
506 // 121: }
507 1, 10, // 125: case 0x1: {
508 OPC_CheckPredicate, 14, // 127: check predicate 14
509 OPC_CheckField, 0, 2, 2, // 129: check Inst[1:0] == 0x2
510 OPC_Decode, 133, 122, 37, // 133: decode to QC_C_MULIADD using decoder 37
511 // 133: }
512 4, 75, // 137: case 0x4: {
513 OPC_SwitchField, 10, 3, // 139: switch Inst[12:10] {
514 0, 10, // 142: case 0x0: {
515 OPC_CheckPredicate, 15, // 144: check predicate 15
516 OPC_CheckField, 0, 7, 1, // 146: check Inst[6:0] == 0x1
517 OPC_Decode, 136, 122, 38, // 150: decode to QC_C_SYNC using decoder 38
518 // 150: }
519 1, 10, // 154: case 0x1: {
520 OPC_CheckPredicate, 15, // 156: check predicate 15
521 OPC_CheckField, 0, 7, 1, // 158: check Inst[6:0] == 0x1
522 OPC_Decode, 137, 122, 38, // 162: decode to QC_C_SYNCR using decoder 38
523 // 162: }
524 4, 22, // 166: case 0x4: {
525 OPC_CheckField, 0, 2, 1, // 168: check Inst[1:0] == 0x1
526 OPC_Scope, 10, // 172: try {
527 OPC_CheckField, 2, 5, 0, // 174: check Inst[6:2] == 0x0
528 OPC_CheckPredicate, 15, // 178: check predicate 15
529 OPC_Decode, 138, 122, 38, // 180: decode to QC_C_SYNCWF using decoder 38
530 // 180: } else try {
531 OPC_CheckPredicate, 13, // 184: check predicate 13
532 OPC_Decode, 248, 121, 39, // 186: decode to QC_C_BEXTI using decoder 39
533 // 186: }
534 // 186: }
535 5, 0, // 190: case 0x5: {
536 OPC_CheckField, 0, 2, 1, // 192: check Inst[1:0] == 0x1
537 OPC_Scope, 10, // 196: try {
538 OPC_CheckField, 2, 5, 0, // 198: check Inst[6:2] == 0x0
539 OPC_CheckPredicate, 15, // 202: check predicate 15
540 OPC_Decode, 139, 122, 38, // 204: decode to QC_C_SYNCWL using decoder 38
541 // 204: } else try {
542 OPC_CheckPredicate, 13, // 208: check predicate 13
543 OPC_Decode, 249, 121, 39, // 210: decode to QC_C_BSETI using decoder 39
544 // 210: }
545 // 210: }
546 // 210: } // switch Inst[12:10]
547 // 210: }
548 5, 0, // 214: case 0x5: {
549 OPC_CheckPredicate, 16, // 216: check predicate 16
550 OPC_CheckField, 10, 3, 3, // 218: check Inst[12:10] == 0x3
551 OPC_CheckField, 5, 2, 0, // 222: check Inst[6:5] == 0x0
552 OPC_CheckField, 0, 2, 2, // 226: check Inst[1:0] == 0x2
553 OPC_Decode, 134, 122, 40, // 230: decode to QC_C_MVEQZ using decoder 40
554 // 230: }
555 // 230: } // switch Inst[15:13]
556};
557static const uint8_t DecoderTableXwchc16[115] = {
558 16, // 0: BitWidth 16
559 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
560 1, 19, // 4: case 0x1: {
561 OPC_SwitchField, 0, 2, // 6: switch Inst[1:0] {
562 0, 6, // 9: case 0x0: {
563 OPC_CheckPredicate, 17, // 11: check predicate 17
564 OPC_Decode, 251, 122, 41, // 13: decode to QK_C_LBU using decoder 41
565 // 13: }
566 2, 0, // 17: case 0x2: {
567 OPC_CheckPredicate, 17, // 19: check predicate 17
568 OPC_Decode, 253, 122, 42, // 21: decode to QK_C_LHU using decoder 42
569 // 21: }
570 // 21: } // switch Inst[1:0]
571 // 21: }
572 4, 67, // 25: case 0x4: {
573 OPC_SwitchField, 5, 2, // 27: switch Inst[6:5] {
574 0, 14, // 30: case 0x0: {
575 OPC_CheckPredicate, 17, // 32: check predicate 17
576 OPC_CheckField, 11, 2, 0, // 34: check Inst[12:11] == 0x0
577 OPC_CheckField, 0, 2, 0, // 38: check Inst[1:0] == 0x0
578 OPC_Decode, 252, 122, 43, // 42: decode to QK_C_LBUSP using decoder 43
579 // 42: }
580 1, 14, // 46: case 0x1: {
581 OPC_CheckPredicate, 17, // 48: check predicate 17
582 OPC_CheckField, 11, 2, 0, // 50: check Inst[12:11] == 0x0
583 OPC_CheckField, 0, 2, 0, // 54: check Inst[1:0] == 0x0
584 OPC_Decode, 254, 122, 44, // 58: decode to QK_C_LHUSP using decoder 44
585 // 58: }
586 2, 14, // 62: case 0x2: {
587 OPC_CheckPredicate, 17, // 64: check predicate 17
588 OPC_CheckField, 11, 2, 0, // 66: check Inst[12:11] == 0x0
589 OPC_CheckField, 0, 2, 0, // 70: check Inst[1:0] == 0x0
590 OPC_Decode, 128, 123, 43, // 74: decode to QK_C_SBSP using decoder 43
591 // 74: }
592 3, 0, // 78: case 0x3: {
593 OPC_CheckPredicate, 17, // 80: check predicate 17
594 OPC_CheckField, 11, 2, 0, // 82: check Inst[12:11] == 0x0
595 OPC_CheckField, 0, 2, 0, // 86: check Inst[1:0] == 0x0
596 OPC_Decode, 130, 123, 44, // 90: decode to QK_C_SHSP using decoder 44
597 // 90: }
598 // 90: } // switch Inst[6:5]
599 // 90: }
600 5, 0, // 94: case 0x5: {
601 OPC_SwitchField, 0, 2, // 96: switch Inst[1:0] {
602 0, 6, // 99: case 0x0: {
603 OPC_CheckPredicate, 17, // 101: check predicate 17
604 OPC_Decode, 255, 122, 41, // 103: decode to QK_C_SB using decoder 41
605 // 103: }
606 2, 0, // 107: case 0x2: {
607 OPC_CheckPredicate, 17, // 109: check predicate 17
608 OPC_Decode, 129, 123, 42, // 111: decode to QK_C_SH using decoder 42
609 // 111: }
610 // 111: } // switch Inst[1:0]
611 // 111: }
612 // 111: } // switch Inst[15:13]
613};
614static const uint8_t DecoderTableZcOverlap16[162] = {
615 16, // 0: BitWidth 16
616 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
617 3, 19, // 4: case 0x3: {
618 OPC_SwitchField, 0, 2, // 6: switch Inst[1:0] {
619 0, 6, // 9: case 0x0: {
620 OPC_CheckPredicate, 18, // 11: check predicate 18
621 OPC_Decode, 180, 113, 45, // 13: decode to C_LD_RV32 using decoder 45
622 // 13: }
623 2, 0, // 17: case 0x2: {
624 OPC_CheckPredicate, 18, // 19: check predicate 18
625 OPC_Decode, 179, 113, 46, // 21: decode to C_LDSP_RV32 using decoder 46
626 // 21: }
627 // 21: } // switch Inst[1:0]
628 // 21: }
629 5, 114, // 25: case 0x5: {
630 OPC_SwitchField, 10, 3, // 27: switch Inst[12:10] {
631 0, 22, // 30: case 0x0: {
632 OPC_CheckField, 0, 2, 2, // 32: check Inst[1:0] == 0x2
633 OPC_Scope, 10, // 36: try {
634 OPC_CheckField, 7, 3, 0, // 38: check Inst[9:7] == 0x0
635 OPC_CheckPredicate, 19, // 42: check predicate 19
636 OPC_Decode, 206, 110, 34, // 44: decode to CM_JT using decoder 34
637 // 44: } else try {
638 OPC_CheckPredicate, 19, // 48: check predicate 19
639 OPC_Decode, 205, 110, 35, // 50: decode to CM_JALT using decoder 35
640 // 50: }
641 // 50: }
642 3, 27, // 54: case 0x3: {
643 OPC_SwitchField, 5, 2, // 56: switch Inst[6:5] {
644 1, 10, // 59: case 0x1: {
645 OPC_CheckPredicate, 20, // 61: check predicate 20
646 OPC_CheckField, 0, 2, 2, // 63: check Inst[1:0] == 0x2
647 OPC_Decode, 208, 110, 31, // 67: decode to CM_MVSA01 using decoder 31
648 // 67: }
649 3, 0, // 71: case 0x3: {
650 OPC_CheckPredicate, 20, // 73: check predicate 20
651 OPC_CheckField, 0, 2, 2, // 75: check Inst[1:0] == 0x2
652 OPC_Decode, 207, 110, 31, // 79: decode to CM_MVA01S using decoder 31
653 // 79: }
654 // 79: } // switch Inst[6:5]
655 // 79: }
656 6, 27, // 83: case 0x6: {
657 OPC_SwitchField, 8, 2, // 85: switch Inst[9:8] {
658 0, 10, // 88: case 0x0: {
659 OPC_CheckPredicate, 20, // 90: check predicate 20
660 OPC_CheckField, 0, 2, 2, // 92: check Inst[1:0] == 0x2
661 OPC_Decode, 212, 110, 32, // 96: decode to CM_PUSH using decoder 32
662 // 96: }
663 2, 0, // 100: case 0x2: {
664 OPC_CheckPredicate, 20, // 102: check predicate 20
665 OPC_CheckField, 0, 2, 2, // 104: check Inst[1:0] == 0x2
666 OPC_Decode, 209, 110, 32, // 108: decode to CM_POP using decoder 32
667 // 108: }
668 // 108: } // switch Inst[9:8]
669 // 108: }
670 7, 0, // 112: case 0x7: {
671 OPC_SwitchField, 8, 2, // 114: switch Inst[9:8] {
672 0, 10, // 117: case 0x0: {
673 OPC_CheckPredicate, 20, // 119: check predicate 20
674 OPC_CheckField, 0, 2, 2, // 121: check Inst[1:0] == 0x2
675 OPC_Decode, 211, 110, 32, // 125: decode to CM_POPRETZ using decoder 32
676 // 125: }
677 2, 0, // 129: case 0x2: {
678 OPC_CheckPredicate, 20, // 131: check predicate 20
679 OPC_CheckField, 0, 2, 2, // 133: check Inst[1:0] == 0x2
680 OPC_Decode, 210, 110, 32, // 137: decode to CM_POPRET using decoder 32
681 // 137: }
682 // 137: } // switch Inst[9:8]
683 // 137: }
684 // 137: } // switch Inst[12:10]
685 // 137: }
686 7, 0, // 141: case 0x7: {
687 OPC_SwitchField, 0, 2, // 143: switch Inst[1:0] {
688 0, 6, // 146: case 0x0: {
689 OPC_CheckPredicate, 18, // 148: check predicate 18
690 OPC_Decode, 206, 113, 45, // 150: decode to C_SD_RV32 using decoder 45
691 // 150: }
692 2, 0, // 154: case 0x2: {
693 OPC_CheckPredicate, 18, // 156: check predicate 18
694 OPC_Decode, 205, 113, 47, // 158: decode to C_SDSP_RV32 using decoder 47
695 // 158: }
696 // 158: } // switch Inst[1:0]
697 // 158: }
698 // 158: } // switch Inst[15:13]
699};
700static const uint8_t DecoderTableZicfiss16[24] = {
701 16, // 0: BitWidth 16
702 OPC_SwitchField, 0, 16, // 1: switch Inst[15:0] {
703 129, 193, 1, 6, // 4: case 0x6081: {
704 OPC_CheckPredicate, 3, // 8: check predicate 3
705 OPC_Decode, 215, 113, 48, // 10: decode to C_SSPUSH using decoder 48
706 // 10: }
707 129, 197, 1, 0, // 14: case 0x6281: {
708 OPC_CheckPredicate, 3, // 18: check predicate 3
709 OPC_Decode, 214, 113, 49, // 20: decode to C_SSPOPCHK using decoder 49
710 // 20: }
711 // 20: } // switch Inst[15:0]
712};
713// Handling 50 cases.
714template <typename InsnType>
715static std::enable_if_t<InsnBitWidth<InsnType> == 16, DecodeStatus>
716decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
717 DecodeComplete = true;
718 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
719 TmpType tmp;
720 switch (Idx) {
721 default: llvm_unreachable("Invalid decoder index!");
722 case 0:
723 return S;
724 case 1:
725 tmp = fieldFromInstruction(insn, 2, 3);
726 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
727 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
728 return MCDisassembler::Fail;
729 tmp = 0x0;
730 tmp |= fieldFromInstruction(insn, 5, 1) << 3;
731 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
732 tmp |= fieldFromInstruction(insn, 7, 4) << 6;
733 tmp |= fieldFromInstruction(insn, 11, 2) << 4;
734 if (!Check(S, decodeUImmNonZeroOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
735 return S;
736 case 2:
737 tmp = 0x0;
738 tmp |= fieldFromInstruction(insn, 2, 5);
739 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
740 if (!Check(S, decodeSImmNonZeroOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
741 return S;
742 case 3:
743 tmp = fieldFromInstruction(insn, 7, 5);
744 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
745 tmp = fieldFromInstruction(insn, 7, 5);
746 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
747 tmp = 0x0;
748 tmp |= fieldFromInstruction(insn, 2, 5);
749 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
750 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
751 return S;
752 case 4:
753 tmp = fieldFromInstruction(insn, 7, 5);
754 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
755 tmp = fieldFromInstruction(insn, 7, 5);
756 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
757 tmp = 0x0;
758 tmp |= fieldFromInstruction(insn, 2, 5);
759 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
760 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
761 return S;
762 case 5:
763 tmp = fieldFromInstruction(insn, 2, 3);
764 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F8_D, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
765 tmp = fieldFromInstruction(insn, 7, 3);
766 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
767 tmp = 0x0;
768 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
769 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
770 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
771 return S;
772 case 6:
773 tmp = fieldFromInstruction(insn, 7, 5);
774 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
775 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
776 return MCDisassembler::Fail;
777 tmp = 0x0;
778 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
779 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
780 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
781 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
782 return S;
783 case 7:
784 tmp = fieldFromInstruction(insn, 2, 3);
785 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
786 tmp = fieldFromInstruction(insn, 7, 3);
787 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
788 tmp = 0x0;
789 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
790 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
791 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
792 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
793 return S;
794 case 8:
795 tmp = fieldFromInstruction(insn, 7, 5);
796 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
797 tmp = 0x0;
798 tmp |= fieldFromInstruction(insn, 2, 5);
799 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
800 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
801 return S;
802 case 9:
803 tmp = fieldFromInstruction(insn, 7, 5);
804 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
805 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
806 return MCDisassembler::Fail;
807 tmp = 0x0;
808 tmp |= fieldFromInstruction(insn, 2, 2) << 6;
809 tmp |= fieldFromInstruction(insn, 4, 3) << 2;
810 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
811 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
812 return S;
813 case 10:
814 tmp = fieldFromInstruction(insn, 2, 3);
815 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
816 tmp = fieldFromInstruction(insn, 7, 3);
817 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
818 tmp = 0x0;
819 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
820 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
821 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
822 return S;
823 case 11:
824 tmp = 0x2;
825 if (!Check(S, DecodeSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
826 tmp = 0x2;
827 if (!Check(S, DecodeSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
828 tmp = 0x0;
829 tmp |= fieldFromInstruction(insn, 2, 1) << 5;
830 tmp |= fieldFromInstruction(insn, 3, 2) << 7;
831 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
832 tmp |= fieldFromInstruction(insn, 6, 1) << 4;
833 tmp |= fieldFromInstruction(insn, 12, 1) << 9;
834 if (!Check(S, decodeSImmNonZeroOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
835 return S;
836 case 12:
837 tmp = fieldFromInstruction(insn, 7, 5);
838 if (!Check(S, DecodeGPRNoX2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
839 tmp = 0x0;
840 tmp |= fieldFromInstruction(insn, 2, 5);
841 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
842 if (!Check(S, decodeCLUIImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
843 return S;
844 case 13:
845 tmp = fieldFromInstruction(insn, 7, 5);
846 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
847 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
848 return MCDisassembler::Fail;
849 tmp = 0x0;
850 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
851 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
852 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
853 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
854 return S;
855 case 14:
856 tmp = fieldFromInstruction(insn, 2, 3);
857 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
858 tmp = fieldFromInstruction(insn, 7, 3);
859 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
860 tmp = 0x0;
861 tmp |= fieldFromInstruction(insn, 5, 1) << 1;
862 tmp |= fieldFromInstruction(insn, 6, 1);
863 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
864 return S;
865 case 15:
866 tmp = fieldFromInstruction(insn, 2, 3);
867 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
868 tmp = fieldFromInstruction(insn, 7, 3);
869 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
870 tmp = fieldFromInstruction(insn, 5, 1) << 1;
871 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
872 return S;
873 case 16:
874 tmp = fieldFromInstruction(insn, 7, 3);
875 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
876 tmp = fieldFromInstruction(insn, 7, 3);
877 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
878 tmp = 0x0;
879 tmp |= fieldFromInstruction(insn, 2, 5);
880 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
881 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
882 return S;
883 case 17:
884 tmp = fieldFromInstruction(insn, 7, 3);
885 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
886 tmp = fieldFromInstruction(insn, 7, 3);
887 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
888 tmp = 0x0;
889 tmp |= fieldFromInstruction(insn, 2, 5);
890 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
891 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
892 return S;
893 case 18:
894 tmp = fieldFromInstruction(insn, 7, 3);
895 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
896 tmp = fieldFromInstruction(insn, 7, 3);
897 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
898 tmp = fieldFromInstruction(insn, 2, 3);
899 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
900 return S;
901 case 19:
902 tmp = fieldFromInstruction(insn, 7, 3);
903 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
904 tmp = fieldFromInstruction(insn, 7, 3);
905 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
906 return S;
907 case 20:
908 tmp = fieldFromInstruction(insn, 7, 5);
909 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
910 return S;
911 case 21:
912 tmp = fieldFromInstruction(insn, 7, 5);
913 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
914 tmp = fieldFromInstruction(insn, 2, 5);
915 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
916 return S;
917 case 22:
918 tmp = fieldFromInstruction(insn, 7, 5);
919 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
920 tmp = fieldFromInstruction(insn, 7, 5);
921 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
922 tmp = fieldFromInstruction(insn, 2, 5);
923 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
924 return S;
925 case 23:
926 tmp = 0x0;
927 tmp |= fieldFromInstruction(insn, 2, 1) << 4;
928 tmp |= fieldFromInstruction(insn, 3, 3);
929 tmp |= fieldFromInstruction(insn, 6, 1) << 6;
930 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
931 tmp |= fieldFromInstruction(insn, 8, 1) << 9;
932 tmp |= fieldFromInstruction(insn, 9, 2) << 7;
933 tmp |= fieldFromInstruction(insn, 11, 1) << 3;
934 tmp |= fieldFromInstruction(insn, 12, 1) << 10;
935 if (!Check(S, decodeSImmOperandAndLslN<12, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
936 return S;
937 case 24:
938 tmp = fieldFromInstruction(insn, 2, 5);
939 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
940 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
941 return MCDisassembler::Fail;
942 tmp = 0x0;
943 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
944 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
945 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
946 return S;
947 case 25:
948 tmp = fieldFromInstruction(insn, 7, 3);
949 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
950 tmp = 0x0;
951 tmp |= fieldFromInstruction(insn, 2, 1) << 4;
952 tmp |= fieldFromInstruction(insn, 3, 2);
953 tmp |= fieldFromInstruction(insn, 5, 2) << 5;
954 tmp |= fieldFromInstruction(insn, 10, 2) << 2;
955 tmp |= fieldFromInstruction(insn, 12, 1) << 7;
956 if (!Check(S, decodeSImmOperandAndLslN<9, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
957 return S;
958 case 26:
959 tmp = fieldFromInstruction(insn, 2, 5);
960 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
961 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
962 return MCDisassembler::Fail;
963 tmp = 0x0;
964 tmp |= fieldFromInstruction(insn, 7, 2) << 6;
965 tmp |= fieldFromInstruction(insn, 9, 4) << 2;
966 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
967 return S;
968 case 27:
969 tmp = fieldFromInstruction(insn, 2, 5);
970 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
971 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
972 return MCDisassembler::Fail;
973 tmp = 0x0;
974 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
975 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
976 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
977 return S;
978 case 28:
979 tmp = fieldFromInstruction(insn, 2, 3);
980 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F8_F, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
981 tmp = fieldFromInstruction(insn, 7, 3);
982 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
983 tmp = 0x0;
984 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
985 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
986 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
987 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
988 return S;
989 case 29:
990 tmp = fieldFromInstruction(insn, 7, 5);
991 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
992 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
993 return MCDisassembler::Fail;
994 tmp = 0x0;
995 tmp |= fieldFromInstruction(insn, 2, 2) << 6;
996 tmp |= fieldFromInstruction(insn, 4, 3) << 2;
997 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
998 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
999 return S;
1000 case 30:
1001 tmp = fieldFromInstruction(insn, 2, 5);
1002 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1003 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
1004 return MCDisassembler::Fail;
1005 tmp = 0x0;
1006 tmp |= fieldFromInstruction(insn, 7, 2) << 6;
1007 tmp |= fieldFromInstruction(insn, 9, 4) << 2;
1008 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1009 return S;
1010 case 31:
1011 tmp = fieldFromInstruction(insn, 7, 3);
1012 if (!Check(S, DecodeSR07RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1013 tmp = fieldFromInstruction(insn, 2, 3);
1014 if (!Check(S, DecodeSR07RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1015 return S;
1016 case 32:
1017 tmp = fieldFromInstruction(insn, 4, 4);
1018 if (!Check(S, decodeZcmpRlist(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1019 tmp = fieldFromInstruction(insn, 2, 2) << 4;
1020 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
1021 return S;
1022 case 33:
1023 tmp = fieldFromInstruction(insn, 4, 4);
1024 if (!Check(S, decodeXqccmpRlistS0(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1025 tmp = fieldFromInstruction(insn, 2, 2) << 4;
1026 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
1027 return S;
1028 case 34:
1029 tmp = fieldFromInstruction(insn, 2, 5);
1030 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1031 return S;
1032 case 35:
1033 tmp = fieldFromInstruction(insn, 2, 8);
1034 if (!Check(S, decodeUImmOperandGE<8, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1035 return S;
1036 case 36:
1037 tmp = fieldFromInstruction(insn, 7, 5);
1038 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1039 tmp = fieldFromInstruction(insn, 7, 5);
1040 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1041 tmp = fieldFromInstruction(insn, 2, 5);
1042 if (!Check(S, decodeUImmPlus1OperandGE<5,6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1043 return S;
1044 case 37:
1045 tmp = fieldFromInstruction(insn, 2, 3);
1046 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1047 tmp = fieldFromInstruction(insn, 2, 3);
1048 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1049 tmp = fieldFromInstruction(insn, 7, 3);
1050 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1051 tmp = 0x0;
1052 tmp |= fieldFromInstruction(insn, 5, 1) << 4;
1053 tmp |= fieldFromInstruction(insn, 6, 1);
1054 tmp |= fieldFromInstruction(insn, 10, 3) << 1;
1055 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1056 return S;
1057 case 38:
1058 tmp = fieldFromInstruction(insn, 7, 3);
1059 if (!Check(S, decodeUImmSlistOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1060 return S;
1061 case 39:
1062 tmp = fieldFromInstruction(insn, 7, 3);
1063 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1064 tmp = fieldFromInstruction(insn, 7, 3);
1065 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1066 tmp = fieldFromInstruction(insn, 2, 5);
1067 if (!Check(S, decodeUImmLog2XLenNonZeroOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1068 return S;
1069 case 40:
1070 tmp = fieldFromInstruction(insn, 2, 3);
1071 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1072 tmp = fieldFromInstruction(insn, 2, 3);
1073 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1074 tmp = fieldFromInstruction(insn, 7, 3);
1075 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1076 return S;
1077 case 41:
1078 tmp = fieldFromInstruction(insn, 2, 3);
1079 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1080 tmp = fieldFromInstruction(insn, 7, 3);
1081 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1082 tmp = 0x0;
1083 tmp |= fieldFromInstruction(insn, 5, 2) << 1;
1084 tmp |= fieldFromInstruction(insn, 10, 2) << 3;
1085 tmp |= fieldFromInstruction(insn, 12, 1);
1086 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1087 return S;
1088 case 42:
1089 tmp = fieldFromInstruction(insn, 2, 3);
1090 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1091 tmp = fieldFromInstruction(insn, 7, 3);
1092 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1093 tmp = 0x0;
1094 tmp |= fieldFromInstruction(insn, 5, 2) << 1;
1095 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1096 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1097 return S;
1098 case 43:
1099 tmp = fieldFromInstruction(insn, 2, 3);
1100 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1101 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
1102 return MCDisassembler::Fail;
1103 tmp = fieldFromInstruction(insn, 7, 4);
1104 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1105 return S;
1106 case 44:
1107 tmp = fieldFromInstruction(insn, 2, 3);
1108 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1109 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
1110 return MCDisassembler::Fail;
1111 tmp = 0x0;
1112 tmp |= fieldFromInstruction(insn, 7, 1) << 4;
1113 tmp |= fieldFromInstruction(insn, 8, 3) << 1;
1114 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1115 return S;
1116 case 45:
1117 tmp = fieldFromInstruction(insn, 2, 3);
1118 if (!Check(S, DecodeGPRPairCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1119 tmp = fieldFromInstruction(insn, 7, 3);
1120 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1121 tmp = 0x0;
1122 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
1123 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1124 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1125 return S;
1126 case 46:
1127 tmp = fieldFromInstruction(insn, 7, 5);
1128 if (!Check(S, DecodeGPRPairNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1129 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
1130 return MCDisassembler::Fail;
1131 tmp = 0x0;
1132 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
1133 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
1134 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
1135 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1136 return S;
1137 case 47:
1138 tmp = fieldFromInstruction(insn, 2, 5);
1139 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1140 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
1141 return MCDisassembler::Fail;
1142 tmp = 0x0;
1143 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
1144 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1145 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1146 return S;
1147 case 48:
1148 if (!Check(Out&: S, In: DecodeGPRX1RegisterClass(Inst&: MI, Decoder)))
1149 return MCDisassembler::Fail;
1150 return S;
1151 case 49:
1152 if (!Check(Out&: S, In: DecodeGPRX5RegisterClass(Inst&: MI, Decoder)))
1153 return MCDisassembler::Fail;
1154 return S;
1155 }
1156}
1157static const uint8_t DecoderTable32[20488] = {
1158 32, // 0: BitWidth 32
1159 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
1160 3, 49, // 4: case 0x3: {
1161 OPC_SwitchField, 12, 3, // 6: switch Inst[14:12] {
1162 0, 4, // 9: case 0x0: {
1163 OPC_Decode, 173, 116, 0, // 11: decode to LB using decoder 0
1164 // 11: }
1165 1, 4, // 15: case 0x1: {
1166 OPC_Decode, 181, 116, 0, // 17: decode to LH using decoder 0
1167 // 17: }
1168 2, 4, // 21: case 0x2: {
1169 OPC_Decode, 195, 116, 0, // 23: decode to LW using decoder 0
1170 // 23: }
1171 3, 6, // 27: case 0x3: {
1172 OPC_CheckPredicate, 21, // 29: check predicate 21
1173 OPC_Decode, 177, 116, 0, // 31: decode to LD using decoder 0
1174 // 31: }
1175 4, 4, // 35: case 0x4: {
1176 OPC_Decode, 174, 116, 0, // 37: decode to LBU using decoder 0
1177 // 37: }
1178 5, 4, // 41: case 0x5: {
1179 OPC_Decode, 182, 116, 0, // 43: decode to LHU using decoder 0
1180 // 43: }
1181 6, 0, // 47: case 0x6: {
1182 OPC_CheckPredicate, 21, // 49: check predicate 21
1183 OPC_Decode, 196, 116, 0, // 51: decode to LWU using decoder 0
1184 // 51: }
1185 // 51: } // switch Inst[14:12]
1186 // 51: }
1187 7, 250, 13, // 55: case 0x7: {
1188 OPC_SwitchField, 12, 3, // 58: switch Inst[14:12] {
1189 0, 179, 3, // 61: case 0x0: {
1190 OPC_SwitchField, 26, 6, // 64: switch Inst[31:26] {
1191 0, 43, // 67: case 0x0: {
1192 OPC_SwitchField, 20, 5, // 69: switch Inst[24:20] {
1193 0, 6, // 72: case 0x0: {
1194 OPC_CheckPredicate, 22, // 74: check predicate 22
1195 OPC_Decode, 147, 127, 1, // 76: decode to VLE8_V using decoder 1
1196 // 76: }
1197 8, 10, // 80: case 0x8: {
1198 OPC_CheckPredicate, 22, // 82: check predicate 22
1199 OPC_CheckField, 25, 1, 1, // 84: check Inst[25] == 0x1
1200 OPC_Decode, 255, 126, 2, // 88: decode to VL1RE8_V using decoder 2
1201 // 88: }
1202 11, 10, // 92: case 0xb: {
1203 OPC_CheckPredicate, 22, // 94: check predicate 22
1204 OPC_CheckField, 25, 1, 1, // 96: check Inst[25] == 0x1
1205 OPC_Decode, 148, 127, 2, // 100: decode to VLM_V using decoder 2
1206 // 100: }
1207 16, 0, // 104: case 0x10: {
1208 OPC_CheckPredicate, 22, // 106: check predicate 22
1209 OPC_Decode, 146, 127, 1, // 108: decode to VLE8FF_V using decoder 1
1210 // 108: }
1211 // 108: } // switch Inst[24:20]
1212 // 108: }
1213 1, 7, // 112: case 0x1: {
1214 OPC_CheckPredicate, 22, // 114: check predicate 22
1215 OPC_Decode, 144, 128, 1, 3, // 116: decode to VLUXEI8_V using decoder 3
1216 // 116: }
1217 2, 6, // 121: case 0x2: {
1218 OPC_CheckPredicate, 22, // 123: check predicate 22
1219 OPC_Decode, 184, 127, 4, // 125: decode to VLSE8_V using decoder 4
1220 // 125: }
1221 3, 6, // 129: case 0x3: {
1222 OPC_CheckPredicate, 22, // 131: check predicate 22
1223 OPC_Decode, 152, 127, 3, // 133: decode to VLOXEI8_V using decoder 3
1224 // 133: }
1225 8, 31, // 137: case 0x8: {
1226 OPC_SwitchField, 20, 5, // 139: switch Inst[24:20] {
1227 0, 6, // 142: case 0x0: {
1228 OPC_CheckPredicate, 22, // 144: check predicate 22
1229 OPC_Decode, 192, 127, 1, // 146: decode to VLSEG2E8_V using decoder 1
1230 // 146: }
1231 8, 10, // 150: case 0x8: {
1232 OPC_CheckPredicate, 22, // 152: check predicate 22
1233 OPC_CheckField, 25, 1, 1, // 154: check Inst[25] == 0x1
1234 OPC_Decode, 131, 127, 5, // 158: decode to VL2RE8_V using decoder 5
1235 // 158: }
1236 16, 0, // 162: case 0x10: {
1237 OPC_CheckPredicate, 22, // 164: check predicate 22
1238 OPC_Decode, 191, 127, 1, // 166: decode to VLSEG2E8FF_V using decoder 1
1239 // 166: }
1240 // 166: } // switch Inst[24:20]
1241 // 166: }
1242 9, 7, // 170: case 0x9: {
1243 OPC_CheckPredicate, 22, // 172: check predicate 22
1244 OPC_Decode, 148, 128, 1, 3, // 174: decode to VLUXSEG2EI8_V using decoder 3
1245 // 174: }
1246 10, 6, // 179: case 0xa: {
1247 OPC_CheckPredicate, 22, // 181: check predicate 22
1248 OPC_Decode, 244, 127, 4, // 183: decode to VLSSEG2E8_V using decoder 4
1249 // 183: }
1250 11, 6, // 187: case 0xb: {
1251 OPC_CheckPredicate, 22, // 189: check predicate 22
1252 OPC_Decode, 156, 127, 3, // 191: decode to VLOXSEG2EI8_V using decoder 3
1253 // 191: }
1254 16, 19, // 195: case 0x10: {
1255 OPC_SwitchField, 20, 5, // 197: switch Inst[24:20] {
1256 0, 6, // 200: case 0x0: {
1257 OPC_CheckPredicate, 22, // 202: check predicate 22
1258 OPC_Decode, 200, 127, 1, // 204: decode to VLSEG3E8_V using decoder 1
1259 // 204: }
1260 16, 0, // 208: case 0x10: {
1261 OPC_CheckPredicate, 22, // 210: check predicate 22
1262 OPC_Decode, 199, 127, 1, // 212: decode to VLSEG3E8FF_V using decoder 1
1263 // 212: }
1264 // 212: } // switch Inst[24:20]
1265 // 212: }
1266 17, 7, // 216: case 0x11: {
1267 OPC_CheckPredicate, 22, // 218: check predicate 22
1268 OPC_Decode, 152, 128, 1, 3, // 220: decode to VLUXSEG3EI8_V using decoder 3
1269 // 220: }
1270 18, 6, // 225: case 0x12: {
1271 OPC_CheckPredicate, 22, // 227: check predicate 22
1272 OPC_Decode, 248, 127, 4, // 229: decode to VLSSEG3E8_V using decoder 4
1273 // 229: }
1274 19, 6, // 233: case 0x13: {
1275 OPC_CheckPredicate, 22, // 235: check predicate 22
1276 OPC_Decode, 160, 127, 3, // 237: decode to VLOXSEG3EI8_V using decoder 3
1277 // 237: }
1278 24, 31, // 241: case 0x18: {
1279 OPC_SwitchField, 20, 5, // 243: switch Inst[24:20] {
1280 0, 6, // 246: case 0x0: {
1281 OPC_CheckPredicate, 22, // 248: check predicate 22
1282 OPC_Decode, 208, 127, 1, // 250: decode to VLSEG4E8_V using decoder 1
1283 // 250: }
1284 8, 10, // 254: case 0x8: {
1285 OPC_CheckPredicate, 22, // 256: check predicate 22
1286 OPC_CheckField, 25, 1, 1, // 258: check Inst[25] == 0x1
1287 OPC_Decode, 135, 127, 6, // 262: decode to VL4RE8_V using decoder 6
1288 // 262: }
1289 16, 0, // 266: case 0x10: {
1290 OPC_CheckPredicate, 22, // 268: check predicate 22
1291 OPC_Decode, 207, 127, 1, // 270: decode to VLSEG4E8FF_V using decoder 1
1292 // 270: }
1293 // 270: } // switch Inst[24:20]
1294 // 270: }
1295 25, 7, // 274: case 0x19: {
1296 OPC_CheckPredicate, 22, // 276: check predicate 22
1297 OPC_Decode, 156, 128, 1, 3, // 278: decode to VLUXSEG4EI8_V using decoder 3
1298 // 278: }
1299 26, 6, // 283: case 0x1a: {
1300 OPC_CheckPredicate, 22, // 285: check predicate 22
1301 OPC_Decode, 252, 127, 4, // 287: decode to VLSSEG4E8_V using decoder 4
1302 // 287: }
1303 27, 6, // 291: case 0x1b: {
1304 OPC_CheckPredicate, 22, // 293: check predicate 22
1305 OPC_Decode, 164, 127, 3, // 295: decode to VLOXSEG4EI8_V using decoder 3
1306 // 295: }
1307 32, 19, // 299: case 0x20: {
1308 OPC_SwitchField, 20, 5, // 301: switch Inst[24:20] {
1309 0, 6, // 304: case 0x0: {
1310 OPC_CheckPredicate, 22, // 306: check predicate 22
1311 OPC_Decode, 216, 127, 1, // 308: decode to VLSEG5E8_V using decoder 1
1312 // 308: }
1313 16, 0, // 312: case 0x10: {
1314 OPC_CheckPredicate, 22, // 314: check predicate 22
1315 OPC_Decode, 215, 127, 1, // 316: decode to VLSEG5E8FF_V using decoder 1
1316 // 316: }
1317 // 316: } // switch Inst[24:20]
1318 // 316: }
1319 33, 7, // 320: case 0x21: {
1320 OPC_CheckPredicate, 22, // 322: check predicate 22
1321 OPC_Decode, 160, 128, 1, 3, // 324: decode to VLUXSEG5EI8_V using decoder 3
1322 // 324: }
1323 34, 7, // 329: case 0x22: {
1324 OPC_CheckPredicate, 22, // 331: check predicate 22
1325 OPC_Decode, 128, 128, 1, 4, // 333: decode to VLSSEG5E8_V using decoder 4
1326 // 333: }
1327 35, 6, // 338: case 0x23: {
1328 OPC_CheckPredicate, 22, // 340: check predicate 22
1329 OPC_Decode, 168, 127, 3, // 342: decode to VLOXSEG5EI8_V using decoder 3
1330 // 342: }
1331 40, 19, // 346: case 0x28: {
1332 OPC_SwitchField, 20, 5, // 348: switch Inst[24:20] {
1333 0, 6, // 351: case 0x0: {
1334 OPC_CheckPredicate, 22, // 353: check predicate 22
1335 OPC_Decode, 224, 127, 1, // 355: decode to VLSEG6E8_V using decoder 1
1336 // 355: }
1337 16, 0, // 359: case 0x10: {
1338 OPC_CheckPredicate, 22, // 361: check predicate 22
1339 OPC_Decode, 223, 127, 1, // 363: decode to VLSEG6E8FF_V using decoder 1
1340 // 363: }
1341 // 363: } // switch Inst[24:20]
1342 // 363: }
1343 41, 7, // 367: case 0x29: {
1344 OPC_CheckPredicate, 22, // 369: check predicate 22
1345 OPC_Decode, 164, 128, 1, 3, // 371: decode to VLUXSEG6EI8_V using decoder 3
1346 // 371: }
1347 42, 7, // 376: case 0x2a: {
1348 OPC_CheckPredicate, 22, // 378: check predicate 22
1349 OPC_Decode, 132, 128, 1, 4, // 380: decode to VLSSEG6E8_V using decoder 4
1350 // 380: }
1351 43, 6, // 385: case 0x2b: {
1352 OPC_CheckPredicate, 22, // 387: check predicate 22
1353 OPC_Decode, 172, 127, 3, // 389: decode to VLOXSEG6EI8_V using decoder 3
1354 // 389: }
1355 48, 19, // 393: case 0x30: {
1356 OPC_SwitchField, 20, 5, // 395: switch Inst[24:20] {
1357 0, 6, // 398: case 0x0: {
1358 OPC_CheckPredicate, 22, // 400: check predicate 22
1359 OPC_Decode, 232, 127, 1, // 402: decode to VLSEG7E8_V using decoder 1
1360 // 402: }
1361 16, 0, // 406: case 0x10: {
1362 OPC_CheckPredicate, 22, // 408: check predicate 22
1363 OPC_Decode, 231, 127, 1, // 410: decode to VLSEG7E8FF_V using decoder 1
1364 // 410: }
1365 // 410: } // switch Inst[24:20]
1366 // 410: }
1367 49, 7, // 414: case 0x31: {
1368 OPC_CheckPredicate, 22, // 416: check predicate 22
1369 OPC_Decode, 168, 128, 1, 3, // 418: decode to VLUXSEG7EI8_V using decoder 3
1370 // 418: }
1371 50, 7, // 423: case 0x32: {
1372 OPC_CheckPredicate, 22, // 425: check predicate 22
1373 OPC_Decode, 136, 128, 1, 4, // 427: decode to VLSSEG7E8_V using decoder 4
1374 // 427: }
1375 51, 6, // 432: case 0x33: {
1376 OPC_CheckPredicate, 22, // 434: check predicate 22
1377 OPC_Decode, 176, 127, 3, // 436: decode to VLOXSEG7EI8_V using decoder 3
1378 // 436: }
1379 56, 31, // 440: case 0x38: {
1380 OPC_SwitchField, 20, 5, // 442: switch Inst[24:20] {
1381 0, 6, // 445: case 0x0: {
1382 OPC_CheckPredicate, 22, // 447: check predicate 22
1383 OPC_Decode, 240, 127, 1, // 449: decode to VLSEG8E8_V using decoder 1
1384 // 449: }
1385 8, 10, // 453: case 0x8: {
1386 OPC_CheckPredicate, 22, // 455: check predicate 22
1387 OPC_CheckField, 25, 1, 1, // 457: check Inst[25] == 0x1
1388 OPC_Decode, 139, 127, 7, // 461: decode to VL8RE8_V using decoder 7
1389 // 461: }
1390 16, 0, // 465: case 0x10: {
1391 OPC_CheckPredicate, 22, // 467: check predicate 22
1392 OPC_Decode, 239, 127, 1, // 469: decode to VLSEG8E8FF_V using decoder 1
1393 // 469: }
1394 // 469: } // switch Inst[24:20]
1395 // 469: }
1396 57, 7, // 473: case 0x39: {
1397 OPC_CheckPredicate, 22, // 475: check predicate 22
1398 OPC_Decode, 172, 128, 1, 3, // 477: decode to VLUXSEG8EI8_V using decoder 3
1399 // 477: }
1400 58, 7, // 482: case 0x3a: {
1401 OPC_CheckPredicate, 22, // 484: check predicate 22
1402 OPC_Decode, 140, 128, 1, 4, // 486: decode to VLSSEG8E8_V using decoder 4
1403 // 486: }
1404 59, 0, // 491: case 0x3b: {
1405 OPC_CheckPredicate, 22, // 493: check predicate 22
1406 OPC_Decode, 180, 127, 3, // 495: decode to VLOXSEG8EI8_V using decoder 3
1407 // 495: }
1408 // 495: } // switch Inst[31:26]
1409 // 495: }
1410 1, 6, // 499: case 0x1: {
1411 OPC_CheckPredicate, 23, // 501: check predicate 23
1412 OPC_Decode, 237, 114, 8, // 503: decode to FLH using decoder 8
1413 // 503: }
1414 2, 6, // 507: case 0x2: {
1415 OPC_CheckPredicate, 24, // 509: check predicate 24
1416 OPC_Decode, 255, 114, 9, // 511: decode to FLW using decoder 9
1417 // 511: }
1418 3, 6, // 515: case 0x3: {
1419 OPC_CheckPredicate, 25, // 517: check predicate 25
1420 OPC_Decode, 224, 114, 10, // 519: decode to FLD using decoder 10
1421 // 519: }
1422 4, 6, // 523: case 0x4: {
1423 OPC_CheckPredicate, 26, // 525: check predicate 26
1424 OPC_Decode, 242, 114, 11, // 527: decode to FLQ using decoder 11
1425 // 527: }
1426 5, 166, 3, // 531: case 0x5: {
1427 OPC_SwitchField, 26, 6, // 534: switch Inst[31:26] {
1428 0, 31, // 537: case 0x0: {
1429 OPC_SwitchField, 20, 5, // 539: switch Inst[24:20] {
1430 0, 6, // 542: case 0x0: {
1431 OPC_CheckPredicate, 22, // 544: check predicate 22
1432 OPC_Decode, 141, 127, 1, // 546: decode to VLE16_V using decoder 1
1433 // 546: }
1434 8, 10, // 550: case 0x8: {
1435 OPC_CheckPredicate, 22, // 552: check predicate 22
1436 OPC_CheckField, 25, 1, 1, // 554: check Inst[25] == 0x1
1437 OPC_Decode, 252, 126, 2, // 558: decode to VL1RE16_V using decoder 2
1438 // 558: }
1439 16, 0, // 562: case 0x10: {
1440 OPC_CheckPredicate, 22, // 564: check predicate 22
1441 OPC_Decode, 140, 127, 1, // 566: decode to VLE16FF_V using decoder 1
1442 // 566: }
1443 // 566: } // switch Inst[24:20]
1444 // 566: }
1445 1, 7, // 570: case 0x1: {
1446 OPC_CheckPredicate, 22, // 572: check predicate 22
1447 OPC_Decode, 141, 128, 1, 3, // 574: decode to VLUXEI16_V using decoder 3
1448 // 574: }
1449 2, 6, // 579: case 0x2: {
1450 OPC_CheckPredicate, 22, // 581: check predicate 22
1451 OPC_Decode, 181, 127, 4, // 583: decode to VLSE16_V using decoder 4
1452 // 583: }
1453 3, 6, // 587: case 0x3: {
1454 OPC_CheckPredicate, 22, // 589: check predicate 22
1455 OPC_Decode, 149, 127, 3, // 591: decode to VLOXEI16_V using decoder 3
1456 // 591: }
1457 8, 31, // 595: case 0x8: {
1458 OPC_SwitchField, 20, 5, // 597: switch Inst[24:20] {
1459 0, 6, // 600: case 0x0: {
1460 OPC_CheckPredicate, 22, // 602: check predicate 22
1461 OPC_Decode, 186, 127, 1, // 604: decode to VLSEG2E16_V using decoder 1
1462 // 604: }
1463 8, 10, // 608: case 0x8: {
1464 OPC_CheckPredicate, 22, // 610: check predicate 22
1465 OPC_CheckField, 25, 1, 1, // 612: check Inst[25] == 0x1
1466 OPC_Decode, 128, 127, 5, // 616: decode to VL2RE16_V using decoder 5
1467 // 616: }
1468 16, 0, // 620: case 0x10: {
1469 OPC_CheckPredicate, 22, // 622: check predicate 22
1470 OPC_Decode, 185, 127, 1, // 624: decode to VLSEG2E16FF_V using decoder 1
1471 // 624: }
1472 // 624: } // switch Inst[24:20]
1473 // 624: }
1474 9, 7, // 628: case 0x9: {
1475 OPC_CheckPredicate, 22, // 630: check predicate 22
1476 OPC_Decode, 145, 128, 1, 3, // 632: decode to VLUXSEG2EI16_V using decoder 3
1477 // 632: }
1478 10, 6, // 637: case 0xa: {
1479 OPC_CheckPredicate, 22, // 639: check predicate 22
1480 OPC_Decode, 241, 127, 4, // 641: decode to VLSSEG2E16_V using decoder 4
1481 // 641: }
1482 11, 6, // 645: case 0xb: {
1483 OPC_CheckPredicate, 22, // 647: check predicate 22
1484 OPC_Decode, 153, 127, 3, // 649: decode to VLOXSEG2EI16_V using decoder 3
1485 // 649: }
1486 16, 19, // 653: case 0x10: {
1487 OPC_SwitchField, 20, 5, // 655: switch Inst[24:20] {
1488 0, 6, // 658: case 0x0: {
1489 OPC_CheckPredicate, 22, // 660: check predicate 22
1490 OPC_Decode, 194, 127, 1, // 662: decode to VLSEG3E16_V using decoder 1
1491 // 662: }
1492 16, 0, // 666: case 0x10: {
1493 OPC_CheckPredicate, 22, // 668: check predicate 22
1494 OPC_Decode, 193, 127, 1, // 670: decode to VLSEG3E16FF_V using decoder 1
1495 // 670: }
1496 // 670: } // switch Inst[24:20]
1497 // 670: }
1498 17, 7, // 674: case 0x11: {
1499 OPC_CheckPredicate, 22, // 676: check predicate 22
1500 OPC_Decode, 149, 128, 1, 3, // 678: decode to VLUXSEG3EI16_V using decoder 3
1501 // 678: }
1502 18, 6, // 683: case 0x12: {
1503 OPC_CheckPredicate, 22, // 685: check predicate 22
1504 OPC_Decode, 245, 127, 4, // 687: decode to VLSSEG3E16_V using decoder 4
1505 // 687: }
1506 19, 6, // 691: case 0x13: {
1507 OPC_CheckPredicate, 22, // 693: check predicate 22
1508 OPC_Decode, 157, 127, 3, // 695: decode to VLOXSEG3EI16_V using decoder 3
1509 // 695: }
1510 24, 31, // 699: case 0x18: {
1511 OPC_SwitchField, 20, 5, // 701: switch Inst[24:20] {
1512 0, 6, // 704: case 0x0: {
1513 OPC_CheckPredicate, 22, // 706: check predicate 22
1514 OPC_Decode, 202, 127, 1, // 708: decode to VLSEG4E16_V using decoder 1
1515 // 708: }
1516 8, 10, // 712: case 0x8: {
1517 OPC_CheckPredicate, 22, // 714: check predicate 22
1518 OPC_CheckField, 25, 1, 1, // 716: check Inst[25] == 0x1
1519 OPC_Decode, 132, 127, 6, // 720: decode to VL4RE16_V using decoder 6
1520 // 720: }
1521 16, 0, // 724: case 0x10: {
1522 OPC_CheckPredicate, 22, // 726: check predicate 22
1523 OPC_Decode, 201, 127, 1, // 728: decode to VLSEG4E16FF_V using decoder 1
1524 // 728: }
1525 // 728: } // switch Inst[24:20]
1526 // 728: }
1527 25, 7, // 732: case 0x19: {
1528 OPC_CheckPredicate, 22, // 734: check predicate 22
1529 OPC_Decode, 153, 128, 1, 3, // 736: decode to VLUXSEG4EI16_V using decoder 3
1530 // 736: }
1531 26, 6, // 741: case 0x1a: {
1532 OPC_CheckPredicate, 22, // 743: check predicate 22
1533 OPC_Decode, 249, 127, 4, // 745: decode to VLSSEG4E16_V using decoder 4
1534 // 745: }
1535 27, 6, // 749: case 0x1b: {
1536 OPC_CheckPredicate, 22, // 751: check predicate 22
1537 OPC_Decode, 161, 127, 3, // 753: decode to VLOXSEG4EI16_V using decoder 3
1538 // 753: }
1539 32, 19, // 757: case 0x20: {
1540 OPC_SwitchField, 20, 5, // 759: switch Inst[24:20] {
1541 0, 6, // 762: case 0x0: {
1542 OPC_CheckPredicate, 22, // 764: check predicate 22
1543 OPC_Decode, 210, 127, 1, // 766: decode to VLSEG5E16_V using decoder 1
1544 // 766: }
1545 16, 0, // 770: case 0x10: {
1546 OPC_CheckPredicate, 22, // 772: check predicate 22
1547 OPC_Decode, 209, 127, 1, // 774: decode to VLSEG5E16FF_V using decoder 1
1548 // 774: }
1549 // 774: } // switch Inst[24:20]
1550 // 774: }
1551 33, 7, // 778: case 0x21: {
1552 OPC_CheckPredicate, 22, // 780: check predicate 22
1553 OPC_Decode, 157, 128, 1, 3, // 782: decode to VLUXSEG5EI16_V using decoder 3
1554 // 782: }
1555 34, 6, // 787: case 0x22: {
1556 OPC_CheckPredicate, 22, // 789: check predicate 22
1557 OPC_Decode, 253, 127, 4, // 791: decode to VLSSEG5E16_V using decoder 4
1558 // 791: }
1559 35, 6, // 795: case 0x23: {
1560 OPC_CheckPredicate, 22, // 797: check predicate 22
1561 OPC_Decode, 165, 127, 3, // 799: decode to VLOXSEG5EI16_V using decoder 3
1562 // 799: }
1563 40, 19, // 803: case 0x28: {
1564 OPC_SwitchField, 20, 5, // 805: switch Inst[24:20] {
1565 0, 6, // 808: case 0x0: {
1566 OPC_CheckPredicate, 22, // 810: check predicate 22
1567 OPC_Decode, 218, 127, 1, // 812: decode to VLSEG6E16_V using decoder 1
1568 // 812: }
1569 16, 0, // 816: case 0x10: {
1570 OPC_CheckPredicate, 22, // 818: check predicate 22
1571 OPC_Decode, 217, 127, 1, // 820: decode to VLSEG6E16FF_V using decoder 1
1572 // 820: }
1573 // 820: } // switch Inst[24:20]
1574 // 820: }
1575 41, 7, // 824: case 0x29: {
1576 OPC_CheckPredicate, 22, // 826: check predicate 22
1577 OPC_Decode, 161, 128, 1, 3, // 828: decode to VLUXSEG6EI16_V using decoder 3
1578 // 828: }
1579 42, 7, // 833: case 0x2a: {
1580 OPC_CheckPredicate, 22, // 835: check predicate 22
1581 OPC_Decode, 129, 128, 1, 4, // 837: decode to VLSSEG6E16_V using decoder 4
1582 // 837: }
1583 43, 6, // 842: case 0x2b: {
1584 OPC_CheckPredicate, 22, // 844: check predicate 22
1585 OPC_Decode, 169, 127, 3, // 846: decode to VLOXSEG6EI16_V using decoder 3
1586 // 846: }
1587 48, 19, // 850: case 0x30: {
1588 OPC_SwitchField, 20, 5, // 852: switch Inst[24:20] {
1589 0, 6, // 855: case 0x0: {
1590 OPC_CheckPredicate, 22, // 857: check predicate 22
1591 OPC_Decode, 226, 127, 1, // 859: decode to VLSEG7E16_V using decoder 1
1592 // 859: }
1593 16, 0, // 863: case 0x10: {
1594 OPC_CheckPredicate, 22, // 865: check predicate 22
1595 OPC_Decode, 225, 127, 1, // 867: decode to VLSEG7E16FF_V using decoder 1
1596 // 867: }
1597 // 867: } // switch Inst[24:20]
1598 // 867: }
1599 49, 7, // 871: case 0x31: {
1600 OPC_CheckPredicate, 22, // 873: check predicate 22
1601 OPC_Decode, 165, 128, 1, 3, // 875: decode to VLUXSEG7EI16_V using decoder 3
1602 // 875: }
1603 50, 7, // 880: case 0x32: {
1604 OPC_CheckPredicate, 22, // 882: check predicate 22
1605 OPC_Decode, 133, 128, 1, 4, // 884: decode to VLSSEG7E16_V using decoder 4
1606 // 884: }
1607 51, 6, // 889: case 0x33: {
1608 OPC_CheckPredicate, 22, // 891: check predicate 22
1609 OPC_Decode, 173, 127, 3, // 893: decode to VLOXSEG7EI16_V using decoder 3
1610 // 893: }
1611 56, 31, // 897: case 0x38: {
1612 OPC_SwitchField, 20, 5, // 899: switch Inst[24:20] {
1613 0, 6, // 902: case 0x0: {
1614 OPC_CheckPredicate, 22, // 904: check predicate 22
1615 OPC_Decode, 234, 127, 1, // 906: decode to VLSEG8E16_V using decoder 1
1616 // 906: }
1617 8, 10, // 910: case 0x8: {
1618 OPC_CheckPredicate, 22, // 912: check predicate 22
1619 OPC_CheckField, 25, 1, 1, // 914: check Inst[25] == 0x1
1620 OPC_Decode, 136, 127, 7, // 918: decode to VL8RE16_V using decoder 7
1621 // 918: }
1622 16, 0, // 922: case 0x10: {
1623 OPC_CheckPredicate, 22, // 924: check predicate 22
1624 OPC_Decode, 233, 127, 1, // 926: decode to VLSEG8E16FF_V using decoder 1
1625 // 926: }
1626 // 926: } // switch Inst[24:20]
1627 // 926: }
1628 57, 7, // 930: case 0x39: {
1629 OPC_CheckPredicate, 22, // 932: check predicate 22
1630 OPC_Decode, 169, 128, 1, 3, // 934: decode to VLUXSEG8EI16_V using decoder 3
1631 // 934: }
1632 58, 7, // 939: case 0x3a: {
1633 OPC_CheckPredicate, 22, // 941: check predicate 22
1634 OPC_Decode, 137, 128, 1, 4, // 943: decode to VLSSEG8E16_V using decoder 4
1635 // 943: }
1636 59, 0, // 948: case 0x3b: {
1637 OPC_CheckPredicate, 22, // 950: check predicate 22
1638 OPC_Decode, 177, 127, 3, // 952: decode to VLOXSEG8EI16_V using decoder 3
1639 // 952: }
1640 // 952: } // switch Inst[31:26]
1641 // 952: }
1642 6, 166, 3, // 956: case 0x6: {
1643 OPC_SwitchField, 26, 6, // 959: switch Inst[31:26] {
1644 0, 31, // 962: case 0x0: {
1645 OPC_SwitchField, 20, 5, // 964: switch Inst[24:20] {
1646 0, 6, // 967: case 0x0: {
1647 OPC_CheckPredicate, 22, // 969: check predicate 22
1648 OPC_Decode, 143, 127, 1, // 971: decode to VLE32_V using decoder 1
1649 // 971: }
1650 8, 10, // 975: case 0x8: {
1651 OPC_CheckPredicate, 22, // 977: check predicate 22
1652 OPC_CheckField, 25, 1, 1, // 979: check Inst[25] == 0x1
1653 OPC_Decode, 253, 126, 2, // 983: decode to VL1RE32_V using decoder 2
1654 // 983: }
1655 16, 0, // 987: case 0x10: {
1656 OPC_CheckPredicate, 22, // 989: check predicate 22
1657 OPC_Decode, 142, 127, 1, // 991: decode to VLE32FF_V using decoder 1
1658 // 991: }
1659 // 991: } // switch Inst[24:20]
1660 // 991: }
1661 1, 7, // 995: case 0x1: {
1662 OPC_CheckPredicate, 22, // 997: check predicate 22
1663 OPC_Decode, 142, 128, 1, 3, // 999: decode to VLUXEI32_V using decoder 3
1664 // 999: }
1665 2, 6, // 1004: case 0x2: {
1666 OPC_CheckPredicate, 22, // 1006: check predicate 22
1667 OPC_Decode, 182, 127, 4, // 1008: decode to VLSE32_V using decoder 4
1668 // 1008: }
1669 3, 6, // 1012: case 0x3: {
1670 OPC_CheckPredicate, 22, // 1014: check predicate 22
1671 OPC_Decode, 150, 127, 3, // 1016: decode to VLOXEI32_V using decoder 3
1672 // 1016: }
1673 8, 31, // 1020: case 0x8: {
1674 OPC_SwitchField, 20, 5, // 1022: switch Inst[24:20] {
1675 0, 6, // 1025: case 0x0: {
1676 OPC_CheckPredicate, 22, // 1027: check predicate 22
1677 OPC_Decode, 188, 127, 1, // 1029: decode to VLSEG2E32_V using decoder 1
1678 // 1029: }
1679 8, 10, // 1033: case 0x8: {
1680 OPC_CheckPredicate, 22, // 1035: check predicate 22
1681 OPC_CheckField, 25, 1, 1, // 1037: check Inst[25] == 0x1
1682 OPC_Decode, 129, 127, 5, // 1041: decode to VL2RE32_V using decoder 5
1683 // 1041: }
1684 16, 0, // 1045: case 0x10: {
1685 OPC_CheckPredicate, 22, // 1047: check predicate 22
1686 OPC_Decode, 187, 127, 1, // 1049: decode to VLSEG2E32FF_V using decoder 1
1687 // 1049: }
1688 // 1049: } // switch Inst[24:20]
1689 // 1049: }
1690 9, 7, // 1053: case 0x9: {
1691 OPC_CheckPredicate, 22, // 1055: check predicate 22
1692 OPC_Decode, 146, 128, 1, 3, // 1057: decode to VLUXSEG2EI32_V using decoder 3
1693 // 1057: }
1694 10, 6, // 1062: case 0xa: {
1695 OPC_CheckPredicate, 22, // 1064: check predicate 22
1696 OPC_Decode, 242, 127, 4, // 1066: decode to VLSSEG2E32_V using decoder 4
1697 // 1066: }
1698 11, 6, // 1070: case 0xb: {
1699 OPC_CheckPredicate, 22, // 1072: check predicate 22
1700 OPC_Decode, 154, 127, 3, // 1074: decode to VLOXSEG2EI32_V using decoder 3
1701 // 1074: }
1702 16, 19, // 1078: case 0x10: {
1703 OPC_SwitchField, 20, 5, // 1080: switch Inst[24:20] {
1704 0, 6, // 1083: case 0x0: {
1705 OPC_CheckPredicate, 22, // 1085: check predicate 22
1706 OPC_Decode, 196, 127, 1, // 1087: decode to VLSEG3E32_V using decoder 1
1707 // 1087: }
1708 16, 0, // 1091: case 0x10: {
1709 OPC_CheckPredicate, 22, // 1093: check predicate 22
1710 OPC_Decode, 195, 127, 1, // 1095: decode to VLSEG3E32FF_V using decoder 1
1711 // 1095: }
1712 // 1095: } // switch Inst[24:20]
1713 // 1095: }
1714 17, 7, // 1099: case 0x11: {
1715 OPC_CheckPredicate, 22, // 1101: check predicate 22
1716 OPC_Decode, 150, 128, 1, 3, // 1103: decode to VLUXSEG3EI32_V using decoder 3
1717 // 1103: }
1718 18, 6, // 1108: case 0x12: {
1719 OPC_CheckPredicate, 22, // 1110: check predicate 22
1720 OPC_Decode, 246, 127, 4, // 1112: decode to VLSSEG3E32_V using decoder 4
1721 // 1112: }
1722 19, 6, // 1116: case 0x13: {
1723 OPC_CheckPredicate, 22, // 1118: check predicate 22
1724 OPC_Decode, 158, 127, 3, // 1120: decode to VLOXSEG3EI32_V using decoder 3
1725 // 1120: }
1726 24, 31, // 1124: case 0x18: {
1727 OPC_SwitchField, 20, 5, // 1126: switch Inst[24:20] {
1728 0, 6, // 1129: case 0x0: {
1729 OPC_CheckPredicate, 22, // 1131: check predicate 22
1730 OPC_Decode, 204, 127, 1, // 1133: decode to VLSEG4E32_V using decoder 1
1731 // 1133: }
1732 8, 10, // 1137: case 0x8: {
1733 OPC_CheckPredicate, 22, // 1139: check predicate 22
1734 OPC_CheckField, 25, 1, 1, // 1141: check Inst[25] == 0x1
1735 OPC_Decode, 133, 127, 6, // 1145: decode to VL4RE32_V using decoder 6
1736 // 1145: }
1737 16, 0, // 1149: case 0x10: {
1738 OPC_CheckPredicate, 22, // 1151: check predicate 22
1739 OPC_Decode, 203, 127, 1, // 1153: decode to VLSEG4E32FF_V using decoder 1
1740 // 1153: }
1741 // 1153: } // switch Inst[24:20]
1742 // 1153: }
1743 25, 7, // 1157: case 0x19: {
1744 OPC_CheckPredicate, 22, // 1159: check predicate 22
1745 OPC_Decode, 154, 128, 1, 3, // 1161: decode to VLUXSEG4EI32_V using decoder 3
1746 // 1161: }
1747 26, 6, // 1166: case 0x1a: {
1748 OPC_CheckPredicate, 22, // 1168: check predicate 22
1749 OPC_Decode, 250, 127, 4, // 1170: decode to VLSSEG4E32_V using decoder 4
1750 // 1170: }
1751 27, 6, // 1174: case 0x1b: {
1752 OPC_CheckPredicate, 22, // 1176: check predicate 22
1753 OPC_Decode, 162, 127, 3, // 1178: decode to VLOXSEG4EI32_V using decoder 3
1754 // 1178: }
1755 32, 19, // 1182: case 0x20: {
1756 OPC_SwitchField, 20, 5, // 1184: switch Inst[24:20] {
1757 0, 6, // 1187: case 0x0: {
1758 OPC_CheckPredicate, 22, // 1189: check predicate 22
1759 OPC_Decode, 212, 127, 1, // 1191: decode to VLSEG5E32_V using decoder 1
1760 // 1191: }
1761 16, 0, // 1195: case 0x10: {
1762 OPC_CheckPredicate, 22, // 1197: check predicate 22
1763 OPC_Decode, 211, 127, 1, // 1199: decode to VLSEG5E32FF_V using decoder 1
1764 // 1199: }
1765 // 1199: } // switch Inst[24:20]
1766 // 1199: }
1767 33, 7, // 1203: case 0x21: {
1768 OPC_CheckPredicate, 22, // 1205: check predicate 22
1769 OPC_Decode, 158, 128, 1, 3, // 1207: decode to VLUXSEG5EI32_V using decoder 3
1770 // 1207: }
1771 34, 6, // 1212: case 0x22: {
1772 OPC_CheckPredicate, 22, // 1214: check predicate 22
1773 OPC_Decode, 254, 127, 4, // 1216: decode to VLSSEG5E32_V using decoder 4
1774 // 1216: }
1775 35, 6, // 1220: case 0x23: {
1776 OPC_CheckPredicate, 22, // 1222: check predicate 22
1777 OPC_Decode, 166, 127, 3, // 1224: decode to VLOXSEG5EI32_V using decoder 3
1778 // 1224: }
1779 40, 19, // 1228: case 0x28: {
1780 OPC_SwitchField, 20, 5, // 1230: switch Inst[24:20] {
1781 0, 6, // 1233: case 0x0: {
1782 OPC_CheckPredicate, 22, // 1235: check predicate 22
1783 OPC_Decode, 220, 127, 1, // 1237: decode to VLSEG6E32_V using decoder 1
1784 // 1237: }
1785 16, 0, // 1241: case 0x10: {
1786 OPC_CheckPredicate, 22, // 1243: check predicate 22
1787 OPC_Decode, 219, 127, 1, // 1245: decode to VLSEG6E32FF_V using decoder 1
1788 // 1245: }
1789 // 1245: } // switch Inst[24:20]
1790 // 1245: }
1791 41, 7, // 1249: case 0x29: {
1792 OPC_CheckPredicate, 22, // 1251: check predicate 22
1793 OPC_Decode, 162, 128, 1, 3, // 1253: decode to VLUXSEG6EI32_V using decoder 3
1794 // 1253: }
1795 42, 7, // 1258: case 0x2a: {
1796 OPC_CheckPredicate, 22, // 1260: check predicate 22
1797 OPC_Decode, 130, 128, 1, 4, // 1262: decode to VLSSEG6E32_V using decoder 4
1798 // 1262: }
1799 43, 6, // 1267: case 0x2b: {
1800 OPC_CheckPredicate, 22, // 1269: check predicate 22
1801 OPC_Decode, 170, 127, 3, // 1271: decode to VLOXSEG6EI32_V using decoder 3
1802 // 1271: }
1803 48, 19, // 1275: case 0x30: {
1804 OPC_SwitchField, 20, 5, // 1277: switch Inst[24:20] {
1805 0, 6, // 1280: case 0x0: {
1806 OPC_CheckPredicate, 22, // 1282: check predicate 22
1807 OPC_Decode, 228, 127, 1, // 1284: decode to VLSEG7E32_V using decoder 1
1808 // 1284: }
1809 16, 0, // 1288: case 0x10: {
1810 OPC_CheckPredicate, 22, // 1290: check predicate 22
1811 OPC_Decode, 227, 127, 1, // 1292: decode to VLSEG7E32FF_V using decoder 1
1812 // 1292: }
1813 // 1292: } // switch Inst[24:20]
1814 // 1292: }
1815 49, 7, // 1296: case 0x31: {
1816 OPC_CheckPredicate, 22, // 1298: check predicate 22
1817 OPC_Decode, 166, 128, 1, 3, // 1300: decode to VLUXSEG7EI32_V using decoder 3
1818 // 1300: }
1819 50, 7, // 1305: case 0x32: {
1820 OPC_CheckPredicate, 22, // 1307: check predicate 22
1821 OPC_Decode, 134, 128, 1, 4, // 1309: decode to VLSSEG7E32_V using decoder 4
1822 // 1309: }
1823 51, 6, // 1314: case 0x33: {
1824 OPC_CheckPredicate, 22, // 1316: check predicate 22
1825 OPC_Decode, 174, 127, 3, // 1318: decode to VLOXSEG7EI32_V using decoder 3
1826 // 1318: }
1827 56, 31, // 1322: case 0x38: {
1828 OPC_SwitchField, 20, 5, // 1324: switch Inst[24:20] {
1829 0, 6, // 1327: case 0x0: {
1830 OPC_CheckPredicate, 22, // 1329: check predicate 22
1831 OPC_Decode, 236, 127, 1, // 1331: decode to VLSEG8E32_V using decoder 1
1832 // 1331: }
1833 8, 10, // 1335: case 0x8: {
1834 OPC_CheckPredicate, 22, // 1337: check predicate 22
1835 OPC_CheckField, 25, 1, 1, // 1339: check Inst[25] == 0x1
1836 OPC_Decode, 137, 127, 7, // 1343: decode to VL8RE32_V using decoder 7
1837 // 1343: }
1838 16, 0, // 1347: case 0x10: {
1839 OPC_CheckPredicate, 22, // 1349: check predicate 22
1840 OPC_Decode, 235, 127, 1, // 1351: decode to VLSEG8E32FF_V using decoder 1
1841 // 1351: }
1842 // 1351: } // switch Inst[24:20]
1843 // 1351: }
1844 57, 7, // 1355: case 0x39: {
1845 OPC_CheckPredicate, 22, // 1357: check predicate 22
1846 OPC_Decode, 170, 128, 1, 3, // 1359: decode to VLUXSEG8EI32_V using decoder 3
1847 // 1359: }
1848 58, 7, // 1364: case 0x3a: {
1849 OPC_CheckPredicate, 22, // 1366: check predicate 22
1850 OPC_Decode, 138, 128, 1, 4, // 1368: decode to VLSSEG8E32_V using decoder 4
1851 // 1368: }
1852 59, 0, // 1373: case 0x3b: {
1853 OPC_CheckPredicate, 22, // 1375: check predicate 22
1854 OPC_Decode, 178, 127, 3, // 1377: decode to VLOXSEG8EI32_V using decoder 3
1855 // 1377: }
1856 // 1377: } // switch Inst[31:26]
1857 // 1377: }
1858 7, 0, // 1381: case 0x7: {
1859 OPC_SwitchField, 26, 3, // 1383: switch Inst[28:26] {
1860 0, 219, 1, // 1386: case 0x0: {
1861 OPC_SwitchField, 29, 3, // 1389: switch Inst[31:29] {
1862 0, 31, // 1392: case 0x0: {
1863 OPC_SwitchField, 20, 5, // 1394: switch Inst[24:20] {
1864 0, 6, // 1397: case 0x0: {
1865 OPC_CheckPredicate, 27, // 1399: check predicate 27
1866 OPC_Decode, 145, 127, 1, // 1401: decode to VLE64_V using decoder 1
1867 // 1401: }
1868 8, 10, // 1405: case 0x8: {
1869 OPC_CheckPredicate, 27, // 1407: check predicate 27
1870 OPC_CheckField, 25, 1, 1, // 1409: check Inst[25] == 0x1
1871 OPC_Decode, 254, 126, 2, // 1413: decode to VL1RE64_V using decoder 2
1872 // 1413: }
1873 16, 0, // 1417: case 0x10: {
1874 OPC_CheckPredicate, 27, // 1419: check predicate 27
1875 OPC_Decode, 144, 127, 1, // 1421: decode to VLE64FF_V using decoder 1
1876 // 1421: }
1877 // 1421: } // switch Inst[24:20]
1878 // 1421: }
1879 1, 31, // 1425: case 0x1: {
1880 OPC_SwitchField, 20, 5, // 1427: switch Inst[24:20] {
1881 0, 6, // 1430: case 0x0: {
1882 OPC_CheckPredicate, 27, // 1432: check predicate 27
1883 OPC_Decode, 190, 127, 1, // 1434: decode to VLSEG2E64_V using decoder 1
1884 // 1434: }
1885 8, 10, // 1438: case 0x8: {
1886 OPC_CheckPredicate, 27, // 1440: check predicate 27
1887 OPC_CheckField, 25, 1, 1, // 1442: check Inst[25] == 0x1
1888 OPC_Decode, 130, 127, 5, // 1446: decode to VL2RE64_V using decoder 5
1889 // 1446: }
1890 16, 0, // 1450: case 0x10: {
1891 OPC_CheckPredicate, 27, // 1452: check predicate 27
1892 OPC_Decode, 189, 127, 1, // 1454: decode to VLSEG2E64FF_V using decoder 1
1893 // 1454: }
1894 // 1454: } // switch Inst[24:20]
1895 // 1454: }
1896 2, 19, // 1458: case 0x2: {
1897 OPC_SwitchField, 20, 5, // 1460: switch Inst[24:20] {
1898 0, 6, // 1463: case 0x0: {
1899 OPC_CheckPredicate, 27, // 1465: check predicate 27
1900 OPC_Decode, 198, 127, 1, // 1467: decode to VLSEG3E64_V using decoder 1
1901 // 1467: }
1902 16, 0, // 1471: case 0x10: {
1903 OPC_CheckPredicate, 27, // 1473: check predicate 27
1904 OPC_Decode, 197, 127, 1, // 1475: decode to VLSEG3E64FF_V using decoder 1
1905 // 1475: }
1906 // 1475: } // switch Inst[24:20]
1907 // 1475: }
1908 3, 31, // 1479: case 0x3: {
1909 OPC_SwitchField, 20, 5, // 1481: switch Inst[24:20] {
1910 0, 6, // 1484: case 0x0: {
1911 OPC_CheckPredicate, 27, // 1486: check predicate 27
1912 OPC_Decode, 206, 127, 1, // 1488: decode to VLSEG4E64_V using decoder 1
1913 // 1488: }
1914 8, 10, // 1492: case 0x8: {
1915 OPC_CheckPredicate, 27, // 1494: check predicate 27
1916 OPC_CheckField, 25, 1, 1, // 1496: check Inst[25] == 0x1
1917 OPC_Decode, 134, 127, 6, // 1500: decode to VL4RE64_V using decoder 6
1918 // 1500: }
1919 16, 0, // 1504: case 0x10: {
1920 OPC_CheckPredicate, 27, // 1506: check predicate 27
1921 OPC_Decode, 205, 127, 1, // 1508: decode to VLSEG4E64FF_V using decoder 1
1922 // 1508: }
1923 // 1508: } // switch Inst[24:20]
1924 // 1508: }
1925 4, 19, // 1512: case 0x4: {
1926 OPC_SwitchField, 20, 5, // 1514: switch Inst[24:20] {
1927 0, 6, // 1517: case 0x0: {
1928 OPC_CheckPredicate, 27, // 1519: check predicate 27
1929 OPC_Decode, 214, 127, 1, // 1521: decode to VLSEG5E64_V using decoder 1
1930 // 1521: }
1931 16, 0, // 1525: case 0x10: {
1932 OPC_CheckPredicate, 27, // 1527: check predicate 27
1933 OPC_Decode, 213, 127, 1, // 1529: decode to VLSEG5E64FF_V using decoder 1
1934 // 1529: }
1935 // 1529: } // switch Inst[24:20]
1936 // 1529: }
1937 5, 19, // 1533: case 0x5: {
1938 OPC_SwitchField, 20, 5, // 1535: switch Inst[24:20] {
1939 0, 6, // 1538: case 0x0: {
1940 OPC_CheckPredicate, 27, // 1540: check predicate 27
1941 OPC_Decode, 222, 127, 1, // 1542: decode to VLSEG6E64_V using decoder 1
1942 // 1542: }
1943 16, 0, // 1546: case 0x10: {
1944 OPC_CheckPredicate, 27, // 1548: check predicate 27
1945 OPC_Decode, 221, 127, 1, // 1550: decode to VLSEG6E64FF_V using decoder 1
1946 // 1550: }
1947 // 1550: } // switch Inst[24:20]
1948 // 1550: }
1949 6, 19, // 1554: case 0x6: {
1950 OPC_SwitchField, 20, 5, // 1556: switch Inst[24:20] {
1951 0, 6, // 1559: case 0x0: {
1952 OPC_CheckPredicate, 27, // 1561: check predicate 27
1953 OPC_Decode, 230, 127, 1, // 1563: decode to VLSEG7E64_V using decoder 1
1954 // 1563: }
1955 16, 0, // 1567: case 0x10: {
1956 OPC_CheckPredicate, 27, // 1569: check predicate 27
1957 OPC_Decode, 229, 127, 1, // 1571: decode to VLSEG7E64FF_V using decoder 1
1958 // 1571: }
1959 // 1571: } // switch Inst[24:20]
1960 // 1571: }
1961 7, 0, // 1575: case 0x7: {
1962 OPC_SwitchField, 20, 5, // 1577: switch Inst[24:20] {
1963 0, 6, // 1580: case 0x0: {
1964 OPC_CheckPredicate, 27, // 1582: check predicate 27
1965 OPC_Decode, 238, 127, 1, // 1584: decode to VLSEG8E64_V using decoder 1
1966 // 1584: }
1967 8, 10, // 1588: case 0x8: {
1968 OPC_CheckPredicate, 27, // 1590: check predicate 27
1969 OPC_CheckField, 25, 1, 1, // 1592: check Inst[25] == 0x1
1970 OPC_Decode, 138, 127, 7, // 1596: decode to VL8RE64_V using decoder 7
1971 // 1596: }
1972 16, 0, // 1600: case 0x10: {
1973 OPC_CheckPredicate, 27, // 1602: check predicate 27
1974 OPC_Decode, 237, 127, 1, // 1604: decode to VLSEG8E64FF_V using decoder 1
1975 // 1604: }
1976 // 1604: } // switch Inst[24:20]
1977 // 1604: }
1978 // 1604: } // switch Inst[31:29]
1979 // 1604: }
1980 1, 75, // 1608: case 0x1: {
1981 OPC_SwitchField, 29, 3, // 1610: switch Inst[31:29] {
1982 0, 7, // 1613: case 0x0: {
1983 OPC_CheckPredicate, 28, // 1615: check predicate 28
1984 OPC_Decode, 143, 128, 1, 3, // 1617: decode to VLUXEI64_V using decoder 3
1985 // 1617: }
1986 1, 7, // 1622: case 0x1: {
1987 OPC_CheckPredicate, 29, // 1624: check predicate 29
1988 OPC_Decode, 147, 128, 1, 3, // 1626: decode to VLUXSEG2EI64_V using decoder 3
1989 // 1626: }
1990 2, 7, // 1631: case 0x2: {
1991 OPC_CheckPredicate, 29, // 1633: check predicate 29
1992 OPC_Decode, 151, 128, 1, 3, // 1635: decode to VLUXSEG3EI64_V using decoder 3
1993 // 1635: }
1994 3, 7, // 1640: case 0x3: {
1995 OPC_CheckPredicate, 29, // 1642: check predicate 29
1996 OPC_Decode, 155, 128, 1, 3, // 1644: decode to VLUXSEG4EI64_V using decoder 3
1997 // 1644: }
1998 4, 7, // 1649: case 0x4: {
1999 OPC_CheckPredicate, 29, // 1651: check predicate 29
2000 OPC_Decode, 159, 128, 1, 3, // 1653: decode to VLUXSEG5EI64_V using decoder 3
2001 // 1653: }
2002 5, 7, // 1658: case 0x5: {
2003 OPC_CheckPredicate, 29, // 1660: check predicate 29
2004 OPC_Decode, 163, 128, 1, 3, // 1662: decode to VLUXSEG6EI64_V using decoder 3
2005 // 1662: }
2006 6, 7, // 1667: case 0x6: {
2007 OPC_CheckPredicate, 29, // 1669: check predicate 29
2008 OPC_Decode, 167, 128, 1, 3, // 1671: decode to VLUXSEG7EI64_V using decoder 3
2009 // 1671: }
2010 7, 0, // 1676: case 0x7: {
2011 OPC_CheckPredicate, 29, // 1678: check predicate 29
2012 OPC_Decode, 171, 128, 1, 3, // 1680: decode to VLUXSEG8EI64_V using decoder 3
2013 // 1680: }
2014 // 1680: } // switch Inst[31:29]
2015 // 1680: }
2016 2, 70, // 1685: case 0x2: {
2017 OPC_SwitchField, 29, 3, // 1687: switch Inst[31:29] {
2018 0, 6, // 1690: case 0x0: {
2019 OPC_CheckPredicate, 27, // 1692: check predicate 27
2020 OPC_Decode, 183, 127, 4, // 1694: decode to VLSE64_V using decoder 4
2021 // 1694: }
2022 1, 6, // 1698: case 0x1: {
2023 OPC_CheckPredicate, 27, // 1700: check predicate 27
2024 OPC_Decode, 243, 127, 4, // 1702: decode to VLSSEG2E64_V using decoder 4
2025 // 1702: }
2026 2, 6, // 1706: case 0x2: {
2027 OPC_CheckPredicate, 27, // 1708: check predicate 27
2028 OPC_Decode, 247, 127, 4, // 1710: decode to VLSSEG3E64_V using decoder 4
2029 // 1710: }
2030 3, 6, // 1714: case 0x3: {
2031 OPC_CheckPredicate, 27, // 1716: check predicate 27
2032 OPC_Decode, 251, 127, 4, // 1718: decode to VLSSEG4E64_V using decoder 4
2033 // 1718: }
2034 4, 6, // 1722: case 0x4: {
2035 OPC_CheckPredicate, 27, // 1724: check predicate 27
2036 OPC_Decode, 255, 127, 4, // 1726: decode to VLSSEG5E64_V using decoder 4
2037 // 1726: }
2038 5, 7, // 1730: case 0x5: {
2039 OPC_CheckPredicate, 27, // 1732: check predicate 27
2040 OPC_Decode, 131, 128, 1, 4, // 1734: decode to VLSSEG6E64_V using decoder 4
2041 // 1734: }
2042 6, 7, // 1739: case 0x6: {
2043 OPC_CheckPredicate, 27, // 1741: check predicate 27
2044 OPC_Decode, 135, 128, 1, 4, // 1743: decode to VLSSEG7E64_V using decoder 4
2045 // 1743: }
2046 7, 0, // 1748: case 0x7: {
2047 OPC_CheckPredicate, 27, // 1750: check predicate 27
2048 OPC_Decode, 139, 128, 1, 4, // 1752: decode to VLSSEG8E64_V using decoder 4
2049 // 1752: }
2050 // 1752: } // switch Inst[31:29]
2051 // 1752: }
2052 3, 67, // 1757: case 0x3: {
2053 OPC_SwitchField, 29, 3, // 1759: switch Inst[31:29] {
2054 0, 6, // 1762: case 0x0: {
2055 OPC_CheckPredicate, 28, // 1764: check predicate 28
2056 OPC_Decode, 151, 127, 3, // 1766: decode to VLOXEI64_V using decoder 3
2057 // 1766: }
2058 1, 6, // 1770: case 0x1: {
2059 OPC_CheckPredicate, 29, // 1772: check predicate 29
2060 OPC_Decode, 155, 127, 3, // 1774: decode to VLOXSEG2EI64_V using decoder 3
2061 // 1774: }
2062 2, 6, // 1778: case 0x2: {
2063 OPC_CheckPredicate, 29, // 1780: check predicate 29
2064 OPC_Decode, 159, 127, 3, // 1782: decode to VLOXSEG3EI64_V using decoder 3
2065 // 1782: }
2066 3, 6, // 1786: case 0x3: {
2067 OPC_CheckPredicate, 29, // 1788: check predicate 29
2068 OPC_Decode, 163, 127, 3, // 1790: decode to VLOXSEG4EI64_V using decoder 3
2069 // 1790: }
2070 4, 6, // 1794: case 0x4: {
2071 OPC_CheckPredicate, 29, // 1796: check predicate 29
2072 OPC_Decode, 167, 127, 3, // 1798: decode to VLOXSEG5EI64_V using decoder 3
2073 // 1798: }
2074 5, 6, // 1802: case 0x5: {
2075 OPC_CheckPredicate, 29, // 1804: check predicate 29
2076 OPC_Decode, 171, 127, 3, // 1806: decode to VLOXSEG6EI64_V using decoder 3
2077 // 1806: }
2078 6, 6, // 1810: case 0x6: {
2079 OPC_CheckPredicate, 29, // 1812: check predicate 29
2080 OPC_Decode, 175, 127, 3, // 1814: decode to VLOXSEG7EI64_V using decoder 3
2081 // 1814: }
2082 7, 0, // 1818: case 0x7: {
2083 OPC_CheckPredicate, 29, // 1820: check predicate 29
2084 OPC_Decode, 179, 127, 3, // 1822: decode to VLOXSEG8EI64_V using decoder 3
2085 // 1822: }
2086 // 1822: } // switch Inst[31:29]
2087 // 1822: }
2088 4, 7, // 1826: case 0x4: {
2089 OPC_CheckPredicate, 30, // 1828: check predicate 30
2090 OPC_Decode, 134, 129, 1, 12, // 1830: decode to VMTL_V using decoder 12
2091 // 1830: }
2092 5, 0, // 1835: case 0x5: {
2093 OPC_CheckPredicate, 31, // 1837: check predicate 31
2094 OPC_Decode, 136, 129, 1, 12, // 1839: decode to VMTTL_V using decoder 12
2095 // 1839: }
2096 // 1839: } // switch Inst[28:26]
2097 // 1839: }
2098 // 1839: } // switch Inst[14:12]
2099 // 1839: }
2100 15, 76, // 1844: case 0xf: {
2101 OPC_SwitchField, 7, 8, // 1846: switch Inst[14:7] {
2102 0, 24, // 1849: case 0x0: {
2103 OPC_SwitchField, 28, 4, // 1851: switch Inst[31:28] {
2104 0, 8, // 1854: case 0x0: {
2105 OPC_CheckField, 15, 5, 0, // 1856: check Inst[19:15] == 0x0
2106 OPC_Decode, 213, 114, 13, // 1860: decode to FENCE using decoder 13
2107 // 1860: }
2108 8, 0, // 1864: case 0x8: {
2109 OPC_CheckField, 15, 13, 224, 12, // 1866: check Inst[27:15] == 0x660
2110 OPC_Decode, 215, 114, 14, // 1871: decode to FENCE_TSO using decoder 14
2111 // 1871: }
2112 // 1871: } // switch Inst[31:28]
2113 // 1871: }
2114 32, 8, // 1875: case 0x20: {
2115 OPC_CheckField, 15, 17, 0, // 1877: check Inst[31:15] == 0x0
2116 OPC_Decode, 214, 114, 14, // 1881: decode to FENCE_I using decoder 14
2117 // 1881: }
2118 64, 0, // 1885: case 0x40: {
2119 OPC_SwitchField, 20, 12, // 1887: switch Inst[31:20] {
2120 0, 6, // 1890: case 0x0: {
2121 OPC_CheckPredicate, 32, // 1892: check predicate 32
2122 OPC_Decode, 196, 110, 15, // 1894: decode to CBO_INVAL using decoder 15
2123 // 1894: }
2124 1, 6, // 1898: case 0x1: {
2125 OPC_CheckPredicate, 32, // 1900: check predicate 32
2126 OPC_Decode, 194, 110, 15, // 1902: decode to CBO_CLEAN using decoder 15
2127 // 1902: }
2128 2, 6, // 1906: case 0x2: {
2129 OPC_CheckPredicate, 32, // 1908: check predicate 32
2130 OPC_Decode, 195, 110, 15, // 1910: decode to CBO_FLUSH using decoder 15
2131 // 1910: }
2132 4, 0, // 1914: case 0x4: {
2133 OPC_CheckPredicate, 33, // 1916: check predicate 33
2134 OPC_Decode, 197, 110, 15, // 1918: decode to CBO_ZERO using decoder 15
2135 // 1918: }
2136 // 1918: } // switch Inst[31:20]
2137 // 1918: }
2138 // 1918: } // switch Inst[14:7]
2139 // 1918: }
2140 19, 149, 3, // 1922: case 0x13: {
2141 OPC_SwitchField, 12, 3, // 1925: switch Inst[14:12] {
2142 0, 4, // 1928: case 0x0: {
2143 OPC_Decode, 159, 107, 0, // 1930: decode to ADDI using decoder 0
2144 // 1930: }
2145 1, 217, 1, // 1934: case 0x1: {
2146 OPC_SwitchField, 26, 6, // 1937: switch Inst[31:26] {
2147 0, 4, // 1940: case 0x0: {
2148 OPC_Decode, 141, 124, 16, // 1942: decode to SLLI using decoder 16
2149 // 1942: }
2150 2, 11, // 1946: case 0x2: {
2151 OPC_CheckPredicate, 34, // 1948: check predicate 34
2152 OPC_CheckField, 20, 6, 15, // 1950: check Inst[25:20] == 0xf
2153 OPC_Decode, 242, 131, 1, 17, // 1954: decode to ZIP_RV32 using decoder 17
2154 // 1954: }
2155 4, 83, // 1959: case 0x4: {
2156 OPC_SwitchField, 20, 6, // 1961: switch Inst[25:20] {
2157 0, 6, // 1964: case 0x0: {
2158 OPC_CheckPredicate, 35, // 1966: check predicate 35
2159 OPC_Decode, 249, 123, 17, // 1968: decode to SHA256SUM0 using decoder 17
2160 // 1968: }
2161 1, 6, // 1972: case 0x1: {
2162 OPC_CheckPredicate, 35, // 1974: check predicate 35
2163 OPC_Decode, 250, 123, 17, // 1976: decode to SHA256SUM1 using decoder 17
2164 // 1976: }
2165 2, 6, // 1980: case 0x2: {
2166 OPC_CheckPredicate, 35, // 1982: check predicate 35
2167 OPC_Decode, 247, 123, 17, // 1984: decode to SHA256SIG0 using decoder 17
2168 // 1984: }
2169 3, 6, // 1988: case 0x3: {
2170 OPC_CheckPredicate, 35, // 1990: check predicate 35
2171 OPC_Decode, 248, 123, 17, // 1992: decode to SHA256SIG1 using decoder 17
2172 // 1992: }
2173 4, 6, // 1996: case 0x4: {
2174 OPC_CheckPredicate, 36, // 1998: check predicate 36
2175 OPC_Decode, 129, 124, 17, // 2000: decode to SHA512SUM0 using decoder 17
2176 // 2000: }
2177 5, 6, // 2004: case 0x5: {
2178 OPC_CheckPredicate, 36, // 2006: check predicate 36
2179 OPC_Decode, 131, 124, 17, // 2008: decode to SHA512SUM1 using decoder 17
2180 // 2008: }
2181 6, 6, // 2012: case 0x6: {
2182 OPC_CheckPredicate, 36, // 2014: check predicate 36
2183 OPC_Decode, 251, 123, 17, // 2016: decode to SHA512SIG0 using decoder 17
2184 // 2016: }
2185 7, 6, // 2020: case 0x7: {
2186 OPC_CheckPredicate, 36, // 2022: check predicate 36
2187 OPC_Decode, 254, 123, 17, // 2024: decode to SHA512SIG1 using decoder 17
2188 // 2024: }
2189 8, 6, // 2028: case 0x8: {
2190 OPC_CheckPredicate, 37, // 2030: check predicate 37
2191 OPC_Decode, 150, 124, 17, // 2032: decode to SM3P0 using decoder 17
2192 // 2032: }
2193 9, 0, // 2036: case 0x9: {
2194 OPC_CheckPredicate, 37, // 2038: check predicate 37
2195 OPC_Decode, 151, 124, 17, // 2040: decode to SM3P1 using decoder 17
2196 // 2040: }
2197 // 2040: } // switch Inst[25:20]
2198 // 2040: }
2199 10, 6, // 2044: case 0xa: {
2200 OPC_CheckPredicate, 38, // 2046: check predicate 38
2201 OPC_Decode, 193, 110, 16, // 2048: decode to BSETI using decoder 16
2202 // 2048: }
2203 12, 23, // 2052: case 0xc: {
2204 OPC_SwitchField, 24, 2, // 2054: switch Inst[25:24] {
2205 0, 10, // 2057: case 0x0: {
2206 OPC_CheckPredicate, 39, // 2059: check predicate 39
2207 OPC_CheckField, 20, 4, 0, // 2061: check Inst[23:20] == 0x0
2208 OPC_Decode, 171, 107, 17, // 2065: decode to AES64IM using decoder 17
2209 // 2065: }
2210 1, 0, // 2069: case 0x1: {
2211 OPC_CheckPredicate, 40, // 2071: check predicate 40
2212 OPC_Decode, 172, 107, 18, // 2073: decode to AES64KS1I using decoder 18
2213 // 2073: }
2214 // 2073: } // switch Inst[25:24]
2215 // 2073: }
2216 18, 6, // 2077: case 0x12: {
2217 OPC_CheckPredicate, 38, // 2079: check predicate 38
2218 OPC_Decode, 178, 110, 16, // 2081: decode to BCLRI using decoder 16
2219 // 2081: }
2220 24, 59, // 2085: case 0x18: {
2221 OPC_SwitchField, 20, 6, // 2087: switch Inst[25:20] {
2222 0, 6, // 2090: case 0x0: {
2223 OPC_CheckPredicate, 41, // 2092: check predicate 41
2224 OPC_Decode, 203, 110, 17, // 2094: decode to CLZ using decoder 17
2225 // 2094: }
2226 1, 6, // 2098: case 0x1: {
2227 OPC_CheckPredicate, 41, // 2100: check predicate 41
2228 OPC_Decode, 221, 110, 17, // 2102: decode to CTZ using decoder 17
2229 // 2102: }
2230 2, 6, // 2106: case 0x2: {
2231 OPC_CheckPredicate, 41, // 2108: check predicate 41
2232 OPC_Decode, 213, 110, 17, // 2110: decode to CPOP using decoder 17
2233 // 2110: }
2234 3, 6, // 2114: case 0x3: {
2235 OPC_CheckPredicate, 42, // 2116: check predicate 42
2236 OPC_Decode, 201, 110, 17, // 2118: decode to CLS using decoder 17
2237 // 2118: }
2238 4, 6, // 2122: case 0x4: {
2239 OPC_CheckPredicate, 41, // 2124: check predicate 41
2240 OPC_Decode, 166, 123, 17, // 2126: decode to SEXT_B using decoder 17
2241 // 2126: }
2242 5, 6, // 2130: case 0x5: {
2243 OPC_CheckPredicate, 41, // 2132: check predicate 41
2244 OPC_Decode, 167, 123, 17, // 2134: decode to SEXT_H using decoder 17
2245 // 2134: }
2246 7, 0, // 2138: case 0x7: {
2247 OPC_CheckPredicate, 42, // 2140: check predicate 42
2248 OPC_Decode, 155, 107, 17, // 2142: decode to ABS using decoder 17
2249 // 2142: }
2250 // 2142: } // switch Inst[25:20]
2251 // 2142: }
2252 26, 0, // 2146: case 0x1a: {
2253 OPC_CheckPredicate, 38, // 2148: check predicate 38
2254 OPC_Decode, 186, 110, 16, // 2150: decode to BINVI using decoder 16
2255 // 2150: }
2256 // 2150: } // switch Inst[31:26]
2257 // 2150: }
2258 2, 4, // 2154: case 0x2: {
2259 OPC_Decode, 146, 124, 0, // 2156: decode to SLTI using decoder 0
2260 // 2156: }
2261 3, 4, // 2160: case 0x3: {
2262 OPC_Decode, 147, 124, 0, // 2162: decode to SLTIU using decoder 0
2263 // 2162: }
2264 4, 5, // 2166: case 0x4: {
2265 OPC_Decode, 214, 131, 1, 0, // 2168: decode to XORI using decoder 0
2266 // 2168: }
2267 5, 108, // 2173: case 0x5: {
2268 OPC_SwitchField, 26, 6, // 2175: switch Inst[31:26] {
2269 0, 4, // 2178: case 0x0: {
2270 OPC_Decode, 178, 124, 16, // 2180: decode to SRLI using decoder 16
2271 // 2180: }
2272 2, 10, // 2184: case 0x2: {
2273 OPC_CheckPredicate, 34, // 2186: check predicate 34
2274 OPC_CheckField, 20, 6, 15, // 2188: check Inst[25:20] == 0xf
2275 OPC_Decode, 195, 125, 17, // 2192: decode to UNZIP_RV32 using decoder 17
2276 // 2192: }
2277 10, 10, // 2196: case 0xa: {
2278 OPC_CheckPredicate, 41, // 2198: check predicate 41
2279 OPC_CheckField, 20, 6, 7, // 2200: check Inst[25:20] == 0x7
2280 OPC_Decode, 137, 118, 17, // 2204: decode to ORC_B using decoder 17
2281 // 2204: }
2282 16, 4, // 2208: case 0x10: {
2283 OPC_Decode, 171, 124, 16, // 2210: decode to SRAI using decoder 16
2284 // 2210: }
2285 18, 6, // 2214: case 0x12: {
2286 OPC_CheckPredicate, 38, // 2216: check predicate 38
2287 OPC_Decode, 182, 110, 16, // 2218: decode to BEXTI using decoder 16
2288 // 2218: }
2289 24, 6, // 2222: case 0x18: {
2290 OPC_CheckPredicate, 43, // 2224: check predicate 43
2291 OPC_Decode, 143, 123, 16, // 2226: decode to RORI using decoder 16
2292 // 2226: }
2293 26, 0, // 2230: case 0x1a: {
2294 OPC_SwitchField, 20, 6, // 2232: switch Inst[25:20] {
2295 7, 6, // 2235: case 0x7: {
2296 OPC_CheckPredicate, 44, // 2237: check predicate 44
2297 OPC_Decode, 191, 110, 17, // 2239: decode to BREV8 using decoder 17
2298 // 2239: }
2299 24, 6, // 2243: case 0x18: {
2300 OPC_CheckPredicate, 45, // 2245: check predicate 45
2301 OPC_Decode, 136, 123, 17, // 2247: decode to REV8_RV32 using decoder 17
2302 // 2247: }
2303 31, 6, // 2251: case 0x1f: {
2304 OPC_CheckPredicate, 46, // 2253: check predicate 46
2305 OPC_Decode, 138, 123, 17, // 2255: decode to REV_RV32 using decoder 17
2306 // 2255: }
2307 48, 6, // 2259: case 0x30: {
2308 OPC_CheckPredicate, 47, // 2261: check predicate 47
2309 OPC_Decode, 135, 123, 17, // 2263: decode to REV16_RV64 using decoder 17
2310 // 2263: }
2311 56, 6, // 2267: case 0x38: {
2312 OPC_CheckPredicate, 48, // 2269: check predicate 48
2313 OPC_Decode, 137, 123, 17, // 2271: decode to REV8_RV64 using decoder 17
2314 // 2271: }
2315 63, 0, // 2275: case 0x3f: {
2316 OPC_CheckPredicate, 47, // 2277: check predicate 47
2317 OPC_Decode, 139, 123, 17, // 2279: decode to REV_RV64 using decoder 17
2318 // 2279: }
2319 // 2279: } // switch Inst[25:20]
2320 // 2279: }
2321 // 2279: } // switch Inst[31:26]
2322 // 2279: }
2323 6, 39, // 2283: case 0x6: {
2324 OPC_Scope, 33, // 2285: try {
2325 OPC_SwitchField, 20, 5, // 2287: switch Inst[24:20] {
2326 0, 8, // 2290: case 0x0: {
2327 OPC_CheckField, 7, 5, 0, // 2292: check Inst[11:7] == 0x0
2328 OPC_Decode, 190, 120, 19, // 2296: decode to PREFETCH_I using decoder 19
2329 // 2296: }
2330 1, 8, // 2300: case 0x1: {
2331 OPC_CheckField, 7, 5, 0, // 2302: check Inst[11:7] == 0x0
2332 OPC_Decode, 191, 120, 19, // 2306: decode to PREFETCH_R using decoder 19
2333 // 2306: }
2334 3, 0, // 2310: case 0x3: {
2335 OPC_CheckField, 7, 5, 0, // 2312: check Inst[11:7] == 0x0
2336 OPC_Decode, 192, 120, 19, // 2316: decode to PREFETCH_W using decoder 19
2337 // 2316: }
2338 // 2316: } // switch Inst[24:20]
2339 // 2316: } else try {
2340 OPC_Decode, 138, 118, 0, // 2320: decode to ORI using decoder 0
2341 // 2320: }
2342 // 2320: }
2343 7, 0, // 2324: case 0x7: {
2344 OPC_Decode, 172, 110, 0, // 2326: decode to ANDI using decoder 0
2345 // 2326: }
2346 // 2326: } // switch Inst[14:12]
2347 // 2326: }
2348 23, 4, // 2330: case 0x17: {
2349 OPC_Decode, 176, 110, 20, // 2332: decode to AUIPC using decoder 20
2350 // 2332: }
2351 27, 195, 35, // 2336: case 0x1b: {
2352 OPC_SwitchField, 12, 3, // 2339: switch Inst[14:12] {
2353 0, 6, // 2342: case 0x0: {
2354 OPC_CheckPredicate, 21, // 2344: check predicate 21
2355 OPC_Decode, 160, 107, 0, // 2346: decode to ADDIW using decoder 0
2356 // 2346: }
2357 1, 68, // 2350: case 0x1: {
2358 OPC_SwitchField, 26, 6, // 2352: switch Inst[31:26] {
2359 0, 10, // 2355: case 0x0: {
2360 OPC_CheckPredicate, 21, // 2357: check predicate 21
2361 OPC_CheckField, 25, 1, 0, // 2359: check Inst[25] == 0x0
2362 OPC_Decode, 142, 124, 21, // 2363: decode to SLLIW using decoder 21
2363 // 2363: }
2364 2, 6, // 2367: case 0x2: {
2365 OPC_CheckPredicate, 49, // 2369: check predicate 49
2366 OPC_Decode, 143, 124, 16, // 2371: decode to SLLI_UW using decoder 16
2367 // 2371: }
2368 24, 0, // 2375: case 0x18: {
2369 OPC_SwitchField, 20, 6, // 2377: switch Inst[25:20] {
2370 0, 6, // 2380: case 0x0: {
2371 OPC_CheckPredicate, 50, // 2382: check predicate 50
2372 OPC_Decode, 204, 110, 17, // 2384: decode to CLZW using decoder 17
2373 // 2384: }
2374 1, 6, // 2388: case 0x1: {
2375 OPC_CheckPredicate, 50, // 2390: check predicate 50
2376 OPC_Decode, 222, 110, 17, // 2392: decode to CTZW using decoder 17
2377 // 2392: }
2378 2, 6, // 2396: case 0x2: {
2379 OPC_CheckPredicate, 50, // 2398: check predicate 50
2380 OPC_Decode, 214, 110, 17, // 2400: decode to CPOPW using decoder 17
2381 // 2400: }
2382 3, 6, // 2404: case 0x3: {
2383 OPC_CheckPredicate, 47, // 2406: check predicate 47
2384 OPC_Decode, 202, 110, 17, // 2408: decode to CLSW using decoder 17
2385 // 2408: }
2386 7, 0, // 2412: case 0x7: {
2387 OPC_CheckPredicate, 47, // 2414: check predicate 47
2388 OPC_Decode, 156, 107, 17, // 2416: decode to ABSW using decoder 17
2389 // 2416: }
2390 // 2416: } // switch Inst[25:20]
2391 // 2416: }
2392 // 2416: } // switch Inst[31:26]
2393 // 2416: }
2394 2, 209, 10, // 2420: case 0x2: {
2395 OPC_SwitchField, 26, 6, // 2423: switch Inst[31:26] {
2396 0, 50, // 2426: case 0x0: {
2397 OPC_SwitchField, 7, 1, // 2428: switch Inst[7] {
2398 0, 23, // 2431: case 0x0: {
2399 OPC_SwitchField, 25, 1, // 2433: switch Inst[25] {
2400 0, 10, // 2436: case 0x0: {
2401 OPC_CheckPredicate, 46, // 2438: check predicate 46
2402 OPC_CheckField, 24, 1, 1, // 2440: check Inst[24] == 0x1
2403 OPC_Decode, 211, 121, 22, // 2444: decode to PWSLLI_B using decoder 22
2404 // 2444: }
2405 1, 0, // 2448: case 0x1: {
2406 OPC_CheckPredicate, 46, // 2450: check predicate 46
2407 OPC_Decode, 212, 121, 23, // 2452: decode to PWSLLI_H using decoder 23
2408 // 2452: }
2409 // 2452: } // switch Inst[25]
2410 // 2452: }
2411 1, 0, // 2456: case 0x1: {
2412 OPC_SwitchField, 25, 1, // 2458: switch Inst[25] {
2413 0, 6, // 2461: case 0x0: {
2414 OPC_CheckPredicate, 46, // 2463: check predicate 46
2415 OPC_Decode, 197, 121, 24, // 2465: decode to PWADD_H using decoder 24
2416 // 2465: }
2417 1, 0, // 2469: case 0x1: {
2418 OPC_CheckPredicate, 46, // 2471: check predicate 46
2419 OPC_Decode, 189, 131, 1, 24, // 2473: decode to WADD using decoder 24
2420 // 2473: }
2421 // 2473: } // switch Inst[25]
2422 // 2473: }
2423 // 2473: } // switch Inst[7]
2424 // 2473: }
2425 1, 33, // 2478: case 0x1: {
2426 OPC_SwitchField, 7, 1, // 2480: switch Inst[7] {
2427 0, 7, // 2483: case 0x0: {
2428 OPC_CheckPredicate, 46, // 2485: check predicate 46
2429 OPC_Decode, 205, 131, 1, 25, // 2487: decode to WSLLI using decoder 25
2430 // 2487: }
2431 1, 0, // 2492: case 0x1: {
2432 OPC_SwitchField, 25, 1, // 2494: switch Inst[25] {
2433 0, 6, // 2497: case 0x0: {
2434 OPC_CheckPredicate, 46, // 2499: check predicate 46
2435 OPC_Decode, 196, 121, 24, // 2501: decode to PWADD_B using decoder 24
2436 // 2501: }
2437 1, 0, // 2505: case 0x1: {
2438 OPC_CheckPredicate, 46, // 2507: check predicate 46
2439 OPC_Decode, 239, 118, 24, // 2509: decode to PM2WADD_H using decoder 24
2440 // 2509: }
2441 // 2509: } // switch Inst[25]
2442 // 2509: }
2443 // 2509: } // switch Inst[7]
2444 // 2509: }
2445 2, 46, // 2513: case 0x2: {
2446 OPC_SwitchField, 7, 1, // 2515: switch Inst[7] {
2447 0, 19, // 2518: case 0x0: {
2448 OPC_SwitchField, 25, 1, // 2520: switch Inst[25] {
2449 0, 6, // 2523: case 0x0: {
2450 OPC_CheckPredicate, 46, // 2525: check predicate 46
2451 OPC_Decode, 213, 121, 24, // 2527: decode to PWSLL_BS using decoder 24
2452 // 2527: }
2453 1, 0, // 2531: case 0x1: {
2454 OPC_CheckPredicate, 46, // 2533: check predicate 46
2455 OPC_Decode, 214, 121, 24, // 2535: decode to PWSLL_HS using decoder 24
2456 // 2535: }
2457 // 2535: } // switch Inst[25]
2458 // 2535: }
2459 1, 0, // 2539: case 0x1: {
2460 OPC_SwitchField, 25, 1, // 2541: switch Inst[25] {
2461 0, 6, // 2544: case 0x0: {
2462 OPC_CheckPredicate, 46, // 2546: check predicate 46
2463 OPC_Decode, 193, 121, 26, // 2548: decode to PWADDA_H using decoder 26
2464 // 2548: }
2465 1, 0, // 2552: case 0x1: {
2466 OPC_CheckPredicate, 46, // 2554: check predicate 46
2467 OPC_Decode, 190, 131, 1, 26, // 2556: decode to WADDA using decoder 26
2468 // 2556: }
2469 // 2556: } // switch Inst[25]
2470 // 2556: }
2471 // 2556: } // switch Inst[7]
2472 // 2556: }
2473 3, 37, // 2561: case 0x3: {
2474 OPC_SwitchField, 7, 1, // 2563: switch Inst[7] {
2475 0, 11, // 2566: case 0x0: {
2476 OPC_CheckPredicate, 46, // 2568: check predicate 46
2477 OPC_CheckField, 25, 1, 1, // 2570: check Inst[25] == 0x1
2478 OPC_Decode, 204, 131, 1, 24, // 2574: decode to WSLL using decoder 24
2479 // 2574: }
2480 1, 0, // 2579: case 0x1: {
2481 OPC_SwitchField, 25, 1, // 2581: switch Inst[25] {
2482 0, 6, // 2584: case 0x0: {
2483 OPC_CheckPredicate, 46, // 2586: check predicate 46
2484 OPC_Decode, 192, 121, 26, // 2588: decode to PWADDA_B using decoder 26
2485 // 2588: }
2486 1, 0, // 2592: case 0x1: {
2487 OPC_CheckPredicate, 46, // 2594: check predicate 46
2488 OPC_Decode, 235, 118, 26, // 2596: decode to PM2WADDA_H using decoder 26
2489 // 2596: }
2490 // 2596: } // switch Inst[25]
2491 // 2596: }
2492 // 2596: } // switch Inst[7]
2493 // 2596: }
2494 4, 28, // 2600: case 0x4: {
2495 OPC_SwitchField, 25, 1, // 2602: switch Inst[25] {
2496 0, 10, // 2605: case 0x0: {
2497 OPC_CheckPredicate, 46, // 2607: check predicate 46
2498 OPC_CheckField, 7, 1, 1, // 2609: check Inst[7] == 0x1
2499 OPC_Decode, 195, 121, 24, // 2613: decode to PWADDU_H using decoder 24
2500 // 2613: }
2501 1, 0, // 2617: case 0x1: {
2502 OPC_CheckPredicate, 46, // 2619: check predicate 46
2503 OPC_CheckField, 7, 1, 1, // 2621: check Inst[7] == 0x1
2504 OPC_Decode, 192, 131, 1, 24, // 2625: decode to WADDU using decoder 24
2505 // 2625: }
2506 // 2625: } // switch Inst[25]
2507 // 2625: }
2508 5, 27, // 2630: case 0x5: {
2509 OPC_SwitchField, 25, 1, // 2632: switch Inst[25] {
2510 0, 10, // 2635: case 0x0: {
2511 OPC_CheckPredicate, 46, // 2637: check predicate 46
2512 OPC_CheckField, 7, 1, 1, // 2639: check Inst[7] == 0x1
2513 OPC_Decode, 194, 121, 24, // 2643: decode to PWADDU_B using decoder 24
2514 // 2643: }
2515 1, 0, // 2647: case 0x1: {
2516 OPC_CheckPredicate, 46, // 2649: check predicate 46
2517 OPC_CheckField, 7, 1, 1, // 2651: check Inst[7] == 0x1
2518 OPC_Decode, 240, 118, 24, // 2655: decode to PM2WADD_HX using decoder 24
2519 // 2655: }
2520 // 2655: } // switch Inst[25]
2521 // 2655: }
2522 6, 28, // 2659: case 0x6: {
2523 OPC_SwitchField, 25, 1, // 2661: switch Inst[25] {
2524 0, 10, // 2664: case 0x0: {
2525 OPC_CheckPredicate, 46, // 2666: check predicate 46
2526 OPC_CheckField, 7, 1, 1, // 2668: check Inst[7] == 0x1
2527 OPC_Decode, 191, 121, 26, // 2672: decode to PWADDAU_H using decoder 26
2528 // 2672: }
2529 1, 0, // 2676: case 0x1: {
2530 OPC_CheckPredicate, 46, // 2678: check predicate 46
2531 OPC_CheckField, 7, 1, 1, // 2680: check Inst[7] == 0x1
2532 OPC_Decode, 191, 131, 1, 26, // 2684: decode to WADDAU using decoder 26
2533 // 2684: }
2534 // 2684: } // switch Inst[25]
2535 // 2684: }
2536 7, 27, // 2689: case 0x7: {
2537 OPC_SwitchField, 25, 1, // 2691: switch Inst[25] {
2538 0, 10, // 2694: case 0x0: {
2539 OPC_CheckPredicate, 46, // 2696: check predicate 46
2540 OPC_CheckField, 7, 1, 1, // 2698: check Inst[7] == 0x1
2541 OPC_Decode, 190, 121, 26, // 2702: decode to PWADDAU_B using decoder 26
2542 // 2702: }
2543 1, 0, // 2706: case 0x1: {
2544 OPC_CheckPredicate, 46, // 2708: check predicate 46
2545 OPC_CheckField, 7, 1, 1, // 2710: check Inst[7] == 0x1
2546 OPC_Decode, 236, 118, 26, // 2714: decode to PM2WADDA_HX using decoder 26
2547 // 2714: }
2548 // 2714: } // switch Inst[25]
2549 // 2714: }
2550 8, 28, // 2718: case 0x8: {
2551 OPC_SwitchField, 25, 1, // 2720: switch Inst[25] {
2552 0, 10, // 2723: case 0x0: {
2553 OPC_CheckPredicate, 46, // 2725: check predicate 46
2554 OPC_CheckField, 7, 1, 1, // 2727: check Inst[7] == 0x1
2555 OPC_Decode, 206, 121, 24, // 2731: decode to PWMUL_H using decoder 24
2556 // 2731: }
2557 1, 0, // 2735: case 0x1: {
2558 OPC_CheckPredicate, 46, // 2737: check predicate 46
2559 OPC_CheckField, 7, 1, 1, // 2739: check Inst[7] == 0x1
2560 OPC_Decode, 197, 131, 1, 24, // 2743: decode to WMUL using decoder 24
2561 // 2743: }
2562 // 2743: } // switch Inst[25]
2563 // 2743: }
2564 9, 27, // 2748: case 0x9: {
2565 OPC_SwitchField, 25, 1, // 2750: switch Inst[25] {
2566 0, 10, // 2753: case 0x0: {
2567 OPC_CheckPredicate, 46, // 2755: check predicate 46
2568 OPC_CheckField, 7, 1, 1, // 2757: check Inst[7] == 0x1
2569 OPC_Decode, 205, 121, 24, // 2761: decode to PWMUL_B using decoder 24
2570 // 2761: }
2571 1, 0, // 2765: case 0x1: {
2572 OPC_CheckPredicate, 46, // 2767: check predicate 46
2573 OPC_CheckField, 7, 1, 1, // 2769: check Inst[7] == 0x1
2574 OPC_Decode, 238, 118, 24, // 2773: decode to PM2WADDU_H using decoder 24
2575 // 2773: }
2576 // 2773: } // switch Inst[25]
2577 // 2773: }
2578 10, 28, // 2777: case 0xa: {
2579 OPC_SwitchField, 25, 1, // 2779: switch Inst[25] {
2580 0, 10, // 2782: case 0x0: {
2581 OPC_CheckPredicate, 46, // 2784: check predicate 46
2582 OPC_CheckField, 7, 1, 1, // 2786: check Inst[7] == 0x1
2583 OPC_Decode, 200, 121, 26, // 2790: decode to PWMACC_H using decoder 26
2584 // 2790: }
2585 1, 0, // 2794: case 0x1: {
2586 OPC_CheckPredicate, 46, // 2796: check predicate 46
2587 OPC_CheckField, 7, 1, 1, // 2798: check Inst[7] == 0x1
2588 OPC_Decode, 194, 131, 1, 26, // 2802: decode to WMACC using decoder 26
2589 // 2802: }
2590 // 2802: } // switch Inst[25]
2591 // 2802: }
2592 11, 14, // 2807: case 0xb: {
2593 OPC_CheckPredicate, 46, // 2809: check predicate 46
2594 OPC_CheckField, 25, 1, 1, // 2811: check Inst[25] == 0x1
2595 OPC_CheckField, 7, 1, 1, // 2815: check Inst[7] == 0x1
2596 OPC_Decode, 234, 118, 26, // 2819: decode to PM2WADDAU_H using decoder 26
2597 // 2819: }
2598 12, 37, // 2823: case 0xc: {
2599 OPC_SwitchField, 7, 1, // 2825: switch Inst[7] {
2600 0, 10, // 2828: case 0x0: {
2601 OPC_CheckPredicate, 46, // 2830: check predicate 46
2602 OPC_CheckField, 25, 1, 0, // 2832: check Inst[25] == 0x0
2603 OPC_Decode, 201, 118, 27, // 2836: decode to PLI_DH using decoder 27
2604 // 2836: }
2605 1, 0, // 2840: case 0x1: {
2606 OPC_SwitchField, 25, 1, // 2842: switch Inst[25] {
2607 0, 6, // 2845: case 0x0: {
2608 OPC_CheckPredicate, 46, // 2847: check predicate 46
2609 OPC_Decode, 204, 121, 24, // 2849: decode to PWMULU_H using decoder 24
2610 // 2849: }
2611 1, 0, // 2853: case 0x1: {
2612 OPC_CheckPredicate, 46, // 2855: check predicate 46
2613 OPC_Decode, 199, 131, 1, 24, // 2857: decode to WMULU using decoder 24
2614 // 2857: }
2615 // 2857: } // switch Inst[25]
2616 // 2857: }
2617 // 2857: } // switch Inst[7]
2618 // 2857: }
2619 13, 31, // 2862: case 0xd: {
2620 OPC_SwitchField, 7, 1, // 2864: switch Inst[7] {
2621 0, 14, // 2867: case 0x0: {
2622 OPC_CheckPredicate, 46, // 2869: check predicate 46
2623 OPC_CheckField, 24, 2, 0, // 2871: check Inst[25:24] == 0x0
2624 OPC_CheckField, 15, 1, 0, // 2875: check Inst[15] == 0x0
2625 OPC_Decode, 200, 118, 28, // 2879: decode to PLI_DB using decoder 28
2626 // 2879: }
2627 1, 0, // 2883: case 0x1: {
2628 OPC_CheckPredicate, 46, // 2885: check predicate 46
2629 OPC_CheckField, 25, 1, 0, // 2887: check Inst[25] == 0x0
2630 OPC_Decode, 203, 121, 24, // 2891: decode to PWMULU_B using decoder 24
2631 // 2891: }
2632 // 2891: } // switch Inst[7]
2633 // 2891: }
2634 14, 28, // 2895: case 0xe: {
2635 OPC_SwitchField, 25, 1, // 2897: switch Inst[25] {
2636 0, 10, // 2900: case 0x0: {
2637 OPC_CheckPredicate, 46, // 2902: check predicate 46
2638 OPC_CheckField, 7, 1, 1, // 2904: check Inst[7] == 0x1
2639 OPC_Decode, 199, 121, 26, // 2908: decode to PWMACCU_H using decoder 26
2640 // 2908: }
2641 1, 0, // 2912: case 0x1: {
2642 OPC_CheckPredicate, 46, // 2914: check predicate 46
2643 OPC_CheckField, 7, 1, 1, // 2916: check Inst[7] == 0x1
2644 OPC_Decode, 196, 131, 1, 26, // 2920: decode to WMACCU using decoder 26
2645 // 2920: }
2646 // 2920: } // switch Inst[25]
2647 // 2920: }
2648 16, 50, // 2925: case 0x10: {
2649 OPC_SwitchField, 7, 1, // 2927: switch Inst[7] {
2650 0, 23, // 2930: case 0x0: {
2651 OPC_SwitchField, 25, 1, // 2932: switch Inst[25] {
2652 0, 10, // 2935: case 0x0: {
2653 OPC_CheckPredicate, 46, // 2937: check predicate 46
2654 OPC_CheckField, 24, 1, 1, // 2939: check Inst[24] == 0x1
2655 OPC_Decode, 207, 121, 22, // 2943: decode to PWSLAI_B using decoder 22
2656 // 2943: }
2657 1, 0, // 2947: case 0x1: {
2658 OPC_CheckPredicate, 46, // 2949: check predicate 46
2659 OPC_Decode, 208, 121, 23, // 2951: decode to PWSLAI_H using decoder 23
2660 // 2951: }
2661 // 2951: } // switch Inst[25]
2662 // 2951: }
2663 1, 0, // 2955: case 0x1: {
2664 OPC_SwitchField, 25, 1, // 2957: switch Inst[25] {
2665 0, 6, // 2960: case 0x0: {
2666 OPC_CheckPredicate, 46, // 2962: check predicate 46
2667 OPC_Decode, 222, 121, 24, // 2964: decode to PWSUB_H using decoder 24
2668 // 2964: }
2669 1, 0, // 2968: case 0x1: {
2670 OPC_CheckPredicate, 46, // 2970: check predicate 46
2671 OPC_Decode, 206, 131, 1, 24, // 2972: decode to WSUB using decoder 24
2672 // 2972: }
2673 // 2972: } // switch Inst[25]
2674 // 2972: }
2675 // 2972: } // switch Inst[7]
2676 // 2972: }
2677 17, 33, // 2977: case 0x11: {
2678 OPC_SwitchField, 7, 1, // 2979: switch Inst[7] {
2679 0, 7, // 2982: case 0x0: {
2680 OPC_CheckPredicate, 46, // 2984: check predicate 46
2681 OPC_Decode, 203, 131, 1, 25, // 2986: decode to WSLAI using decoder 25
2682 // 2986: }
2683 1, 0, // 2991: case 0x1: {
2684 OPC_SwitchField, 25, 1, // 2993: switch Inst[25] {
2685 0, 6, // 2996: case 0x0: {
2686 OPC_CheckPredicate, 46, // 2998: check predicate 46
2687 OPC_Decode, 221, 121, 24, // 3000: decode to PWSUB_B using decoder 24
2688 // 3000: }
2689 1, 0, // 3004: case 0x1: {
2690 OPC_CheckPredicate, 46, // 3006: check predicate 46
2691 OPC_Decode, 243, 118, 24, // 3008: decode to PM2WSUB_H using decoder 24
2692 // 3008: }
2693 // 3008: } // switch Inst[25]
2694 // 3008: }
2695 // 3008: } // switch Inst[7]
2696 // 3008: }
2697 18, 46, // 3012: case 0x12: {
2698 OPC_SwitchField, 7, 1, // 3014: switch Inst[7] {
2699 0, 19, // 3017: case 0x0: {
2700 OPC_SwitchField, 25, 1, // 3019: switch Inst[25] {
2701 0, 6, // 3022: case 0x0: {
2702 OPC_CheckPredicate, 46, // 3024: check predicate 46
2703 OPC_Decode, 209, 121, 24, // 3026: decode to PWSLA_BS using decoder 24
2704 // 3026: }
2705 1, 0, // 3030: case 0x1: {
2706 OPC_CheckPredicate, 46, // 3032: check predicate 46
2707 OPC_Decode, 210, 121, 24, // 3034: decode to PWSLA_HS using decoder 24
2708 // 3034: }
2709 // 3034: } // switch Inst[25]
2710 // 3034: }
2711 1, 0, // 3038: case 0x1: {
2712 OPC_SwitchField, 25, 1, // 3040: switch Inst[25] {
2713 0, 6, // 3043: case 0x0: {
2714 OPC_CheckPredicate, 46, // 3045: check predicate 46
2715 OPC_Decode, 218, 121, 26, // 3047: decode to PWSUBA_H using decoder 26
2716 // 3047: }
2717 1, 0, // 3051: case 0x1: {
2718 OPC_CheckPredicate, 46, // 3053: check predicate 46
2719 OPC_Decode, 207, 131, 1, 26, // 3055: decode to WSUBA using decoder 26
2720 // 3055: }
2721 // 3055: } // switch Inst[25]
2722 // 3055: }
2723 // 3055: } // switch Inst[7]
2724 // 3055: }
2725 19, 37, // 3060: case 0x13: {
2726 OPC_SwitchField, 7, 1, // 3062: switch Inst[7] {
2727 0, 11, // 3065: case 0x0: {
2728 OPC_CheckPredicate, 46, // 3067: check predicate 46
2729 OPC_CheckField, 25, 1, 1, // 3069: check Inst[25] == 0x1
2730 OPC_Decode, 202, 131, 1, 24, // 3073: decode to WSLA using decoder 24
2731 // 3073: }
2732 1, 0, // 3078: case 0x1: {
2733 OPC_SwitchField, 25, 1, // 3080: switch Inst[25] {
2734 0, 6, // 3083: case 0x0: {
2735 OPC_CheckPredicate, 46, // 3085: check predicate 46
2736 OPC_Decode, 217, 121, 26, // 3087: decode to PWSUBA_B using decoder 26
2737 // 3087: }
2738 1, 0, // 3091: case 0x1: {
2739 OPC_CheckPredicate, 46, // 3093: check predicate 46
2740 OPC_Decode, 241, 118, 26, // 3095: decode to PM2WSUBA_H using decoder 26
2741 // 3095: }
2742 // 3095: } // switch Inst[25]
2743 // 3095: }
2744 // 3095: } // switch Inst[7]
2745 // 3095: }
2746 20, 28, // 3099: case 0x14: {
2747 OPC_SwitchField, 25, 1, // 3101: switch Inst[25] {
2748 0, 10, // 3104: case 0x0: {
2749 OPC_CheckPredicate, 46, // 3106: check predicate 46
2750 OPC_CheckField, 7, 1, 1, // 3108: check Inst[7] == 0x1
2751 OPC_Decode, 220, 121, 24, // 3112: decode to PWSUBU_H using decoder 24
2752 // 3112: }
2753 1, 0, // 3116: case 0x1: {
2754 OPC_CheckPredicate, 46, // 3118: check predicate 46
2755 OPC_CheckField, 7, 1, 1, // 3120: check Inst[7] == 0x1
2756 OPC_Decode, 209, 131, 1, 24, // 3124: decode to WSUBU using decoder 24
2757 // 3124: }
2758 // 3124: } // switch Inst[25]
2759 // 3124: }
2760 21, 27, // 3129: case 0x15: {
2761 OPC_SwitchField, 25, 1, // 3131: switch Inst[25] {
2762 0, 10, // 3134: case 0x0: {
2763 OPC_CheckPredicate, 46, // 3136: check predicate 46
2764 OPC_CheckField, 7, 1, 1, // 3138: check Inst[7] == 0x1
2765 OPC_Decode, 219, 121, 24, // 3142: decode to PWSUBU_B using decoder 24
2766 // 3142: }
2767 1, 0, // 3146: case 0x1: {
2768 OPC_CheckPredicate, 46, // 3148: check predicate 46
2769 OPC_CheckField, 7, 1, 1, // 3150: check Inst[7] == 0x1
2770 OPC_Decode, 244, 118, 24, // 3154: decode to PM2WSUB_HX using decoder 24
2771 // 3154: }
2772 // 3154: } // switch Inst[25]
2773 // 3154: }
2774 22, 28, // 3158: case 0x16: {
2775 OPC_SwitchField, 25, 1, // 3160: switch Inst[25] {
2776 0, 10, // 3163: case 0x0: {
2777 OPC_CheckPredicate, 46, // 3165: check predicate 46
2778 OPC_CheckField, 7, 1, 1, // 3167: check Inst[7] == 0x1
2779 OPC_Decode, 216, 121, 26, // 3171: decode to PWSUBAU_H using decoder 26
2780 // 3171: }
2781 1, 0, // 3175: case 0x1: {
2782 OPC_CheckPredicate, 46, // 3177: check predicate 46
2783 OPC_CheckField, 7, 1, 1, // 3179: check Inst[7] == 0x1
2784 OPC_Decode, 208, 131, 1, 26, // 3183: decode to WSUBAU using decoder 26
2785 // 3183: }
2786 // 3183: } // switch Inst[25]
2787 // 3183: }
2788 23, 27, // 3188: case 0x17: {
2789 OPC_SwitchField, 25, 1, // 3190: switch Inst[25] {
2790 0, 10, // 3193: case 0x0: {
2791 OPC_CheckPredicate, 46, // 3195: check predicate 46
2792 OPC_CheckField, 7, 1, 1, // 3197: check Inst[7] == 0x1
2793 OPC_Decode, 215, 121, 26, // 3201: decode to PWSUBAU_B using decoder 26
2794 // 3201: }
2795 1, 0, // 3205: case 0x1: {
2796 OPC_CheckPredicate, 46, // 3207: check predicate 46
2797 OPC_CheckField, 7, 1, 1, // 3209: check Inst[7] == 0x1
2798 OPC_Decode, 242, 118, 26, // 3213: decode to PM2WSUBA_HX using decoder 26
2799 // 3213: }
2800 // 3213: } // switch Inst[25]
2801 // 3213: }
2802 24, 28, // 3217: case 0x18: {
2803 OPC_SwitchField, 25, 1, // 3219: switch Inst[25] {
2804 0, 10, // 3222: case 0x0: {
2805 OPC_CheckPredicate, 46, // 3224: check predicate 46
2806 OPC_CheckField, 7, 1, 1, // 3226: check Inst[7] == 0x1
2807 OPC_Decode, 202, 121, 24, // 3230: decode to PWMULSU_H using decoder 24
2808 // 3230: }
2809 1, 0, // 3234: case 0x1: {
2810 OPC_CheckPredicate, 46, // 3236: check predicate 46
2811 OPC_CheckField, 7, 1, 1, // 3238: check Inst[7] == 0x1
2812 OPC_Decode, 198, 131, 1, 24, // 3242: decode to WMULSU using decoder 24
2813 // 3242: }
2814 // 3242: } // switch Inst[25]
2815 // 3242: }
2816 25, 27, // 3247: case 0x19: {
2817 OPC_SwitchField, 25, 1, // 3249: switch Inst[25] {
2818 0, 10, // 3252: case 0x0: {
2819 OPC_CheckPredicate, 46, // 3254: check predicate 46
2820 OPC_CheckField, 7, 1, 1, // 3256: check Inst[7] == 0x1
2821 OPC_Decode, 201, 121, 24, // 3260: decode to PWMULSU_B using decoder 24
2822 // 3260: }
2823 1, 0, // 3264: case 0x1: {
2824 OPC_CheckPredicate, 46, // 3266: check predicate 46
2825 OPC_CheckField, 7, 1, 1, // 3268: check Inst[7] == 0x1
2826 OPC_Decode, 237, 118, 24, // 3272: decode to PM2WADDSU_H using decoder 24
2827 // 3272: }
2828 // 3272: } // switch Inst[25]
2829 // 3272: }
2830 26, 28, // 3276: case 0x1a: {
2831 OPC_SwitchField, 25, 1, // 3278: switch Inst[25] {
2832 0, 10, // 3281: case 0x0: {
2833 OPC_CheckPredicate, 46, // 3283: check predicate 46
2834 OPC_CheckField, 7, 1, 1, // 3285: check Inst[7] == 0x1
2835 OPC_Decode, 198, 121, 26, // 3289: decode to PWMACCSU_H using decoder 26
2836 // 3289: }
2837 1, 0, // 3293: case 0x1: {
2838 OPC_CheckPredicate, 46, // 3295: check predicate 46
2839 OPC_CheckField, 7, 1, 1, // 3297: check Inst[7] == 0x1
2840 OPC_Decode, 195, 131, 1, 26, // 3301: decode to WMACCSU using decoder 26
2841 // 3301: }
2842 // 3301: } // switch Inst[25]
2843 // 3301: }
2844 27, 14, // 3306: case 0x1b: {
2845 OPC_CheckPredicate, 46, // 3308: check predicate 46
2846 OPC_CheckField, 25, 1, 1, // 3310: check Inst[25] == 0x1
2847 OPC_CheckField, 7, 1, 1, // 3314: check Inst[7] == 0x1
2848 OPC_Decode, 233, 118, 26, // 3318: decode to PM2WADDASU_H using decoder 26
2849 // 3318: }
2850 28, 14, // 3322: case 0x1c: {
2851 OPC_CheckPredicate, 46, // 3324: check predicate 46
2852 OPC_CheckField, 25, 1, 0, // 3326: check Inst[25] == 0x0
2853 OPC_CheckField, 7, 1, 0, // 3330: check Inst[7] == 0x0
2854 OPC_Decode, 204, 118, 29, // 3334: decode to PLUI_DH using decoder 29
2855 // 3334: }
2856 30, 47, // 3338: case 0x1e: {
2857 OPC_SwitchField, 7, 1, // 3340: switch Inst[7] {
2858 0, 21, // 3343: case 0x0: {
2859 OPC_SwitchField, 25, 1, // 3345: switch Inst[25] {
2860 0, 7, // 3348: case 0x0: {
2861 OPC_CheckPredicate, 46, // 3350: check predicate 46
2862 OPC_Decode, 211, 131, 1, 24, // 3352: decode to WZIP8P using decoder 24
2863 // 3352: }
2864 1, 0, // 3357: case 0x1: {
2865 OPC_CheckPredicate, 46, // 3359: check predicate 46
2866 OPC_Decode, 210, 131, 1, 24, // 3361: decode to WZIP16P using decoder 24
2867 // 3361: }
2868 // 3361: } // switch Inst[25]
2869 // 3361: }
2870 1, 0, // 3366: case 0x1: {
2871 OPC_SwitchField, 25, 1, // 3368: switch Inst[25] {
2872 0, 6, // 3371: case 0x0: {
2873 OPC_CheckPredicate, 46, // 3373: check predicate 46
2874 OPC_Decode, 196, 119, 26, // 3375: decode to PMQWACC_H using decoder 26
2875 // 3375: }
2876 1, 0, // 3379: case 0x1: {
2877 OPC_CheckPredicate, 46, // 3381: check predicate 46
2878 OPC_Decode, 166, 117, 26, // 3383: decode to MQWACC using decoder 26
2879 // 3383: }
2880 // 3383: } // switch Inst[25]
2881 // 3383: }
2882 // 3383: } // switch Inst[7]
2883 // 3383: }
2884 31, 27, // 3387: case 0x1f: {
2885 OPC_SwitchField, 25, 1, // 3389: switch Inst[25] {
2886 0, 10, // 3392: case 0x0: {
2887 OPC_CheckPredicate, 46, // 3394: check predicate 46
2888 OPC_CheckField, 7, 1, 1, // 3396: check Inst[7] == 0x1
2889 OPC_Decode, 195, 119, 26, // 3400: decode to PMQRWACC_H using decoder 26
2890 // 3400: }
2891 1, 0, // 3404: case 0x1: {
2892 OPC_CheckPredicate, 46, // 3406: check predicate 46
2893 OPC_CheckField, 7, 1, 1, // 3408: check Inst[7] == 0x1
2894 OPC_Decode, 165, 117, 26, // 3412: decode to MQRWACC using decoder 26
2895 // 3412: }
2896 // 3412: } // switch Inst[25]
2897 // 3412: }
2898 32, 36, // 3416: case 0x20: {
2899 OPC_SwitchField, 25, 1, // 3418: switch Inst[25] {
2900 0, 23, // 3421: case 0x0: {
2901 OPC_SwitchField, 24, 1, // 3423: switch Inst[24] {
2902 0, 10, // 3426: case 0x0: {
2903 OPC_CheckPredicate, 42, // 3428: check predicate 42
2904 OPC_CheckField, 23, 1, 1, // 3430: check Inst[23] == 0x1
2905 OPC_Decode, 229, 120, 30, // 3434: decode to PSLLI_B using decoder 30
2906 // 3434: }
2907 1, 0, // 3438: case 0x1: {
2908 OPC_CheckPredicate, 42, // 3440: check predicate 42
2909 OPC_Decode, 233, 120, 18, // 3442: decode to PSLLI_H using decoder 18
2910 // 3442: }
2911 // 3442: } // switch Inst[24]
2912 // 3442: }
2913 1, 0, // 3446: case 0x1: {
2914 OPC_CheckPredicate, 47, // 3448: check predicate 47
2915 OPC_Decode, 234, 120, 21, // 3450: decode to PSLLI_W using decoder 21
2916 // 3450: }
2917 // 3450: } // switch Inst[25]
2918 // 3450: }
2919 34, 19, // 3454: case 0x22: {
2920 OPC_SwitchField, 25, 1, // 3456: switch Inst[25] {
2921 0, 6, // 3459: case 0x0: {
2922 OPC_CheckPredicate, 42, // 3461: check predicate 42
2923 OPC_Decode, 239, 120, 31, // 3463: decode to PSLL_HS using decoder 31
2924 // 3463: }
2925 1, 0, // 3467: case 0x1: {
2926 OPC_CheckPredicate, 47, // 3469: check predicate 47
2927 OPC_Decode, 240, 120, 31, // 3471: decode to PSLL_WS using decoder 31
2928 // 3471: }
2929 // 3471: } // switch Inst[25]
2930 // 3471: }
2931 35, 10, // 3475: case 0x23: {
2932 OPC_CheckPredicate, 42, // 3477: check predicate 42
2933 OPC_CheckField, 25, 1, 0, // 3479: check Inst[25] == 0x0
2934 OPC_Decode, 235, 120, 31, // 3483: decode to PSLL_BS using decoder 31
2935 // 3483: }
2936 38, 19, // 3487: case 0x26: {
2937 OPC_SwitchField, 25, 1, // 3489: switch Inst[25] {
2938 0, 6, // 3492: case 0x0: {
2939 OPC_CheckPredicate, 42, // 3494: check predicate 42
2940 OPC_Decode, 178, 118, 31, // 3496: decode to PADD_HS using decoder 31
2941 // 3496: }
2942 1, 0, // 3500: case 0x1: {
2943 OPC_CheckPredicate, 47, // 3502: check predicate 47
2944 OPC_Decode, 180, 118, 31, // 3504: decode to PADD_WS using decoder 31
2945 // 3504: }
2946 // 3504: } // switch Inst[25]
2947 // 3504: }
2948 39, 10, // 3508: case 0x27: {
2949 OPC_CheckPredicate, 42, // 3510: check predicate 42
2950 OPC_CheckField, 25, 1, 0, // 3512: check Inst[25] == 0x0
2951 OPC_Decode, 170, 118, 31, // 3516: decode to PADD_BS using decoder 31
2952 // 3516: }
2953 42, 19, // 3520: case 0x2a: {
2954 OPC_SwitchField, 25, 1, // 3522: switch Inst[25] {
2955 0, 6, // 3525: case 0x0: {
2956 OPC_CheckPredicate, 42, // 3527: check predicate 42
2957 OPC_Decode, 162, 121, 31, // 3529: decode to PSSHL_HS using decoder 31
2958 // 3529: }
2959 1, 0, // 3533: case 0x1: {
2960 OPC_CheckPredicate, 47, // 3535: check predicate 47
2961 OPC_Decode, 163, 121, 31, // 3537: decode to PSSHL_WS using decoder 31
2962 // 3537: }
2963 // 3537: } // switch Inst[25]
2964 // 3537: }
2965 43, 10, // 3541: case 0x2b: {
2966 OPC_CheckPredicate, 47, // 3543: check predicate 47
2967 OPC_CheckField, 25, 1, 1, // 3545: check Inst[25] == 0x1
2968 OPC_Decode, 134, 124, 31, // 3549: decode to SHL using decoder 31
2969 // 3549: }
2970 44, 19, // 3553: case 0x2c: {
2971 OPC_SwitchField, 25, 1, // 3555: switch Inst[25] {
2972 0, 6, // 3558: case 0x0: {
2973 OPC_CheckPredicate, 42, // 3560: check predicate 42
2974 OPC_Decode, 202, 118, 32, // 3562: decode to PLI_H using decoder 32
2975 // 3562: }
2976 1, 0, // 3566: case 0x1: {
2977 OPC_CheckPredicate, 47, // 3568: check predicate 47
2978 OPC_Decode, 203, 118, 32, // 3570: decode to PLI_W using decoder 32
2979 // 3570: }
2980 // 3570: } // switch Inst[25]
2981 // 3570: }
2982 45, 14, // 3574: case 0x2d: {
2983 OPC_CheckPredicate, 42, // 3576: check predicate 42
2984 OPC_CheckField, 24, 2, 0, // 3578: check Inst[25:24] == 0x0
2985 OPC_CheckField, 15, 1, 0, // 3582: check Inst[15] == 0x0
2986 OPC_Decode, 199, 118, 33, // 3586: decode to PLI_B using decoder 33
2987 // 3586: }
2988 46, 19, // 3590: case 0x2e: {
2989 OPC_SwitchField, 25, 1, // 3592: switch Inst[25] {
2990 0, 6, // 3595: case 0x0: {
2991 OPC_CheckPredicate, 42, // 3597: check predicate 42
2992 OPC_Decode, 158, 121, 31, // 3599: decode to PSSHLR_HS using decoder 31
2993 // 3599: }
2994 1, 0, // 3603: case 0x1: {
2995 OPC_CheckPredicate, 47, // 3605: check predicate 47
2996 OPC_Decode, 159, 121, 31, // 3607: decode to PSSHLR_WS using decoder 31
2997 // 3607: }
2998 // 3607: } // switch Inst[25]
2999 // 3607: }
3000 47, 10, // 3611: case 0x2f: {
3001 OPC_CheckPredicate, 47, // 3613: check predicate 47
3002 OPC_CheckField, 25, 1, 1, // 3615: check Inst[25] == 0x1
3003 OPC_Decode, 135, 124, 31, // 3619: decode to SHLR using decoder 31
3004 // 3619: }
3005 52, 23, // 3623: case 0x34: {
3006 OPC_SwitchField, 25, 1, // 3625: switch Inst[25] {
3007 0, 10, // 3628: case 0x0: {
3008 OPC_CheckPredicate, 42, // 3630: check predicate 42
3009 OPC_CheckField, 24, 1, 1, // 3632: check Inst[24] == 0x1
3010 OPC_Decode, 166, 121, 18, // 3636: decode to PSSLAI_H using decoder 18
3011 // 3636: }
3012 1, 0, // 3640: case 0x1: {
3013 OPC_CheckPredicate, 47, // 3642: check predicate 47
3014 OPC_Decode, 167, 121, 21, // 3644: decode to PSSLAI_W using decoder 21
3015 // 3644: }
3016 // 3644: } // switch Inst[25]
3017 // 3644: }
3018 56, 35, // 3648: case 0x38: {
3019 OPC_SwitchField, 20, 6, // 3650: switch Inst[25:20] {
3020 4, 6, // 3653: case 0x4: {
3021 OPC_CheckPredicate, 42, // 3655: check predicate 42
3022 OPC_Decode, 222, 120, 17, // 3657: decode to PSEXT_H_B using decoder 17
3023 // 3657: }
3024 7, 6, // 3661: case 0x7: {
3025 OPC_CheckPredicate, 42, // 3663: check predicate 42
3026 OPC_Decode, 196, 120, 17, // 3665: decode to PSABS_H using decoder 17
3027 // 3665: }
3028 36, 6, // 3669: case 0x24: {
3029 OPC_CheckPredicate, 47, // 3671: check predicate 47
3030 OPC_Decode, 223, 120, 17, // 3673: decode to PSEXT_W_B using decoder 17
3031 // 3673: }
3032 37, 0, // 3677: case 0x25: {
3033 OPC_CheckPredicate, 47, // 3679: check predicate 47
3034 OPC_Decode, 224, 120, 17, // 3681: decode to PSEXT_W_H using decoder 17
3035 // 3681: }
3036 // 3681: } // switch Inst[25:20]
3037 // 3681: }
3038 57, 10, // 3685: case 0x39: {
3039 OPC_CheckPredicate, 42, // 3687: check predicate 42
3040 OPC_CheckField, 20, 6, 7, // 3689: check Inst[25:20] == 0x7
3041 OPC_Decode, 193, 120, 17, // 3693: decode to PSABS_B using decoder 17
3042 // 3693: }
3043 58, 19, // 3697: case 0x3a: {
3044 OPC_SwitchField, 25, 1, // 3699: switch Inst[25] {
3045 0, 6, // 3702: case 0x0: {
3046 OPC_CheckPredicate, 42, // 3704: check predicate 42
3047 OPC_Decode, 154, 121, 31, // 3706: decode to PSSHA_HS using decoder 31
3048 // 3706: }
3049 1, 0, // 3710: case 0x1: {
3050 OPC_CheckPredicate, 47, // 3712: check predicate 47
3051 OPC_Decode, 155, 121, 31, // 3714: decode to PSSHA_WS using decoder 31
3052 // 3714: }
3053 // 3714: } // switch Inst[25]
3054 // 3714: }
3055 59, 10, // 3718: case 0x3b: {
3056 OPC_CheckPredicate, 47, // 3720: check predicate 47
3057 OPC_CheckField, 25, 1, 1, // 3722: check Inst[25] == 0x1
3058 OPC_Decode, 246, 123, 31, // 3726: decode to SHA using decoder 31
3059 // 3726: }
3060 60, 19, // 3730: case 0x3c: {
3061 OPC_SwitchField, 25, 1, // 3732: switch Inst[25] {
3062 0, 6, // 3735: case 0x0: {
3063 OPC_CheckPredicate, 42, // 3737: check predicate 42
3064 OPC_Decode, 205, 118, 34, // 3739: decode to PLUI_H using decoder 34
3065 // 3739: }
3066 1, 0, // 3743: case 0x1: {
3067 OPC_CheckPredicate, 47, // 3745: check predicate 47
3068 OPC_Decode, 206, 118, 34, // 3747: decode to PLUI_W using decoder 34
3069 // 3747: }
3070 // 3747: } // switch Inst[25]
3071 // 3747: }
3072 62, 19, // 3751: case 0x3e: {
3073 OPC_SwitchField, 25, 1, // 3753: switch Inst[25] {
3074 0, 6, // 3756: case 0x0: {
3075 OPC_CheckPredicate, 42, // 3758: check predicate 42
3076 OPC_Decode, 150, 121, 31, // 3760: decode to PSSHAR_HS using decoder 31
3077 // 3760: }
3078 1, 0, // 3764: case 0x1: {
3079 OPC_CheckPredicate, 47, // 3766: check predicate 47
3080 OPC_Decode, 151, 121, 31, // 3768: decode to PSSHAR_WS using decoder 31
3081 // 3768: }
3082 // 3768: } // switch Inst[25]
3083 // 3768: }
3084 63, 0, // 3772: case 0x3f: {
3085 OPC_CheckPredicate, 47, // 3774: check predicate 47
3086 OPC_CheckField, 25, 1, 1, // 3776: check Inst[25] == 0x1
3087 OPC_Decode, 133, 124, 31, // 3780: decode to SHAR using decoder 31
3088 // 3780: }
3089 // 3780: } // switch Inst[31:26]
3090 // 3780: }
3091 4, 226, 7, // 3784: case 0x4: {
3092 OPC_SwitchField, 26, 6, // 3787: switch Inst[31:26] {
3093 0, 31, // 3790: case 0x0: {
3094 OPC_SwitchField, 25, 1, // 3792: switch Inst[25] {
3095 0, 14, // 3795: case 0x0: {
3096 OPC_CheckPredicate, 46, // 3797: check predicate 46
3097 OPC_CheckField, 24, 1, 1, // 3799: check Inst[24] == 0x1
3098 OPC_CheckField, 15, 1, 1, // 3803: check Inst[15] == 0x1
3099 OPC_Decode, 157, 120, 35, // 3807: decode to PNSRLI_B using decoder 35
3100 // 3807: }
3101 1, 0, // 3811: case 0x1: {
3102 OPC_CheckPredicate, 46, // 3813: check predicate 46
3103 OPC_CheckField, 15, 1, 1, // 3815: check Inst[15] == 0x1
3104 OPC_Decode, 158, 120, 36, // 3819: decode to PNSRLI_H using decoder 36
3105 // 3819: }
3106 // 3819: } // switch Inst[25]
3107 // 3819: }
3108 1, 10, // 3823: case 0x1: {
3109 OPC_CheckPredicate, 46, // 3825: check predicate 46
3110 OPC_CheckField, 15, 1, 1, // 3827: check Inst[15] == 0x1
3111 OPC_Decode, 135, 118, 37, // 3831: decode to NSRLI using decoder 37
3112 // 3831: }
3113 2, 27, // 3835: case 0x2: {
3114 OPC_SwitchField, 25, 1, // 3837: switch Inst[25] {
3115 0, 10, // 3840: case 0x0: {
3116 OPC_CheckPredicate, 46, // 3842: check predicate 46
3117 OPC_CheckField, 15, 1, 1, // 3844: check Inst[15] == 0x1
3118 OPC_Decode, 159, 120, 38, // 3848: decode to PNSRL_BS using decoder 38
3119 // 3848: }
3120 1, 0, // 3852: case 0x1: {
3121 OPC_CheckPredicate, 46, // 3854: check predicate 46
3122 OPC_CheckField, 15, 1, 1, // 3856: check Inst[15] == 0x1
3123 OPC_Decode, 160, 120, 38, // 3860: decode to PNSRL_HS using decoder 38
3124 // 3860: }
3125 // 3860: } // switch Inst[25]
3126 // 3860: }
3127 3, 14, // 3864: case 0x3: {
3128 OPC_CheckPredicate, 46, // 3866: check predicate 46
3129 OPC_CheckField, 25, 1, 1, // 3868: check Inst[25] == 0x1
3130 OPC_CheckField, 15, 1, 1, // 3872: check Inst[15] == 0x1
3131 OPC_Decode, 134, 118, 38, // 3876: decode to NSRL using decoder 38
3132 // 3876: }
3133 6, 14, // 3880: case 0x6: {
3134 OPC_CheckPredicate, 46, // 3882: check predicate 46
3135 OPC_CheckField, 25, 1, 0, // 3884: check Inst[25] == 0x0
3136 OPC_CheckField, 15, 1, 0, // 3888: check Inst[15] == 0x0
3137 OPC_Decode, 187, 120, 38, // 3892: decode to PREDSUM_DHS using decoder 38
3138 // 3892: }
3139 7, 14, // 3896: case 0x7: {
3140 OPC_CheckPredicate, 46, // 3898: check predicate 46
3141 OPC_CheckField, 25, 1, 0, // 3900: check Inst[25] == 0x0
3142 OPC_CheckField, 15, 1, 0, // 3904: check Inst[15] == 0x0
3143 OPC_Decode, 186, 120, 38, // 3908: decode to PREDSUM_DBS using decoder 38
3144 // 3908: }
3145 8, 31, // 3912: case 0x8: {
3146 OPC_SwitchField, 25, 1, // 3914: switch Inst[25] {
3147 0, 14, // 3917: case 0x0: {
3148 OPC_CheckPredicate, 46, // 3919: check predicate 46
3149 OPC_CheckField, 24, 1, 1, // 3921: check Inst[24] == 0x1
3150 OPC_CheckField, 15, 1, 1, // 3925: check Inst[15] == 0x1
3151 OPC_Decode, 255, 119, 35, // 3929: decode to PNCLIPIU_B using decoder 35
3152 // 3929: }
3153 1, 0, // 3933: case 0x1: {
3154 OPC_CheckPredicate, 46, // 3935: check predicate 46
3155 OPC_CheckField, 15, 1, 1, // 3937: check Inst[15] == 0x1
3156 OPC_Decode, 128, 120, 36, // 3941: decode to PNCLIPIU_H using decoder 36
3157 // 3941: }
3158 // 3941: } // switch Inst[25]
3159 // 3941: }
3160 9, 10, // 3945: case 0x9: {
3161 OPC_CheckPredicate, 46, // 3947: check predicate 46
3162 OPC_CheckField, 15, 1, 1, // 3949: check Inst[15] == 0x1
3163 OPC_Decode, 205, 117, 37, // 3953: decode to NCLIPIU using decoder 37
3164 // 3953: }
3165 10, 27, // 3957: case 0xa: {
3166 OPC_SwitchField, 25, 1, // 3959: switch Inst[25] {
3167 0, 10, // 3962: case 0x0: {
3168 OPC_CheckPredicate, 46, // 3964: check predicate 46
3169 OPC_CheckField, 15, 1, 1, // 3966: check Inst[15] == 0x1
3170 OPC_Decode, 145, 120, 38, // 3970: decode to PNCLIPU_BS using decoder 38
3171 // 3970: }
3172 1, 0, // 3974: case 0x1: {
3173 OPC_CheckPredicate, 46, // 3976: check predicate 46
3174 OPC_CheckField, 15, 1, 1, // 3978: check Inst[15] == 0x1
3175 OPC_Decode, 146, 120, 38, // 3982: decode to PNCLIPU_HS using decoder 38
3176 // 3982: }
3177 // 3982: } // switch Inst[25]
3178 // 3982: }
3179 11, 14, // 3986: case 0xb: {
3180 OPC_CheckPredicate, 46, // 3988: check predicate 46
3181 OPC_CheckField, 25, 1, 1, // 3990: check Inst[25] == 0x1
3182 OPC_CheckField, 15, 1, 1, // 3994: check Inst[15] == 0x1
3183 OPC_Decode, 210, 117, 38, // 3998: decode to NCLIPU using decoder 38
3184 // 3998: }
3185 12, 31, // 4002: case 0xc: {
3186 OPC_SwitchField, 25, 1, // 4004: switch Inst[25] {
3187 0, 14, // 4007: case 0x0: {
3188 OPC_CheckPredicate, 46, // 4009: check predicate 46
3189 OPC_CheckField, 24, 1, 1, // 4011: check Inst[24] == 0x1
3190 OPC_CheckField, 15, 1, 1, // 4015: check Inst[15] == 0x1
3191 OPC_Decode, 134, 120, 35, // 4019: decode to PNCLIPRIU_B using decoder 35
3192 // 4019: }
3193 1, 0, // 4023: case 0x1: {
3194 OPC_CheckPredicate, 46, // 4025: check predicate 46
3195 OPC_CheckField, 15, 1, 1, // 4027: check Inst[15] == 0x1
3196 OPC_Decode, 135, 120, 36, // 4031: decode to PNCLIPRIU_H using decoder 36
3197 // 4031: }
3198 // 4031: } // switch Inst[25]
3199 // 4031: }
3200 13, 10, // 4035: case 0xd: {
3201 OPC_CheckPredicate, 46, // 4037: check predicate 46
3202 OPC_CheckField, 15, 1, 1, // 4039: check Inst[15] == 0x1
3203 OPC_Decode, 208, 117, 37, // 4043: decode to NCLIPRIU using decoder 37
3204 // 4043: }
3205 14, 36, // 4047: case 0xe: {
3206 OPC_SwitchField, 15, 1, // 4049: switch Inst[15] {
3207 0, 10, // 4052: case 0x0: {
3208 OPC_CheckPredicate, 46, // 4054: check predicate 46
3209 OPC_CheckField, 25, 1, 0, // 4056: check Inst[25] == 0x0
3210 OPC_Decode, 182, 120, 38, // 4060: decode to PREDSUMU_DHS using decoder 38
3211 // 4060: }
3212 1, 0, // 4064: case 0x1: {
3213 OPC_SwitchField, 25, 1, // 4066: switch Inst[25] {
3214 0, 6, // 4069: case 0x0: {
3215 OPC_CheckPredicate, 46, // 4071: check predicate 46
3216 OPC_Decode, 138, 120, 38, // 4073: decode to PNCLIPRU_BS using decoder 38
3217 // 4073: }
3218 1, 0, // 4077: case 0x1: {
3219 OPC_CheckPredicate, 46, // 4079: check predicate 46
3220 OPC_Decode, 139, 120, 38, // 4081: decode to PNCLIPRU_HS using decoder 38
3221 // 4081: }
3222 // 4081: } // switch Inst[25]
3223 // 4081: }
3224 // 4081: } // switch Inst[15]
3225 // 4081: }
3226 15, 27, // 4085: case 0xf: {
3227 OPC_SwitchField, 15, 1, // 4087: switch Inst[15] {
3228 0, 10, // 4090: case 0x0: {
3229 OPC_CheckPredicate, 46, // 4092: check predicate 46
3230 OPC_CheckField, 25, 1, 0, // 4094: check Inst[25] == 0x0
3231 OPC_Decode, 181, 120, 38, // 4098: decode to PREDSUMU_DBS using decoder 38
3232 // 4098: }
3233 1, 0, // 4102: case 0x1: {
3234 OPC_CheckPredicate, 46, // 4104: check predicate 46
3235 OPC_CheckField, 25, 1, 1, // 4106: check Inst[25] == 0x1
3236 OPC_Decode, 209, 117, 38, // 4110: decode to NCLIPRU using decoder 38
3237 // 4110: }
3238 // 4110: } // switch Inst[15]
3239 // 4110: }
3240 16, 31, // 4114: case 0x10: {
3241 OPC_SwitchField, 25, 1, // 4116: switch Inst[25] {
3242 0, 14, // 4119: case 0x0: {
3243 OPC_CheckPredicate, 46, // 4121: check predicate 46
3244 OPC_CheckField, 24, 1, 1, // 4123: check Inst[24] == 0x1
3245 OPC_CheckField, 15, 1, 1, // 4127: check Inst[15] == 0x1
3246 OPC_Decode, 149, 120, 35, // 4131: decode to PNSRAI_B using decoder 35
3247 // 4131: }
3248 1, 0, // 4135: case 0x1: {
3249 OPC_CheckPredicate, 46, // 4137: check predicate 46
3250 OPC_CheckField, 15, 1, 1, // 4139: check Inst[15] == 0x1
3251 OPC_Decode, 150, 120, 36, // 4143: decode to PNSRAI_H using decoder 36
3252 // 4143: }
3253 // 4143: } // switch Inst[25]
3254 // 4143: }
3255 17, 10, // 4147: case 0x11: {
3256 OPC_CheckPredicate, 46, // 4149: check predicate 46
3257 OPC_CheckField, 15, 1, 1, // 4151: check Inst[15] == 0x1
3258 OPC_Decode, 131, 118, 37, // 4155: decode to NSRAI using decoder 37
3259 // 4155: }
3260 18, 27, // 4159: case 0x12: {
3261 OPC_SwitchField, 25, 1, // 4161: switch Inst[25] {
3262 0, 10, // 4164: case 0x0: {
3263 OPC_CheckPredicate, 46, // 4166: check predicate 46
3264 OPC_CheckField, 15, 1, 1, // 4168: check Inst[15] == 0x1
3265 OPC_Decode, 155, 120, 38, // 4172: decode to PNSRA_BS using decoder 38
3266 // 4172: }
3267 1, 0, // 4176: case 0x1: {
3268 OPC_CheckPredicate, 46, // 4178: check predicate 46
3269 OPC_CheckField, 15, 1, 1, // 4180: check Inst[15] == 0x1
3270 OPC_Decode, 156, 120, 38, // 4184: decode to PNSRA_HS using decoder 38
3271 // 4184: }
3272 // 4184: } // switch Inst[25]
3273 // 4184: }
3274 19, 14, // 4188: case 0x13: {
3275 OPC_CheckPredicate, 46, // 4190: check predicate 46
3276 OPC_CheckField, 25, 1, 1, // 4192: check Inst[25] == 0x1
3277 OPC_CheckField, 15, 1, 1, // 4196: check Inst[15] == 0x1
3278 OPC_Decode, 130, 118, 38, // 4200: decode to NSRA using decoder 38
3279 // 4200: }
3280 20, 31, // 4204: case 0x14: {
3281 OPC_SwitchField, 25, 1, // 4206: switch Inst[25] {
3282 0, 14, // 4209: case 0x0: {
3283 OPC_CheckPredicate, 46, // 4211: check predicate 46
3284 OPC_CheckField, 24, 1, 1, // 4213: check Inst[24] == 0x1
3285 OPC_CheckField, 15, 1, 1, // 4217: check Inst[15] == 0x1
3286 OPC_Decode, 151, 120, 35, // 4221: decode to PNSRARI_B using decoder 35
3287 // 4221: }
3288 1, 0, // 4225: case 0x1: {
3289 OPC_CheckPredicate, 46, // 4227: check predicate 46
3290 OPC_CheckField, 15, 1, 1, // 4229: check Inst[15] == 0x1
3291 OPC_Decode, 152, 120, 36, // 4233: decode to PNSRARI_H using decoder 36
3292 // 4233: }
3293 // 4233: } // switch Inst[25]
3294 // 4233: }
3295 21, 10, // 4237: case 0x15: {
3296 OPC_CheckPredicate, 46, // 4239: check predicate 46
3297 OPC_CheckField, 15, 1, 1, // 4241: check Inst[15] == 0x1
3298 OPC_Decode, 133, 118, 37, // 4245: decode to NSRARI using decoder 37
3299 // 4245: }
3300 22, 27, // 4249: case 0x16: {
3301 OPC_SwitchField, 25, 1, // 4251: switch Inst[25] {
3302 0, 10, // 4254: case 0x0: {
3303 OPC_CheckPredicate, 46, // 4256: check predicate 46
3304 OPC_CheckField, 15, 1, 1, // 4258: check Inst[15] == 0x1
3305 OPC_Decode, 153, 120, 38, // 4262: decode to PNSRAR_BS using decoder 38
3306 // 4262: }
3307 1, 0, // 4266: case 0x1: {
3308 OPC_CheckPredicate, 46, // 4268: check predicate 46
3309 OPC_CheckField, 15, 1, 1, // 4270: check Inst[15] == 0x1
3310 OPC_Decode, 154, 120, 38, // 4274: decode to PNSRAR_HS using decoder 38
3311 // 4274: }
3312 // 4274: } // switch Inst[25]
3313 // 4274: }
3314 23, 14, // 4278: case 0x17: {
3315 OPC_CheckPredicate, 46, // 4280: check predicate 46
3316 OPC_CheckField, 25, 1, 1, // 4282: check Inst[25] == 0x1
3317 OPC_CheckField, 15, 1, 1, // 4286: check Inst[15] == 0x1
3318 OPC_Decode, 132, 118, 38, // 4290: decode to NSRAR using decoder 38
3319 // 4290: }
3320 24, 31, // 4294: case 0x18: {
3321 OPC_SwitchField, 25, 1, // 4296: switch Inst[25] {
3322 0, 14, // 4299: case 0x0: {
3323 OPC_CheckPredicate, 46, // 4301: check predicate 46
3324 OPC_CheckField, 24, 1, 1, // 4303: check Inst[24] == 0x1
3325 OPC_CheckField, 15, 1, 1, // 4307: check Inst[15] == 0x1
3326 OPC_Decode, 129, 120, 35, // 4311: decode to PNCLIPI_B using decoder 35
3327 // 4311: }
3328 1, 0, // 4315: case 0x1: {
3329 OPC_CheckPredicate, 46, // 4317: check predicate 46
3330 OPC_CheckField, 15, 1, 1, // 4319: check Inst[15] == 0x1
3331 OPC_Decode, 130, 120, 36, // 4323: decode to PNCLIPI_H using decoder 36
3332 // 4323: }
3333 // 4323: } // switch Inst[25]
3334 // 4323: }
3335 25, 10, // 4327: case 0x19: {
3336 OPC_CheckPredicate, 46, // 4329: check predicate 46
3337 OPC_CheckField, 15, 1, 1, // 4331: check Inst[15] == 0x1
3338 OPC_Decode, 204, 117, 37, // 4335: decode to NCLIPI using decoder 37
3339 // 4335: }
3340 26, 27, // 4339: case 0x1a: {
3341 OPC_SwitchField, 25, 1, // 4341: switch Inst[25] {
3342 0, 10, // 4344: case 0x0: {
3343 OPC_CheckPredicate, 46, // 4346: check predicate 46
3344 OPC_CheckField, 15, 1, 1, // 4348: check Inst[15] == 0x1
3345 OPC_Decode, 147, 120, 38, // 4352: decode to PNCLIP_BS using decoder 38
3346 // 4352: }
3347 1, 0, // 4356: case 0x1: {
3348 OPC_CheckPredicate, 46, // 4358: check predicate 46
3349 OPC_CheckField, 15, 1, 1, // 4360: check Inst[15] == 0x1
3350 OPC_Decode, 148, 120, 38, // 4364: decode to PNCLIP_HS using decoder 38
3351 // 4364: }
3352 // 4364: } // switch Inst[25]
3353 // 4364: }
3354 27, 14, // 4368: case 0x1b: {
3355 OPC_CheckPredicate, 46, // 4370: check predicate 46
3356 OPC_CheckField, 25, 1, 1, // 4372: check Inst[25] == 0x1
3357 OPC_CheckField, 15, 1, 1, // 4376: check Inst[15] == 0x1
3358 OPC_Decode, 203, 117, 38, // 4380: decode to NCLIP using decoder 38
3359 // 4380: }
3360 28, 31, // 4384: case 0x1c: {
3361 OPC_SwitchField, 25, 1, // 4386: switch Inst[25] {
3362 0, 14, // 4389: case 0x0: {
3363 OPC_CheckPredicate, 46, // 4391: check predicate 46
3364 OPC_CheckField, 24, 1, 1, // 4393: check Inst[24] == 0x1
3365 OPC_CheckField, 15, 1, 1, // 4397: check Inst[15] == 0x1
3366 OPC_Decode, 136, 120, 35, // 4401: decode to PNCLIPRI_B using decoder 35
3367 // 4401: }
3368 1, 0, // 4405: case 0x1: {
3369 OPC_CheckPredicate, 46, // 4407: check predicate 46
3370 OPC_CheckField, 15, 1, 1, // 4409: check Inst[15] == 0x1
3371 OPC_Decode, 137, 120, 36, // 4413: decode to PNCLIPRI_H using decoder 36
3372 // 4413: }
3373 // 4413: } // switch Inst[25]
3374 // 4413: }
3375 29, 10, // 4417: case 0x1d: {
3376 OPC_CheckPredicate, 46, // 4419: check predicate 46
3377 OPC_CheckField, 15, 1, 1, // 4421: check Inst[15] == 0x1
3378 OPC_Decode, 207, 117, 37, // 4425: decode to NCLIPRI using decoder 37
3379 // 4425: }
3380 30, 27, // 4429: case 0x1e: {
3381 OPC_SwitchField, 25, 1, // 4431: switch Inst[25] {
3382 0, 10, // 4434: case 0x0: {
3383 OPC_CheckPredicate, 46, // 4436: check predicate 46
3384 OPC_CheckField, 15, 1, 1, // 4438: check Inst[15] == 0x1
3385 OPC_Decode, 140, 120, 38, // 4442: decode to PNCLIPR_BS using decoder 38
3386 // 4442: }
3387 1, 0, // 4446: case 0x1: {
3388 OPC_CheckPredicate, 46, // 4448: check predicate 46
3389 OPC_CheckField, 15, 1, 1, // 4450: check Inst[15] == 0x1
3390 OPC_Decode, 141, 120, 38, // 4454: decode to PNCLIPR_HS using decoder 38
3391 // 4454: }
3392 // 4454: } // switch Inst[25]
3393 // 4454: }
3394 31, 14, // 4458: case 0x1f: {
3395 OPC_CheckPredicate, 46, // 4460: check predicate 46
3396 OPC_CheckField, 25, 1, 1, // 4462: check Inst[25] == 0x1
3397 OPC_CheckField, 15, 1, 1, // 4466: check Inst[15] == 0x1
3398 OPC_Decode, 206, 117, 38, // 4470: decode to NCLIPR using decoder 38
3399 // 4470: }
3400 32, 36, // 4474: case 0x20: {
3401 OPC_SwitchField, 25, 1, // 4476: switch Inst[25] {
3402 0, 23, // 4479: case 0x0: {
3403 OPC_SwitchField, 24, 1, // 4481: switch Inst[24] {
3404 0, 10, // 4484: case 0x0: {
3405 OPC_CheckPredicate, 42, // 4486: check predicate 42
3406 OPC_CheckField, 23, 1, 1, // 4488: check Inst[23] == 0x1
3407 OPC_Decode, 129, 121, 30, // 4492: decode to PSRLI_B using decoder 30
3408 // 4492: }
3409 1, 0, // 4496: case 0x1: {
3410 OPC_CheckPredicate, 42, // 4498: check predicate 42
3411 OPC_Decode, 133, 121, 18, // 4500: decode to PSRLI_H using decoder 18
3412 // 4500: }
3413 // 4500: } // switch Inst[24]
3414 // 4500: }
3415 1, 0, // 4504: case 0x1: {
3416 OPC_CheckPredicate, 47, // 4506: check predicate 47
3417 OPC_Decode, 134, 121, 21, // 4508: decode to PSRLI_W using decoder 21
3418 // 4508: }
3419 // 4508: } // switch Inst[25]
3420 // 4508: }
3421 34, 19, // 4512: case 0x22: {
3422 OPC_SwitchField, 25, 1, // 4514: switch Inst[25] {
3423 0, 6, // 4517: case 0x0: {
3424 OPC_CheckPredicate, 42, // 4519: check predicate 42
3425 OPC_Decode, 139, 121, 31, // 4521: decode to PSRL_HS using decoder 31
3426 // 4521: }
3427 1, 0, // 4525: case 0x1: {
3428 OPC_CheckPredicate, 47, // 4527: check predicate 47
3429 OPC_Decode, 140, 121, 31, // 4529: decode to PSRL_WS using decoder 31
3430 // 4529: }
3431 // 4529: } // switch Inst[25]
3432 // 4529: }
3433 35, 10, // 4533: case 0x23: {
3434 OPC_CheckPredicate, 42, // 4535: check predicate 42
3435 OPC_CheckField, 25, 1, 0, // 4537: check Inst[25] == 0x0
3436 OPC_Decode, 135, 121, 31, // 4541: decode to PSRL_BS using decoder 31
3437 // 4541: }
3438 38, 19, // 4545: case 0x26: {
3439 OPC_SwitchField, 25, 1, // 4547: switch Inst[25] {
3440 0, 6, // 4550: case 0x0: {
3441 OPC_CheckPredicate, 42, // 4552: check predicate 42
3442 OPC_Decode, 188, 120, 31, // 4554: decode to PREDSUM_HS using decoder 31
3443 // 4554: }
3444 1, 0, // 4558: case 0x1: {
3445 OPC_CheckPredicate, 47, // 4560: check predicate 47
3446 OPC_Decode, 189, 120, 31, // 4562: decode to PREDSUM_WS using decoder 31
3447 // 4562: }
3448 // 4562: } // switch Inst[25]
3449 // 4562: }
3450 39, 10, // 4566: case 0x27: {
3451 OPC_CheckPredicate, 42, // 4568: check predicate 42
3452 OPC_CheckField, 25, 1, 0, // 4570: check Inst[25] == 0x0
3453 OPC_Decode, 185, 120, 31, // 4574: decode to PREDSUM_BS using decoder 31
3454 // 4574: }
3455 40, 23, // 4578: case 0x28: {
3456 OPC_SwitchField, 25, 1, // 4580: switch Inst[25] {
3457 0, 10, // 4583: case 0x0: {
3458 OPC_CheckPredicate, 42, // 4585: check predicate 42
3459 OPC_CheckField, 24, 1, 1, // 4587: check Inst[24] == 0x1
3460 OPC_Decode, 188, 121, 18, // 4591: decode to PUSATI_H using decoder 18
3461 // 4591: }
3462 1, 0, // 4595: case 0x1: {
3463 OPC_CheckPredicate, 47, // 4597: check predicate 47
3464 OPC_Decode, 189, 121, 21, // 4599: decode to PUSATI_W using decoder 21
3465 // 4599: }
3466 // 4599: } // switch Inst[25]
3467 // 4599: }
3468 41, 6, // 4603: case 0x29: {
3469 OPC_CheckPredicate, 47, // 4605: check predicate 47
3470 OPC_Decode, 197, 125, 39, // 4607: decode to USATI_RV64 using decoder 39
3471 // 4607: }
3472 46, 19, // 4611: case 0x2e: {
3473 OPC_SwitchField, 25, 1, // 4613: switch Inst[25] {
3474 0, 6, // 4616: case 0x0: {
3475 OPC_CheckPredicate, 42, // 4618: check predicate 42
3476 OPC_Decode, 183, 120, 31, // 4620: decode to PREDSUMU_HS using decoder 31
3477 // 4620: }
3478 1, 0, // 4624: case 0x1: {
3479 OPC_CheckPredicate, 47, // 4626: check predicate 47
3480 OPC_Decode, 184, 120, 31, // 4628: decode to PREDSUMU_WS using decoder 31
3481 // 4628: }
3482 // 4628: } // switch Inst[25]
3483 // 4628: }
3484 47, 10, // 4632: case 0x2f: {
3485 OPC_CheckPredicate, 42, // 4634: check predicate 42
3486 OPC_CheckField, 25, 1, 0, // 4636: check Inst[25] == 0x0
3487 OPC_Decode, 180, 120, 31, // 4640: decode to PREDSUMU_BS using decoder 31
3488 // 4640: }
3489 48, 36, // 4644: case 0x30: {
3490 OPC_SwitchField, 25, 1, // 4646: switch Inst[25] {
3491 0, 23, // 4649: case 0x0: {
3492 OPC_SwitchField, 24, 1, // 4651: switch Inst[24] {
3493 0, 10, // 4654: case 0x0: {
3494 OPC_CheckPredicate, 42, // 4656: check predicate 42
3495 OPC_CheckField, 23, 1, 1, // 4658: check Inst[23] == 0x1
3496 OPC_Decode, 241, 120, 30, // 4662: decode to PSRAI_B using decoder 30
3497 // 4662: }
3498 1, 0, // 4666: case 0x1: {
3499 OPC_CheckPredicate, 42, // 4668: check predicate 42
3500 OPC_Decode, 245, 120, 18, // 4670: decode to PSRAI_H using decoder 18
3501 // 4670: }
3502 // 4670: } // switch Inst[24]
3503 // 4670: }
3504 1, 0, // 4674: case 0x1: {
3505 OPC_CheckPredicate, 47, // 4676: check predicate 47
3506 OPC_Decode, 246, 120, 21, // 4678: decode to PSRAI_W using decoder 21
3507 // 4678: }
3508 // 4678: } // switch Inst[25]
3509 // 4678: }
3510 50, 19, // 4682: case 0x32: {
3511 OPC_SwitchField, 25, 1, // 4684: switch Inst[25] {
3512 0, 6, // 4687: case 0x0: {
3513 OPC_CheckPredicate, 42, // 4689: check predicate 42
3514 OPC_Decode, 255, 120, 31, // 4691: decode to PSRA_HS using decoder 31
3515 // 4691: }
3516 1, 0, // 4695: case 0x1: {
3517 OPC_CheckPredicate, 47, // 4697: check predicate 47
3518 OPC_Decode, 128, 121, 31, // 4699: decode to PSRA_WS using decoder 31
3519 // 4699: }
3520 // 4699: } // switch Inst[25]
3521 // 4699: }
3522 51, 10, // 4703: case 0x33: {
3523 OPC_CheckPredicate, 42, // 4705: check predicate 42
3524 OPC_CheckField, 25, 1, 0, // 4707: check Inst[25] == 0x0
3525 OPC_Decode, 251, 120, 31, // 4711: decode to PSRA_BS using decoder 31
3526 // 4711: }
3527 52, 23, // 4715: case 0x34: {
3528 OPC_SwitchField, 25, 1, // 4717: switch Inst[25] {
3529 0, 10, // 4720: case 0x0: {
3530 OPC_CheckPredicate, 42, // 4722: check predicate 42
3531 OPC_CheckField, 24, 1, 1, // 4724: check Inst[24] == 0x1
3532 OPC_Decode, 249, 120, 18, // 4728: decode to PSRARI_H using decoder 18
3533 // 4728: }
3534 1, 0, // 4732: case 0x1: {
3535 OPC_CheckPredicate, 47, // 4734: check predicate 47
3536 OPC_Decode, 250, 120, 21, // 4736: decode to PSRARI_W using decoder 21
3537 // 4736: }
3538 // 4736: } // switch Inst[25]
3539 // 4736: }
3540 53, 6, // 4740: case 0x35: {
3541 OPC_CheckPredicate, 47, // 4742: check predicate 47
3542 OPC_Decode, 174, 124, 39, // 4744: decode to SRARI_RV64 using decoder 39
3543 // 4744: }
3544 56, 23, // 4748: case 0x38: {
3545 OPC_SwitchField, 25, 1, // 4750: switch Inst[25] {
3546 0, 10, // 4753: case 0x0: {
3547 OPC_CheckPredicate, 42, // 4755: check predicate 42
3548 OPC_CheckField, 24, 1, 1, // 4757: check Inst[24] == 0x1
3549 OPC_Decode, 214, 120, 40, // 4761: decode to PSATI_H using decoder 40
3550 // 4761: }
3551 1, 0, // 4765: case 0x1: {
3552 OPC_CheckPredicate, 47, // 4767: check predicate 47
3553 OPC_Decode, 215, 120, 41, // 4769: decode to PSATI_W using decoder 41
3554 // 4769: }
3555 // 4769: } // switch Inst[25]
3556 // 4769: }
3557 57, 0, // 4773: case 0x39: {
3558 OPC_CheckPredicate, 47, // 4775: check predicate 47
3559 OPC_Decode, 149, 123, 42, // 4777: decode to SATI_RV64 using decoder 42
3560 // 4777: }
3561 // 4777: } // switch Inst[31:26]
3562 // 4777: }
3563 5, 27, // 4781: case 0x5: {
3564 OPC_SwitchField, 25, 7, // 4783: switch Inst[31:25] {
3565 0, 6, // 4786: case 0x0: {
3566 OPC_CheckPredicate, 21, // 4788: check predicate 21
3567 OPC_Decode, 179, 124, 21, // 4790: decode to SRLIW using decoder 21
3568 // 4790: }
3569 32, 6, // 4794: case 0x20: {
3570 OPC_CheckPredicate, 21, // 4796: check predicate 21
3571 OPC_Decode, 172, 124, 21, // 4798: decode to SRAIW using decoder 21
3572 // 4798: }
3573 48, 0, // 4802: case 0x30: {
3574 OPC_CheckPredicate, 48, // 4804: check predicate 48
3575 OPC_Decode, 144, 123, 21, // 4806: decode to RORIW using decoder 21
3576 // 4806: }
3577 // 4806: } // switch Inst[31:25]
3578 // 4806: }
3579 6, 0, // 4810: case 0x6: {
3580 OPC_SwitchField, 25, 7, // 4812: switch Inst[31:25] {
3581 0, 69, // 4815: case 0x0: {
3582 OPC_SwitchField, 15, 1, // 4817: switch Inst[15] {
3583 0, 31, // 4820: case 0x0: {
3584 OPC_SwitchField, 24, 1, // 4822: switch Inst[24] {
3585 0, 14, // 4825: case 0x0: {
3586 OPC_CheckPredicate, 46, // 4827: check predicate 46
3587 OPC_CheckField, 23, 1, 1, // 4829: check Inst[23] == 0x1
3588 OPC_CheckField, 7, 1, 0, // 4833: check Inst[7] == 0x0
3589 OPC_Decode, 230, 120, 43, // 4837: decode to PSLLI_DB using decoder 43
3590 // 4837: }
3591 1, 0, // 4841: case 0x1: {
3592 OPC_CheckPredicate, 46, // 4843: check predicate 46
3593 OPC_CheckField, 7, 1, 0, // 4845: check Inst[7] == 0x0
3594 OPC_Decode, 231, 120, 44, // 4849: decode to PSLLI_DH using decoder 44
3595 // 4849: }
3596 // 4849: } // switch Inst[24]
3597 // 4849: }
3598 1, 0, // 4853: case 0x1: {
3599 OPC_SwitchField, 24, 1, // 4855: switch Inst[24] {
3600 0, 14, // 4858: case 0x0: {
3601 OPC_CheckPredicate, 46, // 4860: check predicate 46
3602 OPC_CheckField, 23, 1, 1, // 4862: check Inst[23] == 0x1
3603 OPC_CheckField, 7, 1, 0, // 4866: check Inst[7] == 0x0
3604 OPC_Decode, 130, 121, 43, // 4870: decode to PSRLI_DB using decoder 43
3605 // 4870: }
3606 1, 0, // 4874: case 0x1: {
3607 OPC_CheckPredicate, 46, // 4876: check predicate 46
3608 OPC_CheckField, 7, 1, 0, // 4878: check Inst[7] == 0x0
3609 OPC_Decode, 131, 121, 44, // 4882: decode to PSRLI_DH using decoder 44
3610 // 4882: }
3611 // 4882: } // switch Inst[24]
3612 // 4882: }
3613 // 4882: } // switch Inst[15]
3614 // 4882: }
3615 1, 27, // 4886: case 0x1: {
3616 OPC_SwitchField, 15, 1, // 4888: switch Inst[15] {
3617 0, 10, // 4891: case 0x0: {
3618 OPC_CheckPredicate, 46, // 4893: check predicate 46
3619 OPC_CheckField, 7, 1, 0, // 4895: check Inst[7] == 0x0
3620 OPC_Decode, 232, 120, 45, // 4899: decode to PSLLI_DW using decoder 45
3621 // 4899: }
3622 1, 0, // 4903: case 0x1: {
3623 OPC_CheckPredicate, 46, // 4905: check predicate 46
3624 OPC_CheckField, 7, 1, 0, // 4907: check Inst[7] == 0x0
3625 OPC_Decode, 132, 121, 45, // 4911: decode to PSRLI_DW using decoder 45
3626 // 4911: }
3627 // 4911: } // switch Inst[15]
3628 // 4911: }
3629 4, 27, // 4915: case 0x4: {
3630 OPC_SwitchField, 15, 1, // 4917: switch Inst[15] {
3631 0, 10, // 4920: case 0x0: {
3632 OPC_CheckPredicate, 46, // 4922: check predicate 46
3633 OPC_CheckField, 7, 1, 0, // 4924: check Inst[7] == 0x0
3634 OPC_Decode, 237, 120, 46, // 4928: decode to PSLL_DHS using decoder 46
3635 // 4928: }
3636 1, 0, // 4932: case 0x1: {
3637 OPC_CheckPredicate, 46, // 4934: check predicate 46
3638 OPC_CheckField, 7, 1, 0, // 4936: check Inst[7] == 0x0
3639 OPC_Decode, 137, 121, 46, // 4940: decode to PSRL_DHS using decoder 46
3640 // 4940: }
3641 // 4940: } // switch Inst[15]
3642 // 4940: }
3643 5, 27, // 4944: case 0x5: {
3644 OPC_SwitchField, 15, 1, // 4946: switch Inst[15] {
3645 0, 10, // 4949: case 0x0: {
3646 OPC_CheckPredicate, 46, // 4951: check predicate 46
3647 OPC_CheckField, 7, 1, 0, // 4953: check Inst[7] == 0x0
3648 OPC_Decode, 238, 120, 46, // 4957: decode to PSLL_DWS using decoder 46
3649 // 4957: }
3650 1, 0, // 4961: case 0x1: {
3651 OPC_CheckPredicate, 46, // 4963: check predicate 46
3652 OPC_CheckField, 7, 1, 0, // 4965: check Inst[7] == 0x0
3653 OPC_Decode, 138, 121, 46, // 4969: decode to PSRL_DWS using decoder 46
3654 // 4969: }
3655 // 4969: } // switch Inst[15]
3656 // 4969: }
3657 6, 27, // 4973: case 0x6: {
3658 OPC_SwitchField, 15, 1, // 4975: switch Inst[15] {
3659 0, 10, // 4978: case 0x0: {
3660 OPC_CheckPredicate, 46, // 4980: check predicate 46
3661 OPC_CheckField, 7, 1, 0, // 4982: check Inst[7] == 0x0
3662 OPC_Decode, 236, 120, 46, // 4986: decode to PSLL_DBS using decoder 46
3663 // 4986: }
3664 1, 0, // 4990: case 0x1: {
3665 OPC_CheckPredicate, 46, // 4992: check predicate 46
3666 OPC_CheckField, 7, 1, 0, // 4994: check Inst[7] == 0x0
3667 OPC_Decode, 136, 121, 46, // 4998: decode to PSRL_DBS using decoder 46
3668 // 4998: }
3669 // 4998: } // switch Inst[15]
3670 // 4998: }
3671 12, 14, // 5002: case 0xc: {
3672 OPC_CheckPredicate, 46, // 5004: check predicate 46
3673 OPC_CheckField, 15, 1, 0, // 5006: check Inst[15] == 0x0
3674 OPC_CheckField, 7, 1, 0, // 5010: check Inst[7] == 0x0
3675 OPC_Decode, 174, 118, 46, // 5014: decode to PADD_DHS using decoder 46
3676 // 5014: }
3677 13, 14, // 5018: case 0xd: {
3678 OPC_CheckPredicate, 46, // 5020: check predicate 46
3679 OPC_CheckField, 15, 1, 0, // 5022: check Inst[15] == 0x0
3680 OPC_CheckField, 7, 1, 0, // 5026: check Inst[7] == 0x0
3681 OPC_Decode, 176, 118, 46, // 5030: decode to PADD_DWS using decoder 46
3682 // 5030: }
3683 14, 14, // 5034: case 0xe: {
3684 OPC_CheckPredicate, 46, // 5036: check predicate 46
3685 OPC_CheckField, 15, 1, 0, // 5038: check Inst[15] == 0x0
3686 OPC_CheckField, 7, 1, 0, // 5042: check Inst[7] == 0x0
3687 OPC_Decode, 172, 118, 46, // 5046: decode to PADD_DBS using decoder 46
3688 // 5046: }
3689 16, 18, // 5050: case 0x10: {
3690 OPC_CheckPredicate, 46, // 5052: check predicate 46
3691 OPC_CheckField, 24, 1, 1, // 5054: check Inst[24] == 0x1
3692 OPC_CheckField, 15, 1, 1, // 5058: check Inst[15] == 0x1
3693 OPC_CheckField, 7, 1, 0, // 5062: check Inst[7] == 0x0
3694 OPC_Decode, 186, 121, 44, // 5066: decode to PUSATI_DH using decoder 44
3695 // 5066: }
3696 17, 14, // 5070: case 0x11: {
3697 OPC_CheckPredicate, 46, // 5072: check predicate 46
3698 OPC_CheckField, 15, 1, 1, // 5074: check Inst[15] == 0x1
3699 OPC_CheckField, 7, 1, 0, // 5078: check Inst[7] == 0x0
3700 OPC_Decode, 187, 121, 45, // 5082: decode to PUSATI_DW using decoder 45
3701 // 5082: }
3702 20, 14, // 5086: case 0x14: {
3703 OPC_CheckPredicate, 46, // 5088: check predicate 46
3704 OPC_CheckField, 15, 1, 0, // 5090: check Inst[15] == 0x0
3705 OPC_CheckField, 7, 1, 0, // 5094: check Inst[7] == 0x0
3706 OPC_Decode, 160, 121, 46, // 5098: decode to PSSHL_DHS using decoder 46
3707 // 5098: }
3708 21, 14, // 5102: case 0x15: {
3709 OPC_CheckPredicate, 46, // 5104: check predicate 46
3710 OPC_CheckField, 15, 1, 0, // 5106: check Inst[15] == 0x0
3711 OPC_CheckField, 7, 1, 0, // 5110: check Inst[7] == 0x0
3712 OPC_Decode, 161, 121, 46, // 5114: decode to PSSHL_DWS using decoder 46
3713 // 5114: }
3714 28, 14, // 5118: case 0x1c: {
3715 OPC_CheckPredicate, 46, // 5120: check predicate 46
3716 OPC_CheckField, 15, 1, 0, // 5122: check Inst[15] == 0x0
3717 OPC_CheckField, 7, 1, 0, // 5126: check Inst[7] == 0x0
3718 OPC_Decode, 156, 121, 46, // 5130: decode to PSSHLR_DHS using decoder 46
3719 // 5130: }
3720 29, 14, // 5134: case 0x1d: {
3721 OPC_CheckPredicate, 46, // 5136: check predicate 46
3722 OPC_CheckField, 15, 1, 0, // 5138: check Inst[15] == 0x0
3723 OPC_CheckField, 7, 1, 0, // 5142: check Inst[7] == 0x0
3724 OPC_Decode, 157, 121, 46, // 5146: decode to PSSHLR_DWS using decoder 46
3725 // 5146: }
3726 32, 39, // 5150: case 0x20: {
3727 OPC_SwitchField, 24, 1, // 5152: switch Inst[24] {
3728 0, 18, // 5155: case 0x0: {
3729 OPC_CheckPredicate, 46, // 5157: check predicate 46
3730 OPC_CheckField, 23, 1, 1, // 5159: check Inst[23] == 0x1
3731 OPC_CheckField, 15, 1, 1, // 5163: check Inst[15] == 0x1
3732 OPC_CheckField, 7, 1, 0, // 5167: check Inst[7] == 0x0
3733 OPC_Decode, 242, 120, 43, // 5171: decode to PSRAI_DB using decoder 43
3734 // 5171: }
3735 1, 0, // 5175: case 0x1: {
3736 OPC_CheckPredicate, 46, // 5177: check predicate 46
3737 OPC_CheckField, 15, 1, 1, // 5179: check Inst[15] == 0x1
3738 OPC_CheckField, 7, 1, 0, // 5183: check Inst[7] == 0x0
3739 OPC_Decode, 243, 120, 44, // 5187: decode to PSRAI_DH using decoder 44
3740 // 5187: }
3741 // 5187: } // switch Inst[24]
3742 // 5187: }
3743 33, 14, // 5191: case 0x21: {
3744 OPC_CheckPredicate, 46, // 5193: check predicate 46
3745 OPC_CheckField, 15, 1, 1, // 5195: check Inst[15] == 0x1
3746 OPC_CheckField, 7, 1, 0, // 5199: check Inst[7] == 0x0
3747 OPC_Decode, 244, 120, 45, // 5203: decode to PSRAI_DW using decoder 45
3748 // 5203: }
3749 36, 14, // 5207: case 0x24: {
3750 OPC_CheckPredicate, 46, // 5209: check predicate 46
3751 OPC_CheckField, 15, 1, 1, // 5211: check Inst[15] == 0x1
3752 OPC_CheckField, 7, 1, 0, // 5215: check Inst[7] == 0x0
3753 OPC_Decode, 253, 120, 46, // 5219: decode to PSRA_DHS using decoder 46
3754 // 5219: }
3755 37, 14, // 5223: case 0x25: {
3756 OPC_CheckPredicate, 46, // 5225: check predicate 46
3757 OPC_CheckField, 15, 1, 1, // 5227: check Inst[15] == 0x1
3758 OPC_CheckField, 7, 1, 0, // 5231: check Inst[7] == 0x0
3759 OPC_Decode, 254, 120, 46, // 5235: decode to PSRA_DWS using decoder 46
3760 // 5235: }
3761 38, 14, // 5239: case 0x26: {
3762 OPC_CheckPredicate, 46, // 5241: check predicate 46
3763 OPC_CheckField, 15, 1, 1, // 5243: check Inst[15] == 0x1
3764 OPC_CheckField, 7, 1, 0, // 5247: check Inst[7] == 0x0
3765 OPC_Decode, 252, 120, 46, // 5251: decode to PSRA_DBS using decoder 46
3766 // 5251: }
3767 40, 35, // 5255: case 0x28: {
3768 OPC_SwitchField, 15, 1, // 5257: switch Inst[15] {
3769 0, 14, // 5260: case 0x0: {
3770 OPC_CheckPredicate, 46, // 5262: check predicate 46
3771 OPC_CheckField, 24, 1, 1, // 5264: check Inst[24] == 0x1
3772 OPC_CheckField, 7, 1, 0, // 5268: check Inst[7] == 0x0
3773 OPC_Decode, 164, 121, 44, // 5272: decode to PSSLAI_DH using decoder 44
3774 // 5272: }
3775 1, 0, // 5276: case 0x1: {
3776 OPC_CheckPredicate, 46, // 5278: check predicate 46
3777 OPC_CheckField, 24, 1, 1, // 5280: check Inst[24] == 0x1
3778 OPC_CheckField, 7, 1, 0, // 5284: check Inst[7] == 0x0
3779 OPC_Decode, 247, 120, 44, // 5288: decode to PSRARI_DH using decoder 44
3780 // 5288: }
3781 // 5288: } // switch Inst[15]
3782 // 5288: }
3783 41, 27, // 5292: case 0x29: {
3784 OPC_SwitchField, 15, 1, // 5294: switch Inst[15] {
3785 0, 10, // 5297: case 0x0: {
3786 OPC_CheckPredicate, 46, // 5299: check predicate 46
3787 OPC_CheckField, 7, 1, 0, // 5301: check Inst[7] == 0x0
3788 OPC_Decode, 165, 121, 45, // 5305: decode to PSSLAI_DW using decoder 45
3789 // 5305: }
3790 1, 0, // 5309: case 0x1: {
3791 OPC_CheckPredicate, 46, // 5311: check predicate 46
3792 OPC_CheckField, 7, 1, 0, // 5313: check Inst[7] == 0x0
3793 OPC_Decode, 248, 120, 45, // 5317: decode to PSRARI_DW using decoder 45
3794 // 5317: }
3795 // 5317: } // switch Inst[15]
3796 // 5317: }
3797 48, 48, // 5321: case 0x30: {
3798 OPC_SwitchField, 15, 1, // 5323: switch Inst[15] {
3799 0, 27, // 5326: case 0x0: {
3800 OPC_SwitchField, 20, 5, // 5328: switch Inst[24:20] {
3801 4, 10, // 5331: case 0x4: {
3802 OPC_CheckPredicate, 46, // 5333: check predicate 46
3803 OPC_CheckField, 7, 1, 0, // 5335: check Inst[7] == 0x0
3804 OPC_Decode, 219, 120, 47, // 5339: decode to PSEXT_DH_B using decoder 47
3805 // 5339: }
3806 7, 0, // 5343: case 0x7: {
3807 OPC_CheckPredicate, 46, // 5345: check predicate 46
3808 OPC_CheckField, 7, 1, 0, // 5347: check Inst[7] == 0x0
3809 OPC_Decode, 195, 120, 47, // 5351: decode to PSABS_DH using decoder 47
3810 // 5351: }
3811 // 5351: } // switch Inst[24:20]
3812 // 5351: }
3813 1, 0, // 5355: case 0x1: {
3814 OPC_CheckPredicate, 46, // 5357: check predicate 46
3815 OPC_CheckField, 24, 1, 1, // 5359: check Inst[24] == 0x1
3816 OPC_CheckField, 7, 1, 0, // 5363: check Inst[7] == 0x0
3817 OPC_Decode, 212, 120, 44, // 5367: decode to PSATI_DH using decoder 44
3818 // 5367: }
3819 // 5367: } // switch Inst[15]
3820 // 5367: }
3821 49, 44, // 5371: case 0x31: {
3822 OPC_SwitchField, 15, 1, // 5373: switch Inst[15] {
3823 0, 27, // 5376: case 0x0: {
3824 OPC_SwitchField, 20, 5, // 5378: switch Inst[24:20] {
3825 4, 10, // 5381: case 0x4: {
3826 OPC_CheckPredicate, 46, // 5383: check predicate 46
3827 OPC_CheckField, 7, 1, 0, // 5385: check Inst[7] == 0x0
3828 OPC_Decode, 220, 120, 47, // 5389: decode to PSEXT_DW_B using decoder 47
3829 // 5389: }
3830 5, 0, // 5393: case 0x5: {
3831 OPC_CheckPredicate, 46, // 5395: check predicate 46
3832 OPC_CheckField, 7, 1, 0, // 5397: check Inst[7] == 0x0
3833 OPC_Decode, 221, 120, 47, // 5401: decode to PSEXT_DW_H using decoder 47
3834 // 5401: }
3835 // 5401: } // switch Inst[24:20]
3836 // 5401: }
3837 1, 0, // 5405: case 0x1: {
3838 OPC_CheckPredicate, 46, // 5407: check predicate 46
3839 OPC_CheckField, 7, 1, 0, // 5409: check Inst[7] == 0x0
3840 OPC_Decode, 213, 120, 45, // 5413: decode to PSATI_DW using decoder 45
3841 // 5413: }
3842 // 5413: } // switch Inst[15]
3843 // 5413: }
3844 50, 18, // 5417: case 0x32: {
3845 OPC_CheckPredicate, 46, // 5419: check predicate 46
3846 OPC_CheckField, 20, 5, 7, // 5421: check Inst[24:20] == 0x7
3847 OPC_CheckField, 15, 1, 0, // 5425: check Inst[15] == 0x0
3848 OPC_CheckField, 7, 1, 0, // 5429: check Inst[7] == 0x0
3849 OPC_Decode, 194, 120, 47, // 5433: decode to PSABS_DB using decoder 47
3850 // 5433: }
3851 52, 14, // 5437: case 0x34: {
3852 OPC_CheckPredicate, 46, // 5439: check predicate 46
3853 OPC_CheckField, 15, 1, 0, // 5441: check Inst[15] == 0x0
3854 OPC_CheckField, 7, 1, 0, // 5445: check Inst[7] == 0x0
3855 OPC_Decode, 152, 121, 46, // 5449: decode to PSSHA_DHS using decoder 46
3856 // 5449: }
3857 53, 14, // 5453: case 0x35: {
3858 OPC_CheckPredicate, 46, // 5455: check predicate 46
3859 OPC_CheckField, 15, 1, 0, // 5457: check Inst[15] == 0x0
3860 OPC_CheckField, 7, 1, 0, // 5461: check Inst[7] == 0x0
3861 OPC_Decode, 153, 121, 46, // 5465: decode to PSSHA_DWS using decoder 46
3862 // 5465: }
3863 60, 14, // 5469: case 0x3c: {
3864 OPC_CheckPredicate, 46, // 5471: check predicate 46
3865 OPC_CheckField, 15, 1, 0, // 5473: check Inst[15] == 0x0
3866 OPC_CheckField, 7, 1, 0, // 5477: check Inst[7] == 0x0
3867 OPC_Decode, 148, 121, 46, // 5481: decode to PSSHAR_DHS using decoder 46
3868 // 5481: }
3869 61, 14, // 5485: case 0x3d: {
3870 OPC_CheckPredicate, 46, // 5487: check predicate 46
3871 OPC_CheckField, 15, 1, 0, // 5489: check Inst[15] == 0x0
3872 OPC_CheckField, 7, 1, 0, // 5493: check Inst[7] == 0x0
3873 OPC_Decode, 149, 121, 46, // 5497: decode to PSSHAR_DWS using decoder 46
3874 // 5497: }
3875 64, 48, // 5501: case 0x40: {
3876 OPC_SwitchField, 15, 1, // 5503: switch Inst[15] {
3877 0, 14, // 5506: case 0x0: {
3878 OPC_CheckPredicate, 46, // 5508: check predicate 46
3879 OPC_CheckField, 20, 1, 0, // 5510: check Inst[20] == 0x0
3880 OPC_CheckField, 7, 1, 0, // 5514: check Inst[7] == 0x0
3881 OPC_Decode, 173, 118, 48, // 5518: decode to PADD_DH using decoder 48
3882 // 5518: }
3883 1, 0, // 5522: case 0x1: {
3884 OPC_SwitchField, 20, 1, // 5524: switch Inst[20] {
3885 0, 10, // 5527: case 0x0: {
3886 OPC_CheckPredicate, 46, // 5529: check predicate 46
3887 OPC_CheckField, 7, 1, 0, // 5531: check Inst[7] == 0x0
3888 OPC_Decode, 167, 120, 48, // 5535: decode to PPAIRE_DB using decoder 48
3889 // 5535: }
3890 1, 0, // 5539: case 0x1: {
3891 OPC_CheckPredicate, 46, // 5541: check predicate 46
3892 OPC_CheckField, 7, 1, 0, // 5543: check Inst[7] == 0x0
3893 OPC_Decode, 196, 118, 48, // 5547: decode to PAS_DHX using decoder 48
3894 // 5547: }
3895 // 5547: } // switch Inst[20]
3896 // 5547: }
3897 // 5547: } // switch Inst[15]
3898 // 5547: }
3899 65, 35, // 5551: case 0x41: {
3900 OPC_SwitchField, 15, 1, // 5553: switch Inst[15] {
3901 0, 14, // 5556: case 0x0: {
3902 OPC_CheckPredicate, 46, // 5558: check predicate 46
3903 OPC_CheckField, 20, 1, 0, // 5560: check Inst[20] == 0x0
3904 OPC_CheckField, 7, 1, 0, // 5564: check Inst[7] == 0x0
3905 OPC_Decode, 175, 118, 48, // 5568: decode to PADD_DW using decoder 48
3906 // 5568: }
3907 1, 0, // 5572: case 0x1: {
3908 OPC_CheckPredicate, 46, // 5574: check predicate 46
3909 OPC_CheckField, 20, 1, 0, // 5576: check Inst[20] == 0x0
3910 OPC_CheckField, 7, 1, 0, // 5580: check Inst[7] == 0x0
3911 OPC_Decode, 168, 120, 48, // 5584: decode to PPAIRE_DH using decoder 48
3912 // 5584: }
3913 // 5584: } // switch Inst[15]
3914 // 5584: }
3915 66, 35, // 5588: case 0x42: {
3916 OPC_SwitchField, 15, 1, // 5590: switch Inst[15] {
3917 0, 14, // 5593: case 0x0: {
3918 OPC_CheckPredicate, 46, // 5595: check predicate 46
3919 OPC_CheckField, 20, 1, 0, // 5597: check Inst[20] == 0x0
3920 OPC_CheckField, 7, 1, 0, // 5601: check Inst[7] == 0x0
3921 OPC_Decode, 171, 118, 48, // 5605: decode to PADD_DB using decoder 48
3922 // 5605: }
3923 1, 0, // 5609: case 0x1: {
3924 OPC_CheckPredicate, 46, // 5611: check predicate 46
3925 OPC_CheckField, 20, 1, 1, // 5613: check Inst[20] == 0x1
3926 OPC_CheckField, 7, 1, 0, // 5617: check Inst[7] == 0x0
3927 OPC_Decode, 216, 120, 48, // 5621: decode to PSA_DHX using decoder 48
3928 // 5621: }
3929 // 5621: } // switch Inst[15]
3930 // 5621: }
3931 67, 18, // 5625: case 0x43: {
3932 OPC_CheckPredicate, 46, // 5627: check predicate 46
3933 OPC_CheckField, 20, 1, 0, // 5629: check Inst[20] == 0x0
3934 OPC_CheckField, 15, 1, 0, // 5633: check Inst[15] == 0x0
3935 OPC_CheckField, 7, 1, 0, // 5637: check Inst[7] == 0x0
3936 OPC_Decode, 158, 107, 48, // 5641: decode to ADDD using decoder 48
3937 // 5641: }
3938 72, 48, // 5645: case 0x48: {
3939 OPC_SwitchField, 15, 1, // 5647: switch Inst[15] {
3940 0, 14, // 5650: case 0x0: {
3941 OPC_CheckPredicate, 46, // 5652: check predicate 46
3942 OPC_CheckField, 20, 1, 0, // 5654: check Inst[20] == 0x0
3943 OPC_CheckField, 7, 1, 0, // 5658: check Inst[7] == 0x0
3944 OPC_Decode, 205, 120, 48, // 5662: decode to PSADD_DH using decoder 48
3945 // 5662: }
3946 1, 0, // 5666: case 0x1: {
3947 OPC_SwitchField, 20, 1, // 5668: switch Inst[20] {
3948 0, 10, // 5671: case 0x0: {
3949 OPC_CheckPredicate, 46, // 5673: check predicate 46
3950 OPC_CheckField, 7, 1, 0, // 5675: check Inst[7] == 0x0
3951 OPC_Decode, 162, 120, 48, // 5679: decode to PPAIREO_DB using decoder 48
3952 // 5679: }
3953 1, 0, // 5683: case 0x1: {
3954 OPC_CheckPredicate, 46, // 5685: check predicate 46
3955 OPC_CheckField, 7, 1, 0, // 5687: check Inst[7] == 0x0
3956 OPC_Decode, 209, 120, 48, // 5691: decode to PSAS_DHX using decoder 48
3957 // 5691: }
3958 // 5691: } // switch Inst[20]
3959 // 5691: }
3960 // 5691: } // switch Inst[15]
3961 // 5691: }
3962 73, 35, // 5695: case 0x49: {
3963 OPC_SwitchField, 15, 1, // 5697: switch Inst[15] {
3964 0, 14, // 5700: case 0x0: {
3965 OPC_CheckPredicate, 46, // 5702: check predicate 46
3966 OPC_CheckField, 20, 1, 0, // 5704: check Inst[20] == 0x0
3967 OPC_CheckField, 7, 1, 0, // 5708: check Inst[7] == 0x0
3968 OPC_Decode, 206, 120, 48, // 5712: decode to PSADD_DW using decoder 48
3969 // 5712: }
3970 1, 0, // 5716: case 0x1: {
3971 OPC_CheckPredicate, 46, // 5718: check predicate 46
3972 OPC_CheckField, 20, 1, 0, // 5720: check Inst[20] == 0x0
3973 OPC_CheckField, 7, 1, 0, // 5724: check Inst[7] == 0x0
3974 OPC_Decode, 163, 120, 48, // 5728: decode to PPAIREO_DH using decoder 48
3975 // 5728: }
3976 // 5728: } // switch Inst[15]
3977 // 5728: }
3978 74, 35, // 5732: case 0x4a: {
3979 OPC_SwitchField, 15, 1, // 5734: switch Inst[15] {
3980 0, 14, // 5737: case 0x0: {
3981 OPC_CheckPredicate, 46, // 5739: check predicate 46
3982 OPC_CheckField, 20, 1, 0, // 5741: check Inst[20] == 0x0
3983 OPC_CheckField, 7, 1, 0, // 5745: check Inst[7] == 0x0
3984 OPC_Decode, 204, 120, 48, // 5749: decode to PSADD_DB using decoder 48
3985 // 5749: }
3986 1, 0, // 5753: case 0x1: {
3987 OPC_CheckPredicate, 46, // 5755: check predicate 46
3988 OPC_CheckField, 20, 1, 1, // 5757: check Inst[20] == 0x1
3989 OPC_CheckField, 7, 1, 0, // 5761: check Inst[7] == 0x0
3990 OPC_Decode, 141, 121, 48, // 5765: decode to PSSA_DHX using decoder 48
3991 // 5765: }
3992 // 5765: } // switch Inst[15]
3993 // 5765: }
3994 76, 35, // 5769: case 0x4c: {
3995 OPC_SwitchField, 15, 1, // 5771: switch Inst[15] {
3996 0, 14, // 5774: case 0x0: {
3997 OPC_CheckPredicate, 46, // 5776: check predicate 46
3998 OPC_CheckField, 20, 1, 0, // 5778: check Inst[20] == 0x0
3999 OPC_CheckField, 7, 1, 0, // 5782: check Inst[7] == 0x0
4000 OPC_Decode, 148, 118, 48, // 5786: decode to PAADD_DH using decoder 48
4001 // 5786: }
4002 1, 0, // 5790: case 0x1: {
4003 OPC_CheckPredicate, 46, // 5792: check predicate 46
4004 OPC_CheckField, 20, 1, 1, // 5794: check Inst[20] == 0x1
4005 OPC_CheckField, 7, 1, 0, // 5798: check Inst[7] == 0x0
4006 OPC_Decode, 152, 118, 48, // 5802: decode to PAAS_DHX using decoder 48
4007 // 5802: }
4008 // 5802: } // switch Inst[15]
4009 // 5802: }
4010 77, 18, // 5806: case 0x4d: {
4011 OPC_CheckPredicate, 46, // 5808: check predicate 46
4012 OPC_CheckField, 20, 1, 0, // 5810: check Inst[20] == 0x0
4013 OPC_CheckField, 15, 1, 0, // 5814: check Inst[15] == 0x0
4014 OPC_CheckField, 7, 1, 0, // 5818: check Inst[7] == 0x0
4015 OPC_Decode, 149, 118, 48, // 5822: decode to PAADD_DW using decoder 48
4016 // 5822: }
4017 78, 35, // 5826: case 0x4e: {
4018 OPC_SwitchField, 15, 1, // 5828: switch Inst[15] {
4019 0, 14, // 5831: case 0x0: {
4020 OPC_CheckPredicate, 46, // 5833: check predicate 46
4021 OPC_CheckField, 20, 1, 0, // 5835: check Inst[20] == 0x0
4022 OPC_CheckField, 7, 1, 0, // 5839: check Inst[7] == 0x0
4023 OPC_Decode, 147, 118, 48, // 5843: decode to PAADD_DB using decoder 48
4024 // 5843: }
4025 1, 0, // 5847: case 0x1: {
4026 OPC_CheckPredicate, 46, // 5849: check predicate 46
4027 OPC_CheckField, 20, 1, 1, // 5851: check Inst[20] == 0x1
4028 OPC_CheckField, 7, 1, 0, // 5855: check Inst[7] == 0x0
4029 OPC_Decode, 181, 118, 48, // 5859: decode to PASA_DHX using decoder 48
4030 // 5859: }
4031 // 5859: } // switch Inst[15]
4032 // 5859: }
4033 80, 35, // 5863: case 0x50: {
4034 OPC_SwitchField, 15, 1, // 5865: switch Inst[15] {
4035 0, 14, // 5868: case 0x0: {
4036 OPC_CheckPredicate, 46, // 5870: check predicate 46
4037 OPC_CheckField, 20, 1, 1, // 5872: check Inst[20] == 0x1
4038 OPC_CheckField, 7, 1, 0, // 5876: check Inst[7] == 0x0
4039 OPC_Decode, 225, 120, 48, // 5880: decode to PSH1ADD_DH using decoder 48
4040 // 5880: }
4041 1, 0, // 5884: case 0x1: {
4042 OPC_CheckPredicate, 46, // 5886: check predicate 46
4043 OPC_CheckField, 20, 1, 0, // 5888: check Inst[20] == 0x0
4044 OPC_CheckField, 7, 1, 0, // 5892: check Inst[7] == 0x0
4045 OPC_Decode, 171, 120, 48, // 5896: decode to PPAIROE_DB using decoder 48
4046 // 5896: }
4047 // 5896: } // switch Inst[15]
4048 // 5896: }
4049 81, 35, // 5900: case 0x51: {
4050 OPC_SwitchField, 15, 1, // 5902: switch Inst[15] {
4051 0, 14, // 5905: case 0x0: {
4052 OPC_CheckPredicate, 46, // 5907: check predicate 46
4053 OPC_CheckField, 20, 1, 1, // 5909: check Inst[20] == 0x1
4054 OPC_CheckField, 7, 1, 0, // 5913: check Inst[7] == 0x0
4055 OPC_Decode, 226, 120, 48, // 5917: decode to PSH1ADD_DW using decoder 48
4056 // 5917: }
4057 1, 0, // 5921: case 0x1: {
4058 OPC_CheckPredicate, 46, // 5923: check predicate 46
4059 OPC_CheckField, 20, 1, 0, // 5925: check Inst[20] == 0x0
4060 OPC_CheckField, 7, 1, 0, // 5929: check Inst[7] == 0x0
4061 OPC_Decode, 172, 120, 48, // 5933: decode to PPAIROE_DH using decoder 48
4062 // 5933: }
4063 // 5933: } // switch Inst[15]
4064 // 5933: }
4065 88, 48, // 5937: case 0x58: {
4066 OPC_SwitchField, 15, 1, // 5939: switch Inst[15] {
4067 0, 27, // 5942: case 0x0: {
4068 OPC_SwitchField, 20, 1, // 5944: switch Inst[20] {
4069 0, 10, // 5947: case 0x0: {
4070 OPC_CheckPredicate, 46, // 5949: check predicate 46
4071 OPC_CheckField, 7, 1, 0, // 5951: check Inst[7] == 0x0
4072 OPC_Decode, 199, 120, 48, // 5955: decode to PSADDU_DH using decoder 48
4073 // 5955: }
4074 1, 0, // 5959: case 0x1: {
4075 OPC_CheckPredicate, 46, // 5961: check predicate 46
4076 OPC_CheckField, 7, 1, 0, // 5963: check Inst[7] == 0x0
4077 OPC_Decode, 144, 121, 48, // 5967: decode to PSSH1SADD_DH using decoder 48
4078 // 5967: }
4079 // 5967: } // switch Inst[20]
4080 // 5967: }
4081 1, 0, // 5971: case 0x1: {
4082 OPC_CheckPredicate, 46, // 5973: check predicate 46
4083 OPC_CheckField, 20, 1, 0, // 5975: check Inst[20] == 0x0
4084 OPC_CheckField, 7, 1, 0, // 5979: check Inst[7] == 0x0
4085 OPC_Decode, 176, 120, 48, // 5983: decode to PPAIRO_DB using decoder 48
4086 // 5983: }
4087 // 5983: } // switch Inst[15]
4088 // 5983: }
4089 89, 48, // 5987: case 0x59: {
4090 OPC_SwitchField, 15, 1, // 5989: switch Inst[15] {
4091 0, 27, // 5992: case 0x0: {
4092 OPC_SwitchField, 20, 1, // 5994: switch Inst[20] {
4093 0, 10, // 5997: case 0x0: {
4094 OPC_CheckPredicate, 46, // 5999: check predicate 46
4095 OPC_CheckField, 7, 1, 0, // 6001: check Inst[7] == 0x0
4096 OPC_Decode, 200, 120, 48, // 6005: decode to PSADDU_DW using decoder 48
4097 // 6005: }
4098 1, 0, // 6009: case 0x1: {
4099 OPC_CheckPredicate, 46, // 6011: check predicate 46
4100 OPC_CheckField, 7, 1, 0, // 6013: check Inst[7] == 0x0
4101 OPC_Decode, 145, 121, 48, // 6017: decode to PSSH1SADD_DW using decoder 48
4102 // 6017: }
4103 // 6017: } // switch Inst[20]
4104 // 6017: }
4105 1, 0, // 6021: case 0x1: {
4106 OPC_CheckPredicate, 46, // 6023: check predicate 46
4107 OPC_CheckField, 20, 1, 0, // 6025: check Inst[20] == 0x0
4108 OPC_CheckField, 7, 1, 0, // 6029: check Inst[7] == 0x0
4109 OPC_Decode, 177, 120, 48, // 6033: decode to PPAIRO_DH using decoder 48
4110 // 6033: }
4111 // 6033: } // switch Inst[15]
4112 // 6033: }
4113 90, 18, // 6037: case 0x5a: {
4114 OPC_CheckPredicate, 46, // 6039: check predicate 46
4115 OPC_CheckField, 20, 1, 0, // 6041: check Inst[20] == 0x0
4116 OPC_CheckField, 15, 1, 0, // 6045: check Inst[15] == 0x0
4117 OPC_CheckField, 7, 1, 0, // 6049: check Inst[7] == 0x0
4118 OPC_Decode, 198, 120, 48, // 6053: decode to PSADDU_DB using decoder 48
4119 // 6053: }
4120 92, 18, // 6057: case 0x5c: {
4121 OPC_CheckPredicate, 46, // 6059: check predicate 46
4122 OPC_CheckField, 20, 1, 0, // 6061: check Inst[20] == 0x0
4123 OPC_CheckField, 15, 1, 0, // 6065: check Inst[15] == 0x0
4124 OPC_CheckField, 7, 1, 0, // 6069: check Inst[7] == 0x0
4125 OPC_Decode, 142, 118, 48, // 6073: decode to PAADDU_DH using decoder 48
4126 // 6073: }
4127 93, 18, // 6077: case 0x5d: {
4128 OPC_CheckPredicate, 46, // 6079: check predicate 46
4129 OPC_CheckField, 20, 1, 0, // 6081: check Inst[20] == 0x0
4130 OPC_CheckField, 15, 1, 0, // 6085: check Inst[15] == 0x0
4131 OPC_CheckField, 7, 1, 0, // 6089: check Inst[7] == 0x0
4132 OPC_Decode, 143, 118, 48, // 6093: decode to PAADDU_DW using decoder 48
4133 // 6093: }
4134 94, 18, // 6097: case 0x5e: {
4135 OPC_CheckPredicate, 46, // 6099: check predicate 46
4136 OPC_CheckField, 20, 1, 0, // 6101: check Inst[20] == 0x0
4137 OPC_CheckField, 15, 1, 0, // 6105: check Inst[15] == 0x0
4138 OPC_CheckField, 7, 1, 0, // 6109: check Inst[7] == 0x0
4139 OPC_Decode, 141, 118, 48, // 6113: decode to PAADDU_DB using decoder 48
4140 // 6113: }
4141 96, 35, // 6117: case 0x60: {
4142 OPC_SwitchField, 15, 1, // 6119: switch Inst[15] {
4143 0, 14, // 6122: case 0x0: {
4144 OPC_CheckPredicate, 46, // 6124: check predicate 46
4145 OPC_CheckField, 20, 1, 0, // 6126: check Inst[20] == 0x0
4146 OPC_CheckField, 7, 1, 0, // 6130: check Inst[7] == 0x0
4147 OPC_Decode, 182, 121, 48, // 6134: decode to PSUB_DH using decoder 48
4148 // 6134: }
4149 1, 0, // 6138: case 0x1: {
4150 OPC_CheckPredicate, 46, // 6140: check predicate 46
4151 OPC_CheckField, 20, 1, 1, // 6142: check Inst[20] == 0x1
4152 OPC_CheckField, 7, 1, 0, // 6146: check Inst[7] == 0x0
4153 OPC_Decode, 199, 119, 48, // 6150: decode to PMSEQ_DH using decoder 48
4154 // 6150: }
4155 // 6150: } // switch Inst[15]
4156 // 6150: }
4157 97, 35, // 6154: case 0x61: {
4158 OPC_SwitchField, 15, 1, // 6156: switch Inst[15] {
4159 0, 14, // 6159: case 0x0: {
4160 OPC_CheckPredicate, 46, // 6161: check predicate 46
4161 OPC_CheckField, 20, 1, 0, // 6163: check Inst[20] == 0x0
4162 OPC_CheckField, 7, 1, 0, // 6167: check Inst[7] == 0x0
4163 OPC_Decode, 183, 121, 48, // 6171: decode to PSUB_DW using decoder 48
4164 // 6171: }
4165 1, 0, // 6175: case 0x1: {
4166 OPC_CheckPredicate, 46, // 6177: check predicate 46
4167 OPC_CheckField, 20, 1, 1, // 6179: check Inst[20] == 0x1
4168 OPC_CheckField, 7, 1, 0, // 6183: check Inst[7] == 0x0
4169 OPC_Decode, 200, 119, 48, // 6187: decode to PMSEQ_DW using decoder 48
4170 // 6187: }
4171 // 6187: } // switch Inst[15]
4172 // 6187: }
4173 98, 35, // 6191: case 0x62: {
4174 OPC_SwitchField, 15, 1, // 6193: switch Inst[15] {
4175 0, 14, // 6196: case 0x0: {
4176 OPC_CheckPredicate, 46, // 6198: check predicate 46
4177 OPC_CheckField, 20, 1, 0, // 6200: check Inst[20] == 0x0
4178 OPC_CheckField, 7, 1, 0, // 6204: check Inst[7] == 0x0
4179 OPC_Decode, 181, 121, 48, // 6208: decode to PSUB_DB using decoder 48
4180 // 6208: }
4181 1, 0, // 6212: case 0x1: {
4182 OPC_CheckPredicate, 46, // 6214: check predicate 46
4183 OPC_CheckField, 20, 1, 1, // 6216: check Inst[20] == 0x1
4184 OPC_CheckField, 7, 1, 0, // 6220: check Inst[7] == 0x0
4185 OPC_Decode, 198, 119, 48, // 6224: decode to PMSEQ_DB using decoder 48
4186 // 6224: }
4187 // 6224: } // switch Inst[15]
4188 // 6224: }
4189 99, 18, // 6228: case 0x63: {
4190 OPC_CheckPredicate, 46, // 6230: check predicate 46
4191 OPC_CheckField, 20, 1, 0, // 6232: check Inst[20] == 0x0
4192 OPC_CheckField, 15, 1, 0, // 6236: check Inst[15] == 0x0
4193 OPC_CheckField, 7, 1, 0, // 6240: check Inst[7] == 0x0
4194 OPC_Decode, 203, 124, 48, // 6244: decode to SUBD using decoder 48
4195 // 6244: }
4196 100, 18, // 6248: case 0x64: {
4197 OPC_CheckPredicate, 46, // 6250: check predicate 46
4198 OPC_CheckField, 20, 1, 0, // 6252: check Inst[20] == 0x0
4199 OPC_CheckField, 15, 1, 0, // 6256: check Inst[15] == 0x0
4200 OPC_CheckField, 7, 1, 0, // 6260: check Inst[7] == 0x0
4201 OPC_Decode, 163, 118, 48, // 6264: decode to PABD_DH using decoder 48
4202 // 6264: }
4203 102, 18, // 6268: case 0x66: {
4204 OPC_CheckPredicate, 46, // 6270: check predicate 46
4205 OPC_CheckField, 20, 1, 0, // 6272: check Inst[20] == 0x0
4206 OPC_CheckField, 15, 1, 0, // 6276: check Inst[15] == 0x0
4207 OPC_CheckField, 7, 1, 0, // 6280: check Inst[7] == 0x0
4208 OPC_Decode, 162, 118, 48, // 6284: decode to PABD_DB using decoder 48
4209 // 6284: }
4210 104, 35, // 6288: case 0x68: {
4211 OPC_SwitchField, 15, 1, // 6290: switch Inst[15] {
4212 0, 14, // 6293: case 0x0: {
4213 OPC_CheckPredicate, 46, // 6295: check predicate 46
4214 OPC_CheckField, 20, 1, 0, // 6297: check Inst[20] == 0x0
4215 OPC_CheckField, 7, 1, 0, // 6301: check Inst[7] == 0x0
4216 OPC_Decode, 176, 121, 48, // 6305: decode to PSSUB_DH using decoder 48
4217 // 6305: }
4218 1, 0, // 6309: case 0x1: {
4219 OPC_CheckPredicate, 46, // 6311: check predicate 46
4220 OPC_CheckField, 20, 1, 1, // 6313: check Inst[20] == 0x1
4221 OPC_CheckField, 7, 1, 0, // 6317: check Inst[7] == 0x0
4222 OPC_Decode, 211, 119, 48, // 6321: decode to PMSLT_DH using decoder 48
4223 // 6321: }
4224 // 6321: } // switch Inst[15]
4225 // 6321: }
4226 105, 35, // 6325: case 0x69: {
4227 OPC_SwitchField, 15, 1, // 6327: switch Inst[15] {
4228 0, 14, // 6330: case 0x0: {
4229 OPC_CheckPredicate, 46, // 6332: check predicate 46
4230 OPC_CheckField, 20, 1, 0, // 6334: check Inst[20] == 0x0
4231 OPC_CheckField, 7, 1, 0, // 6338: check Inst[7] == 0x0
4232 OPC_Decode, 177, 121, 48, // 6342: decode to PSSUB_DW using decoder 48
4233 // 6342: }
4234 1, 0, // 6346: case 0x1: {
4235 OPC_CheckPredicate, 46, // 6348: check predicate 46
4236 OPC_CheckField, 20, 1, 1, // 6350: check Inst[20] == 0x1
4237 OPC_CheckField, 7, 1, 0, // 6354: check Inst[7] == 0x0
4238 OPC_Decode, 212, 119, 48, // 6358: decode to PMSLT_DW using decoder 48
4239 // 6358: }
4240 // 6358: } // switch Inst[15]
4241 // 6358: }
4242 106, 35, // 6362: case 0x6a: {
4243 OPC_SwitchField, 15, 1, // 6364: switch Inst[15] {
4244 0, 14, // 6367: case 0x0: {
4245 OPC_CheckPredicate, 46, // 6369: check predicate 46
4246 OPC_CheckField, 20, 1, 0, // 6371: check Inst[20] == 0x0
4247 OPC_CheckField, 7, 1, 0, // 6375: check Inst[7] == 0x0
4248 OPC_Decode, 175, 121, 48, // 6379: decode to PSSUB_DB using decoder 48
4249 // 6379: }
4250 1, 0, // 6383: case 0x1: {
4251 OPC_CheckPredicate, 46, // 6385: check predicate 46
4252 OPC_CheckField, 20, 1, 1, // 6387: check Inst[20] == 0x1
4253 OPC_CheckField, 7, 1, 0, // 6391: check Inst[7] == 0x0
4254 OPC_Decode, 210, 119, 48, // 6395: decode to PMSLT_DB using decoder 48
4255 // 6395: }
4256 // 6395: } // switch Inst[15]
4257 // 6395: }
4258 108, 35, // 6399: case 0x6c: {
4259 OPC_SwitchField, 15, 1, // 6401: switch Inst[15] {
4260 0, 14, // 6404: case 0x0: {
4261 OPC_CheckPredicate, 46, // 6406: check predicate 46
4262 OPC_CheckField, 20, 1, 0, // 6408: check Inst[20] == 0x0
4263 OPC_CheckField, 7, 1, 0, // 6412: check Inst[7] == 0x0
4264 OPC_Decode, 192, 118, 48, // 6416: decode to PASUB_DH using decoder 48
4265 // 6416: }
4266 1, 0, // 6420: case 0x1: {
4267 OPC_CheckPredicate, 46, // 6422: check predicate 46
4268 OPC_CheckField, 20, 1, 1, // 6424: check Inst[20] == 0x1
4269 OPC_CheckField, 7, 1, 0, // 6428: check Inst[7] == 0x0
4270 OPC_Decode, 205, 119, 48, // 6432: decode to PMSLTU_DH using decoder 48
4271 // 6432: }
4272 // 6432: } // switch Inst[15]
4273 // 6432: }
4274 109, 35, // 6436: case 0x6d: {
4275 OPC_SwitchField, 15, 1, // 6438: switch Inst[15] {
4276 0, 14, // 6441: case 0x0: {
4277 OPC_CheckPredicate, 46, // 6443: check predicate 46
4278 OPC_CheckField, 20, 1, 0, // 6445: check Inst[20] == 0x0
4279 OPC_CheckField, 7, 1, 0, // 6449: check Inst[7] == 0x0
4280 OPC_Decode, 193, 118, 48, // 6453: decode to PASUB_DW using decoder 48
4281 // 6453: }
4282 1, 0, // 6457: case 0x1: {
4283 OPC_CheckPredicate, 46, // 6459: check predicate 46
4284 OPC_CheckField, 20, 1, 1, // 6461: check Inst[20] == 0x1
4285 OPC_CheckField, 7, 1, 0, // 6465: check Inst[7] == 0x0
4286 OPC_Decode, 206, 119, 48, // 6469: decode to PMSLTU_DW using decoder 48
4287 // 6469: }
4288 // 6469: } // switch Inst[15]
4289 // 6469: }
4290 110, 35, // 6473: case 0x6e: {
4291 OPC_SwitchField, 15, 1, // 6475: switch Inst[15] {
4292 0, 14, // 6478: case 0x0: {
4293 OPC_CheckPredicate, 46, // 6480: check predicate 46
4294 OPC_CheckField, 20, 1, 0, // 6482: check Inst[20] == 0x0
4295 OPC_CheckField, 7, 1, 0, // 6486: check Inst[7] == 0x0
4296 OPC_Decode, 191, 118, 48, // 6490: decode to PASUB_DB using decoder 48
4297 // 6490: }
4298 1, 0, // 6494: case 0x1: {
4299 OPC_CheckPredicate, 46, // 6496: check predicate 46
4300 OPC_CheckField, 20, 1, 1, // 6498: check Inst[20] == 0x1
4301 OPC_CheckField, 7, 1, 0, // 6502: check Inst[7] == 0x0
4302 OPC_Decode, 204, 119, 48, // 6506: decode to PMSLTU_DB using decoder 48
4303 // 6506: }
4304 // 6506: } // switch Inst[15]
4305 // 6506: }
4306 112, 18, // 6510: case 0x70: {
4307 OPC_CheckPredicate, 46, // 6512: check predicate 46
4308 OPC_CheckField, 20, 1, 1, // 6514: check Inst[20] == 0x1
4309 OPC_CheckField, 15, 1, 1, // 6518: check Inst[15] == 0x1
4310 OPC_CheckField, 7, 1, 0, // 6522: check Inst[7] == 0x0
4311 OPC_Decode, 177, 119, 48, // 6526: decode to PMIN_DH using decoder 48
4312 // 6526: }
4313 113, 18, // 6530: case 0x71: {
4314 OPC_CheckPredicate, 46, // 6532: check predicate 46
4315 OPC_CheckField, 20, 1, 1, // 6534: check Inst[20] == 0x1
4316 OPC_CheckField, 15, 1, 1, // 6538: check Inst[15] == 0x1
4317 OPC_CheckField, 7, 1, 0, // 6542: check Inst[7] == 0x0
4318 OPC_Decode, 178, 119, 48, // 6546: decode to PMIN_DW using decoder 48
4319 // 6546: }
4320 114, 18, // 6550: case 0x72: {
4321 OPC_CheckPredicate, 46, // 6552: check predicate 46
4322 OPC_CheckField, 20, 1, 1, // 6554: check Inst[20] == 0x1
4323 OPC_CheckField, 15, 1, 1, // 6558: check Inst[15] == 0x1
4324 OPC_CheckField, 7, 1, 0, // 6562: check Inst[7] == 0x0
4325 OPC_Decode, 176, 119, 48, // 6566: decode to PMIN_DB using decoder 48
4326 // 6566: }
4327 116, 35, // 6570: case 0x74: {
4328 OPC_SwitchField, 15, 1, // 6572: switch Inst[15] {
4329 0, 14, // 6575: case 0x0: {
4330 OPC_CheckPredicate, 46, // 6577: check predicate 46
4331 OPC_CheckField, 20, 1, 0, // 6579: check Inst[20] == 0x0
4332 OPC_CheckField, 7, 1, 0, // 6583: check Inst[7] == 0x0
4333 OPC_Decode, 159, 118, 48, // 6587: decode to PABDU_DH using decoder 48
4334 // 6587: }
4335 1, 0, // 6591: case 0x1: {
4336 OPC_CheckPredicate, 46, // 6593: check predicate 46
4337 OPC_CheckField, 20, 1, 1, // 6595: check Inst[20] == 0x1
4338 OPC_CheckField, 7, 1, 0, // 6599: check Inst[7] == 0x0
4339 OPC_Decode, 171, 119, 48, // 6603: decode to PMINU_DH using decoder 48
4340 // 6603: }
4341 // 6603: } // switch Inst[15]
4342 // 6603: }
4343 117, 18, // 6607: case 0x75: {
4344 OPC_CheckPredicate, 46, // 6609: check predicate 46
4345 OPC_CheckField, 20, 1, 1, // 6611: check Inst[20] == 0x1
4346 OPC_CheckField, 15, 1, 1, // 6615: check Inst[15] == 0x1
4347 OPC_CheckField, 7, 1, 0, // 6619: check Inst[7] == 0x0
4348 OPC_Decode, 172, 119, 48, // 6623: decode to PMINU_DW using decoder 48
4349 // 6623: }
4350 118, 35, // 6627: case 0x76: {
4351 OPC_SwitchField, 15, 1, // 6629: switch Inst[15] {
4352 0, 14, // 6632: case 0x0: {
4353 OPC_CheckPredicate, 46, // 6634: check predicate 46
4354 OPC_CheckField, 20, 1, 0, // 6636: check Inst[20] == 0x0
4355 OPC_CheckField, 7, 1, 0, // 6640: check Inst[7] == 0x0
4356 OPC_Decode, 158, 118, 48, // 6644: decode to PABDU_DB using decoder 48
4357 // 6644: }
4358 1, 0, // 6648: case 0x1: {
4359 OPC_CheckPredicate, 46, // 6650: check predicate 46
4360 OPC_CheckField, 20, 1, 1, // 6652: check Inst[20] == 0x1
4361 OPC_CheckField, 7, 1, 0, // 6656: check Inst[7] == 0x0
4362 OPC_Decode, 170, 119, 48, // 6660: decode to PMINU_DB using decoder 48
4363 // 6660: }
4364 // 6660: } // switch Inst[15]
4365 // 6660: }
4366 120, 35, // 6664: case 0x78: {
4367 OPC_SwitchField, 15, 1, // 6666: switch Inst[15] {
4368 0, 14, // 6669: case 0x0: {
4369 OPC_CheckPredicate, 46, // 6671: check predicate 46
4370 OPC_CheckField, 20, 1, 0, // 6673: check Inst[20] == 0x0
4371 OPC_CheckField, 7, 1, 0, // 6677: check Inst[7] == 0x0
4372 OPC_Decode, 170, 121, 48, // 6681: decode to PSSUBU_DH using decoder 48
4373 // 6681: }
4374 1, 0, // 6685: case 0x1: {
4375 OPC_CheckPredicate, 46, // 6687: check predicate 46
4376 OPC_CheckField, 20, 1, 1, // 6689: check Inst[20] == 0x1
4377 OPC_CheckField, 7, 1, 0, // 6693: check Inst[7] == 0x0
4378 OPC_Decode, 145, 119, 48, // 6697: decode to PMAX_DH using decoder 48
4379 // 6697: }
4380 // 6697: } // switch Inst[15]
4381 // 6697: }
4382 121, 35, // 6701: case 0x79: {
4383 OPC_SwitchField, 15, 1, // 6703: switch Inst[15] {
4384 0, 14, // 6706: case 0x0: {
4385 OPC_CheckPredicate, 46, // 6708: check predicate 46
4386 OPC_CheckField, 20, 1, 0, // 6710: check Inst[20] == 0x0
4387 OPC_CheckField, 7, 1, 0, // 6714: check Inst[7] == 0x0
4388 OPC_Decode, 171, 121, 48, // 6718: decode to PSSUBU_DW using decoder 48
4389 // 6718: }
4390 1, 0, // 6722: case 0x1: {
4391 OPC_CheckPredicate, 46, // 6724: check predicate 46
4392 OPC_CheckField, 20, 1, 1, // 6726: check Inst[20] == 0x1
4393 OPC_CheckField, 7, 1, 0, // 6730: check Inst[7] == 0x0
4394 OPC_Decode, 146, 119, 48, // 6734: decode to PMAX_DW using decoder 48
4395 // 6734: }
4396 // 6734: } // switch Inst[15]
4397 // 6734: }
4398 122, 35, // 6738: case 0x7a: {
4399 OPC_SwitchField, 15, 1, // 6740: switch Inst[15] {
4400 0, 14, // 6743: case 0x0: {
4401 OPC_CheckPredicate, 46, // 6745: check predicate 46
4402 OPC_CheckField, 20, 1, 0, // 6747: check Inst[20] == 0x0
4403 OPC_CheckField, 7, 1, 0, // 6751: check Inst[7] == 0x0
4404 OPC_Decode, 169, 121, 48, // 6755: decode to PSSUBU_DB using decoder 48
4405 // 6755: }
4406 1, 0, // 6759: case 0x1: {
4407 OPC_CheckPredicate, 46, // 6761: check predicate 46
4408 OPC_CheckField, 20, 1, 1, // 6763: check Inst[20] == 0x1
4409 OPC_CheckField, 7, 1, 0, // 6767: check Inst[7] == 0x0
4410 OPC_Decode, 144, 119, 48, // 6771: decode to PMAX_DB using decoder 48
4411 // 6771: }
4412 // 6771: } // switch Inst[15]
4413 // 6771: }
4414 124, 35, // 6775: case 0x7c: {
4415 OPC_SwitchField, 15, 1, // 6777: switch Inst[15] {
4416 0, 14, // 6780: case 0x0: {
4417 OPC_CheckPredicate, 46, // 6782: check predicate 46
4418 OPC_CheckField, 20, 1, 0, // 6784: check Inst[20] == 0x0
4419 OPC_CheckField, 7, 1, 0, // 6788: check Inst[7] == 0x0
4420 OPC_Decode, 186, 118, 48, // 6792: decode to PASUBU_DH using decoder 48
4421 // 6792: }
4422 1, 0, // 6796: case 0x1: {
4423 OPC_CheckPredicate, 46, // 6798: check predicate 46
4424 OPC_CheckField, 20, 1, 1, // 6800: check Inst[20] == 0x1
4425 OPC_CheckField, 7, 1, 0, // 6804: check Inst[7] == 0x0
4426 OPC_Decode, 139, 119, 48, // 6808: decode to PMAXU_DH using decoder 48
4427 // 6808: }
4428 // 6808: } // switch Inst[15]
4429 // 6808: }
4430 125, 35, // 6812: case 0x7d: {
4431 OPC_SwitchField, 15, 1, // 6814: switch Inst[15] {
4432 0, 14, // 6817: case 0x0: {
4433 OPC_CheckPredicate, 46, // 6819: check predicate 46
4434 OPC_CheckField, 20, 1, 0, // 6821: check Inst[20] == 0x0
4435 OPC_CheckField, 7, 1, 0, // 6825: check Inst[7] == 0x0
4436 OPC_Decode, 187, 118, 48, // 6829: decode to PASUBU_DW using decoder 48
4437 // 6829: }
4438 1, 0, // 6833: case 0x1: {
4439 OPC_CheckPredicate, 46, // 6835: check predicate 46
4440 OPC_CheckField, 20, 1, 1, // 6837: check Inst[20] == 0x1
4441 OPC_CheckField, 7, 1, 0, // 6841: check Inst[7] == 0x0
4442 OPC_Decode, 140, 119, 48, // 6845: decode to PMAXU_DW using decoder 48
4443 // 6845: }
4444 // 6845: } // switch Inst[15]
4445 // 6845: }
4446 126, 0, // 6849: case 0x7e: {
4447 OPC_SwitchField, 15, 1, // 6851: switch Inst[15] {
4448 0, 14, // 6854: case 0x0: {
4449 OPC_CheckPredicate, 46, // 6856: check predicate 46
4450 OPC_CheckField, 20, 1, 0, // 6858: check Inst[20] == 0x0
4451 OPC_CheckField, 7, 1, 0, // 6862: check Inst[7] == 0x0
4452 OPC_Decode, 185, 118, 48, // 6866: decode to PASUBU_DB using decoder 48
4453 // 6866: }
4454 1, 0, // 6870: case 0x1: {
4455 OPC_CheckPredicate, 46, // 6872: check predicate 46
4456 OPC_CheckField, 20, 1, 1, // 6874: check Inst[20] == 0x1
4457 OPC_CheckField, 7, 1, 0, // 6878: check Inst[7] == 0x0
4458 OPC_Decode, 138, 119, 48, // 6882: decode to PMAXU_DB using decoder 48
4459 // 6882: }
4460 // 6882: } // switch Inst[15]
4461 // 6882: }
4462 // 6882: } // switch Inst[31:25]
4463 // 6882: }
4464 // 6882: } // switch Inst[14:12]
4465 // 6882: }
4466 35, 29, // 6886: case 0x23: {
4467 OPC_SwitchField, 12, 3, // 6888: switch Inst[14:12] {
4468 0, 4, // 6891: case 0x0: {
4469 OPC_Decode, 150, 123, 49, // 6893: decode to SB using decoder 49
4470 // 6893: }
4471 1, 4, // 6897: case 0x1: {
4472 OPC_Decode, 239, 123, 49, // 6899: decode to SH using decoder 49
4473 // 6899: }
4474 2, 4, // 6903: case 0x2: {
4475 OPC_Decode, 205, 124, 49, // 6905: decode to SW using decoder 49
4476 // 6905: }
4477 3, 0, // 6909: case 0x3: {
4478 OPC_CheckPredicate, 21, // 6911: check predicate 21
4479 OPC_Decode, 162, 123, 49, // 6913: decode to SD using decoder 49
4480 // 6913: }
4481 // 6913: } // switch Inst[14:12]
4482 // 6913: }
4483 39, 165, 11, // 6917: case 0x27: {
4484 OPC_SwitchField, 12, 3, // 6920: switch Inst[14:12] {
4485 0, 136, 3, // 6923: case 0x0: {
4486 OPC_SwitchField, 26, 6, // 6926: switch Inst[31:26] {
4487 0, 38, // 6929: case 0x0: {
4488 OPC_SwitchField, 20, 5, // 6931: switch Inst[24:20] {
4489 0, 7, // 6934: case 0x0: {
4490 OPC_CheckPredicate, 22, // 6936: check predicate 22
4491 OPC_Decode, 227, 129, 1, 1, // 6938: decode to VSE8_V using decoder 1
4492 // 6938: }
4493 8, 11, // 6943: case 0x8: {
4494 OPC_CheckPredicate, 22, // 6945: check predicate 22
4495 OPC_CheckField, 25, 1, 1, // 6947: check Inst[25] == 0x1
4496 OPC_Decode, 212, 129, 1, 2, // 6951: decode to VS1R_V using decoder 2
4497 // 6951: }
4498 11, 0, // 6956: case 0xb: {
4499 OPC_CheckPredicate, 22, // 6958: check predicate 22
4500 OPC_CheckField, 25, 1, 1, // 6960: check Inst[25] == 0x1
4501 OPC_Decode, 253, 129, 1, 2, // 6964: decode to VSM_V using decoder 2
4502 // 6964: }
4503 // 6964: } // switch Inst[24:20]
4504 // 6964: }
4505 1, 7, // 6969: case 0x1: {
4506 OPC_CheckPredicate, 22, // 6971: check predicate 22
4507 OPC_Decode, 239, 130, 1, 3, // 6973: decode to VSUXEI8_V using decoder 3
4508 // 6973: }
4509 2, 7, // 6978: case 0x2: {
4510 OPC_CheckPredicate, 22, // 6980: check predicate 22
4511 OPC_Decode, 167, 130, 1, 4, // 6982: decode to VSSE8_V using decoder 4
4512 // 6982: }
4513 3, 7, // 6987: case 0x3: {
4514 OPC_CheckPredicate, 22, // 6989: check predicate 22
4515 OPC_Decode, 129, 130, 1, 3, // 6991: decode to VSOXEI8_V using decoder 3
4516 // 6991: }
4517 8, 25, // 6996: case 0x8: {
4518 OPC_SwitchField, 20, 5, // 6998: switch Inst[24:20] {
4519 0, 7, // 7001: case 0x0: {
4520 OPC_CheckPredicate, 22, // 7003: check predicate 22
4521 OPC_Decode, 171, 130, 1, 1, // 7005: decode to VSSEG2E8_V using decoder 1
4522 // 7005: }
4523 8, 0, // 7010: case 0x8: {
4524 OPC_CheckPredicate, 22, // 7012: check predicate 22
4525 OPC_CheckField, 25, 1, 1, // 7014: check Inst[25] == 0x1
4526 OPC_Decode, 213, 129, 1, 5, // 7018: decode to VS2R_V using decoder 5
4527 // 7018: }
4528 // 7018: } // switch Inst[24:20]
4529 // 7018: }
4530 9, 7, // 7023: case 0x9: {
4531 OPC_CheckPredicate, 22, // 7025: check predicate 22
4532 OPC_Decode, 243, 130, 1, 3, // 7027: decode to VSUXSEG2EI8_V using decoder 3
4533 // 7027: }
4534 10, 7, // 7032: case 0xa: {
4535 OPC_CheckPredicate, 22, // 7034: check predicate 22
4536 OPC_Decode, 205, 130, 1, 4, // 7036: decode to VSSSEG2E8_V using decoder 4
4537 // 7036: }
4538 11, 7, // 7041: case 0xb: {
4539 OPC_CheckPredicate, 22, // 7043: check predicate 22
4540 OPC_Decode, 133, 130, 1, 3, // 7045: decode to VSOXSEG2EI8_V using decoder 3
4541 // 7045: }
4542 16, 11, // 7050: case 0x10: {
4543 OPC_CheckPredicate, 22, // 7052: check predicate 22
4544 OPC_CheckField, 20, 5, 0, // 7054: check Inst[24:20] == 0x0
4545 OPC_Decode, 175, 130, 1, 1, // 7058: decode to VSSEG3E8_V using decoder 1
4546 // 7058: }
4547 17, 7, // 7063: case 0x11: {
4548 OPC_CheckPredicate, 22, // 7065: check predicate 22
4549 OPC_Decode, 247, 130, 1, 3, // 7067: decode to VSUXSEG3EI8_V using decoder 3
4550 // 7067: }
4551 18, 7, // 7072: case 0x12: {
4552 OPC_CheckPredicate, 22, // 7074: check predicate 22
4553 OPC_Decode, 209, 130, 1, 4, // 7076: decode to VSSSEG3E8_V using decoder 4
4554 // 7076: }
4555 19, 7, // 7081: case 0x13: {
4556 OPC_CheckPredicate, 22, // 7083: check predicate 22
4557 OPC_Decode, 137, 130, 1, 3, // 7085: decode to VSOXSEG3EI8_V using decoder 3
4558 // 7085: }
4559 24, 25, // 7090: case 0x18: {
4560 OPC_SwitchField, 20, 5, // 7092: switch Inst[24:20] {
4561 0, 7, // 7095: case 0x0: {
4562 OPC_CheckPredicate, 22, // 7097: check predicate 22
4563 OPC_Decode, 179, 130, 1, 1, // 7099: decode to VSSEG4E8_V using decoder 1
4564 // 7099: }
4565 8, 0, // 7104: case 0x8: {
4566 OPC_CheckPredicate, 22, // 7106: check predicate 22
4567 OPC_CheckField, 25, 1, 1, // 7108: check Inst[25] == 0x1
4568 OPC_Decode, 214, 129, 1, 6, // 7112: decode to VS4R_V using decoder 6
4569 // 7112: }
4570 // 7112: } // switch Inst[24:20]
4571 // 7112: }
4572 25, 7, // 7117: case 0x19: {
4573 OPC_CheckPredicate, 22, // 7119: check predicate 22
4574 OPC_Decode, 251, 130, 1, 3, // 7121: decode to VSUXSEG4EI8_V using decoder 3
4575 // 7121: }
4576 26, 7, // 7126: case 0x1a: {
4577 OPC_CheckPredicate, 22, // 7128: check predicate 22
4578 OPC_Decode, 213, 130, 1, 4, // 7130: decode to VSSSEG4E8_V using decoder 4
4579 // 7130: }
4580 27, 7, // 7135: case 0x1b: {
4581 OPC_CheckPredicate, 22, // 7137: check predicate 22
4582 OPC_Decode, 141, 130, 1, 3, // 7139: decode to VSOXSEG4EI8_V using decoder 3
4583 // 7139: }
4584 32, 11, // 7144: case 0x20: {
4585 OPC_CheckPredicate, 22, // 7146: check predicate 22
4586 OPC_CheckField, 20, 5, 0, // 7148: check Inst[24:20] == 0x0
4587 OPC_Decode, 183, 130, 1, 1, // 7152: decode to VSSEG5E8_V using decoder 1
4588 // 7152: }
4589 33, 7, // 7157: case 0x21: {
4590 OPC_CheckPredicate, 22, // 7159: check predicate 22
4591 OPC_Decode, 255, 130, 1, 3, // 7161: decode to VSUXSEG5EI8_V using decoder 3
4592 // 7161: }
4593 34, 7, // 7166: case 0x22: {
4594 OPC_CheckPredicate, 22, // 7168: check predicate 22
4595 OPC_Decode, 217, 130, 1, 4, // 7170: decode to VSSSEG5E8_V using decoder 4
4596 // 7170: }
4597 35, 7, // 7175: case 0x23: {
4598 OPC_CheckPredicate, 22, // 7177: check predicate 22
4599 OPC_Decode, 145, 130, 1, 3, // 7179: decode to VSOXSEG5EI8_V using decoder 3
4600 // 7179: }
4601 40, 11, // 7184: case 0x28: {
4602 OPC_CheckPredicate, 22, // 7186: check predicate 22
4603 OPC_CheckField, 20, 5, 0, // 7188: check Inst[24:20] == 0x0
4604 OPC_Decode, 187, 130, 1, 1, // 7192: decode to VSSEG6E8_V using decoder 1
4605 // 7192: }
4606 41, 7, // 7197: case 0x29: {
4607 OPC_CheckPredicate, 22, // 7199: check predicate 22
4608 OPC_Decode, 131, 131, 1, 3, // 7201: decode to VSUXSEG6EI8_V using decoder 3
4609 // 7201: }
4610 42, 7, // 7206: case 0x2a: {
4611 OPC_CheckPredicate, 22, // 7208: check predicate 22
4612 OPC_Decode, 221, 130, 1, 4, // 7210: decode to VSSSEG6E8_V using decoder 4
4613 // 7210: }
4614 43, 7, // 7215: case 0x2b: {
4615 OPC_CheckPredicate, 22, // 7217: check predicate 22
4616 OPC_Decode, 149, 130, 1, 3, // 7219: decode to VSOXSEG6EI8_V using decoder 3
4617 // 7219: }
4618 48, 11, // 7224: case 0x30: {
4619 OPC_CheckPredicate, 22, // 7226: check predicate 22
4620 OPC_CheckField, 20, 5, 0, // 7228: check Inst[24:20] == 0x0
4621 OPC_Decode, 191, 130, 1, 1, // 7232: decode to VSSEG7E8_V using decoder 1
4622 // 7232: }
4623 49, 7, // 7237: case 0x31: {
4624 OPC_CheckPredicate, 22, // 7239: check predicate 22
4625 OPC_Decode, 135, 131, 1, 3, // 7241: decode to VSUXSEG7EI8_V using decoder 3
4626 // 7241: }
4627 50, 7, // 7246: case 0x32: {
4628 OPC_CheckPredicate, 22, // 7248: check predicate 22
4629 OPC_Decode, 225, 130, 1, 4, // 7250: decode to VSSSEG7E8_V using decoder 4
4630 // 7250: }
4631 51, 7, // 7255: case 0x33: {
4632 OPC_CheckPredicate, 22, // 7257: check predicate 22
4633 OPC_Decode, 153, 130, 1, 3, // 7259: decode to VSOXSEG7EI8_V using decoder 3
4634 // 7259: }
4635 56, 25, // 7264: case 0x38: {
4636 OPC_SwitchField, 20, 5, // 7266: switch Inst[24:20] {
4637 0, 7, // 7269: case 0x0: {
4638 OPC_CheckPredicate, 22, // 7271: check predicate 22
4639 OPC_Decode, 195, 130, 1, 1, // 7273: decode to VSSEG8E8_V using decoder 1
4640 // 7273: }
4641 8, 0, // 7278: case 0x8: {
4642 OPC_CheckPredicate, 22, // 7280: check predicate 22
4643 OPC_CheckField, 25, 1, 1, // 7282: check Inst[25] == 0x1
4644 OPC_Decode, 215, 129, 1, 7, // 7286: decode to VS8R_V using decoder 7
4645 // 7286: }
4646 // 7286: } // switch Inst[24:20]
4647 // 7286: }
4648 57, 7, // 7291: case 0x39: {
4649 OPC_CheckPredicate, 22, // 7293: check predicate 22
4650 OPC_Decode, 139, 131, 1, 3, // 7295: decode to VSUXSEG8EI8_V using decoder 3
4651 // 7295: }
4652 58, 7, // 7300: case 0x3a: {
4653 OPC_CheckPredicate, 22, // 7302: check predicate 22
4654 OPC_Decode, 229, 130, 1, 4, // 7304: decode to VSSSEG8E8_V using decoder 4
4655 // 7304: }
4656 59, 0, // 7309: case 0x3b: {
4657 OPC_CheckPredicate, 22, // 7311: check predicate 22
4658 OPC_Decode, 157, 130, 1, 3, // 7313: decode to VSOXSEG8EI8_V using decoder 3
4659 // 7313: }
4660 // 7313: } // switch Inst[31:26]
4661 // 7313: }
4662 1, 6, // 7318: case 0x1: {
4663 OPC_CheckPredicate, 23, // 7320: check predicate 23
4664 OPC_Decode, 236, 115, 50, // 7322: decode to FSH using decoder 50
4665 // 7322: }
4666 2, 6, // 7326: case 0x2: {
4667 OPC_CheckPredicate, 24, // 7328: check predicate 24
4668 OPC_Decode, 254, 115, 51, // 7330: decode to FSW using decoder 51
4669 // 7330: }
4670 3, 6, // 7334: case 0x3: {
4671 OPC_CheckPredicate, 25, // 7336: check predicate 25
4672 OPC_Decode, 211, 115, 52, // 7338: decode to FSD using decoder 52
4673 // 7338: }
4674 4, 6, // 7342: case 0x4: {
4675 OPC_CheckPredicate, 26, // 7344: check predicate 26
4676 OPC_Decode, 237, 115, 53, // 7346: decode to FSQ using decoder 53
4677 // 7346: }
4678 5, 195, 2, // 7350: case 0x5: {
4679 OPC_SwitchField, 26, 6, // 7353: switch Inst[31:26] {
4680 0, 11, // 7356: case 0x0: {
4681 OPC_CheckPredicate, 22, // 7358: check predicate 22
4682 OPC_CheckField, 20, 5, 0, // 7360: check Inst[24:20] == 0x0
4683 OPC_Decode, 224, 129, 1, 1, // 7364: decode to VSE16_V using decoder 1
4684 // 7364: }
4685 1, 7, // 7369: case 0x1: {
4686 OPC_CheckPredicate, 22, // 7371: check predicate 22
4687 OPC_Decode, 236, 130, 1, 3, // 7373: decode to VSUXEI16_V using decoder 3
4688 // 7373: }
4689 2, 7, // 7378: case 0x2: {
4690 OPC_CheckPredicate, 22, // 7380: check predicate 22
4691 OPC_Decode, 164, 130, 1, 4, // 7382: decode to VSSE16_V using decoder 4
4692 // 7382: }
4693 3, 7, // 7387: case 0x3: {
4694 OPC_CheckPredicate, 22, // 7389: check predicate 22
4695 OPC_Decode, 254, 129, 1, 3, // 7391: decode to VSOXEI16_V using decoder 3
4696 // 7391: }
4697 8, 11, // 7396: case 0x8: {
4698 OPC_CheckPredicate, 22, // 7398: check predicate 22
4699 OPC_CheckField, 20, 5, 0, // 7400: check Inst[24:20] == 0x0
4700 OPC_Decode, 168, 130, 1, 1, // 7404: decode to VSSEG2E16_V using decoder 1
4701 // 7404: }
4702 9, 7, // 7409: case 0x9: {
4703 OPC_CheckPredicate, 22, // 7411: check predicate 22
4704 OPC_Decode, 240, 130, 1, 3, // 7413: decode to VSUXSEG2EI16_V using decoder 3
4705 // 7413: }
4706 10, 7, // 7418: case 0xa: {
4707 OPC_CheckPredicate, 22, // 7420: check predicate 22
4708 OPC_Decode, 202, 130, 1, 4, // 7422: decode to VSSSEG2E16_V using decoder 4
4709 // 7422: }
4710 11, 7, // 7427: case 0xb: {
4711 OPC_CheckPredicate, 22, // 7429: check predicate 22
4712 OPC_Decode, 130, 130, 1, 3, // 7431: decode to VSOXSEG2EI16_V using decoder 3
4713 // 7431: }
4714 16, 11, // 7436: case 0x10: {
4715 OPC_CheckPredicate, 22, // 7438: check predicate 22
4716 OPC_CheckField, 20, 5, 0, // 7440: check Inst[24:20] == 0x0
4717 OPC_Decode, 172, 130, 1, 1, // 7444: decode to VSSEG3E16_V using decoder 1
4718 // 7444: }
4719 17, 7, // 7449: case 0x11: {
4720 OPC_CheckPredicate, 22, // 7451: check predicate 22
4721 OPC_Decode, 244, 130, 1, 3, // 7453: decode to VSUXSEG3EI16_V using decoder 3
4722 // 7453: }
4723 18, 7, // 7458: case 0x12: {
4724 OPC_CheckPredicate, 22, // 7460: check predicate 22
4725 OPC_Decode, 206, 130, 1, 4, // 7462: decode to VSSSEG3E16_V using decoder 4
4726 // 7462: }
4727 19, 7, // 7467: case 0x13: {
4728 OPC_CheckPredicate, 22, // 7469: check predicate 22
4729 OPC_Decode, 134, 130, 1, 3, // 7471: decode to VSOXSEG3EI16_V using decoder 3
4730 // 7471: }
4731 24, 11, // 7476: case 0x18: {
4732 OPC_CheckPredicate, 22, // 7478: check predicate 22
4733 OPC_CheckField, 20, 5, 0, // 7480: check Inst[24:20] == 0x0
4734 OPC_Decode, 176, 130, 1, 1, // 7484: decode to VSSEG4E16_V using decoder 1
4735 // 7484: }
4736 25, 7, // 7489: case 0x19: {
4737 OPC_CheckPredicate, 22, // 7491: check predicate 22
4738 OPC_Decode, 248, 130, 1, 3, // 7493: decode to VSUXSEG4EI16_V using decoder 3
4739 // 7493: }
4740 26, 7, // 7498: case 0x1a: {
4741 OPC_CheckPredicate, 22, // 7500: check predicate 22
4742 OPC_Decode, 210, 130, 1, 4, // 7502: decode to VSSSEG4E16_V using decoder 4
4743 // 7502: }
4744 27, 7, // 7507: case 0x1b: {
4745 OPC_CheckPredicate, 22, // 7509: check predicate 22
4746 OPC_Decode, 138, 130, 1, 3, // 7511: decode to VSOXSEG4EI16_V using decoder 3
4747 // 7511: }
4748 32, 11, // 7516: case 0x20: {
4749 OPC_CheckPredicate, 22, // 7518: check predicate 22
4750 OPC_CheckField, 20, 5, 0, // 7520: check Inst[24:20] == 0x0
4751 OPC_Decode, 180, 130, 1, 1, // 7524: decode to VSSEG5E16_V using decoder 1
4752 // 7524: }
4753 33, 7, // 7529: case 0x21: {
4754 OPC_CheckPredicate, 22, // 7531: check predicate 22
4755 OPC_Decode, 252, 130, 1, 3, // 7533: decode to VSUXSEG5EI16_V using decoder 3
4756 // 7533: }
4757 34, 7, // 7538: case 0x22: {
4758 OPC_CheckPredicate, 22, // 7540: check predicate 22
4759 OPC_Decode, 214, 130, 1, 4, // 7542: decode to VSSSEG5E16_V using decoder 4
4760 // 7542: }
4761 35, 7, // 7547: case 0x23: {
4762 OPC_CheckPredicate, 22, // 7549: check predicate 22
4763 OPC_Decode, 142, 130, 1, 3, // 7551: decode to VSOXSEG5EI16_V using decoder 3
4764 // 7551: }
4765 40, 11, // 7556: case 0x28: {
4766 OPC_CheckPredicate, 22, // 7558: check predicate 22
4767 OPC_CheckField, 20, 5, 0, // 7560: check Inst[24:20] == 0x0
4768 OPC_Decode, 184, 130, 1, 1, // 7564: decode to VSSEG6E16_V using decoder 1
4769 // 7564: }
4770 41, 7, // 7569: case 0x29: {
4771 OPC_CheckPredicate, 22, // 7571: check predicate 22
4772 OPC_Decode, 128, 131, 1, 3, // 7573: decode to VSUXSEG6EI16_V using decoder 3
4773 // 7573: }
4774 42, 7, // 7578: case 0x2a: {
4775 OPC_CheckPredicate, 22, // 7580: check predicate 22
4776 OPC_Decode, 218, 130, 1, 4, // 7582: decode to VSSSEG6E16_V using decoder 4
4777 // 7582: }
4778 43, 7, // 7587: case 0x2b: {
4779 OPC_CheckPredicate, 22, // 7589: check predicate 22
4780 OPC_Decode, 146, 130, 1, 3, // 7591: decode to VSOXSEG6EI16_V using decoder 3
4781 // 7591: }
4782 48, 11, // 7596: case 0x30: {
4783 OPC_CheckPredicate, 22, // 7598: check predicate 22
4784 OPC_CheckField, 20, 5, 0, // 7600: check Inst[24:20] == 0x0
4785 OPC_Decode, 188, 130, 1, 1, // 7604: decode to VSSEG7E16_V using decoder 1
4786 // 7604: }
4787 49, 7, // 7609: case 0x31: {
4788 OPC_CheckPredicate, 22, // 7611: check predicate 22
4789 OPC_Decode, 132, 131, 1, 3, // 7613: decode to VSUXSEG7EI16_V using decoder 3
4790 // 7613: }
4791 50, 7, // 7618: case 0x32: {
4792 OPC_CheckPredicate, 22, // 7620: check predicate 22
4793 OPC_Decode, 222, 130, 1, 4, // 7622: decode to VSSSEG7E16_V using decoder 4
4794 // 7622: }
4795 51, 7, // 7627: case 0x33: {
4796 OPC_CheckPredicate, 22, // 7629: check predicate 22
4797 OPC_Decode, 150, 130, 1, 3, // 7631: decode to VSOXSEG7EI16_V using decoder 3
4798 // 7631: }
4799 56, 11, // 7636: case 0x38: {
4800 OPC_CheckPredicate, 22, // 7638: check predicate 22
4801 OPC_CheckField, 20, 5, 0, // 7640: check Inst[24:20] == 0x0
4802 OPC_Decode, 192, 130, 1, 1, // 7644: decode to VSSEG8E16_V using decoder 1
4803 // 7644: }
4804 57, 7, // 7649: case 0x39: {
4805 OPC_CheckPredicate, 22, // 7651: check predicate 22
4806 OPC_Decode, 136, 131, 1, 3, // 7653: decode to VSUXSEG8EI16_V using decoder 3
4807 // 7653: }
4808 58, 7, // 7658: case 0x3a: {
4809 OPC_CheckPredicate, 22, // 7660: check predicate 22
4810 OPC_Decode, 226, 130, 1, 4, // 7662: decode to VSSSEG8E16_V using decoder 4
4811 // 7662: }
4812 59, 0, // 7667: case 0x3b: {
4813 OPC_CheckPredicate, 22, // 7669: check predicate 22
4814 OPC_Decode, 154, 130, 1, 3, // 7671: decode to VSOXSEG8EI16_V using decoder 3
4815 // 7671: }
4816 // 7671: } // switch Inst[31:26]
4817 // 7671: }
4818 6, 195, 2, // 7676: case 0x6: {
4819 OPC_SwitchField, 26, 6, // 7679: switch Inst[31:26] {
4820 0, 11, // 7682: case 0x0: {
4821 OPC_CheckPredicate, 22, // 7684: check predicate 22
4822 OPC_CheckField, 20, 5, 0, // 7686: check Inst[24:20] == 0x0
4823 OPC_Decode, 225, 129, 1, 1, // 7690: decode to VSE32_V using decoder 1
4824 // 7690: }
4825 1, 7, // 7695: case 0x1: {
4826 OPC_CheckPredicate, 22, // 7697: check predicate 22
4827 OPC_Decode, 237, 130, 1, 3, // 7699: decode to VSUXEI32_V using decoder 3
4828 // 7699: }
4829 2, 7, // 7704: case 0x2: {
4830 OPC_CheckPredicate, 22, // 7706: check predicate 22
4831 OPC_Decode, 165, 130, 1, 4, // 7708: decode to VSSE32_V using decoder 4
4832 // 7708: }
4833 3, 7, // 7713: case 0x3: {
4834 OPC_CheckPredicate, 22, // 7715: check predicate 22
4835 OPC_Decode, 255, 129, 1, 3, // 7717: decode to VSOXEI32_V using decoder 3
4836 // 7717: }
4837 8, 11, // 7722: case 0x8: {
4838 OPC_CheckPredicate, 22, // 7724: check predicate 22
4839 OPC_CheckField, 20, 5, 0, // 7726: check Inst[24:20] == 0x0
4840 OPC_Decode, 169, 130, 1, 1, // 7730: decode to VSSEG2E32_V using decoder 1
4841 // 7730: }
4842 9, 7, // 7735: case 0x9: {
4843 OPC_CheckPredicate, 22, // 7737: check predicate 22
4844 OPC_Decode, 241, 130, 1, 3, // 7739: decode to VSUXSEG2EI32_V using decoder 3
4845 // 7739: }
4846 10, 7, // 7744: case 0xa: {
4847 OPC_CheckPredicate, 22, // 7746: check predicate 22
4848 OPC_Decode, 203, 130, 1, 4, // 7748: decode to VSSSEG2E32_V using decoder 4
4849 // 7748: }
4850 11, 7, // 7753: case 0xb: {
4851 OPC_CheckPredicate, 22, // 7755: check predicate 22
4852 OPC_Decode, 131, 130, 1, 3, // 7757: decode to VSOXSEG2EI32_V using decoder 3
4853 // 7757: }
4854 16, 11, // 7762: case 0x10: {
4855 OPC_CheckPredicate, 22, // 7764: check predicate 22
4856 OPC_CheckField, 20, 5, 0, // 7766: check Inst[24:20] == 0x0
4857 OPC_Decode, 173, 130, 1, 1, // 7770: decode to VSSEG3E32_V using decoder 1
4858 // 7770: }
4859 17, 7, // 7775: case 0x11: {
4860 OPC_CheckPredicate, 22, // 7777: check predicate 22
4861 OPC_Decode, 245, 130, 1, 3, // 7779: decode to VSUXSEG3EI32_V using decoder 3
4862 // 7779: }
4863 18, 7, // 7784: case 0x12: {
4864 OPC_CheckPredicate, 22, // 7786: check predicate 22
4865 OPC_Decode, 207, 130, 1, 4, // 7788: decode to VSSSEG3E32_V using decoder 4
4866 // 7788: }
4867 19, 7, // 7793: case 0x13: {
4868 OPC_CheckPredicate, 22, // 7795: check predicate 22
4869 OPC_Decode, 135, 130, 1, 3, // 7797: decode to VSOXSEG3EI32_V using decoder 3
4870 // 7797: }
4871 24, 11, // 7802: case 0x18: {
4872 OPC_CheckPredicate, 22, // 7804: check predicate 22
4873 OPC_CheckField, 20, 5, 0, // 7806: check Inst[24:20] == 0x0
4874 OPC_Decode, 177, 130, 1, 1, // 7810: decode to VSSEG4E32_V using decoder 1
4875 // 7810: }
4876 25, 7, // 7815: case 0x19: {
4877 OPC_CheckPredicate, 22, // 7817: check predicate 22
4878 OPC_Decode, 249, 130, 1, 3, // 7819: decode to VSUXSEG4EI32_V using decoder 3
4879 // 7819: }
4880 26, 7, // 7824: case 0x1a: {
4881 OPC_CheckPredicate, 22, // 7826: check predicate 22
4882 OPC_Decode, 211, 130, 1, 4, // 7828: decode to VSSSEG4E32_V using decoder 4
4883 // 7828: }
4884 27, 7, // 7833: case 0x1b: {
4885 OPC_CheckPredicate, 22, // 7835: check predicate 22
4886 OPC_Decode, 139, 130, 1, 3, // 7837: decode to VSOXSEG4EI32_V using decoder 3
4887 // 7837: }
4888 32, 11, // 7842: case 0x20: {
4889 OPC_CheckPredicate, 22, // 7844: check predicate 22
4890 OPC_CheckField, 20, 5, 0, // 7846: check Inst[24:20] == 0x0
4891 OPC_Decode, 181, 130, 1, 1, // 7850: decode to VSSEG5E32_V using decoder 1
4892 // 7850: }
4893 33, 7, // 7855: case 0x21: {
4894 OPC_CheckPredicate, 22, // 7857: check predicate 22
4895 OPC_Decode, 253, 130, 1, 3, // 7859: decode to VSUXSEG5EI32_V using decoder 3
4896 // 7859: }
4897 34, 7, // 7864: case 0x22: {
4898 OPC_CheckPredicate, 22, // 7866: check predicate 22
4899 OPC_Decode, 215, 130, 1, 4, // 7868: decode to VSSSEG5E32_V using decoder 4
4900 // 7868: }
4901 35, 7, // 7873: case 0x23: {
4902 OPC_CheckPredicate, 22, // 7875: check predicate 22
4903 OPC_Decode, 143, 130, 1, 3, // 7877: decode to VSOXSEG5EI32_V using decoder 3
4904 // 7877: }
4905 40, 11, // 7882: case 0x28: {
4906 OPC_CheckPredicate, 22, // 7884: check predicate 22
4907 OPC_CheckField, 20, 5, 0, // 7886: check Inst[24:20] == 0x0
4908 OPC_Decode, 185, 130, 1, 1, // 7890: decode to VSSEG6E32_V using decoder 1
4909 // 7890: }
4910 41, 7, // 7895: case 0x29: {
4911 OPC_CheckPredicate, 22, // 7897: check predicate 22
4912 OPC_Decode, 129, 131, 1, 3, // 7899: decode to VSUXSEG6EI32_V using decoder 3
4913 // 7899: }
4914 42, 7, // 7904: case 0x2a: {
4915 OPC_CheckPredicate, 22, // 7906: check predicate 22
4916 OPC_Decode, 219, 130, 1, 4, // 7908: decode to VSSSEG6E32_V using decoder 4
4917 // 7908: }
4918 43, 7, // 7913: case 0x2b: {
4919 OPC_CheckPredicate, 22, // 7915: check predicate 22
4920 OPC_Decode, 147, 130, 1, 3, // 7917: decode to VSOXSEG6EI32_V using decoder 3
4921 // 7917: }
4922 48, 11, // 7922: case 0x30: {
4923 OPC_CheckPredicate, 22, // 7924: check predicate 22
4924 OPC_CheckField, 20, 5, 0, // 7926: check Inst[24:20] == 0x0
4925 OPC_Decode, 189, 130, 1, 1, // 7930: decode to VSSEG7E32_V using decoder 1
4926 // 7930: }
4927 49, 7, // 7935: case 0x31: {
4928 OPC_CheckPredicate, 22, // 7937: check predicate 22
4929 OPC_Decode, 133, 131, 1, 3, // 7939: decode to VSUXSEG7EI32_V using decoder 3
4930 // 7939: }
4931 50, 7, // 7944: case 0x32: {
4932 OPC_CheckPredicate, 22, // 7946: check predicate 22
4933 OPC_Decode, 223, 130, 1, 4, // 7948: decode to VSSSEG7E32_V using decoder 4
4934 // 7948: }
4935 51, 7, // 7953: case 0x33: {
4936 OPC_CheckPredicate, 22, // 7955: check predicate 22
4937 OPC_Decode, 151, 130, 1, 3, // 7957: decode to VSOXSEG7EI32_V using decoder 3
4938 // 7957: }
4939 56, 11, // 7962: case 0x38: {
4940 OPC_CheckPredicate, 22, // 7964: check predicate 22
4941 OPC_CheckField, 20, 5, 0, // 7966: check Inst[24:20] == 0x0
4942 OPC_Decode, 193, 130, 1, 1, // 7970: decode to VSSEG8E32_V using decoder 1
4943 // 7970: }
4944 57, 7, // 7975: case 0x39: {
4945 OPC_CheckPredicate, 22, // 7977: check predicate 22
4946 OPC_Decode, 137, 131, 1, 3, // 7979: decode to VSUXSEG8EI32_V using decoder 3
4947 // 7979: }
4948 58, 7, // 7984: case 0x3a: {
4949 OPC_CheckPredicate, 22, // 7986: check predicate 22
4950 OPC_Decode, 227, 130, 1, 4, // 7988: decode to VSSSEG8E32_V using decoder 4
4951 // 7988: }
4952 59, 0, // 7993: case 0x3b: {
4953 OPC_CheckPredicate, 22, // 7995: check predicate 22
4954 OPC_Decode, 155, 130, 1, 3, // 7997: decode to VSOXSEG8EI32_V using decoder 3
4955 // 7997: }
4956 // 7997: } // switch Inst[31:26]
4957 // 7997: }
4958 7, 0, // 8002: case 0x7: {
4959 OPC_SwitchField, 26, 3, // 8004: switch Inst[28:26] {
4960 0, 107, // 8007: case 0x0: {
4961 OPC_SwitchField, 29, 3, // 8009: switch Inst[31:29] {
4962 0, 11, // 8012: case 0x0: {
4963 OPC_CheckPredicate, 27, // 8014: check predicate 27
4964 OPC_CheckField, 20, 5, 0, // 8016: check Inst[24:20] == 0x0
4965 OPC_Decode, 226, 129, 1, 1, // 8020: decode to VSE64_V using decoder 1
4966 // 8020: }
4967 1, 11, // 8025: case 0x1: {
4968 OPC_CheckPredicate, 27, // 8027: check predicate 27
4969 OPC_CheckField, 20, 5, 0, // 8029: check Inst[24:20] == 0x0
4970 OPC_Decode, 170, 130, 1, 1, // 8033: decode to VSSEG2E64_V using decoder 1
4971 // 8033: }
4972 2, 11, // 8038: case 0x2: {
4973 OPC_CheckPredicate, 27, // 8040: check predicate 27
4974 OPC_CheckField, 20, 5, 0, // 8042: check Inst[24:20] == 0x0
4975 OPC_Decode, 174, 130, 1, 1, // 8046: decode to VSSEG3E64_V using decoder 1
4976 // 8046: }
4977 3, 11, // 8051: case 0x3: {
4978 OPC_CheckPredicate, 27, // 8053: check predicate 27
4979 OPC_CheckField, 20, 5, 0, // 8055: check Inst[24:20] == 0x0
4980 OPC_Decode, 178, 130, 1, 1, // 8059: decode to VSSEG4E64_V using decoder 1
4981 // 8059: }
4982 4, 11, // 8064: case 0x4: {
4983 OPC_CheckPredicate, 27, // 8066: check predicate 27
4984 OPC_CheckField, 20, 5, 0, // 8068: check Inst[24:20] == 0x0
4985 OPC_Decode, 182, 130, 1, 1, // 8072: decode to VSSEG5E64_V using decoder 1
4986 // 8072: }
4987 5, 11, // 8077: case 0x5: {
4988 OPC_CheckPredicate, 27, // 8079: check predicate 27
4989 OPC_CheckField, 20, 5, 0, // 8081: check Inst[24:20] == 0x0
4990 OPC_Decode, 186, 130, 1, 1, // 8085: decode to VSSEG6E64_V using decoder 1
4991 // 8085: }
4992 6, 11, // 8090: case 0x6: {
4993 OPC_CheckPredicate, 27, // 8092: check predicate 27
4994 OPC_CheckField, 20, 5, 0, // 8094: check Inst[24:20] == 0x0
4995 OPC_Decode, 190, 130, 1, 1, // 8098: decode to VSSEG7E64_V using decoder 1
4996 // 8098: }
4997 7, 0, // 8103: case 0x7: {
4998 OPC_CheckPredicate, 27, // 8105: check predicate 27
4999 OPC_CheckField, 20, 5, 0, // 8107: check Inst[24:20] == 0x0
5000 OPC_Decode, 194, 130, 1, 1, // 8111: decode to VSSEG8E64_V using decoder 1
5001 // 8111: }
5002 // 8111: } // switch Inst[31:29]
5003 // 8111: }
5004 1, 75, // 8116: case 0x1: {
5005 OPC_SwitchField, 29, 3, // 8118: switch Inst[31:29] {
5006 0, 7, // 8121: case 0x0: {
5007 OPC_CheckPredicate, 28, // 8123: check predicate 28
5008 OPC_Decode, 238, 130, 1, 3, // 8125: decode to VSUXEI64_V using decoder 3
5009 // 8125: }
5010 1, 7, // 8130: case 0x1: {
5011 OPC_CheckPredicate, 29, // 8132: check predicate 29
5012 OPC_Decode, 242, 130, 1, 3, // 8134: decode to VSUXSEG2EI64_V using decoder 3
5013 // 8134: }
5014 2, 7, // 8139: case 0x2: {
5015 OPC_CheckPredicate, 29, // 8141: check predicate 29
5016 OPC_Decode, 246, 130, 1, 3, // 8143: decode to VSUXSEG3EI64_V using decoder 3
5017 // 8143: }
5018 3, 7, // 8148: case 0x3: {
5019 OPC_CheckPredicate, 29, // 8150: check predicate 29
5020 OPC_Decode, 250, 130, 1, 3, // 8152: decode to VSUXSEG4EI64_V using decoder 3
5021 // 8152: }
5022 4, 7, // 8157: case 0x4: {
5023 OPC_CheckPredicate, 29, // 8159: check predicate 29
5024 OPC_Decode, 254, 130, 1, 3, // 8161: decode to VSUXSEG5EI64_V using decoder 3
5025 // 8161: }
5026 5, 7, // 8166: case 0x5: {
5027 OPC_CheckPredicate, 29, // 8168: check predicate 29
5028 OPC_Decode, 130, 131, 1, 3, // 8170: decode to VSUXSEG6EI64_V using decoder 3
5029 // 8170: }
5030 6, 7, // 8175: case 0x6: {
5031 OPC_CheckPredicate, 29, // 8177: check predicate 29
5032 OPC_Decode, 134, 131, 1, 3, // 8179: decode to VSUXSEG7EI64_V using decoder 3
5033 // 8179: }
5034 7, 0, // 8184: case 0x7: {
5035 OPC_CheckPredicate, 29, // 8186: check predicate 29
5036 OPC_Decode, 138, 131, 1, 3, // 8188: decode to VSUXSEG8EI64_V using decoder 3
5037 // 8188: }
5038 // 8188: } // switch Inst[31:29]
5039 // 8188: }
5040 2, 75, // 8193: case 0x2: {
5041 OPC_SwitchField, 29, 3, // 8195: switch Inst[31:29] {
5042 0, 7, // 8198: case 0x0: {
5043 OPC_CheckPredicate, 27, // 8200: check predicate 27
5044 OPC_Decode, 166, 130, 1, 4, // 8202: decode to VSSE64_V using decoder 4
5045 // 8202: }
5046 1, 7, // 8207: case 0x1: {
5047 OPC_CheckPredicate, 27, // 8209: check predicate 27
5048 OPC_Decode, 204, 130, 1, 4, // 8211: decode to VSSSEG2E64_V using decoder 4
5049 // 8211: }
5050 2, 7, // 8216: case 0x2: {
5051 OPC_CheckPredicate, 27, // 8218: check predicate 27
5052 OPC_Decode, 208, 130, 1, 4, // 8220: decode to VSSSEG3E64_V using decoder 4
5053 // 8220: }
5054 3, 7, // 8225: case 0x3: {
5055 OPC_CheckPredicate, 27, // 8227: check predicate 27
5056 OPC_Decode, 212, 130, 1, 4, // 8229: decode to VSSSEG4E64_V using decoder 4
5057 // 8229: }
5058 4, 7, // 8234: case 0x4: {
5059 OPC_CheckPredicate, 27, // 8236: check predicate 27
5060 OPC_Decode, 216, 130, 1, 4, // 8238: decode to VSSSEG5E64_V using decoder 4
5061 // 8238: }
5062 5, 7, // 8243: case 0x5: {
5063 OPC_CheckPredicate, 27, // 8245: check predicate 27
5064 OPC_Decode, 220, 130, 1, 4, // 8247: decode to VSSSEG6E64_V using decoder 4
5065 // 8247: }
5066 6, 7, // 8252: case 0x6: {
5067 OPC_CheckPredicate, 27, // 8254: check predicate 27
5068 OPC_Decode, 224, 130, 1, 4, // 8256: decode to VSSSEG7E64_V using decoder 4
5069 // 8256: }
5070 7, 0, // 8261: case 0x7: {
5071 OPC_CheckPredicate, 27, // 8263: check predicate 27
5072 OPC_Decode, 228, 130, 1, 4, // 8265: decode to VSSSEG8E64_V using decoder 4
5073 // 8265: }
5074 // 8265: } // switch Inst[31:29]
5075 // 8265: }
5076 3, 75, // 8270: case 0x3: {
5077 OPC_SwitchField, 29, 3, // 8272: switch Inst[31:29] {
5078 0, 7, // 8275: case 0x0: {
5079 OPC_CheckPredicate, 28, // 8277: check predicate 28
5080 OPC_Decode, 128, 130, 1, 3, // 8279: decode to VSOXEI64_V using decoder 3
5081 // 8279: }
5082 1, 7, // 8284: case 0x1: {
5083 OPC_CheckPredicate, 29, // 8286: check predicate 29
5084 OPC_Decode, 132, 130, 1, 3, // 8288: decode to VSOXSEG2EI64_V using decoder 3
5085 // 8288: }
5086 2, 7, // 8293: case 0x2: {
5087 OPC_CheckPredicate, 29, // 8295: check predicate 29
5088 OPC_Decode, 136, 130, 1, 3, // 8297: decode to VSOXSEG3EI64_V using decoder 3
5089 // 8297: }
5090 3, 7, // 8302: case 0x3: {
5091 OPC_CheckPredicate, 29, // 8304: check predicate 29
5092 OPC_Decode, 140, 130, 1, 3, // 8306: decode to VSOXSEG4EI64_V using decoder 3
5093 // 8306: }
5094 4, 7, // 8311: case 0x4: {
5095 OPC_CheckPredicate, 29, // 8313: check predicate 29
5096 OPC_Decode, 144, 130, 1, 3, // 8315: decode to VSOXSEG5EI64_V using decoder 3
5097 // 8315: }
5098 5, 7, // 8320: case 0x5: {
5099 OPC_CheckPredicate, 29, // 8322: check predicate 29
5100 OPC_Decode, 148, 130, 1, 3, // 8324: decode to VSOXSEG6EI64_V using decoder 3
5101 // 8324: }
5102 6, 7, // 8329: case 0x6: {
5103 OPC_CheckPredicate, 29, // 8331: check predicate 29
5104 OPC_Decode, 152, 130, 1, 3, // 8333: decode to VSOXSEG7EI64_V using decoder 3
5105 // 8333: }
5106 7, 0, // 8338: case 0x7: {
5107 OPC_CheckPredicate, 29, // 8340: check predicate 29
5108 OPC_Decode, 156, 130, 1, 3, // 8342: decode to VSOXSEG8EI64_V using decoder 3
5109 // 8342: }
5110 // 8342: } // switch Inst[31:29]
5111 // 8342: }
5112 4, 7, // 8347: case 0x4: {
5113 OPC_CheckPredicate, 30, // 8349: check predicate 30
5114 OPC_Decode, 135, 129, 1, 12, // 8351: decode to VMTS_V using decoder 12
5115 // 8351: }
5116 5, 0, // 8356: case 0x5: {
5117 OPC_CheckPredicate, 31, // 8358: check predicate 31
5118 OPC_Decode, 137, 129, 1, 12, // 8360: decode to VMTTS_V using decoder 12
5119 // 8360: }
5120 // 8360: } // switch Inst[28:26]
5121 // 8360: }
5122 // 8360: } // switch Inst[14:12]
5123 // 8360: }
5124 47, 187, 15, // 8365: case 0x2f: {
5125 OPC_SwitchField, 25, 7, // 8368: switch Inst[31:25] {
5126 0, 35, // 8371: case 0x0: {
5127 OPC_SwitchField, 12, 3, // 8373: switch Inst[14:12] {
5128 0, 6, // 8376: case 0x0: {
5129 OPC_CheckPredicate, 51, // 8378: check predicate 51
5130 OPC_Decode, 131, 109, 54, // 8380: decode to AMOADD_B using decoder 54
5131 // 8380: }
5132 1, 6, // 8384: case 0x1: {
5133 OPC_CheckPredicate, 51, // 8386: check predicate 51
5134 OPC_Decode, 139, 109, 54, // 8388: decode to AMOADD_H using decoder 54
5135 // 8388: }
5136 2, 6, // 8392: case 0x2: {
5137 OPC_CheckPredicate, 52, // 8394: check predicate 52
5138 OPC_Decode, 143, 109, 54, // 8396: decode to AMOADD_W using decoder 54
5139 // 8396: }
5140 3, 0, // 8400: case 0x3: {
5141 OPC_CheckPredicate, 53, // 8402: check predicate 53
5142 OPC_Decode, 135, 109, 54, // 8404: decode to AMOADD_D using decoder 54
5143 // 8404: }
5144 // 8404: } // switch Inst[14:12]
5145 // 8404: }
5146 1, 35, // 8408: case 0x1: {
5147 OPC_SwitchField, 12, 3, // 8410: switch Inst[14:12] {
5148 0, 6, // 8413: case 0x0: {
5149 OPC_CheckPredicate, 51, // 8415: check predicate 51
5150 OPC_Decode, 134, 109, 54, // 8417: decode to AMOADD_B_RL using decoder 54
5151 // 8417: }
5152 1, 6, // 8421: case 0x1: {
5153 OPC_CheckPredicate, 51, // 8423: check predicate 51
5154 OPC_Decode, 142, 109, 54, // 8425: decode to AMOADD_H_RL using decoder 54
5155 // 8425: }
5156 2, 6, // 8429: case 0x2: {
5157 OPC_CheckPredicate, 52, // 8431: check predicate 52
5158 OPC_Decode, 146, 109, 54, // 8433: decode to AMOADD_W_RL using decoder 54
5159 // 8433: }
5160 3, 0, // 8437: case 0x3: {
5161 OPC_CheckPredicate, 53, // 8439: check predicate 53
5162 OPC_Decode, 138, 109, 54, // 8441: decode to AMOADD_D_RL using decoder 54
5163 // 8441: }
5164 // 8441: } // switch Inst[14:12]
5165 // 8441: }
5166 2, 35, // 8445: case 0x2: {
5167 OPC_SwitchField, 12, 3, // 8447: switch Inst[14:12] {
5168 0, 6, // 8450: case 0x0: {
5169 OPC_CheckPredicate, 51, // 8452: check predicate 51
5170 OPC_Decode, 132, 109, 54, // 8454: decode to AMOADD_B_AQ using decoder 54
5171 // 8454: }
5172 1, 6, // 8458: case 0x1: {
5173 OPC_CheckPredicate, 51, // 8460: check predicate 51
5174 OPC_Decode, 140, 109, 54, // 8462: decode to AMOADD_H_AQ using decoder 54
5175 // 8462: }
5176 2, 6, // 8466: case 0x2: {
5177 OPC_CheckPredicate, 52, // 8468: check predicate 52
5178 OPC_Decode, 144, 109, 54, // 8470: decode to AMOADD_W_AQ using decoder 54
5179 // 8470: }
5180 3, 0, // 8474: case 0x3: {
5181 OPC_CheckPredicate, 53, // 8476: check predicate 53
5182 OPC_Decode, 136, 109, 54, // 8478: decode to AMOADD_D_AQ using decoder 54
5183 // 8478: }
5184 // 8478: } // switch Inst[14:12]
5185 // 8478: }
5186 3, 35, // 8482: case 0x3: {
5187 OPC_SwitchField, 12, 3, // 8484: switch Inst[14:12] {
5188 0, 6, // 8487: case 0x0: {
5189 OPC_CheckPredicate, 51, // 8489: check predicate 51
5190 OPC_Decode, 133, 109, 54, // 8491: decode to AMOADD_B_AQRL using decoder 54
5191 // 8491: }
5192 1, 6, // 8495: case 0x1: {
5193 OPC_CheckPredicate, 51, // 8497: check predicate 51
5194 OPC_Decode, 141, 109, 54, // 8499: decode to AMOADD_H_AQRL using decoder 54
5195 // 8499: }
5196 2, 6, // 8503: case 0x2: {
5197 OPC_CheckPredicate, 52, // 8505: check predicate 52
5198 OPC_Decode, 145, 109, 54, // 8507: decode to AMOADD_W_AQRL using decoder 54
5199 // 8507: }
5200 3, 0, // 8511: case 0x3: {
5201 OPC_CheckPredicate, 53, // 8513: check predicate 53
5202 OPC_Decode, 137, 109, 54, // 8515: decode to AMOADD_D_AQRL using decoder 54
5203 // 8515: }
5204 // 8515: } // switch Inst[14:12]
5205 // 8515: }
5206 4, 35, // 8519: case 0x4: {
5207 OPC_SwitchField, 12, 3, // 8521: switch Inst[14:12] {
5208 0, 6, // 8524: case 0x0: {
5209 OPC_CheckPredicate, 51, // 8526: check predicate 51
5210 OPC_Decode, 139, 110, 54, // 8528: decode to AMOSWAP_B using decoder 54
5211 // 8528: }
5212 1, 6, // 8532: case 0x1: {
5213 OPC_CheckPredicate, 51, // 8534: check predicate 51
5214 OPC_Decode, 147, 110, 54, // 8536: decode to AMOSWAP_H using decoder 54
5215 // 8536: }
5216 2, 6, // 8540: case 0x2: {
5217 OPC_CheckPredicate, 52, // 8542: check predicate 52
5218 OPC_Decode, 151, 110, 54, // 8544: decode to AMOSWAP_W using decoder 54
5219 // 8544: }
5220 3, 0, // 8548: case 0x3: {
5221 OPC_CheckPredicate, 53, // 8550: check predicate 53
5222 OPC_Decode, 143, 110, 54, // 8552: decode to AMOSWAP_D using decoder 54
5223 // 8552: }
5224 // 8552: } // switch Inst[14:12]
5225 // 8552: }
5226 5, 35, // 8556: case 0x5: {
5227 OPC_SwitchField, 12, 3, // 8558: switch Inst[14:12] {
5228 0, 6, // 8561: case 0x0: {
5229 OPC_CheckPredicate, 51, // 8563: check predicate 51
5230 OPC_Decode, 142, 110, 54, // 8565: decode to AMOSWAP_B_RL using decoder 54
5231 // 8565: }
5232 1, 6, // 8569: case 0x1: {
5233 OPC_CheckPredicate, 51, // 8571: check predicate 51
5234 OPC_Decode, 150, 110, 54, // 8573: decode to AMOSWAP_H_RL using decoder 54
5235 // 8573: }
5236 2, 6, // 8577: case 0x2: {
5237 OPC_CheckPredicate, 52, // 8579: check predicate 52
5238 OPC_Decode, 154, 110, 54, // 8581: decode to AMOSWAP_W_RL using decoder 54
5239 // 8581: }
5240 3, 0, // 8585: case 0x3: {
5241 OPC_CheckPredicate, 53, // 8587: check predicate 53
5242 OPC_Decode, 146, 110, 54, // 8589: decode to AMOSWAP_D_RL using decoder 54
5243 // 8589: }
5244 // 8589: } // switch Inst[14:12]
5245 // 8589: }
5246 6, 35, // 8593: case 0x6: {
5247 OPC_SwitchField, 12, 3, // 8595: switch Inst[14:12] {
5248 0, 6, // 8598: case 0x0: {
5249 OPC_CheckPredicate, 51, // 8600: check predicate 51
5250 OPC_Decode, 140, 110, 54, // 8602: decode to AMOSWAP_B_AQ using decoder 54
5251 // 8602: }
5252 1, 6, // 8606: case 0x1: {
5253 OPC_CheckPredicate, 51, // 8608: check predicate 51
5254 OPC_Decode, 148, 110, 54, // 8610: decode to AMOSWAP_H_AQ using decoder 54
5255 // 8610: }
5256 2, 6, // 8614: case 0x2: {
5257 OPC_CheckPredicate, 52, // 8616: check predicate 52
5258 OPC_Decode, 152, 110, 54, // 8618: decode to AMOSWAP_W_AQ using decoder 54
5259 // 8618: }
5260 3, 0, // 8622: case 0x3: {
5261 OPC_CheckPredicate, 53, // 8624: check predicate 53
5262 OPC_Decode, 144, 110, 54, // 8626: decode to AMOSWAP_D_AQ using decoder 54
5263 // 8626: }
5264 // 8626: } // switch Inst[14:12]
5265 // 8626: }
5266 7, 35, // 8630: case 0x7: {
5267 OPC_SwitchField, 12, 3, // 8632: switch Inst[14:12] {
5268 0, 6, // 8635: case 0x0: {
5269 OPC_CheckPredicate, 51, // 8637: check predicate 51
5270 OPC_Decode, 141, 110, 54, // 8639: decode to AMOSWAP_B_AQRL using decoder 54
5271 // 8639: }
5272 1, 6, // 8643: case 0x1: {
5273 OPC_CheckPredicate, 51, // 8645: check predicate 51
5274 OPC_Decode, 149, 110, 54, // 8647: decode to AMOSWAP_H_AQRL using decoder 54
5275 // 8647: }
5276 2, 6, // 8651: case 0x2: {
5277 OPC_CheckPredicate, 52, // 8653: check predicate 52
5278 OPC_Decode, 153, 110, 54, // 8655: decode to AMOSWAP_W_AQRL using decoder 54
5279 // 8655: }
5280 3, 0, // 8659: case 0x3: {
5281 OPC_CheckPredicate, 53, // 8661: check predicate 53
5282 OPC_Decode, 145, 110, 54, // 8663: decode to AMOSWAP_D_AQRL using decoder 54
5283 // 8663: }
5284 // 8663: } // switch Inst[14:12]
5285 // 8663: }
5286 8, 27, // 8667: case 0x8: {
5287 OPC_SwitchField, 12, 3, // 8669: switch Inst[14:12] {
5288 2, 10, // 8672: case 0x2: {
5289 OPC_CheckPredicate, 54, // 8674: check predicate 54
5290 OPC_CheckField, 20, 5, 0, // 8676: check Inst[24:20] == 0x0
5291 OPC_Decode, 190, 116, 17, // 8680: decode to LR_W using decoder 17
5292 // 8680: }
5293 3, 0, // 8684: case 0x3: {
5294 OPC_CheckPredicate, 55, // 8686: check predicate 55
5295 OPC_CheckField, 20, 5, 0, // 8688: check Inst[24:20] == 0x0
5296 OPC_Decode, 186, 116, 17, // 8692: decode to LR_D using decoder 17
5297 // 8692: }
5298 // 8692: } // switch Inst[14:12]
5299 // 8692: }
5300 9, 27, // 8696: case 0x9: {
5301 OPC_SwitchField, 12, 3, // 8698: switch Inst[14:12] {
5302 2, 10, // 8701: case 0x2: {
5303 OPC_CheckPredicate, 54, // 8703: check predicate 54
5304 OPC_CheckField, 20, 5, 0, // 8705: check Inst[24:20] == 0x0
5305 OPC_Decode, 193, 116, 17, // 8709: decode to LR_W_RL using decoder 17
5306 // 8709: }
5307 3, 0, // 8713: case 0x3: {
5308 OPC_CheckPredicate, 55, // 8715: check predicate 55
5309 OPC_CheckField, 20, 5, 0, // 8717: check Inst[24:20] == 0x0
5310 OPC_Decode, 189, 116, 17, // 8721: decode to LR_D_RL using decoder 17
5311 // 8721: }
5312 // 8721: } // switch Inst[14:12]
5313 // 8721: }
5314 10, 27, // 8725: case 0xa: {
5315 OPC_SwitchField, 12, 3, // 8727: switch Inst[14:12] {
5316 2, 10, // 8730: case 0x2: {
5317 OPC_CheckPredicate, 54, // 8732: check predicate 54
5318 OPC_CheckField, 20, 5, 0, // 8734: check Inst[24:20] == 0x0
5319 OPC_Decode, 191, 116, 17, // 8738: decode to LR_W_AQ using decoder 17
5320 // 8738: }
5321 3, 0, // 8742: case 0x3: {
5322 OPC_CheckPredicate, 55, // 8744: check predicate 55
5323 OPC_CheckField, 20, 5, 0, // 8746: check Inst[24:20] == 0x0
5324 OPC_Decode, 187, 116, 17, // 8750: decode to LR_D_AQ using decoder 17
5325 // 8750: }
5326 // 8750: } // switch Inst[14:12]
5327 // 8750: }
5328 11, 27, // 8754: case 0xb: {
5329 OPC_SwitchField, 12, 3, // 8756: switch Inst[14:12] {
5330 2, 10, // 8759: case 0x2: {
5331 OPC_CheckPredicate, 54, // 8761: check predicate 54
5332 OPC_CheckField, 20, 5, 0, // 8763: check Inst[24:20] == 0x0
5333 OPC_Decode, 192, 116, 17, // 8767: decode to LR_W_AQRL using decoder 17
5334 // 8767: }
5335 3, 0, // 8771: case 0x3: {
5336 OPC_CheckPredicate, 55, // 8773: check predicate 55
5337 OPC_CheckField, 20, 5, 0, // 8775: check Inst[24:20] == 0x0
5338 OPC_Decode, 188, 116, 17, // 8779: decode to LR_D_AQRL using decoder 17
5339 // 8779: }
5340 // 8779: } // switch Inst[14:12]
5341 // 8779: }
5342 12, 19, // 8783: case 0xc: {
5343 OPC_SwitchField, 12, 3, // 8785: switch Inst[14:12] {
5344 2, 6, // 8788: case 0x2: {
5345 OPC_CheckPredicate, 54, // 8790: check predicate 54
5346 OPC_Decode, 158, 123, 54, // 8792: decode to SC_W using decoder 54
5347 // 8792: }
5348 3, 0, // 8796: case 0x3: {
5349 OPC_CheckPredicate, 55, // 8798: check predicate 55
5350 OPC_Decode, 154, 123, 54, // 8800: decode to SC_D using decoder 54
5351 // 8800: }
5352 // 8800: } // switch Inst[14:12]
5353 // 8800: }
5354 13, 19, // 8804: case 0xd: {
5355 OPC_SwitchField, 12, 3, // 8806: switch Inst[14:12] {
5356 2, 6, // 8809: case 0x2: {
5357 OPC_CheckPredicate, 54, // 8811: check predicate 54
5358 OPC_Decode, 161, 123, 54, // 8813: decode to SC_W_RL using decoder 54
5359 // 8813: }
5360 3, 0, // 8817: case 0x3: {
5361 OPC_CheckPredicate, 55, // 8819: check predicate 55
5362 OPC_Decode, 157, 123, 54, // 8821: decode to SC_D_RL using decoder 54
5363 // 8821: }
5364 // 8821: } // switch Inst[14:12]
5365 // 8821: }
5366 14, 19, // 8825: case 0xe: {
5367 OPC_SwitchField, 12, 3, // 8827: switch Inst[14:12] {
5368 2, 6, // 8830: case 0x2: {
5369 OPC_CheckPredicate, 54, // 8832: check predicate 54
5370 OPC_Decode, 159, 123, 54, // 8834: decode to SC_W_AQ using decoder 54
5371 // 8834: }
5372 3, 0, // 8838: case 0x3: {
5373 OPC_CheckPredicate, 55, // 8840: check predicate 55
5374 OPC_Decode, 155, 123, 54, // 8842: decode to SC_D_AQ using decoder 54
5375 // 8842: }
5376 // 8842: } // switch Inst[14:12]
5377 // 8842: }
5378 15, 19, // 8846: case 0xf: {
5379 OPC_SwitchField, 12, 3, // 8848: switch Inst[14:12] {
5380 2, 6, // 8851: case 0x2: {
5381 OPC_CheckPredicate, 54, // 8853: check predicate 54
5382 OPC_Decode, 160, 123, 54, // 8855: decode to SC_W_AQRL using decoder 54
5383 // 8855: }
5384 3, 0, // 8859: case 0x3: {
5385 OPC_CheckPredicate, 55, // 8861: check predicate 55
5386 OPC_Decode, 156, 123, 54, // 8863: decode to SC_D_AQRL using decoder 54
5387 // 8863: }
5388 // 8863: } // switch Inst[14:12]
5389 // 8863: }
5390 16, 35, // 8867: case 0x10: {
5391 OPC_SwitchField, 12, 3, // 8869: switch Inst[14:12] {
5392 0, 6, // 8872: case 0x0: {
5393 OPC_CheckPredicate, 51, // 8874: check predicate 51
5394 OPC_Decode, 155, 110, 54, // 8876: decode to AMOXOR_B using decoder 54
5395 // 8876: }
5396 1, 6, // 8880: case 0x1: {
5397 OPC_CheckPredicate, 51, // 8882: check predicate 51
5398 OPC_Decode, 163, 110, 54, // 8884: decode to AMOXOR_H using decoder 54
5399 // 8884: }
5400 2, 6, // 8888: case 0x2: {
5401 OPC_CheckPredicate, 52, // 8890: check predicate 52
5402 OPC_Decode, 167, 110, 54, // 8892: decode to AMOXOR_W using decoder 54
5403 // 8892: }
5404 3, 0, // 8896: case 0x3: {
5405 OPC_CheckPredicate, 53, // 8898: check predicate 53
5406 OPC_Decode, 159, 110, 54, // 8900: decode to AMOXOR_D using decoder 54
5407 // 8900: }
5408 // 8900: } // switch Inst[14:12]
5409 // 8900: }
5410 17, 35, // 8904: case 0x11: {
5411 OPC_SwitchField, 12, 3, // 8906: switch Inst[14:12] {
5412 0, 6, // 8909: case 0x0: {
5413 OPC_CheckPredicate, 51, // 8911: check predicate 51
5414 OPC_Decode, 158, 110, 54, // 8913: decode to AMOXOR_B_RL using decoder 54
5415 // 8913: }
5416 1, 6, // 8917: case 0x1: {
5417 OPC_CheckPredicate, 51, // 8919: check predicate 51
5418 OPC_Decode, 166, 110, 54, // 8921: decode to AMOXOR_H_RL using decoder 54
5419 // 8921: }
5420 2, 6, // 8925: case 0x2: {
5421 OPC_CheckPredicate, 52, // 8927: check predicate 52
5422 OPC_Decode, 170, 110, 54, // 8929: decode to AMOXOR_W_RL using decoder 54
5423 // 8929: }
5424 3, 0, // 8933: case 0x3: {
5425 OPC_CheckPredicate, 53, // 8935: check predicate 53
5426 OPC_Decode, 162, 110, 54, // 8937: decode to AMOXOR_D_RL using decoder 54
5427 // 8937: }
5428 // 8937: } // switch Inst[14:12]
5429 // 8937: }
5430 18, 35, // 8941: case 0x12: {
5431 OPC_SwitchField, 12, 3, // 8943: switch Inst[14:12] {
5432 0, 6, // 8946: case 0x0: {
5433 OPC_CheckPredicate, 51, // 8948: check predicate 51
5434 OPC_Decode, 156, 110, 54, // 8950: decode to AMOXOR_B_AQ using decoder 54
5435 // 8950: }
5436 1, 6, // 8954: case 0x1: {
5437 OPC_CheckPredicate, 51, // 8956: check predicate 51
5438 OPC_Decode, 164, 110, 54, // 8958: decode to AMOXOR_H_AQ using decoder 54
5439 // 8958: }
5440 2, 6, // 8962: case 0x2: {
5441 OPC_CheckPredicate, 52, // 8964: check predicate 52
5442 OPC_Decode, 168, 110, 54, // 8966: decode to AMOXOR_W_AQ using decoder 54
5443 // 8966: }
5444 3, 0, // 8970: case 0x3: {
5445 OPC_CheckPredicate, 53, // 8972: check predicate 53
5446 OPC_Decode, 160, 110, 54, // 8974: decode to AMOXOR_D_AQ using decoder 54
5447 // 8974: }
5448 // 8974: } // switch Inst[14:12]
5449 // 8974: }
5450 19, 35, // 8978: case 0x13: {
5451 OPC_SwitchField, 12, 3, // 8980: switch Inst[14:12] {
5452 0, 6, // 8983: case 0x0: {
5453 OPC_CheckPredicate, 51, // 8985: check predicate 51
5454 OPC_Decode, 157, 110, 54, // 8987: decode to AMOXOR_B_AQRL using decoder 54
5455 // 8987: }
5456 1, 6, // 8991: case 0x1: {
5457 OPC_CheckPredicate, 51, // 8993: check predicate 51
5458 OPC_Decode, 165, 110, 54, // 8995: decode to AMOXOR_H_AQRL using decoder 54
5459 // 8995: }
5460 2, 6, // 8999: case 0x2: {
5461 OPC_CheckPredicate, 52, // 9001: check predicate 52
5462 OPC_Decode, 169, 110, 54, // 9003: decode to AMOXOR_W_AQRL using decoder 54
5463 // 9003: }
5464 3, 0, // 9007: case 0x3: {
5465 OPC_CheckPredicate, 53, // 9009: check predicate 53
5466 OPC_Decode, 161, 110, 54, // 9011: decode to AMOXOR_D_AQRL using decoder 54
5467 // 9011: }
5468 // 9011: } // switch Inst[14:12]
5469 // 9011: }
5470 20, 43, // 9015: case 0x14: {
5471 OPC_SwitchField, 12, 3, // 9017: switch Inst[14:12] {
5472 0, 6, // 9020: case 0x0: {
5473 OPC_CheckPredicate, 56, // 9022: check predicate 56
5474 OPC_Decode, 163, 109, 55, // 9024: decode to AMOCAS_B using decoder 55
5475 // 9024: }
5476 1, 6, // 9028: case 0x1: {
5477 OPC_CheckPredicate, 56, // 9030: check predicate 56
5478 OPC_Decode, 175, 109, 55, // 9032: decode to AMOCAS_H using decoder 55
5479 // 9032: }
5480 2, 6, // 9036: case 0x2: {
5481 OPC_CheckPredicate, 57, // 9038: check predicate 57
5482 OPC_Decode, 183, 109, 55, // 9040: decode to AMOCAS_W using decoder 55
5483 // 9040: }
5484 3, 6, // 9044: case 0x3: {
5485 OPC_CheckPredicate, 58, // 9046: check predicate 58
5486 OPC_Decode, 171, 109, 55, // 9048: decode to AMOCAS_D_RV64 using decoder 55
5487 // 9048: }
5488 4, 0, // 9052: case 0x4: {
5489 OPC_CheckPredicate, 58, // 9054: check predicate 58
5490 OPC_Decode, 179, 109, 56, // 9056: decode to AMOCAS_Q using decoder 56
5491 // 9056: }
5492 // 9056: } // switch Inst[14:12]
5493 // 9056: }
5494 21, 43, // 9060: case 0x15: {
5495 OPC_SwitchField, 12, 3, // 9062: switch Inst[14:12] {
5496 0, 6, // 9065: case 0x0: {
5497 OPC_CheckPredicate, 56, // 9067: check predicate 56
5498 OPC_Decode, 166, 109, 55, // 9069: decode to AMOCAS_B_RL using decoder 55
5499 // 9069: }
5500 1, 6, // 9073: case 0x1: {
5501 OPC_CheckPredicate, 56, // 9075: check predicate 56
5502 OPC_Decode, 178, 109, 55, // 9077: decode to AMOCAS_H_RL using decoder 55
5503 // 9077: }
5504 2, 6, // 9081: case 0x2: {
5505 OPC_CheckPredicate, 57, // 9083: check predicate 57
5506 OPC_Decode, 186, 109, 55, // 9085: decode to AMOCAS_W_RL using decoder 55
5507 // 9085: }
5508 3, 6, // 9089: case 0x3: {
5509 OPC_CheckPredicate, 58, // 9091: check predicate 58
5510 OPC_Decode, 174, 109, 55, // 9093: decode to AMOCAS_D_RV64_RL using decoder 55
5511 // 9093: }
5512 4, 0, // 9097: case 0x4: {
5513 OPC_CheckPredicate, 58, // 9099: check predicate 58
5514 OPC_Decode, 182, 109, 56, // 9101: decode to AMOCAS_Q_RL using decoder 56
5515 // 9101: }
5516 // 9101: } // switch Inst[14:12]
5517 // 9101: }
5518 22, 43, // 9105: case 0x16: {
5519 OPC_SwitchField, 12, 3, // 9107: switch Inst[14:12] {
5520 0, 6, // 9110: case 0x0: {
5521 OPC_CheckPredicate, 56, // 9112: check predicate 56
5522 OPC_Decode, 164, 109, 55, // 9114: decode to AMOCAS_B_AQ using decoder 55
5523 // 9114: }
5524 1, 6, // 9118: case 0x1: {
5525 OPC_CheckPredicate, 56, // 9120: check predicate 56
5526 OPC_Decode, 176, 109, 55, // 9122: decode to AMOCAS_H_AQ using decoder 55
5527 // 9122: }
5528 2, 6, // 9126: case 0x2: {
5529 OPC_CheckPredicate, 57, // 9128: check predicate 57
5530 OPC_Decode, 184, 109, 55, // 9130: decode to AMOCAS_W_AQ using decoder 55
5531 // 9130: }
5532 3, 6, // 9134: case 0x3: {
5533 OPC_CheckPredicate, 58, // 9136: check predicate 58
5534 OPC_Decode, 172, 109, 55, // 9138: decode to AMOCAS_D_RV64_AQ using decoder 55
5535 // 9138: }
5536 4, 0, // 9142: case 0x4: {
5537 OPC_CheckPredicate, 58, // 9144: check predicate 58
5538 OPC_Decode, 180, 109, 56, // 9146: decode to AMOCAS_Q_AQ using decoder 56
5539 // 9146: }
5540 // 9146: } // switch Inst[14:12]
5541 // 9146: }
5542 23, 43, // 9150: case 0x17: {
5543 OPC_SwitchField, 12, 3, // 9152: switch Inst[14:12] {
5544 0, 6, // 9155: case 0x0: {
5545 OPC_CheckPredicate, 56, // 9157: check predicate 56
5546 OPC_Decode, 165, 109, 55, // 9159: decode to AMOCAS_B_AQRL using decoder 55
5547 // 9159: }
5548 1, 6, // 9163: case 0x1: {
5549 OPC_CheckPredicate, 56, // 9165: check predicate 56
5550 OPC_Decode, 177, 109, 55, // 9167: decode to AMOCAS_H_AQRL using decoder 55
5551 // 9167: }
5552 2, 6, // 9171: case 0x2: {
5553 OPC_CheckPredicate, 57, // 9173: check predicate 57
5554 OPC_Decode, 185, 109, 55, // 9175: decode to AMOCAS_W_AQRL using decoder 55
5555 // 9175: }
5556 3, 6, // 9179: case 0x3: {
5557 OPC_CheckPredicate, 58, // 9181: check predicate 58
5558 OPC_Decode, 173, 109, 55, // 9183: decode to AMOCAS_D_RV64_AQRL using decoder 55
5559 // 9183: }
5560 4, 0, // 9187: case 0x4: {
5561 OPC_CheckPredicate, 58, // 9189: check predicate 58
5562 OPC_Decode, 181, 109, 56, // 9191: decode to AMOCAS_Q_AQRL using decoder 56
5563 // 9191: }
5564 // 9191: } // switch Inst[14:12]
5565 // 9191: }
5566 26, 51, // 9195: case 0x1a: {
5567 OPC_SwitchField, 12, 3, // 9197: switch Inst[14:12] {
5568 0, 10, // 9200: case 0x0: {
5569 OPC_CheckPredicate, 59, // 9202: check predicate 59
5570 OPC_CheckField, 20, 5, 0, // 9204: check Inst[24:20] == 0x0
5571 OPC_Decode, 175, 116, 17, // 9208: decode to LB_AQ using decoder 17
5572 // 9208: }
5573 1, 10, // 9212: case 0x1: {
5574 OPC_CheckPredicate, 59, // 9214: check predicate 59
5575 OPC_CheckField, 20, 5, 0, // 9216: check Inst[24:20] == 0x0
5576 OPC_Decode, 183, 116, 17, // 9220: decode to LH_AQ using decoder 17
5577 // 9220: }
5578 2, 10, // 9224: case 0x2: {
5579 OPC_CheckPredicate, 59, // 9226: check predicate 59
5580 OPC_CheckField, 20, 5, 0, // 9228: check Inst[24:20] == 0x0
5581 OPC_Decode, 197, 116, 17, // 9232: decode to LW_AQ using decoder 17
5582 // 9232: }
5583 3, 0, // 9236: case 0x3: {
5584 OPC_CheckPredicate, 60, // 9238: check predicate 60
5585 OPC_CheckField, 20, 5, 0, // 9240: check Inst[24:20] == 0x0
5586 OPC_Decode, 178, 116, 17, // 9244: decode to LD_AQ using decoder 17
5587 // 9244: }
5588 // 9244: } // switch Inst[14:12]
5589 // 9244: }
5590 27, 51, // 9248: case 0x1b: {
5591 OPC_SwitchField, 12, 3, // 9250: switch Inst[14:12] {
5592 0, 10, // 9253: case 0x0: {
5593 OPC_CheckPredicate, 59, // 9255: check predicate 59
5594 OPC_CheckField, 20, 5, 0, // 9257: check Inst[24:20] == 0x0
5595 OPC_Decode, 176, 116, 17, // 9261: decode to LB_AQRL using decoder 17
5596 // 9261: }
5597 1, 10, // 9265: case 0x1: {
5598 OPC_CheckPredicate, 59, // 9267: check predicate 59
5599 OPC_CheckField, 20, 5, 0, // 9269: check Inst[24:20] == 0x0
5600 OPC_Decode, 184, 116, 17, // 9273: decode to LH_AQRL using decoder 17
5601 // 9273: }
5602 2, 10, // 9277: case 0x2: {
5603 OPC_CheckPredicate, 59, // 9279: check predicate 59
5604 OPC_CheckField, 20, 5, 0, // 9281: check Inst[24:20] == 0x0
5605 OPC_Decode, 198, 116, 17, // 9285: decode to LW_AQRL using decoder 17
5606 // 9285: }
5607 3, 0, // 9289: case 0x3: {
5608 OPC_CheckPredicate, 60, // 9291: check predicate 60
5609 OPC_CheckField, 20, 5, 0, // 9293: check Inst[24:20] == 0x0
5610 OPC_Decode, 179, 116, 17, // 9297: decode to LD_AQRL using decoder 17
5611 // 9297: }
5612 // 9297: } // switch Inst[14:12]
5613 // 9297: }
5614 29, 35, // 9301: case 0x1d: {
5615 OPC_SwitchField, 7, 8, // 9303: switch Inst[14:7] {
5616 0, 6, // 9306: case 0x0: {
5617 OPC_CheckPredicate, 59, // 9308: check predicate 59
5618 OPC_Decode, 152, 123, 57, // 9310: decode to SB_RL using decoder 57
5619 // 9310: }
5620 32, 6, // 9314: case 0x20: {
5621 OPC_CheckPredicate, 59, // 9316: check predicate 59
5622 OPC_Decode, 138, 124, 57, // 9318: decode to SH_RL using decoder 57
5623 // 9318: }
5624 64, 6, // 9322: case 0x40: {
5625 OPC_CheckPredicate, 59, // 9324: check predicate 59
5626 OPC_Decode, 208, 124, 57, // 9326: decode to SW_RL using decoder 57
5627 // 9326: }
5628 96, 0, // 9330: case 0x60: {
5629 OPC_CheckPredicate, 60, // 9332: check predicate 60
5630 OPC_Decode, 164, 123, 57, // 9334: decode to SD_RL using decoder 57
5631 // 9334: }
5632 // 9334: } // switch Inst[14:7]
5633 // 9334: }
5634 31, 35, // 9338: case 0x1f: {
5635 OPC_SwitchField, 7, 8, // 9340: switch Inst[14:7] {
5636 0, 6, // 9343: case 0x0: {
5637 OPC_CheckPredicate, 59, // 9345: check predicate 59
5638 OPC_Decode, 151, 123, 57, // 9347: decode to SB_AQRL using decoder 57
5639 // 9347: }
5640 32, 6, // 9351: case 0x20: {
5641 OPC_CheckPredicate, 59, // 9353: check predicate 59
5642 OPC_Decode, 136, 124, 57, // 9355: decode to SH_AQRL using decoder 57
5643 // 9355: }
5644 64, 6, // 9359: case 0x40: {
5645 OPC_CheckPredicate, 59, // 9361: check predicate 59
5646 OPC_Decode, 206, 124, 57, // 9363: decode to SW_AQRL using decoder 57
5647 // 9363: }
5648 96, 0, // 9367: case 0x60: {
5649 OPC_CheckPredicate, 60, // 9369: check predicate 60
5650 OPC_Decode, 163, 123, 57, // 9371: decode to SD_AQRL using decoder 57
5651 // 9371: }
5652 // 9371: } // switch Inst[14:7]
5653 // 9371: }
5654 32, 35, // 9375: case 0x20: {
5655 OPC_SwitchField, 12, 3, // 9377: switch Inst[14:12] {
5656 0, 6, // 9380: case 0x0: {
5657 OPC_CheckPredicate, 51, // 9382: check predicate 51
5658 OPC_Decode, 251, 109, 54, // 9384: decode to AMOOR_B using decoder 54
5659 // 9384: }
5660 1, 6, // 9388: case 0x1: {
5661 OPC_CheckPredicate, 51, // 9390: check predicate 51
5662 OPC_Decode, 131, 110, 54, // 9392: decode to AMOOR_H using decoder 54
5663 // 9392: }
5664 2, 6, // 9396: case 0x2: {
5665 OPC_CheckPredicate, 52, // 9398: check predicate 52
5666 OPC_Decode, 135, 110, 54, // 9400: decode to AMOOR_W using decoder 54
5667 // 9400: }
5668 3, 0, // 9404: case 0x3: {
5669 OPC_CheckPredicate, 53, // 9406: check predicate 53
5670 OPC_Decode, 255, 109, 54, // 9408: decode to AMOOR_D using decoder 54
5671 // 9408: }
5672 // 9408: } // switch Inst[14:12]
5673 // 9408: }
5674 33, 35, // 9412: case 0x21: {
5675 OPC_SwitchField, 12, 3, // 9414: switch Inst[14:12] {
5676 0, 6, // 9417: case 0x0: {
5677 OPC_CheckPredicate, 51, // 9419: check predicate 51
5678 OPC_Decode, 254, 109, 54, // 9421: decode to AMOOR_B_RL using decoder 54
5679 // 9421: }
5680 1, 6, // 9425: case 0x1: {
5681 OPC_CheckPredicate, 51, // 9427: check predicate 51
5682 OPC_Decode, 134, 110, 54, // 9429: decode to AMOOR_H_RL using decoder 54
5683 // 9429: }
5684 2, 6, // 9433: case 0x2: {
5685 OPC_CheckPredicate, 52, // 9435: check predicate 52
5686 OPC_Decode, 138, 110, 54, // 9437: decode to AMOOR_W_RL using decoder 54
5687 // 9437: }
5688 3, 0, // 9441: case 0x3: {
5689 OPC_CheckPredicate, 53, // 9443: check predicate 53
5690 OPC_Decode, 130, 110, 54, // 9445: decode to AMOOR_D_RL using decoder 54
5691 // 9445: }
5692 // 9445: } // switch Inst[14:12]
5693 // 9445: }
5694 34, 35, // 9449: case 0x22: {
5695 OPC_SwitchField, 12, 3, // 9451: switch Inst[14:12] {
5696 0, 6, // 9454: case 0x0: {
5697 OPC_CheckPredicate, 51, // 9456: check predicate 51
5698 OPC_Decode, 252, 109, 54, // 9458: decode to AMOOR_B_AQ using decoder 54
5699 // 9458: }
5700 1, 6, // 9462: case 0x1: {
5701 OPC_CheckPredicate, 51, // 9464: check predicate 51
5702 OPC_Decode, 132, 110, 54, // 9466: decode to AMOOR_H_AQ using decoder 54
5703 // 9466: }
5704 2, 6, // 9470: case 0x2: {
5705 OPC_CheckPredicate, 52, // 9472: check predicate 52
5706 OPC_Decode, 136, 110, 54, // 9474: decode to AMOOR_W_AQ using decoder 54
5707 // 9474: }
5708 3, 0, // 9478: case 0x3: {
5709 OPC_CheckPredicate, 53, // 9480: check predicate 53
5710 OPC_Decode, 128, 110, 54, // 9482: decode to AMOOR_D_AQ using decoder 54
5711 // 9482: }
5712 // 9482: } // switch Inst[14:12]
5713 // 9482: }
5714 35, 35, // 9486: case 0x23: {
5715 OPC_SwitchField, 12, 3, // 9488: switch Inst[14:12] {
5716 0, 6, // 9491: case 0x0: {
5717 OPC_CheckPredicate, 51, // 9493: check predicate 51
5718 OPC_Decode, 253, 109, 54, // 9495: decode to AMOOR_B_AQRL using decoder 54
5719 // 9495: }
5720 1, 6, // 9499: case 0x1: {
5721 OPC_CheckPredicate, 51, // 9501: check predicate 51
5722 OPC_Decode, 133, 110, 54, // 9503: decode to AMOOR_H_AQRL using decoder 54
5723 // 9503: }
5724 2, 6, // 9507: case 0x2: {
5725 OPC_CheckPredicate, 52, // 9509: check predicate 52
5726 OPC_Decode, 137, 110, 54, // 9511: decode to AMOOR_W_AQRL using decoder 54
5727 // 9511: }
5728 3, 0, // 9515: case 0x3: {
5729 OPC_CheckPredicate, 53, // 9517: check predicate 53
5730 OPC_Decode, 129, 110, 54, // 9519: decode to AMOOR_D_AQRL using decoder 54
5731 // 9519: }
5732 // 9519: } // switch Inst[14:12]
5733 // 9519: }
5734 36, 19, // 9523: case 0x24: {
5735 OPC_SwitchField, 12, 3, // 9525: switch Inst[14:12] {
5736 2, 6, // 9528: case 0x2: {
5737 OPC_CheckPredicate, 61, // 9530: check predicate 61
5738 OPC_Decode, 187, 124, 54, // 9532: decode to SSAMOSWAP_W using decoder 54
5739 // 9532: }
5740 3, 0, // 9536: case 0x3: {
5741 OPC_CheckPredicate, 62, // 9538: check predicate 62
5742 OPC_Decode, 183, 124, 54, // 9540: decode to SSAMOSWAP_D using decoder 54
5743 // 9540: }
5744 // 9540: } // switch Inst[14:12]
5745 // 9540: }
5746 37, 19, // 9544: case 0x25: {
5747 OPC_SwitchField, 12, 3, // 9546: switch Inst[14:12] {
5748 2, 6, // 9549: case 0x2: {
5749 OPC_CheckPredicate, 61, // 9551: check predicate 61
5750 OPC_Decode, 190, 124, 54, // 9553: decode to SSAMOSWAP_W_RL using decoder 54
5751 // 9553: }
5752 3, 0, // 9557: case 0x3: {
5753 OPC_CheckPredicate, 62, // 9559: check predicate 62
5754 OPC_Decode, 186, 124, 54, // 9561: decode to SSAMOSWAP_D_RL using decoder 54
5755 // 9561: }
5756 // 9561: } // switch Inst[14:12]
5757 // 9561: }
5758 38, 19, // 9565: case 0x26: {
5759 OPC_SwitchField, 12, 3, // 9567: switch Inst[14:12] {
5760 2, 6, // 9570: case 0x2: {
5761 OPC_CheckPredicate, 61, // 9572: check predicate 61
5762 OPC_Decode, 188, 124, 54, // 9574: decode to SSAMOSWAP_W_AQ using decoder 54
5763 // 9574: }
5764 3, 0, // 9578: case 0x3: {
5765 OPC_CheckPredicate, 62, // 9580: check predicate 62
5766 OPC_Decode, 184, 124, 54, // 9582: decode to SSAMOSWAP_D_AQ using decoder 54
5767 // 9582: }
5768 // 9582: } // switch Inst[14:12]
5769 // 9582: }
5770 39, 19, // 9586: case 0x27: {
5771 OPC_SwitchField, 12, 3, // 9588: switch Inst[14:12] {
5772 2, 6, // 9591: case 0x2: {
5773 OPC_CheckPredicate, 61, // 9593: check predicate 61
5774 OPC_Decode, 189, 124, 54, // 9595: decode to SSAMOSWAP_W_AQRL using decoder 54
5775 // 9595: }
5776 3, 0, // 9599: case 0x3: {
5777 OPC_CheckPredicate, 62, // 9601: check predicate 62
5778 OPC_Decode, 185, 124, 54, // 9603: decode to SSAMOSWAP_D_AQRL using decoder 54
5779 // 9603: }
5780 // 9603: } // switch Inst[14:12]
5781 // 9603: }
5782 48, 35, // 9607: case 0x30: {
5783 OPC_SwitchField, 12, 3, // 9609: switch Inst[14:12] {
5784 0, 6, // 9612: case 0x0: {
5785 OPC_CheckPredicate, 51, // 9614: check predicate 51
5786 OPC_Decode, 147, 109, 54, // 9616: decode to AMOAND_B using decoder 54
5787 // 9616: }
5788 1, 6, // 9620: case 0x1: {
5789 OPC_CheckPredicate, 51, // 9622: check predicate 51
5790 OPC_Decode, 155, 109, 54, // 9624: decode to AMOAND_H using decoder 54
5791 // 9624: }
5792 2, 6, // 9628: case 0x2: {
5793 OPC_CheckPredicate, 52, // 9630: check predicate 52
5794 OPC_Decode, 159, 109, 54, // 9632: decode to AMOAND_W using decoder 54
5795 // 9632: }
5796 3, 0, // 9636: case 0x3: {
5797 OPC_CheckPredicate, 53, // 9638: check predicate 53
5798 OPC_Decode, 151, 109, 54, // 9640: decode to AMOAND_D using decoder 54
5799 // 9640: }
5800 // 9640: } // switch Inst[14:12]
5801 // 9640: }
5802 49, 35, // 9644: case 0x31: {
5803 OPC_SwitchField, 12, 3, // 9646: switch Inst[14:12] {
5804 0, 6, // 9649: case 0x0: {
5805 OPC_CheckPredicate, 51, // 9651: check predicate 51
5806 OPC_Decode, 150, 109, 54, // 9653: decode to AMOAND_B_RL using decoder 54
5807 // 9653: }
5808 1, 6, // 9657: case 0x1: {
5809 OPC_CheckPredicate, 51, // 9659: check predicate 51
5810 OPC_Decode, 158, 109, 54, // 9661: decode to AMOAND_H_RL using decoder 54
5811 // 9661: }
5812 2, 6, // 9665: case 0x2: {
5813 OPC_CheckPredicate, 52, // 9667: check predicate 52
5814 OPC_Decode, 162, 109, 54, // 9669: decode to AMOAND_W_RL using decoder 54
5815 // 9669: }
5816 3, 0, // 9673: case 0x3: {
5817 OPC_CheckPredicate, 53, // 9675: check predicate 53
5818 OPC_Decode, 154, 109, 54, // 9677: decode to AMOAND_D_RL using decoder 54
5819 // 9677: }
5820 // 9677: } // switch Inst[14:12]
5821 // 9677: }
5822 50, 35, // 9681: case 0x32: {
5823 OPC_SwitchField, 12, 3, // 9683: switch Inst[14:12] {
5824 0, 6, // 9686: case 0x0: {
5825 OPC_CheckPredicate, 51, // 9688: check predicate 51
5826 OPC_Decode, 148, 109, 54, // 9690: decode to AMOAND_B_AQ using decoder 54
5827 // 9690: }
5828 1, 6, // 9694: case 0x1: {
5829 OPC_CheckPredicate, 51, // 9696: check predicate 51
5830 OPC_Decode, 156, 109, 54, // 9698: decode to AMOAND_H_AQ using decoder 54
5831 // 9698: }
5832 2, 6, // 9702: case 0x2: {
5833 OPC_CheckPredicate, 52, // 9704: check predicate 52
5834 OPC_Decode, 160, 109, 54, // 9706: decode to AMOAND_W_AQ using decoder 54
5835 // 9706: }
5836 3, 0, // 9710: case 0x3: {
5837 OPC_CheckPredicate, 53, // 9712: check predicate 53
5838 OPC_Decode, 152, 109, 54, // 9714: decode to AMOAND_D_AQ using decoder 54
5839 // 9714: }
5840 // 9714: } // switch Inst[14:12]
5841 // 9714: }
5842 51, 35, // 9718: case 0x33: {
5843 OPC_SwitchField, 12, 3, // 9720: switch Inst[14:12] {
5844 0, 6, // 9723: case 0x0: {
5845 OPC_CheckPredicate, 51, // 9725: check predicate 51
5846 OPC_Decode, 149, 109, 54, // 9727: decode to AMOAND_B_AQRL using decoder 54
5847 // 9727: }
5848 1, 6, // 9731: case 0x1: {
5849 OPC_CheckPredicate, 51, // 9733: check predicate 51
5850 OPC_Decode, 157, 109, 54, // 9735: decode to AMOAND_H_AQRL using decoder 54
5851 // 9735: }
5852 2, 6, // 9739: case 0x2: {
5853 OPC_CheckPredicate, 52, // 9741: check predicate 52
5854 OPC_Decode, 161, 109, 54, // 9743: decode to AMOAND_W_AQRL using decoder 54
5855 // 9743: }
5856 3, 0, // 9747: case 0x3: {
5857 OPC_CheckPredicate, 53, // 9749: check predicate 53
5858 OPC_Decode, 153, 109, 54, // 9751: decode to AMOAND_D_AQRL using decoder 54
5859 // 9751: }
5860 // 9751: } // switch Inst[14:12]
5861 // 9751: }
5862 64, 35, // 9755: case 0x40: {
5863 OPC_SwitchField, 12, 3, // 9757: switch Inst[14:12] {
5864 0, 6, // 9760: case 0x0: {
5865 OPC_CheckPredicate, 51, // 9762: check predicate 51
5866 OPC_Decode, 235, 109, 54, // 9764: decode to AMOMIN_B using decoder 54
5867 // 9764: }
5868 1, 6, // 9768: case 0x1: {
5869 OPC_CheckPredicate, 51, // 9770: check predicate 51
5870 OPC_Decode, 243, 109, 54, // 9772: decode to AMOMIN_H using decoder 54
5871 // 9772: }
5872 2, 6, // 9776: case 0x2: {
5873 OPC_CheckPredicate, 52, // 9778: check predicate 52
5874 OPC_Decode, 247, 109, 54, // 9780: decode to AMOMIN_W using decoder 54
5875 // 9780: }
5876 3, 0, // 9784: case 0x3: {
5877 OPC_CheckPredicate, 53, // 9786: check predicate 53
5878 OPC_Decode, 239, 109, 54, // 9788: decode to AMOMIN_D using decoder 54
5879 // 9788: }
5880 // 9788: } // switch Inst[14:12]
5881 // 9788: }
5882 65, 35, // 9792: case 0x41: {
5883 OPC_SwitchField, 12, 3, // 9794: switch Inst[14:12] {
5884 0, 6, // 9797: case 0x0: {
5885 OPC_CheckPredicate, 51, // 9799: check predicate 51
5886 OPC_Decode, 238, 109, 54, // 9801: decode to AMOMIN_B_RL using decoder 54
5887 // 9801: }
5888 1, 6, // 9805: case 0x1: {
5889 OPC_CheckPredicate, 51, // 9807: check predicate 51
5890 OPC_Decode, 246, 109, 54, // 9809: decode to AMOMIN_H_RL using decoder 54
5891 // 9809: }
5892 2, 6, // 9813: case 0x2: {
5893 OPC_CheckPredicate, 52, // 9815: check predicate 52
5894 OPC_Decode, 250, 109, 54, // 9817: decode to AMOMIN_W_RL using decoder 54
5895 // 9817: }
5896 3, 0, // 9821: case 0x3: {
5897 OPC_CheckPredicate, 53, // 9823: check predicate 53
5898 OPC_Decode, 242, 109, 54, // 9825: decode to AMOMIN_D_RL using decoder 54
5899 // 9825: }
5900 // 9825: } // switch Inst[14:12]
5901 // 9825: }
5902 66, 35, // 9829: case 0x42: {
5903 OPC_SwitchField, 12, 3, // 9831: switch Inst[14:12] {
5904 0, 6, // 9834: case 0x0: {
5905 OPC_CheckPredicate, 51, // 9836: check predicate 51
5906 OPC_Decode, 236, 109, 54, // 9838: decode to AMOMIN_B_AQ using decoder 54
5907 // 9838: }
5908 1, 6, // 9842: case 0x1: {
5909 OPC_CheckPredicate, 51, // 9844: check predicate 51
5910 OPC_Decode, 244, 109, 54, // 9846: decode to AMOMIN_H_AQ using decoder 54
5911 // 9846: }
5912 2, 6, // 9850: case 0x2: {
5913 OPC_CheckPredicate, 52, // 9852: check predicate 52
5914 OPC_Decode, 248, 109, 54, // 9854: decode to AMOMIN_W_AQ using decoder 54
5915 // 9854: }
5916 3, 0, // 9858: case 0x3: {
5917 OPC_CheckPredicate, 53, // 9860: check predicate 53
5918 OPC_Decode, 240, 109, 54, // 9862: decode to AMOMIN_D_AQ using decoder 54
5919 // 9862: }
5920 // 9862: } // switch Inst[14:12]
5921 // 9862: }
5922 67, 35, // 9866: case 0x43: {
5923 OPC_SwitchField, 12, 3, // 9868: switch Inst[14:12] {
5924 0, 6, // 9871: case 0x0: {
5925 OPC_CheckPredicate, 51, // 9873: check predicate 51
5926 OPC_Decode, 237, 109, 54, // 9875: decode to AMOMIN_B_AQRL using decoder 54
5927 // 9875: }
5928 1, 6, // 9879: case 0x1: {
5929 OPC_CheckPredicate, 51, // 9881: check predicate 51
5930 OPC_Decode, 245, 109, 54, // 9883: decode to AMOMIN_H_AQRL using decoder 54
5931 // 9883: }
5932 2, 6, // 9887: case 0x2: {
5933 OPC_CheckPredicate, 52, // 9889: check predicate 52
5934 OPC_Decode, 249, 109, 54, // 9891: decode to AMOMIN_W_AQRL using decoder 54
5935 // 9891: }
5936 3, 0, // 9895: case 0x3: {
5937 OPC_CheckPredicate, 53, // 9897: check predicate 53
5938 OPC_Decode, 241, 109, 54, // 9899: decode to AMOMIN_D_AQRL using decoder 54
5939 // 9899: }
5940 // 9899: } // switch Inst[14:12]
5941 // 9899: }
5942 80, 35, // 9903: case 0x50: {
5943 OPC_SwitchField, 12, 3, // 9905: switch Inst[14:12] {
5944 0, 6, // 9908: case 0x0: {
5945 OPC_CheckPredicate, 51, // 9910: check predicate 51
5946 OPC_Decode, 203, 109, 54, // 9912: decode to AMOMAX_B using decoder 54
5947 // 9912: }
5948 1, 6, // 9916: case 0x1: {
5949 OPC_CheckPredicate, 51, // 9918: check predicate 51
5950 OPC_Decode, 211, 109, 54, // 9920: decode to AMOMAX_H using decoder 54
5951 // 9920: }
5952 2, 6, // 9924: case 0x2: {
5953 OPC_CheckPredicate, 52, // 9926: check predicate 52
5954 OPC_Decode, 215, 109, 54, // 9928: decode to AMOMAX_W using decoder 54
5955 // 9928: }
5956 3, 0, // 9932: case 0x3: {
5957 OPC_CheckPredicate, 53, // 9934: check predicate 53
5958 OPC_Decode, 207, 109, 54, // 9936: decode to AMOMAX_D using decoder 54
5959 // 9936: }
5960 // 9936: } // switch Inst[14:12]
5961 // 9936: }
5962 81, 35, // 9940: case 0x51: {
5963 OPC_SwitchField, 12, 3, // 9942: switch Inst[14:12] {
5964 0, 6, // 9945: case 0x0: {
5965 OPC_CheckPredicate, 51, // 9947: check predicate 51
5966 OPC_Decode, 206, 109, 54, // 9949: decode to AMOMAX_B_RL using decoder 54
5967 // 9949: }
5968 1, 6, // 9953: case 0x1: {
5969 OPC_CheckPredicate, 51, // 9955: check predicate 51
5970 OPC_Decode, 214, 109, 54, // 9957: decode to AMOMAX_H_RL using decoder 54
5971 // 9957: }
5972 2, 6, // 9961: case 0x2: {
5973 OPC_CheckPredicate, 52, // 9963: check predicate 52
5974 OPC_Decode, 218, 109, 54, // 9965: decode to AMOMAX_W_RL using decoder 54
5975 // 9965: }
5976 3, 0, // 9969: case 0x3: {
5977 OPC_CheckPredicate, 53, // 9971: check predicate 53
5978 OPC_Decode, 210, 109, 54, // 9973: decode to AMOMAX_D_RL using decoder 54
5979 // 9973: }
5980 // 9973: } // switch Inst[14:12]
5981 // 9973: }
5982 82, 35, // 9977: case 0x52: {
5983 OPC_SwitchField, 12, 3, // 9979: switch Inst[14:12] {
5984 0, 6, // 9982: case 0x0: {
5985 OPC_CheckPredicate, 51, // 9984: check predicate 51
5986 OPC_Decode, 204, 109, 54, // 9986: decode to AMOMAX_B_AQ using decoder 54
5987 // 9986: }
5988 1, 6, // 9990: case 0x1: {
5989 OPC_CheckPredicate, 51, // 9992: check predicate 51
5990 OPC_Decode, 212, 109, 54, // 9994: decode to AMOMAX_H_AQ using decoder 54
5991 // 9994: }
5992 2, 6, // 9998: case 0x2: {
5993 OPC_CheckPredicate, 52, // 10000: check predicate 52
5994 OPC_Decode, 216, 109, 54, // 10002: decode to AMOMAX_W_AQ using decoder 54
5995 // 10002: }
5996 3, 0, // 10006: case 0x3: {
5997 OPC_CheckPredicate, 53, // 10008: check predicate 53
5998 OPC_Decode, 208, 109, 54, // 10010: decode to AMOMAX_D_AQ using decoder 54
5999 // 10010: }
6000 // 10010: } // switch Inst[14:12]
6001 // 10010: }
6002 83, 35, // 10014: case 0x53: {
6003 OPC_SwitchField, 12, 3, // 10016: switch Inst[14:12] {
6004 0, 6, // 10019: case 0x0: {
6005 OPC_CheckPredicate, 51, // 10021: check predicate 51
6006 OPC_Decode, 205, 109, 54, // 10023: decode to AMOMAX_B_AQRL using decoder 54
6007 // 10023: }
6008 1, 6, // 10027: case 0x1: {
6009 OPC_CheckPredicate, 51, // 10029: check predicate 51
6010 OPC_Decode, 213, 109, 54, // 10031: decode to AMOMAX_H_AQRL using decoder 54
6011 // 10031: }
6012 2, 6, // 10035: case 0x2: {
6013 OPC_CheckPredicate, 52, // 10037: check predicate 52
6014 OPC_Decode, 217, 109, 54, // 10039: decode to AMOMAX_W_AQRL using decoder 54
6015 // 10039: }
6016 3, 0, // 10043: case 0x3: {
6017 OPC_CheckPredicate, 53, // 10045: check predicate 53
6018 OPC_Decode, 209, 109, 54, // 10047: decode to AMOMAX_D_AQRL using decoder 54
6019 // 10047: }
6020 // 10047: } // switch Inst[14:12]
6021 // 10047: }
6022 96, 35, // 10051: case 0x60: {
6023 OPC_SwitchField, 12, 3, // 10053: switch Inst[14:12] {
6024 0, 6, // 10056: case 0x0: {
6025 OPC_CheckPredicate, 51, // 10058: check predicate 51
6026 OPC_Decode, 219, 109, 54, // 10060: decode to AMOMINU_B using decoder 54
6027 // 10060: }
6028 1, 6, // 10064: case 0x1: {
6029 OPC_CheckPredicate, 51, // 10066: check predicate 51
6030 OPC_Decode, 227, 109, 54, // 10068: decode to AMOMINU_H using decoder 54
6031 // 10068: }
6032 2, 6, // 10072: case 0x2: {
6033 OPC_CheckPredicate, 52, // 10074: check predicate 52
6034 OPC_Decode, 231, 109, 54, // 10076: decode to AMOMINU_W using decoder 54
6035 // 10076: }
6036 3, 0, // 10080: case 0x3: {
6037 OPC_CheckPredicate, 53, // 10082: check predicate 53
6038 OPC_Decode, 223, 109, 54, // 10084: decode to AMOMINU_D using decoder 54
6039 // 10084: }
6040 // 10084: } // switch Inst[14:12]
6041 // 10084: }
6042 97, 35, // 10088: case 0x61: {
6043 OPC_SwitchField, 12, 3, // 10090: switch Inst[14:12] {
6044 0, 6, // 10093: case 0x0: {
6045 OPC_CheckPredicate, 51, // 10095: check predicate 51
6046 OPC_Decode, 222, 109, 54, // 10097: decode to AMOMINU_B_RL using decoder 54
6047 // 10097: }
6048 1, 6, // 10101: case 0x1: {
6049 OPC_CheckPredicate, 51, // 10103: check predicate 51
6050 OPC_Decode, 230, 109, 54, // 10105: decode to AMOMINU_H_RL using decoder 54
6051 // 10105: }
6052 2, 6, // 10109: case 0x2: {
6053 OPC_CheckPredicate, 52, // 10111: check predicate 52
6054 OPC_Decode, 234, 109, 54, // 10113: decode to AMOMINU_W_RL using decoder 54
6055 // 10113: }
6056 3, 0, // 10117: case 0x3: {
6057 OPC_CheckPredicate, 53, // 10119: check predicate 53
6058 OPC_Decode, 226, 109, 54, // 10121: decode to AMOMINU_D_RL using decoder 54
6059 // 10121: }
6060 // 10121: } // switch Inst[14:12]
6061 // 10121: }
6062 98, 35, // 10125: case 0x62: {
6063 OPC_SwitchField, 12, 3, // 10127: switch Inst[14:12] {
6064 0, 6, // 10130: case 0x0: {
6065 OPC_CheckPredicate, 51, // 10132: check predicate 51
6066 OPC_Decode, 220, 109, 54, // 10134: decode to AMOMINU_B_AQ using decoder 54
6067 // 10134: }
6068 1, 6, // 10138: case 0x1: {
6069 OPC_CheckPredicate, 51, // 10140: check predicate 51
6070 OPC_Decode, 228, 109, 54, // 10142: decode to AMOMINU_H_AQ using decoder 54
6071 // 10142: }
6072 2, 6, // 10146: case 0x2: {
6073 OPC_CheckPredicate, 52, // 10148: check predicate 52
6074 OPC_Decode, 232, 109, 54, // 10150: decode to AMOMINU_W_AQ using decoder 54
6075 // 10150: }
6076 3, 0, // 10154: case 0x3: {
6077 OPC_CheckPredicate, 53, // 10156: check predicate 53
6078 OPC_Decode, 224, 109, 54, // 10158: decode to AMOMINU_D_AQ using decoder 54
6079 // 10158: }
6080 // 10158: } // switch Inst[14:12]
6081 // 10158: }
6082 99, 35, // 10162: case 0x63: {
6083 OPC_SwitchField, 12, 3, // 10164: switch Inst[14:12] {
6084 0, 6, // 10167: case 0x0: {
6085 OPC_CheckPredicate, 51, // 10169: check predicate 51
6086 OPC_Decode, 221, 109, 54, // 10171: decode to AMOMINU_B_AQRL using decoder 54
6087 // 10171: }
6088 1, 6, // 10175: case 0x1: {
6089 OPC_CheckPredicate, 51, // 10177: check predicate 51
6090 OPC_Decode, 229, 109, 54, // 10179: decode to AMOMINU_H_AQRL using decoder 54
6091 // 10179: }
6092 2, 6, // 10183: case 0x2: {
6093 OPC_CheckPredicate, 52, // 10185: check predicate 52
6094 OPC_Decode, 233, 109, 54, // 10187: decode to AMOMINU_W_AQRL using decoder 54
6095 // 10187: }
6096 3, 0, // 10191: case 0x3: {
6097 OPC_CheckPredicate, 53, // 10193: check predicate 53
6098 OPC_Decode, 225, 109, 54, // 10195: decode to AMOMINU_D_AQRL using decoder 54
6099 // 10195: }
6100 // 10195: } // switch Inst[14:12]
6101 // 10195: }
6102 112, 35, // 10199: case 0x70: {
6103 OPC_SwitchField, 12, 3, // 10201: switch Inst[14:12] {
6104 0, 6, // 10204: case 0x0: {
6105 OPC_CheckPredicate, 51, // 10206: check predicate 51
6106 OPC_Decode, 187, 109, 54, // 10208: decode to AMOMAXU_B using decoder 54
6107 // 10208: }
6108 1, 6, // 10212: case 0x1: {
6109 OPC_CheckPredicate, 51, // 10214: check predicate 51
6110 OPC_Decode, 195, 109, 54, // 10216: decode to AMOMAXU_H using decoder 54
6111 // 10216: }
6112 2, 6, // 10220: case 0x2: {
6113 OPC_CheckPredicate, 52, // 10222: check predicate 52
6114 OPC_Decode, 199, 109, 54, // 10224: decode to AMOMAXU_W using decoder 54
6115 // 10224: }
6116 3, 0, // 10228: case 0x3: {
6117 OPC_CheckPredicate, 53, // 10230: check predicate 53
6118 OPC_Decode, 191, 109, 54, // 10232: decode to AMOMAXU_D using decoder 54
6119 // 10232: }
6120 // 10232: } // switch Inst[14:12]
6121 // 10232: }
6122 113, 35, // 10236: case 0x71: {
6123 OPC_SwitchField, 12, 3, // 10238: switch Inst[14:12] {
6124 0, 6, // 10241: case 0x0: {
6125 OPC_CheckPredicate, 51, // 10243: check predicate 51
6126 OPC_Decode, 190, 109, 54, // 10245: decode to AMOMAXU_B_RL using decoder 54
6127 // 10245: }
6128 1, 6, // 10249: case 0x1: {
6129 OPC_CheckPredicate, 51, // 10251: check predicate 51
6130 OPC_Decode, 198, 109, 54, // 10253: decode to AMOMAXU_H_RL using decoder 54
6131 // 10253: }
6132 2, 6, // 10257: case 0x2: {
6133 OPC_CheckPredicate, 52, // 10259: check predicate 52
6134 OPC_Decode, 202, 109, 54, // 10261: decode to AMOMAXU_W_RL using decoder 54
6135 // 10261: }
6136 3, 0, // 10265: case 0x3: {
6137 OPC_CheckPredicate, 53, // 10267: check predicate 53
6138 OPC_Decode, 194, 109, 54, // 10269: decode to AMOMAXU_D_RL using decoder 54
6139 // 10269: }
6140 // 10269: } // switch Inst[14:12]
6141 // 10269: }
6142 114, 35, // 10273: case 0x72: {
6143 OPC_SwitchField, 12, 3, // 10275: switch Inst[14:12] {
6144 0, 6, // 10278: case 0x0: {
6145 OPC_CheckPredicate, 51, // 10280: check predicate 51
6146 OPC_Decode, 188, 109, 54, // 10282: decode to AMOMAXU_B_AQ using decoder 54
6147 // 10282: }
6148 1, 6, // 10286: case 0x1: {
6149 OPC_CheckPredicate, 51, // 10288: check predicate 51
6150 OPC_Decode, 196, 109, 54, // 10290: decode to AMOMAXU_H_AQ using decoder 54
6151 // 10290: }
6152 2, 6, // 10294: case 0x2: {
6153 OPC_CheckPredicate, 52, // 10296: check predicate 52
6154 OPC_Decode, 200, 109, 54, // 10298: decode to AMOMAXU_W_AQ using decoder 54
6155 // 10298: }
6156 3, 0, // 10302: case 0x3: {
6157 OPC_CheckPredicate, 53, // 10304: check predicate 53
6158 OPC_Decode, 192, 109, 54, // 10306: decode to AMOMAXU_D_AQ using decoder 54
6159 // 10306: }
6160 // 10306: } // switch Inst[14:12]
6161 // 10306: }
6162 115, 0, // 10310: case 0x73: {
6163 OPC_SwitchField, 12, 3, // 10312: switch Inst[14:12] {
6164 0, 6, // 10315: case 0x0: {
6165 OPC_CheckPredicate, 51, // 10317: check predicate 51
6166 OPC_Decode, 189, 109, 54, // 10319: decode to AMOMAXU_B_AQRL using decoder 54
6167 // 10319: }
6168 1, 6, // 10323: case 0x1: {
6169 OPC_CheckPredicate, 51, // 10325: check predicate 51
6170 OPC_Decode, 197, 109, 54, // 10327: decode to AMOMAXU_H_AQRL using decoder 54
6171 // 10327: }
6172 2, 6, // 10331: case 0x2: {
6173 OPC_CheckPredicate, 52, // 10333: check predicate 52
6174 OPC_Decode, 201, 109, 54, // 10335: decode to AMOMAXU_W_AQRL using decoder 54
6175 // 10335: }
6176 3, 0, // 10339: case 0x3: {
6177 OPC_CheckPredicate, 53, // 10341: check predicate 53
6178 OPC_Decode, 193, 109, 54, // 10343: decode to AMOMAXU_D_AQRL using decoder 54
6179 // 10343: }
6180 // 10343: } // switch Inst[14:12]
6181 // 10343: }
6182 // 10343: } // switch Inst[31:25]
6183 // 10343: }
6184 51, 138, 6, // 10347: case 0x33: {
6185 OPC_SwitchField, 25, 5, // 10350: switch Inst[29:25] {
6186 0, 126, // 10353: case 0x0: {
6187 OPC_SwitchField, 12, 3, // 10355: switch Inst[14:12] {
6188 0, 15, // 10358: case 0x0: {
6189 OPC_SwitchField, 30, 2, // 10360: switch Inst[31:30] {
6190 0, 4, // 10363: case 0x0: {
6191 OPC_Decode, 157, 107, 31, // 10365: decode to ADD using decoder 31
6192 // 10365: }
6193 1, 0, // 10369: case 0x1: {
6194 OPC_Decode, 202, 124, 31, // 10371: decode to SUB using decoder 31
6195 // 10371: }
6196 // 10371: } // switch Inst[31:30]
6197 // 10371: }
6198 1, 8, // 10375: case 0x1: {
6199 OPC_CheckField, 30, 2, 0, // 10377: check Inst[31:30] == 0x0
6200 OPC_Decode, 140, 124, 31, // 10381: decode to SLL using decoder 31
6201 // 10381: }
6202 2, 8, // 10385: case 0x2: {
6203 OPC_CheckField, 30, 2, 0, // 10387: check Inst[31:30] == 0x0
6204 OPC_Decode, 145, 124, 31, // 10391: decode to SLT using decoder 31
6205 // 10391: }
6206 3, 8, // 10395: case 0x3: {
6207 OPC_CheckField, 30, 2, 0, // 10397: check Inst[31:30] == 0x0
6208 OPC_Decode, 148, 124, 31, // 10401: decode to SLTU using decoder 31
6209 // 10401: }
6210 4, 19, // 10405: case 0x4: {
6211 OPC_SwitchField, 30, 2, // 10407: switch Inst[31:30] {
6212 0, 5, // 10410: case 0x0: {
6213 OPC_Decode, 213, 131, 1, 31, // 10412: decode to XOR using decoder 31
6214 // 10412: }
6215 1, 0, // 10417: case 0x1: {
6216 OPC_CheckPredicate, 43, // 10419: check predicate 43
6217 OPC_Decode, 212, 131, 1, 31, // 10421: decode to XNOR using decoder 31
6218 // 10421: }
6219 // 10421: } // switch Inst[31:30]
6220 // 10421: }
6221 5, 15, // 10426: case 0x5: {
6222 OPC_SwitchField, 30, 2, // 10428: switch Inst[31:30] {
6223 0, 4, // 10431: case 0x0: {
6224 OPC_Decode, 177, 124, 31, // 10433: decode to SRL using decoder 31
6225 // 10433: }
6226 1, 0, // 10437: case 0x1: {
6227 OPC_Decode, 170, 124, 31, // 10439: decode to SRA using decoder 31
6228 // 10439: }
6229 // 10439: } // switch Inst[31:30]
6230 // 10439: }
6231 6, 17, // 10443: case 0x6: {
6232 OPC_SwitchField, 30, 2, // 10445: switch Inst[31:30] {
6233 0, 4, // 10448: case 0x0: {
6234 OPC_Decode, 136, 118, 31, // 10450: decode to OR using decoder 31
6235 // 10450: }
6236 1, 0, // 10454: case 0x1: {
6237 OPC_CheckPredicate, 43, // 10456: check predicate 43
6238 OPC_Decode, 139, 118, 31, // 10458: decode to ORN using decoder 31
6239 // 10458: }
6240 // 10458: } // switch Inst[31:30]
6241 // 10458: }
6242 7, 0, // 10462: case 0x7: {
6243 OPC_SwitchField, 30, 2, // 10464: switch Inst[31:30] {
6244 0, 4, // 10467: case 0x0: {
6245 OPC_Decode, 171, 110, 31, // 10469: decode to AND using decoder 31
6246 // 10469: }
6247 1, 0, // 10473: case 0x1: {
6248 OPC_CheckPredicate, 43, // 10475: check predicate 43
6249 OPC_Decode, 173, 110, 31, // 10477: decode to ANDN using decoder 31
6250 // 10477: }
6251 // 10477: } // switch Inst[31:30]
6252 // 10477: }
6253 // 10477: } // switch Inst[14:12]
6254 // 10477: }
6255 1, 99, // 10481: case 0x1: {
6256 OPC_SwitchField, 12, 3, // 10483: switch Inst[14:12] {
6257 0, 10, // 10486: case 0x0: {
6258 OPC_CheckPredicate, 63, // 10488: check predicate 63
6259 OPC_CheckField, 30, 2, 0, // 10490: check Inst[31:30] == 0x0
6260 OPC_Decode, 171, 117, 31, // 10494: decode to MUL using decoder 31
6261 // 10494: }
6262 1, 10, // 10498: case 0x1: {
6263 OPC_CheckPredicate, 63, // 10500: check predicate 63
6264 OPC_CheckField, 30, 2, 0, // 10502: check Inst[31:30] == 0x0
6265 OPC_Decode, 172, 117, 31, // 10506: decode to MULH using decoder 31
6266 // 10506: }
6267 2, 10, // 10510: case 0x2: {
6268 OPC_CheckPredicate, 63, // 10512: check predicate 63
6269 OPC_CheckField, 30, 2, 0, // 10514: check Inst[31:30] == 0x0
6270 OPC_Decode, 176, 117, 31, // 10518: decode to MULHSU using decoder 31
6271 // 10518: }
6272 3, 10, // 10522: case 0x3: {
6273 OPC_CheckPredicate, 63, // 10524: check predicate 63
6274 OPC_CheckField, 30, 2, 0, // 10526: check Inst[31:30] == 0x0
6275 OPC_Decode, 179, 117, 31, // 10530: decode to MULHU using decoder 31
6276 // 10530: }
6277 4, 10, // 10534: case 0x4: {
6278 OPC_CheckPredicate, 64, // 10536: check predicate 64
6279 OPC_CheckField, 30, 2, 0, // 10538: check Inst[31:30] == 0x0
6280 OPC_Decode, 227, 113, 31, // 10542: decode to DIV using decoder 31
6281 // 10542: }
6282 5, 10, // 10546: case 0x5: {
6283 OPC_CheckPredicate, 64, // 10548: check predicate 64
6284 OPC_CheckField, 30, 2, 0, // 10550: check Inst[31:30] == 0x0
6285 OPC_Decode, 228, 113, 31, // 10554: decode to DIVU using decoder 31
6286 // 10554: }
6287 6, 10, // 10558: case 0x6: {
6288 OPC_CheckPredicate, 64, // 10560: check predicate 64
6289 OPC_CheckField, 30, 2, 0, // 10562: check Inst[31:30] == 0x0
6290 OPC_Decode, 131, 123, 31, // 10566: decode to REM using decoder 31
6291 // 10566: }
6292 7, 0, // 10570: case 0x7: {
6293 OPC_CheckPredicate, 64, // 10572: check predicate 64
6294 OPC_CheckField, 30, 2, 0, // 10574: check Inst[31:30] == 0x0
6295 OPC_Decode, 132, 123, 31, // 10578: decode to REMU using decoder 31
6296 // 10578: }
6297 // 10578: } // switch Inst[14:12]
6298 // 10578: }
6299 4, 64, // 10582: case 0x4: {
6300 OPC_SwitchField, 12, 3, // 10584: switch Inst[14:12] {
6301 1, 10, // 10587: case 0x1: {
6302 OPC_CheckPredicate, 38, // 10589: check predicate 38
6303 OPC_CheckField, 30, 2, 1, // 10591: check Inst[31:30] == 0x1
6304 OPC_Decode, 177, 110, 31, // 10595: decode to BCLR using decoder 31
6305 // 10595: }
6306 4, 23, // 10599: case 0x4: {
6307 OPC_CheckField, 30, 2, 0, // 10601: check Inst[31:30] == 0x0
6308 OPC_Scope, 11, // 10605: try {
6309 OPC_CheckField, 20, 5, 0, // 10607: check Inst[24:20] == 0x0
6310 OPC_CheckPredicate, 45, // 10611: check predicate 45
6311 OPC_Decode, 236, 131, 1, 17, // 10613: decode to ZEXT_H_RV32 using decoder 17
6312 // 10613: } else try {
6313 OPC_CheckPredicate, 65, // 10618: check predicate 65
6314 OPC_Decode, 165, 118, 31, // 10620: decode to PACK using decoder 31
6315 // 10620: }
6316 // 10620: }
6317 5, 10, // 10624: case 0x5: {
6318 OPC_CheckPredicate, 38, // 10626: check predicate 38
6319 OPC_CheckField, 30, 2, 1, // 10628: check Inst[31:30] == 0x1
6320 OPC_Decode, 181, 110, 31, // 10632: decode to BEXT using decoder 31
6321 // 10632: }
6322 7, 0, // 10636: case 0x7: {
6323 OPC_CheckPredicate, 44, // 10638: check predicate 44
6324 OPC_CheckField, 30, 2, 0, // 10640: check Inst[31:30] == 0x0
6325 OPC_Decode, 166, 118, 31, // 10644: decode to PACKH using decoder 31
6326 // 10644: }
6327 // 10644: } // switch Inst[14:12]
6328 // 10644: }
6329 5, 87, // 10648: case 0x5: {
6330 OPC_SwitchField, 12, 3, // 10650: switch Inst[14:12] {
6331 1, 10, // 10653: case 0x1: {
6332 OPC_CheckPredicate, 66, // 10655: check predicate 66
6333 OPC_CheckField, 30, 2, 0, // 10657: check Inst[31:30] == 0x0
6334 OPC_Decode, 198, 110, 31, // 10661: decode to CLMUL using decoder 31
6335 // 10661: }
6336 2, 10, // 10665: case 0x2: {
6337 OPC_CheckPredicate, 67, // 10667: check predicate 67
6338 OPC_CheckField, 30, 2, 0, // 10669: check Inst[31:30] == 0x0
6339 OPC_Decode, 200, 110, 31, // 10673: decode to CLMULR using decoder 31
6340 // 10673: }
6341 3, 10, // 10677: case 0x3: {
6342 OPC_CheckPredicate, 66, // 10679: check predicate 66
6343 OPC_CheckField, 30, 2, 0, // 10681: check Inst[31:30] == 0x0
6344 OPC_Decode, 199, 110, 31, // 10685: decode to CLMULH using decoder 31
6345 // 10685: }
6346 4, 10, // 10689: case 0x4: {
6347 OPC_CheckPredicate, 41, // 10691: check predicate 41
6348 OPC_CheckField, 30, 2, 0, // 10693: check Inst[31:30] == 0x0
6349 OPC_Decode, 229, 116, 31, // 10697: decode to MIN using decoder 31
6350 // 10697: }
6351 5, 10, // 10701: case 0x5: {
6352 OPC_CheckPredicate, 41, // 10703: check predicate 41
6353 OPC_CheckField, 30, 2, 0, // 10705: check Inst[31:30] == 0x0
6354 OPC_Decode, 230, 116, 31, // 10709: decode to MINU using decoder 31
6355 // 10709: }
6356 6, 10, // 10713: case 0x6: {
6357 OPC_CheckPredicate, 41, // 10715: check predicate 41
6358 OPC_CheckField, 30, 2, 0, // 10717: check Inst[31:30] == 0x0
6359 OPC_Decode, 216, 116, 31, // 10721: decode to MAX using decoder 31
6360 // 10721: }
6361 7, 0, // 10725: case 0x7: {
6362 OPC_CheckPredicate, 41, // 10727: check predicate 41
6363 OPC_CheckField, 30, 2, 0, // 10729: check Inst[31:30] == 0x0
6364 OPC_Decode, 217, 116, 31, // 10733: decode to MAXU using decoder 31
6365 // 10733: }
6366 // 10733: } // switch Inst[14:12]
6367 // 10733: }
6368 7, 27, // 10737: case 0x7: {
6369 OPC_SwitchField, 12, 3, // 10739: switch Inst[14:12] {
6370 5, 10, // 10742: case 0x5: {
6371 OPC_CheckPredicate, 68, // 10744: check predicate 68
6372 OPC_CheckField, 30, 2, 0, // 10746: check Inst[31:30] == 0x0
6373 OPC_Decode, 151, 113, 31, // 10750: decode to CZERO_EQZ using decoder 31
6374 // 10750: }
6375 7, 0, // 10754: case 0x7: {
6376 OPC_CheckPredicate, 68, // 10756: check predicate 68
6377 OPC_CheckField, 30, 2, 0, // 10758: check Inst[31:30] == 0x0
6378 OPC_Decode, 152, 113, 31, // 10762: decode to CZERO_NEZ using decoder 31
6379 // 10762: }
6380 // 10762: } // switch Inst[14:12]
6381 // 10762: }
6382 8, 14, // 10766: case 0x8: {
6383 OPC_CheckPredicate, 69, // 10768: check predicate 69
6384 OPC_CheckField, 30, 2, 1, // 10770: check Inst[31:30] == 0x1
6385 OPC_CheckField, 12, 3, 0, // 10774: check Inst[14:12] == 0x0
6386 OPC_Decode, 130, 124, 31, // 10778: decode to SHA512SUM0R using decoder 31
6387 // 10778: }
6388 9, 14, // 10782: case 0x9: {
6389 OPC_CheckPredicate, 69, // 10784: check predicate 69
6390 OPC_CheckField, 30, 2, 1, // 10786: check Inst[31:30] == 0x1
6391 OPC_CheckField, 12, 3, 0, // 10790: check Inst[14:12] == 0x0
6392 OPC_Decode, 132, 124, 31, // 10794: decode to SHA512SUM1R using decoder 31
6393 // 10794: }
6394 10, 14, // 10798: case 0xa: {
6395 OPC_CheckPredicate, 69, // 10800: check predicate 69
6396 OPC_CheckField, 30, 2, 1, // 10802: check Inst[31:30] == 0x1
6397 OPC_CheckField, 12, 3, 0, // 10806: check Inst[14:12] == 0x0
6398 OPC_Decode, 253, 123, 31, // 10810: decode to SHA512SIG0L using decoder 31
6399 // 10810: }
6400 11, 14, // 10814: case 0xb: {
6401 OPC_CheckPredicate, 69, // 10816: check predicate 69
6402 OPC_CheckField, 30, 2, 1, // 10818: check Inst[31:30] == 0x1
6403 OPC_CheckField, 12, 3, 0, // 10822: check Inst[14:12] == 0x0
6404 OPC_Decode, 128, 124, 31, // 10826: decode to SHA512SIG1L using decoder 31
6405 // 10826: }
6406 14, 14, // 10830: case 0xe: {
6407 OPC_CheckPredicate, 69, // 10832: check predicate 69
6408 OPC_CheckField, 30, 2, 1, // 10834: check Inst[31:30] == 0x1
6409 OPC_CheckField, 12, 3, 0, // 10838: check Inst[14:12] == 0x0
6410 OPC_Decode, 252, 123, 31, // 10842: decode to SHA512SIG0H using decoder 31
6411 // 10842: }
6412 15, 14, // 10846: case 0xf: {
6413 OPC_CheckPredicate, 69, // 10848: check predicate 69
6414 OPC_CheckField, 30, 2, 1, // 10850: check Inst[31:30] == 0x1
6415 OPC_CheckField, 12, 3, 0, // 10854: check Inst[14:12] == 0x0
6416 OPC_Decode, 255, 123, 31, // 10858: decode to SHA512SIG1H using decoder 31
6417 // 10858: }
6418 16, 63, // 10862: case 0x10: {
6419 OPC_SwitchField, 12, 3, // 10864: switch Inst[14:12] {
6420 1, 10, // 10867: case 0x1: {
6421 OPC_CheckPredicate, 43, // 10869: check predicate 43
6422 OPC_CheckField, 30, 2, 1, // 10871: check Inst[31:30] == 0x1
6423 OPC_Decode, 140, 123, 31, // 10875: decode to ROL using decoder 31
6424 // 10875: }
6425 2, 10, // 10879: case 0x2: {
6426 OPC_CheckPredicate, 70, // 10881: check predicate 70
6427 OPC_CheckField, 30, 2, 0, // 10883: check Inst[31:30] == 0x0
6428 OPC_Decode, 240, 123, 31, // 10887: decode to SH1ADD using decoder 31
6429 // 10887: }
6430 4, 10, // 10891: case 0x4: {
6431 OPC_CheckPredicate, 70, // 10893: check predicate 70
6432 OPC_CheckField, 30, 2, 0, // 10895: check Inst[31:30] == 0x0
6433 OPC_Decode, 242, 123, 31, // 10899: decode to SH2ADD using decoder 31
6434 // 10899: }
6435 5, 10, // 10903: case 0x5: {
6436 OPC_CheckPredicate, 43, // 10905: check predicate 43
6437 OPC_CheckField, 30, 2, 1, // 10907: check Inst[31:30] == 0x1
6438 OPC_Decode, 142, 123, 31, // 10911: decode to ROR using decoder 31
6439 // 10911: }
6440 6, 0, // 10915: case 0x6: {
6441 OPC_CheckPredicate, 70, // 10917: check predicate 70
6442 OPC_CheckField, 30, 2, 0, // 10919: check Inst[31:30] == 0x0
6443 OPC_Decode, 244, 123, 31, // 10923: decode to SH3ADD using decoder 31
6444 // 10923: }
6445 // 10923: } // switch Inst[14:12]
6446 // 10923: }
6447 17, 10, // 10927: case 0x11: {
6448 OPC_CheckPredicate, 71, // 10929: check predicate 71
6449 OPC_CheckField, 12, 3, 0, // 10931: check Inst[14:12] == 0x0
6450 OPC_Decode, 165, 107, 58, // 10935: decode to AES32ESI using decoder 58
6451 // 10935: }
6452 19, 10, // 10939: case 0x13: {
6453 OPC_CheckPredicate, 71, // 10941: check predicate 71
6454 OPC_CheckField, 12, 3, 0, // 10943: check Inst[14:12] == 0x0
6455 OPC_Decode, 166, 107, 58, // 10947: decode to AES32ESMI using decoder 58
6456 // 10947: }
6457 20, 50, // 10951: case 0x14: {
6458 OPC_SwitchField, 12, 3, // 10953: switch Inst[14:12] {
6459 1, 19, // 10956: case 0x1: {
6460 OPC_SwitchField, 30, 2, // 10958: switch Inst[31:30] {
6461 0, 6, // 10961: case 0x0: {
6462 OPC_CheckPredicate, 38, // 10963: check predicate 38
6463 OPC_Decode, 192, 110, 31, // 10965: decode to BSET using decoder 31
6464 // 10965: }
6465 1, 0, // 10969: case 0x1: {
6466 OPC_CheckPredicate, 38, // 10971: check predicate 38
6467 OPC_Decode, 185, 110, 31, // 10973: decode to BINV using decoder 31
6468 // 10973: }
6469 // 10973: } // switch Inst[31:30]
6470 // 10973: }
6471 2, 11, // 10977: case 0x2: {
6472 OPC_CheckPredicate, 72, // 10979: check predicate 72
6473 OPC_CheckField, 30, 2, 0, // 10981: check Inst[31:30] == 0x0
6474 OPC_Decode, 215, 131, 1, 31, // 10985: decode to XPERM4 using decoder 31
6475 // 10985: }
6476 4, 0, // 10990: case 0x4: {
6477 OPC_CheckPredicate, 72, // 10992: check predicate 72
6478 OPC_CheckField, 30, 2, 0, // 10994: check Inst[31:30] == 0x0
6479 OPC_Decode, 216, 131, 1, 31, // 10998: decode to XPERM8 using decoder 31
6480 // 10998: }
6481 // 10998: } // switch Inst[14:12]
6482 // 10998: }
6483 21, 10, // 11003: case 0x15: {
6484 OPC_CheckPredicate, 73, // 11005: check predicate 73
6485 OPC_CheckField, 12, 3, 0, // 11007: check Inst[14:12] == 0x0
6486 OPC_Decode, 163, 107, 58, // 11011: decode to AES32DSI using decoder 58
6487 // 11011: }
6488 23, 10, // 11015: case 0x17: {
6489 OPC_CheckPredicate, 73, // 11017: check predicate 73
6490 OPC_CheckField, 12, 3, 0, // 11019: check Inst[14:12] == 0x0
6491 OPC_Decode, 164, 107, 58, // 11023: decode to AES32DSMI using decoder 58
6492 // 11023: }
6493 24, 10, // 11027: case 0x18: {
6494 OPC_CheckPredicate, 74, // 11029: check predicate 74
6495 OPC_CheckField, 12, 3, 0, // 11031: check Inst[14:12] == 0x0
6496 OPC_Decode, 152, 124, 58, // 11035: decode to SM4ED using decoder 58
6497 // 11035: }
6498 25, 14, // 11039: case 0x19: {
6499 OPC_CheckPredicate, 75, // 11041: check predicate 75
6500 OPC_CheckField, 30, 2, 0, // 11043: check Inst[31:30] == 0x0
6501 OPC_CheckField, 12, 3, 0, // 11047: check Inst[14:12] == 0x0
6502 OPC_Decode, 169, 107, 31, // 11051: decode to AES64ES using decoder 31
6503 // 11051: }
6504 26, 10, // 11055: case 0x1a: {
6505 OPC_CheckPredicate, 74, // 11057: check predicate 74
6506 OPC_CheckField, 12, 3, 0, // 11059: check Inst[14:12] == 0x0
6507 OPC_Decode, 153, 124, 58, // 11063: decode to SM4KS using decoder 58
6508 // 11063: }
6509 27, 14, // 11067: case 0x1b: {
6510 OPC_CheckPredicate, 75, // 11069: check predicate 75
6511 OPC_CheckField, 30, 2, 0, // 11071: check Inst[31:30] == 0x0
6512 OPC_CheckField, 12, 3, 0, // 11075: check Inst[14:12] == 0x0
6513 OPC_Decode, 170, 107, 31, // 11079: decode to AES64ESM using decoder 31
6514 // 11079: }
6515 29, 14, // 11083: case 0x1d: {
6516 OPC_CheckPredicate, 39, // 11085: check predicate 39
6517 OPC_CheckField, 30, 2, 0, // 11087: check Inst[31:30] == 0x0
6518 OPC_CheckField, 12, 3, 0, // 11091: check Inst[14:12] == 0x0
6519 OPC_Decode, 167, 107, 31, // 11095: decode to AES64DS using decoder 31
6520 // 11095: }
6521 31, 0, // 11099: case 0x1f: {
6522 OPC_SwitchField, 30, 2, // 11101: switch Inst[31:30] {
6523 0, 10, // 11104: case 0x0: {
6524 OPC_CheckPredicate, 39, // 11106: check predicate 39
6525 OPC_CheckField, 12, 3, 0, // 11108: check Inst[14:12] == 0x0
6526 OPC_Decode, 168, 107, 31, // 11112: decode to AES64DSM using decoder 31
6527 // 11112: }
6528 1, 0, // 11116: case 0x1: {
6529 OPC_CheckPredicate, 40, // 11118: check predicate 40
6530 OPC_CheckField, 12, 3, 0, // 11120: check Inst[14:12] == 0x0
6531 OPC_Decode, 173, 107, 31, // 11124: decode to AES64KS2 using decoder 31
6532 // 11124: }
6533 // 11124: } // switch Inst[31:30]
6534 // 11124: }
6535 // 11124: } // switch Inst[29:25]
6536 // 11124: }
6537 55, 4, // 11128: case 0x37: {
6538 OPC_Decode, 194, 116, 20, // 11130: decode to LUI using decoder 20
6539 // 11130: }
6540 59, 155, 19, // 11134: case 0x3b: {
6541 OPC_SwitchField, 25, 7, // 11137: switch Inst[31:25] {
6542 0, 27, // 11140: case 0x0: {
6543 OPC_SwitchField, 12, 3, // 11142: switch Inst[14:12] {
6544 0, 6, // 11145: case 0x0: {
6545 OPC_CheckPredicate, 21, // 11147: check predicate 21
6546 OPC_Decode, 161, 107, 31, // 11149: decode to ADDW using decoder 31
6547 // 11149: }
6548 1, 6, // 11153: case 0x1: {
6549 OPC_CheckPredicate, 21, // 11155: check predicate 21
6550 OPC_Decode, 144, 124, 31, // 11157: decode to SLLW using decoder 31
6551 // 11157: }
6552 5, 0, // 11161: case 0x5: {
6553 OPC_CheckPredicate, 21, // 11163: check predicate 21
6554 OPC_Decode, 181, 124, 31, // 11165: decode to SRLW using decoder 31
6555 // 11165: }
6556 // 11165: } // switch Inst[14:12]
6557 // 11165: }
6558 1, 43, // 11169: case 0x1: {
6559 OPC_SwitchField, 12, 3, // 11171: switch Inst[14:12] {
6560 0, 6, // 11174: case 0x0: {
6561 OPC_CheckPredicate, 76, // 11176: check predicate 76
6562 OPC_Decode, 194, 117, 31, // 11178: decode to MULW using decoder 31
6563 // 11178: }
6564 4, 6, // 11182: case 0x4: {
6565 OPC_CheckPredicate, 77, // 11184: check predicate 77
6566 OPC_Decode, 230, 113, 31, // 11186: decode to DIVW using decoder 31
6567 // 11186: }
6568 5, 6, // 11190: case 0x5: {
6569 OPC_CheckPredicate, 77, // 11192: check predicate 77
6570 OPC_Decode, 229, 113, 31, // 11194: decode to DIVUW using decoder 31
6571 // 11194: }
6572 6, 6, // 11198: case 0x6: {
6573 OPC_CheckPredicate, 77, // 11200: check predicate 77
6574 OPC_Decode, 134, 123, 31, // 11202: decode to REMW using decoder 31
6575 // 11202: }
6576 7, 0, // 11206: case 0x7: {
6577 OPC_CheckPredicate, 77, // 11208: check predicate 77
6578 OPC_Decode, 133, 123, 31, // 11210: decode to REMUW using decoder 31
6579 // 11210: }
6580 // 11210: } // switch Inst[14:12]
6581 // 11210: }
6582 4, 32, // 11214: case 0x4: {
6583 OPC_SwitchField, 12, 3, // 11216: switch Inst[14:12] {
6584 0, 6, // 11219: case 0x0: {
6585 OPC_CheckPredicate, 49, // 11221: check predicate 49
6586 OPC_Decode, 162, 107, 31, // 11223: decode to ADD_UW using decoder 31
6587 // 11223: }
6588 4, 0, // 11227: case 0x4: {
6589 OPC_Scope, 11, // 11229: try {
6590 OPC_CheckField, 20, 5, 0, // 11231: check Inst[24:20] == 0x0
6591 OPC_CheckPredicate, 48, // 11235: check predicate 48
6592 OPC_Decode, 237, 131, 1, 17, // 11237: decode to ZEXT_H_RV64 using decoder 17
6593 // 11237: } else try {
6594 OPC_CheckPredicate, 78, // 11242: check predicate 78
6595 OPC_Decode, 167, 118, 31, // 11244: decode to PACKW using decoder 31
6596 // 11244: }
6597 // 11244: }
6598 // 11244: } // switch Inst[14:12]
6599 // 11244: }
6600 16, 27, // 11248: case 0x10: {
6601 OPC_SwitchField, 12, 3, // 11250: switch Inst[14:12] {
6602 2, 6, // 11253: case 0x2: {
6603 OPC_CheckPredicate, 49, // 11255: check predicate 49
6604 OPC_Decode, 241, 123, 31, // 11257: decode to SH1ADD_UW using decoder 31
6605 // 11257: }
6606 4, 6, // 11261: case 0x4: {
6607 OPC_CheckPredicate, 49, // 11263: check predicate 49
6608 OPC_Decode, 243, 123, 31, // 11265: decode to SH2ADD_UW using decoder 31
6609 // 11265: }
6610 6, 0, // 11269: case 0x6: {
6611 OPC_CheckPredicate, 49, // 11271: check predicate 49
6612 OPC_Decode, 245, 123, 31, // 11273: decode to SH3ADD_UW using decoder 31
6613 // 11273: }
6614 // 11273: } // switch Inst[14:12]
6615 // 11273: }
6616 32, 19, // 11277: case 0x20: {
6617 OPC_SwitchField, 12, 3, // 11279: switch Inst[14:12] {
6618 0, 6, // 11282: case 0x0: {
6619 OPC_CheckPredicate, 21, // 11284: check predicate 21
6620 OPC_Decode, 204, 124, 31, // 11286: decode to SUBW using decoder 31
6621 // 11286: }
6622 5, 0, // 11290: case 0x5: {
6623 OPC_CheckPredicate, 21, // 11292: check predicate 21
6624 OPC_Decode, 175, 124, 31, // 11294: decode to SRAW using decoder 31
6625 // 11294: }
6626 // 11294: } // switch Inst[14:12]
6627 // 11294: }
6628 48, 19, // 11298: case 0x30: {
6629 OPC_SwitchField, 12, 3, // 11300: switch Inst[14:12] {
6630 1, 6, // 11303: case 0x1: {
6631 OPC_CheckPredicate, 48, // 11305: check predicate 48
6632 OPC_Decode, 141, 123, 31, // 11307: decode to ROLW using decoder 31
6633 // 11307: }
6634 5, 0, // 11311: case 0x5: {
6635 OPC_CheckPredicate, 48, // 11313: check predicate 48
6636 OPC_Decode, 145, 123, 31, // 11315: decode to RORW using decoder 31
6637 // 11315: }
6638 // 11315: } // switch Inst[14:12]
6639 // 11315: }
6640 64, 59, // 11319: case 0x40: {
6641 OPC_SwitchField, 12, 3, // 11321: switch Inst[14:12] {
6642 0, 6, // 11324: case 0x0: {
6643 OPC_CheckPredicate, 42, // 11326: check predicate 42
6644 OPC_Decode, 177, 118, 31, // 11328: decode to PADD_H using decoder 31
6645 // 11328: }
6646 2, 6, // 11332: case 0x2: {
6647 OPC_CheckPredicate, 47, // 11334: check predicate 47
6648 OPC_Decode, 142, 120, 31, // 11336: decode to PNCLIPUP_B using decoder 31
6649 // 11336: }
6650 3, 6, // 11340: case 0x3: {
6651 OPC_CheckPredicate, 42, // 11342: check predicate 42
6652 OPC_Decode, 249, 119, 31, // 11344: decode to PMUL_H_B00 using decoder 31
6653 // 11344: }
6654 4, 6, // 11348: case 0x4: {
6655 OPC_CheckPredicate, 42, // 11350: check predicate 42
6656 OPC_Decode, 166, 120, 31, // 11352: decode to PPAIRE_B using decoder 31
6657 // 11352: }
6658 5, 6, // 11356: case 0x5: {
6659 OPC_CheckPredicate, 42, // 11358: check predicate 42
6660 OPC_Decode, 219, 118, 31, // 11360: decode to PM2ADD_H using decoder 31
6661 // 11360: }
6662 6, 6, // 11364: case 0x6: {
6663 OPC_CheckPredicate, 42, // 11366: check predicate 42
6664 OPC_Decode, 197, 118, 31, // 11368: decode to PAS_HX using decoder 31
6665 // 11368: }
6666 7, 0, // 11372: case 0x7: {
6667 OPC_CheckPredicate, 42, // 11374: check predicate 42
6668 OPC_Decode, 229, 119, 31, // 11376: decode to PMULH_H using decoder 31
6669 // 11376: }
6670 // 11376: } // switch Inst[14:12]
6671 // 11376: }
6672 65, 59, // 11380: case 0x41: {
6673 OPC_SwitchField, 12, 3, // 11382: switch Inst[14:12] {
6674 0, 6, // 11385: case 0x0: {
6675 OPC_CheckPredicate, 47, // 11387: check predicate 47
6676 OPC_Decode, 179, 118, 31, // 11389: decode to PADD_W using decoder 31
6677 // 11389: }
6678 2, 6, // 11393: case 0x2: {
6679 OPC_CheckPredicate, 47, // 11395: check predicate 47
6680 OPC_Decode, 143, 120, 31, // 11397: decode to PNCLIPUP_H using decoder 31
6681 // 11397: }
6682 3, 6, // 11401: case 0x3: {
6683 OPC_CheckPredicate, 47, // 11403: check predicate 47
6684 OPC_Decode, 252, 119, 31, // 11405: decode to PMUL_W_H00 using decoder 31
6685 // 11405: }
6686 4, 6, // 11409: case 0x4: {
6687 OPC_CheckPredicate, 47, // 11411: check predicate 47
6688 OPC_Decode, 169, 120, 31, // 11413: decode to PPAIRE_H using decoder 31
6689 // 11413: }
6690 5, 6, // 11417: case 0x5: {
6691 OPC_CheckPredicate, 47, // 11419: check predicate 47
6692 OPC_Decode, 221, 118, 31, // 11421: decode to PM2ADD_W using decoder 31
6693 // 11421: }
6694 6, 6, // 11425: case 0x6: {
6695 OPC_CheckPredicate, 47, // 11427: check predicate 47
6696 OPC_Decode, 198, 118, 31, // 11429: decode to PAS_WX using decoder 31
6697 // 11429: }
6698 7, 0, // 11433: case 0x7: {
6699 OPC_CheckPredicate, 47, // 11435: check predicate 47
6700 OPC_Decode, 232, 119, 31, // 11437: decode to PMULH_W using decoder 31
6701 // 11437: }
6702 // 11437: } // switch Inst[14:12]
6703 // 11437: }
6704 66, 35, // 11441: case 0x42: {
6705 OPC_SwitchField, 12, 3, // 11443: switch Inst[14:12] {
6706 0, 6, // 11446: case 0x0: {
6707 OPC_CheckPredicate, 42, // 11448: check predicate 42
6708 OPC_Decode, 169, 118, 31, // 11450: decode to PADD_B using decoder 31
6709 // 11450: }
6710 5, 6, // 11454: case 0x5: {
6711 OPC_CheckPredicate, 42, // 11456: check predicate 42
6712 OPC_Decode, 255, 118, 31, // 11458: decode to PM4ADD_B using decoder 31
6713 // 11458: }
6714 6, 6, // 11462: case 0x6: {
6715 OPC_CheckPredicate, 42, // 11464: check predicate 42
6716 OPC_Decode, 217, 120, 31, // 11466: decode to PSA_HX using decoder 31
6717 // 11466: }
6718 7, 0, // 11470: case 0x7: {
6719 OPC_CheckPredicate, 42, // 11472: check predicate 42
6720 OPC_Decode, 219, 119, 31, // 11474: decode to PMULHR_H using decoder 31
6721 // 11474: }
6722 // 11474: } // switch Inst[14:12]
6723 // 11474: }
6724 67, 43, // 11478: case 0x43: {
6725 OPC_SwitchField, 12, 3, // 11480: switch Inst[14:12] {
6726 2, 6, // 11483: case 0x2: {
6727 OPC_CheckPredicate, 47, // 11485: check predicate 47
6728 OPC_Decode, 144, 120, 31, // 11487: decode to PNCLIPUP_W using decoder 31
6729 // 11487: }
6730 3, 6, // 11491: case 0x3: {
6731 OPC_CheckPredicate, 47, // 11493: check predicate 47
6732 OPC_Decode, 198, 117, 31, // 11495: decode to MUL_W00 using decoder 31
6733 // 11495: }
6734 5, 6, // 11499: case 0x5: {
6735 OPC_CheckPredicate, 47, // 11501: check predicate 47
6736 OPC_Decode, 128, 119, 31, // 11503: decode to PM4ADD_H using decoder 31
6737 // 11503: }
6738 6, 6, // 11507: case 0x6: {
6739 OPC_CheckPredicate, 47, // 11509: check predicate 47
6740 OPC_Decode, 218, 120, 31, // 11511: decode to PSA_WX using decoder 31
6741 // 11511: }
6742 7, 0, // 11515: case 0x7: {
6743 OPC_CheckPredicate, 47, // 11517: check predicate 47
6744 OPC_Decode, 220, 119, 31, // 11519: decode to PMULHR_W using decoder 31
6745 // 11519: }
6746 // 11519: } // switch Inst[14:12]
6747 // 11519: }
6748 68, 19, // 11523: case 0x44: {
6749 OPC_SwitchField, 12, 3, // 11525: switch Inst[14:12] {
6750 5, 6, // 11528: case 0x5: {
6751 OPC_CheckPredicate, 42, // 11530: check predicate 42
6752 OPC_Decode, 211, 118, 59, // 11532: decode to PM2ADDA_H using decoder 59
6753 // 11532: }
6754 7, 0, // 11536: case 0x7: {
6755 OPC_CheckPredicate, 42, // 11538: check predicate 42
6756 OPC_Decode, 157, 119, 59, // 11540: decode to PMHACC_H using decoder 59
6757 // 11540: }
6758 // 11540: } // switch Inst[14:12]
6759 // 11540: }
6760 69, 27, // 11544: case 0x45: {
6761 OPC_SwitchField, 12, 3, // 11546: switch Inst[14:12] {
6762 3, 6, // 11549: case 0x3: {
6763 OPC_CheckPredicate, 47, // 11551: check predicate 47
6764 OPC_Decode, 134, 119, 59, // 11553: decode to PMACC_W_H00 using decoder 59
6765 // 11553: }
6766 5, 6, // 11557: case 0x5: {
6767 OPC_CheckPredicate, 47, // 11559: check predicate 47
6768 OPC_Decode, 213, 118, 59, // 11561: decode to PM2ADDA_W using decoder 59
6769 // 11561: }
6770 7, 0, // 11565: case 0x7: {
6771 OPC_CheckPredicate, 47, // 11567: check predicate 47
6772 OPC_Decode, 160, 119, 59, // 11569: decode to PMHACC_W using decoder 59
6773 // 11569: }
6774 // 11569: } // switch Inst[14:12]
6775 // 11569: }
6776 70, 19, // 11573: case 0x46: {
6777 OPC_SwitchField, 12, 3, // 11575: switch Inst[14:12] {
6778 5, 6, // 11578: case 0x5: {
6779 OPC_CheckPredicate, 42, // 11580: check predicate 42
6780 OPC_Decode, 249, 118, 59, // 11582: decode to PM4ADDA_B using decoder 59
6781 // 11582: }
6782 7, 0, // 11586: case 0x7: {
6783 OPC_CheckPredicate, 42, // 11588: check predicate 42
6784 OPC_Decode, 167, 119, 59, // 11590: decode to PMHRACC_H using decoder 59
6785 // 11590: }
6786 // 11590: } // switch Inst[14:12]
6787 // 11590: }
6788 71, 35, // 11594: case 0x47: {
6789 OPC_SwitchField, 12, 3, // 11596: switch Inst[14:12] {
6790 1, 6, // 11599: case 0x1: {
6791 OPC_CheckPredicate, 42, // 11601: check predicate 42
6792 OPC_Decode, 149, 124, 59, // 11603: decode to SLX using decoder 59
6793 // 11603: }
6794 3, 6, // 11607: case 0x3: {
6795 OPC_CheckPredicate, 47, // 11609: check predicate 47
6796 OPC_Decode, 213, 116, 59, // 11611: decode to MACC_W00 using decoder 59
6797 // 11611: }
6798 5, 6, // 11615: case 0x5: {
6799 OPC_CheckPredicate, 47, // 11617: check predicate 47
6800 OPC_Decode, 250, 118, 59, // 11619: decode to PM4ADDA_H using decoder 59
6801 // 11619: }
6802 7, 0, // 11623: case 0x7: {
6803 OPC_CheckPredicate, 47, // 11625: check predicate 47
6804 OPC_Decode, 168, 119, 59, // 11627: decode to PMHRACC_W using decoder 59
6805 // 11627: }
6806 // 11627: } // switch Inst[14:12]
6807 // 11627: }
6808 72, 59, // 11631: case 0x48: {
6809 OPC_SwitchField, 12, 3, // 11633: switch Inst[14:12] {
6810 0, 6, // 11636: case 0x0: {
6811 OPC_CheckPredicate, 42, // 11638: check predicate 42
6812 OPC_Decode, 207, 120, 31, // 11640: decode to PSADD_H using decoder 31
6813 // 11640: }
6814 1, 6, // 11644: case 0x1: {
6815 OPC_CheckPredicate, 42, // 11646: check predicate 42
6816 OPC_Decode, 250, 119, 31, // 11648: decode to PMUL_H_B01 using decoder 31
6817 // 11648: }
6818 3, 6, // 11652: case 0x3: {
6819 OPC_CheckPredicate, 42, // 11654: check predicate 42
6820 OPC_Decode, 251, 119, 31, // 11656: decode to PMUL_H_B11 using decoder 31
6821 // 11656: }
6822 4, 6, // 11660: case 0x4: {
6823 OPC_CheckPredicate, 42, // 11662: check predicate 42
6824 OPC_Decode, 161, 120, 31, // 11664: decode to PPAIREO_B using decoder 31
6825 // 11664: }
6826 5, 6, // 11668: case 0x5: {
6827 OPC_CheckPredicate, 42, // 11670: check predicate 42
6828 OPC_Decode, 220, 118, 31, // 11672: decode to PM2ADD_HX using decoder 31
6829 // 11672: }
6830 6, 6, // 11676: case 0x6: {
6831 OPC_CheckPredicate, 42, // 11678: check predicate 42
6832 OPC_Decode, 210, 120, 31, // 11680: decode to PSAS_HX using decoder 31
6833 // 11680: }
6834 7, 0, // 11684: case 0x7: {
6835 OPC_CheckPredicate, 42, // 11686: check predicate 42
6836 OPC_Decode, 227, 119, 31, // 11688: decode to PMULHU_H using decoder 31
6837 // 11688: }
6838 // 11688: } // switch Inst[14:12]
6839 // 11688: }
6840 73, 59, // 11692: case 0x49: {
6841 OPC_SwitchField, 12, 3, // 11694: switch Inst[14:12] {
6842 0, 6, // 11697: case 0x0: {
6843 OPC_CheckPredicate, 47, // 11699: check predicate 47
6844 OPC_Decode, 208, 120, 31, // 11701: decode to PSADD_W using decoder 31
6845 // 11701: }
6846 1, 6, // 11705: case 0x1: {
6847 OPC_CheckPredicate, 47, // 11707: check predicate 47
6848 OPC_Decode, 253, 119, 31, // 11709: decode to PMUL_W_H01 using decoder 31
6849 // 11709: }
6850 3, 6, // 11713: case 0x3: {
6851 OPC_CheckPredicate, 47, // 11715: check predicate 47
6852 OPC_Decode, 254, 119, 31, // 11717: decode to PMUL_W_H11 using decoder 31
6853 // 11717: }
6854 4, 6, // 11721: case 0x4: {
6855 OPC_CheckPredicate, 42, // 11723: check predicate 42
6856 OPC_Decode, 164, 120, 31, // 11725: decode to PPAIREO_H using decoder 31
6857 // 11725: }
6858 5, 6, // 11729: case 0x5: {
6859 OPC_CheckPredicate, 47, // 11731: check predicate 47
6860 OPC_Decode, 222, 118, 31, // 11733: decode to PM2ADD_WX using decoder 31
6861 // 11733: }
6862 6, 6, // 11737: case 0x6: {
6863 OPC_CheckPredicate, 47, // 11739: check predicate 47
6864 OPC_Decode, 211, 120, 31, // 11741: decode to PSAS_WX using decoder 31
6865 // 11741: }
6866 7, 0, // 11745: case 0x7: {
6867 OPC_CheckPredicate, 47, // 11747: check predicate 47
6868 OPC_Decode, 228, 119, 31, // 11749: decode to PMULHU_W using decoder 31
6869 // 11749: }
6870 // 11749: } // switch Inst[14:12]
6871 // 11749: }
6872 74, 27, // 11753: case 0x4a: {
6873 OPC_SwitchField, 12, 3, // 11755: switch Inst[14:12] {
6874 0, 6, // 11758: case 0x0: {
6875 OPC_CheckPredicate, 42, // 11760: check predicate 42
6876 OPC_Decode, 203, 120, 31, // 11762: decode to PSADD_B using decoder 31
6877 // 11762: }
6878 6, 6, // 11766: case 0x6: {
6879 OPC_CheckPredicate, 42, // 11768: check predicate 42
6880 OPC_Decode, 142, 121, 31, // 11770: decode to PSSA_HX using decoder 31
6881 // 11770: }
6882 7, 0, // 11774: case 0x7: {
6883 OPC_CheckPredicate, 42, // 11776: check predicate 42
6884 OPC_Decode, 217, 119, 31, // 11778: decode to PMULHRU_H using decoder 31
6885 // 11778: }
6886 // 11778: } // switch Inst[14:12]
6887 // 11778: }
6888 75, 43, // 11782: case 0x4b: {
6889 OPC_SwitchField, 12, 3, // 11784: switch Inst[14:12] {
6890 1, 6, // 11787: case 0x1: {
6891 OPC_CheckPredicate, 47, // 11789: check predicate 47
6892 OPC_Decode, 199, 117, 31, // 11791: decode to MUL_W01 using decoder 31
6893 // 11791: }
6894 3, 6, // 11795: case 0x3: {
6895 OPC_CheckPredicate, 47, // 11797: check predicate 47
6896 OPC_Decode, 200, 117, 31, // 11799: decode to MUL_W11 using decoder 31
6897 // 11799: }
6898 4, 6, // 11803: case 0x4: {
6899 OPC_CheckPredicate, 47, // 11805: check predicate 47
6900 OPC_Decode, 165, 120, 31, // 11807: decode to PPAIREO_W using decoder 31
6901 // 11807: }
6902 6, 6, // 11811: case 0x6: {
6903 OPC_CheckPredicate, 47, // 11813: check predicate 47
6904 OPC_Decode, 143, 121, 31, // 11815: decode to PSSA_WX using decoder 31
6905 // 11815: }
6906 7, 0, // 11819: case 0x7: {
6907 OPC_CheckPredicate, 47, // 11821: check predicate 47
6908 OPC_Decode, 218, 119, 31, // 11823: decode to PMULHRU_W using decoder 31
6909 // 11823: }
6910 // 11823: } // switch Inst[14:12]
6911 // 11823: }
6912 76, 35, // 11827: case 0x4c: {
6913 OPC_SwitchField, 12, 3, // 11829: switch Inst[14:12] {
6914 0, 6, // 11832: case 0x0: {
6915 OPC_CheckPredicate, 42, // 11834: check predicate 42
6916 OPC_Decode, 150, 118, 31, // 11836: decode to PAADD_H using decoder 31
6917 // 11836: }
6918 5, 6, // 11840: case 0x5: {
6919 OPC_CheckPredicate, 42, // 11842: check predicate 42
6920 OPC_Decode, 212, 118, 59, // 11844: decode to PM2ADDA_HX using decoder 59
6921 // 11844: }
6922 6, 6, // 11848: case 0x6: {
6923 OPC_CheckPredicate, 42, // 11850: check predicate 42
6924 OPC_Decode, 153, 118, 31, // 11852: decode to PAAS_HX using decoder 31
6925 // 11852: }
6926 7, 0, // 11856: case 0x7: {
6927 OPC_CheckPredicate, 42, // 11858: check predicate 42
6928 OPC_Decode, 155, 119, 59, // 11860: decode to PMHACCU_H using decoder 59
6929 // 11860: }
6930 // 11860: } // switch Inst[14:12]
6931 // 11860: }
6932 77, 51, // 11864: case 0x4d: {
6933 OPC_SwitchField, 12, 3, // 11866: switch Inst[14:12] {
6934 0, 6, // 11869: case 0x0: {
6935 OPC_CheckPredicate, 47, // 11871: check predicate 47
6936 OPC_Decode, 151, 118, 31, // 11873: decode to PAADD_W using decoder 31
6937 // 11873: }
6938 1, 6, // 11877: case 0x1: {
6939 OPC_CheckPredicate, 47, // 11879: check predicate 47
6940 OPC_Decode, 135, 119, 59, // 11881: decode to PMACC_W_H01 using decoder 59
6941 // 11881: }
6942 3, 6, // 11885: case 0x3: {
6943 OPC_CheckPredicate, 47, // 11887: check predicate 47
6944 OPC_Decode, 136, 119, 59, // 11889: decode to PMACC_W_H11 using decoder 59
6945 // 11889: }
6946 5, 6, // 11893: case 0x5: {
6947 OPC_CheckPredicate, 47, // 11895: check predicate 47
6948 OPC_Decode, 214, 118, 59, // 11897: decode to PM2ADDA_WX using decoder 59
6949 // 11897: }
6950 6, 6, // 11901: case 0x6: {
6951 OPC_CheckPredicate, 47, // 11903: check predicate 47
6952 OPC_Decode, 154, 118, 31, // 11905: decode to PAAS_WX using decoder 31
6953 // 11905: }
6954 7, 0, // 11909: case 0x7: {
6955 OPC_CheckPredicate, 47, // 11911: check predicate 47
6956 OPC_Decode, 156, 119, 59, // 11913: decode to PMHACCU_W using decoder 59
6957 // 11913: }
6958 // 11913: } // switch Inst[14:12]
6959 // 11913: }
6960 78, 27, // 11917: case 0x4e: {
6961 OPC_SwitchField, 12, 3, // 11919: switch Inst[14:12] {
6962 0, 6, // 11922: case 0x0: {
6963 OPC_CheckPredicate, 42, // 11924: check predicate 42
6964 OPC_Decode, 146, 118, 31, // 11926: decode to PAADD_B using decoder 31
6965 // 11926: }
6966 6, 6, // 11930: case 0x6: {
6967 OPC_CheckPredicate, 42, // 11932: check predicate 42
6968 OPC_Decode, 182, 118, 31, // 11934: decode to PASA_HX using decoder 31
6969 // 11934: }
6970 7, 0, // 11938: case 0x7: {
6971 OPC_CheckPredicate, 42, // 11940: check predicate 42
6972 OPC_Decode, 165, 119, 59, // 11942: decode to PMHRACCU_H using decoder 59
6973 // 11942: }
6974 // 11942: } // switch Inst[14:12]
6975 // 11942: }
6976 79, 35, // 11946: case 0x4f: {
6977 OPC_SwitchField, 12, 3, // 11948: switch Inst[14:12] {
6978 1, 6, // 11951: case 0x1: {
6979 OPC_CheckPredicate, 47, // 11953: check predicate 47
6980 OPC_Decode, 214, 116, 59, // 11955: decode to MACC_W01 using decoder 59
6981 // 11955: }
6982 3, 6, // 11959: case 0x3: {
6983 OPC_CheckPredicate, 47, // 11961: check predicate 47
6984 OPC_Decode, 215, 116, 59, // 11963: decode to MACC_W11 using decoder 59
6985 // 11963: }
6986 6, 6, // 11967: case 0x6: {
6987 OPC_CheckPredicate, 47, // 11969: check predicate 47
6988 OPC_Decode, 183, 118, 31, // 11971: decode to PASA_WX using decoder 31
6989 // 11971: }
6990 7, 0, // 11975: case 0x7: {
6991 OPC_CheckPredicate, 47, // 11977: check predicate 47
6992 OPC_Decode, 166, 119, 59, // 11979: decode to PMHRACCU_W using decoder 59
6993 // 11979: }
6994 // 11979: } // switch Inst[14:12]
6995 // 11979: }
6996 80, 43, // 11983: case 0x50: {
6997 OPC_SwitchField, 12, 3, // 11985: switch Inst[14:12] {
6998 2, 6, // 11988: case 0x2: {
6999 OPC_CheckPredicate, 42, // 11990: check predicate 42
7000 OPC_Decode, 227, 120, 31, // 11992: decode to PSH1ADD_H using decoder 31
7001 // 11992: }
7002 3, 6, // 11996: case 0x3: {
7003 OPC_CheckPredicate, 42, // 11998: check predicate 42
7004 OPC_Decode, 243, 119, 31, // 12000: decode to PMULU_H_B00 using decoder 31
7005 // 12000: }
7006 4, 6, // 12004: case 0x4: {
7007 OPC_CheckPredicate, 42, // 12006: check predicate 42
7008 OPC_Decode, 170, 120, 31, // 12008: decode to PPAIROE_B using decoder 31
7009 // 12008: }
7010 5, 6, // 12012: case 0x5: {
7011 OPC_CheckPredicate, 42, // 12014: check predicate 42
7012 OPC_Decode, 217, 118, 31, // 12016: decode to PM2ADDU_H using decoder 31
7013 // 12016: }
7014 7, 0, // 12020: case 0x7: {
7015 OPC_CheckPredicate, 42, // 12022: check predicate 42
7016 OPC_Decode, 230, 119, 31, // 12024: decode to PMULH_H_B0 using decoder 31
7017 // 12024: }
7018 // 12024: } // switch Inst[14:12]
7019 // 12024: }
7020 81, 43, // 12028: case 0x51: {
7021 OPC_SwitchField, 12, 3, // 12030: switch Inst[14:12] {
7022 2, 6, // 12033: case 0x2: {
7023 OPC_CheckPredicate, 47, // 12035: check predicate 47
7024 OPC_Decode, 228, 120, 31, // 12037: decode to PSH1ADD_W using decoder 31
7025 // 12037: }
7026 3, 6, // 12041: case 0x3: {
7027 OPC_CheckPredicate, 47, // 12043: check predicate 47
7028 OPC_Decode, 246, 119, 31, // 12045: decode to PMULU_W_H00 using decoder 31
7029 // 12045: }
7030 4, 6, // 12049: case 0x4: {
7031 OPC_CheckPredicate, 42, // 12051: check predicate 42
7032 OPC_Decode, 173, 120, 31, // 12053: decode to PPAIROE_H using decoder 31
7033 // 12053: }
7034 5, 6, // 12057: case 0x5: {
7035 OPC_CheckPredicate, 47, // 12059: check predicate 47
7036 OPC_Decode, 218, 118, 31, // 12061: decode to PM2ADDU_W using decoder 31
7037 // 12061: }
7038 7, 0, // 12065: case 0x7: {
7039 OPC_CheckPredicate, 47, // 12067: check predicate 47
7040 OPC_Decode, 233, 119, 31, // 12069: decode to PMULH_W_H0 using decoder 31
7041 // 12069: }
7042 // 12069: } // switch Inst[14:12]
7043 // 12069: }
7044 82, 19, // 12073: case 0x52: {
7045 OPC_SwitchField, 12, 3, // 12075: switch Inst[14:12] {
7046 5, 6, // 12078: case 0x5: {
7047 OPC_CheckPredicate, 42, // 12080: check predicate 42
7048 OPC_Decode, 253, 118, 31, // 12082: decode to PM4ADDU_B using decoder 31
7049 // 12082: }
7050 7, 0, // 12086: case 0x7: {
7051 OPC_CheckPredicate, 42, // 12088: check predicate 42
7052 OPC_Decode, 222, 119, 31, // 12090: decode to PMULHSU_H_B0 using decoder 31
7053 // 12090: }
7054 // 12090: } // switch Inst[14:12]
7055 // 12090: }
7056 83, 35, // 12094: case 0x53: {
7057 OPC_SwitchField, 12, 3, // 12096: switch Inst[14:12] {
7058 3, 6, // 12099: case 0x3: {
7059 OPC_CheckPredicate, 47, // 12101: check predicate 47
7060 OPC_Decode, 191, 117, 31, // 12103: decode to MULU_W00 using decoder 31
7061 // 12103: }
7062 4, 6, // 12107: case 0x4: {
7063 OPC_CheckPredicate, 47, // 12109: check predicate 47
7064 OPC_Decode, 174, 120, 31, // 12111: decode to PPAIROE_W using decoder 31
7065 // 12111: }
7066 5, 6, // 12115: case 0x5: {
7067 OPC_CheckPredicate, 47, // 12117: check predicate 47
7068 OPC_Decode, 254, 118, 31, // 12119: decode to PM4ADDU_H using decoder 31
7069 // 12119: }
7070 7, 0, // 12123: case 0x7: {
7071 OPC_CheckPredicate, 47, // 12125: check predicate 47
7072 OPC_Decode, 225, 119, 31, // 12127: decode to PMULHSU_W_H0 using decoder 31
7073 // 12127: }
7074 // 12127: } // switch Inst[14:12]
7075 // 12127: }
7076 84, 27, // 12131: case 0x54: {
7077 OPC_SwitchField, 12, 3, // 12133: switch Inst[14:12] {
7078 1, 6, // 12136: case 0x1: {
7079 OPC_CheckPredicate, 42, // 12138: check predicate 42
7080 OPC_Decode, 201, 117, 59, // 12140: decode to MVM using decoder 59
7081 // 12140: }
7082 5, 6, // 12144: case 0x5: {
7083 OPC_CheckPredicate, 42, // 12146: check predicate 42
7084 OPC_Decode, 209, 118, 59, // 12148: decode to PM2ADDAU_H using decoder 59
7085 // 12148: }
7086 7, 0, // 12152: case 0x7: {
7087 OPC_CheckPredicate, 42, // 12154: check predicate 42
7088 OPC_Decode, 158, 119, 59, // 12156: decode to PMHACC_H_B0 using decoder 59
7089 // 12156: }
7090 // 12156: } // switch Inst[14:12]
7091 // 12156: }
7092 85, 35, // 12160: case 0x55: {
7093 OPC_SwitchField, 12, 3, // 12162: switch Inst[14:12] {
7094 1, 6, // 12165: case 0x1: {
7095 OPC_CheckPredicate, 42, // 12167: check predicate 42
7096 OPC_Decode, 202, 117, 59, // 12169: decode to MVMN using decoder 59
7097 // 12169: }
7098 3, 6, // 12173: case 0x3: {
7099 OPC_CheckPredicate, 47, // 12175: check predicate 47
7100 OPC_Decode, 131, 119, 59, // 12177: decode to PMACCU_W_H00 using decoder 59
7101 // 12177: }
7102 5, 6, // 12181: case 0x5: {
7103 OPC_CheckPredicate, 47, // 12183: check predicate 47
7104 OPC_Decode, 210, 118, 59, // 12185: decode to PM2ADDAU_W using decoder 59
7105 // 12185: }
7106 7, 0, // 12189: case 0x7: {
7107 OPC_CheckPredicate, 47, // 12191: check predicate 47
7108 OPC_Decode, 161, 119, 59, // 12193: decode to PMHACC_W_H0 using decoder 59
7109 // 12193: }
7110 // 12193: } // switch Inst[14:12]
7111 // 12193: }
7112 86, 27, // 12197: case 0x56: {
7113 OPC_SwitchField, 12, 3, // 12199: switch Inst[14:12] {
7114 1, 6, // 12202: case 0x1: {
7115 OPC_CheckPredicate, 42, // 12204: check predicate 42
7116 OPC_Decode, 218, 116, 59, // 12206: decode to MERGE using decoder 59
7117 // 12206: }
7118 5, 6, // 12210: case 0x5: {
7119 OPC_CheckPredicate, 42, // 12212: check predicate 42
7120 OPC_Decode, 247, 118, 59, // 12214: decode to PM4ADDAU_B using decoder 59
7121 // 12214: }
7122 7, 0, // 12218: case 0x7: {
7123 OPC_CheckPredicate, 42, // 12220: check predicate 42
7124 OPC_Decode, 150, 119, 59, // 12222: decode to PMHACCSU_H_B0 using decoder 59
7125 // 12222: }
7126 // 12222: } // switch Inst[14:12]
7127 // 12222: }
7128 87, 35, // 12226: case 0x57: {
7129 OPC_SwitchField, 12, 3, // 12228: switch Inst[14:12] {
7130 1, 6, // 12231: case 0x1: {
7131 OPC_CheckPredicate, 42, // 12233: check predicate 42
7132 OPC_Decode, 182, 124, 59, // 12235: decode to SRX using decoder 59
7133 // 12235: }
7134 3, 6, // 12239: case 0x3: {
7135 OPC_CheckPredicate, 47, // 12241: check predicate 47
7136 OPC_Decode, 207, 116, 59, // 12243: decode to MACCU_W00 using decoder 59
7137 // 12243: }
7138 5, 6, // 12247: case 0x5: {
7139 OPC_CheckPredicate, 47, // 12249: check predicate 47
7140 OPC_Decode, 248, 118, 59, // 12251: decode to PM4ADDAU_H using decoder 59
7141 // 12251: }
7142 7, 0, // 12255: case 0x7: {
7143 OPC_CheckPredicate, 47, // 12257: check predicate 47
7144 OPC_Decode, 153, 119, 59, // 12259: decode to PMHACCSU_W_H0 using decoder 59
7145 // 12259: }
7146 // 12259: } // switch Inst[14:12]
7147 // 12259: }
7148 88, 59, // 12263: case 0x58: {
7149 OPC_SwitchField, 12, 3, // 12265: switch Inst[14:12] {
7150 0, 6, // 12268: case 0x0: {
7151 OPC_CheckPredicate, 42, // 12270: check predicate 42
7152 OPC_Decode, 201, 120, 31, // 12272: decode to PSADDU_H using decoder 31
7153 // 12272: }
7154 1, 6, // 12276: case 0x1: {
7155 OPC_CheckPredicate, 42, // 12278: check predicate 42
7156 OPC_Decode, 244, 119, 31, // 12280: decode to PMULU_H_B01 using decoder 31
7157 // 12280: }
7158 2, 6, // 12284: case 0x2: {
7159 OPC_CheckPredicate, 42, // 12286: check predicate 42
7160 OPC_Decode, 146, 121, 31, // 12288: decode to PSSH1SADD_H using decoder 31
7161 // 12288: }
7162 3, 6, // 12292: case 0x3: {
7163 OPC_CheckPredicate, 42, // 12294: check predicate 42
7164 OPC_Decode, 245, 119, 31, // 12296: decode to PMULU_H_B11 using decoder 31
7165 // 12296: }
7166 4, 6, // 12300: case 0x4: {
7167 OPC_CheckPredicate, 42, // 12302: check predicate 42
7168 OPC_Decode, 175, 120, 31, // 12304: decode to PPAIRO_B using decoder 31
7169 // 12304: }
7170 5, 6, // 12308: case 0x5: {
7171 OPC_CheckPredicate, 42, // 12310: check predicate 42
7172 OPC_Decode, 183, 119, 31, // 12312: decode to PMQ2ADD_H using decoder 31
7173 // 12312: }
7174 7, 0, // 12316: case 0x7: {
7175 OPC_CheckPredicate, 42, // 12318: check predicate 42
7176 OPC_Decode, 231, 119, 31, // 12320: decode to PMULH_H_B1 using decoder 31
7177 // 12320: }
7178 // 12320: } // switch Inst[14:12]
7179 // 12320: }
7180 89, 59, // 12324: case 0x59: {
7181 OPC_SwitchField, 12, 3, // 12326: switch Inst[14:12] {
7182 0, 6, // 12329: case 0x0: {
7183 OPC_CheckPredicate, 47, // 12331: check predicate 47
7184 OPC_Decode, 202, 120, 31, // 12333: decode to PSADDU_W using decoder 31
7185 // 12333: }
7186 1, 6, // 12337: case 0x1: {
7187 OPC_CheckPredicate, 47, // 12339: check predicate 47
7188 OPC_Decode, 247, 119, 31, // 12341: decode to PMULU_W_H01 using decoder 31
7189 // 12341: }
7190 2, 6, // 12345: case 0x2: {
7191 OPC_CheckPredicate, 47, // 12347: check predicate 47
7192 OPC_Decode, 147, 121, 31, // 12349: decode to PSSH1SADD_W using decoder 31
7193 // 12349: }
7194 3, 6, // 12353: case 0x3: {
7195 OPC_CheckPredicate, 47, // 12355: check predicate 47
7196 OPC_Decode, 248, 119, 31, // 12357: decode to PMULU_W_H11 using decoder 31
7197 // 12357: }
7198 4, 6, // 12361: case 0x4: {
7199 OPC_CheckPredicate, 42, // 12363: check predicate 42
7200 OPC_Decode, 178, 120, 31, // 12365: decode to PPAIRO_H using decoder 31
7201 // 12365: }
7202 5, 6, // 12369: case 0x5: {
7203 OPC_CheckPredicate, 47, // 12371: check predicate 47
7204 OPC_Decode, 184, 119, 31, // 12373: decode to PMQ2ADD_W using decoder 31
7205 // 12373: }
7206 7, 0, // 12377: case 0x7: {
7207 OPC_CheckPredicate, 47, // 12379: check predicate 47
7208 OPC_Decode, 234, 119, 31, // 12381: decode to PMULH_W_H1 using decoder 31
7209 // 12381: }
7210 // 12381: } // switch Inst[14:12]
7211 // 12381: }
7212 90, 35, // 12385: case 0x5a: {
7213 OPC_SwitchField, 12, 3, // 12387: switch Inst[14:12] {
7214 0, 6, // 12390: case 0x0: {
7215 OPC_CheckPredicate, 42, // 12392: check predicate 42
7216 OPC_Decode, 197, 120, 31, // 12394: decode to PSADDU_B using decoder 31
7217 // 12394: }
7218 1, 6, // 12398: case 0x1: {
7219 OPC_CheckPredicate, 42, // 12400: check predicate 42
7220 OPC_Decode, 156, 118, 31, // 12402: decode to PABDSUMU_B using decoder 31
7221 // 12402: }
7222 5, 6, // 12406: case 0x5: {
7223 OPC_CheckPredicate, 42, // 12408: check predicate 42
7224 OPC_Decode, 190, 119, 31, // 12410: decode to PMQR2ADD_H using decoder 31
7225 // 12410: }
7226 7, 0, // 12414: case 0x7: {
7227 OPC_CheckPredicate, 42, // 12416: check predicate 42
7228 OPC_Decode, 223, 119, 31, // 12418: decode to PMULHSU_H_B1 using decoder 31
7229 // 12418: }
7230 // 12418: } // switch Inst[14:12]
7231 // 12418: }
7232 91, 43, // 12422: case 0x5b: {
7233 OPC_SwitchField, 12, 3, // 12424: switch Inst[14:12] {
7234 1, 6, // 12427: case 0x1: {
7235 OPC_CheckPredicate, 47, // 12429: check predicate 47
7236 OPC_Decode, 192, 117, 31, // 12431: decode to MULU_W01 using decoder 31
7237 // 12431: }
7238 3, 6, // 12435: case 0x3: {
7239 OPC_CheckPredicate, 47, // 12437: check predicate 47
7240 OPC_Decode, 193, 117, 31, // 12439: decode to MULU_W11 using decoder 31
7241 // 12439: }
7242 4, 6, // 12443: case 0x4: {
7243 OPC_CheckPredicate, 47, // 12445: check predicate 47
7244 OPC_Decode, 179, 120, 31, // 12447: decode to PPAIRO_W using decoder 31
7245 // 12447: }
7246 5, 6, // 12451: case 0x5: {
7247 OPC_CheckPredicate, 47, // 12453: check predicate 47
7248 OPC_Decode, 191, 119, 31, // 12455: decode to PMQR2ADD_W using decoder 31
7249 // 12455: }
7250 7, 0, // 12459: case 0x7: {
7251 OPC_CheckPredicate, 47, // 12461: check predicate 47
7252 OPC_Decode, 226, 119, 31, // 12463: decode to PMULHSU_W_H1 using decoder 31
7253 // 12463: }
7254 // 12463: } // switch Inst[14:12]
7255 // 12463: }
7256 92, 27, // 12467: case 0x5c: {
7257 OPC_SwitchField, 12, 3, // 12469: switch Inst[14:12] {
7258 0, 6, // 12472: case 0x0: {
7259 OPC_CheckPredicate, 42, // 12474: check predicate 42
7260 OPC_Decode, 144, 118, 31, // 12476: decode to PAADDU_H using decoder 31
7261 // 12476: }
7262 5, 6, // 12480: case 0x5: {
7263 OPC_CheckPredicate, 42, // 12482: check predicate 42
7264 OPC_Decode, 181, 119, 59, // 12484: decode to PMQ2ADDA_H using decoder 59
7265 // 12484: }
7266 7, 0, // 12488: case 0x7: {
7267 OPC_CheckPredicate, 42, // 12490: check predicate 42
7268 OPC_Decode, 159, 119, 59, // 12492: decode to PMHACC_H_B1 using decoder 59
7269 // 12492: }
7270 // 12492: } // switch Inst[14:12]
7271 // 12492: }
7272 93, 43, // 12496: case 0x5d: {
7273 OPC_SwitchField, 12, 3, // 12498: switch Inst[14:12] {
7274 0, 6, // 12501: case 0x0: {
7275 OPC_CheckPredicate, 47, // 12503: check predicate 47
7276 OPC_Decode, 145, 118, 31, // 12505: decode to PAADDU_W using decoder 31
7277 // 12505: }
7278 1, 6, // 12509: case 0x1: {
7279 OPC_CheckPredicate, 47, // 12511: check predicate 47
7280 OPC_Decode, 132, 119, 59, // 12513: decode to PMACCU_W_H01 using decoder 59
7281 // 12513: }
7282 3, 6, // 12517: case 0x3: {
7283 OPC_CheckPredicate, 47, // 12519: check predicate 47
7284 OPC_Decode, 133, 119, 59, // 12521: decode to PMACCU_W_H11 using decoder 59
7285 // 12521: }
7286 5, 6, // 12525: case 0x5: {
7287 OPC_CheckPredicate, 47, // 12527: check predicate 47
7288 OPC_Decode, 182, 119, 59, // 12529: decode to PMQ2ADDA_W using decoder 59
7289 // 12529: }
7290 7, 0, // 12533: case 0x7: {
7291 OPC_CheckPredicate, 47, // 12535: check predicate 47
7292 OPC_Decode, 162, 119, 59, // 12537: decode to PMHACC_W_H1 using decoder 59
7293 // 12537: }
7294 // 12537: } // switch Inst[14:12]
7295 // 12537: }
7296 94, 35, // 12541: case 0x5e: {
7297 OPC_SwitchField, 12, 3, // 12543: switch Inst[14:12] {
7298 0, 6, // 12546: case 0x0: {
7299 OPC_CheckPredicate, 42, // 12548: check predicate 42
7300 OPC_Decode, 140, 118, 31, // 12550: decode to PAADDU_B using decoder 31
7301 // 12550: }
7302 1, 6, // 12554: case 0x1: {
7303 OPC_CheckPredicate, 42, // 12556: check predicate 42
7304 OPC_Decode, 155, 118, 59, // 12558: decode to PABDSUMAU_B using decoder 59
7305 // 12558: }
7306 5, 6, // 12562: case 0x5: {
7307 OPC_CheckPredicate, 42, // 12564: check predicate 42
7308 OPC_Decode, 188, 119, 59, // 12566: decode to PMQR2ADDA_H using decoder 59
7309 // 12566: }
7310 7, 0, // 12570: case 0x7: {
7311 OPC_CheckPredicate, 42, // 12572: check predicate 42
7312 OPC_Decode, 151, 119, 59, // 12574: decode to PMHACCSU_H_B1 using decoder 59
7313 // 12574: }
7314 // 12574: } // switch Inst[14:12]
7315 // 12574: }
7316 95, 35, // 12578: case 0x5f: {
7317 OPC_SwitchField, 12, 3, // 12580: switch Inst[14:12] {
7318 1, 6, // 12583: case 0x1: {
7319 OPC_CheckPredicate, 47, // 12585: check predicate 47
7320 OPC_Decode, 208, 116, 59, // 12587: decode to MACCU_W01 using decoder 59
7321 // 12587: }
7322 3, 6, // 12591: case 0x3: {
7323 OPC_CheckPredicate, 47, // 12593: check predicate 47
7324 OPC_Decode, 209, 116, 59, // 12595: decode to MACCU_W11 using decoder 59
7325 // 12595: }
7326 5, 6, // 12599: case 0x5: {
7327 OPC_CheckPredicate, 47, // 12601: check predicate 47
7328 OPC_Decode, 189, 119, 59, // 12603: decode to PMQR2ADDA_W using decoder 59
7329 // 12603: }
7330 7, 0, // 12607: case 0x7: {
7331 OPC_CheckPredicate, 47, // 12609: check predicate 47
7332 OPC_Decode, 154, 119, 59, // 12611: decode to PMHACCSU_W_H1 using decoder 59
7333 // 12611: }
7334 // 12611: } // switch Inst[14:12]
7335 // 12611: }
7336 96, 43, // 12615: case 0x60: {
7337 OPC_SwitchField, 12, 3, // 12617: switch Inst[14:12] {
7338 0, 6, // 12620: case 0x0: {
7339 OPC_CheckPredicate, 42, // 12622: check predicate 42
7340 OPC_Decode, 184, 121, 31, // 12624: decode to PSUB_H using decoder 31
7341 // 12624: }
7342 2, 6, // 12628: case 0x2: {
7343 OPC_CheckPredicate, 47, // 12630: check predicate 47
7344 OPC_Decode, 131, 120, 31, // 12632: decode to PNCLIPP_B using decoder 31
7345 // 12632: }
7346 5, 6, // 12636: case 0x5: {
7347 OPC_CheckPredicate, 42, // 12638: check predicate 42
7348 OPC_Decode, 229, 118, 31, // 12640: decode to PM2SUB_H using decoder 31
7349 // 12640: }
7350 6, 6, // 12644: case 0x6: {
7351 OPC_CheckPredicate, 42, // 12646: check predicate 42
7352 OPC_Decode, 201, 119, 31, // 12648: decode to PMSEQ_H using decoder 31
7353 // 12648: }
7354 7, 0, // 12652: case 0x7: {
7355 OPC_CheckPredicate, 42, // 12654: check predicate 42
7356 OPC_Decode, 221, 119, 31, // 12656: decode to PMULHSU_H using decoder 31
7357 // 12656: }
7358 // 12656: } // switch Inst[14:12]
7359 // 12656: }
7360 97, 43, // 12660: case 0x61: {
7361 OPC_SwitchField, 12, 3, // 12662: switch Inst[14:12] {
7362 0, 6, // 12665: case 0x0: {
7363 OPC_CheckPredicate, 47, // 12667: check predicate 47
7364 OPC_Decode, 185, 121, 31, // 12669: decode to PSUB_W using decoder 31
7365 // 12669: }
7366 2, 6, // 12673: case 0x2: {
7367 OPC_CheckPredicate, 47, // 12675: check predicate 47
7368 OPC_Decode, 132, 120, 31, // 12677: decode to PNCLIPP_H using decoder 31
7369 // 12677: }
7370 5, 6, // 12681: case 0x5: {
7371 OPC_CheckPredicate, 47, // 12683: check predicate 47
7372 OPC_Decode, 231, 118, 31, // 12685: decode to PM2SUB_W using decoder 31
7373 // 12685: }
7374 6, 6, // 12689: case 0x6: {
7375 OPC_CheckPredicate, 47, // 12691: check predicate 47
7376 OPC_Decode, 202, 119, 31, // 12693: decode to PMSEQ_W using decoder 31
7377 // 12693: }
7378 7, 0, // 12697: case 0x7: {
7379 OPC_CheckPredicate, 47, // 12699: check predicate 47
7380 OPC_Decode, 224, 119, 31, // 12701: decode to PMULHSU_W using decoder 31
7381 // 12701: }
7382 // 12701: } // switch Inst[14:12]
7383 // 12701: }
7384 98, 35, // 12705: case 0x62: {
7385 OPC_SwitchField, 12, 3, // 12707: switch Inst[14:12] {
7386 0, 6, // 12710: case 0x0: {
7387 OPC_CheckPredicate, 42, // 12712: check predicate 42
7388 OPC_Decode, 180, 121, 31, // 12714: decode to PSUB_B using decoder 31
7389 // 12714: }
7390 5, 6, // 12718: case 0x5: {
7391 OPC_CheckPredicate, 42, // 12720: check predicate 42
7392 OPC_Decode, 223, 118, 31, // 12722: decode to PM2SADD_H using decoder 31
7393 // 12722: }
7394 6, 6, // 12726: case 0x6: {
7395 OPC_CheckPredicate, 42, // 12728: check predicate 42
7396 OPC_Decode, 197, 119, 31, // 12730: decode to PMSEQ_B using decoder 31
7397 // 12730: }
7398 7, 0, // 12734: case 0x7: {
7399 OPC_CheckPredicate, 42, // 12736: check predicate 42
7400 OPC_Decode, 215, 119, 31, // 12738: decode to PMULHRSU_H using decoder 31
7401 // 12738: }
7402 // 12738: } // switch Inst[14:12]
7403 // 12738: }
7404 99, 19, // 12742: case 0x63: {
7405 OPC_SwitchField, 12, 3, // 12744: switch Inst[14:12] {
7406 2, 6, // 12747: case 0x2: {
7407 OPC_CheckPredicate, 47, // 12749: check predicate 47
7408 OPC_Decode, 133, 120, 31, // 12751: decode to PNCLIPP_W using decoder 31
7409 // 12751: }
7410 7, 0, // 12755: case 0x7: {
7411 OPC_CheckPredicate, 47, // 12757: check predicate 47
7412 OPC_Decode, 216, 119, 31, // 12759: decode to PMULHRSU_W using decoder 31
7413 // 12759: }
7414 // 12759: } // switch Inst[14:12]
7415 // 12759: }
7416 100, 27, // 12763: case 0x64: {
7417 OPC_SwitchField, 12, 3, // 12765: switch Inst[14:12] {
7418 0, 6, // 12768: case 0x0: {
7419 OPC_CheckPredicate, 42, // 12770: check predicate 42
7420 OPC_Decode, 164, 118, 31, // 12772: decode to PABD_H using decoder 31
7421 // 12772: }
7422 5, 6, // 12776: case 0x5: {
7423 OPC_CheckPredicate, 42, // 12778: check predicate 42
7424 OPC_Decode, 225, 118, 59, // 12780: decode to PM2SUBA_H using decoder 59
7425 // 12780: }
7426 7, 0, // 12784: case 0x7: {
7427 OPC_CheckPredicate, 42, // 12786: check predicate 42
7428 OPC_Decode, 149, 119, 59, // 12788: decode to PMHACCSU_H using decoder 59
7429 // 12788: }
7430 // 12788: } // switch Inst[14:12]
7431 // 12788: }
7432 101, 19, // 12792: case 0x65: {
7433 OPC_SwitchField, 12, 3, // 12794: switch Inst[14:12] {
7434 5, 6, // 12797: case 0x5: {
7435 OPC_CheckPredicate, 47, // 12799: check predicate 47
7436 OPC_Decode, 227, 118, 59, // 12801: decode to PM2SUBA_W using decoder 59
7437 // 12801: }
7438 7, 0, // 12805: case 0x7: {
7439 OPC_CheckPredicate, 47, // 12807: check predicate 47
7440 OPC_Decode, 152, 119, 59, // 12809: decode to PMHACCSU_W using decoder 59
7441 // 12809: }
7442 // 12809: } // switch Inst[14:12]
7443 // 12809: }
7444 102, 19, // 12813: case 0x66: {
7445 OPC_SwitchField, 12, 3, // 12815: switch Inst[14:12] {
7446 0, 6, // 12818: case 0x0: {
7447 OPC_CheckPredicate, 42, // 12820: check predicate 42
7448 OPC_Decode, 161, 118, 31, // 12822: decode to PABD_B using decoder 31
7449 // 12822: }
7450 7, 0, // 12826: case 0x7: {
7451 OPC_CheckPredicate, 42, // 12828: check predicate 42
7452 OPC_Decode, 163, 119, 59, // 12830: decode to PMHRACCSU_H using decoder 59
7453 // 12830: }
7454 // 12830: } // switch Inst[14:12]
7455 // 12830: }
7456 103, 10, // 12834: case 0x67: {
7457 OPC_CheckPredicate, 47, // 12836: check predicate 47
7458 OPC_CheckField, 12, 3, 7, // 12838: check Inst[14:12] == 0x7
7459 OPC_Decode, 164, 119, 59, // 12842: decode to PMHRACCSU_W using decoder 59
7460 // 12842: }
7461 104, 35, // 12846: case 0x68: {
7462 OPC_SwitchField, 12, 3, // 12848: switch Inst[14:12] {
7463 0, 6, // 12851: case 0x0: {
7464 OPC_CheckPredicate, 42, // 12853: check predicate 42
7465 OPC_Decode, 178, 121, 31, // 12855: decode to PSSUB_H using decoder 31
7466 // 12855: }
7467 5, 6, // 12859: case 0x5: {
7468 OPC_CheckPredicate, 42, // 12861: check predicate 42
7469 OPC_Decode, 230, 118, 31, // 12863: decode to PM2SUB_HX using decoder 31
7470 // 12863: }
7471 6, 6, // 12867: case 0x6: {
7472 OPC_CheckPredicate, 42, // 12869: check predicate 42
7473 OPC_Decode, 213, 119, 31, // 12871: decode to PMSLT_H using decoder 31
7474 // 12871: }
7475 7, 0, // 12875: case 0x7: {
7476 OPC_CheckPredicate, 42, // 12877: check predicate 42
7477 OPC_Decode, 237, 119, 31, // 12879: decode to PMULQ_H using decoder 31
7478 // 12879: }
7479 // 12879: } // switch Inst[14:12]
7480 // 12879: }
7481 105, 35, // 12883: case 0x69: {
7482 OPC_SwitchField, 12, 3, // 12885: switch Inst[14:12] {
7483 0, 6, // 12888: case 0x0: {
7484 OPC_CheckPredicate, 47, // 12890: check predicate 47
7485 OPC_Decode, 179, 121, 31, // 12892: decode to PSSUB_W using decoder 31
7486 // 12892: }
7487 5, 6, // 12896: case 0x5: {
7488 OPC_CheckPredicate, 47, // 12898: check predicate 47
7489 OPC_Decode, 232, 118, 31, // 12900: decode to PM2SUB_WX using decoder 31
7490 // 12900: }
7491 6, 6, // 12904: case 0x6: {
7492 OPC_CheckPredicate, 47, // 12906: check predicate 47
7493 OPC_Decode, 214, 119, 31, // 12908: decode to PMSLT_W using decoder 31
7494 // 12908: }
7495 7, 0, // 12912: case 0x7: {
7496 OPC_CheckPredicate, 47, // 12914: check predicate 47
7497 OPC_Decode, 238, 119, 31, // 12916: decode to PMULQ_W using decoder 31
7498 // 12916: }
7499 // 12916: } // switch Inst[14:12]
7500 // 12916: }
7501 106, 35, // 12920: case 0x6a: {
7502 OPC_SwitchField, 12, 3, // 12922: switch Inst[14:12] {
7503 0, 6, // 12925: case 0x0: {
7504 OPC_CheckPredicate, 42, // 12927: check predicate 42
7505 OPC_Decode, 174, 121, 31, // 12929: decode to PSSUB_B using decoder 31
7506 // 12929: }
7507 5, 6, // 12933: case 0x5: {
7508 OPC_CheckPredicate, 42, // 12935: check predicate 42
7509 OPC_Decode, 224, 118, 31, // 12937: decode to PM2SADD_HX using decoder 31
7510 // 12937: }
7511 6, 6, // 12941: case 0x6: {
7512 OPC_CheckPredicate, 42, // 12943: check predicate 42
7513 OPC_Decode, 209, 119, 31, // 12945: decode to PMSLT_B using decoder 31
7514 // 12945: }
7515 7, 0, // 12949: case 0x7: {
7516 OPC_CheckPredicate, 42, // 12951: check predicate 42
7517 OPC_Decode, 235, 119, 31, // 12953: decode to PMULQR_H using decoder 31
7518 // 12953: }
7519 // 12953: } // switch Inst[14:12]
7520 // 12953: }
7521 107, 10, // 12957: case 0x6b: {
7522 OPC_CheckPredicate, 47, // 12959: check predicate 47
7523 OPC_CheckField, 12, 3, 7, // 12961: check Inst[14:12] == 0x7
7524 OPC_Decode, 236, 119, 31, // 12965: decode to PMULQR_W using decoder 31
7525 // 12965: }
7526 108, 27, // 12969: case 0x6c: {
7527 OPC_SwitchField, 12, 3, // 12971: switch Inst[14:12] {
7528 0, 6, // 12974: case 0x0: {
7529 OPC_CheckPredicate, 42, // 12976: check predicate 42
7530 OPC_Decode, 194, 118, 31, // 12978: decode to PASUB_H using decoder 31
7531 // 12978: }
7532 5, 6, // 12982: case 0x5: {
7533 OPC_CheckPredicate, 42, // 12984: check predicate 42
7534 OPC_Decode, 226, 118, 59, // 12986: decode to PM2SUBA_HX using decoder 59
7535 // 12986: }
7536 6, 0, // 12990: case 0x6: {
7537 OPC_CheckPredicate, 42, // 12992: check predicate 42
7538 OPC_Decode, 207, 119, 31, // 12994: decode to PMSLTU_H using decoder 31
7539 // 12994: }
7540 // 12994: } // switch Inst[14:12]
7541 // 12994: }
7542 109, 27, // 12998: case 0x6d: {
7543 OPC_SwitchField, 12, 3, // 13000: switch Inst[14:12] {
7544 0, 6, // 13003: case 0x0: {
7545 OPC_CheckPredicate, 47, // 13005: check predicate 47
7546 OPC_Decode, 195, 118, 31, // 13007: decode to PASUB_W using decoder 31
7547 // 13007: }
7548 5, 6, // 13011: case 0x5: {
7549 OPC_CheckPredicate, 47, // 13013: check predicate 47
7550 OPC_Decode, 228, 118, 59, // 13015: decode to PM2SUBA_WX using decoder 59
7551 // 13015: }
7552 6, 0, // 13019: case 0x6: {
7553 OPC_CheckPredicate, 47, // 13021: check predicate 47
7554 OPC_Decode, 208, 119, 31, // 13023: decode to PMSLTU_W using decoder 31
7555 // 13023: }
7556 // 13023: } // switch Inst[14:12]
7557 // 13023: }
7558 110, 19, // 13027: case 0x6e: {
7559 OPC_SwitchField, 12, 3, // 13029: switch Inst[14:12] {
7560 0, 6, // 13032: case 0x0: {
7561 OPC_CheckPredicate, 42, // 13034: check predicate 42
7562 OPC_Decode, 190, 118, 31, // 13036: decode to PASUB_B using decoder 31
7563 // 13036: }
7564 6, 0, // 13040: case 0x6: {
7565 OPC_CheckPredicate, 42, // 13042: check predicate 42
7566 OPC_Decode, 203, 119, 31, // 13044: decode to PMSLTU_B using decoder 31
7567 // 13044: }
7568 // 13044: } // switch Inst[14:12]
7569 // 13044: }
7570 112, 35, // 13048: case 0x70: {
7571 OPC_SwitchField, 12, 3, // 13050: switch Inst[14:12] {
7572 2, 6, // 13053: case 0x2: {
7573 OPC_CheckPredicate, 47, // 13055: check predicate 47
7574 OPC_Decode, 194, 125, 31, // 13057: decode to UNZIP8P using decoder 31
7575 // 13057: }
7576 3, 6, // 13061: case 0x3: {
7577 OPC_CheckPredicate, 42, // 13063: check predicate 42
7578 OPC_Decode, 239, 119, 31, // 13065: decode to PMULSU_H_B00 using decoder 31
7579 // 13065: }
7580 5, 6, // 13069: case 0x5: {
7581 OPC_CheckPredicate, 42, // 13071: check predicate 42
7582 OPC_Decode, 215, 118, 31, // 13073: decode to PM2ADDSU_H using decoder 31
7583 // 13073: }
7584 6, 0, // 13077: case 0x6: {
7585 OPC_CheckPredicate, 42, // 13079: check predicate 42
7586 OPC_Decode, 179, 119, 31, // 13081: decode to PMIN_H using decoder 31
7587 // 13081: }
7588 // 13081: } // switch Inst[14:12]
7589 // 13081: }
7590 113, 35, // 13085: case 0x71: {
7591 OPC_SwitchField, 12, 3, // 13087: switch Inst[14:12] {
7592 2, 6, // 13090: case 0x2: {
7593 OPC_CheckPredicate, 47, // 13092: check predicate 47
7594 OPC_Decode, 192, 125, 31, // 13094: decode to UNZIP16P using decoder 31
7595 // 13094: }
7596 3, 6, // 13098: case 0x3: {
7597 OPC_CheckPredicate, 47, // 13100: check predicate 47
7598 OPC_Decode, 241, 119, 31, // 13102: decode to PMULSU_W_H00 using decoder 31
7599 // 13102: }
7600 5, 6, // 13106: case 0x5: {
7601 OPC_CheckPredicate, 47, // 13108: check predicate 47
7602 OPC_Decode, 216, 118, 31, // 13110: decode to PM2ADDSU_W using decoder 31
7603 // 13110: }
7604 6, 0, // 13114: case 0x6: {
7605 OPC_CheckPredicate, 47, // 13116: check predicate 47
7606 OPC_Decode, 180, 119, 31, // 13118: decode to PMIN_W using decoder 31
7607 // 13118: }
7608 // 13118: } // switch Inst[14:12]
7609 // 13118: }
7610 114, 27, // 13122: case 0x72: {
7611 OPC_SwitchField, 12, 3, // 13124: switch Inst[14:12] {
7612 2, 6, // 13127: case 0x2: {
7613 OPC_CheckPredicate, 47, // 13129: check predicate 47
7614 OPC_Decode, 193, 125, 31, // 13131: decode to UNZIP8HP using decoder 31
7615 // 13131: }
7616 5, 6, // 13135: case 0x5: {
7617 OPC_CheckPredicate, 42, // 13137: check predicate 42
7618 OPC_Decode, 251, 118, 31, // 13139: decode to PM4ADDSU_B using decoder 31
7619 // 13139: }
7620 6, 0, // 13143: case 0x6: {
7621 OPC_CheckPredicate, 42, // 13145: check predicate 42
7622 OPC_Decode, 175, 119, 31, // 13147: decode to PMIN_B using decoder 31
7623 // 13147: }
7624 // 13147: } // switch Inst[14:12]
7625 // 13147: }
7626 115, 27, // 13151: case 0x73: {
7627 OPC_SwitchField, 12, 3, // 13153: switch Inst[14:12] {
7628 2, 6, // 13156: case 0x2: {
7629 OPC_CheckPredicate, 47, // 13158: check predicate 47
7630 OPC_Decode, 191, 125, 31, // 13160: decode to UNZIP16HP using decoder 31
7631 // 13160: }
7632 3, 6, // 13164: case 0x3: {
7633 OPC_CheckPredicate, 47, // 13166: check predicate 47
7634 OPC_Decode, 186, 117, 31, // 13168: decode to MULSU_W00 using decoder 31
7635 // 13168: }
7636 5, 0, // 13172: case 0x5: {
7637 OPC_CheckPredicate, 47, // 13174: check predicate 47
7638 OPC_Decode, 252, 118, 31, // 13176: decode to PM4ADDSU_H using decoder 31
7639 // 13176: }
7640 // 13176: } // switch Inst[14:12]
7641 // 13176: }
7642 116, 35, // 13180: case 0x74: {
7643 OPC_SwitchField, 12, 3, // 13182: switch Inst[14:12] {
7644 0, 6, // 13185: case 0x0: {
7645 OPC_CheckPredicate, 42, // 13187: check predicate 42
7646 OPC_Decode, 160, 118, 31, // 13189: decode to PABDU_H using decoder 31
7647 // 13189: }
7648 5, 6, // 13193: case 0x5: {
7649 OPC_CheckPredicate, 42, // 13195: check predicate 42
7650 OPC_Decode, 207, 118, 59, // 13197: decode to PM2ADDASU_H using decoder 59
7651 // 13197: }
7652 6, 6, // 13201: case 0x6: {
7653 OPC_CheckPredicate, 42, // 13203: check predicate 42
7654 OPC_Decode, 173, 119, 31, // 13205: decode to PMINU_H using decoder 31
7655 // 13205: }
7656 7, 0, // 13209: case 0x7: {
7657 OPC_CheckPredicate, 47, // 13211: check predicate 47
7658 OPC_Decode, 185, 119, 59, // 13213: decode to PMQACC_W_H00 using decoder 59
7659 // 13213: }
7660 // 13213: } // switch Inst[14:12]
7661 // 13213: }
7662 117, 35, // 13217: case 0x75: {
7663 OPC_SwitchField, 12, 3, // 13219: switch Inst[14:12] {
7664 3, 6, // 13222: case 0x3: {
7665 OPC_CheckPredicate, 47, // 13224: check predicate 47
7666 OPC_Decode, 129, 119, 59, // 13226: decode to PMACCSU_W_H00 using decoder 59
7667 // 13226: }
7668 5, 6, // 13230: case 0x5: {
7669 OPC_CheckPredicate, 47, // 13232: check predicate 47
7670 OPC_Decode, 208, 118, 59, // 13234: decode to PM2ADDASU_W using decoder 59
7671 // 13234: }
7672 6, 6, // 13238: case 0x6: {
7673 OPC_CheckPredicate, 47, // 13240: check predicate 47
7674 OPC_Decode, 174, 119, 31, // 13242: decode to PMINU_W using decoder 31
7675 // 13242: }
7676 7, 0, // 13246: case 0x7: {
7677 OPC_CheckPredicate, 47, // 13248: check predicate 47
7678 OPC_Decode, 156, 117, 59, // 13250: decode to MQACC_W00 using decoder 59
7679 // 13250: }
7680 // 13250: } // switch Inst[14:12]
7681 // 13250: }
7682 118, 35, // 13254: case 0x76: {
7683 OPC_SwitchField, 12, 3, // 13256: switch Inst[14:12] {
7684 0, 6, // 13259: case 0x0: {
7685 OPC_CheckPredicate, 42, // 13261: check predicate 42
7686 OPC_Decode, 157, 118, 31, // 13263: decode to PABDU_B using decoder 31
7687 // 13263: }
7688 5, 6, // 13267: case 0x5: {
7689 OPC_CheckPredicate, 42, // 13269: check predicate 42
7690 OPC_Decode, 245, 118, 59, // 13271: decode to PM4ADDASU_B using decoder 59
7691 // 13271: }
7692 6, 6, // 13275: case 0x6: {
7693 OPC_CheckPredicate, 42, // 13277: check predicate 42
7694 OPC_Decode, 169, 119, 31, // 13279: decode to PMINU_B using decoder 31
7695 // 13279: }
7696 7, 0, // 13283: case 0x7: {
7697 OPC_CheckPredicate, 47, // 13285: check predicate 47
7698 OPC_Decode, 192, 119, 59, // 13287: decode to PMQRACC_W_H00 using decoder 59
7699 // 13287: }
7700 // 13287: } // switch Inst[14:12]
7701 // 13287: }
7702 119, 27, // 13291: case 0x77: {
7703 OPC_SwitchField, 12, 3, // 13293: switch Inst[14:12] {
7704 3, 6, // 13296: case 0x3: {
7705 OPC_CheckPredicate, 47, // 13298: check predicate 47
7706 OPC_Decode, 202, 116, 59, // 13300: decode to MACCSU_W00 using decoder 59
7707 // 13300: }
7708 5, 6, // 13304: case 0x5: {
7709 OPC_CheckPredicate, 47, // 13306: check predicate 47
7710 OPC_Decode, 246, 118, 59, // 13308: decode to PM4ADDASU_H using decoder 59
7711 // 13308: }
7712 7, 0, // 13312: case 0x7: {
7713 OPC_CheckPredicate, 47, // 13314: check predicate 47
7714 OPC_Decode, 162, 117, 59, // 13316: decode to MQRACC_W00 using decoder 59
7715 // 13316: }
7716 // 13316: } // switch Inst[14:12]
7717 // 13316: }
7718 120, 36, // 13320: case 0x78: {
7719 OPC_SwitchField, 12, 3, // 13322: switch Inst[14:12] {
7720 0, 6, // 13325: case 0x0: {
7721 OPC_CheckPredicate, 42, // 13327: check predicate 42
7722 OPC_Decode, 172, 121, 31, // 13329: decode to PSSUBU_H using decoder 31
7723 // 13329: }
7724 2, 7, // 13333: case 0x2: {
7725 OPC_CheckPredicate, 47, // 13335: check predicate 47
7726 OPC_Decode, 241, 131, 1, 31, // 13337: decode to ZIP8P using decoder 31
7727 // 13337: }
7728 3, 6, // 13342: case 0x3: {
7729 OPC_CheckPredicate, 42, // 13344: check predicate 42
7730 OPC_Decode, 240, 119, 31, // 13346: decode to PMULSU_H_B11 using decoder 31
7731 // 13346: }
7732 6, 0, // 13350: case 0x6: {
7733 OPC_CheckPredicate, 42, // 13352: check predicate 42
7734 OPC_Decode, 147, 119, 31, // 13354: decode to PMAX_H using decoder 31
7735 // 13354: }
7736 // 13354: } // switch Inst[14:12]
7737 // 13354: }
7738 121, 36, // 13358: case 0x79: {
7739 OPC_SwitchField, 12, 3, // 13360: switch Inst[14:12] {
7740 0, 6, // 13363: case 0x0: {
7741 OPC_CheckPredicate, 47, // 13365: check predicate 47
7742 OPC_Decode, 173, 121, 31, // 13367: decode to PSSUBU_W using decoder 31
7743 // 13367: }
7744 2, 7, // 13371: case 0x2: {
7745 OPC_CheckPredicate, 47, // 13373: check predicate 47
7746 OPC_Decode, 239, 131, 1, 31, // 13375: decode to ZIP16P using decoder 31
7747 // 13375: }
7748 3, 6, // 13380: case 0x3: {
7749 OPC_CheckPredicate, 47, // 13382: check predicate 47
7750 OPC_Decode, 242, 119, 31, // 13384: decode to PMULSU_W_H11 using decoder 31
7751 // 13384: }
7752 6, 0, // 13388: case 0x6: {
7753 OPC_CheckPredicate, 47, // 13390: check predicate 47
7754 OPC_Decode, 148, 119, 31, // 13392: decode to PMAX_W using decoder 31
7755 // 13392: }
7756 // 13392: } // switch Inst[14:12]
7757 // 13392: }
7758 122, 28, // 13396: case 0x7a: {
7759 OPC_SwitchField, 12, 3, // 13398: switch Inst[14:12] {
7760 0, 6, // 13401: case 0x0: {
7761 OPC_CheckPredicate, 42, // 13403: check predicate 42
7762 OPC_Decode, 168, 121, 31, // 13405: decode to PSSUBU_B using decoder 31
7763 // 13405: }
7764 2, 7, // 13409: case 0x2: {
7765 OPC_CheckPredicate, 47, // 13411: check predicate 47
7766 OPC_Decode, 240, 131, 1, 31, // 13413: decode to ZIP8HP using decoder 31
7767 // 13413: }
7768 6, 0, // 13418: case 0x6: {
7769 OPC_CheckPredicate, 42, // 13420: check predicate 42
7770 OPC_Decode, 143, 119, 31, // 13422: decode to PMAX_B using decoder 31
7771 // 13422: }
7772 // 13422: } // switch Inst[14:12]
7773 // 13422: }
7774 123, 20, // 13426: case 0x7b: {
7775 OPC_SwitchField, 12, 3, // 13428: switch Inst[14:12] {
7776 2, 7, // 13431: case 0x2: {
7777 OPC_CheckPredicate, 47, // 13433: check predicate 47
7778 OPC_Decode, 238, 131, 1, 31, // 13435: decode to ZIP16HP using decoder 31
7779 // 13435: }
7780 3, 0, // 13440: case 0x3: {
7781 OPC_CheckPredicate, 47, // 13442: check predicate 47
7782 OPC_Decode, 187, 117, 31, // 13444: decode to MULSU_W11 using decoder 31
7783 // 13444: }
7784 // 13444: } // switch Inst[14:12]
7785 // 13444: }
7786 124, 35, // 13448: case 0x7c: {
7787 OPC_SwitchField, 12, 3, // 13450: switch Inst[14:12] {
7788 0, 6, // 13453: case 0x0: {
7789 OPC_CheckPredicate, 42, // 13455: check predicate 42
7790 OPC_Decode, 188, 118, 31, // 13457: decode to PASUBU_H using decoder 31
7791 // 13457: }
7792 5, 6, // 13461: case 0x5: {
7793 OPC_CheckPredicate, 47, // 13463: check predicate 47
7794 OPC_Decode, 186, 119, 59, // 13465: decode to PMQACC_W_H01 using decoder 59
7795 // 13465: }
7796 6, 6, // 13469: case 0x6: {
7797 OPC_CheckPredicate, 42, // 13471: check predicate 42
7798 OPC_Decode, 141, 119, 31, // 13473: decode to PMAXU_H using decoder 31
7799 // 13473: }
7800 7, 0, // 13477: case 0x7: {
7801 OPC_CheckPredicate, 47, // 13479: check predicate 47
7802 OPC_Decode, 187, 119, 59, // 13481: decode to PMQACC_W_H11 using decoder 59
7803 // 13481: }
7804 // 13481: } // switch Inst[14:12]
7805 // 13481: }
7806 125, 43, // 13485: case 0x7d: {
7807 OPC_SwitchField, 12, 3, // 13487: switch Inst[14:12] {
7808 0, 6, // 13490: case 0x0: {
7809 OPC_CheckPredicate, 47, // 13492: check predicate 47
7810 OPC_Decode, 189, 118, 31, // 13494: decode to PASUBU_W using decoder 31
7811 // 13494: }
7812 3, 6, // 13498: case 0x3: {
7813 OPC_CheckPredicate, 47, // 13500: check predicate 47
7814 OPC_Decode, 130, 119, 59, // 13502: decode to PMACCSU_W_H11 using decoder 59
7815 // 13502: }
7816 5, 6, // 13506: case 0x5: {
7817 OPC_CheckPredicate, 47, // 13508: check predicate 47
7818 OPC_Decode, 157, 117, 59, // 13510: decode to MQACC_W01 using decoder 59
7819 // 13510: }
7820 6, 6, // 13514: case 0x6: {
7821 OPC_CheckPredicate, 47, // 13516: check predicate 47
7822 OPC_Decode, 142, 119, 31, // 13518: decode to PMAXU_W using decoder 31
7823 // 13518: }
7824 7, 0, // 13522: case 0x7: {
7825 OPC_CheckPredicate, 47, // 13524: check predicate 47
7826 OPC_Decode, 158, 117, 59, // 13526: decode to MQACC_W11 using decoder 59
7827 // 13526: }
7828 // 13526: } // switch Inst[14:12]
7829 // 13526: }
7830 126, 35, // 13530: case 0x7e: {
7831 OPC_SwitchField, 12, 3, // 13532: switch Inst[14:12] {
7832 0, 6, // 13535: case 0x0: {
7833 OPC_CheckPredicate, 42, // 13537: check predicate 42
7834 OPC_Decode, 184, 118, 31, // 13539: decode to PASUBU_B using decoder 31
7835 // 13539: }
7836 5, 6, // 13543: case 0x5: {
7837 OPC_CheckPredicate, 47, // 13545: check predicate 47
7838 OPC_Decode, 193, 119, 59, // 13547: decode to PMQRACC_W_H01 using decoder 59
7839 // 13547: }
7840 6, 6, // 13551: case 0x6: {
7841 OPC_CheckPredicate, 42, // 13553: check predicate 42
7842 OPC_Decode, 137, 119, 31, // 13555: decode to PMAXU_B using decoder 31
7843 // 13555: }
7844 7, 0, // 13559: case 0x7: {
7845 OPC_CheckPredicate, 47, // 13561: check predicate 47
7846 OPC_Decode, 194, 119, 59, // 13563: decode to PMQRACC_W_H11 using decoder 59
7847 // 13563: }
7848 // 13563: } // switch Inst[14:12]
7849 // 13563: }
7850 127, 0, // 13567: case 0x7f: {
7851 OPC_SwitchField, 12, 3, // 13569: switch Inst[14:12] {
7852 3, 6, // 13572: case 0x3: {
7853 OPC_CheckPredicate, 47, // 13574: check predicate 47
7854 OPC_Decode, 203, 116, 59, // 13576: decode to MACCSU_W11 using decoder 59
7855 // 13576: }
7856 5, 6, // 13580: case 0x5: {
7857 OPC_CheckPredicate, 47, // 13582: check predicate 47
7858 OPC_Decode, 163, 117, 59, // 13584: decode to MQRACC_W01 using decoder 59
7859 // 13584: }
7860 7, 0, // 13588: case 0x7: {
7861 OPC_CheckPredicate, 47, // 13590: check predicate 47
7862 OPC_Decode, 164, 117, 59, // 13592: decode to MQRACC_W11 using decoder 59
7863 // 13592: }
7864 // 13592: } // switch Inst[14:12]
7865 // 13592: }
7866 // 13592: } // switch Inst[31:25]
7867 // 13592: }
7868 67, 35, // 13596: case 0x43: {
7869 OPC_SwitchField, 25, 2, // 13598: switch Inst[26:25] {
7870 0, 6, // 13601: case 0x0: {
7871 OPC_CheckPredicate, 24, // 13603: check predicate 24
7872 OPC_Decode, 134, 115, 60, // 13605: decode to FMADD_S using decoder 60
7873 // 13605: }
7874 1, 6, // 13609: case 0x1: {
7875 OPC_CheckPredicate, 25, // 13611: check predicate 25
7876 OPC_Decode, 128, 115, 61, // 13613: decode to FMADD_D using decoder 61
7877 // 13613: }
7878 2, 6, // 13617: case 0x2: {
7879 OPC_CheckPredicate, 79, // 13619: check predicate 79
7880 OPC_Decode, 131, 115, 62, // 13621: decode to FMADD_H using decoder 62
7881 // 13621: }
7882 3, 0, // 13625: case 0x3: {
7883 OPC_CheckPredicate, 26, // 13627: check predicate 26
7884 OPC_Decode, 133, 115, 63, // 13629: decode to FMADD_Q using decoder 63
7885 // 13629: }
7886 // 13629: } // switch Inst[26:25]
7887 // 13629: }
7888 71, 35, // 13633: case 0x47: {
7889 OPC_SwitchField, 25, 2, // 13635: switch Inst[26:25] {
7890 0, 6, // 13638: case 0x0: {
7891 OPC_CheckPredicate, 24, // 13640: check predicate 24
7892 OPC_Decode, 166, 115, 60, // 13642: decode to FMSUB_S using decoder 60
7893 // 13642: }
7894 1, 6, // 13646: case 0x1: {
7895 OPC_CheckPredicate, 25, // 13648: check predicate 25
7896 OPC_Decode, 160, 115, 61, // 13650: decode to FMSUB_D using decoder 61
7897 // 13650: }
7898 2, 6, // 13654: case 0x2: {
7899 OPC_CheckPredicate, 79, // 13656: check predicate 79
7900 OPC_Decode, 163, 115, 62, // 13658: decode to FMSUB_H using decoder 62
7901 // 13658: }
7902 3, 0, // 13662: case 0x3: {
7903 OPC_CheckPredicate, 26, // 13664: check predicate 26
7904 OPC_Decode, 165, 115, 63, // 13666: decode to FMSUB_Q using decoder 63
7905 // 13666: }
7906 // 13666: } // switch Inst[26:25]
7907 // 13666: }
7908 75, 35, // 13670: case 0x4b: {
7909 OPC_SwitchField, 25, 2, // 13672: switch Inst[26:25] {
7910 0, 6, // 13675: case 0x0: {
7911 OPC_CheckPredicate, 24, // 13677: check predicate 24
7912 OPC_Decode, 201, 115, 60, // 13679: decode to FNMSUB_S using decoder 60
7913 // 13679: }
7914 1, 6, // 13683: case 0x1: {
7915 OPC_CheckPredicate, 25, // 13685: check predicate 25
7916 OPC_Decode, 195, 115, 61, // 13687: decode to FNMSUB_D using decoder 61
7917 // 13687: }
7918 2, 6, // 13691: case 0x2: {
7919 OPC_CheckPredicate, 79, // 13693: check predicate 79
7920 OPC_Decode, 198, 115, 62, // 13695: decode to FNMSUB_H using decoder 62
7921 // 13695: }
7922 3, 0, // 13699: case 0x3: {
7923 OPC_CheckPredicate, 26, // 13701: check predicate 26
7924 OPC_Decode, 200, 115, 63, // 13703: decode to FNMSUB_Q using decoder 63
7925 // 13703: }
7926 // 13703: } // switch Inst[26:25]
7927 // 13703: }
7928 79, 35, // 13707: case 0x4f: {
7929 OPC_SwitchField, 25, 2, // 13709: switch Inst[26:25] {
7930 0, 6, // 13712: case 0x0: {
7931 OPC_CheckPredicate, 24, // 13714: check predicate 24
7932 OPC_Decode, 193, 115, 60, // 13716: decode to FNMADD_S using decoder 60
7933 // 13716: }
7934 1, 6, // 13720: case 0x1: {
7935 OPC_CheckPredicate, 25, // 13722: check predicate 25
7936 OPC_Decode, 187, 115, 61, // 13724: decode to FNMADD_D using decoder 61
7937 // 13724: }
7938 2, 6, // 13728: case 0x2: {
7939 OPC_CheckPredicate, 79, // 13730: check predicate 79
7940 OPC_Decode, 190, 115, 62, // 13732: decode to FNMADD_H using decoder 62
7941 // 13732: }
7942 3, 0, // 13736: case 0x3: {
7943 OPC_CheckPredicate, 26, // 13738: check predicate 26
7944 OPC_Decode, 192, 115, 63, // 13740: decode to FNMADD_Q using decoder 63
7945 // 13740: }
7946 // 13740: } // switch Inst[26:25]
7947 // 13740: }
7948 83, 211, 10, // 13744: case 0x53: {
7949 OPC_SwitchField, 25, 7, // 13747: switch Inst[31:25] {
7950 0, 6, // 13750: case 0x0: {
7951 OPC_CheckPredicate, 24, // 13752: check predicate 24
7952 OPC_Decode, 240, 113, 64, // 13754: decode to FADD_S using decoder 64
7953 // 13754: }
7954 1, 6, // 13758: case 0x1: {
7955 OPC_CheckPredicate, 25, // 13760: check predicate 25
7956 OPC_Decode, 234, 113, 65, // 13762: decode to FADD_D using decoder 65
7957 // 13762: }
7958 2, 6, // 13766: case 0x2: {
7959 OPC_CheckPredicate, 79, // 13768: check predicate 79
7960 OPC_Decode, 237, 113, 66, // 13770: decode to FADD_H using decoder 66
7961 // 13770: }
7962 3, 6, // 13774: case 0x3: {
7963 OPC_CheckPredicate, 26, // 13776: check predicate 26
7964 OPC_Decode, 239, 113, 67, // 13778: decode to FADD_Q using decoder 67
7965 // 13778: }
7966 4, 6, // 13782: case 0x4: {
7967 OPC_CheckPredicate, 24, // 13784: check predicate 24
7968 OPC_Decode, 252, 115, 64, // 13786: decode to FSUB_S using decoder 64
7969 // 13786: }
7970 5, 6, // 13790: case 0x5: {
7971 OPC_CheckPredicate, 25, // 13792: check predicate 25
7972 OPC_Decode, 246, 115, 65, // 13794: decode to FSUB_D using decoder 65
7973 // 13794: }
7974 6, 6, // 13798: case 0x6: {
7975 OPC_CheckPredicate, 79, // 13800: check predicate 79
7976 OPC_Decode, 249, 115, 66, // 13802: decode to FSUB_H using decoder 66
7977 // 13802: }
7978 7, 6, // 13806: case 0x7: {
7979 OPC_CheckPredicate, 26, // 13808: check predicate 26
7980 OPC_Decode, 251, 115, 67, // 13810: decode to FSUB_Q using decoder 67
7981 // 13810: }
7982 8, 6, // 13814: case 0x8: {
7983 OPC_CheckPredicate, 24, // 13816: check predicate 24
7984 OPC_Decode, 174, 115, 64, // 13818: decode to FMUL_S using decoder 64
7985 // 13818: }
7986 9, 6, // 13822: case 0x9: {
7987 OPC_CheckPredicate, 25, // 13824: check predicate 25
7988 OPC_Decode, 168, 115, 65, // 13826: decode to FMUL_D using decoder 65
7989 // 13826: }
7990 10, 6, // 13830: case 0xa: {
7991 OPC_CheckPredicate, 79, // 13832: check predicate 79
7992 OPC_Decode, 171, 115, 66, // 13834: decode to FMUL_H using decoder 66
7993 // 13834: }
7994 11, 6, // 13838: case 0xb: {
7995 OPC_CheckPredicate, 26, // 13840: check predicate 26
7996 OPC_Decode, 173, 115, 67, // 13842: decode to FMUL_Q using decoder 67
7997 // 13842: }
7998 12, 6, // 13846: case 0xc: {
7999 OPC_CheckPredicate, 24, // 13848: check predicate 24
8000 OPC_Decode, 211, 114, 64, // 13850: decode to FDIV_S using decoder 64
8001 // 13850: }
8002 13, 6, // 13854: case 0xd: {
8003 OPC_CheckPredicate, 25, // 13856: check predicate 25
8004 OPC_Decode, 205, 114, 65, // 13858: decode to FDIV_D using decoder 65
8005 // 13858: }
8006 14, 6, // 13862: case 0xe: {
8007 OPC_CheckPredicate, 79, // 13864: check predicate 79
8008 OPC_Decode, 208, 114, 66, // 13866: decode to FDIV_H using decoder 66
8009 // 13866: }
8010 15, 6, // 13870: case 0xf: {
8011 OPC_CheckPredicate, 26, // 13872: check predicate 26
8012 OPC_Decode, 210, 114, 67, // 13874: decode to FDIV_Q using decoder 67
8013 // 13874: }
8014 16, 27, // 13878: case 0x10: {
8015 OPC_SwitchField, 12, 3, // 13880: switch Inst[14:12] {
8016 0, 6, // 13883: case 0x0: {
8017 OPC_CheckPredicate, 24, // 13885: check predicate 24
8018 OPC_Decode, 234, 115, 68, // 13887: decode to FSGNJ_S using decoder 68
8019 // 13887: }
8020 1, 6, // 13891: case 0x1: {
8021 OPC_CheckPredicate, 24, // 13893: check predicate 24
8022 OPC_Decode, 218, 115, 68, // 13895: decode to FSGNJN_S using decoder 68
8023 // 13895: }
8024 2, 0, // 13899: case 0x2: {
8025 OPC_CheckPredicate, 24, // 13901: check predicate 24
8026 OPC_Decode, 226, 115, 68, // 13903: decode to FSGNJX_S using decoder 68
8027 // 13903: }
8028 // 13903: } // switch Inst[14:12]
8029 // 13903: }
8030 17, 27, // 13907: case 0x11: {
8031 OPC_SwitchField, 12, 3, // 13909: switch Inst[14:12] {
8032 0, 6, // 13912: case 0x0: {
8033 OPC_CheckPredicate, 25, // 13914: check predicate 25
8034 OPC_Decode, 228, 115, 69, // 13916: decode to FSGNJ_D using decoder 69
8035 // 13916: }
8036 1, 6, // 13920: case 0x1: {
8037 OPC_CheckPredicate, 25, // 13922: check predicate 25
8038 OPC_Decode, 212, 115, 69, // 13924: decode to FSGNJN_D using decoder 69
8039 // 13924: }
8040 2, 0, // 13928: case 0x2: {
8041 OPC_CheckPredicate, 25, // 13930: check predicate 25
8042 OPC_Decode, 220, 115, 69, // 13932: decode to FSGNJX_D using decoder 69
8043 // 13932: }
8044 // 13932: } // switch Inst[14:12]
8045 // 13932: }
8046 18, 27, // 13936: case 0x12: {
8047 OPC_SwitchField, 12, 3, // 13938: switch Inst[14:12] {
8048 0, 6, // 13941: case 0x0: {
8049 OPC_CheckPredicate, 79, // 13943: check predicate 79
8050 OPC_Decode, 231, 115, 70, // 13945: decode to FSGNJ_H using decoder 70
8051 // 13945: }
8052 1, 6, // 13949: case 0x1: {
8053 OPC_CheckPredicate, 79, // 13951: check predicate 79
8054 OPC_Decode, 215, 115, 70, // 13953: decode to FSGNJN_H using decoder 70
8055 // 13953: }
8056 2, 0, // 13957: case 0x2: {
8057 OPC_CheckPredicate, 79, // 13959: check predicate 79
8058 OPC_Decode, 223, 115, 70, // 13961: decode to FSGNJX_H using decoder 70
8059 // 13961: }
8060 // 13961: } // switch Inst[14:12]
8061 // 13961: }
8062 19, 27, // 13965: case 0x13: {
8063 OPC_SwitchField, 12, 3, // 13967: switch Inst[14:12] {
8064 0, 6, // 13970: case 0x0: {
8065 OPC_CheckPredicate, 26, // 13972: check predicate 26
8066 OPC_Decode, 233, 115, 71, // 13974: decode to FSGNJ_Q using decoder 71
8067 // 13974: }
8068 1, 6, // 13978: case 0x1: {
8069 OPC_CheckPredicate, 26, // 13980: check predicate 26
8070 OPC_Decode, 217, 115, 71, // 13982: decode to FSGNJN_Q using decoder 71
8071 // 13982: }
8072 2, 0, // 13986: case 0x2: {
8073 OPC_CheckPredicate, 26, // 13988: check predicate 26
8074 OPC_Decode, 225, 115, 71, // 13990: decode to FSGNJX_Q using decoder 71
8075 // 13990: }
8076 // 13990: } // switch Inst[14:12]
8077 // 13990: }
8078 20, 35, // 13994: case 0x14: {
8079 OPC_SwitchField, 12, 3, // 13996: switch Inst[14:12] {
8080 0, 6, // 13999: case 0x0: {
8081 OPC_CheckPredicate, 24, // 14001: check predicate 24
8082 OPC_Decode, 158, 115, 68, // 14003: decode to FMIN_S using decoder 68
8083 // 14003: }
8084 1, 6, // 14007: case 0x1: {
8085 OPC_CheckPredicate, 24, // 14009: check predicate 24
8086 OPC_Decode, 146, 115, 68, // 14011: decode to FMAX_S using decoder 68
8087 // 14011: }
8088 2, 6, // 14015: case 0x2: {
8089 OPC_CheckPredicate, 80, // 14017: check predicate 80
8090 OPC_Decode, 151, 115, 68, // 14019: decode to FMINM_S using decoder 68
8091 // 14019: }
8092 3, 0, // 14023: case 0x3: {
8093 OPC_CheckPredicate, 80, // 14025: check predicate 80
8094 OPC_Decode, 139, 115, 68, // 14027: decode to FMAXM_S using decoder 68
8095 // 14027: }
8096 // 14027: } // switch Inst[14:12]
8097 // 14027: }
8098 21, 35, // 14031: case 0x15: {
8099 OPC_SwitchField, 12, 3, // 14033: switch Inst[14:12] {
8100 0, 6, // 14036: case 0x0: {
8101 OPC_CheckPredicate, 25, // 14038: check predicate 25
8102 OPC_Decode, 152, 115, 69, // 14040: decode to FMIN_D using decoder 69
8103 // 14040: }
8104 1, 6, // 14044: case 0x1: {
8105 OPC_CheckPredicate, 25, // 14046: check predicate 25
8106 OPC_Decode, 140, 115, 69, // 14048: decode to FMAX_D using decoder 69
8107 // 14048: }
8108 2, 6, // 14052: case 0x2: {
8109 OPC_CheckPredicate, 81, // 14054: check predicate 81
8110 OPC_Decode, 148, 115, 69, // 14056: decode to FMINM_D using decoder 69
8111 // 14056: }
8112 3, 0, // 14060: case 0x3: {
8113 OPC_CheckPredicate, 81, // 14062: check predicate 81
8114 OPC_Decode, 136, 115, 69, // 14064: decode to FMAXM_D using decoder 69
8115 // 14064: }
8116 // 14064: } // switch Inst[14:12]
8117 // 14064: }
8118 22, 35, // 14068: case 0x16: {
8119 OPC_SwitchField, 12, 3, // 14070: switch Inst[14:12] {
8120 0, 6, // 14073: case 0x0: {
8121 OPC_CheckPredicate, 79, // 14075: check predicate 79
8122 OPC_Decode, 155, 115, 70, // 14077: decode to FMIN_H using decoder 70
8123 // 14077: }
8124 1, 6, // 14081: case 0x1: {
8125 OPC_CheckPredicate, 79, // 14083: check predicate 79
8126 OPC_Decode, 143, 115, 70, // 14085: decode to FMAX_H using decoder 70
8127 // 14085: }
8128 2, 6, // 14089: case 0x2: {
8129 OPC_CheckPredicate, 82, // 14091: check predicate 82
8130 OPC_Decode, 149, 115, 70, // 14093: decode to FMINM_H using decoder 70
8131 // 14093: }
8132 3, 0, // 14097: case 0x3: {
8133 OPC_CheckPredicate, 82, // 14099: check predicate 82
8134 OPC_Decode, 137, 115, 70, // 14101: decode to FMAXM_H using decoder 70
8135 // 14101: }
8136 // 14101: } // switch Inst[14:12]
8137 // 14101: }
8138 23, 35, // 14105: case 0x17: {
8139 OPC_SwitchField, 12, 3, // 14107: switch Inst[14:12] {
8140 0, 6, // 14110: case 0x0: {
8141 OPC_CheckPredicate, 26, // 14112: check predicate 26
8142 OPC_Decode, 157, 115, 71, // 14114: decode to FMIN_Q using decoder 71
8143 // 14114: }
8144 1, 6, // 14118: case 0x1: {
8145 OPC_CheckPredicate, 26, // 14120: check predicate 26
8146 OPC_Decode, 145, 115, 71, // 14122: decode to FMAX_Q using decoder 71
8147 // 14122: }
8148 2, 6, // 14126: case 0x2: {
8149 OPC_CheckPredicate, 83, // 14128: check predicate 83
8150 OPC_Decode, 150, 115, 71, // 14130: decode to FMINM_Q using decoder 71
8151 // 14130: }
8152 3, 0, // 14134: case 0x3: {
8153 OPC_CheckPredicate, 83, // 14136: check predicate 83
8154 OPC_Decode, 138, 115, 71, // 14138: decode to FMAXM_Q using decoder 71
8155 // 14138: }
8156 // 14138: } // switch Inst[14:12]
8157 // 14138: }
8158 32, 51, // 14142: case 0x20: {
8159 OPC_SwitchField, 20, 5, // 14144: switch Inst[24:20] {
8160 1, 6, // 14147: case 0x1: {
8161 OPC_CheckPredicate, 25, // 14149: check predicate 25
8162 OPC_Decode, 175, 114, 72, // 14151: decode to FCVT_S_D using decoder 72
8163 // 14151: }
8164 2, 6, // 14155: case 0x2: {
8165 OPC_CheckPredicate, 84, // 14157: check predicate 84
8166 OPC_Decode, 178, 114, 73, // 14159: decode to FCVT_S_H using decoder 73
8167 // 14159: }
8168 3, 6, // 14163: case 0x3: {
8169 OPC_CheckPredicate, 26, // 14165: check predicate 26
8170 OPC_Decode, 184, 114, 74, // 14167: decode to FCVT_S_Q using decoder 74
8171 // 14167: }
8172 4, 6, // 14171: case 0x4: {
8173 OPC_CheckPredicate, 80, // 14173: check predicate 80
8174 OPC_Decode, 210, 115, 75, // 14175: decode to FROUND_S using decoder 75
8175 // 14175: }
8176 5, 6, // 14179: case 0x5: {
8177 OPC_CheckPredicate, 80, // 14181: check predicate 80
8178 OPC_Decode, 206, 115, 75, // 14183: decode to FROUNDNX_S using decoder 75
8179 // 14183: }
8180 6, 0, // 14187: case 0x6: {
8181 OPC_CheckPredicate, 85, // 14189: check predicate 85
8182 OPC_Decode, 174, 114, 73, // 14191: decode to FCVT_S_BF16 using decoder 73
8183 // 14191: }
8184 // 14191: } // switch Inst[24:20]
8185 // 14191: }
8186 33, 43, // 14195: case 0x21: {
8187 OPC_SwitchField, 20, 5, // 14197: switch Inst[24:20] {
8188 0, 6, // 14200: case 0x0: {
8189 OPC_CheckPredicate, 25, // 14202: check predicate 25
8190 OPC_Decode, 132, 114, 76, // 14204: decode to FCVT_D_S using decoder 76
8191 // 14204: }
8192 2, 6, // 14208: case 0x2: {
8193 OPC_CheckPredicate, 86, // 14210: check predicate 86
8194 OPC_Decode, 252, 113, 77, // 14212: decode to FCVT_D_H using decoder 77
8195 // 14212: }
8196 3, 6, // 14216: case 0x3: {
8197 OPC_CheckPredicate, 26, // 14218: check predicate 26
8198 OPC_Decode, 131, 114, 78, // 14220: decode to FCVT_D_Q using decoder 78
8199 // 14220: }
8200 4, 6, // 14224: case 0x4: {
8201 OPC_CheckPredicate, 81, // 14226: check predicate 81
8202 OPC_Decode, 207, 115, 79, // 14228: decode to FROUND_D using decoder 79
8203 // 14228: }
8204 5, 0, // 14232: case 0x5: {
8205 OPC_CheckPredicate, 81, // 14234: check predicate 81
8206 OPC_Decode, 203, 115, 79, // 14236: decode to FROUNDNX_D using decoder 79
8207 // 14236: }
8208 // 14236: } // switch Inst[24:20]
8209 // 14236: }
8210 34, 43, // 14240: case 0x22: {
8211 OPC_SwitchField, 20, 5, // 14242: switch Inst[24:20] {
8212 0, 6, // 14245: case 0x0: {
8213 OPC_CheckPredicate, 84, // 14247: check predicate 84
8214 OPC_Decode, 148, 114, 80, // 14249: decode to FCVT_H_S using decoder 80
8215 // 14249: }
8216 1, 6, // 14253: case 0x1: {
8217 OPC_CheckPredicate, 86, // 14255: check predicate 86
8218 OPC_Decode, 141, 114, 81, // 14257: decode to FCVT_H_D using decoder 81
8219 // 14257: }
8220 4, 6, // 14261: case 0x4: {
8221 OPC_CheckPredicate, 82, // 14263: check predicate 82
8222 OPC_Decode, 208, 115, 82, // 14265: decode to FROUND_H using decoder 82
8223 // 14265: }
8224 5, 6, // 14269: case 0x5: {
8225 OPC_CheckPredicate, 82, // 14271: check predicate 82
8226 OPC_Decode, 204, 115, 82, // 14273: decode to FROUNDNX_H using decoder 82
8227 // 14273: }
8228 8, 0, // 14277: case 0x8: {
8229 OPC_CheckPredicate, 85, // 14279: check predicate 85
8230 OPC_Decode, 251, 113, 80, // 14281: decode to FCVT_BF16_S using decoder 80
8231 // 14281: }
8232 // 14281: } // switch Inst[24:20]
8233 // 14281: }
8234 35, 35, // 14285: case 0x23: {
8235 OPC_SwitchField, 20, 5, // 14287: switch Inst[24:20] {
8236 0, 6, // 14290: case 0x0: {
8237 OPC_CheckPredicate, 26, // 14292: check predicate 26
8238 OPC_Decode, 171, 114, 83, // 14294: decode to FCVT_Q_S using decoder 83
8239 // 14294: }
8240 1, 6, // 14298: case 0x1: {
8241 OPC_CheckPredicate, 26, // 14300: check predicate 26
8242 OPC_Decode, 168, 114, 84, // 14302: decode to FCVT_Q_D using decoder 84
8243 // 14302: }
8244 4, 6, // 14306: case 0x4: {
8245 OPC_CheckPredicate, 83, // 14308: check predicate 83
8246 OPC_Decode, 209, 115, 85, // 14310: decode to FROUND_Q using decoder 85
8247 // 14310: }
8248 5, 0, // 14314: case 0x5: {
8249 OPC_CheckPredicate, 83, // 14316: check predicate 83
8250 OPC_Decode, 205, 115, 85, // 14318: decode to FROUNDNX_Q using decoder 85
8251 // 14318: }
8252 // 14318: } // switch Inst[24:20]
8253 // 14318: }
8254 44, 10, // 14322: case 0x2c: {
8255 OPC_CheckPredicate, 24, // 14324: check predicate 24
8256 OPC_CheckField, 20, 5, 0, // 14326: check Inst[24:20] == 0x0
8257 OPC_Decode, 244, 115, 75, // 14330: decode to FSQRT_S using decoder 75
8258 // 14330: }
8259 45, 10, // 14334: case 0x2d: {
8260 OPC_CheckPredicate, 25, // 14336: check predicate 25
8261 OPC_CheckField, 20, 5, 0, // 14338: check Inst[24:20] == 0x0
8262 OPC_Decode, 238, 115, 79, // 14342: decode to FSQRT_D using decoder 79
8263 // 14342: }
8264 46, 10, // 14346: case 0x2e: {
8265 OPC_CheckPredicate, 79, // 14348: check predicate 79
8266 OPC_CheckField, 20, 5, 0, // 14350: check Inst[24:20] == 0x0
8267 OPC_Decode, 241, 115, 82, // 14354: decode to FSQRT_H using decoder 82
8268 // 14354: }
8269 47, 10, // 14358: case 0x2f: {
8270 OPC_CheckPredicate, 26, // 14360: check predicate 26
8271 OPC_CheckField, 20, 5, 0, // 14362: check Inst[24:20] == 0x0
8272 OPC_Decode, 243, 115, 85, // 14366: decode to FSQRT_Q using decoder 85
8273 // 14366: }
8274 80, 43, // 14370: case 0x50: {
8275 OPC_SwitchField, 12, 3, // 14372: switch Inst[14:12] {
8276 0, 6, // 14375: case 0x0: {
8277 OPC_CheckPredicate, 24, // 14377: check predicate 24
8278 OPC_Decode, 235, 114, 86, // 14379: decode to FLE_S using decoder 86
8279 // 14379: }
8280 1, 6, // 14383: case 0x1: {
8281 OPC_CheckPredicate, 24, // 14385: check predicate 24
8282 OPC_Decode, 253, 114, 86, // 14387: decode to FLT_S using decoder 86
8283 // 14387: }
8284 2, 6, // 14391: case 0x2: {
8285 OPC_CheckPredicate, 24, // 14393: check predicate 24
8286 OPC_Decode, 222, 114, 86, // 14395: decode to FEQ_S using decoder 86
8287 // 14395: }
8288 4, 6, // 14399: case 0x4: {
8289 OPC_CheckPredicate, 80, // 14401: check predicate 80
8290 OPC_Decode, 228, 114, 86, // 14403: decode to FLEQ_S using decoder 86
8291 // 14403: }
8292 5, 0, // 14407: case 0x5: {
8293 OPC_CheckPredicate, 80, // 14409: check predicate 80
8294 OPC_Decode, 246, 114, 86, // 14411: decode to FLTQ_S using decoder 86
8295 // 14411: }
8296 // 14411: } // switch Inst[14:12]
8297 // 14411: }
8298 81, 43, // 14415: case 0x51: {
8299 OPC_SwitchField, 12, 3, // 14417: switch Inst[14:12] {
8300 0, 6, // 14420: case 0x0: {
8301 OPC_CheckPredicate, 25, // 14422: check predicate 25
8302 OPC_Decode, 229, 114, 87, // 14424: decode to FLE_D using decoder 87
8303 // 14424: }
8304 1, 6, // 14428: case 0x1: {
8305 OPC_CheckPredicate, 25, // 14430: check predicate 25
8306 OPC_Decode, 247, 114, 87, // 14432: decode to FLT_D using decoder 87
8307 // 14432: }
8308 2, 6, // 14436: case 0x2: {
8309 OPC_CheckPredicate, 25, // 14438: check predicate 25
8310 OPC_Decode, 216, 114, 87, // 14440: decode to FEQ_D using decoder 87
8311 // 14440: }
8312 4, 6, // 14444: case 0x4: {
8313 OPC_CheckPredicate, 81, // 14446: check predicate 81
8314 OPC_Decode, 225, 114, 87, // 14448: decode to FLEQ_D using decoder 87
8315 // 14448: }
8316 5, 0, // 14452: case 0x5: {
8317 OPC_CheckPredicate, 81, // 14454: check predicate 81
8318 OPC_Decode, 243, 114, 87, // 14456: decode to FLTQ_D using decoder 87
8319 // 14456: }
8320 // 14456: } // switch Inst[14:12]
8321 // 14456: }
8322 82, 43, // 14460: case 0x52: {
8323 OPC_SwitchField, 12, 3, // 14462: switch Inst[14:12] {
8324 0, 6, // 14465: case 0x0: {
8325 OPC_CheckPredicate, 79, // 14467: check predicate 79
8326 OPC_Decode, 232, 114, 88, // 14469: decode to FLE_H using decoder 88
8327 // 14469: }
8328 1, 6, // 14473: case 0x1: {
8329 OPC_CheckPredicate, 79, // 14475: check predicate 79
8330 OPC_Decode, 250, 114, 88, // 14477: decode to FLT_H using decoder 88
8331 // 14477: }
8332 2, 6, // 14481: case 0x2: {
8333 OPC_CheckPredicate, 79, // 14483: check predicate 79
8334 OPC_Decode, 219, 114, 88, // 14485: decode to FEQ_H using decoder 88
8335 // 14485: }
8336 4, 6, // 14489: case 0x4: {
8337 OPC_CheckPredicate, 82, // 14491: check predicate 82
8338 OPC_Decode, 226, 114, 88, // 14493: decode to FLEQ_H using decoder 88
8339 // 14493: }
8340 5, 0, // 14497: case 0x5: {
8341 OPC_CheckPredicate, 82, // 14499: check predicate 82
8342 OPC_Decode, 244, 114, 88, // 14501: decode to FLTQ_H using decoder 88
8343 // 14501: }
8344 // 14501: } // switch Inst[14:12]
8345 // 14501: }
8346 83, 43, // 14505: case 0x53: {
8347 OPC_SwitchField, 12, 3, // 14507: switch Inst[14:12] {
8348 0, 6, // 14510: case 0x0: {
8349 OPC_CheckPredicate, 26, // 14512: check predicate 26
8350 OPC_Decode, 234, 114, 89, // 14514: decode to FLE_Q using decoder 89
8351 // 14514: }
8352 1, 6, // 14518: case 0x1: {
8353 OPC_CheckPredicate, 26, // 14520: check predicate 26
8354 OPC_Decode, 252, 114, 89, // 14522: decode to FLT_Q using decoder 89
8355 // 14522: }
8356 2, 6, // 14526: case 0x2: {
8357 OPC_CheckPredicate, 26, // 14528: check predicate 26
8358 OPC_Decode, 221, 114, 89, // 14530: decode to FEQ_Q using decoder 89
8359 // 14530: }
8360 4, 6, // 14534: case 0x4: {
8361 OPC_CheckPredicate, 83, // 14536: check predicate 83
8362 OPC_Decode, 227, 114, 89, // 14538: decode to FLEQ_Q using decoder 89
8363 // 14538: }
8364 5, 0, // 14542: case 0x5: {
8365 OPC_CheckPredicate, 83, // 14544: check predicate 83
8366 OPC_Decode, 245, 114, 89, // 14546: decode to FLTQ_Q using decoder 89
8367 // 14546: }
8368 // 14546: } // switch Inst[14:12]
8369 // 14546: }
8370 89, 10, // 14550: case 0x59: {
8371 OPC_CheckPredicate, 87, // 14552: check predicate 87
8372 OPC_CheckField, 12, 3, 0, // 14554: check Inst[14:12] == 0x0
8373 OPC_Decode, 178, 115, 90, // 14558: decode to FMVP_D_X using decoder 90
8374 // 14558: }
8375 91, 10, // 14562: case 0x5b: {
8376 OPC_CheckPredicate, 88, // 14564: check predicate 88
8377 OPC_CheckField, 12, 3, 0, // 14566: check Inst[14:12] == 0x0
8378 OPC_Decode, 179, 115, 91, // 14570: decode to FMVP_Q_X using decoder 91
8379 // 14570: }
8380 96, 35, // 14574: case 0x60: {
8381 OPC_SwitchField, 20, 5, // 14576: switch Inst[24:20] {
8382 0, 6, // 14579: case 0x0: {
8383 OPC_CheckPredicate, 24, // 14581: check predicate 24
8384 OPC_Decode, 203, 114, 92, // 14583: decode to FCVT_W_S using decoder 92
8385 // 14583: }
8386 1, 6, // 14587: case 0x1: {
8387 OPC_CheckPredicate, 24, // 14589: check predicate 24
8388 OPC_Decode, 195, 114, 92, // 14591: decode to FCVT_WU_S using decoder 92
8389 // 14591: }
8390 2, 6, // 14595: case 0x2: {
8391 OPC_CheckPredicate, 89, // 14597: check predicate 89
8392 OPC_Decode, 166, 114, 92, // 14599: decode to FCVT_L_S using decoder 92
8393 // 14599: }
8394 3, 0, // 14603: case 0x3: {
8395 OPC_CheckPredicate, 89, // 14605: check predicate 89
8396 OPC_Decode, 159, 114, 92, // 14607: decode to FCVT_LU_S using decoder 92
8397 // 14607: }
8398 // 14607: } // switch Inst[24:20]
8399 // 14607: }
8400 97, 47, // 14611: case 0x61: {
8401 OPC_SwitchField, 20, 5, // 14613: switch Inst[24:20] {
8402 0, 6, // 14616: case 0x0: {
8403 OPC_CheckPredicate, 25, // 14618: check predicate 25
8404 OPC_Decode, 197, 114, 93, // 14620: decode to FCVT_W_D using decoder 93
8405 // 14620: }
8406 1, 6, // 14624: case 0x1: {
8407 OPC_CheckPredicate, 25, // 14626: check predicate 25
8408 OPC_Decode, 189, 114, 93, // 14628: decode to FCVT_WU_D using decoder 93
8409 // 14628: }
8410 2, 6, // 14632: case 0x2: {
8411 OPC_CheckPredicate, 90, // 14634: check predicate 90
8412 OPC_Decode, 161, 114, 93, // 14636: decode to FCVT_L_D using decoder 93
8413 // 14636: }
8414 3, 6, // 14640: case 0x3: {
8415 OPC_CheckPredicate, 90, // 14642: check predicate 90
8416 OPC_Decode, 154, 114, 93, // 14644: decode to FCVT_LU_D using decoder 93
8417 // 14644: }
8418 8, 0, // 14648: case 0x8: {
8419 OPC_CheckPredicate, 81, // 14650: check predicate 81
8420 OPC_CheckField, 12, 3, 1, // 14652: check Inst[14:12] == 0x1
8421 OPC_Decode, 250, 113, 94, // 14656: decode to FCVTMOD_W_D using decoder 94
8422 // 14656: }
8423 // 14656: } // switch Inst[24:20]
8424 // 14656: }
8425 98, 35, // 14660: case 0x62: {
8426 OPC_SwitchField, 20, 5, // 14662: switch Inst[24:20] {
8427 0, 6, // 14665: case 0x0: {
8428 OPC_CheckPredicate, 79, // 14667: check predicate 79
8429 OPC_Decode, 200, 114, 95, // 14669: decode to FCVT_W_H using decoder 95
8430 // 14669: }
8431 1, 6, // 14673: case 0x1: {
8432 OPC_CheckPredicate, 79, // 14675: check predicate 79
8433 OPC_Decode, 192, 114, 95, // 14677: decode to FCVT_WU_H using decoder 95
8434 // 14677: }
8435 2, 6, // 14681: case 0x2: {
8436 OPC_CheckPredicate, 91, // 14683: check predicate 91
8437 OPC_Decode, 163, 114, 95, // 14685: decode to FCVT_L_H using decoder 95
8438 // 14685: }
8439 3, 0, // 14689: case 0x3: {
8440 OPC_CheckPredicate, 91, // 14691: check predicate 91
8441 OPC_Decode, 156, 114, 95, // 14693: decode to FCVT_LU_H using decoder 95
8442 // 14693: }
8443 // 14693: } // switch Inst[24:20]
8444 // 14693: }
8445 99, 35, // 14697: case 0x63: {
8446 OPC_SwitchField, 20, 5, // 14699: switch Inst[24:20] {
8447 0, 6, // 14702: case 0x0: {
8448 OPC_CheckPredicate, 26, // 14704: check predicate 26
8449 OPC_Decode, 202, 114, 96, // 14706: decode to FCVT_W_Q using decoder 96
8450 // 14706: }
8451 1, 6, // 14710: case 0x1: {
8452 OPC_CheckPredicate, 26, // 14712: check predicate 26
8453 OPC_Decode, 194, 114, 96, // 14714: decode to FCVT_WU_Q using decoder 96
8454 // 14714: }
8455 2, 6, // 14718: case 0x2: {
8456 OPC_CheckPredicate, 92, // 14720: check predicate 92
8457 OPC_Decode, 165, 114, 96, // 14722: decode to FCVT_L_Q using decoder 96
8458 // 14722: }
8459 3, 0, // 14726: case 0x3: {
8460 OPC_CheckPredicate, 92, // 14728: check predicate 92
8461 OPC_Decode, 158, 114, 96, // 14730: decode to FCVT_LU_Q using decoder 96
8462 // 14730: }
8463 // 14730: } // switch Inst[24:20]
8464 // 14730: }
8465 104, 35, // 14734: case 0x68: {
8466 OPC_SwitchField, 20, 5, // 14736: switch Inst[24:20] {
8467 0, 6, // 14739: case 0x0: {
8468 OPC_CheckPredicate, 24, // 14741: check predicate 24
8469 OPC_Decode, 185, 114, 97, // 14743: decode to FCVT_S_W using decoder 97
8470 // 14743: }
8471 1, 6, // 14747: case 0x1: {
8472 OPC_CheckPredicate, 24, // 14749: check predicate 24
8473 OPC_Decode, 186, 114, 97, // 14751: decode to FCVT_S_WU using decoder 97
8474 // 14751: }
8475 2, 6, // 14755: case 0x2: {
8476 OPC_CheckPredicate, 89, // 14757: check predicate 89
8477 OPC_Decode, 180, 114, 97, // 14759: decode to FCVT_S_L using decoder 97
8478 // 14759: }
8479 3, 0, // 14763: case 0x3: {
8480 OPC_CheckPredicate, 89, // 14765: check predicate 89
8481 OPC_Decode, 181, 114, 97, // 14767: decode to FCVT_S_LU using decoder 97
8482 // 14767: }
8483 // 14767: } // switch Inst[24:20]
8484 // 14767: }
8485 105, 35, // 14771: case 0x69: {
8486 OPC_SwitchField, 20, 5, // 14773: switch Inst[24:20] {
8487 0, 6, // 14776: case 0x0: {
8488 OPC_CheckPredicate, 25, // 14778: check predicate 25
8489 OPC_Decode, 135, 114, 98, // 14780: decode to FCVT_D_W using decoder 98
8490 // 14780: }
8491 1, 6, // 14784: case 0x1: {
8492 OPC_CheckPredicate, 25, // 14786: check predicate 25
8493 OPC_Decode, 136, 114, 98, // 14788: decode to FCVT_D_WU using decoder 98
8494 // 14788: }
8495 2, 6, // 14792: case 0x2: {
8496 OPC_CheckPredicate, 90, // 14794: check predicate 90
8497 OPC_Decode, 255, 113, 98, // 14796: decode to FCVT_D_L using decoder 98
8498 // 14796: }
8499 3, 0, // 14800: case 0x3: {
8500 OPC_CheckPredicate, 90, // 14802: check predicate 90
8501 OPC_Decode, 128, 114, 98, // 14804: decode to FCVT_D_LU using decoder 98
8502 // 14804: }
8503 // 14804: } // switch Inst[24:20]
8504 // 14804: }
8505 106, 35, // 14808: case 0x6a: {
8506 OPC_SwitchField, 20, 5, // 14810: switch Inst[24:20] {
8507 0, 6, // 14813: case 0x0: {
8508 OPC_CheckPredicate, 79, // 14815: check predicate 79
8509 OPC_Decode, 150, 114, 99, // 14817: decode to FCVT_H_W using decoder 99
8510 // 14817: }
8511 1, 6, // 14821: case 0x1: {
8512 OPC_CheckPredicate, 79, // 14823: check predicate 79
8513 OPC_Decode, 151, 114, 99, // 14825: decode to FCVT_H_WU using decoder 99
8514 // 14825: }
8515 2, 6, // 14829: case 0x2: {
8516 OPC_CheckPredicate, 91, // 14831: check predicate 91
8517 OPC_Decode, 144, 114, 99, // 14833: decode to FCVT_H_L using decoder 99
8518 // 14833: }
8519 3, 0, // 14837: case 0x3: {
8520 OPC_CheckPredicate, 91, // 14839: check predicate 91
8521 OPC_Decode, 145, 114, 99, // 14841: decode to FCVT_H_LU using decoder 99
8522 // 14841: }
8523 // 14841: } // switch Inst[24:20]
8524 // 14841: }
8525 107, 35, // 14845: case 0x6b: {
8526 OPC_SwitchField, 20, 5, // 14847: switch Inst[24:20] {
8527 0, 6, // 14850: case 0x0: {
8528 OPC_CheckPredicate, 26, // 14852: check predicate 26
8529 OPC_Decode, 172, 114, 100, // 14854: decode to FCVT_Q_W using decoder 100
8530 // 14854: }
8531 1, 6, // 14858: case 0x1: {
8532 OPC_CheckPredicate, 26, // 14860: check predicate 26
8533 OPC_Decode, 173, 114, 100, // 14862: decode to FCVT_Q_WU using decoder 100
8534 // 14862: }
8535 2, 6, // 14866: case 0x2: {
8536 OPC_CheckPredicate, 92, // 14868: check predicate 92
8537 OPC_Decode, 169, 114, 100, // 14870: decode to FCVT_Q_L using decoder 100
8538 // 14870: }
8539 3, 0, // 14874: case 0x3: {
8540 OPC_CheckPredicate, 92, // 14876: check predicate 92
8541 OPC_Decode, 170, 114, 100, // 14878: decode to FCVT_Q_LU using decoder 100
8542 // 14878: }
8543 // 14878: } // switch Inst[24:20]
8544 // 14878: }
8545 112, 27, // 14882: case 0x70: {
8546 OPC_SwitchField, 12, 3, // 14884: switch Inst[14:12] {
8547 0, 10, // 14887: case 0x0: {
8548 OPC_CheckPredicate, 24, // 14889: check predicate 24
8549 OPC_CheckField, 20, 5, 0, // 14891: check Inst[24:20] == 0x0
8550 OPC_Decode, 185, 115, 101, // 14895: decode to FMV_X_W using decoder 101
8551 // 14895: }
8552 1, 0, // 14899: case 0x1: {
8553 OPC_CheckPredicate, 24, // 14901: check predicate 24
8554 OPC_CheckField, 20, 5, 0, // 14903: check Inst[24:20] == 0x0
8555 OPC_Decode, 248, 113, 101, // 14907: decode to FCLASS_S using decoder 101
8556 // 14907: }
8557 // 14907: } // switch Inst[14:12]
8558 // 14907: }
8559 113, 36, // 14911: case 0x71: {
8560 OPC_SwitchField, 12, 3, // 14913: switch Inst[14:12] {
8561 0, 19, // 14916: case 0x0: {
8562 OPC_SwitchField, 20, 5, // 14918: switch Inst[24:20] {
8563 0, 6, // 14921: case 0x0: {
8564 OPC_CheckPredicate, 90, // 14923: check predicate 90
8565 OPC_Decode, 183, 115, 102, // 14925: decode to FMV_X_D using decoder 102
8566 // 14925: }
8567 1, 0, // 14929: case 0x1: {
8568 OPC_CheckPredicate, 87, // 14931: check predicate 87
8569 OPC_Decode, 176, 115, 102, // 14933: decode to FMVH_X_D using decoder 102
8570 // 14933: }
8571 // 14933: } // switch Inst[24:20]
8572 // 14933: }
8573 1, 0, // 14937: case 0x1: {
8574 OPC_CheckPredicate, 25, // 14939: check predicate 25
8575 OPC_CheckField, 20, 5, 0, // 14941: check Inst[24:20] == 0x0
8576 OPC_Decode, 242, 113, 102, // 14945: decode to FCLASS_D using decoder 102
8577 // 14945: }
8578 // 14945: } // switch Inst[14:12]
8579 // 14945: }
8580 114, 27, // 14949: case 0x72: {
8581 OPC_SwitchField, 12, 3, // 14951: switch Inst[14:12] {
8582 0, 10, // 14954: case 0x0: {
8583 OPC_CheckPredicate, 23, // 14956: check predicate 23
8584 OPC_CheckField, 20, 5, 0, // 14958: check Inst[24:20] == 0x0
8585 OPC_Decode, 184, 115, 103, // 14962: decode to FMV_X_H using decoder 103
8586 // 14962: }
8587 1, 0, // 14966: case 0x1: {
8588 OPC_CheckPredicate, 79, // 14968: check predicate 79
8589 OPC_CheckField, 20, 5, 0, // 14970: check Inst[24:20] == 0x0
8590 OPC_Decode, 245, 113, 103, // 14974: decode to FCLASS_H using decoder 103
8591 // 14974: }
8592 // 14974: } // switch Inst[14:12]
8593 // 14974: }
8594 115, 27, // 14978: case 0x73: {
8595 OPC_SwitchField, 12, 3, // 14980: switch Inst[14:12] {
8596 0, 10, // 14983: case 0x0: {
8597 OPC_CheckPredicate, 88, // 14985: check predicate 88
8598 OPC_CheckField, 20, 5, 1, // 14987: check Inst[24:20] == 0x1
8599 OPC_Decode, 177, 115, 104, // 14991: decode to FMVH_X_Q using decoder 104
8600 // 14991: }
8601 1, 0, // 14995: case 0x1: {
8602 OPC_CheckPredicate, 26, // 14997: check predicate 26
8603 OPC_CheckField, 20, 5, 0, // 14999: check Inst[24:20] == 0x0
8604 OPC_Decode, 247, 113, 104, // 15003: decode to FCLASS_Q using decoder 104
8605 // 15003: }
8606 // 15003: } // switch Inst[14:12]
8607 // 15003: }
8608 120, 27, // 15007: case 0x78: {
8609 OPC_SwitchField, 20, 5, // 15009: switch Inst[24:20] {
8610 0, 10, // 15012: case 0x0: {
8611 OPC_CheckPredicate, 24, // 15014: check predicate 24
8612 OPC_CheckField, 12, 3, 0, // 15016: check Inst[14:12] == 0x0
8613 OPC_Decode, 182, 115, 105, // 15020: decode to FMV_W_X using decoder 105
8614 // 15020: }
8615 1, 0, // 15024: case 0x1: {
8616 OPC_CheckPredicate, 80, // 15026: check predicate 80
8617 OPC_CheckField, 12, 3, 0, // 15028: check Inst[14:12] == 0x0
8618 OPC_Decode, 241, 114, 106, // 15032: decode to FLI_S using decoder 106
8619 // 15032: }
8620 // 15032: } // switch Inst[24:20]
8621 // 15032: }
8622 121, 27, // 15036: case 0x79: {
8623 OPC_SwitchField, 20, 5, // 15038: switch Inst[24:20] {
8624 0, 10, // 15041: case 0x0: {
8625 OPC_CheckPredicate, 90, // 15043: check predicate 90
8626 OPC_CheckField, 12, 3, 0, // 15045: check Inst[14:12] == 0x0
8627 OPC_Decode, 180, 115, 107, // 15049: decode to FMV_D_X using decoder 107
8628 // 15049: }
8629 1, 0, // 15053: case 0x1: {
8630 OPC_CheckPredicate, 81, // 15055: check predicate 81
8631 OPC_CheckField, 12, 3, 0, // 15057: check Inst[14:12] == 0x0
8632 OPC_Decode, 238, 114, 108, // 15061: decode to FLI_D using decoder 108
8633 // 15061: }
8634 // 15061: } // switch Inst[24:20]
8635 // 15061: }
8636 122, 27, // 15065: case 0x7a: {
8637 OPC_SwitchField, 20, 5, // 15067: switch Inst[24:20] {
8638 0, 10, // 15070: case 0x0: {
8639 OPC_CheckPredicate, 23, // 15072: check predicate 23
8640 OPC_CheckField, 12, 3, 0, // 15074: check Inst[14:12] == 0x0
8641 OPC_Decode, 181, 115, 109, // 15078: decode to FMV_H_X using decoder 109
8642 // 15078: }
8643 1, 0, // 15082: case 0x1: {
8644 OPC_CheckPredicate, 93, // 15084: check predicate 93
8645 OPC_CheckField, 12, 3, 0, // 15086: check Inst[14:12] == 0x0
8646 OPC_Decode, 239, 114, 110, // 15090: decode to FLI_H using decoder 110
8647 // 15090: }
8648 // 15090: } // switch Inst[24:20]
8649 // 15090: }
8650 123, 0, // 15094: case 0x7b: {
8651 OPC_CheckPredicate, 83, // 15096: check predicate 83
8652 OPC_CheckField, 20, 5, 1, // 15098: check Inst[24:20] == 0x1
8653 OPC_CheckField, 12, 3, 0, // 15102: check Inst[14:12] == 0x0
8654 OPC_Decode, 240, 114, 111, // 15106: decode to FLI_Q using decoder 111
8655 // 15106: }
8656 // 15106: } // switch Inst[31:25]
8657 // 15106: }
8658 87, 254, 28, // 15110: case 0x57: {
8659 OPC_SwitchField, 12, 3, // 15113: switch Inst[14:12] {
8660 0, 134, 4, // 15116: case 0x0: {
8661 OPC_SwitchField, 26, 6, // 15119: switch Inst[31:26] {
8662 0, 6, // 15122: case 0x0: {
8663 OPC_CheckPredicate, 22, // 15124: check predicate 22
8664 OPC_Decode, 210, 125, 112, // 15126: decode to VADD_VV using decoder 112
8665 // 15126: }
8666 1, 6, // 15130: case 0x1: {
8667 OPC_CheckPredicate, 94, // 15132: check predicate 94
8668 OPC_Decode, 223, 125, 112, // 15134: decode to VANDN_VV using decoder 112
8669 // 15134: }
8670 2, 7, // 15138: case 0x2: {
8671 OPC_CheckPredicate, 22, // 15140: check predicate 22
8672 OPC_Decode, 234, 130, 1, 112, // 15142: decode to VSUB_VV using decoder 112
8673 // 15142: }
8674 4, 7, // 15147: case 0x4: {
8675 OPC_CheckPredicate, 22, // 15149: check predicate 22
8676 OPC_Decode, 226, 128, 1, 112, // 15151: decode to VMINU_VV using decoder 112
8677 // 15151: }
8678 5, 7, // 15156: case 0x5: {
8679 OPC_CheckPredicate, 22, // 15158: check predicate 22
8680 OPC_Decode, 228, 128, 1, 112, // 15160: decode to VMIN_VV using decoder 112
8681 // 15160: }
8682 6, 7, // 15165: case 0x6: {
8683 OPC_CheckPredicate, 22, // 15167: check predicate 22
8684 OPC_Decode, 209, 128, 1, 112, // 15169: decode to VMAXU_VV using decoder 112
8685 // 15169: }
8686 7, 7, // 15174: case 0x7: {
8687 OPC_CheckPredicate, 22, // 15176: check predicate 22
8688 OPC_Decode, 211, 128, 1, 112, // 15178: decode to VMAX_VV using decoder 112
8689 // 15178: }
8690 9, 6, // 15183: case 0x9: {
8691 OPC_CheckPredicate, 22, // 15185: check predicate 22
8692 OPC_Decode, 226, 125, 112, // 15187: decode to VAND_VV using decoder 112
8693 // 15187: }
8694 10, 7, // 15191: case 0xa: {
8695 OPC_CheckPredicate, 22, // 15193: check predicate 22
8696 OPC_Decode, 178, 129, 1, 112, // 15195: decode to VOR_VV using decoder 112
8697 // 15195: }
8698 11, 7, // 15200: case 0xb: {
8699 OPC_CheckPredicate, 22, // 15202: check predicate 22
8700 OPC_Decode, 183, 131, 1, 112, // 15204: decode to VXOR_VV using decoder 112
8701 // 15204: }
8702 12, 7, // 15209: case 0xc: {
8703 OPC_CheckPredicate, 22, // 15211: check predicate 22
8704 OPC_Decode, 203, 129, 1, 112, // 15213: decode to VRGATHER_VV using decoder 112
8705 // 15213: }
8706 14, 7, // 15218: case 0xe: {
8707 OPC_CheckPredicate, 22, // 15220: check predicate 22
8708 OPC_Decode, 201, 129, 1, 112, // 15222: decode to VRGATHEREI16_VV using decoder 112
8709 // 15222: }
8710 15, 7, // 15227: case 0xf: {
8711 OPC_CheckPredicate, 95, // 15229: check predicate 95
8712 OPC_Decode, 181, 129, 1, 112, // 15231: decode to VPAIRE_VV using decoder 112
8713 // 15231: }
8714 16, 10, // 15236: case 0x10: {
8715 OPC_CheckPredicate, 22, // 15238: check predicate 22
8716 OPC_CheckField, 25, 1, 0, // 15240: check Inst[25] == 0x0
8717 OPC_Decode, 207, 125, 113, // 15244: decode to VADC_VVM using decoder 113
8718 // 15244: }
8719 17, 21, // 15248: case 0x11: {
8720 OPC_SwitchField, 25, 1, // 15250: switch Inst[25] {
8721 0, 7, // 15253: case 0x0: {
8722 OPC_CheckPredicate, 22, // 15255: check predicate 22
8723 OPC_Decode, 178, 128, 1, 113, // 15257: decode to VMADC_VVM using decoder 113
8724 // 15257: }
8725 1, 0, // 15262: case 0x1: {
8726 OPC_CheckPredicate, 22, // 15264: check predicate 22
8727 OPC_Decode, 177, 128, 1, 114, // 15266: decode to VMADC_VV using decoder 114
8728 // 15266: }
8729 // 15266: } // switch Inst[25]
8730 // 15266: }
8731 18, 11, // 15271: case 0x12: {
8732 OPC_CheckPredicate, 22, // 15273: check predicate 22
8733 OPC_CheckField, 25, 1, 0, // 15275: check Inst[25] == 0x0
8734 OPC_Decode, 222, 129, 1, 113, // 15279: decode to VSBC_VVM using decoder 113
8735 // 15279: }
8736 19, 21, // 15284: case 0x13: {
8737 OPC_SwitchField, 25, 1, // 15286: switch Inst[25] {
8738 0, 7, // 15289: case 0x0: {
8739 OPC_CheckPredicate, 22, // 15291: check predicate 22
8740 OPC_Decode, 236, 128, 1, 113, // 15293: decode to VMSBC_VVM using decoder 113
8741 // 15293: }
8742 1, 0, // 15298: case 0x1: {
8743 OPC_CheckPredicate, 22, // 15300: check predicate 22
8744 OPC_Decode, 235, 128, 1, 114, // 15302: decode to VMSBC_VV using decoder 114
8745 // 15302: }
8746 // 15302: } // switch Inst[25]
8747 // 15302: }
8748 20, 7, // 15307: case 0x14: {
8749 OPC_CheckPredicate, 94, // 15309: check predicate 94
8750 OPC_Decode, 208, 129, 1, 112, // 15311: decode to VROR_VV using decoder 112
8751 // 15311: }
8752 21, 7, // 15316: case 0x15: {
8753 OPC_CheckPredicate, 94, // 15318: check predicate 94
8754 OPC_Decode, 205, 129, 1, 112, // 15320: decode to VROL_VV using decoder 112
8755 // 15320: }
8756 23, 25, // 15325: case 0x17: {
8757 OPC_SwitchField, 25, 1, // 15327: switch Inst[25] {
8758 0, 7, // 15330: case 0x0: {
8759 OPC_CheckPredicate, 22, // 15332: check predicate 22
8760 OPC_Decode, 214, 128, 1, 113, // 15334: decode to VMERGE_VVM using decoder 113
8761 // 15334: }
8762 1, 0, // 15339: case 0x1: {
8763 OPC_CheckPredicate, 22, // 15341: check predicate 22
8764 OPC_CheckField, 20, 5, 0, // 15343: check Inst[24:20] == 0x0
8765 OPC_Decode, 152, 129, 1, 115, // 15347: decode to VMV_V_V using decoder 115
8766 // 15347: }
8767 // 15347: } // switch Inst[25]
8768 // 15347: }
8769 24, 7, // 15352: case 0x18: {
8770 OPC_CheckPredicate, 22, // 15354: check predicate 22
8771 OPC_Decode, 241, 128, 1, 112, // 15356: decode to VMSEQ_VV using decoder 112
8772 // 15356: }
8773 25, 7, // 15361: case 0x19: {
8774 OPC_CheckPredicate, 22, // 15363: check predicate 22
8775 OPC_Decode, 131, 129, 1, 112, // 15365: decode to VMSNE_VV using decoder 112
8776 // 15365: }
8777 26, 7, // 15370: case 0x1a: {
8778 OPC_CheckPredicate, 22, // 15372: check predicate 22
8779 OPC_Decode, 254, 128, 1, 112, // 15374: decode to VMSLTU_VV using decoder 112
8780 // 15374: }
8781 27, 7, // 15379: case 0x1b: {
8782 OPC_CheckPredicate, 22, // 15381: check predicate 22
8783 OPC_Decode, 128, 129, 1, 112, // 15383: decode to VMSLT_VV using decoder 112
8784 // 15383: }
8785 28, 7, // 15388: case 0x1c: {
8786 OPC_CheckPredicate, 22, // 15390: check predicate 22
8787 OPC_Decode, 249, 128, 1, 112, // 15392: decode to VMSLEU_VV using decoder 112
8788 // 15392: }
8789 29, 7, // 15397: case 0x1d: {
8790 OPC_CheckPredicate, 22, // 15399: check predicate 22
8791 OPC_Decode, 252, 128, 1, 112, // 15401: decode to VMSLE_VV using decoder 112
8792 // 15401: }
8793 32, 7, // 15406: case 0x20: {
8794 OPC_CheckPredicate, 22, // 15408: check predicate 22
8795 OPC_Decode, 217, 129, 1, 112, // 15410: decode to VSADDU_VV using decoder 112
8796 // 15410: }
8797 33, 7, // 15415: case 0x21: {
8798 OPC_CheckPredicate, 22, // 15417: check predicate 22
8799 OPC_Decode, 220, 129, 1, 112, // 15419: decode to VSADD_VV using decoder 112
8800 // 15419: }
8801 34, 7, // 15424: case 0x22: {
8802 OPC_CheckPredicate, 22, // 15426: check predicate 22
8803 OPC_Decode, 230, 130, 1, 112, // 15428: decode to VSSUBU_VV using decoder 112
8804 // 15428: }
8805 35, 7, // 15433: case 0x23: {
8806 OPC_CheckPredicate, 22, // 15435: check predicate 22
8807 OPC_Decode, 232, 130, 1, 112, // 15437: decode to VSSUB_VV using decoder 112
8808 // 15437: }
8809 37, 7, // 15442: case 0x25: {
8810 OPC_CheckPredicate, 22, // 15444: check predicate 22
8811 OPC_Decode, 244, 129, 1, 112, // 15446: decode to VSLL_VV using decoder 112
8812 // 15446: }
8813 39, 7, // 15451: case 0x27: {
8814 OPC_CheckPredicate, 22, // 15453: check predicate 22
8815 OPC_Decode, 251, 129, 1, 112, // 15455: decode to VSMUL_VV using decoder 112
8816 // 15455: }
8817 40, 7, // 15460: case 0x28: {
8818 OPC_CheckPredicate, 22, // 15462: check predicate 22
8819 OPC_Decode, 162, 130, 1, 112, // 15464: decode to VSRL_VV using decoder 112
8820 // 15464: }
8821 41, 7, // 15469: case 0x29: {
8822 OPC_CheckPredicate, 22, // 15471: check predicate 22
8823 OPC_Decode, 159, 130, 1, 112, // 15473: decode to VSRA_VV using decoder 112
8824 // 15473: }
8825 42, 7, // 15478: case 0x2a: {
8826 OPC_CheckPredicate, 22, // 15480: check predicate 22
8827 OPC_Decode, 200, 130, 1, 112, // 15482: decode to VSSRL_VV using decoder 112
8828 // 15482: }
8829 43, 7, // 15487: case 0x2b: {
8830 OPC_CheckPredicate, 22, // 15489: check predicate 22
8831 OPC_Decode, 197, 130, 1, 112, // 15491: decode to VSSRA_VV using decoder 112
8832 // 15491: }
8833 44, 7, // 15496: case 0x2c: {
8834 OPC_CheckPredicate, 22, // 15498: check predicate 22
8835 OPC_Decode, 175, 129, 1, 112, // 15500: decode to VNSRL_WV using decoder 112
8836 // 15500: }
8837 45, 7, // 15505: case 0x2d: {
8838 OPC_CheckPredicate, 22, // 15507: check predicate 22
8839 OPC_Decode, 172, 129, 1, 112, // 15509: decode to VNSRA_WV using decoder 112
8840 // 15509: }
8841 46, 7, // 15514: case 0x2e: {
8842 OPC_CheckPredicate, 22, // 15516: check predicate 22
8843 OPC_Decode, 158, 129, 1, 112, // 15518: decode to VNCLIPU_WV using decoder 112
8844 // 15518: }
8845 47, 7, // 15523: case 0x2f: {
8846 OPC_CheckPredicate, 22, // 15525: check predicate 22
8847 OPC_Decode, 161, 129, 1, 112, // 15527: decode to VNCLIP_WV using decoder 112
8848 // 15527: }
8849 48, 7, // 15532: case 0x30: {
8850 OPC_CheckPredicate, 22, // 15534: check predicate 22
8851 OPC_Decode, 169, 131, 1, 112, // 15536: decode to VWREDSUMU_VS using decoder 112
8852 // 15536: }
8853 49, 7, // 15541: case 0x31: {
8854 OPC_CheckPredicate, 22, // 15543: check predicate 22
8855 OPC_Decode, 170, 131, 1, 112, // 15545: decode to VWREDSUM_VS using decoder 112
8856 // 15545: }
8857 53, 7, // 15550: case 0x35: {
8858 OPC_CheckPredicate, 96, // 15552: check predicate 96
8859 OPC_Decode, 172, 131, 1, 112, // 15554: decode to VWSLL_VV using decoder 112
8860 // 15554: }
8861 56, 11, // 15559: case 0x38: {
8862 OPC_CheckPredicate, 97, // 15561: check predicate 97
8863 OPC_CheckField, 25, 1, 1, // 15563: check Inst[25] == 0x1
8864 OPC_Decode, 230, 128, 1, 116, // 15567: decode to VMMACC_VV using decoder 116
8865 // 15567: }
8866 57, 20, // 15572: case 0x39: {
8867 OPC_SwitchField, 25, 1, // 15574: switch Inst[25] {
8868 0, 6, // 15577: case 0x0: {
8869 OPC_CheckPredicate, 98, // 15579: check predicate 98
8870 OPC_Decode, 221, 126, 117, // 15581: decode to VFWIMMACC_VV using decoder 117
8871 // 15581: }
8872 1, 0, // 15585: case 0x1: {
8873 OPC_CheckPredicate, 97, // 15587: check predicate 97
8874 OPC_Decode, 162, 131, 1, 116, // 15589: decode to VWMMACC_VV using decoder 116
8875 // 15589: }
8876 // 15589: } // switch Inst[25]
8877 // 15589: }
8878 58, 20, // 15594: case 0x3a: {
8879 OPC_SwitchField, 25, 1, // 15596: switch Inst[25] {
8880 0, 6, // 15599: case 0x0: {
8881 OPC_CheckPredicate, 98, // 15601: check predicate 98
8882 OPC_Decode, 181, 126, 117, // 15603: decode to VFQIMMACC_VV using decoder 117
8883 // 15603: }
8884 1, 0, // 15607: case 0x1: {
8885 OPC_CheckPredicate, 97, // 15609: check predicate 97
8886 OPC_Decode, 183, 129, 1, 116, // 15611: decode to VQMMACC_VV using decoder 116
8887 // 15611: }
8888 // 15611: } // switch Inst[25]
8889 // 15611: }
8890 59, 0, // 15616: case 0x3b: {
8891 OPC_SwitchField, 25, 1, // 15618: switch Inst[25] {
8892 0, 6, // 15621: case 0x0: {
8893 OPC_CheckPredicate, 98, // 15623: check predicate 98
8894 OPC_Decode, 254, 125, 117, // 15625: decode to VF8WIMMACC_VV using decoder 117
8895 // 15625: }
8896 1, 0, // 15629: case 0x1: {
8897 OPC_CheckPredicate, 97, // 15631: check predicate 97
8898 OPC_Decode, 198, 125, 116, // 15633: decode to V8WMMACC_VV using decoder 116
8899 // 15633: }
8900 // 15633: } // switch Inst[25]
8901 // 15633: }
8902 // 15633: } // switch Inst[31:26]
8903 // 15633: }
8904 1, 133, 5, // 15637: case 0x1: {
8905 OPC_SwitchField, 26, 6, // 15640: switch Inst[31:26] {
8906 0, 6, // 15643: case 0x0: {
8907 OPC_CheckPredicate, 99, // 15645: check predicate 99
8908 OPC_Decode, 130, 126, 112, // 15647: decode to VFADD_VV using decoder 112
8909 // 15647: }
8910 1, 6, // 15651: case 0x1: {
8911 OPC_CheckPredicate, 99, // 15653: check predicate 99
8912 OPC_Decode, 193, 126, 112, // 15655: decode to VFREDUSUM_VS using decoder 112
8913 // 15655: }
8914 2, 6, // 15659: case 0x2: {
8915 OPC_CheckPredicate, 99, // 15661: check predicate 99
8916 OPC_Decode, 206, 126, 112, // 15663: decode to VFSUB_VV using decoder 112
8917 // 15663: }
8918 3, 6, // 15667: case 0x3: {
8919 OPC_CheckPredicate, 99, // 15669: check predicate 99
8920 OPC_Decode, 192, 126, 112, // 15671: decode to VFREDOSUM_VS using decoder 112
8921 // 15671: }
8922 4, 6, // 15675: case 0x4: {
8923 OPC_CheckPredicate, 99, // 15677: check predicate 99
8924 OPC_Decode, 150, 126, 112, // 15679: decode to VFMIN_VV using decoder 112
8925 // 15679: }
8926 5, 6, // 15683: case 0x5: {
8927 OPC_CheckPredicate, 99, // 15685: check predicate 99
8928 OPC_Decode, 191, 126, 112, // 15687: decode to VFREDMIN_VS using decoder 112
8929 // 15687: }
8930 6, 6, // 15691: case 0x6: {
8931 OPC_CheckPredicate, 99, // 15693: check predicate 99
8932 OPC_Decode, 147, 126, 112, // 15695: decode to VFMAX_VV using decoder 112
8933 // 15695: }
8934 7, 6, // 15699: case 0x7: {
8935 OPC_CheckPredicate, 99, // 15701: check predicate 99
8936 OPC_Decode, 190, 126, 112, // 15703: decode to VFREDMAX_VS using decoder 112
8937 // 15703: }
8938 8, 6, // 15707: case 0x8: {
8939 OPC_CheckPredicate, 99, // 15709: check predicate 99
8940 OPC_Decode, 201, 126, 112, // 15711: decode to VFSGNJ_VV using decoder 112
8941 // 15711: }
8942 9, 6, // 15715: case 0x9: {
8943 OPC_CheckPredicate, 99, // 15717: check predicate 99
8944 OPC_Decode, 197, 126, 112, // 15719: decode to VFSGNJN_VV using decoder 112
8945 // 15719: }
8946 10, 6, // 15723: case 0xa: {
8947 OPC_CheckPredicate, 99, // 15725: check predicate 99
8948 OPC_Decode, 199, 126, 112, // 15727: decode to VFSGNJX_VV using decoder 112
8949 // 15727: }
8950 16, 14, // 15731: case 0x10: {
8951 OPC_CheckPredicate, 99, // 15733: check predicate 99
8952 OPC_CheckField, 25, 1, 1, // 15735: check Inst[25] == 0x1
8953 OPC_CheckField, 15, 5, 0, // 15739: check Inst[19:15] == 0x0
8954 OPC_Decode, 158, 126, 118, // 15743: decode to VFMV_F_S using decoder 118
8955 // 15743: }
8956 18, 211, 1, // 15747: case 0x12: {
8957 OPC_SwitchField, 15, 5, // 15750: switch Inst[19:15] {
8958 0, 6, // 15753: case 0x0: {
8959 OPC_CheckPredicate, 99, // 15755: check predicate 99
8960 OPC_Decode, 137, 126, 119, // 15757: decode to VFCVT_XU_F_V using decoder 119
8961 // 15757: }
8962 1, 6, // 15761: case 0x1: {
8963 OPC_CheckPredicate, 99, // 15763: check predicate 99
8964 OPC_Decode, 138, 126, 119, // 15765: decode to VFCVT_X_F_V using decoder 119
8965 // 15765: }
8966 2, 6, // 15769: case 0x2: {
8967 OPC_CheckPredicate, 99, // 15771: check predicate 99
8968 OPC_Decode, 133, 126, 119, // 15773: decode to VFCVT_F_XU_V using decoder 119
8969 // 15773: }
8970 3, 6, // 15777: case 0x3: {
8971 OPC_CheckPredicate, 99, // 15779: check predicate 99
8972 OPC_Decode, 134, 126, 119, // 15781: decode to VFCVT_F_X_V using decoder 119
8973 // 15781: }
8974 6, 6, // 15785: case 0x6: {
8975 OPC_CheckPredicate, 99, // 15787: check predicate 99
8976 OPC_Decode, 135, 126, 119, // 15789: decode to VFCVT_RTZ_XU_F_V using decoder 119
8977 // 15789: }
8978 7, 6, // 15793: case 0x7: {
8979 OPC_CheckPredicate, 99, // 15795: check predicate 99
8980 OPC_Decode, 136, 126, 119, // 15797: decode to VFCVT_RTZ_X_F_V using decoder 119
8981 // 15797: }
8982 8, 6, // 15801: case 0x8: {
8983 OPC_CheckPredicate, 99, // 15803: check predicate 99
8984 OPC_Decode, 218, 126, 119, // 15805: decode to VFWCVT_XU_F_V using decoder 119
8985 // 15805: }
8986 9, 6, // 15809: case 0x9: {
8987 OPC_CheckPredicate, 99, // 15811: check predicate 99
8988 OPC_Decode, 219, 126, 119, // 15813: decode to VFWCVT_X_F_V using decoder 119
8989 // 15813: }
8990 10, 6, // 15817: case 0xa: {
8991 OPC_CheckPredicate, 99, // 15819: check predicate 99
8992 OPC_Decode, 214, 126, 119, // 15821: decode to VFWCVT_F_XU_V using decoder 119
8993 // 15821: }
8994 11, 6, // 15825: case 0xb: {
8995 OPC_CheckPredicate, 99, // 15827: check predicate 99
8996 OPC_Decode, 215, 126, 119, // 15829: decode to VFWCVT_F_X_V using decoder 119
8997 // 15829: }
8998 12, 6, // 15833: case 0xc: {
8999 OPC_CheckPredicate, 99, // 15835: check predicate 99
9000 OPC_Decode, 213, 126, 119, // 15837: decode to VFWCVT_F_F_V using decoder 119
9001 // 15837: }
9002 13, 6, // 15841: case 0xd: {
9003 OPC_CheckPredicate, 100, // 15843: check predicate 100
9004 OPC_Decode, 212, 126, 119, // 15845: decode to VFWCVTBF16_F_F_V using decoder 119
9005 // 15845: }
9006 14, 6, // 15849: case 0xe: {
9007 OPC_CheckPredicate, 99, // 15851: check predicate 99
9008 OPC_Decode, 216, 126, 119, // 15853: decode to VFWCVT_RTZ_XU_F_V using decoder 119
9009 // 15853: }
9010 15, 6, // 15857: case 0xf: {
9011 OPC_CheckPredicate, 99, // 15859: check predicate 99
9012 OPC_Decode, 217, 126, 119, // 15861: decode to VFWCVT_RTZ_X_F_V using decoder 119
9013 // 15861: }
9014 16, 6, // 15865: case 0x10: {
9015 OPC_CheckPredicate, 99, // 15867: check predicate 99
9016 OPC_Decode, 171, 126, 119, // 15869: decode to VFNCVT_XU_F_W using decoder 119
9017 // 15869: }
9018 17, 6, // 15873: case 0x11: {
9019 OPC_CheckPredicate, 99, // 15875: check predicate 99
9020 OPC_Decode, 172, 126, 119, // 15877: decode to VFNCVT_X_F_W using decoder 119
9021 // 15877: }
9022 18, 6, // 15881: case 0x12: {
9023 OPC_CheckPredicate, 99, // 15883: check predicate 99
9024 OPC_Decode, 165, 126, 119, // 15885: decode to VFNCVT_F_XU_W using decoder 119
9025 // 15885: }
9026 19, 6, // 15889: case 0x13: {
9027 OPC_CheckPredicate, 99, // 15891: check predicate 99
9028 OPC_Decode, 166, 126, 119, // 15893: decode to VFNCVT_F_X_W using decoder 119
9029 // 15893: }
9030 20, 6, // 15897: case 0x14: {
9031 OPC_CheckPredicate, 99, // 15899: check predicate 99
9032 OPC_Decode, 164, 126, 119, // 15901: decode to VFNCVT_F_F_W using decoder 119
9033 // 15901: }
9034 21, 6, // 15905: case 0x15: {
9035 OPC_CheckPredicate, 99, // 15907: check predicate 99
9036 OPC_Decode, 167, 126, 119, // 15909: decode to VFNCVT_ROD_F_F_W using decoder 119
9037 // 15909: }
9038 22, 6, // 15913: case 0x16: {
9039 OPC_CheckPredicate, 99, // 15915: check predicate 99
9040 OPC_Decode, 168, 126, 119, // 15917: decode to VFNCVT_RTZ_XU_F_W using decoder 119
9041 // 15917: }
9042 23, 6, // 15921: case 0x17: {
9043 OPC_CheckPredicate, 99, // 15923: check predicate 99
9044 OPC_Decode, 169, 126, 119, // 15925: decode to VFNCVT_RTZ_X_F_W using decoder 119
9045 // 15925: }
9046 25, 6, // 15929: case 0x19: {
9047 OPC_CheckPredicate, 101, // 15931: check predicate 101
9048 OPC_Decode, 163, 126, 119, // 15933: decode to VFNCVT_F_F_Q using decoder 119
9049 // 15933: }
9050 27, 6, // 15937: case 0x1b: {
9051 OPC_CheckPredicate, 101, // 15939: check predicate 101
9052 OPC_Decode, 170, 126, 119, // 15941: decode to VFNCVT_SAT_F_F_Q using decoder 119
9053 // 15941: }
9054 29, 6, // 15945: case 0x1d: {
9055 OPC_CheckPredicate, 100, // 15947: check predicate 100
9056 OPC_Decode, 161, 126, 119, // 15949: decode to VFNCVTBF16_F_F_W using decoder 119
9057 // 15949: }
9058 31, 0, // 15953: case 0x1f: {
9059 OPC_CheckPredicate, 101, // 15955: check predicate 101
9060 OPC_Decode, 162, 126, 119, // 15957: decode to VFNCVTBF16_SAT_F_F_W using decoder 119
9061 // 15957: }
9062 // 15957: } // switch Inst[19:15]
9063 // 15957: }
9064 19, 35, // 15961: case 0x13: {
9065 OPC_SwitchField, 15, 5, // 15963: switch Inst[19:15] {
9066 0, 6, // 15966: case 0x0: {
9067 OPC_CheckPredicate, 99, // 15968: check predicate 99
9068 OPC_Decode, 204, 126, 119, // 15970: decode to VFSQRT_V using decoder 119
9069 // 15970: }
9070 4, 6, // 15974: case 0x4: {
9071 OPC_CheckPredicate, 99, // 15976: check predicate 99
9072 OPC_Decode, 194, 126, 119, // 15978: decode to VFRSQRT7_V using decoder 119
9073 // 15978: }
9074 5, 6, // 15982: case 0x5: {
9075 OPC_CheckPredicate, 99, // 15984: check predicate 99
9076 OPC_Decode, 189, 126, 119, // 15986: decode to VFREC7_V using decoder 119
9077 // 15986: }
9078 16, 0, // 15990: case 0x10: {
9079 OPC_CheckPredicate, 99, // 15992: check predicate 99
9080 OPC_Decode, 132, 126, 119, // 15994: decode to VFCLASS_V using decoder 119
9081 // 15994: }
9082 // 15994: } // switch Inst[19:15]
9083 // 15994: }
9084 20, 10, // 15998: case 0x14: {
9085 OPC_CheckPredicate, 98, // 16000: check predicate 98
9086 OPC_CheckField, 25, 1, 1, // 16002: check Inst[25] == 0x1
9087 OPC_Decode, 151, 126, 116, // 16006: decode to VFMMACC_VV using decoder 116
9088 // 16006: }
9089 21, 19, // 16010: case 0x15: {
9090 OPC_SwitchField, 25, 1, // 16012: switch Inst[25] {
9091 0, 6, // 16015: case 0x0: {
9092 OPC_CheckPredicate, 98, // 16017: check predicate 98
9093 OPC_Decode, 231, 126, 117, // 16019: decode to VFWMMACC_VV_SCALE using decoder 117
9094 // 16019: }
9095 1, 0, // 16023: case 0x1: {
9096 OPC_CheckPredicate, 98, // 16025: check predicate 98
9097 OPC_Decode, 230, 126, 116, // 16027: decode to VFWMMACC_VV using decoder 116
9098 // 16027: }
9099 // 16027: } // switch Inst[25]
9100 // 16027: }
9101 22, 19, // 16031: case 0x16: {
9102 OPC_SwitchField, 25, 1, // 16033: switch Inst[25] {
9103 0, 6, // 16036: case 0x0: {
9104 OPC_CheckPredicate, 98, // 16038: check predicate 98
9105 OPC_Decode, 183, 126, 117, // 16040: decode to VFQMMACC_VV_SCALE using decoder 117
9106 // 16040: }
9107 1, 0, // 16044: case 0x1: {
9108 OPC_CheckPredicate, 98, // 16046: check predicate 98
9109 OPC_Decode, 182, 126, 116, // 16048: decode to VFQMMACC_VV using decoder 116
9110 // 16048: }
9111 // 16048: } // switch Inst[25]
9112 // 16048: }
9113 23, 19, // 16052: case 0x17: {
9114 OPC_SwitchField, 25, 1, // 16054: switch Inst[25] {
9115 0, 6, // 16057: case 0x0: {
9116 OPC_CheckPredicate, 98, // 16059: check predicate 98
9117 OPC_Decode, 128, 126, 117, // 16061: decode to VF8WMMACC_VV_SCALE using decoder 117
9118 // 16061: }
9119 1, 0, // 16065: case 0x1: {
9120 OPC_CheckPredicate, 98, // 16067: check predicate 98
9121 OPC_Decode, 255, 125, 116, // 16069: decode to VF8WMMACC_VV using decoder 116
9122 // 16069: }
9123 // 16069: } // switch Inst[25]
9124 // 16069: }
9125 24, 7, // 16073: case 0x18: {
9126 OPC_CheckPredicate, 99, // 16075: check predicate 99
9127 OPC_Decode, 217, 128, 1, 112, // 16077: decode to VMFEQ_VV using decoder 112
9128 // 16077: }
9129 25, 7, // 16082: case 0x19: {
9130 OPC_CheckPredicate, 99, // 16084: check predicate 99
9131 OPC_Decode, 221, 128, 1, 112, // 16086: decode to VMFLE_VV using decoder 112
9132 // 16086: }
9133 27, 7, // 16091: case 0x1b: {
9134 OPC_CheckPredicate, 99, // 16093: check predicate 99
9135 OPC_Decode, 223, 128, 1, 112, // 16095: decode to VMFLT_VV using decoder 112
9136 // 16095: }
9137 28, 7, // 16100: case 0x1c: {
9138 OPC_CheckPredicate, 99, // 16102: check predicate 99
9139 OPC_Decode, 225, 128, 1, 112, // 16104: decode to VMFNE_VV using decoder 112
9140 // 16104: }
9141 32, 6, // 16109: case 0x20: {
9142 OPC_CheckPredicate, 99, // 16111: check predicate 99
9143 OPC_Decode, 140, 126, 112, // 16113: decode to VFDIV_VV using decoder 112
9144 // 16113: }
9145 36, 6, // 16117: case 0x24: {
9146 OPC_CheckPredicate, 99, // 16119: check predicate 99
9147 OPC_Decode, 157, 126, 112, // 16121: decode to VFMUL_VV using decoder 112
9148 // 16121: }
9149 40, 6, // 16125: case 0x28: {
9150 OPC_CheckPredicate, 99, // 16127: check predicate 99
9151 OPC_Decode, 145, 126, 120, // 16129: decode to VFMADD_VV using decoder 120
9152 // 16129: }
9153 41, 6, // 16133: case 0x29: {
9154 OPC_CheckPredicate, 99, // 16135: check predicate 99
9155 OPC_Decode, 176, 126, 120, // 16137: decode to VFNMADD_VV using decoder 120
9156 // 16137: }
9157 42, 6, // 16141: case 0x2a: {
9158 OPC_CheckPredicate, 99, // 16143: check predicate 99
9159 OPC_Decode, 155, 126, 120, // 16145: decode to VFMSUB_VV using decoder 120
9160 // 16145: }
9161 43, 6, // 16149: case 0x2b: {
9162 OPC_CheckPredicate, 99, // 16151: check predicate 99
9163 OPC_Decode, 180, 126, 120, // 16153: decode to VFNMSUB_VV using decoder 120
9164 // 16153: }
9165 44, 6, // 16157: case 0x2c: {
9166 OPC_CheckPredicate, 99, // 16159: check predicate 99
9167 OPC_Decode, 143, 126, 120, // 16161: decode to VFMACC_VV using decoder 120
9168 // 16161: }
9169 45, 6, // 16165: case 0x2d: {
9170 OPC_CheckPredicate, 99, // 16167: check predicate 99
9171 OPC_Decode, 174, 126, 120, // 16169: decode to VFNMACC_VV using decoder 120
9172 // 16169: }
9173 46, 6, // 16173: case 0x2e: {
9174 OPC_CheckPredicate, 99, // 16175: check predicate 99
9175 OPC_Decode, 153, 126, 120, // 16177: decode to VFMSAC_VV using decoder 120
9176 // 16177: }
9177 47, 6, // 16181: case 0x2f: {
9178 OPC_CheckPredicate, 99, // 16183: check predicate 99
9179 OPC_Decode, 178, 126, 120, // 16185: decode to VFNMSAC_VV using decoder 120
9180 // 16185: }
9181 48, 6, // 16189: case 0x30: {
9182 OPC_CheckPredicate, 99, // 16191: check predicate 99
9183 OPC_Decode, 208, 126, 112, // 16193: decode to VFWADD_VV using decoder 112
9184 // 16193: }
9185 49, 6, // 16197: case 0x31: {
9186 OPC_CheckPredicate, 99, // 16199: check predicate 99
9187 OPC_Decode, 241, 126, 112, // 16201: decode to VFWREDUSUM_VS using decoder 112
9188 // 16201: }
9189 50, 6, // 16205: case 0x32: {
9190 OPC_CheckPredicate, 99, // 16207: check predicate 99
9191 OPC_Decode, 243, 126, 112, // 16209: decode to VFWSUB_VV using decoder 112
9192 // 16209: }
9193 51, 6, // 16213: case 0x33: {
9194 OPC_CheckPredicate, 99, // 16215: check predicate 99
9195 OPC_Decode, 240, 126, 112, // 16217: decode to VFWREDOSUM_VS using decoder 112
9196 // 16217: }
9197 52, 6, // 16221: case 0x34: {
9198 OPC_CheckPredicate, 99, // 16223: check predicate 99
9199 OPC_Decode, 210, 126, 112, // 16225: decode to VFWADD_WV using decoder 112
9200 // 16225: }
9201 54, 6, // 16229: case 0x36: {
9202 OPC_CheckPredicate, 99, // 16231: check predicate 99
9203 OPC_Decode, 245, 126, 112, // 16233: decode to VFWSUB_WV using decoder 112
9204 // 16233: }
9205 56, 6, // 16237: case 0x38: {
9206 OPC_CheckPredicate, 99, // 16239: check predicate 99
9207 OPC_Decode, 235, 126, 112, // 16241: decode to VFWMUL_VV using decoder 112
9208 // 16241: }
9209 59, 6, // 16245: case 0x3b: {
9210 OPC_CheckPredicate, 102, // 16247: check predicate 102
9211 OPC_Decode, 223, 126, 120, // 16249: decode to VFWMACCBF16_VV using decoder 120
9212 // 16249: }
9213 60, 6, // 16253: case 0x3c: {
9214 OPC_CheckPredicate, 99, // 16255: check predicate 99
9215 OPC_Decode, 225, 126, 120, // 16257: decode to VFWMACC_VV using decoder 120
9216 // 16257: }
9217 61, 6, // 16261: case 0x3d: {
9218 OPC_CheckPredicate, 99, // 16263: check predicate 99
9219 OPC_Decode, 237, 126, 120, // 16265: decode to VFWNMACC_VV using decoder 120
9220 // 16265: }
9221 62, 6, // 16269: case 0x3e: {
9222 OPC_CheckPredicate, 99, // 16271: check predicate 99
9223 OPC_Decode, 233, 126, 120, // 16273: decode to VFWMSAC_VV using decoder 120
9224 // 16273: }
9225 63, 0, // 16277: case 0x3f: {
9226 OPC_CheckPredicate, 99, // 16279: check predicate 99
9227 OPC_Decode, 239, 126, 120, // 16281: decode to VFWNMSAC_VV using decoder 120
9228 // 16281: }
9229 // 16281: } // switch Inst[31:26]
9230 // 16281: }
9231 2, 128, 6, // 16285: case 0x2: {
9232 OPC_SwitchField, 26, 6, // 16288: switch Inst[31:26] {
9233 0, 7, // 16291: case 0x0: {
9234 OPC_CheckPredicate, 22, // 16293: check predicate 22
9235 OPC_Decode, 194, 129, 1, 112, // 16295: decode to VREDSUM_VS using decoder 112
9236 // 16295: }
9237 1, 7, // 16300: case 0x1: {
9238 OPC_CheckPredicate, 22, // 16302: check predicate 22
9239 OPC_Decode, 188, 129, 1, 112, // 16304: decode to VREDAND_VS using decoder 112
9240 // 16304: }
9241 2, 7, // 16309: case 0x2: {
9242 OPC_CheckPredicate, 22, // 16311: check predicate 22
9243 OPC_Decode, 193, 129, 1, 112, // 16313: decode to VREDOR_VS using decoder 112
9244 // 16313: }
9245 3, 7, // 16318: case 0x3: {
9246 OPC_CheckPredicate, 22, // 16320: check predicate 22
9247 OPC_Decode, 195, 129, 1, 112, // 16322: decode to VREDXOR_VS using decoder 112
9248 // 16322: }
9249 4, 7, // 16327: case 0x4: {
9250 OPC_CheckPredicate, 22, // 16329: check predicate 22
9251 OPC_Decode, 191, 129, 1, 112, // 16331: decode to VREDMINU_VS using decoder 112
9252 // 16331: }
9253 5, 7, // 16336: case 0x5: {
9254 OPC_CheckPredicate, 22, // 16338: check predicate 22
9255 OPC_Decode, 192, 129, 1, 112, // 16340: decode to VREDMIN_VS using decoder 112
9256 // 16340: }
9257 6, 7, // 16345: case 0x6: {
9258 OPC_CheckPredicate, 22, // 16347: check predicate 22
9259 OPC_Decode, 189, 129, 1, 112, // 16349: decode to VREDMAXU_VS using decoder 112
9260 // 16349: }
9261 7, 7, // 16354: case 0x7: {
9262 OPC_CheckPredicate, 22, // 16356: check predicate 22
9263 OPC_Decode, 190, 129, 1, 112, // 16358: decode to VREDMAX_VS using decoder 112
9264 // 16358: }
9265 8, 6, // 16363: case 0x8: {
9266 OPC_CheckPredicate, 22, // 16365: check predicate 22
9267 OPC_Decode, 199, 125, 112, // 16367: decode to VAADDU_VV using decoder 112
9268 // 16367: }
9269 9, 6, // 16371: case 0x9: {
9270 OPC_CheckPredicate, 22, // 16373: check predicate 22
9271 OPC_Decode, 201, 125, 112, // 16375: decode to VAADD_VV using decoder 112
9272 // 16375: }
9273 10, 6, // 16379: case 0xa: {
9274 OPC_CheckPredicate, 22, // 16381: check predicate 22
9275 OPC_Decode, 228, 125, 112, // 16383: decode to VASUBU_VV using decoder 112
9276 // 16383: }
9277 11, 6, // 16387: case 0xb: {
9278 OPC_CheckPredicate, 22, // 16389: check predicate 22
9279 OPC_Decode, 230, 125, 112, // 16391: decode to VASUB_VV using decoder 112
9280 // 16391: }
9281 12, 6, // 16395: case 0xc: {
9282 OPC_CheckPredicate, 103, // 16397: check predicate 103
9283 OPC_Decode, 236, 125, 112, // 16399: decode to VCLMUL_VV using decoder 112
9284 // 16399: }
9285 13, 6, // 16403: case 0xd: {
9286 OPC_CheckPredicate, 103, // 16405: check predicate 103
9287 OPC_Decode, 234, 125, 112, // 16407: decode to VCLMULH_VV using decoder 112
9288 // 16407: }
9289 15, 7, // 16411: case 0xf: {
9290 OPC_CheckPredicate, 95, // 16413: check predicate 95
9291 OPC_Decode, 182, 129, 1, 112, // 16415: decode to VPAIRO_VV using decoder 112
9292 // 16415: }
9293 16, 32, // 16420: case 0x10: {
9294 OPC_SwitchField, 15, 5, // 16422: switch Inst[19:15] {
9295 0, 11, // 16425: case 0x0: {
9296 OPC_CheckPredicate, 22, // 16427: check predicate 22
9297 OPC_CheckField, 25, 1, 1, // 16429: check Inst[25] == 0x1
9298 OPC_Decode, 154, 129, 1, 121, // 16433: decode to VMV_X_S using decoder 121
9299 // 16433: }
9300 16, 6, // 16438: case 0x10: {
9301 OPC_CheckPredicate, 22, // 16440: check predicate 22
9302 OPC_Decode, 240, 125, 122, // 16442: decode to VCPOP_M using decoder 122
9303 // 16442: }
9304 17, 0, // 16446: case 0x11: {
9305 OPC_CheckPredicate, 22, // 16448: check predicate 22
9306 OPC_Decode, 141, 126, 122, // 16450: decode to VFIRST_M using decoder 122
9307 // 16450: }
9308 // 16450: } // switch Inst[19:15]
9309 // 16450: }
9310 17, 6, // 16454: case 0x11: {
9311 OPC_CheckPredicate, 104, // 16456: check predicate 104
9312 OPC_Decode, 204, 125, 112, // 16458: decode to VABD_VV using decoder 112
9313 // 16458: }
9314 18, 132, 1, // 16462: case 0x12: {
9315 OPC_SwitchField, 15, 5, // 16465: switch Inst[19:15] {
9316 2, 7, // 16468: case 0x2: {
9317 OPC_CheckPredicate, 22, // 16470: check predicate 22
9318 OPC_Decode, 187, 131, 1, 119, // 16472: decode to VZEXT_VF8 using decoder 119
9319 // 16472: }
9320 3, 7, // 16477: case 0x3: {
9321 OPC_CheckPredicate, 22, // 16479: check predicate 22
9322 OPC_Decode, 233, 129, 1, 119, // 16481: decode to VSEXT_VF8 using decoder 119
9323 // 16481: }
9324 4, 7, // 16486: case 0x4: {
9325 OPC_CheckPredicate, 22, // 16488: check predicate 22
9326 OPC_Decode, 186, 131, 1, 119, // 16490: decode to VZEXT_VF4 using decoder 119
9327 // 16490: }
9328 5, 7, // 16495: case 0x5: {
9329 OPC_CheckPredicate, 22, // 16497: check predicate 22
9330 OPC_Decode, 232, 129, 1, 119, // 16499: decode to VSEXT_VF4 using decoder 119
9331 // 16499: }
9332 6, 7, // 16504: case 0x6: {
9333 OPC_CheckPredicate, 22, // 16506: check predicate 22
9334 OPC_Decode, 185, 131, 1, 119, // 16508: decode to VZEXT_VF2 using decoder 119
9335 // 16508: }
9336 7, 7, // 16513: case 0x7: {
9337 OPC_CheckPredicate, 22, // 16515: check predicate 22
9338 OPC_Decode, 231, 129, 1, 119, // 16517: decode to VSEXT_VF2 using decoder 119
9339 // 16517: }
9340 8, 6, // 16522: case 0x8: {
9341 OPC_CheckPredicate, 94, // 16524: check predicate 94
9342 OPC_Decode, 232, 125, 119, // 16526: decode to VBREV8_V using decoder 119
9343 // 16526: }
9344 9, 7, // 16530: case 0x9: {
9345 OPC_CheckPredicate, 94, // 16532: check predicate 94
9346 OPC_Decode, 200, 129, 1, 119, // 16534: decode to VREV8_V using decoder 119
9347 // 16534: }
9348 10, 6, // 16539: case 0xa: {
9349 OPC_CheckPredicate, 96, // 16541: check predicate 96
9350 OPC_Decode, 233, 125, 119, // 16543: decode to VBREV_V using decoder 119
9351 // 16543: }
9352 11, 7, // 16547: case 0xb: {
9353 OPC_CheckPredicate, 95, // 16549: check predicate 95
9354 OPC_Decode, 142, 131, 1, 119, // 16551: decode to VUNZIPE_V using decoder 119
9355 // 16551: }
9356 12, 6, // 16556: case 0xc: {
9357 OPC_CheckPredicate, 96, // 16558: check predicate 96
9358 OPC_Decode, 238, 125, 119, // 16560: decode to VCLZ_V using decoder 119
9359 // 16560: }
9360 13, 6, // 16564: case 0xd: {
9361 OPC_CheckPredicate, 96, // 16566: check predicate 96
9362 OPC_Decode, 242, 125, 119, // 16568: decode to VCTZ_V using decoder 119
9363 // 16568: }
9364 14, 6, // 16572: case 0xe: {
9365 OPC_CheckPredicate, 96, // 16574: check predicate 96
9366 OPC_Decode, 241, 125, 119, // 16576: decode to VCPOP_V using decoder 119
9367 // 16576: }
9368 15, 7, // 16580: case 0xf: {
9369 OPC_CheckPredicate, 95, // 16582: check predicate 95
9370 OPC_Decode, 143, 131, 1, 119, // 16584: decode to VUNZIPO_V using decoder 119
9371 // 16584: }
9372 16, 0, // 16589: case 0x10: {
9373 OPC_CheckPredicate, 104, // 16591: check predicate 104
9374 OPC_Decode, 205, 125, 119, // 16593: decode to VABS_V using decoder 119
9375 // 16593: }
9376 // 16593: } // switch Inst[19:15]
9377 // 16593: }
9378 19, 6, // 16597: case 0x13: {
9379 OPC_CheckPredicate, 104, // 16599: check predicate 104
9380 OPC_Decode, 203, 125, 112, // 16601: decode to VABDU_VV using decoder 112
9381 // 16601: }
9382 20, 50, // 16605: case 0x14: {
9383 OPC_SwitchField, 15, 5, // 16607: switch Inst[19:15] {
9384 1, 7, // 16610: case 0x1: {
9385 OPC_CheckPredicate, 22, // 16612: check predicate 22
9386 OPC_Decode, 239, 128, 1, 119, // 16614: decode to VMSBF_M using decoder 119
9387 // 16614: }
9388 2, 7, // 16619: case 0x2: {
9389 OPC_CheckPredicate, 22, // 16621: check predicate 22
9390 OPC_Decode, 133, 129, 1, 119, // 16623: decode to VMSOF_M using decoder 119
9391 // 16623: }
9392 3, 7, // 16628: case 0x3: {
9393 OPC_CheckPredicate, 22, // 16630: check predicate 22
9394 OPC_Decode, 247, 128, 1, 119, // 16632: decode to VMSIF_M using decoder 119
9395 // 16632: }
9396 16, 6, // 16637: case 0x10: {
9397 OPC_CheckPredicate, 22, // 16639: check predicate 22
9398 OPC_Decode, 251, 126, 119, // 16641: decode to VIOTA_M using decoder 119
9399 // 16641: }
9400 17, 0, // 16645: case 0x11: {
9401 OPC_CheckPredicate, 22, // 16647: check predicate 22
9402 OPC_CheckField, 20, 5, 0, // 16649: check Inst[24:20] == 0x0
9403 OPC_Decode, 250, 126, 123, // 16653: decode to VID_V using decoder 123
9404 // 16653: }
9405 // 16653: } // switch Inst[19:15]
9406 // 16653: }
9407 21, 7, // 16657: case 0x15: {
9408 OPC_CheckPredicate, 104, // 16659: check predicate 104
9409 OPC_Decode, 146, 131, 1, 112, // 16661: decode to VWABDA_VV using decoder 112
9410 // 16661: }
9411 22, 7, // 16666: case 0x16: {
9412 OPC_CheckPredicate, 104, // 16668: check predicate 104
9413 OPC_Decode, 145, 131, 1, 112, // 16670: decode to VWABDAU_VV using decoder 112
9414 // 16670: }
9415 23, 10, // 16675: case 0x17: {
9416 OPC_CheckPredicate, 22, // 16677: check predicate 22
9417 OPC_CheckField, 25, 1, 1, // 16679: check Inst[25] == 0x1
9418 OPC_Decode, 239, 125, 114, // 16683: decode to VCOMPRESS_VM using decoder 114
9419 // 16683: }
9420 24, 11, // 16687: case 0x18: {
9421 OPC_CheckPredicate, 22, // 16689: check predicate 22
9422 OPC_CheckField, 25, 1, 1, // 16691: check Inst[25] == 0x1
9423 OPC_Decode, 207, 128, 1, 114, // 16695: decode to VMANDN_MM using decoder 114
9424 // 16695: }
9425 25, 11, // 16700: case 0x19: {
9426 OPC_CheckPredicate, 22, // 16702: check predicate 22
9427 OPC_CheckField, 25, 1, 1, // 16704: check Inst[25] == 0x1
9428 OPC_Decode, 208, 128, 1, 114, // 16708: decode to VMAND_MM using decoder 114
9429 // 16708: }
9430 26, 11, // 16713: case 0x1a: {
9431 OPC_CheckPredicate, 22, // 16715: check predicate 22
9432 OPC_CheckField, 25, 1, 1, // 16717: check Inst[25] == 0x1
9433 OPC_Decode, 234, 128, 1, 114, // 16721: decode to VMOR_MM using decoder 114
9434 // 16721: }
9435 27, 11, // 16726: case 0x1b: {
9436 OPC_CheckPredicate, 22, // 16728: check predicate 22
9437 OPC_CheckField, 25, 1, 1, // 16730: check Inst[25] == 0x1
9438 OPC_Decode, 156, 129, 1, 114, // 16734: decode to VMXOR_MM using decoder 114
9439 // 16734: }
9440 28, 11, // 16739: case 0x1c: {
9441 OPC_CheckPredicate, 22, // 16741: check predicate 22
9442 OPC_CheckField, 25, 1, 1, // 16743: check Inst[25] == 0x1
9443 OPC_Decode, 233, 128, 1, 114, // 16747: decode to VMORN_MM using decoder 114
9444 // 16747: }
9445 29, 11, // 16752: case 0x1d: {
9446 OPC_CheckPredicate, 22, // 16754: check predicate 22
9447 OPC_CheckField, 25, 1, 1, // 16756: check Inst[25] == 0x1
9448 OPC_Decode, 231, 128, 1, 114, // 16760: decode to VMNAND_MM using decoder 114
9449 // 16760: }
9450 30, 11, // 16765: case 0x1e: {
9451 OPC_CheckPredicate, 22, // 16767: check predicate 22
9452 OPC_CheckField, 25, 1, 1, // 16769: check Inst[25] == 0x1
9453 OPC_Decode, 232, 128, 1, 114, // 16773: decode to VMNOR_MM using decoder 114
9454 // 16773: }
9455 31, 11, // 16778: case 0x1f: {
9456 OPC_CheckPredicate, 22, // 16780: check predicate 22
9457 OPC_CheckField, 25, 1, 1, // 16782: check Inst[25] == 0x1
9458 OPC_Decode, 155, 129, 1, 114, // 16786: decode to VMXNOR_MM using decoder 114
9459 // 16786: }
9460 32, 6, // 16791: case 0x20: {
9461 OPC_CheckPredicate, 22, // 16793: check predicate 22
9462 OPC_Decode, 243, 125, 112, // 16795: decode to VDIVU_VV using decoder 112
9463 // 16795: }
9464 33, 6, // 16799: case 0x21: {
9465 OPC_CheckPredicate, 22, // 16801: check predicate 22
9466 OPC_Decode, 245, 125, 112, // 16803: decode to VDIV_VV using decoder 112
9467 // 16803: }
9468 34, 7, // 16807: case 0x22: {
9469 OPC_CheckPredicate, 22, // 16809: check predicate 22
9470 OPC_Decode, 196, 129, 1, 112, // 16811: decode to VREMU_VV using decoder 112
9471 // 16811: }
9472 35, 7, // 16816: case 0x23: {
9473 OPC_CheckPredicate, 22, // 16818: check predicate 22
9474 OPC_Decode, 198, 129, 1, 112, // 16820: decode to VREM_VV using decoder 112
9475 // 16820: }
9476 36, 7, // 16825: case 0x24: {
9477 OPC_CheckPredicate, 22, // 16827: check predicate 22
9478 OPC_Decode, 140, 129, 1, 112, // 16829: decode to VMULHU_VV using decoder 112
9479 // 16829: }
9480 37, 7, // 16834: case 0x25: {
9481 OPC_CheckPredicate, 22, // 16836: check predicate 22
9482 OPC_Decode, 144, 129, 1, 112, // 16838: decode to VMUL_VV using decoder 112
9483 // 16838: }
9484 38, 7, // 16843: case 0x26: {
9485 OPC_CheckPredicate, 22, // 16845: check predicate 22
9486 OPC_Decode, 138, 129, 1, 112, // 16847: decode to VMULHSU_VV using decoder 112
9487 // 16847: }
9488 39, 7, // 16852: case 0x27: {
9489 OPC_CheckPredicate, 22, // 16854: check predicate 22
9490 OPC_Decode, 142, 129, 1, 112, // 16856: decode to VMULH_VV using decoder 112
9491 // 16856: }
9492 40, 6, // 16861: case 0x28: {
9493 OPC_CheckPredicate, 105, // 16863: check predicate 105
9494 OPC_Decode, 250, 125, 124, // 16865: decode to VDOT4AU_VV using decoder 124
9495 // 16865: }
9496 41, 7, // 16869: case 0x29: {
9497 OPC_CheckPredicate, 22, // 16871: check predicate 22
9498 OPC_Decode, 181, 128, 1, 120, // 16873: decode to VMADD_VV using decoder 120
9499 // 16873: }
9500 42, 6, // 16878: case 0x2a: {
9501 OPC_CheckPredicate, 105, // 16880: check predicate 105
9502 OPC_Decode, 247, 125, 124, // 16882: decode to VDOT4ASU_VV using decoder 124
9503 // 16882: }
9504 43, 7, // 16886: case 0x2b: {
9505 OPC_CheckPredicate, 22, // 16888: check predicate 22
9506 OPC_Decode, 165, 129, 1, 120, // 16890: decode to VNMSUB_VV using decoder 120
9507 // 16890: }
9508 44, 6, // 16895: case 0x2c: {
9509 OPC_CheckPredicate, 105, // 16897: check predicate 105
9510 OPC_Decode, 252, 125, 124, // 16899: decode to VDOT4A_VV using decoder 124
9511 // 16899: }
9512 45, 7, // 16903: case 0x2d: {
9513 OPC_CheckPredicate, 22, // 16905: check predicate 22
9514 OPC_Decode, 173, 128, 1, 120, // 16907: decode to VMACC_VV using decoder 120
9515 // 16907: }
9516 47, 7, // 16912: case 0x2f: {
9517 OPC_CheckPredicate, 22, // 16914: check predicate 22
9518 OPC_Decode, 163, 129, 1, 120, // 16916: decode to VNMSAC_VV using decoder 120
9519 // 16916: }
9520 48, 7, // 16921: case 0x30: {
9521 OPC_CheckPredicate, 22, // 16923: check predicate 22
9522 OPC_Decode, 147, 131, 1, 112, // 16925: decode to VWADDU_VV using decoder 112
9523 // 16925: }
9524 49, 7, // 16930: case 0x31: {
9525 OPC_CheckPredicate, 22, // 16932: check predicate 22
9526 OPC_Decode, 151, 131, 1, 112, // 16934: decode to VWADD_VV using decoder 112
9527 // 16934: }
9528 50, 7, // 16939: case 0x32: {
9529 OPC_CheckPredicate, 22, // 16941: check predicate 22
9530 OPC_Decode, 174, 131, 1, 112, // 16943: decode to VWSUBU_VV using decoder 112
9531 // 16943: }
9532 51, 7, // 16948: case 0x33: {
9533 OPC_CheckPredicate, 22, // 16950: check predicate 22
9534 OPC_Decode, 178, 131, 1, 112, // 16952: decode to VWSUB_VV using decoder 112
9535 // 16952: }
9536 52, 7, // 16957: case 0x34: {
9537 OPC_CheckPredicate, 22, // 16959: check predicate 22
9538 OPC_Decode, 149, 131, 1, 112, // 16961: decode to VWADDU_WV using decoder 112
9539 // 16961: }
9540 53, 7, // 16966: case 0x35: {
9541 OPC_CheckPredicate, 22, // 16968: check predicate 22
9542 OPC_Decode, 153, 131, 1, 112, // 16970: decode to VWADD_WV using decoder 112
9543 // 16970: }
9544 54, 7, // 16975: case 0x36: {
9545 OPC_CheckPredicate, 22, // 16977: check predicate 22
9546 OPC_Decode, 176, 131, 1, 112, // 16979: decode to VWSUBU_WV using decoder 112
9547 // 16979: }
9548 55, 7, // 16984: case 0x37: {
9549 OPC_CheckPredicate, 22, // 16986: check predicate 22
9550 OPC_Decode, 180, 131, 1, 112, // 16988: decode to VWSUB_WV using decoder 112
9551 // 16988: }
9552 56, 7, // 16993: case 0x38: {
9553 OPC_CheckPredicate, 22, // 16995: check predicate 22
9554 OPC_Decode, 165, 131, 1, 112, // 16997: decode to VWMULU_VV using decoder 112
9555 // 16997: }
9556 58, 7, // 17002: case 0x3a: {
9557 OPC_CheckPredicate, 22, // 17004: check predicate 22
9558 OPC_Decode, 163, 131, 1, 112, // 17006: decode to VWMULSU_VV using decoder 112
9559 // 17006: }
9560 59, 7, // 17011: case 0x3b: {
9561 OPC_CheckPredicate, 22, // 17013: check predicate 22
9562 OPC_Decode, 167, 131, 1, 112, // 17015: decode to VWMUL_VV using decoder 112
9563 // 17015: }
9564 60, 7, // 17020: case 0x3c: {
9565 OPC_CheckPredicate, 22, // 17022: check predicate 22
9566 OPC_Decode, 158, 131, 1, 120, // 17024: decode to VWMACCU_VV using decoder 120
9567 // 17024: }
9568 61, 7, // 17029: case 0x3d: {
9569 OPC_CheckPredicate, 22, // 17031: check predicate 22
9570 OPC_Decode, 160, 131, 1, 120, // 17033: decode to VWMACC_VV using decoder 120
9571 // 17033: }
9572 62, 7, // 17038: case 0x3e: {
9573 OPC_CheckPredicate, 95, // 17040: check predicate 95
9574 OPC_Decode, 188, 131, 1, 112, // 17042: decode to VZIP_VV using decoder 112
9575 // 17042: }
9576 63, 0, // 17047: case 0x3f: {
9577 OPC_CheckPredicate, 22, // 17049: check predicate 22
9578 OPC_Decode, 155, 131, 1, 120, // 17051: decode to VWMACCSU_VV using decoder 120
9579 // 17051: }
9580 // 17051: } // switch Inst[31:26]
9581 // 17051: }
9582 3, 184, 3, // 17056: case 0x3: {
9583 OPC_SwitchField, 27, 5, // 17059: switch Inst[31:27] {
9584 0, 10, // 17062: case 0x0: {
9585 OPC_CheckPredicate, 22, // 17064: check predicate 22
9586 OPC_CheckField, 26, 1, 0, // 17066: check Inst[26] == 0x0
9587 OPC_Decode, 209, 125, 125, // 17070: decode to VADD_VI using decoder 125
9588 // 17070: }
9589 1, 11, // 17074: case 0x1: {
9590 OPC_CheckPredicate, 22, // 17076: check predicate 22
9591 OPC_CheckField, 26, 1, 1, // 17078: check Inst[26] == 0x1
9592 OPC_Decode, 210, 129, 1, 125, // 17082: decode to VRSUB_VI using decoder 125
9593 // 17082: }
9594 4, 10, // 17087: case 0x4: {
9595 OPC_CheckPredicate, 22, // 17089: check predicate 22
9596 OPC_CheckField, 26, 1, 1, // 17091: check Inst[26] == 0x1
9597 OPC_Decode, 225, 125, 125, // 17095: decode to VAND_VI using decoder 125
9598 // 17095: }
9599 5, 21, // 17099: case 0x5: {
9600 OPC_SwitchField, 26, 1, // 17101: switch Inst[26] {
9601 0, 7, // 17104: case 0x0: {
9602 OPC_CheckPredicate, 22, // 17106: check predicate 22
9603 OPC_Decode, 177, 129, 1, 125, // 17108: decode to VOR_VI using decoder 125
9604 // 17108: }
9605 1, 0, // 17113: case 0x1: {
9606 OPC_CheckPredicate, 22, // 17115: check predicate 22
9607 OPC_Decode, 182, 131, 1, 125, // 17117: decode to VXOR_VI using decoder 125
9608 // 17117: }
9609 // 17117: } // switch Inst[26]
9610 // 17117: }
9611 6, 11, // 17122: case 0x6: {
9612 OPC_CheckPredicate, 22, // 17124: check predicate 22
9613 OPC_CheckField, 26, 1, 0, // 17126: check Inst[26] == 0x0
9614 OPC_Decode, 202, 129, 1, 126, // 17130: decode to VRGATHER_VI using decoder 126
9615 // 17130: }
9616 7, 21, // 17135: case 0x7: {
9617 OPC_SwitchField, 26, 1, // 17137: switch Inst[26] {
9618 0, 7, // 17140: case 0x0: {
9619 OPC_CheckPredicate, 22, // 17142: check predicate 22
9620 OPC_Decode, 241, 129, 1, 126, // 17144: decode to VSLIDEUP_VI using decoder 126
9621 // 17144: }
9622 1, 0, // 17149: case 0x1: {
9623 OPC_CheckPredicate, 22, // 17151: check predicate 22
9624 OPC_Decode, 239, 129, 1, 126, // 17153: decode to VSLIDEDOWN_VI using decoder 126
9625 // 17153: }
9626 // 17153: } // switch Inst[26]
9627 // 17153: }
9628 8, 30, // 17158: case 0x8: {
9629 OPC_SwitchField, 25, 2, // 17160: switch Inst[26:25] {
9630 0, 6, // 17163: case 0x0: {
9631 OPC_CheckPredicate, 22, // 17165: check predicate 22
9632 OPC_Decode, 206, 125, 127, // 17167: decode to VADC_VIM using decoder 127
9633 // 17167: }
9634 2, 7, // 17171: case 0x2: {
9635 OPC_CheckPredicate, 22, // 17173: check predicate 22
9636 OPC_Decode, 176, 128, 1, 127, // 17175: decode to VMADC_VIM using decoder 127
9637 // 17175: }
9638 3, 0, // 17180: case 0x3: {
9639 OPC_CheckPredicate, 22, // 17182: check predicate 22
9640 OPC_Decode, 175, 128, 1, 128, 1, // 17184: decode to VMADC_VI using decoder 128
9641 // 17184: }
9642 // 17184: } // switch Inst[26:25]
9643 // 17184: }
9644 10, 8, // 17190: case 0xa: {
9645 OPC_CheckPredicate, 94, // 17192: check predicate 94
9646 OPC_Decode, 207, 129, 1, 129, 1, // 17194: decode to VROR_VI using decoder 129
9647 // 17194: }
9648 11, 26, // 17200: case 0xb: {
9649 OPC_SwitchField, 25, 2, // 17202: switch Inst[26:25] {
9650 2, 7, // 17205: case 0x2: {
9651 OPC_CheckPredicate, 22, // 17207: check predicate 22
9652 OPC_Decode, 213, 128, 1, 127, // 17209: decode to VMERGE_VIM using decoder 127
9653 // 17209: }
9654 3, 0, // 17214: case 0x3: {
9655 OPC_CheckPredicate, 22, // 17216: check predicate 22
9656 OPC_CheckField, 20, 5, 0, // 17218: check Inst[24:20] == 0x0
9657 OPC_Decode, 151, 129, 1, 130, 1, // 17222: decode to VMV_V_I using decoder 130
9658 // 17222: }
9659 // 17222: } // switch Inst[26:25]
9660 // 17222: }
9661 12, 21, // 17228: case 0xc: {
9662 OPC_SwitchField, 26, 1, // 17230: switch Inst[26] {
9663 0, 7, // 17233: case 0x0: {
9664 OPC_CheckPredicate, 22, // 17235: check predicate 22
9665 OPC_Decode, 240, 128, 1, 125, // 17237: decode to VMSEQ_VI using decoder 125
9666 // 17237: }
9667 1, 0, // 17242: case 0x1: {
9668 OPC_CheckPredicate, 22, // 17244: check predicate 22
9669 OPC_Decode, 130, 129, 1, 125, // 17246: decode to VMSNE_VI using decoder 125
9670 // 17246: }
9671 // 17246: } // switch Inst[26]
9672 // 17246: }
9673 14, 21, // 17251: case 0xe: {
9674 OPC_SwitchField, 26, 1, // 17253: switch Inst[26] {
9675 0, 7, // 17256: case 0x0: {
9676 OPC_CheckPredicate, 22, // 17258: check predicate 22
9677 OPC_Decode, 248, 128, 1, 125, // 17260: decode to VMSLEU_VI using decoder 125
9678 // 17260: }
9679 1, 0, // 17265: case 0x1: {
9680 OPC_CheckPredicate, 22, // 17267: check predicate 22
9681 OPC_Decode, 251, 128, 1, 125, // 17269: decode to VMSLE_VI using decoder 125
9682 // 17269: }
9683 // 17269: } // switch Inst[26]
9684 // 17269: }
9685 15, 21, // 17274: case 0xf: {
9686 OPC_SwitchField, 26, 1, // 17276: switch Inst[26] {
9687 0, 7, // 17279: case 0x0: {
9688 OPC_CheckPredicate, 22, // 17281: check predicate 22
9689 OPC_Decode, 243, 128, 1, 125, // 17283: decode to VMSGTU_VI using decoder 125
9690 // 17283: }
9691 1, 0, // 17288: case 0x1: {
9692 OPC_CheckPredicate, 22, // 17290: check predicate 22
9693 OPC_Decode, 245, 128, 1, 125, // 17292: decode to VMSGT_VI using decoder 125
9694 // 17292: }
9695 // 17292: } // switch Inst[26]
9696 // 17292: }
9697 16, 21, // 17297: case 0x10: {
9698 OPC_SwitchField, 26, 1, // 17299: switch Inst[26] {
9699 0, 7, // 17302: case 0x0: {
9700 OPC_CheckPredicate, 22, // 17304: check predicate 22
9701 OPC_Decode, 216, 129, 1, 125, // 17306: decode to VSADDU_VI using decoder 125
9702 // 17306: }
9703 1, 0, // 17311: case 0x1: {
9704 OPC_CheckPredicate, 22, // 17313: check predicate 22
9705 OPC_Decode, 219, 129, 1, 125, // 17315: decode to VSADD_VI using decoder 125
9706 // 17315: }
9707 // 17315: } // switch Inst[26]
9708 // 17315: }
9709 18, 11, // 17320: case 0x12: {
9710 OPC_CheckPredicate, 22, // 17322: check predicate 22
9711 OPC_CheckField, 26, 1, 1, // 17324: check Inst[26] == 0x1
9712 OPC_Decode, 243, 129, 1, 126, // 17328: decode to VSLL_VI using decoder 126
9713 // 17328: }
9714 19, 59, // 17333: case 0x13: {
9715 OPC_SwitchField, 15, 5, // 17335: switch Inst[19:15] {
9716 0, 12, // 17338: case 0x0: {
9717 OPC_CheckPredicate, 22, // 17340: check predicate 22
9718 OPC_CheckField, 25, 2, 3, // 17342: check Inst[26:25] == 0x3
9719 OPC_Decode, 146, 129, 1, 131, 1, // 17346: decode to VMV1R_V using decoder 131
9720 // 17346: }
9721 1, 12, // 17352: case 0x1: {
9722 OPC_CheckPredicate, 22, // 17354: check predicate 22
9723 OPC_CheckField, 25, 2, 3, // 17356: check Inst[26:25] == 0x3
9724 OPC_Decode, 147, 129, 1, 132, 1, // 17360: decode to VMV2R_V using decoder 132
9725 // 17360: }
9726 3, 12, // 17366: case 0x3: {
9727 OPC_CheckPredicate, 22, // 17368: check predicate 22
9728 OPC_CheckField, 25, 2, 3, // 17370: check Inst[26:25] == 0x3
9729 OPC_Decode, 148, 129, 1, 133, 1, // 17374: decode to VMV4R_V using decoder 133
9730 // 17374: }
9731 7, 0, // 17380: case 0x7: {
9732 OPC_CheckPredicate, 22, // 17382: check predicate 22
9733 OPC_CheckField, 25, 2, 3, // 17384: check Inst[26:25] == 0x3
9734 OPC_Decode, 149, 129, 1, 134, 1, // 17388: decode to VMV8R_V using decoder 134
9735 // 17388: }
9736 // 17388: } // switch Inst[19:15]
9737 // 17388: }
9738 20, 21, // 17394: case 0x14: {
9739 OPC_SwitchField, 26, 1, // 17396: switch Inst[26] {
9740 0, 7, // 17399: case 0x0: {
9741 OPC_CheckPredicate, 22, // 17401: check predicate 22
9742 OPC_Decode, 161, 130, 1, 126, // 17403: decode to VSRL_VI using decoder 126
9743 // 17403: }
9744 1, 0, // 17408: case 0x1: {
9745 OPC_CheckPredicate, 22, // 17410: check predicate 22
9746 OPC_Decode, 158, 130, 1, 126, // 17412: decode to VSRA_VI using decoder 126
9747 // 17412: }
9748 // 17412: } // switch Inst[26]
9749 // 17412: }
9750 21, 21, // 17417: case 0x15: {
9751 OPC_SwitchField, 26, 1, // 17419: switch Inst[26] {
9752 0, 7, // 17422: case 0x0: {
9753 OPC_CheckPredicate, 22, // 17424: check predicate 22
9754 OPC_Decode, 199, 130, 1, 126, // 17426: decode to VSSRL_VI using decoder 126
9755 // 17426: }
9756 1, 0, // 17431: case 0x1: {
9757 OPC_CheckPredicate, 22, // 17433: check predicate 22
9758 OPC_Decode, 196, 130, 1, 126, // 17435: decode to VSSRA_VI using decoder 126
9759 // 17435: }
9760 // 17435: } // switch Inst[26]
9761 // 17435: }
9762 22, 21, // 17440: case 0x16: {
9763 OPC_SwitchField, 26, 1, // 17442: switch Inst[26] {
9764 0, 7, // 17445: case 0x0: {
9765 OPC_CheckPredicate, 22, // 17447: check predicate 22
9766 OPC_Decode, 174, 129, 1, 126, // 17449: decode to VNSRL_WI using decoder 126
9767 // 17449: }
9768 1, 0, // 17454: case 0x1: {
9769 OPC_CheckPredicate, 22, // 17456: check predicate 22
9770 OPC_Decode, 171, 129, 1, 126, // 17458: decode to VNSRA_WI using decoder 126
9771 // 17458: }
9772 // 17458: } // switch Inst[26]
9773 // 17458: }
9774 23, 21, // 17463: case 0x17: {
9775 OPC_SwitchField, 26, 1, // 17465: switch Inst[26] {
9776 0, 7, // 17468: case 0x0: {
9777 OPC_CheckPredicate, 22, // 17470: check predicate 22
9778 OPC_Decode, 157, 129, 1, 126, // 17472: decode to VNCLIPU_WI using decoder 126
9779 // 17472: }
9780 1, 0, // 17477: case 0x1: {
9781 OPC_CheckPredicate, 22, // 17479: check predicate 22
9782 OPC_Decode, 160, 129, 1, 126, // 17481: decode to VNCLIP_WI using decoder 126
9783 // 17481: }
9784 // 17481: } // switch Inst[26]
9785 // 17481: }
9786 26, 0, // 17486: case 0x1a: {
9787 OPC_CheckPredicate, 96, // 17488: check predicate 96
9788 OPC_CheckField, 26, 1, 1, // 17490: check Inst[26] == 0x1
9789 OPC_Decode, 171, 131, 1, 126, // 17494: decode to VWSLL_VI using decoder 126
9790 // 17494: }
9791 // 17494: } // switch Inst[31:27]
9792 // 17494: }
9793 4, 239, 3, // 17499: case 0x4: {
9794 OPC_SwitchField, 26, 6, // 17502: switch Inst[31:26] {
9795 0, 7, // 17505: case 0x0: {
9796 OPC_CheckPredicate, 22, // 17507: check predicate 22
9797 OPC_Decode, 211, 125, 135, 1, // 17509: decode to VADD_VX using decoder 135
9798 // 17509: }
9799 1, 7, // 17514: case 0x1: {
9800 OPC_CheckPredicate, 94, // 17516: check predicate 94
9801 OPC_Decode, 224, 125, 135, 1, // 17518: decode to VANDN_VX using decoder 135
9802 // 17518: }
9803 2, 8, // 17523: case 0x2: {
9804 OPC_CheckPredicate, 22, // 17525: check predicate 22
9805 OPC_Decode, 235, 130, 1, 135, 1, // 17527: decode to VSUB_VX using decoder 135
9806 // 17527: }
9807 3, 8, // 17533: case 0x3: {
9808 OPC_CheckPredicate, 22, // 17535: check predicate 22
9809 OPC_Decode, 211, 129, 1, 135, 1, // 17537: decode to VRSUB_VX using decoder 135
9810 // 17537: }
9811 4, 8, // 17543: case 0x4: {
9812 OPC_CheckPredicate, 22, // 17545: check predicate 22
9813 OPC_Decode, 227, 128, 1, 135, 1, // 17547: decode to VMINU_VX using decoder 135
9814 // 17547: }
9815 5, 8, // 17553: case 0x5: {
9816 OPC_CheckPredicate, 22, // 17555: check predicate 22
9817 OPC_Decode, 229, 128, 1, 135, 1, // 17557: decode to VMIN_VX using decoder 135
9818 // 17557: }
9819 6, 8, // 17563: case 0x6: {
9820 OPC_CheckPredicate, 22, // 17565: check predicate 22
9821 OPC_Decode, 210, 128, 1, 135, 1, // 17567: decode to VMAXU_VX using decoder 135
9822 // 17567: }
9823 7, 8, // 17573: case 0x7: {
9824 OPC_CheckPredicate, 22, // 17575: check predicate 22
9825 OPC_Decode, 212, 128, 1, 135, 1, // 17577: decode to VMAX_VX using decoder 135
9826 // 17577: }
9827 9, 7, // 17583: case 0x9: {
9828 OPC_CheckPredicate, 22, // 17585: check predicate 22
9829 OPC_Decode, 227, 125, 135, 1, // 17587: decode to VAND_VX using decoder 135
9830 // 17587: }
9831 10, 8, // 17592: case 0xa: {
9832 OPC_CheckPredicate, 22, // 17594: check predicate 22
9833 OPC_Decode, 179, 129, 1, 135, 1, // 17596: decode to VOR_VX using decoder 135
9834 // 17596: }
9835 11, 8, // 17602: case 0xb: {
9836 OPC_CheckPredicate, 22, // 17604: check predicate 22
9837 OPC_Decode, 184, 131, 1, 135, 1, // 17606: decode to VXOR_VX using decoder 135
9838 // 17606: }
9839 12, 8, // 17612: case 0xc: {
9840 OPC_CheckPredicate, 22, // 17614: check predicate 22
9841 OPC_Decode, 204, 129, 1, 135, 1, // 17616: decode to VRGATHER_VX using decoder 135
9842 // 17616: }
9843 14, 8, // 17622: case 0xe: {
9844 OPC_CheckPredicate, 22, // 17624: check predicate 22
9845 OPC_Decode, 242, 129, 1, 135, 1, // 17626: decode to VSLIDEUP_VX using decoder 135
9846 // 17626: }
9847 15, 8, // 17632: case 0xf: {
9848 OPC_CheckPredicate, 22, // 17634: check predicate 22
9849 OPC_Decode, 240, 129, 1, 135, 1, // 17636: decode to VSLIDEDOWN_VX using decoder 135
9850 // 17636: }
9851 16, 11, // 17642: case 0x10: {
9852 OPC_CheckPredicate, 22, // 17644: check predicate 22
9853 OPC_CheckField, 25, 1, 0, // 17646: check Inst[25] == 0x0
9854 OPC_Decode, 208, 125, 136, 1, // 17650: decode to VADC_VXM using decoder 136
9855 // 17650: }
9856 17, 23, // 17655: case 0x11: {
9857 OPC_SwitchField, 25, 1, // 17657: switch Inst[25] {
9858 0, 8, // 17660: case 0x0: {
9859 OPC_CheckPredicate, 22, // 17662: check predicate 22
9860 OPC_Decode, 180, 128, 1, 136, 1, // 17664: decode to VMADC_VXM using decoder 136
9861 // 17664: }
9862 1, 0, // 17670: case 0x1: {
9863 OPC_CheckPredicate, 22, // 17672: check predicate 22
9864 OPC_Decode, 179, 128, 1, 137, 1, // 17674: decode to VMADC_VX using decoder 137
9865 // 17674: }
9866 // 17674: } // switch Inst[25]
9867 // 17674: }
9868 18, 12, // 17680: case 0x12: {
9869 OPC_CheckPredicate, 22, // 17682: check predicate 22
9870 OPC_CheckField, 25, 1, 0, // 17684: check Inst[25] == 0x0
9871 OPC_Decode, 223, 129, 1, 136, 1, // 17688: decode to VSBC_VXM using decoder 136
9872 // 17688: }
9873 19, 23, // 17694: case 0x13: {
9874 OPC_SwitchField, 25, 1, // 17696: switch Inst[25] {
9875 0, 8, // 17699: case 0x0: {
9876 OPC_CheckPredicate, 22, // 17701: check predicate 22
9877 OPC_Decode, 238, 128, 1, 136, 1, // 17703: decode to VMSBC_VXM using decoder 136
9878 // 17703: }
9879 1, 0, // 17709: case 0x1: {
9880 OPC_CheckPredicate, 22, // 17711: check predicate 22
9881 OPC_Decode, 237, 128, 1, 137, 1, // 17713: decode to VMSBC_VX using decoder 137
9882 // 17713: }
9883 // 17713: } // switch Inst[25]
9884 // 17713: }
9885 20, 8, // 17719: case 0x14: {
9886 OPC_CheckPredicate, 94, // 17721: check predicate 94
9887 OPC_Decode, 209, 129, 1, 135, 1, // 17723: decode to VROR_VX using decoder 135
9888 // 17723: }
9889 21, 8, // 17729: case 0x15: {
9890 OPC_CheckPredicate, 94, // 17731: check predicate 94
9891 OPC_Decode, 206, 129, 1, 135, 1, // 17733: decode to VROL_VX using decoder 135
9892 // 17733: }
9893 23, 26, // 17739: case 0x17: {
9894 OPC_SwitchField, 25, 1, // 17741: switch Inst[25] {
9895 0, 8, // 17744: case 0x0: {
9896 OPC_CheckPredicate, 22, // 17746: check predicate 22
9897 OPC_Decode, 215, 128, 1, 136, 1, // 17748: decode to VMERGE_VXM using decoder 136
9898 // 17748: }
9899 1, 0, // 17754: case 0x1: {
9900 OPC_CheckPredicate, 22, // 17756: check predicate 22
9901 OPC_CheckField, 20, 5, 0, // 17758: check Inst[24:20] == 0x0
9902 OPC_Decode, 153, 129, 1, 2, // 17762: decode to VMV_V_X using decoder 2
9903 // 17762: }
9904 // 17762: } // switch Inst[25]
9905 // 17762: }
9906 24, 8, // 17767: case 0x18: {
9907 OPC_CheckPredicate, 22, // 17769: check predicate 22
9908 OPC_Decode, 242, 128, 1, 135, 1, // 17771: decode to VMSEQ_VX using decoder 135
9909 // 17771: }
9910 25, 8, // 17777: case 0x19: {
9911 OPC_CheckPredicate, 22, // 17779: check predicate 22
9912 OPC_Decode, 132, 129, 1, 135, 1, // 17781: decode to VMSNE_VX using decoder 135
9913 // 17781: }
9914 26, 8, // 17787: case 0x1a: {
9915 OPC_CheckPredicate, 22, // 17789: check predicate 22
9916 OPC_Decode, 255, 128, 1, 135, 1, // 17791: decode to VMSLTU_VX using decoder 135
9917 // 17791: }
9918 27, 8, // 17797: case 0x1b: {
9919 OPC_CheckPredicate, 22, // 17799: check predicate 22
9920 OPC_Decode, 129, 129, 1, 135, 1, // 17801: decode to VMSLT_VX using decoder 135
9921 // 17801: }
9922 28, 8, // 17807: case 0x1c: {
9923 OPC_CheckPredicate, 22, // 17809: check predicate 22
9924 OPC_Decode, 250, 128, 1, 135, 1, // 17811: decode to VMSLEU_VX using decoder 135
9925 // 17811: }
9926 29, 8, // 17817: case 0x1d: {
9927 OPC_CheckPredicate, 22, // 17819: check predicate 22
9928 OPC_Decode, 253, 128, 1, 135, 1, // 17821: decode to VMSLE_VX using decoder 135
9929 // 17821: }
9930 30, 8, // 17827: case 0x1e: {
9931 OPC_CheckPredicate, 22, // 17829: check predicate 22
9932 OPC_Decode, 244, 128, 1, 135, 1, // 17831: decode to VMSGTU_VX using decoder 135
9933 // 17831: }
9934 31, 8, // 17837: case 0x1f: {
9935 OPC_CheckPredicate, 22, // 17839: check predicate 22
9936 OPC_Decode, 246, 128, 1, 135, 1, // 17841: decode to VMSGT_VX using decoder 135
9937 // 17841: }
9938 32, 8, // 17847: case 0x20: {
9939 OPC_CheckPredicate, 22, // 17849: check predicate 22
9940 OPC_Decode, 218, 129, 1, 135, 1, // 17851: decode to VSADDU_VX using decoder 135
9941 // 17851: }
9942 33, 8, // 17857: case 0x21: {
9943 OPC_CheckPredicate, 22, // 17859: check predicate 22
9944 OPC_Decode, 221, 129, 1, 135, 1, // 17861: decode to VSADD_VX using decoder 135
9945 // 17861: }
9946 34, 8, // 17867: case 0x22: {
9947 OPC_CheckPredicate, 22, // 17869: check predicate 22
9948 OPC_Decode, 231, 130, 1, 135, 1, // 17871: decode to VSSUBU_VX using decoder 135
9949 // 17871: }
9950 35, 8, // 17877: case 0x23: {
9951 OPC_CheckPredicate, 22, // 17879: check predicate 22
9952 OPC_Decode, 233, 130, 1, 135, 1, // 17881: decode to VSSUB_VX using decoder 135
9953 // 17881: }
9954 37, 8, // 17887: case 0x25: {
9955 OPC_CheckPredicate, 22, // 17889: check predicate 22
9956 OPC_Decode, 245, 129, 1, 135, 1, // 17891: decode to VSLL_VX using decoder 135
9957 // 17891: }
9958 39, 8, // 17897: case 0x27: {
9959 OPC_CheckPredicate, 22, // 17899: check predicate 22
9960 OPC_Decode, 252, 129, 1, 135, 1, // 17901: decode to VSMUL_VX using decoder 135
9961 // 17901: }
9962 40, 8, // 17907: case 0x28: {
9963 OPC_CheckPredicate, 22, // 17909: check predicate 22
9964 OPC_Decode, 163, 130, 1, 135, 1, // 17911: decode to VSRL_VX using decoder 135
9965 // 17911: }
9966 41, 8, // 17917: case 0x29: {
9967 OPC_CheckPredicate, 22, // 17919: check predicate 22
9968 OPC_Decode, 160, 130, 1, 135, 1, // 17921: decode to VSRA_VX using decoder 135
9969 // 17921: }
9970 42, 8, // 17927: case 0x2a: {
9971 OPC_CheckPredicate, 22, // 17929: check predicate 22
9972 OPC_Decode, 201, 130, 1, 135, 1, // 17931: decode to VSSRL_VX using decoder 135
9973 // 17931: }
9974 43, 8, // 17937: case 0x2b: {
9975 OPC_CheckPredicate, 22, // 17939: check predicate 22
9976 OPC_Decode, 198, 130, 1, 135, 1, // 17941: decode to VSSRA_VX using decoder 135
9977 // 17941: }
9978 44, 8, // 17947: case 0x2c: {
9979 OPC_CheckPredicate, 22, // 17949: check predicate 22
9980 OPC_Decode, 176, 129, 1, 135, 1, // 17951: decode to VNSRL_WX using decoder 135
9981 // 17951: }
9982 45, 8, // 17957: case 0x2d: {
9983 OPC_CheckPredicate, 22, // 17959: check predicate 22
9984 OPC_Decode, 173, 129, 1, 135, 1, // 17961: decode to VNSRA_WX using decoder 135
9985 // 17961: }
9986 46, 8, // 17967: case 0x2e: {
9987 OPC_CheckPredicate, 22, // 17969: check predicate 22
9988 OPC_Decode, 159, 129, 1, 135, 1, // 17971: decode to VNCLIPU_WX using decoder 135
9989 // 17971: }
9990 47, 8, // 17977: case 0x2f: {
9991 OPC_CheckPredicate, 22, // 17979: check predicate 22
9992 OPC_Decode, 162, 129, 1, 135, 1, // 17981: decode to VNCLIP_WX using decoder 135
9993 // 17981: }
9994 53, 0, // 17987: case 0x35: {
9995 OPC_CheckPredicate, 96, // 17989: check predicate 96
9996 OPC_Decode, 173, 131, 1, 135, 1, // 17991: decode to VWSLL_VX using decoder 135
9997 // 17991: }
9998 // 17991: } // switch Inst[31:26]
9999 // 17991: }
10000 5, 254, 2, // 17997: case 0x5: {
10001 OPC_SwitchField, 26, 6, // 18000: switch Inst[31:26] {
10002 0, 7, // 18003: case 0x0: {
10003 OPC_CheckPredicate, 99, // 18005: check predicate 99
10004 OPC_Decode, 129, 126, 138, 1, // 18007: decode to VFADD_VF using decoder 138
10005 // 18007: }
10006 2, 7, // 18012: case 0x2: {
10007 OPC_CheckPredicate, 99, // 18014: check predicate 99
10008 OPC_Decode, 205, 126, 138, 1, // 18016: decode to VFSUB_VF using decoder 138
10009 // 18016: }
10010 4, 7, // 18021: case 0x4: {
10011 OPC_CheckPredicate, 99, // 18023: check predicate 99
10012 OPC_Decode, 149, 126, 138, 1, // 18025: decode to VFMIN_VF using decoder 138
10013 // 18025: }
10014 6, 7, // 18030: case 0x6: {
10015 OPC_CheckPredicate, 99, // 18032: check predicate 99
10016 OPC_Decode, 146, 126, 138, 1, // 18034: decode to VFMAX_VF using decoder 138
10017 // 18034: }
10018 8, 7, // 18039: case 0x8: {
10019 OPC_CheckPredicate, 99, // 18041: check predicate 99
10020 OPC_Decode, 200, 126, 138, 1, // 18043: decode to VFSGNJ_VF using decoder 138
10021 // 18043: }
10022 9, 7, // 18048: case 0x9: {
10023 OPC_CheckPredicate, 99, // 18050: check predicate 99
10024 OPC_Decode, 196, 126, 138, 1, // 18052: decode to VFSGNJN_VF using decoder 138
10025 // 18052: }
10026 10, 7, // 18057: case 0xa: {
10027 OPC_CheckPredicate, 99, // 18059: check predicate 99
10028 OPC_Decode, 198, 126, 138, 1, // 18061: decode to VFSGNJX_VF using decoder 138
10029 // 18061: }
10030 14, 7, // 18066: case 0xe: {
10031 OPC_CheckPredicate, 99, // 18068: check predicate 99
10032 OPC_Decode, 203, 126, 138, 1, // 18070: decode to VFSLIDE1UP_VF using decoder 138
10033 // 18070: }
10034 15, 7, // 18075: case 0xf: {
10035 OPC_CheckPredicate, 99, // 18077: check predicate 99
10036 OPC_Decode, 202, 126, 138, 1, // 18079: decode to VFSLIDE1DOWN_VF using decoder 138
10037 // 18079: }
10038 16, 11, // 18084: case 0x10: {
10039 OPC_CheckPredicate, 99, // 18086: check predicate 99
10040 OPC_CheckField, 20, 6, 32, // 18088: check Inst[25:20] == 0x20
10041 OPC_Decode, 159, 126, 139, 1, // 18092: decode to VFMV_S_F using decoder 139
10042 // 18092: }
10043 23, 25, // 18097: case 0x17: {
10044 OPC_SwitchField, 25, 1, // 18099: switch Inst[25] {
10045 0, 7, // 18102: case 0x0: {
10046 OPC_CheckPredicate, 99, // 18104: check predicate 99
10047 OPC_Decode, 148, 126, 140, 1, // 18106: decode to VFMERGE_VFM using decoder 140
10048 // 18106: }
10049 1, 0, // 18111: case 0x1: {
10050 OPC_CheckPredicate, 99, // 18113: check predicate 99
10051 OPC_CheckField, 20, 5, 0, // 18115: check Inst[24:20] == 0x0
10052 OPC_Decode, 160, 126, 141, 1, // 18119: decode to VFMV_V_F using decoder 141
10053 // 18119: }
10054 // 18119: } // switch Inst[25]
10055 // 18119: }
10056 24, 8, // 18124: case 0x18: {
10057 OPC_CheckPredicate, 99, // 18126: check predicate 99
10058 OPC_Decode, 216, 128, 1, 138, 1, // 18128: decode to VMFEQ_VF using decoder 138
10059 // 18128: }
10060 25, 8, // 18134: case 0x19: {
10061 OPC_CheckPredicate, 99, // 18136: check predicate 99
10062 OPC_Decode, 220, 128, 1, 138, 1, // 18138: decode to VMFLE_VF using decoder 138
10063 // 18138: }
10064 27, 8, // 18144: case 0x1b: {
10065 OPC_CheckPredicate, 99, // 18146: check predicate 99
10066 OPC_Decode, 222, 128, 1, 138, 1, // 18148: decode to VMFLT_VF using decoder 138
10067 // 18148: }
10068 28, 8, // 18154: case 0x1c: {
10069 OPC_CheckPredicate, 99, // 18156: check predicate 99
10070 OPC_Decode, 224, 128, 1, 138, 1, // 18158: decode to VMFNE_VF using decoder 138
10071 // 18158: }
10072 29, 8, // 18164: case 0x1d: {
10073 OPC_CheckPredicate, 99, // 18166: check predicate 99
10074 OPC_Decode, 219, 128, 1, 138, 1, // 18168: decode to VMFGT_VF using decoder 138
10075 // 18168: }
10076 31, 8, // 18174: case 0x1f: {
10077 OPC_CheckPredicate, 99, // 18176: check predicate 99
10078 OPC_Decode, 218, 128, 1, 138, 1, // 18178: decode to VMFGE_VF using decoder 138
10079 // 18178: }
10080 32, 7, // 18184: case 0x20: {
10081 OPC_CheckPredicate, 99, // 18186: check predicate 99
10082 OPC_Decode, 139, 126, 138, 1, // 18188: decode to VFDIV_VF using decoder 138
10083 // 18188: }
10084 33, 7, // 18193: case 0x21: {
10085 OPC_CheckPredicate, 99, // 18195: check predicate 99
10086 OPC_Decode, 188, 126, 138, 1, // 18197: decode to VFRDIV_VF using decoder 138
10087 // 18197: }
10088 36, 7, // 18202: case 0x24: {
10089 OPC_CheckPredicate, 99, // 18204: check predicate 99
10090 OPC_Decode, 156, 126, 138, 1, // 18206: decode to VFMUL_VF using decoder 138
10091 // 18206: }
10092 39, 7, // 18211: case 0x27: {
10093 OPC_CheckPredicate, 99, // 18213: check predicate 99
10094 OPC_Decode, 195, 126, 138, 1, // 18215: decode to VFRSUB_VF using decoder 138
10095 // 18215: }
10096 40, 7, // 18220: case 0x28: {
10097 OPC_CheckPredicate, 99, // 18222: check predicate 99
10098 OPC_Decode, 144, 126, 142, 1, // 18224: decode to VFMADD_VF using decoder 142
10099 // 18224: }
10100 41, 7, // 18229: case 0x29: {
10101 OPC_CheckPredicate, 99, // 18231: check predicate 99
10102 OPC_Decode, 175, 126, 142, 1, // 18233: decode to VFNMADD_VF using decoder 142
10103 // 18233: }
10104 42, 7, // 18238: case 0x2a: {
10105 OPC_CheckPredicate, 99, // 18240: check predicate 99
10106 OPC_Decode, 154, 126, 142, 1, // 18242: decode to VFMSUB_VF using decoder 142
10107 // 18242: }
10108 43, 7, // 18247: case 0x2b: {
10109 OPC_CheckPredicate, 99, // 18249: check predicate 99
10110 OPC_Decode, 179, 126, 142, 1, // 18251: decode to VFNMSUB_VF using decoder 142
10111 // 18251: }
10112 44, 7, // 18256: case 0x2c: {
10113 OPC_CheckPredicate, 99, // 18258: check predicate 99
10114 OPC_Decode, 142, 126, 142, 1, // 18260: decode to VFMACC_VF using decoder 142
10115 // 18260: }
10116 45, 7, // 18265: case 0x2d: {
10117 OPC_CheckPredicate, 99, // 18267: check predicate 99
10118 OPC_Decode, 173, 126, 142, 1, // 18269: decode to VFNMACC_VF using decoder 142
10119 // 18269: }
10120 46, 7, // 18274: case 0x2e: {
10121 OPC_CheckPredicate, 99, // 18276: check predicate 99
10122 OPC_Decode, 152, 126, 142, 1, // 18278: decode to VFMSAC_VF using decoder 142
10123 // 18278: }
10124 47, 7, // 18283: case 0x2f: {
10125 OPC_CheckPredicate, 99, // 18285: check predicate 99
10126 OPC_Decode, 177, 126, 142, 1, // 18287: decode to VFNMSAC_VF using decoder 142
10127 // 18287: }
10128 48, 7, // 18292: case 0x30: {
10129 OPC_CheckPredicate, 99, // 18294: check predicate 99
10130 OPC_Decode, 207, 126, 138, 1, // 18296: decode to VFWADD_VF using decoder 138
10131 // 18296: }
10132 50, 7, // 18301: case 0x32: {
10133 OPC_CheckPredicate, 99, // 18303: check predicate 99
10134 OPC_Decode, 242, 126, 138, 1, // 18305: decode to VFWSUB_VF using decoder 138
10135 // 18305: }
10136 52, 7, // 18310: case 0x34: {
10137 OPC_CheckPredicate, 99, // 18312: check predicate 99
10138 OPC_Decode, 209, 126, 138, 1, // 18314: decode to VFWADD_WF using decoder 138
10139 // 18314: }
10140 54, 7, // 18319: case 0x36: {
10141 OPC_CheckPredicate, 99, // 18321: check predicate 99
10142 OPC_Decode, 244, 126, 138, 1, // 18323: decode to VFWSUB_WF using decoder 138
10143 // 18323: }
10144 56, 7, // 18328: case 0x38: {
10145 OPC_CheckPredicate, 99, // 18330: check predicate 99
10146 OPC_Decode, 234, 126, 138, 1, // 18332: decode to VFWMUL_VF using decoder 138
10147 // 18332: }
10148 59, 7, // 18337: case 0x3b: {
10149 OPC_CheckPredicate, 102, // 18339: check predicate 102
10150 OPC_Decode, 222, 126, 142, 1, // 18341: decode to VFWMACCBF16_VF using decoder 142
10151 // 18341: }
10152 60, 7, // 18346: case 0x3c: {
10153 OPC_CheckPredicate, 99, // 18348: check predicate 99
10154 OPC_Decode, 224, 126, 142, 1, // 18350: decode to VFWMACC_VF using decoder 142
10155 // 18350: }
10156 61, 7, // 18355: case 0x3d: {
10157 OPC_CheckPredicate, 99, // 18357: check predicate 99
10158 OPC_Decode, 236, 126, 142, 1, // 18359: decode to VFWNMACC_VF using decoder 142
10159 // 18359: }
10160 62, 7, // 18364: case 0x3e: {
10161 OPC_CheckPredicate, 99, // 18366: check predicate 99
10162 OPC_Decode, 232, 126, 142, 1, // 18368: decode to VFWMSAC_VF using decoder 142
10163 // 18368: }
10164 63, 0, // 18373: case 0x3f: {
10165 OPC_CheckPredicate, 99, // 18375: check predicate 99
10166 OPC_Decode, 238, 126, 142, 1, // 18377: decode to VFWNMSAC_VF using decoder 142
10167 // 18377: }
10168 // 18377: } // switch Inst[31:26]
10169 // 18377: }
10170 6, 139, 3, // 18382: case 0x6: {
10171 OPC_SwitchField, 26, 6, // 18385: switch Inst[31:26] {
10172 8, 7, // 18388: case 0x8: {
10173 OPC_CheckPredicate, 22, // 18390: check predicate 22
10174 OPC_Decode, 200, 125, 135, 1, // 18392: decode to VAADDU_VX using decoder 135
10175 // 18392: }
10176 9, 7, // 18397: case 0x9: {
10177 OPC_CheckPredicate, 22, // 18399: check predicate 22
10178 OPC_Decode, 202, 125, 135, 1, // 18401: decode to VAADD_VX using decoder 135
10179 // 18401: }
10180 10, 7, // 18406: case 0xa: {
10181 OPC_CheckPredicate, 22, // 18408: check predicate 22
10182 OPC_Decode, 229, 125, 135, 1, // 18410: decode to VASUBU_VX using decoder 135
10183 // 18410: }
10184 11, 7, // 18415: case 0xb: {
10185 OPC_CheckPredicate, 22, // 18417: check predicate 22
10186 OPC_Decode, 231, 125, 135, 1, // 18419: decode to VASUB_VX using decoder 135
10187 // 18419: }
10188 12, 7, // 18424: case 0xc: {
10189 OPC_CheckPredicate, 103, // 18426: check predicate 103
10190 OPC_Decode, 237, 125, 135, 1, // 18428: decode to VCLMUL_VX using decoder 135
10191 // 18428: }
10192 13, 7, // 18433: case 0xd: {
10193 OPC_CheckPredicate, 103, // 18435: check predicate 103
10194 OPC_Decode, 235, 125, 135, 1, // 18437: decode to VCLMULH_VX using decoder 135
10195 // 18437: }
10196 14, 8, // 18442: case 0xe: {
10197 OPC_CheckPredicate, 22, // 18444: check predicate 22
10198 OPC_Decode, 238, 129, 1, 135, 1, // 18446: decode to VSLIDE1UP_VX using decoder 135
10199 // 18446: }
10200 15, 8, // 18452: case 0xf: {
10201 OPC_CheckPredicate, 22, // 18454: check predicate 22
10202 OPC_Decode, 237, 129, 1, 135, 1, // 18456: decode to VSLIDE1DOWN_VX using decoder 135
10203 // 18456: }
10204 16, 12, // 18462: case 0x10: {
10205 OPC_CheckPredicate, 22, // 18464: check predicate 22
10206 OPC_CheckField, 20, 6, 32, // 18466: check Inst[25:20] == 0x20
10207 OPC_Decode, 150, 129, 1, 143, 1, // 18470: decode to VMV_S_X using decoder 143
10208 // 18470: }
10209 32, 7, // 18476: case 0x20: {
10210 OPC_CheckPredicate, 22, // 18478: check predicate 22
10211 OPC_Decode, 244, 125, 135, 1, // 18480: decode to VDIVU_VX using decoder 135
10212 // 18480: }
10213 33, 7, // 18485: case 0x21: {
10214 OPC_CheckPredicate, 22, // 18487: check predicate 22
10215 OPC_Decode, 246, 125, 135, 1, // 18489: decode to VDIV_VX using decoder 135
10216 // 18489: }
10217 34, 8, // 18494: case 0x22: {
10218 OPC_CheckPredicate, 22, // 18496: check predicate 22
10219 OPC_Decode, 197, 129, 1, 135, 1, // 18498: decode to VREMU_VX using decoder 135
10220 // 18498: }
10221 35, 8, // 18504: case 0x23: {
10222 OPC_CheckPredicate, 22, // 18506: check predicate 22
10223 OPC_Decode, 199, 129, 1, 135, 1, // 18508: decode to VREM_VX using decoder 135
10224 // 18508: }
10225 36, 8, // 18514: case 0x24: {
10226 OPC_CheckPredicate, 22, // 18516: check predicate 22
10227 OPC_Decode, 141, 129, 1, 135, 1, // 18518: decode to VMULHU_VX using decoder 135
10228 // 18518: }
10229 37, 8, // 18524: case 0x25: {
10230 OPC_CheckPredicate, 22, // 18526: check predicate 22
10231 OPC_Decode, 145, 129, 1, 135, 1, // 18528: decode to VMUL_VX using decoder 135
10232 // 18528: }
10233 38, 8, // 18534: case 0x26: {
10234 OPC_CheckPredicate, 22, // 18536: check predicate 22
10235 OPC_Decode, 139, 129, 1, 135, 1, // 18538: decode to VMULHSU_VX using decoder 135
10236 // 18538: }
10237 39, 8, // 18544: case 0x27: {
10238 OPC_CheckPredicate, 22, // 18546: check predicate 22
10239 OPC_Decode, 143, 129, 1, 135, 1, // 18548: decode to VMULH_VX using decoder 135
10240 // 18548: }
10241 40, 7, // 18554: case 0x28: {
10242 OPC_CheckPredicate, 105, // 18556: check predicate 105
10243 OPC_Decode, 251, 125, 144, 1, // 18558: decode to VDOT4AU_VX using decoder 144
10244 // 18558: }
10245 41, 8, // 18563: case 0x29: {
10246 OPC_CheckPredicate, 22, // 18565: check predicate 22
10247 OPC_Decode, 182, 128, 1, 145, 1, // 18567: decode to VMADD_VX using decoder 145
10248 // 18567: }
10249 42, 7, // 18573: case 0x2a: {
10250 OPC_CheckPredicate, 105, // 18575: check predicate 105
10251 OPC_Decode, 248, 125, 144, 1, // 18577: decode to VDOT4ASU_VX using decoder 144
10252 // 18577: }
10253 43, 8, // 18582: case 0x2b: {
10254 OPC_CheckPredicate, 22, // 18584: check predicate 22
10255 OPC_Decode, 166, 129, 1, 145, 1, // 18586: decode to VNMSUB_VX using decoder 145
10256 // 18586: }
10257 44, 7, // 18592: case 0x2c: {
10258 OPC_CheckPredicate, 105, // 18594: check predicate 105
10259 OPC_Decode, 253, 125, 144, 1, // 18596: decode to VDOT4A_VX using decoder 144
10260 // 18596: }
10261 45, 8, // 18601: case 0x2d: {
10262 OPC_CheckPredicate, 22, // 18603: check predicate 22
10263 OPC_Decode, 174, 128, 1, 145, 1, // 18605: decode to VMACC_VX using decoder 145
10264 // 18605: }
10265 46, 7, // 18611: case 0x2e: {
10266 OPC_CheckPredicate, 105, // 18613: check predicate 105
10267 OPC_Decode, 249, 125, 144, 1, // 18615: decode to VDOT4AUS_VX using decoder 144
10268 // 18615: }
10269 47, 8, // 18620: case 0x2f: {
10270 OPC_CheckPredicate, 22, // 18622: check predicate 22
10271 OPC_Decode, 164, 129, 1, 145, 1, // 18624: decode to VNMSAC_VX using decoder 145
10272 // 18624: }
10273 48, 8, // 18630: case 0x30: {
10274 OPC_CheckPredicate, 22, // 18632: check predicate 22
10275 OPC_Decode, 148, 131, 1, 135, 1, // 18634: decode to VWADDU_VX using decoder 135
10276 // 18634: }
10277 49, 8, // 18640: case 0x31: {
10278 OPC_CheckPredicate, 22, // 18642: check predicate 22
10279 OPC_Decode, 152, 131, 1, 135, 1, // 18644: decode to VWADD_VX using decoder 135
10280 // 18644: }
10281 50, 8, // 18650: case 0x32: {
10282 OPC_CheckPredicate, 22, // 18652: check predicate 22
10283 OPC_Decode, 175, 131, 1, 135, 1, // 18654: decode to VWSUBU_VX using decoder 135
10284 // 18654: }
10285 51, 8, // 18660: case 0x33: {
10286 OPC_CheckPredicate, 22, // 18662: check predicate 22
10287 OPC_Decode, 179, 131, 1, 135, 1, // 18664: decode to VWSUB_VX using decoder 135
10288 // 18664: }
10289 52, 8, // 18670: case 0x34: {
10290 OPC_CheckPredicate, 22, // 18672: check predicate 22
10291 OPC_Decode, 150, 131, 1, 135, 1, // 18674: decode to VWADDU_WX using decoder 135
10292 // 18674: }
10293 53, 8, // 18680: case 0x35: {
10294 OPC_CheckPredicate, 22, // 18682: check predicate 22
10295 OPC_Decode, 154, 131, 1, 135, 1, // 18684: decode to VWADD_WX using decoder 135
10296 // 18684: }
10297 54, 8, // 18690: case 0x36: {
10298 OPC_CheckPredicate, 22, // 18692: check predicate 22
10299 OPC_Decode, 177, 131, 1, 135, 1, // 18694: decode to VWSUBU_WX using decoder 135
10300 // 18694: }
10301 55, 8, // 18700: case 0x37: {
10302 OPC_CheckPredicate, 22, // 18702: check predicate 22
10303 OPC_Decode, 181, 131, 1, 135, 1, // 18704: decode to VWSUB_WX using decoder 135
10304 // 18704: }
10305 56, 8, // 18710: case 0x38: {
10306 OPC_CheckPredicate, 22, // 18712: check predicate 22
10307 OPC_Decode, 166, 131, 1, 135, 1, // 18714: decode to VWMULU_VX using decoder 135
10308 // 18714: }
10309 58, 8, // 18720: case 0x3a: {
10310 OPC_CheckPredicate, 22, // 18722: check predicate 22
10311 OPC_Decode, 164, 131, 1, 135, 1, // 18724: decode to VWMULSU_VX using decoder 135
10312 // 18724: }
10313 59, 8, // 18730: case 0x3b: {
10314 OPC_CheckPredicate, 22, // 18732: check predicate 22
10315 OPC_Decode, 168, 131, 1, 135, 1, // 18734: decode to VWMUL_VX using decoder 135
10316 // 18734: }
10317 60, 8, // 18740: case 0x3c: {
10318 OPC_CheckPredicate, 22, // 18742: check predicate 22
10319 OPC_Decode, 159, 131, 1, 145, 1, // 18744: decode to VWMACCU_VX using decoder 145
10320 // 18744: }
10321 61, 8, // 18750: case 0x3d: {
10322 OPC_CheckPredicate, 22, // 18752: check predicate 22
10323 OPC_Decode, 161, 131, 1, 145, 1, // 18754: decode to VWMACC_VX using decoder 145
10324 // 18754: }
10325 62, 8, // 18760: case 0x3e: {
10326 OPC_CheckPredicate, 22, // 18762: check predicate 22
10327 OPC_Decode, 157, 131, 1, 145, 1, // 18764: decode to VWMACCUS_VX using decoder 145
10328 // 18764: }
10329 63, 0, // 18770: case 0x3f: {
10330 OPC_CheckPredicate, 22, // 18772: check predicate 22
10331 OPC_Decode, 156, 131, 1, 145, 1, // 18774: decode to VWMACCSU_VX using decoder 145
10332 // 18774: }
10333 // 18774: } // switch Inst[31:26]
10334 // 18774: }
10335 7, 0, // 18780: case 0x7: {
10336 OPC_SwitchField, 31, 1, // 18782: switch Inst[31] {
10337 0, 8, // 18785: case 0x0: {
10338 OPC_CheckPredicate, 22, // 18787: check predicate 22
10339 OPC_Decode, 230, 129, 1, 146, 1, // 18789: decode to VSETVLI using decoder 146
10340 // 18789: }
10341 1, 0, // 18795: case 0x1: {
10342 OPC_SwitchField, 30, 1, // 18797: switch Inst[30] {
10343 0, 11, // 18800: case 0x0: {
10344 OPC_CheckPredicate, 22, // 18802: check predicate 22
10345 OPC_CheckField, 25, 5, 0, // 18804: check Inst[29:25] == 0x0
10346 OPC_Decode, 229, 129, 1, 31, // 18808: decode to VSETVL using decoder 31
10347 // 18808: }
10348 1, 0, // 18813: case 0x1: {
10349 OPC_CheckPredicate, 22, // 18815: check predicate 22
10350 OPC_Decode, 228, 129, 1, 147, 1, // 18817: decode to VSETIVLI using decoder 147
10351 // 18817: }
10352 // 18817: } // switch Inst[30]
10353 // 18817: }
10354 // 18817: } // switch Inst[31]
10355 // 18817: }
10356 // 18817: } // switch Inst[14:12]
10357 // 18817: }
10358 99, 63, // 18823: case 0x63: {
10359 OPC_SwitchField, 12, 3, // 18825: switch Inst[14:12] {
10360 0, 5, // 18828: case 0x0: {
10361 OPC_Decode, 179, 110, 148, 1, // 18830: decode to BEQ using decoder 148
10362 // 18830: }
10363 1, 5, // 18835: case 0x1: {
10364 OPC_Decode, 189, 110, 148, 1, // 18837: decode to BNE using decoder 148
10365 // 18837: }
10366 2, 7, // 18842: case 0x2: {
10367 OPC_CheckPredicate, 106, // 18844: check predicate 106
10368 OPC_Decode, 180, 110, 149, 1, // 18846: decode to BEQI using decoder 149
10369 // 18846: }
10370 3, 7, // 18851: case 0x3: {
10371 OPC_CheckPredicate, 106, // 18853: check predicate 106
10372 OPC_Decode, 190, 110, 149, 1, // 18855: decode to BNEI using decoder 149
10373 // 18855: }
10374 4, 5, // 18860: case 0x4: {
10375 OPC_Decode, 187, 110, 148, 1, // 18862: decode to BLT using decoder 148
10376 // 18862: }
10377 5, 5, // 18867: case 0x5: {
10378 OPC_Decode, 183, 110, 148, 1, // 18869: decode to BGE using decoder 148
10379 // 18869: }
10380 6, 5, // 18874: case 0x6: {
10381 OPC_Decode, 188, 110, 148, 1, // 18876: decode to BLTU using decoder 148
10382 // 18876: }
10383 7, 0, // 18881: case 0x7: {
10384 OPC_Decode, 184, 110, 148, 1, // 18883: decode to BGEU using decoder 148
10385 // 18883: }
10386 // 18883: } // switch Inst[14:12]
10387 // 18883: }
10388 103, 8, // 18888: case 0x67: {
10389 OPC_CheckField, 12, 3, 0, // 18890: check Inst[14:12] == 0x0
10390 OPC_Decode, 172, 116, 0, // 18894: decode to JALR using decoder 0
10391 // 18894: }
10392 111, 5, // 18898: case 0x6f: {
10393 OPC_Decode, 171, 116, 150, 1, // 18900: decode to JAL using decoder 150
10394 // 18900: }
10395 115, 218, 6, // 18905: case 0x73: {
10396 OPC_SwitchField, 12, 3, // 18908: switch Inst[14:12] {
10397 0, 246, 1, // 18911: case 0x0: {
10398 OPC_SwitchField, 25, 7, // 18914: switch Inst[31:25] {
10399 0, 51, // 18917: case 0x0: {
10400 OPC_SwitchField, 15, 10, // 18919: switch Inst[24:15] {
10401 0, 8, // 18922: case 0x0: {
10402 OPC_CheckField, 7, 5, 0, // 18924: check Inst[11:7] == 0x0
10403 OPC_Decode, 233, 113, 14, // 18928: decode to ECALL using decoder 14
10404 // 18928: }
10405 32, 8, // 18932: case 0x20: {
10406 OPC_CheckField, 7, 5, 0, // 18934: check Inst[11:7] == 0x0
10407 OPC_Decode, 232, 113, 14, // 18938: decode to EBREAK using decoder 14
10408 // 18938: }
10409 160, 3, 11, // 18942: case 0x1a0: {
10410 OPC_CheckPredicate, 107, // 18945: check predicate 107
10411 OPC_CheckField, 7, 5, 0, // 18947: check Inst[11:7] == 0x0
10412 OPC_Decode, 200, 131, 1, 14, // 18951: decode to WRS_NTO using decoder 14
10413 // 18951: }
10414 160, 7, 0, // 18956: case 0x3a0: {
10415 OPC_CheckPredicate, 107, // 18959: check predicate 107
10416 OPC_CheckField, 7, 5, 0, // 18961: check Inst[11:7] == 0x0
10417 OPC_Decode, 201, 131, 1, 14, // 18965: decode to WRS_STO using decoder 14
10418 // 18965: }
10419 // 18965: } // switch Inst[24:15]
10420 // 18965: }
10421 8, 38, // 18970: case 0x8: {
10422 OPC_SwitchField, 15, 10, // 18972: switch Inst[24:15] {
10423 64, 8, // 18975: case 0x40: {
10424 OPC_CheckField, 7, 5, 0, // 18977: check Inst[11:7] == 0x0
10425 OPC_Decode, 176, 124, 14, // 18981: decode to SRET using decoder 14
10426 // 18981: }
10427 128, 1, 10, // 18985: case 0x80: {
10428 OPC_CheckPredicate, 108, // 18988: check predicate 108
10429 OPC_CheckField, 7, 5, 0, // 18990: check Inst[11:7] == 0x0
10430 OPC_Decode, 153, 123, 14, // 18994: decode to SCTRCLR using decoder 14
10431 // 18994: }
10432 160, 1, 0, // 18998: case 0xa0: {
10433 OPC_CheckField, 7, 5, 0, // 19001: check Inst[11:7] == 0x0
10434 OPC_Decode, 193, 131, 1, 14, // 19005: decode to WFI using decoder 14
10435 // 19005: }
10436 // 19005: } // switch Inst[24:15]
10437 // 19005: }
10438 9, 9, // 19010: case 0x9: {
10439 OPC_CheckField, 7, 5, 0, // 19012: check Inst[11:7] == 0x0
10440 OPC_Decode, 169, 123, 151, 1, // 19016: decode to SFENCE_VMA using decoder 151
10441 // 19016: }
10442 11, 11, // 19021: case 0xb: {
10443 OPC_CheckPredicate, 109, // 19023: check predicate 109
10444 OPC_CheckField, 7, 5, 0, // 19025: check Inst[11:7] == 0x0
10445 OPC_Decode, 139, 124, 151, 1, // 19029: decode to SINVAL_VMA using decoder 151
10446 // 19029: }
10447 12, 27, // 19034: case 0xc: {
10448 OPC_SwitchField, 15, 10, // 19036: switch Inst[24:15] {
10449 0, 10, // 19039: case 0x0: {
10450 OPC_CheckPredicate, 109, // 19041: check predicate 109
10451 OPC_CheckField, 7, 5, 0, // 19043: check Inst[11:7] == 0x0
10452 OPC_Decode, 170, 123, 14, // 19047: decode to SFENCE_W_INVAL using decoder 14
10453 // 19047: }
10454 32, 0, // 19051: case 0x20: {
10455 OPC_CheckPredicate, 109, // 19053: check predicate 109
10456 OPC_CheckField, 7, 5, 0, // 19055: check Inst[11:7] == 0x0
10457 OPC_Decode, 168, 123, 14, // 19059: decode to SFENCE_INVAL_IR using decoder 14
10458 // 19059: }
10459 // 19059: } // switch Inst[24:15]
10460 // 19059: }
10461 17, 11, // 19063: case 0x11: {
10462 OPC_CheckPredicate, 110, // 19065: check predicate 110
10463 OPC_CheckField, 7, 5, 0, // 19067: check Inst[11:7] == 0x0
10464 OPC_Decode, 128, 116, 151, 1, // 19071: decode to HFENCE_VVMA using decoder 151
10465 // 19071: }
10466 19, 11, // 19076: case 0x13: {
10467 OPC_CheckPredicate, 109, // 19078: check predicate 109
10468 OPC_CheckField, 7, 5, 0, // 19080: check Inst[11:7] == 0x0
10469 OPC_Decode, 130, 116, 151, 1, // 19084: decode to HINVAL_VVMA using decoder 151
10470 // 19084: }
10471 24, 12, // 19089: case 0x18: {
10472 OPC_CheckField, 15, 10, 64, // 19091: check Inst[24:15] == 0x40
10473 OPC_CheckField, 7, 5, 0, // 19095: check Inst[11:7] == 0x0
10474 OPC_Decode, 167, 117, 14, // 19099: decode to MRET using decoder 14
10475 // 19099: }
10476 49, 11, // 19103: case 0x31: {
10477 OPC_CheckPredicate, 110, // 19105: check predicate 110
10478 OPC_CheckField, 7, 5, 0, // 19107: check Inst[11:7] == 0x0
10479 OPC_Decode, 255, 115, 151, 1, // 19111: decode to HFENCE_GVMA using decoder 151
10480 // 19111: }
10481 51, 11, // 19116: case 0x33: {
10482 OPC_CheckPredicate, 109, // 19118: check predicate 109
10483 OPC_CheckField, 7, 5, 0, // 19120: check Inst[11:7] == 0x0
10484 OPC_Decode, 129, 116, 151, 1, // 19124: decode to HINVAL_GVMA using decoder 151
10485 // 19124: }
10486 56, 14, // 19129: case 0x38: {
10487 OPC_CheckPredicate, 111, // 19131: check predicate 111
10488 OPC_CheckField, 15, 10, 64, // 19133: check Inst[24:15] == 0x40
10489 OPC_CheckField, 7, 5, 0, // 19137: check Inst[11:7] == 0x0
10490 OPC_Decode, 240, 116, 14, // 19141: decode to MNRET using decoder 14
10491 // 19141: }
10492 61, 0, // 19145: case 0x3d: {
10493 OPC_CheckField, 15, 10, 192, 4, // 19147: check Inst[24:15] == 0x240
10494 OPC_CheckField, 7, 5, 0, // 19152: check Inst[11:7] == 0x0
10495 OPC_Decode, 231, 113, 14, // 19156: decode to DRET using decoder 14
10496 // 19156: }
10497 // 19156: } // switch Inst[31:25]
10498 // 19156: }
10499 1, 21, // 19160: case 0x1: {
10500 OPC_Scope, 14, // 19162: try {
10501 OPC_CheckField, 7, 5, 0, // 19164: check Inst[11:7] == 0x0
10502 OPC_CheckField, 15, 17, 128, 128, 6, // 19168: check Inst[31:15] == 0x18000
10503 OPC_Decode, 190, 125, 14, // 19174: decode to UNIMP using decoder 14
10504 // 19174: } else try {
10505 OPC_Decode, 219, 110, 152, 1, // 19178: decode to CSRRW using decoder 152
10506 // 19178: }
10507 // 19178: }
10508 2, 5, // 19183: case 0x2: {
10509 OPC_Decode, 217, 110, 152, 1, // 19185: decode to CSRRS using decoder 152
10510 // 19185: }
10511 3, 5, // 19190: case 0x3: {
10512 OPC_Decode, 215, 110, 152, 1, // 19192: decode to CSRRC using decoder 152
10513 // 19192: }
10514 4, 161, 4, // 19197: case 0x4: {
10515 OPC_SwitchField, 25, 7, // 19200: switch Inst[31:25] {
10516 48, 19, // 19203: case 0x30: {
10517 OPC_SwitchField, 20, 5, // 19205: switch Inst[24:20] {
10518 0, 6, // 19208: case 0x0: {
10519 OPC_CheckPredicate, 110, // 19210: check predicate 110
10520 OPC_Decode, 133, 116, 17, // 19212: decode to HLV_B using decoder 17
10521 // 19212: }
10522 1, 0, // 19216: case 0x1: {
10523 OPC_CheckPredicate, 110, // 19218: check predicate 110
10524 OPC_Decode, 134, 116, 17, // 19220: decode to HLV_BU using decoder 17
10525 // 19220: }
10526 // 19220: } // switch Inst[24:20]
10527 // 19220: }
10528 49, 10, // 19224: case 0x31: {
10529 OPC_CheckPredicate, 110, // 19226: check predicate 110
10530 OPC_CheckField, 7, 5, 0, // 19228: check Inst[11:7] == 0x0
10531 OPC_Decode, 140, 116, 57, // 19232: decode to HSV_B using decoder 57
10532 // 19232: }
10533 50, 27, // 19236: case 0x32: {
10534 OPC_SwitchField, 20, 5, // 19238: switch Inst[24:20] {
10535 0, 6, // 19241: case 0x0: {
10536 OPC_CheckPredicate, 110, // 19243: check predicate 110
10537 OPC_Decode, 136, 116, 17, // 19245: decode to HLV_H using decoder 17
10538 // 19245: }
10539 1, 6, // 19249: case 0x1: {
10540 OPC_CheckPredicate, 110, // 19251: check predicate 110
10541 OPC_Decode, 137, 116, 17, // 19253: decode to HLV_HU using decoder 17
10542 // 19253: }
10543 3, 0, // 19257: case 0x3: {
10544 OPC_CheckPredicate, 110, // 19259: check predicate 110
10545 OPC_Decode, 131, 116, 17, // 19261: decode to HLVX_HU using decoder 17
10546 // 19261: }
10547 // 19261: } // switch Inst[24:20]
10548 // 19261: }
10549 51, 10, // 19265: case 0x33: {
10550 OPC_CheckPredicate, 110, // 19267: check predicate 110
10551 OPC_CheckField, 7, 5, 0, // 19269: check Inst[11:7] == 0x0
10552 OPC_Decode, 142, 116, 57, // 19273: decode to HSV_H using decoder 57
10553 // 19273: }
10554 52, 27, // 19277: case 0x34: {
10555 OPC_SwitchField, 20, 5, // 19279: switch Inst[24:20] {
10556 0, 6, // 19282: case 0x0: {
10557 OPC_CheckPredicate, 110, // 19284: check predicate 110
10558 OPC_Decode, 138, 116, 17, // 19286: decode to HLV_W using decoder 17
10559 // 19286: }
10560 1, 6, // 19290: case 0x1: {
10561 OPC_CheckPredicate, 112, // 19292: check predicate 112
10562 OPC_Decode, 139, 116, 17, // 19294: decode to HLV_WU using decoder 17
10563 // 19294: }
10564 3, 0, // 19298: case 0x3: {
10565 OPC_CheckPredicate, 110, // 19300: check predicate 110
10566 OPC_Decode, 132, 116, 17, // 19302: decode to HLVX_WU using decoder 17
10567 // 19302: }
10568 // 19302: } // switch Inst[24:20]
10569 // 19302: }
10570 53, 10, // 19306: case 0x35: {
10571 OPC_CheckPredicate, 110, // 19308: check predicate 110
10572 OPC_CheckField, 7, 5, 0, // 19310: check Inst[11:7] == 0x0
10573 OPC_Decode, 143, 116, 57, // 19314: decode to HSV_W using decoder 57
10574 // 19314: }
10575 54, 10, // 19318: case 0x36: {
10576 OPC_CheckPredicate, 112, // 19320: check predicate 112
10577 OPC_CheckField, 20, 5, 0, // 19322: check Inst[24:20] == 0x0
10578 OPC_Decode, 135, 116, 17, // 19326: decode to HLV_D using decoder 17
10579 // 19326: }
10580 55, 10, // 19330: case 0x37: {
10581 OPC_CheckPredicate, 112, // 19332: check predicate 112
10582 OPC_CheckField, 7, 5, 0, // 19334: check Inst[11:7] == 0x0
10583 OPC_Decode, 141, 116, 57, // 19338: decode to HSV_D using decoder 57
10584 // 19338: }
10585 64, 35, // 19342: case 0x40: {
10586 OPC_SwitchField, 20, 5, // 19344: switch Inst[24:20] {
10587 28, 6, // 19347: case 0x1c: {
10588 OPC_CheckPredicate, 113, // 19349: check predicate 113
10589 OPC_Decode, 249, 116, 17, // 19351: decode to MOP_R_0 using decoder 17
10590 // 19351: }
10591 29, 6, // 19355: case 0x1d: {
10592 OPC_CheckPredicate, 113, // 19357: check predicate 113
10593 OPC_Decode, 250, 116, 17, // 19359: decode to MOP_R_1 using decoder 17
10594 // 19359: }
10595 30, 6, // 19363: case 0x1e: {
10596 OPC_CheckPredicate, 113, // 19365: check predicate 113
10597 OPC_Decode, 133, 117, 17, // 19367: decode to MOP_R_2 using decoder 17
10598 // 19367: }
10599 31, 0, // 19371: case 0x1f: {
10600 OPC_CheckPredicate, 113, // 19373: check predicate 113
10601 OPC_Decode, 144, 117, 17, // 19375: decode to MOP_R_3 using decoder 17
10602 // 19375: }
10603 // 19375: } // switch Inst[24:20]
10604 // 19375: }
10605 65, 6, // 19379: case 0x41: {
10606 OPC_CheckPredicate, 113, // 19381: check predicate 113
10607 OPC_Decode, 241, 116, 31, // 19383: decode to MOP_RR_0 using decoder 31
10608 // 19383: }
10609 66, 35, // 19387: case 0x42: {
10610 OPC_SwitchField, 20, 5, // 19389: switch Inst[24:20] {
10611 28, 6, // 19392: case 0x1c: {
10612 OPC_CheckPredicate, 113, // 19394: check predicate 113
10613 OPC_Decode, 147, 117, 17, // 19396: decode to MOP_R_4 using decoder 17
10614 // 19396: }
10615 29, 6, // 19400: case 0x1d: {
10616 OPC_CheckPredicate, 113, // 19402: check predicate 113
10617 OPC_Decode, 148, 117, 17, // 19404: decode to MOP_R_5 using decoder 17
10618 // 19404: }
10619 30, 6, // 19408: case 0x1e: {
10620 OPC_CheckPredicate, 113, // 19410: check predicate 113
10621 OPC_Decode, 149, 117, 17, // 19412: decode to MOP_R_6 using decoder 17
10622 // 19412: }
10623 31, 0, // 19416: case 0x1f: {
10624 OPC_CheckPredicate, 113, // 19418: check predicate 113
10625 OPC_Decode, 150, 117, 17, // 19420: decode to MOP_R_7 using decoder 17
10626 // 19420: }
10627 // 19420: } // switch Inst[24:20]
10628 // 19420: }
10629 67, 6, // 19424: case 0x43: {
10630 OPC_CheckPredicate, 113, // 19426: check predicate 113
10631 OPC_Decode, 242, 116, 31, // 19428: decode to MOP_RR_1 using decoder 31
10632 // 19428: }
10633 68, 35, // 19432: case 0x44: {
10634 OPC_SwitchField, 20, 5, // 19434: switch Inst[24:20] {
10635 28, 6, // 19437: case 0x1c: {
10636 OPC_CheckPredicate, 113, // 19439: check predicate 113
10637 OPC_Decode, 151, 117, 17, // 19441: decode to MOP_R_8 using decoder 17
10638 // 19441: }
10639 29, 6, // 19445: case 0x1d: {
10640 OPC_CheckPredicate, 113, // 19447: check predicate 113
10641 OPC_Decode, 152, 117, 17, // 19449: decode to MOP_R_9 using decoder 17
10642 // 19449: }
10643 30, 6, // 19453: case 0x1e: {
10644 OPC_CheckPredicate, 113, // 19455: check predicate 113
10645 OPC_Decode, 251, 116, 17, // 19457: decode to MOP_R_10 using decoder 17
10646 // 19457: }
10647 31, 0, // 19461: case 0x1f: {
10648 OPC_CheckPredicate, 113, // 19463: check predicate 113
10649 OPC_Decode, 252, 116, 17, // 19465: decode to MOP_R_11 using decoder 17
10650 // 19465: }
10651 // 19465: } // switch Inst[24:20]
10652 // 19465: }
10653 69, 6, // 19469: case 0x45: {
10654 OPC_CheckPredicate, 113, // 19471: check predicate 113
10655 OPC_Decode, 243, 116, 31, // 19473: decode to MOP_RR_2 using decoder 31
10656 // 19473: }
10657 70, 35, // 19477: case 0x46: {
10658 OPC_SwitchField, 20, 5, // 19479: switch Inst[24:20] {
10659 28, 6, // 19482: case 0x1c: {
10660 OPC_CheckPredicate, 113, // 19484: check predicate 113
10661 OPC_Decode, 253, 116, 17, // 19486: decode to MOP_R_12 using decoder 17
10662 // 19486: }
10663 29, 6, // 19490: case 0x1d: {
10664 OPC_CheckPredicate, 113, // 19492: check predicate 113
10665 OPC_Decode, 254, 116, 17, // 19494: decode to MOP_R_13 using decoder 17
10666 // 19494: }
10667 30, 6, // 19498: case 0x1e: {
10668 OPC_CheckPredicate, 113, // 19500: check predicate 113
10669 OPC_Decode, 255, 116, 17, // 19502: decode to MOP_R_14 using decoder 17
10670 // 19502: }
10671 31, 0, // 19506: case 0x1f: {
10672 OPC_CheckPredicate, 113, // 19508: check predicate 113
10673 OPC_Decode, 128, 117, 17, // 19510: decode to MOP_R_15 using decoder 17
10674 // 19510: }
10675 // 19510: } // switch Inst[24:20]
10676 // 19510: }
10677 71, 6, // 19514: case 0x47: {
10678 OPC_CheckPredicate, 113, // 19516: check predicate 113
10679 OPC_Decode, 244, 116, 31, // 19518: decode to MOP_RR_3 using decoder 31
10680 // 19518: }
10681 96, 35, // 19522: case 0x60: {
10682 OPC_SwitchField, 20, 5, // 19524: switch Inst[24:20] {
10683 28, 6, // 19527: case 0x1c: {
10684 OPC_CheckPredicate, 113, // 19529: check predicate 113
10685 OPC_Decode, 129, 117, 17, // 19531: decode to MOP_R_16 using decoder 17
10686 // 19531: }
10687 29, 6, // 19535: case 0x1d: {
10688 OPC_CheckPredicate, 113, // 19537: check predicate 113
10689 OPC_Decode, 130, 117, 17, // 19539: decode to MOP_R_17 using decoder 17
10690 // 19539: }
10691 30, 6, // 19543: case 0x1e: {
10692 OPC_CheckPredicate, 113, // 19545: check predicate 113
10693 OPC_Decode, 131, 117, 17, // 19547: decode to MOP_R_18 using decoder 17
10694 // 19547: }
10695 31, 0, // 19551: case 0x1f: {
10696 OPC_CheckPredicate, 113, // 19553: check predicate 113
10697 OPC_Decode, 132, 117, 17, // 19555: decode to MOP_R_19 using decoder 17
10698 // 19555: }
10699 // 19555: } // switch Inst[24:20]
10700 // 19555: }
10701 97, 6, // 19559: case 0x61: {
10702 OPC_CheckPredicate, 113, // 19561: check predicate 113
10703 OPC_Decode, 245, 116, 31, // 19563: decode to MOP_RR_4 using decoder 31
10704 // 19563: }
10705 98, 35, // 19567: case 0x62: {
10706 OPC_SwitchField, 20, 5, // 19569: switch Inst[24:20] {
10707 28, 6, // 19572: case 0x1c: {
10708 OPC_CheckPredicate, 113, // 19574: check predicate 113
10709 OPC_Decode, 134, 117, 17, // 19576: decode to MOP_R_20 using decoder 17
10710 // 19576: }
10711 29, 6, // 19580: case 0x1d: {
10712 OPC_CheckPredicate, 113, // 19582: check predicate 113
10713 OPC_Decode, 135, 117, 17, // 19584: decode to MOP_R_21 using decoder 17
10714 // 19584: }
10715 30, 6, // 19588: case 0x1e: {
10716 OPC_CheckPredicate, 113, // 19590: check predicate 113
10717 OPC_Decode, 136, 117, 17, // 19592: decode to MOP_R_22 using decoder 17
10718 // 19592: }
10719 31, 0, // 19596: case 0x1f: {
10720 OPC_CheckPredicate, 113, // 19598: check predicate 113
10721 OPC_Decode, 137, 117, 17, // 19600: decode to MOP_R_23 using decoder 17
10722 // 19600: }
10723 // 19600: } // switch Inst[24:20]
10724 // 19600: }
10725 99, 6, // 19604: case 0x63: {
10726 OPC_CheckPredicate, 113, // 19606: check predicate 113
10727 OPC_Decode, 246, 116, 31, // 19608: decode to MOP_RR_5 using decoder 31
10728 // 19608: }
10729 100, 35, // 19612: case 0x64: {
10730 OPC_SwitchField, 20, 5, // 19614: switch Inst[24:20] {
10731 28, 6, // 19617: case 0x1c: {
10732 OPC_CheckPredicate, 113, // 19619: check predicate 113
10733 OPC_Decode, 138, 117, 17, // 19621: decode to MOP_R_24 using decoder 17
10734 // 19621: }
10735 29, 6, // 19625: case 0x1d: {
10736 OPC_CheckPredicate, 113, // 19627: check predicate 113
10737 OPC_Decode, 139, 117, 17, // 19629: decode to MOP_R_25 using decoder 17
10738 // 19629: }
10739 30, 6, // 19633: case 0x1e: {
10740 OPC_CheckPredicate, 113, // 19635: check predicate 113
10741 OPC_Decode, 140, 117, 17, // 19637: decode to MOP_R_26 using decoder 17
10742 // 19637: }
10743 31, 0, // 19641: case 0x1f: {
10744 OPC_CheckPredicate, 113, // 19643: check predicate 113
10745 OPC_Decode, 141, 117, 17, // 19645: decode to MOP_R_27 using decoder 17
10746 // 19645: }
10747 // 19645: } // switch Inst[24:20]
10748 // 19645: }
10749 101, 6, // 19649: case 0x65: {
10750 OPC_CheckPredicate, 113, // 19651: check predicate 113
10751 OPC_Decode, 247, 116, 31, // 19653: decode to MOP_RR_6 using decoder 31
10752 // 19653: }
10753 102, 61, // 19657: case 0x66: {
10754 OPC_SwitchField, 20, 5, // 19659: switch Inst[24:20] {
10755 28, 32, // 19662: case 0x1c: {
10756 OPC_Scope, 11, // 19664: try {
10757 OPC_CheckField, 7, 5, 0, // 19666: check Inst[11:7] == 0x0
10758 OPC_CheckPredicate, 113, // 19670: check predicate 113
10759 OPC_Decode, 197, 124, 153, 1, // 19672: decode to SSPOPCHK using decoder 153
10760 OPC_Scope, 11, // 19677: } else try {
10761 OPC_CheckField, 15, 5, 0, // 19679: check Inst[19:15] == 0x0
10762 OPC_CheckPredicate, 113, // 19683: check predicate 113
10763 OPC_Decode, 199, 124, 154, 1, // 19685: decode to SSRDP using decoder 154
10764 // 19685: } else try {
10765 OPC_CheckPredicate, 113, // 19690: check predicate 113
10766 OPC_Decode, 142, 117, 17, // 19692: decode to MOP_R_28 using decoder 17
10767 // 19692: }
10768 // 19692: }
10769 29, 6, // 19696: case 0x1d: {
10770 OPC_CheckPredicate, 113, // 19698: check predicate 113
10771 OPC_Decode, 143, 117, 17, // 19700: decode to MOP_R_29 using decoder 17
10772 // 19700: }
10773 30, 6, // 19704: case 0x1e: {
10774 OPC_CheckPredicate, 113, // 19706: check predicate 113
10775 OPC_Decode, 145, 117, 17, // 19708: decode to MOP_R_30 using decoder 17
10776 // 19708: }
10777 31, 0, // 19712: case 0x1f: {
10778 OPC_CheckPredicate, 113, // 19714: check predicate 113
10779 OPC_Decode, 146, 117, 17, // 19716: decode to MOP_R_31 using decoder 17
10780 // 19716: }
10781 // 19716: } // switch Inst[24:20]
10782 // 19716: }
10783 103, 0, // 19720: case 0x67: {
10784 OPC_Scope, 15, // 19722: try {
10785 OPC_CheckField, 7, 5, 0, // 19724: check Inst[11:7] == 0x0
10786 OPC_CheckPredicate, 113, // 19728: check predicate 113
10787 OPC_CheckField, 15, 5, 0, // 19730: check Inst[19:15] == 0x0
10788 OPC_Decode, 198, 124, 155, 1, // 19734: decode to SSPUSH using decoder 155
10789 // 19734: } else try {
10790 OPC_CheckPredicate, 113, // 19739: check predicate 113
10791 OPC_Decode, 248, 116, 31, // 19741: decode to MOP_RR_7 using decoder 31
10792 // 19741: }
10793 // 19741: }
10794 // 19741: } // switch Inst[31:25]
10795 // 19741: }
10796 5, 5, // 19745: case 0x5: {
10797 OPC_Decode, 220, 110, 156, 1, // 19747: decode to CSRRWI using decoder 156
10798 // 19747: }
10799 6, 5, // 19752: case 0x6: {
10800 OPC_Decode, 218, 110, 156, 1, // 19754: decode to CSRRSI using decoder 156
10801 // 19754: }
10802 7, 0, // 19759: case 0x7: {
10803 OPC_Decode, 216, 110, 156, 1, // 19761: decode to CSRRCI using decoder 156
10804 // 19761: }
10805 // 19761: } // switch Inst[14:12]
10806 // 19761: }
10807 119, 223, 3, // 19766: case 0x77: {
10808 OPC_SwitchField, 26, 6, // 19769: switch Inst[31:26] {
10809 32, 15, // 19772: case 0x20: {
10810 OPC_CheckPredicate, 114, // 19774: check predicate 114
10811 OPC_CheckField, 25, 1, 1, // 19776: check Inst[25] == 0x1
10812 OPC_CheckField, 12, 3, 2, // 19780: check Inst[14:12] == 0x2
10813 OPC_Decode, 247, 129, 1, 114, // 19784: decode to VSM3ME_VV using decoder 114
10814 // 19784: }
10815 33, 16, // 19789: case 0x21: {
10816 OPC_CheckPredicate, 115, // 19791: check predicate 115
10817 OPC_CheckField, 25, 1, 1, // 19793: check Inst[25] == 0x1
10818 OPC_CheckField, 12, 3, 2, // 19797: check Inst[14:12] == 0x2
10819 OPC_Decode, 248, 129, 1, 157, 1, // 19801: decode to VSM4K_VI using decoder 157
10820 // 19801: }
10821 34, 15, // 19807: case 0x22: {
10822 OPC_CheckPredicate, 116, // 19809: check predicate 116
10823 OPC_CheckField, 25, 1, 1, // 19811: check Inst[25] == 0x1
10824 OPC_CheckField, 12, 3, 2, // 19815: check Inst[14:12] == 0x2
10825 OPC_Decode, 220, 125, 157, 1, // 19819: decode to VAESKF1_VI using decoder 157
10826 // 19819: }
10827 35, 15, // 19824: case 0x23: {
10828 OPC_CheckPredicate, 117, // 19826: check predicate 117
10829 OPC_CheckField, 25, 1, 1, // 19828: check Inst[25] == 0x1
10830 OPC_CheckField, 12, 3, 2, // 19832: check Inst[14:12] == 0x2
10831 OPC_Decode, 246, 126, 158, 1, // 19836: decode to VGHSH_VS using decoder 158
10832 // 19836: }
10833 36, 10, // 19841: case 0x24: {
10834 OPC_CheckPredicate, 118, // 19843: check predicate 118
10835 OPC_CheckField, 12, 3, 1, // 19845: check Inst[14:12] == 0x1
10836 OPC_Decode, 220, 126, 124, // 19849: decode to VFWDOTA_VV using decoder 124
10837 // 19849: }
10838 38, 20, // 19853: case 0x26: {
10839 OPC_SwitchField, 12, 3, // 19855: switch Inst[14:12] {
10840 0, 7, // 19858: case 0x0: {
10841 OPC_CheckPredicate, 119, // 19860: check predicate 119
10842 OPC_Decode, 187, 129, 1, 124, // 19862: decode to VQWDOTAU_VV using decoder 124
10843 // 19862: }
10844 1, 0, // 19867: case 0x1: {
10845 OPC_CheckPredicate, 120, // 19869: check predicate 120
10846 OPC_Decode, 187, 126, 124, // 19871: decode to VFQWDOTA_VV using decoder 124
10847 // 19871: }
10848 // 19871: } // switch Inst[14:12]
10849 // 19871: }
10850 39, 20, // 19875: case 0x27: {
10851 OPC_SwitchField, 12, 3, // 19877: switch Inst[14:12] {
10852 0, 7, // 19880: case 0x0: {
10853 OPC_CheckPredicate, 119, // 19882: check predicate 119
10854 OPC_Decode, 186, 129, 1, 124, // 19884: decode to VQWDOTAS_VV using decoder 124
10855 // 19884: }
10856 1, 0, // 19889: case 0x1: {
10857 OPC_CheckPredicate, 120, // 19891: check predicate 120
10858 OPC_Decode, 186, 126, 124, // 19893: decode to VFQWDOTA_ALT_VV using decoder 124
10859 // 19893: }
10860 // 19893: } // switch Inst[14:12]
10861 // 19893: }
10862 40, 84, // 19897: case 0x28: {
10863 OPC_SwitchField, 12, 8, // 19899: switch Inst[19:12] {
10864 2, 11, // 19902: case 0x2: {
10865 OPC_CheckPredicate, 116, // 19904: check predicate 116
10866 OPC_CheckField, 25, 1, 1, // 19906: check Inst[25] == 0x1
10867 OPC_Decode, 215, 125, 159, 1, // 19910: decode to VAESDM_VV using decoder 159
10868 // 19910: }
10869 10, 11, // 19915: case 0xa: {
10870 OPC_CheckPredicate, 116, // 19917: check predicate 116
10871 OPC_CheckField, 25, 1, 1, // 19919: check Inst[25] == 0x1
10872 OPC_Decode, 213, 125, 159, 1, // 19923: decode to VAESDF_VV using decoder 159
10873 // 19923: }
10874 18, 11, // 19928: case 0x12: {
10875 OPC_CheckPredicate, 116, // 19930: check predicate 116
10876 OPC_CheckField, 25, 1, 1, // 19932: check Inst[25] == 0x1
10877 OPC_Decode, 219, 125, 159, 1, // 19936: decode to VAESEM_VV using decoder 159
10878 // 19936: }
10879 26, 11, // 19941: case 0x1a: {
10880 OPC_CheckPredicate, 116, // 19943: check predicate 116
10881 OPC_CheckField, 25, 1, 1, // 19945: check Inst[25] == 0x1
10882 OPC_Decode, 217, 125, 159, 1, // 19949: decode to VAESEF_VV using decoder 159
10883 // 19949: }
10884 130, 1, 12, // 19954: case 0x82: {
10885 OPC_CheckPredicate, 115, // 19957: check predicate 115
10886 OPC_CheckField, 25, 1, 1, // 19959: check Inst[25] == 0x1
10887 OPC_Decode, 250, 129, 1, 159, 1, // 19963: decode to VSM4R_VV using decoder 159
10888 // 19963: }
10889 138, 1, 0, // 19969: case 0x8a: {
10890 OPC_CheckPredicate, 121, // 19972: check predicate 121
10891 OPC_CheckField, 25, 1, 1, // 19974: check Inst[25] == 0x1
10892 OPC_Decode, 249, 126, 159, 1, // 19978: decode to VGMUL_VV using decoder 159
10893 // 19978: }
10894 // 19978: } // switch Inst[19:12]
10895 // 19978: }
10896 41, 97, // 19983: case 0x29: {
10897 OPC_SwitchField, 12, 8, // 19985: switch Inst[19:12] {
10898 2, 11, // 19988: case 0x2: {
10899 OPC_CheckPredicate, 116, // 19990: check predicate 116
10900 OPC_CheckField, 25, 1, 1, // 19992: check Inst[25] == 0x1
10901 OPC_Decode, 214, 125, 159, 1, // 19996: decode to VAESDM_VS using decoder 159
10902 // 19996: }
10903 10, 11, // 20001: case 0xa: {
10904 OPC_CheckPredicate, 116, // 20003: check predicate 116
10905 OPC_CheckField, 25, 1, 1, // 20005: check Inst[25] == 0x1
10906 OPC_Decode, 212, 125, 159, 1, // 20009: decode to VAESDF_VS using decoder 159
10907 // 20009: }
10908 18, 11, // 20014: case 0x12: {
10909 OPC_CheckPredicate, 116, // 20016: check predicate 116
10910 OPC_CheckField, 25, 1, 1, // 20018: check Inst[25] == 0x1
10911 OPC_Decode, 218, 125, 159, 1, // 20022: decode to VAESEM_VS using decoder 159
10912 // 20022: }
10913 26, 11, // 20027: case 0x1a: {
10914 OPC_CheckPredicate, 116, // 20029: check predicate 116
10915 OPC_CheckField, 25, 1, 1, // 20031: check Inst[25] == 0x1
10916 OPC_Decode, 216, 125, 159, 1, // 20035: decode to VAESEF_VS using decoder 159
10917 // 20035: }
10918 58, 11, // 20040: case 0x3a: {
10919 OPC_CheckPredicate, 116, // 20042: check predicate 116
10920 OPC_CheckField, 25, 1, 1, // 20044: check Inst[25] == 0x1
10921 OPC_Decode, 222, 125, 159, 1, // 20048: decode to VAESZ_VS using decoder 159
10922 // 20048: }
10923 130, 1, 12, // 20053: case 0x82: {
10924 OPC_CheckPredicate, 115, // 20056: check predicate 115
10925 OPC_CheckField, 25, 1, 1, // 20058: check Inst[25] == 0x1
10926 OPC_Decode, 249, 129, 1, 159, 1, // 20062: decode to VSM4R_VS using decoder 159
10927 // 20062: }
10928 138, 1, 0, // 20068: case 0x8a: {
10929 OPC_CheckPredicate, 117, // 20071: check predicate 117
10930 OPC_CheckField, 25, 1, 1, // 20073: check Inst[25] == 0x1
10931 OPC_Decode, 248, 126, 159, 1, // 20077: decode to VGMUL_VS using decoder 159
10932 // 20077: }
10933 // 20077: } // switch Inst[19:12]
10934 // 20077: }
10935 42, 15, // 20082: case 0x2a: {
10936 OPC_CheckPredicate, 116, // 20084: check predicate 116
10937 OPC_CheckField, 25, 1, 1, // 20086: check Inst[25] == 0x1
10938 OPC_CheckField, 12, 3, 2, // 20090: check Inst[14:12] == 0x2
10939 OPC_Decode, 221, 125, 160, 1, // 20094: decode to VAESKF2_VI using decoder 160
10940 // 20094: }
10941 43, 26, // 20099: case 0x2b: {
10942 OPC_SwitchField, 12, 3, // 20101: switch Inst[14:12] {
10943 1, 7, // 20104: case 0x1: {
10944 OPC_CheckPredicate, 122, // 20106: check predicate 122
10945 OPC_Decode, 131, 126, 161, 1, // 20108: decode to VFBDOTA_VV using decoder 161
10946 // 20108: }
10947 2, 0, // 20113: case 0x2: {
10948 OPC_CheckPredicate, 114, // 20115: check predicate 114
10949 OPC_CheckField, 25, 1, 1, // 20117: check Inst[25] == 0x1
10950 OPC_Decode, 246, 129, 1, 160, 1, // 20121: decode to VSM3C_VI using decoder 160
10951 // 20121: }
10952 // 20121: } // switch Inst[14:12]
10953 // 20121: }
10954 44, 25, // 20127: case 0x2c: {
10955 OPC_SwitchField, 12, 3, // 20129: switch Inst[14:12] {
10956 1, 7, // 20132: case 0x1: {
10957 OPC_CheckPredicate, 123, // 20134: check predicate 123
10958 OPC_Decode, 211, 126, 161, 1, // 20136: decode to VFWBDOTA_VV using decoder 161
10959 // 20136: }
10960 2, 0, // 20141: case 0x2: {
10961 OPC_CheckPredicate, 121, // 20143: check predicate 121
10962 OPC_CheckField, 25, 1, 1, // 20145: check Inst[25] == 0x1
10963 OPC_Decode, 247, 126, 158, 1, // 20149: decode to VGHSH_VV using decoder 158
10964 // 20149: }
10965 // 20149: } // switch Inst[14:12]
10966 // 20149: }
10967 45, 16, // 20154: case 0x2d: {
10968 OPC_CheckPredicate, 124, // 20156: check predicate 124
10969 OPC_CheckField, 25, 1, 1, // 20158: check Inst[25] == 0x1
10970 OPC_CheckField, 12, 3, 2, // 20162: check Inst[14:12] == 0x2
10971 OPC_Decode, 236, 129, 1, 158, 1, // 20166: decode to VSHA2MS_VV using decoder 158
10972 // 20166: }
10973 46, 36, // 20172: case 0x2e: {
10974 OPC_SwitchField, 12, 3, // 20174: switch Inst[14:12] {
10975 0, 8, // 20177: case 0x0: {
10976 OPC_CheckPredicate, 125, // 20179: check predicate 125
10977 OPC_Decode, 185, 129, 1, 161, 1, // 20181: decode to VQWBDOTAU_VV using decoder 161
10978 // 20181: }
10979 1, 7, // 20187: case 0x1: {
10980 OPC_CheckPredicate, 126, // 20189: check predicate 126
10981 OPC_Decode, 185, 126, 161, 1, // 20191: decode to VFQWBDOTA_VV using decoder 161
10982 // 20191: }
10983 2, 0, // 20196: case 0x2: {
10984 OPC_CheckPredicate, 124, // 20198: check predicate 124
10985 OPC_CheckField, 25, 1, 1, // 20200: check Inst[25] == 0x1
10986 OPC_Decode, 234, 129, 1, 158, 1, // 20204: decode to VSHA2CH_VV using decoder 158
10987 // 20204: }
10988 // 20204: } // switch Inst[14:12]
10989 // 20204: }
10990 47, 0, // 20210: case 0x2f: {
10991 OPC_SwitchField, 12, 3, // 20212: switch Inst[14:12] {
10992 0, 8, // 20215: case 0x0: {
10993 OPC_CheckPredicate, 125, // 20217: check predicate 125
10994 OPC_Decode, 184, 129, 1, 161, 1, // 20219: decode to VQWBDOTAS_VV using decoder 161
10995 // 20219: }
10996 1, 7, // 20225: case 0x1: {
10997 OPC_CheckPredicate, 126, // 20227: check predicate 126
10998 OPC_Decode, 184, 126, 161, 1, // 20229: decode to VFQWBDOTA_ALT_VV using decoder 161
10999 // 20229: }
11000 2, 0, // 20234: case 0x2: {
11001 OPC_CheckPredicate, 124, // 20236: check predicate 124
11002 OPC_CheckField, 25, 1, 1, // 20238: check Inst[25] == 0x1
11003 OPC_Decode, 235, 129, 1, 158, 1, // 20242: decode to VSHA2CL_VV using decoder 158
11004 // 20242: }
11005 // 20242: } // switch Inst[14:12]
11006 // 20242: }
11007 // 20242: } // switch Inst[31:26]
11008 // 20242: }
11009 123, 0, // 20248: case 0x7b: {
11010 OPC_SwitchField, 12, 3, // 20250: switch Inst[14:12] {
11011 0, 194, 1, // 20253: case 0x0: {
11012 OPC_SwitchField, 25, 7, // 20256: switch Inst[31:25] {
11013 1, 7, // 20259: case 0x1: {
11014 OPC_CheckPredicate, 127, // 20261: check predicate 127
11015 OPC_Decode, 168, 118, 162, 1, // 20263: decode to PACKY using decoder 162
11016 // 20263: }
11017 3, 22, // 20268: case 0x3: {
11018 OPC_Scope, 12, // 20270: try {
11019 OPC_CheckField, 20, 5, 0, // 20272: check Inst[24:20] == 0x0
11020 OPC_CheckPredicate, 127, // 20276: check predicate 127
11021 OPC_Decode, 228, 131, 1, 163, 1, // 20278: decode to YMV using decoder 163
11022 // 20278: } else try {
11023 OPC_CheckPredicate, 127, // 20284: check predicate 127
11024 OPC_Decode, 217, 131, 1, 164, 1, // 20286: decode to YADD using decoder 164
11025 // 20286: }
11026 // 20286: }
11027 6, 8, // 20292: case 0x6: {
11028 OPC_CheckPredicate, 127, // 20294: check predicate 127
11029 OPC_Decode, 226, 131, 1, 165, 1, // 20296: decode to YEQ using decoder 165
11030 // 20296: }
11031 7, 8, // 20302: case 0x7: {
11032 OPC_CheckPredicate, 127, // 20304: check predicate 127
11033 OPC_Decode, 232, 131, 1, 166, 1, // 20306: decode to YSUNSEAL using decoder 166
11034 // 20306: }
11035 11, 8, // 20312: case 0xb: {
11036 OPC_CheckPredicate, 127, // 20314: check predicate 127
11037 OPC_Decode, 219, 131, 1, 162, 1, // 20316: decode to YADDRW using decoder 162
11038 // 20316: }
11039 14, 8, // 20322: case 0xe: {
11040 OPC_CheckPredicate, 127, // 20324: check predicate 127
11041 OPC_Decode, 231, 131, 1, 165, 1, // 20326: decode to YSS using decoder 165
11042 // 20326: }
11043 15, 8, // 20332: case 0xf: {
11044 OPC_CheckPredicate, 127, // 20334: check predicate 127
11045 OPC_Decode, 222, 131, 1, 166, 1, // 20336: decode to YBLD using decoder 166
11046 // 20336: }
11047 19, 8, // 20342: case 0x13: {
11048 OPC_CheckPredicate, 127, // 20344: check predicate 127
11049 OPC_Decode, 229, 131, 1, 162, 1, // 20346: decode to YPERMC using decoder 162
11050 // 20346: }
11051 27, 8, // 20352: case 0x1b: {
11052 OPC_CheckPredicate, 127, // 20354: check predicate 127
11053 OPC_Decode, 224, 131, 1, 162, 1, // 20356: decode to YBNDSW using decoder 162
11054 // 20356: }
11055 35, 8, // 20362: case 0x23: {
11056 OPC_CheckPredicate, 127, // 20364: check predicate 127
11057 OPC_Decode, 223, 131, 1, 162, 1, // 20366: decode to YBNDSRW using decoder 162
11058 // 20366: }
11059 120, 11, // 20372: case 0x78: {
11060 OPC_CheckPredicate, 127, // 20374: check predicate 127
11061 OPC_CheckField, 20, 5, 0, // 20376: check Inst[24:20] == 0x0
11062 OPC_Decode, 220, 131, 1, 17, // 20380: decode to YAMASK using decoder 17
11063 // 20380: }
11064 122, 0, // 20385: case 0x7a: {
11065 OPC_SwitchField, 20, 5, // 20387: switch Inst[24:20] {
11066 0, 8, // 20390: case 0x0: {
11067 OPC_CheckPredicate, 127, // 20392: check predicate 127
11068 OPC_Decode, 221, 131, 1, 167, 1, // 20394: decode to YBASER using decoder 167
11069 // 20394: }
11070 1, 8, // 20400: case 0x1: {
11071 OPC_CheckPredicate, 127, // 20402: check predicate 127
11072 OPC_Decode, 230, 131, 1, 167, 1, // 20404: decode to YPERMR using decoder 167
11073 // 20404: }
11074 2, 8, // 20410: case 0x2: {
11075 OPC_CheckPredicate, 127, // 20412: check predicate 127
11076 OPC_Decode, 234, 131, 1, 167, 1, // 20414: decode to YTOPR using decoder 167
11077 // 20414: }
11078 3, 8, // 20420: case 0x3: {
11079 OPC_CheckPredicate, 127, // 20422: check predicate 127
11080 OPC_Decode, 227, 131, 1, 167, 1, // 20424: decode to YLENR using decoder 167
11081 // 20424: }
11082 4, 8, // 20430: case 0x4: {
11083 OPC_CheckPredicate, 127, // 20432: check predicate 127
11084 OPC_Decode, 233, 131, 1, 167, 1, // 20434: decode to YTAGR using decoder 167
11085 // 20434: }
11086 5, 0, // 20440: case 0x5: {
11087 OPC_CheckPredicate, 127, // 20442: check predicate 127
11088 OPC_Decode, 235, 131, 1, 167, 1, // 20444: decode to YTYPER using decoder 167
11089 // 20444: }
11090 // 20444: } // switch Inst[24:20]
11091 // 20444: }
11092 // 20444: } // switch Inst[31:25]
11093 // 20444: }
11094 4, 8, // 20450: case 0x4: {
11095 OPC_CheckPredicate, 127, // 20452: check predicate 127
11096 OPC_Decode, 218, 131, 1, 168, 1, // 20454: decode to YADDI using decoder 168
11097 // 20454: }
11098 5, 0, // 20460: case 0x5: {
11099 OPC_SwitchField, 29, 3, // 20462: switch Inst[31:29] {
11100 0, 11, // 20465: case 0x0: {
11101 OPC_CheckPredicate, 127, // 20467: check predicate 127
11102 OPC_CheckField, 27, 2, 0, // 20469: check Inst[28:27] == 0x0
11103 OPC_Decode, 180, 124, 169, 1, // 20473: decode to SRLIY using decoder 169
11104 // 20473: }
11105 7, 0, // 20478: case 0x7: {
11106 OPC_CheckPredicate, 127, // 20480: check predicate 127
11107 OPC_Decode, 225, 131, 1, 170, 1, // 20482: decode to YBNDSWI using decoder 170
11108 // 20482: }
11109 // 20482: } // switch Inst[31:29]
11110 // 20482: }
11111 // 20482: } // switch Inst[14:12]
11112 // 20482: }
11113 // 20482: } // switch Inst[6:0]
11114};
11115static const uint8_t DecoderTableRV32Only32[795] = {
11116 32, // 0: BitWidth 32
11117 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
11118 0, 99, // 4: case 0x0: {
11119 OPC_SwitchField, 25, 7, // 6: switch Inst[31:25] {
11120 73, 10, // 9: case 0x49: {
11121 OPC_CheckPredicate, 46, // 11: check predicate 46
11122 OPC_CheckField, 0, 7, 59, // 13: check Inst[6:0] == 0x3b
11123 OPC_Decode, 146, 123, 31, // 17: decode to SADD using decoder 31
11124 // 17: }
11125 77, 10, // 21: case 0x4d: {
11126 OPC_CheckPredicate, 46, // 23: check predicate 46
11127 OPC_CheckField, 0, 7, 59, // 25: check Inst[6:0] == 0x3b
11128 OPC_Decode, 153, 107, 31, // 29: decode to AADD using decoder 31
11129 // 29: }
11130 89, 10, // 33: case 0x59: {
11131 OPC_CheckPredicate, 46, // 35: check predicate 46
11132 OPC_CheckField, 0, 7, 59, // 37: check Inst[6:0] == 0x3b
11133 OPC_Decode, 147, 123, 31, // 41: decode to SADDU using decoder 31
11134 // 41: }
11135 93, 10, // 45: case 0x5d: {
11136 OPC_CheckPredicate, 46, // 47: check predicate 46
11137 OPC_CheckField, 0, 7, 59, // 49: check Inst[6:0] == 0x3b
11138 OPC_Decode, 154, 107, 31, // 53: decode to AADDU using decoder 31
11139 // 53: }
11140 105, 10, // 57: case 0x69: {
11141 OPC_CheckPredicate, 46, // 59: check predicate 46
11142 OPC_CheckField, 0, 7, 59, // 61: check Inst[6:0] == 0x3b
11143 OPC_Decode, 200, 124, 31, // 65: decode to SSUB using decoder 31
11144 // 65: }
11145 109, 10, // 69: case 0x6d: {
11146 OPC_CheckPredicate, 46, // 71: check predicate 46
11147 OPC_CheckField, 0, 7, 59, // 73: check Inst[6:0] == 0x3b
11148 OPC_Decode, 174, 110, 31, // 77: decode to ASUB using decoder 31
11149 // 77: }
11150 121, 10, // 81: case 0x79: {
11151 OPC_CheckPredicate, 46, // 83: check predicate 46
11152 OPC_CheckField, 0, 7, 59, // 85: check Inst[6:0] == 0x3b
11153 OPC_Decode, 201, 124, 31, // 89: decode to SSUBU using decoder 31
11154 // 89: }
11155 125, 0, // 93: case 0x7d: {
11156 OPC_CheckPredicate, 46, // 95: check predicate 46
11157 OPC_CheckField, 0, 7, 59, // 97: check Inst[6:0] == 0x3b
11158 OPC_Decode, 175, 110, 31, // 101: decode to ASUBU using decoder 31
11159 // 101: }
11160 // 101: } // switch Inst[31:25]
11161 // 101: }
11162 1, 51, // 105: case 0x1: {
11163 OPC_SwitchField, 25, 7, // 107: switch Inst[31:25] {
11164 73, 10, // 110: case 0x49: {
11165 OPC_CheckPredicate, 46, // 112: check predicate 46
11166 OPC_CheckField, 0, 7, 59, // 114: check Inst[6:0] == 0x3b
11167 OPC_Decode, 196, 117, 31, // 118: decode to MUL_H01 using decoder 31
11168 // 118: }
11169 77, 10, // 122: case 0x4d: {
11170 OPC_CheckPredicate, 46, // 124: check predicate 46
11171 OPC_CheckField, 0, 7, 59, // 126: check Inst[6:0] == 0x3b
11172 OPC_Decode, 211, 116, 59, // 130: decode to MACC_H01 using decoder 59
11173 // 130: }
11174 89, 10, // 134: case 0x59: {
11175 OPC_CheckPredicate, 46, // 136: check predicate 46
11176 OPC_CheckField, 0, 7, 59, // 138: check Inst[6:0] == 0x3b
11177 OPC_Decode, 189, 117, 31, // 142: decode to MULU_H01 using decoder 31
11178 // 142: }
11179 93, 0, // 146: case 0x5d: {
11180 OPC_CheckPredicate, 46, // 148: check predicate 46
11181 OPC_CheckField, 0, 7, 59, // 150: check Inst[6:0] == 0x3b
11182 OPC_Decode, 205, 116, 59, // 154: decode to MACCU_H01 using decoder 59
11183 // 154: }
11184 // 154: } // switch Inst[31:25]
11185 // 154: }
11186 2, 75, // 158: case 0x2: {
11187 OPC_SwitchField, 25, 7, // 160: switch Inst[31:25] {
11188 85, 10, // 163: case 0x55: {
11189 OPC_CheckPredicate, 46, // 165: check predicate 46
11190 OPC_CheckField, 0, 7, 27, // 167: check Inst[6:0] == 0x1b
11191 OPC_Decode, 194, 124, 31, // 171: decode to SSHL using decoder 31
11192 // 171: }
11193 89, 10, // 175: case 0x59: {
11194 OPC_CheckPredicate, 46, // 177: check predicate 46
11195 OPC_CheckField, 0, 7, 59, // 179: check Inst[6:0] == 0x3b
11196 OPC_Decode, 191, 124, 31, // 183: decode to SSH1SADD using decoder 31
11197 // 183: }
11198 93, 10, // 187: case 0x5d: {
11199 OPC_CheckPredicate, 46, // 189: check predicate 46
11200 OPC_CheckField, 0, 7, 27, // 191: check Inst[6:0] == 0x1b
11201 OPC_Decode, 195, 124, 31, // 195: decode to SSHLR using decoder 31
11202 // 195: }
11203 105, 10, // 199: case 0x69: {
11204 OPC_CheckPredicate, 46, // 201: check predicate 46
11205 OPC_CheckField, 0, 7, 27, // 203: check Inst[6:0] == 0x1b
11206 OPC_Decode, 196, 124, 21, // 207: decode to SSLAI using decoder 21
11207 // 207: }
11208 117, 10, // 211: case 0x75: {
11209 OPC_CheckPredicate, 46, // 213: check predicate 46
11210 OPC_CheckField, 0, 7, 27, // 215: check Inst[6:0] == 0x1b
11211 OPC_Decode, 192, 124, 31, // 219: decode to SSHA using decoder 31
11212 // 219: }
11213 125, 0, // 223: case 0x7d: {
11214 OPC_CheckPredicate, 46, // 225: check predicate 46
11215 OPC_CheckField, 0, 7, 27, // 227: check Inst[6:0] == 0x1b
11216 OPC_Decode, 193, 124, 31, // 231: decode to SSHAR using decoder 31
11217 // 231: }
11218 // 231: } // switch Inst[31:25]
11219 // 231: }
11220 3, 165, 1, // 235: case 0x3: {
11221 OPC_SwitchField, 0, 7, // 238: switch Inst[6:0] {
11222 3, 8, // 241: case 0x3: {
11223 OPC_CheckPredicate, 128, 1, // 243: check predicate 128
11224 OPC_Decode, 180, 116, 171, 1, // 246: decode to LD_RV32 using decoder 171
11225 // 246: }
11226 35, 8, // 251: case 0x23: {
11227 OPC_CheckPredicate, 128, 1, // 253: check predicate 128
11228 OPC_Decode, 165, 123, 172, 1, // 256: decode to SD_RV32 using decoder 172
11229 // 256: }
11230 47, 39, // 261: case 0x2f: {
11231 OPC_SwitchField, 25, 7, // 263: switch Inst[31:25] {
11232 20, 7, // 266: case 0x14: {
11233 OPC_CheckPredicate, 129, 1, // 268: check predicate 129
11234 OPC_Decode, 167, 109, 56, // 271: decode to AMOCAS_D_RV32 using decoder 56
11235 // 271: }
11236 21, 7, // 275: case 0x15: {
11237 OPC_CheckPredicate, 129, 1, // 277: check predicate 129
11238 OPC_Decode, 170, 109, 56, // 280: decode to AMOCAS_D_RV32_RL using decoder 56
11239 // 280: }
11240 22, 7, // 284: case 0x16: {
11241 OPC_CheckPredicate, 129, 1, // 286: check predicate 129
11242 OPC_Decode, 168, 109, 56, // 289: decode to AMOCAS_D_RV32_AQ using decoder 56
11243 // 289: }
11244 23, 0, // 293: case 0x17: {
11245 OPC_CheckPredicate, 129, 1, // 295: check predicate 129
11246 OPC_Decode, 169, 109, 56, // 298: decode to AMOCAS_D_RV32_AQRL using decoder 56
11247 // 298: }
11248 // 298: } // switch Inst[31:25]
11249 // 298: }
11250 59, 0, // 302: case 0x3b: {
11251 OPC_SwitchField, 25, 7, // 304: switch Inst[31:25] {
11252 65, 6, // 307: case 0x41: {
11253 OPC_CheckPredicate, 46, // 309: check predicate 46
11254 OPC_Decode, 195, 117, 31, // 311: decode to MUL_H00 using decoder 31
11255 // 311: }
11256 69, 6, // 315: case 0x45: {
11257 OPC_CheckPredicate, 46, // 317: check predicate 46
11258 OPC_Decode, 210, 116, 59, // 319: decode to MACC_H00 using decoder 59
11259 // 319: }
11260 73, 6, // 323: case 0x49: {
11261 OPC_CheckPredicate, 46, // 325: check predicate 46
11262 OPC_Decode, 197, 117, 31, // 327: decode to MUL_H11 using decoder 31
11263 // 327: }
11264 77, 6, // 331: case 0x4d: {
11265 OPC_CheckPredicate, 46, // 333: check predicate 46
11266 OPC_Decode, 212, 116, 59, // 335: decode to MACC_H11 using decoder 59
11267 // 335: }
11268 81, 6, // 339: case 0x51: {
11269 OPC_CheckPredicate, 46, // 341: check predicate 46
11270 OPC_Decode, 188, 117, 31, // 343: decode to MULU_H00 using decoder 31
11271 // 343: }
11272 85, 6, // 347: case 0x55: {
11273 OPC_CheckPredicate, 46, // 349: check predicate 46
11274 OPC_Decode, 204, 116, 59, // 351: decode to MACCU_H00 using decoder 59
11275 // 351: }
11276 89, 6, // 355: case 0x59: {
11277 OPC_CheckPredicate, 46, // 357: check predicate 46
11278 OPC_Decode, 190, 117, 31, // 359: decode to MULU_H11 using decoder 31
11279 // 359: }
11280 93, 6, // 363: case 0x5d: {
11281 OPC_CheckPredicate, 46, // 365: check predicate 46
11282 OPC_Decode, 206, 116, 59, // 367: decode to MACCU_H11 using decoder 59
11283 // 367: }
11284 113, 6, // 371: case 0x71: {
11285 OPC_CheckPredicate, 46, // 373: check predicate 46
11286 OPC_Decode, 184, 117, 31, // 375: decode to MULSU_H00 using decoder 31
11287 // 375: }
11288 117, 6, // 379: case 0x75: {
11289 OPC_CheckPredicate, 46, // 381: check predicate 46
11290 OPC_Decode, 200, 116, 59, // 383: decode to MACCSU_H00 using decoder 59
11291 // 383: }
11292 121, 6, // 387: case 0x79: {
11293 OPC_CheckPredicate, 46, // 389: check predicate 46
11294 OPC_Decode, 185, 117, 31, // 391: decode to MULSU_H11 using decoder 31
11295 // 391: }
11296 125, 0, // 395: case 0x7d: {
11297 OPC_CheckPredicate, 46, // 397: check predicate 46
11298 OPC_Decode, 201, 116, 59, // 399: decode to MACCSU_H11 using decoder 59
11299 // 399: }
11300 // 399: } // switch Inst[31:25]
11301 // 399: }
11302 // 399: } // switch Inst[6:0]
11303 // 399: }
11304 4, 39, // 403: case 0x4: {
11305 OPC_SwitchField, 25, 7, // 405: switch Inst[31:25] {
11306 81, 10, // 408: case 0x51: {
11307 OPC_CheckPredicate, 46, // 410: check predicate 46
11308 OPC_CheckField, 0, 7, 27, // 412: check Inst[6:0] == 0x1b
11309 OPC_Decode, 196, 125, 21, // 416: decode to USATI_RV32 using decoder 21
11310 // 416: }
11311 105, 10, // 420: case 0x69: {
11312 OPC_CheckPredicate, 46, // 422: check predicate 46
11313 OPC_CheckField, 0, 7, 27, // 424: check Inst[6:0] == 0x1b
11314 OPC_Decode, 173, 124, 21, // 428: decode to SRARI_RV32 using decoder 21
11315 // 428: }
11316 113, 0, // 432: case 0x71: {
11317 OPC_CheckPredicate, 46, // 434: check predicate 46
11318 OPC_CheckField, 0, 7, 27, // 436: check Inst[6:0] == 0x1b
11319 OPC_Decode, 148, 123, 41, // 440: decode to SATI_RV32 using decoder 41
11320 // 440: }
11321 // 440: } // switch Inst[31:25]
11322 // 440: }
11323 5, 27, // 444: case 0x5: {
11324 OPC_SwitchField, 25, 7, // 446: switch Inst[31:25] {
11325 124, 10, // 449: case 0x7c: {
11326 OPC_CheckPredicate, 46, // 451: check predicate 46
11327 OPC_CheckField, 0, 7, 59, // 453: check Inst[6:0] == 0x3b
11328 OPC_Decode, 154, 117, 59, // 457: decode to MQACC_H01 using decoder 59
11329 // 457: }
11330 126, 0, // 461: case 0x7e: {
11331 OPC_CheckPredicate, 46, // 463: check predicate 46
11332 OPC_CheckField, 0, 7, 59, // 465: check Inst[6:0] == 0x3b
11333 OPC_Decode, 160, 117, 59, // 469: decode to MQRACC_H01 using decoder 59
11334 // 469: }
11335 // 469: } // switch Inst[31:25]
11336 // 469: }
11337 6, 39, // 473: case 0x6: {
11338 OPC_SwitchField, 25, 7, // 475: switch Inst[31:25] {
11339 97, 10, // 478: case 0x61: {
11340 OPC_CheckPredicate, 46, // 480: check predicate 46
11341 OPC_CheckField, 0, 7, 59, // 482: check Inst[6:0] == 0x3b
11342 OPC_Decode, 168, 117, 31, // 486: decode to MSEQ using decoder 31
11343 // 486: }
11344 105, 10, // 490: case 0x69: {
11345 OPC_CheckPredicate, 46, // 492: check predicate 46
11346 OPC_CheckField, 0, 7, 59, // 494: check Inst[6:0] == 0x3b
11347 OPC_Decode, 169, 117, 31, // 498: decode to MSLT using decoder 31
11348 // 498: }
11349 109, 0, // 502: case 0x6d: {
11350 OPC_CheckPredicate, 46, // 504: check predicate 46
11351 OPC_CheckField, 0, 7, 59, // 506: check Inst[6:0] == 0x3b
11352 OPC_Decode, 170, 117, 31, // 510: decode to MSLTU using decoder 31
11353 // 510: }
11354 // 510: } // switch Inst[31:25]
11355 // 510: }
11356 7, 0, // 514: case 0x7: {
11357 OPC_SwitchField, 25, 7, // 516: switch Inst[31:25] {
11358 67, 10, // 519: case 0x43: {
11359 OPC_CheckPredicate, 46, // 521: check predicate 46
11360 OPC_CheckField, 0, 7, 59, // 523: check Inst[6:0] == 0x3b
11361 OPC_Decode, 173, 117, 31, // 527: decode to MULHR using decoder 31
11362 // 527: }
11363 69, 10, // 531: case 0x45: {
11364 OPC_CheckPredicate, 46, // 533: check predicate 46
11365 OPC_CheckField, 0, 7, 59, // 535: check Inst[6:0] == 0x3b
11366 OPC_Decode, 219, 116, 59, // 539: decode to MHACC using decoder 59
11367 // 539: }
11368 71, 10, // 543: case 0x47: {
11369 OPC_CheckPredicate, 46, // 545: check predicate 46
11370 OPC_CheckField, 0, 7, 59, // 547: check Inst[6:0] == 0x3b
11371 OPC_Decode, 226, 116, 59, // 551: decode to MHRACC using decoder 59
11372 // 551: }
11373 75, 10, // 555: case 0x4b: {
11374 OPC_CheckPredicate, 46, // 557: check predicate 46
11375 OPC_CheckField, 0, 7, 59, // 559: check Inst[6:0] == 0x3b
11376 OPC_Decode, 175, 117, 31, // 563: decode to MULHRU using decoder 31
11377 // 563: }
11378 77, 10, // 567: case 0x4d: {
11379 OPC_CheckPredicate, 46, // 569: check predicate 46
11380 OPC_CheckField, 0, 7, 59, // 571: check Inst[6:0] == 0x3b
11381 OPC_Decode, 223, 116, 59, // 575: decode to MHACCU using decoder 59
11382 // 575: }
11383 79, 10, // 579: case 0x4f: {
11384 OPC_CheckPredicate, 46, // 581: check predicate 46
11385 OPC_CheckField, 0, 7, 59, // 583: check Inst[6:0] == 0x3b
11386 OPC_Decode, 228, 116, 59, // 587: decode to MHRACCU using decoder 59
11387 // 587: }
11388 81, 10, // 591: case 0x51: {
11389 OPC_CheckPredicate, 46, // 593: check predicate 46
11390 OPC_CheckField, 0, 7, 59, // 595: check Inst[6:0] == 0x3b
11391 OPC_Decode, 180, 117, 31, // 599: decode to MULH_H0 using decoder 31
11392 // 599: }
11393 83, 10, // 603: case 0x53: {
11394 OPC_CheckPredicate, 46, // 605: check predicate 46
11395 OPC_CheckField, 0, 7, 59, // 607: check Inst[6:0] == 0x3b
11396 OPC_Decode, 177, 117, 31, // 611: decode to MULHSU_H0 using decoder 31
11397 // 611: }
11398 85, 10, // 615: case 0x55: {
11399 OPC_CheckPredicate, 46, // 617: check predicate 46
11400 OPC_CheckField, 0, 7, 59, // 619: check Inst[6:0] == 0x3b
11401 OPC_Decode, 224, 116, 59, // 623: decode to MHACC_H0 using decoder 59
11402 // 623: }
11403 87, 10, // 627: case 0x57: {
11404 OPC_CheckPredicate, 46, // 629: check predicate 46
11405 OPC_CheckField, 0, 7, 59, // 631: check Inst[6:0] == 0x3b
11406 OPC_Decode, 221, 116, 59, // 635: decode to MHACCSU_H0 using decoder 59
11407 // 635: }
11408 89, 10, // 639: case 0x59: {
11409 OPC_CheckPredicate, 46, // 641: check predicate 46
11410 OPC_CheckField, 0, 7, 59, // 643: check Inst[6:0] == 0x3b
11411 OPC_Decode, 181, 117, 31, // 647: decode to MULH_H1 using decoder 31
11412 // 647: }
11413 91, 10, // 651: case 0x5b: {
11414 OPC_CheckPredicate, 46, // 653: check predicate 46
11415 OPC_CheckField, 0, 7, 59, // 655: check Inst[6:0] == 0x3b
11416 OPC_Decode, 178, 117, 31, // 659: decode to MULHSU_H1 using decoder 31
11417 // 659: }
11418 93, 10, // 663: case 0x5d: {
11419 OPC_CheckPredicate, 46, // 665: check predicate 46
11420 OPC_CheckField, 0, 7, 59, // 667: check Inst[6:0] == 0x3b
11421 OPC_Decode, 225, 116, 59, // 671: decode to MHACC_H1 using decoder 59
11422 // 671: }
11423 95, 10, // 675: case 0x5f: {
11424 OPC_CheckPredicate, 46, // 677: check predicate 46
11425 OPC_CheckField, 0, 7, 59, // 679: check Inst[6:0] == 0x3b
11426 OPC_Decode, 222, 116, 59, // 683: decode to MHACCSU_H1 using decoder 59
11427 // 683: }
11428 99, 10, // 687: case 0x63: {
11429 OPC_CheckPredicate, 46, // 689: check predicate 46
11430 OPC_CheckField, 0, 7, 59, // 691: check Inst[6:0] == 0x3b
11431 OPC_Decode, 174, 117, 31, // 695: decode to MULHRSU using decoder 31
11432 // 695: }
11433 101, 10, // 699: case 0x65: {
11434 OPC_CheckPredicate, 46, // 701: check predicate 46
11435 OPC_CheckField, 0, 7, 59, // 703: check Inst[6:0] == 0x3b
11436 OPC_Decode, 220, 116, 59, // 707: decode to MHACCSU using decoder 59
11437 // 707: }
11438 103, 10, // 711: case 0x67: {
11439 OPC_CheckPredicate, 46, // 713: check predicate 46
11440 OPC_CheckField, 0, 7, 59, // 715: check Inst[6:0] == 0x3b
11441 OPC_Decode, 227, 116, 59, // 719: decode to MHRACCSU using decoder 59
11442 // 719: }
11443 105, 10, // 723: case 0x69: {
11444 OPC_CheckPredicate, 46, // 725: check predicate 46
11445 OPC_CheckField, 0, 7, 59, // 727: check Inst[6:0] == 0x3b
11446 OPC_Decode, 182, 117, 31, // 731: decode to MULQ using decoder 31
11447 // 731: }
11448 107, 10, // 735: case 0x6b: {
11449 OPC_CheckPredicate, 46, // 737: check predicate 46
11450 OPC_CheckField, 0, 7, 59, // 739: check Inst[6:0] == 0x3b
11451 OPC_Decode, 183, 117, 31, // 743: decode to MULQR using decoder 31
11452 // 743: }
11453 116, 10, // 747: case 0x74: {
11454 OPC_CheckPredicate, 46, // 749: check predicate 46
11455 OPC_CheckField, 0, 7, 59, // 751: check Inst[6:0] == 0x3b
11456 OPC_Decode, 153, 117, 59, // 755: decode to MQACC_H00 using decoder 59
11457 // 755: }
11458 118, 10, // 759: case 0x76: {
11459 OPC_CheckPredicate, 46, // 761: check predicate 46
11460 OPC_CheckField, 0, 7, 59, // 763: check Inst[6:0] == 0x3b
11461 OPC_Decode, 159, 117, 59, // 767: decode to MQRACC_H00 using decoder 59
11462 // 767: }
11463 124, 10, // 771: case 0x7c: {
11464 OPC_CheckPredicate, 46, // 773: check predicate 46
11465 OPC_CheckField, 0, 7, 59, // 775: check Inst[6:0] == 0x3b
11466 OPC_Decode, 155, 117, 59, // 779: decode to MQACC_H11 using decoder 59
11467 // 779: }
11468 126, 0, // 783: case 0x7e: {
11469 OPC_CheckPredicate, 46, // 785: check predicate 46
11470 OPC_CheckField, 0, 7, 59, // 787: check Inst[6:0] == 0x3b
11471 OPC_Decode, 161, 117, 59, // 791: decode to MQRACC_H11 using decoder 59
11472 // 791: }
11473 // 791: } // switch Inst[31:25]
11474 // 791: }
11475 // 791: } // switch Inst[14:12]
11476};
11477static const uint8_t DecoderTableXAIF32[2612] = {
11478 32, // 0: BitWidth 32
11479 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
11480 7, 12, // 4: case 0x7: {
11481 OPC_CheckPredicate, 130, 1, // 6: check predicate 130
11482 OPC_CheckField, 12, 3, 5, // 9: check Inst[14:12] == 0x5
11483 OPC_Decode, 175, 108, 173, 1, // 13: decode to AIF_FLQ2 using decoder 173
11484 // 13: }
11485 11, 195, 4, // 18: case 0xb: {
11486 OPC_SwitchField, 12, 3, // 21: switch Inst[14:12] {
11487 0, 8, // 24: case 0x0: {
11488 OPC_CheckPredicate, 130, 1, // 26: check predicate 130
11489 OPC_Decode, 249, 107, 173, 1, // 29: decode to AIF_FBC_PS using decoder 173
11490 // 29: }
11491 1, 123, // 34: case 0x1: {
11492 OPC_SwitchField, 25, 7, // 36: switch Inst[31:25] {
11493 4, 8, // 39: case 0x4: {
11494 OPC_CheckPredicate, 130, 1, // 41: check predicate 130
11495 OPC_Decode, 159, 108, 174, 1, // 44: decode to AIF_FG32B_PS using decoder 174
11496 // 44: }
11497 8, 8, // 49: case 0x8: {
11498 OPC_CheckPredicate, 130, 1, // 51: check predicate 130
11499 OPC_Decode, 160, 108, 174, 1, // 54: decode to AIF_FG32H_PS using decoder 174
11500 // 54: }
11501 16, 8, // 59: case 0x10: {
11502 OPC_CheckPredicate, 130, 1, // 61: check predicate 130
11503 OPC_Decode, 161, 108, 174, 1, // 64: decode to AIF_FG32W_PS using decoder 174
11504 // 64: }
11505 36, 8, // 69: case 0x24: {
11506 OPC_CheckPredicate, 130, 1, // 71: check predicate 130
11507 OPC_Decode, 164, 108, 175, 1, // 74: decode to AIF_FGB_PS using decoder 175
11508 // 74: }
11509 40, 8, // 79: case 0x28: {
11510 OPC_CheckPredicate, 130, 1, // 81: check predicate 130
11511 OPC_Decode, 167, 108, 175, 1, // 84: decode to AIF_FGH_PS using decoder 175
11512 // 84: }
11513 48, 8, // 89: case 0x30: {
11514 OPC_CheckPredicate, 130, 1, // 91: check predicate 130
11515 OPC_Decode, 170, 108, 175, 1, // 94: decode to AIF_FGW_PS using decoder 175
11516 // 94: }
11517 68, 8, // 99: case 0x44: {
11518 OPC_CheckPredicate, 130, 1, // 101: check predicate 130
11519 OPC_Decode, 212, 108, 174, 1, // 104: decode to AIF_FSC32B_PS using decoder 174
11520 // 104: }
11521 72, 8, // 109: case 0x48: {
11522 OPC_CheckPredicate, 130, 1, // 111: check predicate 130
11523 OPC_Decode, 213, 108, 174, 1, // 114: decode to AIF_FSC32H_PS using decoder 174
11524 // 114: }
11525 80, 8, // 119: case 0x50: {
11526 OPC_CheckPredicate, 130, 1, // 121: check predicate 130
11527 OPC_Decode, 214, 108, 174, 1, // 124: decode to AIF_FSC32W_PS using decoder 174
11528 // 124: }
11529 100, 8, // 129: case 0x64: {
11530 OPC_CheckPredicate, 130, 1, // 131: check predicate 130
11531 OPC_Decode, 217, 108, 175, 1, // 134: decode to AIF_FSCB_PS using decoder 175
11532 // 134: }
11533 104, 8, // 139: case 0x68: {
11534 OPC_CheckPredicate, 130, 1, // 141: check predicate 130
11535 OPC_Decode, 220, 108, 175, 1, // 144: decode to AIF_FSCH_PS using decoder 175
11536 // 144: }
11537 112, 0, // 149: case 0x70: {
11538 OPC_CheckPredicate, 130, 1, // 151: check predicate 130
11539 OPC_Decode, 223, 108, 175, 1, // 154: decode to AIF_FSCW_PS using decoder 175
11540 // 154: }
11541 // 154: } // switch Inst[31:25]
11542 // 154: }
11543 2, 8, // 159: case 0x2: {
11544 OPC_CheckPredicate, 130, 1, // 161: check predicate 130
11545 OPC_Decode, 183, 108, 173, 1, // 164: decode to AIF_FLW_PS using decoder 173
11546 // 164: }
11547 3, 12, // 169: case 0x3: {
11548 OPC_CheckPredicate, 130, 1, // 171: check predicate 130
11549 OPC_CheckField, 20, 12, 0, // 174: check Inst[31:20] == 0x0
11550 OPC_Decode, 248, 107, 176, 1, // 178: decode to AIF_FBCX_PS using decoder 176
11551 // 178: }
11552 4, 223, 1, // 183: case 0x4: {
11553 OPC_SwitchField, 25, 7, // 186: switch Inst[31:25] {
11554 3, 8, // 189: case 0x3: {
11555 OPC_CheckPredicate, 130, 1, // 191: check predicate 130
11556 OPC_Decode, 223, 107, 175, 1, // 194: decode to AIF_FAMOADDL_PI using decoder 175
11557 // 194: }
11558 7, 8, // 199: case 0x7: {
11559 OPC_CheckPredicate, 130, 1, // 201: check predicate 130
11560 OPC_Decode, 241, 107, 175, 1, // 204: decode to AIF_FAMOSWAPL_PI using decoder 175
11561 // 204: }
11562 11, 8, // 209: case 0xb: {
11563 OPC_CheckPredicate, 130, 1, // 211: check predicate 130
11564 OPC_Decode, 225, 107, 175, 1, // 214: decode to AIF_FAMOANDL_PI using decoder 175
11565 // 214: }
11566 15, 8, // 219: case 0xf: {
11567 OPC_CheckPredicate, 130, 1, // 221: check predicate 130
11568 OPC_Decode, 239, 107, 175, 1, // 224: decode to AIF_FAMOORL_PI using decoder 175
11569 // 224: }
11570 19, 8, // 229: case 0x13: {
11571 OPC_CheckPredicate, 130, 1, // 231: check predicate 130
11572 OPC_Decode, 243, 107, 175, 1, // 234: decode to AIF_FAMOXORL_PI using decoder 175
11573 // 234: }
11574 20, 8, // 239: case 0x14: {
11575 OPC_CheckPredicate, 130, 1, // 241: check predicate 130
11576 OPC_Decode, 229, 107, 175, 1, // 244: decode to AIF_FAMOMAXL_PS using decoder 175
11577 // 244: }
11578 23, 8, // 249: case 0x17: {
11579 OPC_CheckPredicate, 130, 1, // 251: check predicate 130
11580 OPC_Decode, 234, 107, 175, 1, // 254: decode to AIF_FAMOMINL_PI using decoder 175
11581 // 254: }
11582 24, 8, // 259: case 0x18: {
11583 OPC_CheckPredicate, 130, 1, // 261: check predicate 130
11584 OPC_Decode, 235, 107, 175, 1, // 264: decode to AIF_FAMOMINL_PS using decoder 175
11585 // 264: }
11586 27, 8, // 269: case 0x1b: {
11587 OPC_CheckPredicate, 130, 1, // 271: check predicate 130
11588 OPC_Decode, 228, 107, 175, 1, // 274: decode to AIF_FAMOMAXL_PI using decoder 175
11589 // 274: }
11590 31, 8, // 279: case 0x1f: {
11591 OPC_CheckPredicate, 130, 1, // 281: check predicate 130
11592 OPC_Decode, 237, 107, 175, 1, // 284: decode to AIF_FAMOMINUL_PI using decoder 175
11593 // 284: }
11594 35, 8, // 289: case 0x23: {
11595 OPC_CheckPredicate, 130, 1, // 291: check predicate 130
11596 OPC_Decode, 231, 107, 175, 1, // 294: decode to AIF_FAMOMAXUL_PI using decoder 175
11597 // 294: }
11598 67, 8, // 299: case 0x43: {
11599 OPC_CheckPredicate, 130, 1, // 301: check predicate 130
11600 OPC_Decode, 222, 107, 175, 1, // 304: decode to AIF_FAMOADDG_PI using decoder 175
11601 // 304: }
11602 71, 8, // 309: case 0x47: {
11603 OPC_CheckPredicate, 130, 1, // 311: check predicate 130
11604 OPC_Decode, 240, 107, 175, 1, // 314: decode to AIF_FAMOSWAPG_PI using decoder 175
11605 // 314: }
11606 75, 8, // 319: case 0x4b: {
11607 OPC_CheckPredicate, 130, 1, // 321: check predicate 130
11608 OPC_Decode, 224, 107, 175, 1, // 324: decode to AIF_FAMOANDG_PI using decoder 175
11609 // 324: }
11610 79, 8, // 329: case 0x4f: {
11611 OPC_CheckPredicate, 130, 1, // 331: check predicate 130
11612 OPC_Decode, 238, 107, 175, 1, // 334: decode to AIF_FAMOORG_PI using decoder 175
11613 // 334: }
11614 83, 8, // 339: case 0x53: {
11615 OPC_CheckPredicate, 130, 1, // 341: check predicate 130
11616 OPC_Decode, 242, 107, 175, 1, // 344: decode to AIF_FAMOXORG_PI using decoder 175
11617 // 344: }
11618 84, 8, // 349: case 0x54: {
11619 OPC_CheckPredicate, 130, 1, // 351: check predicate 130
11620 OPC_Decode, 227, 107, 175, 1, // 354: decode to AIF_FAMOMAXG_PS using decoder 175
11621 // 354: }
11622 87, 8, // 359: case 0x57: {
11623 OPC_CheckPredicate, 130, 1, // 361: check predicate 130
11624 OPC_Decode, 232, 107, 175, 1, // 364: decode to AIF_FAMOMING_PI using decoder 175
11625 // 364: }
11626 88, 8, // 369: case 0x58: {
11627 OPC_CheckPredicate, 130, 1, // 371: check predicate 130
11628 OPC_Decode, 233, 107, 175, 1, // 374: decode to AIF_FAMOMING_PS using decoder 175
11629 // 374: }
11630 91, 8, // 379: case 0x5b: {
11631 OPC_CheckPredicate, 130, 1, // 381: check predicate 130
11632 OPC_Decode, 226, 107, 175, 1, // 384: decode to AIF_FAMOMAXG_PI using decoder 175
11633 // 384: }
11634 95, 8, // 389: case 0x5f: {
11635 OPC_CheckPredicate, 130, 1, // 391: check predicate 130
11636 OPC_Decode, 236, 107, 175, 1, // 394: decode to AIF_FAMOMINUG_PI using decoder 175
11637 // 394: }
11638 99, 0, // 399: case 0x63: {
11639 OPC_CheckPredicate, 130, 1, // 401: check predicate 130
11640 OPC_Decode, 230, 107, 175, 1, // 404: decode to AIF_FAMOMAXUG_PI using decoder 175
11641 // 404: }
11642 // 404: } // switch Inst[31:25]
11643 // 404: }
11644 6, 8, // 409: case 0x6: {
11645 OPC_CheckPredicate, 130, 1, // 411: check predicate 130
11646 OPC_Decode, 242, 108, 177, 1, // 414: decode to AIF_FSW_PS using decoder 177
11647 // 414: }
11648 7, 0, // 419: case 0x7: {
11649 OPC_SwitchField, 25, 7, // 421: switch Inst[31:25] {
11650 8, 12, // 424: case 0x8: {
11651 OPC_CheckPredicate, 130, 1, // 426: check predicate 130
11652 OPC_CheckField, 20, 5, 0, // 429: check Inst[24:20] == 0x0
11653 OPC_Decode, 182, 108, 176, 1, // 433: decode to AIF_FLWL_PS using decoder 176
11654 // 433: }
11655 9, 12, // 438: case 0x9: {
11656 OPC_CheckPredicate, 130, 1, // 440: check predicate 130
11657 OPC_CheckField, 20, 5, 0, // 443: check Inst[24:20] == 0x0
11658 OPC_Decode, 181, 108, 176, 1, // 447: decode to AIF_FLWG_PS using decoder 176
11659 // 447: }
11660 40, 12, // 452: case 0x28: {
11661 OPC_CheckPredicate, 130, 1, // 454: check predicate 130
11662 OPC_CheckField, 20, 5, 0, // 457: check Inst[24:20] == 0x0
11663 OPC_Decode, 241, 108, 176, 1, // 461: decode to AIF_FSWL_PS using decoder 176
11664 // 461: }
11665 41, 12, // 466: case 0x29: {
11666 OPC_CheckPredicate, 130, 1, // 468: check predicate 130
11667 OPC_CheckField, 20, 5, 0, // 471: check Inst[24:20] == 0x0
11668 OPC_Decode, 239, 108, 176, 1, // 475: decode to AIF_FSWG_PS using decoder 176
11669 // 475: }
11670 64, 8, // 480: case 0x40: {
11671 OPC_CheckPredicate, 130, 1, // 482: check predicate 130
11672 OPC_Decode, 163, 108, 175, 1, // 485: decode to AIF_FGBL_PS using decoder 175
11673 // 485: }
11674 65, 8, // 490: case 0x41: {
11675 OPC_CheckPredicate, 130, 1, // 492: check predicate 130
11676 OPC_Decode, 162, 108, 175, 1, // 495: decode to AIF_FGBG_PS using decoder 175
11677 // 495: }
11678 68, 8, // 500: case 0x44: {
11679 OPC_CheckPredicate, 130, 1, // 502: check predicate 130
11680 OPC_Decode, 166, 108, 175, 1, // 505: decode to AIF_FGHL_PS using decoder 175
11681 // 505: }
11682 69, 8, // 510: case 0x45: {
11683 OPC_CheckPredicate, 130, 1, // 512: check predicate 130
11684 OPC_Decode, 165, 108, 175, 1, // 515: decode to AIF_FGHG_PS using decoder 175
11685 // 515: }
11686 72, 8, // 520: case 0x48: {
11687 OPC_CheckPredicate, 130, 1, // 522: check predicate 130
11688 OPC_Decode, 169, 108, 175, 1, // 525: decode to AIF_FGWL_PS using decoder 175
11689 // 525: }
11690 73, 8, // 530: case 0x49: {
11691 OPC_CheckPredicate, 130, 1, // 532: check predicate 130
11692 OPC_Decode, 168, 108, 175, 1, // 535: decode to AIF_FGWG_PS using decoder 175
11693 // 535: }
11694 96, 8, // 540: case 0x60: {
11695 OPC_CheckPredicate, 130, 1, // 542: check predicate 130
11696 OPC_Decode, 216, 108, 175, 1, // 545: decode to AIF_FSCBL_PS using decoder 175
11697 // 545: }
11698 97, 8, // 550: case 0x61: {
11699 OPC_CheckPredicate, 130, 1, // 552: check predicate 130
11700 OPC_Decode, 215, 108, 175, 1, // 555: decode to AIF_FSCBG_PS using decoder 175
11701 // 555: }
11702 100, 8, // 560: case 0x64: {
11703 OPC_CheckPredicate, 130, 1, // 562: check predicate 130
11704 OPC_Decode, 219, 108, 175, 1, // 565: decode to AIF_FSCHL_PS using decoder 175
11705 // 565: }
11706 101, 8, // 570: case 0x65: {
11707 OPC_CheckPredicate, 130, 1, // 572: check predicate 130
11708 OPC_Decode, 218, 108, 175, 1, // 575: decode to AIF_FSCHG_PS using decoder 175
11709 // 575: }
11710 104, 8, // 580: case 0x68: {
11711 OPC_CheckPredicate, 130, 1, // 582: check predicate 130
11712 OPC_Decode, 222, 108, 175, 1, // 585: decode to AIF_FSCWL_PS using decoder 175
11713 // 585: }
11714 105, 0, // 590: case 0x69: {
11715 OPC_CheckPredicate, 130, 1, // 592: check predicate 130
11716 OPC_Decode, 221, 108, 175, 1, // 595: decode to AIF_FSCWG_PS using decoder 175
11717 // 595: }
11718 // 595: } // switch Inst[31:25]
11719 // 595: }
11720 // 595: } // switch Inst[14:12]
11721 // 595: }
11722 31, 8, // 600: case 0x1f: {
11723 OPC_CheckPredicate, 130, 1, // 602: check predicate 130
11724 OPC_Decode, 247, 107, 178, 1, // 605: decode to AIF_FBCI_PS using decoder 178
11725 // 605: }
11726 39, 12, // 610: case 0x27: {
11727 OPC_CheckPredicate, 130, 1, // 612: check predicate 130
11728 OPC_CheckField, 12, 3, 5, // 615: check Inst[14:12] == 0x5
11729 OPC_Decode, 231, 108, 177, 1, // 619: decode to AIF_FSQ2 using decoder 177
11730 // 619: }
11731 59, 149, 4, // 624: case 0x3b: {
11732 OPC_SwitchField, 25, 7, // 627: switch Inst[31:25] {
11733 0, 21, // 630: case 0x0: {
11734 OPC_SwitchField, 12, 3, // 632: switch Inst[14:12] {
11735 2, 7, // 635: case 0x2: {
11736 OPC_CheckPredicate, 130, 1, // 637: check predicate 130
11737 OPC_Decode, 177, 107, 54, // 640: decode to AIF_AMOADDL_W using decoder 54
11738 // 640: }
11739 3, 0, // 644: case 0x3: {
11740 OPC_CheckPredicate, 130, 1, // 646: check predicate 130
11741 OPC_Decode, 176, 107, 54, // 649: decode to AIF_AMOADDL_D using decoder 54
11742 // 649: }
11743 // 649: } // switch Inst[14:12]
11744 // 649: }
11745 1, 21, // 653: case 0x1: {
11746 OPC_SwitchField, 12, 3, // 655: switch Inst[14:12] {
11747 2, 7, // 658: case 0x2: {
11748 OPC_CheckPredicate, 130, 1, // 660: check predicate 130
11749 OPC_Decode, 175, 107, 54, // 663: decode to AIF_AMOADDG_W using decoder 54
11750 // 663: }
11751 3, 0, // 667: case 0x3: {
11752 OPC_CheckPredicate, 130, 1, // 669: check predicate 130
11753 OPC_Decode, 174, 107, 54, // 672: decode to AIF_AMOADDG_D using decoder 54
11754 // 672: }
11755 // 672: } // switch Inst[14:12]
11756 // 672: }
11757 4, 21, // 676: case 0x4: {
11758 OPC_SwitchField, 12, 3, // 678: switch Inst[14:12] {
11759 2, 7, // 681: case 0x2: {
11760 OPC_CheckPredicate, 130, 1, // 683: check predicate 130
11761 OPC_Decode, 209, 107, 54, // 686: decode to AIF_AMOSWAPL_W using decoder 54
11762 // 686: }
11763 3, 0, // 690: case 0x3: {
11764 OPC_CheckPredicate, 130, 1, // 692: check predicate 130
11765 OPC_Decode, 208, 107, 54, // 695: decode to AIF_AMOSWAPL_D using decoder 54
11766 // 695: }
11767 // 695: } // switch Inst[14:12]
11768 // 695: }
11769 5, 21, // 699: case 0x5: {
11770 OPC_SwitchField, 12, 3, // 701: switch Inst[14:12] {
11771 2, 7, // 704: case 0x2: {
11772 OPC_CheckPredicate, 130, 1, // 706: check predicate 130
11773 OPC_Decode, 207, 107, 54, // 709: decode to AIF_AMOSWAPG_W using decoder 54
11774 // 709: }
11775 3, 0, // 713: case 0x3: {
11776 OPC_CheckPredicate, 130, 1, // 715: check predicate 130
11777 OPC_Decode, 206, 107, 54, // 718: decode to AIF_AMOSWAPG_D using decoder 54
11778 // 718: }
11779 // 718: } // switch Inst[14:12]
11780 // 718: }
11781 8, 11, // 722: case 0x8: {
11782 OPC_CheckPredicate, 130, 1, // 724: check predicate 130
11783 OPC_CheckField, 7, 8, 96, // 727: check Inst[14:7] == 0x60
11784 OPC_Decode, 128, 109, 57, // 731: decode to AIF_SBL using decoder 57
11785 // 731: }
11786 9, 11, // 735: case 0x9: {
11787 OPC_CheckPredicate, 130, 1, // 737: check predicate 130
11788 OPC_CheckField, 7, 8, 96, // 740: check Inst[14:7] == 0x60
11789 OPC_Decode, 255, 108, 57, // 744: decode to AIF_SBG using decoder 57
11790 // 744: }
11791 12, 11, // 748: case 0xc: {
11792 OPC_CheckPredicate, 130, 1, // 750: check predicate 130
11793 OPC_CheckField, 7, 8, 96, // 753: check Inst[14:7] == 0x60
11794 OPC_Decode, 130, 109, 57, // 757: decode to AIF_SHL using decoder 57
11795 // 757: }
11796 13, 11, // 761: case 0xd: {
11797 OPC_CheckPredicate, 130, 1, // 763: check predicate 130
11798 OPC_CheckField, 7, 8, 96, // 766: check Inst[14:7] == 0x60
11799 OPC_Decode, 129, 109, 57, // 770: decode to AIF_SHG using decoder 57
11800 // 770: }
11801 16, 21, // 774: case 0x10: {
11802 OPC_SwitchField, 12, 3, // 776: switch Inst[14:12] {
11803 2, 7, // 779: case 0x2: {
11804 OPC_CheckPredicate, 130, 1, // 781: check predicate 130
11805 OPC_Decode, 213, 107, 54, // 784: decode to AIF_AMOXORL_W using decoder 54
11806 // 784: }
11807 3, 0, // 788: case 0x3: {
11808 OPC_CheckPredicate, 130, 1, // 790: check predicate 130
11809 OPC_Decode, 212, 107, 54, // 793: decode to AIF_AMOXORL_D using decoder 54
11810 // 793: }
11811 // 793: } // switch Inst[14:12]
11812 // 793: }
11813 17, 21, // 797: case 0x11: {
11814 OPC_SwitchField, 12, 3, // 799: switch Inst[14:12] {
11815 2, 7, // 802: case 0x2: {
11816 OPC_CheckPredicate, 130, 1, // 804: check predicate 130
11817 OPC_Decode, 211, 107, 54, // 807: decode to AIF_AMOXORG_W using decoder 54
11818 // 807: }
11819 3, 0, // 811: case 0x3: {
11820 OPC_CheckPredicate, 130, 1, // 813: check predicate 130
11821 OPC_Decode, 210, 107, 54, // 816: decode to AIF_AMOXORG_D using decoder 54
11822 // 816: }
11823 // 816: } // switch Inst[14:12]
11824 // 816: }
11825 32, 21, // 820: case 0x20: {
11826 OPC_SwitchField, 12, 3, // 822: switch Inst[14:12] {
11827 2, 7, // 825: case 0x2: {
11828 OPC_CheckPredicate, 130, 1, // 827: check predicate 130
11829 OPC_Decode, 205, 107, 54, // 830: decode to AIF_AMOORL_W using decoder 54
11830 // 830: }
11831 3, 0, // 834: case 0x3: {
11832 OPC_CheckPredicate, 130, 1, // 836: check predicate 130
11833 OPC_Decode, 204, 107, 54, // 839: decode to AIF_AMOORL_D using decoder 54
11834 // 839: }
11835 // 839: } // switch Inst[14:12]
11836 // 839: }
11837 33, 21, // 843: case 0x21: {
11838 OPC_SwitchField, 12, 3, // 845: switch Inst[14:12] {
11839 2, 7, // 848: case 0x2: {
11840 OPC_CheckPredicate, 130, 1, // 850: check predicate 130
11841 OPC_Decode, 203, 107, 54, // 853: decode to AIF_AMOORG_W using decoder 54
11842 // 853: }
11843 3, 0, // 857: case 0x3: {
11844 OPC_CheckPredicate, 130, 1, // 859: check predicate 130
11845 OPC_Decode, 202, 107, 54, // 862: decode to AIF_AMOORG_D using decoder 54
11846 // 862: }
11847 // 862: } // switch Inst[14:12]
11848 // 862: }
11849 48, 21, // 866: case 0x30: {
11850 OPC_SwitchField, 12, 3, // 868: switch Inst[14:12] {
11851 2, 7, // 871: case 0x2: {
11852 OPC_CheckPredicate, 130, 1, // 873: check predicate 130
11853 OPC_Decode, 181, 107, 54, // 876: decode to AIF_AMOANDL_W using decoder 54
11854 // 876: }
11855 3, 0, // 880: case 0x3: {
11856 OPC_CheckPredicate, 130, 1, // 882: check predicate 130
11857 OPC_Decode, 180, 107, 54, // 885: decode to AIF_AMOANDL_D using decoder 54
11858 // 885: }
11859 // 885: } // switch Inst[14:12]
11860 // 885: }
11861 49, 21, // 889: case 0x31: {
11862 OPC_SwitchField, 12, 3, // 891: switch Inst[14:12] {
11863 2, 7, // 894: case 0x2: {
11864 OPC_CheckPredicate, 130, 1, // 896: check predicate 130
11865 OPC_Decode, 179, 107, 54, // 899: decode to AIF_AMOANDG_W using decoder 54
11866 // 899: }
11867 3, 0, // 903: case 0x3: {
11868 OPC_CheckPredicate, 130, 1, // 905: check predicate 130
11869 OPC_Decode, 178, 107, 54, // 908: decode to AIF_AMOANDG_D using decoder 54
11870 // 908: }
11871 // 908: } // switch Inst[14:12]
11872 // 908: }
11873 64, 39, // 912: case 0x40: {
11874 OPC_SwitchField, 12, 3, // 914: switch Inst[14:12] {
11875 2, 7, // 917: case 0x2: {
11876 OPC_CheckPredicate, 130, 1, // 919: check predicate 130
11877 OPC_Decode, 197, 107, 54, // 922: decode to AIF_AMOMINL_W using decoder 54
11878 // 922: }
11879 3, 7, // 926: case 0x3: {
11880 OPC_CheckPredicate, 130, 1, // 928: check predicate 130
11881 OPC_Decode, 196, 107, 54, // 931: decode to AIF_AMOMINL_D using decoder 54
11882 // 931: }
11883 6, 7, // 935: case 0x6: {
11884 OPC_CheckPredicate, 130, 1, // 937: check predicate 130
11885 OPC_Decode, 254, 108, 31, // 940: decode to AIF_PACKB using decoder 31
11886 // 940: }
11887 7, 0, // 944: case 0x7: {
11888 OPC_CheckPredicate, 130, 1, // 946: check predicate 130
11889 OPC_Decode, 214, 107, 31, // 949: decode to AIF_BITMIXB using decoder 31
11890 // 949: }
11891 // 949: } // switch Inst[14:12]
11892 // 949: }
11893 65, 21, // 953: case 0x41: {
11894 OPC_SwitchField, 12, 3, // 955: switch Inst[14:12] {
11895 2, 7, // 958: case 0x2: {
11896 OPC_CheckPredicate, 130, 1, // 960: check predicate 130
11897 OPC_Decode, 195, 107, 54, // 963: decode to AIF_AMOMING_W using decoder 54
11898 // 963: }
11899 3, 0, // 967: case 0x3: {
11900 OPC_CheckPredicate, 130, 1, // 969: check predicate 130
11901 OPC_Decode, 194, 107, 54, // 972: decode to AIF_AMOMING_D using decoder 54
11902 // 972: }
11903 // 972: } // switch Inst[14:12]
11904 // 972: }
11905 80, 21, // 976: case 0x50: {
11906 OPC_SwitchField, 12, 3, // 978: switch Inst[14:12] {
11907 2, 7, // 981: case 0x2: {
11908 OPC_CheckPredicate, 130, 1, // 983: check predicate 130
11909 OPC_Decode, 189, 107, 54, // 986: decode to AIF_AMOMAXL_W using decoder 54
11910 // 986: }
11911 3, 0, // 990: case 0x3: {
11912 OPC_CheckPredicate, 130, 1, // 992: check predicate 130
11913 OPC_Decode, 188, 107, 54, // 995: decode to AIF_AMOMAXL_D using decoder 54
11914 // 995: }
11915 // 995: } // switch Inst[14:12]
11916 // 995: }
11917 81, 21, // 999: case 0x51: {
11918 OPC_SwitchField, 12, 3, // 1001: switch Inst[14:12] {
11919 2, 7, // 1004: case 0x2: {
11920 OPC_CheckPredicate, 130, 1, // 1006: check predicate 130
11921 OPC_Decode, 187, 107, 54, // 1009: decode to AIF_AMOMAXG_W using decoder 54
11922 // 1009: }
11923 3, 0, // 1013: case 0x3: {
11924 OPC_CheckPredicate, 130, 1, // 1015: check predicate 130
11925 OPC_Decode, 186, 107, 54, // 1018: decode to AIF_AMOMAXG_D using decoder 54
11926 // 1018: }
11927 // 1018: } // switch Inst[14:12]
11928 // 1018: }
11929 96, 21, // 1022: case 0x60: {
11930 OPC_SwitchField, 12, 3, // 1024: switch Inst[14:12] {
11931 2, 7, // 1027: case 0x2: {
11932 OPC_CheckPredicate, 130, 1, // 1029: check predicate 130
11933 OPC_Decode, 201, 107, 54, // 1032: decode to AIF_AMOMINUL_W using decoder 54
11934 // 1032: }
11935 3, 0, // 1036: case 0x3: {
11936 OPC_CheckPredicate, 130, 1, // 1038: check predicate 130
11937 OPC_Decode, 200, 107, 54, // 1041: decode to AIF_AMOMINUL_D using decoder 54
11938 // 1041: }
11939 // 1041: } // switch Inst[14:12]
11940 // 1041: }
11941 97, 21, // 1045: case 0x61: {
11942 OPC_SwitchField, 12, 3, // 1047: switch Inst[14:12] {
11943 2, 7, // 1050: case 0x2: {
11944 OPC_CheckPredicate, 130, 1, // 1052: check predicate 130
11945 OPC_Decode, 199, 107, 54, // 1055: decode to AIF_AMOMINUG_W using decoder 54
11946 // 1055: }
11947 3, 0, // 1059: case 0x3: {
11948 OPC_CheckPredicate, 130, 1, // 1061: check predicate 130
11949 OPC_Decode, 198, 107, 54, // 1064: decode to AIF_AMOMINUG_D using decoder 54
11950 // 1064: }
11951 // 1064: } // switch Inst[14:12]
11952 // 1064: }
11953 112, 21, // 1068: case 0x70: {
11954 OPC_SwitchField, 12, 3, // 1070: switch Inst[14:12] {
11955 2, 7, // 1073: case 0x2: {
11956 OPC_CheckPredicate, 130, 1, // 1075: check predicate 130
11957 OPC_Decode, 193, 107, 54, // 1078: decode to AIF_AMOMAXUL_W using decoder 54
11958 // 1078: }
11959 3, 0, // 1082: case 0x3: {
11960 OPC_CheckPredicate, 130, 1, // 1084: check predicate 130
11961 OPC_Decode, 192, 107, 54, // 1087: decode to AIF_AMOMAXUL_D using decoder 54
11962 // 1087: }
11963 // 1087: } // switch Inst[14:12]
11964 // 1087: }
11965 113, 21, // 1091: case 0x71: {
11966 OPC_SwitchField, 12, 3, // 1093: switch Inst[14:12] {
11967 2, 7, // 1096: case 0x2: {
11968 OPC_CheckPredicate, 130, 1, // 1098: check predicate 130
11969 OPC_Decode, 191, 107, 54, // 1101: decode to AIF_AMOMAXUG_W using decoder 54
11970 // 1101: }
11971 3, 0, // 1105: case 0x3: {
11972 OPC_CheckPredicate, 130, 1, // 1107: check predicate 130
11973 OPC_Decode, 190, 107, 54, // 1110: decode to AIF_AMOMAXUG_D using decoder 54
11974 // 1110: }
11975 // 1110: } // switch Inst[14:12]
11976 // 1110: }
11977 120, 21, // 1114: case 0x78: {
11978 OPC_SwitchField, 12, 3, // 1116: switch Inst[14:12] {
11979 2, 7, // 1119: case 0x2: {
11980 OPC_CheckPredicate, 130, 1, // 1121: check predicate 130
11981 OPC_Decode, 185, 107, 54, // 1124: decode to AIF_AMOCMPSWAPL_W using decoder 54
11982 // 1124: }
11983 3, 0, // 1128: case 0x3: {
11984 OPC_CheckPredicate, 130, 1, // 1130: check predicate 130
11985 OPC_Decode, 184, 107, 54, // 1133: decode to AIF_AMOCMPSWAPL_D using decoder 54
11986 // 1133: }
11987 // 1133: } // switch Inst[14:12]
11988 // 1133: }
11989 121, 0, // 1137: case 0x79: {
11990 OPC_SwitchField, 12, 3, // 1139: switch Inst[14:12] {
11991 2, 7, // 1142: case 0x2: {
11992 OPC_CheckPredicate, 130, 1, // 1144: check predicate 130
11993 OPC_Decode, 183, 107, 54, // 1147: decode to AIF_AMOCMPSWAPG_W using decoder 54
11994 // 1147: }
11995 3, 0, // 1151: case 0x3: {
11996 OPC_CheckPredicate, 130, 1, // 1153: check predicate 130
11997 OPC_Decode, 182, 107, 54, // 1156: decode to AIF_AMOCMPSWAPG_D using decoder 54
11998 // 1156: }
11999 // 1156: } // switch Inst[14:12]
12000 // 1156: }
12001 // 1156: } // switch Inst[31:25]
12002 // 1156: }
12003 63, 45, // 1160: case 0x3f: {
12004 OPC_SwitchField, 12, 3, // 1162: switch Inst[14:12] {
12005 0, 12, // 1165: case 0x0: {
12006 OPC_CheckPredicate, 130, 1, // 1167: check predicate 130
12007 OPC_CheckField, 25, 2, 2, // 1170: check Inst[26:25] == 0x2
12008 OPC_Decode, 219, 107, 179, 1, // 1174: decode to AIF_FADDI_PI using decoder 179
12009 // 1174: }
12010 1, 12, // 1179: case 0x1: {
12011 OPC_CheckPredicate, 130, 1, // 1181: check predicate 130
12012 OPC_CheckField, 25, 2, 2, // 1184: check Inst[26:25] == 0x2
12013 OPC_Decode, 244, 107, 179, 1, // 1188: decode to AIF_FANDI_PI using decoder 179
12014 // 1188: }
12015 2, 0, // 1193: case 0x2: {
12016 OPC_CheckPredicate, 130, 1, // 1195: check predicate 130
12017 OPC_CheckField, 25, 2, 2, // 1198: check Inst[26:25] == 0x2
12018 OPC_Decode, 252, 107, 180, 1, // 1202: decode to AIF_FCMOV_PS using decoder 180
12019 // 1202: }
12020 // 1202: } // switch Inst[14:12]
12021 // 1202: }
12022 91, 43, // 1207: case 0x5b: {
12023 OPC_SwitchField, 25, 2, // 1209: switch Inst[26:25] {
12024 0, 8, // 1212: case 0x0: {
12025 OPC_CheckPredicate, 130, 1, // 1214: check predicate 130
12026 OPC_Decode, 184, 108, 181, 1, // 1217: decode to AIF_FMADD_PS using decoder 181
12027 // 1217: }
12028 1, 8, // 1222: case 0x1: {
12029 OPC_CheckPredicate, 130, 1, // 1224: check predicate 130
12030 OPC_Decode, 191, 108, 181, 1, // 1227: decode to AIF_FMSUB_PS using decoder 181
12031 // 1227: }
12032 2, 8, // 1232: case 0x2: {
12033 OPC_CheckPredicate, 130, 1, // 1234: check predicate 130
12034 OPC_Decode, 199, 108, 181, 1, // 1237: decode to AIF_FNMSUB_PS using decoder 181
12035 // 1237: }
12036 3, 0, // 1242: case 0x3: {
12037 OPC_CheckPredicate, 130, 1, // 1244: check predicate 130
12038 OPC_Decode, 198, 108, 181, 1, // 1247: decode to AIF_FNMADD_PS using decoder 181
12039 // 1247: }
12040 // 1247: } // switch Inst[26:25]
12041 // 1247: }
12042 95, 8, // 1252: case 0x5f: {
12043 OPC_CheckPredicate, 130, 1, // 1254: check predicate 130
12044 OPC_Decode, 246, 107, 178, 1, // 1257: decode to AIF_FBCI_PI using decoder 178
12045 // 1257: }
12046 119, 16, // 1262: case 0x77: {
12047 OPC_CheckPredicate, 130, 1, // 1264: check predicate 130
12048 OPC_CheckField, 25, 7, 0, // 1267: check Inst[31:25] == 0x0
12049 OPC_CheckField, 12, 3, 0, // 1271: check Inst[14:12] == 0x0
12050 OPC_Decode, 251, 107, 182, 1, // 1275: decode to AIF_FCMOVM_PS using decoder 182
12051 // 1275: }
12052 123, 0, // 1280: case 0x7b: {
12053 OPC_SwitchField, 25, 7, // 1282: switch Inst[31:25] {
12054 0, 8, // 1285: case 0x0: {
12055 OPC_CheckPredicate, 130, 1, // 1287: check predicate 130
12056 OPC_Decode, 221, 107, 183, 1, // 1290: decode to AIF_FADD_PS using decoder 183
12057 // 1290: }
12058 3, 102, // 1295: case 0x3: {
12059 OPC_SwitchField, 12, 3, // 1297: switch Inst[14:12] {
12060 0, 8, // 1300: case 0x0: {
12061 OPC_CheckPredicate, 130, 1, // 1302: check predicate 130
12062 OPC_Decode, 220, 107, 182, 1, // 1305: decode to AIF_FADD_PI using decoder 182
12063 // 1305: }
12064 1, 8, // 1310: case 0x1: {
12065 OPC_CheckPredicate, 130, 1, // 1312: check predicate 130
12066 OPC_Decode, 230, 108, 182, 1, // 1315: decode to AIF_FSLL_PI using decoder 182
12067 // 1315: }
12068 2, 12, // 1320: case 0x2: {
12069 OPC_CheckPredicate, 130, 1, // 1322: check predicate 130
12070 OPC_CheckField, 20, 5, 0, // 1325: check Inst[24:20] == 0x0
12071 OPC_Decode, 200, 108, 184, 1, // 1329: decode to AIF_FNOT_PI using decoder 184
12072 // 1329: }
12073 3, 23, // 1334: case 0x3: {
12074 OPC_SwitchField, 20, 5, // 1336: switch Inst[24:20] {
12075 0, 8, // 1339: case 0x0: {
12076 OPC_CheckPredicate, 130, 1, // 1341: check predicate 130
12077 OPC_Decode, 210, 108, 184, 1, // 1344: decode to AIF_FSAT8_PI using decoder 184
12078 // 1344: }
12079 1, 0, // 1349: case 0x1: {
12080 OPC_CheckPredicate, 130, 1, // 1351: check predicate 130
12081 OPC_Decode, 211, 108, 184, 1, // 1354: decode to AIF_FSATU8_PI using decoder 184
12082 // 1354: }
12083 // 1354: } // switch Inst[24:20]
12084 // 1354: }
12085 4, 8, // 1359: case 0x4: {
12086 OPC_CheckPredicate, 130, 1, // 1361: check predicate 130
12087 OPC_Decode, 243, 108, 182, 1, // 1364: decode to AIF_FXOR_PI using decoder 182
12088 // 1364: }
12089 5, 8, // 1369: case 0x5: {
12090 OPC_CheckPredicate, 130, 1, // 1371: check predicate 130
12091 OPC_Decode, 236, 108, 182, 1, // 1374: decode to AIF_FSRL_PI using decoder 182
12092 // 1374: }
12093 6, 8, // 1379: case 0x6: {
12094 OPC_CheckPredicate, 130, 1, // 1381: check predicate 130
12095 OPC_Decode, 201, 108, 182, 1, // 1384: decode to AIF_FOR_PI using decoder 182
12096 // 1384: }
12097 7, 0, // 1389: case 0x7: {
12098 OPC_CheckPredicate, 130, 1, // 1391: check predicate 130
12099 OPC_Decode, 245, 107, 182, 1, // 1394: decode to AIF_FAND_PI using decoder 182
12100 // 1394: }
12101 // 1394: } // switch Inst[14:12]
12102 // 1394: }
12103 4, 8, // 1399: case 0x4: {
12104 OPC_CheckPredicate, 130, 1, // 1401: check predicate 130
12105 OPC_Decode, 238, 108, 183, 1, // 1404: decode to AIF_FSUB_PS using decoder 183
12106 // 1404: }
12107 7, 23, // 1409: case 0x7: {
12108 OPC_SwitchField, 12, 3, // 1411: switch Inst[14:12] {
12109 0, 8, // 1414: case 0x0: {
12110 OPC_CheckPredicate, 130, 1, // 1416: check predicate 130
12111 OPC_Decode, 237, 108, 182, 1, // 1419: decode to AIF_FSUB_PI using decoder 182
12112 // 1419: }
12113 5, 0, // 1424: case 0x5: {
12114 OPC_CheckPredicate, 130, 1, // 1426: check predicate 130
12115 OPC_Decode, 234, 108, 182, 1, // 1429: decode to AIF_FSRA_PI using decoder 182
12116 // 1429: }
12117 // 1429: } // switch Inst[14:12]
12118 // 1429: }
12119 8, 8, // 1434: case 0x8: {
12120 OPC_CheckPredicate, 130, 1, // 1436: check predicate 130
12121 OPC_Decode, 195, 108, 183, 1, // 1439: decode to AIF_FMUL_PS using decoder 183
12122 // 1439: }
12123 11, 33, // 1444: case 0xb: {
12124 OPC_SwitchField, 12, 3, // 1446: switch Inst[14:12] {
12125 0, 8, // 1449: case 0x0: {
12126 OPC_CheckPredicate, 130, 1, // 1451: check predicate 130
12127 OPC_Decode, 194, 108, 182, 1, // 1454: decode to AIF_FMUL_PI using decoder 182
12128 // 1454: }
12129 1, 8, // 1459: case 0x1: {
12130 OPC_CheckPredicate, 130, 1, // 1461: check predicate 130
12131 OPC_Decode, 193, 108, 182, 1, // 1464: decode to AIF_FMULH_PI using decoder 182
12132 // 1464: }
12133 2, 0, // 1469: case 0x2: {
12134 OPC_CheckPredicate, 130, 1, // 1471: check predicate 130
12135 OPC_Decode, 192, 108, 182, 1, // 1474: decode to AIF_FMULHU_PI using decoder 182
12136 // 1474: }
12137 // 1474: } // switch Inst[14:12]
12138 // 1474: }
12139 12, 8, // 1479: case 0xc: {
12140 OPC_CheckPredicate, 130, 1, // 1481: check predicate 130
12141 OPC_Decode, 153, 108, 183, 1, // 1484: decode to AIF_FDIV_PS using decoder 183
12142 // 1484: }
12143 15, 43, // 1489: case 0xf: {
12144 OPC_SwitchField, 12, 3, // 1491: switch Inst[14:12] {
12145 0, 8, // 1494: case 0x0: {
12146 OPC_CheckPredicate, 130, 1, // 1496: check predicate 130
12147 OPC_Decode, 152, 108, 182, 1, // 1499: decode to AIF_FDIV_PI using decoder 182
12148 // 1499: }
12149 1, 8, // 1504: case 0x1: {
12150 OPC_CheckPredicate, 130, 1, // 1506: check predicate 130
12151 OPC_Decode, 151, 108, 182, 1, // 1509: decode to AIF_FDIVU_PI using decoder 182
12152 // 1509: }
12153 2, 8, // 1514: case 0x2: {
12154 OPC_CheckPredicate, 130, 1, // 1516: check predicate 130
12155 OPC_Decode, 207, 108, 182, 1, // 1519: decode to AIF_FREM_PI using decoder 182
12156 // 1519: }
12157 3, 0, // 1524: case 0x3: {
12158 OPC_CheckPredicate, 130, 1, // 1526: check predicate 130
12159 OPC_Decode, 206, 108, 182, 1, // 1529: decode to AIF_FREMU_PI using decoder 182
12160 // 1529: }
12161 // 1529: } // switch Inst[14:12]
12162 // 1529: }
12163 16, 33, // 1534: case 0x10: {
12164 OPC_SwitchField, 12, 3, // 1536: switch Inst[14:12] {
12165 0, 8, // 1539: case 0x0: {
12166 OPC_CheckPredicate, 130, 1, // 1541: check predicate 130
12167 OPC_Decode, 227, 108, 182, 1, // 1544: decode to AIF_FSGNJ_PS using decoder 182
12168 // 1544: }
12169 1, 8, // 1549: case 0x1: {
12170 OPC_CheckPredicate, 130, 1, // 1551: check predicate 130
12171 OPC_Decode, 225, 108, 182, 1, // 1554: decode to AIF_FSGNJN_PS using decoder 182
12172 // 1554: }
12173 2, 0, // 1559: case 0x2: {
12174 OPC_CheckPredicate, 130, 1, // 1561: check predicate 130
12175 OPC_Decode, 226, 108, 182, 1, // 1564: decode to AIF_FSGNJX_PS using decoder 182
12176 // 1564: }
12177 // 1564: } // switch Inst[14:12]
12178 // 1564: }
12179 19, 31, // 1569: case 0x13: {
12180 OPC_SwitchField, 12, 3, // 1571: switch Inst[14:12] {
12181 0, 12, // 1574: case 0x0: {
12182 OPC_CheckPredicate, 130, 1, // 1576: check predicate 130
12183 OPC_CheckField, 20, 5, 0, // 1579: check Inst[24:20] == 0x0
12184 OPC_Decode, 202, 108, 184, 1, // 1583: decode to AIF_FPACKREPB_PI using decoder 184
12185 // 1583: }
12186 1, 0, // 1588: case 0x1: {
12187 OPC_CheckPredicate, 130, 1, // 1590: check predicate 130
12188 OPC_CheckField, 20, 5, 0, // 1593: check Inst[24:20] == 0x0
12189 OPC_Decode, 203, 108, 184, 1, // 1597: decode to AIF_FPACKREPH_PI using decoder 184
12190 // 1597: }
12191 // 1597: } // switch Inst[14:12]
12192 // 1597: }
12193 20, 23, // 1602: case 0x14: {
12194 OPC_SwitchField, 12, 3, // 1604: switch Inst[14:12] {
12195 0, 8, // 1607: case 0x0: {
12196 OPC_CheckPredicate, 130, 1, // 1609: check predicate 130
12197 OPC_Decode, 190, 108, 182, 1, // 1612: decode to AIF_FMIN_PS using decoder 182
12198 // 1612: }
12199 1, 0, // 1617: case 0x1: {
12200 OPC_CheckPredicate, 130, 1, // 1619: check predicate 130
12201 OPC_Decode, 187, 108, 182, 1, // 1622: decode to AIF_FMAX_PS using decoder 182
12202 // 1622: }
12203 // 1622: } // switch Inst[14:12]
12204 // 1622: }
12205 23, 43, // 1627: case 0x17: {
12206 OPC_SwitchField, 12, 3, // 1629: switch Inst[14:12] {
12207 0, 8, // 1632: case 0x0: {
12208 OPC_CheckPredicate, 130, 1, // 1634: check predicate 130
12209 OPC_Decode, 189, 108, 182, 1, // 1637: decode to AIF_FMIN_PI using decoder 182
12210 // 1637: }
12211 1, 8, // 1642: case 0x1: {
12212 OPC_CheckPredicate, 130, 1, // 1644: check predicate 130
12213 OPC_Decode, 186, 108, 182, 1, // 1647: decode to AIF_FMAX_PI using decoder 182
12214 // 1647: }
12215 2, 8, // 1652: case 0x2: {
12216 OPC_CheckPredicate, 130, 1, // 1654: check predicate 130
12217 OPC_Decode, 188, 108, 182, 1, // 1657: decode to AIF_FMINU_PI using decoder 182
12218 // 1657: }
12219 3, 0, // 1662: case 0x3: {
12220 OPC_CheckPredicate, 130, 1, // 1664: check predicate 130
12221 OPC_Decode, 185, 108, 182, 1, // 1667: decode to AIF_FMAXU_PI using decoder 182
12222 // 1667: }
12223 // 1667: } // switch Inst[14:12]
12224 // 1667: }
12225 24, 12, // 1672: case 0x18: {
12226 OPC_CheckPredicate, 130, 1, // 1674: check predicate 130
12227 OPC_CheckField, 12, 3, 0, // 1677: check Inst[14:12] == 0x0
12228 OPC_Decode, 204, 108, 182, 1, // 1681: decode to AIF_FRCP_FIX_RAST using decoder 182
12229 // 1681: }
12230 31, 12, // 1686: case 0x1f: {
12231 OPC_CheckPredicate, 130, 1, // 1688: check predicate 130
12232 OPC_CheckField, 12, 3, 0, // 1691: check Inst[14:12] == 0x0
12233 OPC_Decode, 176, 108, 185, 1, // 1695: decode to AIF_FLTM_PI using decoder 185
12234 // 1695: }
12235 39, 33, // 1700: case 0x27: {
12236 OPC_SwitchField, 12, 3, // 1702: switch Inst[14:12] {
12237 1, 8, // 1705: case 0x1: {
12238 OPC_CheckPredicate, 130, 1, // 1707: check predicate 130
12239 OPC_Decode, 229, 108, 186, 1, // 1710: decode to AIF_FSLLI_PI using decoder 186
12240 // 1710: }
12241 5, 8, // 1715: case 0x5: {
12242 OPC_CheckPredicate, 130, 1, // 1717: check predicate 130
12243 OPC_Decode, 235, 108, 186, 1, // 1720: decode to AIF_FSRLI_PI using decoder 186
12244 // 1720: }
12245 7, 0, // 1725: case 0x7: {
12246 OPC_CheckPredicate, 130, 1, // 1727: check predicate 130
12247 OPC_Decode, 233, 108, 186, 1, // 1730: decode to AIF_FSRAI_PI using decoder 186
12248 // 1730: }
12249 // 1730: } // switch Inst[14:12]
12250 // 1730: }
12251 41, 16, // 1735: case 0x29: {
12252 OPC_CheckPredicate, 130, 1, // 1737: check predicate 130
12253 OPC_CheckField, 18, 7, 0, // 1740: check Inst[24:18] == 0x0
12254 OPC_CheckField, 12, 3, 0, // 1744: check Inst[14:12] == 0x0
12255 OPC_Decode, 247, 108, 187, 1, // 1748: decode to AIF_MASKPOPC using decoder 187
12256 // 1748: }
12257 42, 16, // 1753: case 0x2a: {
12258 OPC_CheckPredicate, 130, 1, // 1755: check predicate 130
12259 OPC_CheckField, 18, 7, 0, // 1758: check Inst[24:18] == 0x0
12260 OPC_CheckField, 12, 3, 0, // 1762: check Inst[14:12] == 0x0
12261 OPC_Decode, 248, 108, 187, 1, // 1766: decode to AIF_MASKPOPCZ using decoder 187
12262 // 1766: }
12263 43, 12, // 1771: case 0x2b: {
12264 OPC_CheckPredicate, 130, 1, // 1773: check predicate 130
12265 OPC_CheckField, 10, 2, 0, // 1776: check Inst[11:10] == 0x0
12266 OPC_Decode, 253, 108, 188, 1, // 1780: decode to AIF_MOV_M_X using decoder 188
12267 // 1780: }
12268 44, 111, // 1785: case 0x2c: {
12269 OPC_SwitchField, 20, 5, // 1787: switch Inst[24:20] {
12270 0, 12, // 1790: case 0x0: {
12271 OPC_CheckPredicate, 130, 1, // 1792: check predicate 130
12272 OPC_CheckField, 12, 3, 0, // 1795: check Inst[14:12] == 0x0
12273 OPC_Decode, 232, 108, 184, 1, // 1799: decode to AIF_FSQRT_PS using decoder 184
12274 // 1799: }
12275 1, 8, // 1804: case 0x1: {
12276 OPC_CheckPredicate, 130, 1, // 1806: check predicate 130
12277 OPC_Decode, 208, 108, 189, 1, // 1809: decode to AIF_FROUND_PS using decoder 189
12278 // 1809: }
12279 2, 12, // 1814: case 0x2: {
12280 OPC_CheckPredicate, 130, 1, // 1816: check predicate 130
12281 OPC_CheckField, 12, 3, 0, // 1819: check Inst[14:12] == 0x0
12282 OPC_Decode, 158, 108, 184, 1, // 1823: decode to AIF_FFRC_PS using decoder 184
12283 // 1823: }
12284 3, 12, // 1828: case 0x3: {
12285 OPC_CheckPredicate, 130, 1, // 1830: check predicate 130
12286 OPC_CheckField, 12, 3, 0, // 1833: check Inst[14:12] == 0x0
12287 OPC_Decode, 174, 108, 184, 1, // 1837: decode to AIF_FLOG_PS using decoder 184
12288 // 1837: }
12289 4, 12, // 1842: case 0x4: {
12290 OPC_CheckPredicate, 130, 1, // 1844: check predicate 130
12291 OPC_CheckField, 12, 3, 0, // 1847: check Inst[14:12] == 0x0
12292 OPC_Decode, 157, 108, 184, 1, // 1851: decode to AIF_FEXP_PS using decoder 184
12293 // 1851: }
12294 6, 12, // 1856: case 0x6: {
12295 OPC_CheckPredicate, 130, 1, // 1858: check predicate 130
12296 OPC_CheckField, 12, 3, 0, // 1861: check Inst[14:12] == 0x0
12297 OPC_Decode, 228, 108, 184, 1, // 1865: decode to AIF_FSIN_PS using decoder 184
12298 // 1865: }
12299 7, 12, // 1870: case 0x7: {
12300 OPC_CheckPredicate, 130, 1, // 1872: check predicate 130
12301 OPC_CheckField, 12, 3, 0, // 1875: check Inst[14:12] == 0x0
12302 OPC_Decode, 205, 108, 184, 1, // 1879: decode to AIF_FRCP_PS using decoder 184
12303 // 1879: }
12304 8, 0, // 1884: case 0x8: {
12305 OPC_CheckPredicate, 130, 1, // 1886: check predicate 130
12306 OPC_CheckField, 12, 3, 0, // 1889: check Inst[14:12] == 0x0
12307 OPC_Decode, 209, 108, 184, 1, // 1893: decode to AIF_FRSQ_PS using decoder 184
12308 // 1893: }
12309 // 1893: } // switch Inst[24:20]
12310 // 1893: }
12311 47, 12, // 1898: case 0x2f: {
12312 OPC_CheckPredicate, 130, 1, // 1900: check predicate 130
12313 OPC_CheckField, 12, 3, 0, // 1903: check Inst[14:12] == 0x0
12314 OPC_Decode, 249, 108, 190, 1, // 1907: decode to AIF_MASKPOPC_ET_RAST using decoder 190
12315 // 1907: }
12316 51, 71, // 1912: case 0x33: {
12317 OPC_SwitchField, 10, 5, // 1914: switch Inst[14:10] {
12318 8, 12, // 1917: case 0x8: {
12319 OPC_CheckPredicate, 130, 1, // 1919: check predicate 130
12320 OPC_CheckField, 18, 7, 0, // 1922: check Inst[24:18] == 0x0
12321 OPC_Decode, 245, 108, 191, 1, // 1926: decode to AIF_MASKNOT using decoder 191
12322 // 1926: }
12323 16, 16, // 1931: case 0x10: {
12324 OPC_CheckPredicate, 130, 1, // 1933: check predicate 130
12325 OPC_CheckField, 23, 2, 0, // 1936: check Inst[24:23] == 0x0
12326 OPC_CheckField, 18, 2, 0, // 1940: check Inst[19:18] == 0x0
12327 OPC_Decode, 250, 108, 192, 1, // 1944: decode to AIF_MASKXOR using decoder 192
12328 // 1944: }
12329 24, 16, // 1949: case 0x18: {
12330 OPC_CheckPredicate, 130, 1, // 1951: check predicate 130
12331 OPC_CheckField, 23, 2, 0, // 1954: check Inst[24:23] == 0x0
12332 OPC_CheckField, 18, 2, 0, // 1958: check Inst[19:18] == 0x0
12333 OPC_Decode, 246, 108, 192, 1, // 1962: decode to AIF_MASKOR using decoder 192
12334 // 1962: }
12335 28, 0, // 1967: case 0x1c: {
12336 OPC_CheckPredicate, 130, 1, // 1969: check predicate 130
12337 OPC_CheckField, 23, 2, 0, // 1972: check Inst[24:23] == 0x0
12338 OPC_CheckField, 18, 2, 0, // 1976: check Inst[19:18] == 0x0
12339 OPC_Decode, 244, 108, 192, 1, // 1980: decode to AIF_MASKAND using decoder 192
12340 // 1980: }
12341 // 1980: } // switch Inst[14:10]
12342 // 1980: }
12343 68, 43, // 1985: case 0x44: {
12344 OPC_SwitchField, 12, 3, // 1987: switch Inst[14:12] {
12345 0, 8, // 1990: case 0x0: {
12346 OPC_CheckPredicate, 130, 1, // 1992: check predicate 130
12347 OPC_Decode, 216, 107, 182, 1, // 1995: decode to AIF_CUBEFACE_PS using decoder 182
12348 // 1995: }
12349 1, 8, // 2000: case 0x1: {
12350 OPC_CheckPredicate, 130, 1, // 2002: check predicate 130
12351 OPC_Decode, 215, 107, 182, 1, // 2005: decode to AIF_CUBEFACEIDX_PS using decoder 182
12352 // 2005: }
12353 2, 8, // 2010: case 0x2: {
12354 OPC_CheckPredicate, 130, 1, // 2012: check predicate 130
12355 OPC_Decode, 217, 107, 182, 1, // 2015: decode to AIF_CUBESGNSC_PS using decoder 182
12356 // 2015: }
12357 3, 0, // 2020: case 0x3: {
12358 OPC_CheckPredicate, 130, 1, // 2022: check predicate 130
12359 OPC_Decode, 218, 107, 182, 1, // 2025: decode to AIF_CUBESGNTC_PS using decoder 182
12360 // 2025: }
12361 // 2025: } // switch Inst[14:12]
12362 // 2025: }
12363 80, 63, // 2030: case 0x50: {
12364 OPC_SwitchField, 12, 3, // 2032: switch Inst[14:12] {
12365 0, 8, // 2035: case 0x0: {
12366 OPC_CheckPredicate, 130, 1, // 2037: check predicate 130
12367 OPC_Decode, 173, 108, 182, 1, // 2040: decode to AIF_FLE_PS using decoder 182
12368 // 2040: }
12369 1, 8, // 2045: case 0x1: {
12370 OPC_CheckPredicate, 130, 1, // 2047: check predicate 130
12371 OPC_Decode, 180, 108, 182, 1, // 2050: decode to AIF_FLT_PS using decoder 182
12372 // 2050: }
12373 2, 8, // 2055: case 0x2: {
12374 OPC_CheckPredicate, 130, 1, // 2057: check predicate 130
12375 OPC_Decode, 156, 108, 182, 1, // 2060: decode to AIF_FEQ_PS using decoder 182
12376 // 2060: }
12377 4, 8, // 2065: case 0x4: {
12378 OPC_CheckPredicate, 130, 1, // 2067: check predicate 130
12379 OPC_Decode, 171, 108, 185, 1, // 2070: decode to AIF_FLEM_PS using decoder 185
12380 // 2070: }
12381 5, 8, // 2075: case 0x5: {
12382 OPC_CheckPredicate, 130, 1, // 2077: check predicate 130
12383 OPC_Decode, 177, 108, 185, 1, // 2080: decode to AIF_FLTM_PS using decoder 185
12384 // 2080: }
12385 6, 0, // 2085: case 0x6: {
12386 OPC_CheckPredicate, 130, 1, // 2087: check predicate 130
12387 OPC_Decode, 154, 108, 185, 1, // 2090: decode to AIF_FEQM_PS using decoder 185
12388 // 2090: }
12389 // 2090: } // switch Inst[14:12]
12390 // 2090: }
12391 83, 57, // 2095: case 0x53: {
12392 OPC_SwitchField, 12, 3, // 2097: switch Inst[14:12] {
12393 0, 8, // 2100: case 0x0: {
12394 OPC_CheckPredicate, 130, 1, // 2102: check predicate 130
12395 OPC_Decode, 172, 108, 182, 1, // 2105: decode to AIF_FLE_PI using decoder 182
12396 // 2105: }
12397 1, 8, // 2110: case 0x1: {
12398 OPC_CheckPredicate, 130, 1, // 2112: check predicate 130
12399 OPC_Decode, 179, 108, 182, 1, // 2115: decode to AIF_FLT_PI using decoder 182
12400 // 2115: }
12401 2, 8, // 2120: case 0x2: {
12402 OPC_CheckPredicate, 130, 1, // 2122: check predicate 130
12403 OPC_Decode, 155, 108, 182, 1, // 2125: decode to AIF_FEQ_PI using decoder 182
12404 // 2125: }
12405 3, 8, // 2130: case 0x3: {
12406 OPC_CheckPredicate, 130, 1, // 2132: check predicate 130
12407 OPC_Decode, 178, 108, 182, 1, // 2135: decode to AIF_FLTU_PI using decoder 182
12408 // 2135: }
12409 4, 0, // 2140: case 0x4: {
12410 OPC_CheckPredicate, 130, 1, // 2142: check predicate 130
12411 OPC_CheckField, 20, 5, 0, // 2145: check Inst[24:20] == 0x0
12412 OPC_Decode, 224, 108, 193, 1, // 2149: decode to AIF_FSETM_PI using decoder 193
12413 // 2149: }
12414 // 2149: } // switch Inst[14:12]
12415 // 2149: }
12416 96, 37, // 2154: case 0x60: {
12417 OPC_SwitchField, 20, 5, // 2156: switch Inst[24:20] {
12418 0, 8, // 2159: case 0x0: {
12419 OPC_CheckPredicate, 130, 1, // 2161: check predicate 130
12420 OPC_Decode, 142, 108, 189, 1, // 2164: decode to AIF_FCVT_PW_PS using decoder 189
12421 // 2164: }
12422 1, 8, // 2169: case 0x1: {
12423 OPC_CheckPredicate, 130, 1, // 2171: check predicate 130
12424 OPC_Decode, 141, 108, 189, 1, // 2174: decode to AIF_FCVT_PWU_PS using decoder 189
12425 // 2174: }
12426 2, 0, // 2179: case 0x2: {
12427 OPC_CheckPredicate, 130, 1, // 2181: check predicate 130
12428 OPC_CheckField, 12, 3, 0, // 2184: check Inst[14:12] == 0x0
12429 OPC_Decode, 143, 108, 184, 1, // 2188: decode to AIF_FCVT_RAST_PS using decoder 184
12430 // 2188: }
12431 // 2188: } // switch Inst[24:20]
12432 // 2188: }
12433 104, 177, 1, // 2193: case 0x68: {
12434 OPC_SwitchField, 20, 5, // 2196: switch Inst[24:20] {
12435 0, 8, // 2199: case 0x0: {
12436 OPC_CheckPredicate, 130, 1, // 2201: check predicate 130
12437 OPC_Decode, 131, 108, 189, 1, // 2204: decode to AIF_FCVT_PS_PW using decoder 189
12438 // 2204: }
12439 1, 8, // 2209: case 0x1: {
12440 OPC_CheckPredicate, 130, 1, // 2211: check predicate 130
12441 OPC_Decode, 132, 108, 189, 1, // 2214: decode to AIF_FCVT_PS_PWU using decoder 189
12442 // 2214: }
12443 2, 12, // 2219: case 0x2: {
12444 OPC_CheckPredicate, 130, 1, // 2221: check predicate 130
12445 OPC_CheckField, 12, 3, 0, // 2224: check Inst[14:12] == 0x0
12446 OPC_Decode, 133, 108, 184, 1, // 2228: decode to AIF_FCVT_PS_RAST using decoder 184
12447 // 2228: }
12448 8, 12, // 2233: case 0x8: {
12449 OPC_CheckPredicate, 130, 1, // 2235: check predicate 130
12450 OPC_CheckField, 12, 3, 0, // 2238: check Inst[14:12] == 0x0
12451 OPC_Decode, 128, 108, 184, 1, // 2242: decode to AIF_FCVT_PS_F10 using decoder 184
12452 // 2242: }
12453 9, 12, // 2247: case 0x9: {
12454 OPC_CheckPredicate, 130, 1, // 2249: check predicate 130
12455 OPC_CheckField, 12, 3, 0, // 2252: check Inst[14:12] == 0x0
12456 OPC_Decode, 129, 108, 184, 1, // 2256: decode to AIF_FCVT_PS_F11 using decoder 184
12457 // 2256: }
12458 10, 12, // 2261: case 0xa: {
12459 OPC_CheckPredicate, 130, 1, // 2263: check predicate 130
12460 OPC_CheckField, 12, 3, 0, // 2266: check Inst[14:12] == 0x0
12461 OPC_Decode, 130, 108, 184, 1, // 2270: decode to AIF_FCVT_PS_F16 using decoder 184
12462 // 2270: }
12463 16, 12, // 2275: case 0x10: {
12464 OPC_CheckPredicate, 130, 1, // 2277: check predicate 130
12465 OPC_CheckField, 12, 3, 0, // 2280: check Inst[14:12] == 0x0
12466 OPC_Decode, 139, 108, 184, 1, // 2284: decode to AIF_FCVT_PS_UN24 using decoder 184
12467 // 2284: }
12468 17, 12, // 2289: case 0x11: {
12469 OPC_CheckPredicate, 130, 1, // 2291: check predicate 130
12470 OPC_CheckField, 12, 3, 0, // 2294: check Inst[14:12] == 0x0
12471 OPC_Decode, 137, 108, 184, 1, // 2298: decode to AIF_FCVT_PS_UN16 using decoder 184
12472 // 2298: }
12473 18, 12, // 2303: case 0x12: {
12474 OPC_CheckPredicate, 130, 1, // 2305: check predicate 130
12475 OPC_CheckField, 12, 3, 0, // 2308: check Inst[14:12] == 0x0
12476 OPC_Decode, 136, 108, 184, 1, // 2312: decode to AIF_FCVT_PS_UN10 using decoder 184
12477 // 2312: }
12478 19, 12, // 2317: case 0x13: {
12479 OPC_CheckPredicate, 130, 1, // 2319: check predicate 130
12480 OPC_CheckField, 12, 3, 0, // 2322: check Inst[14:12] == 0x0
12481 OPC_Decode, 140, 108, 184, 1, // 2326: decode to AIF_FCVT_PS_UN8 using decoder 184
12482 // 2326: }
12483 23, 12, // 2331: case 0x17: {
12484 OPC_CheckPredicate, 130, 1, // 2333: check predicate 130
12485 OPC_CheckField, 12, 3, 0, // 2336: check Inst[14:12] == 0x0
12486 OPC_Decode, 138, 108, 184, 1, // 2340: decode to AIF_FCVT_PS_UN2 using decoder 184
12487 // 2340: }
12488 25, 12, // 2345: case 0x19: {
12489 OPC_CheckPredicate, 130, 1, // 2347: check predicate 130
12490 OPC_CheckField, 12, 3, 0, // 2350: check Inst[14:12] == 0x0
12491 OPC_Decode, 134, 108, 184, 1, // 2354: decode to AIF_FCVT_PS_SN16 using decoder 184
12492 // 2354: }
12493 27, 0, // 2359: case 0x1b: {
12494 OPC_CheckPredicate, 130, 1, // 2361: check predicate 130
12495 OPC_CheckField, 12, 3, 0, // 2364: check Inst[14:12] == 0x0
12496 OPC_Decode, 135, 108, 184, 1, // 2368: decode to AIF_FCVT_PS_SN8 using decoder 184
12497 // 2368: }
12498 // 2368: } // switch Inst[24:20]
12499 // 2368: }
12500 107, 34, // 2373: case 0x6b: {
12501 OPC_SwitchField, 12, 3, // 2375: switch Inst[14:12] {
12502 0, 12, // 2378: case 0x0: {
12503 OPC_CheckPredicate, 130, 1, // 2380: check predicate 130
12504 OPC_CheckField, 15, 10, 0, // 2383: check Inst[24:15] == 0x0
12505 OPC_Decode, 252, 108, 194, 1, // 2387: decode to AIF_MOVA_X_M using decoder 194
12506 // 2387: }
12507 1, 0, // 2392: case 0x1: {
12508 OPC_CheckPredicate, 130, 1, // 2394: check predicate 130
12509 OPC_CheckField, 20, 5, 0, // 2397: check Inst[24:20] == 0x0
12510 OPC_CheckField, 7, 5, 0, // 2401: check Inst[11:7] == 0x0
12511 OPC_Decode, 251, 108, 15, // 2405: decode to AIF_MOVA_M_X using decoder 15
12512 // 2405: }
12513 // 2405: } // switch Inst[14:12]
12514 // 2405: }
12515 108, 143, 1, // 2409: case 0x6c: {
12516 OPC_SwitchField, 20, 5, // 2412: switch Inst[24:20] {
12517 8, 12, // 2415: case 0x8: {
12518 OPC_CheckPredicate, 130, 1, // 2417: check predicate 130
12519 OPC_CheckField, 12, 3, 0, // 2420: check Inst[14:12] == 0x0
12520 OPC_Decode, 254, 107, 184, 1, // 2424: decode to AIF_FCVT_F11_PS using decoder 184
12521 // 2424: }
12522 9, 12, // 2429: case 0x9: {
12523 OPC_CheckPredicate, 130, 1, // 2431: check predicate 130
12524 OPC_CheckField, 12, 3, 0, // 2434: check Inst[14:12] == 0x0
12525 OPC_Decode, 255, 107, 184, 1, // 2438: decode to AIF_FCVT_F16_PS using decoder 184
12526 // 2438: }
12527 11, 12, // 2443: case 0xb: {
12528 OPC_CheckPredicate, 130, 1, // 2445: check predicate 130
12529 OPC_CheckField, 12, 3, 0, // 2448: check Inst[14:12] == 0x0
12530 OPC_Decode, 253, 107, 184, 1, // 2452: decode to AIF_FCVT_F10_PS using decoder 184
12531 // 2452: }
12532 16, 12, // 2457: case 0x10: {
12533 OPC_CheckPredicate, 130, 1, // 2459: check predicate 130
12534 OPC_CheckField, 12, 3, 0, // 2462: check Inst[14:12] == 0x0
12535 OPC_Decode, 148, 108, 184, 1, // 2466: decode to AIF_FCVT_UN24_PS using decoder 184
12536 // 2466: }
12537 17, 12, // 2471: case 0x11: {
12538 OPC_CheckPredicate, 130, 1, // 2473: check predicate 130
12539 OPC_CheckField, 12, 3, 0, // 2476: check Inst[14:12] == 0x0
12540 OPC_Decode, 147, 108, 184, 1, // 2480: decode to AIF_FCVT_UN16_PS using decoder 184
12541 // 2480: }
12542 18, 12, // 2485: case 0x12: {
12543 OPC_CheckPredicate, 130, 1, // 2487: check predicate 130
12544 OPC_CheckField, 12, 3, 0, // 2490: check Inst[14:12] == 0x0
12545 OPC_Decode, 146, 108, 184, 1, // 2494: decode to AIF_FCVT_UN10_PS using decoder 184
12546 // 2494: }
12547 19, 12, // 2499: case 0x13: {
12548 OPC_CheckPredicate, 130, 1, // 2501: check predicate 130
12549 OPC_CheckField, 12, 3, 0, // 2504: check Inst[14:12] == 0x0
12550 OPC_Decode, 150, 108, 184, 1, // 2508: decode to AIF_FCVT_UN8_PS using decoder 184
12551 // 2508: }
12552 23, 12, // 2513: case 0x17: {
12553 OPC_CheckPredicate, 130, 1, // 2515: check predicate 130
12554 OPC_CheckField, 12, 3, 0, // 2518: check Inst[14:12] == 0x0
12555 OPC_Decode, 149, 108, 184, 1, // 2522: decode to AIF_FCVT_UN2_PS using decoder 184
12556 // 2522: }
12557 25, 12, // 2527: case 0x19: {
12558 OPC_CheckPredicate, 130, 1, // 2529: check predicate 130
12559 OPC_CheckField, 12, 3, 0, // 2532: check Inst[14:12] == 0x0
12560 OPC_Decode, 144, 108, 184, 1, // 2536: decode to AIF_FCVT_SN16_PS using decoder 184
12561 // 2536: }
12562 27, 0, // 2541: case 0x1b: {
12563 OPC_CheckPredicate, 130, 1, // 2543: check predicate 130
12564 OPC_CheckField, 12, 3, 0, // 2546: check Inst[14:12] == 0x0
12565 OPC_Decode, 145, 108, 184, 1, // 2550: decode to AIF_FCVT_SN8_PS using decoder 184
12566 // 2550: }
12567 // 2550: } // switch Inst[24:20]
12568 // 2550: }
12569 112, 45, // 2555: case 0x70: {
12570 OPC_SwitchField, 12, 3, // 2557: switch Inst[14:12] {
12571 0, 12, // 2560: case 0x0: {
12572 OPC_CheckPredicate, 130, 1, // 2562: check predicate 130
12573 OPC_CheckField, 23, 2, 0, // 2565: check Inst[24:23] == 0x0
12574 OPC_Decode, 197, 108, 195, 1, // 2569: decode to AIF_FMVZ_X_PS using decoder 195
12575 // 2569: }
12576 1, 12, // 2574: case 0x1: {
12577 OPC_CheckPredicate, 130, 1, // 2576: check predicate 130
12578 OPC_CheckField, 20, 5, 0, // 2579: check Inst[24:20] == 0x0
12579 OPC_Decode, 250, 107, 184, 1, // 2583: decode to AIF_FCLASS_PS using decoder 184
12580 // 2583: }
12581 2, 0, // 2588: case 0x2: {
12582 OPC_CheckPredicate, 130, 1, // 2590: check predicate 130
12583 OPC_CheckField, 23, 2, 0, // 2593: check Inst[24:23] == 0x0
12584 OPC_Decode, 196, 108, 195, 1, // 2597: decode to AIF_FMVS_X_PS using decoder 195
12585 // 2597: }
12586 // 2597: } // switch Inst[14:12]
12587 // 2597: }
12588 115, 0, // 2602: case 0x73: {
12589 OPC_CheckPredicate, 130, 1, // 2604: check predicate 130
12590 OPC_Decode, 240, 108, 196, 1, // 2607: decode to AIF_FSWIZZ_PS using decoder 196
12591 // 2607: }
12592 // 2607: } // switch Inst[31:25]
12593 // 2607: }
12594 // 2607: } // switch Inst[6:0]
12595};
12596static const uint8_t DecoderTableXAndes32[612] = {
12597 32, // 0: BitWidth 32
12598 OPC_SwitchField, 12, 2, // 1: switch Inst[13:12] {
12599 0, 150, 3, // 4: case 0x0: {
12600 OPC_SwitchField, 0, 7, // 7: switch Inst[6:0] {
12601 11, 8, // 10: case 0xb: {
12602 OPC_CheckPredicate, 131, 1, // 12: check predicate 131
12603 OPC_Decode, 226, 117, 197, 1, // 15: decode to NDS_LBGP using decoder 197
12604 // 15: }
12605 43, 23, // 20: case 0x2b: {
12606 OPC_SwitchField, 14, 1, // 22: switch Inst[14] {
12607 0, 8, // 25: case 0x0: {
12608 OPC_CheckPredicate, 131, 1, // 27: check predicate 131
12609 OPC_Decode, 242, 117, 198, 1, // 30: decode to NDS_SHGP using decoder 198
12610 // 30: }
12611 1, 0, // 35: case 0x1: {
12612 OPC_CheckPredicate, 131, 1, // 37: check predicate 131
12613 OPC_Decode, 243, 117, 199, 1, // 40: decode to NDS_SWGP using decoder 199
12614 // 40: }
12615 // 40: } // switch Inst[14]
12616 // 40: }
12617 91, 0, // 45: case 0x5b: {
12618 OPC_SwitchField, 26, 6, // 47: switch Inst[31:26] {
12619 0, 95, // 50: case 0x0: {
12620 OPC_SwitchField, 14, 6, // 52: switch Inst[19:14] {
12621 1, 12, // 55: case 0x1: {
12622 OPC_CheckPredicate, 132, 1, // 57: check predicate 132
12623 OPC_CheckField, 25, 1, 0, // 60: check Inst[25] == 0x0
12624 OPC_Decode, 254, 117, 131, 1, // 64: decode to NDS_VFWCVT_S_BF16 using decoder 131
12625 // 64: }
12626 3, 12, // 69: case 0x3: {
12627 OPC_CheckPredicate, 132, 1, // 71: check predicate 132
12628 OPC_CheckField, 25, 1, 0, // 74: check Inst[25] == 0x0
12629 OPC_Decode, 247, 117, 131, 1, // 78: decode to NDS_VFNCVT_BF16_S using decoder 131
12630 // 78: }
12631 5, 12, // 83: case 0x5: {
12632 OPC_CheckPredicate, 133, 1, // 85: check predicate 133
12633 OPC_CheckField, 25, 1, 0, // 88: check Inst[25] == 0x0
12634 OPC_Decode, 219, 117, 200, 1, // 92: decode to NDS_FCVT_S_BF16 using decoder 200
12635 // 92: }
12636 7, 12, // 97: case 0x7: {
12637 OPC_CheckPredicate, 133, 1, // 99: check predicate 133
12638 OPC_CheckField, 25, 1, 0, // 102: check Inst[25] == 0x0
12639 OPC_Decode, 218, 117, 201, 1, // 106: decode to NDS_FCVT_BF16_S using decoder 201
12640 // 106: }
12641 9, 7, // 111: case 0x9: {
12642 OPC_CheckPredicate, 134, 1, // 113: check predicate 134
12643 OPC_Decode, 252, 117, 119, // 116: decode to NDS_VFWCVT_F_N using decoder 119
12644 // 116: }
12645 11, 7, // 120: case 0xb: {
12646 OPC_CheckPredicate, 134, 1, // 122: check predicate 134
12647 OPC_Decode, 253, 117, 119, // 125: decode to NDS_VFWCVT_F_NU using decoder 119
12648 // 125: }
12649 13, 7, // 129: case 0xd: {
12650 OPC_CheckPredicate, 134, 1, // 131: check predicate 134
12651 OPC_Decode, 250, 117, 119, // 134: decode to NDS_VFWCVT_F_B using decoder 119
12652 // 134: }
12653 15, 0, // 138: case 0xf: {
12654 OPC_CheckPredicate, 134, 1, // 140: check predicate 134
12655 OPC_Decode, 251, 117, 119, // 143: decode to NDS_VFWCVT_F_BU using decoder 119
12656 // 143: }
12657 // 143: } // switch Inst[19:14]
12658 // 143: }
12659 1, 46, // 147: case 0x1: {
12660 OPC_SwitchField, 20, 5, // 149: switch Inst[24:20] {
12661 0, 15, // 152: case 0x0: {
12662 OPC_CheckPredicate, 134, 1, // 154: check predicate 134
12663 OPC_CheckField, 25, 1, 1, // 157: check Inst[25] == 0x1
12664 OPC_CheckField, 14, 1, 1, // 161: check Inst[14] == 0x1
12665 OPC_Decode, 255, 117, 2, // 165: decode to NDS_VLE4_V using decoder 2
12666 // 165: }
12667 2, 11, // 169: case 0x2: {
12668 OPC_CheckPredicate, 135, 1, // 171: check predicate 135
12669 OPC_CheckField, 14, 1, 1, // 174: check Inst[14] == 0x1
12670 OPC_Decode, 128, 118, 1, // 178: decode to NDS_VLN8_V using decoder 1
12671 // 178: }
12672 3, 0, // 182: case 0x3: {
12673 OPC_CheckPredicate, 135, 1, // 184: check predicate 135
12674 OPC_CheckField, 14, 1, 1, // 187: check Inst[14] == 0x1
12675 OPC_Decode, 129, 118, 1, // 191: decode to NDS_VLNU8_V using decoder 1
12676 // 191: }
12677 // 191: } // switch Inst[24:20]
12678 // 191: }
12679 2, 26, // 195: case 0x2: {
12680 OPC_SwitchField, 14, 1, // 197: switch Inst[14] {
12681 0, 11, // 200: case 0x0: {
12682 OPC_CheckPredicate, 131, 1, // 202: check predicate 131
12683 OPC_CheckField, 25, 1, 1, // 205: check Inst[25] == 0x1
12684 OPC_Decode, 232, 117, 54, // 209: decode to NDS_LEA_H using decoder 54
12685 // 209: }
12686 1, 0, // 213: case 0x1: {
12687 OPC_CheckPredicate, 136, 1, // 215: check predicate 136
12688 OPC_Decode, 249, 117, 138, 1, // 218: decode to NDS_VFPMADT_VF using decoder 138
12689 // 218: }
12690 // 218: } // switch Inst[14]
12691 // 218: }
12692 3, 36, // 223: case 0x3: {
12693 OPC_SwitchField, 14, 1, // 225: switch Inst[14] {
12694 0, 21, // 228: case 0x0: {
12695 OPC_SwitchField, 25, 1, // 230: switch Inst[25] {
12696 0, 7, // 233: case 0x0: {
12697 OPC_CheckPredicate, 131, 1, // 235: check predicate 131
12698 OPC_Decode, 234, 117, 54, // 238: decode to NDS_LEA_W using decoder 54
12699 // 238: }
12700 1, 0, // 242: case 0x1: {
12701 OPC_CheckPredicate, 131, 1, // 244: check predicate 131
12702 OPC_Decode, 230, 117, 54, // 247: decode to NDS_LEA_D using decoder 54
12703 // 247: }
12704 // 247: } // switch Inst[25]
12705 // 247: }
12706 1, 0, // 251: case 0x1: {
12707 OPC_CheckPredicate, 136, 1, // 253: check predicate 136
12708 OPC_Decode, 248, 117, 138, 1, // 256: decode to NDS_VFPMADB_VF using decoder 138
12709 // 256: }
12710 // 256: } // switch Inst[14]
12711 // 256: }
12712 4, 36, // 261: case 0x4: {
12713 OPC_SwitchField, 14, 1, // 263: switch Inst[14] {
12714 0, 21, // 266: case 0x0: {
12715 OPC_SwitchField, 25, 1, // 268: switch Inst[25] {
12716 0, 7, // 271: case 0x0: {
12717 OPC_CheckPredicate, 137, 1, // 273: check predicate 137
12718 OPC_Decode, 229, 117, 54, // 276: decode to NDS_LEA_B_ZE using decoder 54
12719 // 276: }
12720 1, 0, // 280: case 0x1: {
12721 OPC_CheckPredicate, 137, 1, // 282: check predicate 137
12722 OPC_Decode, 233, 117, 54, // 285: decode to NDS_LEA_H_ZE using decoder 54
12723 // 285: }
12724 // 285: } // switch Inst[25]
12725 // 285: }
12726 1, 0, // 289: case 0x1: {
12727 OPC_CheckPredicate, 138, 1, // 291: check predicate 138
12728 OPC_Decode, 245, 117, 202, 1, // 294: decode to NDS_VD4DOTS_VV using decoder 202
12729 // 294: }
12730 // 294: } // switch Inst[14]
12731 // 294: }
12732 5, 36, // 299: case 0x5: {
12733 OPC_SwitchField, 14, 1, // 301: switch Inst[14] {
12734 0, 21, // 304: case 0x0: {
12735 OPC_SwitchField, 25, 1, // 306: switch Inst[25] {
12736 0, 7, // 309: case 0x0: {
12737 OPC_CheckPredicate, 137, 1, // 311: check predicate 137
12738 OPC_Decode, 235, 117, 54, // 314: decode to NDS_LEA_W_ZE using decoder 54
12739 // 314: }
12740 1, 0, // 318: case 0x1: {
12741 OPC_CheckPredicate, 137, 1, // 320: check predicate 137
12742 OPC_Decode, 231, 117, 54, // 323: decode to NDS_LEA_D_ZE using decoder 54
12743 // 323: }
12744 // 323: } // switch Inst[25]
12745 // 323: }
12746 1, 0, // 327: case 0x1: {
12747 OPC_CheckPredicate, 138, 1, // 329: check predicate 138
12748 OPC_Decode, 244, 117, 202, 1, // 332: decode to NDS_VD4DOTSU_VV using decoder 202
12749 // 332: }
12750 // 332: } // switch Inst[14]
12751 // 332: }
12752 7, 12, // 337: case 0x7: {
12753 OPC_CheckPredicate, 138, 1, // 339: check predicate 138
12754 OPC_CheckField, 14, 1, 1, // 342: check Inst[14] == 0x1
12755 OPC_Decode, 246, 117, 202, 1, // 346: decode to NDS_VD4DOTU_VV using decoder 202
12756 // 346: }
12757 8, 29, // 351: case 0x8: {
12758 OPC_SwitchField, 25, 1, // 353: switch Inst[25] {
12759 0, 11, // 356: case 0x0: {
12760 OPC_CheckPredicate, 131, 1, // 358: check predicate 131
12761 OPC_CheckField, 14, 1, 0, // 361: check Inst[14] == 0x0
12762 OPC_Decode, 220, 117, 31, // 365: decode to NDS_FFB using decoder 31
12763 // 365: }
12764 1, 0, // 369: case 0x1: {
12765 OPC_CheckPredicate, 131, 1, // 371: check predicate 131
12766 OPC_CheckField, 14, 1, 0, // 374: check Inst[14] == 0x0
12767 OPC_Decode, 222, 117, 31, // 378: decode to NDS_FFZMISM using decoder 31
12768 // 378: }
12769 // 378: } // switch Inst[25]
12770 // 378: }
12771 9, 0, // 382: case 0x9: {
12772 OPC_SwitchField, 25, 1, // 384: switch Inst[25] {
12773 0, 11, // 387: case 0x0: {
12774 OPC_CheckPredicate, 131, 1, // 389: check predicate 131
12775 OPC_CheckField, 14, 1, 0, // 392: check Inst[14] == 0x0
12776 OPC_Decode, 221, 117, 31, // 396: decode to NDS_FFMISM using decoder 31
12777 // 396: }
12778 1, 0, // 400: case 0x1: {
12779 OPC_CheckPredicate, 131, 1, // 402: check predicate 131
12780 OPC_CheckField, 14, 1, 0, // 405: check Inst[14] == 0x0
12781 OPC_Decode, 223, 117, 31, // 409: decode to NDS_FLMISM using decoder 31
12782 // 409: }
12783 // 409: } // switch Inst[25]
12784 // 409: }
12785 // 409: } // switch Inst[31:26]
12786 // 409: }
12787 // 409: } // switch Inst[6:0]
12788 // 409: }
12789 1, 52, // 413: case 0x1: {
12790 OPC_SwitchField, 0, 7, // 415: switch Inst[6:0] {
12791 11, 8, // 418: case 0xb: {
12792 OPC_CheckPredicate, 131, 1, // 420: check predicate 131
12793 OPC_Decode, 211, 117, 197, 1, // 423: decode to NDS_ADDIGP using decoder 197
12794 // 423: }
12795 43, 23, // 428: case 0x2b: {
12796 OPC_SwitchField, 14, 1, // 430: switch Inst[14] {
12797 0, 8, // 433: case 0x0: {
12798 OPC_CheckPredicate, 131, 1, // 435: check predicate 131
12799 OPC_Decode, 236, 117, 203, 1, // 438: decode to NDS_LHGP using decoder 203
12800 // 438: }
12801 1, 0, // 443: case 0x1: {
12802 OPC_CheckPredicate, 131, 1, // 445: check predicate 131
12803 OPC_Decode, 237, 117, 203, 1, // 448: decode to NDS_LHUGP using decoder 203
12804 // 448: }
12805 // 448: } // switch Inst[14]
12806 // 448: }
12807 91, 0, // 453: case 0x5b: {
12808 OPC_CheckPredicate, 131, 1, // 455: check predicate 131
12809 OPC_CheckField, 14, 1, 1, // 458: check Inst[14] == 0x1
12810 OPC_Decode, 214, 117, 204, 1, // 462: decode to NDS_BEQC using decoder 204
12811 // 462: }
12812 // 462: } // switch Inst[6:0]
12813 // 462: }
12814 2, 63, // 467: case 0x2: {
12815 OPC_SwitchField, 0, 7, // 469: switch Inst[6:0] {
12816 11, 8, // 472: case 0xb: {
12817 OPC_CheckPredicate, 131, 1, // 474: check predicate 131
12818 OPC_Decode, 227, 117, 197, 1, // 477: decode to NDS_LBUGP using decoder 197
12819 // 477: }
12820 43, 23, // 482: case 0x2b: {
12821 OPC_SwitchField, 14, 1, // 484: switch Inst[14] {
12822 0, 8, // 487: case 0x0: {
12823 OPC_CheckPredicate, 131, 1, // 489: check predicate 131
12824 OPC_Decode, 238, 117, 205, 1, // 492: decode to NDS_LWGP using decoder 205
12825 // 492: }
12826 1, 0, // 497: case 0x1: {
12827 OPC_CheckPredicate, 137, 1, // 499: check predicate 137
12828 OPC_Decode, 239, 117, 205, 1, // 502: decode to NDS_LWUGP using decoder 205
12829 // 502: }
12830 // 502: } // switch Inst[14]
12831 // 502: }
12832 91, 0, // 507: case 0x5b: {
12833 OPC_SwitchField, 14, 1, // 509: switch Inst[14] {
12834 0, 8, // 512: case 0x0: {
12835 OPC_CheckPredicate, 131, 1, // 514: check predicate 131
12836 OPC_Decode, 216, 117, 206, 1, // 517: decode to NDS_BFOZ using decoder 206
12837 // 517: }
12838 1, 0, // 522: case 0x1: {
12839 OPC_CheckPredicate, 131, 1, // 524: check predicate 131
12840 OPC_Decode, 217, 117, 204, 1, // 527: decode to NDS_BNEC using decoder 204
12841 // 527: }
12842 // 527: } // switch Inst[14]
12843 // 527: }
12844 // 527: } // switch Inst[6:0]
12845 // 527: }
12846 3, 0, // 532: case 0x3: {
12847 OPC_SwitchField, 0, 7, // 534: switch Inst[6:0] {
12848 11, 8, // 537: case 0xb: {
12849 OPC_CheckPredicate, 131, 1, // 539: check predicate 131
12850 OPC_Decode, 240, 117, 207, 1, // 542: decode to NDS_SBGP using decoder 207
12851 // 542: }
12852 43, 23, // 547: case 0x2b: {
12853 OPC_SwitchField, 14, 1, // 549: switch Inst[14] {
12854 0, 8, // 552: case 0x0: {
12855 OPC_CheckPredicate, 137, 1, // 554: check predicate 137
12856 OPC_Decode, 228, 117, 208, 1, // 557: decode to NDS_LDGP using decoder 208
12857 // 557: }
12858 1, 0, // 562: case 0x1: {
12859 OPC_CheckPredicate, 137, 1, // 564: check predicate 137
12860 OPC_Decode, 241, 117, 209, 1, // 567: decode to NDS_SDGP using decoder 209
12861 // 567: }
12862 // 567: } // switch Inst[14]
12863 // 567: }
12864 91, 0, // 572: case 0x5b: {
12865 OPC_SwitchField, 14, 1, // 574: switch Inst[14] {
12866 0, 8, // 577: case 0x0: {
12867 OPC_CheckPredicate, 131, 1, // 579: check predicate 131
12868 OPC_Decode, 215, 117, 206, 1, // 582: decode to NDS_BFOS using decoder 206
12869 // 582: }
12870 1, 0, // 587: case 0x1: {
12871 OPC_SwitchField, 30, 1, // 589: switch Inst[30] {
12872 0, 8, // 592: case 0x0: {
12873 OPC_CheckPredicate, 131, 1, // 594: check predicate 131
12874 OPC_Decode, 212, 117, 210, 1, // 597: decode to NDS_BBC using decoder 210
12875 // 597: }
12876 1, 0, // 602: case 0x1: {
12877 OPC_CheckPredicate, 131, 1, // 604: check predicate 131
12878 OPC_Decode, 213, 117, 210, 1, // 607: decode to NDS_BBS using decoder 210
12879 // 607: }
12880 // 607: } // switch Inst[30]
12881 // 607: }
12882 // 607: } // switch Inst[14]
12883 // 607: }
12884 // 607: } // switch Inst[6:0]
12885 // 607: }
12886 // 607: } // switch Inst[13:12]
12887};
12888static const uint8_t DecoderTableXCV32[3680] = {
12889 32, // 0: BitWidth 32
12890 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
12891 0, 190, 4, // 4: case 0x0: {
12892 OPC_SwitchField, 0, 7, // 7: switch Inst[6:0] {
12893 11, 8, // 10: case 0xb: {
12894 OPC_CheckPredicate, 139, 1, // 12: check predicate 139
12895 OPC_Decode, 255, 111, 211, 1, // 15: decode to CV_LB_ri_inc using decoder 211
12896 // 15: }
12897 43, 8, // 20: case 0x2b: {
12898 OPC_CheckPredicate, 139, 1, // 22: check predicate 139
12899 OPC_Decode, 196, 112, 212, 1, // 25: decode to CV_SB_ri_inc using decoder 212
12900 // 25: }
12901 91, 33, // 30: case 0x5b: {
12902 OPC_SwitchField, 30, 2, // 32: switch Inst[31:30] {
12903 0, 8, // 35: case 0x0: {
12904 OPC_CheckPredicate, 140, 1, // 37: check predicate 140
12905 OPC_Decode, 238, 111, 213, 1, // 40: decode to CV_EXTRACT using decoder 213
12906 // 40: }
12907 1, 8, // 45: case 0x1: {
12908 OPC_CheckPredicate, 140, 1, // 47: check predicate 140
12909 OPC_Decode, 240, 111, 213, 1, // 50: decode to CV_EXTRACTU using decoder 213
12910 // 50: }
12911 2, 0, // 55: case 0x2: {
12912 OPC_CheckPredicate, 140, 1, // 57: check predicate 140
12913 OPC_Decode, 248, 111, 214, 1, // 60: decode to CV_INSERT using decoder 214
12914 // 60: }
12915 // 60: } // switch Inst[31:30]
12916 // 60: }
12917 123, 0, // 65: case 0x7b: {
12918 OPC_SwitchField, 26, 6, // 67: switch Inst[31:26] {
12919 0, 11, // 70: case 0x0: {
12920 OPC_CheckPredicate, 141, 1, // 72: check predicate 141
12921 OPC_CheckField, 25, 1, 0, // 75: check Inst[25] == 0x0
12922 OPC_Decode, 238, 110, 31, // 79: decode to CV_ADD_H using decoder 31
12923 // 79: }
12924 1, 11, // 83: case 0x1: {
12925 OPC_CheckPredicate, 141, 1, // 85: check predicate 141
12926 OPC_CheckField, 25, 1, 0, // 88: check Inst[25] == 0x0
12927 OPC_Decode, 146, 111, 31, // 92: decode to CV_CMPEQ_H using decoder 31
12928 // 92: }
12929 2, 11, // 96: case 0x2: {
12930 OPC_CheckPredicate, 141, 1, // 98: check predicate 141
12931 OPC_CheckField, 25, 1, 0, // 101: check Inst[25] == 0x0
12932 OPC_Decode, 137, 113, 31, // 105: decode to CV_SUB_H using decoder 31
12933 // 105: }
12934 3, 11, // 109: case 0x3: {
12935 OPC_CheckPredicate, 141, 1, // 111: check predicate 141
12936 OPC_CheckField, 25, 1, 0, // 114: check Inst[25] == 0x0
12937 OPC_Decode, 200, 111, 31, // 118: decode to CV_CMPNE_H using decoder 31
12938 // 118: }
12939 4, 11, // 122: case 0x4: {
12940 OPC_CheckPredicate, 141, 1, // 124: check predicate 141
12941 OPC_CheckField, 25, 1, 0, // 127: check Inst[25] == 0x0
12942 OPC_Decode, 128, 111, 31, // 131: decode to CV_AVG_H using decoder 31
12943 // 131: }
12944 5, 11, // 135: case 0x5: {
12945 OPC_CheckPredicate, 141, 1, // 137: check predicate 141
12946 OPC_CheckField, 25, 1, 0, // 140: check Inst[25] == 0x0
12947 OPC_Decode, 170, 111, 31, // 144: decode to CV_CMPGT_H using decoder 31
12948 // 144: }
12949 6, 11, // 148: case 0x6: {
12950 OPC_CheckPredicate, 141, 1, // 150: check predicate 141
12951 OPC_CheckField, 25, 1, 0, // 153: check Inst[25] == 0x0
12952 OPC_Decode, 250, 110, 31, // 157: decode to CV_AVGU_H using decoder 31
12953 // 157: }
12954 7, 11, // 161: case 0x7: {
12955 OPC_CheckPredicate, 141, 1, // 163: check predicate 141
12956 OPC_CheckField, 25, 1, 0, // 166: check Inst[25] == 0x0
12957 OPC_Decode, 158, 111, 31, // 170: decode to CV_CMPGE_H using decoder 31
12958 // 170: }
12959 8, 11, // 174: case 0x8: {
12960 OPC_CheckPredicate, 141, 1, // 176: check predicate 141
12961 OPC_CheckField, 25, 1, 0, // 179: check Inst[25] == 0x0
12962 OPC_Decode, 171, 112, 31, // 183: decode to CV_MIN_H using decoder 31
12963 // 183: }
12964 9, 11, // 187: case 0x9: {
12965 OPC_CheckPredicate, 141, 1, // 189: check predicate 141
12966 OPC_CheckField, 25, 1, 0, // 192: check Inst[25] == 0x0
12967 OPC_Decode, 194, 111, 31, // 196: decode to CV_CMPLT_H using decoder 31
12968 // 196: }
12969 10, 11, // 200: case 0xa: {
12970 OPC_CheckPredicate, 141, 1, // 202: check predicate 141
12971 OPC_CheckField, 25, 1, 0, // 205: check Inst[25] == 0x0
12972 OPC_Decode, 165, 112, 31, // 209: decode to CV_MINU_H using decoder 31
12973 // 209: }
12974 11, 11, // 213: case 0xb: {
12975 OPC_CheckPredicate, 141, 1, // 215: check predicate 141
12976 OPC_CheckField, 25, 1, 0, // 218: check Inst[25] == 0x0
12977 OPC_Decode, 182, 111, 31, // 222: decode to CV_CMPLE_H using decoder 31
12978 // 222: }
12979 12, 11, // 226: case 0xc: {
12980 OPC_CheckPredicate, 141, 1, // 228: check predicate 141
12981 OPC_CheckField, 25, 1, 0, // 231: check Inst[25] == 0x0
12982 OPC_Decode, 157, 112, 31, // 235: decode to CV_MAX_H using decoder 31
12983 // 235: }
12984 13, 11, // 239: case 0xd: {
12985 OPC_CheckPredicate, 141, 1, // 241: check predicate 141
12986 OPC_CheckField, 25, 1, 0, // 244: check Inst[25] == 0x0
12987 OPC_Decode, 164, 111, 31, // 248: decode to CV_CMPGTU_H using decoder 31
12988 // 248: }
12989 14, 11, // 252: case 0xe: {
12990 OPC_CheckPredicate, 141, 1, // 254: check predicate 141
12991 OPC_CheckField, 25, 1, 0, // 257: check Inst[25] == 0x0
12992 OPC_Decode, 151, 112, 31, // 261: decode to CV_MAXU_H using decoder 31
12993 // 261: }
12994 15, 11, // 265: case 0xf: {
12995 OPC_CheckPredicate, 141, 1, // 267: check predicate 141
12996 OPC_CheckField, 25, 1, 0, // 270: check Inst[25] == 0x0
12997 OPC_Decode, 152, 111, 31, // 274: decode to CV_CMPGEU_H using decoder 31
12998 // 274: }
12999 16, 11, // 278: case 0x10: {
13000 OPC_CheckPredicate, 141, 1, // 280: check predicate 141
13001 OPC_CheckField, 25, 1, 0, // 283: check Inst[25] == 0x0
13002 OPC_Decode, 244, 112, 31, // 287: decode to CV_SRL_H using decoder 31
13003 // 287: }
13004 17, 11, // 291: case 0x11: {
13005 OPC_CheckPredicate, 141, 1, // 293: check predicate 141
13006 OPC_CheckField, 25, 1, 0, // 296: check Inst[25] == 0x0
13007 OPC_Decode, 188, 111, 31, // 300: decode to CV_CMPLTU_H using decoder 31
13008 // 300: }
13009 18, 11, // 304: case 0x12: {
13010 OPC_CheckPredicate, 141, 1, // 306: check predicate 141
13011 OPC_CheckField, 25, 1, 0, // 309: check Inst[25] == 0x0
13012 OPC_Decode, 238, 112, 31, // 313: decode to CV_SRA_H using decoder 31
13013 // 313: }
13014 19, 11, // 317: case 0x13: {
13015 OPC_CheckPredicate, 141, 1, // 319: check predicate 141
13016 OPC_CheckField, 25, 1, 0, // 322: check Inst[25] == 0x0
13017 OPC_Decode, 176, 111, 31, // 326: decode to CV_CMPLEU_H using decoder 31
13018 // 326: }
13019 20, 11, // 330: case 0x14: {
13020 OPC_CheckPredicate, 141, 1, // 332: check predicate 141
13021 OPC_CheckField, 25, 1, 0, // 335: check Inst[25] == 0x0
13022 OPC_Decode, 232, 112, 31, // 339: decode to CV_SLL_H using decoder 31
13023 // 339: }
13024 21, 21, // 343: case 0x15: {
13025 OPC_SwitchField, 25, 1, // 345: switch Inst[25] {
13026 0, 7, // 348: case 0x0: {
13027 OPC_CheckPredicate, 141, 1, // 350: check predicate 141
13028 OPC_Decode, 211, 111, 59, // 353: decode to CV_CPLXMUL_R using decoder 59
13029 // 353: }
13030 1, 0, // 357: case 0x1: {
13031 OPC_CheckPredicate, 141, 1, // 359: check predicate 141
13032 OPC_Decode, 207, 111, 59, // 362: decode to CV_CPLXMUL_I using decoder 59
13033 // 362: }
13034 // 362: } // switch Inst[25]
13035 // 362: }
13036 22, 11, // 366: case 0x16: {
13037 OPC_CheckPredicate, 141, 1, // 368: check predicate 141
13038 OPC_CheckField, 25, 1, 0, // 371: check Inst[25] == 0x0
13039 OPC_Decode, 186, 112, 31, // 375: decode to CV_OR_H using decoder 31
13040 // 375: }
13041 23, 11, // 379: case 0x17: {
13042 OPC_CheckPredicate, 141, 1, // 381: check predicate 141
13043 OPC_CheckField, 20, 6, 0, // 384: check Inst[25:20] == 0x0
13044 OPC_Decode, 206, 111, 17, // 388: decode to CV_CPLXCONJ using decoder 17
13045 // 388: }
13046 24, 11, // 392: case 0x18: {
13047 OPC_CheckPredicate, 141, 1, // 394: check predicate 141
13048 OPC_CheckField, 25, 1, 0, // 397: check Inst[25] == 0x0
13049 OPC_Decode, 146, 113, 31, // 401: decode to CV_XOR_H using decoder 31
13050 // 401: }
13051 25, 11, // 405: case 0x19: {
13052 OPC_CheckPredicate, 141, 1, // 407: check predicate 141
13053 OPC_CheckField, 25, 1, 0, // 410: check Inst[25] == 0x0
13054 OPC_Decode, 253, 112, 31, // 414: decode to CV_SUBROTMJ using decoder 31
13055 // 414: }
13056 26, 11, // 418: case 0x1a: {
13057 OPC_CheckPredicate, 141, 1, // 420: check predicate 141
13058 OPC_CheckField, 25, 1, 0, // 423: check Inst[25] == 0x0
13059 OPC_Decode, 244, 110, 31, // 427: decode to CV_AND_H using decoder 31
13060 // 427: }
13061 28, 11, // 431: case 0x1c: {
13062 OPC_CheckPredicate, 141, 1, // 433: check predicate 141
13063 OPC_CheckField, 20, 6, 0, // 436: check Inst[25:20] == 0x0
13064 OPC_Decode, 225, 110, 17, // 440: decode to CV_ABS_H using decoder 17
13065 // 440: }
13066 32, 11, // 444: case 0x20: {
13067 OPC_CheckPredicate, 141, 1, // 446: check predicate 141
13068 OPC_CheckField, 25, 1, 0, // 449: check Inst[25] == 0x0
13069 OPC_Decode, 222, 111, 31, // 453: decode to CV_DOTUP_H using decoder 31
13070 // 453: }
13071 34, 11, // 457: case 0x22: {
13072 OPC_CheckPredicate, 141, 1, // 459: check predicate 141
13073 OPC_CheckField, 25, 1, 0, // 462: check Inst[25] == 0x0
13074 OPC_Decode, 228, 111, 31, // 466: decode to CV_DOTUSP_H using decoder 31
13075 // 466: }
13076 36, 11, // 470: case 0x24: {
13077 OPC_CheckPredicate, 141, 1, // 472: check predicate 141
13078 OPC_CheckField, 25, 1, 0, // 475: check Inst[25] == 0x0
13079 OPC_Decode, 216, 111, 31, // 479: decode to CV_DOTSP_H using decoder 31
13080 // 479: }
13081 38, 11, // 483: case 0x26: {
13082 OPC_CheckPredicate, 141, 1, // 485: check predicate 141
13083 OPC_CheckField, 25, 1, 0, // 488: check Inst[25] == 0x0
13084 OPC_Decode, 206, 112, 59, // 492: decode to CV_SDOTUP_H using decoder 59
13085 // 492: }
13086 40, 11, // 496: case 0x28: {
13087 OPC_CheckPredicate, 141, 1, // 498: check predicate 141
13088 OPC_CheckField, 25, 1, 0, // 501: check Inst[25] == 0x0
13089 OPC_Decode, 212, 112, 59, // 505: decode to CV_SDOTUSP_H using decoder 59
13090 // 505: }
13091 42, 11, // 509: case 0x2a: {
13092 OPC_CheckPredicate, 141, 1, // 511: check predicate 141
13093 OPC_CheckField, 25, 1, 0, // 514: check Inst[25] == 0x0
13094 OPC_Decode, 200, 112, 59, // 518: decode to CV_SDOTSP_H using decoder 59
13095 // 518: }
13096 46, 8, // 522: case 0x2e: {
13097 OPC_CheckPredicate, 141, 1, // 524: check predicate 141
13098 OPC_Decode, 245, 111, 215, 1, // 527: decode to CV_EXTRACT_H using decoder 215
13099 // 527: }
13100 48, 11, // 532: case 0x30: {
13101 OPC_CheckPredicate, 141, 1, // 534: check predicate 141
13102 OPC_CheckField, 25, 1, 0, // 537: check Inst[25] == 0x0
13103 OPC_Decode, 224, 112, 31, // 541: decode to CV_SHUFFLE_H using decoder 31
13104 // 541: }
13105 56, 11, // 545: case 0x38: {
13106 OPC_CheckPredicate, 141, 1, // 547: check predicate 141
13107 OPC_CheckField, 25, 1, 0, // 550: check Inst[25] == 0x0
13108 OPC_Decode, 218, 112, 59, // 554: decode to CV_SHUFFLE2_H using decoder 59
13109 // 554: }
13110 60, 0, // 558: case 0x3c: {
13111 OPC_SwitchField, 25, 1, // 560: switch Inst[25] {
13112 0, 7, // 563: case 0x0: {
13113 OPC_CheckPredicate, 141, 1, // 565: check predicate 141
13114 OPC_Decode, 191, 112, 31, // 568: decode to CV_PACK using decoder 31
13115 // 568: }
13116 1, 0, // 572: case 0x1: {
13117 OPC_CheckPredicate, 141, 1, // 574: check predicate 141
13118 OPC_Decode, 194, 112, 31, // 577: decode to CV_PACK_H using decoder 31
13119 // 577: }
13120 // 577: } // switch Inst[25]
13121 // 577: }
13122 // 577: } // switch Inst[31:26]
13123 // 577: }
13124 // 577: } // switch Inst[6:0]
13125 // 577: }
13126 1, 141, 4, // 581: case 0x1: {
13127 OPC_SwitchField, 0, 7, // 584: switch Inst[6:0] {
13128 11, 8, // 587: case 0xb: {
13129 OPC_CheckPredicate, 139, 1, // 589: check predicate 139
13130 OPC_Decode, 133, 112, 211, 1, // 592: decode to CV_LH_ri_inc using decoder 211
13131 // 592: }
13132 43, 8, // 597: case 0x2b: {
13133 OPC_CheckPredicate, 139, 1, // 599: check predicate 139
13134 OPC_Decode, 226, 112, 212, 1, // 602: decode to CV_SH_ri_inc using decoder 212
13135 // 602: }
13136 91, 33, // 607: case 0x5b: {
13137 OPC_SwitchField, 30, 2, // 609: switch Inst[31:30] {
13138 0, 8, // 612: case 0x0: {
13139 OPC_CheckPredicate, 140, 1, // 614: check predicate 140
13140 OPC_Decode, 133, 111, 213, 1, // 617: decode to CV_BCLR using decoder 213
13141 // 617: }
13142 1, 8, // 622: case 0x1: {
13143 OPC_CheckPredicate, 140, 1, // 624: check predicate 140
13144 OPC_Decode, 138, 111, 213, 1, // 627: decode to CV_BSET using decoder 213
13145 // 627: }
13146 3, 0, // 632: case 0x3: {
13147 OPC_CheckPredicate, 140, 1, // 634: check predicate 140
13148 OPC_Decode, 136, 111, 216, 1, // 637: decode to CV_BITREV using decoder 216
13149 // 637: }
13150 // 637: } // switch Inst[31:30]
13151 // 637: }
13152 123, 0, // 642: case 0x7b: {
13153 OPC_SwitchField, 26, 6, // 644: switch Inst[31:26] {
13154 0, 11, // 647: case 0x0: {
13155 OPC_CheckPredicate, 141, 1, // 649: check predicate 141
13156 OPC_CheckField, 25, 1, 0, // 652: check Inst[25] == 0x0
13157 OPC_Decode, 234, 110, 31, // 656: decode to CV_ADD_B using decoder 31
13158 // 656: }
13159 1, 11, // 660: case 0x1: {
13160 OPC_CheckPredicate, 141, 1, // 662: check predicate 141
13161 OPC_CheckField, 25, 1, 0, // 665: check Inst[25] == 0x0
13162 OPC_Decode, 145, 111, 31, // 669: decode to CV_CMPEQ_B using decoder 31
13163 // 669: }
13164 2, 11, // 673: case 0x2: {
13165 OPC_CheckPredicate, 141, 1, // 675: check predicate 141
13166 OPC_CheckField, 25, 1, 0, // 678: check Inst[25] == 0x0
13167 OPC_Decode, 133, 113, 31, // 682: decode to CV_SUB_B using decoder 31
13168 // 682: }
13169 3, 11, // 686: case 0x3: {
13170 OPC_CheckPredicate, 141, 1, // 688: check predicate 141
13171 OPC_CheckField, 25, 1, 0, // 691: check Inst[25] == 0x0
13172 OPC_Decode, 199, 111, 31, // 695: decode to CV_CMPNE_B using decoder 31
13173 // 695: }
13174 4, 11, // 699: case 0x4: {
13175 OPC_CheckPredicate, 141, 1, // 701: check predicate 141
13176 OPC_CheckField, 25, 1, 0, // 704: check Inst[25] == 0x0
13177 OPC_Decode, 255, 110, 31, // 708: decode to CV_AVG_B using decoder 31
13178 // 708: }
13179 5, 11, // 712: case 0x5: {
13180 OPC_CheckPredicate, 141, 1, // 714: check predicate 141
13181 OPC_CheckField, 25, 1, 0, // 717: check Inst[25] == 0x0
13182 OPC_Decode, 169, 111, 31, // 721: decode to CV_CMPGT_B using decoder 31
13183 // 721: }
13184 6, 11, // 725: case 0x6: {
13185 OPC_CheckPredicate, 141, 1, // 727: check predicate 141
13186 OPC_CheckField, 25, 1, 0, // 730: check Inst[25] == 0x0
13187 OPC_Decode, 249, 110, 31, // 734: decode to CV_AVGU_B using decoder 31
13188 // 734: }
13189 7, 11, // 738: case 0x7: {
13190 OPC_CheckPredicate, 141, 1, // 740: check predicate 141
13191 OPC_CheckField, 25, 1, 0, // 743: check Inst[25] == 0x0
13192 OPC_Decode, 157, 111, 31, // 747: decode to CV_CMPGE_B using decoder 31
13193 // 747: }
13194 8, 11, // 751: case 0x8: {
13195 OPC_CheckPredicate, 141, 1, // 753: check predicate 141
13196 OPC_CheckField, 25, 1, 0, // 756: check Inst[25] == 0x0
13197 OPC_Decode, 170, 112, 31, // 760: decode to CV_MIN_B using decoder 31
13198 // 760: }
13199 9, 11, // 764: case 0x9: {
13200 OPC_CheckPredicate, 141, 1, // 766: check predicate 141
13201 OPC_CheckField, 25, 1, 0, // 769: check Inst[25] == 0x0
13202 OPC_Decode, 193, 111, 31, // 773: decode to CV_CMPLT_B using decoder 31
13203 // 773: }
13204 10, 11, // 777: case 0xa: {
13205 OPC_CheckPredicate, 141, 1, // 779: check predicate 141
13206 OPC_CheckField, 25, 1, 0, // 782: check Inst[25] == 0x0
13207 OPC_Decode, 164, 112, 31, // 786: decode to CV_MINU_B using decoder 31
13208 // 786: }
13209 11, 11, // 790: case 0xb: {
13210 OPC_CheckPredicate, 141, 1, // 792: check predicate 141
13211 OPC_CheckField, 25, 1, 0, // 795: check Inst[25] == 0x0
13212 OPC_Decode, 181, 111, 31, // 799: decode to CV_CMPLE_B using decoder 31
13213 // 799: }
13214 12, 11, // 803: case 0xc: {
13215 OPC_CheckPredicate, 141, 1, // 805: check predicate 141
13216 OPC_CheckField, 25, 1, 0, // 808: check Inst[25] == 0x0
13217 OPC_Decode, 156, 112, 31, // 812: decode to CV_MAX_B using decoder 31
13218 // 812: }
13219 13, 11, // 816: case 0xd: {
13220 OPC_CheckPredicate, 141, 1, // 818: check predicate 141
13221 OPC_CheckField, 25, 1, 0, // 821: check Inst[25] == 0x0
13222 OPC_Decode, 163, 111, 31, // 825: decode to CV_CMPGTU_B using decoder 31
13223 // 825: }
13224 14, 11, // 829: case 0xe: {
13225 OPC_CheckPredicate, 141, 1, // 831: check predicate 141
13226 OPC_CheckField, 25, 1, 0, // 834: check Inst[25] == 0x0
13227 OPC_Decode, 150, 112, 31, // 838: decode to CV_MAXU_B using decoder 31
13228 // 838: }
13229 15, 11, // 842: case 0xf: {
13230 OPC_CheckPredicate, 141, 1, // 844: check predicate 141
13231 OPC_CheckField, 25, 1, 0, // 847: check Inst[25] == 0x0
13232 OPC_Decode, 151, 111, 31, // 851: decode to CV_CMPGEU_B using decoder 31
13233 // 851: }
13234 16, 11, // 855: case 0x10: {
13235 OPC_CheckPredicate, 141, 1, // 857: check predicate 141
13236 OPC_CheckField, 25, 1, 0, // 860: check Inst[25] == 0x0
13237 OPC_Decode, 243, 112, 31, // 864: decode to CV_SRL_B using decoder 31
13238 // 864: }
13239 17, 11, // 868: case 0x11: {
13240 OPC_CheckPredicate, 141, 1, // 870: check predicate 141
13241 OPC_CheckField, 25, 1, 0, // 873: check Inst[25] == 0x0
13242 OPC_Decode, 187, 111, 31, // 877: decode to CV_CMPLTU_B using decoder 31
13243 // 877: }
13244 18, 11, // 881: case 0x12: {
13245 OPC_CheckPredicate, 141, 1, // 883: check predicate 141
13246 OPC_CheckField, 25, 1, 0, // 886: check Inst[25] == 0x0
13247 OPC_Decode, 237, 112, 31, // 890: decode to CV_SRA_B using decoder 31
13248 // 890: }
13249 19, 11, // 894: case 0x13: {
13250 OPC_CheckPredicate, 141, 1, // 896: check predicate 141
13251 OPC_CheckField, 25, 1, 0, // 899: check Inst[25] == 0x0
13252 OPC_Decode, 175, 111, 31, // 903: decode to CV_CMPLEU_B using decoder 31
13253 // 903: }
13254 20, 11, // 907: case 0x14: {
13255 OPC_CheckPredicate, 141, 1, // 909: check predicate 141
13256 OPC_CheckField, 25, 1, 0, // 912: check Inst[25] == 0x0
13257 OPC_Decode, 231, 112, 31, // 916: decode to CV_SLL_B using decoder 31
13258 // 916: }
13259 22, 11, // 920: case 0x16: {
13260 OPC_CheckPredicate, 141, 1, // 922: check predicate 141
13261 OPC_CheckField, 25, 1, 0, // 925: check Inst[25] == 0x0
13262 OPC_Decode, 185, 112, 31, // 929: decode to CV_OR_B using decoder 31
13263 // 929: }
13264 24, 11, // 933: case 0x18: {
13265 OPC_CheckPredicate, 141, 1, // 935: check predicate 141
13266 OPC_CheckField, 25, 1, 0, // 938: check Inst[25] == 0x0
13267 OPC_Decode, 145, 113, 31, // 942: decode to CV_XOR_B using decoder 31
13268 // 942: }
13269 26, 11, // 946: case 0x1a: {
13270 OPC_CheckPredicate, 141, 1, // 948: check predicate 141
13271 OPC_CheckField, 25, 1, 0, // 951: check Inst[25] == 0x0
13272 OPC_Decode, 243, 110, 31, // 955: decode to CV_AND_B using decoder 31
13273 // 955: }
13274 28, 11, // 959: case 0x1c: {
13275 OPC_CheckPredicate, 141, 1, // 961: check predicate 141
13276 OPC_CheckField, 20, 6, 0, // 964: check Inst[25:20] == 0x0
13277 OPC_Decode, 224, 110, 17, // 968: decode to CV_ABS_B using decoder 17
13278 // 968: }
13279 32, 11, // 972: case 0x20: {
13280 OPC_CheckPredicate, 141, 1, // 974: check predicate 141
13281 OPC_CheckField, 25, 1, 0, // 977: check Inst[25] == 0x0
13282 OPC_Decode, 221, 111, 31, // 981: decode to CV_DOTUP_B using decoder 31
13283 // 981: }
13284 34, 11, // 985: case 0x22: {
13285 OPC_CheckPredicate, 141, 1, // 987: check predicate 141
13286 OPC_CheckField, 25, 1, 0, // 990: check Inst[25] == 0x0
13287 OPC_Decode, 227, 111, 31, // 994: decode to CV_DOTUSP_B using decoder 31
13288 // 994: }
13289 36, 11, // 998: case 0x24: {
13290 OPC_CheckPredicate, 141, 1, // 1000: check predicate 141
13291 OPC_CheckField, 25, 1, 0, // 1003: check Inst[25] == 0x0
13292 OPC_Decode, 215, 111, 31, // 1007: decode to CV_DOTSP_B using decoder 31
13293 // 1007: }
13294 38, 11, // 1011: case 0x26: {
13295 OPC_CheckPredicate, 141, 1, // 1013: check predicate 141
13296 OPC_CheckField, 25, 1, 0, // 1016: check Inst[25] == 0x0
13297 OPC_Decode, 205, 112, 59, // 1020: decode to CV_SDOTUP_B using decoder 59
13298 // 1020: }
13299 40, 11, // 1024: case 0x28: {
13300 OPC_CheckPredicate, 141, 1, // 1026: check predicate 141
13301 OPC_CheckField, 25, 1, 0, // 1029: check Inst[25] == 0x0
13302 OPC_Decode, 211, 112, 59, // 1033: decode to CV_SDOTUSP_B using decoder 59
13303 // 1033: }
13304 42, 11, // 1037: case 0x2a: {
13305 OPC_CheckPredicate, 141, 1, // 1039: check predicate 141
13306 OPC_CheckField, 25, 1, 0, // 1042: check Inst[25] == 0x0
13307 OPC_Decode, 199, 112, 59, // 1046: decode to CV_SDOTSP_B using decoder 59
13308 // 1046: }
13309 46, 8, // 1050: case 0x2e: {
13310 OPC_CheckPredicate, 141, 1, // 1052: check predicate 141
13311 OPC_Decode, 244, 111, 215, 1, // 1055: decode to CV_EXTRACT_B using decoder 215
13312 // 1055: }
13313 48, 11, // 1060: case 0x30: {
13314 OPC_CheckPredicate, 141, 1, // 1062: check predicate 141
13315 OPC_CheckField, 25, 1, 0, // 1065: check Inst[25] == 0x0
13316 OPC_Decode, 223, 112, 31, // 1069: decode to CV_SHUFFLE_B using decoder 31
13317 // 1069: }
13318 56, 11, // 1073: case 0x38: {
13319 OPC_CheckPredicate, 141, 1, // 1075: check predicate 141
13320 OPC_CheckField, 25, 1, 0, // 1078: check Inst[25] == 0x0
13321 OPC_Decode, 217, 112, 59, // 1082: decode to CV_SHUFFLE2_B using decoder 59
13322 // 1082: }
13323 62, 0, // 1086: case 0x3e: {
13324 OPC_SwitchField, 25, 1, // 1088: switch Inst[25] {
13325 0, 7, // 1091: case 0x0: {
13326 OPC_CheckPredicate, 141, 1, // 1093: check predicate 141
13327 OPC_Decode, 193, 112, 59, // 1096: decode to CV_PACKLO_B using decoder 59
13328 // 1096: }
13329 1, 0, // 1100: case 0x1: {
13330 OPC_CheckPredicate, 141, 1, // 1102: check predicate 141
13331 OPC_Decode, 192, 112, 59, // 1105: decode to CV_PACKHI_B using decoder 59
13332 // 1105: }
13333 // 1105: } // switch Inst[25]
13334 // 1105: }
13335 // 1105: } // switch Inst[31:26]
13336 // 1105: }
13337 // 1105: } // switch Inst[6:0]
13338 // 1105: }
13339 2, 145, 1, // 1109: case 0x2: {
13340 OPC_SwitchField, 0, 7, // 1112: switch Inst[6:0] {
13341 11, 8, // 1115: case 0xb: {
13342 OPC_CheckPredicate, 139, 1, // 1117: check predicate 139
13343 OPC_Decode, 136, 112, 211, 1, // 1120: decode to CV_LW_ri_inc using decoder 211
13344 // 1120: }
13345 43, 8, // 1125: case 0x2b: {
13346 OPC_CheckPredicate, 139, 1, // 1127: check predicate 139
13347 OPC_Decode, 142, 113, 212, 1, // 1130: decode to CV_SW_ri_inc using decoder 212
13348 // 1130: }
13349 91, 43, // 1135: case 0x5b: {
13350 OPC_SwitchField, 30, 2, // 1137: switch Inst[31:30] {
13351 0, 8, // 1140: case 0x0: {
13352 OPC_CheckPredicate, 142, 1, // 1142: check predicate 142
13353 OPC_Decode, 226, 110, 217, 1, // 1145: decode to CV_ADDN using decoder 217
13354 // 1145: }
13355 1, 8, // 1150: case 0x1: {
13356 OPC_CheckPredicate, 142, 1, // 1152: check predicate 142
13357 OPC_Decode, 230, 110, 217, 1, // 1155: decode to CV_ADDUN using decoder 217
13358 // 1155: }
13359 2, 8, // 1160: case 0x2: {
13360 OPC_CheckPredicate, 142, 1, // 1162: check predicate 142
13361 OPC_Decode, 228, 110, 217, 1, // 1165: decode to CV_ADDRN using decoder 217
13362 // 1165: }
13363 3, 0, // 1170: case 0x3: {
13364 OPC_CheckPredicate, 142, 1, // 1172: check predicate 142
13365 OPC_Decode, 232, 110, 217, 1, // 1175: decode to CV_ADDURN using decoder 217
13366 // 1175: }
13367 // 1175: } // switch Inst[31:30]
13368 // 1175: }
13369 123, 0, // 1180: case 0x7b: {
13370 OPC_SwitchField, 26, 6, // 1182: switch Inst[31:26] {
13371 21, 21, // 1185: case 0x15: {
13372 OPC_SwitchField, 25, 1, // 1187: switch Inst[25] {
13373 0, 7, // 1190: case 0x0: {
13374 OPC_CheckPredicate, 141, 1, // 1192: check predicate 141
13375 OPC_Decode, 212, 111, 59, // 1195: decode to CV_CPLXMUL_R_DIV2 using decoder 59
13376 // 1195: }
13377 1, 0, // 1199: case 0x1: {
13378 OPC_CheckPredicate, 141, 1, // 1201: check predicate 141
13379 OPC_Decode, 208, 111, 59, // 1204: decode to CV_CPLXMUL_I_DIV2 using decoder 59
13380 // 1204: }
13381 // 1204: } // switch Inst[25]
13382 // 1204: }
13383 25, 11, // 1208: case 0x19: {
13384 OPC_CheckPredicate, 141, 1, // 1210: check predicate 141
13385 OPC_CheckField, 25, 1, 0, // 1213: check Inst[25] == 0x0
13386 OPC_Decode, 254, 112, 31, // 1217: decode to CV_SUBROTMJ_DIV2 using decoder 31
13387 // 1217: }
13388 27, 11, // 1221: case 0x1b: {
13389 OPC_CheckPredicate, 141, 1, // 1223: check predicate 141
13390 OPC_CheckField, 25, 1, 0, // 1226: check Inst[25] == 0x0
13391 OPC_Decode, 235, 110, 31, // 1230: decode to CV_ADD_DIV2 using decoder 31
13392 // 1230: }
13393 29, 11, // 1234: case 0x1d: {
13394 OPC_CheckPredicate, 141, 1, // 1236: check predicate 141
13395 OPC_CheckField, 25, 1, 0, // 1239: check Inst[25] == 0x0
13396 OPC_Decode, 134, 113, 31, // 1243: decode to CV_SUB_DIV2 using decoder 31
13397 // 1243: }
13398 46, 0, // 1247: case 0x2e: {
13399 OPC_CheckPredicate, 141, 1, // 1249: check predicate 141
13400 OPC_Decode, 243, 111, 215, 1, // 1252: decode to CV_EXTRACTU_H using decoder 215
13401 // 1252: }
13402 // 1252: } // switch Inst[31:26]
13403 // 1252: }
13404 // 1252: } // switch Inst[6:0]
13405 // 1252: }
13406 3, 199, 4, // 1257: case 0x3: {
13407 OPC_SwitchField, 0, 7, // 1260: switch Inst[6:0] {
13408 11, 7, // 1263: case 0xb: {
13409 OPC_CheckPredicate, 143, 1, // 1265: check predicate 143
13410 OPC_Decode, 233, 111, 0, // 1268: decode to CV_ELW using decoder 0
13411 // 1268: }
13412 43, 253, 3, // 1272: case 0x2b: {
13413 OPC_SwitchField, 25, 7, // 1275: switch Inst[31:25] {
13414 0, 8, // 1278: case 0x0: {
13415 OPC_CheckPredicate, 139, 1, // 1280: check predicate 139
13416 OPC_Decode, 129, 112, 218, 1, // 1283: decode to CV_LB_rr_inc using decoder 218
13417 // 1283: }
13418 1, 8, // 1288: case 0x1: {
13419 OPC_CheckPredicate, 139, 1, // 1290: check predicate 139
13420 OPC_Decode, 135, 112, 218, 1, // 1293: decode to CV_LH_rr_inc using decoder 218
13421 // 1293: }
13422 2, 8, // 1298: case 0x2: {
13423 OPC_CheckPredicate, 139, 1, // 1300: check predicate 139
13424 OPC_Decode, 138, 112, 218, 1, // 1303: decode to CV_LW_rr_inc using decoder 218
13425 // 1303: }
13426 4, 7, // 1308: case 0x4: {
13427 OPC_CheckPredicate, 139, 1, // 1310: check predicate 139
13428 OPC_Decode, 128, 112, 31, // 1313: decode to CV_LB_rr using decoder 31
13429 // 1313: }
13430 5, 7, // 1317: case 0x5: {
13431 OPC_CheckPredicate, 139, 1, // 1319: check predicate 139
13432 OPC_Decode, 134, 112, 31, // 1322: decode to CV_LH_rr using decoder 31
13433 // 1322: }
13434 6, 7, // 1326: case 0x6: {
13435 OPC_CheckPredicate, 139, 1, // 1328: check predicate 139
13436 OPC_Decode, 137, 112, 31, // 1331: decode to CV_LW_rr using decoder 31
13437 // 1331: }
13438 8, 8, // 1335: case 0x8: {
13439 OPC_CheckPredicate, 139, 1, // 1337: check predicate 139
13440 OPC_Decode, 254, 111, 218, 1, // 1340: decode to CV_LBU_rr_inc using decoder 218
13441 // 1340: }
13442 9, 8, // 1345: case 0x9: {
13443 OPC_CheckPredicate, 139, 1, // 1347: check predicate 139
13444 OPC_Decode, 132, 112, 218, 1, // 1350: decode to CV_LHU_rr_inc using decoder 218
13445 // 1350: }
13446 12, 7, // 1355: case 0xc: {
13447 OPC_CheckPredicate, 139, 1, // 1357: check predicate 139
13448 OPC_Decode, 253, 111, 31, // 1360: decode to CV_LBU_rr using decoder 31
13449 // 1360: }
13450 13, 7, // 1364: case 0xd: {
13451 OPC_CheckPredicate, 139, 1, // 1366: check predicate 139
13452 OPC_Decode, 131, 112, 31, // 1369: decode to CV_LHU_rr using decoder 31
13453 // 1369: }
13454 16, 8, // 1373: case 0x10: {
13455 OPC_CheckPredicate, 139, 1, // 1375: check predicate 139
13456 OPC_Decode, 198, 112, 219, 1, // 1378: decode to CV_SB_rr_inc using decoder 219
13457 // 1378: }
13458 17, 8, // 1383: case 0x11: {
13459 OPC_CheckPredicate, 139, 1, // 1385: check predicate 139
13460 OPC_Decode, 228, 112, 219, 1, // 1388: decode to CV_SH_rr_inc using decoder 219
13461 // 1388: }
13462 18, 8, // 1393: case 0x12: {
13463 OPC_CheckPredicate, 139, 1, // 1395: check predicate 139
13464 OPC_Decode, 144, 113, 219, 1, // 1398: decode to CV_SW_rr_inc using decoder 219
13465 // 1398: }
13466 20, 8, // 1403: case 0x14: {
13467 OPC_CheckPredicate, 139, 1, // 1405: check predicate 139
13468 OPC_Decode, 197, 112, 220, 1, // 1408: decode to CV_SB_rr using decoder 220
13469 // 1408: }
13470 21, 8, // 1413: case 0x15: {
13471 OPC_CheckPredicate, 139, 1, // 1415: check predicate 139
13472 OPC_Decode, 227, 112, 220, 1, // 1418: decode to CV_SH_rr using decoder 220
13473 // 1418: }
13474 22, 8, // 1423: case 0x16: {
13475 OPC_CheckPredicate, 139, 1, // 1425: check predicate 139
13476 OPC_Decode, 143, 113, 220, 1, // 1428: decode to CV_SW_rr using decoder 220
13477 // 1428: }
13478 24, 7, // 1433: case 0x18: {
13479 OPC_CheckPredicate, 140, 1, // 1435: check predicate 140
13480 OPC_Decode, 239, 111, 31, // 1438: decode to CV_EXTRACTR using decoder 31
13481 // 1438: }
13482 25, 7, // 1442: case 0x19: {
13483 OPC_CheckPredicate, 140, 1, // 1444: check predicate 140
13484 OPC_Decode, 241, 111, 31, // 1447: decode to CV_EXTRACTUR using decoder 31
13485 // 1447: }
13486 26, 7, // 1451: case 0x1a: {
13487 OPC_CheckPredicate, 140, 1, // 1453: check predicate 140
13488 OPC_Decode, 249, 111, 59, // 1456: decode to CV_INSERTR using decoder 59
13489 // 1456: }
13490 28, 7, // 1460: case 0x1c: {
13491 OPC_CheckPredicate, 140, 1, // 1462: check predicate 140
13492 OPC_Decode, 134, 111, 31, // 1465: decode to CV_BCLRR using decoder 31
13493 // 1465: }
13494 29, 7, // 1469: case 0x1d: {
13495 OPC_CheckPredicate, 140, 1, // 1471: check predicate 140
13496 OPC_Decode, 139, 111, 31, // 1474: decode to CV_BSETR using decoder 31
13497 // 1474: }
13498 32, 7, // 1478: case 0x20: {
13499 OPC_CheckPredicate, 140, 1, // 1480: check predicate 140
13500 OPC_Decode, 195, 112, 31, // 1483: decode to CV_ROR using decoder 31
13501 // 1483: }
13502 33, 11, // 1487: case 0x21: {
13503 OPC_CheckPredicate, 140, 1, // 1489: check predicate 140
13504 OPC_CheckField, 20, 5, 0, // 1492: check Inst[24:20] == 0x0
13505 OPC_Decode, 246, 111, 17, // 1496: decode to CV_FF1 using decoder 17
13506 // 1496: }
13507 34, 11, // 1500: case 0x22: {
13508 OPC_CheckPredicate, 140, 1, // 1502: check predicate 140
13509 OPC_CheckField, 20, 5, 0, // 1505: check Inst[24:20] == 0x0
13510 OPC_Decode, 247, 111, 17, // 1509: decode to CV_FL1 using decoder 17
13511 // 1509: }
13512 35, 11, // 1513: case 0x23: {
13513 OPC_CheckPredicate, 140, 1, // 1515: check predicate 140
13514 OPC_CheckField, 20, 5, 0, // 1518: check Inst[24:20] == 0x0
13515 OPC_Decode, 140, 111, 17, // 1522: decode to CV_CLB using decoder 17
13516 // 1522: }
13517 36, 11, // 1526: case 0x24: {
13518 OPC_CheckPredicate, 140, 1, // 1528: check predicate 140
13519 OPC_CheckField, 20, 5, 0, // 1531: check Inst[24:20] == 0x0
13520 OPC_Decode, 205, 111, 17, // 1535: decode to CV_CNT using decoder 17
13521 // 1535: }
13522 40, 11, // 1539: case 0x28: {
13523 OPC_CheckPredicate, 142, 1, // 1541: check predicate 142
13524 OPC_CheckField, 20, 5, 0, // 1544: check Inst[24:20] == 0x0
13525 OPC_Decode, 223, 110, 17, // 1548: decode to CV_ABS using decoder 17
13526 // 1548: }
13527 41, 7, // 1552: case 0x29: {
13528 OPC_CheckPredicate, 142, 1, // 1554: check predicate 142
13529 OPC_Decode, 229, 112, 31, // 1557: decode to CV_SLE using decoder 31
13530 // 1557: }
13531 42, 7, // 1561: case 0x2a: {
13532 OPC_CheckPredicate, 142, 1, // 1563: check predicate 142
13533 OPC_Decode, 230, 112, 31, // 1566: decode to CV_SLEU using decoder 31
13534 // 1566: }
13535 43, 7, // 1570: case 0x2b: {
13536 OPC_CheckPredicate, 142, 1, // 1572: check predicate 142
13537 OPC_Decode, 162, 112, 31, // 1575: decode to CV_MIN using decoder 31
13538 // 1575: }
13539 44, 7, // 1579: case 0x2c: {
13540 OPC_CheckPredicate, 142, 1, // 1581: check predicate 142
13541 OPC_Decode, 163, 112, 31, // 1584: decode to CV_MINU using decoder 31
13542 // 1584: }
13543 45, 7, // 1588: case 0x2d: {
13544 OPC_CheckPredicate, 142, 1, // 1590: check predicate 142
13545 OPC_Decode, 148, 112, 31, // 1593: decode to CV_MAX using decoder 31
13546 // 1593: }
13547 46, 7, // 1597: case 0x2e: {
13548 OPC_CheckPredicate, 142, 1, // 1599: check predicate 142
13549 OPC_Decode, 149, 112, 31, // 1602: decode to CV_MAXU using decoder 31
13550 // 1602: }
13551 48, 11, // 1606: case 0x30: {
13552 OPC_CheckPredicate, 142, 1, // 1608: check predicate 142
13553 OPC_CheckField, 20, 5, 0, // 1611: check Inst[24:20] == 0x0
13554 OPC_Decode, 236, 111, 17, // 1615: decode to CV_EXTHS using decoder 17
13555 // 1615: }
13556 49, 11, // 1619: case 0x31: {
13557 OPC_CheckPredicate, 142, 1, // 1621: check predicate 142
13558 OPC_CheckField, 20, 5, 0, // 1624: check Inst[24:20] == 0x0
13559 OPC_Decode, 237, 111, 17, // 1628: decode to CV_EXTHZ using decoder 17
13560 // 1628: }
13561 50, 11, // 1632: case 0x32: {
13562 OPC_CheckPredicate, 142, 1, // 1634: check predicate 142
13563 OPC_CheckField, 20, 5, 0, // 1637: check Inst[24:20] == 0x0
13564 OPC_Decode, 234, 111, 17, // 1641: decode to CV_EXTBS using decoder 17
13565 // 1641: }
13566 51, 11, // 1645: case 0x33: {
13567 OPC_CheckPredicate, 142, 1, // 1647: check predicate 142
13568 OPC_CheckField, 20, 5, 0, // 1650: check Inst[24:20] == 0x0
13569 OPC_Decode, 235, 111, 17, // 1654: decode to CV_EXTBZ using decoder 17
13570 // 1654: }
13571 56, 7, // 1658: case 0x38: {
13572 OPC_CheckPredicate, 142, 1, // 1660: check predicate 142
13573 OPC_Decode, 141, 111, 21, // 1663: decode to CV_CLIP using decoder 21
13574 // 1663: }
13575 57, 7, // 1667: case 0x39: {
13576 OPC_CheckPredicate, 142, 1, // 1669: check predicate 142
13577 OPC_Decode, 143, 111, 21, // 1672: decode to CV_CLIPU using decoder 21
13578 // 1672: }
13579 58, 7, // 1676: case 0x3a: {
13580 OPC_CheckPredicate, 142, 1, // 1678: check predicate 142
13581 OPC_Decode, 142, 111, 31, // 1681: decode to CV_CLIPR using decoder 31
13582 // 1681: }
13583 59, 7, // 1685: case 0x3b: {
13584 OPC_CheckPredicate, 142, 1, // 1687: check predicate 142
13585 OPC_Decode, 144, 111, 31, // 1690: decode to CV_CLIPUR using decoder 31
13586 // 1690: }
13587 64, 7, // 1694: case 0x40: {
13588 OPC_CheckPredicate, 142, 1, // 1696: check predicate 142
13589 OPC_Decode, 227, 110, 59, // 1699: decode to CV_ADDNR using decoder 59
13590 // 1699: }
13591 65, 7, // 1703: case 0x41: {
13592 OPC_CheckPredicate, 142, 1, // 1705: check predicate 142
13593 OPC_Decode, 231, 110, 59, // 1708: decode to CV_ADDUNR using decoder 59
13594 // 1708: }
13595 66, 7, // 1712: case 0x42: {
13596 OPC_CheckPredicate, 142, 1, // 1714: check predicate 142
13597 OPC_Decode, 229, 110, 59, // 1717: decode to CV_ADDRNR using decoder 59
13598 // 1717: }
13599 67, 7, // 1721: case 0x43: {
13600 OPC_CheckPredicate, 142, 1, // 1723: check predicate 142
13601 OPC_Decode, 233, 110, 59, // 1726: decode to CV_ADDURNR using decoder 59
13602 // 1726: }
13603 68, 7, // 1730: case 0x44: {
13604 OPC_CheckPredicate, 142, 1, // 1732: check predicate 142
13605 OPC_Decode, 250, 112, 59, // 1735: decode to CV_SUBNR using decoder 59
13606 // 1735: }
13607 69, 7, // 1739: case 0x45: {
13608 OPC_CheckPredicate, 142, 1, // 1741: check predicate 142
13609 OPC_Decode, 130, 113, 59, // 1744: decode to CV_SUBUNR using decoder 59
13610 // 1744: }
13611 70, 7, // 1748: case 0x46: {
13612 OPC_CheckPredicate, 142, 1, // 1750: check predicate 142
13613 OPC_Decode, 252, 112, 59, // 1753: decode to CV_SUBRNR using decoder 59
13614 // 1753: }
13615 71, 7, // 1757: case 0x47: {
13616 OPC_CheckPredicate, 142, 1, // 1759: check predicate 142
13617 OPC_Decode, 132, 113, 59, // 1762: decode to CV_SUBURNR using decoder 59
13618 // 1762: }
13619 72, 7, // 1766: case 0x48: {
13620 OPC_CheckPredicate, 144, 1, // 1768: check predicate 144
13621 OPC_Decode, 139, 112, 59, // 1771: decode to CV_MAC using decoder 59
13622 // 1771: }
13623 73, 0, // 1775: case 0x49: {
13624 OPC_CheckPredicate, 144, 1, // 1777: check predicate 144
13625 OPC_Decode, 176, 112, 59, // 1780: decode to CV_MSU using decoder 59
13626 // 1780: }
13627 // 1780: } // switch Inst[31:25]
13628 // 1780: }
13629 91, 43, // 1784: case 0x5b: {
13630 OPC_SwitchField, 30, 2, // 1786: switch Inst[31:30] {
13631 0, 8, // 1789: case 0x0: {
13632 OPC_CheckPredicate, 142, 1, // 1791: check predicate 142
13633 OPC_Decode, 249, 112, 217, 1, // 1794: decode to CV_SUBN using decoder 217
13634 // 1794: }
13635 1, 8, // 1799: case 0x1: {
13636 OPC_CheckPredicate, 142, 1, // 1801: check predicate 142
13637 OPC_Decode, 129, 113, 217, 1, // 1804: decode to CV_SUBUN using decoder 217
13638 // 1804: }
13639 2, 8, // 1809: case 0x2: {
13640 OPC_CheckPredicate, 142, 1, // 1811: check predicate 142
13641 OPC_Decode, 251, 112, 217, 1, // 1814: decode to CV_SUBRN using decoder 217
13642 // 1814: }
13643 3, 0, // 1819: case 0x3: {
13644 OPC_CheckPredicate, 142, 1, // 1821: check predicate 142
13645 OPC_Decode, 131, 113, 217, 1, // 1824: decode to CV_SUBURN using decoder 217
13646 // 1824: }
13647 // 1824: } // switch Inst[31:30]
13648 // 1824: }
13649 123, 0, // 1829: case 0x7b: {
13650 OPC_CheckPredicate, 141, 1, // 1831: check predicate 141
13651 OPC_CheckField, 26, 6, 46, // 1834: check Inst[31:26] == 0x2e
13652 OPC_Decode, 242, 111, 215, 1, // 1838: decode to CV_EXTRACTU_B using decoder 215
13653 // 1838: }
13654 // 1838: } // switch Inst[6:0]
13655 // 1838: }
13656 4, 141, 4, // 1843: case 0x4: {
13657 OPC_SwitchField, 0, 7, // 1846: switch Inst[6:0] {
13658 11, 8, // 1849: case 0xb: {
13659 OPC_CheckPredicate, 139, 1, // 1851: check predicate 139
13660 OPC_Decode, 252, 111, 211, 1, // 1854: decode to CV_LBU_ri_inc using decoder 211
13661 // 1854: }
13662 91, 43, // 1859: case 0x5b: {
13663 OPC_SwitchField, 30, 2, // 1861: switch Inst[31:30] {
13664 0, 8, // 1864: case 0x0: {
13665 OPC_CheckPredicate, 144, 1, // 1866: check predicate 144
13666 OPC_Decode, 181, 112, 217, 1, // 1869: decode to CV_MULSN using decoder 217
13667 // 1869: }
13668 1, 8, // 1874: case 0x1: {
13669 OPC_CheckPredicate, 144, 1, // 1876: check predicate 144
13670 OPC_Decode, 177, 112, 217, 1, // 1879: decode to CV_MULHHSN using decoder 217
13671 // 1879: }
13672 2, 8, // 1884: case 0x2: {
13673 OPC_CheckPredicate, 144, 1, // 1886: check predicate 144
13674 OPC_Decode, 182, 112, 217, 1, // 1889: decode to CV_MULSRN using decoder 217
13675 // 1889: }
13676 3, 0, // 1894: case 0x3: {
13677 OPC_CheckPredicate, 144, 1, // 1896: check predicate 144
13678 OPC_Decode, 178, 112, 217, 1, // 1899: decode to CV_MULHHSRN using decoder 217
13679 // 1899: }
13680 // 1899: } // switch Inst[31:30]
13681 // 1899: }
13682 123, 0, // 1904: case 0x7b: {
13683 OPC_SwitchField, 26, 6, // 1906: switch Inst[31:26] {
13684 0, 11, // 1909: case 0x0: {
13685 OPC_CheckPredicate, 141, 1, // 1911: check predicate 141
13686 OPC_CheckField, 25, 1, 0, // 1914: check Inst[25] == 0x0
13687 OPC_Decode, 242, 110, 31, // 1918: decode to CV_ADD_SC_H using decoder 31
13688 // 1918: }
13689 1, 11, // 1922: case 0x1: {
13690 OPC_CheckPredicate, 141, 1, // 1924: check predicate 141
13691 OPC_CheckField, 25, 1, 0, // 1927: check Inst[25] == 0x0
13692 OPC_Decode, 150, 111, 31, // 1931: decode to CV_CMPEQ_SC_H using decoder 31
13693 // 1931: }
13694 2, 11, // 1935: case 0x2: {
13695 OPC_CheckPredicate, 141, 1, // 1937: check predicate 141
13696 OPC_CheckField, 25, 1, 0, // 1940: check Inst[25] == 0x0
13697 OPC_Decode, 141, 113, 31, // 1944: decode to CV_SUB_SC_H using decoder 31
13698 // 1944: }
13699 3, 11, // 1948: case 0x3: {
13700 OPC_CheckPredicate, 141, 1, // 1950: check predicate 141
13701 OPC_CheckField, 25, 1, 0, // 1953: check Inst[25] == 0x0
13702 OPC_Decode, 204, 111, 31, // 1957: decode to CV_CMPNE_SC_H using decoder 31
13703 // 1957: }
13704 4, 11, // 1961: case 0x4: {
13705 OPC_CheckPredicate, 141, 1, // 1963: check predicate 141
13706 OPC_CheckField, 25, 1, 0, // 1966: check Inst[25] == 0x0
13707 OPC_Decode, 132, 111, 31, // 1970: decode to CV_AVG_SC_H using decoder 31
13708 // 1970: }
13709 5, 11, // 1974: case 0x5: {
13710 OPC_CheckPredicate, 141, 1, // 1976: check predicate 141
13711 OPC_CheckField, 25, 1, 0, // 1979: check Inst[25] == 0x0
13712 OPC_Decode, 174, 111, 31, // 1983: decode to CV_CMPGT_SC_H using decoder 31
13713 // 1983: }
13714 6, 11, // 1987: case 0x6: {
13715 OPC_CheckPredicate, 141, 1, // 1989: check predicate 141
13716 OPC_CheckField, 25, 1, 0, // 1992: check Inst[25] == 0x0
13717 OPC_Decode, 254, 110, 31, // 1996: decode to CV_AVGU_SC_H using decoder 31
13718 // 1996: }
13719 7, 11, // 2000: case 0x7: {
13720 OPC_CheckPredicate, 141, 1, // 2002: check predicate 141
13721 OPC_CheckField, 25, 1, 0, // 2005: check Inst[25] == 0x0
13722 OPC_Decode, 162, 111, 31, // 2009: decode to CV_CMPGE_SC_H using decoder 31
13723 // 2009: }
13724 8, 11, // 2013: case 0x8: {
13725 OPC_CheckPredicate, 141, 1, // 2015: check predicate 141
13726 OPC_CheckField, 25, 1, 0, // 2018: check Inst[25] == 0x0
13727 OPC_Decode, 175, 112, 31, // 2022: decode to CV_MIN_SC_H using decoder 31
13728 // 2022: }
13729 9, 11, // 2026: case 0x9: {
13730 OPC_CheckPredicate, 141, 1, // 2028: check predicate 141
13731 OPC_CheckField, 25, 1, 0, // 2031: check Inst[25] == 0x0
13732 OPC_Decode, 198, 111, 31, // 2035: decode to CV_CMPLT_SC_H using decoder 31
13733 // 2035: }
13734 10, 11, // 2039: case 0xa: {
13735 OPC_CheckPredicate, 141, 1, // 2041: check predicate 141
13736 OPC_CheckField, 25, 1, 0, // 2044: check Inst[25] == 0x0
13737 OPC_Decode, 169, 112, 31, // 2048: decode to CV_MINU_SC_H using decoder 31
13738 // 2048: }
13739 11, 11, // 2052: case 0xb: {
13740 OPC_CheckPredicate, 141, 1, // 2054: check predicate 141
13741 OPC_CheckField, 25, 1, 0, // 2057: check Inst[25] == 0x0
13742 OPC_Decode, 186, 111, 31, // 2061: decode to CV_CMPLE_SC_H using decoder 31
13743 // 2061: }
13744 12, 11, // 2065: case 0xc: {
13745 OPC_CheckPredicate, 141, 1, // 2067: check predicate 141
13746 OPC_CheckField, 25, 1, 0, // 2070: check Inst[25] == 0x0
13747 OPC_Decode, 161, 112, 31, // 2074: decode to CV_MAX_SC_H using decoder 31
13748 // 2074: }
13749 13, 11, // 2078: case 0xd: {
13750 OPC_CheckPredicate, 141, 1, // 2080: check predicate 141
13751 OPC_CheckField, 25, 1, 0, // 2083: check Inst[25] == 0x0
13752 OPC_Decode, 168, 111, 31, // 2087: decode to CV_CMPGTU_SC_H using decoder 31
13753 // 2087: }
13754 14, 11, // 2091: case 0xe: {
13755 OPC_CheckPredicate, 141, 1, // 2093: check predicate 141
13756 OPC_CheckField, 25, 1, 0, // 2096: check Inst[25] == 0x0
13757 OPC_Decode, 155, 112, 31, // 2100: decode to CV_MAXU_SC_H using decoder 31
13758 // 2100: }
13759 15, 11, // 2104: case 0xf: {
13760 OPC_CheckPredicate, 141, 1, // 2106: check predicate 141
13761 OPC_CheckField, 25, 1, 0, // 2109: check Inst[25] == 0x0
13762 OPC_Decode, 156, 111, 31, // 2113: decode to CV_CMPGEU_SC_H using decoder 31
13763 // 2113: }
13764 16, 11, // 2117: case 0x10: {
13765 OPC_CheckPredicate, 141, 1, // 2119: check predicate 141
13766 OPC_CheckField, 25, 1, 0, // 2122: check Inst[25] == 0x0
13767 OPC_Decode, 248, 112, 31, // 2126: decode to CV_SRL_SC_H using decoder 31
13768 // 2126: }
13769 17, 11, // 2130: case 0x11: {
13770 OPC_CheckPredicate, 141, 1, // 2132: check predicate 141
13771 OPC_CheckField, 25, 1, 0, // 2135: check Inst[25] == 0x0
13772 OPC_Decode, 192, 111, 31, // 2139: decode to CV_CMPLTU_SC_H using decoder 31
13773 // 2139: }
13774 18, 11, // 2143: case 0x12: {
13775 OPC_CheckPredicate, 141, 1, // 2145: check predicate 141
13776 OPC_CheckField, 25, 1, 0, // 2148: check Inst[25] == 0x0
13777 OPC_Decode, 242, 112, 31, // 2152: decode to CV_SRA_SC_H using decoder 31
13778 // 2152: }
13779 19, 11, // 2156: case 0x13: {
13780 OPC_CheckPredicate, 141, 1, // 2158: check predicate 141
13781 OPC_CheckField, 25, 1, 0, // 2161: check Inst[25] == 0x0
13782 OPC_Decode, 180, 111, 31, // 2165: decode to CV_CMPLEU_SC_H using decoder 31
13783 // 2165: }
13784 20, 11, // 2169: case 0x14: {
13785 OPC_CheckPredicate, 141, 1, // 2171: check predicate 141
13786 OPC_CheckField, 25, 1, 0, // 2174: check Inst[25] == 0x0
13787 OPC_Decode, 236, 112, 31, // 2178: decode to CV_SLL_SC_H using decoder 31
13788 // 2178: }
13789 21, 21, // 2182: case 0x15: {
13790 OPC_SwitchField, 25, 1, // 2184: switch Inst[25] {
13791 0, 7, // 2187: case 0x0: {
13792 OPC_CheckPredicate, 141, 1, // 2189: check predicate 141
13793 OPC_Decode, 213, 111, 59, // 2192: decode to CV_CPLXMUL_R_DIV4 using decoder 59
13794 // 2192: }
13795 1, 0, // 2196: case 0x1: {
13796 OPC_CheckPredicate, 141, 1, // 2198: check predicate 141
13797 OPC_Decode, 209, 111, 59, // 2201: decode to CV_CPLXMUL_I_DIV4 using decoder 59
13798 // 2201: }
13799 // 2201: } // switch Inst[25]
13800 // 2201: }
13801 22, 11, // 2205: case 0x16: {
13802 OPC_CheckPredicate, 141, 1, // 2207: check predicate 141
13803 OPC_CheckField, 25, 1, 0, // 2210: check Inst[25] == 0x0
13804 OPC_Decode, 190, 112, 31, // 2214: decode to CV_OR_SC_H using decoder 31
13805 // 2214: }
13806 24, 11, // 2218: case 0x18: {
13807 OPC_CheckPredicate, 141, 1, // 2220: check predicate 141
13808 OPC_CheckField, 25, 1, 0, // 2223: check Inst[25] == 0x0
13809 OPC_Decode, 150, 113, 31, // 2227: decode to CV_XOR_SC_H using decoder 31
13810 // 2227: }
13811 25, 11, // 2231: case 0x19: {
13812 OPC_CheckPredicate, 141, 1, // 2233: check predicate 141
13813 OPC_CheckField, 25, 1, 0, // 2236: check Inst[25] == 0x0
13814 OPC_Decode, 255, 112, 31, // 2240: decode to CV_SUBROTMJ_DIV4 using decoder 31
13815 // 2240: }
13816 26, 11, // 2244: case 0x1a: {
13817 OPC_CheckPredicate, 141, 1, // 2246: check predicate 141
13818 OPC_CheckField, 25, 1, 0, // 2249: check Inst[25] == 0x0
13819 OPC_Decode, 248, 110, 31, // 2253: decode to CV_AND_SC_H using decoder 31
13820 // 2253: }
13821 27, 11, // 2257: case 0x1b: {
13822 OPC_CheckPredicate, 141, 1, // 2259: check predicate 141
13823 OPC_CheckField, 25, 1, 0, // 2262: check Inst[25] == 0x0
13824 OPC_Decode, 236, 110, 31, // 2266: decode to CV_ADD_DIV4 using decoder 31
13825 // 2266: }
13826 29, 11, // 2270: case 0x1d: {
13827 OPC_CheckPredicate, 141, 1, // 2272: check predicate 141
13828 OPC_CheckField, 25, 1, 0, // 2275: check Inst[25] == 0x0
13829 OPC_Decode, 135, 113, 31, // 2279: decode to CV_SUB_DIV4 using decoder 31
13830 // 2279: }
13831 32, 11, // 2283: case 0x20: {
13832 OPC_CheckPredicate, 141, 1, // 2285: check predicate 141
13833 OPC_CheckField, 25, 1, 0, // 2288: check Inst[25] == 0x0
13834 OPC_Decode, 226, 111, 31, // 2292: decode to CV_DOTUP_SC_H using decoder 31
13835 // 2292: }
13836 34, 11, // 2296: case 0x22: {
13837 OPC_CheckPredicate, 141, 1, // 2298: check predicate 141
13838 OPC_CheckField, 25, 1, 0, // 2301: check Inst[25] == 0x0
13839 OPC_Decode, 232, 111, 31, // 2305: decode to CV_DOTUSP_SC_H using decoder 31
13840 // 2305: }
13841 36, 11, // 2309: case 0x24: {
13842 OPC_CheckPredicate, 141, 1, // 2311: check predicate 141
13843 OPC_CheckField, 25, 1, 0, // 2314: check Inst[25] == 0x0
13844 OPC_Decode, 220, 111, 31, // 2318: decode to CV_DOTSP_SC_H using decoder 31
13845 // 2318: }
13846 38, 11, // 2322: case 0x26: {
13847 OPC_CheckPredicate, 141, 1, // 2324: check predicate 141
13848 OPC_CheckField, 25, 1, 0, // 2327: check Inst[25] == 0x0
13849 OPC_Decode, 210, 112, 59, // 2331: decode to CV_SDOTUP_SC_H using decoder 59
13850 // 2331: }
13851 40, 11, // 2335: case 0x28: {
13852 OPC_CheckPredicate, 141, 1, // 2337: check predicate 141
13853 OPC_CheckField, 25, 1, 0, // 2340: check Inst[25] == 0x0
13854 OPC_Decode, 216, 112, 59, // 2344: decode to CV_SDOTUSP_SC_H using decoder 59
13855 // 2344: }
13856 42, 11, // 2348: case 0x2a: {
13857 OPC_CheckPredicate, 141, 1, // 2350: check predicate 141
13858 OPC_CheckField, 25, 1, 0, // 2353: check Inst[25] == 0x0
13859 OPC_Decode, 204, 112, 59, // 2357: decode to CV_SDOTSP_SC_H using decoder 59
13860 // 2357: }
13861 46, 0, // 2361: case 0x2e: {
13862 OPC_CheckPredicate, 141, 1, // 2363: check predicate 141
13863 OPC_Decode, 251, 111, 221, 1, // 2366: decode to CV_INSERT_H using decoder 221
13864 // 2366: }
13865 // 2366: } // switch Inst[31:26]
13866 // 2366: }
13867 // 2366: } // switch Inst[6:0]
13868 // 2366: }
13869 5, 207, 3, // 2371: case 0x5: {
13870 OPC_SwitchField, 0, 7, // 2374: switch Inst[6:0] {
13871 11, 8, // 2377: case 0xb: {
13872 OPC_CheckPredicate, 139, 1, // 2379: check predicate 139
13873 OPC_Decode, 130, 112, 211, 1, // 2382: decode to CV_LHU_ri_inc using decoder 211
13874 // 2382: }
13875 91, 43, // 2387: case 0x5b: {
13876 OPC_SwitchField, 30, 2, // 2389: switch Inst[31:30] {
13877 0, 8, // 2392: case 0x0: {
13878 OPC_CheckPredicate, 144, 1, // 2394: check predicate 144
13879 OPC_Decode, 183, 112, 217, 1, // 2397: decode to CV_MULUN using decoder 217
13880 // 2397: }
13881 1, 8, // 2402: case 0x1: {
13882 OPC_CheckPredicate, 144, 1, // 2404: check predicate 144
13883 OPC_Decode, 179, 112, 217, 1, // 2407: decode to CV_MULHHUN using decoder 217
13884 // 2407: }
13885 2, 8, // 2412: case 0x2: {
13886 OPC_CheckPredicate, 144, 1, // 2414: check predicate 144
13887 OPC_Decode, 184, 112, 217, 1, // 2417: decode to CV_MULURN using decoder 217
13888 // 2417: }
13889 3, 0, // 2422: case 0x3: {
13890 OPC_CheckPredicate, 144, 1, // 2424: check predicate 144
13891 OPC_Decode, 180, 112, 217, 1, // 2427: decode to CV_MULHHURN using decoder 217
13892 // 2427: }
13893 // 2427: } // switch Inst[31:30]
13894 // 2427: }
13895 123, 0, // 2432: case 0x7b: {
13896 OPC_SwitchField, 26, 6, // 2434: switch Inst[31:26] {
13897 0, 11, // 2437: case 0x0: {
13898 OPC_CheckPredicate, 141, 1, // 2439: check predicate 141
13899 OPC_CheckField, 25, 1, 0, // 2442: check Inst[25] == 0x0
13900 OPC_Decode, 241, 110, 31, // 2446: decode to CV_ADD_SC_B using decoder 31
13901 // 2446: }
13902 1, 11, // 2450: case 0x1: {
13903 OPC_CheckPredicate, 141, 1, // 2452: check predicate 141
13904 OPC_CheckField, 25, 1, 0, // 2455: check Inst[25] == 0x0
13905 OPC_Decode, 149, 111, 31, // 2459: decode to CV_CMPEQ_SC_B using decoder 31
13906 // 2459: }
13907 2, 11, // 2463: case 0x2: {
13908 OPC_CheckPredicate, 141, 1, // 2465: check predicate 141
13909 OPC_CheckField, 25, 1, 0, // 2468: check Inst[25] == 0x0
13910 OPC_Decode, 140, 113, 31, // 2472: decode to CV_SUB_SC_B using decoder 31
13911 // 2472: }
13912 3, 11, // 2476: case 0x3: {
13913 OPC_CheckPredicate, 141, 1, // 2478: check predicate 141
13914 OPC_CheckField, 25, 1, 0, // 2481: check Inst[25] == 0x0
13915 OPC_Decode, 203, 111, 31, // 2485: decode to CV_CMPNE_SC_B using decoder 31
13916 // 2485: }
13917 4, 11, // 2489: case 0x4: {
13918 OPC_CheckPredicate, 141, 1, // 2491: check predicate 141
13919 OPC_CheckField, 25, 1, 0, // 2494: check Inst[25] == 0x0
13920 OPC_Decode, 131, 111, 31, // 2498: decode to CV_AVG_SC_B using decoder 31
13921 // 2498: }
13922 5, 11, // 2502: case 0x5: {
13923 OPC_CheckPredicate, 141, 1, // 2504: check predicate 141
13924 OPC_CheckField, 25, 1, 0, // 2507: check Inst[25] == 0x0
13925 OPC_Decode, 173, 111, 31, // 2511: decode to CV_CMPGT_SC_B using decoder 31
13926 // 2511: }
13927 6, 11, // 2515: case 0x6: {
13928 OPC_CheckPredicate, 141, 1, // 2517: check predicate 141
13929 OPC_CheckField, 25, 1, 0, // 2520: check Inst[25] == 0x0
13930 OPC_Decode, 253, 110, 31, // 2524: decode to CV_AVGU_SC_B using decoder 31
13931 // 2524: }
13932 7, 11, // 2528: case 0x7: {
13933 OPC_CheckPredicate, 141, 1, // 2530: check predicate 141
13934 OPC_CheckField, 25, 1, 0, // 2533: check Inst[25] == 0x0
13935 OPC_Decode, 161, 111, 31, // 2537: decode to CV_CMPGE_SC_B using decoder 31
13936 // 2537: }
13937 8, 11, // 2541: case 0x8: {
13938 OPC_CheckPredicate, 141, 1, // 2543: check predicate 141
13939 OPC_CheckField, 25, 1, 0, // 2546: check Inst[25] == 0x0
13940 OPC_Decode, 174, 112, 31, // 2550: decode to CV_MIN_SC_B using decoder 31
13941 // 2550: }
13942 9, 11, // 2554: case 0x9: {
13943 OPC_CheckPredicate, 141, 1, // 2556: check predicate 141
13944 OPC_CheckField, 25, 1, 0, // 2559: check Inst[25] == 0x0
13945 OPC_Decode, 197, 111, 31, // 2563: decode to CV_CMPLT_SC_B using decoder 31
13946 // 2563: }
13947 10, 11, // 2567: case 0xa: {
13948 OPC_CheckPredicate, 141, 1, // 2569: check predicate 141
13949 OPC_CheckField, 25, 1, 0, // 2572: check Inst[25] == 0x0
13950 OPC_Decode, 168, 112, 31, // 2576: decode to CV_MINU_SC_B using decoder 31
13951 // 2576: }
13952 11, 11, // 2580: case 0xb: {
13953 OPC_CheckPredicate, 141, 1, // 2582: check predicate 141
13954 OPC_CheckField, 25, 1, 0, // 2585: check Inst[25] == 0x0
13955 OPC_Decode, 185, 111, 31, // 2589: decode to CV_CMPLE_SC_B using decoder 31
13956 // 2589: }
13957 12, 11, // 2593: case 0xc: {
13958 OPC_CheckPredicate, 141, 1, // 2595: check predicate 141
13959 OPC_CheckField, 25, 1, 0, // 2598: check Inst[25] == 0x0
13960 OPC_Decode, 160, 112, 31, // 2602: decode to CV_MAX_SC_B using decoder 31
13961 // 2602: }
13962 13, 11, // 2606: case 0xd: {
13963 OPC_CheckPredicate, 141, 1, // 2608: check predicate 141
13964 OPC_CheckField, 25, 1, 0, // 2611: check Inst[25] == 0x0
13965 OPC_Decode, 167, 111, 31, // 2615: decode to CV_CMPGTU_SC_B using decoder 31
13966 // 2615: }
13967 14, 11, // 2619: case 0xe: {
13968 OPC_CheckPredicate, 141, 1, // 2621: check predicate 141
13969 OPC_CheckField, 25, 1, 0, // 2624: check Inst[25] == 0x0
13970 OPC_Decode, 154, 112, 31, // 2628: decode to CV_MAXU_SC_B using decoder 31
13971 // 2628: }
13972 15, 11, // 2632: case 0xf: {
13973 OPC_CheckPredicate, 141, 1, // 2634: check predicate 141
13974 OPC_CheckField, 25, 1, 0, // 2637: check Inst[25] == 0x0
13975 OPC_Decode, 155, 111, 31, // 2641: decode to CV_CMPGEU_SC_B using decoder 31
13976 // 2641: }
13977 16, 11, // 2645: case 0x10: {
13978 OPC_CheckPredicate, 141, 1, // 2647: check predicate 141
13979 OPC_CheckField, 25, 1, 0, // 2650: check Inst[25] == 0x0
13980 OPC_Decode, 247, 112, 31, // 2654: decode to CV_SRL_SC_B using decoder 31
13981 // 2654: }
13982 17, 11, // 2658: case 0x11: {
13983 OPC_CheckPredicate, 141, 1, // 2660: check predicate 141
13984 OPC_CheckField, 25, 1, 0, // 2663: check Inst[25] == 0x0
13985 OPC_Decode, 191, 111, 31, // 2667: decode to CV_CMPLTU_SC_B using decoder 31
13986 // 2667: }
13987 18, 11, // 2671: case 0x12: {
13988 OPC_CheckPredicate, 141, 1, // 2673: check predicate 141
13989 OPC_CheckField, 25, 1, 0, // 2676: check Inst[25] == 0x0
13990 OPC_Decode, 241, 112, 31, // 2680: decode to CV_SRA_SC_B using decoder 31
13991 // 2680: }
13992 19, 11, // 2684: case 0x13: {
13993 OPC_CheckPredicate, 141, 1, // 2686: check predicate 141
13994 OPC_CheckField, 25, 1, 0, // 2689: check Inst[25] == 0x0
13995 OPC_Decode, 179, 111, 31, // 2693: decode to CV_CMPLEU_SC_B using decoder 31
13996 // 2693: }
13997 20, 11, // 2697: case 0x14: {
13998 OPC_CheckPredicate, 141, 1, // 2699: check predicate 141
13999 OPC_CheckField, 25, 1, 0, // 2702: check Inst[25] == 0x0
14000 OPC_Decode, 235, 112, 31, // 2706: decode to CV_SLL_SC_B using decoder 31
14001 // 2706: }
14002 22, 11, // 2710: case 0x16: {
14003 OPC_CheckPredicate, 141, 1, // 2712: check predicate 141
14004 OPC_CheckField, 25, 1, 0, // 2715: check Inst[25] == 0x0
14005 OPC_Decode, 189, 112, 31, // 2719: decode to CV_OR_SC_B using decoder 31
14006 // 2719: }
14007 24, 11, // 2723: case 0x18: {
14008 OPC_CheckPredicate, 141, 1, // 2725: check predicate 141
14009 OPC_CheckField, 25, 1, 0, // 2728: check Inst[25] == 0x0
14010 OPC_Decode, 149, 113, 31, // 2732: decode to CV_XOR_SC_B using decoder 31
14011 // 2732: }
14012 26, 11, // 2736: case 0x1a: {
14013 OPC_CheckPredicate, 141, 1, // 2738: check predicate 141
14014 OPC_CheckField, 25, 1, 0, // 2741: check Inst[25] == 0x0
14015 OPC_Decode, 247, 110, 31, // 2745: decode to CV_AND_SC_B using decoder 31
14016 // 2745: }
14017 32, 11, // 2749: case 0x20: {
14018 OPC_CheckPredicate, 141, 1, // 2751: check predicate 141
14019 OPC_CheckField, 25, 1, 0, // 2754: check Inst[25] == 0x0
14020 OPC_Decode, 225, 111, 31, // 2758: decode to CV_DOTUP_SC_B using decoder 31
14021 // 2758: }
14022 34, 11, // 2762: case 0x22: {
14023 OPC_CheckPredicate, 141, 1, // 2764: check predicate 141
14024 OPC_CheckField, 25, 1, 0, // 2767: check Inst[25] == 0x0
14025 OPC_Decode, 231, 111, 31, // 2771: decode to CV_DOTUSP_SC_B using decoder 31
14026 // 2771: }
14027 36, 11, // 2775: case 0x24: {
14028 OPC_CheckPredicate, 141, 1, // 2777: check predicate 141
14029 OPC_CheckField, 25, 1, 0, // 2780: check Inst[25] == 0x0
14030 OPC_Decode, 219, 111, 31, // 2784: decode to CV_DOTSP_SC_B using decoder 31
14031 // 2784: }
14032 38, 11, // 2788: case 0x26: {
14033 OPC_CheckPredicate, 141, 1, // 2790: check predicate 141
14034 OPC_CheckField, 25, 1, 0, // 2793: check Inst[25] == 0x0
14035 OPC_Decode, 209, 112, 59, // 2797: decode to CV_SDOTUP_SC_B using decoder 59
14036 // 2797: }
14037 40, 11, // 2801: case 0x28: {
14038 OPC_CheckPredicate, 141, 1, // 2803: check predicate 141
14039 OPC_CheckField, 25, 1, 0, // 2806: check Inst[25] == 0x0
14040 OPC_Decode, 215, 112, 59, // 2810: decode to CV_SDOTUSP_SC_B using decoder 59
14041 // 2810: }
14042 42, 11, // 2814: case 0x2a: {
14043 OPC_CheckPredicate, 141, 1, // 2816: check predicate 141
14044 OPC_CheckField, 25, 1, 0, // 2819: check Inst[25] == 0x0
14045 OPC_Decode, 203, 112, 59, // 2823: decode to CV_SDOTSP_SC_B using decoder 59
14046 // 2823: }
14047 46, 0, // 2827: case 0x2e: {
14048 OPC_CheckPredicate, 141, 1, // 2829: check predicate 141
14049 OPC_Decode, 250, 111, 221, 1, // 2832: decode to CV_INSERT_B using decoder 221
14050 // 2832: }
14051 // 2832: } // switch Inst[31:26]
14052 // 2832: }
14053 // 2832: } // switch Inst[6:0]
14054 // 2832: }
14055 6, 179, 3, // 2837: case 0x6: {
14056 OPC_SwitchField, 0, 7, // 2840: switch Inst[6:0] {
14057 11, 8, // 2843: case 0xb: {
14058 OPC_CheckPredicate, 145, 1, // 2845: check predicate 145
14059 OPC_Decode, 135, 111, 222, 1, // 2848: decode to CV_BEQIMM using decoder 222
14060 // 2848: }
14061 91, 43, // 2853: case 0x5b: {
14062 OPC_SwitchField, 30, 2, // 2855: switch Inst[31:30] {
14063 0, 8, // 2858: case 0x0: {
14064 OPC_CheckPredicate, 144, 1, // 2860: check predicate 144
14065 OPC_Decode, 144, 112, 223, 1, // 2863: decode to CV_MACSN using decoder 223
14066 // 2863: }
14067 1, 8, // 2868: case 0x1: {
14068 OPC_CheckPredicate, 144, 1, // 2870: check predicate 144
14069 OPC_Decode, 140, 112, 223, 1, // 2873: decode to CV_MACHHSN using decoder 223
14070 // 2873: }
14071 2, 8, // 2878: case 0x2: {
14072 OPC_CheckPredicate, 144, 1, // 2880: check predicate 144
14073 OPC_Decode, 145, 112, 223, 1, // 2883: decode to CV_MACSRN using decoder 223
14074 // 2883: }
14075 3, 0, // 2888: case 0x3: {
14076 OPC_CheckPredicate, 144, 1, // 2890: check predicate 144
14077 OPC_Decode, 141, 112, 223, 1, // 2893: decode to CV_MACHHSRN using decoder 223
14078 // 2893: }
14079 // 2893: } // switch Inst[31:30]
14080 // 2893: }
14081 123, 0, // 2898: case 0x7b: {
14082 OPC_SwitchField, 26, 6, // 2900: switch Inst[31:26] {
14083 0, 8, // 2903: case 0x0: {
14084 OPC_CheckPredicate, 141, 1, // 2905: check predicate 141
14085 OPC_Decode, 240, 110, 224, 1, // 2908: decode to CV_ADD_SCI_H using decoder 224
14086 // 2908: }
14087 1, 8, // 2913: case 0x1: {
14088 OPC_CheckPredicate, 141, 1, // 2915: check predicate 141
14089 OPC_Decode, 148, 111, 224, 1, // 2918: decode to CV_CMPEQ_SCI_H using decoder 224
14090 // 2918: }
14091 2, 8, // 2923: case 0x2: {
14092 OPC_CheckPredicate, 141, 1, // 2925: check predicate 141
14093 OPC_Decode, 139, 113, 224, 1, // 2928: decode to CV_SUB_SCI_H using decoder 224
14094 // 2928: }
14095 3, 8, // 2933: case 0x3: {
14096 OPC_CheckPredicate, 141, 1, // 2935: check predicate 141
14097 OPC_Decode, 202, 111, 224, 1, // 2938: decode to CV_CMPNE_SCI_H using decoder 224
14098 // 2938: }
14099 4, 8, // 2943: case 0x4: {
14100 OPC_CheckPredicate, 141, 1, // 2945: check predicate 141
14101 OPC_Decode, 130, 111, 224, 1, // 2948: decode to CV_AVG_SCI_H using decoder 224
14102 // 2948: }
14103 5, 8, // 2953: case 0x5: {
14104 OPC_CheckPredicate, 141, 1, // 2955: check predicate 141
14105 OPC_Decode, 172, 111, 224, 1, // 2958: decode to CV_CMPGT_SCI_H using decoder 224
14106 // 2958: }
14107 6, 8, // 2963: case 0x6: {
14108 OPC_CheckPredicate, 141, 1, // 2965: check predicate 141
14109 OPC_Decode, 252, 110, 215, 1, // 2968: decode to CV_AVGU_SCI_H using decoder 215
14110 // 2968: }
14111 7, 8, // 2973: case 0x7: {
14112 OPC_CheckPredicate, 141, 1, // 2975: check predicate 141
14113 OPC_Decode, 160, 111, 224, 1, // 2978: decode to CV_CMPGE_SCI_H using decoder 224
14114 // 2978: }
14115 8, 8, // 2983: case 0x8: {
14116 OPC_CheckPredicate, 141, 1, // 2985: check predicate 141
14117 OPC_Decode, 173, 112, 224, 1, // 2988: decode to CV_MIN_SCI_H using decoder 224
14118 // 2988: }
14119 9, 8, // 2993: case 0x9: {
14120 OPC_CheckPredicate, 141, 1, // 2995: check predicate 141
14121 OPC_Decode, 196, 111, 224, 1, // 2998: decode to CV_CMPLT_SCI_H using decoder 224
14122 // 2998: }
14123 10, 8, // 3003: case 0xa: {
14124 OPC_CheckPredicate, 141, 1, // 3005: check predicate 141
14125 OPC_Decode, 167, 112, 215, 1, // 3008: decode to CV_MINU_SCI_H using decoder 215
14126 // 3008: }
14127 11, 8, // 3013: case 0xb: {
14128 OPC_CheckPredicate, 141, 1, // 3015: check predicate 141
14129 OPC_Decode, 184, 111, 224, 1, // 3018: decode to CV_CMPLE_SCI_H using decoder 224
14130 // 3018: }
14131 12, 8, // 3023: case 0xc: {
14132 OPC_CheckPredicate, 141, 1, // 3025: check predicate 141
14133 OPC_Decode, 159, 112, 224, 1, // 3028: decode to CV_MAX_SCI_H using decoder 224
14134 // 3028: }
14135 13, 8, // 3033: case 0xd: {
14136 OPC_CheckPredicate, 141, 1, // 3035: check predicate 141
14137 OPC_Decode, 166, 111, 215, 1, // 3038: decode to CV_CMPGTU_SCI_H using decoder 215
14138 // 3038: }
14139 14, 8, // 3043: case 0xe: {
14140 OPC_CheckPredicate, 141, 1, // 3045: check predicate 141
14141 OPC_Decode, 153, 112, 215, 1, // 3048: decode to CV_MAXU_SCI_H using decoder 215
14142 // 3048: }
14143 15, 8, // 3053: case 0xf: {
14144 OPC_CheckPredicate, 141, 1, // 3055: check predicate 141
14145 OPC_Decode, 154, 111, 215, 1, // 3058: decode to CV_CMPGEU_SCI_H using decoder 215
14146 // 3058: }
14147 16, 8, // 3063: case 0x10: {
14148 OPC_CheckPredicate, 141, 1, // 3065: check predicate 141
14149 OPC_Decode, 246, 112, 225, 1, // 3068: decode to CV_SRL_SCI_H using decoder 225
14150 // 3068: }
14151 17, 8, // 3073: case 0x11: {
14152 OPC_CheckPredicate, 141, 1, // 3075: check predicate 141
14153 OPC_Decode, 190, 111, 215, 1, // 3078: decode to CV_CMPLTU_SCI_H using decoder 215
14154 // 3078: }
14155 18, 8, // 3083: case 0x12: {
14156 OPC_CheckPredicate, 141, 1, // 3085: check predicate 141
14157 OPC_Decode, 240, 112, 225, 1, // 3088: decode to CV_SRA_SCI_H using decoder 225
14158 // 3088: }
14159 19, 8, // 3093: case 0x13: {
14160 OPC_CheckPredicate, 141, 1, // 3095: check predicate 141
14161 OPC_Decode, 178, 111, 215, 1, // 3098: decode to CV_CMPLEU_SCI_H using decoder 215
14162 // 3098: }
14163 20, 8, // 3103: case 0x14: {
14164 OPC_CheckPredicate, 141, 1, // 3105: check predicate 141
14165 OPC_Decode, 234, 112, 225, 1, // 3108: decode to CV_SLL_SCI_H using decoder 225
14166 // 3108: }
14167 21, 21, // 3113: case 0x15: {
14168 OPC_SwitchField, 25, 1, // 3115: switch Inst[25] {
14169 0, 7, // 3118: case 0x0: {
14170 OPC_CheckPredicate, 141, 1, // 3120: check predicate 141
14171 OPC_Decode, 214, 111, 59, // 3123: decode to CV_CPLXMUL_R_DIV8 using decoder 59
14172 // 3123: }
14173 1, 0, // 3127: case 0x1: {
14174 OPC_CheckPredicate, 141, 1, // 3129: check predicate 141
14175 OPC_Decode, 210, 111, 59, // 3132: decode to CV_CPLXMUL_I_DIV8 using decoder 59
14176 // 3132: }
14177 // 3132: } // switch Inst[25]
14178 // 3132: }
14179 22, 8, // 3136: case 0x16: {
14180 OPC_CheckPredicate, 141, 1, // 3138: check predicate 141
14181 OPC_Decode, 188, 112, 224, 1, // 3141: decode to CV_OR_SCI_H using decoder 224
14182 // 3141: }
14183 24, 8, // 3146: case 0x18: {
14184 OPC_CheckPredicate, 141, 1, // 3148: check predicate 141
14185 OPC_Decode, 148, 113, 224, 1, // 3151: decode to CV_XOR_SCI_H using decoder 224
14186 // 3151: }
14187 25, 11, // 3156: case 0x19: {
14188 OPC_CheckPredicate, 141, 1, // 3158: check predicate 141
14189 OPC_CheckField, 25, 1, 0, // 3161: check Inst[25] == 0x0
14190 OPC_Decode, 128, 113, 31, // 3165: decode to CV_SUBROTMJ_DIV8 using decoder 31
14191 // 3165: }
14192 26, 8, // 3169: case 0x1a: {
14193 OPC_CheckPredicate, 141, 1, // 3171: check predicate 141
14194 OPC_Decode, 246, 110, 224, 1, // 3174: decode to CV_AND_SCI_H using decoder 224
14195 // 3174: }
14196 27, 11, // 3179: case 0x1b: {
14197 OPC_CheckPredicate, 141, 1, // 3181: check predicate 141
14198 OPC_CheckField, 25, 1, 0, // 3184: check Inst[25] == 0x0
14199 OPC_Decode, 237, 110, 31, // 3188: decode to CV_ADD_DIV8 using decoder 31
14200 // 3188: }
14201 29, 11, // 3192: case 0x1d: {
14202 OPC_CheckPredicate, 141, 1, // 3194: check predicate 141
14203 OPC_CheckField, 25, 1, 0, // 3197: check Inst[25] == 0x0
14204 OPC_Decode, 136, 113, 31, // 3201: decode to CV_SUB_DIV8 using decoder 31
14205 // 3201: }
14206 32, 8, // 3205: case 0x20: {
14207 OPC_CheckPredicate, 141, 1, // 3207: check predicate 141
14208 OPC_Decode, 224, 111, 215, 1, // 3210: decode to CV_DOTUP_SCI_H using decoder 215
14209 // 3210: }
14210 34, 8, // 3215: case 0x22: {
14211 OPC_CheckPredicate, 141, 1, // 3217: check predicate 141
14212 OPC_Decode, 230, 111, 224, 1, // 3220: decode to CV_DOTUSP_SCI_H using decoder 224
14213 // 3220: }
14214 36, 8, // 3225: case 0x24: {
14215 OPC_CheckPredicate, 141, 1, // 3227: check predicate 141
14216 OPC_Decode, 218, 111, 224, 1, // 3230: decode to CV_DOTSP_SCI_H using decoder 224
14217 // 3230: }
14218 38, 8, // 3235: case 0x26: {
14219 OPC_CheckPredicate, 141, 1, // 3237: check predicate 141
14220 OPC_Decode, 208, 112, 221, 1, // 3240: decode to CV_SDOTUP_SCI_H using decoder 221
14221 // 3240: }
14222 40, 8, // 3245: case 0x28: {
14223 OPC_CheckPredicate, 141, 1, // 3247: check predicate 141
14224 OPC_Decode, 214, 112, 226, 1, // 3250: decode to CV_SDOTUSP_SCI_H using decoder 226
14225 // 3250: }
14226 42, 8, // 3255: case 0x2a: {
14227 OPC_CheckPredicate, 141, 1, // 3257: check predicate 141
14228 OPC_Decode, 202, 112, 226, 1, // 3260: decode to CV_SDOTSP_SCI_H using decoder 226
14229 // 3260: }
14230 48, 0, // 3265: case 0x30: {
14231 OPC_CheckPredicate, 141, 1, // 3267: check predicate 141
14232 OPC_Decode, 225, 112, 215, 1, // 3270: decode to CV_SHUFFLE_SCI_H using decoder 215
14233 // 3270: }
14234 // 3270: } // switch Inst[31:26]
14235 // 3270: }
14236 // 3270: } // switch Inst[6:0]
14237 // 3270: }
14238 7, 0, // 3275: case 0x7: {
14239 OPC_SwitchField, 0, 7, // 3277: switch Inst[6:0] {
14240 11, 8, // 3280: case 0xb: {
14241 OPC_CheckPredicate, 145, 1, // 3282: check predicate 145
14242 OPC_Decode, 137, 111, 222, 1, // 3285: decode to CV_BNEIMM using decoder 222
14243 // 3285: }
14244 91, 43, // 3290: case 0x5b: {
14245 OPC_SwitchField, 30, 2, // 3292: switch Inst[31:30] {
14246 0, 8, // 3295: case 0x0: {
14247 OPC_CheckPredicate, 144, 1, // 3297: check predicate 144
14248 OPC_Decode, 146, 112, 223, 1, // 3300: decode to CV_MACUN using decoder 223
14249 // 3300: }
14250 1, 8, // 3305: case 0x1: {
14251 OPC_CheckPredicate, 144, 1, // 3307: check predicate 144
14252 OPC_Decode, 142, 112, 223, 1, // 3310: decode to CV_MACHHUN using decoder 223
14253 // 3310: }
14254 2, 8, // 3315: case 0x2: {
14255 OPC_CheckPredicate, 144, 1, // 3317: check predicate 144
14256 OPC_Decode, 147, 112, 223, 1, // 3320: decode to CV_MACURN using decoder 223
14257 // 3320: }
14258 3, 0, // 3325: case 0x3: {
14259 OPC_CheckPredicate, 144, 1, // 3327: check predicate 144
14260 OPC_Decode, 143, 112, 223, 1, // 3330: decode to CV_MACHHURN using decoder 223
14261 // 3330: }
14262 // 3330: } // switch Inst[31:30]
14263 // 3330: }
14264 123, 0, // 3335: case 0x7b: {
14265 OPC_SwitchField, 26, 6, // 3337: switch Inst[31:26] {
14266 0, 8, // 3340: case 0x0: {
14267 OPC_CheckPredicate, 141, 1, // 3342: check predicate 141
14268 OPC_Decode, 239, 110, 224, 1, // 3345: decode to CV_ADD_SCI_B using decoder 224
14269 // 3345: }
14270 1, 8, // 3350: case 0x1: {
14271 OPC_CheckPredicate, 141, 1, // 3352: check predicate 141
14272 OPC_Decode, 147, 111, 224, 1, // 3355: decode to CV_CMPEQ_SCI_B using decoder 224
14273 // 3355: }
14274 2, 8, // 3360: case 0x2: {
14275 OPC_CheckPredicate, 141, 1, // 3362: check predicate 141
14276 OPC_Decode, 138, 113, 224, 1, // 3365: decode to CV_SUB_SCI_B using decoder 224
14277 // 3365: }
14278 3, 8, // 3370: case 0x3: {
14279 OPC_CheckPredicate, 141, 1, // 3372: check predicate 141
14280 OPC_Decode, 201, 111, 224, 1, // 3375: decode to CV_CMPNE_SCI_B using decoder 224
14281 // 3375: }
14282 4, 8, // 3380: case 0x4: {
14283 OPC_CheckPredicate, 141, 1, // 3382: check predicate 141
14284 OPC_Decode, 129, 111, 224, 1, // 3385: decode to CV_AVG_SCI_B using decoder 224
14285 // 3385: }
14286 5, 8, // 3390: case 0x5: {
14287 OPC_CheckPredicate, 141, 1, // 3392: check predicate 141
14288 OPC_Decode, 171, 111, 224, 1, // 3395: decode to CV_CMPGT_SCI_B using decoder 224
14289 // 3395: }
14290 6, 8, // 3400: case 0x6: {
14291 OPC_CheckPredicate, 141, 1, // 3402: check predicate 141
14292 OPC_Decode, 251, 110, 215, 1, // 3405: decode to CV_AVGU_SCI_B using decoder 215
14293 // 3405: }
14294 7, 8, // 3410: case 0x7: {
14295 OPC_CheckPredicate, 141, 1, // 3412: check predicate 141
14296 OPC_Decode, 159, 111, 224, 1, // 3415: decode to CV_CMPGE_SCI_B using decoder 224
14297 // 3415: }
14298 8, 8, // 3420: case 0x8: {
14299 OPC_CheckPredicate, 141, 1, // 3422: check predicate 141
14300 OPC_Decode, 172, 112, 224, 1, // 3425: decode to CV_MIN_SCI_B using decoder 224
14301 // 3425: }
14302 9, 8, // 3430: case 0x9: {
14303 OPC_CheckPredicate, 141, 1, // 3432: check predicate 141
14304 OPC_Decode, 195, 111, 224, 1, // 3435: decode to CV_CMPLT_SCI_B using decoder 224
14305 // 3435: }
14306 10, 8, // 3440: case 0xa: {
14307 OPC_CheckPredicate, 141, 1, // 3442: check predicate 141
14308 OPC_Decode, 166, 112, 215, 1, // 3445: decode to CV_MINU_SCI_B using decoder 215
14309 // 3445: }
14310 11, 8, // 3450: case 0xb: {
14311 OPC_CheckPredicate, 141, 1, // 3452: check predicate 141
14312 OPC_Decode, 183, 111, 224, 1, // 3455: decode to CV_CMPLE_SCI_B using decoder 224
14313 // 3455: }
14314 12, 8, // 3460: case 0xc: {
14315 OPC_CheckPredicate, 141, 1, // 3462: check predicate 141
14316 OPC_Decode, 158, 112, 224, 1, // 3465: decode to CV_MAX_SCI_B using decoder 224
14317 // 3465: }
14318 13, 8, // 3470: case 0xd: {
14319 OPC_CheckPredicate, 141, 1, // 3472: check predicate 141
14320 OPC_Decode, 165, 111, 215, 1, // 3475: decode to CV_CMPGTU_SCI_B using decoder 215
14321 // 3475: }
14322 14, 8, // 3480: case 0xe: {
14323 OPC_CheckPredicate, 141, 1, // 3482: check predicate 141
14324 OPC_Decode, 152, 112, 215, 1, // 3485: decode to CV_MAXU_SCI_B using decoder 215
14325 // 3485: }
14326 15, 8, // 3490: case 0xf: {
14327 OPC_CheckPredicate, 141, 1, // 3492: check predicate 141
14328 OPC_Decode, 153, 111, 215, 1, // 3495: decode to CV_CMPGEU_SCI_B using decoder 215
14329 // 3495: }
14330 16, 8, // 3500: case 0x10: {
14331 OPC_CheckPredicate, 141, 1, // 3502: check predicate 141
14332 OPC_Decode, 245, 112, 227, 1, // 3505: decode to CV_SRL_SCI_B using decoder 227
14333 // 3505: }
14334 17, 8, // 3510: case 0x11: {
14335 OPC_CheckPredicate, 141, 1, // 3512: check predicate 141
14336 OPC_Decode, 189, 111, 215, 1, // 3515: decode to CV_CMPLTU_SCI_B using decoder 215
14337 // 3515: }
14338 18, 8, // 3520: case 0x12: {
14339 OPC_CheckPredicate, 141, 1, // 3522: check predicate 141
14340 OPC_Decode, 239, 112, 227, 1, // 3525: decode to CV_SRA_SCI_B using decoder 227
14341 // 3525: }
14342 19, 8, // 3530: case 0x13: {
14343 OPC_CheckPredicate, 141, 1, // 3532: check predicate 141
14344 OPC_Decode, 177, 111, 215, 1, // 3535: decode to CV_CMPLEU_SCI_B using decoder 215
14345 // 3535: }
14346 20, 8, // 3540: case 0x14: {
14347 OPC_CheckPredicate, 141, 1, // 3542: check predicate 141
14348 OPC_Decode, 233, 112, 227, 1, // 3545: decode to CV_SLL_SCI_B using decoder 227
14349 // 3545: }
14350 22, 8, // 3550: case 0x16: {
14351 OPC_CheckPredicate, 141, 1, // 3552: check predicate 141
14352 OPC_Decode, 187, 112, 224, 1, // 3555: decode to CV_OR_SCI_B using decoder 224
14353 // 3555: }
14354 24, 8, // 3560: case 0x18: {
14355 OPC_CheckPredicate, 141, 1, // 3562: check predicate 141
14356 OPC_Decode, 147, 113, 224, 1, // 3565: decode to CV_XOR_SCI_B using decoder 224
14357 // 3565: }
14358 26, 8, // 3570: case 0x1a: {
14359 OPC_CheckPredicate, 141, 1, // 3572: check predicate 141
14360 OPC_Decode, 245, 110, 224, 1, // 3575: decode to CV_AND_SCI_B using decoder 224
14361 // 3575: }
14362 32, 8, // 3580: case 0x20: {
14363 OPC_CheckPredicate, 141, 1, // 3582: check predicate 141
14364 OPC_Decode, 223, 111, 215, 1, // 3585: decode to CV_DOTUP_SCI_B using decoder 215
14365 // 3585: }
14366 34, 8, // 3590: case 0x22: {
14367 OPC_CheckPredicate, 141, 1, // 3592: check predicate 141
14368 OPC_Decode, 229, 111, 224, 1, // 3595: decode to CV_DOTUSP_SCI_B using decoder 224
14369 // 3595: }
14370 36, 8, // 3600: case 0x24: {
14371 OPC_CheckPredicate, 141, 1, // 3602: check predicate 141
14372 OPC_Decode, 217, 111, 224, 1, // 3605: decode to CV_DOTSP_SCI_B using decoder 224
14373 // 3605: }
14374 38, 8, // 3610: case 0x26: {
14375 OPC_CheckPredicate, 141, 1, // 3612: check predicate 141
14376 OPC_Decode, 207, 112, 221, 1, // 3615: decode to CV_SDOTUP_SCI_B using decoder 221
14377 // 3615: }
14378 40, 8, // 3620: case 0x28: {
14379 OPC_CheckPredicate, 141, 1, // 3622: check predicate 141
14380 OPC_Decode, 213, 112, 226, 1, // 3625: decode to CV_SDOTUSP_SCI_B using decoder 226
14381 // 3625: }
14382 42, 8, // 3630: case 0x2a: {
14383 OPC_CheckPredicate, 141, 1, // 3632: check predicate 141
14384 OPC_Decode, 201, 112, 226, 1, // 3635: decode to CV_SDOTSP_SCI_B using decoder 226
14385 // 3635: }
14386 48, 8, // 3640: case 0x30: {
14387 OPC_CheckPredicate, 141, 1, // 3642: check predicate 141
14388 OPC_Decode, 219, 112, 215, 1, // 3645: decode to CV_SHUFFLEI0_SCI_B using decoder 215
14389 // 3645: }
14390 50, 8, // 3650: case 0x32: {
14391 OPC_CheckPredicate, 141, 1, // 3652: check predicate 141
14392 OPC_Decode, 220, 112, 215, 1, // 3655: decode to CV_SHUFFLEI1_SCI_B using decoder 215
14393 // 3655: }
14394 52, 8, // 3660: case 0x34: {
14395 OPC_CheckPredicate, 141, 1, // 3662: check predicate 141
14396 OPC_Decode, 221, 112, 215, 1, // 3665: decode to CV_SHUFFLEI2_SCI_B using decoder 215
14397 // 3665: }
14398 54, 0, // 3670: case 0x36: {
14399 OPC_CheckPredicate, 141, 1, // 3672: check predicate 141
14400 OPC_Decode, 222, 112, 215, 1, // 3675: decode to CV_SHUFFLEI3_SCI_B using decoder 215
14401 // 3675: }
14402 // 3675: } // switch Inst[31:26]
14403 // 3675: }
14404 // 3675: } // switch Inst[6:0]
14405 // 3675: }
14406 // 3675: } // switch Inst[14:12]
14407};
14408static const uint8_t DecoderTableXMIPS32[152] = {
14409 32, // 0: BitWidth 32
14410 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
14411 0, 16, // 4: case 0x0: {
14412 OPC_CheckPredicate, 146, 1, // 6: check predicate 146
14413 OPC_CheckField, 29, 3, 0, // 9: check Inst[31:29] == 0x0
14414 OPC_CheckField, 0, 7, 11, // 13: check Inst[6:0] == 0xb
14415 OPC_Decode, 237, 116, 228, 1, // 17: decode to MIPS_PREF using decoder 228
14416 // 17: }
14417 1, 43, // 22: case 0x1: {
14418 OPC_SwitchField, 15, 17, // 24: switch Inst[31:15] {
14419 32, 11, // 27: case 0x20: {
14420 OPC_CheckPredicate, 147, 1, // 29: check predicate 147
14421 OPC_CheckField, 0, 12, 19, // 32: check Inst[11:0] == 0x13
14422 OPC_Decode, 233, 116, 14, // 36: decode to MIPS_IHB using decoder 14
14423 // 36: }
14424 96, 11, // 40: case 0x60: {
14425 OPC_CheckPredicate, 147, 1, // 42: check predicate 147
14426 OPC_CheckField, 0, 12, 19, // 45: check Inst[11:0] == 0x13
14427 OPC_Decode, 232, 116, 14, // 49: decode to MIPS_EHB using decoder 14
14428 // 49: }
14429 160, 1, 0, // 53: case 0xa0: {
14430 OPC_CheckPredicate, 147, 1, // 56: check predicate 147
14431 OPC_CheckField, 0, 12, 19, // 59: check Inst[11:0] == 0x13
14432 OPC_Decode, 236, 116, 14, // 63: decode to MIPS_PAUSE using decoder 14
14433 // 63: }
14434 // 63: } // switch Inst[31:15]
14435 // 63: }
14436 3, 16, // 67: case 0x3: {
14437 OPC_CheckPredicate, 148, 1, // 69: check predicate 148
14438 OPC_CheckField, 25, 2, 3, // 72: check Inst[26:25] == 0x3
14439 OPC_CheckField, 0, 7, 11, // 76: check Inst[6:0] == 0xb
14440 OPC_Decode, 231, 116, 229, 1, // 80: decode to MIPS_CCMOV using decoder 229
14441 // 80: }
14442 4, 35, // 85: case 0x4: {
14443 OPC_SwitchField, 20, 2, // 87: switch Inst[21:20] {
14444 0, 16, // 90: case 0x0: {
14445 OPC_CheckPredicate, 149, 1, // 92: check predicate 149
14446 OPC_CheckField, 22, 1, 0, // 95: check Inst[22] == 0x0
14447 OPC_CheckField, 0, 7, 11, // 99: check Inst[6:0] == 0xb
14448 OPC_Decode, 234, 116, 230, 1, // 103: decode to MIPS_LDP using decoder 230
14449 // 103: }
14450 1, 0, // 108: case 0x1: {
14451 OPC_CheckPredicate, 149, 1, // 110: check predicate 149
14452 OPC_CheckField, 0, 7, 11, // 113: check Inst[6:0] == 0xb
14453 OPC_Decode, 235, 116, 231, 1, // 117: decode to MIPS_LWP using decoder 231
14454 // 117: }
14455 // 117: } // switch Inst[21:20]
14456 // 117: }
14457 5, 0, // 122: case 0x5: {
14458 OPC_SwitchField, 0, 9, // 124: switch Inst[8:0] {
14459 11, 12, // 127: case 0xb: {
14460 OPC_CheckPredicate, 149, 1, // 129: check predicate 149
14461 OPC_CheckField, 9, 1, 0, // 132: check Inst[9] == 0x0
14462 OPC_Decode, 238, 116, 232, 1, // 136: decode to MIPS_SDP using decoder 232
14463 // 136: }
14464 139, 1, 0, // 141: case 0x8b: {
14465 OPC_CheckPredicate, 149, 1, // 144: check predicate 149
14466 OPC_Decode, 239, 116, 233, 1, // 147: decode to MIPS_SWP using decoder 233
14467 // 147: }
14468 // 147: } // switch Inst[8:0]
14469 // 147: }
14470 // 147: } // switch Inst[14:12]
14471};
14472static const uint8_t DecoderTableXSMT32[994] = {
14473 32, // 0: BitWidth 32
14474 OPC_SwitchField, 26, 3, // 1: switch Inst[28:26] {
14475 0, 232, 1, // 4: case 0x0: {
14476 OPC_SwitchField, 14, 1, // 7: switch Inst[14] {
14477 0, 183, 1, // 10: case 0x0: {
14478 OPC_SwitchField, 31, 1, // 13: switch Inst[31] {
14479 0, 41, // 16: case 0x0: {
14480 OPC_SwitchField, 29, 2, // 18: switch Inst[30:29] {
14481 2, 17, // 21: case 0x2: {
14482 OPC_CheckPredicate, 150, 1, // 23: check predicate 150
14483 OPC_CheckField, 25, 1, 1, // 26: check Inst[25] == 0x1
14484 OPC_CheckField, 0, 7, 43, // 30: check Inst[6:0] == 0x2b
14485 OPC_Decode, 167, 129, 1, 234, 1, // 34: decode to VNPACK4_VV using decoder 234
14486 // 34: }
14487 3, 0, // 40: case 0x3: {
14488 OPC_CheckPredicate, 150, 1, // 42: check predicate 150
14489 OPC_CheckField, 25, 1, 1, // 45: check Inst[25] == 0x1
14490 OPC_CheckField, 0, 7, 43, // 49: check Inst[6:0] == 0x2b
14491 OPC_Decode, 168, 129, 1, 234, 1, // 53: decode to VNPACK_VV using decoder 234
14492 // 53: }
14493 // 53: } // switch Inst[30:29]
14494 // 53: }
14495 1, 0, // 59: case 0x1: {
14496 OPC_SwitchField, 12, 2, // 61: switch Inst[13:12] {
14497 0, 31, // 64: case 0x0: {
14498 OPC_CheckField, 0, 7, 43, // 66: check Inst[6:0] == 0x2b
14499 OPC_CheckField, 25, 1, 1, // 70: check Inst[25] == 0x1
14500 OPC_Scope, 12, // 74: try {
14501 OPC_CheckField, 29, 2, 3, // 76: check Inst[30:29] == 0x3
14502 OPC_CheckPredicate, 151, 1, // 80: check predicate 151
14503 OPC_Decode, 168, 124, 235, 1, // 83: decode to SMT_VMADOTU using decoder 235
14504 // 83: } else try {
14505 OPC_CheckPredicate, 150, 1, // 88: check predicate 150
14506 OPC_Decode, 199, 128, 1, 236, 1, // 91: decode to VMADOTU using decoder 236
14507 // 91: }
14508 // 91: }
14509 1, 31, // 97: case 0x1: {
14510 OPC_CheckField, 0, 7, 43, // 99: check Inst[6:0] == 0x2b
14511 OPC_CheckField, 25, 1, 1, // 103: check Inst[25] == 0x1
14512 OPC_Scope, 12, // 107: try {
14513 OPC_CheckField, 29, 2, 3, // 109: check Inst[30:29] == 0x3
14514 OPC_CheckPredicate, 151, 1, // 113: check predicate 151
14515 OPC_Decode, 169, 124, 235, 1, // 116: decode to SMT_VMADOTUS using decoder 235
14516 // 116: } else try {
14517 OPC_CheckPredicate, 150, 1, // 121: check predicate 150
14518 OPC_Decode, 200, 128, 1, 236, 1, // 124: decode to VMADOTUS using decoder 236
14519 // 124: }
14520 // 124: }
14521 2, 31, // 130: case 0x2: {
14522 OPC_CheckField, 0, 7, 43, // 132: check Inst[6:0] == 0x2b
14523 OPC_CheckField, 25, 1, 1, // 136: check Inst[25] == 0x1
14524 OPC_Scope, 12, // 140: try {
14525 OPC_CheckField, 29, 2, 3, // 142: check Inst[30:29] == 0x3
14526 OPC_CheckPredicate, 151, 1, // 146: check predicate 151
14527 OPC_Decode, 167, 124, 235, 1, // 149: decode to SMT_VMADOTSU using decoder 235
14528 // 149: } else try {
14529 OPC_CheckPredicate, 150, 1, // 154: check predicate 150
14530 OPC_Decode, 196, 128, 1, 236, 1, // 157: decode to VMADOTSU using decoder 236
14531 // 157: }
14532 // 157: }
14533 3, 0, // 163: case 0x3: {
14534 OPC_CheckField, 0, 7, 43, // 165: check Inst[6:0] == 0x2b
14535 OPC_CheckField, 25, 1, 1, // 169: check Inst[25] == 0x1
14536 OPC_Scope, 12, // 173: try {
14537 OPC_CheckField, 29, 2, 3, // 175: check Inst[30:29] == 0x3
14538 OPC_CheckPredicate, 151, 1, // 179: check predicate 151
14539 OPC_Decode, 154, 124, 235, 1, // 182: decode to SMT_VMADOT using decoder 235
14540 // 182: } else try {
14541 OPC_CheckPredicate, 150, 1, // 187: check predicate 150
14542 OPC_Decode, 183, 128, 1, 236, 1, // 190: decode to VMADOT using decoder 236
14543 // 190: }
14544 // 190: }
14545 // 190: } // switch Inst[13:12]
14546 // 190: }
14547 // 190: } // switch Inst[31]
14548 // 190: }
14549 1, 0, // 196: case 0x1: {
14550 OPC_SwitchField, 29, 3, // 198: switch Inst[31:29] {
14551 2, 17, // 201: case 0x2: {
14552 OPC_CheckPredicate, 150, 1, // 203: check predicate 150
14553 OPC_CheckField, 25, 1, 1, // 206: check Inst[25] == 0x1
14554 OPC_CheckField, 0, 7, 43, // 210: check Inst[6:0] == 0x2b
14555 OPC_Decode, 169, 129, 1, 234, 1, // 214: decode to VNSPACK4_VV using decoder 234
14556 // 214: }
14557 3, 0, // 220: case 0x3: {
14558 OPC_CheckPredicate, 150, 1, // 222: check predicate 150
14559 OPC_CheckField, 25, 1, 1, // 225: check Inst[25] == 0x1
14560 OPC_CheckField, 0, 7, 43, // 229: check Inst[6:0] == 0x2b
14561 OPC_Decode, 170, 129, 1, 234, 1, // 233: decode to VNSPACK_VV using decoder 234
14562 // 233: }
14563 // 233: } // switch Inst[31:29]
14564 // 233: }
14565 // 233: } // switch Inst[14]
14566 // 233: }
14567 1, 246, 3, // 239: case 0x1: {
14568 OPC_SwitchField, 14, 1, // 242: switch Inst[14] {
14569 0, 187, 2, // 245: case 0x0: {
14570 OPC_SwitchField, 31, 1, // 248: switch Inst[31] {
14571 0, 21, // 251: case 0x0: {
14572 OPC_CheckPredicate, 150, 1, // 253: check predicate 150
14573 OPC_CheckField, 29, 2, 3, // 256: check Inst[30:29] == 0x3
14574 OPC_CheckField, 25, 1, 1, // 260: check Inst[25] == 0x1
14575 OPC_CheckField, 0, 7, 43, // 264: check Inst[6:0] == 0x2b
14576 OPC_Decode, 180, 129, 1, 237, 1, // 268: decode to VPACK_VV using decoder 237
14577 // 268: }
14578 1, 0, // 274: case 0x1: {
14579 OPC_SwitchField, 12, 2, // 276: switch Inst[13:12] {
14580 0, 69, // 279: case 0x0: {
14581 OPC_SwitchField, 15, 1, // 281: switch Inst[15] {
14582 0, 31, // 284: case 0x0: {
14583 OPC_CheckField, 0, 7, 43, // 286: check Inst[6:0] == 0x2b
14584 OPC_CheckField, 25, 1, 1, // 290: check Inst[25] == 0x1
14585 OPC_Scope, 12, // 294: try {
14586 OPC_CheckField, 29, 2, 3, // 296: check Inst[30:29] == 0x3
14587 OPC_CheckPredicate, 151, 1, // 300: check predicate 151
14588 OPC_Decode, 157, 124, 238, 1, // 303: decode to SMT_VMADOT1U using decoder 238
14589 // 303: } else try {
14590 OPC_CheckPredicate, 150, 1, // 308: check predicate 150
14591 OPC_Decode, 186, 128, 1, 239, 1, // 311: decode to VMADOT1U using decoder 239
14592 // 311: }
14593 // 311: }
14594 1, 0, // 317: case 0x1: {
14595 OPC_CheckField, 0, 7, 43, // 319: check Inst[6:0] == 0x2b
14596 OPC_CheckField, 25, 1, 1, // 323: check Inst[25] == 0x1
14597 OPC_Scope, 12, // 327: try {
14598 OPC_CheckField, 29, 2, 3, // 329: check Inst[30:29] == 0x3
14599 OPC_CheckPredicate, 151, 1, // 333: check predicate 151
14600 OPC_Decode, 165, 124, 238, 1, // 336: decode to SMT_VMADOT3U using decoder 238
14601 // 336: } else try {
14602 OPC_CheckPredicate, 150, 1, // 341: check predicate 150
14603 OPC_Decode, 194, 128, 1, 239, 1, // 344: decode to VMADOT3U using decoder 239
14604 // 344: }
14605 // 344: }
14606 // 344: } // switch Inst[15]
14607 // 344: }
14608 1, 69, // 350: case 0x1: {
14609 OPC_SwitchField, 15, 1, // 352: switch Inst[15] {
14610 0, 31, // 355: case 0x0: {
14611 OPC_CheckField, 0, 7, 43, // 357: check Inst[6:0] == 0x2b
14612 OPC_CheckField, 25, 1, 1, // 361: check Inst[25] == 0x1
14613 OPC_Scope, 12, // 365: try {
14614 OPC_CheckField, 29, 2, 3, // 367: check Inst[30:29] == 0x3
14615 OPC_CheckPredicate, 151, 1, // 371: check predicate 151
14616 OPC_Decode, 158, 124, 238, 1, // 374: decode to SMT_VMADOT1US using decoder 238
14617 // 374: } else try {
14618 OPC_CheckPredicate, 150, 1, // 379: check predicate 150
14619 OPC_Decode, 187, 128, 1, 239, 1, // 382: decode to VMADOT1US using decoder 239
14620 // 382: }
14621 // 382: }
14622 1, 0, // 388: case 0x1: {
14623 OPC_CheckField, 0, 7, 43, // 390: check Inst[6:0] == 0x2b
14624 OPC_CheckField, 25, 1, 1, // 394: check Inst[25] == 0x1
14625 OPC_Scope, 12, // 398: try {
14626 OPC_CheckField, 29, 2, 3, // 400: check Inst[30:29] == 0x3
14627 OPC_CheckPredicate, 151, 1, // 404: check predicate 151
14628 OPC_Decode, 166, 124, 238, 1, // 407: decode to SMT_VMADOT3US using decoder 238
14629 // 407: } else try {
14630 OPC_CheckPredicate, 150, 1, // 412: check predicate 150
14631 OPC_Decode, 195, 128, 1, 239, 1, // 415: decode to VMADOT3US using decoder 239
14632 // 415: }
14633 // 415: }
14634 // 415: } // switch Inst[15]
14635 // 415: }
14636 2, 69, // 421: case 0x2: {
14637 OPC_SwitchField, 15, 1, // 423: switch Inst[15] {
14638 0, 31, // 426: case 0x0: {
14639 OPC_CheckField, 0, 7, 43, // 428: check Inst[6:0] == 0x2b
14640 OPC_CheckField, 25, 1, 1, // 432: check Inst[25] == 0x1
14641 OPC_Scope, 12, // 436: try {
14642 OPC_CheckField, 29, 2, 3, // 438: check Inst[30:29] == 0x3
14643 OPC_CheckPredicate, 151, 1, // 442: check predicate 151
14644 OPC_Decode, 156, 124, 238, 1, // 445: decode to SMT_VMADOT1SU using decoder 238
14645 // 445: } else try {
14646 OPC_CheckPredicate, 150, 1, // 450: check predicate 150
14647 OPC_Decode, 185, 128, 1, 239, 1, // 453: decode to VMADOT1SU using decoder 239
14648 // 453: }
14649 // 453: }
14650 1, 0, // 459: case 0x1: {
14651 OPC_CheckField, 0, 7, 43, // 461: check Inst[6:0] == 0x2b
14652 OPC_CheckField, 25, 1, 1, // 465: check Inst[25] == 0x1
14653 OPC_Scope, 12, // 469: try {
14654 OPC_CheckField, 29, 2, 3, // 471: check Inst[30:29] == 0x3
14655 OPC_CheckPredicate, 151, 1, // 475: check predicate 151
14656 OPC_Decode, 164, 124, 238, 1, // 478: decode to SMT_VMADOT3SU using decoder 238
14657 // 478: } else try {
14658 OPC_CheckPredicate, 150, 1, // 483: check predicate 150
14659 OPC_Decode, 193, 128, 1, 239, 1, // 486: decode to VMADOT3SU using decoder 239
14660 // 486: }
14661 // 486: }
14662 // 486: } // switch Inst[15]
14663 // 486: }
14664 3, 0, // 492: case 0x3: {
14665 OPC_SwitchField, 15, 1, // 494: switch Inst[15] {
14666 0, 31, // 497: case 0x0: {
14667 OPC_CheckField, 0, 7, 43, // 499: check Inst[6:0] == 0x2b
14668 OPC_CheckField, 25, 1, 1, // 503: check Inst[25] == 0x1
14669 OPC_Scope, 12, // 507: try {
14670 OPC_CheckField, 29, 2, 3, // 509: check Inst[30:29] == 0x3
14671 OPC_CheckPredicate, 151, 1, // 513: check predicate 151
14672 OPC_Decode, 155, 124, 238, 1, // 516: decode to SMT_VMADOT1 using decoder 238
14673 // 516: } else try {
14674 OPC_CheckPredicate, 150, 1, // 521: check predicate 150
14675 OPC_Decode, 184, 128, 1, 239, 1, // 524: decode to VMADOT1 using decoder 239
14676 // 524: }
14677 // 524: }
14678 1, 0, // 530: case 0x1: {
14679 OPC_CheckField, 0, 7, 43, // 532: check Inst[6:0] == 0x2b
14680 OPC_CheckField, 25, 1, 1, // 536: check Inst[25] == 0x1
14681 OPC_Scope, 12, // 540: try {
14682 OPC_CheckField, 29, 2, 3, // 542: check Inst[30:29] == 0x3
14683 OPC_CheckPredicate, 151, 1, // 546: check predicate 151
14684 OPC_Decode, 163, 124, 238, 1, // 549: decode to SMT_VMADOT3 using decoder 238
14685 // 549: } else try {
14686 OPC_CheckPredicate, 150, 1, // 554: check predicate 150
14687 OPC_Decode, 192, 128, 1, 239, 1, // 557: decode to VMADOT3 using decoder 239
14688 // 557: }
14689 // 557: }
14690 // 557: } // switch Inst[15]
14691 // 557: }
14692 // 557: } // switch Inst[13:12]
14693 // 557: }
14694 // 557: } // switch Inst[31]
14695 // 557: }
14696 1, 0, // 563: case 0x1: {
14697 OPC_SwitchField, 31, 1, // 565: switch Inst[31] {
14698 0, 21, // 568: case 0x0: {
14699 OPC_CheckPredicate, 150, 1, // 570: check predicate 150
14700 OPC_CheckField, 29, 2, 3, // 573: check Inst[30:29] == 0x3
14701 OPC_CheckField, 25, 1, 1, // 577: check Inst[25] == 0x1
14702 OPC_CheckField, 0, 7, 43, // 581: check Inst[6:0] == 0x2b
14703 OPC_Decode, 144, 131, 1, 237, 1, // 585: decode to VUPACK_VV using decoder 237
14704 // 585: }
14705 1, 0, // 591: case 0x1: {
14706 OPC_SwitchField, 12, 2, // 593: switch Inst[13:12] {
14707 0, 35, // 596: case 0x0: {
14708 OPC_CheckField, 0, 7, 43, // 598: check Inst[6:0] == 0x2b
14709 OPC_CheckField, 15, 1, 0, // 602: check Inst[15] == 0x0
14710 OPC_CheckField, 25, 1, 1, // 606: check Inst[25] == 0x1
14711 OPC_Scope, 12, // 610: try {
14712 OPC_CheckField, 29, 2, 3, // 612: check Inst[30:29] == 0x3
14713 OPC_CheckPredicate, 151, 1, // 616: check predicate 151
14714 OPC_Decode, 161, 124, 238, 1, // 619: decode to SMT_VMADOT2U using decoder 238
14715 // 619: } else try {
14716 OPC_CheckPredicate, 150, 1, // 624: check predicate 150
14717 OPC_Decode, 190, 128, 1, 239, 1, // 627: decode to VMADOT2U using decoder 239
14718 // 627: }
14719 // 627: }
14720 1, 35, // 633: case 0x1: {
14721 OPC_CheckField, 0, 7, 43, // 635: check Inst[6:0] == 0x2b
14722 OPC_CheckField, 15, 1, 0, // 639: check Inst[15] == 0x0
14723 OPC_CheckField, 25, 1, 1, // 643: check Inst[25] == 0x1
14724 OPC_Scope, 12, // 647: try {
14725 OPC_CheckField, 29, 2, 3, // 649: check Inst[30:29] == 0x3
14726 OPC_CheckPredicate, 151, 1, // 653: check predicate 151
14727 OPC_Decode, 162, 124, 238, 1, // 656: decode to SMT_VMADOT2US using decoder 238
14728 // 656: } else try {
14729 OPC_CheckPredicate, 150, 1, // 661: check predicate 150
14730 OPC_Decode, 191, 128, 1, 239, 1, // 664: decode to VMADOT2US using decoder 239
14731 // 664: }
14732 // 664: }
14733 2, 35, // 670: case 0x2: {
14734 OPC_CheckField, 0, 7, 43, // 672: check Inst[6:0] == 0x2b
14735 OPC_CheckField, 15, 1, 0, // 676: check Inst[15] == 0x0
14736 OPC_CheckField, 25, 1, 1, // 680: check Inst[25] == 0x1
14737 OPC_Scope, 12, // 684: try {
14738 OPC_CheckField, 29, 2, 3, // 686: check Inst[30:29] == 0x3
14739 OPC_CheckPredicate, 151, 1, // 690: check predicate 151
14740 OPC_Decode, 160, 124, 238, 1, // 693: decode to SMT_VMADOT2SU using decoder 238
14741 // 693: } else try {
14742 OPC_CheckPredicate, 150, 1, // 698: check predicate 150
14743 OPC_Decode, 189, 128, 1, 239, 1, // 701: decode to VMADOT2SU using decoder 239
14744 // 701: }
14745 // 701: }
14746 3, 0, // 707: case 0x3: {
14747 OPC_CheckField, 0, 7, 43, // 709: check Inst[6:0] == 0x2b
14748 OPC_CheckField, 15, 1, 0, // 713: check Inst[15] == 0x0
14749 OPC_CheckField, 25, 1, 1, // 717: check Inst[25] == 0x1
14750 OPC_Scope, 12, // 721: try {
14751 OPC_CheckField, 29, 2, 3, // 723: check Inst[30:29] == 0x3
14752 OPC_CheckPredicate, 151, 1, // 727: check predicate 151
14753 OPC_Decode, 159, 124, 238, 1, // 730: decode to SMT_VMADOT2 using decoder 238
14754 // 730: } else try {
14755 OPC_CheckPredicate, 150, 1, // 735: check predicate 150
14756 OPC_Decode, 188, 128, 1, 239, 1, // 738: decode to VMADOT2 using decoder 239
14757 // 738: }
14758 // 738: }
14759 // 738: } // switch Inst[13:12]
14760 // 738: }
14761 // 738: } // switch Inst[31]
14762 // 738: }
14763 // 738: } // switch Inst[14]
14764 // 738: }
14765 2, 79, // 744: case 0x2: {
14766 OPC_SwitchField, 12, 3, // 746: switch Inst[14:12] {
14767 0, 17, // 749: case 0x0: {
14768 OPC_CheckPredicate, 150, 1, // 751: check predicate 150
14769 OPC_CheckField, 31, 1, 1, // 754: check Inst[31] == 0x1
14770 OPC_CheckField, 0, 7, 43, // 758: check Inst[6:0] == 0x2b
14771 OPC_Decode, 204, 128, 1, 240, 1, // 762: decode to VMADOTU_SP using decoder 240
14772 // 762: }
14773 1, 17, // 768: case 0x1: {
14774 OPC_CheckPredicate, 150, 1, // 770: check predicate 150
14775 OPC_CheckField, 31, 1, 1, // 773: check Inst[31] == 0x1
14776 OPC_CheckField, 0, 7, 43, // 777: check Inst[6:0] == 0x2b
14777 OPC_Decode, 202, 128, 1, 240, 1, // 781: decode to VMADOTUS_SP using decoder 240
14778 // 781: }
14779 2, 17, // 787: case 0x2: {
14780 OPC_CheckPredicate, 150, 1, // 789: check predicate 150
14781 OPC_CheckField, 31, 1, 1, // 792: check Inst[31] == 0x1
14782 OPC_CheckField, 0, 7, 43, // 796: check Inst[6:0] == 0x2b
14783 OPC_Decode, 198, 128, 1, 240, 1, // 800: decode to VMADOTSU_SP using decoder 240
14784 // 800: }
14785 3, 0, // 806: case 0x3: {
14786 OPC_CheckPredicate, 150, 1, // 808: check predicate 150
14787 OPC_CheckField, 31, 1, 1, // 811: check Inst[31] == 0x1
14788 OPC_CheckField, 0, 7, 43, // 815: check Inst[6:0] == 0x2b
14789 OPC_Decode, 206, 128, 1, 240, 1, // 819: decode to VMADOT_SP using decoder 240
14790 // 819: }
14791 // 819: } // switch Inst[14:12]
14792 // 819: }
14793 3, 17, // 825: case 0x3: {
14794 OPC_CheckPredicate, 150, 1, // 827: check predicate 150
14795 OPC_CheckField, 31, 1, 1, // 830: check Inst[31] == 0x1
14796 OPC_CheckField, 0, 7, 43, // 834: check Inst[6:0] == 0x2b
14797 OPC_Decode, 203, 128, 1, 241, 1, // 838: decode to VMADOTU_HP using decoder 241
14798 // 838: }
14799 4, 17, // 844: case 0x4: {
14800 OPC_CheckPredicate, 150, 1, // 846: check predicate 150
14801 OPC_CheckField, 31, 1, 1, // 849: check Inst[31] == 0x1
14802 OPC_CheckField, 0, 7, 43, // 853: check Inst[6:0] == 0x2b
14803 OPC_Decode, 205, 128, 1, 241, 1, // 857: decode to VMADOT_HP using decoder 241
14804 // 857: }
14805 5, 17, // 863: case 0x5: {
14806 OPC_CheckPredicate, 150, 1, // 865: check predicate 150
14807 OPC_CheckField, 31, 1, 1, // 868: check Inst[31] == 0x1
14808 OPC_CheckField, 0, 7, 43, // 872: check Inst[6:0] == 0x2b
14809 OPC_Decode, 197, 128, 1, 241, 1, // 876: decode to VMADOTSU_HP using decoder 241
14810 // 876: }
14811 6, 17, // 882: case 0x6: {
14812 OPC_CheckPredicate, 150, 1, // 884: check predicate 150
14813 OPC_CheckField, 31, 1, 1, // 887: check Inst[31] == 0x1
14814 OPC_CheckField, 0, 7, 43, // 891: check Inst[6:0] == 0x2b
14815 OPC_Decode, 201, 128, 1, 241, 1, // 895: decode to VMADOTUS_HP using decoder 241
14816 // 895: }
14817 7, 0, // 901: case 0x7: {
14818 OPC_SwitchField, 12, 3, // 903: switch Inst[14:12] {
14819 4, 20, // 906: case 0x4: {
14820 OPC_CheckPredicate, 150, 1, // 908: check predicate 150
14821 OPC_CheckField, 29, 3, 4, // 911: check Inst[31:29] == 0x4
14822 OPC_CheckField, 25, 1, 1, // 915: check Inst[25] == 0x1
14823 OPC_CheckField, 0, 7, 43, // 919: check Inst[6:0] == 0x2b
14824 OPC_Decode, 226, 126, 235, 1, // 923: decode to VFWMADOT using decoder 235
14825 // 923: }
14826 5, 20, // 928: case 0x5: {
14827 OPC_CheckPredicate, 150, 1, // 930: check predicate 150
14828 OPC_CheckField, 29, 3, 4, // 933: check Inst[31:29] == 0x4
14829 OPC_CheckField, 25, 1, 1, // 937: check Inst[25] == 0x1
14830 OPC_CheckField, 0, 7, 43, // 941: check Inst[6:0] == 0x2b
14831 OPC_Decode, 227, 126, 242, 1, // 945: decode to VFWMADOT1 using decoder 242
14832 // 945: }
14833 6, 20, // 950: case 0x6: {
14834 OPC_CheckPredicate, 150, 1, // 952: check predicate 150
14835 OPC_CheckField, 29, 3, 4, // 955: check Inst[31:29] == 0x4
14836 OPC_CheckField, 25, 1, 1, // 959: check Inst[25] == 0x1
14837 OPC_CheckField, 0, 7, 43, // 963: check Inst[6:0] == 0x2b
14838 OPC_Decode, 228, 126, 242, 1, // 967: decode to VFWMADOT2 using decoder 242
14839 // 967: }
14840 7, 0, // 972: case 0x7: {
14841 OPC_CheckPredicate, 150, 1, // 974: check predicate 150
14842 OPC_CheckField, 29, 3, 4, // 977: check Inst[31:29] == 0x4
14843 OPC_CheckField, 25, 1, 1, // 981: check Inst[25] == 0x1
14844 OPC_CheckField, 0, 7, 43, // 985: check Inst[6:0] == 0x2b
14845 OPC_Decode, 229, 126, 242, 1, // 989: decode to VFWMADOT3 using decoder 242
14846 // 989: }
14847 // 989: } // switch Inst[14:12]
14848 // 989: }
14849 // 989: } // switch Inst[28:26]
14850};
14851static const uint8_t DecoderTableXSfcease32[16] = {
14852 32, // 0: BitWidth 32
14853 OPC_CheckPredicate, 152, 1, // 1: check predicate 152
14854 OPC_CheckField, 0, 32, 243, 128, 192, 130, 3,
14855 // 4: check Inst[31:0] == 0x30500073
14856 OPC_Decode, 172, 123, 14, // 12: decode to SF_CEASE using decoder 14
14857};
14858static const uint8_t DecoderTableXSfsystem32[32] = {
14859 32, // 0: BitWidth 32
14860 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
14861 192, 31, 11, // 4: case 0xfc0: {
14862 OPC_CheckPredicate, 153, 1, // 7: check predicate 153
14863 OPC_CheckField, 0, 15, 115, // 10: check Inst[14:0] == 0x73
14864 OPC_Decode, 173, 123, 15, // 14: decode to SF_CFLUSH_D_L1 using decoder 15
14865 // 14: }
14866 194, 31, 0, // 18: case 0xfc2: {
14867 OPC_CheckPredicate, 154, 1, // 21: check predicate 154
14868 OPC_CheckField, 0, 15, 115, // 24: check Inst[14:0] == 0x73
14869 OPC_Decode, 171, 123, 15, // 28: decode to SF_CDISCARD_D_L1 using decoder 15
14870 // 28: }
14871 // 28: } // switch Inst[31:20]
14872};
14873static const uint8_t DecoderTableXSfvector32[1129] = {
14874 32, // 0: BitWidth 32
14875 OPC_SwitchField, 28, 4, // 1: switch Inst[31:28] {
14876 0, 69, // 4: case 0x0: {
14877 OPC_SwitchField, 12, 3, // 6: switch Inst[14:12] {
14878 3, 31, // 9: case 0x3: {
14879 OPC_SwitchField, 25, 1, // 11: switch Inst[25] {
14880 0, 12, // 14: case 0x0: {
14881 OPC_CheckPredicate, 155, 1, // 16: check predicate 155
14882 OPC_CheckField, 0, 7, 91, // 19: check Inst[6:0] == 0x5b
14883 OPC_Decode, 196, 123, 243, 1, // 23: decode to SF_VC_V_I using decoder 243
14884 // 23: }
14885 1, 0, // 28: case 0x1: {
14886 OPC_CheckPredicate, 155, 1, // 30: check predicate 155
14887 OPC_CheckField, 0, 7, 91, // 33: check Inst[6:0] == 0x5b
14888 OPC_Decode, 186, 123, 244, 1, // 37: decode to SF_VC_I using decoder 244
14889 // 37: }
14890 // 37: } // switch Inst[25]
14891 // 37: }
14892 4, 0, // 42: case 0x4: {
14893 OPC_SwitchField, 25, 1, // 44: switch Inst[25] {
14894 0, 12, // 47: case 0x0: {
14895 OPC_CheckPredicate, 155, 1, // 49: check predicate 155
14896 OPC_CheckField, 0, 7, 91, // 52: check Inst[6:0] == 0x5b
14897 OPC_Decode, 203, 123, 245, 1, // 56: decode to SF_VC_V_X using decoder 245
14898 // 56: }
14899 1, 0, // 61: case 0x1: {
14900 OPC_CheckPredicate, 155, 1, // 63: check predicate 155
14901 OPC_CheckField, 0, 7, 91, // 66: check Inst[6:0] == 0x5b
14902 OPC_Decode, 207, 123, 246, 1, // 70: decode to SF_VC_X using decoder 246
14903 // 70: }
14904 // 70: } // switch Inst[25]
14905 // 70: }
14906 // 70: } // switch Inst[14:12]
14907 // 70: }
14908 1, 33, // 75: case 0x1: {
14909 OPC_SwitchField, 0, 15, // 77: switch Inst[14:0] {
14910 135, 224, 1, 11, // 80: case 0x7007: {
14911 OPC_CheckPredicate, 156, 1, // 84: check predicate 156
14912 OPC_CheckField, 25, 3, 1, // 87: check Inst[27:25] == 0x1
14913 OPC_Decode, 219, 123, 57, // 91: decode to SF_VLTE8 using decoder 57
14914 // 91: }
14915 167, 224, 1, 0, // 95: case 0x7027: {
14916 OPC_CheckPredicate, 156, 1, // 99: check predicate 156
14917 OPC_CheckField, 25, 3, 1, // 102: check Inst[27:25] == 0x1
14918 OPC_Decode, 234, 123, 57, // 106: decode to SF_VSTE8 using decoder 57
14919 // 106: }
14920 // 106: } // switch Inst[14:0]
14921 // 106: }
14922 2, 143, 1, // 110: case 0x2: {
14923 OPC_SwitchField, 12, 3, // 113: switch Inst[14:12] {
14924 0, 31, // 116: case 0x0: {
14925 OPC_SwitchField, 25, 1, // 118: switch Inst[25] {
14926 0, 12, // 121: case 0x0: {
14927 OPC_CheckPredicate, 155, 1, // 123: check predicate 155
14928 OPC_CheckField, 0, 7, 91, // 126: check Inst[6:0] == 0x5b
14929 OPC_Decode, 200, 123, 247, 1, // 130: decode to SF_VC_V_VV using decoder 247
14930 // 130: }
14931 1, 0, // 135: case 0x1: {
14932 OPC_CheckPredicate, 155, 1, // 137: check predicate 155
14933 OPC_CheckField, 0, 7, 91, // 140: check Inst[6:0] == 0x5b
14934 OPC_Decode, 190, 123, 248, 1, // 144: decode to SF_VC_VV using decoder 248
14935 // 144: }
14936 // 144: } // switch Inst[25]
14937 // 144: }
14938 3, 31, // 149: case 0x3: {
14939 OPC_SwitchField, 25, 1, // 151: switch Inst[25] {
14940 0, 12, // 154: case 0x0: {
14941 OPC_CheckPredicate, 155, 1, // 156: check predicate 155
14942 OPC_CheckField, 0, 7, 91, // 159: check Inst[6:0] == 0x5b
14943 OPC_Decode, 197, 123, 249, 1, // 163: decode to SF_VC_V_IV using decoder 249
14944 // 163: }
14945 1, 0, // 168: case 0x1: {
14946 OPC_CheckPredicate, 155, 1, // 170: check predicate 155
14947 OPC_CheckField, 0, 7, 91, // 173: check Inst[6:0] == 0x5b
14948 OPC_Decode, 187, 123, 250, 1, // 177: decode to SF_VC_IV using decoder 250
14949 // 177: }
14950 // 177: } // switch Inst[25]
14951 // 177: }
14952 4, 31, // 182: case 0x4: {
14953 OPC_SwitchField, 25, 1, // 184: switch Inst[25] {
14954 0, 12, // 187: case 0x0: {
14955 OPC_CheckPredicate, 155, 1, // 189: check predicate 155
14956 OPC_CheckField, 0, 7, 91, // 192: check Inst[6:0] == 0x5b
14957 OPC_Decode, 204, 123, 251, 1, // 196: decode to SF_VC_V_XV using decoder 251
14958 // 196: }
14959 1, 0, // 201: case 0x1: {
14960 OPC_CheckPredicate, 155, 1, // 203: check predicate 155
14961 OPC_CheckField, 0, 7, 91, // 206: check Inst[6:0] == 0x5b
14962 OPC_Decode, 208, 123, 252, 1, // 210: decode to SF_VC_XV using decoder 252
14963 // 210: }
14964 // 210: } // switch Inst[25]
14965 // 210: }
14966 5, 0, // 215: case 0x5: {
14967 OPC_SwitchField, 25, 1, // 217: switch Inst[25] {
14968 0, 16, // 220: case 0x0: {
14969 OPC_CheckPredicate, 155, 1, // 222: check predicate 155
14970 OPC_CheckField, 27, 1, 1, // 225: check Inst[27] == 0x1
14971 OPC_CheckField, 0, 7, 91, // 229: check Inst[6:0] == 0x5b
14972 OPC_Decode, 193, 123, 253, 1, // 233: decode to SF_VC_V_FV using decoder 253
14973 // 233: }
14974 1, 0, // 238: case 0x1: {
14975 OPC_CheckPredicate, 155, 1, // 240: check predicate 155
14976 OPC_CheckField, 27, 1, 1, // 243: check Inst[27] == 0x1
14977 OPC_CheckField, 0, 7, 91, // 247: check Inst[6:0] == 0x5b
14978 OPC_Decode, 183, 123, 254, 1, // 251: decode to SF_VC_FV using decoder 254
14979 // 251: }
14980 // 251: } // switch Inst[25]
14981 // 251: }
14982 // 251: } // switch Inst[14:12]
14983 // 251: }
14984 3, 33, // 256: case 0x3: {
14985 OPC_SwitchField, 0, 15, // 258: switch Inst[14:0] {
14986 135, 224, 1, 11, // 261: case 0x7007: {
14987 OPC_CheckPredicate, 156, 1, // 265: check predicate 156
14988 OPC_CheckField, 25, 3, 1, // 268: check Inst[27:25] == 0x1
14989 OPC_Decode, 216, 123, 57, // 272: decode to SF_VLTE16 using decoder 57
14990 // 272: }
14991 167, 224, 1, 0, // 276: case 0x7027: {
14992 OPC_CheckPredicate, 156, 1, // 280: check predicate 156
14993 OPC_CheckField, 25, 3, 1, // 283: check Inst[27:25] == 0x1
14994 OPC_Decode, 231, 123, 57, // 287: decode to SF_VSTE16 using decoder 57
14995 // 287: }
14996 // 287: } // switch Inst[14:0]
14997 // 287: }
14998 4, 95, // 291: case 0x4: {
14999 OPC_SwitchField, 12, 3, // 293: switch Inst[14:12] {
15000 1, 37, // 296: case 0x1: {
15001 OPC_SwitchField, 15, 5, // 298: switch Inst[19:15] {
15002 6, 15, // 301: case 0x6: {
15003 OPC_CheckPredicate, 157, 1, // 303: check predicate 157
15004 OPC_CheckField, 26, 2, 3, // 306: check Inst[27:26] == 0x3
15005 OPC_CheckField, 0, 7, 87, // 310: check Inst[6:0] == 0x57
15006 OPC_Decode, 211, 123, 119, // 314: decode to SF_VFEXPA_V using decoder 119
15007 // 314: }
15008 7, 0, // 318: case 0x7: {
15009 OPC_CheckPredicate, 158, 1, // 320: check predicate 158
15010 OPC_CheckField, 26, 2, 3, // 323: check Inst[27:26] == 0x3
15011 OPC_CheckField, 0, 7, 87, // 327: check Inst[6:0] == 0x57
15012 OPC_Decode, 212, 123, 119, // 331: decode to SF_VFEXP_V using decoder 119
15013 // 331: }
15014 // 331: } // switch Inst[19:15]
15015 // 331: }
15016 6, 0, // 335: case 0x6: {
15017 OPC_SwitchField, 20, 8, // 337: switch Inst[27:20] {
15018 60, 15, // 340: case 0x3c: {
15019 OPC_CheckPredicate, 156, 1, // 342: check predicate 156
15020 OPC_CheckField, 15, 5, 0, // 345: check Inst[19:15] == 0x0
15021 OPC_CheckField, 0, 12, 87, // 349: check Inst[11:0] == 0x57
15022 OPC_Decode, 235, 123, 14, // 353: decode to SF_VTDISCARD using decoder 14
15023 // 353: }
15024 62, 16, // 357: case 0x3e: {
15025 OPC_CheckPredicate, 156, 1, // 359: check predicate 156
15026 OPC_CheckField, 15, 5, 0, // 362: check Inst[19:15] == 0x0
15027 OPC_CheckField, 0, 8, 87, // 366: check Inst[7:0] == 0x57
15028 OPC_Decode, 238, 123, 255, 1, // 370: decode to SF_VTZERO_T using decoder 255
15029 // 370: }
15030 63, 0, // 375: case 0x3f: {
15031 OPC_CheckPredicate, 156, 1, // 377: check predicate 156
15032 OPC_CheckField, 0, 7, 87, // 380: check Inst[6:0] == 0x57
15033 OPC_Decode, 237, 123, 2, // 384: decode to SF_VTMV_V_T using decoder 2
15034 // 384: }
15035 // 384: } // switch Inst[27:20]
15036 // 384: }
15037 // 384: } // switch Inst[14:12]
15038 // 384: }
15039 5, 49, // 388: case 0x5: {
15040 OPC_SwitchField, 0, 15, // 390: switch Inst[14:0] {
15041 215, 192, 1, 12, // 393: case 0x6057: {
15042 OPC_CheckPredicate, 156, 1, // 397: check predicate 156
15043 OPC_CheckField, 25, 3, 7, // 400: check Inst[27:25] == 0x7
15044 OPC_Decode, 236, 123, 128, 2, // 404: decode to SF_VTMV_T_V using decoder 256
15045 // 404: }
15046 135, 224, 1, 11, // 409: case 0x7007: {
15047 OPC_CheckPredicate, 156, 1, // 413: check predicate 156
15048 OPC_CheckField, 25, 3, 1, // 416: check Inst[27:25] == 0x1
15049 OPC_Decode, 217, 123, 57, // 420: decode to SF_VLTE32 using decoder 57
15050 // 420: }
15051 167, 224, 1, 0, // 424: case 0x7027: {
15052 OPC_CheckPredicate, 156, 1, // 428: check predicate 156
15053 OPC_CheckField, 25, 3, 1, // 431: check Inst[27:25] == 0x1
15054 OPC_Decode, 232, 123, 57, // 435: decode to SF_VSTE32 using decoder 57
15055 // 435: }
15056 // 435: } // switch Inst[14:0]
15057 // 435: }
15058 7, 33, // 439: case 0x7: {
15059 OPC_SwitchField, 0, 15, // 441: switch Inst[14:0] {
15060 135, 224, 1, 11, // 444: case 0x7007: {
15061 OPC_CheckPredicate, 156, 1, // 448: check predicate 156
15062 OPC_CheckField, 25, 3, 1, // 451: check Inst[27:25] == 0x1
15063 OPC_Decode, 218, 123, 57, // 455: decode to SF_VLTE64 using decoder 57
15064 // 455: }
15065 167, 224, 1, 0, // 459: case 0x7027: {
15066 OPC_CheckPredicate, 156, 1, // 463: check predicate 156
15067 OPC_CheckField, 25, 3, 1, // 466: check Inst[27:25] == 0x1
15068 OPC_Decode, 233, 123, 57, // 470: decode to SF_VSTE64 using decoder 57
15069 // 470: }
15070 // 470: } // switch Inst[14:0]
15071 // 470: }
15072 8, 95, // 474: case 0x8: {
15073 OPC_SwitchField, 26, 2, // 476: switch Inst[27:26] {
15074 1, 54, // 479: case 0x1: {
15075 OPC_SwitchField, 20, 6, // 481: switch Inst[25:20] {
15076 0, 15, // 484: case 0x0: {
15077 OPC_CheckPredicate, 156, 1, // 486: check predicate 156
15078 OPC_CheckField, 12, 3, 7, // 489: check Inst[14:12] == 0x7
15079 OPC_CheckField, 0, 7, 87, // 493: check Inst[6:0] == 0x57
15080 OPC_Decode, 230, 123, 17, // 497: decode to SF_VSETTN using decoder 17
15081 // 497: }
15082 1, 15, // 501: case 0x1: {
15083 OPC_CheckPredicate, 156, 1, // 503: check predicate 156
15084 OPC_CheckField, 12, 3, 7, // 506: check Inst[14:12] == 0x7
15085 OPC_CheckField, 0, 7, 87, // 510: check Inst[6:0] == 0x57
15086 OPC_Decode, 229, 123, 17, // 514: decode to SF_VSETTM using decoder 17
15087 // 514: }
15088 2, 0, // 518: case 0x2: {
15089 OPC_CheckPredicate, 156, 1, // 520: check predicate 156
15090 OPC_CheckField, 12, 3, 7, // 523: check Inst[14:12] == 0x7
15091 OPC_CheckField, 0, 7, 87, // 527: check Inst[6:0] == 0x57
15092 OPC_Decode, 228, 123, 17, // 531: decode to SF_VSETTK using decoder 17
15093 // 531: }
15094 // 531: } // switch Inst[25:20]
15095 // 531: }
15096 2, 16, // 535: case 0x2: {
15097 OPC_CheckPredicate, 159, 1, // 537: check predicate 159
15098 OPC_CheckField, 12, 3, 5, // 540: check Inst[14:12] == 0x5
15099 OPC_CheckField, 0, 7, 91, // 544: check Inst[6:0] == 0x5b
15100 OPC_Decode, 213, 123, 138, 1, // 548: decode to SF_VFNRCLIP_XU_F_QF using decoder 138
15101 // 548: }
15102 3, 0, // 553: case 0x3: {
15103 OPC_CheckPredicate, 159, 1, // 555: check predicate 159
15104 OPC_CheckField, 12, 3, 5, // 558: check Inst[14:12] == 0x5
15105 OPC_CheckField, 0, 7, 91, // 562: check Inst[6:0] == 0x5b
15106 OPC_Decode, 214, 123, 138, 1, // 566: decode to SF_VFNRCLIP_X_F_QF using decoder 138
15107 // 566: }
15108 // 566: } // switch Inst[27:26]
15109 // 566: }
15110 10, 143, 1, // 571: case 0xa: {
15111 OPC_SwitchField, 12, 3, // 574: switch Inst[14:12] {
15112 0, 31, // 577: case 0x0: {
15113 OPC_SwitchField, 25, 1, // 579: switch Inst[25] {
15114 0, 12, // 582: case 0x0: {
15115 OPC_CheckPredicate, 155, 1, // 584: check predicate 155
15116 OPC_CheckField, 0, 7, 91, // 587: check Inst[6:0] == 0x5b
15117 OPC_Decode, 201, 123, 129, 2, // 591: decode to SF_VC_V_VVV using decoder 257
15118 // 591: }
15119 1, 0, // 596: case 0x1: {
15120 OPC_CheckPredicate, 155, 1, // 598: check predicate 155
15121 OPC_CheckField, 0, 7, 91, // 601: check Inst[6:0] == 0x5b
15122 OPC_Decode, 191, 123, 130, 2, // 605: decode to SF_VC_VVV using decoder 258
15123 // 605: }
15124 // 605: } // switch Inst[25]
15125 // 605: }
15126 3, 31, // 610: case 0x3: {
15127 OPC_SwitchField, 25, 1, // 612: switch Inst[25] {
15128 0, 12, // 615: case 0x0: {
15129 OPC_CheckPredicate, 155, 1, // 617: check predicate 155
15130 OPC_CheckField, 0, 7, 91, // 620: check Inst[6:0] == 0x5b
15131 OPC_Decode, 198, 123, 131, 2, // 624: decode to SF_VC_V_IVV using decoder 259
15132 // 624: }
15133 1, 0, // 629: case 0x1: {
15134 OPC_CheckPredicate, 155, 1, // 631: check predicate 155
15135 OPC_CheckField, 0, 7, 91, // 634: check Inst[6:0] == 0x5b
15136 OPC_Decode, 188, 123, 132, 2, // 638: decode to SF_VC_IVV using decoder 260
15137 // 638: }
15138 // 638: } // switch Inst[25]
15139 // 638: }
15140 4, 31, // 643: case 0x4: {
15141 OPC_SwitchField, 25, 1, // 645: switch Inst[25] {
15142 0, 12, // 648: case 0x0: {
15143 OPC_CheckPredicate, 155, 1, // 650: check predicate 155
15144 OPC_CheckField, 0, 7, 91, // 653: check Inst[6:0] == 0x5b
15145 OPC_Decode, 205, 123, 133, 2, // 657: decode to SF_VC_V_XVV using decoder 261
15146 // 657: }
15147 1, 0, // 662: case 0x1: {
15148 OPC_CheckPredicate, 155, 1, // 664: check predicate 155
15149 OPC_CheckField, 0, 7, 91, // 667: check Inst[6:0] == 0x5b
15150 OPC_Decode, 209, 123, 134, 2, // 671: decode to SF_VC_XVV using decoder 262
15151 // 671: }
15152 // 671: } // switch Inst[25]
15153 // 671: }
15154 5, 0, // 676: case 0x5: {
15155 OPC_SwitchField, 25, 1, // 678: switch Inst[25] {
15156 0, 16, // 681: case 0x0: {
15157 OPC_CheckPredicate, 155, 1, // 683: check predicate 155
15158 OPC_CheckField, 27, 1, 1, // 686: check Inst[27] == 0x1
15159 OPC_CheckField, 0, 7, 91, // 690: check Inst[6:0] == 0x5b
15160 OPC_Decode, 194, 123, 135, 2, // 694: decode to SF_VC_V_FVV using decoder 263
15161 // 694: }
15162 1, 0, // 699: case 0x1: {
15163 OPC_CheckPredicate, 155, 1, // 701: check predicate 155
15164 OPC_CheckField, 27, 1, 1, // 704: check Inst[27] == 0x1
15165 OPC_CheckField, 0, 7, 91, // 708: check Inst[6:0] == 0x5b
15166 OPC_Decode, 184, 123, 136, 2, // 712: decode to SF_VC_FVV using decoder 264
15167 // 712: }
15168 // 712: } // switch Inst[25]
15169 // 712: }
15170 // 712: } // switch Inst[14:12]
15171 // 712: }
15172 11, 71, // 717: case 0xb: {
15173 OPC_SwitchField, 25, 3, // 719: switch Inst[27:25] {
15174 1, 15, // 722: case 0x1: {
15175 OPC_CheckPredicate, 160, 1, // 724: check predicate 160
15176 OPC_CheckField, 12, 3, 2, // 727: check Inst[14:12] == 0x2
15177 OPC_CheckField, 0, 7, 91, // 731: check Inst[6:0] == 0x5b
15178 OPC_Decode, 224, 123, 116, // 735: decode to SF_VQMACCU_2x8x2 using decoder 116
15179 // 735: }
15180 3, 15, // 739: case 0x3: {
15181 OPC_CheckPredicate, 160, 1, // 741: check predicate 160
15182 OPC_CheckField, 12, 3, 2, // 744: check Inst[14:12] == 0x2
15183 OPC_CheckField, 0, 7, 91, // 748: check Inst[6:0] == 0x5b
15184 OPC_Decode, 226, 123, 116, // 752: decode to SF_VQMACC_2x8x2 using decoder 116
15185 // 752: }
15186 5, 15, // 756: case 0x5: {
15187 OPC_CheckPredicate, 160, 1, // 758: check predicate 160
15188 OPC_CheckField, 12, 3, 2, // 761: check Inst[14:12] == 0x2
15189 OPC_CheckField, 0, 7, 91, // 765: check Inst[6:0] == 0x5b
15190 OPC_Decode, 222, 123, 116, // 769: decode to SF_VQMACCUS_2x8x2 using decoder 116
15191 // 769: }
15192 7, 0, // 773: case 0x7: {
15193 OPC_CheckPredicate, 160, 1, // 775: check predicate 160
15194 OPC_CheckField, 12, 3, 2, // 778: check Inst[14:12] == 0x2
15195 OPC_CheckField, 0, 7, 91, // 782: check Inst[6:0] == 0x5b
15196 OPC_Decode, 220, 123, 116, // 786: decode to SF_VQMACCSU_2x8x2 using decoder 116
15197 // 786: }
15198 // 786: } // switch Inst[27:25]
15199 // 786: }
15200 15, 0, // 790: case 0xf: {
15201 OPC_SwitchField, 12, 3, // 792: switch Inst[14:12] {
15202 0, 83, // 795: case 0x0: {
15203 OPC_SwitchField, 0, 7, // 797: switch Inst[6:0] {
15204 91, 23, // 800: case 0x5b: {
15205 OPC_SwitchField, 25, 1, // 802: switch Inst[25] {
15206 0, 8, // 805: case 0x0: {
15207 OPC_CheckPredicate, 155, 1, // 807: check predicate 155
15208 OPC_Decode, 202, 123, 129, 2, // 810: decode to SF_VC_V_VVW using decoder 257
15209 // 810: }
15210 1, 0, // 815: case 0x1: {
15211 OPC_CheckPredicate, 155, 1, // 817: check predicate 155
15212 OPC_Decode, 192, 123, 130, 2, // 820: decode to SF_VC_VVW using decoder 258
15213 // 820: }
15214 // 820: } // switch Inst[25]
15215 // 820: }
15216 119, 0, // 825: case 0x77: {
15217 OPC_SwitchField, 7, 3, // 827: switch Inst[9:7] {
15218 0, 23, // 830: case 0x0: {
15219 OPC_SwitchField, 25, 3, // 832: switch Inst[27:25] {
15220 1, 8, // 835: case 0x1: {
15221 OPC_CheckPredicate, 161, 1, // 837: check predicate 161
15222 OPC_Decode, 182, 123, 137, 2, // 840: decode to SF_MM_U_U using decoder 265
15223 // 840: }
15224 3, 0, // 845: case 0x3: {
15225 OPC_CheckPredicate, 161, 1, // 847: check predicate 161
15226 OPC_Decode, 180, 123, 137, 2, // 850: decode to SF_MM_S_U using decoder 265
15227 // 850: }
15228 // 850: } // switch Inst[27:25]
15229 // 850: }
15230 1, 0, // 855: case 0x1: {
15231 OPC_SwitchField, 25, 3, // 857: switch Inst[27:25] {
15232 1, 8, // 860: case 0x1: {
15233 OPC_CheckPredicate, 161, 1, // 862: check predicate 161
15234 OPC_Decode, 181, 123, 137, 2, // 865: decode to SF_MM_U_S using decoder 265
15235 // 865: }
15236 3, 0, // 870: case 0x3: {
15237 OPC_CheckPredicate, 161, 1, // 872: check predicate 161
15238 OPC_Decode, 179, 123, 137, 2, // 875: decode to SF_MM_S_S using decoder 265
15239 // 875: }
15240 // 875: } // switch Inst[27:25]
15241 // 875: }
15242 // 875: } // switch Inst[9:7]
15243 // 875: }
15244 // 875: } // switch Inst[6:0]
15245 // 875: }
15246 1, 83, // 880: case 0x1: {
15247 OPC_SwitchField, 25, 3, // 882: switch Inst[27:25] {
15248 1, 26, // 885: case 0x1: {
15249 OPC_SwitchField, 0, 7, // 887: switch Inst[6:0] {
15250 91, 7, // 890: case 0x5b: {
15251 OPC_CheckPredicate, 162, 1, // 892: check predicate 162
15252 OPC_Decode, 215, 123, 116, // 895: decode to SF_VFWMACC_4x4x4 using decoder 116
15253 // 895: }
15254 119, 0, // 899: case 0x77: {
15255 OPC_CheckPredicate, 163, 1, // 901: check predicate 163
15256 OPC_CheckField, 7, 2, 0, // 904: check Inst[8:7] == 0x0
15257 OPC_Decode, 178, 123, 138, 2, // 908: decode to SF_MM_F_F using decoder 266
15258 // 908: }
15259 // 908: } // switch Inst[6:0]
15260 // 908: }
15261 5, 24, // 913: case 0x5: {
15262 OPC_SwitchField, 0, 10, // 915: switch Inst[9:0] {
15263 119, 8, // 918: case 0x77: {
15264 OPC_CheckPredicate, 164, 1, // 920: check predicate 164
15265 OPC_Decode, 177, 123, 137, 2, // 923: decode to SF_MM_E5M2_E5M2 using decoder 265
15266 // 923: }
15267 247, 1, 0, // 928: case 0xf7: {
15268 OPC_CheckPredicate, 164, 1, // 931: check predicate 164
15269 OPC_Decode, 176, 123, 137, 2, // 934: decode to SF_MM_E5M2_E4M3 using decoder 265
15270 // 934: }
15271 // 934: } // switch Inst[9:0]
15272 // 934: }
15273 7, 0, // 939: case 0x7: {
15274 OPC_SwitchField, 0, 10, // 941: switch Inst[9:0] {
15275 119, 8, // 944: case 0x77: {
15276 OPC_CheckPredicate, 164, 1, // 946: check predicate 164
15277 OPC_Decode, 175, 123, 137, 2, // 949: decode to SF_MM_E4M3_E5M2 using decoder 265
15278 // 949: }
15279 247, 1, 0, // 954: case 0xf7: {
15280 OPC_CheckPredicate, 164, 1, // 957: check predicate 164
15281 OPC_Decode, 174, 123, 137, 2, // 960: decode to SF_MM_E4M3_E4M3 using decoder 265
15282 // 960: }
15283 // 960: } // switch Inst[9:0]
15284 // 960: }
15285 // 960: } // switch Inst[27:25]
15286 // 960: }
15287 2, 55, // 965: case 0x2: {
15288 OPC_SwitchField, 25, 3, // 967: switch Inst[27:25] {
15289 1, 11, // 970: case 0x1: {
15290 OPC_CheckPredicate, 165, 1, // 972: check predicate 165
15291 OPC_CheckField, 0, 7, 91, // 975: check Inst[6:0] == 0x5b
15292 OPC_Decode, 225, 123, 116, // 979: decode to SF_VQMACCU_4x8x4 using decoder 116
15293 // 979: }
15294 3, 11, // 983: case 0x3: {
15295 OPC_CheckPredicate, 165, 1, // 985: check predicate 165
15296 OPC_CheckField, 0, 7, 91, // 988: check Inst[6:0] == 0x5b
15297 OPC_Decode, 227, 123, 116, // 992: decode to SF_VQMACC_4x8x4 using decoder 116
15298 // 992: }
15299 5, 11, // 996: case 0x5: {
15300 OPC_CheckPredicate, 165, 1, // 998: check predicate 165
15301 OPC_CheckField, 0, 7, 91, // 1001: check Inst[6:0] == 0x5b
15302 OPC_Decode, 223, 123, 116, // 1005: decode to SF_VQMACCUS_4x8x4 using decoder 116
15303 // 1005: }
15304 7, 0, // 1009: case 0x7: {
15305 OPC_CheckPredicate, 165, 1, // 1011: check predicate 165
15306 OPC_CheckField, 0, 7, 91, // 1014: check Inst[6:0] == 0x5b
15307 OPC_Decode, 221, 123, 116, // 1018: decode to SF_VQMACCSU_4x8x4 using decoder 116
15308 // 1018: }
15309 // 1018: } // switch Inst[27:25]
15310 // 1018: }
15311 3, 31, // 1022: case 0x3: {
15312 OPC_SwitchField, 25, 1, // 1024: switch Inst[25] {
15313 0, 12, // 1027: case 0x0: {
15314 OPC_CheckPredicate, 155, 1, // 1029: check predicate 155
15315 OPC_CheckField, 0, 7, 91, // 1032: check Inst[6:0] == 0x5b
15316 OPC_Decode, 199, 123, 131, 2, // 1036: decode to SF_VC_V_IVW using decoder 259
15317 // 1036: }
15318 1, 0, // 1041: case 0x1: {
15319 OPC_CheckPredicate, 155, 1, // 1043: check predicate 155
15320 OPC_CheckField, 0, 7, 91, // 1046: check Inst[6:0] == 0x5b
15321 OPC_Decode, 189, 123, 132, 2, // 1050: decode to SF_VC_IVW using decoder 260
15322 // 1050: }
15323 // 1050: } // switch Inst[25]
15324 // 1050: }
15325 4, 31, // 1055: case 0x4: {
15326 OPC_SwitchField, 25, 1, // 1057: switch Inst[25] {
15327 0, 12, // 1060: case 0x0: {
15328 OPC_CheckPredicate, 155, 1, // 1062: check predicate 155
15329 OPC_CheckField, 0, 7, 91, // 1065: check Inst[6:0] == 0x5b
15330 OPC_Decode, 206, 123, 133, 2, // 1069: decode to SF_VC_V_XVW using decoder 261
15331 // 1069: }
15332 1, 0, // 1074: case 0x1: {
15333 OPC_CheckPredicate, 155, 1, // 1076: check predicate 155
15334 OPC_CheckField, 0, 7, 91, // 1079: check Inst[6:0] == 0x5b
15335 OPC_Decode, 210, 123, 134, 2, // 1083: decode to SF_VC_XVW using decoder 262
15336 // 1083: }
15337 // 1083: } // switch Inst[25]
15338 // 1083: }
15339 5, 0, // 1088: case 0x5: {
15340 OPC_SwitchField, 25, 1, // 1090: switch Inst[25] {
15341 0, 16, // 1093: case 0x0: {
15342 OPC_CheckPredicate, 155, 1, // 1095: check predicate 155
15343 OPC_CheckField, 27, 1, 1, // 1098: check Inst[27] == 0x1
15344 OPC_CheckField, 0, 7, 91, // 1102: check Inst[6:0] == 0x5b
15345 OPC_Decode, 195, 123, 135, 2, // 1106: decode to SF_VC_V_FVW using decoder 263
15346 // 1106: }
15347 1, 0, // 1111: case 0x1: {
15348 OPC_CheckPredicate, 155, 1, // 1113: check predicate 155
15349 OPC_CheckField, 27, 1, 1, // 1116: check Inst[27] == 0x1
15350 OPC_CheckField, 0, 7, 91, // 1120: check Inst[6:0] == 0x5b
15351 OPC_Decode, 185, 123, 136, 2, // 1124: decode to SF_VC_FVW using decoder 264
15352 // 1124: }
15353 // 1124: } // switch Inst[25]
15354 // 1124: }
15355 // 1124: } // switch Inst[14:12]
15356 // 1124: }
15357 // 1124: } // switch Inst[31:28]
15358};
15359static const uint8_t DecoderTableXTHead32[1598] = {
15360 32, // 0: BitWidth 32
15361 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
15362 0, 235, 2, // 4: case 0x0: {
15363 OPC_SwitchField, 25, 7, // 7: switch Inst[31:25] {
15364 0, 168, 1, // 10: case 0x0: {
15365 OPC_SwitchField, 15, 10, // 13: switch Inst[24:15] {
15366 32, 11, // 16: case 0x20: {
15367 OPC_CheckPredicate, 166, 1, // 18: check predicate 166
15368 OPC_CheckField, 0, 12, 11, // 21: check Inst[11:0] == 0xb
15369 OPC_Decode, 210, 124, 14, // 25: decode to TH_DCACHE_CALL using decoder 14
15370 // 25: }
15371 64, 11, // 29: case 0x40: {
15372 OPC_CheckPredicate, 166, 1, // 31: check predicate 166
15373 OPC_CheckField, 0, 12, 11, // 34: check Inst[11:0] == 0xb
15374 OPC_Decode, 220, 124, 14, // 38: decode to TH_DCACHE_IALL using decoder 14
15375 // 38: }
15376 96, 11, // 42: case 0x60: {
15377 OPC_CheckPredicate, 166, 1, // 44: check predicate 166
15378 OPC_CheckField, 0, 12, 11, // 47: check Inst[11:0] == 0xb
15379 OPC_Decode, 211, 124, 14, // 51: decode to TH_DCACHE_CIALL using decoder 14
15380 // 51: }
15381 128, 4, 11, // 55: case 0x200: {
15382 OPC_CheckPredicate, 166, 1, // 58: check predicate 166
15383 OPC_CheckField, 0, 12, 11, // 61: check Inst[11:0] == 0xb
15384 OPC_Decode, 236, 124, 14, // 65: decode to TH_ICACHE_IALL using decoder 14
15385 // 65: }
15386 160, 4, 11, // 69: case 0x220: {
15387 OPC_CheckPredicate, 166, 1, // 72: check predicate 166
15388 OPC_CheckField, 0, 12, 11, // 75: check Inst[11:0] == 0xb
15389 OPC_Decode, 237, 124, 14, // 79: decode to TH_ICACHE_IALLS using decoder 14
15390 // 79: }
15391 160, 5, 11, // 83: case 0x2a0: {
15392 OPC_CheckPredicate, 166, 1, // 86: check predicate 166
15393 OPC_CheckField, 0, 12, 11, // 89: check Inst[11:0] == 0xb
15394 OPC_Decode, 240, 124, 14, // 93: decode to TH_L2CACHE_CALL using decoder 14
15395 // 93: }
15396 192, 5, 11, // 97: case 0x2c0: {
15397 OPC_CheckPredicate, 166, 1, // 100: check predicate 166
15398 OPC_CheckField, 0, 12, 11, // 103: check Inst[11:0] == 0xb
15399 OPC_Decode, 242, 124, 14, // 107: decode to TH_L2CACHE_IALL using decoder 14
15400 // 107: }
15401 224, 5, 11, // 111: case 0x2e0: {
15402 OPC_CheckPredicate, 166, 1, // 114: check predicate 166
15403 OPC_CheckField, 0, 12, 11, // 117: check Inst[11:0] == 0xb
15404 OPC_Decode, 241, 124, 14, // 121: decode to TH_L2CACHE_CIALL using decoder 14
15405 // 121: }
15406 128, 6, 11, // 125: case 0x300: {
15407 OPC_CheckPredicate, 167, 1, // 128: check predicate 167
15408 OPC_CheckField, 0, 12, 11, // 131: check Inst[11:0] == 0xb
15409 OPC_Decode, 177, 125, 14, // 135: decode to TH_SYNC using decoder 14
15410 // 135: }
15411 160, 6, 11, // 139: case 0x320: {
15412 OPC_CheckPredicate, 167, 1, // 142: check predicate 167
15413 OPC_CheckField, 0, 12, 11, // 145: check Inst[11:0] == 0xb
15414 OPC_Decode, 180, 125, 14, // 149: decode to TH_SYNC_S using decoder 14
15415 // 149: }
15416 192, 6, 11, // 153: case 0x340: {
15417 OPC_CheckPredicate, 167, 1, // 156: check predicate 167
15418 OPC_CheckField, 0, 12, 11, // 159: check Inst[11:0] == 0xb
15419 OPC_Decode, 178, 125, 14, // 163: decode to TH_SYNC_I using decoder 14
15420 // 163: }
15421 224, 6, 0, // 167: case 0x360: {
15422 OPC_CheckPredicate, 167, 1, // 170: check predicate 167
15423 OPC_CheckField, 0, 12, 11, // 173: check Inst[11:0] == 0xb
15424 OPC_Decode, 179, 125, 14, // 177: decode to TH_SYNC_IS using decoder 14
15425 // 177: }
15426 // 177: } // switch Inst[24:15]
15427 // 177: }
15428 1, 172, 1, // 181: case 0x1: {
15429 OPC_SwitchField, 20, 5, // 184: switch Inst[24:20] {
15430 1, 11, // 187: case 0x1: {
15431 OPC_CheckPredicate, 166, 1, // 189: check predicate 166
15432 OPC_CheckField, 0, 12, 11, // 192: check Inst[11:0] == 0xb
15433 OPC_Decode, 217, 124, 15, // 196: decode to TH_DCACHE_CSW using decoder 15
15434 // 196: }
15435 2, 11, // 200: case 0x2: {
15436 OPC_CheckPredicate, 166, 1, // 202: check predicate 166
15437 OPC_CheckField, 0, 12, 11, // 205: check Inst[11:0] == 0xb
15438 OPC_Decode, 222, 124, 15, // 209: decode to TH_DCACHE_ISW using decoder 15
15439 // 209: }
15440 3, 11, // 213: case 0x3: {
15441 OPC_CheckPredicate, 166, 1, // 215: check predicate 166
15442 OPC_CheckField, 0, 12, 11, // 218: check Inst[11:0] == 0xb
15443 OPC_Decode, 213, 124, 15, // 222: decode to TH_DCACHE_CISW using decoder 15
15444 // 222: }
15445 4, 11, // 226: case 0x4: {
15446 OPC_CheckPredicate, 166, 1, // 228: check predicate 166
15447 OPC_CheckField, 0, 12, 11, // 231: check Inst[11:0] == 0xb
15448 OPC_Decode, 219, 124, 15, // 235: decode to TH_DCACHE_CVAL1 using decoder 15
15449 // 235: }
15450 5, 11, // 239: case 0x5: {
15451 OPC_CheckPredicate, 166, 1, // 241: check predicate 166
15452 OPC_CheckField, 0, 12, 11, // 244: check Inst[11:0] == 0xb
15453 OPC_Decode, 218, 124, 15, // 248: decode to TH_DCACHE_CVA using decoder 15
15454 // 248: }
15455 6, 11, // 252: case 0x6: {
15456 OPC_CheckPredicate, 166, 1, // 254: check predicate 166
15457 OPC_CheckField, 0, 12, 11, // 257: check Inst[11:0] == 0xb
15458 OPC_Decode, 223, 124, 15, // 261: decode to TH_DCACHE_IVA using decoder 15
15459 // 261: }
15460 7, 11, // 265: case 0x7: {
15461 OPC_CheckPredicate, 166, 1, // 267: check predicate 166
15462 OPC_CheckField, 0, 12, 11, // 270: check Inst[11:0] == 0xb
15463 OPC_Decode, 214, 124, 15, // 274: decode to TH_DCACHE_CIVA using decoder 15
15464 // 274: }
15465 8, 11, // 278: case 0x8: {
15466 OPC_CheckPredicate, 166, 1, // 280: check predicate 166
15467 OPC_CheckField, 0, 12, 11, // 283: check Inst[11:0] == 0xb
15468 OPC_Decode, 216, 124, 15, // 287: decode to TH_DCACHE_CPAL1 using decoder 15
15469 // 287: }
15470 9, 11, // 291: case 0x9: {
15471 OPC_CheckPredicate, 166, 1, // 293: check predicate 166
15472 OPC_CheckField, 0, 12, 11, // 296: check Inst[11:0] == 0xb
15473 OPC_Decode, 215, 124, 15, // 300: decode to TH_DCACHE_CPA using decoder 15
15474 // 300: }
15475 10, 11, // 304: case 0xa: {
15476 OPC_CheckPredicate, 166, 1, // 306: check predicate 166
15477 OPC_CheckField, 0, 12, 11, // 309: check Inst[11:0] == 0xb
15478 OPC_Decode, 221, 124, 15, // 313: decode to TH_DCACHE_IPA using decoder 15
15479 // 313: }
15480 11, 11, // 317: case 0xb: {
15481 OPC_CheckPredicate, 166, 1, // 319: check predicate 166
15482 OPC_CheckField, 0, 12, 11, // 322: check Inst[11:0] == 0xb
15483 OPC_Decode, 212, 124, 15, // 326: decode to TH_DCACHE_CIPA using decoder 15
15484 // 326: }
15485 16, 11, // 330: case 0x10: {
15486 OPC_CheckPredicate, 166, 1, // 332: check predicate 166
15487 OPC_CheckField, 0, 12, 11, // 335: check Inst[11:0] == 0xb
15488 OPC_Decode, 239, 124, 15, // 339: decode to TH_ICACHE_IVA using decoder 15
15489 // 339: }
15490 24, 0, // 343: case 0x18: {
15491 OPC_CheckPredicate, 166, 1, // 345: check predicate 166
15492 OPC_CheckField, 0, 12, 11, // 348: check Inst[11:0] == 0xb
15493 OPC_Decode, 238, 124, 15, // 352: decode to TH_ICACHE_IPA using decoder 15
15494 // 352: }
15495 // 352: } // switch Inst[24:20]
15496 // 352: }
15497 2, 0, // 356: case 0x2: {
15498 OPC_CheckPredicate, 167, 1, // 358: check predicate 167
15499 OPC_CheckField, 0, 12, 11, // 361: check Inst[11:0] == 0xb
15500 OPC_Decode, 161, 125, 151, 1, // 365: decode to TH_SFENCE_VMAS using decoder 151
15501 // 365: }
15502 // 365: } // switch Inst[31:25]
15503 // 365: }
15504 1, 134, 2, // 370: case 0x1: {
15505 OPC_SwitchField, 27, 5, // 373: switch Inst[31:27] {
15506 0, 12, // 376: case 0x0: {
15507 OPC_CheckPredicate, 168, 1, // 378: check predicate 168
15508 OPC_CheckField, 0, 7, 11, // 381: check Inst[6:0] == 0xb
15509 OPC_Decode, 209, 124, 139, 2, // 385: decode to TH_ADDSL using decoder 267
15510 // 385: }
15511 2, 33, // 390: case 0x2: {
15512 OPC_SwitchField, 26, 1, // 392: switch Inst[26] {
15513 0, 11, // 395: case 0x0: {
15514 OPC_CheckPredicate, 169, 1, // 397: check predicate 169
15515 OPC_CheckField, 0, 7, 11, // 400: check Inst[6:0] == 0xb
15516 OPC_Decode, 167, 125, 16, // 404: decode to TH_SRRI using decoder 16
15517 // 404: }
15518 1, 0, // 408: case 0x1: {
15519 OPC_CheckPredicate, 170, 1, // 410: check predicate 170
15520 OPC_CheckField, 25, 1, 0, // 413: check Inst[25] == 0x0
15521 OPC_CheckField, 0, 7, 11, // 417: check Inst[6:0] == 0xb
15522 OPC_Decode, 168, 125, 21, // 421: decode to TH_SRRIW using decoder 21
15523 // 421: }
15524 // 421: } // switch Inst[26]
15525 // 421: }
15526 4, 55, // 425: case 0x4: {
15527 OPC_SwitchField, 25, 2, // 427: switch Inst[26:25] {
15528 0, 11, // 430: case 0x0: {
15529 OPC_CheckPredicate, 171, 1, // 432: check predicate 171
15530 OPC_CheckField, 0, 7, 11, // 435: check Inst[6:0] == 0xb
15531 OPC_Decode, 146, 125, 59, // 439: decode to TH_MULA using decoder 59
15532 // 439: }
15533 1, 11, // 443: case 0x1: {
15534 OPC_CheckPredicate, 171, 1, // 445: check predicate 171
15535 OPC_CheckField, 0, 7, 11, // 448: check Inst[6:0] == 0xb
15536 OPC_Decode, 149, 125, 59, // 452: decode to TH_MULS using decoder 59
15537 // 452: }
15538 2, 11, // 456: case 0x2: {
15539 OPC_CheckPredicate, 172, 1, // 458: check predicate 172
15540 OPC_CheckField, 0, 7, 11, // 461: check Inst[6:0] == 0xb
15541 OPC_Decode, 148, 125, 59, // 465: decode to TH_MULAW using decoder 59
15542 // 465: }
15543 3, 0, // 469: case 0x3: {
15544 OPC_CheckPredicate, 172, 1, // 471: check predicate 172
15545 OPC_CheckField, 0, 7, 11, // 474: check Inst[6:0] == 0xb
15546 OPC_Decode, 151, 125, 59, // 478: decode to TH_MULSW using decoder 59
15547 // 478: }
15548 // 478: } // switch Inst[26:25]
15549 // 478: }
15550 5, 29, // 482: case 0x5: {
15551 OPC_SwitchField, 25, 2, // 484: switch Inst[26:25] {
15552 0, 11, // 487: case 0x0: {
15553 OPC_CheckPredicate, 171, 1, // 489: check predicate 171
15554 OPC_CheckField, 0, 7, 11, // 492: check Inst[6:0] == 0xb
15555 OPC_Decode, 147, 125, 59, // 496: decode to TH_MULAH using decoder 59
15556 // 496: }
15557 1, 0, // 500: case 0x1: {
15558 OPC_CheckPredicate, 171, 1, // 502: check predicate 171
15559 OPC_CheckField, 0, 7, 11, // 505: check Inst[6:0] == 0xb
15560 OPC_Decode, 150, 125, 59, // 509: decode to TH_MULSH using decoder 59
15561 // 509: }
15562 // 509: } // switch Inst[26:25]
15563 // 509: }
15564 8, 29, // 513: case 0x8: {
15565 OPC_SwitchField, 25, 2, // 515: switch Inst[26:25] {
15566 0, 11, // 518: case 0x0: {
15567 OPC_CheckPredicate, 173, 1, // 520: check predicate 173
15568 OPC_CheckField, 0, 7, 11, // 523: check Inst[6:0] == 0xb
15569 OPC_Decode, 152, 125, 59, // 527: decode to TH_MVEQZ using decoder 59
15570 // 527: }
15571 1, 0, // 531: case 0x1: {
15572 OPC_CheckPredicate, 173, 1, // 533: check predicate 173
15573 OPC_CheckField, 0, 7, 11, // 536: check Inst[6:0] == 0xb
15574 OPC_Decode, 153, 125, 59, // 540: decode to TH_MVNEZ using decoder 59
15575 // 540: }
15576 // 540: } // switch Inst[26:25]
15577 // 540: }
15578 16, 55, // 544: case 0x10: {
15579 OPC_SwitchField, 20, 7, // 546: switch Inst[26:20] {
15580 0, 11, // 549: case 0x0: {
15581 OPC_CheckPredicate, 169, 1, // 551: check predicate 169
15582 OPC_CheckField, 0, 7, 11, // 554: check Inst[6:0] == 0xb
15583 OPC_Decode, 182, 125, 17, // 558: decode to TH_TSTNBZ using decoder 17
15584 // 558: }
15585 32, 11, // 562: case 0x20: {
15586 OPC_CheckPredicate, 169, 1, // 564: check predicate 169
15587 OPC_CheckField, 0, 7, 11, // 567: check Inst[6:0] == 0xb
15588 OPC_Decode, 154, 125, 17, // 571: decode to TH_REV using decoder 17
15589 // 571: }
15590 64, 11, // 575: case 0x40: {
15591 OPC_CheckPredicate, 169, 1, // 577: check predicate 169
15592 OPC_CheckField, 0, 7, 11, // 580: check Inst[6:0] == 0xb
15593 OPC_Decode, 226, 124, 17, // 584: decode to TH_FF0 using decoder 17
15594 // 584: }
15595 96, 0, // 588: case 0x60: {
15596 OPC_CheckPredicate, 169, 1, // 590: check predicate 169
15597 OPC_CheckField, 0, 7, 11, // 593: check Inst[6:0] == 0xb
15598 OPC_Decode, 227, 124, 17, // 597: decode to TH_FF1 using decoder 17
15599 // 597: }
15600 // 597: } // switch Inst[26:20]
15601 // 597: }
15602 17, 15, // 601: case 0x11: {
15603 OPC_CheckPredicate, 174, 1, // 603: check predicate 174
15604 OPC_CheckField, 26, 1, 0, // 606: check Inst[26] == 0x0
15605 OPC_CheckField, 0, 7, 11, // 610: check Inst[6:0] == 0xb
15606 OPC_Decode, 181, 125, 16, // 614: decode to TH_TST using decoder 16
15607 // 614: }
15608 18, 0, // 618: case 0x12: {
15609 OPC_CheckPredicate, 170, 1, // 620: check predicate 170
15610 OPC_CheckField, 20, 7, 0, // 623: check Inst[26:20] == 0x0
15611 OPC_CheckField, 0, 7, 11, // 627: check Inst[6:0] == 0xb
15612 OPC_Decode, 155, 125, 17, // 631: decode to TH_REVW using decoder 17
15613 // 631: }
15614 // 631: } // switch Inst[31:27]
15615 // 631: }
15616 2, 12, // 635: case 0x2: {
15617 OPC_CheckPredicate, 169, 1, // 637: check predicate 169
15618 OPC_CheckField, 0, 7, 11, // 640: check Inst[6:0] == 0xb
15619 OPC_Decode, 224, 124, 206, 1, // 644: decode to TH_EXT using decoder 206
15620 // 644: }
15621 3, 12, // 649: case 0x3: {
15622 OPC_CheckPredicate, 169, 1, // 651: check predicate 169
15623 OPC_CheckField, 0, 7, 11, // 654: check Inst[6:0] == 0xb
15624 OPC_Decode, 225, 124, 206, 1, // 658: decode to TH_EXTU using decoder 206
15625 // 658: }
15626 4, 181, 3, // 663: case 0x4: {
15627 OPC_SwitchField, 27, 5, // 666: switch Inst[31:27] {
15628 0, 12, // 669: case 0x0: {
15629 OPC_CheckPredicate, 175, 1, // 671: check predicate 175
15630 OPC_CheckField, 0, 7, 11, // 674: check Inst[6:0] == 0xb
15631 OPC_Decode, 254, 124, 139, 2, // 678: decode to TH_LRB using decoder 267
15632 // 678: }
15633 1, 12, // 683: case 0x1: {
15634 OPC_CheckPredicate, 175, 1, // 685: check predicate 175
15635 OPC_CheckField, 0, 7, 11, // 688: check Inst[6:0] == 0xb
15636 OPC_Decode, 244, 124, 140, 2, // 692: decode to TH_LBIB using decoder 268
15637 // 692: }
15638 2, 12, // 697: case 0x2: {
15639 OPC_CheckPredicate, 175, 1, // 699: check predicate 175
15640 OPC_CheckField, 0, 7, 11, // 702: check Inst[6:0] == 0xb
15641 OPC_Decode, 133, 125, 139, 2, // 706: decode to TH_LURB using decoder 267
15642 // 706: }
15643 3, 12, // 711: case 0x3: {
15644 OPC_CheckPredicate, 175, 1, // 713: check predicate 175
15645 OPC_CheckField, 0, 7, 11, // 716: check Inst[6:0] == 0xb
15646 OPC_Decode, 243, 124, 140, 2, // 720: decode to TH_LBIA using decoder 268
15647 // 720: }
15648 4, 12, // 725: case 0x4: {
15649 OPC_CheckPredicate, 175, 1, // 727: check predicate 175
15650 OPC_CheckField, 0, 7, 11, // 730: check Inst[6:0] == 0xb
15651 OPC_Decode, 129, 125, 139, 2, // 734: decode to TH_LRH using decoder 267
15652 // 734: }
15653 5, 12, // 739: case 0x5: {
15654 OPC_CheckPredicate, 175, 1, // 741: check predicate 175
15655 OPC_CheckField, 0, 7, 11, // 744: check Inst[6:0] == 0xb
15656 OPC_Decode, 251, 124, 140, 2, // 748: decode to TH_LHIB using decoder 268
15657 // 748: }
15658 6, 12, // 753: case 0x6: {
15659 OPC_CheckPredicate, 175, 1, // 755: check predicate 175
15660 OPC_CheckField, 0, 7, 11, // 758: check Inst[6:0] == 0xb
15661 OPC_Decode, 136, 125, 139, 2, // 762: decode to TH_LURH using decoder 267
15662 // 762: }
15663 7, 12, // 767: case 0x7: {
15664 OPC_CheckPredicate, 175, 1, // 769: check predicate 175
15665 OPC_CheckField, 0, 7, 11, // 772: check Inst[6:0] == 0xb
15666 OPC_Decode, 250, 124, 140, 2, // 776: decode to TH_LHIA using decoder 268
15667 // 776: }
15668 8, 12, // 781: case 0x8: {
15669 OPC_CheckPredicate, 175, 1, // 783: check predicate 175
15670 OPC_CheckField, 0, 7, 11, // 786: check Inst[6:0] == 0xb
15671 OPC_Decode, 131, 125, 139, 2, // 790: decode to TH_LRW using decoder 267
15672 // 790: }
15673 9, 12, // 795: case 0x9: {
15674 OPC_CheckPredicate, 175, 1, // 797: check predicate 175
15675 OPC_CheckField, 0, 7, 11, // 800: check Inst[6:0] == 0xb
15676 OPC_Decode, 142, 125, 140, 2, // 804: decode to TH_LWIB using decoder 268
15677 // 804: }
15678 10, 12, // 809: case 0xa: {
15679 OPC_CheckPredicate, 175, 1, // 811: check predicate 175
15680 OPC_CheckField, 0, 7, 11, // 814: check Inst[6:0] == 0xb
15681 OPC_Decode, 138, 125, 139, 2, // 818: decode to TH_LURW using decoder 267
15682 // 818: }
15683 11, 12, // 823: case 0xb: {
15684 OPC_CheckPredicate, 175, 1, // 825: check predicate 175
15685 OPC_CheckField, 0, 7, 11, // 828: check Inst[6:0] == 0xb
15686 OPC_Decode, 141, 125, 140, 2, // 832: decode to TH_LWIA using decoder 268
15687 // 832: }
15688 12, 12, // 837: case 0xc: {
15689 OPC_CheckPredicate, 176, 1, // 839: check predicate 176
15690 OPC_CheckField, 0, 7, 11, // 842: check Inst[6:0] == 0xb
15691 OPC_Decode, 128, 125, 139, 2, // 846: decode to TH_LRD using decoder 267
15692 // 846: }
15693 13, 12, // 851: case 0xd: {
15694 OPC_CheckPredicate, 176, 1, // 853: check predicate 176
15695 OPC_CheckField, 0, 7, 11, // 856: check Inst[6:0] == 0xb
15696 OPC_Decode, 249, 124, 140, 2, // 860: decode to TH_LDIB using decoder 268
15697 // 860: }
15698 14, 12, // 865: case 0xe: {
15699 OPC_CheckPredicate, 176, 1, // 867: check predicate 176
15700 OPC_CheckField, 0, 7, 11, // 870: check Inst[6:0] == 0xb
15701 OPC_Decode, 135, 125, 139, 2, // 874: decode to TH_LURD using decoder 267
15702 // 874: }
15703 15, 12, // 879: case 0xf: {
15704 OPC_CheckPredicate, 176, 1, // 881: check predicate 176
15705 OPC_CheckField, 0, 7, 11, // 884: check Inst[6:0] == 0xb
15706 OPC_Decode, 248, 124, 140, 2, // 888: decode to TH_LDIA using decoder 268
15707 // 888: }
15708 16, 12, // 893: case 0x10: {
15709 OPC_CheckPredicate, 175, 1, // 895: check predicate 175
15710 OPC_CheckField, 0, 7, 11, // 898: check Inst[6:0] == 0xb
15711 OPC_Decode, 255, 124, 139, 2, // 902: decode to TH_LRBU using decoder 267
15712 // 902: }
15713 17, 12, // 907: case 0x11: {
15714 OPC_CheckPredicate, 175, 1, // 909: check predicate 175
15715 OPC_CheckField, 0, 7, 11, // 912: check Inst[6:0] == 0xb
15716 OPC_Decode, 246, 124, 140, 2, // 916: decode to TH_LBUIB using decoder 268
15717 // 916: }
15718 18, 12, // 921: case 0x12: {
15719 OPC_CheckPredicate, 175, 1, // 923: check predicate 175
15720 OPC_CheckField, 0, 7, 11, // 926: check Inst[6:0] == 0xb
15721 OPC_Decode, 134, 125, 139, 2, // 930: decode to TH_LURBU using decoder 267
15722 // 930: }
15723 19, 12, // 935: case 0x13: {
15724 OPC_CheckPredicate, 175, 1, // 937: check predicate 175
15725 OPC_CheckField, 0, 7, 11, // 940: check Inst[6:0] == 0xb
15726 OPC_Decode, 245, 124, 140, 2, // 944: decode to TH_LBUIA using decoder 268
15727 // 944: }
15728 20, 12, // 949: case 0x14: {
15729 OPC_CheckPredicate, 175, 1, // 951: check predicate 175
15730 OPC_CheckField, 0, 7, 11, // 954: check Inst[6:0] == 0xb
15731 OPC_Decode, 130, 125, 139, 2, // 958: decode to TH_LRHU using decoder 267
15732 // 958: }
15733 21, 12, // 963: case 0x15: {
15734 OPC_CheckPredicate, 175, 1, // 965: check predicate 175
15735 OPC_CheckField, 0, 7, 11, // 968: check Inst[6:0] == 0xb
15736 OPC_Decode, 253, 124, 140, 2, // 972: decode to TH_LHUIB using decoder 268
15737 // 972: }
15738 22, 12, // 977: case 0x16: {
15739 OPC_CheckPredicate, 175, 1, // 979: check predicate 175
15740 OPC_CheckField, 0, 7, 11, // 982: check Inst[6:0] == 0xb
15741 OPC_Decode, 137, 125, 139, 2, // 986: decode to TH_LURHU using decoder 267
15742 // 986: }
15743 23, 12, // 991: case 0x17: {
15744 OPC_CheckPredicate, 175, 1, // 993: check predicate 175
15745 OPC_CheckField, 0, 7, 11, // 996: check Inst[6:0] == 0xb
15746 OPC_Decode, 252, 124, 140, 2, // 1000: decode to TH_LHUIA using decoder 268
15747 // 1000: }
15748 24, 12, // 1005: case 0x18: {
15749 OPC_CheckPredicate, 176, 1, // 1007: check predicate 176
15750 OPC_CheckField, 0, 7, 11, // 1010: check Inst[6:0] == 0xb
15751 OPC_Decode, 132, 125, 139, 2, // 1014: decode to TH_LRWU using decoder 267
15752 // 1014: }
15753 25, 12, // 1019: case 0x19: {
15754 OPC_CheckPredicate, 176, 1, // 1021: check predicate 176
15755 OPC_CheckField, 0, 7, 11, // 1024: check Inst[6:0] == 0xb
15756 OPC_Decode, 145, 125, 140, 2, // 1028: decode to TH_LWUIB using decoder 268
15757 // 1028: }
15758 26, 12, // 1033: case 0x1a: {
15759 OPC_CheckPredicate, 176, 1, // 1035: check predicate 176
15760 OPC_CheckField, 0, 7, 11, // 1038: check Inst[6:0] == 0xb
15761 OPC_Decode, 139, 125, 139, 2, // 1042: decode to TH_LURWU using decoder 267
15762 // 1042: }
15763 27, 12, // 1047: case 0x1b: {
15764 OPC_CheckPredicate, 176, 1, // 1049: check predicate 176
15765 OPC_CheckField, 0, 7, 11, // 1052: check Inst[6:0] == 0xb
15766 OPC_Decode, 144, 125, 140, 2, // 1056: decode to TH_LWUIA using decoder 268
15767 // 1056: }
15768 28, 12, // 1061: case 0x1c: {
15769 OPC_CheckPredicate, 177, 1, // 1063: check predicate 177
15770 OPC_CheckField, 0, 7, 11, // 1066: check Inst[6:0] == 0xb
15771 OPC_Decode, 140, 125, 141, 2, // 1070: decode to TH_LWD using decoder 269
15772 // 1070: }
15773 30, 12, // 1075: case 0x1e: {
15774 OPC_CheckPredicate, 177, 1, // 1077: check predicate 177
15775 OPC_CheckField, 0, 7, 11, // 1080: check Inst[6:0] == 0xb
15776 OPC_Decode, 143, 125, 141, 2, // 1084: decode to TH_LWUD using decoder 269
15777 // 1084: }
15778 31, 0, // 1089: case 0x1f: {
15779 OPC_CheckPredicate, 178, 1, // 1091: check predicate 178
15780 OPC_CheckField, 0, 7, 11, // 1094: check Inst[6:0] == 0xb
15781 OPC_Decode, 247, 124, 142, 2, // 1098: decode to TH_LDD using decoder 270
15782 // 1098: }
15783 // 1098: } // switch Inst[31:27]
15784 // 1098: }
15785 5, 255, 1, // 1103: case 0x5: {
15786 OPC_SwitchField, 27, 5, // 1106: switch Inst[31:27] {
15787 0, 12, // 1109: case 0x0: {
15788 OPC_CheckPredicate, 175, 1, // 1111: check predicate 175
15789 OPC_CheckField, 0, 7, 11, // 1114: check Inst[6:0] == 0xb
15790 OPC_Decode, 164, 125, 139, 2, // 1118: decode to TH_SRB using decoder 267
15791 // 1118: }
15792 1, 12, // 1123: case 0x1: {
15793 OPC_CheckPredicate, 175, 1, // 1125: check predicate 175
15794 OPC_CheckField, 0, 7, 11, // 1128: check Inst[6:0] == 0xb
15795 OPC_Decode, 157, 125, 143, 2, // 1132: decode to TH_SBIB using decoder 271
15796 // 1132: }
15797 2, 12, // 1137: case 0x2: {
15798 OPC_CheckPredicate, 175, 1, // 1139: check predicate 175
15799 OPC_CheckField, 0, 7, 11, // 1142: check Inst[6:0] == 0xb
15800 OPC_Decode, 170, 125, 139, 2, // 1146: decode to TH_SURB using decoder 267
15801 // 1146: }
15802 3, 12, // 1151: case 0x3: {
15803 OPC_CheckPredicate, 175, 1, // 1153: check predicate 175
15804 OPC_CheckField, 0, 7, 11, // 1156: check Inst[6:0] == 0xb
15805 OPC_Decode, 156, 125, 143, 2, // 1160: decode to TH_SBIA using decoder 271
15806 // 1160: }
15807 4, 12, // 1165: case 0x4: {
15808 OPC_CheckPredicate, 175, 1, // 1167: check predicate 175
15809 OPC_CheckField, 0, 7, 11, // 1170: check Inst[6:0] == 0xb
15810 OPC_Decode, 166, 125, 139, 2, // 1174: decode to TH_SRH using decoder 267
15811 // 1174: }
15812 5, 12, // 1179: case 0x5: {
15813 OPC_CheckPredicate, 175, 1, // 1181: check predicate 175
15814 OPC_CheckField, 0, 7, 11, // 1184: check Inst[6:0] == 0xb
15815 OPC_Decode, 163, 125, 143, 2, // 1188: decode to TH_SHIB using decoder 271
15816 // 1188: }
15817 6, 12, // 1193: case 0x6: {
15818 OPC_CheckPredicate, 175, 1, // 1195: check predicate 175
15819 OPC_CheckField, 0, 7, 11, // 1198: check Inst[6:0] == 0xb
15820 OPC_Decode, 172, 125, 139, 2, // 1202: decode to TH_SURH using decoder 267
15821 // 1202: }
15822 7, 12, // 1207: case 0x7: {
15823 OPC_CheckPredicate, 175, 1, // 1209: check predicate 175
15824 OPC_CheckField, 0, 7, 11, // 1212: check Inst[6:0] == 0xb
15825 OPC_Decode, 162, 125, 143, 2, // 1216: decode to TH_SHIA using decoder 271
15826 // 1216: }
15827 8, 12, // 1221: case 0x8: {
15828 OPC_CheckPredicate, 175, 1, // 1223: check predicate 175
15829 OPC_CheckField, 0, 7, 11, // 1226: check Inst[6:0] == 0xb
15830 OPC_Decode, 169, 125, 139, 2, // 1230: decode to TH_SRW using decoder 267
15831 // 1230: }
15832 9, 12, // 1235: case 0x9: {
15833 OPC_CheckPredicate, 175, 1, // 1237: check predicate 175
15834 OPC_CheckField, 0, 7, 11, // 1240: check Inst[6:0] == 0xb
15835 OPC_Decode, 176, 125, 143, 2, // 1244: decode to TH_SWIB using decoder 271
15836 // 1244: }
15837 10, 12, // 1249: case 0xa: {
15838 OPC_CheckPredicate, 175, 1, // 1251: check predicate 175
15839 OPC_CheckField, 0, 7, 11, // 1254: check Inst[6:0] == 0xb
15840 OPC_Decode, 173, 125, 139, 2, // 1258: decode to TH_SURW using decoder 267
15841 // 1258: }
15842 11, 12, // 1263: case 0xb: {
15843 OPC_CheckPredicate, 175, 1, // 1265: check predicate 175
15844 OPC_CheckField, 0, 7, 11, // 1268: check Inst[6:0] == 0xb
15845 OPC_Decode, 175, 125, 143, 2, // 1272: decode to TH_SWIA using decoder 271
15846 // 1272: }
15847 12, 12, // 1277: case 0xc: {
15848 OPC_CheckPredicate, 176, 1, // 1279: check predicate 176
15849 OPC_CheckField, 0, 7, 11, // 1282: check Inst[6:0] == 0xb
15850 OPC_Decode, 165, 125, 139, 2, // 1286: decode to TH_SRD using decoder 267
15851 // 1286: }
15852 13, 12, // 1291: case 0xd: {
15853 OPC_CheckPredicate, 176, 1, // 1293: check predicate 176
15854 OPC_CheckField, 0, 7, 11, // 1296: check Inst[6:0] == 0xb
15855 OPC_Decode, 160, 125, 143, 2, // 1300: decode to TH_SDIB using decoder 271
15856 // 1300: }
15857 14, 12, // 1305: case 0xe: {
15858 OPC_CheckPredicate, 176, 1, // 1307: check predicate 176
15859 OPC_CheckField, 0, 7, 11, // 1310: check Inst[6:0] == 0xb
15860 OPC_Decode, 171, 125, 139, 2, // 1314: decode to TH_SURD using decoder 267
15861 // 1314: }
15862 15, 12, // 1319: case 0xf: {
15863 OPC_CheckPredicate, 176, 1, // 1321: check predicate 176
15864 OPC_CheckField, 0, 7, 11, // 1324: check Inst[6:0] == 0xb
15865 OPC_Decode, 159, 125, 143, 2, // 1328: decode to TH_SDIA using decoder 271
15866 // 1328: }
15867 28, 12, // 1333: case 0x1c: {
15868 OPC_CheckPredicate, 177, 1, // 1335: check predicate 177
15869 OPC_CheckField, 0, 7, 11, // 1338: check Inst[6:0] == 0xb
15870 OPC_Decode, 174, 125, 141, 2, // 1342: decode to TH_SWD using decoder 269
15871 // 1342: }
15872 31, 0, // 1347: case 0x1f: {
15873 OPC_CheckPredicate, 178, 1, // 1349: check predicate 178
15874 OPC_CheckField, 0, 7, 11, // 1352: check Inst[6:0] == 0xb
15875 OPC_Decode, 158, 125, 142, 2, // 1356: decode to TH_SDD using decoder 270
15876 // 1356: }
15877 // 1356: } // switch Inst[31:27]
15878 // 1356: }
15879 6, 173, 1, // 1361: case 0x6: {
15880 OPC_SwitchField, 27, 5, // 1364: switch Inst[31:27] {
15881 8, 12, // 1367: case 0x8: {
15882 OPC_CheckPredicate, 179, 1, // 1369: check predicate 179
15883 OPC_CheckField, 0, 7, 11, // 1372: check Inst[6:0] == 0xb
15884 OPC_Decode, 229, 124, 144, 2, // 1376: decode to TH_FLRW using decoder 272
15885 // 1376: }
15886 10, 12, // 1381: case 0xa: {
15887 OPC_CheckPredicate, 180, 1, // 1383: check predicate 180
15888 OPC_CheckField, 0, 7, 11, // 1386: check Inst[6:0] == 0xb
15889 OPC_Decode, 231, 124, 144, 2, // 1390: decode to TH_FLURW using decoder 272
15890 // 1390: }
15891 12, 12, // 1395: case 0xc: {
15892 OPC_CheckPredicate, 181, 1, // 1397: check predicate 181
15893 OPC_CheckField, 0, 7, 11, // 1400: check Inst[6:0] == 0xb
15894 OPC_Decode, 228, 124, 145, 2, // 1404: decode to TH_FLRD using decoder 273
15895 // 1404: }
15896 14, 12, // 1409: case 0xe: {
15897 OPC_CheckPredicate, 182, 1, // 1411: check predicate 182
15898 OPC_CheckField, 0, 7, 11, // 1414: check Inst[6:0] == 0xb
15899 OPC_Decode, 230, 124, 145, 2, // 1418: decode to TH_FLURD using decoder 273
15900 // 1418: }
15901 16, 30, // 1423: case 0x10: {
15902 OPC_SwitchField, 26, 1, // 1425: switch Inst[26] {
15903 0, 11, // 1428: case 0x0: {
15904 OPC_CheckPredicate, 183, 1, // 1430: check predicate 183
15905 OPC_CheckField, 0, 7, 11, // 1433: check Inst[6:0] == 0xb
15906 OPC_Decode, 188, 125, 120, // 1437: decode to TH_VMAQA_VV using decoder 120
15907 // 1437: }
15908 1, 0, // 1441: case 0x1: {
15909 OPC_CheckPredicate, 183, 1, // 1443: check predicate 183
15910 OPC_CheckField, 0, 7, 11, // 1446: check Inst[6:0] == 0xb
15911 OPC_Decode, 189, 125, 145, 1, // 1450: decode to TH_VMAQA_VX using decoder 145
15912 // 1450: }
15913 // 1450: } // switch Inst[26]
15914 // 1450: }
15915 17, 30, // 1455: case 0x11: {
15916 OPC_SwitchField, 26, 1, // 1457: switch Inst[26] {
15917 0, 11, // 1460: case 0x0: {
15918 OPC_CheckPredicate, 183, 1, // 1462: check predicate 183
15919 OPC_CheckField, 0, 7, 11, // 1465: check Inst[6:0] == 0xb
15920 OPC_Decode, 186, 125, 120, // 1469: decode to TH_VMAQAU_VV using decoder 120
15921 // 1469: }
15922 1, 0, // 1473: case 0x1: {
15923 OPC_CheckPredicate, 183, 1, // 1475: check predicate 183
15924 OPC_CheckField, 0, 7, 11, // 1478: check Inst[6:0] == 0xb
15925 OPC_Decode, 187, 125, 145, 1, // 1482: decode to TH_VMAQAU_VX using decoder 145
15926 // 1482: }
15927 // 1482: } // switch Inst[26]
15928 // 1482: }
15929 18, 30, // 1487: case 0x12: {
15930 OPC_SwitchField, 26, 1, // 1489: switch Inst[26] {
15931 0, 11, // 1492: case 0x0: {
15932 OPC_CheckPredicate, 183, 1, // 1494: check predicate 183
15933 OPC_CheckField, 0, 7, 11, // 1497: check Inst[6:0] == 0xb
15934 OPC_Decode, 183, 125, 120, // 1501: decode to TH_VMAQASU_VV using decoder 120
15935 // 1501: }
15936 1, 0, // 1505: case 0x1: {
15937 OPC_CheckPredicate, 183, 1, // 1507: check predicate 183
15938 OPC_CheckField, 0, 7, 11, // 1510: check Inst[6:0] == 0xb
15939 OPC_Decode, 184, 125, 145, 1, // 1514: decode to TH_VMAQASU_VX using decoder 145
15940 // 1514: }
15941 // 1514: } // switch Inst[26]
15942 // 1514: }
15943 19, 0, // 1519: case 0x13: {
15944 OPC_CheckPredicate, 183, 1, // 1521: check predicate 183
15945 OPC_CheckField, 26, 1, 1, // 1524: check Inst[26] == 0x1
15946 OPC_CheckField, 0, 7, 11, // 1528: check Inst[6:0] == 0xb
15947 OPC_Decode, 185, 125, 145, 1, // 1532: decode to TH_VMAQAUS_VX using decoder 145
15948 // 1532: }
15949 // 1532: } // switch Inst[31:27]
15950 // 1532: }
15951 7, 0, // 1537: case 0x7: {
15952 OPC_SwitchField, 27, 5, // 1539: switch Inst[31:27] {
15953 8, 12, // 1542: case 0x8: {
15954 OPC_CheckPredicate, 179, 1, // 1544: check predicate 179
15955 OPC_CheckField, 0, 7, 11, // 1547: check Inst[6:0] == 0xb
15956 OPC_Decode, 233, 124, 144, 2, // 1551: decode to TH_FSRW using decoder 272
15957 // 1551: }
15958 10, 12, // 1556: case 0xa: {
15959 OPC_CheckPredicate, 180, 1, // 1558: check predicate 180
15960 OPC_CheckField, 0, 7, 11, // 1561: check Inst[6:0] == 0xb
15961 OPC_Decode, 235, 124, 144, 2, // 1565: decode to TH_FSURW using decoder 272
15962 // 1565: }
15963 12, 12, // 1570: case 0xc: {
15964 OPC_CheckPredicate, 181, 1, // 1572: check predicate 181
15965 OPC_CheckField, 0, 7, 11, // 1575: check Inst[6:0] == 0xb
15966 OPC_Decode, 232, 124, 145, 2, // 1579: decode to TH_FSRD using decoder 273
15967 // 1579: }
15968 14, 0, // 1584: case 0xe: {
15969 OPC_CheckPredicate, 182, 1, // 1586: check predicate 182
15970 OPC_CheckField, 0, 7, 11, // 1589: check Inst[6:0] == 0xb
15971 OPC_Decode, 234, 124, 145, 2, // 1593: decode to TH_FSURD using decoder 273
15972 // 1593: }
15973 // 1593: } // switch Inst[31:27]
15974 // 1593: }
15975 // 1593: } // switch Inst[14:12]
15976};
15977static const uint8_t DecoderTableXVentana32[40] = {
15978 32, // 0: BitWidth 32
15979 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
15980 6, 16, // 4: case 0x6: {
15981 OPC_CheckPredicate, 184, 1, // 6: check predicate 184
15982 OPC_CheckField, 25, 7, 0, // 9: check Inst[31:25] == 0x0
15983 OPC_CheckField, 0, 7, 123, // 13: check Inst[6:0] == 0x7b
15984 OPC_Decode, 140, 131, 1, 31, // 17: decode to VT_MASKC using decoder 31
15985 // 17: }
15986 7, 0, // 22: case 0x7: {
15987 OPC_CheckPredicate, 184, 1, // 24: check predicate 184
15988 OPC_CheckField, 25, 7, 0, // 27: check Inst[31:25] == 0x0
15989 OPC_CheckField, 0, 7, 123, // 31: check Inst[6:0] == 0x7b
15990 OPC_Decode, 141, 131, 1, 31, // 35: decode to VT_MASKCN using decoder 31
15991 // 35: }
15992 // 35: } // switch Inst[14:12]
15993};
15994static const uint8_t DecoderTableXqci32[1203] = {
15995 32, // 0: BitWidth 32
15996 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
15997 11, 143, 4, // 4: case 0xb: {
15998 OPC_SwitchField, 12, 3, // 7: switch Inst[14:12] {
15999 0, 22, // 10: case 0x0: {
16000 OPC_SwitchField, 31, 1, // 12: switch Inst[31] {
16001 0, 8, // 15: case 0x0: {
16002 OPC_CheckPredicate, 185, 1, // 17: check predicate 185
16003 OPC_Decode, 250, 122, 146, 2, // 20: decode to QC_WRAPI using decoder 274
16004 // 20: }
16005 1, 0, // 25: case 0x1: {
16006 OPC_CheckPredicate, 13, // 27: check predicate 13
16007 OPC_Decode, 184, 122, 147, 2, // 29: decode to QC_INSBRI using decoder 275
16008 // 29: }
16009 // 29: } // switch Inst[31]
16010 // 29: }
16011 1, 30, // 34: case 0x1: {
16012 OPC_SwitchField, 30, 2, // 36: switch Inst[31:30] {
16013 0, 7, // 39: case 0x0: {
16014 OPC_CheckPredicate, 13, // 41: check predicate 13
16015 OPC_Decode, 180, 122, 148, 2, // 43: decode to QC_INSBI using decoder 276
16016 // 43: }
16017 1, 7, // 48: case 0x1: {
16018 OPC_CheckPredicate, 13, // 50: check predicate 13
16019 OPC_Decode, 177, 122, 149, 2, // 52: decode to QC_INSB using decoder 277
16020 // 52: }
16021 2, 0, // 57: case 0x2: {
16022 OPC_CheckPredicate, 13, // 59: check predicate 13
16023 OPC_Decode, 178, 122, 149, 2, // 61: decode to QC_INSBH using decoder 277
16024 // 61: }
16025 // 61: } // switch Inst[31:30]
16026 // 61: }
16027 2, 39, // 66: case 0x2: {
16028 OPC_SwitchField, 30, 2, // 68: switch Inst[31:30] {
16029 0, 7, // 71: case 0x0: {
16030 OPC_CheckPredicate, 13, // 73: check predicate 13
16031 OPC_Decode, 151, 122, 150, 2, // 75: decode to QC_EXTU using decoder 278
16032 // 75: }
16033 1, 7, // 80: case 0x1: {
16034 OPC_CheckPredicate, 13, // 82: check predicate 13
16035 OPC_Decode, 142, 122, 150, 2, // 84: decode to QC_EXT using decoder 278
16036 // 84: }
16037 2, 7, // 89: case 0x2: {
16038 OPC_CheckPredicate, 13, // 91: check predicate 13
16039 OPC_Decode, 147, 122, 151, 2, // 93: decode to QC_EXTDU using decoder 279
16040 // 93: }
16041 3, 0, // 98: case 0x3: {
16042 OPC_CheckPredicate, 13, // 100: check predicate 13
16043 OPC_Decode, 143, 122, 151, 2, // 102: decode to QC_EXTD using decoder 279
16044 // 102: }
16045 // 102: } // switch Inst[31:30]
16046 // 102: }
16047 3, 183, 2, // 107: case 0x3: {
16048 OPC_SwitchField, 30, 2, // 110: switch Inst[31:30] {
16049 0, 168, 2, // 113: case 0x0: {
16050 OPC_SwitchField, 25, 5, // 116: switch Inst[29:25] {
16051 0, 20, // 119: case 0x0: {
16052 OPC_Scope, 11, // 121: try {
16053 OPC_CheckField, 20, 5, 0, // 123: check Inst[24:20] == 0x0
16054 OPC_CheckPredicate, 13, // 127: check predicate 13
16055 OPC_Decode, 243, 121, 152, 2, // 129: decode to QC_COMPRESS2 using decoder 280
16056 // 129: } else try {
16057 OPC_CheckPredicate, 13, // 134: check predicate 13
16058 OPC_Decode, 183, 122, 153, 2, // 136: decode to QC_INSBR using decoder 281
16059 // 136: }
16060 // 136: }
16061 1, 20, // 141: case 0x1: {
16062 OPC_Scope, 11, // 143: try {
16063 OPC_CheckField, 20, 5, 0, // 145: check Inst[24:20] == 0x0
16064 OPC_CheckPredicate, 13, // 149: check predicate 13
16065 OPC_Decode, 244, 121, 152, 2, // 151: decode to QC_COMPRESS3 using decoder 280
16066 // 151: } else try {
16067 OPC_CheckPredicate, 13, // 156: check predicate 13
16068 OPC_Decode, 179, 122, 153, 2, // 158: decode to QC_INSBHR using decoder 281
16069 // 158: }
16070 // 158: }
16071 2, 20, // 163: case 0x2: {
16072 OPC_Scope, 11, // 165: try {
16073 OPC_CheckField, 20, 5, 0, // 167: check Inst[24:20] == 0x0
16074 OPC_CheckPredicate, 13, // 171: check predicate 13
16075 OPC_Decode, 140, 122, 152, 2, // 173: decode to QC_EXPAND2 using decoder 280
16076 // 173: } else try {
16077 OPC_CheckPredicate, 13, // 178: check predicate 13
16078 OPC_Decode, 181, 122, 153, 2, // 180: decode to QC_INSBPR using decoder 281
16079 // 180: }
16080 // 180: }
16081 3, 20, // 185: case 0x3: {
16082 OPC_Scope, 11, // 187: try {
16083 OPC_CheckField, 20, 5, 0, // 189: check Inst[24:20] == 0x0
16084 OPC_CheckPredicate, 13, // 193: check predicate 13
16085 OPC_Decode, 141, 122, 152, 2, // 195: decode to QC_EXPAND3 using decoder 280
16086 // 195: } else try {
16087 OPC_CheckPredicate, 13, // 200: check predicate 13
16088 OPC_Decode, 182, 122, 153, 2, // 202: decode to QC_INSBPRH using decoder 281
16089 // 202: }
16090 // 202: }
16091 4, 20, // 207: case 0x4: {
16092 OPC_Scope, 11, // 209: try {
16093 OPC_CheckField, 20, 5, 0, // 211: check Inst[24:20] == 0x0
16094 OPC_CheckPredicate, 13, // 215: check predicate 13
16095 OPC_Decode, 232, 121, 152, 2, // 217: decode to QC_CLO using decoder 280
16096 // 217: } else try {
16097 OPC_CheckPredicate, 13, // 222: check predicate 13
16098 OPC_Decode, 150, 122, 154, 2, // 224: decode to QC_EXTDUR using decoder 282
16099 // 224: }
16100 // 224: }
16101 5, 20, // 229: case 0x5: {
16102 OPC_Scope, 11, // 231: try {
16103 OPC_CheckField, 20, 5, 0, // 233: check Inst[24:20] == 0x0
16104 OPC_CheckPredicate, 13, // 237: check predicate 13
16105 OPC_Decode, 247, 121, 152, 2, // 239: decode to QC_CTO using decoder 280
16106 // 239: } else try {
16107 OPC_CheckPredicate, 13, // 244: check predicate 13
16108 OPC_Decode, 146, 122, 154, 2, // 246: decode to QC_EXTDR using decoder 282
16109 // 246: }
16110 // 246: }
16111 6, 20, // 251: case 0x6: {
16112 OPC_Scope, 11, // 253: try {
16113 OPC_CheckField, 20, 5, 0, // 255: check Inst[24:20] == 0x0
16114 OPC_CheckPredicate, 13, // 259: check predicate 13
16115 OPC_Decode, 231, 121, 152, 2, // 261: decode to QC_BREV32 using decoder 280
16116 // 261: } else try {
16117 OPC_CheckPredicate, 13, // 266: check predicate 13
16118 OPC_Decode, 148, 122, 154, 2, // 268: decode to QC_EXTDUPR using decoder 282
16119 // 268: }
16120 // 268: }
16121 7, 21, // 273: case 0x7: {
16122 OPC_Scope, 12, // 275: try {
16123 OPC_CheckField, 20, 5, 0, // 277: check Inst[24:20] == 0x0
16124 OPC_CheckPredicate, 185, 1, // 281: check predicate 185
16125 OPC_Decode, 219, 122, 152, 2, // 284: decode to QC_NORM using decoder 280
16126 // 284: } else try {
16127 OPC_CheckPredicate, 13, // 289: check predicate 13
16128 OPC_Decode, 149, 122, 154, 2, // 291: decode to QC_EXTDUPRH using decoder 282
16129 // 291: }
16130 // 291: }
16131 8, 21, // 296: case 0x8: {
16132 OPC_Scope, 12, // 298: try {
16133 OPC_CheckField, 20, 5, 0, // 300: check Inst[24:20] == 0x0
16134 OPC_CheckPredicate, 185, 1, // 304: check predicate 185
16135 OPC_Decode, 221, 122, 152, 2, // 307: decode to QC_NORMU using decoder 280
16136 // 307: } else try {
16137 OPC_CheckPredicate, 13, // 312: check predicate 13
16138 OPC_Decode, 144, 122, 154, 2, // 314: decode to QC_EXTDPR using decoder 282
16139 // 314: }
16140 // 314: }
16141 9, 21, // 319: case 0x9: {
16142 OPC_Scope, 12, // 321: try {
16143 OPC_CheckField, 20, 5, 0, // 323: check Inst[24:20] == 0x0
16144 OPC_CheckPredicate, 185, 1, // 327: check predicate 185
16145 OPC_Decode, 220, 122, 152, 2, // 330: decode to QC_NORMEU using decoder 280
16146 // 330: } else try {
16147 OPC_CheckPredicate, 13, // 335: check predicate 13
16148 OPC_Decode, 145, 122, 154, 2, // 337: decode to QC_EXTDPRH using decoder 282
16149 // 337: }
16150 // 337: }
16151 10, 8, // 342: case 0xa: {
16152 OPC_CheckPredicate, 185, 1, // 344: check predicate 185
16153 OPC_Decode, 236, 122, 155, 2, // 347: decode to QC_SHLSAT using decoder 283
16154 // 347: }
16155 12, 8, // 352: case 0xc: {
16156 OPC_CheckPredicate, 185, 1, // 354: check predicate 185
16157 OPC_Decode, 237, 122, 155, 2, // 357: decode to QC_SHLUSAT using decoder 283
16158 // 357: }
16159 14, 8, // 362: case 0xe: {
16160 OPC_CheckPredicate, 185, 1, // 364: check predicate 185
16161 OPC_Decode, 223, 121, 155, 2, // 367: decode to QC_ADDSAT using decoder 283
16162 // 367: }
16163 15, 8, // 372: case 0xf: {
16164 OPC_CheckPredicate, 185, 1, // 374: check predicate 185
16165 OPC_Decode, 224, 121, 155, 2, // 377: decode to QC_ADDUSAT using decoder 283
16166 // 377: }
16167 16, 8, // 382: case 0x10: {
16168 OPC_CheckPredicate, 185, 1, // 384: check predicate 185
16169 OPC_Decode, 241, 122, 155, 2, // 387: decode to QC_SUBSAT using decoder 283
16170 // 387: }
16171 17, 8, // 392: case 0x11: {
16172 OPC_CheckPredicate, 185, 1, // 394: check predicate 185
16173 OPC_Decode, 242, 122, 155, 2, // 397: decode to QC_SUBUSAT using decoder 283
16174 // 397: }
16175 18, 0, // 402: case 0x12: {
16176 OPC_CheckPredicate, 185, 1, // 404: check predicate 185
16177 OPC_Decode, 249, 122, 156, 2, // 407: decode to QC_WRAP using decoder 284
16178 // 407: }
16179 // 407: } // switch Inst[29:25]
16180 // 407: }
16181 1, 0, // 412: case 0x1: {
16182 OPC_CheckPredicate, 14, // 414: check predicate 14
16183 OPC_Decode, 235, 122, 157, 2, // 416: decode to QC_SHLADD using decoder 285
16184 // 416: }
16185 // 416: } // switch Inst[31:30]
16186 // 416: }
16187 4, 8, // 421: case 0x4: {
16188 OPC_CheckPredicate, 186, 1, // 423: check predicate 186
16189 OPC_Decode, 222, 122, 158, 2, // 426: decode to QC_OUTW using decoder 286
16190 // 426: }
16191 5, 8, // 431: case 0x5: {
16192 OPC_CheckPredicate, 186, 1, // 433: check predicate 186
16193 OPC_Decode, 185, 122, 159, 2, // 436: decode to QC_INW using decoder 287
16194 // 436: }
16195 6, 7, // 441: case 0x6: {
16196 OPC_CheckPredicate, 14, // 443: check predicate 14
16197 OPC_Decode, 206, 122, 160, 2, // 445: decode to QC_MULIADD using decoder 288
16198 // 445: }
16199 7, 0, // 450: case 0x7: {
16200 OPC_SwitchField, 30, 2, // 452: switch Inst[31:30] {
16201 0, 8, // 455: case 0x0: {
16202 OPC_CheckPredicate, 187, 1, // 457: check predicate 187
16203 OPC_Decode, 204, 122, 161, 2, // 460: decode to QC_LWM using decoder 289
16204 // 460: }
16205 1, 8, // 465: case 0x1: {
16206 OPC_CheckPredicate, 187, 1, // 467: check predicate 187
16207 OPC_Decode, 205, 122, 162, 2, // 470: decode to QC_LWMI using decoder 290
16208 // 470: }
16209 2, 43, // 475: case 0x2: {
16210 OPC_SwitchField, 28, 2, // 477: switch Inst[29:28] {
16211 0, 8, // 480: case 0x0: {
16212 OPC_CheckPredicate, 188, 1, // 482: check predicate 188
16213 OPC_Decode, 199, 122, 163, 2, // 485: decode to QC_LRB using decoder 291
16214 // 485: }
16215 1, 8, // 490: case 0x1: {
16216 OPC_CheckPredicate, 188, 1, // 492: check predicate 188
16217 OPC_Decode, 201, 122, 163, 2, // 495: decode to QC_LRH using decoder 291
16218 // 495: }
16219 2, 8, // 500: case 0x2: {
16220 OPC_CheckPredicate, 188, 1, // 502: check predicate 188
16221 OPC_Decode, 203, 122, 163, 2, // 505: decode to QC_LRW using decoder 291
16222 // 505: }
16223 3, 0, // 510: case 0x3: {
16224 OPC_CheckPredicate, 188, 1, // 512: check predicate 188
16225 OPC_Decode, 200, 122, 163, 2, // 515: decode to QC_LRBU using decoder 291
16226 // 515: }
16227 // 515: } // switch Inst[29:28]
16228 // 515: }
16229 3, 0, // 520: case 0x3: {
16230 OPC_CheckPredicate, 188, 1, // 522: check predicate 188
16231 OPC_CheckField, 28, 2, 0, // 525: check Inst[29:28] == 0x0
16232 OPC_Decode, 202, 122, 163, 2, // 529: decode to QC_LRHU using decoder 291
16233 // 529: }
16234 // 529: } // switch Inst[31:30]
16235 // 529: }
16236 // 529: } // switch Inst[14:12]
16237 // 529: }
16238 19, 82, // 534: case 0x13: {
16239 OPC_SwitchField, 28, 4, // 536: switch Inst[31:28] {
16240 1, 15, // 539: case 0x1: {
16241 OPC_CheckPredicate, 15, // 541: check predicate 15
16242 OPC_CheckField, 25, 3, 0, // 543: check Inst[27:25] == 0x0
16243 OPC_CheckField, 7, 13, 96, // 547: check Inst[19:7] == 0x60
16244 OPC_Decode, 245, 122, 164, 2, // 551: decode to QC_SYNC using decoder 292
16245 // 551: }
16246 2, 15, // 556: case 0x2: {
16247 OPC_CheckPredicate, 15, // 558: check predicate 15
16248 OPC_CheckField, 25, 3, 0, // 560: check Inst[27:25] == 0x0
16249 OPC_CheckField, 7, 13, 96, // 564: check Inst[19:7] == 0x60
16250 OPC_Decode, 246, 122, 164, 2, // 568: decode to QC_SYNCR using decoder 292
16251 // 568: }
16252 4, 26, // 573: case 0x4: {
16253 OPC_SwitchField, 7, 13, // 575: switch Inst[19:7] {
16254 64, 8, // 578: case 0x40: {
16255 OPC_CheckPredicate, 189, 1, // 580: check predicate 189
16256 OPC_Decode, 223, 122, 165, 2, // 583: decode to QC_PPUTCI using decoder 293
16257 // 583: }
16258 96, 0, // 588: case 0x60: {
16259 OPC_CheckPredicate, 15, // 590: check predicate 15
16260 OPC_CheckField, 25, 3, 0, // 592: check Inst[27:25] == 0x0
16261 OPC_Decode, 247, 122, 164, 2, // 596: decode to QC_SYNCWF using decoder 292
16262 // 596: }
16263 // 596: } // switch Inst[19:7]
16264 // 596: }
16265 8, 0, // 601: case 0x8: {
16266 OPC_CheckPredicate, 15, // 603: check predicate 15
16267 OPC_CheckField, 25, 3, 0, // 605: check Inst[27:25] == 0x0
16268 OPC_CheckField, 7, 13, 96, // 609: check Inst[19:7] == 0x60
16269 OPC_Decode, 248, 122, 164, 2, // 613: decode to QC_SYNCWL using decoder 292
16270 // 613: }
16271 // 613: } // switch Inst[31:28]
16272 // 613: }
16273 27, 8, // 618: case 0x1b: {
16274 OPC_CheckPredicate, 190, 1, // 620: check predicate 190
16275 OPC_Decode, 186, 122, 166, 2, // 623: decode to QC_LI using decoder 294
16276 // 623: }
16277 43, 95, // 628: case 0x2b: {
16278 OPC_SwitchField, 30, 2, // 630: switch Inst[31:30] {
16279 0, 12, // 633: case 0x0: {
16280 OPC_CheckPredicate, 187, 1, // 635: check predicate 187
16281 OPC_CheckField, 12, 3, 7, // 638: check Inst[14:12] == 0x7
16282 OPC_Decode, 243, 122, 161, 2, // 642: decode to QC_SWM using decoder 289
16283 // 642: }
16284 1, 12, // 647: case 0x1: {
16285 OPC_CheckPredicate, 187, 1, // 649: check predicate 187
16286 OPC_CheckField, 12, 3, 7, // 652: check Inst[14:12] == 0x7
16287 OPC_Decode, 244, 122, 162, 2, // 656: decode to QC_SWMI using decoder 290
16288 // 656: }
16289 2, 12, // 661: case 0x2: {
16290 OPC_CheckPredicate, 187, 1, // 663: check predicate 187
16291 OPC_CheckField, 12, 3, 7, // 666: check Inst[14:12] == 0x7
16292 OPC_Decode, 233, 122, 167, 2, // 670: decode to QC_SETWM using decoder 295
16293 // 670: }
16294 3, 0, // 675: case 0x3: {
16295 OPC_SwitchField, 12, 3, // 677: switch Inst[14:12] {
16296 6, 33, // 680: case 0x6: {
16297 OPC_SwitchField, 28, 2, // 682: switch Inst[29:28] {
16298 1, 8, // 685: case 0x1: {
16299 OPC_CheckPredicate, 188, 1, // 687: check predicate 188
16300 OPC_Decode, 238, 122, 163, 2, // 690: decode to QC_SRB using decoder 291
16301 // 690: }
16302 2, 8, // 695: case 0x2: {
16303 OPC_CheckPredicate, 188, 1, // 697: check predicate 188
16304 OPC_Decode, 239, 122, 163, 2, // 700: decode to QC_SRH using decoder 291
16305 // 700: }
16306 3, 0, // 705: case 0x3: {
16307 OPC_CheckPredicate, 188, 1, // 707: check predicate 188
16308 OPC_Decode, 240, 122, 163, 2, // 710: decode to QC_SRW using decoder 291
16309 // 710: }
16310 // 710: } // switch Inst[29:28]
16311 // 710: }
16312 7, 0, // 715: case 0x7: {
16313 OPC_CheckPredicate, 187, 1, // 717: check predicate 187
16314 OPC_Decode, 234, 122, 168, 2, // 720: decode to QC_SETWMI using decoder 296
16315 // 720: }
16316 // 720: } // switch Inst[14:12]
16317 // 720: }
16318 // 720: } // switch Inst[31:30]
16319 // 720: }
16320 91, 223, 2, // 725: case 0x5b: {
16321 OPC_SwitchField, 12, 3, // 728: switch Inst[14:12] {
16322 0, 41, // 731: case 0x0: {
16323 OPC_SwitchField, 25, 2, // 733: switch Inst[26:25] {
16324 0, 7, // 736: case 0x0: {
16325 OPC_CheckPredicate, 16, // 738: check predicate 16
16326 OPC_Decode, 207, 122, 169, 2, // 740: decode to QC_MVEQ using decoder 297
16327 // 740: }
16328 1, 8, // 745: case 0x1: {
16329 OPC_CheckPredicate, 191, 1, // 747: check predicate 191
16330 OPC_Decode, 187, 122, 170, 2, // 750: decode to QC_LIEQ using decoder 298
16331 // 750: }
16332 2, 7, // 755: case 0x2: {
16333 OPC_CheckPredicate, 16, // 757: check predicate 16
16334 OPC_Decode, 208, 122, 171, 2, // 759: decode to QC_MVEQI using decoder 299
16335 // 759: }
16336 3, 0, // 764: case 0x3: {
16337 OPC_CheckPredicate, 191, 1, // 766: check predicate 191
16338 OPC_Decode, 188, 122, 172, 2, // 769: decode to QC_LIEQI using decoder 300
16339 // 769: }
16340 // 769: } // switch Inst[26:25]
16341 // 769: }
16342 1, 41, // 774: case 0x1: {
16343 OPC_SwitchField, 25, 2, // 776: switch Inst[26:25] {
16344 0, 7, // 779: case 0x0: {
16345 OPC_CheckPredicate, 16, // 781: check predicate 16
16346 OPC_Decode, 217, 122, 169, 2, // 783: decode to QC_MVNE using decoder 297
16347 // 783: }
16348 1, 8, // 788: case 0x1: {
16349 OPC_CheckPredicate, 191, 1, // 790: check predicate 191
16350 OPC_Decode, 197, 122, 170, 2, // 793: decode to QC_LINE using decoder 298
16351 // 793: }
16352 2, 7, // 798: case 0x2: {
16353 OPC_CheckPredicate, 16, // 800: check predicate 16
16354 OPC_Decode, 218, 122, 171, 2, // 802: decode to QC_MVNEI using decoder 299
16355 // 802: }
16356 3, 0, // 807: case 0x3: {
16357 OPC_CheckPredicate, 191, 1, // 809: check predicate 191
16358 OPC_Decode, 198, 122, 172, 2, // 812: decode to QC_LINEI using decoder 300
16359 // 812: }
16360 // 812: } // switch Inst[26:25]
16361 // 812: }
16362 2, 43, // 817: case 0x2: {
16363 OPC_SwitchField, 25, 2, // 819: switch Inst[26:25] {
16364 0, 8, // 822: case 0x0: {
16365 OPC_CheckPredicate, 192, 1, // 824: check predicate 192
16366 OPC_Decode, 227, 122, 172, 2, // 827: decode to QC_SELECTIIEQ using decoder 300
16367 // 827: }
16368 1, 8, // 832: case 0x1: {
16369 OPC_CheckPredicate, 192, 1, // 834: check predicate 192
16370 OPC_Decode, 225, 122, 170, 2, // 837: decode to QC_SELECTIEQ using decoder 298
16371 // 837: }
16372 2, 8, // 842: case 0x2: {
16373 OPC_CheckPredicate, 192, 1, // 844: check predicate 192
16374 OPC_Decode, 224, 122, 173, 2, // 847: decode to QC_SELECTEQI using decoder 301
16375 // 847: }
16376 3, 0, // 852: case 0x3: {
16377 OPC_CheckPredicate, 192, 1, // 854: check predicate 192
16378 OPC_Decode, 226, 122, 174, 2, // 857: decode to QC_SELECTIEQI using decoder 302
16379 // 857: }
16380 // 857: } // switch Inst[26:25]
16381 // 857: }
16382 3, 43, // 862: case 0x3: {
16383 OPC_SwitchField, 25, 2, // 864: switch Inst[26:25] {
16384 0, 8, // 867: case 0x0: {
16385 OPC_CheckPredicate, 192, 1, // 869: check predicate 192
16386 OPC_Decode, 228, 122, 172, 2, // 872: decode to QC_SELECTIINE using decoder 300
16387 // 872: }
16388 1, 8, // 877: case 0x1: {
16389 OPC_CheckPredicate, 192, 1, // 879: check predicate 192
16390 OPC_Decode, 229, 122, 170, 2, // 882: decode to QC_SELECTINE using decoder 298
16391 // 882: }
16392 2, 8, // 887: case 0x2: {
16393 OPC_CheckPredicate, 192, 1, // 889: check predicate 192
16394 OPC_Decode, 231, 122, 173, 2, // 892: decode to QC_SELECTNEI using decoder 301
16395 // 892: }
16396 3, 0, // 897: case 0x3: {
16397 OPC_CheckPredicate, 192, 1, // 899: check predicate 192
16398 OPC_Decode, 230, 122, 174, 2, // 902: decode to QC_SELECTINEI using decoder 302
16399 // 902: }
16400 // 902: } // switch Inst[26:25]
16401 // 902: }
16402 4, 41, // 907: case 0x4: {
16403 OPC_SwitchField, 25, 2, // 909: switch Inst[26:25] {
16404 0, 7, // 912: case 0x0: {
16405 OPC_CheckPredicate, 16, // 914: check predicate 16
16406 OPC_Decode, 213, 122, 169, 2, // 916: decode to QC_MVLT using decoder 297
16407 // 916: }
16408 1, 8, // 921: case 0x1: {
16409 OPC_CheckPredicate, 191, 1, // 923: check predicate 191
16410 OPC_Decode, 193, 122, 170, 2, // 926: decode to QC_LILT using decoder 298
16411 // 926: }
16412 2, 7, // 931: case 0x2: {
16413 OPC_CheckPredicate, 16, // 933: check predicate 16
16414 OPC_Decode, 214, 122, 171, 2, // 935: decode to QC_MVLTI using decoder 299
16415 // 935: }
16416 3, 0, // 940: case 0x3: {
16417 OPC_CheckPredicate, 191, 1, // 942: check predicate 191
16418 OPC_Decode, 194, 122, 172, 2, // 945: decode to QC_LILTI using decoder 300
16419 // 945: }
16420 // 945: } // switch Inst[26:25]
16421 // 945: }
16422 5, 41, // 950: case 0x5: {
16423 OPC_SwitchField, 25, 2, // 952: switch Inst[26:25] {
16424 0, 7, // 955: case 0x0: {
16425 OPC_CheckPredicate, 16, // 957: check predicate 16
16426 OPC_Decode, 209, 122, 169, 2, // 959: decode to QC_MVGE using decoder 297
16427 // 959: }
16428 1, 8, // 964: case 0x1: {
16429 OPC_CheckPredicate, 191, 1, // 966: check predicate 191
16430 OPC_Decode, 189, 122, 170, 2, // 969: decode to QC_LIGE using decoder 298
16431 // 969: }
16432 2, 7, // 974: case 0x2: {
16433 OPC_CheckPredicate, 16, // 976: check predicate 16
16434 OPC_Decode, 210, 122, 171, 2, // 978: decode to QC_MVGEI using decoder 299
16435 // 978: }
16436 3, 0, // 983: case 0x3: {
16437 OPC_CheckPredicate, 191, 1, // 985: check predicate 191
16438 OPC_Decode, 190, 122, 172, 2, // 988: decode to QC_LIGEI using decoder 300
16439 // 988: }
16440 // 988: } // switch Inst[26:25]
16441 // 988: }
16442 6, 41, // 993: case 0x6: {
16443 OPC_SwitchField, 25, 2, // 995: switch Inst[26:25] {
16444 0, 7, // 998: case 0x0: {
16445 OPC_CheckPredicate, 16, // 1000: check predicate 16
16446 OPC_Decode, 215, 122, 169, 2, // 1002: decode to QC_MVLTU using decoder 297
16447 // 1002: }
16448 1, 8, // 1007: case 0x1: {
16449 OPC_CheckPredicate, 191, 1, // 1009: check predicate 191
16450 OPC_Decode, 195, 122, 170, 2, // 1012: decode to QC_LILTU using decoder 298
16451 // 1012: }
16452 2, 7, // 1017: case 0x2: {
16453 OPC_CheckPredicate, 16, // 1019: check predicate 16
16454 OPC_Decode, 216, 122, 175, 2, // 1021: decode to QC_MVLTUI using decoder 303
16455 // 1021: }
16456 3, 0, // 1026: case 0x3: {
16457 OPC_CheckPredicate, 191, 1, // 1028: check predicate 191
16458 OPC_Decode, 196, 122, 176, 2, // 1031: decode to QC_LILTUI using decoder 304
16459 // 1031: }
16460 // 1031: } // switch Inst[26:25]
16461 // 1031: }
16462 7, 0, // 1036: case 0x7: {
16463 OPC_SwitchField, 25, 2, // 1038: switch Inst[26:25] {
16464 0, 7, // 1041: case 0x0: {
16465 OPC_CheckPredicate, 16, // 1043: check predicate 16
16466 OPC_Decode, 211, 122, 169, 2, // 1045: decode to QC_MVGEU using decoder 297
16467 // 1045: }
16468 1, 8, // 1050: case 0x1: {
16469 OPC_CheckPredicate, 191, 1, // 1052: check predicate 191
16470 OPC_Decode, 191, 122, 170, 2, // 1055: decode to QC_LIGEU using decoder 298
16471 // 1055: }
16472 2, 7, // 1060: case 0x2: {
16473 OPC_CheckPredicate, 16, // 1062: check predicate 16
16474 OPC_Decode, 212, 122, 175, 2, // 1064: decode to QC_MVGEUI using decoder 303
16475 // 1064: }
16476 3, 0, // 1069: case 0x3: {
16477 OPC_CheckPredicate, 191, 1, // 1071: check predicate 191
16478 OPC_Decode, 192, 122, 176, 2, // 1074: decode to QC_LIGEUI using decoder 304
16479 // 1074: }
16480 // 1074: } // switch Inst[26:25]
16481 // 1074: }
16482 // 1074: } // switch Inst[14:12]
16483 // 1074: }
16484 115, 57, // 1079: case 0x73: {
16485 OPC_SwitchField, 25, 7, // 1081: switch Inst[31:25] {
16486 70, 12, // 1084: case 0x46: {
16487 OPC_CheckPredicate, 193, 1, // 1086: check predicate 193
16488 OPC_CheckField, 12, 3, 0, // 1089: check Inst[14:12] == 0x0
16489 OPC_Decode, 245, 121, 177, 2, // 1093: decode to QC_CSRRWR using decoder 305
16490 // 1093: }
16491 71, 12, // 1098: case 0x47: {
16492 OPC_CheckPredicate, 193, 1, // 1100: check predicate 193
16493 OPC_CheckField, 12, 3, 0, // 1103: check Inst[14:12] == 0x0
16494 OPC_Decode, 246, 121, 178, 2, // 1107: decode to QC_CSRRWRI using decoder 306
16495 // 1107: }
16496 102, 11, // 1112: case 0x66: {
16497 OPC_CheckPredicate, 12, // 1114: check predicate 12
16498 OPC_CheckField, 7, 8, 0, // 1116: check Inst[14:7] == 0x0
16499 OPC_Decode, 232, 122, 179, 2, // 1120: decode to QC_SETINTI using decoder 307
16500 // 1120: }
16501 103, 0, // 1125: case 0x67: {
16502 OPC_CheckPredicate, 12, // 1127: check predicate 12
16503 OPC_CheckField, 7, 8, 0, // 1129: check Inst[14:7] == 0x0
16504 OPC_Decode, 233, 121, 179, 2, // 1133: decode to QC_CLRINTI using decoder 307
16505 // 1133: }
16506 // 1133: } // switch Inst[31:25]
16507 // 1133: }
16508 123, 0, // 1138: case 0x7b: {
16509 OPC_SwitchField, 12, 3, // 1140: switch Inst[14:12] {
16510 0, 8, // 1143: case 0x0: {
16511 OPC_CheckPredicate, 194, 1, // 1145: check predicate 194
16512 OPC_Decode, 225, 121, 180, 2, // 1148: decode to QC_BEQI using decoder 308
16513 // 1148: }
16514 1, 8, // 1153: case 0x1: {
16515 OPC_CheckPredicate, 194, 1, // 1155: check predicate 194
16516 OPC_Decode, 230, 121, 180, 2, // 1158: decode to QC_BNEI using decoder 308
16517 // 1158: }
16518 4, 8, // 1163: case 0x4: {
16519 OPC_CheckPredicate, 194, 1, // 1165: check predicate 194
16520 OPC_Decode, 228, 121, 180, 2, // 1168: decode to QC_BLTI using decoder 308
16521 // 1168: }
16522 5, 8, // 1173: case 0x5: {
16523 OPC_CheckPredicate, 194, 1, // 1175: check predicate 194
16524 OPC_Decode, 226, 121, 180, 2, // 1178: decode to QC_BGEI using decoder 308
16525 // 1178: }
16526 6, 8, // 1183: case 0x6: {
16527 OPC_CheckPredicate, 194, 1, // 1185: check predicate 194
16528 OPC_Decode, 229, 121, 181, 2, // 1188: decode to QC_BLTUI using decoder 309
16529 // 1188: }
16530 7, 0, // 1193: case 0x7: {
16531 OPC_CheckPredicate, 194, 1, // 1195: check predicate 194
16532 OPC_Decode, 227, 121, 181, 2, // 1198: decode to QC_BGEUI using decoder 309
16533 // 1198: }
16534 // 1198: } // switch Inst[14:12]
16535 // 1198: }
16536 // 1198: } // switch Inst[6:0]
16537};
16538static const uint8_t DecoderTableZdinxGPRPairRV3232[34] = {
16539 32, // 0: BitWidth 32
16540 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
16541 162, 8, 12, // 4: case 0x422: {
16542 OPC_CheckPredicate, 195, 1, // 7: check predicate 195
16543 OPC_CheckField, 0, 7, 83, // 10: check Inst[6:0] == 0x53
16544 OPC_Decode, 253, 113, 182, 2, // 14: decode to FCVT_D_H_IN32X using decoder 310
16545 // 14: }
16546 193, 8, 0, // 19: case 0x441: {
16547 OPC_CheckPredicate, 195, 1, // 22: check predicate 195
16548 OPC_CheckField, 0, 7, 83, // 25: check Inst[6:0] == 0x53
16549 OPC_Decode, 142, 114, 183, 2, // 29: decode to FCVT_H_D_IN32X using decoder 311
16550 // 29: }
16551 // 29: } // switch Inst[31:20]
16552};
16553static const uint8_t DecoderTableZdinxRV32Only32[310] = {
16554 32, // 0: BitWidth 32
16555 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16556 67, 12, // 4: case 0x43: {
16557 OPC_CheckPredicate, 196, 1, // 6: check predicate 196
16558 OPC_CheckField, 25, 2, 1, // 9: check Inst[26:25] == 0x1
16559 OPC_Decode, 129, 115, 184, 2, // 13: decode to FMADD_D_IN32X using decoder 312
16560 // 13: }
16561 71, 12, // 18: case 0x47: {
16562 OPC_CheckPredicate, 196, 1, // 20: check predicate 196
16563 OPC_CheckField, 25, 2, 1, // 23: check Inst[26:25] == 0x1
16564 OPC_Decode, 161, 115, 184, 2, // 27: decode to FMSUB_D_IN32X using decoder 312
16565 // 27: }
16566 75, 12, // 32: case 0x4b: {
16567 OPC_CheckPredicate, 196, 1, // 34: check predicate 196
16568 OPC_CheckField, 25, 2, 1, // 37: check Inst[26:25] == 0x1
16569 OPC_Decode, 196, 115, 184, 2, // 41: decode to FNMSUB_D_IN32X using decoder 312
16570 // 41: }
16571 79, 12, // 46: case 0x4f: {
16572 OPC_CheckPredicate, 196, 1, // 48: check predicate 196
16573 OPC_CheckField, 25, 2, 1, // 51: check Inst[26:25] == 0x1
16574 OPC_Decode, 188, 115, 184, 2, // 55: decode to FNMADD_D_IN32X using decoder 312
16575 // 55: }
16576 83, 0, // 60: case 0x53: {
16577 OPC_SwitchField, 25, 7, // 62: switch Inst[31:25] {
16578 1, 8, // 65: case 0x1: {
16579 OPC_CheckPredicate, 196, 1, // 67: check predicate 196
16580 OPC_Decode, 235, 113, 185, 2, // 70: decode to FADD_D_IN32X using decoder 313
16581 // 70: }
16582 5, 8, // 75: case 0x5: {
16583 OPC_CheckPredicate, 196, 1, // 77: check predicate 196
16584 OPC_Decode, 247, 115, 185, 2, // 80: decode to FSUB_D_IN32X using decoder 313
16585 // 80: }
16586 9, 8, // 85: case 0x9: {
16587 OPC_CheckPredicate, 196, 1, // 87: check predicate 196
16588 OPC_Decode, 169, 115, 185, 2, // 90: decode to FMUL_D_IN32X using decoder 313
16589 // 90: }
16590 13, 8, // 95: case 0xd: {
16591 OPC_CheckPredicate, 196, 1, // 97: check predicate 196
16592 OPC_Decode, 206, 114, 185, 2, // 100: decode to FDIV_D_IN32X using decoder 313
16593 // 100: }
16594 17, 33, // 105: case 0x11: {
16595 OPC_SwitchField, 12, 3, // 107: switch Inst[14:12] {
16596 0, 8, // 110: case 0x0: {
16597 OPC_CheckPredicate, 196, 1, // 112: check predicate 196
16598 OPC_Decode, 229, 115, 186, 2, // 115: decode to FSGNJ_D_IN32X using decoder 314
16599 // 115: }
16600 1, 8, // 120: case 0x1: {
16601 OPC_CheckPredicate, 196, 1, // 122: check predicate 196
16602 OPC_Decode, 213, 115, 186, 2, // 125: decode to FSGNJN_D_IN32X using decoder 314
16603 // 125: }
16604 2, 0, // 130: case 0x2: {
16605 OPC_CheckPredicate, 196, 1, // 132: check predicate 196
16606 OPC_Decode, 221, 115, 186, 2, // 135: decode to FSGNJX_D_IN32X using decoder 314
16607 // 135: }
16608 // 135: } // switch Inst[14:12]
16609 // 135: }
16610 21, 23, // 140: case 0x15: {
16611 OPC_SwitchField, 12, 3, // 142: switch Inst[14:12] {
16612 0, 8, // 145: case 0x0: {
16613 OPC_CheckPredicate, 196, 1, // 147: check predicate 196
16614 OPC_Decode, 153, 115, 186, 2, // 150: decode to FMIN_D_IN32X using decoder 314
16615 // 150: }
16616 1, 0, // 155: case 0x1: {
16617 OPC_CheckPredicate, 196, 1, // 157: check predicate 196
16618 OPC_Decode, 141, 115, 186, 2, // 160: decode to FMAX_D_IN32X using decoder 314
16619 // 160: }
16620 // 160: } // switch Inst[14:12]
16621 // 160: }
16622 32, 12, // 165: case 0x20: {
16623 OPC_CheckPredicate, 196, 1, // 167: check predicate 196
16624 OPC_CheckField, 20, 5, 1, // 170: check Inst[24:20] == 0x1
16625 OPC_Decode, 176, 114, 187, 2, // 174: decode to FCVT_S_D_IN32X using decoder 315
16626 // 174: }
16627 33, 12, // 179: case 0x21: {
16628 OPC_CheckPredicate, 196, 1, // 181: check predicate 196
16629 OPC_CheckField, 20, 5, 0, // 184: check Inst[24:20] == 0x0
16630 OPC_Decode, 133, 114, 188, 2, // 188: decode to FCVT_D_S_IN32X using decoder 316
16631 // 188: }
16632 45, 12, // 193: case 0x2d: {
16633 OPC_CheckPredicate, 196, 1, // 195: check predicate 196
16634 OPC_CheckField, 20, 5, 0, // 198: check Inst[24:20] == 0x0
16635 OPC_Decode, 239, 115, 189, 2, // 202: decode to FSQRT_D_IN32X using decoder 317
16636 // 202: }
16637 81, 33, // 207: case 0x51: {
16638 OPC_SwitchField, 12, 3, // 209: switch Inst[14:12] {
16639 0, 8, // 212: case 0x0: {
16640 OPC_CheckPredicate, 196, 1, // 214: check predicate 196
16641 OPC_Decode, 230, 114, 190, 2, // 217: decode to FLE_D_IN32X using decoder 318
16642 // 217: }
16643 1, 8, // 222: case 0x1: {
16644 OPC_CheckPredicate, 196, 1, // 224: check predicate 196
16645 OPC_Decode, 248, 114, 190, 2, // 227: decode to FLT_D_IN32X using decoder 318
16646 // 227: }
16647 2, 0, // 232: case 0x2: {
16648 OPC_CheckPredicate, 196, 1, // 234: check predicate 196
16649 OPC_Decode, 217, 114, 190, 2, // 237: decode to FEQ_D_IN32X using decoder 318
16650 // 237: }
16651 // 237: } // switch Inst[14:12]
16652 // 237: }
16653 97, 23, // 242: case 0x61: {
16654 OPC_SwitchField, 20, 5, // 244: switch Inst[24:20] {
16655 0, 8, // 247: case 0x0: {
16656 OPC_CheckPredicate, 196, 1, // 249: check predicate 196
16657 OPC_Decode, 198, 114, 191, 2, // 252: decode to FCVT_W_D_IN32X using decoder 319
16658 // 252: }
16659 1, 0, // 257: case 0x1: {
16660 OPC_CheckPredicate, 196, 1, // 259: check predicate 196
16661 OPC_Decode, 190, 114, 191, 2, // 262: decode to FCVT_WU_D_IN32X using decoder 319
16662 // 262: }
16663 // 262: } // switch Inst[24:20]
16664 // 262: }
16665 105, 23, // 267: case 0x69: {
16666 OPC_SwitchField, 20, 5, // 269: switch Inst[24:20] {
16667 0, 8, // 272: case 0x0: {
16668 OPC_CheckPredicate, 196, 1, // 274: check predicate 196
16669 OPC_Decode, 139, 114, 192, 2, // 277: decode to FCVT_D_W_IN32X using decoder 320
16670 // 277: }
16671 1, 0, // 282: case 0x1: {
16672 OPC_CheckPredicate, 196, 1, // 284: check predicate 196
16673 OPC_Decode, 137, 114, 192, 2, // 287: decode to FCVT_D_WU_IN32X using decoder 320
16674 // 287: }
16675 // 287: } // switch Inst[24:20]
16676 // 287: }
16677 113, 0, // 292: case 0x71: {
16678 OPC_CheckPredicate, 196, 1, // 294: check predicate 196
16679 OPC_CheckField, 20, 5, 0, // 297: check Inst[24:20] == 0x0
16680 OPC_CheckField, 12, 3, 1, // 301: check Inst[14:12] == 0x1
16681 OPC_Decode, 243, 113, 193, 2, // 305: decode to FCLASS_D_IN32X using decoder 321
16682 // 305: }
16683 // 305: } // switch Inst[31:25]
16684 // 305: }
16685 // 305: } // switch Inst[6:0]
16686};
16687static const uint8_t DecoderTableZfinx32[986] = {
16688 32, // 0: BitWidth 32
16689 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16690 67, 33, // 4: case 0x43: {
16691 OPC_SwitchField, 25, 2, // 6: switch Inst[26:25] {
16692 0, 8, // 9: case 0x0: {
16693 OPC_CheckPredicate, 197, 1, // 11: check predicate 197
16694 OPC_Decode, 135, 115, 194, 2, // 14: decode to FMADD_S_INX using decoder 322
16695 // 14: }
16696 1, 8, // 19: case 0x1: {
16697 OPC_CheckPredicate, 198, 1, // 21: check predicate 198
16698 OPC_Decode, 130, 115, 195, 2, // 24: decode to FMADD_D_INX using decoder 323
16699 // 24: }
16700 2, 0, // 29: case 0x2: {
16701 OPC_CheckPredicate, 199, 1, // 31: check predicate 199
16702 OPC_Decode, 132, 115, 196, 2, // 34: decode to FMADD_H_INX using decoder 324
16703 // 34: }
16704 // 34: } // switch Inst[26:25]
16705 // 34: }
16706 71, 33, // 39: case 0x47: {
16707 OPC_SwitchField, 25, 2, // 41: switch Inst[26:25] {
16708 0, 8, // 44: case 0x0: {
16709 OPC_CheckPredicate, 197, 1, // 46: check predicate 197
16710 OPC_Decode, 167, 115, 194, 2, // 49: decode to FMSUB_S_INX using decoder 322
16711 // 49: }
16712 1, 8, // 54: case 0x1: {
16713 OPC_CheckPredicate, 198, 1, // 56: check predicate 198
16714 OPC_Decode, 162, 115, 195, 2, // 59: decode to FMSUB_D_INX using decoder 323
16715 // 59: }
16716 2, 0, // 64: case 0x2: {
16717 OPC_CheckPredicate, 199, 1, // 66: check predicate 199
16718 OPC_Decode, 164, 115, 196, 2, // 69: decode to FMSUB_H_INX using decoder 324
16719 // 69: }
16720 // 69: } // switch Inst[26:25]
16721 // 69: }
16722 75, 33, // 74: case 0x4b: {
16723 OPC_SwitchField, 25, 2, // 76: switch Inst[26:25] {
16724 0, 8, // 79: case 0x0: {
16725 OPC_CheckPredicate, 197, 1, // 81: check predicate 197
16726 OPC_Decode, 202, 115, 194, 2, // 84: decode to FNMSUB_S_INX using decoder 322
16727 // 84: }
16728 1, 8, // 89: case 0x1: {
16729 OPC_CheckPredicate, 198, 1, // 91: check predicate 198
16730 OPC_Decode, 197, 115, 195, 2, // 94: decode to FNMSUB_D_INX using decoder 323
16731 // 94: }
16732 2, 0, // 99: case 0x2: {
16733 OPC_CheckPredicate, 199, 1, // 101: check predicate 199
16734 OPC_Decode, 199, 115, 196, 2, // 104: decode to FNMSUB_H_INX using decoder 324
16735 // 104: }
16736 // 104: } // switch Inst[26:25]
16737 // 104: }
16738 79, 33, // 109: case 0x4f: {
16739 OPC_SwitchField, 25, 2, // 111: switch Inst[26:25] {
16740 0, 8, // 114: case 0x0: {
16741 OPC_CheckPredicate, 197, 1, // 116: check predicate 197
16742 OPC_Decode, 194, 115, 194, 2, // 119: decode to FNMADD_S_INX using decoder 322
16743 // 119: }
16744 1, 8, // 124: case 0x1: {
16745 OPC_CheckPredicate, 198, 1, // 126: check predicate 198
16746 OPC_Decode, 189, 115, 195, 2, // 129: decode to FNMADD_D_INX using decoder 323
16747 // 129: }
16748 2, 0, // 134: case 0x2: {
16749 OPC_CheckPredicate, 199, 1, // 136: check predicate 199
16750 OPC_Decode, 191, 115, 196, 2, // 139: decode to FNMADD_H_INX using decoder 324
16751 // 139: }
16752 // 139: } // switch Inst[26:25]
16753 // 139: }
16754 83, 0, // 144: case 0x53: {
16755 OPC_SwitchField, 25, 7, // 146: switch Inst[31:25] {
16756 0, 8, // 149: case 0x0: {
16757 OPC_CheckPredicate, 197, 1, // 151: check predicate 197
16758 OPC_Decode, 241, 113, 197, 2, // 154: decode to FADD_S_INX using decoder 325
16759 // 154: }
16760 1, 8, // 159: case 0x1: {
16761 OPC_CheckPredicate, 198, 1, // 161: check predicate 198
16762 OPC_Decode, 236, 113, 198, 2, // 164: decode to FADD_D_INX using decoder 326
16763 // 164: }
16764 2, 8, // 169: case 0x2: {
16765 OPC_CheckPredicate, 199, 1, // 171: check predicate 199
16766 OPC_Decode, 238, 113, 199, 2, // 174: decode to FADD_H_INX using decoder 327
16767 // 174: }
16768 4, 8, // 179: case 0x4: {
16769 OPC_CheckPredicate, 197, 1, // 181: check predicate 197
16770 OPC_Decode, 253, 115, 197, 2, // 184: decode to FSUB_S_INX using decoder 325
16771 // 184: }
16772 5, 8, // 189: case 0x5: {
16773 OPC_CheckPredicate, 198, 1, // 191: check predicate 198
16774 OPC_Decode, 248, 115, 198, 2, // 194: decode to FSUB_D_INX using decoder 326
16775 // 194: }
16776 6, 8, // 199: case 0x6: {
16777 OPC_CheckPredicate, 199, 1, // 201: check predicate 199
16778 OPC_Decode, 250, 115, 199, 2, // 204: decode to FSUB_H_INX using decoder 327
16779 // 204: }
16780 8, 8, // 209: case 0x8: {
16781 OPC_CheckPredicate, 197, 1, // 211: check predicate 197
16782 OPC_Decode, 175, 115, 197, 2, // 214: decode to FMUL_S_INX using decoder 325
16783 // 214: }
16784 9, 8, // 219: case 0x9: {
16785 OPC_CheckPredicate, 198, 1, // 221: check predicate 198
16786 OPC_Decode, 170, 115, 198, 2, // 224: decode to FMUL_D_INX using decoder 326
16787 // 224: }
16788 10, 8, // 229: case 0xa: {
16789 OPC_CheckPredicate, 199, 1, // 231: check predicate 199
16790 OPC_Decode, 172, 115, 199, 2, // 234: decode to FMUL_H_INX using decoder 327
16791 // 234: }
16792 12, 8, // 239: case 0xc: {
16793 OPC_CheckPredicate, 197, 1, // 241: check predicate 197
16794 OPC_Decode, 212, 114, 197, 2, // 244: decode to FDIV_S_INX using decoder 325
16795 // 244: }
16796 13, 8, // 249: case 0xd: {
16797 OPC_CheckPredicate, 198, 1, // 251: check predicate 198
16798 OPC_Decode, 207, 114, 198, 2, // 254: decode to FDIV_D_INX using decoder 326
16799 // 254: }
16800 14, 8, // 259: case 0xe: {
16801 OPC_CheckPredicate, 199, 1, // 261: check predicate 199
16802 OPC_Decode, 209, 114, 199, 2, // 264: decode to FDIV_H_INX using decoder 327
16803 // 264: }
16804 16, 33, // 269: case 0x10: {
16805 OPC_SwitchField, 12, 3, // 271: switch Inst[14:12] {
16806 0, 8, // 274: case 0x0: {
16807 OPC_CheckPredicate, 197, 1, // 276: check predicate 197
16808 OPC_Decode, 235, 115, 200, 2, // 279: decode to FSGNJ_S_INX using decoder 328
16809 // 279: }
16810 1, 8, // 284: case 0x1: {
16811 OPC_CheckPredicate, 197, 1, // 286: check predicate 197
16812 OPC_Decode, 219, 115, 200, 2, // 289: decode to FSGNJN_S_INX using decoder 328
16813 // 289: }
16814 2, 0, // 294: case 0x2: {
16815 OPC_CheckPredicate, 197, 1, // 296: check predicate 197
16816 OPC_Decode, 227, 115, 200, 2, // 299: decode to FSGNJX_S_INX using decoder 328
16817 // 299: }
16818 // 299: } // switch Inst[14:12]
16819 // 299: }
16820 17, 30, // 304: case 0x11: {
16821 OPC_SwitchField, 12, 3, // 306: switch Inst[14:12] {
16822 0, 7, // 309: case 0x0: {
16823 OPC_CheckPredicate, 198, 1, // 311: check predicate 198
16824 OPC_Decode, 230, 115, 31, // 314: decode to FSGNJ_D_INX using decoder 31
16825 // 314: }
16826 1, 7, // 318: case 0x1: {
16827 OPC_CheckPredicate, 198, 1, // 320: check predicate 198
16828 OPC_Decode, 214, 115, 31, // 323: decode to FSGNJN_D_INX using decoder 31
16829 // 323: }
16830 2, 0, // 327: case 0x2: {
16831 OPC_CheckPredicate, 198, 1, // 329: check predicate 198
16832 OPC_Decode, 222, 115, 31, // 332: decode to FSGNJX_D_INX using decoder 31
16833 // 332: }
16834 // 332: } // switch Inst[14:12]
16835 // 332: }
16836 18, 33, // 336: case 0x12: {
16837 OPC_SwitchField, 12, 3, // 338: switch Inst[14:12] {
16838 0, 8, // 341: case 0x0: {
16839 OPC_CheckPredicate, 199, 1, // 343: check predicate 199
16840 OPC_Decode, 232, 115, 201, 2, // 346: decode to FSGNJ_H_INX using decoder 329
16841 // 346: }
16842 1, 8, // 351: case 0x1: {
16843 OPC_CheckPredicate, 199, 1, // 353: check predicate 199
16844 OPC_Decode, 216, 115, 201, 2, // 356: decode to FSGNJN_H_INX using decoder 329
16845 // 356: }
16846 2, 0, // 361: case 0x2: {
16847 OPC_CheckPredicate, 199, 1, // 363: check predicate 199
16848 OPC_Decode, 224, 115, 201, 2, // 366: decode to FSGNJX_H_INX using decoder 329
16849 // 366: }
16850 // 366: } // switch Inst[14:12]
16851 // 366: }
16852 20, 23, // 371: case 0x14: {
16853 OPC_SwitchField, 12, 3, // 373: switch Inst[14:12] {
16854 0, 8, // 376: case 0x0: {
16855 OPC_CheckPredicate, 197, 1, // 378: check predicate 197
16856 OPC_Decode, 159, 115, 200, 2, // 381: decode to FMIN_S_INX using decoder 328
16857 // 381: }
16858 1, 0, // 386: case 0x1: {
16859 OPC_CheckPredicate, 197, 1, // 388: check predicate 197
16860 OPC_Decode, 147, 115, 200, 2, // 391: decode to FMAX_S_INX using decoder 328
16861 // 391: }
16862 // 391: } // switch Inst[14:12]
16863 // 391: }
16864 21, 21, // 396: case 0x15: {
16865 OPC_SwitchField, 12, 3, // 398: switch Inst[14:12] {
16866 0, 7, // 401: case 0x0: {
16867 OPC_CheckPredicate, 198, 1, // 403: check predicate 198
16868 OPC_Decode, 154, 115, 31, // 406: decode to FMIN_D_INX using decoder 31
16869 // 406: }
16870 1, 0, // 410: case 0x1: {
16871 OPC_CheckPredicate, 198, 1, // 412: check predicate 198
16872 OPC_Decode, 142, 115, 31, // 415: decode to FMAX_D_INX using decoder 31
16873 // 415: }
16874 // 415: } // switch Inst[14:12]
16875 // 415: }
16876 22, 23, // 419: case 0x16: {
16877 OPC_SwitchField, 12, 3, // 421: switch Inst[14:12] {
16878 0, 8, // 424: case 0x0: {
16879 OPC_CheckPredicate, 199, 1, // 426: check predicate 199
16880 OPC_Decode, 156, 115, 201, 2, // 429: decode to FMIN_H_INX using decoder 329
16881 // 429: }
16882 1, 0, // 434: case 0x1: {
16883 OPC_CheckPredicate, 199, 1, // 436: check predicate 199
16884 OPC_Decode, 144, 115, 201, 2, // 439: decode to FMAX_H_INX using decoder 329
16885 // 439: }
16886 // 439: } // switch Inst[14:12]
16887 // 439: }
16888 32, 23, // 444: case 0x20: {
16889 OPC_SwitchField, 20, 5, // 446: switch Inst[24:20] {
16890 1, 8, // 449: case 0x1: {
16891 OPC_CheckPredicate, 198, 1, // 451: check predicate 198
16892 OPC_Decode, 177, 114, 202, 2, // 454: decode to FCVT_S_D_INX using decoder 330
16893 // 454: }
16894 2, 0, // 459: case 0x2: {
16895 OPC_CheckPredicate, 200, 1, // 461: check predicate 200
16896 OPC_Decode, 179, 114, 203, 2, // 464: decode to FCVT_S_H_INX using decoder 331
16897 // 464: }
16898 // 464: } // switch Inst[24:20]
16899 // 464: }
16900 33, 23, // 469: case 0x21: {
16901 OPC_SwitchField, 20, 5, // 471: switch Inst[24:20] {
16902 0, 8, // 474: case 0x0: {
16903 OPC_CheckPredicate, 198, 1, // 476: check predicate 198
16904 OPC_Decode, 134, 114, 204, 2, // 479: decode to FCVT_D_S_INX using decoder 332
16905 // 479: }
16906 2, 0, // 484: case 0x2: {
16907 OPC_CheckPredicate, 201, 1, // 486: check predicate 201
16908 OPC_Decode, 254, 113, 205, 2, // 489: decode to FCVT_D_H_INX using decoder 333
16909 // 489: }
16910 // 489: } // switch Inst[24:20]
16911 // 489: }
16912 34, 23, // 494: case 0x22: {
16913 OPC_SwitchField, 20, 5, // 496: switch Inst[24:20] {
16914 0, 8, // 499: case 0x0: {
16915 OPC_CheckPredicate, 200, 1, // 501: check predicate 200
16916 OPC_Decode, 149, 114, 206, 2, // 504: decode to FCVT_H_S_INX using decoder 334
16917 // 504: }
16918 1, 0, // 509: case 0x1: {
16919 OPC_CheckPredicate, 201, 1, // 511: check predicate 201
16920 OPC_Decode, 143, 114, 207, 2, // 514: decode to FCVT_H_D_INX using decoder 335
16921 // 514: }
16922 // 514: } // switch Inst[24:20]
16923 // 514: }
16924 44, 12, // 519: case 0x2c: {
16925 OPC_CheckPredicate, 197, 1, // 521: check predicate 197
16926 OPC_CheckField, 20, 5, 0, // 524: check Inst[24:20] == 0x0
16927 OPC_Decode, 245, 115, 208, 2, // 528: decode to FSQRT_S_INX using decoder 336
16928 // 528: }
16929 45, 12, // 533: case 0x2d: {
16930 OPC_CheckPredicate, 198, 1, // 535: check predicate 198
16931 OPC_CheckField, 20, 5, 0, // 538: check Inst[24:20] == 0x0
16932 OPC_Decode, 240, 115, 209, 2, // 542: decode to FSQRT_D_INX using decoder 337
16933 // 542: }
16934 46, 12, // 547: case 0x2e: {
16935 OPC_CheckPredicate, 199, 1, // 549: check predicate 199
16936 OPC_CheckField, 20, 5, 0, // 552: check Inst[24:20] == 0x0
16937 OPC_Decode, 242, 115, 210, 2, // 556: decode to FSQRT_H_INX using decoder 338
16938 // 556: }
16939 80, 33, // 561: case 0x50: {
16940 OPC_SwitchField, 12, 3, // 563: switch Inst[14:12] {
16941 0, 8, // 566: case 0x0: {
16942 OPC_CheckPredicate, 197, 1, // 568: check predicate 197
16943 OPC_Decode, 236, 114, 211, 2, // 571: decode to FLE_S_INX using decoder 339
16944 // 571: }
16945 1, 8, // 576: case 0x1: {
16946 OPC_CheckPredicate, 197, 1, // 578: check predicate 197
16947 OPC_Decode, 254, 114, 211, 2, // 581: decode to FLT_S_INX using decoder 339
16948 // 581: }
16949 2, 0, // 586: case 0x2: {
16950 OPC_CheckPredicate, 197, 1, // 588: check predicate 197
16951 OPC_Decode, 223, 114, 211, 2, // 591: decode to FEQ_S_INX using decoder 339
16952 // 591: }
16953 // 591: } // switch Inst[14:12]
16954 // 591: }
16955 81, 30, // 596: case 0x51: {
16956 OPC_SwitchField, 12, 3, // 598: switch Inst[14:12] {
16957 0, 7, // 601: case 0x0: {
16958 OPC_CheckPredicate, 198, 1, // 603: check predicate 198
16959 OPC_Decode, 231, 114, 31, // 606: decode to FLE_D_INX using decoder 31
16960 // 606: }
16961 1, 7, // 610: case 0x1: {
16962 OPC_CheckPredicate, 198, 1, // 612: check predicate 198
16963 OPC_Decode, 249, 114, 31, // 615: decode to FLT_D_INX using decoder 31
16964 // 615: }
16965 2, 0, // 619: case 0x2: {
16966 OPC_CheckPredicate, 198, 1, // 621: check predicate 198
16967 OPC_Decode, 218, 114, 31, // 624: decode to FEQ_D_INX using decoder 31
16968 // 624: }
16969 // 624: } // switch Inst[14:12]
16970 // 624: }
16971 82, 33, // 628: case 0x52: {
16972 OPC_SwitchField, 12, 3, // 630: switch Inst[14:12] {
16973 0, 8, // 633: case 0x0: {
16974 OPC_CheckPredicate, 199, 1, // 635: check predicate 199
16975 OPC_Decode, 233, 114, 212, 2, // 638: decode to FLE_H_INX using decoder 340
16976 // 638: }
16977 1, 8, // 643: case 0x1: {
16978 OPC_CheckPredicate, 199, 1, // 645: check predicate 199
16979 OPC_Decode, 251, 114, 212, 2, // 648: decode to FLT_H_INX using decoder 340
16980 // 648: }
16981 2, 0, // 653: case 0x2: {
16982 OPC_CheckPredicate, 199, 1, // 655: check predicate 199
16983 OPC_Decode, 220, 114, 212, 2, // 658: decode to FEQ_H_INX using decoder 340
16984 // 658: }
16985 // 658: } // switch Inst[14:12]
16986 // 658: }
16987 96, 43, // 663: case 0x60: {
16988 OPC_SwitchField, 20, 5, // 665: switch Inst[24:20] {
16989 0, 8, // 668: case 0x0: {
16990 OPC_CheckPredicate, 197, 1, // 670: check predicate 197
16991 OPC_Decode, 204, 114, 204, 2, // 673: decode to FCVT_W_S_INX using decoder 332
16992 // 673: }
16993 1, 8, // 678: case 0x1: {
16994 OPC_CheckPredicate, 197, 1, // 680: check predicate 197
16995 OPC_Decode, 196, 114, 204, 2, // 683: decode to FCVT_WU_S_INX using decoder 332
16996 // 683: }
16997 2, 8, // 688: case 0x2: {
16998 OPC_CheckPredicate, 202, 1, // 690: check predicate 202
16999 OPC_Decode, 167, 114, 204, 2, // 693: decode to FCVT_L_S_INX using decoder 332
17000 // 693: }
17001 3, 0, // 698: case 0x3: {
17002 OPC_CheckPredicate, 202, 1, // 700: check predicate 202
17003 OPC_Decode, 160, 114, 204, 2, // 703: decode to FCVT_LU_S_INX using decoder 332
17004 // 703: }
17005 // 703: } // switch Inst[24:20]
17006 // 703: }
17007 97, 43, // 708: case 0x61: {
17008 OPC_SwitchField, 20, 5, // 710: switch Inst[24:20] {
17009 0, 8, // 713: case 0x0: {
17010 OPC_CheckPredicate, 198, 1, // 715: check predicate 198
17011 OPC_Decode, 199, 114, 209, 2, // 718: decode to FCVT_W_D_INX using decoder 337
17012 // 718: }
17013 1, 8, // 723: case 0x1: {
17014 OPC_CheckPredicate, 198, 1, // 725: check predicate 198
17015 OPC_Decode, 191, 114, 209, 2, // 728: decode to FCVT_WU_D_INX using decoder 337
17016 // 728: }
17017 2, 8, // 733: case 0x2: {
17018 OPC_CheckPredicate, 203, 1, // 735: check predicate 203
17019 OPC_Decode, 162, 114, 209, 2, // 738: decode to FCVT_L_D_INX using decoder 337
17020 // 738: }
17021 3, 0, // 743: case 0x3: {
17022 OPC_CheckPredicate, 203, 1, // 745: check predicate 203
17023 OPC_Decode, 155, 114, 209, 2, // 748: decode to FCVT_LU_D_INX using decoder 337
17024 // 748: }
17025 // 748: } // switch Inst[24:20]
17026 // 748: }
17027 98, 43, // 753: case 0x62: {
17028 OPC_SwitchField, 20, 5, // 755: switch Inst[24:20] {
17029 0, 8, // 758: case 0x0: {
17030 OPC_CheckPredicate, 199, 1, // 760: check predicate 199
17031 OPC_Decode, 201, 114, 205, 2, // 763: decode to FCVT_W_H_INX using decoder 333
17032 // 763: }
17033 1, 8, // 768: case 0x1: {
17034 OPC_CheckPredicate, 199, 1, // 770: check predicate 199
17035 OPC_Decode, 193, 114, 205, 2, // 773: decode to FCVT_WU_H_INX using decoder 333
17036 // 773: }
17037 2, 8, // 778: case 0x2: {
17038 OPC_CheckPredicate, 204, 1, // 780: check predicate 204
17039 OPC_Decode, 164, 114, 205, 2, // 783: decode to FCVT_L_H_INX using decoder 333
17040 // 783: }
17041 3, 0, // 788: case 0x3: {
17042 OPC_CheckPredicate, 204, 1, // 790: check predicate 204
17043 OPC_Decode, 157, 114, 205, 2, // 793: decode to FCVT_LU_H_INX using decoder 333
17044 // 793: }
17045 // 793: } // switch Inst[24:20]
17046 // 793: }
17047 104, 43, // 798: case 0x68: {
17048 OPC_SwitchField, 20, 5, // 800: switch Inst[24:20] {
17049 0, 8, // 803: case 0x0: {
17050 OPC_CheckPredicate, 197, 1, // 805: check predicate 197
17051 OPC_Decode, 188, 114, 202, 2, // 808: decode to FCVT_S_W_INX using decoder 330
17052 // 808: }
17053 1, 8, // 813: case 0x1: {
17054 OPC_CheckPredicate, 197, 1, // 815: check predicate 197
17055 OPC_Decode, 187, 114, 202, 2, // 818: decode to FCVT_S_WU_INX using decoder 330
17056 // 818: }
17057 2, 8, // 823: case 0x2: {
17058 OPC_CheckPredicate, 202, 1, // 825: check predicate 202
17059 OPC_Decode, 183, 114, 202, 2, // 828: decode to FCVT_S_L_INX using decoder 330
17060 // 828: }
17061 3, 0, // 833: case 0x3: {
17062 OPC_CheckPredicate, 202, 1, // 835: check predicate 202
17063 OPC_Decode, 182, 114, 202, 2, // 838: decode to FCVT_S_LU_INX using decoder 330
17064 // 838: }
17065 // 838: } // switch Inst[24:20]
17066 // 838: }
17067 105, 43, // 843: case 0x69: {
17068 OPC_SwitchField, 20, 5, // 845: switch Inst[24:20] {
17069 0, 8, // 848: case 0x0: {
17070 OPC_CheckPredicate, 198, 1, // 850: check predicate 198
17071 OPC_Decode, 140, 114, 209, 2, // 853: decode to FCVT_D_W_INX using decoder 337
17072 // 853: }
17073 1, 8, // 858: case 0x1: {
17074 OPC_CheckPredicate, 198, 1, // 860: check predicate 198
17075 OPC_Decode, 138, 114, 209, 2, // 863: decode to FCVT_D_WU_INX using decoder 337
17076 // 863: }
17077 2, 8, // 868: case 0x2: {
17078 OPC_CheckPredicate, 203, 1, // 870: check predicate 203
17079 OPC_Decode, 130, 114, 209, 2, // 873: decode to FCVT_D_L_INX using decoder 337
17080 // 873: }
17081 3, 0, // 878: case 0x3: {
17082 OPC_CheckPredicate, 203, 1, // 880: check predicate 203
17083 OPC_Decode, 129, 114, 209, 2, // 883: decode to FCVT_D_LU_INX using decoder 337
17084 // 883: }
17085 // 883: } // switch Inst[24:20]
17086 // 883: }
17087 106, 43, // 888: case 0x6a: {
17088 OPC_SwitchField, 20, 5, // 890: switch Inst[24:20] {
17089 0, 8, // 893: case 0x0: {
17090 OPC_CheckPredicate, 199, 1, // 895: check predicate 199
17091 OPC_Decode, 153, 114, 207, 2, // 898: decode to FCVT_H_W_INX using decoder 335
17092 // 898: }
17093 1, 8, // 903: case 0x1: {
17094 OPC_CheckPredicate, 199, 1, // 905: check predicate 199
17095 OPC_Decode, 152, 114, 207, 2, // 908: decode to FCVT_H_WU_INX using decoder 335
17096 // 908: }
17097 2, 8, // 913: case 0x2: {
17098 OPC_CheckPredicate, 204, 1, // 915: check predicate 204
17099 OPC_Decode, 147, 114, 207, 2, // 918: decode to FCVT_H_L_INX using decoder 335
17100 // 918: }
17101 3, 0, // 923: case 0x3: {
17102 OPC_CheckPredicate, 204, 1, // 925: check predicate 204
17103 OPC_Decode, 146, 114, 207, 2, // 928: decode to FCVT_H_LU_INX using decoder 335
17104 // 928: }
17105 // 928: } // switch Inst[24:20]
17106 // 928: }
17107 112, 16, // 933: case 0x70: {
17108 OPC_CheckPredicate, 197, 1, // 935: check predicate 197
17109 OPC_CheckField, 20, 5, 0, // 938: check Inst[24:20] == 0x0
17110 OPC_CheckField, 12, 3, 1, // 942: check Inst[14:12] == 0x1
17111 OPC_Decode, 249, 113, 213, 2, // 946: decode to FCLASS_S_INX using decoder 341
17112 // 946: }
17113 113, 15, // 951: case 0x71: {
17114 OPC_CheckPredicate, 198, 1, // 953: check predicate 198
17115 OPC_CheckField, 20, 5, 0, // 956: check Inst[24:20] == 0x0
17116 OPC_CheckField, 12, 3, 1, // 960: check Inst[14:12] == 0x1
17117 OPC_Decode, 244, 113, 17, // 964: decode to FCLASS_D_INX using decoder 17
17118 // 964: }
17119 114, 0, // 968: case 0x72: {
17120 OPC_CheckPredicate, 199, 1, // 970: check predicate 199
17121 OPC_CheckField, 20, 5, 0, // 973: check Inst[24:20] == 0x0
17122 OPC_CheckField, 12, 3, 1, // 977: check Inst[14:12] == 0x1
17123 OPC_Decode, 246, 113, 214, 2, // 981: decode to FCLASS_H_INX using decoder 342
17124 // 981: }
17125 // 981: } // switch Inst[31:25]
17126 // 981: }
17127 // 981: } // switch Inst[6:0]
17128};
17129// Handling 343 cases.
17130template <typename InsnType>
17131static std::enable_if_t<InsnBitWidth<InsnType> == 32, DecodeStatus>
17132decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
17133 DecodeComplete = true;
17134 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
17135 TmpType tmp;
17136 switch (Idx) {
17137 default: llvm_unreachable("Invalid decoder index!");
17138 case 0:
17139 tmp = fieldFromInstruction(insn, 7, 5);
17140 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17141 tmp = fieldFromInstruction(insn, 15, 5);
17142 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17143 tmp = fieldFromInstruction(insn, 20, 12);
17144 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17145 return S;
17146 case 1:
17147 tmp = fieldFromInstruction(insn, 7, 5);
17148 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17149 tmp = fieldFromInstruction(insn, 15, 5);
17150 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17151 tmp = fieldFromInstruction(insn, 25, 1);
17152 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17153 return S;
17154 case 2:
17155 tmp = fieldFromInstruction(insn, 7, 5);
17156 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17157 tmp = fieldFromInstruction(insn, 15, 5);
17158 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17159 return S;
17160 case 3:
17161 tmp = fieldFromInstruction(insn, 7, 5);
17162 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17163 tmp = fieldFromInstruction(insn, 15, 5);
17164 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17165 tmp = fieldFromInstruction(insn, 20, 5);
17166 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17167 tmp = fieldFromInstruction(insn, 25, 1);
17168 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17169 return S;
17170 case 4:
17171 tmp = fieldFromInstruction(insn, 7, 5);
17172 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17173 tmp = fieldFromInstruction(insn, 15, 5);
17174 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17175 tmp = fieldFromInstruction(insn, 20, 5);
17176 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17177 tmp = fieldFromInstruction(insn, 25, 1);
17178 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17179 return S;
17180 case 5:
17181 tmp = fieldFromInstruction(insn, 7, 5);
17182 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17183 tmp = fieldFromInstruction(insn, 15, 5);
17184 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17185 return S;
17186 case 6:
17187 tmp = fieldFromInstruction(insn, 7, 5);
17188 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17189 tmp = fieldFromInstruction(insn, 15, 5);
17190 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17191 return S;
17192 case 7:
17193 tmp = fieldFromInstruction(insn, 7, 5);
17194 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17195 tmp = fieldFromInstruction(insn, 15, 5);
17196 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17197 return S;
17198 case 8:
17199 tmp = fieldFromInstruction(insn, 7, 5);
17200 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17201 tmp = fieldFromInstruction(insn, 15, 5);
17202 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17203 tmp = fieldFromInstruction(insn, 20, 12);
17204 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17205 return S;
17206 case 9:
17207 tmp = fieldFromInstruction(insn, 7, 5);
17208 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17209 tmp = fieldFromInstruction(insn, 15, 5);
17210 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17211 tmp = fieldFromInstruction(insn, 20, 12);
17212 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17213 return S;
17214 case 10:
17215 tmp = fieldFromInstruction(insn, 7, 5);
17216 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17217 tmp = fieldFromInstruction(insn, 15, 5);
17218 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17219 tmp = fieldFromInstruction(insn, 20, 12);
17220 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17221 return S;
17222 case 11:
17223 tmp = fieldFromInstruction(insn, 7, 5);
17224 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17225 tmp = fieldFromInstruction(insn, 15, 5);
17226 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17227 tmp = fieldFromInstruction(insn, 20, 12);
17228 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17229 return S;
17230 case 12:
17231 tmp = fieldFromInstruction(insn, 7, 5);
17232 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17233 tmp = fieldFromInstruction(insn, 15, 5);
17234 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17235 tmp = fieldFromInstruction(insn, 20, 5);
17236 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17237 tmp = fieldFromInstruction(insn, 29, 3);
17238 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17239 tmp = fieldFromInstruction(insn, 25, 1);
17240 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17241 return S;
17242 case 13:
17243 tmp = fieldFromInstruction(insn, 24, 4);
17244 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17245 tmp = fieldFromInstruction(insn, 20, 4);
17246 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17247 return S;
17248 case 14:
17249 return S;
17250 case 15:
17251 tmp = fieldFromInstruction(insn, 15, 5);
17252 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17253 return S;
17254 case 16:
17255 tmp = fieldFromInstruction(insn, 7, 5);
17256 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17257 tmp = fieldFromInstruction(insn, 15, 5);
17258 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17259 tmp = fieldFromInstruction(insn, 20, 6);
17260 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17261 return S;
17262 case 17:
17263 tmp = fieldFromInstruction(insn, 7, 5);
17264 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17265 tmp = fieldFromInstruction(insn, 15, 5);
17266 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17267 return S;
17268 case 18:
17269 tmp = fieldFromInstruction(insn, 7, 5);
17270 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17271 tmp = fieldFromInstruction(insn, 15, 5);
17272 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17273 tmp = fieldFromInstruction(insn, 20, 4);
17274 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17275 return S;
17276 case 19:
17277 tmp = fieldFromInstruction(insn, 15, 5);
17278 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17279 tmp = fieldFromInstruction(insn, 25, 7) << 5;
17280 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17281 return S;
17282 case 20:
17283 tmp = fieldFromInstruction(insn, 7, 5);
17284 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17285 tmp = fieldFromInstruction(insn, 12, 20);
17286 if (!Check(S, decodeUImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17287 return S;
17288 case 21:
17289 tmp = fieldFromInstruction(insn, 7, 5);
17290 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17291 tmp = fieldFromInstruction(insn, 15, 5);
17292 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17293 tmp = fieldFromInstruction(insn, 20, 5);
17294 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17295 return S;
17296 case 22:
17297 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17298 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17299 tmp = fieldFromInstruction(insn, 15, 5);
17300 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17301 tmp = fieldFromInstruction(insn, 20, 4);
17302 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17303 return S;
17304 case 23:
17305 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17306 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17307 tmp = fieldFromInstruction(insn, 15, 5);
17308 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17309 tmp = fieldFromInstruction(insn, 20, 5);
17310 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17311 return S;
17312 case 24:
17313 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17314 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17315 tmp = fieldFromInstruction(insn, 15, 5);
17316 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17317 tmp = fieldFromInstruction(insn, 20, 5);
17318 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17319 return S;
17320 case 25:
17321 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17322 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17323 tmp = fieldFromInstruction(insn, 15, 5);
17324 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17325 tmp = fieldFromInstruction(insn, 20, 6);
17326 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17327 return S;
17328 case 26:
17329 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17330 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17331 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17332 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17333 tmp = fieldFromInstruction(insn, 15, 5);
17334 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17335 tmp = fieldFromInstruction(insn, 20, 5);
17336 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17337 return S;
17338 case 27:
17339 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17340 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17341 tmp = 0x0;
17342 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
17343 tmp |= fieldFromInstruction(insn, 16, 9);
17344 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17345 return S;
17346 case 28:
17347 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17348 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17349 tmp = fieldFromInstruction(insn, 16, 8);
17350 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17351 return S;
17352 case 29:
17353 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17354 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17355 tmp = 0x0;
17356 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
17357 tmp |= fieldFromInstruction(insn, 24, 1);
17358 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17359 return S;
17360 case 30:
17361 tmp = fieldFromInstruction(insn, 7, 5);
17362 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17363 tmp = fieldFromInstruction(insn, 15, 5);
17364 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17365 tmp = fieldFromInstruction(insn, 20, 3);
17366 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17367 return S;
17368 case 31:
17369 tmp = fieldFromInstruction(insn, 7, 5);
17370 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17371 tmp = fieldFromInstruction(insn, 15, 5);
17372 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17373 tmp = fieldFromInstruction(insn, 20, 5);
17374 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17375 return S;
17376 case 32:
17377 tmp = fieldFromInstruction(insn, 7, 5);
17378 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17379 tmp = 0x0;
17380 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
17381 tmp |= fieldFromInstruction(insn, 16, 9);
17382 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17383 return S;
17384 case 33:
17385 tmp = fieldFromInstruction(insn, 7, 5);
17386 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17387 tmp = fieldFromInstruction(insn, 16, 8);
17388 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17389 return S;
17390 case 34:
17391 tmp = fieldFromInstruction(insn, 7, 5);
17392 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17393 tmp = 0x0;
17394 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
17395 tmp |= fieldFromInstruction(insn, 24, 1);
17396 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17397 return S;
17398 case 35:
17399 tmp = fieldFromInstruction(insn, 7, 5);
17400 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17401 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17402 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17403 tmp = fieldFromInstruction(insn, 20, 4);
17404 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17405 return S;
17406 case 36:
17407 tmp = fieldFromInstruction(insn, 7, 5);
17408 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17409 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17410 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17411 tmp = fieldFromInstruction(insn, 20, 5);
17412 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17413 return S;
17414 case 37:
17415 tmp = fieldFromInstruction(insn, 7, 5);
17416 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17417 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17418 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17419 tmp = fieldFromInstruction(insn, 20, 6);
17420 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17421 return S;
17422 case 38:
17423 tmp = fieldFromInstruction(insn, 7, 5);
17424 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17425 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17426 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17427 tmp = fieldFromInstruction(insn, 20, 5);
17428 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17429 return S;
17430 case 39:
17431 tmp = fieldFromInstruction(insn, 7, 5);
17432 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17433 tmp = fieldFromInstruction(insn, 15, 5);
17434 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17435 tmp = fieldFromInstruction(insn, 20, 6);
17436 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17437 return S;
17438 case 40:
17439 tmp = fieldFromInstruction(insn, 7, 5);
17440 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17441 tmp = fieldFromInstruction(insn, 15, 5);
17442 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17443 tmp = fieldFromInstruction(insn, 20, 4);
17444 if (!Check(S, decodeUImmPlus1Operand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17445 return S;
17446 case 41:
17447 tmp = fieldFromInstruction(insn, 7, 5);
17448 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17449 tmp = fieldFromInstruction(insn, 15, 5);
17450 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17451 tmp = fieldFromInstruction(insn, 20, 5);
17452 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17453 return S;
17454 case 42:
17455 tmp = fieldFromInstruction(insn, 7, 5);
17456 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17457 tmp = fieldFromInstruction(insn, 15, 5);
17458 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17459 tmp = fieldFromInstruction(insn, 20, 6);
17460 if (!Check(S, decodeUImmPlus1Operand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17461 return S;
17462 case 43:
17463 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17464 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17465 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17466 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17467 tmp = fieldFromInstruction(insn, 20, 3);
17468 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17469 return S;
17470 case 44:
17471 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17472 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17473 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17474 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17475 tmp = fieldFromInstruction(insn, 20, 4);
17476 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17477 return S;
17478 case 45:
17479 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17480 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17481 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17482 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17483 tmp = fieldFromInstruction(insn, 20, 5);
17484 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17485 return S;
17486 case 46:
17487 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17488 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17489 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17490 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17491 tmp = fieldFromInstruction(insn, 20, 5);
17492 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17493 return S;
17494 case 47:
17495 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17496 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17497 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17498 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17499 return S;
17500 case 48:
17501 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17502 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17503 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17504 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17505 tmp = fieldFromInstruction(insn, 21, 4) << 1;
17506 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17507 return S;
17508 case 49:
17509 tmp = fieldFromInstruction(insn, 20, 5);
17510 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17511 tmp = fieldFromInstruction(insn, 15, 5);
17512 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17513 tmp = 0x0;
17514 tmp |= fieldFromInstruction(insn, 7, 5);
17515 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17516 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17517 return S;
17518 case 50:
17519 tmp = fieldFromInstruction(insn, 20, 5);
17520 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17521 tmp = fieldFromInstruction(insn, 15, 5);
17522 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17523 tmp = 0x0;
17524 tmp |= fieldFromInstruction(insn, 7, 5);
17525 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17526 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17527 return S;
17528 case 51:
17529 tmp = fieldFromInstruction(insn, 20, 5);
17530 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17531 tmp = fieldFromInstruction(insn, 15, 5);
17532 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17533 tmp = 0x0;
17534 tmp |= fieldFromInstruction(insn, 7, 5);
17535 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17536 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17537 return S;
17538 case 52:
17539 tmp = fieldFromInstruction(insn, 20, 5);
17540 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17541 tmp = fieldFromInstruction(insn, 15, 5);
17542 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17543 tmp = 0x0;
17544 tmp |= fieldFromInstruction(insn, 7, 5);
17545 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17546 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17547 return S;
17548 case 53:
17549 tmp = fieldFromInstruction(insn, 20, 5);
17550 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17551 tmp = fieldFromInstruction(insn, 15, 5);
17552 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17553 tmp = 0x0;
17554 tmp |= fieldFromInstruction(insn, 7, 5);
17555 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17556 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17557 return S;
17558 case 54:
17559 tmp = fieldFromInstruction(insn, 7, 5);
17560 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17561 tmp = fieldFromInstruction(insn, 20, 5);
17562 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17563 tmp = fieldFromInstruction(insn, 15, 5);
17564 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17565 return S;
17566 case 55:
17567 tmp = fieldFromInstruction(insn, 7, 5);
17568 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17569 tmp = fieldFromInstruction(insn, 7, 5);
17570 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17571 tmp = fieldFromInstruction(insn, 20, 5);
17572 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17573 tmp = fieldFromInstruction(insn, 15, 5);
17574 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17575 return S;
17576 case 56:
17577 tmp = fieldFromInstruction(insn, 7, 5);
17578 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17579 tmp = fieldFromInstruction(insn, 7, 5);
17580 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17581 tmp = fieldFromInstruction(insn, 20, 5);
17582 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17583 tmp = fieldFromInstruction(insn, 15, 5);
17584 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17585 return S;
17586 case 57:
17587 tmp = fieldFromInstruction(insn, 20, 5);
17588 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17589 tmp = fieldFromInstruction(insn, 15, 5);
17590 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17591 return S;
17592 case 58:
17593 tmp = fieldFromInstruction(insn, 7, 5);
17594 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17595 tmp = fieldFromInstruction(insn, 15, 5);
17596 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17597 tmp = fieldFromInstruction(insn, 20, 5);
17598 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17599 tmp = fieldFromInstruction(insn, 30, 2);
17600 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17601 return S;
17602 case 59:
17603 tmp = fieldFromInstruction(insn, 7, 5);
17604 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17605 tmp = fieldFromInstruction(insn, 7, 5);
17606 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17607 tmp = fieldFromInstruction(insn, 15, 5);
17608 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17609 tmp = fieldFromInstruction(insn, 20, 5);
17610 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17611 return S;
17612 case 60:
17613 tmp = fieldFromInstruction(insn, 7, 5);
17614 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17615 tmp = fieldFromInstruction(insn, 15, 5);
17616 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17617 tmp = fieldFromInstruction(insn, 20, 5);
17618 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17619 tmp = fieldFromInstruction(insn, 27, 5);
17620 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17621 tmp = fieldFromInstruction(insn, 12, 3);
17622 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17623 return S;
17624 case 61:
17625 tmp = fieldFromInstruction(insn, 7, 5);
17626 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17627 tmp = fieldFromInstruction(insn, 15, 5);
17628 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17629 tmp = fieldFromInstruction(insn, 20, 5);
17630 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17631 tmp = fieldFromInstruction(insn, 27, 5);
17632 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17633 tmp = fieldFromInstruction(insn, 12, 3);
17634 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17635 return S;
17636 case 62:
17637 tmp = fieldFromInstruction(insn, 7, 5);
17638 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17639 tmp = fieldFromInstruction(insn, 15, 5);
17640 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17641 tmp = fieldFromInstruction(insn, 20, 5);
17642 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17643 tmp = fieldFromInstruction(insn, 27, 5);
17644 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17645 tmp = fieldFromInstruction(insn, 12, 3);
17646 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17647 return S;
17648 case 63:
17649 tmp = fieldFromInstruction(insn, 7, 5);
17650 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17651 tmp = fieldFromInstruction(insn, 15, 5);
17652 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17653 tmp = fieldFromInstruction(insn, 20, 5);
17654 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17655 tmp = fieldFromInstruction(insn, 27, 5);
17656 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17657 tmp = fieldFromInstruction(insn, 12, 3);
17658 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17659 return S;
17660 case 64:
17661 tmp = fieldFromInstruction(insn, 7, 5);
17662 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17663 tmp = fieldFromInstruction(insn, 15, 5);
17664 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17665 tmp = fieldFromInstruction(insn, 20, 5);
17666 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17667 tmp = fieldFromInstruction(insn, 12, 3);
17668 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17669 return S;
17670 case 65:
17671 tmp = fieldFromInstruction(insn, 7, 5);
17672 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17673 tmp = fieldFromInstruction(insn, 15, 5);
17674 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17675 tmp = fieldFromInstruction(insn, 20, 5);
17676 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17677 tmp = fieldFromInstruction(insn, 12, 3);
17678 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17679 return S;
17680 case 66:
17681 tmp = fieldFromInstruction(insn, 7, 5);
17682 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17683 tmp = fieldFromInstruction(insn, 15, 5);
17684 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17685 tmp = fieldFromInstruction(insn, 20, 5);
17686 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17687 tmp = fieldFromInstruction(insn, 12, 3);
17688 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17689 return S;
17690 case 67:
17691 tmp = fieldFromInstruction(insn, 7, 5);
17692 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17693 tmp = fieldFromInstruction(insn, 15, 5);
17694 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17695 tmp = fieldFromInstruction(insn, 20, 5);
17696 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17697 tmp = fieldFromInstruction(insn, 12, 3);
17698 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17699 return S;
17700 case 68:
17701 tmp = fieldFromInstruction(insn, 7, 5);
17702 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17703 tmp = fieldFromInstruction(insn, 15, 5);
17704 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17705 tmp = fieldFromInstruction(insn, 20, 5);
17706 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17707 return S;
17708 case 69:
17709 tmp = fieldFromInstruction(insn, 7, 5);
17710 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17711 tmp = fieldFromInstruction(insn, 15, 5);
17712 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17713 tmp = fieldFromInstruction(insn, 20, 5);
17714 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17715 return S;
17716 case 70:
17717 tmp = fieldFromInstruction(insn, 7, 5);
17718 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17719 tmp = fieldFromInstruction(insn, 15, 5);
17720 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17721 tmp = fieldFromInstruction(insn, 20, 5);
17722 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17723 return S;
17724 case 71:
17725 tmp = fieldFromInstruction(insn, 7, 5);
17726 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17727 tmp = fieldFromInstruction(insn, 15, 5);
17728 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17729 tmp = fieldFromInstruction(insn, 20, 5);
17730 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17731 return S;
17732 case 72:
17733 tmp = fieldFromInstruction(insn, 7, 5);
17734 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17735 tmp = fieldFromInstruction(insn, 15, 5);
17736 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17737 tmp = fieldFromInstruction(insn, 12, 3);
17738 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17739 return S;
17740 case 73:
17741 tmp = fieldFromInstruction(insn, 7, 5);
17742 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17743 tmp = fieldFromInstruction(insn, 15, 5);
17744 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17745 tmp = fieldFromInstruction(insn, 12, 3);
17746 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17747 return S;
17748 case 74:
17749 tmp = fieldFromInstruction(insn, 7, 5);
17750 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17751 tmp = fieldFromInstruction(insn, 15, 5);
17752 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17753 tmp = fieldFromInstruction(insn, 12, 3);
17754 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17755 return S;
17756 case 75:
17757 tmp = fieldFromInstruction(insn, 7, 5);
17758 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17759 tmp = fieldFromInstruction(insn, 15, 5);
17760 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17761 tmp = fieldFromInstruction(insn, 12, 3);
17762 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17763 return S;
17764 case 76:
17765 tmp = fieldFromInstruction(insn, 7, 5);
17766 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17767 tmp = fieldFromInstruction(insn, 15, 5);
17768 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17769 tmp = fieldFromInstruction(insn, 12, 3);
17770 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17771 return S;
17772 case 77:
17773 tmp = fieldFromInstruction(insn, 7, 5);
17774 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17775 tmp = fieldFromInstruction(insn, 15, 5);
17776 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17777 tmp = fieldFromInstruction(insn, 12, 3);
17778 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17779 return S;
17780 case 78:
17781 tmp = fieldFromInstruction(insn, 7, 5);
17782 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17783 tmp = fieldFromInstruction(insn, 15, 5);
17784 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17785 tmp = fieldFromInstruction(insn, 12, 3);
17786 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17787 return S;
17788 case 79:
17789 tmp = fieldFromInstruction(insn, 7, 5);
17790 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17791 tmp = fieldFromInstruction(insn, 15, 5);
17792 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17793 tmp = fieldFromInstruction(insn, 12, 3);
17794 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17795 return S;
17796 case 80:
17797 tmp = fieldFromInstruction(insn, 7, 5);
17798 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17799 tmp = fieldFromInstruction(insn, 15, 5);
17800 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17801 tmp = fieldFromInstruction(insn, 12, 3);
17802 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17803 return S;
17804 case 81:
17805 tmp = fieldFromInstruction(insn, 7, 5);
17806 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17807 tmp = fieldFromInstruction(insn, 15, 5);
17808 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17809 tmp = fieldFromInstruction(insn, 12, 3);
17810 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17811 return S;
17812 case 82:
17813 tmp = fieldFromInstruction(insn, 7, 5);
17814 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17815 tmp = fieldFromInstruction(insn, 15, 5);
17816 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17817 tmp = fieldFromInstruction(insn, 12, 3);
17818 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17819 return S;
17820 case 83:
17821 tmp = fieldFromInstruction(insn, 7, 5);
17822 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17823 tmp = fieldFromInstruction(insn, 15, 5);
17824 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17825 tmp = fieldFromInstruction(insn, 12, 3);
17826 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17827 return S;
17828 case 84:
17829 tmp = fieldFromInstruction(insn, 7, 5);
17830 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17831 tmp = fieldFromInstruction(insn, 15, 5);
17832 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17833 tmp = fieldFromInstruction(insn, 12, 3);
17834 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17835 return S;
17836 case 85:
17837 tmp = fieldFromInstruction(insn, 7, 5);
17838 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17839 tmp = fieldFromInstruction(insn, 15, 5);
17840 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17841 tmp = fieldFromInstruction(insn, 12, 3);
17842 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17843 return S;
17844 case 86:
17845 tmp = fieldFromInstruction(insn, 7, 5);
17846 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17847 tmp = fieldFromInstruction(insn, 15, 5);
17848 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17849 tmp = fieldFromInstruction(insn, 20, 5);
17850 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17851 return S;
17852 case 87:
17853 tmp = fieldFromInstruction(insn, 7, 5);
17854 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17855 tmp = fieldFromInstruction(insn, 15, 5);
17856 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17857 tmp = fieldFromInstruction(insn, 20, 5);
17858 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17859 return S;
17860 case 88:
17861 tmp = fieldFromInstruction(insn, 7, 5);
17862 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17863 tmp = fieldFromInstruction(insn, 15, 5);
17864 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17865 tmp = fieldFromInstruction(insn, 20, 5);
17866 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17867 return S;
17868 case 89:
17869 tmp = fieldFromInstruction(insn, 7, 5);
17870 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17871 tmp = fieldFromInstruction(insn, 15, 5);
17872 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17873 tmp = fieldFromInstruction(insn, 20, 5);
17874 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17875 return S;
17876 case 90:
17877 tmp = fieldFromInstruction(insn, 7, 5);
17878 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17879 tmp = fieldFromInstruction(insn, 15, 5);
17880 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17881 tmp = fieldFromInstruction(insn, 20, 5);
17882 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17883 return S;
17884 case 91:
17885 tmp = fieldFromInstruction(insn, 7, 5);
17886 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17887 tmp = fieldFromInstruction(insn, 15, 5);
17888 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17889 tmp = fieldFromInstruction(insn, 20, 5);
17890 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17891 return S;
17892 case 92:
17893 tmp = fieldFromInstruction(insn, 7, 5);
17894 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17895 tmp = fieldFromInstruction(insn, 15, 5);
17896 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17897 tmp = fieldFromInstruction(insn, 12, 3);
17898 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17899 return S;
17900 case 93:
17901 tmp = fieldFromInstruction(insn, 7, 5);
17902 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17903 tmp = fieldFromInstruction(insn, 15, 5);
17904 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17905 tmp = fieldFromInstruction(insn, 12, 3);
17906 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17907 return S;
17908 case 94:
17909 tmp = fieldFromInstruction(insn, 7, 5);
17910 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17911 tmp = fieldFromInstruction(insn, 15, 5);
17912 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17913 tmp = 0x1;
17914 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17915 return S;
17916 case 95:
17917 tmp = fieldFromInstruction(insn, 7, 5);
17918 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17919 tmp = fieldFromInstruction(insn, 15, 5);
17920 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17921 tmp = fieldFromInstruction(insn, 12, 3);
17922 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17923 return S;
17924 case 96:
17925 tmp = fieldFromInstruction(insn, 7, 5);
17926 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17927 tmp = fieldFromInstruction(insn, 15, 5);
17928 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17929 tmp = fieldFromInstruction(insn, 12, 3);
17930 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17931 return S;
17932 case 97:
17933 tmp = fieldFromInstruction(insn, 7, 5);
17934 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17935 tmp = fieldFromInstruction(insn, 15, 5);
17936 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17937 tmp = fieldFromInstruction(insn, 12, 3);
17938 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17939 return S;
17940 case 98:
17941 tmp = fieldFromInstruction(insn, 7, 5);
17942 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17943 tmp = fieldFromInstruction(insn, 15, 5);
17944 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17945 tmp = fieldFromInstruction(insn, 12, 3);
17946 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17947 return S;
17948 case 99:
17949 tmp = fieldFromInstruction(insn, 7, 5);
17950 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17951 tmp = fieldFromInstruction(insn, 15, 5);
17952 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17953 tmp = fieldFromInstruction(insn, 12, 3);
17954 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17955 return S;
17956 case 100:
17957 tmp = fieldFromInstruction(insn, 7, 5);
17958 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17959 tmp = fieldFromInstruction(insn, 15, 5);
17960 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17961 tmp = fieldFromInstruction(insn, 12, 3);
17962 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17963 return S;
17964 case 101:
17965 tmp = fieldFromInstruction(insn, 7, 5);
17966 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17967 tmp = fieldFromInstruction(insn, 15, 5);
17968 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17969 return S;
17970 case 102:
17971 tmp = fieldFromInstruction(insn, 7, 5);
17972 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17973 tmp = fieldFromInstruction(insn, 15, 5);
17974 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17975 return S;
17976 case 103:
17977 tmp = fieldFromInstruction(insn, 7, 5);
17978 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17979 tmp = fieldFromInstruction(insn, 15, 5);
17980 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17981 return S;
17982 case 104:
17983 tmp = fieldFromInstruction(insn, 7, 5);
17984 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17985 tmp = fieldFromInstruction(insn, 15, 5);
17986 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17987 return S;
17988 case 105:
17989 tmp = fieldFromInstruction(insn, 7, 5);
17990 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17991 tmp = fieldFromInstruction(insn, 15, 5);
17992 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17993 return S;
17994 case 106:
17995 tmp = fieldFromInstruction(insn, 7, 5);
17996 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17997 tmp = fieldFromInstruction(insn, 15, 5);
17998 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
17999 return S;
18000 case 107:
18001 tmp = fieldFromInstruction(insn, 7, 5);
18002 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18003 tmp = fieldFromInstruction(insn, 15, 5);
18004 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18005 return S;
18006 case 108:
18007 tmp = fieldFromInstruction(insn, 7, 5);
18008 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18009 tmp = fieldFromInstruction(insn, 15, 5);
18010 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18011 return S;
18012 case 109:
18013 tmp = fieldFromInstruction(insn, 7, 5);
18014 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18015 tmp = fieldFromInstruction(insn, 15, 5);
18016 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18017 return S;
18018 case 110:
18019 tmp = fieldFromInstruction(insn, 7, 5);
18020 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18021 tmp = fieldFromInstruction(insn, 15, 5);
18022 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18023 return S;
18024 case 111:
18025 tmp = fieldFromInstruction(insn, 7, 5);
18026 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18027 tmp = fieldFromInstruction(insn, 15, 5);
18028 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18029 return S;
18030 case 112:
18031 tmp = fieldFromInstruction(insn, 7, 5);
18032 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18033 tmp = fieldFromInstruction(insn, 20, 5);
18034 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18035 tmp = fieldFromInstruction(insn, 15, 5);
18036 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18037 tmp = fieldFromInstruction(insn, 25, 1);
18038 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18039 return S;
18040 case 113:
18041 tmp = fieldFromInstruction(insn, 7, 5);
18042 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18043 tmp = fieldFromInstruction(insn, 20, 5);
18044 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18045 tmp = fieldFromInstruction(insn, 15, 5);
18046 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18047 tmp = 0x0;
18048 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18049 return S;
18050 case 114:
18051 tmp = fieldFromInstruction(insn, 7, 5);
18052 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18053 tmp = fieldFromInstruction(insn, 20, 5);
18054 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18055 tmp = fieldFromInstruction(insn, 15, 5);
18056 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18057 return S;
18058 case 115:
18059 tmp = fieldFromInstruction(insn, 7, 5);
18060 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18061 tmp = fieldFromInstruction(insn, 15, 5);
18062 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18063 return S;
18064 case 116:
18065 tmp = fieldFromInstruction(insn, 7, 5);
18066 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18067 tmp = fieldFromInstruction(insn, 7, 5);
18068 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18069 tmp = fieldFromInstruction(insn, 15, 5);
18070 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18071 tmp = fieldFromInstruction(insn, 20, 5);
18072 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18073 return S;
18074 case 117:
18075 tmp = fieldFromInstruction(insn, 7, 5);
18076 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18077 tmp = fieldFromInstruction(insn, 7, 5);
18078 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18079 tmp = fieldFromInstruction(insn, 15, 5);
18080 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18081 tmp = fieldFromInstruction(insn, 20, 5);
18082 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18083 tmp = 0x0;
18084 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18085 return S;
18086 case 118:
18087 tmp = fieldFromInstruction(insn, 7, 5);
18088 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18089 tmp = fieldFromInstruction(insn, 20, 5);
18090 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18091 return S;
18092 case 119:
18093 tmp = fieldFromInstruction(insn, 7, 5);
18094 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18095 tmp = fieldFromInstruction(insn, 20, 5);
18096 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18097 tmp = fieldFromInstruction(insn, 25, 1);
18098 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18099 return S;
18100 case 120:
18101 tmp = fieldFromInstruction(insn, 7, 5);
18102 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18103 tmp = fieldFromInstruction(insn, 7, 5);
18104 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18105 tmp = fieldFromInstruction(insn, 15, 5);
18106 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18107 tmp = fieldFromInstruction(insn, 20, 5);
18108 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18109 tmp = fieldFromInstruction(insn, 25, 1);
18110 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18111 return S;
18112 case 121:
18113 tmp = fieldFromInstruction(insn, 7, 5);
18114 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18115 tmp = fieldFromInstruction(insn, 20, 5);
18116 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18117 return S;
18118 case 122:
18119 tmp = fieldFromInstruction(insn, 7, 5);
18120 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18121 tmp = fieldFromInstruction(insn, 20, 5);
18122 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18123 tmp = fieldFromInstruction(insn, 25, 1);
18124 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18125 return S;
18126 case 123:
18127 tmp = fieldFromInstruction(insn, 7, 5);
18128 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18129 tmp = fieldFromInstruction(insn, 25, 1);
18130 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18131 return S;
18132 case 124:
18133 tmp = fieldFromInstruction(insn, 7, 5);
18134 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18135 tmp = fieldFromInstruction(insn, 7, 5);
18136 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18137 tmp = fieldFromInstruction(insn, 20, 5);
18138 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18139 tmp = fieldFromInstruction(insn, 15, 5);
18140 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18141 tmp = fieldFromInstruction(insn, 25, 1);
18142 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18143 return S;
18144 case 125:
18145 tmp = fieldFromInstruction(insn, 7, 5);
18146 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18147 tmp = fieldFromInstruction(insn, 20, 5);
18148 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18149 tmp = fieldFromInstruction(insn, 15, 5);
18150 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18151 tmp = fieldFromInstruction(insn, 25, 1);
18152 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18153 return S;
18154 case 126:
18155 tmp = fieldFromInstruction(insn, 7, 5);
18156 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18157 tmp = fieldFromInstruction(insn, 20, 5);
18158 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18159 tmp = fieldFromInstruction(insn, 15, 5);
18160 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18161 tmp = fieldFromInstruction(insn, 25, 1);
18162 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18163 return S;
18164 case 127:
18165 tmp = fieldFromInstruction(insn, 7, 5);
18166 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18167 tmp = fieldFromInstruction(insn, 20, 5);
18168 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18169 tmp = fieldFromInstruction(insn, 15, 5);
18170 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18171 tmp = 0x0;
18172 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18173 return S;
18174 case 128:
18175 tmp = fieldFromInstruction(insn, 7, 5);
18176 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18177 tmp = fieldFromInstruction(insn, 20, 5);
18178 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18179 tmp = fieldFromInstruction(insn, 15, 5);
18180 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18181 return S;
18182 case 129:
18183 tmp = fieldFromInstruction(insn, 7, 5);
18184 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18185 tmp = fieldFromInstruction(insn, 20, 5);
18186 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18187 tmp = 0x0;
18188 tmp |= fieldFromInstruction(insn, 15, 5);
18189 tmp |= fieldFromInstruction(insn, 26, 1) << 5;
18190 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18191 tmp = fieldFromInstruction(insn, 25, 1);
18192 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18193 return S;
18194 case 130:
18195 tmp = fieldFromInstruction(insn, 7, 5);
18196 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18197 tmp = fieldFromInstruction(insn, 15, 5);
18198 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18199 return S;
18200 case 131:
18201 tmp = fieldFromInstruction(insn, 7, 5);
18202 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18203 tmp = fieldFromInstruction(insn, 20, 5);
18204 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18205 return S;
18206 case 132:
18207 tmp = fieldFromInstruction(insn, 7, 5);
18208 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18209 tmp = fieldFromInstruction(insn, 20, 5);
18210 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18211 return S;
18212 case 133:
18213 tmp = fieldFromInstruction(insn, 7, 5);
18214 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18215 tmp = fieldFromInstruction(insn, 20, 5);
18216 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18217 return S;
18218 case 134:
18219 tmp = fieldFromInstruction(insn, 7, 5);
18220 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18221 tmp = fieldFromInstruction(insn, 20, 5);
18222 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18223 return S;
18224 case 135:
18225 tmp = fieldFromInstruction(insn, 7, 5);
18226 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18227 tmp = fieldFromInstruction(insn, 20, 5);
18228 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18229 tmp = fieldFromInstruction(insn, 15, 5);
18230 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18231 tmp = fieldFromInstruction(insn, 25, 1);
18232 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18233 return S;
18234 case 136:
18235 tmp = fieldFromInstruction(insn, 7, 5);
18236 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18237 tmp = fieldFromInstruction(insn, 20, 5);
18238 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18239 tmp = fieldFromInstruction(insn, 15, 5);
18240 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18241 tmp = 0x0;
18242 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18243 return S;
18244 case 137:
18245 tmp = fieldFromInstruction(insn, 7, 5);
18246 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18247 tmp = fieldFromInstruction(insn, 20, 5);
18248 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18249 tmp = fieldFromInstruction(insn, 15, 5);
18250 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18251 return S;
18252 case 138:
18253 tmp = fieldFromInstruction(insn, 7, 5);
18254 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18255 tmp = fieldFromInstruction(insn, 20, 5);
18256 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18257 tmp = fieldFromInstruction(insn, 15, 5);
18258 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18259 tmp = fieldFromInstruction(insn, 25, 1);
18260 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18261 return S;
18262 case 139:
18263 tmp = fieldFromInstruction(insn, 7, 5);
18264 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18265 tmp = fieldFromInstruction(insn, 7, 5);
18266 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18267 tmp = fieldFromInstruction(insn, 15, 5);
18268 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18269 return S;
18270 case 140:
18271 tmp = fieldFromInstruction(insn, 7, 5);
18272 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18273 tmp = fieldFromInstruction(insn, 20, 5);
18274 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18275 tmp = fieldFromInstruction(insn, 15, 5);
18276 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18277 tmp = 0x0;
18278 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18279 return S;
18280 case 141:
18281 tmp = fieldFromInstruction(insn, 7, 5);
18282 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18283 tmp = fieldFromInstruction(insn, 15, 5);
18284 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18285 return S;
18286 case 142:
18287 tmp = fieldFromInstruction(insn, 7, 5);
18288 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18289 tmp = fieldFromInstruction(insn, 7, 5);
18290 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18291 tmp = fieldFromInstruction(insn, 15, 5);
18292 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18293 tmp = fieldFromInstruction(insn, 20, 5);
18294 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18295 tmp = fieldFromInstruction(insn, 25, 1);
18296 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18297 return S;
18298 case 143:
18299 tmp = fieldFromInstruction(insn, 7, 5);
18300 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18301 tmp = fieldFromInstruction(insn, 7, 5);
18302 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18303 tmp = fieldFromInstruction(insn, 15, 5);
18304 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18305 return S;
18306 case 144:
18307 tmp = fieldFromInstruction(insn, 7, 5);
18308 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18309 tmp = fieldFromInstruction(insn, 7, 5);
18310 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18311 tmp = fieldFromInstruction(insn, 20, 5);
18312 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18313 tmp = fieldFromInstruction(insn, 15, 5);
18314 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18315 tmp = fieldFromInstruction(insn, 25, 1);
18316 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18317 return S;
18318 case 145:
18319 tmp = fieldFromInstruction(insn, 7, 5);
18320 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18321 tmp = fieldFromInstruction(insn, 7, 5);
18322 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18323 tmp = fieldFromInstruction(insn, 15, 5);
18324 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18325 tmp = fieldFromInstruction(insn, 20, 5);
18326 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18327 tmp = fieldFromInstruction(insn, 25, 1);
18328 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18329 return S;
18330 case 146:
18331 tmp = fieldFromInstruction(insn, 7, 5);
18332 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18333 tmp = fieldFromInstruction(insn, 15, 5);
18334 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18335 tmp = fieldFromInstruction(insn, 20, 11);
18336 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18337 return S;
18338 case 147:
18339 tmp = fieldFromInstruction(insn, 7, 5);
18340 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18341 tmp = fieldFromInstruction(insn, 15, 5);
18342 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18343 tmp = fieldFromInstruction(insn, 20, 10);
18344 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18345 return S;
18346 case 148:
18347 tmp = fieldFromInstruction(insn, 15, 5);
18348 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18349 tmp = fieldFromInstruction(insn, 20, 5);
18350 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18351 tmp = 0x0;
18352 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18353 tmp |= fieldFromInstruction(insn, 8, 4);
18354 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18355 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18356 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18357 return S;
18358 case 149:
18359 tmp = fieldFromInstruction(insn, 15, 5);
18360 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18361 tmp = fieldFromInstruction(insn, 20, 5);
18362 if (!Check(S, decodeImmZibiOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18363 tmp = 0x0;
18364 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18365 tmp |= fieldFromInstruction(insn, 8, 4);
18366 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18367 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18368 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18369 return S;
18370 case 150:
18371 tmp = fieldFromInstruction(insn, 7, 5);
18372 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18373 tmp = 0x0;
18374 tmp |= fieldFromInstruction(insn, 12, 8) << 11;
18375 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
18376 tmp |= fieldFromInstruction(insn, 21, 10);
18377 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
18378 if (!Check(S, decodeSImmOperandAndLslN<21, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18379 return S;
18380 case 151:
18381 tmp = fieldFromInstruction(insn, 15, 5);
18382 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18383 tmp = fieldFromInstruction(insn, 20, 5);
18384 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18385 return S;
18386 case 152:
18387 tmp = fieldFromInstruction(insn, 7, 5);
18388 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18389 tmp = fieldFromInstruction(insn, 20, 12);
18390 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18391 tmp = fieldFromInstruction(insn, 15, 5);
18392 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18393 return S;
18394 case 153:
18395 tmp = fieldFromInstruction(insn, 15, 5);
18396 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18397 return S;
18398 case 154:
18399 tmp = fieldFromInstruction(insn, 7, 5);
18400 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18401 return S;
18402 case 155:
18403 tmp = fieldFromInstruction(insn, 20, 5);
18404 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18405 return S;
18406 case 156:
18407 tmp = fieldFromInstruction(insn, 7, 5);
18408 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18409 tmp = fieldFromInstruction(insn, 20, 12);
18410 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18411 tmp = fieldFromInstruction(insn, 15, 5);
18412 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18413 return S;
18414 case 157:
18415 tmp = fieldFromInstruction(insn, 7, 5);
18416 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18417 tmp = fieldFromInstruction(insn, 20, 5);
18418 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18419 tmp = fieldFromInstruction(insn, 15, 5);
18420 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18421 return S;
18422 case 158:
18423 tmp = fieldFromInstruction(insn, 7, 5);
18424 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18425 tmp = fieldFromInstruction(insn, 7, 5);
18426 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18427 tmp = fieldFromInstruction(insn, 20, 5);
18428 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18429 tmp = fieldFromInstruction(insn, 15, 5);
18430 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18431 return S;
18432 case 159:
18433 tmp = fieldFromInstruction(insn, 7, 5);
18434 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18435 tmp = fieldFromInstruction(insn, 7, 5);
18436 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18437 tmp = fieldFromInstruction(insn, 20, 5);
18438 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18439 return S;
18440 case 160:
18441 tmp = fieldFromInstruction(insn, 7, 5);
18442 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18443 tmp = fieldFromInstruction(insn, 7, 5);
18444 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18445 tmp = fieldFromInstruction(insn, 20, 5);
18446 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18447 tmp = fieldFromInstruction(insn, 15, 5);
18448 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18449 return S;
18450 case 161:
18451 tmp = fieldFromInstruction(insn, 7, 5);
18452 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18453 tmp = fieldFromInstruction(insn, 7, 5);
18454 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18455 tmp = fieldFromInstruction(insn, 23, 2) << 3;
18456 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18457 tmp = fieldFromInstruction(insn, 15, 5);
18458 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18459 tmp = fieldFromInstruction(insn, 20, 3);
18460 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18461 tmp = fieldFromInstruction(insn, 25, 1);
18462 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18463 return S;
18464 case 162:
18465 tmp = fieldFromInstruction(insn, 7, 5);
18466 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18467 tmp = fieldFromInstruction(insn, 15, 5);
18468 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18469 tmp = fieldFromInstruction(insn, 20, 5);
18470 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18471 return S;
18472 case 163:
18473 tmp = fieldFromInstruction(insn, 7, 5);
18474 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18475 tmp = fieldFromInstruction(insn, 15, 5);
18476 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18477 return S;
18478 case 164:
18479 tmp = fieldFromInstruction(insn, 7, 5);
18480 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18481 tmp = fieldFromInstruction(insn, 15, 5);
18482 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18483 tmp = fieldFromInstruction(insn, 20, 5);
18484 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18485 return S;
18486 case 165:
18487 tmp = fieldFromInstruction(insn, 7, 5);
18488 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18489 tmp = fieldFromInstruction(insn, 15, 5);
18490 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18491 tmp = fieldFromInstruction(insn, 20, 5);
18492 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18493 return S;
18494 case 166:
18495 tmp = fieldFromInstruction(insn, 7, 5);
18496 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18497 tmp = fieldFromInstruction(insn, 15, 5);
18498 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18499 tmp = fieldFromInstruction(insn, 20, 5);
18500 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18501 return S;
18502 case 167:
18503 tmp = fieldFromInstruction(insn, 7, 5);
18504 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18505 tmp = fieldFromInstruction(insn, 15, 5);
18506 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18507 return S;
18508 case 168:
18509 tmp = fieldFromInstruction(insn, 7, 5);
18510 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18511 tmp = fieldFromInstruction(insn, 15, 5);
18512 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18513 tmp = fieldFromInstruction(insn, 20, 12);
18514 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18515 return S;
18516 case 169:
18517 tmp = fieldFromInstruction(insn, 7, 5);
18518 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18519 tmp = fieldFromInstruction(insn, 15, 5);
18520 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18521 tmp = fieldFromInstruction(insn, 20, 7);
18522 if (!Check(S, decodeUImm7EqXLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18523 return S;
18524 case 170:
18525 tmp = fieldFromInstruction(insn, 7, 5);
18526 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18527 tmp = fieldFromInstruction(insn, 15, 5);
18528 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18529 tmp = fieldFromInstruction(insn, 20, 9);
18530 if (!Check(S, DecodeYBNDSWImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18531 return S;
18532 case 171:
18533 tmp = fieldFromInstruction(insn, 7, 5);
18534 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18535 tmp = fieldFromInstruction(insn, 15, 5);
18536 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18537 tmp = fieldFromInstruction(insn, 20, 12);
18538 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18539 return S;
18540 case 172:
18541 tmp = fieldFromInstruction(insn, 20, 5);
18542 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18543 tmp = fieldFromInstruction(insn, 15, 5);
18544 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18545 tmp = 0x0;
18546 tmp |= fieldFromInstruction(insn, 7, 5);
18547 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18548 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18549 return S;
18550 case 173:
18551 tmp = fieldFromInstruction(insn, 7, 5);
18552 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18553 tmp = fieldFromInstruction(insn, 20, 12);
18554 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18555 tmp = fieldFromInstruction(insn, 15, 5);
18556 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18557 return S;
18558 case 174:
18559 tmp = fieldFromInstruction(insn, 7, 5);
18560 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18561 tmp = fieldFromInstruction(insn, 15, 5);
18562 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18563 tmp = fieldFromInstruction(insn, 20, 5);
18564 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18565 return S;
18566 case 175:
18567 tmp = fieldFromInstruction(insn, 7, 5);
18568 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18569 tmp = fieldFromInstruction(insn, 15, 5);
18570 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18571 tmp = fieldFromInstruction(insn, 20, 5);
18572 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18573 return S;
18574 case 176:
18575 tmp = fieldFromInstruction(insn, 7, 5);
18576 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18577 tmp = fieldFromInstruction(insn, 15, 5);
18578 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18579 return S;
18580 case 177:
18581 tmp = fieldFromInstruction(insn, 20, 5);
18582 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18583 tmp = 0x0;
18584 tmp |= fieldFromInstruction(insn, 7, 5);
18585 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18586 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18587 tmp = fieldFromInstruction(insn, 15, 5);
18588 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18589 return S;
18590 case 178:
18591 tmp = fieldFromInstruction(insn, 7, 5);
18592 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18593 tmp = fieldFromInstruction(insn, 12, 20);
18594 if (!Check(S, decodeUImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18595 return S;
18596 case 179:
18597 tmp = fieldFromInstruction(insn, 7, 5);
18598 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18599 tmp = fieldFromInstruction(insn, 15, 5);
18600 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18601 tmp = 0x0;
18602 tmp |= fieldFromInstruction(insn, 20, 5);
18603 tmp |= fieldFromInstruction(insn, 27, 5) << 5;
18604 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18605 return S;
18606 case 180:
18607 tmp = fieldFromInstruction(insn, 7, 5);
18608 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18609 tmp = fieldFromInstruction(insn, 15, 5);
18610 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18611 tmp = fieldFromInstruction(insn, 20, 5);
18612 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18613 tmp = fieldFromInstruction(insn, 27, 5);
18614 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18615 return S;
18616 case 181:
18617 tmp = fieldFromInstruction(insn, 7, 5);
18618 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18619 tmp = fieldFromInstruction(insn, 15, 5);
18620 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18621 tmp = fieldFromInstruction(insn, 20, 5);
18622 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18623 tmp = fieldFromInstruction(insn, 27, 5);
18624 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18625 tmp = fieldFromInstruction(insn, 12, 3);
18626 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18627 return S;
18628 case 182:
18629 tmp = fieldFromInstruction(insn, 7, 5);
18630 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18631 tmp = fieldFromInstruction(insn, 15, 5);
18632 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18633 tmp = fieldFromInstruction(insn, 20, 5);
18634 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18635 return S;
18636 case 183:
18637 tmp = fieldFromInstruction(insn, 7, 5);
18638 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18639 tmp = fieldFromInstruction(insn, 15, 5);
18640 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18641 tmp = fieldFromInstruction(insn, 20, 5);
18642 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18643 tmp = fieldFromInstruction(insn, 12, 3);
18644 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18645 return S;
18646 case 184:
18647 tmp = fieldFromInstruction(insn, 7, 5);
18648 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18649 tmp = fieldFromInstruction(insn, 15, 5);
18650 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18651 return S;
18652 case 185:
18653 tmp = fieldFromInstruction(insn, 7, 5);
18654 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18655 tmp = fieldFromInstruction(insn, 15, 5);
18656 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18657 tmp = fieldFromInstruction(insn, 20, 5);
18658 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18659 return S;
18660 case 186:
18661 tmp = fieldFromInstruction(insn, 7, 5);
18662 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18663 tmp = fieldFromInstruction(insn, 15, 5);
18664 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18665 tmp = fieldFromInstruction(insn, 20, 5);
18666 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18667 return S;
18668 case 187:
18669 tmp = fieldFromInstruction(insn, 7, 5);
18670 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18671 tmp = fieldFromInstruction(insn, 15, 3);
18672 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18673 return S;
18674 case 188:
18675 tmp = fieldFromInstruction(insn, 7, 3);
18676 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18677 tmp = fieldFromInstruction(insn, 15, 5);
18678 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18679 tmp = 0x0;
18680 tmp |= fieldFromInstruction(insn, 12, 3);
18681 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18682 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18683 return S;
18684 case 189:
18685 tmp = fieldFromInstruction(insn, 7, 5);
18686 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18687 tmp = fieldFromInstruction(insn, 15, 5);
18688 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18689 tmp = fieldFromInstruction(insn, 12, 3);
18690 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18691 return S;
18692 case 190:
18693 tmp = fieldFromInstruction(insn, 7, 5);
18694 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18695 tmp = fieldFromInstruction(insn, 15, 3);
18696 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18697 tmp = fieldFromInstruction(insn, 20, 3);
18698 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18699 tmp = 0x0;
18700 tmp |= fieldFromInstruction(insn, 18, 2);
18701 tmp |= fieldFromInstruction(insn, 23, 2) << 2;
18702 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18703 return S;
18704 case 191:
18705 tmp = fieldFromInstruction(insn, 7, 3);
18706 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18707 tmp = fieldFromInstruction(insn, 15, 3);
18708 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18709 return S;
18710 case 192:
18711 tmp = fieldFromInstruction(insn, 7, 3);
18712 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18713 tmp = fieldFromInstruction(insn, 15, 3);
18714 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18715 tmp = fieldFromInstruction(insn, 20, 3);
18716 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18717 return S;
18718 case 193:
18719 tmp = fieldFromInstruction(insn, 7, 5);
18720 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18721 tmp = fieldFromInstruction(insn, 15, 5);
18722 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18723 return S;
18724 case 194:
18725 tmp = fieldFromInstruction(insn, 7, 5);
18726 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18727 return S;
18728 case 195:
18729 tmp = fieldFromInstruction(insn, 7, 5);
18730 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18731 tmp = fieldFromInstruction(insn, 15, 5);
18732 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18733 tmp = fieldFromInstruction(insn, 20, 3);
18734 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18735 return S;
18736 case 196:
18737 tmp = fieldFromInstruction(insn, 7, 5);
18738 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18739 tmp = fieldFromInstruction(insn, 15, 5);
18740 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18741 tmp = 0x0;
18742 tmp |= fieldFromInstruction(insn, 12, 3);
18743 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18744 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18745 return S;
18746 case 197:
18747 tmp = fieldFromInstruction(insn, 7, 5);
18748 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18749 tmp = 0x0;
18750 tmp |= fieldFromInstruction(insn, 14, 1);
18751 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
18752 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
18753 tmp |= fieldFromInstruction(insn, 20, 1) << 11;
18754 tmp |= fieldFromInstruction(insn, 21, 10) << 1;
18755 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
18756 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18757 return S;
18758 case 198:
18759 tmp = fieldFromInstruction(insn, 20, 5);
18760 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18761 tmp = 0x0;
18762 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18763 tmp |= fieldFromInstruction(insn, 8, 4);
18764 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
18765 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
18766 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18767 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18768 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18769 return S;
18770 case 199:
18771 tmp = fieldFromInstruction(insn, 20, 5);
18772 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18773 tmp = 0x0;
18774 tmp |= fieldFromInstruction(insn, 7, 1) << 9;
18775 tmp |= fieldFromInstruction(insn, 8, 1) << 15;
18776 tmp |= fieldFromInstruction(insn, 9, 3);
18777 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
18778 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
18779 tmp |= fieldFromInstruction(insn, 25, 6) << 3;
18780 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18781 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18782 return S;
18783 case 200:
18784 tmp = fieldFromInstruction(insn, 7, 5);
18785 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18786 tmp = fieldFromInstruction(insn, 20, 5);
18787 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18788 return S;
18789 case 201:
18790 tmp = fieldFromInstruction(insn, 7, 5);
18791 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18792 tmp = fieldFromInstruction(insn, 20, 5);
18793 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18794 return S;
18795 case 202:
18796 tmp = fieldFromInstruction(insn, 7, 5);
18797 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18798 tmp = fieldFromInstruction(insn, 15, 5);
18799 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18800 tmp = fieldFromInstruction(insn, 20, 5);
18801 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18802 tmp = fieldFromInstruction(insn, 25, 1);
18803 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18804 return S;
18805 case 203:
18806 tmp = fieldFromInstruction(insn, 7, 5);
18807 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18808 tmp = 0x0;
18809 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
18810 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
18811 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
18812 tmp |= fieldFromInstruction(insn, 21, 10);
18813 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18814 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18815 return S;
18816 case 204:
18817 tmp = fieldFromInstruction(insn, 15, 5);
18818 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18819 tmp = 0x0;
18820 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
18821 tmp |= fieldFromInstruction(insn, 20, 5);
18822 tmp |= fieldFromInstruction(insn, 30, 1) << 6;
18823 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18824 tmp = 0x0;
18825 tmp |= fieldFromInstruction(insn, 8, 4);
18826 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
18827 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
18828 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18829 return S;
18830 case 205:
18831 tmp = fieldFromInstruction(insn, 7, 5);
18832 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18833 tmp = 0x0;
18834 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
18835 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
18836 tmp |= fieldFromInstruction(insn, 20, 1) << 9;
18837 tmp |= fieldFromInstruction(insn, 21, 1) << 15;
18838 tmp |= fieldFromInstruction(insn, 22, 9);
18839 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18840 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18841 return S;
18842 case 206:
18843 tmp = fieldFromInstruction(insn, 7, 5);
18844 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18845 tmp = fieldFromInstruction(insn, 15, 5);
18846 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18847 tmp = fieldFromInstruction(insn, 26, 6);
18848 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18849 tmp = fieldFromInstruction(insn, 20, 6);
18850 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18851 return S;
18852 case 207:
18853 tmp = fieldFromInstruction(insn, 20, 5);
18854 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18855 tmp = 0x0;
18856 tmp |= fieldFromInstruction(insn, 7, 1) << 11;
18857 tmp |= fieldFromInstruction(insn, 8, 4) << 1;
18858 tmp |= fieldFromInstruction(insn, 14, 1);
18859 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
18860 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
18861 tmp |= fieldFromInstruction(insn, 25, 6) << 5;
18862 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
18863 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18864 return S;
18865 case 208:
18866 tmp = fieldFromInstruction(insn, 7, 5);
18867 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18868 tmp = 0x0;
18869 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
18870 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
18871 tmp |= fieldFromInstruction(insn, 20, 1) << 8;
18872 tmp |= fieldFromInstruction(insn, 21, 2) << 14;
18873 tmp |= fieldFromInstruction(insn, 23, 8);
18874 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18875 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18876 return S;
18877 case 209:
18878 tmp = fieldFromInstruction(insn, 20, 5);
18879 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18880 tmp = 0x0;
18881 tmp |= fieldFromInstruction(insn, 7, 1) << 8;
18882 tmp |= fieldFromInstruction(insn, 8, 2) << 14;
18883 tmp |= fieldFromInstruction(insn, 10, 2);
18884 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
18885 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
18886 tmp |= fieldFromInstruction(insn, 25, 6) << 2;
18887 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18888 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18889 return S;
18890 case 210:
18891 tmp = fieldFromInstruction(insn, 15, 5);
18892 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18893 tmp = 0x0;
18894 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
18895 tmp |= fieldFromInstruction(insn, 20, 5);
18896 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18897 tmp = 0x0;
18898 tmp |= fieldFromInstruction(insn, 8, 4);
18899 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
18900 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
18901 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18902 return S;
18903 case 211:
18904 tmp = fieldFromInstruction(insn, 7, 5);
18905 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18906 tmp = fieldFromInstruction(insn, 15, 5);
18907 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18908 tmp = fieldFromInstruction(insn, 15, 5);
18909 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18910 tmp = fieldFromInstruction(insn, 20, 12);
18911 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18912 return S;
18913 case 212:
18914 tmp = fieldFromInstruction(insn, 15, 5);
18915 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18916 tmp = fieldFromInstruction(insn, 20, 5);
18917 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18918 tmp = fieldFromInstruction(insn, 15, 5);
18919 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18920 tmp = 0x0;
18921 tmp |= fieldFromInstruction(insn, 7, 5);
18922 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18923 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18924 return S;
18925 case 213:
18926 tmp = fieldFromInstruction(insn, 7, 5);
18927 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18928 tmp = fieldFromInstruction(insn, 15, 5);
18929 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18930 tmp = fieldFromInstruction(insn, 25, 5);
18931 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18932 tmp = fieldFromInstruction(insn, 20, 5);
18933 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18934 return S;
18935 case 214:
18936 tmp = fieldFromInstruction(insn, 7, 5);
18937 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18938 tmp = fieldFromInstruction(insn, 7, 5);
18939 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18940 tmp = fieldFromInstruction(insn, 15, 5);
18941 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18942 tmp = fieldFromInstruction(insn, 25, 5);
18943 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18944 tmp = fieldFromInstruction(insn, 20, 5);
18945 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18946 return S;
18947 case 215:
18948 tmp = fieldFromInstruction(insn, 7, 5);
18949 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18950 tmp = fieldFromInstruction(insn, 15, 5);
18951 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18952 tmp = 0x0;
18953 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18954 tmp |= fieldFromInstruction(insn, 25, 1);
18955 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18956 return S;
18957 case 216:
18958 tmp = fieldFromInstruction(insn, 7, 5);
18959 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18960 tmp = fieldFromInstruction(insn, 15, 5);
18961 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18962 tmp = fieldFromInstruction(insn, 25, 5);
18963 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18964 tmp = fieldFromInstruction(insn, 20, 5);
18965 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18966 return S;
18967 case 217:
18968 tmp = fieldFromInstruction(insn, 7, 5);
18969 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18970 tmp = fieldFromInstruction(insn, 15, 5);
18971 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18972 tmp = fieldFromInstruction(insn, 20, 5);
18973 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18974 tmp = fieldFromInstruction(insn, 25, 5);
18975 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18976 return S;
18977 case 218:
18978 tmp = fieldFromInstruction(insn, 7, 5);
18979 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18980 tmp = fieldFromInstruction(insn, 15, 5);
18981 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18982 tmp = fieldFromInstruction(insn, 15, 5);
18983 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18984 tmp = fieldFromInstruction(insn, 20, 5);
18985 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18986 return S;
18987 case 219:
18988 tmp = fieldFromInstruction(insn, 15, 5);
18989 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18990 tmp = fieldFromInstruction(insn, 20, 5);
18991 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18992 tmp = fieldFromInstruction(insn, 15, 5);
18993 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18994 tmp = fieldFromInstruction(insn, 7, 5);
18995 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18996 return S;
18997 case 220:
18998 tmp = fieldFromInstruction(insn, 20, 5);
18999 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19000 tmp = fieldFromInstruction(insn, 15, 5);
19001 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19002 tmp = fieldFromInstruction(insn, 7, 5);
19003 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19004 return S;
19005 case 221:
19006 tmp = fieldFromInstruction(insn, 7, 5);
19007 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19008 tmp = fieldFromInstruction(insn, 7, 5);
19009 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19010 tmp = fieldFromInstruction(insn, 15, 5);
19011 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19012 tmp = 0x0;
19013 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19014 tmp |= fieldFromInstruction(insn, 25, 1);
19015 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19016 return S;
19017 case 222:
19018 tmp = fieldFromInstruction(insn, 15, 5);
19019 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19020 tmp = fieldFromInstruction(insn, 20, 5);
19021 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19022 tmp = 0x0;
19023 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19024 tmp |= fieldFromInstruction(insn, 8, 4);
19025 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19026 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19027 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19028 return S;
19029 case 223:
19030 tmp = fieldFromInstruction(insn, 7, 5);
19031 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19032 tmp = fieldFromInstruction(insn, 7, 5);
19033 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19034 tmp = fieldFromInstruction(insn, 15, 5);
19035 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19036 tmp = fieldFromInstruction(insn, 20, 5);
19037 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19038 tmp = fieldFromInstruction(insn, 25, 5);
19039 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19040 return S;
19041 case 224:
19042 tmp = fieldFromInstruction(insn, 7, 5);
19043 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19044 tmp = fieldFromInstruction(insn, 15, 5);
19045 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19046 tmp = 0x0;
19047 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19048 tmp |= fieldFromInstruction(insn, 25, 1);
19049 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19050 return S;
19051 case 225:
19052 tmp = fieldFromInstruction(insn, 7, 5);
19053 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19054 tmp = fieldFromInstruction(insn, 15, 5);
19055 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19056 tmp = 0x0;
19057 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19058 tmp |= fieldFromInstruction(insn, 25, 1);
19059 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19060 return S;
19061 case 226:
19062 tmp = fieldFromInstruction(insn, 7, 5);
19063 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19064 tmp = fieldFromInstruction(insn, 7, 5);
19065 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19066 tmp = fieldFromInstruction(insn, 15, 5);
19067 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19068 tmp = 0x0;
19069 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19070 tmp |= fieldFromInstruction(insn, 25, 1);
19071 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19072 return S;
19073 case 227:
19074 tmp = fieldFromInstruction(insn, 7, 5);
19075 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19076 tmp = fieldFromInstruction(insn, 15, 5);
19077 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19078 tmp = 0x0;
19079 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19080 tmp |= fieldFromInstruction(insn, 25, 1);
19081 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19082 return S;
19083 case 228:
19084 tmp = fieldFromInstruction(insn, 15, 5);
19085 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19086 tmp = fieldFromInstruction(insn, 20, 9);
19087 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19088 tmp = fieldFromInstruction(insn, 7, 5);
19089 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19090 return S;
19091 case 229:
19092 tmp = fieldFromInstruction(insn, 7, 5);
19093 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19094 tmp = fieldFromInstruction(insn, 15, 5);
19095 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19096 tmp = fieldFromInstruction(insn, 20, 5);
19097 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19098 tmp = fieldFromInstruction(insn, 27, 5);
19099 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19100 return S;
19101 case 230:
19102 tmp = fieldFromInstruction(insn, 7, 5);
19103 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19104 tmp = fieldFromInstruction(insn, 27, 5);
19105 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19106 tmp = fieldFromInstruction(insn, 15, 5);
19107 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19108 tmp = fieldFromInstruction(insn, 23, 4) << 3;
19109 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19110 return S;
19111 case 231:
19112 tmp = fieldFromInstruction(insn, 7, 5);
19113 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19114 tmp = fieldFromInstruction(insn, 27, 5);
19115 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19116 tmp = fieldFromInstruction(insn, 15, 5);
19117 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19118 tmp = fieldFromInstruction(insn, 22, 5) << 2;
19119 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19120 return S;
19121 case 232:
19122 tmp = fieldFromInstruction(insn, 20, 5);
19123 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19124 tmp = fieldFromInstruction(insn, 27, 5);
19125 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19126 tmp = fieldFromInstruction(insn, 15, 5);
19127 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19128 tmp = 0x0;
19129 tmp |= fieldFromInstruction(insn, 10, 2) << 3;
19130 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
19131 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19132 return S;
19133 case 233:
19134 tmp = fieldFromInstruction(insn, 20, 5);
19135 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19136 tmp = fieldFromInstruction(insn, 27, 5);
19137 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19138 tmp = fieldFromInstruction(insn, 15, 5);
19139 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19140 tmp = 0x0;
19141 tmp |= fieldFromInstruction(insn, 9, 3) << 2;
19142 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
19143 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19144 return S;
19145 case 234:
19146 tmp = fieldFromInstruction(insn, 7, 5);
19147 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19148 tmp = fieldFromInstruction(insn, 15, 5);
19149 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19150 tmp = fieldFromInstruction(insn, 20, 5);
19151 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19152 tmp = fieldFromInstruction(insn, 12, 2);
19153 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19154 return S;
19155 case 235:
19156 tmp = fieldFromInstruction(insn, 7, 5);
19157 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19158 tmp = fieldFromInstruction(insn, 7, 5);
19159 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19160 tmp = fieldFromInstruction(insn, 15, 5);
19161 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19162 tmp = fieldFromInstruction(insn, 20, 5);
19163 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19164 return S;
19165 case 236:
19166 tmp = fieldFromInstruction(insn, 7, 5);
19167 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19168 tmp = fieldFromInstruction(insn, 7, 5);
19169 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19170 tmp = fieldFromInstruction(insn, 15, 5);
19171 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19172 tmp = fieldFromInstruction(insn, 20, 5);
19173 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19174 tmp = fieldFromInstruction(insn, 29, 2);
19175 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19176 return S;
19177 case 237:
19178 tmp = fieldFromInstruction(insn, 7, 5);
19179 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19180 tmp = fieldFromInstruction(insn, 15, 5);
19181 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19182 tmp = fieldFromInstruction(insn, 20, 5);
19183 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19184 tmp = fieldFromInstruction(insn, 12, 2);
19185 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19186 return S;
19187 case 238:
19188 tmp = fieldFromInstruction(insn, 7, 5);
19189 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19190 tmp = fieldFromInstruction(insn, 7, 5);
19191 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19192 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19193 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19194 tmp = fieldFromInstruction(insn, 20, 5);
19195 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19196 return S;
19197 case 239:
19198 tmp = fieldFromInstruction(insn, 7, 5);
19199 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19200 tmp = fieldFromInstruction(insn, 7, 5);
19201 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19202 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19203 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19204 tmp = fieldFromInstruction(insn, 20, 5);
19205 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19206 tmp = fieldFromInstruction(insn, 29, 2);
19207 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19208 return S;
19209 case 240:
19210 tmp = fieldFromInstruction(insn, 8, 4) << 1;
19211 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19212 tmp = fieldFromInstruction(insn, 8, 4) << 1;
19213 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19214 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19215 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19216 tmp = fieldFromInstruction(insn, 20, 5);
19217 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19218 tmp = fieldFromInstruction(insn, 25, 1);
19219 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19220 tmp = 0x0;
19221 tmp |= fieldFromInstruction(insn, 7, 1);
19222 tmp |= fieldFromInstruction(insn, 15, 1) << 1;
19223 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19224 tmp = fieldFromInstruction(insn, 29, 2);
19225 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19226 return S;
19227 case 241:
19228 tmp = fieldFromInstruction(insn, 7, 5);
19229 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19230 tmp = fieldFromInstruction(insn, 7, 5);
19231 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19232 tmp = fieldFromInstruction(insn, 15, 5);
19233 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19234 tmp = fieldFromInstruction(insn, 20, 5);
19235 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19236 tmp = fieldFromInstruction(insn, 25, 1);
19237 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19238 tmp = fieldFromInstruction(insn, 12, 3);
19239 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19240 tmp = fieldFromInstruction(insn, 29, 2);
19241 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19242 return S;
19243 case 242:
19244 tmp = fieldFromInstruction(insn, 7, 5);
19245 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19246 tmp = fieldFromInstruction(insn, 7, 5);
19247 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19248 tmp = fieldFromInstruction(insn, 15, 5);
19249 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19250 tmp = fieldFromInstruction(insn, 20, 5);
19251 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19252 return S;
19253 case 243:
19254 tmp = fieldFromInstruction(insn, 7, 5);
19255 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19256 tmp = fieldFromInstruction(insn, 26, 2);
19257 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19258 tmp = fieldFromInstruction(insn, 20, 5);
19259 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19260 tmp = fieldFromInstruction(insn, 15, 5);
19261 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19262 return S;
19263 case 244:
19264 tmp = fieldFromInstruction(insn, 26, 2);
19265 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19266 tmp = fieldFromInstruction(insn, 20, 5);
19267 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19268 tmp = fieldFromInstruction(insn, 7, 5);
19269 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19270 tmp = fieldFromInstruction(insn, 15, 5);
19271 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19272 return S;
19273 case 245:
19274 tmp = fieldFromInstruction(insn, 7, 5);
19275 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19276 tmp = fieldFromInstruction(insn, 26, 2);
19277 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19278 tmp = fieldFromInstruction(insn, 20, 5);
19279 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19280 tmp = fieldFromInstruction(insn, 15, 5);
19281 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19282 return S;
19283 case 246:
19284 tmp = fieldFromInstruction(insn, 26, 2);
19285 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19286 tmp = fieldFromInstruction(insn, 20, 5);
19287 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19288 tmp = fieldFromInstruction(insn, 7, 5);
19289 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19290 tmp = fieldFromInstruction(insn, 15, 5);
19291 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19292 return S;
19293 case 247:
19294 tmp = fieldFromInstruction(insn, 7, 5);
19295 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19296 tmp = fieldFromInstruction(insn, 26, 2);
19297 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19298 tmp = fieldFromInstruction(insn, 20, 5);
19299 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19300 tmp = fieldFromInstruction(insn, 15, 5);
19301 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19302 return S;
19303 case 248:
19304 tmp = fieldFromInstruction(insn, 26, 2);
19305 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19306 tmp = fieldFromInstruction(insn, 7, 5);
19307 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19308 tmp = fieldFromInstruction(insn, 20, 5);
19309 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19310 tmp = fieldFromInstruction(insn, 15, 5);
19311 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19312 return S;
19313 case 249:
19314 tmp = fieldFromInstruction(insn, 7, 5);
19315 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19316 tmp = fieldFromInstruction(insn, 26, 2);
19317 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19318 tmp = fieldFromInstruction(insn, 20, 5);
19319 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19320 tmp = fieldFromInstruction(insn, 15, 5);
19321 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19322 return S;
19323 case 250:
19324 tmp = fieldFromInstruction(insn, 26, 2);
19325 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19326 tmp = fieldFromInstruction(insn, 7, 5);
19327 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19328 tmp = fieldFromInstruction(insn, 20, 5);
19329 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19330 tmp = fieldFromInstruction(insn, 15, 5);
19331 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19332 return S;
19333 case 251:
19334 tmp = fieldFromInstruction(insn, 7, 5);
19335 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19336 tmp = fieldFromInstruction(insn, 26, 2);
19337 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19338 tmp = fieldFromInstruction(insn, 20, 5);
19339 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19340 tmp = fieldFromInstruction(insn, 15, 5);
19341 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19342 return S;
19343 case 252:
19344 tmp = fieldFromInstruction(insn, 26, 2);
19345 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19346 tmp = fieldFromInstruction(insn, 7, 5);
19347 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19348 tmp = fieldFromInstruction(insn, 20, 5);
19349 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19350 tmp = fieldFromInstruction(insn, 15, 5);
19351 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19352 return S;
19353 case 253:
19354 tmp = fieldFromInstruction(insn, 7, 5);
19355 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19356 tmp = fieldFromInstruction(insn, 26, 1);
19357 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19358 tmp = fieldFromInstruction(insn, 20, 5);
19359 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19360 tmp = fieldFromInstruction(insn, 15, 5);
19361 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19362 return S;
19363 case 254:
19364 tmp = fieldFromInstruction(insn, 26, 1);
19365 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19366 tmp = fieldFromInstruction(insn, 7, 5);
19367 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19368 tmp = fieldFromInstruction(insn, 20, 5);
19369 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19370 tmp = fieldFromInstruction(insn, 15, 5);
19371 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19372 return S;
19373 case 255:
19374 tmp = fieldFromInstruction(insn, 8, 4);
19375 if (!Check(S, DecodeSimpleRegisterClass<RISCV::T0, 16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19376 return S;
19377 case 256:
19378 tmp = fieldFromInstruction(insn, 15, 5);
19379 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19380 tmp = fieldFromInstruction(insn, 20, 5);
19381 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19382 return S;
19383 case 257:
19384 tmp = fieldFromInstruction(insn, 7, 5);
19385 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19386 tmp = fieldFromInstruction(insn, 26, 2);
19387 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19388 tmp = fieldFromInstruction(insn, 7, 5);
19389 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19390 tmp = fieldFromInstruction(insn, 20, 5);
19391 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19392 tmp = fieldFromInstruction(insn, 15, 5);
19393 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19394 return S;
19395 case 258:
19396 tmp = fieldFromInstruction(insn, 26, 2);
19397 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19398 tmp = fieldFromInstruction(insn, 7, 5);
19399 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19400 tmp = fieldFromInstruction(insn, 20, 5);
19401 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19402 tmp = fieldFromInstruction(insn, 15, 5);
19403 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19404 return S;
19405 case 259:
19406 tmp = fieldFromInstruction(insn, 7, 5);
19407 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19408 tmp = fieldFromInstruction(insn, 26, 2);
19409 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19410 tmp = fieldFromInstruction(insn, 7, 5);
19411 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19412 tmp = fieldFromInstruction(insn, 20, 5);
19413 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19414 tmp = fieldFromInstruction(insn, 15, 5);
19415 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19416 return S;
19417 case 260:
19418 tmp = fieldFromInstruction(insn, 26, 2);
19419 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19420 tmp = fieldFromInstruction(insn, 7, 5);
19421 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19422 tmp = fieldFromInstruction(insn, 20, 5);
19423 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19424 tmp = fieldFromInstruction(insn, 15, 5);
19425 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19426 return S;
19427 case 261:
19428 tmp = fieldFromInstruction(insn, 7, 5);
19429 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19430 tmp = fieldFromInstruction(insn, 26, 2);
19431 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19432 tmp = fieldFromInstruction(insn, 7, 5);
19433 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19434 tmp = fieldFromInstruction(insn, 20, 5);
19435 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19436 tmp = fieldFromInstruction(insn, 15, 5);
19437 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19438 return S;
19439 case 262:
19440 tmp = fieldFromInstruction(insn, 26, 2);
19441 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19442 tmp = fieldFromInstruction(insn, 7, 5);
19443 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19444 tmp = fieldFromInstruction(insn, 20, 5);
19445 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19446 tmp = fieldFromInstruction(insn, 15, 5);
19447 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19448 return S;
19449 case 263:
19450 tmp = fieldFromInstruction(insn, 7, 5);
19451 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19452 tmp = fieldFromInstruction(insn, 26, 1);
19453 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19454 tmp = fieldFromInstruction(insn, 7, 5);
19455 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19456 tmp = fieldFromInstruction(insn, 20, 5);
19457 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19458 tmp = fieldFromInstruction(insn, 15, 5);
19459 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19460 return S;
19461 case 264:
19462 tmp = fieldFromInstruction(insn, 26, 1);
19463 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19464 tmp = fieldFromInstruction(insn, 7, 5);
19465 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19466 tmp = fieldFromInstruction(insn, 20, 5);
19467 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19468 tmp = fieldFromInstruction(insn, 15, 5);
19469 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19470 return S;
19471 case 265:
19472 tmp = fieldFromInstruction(insn, 10, 2) << 2;
19473 if (!Check(S, DecodeTRM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19474 tmp = fieldFromInstruction(insn, 20, 5);
19475 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19476 tmp = fieldFromInstruction(insn, 15, 5);
19477 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19478 return S;
19479 case 266:
19480 tmp = fieldFromInstruction(insn, 9, 3) << 1;
19481 if (!Check(S, DecodeTRM2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19482 tmp = fieldFromInstruction(insn, 20, 5);
19483 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19484 tmp = fieldFromInstruction(insn, 15, 5);
19485 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19486 return S;
19487 case 267:
19488 tmp = fieldFromInstruction(insn, 7, 5);
19489 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19490 tmp = fieldFromInstruction(insn, 15, 5);
19491 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19492 tmp = fieldFromInstruction(insn, 20, 5);
19493 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19494 tmp = fieldFromInstruction(insn, 25, 2);
19495 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19496 return S;
19497 case 268:
19498 tmp = fieldFromInstruction(insn, 7, 5);
19499 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19500 tmp = fieldFromInstruction(insn, 15, 5);
19501 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19502 tmp = fieldFromInstruction(insn, 15, 5);
19503 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19504 tmp = fieldFromInstruction(insn, 20, 5);
19505 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19506 tmp = fieldFromInstruction(insn, 25, 2);
19507 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19508 return S;
19509 case 269:
19510 tmp = fieldFromInstruction(insn, 7, 5);
19511 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19512 tmp = fieldFromInstruction(insn, 20, 5);
19513 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19514 tmp = fieldFromInstruction(insn, 15, 5);
19515 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19516 tmp = fieldFromInstruction(insn, 25, 2);
19517 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19518 if (!Check(Out&: S, In: decodeImmThreeOperand(Inst&: MI, Decoder)))
19519 return MCDisassembler::Fail;
19520 return S;
19521 case 270:
19522 tmp = fieldFromInstruction(insn, 7, 5);
19523 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19524 tmp = fieldFromInstruction(insn, 20, 5);
19525 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19526 tmp = fieldFromInstruction(insn, 15, 5);
19527 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19528 tmp = fieldFromInstruction(insn, 25, 2);
19529 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19530 if (!Check(Out&: S, In: decodeImmFourOperand(Inst&: MI, Decoder)))
19531 return MCDisassembler::Fail;
19532 return S;
19533 case 271:
19534 tmp = fieldFromInstruction(insn, 15, 5);
19535 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19536 tmp = fieldFromInstruction(insn, 7, 5);
19537 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19538 tmp = fieldFromInstruction(insn, 15, 5);
19539 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19540 tmp = fieldFromInstruction(insn, 20, 5);
19541 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19542 tmp = fieldFromInstruction(insn, 25, 2);
19543 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19544 return S;
19545 case 272:
19546 tmp = fieldFromInstruction(insn, 7, 5);
19547 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19548 tmp = fieldFromInstruction(insn, 15, 5);
19549 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19550 tmp = fieldFromInstruction(insn, 20, 5);
19551 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19552 tmp = fieldFromInstruction(insn, 25, 2);
19553 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19554 return S;
19555 case 273:
19556 tmp = fieldFromInstruction(insn, 7, 5);
19557 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19558 tmp = fieldFromInstruction(insn, 15, 5);
19559 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19560 tmp = fieldFromInstruction(insn, 20, 5);
19561 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19562 tmp = fieldFromInstruction(insn, 25, 2);
19563 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19564 return S;
19565 case 274:
19566 tmp = fieldFromInstruction(insn, 7, 5);
19567 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19568 tmp = fieldFromInstruction(insn, 15, 5);
19569 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19570 tmp = fieldFromInstruction(insn, 20, 11);
19571 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19572 return S;
19573 case 275:
19574 tmp = fieldFromInstruction(insn, 7, 5);
19575 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19576 tmp = fieldFromInstruction(insn, 7, 5);
19577 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19578 tmp = fieldFromInstruction(insn, 15, 5);
19579 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19580 tmp = fieldFromInstruction(insn, 20, 11);
19581 if (!Check(S, decodeSImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19582 return S;
19583 case 276:
19584 tmp = fieldFromInstruction(insn, 7, 5);
19585 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19586 tmp = fieldFromInstruction(insn, 7, 5);
19587 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19588 tmp = fieldFromInstruction(insn, 15, 5);
19589 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19590 tmp = fieldFromInstruction(insn, 25, 5);
19591 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19592 tmp = fieldFromInstruction(insn, 20, 5);
19593 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19594 return S;
19595 case 277:
19596 tmp = fieldFromInstruction(insn, 7, 5);
19597 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19598 tmp = fieldFromInstruction(insn, 7, 5);
19599 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19600 tmp = fieldFromInstruction(insn, 15, 5);
19601 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19602 tmp = fieldFromInstruction(insn, 25, 5);
19603 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19604 tmp = fieldFromInstruction(insn, 20, 5);
19605 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19606 return S;
19607 case 278:
19608 tmp = fieldFromInstruction(insn, 7, 5);
19609 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19610 tmp = fieldFromInstruction(insn, 15, 5);
19611 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19612 tmp = fieldFromInstruction(insn, 25, 5);
19613 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19614 tmp = fieldFromInstruction(insn, 20, 5);
19615 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19616 return S;
19617 case 279:
19618 tmp = fieldFromInstruction(insn, 7, 5);
19619 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19620 tmp = fieldFromInstruction(insn, 15, 5);
19621 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19622 tmp = fieldFromInstruction(insn, 25, 5);
19623 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19624 tmp = fieldFromInstruction(insn, 20, 5);
19625 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19626 return S;
19627 case 280:
19628 tmp = fieldFromInstruction(insn, 7, 5);
19629 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19630 tmp = fieldFromInstruction(insn, 15, 5);
19631 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19632 return S;
19633 case 281:
19634 tmp = fieldFromInstruction(insn, 7, 5);
19635 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19636 tmp = fieldFromInstruction(insn, 7, 5);
19637 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19638 tmp = fieldFromInstruction(insn, 15, 5);
19639 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19640 tmp = fieldFromInstruction(insn, 20, 5);
19641 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19642 return S;
19643 case 282:
19644 tmp = fieldFromInstruction(insn, 7, 5);
19645 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19646 tmp = fieldFromInstruction(insn, 15, 5);
19647 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19648 tmp = fieldFromInstruction(insn, 20, 5);
19649 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19650 return S;
19651 case 283:
19652 tmp = fieldFromInstruction(insn, 7, 5);
19653 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19654 tmp = fieldFromInstruction(insn, 15, 5);
19655 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19656 tmp = fieldFromInstruction(insn, 20, 5);
19657 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19658 return S;
19659 case 284:
19660 tmp = fieldFromInstruction(insn, 7, 5);
19661 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19662 tmp = fieldFromInstruction(insn, 15, 5);
19663 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19664 tmp = fieldFromInstruction(insn, 20, 5);
19665 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19666 return S;
19667 case 285:
19668 tmp = fieldFromInstruction(insn, 7, 5);
19669 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19670 tmp = fieldFromInstruction(insn, 15, 5);
19671 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19672 tmp = fieldFromInstruction(insn, 20, 5);
19673 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19674 tmp = fieldFromInstruction(insn, 25, 5);
19675 if (!Check(S, decodeUImmOperandGE<5, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19676 return S;
19677 case 286:
19678 tmp = fieldFromInstruction(insn, 7, 5);
19679 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19680 tmp = fieldFromInstruction(insn, 15, 5);
19681 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19682 tmp = fieldFromInstruction(insn, 20, 12) << 2;
19683 if (!Check(S, decodeUImmOperand<14>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19684 return S;
19685 case 287:
19686 tmp = fieldFromInstruction(insn, 7, 5);
19687 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19688 tmp = fieldFromInstruction(insn, 15, 5);
19689 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19690 tmp = fieldFromInstruction(insn, 20, 12) << 2;
19691 if (!Check(S, decodeUImmOperand<14>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19692 return S;
19693 case 288:
19694 tmp = fieldFromInstruction(insn, 7, 5);
19695 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19696 tmp = fieldFromInstruction(insn, 7, 5);
19697 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19698 tmp = fieldFromInstruction(insn, 15, 5);
19699 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19700 tmp = fieldFromInstruction(insn, 20, 12);
19701 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19702 return S;
19703 case 289:
19704 tmp = fieldFromInstruction(insn, 7, 5);
19705 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19706 tmp = fieldFromInstruction(insn, 15, 5);
19707 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19708 tmp = fieldFromInstruction(insn, 20, 5);
19709 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19710 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19711 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19712 return S;
19713 case 290:
19714 tmp = fieldFromInstruction(insn, 7, 5);
19715 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19716 tmp = fieldFromInstruction(insn, 15, 5);
19717 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19718 tmp = fieldFromInstruction(insn, 20, 5);
19719 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19720 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19721 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19722 return S;
19723 case 291:
19724 tmp = fieldFromInstruction(insn, 7, 5);
19725 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19726 tmp = fieldFromInstruction(insn, 15, 5);
19727 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19728 tmp = fieldFromInstruction(insn, 20, 5);
19729 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19730 tmp = fieldFromInstruction(insn, 25, 3);
19731 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19732 return S;
19733 case 292:
19734 tmp = fieldFromInstruction(insn, 20, 5);
19735 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19736 return S;
19737 case 293:
19738 tmp = fieldFromInstruction(insn, 20, 8);
19739 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19740 return S;
19741 case 294:
19742 tmp = fieldFromInstruction(insn, 7, 5);
19743 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19744 tmp = 0x0;
19745 tmp |= fieldFromInstruction(insn, 12, 4) << 15;
19746 tmp |= fieldFromInstruction(insn, 16, 15);
19747 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
19748 if (!Check(S, decodeSImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19749 return S;
19750 case 295:
19751 tmp = fieldFromInstruction(insn, 7, 5);
19752 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19753 tmp = fieldFromInstruction(insn, 15, 5);
19754 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19755 tmp = fieldFromInstruction(insn, 20, 5);
19756 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19757 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19758 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19759 return S;
19760 case 296:
19761 tmp = fieldFromInstruction(insn, 7, 5);
19762 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19763 tmp = fieldFromInstruction(insn, 15, 5);
19764 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19765 tmp = fieldFromInstruction(insn, 20, 5);
19766 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19767 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19768 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19769 return S;
19770 case 297:
19771 tmp = fieldFromInstruction(insn, 7, 5);
19772 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19773 tmp = fieldFromInstruction(insn, 7, 5);
19774 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19775 tmp = fieldFromInstruction(insn, 15, 5);
19776 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19777 tmp = fieldFromInstruction(insn, 20, 5);
19778 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19779 tmp = fieldFromInstruction(insn, 27, 5);
19780 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19781 return S;
19782 case 298:
19783 tmp = fieldFromInstruction(insn, 7, 5);
19784 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19785 tmp = fieldFromInstruction(insn, 7, 5);
19786 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19787 tmp = fieldFromInstruction(insn, 15, 5);
19788 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19789 tmp = fieldFromInstruction(insn, 20, 5);
19790 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19791 tmp = fieldFromInstruction(insn, 27, 5);
19792 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19793 return S;
19794 case 299:
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, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19801 tmp = fieldFromInstruction(insn, 20, 5);
19802 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19803 tmp = fieldFromInstruction(insn, 27, 5);
19804 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19805 return S;
19806 case 300:
19807 tmp = fieldFromInstruction(insn, 7, 5);
19808 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19809 tmp = fieldFromInstruction(insn, 7, 5);
19810 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19811 tmp = fieldFromInstruction(insn, 15, 5);
19812 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19813 tmp = fieldFromInstruction(insn, 20, 5);
19814 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19815 tmp = fieldFromInstruction(insn, 27, 5);
19816 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19817 return S;
19818 case 301:
19819 tmp = fieldFromInstruction(insn, 7, 5);
19820 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
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, decodeSImmOperand<5>(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 tmp = fieldFromInstruction(insn, 27, 5);
19828 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19829 return S;
19830 case 302:
19831 tmp = fieldFromInstruction(insn, 7, 5);
19832 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19833 tmp = fieldFromInstruction(insn, 7, 5);
19834 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19835 tmp = fieldFromInstruction(insn, 15, 5);
19836 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19837 tmp = fieldFromInstruction(insn, 20, 5);
19838 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19839 tmp = fieldFromInstruction(insn, 27, 5);
19840 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19841 return S;
19842 case 303:
19843 tmp = fieldFromInstruction(insn, 7, 5);
19844 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19845 tmp = fieldFromInstruction(insn, 7, 5);
19846 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19847 tmp = fieldFromInstruction(insn, 15, 5);
19848 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19849 tmp = fieldFromInstruction(insn, 20, 5);
19850 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19851 tmp = fieldFromInstruction(insn, 27, 5);
19852 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19853 return S;
19854 case 304:
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, 5);
19862 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19863 tmp = fieldFromInstruction(insn, 27, 5);
19864 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19865 return S;
19866 case 305:
19867 tmp = fieldFromInstruction(insn, 7, 5);
19868 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19869 tmp = fieldFromInstruction(insn, 15, 5);
19870 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19871 tmp = fieldFromInstruction(insn, 20, 5);
19872 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19873 return S;
19874 case 306:
19875 tmp = fieldFromInstruction(insn, 7, 5);
19876 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19877 tmp = fieldFromInstruction(insn, 15, 5);
19878 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19879 tmp = fieldFromInstruction(insn, 20, 5);
19880 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19881 return S;
19882 case 307:
19883 tmp = fieldFromInstruction(insn, 15, 10);
19884 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19885 return S;
19886 case 308:
19887 tmp = fieldFromInstruction(insn, 15, 5);
19888 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19889 tmp = fieldFromInstruction(insn, 20, 5);
19890 if (!Check(S, decodeSImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19891 tmp = 0x0;
19892 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19893 tmp |= fieldFromInstruction(insn, 8, 4);
19894 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19895 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19896 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19897 return S;
19898 case 309:
19899 tmp = fieldFromInstruction(insn, 15, 5);
19900 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19901 tmp = fieldFromInstruction(insn, 20, 5);
19902 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19903 tmp = 0x0;
19904 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19905 tmp |= fieldFromInstruction(insn, 8, 4);
19906 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19907 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19908 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19909 return S;
19910 case 310:
19911 tmp = fieldFromInstruction(insn, 7, 5);
19912 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19913 tmp = fieldFromInstruction(insn, 15, 5);
19914 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19915 tmp = fieldFromInstruction(insn, 12, 3);
19916 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19917 return S;
19918 case 311:
19919 tmp = fieldFromInstruction(insn, 7, 5);
19920 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19921 tmp = fieldFromInstruction(insn, 15, 5);
19922 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19923 tmp = fieldFromInstruction(insn, 12, 3);
19924 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19925 return S;
19926 case 312:
19927 tmp = fieldFromInstruction(insn, 7, 5);
19928 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19929 tmp = fieldFromInstruction(insn, 15, 5);
19930 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19931 tmp = fieldFromInstruction(insn, 20, 5);
19932 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19933 tmp = fieldFromInstruction(insn, 27, 5);
19934 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19935 tmp = fieldFromInstruction(insn, 12, 3);
19936 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19937 return S;
19938 case 313:
19939 tmp = fieldFromInstruction(insn, 7, 5);
19940 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19941 tmp = fieldFromInstruction(insn, 15, 5);
19942 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19943 tmp = fieldFromInstruction(insn, 20, 5);
19944 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19945 tmp = fieldFromInstruction(insn, 12, 3);
19946 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19947 return S;
19948 case 314:
19949 tmp = fieldFromInstruction(insn, 7, 5);
19950 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19951 tmp = fieldFromInstruction(insn, 15, 5);
19952 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19953 tmp = fieldFromInstruction(insn, 20, 5);
19954 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19955 return S;
19956 case 315:
19957 tmp = fieldFromInstruction(insn, 7, 5);
19958 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19959 tmp = fieldFromInstruction(insn, 15, 5);
19960 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19961 tmp = fieldFromInstruction(insn, 12, 3);
19962 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19963 return S;
19964 case 316:
19965 tmp = fieldFromInstruction(insn, 7, 5);
19966 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19967 tmp = fieldFromInstruction(insn, 15, 5);
19968 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19969 tmp = fieldFromInstruction(insn, 12, 3);
19970 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19971 return S;
19972 case 317:
19973 tmp = fieldFromInstruction(insn, 7, 5);
19974 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19975 tmp = fieldFromInstruction(insn, 15, 5);
19976 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19977 tmp = fieldFromInstruction(insn, 12, 3);
19978 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19979 return S;
19980 case 318:
19981 tmp = fieldFromInstruction(insn, 7, 5);
19982 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19983 tmp = fieldFromInstruction(insn, 15, 5);
19984 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19985 tmp = fieldFromInstruction(insn, 20, 5);
19986 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19987 return S;
19988 case 319:
19989 tmp = fieldFromInstruction(insn, 7, 5);
19990 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19991 tmp = fieldFromInstruction(insn, 15, 5);
19992 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19993 tmp = fieldFromInstruction(insn, 12, 3);
19994 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19995 return S;
19996 case 320:
19997 tmp = fieldFromInstruction(insn, 7, 5);
19998 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19999 tmp = fieldFromInstruction(insn, 15, 5);
20000 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20001 tmp = fieldFromInstruction(insn, 12, 3);
20002 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20003 return S;
20004 case 321:
20005 tmp = fieldFromInstruction(insn, 7, 5);
20006 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20007 tmp = fieldFromInstruction(insn, 15, 5);
20008 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20009 return S;
20010 case 322:
20011 tmp = fieldFromInstruction(insn, 7, 5);
20012 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20013 tmp = fieldFromInstruction(insn, 15, 5);
20014 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20015 tmp = fieldFromInstruction(insn, 20, 5);
20016 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20017 tmp = fieldFromInstruction(insn, 27, 5);
20018 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20019 tmp = fieldFromInstruction(insn, 12, 3);
20020 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20021 return S;
20022 case 323:
20023 tmp = fieldFromInstruction(insn, 7, 5);
20024 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20025 tmp = fieldFromInstruction(insn, 15, 5);
20026 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20027 tmp = fieldFromInstruction(insn, 20, 5);
20028 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20029 tmp = fieldFromInstruction(insn, 27, 5);
20030 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20031 tmp = fieldFromInstruction(insn, 12, 3);
20032 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20033 return S;
20034 case 324:
20035 tmp = fieldFromInstruction(insn, 7, 5);
20036 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20037 tmp = fieldFromInstruction(insn, 15, 5);
20038 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20039 tmp = fieldFromInstruction(insn, 20, 5);
20040 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20041 tmp = fieldFromInstruction(insn, 27, 5);
20042 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20043 tmp = fieldFromInstruction(insn, 12, 3);
20044 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20045 return S;
20046 case 325:
20047 tmp = fieldFromInstruction(insn, 7, 5);
20048 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20049 tmp = fieldFromInstruction(insn, 15, 5);
20050 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20051 tmp = fieldFromInstruction(insn, 20, 5);
20052 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20053 tmp = fieldFromInstruction(insn, 12, 3);
20054 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20055 return S;
20056 case 326:
20057 tmp = fieldFromInstruction(insn, 7, 5);
20058 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20059 tmp = fieldFromInstruction(insn, 15, 5);
20060 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20061 tmp = fieldFromInstruction(insn, 20, 5);
20062 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20063 tmp = fieldFromInstruction(insn, 12, 3);
20064 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20065 return S;
20066 case 327:
20067 tmp = fieldFromInstruction(insn, 7, 5);
20068 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20069 tmp = fieldFromInstruction(insn, 15, 5);
20070 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20071 tmp = fieldFromInstruction(insn, 20, 5);
20072 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20073 tmp = fieldFromInstruction(insn, 12, 3);
20074 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20075 return S;
20076 case 328:
20077 tmp = fieldFromInstruction(insn, 7, 5);
20078 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20079 tmp = fieldFromInstruction(insn, 15, 5);
20080 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20081 tmp = fieldFromInstruction(insn, 20, 5);
20082 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20083 return S;
20084 case 329:
20085 tmp = fieldFromInstruction(insn, 7, 5);
20086 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20087 tmp = fieldFromInstruction(insn, 15, 5);
20088 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20089 tmp = fieldFromInstruction(insn, 20, 5);
20090 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20091 return S;
20092 case 330:
20093 tmp = fieldFromInstruction(insn, 7, 5);
20094 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20095 tmp = fieldFromInstruction(insn, 15, 5);
20096 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20097 tmp = fieldFromInstruction(insn, 12, 3);
20098 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20099 return S;
20100 case 331:
20101 tmp = fieldFromInstruction(insn, 7, 5);
20102 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20103 tmp = fieldFromInstruction(insn, 15, 5);
20104 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20105 tmp = fieldFromInstruction(insn, 12, 3);
20106 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20107 return S;
20108 case 332:
20109 tmp = fieldFromInstruction(insn, 7, 5);
20110 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20111 tmp = fieldFromInstruction(insn, 15, 5);
20112 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20113 tmp = fieldFromInstruction(insn, 12, 3);
20114 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20115 return S;
20116 case 333:
20117 tmp = fieldFromInstruction(insn, 7, 5);
20118 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20119 tmp = fieldFromInstruction(insn, 15, 5);
20120 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20121 tmp = fieldFromInstruction(insn, 12, 3);
20122 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20123 return S;
20124 case 334:
20125 tmp = fieldFromInstruction(insn, 7, 5);
20126 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20127 tmp = fieldFromInstruction(insn, 15, 5);
20128 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20129 tmp = fieldFromInstruction(insn, 12, 3);
20130 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20131 return S;
20132 case 335:
20133 tmp = fieldFromInstruction(insn, 7, 5);
20134 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20135 tmp = fieldFromInstruction(insn, 15, 5);
20136 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20137 tmp = fieldFromInstruction(insn, 12, 3);
20138 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20139 return S;
20140 case 336:
20141 tmp = fieldFromInstruction(insn, 7, 5);
20142 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20143 tmp = fieldFromInstruction(insn, 15, 5);
20144 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20145 tmp = fieldFromInstruction(insn, 12, 3);
20146 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20147 return S;
20148 case 337:
20149 tmp = fieldFromInstruction(insn, 7, 5);
20150 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20151 tmp = fieldFromInstruction(insn, 15, 5);
20152 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20153 tmp = fieldFromInstruction(insn, 12, 3);
20154 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20155 return S;
20156 case 338:
20157 tmp = fieldFromInstruction(insn, 7, 5);
20158 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20159 tmp = fieldFromInstruction(insn, 15, 5);
20160 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20161 tmp = fieldFromInstruction(insn, 12, 3);
20162 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20163 return S;
20164 case 339:
20165 tmp = fieldFromInstruction(insn, 7, 5);
20166 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20167 tmp = fieldFromInstruction(insn, 15, 5);
20168 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20169 tmp = fieldFromInstruction(insn, 20, 5);
20170 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20171 return S;
20172 case 340:
20173 tmp = fieldFromInstruction(insn, 7, 5);
20174 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20175 tmp = fieldFromInstruction(insn, 15, 5);
20176 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20177 tmp = fieldFromInstruction(insn, 20, 5);
20178 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20179 return S;
20180 case 341:
20181 tmp = fieldFromInstruction(insn, 7, 5);
20182 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20183 tmp = fieldFromInstruction(insn, 15, 5);
20184 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20185 return S;
20186 case 342:
20187 tmp = fieldFromInstruction(insn, 7, 5);
20188 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20189 tmp = fieldFromInstruction(insn, 15, 5);
20190 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20191 return S;
20192 }
20193}
20194static const uint8_t DecoderTableXqci48[368] = {
20195 48, // 0: BitWidth 48
20196 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
20197 0, 15, // 4: case 0x0: {
20198 OPC_CheckPredicate, 190, 1, // 6: check predicate 190
20199 OPC_CheckField, 15, 1, 0, // 9: check Inst[15] == 0x0
20200 OPC_CheckField, 0, 7, 31, // 13: check Inst[6:0] == 0x1f
20201 OPC_Decode, 168, 122, 0, // 17: decode to QC_E_LI using decoder 0
20202 // 17: }
20203 1, 29, // 21: case 0x1: {
20204 OPC_SwitchField, 15, 1, // 23: switch Inst[15] {
20205 0, 11, // 26: case 0x0: {
20206 OPC_CheckPredicate, 205, 1, // 28: check predicate 205
20207 OPC_CheckField, 0, 7, 31, // 31: check Inst[6:0] == 0x1f
20208 OPC_Decode, 175, 122, 1, // 35: decode to QC_E_XORAI using decoder 1
20209 // 35: }
20210 1, 0, // 39: case 0x1: {
20211 OPC_CheckPredicate, 205, 1, // 41: check predicate 205
20212 OPC_CheckField, 0, 7, 31, // 44: check Inst[6:0] == 0x1f
20213 OPC_Decode, 170, 122, 1, // 48: decode to QC_E_ORAI using decoder 1
20214 // 48: }
20215 // 48: } // switch Inst[15]
20216 // 48: }
20217 2, 29, // 52: case 0x2: {
20218 OPC_SwitchField, 15, 1, // 54: switch Inst[15] {
20219 0, 11, // 57: case 0x0: {
20220 OPC_CheckPredicate, 205, 1, // 59: check predicate 205
20221 OPC_CheckField, 0, 7, 31, // 62: check Inst[6:0] == 0x1f
20222 OPC_Decode, 152, 122, 1, // 66: decode to QC_E_ADDAI using decoder 1
20223 // 66: }
20224 1, 0, // 70: case 0x1: {
20225 OPC_CheckPredicate, 205, 1, // 72: check predicate 205
20226 OPC_CheckField, 0, 7, 31, // 75: check Inst[6:0] == 0x1f
20227 OPC_Decode, 154, 122, 1, // 79: decode to QC_E_ANDAI using decoder 1
20228 // 79: }
20229 // 79: } // switch Inst[15]
20230 // 79: }
20231 3, 55, // 83: case 0x3: {
20232 OPC_SwitchField, 30, 2, // 85: switch Inst[31:30] {
20233 0, 11, // 88: case 0x0: {
20234 OPC_CheckPredicate, 205, 1, // 90: check predicate 205
20235 OPC_CheckField, 0, 7, 31, // 93: check Inst[6:0] == 0x1f
20236 OPC_Decode, 176, 122, 2, // 97: decode to QC_E_XORI using decoder 2
20237 // 97: }
20238 1, 11, // 101: case 0x1: {
20239 OPC_CheckPredicate, 205, 1, // 103: check predicate 205
20240 OPC_CheckField, 0, 7, 31, // 106: check Inst[6:0] == 0x1f
20241 OPC_Decode, 171, 122, 2, // 110: decode to QC_E_ORI using decoder 2
20242 // 110: }
20243 2, 11, // 114: case 0x2: {
20244 OPC_CheckPredicate, 205, 1, // 116: check predicate 205
20245 OPC_CheckField, 0, 7, 31, // 119: check Inst[6:0] == 0x1f
20246 OPC_Decode, 153, 122, 2, // 123: decode to QC_E_ADDI using decoder 2
20247 // 123: }
20248 3, 0, // 127: case 0x3: {
20249 OPC_CheckPredicate, 205, 1, // 129: check predicate 205
20250 OPC_CheckField, 0, 7, 31, // 132: check Inst[6:0] == 0x1f
20251 OPC_Decode, 155, 122, 2, // 136: decode to QC_E_ANDI using decoder 2
20252 // 136: }
20253 // 136: } // switch Inst[31:30]
20254 // 136: }
20255 4, 112, // 140: case 0x4: {
20256 OPC_SwitchField, 20, 5, // 142: switch Inst[24:20] {
20257 0, 29, // 145: case 0x0: {
20258 OPC_SwitchField, 15, 2, // 147: switch Inst[16:15] {
20259 0, 11, // 150: case 0x0: {
20260 OPC_CheckPredicate, 206, 1, // 152: check predicate 206
20261 OPC_CheckField, 0, 7, 31, // 155: check Inst[6:0] == 0x1f
20262 OPC_Decode, 162, 122, 3, // 159: decode to QC_E_J using decoder 3
20263 // 159: }
20264 1, 0, // 163: case 0x1: {
20265 OPC_CheckPredicate, 206, 1, // 165: check predicate 206
20266 OPC_CheckField, 0, 7, 31, // 168: check Inst[6:0] == 0x1f
20267 OPC_Decode, 163, 122, 3, // 172: decode to QC_E_JAL using decoder 3
20268 // 172: }
20269 // 172: } // switch Inst[16:15]
20270 // 172: }
20271 24, 11, // 176: case 0x18: {
20272 OPC_CheckPredicate, 194, 1, // 178: check predicate 194
20273 OPC_CheckField, 0, 7, 31, // 181: check Inst[6:0] == 0x1f
20274 OPC_Decode, 156, 122, 4, // 185: decode to QC_E_BEQI using decoder 4
20275 // 185: }
20276 25, 11, // 189: case 0x19: {
20277 OPC_CheckPredicate, 194, 1, // 191: check predicate 194
20278 OPC_CheckField, 0, 7, 31, // 194: check Inst[6:0] == 0x1f
20279 OPC_Decode, 161, 122, 4, // 198: decode to QC_E_BNEI using decoder 4
20280 // 198: }
20281 28, 11, // 202: case 0x1c: {
20282 OPC_CheckPredicate, 194, 1, // 204: check predicate 194
20283 OPC_CheckField, 0, 7, 31, // 207: check Inst[6:0] == 0x1f
20284 OPC_Decode, 159, 122, 4, // 211: decode to QC_E_BLTI using decoder 4
20285 // 211: }
20286 29, 11, // 215: case 0x1d: {
20287 OPC_CheckPredicate, 194, 1, // 217: check predicate 194
20288 OPC_CheckField, 0, 7, 31, // 220: check Inst[6:0] == 0x1f
20289 OPC_Decode, 157, 122, 4, // 224: decode to QC_E_BGEI using decoder 4
20290 // 224: }
20291 30, 11, // 228: case 0x1e: {
20292 OPC_CheckPredicate, 194, 1, // 230: check predicate 194
20293 OPC_CheckField, 0, 7, 31, // 233: check Inst[6:0] == 0x1f
20294 OPC_Decode, 160, 122, 5, // 237: decode to QC_E_BLTUI using decoder 5
20295 // 237: }
20296 31, 0, // 241: case 0x1f: {
20297 OPC_CheckPredicate, 194, 1, // 243: check predicate 194
20298 OPC_CheckField, 0, 7, 31, // 246: check Inst[6:0] == 0x1f
20299 OPC_Decode, 158, 122, 5, // 250: decode to QC_E_BGEUI using decoder 5
20300 // 250: }
20301 // 250: } // switch Inst[24:20]
20302 // 250: }
20303 5, 55, // 254: case 0x5: {
20304 OPC_SwitchField, 30, 2, // 256: switch Inst[31:30] {
20305 0, 11, // 259: case 0x0: {
20306 OPC_CheckPredicate, 207, 1, // 261: check predicate 207
20307 OPC_CheckField, 0, 7, 31, // 264: check Inst[6:0] == 0x1f
20308 OPC_Decode, 164, 122, 6, // 268: decode to QC_E_LB using decoder 6
20309 // 268: }
20310 1, 11, // 272: case 0x1: {
20311 OPC_CheckPredicate, 207, 1, // 274: check predicate 207
20312 OPC_CheckField, 0, 7, 31, // 277: check Inst[6:0] == 0x1f
20313 OPC_Decode, 165, 122, 6, // 281: decode to QC_E_LBU using decoder 6
20314 // 281: }
20315 2, 11, // 285: case 0x2: {
20316 OPC_CheckPredicate, 207, 1, // 287: check predicate 207
20317 OPC_CheckField, 0, 7, 31, // 290: check Inst[6:0] == 0x1f
20318 OPC_Decode, 166, 122, 6, // 294: decode to QC_E_LH using decoder 6
20319 // 294: }
20320 3, 0, // 298: case 0x3: {
20321 OPC_CheckPredicate, 207, 1, // 300: check predicate 207
20322 OPC_CheckField, 0, 7, 31, // 303: check Inst[6:0] == 0x1f
20323 OPC_Decode, 167, 122, 6, // 307: decode to QC_E_LHU using decoder 6
20324 // 307: }
20325 // 307: } // switch Inst[31:30]
20326 // 307: }
20327 6, 0, // 311: case 0x6: {
20328 OPC_SwitchField, 30, 2, // 313: switch Inst[31:30] {
20329 0, 11, // 316: case 0x0: {
20330 OPC_CheckPredicate, 207, 1, // 318: check predicate 207
20331 OPC_CheckField, 0, 7, 31, // 321: check Inst[6:0] == 0x1f
20332 OPC_Decode, 169, 122, 6, // 325: decode to QC_E_LW using decoder 6
20333 // 325: }
20334 1, 11, // 329: case 0x1: {
20335 OPC_CheckPredicate, 207, 1, // 331: check predicate 207
20336 OPC_CheckField, 0, 7, 31, // 334: check Inst[6:0] == 0x1f
20337 OPC_Decode, 172, 122, 7, // 338: decode to QC_E_SB using decoder 7
20338 // 338: }
20339 2, 11, // 342: case 0x2: {
20340 OPC_CheckPredicate, 207, 1, // 344: check predicate 207
20341 OPC_CheckField, 0, 7, 31, // 347: check Inst[6:0] == 0x1f
20342 OPC_Decode, 173, 122, 7, // 351: decode to QC_E_SH using decoder 7
20343 // 351: }
20344 3, 0, // 355: case 0x3: {
20345 OPC_CheckPredicate, 207, 1, // 357: check predicate 207
20346 OPC_CheckField, 0, 7, 31, // 360: check Inst[6:0] == 0x1f
20347 OPC_Decode, 174, 122, 7, // 364: decode to QC_E_SW using decoder 7
20348 // 364: }
20349 // 364: } // switch Inst[31:30]
20350 // 364: }
20351 // 364: } // switch Inst[14:12]
20352};
20353// Handling 8 cases.
20354template <typename InsnType>
20355static std::enable_if_t<InsnBitWidth<InsnType> == 48, DecodeStatus>
20356decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
20357 DecodeComplete = true;
20358 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
20359 TmpType tmp;
20360 switch (Idx) {
20361 default: llvm_unreachable("Invalid decoder index!");
20362 case 0:
20363 tmp = fieldFromInstruction(insn, 7, 5);
20364 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20365 tmp = fieldFromInstruction(insn, 16, 32);
20366 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20367 return S;
20368 case 1:
20369 tmp = fieldFromInstruction(insn, 7, 5);
20370 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20371 tmp = fieldFromInstruction(insn, 7, 5);
20372 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20373 tmp = fieldFromInstruction(insn, 16, 32);
20374 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20375 return S;
20376 case 2:
20377 tmp = fieldFromInstruction(insn, 7, 5);
20378 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20379 tmp = fieldFromInstruction(insn, 15, 5);
20380 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20381 tmp = 0x0;
20382 tmp |= fieldFromInstruction(insn, 20, 10);
20383 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20384 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20385 return S;
20386 case 3:
20387 tmp = 0x0;
20388 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20389 tmp |= fieldFromInstruction(insn, 8, 4);
20390 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
20391 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20392 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20393 tmp |= fieldFromInstruction(insn, 32, 16) << 15;
20394 if (!Check(S, decodeSImmOperandAndLslN<32, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20395 return S;
20396 case 4:
20397 tmp = fieldFromInstruction(insn, 15, 5);
20398 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20399 tmp = fieldFromInstruction(insn, 32, 16);
20400 if (!Check(S, decodeSImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20401 tmp = 0x0;
20402 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20403 tmp |= fieldFromInstruction(insn, 8, 4);
20404 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20405 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20406 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20407 return S;
20408 case 5:
20409 tmp = fieldFromInstruction(insn, 15, 5);
20410 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20411 tmp = fieldFromInstruction(insn, 32, 16);
20412 if (!Check(S, decodeUImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20413 tmp = 0x0;
20414 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20415 tmp |= fieldFromInstruction(insn, 8, 4);
20416 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20417 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20418 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20419 return S;
20420 case 6:
20421 tmp = fieldFromInstruction(insn, 7, 5);
20422 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20423 tmp = fieldFromInstruction(insn, 15, 5);
20424 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20425 tmp = 0x0;
20426 tmp |= fieldFromInstruction(insn, 20, 10);
20427 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20428 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20429 return S;
20430 case 7:
20431 tmp = fieldFromInstruction(insn, 20, 5);
20432 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20433 tmp = fieldFromInstruction(insn, 15, 5);
20434 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20435 tmp = 0x0;
20436 tmp |= fieldFromInstruction(insn, 7, 5);
20437 tmp |= fieldFromInstruction(insn, 25, 5) << 5;
20438 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20439 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20440 return S;
20441 }
20442}
20443static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) {
20444 switch (Idx) {
20445 default: llvm_unreachable("Invalid index!");
20446 case 0:
20447 return FB[RISCV::FeatureStdExtZca];
20448 case 1:
20449 return FB[RISCV::FeatureStdExtZcd];
20450 case 2:
20451 return FB[RISCV::FeatureStdExtZca] && FB[RISCV::Feature64Bit];
20452 case 3:
20453 return FB[RISCV::FeatureStdExtZcmop];
20454 case 4:
20455 return FB[RISCV::FeatureStdExtZcb];
20456 case 5:
20457 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZmmul];
20458 case 6:
20459 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZbb];
20460 case 7:
20461 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
20462 case 8:
20463 return FB[RISCV::FeatureStdExtZcf] && !(FB[RISCV::Feature64Bit]);
20464 case 9:
20465 return FB[RISCV::FeatureStdExtZca] && !(FB[RISCV::Feature64Bit]);
20466 case 10:
20467 return FB[RISCV::FeatureVendorXqccmp];
20468 case 11:
20469 return FB[RISCV::FeatureVendorXqccmt];
20470 case 12:
20471 return FB[RISCV::FeatureVendorXqciint] && !(FB[RISCV::Feature64Bit]);
20472 case 13:
20473 return FB[RISCV::FeatureVendorXqcibm] && !(FB[RISCV::Feature64Bit]);
20474 case 14:
20475 return FB[RISCV::FeatureVendorXqciac] && !(FB[RISCV::Feature64Bit]);
20476 case 15:
20477 return FB[RISCV::FeatureVendorXqcisync] && !(FB[RISCV::Feature64Bit]);
20478 case 16:
20479 return FB[RISCV::FeatureVendorXqcicm] && !(FB[RISCV::Feature64Bit]);
20480 case 17:
20481 return FB[RISCV::FeatureVendorXwchc];
20482 case 18:
20483 return FB[RISCV::FeatureStdExtZclsd] && !(FB[RISCV::Feature64Bit]);
20484 case 19:
20485 return FB[RISCV::FeatureStdExtZcmt];
20486 case 20:
20487 return FB[RISCV::FeatureStdExtZcmp];
20488 case 21:
20489 return FB[RISCV::Feature64Bit];
20490 case 22:
20491 return FB[RISCV::FeatureStdExtZve32x];
20492 case 23:
20493 return FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZfhmin] || FB[RISCV::FeatureStdExtZfbfmin];
20494 case 24:
20495 return FB[RISCV::FeatureStdExtF];
20496 case 25:
20497 return FB[RISCV::FeatureStdExtD];
20498 case 26:
20499 return FB[RISCV::FeatureStdExtQ];
20500 case 27:
20501 return FB[RISCV::FeatureStdExtZve64x];
20502 case 28:
20503 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtZve64x];
20504 case 29:
20505 return FB[RISCV::FeatureStdExtZve64x] && FB[RISCV::Feature64Bit];
20506 case 30:
20507 return FB[RISCV::FeatureStdExtZvvmtls];
20508 case 31:
20509 return FB[RISCV::FeatureStdExtZvvmttls];
20510 case 32:
20511 return FB[RISCV::FeatureStdExtZicbom];
20512 case 33:
20513 return FB[RISCV::FeatureStdExtZicboz];
20514 case 34:
20515 return FB[RISCV::FeatureStdExtZbkb] && !(FB[RISCV::Feature64Bit]);
20516 case 35:
20517 return FB[RISCV::FeatureStdExtZknh];
20518 case 36:
20519 return FB[RISCV::FeatureStdExtZknh] && FB[RISCV::Feature64Bit];
20520 case 37:
20521 return FB[RISCV::FeatureStdExtZksh];
20522 case 38:
20523 return FB[RISCV::FeatureStdExtZbs];
20524 case 39:
20525 return FB[RISCV::FeatureStdExtZknd] && FB[RISCV::Feature64Bit];
20526 case 40:
20527 return (FB[RISCV::FeatureStdExtZknd] || FB[RISCV::FeatureStdExtZkne]) && FB[RISCV::Feature64Bit];
20528 case 41:
20529 return FB[RISCV::FeatureStdExtZbb];
20530 case 42:
20531 return FB[RISCV::FeatureStdExtP];
20532 case 43:
20533 return FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb];
20534 case 44:
20535 return FB[RISCV::FeatureStdExtZbkb];
20536 case 45:
20537 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && !(FB[RISCV::Feature64Bit]);
20538 case 46:
20539 return FB[RISCV::FeatureStdExtP] && !(FB[RISCV::Feature64Bit]);
20540 case 47:
20541 return FB[RISCV::FeatureStdExtP] && FB[RISCV::Feature64Bit];
20542 case 48:
20543 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && FB[RISCV::Feature64Bit];
20544 case 49:
20545 return FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
20546 case 50:
20547 return FB[RISCV::FeatureStdExtZbb] && FB[RISCV::Feature64Bit];
20548 case 51:
20549 return FB[RISCV::FeatureStdExtZabha];
20550 case 52:
20551 return FB[RISCV::FeatureStdExtZaamo];
20552 case 53:
20553 return FB[RISCV::FeatureStdExtZaamo] && FB[RISCV::Feature64Bit];
20554 case 54:
20555 return FB[RISCV::FeatureStdExtZalrsc];
20556 case 55:
20557 return FB[RISCV::FeatureStdExtZalrsc] && FB[RISCV::Feature64Bit];
20558 case 56:
20559 return FB[RISCV::FeatureStdExtZabha] && FB[RISCV::FeatureStdExtZacas];
20560 case 57:
20561 return FB[RISCV::FeatureStdExtZacas];
20562 case 58:
20563 return FB[RISCV::FeatureStdExtZacas] && FB[RISCV::Feature64Bit];
20564 case 59:
20565 return FB[RISCV::FeatureStdExtZalasr];
20566 case 60:
20567 return FB[RISCV::FeatureStdExtZalasr] && FB[RISCV::Feature64Bit];
20568 case 61:
20569 return FB[RISCV::FeatureStdExtZicfiss];
20570 case 62:
20571 return FB[RISCV::FeatureStdExtZicfiss] && FB[RISCV::Feature64Bit];
20572 case 63:
20573 return FB[RISCV::FeatureStdExtZmmul];
20574 case 64:
20575 return FB[RISCV::FeatureStdExtM];
20576 case 65:
20577 return FB[RISCV::FeatureStdExtZbkb] || FB[RISCV::FeatureStdExtP];
20578 case 66:
20579 return FB[RISCV::FeatureStdExtZbkc];
20580 case 67:
20581 return FB[RISCV::FeatureStdExtZbc];
20582 case 68:
20583 return FB[RISCV::FeatureStdExtZicond];
20584 case 69:
20585 return FB[RISCV::FeatureStdExtZknh] && !(FB[RISCV::Feature64Bit]);
20586 case 70:
20587 return FB[RISCV::FeatureStdExtZba];
20588 case 71:
20589 return FB[RISCV::FeatureStdExtZkne] && !(FB[RISCV::Feature64Bit]);
20590 case 72:
20591 return FB[RISCV::FeatureStdExtZbkx];
20592 case 73:
20593 return FB[RISCV::FeatureStdExtZknd] && !(FB[RISCV::Feature64Bit]);
20594 case 74:
20595 return FB[RISCV::FeatureStdExtZksed];
20596 case 75:
20597 return FB[RISCV::FeatureStdExtZkne] && FB[RISCV::Feature64Bit];
20598 case 76:
20599 return FB[RISCV::FeatureStdExtZmmul] && FB[RISCV::Feature64Bit];
20600 case 77:
20601 return FB[RISCV::FeatureStdExtM] && FB[RISCV::Feature64Bit];
20602 case 78:
20603 return FB[RISCV::FeatureStdExtZbkb] && FB[RISCV::Feature64Bit];
20604 case 79:
20605 return FB[RISCV::FeatureStdExtZfh];
20606 case 80:
20607 return FB[RISCV::FeatureStdExtZfa];
20608 case 81:
20609 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD];
20610 case 82:
20611 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtZfh];
20612 case 83:
20613 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ];
20614 case 84:
20615 return FB[RISCV::FeatureStdExtZfhmin];
20616 case 85:
20617 return FB[RISCV::FeatureStdExtZfbfmin];
20618 case 86:
20619 return FB[RISCV::FeatureStdExtZfhmin] && FB[RISCV::FeatureStdExtD];
20620 case 87:
20621 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD] && !(FB[RISCV::Feature64Bit]);
20622 case 88:
20623 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
20624 case 89:
20625 return FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
20626 case 90:
20627 return FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
20628 case 91:
20629 return FB[RISCV::FeatureStdExtZfh] && FB[RISCV::Feature64Bit];
20630 case 92:
20631 return FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
20632 case 93:
20633 return FB[RISCV::FeatureStdExtZfa] && (FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZvfh]);
20634 case 94:
20635 return FB[RISCV::FeatureStdExtZvkb];
20636 case 95:
20637 return FB[RISCV::FeatureStdExtZvzip];
20638 case 96:
20639 return FB[RISCV::FeatureStdExtZvbb];
20640 case 97:
20641 return FB[RISCV::FeatureStdExtZvvmm];
20642 case 98:
20643 return FB[RISCV::FeatureStdExtZvvfmm];
20644 case 99:
20645 return FB[RISCV::FeatureStdExtZve32f];
20646 case 100:
20647 return FB[RISCV::FeatureStdExtZvfbfmin] || FB[RISCV::FeatureStdExtZvfofp8min];
20648 case 101:
20649 return FB[RISCV::FeatureStdExtZvfofp8min];
20650 case 102:
20651 return FB[RISCV::FeatureStdExtZvfbfwma];
20652 case 103:
20653 return FB[RISCV::FeatureStdExtZvbc] || FB[RISCV::FeatureStdExtZvbc32e];
20654 case 104:
20655 return FB[RISCV::FeatureStdExtZvabd];
20656 case 105:
20657 return FB[RISCV::FeatureStdExtZvdot4a8i];
20658 case 106:
20659 return FB[RISCV::FeatureStdExtZibi];
20660 case 107:
20661 return FB[RISCV::FeatureStdExtZawrs];
20662 case 108:
20663 return FB[RISCV::FeatureStdExtSmctr] || FB[RISCV::FeatureStdExtSsctr];
20664 case 109:
20665 return FB[RISCV::FeatureStdExtSvinval];
20666 case 110:
20667 return FB[RISCV::FeatureStdExtH];
20668 case 111:
20669 return FB[RISCV::FeatureStdExtSmrnmi];
20670 case 112:
20671 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtH];
20672 case 113:
20673 return FB[RISCV::FeatureStdExtZimop];
20674 case 114:
20675 return FB[RISCV::FeatureStdExtZvksh];
20676 case 115:
20677 return FB[RISCV::FeatureStdExtZvksed];
20678 case 116:
20679 return FB[RISCV::FeatureStdExtZvkned];
20680 case 117:
20681 return FB[RISCV::FeatureStdExtZvkgs];
20682 case 118:
20683 return FB[RISCV::FeatureStdExtZvfwdota16bf];
20684 case 119:
20685 return FB[RISCV::FeatureStdExtZvqwdota8i] || FB[RISCV::FeatureStdExtZvqwdota16i];
20686 case 120:
20687 return FB[RISCV::FeatureStdExtZvfqwdota8f];
20688 case 121:
20689 return FB[RISCV::FeatureStdExtZvkg];
20690 case 122:
20691 return FB[RISCV::FeatureStdExtZvfbdota32f];
20692 case 123:
20693 return FB[RISCV::FeatureStdExtZvfwbdota16bf];
20694 case 124:
20695 return FB[RISCV::FeatureStdExtZvknha];
20696 case 125:
20697 return FB[RISCV::FeatureStdExtZvqwbdota8i] || FB[RISCV::FeatureStdExtZvqwbdota16i];
20698 case 126:
20699 return FB[RISCV::FeatureStdExtZvfqwbdota8f];
20700 case 127:
20701 return FB[RISCV::FeatureStdExtY];
20702 case 128:
20703 return FB[RISCV::FeatureStdExtZilsd] && !(FB[RISCV::Feature64Bit]);
20704 case 129:
20705 return FB[RISCV::FeatureStdExtZacas] && !(FB[RISCV::Feature64Bit]);
20706 case 130:
20707 return FB[RISCV::FeatureVendorXAIFET];
20708 case 131:
20709 return FB[RISCV::FeatureVendorXAndesPerf];
20710 case 132:
20711 return FB[RISCV::FeatureVendorXAndesVBFHCvt];
20712 case 133:
20713 return FB[RISCV::FeatureVendorXAndesBFHCvt];
20714 case 134:
20715 return FB[RISCV::FeatureVendorXAndesVSIntH];
20716 case 135:
20717 return FB[RISCV::FeatureVendorXAndesVSIntLoad];
20718 case 136:
20719 return FB[RISCV::FeatureVendorXAndesVPackFPH];
20720 case 137:
20721 return FB[RISCV::FeatureVendorXAndesPerf] && FB[RISCV::Feature64Bit];
20722 case 138:
20723 return FB[RISCV::FeatureVendorXAndesVDot];
20724 case 139:
20725 return FB[RISCV::FeatureVendorXCVmem] && !(FB[RISCV::Feature64Bit]);
20726 case 140:
20727 return FB[RISCV::FeatureVendorXCVbitmanip] && !(FB[RISCV::Feature64Bit]);
20728 case 141:
20729 return FB[RISCV::FeatureVendorXCVsimd] && !(FB[RISCV::Feature64Bit]);
20730 case 142:
20731 return FB[RISCV::FeatureVendorXCValu] && !(FB[RISCV::Feature64Bit]);
20732 case 143:
20733 return FB[RISCV::FeatureVendorXCVelw] && !(FB[RISCV::Feature64Bit]);
20734 case 144:
20735 return FB[RISCV::FeatureVendorXCVmac] && !(FB[RISCV::Feature64Bit]);
20736 case 145:
20737 return FB[RISCV::FeatureVendorXCVbi] && !(FB[RISCV::Feature64Bit]);
20738 case 146:
20739 return FB[RISCV::FeatureVendorXMIPSCBOP];
20740 case 147:
20741 return FB[RISCV::FeatureVendorXMIPSEXECTL];
20742 case 148:
20743 return FB[RISCV::FeatureVendorXMIPSCMov];
20744 case 149:
20745 return FB[RISCV::FeatureVendorXMIPSLSP];
20746 case 150:
20747 return FB[RISCV::FeatureVendorXSMTVDotII] && FB[RISCV::Feature64Bit];
20748 case 151:
20749 return FB[RISCV::FeatureVendorXSMTVDot] && FB[RISCV::Feature64Bit];
20750 case 152:
20751 return FB[RISCV::FeatureVendorXSfcease];
20752 case 153:
20753 return FB[RISCV::FeatureVendorXSiFivecflushdlone];
20754 case 154:
20755 return FB[RISCV::FeatureVendorXSiFivecdiscarddlone];
20756 case 155:
20757 return FB[RISCV::FeatureVendorXSfvcp];
20758 case 156:
20759 return FB[RISCV::FeatureVendorXSfmmbase];
20760 case 157:
20761 return FB[RISCV::FeatureVendorXSfvfexpa];
20762 case 158:
20763 return FB[RISCV::FeatureVendorXSfvfbfexp16e] || FB[RISCV::FeatureVendorXSfvfexp16e] || FB[RISCV::FeatureVendorXSfvfexp32e];
20764 case 159:
20765 return FB[RISCV::FeatureVendorXSfvfnrclipxfqf];
20766 case 160:
20767 return FB[RISCV::FeatureVendorXSfvqmaccdod];
20768 case 161:
20769 return FB[RISCV::FeatureVendorXSfmm32a8i];
20770 case 162:
20771 return FB[RISCV::FeatureVendorXSfvfwmaccqqq];
20772 case 163:
20773 return FB[RISCV::FeatureVendorXSfmm32a16f] || FB[RISCV::FeatureVendorXSfmm32a32f] || FB[RISCV::FeatureVendorXSfmm64a64f];
20774 case 164:
20775 return FB[RISCV::FeatureVendorXSfmm32a8f];
20776 case 165:
20777 return FB[RISCV::FeatureVendorXSfvqmaccqoq];
20778 case 166:
20779 return FB[RISCV::FeatureVendorXTHeadCmo];
20780 case 167:
20781 return FB[RISCV::FeatureVendorXTHeadSync];
20782 case 168:
20783 return FB[RISCV::FeatureVendorXTHeadBa];
20784 case 169:
20785 return FB[RISCV::FeatureVendorXTHeadBb];
20786 case 170:
20787 return FB[RISCV::FeatureVendorXTHeadBb] && FB[RISCV::Feature64Bit];
20788 case 171:
20789 return FB[RISCV::FeatureVendorXTHeadMac];
20790 case 172:
20791 return FB[RISCV::FeatureVendorXTHeadMac] && FB[RISCV::Feature64Bit];
20792 case 173:
20793 return FB[RISCV::FeatureVendorXTHeadCondMov];
20794 case 174:
20795 return FB[RISCV::FeatureVendorXTHeadBs];
20796 case 175:
20797 return FB[RISCV::FeatureVendorXTHeadMemIdx];
20798 case 176:
20799 return FB[RISCV::FeatureVendorXTHeadMemIdx] && FB[RISCV::Feature64Bit];
20800 case 177:
20801 return FB[RISCV::FeatureVendorXTHeadMemPair];
20802 case 178:
20803 return FB[RISCV::FeatureVendorXTHeadMemPair] && FB[RISCV::Feature64Bit];
20804 case 179:
20805 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF];
20806 case 180:
20807 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
20808 case 181:
20809 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD];
20810 case 182:
20811 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
20812 case 183:
20813 return FB[RISCV::FeatureVendorXTHeadVdot];
20814 case 184:
20815 return FB[RISCV::FeatureVendorXVentanaCondOps];
20816 case 185:
20817 return FB[RISCV::FeatureVendorXqcia] && !(FB[RISCV::Feature64Bit]);
20818 case 186:
20819 return FB[RISCV::FeatureVendorXqciio] && !(FB[RISCV::Feature64Bit]);
20820 case 187:
20821 return FB[RISCV::FeatureVendorXqcilsm] && !(FB[RISCV::Feature64Bit]);
20822 case 188:
20823 return FB[RISCV::FeatureVendorXqcisls] && !(FB[RISCV::Feature64Bit]);
20824 case 189:
20825 return FB[RISCV::FeatureVendorXqcisim] && !(FB[RISCV::Feature64Bit]);
20826 case 190:
20827 return FB[RISCV::FeatureVendorXqcili] && !(FB[RISCV::Feature64Bit]);
20828 case 191:
20829 return FB[RISCV::FeatureVendorXqcicli] && !(FB[RISCV::Feature64Bit]);
20830 case 192:
20831 return FB[RISCV::FeatureVendorXqcics] && !(FB[RISCV::Feature64Bit]);
20832 case 193:
20833 return FB[RISCV::FeatureVendorXqcicsr] && !(FB[RISCV::Feature64Bit]);
20834 case 194:
20835 return FB[RISCV::FeatureVendorXqcibi] && !(FB[RISCV::Feature64Bit]);
20836 case 195:
20837 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && !(FB[RISCV::Feature64Bit]);
20838 case 196:
20839 return FB[RISCV::FeatureStdExtZdinx] && !(FB[RISCV::Feature64Bit]);
20840 case 197:
20841 return FB[RISCV::FeatureStdExtZfinx];
20842 case 198:
20843 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
20844 case 199:
20845 return FB[RISCV::FeatureStdExtZhinx];
20846 case 200:
20847 return FB[RISCV::FeatureStdExtZhinxmin];
20848 case 201:
20849 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
20850 case 202:
20851 return FB[RISCV::FeatureStdExtZfinx] && FB[RISCV::Feature64Bit];
20852 case 203:
20853 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit] && FB[RISCV::Feature64Bit];
20854 case 204:
20855 return FB[RISCV::FeatureStdExtZhinx] && FB[RISCV::Feature64Bit];
20856 case 205:
20857 return FB[RISCV::FeatureVendorXqcilia] && !(FB[RISCV::Feature64Bit]);
20858 case 206:
20859 return FB[RISCV::FeatureVendorXqcilb] && !(FB[RISCV::Feature64Bit]);
20860 case 207:
20861 return FB[RISCV::FeatureVendorXqcilo] && !(FB[RISCV::Feature64Bit]);
20862 }
20863}
20864
20865
20866template <typename InsnType>
20867static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
20868 InsnType insn, uint64_t Address,
20869 const MCDisassembler *DisAsm,
20870 const MCSubtargetInfo &STI) {
20871 const FeatureBitset &Bits = STI.getFeatureBits();
20872 const uint8_t *Ptr = DecodeTable;
20873
20874 [[maybe_unused]] uint32_t BitWidth = decodeULEB128AndIncUnsafe(p&: Ptr);
20875 assert(InsnBitWidth<InsnType> == BitWidth &&
20876 "Table and instruction bitwidth mismatch");
20877
20878 SmallVector<const uint8_t *, 8> ScopeStack;
20879 DecodeStatus S = MCDisassembler::Success;
20880 while (true) {
20881 ptrdiff_t Loc = Ptr - DecodeTable;
20882 const uint8_t DecoderOp = *Ptr++;
20883 switch (DecoderOp) {
20884 default:
20885 errs() << Loc << ": Unexpected decode table opcode: "
20886 << (int)DecoderOp << '\n';
20887 return MCDisassembler::Fail;
20888 case OPC_Scope: {
20889 unsigned NumToSkip = decodeULEB128AndIncUnsafe(p&: Ptr);
20890 const uint8_t *SkipTo = Ptr + NumToSkip;
20891 ScopeStack.push_back(Elt: SkipTo);
20892 LLVM_DEBUG(dbgs() << Loc << ": OPC_Scope(" << SkipTo - DecodeTable
20893 << ")\n");
20894 continue;
20895 }
20896 case OPC_SwitchField: {
20897 // Decode the start value.
20898 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
20899 unsigned Len = *Ptr++;
20900 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
20901 uint64_t CaseValue;
20902 unsigned CaseSize;
20903 while (true) {
20904 CaseValue = decodeULEB128AndIncUnsafe(p&: Ptr);
20905 CaseSize = decodeULEB128AndIncUnsafe(p&: Ptr);
20906 if (FieldValue == CaseValue || !CaseSize)
20907 break;
20908 Ptr += CaseSize;
20909 }
20910 if (FieldValue == CaseValue) {
20911 LLVM_DEBUG(dbgs() << Loc << ": OPC_SwitchField(" << Start << ", " << Len
20912 << "): " << FieldValue << '\n');
20913 continue;
20914 }
20915 break;
20916 }
20917 case OPC_CheckField: {
20918 // Decode the start value.
20919 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
20920 unsigned Len = *Ptr;
20921 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
20922 // Decode the field value.
20923 unsigned PtrLen = 0;
20924 uint64_t ExpectedValue = decodeULEB128(p: ++Ptr, n: &PtrLen);
20925 Ptr += PtrLen;
20926 bool Failed = ExpectedValue != FieldValue;
20927
20928 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckField(" << Start << ", " << Len
20929 << ", " << ExpectedValue << "): FieldValue = "
20930 << FieldValue << ", ExpectedValue = " << ExpectedValue
20931 << ": " << (Failed ? "FAIL, " : "PASS\n"););
20932 if (!Failed)
20933 continue;
20934 break;
20935 }
20936 case OPC_CheckPredicate: {
20937 // Decode the Predicate Index value.
20938 unsigned PIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
20939 // Check the predicate.
20940 bool Failed = !checkDecoderPredicate(Idx: PIdx, FB: Bits);
20941
20942 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckPredicate(" << PIdx << "): "
20943 << (Failed ? "FAIL, " : "PASS\n"););
20944 if (!Failed)
20945 continue;
20946 break;
20947 }
20948 case OPC_Decode: {
20949 // Decode the Opcode value.
20950 unsigned Opc = decodeULEB128AndIncUnsafe(p&: Ptr);
20951 unsigned DecodeIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
20952
20953 MI.clear();
20954 MI.setOpcode(Opc);
20955 bool DecodeComplete;
20956 S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm,
20957 DecodeComplete);
20958 LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc
20959 << ", using decoder " << DecodeIdx << ": "
20960 << (S ? "PASS, " : "FAIL, "));
20961
20962 if (DecodeComplete) {
20963 LLVM_DEBUG(dbgs() << "decoding complete\n");
20964 return S;
20965 }
20966 assert(S == MCDisassembler::Fail);
20967 // Reset decode status. This also drops a SoftFail status that could be
20968 // set before the decode attempt.
20969 S = MCDisassembler::Success;
20970 break;
20971 }
20972 }
20973 if (ScopeStack.empty()) {
20974 LLVM_DEBUG(dbgs() << "returning Fail\n");
20975 return MCDisassembler::Fail;
20976 }
20977 Ptr = ScopeStack.pop_back_val();
20978 LLVM_DEBUG(dbgs() << "continuing at " << Ptr - DecodeTable << '\n');
20979 }
20980 llvm_unreachable("bogosity detected in disassembler state machine!");
20981}
20982
20983
20984} // namespace
20985