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, 224, 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, 158, 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, 200, 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, 201, 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, 156, 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, 213, 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, 166, 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, 159, 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, 167, 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, 188, 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, 186, 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, 189, 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, 179, 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, 195, 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, 196, 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, 197, 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, 192, 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, 193, 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, 194, 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, 157, 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, 187, 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, 180, 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, 178, 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, 184, 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, 183, 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, 204, 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, 211, 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, 215, 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, 214, 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, 162, 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, 218, 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, 219, 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, 225, 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, 160, 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, 203, 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, 198, 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, 161, 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, 226, 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, 209, 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, 227, 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, 210, 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, 228, 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, 202, 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, 177, 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, 199, 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, 165, 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, 176, 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, 155, 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, 170, 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, 174, 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, 171, 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, 220, 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, 163, 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, 221, 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, 205, 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, 164, 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, 206, 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, 168, 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, 172, 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, 175, 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, 169, 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, 173, 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, 239, 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, 238, 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, 243, 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, 244, 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, 240, 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, 242, 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, 241, 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, 237, 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, 236, 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, 130, 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, 131, 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, 134, 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, 133, 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, 132, 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, 253, 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, 255, 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, 254, 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, 128, 122, 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, 137, 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, 252, 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, 129, 122, 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, 135, 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, 138, 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, 139, 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, 140, 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, 250, 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, 141, 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, 251, 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, 136, 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, 253, 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, 255, 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, 254, 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, 128, 123, 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, 130, 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, 132, 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, 129, 123, 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, 131, 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, 182, 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, 181, 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, 208, 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, 207, 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, 210, 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, 209, 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, 214, 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, 211, 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, 213, 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, 212, 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, 208, 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, 207, 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, 217, 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, 216, 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[20486] = {
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, 175, 116, 0, // 11: decode to LB using decoder 0
1164 // 11: }
1165 1, 4, // 15: case 0x1: {
1166 OPC_Decode, 183, 116, 0, // 17: decode to LH using decoder 0
1167 // 17: }
1168 2, 4, // 21: case 0x2: {
1169 OPC_Decode, 197, 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, 179, 116, 0, // 31: decode to LD using decoder 0
1174 // 31: }
1175 4, 4, // 35: case 0x4: {
1176 OPC_Decode, 176, 116, 0, // 37: decode to LBU using decoder 0
1177 // 37: }
1178 5, 4, // 41: case 0x5: {
1179 OPC_Decode, 184, 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, 198, 116, 0, // 51: decode to LWU using decoder 0
1184 // 51: }
1185 // 51: } // switch Inst[14:12]
1186 // 51: }
1187 7, 248, 13, // 55: case 0x7: {
1188 OPC_SwitchField, 12, 3, // 58: switch Inst[14:12] {
1189 0, 178, 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, 145, 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, 253, 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, 146, 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, 144, 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, 142, 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, 182, 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, 150, 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, 190, 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, 129, 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, 189, 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, 146, 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, 242, 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, 154, 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, 198, 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, 197, 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, 150, 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, 246, 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, 158, 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, 206, 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, 133, 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, 205, 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, 154, 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, 250, 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, 162, 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, 214, 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, 213, 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, 158, 128, 1, 3, // 324: decode to VLUXSEG5EI8_V using decoder 3
1322 // 324: }
1323 34, 6, // 329: case 0x22: {
1324 OPC_CheckPredicate, 22, // 331: check predicate 22
1325 OPC_Decode, 254, 127, 4, // 333: decode to VLSSEG5E8_V using decoder 4
1326 // 333: }
1327 35, 6, // 337: case 0x23: {
1328 OPC_CheckPredicate, 22, // 339: check predicate 22
1329 OPC_Decode, 166, 127, 3, // 341: decode to VLOXSEG5EI8_V using decoder 3
1330 // 341: }
1331 40, 19, // 345: case 0x28: {
1332 OPC_SwitchField, 20, 5, // 347: switch Inst[24:20] {
1333 0, 6, // 350: case 0x0: {
1334 OPC_CheckPredicate, 22, // 352: check predicate 22
1335 OPC_Decode, 222, 127, 1, // 354: decode to VLSEG6E8_V using decoder 1
1336 // 354: }
1337 16, 0, // 358: case 0x10: {
1338 OPC_CheckPredicate, 22, // 360: check predicate 22
1339 OPC_Decode, 221, 127, 1, // 362: decode to VLSEG6E8FF_V using decoder 1
1340 // 362: }
1341 // 362: } // switch Inst[24:20]
1342 // 362: }
1343 41, 7, // 366: case 0x29: {
1344 OPC_CheckPredicate, 22, // 368: check predicate 22
1345 OPC_Decode, 162, 128, 1, 3, // 370: decode to VLUXSEG6EI8_V using decoder 3
1346 // 370: }
1347 42, 7, // 375: case 0x2a: {
1348 OPC_CheckPredicate, 22, // 377: check predicate 22
1349 OPC_Decode, 130, 128, 1, 4, // 379: decode to VLSSEG6E8_V using decoder 4
1350 // 379: }
1351 43, 6, // 384: case 0x2b: {
1352 OPC_CheckPredicate, 22, // 386: check predicate 22
1353 OPC_Decode, 170, 127, 3, // 388: decode to VLOXSEG6EI8_V using decoder 3
1354 // 388: }
1355 48, 19, // 392: case 0x30: {
1356 OPC_SwitchField, 20, 5, // 394: switch Inst[24:20] {
1357 0, 6, // 397: case 0x0: {
1358 OPC_CheckPredicate, 22, // 399: check predicate 22
1359 OPC_Decode, 230, 127, 1, // 401: decode to VLSEG7E8_V using decoder 1
1360 // 401: }
1361 16, 0, // 405: case 0x10: {
1362 OPC_CheckPredicate, 22, // 407: check predicate 22
1363 OPC_Decode, 229, 127, 1, // 409: decode to VLSEG7E8FF_V using decoder 1
1364 // 409: }
1365 // 409: } // switch Inst[24:20]
1366 // 409: }
1367 49, 7, // 413: case 0x31: {
1368 OPC_CheckPredicate, 22, // 415: check predicate 22
1369 OPC_Decode, 166, 128, 1, 3, // 417: decode to VLUXSEG7EI8_V using decoder 3
1370 // 417: }
1371 50, 7, // 422: case 0x32: {
1372 OPC_CheckPredicate, 22, // 424: check predicate 22
1373 OPC_Decode, 134, 128, 1, 4, // 426: decode to VLSSEG7E8_V using decoder 4
1374 // 426: }
1375 51, 6, // 431: case 0x33: {
1376 OPC_CheckPredicate, 22, // 433: check predicate 22
1377 OPC_Decode, 174, 127, 3, // 435: decode to VLOXSEG7EI8_V using decoder 3
1378 // 435: }
1379 56, 31, // 439: case 0x38: {
1380 OPC_SwitchField, 20, 5, // 441: switch Inst[24:20] {
1381 0, 6, // 444: case 0x0: {
1382 OPC_CheckPredicate, 22, // 446: check predicate 22
1383 OPC_Decode, 238, 127, 1, // 448: decode to VLSEG8E8_V using decoder 1
1384 // 448: }
1385 8, 10, // 452: case 0x8: {
1386 OPC_CheckPredicate, 22, // 454: check predicate 22
1387 OPC_CheckField, 25, 1, 1, // 456: check Inst[25] == 0x1
1388 OPC_Decode, 137, 127, 7, // 460: decode to VL8RE8_V using decoder 7
1389 // 460: }
1390 16, 0, // 464: case 0x10: {
1391 OPC_CheckPredicate, 22, // 466: check predicate 22
1392 OPC_Decode, 237, 127, 1, // 468: decode to VLSEG8E8FF_V using decoder 1
1393 // 468: }
1394 // 468: } // switch Inst[24:20]
1395 // 468: }
1396 57, 7, // 472: case 0x39: {
1397 OPC_CheckPredicate, 22, // 474: check predicate 22
1398 OPC_Decode, 170, 128, 1, 3, // 476: decode to VLUXSEG8EI8_V using decoder 3
1399 // 476: }
1400 58, 7, // 481: case 0x3a: {
1401 OPC_CheckPredicate, 22, // 483: check predicate 22
1402 OPC_Decode, 138, 128, 1, 4, // 485: decode to VLSSEG8E8_V using decoder 4
1403 // 485: }
1404 59, 0, // 490: case 0x3b: {
1405 OPC_CheckPredicate, 22, // 492: check predicate 22
1406 OPC_Decode, 178, 127, 3, // 494: decode to VLOXSEG8EI8_V using decoder 3
1407 // 494: }
1408 // 494: } // switch Inst[31:26]
1409 // 494: }
1410 1, 6, // 498: case 0x1: {
1411 OPC_CheckPredicate, 23, // 500: check predicate 23
1412 OPC_Decode, 239, 114, 8, // 502: decode to FLH using decoder 8
1413 // 502: }
1414 2, 6, // 506: case 0x2: {
1415 OPC_CheckPredicate, 24, // 508: check predicate 24
1416 OPC_Decode, 129, 115, 9, // 510: decode to FLW using decoder 9
1417 // 510: }
1418 3, 6, // 514: case 0x3: {
1419 OPC_CheckPredicate, 25, // 516: check predicate 25
1420 OPC_Decode, 226, 114, 10, // 518: decode to FLD using decoder 10
1421 // 518: }
1422 4, 6, // 522: case 0x4: {
1423 OPC_CheckPredicate, 26, // 524: check predicate 26
1424 OPC_Decode, 244, 114, 11, // 526: decode to FLQ using decoder 11
1425 // 526: }
1426 5, 165, 3, // 530: case 0x5: {
1427 OPC_SwitchField, 26, 6, // 533: switch Inst[31:26] {
1428 0, 31, // 536: case 0x0: {
1429 OPC_SwitchField, 20, 5, // 538: switch Inst[24:20] {
1430 0, 6, // 541: case 0x0: {
1431 OPC_CheckPredicate, 22, // 543: check predicate 22
1432 OPC_Decode, 139, 127, 1, // 545: decode to VLE16_V using decoder 1
1433 // 545: }
1434 8, 10, // 549: case 0x8: {
1435 OPC_CheckPredicate, 22, // 551: check predicate 22
1436 OPC_CheckField, 25, 1, 1, // 553: check Inst[25] == 0x1
1437 OPC_Decode, 250, 126, 2, // 557: decode to VL1RE16_V using decoder 2
1438 // 557: }
1439 16, 0, // 561: case 0x10: {
1440 OPC_CheckPredicate, 22, // 563: check predicate 22
1441 OPC_Decode, 138, 127, 1, // 565: decode to VLE16FF_V using decoder 1
1442 // 565: }
1443 // 565: } // switch Inst[24:20]
1444 // 565: }
1445 1, 7, // 569: case 0x1: {
1446 OPC_CheckPredicate, 22, // 571: check predicate 22
1447 OPC_Decode, 139, 128, 1, 3, // 573: decode to VLUXEI16_V using decoder 3
1448 // 573: }
1449 2, 6, // 578: case 0x2: {
1450 OPC_CheckPredicate, 22, // 580: check predicate 22
1451 OPC_Decode, 179, 127, 4, // 582: decode to VLSE16_V using decoder 4
1452 // 582: }
1453 3, 6, // 586: case 0x3: {
1454 OPC_CheckPredicate, 22, // 588: check predicate 22
1455 OPC_Decode, 147, 127, 3, // 590: decode to VLOXEI16_V using decoder 3
1456 // 590: }
1457 8, 31, // 594: case 0x8: {
1458 OPC_SwitchField, 20, 5, // 596: switch Inst[24:20] {
1459 0, 6, // 599: case 0x0: {
1460 OPC_CheckPredicate, 22, // 601: check predicate 22
1461 OPC_Decode, 184, 127, 1, // 603: decode to VLSEG2E16_V using decoder 1
1462 // 603: }
1463 8, 10, // 607: case 0x8: {
1464 OPC_CheckPredicate, 22, // 609: check predicate 22
1465 OPC_CheckField, 25, 1, 1, // 611: check Inst[25] == 0x1
1466 OPC_Decode, 254, 126, 5, // 615: decode to VL2RE16_V using decoder 5
1467 // 615: }
1468 16, 0, // 619: case 0x10: {
1469 OPC_CheckPredicate, 22, // 621: check predicate 22
1470 OPC_Decode, 183, 127, 1, // 623: decode to VLSEG2E16FF_V using decoder 1
1471 // 623: }
1472 // 623: } // switch Inst[24:20]
1473 // 623: }
1474 9, 7, // 627: case 0x9: {
1475 OPC_CheckPredicate, 22, // 629: check predicate 22
1476 OPC_Decode, 143, 128, 1, 3, // 631: decode to VLUXSEG2EI16_V using decoder 3
1477 // 631: }
1478 10, 6, // 636: case 0xa: {
1479 OPC_CheckPredicate, 22, // 638: check predicate 22
1480 OPC_Decode, 239, 127, 4, // 640: decode to VLSSEG2E16_V using decoder 4
1481 // 640: }
1482 11, 6, // 644: case 0xb: {
1483 OPC_CheckPredicate, 22, // 646: check predicate 22
1484 OPC_Decode, 151, 127, 3, // 648: decode to VLOXSEG2EI16_V using decoder 3
1485 // 648: }
1486 16, 19, // 652: case 0x10: {
1487 OPC_SwitchField, 20, 5, // 654: switch Inst[24:20] {
1488 0, 6, // 657: case 0x0: {
1489 OPC_CheckPredicate, 22, // 659: check predicate 22
1490 OPC_Decode, 192, 127, 1, // 661: decode to VLSEG3E16_V using decoder 1
1491 // 661: }
1492 16, 0, // 665: case 0x10: {
1493 OPC_CheckPredicate, 22, // 667: check predicate 22
1494 OPC_Decode, 191, 127, 1, // 669: decode to VLSEG3E16FF_V using decoder 1
1495 // 669: }
1496 // 669: } // switch Inst[24:20]
1497 // 669: }
1498 17, 7, // 673: case 0x11: {
1499 OPC_CheckPredicate, 22, // 675: check predicate 22
1500 OPC_Decode, 147, 128, 1, 3, // 677: decode to VLUXSEG3EI16_V using decoder 3
1501 // 677: }
1502 18, 6, // 682: case 0x12: {
1503 OPC_CheckPredicate, 22, // 684: check predicate 22
1504 OPC_Decode, 243, 127, 4, // 686: decode to VLSSEG3E16_V using decoder 4
1505 // 686: }
1506 19, 6, // 690: case 0x13: {
1507 OPC_CheckPredicate, 22, // 692: check predicate 22
1508 OPC_Decode, 155, 127, 3, // 694: decode to VLOXSEG3EI16_V using decoder 3
1509 // 694: }
1510 24, 31, // 698: case 0x18: {
1511 OPC_SwitchField, 20, 5, // 700: switch Inst[24:20] {
1512 0, 6, // 703: case 0x0: {
1513 OPC_CheckPredicate, 22, // 705: check predicate 22
1514 OPC_Decode, 200, 127, 1, // 707: decode to VLSEG4E16_V using decoder 1
1515 // 707: }
1516 8, 10, // 711: case 0x8: {
1517 OPC_CheckPredicate, 22, // 713: check predicate 22
1518 OPC_CheckField, 25, 1, 1, // 715: check Inst[25] == 0x1
1519 OPC_Decode, 130, 127, 6, // 719: decode to VL4RE16_V using decoder 6
1520 // 719: }
1521 16, 0, // 723: case 0x10: {
1522 OPC_CheckPredicate, 22, // 725: check predicate 22
1523 OPC_Decode, 199, 127, 1, // 727: decode to VLSEG4E16FF_V using decoder 1
1524 // 727: }
1525 // 727: } // switch Inst[24:20]
1526 // 727: }
1527 25, 7, // 731: case 0x19: {
1528 OPC_CheckPredicate, 22, // 733: check predicate 22
1529 OPC_Decode, 151, 128, 1, 3, // 735: decode to VLUXSEG4EI16_V using decoder 3
1530 // 735: }
1531 26, 6, // 740: case 0x1a: {
1532 OPC_CheckPredicate, 22, // 742: check predicate 22
1533 OPC_Decode, 247, 127, 4, // 744: decode to VLSSEG4E16_V using decoder 4
1534 // 744: }
1535 27, 6, // 748: case 0x1b: {
1536 OPC_CheckPredicate, 22, // 750: check predicate 22
1537 OPC_Decode, 159, 127, 3, // 752: decode to VLOXSEG4EI16_V using decoder 3
1538 // 752: }
1539 32, 19, // 756: case 0x20: {
1540 OPC_SwitchField, 20, 5, // 758: switch Inst[24:20] {
1541 0, 6, // 761: case 0x0: {
1542 OPC_CheckPredicate, 22, // 763: check predicate 22
1543 OPC_Decode, 208, 127, 1, // 765: decode to VLSEG5E16_V using decoder 1
1544 // 765: }
1545 16, 0, // 769: case 0x10: {
1546 OPC_CheckPredicate, 22, // 771: check predicate 22
1547 OPC_Decode, 207, 127, 1, // 773: decode to VLSEG5E16FF_V using decoder 1
1548 // 773: }
1549 // 773: } // switch Inst[24:20]
1550 // 773: }
1551 33, 7, // 777: case 0x21: {
1552 OPC_CheckPredicate, 22, // 779: check predicate 22
1553 OPC_Decode, 155, 128, 1, 3, // 781: decode to VLUXSEG5EI16_V using decoder 3
1554 // 781: }
1555 34, 6, // 786: case 0x22: {
1556 OPC_CheckPredicate, 22, // 788: check predicate 22
1557 OPC_Decode, 251, 127, 4, // 790: decode to VLSSEG5E16_V using decoder 4
1558 // 790: }
1559 35, 6, // 794: case 0x23: {
1560 OPC_CheckPredicate, 22, // 796: check predicate 22
1561 OPC_Decode, 163, 127, 3, // 798: decode to VLOXSEG5EI16_V using decoder 3
1562 // 798: }
1563 40, 19, // 802: case 0x28: {
1564 OPC_SwitchField, 20, 5, // 804: switch Inst[24:20] {
1565 0, 6, // 807: case 0x0: {
1566 OPC_CheckPredicate, 22, // 809: check predicate 22
1567 OPC_Decode, 216, 127, 1, // 811: decode to VLSEG6E16_V using decoder 1
1568 // 811: }
1569 16, 0, // 815: case 0x10: {
1570 OPC_CheckPredicate, 22, // 817: check predicate 22
1571 OPC_Decode, 215, 127, 1, // 819: decode to VLSEG6E16FF_V using decoder 1
1572 // 819: }
1573 // 819: } // switch Inst[24:20]
1574 // 819: }
1575 41, 7, // 823: case 0x29: {
1576 OPC_CheckPredicate, 22, // 825: check predicate 22
1577 OPC_Decode, 159, 128, 1, 3, // 827: decode to VLUXSEG6EI16_V using decoder 3
1578 // 827: }
1579 42, 6, // 832: case 0x2a: {
1580 OPC_CheckPredicate, 22, // 834: check predicate 22
1581 OPC_Decode, 255, 127, 4, // 836: decode to VLSSEG6E16_V using decoder 4
1582 // 836: }
1583 43, 6, // 840: case 0x2b: {
1584 OPC_CheckPredicate, 22, // 842: check predicate 22
1585 OPC_Decode, 167, 127, 3, // 844: decode to VLOXSEG6EI16_V using decoder 3
1586 // 844: }
1587 48, 19, // 848: case 0x30: {
1588 OPC_SwitchField, 20, 5, // 850: switch Inst[24:20] {
1589 0, 6, // 853: case 0x0: {
1590 OPC_CheckPredicate, 22, // 855: check predicate 22
1591 OPC_Decode, 224, 127, 1, // 857: decode to VLSEG7E16_V using decoder 1
1592 // 857: }
1593 16, 0, // 861: case 0x10: {
1594 OPC_CheckPredicate, 22, // 863: check predicate 22
1595 OPC_Decode, 223, 127, 1, // 865: decode to VLSEG7E16FF_V using decoder 1
1596 // 865: }
1597 // 865: } // switch Inst[24:20]
1598 // 865: }
1599 49, 7, // 869: case 0x31: {
1600 OPC_CheckPredicate, 22, // 871: check predicate 22
1601 OPC_Decode, 163, 128, 1, 3, // 873: decode to VLUXSEG7EI16_V using decoder 3
1602 // 873: }
1603 50, 7, // 878: case 0x32: {
1604 OPC_CheckPredicate, 22, // 880: check predicate 22
1605 OPC_Decode, 131, 128, 1, 4, // 882: decode to VLSSEG7E16_V using decoder 4
1606 // 882: }
1607 51, 6, // 887: case 0x33: {
1608 OPC_CheckPredicate, 22, // 889: check predicate 22
1609 OPC_Decode, 171, 127, 3, // 891: decode to VLOXSEG7EI16_V using decoder 3
1610 // 891: }
1611 56, 31, // 895: case 0x38: {
1612 OPC_SwitchField, 20, 5, // 897: switch Inst[24:20] {
1613 0, 6, // 900: case 0x0: {
1614 OPC_CheckPredicate, 22, // 902: check predicate 22
1615 OPC_Decode, 232, 127, 1, // 904: decode to VLSEG8E16_V using decoder 1
1616 // 904: }
1617 8, 10, // 908: case 0x8: {
1618 OPC_CheckPredicate, 22, // 910: check predicate 22
1619 OPC_CheckField, 25, 1, 1, // 912: check Inst[25] == 0x1
1620 OPC_Decode, 134, 127, 7, // 916: decode to VL8RE16_V using decoder 7
1621 // 916: }
1622 16, 0, // 920: case 0x10: {
1623 OPC_CheckPredicate, 22, // 922: check predicate 22
1624 OPC_Decode, 231, 127, 1, // 924: decode to VLSEG8E16FF_V using decoder 1
1625 // 924: }
1626 // 924: } // switch Inst[24:20]
1627 // 924: }
1628 57, 7, // 928: case 0x39: {
1629 OPC_CheckPredicate, 22, // 930: check predicate 22
1630 OPC_Decode, 167, 128, 1, 3, // 932: decode to VLUXSEG8EI16_V using decoder 3
1631 // 932: }
1632 58, 7, // 937: case 0x3a: {
1633 OPC_CheckPredicate, 22, // 939: check predicate 22
1634 OPC_Decode, 135, 128, 1, 4, // 941: decode to VLSSEG8E16_V using decoder 4
1635 // 941: }
1636 59, 0, // 946: case 0x3b: {
1637 OPC_CheckPredicate, 22, // 948: check predicate 22
1638 OPC_Decode, 175, 127, 3, // 950: decode to VLOXSEG8EI16_V using decoder 3
1639 // 950: }
1640 // 950: } // switch Inst[31:26]
1641 // 950: }
1642 6, 166, 3, // 954: case 0x6: {
1643 OPC_SwitchField, 26, 6, // 957: switch Inst[31:26] {
1644 0, 31, // 960: case 0x0: {
1645 OPC_SwitchField, 20, 5, // 962: switch Inst[24:20] {
1646 0, 6, // 965: case 0x0: {
1647 OPC_CheckPredicate, 22, // 967: check predicate 22
1648 OPC_Decode, 141, 127, 1, // 969: decode to VLE32_V using decoder 1
1649 // 969: }
1650 8, 10, // 973: case 0x8: {
1651 OPC_CheckPredicate, 22, // 975: check predicate 22
1652 OPC_CheckField, 25, 1, 1, // 977: check Inst[25] == 0x1
1653 OPC_Decode, 251, 126, 2, // 981: decode to VL1RE32_V using decoder 2
1654 // 981: }
1655 16, 0, // 985: case 0x10: {
1656 OPC_CheckPredicate, 22, // 987: check predicate 22
1657 OPC_Decode, 140, 127, 1, // 989: decode to VLE32FF_V using decoder 1
1658 // 989: }
1659 // 989: } // switch Inst[24:20]
1660 // 989: }
1661 1, 7, // 993: case 0x1: {
1662 OPC_CheckPredicate, 22, // 995: check predicate 22
1663 OPC_Decode, 140, 128, 1, 3, // 997: decode to VLUXEI32_V using decoder 3
1664 // 997: }
1665 2, 6, // 1002: case 0x2: {
1666 OPC_CheckPredicate, 22, // 1004: check predicate 22
1667 OPC_Decode, 180, 127, 4, // 1006: decode to VLSE32_V using decoder 4
1668 // 1006: }
1669 3, 6, // 1010: case 0x3: {
1670 OPC_CheckPredicate, 22, // 1012: check predicate 22
1671 OPC_Decode, 148, 127, 3, // 1014: decode to VLOXEI32_V using decoder 3
1672 // 1014: }
1673 8, 31, // 1018: case 0x8: {
1674 OPC_SwitchField, 20, 5, // 1020: switch Inst[24:20] {
1675 0, 6, // 1023: case 0x0: {
1676 OPC_CheckPredicate, 22, // 1025: check predicate 22
1677 OPC_Decode, 186, 127, 1, // 1027: decode to VLSEG2E32_V using decoder 1
1678 // 1027: }
1679 8, 10, // 1031: case 0x8: {
1680 OPC_CheckPredicate, 22, // 1033: check predicate 22
1681 OPC_CheckField, 25, 1, 1, // 1035: check Inst[25] == 0x1
1682 OPC_Decode, 255, 126, 5, // 1039: decode to VL2RE32_V using decoder 5
1683 // 1039: }
1684 16, 0, // 1043: case 0x10: {
1685 OPC_CheckPredicate, 22, // 1045: check predicate 22
1686 OPC_Decode, 185, 127, 1, // 1047: decode to VLSEG2E32FF_V using decoder 1
1687 // 1047: }
1688 // 1047: } // switch Inst[24:20]
1689 // 1047: }
1690 9, 7, // 1051: case 0x9: {
1691 OPC_CheckPredicate, 22, // 1053: check predicate 22
1692 OPC_Decode, 144, 128, 1, 3, // 1055: decode to VLUXSEG2EI32_V using decoder 3
1693 // 1055: }
1694 10, 6, // 1060: case 0xa: {
1695 OPC_CheckPredicate, 22, // 1062: check predicate 22
1696 OPC_Decode, 240, 127, 4, // 1064: decode to VLSSEG2E32_V using decoder 4
1697 // 1064: }
1698 11, 6, // 1068: case 0xb: {
1699 OPC_CheckPredicate, 22, // 1070: check predicate 22
1700 OPC_Decode, 152, 127, 3, // 1072: decode to VLOXSEG2EI32_V using decoder 3
1701 // 1072: }
1702 16, 19, // 1076: case 0x10: {
1703 OPC_SwitchField, 20, 5, // 1078: switch Inst[24:20] {
1704 0, 6, // 1081: case 0x0: {
1705 OPC_CheckPredicate, 22, // 1083: check predicate 22
1706 OPC_Decode, 194, 127, 1, // 1085: decode to VLSEG3E32_V using decoder 1
1707 // 1085: }
1708 16, 0, // 1089: case 0x10: {
1709 OPC_CheckPredicate, 22, // 1091: check predicate 22
1710 OPC_Decode, 193, 127, 1, // 1093: decode to VLSEG3E32FF_V using decoder 1
1711 // 1093: }
1712 // 1093: } // switch Inst[24:20]
1713 // 1093: }
1714 17, 7, // 1097: case 0x11: {
1715 OPC_CheckPredicate, 22, // 1099: check predicate 22
1716 OPC_Decode, 148, 128, 1, 3, // 1101: decode to VLUXSEG3EI32_V using decoder 3
1717 // 1101: }
1718 18, 6, // 1106: case 0x12: {
1719 OPC_CheckPredicate, 22, // 1108: check predicate 22
1720 OPC_Decode, 244, 127, 4, // 1110: decode to VLSSEG3E32_V using decoder 4
1721 // 1110: }
1722 19, 6, // 1114: case 0x13: {
1723 OPC_CheckPredicate, 22, // 1116: check predicate 22
1724 OPC_Decode, 156, 127, 3, // 1118: decode to VLOXSEG3EI32_V using decoder 3
1725 // 1118: }
1726 24, 31, // 1122: case 0x18: {
1727 OPC_SwitchField, 20, 5, // 1124: switch Inst[24:20] {
1728 0, 6, // 1127: case 0x0: {
1729 OPC_CheckPredicate, 22, // 1129: check predicate 22
1730 OPC_Decode, 202, 127, 1, // 1131: decode to VLSEG4E32_V using decoder 1
1731 // 1131: }
1732 8, 10, // 1135: case 0x8: {
1733 OPC_CheckPredicate, 22, // 1137: check predicate 22
1734 OPC_CheckField, 25, 1, 1, // 1139: check Inst[25] == 0x1
1735 OPC_Decode, 131, 127, 6, // 1143: decode to VL4RE32_V using decoder 6
1736 // 1143: }
1737 16, 0, // 1147: case 0x10: {
1738 OPC_CheckPredicate, 22, // 1149: check predicate 22
1739 OPC_Decode, 201, 127, 1, // 1151: decode to VLSEG4E32FF_V using decoder 1
1740 // 1151: }
1741 // 1151: } // switch Inst[24:20]
1742 // 1151: }
1743 25, 7, // 1155: case 0x19: {
1744 OPC_CheckPredicate, 22, // 1157: check predicate 22
1745 OPC_Decode, 152, 128, 1, 3, // 1159: decode to VLUXSEG4EI32_V using decoder 3
1746 // 1159: }
1747 26, 6, // 1164: case 0x1a: {
1748 OPC_CheckPredicate, 22, // 1166: check predicate 22
1749 OPC_Decode, 248, 127, 4, // 1168: decode to VLSSEG4E32_V using decoder 4
1750 // 1168: }
1751 27, 6, // 1172: case 0x1b: {
1752 OPC_CheckPredicate, 22, // 1174: check predicate 22
1753 OPC_Decode, 160, 127, 3, // 1176: decode to VLOXSEG4EI32_V using decoder 3
1754 // 1176: }
1755 32, 19, // 1180: case 0x20: {
1756 OPC_SwitchField, 20, 5, // 1182: switch Inst[24:20] {
1757 0, 6, // 1185: case 0x0: {
1758 OPC_CheckPredicate, 22, // 1187: check predicate 22
1759 OPC_Decode, 210, 127, 1, // 1189: decode to VLSEG5E32_V using decoder 1
1760 // 1189: }
1761 16, 0, // 1193: case 0x10: {
1762 OPC_CheckPredicate, 22, // 1195: check predicate 22
1763 OPC_Decode, 209, 127, 1, // 1197: decode to VLSEG5E32FF_V using decoder 1
1764 // 1197: }
1765 // 1197: } // switch Inst[24:20]
1766 // 1197: }
1767 33, 7, // 1201: case 0x21: {
1768 OPC_CheckPredicate, 22, // 1203: check predicate 22
1769 OPC_Decode, 156, 128, 1, 3, // 1205: decode to VLUXSEG5EI32_V using decoder 3
1770 // 1205: }
1771 34, 6, // 1210: case 0x22: {
1772 OPC_CheckPredicate, 22, // 1212: check predicate 22
1773 OPC_Decode, 252, 127, 4, // 1214: decode to VLSSEG5E32_V using decoder 4
1774 // 1214: }
1775 35, 6, // 1218: case 0x23: {
1776 OPC_CheckPredicate, 22, // 1220: check predicate 22
1777 OPC_Decode, 164, 127, 3, // 1222: decode to VLOXSEG5EI32_V using decoder 3
1778 // 1222: }
1779 40, 19, // 1226: case 0x28: {
1780 OPC_SwitchField, 20, 5, // 1228: switch Inst[24:20] {
1781 0, 6, // 1231: case 0x0: {
1782 OPC_CheckPredicate, 22, // 1233: check predicate 22
1783 OPC_Decode, 218, 127, 1, // 1235: decode to VLSEG6E32_V using decoder 1
1784 // 1235: }
1785 16, 0, // 1239: case 0x10: {
1786 OPC_CheckPredicate, 22, // 1241: check predicate 22
1787 OPC_Decode, 217, 127, 1, // 1243: decode to VLSEG6E32FF_V using decoder 1
1788 // 1243: }
1789 // 1243: } // switch Inst[24:20]
1790 // 1243: }
1791 41, 7, // 1247: case 0x29: {
1792 OPC_CheckPredicate, 22, // 1249: check predicate 22
1793 OPC_Decode, 160, 128, 1, 3, // 1251: decode to VLUXSEG6EI32_V using decoder 3
1794 // 1251: }
1795 42, 7, // 1256: case 0x2a: {
1796 OPC_CheckPredicate, 22, // 1258: check predicate 22
1797 OPC_Decode, 128, 128, 1, 4, // 1260: decode to VLSSEG6E32_V using decoder 4
1798 // 1260: }
1799 43, 6, // 1265: case 0x2b: {
1800 OPC_CheckPredicate, 22, // 1267: check predicate 22
1801 OPC_Decode, 168, 127, 3, // 1269: decode to VLOXSEG6EI32_V using decoder 3
1802 // 1269: }
1803 48, 19, // 1273: case 0x30: {
1804 OPC_SwitchField, 20, 5, // 1275: switch Inst[24:20] {
1805 0, 6, // 1278: case 0x0: {
1806 OPC_CheckPredicate, 22, // 1280: check predicate 22
1807 OPC_Decode, 226, 127, 1, // 1282: decode to VLSEG7E32_V using decoder 1
1808 // 1282: }
1809 16, 0, // 1286: case 0x10: {
1810 OPC_CheckPredicate, 22, // 1288: check predicate 22
1811 OPC_Decode, 225, 127, 1, // 1290: decode to VLSEG7E32FF_V using decoder 1
1812 // 1290: }
1813 // 1290: } // switch Inst[24:20]
1814 // 1290: }
1815 49, 7, // 1294: case 0x31: {
1816 OPC_CheckPredicate, 22, // 1296: check predicate 22
1817 OPC_Decode, 164, 128, 1, 3, // 1298: decode to VLUXSEG7EI32_V using decoder 3
1818 // 1298: }
1819 50, 7, // 1303: case 0x32: {
1820 OPC_CheckPredicate, 22, // 1305: check predicate 22
1821 OPC_Decode, 132, 128, 1, 4, // 1307: decode to VLSSEG7E32_V using decoder 4
1822 // 1307: }
1823 51, 6, // 1312: case 0x33: {
1824 OPC_CheckPredicate, 22, // 1314: check predicate 22
1825 OPC_Decode, 172, 127, 3, // 1316: decode to VLOXSEG7EI32_V using decoder 3
1826 // 1316: }
1827 56, 31, // 1320: case 0x38: {
1828 OPC_SwitchField, 20, 5, // 1322: switch Inst[24:20] {
1829 0, 6, // 1325: case 0x0: {
1830 OPC_CheckPredicate, 22, // 1327: check predicate 22
1831 OPC_Decode, 234, 127, 1, // 1329: decode to VLSEG8E32_V using decoder 1
1832 // 1329: }
1833 8, 10, // 1333: case 0x8: {
1834 OPC_CheckPredicate, 22, // 1335: check predicate 22
1835 OPC_CheckField, 25, 1, 1, // 1337: check Inst[25] == 0x1
1836 OPC_Decode, 135, 127, 7, // 1341: decode to VL8RE32_V using decoder 7
1837 // 1341: }
1838 16, 0, // 1345: case 0x10: {
1839 OPC_CheckPredicate, 22, // 1347: check predicate 22
1840 OPC_Decode, 233, 127, 1, // 1349: decode to VLSEG8E32FF_V using decoder 1
1841 // 1349: }
1842 // 1349: } // switch Inst[24:20]
1843 // 1349: }
1844 57, 7, // 1353: case 0x39: {
1845 OPC_CheckPredicate, 22, // 1355: check predicate 22
1846 OPC_Decode, 168, 128, 1, 3, // 1357: decode to VLUXSEG8EI32_V using decoder 3
1847 // 1357: }
1848 58, 7, // 1362: case 0x3a: {
1849 OPC_CheckPredicate, 22, // 1364: check predicate 22
1850 OPC_Decode, 136, 128, 1, 4, // 1366: decode to VLSSEG8E32_V using decoder 4
1851 // 1366: }
1852 59, 0, // 1371: case 0x3b: {
1853 OPC_CheckPredicate, 22, // 1373: check predicate 22
1854 OPC_Decode, 176, 127, 3, // 1375: decode to VLOXSEG8EI32_V using decoder 3
1855 // 1375: }
1856 // 1375: } // switch Inst[31:26]
1857 // 1375: }
1858 7, 0, // 1379: case 0x7: {
1859 OPC_SwitchField, 26, 3, // 1381: switch Inst[28:26] {
1860 0, 219, 1, // 1384: case 0x0: {
1861 OPC_SwitchField, 29, 3, // 1387: switch Inst[31:29] {
1862 0, 31, // 1390: case 0x0: {
1863 OPC_SwitchField, 20, 5, // 1392: switch Inst[24:20] {
1864 0, 6, // 1395: case 0x0: {
1865 OPC_CheckPredicate, 27, // 1397: check predicate 27
1866 OPC_Decode, 143, 127, 1, // 1399: decode to VLE64_V using decoder 1
1867 // 1399: }
1868 8, 10, // 1403: case 0x8: {
1869 OPC_CheckPredicate, 27, // 1405: check predicate 27
1870 OPC_CheckField, 25, 1, 1, // 1407: check Inst[25] == 0x1
1871 OPC_Decode, 252, 126, 2, // 1411: decode to VL1RE64_V using decoder 2
1872 // 1411: }
1873 16, 0, // 1415: case 0x10: {
1874 OPC_CheckPredicate, 27, // 1417: check predicate 27
1875 OPC_Decode, 142, 127, 1, // 1419: decode to VLE64FF_V using decoder 1
1876 // 1419: }
1877 // 1419: } // switch Inst[24:20]
1878 // 1419: }
1879 1, 31, // 1423: case 0x1: {
1880 OPC_SwitchField, 20, 5, // 1425: switch Inst[24:20] {
1881 0, 6, // 1428: case 0x0: {
1882 OPC_CheckPredicate, 27, // 1430: check predicate 27
1883 OPC_Decode, 188, 127, 1, // 1432: decode to VLSEG2E64_V using decoder 1
1884 // 1432: }
1885 8, 10, // 1436: case 0x8: {
1886 OPC_CheckPredicate, 27, // 1438: check predicate 27
1887 OPC_CheckField, 25, 1, 1, // 1440: check Inst[25] == 0x1
1888 OPC_Decode, 128, 127, 5, // 1444: decode to VL2RE64_V using decoder 5
1889 // 1444: }
1890 16, 0, // 1448: case 0x10: {
1891 OPC_CheckPredicate, 27, // 1450: check predicate 27
1892 OPC_Decode, 187, 127, 1, // 1452: decode to VLSEG2E64FF_V using decoder 1
1893 // 1452: }
1894 // 1452: } // switch Inst[24:20]
1895 // 1452: }
1896 2, 19, // 1456: case 0x2: {
1897 OPC_SwitchField, 20, 5, // 1458: switch Inst[24:20] {
1898 0, 6, // 1461: case 0x0: {
1899 OPC_CheckPredicate, 27, // 1463: check predicate 27
1900 OPC_Decode, 196, 127, 1, // 1465: decode to VLSEG3E64_V using decoder 1
1901 // 1465: }
1902 16, 0, // 1469: case 0x10: {
1903 OPC_CheckPredicate, 27, // 1471: check predicate 27
1904 OPC_Decode, 195, 127, 1, // 1473: decode to VLSEG3E64FF_V using decoder 1
1905 // 1473: }
1906 // 1473: } // switch Inst[24:20]
1907 // 1473: }
1908 3, 31, // 1477: case 0x3: {
1909 OPC_SwitchField, 20, 5, // 1479: switch Inst[24:20] {
1910 0, 6, // 1482: case 0x0: {
1911 OPC_CheckPredicate, 27, // 1484: check predicate 27
1912 OPC_Decode, 204, 127, 1, // 1486: decode to VLSEG4E64_V using decoder 1
1913 // 1486: }
1914 8, 10, // 1490: case 0x8: {
1915 OPC_CheckPredicate, 27, // 1492: check predicate 27
1916 OPC_CheckField, 25, 1, 1, // 1494: check Inst[25] == 0x1
1917 OPC_Decode, 132, 127, 6, // 1498: decode to VL4RE64_V using decoder 6
1918 // 1498: }
1919 16, 0, // 1502: case 0x10: {
1920 OPC_CheckPredicate, 27, // 1504: check predicate 27
1921 OPC_Decode, 203, 127, 1, // 1506: decode to VLSEG4E64FF_V using decoder 1
1922 // 1506: }
1923 // 1506: } // switch Inst[24:20]
1924 // 1506: }
1925 4, 19, // 1510: case 0x4: {
1926 OPC_SwitchField, 20, 5, // 1512: switch Inst[24:20] {
1927 0, 6, // 1515: case 0x0: {
1928 OPC_CheckPredicate, 27, // 1517: check predicate 27
1929 OPC_Decode, 212, 127, 1, // 1519: decode to VLSEG5E64_V using decoder 1
1930 // 1519: }
1931 16, 0, // 1523: case 0x10: {
1932 OPC_CheckPredicate, 27, // 1525: check predicate 27
1933 OPC_Decode, 211, 127, 1, // 1527: decode to VLSEG5E64FF_V using decoder 1
1934 // 1527: }
1935 // 1527: } // switch Inst[24:20]
1936 // 1527: }
1937 5, 19, // 1531: case 0x5: {
1938 OPC_SwitchField, 20, 5, // 1533: switch Inst[24:20] {
1939 0, 6, // 1536: case 0x0: {
1940 OPC_CheckPredicate, 27, // 1538: check predicate 27
1941 OPC_Decode, 220, 127, 1, // 1540: decode to VLSEG6E64_V using decoder 1
1942 // 1540: }
1943 16, 0, // 1544: case 0x10: {
1944 OPC_CheckPredicate, 27, // 1546: check predicate 27
1945 OPC_Decode, 219, 127, 1, // 1548: decode to VLSEG6E64FF_V using decoder 1
1946 // 1548: }
1947 // 1548: } // switch Inst[24:20]
1948 // 1548: }
1949 6, 19, // 1552: case 0x6: {
1950 OPC_SwitchField, 20, 5, // 1554: switch Inst[24:20] {
1951 0, 6, // 1557: case 0x0: {
1952 OPC_CheckPredicate, 27, // 1559: check predicate 27
1953 OPC_Decode, 228, 127, 1, // 1561: decode to VLSEG7E64_V using decoder 1
1954 // 1561: }
1955 16, 0, // 1565: case 0x10: {
1956 OPC_CheckPredicate, 27, // 1567: check predicate 27
1957 OPC_Decode, 227, 127, 1, // 1569: decode to VLSEG7E64FF_V using decoder 1
1958 // 1569: }
1959 // 1569: } // switch Inst[24:20]
1960 // 1569: }
1961 7, 0, // 1573: case 0x7: {
1962 OPC_SwitchField, 20, 5, // 1575: switch Inst[24:20] {
1963 0, 6, // 1578: case 0x0: {
1964 OPC_CheckPredicate, 27, // 1580: check predicate 27
1965 OPC_Decode, 236, 127, 1, // 1582: decode to VLSEG8E64_V using decoder 1
1966 // 1582: }
1967 8, 10, // 1586: case 0x8: {
1968 OPC_CheckPredicate, 27, // 1588: check predicate 27
1969 OPC_CheckField, 25, 1, 1, // 1590: check Inst[25] == 0x1
1970 OPC_Decode, 136, 127, 7, // 1594: decode to VL8RE64_V using decoder 7
1971 // 1594: }
1972 16, 0, // 1598: case 0x10: {
1973 OPC_CheckPredicate, 27, // 1600: check predicate 27
1974 OPC_Decode, 235, 127, 1, // 1602: decode to VLSEG8E64FF_V using decoder 1
1975 // 1602: }
1976 // 1602: } // switch Inst[24:20]
1977 // 1602: }
1978 // 1602: } // switch Inst[31:29]
1979 // 1602: }
1980 1, 75, // 1606: case 0x1: {
1981 OPC_SwitchField, 29, 3, // 1608: switch Inst[31:29] {
1982 0, 7, // 1611: case 0x0: {
1983 OPC_CheckPredicate, 28, // 1613: check predicate 28
1984 OPC_Decode, 141, 128, 1, 3, // 1615: decode to VLUXEI64_V using decoder 3
1985 // 1615: }
1986 1, 7, // 1620: case 0x1: {
1987 OPC_CheckPredicate, 29, // 1622: check predicate 29
1988 OPC_Decode, 145, 128, 1, 3, // 1624: decode to VLUXSEG2EI64_V using decoder 3
1989 // 1624: }
1990 2, 7, // 1629: case 0x2: {
1991 OPC_CheckPredicate, 29, // 1631: check predicate 29
1992 OPC_Decode, 149, 128, 1, 3, // 1633: decode to VLUXSEG3EI64_V using decoder 3
1993 // 1633: }
1994 3, 7, // 1638: case 0x3: {
1995 OPC_CheckPredicate, 29, // 1640: check predicate 29
1996 OPC_Decode, 153, 128, 1, 3, // 1642: decode to VLUXSEG4EI64_V using decoder 3
1997 // 1642: }
1998 4, 7, // 1647: case 0x4: {
1999 OPC_CheckPredicate, 29, // 1649: check predicate 29
2000 OPC_Decode, 157, 128, 1, 3, // 1651: decode to VLUXSEG5EI64_V using decoder 3
2001 // 1651: }
2002 5, 7, // 1656: case 0x5: {
2003 OPC_CheckPredicate, 29, // 1658: check predicate 29
2004 OPC_Decode, 161, 128, 1, 3, // 1660: decode to VLUXSEG6EI64_V using decoder 3
2005 // 1660: }
2006 6, 7, // 1665: case 0x6: {
2007 OPC_CheckPredicate, 29, // 1667: check predicate 29
2008 OPC_Decode, 165, 128, 1, 3, // 1669: decode to VLUXSEG7EI64_V using decoder 3
2009 // 1669: }
2010 7, 0, // 1674: case 0x7: {
2011 OPC_CheckPredicate, 29, // 1676: check predicate 29
2012 OPC_Decode, 169, 128, 1, 3, // 1678: decode to VLUXSEG8EI64_V using decoder 3
2013 // 1678: }
2014 // 1678: } // switch Inst[31:29]
2015 // 1678: }
2016 2, 70, // 1683: case 0x2: {
2017 OPC_SwitchField, 29, 3, // 1685: switch Inst[31:29] {
2018 0, 6, // 1688: case 0x0: {
2019 OPC_CheckPredicate, 27, // 1690: check predicate 27
2020 OPC_Decode, 181, 127, 4, // 1692: decode to VLSE64_V using decoder 4
2021 // 1692: }
2022 1, 6, // 1696: case 0x1: {
2023 OPC_CheckPredicate, 27, // 1698: check predicate 27
2024 OPC_Decode, 241, 127, 4, // 1700: decode to VLSSEG2E64_V using decoder 4
2025 // 1700: }
2026 2, 6, // 1704: case 0x2: {
2027 OPC_CheckPredicate, 27, // 1706: check predicate 27
2028 OPC_Decode, 245, 127, 4, // 1708: decode to VLSSEG3E64_V using decoder 4
2029 // 1708: }
2030 3, 6, // 1712: case 0x3: {
2031 OPC_CheckPredicate, 27, // 1714: check predicate 27
2032 OPC_Decode, 249, 127, 4, // 1716: decode to VLSSEG4E64_V using decoder 4
2033 // 1716: }
2034 4, 6, // 1720: case 0x4: {
2035 OPC_CheckPredicate, 27, // 1722: check predicate 27
2036 OPC_Decode, 253, 127, 4, // 1724: decode to VLSSEG5E64_V using decoder 4
2037 // 1724: }
2038 5, 7, // 1728: case 0x5: {
2039 OPC_CheckPredicate, 27, // 1730: check predicate 27
2040 OPC_Decode, 129, 128, 1, 4, // 1732: decode to VLSSEG6E64_V using decoder 4
2041 // 1732: }
2042 6, 7, // 1737: case 0x6: {
2043 OPC_CheckPredicate, 27, // 1739: check predicate 27
2044 OPC_Decode, 133, 128, 1, 4, // 1741: decode to VLSSEG7E64_V using decoder 4
2045 // 1741: }
2046 7, 0, // 1746: case 0x7: {
2047 OPC_CheckPredicate, 27, // 1748: check predicate 27
2048 OPC_Decode, 137, 128, 1, 4, // 1750: decode to VLSSEG8E64_V using decoder 4
2049 // 1750: }
2050 // 1750: } // switch Inst[31:29]
2051 // 1750: }
2052 3, 67, // 1755: case 0x3: {
2053 OPC_SwitchField, 29, 3, // 1757: switch Inst[31:29] {
2054 0, 6, // 1760: case 0x0: {
2055 OPC_CheckPredicate, 28, // 1762: check predicate 28
2056 OPC_Decode, 149, 127, 3, // 1764: decode to VLOXEI64_V using decoder 3
2057 // 1764: }
2058 1, 6, // 1768: case 0x1: {
2059 OPC_CheckPredicate, 29, // 1770: check predicate 29
2060 OPC_Decode, 153, 127, 3, // 1772: decode to VLOXSEG2EI64_V using decoder 3
2061 // 1772: }
2062 2, 6, // 1776: case 0x2: {
2063 OPC_CheckPredicate, 29, // 1778: check predicate 29
2064 OPC_Decode, 157, 127, 3, // 1780: decode to VLOXSEG3EI64_V using decoder 3
2065 // 1780: }
2066 3, 6, // 1784: case 0x3: {
2067 OPC_CheckPredicate, 29, // 1786: check predicate 29
2068 OPC_Decode, 161, 127, 3, // 1788: decode to VLOXSEG4EI64_V using decoder 3
2069 // 1788: }
2070 4, 6, // 1792: case 0x4: {
2071 OPC_CheckPredicate, 29, // 1794: check predicate 29
2072 OPC_Decode, 165, 127, 3, // 1796: decode to VLOXSEG5EI64_V using decoder 3
2073 // 1796: }
2074 5, 6, // 1800: case 0x5: {
2075 OPC_CheckPredicate, 29, // 1802: check predicate 29
2076 OPC_Decode, 169, 127, 3, // 1804: decode to VLOXSEG6EI64_V using decoder 3
2077 // 1804: }
2078 6, 6, // 1808: case 0x6: {
2079 OPC_CheckPredicate, 29, // 1810: check predicate 29
2080 OPC_Decode, 173, 127, 3, // 1812: decode to VLOXSEG7EI64_V using decoder 3
2081 // 1812: }
2082 7, 0, // 1816: case 0x7: {
2083 OPC_CheckPredicate, 29, // 1818: check predicate 29
2084 OPC_Decode, 177, 127, 3, // 1820: decode to VLOXSEG8EI64_V using decoder 3
2085 // 1820: }
2086 // 1820: } // switch Inst[31:29]
2087 // 1820: }
2088 4, 7, // 1824: case 0x4: {
2089 OPC_CheckPredicate, 30, // 1826: check predicate 30
2090 OPC_Decode, 236, 128, 1, 12, // 1828: decode to VMTL_V using decoder 12
2091 // 1828: }
2092 5, 0, // 1833: case 0x5: {
2093 OPC_CheckPredicate, 31, // 1835: check predicate 31
2094 OPC_Decode, 238, 128, 1, 12, // 1837: decode to VMTTL_V using decoder 12
2095 // 1837: }
2096 // 1837: } // switch Inst[28:26]
2097 // 1837: }
2098 // 1837: } // switch Inst[14:12]
2099 // 1837: }
2100 15, 76, // 1842: case 0xf: {
2101 OPC_SwitchField, 7, 8, // 1844: switch Inst[14:7] {
2102 0, 24, // 1847: case 0x0: {
2103 OPC_SwitchField, 28, 4, // 1849: switch Inst[31:28] {
2104 0, 8, // 1852: case 0x0: {
2105 OPC_CheckField, 15, 5, 0, // 1854: check Inst[19:15] == 0x0
2106 OPC_Decode, 215, 114, 13, // 1858: decode to FENCE using decoder 13
2107 // 1858: }
2108 8, 0, // 1862: case 0x8: {
2109 OPC_CheckField, 15, 13, 224, 12, // 1864: check Inst[27:15] == 0x660
2110 OPC_Decode, 217, 114, 14, // 1869: decode to FENCE_TSO using decoder 14
2111 // 1869: }
2112 // 1869: } // switch Inst[31:28]
2113 // 1869: }
2114 32, 8, // 1873: case 0x20: {
2115 OPC_CheckField, 15, 17, 0, // 1875: check Inst[31:15] == 0x0
2116 OPC_Decode, 216, 114, 14, // 1879: decode to FENCE_I using decoder 14
2117 // 1879: }
2118 64, 0, // 1883: case 0x40: {
2119 OPC_SwitchField, 20, 12, // 1885: switch Inst[31:20] {
2120 0, 6, // 1888: case 0x0: {
2121 OPC_CheckPredicate, 32, // 1890: check predicate 32
2122 OPC_Decode, 198, 110, 15, // 1892: decode to CBO_INVAL using decoder 15
2123 // 1892: }
2124 1, 6, // 1896: case 0x1: {
2125 OPC_CheckPredicate, 32, // 1898: check predicate 32
2126 OPC_Decode, 196, 110, 15, // 1900: decode to CBO_CLEAN using decoder 15
2127 // 1900: }
2128 2, 6, // 1904: case 0x2: {
2129 OPC_CheckPredicate, 32, // 1906: check predicate 32
2130 OPC_Decode, 197, 110, 15, // 1908: decode to CBO_FLUSH using decoder 15
2131 // 1908: }
2132 4, 0, // 1912: case 0x4: {
2133 OPC_CheckPredicate, 33, // 1914: check predicate 33
2134 OPC_Decode, 199, 110, 15, // 1916: decode to CBO_ZERO using decoder 15
2135 // 1916: }
2136 // 1916: } // switch Inst[31:20]
2137 // 1916: }
2138 // 1916: } // switch Inst[14:7]
2139 // 1916: }
2140 19, 149, 3, // 1920: case 0x13: {
2141 OPC_SwitchField, 12, 3, // 1923: switch Inst[14:12] {
2142 0, 4, // 1926: case 0x0: {
2143 OPC_Decode, 161, 107, 0, // 1928: decode to ADDI using decoder 0
2144 // 1928: }
2145 1, 217, 1, // 1932: case 0x1: {
2146 OPC_SwitchField, 26, 6, // 1935: switch Inst[31:26] {
2147 0, 4, // 1938: case 0x0: {
2148 OPC_Decode, 143, 124, 16, // 1940: decode to SLLI using decoder 16
2149 // 1940: }
2150 2, 11, // 1944: case 0x2: {
2151 OPC_CheckPredicate, 34, // 1946: check predicate 34
2152 OPC_CheckField, 20, 6, 15, // 1948: check Inst[25:20] == 0xf
2153 OPC_Decode, 210, 131, 1, 17, // 1952: decode to ZIP_RV32 using decoder 17
2154 // 1952: }
2155 4, 83, // 1957: case 0x4: {
2156 OPC_SwitchField, 20, 6, // 1959: switch Inst[25:20] {
2157 0, 6, // 1962: case 0x0: {
2158 OPC_CheckPredicate, 35, // 1964: check predicate 35
2159 OPC_Decode, 251, 123, 17, // 1966: decode to SHA256SUM0 using decoder 17
2160 // 1966: }
2161 1, 6, // 1970: case 0x1: {
2162 OPC_CheckPredicate, 35, // 1972: check predicate 35
2163 OPC_Decode, 252, 123, 17, // 1974: decode to SHA256SUM1 using decoder 17
2164 // 1974: }
2165 2, 6, // 1978: case 0x2: {
2166 OPC_CheckPredicate, 35, // 1980: check predicate 35
2167 OPC_Decode, 249, 123, 17, // 1982: decode to SHA256SIG0 using decoder 17
2168 // 1982: }
2169 3, 6, // 1986: case 0x3: {
2170 OPC_CheckPredicate, 35, // 1988: check predicate 35
2171 OPC_Decode, 250, 123, 17, // 1990: decode to SHA256SIG1 using decoder 17
2172 // 1990: }
2173 4, 6, // 1994: case 0x4: {
2174 OPC_CheckPredicate, 36, // 1996: check predicate 36
2175 OPC_Decode, 131, 124, 17, // 1998: decode to SHA512SUM0 using decoder 17
2176 // 1998: }
2177 5, 6, // 2002: case 0x5: {
2178 OPC_CheckPredicate, 36, // 2004: check predicate 36
2179 OPC_Decode, 133, 124, 17, // 2006: decode to SHA512SUM1 using decoder 17
2180 // 2006: }
2181 6, 6, // 2010: case 0x6: {
2182 OPC_CheckPredicate, 36, // 2012: check predicate 36
2183 OPC_Decode, 253, 123, 17, // 2014: decode to SHA512SIG0 using decoder 17
2184 // 2014: }
2185 7, 6, // 2018: case 0x7: {
2186 OPC_CheckPredicate, 36, // 2020: check predicate 36
2187 OPC_Decode, 128, 124, 17, // 2022: decode to SHA512SIG1 using decoder 17
2188 // 2022: }
2189 8, 6, // 2026: case 0x8: {
2190 OPC_CheckPredicate, 37, // 2028: check predicate 37
2191 OPC_Decode, 152, 124, 17, // 2030: decode to SM3P0 using decoder 17
2192 // 2030: }
2193 9, 0, // 2034: case 0x9: {
2194 OPC_CheckPredicate, 37, // 2036: check predicate 37
2195 OPC_Decode, 153, 124, 17, // 2038: decode to SM3P1 using decoder 17
2196 // 2038: }
2197 // 2038: } // switch Inst[25:20]
2198 // 2038: }
2199 10, 6, // 2042: case 0xa: {
2200 OPC_CheckPredicate, 38, // 2044: check predicate 38
2201 OPC_Decode, 195, 110, 16, // 2046: decode to BSETI using decoder 16
2202 // 2046: }
2203 12, 23, // 2050: case 0xc: {
2204 OPC_SwitchField, 24, 2, // 2052: switch Inst[25:24] {
2205 0, 10, // 2055: case 0x0: {
2206 OPC_CheckPredicate, 39, // 2057: check predicate 39
2207 OPC_CheckField, 20, 4, 0, // 2059: check Inst[23:20] == 0x0
2208 OPC_Decode, 173, 107, 17, // 2063: decode to AES64IM using decoder 17
2209 // 2063: }
2210 1, 0, // 2067: case 0x1: {
2211 OPC_CheckPredicate, 40, // 2069: check predicate 40
2212 OPC_Decode, 174, 107, 18, // 2071: decode to AES64KS1I using decoder 18
2213 // 2071: }
2214 // 2071: } // switch Inst[25:24]
2215 // 2071: }
2216 18, 6, // 2075: case 0x12: {
2217 OPC_CheckPredicate, 38, // 2077: check predicate 38
2218 OPC_Decode, 180, 110, 16, // 2079: decode to BCLRI using decoder 16
2219 // 2079: }
2220 24, 59, // 2083: case 0x18: {
2221 OPC_SwitchField, 20, 6, // 2085: switch Inst[25:20] {
2222 0, 6, // 2088: case 0x0: {
2223 OPC_CheckPredicate, 41, // 2090: check predicate 41
2224 OPC_Decode, 205, 110, 17, // 2092: decode to CLZ using decoder 17
2225 // 2092: }
2226 1, 6, // 2096: case 0x1: {
2227 OPC_CheckPredicate, 41, // 2098: check predicate 41
2228 OPC_Decode, 223, 110, 17, // 2100: decode to CTZ using decoder 17
2229 // 2100: }
2230 2, 6, // 2104: case 0x2: {
2231 OPC_CheckPredicate, 41, // 2106: check predicate 41
2232 OPC_Decode, 215, 110, 17, // 2108: decode to CPOP using decoder 17
2233 // 2108: }
2234 3, 6, // 2112: case 0x3: {
2235 OPC_CheckPredicate, 42, // 2114: check predicate 42
2236 OPC_Decode, 203, 110, 17, // 2116: decode to CLS using decoder 17
2237 // 2116: }
2238 4, 6, // 2120: case 0x4: {
2239 OPC_CheckPredicate, 41, // 2122: check predicate 41
2240 OPC_Decode, 168, 123, 17, // 2124: decode to SEXT_B using decoder 17
2241 // 2124: }
2242 5, 6, // 2128: case 0x5: {
2243 OPC_CheckPredicate, 41, // 2130: check predicate 41
2244 OPC_Decode, 169, 123, 17, // 2132: decode to SEXT_H using decoder 17
2245 // 2132: }
2246 7, 0, // 2136: case 0x7: {
2247 OPC_CheckPredicate, 42, // 2138: check predicate 42
2248 OPC_Decode, 157, 107, 17, // 2140: decode to ABS using decoder 17
2249 // 2140: }
2250 // 2140: } // switch Inst[25:20]
2251 // 2140: }
2252 26, 0, // 2144: case 0x1a: {
2253 OPC_CheckPredicate, 38, // 2146: check predicate 38
2254 OPC_Decode, 188, 110, 16, // 2148: decode to BINVI using decoder 16
2255 // 2148: }
2256 // 2148: } // switch Inst[31:26]
2257 // 2148: }
2258 2, 4, // 2152: case 0x2: {
2259 OPC_Decode, 148, 124, 0, // 2154: decode to SLTI using decoder 0
2260 // 2154: }
2261 3, 4, // 2158: case 0x3: {
2262 OPC_Decode, 149, 124, 0, // 2160: decode to SLTIU using decoder 0
2263 // 2160: }
2264 4, 5, // 2164: case 0x4: {
2265 OPC_Decode, 182, 131, 1, 0, // 2166: decode to XORI using decoder 0
2266 // 2166: }
2267 5, 108, // 2171: case 0x5: {
2268 OPC_SwitchField, 26, 6, // 2173: switch Inst[31:26] {
2269 0, 4, // 2176: case 0x0: {
2270 OPC_Decode, 180, 124, 16, // 2178: decode to SRLI using decoder 16
2271 // 2178: }
2272 2, 10, // 2182: case 0x2: {
2273 OPC_CheckPredicate, 34, // 2184: check predicate 34
2274 OPC_CheckField, 20, 6, 15, // 2186: check Inst[25:20] == 0xf
2275 OPC_Decode, 197, 125, 17, // 2190: decode to UNZIP_RV32 using decoder 17
2276 // 2190: }
2277 10, 10, // 2194: case 0xa: {
2278 OPC_CheckPredicate, 41, // 2196: check predicate 41
2279 OPC_CheckField, 20, 6, 7, // 2198: check Inst[25:20] == 0x7
2280 OPC_Decode, 139, 118, 17, // 2202: decode to ORC_B using decoder 17
2281 // 2202: }
2282 16, 4, // 2206: case 0x10: {
2283 OPC_Decode, 173, 124, 16, // 2208: decode to SRAI using decoder 16
2284 // 2208: }
2285 18, 6, // 2212: case 0x12: {
2286 OPC_CheckPredicate, 38, // 2214: check predicate 38
2287 OPC_Decode, 184, 110, 16, // 2216: decode to BEXTI using decoder 16
2288 // 2216: }
2289 24, 6, // 2220: case 0x18: {
2290 OPC_CheckPredicate, 43, // 2222: check predicate 43
2291 OPC_Decode, 145, 123, 16, // 2224: decode to RORI using decoder 16
2292 // 2224: }
2293 26, 0, // 2228: case 0x1a: {
2294 OPC_SwitchField, 20, 6, // 2230: switch Inst[25:20] {
2295 7, 6, // 2233: case 0x7: {
2296 OPC_CheckPredicate, 44, // 2235: check predicate 44
2297 OPC_Decode, 193, 110, 17, // 2237: decode to BREV8 using decoder 17
2298 // 2237: }
2299 24, 6, // 2241: case 0x18: {
2300 OPC_CheckPredicate, 45, // 2243: check predicate 45
2301 OPC_Decode, 138, 123, 17, // 2245: decode to REV8_RV32 using decoder 17
2302 // 2245: }
2303 31, 6, // 2249: case 0x1f: {
2304 OPC_CheckPredicate, 46, // 2251: check predicate 46
2305 OPC_Decode, 140, 123, 17, // 2253: decode to REV_RV32 using decoder 17
2306 // 2253: }
2307 48, 6, // 2257: case 0x30: {
2308 OPC_CheckPredicate, 47, // 2259: check predicate 47
2309 OPC_Decode, 137, 123, 17, // 2261: decode to REV16_RV64 using decoder 17
2310 // 2261: }
2311 56, 6, // 2265: case 0x38: {
2312 OPC_CheckPredicate, 48, // 2267: check predicate 48
2313 OPC_Decode, 139, 123, 17, // 2269: decode to REV8_RV64 using decoder 17
2314 // 2269: }
2315 63, 0, // 2273: case 0x3f: {
2316 OPC_CheckPredicate, 47, // 2275: check predicate 47
2317 OPC_Decode, 141, 123, 17, // 2277: decode to REV_RV64 using decoder 17
2318 // 2277: }
2319 // 2277: } // switch Inst[25:20]
2320 // 2277: }
2321 // 2277: } // switch Inst[31:26]
2322 // 2277: }
2323 6, 39, // 2281: case 0x6: {
2324 OPC_Scope, 33, // 2283: try {
2325 OPC_SwitchField, 20, 5, // 2285: switch Inst[24:20] {
2326 0, 8, // 2288: case 0x0: {
2327 OPC_CheckField, 7, 5, 0, // 2290: check Inst[11:7] == 0x0
2328 OPC_Decode, 192, 120, 19, // 2294: decode to PREFETCH_I using decoder 19
2329 // 2294: }
2330 1, 8, // 2298: case 0x1: {
2331 OPC_CheckField, 7, 5, 0, // 2300: check Inst[11:7] == 0x0
2332 OPC_Decode, 193, 120, 19, // 2304: decode to PREFETCH_R using decoder 19
2333 // 2304: }
2334 3, 0, // 2308: case 0x3: {
2335 OPC_CheckField, 7, 5, 0, // 2310: check Inst[11:7] == 0x0
2336 OPC_Decode, 194, 120, 19, // 2314: decode to PREFETCH_W using decoder 19
2337 // 2314: }
2338 // 2314: } // switch Inst[24:20]
2339 // 2314: } else try {
2340 OPC_Decode, 140, 118, 0, // 2318: decode to ORI using decoder 0
2341 // 2318: }
2342 // 2318: }
2343 7, 0, // 2322: case 0x7: {
2344 OPC_Decode, 174, 110, 0, // 2324: decode to ANDI using decoder 0
2345 // 2324: }
2346 // 2324: } // switch Inst[14:12]
2347 // 2324: }
2348 23, 4, // 2328: case 0x17: {
2349 OPC_Decode, 178, 110, 20, // 2330: decode to AUIPC using decoder 20
2350 // 2330: }
2351 27, 195, 35, // 2334: case 0x1b: {
2352 OPC_SwitchField, 12, 3, // 2337: switch Inst[14:12] {
2353 0, 6, // 2340: case 0x0: {
2354 OPC_CheckPredicate, 21, // 2342: check predicate 21
2355 OPC_Decode, 162, 107, 0, // 2344: decode to ADDIW using decoder 0
2356 // 2344: }
2357 1, 68, // 2348: case 0x1: {
2358 OPC_SwitchField, 26, 6, // 2350: switch Inst[31:26] {
2359 0, 10, // 2353: case 0x0: {
2360 OPC_CheckPredicate, 21, // 2355: check predicate 21
2361 OPC_CheckField, 25, 1, 0, // 2357: check Inst[25] == 0x0
2362 OPC_Decode, 144, 124, 21, // 2361: decode to SLLIW using decoder 21
2363 // 2361: }
2364 2, 6, // 2365: case 0x2: {
2365 OPC_CheckPredicate, 49, // 2367: check predicate 49
2366 OPC_Decode, 145, 124, 16, // 2369: decode to SLLI_UW using decoder 16
2367 // 2369: }
2368 24, 0, // 2373: case 0x18: {
2369 OPC_SwitchField, 20, 6, // 2375: switch Inst[25:20] {
2370 0, 6, // 2378: case 0x0: {
2371 OPC_CheckPredicate, 50, // 2380: check predicate 50
2372 OPC_Decode, 206, 110, 17, // 2382: decode to CLZW using decoder 17
2373 // 2382: }
2374 1, 6, // 2386: case 0x1: {
2375 OPC_CheckPredicate, 50, // 2388: check predicate 50
2376 OPC_Decode, 224, 110, 17, // 2390: decode to CTZW using decoder 17
2377 // 2390: }
2378 2, 6, // 2394: case 0x2: {
2379 OPC_CheckPredicate, 50, // 2396: check predicate 50
2380 OPC_Decode, 216, 110, 17, // 2398: decode to CPOPW using decoder 17
2381 // 2398: }
2382 3, 6, // 2402: case 0x3: {
2383 OPC_CheckPredicate, 47, // 2404: check predicate 47
2384 OPC_Decode, 204, 110, 17, // 2406: decode to CLSW using decoder 17
2385 // 2406: }
2386 7, 0, // 2410: case 0x7: {
2387 OPC_CheckPredicate, 47, // 2412: check predicate 47
2388 OPC_Decode, 158, 107, 17, // 2414: decode to ABSW using decoder 17
2389 // 2414: }
2390 // 2414: } // switch Inst[25:20]
2391 // 2414: }
2392 // 2414: } // switch Inst[31:26]
2393 // 2414: }
2394 2, 209, 10, // 2418: case 0x2: {
2395 OPC_SwitchField, 26, 6, // 2421: switch Inst[31:26] {
2396 0, 50, // 2424: case 0x0: {
2397 OPC_SwitchField, 7, 1, // 2426: switch Inst[7] {
2398 0, 23, // 2429: case 0x0: {
2399 OPC_SwitchField, 25, 1, // 2431: switch Inst[25] {
2400 0, 10, // 2434: case 0x0: {
2401 OPC_CheckPredicate, 46, // 2436: check predicate 46
2402 OPC_CheckField, 24, 1, 1, // 2438: check Inst[24] == 0x1
2403 OPC_Decode, 213, 121, 22, // 2442: decode to PWSLLI_B using decoder 22
2404 // 2442: }
2405 1, 0, // 2446: case 0x1: {
2406 OPC_CheckPredicate, 46, // 2448: check predicate 46
2407 OPC_Decode, 214, 121, 23, // 2450: decode to PWSLLI_H using decoder 23
2408 // 2450: }
2409 // 2450: } // switch Inst[25]
2410 // 2450: }
2411 1, 0, // 2454: case 0x1: {
2412 OPC_SwitchField, 25, 1, // 2456: switch Inst[25] {
2413 0, 6, // 2459: case 0x0: {
2414 OPC_CheckPredicate, 46, // 2461: check predicate 46
2415 OPC_Decode, 199, 121, 24, // 2463: decode to PWADD_H using decoder 24
2416 // 2463: }
2417 1, 0, // 2467: case 0x1: {
2418 OPC_CheckPredicate, 46, // 2469: check predicate 46
2419 OPC_Decode, 157, 131, 1, 24, // 2471: decode to WADD using decoder 24
2420 // 2471: }
2421 // 2471: } // switch Inst[25]
2422 // 2471: }
2423 // 2471: } // switch Inst[7]
2424 // 2471: }
2425 1, 33, // 2476: case 0x1: {
2426 OPC_SwitchField, 7, 1, // 2478: switch Inst[7] {
2427 0, 7, // 2481: case 0x0: {
2428 OPC_CheckPredicate, 46, // 2483: check predicate 46
2429 OPC_Decode, 173, 131, 1, 25, // 2485: decode to WSLLI using decoder 25
2430 // 2485: }
2431 1, 0, // 2490: case 0x1: {
2432 OPC_SwitchField, 25, 1, // 2492: switch Inst[25] {
2433 0, 6, // 2495: case 0x0: {
2434 OPC_CheckPredicate, 46, // 2497: check predicate 46
2435 OPC_Decode, 198, 121, 24, // 2499: decode to PWADD_B using decoder 24
2436 // 2499: }
2437 1, 0, // 2503: case 0x1: {
2438 OPC_CheckPredicate, 46, // 2505: check predicate 46
2439 OPC_Decode, 241, 118, 24, // 2507: decode to PM2WADD_H using decoder 24
2440 // 2507: }
2441 // 2507: } // switch Inst[25]
2442 // 2507: }
2443 // 2507: } // switch Inst[7]
2444 // 2507: }
2445 2, 46, // 2511: case 0x2: {
2446 OPC_SwitchField, 7, 1, // 2513: switch Inst[7] {
2447 0, 19, // 2516: case 0x0: {
2448 OPC_SwitchField, 25, 1, // 2518: switch Inst[25] {
2449 0, 6, // 2521: case 0x0: {
2450 OPC_CheckPredicate, 46, // 2523: check predicate 46
2451 OPC_Decode, 215, 121, 24, // 2525: decode to PWSLL_BS using decoder 24
2452 // 2525: }
2453 1, 0, // 2529: case 0x1: {
2454 OPC_CheckPredicate, 46, // 2531: check predicate 46
2455 OPC_Decode, 216, 121, 24, // 2533: decode to PWSLL_HS using decoder 24
2456 // 2533: }
2457 // 2533: } // switch Inst[25]
2458 // 2533: }
2459 1, 0, // 2537: case 0x1: {
2460 OPC_SwitchField, 25, 1, // 2539: switch Inst[25] {
2461 0, 6, // 2542: case 0x0: {
2462 OPC_CheckPredicate, 46, // 2544: check predicate 46
2463 OPC_Decode, 195, 121, 26, // 2546: decode to PWADDA_H using decoder 26
2464 // 2546: }
2465 1, 0, // 2550: case 0x1: {
2466 OPC_CheckPredicate, 46, // 2552: check predicate 46
2467 OPC_Decode, 158, 131, 1, 26, // 2554: decode to WADDA using decoder 26
2468 // 2554: }
2469 // 2554: } // switch Inst[25]
2470 // 2554: }
2471 // 2554: } // switch Inst[7]
2472 // 2554: }
2473 3, 37, // 2559: case 0x3: {
2474 OPC_SwitchField, 7, 1, // 2561: switch Inst[7] {
2475 0, 11, // 2564: case 0x0: {
2476 OPC_CheckPredicate, 46, // 2566: check predicate 46
2477 OPC_CheckField, 25, 1, 1, // 2568: check Inst[25] == 0x1
2478 OPC_Decode, 172, 131, 1, 24, // 2572: decode to WSLL using decoder 24
2479 // 2572: }
2480 1, 0, // 2577: case 0x1: {
2481 OPC_SwitchField, 25, 1, // 2579: switch Inst[25] {
2482 0, 6, // 2582: case 0x0: {
2483 OPC_CheckPredicate, 46, // 2584: check predicate 46
2484 OPC_Decode, 194, 121, 26, // 2586: decode to PWADDA_B using decoder 26
2485 // 2586: }
2486 1, 0, // 2590: case 0x1: {
2487 OPC_CheckPredicate, 46, // 2592: check predicate 46
2488 OPC_Decode, 237, 118, 26, // 2594: decode to PM2WADDA_H using decoder 26
2489 // 2594: }
2490 // 2594: } // switch Inst[25]
2491 // 2594: }
2492 // 2594: } // switch Inst[7]
2493 // 2594: }
2494 4, 28, // 2598: case 0x4: {
2495 OPC_SwitchField, 25, 1, // 2600: switch Inst[25] {
2496 0, 10, // 2603: case 0x0: {
2497 OPC_CheckPredicate, 46, // 2605: check predicate 46
2498 OPC_CheckField, 7, 1, 1, // 2607: check Inst[7] == 0x1
2499 OPC_Decode, 197, 121, 24, // 2611: decode to PWADDU_H using decoder 24
2500 // 2611: }
2501 1, 0, // 2615: case 0x1: {
2502 OPC_CheckPredicate, 46, // 2617: check predicate 46
2503 OPC_CheckField, 7, 1, 1, // 2619: check Inst[7] == 0x1
2504 OPC_Decode, 160, 131, 1, 24, // 2623: decode to WADDU using decoder 24
2505 // 2623: }
2506 // 2623: } // switch Inst[25]
2507 // 2623: }
2508 5, 27, // 2628: case 0x5: {
2509 OPC_SwitchField, 25, 1, // 2630: switch Inst[25] {
2510 0, 10, // 2633: case 0x0: {
2511 OPC_CheckPredicate, 46, // 2635: check predicate 46
2512 OPC_CheckField, 7, 1, 1, // 2637: check Inst[7] == 0x1
2513 OPC_Decode, 196, 121, 24, // 2641: decode to PWADDU_B using decoder 24
2514 // 2641: }
2515 1, 0, // 2645: case 0x1: {
2516 OPC_CheckPredicate, 46, // 2647: check predicate 46
2517 OPC_CheckField, 7, 1, 1, // 2649: check Inst[7] == 0x1
2518 OPC_Decode, 242, 118, 24, // 2653: decode to PM2WADD_HX using decoder 24
2519 // 2653: }
2520 // 2653: } // switch Inst[25]
2521 // 2653: }
2522 6, 28, // 2657: case 0x6: {
2523 OPC_SwitchField, 25, 1, // 2659: switch Inst[25] {
2524 0, 10, // 2662: case 0x0: {
2525 OPC_CheckPredicate, 46, // 2664: check predicate 46
2526 OPC_CheckField, 7, 1, 1, // 2666: check Inst[7] == 0x1
2527 OPC_Decode, 193, 121, 26, // 2670: decode to PWADDAU_H using decoder 26
2528 // 2670: }
2529 1, 0, // 2674: case 0x1: {
2530 OPC_CheckPredicate, 46, // 2676: check predicate 46
2531 OPC_CheckField, 7, 1, 1, // 2678: check Inst[7] == 0x1
2532 OPC_Decode, 159, 131, 1, 26, // 2682: decode to WADDAU using decoder 26
2533 // 2682: }
2534 // 2682: } // switch Inst[25]
2535 // 2682: }
2536 7, 27, // 2687: case 0x7: {
2537 OPC_SwitchField, 25, 1, // 2689: switch Inst[25] {
2538 0, 10, // 2692: case 0x0: {
2539 OPC_CheckPredicate, 46, // 2694: check predicate 46
2540 OPC_CheckField, 7, 1, 1, // 2696: check Inst[7] == 0x1
2541 OPC_Decode, 192, 121, 26, // 2700: decode to PWADDAU_B using decoder 26
2542 // 2700: }
2543 1, 0, // 2704: case 0x1: {
2544 OPC_CheckPredicate, 46, // 2706: check predicate 46
2545 OPC_CheckField, 7, 1, 1, // 2708: check Inst[7] == 0x1
2546 OPC_Decode, 238, 118, 26, // 2712: decode to PM2WADDA_HX using decoder 26
2547 // 2712: }
2548 // 2712: } // switch Inst[25]
2549 // 2712: }
2550 8, 28, // 2716: case 0x8: {
2551 OPC_SwitchField, 25, 1, // 2718: switch Inst[25] {
2552 0, 10, // 2721: case 0x0: {
2553 OPC_CheckPredicate, 46, // 2723: check predicate 46
2554 OPC_CheckField, 7, 1, 1, // 2725: check Inst[7] == 0x1
2555 OPC_Decode, 208, 121, 24, // 2729: decode to PWMUL_H using decoder 24
2556 // 2729: }
2557 1, 0, // 2733: case 0x1: {
2558 OPC_CheckPredicate, 46, // 2735: check predicate 46
2559 OPC_CheckField, 7, 1, 1, // 2737: check Inst[7] == 0x1
2560 OPC_Decode, 165, 131, 1, 24, // 2741: decode to WMUL using decoder 24
2561 // 2741: }
2562 // 2741: } // switch Inst[25]
2563 // 2741: }
2564 9, 27, // 2746: case 0x9: {
2565 OPC_SwitchField, 25, 1, // 2748: switch Inst[25] {
2566 0, 10, // 2751: case 0x0: {
2567 OPC_CheckPredicate, 46, // 2753: check predicate 46
2568 OPC_CheckField, 7, 1, 1, // 2755: check Inst[7] == 0x1
2569 OPC_Decode, 207, 121, 24, // 2759: decode to PWMUL_B using decoder 24
2570 // 2759: }
2571 1, 0, // 2763: case 0x1: {
2572 OPC_CheckPredicate, 46, // 2765: check predicate 46
2573 OPC_CheckField, 7, 1, 1, // 2767: check Inst[7] == 0x1
2574 OPC_Decode, 240, 118, 24, // 2771: decode to PM2WADDU_H using decoder 24
2575 // 2771: }
2576 // 2771: } // switch Inst[25]
2577 // 2771: }
2578 10, 28, // 2775: case 0xa: {
2579 OPC_SwitchField, 25, 1, // 2777: switch Inst[25] {
2580 0, 10, // 2780: case 0x0: {
2581 OPC_CheckPredicate, 46, // 2782: check predicate 46
2582 OPC_CheckField, 7, 1, 1, // 2784: check Inst[7] == 0x1
2583 OPC_Decode, 202, 121, 26, // 2788: decode to PWMACC_H using decoder 26
2584 // 2788: }
2585 1, 0, // 2792: case 0x1: {
2586 OPC_CheckPredicate, 46, // 2794: check predicate 46
2587 OPC_CheckField, 7, 1, 1, // 2796: check Inst[7] == 0x1
2588 OPC_Decode, 162, 131, 1, 26, // 2800: decode to WMACC using decoder 26
2589 // 2800: }
2590 // 2800: } // switch Inst[25]
2591 // 2800: }
2592 11, 14, // 2805: case 0xb: {
2593 OPC_CheckPredicate, 46, // 2807: check predicate 46
2594 OPC_CheckField, 25, 1, 1, // 2809: check Inst[25] == 0x1
2595 OPC_CheckField, 7, 1, 1, // 2813: check Inst[7] == 0x1
2596 OPC_Decode, 236, 118, 26, // 2817: decode to PM2WADDAU_H using decoder 26
2597 // 2817: }
2598 12, 37, // 2821: case 0xc: {
2599 OPC_SwitchField, 7, 1, // 2823: switch Inst[7] {
2600 0, 10, // 2826: case 0x0: {
2601 OPC_CheckPredicate, 46, // 2828: check predicate 46
2602 OPC_CheckField, 25, 1, 0, // 2830: check Inst[25] == 0x0
2603 OPC_Decode, 203, 118, 27, // 2834: decode to PLI_DH using decoder 27
2604 // 2834: }
2605 1, 0, // 2838: case 0x1: {
2606 OPC_SwitchField, 25, 1, // 2840: switch Inst[25] {
2607 0, 6, // 2843: case 0x0: {
2608 OPC_CheckPredicate, 46, // 2845: check predicate 46
2609 OPC_Decode, 206, 121, 24, // 2847: decode to PWMULU_H using decoder 24
2610 // 2847: }
2611 1, 0, // 2851: case 0x1: {
2612 OPC_CheckPredicate, 46, // 2853: check predicate 46
2613 OPC_Decode, 167, 131, 1, 24, // 2855: decode to WMULU using decoder 24
2614 // 2855: }
2615 // 2855: } // switch Inst[25]
2616 // 2855: }
2617 // 2855: } // switch Inst[7]
2618 // 2855: }
2619 13, 31, // 2860: case 0xd: {
2620 OPC_SwitchField, 7, 1, // 2862: switch Inst[7] {
2621 0, 14, // 2865: case 0x0: {
2622 OPC_CheckPredicate, 46, // 2867: check predicate 46
2623 OPC_CheckField, 24, 2, 0, // 2869: check Inst[25:24] == 0x0
2624 OPC_CheckField, 15, 1, 0, // 2873: check Inst[15] == 0x0
2625 OPC_Decode, 202, 118, 28, // 2877: decode to PLI_DB using decoder 28
2626 // 2877: }
2627 1, 0, // 2881: case 0x1: {
2628 OPC_CheckPredicate, 46, // 2883: check predicate 46
2629 OPC_CheckField, 25, 1, 0, // 2885: check Inst[25] == 0x0
2630 OPC_Decode, 205, 121, 24, // 2889: decode to PWMULU_B using decoder 24
2631 // 2889: }
2632 // 2889: } // switch Inst[7]
2633 // 2889: }
2634 14, 28, // 2893: case 0xe: {
2635 OPC_SwitchField, 25, 1, // 2895: switch Inst[25] {
2636 0, 10, // 2898: case 0x0: {
2637 OPC_CheckPredicate, 46, // 2900: check predicate 46
2638 OPC_CheckField, 7, 1, 1, // 2902: check Inst[7] == 0x1
2639 OPC_Decode, 201, 121, 26, // 2906: decode to PWMACCU_H using decoder 26
2640 // 2906: }
2641 1, 0, // 2910: case 0x1: {
2642 OPC_CheckPredicate, 46, // 2912: check predicate 46
2643 OPC_CheckField, 7, 1, 1, // 2914: check Inst[7] == 0x1
2644 OPC_Decode, 164, 131, 1, 26, // 2918: decode to WMACCU using decoder 26
2645 // 2918: }
2646 // 2918: } // switch Inst[25]
2647 // 2918: }
2648 16, 50, // 2923: case 0x10: {
2649 OPC_SwitchField, 7, 1, // 2925: switch Inst[7] {
2650 0, 23, // 2928: case 0x0: {
2651 OPC_SwitchField, 25, 1, // 2930: switch Inst[25] {
2652 0, 10, // 2933: case 0x0: {
2653 OPC_CheckPredicate, 46, // 2935: check predicate 46
2654 OPC_CheckField, 24, 1, 1, // 2937: check Inst[24] == 0x1
2655 OPC_Decode, 209, 121, 22, // 2941: decode to PWSLAI_B using decoder 22
2656 // 2941: }
2657 1, 0, // 2945: case 0x1: {
2658 OPC_CheckPredicate, 46, // 2947: check predicate 46
2659 OPC_Decode, 210, 121, 23, // 2949: decode to PWSLAI_H using decoder 23
2660 // 2949: }
2661 // 2949: } // switch Inst[25]
2662 // 2949: }
2663 1, 0, // 2953: case 0x1: {
2664 OPC_SwitchField, 25, 1, // 2955: switch Inst[25] {
2665 0, 6, // 2958: case 0x0: {
2666 OPC_CheckPredicate, 46, // 2960: check predicate 46
2667 OPC_Decode, 224, 121, 24, // 2962: decode to PWSUB_H using decoder 24
2668 // 2962: }
2669 1, 0, // 2966: case 0x1: {
2670 OPC_CheckPredicate, 46, // 2968: check predicate 46
2671 OPC_Decode, 174, 131, 1, 24, // 2970: decode to WSUB using decoder 24
2672 // 2970: }
2673 // 2970: } // switch Inst[25]
2674 // 2970: }
2675 // 2970: } // switch Inst[7]
2676 // 2970: }
2677 17, 33, // 2975: case 0x11: {
2678 OPC_SwitchField, 7, 1, // 2977: switch Inst[7] {
2679 0, 7, // 2980: case 0x0: {
2680 OPC_CheckPredicate, 46, // 2982: check predicate 46
2681 OPC_Decode, 171, 131, 1, 25, // 2984: decode to WSLAI using decoder 25
2682 // 2984: }
2683 1, 0, // 2989: case 0x1: {
2684 OPC_SwitchField, 25, 1, // 2991: switch Inst[25] {
2685 0, 6, // 2994: case 0x0: {
2686 OPC_CheckPredicate, 46, // 2996: check predicate 46
2687 OPC_Decode, 223, 121, 24, // 2998: decode to PWSUB_B using decoder 24
2688 // 2998: }
2689 1, 0, // 3002: case 0x1: {
2690 OPC_CheckPredicate, 46, // 3004: check predicate 46
2691 OPC_Decode, 245, 118, 24, // 3006: decode to PM2WSUB_H using decoder 24
2692 // 3006: }
2693 // 3006: } // switch Inst[25]
2694 // 3006: }
2695 // 3006: } // switch Inst[7]
2696 // 3006: }
2697 18, 46, // 3010: case 0x12: {
2698 OPC_SwitchField, 7, 1, // 3012: switch Inst[7] {
2699 0, 19, // 3015: case 0x0: {
2700 OPC_SwitchField, 25, 1, // 3017: switch Inst[25] {
2701 0, 6, // 3020: case 0x0: {
2702 OPC_CheckPredicate, 46, // 3022: check predicate 46
2703 OPC_Decode, 211, 121, 24, // 3024: decode to PWSLA_BS using decoder 24
2704 // 3024: }
2705 1, 0, // 3028: case 0x1: {
2706 OPC_CheckPredicate, 46, // 3030: check predicate 46
2707 OPC_Decode, 212, 121, 24, // 3032: decode to PWSLA_HS using decoder 24
2708 // 3032: }
2709 // 3032: } // switch Inst[25]
2710 // 3032: }
2711 1, 0, // 3036: case 0x1: {
2712 OPC_SwitchField, 25, 1, // 3038: switch Inst[25] {
2713 0, 6, // 3041: case 0x0: {
2714 OPC_CheckPredicate, 46, // 3043: check predicate 46
2715 OPC_Decode, 220, 121, 26, // 3045: decode to PWSUBA_H using decoder 26
2716 // 3045: }
2717 1, 0, // 3049: case 0x1: {
2718 OPC_CheckPredicate, 46, // 3051: check predicate 46
2719 OPC_Decode, 175, 131, 1, 26, // 3053: decode to WSUBA using decoder 26
2720 // 3053: }
2721 // 3053: } // switch Inst[25]
2722 // 3053: }
2723 // 3053: } // switch Inst[7]
2724 // 3053: }
2725 19, 37, // 3058: case 0x13: {
2726 OPC_SwitchField, 7, 1, // 3060: switch Inst[7] {
2727 0, 11, // 3063: case 0x0: {
2728 OPC_CheckPredicate, 46, // 3065: check predicate 46
2729 OPC_CheckField, 25, 1, 1, // 3067: check Inst[25] == 0x1
2730 OPC_Decode, 170, 131, 1, 24, // 3071: decode to WSLA using decoder 24
2731 // 3071: }
2732 1, 0, // 3076: case 0x1: {
2733 OPC_SwitchField, 25, 1, // 3078: switch Inst[25] {
2734 0, 6, // 3081: case 0x0: {
2735 OPC_CheckPredicate, 46, // 3083: check predicate 46
2736 OPC_Decode, 219, 121, 26, // 3085: decode to PWSUBA_B using decoder 26
2737 // 3085: }
2738 1, 0, // 3089: case 0x1: {
2739 OPC_CheckPredicate, 46, // 3091: check predicate 46
2740 OPC_Decode, 243, 118, 26, // 3093: decode to PM2WSUBA_H using decoder 26
2741 // 3093: }
2742 // 3093: } // switch Inst[25]
2743 // 3093: }
2744 // 3093: } // switch Inst[7]
2745 // 3093: }
2746 20, 28, // 3097: case 0x14: {
2747 OPC_SwitchField, 25, 1, // 3099: switch Inst[25] {
2748 0, 10, // 3102: case 0x0: {
2749 OPC_CheckPredicate, 46, // 3104: check predicate 46
2750 OPC_CheckField, 7, 1, 1, // 3106: check Inst[7] == 0x1
2751 OPC_Decode, 222, 121, 24, // 3110: decode to PWSUBU_H using decoder 24
2752 // 3110: }
2753 1, 0, // 3114: case 0x1: {
2754 OPC_CheckPredicate, 46, // 3116: check predicate 46
2755 OPC_CheckField, 7, 1, 1, // 3118: check Inst[7] == 0x1
2756 OPC_Decode, 177, 131, 1, 24, // 3122: decode to WSUBU using decoder 24
2757 // 3122: }
2758 // 3122: } // switch Inst[25]
2759 // 3122: }
2760 21, 27, // 3127: case 0x15: {
2761 OPC_SwitchField, 25, 1, // 3129: switch Inst[25] {
2762 0, 10, // 3132: case 0x0: {
2763 OPC_CheckPredicate, 46, // 3134: check predicate 46
2764 OPC_CheckField, 7, 1, 1, // 3136: check Inst[7] == 0x1
2765 OPC_Decode, 221, 121, 24, // 3140: decode to PWSUBU_B using decoder 24
2766 // 3140: }
2767 1, 0, // 3144: case 0x1: {
2768 OPC_CheckPredicate, 46, // 3146: check predicate 46
2769 OPC_CheckField, 7, 1, 1, // 3148: check Inst[7] == 0x1
2770 OPC_Decode, 246, 118, 24, // 3152: decode to PM2WSUB_HX using decoder 24
2771 // 3152: }
2772 // 3152: } // switch Inst[25]
2773 // 3152: }
2774 22, 28, // 3156: case 0x16: {
2775 OPC_SwitchField, 25, 1, // 3158: switch Inst[25] {
2776 0, 10, // 3161: case 0x0: {
2777 OPC_CheckPredicate, 46, // 3163: check predicate 46
2778 OPC_CheckField, 7, 1, 1, // 3165: check Inst[7] == 0x1
2779 OPC_Decode, 218, 121, 26, // 3169: decode to PWSUBAU_H using decoder 26
2780 // 3169: }
2781 1, 0, // 3173: case 0x1: {
2782 OPC_CheckPredicate, 46, // 3175: check predicate 46
2783 OPC_CheckField, 7, 1, 1, // 3177: check Inst[7] == 0x1
2784 OPC_Decode, 176, 131, 1, 26, // 3181: decode to WSUBAU using decoder 26
2785 // 3181: }
2786 // 3181: } // switch Inst[25]
2787 // 3181: }
2788 23, 27, // 3186: case 0x17: {
2789 OPC_SwitchField, 25, 1, // 3188: switch Inst[25] {
2790 0, 10, // 3191: case 0x0: {
2791 OPC_CheckPredicate, 46, // 3193: check predicate 46
2792 OPC_CheckField, 7, 1, 1, // 3195: check Inst[7] == 0x1
2793 OPC_Decode, 217, 121, 26, // 3199: decode to PWSUBAU_B using decoder 26
2794 // 3199: }
2795 1, 0, // 3203: case 0x1: {
2796 OPC_CheckPredicate, 46, // 3205: check predicate 46
2797 OPC_CheckField, 7, 1, 1, // 3207: check Inst[7] == 0x1
2798 OPC_Decode, 244, 118, 26, // 3211: decode to PM2WSUBA_HX using decoder 26
2799 // 3211: }
2800 // 3211: } // switch Inst[25]
2801 // 3211: }
2802 24, 28, // 3215: case 0x18: {
2803 OPC_SwitchField, 25, 1, // 3217: switch Inst[25] {
2804 0, 10, // 3220: case 0x0: {
2805 OPC_CheckPredicate, 46, // 3222: check predicate 46
2806 OPC_CheckField, 7, 1, 1, // 3224: check Inst[7] == 0x1
2807 OPC_Decode, 204, 121, 24, // 3228: decode to PWMULSU_H using decoder 24
2808 // 3228: }
2809 1, 0, // 3232: case 0x1: {
2810 OPC_CheckPredicate, 46, // 3234: check predicate 46
2811 OPC_CheckField, 7, 1, 1, // 3236: check Inst[7] == 0x1
2812 OPC_Decode, 166, 131, 1, 24, // 3240: decode to WMULSU using decoder 24
2813 // 3240: }
2814 // 3240: } // switch Inst[25]
2815 // 3240: }
2816 25, 27, // 3245: case 0x19: {
2817 OPC_SwitchField, 25, 1, // 3247: switch Inst[25] {
2818 0, 10, // 3250: case 0x0: {
2819 OPC_CheckPredicate, 46, // 3252: check predicate 46
2820 OPC_CheckField, 7, 1, 1, // 3254: check Inst[7] == 0x1
2821 OPC_Decode, 203, 121, 24, // 3258: decode to PWMULSU_B using decoder 24
2822 // 3258: }
2823 1, 0, // 3262: case 0x1: {
2824 OPC_CheckPredicate, 46, // 3264: check predicate 46
2825 OPC_CheckField, 7, 1, 1, // 3266: check Inst[7] == 0x1
2826 OPC_Decode, 239, 118, 24, // 3270: decode to PM2WADDSU_H using decoder 24
2827 // 3270: }
2828 // 3270: } // switch Inst[25]
2829 // 3270: }
2830 26, 28, // 3274: case 0x1a: {
2831 OPC_SwitchField, 25, 1, // 3276: switch Inst[25] {
2832 0, 10, // 3279: case 0x0: {
2833 OPC_CheckPredicate, 46, // 3281: check predicate 46
2834 OPC_CheckField, 7, 1, 1, // 3283: check Inst[7] == 0x1
2835 OPC_Decode, 200, 121, 26, // 3287: decode to PWMACCSU_H using decoder 26
2836 // 3287: }
2837 1, 0, // 3291: case 0x1: {
2838 OPC_CheckPredicate, 46, // 3293: check predicate 46
2839 OPC_CheckField, 7, 1, 1, // 3295: check Inst[7] == 0x1
2840 OPC_Decode, 163, 131, 1, 26, // 3299: decode to WMACCSU using decoder 26
2841 // 3299: }
2842 // 3299: } // switch Inst[25]
2843 // 3299: }
2844 27, 14, // 3304: case 0x1b: {
2845 OPC_CheckPredicate, 46, // 3306: check predicate 46
2846 OPC_CheckField, 25, 1, 1, // 3308: check Inst[25] == 0x1
2847 OPC_CheckField, 7, 1, 1, // 3312: check Inst[7] == 0x1
2848 OPC_Decode, 235, 118, 26, // 3316: decode to PM2WADDASU_H using decoder 26
2849 // 3316: }
2850 28, 14, // 3320: case 0x1c: {
2851 OPC_CheckPredicate, 46, // 3322: check predicate 46
2852 OPC_CheckField, 25, 1, 0, // 3324: check Inst[25] == 0x0
2853 OPC_CheckField, 7, 1, 0, // 3328: check Inst[7] == 0x0
2854 OPC_Decode, 206, 118, 29, // 3332: decode to PLUI_DH using decoder 29
2855 // 3332: }
2856 30, 47, // 3336: case 0x1e: {
2857 OPC_SwitchField, 7, 1, // 3338: switch Inst[7] {
2858 0, 21, // 3341: case 0x0: {
2859 OPC_SwitchField, 25, 1, // 3343: switch Inst[25] {
2860 0, 7, // 3346: case 0x0: {
2861 OPC_CheckPredicate, 46, // 3348: check predicate 46
2862 OPC_Decode, 179, 131, 1, 24, // 3350: decode to WZIP8P using decoder 24
2863 // 3350: }
2864 1, 0, // 3355: case 0x1: {
2865 OPC_CheckPredicate, 46, // 3357: check predicate 46
2866 OPC_Decode, 178, 131, 1, 24, // 3359: decode to WZIP16P using decoder 24
2867 // 3359: }
2868 // 3359: } // switch Inst[25]
2869 // 3359: }
2870 1, 0, // 3364: case 0x1: {
2871 OPC_SwitchField, 25, 1, // 3366: switch Inst[25] {
2872 0, 6, // 3369: case 0x0: {
2873 OPC_CheckPredicate, 46, // 3371: check predicate 46
2874 OPC_Decode, 198, 119, 26, // 3373: decode to PMQWACC_H using decoder 26
2875 // 3373: }
2876 1, 0, // 3377: case 0x1: {
2877 OPC_CheckPredicate, 46, // 3379: check predicate 46
2878 OPC_Decode, 168, 117, 26, // 3381: decode to MQWACC using decoder 26
2879 // 3381: }
2880 // 3381: } // switch Inst[25]
2881 // 3381: }
2882 // 3381: } // switch Inst[7]
2883 // 3381: }
2884 31, 27, // 3385: case 0x1f: {
2885 OPC_SwitchField, 25, 1, // 3387: switch Inst[25] {
2886 0, 10, // 3390: case 0x0: {
2887 OPC_CheckPredicate, 46, // 3392: check predicate 46
2888 OPC_CheckField, 7, 1, 1, // 3394: check Inst[7] == 0x1
2889 OPC_Decode, 197, 119, 26, // 3398: decode to PMQRWACC_H using decoder 26
2890 // 3398: }
2891 1, 0, // 3402: case 0x1: {
2892 OPC_CheckPredicate, 46, // 3404: check predicate 46
2893 OPC_CheckField, 7, 1, 1, // 3406: check Inst[7] == 0x1
2894 OPC_Decode, 167, 117, 26, // 3410: decode to MQRWACC using decoder 26
2895 // 3410: }
2896 // 3410: } // switch Inst[25]
2897 // 3410: }
2898 32, 36, // 3414: case 0x20: {
2899 OPC_SwitchField, 25, 1, // 3416: switch Inst[25] {
2900 0, 23, // 3419: case 0x0: {
2901 OPC_SwitchField, 24, 1, // 3421: switch Inst[24] {
2902 0, 10, // 3424: case 0x0: {
2903 OPC_CheckPredicate, 42, // 3426: check predicate 42
2904 OPC_CheckField, 23, 1, 1, // 3428: check Inst[23] == 0x1
2905 OPC_Decode, 231, 120, 30, // 3432: decode to PSLLI_B using decoder 30
2906 // 3432: }
2907 1, 0, // 3436: case 0x1: {
2908 OPC_CheckPredicate, 42, // 3438: check predicate 42
2909 OPC_Decode, 235, 120, 18, // 3440: decode to PSLLI_H using decoder 18
2910 // 3440: }
2911 // 3440: } // switch Inst[24]
2912 // 3440: }
2913 1, 0, // 3444: case 0x1: {
2914 OPC_CheckPredicate, 47, // 3446: check predicate 47
2915 OPC_Decode, 236, 120, 21, // 3448: decode to PSLLI_W using decoder 21
2916 // 3448: }
2917 // 3448: } // switch Inst[25]
2918 // 3448: }
2919 34, 19, // 3452: case 0x22: {
2920 OPC_SwitchField, 25, 1, // 3454: switch Inst[25] {
2921 0, 6, // 3457: case 0x0: {
2922 OPC_CheckPredicate, 42, // 3459: check predicate 42
2923 OPC_Decode, 241, 120, 31, // 3461: decode to PSLL_HS using decoder 31
2924 // 3461: }
2925 1, 0, // 3465: case 0x1: {
2926 OPC_CheckPredicate, 47, // 3467: check predicate 47
2927 OPC_Decode, 242, 120, 31, // 3469: decode to PSLL_WS using decoder 31
2928 // 3469: }
2929 // 3469: } // switch Inst[25]
2930 // 3469: }
2931 35, 10, // 3473: case 0x23: {
2932 OPC_CheckPredicate, 42, // 3475: check predicate 42
2933 OPC_CheckField, 25, 1, 0, // 3477: check Inst[25] == 0x0
2934 OPC_Decode, 237, 120, 31, // 3481: decode to PSLL_BS using decoder 31
2935 // 3481: }
2936 38, 19, // 3485: case 0x26: {
2937 OPC_SwitchField, 25, 1, // 3487: switch Inst[25] {
2938 0, 6, // 3490: case 0x0: {
2939 OPC_CheckPredicate, 42, // 3492: check predicate 42
2940 OPC_Decode, 180, 118, 31, // 3494: decode to PADD_HS using decoder 31
2941 // 3494: }
2942 1, 0, // 3498: case 0x1: {
2943 OPC_CheckPredicate, 47, // 3500: check predicate 47
2944 OPC_Decode, 182, 118, 31, // 3502: decode to PADD_WS using decoder 31
2945 // 3502: }
2946 // 3502: } // switch Inst[25]
2947 // 3502: }
2948 39, 10, // 3506: case 0x27: {
2949 OPC_CheckPredicate, 42, // 3508: check predicate 42
2950 OPC_CheckField, 25, 1, 0, // 3510: check Inst[25] == 0x0
2951 OPC_Decode, 172, 118, 31, // 3514: decode to PADD_BS using decoder 31
2952 // 3514: }
2953 42, 19, // 3518: case 0x2a: {
2954 OPC_SwitchField, 25, 1, // 3520: switch Inst[25] {
2955 0, 6, // 3523: case 0x0: {
2956 OPC_CheckPredicate, 42, // 3525: check predicate 42
2957 OPC_Decode, 164, 121, 31, // 3527: decode to PSSHL_HS using decoder 31
2958 // 3527: }
2959 1, 0, // 3531: case 0x1: {
2960 OPC_CheckPredicate, 47, // 3533: check predicate 47
2961 OPC_Decode, 165, 121, 31, // 3535: decode to PSSHL_WS using decoder 31
2962 // 3535: }
2963 // 3535: } // switch Inst[25]
2964 // 3535: }
2965 43, 10, // 3539: case 0x2b: {
2966 OPC_CheckPredicate, 47, // 3541: check predicate 47
2967 OPC_CheckField, 25, 1, 1, // 3543: check Inst[25] == 0x1
2968 OPC_Decode, 136, 124, 31, // 3547: decode to SHL using decoder 31
2969 // 3547: }
2970 44, 19, // 3551: case 0x2c: {
2971 OPC_SwitchField, 25, 1, // 3553: switch Inst[25] {
2972 0, 6, // 3556: case 0x0: {
2973 OPC_CheckPredicate, 42, // 3558: check predicate 42
2974 OPC_Decode, 204, 118, 32, // 3560: decode to PLI_H using decoder 32
2975 // 3560: }
2976 1, 0, // 3564: case 0x1: {
2977 OPC_CheckPredicate, 47, // 3566: check predicate 47
2978 OPC_Decode, 205, 118, 32, // 3568: decode to PLI_W using decoder 32
2979 // 3568: }
2980 // 3568: } // switch Inst[25]
2981 // 3568: }
2982 45, 14, // 3572: case 0x2d: {
2983 OPC_CheckPredicate, 42, // 3574: check predicate 42
2984 OPC_CheckField, 24, 2, 0, // 3576: check Inst[25:24] == 0x0
2985 OPC_CheckField, 15, 1, 0, // 3580: check Inst[15] == 0x0
2986 OPC_Decode, 201, 118, 33, // 3584: decode to PLI_B using decoder 33
2987 // 3584: }
2988 46, 19, // 3588: case 0x2e: {
2989 OPC_SwitchField, 25, 1, // 3590: switch Inst[25] {
2990 0, 6, // 3593: case 0x0: {
2991 OPC_CheckPredicate, 42, // 3595: check predicate 42
2992 OPC_Decode, 160, 121, 31, // 3597: decode to PSSHLR_HS using decoder 31
2993 // 3597: }
2994 1, 0, // 3601: case 0x1: {
2995 OPC_CheckPredicate, 47, // 3603: check predicate 47
2996 OPC_Decode, 161, 121, 31, // 3605: decode to PSSHLR_WS using decoder 31
2997 // 3605: }
2998 // 3605: } // switch Inst[25]
2999 // 3605: }
3000 47, 10, // 3609: case 0x2f: {
3001 OPC_CheckPredicate, 47, // 3611: check predicate 47
3002 OPC_CheckField, 25, 1, 1, // 3613: check Inst[25] == 0x1
3003 OPC_Decode, 137, 124, 31, // 3617: decode to SHLR using decoder 31
3004 // 3617: }
3005 52, 23, // 3621: case 0x34: {
3006 OPC_SwitchField, 25, 1, // 3623: switch Inst[25] {
3007 0, 10, // 3626: case 0x0: {
3008 OPC_CheckPredicate, 42, // 3628: check predicate 42
3009 OPC_CheckField, 24, 1, 1, // 3630: check Inst[24] == 0x1
3010 OPC_Decode, 168, 121, 18, // 3634: decode to PSSLAI_H using decoder 18
3011 // 3634: }
3012 1, 0, // 3638: case 0x1: {
3013 OPC_CheckPredicate, 47, // 3640: check predicate 47
3014 OPC_Decode, 169, 121, 21, // 3642: decode to PSSLAI_W using decoder 21
3015 // 3642: }
3016 // 3642: } // switch Inst[25]
3017 // 3642: }
3018 56, 35, // 3646: case 0x38: {
3019 OPC_SwitchField, 20, 6, // 3648: switch Inst[25:20] {
3020 4, 6, // 3651: case 0x4: {
3021 OPC_CheckPredicate, 42, // 3653: check predicate 42
3022 OPC_Decode, 224, 120, 17, // 3655: decode to PSEXT_H_B using decoder 17
3023 // 3655: }
3024 7, 6, // 3659: case 0x7: {
3025 OPC_CheckPredicate, 42, // 3661: check predicate 42
3026 OPC_Decode, 198, 120, 17, // 3663: decode to PSABS_H using decoder 17
3027 // 3663: }
3028 36, 6, // 3667: case 0x24: {
3029 OPC_CheckPredicate, 47, // 3669: check predicate 47
3030 OPC_Decode, 225, 120, 17, // 3671: decode to PSEXT_W_B using decoder 17
3031 // 3671: }
3032 37, 0, // 3675: case 0x25: {
3033 OPC_CheckPredicate, 47, // 3677: check predicate 47
3034 OPC_Decode, 226, 120, 17, // 3679: decode to PSEXT_W_H using decoder 17
3035 // 3679: }
3036 // 3679: } // switch Inst[25:20]
3037 // 3679: }
3038 57, 10, // 3683: case 0x39: {
3039 OPC_CheckPredicate, 42, // 3685: check predicate 42
3040 OPC_CheckField, 20, 6, 7, // 3687: check Inst[25:20] == 0x7
3041 OPC_Decode, 195, 120, 17, // 3691: decode to PSABS_B using decoder 17
3042 // 3691: }
3043 58, 19, // 3695: case 0x3a: {
3044 OPC_SwitchField, 25, 1, // 3697: switch Inst[25] {
3045 0, 6, // 3700: case 0x0: {
3046 OPC_CheckPredicate, 42, // 3702: check predicate 42
3047 OPC_Decode, 156, 121, 31, // 3704: decode to PSSHA_HS using decoder 31
3048 // 3704: }
3049 1, 0, // 3708: case 0x1: {
3050 OPC_CheckPredicate, 47, // 3710: check predicate 47
3051 OPC_Decode, 157, 121, 31, // 3712: decode to PSSHA_WS using decoder 31
3052 // 3712: }
3053 // 3712: } // switch Inst[25]
3054 // 3712: }
3055 59, 10, // 3716: case 0x3b: {
3056 OPC_CheckPredicate, 47, // 3718: check predicate 47
3057 OPC_CheckField, 25, 1, 1, // 3720: check Inst[25] == 0x1
3058 OPC_Decode, 248, 123, 31, // 3724: decode to SHA using decoder 31
3059 // 3724: }
3060 60, 19, // 3728: case 0x3c: {
3061 OPC_SwitchField, 25, 1, // 3730: switch Inst[25] {
3062 0, 6, // 3733: case 0x0: {
3063 OPC_CheckPredicate, 42, // 3735: check predicate 42
3064 OPC_Decode, 207, 118, 34, // 3737: decode to PLUI_H using decoder 34
3065 // 3737: }
3066 1, 0, // 3741: case 0x1: {
3067 OPC_CheckPredicate, 47, // 3743: check predicate 47
3068 OPC_Decode, 208, 118, 34, // 3745: decode to PLUI_W using decoder 34
3069 // 3745: }
3070 // 3745: } // switch Inst[25]
3071 // 3745: }
3072 62, 19, // 3749: case 0x3e: {
3073 OPC_SwitchField, 25, 1, // 3751: switch Inst[25] {
3074 0, 6, // 3754: case 0x0: {
3075 OPC_CheckPredicate, 42, // 3756: check predicate 42
3076 OPC_Decode, 152, 121, 31, // 3758: decode to PSSHAR_HS using decoder 31
3077 // 3758: }
3078 1, 0, // 3762: case 0x1: {
3079 OPC_CheckPredicate, 47, // 3764: check predicate 47
3080 OPC_Decode, 153, 121, 31, // 3766: decode to PSSHAR_WS using decoder 31
3081 // 3766: }
3082 // 3766: } // switch Inst[25]
3083 // 3766: }
3084 63, 0, // 3770: case 0x3f: {
3085 OPC_CheckPredicate, 47, // 3772: check predicate 47
3086 OPC_CheckField, 25, 1, 1, // 3774: check Inst[25] == 0x1
3087 OPC_Decode, 135, 124, 31, // 3778: decode to SHAR using decoder 31
3088 // 3778: }
3089 // 3778: } // switch Inst[31:26]
3090 // 3778: }
3091 4, 226, 7, // 3782: case 0x4: {
3092 OPC_SwitchField, 26, 6, // 3785: switch Inst[31:26] {
3093 0, 31, // 3788: case 0x0: {
3094 OPC_SwitchField, 25, 1, // 3790: switch Inst[25] {
3095 0, 14, // 3793: case 0x0: {
3096 OPC_CheckPredicate, 46, // 3795: check predicate 46
3097 OPC_CheckField, 24, 1, 1, // 3797: check Inst[24] == 0x1
3098 OPC_CheckField, 15, 1, 1, // 3801: check Inst[15] == 0x1
3099 OPC_Decode, 159, 120, 35, // 3805: decode to PNSRLI_B using decoder 35
3100 // 3805: }
3101 1, 0, // 3809: case 0x1: {
3102 OPC_CheckPredicate, 46, // 3811: check predicate 46
3103 OPC_CheckField, 15, 1, 1, // 3813: check Inst[15] == 0x1
3104 OPC_Decode, 160, 120, 36, // 3817: decode to PNSRLI_H using decoder 36
3105 // 3817: }
3106 // 3817: } // switch Inst[25]
3107 // 3817: }
3108 1, 10, // 3821: case 0x1: {
3109 OPC_CheckPredicate, 46, // 3823: check predicate 46
3110 OPC_CheckField, 15, 1, 1, // 3825: check Inst[15] == 0x1
3111 OPC_Decode, 137, 118, 37, // 3829: decode to NSRLI using decoder 37
3112 // 3829: }
3113 2, 27, // 3833: case 0x2: {
3114 OPC_SwitchField, 25, 1, // 3835: switch Inst[25] {
3115 0, 10, // 3838: case 0x0: {
3116 OPC_CheckPredicate, 46, // 3840: check predicate 46
3117 OPC_CheckField, 15, 1, 1, // 3842: check Inst[15] == 0x1
3118 OPC_Decode, 161, 120, 38, // 3846: decode to PNSRL_BS using decoder 38
3119 // 3846: }
3120 1, 0, // 3850: case 0x1: {
3121 OPC_CheckPredicate, 46, // 3852: check predicate 46
3122 OPC_CheckField, 15, 1, 1, // 3854: check Inst[15] == 0x1
3123 OPC_Decode, 162, 120, 38, // 3858: decode to PNSRL_HS using decoder 38
3124 // 3858: }
3125 // 3858: } // switch Inst[25]
3126 // 3858: }
3127 3, 14, // 3862: case 0x3: {
3128 OPC_CheckPredicate, 46, // 3864: check predicate 46
3129 OPC_CheckField, 25, 1, 1, // 3866: check Inst[25] == 0x1
3130 OPC_CheckField, 15, 1, 1, // 3870: check Inst[15] == 0x1
3131 OPC_Decode, 136, 118, 38, // 3874: decode to NSRL using decoder 38
3132 // 3874: }
3133 6, 14, // 3878: case 0x6: {
3134 OPC_CheckPredicate, 46, // 3880: check predicate 46
3135 OPC_CheckField, 25, 1, 0, // 3882: check Inst[25] == 0x0
3136 OPC_CheckField, 15, 1, 0, // 3886: check Inst[15] == 0x0
3137 OPC_Decode, 189, 120, 38, // 3890: decode to PREDSUM_DHS using decoder 38
3138 // 3890: }
3139 7, 14, // 3894: case 0x7: {
3140 OPC_CheckPredicate, 46, // 3896: check predicate 46
3141 OPC_CheckField, 25, 1, 0, // 3898: check Inst[25] == 0x0
3142 OPC_CheckField, 15, 1, 0, // 3902: check Inst[15] == 0x0
3143 OPC_Decode, 188, 120, 38, // 3906: decode to PREDSUM_DBS using decoder 38
3144 // 3906: }
3145 8, 31, // 3910: case 0x8: {
3146 OPC_SwitchField, 25, 1, // 3912: switch Inst[25] {
3147 0, 14, // 3915: case 0x0: {
3148 OPC_CheckPredicate, 46, // 3917: check predicate 46
3149 OPC_CheckField, 24, 1, 1, // 3919: check Inst[24] == 0x1
3150 OPC_CheckField, 15, 1, 1, // 3923: check Inst[15] == 0x1
3151 OPC_Decode, 129, 120, 35, // 3927: decode to PNCLIPIU_B using decoder 35
3152 // 3927: }
3153 1, 0, // 3931: case 0x1: {
3154 OPC_CheckPredicate, 46, // 3933: check predicate 46
3155 OPC_CheckField, 15, 1, 1, // 3935: check Inst[15] == 0x1
3156 OPC_Decode, 130, 120, 36, // 3939: decode to PNCLIPIU_H using decoder 36
3157 // 3939: }
3158 // 3939: } // switch Inst[25]
3159 // 3939: }
3160 9, 10, // 3943: case 0x9: {
3161 OPC_CheckPredicate, 46, // 3945: check predicate 46
3162 OPC_CheckField, 15, 1, 1, // 3947: check Inst[15] == 0x1
3163 OPC_Decode, 207, 117, 37, // 3951: decode to NCLIPIU using decoder 37
3164 // 3951: }
3165 10, 27, // 3955: case 0xa: {
3166 OPC_SwitchField, 25, 1, // 3957: switch Inst[25] {
3167 0, 10, // 3960: case 0x0: {
3168 OPC_CheckPredicate, 46, // 3962: check predicate 46
3169 OPC_CheckField, 15, 1, 1, // 3964: check Inst[15] == 0x1
3170 OPC_Decode, 147, 120, 38, // 3968: decode to PNCLIPU_BS using decoder 38
3171 // 3968: }
3172 1, 0, // 3972: case 0x1: {
3173 OPC_CheckPredicate, 46, // 3974: check predicate 46
3174 OPC_CheckField, 15, 1, 1, // 3976: check Inst[15] == 0x1
3175 OPC_Decode, 148, 120, 38, // 3980: decode to PNCLIPU_HS using decoder 38
3176 // 3980: }
3177 // 3980: } // switch Inst[25]
3178 // 3980: }
3179 11, 14, // 3984: case 0xb: {
3180 OPC_CheckPredicate, 46, // 3986: check predicate 46
3181 OPC_CheckField, 25, 1, 1, // 3988: check Inst[25] == 0x1
3182 OPC_CheckField, 15, 1, 1, // 3992: check Inst[15] == 0x1
3183 OPC_Decode, 212, 117, 38, // 3996: decode to NCLIPU using decoder 38
3184 // 3996: }
3185 12, 31, // 4000: case 0xc: {
3186 OPC_SwitchField, 25, 1, // 4002: switch Inst[25] {
3187 0, 14, // 4005: case 0x0: {
3188 OPC_CheckPredicate, 46, // 4007: check predicate 46
3189 OPC_CheckField, 24, 1, 1, // 4009: check Inst[24] == 0x1
3190 OPC_CheckField, 15, 1, 1, // 4013: check Inst[15] == 0x1
3191 OPC_Decode, 136, 120, 35, // 4017: decode to PNCLIPRIU_B using decoder 35
3192 // 4017: }
3193 1, 0, // 4021: case 0x1: {
3194 OPC_CheckPredicate, 46, // 4023: check predicate 46
3195 OPC_CheckField, 15, 1, 1, // 4025: check Inst[15] == 0x1
3196 OPC_Decode, 137, 120, 36, // 4029: decode to PNCLIPRIU_H using decoder 36
3197 // 4029: }
3198 // 4029: } // switch Inst[25]
3199 // 4029: }
3200 13, 10, // 4033: case 0xd: {
3201 OPC_CheckPredicate, 46, // 4035: check predicate 46
3202 OPC_CheckField, 15, 1, 1, // 4037: check Inst[15] == 0x1
3203 OPC_Decode, 210, 117, 37, // 4041: decode to NCLIPRIU using decoder 37
3204 // 4041: }
3205 14, 36, // 4045: case 0xe: {
3206 OPC_SwitchField, 15, 1, // 4047: switch Inst[15] {
3207 0, 10, // 4050: case 0x0: {
3208 OPC_CheckPredicate, 46, // 4052: check predicate 46
3209 OPC_CheckField, 25, 1, 0, // 4054: check Inst[25] == 0x0
3210 OPC_Decode, 184, 120, 38, // 4058: decode to PREDSUMU_DHS using decoder 38
3211 // 4058: }
3212 1, 0, // 4062: case 0x1: {
3213 OPC_SwitchField, 25, 1, // 4064: switch Inst[25] {
3214 0, 6, // 4067: case 0x0: {
3215 OPC_CheckPredicate, 46, // 4069: check predicate 46
3216 OPC_Decode, 140, 120, 38, // 4071: decode to PNCLIPRU_BS using decoder 38
3217 // 4071: }
3218 1, 0, // 4075: case 0x1: {
3219 OPC_CheckPredicate, 46, // 4077: check predicate 46
3220 OPC_Decode, 141, 120, 38, // 4079: decode to PNCLIPRU_HS using decoder 38
3221 // 4079: }
3222 // 4079: } // switch Inst[25]
3223 // 4079: }
3224 // 4079: } // switch Inst[15]
3225 // 4079: }
3226 15, 27, // 4083: case 0xf: {
3227 OPC_SwitchField, 15, 1, // 4085: switch Inst[15] {
3228 0, 10, // 4088: case 0x0: {
3229 OPC_CheckPredicate, 46, // 4090: check predicate 46
3230 OPC_CheckField, 25, 1, 0, // 4092: check Inst[25] == 0x0
3231 OPC_Decode, 183, 120, 38, // 4096: decode to PREDSUMU_DBS using decoder 38
3232 // 4096: }
3233 1, 0, // 4100: case 0x1: {
3234 OPC_CheckPredicate, 46, // 4102: check predicate 46
3235 OPC_CheckField, 25, 1, 1, // 4104: check Inst[25] == 0x1
3236 OPC_Decode, 211, 117, 38, // 4108: decode to NCLIPRU using decoder 38
3237 // 4108: }
3238 // 4108: } // switch Inst[15]
3239 // 4108: }
3240 16, 31, // 4112: case 0x10: {
3241 OPC_SwitchField, 25, 1, // 4114: switch Inst[25] {
3242 0, 14, // 4117: case 0x0: {
3243 OPC_CheckPredicate, 46, // 4119: check predicate 46
3244 OPC_CheckField, 24, 1, 1, // 4121: check Inst[24] == 0x1
3245 OPC_CheckField, 15, 1, 1, // 4125: check Inst[15] == 0x1
3246 OPC_Decode, 151, 120, 35, // 4129: decode to PNSRAI_B using decoder 35
3247 // 4129: }
3248 1, 0, // 4133: case 0x1: {
3249 OPC_CheckPredicate, 46, // 4135: check predicate 46
3250 OPC_CheckField, 15, 1, 1, // 4137: check Inst[15] == 0x1
3251 OPC_Decode, 152, 120, 36, // 4141: decode to PNSRAI_H using decoder 36
3252 // 4141: }
3253 // 4141: } // switch Inst[25]
3254 // 4141: }
3255 17, 10, // 4145: case 0x11: {
3256 OPC_CheckPredicate, 46, // 4147: check predicate 46
3257 OPC_CheckField, 15, 1, 1, // 4149: check Inst[15] == 0x1
3258 OPC_Decode, 133, 118, 37, // 4153: decode to NSRAI using decoder 37
3259 // 4153: }
3260 18, 27, // 4157: case 0x12: {
3261 OPC_SwitchField, 25, 1, // 4159: switch Inst[25] {
3262 0, 10, // 4162: case 0x0: {
3263 OPC_CheckPredicate, 46, // 4164: check predicate 46
3264 OPC_CheckField, 15, 1, 1, // 4166: check Inst[15] == 0x1
3265 OPC_Decode, 157, 120, 38, // 4170: decode to PNSRA_BS using decoder 38
3266 // 4170: }
3267 1, 0, // 4174: case 0x1: {
3268 OPC_CheckPredicate, 46, // 4176: check predicate 46
3269 OPC_CheckField, 15, 1, 1, // 4178: check Inst[15] == 0x1
3270 OPC_Decode, 158, 120, 38, // 4182: decode to PNSRA_HS using decoder 38
3271 // 4182: }
3272 // 4182: } // switch Inst[25]
3273 // 4182: }
3274 19, 14, // 4186: case 0x13: {
3275 OPC_CheckPredicate, 46, // 4188: check predicate 46
3276 OPC_CheckField, 25, 1, 1, // 4190: check Inst[25] == 0x1
3277 OPC_CheckField, 15, 1, 1, // 4194: check Inst[15] == 0x1
3278 OPC_Decode, 132, 118, 38, // 4198: decode to NSRA using decoder 38
3279 // 4198: }
3280 20, 31, // 4202: case 0x14: {
3281 OPC_SwitchField, 25, 1, // 4204: switch Inst[25] {
3282 0, 14, // 4207: case 0x0: {
3283 OPC_CheckPredicate, 46, // 4209: check predicate 46
3284 OPC_CheckField, 24, 1, 1, // 4211: check Inst[24] == 0x1
3285 OPC_CheckField, 15, 1, 1, // 4215: check Inst[15] == 0x1
3286 OPC_Decode, 153, 120, 35, // 4219: decode to PNSRARI_B using decoder 35
3287 // 4219: }
3288 1, 0, // 4223: case 0x1: {
3289 OPC_CheckPredicate, 46, // 4225: check predicate 46
3290 OPC_CheckField, 15, 1, 1, // 4227: check Inst[15] == 0x1
3291 OPC_Decode, 154, 120, 36, // 4231: decode to PNSRARI_H using decoder 36
3292 // 4231: }
3293 // 4231: } // switch Inst[25]
3294 // 4231: }
3295 21, 10, // 4235: case 0x15: {
3296 OPC_CheckPredicate, 46, // 4237: check predicate 46
3297 OPC_CheckField, 15, 1, 1, // 4239: check Inst[15] == 0x1
3298 OPC_Decode, 135, 118, 37, // 4243: decode to NSRARI using decoder 37
3299 // 4243: }
3300 22, 27, // 4247: case 0x16: {
3301 OPC_SwitchField, 25, 1, // 4249: switch Inst[25] {
3302 0, 10, // 4252: case 0x0: {
3303 OPC_CheckPredicate, 46, // 4254: check predicate 46
3304 OPC_CheckField, 15, 1, 1, // 4256: check Inst[15] == 0x1
3305 OPC_Decode, 155, 120, 38, // 4260: decode to PNSRAR_BS using decoder 38
3306 // 4260: }
3307 1, 0, // 4264: case 0x1: {
3308 OPC_CheckPredicate, 46, // 4266: check predicate 46
3309 OPC_CheckField, 15, 1, 1, // 4268: check Inst[15] == 0x1
3310 OPC_Decode, 156, 120, 38, // 4272: decode to PNSRAR_HS using decoder 38
3311 // 4272: }
3312 // 4272: } // switch Inst[25]
3313 // 4272: }
3314 23, 14, // 4276: case 0x17: {
3315 OPC_CheckPredicate, 46, // 4278: check predicate 46
3316 OPC_CheckField, 25, 1, 1, // 4280: check Inst[25] == 0x1
3317 OPC_CheckField, 15, 1, 1, // 4284: check Inst[15] == 0x1
3318 OPC_Decode, 134, 118, 38, // 4288: decode to NSRAR using decoder 38
3319 // 4288: }
3320 24, 31, // 4292: case 0x18: {
3321 OPC_SwitchField, 25, 1, // 4294: switch Inst[25] {
3322 0, 14, // 4297: case 0x0: {
3323 OPC_CheckPredicate, 46, // 4299: check predicate 46
3324 OPC_CheckField, 24, 1, 1, // 4301: check Inst[24] == 0x1
3325 OPC_CheckField, 15, 1, 1, // 4305: check Inst[15] == 0x1
3326 OPC_Decode, 131, 120, 35, // 4309: decode to PNCLIPI_B using decoder 35
3327 // 4309: }
3328 1, 0, // 4313: case 0x1: {
3329 OPC_CheckPredicate, 46, // 4315: check predicate 46
3330 OPC_CheckField, 15, 1, 1, // 4317: check Inst[15] == 0x1
3331 OPC_Decode, 132, 120, 36, // 4321: decode to PNCLIPI_H using decoder 36
3332 // 4321: }
3333 // 4321: } // switch Inst[25]
3334 // 4321: }
3335 25, 10, // 4325: case 0x19: {
3336 OPC_CheckPredicate, 46, // 4327: check predicate 46
3337 OPC_CheckField, 15, 1, 1, // 4329: check Inst[15] == 0x1
3338 OPC_Decode, 206, 117, 37, // 4333: decode to NCLIPI using decoder 37
3339 // 4333: }
3340 26, 27, // 4337: case 0x1a: {
3341 OPC_SwitchField, 25, 1, // 4339: switch Inst[25] {
3342 0, 10, // 4342: case 0x0: {
3343 OPC_CheckPredicate, 46, // 4344: check predicate 46
3344 OPC_CheckField, 15, 1, 1, // 4346: check Inst[15] == 0x1
3345 OPC_Decode, 149, 120, 38, // 4350: decode to PNCLIP_BS using decoder 38
3346 // 4350: }
3347 1, 0, // 4354: case 0x1: {
3348 OPC_CheckPredicate, 46, // 4356: check predicate 46
3349 OPC_CheckField, 15, 1, 1, // 4358: check Inst[15] == 0x1
3350 OPC_Decode, 150, 120, 38, // 4362: decode to PNCLIP_HS using decoder 38
3351 // 4362: }
3352 // 4362: } // switch Inst[25]
3353 // 4362: }
3354 27, 14, // 4366: case 0x1b: {
3355 OPC_CheckPredicate, 46, // 4368: check predicate 46
3356 OPC_CheckField, 25, 1, 1, // 4370: check Inst[25] == 0x1
3357 OPC_CheckField, 15, 1, 1, // 4374: check Inst[15] == 0x1
3358 OPC_Decode, 205, 117, 38, // 4378: decode to NCLIP using decoder 38
3359 // 4378: }
3360 28, 31, // 4382: case 0x1c: {
3361 OPC_SwitchField, 25, 1, // 4384: switch Inst[25] {
3362 0, 14, // 4387: case 0x0: {
3363 OPC_CheckPredicate, 46, // 4389: check predicate 46
3364 OPC_CheckField, 24, 1, 1, // 4391: check Inst[24] == 0x1
3365 OPC_CheckField, 15, 1, 1, // 4395: check Inst[15] == 0x1
3366 OPC_Decode, 138, 120, 35, // 4399: decode to PNCLIPRI_B using decoder 35
3367 // 4399: }
3368 1, 0, // 4403: case 0x1: {
3369 OPC_CheckPredicate, 46, // 4405: check predicate 46
3370 OPC_CheckField, 15, 1, 1, // 4407: check Inst[15] == 0x1
3371 OPC_Decode, 139, 120, 36, // 4411: decode to PNCLIPRI_H using decoder 36
3372 // 4411: }
3373 // 4411: } // switch Inst[25]
3374 // 4411: }
3375 29, 10, // 4415: case 0x1d: {
3376 OPC_CheckPredicate, 46, // 4417: check predicate 46
3377 OPC_CheckField, 15, 1, 1, // 4419: check Inst[15] == 0x1
3378 OPC_Decode, 209, 117, 37, // 4423: decode to NCLIPRI using decoder 37
3379 // 4423: }
3380 30, 27, // 4427: case 0x1e: {
3381 OPC_SwitchField, 25, 1, // 4429: switch Inst[25] {
3382 0, 10, // 4432: case 0x0: {
3383 OPC_CheckPredicate, 46, // 4434: check predicate 46
3384 OPC_CheckField, 15, 1, 1, // 4436: check Inst[15] == 0x1
3385 OPC_Decode, 142, 120, 38, // 4440: decode to PNCLIPR_BS using decoder 38
3386 // 4440: }
3387 1, 0, // 4444: case 0x1: {
3388 OPC_CheckPredicate, 46, // 4446: check predicate 46
3389 OPC_CheckField, 15, 1, 1, // 4448: check Inst[15] == 0x1
3390 OPC_Decode, 143, 120, 38, // 4452: decode to PNCLIPR_HS using decoder 38
3391 // 4452: }
3392 // 4452: } // switch Inst[25]
3393 // 4452: }
3394 31, 14, // 4456: case 0x1f: {
3395 OPC_CheckPredicate, 46, // 4458: check predicate 46
3396 OPC_CheckField, 25, 1, 1, // 4460: check Inst[25] == 0x1
3397 OPC_CheckField, 15, 1, 1, // 4464: check Inst[15] == 0x1
3398 OPC_Decode, 208, 117, 38, // 4468: decode to NCLIPR using decoder 38
3399 // 4468: }
3400 32, 36, // 4472: case 0x20: {
3401 OPC_SwitchField, 25, 1, // 4474: switch Inst[25] {
3402 0, 23, // 4477: case 0x0: {
3403 OPC_SwitchField, 24, 1, // 4479: switch Inst[24] {
3404 0, 10, // 4482: case 0x0: {
3405 OPC_CheckPredicate, 42, // 4484: check predicate 42
3406 OPC_CheckField, 23, 1, 1, // 4486: check Inst[23] == 0x1
3407 OPC_Decode, 131, 121, 30, // 4490: decode to PSRLI_B using decoder 30
3408 // 4490: }
3409 1, 0, // 4494: case 0x1: {
3410 OPC_CheckPredicate, 42, // 4496: check predicate 42
3411 OPC_Decode, 135, 121, 18, // 4498: decode to PSRLI_H using decoder 18
3412 // 4498: }
3413 // 4498: } // switch Inst[24]
3414 // 4498: }
3415 1, 0, // 4502: case 0x1: {
3416 OPC_CheckPredicate, 47, // 4504: check predicate 47
3417 OPC_Decode, 136, 121, 21, // 4506: decode to PSRLI_W using decoder 21
3418 // 4506: }
3419 // 4506: } // switch Inst[25]
3420 // 4506: }
3421 34, 19, // 4510: case 0x22: {
3422 OPC_SwitchField, 25, 1, // 4512: switch Inst[25] {
3423 0, 6, // 4515: case 0x0: {
3424 OPC_CheckPredicate, 42, // 4517: check predicate 42
3425 OPC_Decode, 141, 121, 31, // 4519: decode to PSRL_HS using decoder 31
3426 // 4519: }
3427 1, 0, // 4523: case 0x1: {
3428 OPC_CheckPredicate, 47, // 4525: check predicate 47
3429 OPC_Decode, 142, 121, 31, // 4527: decode to PSRL_WS using decoder 31
3430 // 4527: }
3431 // 4527: } // switch Inst[25]
3432 // 4527: }
3433 35, 10, // 4531: case 0x23: {
3434 OPC_CheckPredicate, 42, // 4533: check predicate 42
3435 OPC_CheckField, 25, 1, 0, // 4535: check Inst[25] == 0x0
3436 OPC_Decode, 137, 121, 31, // 4539: decode to PSRL_BS using decoder 31
3437 // 4539: }
3438 38, 19, // 4543: case 0x26: {
3439 OPC_SwitchField, 25, 1, // 4545: switch Inst[25] {
3440 0, 6, // 4548: case 0x0: {
3441 OPC_CheckPredicate, 42, // 4550: check predicate 42
3442 OPC_Decode, 190, 120, 31, // 4552: decode to PREDSUM_HS using decoder 31
3443 // 4552: }
3444 1, 0, // 4556: case 0x1: {
3445 OPC_CheckPredicate, 47, // 4558: check predicate 47
3446 OPC_Decode, 191, 120, 31, // 4560: decode to PREDSUM_WS using decoder 31
3447 // 4560: }
3448 // 4560: } // switch Inst[25]
3449 // 4560: }
3450 39, 10, // 4564: case 0x27: {
3451 OPC_CheckPredicate, 42, // 4566: check predicate 42
3452 OPC_CheckField, 25, 1, 0, // 4568: check Inst[25] == 0x0
3453 OPC_Decode, 187, 120, 31, // 4572: decode to PREDSUM_BS using decoder 31
3454 // 4572: }
3455 40, 23, // 4576: case 0x28: {
3456 OPC_SwitchField, 25, 1, // 4578: switch Inst[25] {
3457 0, 10, // 4581: case 0x0: {
3458 OPC_CheckPredicate, 42, // 4583: check predicate 42
3459 OPC_CheckField, 24, 1, 1, // 4585: check Inst[24] == 0x1
3460 OPC_Decode, 190, 121, 18, // 4589: decode to PUSATI_H using decoder 18
3461 // 4589: }
3462 1, 0, // 4593: case 0x1: {
3463 OPC_CheckPredicate, 47, // 4595: check predicate 47
3464 OPC_Decode, 191, 121, 21, // 4597: decode to PUSATI_W using decoder 21
3465 // 4597: }
3466 // 4597: } // switch Inst[25]
3467 // 4597: }
3468 41, 6, // 4601: case 0x29: {
3469 OPC_CheckPredicate, 47, // 4603: check predicate 47
3470 OPC_Decode, 199, 125, 39, // 4605: decode to USATI_RV64 using decoder 39
3471 // 4605: }
3472 46, 19, // 4609: case 0x2e: {
3473 OPC_SwitchField, 25, 1, // 4611: switch Inst[25] {
3474 0, 6, // 4614: case 0x0: {
3475 OPC_CheckPredicate, 42, // 4616: check predicate 42
3476 OPC_Decode, 185, 120, 31, // 4618: decode to PREDSUMU_HS using decoder 31
3477 // 4618: }
3478 1, 0, // 4622: case 0x1: {
3479 OPC_CheckPredicate, 47, // 4624: check predicate 47
3480 OPC_Decode, 186, 120, 31, // 4626: decode to PREDSUMU_WS using decoder 31
3481 // 4626: }
3482 // 4626: } // switch Inst[25]
3483 // 4626: }
3484 47, 10, // 4630: case 0x2f: {
3485 OPC_CheckPredicate, 42, // 4632: check predicate 42
3486 OPC_CheckField, 25, 1, 0, // 4634: check Inst[25] == 0x0
3487 OPC_Decode, 182, 120, 31, // 4638: decode to PREDSUMU_BS using decoder 31
3488 // 4638: }
3489 48, 36, // 4642: case 0x30: {
3490 OPC_SwitchField, 25, 1, // 4644: switch Inst[25] {
3491 0, 23, // 4647: case 0x0: {
3492 OPC_SwitchField, 24, 1, // 4649: switch Inst[24] {
3493 0, 10, // 4652: case 0x0: {
3494 OPC_CheckPredicate, 42, // 4654: check predicate 42
3495 OPC_CheckField, 23, 1, 1, // 4656: check Inst[23] == 0x1
3496 OPC_Decode, 243, 120, 30, // 4660: decode to PSRAI_B using decoder 30
3497 // 4660: }
3498 1, 0, // 4664: case 0x1: {
3499 OPC_CheckPredicate, 42, // 4666: check predicate 42
3500 OPC_Decode, 247, 120, 18, // 4668: decode to PSRAI_H using decoder 18
3501 // 4668: }
3502 // 4668: } // switch Inst[24]
3503 // 4668: }
3504 1, 0, // 4672: case 0x1: {
3505 OPC_CheckPredicate, 47, // 4674: check predicate 47
3506 OPC_Decode, 248, 120, 21, // 4676: decode to PSRAI_W using decoder 21
3507 // 4676: }
3508 // 4676: } // switch Inst[25]
3509 // 4676: }
3510 50, 19, // 4680: case 0x32: {
3511 OPC_SwitchField, 25, 1, // 4682: switch Inst[25] {
3512 0, 6, // 4685: case 0x0: {
3513 OPC_CheckPredicate, 42, // 4687: check predicate 42
3514 OPC_Decode, 129, 121, 31, // 4689: decode to PSRA_HS using decoder 31
3515 // 4689: }
3516 1, 0, // 4693: case 0x1: {
3517 OPC_CheckPredicate, 47, // 4695: check predicate 47
3518 OPC_Decode, 130, 121, 31, // 4697: decode to PSRA_WS using decoder 31
3519 // 4697: }
3520 // 4697: } // switch Inst[25]
3521 // 4697: }
3522 51, 10, // 4701: case 0x33: {
3523 OPC_CheckPredicate, 42, // 4703: check predicate 42
3524 OPC_CheckField, 25, 1, 0, // 4705: check Inst[25] == 0x0
3525 OPC_Decode, 253, 120, 31, // 4709: decode to PSRA_BS using decoder 31
3526 // 4709: }
3527 52, 23, // 4713: case 0x34: {
3528 OPC_SwitchField, 25, 1, // 4715: switch Inst[25] {
3529 0, 10, // 4718: case 0x0: {
3530 OPC_CheckPredicate, 42, // 4720: check predicate 42
3531 OPC_CheckField, 24, 1, 1, // 4722: check Inst[24] == 0x1
3532 OPC_Decode, 251, 120, 18, // 4726: decode to PSRARI_H using decoder 18
3533 // 4726: }
3534 1, 0, // 4730: case 0x1: {
3535 OPC_CheckPredicate, 47, // 4732: check predicate 47
3536 OPC_Decode, 252, 120, 21, // 4734: decode to PSRARI_W using decoder 21
3537 // 4734: }
3538 // 4734: } // switch Inst[25]
3539 // 4734: }
3540 53, 6, // 4738: case 0x35: {
3541 OPC_CheckPredicate, 47, // 4740: check predicate 47
3542 OPC_Decode, 176, 124, 39, // 4742: decode to SRARI_RV64 using decoder 39
3543 // 4742: }
3544 56, 23, // 4746: case 0x38: {
3545 OPC_SwitchField, 25, 1, // 4748: switch Inst[25] {
3546 0, 10, // 4751: case 0x0: {
3547 OPC_CheckPredicate, 42, // 4753: check predicate 42
3548 OPC_CheckField, 24, 1, 1, // 4755: check Inst[24] == 0x1
3549 OPC_Decode, 216, 120, 40, // 4759: decode to PSATI_H using decoder 40
3550 // 4759: }
3551 1, 0, // 4763: case 0x1: {
3552 OPC_CheckPredicate, 47, // 4765: check predicate 47
3553 OPC_Decode, 217, 120, 41, // 4767: decode to PSATI_W using decoder 41
3554 // 4767: }
3555 // 4767: } // switch Inst[25]
3556 // 4767: }
3557 57, 0, // 4771: case 0x39: {
3558 OPC_CheckPredicate, 47, // 4773: check predicate 47
3559 OPC_Decode, 151, 123, 42, // 4775: decode to SATI_RV64 using decoder 42
3560 // 4775: }
3561 // 4775: } // switch Inst[31:26]
3562 // 4775: }
3563 5, 27, // 4779: case 0x5: {
3564 OPC_SwitchField, 25, 7, // 4781: switch Inst[31:25] {
3565 0, 6, // 4784: case 0x0: {
3566 OPC_CheckPredicate, 21, // 4786: check predicate 21
3567 OPC_Decode, 181, 124, 21, // 4788: decode to SRLIW using decoder 21
3568 // 4788: }
3569 32, 6, // 4792: case 0x20: {
3570 OPC_CheckPredicate, 21, // 4794: check predicate 21
3571 OPC_Decode, 174, 124, 21, // 4796: decode to SRAIW using decoder 21
3572 // 4796: }
3573 48, 0, // 4800: case 0x30: {
3574 OPC_CheckPredicate, 48, // 4802: check predicate 48
3575 OPC_Decode, 146, 123, 21, // 4804: decode to RORIW using decoder 21
3576 // 4804: }
3577 // 4804: } // switch Inst[31:25]
3578 // 4804: }
3579 6, 0, // 4808: case 0x6: {
3580 OPC_SwitchField, 25, 7, // 4810: switch Inst[31:25] {
3581 0, 69, // 4813: case 0x0: {
3582 OPC_SwitchField, 15, 1, // 4815: switch Inst[15] {
3583 0, 31, // 4818: case 0x0: {
3584 OPC_SwitchField, 24, 1, // 4820: switch Inst[24] {
3585 0, 14, // 4823: case 0x0: {
3586 OPC_CheckPredicate, 46, // 4825: check predicate 46
3587 OPC_CheckField, 23, 1, 1, // 4827: check Inst[23] == 0x1
3588 OPC_CheckField, 7, 1, 0, // 4831: check Inst[7] == 0x0
3589 OPC_Decode, 232, 120, 43, // 4835: decode to PSLLI_DB using decoder 43
3590 // 4835: }
3591 1, 0, // 4839: case 0x1: {
3592 OPC_CheckPredicate, 46, // 4841: check predicate 46
3593 OPC_CheckField, 7, 1, 0, // 4843: check Inst[7] == 0x0
3594 OPC_Decode, 233, 120, 44, // 4847: decode to PSLLI_DH using decoder 44
3595 // 4847: }
3596 // 4847: } // switch Inst[24]
3597 // 4847: }
3598 1, 0, // 4851: case 0x1: {
3599 OPC_SwitchField, 24, 1, // 4853: switch Inst[24] {
3600 0, 14, // 4856: case 0x0: {
3601 OPC_CheckPredicate, 46, // 4858: check predicate 46
3602 OPC_CheckField, 23, 1, 1, // 4860: check Inst[23] == 0x1
3603 OPC_CheckField, 7, 1, 0, // 4864: check Inst[7] == 0x0
3604 OPC_Decode, 132, 121, 43, // 4868: decode to PSRLI_DB using decoder 43
3605 // 4868: }
3606 1, 0, // 4872: case 0x1: {
3607 OPC_CheckPredicate, 46, // 4874: check predicate 46
3608 OPC_CheckField, 7, 1, 0, // 4876: check Inst[7] == 0x0
3609 OPC_Decode, 133, 121, 44, // 4880: decode to PSRLI_DH using decoder 44
3610 // 4880: }
3611 // 4880: } // switch Inst[24]
3612 // 4880: }
3613 // 4880: } // switch Inst[15]
3614 // 4880: }
3615 1, 27, // 4884: case 0x1: {
3616 OPC_SwitchField, 15, 1, // 4886: switch Inst[15] {
3617 0, 10, // 4889: case 0x0: {
3618 OPC_CheckPredicate, 46, // 4891: check predicate 46
3619 OPC_CheckField, 7, 1, 0, // 4893: check Inst[7] == 0x0
3620 OPC_Decode, 234, 120, 45, // 4897: decode to PSLLI_DW using decoder 45
3621 // 4897: }
3622 1, 0, // 4901: case 0x1: {
3623 OPC_CheckPredicate, 46, // 4903: check predicate 46
3624 OPC_CheckField, 7, 1, 0, // 4905: check Inst[7] == 0x0
3625 OPC_Decode, 134, 121, 45, // 4909: decode to PSRLI_DW using decoder 45
3626 // 4909: }
3627 // 4909: } // switch Inst[15]
3628 // 4909: }
3629 4, 27, // 4913: case 0x4: {
3630 OPC_SwitchField, 15, 1, // 4915: switch Inst[15] {
3631 0, 10, // 4918: case 0x0: {
3632 OPC_CheckPredicate, 46, // 4920: check predicate 46
3633 OPC_CheckField, 7, 1, 0, // 4922: check Inst[7] == 0x0
3634 OPC_Decode, 239, 120, 46, // 4926: decode to PSLL_DHS using decoder 46
3635 // 4926: }
3636 1, 0, // 4930: case 0x1: {
3637 OPC_CheckPredicate, 46, // 4932: check predicate 46
3638 OPC_CheckField, 7, 1, 0, // 4934: check Inst[7] == 0x0
3639 OPC_Decode, 139, 121, 46, // 4938: decode to PSRL_DHS using decoder 46
3640 // 4938: }
3641 // 4938: } // switch Inst[15]
3642 // 4938: }
3643 5, 27, // 4942: case 0x5: {
3644 OPC_SwitchField, 15, 1, // 4944: switch Inst[15] {
3645 0, 10, // 4947: case 0x0: {
3646 OPC_CheckPredicate, 46, // 4949: check predicate 46
3647 OPC_CheckField, 7, 1, 0, // 4951: check Inst[7] == 0x0
3648 OPC_Decode, 240, 120, 46, // 4955: decode to PSLL_DWS using decoder 46
3649 // 4955: }
3650 1, 0, // 4959: case 0x1: {
3651 OPC_CheckPredicate, 46, // 4961: check predicate 46
3652 OPC_CheckField, 7, 1, 0, // 4963: check Inst[7] == 0x0
3653 OPC_Decode, 140, 121, 46, // 4967: decode to PSRL_DWS using decoder 46
3654 // 4967: }
3655 // 4967: } // switch Inst[15]
3656 // 4967: }
3657 6, 27, // 4971: case 0x6: {
3658 OPC_SwitchField, 15, 1, // 4973: switch Inst[15] {
3659 0, 10, // 4976: case 0x0: {
3660 OPC_CheckPredicate, 46, // 4978: check predicate 46
3661 OPC_CheckField, 7, 1, 0, // 4980: check Inst[7] == 0x0
3662 OPC_Decode, 238, 120, 46, // 4984: decode to PSLL_DBS using decoder 46
3663 // 4984: }
3664 1, 0, // 4988: case 0x1: {
3665 OPC_CheckPredicate, 46, // 4990: check predicate 46
3666 OPC_CheckField, 7, 1, 0, // 4992: check Inst[7] == 0x0
3667 OPC_Decode, 138, 121, 46, // 4996: decode to PSRL_DBS using decoder 46
3668 // 4996: }
3669 // 4996: } // switch Inst[15]
3670 // 4996: }
3671 12, 14, // 5000: case 0xc: {
3672 OPC_CheckPredicate, 46, // 5002: check predicate 46
3673 OPC_CheckField, 15, 1, 0, // 5004: check Inst[15] == 0x0
3674 OPC_CheckField, 7, 1, 0, // 5008: check Inst[7] == 0x0
3675 OPC_Decode, 176, 118, 46, // 5012: decode to PADD_DHS using decoder 46
3676 // 5012: }
3677 13, 14, // 5016: case 0xd: {
3678 OPC_CheckPredicate, 46, // 5018: check predicate 46
3679 OPC_CheckField, 15, 1, 0, // 5020: check Inst[15] == 0x0
3680 OPC_CheckField, 7, 1, 0, // 5024: check Inst[7] == 0x0
3681 OPC_Decode, 178, 118, 46, // 5028: decode to PADD_DWS using decoder 46
3682 // 5028: }
3683 14, 14, // 5032: case 0xe: {
3684 OPC_CheckPredicate, 46, // 5034: check predicate 46
3685 OPC_CheckField, 15, 1, 0, // 5036: check Inst[15] == 0x0
3686 OPC_CheckField, 7, 1, 0, // 5040: check Inst[7] == 0x0
3687 OPC_Decode, 174, 118, 46, // 5044: decode to PADD_DBS using decoder 46
3688 // 5044: }
3689 16, 18, // 5048: case 0x10: {
3690 OPC_CheckPredicate, 46, // 5050: check predicate 46
3691 OPC_CheckField, 24, 1, 1, // 5052: check Inst[24] == 0x1
3692 OPC_CheckField, 15, 1, 1, // 5056: check Inst[15] == 0x1
3693 OPC_CheckField, 7, 1, 0, // 5060: check Inst[7] == 0x0
3694 OPC_Decode, 188, 121, 44, // 5064: decode to PUSATI_DH using decoder 44
3695 // 5064: }
3696 17, 14, // 5068: case 0x11: {
3697 OPC_CheckPredicate, 46, // 5070: check predicate 46
3698 OPC_CheckField, 15, 1, 1, // 5072: check Inst[15] == 0x1
3699 OPC_CheckField, 7, 1, 0, // 5076: check Inst[7] == 0x0
3700 OPC_Decode, 189, 121, 45, // 5080: decode to PUSATI_DW using decoder 45
3701 // 5080: }
3702 20, 14, // 5084: case 0x14: {
3703 OPC_CheckPredicate, 46, // 5086: check predicate 46
3704 OPC_CheckField, 15, 1, 0, // 5088: check Inst[15] == 0x0
3705 OPC_CheckField, 7, 1, 0, // 5092: check Inst[7] == 0x0
3706 OPC_Decode, 162, 121, 46, // 5096: decode to PSSHL_DHS using decoder 46
3707 // 5096: }
3708 21, 14, // 5100: case 0x15: {
3709 OPC_CheckPredicate, 46, // 5102: check predicate 46
3710 OPC_CheckField, 15, 1, 0, // 5104: check Inst[15] == 0x0
3711 OPC_CheckField, 7, 1, 0, // 5108: check Inst[7] == 0x0
3712 OPC_Decode, 163, 121, 46, // 5112: decode to PSSHL_DWS using decoder 46
3713 // 5112: }
3714 28, 14, // 5116: case 0x1c: {
3715 OPC_CheckPredicate, 46, // 5118: check predicate 46
3716 OPC_CheckField, 15, 1, 0, // 5120: check Inst[15] == 0x0
3717 OPC_CheckField, 7, 1, 0, // 5124: check Inst[7] == 0x0
3718 OPC_Decode, 158, 121, 46, // 5128: decode to PSSHLR_DHS using decoder 46
3719 // 5128: }
3720 29, 14, // 5132: case 0x1d: {
3721 OPC_CheckPredicate, 46, // 5134: check predicate 46
3722 OPC_CheckField, 15, 1, 0, // 5136: check Inst[15] == 0x0
3723 OPC_CheckField, 7, 1, 0, // 5140: check Inst[7] == 0x0
3724 OPC_Decode, 159, 121, 46, // 5144: decode to PSSHLR_DWS using decoder 46
3725 // 5144: }
3726 32, 39, // 5148: case 0x20: {
3727 OPC_SwitchField, 24, 1, // 5150: switch Inst[24] {
3728 0, 18, // 5153: case 0x0: {
3729 OPC_CheckPredicate, 46, // 5155: check predicate 46
3730 OPC_CheckField, 23, 1, 1, // 5157: check Inst[23] == 0x1
3731 OPC_CheckField, 15, 1, 1, // 5161: check Inst[15] == 0x1
3732 OPC_CheckField, 7, 1, 0, // 5165: check Inst[7] == 0x0
3733 OPC_Decode, 244, 120, 43, // 5169: decode to PSRAI_DB using decoder 43
3734 // 5169: }
3735 1, 0, // 5173: case 0x1: {
3736 OPC_CheckPredicate, 46, // 5175: check predicate 46
3737 OPC_CheckField, 15, 1, 1, // 5177: check Inst[15] == 0x1
3738 OPC_CheckField, 7, 1, 0, // 5181: check Inst[7] == 0x0
3739 OPC_Decode, 245, 120, 44, // 5185: decode to PSRAI_DH using decoder 44
3740 // 5185: }
3741 // 5185: } // switch Inst[24]
3742 // 5185: }
3743 33, 14, // 5189: case 0x21: {
3744 OPC_CheckPredicate, 46, // 5191: check predicate 46
3745 OPC_CheckField, 15, 1, 1, // 5193: check Inst[15] == 0x1
3746 OPC_CheckField, 7, 1, 0, // 5197: check Inst[7] == 0x0
3747 OPC_Decode, 246, 120, 45, // 5201: decode to PSRAI_DW using decoder 45
3748 // 5201: }
3749 36, 14, // 5205: case 0x24: {
3750 OPC_CheckPredicate, 46, // 5207: check predicate 46
3751 OPC_CheckField, 15, 1, 1, // 5209: check Inst[15] == 0x1
3752 OPC_CheckField, 7, 1, 0, // 5213: check Inst[7] == 0x0
3753 OPC_Decode, 255, 120, 46, // 5217: decode to PSRA_DHS using decoder 46
3754 // 5217: }
3755 37, 14, // 5221: case 0x25: {
3756 OPC_CheckPredicate, 46, // 5223: check predicate 46
3757 OPC_CheckField, 15, 1, 1, // 5225: check Inst[15] == 0x1
3758 OPC_CheckField, 7, 1, 0, // 5229: check Inst[7] == 0x0
3759 OPC_Decode, 128, 121, 46, // 5233: decode to PSRA_DWS using decoder 46
3760 // 5233: }
3761 38, 14, // 5237: case 0x26: {
3762 OPC_CheckPredicate, 46, // 5239: check predicate 46
3763 OPC_CheckField, 15, 1, 1, // 5241: check Inst[15] == 0x1
3764 OPC_CheckField, 7, 1, 0, // 5245: check Inst[7] == 0x0
3765 OPC_Decode, 254, 120, 46, // 5249: decode to PSRA_DBS using decoder 46
3766 // 5249: }
3767 40, 35, // 5253: case 0x28: {
3768 OPC_SwitchField, 15, 1, // 5255: switch Inst[15] {
3769 0, 14, // 5258: case 0x0: {
3770 OPC_CheckPredicate, 46, // 5260: check predicate 46
3771 OPC_CheckField, 24, 1, 1, // 5262: check Inst[24] == 0x1
3772 OPC_CheckField, 7, 1, 0, // 5266: check Inst[7] == 0x0
3773 OPC_Decode, 166, 121, 44, // 5270: decode to PSSLAI_DH using decoder 44
3774 // 5270: }
3775 1, 0, // 5274: case 0x1: {
3776 OPC_CheckPredicate, 46, // 5276: check predicate 46
3777 OPC_CheckField, 24, 1, 1, // 5278: check Inst[24] == 0x1
3778 OPC_CheckField, 7, 1, 0, // 5282: check Inst[7] == 0x0
3779 OPC_Decode, 249, 120, 44, // 5286: decode to PSRARI_DH using decoder 44
3780 // 5286: }
3781 // 5286: } // switch Inst[15]
3782 // 5286: }
3783 41, 27, // 5290: case 0x29: {
3784 OPC_SwitchField, 15, 1, // 5292: switch Inst[15] {
3785 0, 10, // 5295: case 0x0: {
3786 OPC_CheckPredicate, 46, // 5297: check predicate 46
3787 OPC_CheckField, 7, 1, 0, // 5299: check Inst[7] == 0x0
3788 OPC_Decode, 167, 121, 45, // 5303: decode to PSSLAI_DW using decoder 45
3789 // 5303: }
3790 1, 0, // 5307: case 0x1: {
3791 OPC_CheckPredicate, 46, // 5309: check predicate 46
3792 OPC_CheckField, 7, 1, 0, // 5311: check Inst[7] == 0x0
3793 OPC_Decode, 250, 120, 45, // 5315: decode to PSRARI_DW using decoder 45
3794 // 5315: }
3795 // 5315: } // switch Inst[15]
3796 // 5315: }
3797 48, 48, // 5319: case 0x30: {
3798 OPC_SwitchField, 15, 1, // 5321: switch Inst[15] {
3799 0, 27, // 5324: case 0x0: {
3800 OPC_SwitchField, 20, 5, // 5326: switch Inst[24:20] {
3801 4, 10, // 5329: case 0x4: {
3802 OPC_CheckPredicate, 46, // 5331: check predicate 46
3803 OPC_CheckField, 7, 1, 0, // 5333: check Inst[7] == 0x0
3804 OPC_Decode, 221, 120, 47, // 5337: decode to PSEXT_DH_B using decoder 47
3805 // 5337: }
3806 7, 0, // 5341: case 0x7: {
3807 OPC_CheckPredicate, 46, // 5343: check predicate 46
3808 OPC_CheckField, 7, 1, 0, // 5345: check Inst[7] == 0x0
3809 OPC_Decode, 197, 120, 47, // 5349: decode to PSABS_DH using decoder 47
3810 // 5349: }
3811 // 5349: } // switch Inst[24:20]
3812 // 5349: }
3813 1, 0, // 5353: case 0x1: {
3814 OPC_CheckPredicate, 46, // 5355: check predicate 46
3815 OPC_CheckField, 24, 1, 1, // 5357: check Inst[24] == 0x1
3816 OPC_CheckField, 7, 1, 0, // 5361: check Inst[7] == 0x0
3817 OPC_Decode, 214, 120, 44, // 5365: decode to PSATI_DH using decoder 44
3818 // 5365: }
3819 // 5365: } // switch Inst[15]
3820 // 5365: }
3821 49, 44, // 5369: case 0x31: {
3822 OPC_SwitchField, 15, 1, // 5371: switch Inst[15] {
3823 0, 27, // 5374: case 0x0: {
3824 OPC_SwitchField, 20, 5, // 5376: switch Inst[24:20] {
3825 4, 10, // 5379: case 0x4: {
3826 OPC_CheckPredicate, 46, // 5381: check predicate 46
3827 OPC_CheckField, 7, 1, 0, // 5383: check Inst[7] == 0x0
3828 OPC_Decode, 222, 120, 47, // 5387: decode to PSEXT_DW_B using decoder 47
3829 // 5387: }
3830 5, 0, // 5391: case 0x5: {
3831 OPC_CheckPredicate, 46, // 5393: check predicate 46
3832 OPC_CheckField, 7, 1, 0, // 5395: check Inst[7] == 0x0
3833 OPC_Decode, 223, 120, 47, // 5399: decode to PSEXT_DW_H using decoder 47
3834 // 5399: }
3835 // 5399: } // switch Inst[24:20]
3836 // 5399: }
3837 1, 0, // 5403: case 0x1: {
3838 OPC_CheckPredicate, 46, // 5405: check predicate 46
3839 OPC_CheckField, 7, 1, 0, // 5407: check Inst[7] == 0x0
3840 OPC_Decode, 215, 120, 45, // 5411: decode to PSATI_DW using decoder 45
3841 // 5411: }
3842 // 5411: } // switch Inst[15]
3843 // 5411: }
3844 50, 18, // 5415: case 0x32: {
3845 OPC_CheckPredicate, 46, // 5417: check predicate 46
3846 OPC_CheckField, 20, 5, 7, // 5419: check Inst[24:20] == 0x7
3847 OPC_CheckField, 15, 1, 0, // 5423: check Inst[15] == 0x0
3848 OPC_CheckField, 7, 1, 0, // 5427: check Inst[7] == 0x0
3849 OPC_Decode, 196, 120, 47, // 5431: decode to PSABS_DB using decoder 47
3850 // 5431: }
3851 52, 14, // 5435: case 0x34: {
3852 OPC_CheckPredicate, 46, // 5437: check predicate 46
3853 OPC_CheckField, 15, 1, 0, // 5439: check Inst[15] == 0x0
3854 OPC_CheckField, 7, 1, 0, // 5443: check Inst[7] == 0x0
3855 OPC_Decode, 154, 121, 46, // 5447: decode to PSSHA_DHS using decoder 46
3856 // 5447: }
3857 53, 14, // 5451: case 0x35: {
3858 OPC_CheckPredicate, 46, // 5453: check predicate 46
3859 OPC_CheckField, 15, 1, 0, // 5455: check Inst[15] == 0x0
3860 OPC_CheckField, 7, 1, 0, // 5459: check Inst[7] == 0x0
3861 OPC_Decode, 155, 121, 46, // 5463: decode to PSSHA_DWS using decoder 46
3862 // 5463: }
3863 60, 14, // 5467: case 0x3c: {
3864 OPC_CheckPredicate, 46, // 5469: check predicate 46
3865 OPC_CheckField, 15, 1, 0, // 5471: check Inst[15] == 0x0
3866 OPC_CheckField, 7, 1, 0, // 5475: check Inst[7] == 0x0
3867 OPC_Decode, 150, 121, 46, // 5479: decode to PSSHAR_DHS using decoder 46
3868 // 5479: }
3869 61, 14, // 5483: case 0x3d: {
3870 OPC_CheckPredicate, 46, // 5485: check predicate 46
3871 OPC_CheckField, 15, 1, 0, // 5487: check Inst[15] == 0x0
3872 OPC_CheckField, 7, 1, 0, // 5491: check Inst[7] == 0x0
3873 OPC_Decode, 151, 121, 46, // 5495: decode to PSSHAR_DWS using decoder 46
3874 // 5495: }
3875 64, 48, // 5499: case 0x40: {
3876 OPC_SwitchField, 15, 1, // 5501: switch Inst[15] {
3877 0, 14, // 5504: case 0x0: {
3878 OPC_CheckPredicate, 46, // 5506: check predicate 46
3879 OPC_CheckField, 20, 1, 0, // 5508: check Inst[20] == 0x0
3880 OPC_CheckField, 7, 1, 0, // 5512: check Inst[7] == 0x0
3881 OPC_Decode, 175, 118, 48, // 5516: decode to PADD_DH using decoder 48
3882 // 5516: }
3883 1, 0, // 5520: case 0x1: {
3884 OPC_SwitchField, 20, 1, // 5522: switch Inst[20] {
3885 0, 10, // 5525: case 0x0: {
3886 OPC_CheckPredicate, 46, // 5527: check predicate 46
3887 OPC_CheckField, 7, 1, 0, // 5529: check Inst[7] == 0x0
3888 OPC_Decode, 169, 120, 48, // 5533: decode to PPAIRE_DB using decoder 48
3889 // 5533: }
3890 1, 0, // 5537: case 0x1: {
3891 OPC_CheckPredicate, 46, // 5539: check predicate 46
3892 OPC_CheckField, 7, 1, 0, // 5541: check Inst[7] == 0x0
3893 OPC_Decode, 198, 118, 48, // 5545: decode to PAS_DHX using decoder 48
3894 // 5545: }
3895 // 5545: } // switch Inst[20]
3896 // 5545: }
3897 // 5545: } // switch Inst[15]
3898 // 5545: }
3899 65, 35, // 5549: case 0x41: {
3900 OPC_SwitchField, 15, 1, // 5551: switch Inst[15] {
3901 0, 14, // 5554: case 0x0: {
3902 OPC_CheckPredicate, 46, // 5556: check predicate 46
3903 OPC_CheckField, 20, 1, 0, // 5558: check Inst[20] == 0x0
3904 OPC_CheckField, 7, 1, 0, // 5562: check Inst[7] == 0x0
3905 OPC_Decode, 177, 118, 48, // 5566: decode to PADD_DW using decoder 48
3906 // 5566: }
3907 1, 0, // 5570: case 0x1: {
3908 OPC_CheckPredicate, 46, // 5572: check predicate 46
3909 OPC_CheckField, 20, 1, 0, // 5574: check Inst[20] == 0x0
3910 OPC_CheckField, 7, 1, 0, // 5578: check Inst[7] == 0x0
3911 OPC_Decode, 170, 120, 48, // 5582: decode to PPAIRE_DH using decoder 48
3912 // 5582: }
3913 // 5582: } // switch Inst[15]
3914 // 5582: }
3915 66, 35, // 5586: case 0x42: {
3916 OPC_SwitchField, 15, 1, // 5588: switch Inst[15] {
3917 0, 14, // 5591: case 0x0: {
3918 OPC_CheckPredicate, 46, // 5593: check predicate 46
3919 OPC_CheckField, 20, 1, 0, // 5595: check Inst[20] == 0x0
3920 OPC_CheckField, 7, 1, 0, // 5599: check Inst[7] == 0x0
3921 OPC_Decode, 173, 118, 48, // 5603: decode to PADD_DB using decoder 48
3922 // 5603: }
3923 1, 0, // 5607: case 0x1: {
3924 OPC_CheckPredicate, 46, // 5609: check predicate 46
3925 OPC_CheckField, 20, 1, 1, // 5611: check Inst[20] == 0x1
3926 OPC_CheckField, 7, 1, 0, // 5615: check Inst[7] == 0x0
3927 OPC_Decode, 218, 120, 48, // 5619: decode to PSA_DHX using decoder 48
3928 // 5619: }
3929 // 5619: } // switch Inst[15]
3930 // 5619: }
3931 67, 18, // 5623: case 0x43: {
3932 OPC_CheckPredicate, 46, // 5625: check predicate 46
3933 OPC_CheckField, 20, 1, 0, // 5627: check Inst[20] == 0x0
3934 OPC_CheckField, 15, 1, 0, // 5631: check Inst[15] == 0x0
3935 OPC_CheckField, 7, 1, 0, // 5635: check Inst[7] == 0x0
3936 OPC_Decode, 160, 107, 48, // 5639: decode to ADDD using decoder 48
3937 // 5639: }
3938 72, 48, // 5643: case 0x48: {
3939 OPC_SwitchField, 15, 1, // 5645: switch Inst[15] {
3940 0, 14, // 5648: case 0x0: {
3941 OPC_CheckPredicate, 46, // 5650: check predicate 46
3942 OPC_CheckField, 20, 1, 0, // 5652: check Inst[20] == 0x0
3943 OPC_CheckField, 7, 1, 0, // 5656: check Inst[7] == 0x0
3944 OPC_Decode, 207, 120, 48, // 5660: decode to PSADD_DH using decoder 48
3945 // 5660: }
3946 1, 0, // 5664: case 0x1: {
3947 OPC_SwitchField, 20, 1, // 5666: switch Inst[20] {
3948 0, 10, // 5669: case 0x0: {
3949 OPC_CheckPredicate, 46, // 5671: check predicate 46
3950 OPC_CheckField, 7, 1, 0, // 5673: check Inst[7] == 0x0
3951 OPC_Decode, 164, 120, 48, // 5677: decode to PPAIREO_DB using decoder 48
3952 // 5677: }
3953 1, 0, // 5681: case 0x1: {
3954 OPC_CheckPredicate, 46, // 5683: check predicate 46
3955 OPC_CheckField, 7, 1, 0, // 5685: check Inst[7] == 0x0
3956 OPC_Decode, 211, 120, 48, // 5689: decode to PSAS_DHX using decoder 48
3957 // 5689: }
3958 // 5689: } // switch Inst[20]
3959 // 5689: }
3960 // 5689: } // switch Inst[15]
3961 // 5689: }
3962 73, 35, // 5693: case 0x49: {
3963 OPC_SwitchField, 15, 1, // 5695: switch Inst[15] {
3964 0, 14, // 5698: case 0x0: {
3965 OPC_CheckPredicate, 46, // 5700: check predicate 46
3966 OPC_CheckField, 20, 1, 0, // 5702: check Inst[20] == 0x0
3967 OPC_CheckField, 7, 1, 0, // 5706: check Inst[7] == 0x0
3968 OPC_Decode, 208, 120, 48, // 5710: decode to PSADD_DW using decoder 48
3969 // 5710: }
3970 1, 0, // 5714: case 0x1: {
3971 OPC_CheckPredicate, 46, // 5716: check predicate 46
3972 OPC_CheckField, 20, 1, 0, // 5718: check Inst[20] == 0x0
3973 OPC_CheckField, 7, 1, 0, // 5722: check Inst[7] == 0x0
3974 OPC_Decode, 165, 120, 48, // 5726: decode to PPAIREO_DH using decoder 48
3975 // 5726: }
3976 // 5726: } // switch Inst[15]
3977 // 5726: }
3978 74, 35, // 5730: case 0x4a: {
3979 OPC_SwitchField, 15, 1, // 5732: switch Inst[15] {
3980 0, 14, // 5735: case 0x0: {
3981 OPC_CheckPredicate, 46, // 5737: check predicate 46
3982 OPC_CheckField, 20, 1, 0, // 5739: check Inst[20] == 0x0
3983 OPC_CheckField, 7, 1, 0, // 5743: check Inst[7] == 0x0
3984 OPC_Decode, 206, 120, 48, // 5747: decode to PSADD_DB using decoder 48
3985 // 5747: }
3986 1, 0, // 5751: case 0x1: {
3987 OPC_CheckPredicate, 46, // 5753: check predicate 46
3988 OPC_CheckField, 20, 1, 1, // 5755: check Inst[20] == 0x1
3989 OPC_CheckField, 7, 1, 0, // 5759: check Inst[7] == 0x0
3990 OPC_Decode, 143, 121, 48, // 5763: decode to PSSA_DHX using decoder 48
3991 // 5763: }
3992 // 5763: } // switch Inst[15]
3993 // 5763: }
3994 76, 35, // 5767: case 0x4c: {
3995 OPC_SwitchField, 15, 1, // 5769: switch Inst[15] {
3996 0, 14, // 5772: case 0x0: {
3997 OPC_CheckPredicate, 46, // 5774: check predicate 46
3998 OPC_CheckField, 20, 1, 0, // 5776: check Inst[20] == 0x0
3999 OPC_CheckField, 7, 1, 0, // 5780: check Inst[7] == 0x0
4000 OPC_Decode, 150, 118, 48, // 5784: decode to PAADD_DH using decoder 48
4001 // 5784: }
4002 1, 0, // 5788: case 0x1: {
4003 OPC_CheckPredicate, 46, // 5790: check predicate 46
4004 OPC_CheckField, 20, 1, 1, // 5792: check Inst[20] == 0x1
4005 OPC_CheckField, 7, 1, 0, // 5796: check Inst[7] == 0x0
4006 OPC_Decode, 154, 118, 48, // 5800: decode to PAAS_DHX using decoder 48
4007 // 5800: }
4008 // 5800: } // switch Inst[15]
4009 // 5800: }
4010 77, 18, // 5804: case 0x4d: {
4011 OPC_CheckPredicate, 46, // 5806: check predicate 46
4012 OPC_CheckField, 20, 1, 0, // 5808: check Inst[20] == 0x0
4013 OPC_CheckField, 15, 1, 0, // 5812: check Inst[15] == 0x0
4014 OPC_CheckField, 7, 1, 0, // 5816: check Inst[7] == 0x0
4015 OPC_Decode, 151, 118, 48, // 5820: decode to PAADD_DW using decoder 48
4016 // 5820: }
4017 78, 35, // 5824: case 0x4e: {
4018 OPC_SwitchField, 15, 1, // 5826: switch Inst[15] {
4019 0, 14, // 5829: case 0x0: {
4020 OPC_CheckPredicate, 46, // 5831: check predicate 46
4021 OPC_CheckField, 20, 1, 0, // 5833: check Inst[20] == 0x0
4022 OPC_CheckField, 7, 1, 0, // 5837: check Inst[7] == 0x0
4023 OPC_Decode, 149, 118, 48, // 5841: decode to PAADD_DB using decoder 48
4024 // 5841: }
4025 1, 0, // 5845: case 0x1: {
4026 OPC_CheckPredicate, 46, // 5847: check predicate 46
4027 OPC_CheckField, 20, 1, 1, // 5849: check Inst[20] == 0x1
4028 OPC_CheckField, 7, 1, 0, // 5853: check Inst[7] == 0x0
4029 OPC_Decode, 183, 118, 48, // 5857: decode to PASA_DHX using decoder 48
4030 // 5857: }
4031 // 5857: } // switch Inst[15]
4032 // 5857: }
4033 80, 35, // 5861: case 0x50: {
4034 OPC_SwitchField, 15, 1, // 5863: switch Inst[15] {
4035 0, 14, // 5866: case 0x0: {
4036 OPC_CheckPredicate, 46, // 5868: check predicate 46
4037 OPC_CheckField, 20, 1, 1, // 5870: check Inst[20] == 0x1
4038 OPC_CheckField, 7, 1, 0, // 5874: check Inst[7] == 0x0
4039 OPC_Decode, 227, 120, 48, // 5878: decode to PSH1ADD_DH using decoder 48
4040 // 5878: }
4041 1, 0, // 5882: case 0x1: {
4042 OPC_CheckPredicate, 46, // 5884: check predicate 46
4043 OPC_CheckField, 20, 1, 0, // 5886: check Inst[20] == 0x0
4044 OPC_CheckField, 7, 1, 0, // 5890: check Inst[7] == 0x0
4045 OPC_Decode, 173, 120, 48, // 5894: decode to PPAIROE_DB using decoder 48
4046 // 5894: }
4047 // 5894: } // switch Inst[15]
4048 // 5894: }
4049 81, 35, // 5898: case 0x51: {
4050 OPC_SwitchField, 15, 1, // 5900: switch Inst[15] {
4051 0, 14, // 5903: case 0x0: {
4052 OPC_CheckPredicate, 46, // 5905: check predicate 46
4053 OPC_CheckField, 20, 1, 1, // 5907: check Inst[20] == 0x1
4054 OPC_CheckField, 7, 1, 0, // 5911: check Inst[7] == 0x0
4055 OPC_Decode, 228, 120, 48, // 5915: decode to PSH1ADD_DW using decoder 48
4056 // 5915: }
4057 1, 0, // 5919: case 0x1: {
4058 OPC_CheckPredicate, 46, // 5921: check predicate 46
4059 OPC_CheckField, 20, 1, 0, // 5923: check Inst[20] == 0x0
4060 OPC_CheckField, 7, 1, 0, // 5927: check Inst[7] == 0x0
4061 OPC_Decode, 174, 120, 48, // 5931: decode to PPAIROE_DH using decoder 48
4062 // 5931: }
4063 // 5931: } // switch Inst[15]
4064 // 5931: }
4065 88, 48, // 5935: case 0x58: {
4066 OPC_SwitchField, 15, 1, // 5937: switch Inst[15] {
4067 0, 27, // 5940: case 0x0: {
4068 OPC_SwitchField, 20, 1, // 5942: switch Inst[20] {
4069 0, 10, // 5945: case 0x0: {
4070 OPC_CheckPredicate, 46, // 5947: check predicate 46
4071 OPC_CheckField, 7, 1, 0, // 5949: check Inst[7] == 0x0
4072 OPC_Decode, 201, 120, 48, // 5953: decode to PSADDU_DH using decoder 48
4073 // 5953: }
4074 1, 0, // 5957: case 0x1: {
4075 OPC_CheckPredicate, 46, // 5959: check predicate 46
4076 OPC_CheckField, 7, 1, 0, // 5961: check Inst[7] == 0x0
4077 OPC_Decode, 146, 121, 48, // 5965: decode to PSSH1SADD_DH using decoder 48
4078 // 5965: }
4079 // 5965: } // switch Inst[20]
4080 // 5965: }
4081 1, 0, // 5969: case 0x1: {
4082 OPC_CheckPredicate, 46, // 5971: check predicate 46
4083 OPC_CheckField, 20, 1, 0, // 5973: check Inst[20] == 0x0
4084 OPC_CheckField, 7, 1, 0, // 5977: check Inst[7] == 0x0
4085 OPC_Decode, 178, 120, 48, // 5981: decode to PPAIRO_DB using decoder 48
4086 // 5981: }
4087 // 5981: } // switch Inst[15]
4088 // 5981: }
4089 89, 48, // 5985: case 0x59: {
4090 OPC_SwitchField, 15, 1, // 5987: switch Inst[15] {
4091 0, 27, // 5990: case 0x0: {
4092 OPC_SwitchField, 20, 1, // 5992: switch Inst[20] {
4093 0, 10, // 5995: case 0x0: {
4094 OPC_CheckPredicate, 46, // 5997: check predicate 46
4095 OPC_CheckField, 7, 1, 0, // 5999: check Inst[7] == 0x0
4096 OPC_Decode, 202, 120, 48, // 6003: decode to PSADDU_DW using decoder 48
4097 // 6003: }
4098 1, 0, // 6007: case 0x1: {
4099 OPC_CheckPredicate, 46, // 6009: check predicate 46
4100 OPC_CheckField, 7, 1, 0, // 6011: check Inst[7] == 0x0
4101 OPC_Decode, 147, 121, 48, // 6015: decode to PSSH1SADD_DW using decoder 48
4102 // 6015: }
4103 // 6015: } // switch Inst[20]
4104 // 6015: }
4105 1, 0, // 6019: case 0x1: {
4106 OPC_CheckPredicate, 46, // 6021: check predicate 46
4107 OPC_CheckField, 20, 1, 0, // 6023: check Inst[20] == 0x0
4108 OPC_CheckField, 7, 1, 0, // 6027: check Inst[7] == 0x0
4109 OPC_Decode, 179, 120, 48, // 6031: decode to PPAIRO_DH using decoder 48
4110 // 6031: }
4111 // 6031: } // switch Inst[15]
4112 // 6031: }
4113 90, 18, // 6035: case 0x5a: {
4114 OPC_CheckPredicate, 46, // 6037: check predicate 46
4115 OPC_CheckField, 20, 1, 0, // 6039: check Inst[20] == 0x0
4116 OPC_CheckField, 15, 1, 0, // 6043: check Inst[15] == 0x0
4117 OPC_CheckField, 7, 1, 0, // 6047: check Inst[7] == 0x0
4118 OPC_Decode, 200, 120, 48, // 6051: decode to PSADDU_DB using decoder 48
4119 // 6051: }
4120 92, 18, // 6055: case 0x5c: {
4121 OPC_CheckPredicate, 46, // 6057: check predicate 46
4122 OPC_CheckField, 20, 1, 0, // 6059: check Inst[20] == 0x0
4123 OPC_CheckField, 15, 1, 0, // 6063: check Inst[15] == 0x0
4124 OPC_CheckField, 7, 1, 0, // 6067: check Inst[7] == 0x0
4125 OPC_Decode, 144, 118, 48, // 6071: decode to PAADDU_DH using decoder 48
4126 // 6071: }
4127 93, 18, // 6075: case 0x5d: {
4128 OPC_CheckPredicate, 46, // 6077: check predicate 46
4129 OPC_CheckField, 20, 1, 0, // 6079: check Inst[20] == 0x0
4130 OPC_CheckField, 15, 1, 0, // 6083: check Inst[15] == 0x0
4131 OPC_CheckField, 7, 1, 0, // 6087: check Inst[7] == 0x0
4132 OPC_Decode, 145, 118, 48, // 6091: decode to PAADDU_DW using decoder 48
4133 // 6091: }
4134 94, 18, // 6095: case 0x5e: {
4135 OPC_CheckPredicate, 46, // 6097: check predicate 46
4136 OPC_CheckField, 20, 1, 0, // 6099: check Inst[20] == 0x0
4137 OPC_CheckField, 15, 1, 0, // 6103: check Inst[15] == 0x0
4138 OPC_CheckField, 7, 1, 0, // 6107: check Inst[7] == 0x0
4139 OPC_Decode, 143, 118, 48, // 6111: decode to PAADDU_DB using decoder 48
4140 // 6111: }
4141 96, 35, // 6115: case 0x60: {
4142 OPC_SwitchField, 15, 1, // 6117: switch Inst[15] {
4143 0, 14, // 6120: case 0x0: {
4144 OPC_CheckPredicate, 46, // 6122: check predicate 46
4145 OPC_CheckField, 20, 1, 0, // 6124: check Inst[20] == 0x0
4146 OPC_CheckField, 7, 1, 0, // 6128: check Inst[7] == 0x0
4147 OPC_Decode, 184, 121, 48, // 6132: decode to PSUB_DH using decoder 48
4148 // 6132: }
4149 1, 0, // 6136: case 0x1: {
4150 OPC_CheckPredicate, 46, // 6138: check predicate 46
4151 OPC_CheckField, 20, 1, 1, // 6140: check Inst[20] == 0x1
4152 OPC_CheckField, 7, 1, 0, // 6144: check Inst[7] == 0x0
4153 OPC_Decode, 201, 119, 48, // 6148: decode to PMSEQ_DH using decoder 48
4154 // 6148: }
4155 // 6148: } // switch Inst[15]
4156 // 6148: }
4157 97, 35, // 6152: case 0x61: {
4158 OPC_SwitchField, 15, 1, // 6154: switch Inst[15] {
4159 0, 14, // 6157: case 0x0: {
4160 OPC_CheckPredicate, 46, // 6159: check predicate 46
4161 OPC_CheckField, 20, 1, 0, // 6161: check Inst[20] == 0x0
4162 OPC_CheckField, 7, 1, 0, // 6165: check Inst[7] == 0x0
4163 OPC_Decode, 185, 121, 48, // 6169: decode to PSUB_DW using decoder 48
4164 // 6169: }
4165 1, 0, // 6173: case 0x1: {
4166 OPC_CheckPredicate, 46, // 6175: check predicate 46
4167 OPC_CheckField, 20, 1, 1, // 6177: check Inst[20] == 0x1
4168 OPC_CheckField, 7, 1, 0, // 6181: check Inst[7] == 0x0
4169 OPC_Decode, 202, 119, 48, // 6185: decode to PMSEQ_DW using decoder 48
4170 // 6185: }
4171 // 6185: } // switch Inst[15]
4172 // 6185: }
4173 98, 35, // 6189: case 0x62: {
4174 OPC_SwitchField, 15, 1, // 6191: switch Inst[15] {
4175 0, 14, // 6194: case 0x0: {
4176 OPC_CheckPredicate, 46, // 6196: check predicate 46
4177 OPC_CheckField, 20, 1, 0, // 6198: check Inst[20] == 0x0
4178 OPC_CheckField, 7, 1, 0, // 6202: check Inst[7] == 0x0
4179 OPC_Decode, 183, 121, 48, // 6206: decode to PSUB_DB using decoder 48
4180 // 6206: }
4181 1, 0, // 6210: case 0x1: {
4182 OPC_CheckPredicate, 46, // 6212: check predicate 46
4183 OPC_CheckField, 20, 1, 1, // 6214: check Inst[20] == 0x1
4184 OPC_CheckField, 7, 1, 0, // 6218: check Inst[7] == 0x0
4185 OPC_Decode, 200, 119, 48, // 6222: decode to PMSEQ_DB using decoder 48
4186 // 6222: }
4187 // 6222: } // switch Inst[15]
4188 // 6222: }
4189 99, 18, // 6226: case 0x63: {
4190 OPC_CheckPredicate, 46, // 6228: check predicate 46
4191 OPC_CheckField, 20, 1, 0, // 6230: check Inst[20] == 0x0
4192 OPC_CheckField, 15, 1, 0, // 6234: check Inst[15] == 0x0
4193 OPC_CheckField, 7, 1, 0, // 6238: check Inst[7] == 0x0
4194 OPC_Decode, 205, 124, 48, // 6242: decode to SUBD using decoder 48
4195 // 6242: }
4196 100, 18, // 6246: case 0x64: {
4197 OPC_CheckPredicate, 46, // 6248: check predicate 46
4198 OPC_CheckField, 20, 1, 0, // 6250: check Inst[20] == 0x0
4199 OPC_CheckField, 15, 1, 0, // 6254: check Inst[15] == 0x0
4200 OPC_CheckField, 7, 1, 0, // 6258: check Inst[7] == 0x0
4201 OPC_Decode, 165, 118, 48, // 6262: decode to PABD_DH using decoder 48
4202 // 6262: }
4203 102, 18, // 6266: case 0x66: {
4204 OPC_CheckPredicate, 46, // 6268: check predicate 46
4205 OPC_CheckField, 20, 1, 0, // 6270: check Inst[20] == 0x0
4206 OPC_CheckField, 15, 1, 0, // 6274: check Inst[15] == 0x0
4207 OPC_CheckField, 7, 1, 0, // 6278: check Inst[7] == 0x0
4208 OPC_Decode, 164, 118, 48, // 6282: decode to PABD_DB using decoder 48
4209 // 6282: }
4210 104, 35, // 6286: case 0x68: {
4211 OPC_SwitchField, 15, 1, // 6288: switch Inst[15] {
4212 0, 14, // 6291: case 0x0: {
4213 OPC_CheckPredicate, 46, // 6293: check predicate 46
4214 OPC_CheckField, 20, 1, 0, // 6295: check Inst[20] == 0x0
4215 OPC_CheckField, 7, 1, 0, // 6299: check Inst[7] == 0x0
4216 OPC_Decode, 178, 121, 48, // 6303: decode to PSSUB_DH using decoder 48
4217 // 6303: }
4218 1, 0, // 6307: case 0x1: {
4219 OPC_CheckPredicate, 46, // 6309: check predicate 46
4220 OPC_CheckField, 20, 1, 1, // 6311: check Inst[20] == 0x1
4221 OPC_CheckField, 7, 1, 0, // 6315: check Inst[7] == 0x0
4222 OPC_Decode, 213, 119, 48, // 6319: decode to PMSLT_DH using decoder 48
4223 // 6319: }
4224 // 6319: } // switch Inst[15]
4225 // 6319: }
4226 105, 35, // 6323: case 0x69: {
4227 OPC_SwitchField, 15, 1, // 6325: switch Inst[15] {
4228 0, 14, // 6328: case 0x0: {
4229 OPC_CheckPredicate, 46, // 6330: check predicate 46
4230 OPC_CheckField, 20, 1, 0, // 6332: check Inst[20] == 0x0
4231 OPC_CheckField, 7, 1, 0, // 6336: check Inst[7] == 0x0
4232 OPC_Decode, 179, 121, 48, // 6340: decode to PSSUB_DW using decoder 48
4233 // 6340: }
4234 1, 0, // 6344: case 0x1: {
4235 OPC_CheckPredicate, 46, // 6346: check predicate 46
4236 OPC_CheckField, 20, 1, 1, // 6348: check Inst[20] == 0x1
4237 OPC_CheckField, 7, 1, 0, // 6352: check Inst[7] == 0x0
4238 OPC_Decode, 214, 119, 48, // 6356: decode to PMSLT_DW using decoder 48
4239 // 6356: }
4240 // 6356: } // switch Inst[15]
4241 // 6356: }
4242 106, 35, // 6360: case 0x6a: {
4243 OPC_SwitchField, 15, 1, // 6362: switch Inst[15] {
4244 0, 14, // 6365: case 0x0: {
4245 OPC_CheckPredicate, 46, // 6367: check predicate 46
4246 OPC_CheckField, 20, 1, 0, // 6369: check Inst[20] == 0x0
4247 OPC_CheckField, 7, 1, 0, // 6373: check Inst[7] == 0x0
4248 OPC_Decode, 177, 121, 48, // 6377: decode to PSSUB_DB using decoder 48
4249 // 6377: }
4250 1, 0, // 6381: case 0x1: {
4251 OPC_CheckPredicate, 46, // 6383: check predicate 46
4252 OPC_CheckField, 20, 1, 1, // 6385: check Inst[20] == 0x1
4253 OPC_CheckField, 7, 1, 0, // 6389: check Inst[7] == 0x0
4254 OPC_Decode, 212, 119, 48, // 6393: decode to PMSLT_DB using decoder 48
4255 // 6393: }
4256 // 6393: } // switch Inst[15]
4257 // 6393: }
4258 108, 35, // 6397: case 0x6c: {
4259 OPC_SwitchField, 15, 1, // 6399: switch Inst[15] {
4260 0, 14, // 6402: case 0x0: {
4261 OPC_CheckPredicate, 46, // 6404: check predicate 46
4262 OPC_CheckField, 20, 1, 0, // 6406: check Inst[20] == 0x0
4263 OPC_CheckField, 7, 1, 0, // 6410: check Inst[7] == 0x0
4264 OPC_Decode, 194, 118, 48, // 6414: decode to PASUB_DH using decoder 48
4265 // 6414: }
4266 1, 0, // 6418: case 0x1: {
4267 OPC_CheckPredicate, 46, // 6420: check predicate 46
4268 OPC_CheckField, 20, 1, 1, // 6422: check Inst[20] == 0x1
4269 OPC_CheckField, 7, 1, 0, // 6426: check Inst[7] == 0x0
4270 OPC_Decode, 207, 119, 48, // 6430: decode to PMSLTU_DH using decoder 48
4271 // 6430: }
4272 // 6430: } // switch Inst[15]
4273 // 6430: }
4274 109, 35, // 6434: case 0x6d: {
4275 OPC_SwitchField, 15, 1, // 6436: switch Inst[15] {
4276 0, 14, // 6439: case 0x0: {
4277 OPC_CheckPredicate, 46, // 6441: check predicate 46
4278 OPC_CheckField, 20, 1, 0, // 6443: check Inst[20] == 0x0
4279 OPC_CheckField, 7, 1, 0, // 6447: check Inst[7] == 0x0
4280 OPC_Decode, 195, 118, 48, // 6451: decode to PASUB_DW using decoder 48
4281 // 6451: }
4282 1, 0, // 6455: case 0x1: {
4283 OPC_CheckPredicate, 46, // 6457: check predicate 46
4284 OPC_CheckField, 20, 1, 1, // 6459: check Inst[20] == 0x1
4285 OPC_CheckField, 7, 1, 0, // 6463: check Inst[7] == 0x0
4286 OPC_Decode, 208, 119, 48, // 6467: decode to PMSLTU_DW using decoder 48
4287 // 6467: }
4288 // 6467: } // switch Inst[15]
4289 // 6467: }
4290 110, 35, // 6471: case 0x6e: {
4291 OPC_SwitchField, 15, 1, // 6473: switch Inst[15] {
4292 0, 14, // 6476: case 0x0: {
4293 OPC_CheckPredicate, 46, // 6478: check predicate 46
4294 OPC_CheckField, 20, 1, 0, // 6480: check Inst[20] == 0x0
4295 OPC_CheckField, 7, 1, 0, // 6484: check Inst[7] == 0x0
4296 OPC_Decode, 193, 118, 48, // 6488: decode to PASUB_DB using decoder 48
4297 // 6488: }
4298 1, 0, // 6492: case 0x1: {
4299 OPC_CheckPredicate, 46, // 6494: check predicate 46
4300 OPC_CheckField, 20, 1, 1, // 6496: check Inst[20] == 0x1
4301 OPC_CheckField, 7, 1, 0, // 6500: check Inst[7] == 0x0
4302 OPC_Decode, 206, 119, 48, // 6504: decode to PMSLTU_DB using decoder 48
4303 // 6504: }
4304 // 6504: } // switch Inst[15]
4305 // 6504: }
4306 112, 18, // 6508: case 0x70: {
4307 OPC_CheckPredicate, 46, // 6510: check predicate 46
4308 OPC_CheckField, 20, 1, 1, // 6512: check Inst[20] == 0x1
4309 OPC_CheckField, 15, 1, 1, // 6516: check Inst[15] == 0x1
4310 OPC_CheckField, 7, 1, 0, // 6520: check Inst[7] == 0x0
4311 OPC_Decode, 179, 119, 48, // 6524: decode to PMIN_DH using decoder 48
4312 // 6524: }
4313 113, 18, // 6528: case 0x71: {
4314 OPC_CheckPredicate, 46, // 6530: check predicate 46
4315 OPC_CheckField, 20, 1, 1, // 6532: check Inst[20] == 0x1
4316 OPC_CheckField, 15, 1, 1, // 6536: check Inst[15] == 0x1
4317 OPC_CheckField, 7, 1, 0, // 6540: check Inst[7] == 0x0
4318 OPC_Decode, 180, 119, 48, // 6544: decode to PMIN_DW using decoder 48
4319 // 6544: }
4320 114, 18, // 6548: case 0x72: {
4321 OPC_CheckPredicate, 46, // 6550: check predicate 46
4322 OPC_CheckField, 20, 1, 1, // 6552: check Inst[20] == 0x1
4323 OPC_CheckField, 15, 1, 1, // 6556: check Inst[15] == 0x1
4324 OPC_CheckField, 7, 1, 0, // 6560: check Inst[7] == 0x0
4325 OPC_Decode, 178, 119, 48, // 6564: decode to PMIN_DB using decoder 48
4326 // 6564: }
4327 116, 35, // 6568: case 0x74: {
4328 OPC_SwitchField, 15, 1, // 6570: switch Inst[15] {
4329 0, 14, // 6573: case 0x0: {
4330 OPC_CheckPredicate, 46, // 6575: check predicate 46
4331 OPC_CheckField, 20, 1, 0, // 6577: check Inst[20] == 0x0
4332 OPC_CheckField, 7, 1, 0, // 6581: check Inst[7] == 0x0
4333 OPC_Decode, 161, 118, 48, // 6585: decode to PABDU_DH using decoder 48
4334 // 6585: }
4335 1, 0, // 6589: case 0x1: {
4336 OPC_CheckPredicate, 46, // 6591: check predicate 46
4337 OPC_CheckField, 20, 1, 1, // 6593: check Inst[20] == 0x1
4338 OPC_CheckField, 7, 1, 0, // 6597: check Inst[7] == 0x0
4339 OPC_Decode, 173, 119, 48, // 6601: decode to PMINU_DH using decoder 48
4340 // 6601: }
4341 // 6601: } // switch Inst[15]
4342 // 6601: }
4343 117, 18, // 6605: case 0x75: {
4344 OPC_CheckPredicate, 46, // 6607: check predicate 46
4345 OPC_CheckField, 20, 1, 1, // 6609: check Inst[20] == 0x1
4346 OPC_CheckField, 15, 1, 1, // 6613: check Inst[15] == 0x1
4347 OPC_CheckField, 7, 1, 0, // 6617: check Inst[7] == 0x0
4348 OPC_Decode, 174, 119, 48, // 6621: decode to PMINU_DW using decoder 48
4349 // 6621: }
4350 118, 35, // 6625: case 0x76: {
4351 OPC_SwitchField, 15, 1, // 6627: switch Inst[15] {
4352 0, 14, // 6630: case 0x0: {
4353 OPC_CheckPredicate, 46, // 6632: check predicate 46
4354 OPC_CheckField, 20, 1, 0, // 6634: check Inst[20] == 0x0
4355 OPC_CheckField, 7, 1, 0, // 6638: check Inst[7] == 0x0
4356 OPC_Decode, 160, 118, 48, // 6642: decode to PABDU_DB using decoder 48
4357 // 6642: }
4358 1, 0, // 6646: case 0x1: {
4359 OPC_CheckPredicate, 46, // 6648: check predicate 46
4360 OPC_CheckField, 20, 1, 1, // 6650: check Inst[20] == 0x1
4361 OPC_CheckField, 7, 1, 0, // 6654: check Inst[7] == 0x0
4362 OPC_Decode, 172, 119, 48, // 6658: decode to PMINU_DB using decoder 48
4363 // 6658: }
4364 // 6658: } // switch Inst[15]
4365 // 6658: }
4366 120, 35, // 6662: case 0x78: {
4367 OPC_SwitchField, 15, 1, // 6664: switch Inst[15] {
4368 0, 14, // 6667: case 0x0: {
4369 OPC_CheckPredicate, 46, // 6669: check predicate 46
4370 OPC_CheckField, 20, 1, 0, // 6671: check Inst[20] == 0x0
4371 OPC_CheckField, 7, 1, 0, // 6675: check Inst[7] == 0x0
4372 OPC_Decode, 172, 121, 48, // 6679: decode to PSSUBU_DH using decoder 48
4373 // 6679: }
4374 1, 0, // 6683: case 0x1: {
4375 OPC_CheckPredicate, 46, // 6685: check predicate 46
4376 OPC_CheckField, 20, 1, 1, // 6687: check Inst[20] == 0x1
4377 OPC_CheckField, 7, 1, 0, // 6691: check Inst[7] == 0x0
4378 OPC_Decode, 147, 119, 48, // 6695: decode to PMAX_DH using decoder 48
4379 // 6695: }
4380 // 6695: } // switch Inst[15]
4381 // 6695: }
4382 121, 35, // 6699: case 0x79: {
4383 OPC_SwitchField, 15, 1, // 6701: switch Inst[15] {
4384 0, 14, // 6704: case 0x0: {
4385 OPC_CheckPredicate, 46, // 6706: check predicate 46
4386 OPC_CheckField, 20, 1, 0, // 6708: check Inst[20] == 0x0
4387 OPC_CheckField, 7, 1, 0, // 6712: check Inst[7] == 0x0
4388 OPC_Decode, 173, 121, 48, // 6716: decode to PSSUBU_DW using decoder 48
4389 // 6716: }
4390 1, 0, // 6720: case 0x1: {
4391 OPC_CheckPredicate, 46, // 6722: check predicate 46
4392 OPC_CheckField, 20, 1, 1, // 6724: check Inst[20] == 0x1
4393 OPC_CheckField, 7, 1, 0, // 6728: check Inst[7] == 0x0
4394 OPC_Decode, 148, 119, 48, // 6732: decode to PMAX_DW using decoder 48
4395 // 6732: }
4396 // 6732: } // switch Inst[15]
4397 // 6732: }
4398 122, 35, // 6736: case 0x7a: {
4399 OPC_SwitchField, 15, 1, // 6738: switch Inst[15] {
4400 0, 14, // 6741: case 0x0: {
4401 OPC_CheckPredicate, 46, // 6743: check predicate 46
4402 OPC_CheckField, 20, 1, 0, // 6745: check Inst[20] == 0x0
4403 OPC_CheckField, 7, 1, 0, // 6749: check Inst[7] == 0x0
4404 OPC_Decode, 171, 121, 48, // 6753: decode to PSSUBU_DB using decoder 48
4405 // 6753: }
4406 1, 0, // 6757: case 0x1: {
4407 OPC_CheckPredicate, 46, // 6759: check predicate 46
4408 OPC_CheckField, 20, 1, 1, // 6761: check Inst[20] == 0x1
4409 OPC_CheckField, 7, 1, 0, // 6765: check Inst[7] == 0x0
4410 OPC_Decode, 146, 119, 48, // 6769: decode to PMAX_DB using decoder 48
4411 // 6769: }
4412 // 6769: } // switch Inst[15]
4413 // 6769: }
4414 124, 35, // 6773: case 0x7c: {
4415 OPC_SwitchField, 15, 1, // 6775: switch Inst[15] {
4416 0, 14, // 6778: case 0x0: {
4417 OPC_CheckPredicate, 46, // 6780: check predicate 46
4418 OPC_CheckField, 20, 1, 0, // 6782: check Inst[20] == 0x0
4419 OPC_CheckField, 7, 1, 0, // 6786: check Inst[7] == 0x0
4420 OPC_Decode, 188, 118, 48, // 6790: decode to PASUBU_DH using decoder 48
4421 // 6790: }
4422 1, 0, // 6794: case 0x1: {
4423 OPC_CheckPredicate, 46, // 6796: check predicate 46
4424 OPC_CheckField, 20, 1, 1, // 6798: check Inst[20] == 0x1
4425 OPC_CheckField, 7, 1, 0, // 6802: check Inst[7] == 0x0
4426 OPC_Decode, 141, 119, 48, // 6806: decode to PMAXU_DH using decoder 48
4427 // 6806: }
4428 // 6806: } // switch Inst[15]
4429 // 6806: }
4430 125, 35, // 6810: case 0x7d: {
4431 OPC_SwitchField, 15, 1, // 6812: switch Inst[15] {
4432 0, 14, // 6815: case 0x0: {
4433 OPC_CheckPredicate, 46, // 6817: check predicate 46
4434 OPC_CheckField, 20, 1, 0, // 6819: check Inst[20] == 0x0
4435 OPC_CheckField, 7, 1, 0, // 6823: check Inst[7] == 0x0
4436 OPC_Decode, 189, 118, 48, // 6827: decode to PASUBU_DW using decoder 48
4437 // 6827: }
4438 1, 0, // 6831: case 0x1: {
4439 OPC_CheckPredicate, 46, // 6833: check predicate 46
4440 OPC_CheckField, 20, 1, 1, // 6835: check Inst[20] == 0x1
4441 OPC_CheckField, 7, 1, 0, // 6839: check Inst[7] == 0x0
4442 OPC_Decode, 142, 119, 48, // 6843: decode to PMAXU_DW using decoder 48
4443 // 6843: }
4444 // 6843: } // switch Inst[15]
4445 // 6843: }
4446 126, 0, // 6847: case 0x7e: {
4447 OPC_SwitchField, 15, 1, // 6849: switch Inst[15] {
4448 0, 14, // 6852: case 0x0: {
4449 OPC_CheckPredicate, 46, // 6854: check predicate 46
4450 OPC_CheckField, 20, 1, 0, // 6856: check Inst[20] == 0x0
4451 OPC_CheckField, 7, 1, 0, // 6860: check Inst[7] == 0x0
4452 OPC_Decode, 187, 118, 48, // 6864: decode to PASUBU_DB using decoder 48
4453 // 6864: }
4454 1, 0, // 6868: case 0x1: {
4455 OPC_CheckPredicate, 46, // 6870: check predicate 46
4456 OPC_CheckField, 20, 1, 1, // 6872: check Inst[20] == 0x1
4457 OPC_CheckField, 7, 1, 0, // 6876: check Inst[7] == 0x0
4458 OPC_Decode, 140, 119, 48, // 6880: decode to PMAXU_DB using decoder 48
4459 // 6880: }
4460 // 6880: } // switch Inst[15]
4461 // 6880: }
4462 // 6880: } // switch Inst[31:25]
4463 // 6880: }
4464 // 6880: } // switch Inst[14:12]
4465 // 6880: }
4466 35, 29, // 6884: case 0x23: {
4467 OPC_SwitchField, 12, 3, // 6886: switch Inst[14:12] {
4468 0, 4, // 6889: case 0x0: {
4469 OPC_Decode, 152, 123, 49, // 6891: decode to SB using decoder 49
4470 // 6891: }
4471 1, 4, // 6895: case 0x1: {
4472 OPC_Decode, 241, 123, 49, // 6897: decode to SH using decoder 49
4473 // 6897: }
4474 2, 4, // 6901: case 0x2: {
4475 OPC_Decode, 207, 124, 49, // 6903: decode to SW using decoder 49
4476 // 6903: }
4477 3, 0, // 6907: case 0x3: {
4478 OPC_CheckPredicate, 21, // 6909: check predicate 21
4479 OPC_Decode, 164, 123, 49, // 6911: decode to SD using decoder 49
4480 // 6911: }
4481 // 6911: } // switch Inst[14:12]
4482 // 6911: }
4483 39, 165, 11, // 6915: case 0x27: {
4484 OPC_SwitchField, 12, 3, // 6918: switch Inst[14:12] {
4485 0, 136, 3, // 6921: case 0x0: {
4486 OPC_SwitchField, 26, 6, // 6924: switch Inst[31:26] {
4487 0, 38, // 6927: case 0x0: {
4488 OPC_SwitchField, 20, 5, // 6929: switch Inst[24:20] {
4489 0, 7, // 6932: case 0x0: {
4490 OPC_CheckPredicate, 22, // 6934: check predicate 22
4491 OPC_Decode, 196, 129, 1, 1, // 6936: decode to VSE8_V using decoder 1
4492 // 6936: }
4493 8, 11, // 6941: case 0x8: {
4494 OPC_CheckPredicate, 22, // 6943: check predicate 22
4495 OPC_CheckField, 25, 1, 1, // 6945: check Inst[25] == 0x1
4496 OPC_Decode, 181, 129, 1, 2, // 6949: decode to VS1R_V using decoder 2
4497 // 6949: }
4498 11, 0, // 6954: case 0xb: {
4499 OPC_CheckPredicate, 22, // 6956: check predicate 22
4500 OPC_CheckField, 25, 1, 1, // 6958: check Inst[25] == 0x1
4501 OPC_Decode, 222, 129, 1, 2, // 6962: decode to VSM_V using decoder 2
4502 // 6962: }
4503 // 6962: } // switch Inst[24:20]
4504 // 6962: }
4505 1, 7, // 6967: case 0x1: {
4506 OPC_CheckPredicate, 22, // 6969: check predicate 22
4507 OPC_Decode, 208, 130, 1, 3, // 6971: decode to VSUXEI8_V using decoder 3
4508 // 6971: }
4509 2, 7, // 6976: case 0x2: {
4510 OPC_CheckPredicate, 22, // 6978: check predicate 22
4511 OPC_Decode, 136, 130, 1, 4, // 6980: decode to VSSE8_V using decoder 4
4512 // 6980: }
4513 3, 7, // 6985: case 0x3: {
4514 OPC_CheckPredicate, 22, // 6987: check predicate 22
4515 OPC_Decode, 226, 129, 1, 3, // 6989: decode to VSOXEI8_V using decoder 3
4516 // 6989: }
4517 8, 25, // 6994: case 0x8: {
4518 OPC_SwitchField, 20, 5, // 6996: switch Inst[24:20] {
4519 0, 7, // 6999: case 0x0: {
4520 OPC_CheckPredicate, 22, // 7001: check predicate 22
4521 OPC_Decode, 140, 130, 1, 1, // 7003: decode to VSSEG2E8_V using decoder 1
4522 // 7003: }
4523 8, 0, // 7008: case 0x8: {
4524 OPC_CheckPredicate, 22, // 7010: check predicate 22
4525 OPC_CheckField, 25, 1, 1, // 7012: check Inst[25] == 0x1
4526 OPC_Decode, 182, 129, 1, 5, // 7016: decode to VS2R_V using decoder 5
4527 // 7016: }
4528 // 7016: } // switch Inst[24:20]
4529 // 7016: }
4530 9, 7, // 7021: case 0x9: {
4531 OPC_CheckPredicate, 22, // 7023: check predicate 22
4532 OPC_Decode, 212, 130, 1, 3, // 7025: decode to VSUXSEG2EI8_V using decoder 3
4533 // 7025: }
4534 10, 7, // 7030: case 0xa: {
4535 OPC_CheckPredicate, 22, // 7032: check predicate 22
4536 OPC_Decode, 174, 130, 1, 4, // 7034: decode to VSSSEG2E8_V using decoder 4
4537 // 7034: }
4538 11, 7, // 7039: case 0xb: {
4539 OPC_CheckPredicate, 22, // 7041: check predicate 22
4540 OPC_Decode, 230, 129, 1, 3, // 7043: decode to VSOXSEG2EI8_V using decoder 3
4541 // 7043: }
4542 16, 11, // 7048: case 0x10: {
4543 OPC_CheckPredicate, 22, // 7050: check predicate 22
4544 OPC_CheckField, 20, 5, 0, // 7052: check Inst[24:20] == 0x0
4545 OPC_Decode, 144, 130, 1, 1, // 7056: decode to VSSEG3E8_V using decoder 1
4546 // 7056: }
4547 17, 7, // 7061: case 0x11: {
4548 OPC_CheckPredicate, 22, // 7063: check predicate 22
4549 OPC_Decode, 216, 130, 1, 3, // 7065: decode to VSUXSEG3EI8_V using decoder 3
4550 // 7065: }
4551 18, 7, // 7070: case 0x12: {
4552 OPC_CheckPredicate, 22, // 7072: check predicate 22
4553 OPC_Decode, 178, 130, 1, 4, // 7074: decode to VSSSEG3E8_V using decoder 4
4554 // 7074: }
4555 19, 7, // 7079: case 0x13: {
4556 OPC_CheckPredicate, 22, // 7081: check predicate 22
4557 OPC_Decode, 234, 129, 1, 3, // 7083: decode to VSOXSEG3EI8_V using decoder 3
4558 // 7083: }
4559 24, 25, // 7088: case 0x18: {
4560 OPC_SwitchField, 20, 5, // 7090: switch Inst[24:20] {
4561 0, 7, // 7093: case 0x0: {
4562 OPC_CheckPredicate, 22, // 7095: check predicate 22
4563 OPC_Decode, 148, 130, 1, 1, // 7097: decode to VSSEG4E8_V using decoder 1
4564 // 7097: }
4565 8, 0, // 7102: case 0x8: {
4566 OPC_CheckPredicate, 22, // 7104: check predicate 22
4567 OPC_CheckField, 25, 1, 1, // 7106: check Inst[25] == 0x1
4568 OPC_Decode, 183, 129, 1, 6, // 7110: decode to VS4R_V using decoder 6
4569 // 7110: }
4570 // 7110: } // switch Inst[24:20]
4571 // 7110: }
4572 25, 7, // 7115: case 0x19: {
4573 OPC_CheckPredicate, 22, // 7117: check predicate 22
4574 OPC_Decode, 220, 130, 1, 3, // 7119: decode to VSUXSEG4EI8_V using decoder 3
4575 // 7119: }
4576 26, 7, // 7124: case 0x1a: {
4577 OPC_CheckPredicate, 22, // 7126: check predicate 22
4578 OPC_Decode, 182, 130, 1, 4, // 7128: decode to VSSSEG4E8_V using decoder 4
4579 // 7128: }
4580 27, 7, // 7133: case 0x1b: {
4581 OPC_CheckPredicate, 22, // 7135: check predicate 22
4582 OPC_Decode, 238, 129, 1, 3, // 7137: decode to VSOXSEG4EI8_V using decoder 3
4583 // 7137: }
4584 32, 11, // 7142: case 0x20: {
4585 OPC_CheckPredicate, 22, // 7144: check predicate 22
4586 OPC_CheckField, 20, 5, 0, // 7146: check Inst[24:20] == 0x0
4587 OPC_Decode, 152, 130, 1, 1, // 7150: decode to VSSEG5E8_V using decoder 1
4588 // 7150: }
4589 33, 7, // 7155: case 0x21: {
4590 OPC_CheckPredicate, 22, // 7157: check predicate 22
4591 OPC_Decode, 224, 130, 1, 3, // 7159: decode to VSUXSEG5EI8_V using decoder 3
4592 // 7159: }
4593 34, 7, // 7164: case 0x22: {
4594 OPC_CheckPredicate, 22, // 7166: check predicate 22
4595 OPC_Decode, 186, 130, 1, 4, // 7168: decode to VSSSEG5E8_V using decoder 4
4596 // 7168: }
4597 35, 7, // 7173: case 0x23: {
4598 OPC_CheckPredicate, 22, // 7175: check predicate 22
4599 OPC_Decode, 242, 129, 1, 3, // 7177: decode to VSOXSEG5EI8_V using decoder 3
4600 // 7177: }
4601 40, 11, // 7182: case 0x28: {
4602 OPC_CheckPredicate, 22, // 7184: check predicate 22
4603 OPC_CheckField, 20, 5, 0, // 7186: check Inst[24:20] == 0x0
4604 OPC_Decode, 156, 130, 1, 1, // 7190: decode to VSSEG6E8_V using decoder 1
4605 // 7190: }
4606 41, 7, // 7195: case 0x29: {
4607 OPC_CheckPredicate, 22, // 7197: check predicate 22
4608 OPC_Decode, 228, 130, 1, 3, // 7199: decode to VSUXSEG6EI8_V using decoder 3
4609 // 7199: }
4610 42, 7, // 7204: case 0x2a: {
4611 OPC_CheckPredicate, 22, // 7206: check predicate 22
4612 OPC_Decode, 190, 130, 1, 4, // 7208: decode to VSSSEG6E8_V using decoder 4
4613 // 7208: }
4614 43, 7, // 7213: case 0x2b: {
4615 OPC_CheckPredicate, 22, // 7215: check predicate 22
4616 OPC_Decode, 246, 129, 1, 3, // 7217: decode to VSOXSEG6EI8_V using decoder 3
4617 // 7217: }
4618 48, 11, // 7222: case 0x30: {
4619 OPC_CheckPredicate, 22, // 7224: check predicate 22
4620 OPC_CheckField, 20, 5, 0, // 7226: check Inst[24:20] == 0x0
4621 OPC_Decode, 160, 130, 1, 1, // 7230: decode to VSSEG7E8_V using decoder 1
4622 // 7230: }
4623 49, 7, // 7235: case 0x31: {
4624 OPC_CheckPredicate, 22, // 7237: check predicate 22
4625 OPC_Decode, 232, 130, 1, 3, // 7239: decode to VSUXSEG7EI8_V using decoder 3
4626 // 7239: }
4627 50, 7, // 7244: case 0x32: {
4628 OPC_CheckPredicate, 22, // 7246: check predicate 22
4629 OPC_Decode, 194, 130, 1, 4, // 7248: decode to VSSSEG7E8_V using decoder 4
4630 // 7248: }
4631 51, 7, // 7253: case 0x33: {
4632 OPC_CheckPredicate, 22, // 7255: check predicate 22
4633 OPC_Decode, 250, 129, 1, 3, // 7257: decode to VSOXSEG7EI8_V using decoder 3
4634 // 7257: }
4635 56, 25, // 7262: case 0x38: {
4636 OPC_SwitchField, 20, 5, // 7264: switch Inst[24:20] {
4637 0, 7, // 7267: case 0x0: {
4638 OPC_CheckPredicate, 22, // 7269: check predicate 22
4639 OPC_Decode, 164, 130, 1, 1, // 7271: decode to VSSEG8E8_V using decoder 1
4640 // 7271: }
4641 8, 0, // 7276: case 0x8: {
4642 OPC_CheckPredicate, 22, // 7278: check predicate 22
4643 OPC_CheckField, 25, 1, 1, // 7280: check Inst[25] == 0x1
4644 OPC_Decode, 184, 129, 1, 7, // 7284: decode to VS8R_V using decoder 7
4645 // 7284: }
4646 // 7284: } // switch Inst[24:20]
4647 // 7284: }
4648 57, 7, // 7289: case 0x39: {
4649 OPC_CheckPredicate, 22, // 7291: check predicate 22
4650 OPC_Decode, 236, 130, 1, 3, // 7293: decode to VSUXSEG8EI8_V using decoder 3
4651 // 7293: }
4652 58, 7, // 7298: case 0x3a: {
4653 OPC_CheckPredicate, 22, // 7300: check predicate 22
4654 OPC_Decode, 198, 130, 1, 4, // 7302: decode to VSSSEG8E8_V using decoder 4
4655 // 7302: }
4656 59, 0, // 7307: case 0x3b: {
4657 OPC_CheckPredicate, 22, // 7309: check predicate 22
4658 OPC_Decode, 254, 129, 1, 3, // 7311: decode to VSOXSEG8EI8_V using decoder 3
4659 // 7311: }
4660 // 7311: } // switch Inst[31:26]
4661 // 7311: }
4662 1, 6, // 7316: case 0x1: {
4663 OPC_CheckPredicate, 23, // 7318: check predicate 23
4664 OPC_Decode, 238, 115, 50, // 7320: decode to FSH using decoder 50
4665 // 7320: }
4666 2, 6, // 7324: case 0x2: {
4667 OPC_CheckPredicate, 24, // 7326: check predicate 24
4668 OPC_Decode, 128, 116, 51, // 7328: decode to FSW using decoder 51
4669 // 7328: }
4670 3, 6, // 7332: case 0x3: {
4671 OPC_CheckPredicate, 25, // 7334: check predicate 25
4672 OPC_Decode, 213, 115, 52, // 7336: decode to FSD using decoder 52
4673 // 7336: }
4674 4, 6, // 7340: case 0x4: {
4675 OPC_CheckPredicate, 26, // 7342: check predicate 26
4676 OPC_Decode, 239, 115, 53, // 7344: decode to FSQ using decoder 53
4677 // 7344: }
4678 5, 195, 2, // 7348: case 0x5: {
4679 OPC_SwitchField, 26, 6, // 7351: switch Inst[31:26] {
4680 0, 11, // 7354: case 0x0: {
4681 OPC_CheckPredicate, 22, // 7356: check predicate 22
4682 OPC_CheckField, 20, 5, 0, // 7358: check Inst[24:20] == 0x0
4683 OPC_Decode, 193, 129, 1, 1, // 7362: decode to VSE16_V using decoder 1
4684 // 7362: }
4685 1, 7, // 7367: case 0x1: {
4686 OPC_CheckPredicate, 22, // 7369: check predicate 22
4687 OPC_Decode, 205, 130, 1, 3, // 7371: decode to VSUXEI16_V using decoder 3
4688 // 7371: }
4689 2, 7, // 7376: case 0x2: {
4690 OPC_CheckPredicate, 22, // 7378: check predicate 22
4691 OPC_Decode, 133, 130, 1, 4, // 7380: decode to VSSE16_V using decoder 4
4692 // 7380: }
4693 3, 7, // 7385: case 0x3: {
4694 OPC_CheckPredicate, 22, // 7387: check predicate 22
4695 OPC_Decode, 223, 129, 1, 3, // 7389: decode to VSOXEI16_V using decoder 3
4696 // 7389: }
4697 8, 11, // 7394: case 0x8: {
4698 OPC_CheckPredicate, 22, // 7396: check predicate 22
4699 OPC_CheckField, 20, 5, 0, // 7398: check Inst[24:20] == 0x0
4700 OPC_Decode, 137, 130, 1, 1, // 7402: decode to VSSEG2E16_V using decoder 1
4701 // 7402: }
4702 9, 7, // 7407: case 0x9: {
4703 OPC_CheckPredicate, 22, // 7409: check predicate 22
4704 OPC_Decode, 209, 130, 1, 3, // 7411: decode to VSUXSEG2EI16_V using decoder 3
4705 // 7411: }
4706 10, 7, // 7416: case 0xa: {
4707 OPC_CheckPredicate, 22, // 7418: check predicate 22
4708 OPC_Decode, 171, 130, 1, 4, // 7420: decode to VSSSEG2E16_V using decoder 4
4709 // 7420: }
4710 11, 7, // 7425: case 0xb: {
4711 OPC_CheckPredicate, 22, // 7427: check predicate 22
4712 OPC_Decode, 227, 129, 1, 3, // 7429: decode to VSOXSEG2EI16_V using decoder 3
4713 // 7429: }
4714 16, 11, // 7434: case 0x10: {
4715 OPC_CheckPredicate, 22, // 7436: check predicate 22
4716 OPC_CheckField, 20, 5, 0, // 7438: check Inst[24:20] == 0x0
4717 OPC_Decode, 141, 130, 1, 1, // 7442: decode to VSSEG3E16_V using decoder 1
4718 // 7442: }
4719 17, 7, // 7447: case 0x11: {
4720 OPC_CheckPredicate, 22, // 7449: check predicate 22
4721 OPC_Decode, 213, 130, 1, 3, // 7451: decode to VSUXSEG3EI16_V using decoder 3
4722 // 7451: }
4723 18, 7, // 7456: case 0x12: {
4724 OPC_CheckPredicate, 22, // 7458: check predicate 22
4725 OPC_Decode, 175, 130, 1, 4, // 7460: decode to VSSSEG3E16_V using decoder 4
4726 // 7460: }
4727 19, 7, // 7465: case 0x13: {
4728 OPC_CheckPredicate, 22, // 7467: check predicate 22
4729 OPC_Decode, 231, 129, 1, 3, // 7469: decode to VSOXSEG3EI16_V using decoder 3
4730 // 7469: }
4731 24, 11, // 7474: case 0x18: {
4732 OPC_CheckPredicate, 22, // 7476: check predicate 22
4733 OPC_CheckField, 20, 5, 0, // 7478: check Inst[24:20] == 0x0
4734 OPC_Decode, 145, 130, 1, 1, // 7482: decode to VSSEG4E16_V using decoder 1
4735 // 7482: }
4736 25, 7, // 7487: case 0x19: {
4737 OPC_CheckPredicate, 22, // 7489: check predicate 22
4738 OPC_Decode, 217, 130, 1, 3, // 7491: decode to VSUXSEG4EI16_V using decoder 3
4739 // 7491: }
4740 26, 7, // 7496: case 0x1a: {
4741 OPC_CheckPredicate, 22, // 7498: check predicate 22
4742 OPC_Decode, 179, 130, 1, 4, // 7500: decode to VSSSEG4E16_V using decoder 4
4743 // 7500: }
4744 27, 7, // 7505: case 0x1b: {
4745 OPC_CheckPredicate, 22, // 7507: check predicate 22
4746 OPC_Decode, 235, 129, 1, 3, // 7509: decode to VSOXSEG4EI16_V using decoder 3
4747 // 7509: }
4748 32, 11, // 7514: case 0x20: {
4749 OPC_CheckPredicate, 22, // 7516: check predicate 22
4750 OPC_CheckField, 20, 5, 0, // 7518: check Inst[24:20] == 0x0
4751 OPC_Decode, 149, 130, 1, 1, // 7522: decode to VSSEG5E16_V using decoder 1
4752 // 7522: }
4753 33, 7, // 7527: case 0x21: {
4754 OPC_CheckPredicate, 22, // 7529: check predicate 22
4755 OPC_Decode, 221, 130, 1, 3, // 7531: decode to VSUXSEG5EI16_V using decoder 3
4756 // 7531: }
4757 34, 7, // 7536: case 0x22: {
4758 OPC_CheckPredicate, 22, // 7538: check predicate 22
4759 OPC_Decode, 183, 130, 1, 4, // 7540: decode to VSSSEG5E16_V using decoder 4
4760 // 7540: }
4761 35, 7, // 7545: case 0x23: {
4762 OPC_CheckPredicate, 22, // 7547: check predicate 22
4763 OPC_Decode, 239, 129, 1, 3, // 7549: decode to VSOXSEG5EI16_V using decoder 3
4764 // 7549: }
4765 40, 11, // 7554: case 0x28: {
4766 OPC_CheckPredicate, 22, // 7556: check predicate 22
4767 OPC_CheckField, 20, 5, 0, // 7558: check Inst[24:20] == 0x0
4768 OPC_Decode, 153, 130, 1, 1, // 7562: decode to VSSEG6E16_V using decoder 1
4769 // 7562: }
4770 41, 7, // 7567: case 0x29: {
4771 OPC_CheckPredicate, 22, // 7569: check predicate 22
4772 OPC_Decode, 225, 130, 1, 3, // 7571: decode to VSUXSEG6EI16_V using decoder 3
4773 // 7571: }
4774 42, 7, // 7576: case 0x2a: {
4775 OPC_CheckPredicate, 22, // 7578: check predicate 22
4776 OPC_Decode, 187, 130, 1, 4, // 7580: decode to VSSSEG6E16_V using decoder 4
4777 // 7580: }
4778 43, 7, // 7585: case 0x2b: {
4779 OPC_CheckPredicate, 22, // 7587: check predicate 22
4780 OPC_Decode, 243, 129, 1, 3, // 7589: decode to VSOXSEG6EI16_V using decoder 3
4781 // 7589: }
4782 48, 11, // 7594: case 0x30: {
4783 OPC_CheckPredicate, 22, // 7596: check predicate 22
4784 OPC_CheckField, 20, 5, 0, // 7598: check Inst[24:20] == 0x0
4785 OPC_Decode, 157, 130, 1, 1, // 7602: decode to VSSEG7E16_V using decoder 1
4786 // 7602: }
4787 49, 7, // 7607: case 0x31: {
4788 OPC_CheckPredicate, 22, // 7609: check predicate 22
4789 OPC_Decode, 229, 130, 1, 3, // 7611: decode to VSUXSEG7EI16_V using decoder 3
4790 // 7611: }
4791 50, 7, // 7616: case 0x32: {
4792 OPC_CheckPredicate, 22, // 7618: check predicate 22
4793 OPC_Decode, 191, 130, 1, 4, // 7620: decode to VSSSEG7E16_V using decoder 4
4794 // 7620: }
4795 51, 7, // 7625: case 0x33: {
4796 OPC_CheckPredicate, 22, // 7627: check predicate 22
4797 OPC_Decode, 247, 129, 1, 3, // 7629: decode to VSOXSEG7EI16_V using decoder 3
4798 // 7629: }
4799 56, 11, // 7634: case 0x38: {
4800 OPC_CheckPredicate, 22, // 7636: check predicate 22
4801 OPC_CheckField, 20, 5, 0, // 7638: check Inst[24:20] == 0x0
4802 OPC_Decode, 161, 130, 1, 1, // 7642: decode to VSSEG8E16_V using decoder 1
4803 // 7642: }
4804 57, 7, // 7647: case 0x39: {
4805 OPC_CheckPredicate, 22, // 7649: check predicate 22
4806 OPC_Decode, 233, 130, 1, 3, // 7651: decode to VSUXSEG8EI16_V using decoder 3
4807 // 7651: }
4808 58, 7, // 7656: case 0x3a: {
4809 OPC_CheckPredicate, 22, // 7658: check predicate 22
4810 OPC_Decode, 195, 130, 1, 4, // 7660: decode to VSSSEG8E16_V using decoder 4
4811 // 7660: }
4812 59, 0, // 7665: case 0x3b: {
4813 OPC_CheckPredicate, 22, // 7667: check predicate 22
4814 OPC_Decode, 251, 129, 1, 3, // 7669: decode to VSOXSEG8EI16_V using decoder 3
4815 // 7669: }
4816 // 7669: } // switch Inst[31:26]
4817 // 7669: }
4818 6, 195, 2, // 7674: case 0x6: {
4819 OPC_SwitchField, 26, 6, // 7677: switch Inst[31:26] {
4820 0, 11, // 7680: case 0x0: {
4821 OPC_CheckPredicate, 22, // 7682: check predicate 22
4822 OPC_CheckField, 20, 5, 0, // 7684: check Inst[24:20] == 0x0
4823 OPC_Decode, 194, 129, 1, 1, // 7688: decode to VSE32_V using decoder 1
4824 // 7688: }
4825 1, 7, // 7693: case 0x1: {
4826 OPC_CheckPredicate, 22, // 7695: check predicate 22
4827 OPC_Decode, 206, 130, 1, 3, // 7697: decode to VSUXEI32_V using decoder 3
4828 // 7697: }
4829 2, 7, // 7702: case 0x2: {
4830 OPC_CheckPredicate, 22, // 7704: check predicate 22
4831 OPC_Decode, 134, 130, 1, 4, // 7706: decode to VSSE32_V using decoder 4
4832 // 7706: }
4833 3, 7, // 7711: case 0x3: {
4834 OPC_CheckPredicate, 22, // 7713: check predicate 22
4835 OPC_Decode, 224, 129, 1, 3, // 7715: decode to VSOXEI32_V using decoder 3
4836 // 7715: }
4837 8, 11, // 7720: case 0x8: {
4838 OPC_CheckPredicate, 22, // 7722: check predicate 22
4839 OPC_CheckField, 20, 5, 0, // 7724: check Inst[24:20] == 0x0
4840 OPC_Decode, 138, 130, 1, 1, // 7728: decode to VSSEG2E32_V using decoder 1
4841 // 7728: }
4842 9, 7, // 7733: case 0x9: {
4843 OPC_CheckPredicate, 22, // 7735: check predicate 22
4844 OPC_Decode, 210, 130, 1, 3, // 7737: decode to VSUXSEG2EI32_V using decoder 3
4845 // 7737: }
4846 10, 7, // 7742: case 0xa: {
4847 OPC_CheckPredicate, 22, // 7744: check predicate 22
4848 OPC_Decode, 172, 130, 1, 4, // 7746: decode to VSSSEG2E32_V using decoder 4
4849 // 7746: }
4850 11, 7, // 7751: case 0xb: {
4851 OPC_CheckPredicate, 22, // 7753: check predicate 22
4852 OPC_Decode, 228, 129, 1, 3, // 7755: decode to VSOXSEG2EI32_V using decoder 3
4853 // 7755: }
4854 16, 11, // 7760: case 0x10: {
4855 OPC_CheckPredicate, 22, // 7762: check predicate 22
4856 OPC_CheckField, 20, 5, 0, // 7764: check Inst[24:20] == 0x0
4857 OPC_Decode, 142, 130, 1, 1, // 7768: decode to VSSEG3E32_V using decoder 1
4858 // 7768: }
4859 17, 7, // 7773: case 0x11: {
4860 OPC_CheckPredicate, 22, // 7775: check predicate 22
4861 OPC_Decode, 214, 130, 1, 3, // 7777: decode to VSUXSEG3EI32_V using decoder 3
4862 // 7777: }
4863 18, 7, // 7782: case 0x12: {
4864 OPC_CheckPredicate, 22, // 7784: check predicate 22
4865 OPC_Decode, 176, 130, 1, 4, // 7786: decode to VSSSEG3E32_V using decoder 4
4866 // 7786: }
4867 19, 7, // 7791: case 0x13: {
4868 OPC_CheckPredicate, 22, // 7793: check predicate 22
4869 OPC_Decode, 232, 129, 1, 3, // 7795: decode to VSOXSEG3EI32_V using decoder 3
4870 // 7795: }
4871 24, 11, // 7800: case 0x18: {
4872 OPC_CheckPredicate, 22, // 7802: check predicate 22
4873 OPC_CheckField, 20, 5, 0, // 7804: check Inst[24:20] == 0x0
4874 OPC_Decode, 146, 130, 1, 1, // 7808: decode to VSSEG4E32_V using decoder 1
4875 // 7808: }
4876 25, 7, // 7813: case 0x19: {
4877 OPC_CheckPredicate, 22, // 7815: check predicate 22
4878 OPC_Decode, 218, 130, 1, 3, // 7817: decode to VSUXSEG4EI32_V using decoder 3
4879 // 7817: }
4880 26, 7, // 7822: case 0x1a: {
4881 OPC_CheckPredicate, 22, // 7824: check predicate 22
4882 OPC_Decode, 180, 130, 1, 4, // 7826: decode to VSSSEG4E32_V using decoder 4
4883 // 7826: }
4884 27, 7, // 7831: case 0x1b: {
4885 OPC_CheckPredicate, 22, // 7833: check predicate 22
4886 OPC_Decode, 236, 129, 1, 3, // 7835: decode to VSOXSEG4EI32_V using decoder 3
4887 // 7835: }
4888 32, 11, // 7840: case 0x20: {
4889 OPC_CheckPredicate, 22, // 7842: check predicate 22
4890 OPC_CheckField, 20, 5, 0, // 7844: check Inst[24:20] == 0x0
4891 OPC_Decode, 150, 130, 1, 1, // 7848: decode to VSSEG5E32_V using decoder 1
4892 // 7848: }
4893 33, 7, // 7853: case 0x21: {
4894 OPC_CheckPredicate, 22, // 7855: check predicate 22
4895 OPC_Decode, 222, 130, 1, 3, // 7857: decode to VSUXSEG5EI32_V using decoder 3
4896 // 7857: }
4897 34, 7, // 7862: case 0x22: {
4898 OPC_CheckPredicate, 22, // 7864: check predicate 22
4899 OPC_Decode, 184, 130, 1, 4, // 7866: decode to VSSSEG5E32_V using decoder 4
4900 // 7866: }
4901 35, 7, // 7871: case 0x23: {
4902 OPC_CheckPredicate, 22, // 7873: check predicate 22
4903 OPC_Decode, 240, 129, 1, 3, // 7875: decode to VSOXSEG5EI32_V using decoder 3
4904 // 7875: }
4905 40, 11, // 7880: case 0x28: {
4906 OPC_CheckPredicate, 22, // 7882: check predicate 22
4907 OPC_CheckField, 20, 5, 0, // 7884: check Inst[24:20] == 0x0
4908 OPC_Decode, 154, 130, 1, 1, // 7888: decode to VSSEG6E32_V using decoder 1
4909 // 7888: }
4910 41, 7, // 7893: case 0x29: {
4911 OPC_CheckPredicate, 22, // 7895: check predicate 22
4912 OPC_Decode, 226, 130, 1, 3, // 7897: decode to VSUXSEG6EI32_V using decoder 3
4913 // 7897: }
4914 42, 7, // 7902: case 0x2a: {
4915 OPC_CheckPredicate, 22, // 7904: check predicate 22
4916 OPC_Decode, 188, 130, 1, 4, // 7906: decode to VSSSEG6E32_V using decoder 4
4917 // 7906: }
4918 43, 7, // 7911: case 0x2b: {
4919 OPC_CheckPredicate, 22, // 7913: check predicate 22
4920 OPC_Decode, 244, 129, 1, 3, // 7915: decode to VSOXSEG6EI32_V using decoder 3
4921 // 7915: }
4922 48, 11, // 7920: case 0x30: {
4923 OPC_CheckPredicate, 22, // 7922: check predicate 22
4924 OPC_CheckField, 20, 5, 0, // 7924: check Inst[24:20] == 0x0
4925 OPC_Decode, 158, 130, 1, 1, // 7928: decode to VSSEG7E32_V using decoder 1
4926 // 7928: }
4927 49, 7, // 7933: case 0x31: {
4928 OPC_CheckPredicate, 22, // 7935: check predicate 22
4929 OPC_Decode, 230, 130, 1, 3, // 7937: decode to VSUXSEG7EI32_V using decoder 3
4930 // 7937: }
4931 50, 7, // 7942: case 0x32: {
4932 OPC_CheckPredicate, 22, // 7944: check predicate 22
4933 OPC_Decode, 192, 130, 1, 4, // 7946: decode to VSSSEG7E32_V using decoder 4
4934 // 7946: }
4935 51, 7, // 7951: case 0x33: {
4936 OPC_CheckPredicate, 22, // 7953: check predicate 22
4937 OPC_Decode, 248, 129, 1, 3, // 7955: decode to VSOXSEG7EI32_V using decoder 3
4938 // 7955: }
4939 56, 11, // 7960: case 0x38: {
4940 OPC_CheckPredicate, 22, // 7962: check predicate 22
4941 OPC_CheckField, 20, 5, 0, // 7964: check Inst[24:20] == 0x0
4942 OPC_Decode, 162, 130, 1, 1, // 7968: decode to VSSEG8E32_V using decoder 1
4943 // 7968: }
4944 57, 7, // 7973: case 0x39: {
4945 OPC_CheckPredicate, 22, // 7975: check predicate 22
4946 OPC_Decode, 234, 130, 1, 3, // 7977: decode to VSUXSEG8EI32_V using decoder 3
4947 // 7977: }
4948 58, 7, // 7982: case 0x3a: {
4949 OPC_CheckPredicate, 22, // 7984: check predicate 22
4950 OPC_Decode, 196, 130, 1, 4, // 7986: decode to VSSSEG8E32_V using decoder 4
4951 // 7986: }
4952 59, 0, // 7991: case 0x3b: {
4953 OPC_CheckPredicate, 22, // 7993: check predicate 22
4954 OPC_Decode, 252, 129, 1, 3, // 7995: decode to VSOXSEG8EI32_V using decoder 3
4955 // 7995: }
4956 // 7995: } // switch Inst[31:26]
4957 // 7995: }
4958 7, 0, // 8000: case 0x7: {
4959 OPC_SwitchField, 26, 3, // 8002: switch Inst[28:26] {
4960 0, 107, // 8005: case 0x0: {
4961 OPC_SwitchField, 29, 3, // 8007: switch Inst[31:29] {
4962 0, 11, // 8010: case 0x0: {
4963 OPC_CheckPredicate, 27, // 8012: check predicate 27
4964 OPC_CheckField, 20, 5, 0, // 8014: check Inst[24:20] == 0x0
4965 OPC_Decode, 195, 129, 1, 1, // 8018: decode to VSE64_V using decoder 1
4966 // 8018: }
4967 1, 11, // 8023: case 0x1: {
4968 OPC_CheckPredicate, 27, // 8025: check predicate 27
4969 OPC_CheckField, 20, 5, 0, // 8027: check Inst[24:20] == 0x0
4970 OPC_Decode, 139, 130, 1, 1, // 8031: decode to VSSEG2E64_V using decoder 1
4971 // 8031: }
4972 2, 11, // 8036: case 0x2: {
4973 OPC_CheckPredicate, 27, // 8038: check predicate 27
4974 OPC_CheckField, 20, 5, 0, // 8040: check Inst[24:20] == 0x0
4975 OPC_Decode, 143, 130, 1, 1, // 8044: decode to VSSEG3E64_V using decoder 1
4976 // 8044: }
4977 3, 11, // 8049: case 0x3: {
4978 OPC_CheckPredicate, 27, // 8051: check predicate 27
4979 OPC_CheckField, 20, 5, 0, // 8053: check Inst[24:20] == 0x0
4980 OPC_Decode, 147, 130, 1, 1, // 8057: decode to VSSEG4E64_V using decoder 1
4981 // 8057: }
4982 4, 11, // 8062: case 0x4: {
4983 OPC_CheckPredicate, 27, // 8064: check predicate 27
4984 OPC_CheckField, 20, 5, 0, // 8066: check Inst[24:20] == 0x0
4985 OPC_Decode, 151, 130, 1, 1, // 8070: decode to VSSEG5E64_V using decoder 1
4986 // 8070: }
4987 5, 11, // 8075: case 0x5: {
4988 OPC_CheckPredicate, 27, // 8077: check predicate 27
4989 OPC_CheckField, 20, 5, 0, // 8079: check Inst[24:20] == 0x0
4990 OPC_Decode, 155, 130, 1, 1, // 8083: decode to VSSEG6E64_V using decoder 1
4991 // 8083: }
4992 6, 11, // 8088: case 0x6: {
4993 OPC_CheckPredicate, 27, // 8090: check predicate 27
4994 OPC_CheckField, 20, 5, 0, // 8092: check Inst[24:20] == 0x0
4995 OPC_Decode, 159, 130, 1, 1, // 8096: decode to VSSEG7E64_V using decoder 1
4996 // 8096: }
4997 7, 0, // 8101: case 0x7: {
4998 OPC_CheckPredicate, 27, // 8103: check predicate 27
4999 OPC_CheckField, 20, 5, 0, // 8105: check Inst[24:20] == 0x0
5000 OPC_Decode, 163, 130, 1, 1, // 8109: decode to VSSEG8E64_V using decoder 1
5001 // 8109: }
5002 // 8109: } // switch Inst[31:29]
5003 // 8109: }
5004 1, 75, // 8114: case 0x1: {
5005 OPC_SwitchField, 29, 3, // 8116: switch Inst[31:29] {
5006 0, 7, // 8119: case 0x0: {
5007 OPC_CheckPredicate, 28, // 8121: check predicate 28
5008 OPC_Decode, 207, 130, 1, 3, // 8123: decode to VSUXEI64_V using decoder 3
5009 // 8123: }
5010 1, 7, // 8128: case 0x1: {
5011 OPC_CheckPredicate, 29, // 8130: check predicate 29
5012 OPC_Decode, 211, 130, 1, 3, // 8132: decode to VSUXSEG2EI64_V using decoder 3
5013 // 8132: }
5014 2, 7, // 8137: case 0x2: {
5015 OPC_CheckPredicate, 29, // 8139: check predicate 29
5016 OPC_Decode, 215, 130, 1, 3, // 8141: decode to VSUXSEG3EI64_V using decoder 3
5017 // 8141: }
5018 3, 7, // 8146: case 0x3: {
5019 OPC_CheckPredicate, 29, // 8148: check predicate 29
5020 OPC_Decode, 219, 130, 1, 3, // 8150: decode to VSUXSEG4EI64_V using decoder 3
5021 // 8150: }
5022 4, 7, // 8155: case 0x4: {
5023 OPC_CheckPredicate, 29, // 8157: check predicate 29
5024 OPC_Decode, 223, 130, 1, 3, // 8159: decode to VSUXSEG5EI64_V using decoder 3
5025 // 8159: }
5026 5, 7, // 8164: case 0x5: {
5027 OPC_CheckPredicate, 29, // 8166: check predicate 29
5028 OPC_Decode, 227, 130, 1, 3, // 8168: decode to VSUXSEG6EI64_V using decoder 3
5029 // 8168: }
5030 6, 7, // 8173: case 0x6: {
5031 OPC_CheckPredicate, 29, // 8175: check predicate 29
5032 OPC_Decode, 231, 130, 1, 3, // 8177: decode to VSUXSEG7EI64_V using decoder 3
5033 // 8177: }
5034 7, 0, // 8182: case 0x7: {
5035 OPC_CheckPredicate, 29, // 8184: check predicate 29
5036 OPC_Decode, 235, 130, 1, 3, // 8186: decode to VSUXSEG8EI64_V using decoder 3
5037 // 8186: }
5038 // 8186: } // switch Inst[31:29]
5039 // 8186: }
5040 2, 75, // 8191: case 0x2: {
5041 OPC_SwitchField, 29, 3, // 8193: switch Inst[31:29] {
5042 0, 7, // 8196: case 0x0: {
5043 OPC_CheckPredicate, 27, // 8198: check predicate 27
5044 OPC_Decode, 135, 130, 1, 4, // 8200: decode to VSSE64_V using decoder 4
5045 // 8200: }
5046 1, 7, // 8205: case 0x1: {
5047 OPC_CheckPredicate, 27, // 8207: check predicate 27
5048 OPC_Decode, 173, 130, 1, 4, // 8209: decode to VSSSEG2E64_V using decoder 4
5049 // 8209: }
5050 2, 7, // 8214: case 0x2: {
5051 OPC_CheckPredicate, 27, // 8216: check predicate 27
5052 OPC_Decode, 177, 130, 1, 4, // 8218: decode to VSSSEG3E64_V using decoder 4
5053 // 8218: }
5054 3, 7, // 8223: case 0x3: {
5055 OPC_CheckPredicate, 27, // 8225: check predicate 27
5056 OPC_Decode, 181, 130, 1, 4, // 8227: decode to VSSSEG4E64_V using decoder 4
5057 // 8227: }
5058 4, 7, // 8232: case 0x4: {
5059 OPC_CheckPredicate, 27, // 8234: check predicate 27
5060 OPC_Decode, 185, 130, 1, 4, // 8236: decode to VSSSEG5E64_V using decoder 4
5061 // 8236: }
5062 5, 7, // 8241: case 0x5: {
5063 OPC_CheckPredicate, 27, // 8243: check predicate 27
5064 OPC_Decode, 189, 130, 1, 4, // 8245: decode to VSSSEG6E64_V using decoder 4
5065 // 8245: }
5066 6, 7, // 8250: case 0x6: {
5067 OPC_CheckPredicate, 27, // 8252: check predicate 27
5068 OPC_Decode, 193, 130, 1, 4, // 8254: decode to VSSSEG7E64_V using decoder 4
5069 // 8254: }
5070 7, 0, // 8259: case 0x7: {
5071 OPC_CheckPredicate, 27, // 8261: check predicate 27
5072 OPC_Decode, 197, 130, 1, 4, // 8263: decode to VSSSEG8E64_V using decoder 4
5073 // 8263: }
5074 // 8263: } // switch Inst[31:29]
5075 // 8263: }
5076 3, 75, // 8268: case 0x3: {
5077 OPC_SwitchField, 29, 3, // 8270: switch Inst[31:29] {
5078 0, 7, // 8273: case 0x0: {
5079 OPC_CheckPredicate, 28, // 8275: check predicate 28
5080 OPC_Decode, 225, 129, 1, 3, // 8277: decode to VSOXEI64_V using decoder 3
5081 // 8277: }
5082 1, 7, // 8282: case 0x1: {
5083 OPC_CheckPredicate, 29, // 8284: check predicate 29
5084 OPC_Decode, 229, 129, 1, 3, // 8286: decode to VSOXSEG2EI64_V using decoder 3
5085 // 8286: }
5086 2, 7, // 8291: case 0x2: {
5087 OPC_CheckPredicate, 29, // 8293: check predicate 29
5088 OPC_Decode, 233, 129, 1, 3, // 8295: decode to VSOXSEG3EI64_V using decoder 3
5089 // 8295: }
5090 3, 7, // 8300: case 0x3: {
5091 OPC_CheckPredicate, 29, // 8302: check predicate 29
5092 OPC_Decode, 237, 129, 1, 3, // 8304: decode to VSOXSEG4EI64_V using decoder 3
5093 // 8304: }
5094 4, 7, // 8309: case 0x4: {
5095 OPC_CheckPredicate, 29, // 8311: check predicate 29
5096 OPC_Decode, 241, 129, 1, 3, // 8313: decode to VSOXSEG5EI64_V using decoder 3
5097 // 8313: }
5098 5, 7, // 8318: case 0x5: {
5099 OPC_CheckPredicate, 29, // 8320: check predicate 29
5100 OPC_Decode, 245, 129, 1, 3, // 8322: decode to VSOXSEG6EI64_V using decoder 3
5101 // 8322: }
5102 6, 7, // 8327: case 0x6: {
5103 OPC_CheckPredicate, 29, // 8329: check predicate 29
5104 OPC_Decode, 249, 129, 1, 3, // 8331: decode to VSOXSEG7EI64_V using decoder 3
5105 // 8331: }
5106 7, 0, // 8336: case 0x7: {
5107 OPC_CheckPredicate, 29, // 8338: check predicate 29
5108 OPC_Decode, 253, 129, 1, 3, // 8340: decode to VSOXSEG8EI64_V using decoder 3
5109 // 8340: }
5110 // 8340: } // switch Inst[31:29]
5111 // 8340: }
5112 4, 7, // 8345: case 0x4: {
5113 OPC_CheckPredicate, 30, // 8347: check predicate 30
5114 OPC_Decode, 237, 128, 1, 12, // 8349: decode to VMTS_V using decoder 12
5115 // 8349: }
5116 5, 0, // 8354: case 0x5: {
5117 OPC_CheckPredicate, 31, // 8356: check predicate 31
5118 OPC_Decode, 239, 128, 1, 12, // 8358: decode to VMTTS_V using decoder 12
5119 // 8358: }
5120 // 8358: } // switch Inst[28:26]
5121 // 8358: }
5122 // 8358: } // switch Inst[14:12]
5123 // 8358: }
5124 47, 187, 15, // 8363: case 0x2f: {
5125 OPC_SwitchField, 25, 7, // 8366: switch Inst[31:25] {
5126 0, 35, // 8369: case 0x0: {
5127 OPC_SwitchField, 12, 3, // 8371: switch Inst[14:12] {
5128 0, 6, // 8374: case 0x0: {
5129 OPC_CheckPredicate, 51, // 8376: check predicate 51
5130 OPC_Decode, 133, 109, 54, // 8378: decode to AMOADD_B using decoder 54
5131 // 8378: }
5132 1, 6, // 8382: case 0x1: {
5133 OPC_CheckPredicate, 51, // 8384: check predicate 51
5134 OPC_Decode, 141, 109, 54, // 8386: decode to AMOADD_H using decoder 54
5135 // 8386: }
5136 2, 6, // 8390: case 0x2: {
5137 OPC_CheckPredicate, 52, // 8392: check predicate 52
5138 OPC_Decode, 145, 109, 54, // 8394: decode to AMOADD_W using decoder 54
5139 // 8394: }
5140 3, 0, // 8398: case 0x3: {
5141 OPC_CheckPredicate, 53, // 8400: check predicate 53
5142 OPC_Decode, 137, 109, 54, // 8402: decode to AMOADD_D using decoder 54
5143 // 8402: }
5144 // 8402: } // switch Inst[14:12]
5145 // 8402: }
5146 1, 35, // 8406: case 0x1: {
5147 OPC_SwitchField, 12, 3, // 8408: switch Inst[14:12] {
5148 0, 6, // 8411: case 0x0: {
5149 OPC_CheckPredicate, 51, // 8413: check predicate 51
5150 OPC_Decode, 136, 109, 54, // 8415: decode to AMOADD_B_RL using decoder 54
5151 // 8415: }
5152 1, 6, // 8419: case 0x1: {
5153 OPC_CheckPredicate, 51, // 8421: check predicate 51
5154 OPC_Decode, 144, 109, 54, // 8423: decode to AMOADD_H_RL using decoder 54
5155 // 8423: }
5156 2, 6, // 8427: case 0x2: {
5157 OPC_CheckPredicate, 52, // 8429: check predicate 52
5158 OPC_Decode, 148, 109, 54, // 8431: decode to AMOADD_W_RL using decoder 54
5159 // 8431: }
5160 3, 0, // 8435: case 0x3: {
5161 OPC_CheckPredicate, 53, // 8437: check predicate 53
5162 OPC_Decode, 140, 109, 54, // 8439: decode to AMOADD_D_RL using decoder 54
5163 // 8439: }
5164 // 8439: } // switch Inst[14:12]
5165 // 8439: }
5166 2, 35, // 8443: case 0x2: {
5167 OPC_SwitchField, 12, 3, // 8445: switch Inst[14:12] {
5168 0, 6, // 8448: case 0x0: {
5169 OPC_CheckPredicate, 51, // 8450: check predicate 51
5170 OPC_Decode, 134, 109, 54, // 8452: decode to AMOADD_B_AQ using decoder 54
5171 // 8452: }
5172 1, 6, // 8456: case 0x1: {
5173 OPC_CheckPredicate, 51, // 8458: check predicate 51
5174 OPC_Decode, 142, 109, 54, // 8460: decode to AMOADD_H_AQ using decoder 54
5175 // 8460: }
5176 2, 6, // 8464: case 0x2: {
5177 OPC_CheckPredicate, 52, // 8466: check predicate 52
5178 OPC_Decode, 146, 109, 54, // 8468: decode to AMOADD_W_AQ using decoder 54
5179 // 8468: }
5180 3, 0, // 8472: case 0x3: {
5181 OPC_CheckPredicate, 53, // 8474: check predicate 53
5182 OPC_Decode, 138, 109, 54, // 8476: decode to AMOADD_D_AQ using decoder 54
5183 // 8476: }
5184 // 8476: } // switch Inst[14:12]
5185 // 8476: }
5186 3, 35, // 8480: case 0x3: {
5187 OPC_SwitchField, 12, 3, // 8482: switch Inst[14:12] {
5188 0, 6, // 8485: case 0x0: {
5189 OPC_CheckPredicate, 51, // 8487: check predicate 51
5190 OPC_Decode, 135, 109, 54, // 8489: decode to AMOADD_B_AQRL using decoder 54
5191 // 8489: }
5192 1, 6, // 8493: case 0x1: {
5193 OPC_CheckPredicate, 51, // 8495: check predicate 51
5194 OPC_Decode, 143, 109, 54, // 8497: decode to AMOADD_H_AQRL using decoder 54
5195 // 8497: }
5196 2, 6, // 8501: case 0x2: {
5197 OPC_CheckPredicate, 52, // 8503: check predicate 52
5198 OPC_Decode, 147, 109, 54, // 8505: decode to AMOADD_W_AQRL using decoder 54
5199 // 8505: }
5200 3, 0, // 8509: case 0x3: {
5201 OPC_CheckPredicate, 53, // 8511: check predicate 53
5202 OPC_Decode, 139, 109, 54, // 8513: decode to AMOADD_D_AQRL using decoder 54
5203 // 8513: }
5204 // 8513: } // switch Inst[14:12]
5205 // 8513: }
5206 4, 35, // 8517: case 0x4: {
5207 OPC_SwitchField, 12, 3, // 8519: switch Inst[14:12] {
5208 0, 6, // 8522: case 0x0: {
5209 OPC_CheckPredicate, 51, // 8524: check predicate 51
5210 OPC_Decode, 141, 110, 54, // 8526: decode to AMOSWAP_B using decoder 54
5211 // 8526: }
5212 1, 6, // 8530: case 0x1: {
5213 OPC_CheckPredicate, 51, // 8532: check predicate 51
5214 OPC_Decode, 149, 110, 54, // 8534: decode to AMOSWAP_H using decoder 54
5215 // 8534: }
5216 2, 6, // 8538: case 0x2: {
5217 OPC_CheckPredicate, 52, // 8540: check predicate 52
5218 OPC_Decode, 153, 110, 54, // 8542: decode to AMOSWAP_W using decoder 54
5219 // 8542: }
5220 3, 0, // 8546: case 0x3: {
5221 OPC_CheckPredicate, 53, // 8548: check predicate 53
5222 OPC_Decode, 145, 110, 54, // 8550: decode to AMOSWAP_D using decoder 54
5223 // 8550: }
5224 // 8550: } // switch Inst[14:12]
5225 // 8550: }
5226 5, 35, // 8554: case 0x5: {
5227 OPC_SwitchField, 12, 3, // 8556: switch Inst[14:12] {
5228 0, 6, // 8559: case 0x0: {
5229 OPC_CheckPredicate, 51, // 8561: check predicate 51
5230 OPC_Decode, 144, 110, 54, // 8563: decode to AMOSWAP_B_RL using decoder 54
5231 // 8563: }
5232 1, 6, // 8567: case 0x1: {
5233 OPC_CheckPredicate, 51, // 8569: check predicate 51
5234 OPC_Decode, 152, 110, 54, // 8571: decode to AMOSWAP_H_RL using decoder 54
5235 // 8571: }
5236 2, 6, // 8575: case 0x2: {
5237 OPC_CheckPredicate, 52, // 8577: check predicate 52
5238 OPC_Decode, 156, 110, 54, // 8579: decode to AMOSWAP_W_RL using decoder 54
5239 // 8579: }
5240 3, 0, // 8583: case 0x3: {
5241 OPC_CheckPredicate, 53, // 8585: check predicate 53
5242 OPC_Decode, 148, 110, 54, // 8587: decode to AMOSWAP_D_RL using decoder 54
5243 // 8587: }
5244 // 8587: } // switch Inst[14:12]
5245 // 8587: }
5246 6, 35, // 8591: case 0x6: {
5247 OPC_SwitchField, 12, 3, // 8593: switch Inst[14:12] {
5248 0, 6, // 8596: case 0x0: {
5249 OPC_CheckPredicate, 51, // 8598: check predicate 51
5250 OPC_Decode, 142, 110, 54, // 8600: decode to AMOSWAP_B_AQ using decoder 54
5251 // 8600: }
5252 1, 6, // 8604: case 0x1: {
5253 OPC_CheckPredicate, 51, // 8606: check predicate 51
5254 OPC_Decode, 150, 110, 54, // 8608: decode to AMOSWAP_H_AQ using decoder 54
5255 // 8608: }
5256 2, 6, // 8612: case 0x2: {
5257 OPC_CheckPredicate, 52, // 8614: check predicate 52
5258 OPC_Decode, 154, 110, 54, // 8616: decode to AMOSWAP_W_AQ using decoder 54
5259 // 8616: }
5260 3, 0, // 8620: case 0x3: {
5261 OPC_CheckPredicate, 53, // 8622: check predicate 53
5262 OPC_Decode, 146, 110, 54, // 8624: decode to AMOSWAP_D_AQ using decoder 54
5263 // 8624: }
5264 // 8624: } // switch Inst[14:12]
5265 // 8624: }
5266 7, 35, // 8628: case 0x7: {
5267 OPC_SwitchField, 12, 3, // 8630: switch Inst[14:12] {
5268 0, 6, // 8633: case 0x0: {
5269 OPC_CheckPredicate, 51, // 8635: check predicate 51
5270 OPC_Decode, 143, 110, 54, // 8637: decode to AMOSWAP_B_AQRL using decoder 54
5271 // 8637: }
5272 1, 6, // 8641: case 0x1: {
5273 OPC_CheckPredicate, 51, // 8643: check predicate 51
5274 OPC_Decode, 151, 110, 54, // 8645: decode to AMOSWAP_H_AQRL using decoder 54
5275 // 8645: }
5276 2, 6, // 8649: case 0x2: {
5277 OPC_CheckPredicate, 52, // 8651: check predicate 52
5278 OPC_Decode, 155, 110, 54, // 8653: decode to AMOSWAP_W_AQRL using decoder 54
5279 // 8653: }
5280 3, 0, // 8657: case 0x3: {
5281 OPC_CheckPredicate, 53, // 8659: check predicate 53
5282 OPC_Decode, 147, 110, 54, // 8661: decode to AMOSWAP_D_AQRL using decoder 54
5283 // 8661: }
5284 // 8661: } // switch Inst[14:12]
5285 // 8661: }
5286 8, 27, // 8665: case 0x8: {
5287 OPC_SwitchField, 12, 3, // 8667: switch Inst[14:12] {
5288 2, 10, // 8670: case 0x2: {
5289 OPC_CheckPredicate, 54, // 8672: check predicate 54
5290 OPC_CheckField, 20, 5, 0, // 8674: check Inst[24:20] == 0x0
5291 OPC_Decode, 192, 116, 17, // 8678: decode to LR_W using decoder 17
5292 // 8678: }
5293 3, 0, // 8682: case 0x3: {
5294 OPC_CheckPredicate, 55, // 8684: check predicate 55
5295 OPC_CheckField, 20, 5, 0, // 8686: check Inst[24:20] == 0x0
5296 OPC_Decode, 188, 116, 17, // 8690: decode to LR_D using decoder 17
5297 // 8690: }
5298 // 8690: } // switch Inst[14:12]
5299 // 8690: }
5300 9, 27, // 8694: case 0x9: {
5301 OPC_SwitchField, 12, 3, // 8696: switch Inst[14:12] {
5302 2, 10, // 8699: case 0x2: {
5303 OPC_CheckPredicate, 54, // 8701: check predicate 54
5304 OPC_CheckField, 20, 5, 0, // 8703: check Inst[24:20] == 0x0
5305 OPC_Decode, 195, 116, 17, // 8707: decode to LR_W_RL using decoder 17
5306 // 8707: }
5307 3, 0, // 8711: case 0x3: {
5308 OPC_CheckPredicate, 55, // 8713: check predicate 55
5309 OPC_CheckField, 20, 5, 0, // 8715: check Inst[24:20] == 0x0
5310 OPC_Decode, 191, 116, 17, // 8719: decode to LR_D_RL using decoder 17
5311 // 8719: }
5312 // 8719: } // switch Inst[14:12]
5313 // 8719: }
5314 10, 27, // 8723: case 0xa: {
5315 OPC_SwitchField, 12, 3, // 8725: switch Inst[14:12] {
5316 2, 10, // 8728: case 0x2: {
5317 OPC_CheckPredicate, 54, // 8730: check predicate 54
5318 OPC_CheckField, 20, 5, 0, // 8732: check Inst[24:20] == 0x0
5319 OPC_Decode, 193, 116, 17, // 8736: decode to LR_W_AQ using decoder 17
5320 // 8736: }
5321 3, 0, // 8740: case 0x3: {
5322 OPC_CheckPredicate, 55, // 8742: check predicate 55
5323 OPC_CheckField, 20, 5, 0, // 8744: check Inst[24:20] == 0x0
5324 OPC_Decode, 189, 116, 17, // 8748: decode to LR_D_AQ using decoder 17
5325 // 8748: }
5326 // 8748: } // switch Inst[14:12]
5327 // 8748: }
5328 11, 27, // 8752: case 0xb: {
5329 OPC_SwitchField, 12, 3, // 8754: switch Inst[14:12] {
5330 2, 10, // 8757: case 0x2: {
5331 OPC_CheckPredicate, 54, // 8759: check predicate 54
5332 OPC_CheckField, 20, 5, 0, // 8761: check Inst[24:20] == 0x0
5333 OPC_Decode, 194, 116, 17, // 8765: decode to LR_W_AQRL using decoder 17
5334 // 8765: }
5335 3, 0, // 8769: case 0x3: {
5336 OPC_CheckPredicate, 55, // 8771: check predicate 55
5337 OPC_CheckField, 20, 5, 0, // 8773: check Inst[24:20] == 0x0
5338 OPC_Decode, 190, 116, 17, // 8777: decode to LR_D_AQRL using decoder 17
5339 // 8777: }
5340 // 8777: } // switch Inst[14:12]
5341 // 8777: }
5342 12, 19, // 8781: case 0xc: {
5343 OPC_SwitchField, 12, 3, // 8783: switch Inst[14:12] {
5344 2, 6, // 8786: case 0x2: {
5345 OPC_CheckPredicate, 54, // 8788: check predicate 54
5346 OPC_Decode, 160, 123, 54, // 8790: decode to SC_W using decoder 54
5347 // 8790: }
5348 3, 0, // 8794: case 0x3: {
5349 OPC_CheckPredicate, 55, // 8796: check predicate 55
5350 OPC_Decode, 156, 123, 54, // 8798: decode to SC_D using decoder 54
5351 // 8798: }
5352 // 8798: } // switch Inst[14:12]
5353 // 8798: }
5354 13, 19, // 8802: case 0xd: {
5355 OPC_SwitchField, 12, 3, // 8804: switch Inst[14:12] {
5356 2, 6, // 8807: case 0x2: {
5357 OPC_CheckPredicate, 54, // 8809: check predicate 54
5358 OPC_Decode, 163, 123, 54, // 8811: decode to SC_W_RL using decoder 54
5359 // 8811: }
5360 3, 0, // 8815: case 0x3: {
5361 OPC_CheckPredicate, 55, // 8817: check predicate 55
5362 OPC_Decode, 159, 123, 54, // 8819: decode to SC_D_RL using decoder 54
5363 // 8819: }
5364 // 8819: } // switch Inst[14:12]
5365 // 8819: }
5366 14, 19, // 8823: case 0xe: {
5367 OPC_SwitchField, 12, 3, // 8825: switch Inst[14:12] {
5368 2, 6, // 8828: case 0x2: {
5369 OPC_CheckPredicate, 54, // 8830: check predicate 54
5370 OPC_Decode, 161, 123, 54, // 8832: decode to SC_W_AQ using decoder 54
5371 // 8832: }
5372 3, 0, // 8836: case 0x3: {
5373 OPC_CheckPredicate, 55, // 8838: check predicate 55
5374 OPC_Decode, 157, 123, 54, // 8840: decode to SC_D_AQ using decoder 54
5375 // 8840: }
5376 // 8840: } // switch Inst[14:12]
5377 // 8840: }
5378 15, 19, // 8844: case 0xf: {
5379 OPC_SwitchField, 12, 3, // 8846: switch Inst[14:12] {
5380 2, 6, // 8849: case 0x2: {
5381 OPC_CheckPredicate, 54, // 8851: check predicate 54
5382 OPC_Decode, 162, 123, 54, // 8853: decode to SC_W_AQRL using decoder 54
5383 // 8853: }
5384 3, 0, // 8857: case 0x3: {
5385 OPC_CheckPredicate, 55, // 8859: check predicate 55
5386 OPC_Decode, 158, 123, 54, // 8861: decode to SC_D_AQRL using decoder 54
5387 // 8861: }
5388 // 8861: } // switch Inst[14:12]
5389 // 8861: }
5390 16, 35, // 8865: case 0x10: {
5391 OPC_SwitchField, 12, 3, // 8867: switch Inst[14:12] {
5392 0, 6, // 8870: case 0x0: {
5393 OPC_CheckPredicate, 51, // 8872: check predicate 51
5394 OPC_Decode, 157, 110, 54, // 8874: decode to AMOXOR_B using decoder 54
5395 // 8874: }
5396 1, 6, // 8878: case 0x1: {
5397 OPC_CheckPredicate, 51, // 8880: check predicate 51
5398 OPC_Decode, 165, 110, 54, // 8882: decode to AMOXOR_H using decoder 54
5399 // 8882: }
5400 2, 6, // 8886: case 0x2: {
5401 OPC_CheckPredicate, 52, // 8888: check predicate 52
5402 OPC_Decode, 169, 110, 54, // 8890: decode to AMOXOR_W using decoder 54
5403 // 8890: }
5404 3, 0, // 8894: case 0x3: {
5405 OPC_CheckPredicate, 53, // 8896: check predicate 53
5406 OPC_Decode, 161, 110, 54, // 8898: decode to AMOXOR_D using decoder 54
5407 // 8898: }
5408 // 8898: } // switch Inst[14:12]
5409 // 8898: }
5410 17, 35, // 8902: case 0x11: {
5411 OPC_SwitchField, 12, 3, // 8904: switch Inst[14:12] {
5412 0, 6, // 8907: case 0x0: {
5413 OPC_CheckPredicate, 51, // 8909: check predicate 51
5414 OPC_Decode, 160, 110, 54, // 8911: decode to AMOXOR_B_RL using decoder 54
5415 // 8911: }
5416 1, 6, // 8915: case 0x1: {
5417 OPC_CheckPredicate, 51, // 8917: check predicate 51
5418 OPC_Decode, 168, 110, 54, // 8919: decode to AMOXOR_H_RL using decoder 54
5419 // 8919: }
5420 2, 6, // 8923: case 0x2: {
5421 OPC_CheckPredicate, 52, // 8925: check predicate 52
5422 OPC_Decode, 172, 110, 54, // 8927: decode to AMOXOR_W_RL using decoder 54
5423 // 8927: }
5424 3, 0, // 8931: case 0x3: {
5425 OPC_CheckPredicate, 53, // 8933: check predicate 53
5426 OPC_Decode, 164, 110, 54, // 8935: decode to AMOXOR_D_RL using decoder 54
5427 // 8935: }
5428 // 8935: } // switch Inst[14:12]
5429 // 8935: }
5430 18, 35, // 8939: case 0x12: {
5431 OPC_SwitchField, 12, 3, // 8941: switch Inst[14:12] {
5432 0, 6, // 8944: case 0x0: {
5433 OPC_CheckPredicate, 51, // 8946: check predicate 51
5434 OPC_Decode, 158, 110, 54, // 8948: decode to AMOXOR_B_AQ using decoder 54
5435 // 8948: }
5436 1, 6, // 8952: case 0x1: {
5437 OPC_CheckPredicate, 51, // 8954: check predicate 51
5438 OPC_Decode, 166, 110, 54, // 8956: decode to AMOXOR_H_AQ using decoder 54
5439 // 8956: }
5440 2, 6, // 8960: case 0x2: {
5441 OPC_CheckPredicate, 52, // 8962: check predicate 52
5442 OPC_Decode, 170, 110, 54, // 8964: decode to AMOXOR_W_AQ using decoder 54
5443 // 8964: }
5444 3, 0, // 8968: case 0x3: {
5445 OPC_CheckPredicate, 53, // 8970: check predicate 53
5446 OPC_Decode, 162, 110, 54, // 8972: decode to AMOXOR_D_AQ using decoder 54
5447 // 8972: }
5448 // 8972: } // switch Inst[14:12]
5449 // 8972: }
5450 19, 35, // 8976: case 0x13: {
5451 OPC_SwitchField, 12, 3, // 8978: switch Inst[14:12] {
5452 0, 6, // 8981: case 0x0: {
5453 OPC_CheckPredicate, 51, // 8983: check predicate 51
5454 OPC_Decode, 159, 110, 54, // 8985: decode to AMOXOR_B_AQRL using decoder 54
5455 // 8985: }
5456 1, 6, // 8989: case 0x1: {
5457 OPC_CheckPredicate, 51, // 8991: check predicate 51
5458 OPC_Decode, 167, 110, 54, // 8993: decode to AMOXOR_H_AQRL using decoder 54
5459 // 8993: }
5460 2, 6, // 8997: case 0x2: {
5461 OPC_CheckPredicate, 52, // 8999: check predicate 52
5462 OPC_Decode, 171, 110, 54, // 9001: decode to AMOXOR_W_AQRL using decoder 54
5463 // 9001: }
5464 3, 0, // 9005: case 0x3: {
5465 OPC_CheckPredicate, 53, // 9007: check predicate 53
5466 OPC_Decode, 163, 110, 54, // 9009: decode to AMOXOR_D_AQRL using decoder 54
5467 // 9009: }
5468 // 9009: } // switch Inst[14:12]
5469 // 9009: }
5470 20, 43, // 9013: case 0x14: {
5471 OPC_SwitchField, 12, 3, // 9015: switch Inst[14:12] {
5472 0, 6, // 9018: case 0x0: {
5473 OPC_CheckPredicate, 56, // 9020: check predicate 56
5474 OPC_Decode, 165, 109, 55, // 9022: decode to AMOCAS_B using decoder 55
5475 // 9022: }
5476 1, 6, // 9026: case 0x1: {
5477 OPC_CheckPredicate, 56, // 9028: check predicate 56
5478 OPC_Decode, 177, 109, 55, // 9030: decode to AMOCAS_H using decoder 55
5479 // 9030: }
5480 2, 6, // 9034: case 0x2: {
5481 OPC_CheckPredicate, 57, // 9036: check predicate 57
5482 OPC_Decode, 185, 109, 55, // 9038: decode to AMOCAS_W using decoder 55
5483 // 9038: }
5484 3, 6, // 9042: case 0x3: {
5485 OPC_CheckPredicate, 58, // 9044: check predicate 58
5486 OPC_Decode, 173, 109, 55, // 9046: decode to AMOCAS_D_RV64 using decoder 55
5487 // 9046: }
5488 4, 0, // 9050: case 0x4: {
5489 OPC_CheckPredicate, 58, // 9052: check predicate 58
5490 OPC_Decode, 181, 109, 56, // 9054: decode to AMOCAS_Q using decoder 56
5491 // 9054: }
5492 // 9054: } // switch Inst[14:12]
5493 // 9054: }
5494 21, 43, // 9058: case 0x15: {
5495 OPC_SwitchField, 12, 3, // 9060: switch Inst[14:12] {
5496 0, 6, // 9063: case 0x0: {
5497 OPC_CheckPredicate, 56, // 9065: check predicate 56
5498 OPC_Decode, 168, 109, 55, // 9067: decode to AMOCAS_B_RL using decoder 55
5499 // 9067: }
5500 1, 6, // 9071: case 0x1: {
5501 OPC_CheckPredicate, 56, // 9073: check predicate 56
5502 OPC_Decode, 180, 109, 55, // 9075: decode to AMOCAS_H_RL using decoder 55
5503 // 9075: }
5504 2, 6, // 9079: case 0x2: {
5505 OPC_CheckPredicate, 57, // 9081: check predicate 57
5506 OPC_Decode, 188, 109, 55, // 9083: decode to AMOCAS_W_RL using decoder 55
5507 // 9083: }
5508 3, 6, // 9087: case 0x3: {
5509 OPC_CheckPredicate, 58, // 9089: check predicate 58
5510 OPC_Decode, 176, 109, 55, // 9091: decode to AMOCAS_D_RV64_RL using decoder 55
5511 // 9091: }
5512 4, 0, // 9095: case 0x4: {
5513 OPC_CheckPredicate, 58, // 9097: check predicate 58
5514 OPC_Decode, 184, 109, 56, // 9099: decode to AMOCAS_Q_RL using decoder 56
5515 // 9099: }
5516 // 9099: } // switch Inst[14:12]
5517 // 9099: }
5518 22, 43, // 9103: case 0x16: {
5519 OPC_SwitchField, 12, 3, // 9105: switch Inst[14:12] {
5520 0, 6, // 9108: case 0x0: {
5521 OPC_CheckPredicate, 56, // 9110: check predicate 56
5522 OPC_Decode, 166, 109, 55, // 9112: decode to AMOCAS_B_AQ using decoder 55
5523 // 9112: }
5524 1, 6, // 9116: case 0x1: {
5525 OPC_CheckPredicate, 56, // 9118: check predicate 56
5526 OPC_Decode, 178, 109, 55, // 9120: decode to AMOCAS_H_AQ using decoder 55
5527 // 9120: }
5528 2, 6, // 9124: case 0x2: {
5529 OPC_CheckPredicate, 57, // 9126: check predicate 57
5530 OPC_Decode, 186, 109, 55, // 9128: decode to AMOCAS_W_AQ using decoder 55
5531 // 9128: }
5532 3, 6, // 9132: case 0x3: {
5533 OPC_CheckPredicate, 58, // 9134: check predicate 58
5534 OPC_Decode, 174, 109, 55, // 9136: decode to AMOCAS_D_RV64_AQ using decoder 55
5535 // 9136: }
5536 4, 0, // 9140: case 0x4: {
5537 OPC_CheckPredicate, 58, // 9142: check predicate 58
5538 OPC_Decode, 182, 109, 56, // 9144: decode to AMOCAS_Q_AQ using decoder 56
5539 // 9144: }
5540 // 9144: } // switch Inst[14:12]
5541 // 9144: }
5542 23, 43, // 9148: case 0x17: {
5543 OPC_SwitchField, 12, 3, // 9150: switch Inst[14:12] {
5544 0, 6, // 9153: case 0x0: {
5545 OPC_CheckPredicate, 56, // 9155: check predicate 56
5546 OPC_Decode, 167, 109, 55, // 9157: decode to AMOCAS_B_AQRL using decoder 55
5547 // 9157: }
5548 1, 6, // 9161: case 0x1: {
5549 OPC_CheckPredicate, 56, // 9163: check predicate 56
5550 OPC_Decode, 179, 109, 55, // 9165: decode to AMOCAS_H_AQRL using decoder 55
5551 // 9165: }
5552 2, 6, // 9169: case 0x2: {
5553 OPC_CheckPredicate, 57, // 9171: check predicate 57
5554 OPC_Decode, 187, 109, 55, // 9173: decode to AMOCAS_W_AQRL using decoder 55
5555 // 9173: }
5556 3, 6, // 9177: case 0x3: {
5557 OPC_CheckPredicate, 58, // 9179: check predicate 58
5558 OPC_Decode, 175, 109, 55, // 9181: decode to AMOCAS_D_RV64_AQRL using decoder 55
5559 // 9181: }
5560 4, 0, // 9185: case 0x4: {
5561 OPC_CheckPredicate, 58, // 9187: check predicate 58
5562 OPC_Decode, 183, 109, 56, // 9189: decode to AMOCAS_Q_AQRL using decoder 56
5563 // 9189: }
5564 // 9189: } // switch Inst[14:12]
5565 // 9189: }
5566 26, 51, // 9193: case 0x1a: {
5567 OPC_SwitchField, 12, 3, // 9195: switch Inst[14:12] {
5568 0, 10, // 9198: case 0x0: {
5569 OPC_CheckPredicate, 59, // 9200: check predicate 59
5570 OPC_CheckField, 20, 5, 0, // 9202: check Inst[24:20] == 0x0
5571 OPC_Decode, 177, 116, 17, // 9206: decode to LB_AQ using decoder 17
5572 // 9206: }
5573 1, 10, // 9210: case 0x1: {
5574 OPC_CheckPredicate, 59, // 9212: check predicate 59
5575 OPC_CheckField, 20, 5, 0, // 9214: check Inst[24:20] == 0x0
5576 OPC_Decode, 185, 116, 17, // 9218: decode to LH_AQ using decoder 17
5577 // 9218: }
5578 2, 10, // 9222: case 0x2: {
5579 OPC_CheckPredicate, 59, // 9224: check predicate 59
5580 OPC_CheckField, 20, 5, 0, // 9226: check Inst[24:20] == 0x0
5581 OPC_Decode, 199, 116, 17, // 9230: decode to LW_AQ using decoder 17
5582 // 9230: }
5583 3, 0, // 9234: case 0x3: {
5584 OPC_CheckPredicate, 60, // 9236: check predicate 60
5585 OPC_CheckField, 20, 5, 0, // 9238: check Inst[24:20] == 0x0
5586 OPC_Decode, 180, 116, 17, // 9242: decode to LD_AQ using decoder 17
5587 // 9242: }
5588 // 9242: } // switch Inst[14:12]
5589 // 9242: }
5590 27, 51, // 9246: case 0x1b: {
5591 OPC_SwitchField, 12, 3, // 9248: switch Inst[14:12] {
5592 0, 10, // 9251: case 0x0: {
5593 OPC_CheckPredicate, 59, // 9253: check predicate 59
5594 OPC_CheckField, 20, 5, 0, // 9255: check Inst[24:20] == 0x0
5595 OPC_Decode, 178, 116, 17, // 9259: decode to LB_AQRL using decoder 17
5596 // 9259: }
5597 1, 10, // 9263: case 0x1: {
5598 OPC_CheckPredicate, 59, // 9265: check predicate 59
5599 OPC_CheckField, 20, 5, 0, // 9267: check Inst[24:20] == 0x0
5600 OPC_Decode, 186, 116, 17, // 9271: decode to LH_AQRL using decoder 17
5601 // 9271: }
5602 2, 10, // 9275: case 0x2: {
5603 OPC_CheckPredicate, 59, // 9277: check predicate 59
5604 OPC_CheckField, 20, 5, 0, // 9279: check Inst[24:20] == 0x0
5605 OPC_Decode, 200, 116, 17, // 9283: decode to LW_AQRL using decoder 17
5606 // 9283: }
5607 3, 0, // 9287: case 0x3: {
5608 OPC_CheckPredicate, 60, // 9289: check predicate 60
5609 OPC_CheckField, 20, 5, 0, // 9291: check Inst[24:20] == 0x0
5610 OPC_Decode, 181, 116, 17, // 9295: decode to LD_AQRL using decoder 17
5611 // 9295: }
5612 // 9295: } // switch Inst[14:12]
5613 // 9295: }
5614 29, 35, // 9299: case 0x1d: {
5615 OPC_SwitchField, 7, 8, // 9301: switch Inst[14:7] {
5616 0, 6, // 9304: case 0x0: {
5617 OPC_CheckPredicate, 59, // 9306: check predicate 59
5618 OPC_Decode, 154, 123, 57, // 9308: decode to SB_RL using decoder 57
5619 // 9308: }
5620 32, 6, // 9312: case 0x20: {
5621 OPC_CheckPredicate, 59, // 9314: check predicate 59
5622 OPC_Decode, 140, 124, 57, // 9316: decode to SH_RL using decoder 57
5623 // 9316: }
5624 64, 6, // 9320: case 0x40: {
5625 OPC_CheckPredicate, 59, // 9322: check predicate 59
5626 OPC_Decode, 210, 124, 57, // 9324: decode to SW_RL using decoder 57
5627 // 9324: }
5628 96, 0, // 9328: case 0x60: {
5629 OPC_CheckPredicate, 60, // 9330: check predicate 60
5630 OPC_Decode, 166, 123, 57, // 9332: decode to SD_RL using decoder 57
5631 // 9332: }
5632 // 9332: } // switch Inst[14:7]
5633 // 9332: }
5634 31, 35, // 9336: case 0x1f: {
5635 OPC_SwitchField, 7, 8, // 9338: switch Inst[14:7] {
5636 0, 6, // 9341: case 0x0: {
5637 OPC_CheckPredicate, 59, // 9343: check predicate 59
5638 OPC_Decode, 153, 123, 57, // 9345: decode to SB_AQRL using decoder 57
5639 // 9345: }
5640 32, 6, // 9349: case 0x20: {
5641 OPC_CheckPredicate, 59, // 9351: check predicate 59
5642 OPC_Decode, 138, 124, 57, // 9353: decode to SH_AQRL using decoder 57
5643 // 9353: }
5644 64, 6, // 9357: case 0x40: {
5645 OPC_CheckPredicate, 59, // 9359: check predicate 59
5646 OPC_Decode, 208, 124, 57, // 9361: decode to SW_AQRL using decoder 57
5647 // 9361: }
5648 96, 0, // 9365: case 0x60: {
5649 OPC_CheckPredicate, 60, // 9367: check predicate 60
5650 OPC_Decode, 165, 123, 57, // 9369: decode to SD_AQRL using decoder 57
5651 // 9369: }
5652 // 9369: } // switch Inst[14:7]
5653 // 9369: }
5654 32, 35, // 9373: case 0x20: {
5655 OPC_SwitchField, 12, 3, // 9375: switch Inst[14:12] {
5656 0, 6, // 9378: case 0x0: {
5657 OPC_CheckPredicate, 51, // 9380: check predicate 51
5658 OPC_Decode, 253, 109, 54, // 9382: decode to AMOOR_B using decoder 54
5659 // 9382: }
5660 1, 6, // 9386: case 0x1: {
5661 OPC_CheckPredicate, 51, // 9388: check predicate 51
5662 OPC_Decode, 133, 110, 54, // 9390: decode to AMOOR_H using decoder 54
5663 // 9390: }
5664 2, 6, // 9394: case 0x2: {
5665 OPC_CheckPredicate, 52, // 9396: check predicate 52
5666 OPC_Decode, 137, 110, 54, // 9398: decode to AMOOR_W using decoder 54
5667 // 9398: }
5668 3, 0, // 9402: case 0x3: {
5669 OPC_CheckPredicate, 53, // 9404: check predicate 53
5670 OPC_Decode, 129, 110, 54, // 9406: decode to AMOOR_D using decoder 54
5671 // 9406: }
5672 // 9406: } // switch Inst[14:12]
5673 // 9406: }
5674 33, 35, // 9410: case 0x21: {
5675 OPC_SwitchField, 12, 3, // 9412: switch Inst[14:12] {
5676 0, 6, // 9415: case 0x0: {
5677 OPC_CheckPredicate, 51, // 9417: check predicate 51
5678 OPC_Decode, 128, 110, 54, // 9419: decode to AMOOR_B_RL using decoder 54
5679 // 9419: }
5680 1, 6, // 9423: case 0x1: {
5681 OPC_CheckPredicate, 51, // 9425: check predicate 51
5682 OPC_Decode, 136, 110, 54, // 9427: decode to AMOOR_H_RL using decoder 54
5683 // 9427: }
5684 2, 6, // 9431: case 0x2: {
5685 OPC_CheckPredicate, 52, // 9433: check predicate 52
5686 OPC_Decode, 140, 110, 54, // 9435: decode to AMOOR_W_RL using decoder 54
5687 // 9435: }
5688 3, 0, // 9439: case 0x3: {
5689 OPC_CheckPredicate, 53, // 9441: check predicate 53
5690 OPC_Decode, 132, 110, 54, // 9443: decode to AMOOR_D_RL using decoder 54
5691 // 9443: }
5692 // 9443: } // switch Inst[14:12]
5693 // 9443: }
5694 34, 35, // 9447: case 0x22: {
5695 OPC_SwitchField, 12, 3, // 9449: switch Inst[14:12] {
5696 0, 6, // 9452: case 0x0: {
5697 OPC_CheckPredicate, 51, // 9454: check predicate 51
5698 OPC_Decode, 254, 109, 54, // 9456: decode to AMOOR_B_AQ using decoder 54
5699 // 9456: }
5700 1, 6, // 9460: case 0x1: {
5701 OPC_CheckPredicate, 51, // 9462: check predicate 51
5702 OPC_Decode, 134, 110, 54, // 9464: decode to AMOOR_H_AQ using decoder 54
5703 // 9464: }
5704 2, 6, // 9468: case 0x2: {
5705 OPC_CheckPredicate, 52, // 9470: check predicate 52
5706 OPC_Decode, 138, 110, 54, // 9472: decode to AMOOR_W_AQ using decoder 54
5707 // 9472: }
5708 3, 0, // 9476: case 0x3: {
5709 OPC_CheckPredicate, 53, // 9478: check predicate 53
5710 OPC_Decode, 130, 110, 54, // 9480: decode to AMOOR_D_AQ using decoder 54
5711 // 9480: }
5712 // 9480: } // switch Inst[14:12]
5713 // 9480: }
5714 35, 35, // 9484: case 0x23: {
5715 OPC_SwitchField, 12, 3, // 9486: switch Inst[14:12] {
5716 0, 6, // 9489: case 0x0: {
5717 OPC_CheckPredicate, 51, // 9491: check predicate 51
5718 OPC_Decode, 255, 109, 54, // 9493: decode to AMOOR_B_AQRL using decoder 54
5719 // 9493: }
5720 1, 6, // 9497: case 0x1: {
5721 OPC_CheckPredicate, 51, // 9499: check predicate 51
5722 OPC_Decode, 135, 110, 54, // 9501: decode to AMOOR_H_AQRL using decoder 54
5723 // 9501: }
5724 2, 6, // 9505: case 0x2: {
5725 OPC_CheckPredicate, 52, // 9507: check predicate 52
5726 OPC_Decode, 139, 110, 54, // 9509: decode to AMOOR_W_AQRL using decoder 54
5727 // 9509: }
5728 3, 0, // 9513: case 0x3: {
5729 OPC_CheckPredicate, 53, // 9515: check predicate 53
5730 OPC_Decode, 131, 110, 54, // 9517: decode to AMOOR_D_AQRL using decoder 54
5731 // 9517: }
5732 // 9517: } // switch Inst[14:12]
5733 // 9517: }
5734 36, 19, // 9521: case 0x24: {
5735 OPC_SwitchField, 12, 3, // 9523: switch Inst[14:12] {
5736 2, 6, // 9526: case 0x2: {
5737 OPC_CheckPredicate, 61, // 9528: check predicate 61
5738 OPC_Decode, 189, 124, 54, // 9530: decode to SSAMOSWAP_W using decoder 54
5739 // 9530: }
5740 3, 0, // 9534: case 0x3: {
5741 OPC_CheckPredicate, 62, // 9536: check predicate 62
5742 OPC_Decode, 185, 124, 54, // 9538: decode to SSAMOSWAP_D using decoder 54
5743 // 9538: }
5744 // 9538: } // switch Inst[14:12]
5745 // 9538: }
5746 37, 19, // 9542: case 0x25: {
5747 OPC_SwitchField, 12, 3, // 9544: switch Inst[14:12] {
5748 2, 6, // 9547: case 0x2: {
5749 OPC_CheckPredicate, 61, // 9549: check predicate 61
5750 OPC_Decode, 192, 124, 54, // 9551: decode to SSAMOSWAP_W_RL using decoder 54
5751 // 9551: }
5752 3, 0, // 9555: case 0x3: {
5753 OPC_CheckPredicate, 62, // 9557: check predicate 62
5754 OPC_Decode, 188, 124, 54, // 9559: decode to SSAMOSWAP_D_RL using decoder 54
5755 // 9559: }
5756 // 9559: } // switch Inst[14:12]
5757 // 9559: }
5758 38, 19, // 9563: case 0x26: {
5759 OPC_SwitchField, 12, 3, // 9565: switch Inst[14:12] {
5760 2, 6, // 9568: case 0x2: {
5761 OPC_CheckPredicate, 61, // 9570: check predicate 61
5762 OPC_Decode, 190, 124, 54, // 9572: decode to SSAMOSWAP_W_AQ using decoder 54
5763 // 9572: }
5764 3, 0, // 9576: case 0x3: {
5765 OPC_CheckPredicate, 62, // 9578: check predicate 62
5766 OPC_Decode, 186, 124, 54, // 9580: decode to SSAMOSWAP_D_AQ using decoder 54
5767 // 9580: }
5768 // 9580: } // switch Inst[14:12]
5769 // 9580: }
5770 39, 19, // 9584: case 0x27: {
5771 OPC_SwitchField, 12, 3, // 9586: switch Inst[14:12] {
5772 2, 6, // 9589: case 0x2: {
5773 OPC_CheckPredicate, 61, // 9591: check predicate 61
5774 OPC_Decode, 191, 124, 54, // 9593: decode to SSAMOSWAP_W_AQRL using decoder 54
5775 // 9593: }
5776 3, 0, // 9597: case 0x3: {
5777 OPC_CheckPredicate, 62, // 9599: check predicate 62
5778 OPC_Decode, 187, 124, 54, // 9601: decode to SSAMOSWAP_D_AQRL using decoder 54
5779 // 9601: }
5780 // 9601: } // switch Inst[14:12]
5781 // 9601: }
5782 48, 35, // 9605: case 0x30: {
5783 OPC_SwitchField, 12, 3, // 9607: switch Inst[14:12] {
5784 0, 6, // 9610: case 0x0: {
5785 OPC_CheckPredicate, 51, // 9612: check predicate 51
5786 OPC_Decode, 149, 109, 54, // 9614: decode to AMOAND_B using decoder 54
5787 // 9614: }
5788 1, 6, // 9618: case 0x1: {
5789 OPC_CheckPredicate, 51, // 9620: check predicate 51
5790 OPC_Decode, 157, 109, 54, // 9622: decode to AMOAND_H using decoder 54
5791 // 9622: }
5792 2, 6, // 9626: case 0x2: {
5793 OPC_CheckPredicate, 52, // 9628: check predicate 52
5794 OPC_Decode, 161, 109, 54, // 9630: decode to AMOAND_W using decoder 54
5795 // 9630: }
5796 3, 0, // 9634: case 0x3: {
5797 OPC_CheckPredicate, 53, // 9636: check predicate 53
5798 OPC_Decode, 153, 109, 54, // 9638: decode to AMOAND_D using decoder 54
5799 // 9638: }
5800 // 9638: } // switch Inst[14:12]
5801 // 9638: }
5802 49, 35, // 9642: case 0x31: {
5803 OPC_SwitchField, 12, 3, // 9644: switch Inst[14:12] {
5804 0, 6, // 9647: case 0x0: {
5805 OPC_CheckPredicate, 51, // 9649: check predicate 51
5806 OPC_Decode, 152, 109, 54, // 9651: decode to AMOAND_B_RL using decoder 54
5807 // 9651: }
5808 1, 6, // 9655: case 0x1: {
5809 OPC_CheckPredicate, 51, // 9657: check predicate 51
5810 OPC_Decode, 160, 109, 54, // 9659: decode to AMOAND_H_RL using decoder 54
5811 // 9659: }
5812 2, 6, // 9663: case 0x2: {
5813 OPC_CheckPredicate, 52, // 9665: check predicate 52
5814 OPC_Decode, 164, 109, 54, // 9667: decode to AMOAND_W_RL using decoder 54
5815 // 9667: }
5816 3, 0, // 9671: case 0x3: {
5817 OPC_CheckPredicate, 53, // 9673: check predicate 53
5818 OPC_Decode, 156, 109, 54, // 9675: decode to AMOAND_D_RL using decoder 54
5819 // 9675: }
5820 // 9675: } // switch Inst[14:12]
5821 // 9675: }
5822 50, 35, // 9679: case 0x32: {
5823 OPC_SwitchField, 12, 3, // 9681: switch Inst[14:12] {
5824 0, 6, // 9684: case 0x0: {
5825 OPC_CheckPredicate, 51, // 9686: check predicate 51
5826 OPC_Decode, 150, 109, 54, // 9688: decode to AMOAND_B_AQ using decoder 54
5827 // 9688: }
5828 1, 6, // 9692: case 0x1: {
5829 OPC_CheckPredicate, 51, // 9694: check predicate 51
5830 OPC_Decode, 158, 109, 54, // 9696: decode to AMOAND_H_AQ using decoder 54
5831 // 9696: }
5832 2, 6, // 9700: case 0x2: {
5833 OPC_CheckPredicate, 52, // 9702: check predicate 52
5834 OPC_Decode, 162, 109, 54, // 9704: decode to AMOAND_W_AQ using decoder 54
5835 // 9704: }
5836 3, 0, // 9708: case 0x3: {
5837 OPC_CheckPredicate, 53, // 9710: check predicate 53
5838 OPC_Decode, 154, 109, 54, // 9712: decode to AMOAND_D_AQ using decoder 54
5839 // 9712: }
5840 // 9712: } // switch Inst[14:12]
5841 // 9712: }
5842 51, 35, // 9716: case 0x33: {
5843 OPC_SwitchField, 12, 3, // 9718: switch Inst[14:12] {
5844 0, 6, // 9721: case 0x0: {
5845 OPC_CheckPredicate, 51, // 9723: check predicate 51
5846 OPC_Decode, 151, 109, 54, // 9725: decode to AMOAND_B_AQRL using decoder 54
5847 // 9725: }
5848 1, 6, // 9729: case 0x1: {
5849 OPC_CheckPredicate, 51, // 9731: check predicate 51
5850 OPC_Decode, 159, 109, 54, // 9733: decode to AMOAND_H_AQRL using decoder 54
5851 // 9733: }
5852 2, 6, // 9737: case 0x2: {
5853 OPC_CheckPredicate, 52, // 9739: check predicate 52
5854 OPC_Decode, 163, 109, 54, // 9741: decode to AMOAND_W_AQRL using decoder 54
5855 // 9741: }
5856 3, 0, // 9745: case 0x3: {
5857 OPC_CheckPredicate, 53, // 9747: check predicate 53
5858 OPC_Decode, 155, 109, 54, // 9749: decode to AMOAND_D_AQRL using decoder 54
5859 // 9749: }
5860 // 9749: } // switch Inst[14:12]
5861 // 9749: }
5862 64, 35, // 9753: case 0x40: {
5863 OPC_SwitchField, 12, 3, // 9755: switch Inst[14:12] {
5864 0, 6, // 9758: case 0x0: {
5865 OPC_CheckPredicate, 51, // 9760: check predicate 51
5866 OPC_Decode, 237, 109, 54, // 9762: decode to AMOMIN_B using decoder 54
5867 // 9762: }
5868 1, 6, // 9766: case 0x1: {
5869 OPC_CheckPredicate, 51, // 9768: check predicate 51
5870 OPC_Decode, 245, 109, 54, // 9770: decode to AMOMIN_H using decoder 54
5871 // 9770: }
5872 2, 6, // 9774: case 0x2: {
5873 OPC_CheckPredicate, 52, // 9776: check predicate 52
5874 OPC_Decode, 249, 109, 54, // 9778: decode to AMOMIN_W using decoder 54
5875 // 9778: }
5876 3, 0, // 9782: case 0x3: {
5877 OPC_CheckPredicate, 53, // 9784: check predicate 53
5878 OPC_Decode, 241, 109, 54, // 9786: decode to AMOMIN_D using decoder 54
5879 // 9786: }
5880 // 9786: } // switch Inst[14:12]
5881 // 9786: }
5882 65, 35, // 9790: case 0x41: {
5883 OPC_SwitchField, 12, 3, // 9792: switch Inst[14:12] {
5884 0, 6, // 9795: case 0x0: {
5885 OPC_CheckPredicate, 51, // 9797: check predicate 51
5886 OPC_Decode, 240, 109, 54, // 9799: decode to AMOMIN_B_RL using decoder 54
5887 // 9799: }
5888 1, 6, // 9803: case 0x1: {
5889 OPC_CheckPredicate, 51, // 9805: check predicate 51
5890 OPC_Decode, 248, 109, 54, // 9807: decode to AMOMIN_H_RL using decoder 54
5891 // 9807: }
5892 2, 6, // 9811: case 0x2: {
5893 OPC_CheckPredicate, 52, // 9813: check predicate 52
5894 OPC_Decode, 252, 109, 54, // 9815: decode to AMOMIN_W_RL using decoder 54
5895 // 9815: }
5896 3, 0, // 9819: case 0x3: {
5897 OPC_CheckPredicate, 53, // 9821: check predicate 53
5898 OPC_Decode, 244, 109, 54, // 9823: decode to AMOMIN_D_RL using decoder 54
5899 // 9823: }
5900 // 9823: } // switch Inst[14:12]
5901 // 9823: }
5902 66, 35, // 9827: case 0x42: {
5903 OPC_SwitchField, 12, 3, // 9829: switch Inst[14:12] {
5904 0, 6, // 9832: case 0x0: {
5905 OPC_CheckPredicate, 51, // 9834: check predicate 51
5906 OPC_Decode, 238, 109, 54, // 9836: decode to AMOMIN_B_AQ using decoder 54
5907 // 9836: }
5908 1, 6, // 9840: case 0x1: {
5909 OPC_CheckPredicate, 51, // 9842: check predicate 51
5910 OPC_Decode, 246, 109, 54, // 9844: decode to AMOMIN_H_AQ using decoder 54
5911 // 9844: }
5912 2, 6, // 9848: case 0x2: {
5913 OPC_CheckPredicate, 52, // 9850: check predicate 52
5914 OPC_Decode, 250, 109, 54, // 9852: decode to AMOMIN_W_AQ using decoder 54
5915 // 9852: }
5916 3, 0, // 9856: case 0x3: {
5917 OPC_CheckPredicate, 53, // 9858: check predicate 53
5918 OPC_Decode, 242, 109, 54, // 9860: decode to AMOMIN_D_AQ using decoder 54
5919 // 9860: }
5920 // 9860: } // switch Inst[14:12]
5921 // 9860: }
5922 67, 35, // 9864: case 0x43: {
5923 OPC_SwitchField, 12, 3, // 9866: switch Inst[14:12] {
5924 0, 6, // 9869: case 0x0: {
5925 OPC_CheckPredicate, 51, // 9871: check predicate 51
5926 OPC_Decode, 239, 109, 54, // 9873: decode to AMOMIN_B_AQRL using decoder 54
5927 // 9873: }
5928 1, 6, // 9877: case 0x1: {
5929 OPC_CheckPredicate, 51, // 9879: check predicate 51
5930 OPC_Decode, 247, 109, 54, // 9881: decode to AMOMIN_H_AQRL using decoder 54
5931 // 9881: }
5932 2, 6, // 9885: case 0x2: {
5933 OPC_CheckPredicate, 52, // 9887: check predicate 52
5934 OPC_Decode, 251, 109, 54, // 9889: decode to AMOMIN_W_AQRL using decoder 54
5935 // 9889: }
5936 3, 0, // 9893: case 0x3: {
5937 OPC_CheckPredicate, 53, // 9895: check predicate 53
5938 OPC_Decode, 243, 109, 54, // 9897: decode to AMOMIN_D_AQRL using decoder 54
5939 // 9897: }
5940 // 9897: } // switch Inst[14:12]
5941 // 9897: }
5942 80, 35, // 9901: case 0x50: {
5943 OPC_SwitchField, 12, 3, // 9903: switch Inst[14:12] {
5944 0, 6, // 9906: case 0x0: {
5945 OPC_CheckPredicate, 51, // 9908: check predicate 51
5946 OPC_Decode, 205, 109, 54, // 9910: decode to AMOMAX_B using decoder 54
5947 // 9910: }
5948 1, 6, // 9914: case 0x1: {
5949 OPC_CheckPredicate, 51, // 9916: check predicate 51
5950 OPC_Decode, 213, 109, 54, // 9918: decode to AMOMAX_H using decoder 54
5951 // 9918: }
5952 2, 6, // 9922: case 0x2: {
5953 OPC_CheckPredicate, 52, // 9924: check predicate 52
5954 OPC_Decode, 217, 109, 54, // 9926: decode to AMOMAX_W using decoder 54
5955 // 9926: }
5956 3, 0, // 9930: case 0x3: {
5957 OPC_CheckPredicate, 53, // 9932: check predicate 53
5958 OPC_Decode, 209, 109, 54, // 9934: decode to AMOMAX_D using decoder 54
5959 // 9934: }
5960 // 9934: } // switch Inst[14:12]
5961 // 9934: }
5962 81, 35, // 9938: case 0x51: {
5963 OPC_SwitchField, 12, 3, // 9940: switch Inst[14:12] {
5964 0, 6, // 9943: case 0x0: {
5965 OPC_CheckPredicate, 51, // 9945: check predicate 51
5966 OPC_Decode, 208, 109, 54, // 9947: decode to AMOMAX_B_RL using decoder 54
5967 // 9947: }
5968 1, 6, // 9951: case 0x1: {
5969 OPC_CheckPredicate, 51, // 9953: check predicate 51
5970 OPC_Decode, 216, 109, 54, // 9955: decode to AMOMAX_H_RL using decoder 54
5971 // 9955: }
5972 2, 6, // 9959: case 0x2: {
5973 OPC_CheckPredicate, 52, // 9961: check predicate 52
5974 OPC_Decode, 220, 109, 54, // 9963: decode to AMOMAX_W_RL using decoder 54
5975 // 9963: }
5976 3, 0, // 9967: case 0x3: {
5977 OPC_CheckPredicate, 53, // 9969: check predicate 53
5978 OPC_Decode, 212, 109, 54, // 9971: decode to AMOMAX_D_RL using decoder 54
5979 // 9971: }
5980 // 9971: } // switch Inst[14:12]
5981 // 9971: }
5982 82, 35, // 9975: case 0x52: {
5983 OPC_SwitchField, 12, 3, // 9977: switch Inst[14:12] {
5984 0, 6, // 9980: case 0x0: {
5985 OPC_CheckPredicate, 51, // 9982: check predicate 51
5986 OPC_Decode, 206, 109, 54, // 9984: decode to AMOMAX_B_AQ using decoder 54
5987 // 9984: }
5988 1, 6, // 9988: case 0x1: {
5989 OPC_CheckPredicate, 51, // 9990: check predicate 51
5990 OPC_Decode, 214, 109, 54, // 9992: decode to AMOMAX_H_AQ using decoder 54
5991 // 9992: }
5992 2, 6, // 9996: case 0x2: {
5993 OPC_CheckPredicate, 52, // 9998: check predicate 52
5994 OPC_Decode, 218, 109, 54, // 10000: decode to AMOMAX_W_AQ using decoder 54
5995 // 10000: }
5996 3, 0, // 10004: case 0x3: {
5997 OPC_CheckPredicate, 53, // 10006: check predicate 53
5998 OPC_Decode, 210, 109, 54, // 10008: decode to AMOMAX_D_AQ using decoder 54
5999 // 10008: }
6000 // 10008: } // switch Inst[14:12]
6001 // 10008: }
6002 83, 35, // 10012: case 0x53: {
6003 OPC_SwitchField, 12, 3, // 10014: switch Inst[14:12] {
6004 0, 6, // 10017: case 0x0: {
6005 OPC_CheckPredicate, 51, // 10019: check predicate 51
6006 OPC_Decode, 207, 109, 54, // 10021: decode to AMOMAX_B_AQRL using decoder 54
6007 // 10021: }
6008 1, 6, // 10025: case 0x1: {
6009 OPC_CheckPredicate, 51, // 10027: check predicate 51
6010 OPC_Decode, 215, 109, 54, // 10029: decode to AMOMAX_H_AQRL using decoder 54
6011 // 10029: }
6012 2, 6, // 10033: case 0x2: {
6013 OPC_CheckPredicate, 52, // 10035: check predicate 52
6014 OPC_Decode, 219, 109, 54, // 10037: decode to AMOMAX_W_AQRL using decoder 54
6015 // 10037: }
6016 3, 0, // 10041: case 0x3: {
6017 OPC_CheckPredicate, 53, // 10043: check predicate 53
6018 OPC_Decode, 211, 109, 54, // 10045: decode to AMOMAX_D_AQRL using decoder 54
6019 // 10045: }
6020 // 10045: } // switch Inst[14:12]
6021 // 10045: }
6022 96, 35, // 10049: case 0x60: {
6023 OPC_SwitchField, 12, 3, // 10051: switch Inst[14:12] {
6024 0, 6, // 10054: case 0x0: {
6025 OPC_CheckPredicate, 51, // 10056: check predicate 51
6026 OPC_Decode, 221, 109, 54, // 10058: decode to AMOMINU_B using decoder 54
6027 // 10058: }
6028 1, 6, // 10062: case 0x1: {
6029 OPC_CheckPredicate, 51, // 10064: check predicate 51
6030 OPC_Decode, 229, 109, 54, // 10066: decode to AMOMINU_H using decoder 54
6031 // 10066: }
6032 2, 6, // 10070: case 0x2: {
6033 OPC_CheckPredicate, 52, // 10072: check predicate 52
6034 OPC_Decode, 233, 109, 54, // 10074: decode to AMOMINU_W using decoder 54
6035 // 10074: }
6036 3, 0, // 10078: case 0x3: {
6037 OPC_CheckPredicate, 53, // 10080: check predicate 53
6038 OPC_Decode, 225, 109, 54, // 10082: decode to AMOMINU_D using decoder 54
6039 // 10082: }
6040 // 10082: } // switch Inst[14:12]
6041 // 10082: }
6042 97, 35, // 10086: case 0x61: {
6043 OPC_SwitchField, 12, 3, // 10088: switch Inst[14:12] {
6044 0, 6, // 10091: case 0x0: {
6045 OPC_CheckPredicate, 51, // 10093: check predicate 51
6046 OPC_Decode, 224, 109, 54, // 10095: decode to AMOMINU_B_RL using decoder 54
6047 // 10095: }
6048 1, 6, // 10099: case 0x1: {
6049 OPC_CheckPredicate, 51, // 10101: check predicate 51
6050 OPC_Decode, 232, 109, 54, // 10103: decode to AMOMINU_H_RL using decoder 54
6051 // 10103: }
6052 2, 6, // 10107: case 0x2: {
6053 OPC_CheckPredicate, 52, // 10109: check predicate 52
6054 OPC_Decode, 236, 109, 54, // 10111: decode to AMOMINU_W_RL using decoder 54
6055 // 10111: }
6056 3, 0, // 10115: case 0x3: {
6057 OPC_CheckPredicate, 53, // 10117: check predicate 53
6058 OPC_Decode, 228, 109, 54, // 10119: decode to AMOMINU_D_RL using decoder 54
6059 // 10119: }
6060 // 10119: } // switch Inst[14:12]
6061 // 10119: }
6062 98, 35, // 10123: case 0x62: {
6063 OPC_SwitchField, 12, 3, // 10125: switch Inst[14:12] {
6064 0, 6, // 10128: case 0x0: {
6065 OPC_CheckPredicate, 51, // 10130: check predicate 51
6066 OPC_Decode, 222, 109, 54, // 10132: decode to AMOMINU_B_AQ using decoder 54
6067 // 10132: }
6068 1, 6, // 10136: case 0x1: {
6069 OPC_CheckPredicate, 51, // 10138: check predicate 51
6070 OPC_Decode, 230, 109, 54, // 10140: decode to AMOMINU_H_AQ using decoder 54
6071 // 10140: }
6072 2, 6, // 10144: case 0x2: {
6073 OPC_CheckPredicate, 52, // 10146: check predicate 52
6074 OPC_Decode, 234, 109, 54, // 10148: decode to AMOMINU_W_AQ using decoder 54
6075 // 10148: }
6076 3, 0, // 10152: case 0x3: {
6077 OPC_CheckPredicate, 53, // 10154: check predicate 53
6078 OPC_Decode, 226, 109, 54, // 10156: decode to AMOMINU_D_AQ using decoder 54
6079 // 10156: }
6080 // 10156: } // switch Inst[14:12]
6081 // 10156: }
6082 99, 35, // 10160: case 0x63: {
6083 OPC_SwitchField, 12, 3, // 10162: switch Inst[14:12] {
6084 0, 6, // 10165: case 0x0: {
6085 OPC_CheckPredicate, 51, // 10167: check predicate 51
6086 OPC_Decode, 223, 109, 54, // 10169: decode to AMOMINU_B_AQRL using decoder 54
6087 // 10169: }
6088 1, 6, // 10173: case 0x1: {
6089 OPC_CheckPredicate, 51, // 10175: check predicate 51
6090 OPC_Decode, 231, 109, 54, // 10177: decode to AMOMINU_H_AQRL using decoder 54
6091 // 10177: }
6092 2, 6, // 10181: case 0x2: {
6093 OPC_CheckPredicate, 52, // 10183: check predicate 52
6094 OPC_Decode, 235, 109, 54, // 10185: decode to AMOMINU_W_AQRL using decoder 54
6095 // 10185: }
6096 3, 0, // 10189: case 0x3: {
6097 OPC_CheckPredicate, 53, // 10191: check predicate 53
6098 OPC_Decode, 227, 109, 54, // 10193: decode to AMOMINU_D_AQRL using decoder 54
6099 // 10193: }
6100 // 10193: } // switch Inst[14:12]
6101 // 10193: }
6102 112, 35, // 10197: case 0x70: {
6103 OPC_SwitchField, 12, 3, // 10199: switch Inst[14:12] {
6104 0, 6, // 10202: case 0x0: {
6105 OPC_CheckPredicate, 51, // 10204: check predicate 51
6106 OPC_Decode, 189, 109, 54, // 10206: decode to AMOMAXU_B using decoder 54
6107 // 10206: }
6108 1, 6, // 10210: case 0x1: {
6109 OPC_CheckPredicate, 51, // 10212: check predicate 51
6110 OPC_Decode, 197, 109, 54, // 10214: decode to AMOMAXU_H using decoder 54
6111 // 10214: }
6112 2, 6, // 10218: case 0x2: {
6113 OPC_CheckPredicate, 52, // 10220: check predicate 52
6114 OPC_Decode, 201, 109, 54, // 10222: decode to AMOMAXU_W using decoder 54
6115 // 10222: }
6116 3, 0, // 10226: case 0x3: {
6117 OPC_CheckPredicate, 53, // 10228: check predicate 53
6118 OPC_Decode, 193, 109, 54, // 10230: decode to AMOMAXU_D using decoder 54
6119 // 10230: }
6120 // 10230: } // switch Inst[14:12]
6121 // 10230: }
6122 113, 35, // 10234: case 0x71: {
6123 OPC_SwitchField, 12, 3, // 10236: switch Inst[14:12] {
6124 0, 6, // 10239: case 0x0: {
6125 OPC_CheckPredicate, 51, // 10241: check predicate 51
6126 OPC_Decode, 192, 109, 54, // 10243: decode to AMOMAXU_B_RL using decoder 54
6127 // 10243: }
6128 1, 6, // 10247: case 0x1: {
6129 OPC_CheckPredicate, 51, // 10249: check predicate 51
6130 OPC_Decode, 200, 109, 54, // 10251: decode to AMOMAXU_H_RL using decoder 54
6131 // 10251: }
6132 2, 6, // 10255: case 0x2: {
6133 OPC_CheckPredicate, 52, // 10257: check predicate 52
6134 OPC_Decode, 204, 109, 54, // 10259: decode to AMOMAXU_W_RL using decoder 54
6135 // 10259: }
6136 3, 0, // 10263: case 0x3: {
6137 OPC_CheckPredicate, 53, // 10265: check predicate 53
6138 OPC_Decode, 196, 109, 54, // 10267: decode to AMOMAXU_D_RL using decoder 54
6139 // 10267: }
6140 // 10267: } // switch Inst[14:12]
6141 // 10267: }
6142 114, 35, // 10271: case 0x72: {
6143 OPC_SwitchField, 12, 3, // 10273: switch Inst[14:12] {
6144 0, 6, // 10276: case 0x0: {
6145 OPC_CheckPredicate, 51, // 10278: check predicate 51
6146 OPC_Decode, 190, 109, 54, // 10280: decode to AMOMAXU_B_AQ using decoder 54
6147 // 10280: }
6148 1, 6, // 10284: case 0x1: {
6149 OPC_CheckPredicate, 51, // 10286: check predicate 51
6150 OPC_Decode, 198, 109, 54, // 10288: decode to AMOMAXU_H_AQ using decoder 54
6151 // 10288: }
6152 2, 6, // 10292: case 0x2: {
6153 OPC_CheckPredicate, 52, // 10294: check predicate 52
6154 OPC_Decode, 202, 109, 54, // 10296: decode to AMOMAXU_W_AQ using decoder 54
6155 // 10296: }
6156 3, 0, // 10300: case 0x3: {
6157 OPC_CheckPredicate, 53, // 10302: check predicate 53
6158 OPC_Decode, 194, 109, 54, // 10304: decode to AMOMAXU_D_AQ using decoder 54
6159 // 10304: }
6160 // 10304: } // switch Inst[14:12]
6161 // 10304: }
6162 115, 0, // 10308: case 0x73: {
6163 OPC_SwitchField, 12, 3, // 10310: switch Inst[14:12] {
6164 0, 6, // 10313: case 0x0: {
6165 OPC_CheckPredicate, 51, // 10315: check predicate 51
6166 OPC_Decode, 191, 109, 54, // 10317: decode to AMOMAXU_B_AQRL using decoder 54
6167 // 10317: }
6168 1, 6, // 10321: case 0x1: {
6169 OPC_CheckPredicate, 51, // 10323: check predicate 51
6170 OPC_Decode, 199, 109, 54, // 10325: decode to AMOMAXU_H_AQRL using decoder 54
6171 // 10325: }
6172 2, 6, // 10329: case 0x2: {
6173 OPC_CheckPredicate, 52, // 10331: check predicate 52
6174 OPC_Decode, 203, 109, 54, // 10333: decode to AMOMAXU_W_AQRL using decoder 54
6175 // 10333: }
6176 3, 0, // 10337: case 0x3: {
6177 OPC_CheckPredicate, 53, // 10339: check predicate 53
6178 OPC_Decode, 195, 109, 54, // 10341: decode to AMOMAXU_D_AQRL using decoder 54
6179 // 10341: }
6180 // 10341: } // switch Inst[14:12]
6181 // 10341: }
6182 // 10341: } // switch Inst[31:25]
6183 // 10341: }
6184 51, 138, 6, // 10345: case 0x33: {
6185 OPC_SwitchField, 25, 5, // 10348: switch Inst[29:25] {
6186 0, 126, // 10351: case 0x0: {
6187 OPC_SwitchField, 12, 3, // 10353: switch Inst[14:12] {
6188 0, 15, // 10356: case 0x0: {
6189 OPC_SwitchField, 30, 2, // 10358: switch Inst[31:30] {
6190 0, 4, // 10361: case 0x0: {
6191 OPC_Decode, 159, 107, 31, // 10363: decode to ADD using decoder 31
6192 // 10363: }
6193 1, 0, // 10367: case 0x1: {
6194 OPC_Decode, 204, 124, 31, // 10369: decode to SUB using decoder 31
6195 // 10369: }
6196 // 10369: } // switch Inst[31:30]
6197 // 10369: }
6198 1, 8, // 10373: case 0x1: {
6199 OPC_CheckField, 30, 2, 0, // 10375: check Inst[31:30] == 0x0
6200 OPC_Decode, 142, 124, 31, // 10379: decode to SLL using decoder 31
6201 // 10379: }
6202 2, 8, // 10383: case 0x2: {
6203 OPC_CheckField, 30, 2, 0, // 10385: check Inst[31:30] == 0x0
6204 OPC_Decode, 147, 124, 31, // 10389: decode to SLT using decoder 31
6205 // 10389: }
6206 3, 8, // 10393: case 0x3: {
6207 OPC_CheckField, 30, 2, 0, // 10395: check Inst[31:30] == 0x0
6208 OPC_Decode, 150, 124, 31, // 10399: decode to SLTU using decoder 31
6209 // 10399: }
6210 4, 19, // 10403: case 0x4: {
6211 OPC_SwitchField, 30, 2, // 10405: switch Inst[31:30] {
6212 0, 5, // 10408: case 0x0: {
6213 OPC_Decode, 181, 131, 1, 31, // 10410: decode to XOR using decoder 31
6214 // 10410: }
6215 1, 0, // 10415: case 0x1: {
6216 OPC_CheckPredicate, 43, // 10417: check predicate 43
6217 OPC_Decode, 180, 131, 1, 31, // 10419: decode to XNOR using decoder 31
6218 // 10419: }
6219 // 10419: } // switch Inst[31:30]
6220 // 10419: }
6221 5, 15, // 10424: case 0x5: {
6222 OPC_SwitchField, 30, 2, // 10426: switch Inst[31:30] {
6223 0, 4, // 10429: case 0x0: {
6224 OPC_Decode, 179, 124, 31, // 10431: decode to SRL using decoder 31
6225 // 10431: }
6226 1, 0, // 10435: case 0x1: {
6227 OPC_Decode, 172, 124, 31, // 10437: decode to SRA using decoder 31
6228 // 10437: }
6229 // 10437: } // switch Inst[31:30]
6230 // 10437: }
6231 6, 17, // 10441: case 0x6: {
6232 OPC_SwitchField, 30, 2, // 10443: switch Inst[31:30] {
6233 0, 4, // 10446: case 0x0: {
6234 OPC_Decode, 138, 118, 31, // 10448: decode to OR using decoder 31
6235 // 10448: }
6236 1, 0, // 10452: case 0x1: {
6237 OPC_CheckPredicate, 43, // 10454: check predicate 43
6238 OPC_Decode, 141, 118, 31, // 10456: decode to ORN using decoder 31
6239 // 10456: }
6240 // 10456: } // switch Inst[31:30]
6241 // 10456: }
6242 7, 0, // 10460: case 0x7: {
6243 OPC_SwitchField, 30, 2, // 10462: switch Inst[31:30] {
6244 0, 4, // 10465: case 0x0: {
6245 OPC_Decode, 173, 110, 31, // 10467: decode to AND using decoder 31
6246 // 10467: }
6247 1, 0, // 10471: case 0x1: {
6248 OPC_CheckPredicate, 43, // 10473: check predicate 43
6249 OPC_Decode, 175, 110, 31, // 10475: decode to ANDN using decoder 31
6250 // 10475: }
6251 // 10475: } // switch Inst[31:30]
6252 // 10475: }
6253 // 10475: } // switch Inst[14:12]
6254 // 10475: }
6255 1, 99, // 10479: case 0x1: {
6256 OPC_SwitchField, 12, 3, // 10481: switch Inst[14:12] {
6257 0, 10, // 10484: case 0x0: {
6258 OPC_CheckPredicate, 63, // 10486: check predicate 63
6259 OPC_CheckField, 30, 2, 0, // 10488: check Inst[31:30] == 0x0
6260 OPC_Decode, 173, 117, 31, // 10492: decode to MUL using decoder 31
6261 // 10492: }
6262 1, 10, // 10496: case 0x1: {
6263 OPC_CheckPredicate, 63, // 10498: check predicate 63
6264 OPC_CheckField, 30, 2, 0, // 10500: check Inst[31:30] == 0x0
6265 OPC_Decode, 174, 117, 31, // 10504: decode to MULH using decoder 31
6266 // 10504: }
6267 2, 10, // 10508: case 0x2: {
6268 OPC_CheckPredicate, 63, // 10510: check predicate 63
6269 OPC_CheckField, 30, 2, 0, // 10512: check Inst[31:30] == 0x0
6270 OPC_Decode, 178, 117, 31, // 10516: decode to MULHSU using decoder 31
6271 // 10516: }
6272 3, 10, // 10520: case 0x3: {
6273 OPC_CheckPredicate, 63, // 10522: check predicate 63
6274 OPC_CheckField, 30, 2, 0, // 10524: check Inst[31:30] == 0x0
6275 OPC_Decode, 181, 117, 31, // 10528: decode to MULHU using decoder 31
6276 // 10528: }
6277 4, 10, // 10532: case 0x4: {
6278 OPC_CheckPredicate, 64, // 10534: check predicate 64
6279 OPC_CheckField, 30, 2, 0, // 10536: check Inst[31:30] == 0x0
6280 OPC_Decode, 229, 113, 31, // 10540: decode to DIV using decoder 31
6281 // 10540: }
6282 5, 10, // 10544: case 0x5: {
6283 OPC_CheckPredicate, 64, // 10546: check predicate 64
6284 OPC_CheckField, 30, 2, 0, // 10548: check Inst[31:30] == 0x0
6285 OPC_Decode, 230, 113, 31, // 10552: decode to DIVU using decoder 31
6286 // 10552: }
6287 6, 10, // 10556: case 0x6: {
6288 OPC_CheckPredicate, 64, // 10558: check predicate 64
6289 OPC_CheckField, 30, 2, 0, // 10560: check Inst[31:30] == 0x0
6290 OPC_Decode, 133, 123, 31, // 10564: decode to REM using decoder 31
6291 // 10564: }
6292 7, 0, // 10568: case 0x7: {
6293 OPC_CheckPredicate, 64, // 10570: check predicate 64
6294 OPC_CheckField, 30, 2, 0, // 10572: check Inst[31:30] == 0x0
6295 OPC_Decode, 134, 123, 31, // 10576: decode to REMU using decoder 31
6296 // 10576: }
6297 // 10576: } // switch Inst[14:12]
6298 // 10576: }
6299 4, 64, // 10580: case 0x4: {
6300 OPC_SwitchField, 12, 3, // 10582: switch Inst[14:12] {
6301 1, 10, // 10585: case 0x1: {
6302 OPC_CheckPredicate, 38, // 10587: check predicate 38
6303 OPC_CheckField, 30, 2, 1, // 10589: check Inst[31:30] == 0x1
6304 OPC_Decode, 179, 110, 31, // 10593: decode to BCLR using decoder 31
6305 // 10593: }
6306 4, 23, // 10597: case 0x4: {
6307 OPC_CheckField, 30, 2, 0, // 10599: check Inst[31:30] == 0x0
6308 OPC_Scope, 11, // 10603: try {
6309 OPC_CheckField, 20, 5, 0, // 10605: check Inst[24:20] == 0x0
6310 OPC_CheckPredicate, 45, // 10609: check predicate 45
6311 OPC_Decode, 204, 131, 1, 17, // 10611: decode to ZEXT_H_RV32 using decoder 17
6312 // 10611: } else try {
6313 OPC_CheckPredicate, 65, // 10616: check predicate 65
6314 OPC_Decode, 167, 118, 31, // 10618: decode to PACK using decoder 31
6315 // 10618: }
6316 // 10618: }
6317 5, 10, // 10622: case 0x5: {
6318 OPC_CheckPredicate, 38, // 10624: check predicate 38
6319 OPC_CheckField, 30, 2, 1, // 10626: check Inst[31:30] == 0x1
6320 OPC_Decode, 183, 110, 31, // 10630: decode to BEXT using decoder 31
6321 // 10630: }
6322 7, 0, // 10634: case 0x7: {
6323 OPC_CheckPredicate, 44, // 10636: check predicate 44
6324 OPC_CheckField, 30, 2, 0, // 10638: check Inst[31:30] == 0x0
6325 OPC_Decode, 168, 118, 31, // 10642: decode to PACKH using decoder 31
6326 // 10642: }
6327 // 10642: } // switch Inst[14:12]
6328 // 10642: }
6329 5, 87, // 10646: case 0x5: {
6330 OPC_SwitchField, 12, 3, // 10648: switch Inst[14:12] {
6331 1, 10, // 10651: case 0x1: {
6332 OPC_CheckPredicate, 66, // 10653: check predicate 66
6333 OPC_CheckField, 30, 2, 0, // 10655: check Inst[31:30] == 0x0
6334 OPC_Decode, 200, 110, 31, // 10659: decode to CLMUL using decoder 31
6335 // 10659: }
6336 2, 10, // 10663: case 0x2: {
6337 OPC_CheckPredicate, 67, // 10665: check predicate 67
6338 OPC_CheckField, 30, 2, 0, // 10667: check Inst[31:30] == 0x0
6339 OPC_Decode, 202, 110, 31, // 10671: decode to CLMULR using decoder 31
6340 // 10671: }
6341 3, 10, // 10675: case 0x3: {
6342 OPC_CheckPredicate, 66, // 10677: check predicate 66
6343 OPC_CheckField, 30, 2, 0, // 10679: check Inst[31:30] == 0x0
6344 OPC_Decode, 201, 110, 31, // 10683: decode to CLMULH using decoder 31
6345 // 10683: }
6346 4, 10, // 10687: case 0x4: {
6347 OPC_CheckPredicate, 41, // 10689: check predicate 41
6348 OPC_CheckField, 30, 2, 0, // 10691: check Inst[31:30] == 0x0
6349 OPC_Decode, 231, 116, 31, // 10695: decode to MIN using decoder 31
6350 // 10695: }
6351 5, 10, // 10699: case 0x5: {
6352 OPC_CheckPredicate, 41, // 10701: check predicate 41
6353 OPC_CheckField, 30, 2, 0, // 10703: check Inst[31:30] == 0x0
6354 OPC_Decode, 232, 116, 31, // 10707: decode to MINU using decoder 31
6355 // 10707: }
6356 6, 10, // 10711: case 0x6: {
6357 OPC_CheckPredicate, 41, // 10713: check predicate 41
6358 OPC_CheckField, 30, 2, 0, // 10715: check Inst[31:30] == 0x0
6359 OPC_Decode, 218, 116, 31, // 10719: decode to MAX using decoder 31
6360 // 10719: }
6361 7, 0, // 10723: case 0x7: {
6362 OPC_CheckPredicate, 41, // 10725: check predicate 41
6363 OPC_CheckField, 30, 2, 0, // 10727: check Inst[31:30] == 0x0
6364 OPC_Decode, 219, 116, 31, // 10731: decode to MAXU using decoder 31
6365 // 10731: }
6366 // 10731: } // switch Inst[14:12]
6367 // 10731: }
6368 7, 27, // 10735: case 0x7: {
6369 OPC_SwitchField, 12, 3, // 10737: switch Inst[14:12] {
6370 5, 10, // 10740: case 0x5: {
6371 OPC_CheckPredicate, 68, // 10742: check predicate 68
6372 OPC_CheckField, 30, 2, 0, // 10744: check Inst[31:30] == 0x0
6373 OPC_Decode, 153, 113, 31, // 10748: decode to CZERO_EQZ using decoder 31
6374 // 10748: }
6375 7, 0, // 10752: case 0x7: {
6376 OPC_CheckPredicate, 68, // 10754: check predicate 68
6377 OPC_CheckField, 30, 2, 0, // 10756: check Inst[31:30] == 0x0
6378 OPC_Decode, 154, 113, 31, // 10760: decode to CZERO_NEZ using decoder 31
6379 // 10760: }
6380 // 10760: } // switch Inst[14:12]
6381 // 10760: }
6382 8, 14, // 10764: case 0x8: {
6383 OPC_CheckPredicate, 69, // 10766: check predicate 69
6384 OPC_CheckField, 30, 2, 1, // 10768: check Inst[31:30] == 0x1
6385 OPC_CheckField, 12, 3, 0, // 10772: check Inst[14:12] == 0x0
6386 OPC_Decode, 132, 124, 31, // 10776: decode to SHA512SUM0R using decoder 31
6387 // 10776: }
6388 9, 14, // 10780: case 0x9: {
6389 OPC_CheckPredicate, 69, // 10782: check predicate 69
6390 OPC_CheckField, 30, 2, 1, // 10784: check Inst[31:30] == 0x1
6391 OPC_CheckField, 12, 3, 0, // 10788: check Inst[14:12] == 0x0
6392 OPC_Decode, 134, 124, 31, // 10792: decode to SHA512SUM1R using decoder 31
6393 // 10792: }
6394 10, 14, // 10796: case 0xa: {
6395 OPC_CheckPredicate, 69, // 10798: check predicate 69
6396 OPC_CheckField, 30, 2, 1, // 10800: check Inst[31:30] == 0x1
6397 OPC_CheckField, 12, 3, 0, // 10804: check Inst[14:12] == 0x0
6398 OPC_Decode, 255, 123, 31, // 10808: decode to SHA512SIG0L using decoder 31
6399 // 10808: }
6400 11, 14, // 10812: case 0xb: {
6401 OPC_CheckPredicate, 69, // 10814: check predicate 69
6402 OPC_CheckField, 30, 2, 1, // 10816: check Inst[31:30] == 0x1
6403 OPC_CheckField, 12, 3, 0, // 10820: check Inst[14:12] == 0x0
6404 OPC_Decode, 130, 124, 31, // 10824: decode to SHA512SIG1L using decoder 31
6405 // 10824: }
6406 14, 14, // 10828: case 0xe: {
6407 OPC_CheckPredicate, 69, // 10830: check predicate 69
6408 OPC_CheckField, 30, 2, 1, // 10832: check Inst[31:30] == 0x1
6409 OPC_CheckField, 12, 3, 0, // 10836: check Inst[14:12] == 0x0
6410 OPC_Decode, 254, 123, 31, // 10840: decode to SHA512SIG0H using decoder 31
6411 // 10840: }
6412 15, 14, // 10844: case 0xf: {
6413 OPC_CheckPredicate, 69, // 10846: check predicate 69
6414 OPC_CheckField, 30, 2, 1, // 10848: check Inst[31:30] == 0x1
6415 OPC_CheckField, 12, 3, 0, // 10852: check Inst[14:12] == 0x0
6416 OPC_Decode, 129, 124, 31, // 10856: decode to SHA512SIG1H using decoder 31
6417 // 10856: }
6418 16, 63, // 10860: case 0x10: {
6419 OPC_SwitchField, 12, 3, // 10862: switch Inst[14:12] {
6420 1, 10, // 10865: case 0x1: {
6421 OPC_CheckPredicate, 43, // 10867: check predicate 43
6422 OPC_CheckField, 30, 2, 1, // 10869: check Inst[31:30] == 0x1
6423 OPC_Decode, 142, 123, 31, // 10873: decode to ROL using decoder 31
6424 // 10873: }
6425 2, 10, // 10877: case 0x2: {
6426 OPC_CheckPredicate, 70, // 10879: check predicate 70
6427 OPC_CheckField, 30, 2, 0, // 10881: check Inst[31:30] == 0x0
6428 OPC_Decode, 242, 123, 31, // 10885: decode to SH1ADD using decoder 31
6429 // 10885: }
6430 4, 10, // 10889: case 0x4: {
6431 OPC_CheckPredicate, 70, // 10891: check predicate 70
6432 OPC_CheckField, 30, 2, 0, // 10893: check Inst[31:30] == 0x0
6433 OPC_Decode, 244, 123, 31, // 10897: decode to SH2ADD using decoder 31
6434 // 10897: }
6435 5, 10, // 10901: case 0x5: {
6436 OPC_CheckPredicate, 43, // 10903: check predicate 43
6437 OPC_CheckField, 30, 2, 1, // 10905: check Inst[31:30] == 0x1
6438 OPC_Decode, 144, 123, 31, // 10909: decode to ROR using decoder 31
6439 // 10909: }
6440 6, 0, // 10913: case 0x6: {
6441 OPC_CheckPredicate, 70, // 10915: check predicate 70
6442 OPC_CheckField, 30, 2, 0, // 10917: check Inst[31:30] == 0x0
6443 OPC_Decode, 246, 123, 31, // 10921: decode to SH3ADD using decoder 31
6444 // 10921: }
6445 // 10921: } // switch Inst[14:12]
6446 // 10921: }
6447 17, 10, // 10925: case 0x11: {
6448 OPC_CheckPredicate, 71, // 10927: check predicate 71
6449 OPC_CheckField, 12, 3, 0, // 10929: check Inst[14:12] == 0x0
6450 OPC_Decode, 167, 107, 58, // 10933: decode to AES32ESI using decoder 58
6451 // 10933: }
6452 19, 10, // 10937: case 0x13: {
6453 OPC_CheckPredicate, 71, // 10939: check predicate 71
6454 OPC_CheckField, 12, 3, 0, // 10941: check Inst[14:12] == 0x0
6455 OPC_Decode, 168, 107, 58, // 10945: decode to AES32ESMI using decoder 58
6456 // 10945: }
6457 20, 50, // 10949: case 0x14: {
6458 OPC_SwitchField, 12, 3, // 10951: switch Inst[14:12] {
6459 1, 19, // 10954: case 0x1: {
6460 OPC_SwitchField, 30, 2, // 10956: switch Inst[31:30] {
6461 0, 6, // 10959: case 0x0: {
6462 OPC_CheckPredicate, 38, // 10961: check predicate 38
6463 OPC_Decode, 194, 110, 31, // 10963: decode to BSET using decoder 31
6464 // 10963: }
6465 1, 0, // 10967: case 0x1: {
6466 OPC_CheckPredicate, 38, // 10969: check predicate 38
6467 OPC_Decode, 187, 110, 31, // 10971: decode to BINV using decoder 31
6468 // 10971: }
6469 // 10971: } // switch Inst[31:30]
6470 // 10971: }
6471 2, 11, // 10975: case 0x2: {
6472 OPC_CheckPredicate, 72, // 10977: check predicate 72
6473 OPC_CheckField, 30, 2, 0, // 10979: check Inst[31:30] == 0x0
6474 OPC_Decode, 183, 131, 1, 31, // 10983: decode to XPERM4 using decoder 31
6475 // 10983: }
6476 4, 0, // 10988: case 0x4: {
6477 OPC_CheckPredicate, 72, // 10990: check predicate 72
6478 OPC_CheckField, 30, 2, 0, // 10992: check Inst[31:30] == 0x0
6479 OPC_Decode, 184, 131, 1, 31, // 10996: decode to XPERM8 using decoder 31
6480 // 10996: }
6481 // 10996: } // switch Inst[14:12]
6482 // 10996: }
6483 21, 10, // 11001: case 0x15: {
6484 OPC_CheckPredicate, 73, // 11003: check predicate 73
6485 OPC_CheckField, 12, 3, 0, // 11005: check Inst[14:12] == 0x0
6486 OPC_Decode, 165, 107, 58, // 11009: decode to AES32DSI using decoder 58
6487 // 11009: }
6488 23, 10, // 11013: case 0x17: {
6489 OPC_CheckPredicate, 73, // 11015: check predicate 73
6490 OPC_CheckField, 12, 3, 0, // 11017: check Inst[14:12] == 0x0
6491 OPC_Decode, 166, 107, 58, // 11021: decode to AES32DSMI using decoder 58
6492 // 11021: }
6493 24, 10, // 11025: case 0x18: {
6494 OPC_CheckPredicate, 74, // 11027: check predicate 74
6495 OPC_CheckField, 12, 3, 0, // 11029: check Inst[14:12] == 0x0
6496 OPC_Decode, 154, 124, 58, // 11033: decode to SM4ED using decoder 58
6497 // 11033: }
6498 25, 14, // 11037: case 0x19: {
6499 OPC_CheckPredicate, 75, // 11039: check predicate 75
6500 OPC_CheckField, 30, 2, 0, // 11041: check Inst[31:30] == 0x0
6501 OPC_CheckField, 12, 3, 0, // 11045: check Inst[14:12] == 0x0
6502 OPC_Decode, 171, 107, 31, // 11049: decode to AES64ES using decoder 31
6503 // 11049: }
6504 26, 10, // 11053: case 0x1a: {
6505 OPC_CheckPredicate, 74, // 11055: check predicate 74
6506 OPC_CheckField, 12, 3, 0, // 11057: check Inst[14:12] == 0x0
6507 OPC_Decode, 155, 124, 58, // 11061: decode to SM4KS using decoder 58
6508 // 11061: }
6509 27, 14, // 11065: case 0x1b: {
6510 OPC_CheckPredicate, 75, // 11067: check predicate 75
6511 OPC_CheckField, 30, 2, 0, // 11069: check Inst[31:30] == 0x0
6512 OPC_CheckField, 12, 3, 0, // 11073: check Inst[14:12] == 0x0
6513 OPC_Decode, 172, 107, 31, // 11077: decode to AES64ESM using decoder 31
6514 // 11077: }
6515 29, 14, // 11081: case 0x1d: {
6516 OPC_CheckPredicate, 39, // 11083: check predicate 39
6517 OPC_CheckField, 30, 2, 0, // 11085: check Inst[31:30] == 0x0
6518 OPC_CheckField, 12, 3, 0, // 11089: check Inst[14:12] == 0x0
6519 OPC_Decode, 169, 107, 31, // 11093: decode to AES64DS using decoder 31
6520 // 11093: }
6521 31, 0, // 11097: case 0x1f: {
6522 OPC_SwitchField, 30, 2, // 11099: switch Inst[31:30] {
6523 0, 10, // 11102: case 0x0: {
6524 OPC_CheckPredicate, 39, // 11104: check predicate 39
6525 OPC_CheckField, 12, 3, 0, // 11106: check Inst[14:12] == 0x0
6526 OPC_Decode, 170, 107, 31, // 11110: decode to AES64DSM using decoder 31
6527 // 11110: }
6528 1, 0, // 11114: case 0x1: {
6529 OPC_CheckPredicate, 40, // 11116: check predicate 40
6530 OPC_CheckField, 12, 3, 0, // 11118: check Inst[14:12] == 0x0
6531 OPC_Decode, 175, 107, 31, // 11122: decode to AES64KS2 using decoder 31
6532 // 11122: }
6533 // 11122: } // switch Inst[31:30]
6534 // 11122: }
6535 // 11122: } // switch Inst[29:25]
6536 // 11122: }
6537 55, 4, // 11126: case 0x37: {
6538 OPC_Decode, 196, 116, 20, // 11128: decode to LUI using decoder 20
6539 // 11128: }
6540 59, 155, 19, // 11132: case 0x3b: {
6541 OPC_SwitchField, 25, 7, // 11135: switch Inst[31:25] {
6542 0, 27, // 11138: case 0x0: {
6543 OPC_SwitchField, 12, 3, // 11140: switch Inst[14:12] {
6544 0, 6, // 11143: case 0x0: {
6545 OPC_CheckPredicate, 21, // 11145: check predicate 21
6546 OPC_Decode, 163, 107, 31, // 11147: decode to ADDW using decoder 31
6547 // 11147: }
6548 1, 6, // 11151: case 0x1: {
6549 OPC_CheckPredicate, 21, // 11153: check predicate 21
6550 OPC_Decode, 146, 124, 31, // 11155: decode to SLLW using decoder 31
6551 // 11155: }
6552 5, 0, // 11159: case 0x5: {
6553 OPC_CheckPredicate, 21, // 11161: check predicate 21
6554 OPC_Decode, 183, 124, 31, // 11163: decode to SRLW using decoder 31
6555 // 11163: }
6556 // 11163: } // switch Inst[14:12]
6557 // 11163: }
6558 1, 43, // 11167: case 0x1: {
6559 OPC_SwitchField, 12, 3, // 11169: switch Inst[14:12] {
6560 0, 6, // 11172: case 0x0: {
6561 OPC_CheckPredicate, 76, // 11174: check predicate 76
6562 OPC_Decode, 196, 117, 31, // 11176: decode to MULW using decoder 31
6563 // 11176: }
6564 4, 6, // 11180: case 0x4: {
6565 OPC_CheckPredicate, 77, // 11182: check predicate 77
6566 OPC_Decode, 232, 113, 31, // 11184: decode to DIVW using decoder 31
6567 // 11184: }
6568 5, 6, // 11188: case 0x5: {
6569 OPC_CheckPredicate, 77, // 11190: check predicate 77
6570 OPC_Decode, 231, 113, 31, // 11192: decode to DIVUW using decoder 31
6571 // 11192: }
6572 6, 6, // 11196: case 0x6: {
6573 OPC_CheckPredicate, 77, // 11198: check predicate 77
6574 OPC_Decode, 136, 123, 31, // 11200: decode to REMW using decoder 31
6575 // 11200: }
6576 7, 0, // 11204: case 0x7: {
6577 OPC_CheckPredicate, 77, // 11206: check predicate 77
6578 OPC_Decode, 135, 123, 31, // 11208: decode to REMUW using decoder 31
6579 // 11208: }
6580 // 11208: } // switch Inst[14:12]
6581 // 11208: }
6582 4, 32, // 11212: case 0x4: {
6583 OPC_SwitchField, 12, 3, // 11214: switch Inst[14:12] {
6584 0, 6, // 11217: case 0x0: {
6585 OPC_CheckPredicate, 49, // 11219: check predicate 49
6586 OPC_Decode, 164, 107, 31, // 11221: decode to ADD_UW using decoder 31
6587 // 11221: }
6588 4, 0, // 11225: case 0x4: {
6589 OPC_Scope, 11, // 11227: try {
6590 OPC_CheckField, 20, 5, 0, // 11229: check Inst[24:20] == 0x0
6591 OPC_CheckPredicate, 48, // 11233: check predicate 48
6592 OPC_Decode, 205, 131, 1, 17, // 11235: decode to ZEXT_H_RV64 using decoder 17
6593 // 11235: } else try {
6594 OPC_CheckPredicate, 78, // 11240: check predicate 78
6595 OPC_Decode, 169, 118, 31, // 11242: decode to PACKW using decoder 31
6596 // 11242: }
6597 // 11242: }
6598 // 11242: } // switch Inst[14:12]
6599 // 11242: }
6600 16, 27, // 11246: case 0x10: {
6601 OPC_SwitchField, 12, 3, // 11248: switch Inst[14:12] {
6602 2, 6, // 11251: case 0x2: {
6603 OPC_CheckPredicate, 49, // 11253: check predicate 49
6604 OPC_Decode, 243, 123, 31, // 11255: decode to SH1ADD_UW using decoder 31
6605 // 11255: }
6606 4, 6, // 11259: case 0x4: {
6607 OPC_CheckPredicate, 49, // 11261: check predicate 49
6608 OPC_Decode, 245, 123, 31, // 11263: decode to SH2ADD_UW using decoder 31
6609 // 11263: }
6610 6, 0, // 11267: case 0x6: {
6611 OPC_CheckPredicate, 49, // 11269: check predicate 49
6612 OPC_Decode, 247, 123, 31, // 11271: decode to SH3ADD_UW using decoder 31
6613 // 11271: }
6614 // 11271: } // switch Inst[14:12]
6615 // 11271: }
6616 32, 19, // 11275: case 0x20: {
6617 OPC_SwitchField, 12, 3, // 11277: switch Inst[14:12] {
6618 0, 6, // 11280: case 0x0: {
6619 OPC_CheckPredicate, 21, // 11282: check predicate 21
6620 OPC_Decode, 206, 124, 31, // 11284: decode to SUBW using decoder 31
6621 // 11284: }
6622 5, 0, // 11288: case 0x5: {
6623 OPC_CheckPredicate, 21, // 11290: check predicate 21
6624 OPC_Decode, 177, 124, 31, // 11292: decode to SRAW using decoder 31
6625 // 11292: }
6626 // 11292: } // switch Inst[14:12]
6627 // 11292: }
6628 48, 19, // 11296: case 0x30: {
6629 OPC_SwitchField, 12, 3, // 11298: switch Inst[14:12] {
6630 1, 6, // 11301: case 0x1: {
6631 OPC_CheckPredicate, 48, // 11303: check predicate 48
6632 OPC_Decode, 143, 123, 31, // 11305: decode to ROLW using decoder 31
6633 // 11305: }
6634 5, 0, // 11309: case 0x5: {
6635 OPC_CheckPredicate, 48, // 11311: check predicate 48
6636 OPC_Decode, 147, 123, 31, // 11313: decode to RORW using decoder 31
6637 // 11313: }
6638 // 11313: } // switch Inst[14:12]
6639 // 11313: }
6640 64, 59, // 11317: case 0x40: {
6641 OPC_SwitchField, 12, 3, // 11319: switch Inst[14:12] {
6642 0, 6, // 11322: case 0x0: {
6643 OPC_CheckPredicate, 42, // 11324: check predicate 42
6644 OPC_Decode, 179, 118, 31, // 11326: decode to PADD_H using decoder 31
6645 // 11326: }
6646 2, 6, // 11330: case 0x2: {
6647 OPC_CheckPredicate, 47, // 11332: check predicate 47
6648 OPC_Decode, 144, 120, 31, // 11334: decode to PNCLIPUP_B using decoder 31
6649 // 11334: }
6650 3, 6, // 11338: case 0x3: {
6651 OPC_CheckPredicate, 42, // 11340: check predicate 42
6652 OPC_Decode, 251, 119, 31, // 11342: decode to PMUL_H_B00 using decoder 31
6653 // 11342: }
6654 4, 6, // 11346: case 0x4: {
6655 OPC_CheckPredicate, 42, // 11348: check predicate 42
6656 OPC_Decode, 168, 120, 31, // 11350: decode to PPAIRE_B using decoder 31
6657 // 11350: }
6658 5, 6, // 11354: case 0x5: {
6659 OPC_CheckPredicate, 42, // 11356: check predicate 42
6660 OPC_Decode, 221, 118, 31, // 11358: decode to PM2ADD_H using decoder 31
6661 // 11358: }
6662 6, 6, // 11362: case 0x6: {
6663 OPC_CheckPredicate, 42, // 11364: check predicate 42
6664 OPC_Decode, 199, 118, 31, // 11366: decode to PAS_HX using decoder 31
6665 // 11366: }
6666 7, 0, // 11370: case 0x7: {
6667 OPC_CheckPredicate, 42, // 11372: check predicate 42
6668 OPC_Decode, 231, 119, 31, // 11374: decode to PMULH_H using decoder 31
6669 // 11374: }
6670 // 11374: } // switch Inst[14:12]
6671 // 11374: }
6672 65, 59, // 11378: case 0x41: {
6673 OPC_SwitchField, 12, 3, // 11380: switch Inst[14:12] {
6674 0, 6, // 11383: case 0x0: {
6675 OPC_CheckPredicate, 47, // 11385: check predicate 47
6676 OPC_Decode, 181, 118, 31, // 11387: decode to PADD_W using decoder 31
6677 // 11387: }
6678 2, 6, // 11391: case 0x2: {
6679 OPC_CheckPredicate, 47, // 11393: check predicate 47
6680 OPC_Decode, 145, 120, 31, // 11395: decode to PNCLIPUP_H using decoder 31
6681 // 11395: }
6682 3, 6, // 11399: case 0x3: {
6683 OPC_CheckPredicate, 47, // 11401: check predicate 47
6684 OPC_Decode, 254, 119, 31, // 11403: decode to PMUL_W_H00 using decoder 31
6685 // 11403: }
6686 4, 6, // 11407: case 0x4: {
6687 OPC_CheckPredicate, 47, // 11409: check predicate 47
6688 OPC_Decode, 171, 120, 31, // 11411: decode to PPAIRE_H using decoder 31
6689 // 11411: }
6690 5, 6, // 11415: case 0x5: {
6691 OPC_CheckPredicate, 47, // 11417: check predicate 47
6692 OPC_Decode, 223, 118, 31, // 11419: decode to PM2ADD_W using decoder 31
6693 // 11419: }
6694 6, 6, // 11423: case 0x6: {
6695 OPC_CheckPredicate, 47, // 11425: check predicate 47
6696 OPC_Decode, 200, 118, 31, // 11427: decode to PAS_WX using decoder 31
6697 // 11427: }
6698 7, 0, // 11431: case 0x7: {
6699 OPC_CheckPredicate, 47, // 11433: check predicate 47
6700 OPC_Decode, 234, 119, 31, // 11435: decode to PMULH_W using decoder 31
6701 // 11435: }
6702 // 11435: } // switch Inst[14:12]
6703 // 11435: }
6704 66, 35, // 11439: case 0x42: {
6705 OPC_SwitchField, 12, 3, // 11441: switch Inst[14:12] {
6706 0, 6, // 11444: case 0x0: {
6707 OPC_CheckPredicate, 42, // 11446: check predicate 42
6708 OPC_Decode, 171, 118, 31, // 11448: decode to PADD_B using decoder 31
6709 // 11448: }
6710 5, 6, // 11452: case 0x5: {
6711 OPC_CheckPredicate, 42, // 11454: check predicate 42
6712 OPC_Decode, 129, 119, 31, // 11456: decode to PM4ADD_B using decoder 31
6713 // 11456: }
6714 6, 6, // 11460: case 0x6: {
6715 OPC_CheckPredicate, 42, // 11462: check predicate 42
6716 OPC_Decode, 219, 120, 31, // 11464: decode to PSA_HX using decoder 31
6717 // 11464: }
6718 7, 0, // 11468: case 0x7: {
6719 OPC_CheckPredicate, 42, // 11470: check predicate 42
6720 OPC_Decode, 221, 119, 31, // 11472: decode to PMULHR_H using decoder 31
6721 // 11472: }
6722 // 11472: } // switch Inst[14:12]
6723 // 11472: }
6724 67, 43, // 11476: case 0x43: {
6725 OPC_SwitchField, 12, 3, // 11478: switch Inst[14:12] {
6726 2, 6, // 11481: case 0x2: {
6727 OPC_CheckPredicate, 47, // 11483: check predicate 47
6728 OPC_Decode, 146, 120, 31, // 11485: decode to PNCLIPUP_W using decoder 31
6729 // 11485: }
6730 3, 6, // 11489: case 0x3: {
6731 OPC_CheckPredicate, 47, // 11491: check predicate 47
6732 OPC_Decode, 200, 117, 31, // 11493: decode to MUL_W00 using decoder 31
6733 // 11493: }
6734 5, 6, // 11497: case 0x5: {
6735 OPC_CheckPredicate, 47, // 11499: check predicate 47
6736 OPC_Decode, 130, 119, 31, // 11501: decode to PM4ADD_H using decoder 31
6737 // 11501: }
6738 6, 6, // 11505: case 0x6: {
6739 OPC_CheckPredicate, 47, // 11507: check predicate 47
6740 OPC_Decode, 220, 120, 31, // 11509: decode to PSA_WX using decoder 31
6741 // 11509: }
6742 7, 0, // 11513: case 0x7: {
6743 OPC_CheckPredicate, 47, // 11515: check predicate 47
6744 OPC_Decode, 222, 119, 31, // 11517: decode to PMULHR_W using decoder 31
6745 // 11517: }
6746 // 11517: } // switch Inst[14:12]
6747 // 11517: }
6748 68, 19, // 11521: case 0x44: {
6749 OPC_SwitchField, 12, 3, // 11523: switch Inst[14:12] {
6750 5, 6, // 11526: case 0x5: {
6751 OPC_CheckPredicate, 42, // 11528: check predicate 42
6752 OPC_Decode, 213, 118, 59, // 11530: decode to PM2ADDA_H using decoder 59
6753 // 11530: }
6754 7, 0, // 11534: case 0x7: {
6755 OPC_CheckPredicate, 42, // 11536: check predicate 42
6756 OPC_Decode, 159, 119, 59, // 11538: decode to PMHACC_H using decoder 59
6757 // 11538: }
6758 // 11538: } // switch Inst[14:12]
6759 // 11538: }
6760 69, 27, // 11542: case 0x45: {
6761 OPC_SwitchField, 12, 3, // 11544: switch Inst[14:12] {
6762 3, 6, // 11547: case 0x3: {
6763 OPC_CheckPredicate, 47, // 11549: check predicate 47
6764 OPC_Decode, 136, 119, 59, // 11551: decode to PMACC_W_H00 using decoder 59
6765 // 11551: }
6766 5, 6, // 11555: case 0x5: {
6767 OPC_CheckPredicate, 47, // 11557: check predicate 47
6768 OPC_Decode, 215, 118, 59, // 11559: decode to PM2ADDA_W using decoder 59
6769 // 11559: }
6770 7, 0, // 11563: case 0x7: {
6771 OPC_CheckPredicate, 47, // 11565: check predicate 47
6772 OPC_Decode, 162, 119, 59, // 11567: decode to PMHACC_W using decoder 59
6773 // 11567: }
6774 // 11567: } // switch Inst[14:12]
6775 // 11567: }
6776 70, 19, // 11571: case 0x46: {
6777 OPC_SwitchField, 12, 3, // 11573: switch Inst[14:12] {
6778 5, 6, // 11576: case 0x5: {
6779 OPC_CheckPredicate, 42, // 11578: check predicate 42
6780 OPC_Decode, 251, 118, 59, // 11580: decode to PM4ADDA_B using decoder 59
6781 // 11580: }
6782 7, 0, // 11584: case 0x7: {
6783 OPC_CheckPredicate, 42, // 11586: check predicate 42
6784 OPC_Decode, 169, 119, 59, // 11588: decode to PMHRACC_H using decoder 59
6785 // 11588: }
6786 // 11588: } // switch Inst[14:12]
6787 // 11588: }
6788 71, 35, // 11592: case 0x47: {
6789 OPC_SwitchField, 12, 3, // 11594: switch Inst[14:12] {
6790 1, 6, // 11597: case 0x1: {
6791 OPC_CheckPredicate, 42, // 11599: check predicate 42
6792 OPC_Decode, 151, 124, 59, // 11601: decode to SLX using decoder 59
6793 // 11601: }
6794 3, 6, // 11605: case 0x3: {
6795 OPC_CheckPredicate, 47, // 11607: check predicate 47
6796 OPC_Decode, 215, 116, 59, // 11609: decode to MACC_W00 using decoder 59
6797 // 11609: }
6798 5, 6, // 11613: case 0x5: {
6799 OPC_CheckPredicate, 47, // 11615: check predicate 47
6800 OPC_Decode, 252, 118, 59, // 11617: decode to PM4ADDA_H using decoder 59
6801 // 11617: }
6802 7, 0, // 11621: case 0x7: {
6803 OPC_CheckPredicate, 47, // 11623: check predicate 47
6804 OPC_Decode, 170, 119, 59, // 11625: decode to PMHRACC_W using decoder 59
6805 // 11625: }
6806 // 11625: } // switch Inst[14:12]
6807 // 11625: }
6808 72, 59, // 11629: case 0x48: {
6809 OPC_SwitchField, 12, 3, // 11631: switch Inst[14:12] {
6810 0, 6, // 11634: case 0x0: {
6811 OPC_CheckPredicate, 42, // 11636: check predicate 42
6812 OPC_Decode, 209, 120, 31, // 11638: decode to PSADD_H using decoder 31
6813 // 11638: }
6814 1, 6, // 11642: case 0x1: {
6815 OPC_CheckPredicate, 42, // 11644: check predicate 42
6816 OPC_Decode, 252, 119, 31, // 11646: decode to PMUL_H_B01 using decoder 31
6817 // 11646: }
6818 3, 6, // 11650: case 0x3: {
6819 OPC_CheckPredicate, 42, // 11652: check predicate 42
6820 OPC_Decode, 253, 119, 31, // 11654: decode to PMUL_H_B11 using decoder 31
6821 // 11654: }
6822 4, 6, // 11658: case 0x4: {
6823 OPC_CheckPredicate, 42, // 11660: check predicate 42
6824 OPC_Decode, 163, 120, 31, // 11662: decode to PPAIREO_B using decoder 31
6825 // 11662: }
6826 5, 6, // 11666: case 0x5: {
6827 OPC_CheckPredicate, 42, // 11668: check predicate 42
6828 OPC_Decode, 222, 118, 31, // 11670: decode to PM2ADD_HX using decoder 31
6829 // 11670: }
6830 6, 6, // 11674: case 0x6: {
6831 OPC_CheckPredicate, 42, // 11676: check predicate 42
6832 OPC_Decode, 212, 120, 31, // 11678: decode to PSAS_HX using decoder 31
6833 // 11678: }
6834 7, 0, // 11682: case 0x7: {
6835 OPC_CheckPredicate, 42, // 11684: check predicate 42
6836 OPC_Decode, 229, 119, 31, // 11686: decode to PMULHU_H using decoder 31
6837 // 11686: }
6838 // 11686: } // switch Inst[14:12]
6839 // 11686: }
6840 73, 59, // 11690: case 0x49: {
6841 OPC_SwitchField, 12, 3, // 11692: switch Inst[14:12] {
6842 0, 6, // 11695: case 0x0: {
6843 OPC_CheckPredicate, 47, // 11697: check predicate 47
6844 OPC_Decode, 210, 120, 31, // 11699: decode to PSADD_W using decoder 31
6845 // 11699: }
6846 1, 6, // 11703: case 0x1: {
6847 OPC_CheckPredicate, 47, // 11705: check predicate 47
6848 OPC_Decode, 255, 119, 31, // 11707: decode to PMUL_W_H01 using decoder 31
6849 // 11707: }
6850 3, 6, // 11711: case 0x3: {
6851 OPC_CheckPredicate, 47, // 11713: check predicate 47
6852 OPC_Decode, 128, 120, 31, // 11715: decode to PMUL_W_H11 using decoder 31
6853 // 11715: }
6854 4, 6, // 11719: case 0x4: {
6855 OPC_CheckPredicate, 42, // 11721: check predicate 42
6856 OPC_Decode, 166, 120, 31, // 11723: decode to PPAIREO_H using decoder 31
6857 // 11723: }
6858 5, 6, // 11727: case 0x5: {
6859 OPC_CheckPredicate, 47, // 11729: check predicate 47
6860 OPC_Decode, 224, 118, 31, // 11731: decode to PM2ADD_WX using decoder 31
6861 // 11731: }
6862 6, 6, // 11735: case 0x6: {
6863 OPC_CheckPredicate, 47, // 11737: check predicate 47
6864 OPC_Decode, 213, 120, 31, // 11739: decode to PSAS_WX using decoder 31
6865 // 11739: }
6866 7, 0, // 11743: case 0x7: {
6867 OPC_CheckPredicate, 47, // 11745: check predicate 47
6868 OPC_Decode, 230, 119, 31, // 11747: decode to PMULHU_W using decoder 31
6869 // 11747: }
6870 // 11747: } // switch Inst[14:12]
6871 // 11747: }
6872 74, 27, // 11751: case 0x4a: {
6873 OPC_SwitchField, 12, 3, // 11753: switch Inst[14:12] {
6874 0, 6, // 11756: case 0x0: {
6875 OPC_CheckPredicate, 42, // 11758: check predicate 42
6876 OPC_Decode, 205, 120, 31, // 11760: decode to PSADD_B using decoder 31
6877 // 11760: }
6878 6, 6, // 11764: case 0x6: {
6879 OPC_CheckPredicate, 42, // 11766: check predicate 42
6880 OPC_Decode, 144, 121, 31, // 11768: decode to PSSA_HX using decoder 31
6881 // 11768: }
6882 7, 0, // 11772: case 0x7: {
6883 OPC_CheckPredicate, 42, // 11774: check predicate 42
6884 OPC_Decode, 219, 119, 31, // 11776: decode to PMULHRU_H using decoder 31
6885 // 11776: }
6886 // 11776: } // switch Inst[14:12]
6887 // 11776: }
6888 75, 43, // 11780: case 0x4b: {
6889 OPC_SwitchField, 12, 3, // 11782: switch Inst[14:12] {
6890 1, 6, // 11785: case 0x1: {
6891 OPC_CheckPredicate, 47, // 11787: check predicate 47
6892 OPC_Decode, 201, 117, 31, // 11789: decode to MUL_W01 using decoder 31
6893 // 11789: }
6894 3, 6, // 11793: case 0x3: {
6895 OPC_CheckPredicate, 47, // 11795: check predicate 47
6896 OPC_Decode, 202, 117, 31, // 11797: decode to MUL_W11 using decoder 31
6897 // 11797: }
6898 4, 6, // 11801: case 0x4: {
6899 OPC_CheckPredicate, 47, // 11803: check predicate 47
6900 OPC_Decode, 167, 120, 31, // 11805: decode to PPAIREO_W using decoder 31
6901 // 11805: }
6902 6, 6, // 11809: case 0x6: {
6903 OPC_CheckPredicate, 47, // 11811: check predicate 47
6904 OPC_Decode, 145, 121, 31, // 11813: decode to PSSA_WX using decoder 31
6905 // 11813: }
6906 7, 0, // 11817: case 0x7: {
6907 OPC_CheckPredicate, 47, // 11819: check predicate 47
6908 OPC_Decode, 220, 119, 31, // 11821: decode to PMULHRU_W using decoder 31
6909 // 11821: }
6910 // 11821: } // switch Inst[14:12]
6911 // 11821: }
6912 76, 35, // 11825: case 0x4c: {
6913 OPC_SwitchField, 12, 3, // 11827: switch Inst[14:12] {
6914 0, 6, // 11830: case 0x0: {
6915 OPC_CheckPredicate, 42, // 11832: check predicate 42
6916 OPC_Decode, 152, 118, 31, // 11834: decode to PAADD_H using decoder 31
6917 // 11834: }
6918 5, 6, // 11838: case 0x5: {
6919 OPC_CheckPredicate, 42, // 11840: check predicate 42
6920 OPC_Decode, 214, 118, 59, // 11842: decode to PM2ADDA_HX using decoder 59
6921 // 11842: }
6922 6, 6, // 11846: case 0x6: {
6923 OPC_CheckPredicate, 42, // 11848: check predicate 42
6924 OPC_Decode, 155, 118, 31, // 11850: decode to PAAS_HX using decoder 31
6925 // 11850: }
6926 7, 0, // 11854: case 0x7: {
6927 OPC_CheckPredicate, 42, // 11856: check predicate 42
6928 OPC_Decode, 157, 119, 59, // 11858: decode to PMHACCU_H using decoder 59
6929 // 11858: }
6930 // 11858: } // switch Inst[14:12]
6931 // 11858: }
6932 77, 51, // 11862: case 0x4d: {
6933 OPC_SwitchField, 12, 3, // 11864: switch Inst[14:12] {
6934 0, 6, // 11867: case 0x0: {
6935 OPC_CheckPredicate, 47, // 11869: check predicate 47
6936 OPC_Decode, 153, 118, 31, // 11871: decode to PAADD_W using decoder 31
6937 // 11871: }
6938 1, 6, // 11875: case 0x1: {
6939 OPC_CheckPredicate, 47, // 11877: check predicate 47
6940 OPC_Decode, 137, 119, 59, // 11879: decode to PMACC_W_H01 using decoder 59
6941 // 11879: }
6942 3, 6, // 11883: case 0x3: {
6943 OPC_CheckPredicate, 47, // 11885: check predicate 47
6944 OPC_Decode, 138, 119, 59, // 11887: decode to PMACC_W_H11 using decoder 59
6945 // 11887: }
6946 5, 6, // 11891: case 0x5: {
6947 OPC_CheckPredicate, 47, // 11893: check predicate 47
6948 OPC_Decode, 216, 118, 59, // 11895: decode to PM2ADDA_WX using decoder 59
6949 // 11895: }
6950 6, 6, // 11899: case 0x6: {
6951 OPC_CheckPredicate, 47, // 11901: check predicate 47
6952 OPC_Decode, 156, 118, 31, // 11903: decode to PAAS_WX using decoder 31
6953 // 11903: }
6954 7, 0, // 11907: case 0x7: {
6955 OPC_CheckPredicate, 47, // 11909: check predicate 47
6956 OPC_Decode, 158, 119, 59, // 11911: decode to PMHACCU_W using decoder 59
6957 // 11911: }
6958 // 11911: } // switch Inst[14:12]
6959 // 11911: }
6960 78, 27, // 11915: case 0x4e: {
6961 OPC_SwitchField, 12, 3, // 11917: switch Inst[14:12] {
6962 0, 6, // 11920: case 0x0: {
6963 OPC_CheckPredicate, 42, // 11922: check predicate 42
6964 OPC_Decode, 148, 118, 31, // 11924: decode to PAADD_B using decoder 31
6965 // 11924: }
6966 6, 6, // 11928: case 0x6: {
6967 OPC_CheckPredicate, 42, // 11930: check predicate 42
6968 OPC_Decode, 184, 118, 31, // 11932: decode to PASA_HX using decoder 31
6969 // 11932: }
6970 7, 0, // 11936: case 0x7: {
6971 OPC_CheckPredicate, 42, // 11938: check predicate 42
6972 OPC_Decode, 167, 119, 59, // 11940: decode to PMHRACCU_H using decoder 59
6973 // 11940: }
6974 // 11940: } // switch Inst[14:12]
6975 // 11940: }
6976 79, 35, // 11944: case 0x4f: {
6977 OPC_SwitchField, 12, 3, // 11946: switch Inst[14:12] {
6978 1, 6, // 11949: case 0x1: {
6979 OPC_CheckPredicate, 47, // 11951: check predicate 47
6980 OPC_Decode, 216, 116, 59, // 11953: decode to MACC_W01 using decoder 59
6981 // 11953: }
6982 3, 6, // 11957: case 0x3: {
6983 OPC_CheckPredicate, 47, // 11959: check predicate 47
6984 OPC_Decode, 217, 116, 59, // 11961: decode to MACC_W11 using decoder 59
6985 // 11961: }
6986 6, 6, // 11965: case 0x6: {
6987 OPC_CheckPredicate, 47, // 11967: check predicate 47
6988 OPC_Decode, 185, 118, 31, // 11969: decode to PASA_WX using decoder 31
6989 // 11969: }
6990 7, 0, // 11973: case 0x7: {
6991 OPC_CheckPredicate, 47, // 11975: check predicate 47
6992 OPC_Decode, 168, 119, 59, // 11977: decode to PMHRACCU_W using decoder 59
6993 // 11977: }
6994 // 11977: } // switch Inst[14:12]
6995 // 11977: }
6996 80, 43, // 11981: case 0x50: {
6997 OPC_SwitchField, 12, 3, // 11983: switch Inst[14:12] {
6998 2, 6, // 11986: case 0x2: {
6999 OPC_CheckPredicate, 42, // 11988: check predicate 42
7000 OPC_Decode, 229, 120, 31, // 11990: decode to PSH1ADD_H using decoder 31
7001 // 11990: }
7002 3, 6, // 11994: case 0x3: {
7003 OPC_CheckPredicate, 42, // 11996: check predicate 42
7004 OPC_Decode, 245, 119, 31, // 11998: decode to PMULU_H_B00 using decoder 31
7005 // 11998: }
7006 4, 6, // 12002: case 0x4: {
7007 OPC_CheckPredicate, 42, // 12004: check predicate 42
7008 OPC_Decode, 172, 120, 31, // 12006: decode to PPAIROE_B using decoder 31
7009 // 12006: }
7010 5, 6, // 12010: case 0x5: {
7011 OPC_CheckPredicate, 42, // 12012: check predicate 42
7012 OPC_Decode, 219, 118, 31, // 12014: decode to PM2ADDU_H using decoder 31
7013 // 12014: }
7014 7, 0, // 12018: case 0x7: {
7015 OPC_CheckPredicate, 42, // 12020: check predicate 42
7016 OPC_Decode, 232, 119, 31, // 12022: decode to PMULH_H_B0 using decoder 31
7017 // 12022: }
7018 // 12022: } // switch Inst[14:12]
7019 // 12022: }
7020 81, 43, // 12026: case 0x51: {
7021 OPC_SwitchField, 12, 3, // 12028: switch Inst[14:12] {
7022 2, 6, // 12031: case 0x2: {
7023 OPC_CheckPredicate, 47, // 12033: check predicate 47
7024 OPC_Decode, 230, 120, 31, // 12035: decode to PSH1ADD_W using decoder 31
7025 // 12035: }
7026 3, 6, // 12039: case 0x3: {
7027 OPC_CheckPredicate, 47, // 12041: check predicate 47
7028 OPC_Decode, 248, 119, 31, // 12043: decode to PMULU_W_H00 using decoder 31
7029 // 12043: }
7030 4, 6, // 12047: case 0x4: {
7031 OPC_CheckPredicate, 42, // 12049: check predicate 42
7032 OPC_Decode, 175, 120, 31, // 12051: decode to PPAIROE_H using decoder 31
7033 // 12051: }
7034 5, 6, // 12055: case 0x5: {
7035 OPC_CheckPredicate, 47, // 12057: check predicate 47
7036 OPC_Decode, 220, 118, 31, // 12059: decode to PM2ADDU_W using decoder 31
7037 // 12059: }
7038 7, 0, // 12063: case 0x7: {
7039 OPC_CheckPredicate, 47, // 12065: check predicate 47
7040 OPC_Decode, 235, 119, 31, // 12067: decode to PMULH_W_H0 using decoder 31
7041 // 12067: }
7042 // 12067: } // switch Inst[14:12]
7043 // 12067: }
7044 82, 19, // 12071: case 0x52: {
7045 OPC_SwitchField, 12, 3, // 12073: switch Inst[14:12] {
7046 5, 6, // 12076: case 0x5: {
7047 OPC_CheckPredicate, 42, // 12078: check predicate 42
7048 OPC_Decode, 255, 118, 31, // 12080: decode to PM4ADDU_B using decoder 31
7049 // 12080: }
7050 7, 0, // 12084: case 0x7: {
7051 OPC_CheckPredicate, 42, // 12086: check predicate 42
7052 OPC_Decode, 224, 119, 31, // 12088: decode to PMULHSU_H_B0 using decoder 31
7053 // 12088: }
7054 // 12088: } // switch Inst[14:12]
7055 // 12088: }
7056 83, 35, // 12092: case 0x53: {
7057 OPC_SwitchField, 12, 3, // 12094: switch Inst[14:12] {
7058 3, 6, // 12097: case 0x3: {
7059 OPC_CheckPredicate, 47, // 12099: check predicate 47
7060 OPC_Decode, 193, 117, 31, // 12101: decode to MULU_W00 using decoder 31
7061 // 12101: }
7062 4, 6, // 12105: case 0x4: {
7063 OPC_CheckPredicate, 47, // 12107: check predicate 47
7064 OPC_Decode, 176, 120, 31, // 12109: decode to PPAIROE_W using decoder 31
7065 // 12109: }
7066 5, 6, // 12113: case 0x5: {
7067 OPC_CheckPredicate, 47, // 12115: check predicate 47
7068 OPC_Decode, 128, 119, 31, // 12117: decode to PM4ADDU_H using decoder 31
7069 // 12117: }
7070 7, 0, // 12121: case 0x7: {
7071 OPC_CheckPredicate, 47, // 12123: check predicate 47
7072 OPC_Decode, 227, 119, 31, // 12125: decode to PMULHSU_W_H0 using decoder 31
7073 // 12125: }
7074 // 12125: } // switch Inst[14:12]
7075 // 12125: }
7076 84, 27, // 12129: case 0x54: {
7077 OPC_SwitchField, 12, 3, // 12131: switch Inst[14:12] {
7078 1, 6, // 12134: case 0x1: {
7079 OPC_CheckPredicate, 42, // 12136: check predicate 42
7080 OPC_Decode, 203, 117, 59, // 12138: decode to MVM using decoder 59
7081 // 12138: }
7082 5, 6, // 12142: case 0x5: {
7083 OPC_CheckPredicate, 42, // 12144: check predicate 42
7084 OPC_Decode, 211, 118, 59, // 12146: decode to PM2ADDAU_H using decoder 59
7085 // 12146: }
7086 7, 0, // 12150: case 0x7: {
7087 OPC_CheckPredicate, 42, // 12152: check predicate 42
7088 OPC_Decode, 160, 119, 59, // 12154: decode to PMHACC_H_B0 using decoder 59
7089 // 12154: }
7090 // 12154: } // switch Inst[14:12]
7091 // 12154: }
7092 85, 35, // 12158: case 0x55: {
7093 OPC_SwitchField, 12, 3, // 12160: switch Inst[14:12] {
7094 1, 6, // 12163: case 0x1: {
7095 OPC_CheckPredicate, 42, // 12165: check predicate 42
7096 OPC_Decode, 204, 117, 59, // 12167: decode to MVMN using decoder 59
7097 // 12167: }
7098 3, 6, // 12171: case 0x3: {
7099 OPC_CheckPredicate, 47, // 12173: check predicate 47
7100 OPC_Decode, 133, 119, 59, // 12175: decode to PMACCU_W_H00 using decoder 59
7101 // 12175: }
7102 5, 6, // 12179: case 0x5: {
7103 OPC_CheckPredicate, 47, // 12181: check predicate 47
7104 OPC_Decode, 212, 118, 59, // 12183: decode to PM2ADDAU_W using decoder 59
7105 // 12183: }
7106 7, 0, // 12187: case 0x7: {
7107 OPC_CheckPredicate, 47, // 12189: check predicate 47
7108 OPC_Decode, 163, 119, 59, // 12191: decode to PMHACC_W_H0 using decoder 59
7109 // 12191: }
7110 // 12191: } // switch Inst[14:12]
7111 // 12191: }
7112 86, 27, // 12195: case 0x56: {
7113 OPC_SwitchField, 12, 3, // 12197: switch Inst[14:12] {
7114 1, 6, // 12200: case 0x1: {
7115 OPC_CheckPredicate, 42, // 12202: check predicate 42
7116 OPC_Decode, 220, 116, 59, // 12204: decode to MERGE using decoder 59
7117 // 12204: }
7118 5, 6, // 12208: case 0x5: {
7119 OPC_CheckPredicate, 42, // 12210: check predicate 42
7120 OPC_Decode, 249, 118, 59, // 12212: decode to PM4ADDAU_B using decoder 59
7121 // 12212: }
7122 7, 0, // 12216: case 0x7: {
7123 OPC_CheckPredicate, 42, // 12218: check predicate 42
7124 OPC_Decode, 152, 119, 59, // 12220: decode to PMHACCSU_H_B0 using decoder 59
7125 // 12220: }
7126 // 12220: } // switch Inst[14:12]
7127 // 12220: }
7128 87, 35, // 12224: case 0x57: {
7129 OPC_SwitchField, 12, 3, // 12226: switch Inst[14:12] {
7130 1, 6, // 12229: case 0x1: {
7131 OPC_CheckPredicate, 42, // 12231: check predicate 42
7132 OPC_Decode, 184, 124, 59, // 12233: decode to SRX using decoder 59
7133 // 12233: }
7134 3, 6, // 12237: case 0x3: {
7135 OPC_CheckPredicate, 47, // 12239: check predicate 47
7136 OPC_Decode, 209, 116, 59, // 12241: decode to MACCU_W00 using decoder 59
7137 // 12241: }
7138 5, 6, // 12245: case 0x5: {
7139 OPC_CheckPredicate, 47, // 12247: check predicate 47
7140 OPC_Decode, 250, 118, 59, // 12249: decode to PM4ADDAU_H using decoder 59
7141 // 12249: }
7142 7, 0, // 12253: case 0x7: {
7143 OPC_CheckPredicate, 47, // 12255: check predicate 47
7144 OPC_Decode, 155, 119, 59, // 12257: decode to PMHACCSU_W_H0 using decoder 59
7145 // 12257: }
7146 // 12257: } // switch Inst[14:12]
7147 // 12257: }
7148 88, 59, // 12261: case 0x58: {
7149 OPC_SwitchField, 12, 3, // 12263: switch Inst[14:12] {
7150 0, 6, // 12266: case 0x0: {
7151 OPC_CheckPredicate, 42, // 12268: check predicate 42
7152 OPC_Decode, 203, 120, 31, // 12270: decode to PSADDU_H using decoder 31
7153 // 12270: }
7154 1, 6, // 12274: case 0x1: {
7155 OPC_CheckPredicate, 42, // 12276: check predicate 42
7156 OPC_Decode, 246, 119, 31, // 12278: decode to PMULU_H_B01 using decoder 31
7157 // 12278: }
7158 2, 6, // 12282: case 0x2: {
7159 OPC_CheckPredicate, 42, // 12284: check predicate 42
7160 OPC_Decode, 148, 121, 31, // 12286: decode to PSSH1SADD_H using decoder 31
7161 // 12286: }
7162 3, 6, // 12290: case 0x3: {
7163 OPC_CheckPredicate, 42, // 12292: check predicate 42
7164 OPC_Decode, 247, 119, 31, // 12294: decode to PMULU_H_B11 using decoder 31
7165 // 12294: }
7166 4, 6, // 12298: case 0x4: {
7167 OPC_CheckPredicate, 42, // 12300: check predicate 42
7168 OPC_Decode, 177, 120, 31, // 12302: decode to PPAIRO_B using decoder 31
7169 // 12302: }
7170 5, 6, // 12306: case 0x5: {
7171 OPC_CheckPredicate, 42, // 12308: check predicate 42
7172 OPC_Decode, 185, 119, 31, // 12310: decode to PMQ2ADD_H using decoder 31
7173 // 12310: }
7174 7, 0, // 12314: case 0x7: {
7175 OPC_CheckPredicate, 42, // 12316: check predicate 42
7176 OPC_Decode, 233, 119, 31, // 12318: decode to PMULH_H_B1 using decoder 31
7177 // 12318: }
7178 // 12318: } // switch Inst[14:12]
7179 // 12318: }
7180 89, 59, // 12322: case 0x59: {
7181 OPC_SwitchField, 12, 3, // 12324: switch Inst[14:12] {
7182 0, 6, // 12327: case 0x0: {
7183 OPC_CheckPredicate, 47, // 12329: check predicate 47
7184 OPC_Decode, 204, 120, 31, // 12331: decode to PSADDU_W using decoder 31
7185 // 12331: }
7186 1, 6, // 12335: case 0x1: {
7187 OPC_CheckPredicate, 47, // 12337: check predicate 47
7188 OPC_Decode, 249, 119, 31, // 12339: decode to PMULU_W_H01 using decoder 31
7189 // 12339: }
7190 2, 6, // 12343: case 0x2: {
7191 OPC_CheckPredicate, 47, // 12345: check predicate 47
7192 OPC_Decode, 149, 121, 31, // 12347: decode to PSSH1SADD_W using decoder 31
7193 // 12347: }
7194 3, 6, // 12351: case 0x3: {
7195 OPC_CheckPredicate, 47, // 12353: check predicate 47
7196 OPC_Decode, 250, 119, 31, // 12355: decode to PMULU_W_H11 using decoder 31
7197 // 12355: }
7198 4, 6, // 12359: case 0x4: {
7199 OPC_CheckPredicate, 42, // 12361: check predicate 42
7200 OPC_Decode, 180, 120, 31, // 12363: decode to PPAIRO_H using decoder 31
7201 // 12363: }
7202 5, 6, // 12367: case 0x5: {
7203 OPC_CheckPredicate, 47, // 12369: check predicate 47
7204 OPC_Decode, 186, 119, 31, // 12371: decode to PMQ2ADD_W using decoder 31
7205 // 12371: }
7206 7, 0, // 12375: case 0x7: {
7207 OPC_CheckPredicate, 47, // 12377: check predicate 47
7208 OPC_Decode, 236, 119, 31, // 12379: decode to PMULH_W_H1 using decoder 31
7209 // 12379: }
7210 // 12379: } // switch Inst[14:12]
7211 // 12379: }
7212 90, 35, // 12383: case 0x5a: {
7213 OPC_SwitchField, 12, 3, // 12385: switch Inst[14:12] {
7214 0, 6, // 12388: case 0x0: {
7215 OPC_CheckPredicate, 42, // 12390: check predicate 42
7216 OPC_Decode, 199, 120, 31, // 12392: decode to PSADDU_B using decoder 31
7217 // 12392: }
7218 1, 6, // 12396: case 0x1: {
7219 OPC_CheckPredicate, 42, // 12398: check predicate 42
7220 OPC_Decode, 158, 118, 31, // 12400: decode to PABDSUMU_B using decoder 31
7221 // 12400: }
7222 5, 6, // 12404: case 0x5: {
7223 OPC_CheckPredicate, 42, // 12406: check predicate 42
7224 OPC_Decode, 192, 119, 31, // 12408: decode to PMQR2ADD_H using decoder 31
7225 // 12408: }
7226 7, 0, // 12412: case 0x7: {
7227 OPC_CheckPredicate, 42, // 12414: check predicate 42
7228 OPC_Decode, 225, 119, 31, // 12416: decode to PMULHSU_H_B1 using decoder 31
7229 // 12416: }
7230 // 12416: } // switch Inst[14:12]
7231 // 12416: }
7232 91, 43, // 12420: case 0x5b: {
7233 OPC_SwitchField, 12, 3, // 12422: switch Inst[14:12] {
7234 1, 6, // 12425: case 0x1: {
7235 OPC_CheckPredicate, 47, // 12427: check predicate 47
7236 OPC_Decode, 194, 117, 31, // 12429: decode to MULU_W01 using decoder 31
7237 // 12429: }
7238 3, 6, // 12433: case 0x3: {
7239 OPC_CheckPredicate, 47, // 12435: check predicate 47
7240 OPC_Decode, 195, 117, 31, // 12437: decode to MULU_W11 using decoder 31
7241 // 12437: }
7242 4, 6, // 12441: case 0x4: {
7243 OPC_CheckPredicate, 47, // 12443: check predicate 47
7244 OPC_Decode, 181, 120, 31, // 12445: decode to PPAIRO_W using decoder 31
7245 // 12445: }
7246 5, 6, // 12449: case 0x5: {
7247 OPC_CheckPredicate, 47, // 12451: check predicate 47
7248 OPC_Decode, 193, 119, 31, // 12453: decode to PMQR2ADD_W using decoder 31
7249 // 12453: }
7250 7, 0, // 12457: case 0x7: {
7251 OPC_CheckPredicate, 47, // 12459: check predicate 47
7252 OPC_Decode, 228, 119, 31, // 12461: decode to PMULHSU_W_H1 using decoder 31
7253 // 12461: }
7254 // 12461: } // switch Inst[14:12]
7255 // 12461: }
7256 92, 27, // 12465: case 0x5c: {
7257 OPC_SwitchField, 12, 3, // 12467: switch Inst[14:12] {
7258 0, 6, // 12470: case 0x0: {
7259 OPC_CheckPredicate, 42, // 12472: check predicate 42
7260 OPC_Decode, 146, 118, 31, // 12474: decode to PAADDU_H using decoder 31
7261 // 12474: }
7262 5, 6, // 12478: case 0x5: {
7263 OPC_CheckPredicate, 42, // 12480: check predicate 42
7264 OPC_Decode, 183, 119, 59, // 12482: decode to PMQ2ADDA_H using decoder 59
7265 // 12482: }
7266 7, 0, // 12486: case 0x7: {
7267 OPC_CheckPredicate, 42, // 12488: check predicate 42
7268 OPC_Decode, 161, 119, 59, // 12490: decode to PMHACC_H_B1 using decoder 59
7269 // 12490: }
7270 // 12490: } // switch Inst[14:12]
7271 // 12490: }
7272 93, 43, // 12494: case 0x5d: {
7273 OPC_SwitchField, 12, 3, // 12496: switch Inst[14:12] {
7274 0, 6, // 12499: case 0x0: {
7275 OPC_CheckPredicate, 47, // 12501: check predicate 47
7276 OPC_Decode, 147, 118, 31, // 12503: decode to PAADDU_W using decoder 31
7277 // 12503: }
7278 1, 6, // 12507: case 0x1: {
7279 OPC_CheckPredicate, 47, // 12509: check predicate 47
7280 OPC_Decode, 134, 119, 59, // 12511: decode to PMACCU_W_H01 using decoder 59
7281 // 12511: }
7282 3, 6, // 12515: case 0x3: {
7283 OPC_CheckPredicate, 47, // 12517: check predicate 47
7284 OPC_Decode, 135, 119, 59, // 12519: decode to PMACCU_W_H11 using decoder 59
7285 // 12519: }
7286 5, 6, // 12523: case 0x5: {
7287 OPC_CheckPredicate, 47, // 12525: check predicate 47
7288 OPC_Decode, 184, 119, 59, // 12527: decode to PMQ2ADDA_W using decoder 59
7289 // 12527: }
7290 7, 0, // 12531: case 0x7: {
7291 OPC_CheckPredicate, 47, // 12533: check predicate 47
7292 OPC_Decode, 164, 119, 59, // 12535: decode to PMHACC_W_H1 using decoder 59
7293 // 12535: }
7294 // 12535: } // switch Inst[14:12]
7295 // 12535: }
7296 94, 35, // 12539: case 0x5e: {
7297 OPC_SwitchField, 12, 3, // 12541: switch Inst[14:12] {
7298 0, 6, // 12544: case 0x0: {
7299 OPC_CheckPredicate, 42, // 12546: check predicate 42
7300 OPC_Decode, 142, 118, 31, // 12548: decode to PAADDU_B using decoder 31
7301 // 12548: }
7302 1, 6, // 12552: case 0x1: {
7303 OPC_CheckPredicate, 42, // 12554: check predicate 42
7304 OPC_Decode, 157, 118, 59, // 12556: decode to PABDSUMAU_B using decoder 59
7305 // 12556: }
7306 5, 6, // 12560: case 0x5: {
7307 OPC_CheckPredicate, 42, // 12562: check predicate 42
7308 OPC_Decode, 190, 119, 59, // 12564: decode to PMQR2ADDA_H using decoder 59
7309 // 12564: }
7310 7, 0, // 12568: case 0x7: {
7311 OPC_CheckPredicate, 42, // 12570: check predicate 42
7312 OPC_Decode, 153, 119, 59, // 12572: decode to PMHACCSU_H_B1 using decoder 59
7313 // 12572: }
7314 // 12572: } // switch Inst[14:12]
7315 // 12572: }
7316 95, 35, // 12576: case 0x5f: {
7317 OPC_SwitchField, 12, 3, // 12578: switch Inst[14:12] {
7318 1, 6, // 12581: case 0x1: {
7319 OPC_CheckPredicate, 47, // 12583: check predicate 47
7320 OPC_Decode, 210, 116, 59, // 12585: decode to MACCU_W01 using decoder 59
7321 // 12585: }
7322 3, 6, // 12589: case 0x3: {
7323 OPC_CheckPredicate, 47, // 12591: check predicate 47
7324 OPC_Decode, 211, 116, 59, // 12593: decode to MACCU_W11 using decoder 59
7325 // 12593: }
7326 5, 6, // 12597: case 0x5: {
7327 OPC_CheckPredicate, 47, // 12599: check predicate 47
7328 OPC_Decode, 191, 119, 59, // 12601: decode to PMQR2ADDA_W using decoder 59
7329 // 12601: }
7330 7, 0, // 12605: case 0x7: {
7331 OPC_CheckPredicate, 47, // 12607: check predicate 47
7332 OPC_Decode, 156, 119, 59, // 12609: decode to PMHACCSU_W_H1 using decoder 59
7333 // 12609: }
7334 // 12609: } // switch Inst[14:12]
7335 // 12609: }
7336 96, 43, // 12613: case 0x60: {
7337 OPC_SwitchField, 12, 3, // 12615: switch Inst[14:12] {
7338 0, 6, // 12618: case 0x0: {
7339 OPC_CheckPredicate, 42, // 12620: check predicate 42
7340 OPC_Decode, 186, 121, 31, // 12622: decode to PSUB_H using decoder 31
7341 // 12622: }
7342 2, 6, // 12626: case 0x2: {
7343 OPC_CheckPredicate, 47, // 12628: check predicate 47
7344 OPC_Decode, 133, 120, 31, // 12630: decode to PNCLIPP_B using decoder 31
7345 // 12630: }
7346 5, 6, // 12634: case 0x5: {
7347 OPC_CheckPredicate, 42, // 12636: check predicate 42
7348 OPC_Decode, 231, 118, 31, // 12638: decode to PM2SUB_H using decoder 31
7349 // 12638: }
7350 6, 6, // 12642: case 0x6: {
7351 OPC_CheckPredicate, 42, // 12644: check predicate 42
7352 OPC_Decode, 203, 119, 31, // 12646: decode to PMSEQ_H using decoder 31
7353 // 12646: }
7354 7, 0, // 12650: case 0x7: {
7355 OPC_CheckPredicate, 42, // 12652: check predicate 42
7356 OPC_Decode, 223, 119, 31, // 12654: decode to PMULHSU_H using decoder 31
7357 // 12654: }
7358 // 12654: } // switch Inst[14:12]
7359 // 12654: }
7360 97, 43, // 12658: case 0x61: {
7361 OPC_SwitchField, 12, 3, // 12660: switch Inst[14:12] {
7362 0, 6, // 12663: case 0x0: {
7363 OPC_CheckPredicate, 47, // 12665: check predicate 47
7364 OPC_Decode, 187, 121, 31, // 12667: decode to PSUB_W using decoder 31
7365 // 12667: }
7366 2, 6, // 12671: case 0x2: {
7367 OPC_CheckPredicate, 47, // 12673: check predicate 47
7368 OPC_Decode, 134, 120, 31, // 12675: decode to PNCLIPP_H using decoder 31
7369 // 12675: }
7370 5, 6, // 12679: case 0x5: {
7371 OPC_CheckPredicate, 47, // 12681: check predicate 47
7372 OPC_Decode, 233, 118, 31, // 12683: decode to PM2SUB_W using decoder 31
7373 // 12683: }
7374 6, 6, // 12687: case 0x6: {
7375 OPC_CheckPredicate, 47, // 12689: check predicate 47
7376 OPC_Decode, 204, 119, 31, // 12691: decode to PMSEQ_W using decoder 31
7377 // 12691: }
7378 7, 0, // 12695: case 0x7: {
7379 OPC_CheckPredicate, 47, // 12697: check predicate 47
7380 OPC_Decode, 226, 119, 31, // 12699: decode to PMULHSU_W using decoder 31
7381 // 12699: }
7382 // 12699: } // switch Inst[14:12]
7383 // 12699: }
7384 98, 35, // 12703: case 0x62: {
7385 OPC_SwitchField, 12, 3, // 12705: switch Inst[14:12] {
7386 0, 6, // 12708: case 0x0: {
7387 OPC_CheckPredicate, 42, // 12710: check predicate 42
7388 OPC_Decode, 182, 121, 31, // 12712: decode to PSUB_B using decoder 31
7389 // 12712: }
7390 5, 6, // 12716: case 0x5: {
7391 OPC_CheckPredicate, 42, // 12718: check predicate 42
7392 OPC_Decode, 225, 118, 31, // 12720: decode to PM2SADD_H using decoder 31
7393 // 12720: }
7394 6, 6, // 12724: case 0x6: {
7395 OPC_CheckPredicate, 42, // 12726: check predicate 42
7396 OPC_Decode, 199, 119, 31, // 12728: decode to PMSEQ_B using decoder 31
7397 // 12728: }
7398 7, 0, // 12732: case 0x7: {
7399 OPC_CheckPredicate, 42, // 12734: check predicate 42
7400 OPC_Decode, 217, 119, 31, // 12736: decode to PMULHRSU_H using decoder 31
7401 // 12736: }
7402 // 12736: } // switch Inst[14:12]
7403 // 12736: }
7404 99, 19, // 12740: case 0x63: {
7405 OPC_SwitchField, 12, 3, // 12742: switch Inst[14:12] {
7406 2, 6, // 12745: case 0x2: {
7407 OPC_CheckPredicate, 47, // 12747: check predicate 47
7408 OPC_Decode, 135, 120, 31, // 12749: decode to PNCLIPP_W using decoder 31
7409 // 12749: }
7410 7, 0, // 12753: case 0x7: {
7411 OPC_CheckPredicate, 47, // 12755: check predicate 47
7412 OPC_Decode, 218, 119, 31, // 12757: decode to PMULHRSU_W using decoder 31
7413 // 12757: }
7414 // 12757: } // switch Inst[14:12]
7415 // 12757: }
7416 100, 27, // 12761: case 0x64: {
7417 OPC_SwitchField, 12, 3, // 12763: switch Inst[14:12] {
7418 0, 6, // 12766: case 0x0: {
7419 OPC_CheckPredicate, 42, // 12768: check predicate 42
7420 OPC_Decode, 166, 118, 31, // 12770: decode to PABD_H using decoder 31
7421 // 12770: }
7422 5, 6, // 12774: case 0x5: {
7423 OPC_CheckPredicate, 42, // 12776: check predicate 42
7424 OPC_Decode, 227, 118, 59, // 12778: decode to PM2SUBA_H using decoder 59
7425 // 12778: }
7426 7, 0, // 12782: case 0x7: {
7427 OPC_CheckPredicate, 42, // 12784: check predicate 42
7428 OPC_Decode, 151, 119, 59, // 12786: decode to PMHACCSU_H using decoder 59
7429 // 12786: }
7430 // 12786: } // switch Inst[14:12]
7431 // 12786: }
7432 101, 19, // 12790: case 0x65: {
7433 OPC_SwitchField, 12, 3, // 12792: switch Inst[14:12] {
7434 5, 6, // 12795: case 0x5: {
7435 OPC_CheckPredicate, 47, // 12797: check predicate 47
7436 OPC_Decode, 229, 118, 59, // 12799: decode to PM2SUBA_W using decoder 59
7437 // 12799: }
7438 7, 0, // 12803: case 0x7: {
7439 OPC_CheckPredicate, 47, // 12805: check predicate 47
7440 OPC_Decode, 154, 119, 59, // 12807: decode to PMHACCSU_W using decoder 59
7441 // 12807: }
7442 // 12807: } // switch Inst[14:12]
7443 // 12807: }
7444 102, 19, // 12811: case 0x66: {
7445 OPC_SwitchField, 12, 3, // 12813: switch Inst[14:12] {
7446 0, 6, // 12816: case 0x0: {
7447 OPC_CheckPredicate, 42, // 12818: check predicate 42
7448 OPC_Decode, 163, 118, 31, // 12820: decode to PABD_B using decoder 31
7449 // 12820: }
7450 7, 0, // 12824: case 0x7: {
7451 OPC_CheckPredicate, 42, // 12826: check predicate 42
7452 OPC_Decode, 165, 119, 59, // 12828: decode to PMHRACCSU_H using decoder 59
7453 // 12828: }
7454 // 12828: } // switch Inst[14:12]
7455 // 12828: }
7456 103, 10, // 12832: case 0x67: {
7457 OPC_CheckPredicate, 47, // 12834: check predicate 47
7458 OPC_CheckField, 12, 3, 7, // 12836: check Inst[14:12] == 0x7
7459 OPC_Decode, 166, 119, 59, // 12840: decode to PMHRACCSU_W using decoder 59
7460 // 12840: }
7461 104, 35, // 12844: case 0x68: {
7462 OPC_SwitchField, 12, 3, // 12846: switch Inst[14:12] {
7463 0, 6, // 12849: case 0x0: {
7464 OPC_CheckPredicate, 42, // 12851: check predicate 42
7465 OPC_Decode, 180, 121, 31, // 12853: decode to PSSUB_H using decoder 31
7466 // 12853: }
7467 5, 6, // 12857: case 0x5: {
7468 OPC_CheckPredicate, 42, // 12859: check predicate 42
7469 OPC_Decode, 232, 118, 31, // 12861: decode to PM2SUB_HX using decoder 31
7470 // 12861: }
7471 6, 6, // 12865: case 0x6: {
7472 OPC_CheckPredicate, 42, // 12867: check predicate 42
7473 OPC_Decode, 215, 119, 31, // 12869: decode to PMSLT_H using decoder 31
7474 // 12869: }
7475 7, 0, // 12873: case 0x7: {
7476 OPC_CheckPredicate, 42, // 12875: check predicate 42
7477 OPC_Decode, 239, 119, 31, // 12877: decode to PMULQ_H using decoder 31
7478 // 12877: }
7479 // 12877: } // switch Inst[14:12]
7480 // 12877: }
7481 105, 35, // 12881: case 0x69: {
7482 OPC_SwitchField, 12, 3, // 12883: switch Inst[14:12] {
7483 0, 6, // 12886: case 0x0: {
7484 OPC_CheckPredicate, 47, // 12888: check predicate 47
7485 OPC_Decode, 181, 121, 31, // 12890: decode to PSSUB_W using decoder 31
7486 // 12890: }
7487 5, 6, // 12894: case 0x5: {
7488 OPC_CheckPredicate, 47, // 12896: check predicate 47
7489 OPC_Decode, 234, 118, 31, // 12898: decode to PM2SUB_WX using decoder 31
7490 // 12898: }
7491 6, 6, // 12902: case 0x6: {
7492 OPC_CheckPredicate, 47, // 12904: check predicate 47
7493 OPC_Decode, 216, 119, 31, // 12906: decode to PMSLT_W using decoder 31
7494 // 12906: }
7495 7, 0, // 12910: case 0x7: {
7496 OPC_CheckPredicate, 47, // 12912: check predicate 47
7497 OPC_Decode, 240, 119, 31, // 12914: decode to PMULQ_W using decoder 31
7498 // 12914: }
7499 // 12914: } // switch Inst[14:12]
7500 // 12914: }
7501 106, 35, // 12918: case 0x6a: {
7502 OPC_SwitchField, 12, 3, // 12920: switch Inst[14:12] {
7503 0, 6, // 12923: case 0x0: {
7504 OPC_CheckPredicate, 42, // 12925: check predicate 42
7505 OPC_Decode, 176, 121, 31, // 12927: decode to PSSUB_B using decoder 31
7506 // 12927: }
7507 5, 6, // 12931: case 0x5: {
7508 OPC_CheckPredicate, 42, // 12933: check predicate 42
7509 OPC_Decode, 226, 118, 31, // 12935: decode to PM2SADD_HX using decoder 31
7510 // 12935: }
7511 6, 6, // 12939: case 0x6: {
7512 OPC_CheckPredicate, 42, // 12941: check predicate 42
7513 OPC_Decode, 211, 119, 31, // 12943: decode to PMSLT_B using decoder 31
7514 // 12943: }
7515 7, 0, // 12947: case 0x7: {
7516 OPC_CheckPredicate, 42, // 12949: check predicate 42
7517 OPC_Decode, 237, 119, 31, // 12951: decode to PMULQR_H using decoder 31
7518 // 12951: }
7519 // 12951: } // switch Inst[14:12]
7520 // 12951: }
7521 107, 10, // 12955: case 0x6b: {
7522 OPC_CheckPredicate, 47, // 12957: check predicate 47
7523 OPC_CheckField, 12, 3, 7, // 12959: check Inst[14:12] == 0x7
7524 OPC_Decode, 238, 119, 31, // 12963: decode to PMULQR_W using decoder 31
7525 // 12963: }
7526 108, 27, // 12967: case 0x6c: {
7527 OPC_SwitchField, 12, 3, // 12969: switch Inst[14:12] {
7528 0, 6, // 12972: case 0x0: {
7529 OPC_CheckPredicate, 42, // 12974: check predicate 42
7530 OPC_Decode, 196, 118, 31, // 12976: decode to PASUB_H using decoder 31
7531 // 12976: }
7532 5, 6, // 12980: case 0x5: {
7533 OPC_CheckPredicate, 42, // 12982: check predicate 42
7534 OPC_Decode, 228, 118, 59, // 12984: decode to PM2SUBA_HX using decoder 59
7535 // 12984: }
7536 6, 0, // 12988: case 0x6: {
7537 OPC_CheckPredicate, 42, // 12990: check predicate 42
7538 OPC_Decode, 209, 119, 31, // 12992: decode to PMSLTU_H using decoder 31
7539 // 12992: }
7540 // 12992: } // switch Inst[14:12]
7541 // 12992: }
7542 109, 27, // 12996: case 0x6d: {
7543 OPC_SwitchField, 12, 3, // 12998: switch Inst[14:12] {
7544 0, 6, // 13001: case 0x0: {
7545 OPC_CheckPredicate, 47, // 13003: check predicate 47
7546 OPC_Decode, 197, 118, 31, // 13005: decode to PASUB_W using decoder 31
7547 // 13005: }
7548 5, 6, // 13009: case 0x5: {
7549 OPC_CheckPredicate, 47, // 13011: check predicate 47
7550 OPC_Decode, 230, 118, 59, // 13013: decode to PM2SUBA_WX using decoder 59
7551 // 13013: }
7552 6, 0, // 13017: case 0x6: {
7553 OPC_CheckPredicate, 47, // 13019: check predicate 47
7554 OPC_Decode, 210, 119, 31, // 13021: decode to PMSLTU_W using decoder 31
7555 // 13021: }
7556 // 13021: } // switch Inst[14:12]
7557 // 13021: }
7558 110, 19, // 13025: case 0x6e: {
7559 OPC_SwitchField, 12, 3, // 13027: switch Inst[14:12] {
7560 0, 6, // 13030: case 0x0: {
7561 OPC_CheckPredicate, 42, // 13032: check predicate 42
7562 OPC_Decode, 192, 118, 31, // 13034: decode to PASUB_B using decoder 31
7563 // 13034: }
7564 6, 0, // 13038: case 0x6: {
7565 OPC_CheckPredicate, 42, // 13040: check predicate 42
7566 OPC_Decode, 205, 119, 31, // 13042: decode to PMSLTU_B using decoder 31
7567 // 13042: }
7568 // 13042: } // switch Inst[14:12]
7569 // 13042: }
7570 112, 35, // 13046: case 0x70: {
7571 OPC_SwitchField, 12, 3, // 13048: switch Inst[14:12] {
7572 2, 6, // 13051: case 0x2: {
7573 OPC_CheckPredicate, 47, // 13053: check predicate 47
7574 OPC_Decode, 196, 125, 31, // 13055: decode to UNZIP8P using decoder 31
7575 // 13055: }
7576 3, 6, // 13059: case 0x3: {
7577 OPC_CheckPredicate, 42, // 13061: check predicate 42
7578 OPC_Decode, 241, 119, 31, // 13063: decode to PMULSU_H_B00 using decoder 31
7579 // 13063: }
7580 5, 6, // 13067: case 0x5: {
7581 OPC_CheckPredicate, 42, // 13069: check predicate 42
7582 OPC_Decode, 217, 118, 31, // 13071: decode to PM2ADDSU_H using decoder 31
7583 // 13071: }
7584 6, 0, // 13075: case 0x6: {
7585 OPC_CheckPredicate, 42, // 13077: check predicate 42
7586 OPC_Decode, 181, 119, 31, // 13079: decode to PMIN_H using decoder 31
7587 // 13079: }
7588 // 13079: } // switch Inst[14:12]
7589 // 13079: }
7590 113, 35, // 13083: case 0x71: {
7591 OPC_SwitchField, 12, 3, // 13085: switch Inst[14:12] {
7592 2, 6, // 13088: case 0x2: {
7593 OPC_CheckPredicate, 47, // 13090: check predicate 47
7594 OPC_Decode, 194, 125, 31, // 13092: decode to UNZIP16P using decoder 31
7595 // 13092: }
7596 3, 6, // 13096: case 0x3: {
7597 OPC_CheckPredicate, 47, // 13098: check predicate 47
7598 OPC_Decode, 243, 119, 31, // 13100: decode to PMULSU_W_H00 using decoder 31
7599 // 13100: }
7600 5, 6, // 13104: case 0x5: {
7601 OPC_CheckPredicate, 47, // 13106: check predicate 47
7602 OPC_Decode, 218, 118, 31, // 13108: decode to PM2ADDSU_W using decoder 31
7603 // 13108: }
7604 6, 0, // 13112: case 0x6: {
7605 OPC_CheckPredicate, 47, // 13114: check predicate 47
7606 OPC_Decode, 182, 119, 31, // 13116: decode to PMIN_W using decoder 31
7607 // 13116: }
7608 // 13116: } // switch Inst[14:12]
7609 // 13116: }
7610 114, 27, // 13120: case 0x72: {
7611 OPC_SwitchField, 12, 3, // 13122: switch Inst[14:12] {
7612 2, 6, // 13125: case 0x2: {
7613 OPC_CheckPredicate, 47, // 13127: check predicate 47
7614 OPC_Decode, 195, 125, 31, // 13129: decode to UNZIP8HP using decoder 31
7615 // 13129: }
7616 5, 6, // 13133: case 0x5: {
7617 OPC_CheckPredicate, 42, // 13135: check predicate 42
7618 OPC_Decode, 253, 118, 31, // 13137: decode to PM4ADDSU_B using decoder 31
7619 // 13137: }
7620 6, 0, // 13141: case 0x6: {
7621 OPC_CheckPredicate, 42, // 13143: check predicate 42
7622 OPC_Decode, 177, 119, 31, // 13145: decode to PMIN_B using decoder 31
7623 // 13145: }
7624 // 13145: } // switch Inst[14:12]
7625 // 13145: }
7626 115, 27, // 13149: case 0x73: {
7627 OPC_SwitchField, 12, 3, // 13151: switch Inst[14:12] {
7628 2, 6, // 13154: case 0x2: {
7629 OPC_CheckPredicate, 47, // 13156: check predicate 47
7630 OPC_Decode, 193, 125, 31, // 13158: decode to UNZIP16HP using decoder 31
7631 // 13158: }
7632 3, 6, // 13162: case 0x3: {
7633 OPC_CheckPredicate, 47, // 13164: check predicate 47
7634 OPC_Decode, 188, 117, 31, // 13166: decode to MULSU_W00 using decoder 31
7635 // 13166: }
7636 5, 0, // 13170: case 0x5: {
7637 OPC_CheckPredicate, 47, // 13172: check predicate 47
7638 OPC_Decode, 254, 118, 31, // 13174: decode to PM4ADDSU_H using decoder 31
7639 // 13174: }
7640 // 13174: } // switch Inst[14:12]
7641 // 13174: }
7642 116, 35, // 13178: case 0x74: {
7643 OPC_SwitchField, 12, 3, // 13180: switch Inst[14:12] {
7644 0, 6, // 13183: case 0x0: {
7645 OPC_CheckPredicate, 42, // 13185: check predicate 42
7646 OPC_Decode, 162, 118, 31, // 13187: decode to PABDU_H using decoder 31
7647 // 13187: }
7648 5, 6, // 13191: case 0x5: {
7649 OPC_CheckPredicate, 42, // 13193: check predicate 42
7650 OPC_Decode, 209, 118, 59, // 13195: decode to PM2ADDASU_H using decoder 59
7651 // 13195: }
7652 6, 6, // 13199: case 0x6: {
7653 OPC_CheckPredicate, 42, // 13201: check predicate 42
7654 OPC_Decode, 175, 119, 31, // 13203: decode to PMINU_H using decoder 31
7655 // 13203: }
7656 7, 0, // 13207: case 0x7: {
7657 OPC_CheckPredicate, 47, // 13209: check predicate 47
7658 OPC_Decode, 187, 119, 59, // 13211: decode to PMQACC_W_H00 using decoder 59
7659 // 13211: }
7660 // 13211: } // switch Inst[14:12]
7661 // 13211: }
7662 117, 35, // 13215: case 0x75: {
7663 OPC_SwitchField, 12, 3, // 13217: switch Inst[14:12] {
7664 3, 6, // 13220: case 0x3: {
7665 OPC_CheckPredicate, 47, // 13222: check predicate 47
7666 OPC_Decode, 131, 119, 59, // 13224: decode to PMACCSU_W_H00 using decoder 59
7667 // 13224: }
7668 5, 6, // 13228: case 0x5: {
7669 OPC_CheckPredicate, 47, // 13230: check predicate 47
7670 OPC_Decode, 210, 118, 59, // 13232: decode to PM2ADDASU_W using decoder 59
7671 // 13232: }
7672 6, 6, // 13236: case 0x6: {
7673 OPC_CheckPredicate, 47, // 13238: check predicate 47
7674 OPC_Decode, 176, 119, 31, // 13240: decode to PMINU_W using decoder 31
7675 // 13240: }
7676 7, 0, // 13244: case 0x7: {
7677 OPC_CheckPredicate, 47, // 13246: check predicate 47
7678 OPC_Decode, 158, 117, 59, // 13248: decode to MQACC_W00 using decoder 59
7679 // 13248: }
7680 // 13248: } // switch Inst[14:12]
7681 // 13248: }
7682 118, 35, // 13252: case 0x76: {
7683 OPC_SwitchField, 12, 3, // 13254: switch Inst[14:12] {
7684 0, 6, // 13257: case 0x0: {
7685 OPC_CheckPredicate, 42, // 13259: check predicate 42
7686 OPC_Decode, 159, 118, 31, // 13261: decode to PABDU_B using decoder 31
7687 // 13261: }
7688 5, 6, // 13265: case 0x5: {
7689 OPC_CheckPredicate, 42, // 13267: check predicate 42
7690 OPC_Decode, 247, 118, 59, // 13269: decode to PM4ADDASU_B using decoder 59
7691 // 13269: }
7692 6, 6, // 13273: case 0x6: {
7693 OPC_CheckPredicate, 42, // 13275: check predicate 42
7694 OPC_Decode, 171, 119, 31, // 13277: decode to PMINU_B using decoder 31
7695 // 13277: }
7696 7, 0, // 13281: case 0x7: {
7697 OPC_CheckPredicate, 47, // 13283: check predicate 47
7698 OPC_Decode, 194, 119, 59, // 13285: decode to PMQRACC_W_H00 using decoder 59
7699 // 13285: }
7700 // 13285: } // switch Inst[14:12]
7701 // 13285: }
7702 119, 27, // 13289: case 0x77: {
7703 OPC_SwitchField, 12, 3, // 13291: switch Inst[14:12] {
7704 3, 6, // 13294: case 0x3: {
7705 OPC_CheckPredicate, 47, // 13296: check predicate 47
7706 OPC_Decode, 204, 116, 59, // 13298: decode to MACCSU_W00 using decoder 59
7707 // 13298: }
7708 5, 6, // 13302: case 0x5: {
7709 OPC_CheckPredicate, 47, // 13304: check predicate 47
7710 OPC_Decode, 248, 118, 59, // 13306: decode to PM4ADDASU_H using decoder 59
7711 // 13306: }
7712 7, 0, // 13310: case 0x7: {
7713 OPC_CheckPredicate, 47, // 13312: check predicate 47
7714 OPC_Decode, 164, 117, 59, // 13314: decode to MQRACC_W00 using decoder 59
7715 // 13314: }
7716 // 13314: } // switch Inst[14:12]
7717 // 13314: }
7718 120, 36, // 13318: case 0x78: {
7719 OPC_SwitchField, 12, 3, // 13320: switch Inst[14:12] {
7720 0, 6, // 13323: case 0x0: {
7721 OPC_CheckPredicate, 42, // 13325: check predicate 42
7722 OPC_Decode, 174, 121, 31, // 13327: decode to PSSUBU_H using decoder 31
7723 // 13327: }
7724 2, 7, // 13331: case 0x2: {
7725 OPC_CheckPredicate, 47, // 13333: check predicate 47
7726 OPC_Decode, 209, 131, 1, 31, // 13335: decode to ZIP8P using decoder 31
7727 // 13335: }
7728 3, 6, // 13340: case 0x3: {
7729 OPC_CheckPredicate, 42, // 13342: check predicate 42
7730 OPC_Decode, 242, 119, 31, // 13344: decode to PMULSU_H_B11 using decoder 31
7731 // 13344: }
7732 6, 0, // 13348: case 0x6: {
7733 OPC_CheckPredicate, 42, // 13350: check predicate 42
7734 OPC_Decode, 149, 119, 31, // 13352: decode to PMAX_H using decoder 31
7735 // 13352: }
7736 // 13352: } // switch Inst[14:12]
7737 // 13352: }
7738 121, 36, // 13356: case 0x79: {
7739 OPC_SwitchField, 12, 3, // 13358: switch Inst[14:12] {
7740 0, 6, // 13361: case 0x0: {
7741 OPC_CheckPredicate, 47, // 13363: check predicate 47
7742 OPC_Decode, 175, 121, 31, // 13365: decode to PSSUBU_W using decoder 31
7743 // 13365: }
7744 2, 7, // 13369: case 0x2: {
7745 OPC_CheckPredicate, 47, // 13371: check predicate 47
7746 OPC_Decode, 207, 131, 1, 31, // 13373: decode to ZIP16P using decoder 31
7747 // 13373: }
7748 3, 6, // 13378: case 0x3: {
7749 OPC_CheckPredicate, 47, // 13380: check predicate 47
7750 OPC_Decode, 244, 119, 31, // 13382: decode to PMULSU_W_H11 using decoder 31
7751 // 13382: }
7752 6, 0, // 13386: case 0x6: {
7753 OPC_CheckPredicate, 47, // 13388: check predicate 47
7754 OPC_Decode, 150, 119, 31, // 13390: decode to PMAX_W using decoder 31
7755 // 13390: }
7756 // 13390: } // switch Inst[14:12]
7757 // 13390: }
7758 122, 28, // 13394: case 0x7a: {
7759 OPC_SwitchField, 12, 3, // 13396: switch Inst[14:12] {
7760 0, 6, // 13399: case 0x0: {
7761 OPC_CheckPredicate, 42, // 13401: check predicate 42
7762 OPC_Decode, 170, 121, 31, // 13403: decode to PSSUBU_B using decoder 31
7763 // 13403: }
7764 2, 7, // 13407: case 0x2: {
7765 OPC_CheckPredicate, 47, // 13409: check predicate 47
7766 OPC_Decode, 208, 131, 1, 31, // 13411: decode to ZIP8HP using decoder 31
7767 // 13411: }
7768 6, 0, // 13416: case 0x6: {
7769 OPC_CheckPredicate, 42, // 13418: check predicate 42
7770 OPC_Decode, 145, 119, 31, // 13420: decode to PMAX_B using decoder 31
7771 // 13420: }
7772 // 13420: } // switch Inst[14:12]
7773 // 13420: }
7774 123, 20, // 13424: case 0x7b: {
7775 OPC_SwitchField, 12, 3, // 13426: switch Inst[14:12] {
7776 2, 7, // 13429: case 0x2: {
7777 OPC_CheckPredicate, 47, // 13431: check predicate 47
7778 OPC_Decode, 206, 131, 1, 31, // 13433: decode to ZIP16HP using decoder 31
7779 // 13433: }
7780 3, 0, // 13438: case 0x3: {
7781 OPC_CheckPredicate, 47, // 13440: check predicate 47
7782 OPC_Decode, 189, 117, 31, // 13442: decode to MULSU_W11 using decoder 31
7783 // 13442: }
7784 // 13442: } // switch Inst[14:12]
7785 // 13442: }
7786 124, 35, // 13446: case 0x7c: {
7787 OPC_SwitchField, 12, 3, // 13448: switch Inst[14:12] {
7788 0, 6, // 13451: case 0x0: {
7789 OPC_CheckPredicate, 42, // 13453: check predicate 42
7790 OPC_Decode, 190, 118, 31, // 13455: decode to PASUBU_H using decoder 31
7791 // 13455: }
7792 5, 6, // 13459: case 0x5: {
7793 OPC_CheckPredicate, 47, // 13461: check predicate 47
7794 OPC_Decode, 188, 119, 59, // 13463: decode to PMQACC_W_H01 using decoder 59
7795 // 13463: }
7796 6, 6, // 13467: case 0x6: {
7797 OPC_CheckPredicate, 42, // 13469: check predicate 42
7798 OPC_Decode, 143, 119, 31, // 13471: decode to PMAXU_H using decoder 31
7799 // 13471: }
7800 7, 0, // 13475: case 0x7: {
7801 OPC_CheckPredicate, 47, // 13477: check predicate 47
7802 OPC_Decode, 189, 119, 59, // 13479: decode to PMQACC_W_H11 using decoder 59
7803 // 13479: }
7804 // 13479: } // switch Inst[14:12]
7805 // 13479: }
7806 125, 43, // 13483: case 0x7d: {
7807 OPC_SwitchField, 12, 3, // 13485: switch Inst[14:12] {
7808 0, 6, // 13488: case 0x0: {
7809 OPC_CheckPredicate, 47, // 13490: check predicate 47
7810 OPC_Decode, 191, 118, 31, // 13492: decode to PASUBU_W using decoder 31
7811 // 13492: }
7812 3, 6, // 13496: case 0x3: {
7813 OPC_CheckPredicate, 47, // 13498: check predicate 47
7814 OPC_Decode, 132, 119, 59, // 13500: decode to PMACCSU_W_H11 using decoder 59
7815 // 13500: }
7816 5, 6, // 13504: case 0x5: {
7817 OPC_CheckPredicate, 47, // 13506: check predicate 47
7818 OPC_Decode, 159, 117, 59, // 13508: decode to MQACC_W01 using decoder 59
7819 // 13508: }
7820 6, 6, // 13512: case 0x6: {
7821 OPC_CheckPredicate, 47, // 13514: check predicate 47
7822 OPC_Decode, 144, 119, 31, // 13516: decode to PMAXU_W using decoder 31
7823 // 13516: }
7824 7, 0, // 13520: case 0x7: {
7825 OPC_CheckPredicate, 47, // 13522: check predicate 47
7826 OPC_Decode, 160, 117, 59, // 13524: decode to MQACC_W11 using decoder 59
7827 // 13524: }
7828 // 13524: } // switch Inst[14:12]
7829 // 13524: }
7830 126, 35, // 13528: case 0x7e: {
7831 OPC_SwitchField, 12, 3, // 13530: switch Inst[14:12] {
7832 0, 6, // 13533: case 0x0: {
7833 OPC_CheckPredicate, 42, // 13535: check predicate 42
7834 OPC_Decode, 186, 118, 31, // 13537: decode to PASUBU_B using decoder 31
7835 // 13537: }
7836 5, 6, // 13541: case 0x5: {
7837 OPC_CheckPredicate, 47, // 13543: check predicate 47
7838 OPC_Decode, 195, 119, 59, // 13545: decode to PMQRACC_W_H01 using decoder 59
7839 // 13545: }
7840 6, 6, // 13549: case 0x6: {
7841 OPC_CheckPredicate, 42, // 13551: check predicate 42
7842 OPC_Decode, 139, 119, 31, // 13553: decode to PMAXU_B using decoder 31
7843 // 13553: }
7844 7, 0, // 13557: case 0x7: {
7845 OPC_CheckPredicate, 47, // 13559: check predicate 47
7846 OPC_Decode, 196, 119, 59, // 13561: decode to PMQRACC_W_H11 using decoder 59
7847 // 13561: }
7848 // 13561: } // switch Inst[14:12]
7849 // 13561: }
7850 127, 0, // 13565: case 0x7f: {
7851 OPC_SwitchField, 12, 3, // 13567: switch Inst[14:12] {
7852 3, 6, // 13570: case 0x3: {
7853 OPC_CheckPredicate, 47, // 13572: check predicate 47
7854 OPC_Decode, 205, 116, 59, // 13574: decode to MACCSU_W11 using decoder 59
7855 // 13574: }
7856 5, 6, // 13578: case 0x5: {
7857 OPC_CheckPredicate, 47, // 13580: check predicate 47
7858 OPC_Decode, 165, 117, 59, // 13582: decode to MQRACC_W01 using decoder 59
7859 // 13582: }
7860 7, 0, // 13586: case 0x7: {
7861 OPC_CheckPredicate, 47, // 13588: check predicate 47
7862 OPC_Decode, 166, 117, 59, // 13590: decode to MQRACC_W11 using decoder 59
7863 // 13590: }
7864 // 13590: } // switch Inst[14:12]
7865 // 13590: }
7866 // 13590: } // switch Inst[31:25]
7867 // 13590: }
7868 67, 35, // 13594: case 0x43: {
7869 OPC_SwitchField, 25, 2, // 13596: switch Inst[26:25] {
7870 0, 6, // 13599: case 0x0: {
7871 OPC_CheckPredicate, 24, // 13601: check predicate 24
7872 OPC_Decode, 136, 115, 60, // 13603: decode to FMADD_S using decoder 60
7873 // 13603: }
7874 1, 6, // 13607: case 0x1: {
7875 OPC_CheckPredicate, 25, // 13609: check predicate 25
7876 OPC_Decode, 130, 115, 61, // 13611: decode to FMADD_D using decoder 61
7877 // 13611: }
7878 2, 6, // 13615: case 0x2: {
7879 OPC_CheckPredicate, 79, // 13617: check predicate 79
7880 OPC_Decode, 133, 115, 62, // 13619: decode to FMADD_H using decoder 62
7881 // 13619: }
7882 3, 0, // 13623: case 0x3: {
7883 OPC_CheckPredicate, 26, // 13625: check predicate 26
7884 OPC_Decode, 135, 115, 63, // 13627: decode to FMADD_Q using decoder 63
7885 // 13627: }
7886 // 13627: } // switch Inst[26:25]
7887 // 13627: }
7888 71, 35, // 13631: case 0x47: {
7889 OPC_SwitchField, 25, 2, // 13633: switch Inst[26:25] {
7890 0, 6, // 13636: case 0x0: {
7891 OPC_CheckPredicate, 24, // 13638: check predicate 24
7892 OPC_Decode, 168, 115, 60, // 13640: decode to FMSUB_S using decoder 60
7893 // 13640: }
7894 1, 6, // 13644: case 0x1: {
7895 OPC_CheckPredicate, 25, // 13646: check predicate 25
7896 OPC_Decode, 162, 115, 61, // 13648: decode to FMSUB_D using decoder 61
7897 // 13648: }
7898 2, 6, // 13652: case 0x2: {
7899 OPC_CheckPredicate, 79, // 13654: check predicate 79
7900 OPC_Decode, 165, 115, 62, // 13656: decode to FMSUB_H using decoder 62
7901 // 13656: }
7902 3, 0, // 13660: case 0x3: {
7903 OPC_CheckPredicate, 26, // 13662: check predicate 26
7904 OPC_Decode, 167, 115, 63, // 13664: decode to FMSUB_Q using decoder 63
7905 // 13664: }
7906 // 13664: } // switch Inst[26:25]
7907 // 13664: }
7908 75, 35, // 13668: case 0x4b: {
7909 OPC_SwitchField, 25, 2, // 13670: switch Inst[26:25] {
7910 0, 6, // 13673: case 0x0: {
7911 OPC_CheckPredicate, 24, // 13675: check predicate 24
7912 OPC_Decode, 203, 115, 60, // 13677: decode to FNMSUB_S using decoder 60
7913 // 13677: }
7914 1, 6, // 13681: case 0x1: {
7915 OPC_CheckPredicate, 25, // 13683: check predicate 25
7916 OPC_Decode, 197, 115, 61, // 13685: decode to FNMSUB_D using decoder 61
7917 // 13685: }
7918 2, 6, // 13689: case 0x2: {
7919 OPC_CheckPredicate, 79, // 13691: check predicate 79
7920 OPC_Decode, 200, 115, 62, // 13693: decode to FNMSUB_H using decoder 62
7921 // 13693: }
7922 3, 0, // 13697: case 0x3: {
7923 OPC_CheckPredicate, 26, // 13699: check predicate 26
7924 OPC_Decode, 202, 115, 63, // 13701: decode to FNMSUB_Q using decoder 63
7925 // 13701: }
7926 // 13701: } // switch Inst[26:25]
7927 // 13701: }
7928 79, 35, // 13705: case 0x4f: {
7929 OPC_SwitchField, 25, 2, // 13707: switch Inst[26:25] {
7930 0, 6, // 13710: case 0x0: {
7931 OPC_CheckPredicate, 24, // 13712: check predicate 24
7932 OPC_Decode, 195, 115, 60, // 13714: decode to FNMADD_S using decoder 60
7933 // 13714: }
7934 1, 6, // 13718: case 0x1: {
7935 OPC_CheckPredicate, 25, // 13720: check predicate 25
7936 OPC_Decode, 189, 115, 61, // 13722: decode to FNMADD_D using decoder 61
7937 // 13722: }
7938 2, 6, // 13726: case 0x2: {
7939 OPC_CheckPredicate, 79, // 13728: check predicate 79
7940 OPC_Decode, 192, 115, 62, // 13730: decode to FNMADD_H using decoder 62
7941 // 13730: }
7942 3, 0, // 13734: case 0x3: {
7943 OPC_CheckPredicate, 26, // 13736: check predicate 26
7944 OPC_Decode, 194, 115, 63, // 13738: decode to FNMADD_Q using decoder 63
7945 // 13738: }
7946 // 13738: } // switch Inst[26:25]
7947 // 13738: }
7948 83, 211, 10, // 13742: case 0x53: {
7949 OPC_SwitchField, 25, 7, // 13745: switch Inst[31:25] {
7950 0, 6, // 13748: case 0x0: {
7951 OPC_CheckPredicate, 24, // 13750: check predicate 24
7952 OPC_Decode, 242, 113, 64, // 13752: decode to FADD_S using decoder 64
7953 // 13752: }
7954 1, 6, // 13756: case 0x1: {
7955 OPC_CheckPredicate, 25, // 13758: check predicate 25
7956 OPC_Decode, 236, 113, 65, // 13760: decode to FADD_D using decoder 65
7957 // 13760: }
7958 2, 6, // 13764: case 0x2: {
7959 OPC_CheckPredicate, 79, // 13766: check predicate 79
7960 OPC_Decode, 239, 113, 66, // 13768: decode to FADD_H using decoder 66
7961 // 13768: }
7962 3, 6, // 13772: case 0x3: {
7963 OPC_CheckPredicate, 26, // 13774: check predicate 26
7964 OPC_Decode, 241, 113, 67, // 13776: decode to FADD_Q using decoder 67
7965 // 13776: }
7966 4, 6, // 13780: case 0x4: {
7967 OPC_CheckPredicate, 24, // 13782: check predicate 24
7968 OPC_Decode, 254, 115, 64, // 13784: decode to FSUB_S using decoder 64
7969 // 13784: }
7970 5, 6, // 13788: case 0x5: {
7971 OPC_CheckPredicate, 25, // 13790: check predicate 25
7972 OPC_Decode, 248, 115, 65, // 13792: decode to FSUB_D using decoder 65
7973 // 13792: }
7974 6, 6, // 13796: case 0x6: {
7975 OPC_CheckPredicate, 79, // 13798: check predicate 79
7976 OPC_Decode, 251, 115, 66, // 13800: decode to FSUB_H using decoder 66
7977 // 13800: }
7978 7, 6, // 13804: case 0x7: {
7979 OPC_CheckPredicate, 26, // 13806: check predicate 26
7980 OPC_Decode, 253, 115, 67, // 13808: decode to FSUB_Q using decoder 67
7981 // 13808: }
7982 8, 6, // 13812: case 0x8: {
7983 OPC_CheckPredicate, 24, // 13814: check predicate 24
7984 OPC_Decode, 176, 115, 64, // 13816: decode to FMUL_S using decoder 64
7985 // 13816: }
7986 9, 6, // 13820: case 0x9: {
7987 OPC_CheckPredicate, 25, // 13822: check predicate 25
7988 OPC_Decode, 170, 115, 65, // 13824: decode to FMUL_D using decoder 65
7989 // 13824: }
7990 10, 6, // 13828: case 0xa: {
7991 OPC_CheckPredicate, 79, // 13830: check predicate 79
7992 OPC_Decode, 173, 115, 66, // 13832: decode to FMUL_H using decoder 66
7993 // 13832: }
7994 11, 6, // 13836: case 0xb: {
7995 OPC_CheckPredicate, 26, // 13838: check predicate 26
7996 OPC_Decode, 175, 115, 67, // 13840: decode to FMUL_Q using decoder 67
7997 // 13840: }
7998 12, 6, // 13844: case 0xc: {
7999 OPC_CheckPredicate, 24, // 13846: check predicate 24
8000 OPC_Decode, 213, 114, 64, // 13848: decode to FDIV_S using decoder 64
8001 // 13848: }
8002 13, 6, // 13852: case 0xd: {
8003 OPC_CheckPredicate, 25, // 13854: check predicate 25
8004 OPC_Decode, 207, 114, 65, // 13856: decode to FDIV_D using decoder 65
8005 // 13856: }
8006 14, 6, // 13860: case 0xe: {
8007 OPC_CheckPredicate, 79, // 13862: check predicate 79
8008 OPC_Decode, 210, 114, 66, // 13864: decode to FDIV_H using decoder 66
8009 // 13864: }
8010 15, 6, // 13868: case 0xf: {
8011 OPC_CheckPredicate, 26, // 13870: check predicate 26
8012 OPC_Decode, 212, 114, 67, // 13872: decode to FDIV_Q using decoder 67
8013 // 13872: }
8014 16, 27, // 13876: case 0x10: {
8015 OPC_SwitchField, 12, 3, // 13878: switch Inst[14:12] {
8016 0, 6, // 13881: case 0x0: {
8017 OPC_CheckPredicate, 24, // 13883: check predicate 24
8018 OPC_Decode, 236, 115, 68, // 13885: decode to FSGNJ_S using decoder 68
8019 // 13885: }
8020 1, 6, // 13889: case 0x1: {
8021 OPC_CheckPredicate, 24, // 13891: check predicate 24
8022 OPC_Decode, 220, 115, 68, // 13893: decode to FSGNJN_S using decoder 68
8023 // 13893: }
8024 2, 0, // 13897: case 0x2: {
8025 OPC_CheckPredicate, 24, // 13899: check predicate 24
8026 OPC_Decode, 228, 115, 68, // 13901: decode to FSGNJX_S using decoder 68
8027 // 13901: }
8028 // 13901: } // switch Inst[14:12]
8029 // 13901: }
8030 17, 27, // 13905: case 0x11: {
8031 OPC_SwitchField, 12, 3, // 13907: switch Inst[14:12] {
8032 0, 6, // 13910: case 0x0: {
8033 OPC_CheckPredicate, 25, // 13912: check predicate 25
8034 OPC_Decode, 230, 115, 69, // 13914: decode to FSGNJ_D using decoder 69
8035 // 13914: }
8036 1, 6, // 13918: case 0x1: {
8037 OPC_CheckPredicate, 25, // 13920: check predicate 25
8038 OPC_Decode, 214, 115, 69, // 13922: decode to FSGNJN_D using decoder 69
8039 // 13922: }
8040 2, 0, // 13926: case 0x2: {
8041 OPC_CheckPredicate, 25, // 13928: check predicate 25
8042 OPC_Decode, 222, 115, 69, // 13930: decode to FSGNJX_D using decoder 69
8043 // 13930: }
8044 // 13930: } // switch Inst[14:12]
8045 // 13930: }
8046 18, 27, // 13934: case 0x12: {
8047 OPC_SwitchField, 12, 3, // 13936: switch Inst[14:12] {
8048 0, 6, // 13939: case 0x0: {
8049 OPC_CheckPredicate, 79, // 13941: check predicate 79
8050 OPC_Decode, 233, 115, 70, // 13943: decode to FSGNJ_H using decoder 70
8051 // 13943: }
8052 1, 6, // 13947: case 0x1: {
8053 OPC_CheckPredicate, 79, // 13949: check predicate 79
8054 OPC_Decode, 217, 115, 70, // 13951: decode to FSGNJN_H using decoder 70
8055 // 13951: }
8056 2, 0, // 13955: case 0x2: {
8057 OPC_CheckPredicate, 79, // 13957: check predicate 79
8058 OPC_Decode, 225, 115, 70, // 13959: decode to FSGNJX_H using decoder 70
8059 // 13959: }
8060 // 13959: } // switch Inst[14:12]
8061 // 13959: }
8062 19, 27, // 13963: case 0x13: {
8063 OPC_SwitchField, 12, 3, // 13965: switch Inst[14:12] {
8064 0, 6, // 13968: case 0x0: {
8065 OPC_CheckPredicate, 26, // 13970: check predicate 26
8066 OPC_Decode, 235, 115, 71, // 13972: decode to FSGNJ_Q using decoder 71
8067 // 13972: }
8068 1, 6, // 13976: case 0x1: {
8069 OPC_CheckPredicate, 26, // 13978: check predicate 26
8070 OPC_Decode, 219, 115, 71, // 13980: decode to FSGNJN_Q using decoder 71
8071 // 13980: }
8072 2, 0, // 13984: case 0x2: {
8073 OPC_CheckPredicate, 26, // 13986: check predicate 26
8074 OPC_Decode, 227, 115, 71, // 13988: decode to FSGNJX_Q using decoder 71
8075 // 13988: }
8076 // 13988: } // switch Inst[14:12]
8077 // 13988: }
8078 20, 35, // 13992: case 0x14: {
8079 OPC_SwitchField, 12, 3, // 13994: switch Inst[14:12] {
8080 0, 6, // 13997: case 0x0: {
8081 OPC_CheckPredicate, 24, // 13999: check predicate 24
8082 OPC_Decode, 160, 115, 68, // 14001: decode to FMIN_S using decoder 68
8083 // 14001: }
8084 1, 6, // 14005: case 0x1: {
8085 OPC_CheckPredicate, 24, // 14007: check predicate 24
8086 OPC_Decode, 148, 115, 68, // 14009: decode to FMAX_S using decoder 68
8087 // 14009: }
8088 2, 6, // 14013: case 0x2: {
8089 OPC_CheckPredicate, 80, // 14015: check predicate 80
8090 OPC_Decode, 153, 115, 68, // 14017: decode to FMINM_S using decoder 68
8091 // 14017: }
8092 3, 0, // 14021: case 0x3: {
8093 OPC_CheckPredicate, 80, // 14023: check predicate 80
8094 OPC_Decode, 141, 115, 68, // 14025: decode to FMAXM_S using decoder 68
8095 // 14025: }
8096 // 14025: } // switch Inst[14:12]
8097 // 14025: }
8098 21, 35, // 14029: case 0x15: {
8099 OPC_SwitchField, 12, 3, // 14031: switch Inst[14:12] {
8100 0, 6, // 14034: case 0x0: {
8101 OPC_CheckPredicate, 25, // 14036: check predicate 25
8102 OPC_Decode, 154, 115, 69, // 14038: decode to FMIN_D using decoder 69
8103 // 14038: }
8104 1, 6, // 14042: case 0x1: {
8105 OPC_CheckPredicate, 25, // 14044: check predicate 25
8106 OPC_Decode, 142, 115, 69, // 14046: decode to FMAX_D using decoder 69
8107 // 14046: }
8108 2, 6, // 14050: case 0x2: {
8109 OPC_CheckPredicate, 81, // 14052: check predicate 81
8110 OPC_Decode, 150, 115, 69, // 14054: decode to FMINM_D using decoder 69
8111 // 14054: }
8112 3, 0, // 14058: case 0x3: {
8113 OPC_CheckPredicate, 81, // 14060: check predicate 81
8114 OPC_Decode, 138, 115, 69, // 14062: decode to FMAXM_D using decoder 69
8115 // 14062: }
8116 // 14062: } // switch Inst[14:12]
8117 // 14062: }
8118 22, 35, // 14066: case 0x16: {
8119 OPC_SwitchField, 12, 3, // 14068: switch Inst[14:12] {
8120 0, 6, // 14071: case 0x0: {
8121 OPC_CheckPredicate, 79, // 14073: check predicate 79
8122 OPC_Decode, 157, 115, 70, // 14075: decode to FMIN_H using decoder 70
8123 // 14075: }
8124 1, 6, // 14079: case 0x1: {
8125 OPC_CheckPredicate, 79, // 14081: check predicate 79
8126 OPC_Decode, 145, 115, 70, // 14083: decode to FMAX_H using decoder 70
8127 // 14083: }
8128 2, 6, // 14087: case 0x2: {
8129 OPC_CheckPredicate, 82, // 14089: check predicate 82
8130 OPC_Decode, 151, 115, 70, // 14091: decode to FMINM_H using decoder 70
8131 // 14091: }
8132 3, 0, // 14095: case 0x3: {
8133 OPC_CheckPredicate, 82, // 14097: check predicate 82
8134 OPC_Decode, 139, 115, 70, // 14099: decode to FMAXM_H using decoder 70
8135 // 14099: }
8136 // 14099: } // switch Inst[14:12]
8137 // 14099: }
8138 23, 35, // 14103: case 0x17: {
8139 OPC_SwitchField, 12, 3, // 14105: switch Inst[14:12] {
8140 0, 6, // 14108: case 0x0: {
8141 OPC_CheckPredicate, 26, // 14110: check predicate 26
8142 OPC_Decode, 159, 115, 71, // 14112: decode to FMIN_Q using decoder 71
8143 // 14112: }
8144 1, 6, // 14116: case 0x1: {
8145 OPC_CheckPredicate, 26, // 14118: check predicate 26
8146 OPC_Decode, 147, 115, 71, // 14120: decode to FMAX_Q using decoder 71
8147 // 14120: }
8148 2, 6, // 14124: case 0x2: {
8149 OPC_CheckPredicate, 83, // 14126: check predicate 83
8150 OPC_Decode, 152, 115, 71, // 14128: decode to FMINM_Q using decoder 71
8151 // 14128: }
8152 3, 0, // 14132: case 0x3: {
8153 OPC_CheckPredicate, 83, // 14134: check predicate 83
8154 OPC_Decode, 140, 115, 71, // 14136: decode to FMAXM_Q using decoder 71
8155 // 14136: }
8156 // 14136: } // switch Inst[14:12]
8157 // 14136: }
8158 32, 51, // 14140: case 0x20: {
8159 OPC_SwitchField, 20, 5, // 14142: switch Inst[24:20] {
8160 1, 6, // 14145: case 0x1: {
8161 OPC_CheckPredicate, 25, // 14147: check predicate 25
8162 OPC_Decode, 177, 114, 72, // 14149: decode to FCVT_S_D using decoder 72
8163 // 14149: }
8164 2, 6, // 14153: case 0x2: {
8165 OPC_CheckPredicate, 84, // 14155: check predicate 84
8166 OPC_Decode, 180, 114, 73, // 14157: decode to FCVT_S_H using decoder 73
8167 // 14157: }
8168 3, 6, // 14161: case 0x3: {
8169 OPC_CheckPredicate, 26, // 14163: check predicate 26
8170 OPC_Decode, 186, 114, 74, // 14165: decode to FCVT_S_Q using decoder 74
8171 // 14165: }
8172 4, 6, // 14169: case 0x4: {
8173 OPC_CheckPredicate, 80, // 14171: check predicate 80
8174 OPC_Decode, 212, 115, 75, // 14173: decode to FROUND_S using decoder 75
8175 // 14173: }
8176 5, 6, // 14177: case 0x5: {
8177 OPC_CheckPredicate, 80, // 14179: check predicate 80
8178 OPC_Decode, 208, 115, 75, // 14181: decode to FROUNDNX_S using decoder 75
8179 // 14181: }
8180 6, 0, // 14185: case 0x6: {
8181 OPC_CheckPredicate, 85, // 14187: check predicate 85
8182 OPC_Decode, 176, 114, 73, // 14189: decode to FCVT_S_BF16 using decoder 73
8183 // 14189: }
8184 // 14189: } // switch Inst[24:20]
8185 // 14189: }
8186 33, 43, // 14193: case 0x21: {
8187 OPC_SwitchField, 20, 5, // 14195: switch Inst[24:20] {
8188 0, 6, // 14198: case 0x0: {
8189 OPC_CheckPredicate, 25, // 14200: check predicate 25
8190 OPC_Decode, 134, 114, 76, // 14202: decode to FCVT_D_S using decoder 76
8191 // 14202: }
8192 2, 6, // 14206: case 0x2: {
8193 OPC_CheckPredicate, 86, // 14208: check predicate 86
8194 OPC_Decode, 254, 113, 77, // 14210: decode to FCVT_D_H using decoder 77
8195 // 14210: }
8196 3, 6, // 14214: case 0x3: {
8197 OPC_CheckPredicate, 26, // 14216: check predicate 26
8198 OPC_Decode, 133, 114, 78, // 14218: decode to FCVT_D_Q using decoder 78
8199 // 14218: }
8200 4, 6, // 14222: case 0x4: {
8201 OPC_CheckPredicate, 81, // 14224: check predicate 81
8202 OPC_Decode, 209, 115, 79, // 14226: decode to FROUND_D using decoder 79
8203 // 14226: }
8204 5, 0, // 14230: case 0x5: {
8205 OPC_CheckPredicate, 81, // 14232: check predicate 81
8206 OPC_Decode, 205, 115, 79, // 14234: decode to FROUNDNX_D using decoder 79
8207 // 14234: }
8208 // 14234: } // switch Inst[24:20]
8209 // 14234: }
8210 34, 43, // 14238: case 0x22: {
8211 OPC_SwitchField, 20, 5, // 14240: switch Inst[24:20] {
8212 0, 6, // 14243: case 0x0: {
8213 OPC_CheckPredicate, 84, // 14245: check predicate 84
8214 OPC_Decode, 150, 114, 80, // 14247: decode to FCVT_H_S using decoder 80
8215 // 14247: }
8216 1, 6, // 14251: case 0x1: {
8217 OPC_CheckPredicate, 86, // 14253: check predicate 86
8218 OPC_Decode, 143, 114, 81, // 14255: decode to FCVT_H_D using decoder 81
8219 // 14255: }
8220 4, 6, // 14259: case 0x4: {
8221 OPC_CheckPredicate, 82, // 14261: check predicate 82
8222 OPC_Decode, 210, 115, 82, // 14263: decode to FROUND_H using decoder 82
8223 // 14263: }
8224 5, 6, // 14267: case 0x5: {
8225 OPC_CheckPredicate, 82, // 14269: check predicate 82
8226 OPC_Decode, 206, 115, 82, // 14271: decode to FROUNDNX_H using decoder 82
8227 // 14271: }
8228 8, 0, // 14275: case 0x8: {
8229 OPC_CheckPredicate, 85, // 14277: check predicate 85
8230 OPC_Decode, 253, 113, 80, // 14279: decode to FCVT_BF16_S using decoder 80
8231 // 14279: }
8232 // 14279: } // switch Inst[24:20]
8233 // 14279: }
8234 35, 35, // 14283: case 0x23: {
8235 OPC_SwitchField, 20, 5, // 14285: switch Inst[24:20] {
8236 0, 6, // 14288: case 0x0: {
8237 OPC_CheckPredicate, 26, // 14290: check predicate 26
8238 OPC_Decode, 173, 114, 83, // 14292: decode to FCVT_Q_S using decoder 83
8239 // 14292: }
8240 1, 6, // 14296: case 0x1: {
8241 OPC_CheckPredicate, 26, // 14298: check predicate 26
8242 OPC_Decode, 170, 114, 84, // 14300: decode to FCVT_Q_D using decoder 84
8243 // 14300: }
8244 4, 6, // 14304: case 0x4: {
8245 OPC_CheckPredicate, 83, // 14306: check predicate 83
8246 OPC_Decode, 211, 115, 85, // 14308: decode to FROUND_Q using decoder 85
8247 // 14308: }
8248 5, 0, // 14312: case 0x5: {
8249 OPC_CheckPredicate, 83, // 14314: check predicate 83
8250 OPC_Decode, 207, 115, 85, // 14316: decode to FROUNDNX_Q using decoder 85
8251 // 14316: }
8252 // 14316: } // switch Inst[24:20]
8253 // 14316: }
8254 44, 10, // 14320: case 0x2c: {
8255 OPC_CheckPredicate, 24, // 14322: check predicate 24
8256 OPC_CheckField, 20, 5, 0, // 14324: check Inst[24:20] == 0x0
8257 OPC_Decode, 246, 115, 75, // 14328: decode to FSQRT_S using decoder 75
8258 // 14328: }
8259 45, 10, // 14332: case 0x2d: {
8260 OPC_CheckPredicate, 25, // 14334: check predicate 25
8261 OPC_CheckField, 20, 5, 0, // 14336: check Inst[24:20] == 0x0
8262 OPC_Decode, 240, 115, 79, // 14340: decode to FSQRT_D using decoder 79
8263 // 14340: }
8264 46, 10, // 14344: case 0x2e: {
8265 OPC_CheckPredicate, 79, // 14346: check predicate 79
8266 OPC_CheckField, 20, 5, 0, // 14348: check Inst[24:20] == 0x0
8267 OPC_Decode, 243, 115, 82, // 14352: decode to FSQRT_H using decoder 82
8268 // 14352: }
8269 47, 10, // 14356: case 0x2f: {
8270 OPC_CheckPredicate, 26, // 14358: check predicate 26
8271 OPC_CheckField, 20, 5, 0, // 14360: check Inst[24:20] == 0x0
8272 OPC_Decode, 245, 115, 85, // 14364: decode to FSQRT_Q using decoder 85
8273 // 14364: }
8274 80, 43, // 14368: case 0x50: {
8275 OPC_SwitchField, 12, 3, // 14370: switch Inst[14:12] {
8276 0, 6, // 14373: case 0x0: {
8277 OPC_CheckPredicate, 24, // 14375: check predicate 24
8278 OPC_Decode, 237, 114, 86, // 14377: decode to FLE_S using decoder 86
8279 // 14377: }
8280 1, 6, // 14381: case 0x1: {
8281 OPC_CheckPredicate, 24, // 14383: check predicate 24
8282 OPC_Decode, 255, 114, 86, // 14385: decode to FLT_S using decoder 86
8283 // 14385: }
8284 2, 6, // 14389: case 0x2: {
8285 OPC_CheckPredicate, 24, // 14391: check predicate 24
8286 OPC_Decode, 224, 114, 86, // 14393: decode to FEQ_S using decoder 86
8287 // 14393: }
8288 4, 6, // 14397: case 0x4: {
8289 OPC_CheckPredicate, 80, // 14399: check predicate 80
8290 OPC_Decode, 230, 114, 86, // 14401: decode to FLEQ_S using decoder 86
8291 // 14401: }
8292 5, 0, // 14405: case 0x5: {
8293 OPC_CheckPredicate, 80, // 14407: check predicate 80
8294 OPC_Decode, 248, 114, 86, // 14409: decode to FLTQ_S using decoder 86
8295 // 14409: }
8296 // 14409: } // switch Inst[14:12]
8297 // 14409: }
8298 81, 43, // 14413: case 0x51: {
8299 OPC_SwitchField, 12, 3, // 14415: switch Inst[14:12] {
8300 0, 6, // 14418: case 0x0: {
8301 OPC_CheckPredicate, 25, // 14420: check predicate 25
8302 OPC_Decode, 231, 114, 87, // 14422: decode to FLE_D using decoder 87
8303 // 14422: }
8304 1, 6, // 14426: case 0x1: {
8305 OPC_CheckPredicate, 25, // 14428: check predicate 25
8306 OPC_Decode, 249, 114, 87, // 14430: decode to FLT_D using decoder 87
8307 // 14430: }
8308 2, 6, // 14434: case 0x2: {
8309 OPC_CheckPredicate, 25, // 14436: check predicate 25
8310 OPC_Decode, 218, 114, 87, // 14438: decode to FEQ_D using decoder 87
8311 // 14438: }
8312 4, 6, // 14442: case 0x4: {
8313 OPC_CheckPredicate, 81, // 14444: check predicate 81
8314 OPC_Decode, 227, 114, 87, // 14446: decode to FLEQ_D using decoder 87
8315 // 14446: }
8316 5, 0, // 14450: case 0x5: {
8317 OPC_CheckPredicate, 81, // 14452: check predicate 81
8318 OPC_Decode, 245, 114, 87, // 14454: decode to FLTQ_D using decoder 87
8319 // 14454: }
8320 // 14454: } // switch Inst[14:12]
8321 // 14454: }
8322 82, 43, // 14458: case 0x52: {
8323 OPC_SwitchField, 12, 3, // 14460: switch Inst[14:12] {
8324 0, 6, // 14463: case 0x0: {
8325 OPC_CheckPredicate, 79, // 14465: check predicate 79
8326 OPC_Decode, 234, 114, 88, // 14467: decode to FLE_H using decoder 88
8327 // 14467: }
8328 1, 6, // 14471: case 0x1: {
8329 OPC_CheckPredicate, 79, // 14473: check predicate 79
8330 OPC_Decode, 252, 114, 88, // 14475: decode to FLT_H using decoder 88
8331 // 14475: }
8332 2, 6, // 14479: case 0x2: {
8333 OPC_CheckPredicate, 79, // 14481: check predicate 79
8334 OPC_Decode, 221, 114, 88, // 14483: decode to FEQ_H using decoder 88
8335 // 14483: }
8336 4, 6, // 14487: case 0x4: {
8337 OPC_CheckPredicate, 82, // 14489: check predicate 82
8338 OPC_Decode, 228, 114, 88, // 14491: decode to FLEQ_H using decoder 88
8339 // 14491: }
8340 5, 0, // 14495: case 0x5: {
8341 OPC_CheckPredicate, 82, // 14497: check predicate 82
8342 OPC_Decode, 246, 114, 88, // 14499: decode to FLTQ_H using decoder 88
8343 // 14499: }
8344 // 14499: } // switch Inst[14:12]
8345 // 14499: }
8346 83, 43, // 14503: case 0x53: {
8347 OPC_SwitchField, 12, 3, // 14505: switch Inst[14:12] {
8348 0, 6, // 14508: case 0x0: {
8349 OPC_CheckPredicate, 26, // 14510: check predicate 26
8350 OPC_Decode, 236, 114, 89, // 14512: decode to FLE_Q using decoder 89
8351 // 14512: }
8352 1, 6, // 14516: case 0x1: {
8353 OPC_CheckPredicate, 26, // 14518: check predicate 26
8354 OPC_Decode, 254, 114, 89, // 14520: decode to FLT_Q using decoder 89
8355 // 14520: }
8356 2, 6, // 14524: case 0x2: {
8357 OPC_CheckPredicate, 26, // 14526: check predicate 26
8358 OPC_Decode, 223, 114, 89, // 14528: decode to FEQ_Q using decoder 89
8359 // 14528: }
8360 4, 6, // 14532: case 0x4: {
8361 OPC_CheckPredicate, 83, // 14534: check predicate 83
8362 OPC_Decode, 229, 114, 89, // 14536: decode to FLEQ_Q using decoder 89
8363 // 14536: }
8364 5, 0, // 14540: case 0x5: {
8365 OPC_CheckPredicate, 83, // 14542: check predicate 83
8366 OPC_Decode, 247, 114, 89, // 14544: decode to FLTQ_Q using decoder 89
8367 // 14544: }
8368 // 14544: } // switch Inst[14:12]
8369 // 14544: }
8370 89, 10, // 14548: case 0x59: {
8371 OPC_CheckPredicate, 87, // 14550: check predicate 87
8372 OPC_CheckField, 12, 3, 0, // 14552: check Inst[14:12] == 0x0
8373 OPC_Decode, 180, 115, 90, // 14556: decode to FMVP_D_X using decoder 90
8374 // 14556: }
8375 91, 10, // 14560: case 0x5b: {
8376 OPC_CheckPredicate, 88, // 14562: check predicate 88
8377 OPC_CheckField, 12, 3, 0, // 14564: check Inst[14:12] == 0x0
8378 OPC_Decode, 181, 115, 91, // 14568: decode to FMVP_Q_X using decoder 91
8379 // 14568: }
8380 96, 35, // 14572: case 0x60: {
8381 OPC_SwitchField, 20, 5, // 14574: switch Inst[24:20] {
8382 0, 6, // 14577: case 0x0: {
8383 OPC_CheckPredicate, 24, // 14579: check predicate 24
8384 OPC_Decode, 205, 114, 92, // 14581: decode to FCVT_W_S using decoder 92
8385 // 14581: }
8386 1, 6, // 14585: case 0x1: {
8387 OPC_CheckPredicate, 24, // 14587: check predicate 24
8388 OPC_Decode, 197, 114, 92, // 14589: decode to FCVT_WU_S using decoder 92
8389 // 14589: }
8390 2, 6, // 14593: case 0x2: {
8391 OPC_CheckPredicate, 89, // 14595: check predicate 89
8392 OPC_Decode, 168, 114, 92, // 14597: decode to FCVT_L_S using decoder 92
8393 // 14597: }
8394 3, 0, // 14601: case 0x3: {
8395 OPC_CheckPredicate, 89, // 14603: check predicate 89
8396 OPC_Decode, 161, 114, 92, // 14605: decode to FCVT_LU_S using decoder 92
8397 // 14605: }
8398 // 14605: } // switch Inst[24:20]
8399 // 14605: }
8400 97, 47, // 14609: case 0x61: {
8401 OPC_SwitchField, 20, 5, // 14611: switch Inst[24:20] {
8402 0, 6, // 14614: case 0x0: {
8403 OPC_CheckPredicate, 25, // 14616: check predicate 25
8404 OPC_Decode, 199, 114, 93, // 14618: decode to FCVT_W_D using decoder 93
8405 // 14618: }
8406 1, 6, // 14622: case 0x1: {
8407 OPC_CheckPredicate, 25, // 14624: check predicate 25
8408 OPC_Decode, 191, 114, 93, // 14626: decode to FCVT_WU_D using decoder 93
8409 // 14626: }
8410 2, 6, // 14630: case 0x2: {
8411 OPC_CheckPredicate, 90, // 14632: check predicate 90
8412 OPC_Decode, 163, 114, 93, // 14634: decode to FCVT_L_D using decoder 93
8413 // 14634: }
8414 3, 6, // 14638: case 0x3: {
8415 OPC_CheckPredicate, 90, // 14640: check predicate 90
8416 OPC_Decode, 156, 114, 93, // 14642: decode to FCVT_LU_D using decoder 93
8417 // 14642: }
8418 8, 0, // 14646: case 0x8: {
8419 OPC_CheckPredicate, 81, // 14648: check predicate 81
8420 OPC_CheckField, 12, 3, 1, // 14650: check Inst[14:12] == 0x1
8421 OPC_Decode, 252, 113, 94, // 14654: decode to FCVTMOD_W_D using decoder 94
8422 // 14654: }
8423 // 14654: } // switch Inst[24:20]
8424 // 14654: }
8425 98, 35, // 14658: case 0x62: {
8426 OPC_SwitchField, 20, 5, // 14660: switch Inst[24:20] {
8427 0, 6, // 14663: case 0x0: {
8428 OPC_CheckPredicate, 79, // 14665: check predicate 79
8429 OPC_Decode, 202, 114, 95, // 14667: decode to FCVT_W_H using decoder 95
8430 // 14667: }
8431 1, 6, // 14671: case 0x1: {
8432 OPC_CheckPredicate, 79, // 14673: check predicate 79
8433 OPC_Decode, 194, 114, 95, // 14675: decode to FCVT_WU_H using decoder 95
8434 // 14675: }
8435 2, 6, // 14679: case 0x2: {
8436 OPC_CheckPredicate, 91, // 14681: check predicate 91
8437 OPC_Decode, 165, 114, 95, // 14683: decode to FCVT_L_H using decoder 95
8438 // 14683: }
8439 3, 0, // 14687: case 0x3: {
8440 OPC_CheckPredicate, 91, // 14689: check predicate 91
8441 OPC_Decode, 158, 114, 95, // 14691: decode to FCVT_LU_H using decoder 95
8442 // 14691: }
8443 // 14691: } // switch Inst[24:20]
8444 // 14691: }
8445 99, 35, // 14695: case 0x63: {
8446 OPC_SwitchField, 20, 5, // 14697: switch Inst[24:20] {
8447 0, 6, // 14700: case 0x0: {
8448 OPC_CheckPredicate, 26, // 14702: check predicate 26
8449 OPC_Decode, 204, 114, 96, // 14704: decode to FCVT_W_Q using decoder 96
8450 // 14704: }
8451 1, 6, // 14708: case 0x1: {
8452 OPC_CheckPredicate, 26, // 14710: check predicate 26
8453 OPC_Decode, 196, 114, 96, // 14712: decode to FCVT_WU_Q using decoder 96
8454 // 14712: }
8455 2, 6, // 14716: case 0x2: {
8456 OPC_CheckPredicate, 92, // 14718: check predicate 92
8457 OPC_Decode, 167, 114, 96, // 14720: decode to FCVT_L_Q using decoder 96
8458 // 14720: }
8459 3, 0, // 14724: case 0x3: {
8460 OPC_CheckPredicate, 92, // 14726: check predicate 92
8461 OPC_Decode, 160, 114, 96, // 14728: decode to FCVT_LU_Q using decoder 96
8462 // 14728: }
8463 // 14728: } // switch Inst[24:20]
8464 // 14728: }
8465 104, 35, // 14732: case 0x68: {
8466 OPC_SwitchField, 20, 5, // 14734: switch Inst[24:20] {
8467 0, 6, // 14737: case 0x0: {
8468 OPC_CheckPredicate, 24, // 14739: check predicate 24
8469 OPC_Decode, 187, 114, 97, // 14741: decode to FCVT_S_W using decoder 97
8470 // 14741: }
8471 1, 6, // 14745: case 0x1: {
8472 OPC_CheckPredicate, 24, // 14747: check predicate 24
8473 OPC_Decode, 188, 114, 97, // 14749: decode to FCVT_S_WU using decoder 97
8474 // 14749: }
8475 2, 6, // 14753: case 0x2: {
8476 OPC_CheckPredicate, 89, // 14755: check predicate 89
8477 OPC_Decode, 182, 114, 97, // 14757: decode to FCVT_S_L using decoder 97
8478 // 14757: }
8479 3, 0, // 14761: case 0x3: {
8480 OPC_CheckPredicate, 89, // 14763: check predicate 89
8481 OPC_Decode, 183, 114, 97, // 14765: decode to FCVT_S_LU using decoder 97
8482 // 14765: }
8483 // 14765: } // switch Inst[24:20]
8484 // 14765: }
8485 105, 35, // 14769: case 0x69: {
8486 OPC_SwitchField, 20, 5, // 14771: switch Inst[24:20] {
8487 0, 6, // 14774: case 0x0: {
8488 OPC_CheckPredicate, 25, // 14776: check predicate 25
8489 OPC_Decode, 137, 114, 98, // 14778: decode to FCVT_D_W using decoder 98
8490 // 14778: }
8491 1, 6, // 14782: case 0x1: {
8492 OPC_CheckPredicate, 25, // 14784: check predicate 25
8493 OPC_Decode, 138, 114, 98, // 14786: decode to FCVT_D_WU using decoder 98
8494 // 14786: }
8495 2, 6, // 14790: case 0x2: {
8496 OPC_CheckPredicate, 90, // 14792: check predicate 90
8497 OPC_Decode, 129, 114, 98, // 14794: decode to FCVT_D_L using decoder 98
8498 // 14794: }
8499 3, 0, // 14798: case 0x3: {
8500 OPC_CheckPredicate, 90, // 14800: check predicate 90
8501 OPC_Decode, 130, 114, 98, // 14802: decode to FCVT_D_LU using decoder 98
8502 // 14802: }
8503 // 14802: } // switch Inst[24:20]
8504 // 14802: }
8505 106, 35, // 14806: case 0x6a: {
8506 OPC_SwitchField, 20, 5, // 14808: switch Inst[24:20] {
8507 0, 6, // 14811: case 0x0: {
8508 OPC_CheckPredicate, 79, // 14813: check predicate 79
8509 OPC_Decode, 152, 114, 99, // 14815: decode to FCVT_H_W using decoder 99
8510 // 14815: }
8511 1, 6, // 14819: case 0x1: {
8512 OPC_CheckPredicate, 79, // 14821: check predicate 79
8513 OPC_Decode, 153, 114, 99, // 14823: decode to FCVT_H_WU using decoder 99
8514 // 14823: }
8515 2, 6, // 14827: case 0x2: {
8516 OPC_CheckPredicate, 91, // 14829: check predicate 91
8517 OPC_Decode, 146, 114, 99, // 14831: decode to FCVT_H_L using decoder 99
8518 // 14831: }
8519 3, 0, // 14835: case 0x3: {
8520 OPC_CheckPredicate, 91, // 14837: check predicate 91
8521 OPC_Decode, 147, 114, 99, // 14839: decode to FCVT_H_LU using decoder 99
8522 // 14839: }
8523 // 14839: } // switch Inst[24:20]
8524 // 14839: }
8525 107, 35, // 14843: case 0x6b: {
8526 OPC_SwitchField, 20, 5, // 14845: switch Inst[24:20] {
8527 0, 6, // 14848: case 0x0: {
8528 OPC_CheckPredicate, 26, // 14850: check predicate 26
8529 OPC_Decode, 174, 114, 100, // 14852: decode to FCVT_Q_W using decoder 100
8530 // 14852: }
8531 1, 6, // 14856: case 0x1: {
8532 OPC_CheckPredicate, 26, // 14858: check predicate 26
8533 OPC_Decode, 175, 114, 100, // 14860: decode to FCVT_Q_WU using decoder 100
8534 // 14860: }
8535 2, 6, // 14864: case 0x2: {
8536 OPC_CheckPredicate, 92, // 14866: check predicate 92
8537 OPC_Decode, 171, 114, 100, // 14868: decode to FCVT_Q_L using decoder 100
8538 // 14868: }
8539 3, 0, // 14872: case 0x3: {
8540 OPC_CheckPredicate, 92, // 14874: check predicate 92
8541 OPC_Decode, 172, 114, 100, // 14876: decode to FCVT_Q_LU using decoder 100
8542 // 14876: }
8543 // 14876: } // switch Inst[24:20]
8544 // 14876: }
8545 112, 27, // 14880: case 0x70: {
8546 OPC_SwitchField, 12, 3, // 14882: switch Inst[14:12] {
8547 0, 10, // 14885: case 0x0: {
8548 OPC_CheckPredicate, 24, // 14887: check predicate 24
8549 OPC_CheckField, 20, 5, 0, // 14889: check Inst[24:20] == 0x0
8550 OPC_Decode, 187, 115, 101, // 14893: decode to FMV_X_W using decoder 101
8551 // 14893: }
8552 1, 0, // 14897: case 0x1: {
8553 OPC_CheckPredicate, 24, // 14899: check predicate 24
8554 OPC_CheckField, 20, 5, 0, // 14901: check Inst[24:20] == 0x0
8555 OPC_Decode, 250, 113, 101, // 14905: decode to FCLASS_S using decoder 101
8556 // 14905: }
8557 // 14905: } // switch Inst[14:12]
8558 // 14905: }
8559 113, 36, // 14909: case 0x71: {
8560 OPC_SwitchField, 12, 3, // 14911: switch Inst[14:12] {
8561 0, 19, // 14914: case 0x0: {
8562 OPC_SwitchField, 20, 5, // 14916: switch Inst[24:20] {
8563 0, 6, // 14919: case 0x0: {
8564 OPC_CheckPredicate, 90, // 14921: check predicate 90
8565 OPC_Decode, 185, 115, 102, // 14923: decode to FMV_X_D using decoder 102
8566 // 14923: }
8567 1, 0, // 14927: case 0x1: {
8568 OPC_CheckPredicate, 87, // 14929: check predicate 87
8569 OPC_Decode, 178, 115, 102, // 14931: decode to FMVH_X_D using decoder 102
8570 // 14931: }
8571 // 14931: } // switch Inst[24:20]
8572 // 14931: }
8573 1, 0, // 14935: case 0x1: {
8574 OPC_CheckPredicate, 25, // 14937: check predicate 25
8575 OPC_CheckField, 20, 5, 0, // 14939: check Inst[24:20] == 0x0
8576 OPC_Decode, 244, 113, 102, // 14943: decode to FCLASS_D using decoder 102
8577 // 14943: }
8578 // 14943: } // switch Inst[14:12]
8579 // 14943: }
8580 114, 27, // 14947: case 0x72: {
8581 OPC_SwitchField, 12, 3, // 14949: switch Inst[14:12] {
8582 0, 10, // 14952: case 0x0: {
8583 OPC_CheckPredicate, 23, // 14954: check predicate 23
8584 OPC_CheckField, 20, 5, 0, // 14956: check Inst[24:20] == 0x0
8585 OPC_Decode, 186, 115, 103, // 14960: decode to FMV_X_H using decoder 103
8586 // 14960: }
8587 1, 0, // 14964: case 0x1: {
8588 OPC_CheckPredicate, 79, // 14966: check predicate 79
8589 OPC_CheckField, 20, 5, 0, // 14968: check Inst[24:20] == 0x0
8590 OPC_Decode, 247, 113, 103, // 14972: decode to FCLASS_H using decoder 103
8591 // 14972: }
8592 // 14972: } // switch Inst[14:12]
8593 // 14972: }
8594 115, 27, // 14976: case 0x73: {
8595 OPC_SwitchField, 12, 3, // 14978: switch Inst[14:12] {
8596 0, 10, // 14981: case 0x0: {
8597 OPC_CheckPredicate, 88, // 14983: check predicate 88
8598 OPC_CheckField, 20, 5, 1, // 14985: check Inst[24:20] == 0x1
8599 OPC_Decode, 179, 115, 104, // 14989: decode to FMVH_X_Q using decoder 104
8600 // 14989: }
8601 1, 0, // 14993: case 0x1: {
8602 OPC_CheckPredicate, 26, // 14995: check predicate 26
8603 OPC_CheckField, 20, 5, 0, // 14997: check Inst[24:20] == 0x0
8604 OPC_Decode, 249, 113, 104, // 15001: decode to FCLASS_Q using decoder 104
8605 // 15001: }
8606 // 15001: } // switch Inst[14:12]
8607 // 15001: }
8608 120, 27, // 15005: case 0x78: {
8609 OPC_SwitchField, 20, 5, // 15007: switch Inst[24:20] {
8610 0, 10, // 15010: case 0x0: {
8611 OPC_CheckPredicate, 24, // 15012: check predicate 24
8612 OPC_CheckField, 12, 3, 0, // 15014: check Inst[14:12] == 0x0
8613 OPC_Decode, 184, 115, 105, // 15018: decode to FMV_W_X using decoder 105
8614 // 15018: }
8615 1, 0, // 15022: case 0x1: {
8616 OPC_CheckPredicate, 80, // 15024: check predicate 80
8617 OPC_CheckField, 12, 3, 0, // 15026: check Inst[14:12] == 0x0
8618 OPC_Decode, 243, 114, 106, // 15030: decode to FLI_S using decoder 106
8619 // 15030: }
8620 // 15030: } // switch Inst[24:20]
8621 // 15030: }
8622 121, 27, // 15034: case 0x79: {
8623 OPC_SwitchField, 20, 5, // 15036: switch Inst[24:20] {
8624 0, 10, // 15039: case 0x0: {
8625 OPC_CheckPredicate, 90, // 15041: check predicate 90
8626 OPC_CheckField, 12, 3, 0, // 15043: check Inst[14:12] == 0x0
8627 OPC_Decode, 182, 115, 107, // 15047: decode to FMV_D_X using decoder 107
8628 // 15047: }
8629 1, 0, // 15051: case 0x1: {
8630 OPC_CheckPredicate, 81, // 15053: check predicate 81
8631 OPC_CheckField, 12, 3, 0, // 15055: check Inst[14:12] == 0x0
8632 OPC_Decode, 240, 114, 108, // 15059: decode to FLI_D using decoder 108
8633 // 15059: }
8634 // 15059: } // switch Inst[24:20]
8635 // 15059: }
8636 122, 27, // 15063: case 0x7a: {
8637 OPC_SwitchField, 20, 5, // 15065: switch Inst[24:20] {
8638 0, 10, // 15068: case 0x0: {
8639 OPC_CheckPredicate, 23, // 15070: check predicate 23
8640 OPC_CheckField, 12, 3, 0, // 15072: check Inst[14:12] == 0x0
8641 OPC_Decode, 183, 115, 109, // 15076: decode to FMV_H_X using decoder 109
8642 // 15076: }
8643 1, 0, // 15080: case 0x1: {
8644 OPC_CheckPredicate, 93, // 15082: check predicate 93
8645 OPC_CheckField, 12, 3, 0, // 15084: check Inst[14:12] == 0x0
8646 OPC_Decode, 241, 114, 110, // 15088: decode to FLI_H using decoder 110
8647 // 15088: }
8648 // 15088: } // switch Inst[24:20]
8649 // 15088: }
8650 123, 0, // 15092: case 0x7b: {
8651 OPC_CheckPredicate, 83, // 15094: check predicate 83
8652 OPC_CheckField, 20, 5, 1, // 15096: check Inst[24:20] == 0x1
8653 OPC_CheckField, 12, 3, 0, // 15100: check Inst[14:12] == 0x0
8654 OPC_Decode, 242, 114, 111, // 15104: decode to FLI_Q using decoder 111
8655 // 15104: }
8656 // 15104: } // switch Inst[31:25]
8657 // 15104: }
8658 87, 254, 28, // 15108: case 0x57: {
8659 OPC_SwitchField, 12, 3, // 15111: switch Inst[14:12] {
8660 0, 134, 4, // 15114: case 0x0: {
8661 OPC_SwitchField, 26, 6, // 15117: switch Inst[31:26] {
8662 0, 6, // 15120: case 0x0: {
8663 OPC_CheckPredicate, 22, // 15122: check predicate 22
8664 OPC_Decode, 212, 125, 112, // 15124: decode to VADD_VV using decoder 112
8665 // 15124: }
8666 1, 6, // 15128: case 0x1: {
8667 OPC_CheckPredicate, 94, // 15130: check predicate 94
8668 OPC_Decode, 225, 125, 112, // 15132: decode to VANDN_VV using decoder 112
8669 // 15132: }
8670 2, 7, // 15136: case 0x2: {
8671 OPC_CheckPredicate, 22, // 15138: check predicate 22
8672 OPC_Decode, 203, 130, 1, 112, // 15140: decode to VSUB_VV using decoder 112
8673 // 15140: }
8674 4, 7, // 15145: case 0x4: {
8675 OPC_CheckPredicate, 22, // 15147: check predicate 22
8676 OPC_Decode, 200, 128, 1, 112, // 15149: decode to VMINU_VV using decoder 112
8677 // 15149: }
8678 5, 7, // 15154: case 0x5: {
8679 OPC_CheckPredicate, 22, // 15156: check predicate 22
8680 OPC_Decode, 202, 128, 1, 112, // 15158: decode to VMIN_VV using decoder 112
8681 // 15158: }
8682 6, 7, // 15163: case 0x6: {
8683 OPC_CheckPredicate, 22, // 15165: check predicate 22
8684 OPC_Decode, 183, 128, 1, 112, // 15167: decode to VMAXU_VV using decoder 112
8685 // 15167: }
8686 7, 7, // 15172: case 0x7: {
8687 OPC_CheckPredicate, 22, // 15174: check predicate 22
8688 OPC_Decode, 185, 128, 1, 112, // 15176: decode to VMAX_VV using decoder 112
8689 // 15176: }
8690 9, 6, // 15181: case 0x9: {
8691 OPC_CheckPredicate, 22, // 15183: check predicate 22
8692 OPC_Decode, 228, 125, 112, // 15185: decode to VAND_VV using decoder 112
8693 // 15185: }
8694 10, 7, // 15189: case 0xa: {
8695 OPC_CheckPredicate, 22, // 15191: check predicate 22
8696 OPC_Decode, 148, 129, 1, 112, // 15193: decode to VOR_VV using decoder 112
8697 // 15193: }
8698 11, 7, // 15198: case 0xb: {
8699 OPC_CheckPredicate, 22, // 15200: check predicate 22
8700 OPC_Decode, 151, 131, 1, 112, // 15202: decode to VXOR_VV using decoder 112
8701 // 15202: }
8702 12, 7, // 15207: case 0xc: {
8703 OPC_CheckPredicate, 22, // 15209: check predicate 22
8704 OPC_Decode, 172, 129, 1, 112, // 15211: decode to VRGATHER_VV using decoder 112
8705 // 15211: }
8706 14, 7, // 15216: case 0xe: {
8707 OPC_CheckPredicate, 22, // 15218: check predicate 22
8708 OPC_Decode, 170, 129, 1, 112, // 15220: decode to VRGATHEREI16_VV using decoder 112
8709 // 15220: }
8710 15, 7, // 15225: case 0xf: {
8711 OPC_CheckPredicate, 95, // 15227: check predicate 95
8712 OPC_Decode, 150, 129, 1, 112, // 15229: decode to VPAIRE_VV using decoder 112
8713 // 15229: }
8714 16, 10, // 15234: case 0x10: {
8715 OPC_CheckPredicate, 22, // 15236: check predicate 22
8716 OPC_CheckField, 25, 1, 0, // 15238: check Inst[25] == 0x0
8717 OPC_Decode, 209, 125, 113, // 15242: decode to VADC_VVM using decoder 113
8718 // 15242: }
8719 17, 21, // 15246: case 0x11: {
8720 OPC_SwitchField, 25, 1, // 15248: switch Inst[25] {
8721 0, 7, // 15251: case 0x0: {
8722 OPC_CheckPredicate, 22, // 15253: check predicate 22
8723 OPC_Decode, 176, 128, 1, 113, // 15255: decode to VMADC_VVM using decoder 113
8724 // 15255: }
8725 1, 0, // 15260: case 0x1: {
8726 OPC_CheckPredicate, 22, // 15262: check predicate 22
8727 OPC_Decode, 175, 128, 1, 114, // 15264: decode to VMADC_VV using decoder 114
8728 // 15264: }
8729 // 15264: } // switch Inst[25]
8730 // 15264: }
8731 18, 11, // 15269: case 0x12: {
8732 OPC_CheckPredicate, 22, // 15271: check predicate 22
8733 OPC_CheckField, 25, 1, 0, // 15273: check Inst[25] == 0x0
8734 OPC_Decode, 191, 129, 1, 113, // 15277: decode to VSBC_VVM using decoder 113
8735 // 15277: }
8736 19, 21, // 15282: case 0x13: {
8737 OPC_SwitchField, 25, 1, // 15284: switch Inst[25] {
8738 0, 7, // 15287: case 0x0: {
8739 OPC_CheckPredicate, 22, // 15289: check predicate 22
8740 OPC_Decode, 210, 128, 1, 113, // 15291: decode to VMSBC_VVM using decoder 113
8741 // 15291: }
8742 1, 0, // 15296: case 0x1: {
8743 OPC_CheckPredicate, 22, // 15298: check predicate 22
8744 OPC_Decode, 209, 128, 1, 114, // 15300: decode to VMSBC_VV using decoder 114
8745 // 15300: }
8746 // 15300: } // switch Inst[25]
8747 // 15300: }
8748 20, 7, // 15305: case 0x14: {
8749 OPC_CheckPredicate, 94, // 15307: check predicate 94
8750 OPC_Decode, 177, 129, 1, 112, // 15309: decode to VROR_VV using decoder 112
8751 // 15309: }
8752 21, 7, // 15314: case 0x15: {
8753 OPC_CheckPredicate, 94, // 15316: check predicate 94
8754 OPC_Decode, 174, 129, 1, 112, // 15318: decode to VROL_VV using decoder 112
8755 // 15318: }
8756 23, 25, // 15323: case 0x17: {
8757 OPC_SwitchField, 25, 1, // 15325: switch Inst[25] {
8758 0, 7, // 15328: case 0x0: {
8759 OPC_CheckPredicate, 22, // 15330: check predicate 22
8760 OPC_Decode, 188, 128, 1, 113, // 15332: decode to VMERGE_VVM using decoder 113
8761 // 15332: }
8762 1, 0, // 15337: case 0x1: {
8763 OPC_CheckPredicate, 22, // 15339: check predicate 22
8764 OPC_CheckField, 20, 5, 0, // 15341: check Inst[24:20] == 0x0
8765 OPC_Decode, 254, 128, 1, 115, // 15345: decode to VMV_V_V using decoder 115
8766 // 15345: }
8767 // 15345: } // switch Inst[25]
8768 // 15345: }
8769 24, 7, // 15350: case 0x18: {
8770 OPC_CheckPredicate, 22, // 15352: check predicate 22
8771 OPC_Decode, 215, 128, 1, 112, // 15354: decode to VMSEQ_VV using decoder 112
8772 // 15354: }
8773 25, 7, // 15359: case 0x19: {
8774 OPC_CheckPredicate, 22, // 15361: check predicate 22
8775 OPC_Decode, 233, 128, 1, 112, // 15363: decode to VMSNE_VV using decoder 112
8776 // 15363: }
8777 26, 7, // 15368: case 0x1a: {
8778 OPC_CheckPredicate, 22, // 15370: check predicate 22
8779 OPC_Decode, 228, 128, 1, 112, // 15372: decode to VMSLTU_VV using decoder 112
8780 // 15372: }
8781 27, 7, // 15377: case 0x1b: {
8782 OPC_CheckPredicate, 22, // 15379: check predicate 22
8783 OPC_Decode, 230, 128, 1, 112, // 15381: decode to VMSLT_VV using decoder 112
8784 // 15381: }
8785 28, 7, // 15386: case 0x1c: {
8786 OPC_CheckPredicate, 22, // 15388: check predicate 22
8787 OPC_Decode, 223, 128, 1, 112, // 15390: decode to VMSLEU_VV using decoder 112
8788 // 15390: }
8789 29, 7, // 15395: case 0x1d: {
8790 OPC_CheckPredicate, 22, // 15397: check predicate 22
8791 OPC_Decode, 226, 128, 1, 112, // 15399: decode to VMSLE_VV using decoder 112
8792 // 15399: }
8793 32, 7, // 15404: case 0x20: {
8794 OPC_CheckPredicate, 22, // 15406: check predicate 22
8795 OPC_Decode, 186, 129, 1, 112, // 15408: decode to VSADDU_VV using decoder 112
8796 // 15408: }
8797 33, 7, // 15413: case 0x21: {
8798 OPC_CheckPredicate, 22, // 15415: check predicate 22
8799 OPC_Decode, 189, 129, 1, 112, // 15417: decode to VSADD_VV using decoder 112
8800 // 15417: }
8801 34, 7, // 15422: case 0x22: {
8802 OPC_CheckPredicate, 22, // 15424: check predicate 22
8803 OPC_Decode, 199, 130, 1, 112, // 15426: decode to VSSUBU_VV using decoder 112
8804 // 15426: }
8805 35, 7, // 15431: case 0x23: {
8806 OPC_CheckPredicate, 22, // 15433: check predicate 22
8807 OPC_Decode, 201, 130, 1, 112, // 15435: decode to VSSUB_VV using decoder 112
8808 // 15435: }
8809 37, 7, // 15440: case 0x25: {
8810 OPC_CheckPredicate, 22, // 15442: check predicate 22
8811 OPC_Decode, 213, 129, 1, 112, // 15444: decode to VSLL_VV using decoder 112
8812 // 15444: }
8813 39, 7, // 15449: case 0x27: {
8814 OPC_CheckPredicate, 22, // 15451: check predicate 22
8815 OPC_Decode, 220, 129, 1, 112, // 15453: decode to VSMUL_VV using decoder 112
8816 // 15453: }
8817 40, 7, // 15458: case 0x28: {
8818 OPC_CheckPredicate, 22, // 15460: check predicate 22
8819 OPC_Decode, 131, 130, 1, 112, // 15462: decode to VSRL_VV using decoder 112
8820 // 15462: }
8821 41, 7, // 15467: case 0x29: {
8822 OPC_CheckPredicate, 22, // 15469: check predicate 22
8823 OPC_Decode, 128, 130, 1, 112, // 15471: decode to VSRA_VV using decoder 112
8824 // 15471: }
8825 42, 7, // 15476: case 0x2a: {
8826 OPC_CheckPredicate, 22, // 15478: check predicate 22
8827 OPC_Decode, 169, 130, 1, 112, // 15480: decode to VSSRL_VV using decoder 112
8828 // 15480: }
8829 43, 7, // 15485: case 0x2b: {
8830 OPC_CheckPredicate, 22, // 15487: check predicate 22
8831 OPC_Decode, 166, 130, 1, 112, // 15489: decode to VSSRA_VV using decoder 112
8832 // 15489: }
8833 44, 7, // 15494: case 0x2c: {
8834 OPC_CheckPredicate, 22, // 15496: check predicate 22
8835 OPC_Decode, 145, 129, 1, 112, // 15498: decode to VNSRL_WV using decoder 112
8836 // 15498: }
8837 45, 7, // 15503: case 0x2d: {
8838 OPC_CheckPredicate, 22, // 15505: check predicate 22
8839 OPC_Decode, 142, 129, 1, 112, // 15507: decode to VNSRA_WV using decoder 112
8840 // 15507: }
8841 46, 7, // 15512: case 0x2e: {
8842 OPC_CheckPredicate, 22, // 15514: check predicate 22
8843 OPC_Decode, 132, 129, 1, 112, // 15516: decode to VNCLIPU_WV using decoder 112
8844 // 15516: }
8845 47, 7, // 15521: case 0x2f: {
8846 OPC_CheckPredicate, 22, // 15523: check predicate 22
8847 OPC_Decode, 135, 129, 1, 112, // 15525: decode to VNCLIP_WV using decoder 112
8848 // 15525: }
8849 48, 7, // 15530: case 0x30: {
8850 OPC_CheckPredicate, 22, // 15532: check predicate 22
8851 OPC_Decode, 137, 131, 1, 112, // 15534: decode to VWREDSUMU_VS using decoder 112
8852 // 15534: }
8853 49, 7, // 15539: case 0x31: {
8854 OPC_CheckPredicate, 22, // 15541: check predicate 22
8855 OPC_Decode, 138, 131, 1, 112, // 15543: decode to VWREDSUM_VS using decoder 112
8856 // 15543: }
8857 53, 7, // 15548: case 0x35: {
8858 OPC_CheckPredicate, 96, // 15550: check predicate 96
8859 OPC_Decode, 140, 131, 1, 112, // 15552: decode to VWSLL_VV using decoder 112
8860 // 15552: }
8861 56, 11, // 15557: case 0x38: {
8862 OPC_CheckPredicate, 97, // 15559: check predicate 97
8863 OPC_CheckField, 25, 1, 1, // 15561: check Inst[25] == 0x1
8864 OPC_Decode, 204, 128, 1, 116, // 15565: decode to VMMACC_VV using decoder 116
8865 // 15565: }
8866 57, 20, // 15570: case 0x39: {
8867 OPC_SwitchField, 25, 1, // 15572: switch Inst[25] {
8868 0, 6, // 15575: case 0x0: {
8869 OPC_CheckPredicate, 98, // 15577: check predicate 98
8870 OPC_Decode, 223, 126, 117, // 15579: decode to VFWIMMACC_VV using decoder 117
8871 // 15579: }
8872 1, 0, // 15583: case 0x1: {
8873 OPC_CheckPredicate, 97, // 15585: check predicate 97
8874 OPC_Decode, 130, 131, 1, 116, // 15587: decode to VWMMACC_VV using decoder 116
8875 // 15587: }
8876 // 15587: } // switch Inst[25]
8877 // 15587: }
8878 58, 20, // 15592: case 0x3a: {
8879 OPC_SwitchField, 25, 1, // 15594: switch Inst[25] {
8880 0, 6, // 15597: case 0x0: {
8881 OPC_CheckPredicate, 98, // 15599: check predicate 98
8882 OPC_Decode, 183, 126, 117, // 15601: decode to VFQIMMACC_VV using decoder 117
8883 // 15601: }
8884 1, 0, // 15605: case 0x1: {
8885 OPC_CheckPredicate, 97, // 15607: check predicate 97
8886 OPC_Decode, 152, 129, 1, 116, // 15609: decode to VQMMACC_VV using decoder 116
8887 // 15609: }
8888 // 15609: } // switch Inst[25]
8889 // 15609: }
8890 59, 0, // 15614: case 0x3b: {
8891 OPC_SwitchField, 25, 1, // 15616: switch Inst[25] {
8892 0, 6, // 15619: case 0x0: {
8893 OPC_CheckPredicate, 98, // 15621: check predicate 98
8894 OPC_Decode, 128, 126, 117, // 15623: decode to VF8WIMMACC_VV using decoder 117
8895 // 15623: }
8896 1, 0, // 15627: case 0x1: {
8897 OPC_CheckPredicate, 97, // 15629: check predicate 97
8898 OPC_Decode, 200, 125, 116, // 15631: decode to V8WMMACC_VV using decoder 116
8899 // 15631: }
8900 // 15631: } // switch Inst[25]
8901 // 15631: }
8902 // 15631: } // switch Inst[31:26]
8903 // 15631: }
8904 1, 133, 5, // 15635: case 0x1: {
8905 OPC_SwitchField, 26, 6, // 15638: switch Inst[31:26] {
8906 0, 6, // 15641: case 0x0: {
8907 OPC_CheckPredicate, 99, // 15643: check predicate 99
8908 OPC_Decode, 132, 126, 112, // 15645: decode to VFADD_VV using decoder 112
8909 // 15645: }
8910 1, 6, // 15649: case 0x1: {
8911 OPC_CheckPredicate, 99, // 15651: check predicate 99
8912 OPC_Decode, 195, 126, 112, // 15653: decode to VFREDUSUM_VS using decoder 112
8913 // 15653: }
8914 2, 6, // 15657: case 0x2: {
8915 OPC_CheckPredicate, 99, // 15659: check predicate 99
8916 OPC_Decode, 208, 126, 112, // 15661: decode to VFSUB_VV using decoder 112
8917 // 15661: }
8918 3, 6, // 15665: case 0x3: {
8919 OPC_CheckPredicate, 99, // 15667: check predicate 99
8920 OPC_Decode, 194, 126, 112, // 15669: decode to VFREDOSUM_VS using decoder 112
8921 // 15669: }
8922 4, 6, // 15673: case 0x4: {
8923 OPC_CheckPredicate, 99, // 15675: check predicate 99
8924 OPC_Decode, 152, 126, 112, // 15677: decode to VFMIN_VV using decoder 112
8925 // 15677: }
8926 5, 6, // 15681: case 0x5: {
8927 OPC_CheckPredicate, 99, // 15683: check predicate 99
8928 OPC_Decode, 193, 126, 112, // 15685: decode to VFREDMIN_VS using decoder 112
8929 // 15685: }
8930 6, 6, // 15689: case 0x6: {
8931 OPC_CheckPredicate, 99, // 15691: check predicate 99
8932 OPC_Decode, 149, 126, 112, // 15693: decode to VFMAX_VV using decoder 112
8933 // 15693: }
8934 7, 6, // 15697: case 0x7: {
8935 OPC_CheckPredicate, 99, // 15699: check predicate 99
8936 OPC_Decode, 192, 126, 112, // 15701: decode to VFREDMAX_VS using decoder 112
8937 // 15701: }
8938 8, 6, // 15705: case 0x8: {
8939 OPC_CheckPredicate, 99, // 15707: check predicate 99
8940 OPC_Decode, 203, 126, 112, // 15709: decode to VFSGNJ_VV using decoder 112
8941 // 15709: }
8942 9, 6, // 15713: case 0x9: {
8943 OPC_CheckPredicate, 99, // 15715: check predicate 99
8944 OPC_Decode, 199, 126, 112, // 15717: decode to VFSGNJN_VV using decoder 112
8945 // 15717: }
8946 10, 6, // 15721: case 0xa: {
8947 OPC_CheckPredicate, 99, // 15723: check predicate 99
8948 OPC_Decode, 201, 126, 112, // 15725: decode to VFSGNJX_VV using decoder 112
8949 // 15725: }
8950 16, 14, // 15729: case 0x10: {
8951 OPC_CheckPredicate, 99, // 15731: check predicate 99
8952 OPC_CheckField, 25, 1, 1, // 15733: check Inst[25] == 0x1
8953 OPC_CheckField, 15, 5, 0, // 15737: check Inst[19:15] == 0x0
8954 OPC_Decode, 160, 126, 118, // 15741: decode to VFMV_F_S using decoder 118
8955 // 15741: }
8956 18, 211, 1, // 15745: case 0x12: {
8957 OPC_SwitchField, 15, 5, // 15748: switch Inst[19:15] {
8958 0, 6, // 15751: case 0x0: {
8959 OPC_CheckPredicate, 99, // 15753: check predicate 99
8960 OPC_Decode, 139, 126, 119, // 15755: decode to VFCVT_XU_F_V using decoder 119
8961 // 15755: }
8962 1, 6, // 15759: case 0x1: {
8963 OPC_CheckPredicate, 99, // 15761: check predicate 99
8964 OPC_Decode, 140, 126, 119, // 15763: decode to VFCVT_X_F_V using decoder 119
8965 // 15763: }
8966 2, 6, // 15767: case 0x2: {
8967 OPC_CheckPredicate, 99, // 15769: check predicate 99
8968 OPC_Decode, 135, 126, 119, // 15771: decode to VFCVT_F_XU_V using decoder 119
8969 // 15771: }
8970 3, 6, // 15775: case 0x3: {
8971 OPC_CheckPredicate, 99, // 15777: check predicate 99
8972 OPC_Decode, 136, 126, 119, // 15779: decode to VFCVT_F_X_V using decoder 119
8973 // 15779: }
8974 6, 6, // 15783: case 0x6: {
8975 OPC_CheckPredicate, 99, // 15785: check predicate 99
8976 OPC_Decode, 137, 126, 119, // 15787: decode to VFCVT_RTZ_XU_F_V using decoder 119
8977 // 15787: }
8978 7, 6, // 15791: case 0x7: {
8979 OPC_CheckPredicate, 99, // 15793: check predicate 99
8980 OPC_Decode, 138, 126, 119, // 15795: decode to VFCVT_RTZ_X_F_V using decoder 119
8981 // 15795: }
8982 8, 6, // 15799: case 0x8: {
8983 OPC_CheckPredicate, 99, // 15801: check predicate 99
8984 OPC_Decode, 220, 126, 119, // 15803: decode to VFWCVT_XU_F_V using decoder 119
8985 // 15803: }
8986 9, 6, // 15807: case 0x9: {
8987 OPC_CheckPredicate, 99, // 15809: check predicate 99
8988 OPC_Decode, 221, 126, 119, // 15811: decode to VFWCVT_X_F_V using decoder 119
8989 // 15811: }
8990 10, 6, // 15815: case 0xa: {
8991 OPC_CheckPredicate, 99, // 15817: check predicate 99
8992 OPC_Decode, 216, 126, 119, // 15819: decode to VFWCVT_F_XU_V using decoder 119
8993 // 15819: }
8994 11, 6, // 15823: case 0xb: {
8995 OPC_CheckPredicate, 99, // 15825: check predicate 99
8996 OPC_Decode, 217, 126, 119, // 15827: decode to VFWCVT_F_X_V using decoder 119
8997 // 15827: }
8998 12, 6, // 15831: case 0xc: {
8999 OPC_CheckPredicate, 99, // 15833: check predicate 99
9000 OPC_Decode, 215, 126, 119, // 15835: decode to VFWCVT_F_F_V using decoder 119
9001 // 15835: }
9002 13, 6, // 15839: case 0xd: {
9003 OPC_CheckPredicate, 100, // 15841: check predicate 100
9004 OPC_Decode, 214, 126, 119, // 15843: decode to VFWCVTBF16_F_F_V using decoder 119
9005 // 15843: }
9006 14, 6, // 15847: case 0xe: {
9007 OPC_CheckPredicate, 99, // 15849: check predicate 99
9008 OPC_Decode, 218, 126, 119, // 15851: decode to VFWCVT_RTZ_XU_F_V using decoder 119
9009 // 15851: }
9010 15, 6, // 15855: case 0xf: {
9011 OPC_CheckPredicate, 99, // 15857: check predicate 99
9012 OPC_Decode, 219, 126, 119, // 15859: decode to VFWCVT_RTZ_X_F_V using decoder 119
9013 // 15859: }
9014 16, 6, // 15863: case 0x10: {
9015 OPC_CheckPredicate, 99, // 15865: check predicate 99
9016 OPC_Decode, 173, 126, 119, // 15867: decode to VFNCVT_XU_F_W using decoder 119
9017 // 15867: }
9018 17, 6, // 15871: case 0x11: {
9019 OPC_CheckPredicate, 99, // 15873: check predicate 99
9020 OPC_Decode, 174, 126, 119, // 15875: decode to VFNCVT_X_F_W using decoder 119
9021 // 15875: }
9022 18, 6, // 15879: case 0x12: {
9023 OPC_CheckPredicate, 99, // 15881: check predicate 99
9024 OPC_Decode, 167, 126, 119, // 15883: decode to VFNCVT_F_XU_W using decoder 119
9025 // 15883: }
9026 19, 6, // 15887: case 0x13: {
9027 OPC_CheckPredicate, 99, // 15889: check predicate 99
9028 OPC_Decode, 168, 126, 119, // 15891: decode to VFNCVT_F_X_W using decoder 119
9029 // 15891: }
9030 20, 6, // 15895: case 0x14: {
9031 OPC_CheckPredicate, 99, // 15897: check predicate 99
9032 OPC_Decode, 166, 126, 119, // 15899: decode to VFNCVT_F_F_W using decoder 119
9033 // 15899: }
9034 21, 6, // 15903: case 0x15: {
9035 OPC_CheckPredicate, 99, // 15905: check predicate 99
9036 OPC_Decode, 169, 126, 119, // 15907: decode to VFNCVT_ROD_F_F_W using decoder 119
9037 // 15907: }
9038 22, 6, // 15911: case 0x16: {
9039 OPC_CheckPredicate, 99, // 15913: check predicate 99
9040 OPC_Decode, 170, 126, 119, // 15915: decode to VFNCVT_RTZ_XU_F_W using decoder 119
9041 // 15915: }
9042 23, 6, // 15919: case 0x17: {
9043 OPC_CheckPredicate, 99, // 15921: check predicate 99
9044 OPC_Decode, 171, 126, 119, // 15923: decode to VFNCVT_RTZ_X_F_W using decoder 119
9045 // 15923: }
9046 25, 6, // 15927: case 0x19: {
9047 OPC_CheckPredicate, 101, // 15929: check predicate 101
9048 OPC_Decode, 165, 126, 119, // 15931: decode to VFNCVT_F_F_Q using decoder 119
9049 // 15931: }
9050 27, 6, // 15935: case 0x1b: {
9051 OPC_CheckPredicate, 101, // 15937: check predicate 101
9052 OPC_Decode, 172, 126, 119, // 15939: decode to VFNCVT_SAT_F_F_Q using decoder 119
9053 // 15939: }
9054 29, 6, // 15943: case 0x1d: {
9055 OPC_CheckPredicate, 100, // 15945: check predicate 100
9056 OPC_Decode, 163, 126, 119, // 15947: decode to VFNCVTBF16_F_F_W using decoder 119
9057 // 15947: }
9058 31, 0, // 15951: case 0x1f: {
9059 OPC_CheckPredicate, 101, // 15953: check predicate 101
9060 OPC_Decode, 164, 126, 119, // 15955: decode to VFNCVTBF16_SAT_F_F_W using decoder 119
9061 // 15955: }
9062 // 15955: } // switch Inst[19:15]
9063 // 15955: }
9064 19, 35, // 15959: case 0x13: {
9065 OPC_SwitchField, 15, 5, // 15961: switch Inst[19:15] {
9066 0, 6, // 15964: case 0x0: {
9067 OPC_CheckPredicate, 99, // 15966: check predicate 99
9068 OPC_Decode, 206, 126, 119, // 15968: decode to VFSQRT_V using decoder 119
9069 // 15968: }
9070 4, 6, // 15972: case 0x4: {
9071 OPC_CheckPredicate, 99, // 15974: check predicate 99
9072 OPC_Decode, 196, 126, 119, // 15976: decode to VFRSQRT7_V using decoder 119
9073 // 15976: }
9074 5, 6, // 15980: case 0x5: {
9075 OPC_CheckPredicate, 99, // 15982: check predicate 99
9076 OPC_Decode, 191, 126, 119, // 15984: decode to VFREC7_V using decoder 119
9077 // 15984: }
9078 16, 0, // 15988: case 0x10: {
9079 OPC_CheckPredicate, 99, // 15990: check predicate 99
9080 OPC_Decode, 134, 126, 119, // 15992: decode to VFCLASS_V using decoder 119
9081 // 15992: }
9082 // 15992: } // switch Inst[19:15]
9083 // 15992: }
9084 20, 10, // 15996: case 0x14: {
9085 OPC_CheckPredicate, 98, // 15998: check predicate 98
9086 OPC_CheckField, 25, 1, 1, // 16000: check Inst[25] == 0x1
9087 OPC_Decode, 153, 126, 116, // 16004: decode to VFMMACC_VV using decoder 116
9088 // 16004: }
9089 21, 19, // 16008: case 0x15: {
9090 OPC_SwitchField, 25, 1, // 16010: switch Inst[25] {
9091 0, 6, // 16013: case 0x0: {
9092 OPC_CheckPredicate, 98, // 16015: check predicate 98
9093 OPC_Decode, 229, 126, 117, // 16017: decode to VFWMMACC_VV_SCALE using decoder 117
9094 // 16017: }
9095 1, 0, // 16021: case 0x1: {
9096 OPC_CheckPredicate, 98, // 16023: check predicate 98
9097 OPC_Decode, 228, 126, 116, // 16025: decode to VFWMMACC_VV using decoder 116
9098 // 16025: }
9099 // 16025: } // switch Inst[25]
9100 // 16025: }
9101 22, 19, // 16029: case 0x16: {
9102 OPC_SwitchField, 25, 1, // 16031: switch Inst[25] {
9103 0, 6, // 16034: case 0x0: {
9104 OPC_CheckPredicate, 98, // 16036: check predicate 98
9105 OPC_Decode, 185, 126, 117, // 16038: decode to VFQMMACC_VV_SCALE using decoder 117
9106 // 16038: }
9107 1, 0, // 16042: case 0x1: {
9108 OPC_CheckPredicate, 98, // 16044: check predicate 98
9109 OPC_Decode, 184, 126, 116, // 16046: decode to VFQMMACC_VV using decoder 116
9110 // 16046: }
9111 // 16046: } // switch Inst[25]
9112 // 16046: }
9113 23, 19, // 16050: case 0x17: {
9114 OPC_SwitchField, 25, 1, // 16052: switch Inst[25] {
9115 0, 6, // 16055: case 0x0: {
9116 OPC_CheckPredicate, 98, // 16057: check predicate 98
9117 OPC_Decode, 130, 126, 117, // 16059: decode to VF8WMMACC_VV_SCALE using decoder 117
9118 // 16059: }
9119 1, 0, // 16063: case 0x1: {
9120 OPC_CheckPredicate, 98, // 16065: check predicate 98
9121 OPC_Decode, 129, 126, 116, // 16067: decode to VF8WMMACC_VV using decoder 116
9122 // 16067: }
9123 // 16067: } // switch Inst[25]
9124 // 16067: }
9125 24, 7, // 16071: case 0x18: {
9126 OPC_CheckPredicate, 99, // 16073: check predicate 99
9127 OPC_Decode, 191, 128, 1, 112, // 16075: decode to VMFEQ_VV using decoder 112
9128 // 16075: }
9129 25, 7, // 16080: case 0x19: {
9130 OPC_CheckPredicate, 99, // 16082: check predicate 99
9131 OPC_Decode, 195, 128, 1, 112, // 16084: decode to VMFLE_VV using decoder 112
9132 // 16084: }
9133 27, 7, // 16089: case 0x1b: {
9134 OPC_CheckPredicate, 99, // 16091: check predicate 99
9135 OPC_Decode, 197, 128, 1, 112, // 16093: decode to VMFLT_VV using decoder 112
9136 // 16093: }
9137 28, 7, // 16098: case 0x1c: {
9138 OPC_CheckPredicate, 99, // 16100: check predicate 99
9139 OPC_Decode, 199, 128, 1, 112, // 16102: decode to VMFNE_VV using decoder 112
9140 // 16102: }
9141 32, 6, // 16107: case 0x20: {
9142 OPC_CheckPredicate, 99, // 16109: check predicate 99
9143 OPC_Decode, 142, 126, 112, // 16111: decode to VFDIV_VV using decoder 112
9144 // 16111: }
9145 36, 6, // 16115: case 0x24: {
9146 OPC_CheckPredicate, 99, // 16117: check predicate 99
9147 OPC_Decode, 159, 126, 112, // 16119: decode to VFMUL_VV using decoder 112
9148 // 16119: }
9149 40, 6, // 16123: case 0x28: {
9150 OPC_CheckPredicate, 99, // 16125: check predicate 99
9151 OPC_Decode, 147, 126, 120, // 16127: decode to VFMADD_VV using decoder 120
9152 // 16127: }
9153 41, 6, // 16131: case 0x29: {
9154 OPC_CheckPredicate, 99, // 16133: check predicate 99
9155 OPC_Decode, 178, 126, 120, // 16135: decode to VFNMADD_VV using decoder 120
9156 // 16135: }
9157 42, 6, // 16139: case 0x2a: {
9158 OPC_CheckPredicate, 99, // 16141: check predicate 99
9159 OPC_Decode, 157, 126, 120, // 16143: decode to VFMSUB_VV using decoder 120
9160 // 16143: }
9161 43, 6, // 16147: case 0x2b: {
9162 OPC_CheckPredicate, 99, // 16149: check predicate 99
9163 OPC_Decode, 182, 126, 120, // 16151: decode to VFNMSUB_VV using decoder 120
9164 // 16151: }
9165 44, 6, // 16155: case 0x2c: {
9166 OPC_CheckPredicate, 99, // 16157: check predicate 99
9167 OPC_Decode, 145, 126, 120, // 16159: decode to VFMACC_VV using decoder 120
9168 // 16159: }
9169 45, 6, // 16163: case 0x2d: {
9170 OPC_CheckPredicate, 99, // 16165: check predicate 99
9171 OPC_Decode, 176, 126, 120, // 16167: decode to VFNMACC_VV using decoder 120
9172 // 16167: }
9173 46, 6, // 16171: case 0x2e: {
9174 OPC_CheckPredicate, 99, // 16173: check predicate 99
9175 OPC_Decode, 155, 126, 120, // 16175: decode to VFMSAC_VV using decoder 120
9176 // 16175: }
9177 47, 6, // 16179: case 0x2f: {
9178 OPC_CheckPredicate, 99, // 16181: check predicate 99
9179 OPC_Decode, 180, 126, 120, // 16183: decode to VFNMSAC_VV using decoder 120
9180 // 16183: }
9181 48, 6, // 16187: case 0x30: {
9182 OPC_CheckPredicate, 99, // 16189: check predicate 99
9183 OPC_Decode, 210, 126, 112, // 16191: decode to VFWADD_VV using decoder 112
9184 // 16191: }
9185 49, 6, // 16195: case 0x31: {
9186 OPC_CheckPredicate, 99, // 16197: check predicate 99
9187 OPC_Decode, 239, 126, 112, // 16199: decode to VFWREDUSUM_VS using decoder 112
9188 // 16199: }
9189 50, 6, // 16203: case 0x32: {
9190 OPC_CheckPredicate, 99, // 16205: check predicate 99
9191 OPC_Decode, 241, 126, 112, // 16207: decode to VFWSUB_VV using decoder 112
9192 // 16207: }
9193 51, 6, // 16211: case 0x33: {
9194 OPC_CheckPredicate, 99, // 16213: check predicate 99
9195 OPC_Decode, 238, 126, 112, // 16215: decode to VFWREDOSUM_VS using decoder 112
9196 // 16215: }
9197 52, 6, // 16219: case 0x34: {
9198 OPC_CheckPredicate, 99, // 16221: check predicate 99
9199 OPC_Decode, 212, 126, 112, // 16223: decode to VFWADD_WV using decoder 112
9200 // 16223: }
9201 54, 6, // 16227: case 0x36: {
9202 OPC_CheckPredicate, 99, // 16229: check predicate 99
9203 OPC_Decode, 243, 126, 112, // 16231: decode to VFWSUB_WV using decoder 112
9204 // 16231: }
9205 56, 6, // 16235: case 0x38: {
9206 OPC_CheckPredicate, 99, // 16237: check predicate 99
9207 OPC_Decode, 233, 126, 112, // 16239: decode to VFWMUL_VV using decoder 112
9208 // 16239: }
9209 59, 6, // 16243: case 0x3b: {
9210 OPC_CheckPredicate, 102, // 16245: check predicate 102
9211 OPC_Decode, 225, 126, 120, // 16247: decode to VFWMACCBF16_VV using decoder 120
9212 // 16247: }
9213 60, 6, // 16251: case 0x3c: {
9214 OPC_CheckPredicate, 99, // 16253: check predicate 99
9215 OPC_Decode, 227, 126, 120, // 16255: decode to VFWMACC_VV using decoder 120
9216 // 16255: }
9217 61, 6, // 16259: case 0x3d: {
9218 OPC_CheckPredicate, 99, // 16261: check predicate 99
9219 OPC_Decode, 235, 126, 120, // 16263: decode to VFWNMACC_VV using decoder 120
9220 // 16263: }
9221 62, 6, // 16267: case 0x3e: {
9222 OPC_CheckPredicate, 99, // 16269: check predicate 99
9223 OPC_Decode, 231, 126, 120, // 16271: decode to VFWMSAC_VV using decoder 120
9224 // 16271: }
9225 63, 0, // 16275: case 0x3f: {
9226 OPC_CheckPredicate, 99, // 16277: check predicate 99
9227 OPC_Decode, 237, 126, 120, // 16279: decode to VFWNMSAC_VV using decoder 120
9228 // 16279: }
9229 // 16279: } // switch Inst[31:26]
9230 // 16279: }
9231 2, 128, 6, // 16283: case 0x2: {
9232 OPC_SwitchField, 26, 6, // 16286: switch Inst[31:26] {
9233 0, 7, // 16289: case 0x0: {
9234 OPC_CheckPredicate, 22, // 16291: check predicate 22
9235 OPC_Decode, 163, 129, 1, 112, // 16293: decode to VREDSUM_VS using decoder 112
9236 // 16293: }
9237 1, 7, // 16298: case 0x1: {
9238 OPC_CheckPredicate, 22, // 16300: check predicate 22
9239 OPC_Decode, 157, 129, 1, 112, // 16302: decode to VREDAND_VS using decoder 112
9240 // 16302: }
9241 2, 7, // 16307: case 0x2: {
9242 OPC_CheckPredicate, 22, // 16309: check predicate 22
9243 OPC_Decode, 162, 129, 1, 112, // 16311: decode to VREDOR_VS using decoder 112
9244 // 16311: }
9245 3, 7, // 16316: case 0x3: {
9246 OPC_CheckPredicate, 22, // 16318: check predicate 22
9247 OPC_Decode, 164, 129, 1, 112, // 16320: decode to VREDXOR_VS using decoder 112
9248 // 16320: }
9249 4, 7, // 16325: case 0x4: {
9250 OPC_CheckPredicate, 22, // 16327: check predicate 22
9251 OPC_Decode, 160, 129, 1, 112, // 16329: decode to VREDMINU_VS using decoder 112
9252 // 16329: }
9253 5, 7, // 16334: case 0x5: {
9254 OPC_CheckPredicate, 22, // 16336: check predicate 22
9255 OPC_Decode, 161, 129, 1, 112, // 16338: decode to VREDMIN_VS using decoder 112
9256 // 16338: }
9257 6, 7, // 16343: case 0x6: {
9258 OPC_CheckPredicate, 22, // 16345: check predicate 22
9259 OPC_Decode, 158, 129, 1, 112, // 16347: decode to VREDMAXU_VS using decoder 112
9260 // 16347: }
9261 7, 7, // 16352: case 0x7: {
9262 OPC_CheckPredicate, 22, // 16354: check predicate 22
9263 OPC_Decode, 159, 129, 1, 112, // 16356: decode to VREDMAX_VS using decoder 112
9264 // 16356: }
9265 8, 6, // 16361: case 0x8: {
9266 OPC_CheckPredicate, 22, // 16363: check predicate 22
9267 OPC_Decode, 201, 125, 112, // 16365: decode to VAADDU_VV using decoder 112
9268 // 16365: }
9269 9, 6, // 16369: case 0x9: {
9270 OPC_CheckPredicate, 22, // 16371: check predicate 22
9271 OPC_Decode, 203, 125, 112, // 16373: decode to VAADD_VV using decoder 112
9272 // 16373: }
9273 10, 6, // 16377: case 0xa: {
9274 OPC_CheckPredicate, 22, // 16379: check predicate 22
9275 OPC_Decode, 230, 125, 112, // 16381: decode to VASUBU_VV using decoder 112
9276 // 16381: }
9277 11, 6, // 16385: case 0xb: {
9278 OPC_CheckPredicate, 22, // 16387: check predicate 22
9279 OPC_Decode, 232, 125, 112, // 16389: decode to VASUB_VV using decoder 112
9280 // 16389: }
9281 12, 6, // 16393: case 0xc: {
9282 OPC_CheckPredicate, 103, // 16395: check predicate 103
9283 OPC_Decode, 238, 125, 112, // 16397: decode to VCLMUL_VV using decoder 112
9284 // 16397: }
9285 13, 6, // 16401: case 0xd: {
9286 OPC_CheckPredicate, 103, // 16403: check predicate 103
9287 OPC_Decode, 236, 125, 112, // 16405: decode to VCLMULH_VV using decoder 112
9288 // 16405: }
9289 15, 7, // 16409: case 0xf: {
9290 OPC_CheckPredicate, 95, // 16411: check predicate 95
9291 OPC_Decode, 151, 129, 1, 112, // 16413: decode to VPAIRO_VV using decoder 112
9292 // 16413: }
9293 16, 32, // 16418: case 0x10: {
9294 OPC_SwitchField, 15, 5, // 16420: switch Inst[19:15] {
9295 0, 11, // 16423: case 0x0: {
9296 OPC_CheckPredicate, 22, // 16425: check predicate 22
9297 OPC_CheckField, 25, 1, 1, // 16427: check Inst[25] == 0x1
9298 OPC_Decode, 128, 129, 1, 121, // 16431: decode to VMV_X_S using decoder 121
9299 // 16431: }
9300 16, 6, // 16436: case 0x10: {
9301 OPC_CheckPredicate, 22, // 16438: check predicate 22
9302 OPC_Decode, 242, 125, 122, // 16440: decode to VCPOP_M using decoder 122
9303 // 16440: }
9304 17, 0, // 16444: case 0x11: {
9305 OPC_CheckPredicate, 22, // 16446: check predicate 22
9306 OPC_Decode, 143, 126, 122, // 16448: decode to VFIRST_M using decoder 122
9307 // 16448: }
9308 // 16448: } // switch Inst[19:15]
9309 // 16448: }
9310 17, 6, // 16452: case 0x11: {
9311 OPC_CheckPredicate, 104, // 16454: check predicate 104
9312 OPC_Decode, 206, 125, 112, // 16456: decode to VABD_VV using decoder 112
9313 // 16456: }
9314 18, 132, 1, // 16460: case 0x12: {
9315 OPC_SwitchField, 15, 5, // 16463: switch Inst[19:15] {
9316 2, 7, // 16466: case 0x2: {
9317 OPC_CheckPredicate, 22, // 16468: check predicate 22
9318 OPC_Decode, 155, 131, 1, 119, // 16470: decode to VZEXT_VF8 using decoder 119
9319 // 16470: }
9320 3, 7, // 16475: case 0x3: {
9321 OPC_CheckPredicate, 22, // 16477: check predicate 22
9322 OPC_Decode, 202, 129, 1, 119, // 16479: decode to VSEXT_VF8 using decoder 119
9323 // 16479: }
9324 4, 7, // 16484: case 0x4: {
9325 OPC_CheckPredicate, 22, // 16486: check predicate 22
9326 OPC_Decode, 154, 131, 1, 119, // 16488: decode to VZEXT_VF4 using decoder 119
9327 // 16488: }
9328 5, 7, // 16493: case 0x5: {
9329 OPC_CheckPredicate, 22, // 16495: check predicate 22
9330 OPC_Decode, 201, 129, 1, 119, // 16497: decode to VSEXT_VF4 using decoder 119
9331 // 16497: }
9332 6, 7, // 16502: case 0x6: {
9333 OPC_CheckPredicate, 22, // 16504: check predicate 22
9334 OPC_Decode, 153, 131, 1, 119, // 16506: decode to VZEXT_VF2 using decoder 119
9335 // 16506: }
9336 7, 7, // 16511: case 0x7: {
9337 OPC_CheckPredicate, 22, // 16513: check predicate 22
9338 OPC_Decode, 200, 129, 1, 119, // 16515: decode to VSEXT_VF2 using decoder 119
9339 // 16515: }
9340 8, 6, // 16520: case 0x8: {
9341 OPC_CheckPredicate, 94, // 16522: check predicate 94
9342 OPC_Decode, 234, 125, 119, // 16524: decode to VBREV8_V using decoder 119
9343 // 16524: }
9344 9, 7, // 16528: case 0x9: {
9345 OPC_CheckPredicate, 94, // 16530: check predicate 94
9346 OPC_Decode, 169, 129, 1, 119, // 16532: decode to VREV8_V using decoder 119
9347 // 16532: }
9348 10, 6, // 16537: case 0xa: {
9349 OPC_CheckPredicate, 96, // 16539: check predicate 96
9350 OPC_Decode, 235, 125, 119, // 16541: decode to VBREV_V using decoder 119
9351 // 16541: }
9352 11, 7, // 16545: case 0xb: {
9353 OPC_CheckPredicate, 95, // 16547: check predicate 95
9354 OPC_Decode, 239, 130, 1, 119, // 16549: decode to VUNZIPE_V using decoder 119
9355 // 16549: }
9356 12, 6, // 16554: case 0xc: {
9357 OPC_CheckPredicate, 96, // 16556: check predicate 96
9358 OPC_Decode, 240, 125, 119, // 16558: decode to VCLZ_V using decoder 119
9359 // 16558: }
9360 13, 6, // 16562: case 0xd: {
9361 OPC_CheckPredicate, 96, // 16564: check predicate 96
9362 OPC_Decode, 244, 125, 119, // 16566: decode to VCTZ_V using decoder 119
9363 // 16566: }
9364 14, 6, // 16570: case 0xe: {
9365 OPC_CheckPredicate, 96, // 16572: check predicate 96
9366 OPC_Decode, 243, 125, 119, // 16574: decode to VCPOP_V using decoder 119
9367 // 16574: }
9368 15, 7, // 16578: case 0xf: {
9369 OPC_CheckPredicate, 95, // 16580: check predicate 95
9370 OPC_Decode, 240, 130, 1, 119, // 16582: decode to VUNZIPO_V using decoder 119
9371 // 16582: }
9372 16, 0, // 16587: case 0x10: {
9373 OPC_CheckPredicate, 104, // 16589: check predicate 104
9374 OPC_Decode, 207, 125, 119, // 16591: decode to VABS_V using decoder 119
9375 // 16591: }
9376 // 16591: } // switch Inst[19:15]
9377 // 16591: }
9378 19, 6, // 16595: case 0x13: {
9379 OPC_CheckPredicate, 104, // 16597: check predicate 104
9380 OPC_Decode, 205, 125, 112, // 16599: decode to VABDU_VV using decoder 112
9381 // 16599: }
9382 20, 50, // 16603: case 0x14: {
9383 OPC_SwitchField, 15, 5, // 16605: switch Inst[19:15] {
9384 1, 7, // 16608: case 0x1: {
9385 OPC_CheckPredicate, 22, // 16610: check predicate 22
9386 OPC_Decode, 213, 128, 1, 119, // 16612: decode to VMSBF_M using decoder 119
9387 // 16612: }
9388 2, 7, // 16617: case 0x2: {
9389 OPC_CheckPredicate, 22, // 16619: check predicate 22
9390 OPC_Decode, 235, 128, 1, 119, // 16621: decode to VMSOF_M using decoder 119
9391 // 16621: }
9392 3, 7, // 16626: case 0x3: {
9393 OPC_CheckPredicate, 22, // 16628: check predicate 22
9394 OPC_Decode, 221, 128, 1, 119, // 16630: decode to VMSIF_M using decoder 119
9395 // 16630: }
9396 16, 6, // 16635: case 0x10: {
9397 OPC_CheckPredicate, 22, // 16637: check predicate 22
9398 OPC_Decode, 249, 126, 119, // 16639: decode to VIOTA_M using decoder 119
9399 // 16639: }
9400 17, 0, // 16643: case 0x11: {
9401 OPC_CheckPredicate, 22, // 16645: check predicate 22
9402 OPC_CheckField, 20, 5, 0, // 16647: check Inst[24:20] == 0x0
9403 OPC_Decode, 248, 126, 123, // 16651: decode to VID_V using decoder 123
9404 // 16651: }
9405 // 16651: } // switch Inst[19:15]
9406 // 16651: }
9407 21, 7, // 16655: case 0x15: {
9408 OPC_CheckPredicate, 104, // 16657: check predicate 104
9409 OPC_Decode, 242, 130, 1, 112, // 16659: decode to VWABDA_VV using decoder 112
9410 // 16659: }
9411 22, 7, // 16664: case 0x16: {
9412 OPC_CheckPredicate, 104, // 16666: check predicate 104
9413 OPC_Decode, 241, 130, 1, 112, // 16668: decode to VWABDAU_VV using decoder 112
9414 // 16668: }
9415 23, 10, // 16673: case 0x17: {
9416 OPC_CheckPredicate, 22, // 16675: check predicate 22
9417 OPC_CheckField, 25, 1, 1, // 16677: check Inst[25] == 0x1
9418 OPC_Decode, 241, 125, 114, // 16681: decode to VCOMPRESS_VM using decoder 114
9419 // 16681: }
9420 24, 11, // 16685: case 0x18: {
9421 OPC_CheckPredicate, 22, // 16687: check predicate 22
9422 OPC_CheckField, 25, 1, 1, // 16689: check Inst[25] == 0x1
9423 OPC_Decode, 181, 128, 1, 114, // 16693: decode to VMANDN_MM using decoder 114
9424 // 16693: }
9425 25, 11, // 16698: case 0x19: {
9426 OPC_CheckPredicate, 22, // 16700: check predicate 22
9427 OPC_CheckField, 25, 1, 1, // 16702: check Inst[25] == 0x1
9428 OPC_Decode, 182, 128, 1, 114, // 16706: decode to VMAND_MM using decoder 114
9429 // 16706: }
9430 26, 11, // 16711: case 0x1a: {
9431 OPC_CheckPredicate, 22, // 16713: check predicate 22
9432 OPC_CheckField, 25, 1, 1, // 16715: check Inst[25] == 0x1
9433 OPC_Decode, 208, 128, 1, 114, // 16719: decode to VMOR_MM using decoder 114
9434 // 16719: }
9435 27, 11, // 16724: case 0x1b: {
9436 OPC_CheckPredicate, 22, // 16726: check predicate 22
9437 OPC_CheckField, 25, 1, 1, // 16728: check Inst[25] == 0x1
9438 OPC_Decode, 130, 129, 1, 114, // 16732: decode to VMXOR_MM using decoder 114
9439 // 16732: }
9440 28, 11, // 16737: case 0x1c: {
9441 OPC_CheckPredicate, 22, // 16739: check predicate 22
9442 OPC_CheckField, 25, 1, 1, // 16741: check Inst[25] == 0x1
9443 OPC_Decode, 207, 128, 1, 114, // 16745: decode to VMORN_MM using decoder 114
9444 // 16745: }
9445 29, 11, // 16750: case 0x1d: {
9446 OPC_CheckPredicate, 22, // 16752: check predicate 22
9447 OPC_CheckField, 25, 1, 1, // 16754: check Inst[25] == 0x1
9448 OPC_Decode, 205, 128, 1, 114, // 16758: decode to VMNAND_MM using decoder 114
9449 // 16758: }
9450 30, 11, // 16763: case 0x1e: {
9451 OPC_CheckPredicate, 22, // 16765: check predicate 22
9452 OPC_CheckField, 25, 1, 1, // 16767: check Inst[25] == 0x1
9453 OPC_Decode, 206, 128, 1, 114, // 16771: decode to VMNOR_MM using decoder 114
9454 // 16771: }
9455 31, 11, // 16776: case 0x1f: {
9456 OPC_CheckPredicate, 22, // 16778: check predicate 22
9457 OPC_CheckField, 25, 1, 1, // 16780: check Inst[25] == 0x1
9458 OPC_Decode, 129, 129, 1, 114, // 16784: decode to VMXNOR_MM using decoder 114
9459 // 16784: }
9460 32, 6, // 16789: case 0x20: {
9461 OPC_CheckPredicate, 22, // 16791: check predicate 22
9462 OPC_Decode, 245, 125, 112, // 16793: decode to VDIVU_VV using decoder 112
9463 // 16793: }
9464 33, 6, // 16797: case 0x21: {
9465 OPC_CheckPredicate, 22, // 16799: check predicate 22
9466 OPC_Decode, 247, 125, 112, // 16801: decode to VDIV_VV using decoder 112
9467 // 16801: }
9468 34, 7, // 16805: case 0x22: {
9469 OPC_CheckPredicate, 22, // 16807: check predicate 22
9470 OPC_Decode, 165, 129, 1, 112, // 16809: decode to VREMU_VV using decoder 112
9471 // 16809: }
9472 35, 7, // 16814: case 0x23: {
9473 OPC_CheckPredicate, 22, // 16816: check predicate 22
9474 OPC_Decode, 167, 129, 1, 112, // 16818: decode to VREM_VV using decoder 112
9475 // 16818: }
9476 36, 7, // 16823: case 0x24: {
9477 OPC_CheckPredicate, 22, // 16825: check predicate 22
9478 OPC_Decode, 242, 128, 1, 112, // 16827: decode to VMULHU_VV using decoder 112
9479 // 16827: }
9480 37, 7, // 16832: case 0x25: {
9481 OPC_CheckPredicate, 22, // 16834: check predicate 22
9482 OPC_Decode, 246, 128, 1, 112, // 16836: decode to VMUL_VV using decoder 112
9483 // 16836: }
9484 38, 7, // 16841: case 0x26: {
9485 OPC_CheckPredicate, 22, // 16843: check predicate 22
9486 OPC_Decode, 240, 128, 1, 112, // 16845: decode to VMULHSU_VV using decoder 112
9487 // 16845: }
9488 39, 7, // 16850: case 0x27: {
9489 OPC_CheckPredicate, 22, // 16852: check predicate 22
9490 OPC_Decode, 244, 128, 1, 112, // 16854: decode to VMULH_VV using decoder 112
9491 // 16854: }
9492 40, 6, // 16859: case 0x28: {
9493 OPC_CheckPredicate, 105, // 16861: check predicate 105
9494 OPC_Decode, 252, 125, 124, // 16863: decode to VDOT4AU_VV using decoder 124
9495 // 16863: }
9496 41, 7, // 16867: case 0x29: {
9497 OPC_CheckPredicate, 22, // 16869: check predicate 22
9498 OPC_Decode, 179, 128, 1, 120, // 16871: decode to VMADD_VV using decoder 120
9499 // 16871: }
9500 42, 6, // 16876: case 0x2a: {
9501 OPC_CheckPredicate, 105, // 16878: check predicate 105
9502 OPC_Decode, 249, 125, 124, // 16880: decode to VDOT4ASU_VV using decoder 124
9503 // 16880: }
9504 43, 7, // 16884: case 0x2b: {
9505 OPC_CheckPredicate, 22, // 16886: check predicate 22
9506 OPC_Decode, 139, 129, 1, 120, // 16888: decode to VNMSUB_VV using decoder 120
9507 // 16888: }
9508 44, 6, // 16893: case 0x2c: {
9509 OPC_CheckPredicate, 105, // 16895: check predicate 105
9510 OPC_Decode, 254, 125, 124, // 16897: decode to VDOT4A_VV using decoder 124
9511 // 16897: }
9512 45, 7, // 16901: case 0x2d: {
9513 OPC_CheckPredicate, 22, // 16903: check predicate 22
9514 OPC_Decode, 171, 128, 1, 120, // 16905: decode to VMACC_VV using decoder 120
9515 // 16905: }
9516 47, 7, // 16910: case 0x2f: {
9517 OPC_CheckPredicate, 22, // 16912: check predicate 22
9518 OPC_Decode, 137, 129, 1, 120, // 16914: decode to VNMSAC_VV using decoder 120
9519 // 16914: }
9520 48, 7, // 16919: case 0x30: {
9521 OPC_CheckPredicate, 22, // 16921: check predicate 22
9522 OPC_Decode, 243, 130, 1, 112, // 16923: decode to VWADDU_VV using decoder 112
9523 // 16923: }
9524 49, 7, // 16928: case 0x31: {
9525 OPC_CheckPredicate, 22, // 16930: check predicate 22
9526 OPC_Decode, 247, 130, 1, 112, // 16932: decode to VWADD_VV using decoder 112
9527 // 16932: }
9528 50, 7, // 16937: case 0x32: {
9529 OPC_CheckPredicate, 22, // 16939: check predicate 22
9530 OPC_Decode, 142, 131, 1, 112, // 16941: decode to VWSUBU_VV using decoder 112
9531 // 16941: }
9532 51, 7, // 16946: case 0x33: {
9533 OPC_CheckPredicate, 22, // 16948: check predicate 22
9534 OPC_Decode, 146, 131, 1, 112, // 16950: decode to VWSUB_VV using decoder 112
9535 // 16950: }
9536 52, 7, // 16955: case 0x34: {
9537 OPC_CheckPredicate, 22, // 16957: check predicate 22
9538 OPC_Decode, 245, 130, 1, 112, // 16959: decode to VWADDU_WV using decoder 112
9539 // 16959: }
9540 53, 7, // 16964: case 0x35: {
9541 OPC_CheckPredicate, 22, // 16966: check predicate 22
9542 OPC_Decode, 249, 130, 1, 112, // 16968: decode to VWADD_WV using decoder 112
9543 // 16968: }
9544 54, 7, // 16973: case 0x36: {
9545 OPC_CheckPredicate, 22, // 16975: check predicate 22
9546 OPC_Decode, 144, 131, 1, 112, // 16977: decode to VWSUBU_WV using decoder 112
9547 // 16977: }
9548 55, 7, // 16982: case 0x37: {
9549 OPC_CheckPredicate, 22, // 16984: check predicate 22
9550 OPC_Decode, 148, 131, 1, 112, // 16986: decode to VWSUB_WV using decoder 112
9551 // 16986: }
9552 56, 7, // 16991: case 0x38: {
9553 OPC_CheckPredicate, 22, // 16993: check predicate 22
9554 OPC_Decode, 133, 131, 1, 112, // 16995: decode to VWMULU_VV using decoder 112
9555 // 16995: }
9556 58, 7, // 17000: case 0x3a: {
9557 OPC_CheckPredicate, 22, // 17002: check predicate 22
9558 OPC_Decode, 131, 131, 1, 112, // 17004: decode to VWMULSU_VV using decoder 112
9559 // 17004: }
9560 59, 7, // 17009: case 0x3b: {
9561 OPC_CheckPredicate, 22, // 17011: check predicate 22
9562 OPC_Decode, 135, 131, 1, 112, // 17013: decode to VWMUL_VV using decoder 112
9563 // 17013: }
9564 60, 7, // 17018: case 0x3c: {
9565 OPC_CheckPredicate, 22, // 17020: check predicate 22
9566 OPC_Decode, 254, 130, 1, 120, // 17022: decode to VWMACCU_VV using decoder 120
9567 // 17022: }
9568 61, 7, // 17027: case 0x3d: {
9569 OPC_CheckPredicate, 22, // 17029: check predicate 22
9570 OPC_Decode, 128, 131, 1, 120, // 17031: decode to VWMACC_VV using decoder 120
9571 // 17031: }
9572 62, 7, // 17036: case 0x3e: {
9573 OPC_CheckPredicate, 95, // 17038: check predicate 95
9574 OPC_Decode, 156, 131, 1, 112, // 17040: decode to VZIP_VV using decoder 112
9575 // 17040: }
9576 63, 0, // 17045: case 0x3f: {
9577 OPC_CheckPredicate, 22, // 17047: check predicate 22
9578 OPC_Decode, 251, 130, 1, 120, // 17049: decode to VWMACCSU_VV using decoder 120
9579 // 17049: }
9580 // 17049: } // switch Inst[31:26]
9581 // 17049: }
9582 3, 184, 3, // 17054: case 0x3: {
9583 OPC_SwitchField, 27, 5, // 17057: switch Inst[31:27] {
9584 0, 10, // 17060: case 0x0: {
9585 OPC_CheckPredicate, 22, // 17062: check predicate 22
9586 OPC_CheckField, 26, 1, 0, // 17064: check Inst[26] == 0x0
9587 OPC_Decode, 211, 125, 125, // 17068: decode to VADD_VI using decoder 125
9588 // 17068: }
9589 1, 11, // 17072: case 0x1: {
9590 OPC_CheckPredicate, 22, // 17074: check predicate 22
9591 OPC_CheckField, 26, 1, 1, // 17076: check Inst[26] == 0x1
9592 OPC_Decode, 179, 129, 1, 125, // 17080: decode to VRSUB_VI using decoder 125
9593 // 17080: }
9594 4, 10, // 17085: case 0x4: {
9595 OPC_CheckPredicate, 22, // 17087: check predicate 22
9596 OPC_CheckField, 26, 1, 1, // 17089: check Inst[26] == 0x1
9597 OPC_Decode, 227, 125, 125, // 17093: decode to VAND_VI using decoder 125
9598 // 17093: }
9599 5, 21, // 17097: case 0x5: {
9600 OPC_SwitchField, 26, 1, // 17099: switch Inst[26] {
9601 0, 7, // 17102: case 0x0: {
9602 OPC_CheckPredicate, 22, // 17104: check predicate 22
9603 OPC_Decode, 147, 129, 1, 125, // 17106: decode to VOR_VI using decoder 125
9604 // 17106: }
9605 1, 0, // 17111: case 0x1: {
9606 OPC_CheckPredicate, 22, // 17113: check predicate 22
9607 OPC_Decode, 150, 131, 1, 125, // 17115: decode to VXOR_VI using decoder 125
9608 // 17115: }
9609 // 17115: } // switch Inst[26]
9610 // 17115: }
9611 6, 11, // 17120: case 0x6: {
9612 OPC_CheckPredicate, 22, // 17122: check predicate 22
9613 OPC_CheckField, 26, 1, 0, // 17124: check Inst[26] == 0x0
9614 OPC_Decode, 171, 129, 1, 126, // 17128: decode to VRGATHER_VI using decoder 126
9615 // 17128: }
9616 7, 21, // 17133: case 0x7: {
9617 OPC_SwitchField, 26, 1, // 17135: switch Inst[26] {
9618 0, 7, // 17138: case 0x0: {
9619 OPC_CheckPredicate, 22, // 17140: check predicate 22
9620 OPC_Decode, 210, 129, 1, 126, // 17142: decode to VSLIDEUP_VI using decoder 126
9621 // 17142: }
9622 1, 0, // 17147: case 0x1: {
9623 OPC_CheckPredicate, 22, // 17149: check predicate 22
9624 OPC_Decode, 208, 129, 1, 126, // 17151: decode to VSLIDEDOWN_VI using decoder 126
9625 // 17151: }
9626 // 17151: } // switch Inst[26]
9627 // 17151: }
9628 8, 30, // 17156: case 0x8: {
9629 OPC_SwitchField, 25, 2, // 17158: switch Inst[26:25] {
9630 0, 6, // 17161: case 0x0: {
9631 OPC_CheckPredicate, 22, // 17163: check predicate 22
9632 OPC_Decode, 208, 125, 127, // 17165: decode to VADC_VIM using decoder 127
9633 // 17165: }
9634 2, 7, // 17169: case 0x2: {
9635 OPC_CheckPredicate, 22, // 17171: check predicate 22
9636 OPC_Decode, 174, 128, 1, 127, // 17173: decode to VMADC_VIM using decoder 127
9637 // 17173: }
9638 3, 0, // 17178: case 0x3: {
9639 OPC_CheckPredicate, 22, // 17180: check predicate 22
9640 OPC_Decode, 173, 128, 1, 128, 1, // 17182: decode to VMADC_VI using decoder 128
9641 // 17182: }
9642 // 17182: } // switch Inst[26:25]
9643 // 17182: }
9644 10, 8, // 17188: case 0xa: {
9645 OPC_CheckPredicate, 94, // 17190: check predicate 94
9646 OPC_Decode, 176, 129, 1, 129, 1, // 17192: decode to VROR_VI using decoder 129
9647 // 17192: }
9648 11, 26, // 17198: case 0xb: {
9649 OPC_SwitchField, 25, 2, // 17200: switch Inst[26:25] {
9650 2, 7, // 17203: case 0x2: {
9651 OPC_CheckPredicate, 22, // 17205: check predicate 22
9652 OPC_Decode, 187, 128, 1, 127, // 17207: decode to VMERGE_VIM using decoder 127
9653 // 17207: }
9654 3, 0, // 17212: case 0x3: {
9655 OPC_CheckPredicate, 22, // 17214: check predicate 22
9656 OPC_CheckField, 20, 5, 0, // 17216: check Inst[24:20] == 0x0
9657 OPC_Decode, 253, 128, 1, 130, 1, // 17220: decode to VMV_V_I using decoder 130
9658 // 17220: }
9659 // 17220: } // switch Inst[26:25]
9660 // 17220: }
9661 12, 21, // 17226: case 0xc: {
9662 OPC_SwitchField, 26, 1, // 17228: switch Inst[26] {
9663 0, 7, // 17231: case 0x0: {
9664 OPC_CheckPredicate, 22, // 17233: check predicate 22
9665 OPC_Decode, 214, 128, 1, 125, // 17235: decode to VMSEQ_VI using decoder 125
9666 // 17235: }
9667 1, 0, // 17240: case 0x1: {
9668 OPC_CheckPredicate, 22, // 17242: check predicate 22
9669 OPC_Decode, 232, 128, 1, 125, // 17244: decode to VMSNE_VI using decoder 125
9670 // 17244: }
9671 // 17244: } // switch Inst[26]
9672 // 17244: }
9673 14, 21, // 17249: case 0xe: {
9674 OPC_SwitchField, 26, 1, // 17251: switch Inst[26] {
9675 0, 7, // 17254: case 0x0: {
9676 OPC_CheckPredicate, 22, // 17256: check predicate 22
9677 OPC_Decode, 222, 128, 1, 125, // 17258: decode to VMSLEU_VI using decoder 125
9678 // 17258: }
9679 1, 0, // 17263: case 0x1: {
9680 OPC_CheckPredicate, 22, // 17265: check predicate 22
9681 OPC_Decode, 225, 128, 1, 125, // 17267: decode to VMSLE_VI using decoder 125
9682 // 17267: }
9683 // 17267: } // switch Inst[26]
9684 // 17267: }
9685 15, 21, // 17272: case 0xf: {
9686 OPC_SwitchField, 26, 1, // 17274: switch Inst[26] {
9687 0, 7, // 17277: case 0x0: {
9688 OPC_CheckPredicate, 22, // 17279: check predicate 22
9689 OPC_Decode, 217, 128, 1, 125, // 17281: decode to VMSGTU_VI using decoder 125
9690 // 17281: }
9691 1, 0, // 17286: case 0x1: {
9692 OPC_CheckPredicate, 22, // 17288: check predicate 22
9693 OPC_Decode, 219, 128, 1, 125, // 17290: decode to VMSGT_VI using decoder 125
9694 // 17290: }
9695 // 17290: } // switch Inst[26]
9696 // 17290: }
9697 16, 21, // 17295: case 0x10: {
9698 OPC_SwitchField, 26, 1, // 17297: switch Inst[26] {
9699 0, 7, // 17300: case 0x0: {
9700 OPC_CheckPredicate, 22, // 17302: check predicate 22
9701 OPC_Decode, 185, 129, 1, 125, // 17304: decode to VSADDU_VI using decoder 125
9702 // 17304: }
9703 1, 0, // 17309: case 0x1: {
9704 OPC_CheckPredicate, 22, // 17311: check predicate 22
9705 OPC_Decode, 188, 129, 1, 125, // 17313: decode to VSADD_VI using decoder 125
9706 // 17313: }
9707 // 17313: } // switch Inst[26]
9708 // 17313: }
9709 18, 11, // 17318: case 0x12: {
9710 OPC_CheckPredicate, 22, // 17320: check predicate 22
9711 OPC_CheckField, 26, 1, 1, // 17322: check Inst[26] == 0x1
9712 OPC_Decode, 212, 129, 1, 126, // 17326: decode to VSLL_VI using decoder 126
9713 // 17326: }
9714 19, 59, // 17331: case 0x13: {
9715 OPC_SwitchField, 15, 5, // 17333: switch Inst[19:15] {
9716 0, 12, // 17336: case 0x0: {
9717 OPC_CheckPredicate, 22, // 17338: check predicate 22
9718 OPC_CheckField, 25, 2, 3, // 17340: check Inst[26:25] == 0x3
9719 OPC_Decode, 248, 128, 1, 131, 1, // 17344: decode to VMV1R_V using decoder 131
9720 // 17344: }
9721 1, 12, // 17350: case 0x1: {
9722 OPC_CheckPredicate, 22, // 17352: check predicate 22
9723 OPC_CheckField, 25, 2, 3, // 17354: check Inst[26:25] == 0x3
9724 OPC_Decode, 249, 128, 1, 132, 1, // 17358: decode to VMV2R_V using decoder 132
9725 // 17358: }
9726 3, 12, // 17364: case 0x3: {
9727 OPC_CheckPredicate, 22, // 17366: check predicate 22
9728 OPC_CheckField, 25, 2, 3, // 17368: check Inst[26:25] == 0x3
9729 OPC_Decode, 250, 128, 1, 133, 1, // 17372: decode to VMV4R_V using decoder 133
9730 // 17372: }
9731 7, 0, // 17378: case 0x7: {
9732 OPC_CheckPredicate, 22, // 17380: check predicate 22
9733 OPC_CheckField, 25, 2, 3, // 17382: check Inst[26:25] == 0x3
9734 OPC_Decode, 251, 128, 1, 134, 1, // 17386: decode to VMV8R_V using decoder 134
9735 // 17386: }
9736 // 17386: } // switch Inst[19:15]
9737 // 17386: }
9738 20, 21, // 17392: case 0x14: {
9739 OPC_SwitchField, 26, 1, // 17394: switch Inst[26] {
9740 0, 7, // 17397: case 0x0: {
9741 OPC_CheckPredicate, 22, // 17399: check predicate 22
9742 OPC_Decode, 130, 130, 1, 126, // 17401: decode to VSRL_VI using decoder 126
9743 // 17401: }
9744 1, 0, // 17406: case 0x1: {
9745 OPC_CheckPredicate, 22, // 17408: check predicate 22
9746 OPC_Decode, 255, 129, 1, 126, // 17410: decode to VSRA_VI using decoder 126
9747 // 17410: }
9748 // 17410: } // switch Inst[26]
9749 // 17410: }
9750 21, 21, // 17415: case 0x15: {
9751 OPC_SwitchField, 26, 1, // 17417: switch Inst[26] {
9752 0, 7, // 17420: case 0x0: {
9753 OPC_CheckPredicate, 22, // 17422: check predicate 22
9754 OPC_Decode, 168, 130, 1, 126, // 17424: decode to VSSRL_VI using decoder 126
9755 // 17424: }
9756 1, 0, // 17429: case 0x1: {
9757 OPC_CheckPredicate, 22, // 17431: check predicate 22
9758 OPC_Decode, 165, 130, 1, 126, // 17433: decode to VSSRA_VI using decoder 126
9759 // 17433: }
9760 // 17433: } // switch Inst[26]
9761 // 17433: }
9762 22, 21, // 17438: case 0x16: {
9763 OPC_SwitchField, 26, 1, // 17440: switch Inst[26] {
9764 0, 7, // 17443: case 0x0: {
9765 OPC_CheckPredicate, 22, // 17445: check predicate 22
9766 OPC_Decode, 144, 129, 1, 126, // 17447: decode to VNSRL_WI using decoder 126
9767 // 17447: }
9768 1, 0, // 17452: case 0x1: {
9769 OPC_CheckPredicate, 22, // 17454: check predicate 22
9770 OPC_Decode, 141, 129, 1, 126, // 17456: decode to VNSRA_WI using decoder 126
9771 // 17456: }
9772 // 17456: } // switch Inst[26]
9773 // 17456: }
9774 23, 21, // 17461: case 0x17: {
9775 OPC_SwitchField, 26, 1, // 17463: switch Inst[26] {
9776 0, 7, // 17466: case 0x0: {
9777 OPC_CheckPredicate, 22, // 17468: check predicate 22
9778 OPC_Decode, 131, 129, 1, 126, // 17470: decode to VNCLIPU_WI using decoder 126
9779 // 17470: }
9780 1, 0, // 17475: case 0x1: {
9781 OPC_CheckPredicate, 22, // 17477: check predicate 22
9782 OPC_Decode, 134, 129, 1, 126, // 17479: decode to VNCLIP_WI using decoder 126
9783 // 17479: }
9784 // 17479: } // switch Inst[26]
9785 // 17479: }
9786 26, 0, // 17484: case 0x1a: {
9787 OPC_CheckPredicate, 96, // 17486: check predicate 96
9788 OPC_CheckField, 26, 1, 1, // 17488: check Inst[26] == 0x1
9789 OPC_Decode, 139, 131, 1, 126, // 17492: decode to VWSLL_VI using decoder 126
9790 // 17492: }
9791 // 17492: } // switch Inst[31:27]
9792 // 17492: }
9793 4, 239, 3, // 17497: case 0x4: {
9794 OPC_SwitchField, 26, 6, // 17500: switch Inst[31:26] {
9795 0, 7, // 17503: case 0x0: {
9796 OPC_CheckPredicate, 22, // 17505: check predicate 22
9797 OPC_Decode, 213, 125, 135, 1, // 17507: decode to VADD_VX using decoder 135
9798 // 17507: }
9799 1, 7, // 17512: case 0x1: {
9800 OPC_CheckPredicate, 94, // 17514: check predicate 94
9801 OPC_Decode, 226, 125, 135, 1, // 17516: decode to VANDN_VX using decoder 135
9802 // 17516: }
9803 2, 8, // 17521: case 0x2: {
9804 OPC_CheckPredicate, 22, // 17523: check predicate 22
9805 OPC_Decode, 204, 130, 1, 135, 1, // 17525: decode to VSUB_VX using decoder 135
9806 // 17525: }
9807 3, 8, // 17531: case 0x3: {
9808 OPC_CheckPredicate, 22, // 17533: check predicate 22
9809 OPC_Decode, 180, 129, 1, 135, 1, // 17535: decode to VRSUB_VX using decoder 135
9810 // 17535: }
9811 4, 8, // 17541: case 0x4: {
9812 OPC_CheckPredicate, 22, // 17543: check predicate 22
9813 OPC_Decode, 201, 128, 1, 135, 1, // 17545: decode to VMINU_VX using decoder 135
9814 // 17545: }
9815 5, 8, // 17551: case 0x5: {
9816 OPC_CheckPredicate, 22, // 17553: check predicate 22
9817 OPC_Decode, 203, 128, 1, 135, 1, // 17555: decode to VMIN_VX using decoder 135
9818 // 17555: }
9819 6, 8, // 17561: case 0x6: {
9820 OPC_CheckPredicate, 22, // 17563: check predicate 22
9821 OPC_Decode, 184, 128, 1, 135, 1, // 17565: decode to VMAXU_VX using decoder 135
9822 // 17565: }
9823 7, 8, // 17571: case 0x7: {
9824 OPC_CheckPredicate, 22, // 17573: check predicate 22
9825 OPC_Decode, 186, 128, 1, 135, 1, // 17575: decode to VMAX_VX using decoder 135
9826 // 17575: }
9827 9, 7, // 17581: case 0x9: {
9828 OPC_CheckPredicate, 22, // 17583: check predicate 22
9829 OPC_Decode, 229, 125, 135, 1, // 17585: decode to VAND_VX using decoder 135
9830 // 17585: }
9831 10, 8, // 17590: case 0xa: {
9832 OPC_CheckPredicate, 22, // 17592: check predicate 22
9833 OPC_Decode, 149, 129, 1, 135, 1, // 17594: decode to VOR_VX using decoder 135
9834 // 17594: }
9835 11, 8, // 17600: case 0xb: {
9836 OPC_CheckPredicate, 22, // 17602: check predicate 22
9837 OPC_Decode, 152, 131, 1, 135, 1, // 17604: decode to VXOR_VX using decoder 135
9838 // 17604: }
9839 12, 8, // 17610: case 0xc: {
9840 OPC_CheckPredicate, 22, // 17612: check predicate 22
9841 OPC_Decode, 173, 129, 1, 135, 1, // 17614: decode to VRGATHER_VX using decoder 135
9842 // 17614: }
9843 14, 8, // 17620: case 0xe: {
9844 OPC_CheckPredicate, 22, // 17622: check predicate 22
9845 OPC_Decode, 211, 129, 1, 135, 1, // 17624: decode to VSLIDEUP_VX using decoder 135
9846 // 17624: }
9847 15, 8, // 17630: case 0xf: {
9848 OPC_CheckPredicate, 22, // 17632: check predicate 22
9849 OPC_Decode, 209, 129, 1, 135, 1, // 17634: decode to VSLIDEDOWN_VX using decoder 135
9850 // 17634: }
9851 16, 11, // 17640: case 0x10: {
9852 OPC_CheckPredicate, 22, // 17642: check predicate 22
9853 OPC_CheckField, 25, 1, 0, // 17644: check Inst[25] == 0x0
9854 OPC_Decode, 210, 125, 136, 1, // 17648: decode to VADC_VXM using decoder 136
9855 // 17648: }
9856 17, 23, // 17653: case 0x11: {
9857 OPC_SwitchField, 25, 1, // 17655: switch Inst[25] {
9858 0, 8, // 17658: case 0x0: {
9859 OPC_CheckPredicate, 22, // 17660: check predicate 22
9860 OPC_Decode, 178, 128, 1, 136, 1, // 17662: decode to VMADC_VXM using decoder 136
9861 // 17662: }
9862 1, 0, // 17668: case 0x1: {
9863 OPC_CheckPredicate, 22, // 17670: check predicate 22
9864 OPC_Decode, 177, 128, 1, 137, 1, // 17672: decode to VMADC_VX using decoder 137
9865 // 17672: }
9866 // 17672: } // switch Inst[25]
9867 // 17672: }
9868 18, 12, // 17678: case 0x12: {
9869 OPC_CheckPredicate, 22, // 17680: check predicate 22
9870 OPC_CheckField, 25, 1, 0, // 17682: check Inst[25] == 0x0
9871 OPC_Decode, 192, 129, 1, 136, 1, // 17686: decode to VSBC_VXM using decoder 136
9872 // 17686: }
9873 19, 23, // 17692: case 0x13: {
9874 OPC_SwitchField, 25, 1, // 17694: switch Inst[25] {
9875 0, 8, // 17697: case 0x0: {
9876 OPC_CheckPredicate, 22, // 17699: check predicate 22
9877 OPC_Decode, 212, 128, 1, 136, 1, // 17701: decode to VMSBC_VXM using decoder 136
9878 // 17701: }
9879 1, 0, // 17707: case 0x1: {
9880 OPC_CheckPredicate, 22, // 17709: check predicate 22
9881 OPC_Decode, 211, 128, 1, 137, 1, // 17711: decode to VMSBC_VX using decoder 137
9882 // 17711: }
9883 // 17711: } // switch Inst[25]
9884 // 17711: }
9885 20, 8, // 17717: case 0x14: {
9886 OPC_CheckPredicate, 94, // 17719: check predicate 94
9887 OPC_Decode, 178, 129, 1, 135, 1, // 17721: decode to VROR_VX using decoder 135
9888 // 17721: }
9889 21, 8, // 17727: case 0x15: {
9890 OPC_CheckPredicate, 94, // 17729: check predicate 94
9891 OPC_Decode, 175, 129, 1, 135, 1, // 17731: decode to VROL_VX using decoder 135
9892 // 17731: }
9893 23, 26, // 17737: case 0x17: {
9894 OPC_SwitchField, 25, 1, // 17739: switch Inst[25] {
9895 0, 8, // 17742: case 0x0: {
9896 OPC_CheckPredicate, 22, // 17744: check predicate 22
9897 OPC_Decode, 189, 128, 1, 136, 1, // 17746: decode to VMERGE_VXM using decoder 136
9898 // 17746: }
9899 1, 0, // 17752: case 0x1: {
9900 OPC_CheckPredicate, 22, // 17754: check predicate 22
9901 OPC_CheckField, 20, 5, 0, // 17756: check Inst[24:20] == 0x0
9902 OPC_Decode, 255, 128, 1, 2, // 17760: decode to VMV_V_X using decoder 2
9903 // 17760: }
9904 // 17760: } // switch Inst[25]
9905 // 17760: }
9906 24, 8, // 17765: case 0x18: {
9907 OPC_CheckPredicate, 22, // 17767: check predicate 22
9908 OPC_Decode, 216, 128, 1, 135, 1, // 17769: decode to VMSEQ_VX using decoder 135
9909 // 17769: }
9910 25, 8, // 17775: case 0x19: {
9911 OPC_CheckPredicate, 22, // 17777: check predicate 22
9912 OPC_Decode, 234, 128, 1, 135, 1, // 17779: decode to VMSNE_VX using decoder 135
9913 // 17779: }
9914 26, 8, // 17785: case 0x1a: {
9915 OPC_CheckPredicate, 22, // 17787: check predicate 22
9916 OPC_Decode, 229, 128, 1, 135, 1, // 17789: decode to VMSLTU_VX using decoder 135
9917 // 17789: }
9918 27, 8, // 17795: case 0x1b: {
9919 OPC_CheckPredicate, 22, // 17797: check predicate 22
9920 OPC_Decode, 231, 128, 1, 135, 1, // 17799: decode to VMSLT_VX using decoder 135
9921 // 17799: }
9922 28, 8, // 17805: case 0x1c: {
9923 OPC_CheckPredicate, 22, // 17807: check predicate 22
9924 OPC_Decode, 224, 128, 1, 135, 1, // 17809: decode to VMSLEU_VX using decoder 135
9925 // 17809: }
9926 29, 8, // 17815: case 0x1d: {
9927 OPC_CheckPredicate, 22, // 17817: check predicate 22
9928 OPC_Decode, 227, 128, 1, 135, 1, // 17819: decode to VMSLE_VX using decoder 135
9929 // 17819: }
9930 30, 8, // 17825: case 0x1e: {
9931 OPC_CheckPredicate, 22, // 17827: check predicate 22
9932 OPC_Decode, 218, 128, 1, 135, 1, // 17829: decode to VMSGTU_VX using decoder 135
9933 // 17829: }
9934 31, 8, // 17835: case 0x1f: {
9935 OPC_CheckPredicate, 22, // 17837: check predicate 22
9936 OPC_Decode, 220, 128, 1, 135, 1, // 17839: decode to VMSGT_VX using decoder 135
9937 // 17839: }
9938 32, 8, // 17845: case 0x20: {
9939 OPC_CheckPredicate, 22, // 17847: check predicate 22
9940 OPC_Decode, 187, 129, 1, 135, 1, // 17849: decode to VSADDU_VX using decoder 135
9941 // 17849: }
9942 33, 8, // 17855: case 0x21: {
9943 OPC_CheckPredicate, 22, // 17857: check predicate 22
9944 OPC_Decode, 190, 129, 1, 135, 1, // 17859: decode to VSADD_VX using decoder 135
9945 // 17859: }
9946 34, 8, // 17865: case 0x22: {
9947 OPC_CheckPredicate, 22, // 17867: check predicate 22
9948 OPC_Decode, 200, 130, 1, 135, 1, // 17869: decode to VSSUBU_VX using decoder 135
9949 // 17869: }
9950 35, 8, // 17875: case 0x23: {
9951 OPC_CheckPredicate, 22, // 17877: check predicate 22
9952 OPC_Decode, 202, 130, 1, 135, 1, // 17879: decode to VSSUB_VX using decoder 135
9953 // 17879: }
9954 37, 8, // 17885: case 0x25: {
9955 OPC_CheckPredicate, 22, // 17887: check predicate 22
9956 OPC_Decode, 214, 129, 1, 135, 1, // 17889: decode to VSLL_VX using decoder 135
9957 // 17889: }
9958 39, 8, // 17895: case 0x27: {
9959 OPC_CheckPredicate, 22, // 17897: check predicate 22
9960 OPC_Decode, 221, 129, 1, 135, 1, // 17899: decode to VSMUL_VX using decoder 135
9961 // 17899: }
9962 40, 8, // 17905: case 0x28: {
9963 OPC_CheckPredicate, 22, // 17907: check predicate 22
9964 OPC_Decode, 132, 130, 1, 135, 1, // 17909: decode to VSRL_VX using decoder 135
9965 // 17909: }
9966 41, 8, // 17915: case 0x29: {
9967 OPC_CheckPredicate, 22, // 17917: check predicate 22
9968 OPC_Decode, 129, 130, 1, 135, 1, // 17919: decode to VSRA_VX using decoder 135
9969 // 17919: }
9970 42, 8, // 17925: case 0x2a: {
9971 OPC_CheckPredicate, 22, // 17927: check predicate 22
9972 OPC_Decode, 170, 130, 1, 135, 1, // 17929: decode to VSSRL_VX using decoder 135
9973 // 17929: }
9974 43, 8, // 17935: case 0x2b: {
9975 OPC_CheckPredicate, 22, // 17937: check predicate 22
9976 OPC_Decode, 167, 130, 1, 135, 1, // 17939: decode to VSSRA_VX using decoder 135
9977 // 17939: }
9978 44, 8, // 17945: case 0x2c: {
9979 OPC_CheckPredicate, 22, // 17947: check predicate 22
9980 OPC_Decode, 146, 129, 1, 135, 1, // 17949: decode to VNSRL_WX using decoder 135
9981 // 17949: }
9982 45, 8, // 17955: case 0x2d: {
9983 OPC_CheckPredicate, 22, // 17957: check predicate 22
9984 OPC_Decode, 143, 129, 1, 135, 1, // 17959: decode to VNSRA_WX using decoder 135
9985 // 17959: }
9986 46, 8, // 17965: case 0x2e: {
9987 OPC_CheckPredicate, 22, // 17967: check predicate 22
9988 OPC_Decode, 133, 129, 1, 135, 1, // 17969: decode to VNCLIPU_WX using decoder 135
9989 // 17969: }
9990 47, 8, // 17975: case 0x2f: {
9991 OPC_CheckPredicate, 22, // 17977: check predicate 22
9992 OPC_Decode, 136, 129, 1, 135, 1, // 17979: decode to VNCLIP_WX using decoder 135
9993 // 17979: }
9994 53, 0, // 17985: case 0x35: {
9995 OPC_CheckPredicate, 96, // 17987: check predicate 96
9996 OPC_Decode, 141, 131, 1, 135, 1, // 17989: decode to VWSLL_VX using decoder 135
9997 // 17989: }
9998 // 17989: } // switch Inst[31:26]
9999 // 17989: }
10000 5, 254, 2, // 17995: case 0x5: {
10001 OPC_SwitchField, 26, 6, // 17998: switch Inst[31:26] {
10002 0, 7, // 18001: case 0x0: {
10003 OPC_CheckPredicate, 99, // 18003: check predicate 99
10004 OPC_Decode, 131, 126, 138, 1, // 18005: decode to VFADD_VF using decoder 138
10005 // 18005: }
10006 2, 7, // 18010: case 0x2: {
10007 OPC_CheckPredicate, 99, // 18012: check predicate 99
10008 OPC_Decode, 207, 126, 138, 1, // 18014: decode to VFSUB_VF using decoder 138
10009 // 18014: }
10010 4, 7, // 18019: case 0x4: {
10011 OPC_CheckPredicate, 99, // 18021: check predicate 99
10012 OPC_Decode, 151, 126, 138, 1, // 18023: decode to VFMIN_VF using decoder 138
10013 // 18023: }
10014 6, 7, // 18028: case 0x6: {
10015 OPC_CheckPredicate, 99, // 18030: check predicate 99
10016 OPC_Decode, 148, 126, 138, 1, // 18032: decode to VFMAX_VF using decoder 138
10017 // 18032: }
10018 8, 7, // 18037: case 0x8: {
10019 OPC_CheckPredicate, 99, // 18039: check predicate 99
10020 OPC_Decode, 202, 126, 138, 1, // 18041: decode to VFSGNJ_VF using decoder 138
10021 // 18041: }
10022 9, 7, // 18046: case 0x9: {
10023 OPC_CheckPredicate, 99, // 18048: check predicate 99
10024 OPC_Decode, 198, 126, 138, 1, // 18050: decode to VFSGNJN_VF using decoder 138
10025 // 18050: }
10026 10, 7, // 18055: case 0xa: {
10027 OPC_CheckPredicate, 99, // 18057: check predicate 99
10028 OPC_Decode, 200, 126, 138, 1, // 18059: decode to VFSGNJX_VF using decoder 138
10029 // 18059: }
10030 14, 7, // 18064: case 0xe: {
10031 OPC_CheckPredicate, 99, // 18066: check predicate 99
10032 OPC_Decode, 205, 126, 138, 1, // 18068: decode to VFSLIDE1UP_VF using decoder 138
10033 // 18068: }
10034 15, 7, // 18073: case 0xf: {
10035 OPC_CheckPredicate, 99, // 18075: check predicate 99
10036 OPC_Decode, 204, 126, 138, 1, // 18077: decode to VFSLIDE1DOWN_VF using decoder 138
10037 // 18077: }
10038 16, 11, // 18082: case 0x10: {
10039 OPC_CheckPredicate, 99, // 18084: check predicate 99
10040 OPC_CheckField, 20, 6, 32, // 18086: check Inst[25:20] == 0x20
10041 OPC_Decode, 161, 126, 139, 1, // 18090: decode to VFMV_S_F using decoder 139
10042 // 18090: }
10043 23, 25, // 18095: case 0x17: {
10044 OPC_SwitchField, 25, 1, // 18097: switch Inst[25] {
10045 0, 7, // 18100: case 0x0: {
10046 OPC_CheckPredicate, 99, // 18102: check predicate 99
10047 OPC_Decode, 150, 126, 140, 1, // 18104: decode to VFMERGE_VFM using decoder 140
10048 // 18104: }
10049 1, 0, // 18109: case 0x1: {
10050 OPC_CheckPredicate, 99, // 18111: check predicate 99
10051 OPC_CheckField, 20, 5, 0, // 18113: check Inst[24:20] == 0x0
10052 OPC_Decode, 162, 126, 141, 1, // 18117: decode to VFMV_V_F using decoder 141
10053 // 18117: }
10054 // 18117: } // switch Inst[25]
10055 // 18117: }
10056 24, 8, // 18122: case 0x18: {
10057 OPC_CheckPredicate, 99, // 18124: check predicate 99
10058 OPC_Decode, 190, 128, 1, 138, 1, // 18126: decode to VMFEQ_VF using decoder 138
10059 // 18126: }
10060 25, 8, // 18132: case 0x19: {
10061 OPC_CheckPredicate, 99, // 18134: check predicate 99
10062 OPC_Decode, 194, 128, 1, 138, 1, // 18136: decode to VMFLE_VF using decoder 138
10063 // 18136: }
10064 27, 8, // 18142: case 0x1b: {
10065 OPC_CheckPredicate, 99, // 18144: check predicate 99
10066 OPC_Decode, 196, 128, 1, 138, 1, // 18146: decode to VMFLT_VF using decoder 138
10067 // 18146: }
10068 28, 8, // 18152: case 0x1c: {
10069 OPC_CheckPredicate, 99, // 18154: check predicate 99
10070 OPC_Decode, 198, 128, 1, 138, 1, // 18156: decode to VMFNE_VF using decoder 138
10071 // 18156: }
10072 29, 8, // 18162: case 0x1d: {
10073 OPC_CheckPredicate, 99, // 18164: check predicate 99
10074 OPC_Decode, 193, 128, 1, 138, 1, // 18166: decode to VMFGT_VF using decoder 138
10075 // 18166: }
10076 31, 8, // 18172: case 0x1f: {
10077 OPC_CheckPredicate, 99, // 18174: check predicate 99
10078 OPC_Decode, 192, 128, 1, 138, 1, // 18176: decode to VMFGE_VF using decoder 138
10079 // 18176: }
10080 32, 7, // 18182: case 0x20: {
10081 OPC_CheckPredicate, 99, // 18184: check predicate 99
10082 OPC_Decode, 141, 126, 138, 1, // 18186: decode to VFDIV_VF using decoder 138
10083 // 18186: }
10084 33, 7, // 18191: case 0x21: {
10085 OPC_CheckPredicate, 99, // 18193: check predicate 99
10086 OPC_Decode, 190, 126, 138, 1, // 18195: decode to VFRDIV_VF using decoder 138
10087 // 18195: }
10088 36, 7, // 18200: case 0x24: {
10089 OPC_CheckPredicate, 99, // 18202: check predicate 99
10090 OPC_Decode, 158, 126, 138, 1, // 18204: decode to VFMUL_VF using decoder 138
10091 // 18204: }
10092 39, 7, // 18209: case 0x27: {
10093 OPC_CheckPredicate, 99, // 18211: check predicate 99
10094 OPC_Decode, 197, 126, 138, 1, // 18213: decode to VFRSUB_VF using decoder 138
10095 // 18213: }
10096 40, 7, // 18218: case 0x28: {
10097 OPC_CheckPredicate, 99, // 18220: check predicate 99
10098 OPC_Decode, 146, 126, 142, 1, // 18222: decode to VFMADD_VF using decoder 142
10099 // 18222: }
10100 41, 7, // 18227: case 0x29: {
10101 OPC_CheckPredicate, 99, // 18229: check predicate 99
10102 OPC_Decode, 177, 126, 142, 1, // 18231: decode to VFNMADD_VF using decoder 142
10103 // 18231: }
10104 42, 7, // 18236: case 0x2a: {
10105 OPC_CheckPredicate, 99, // 18238: check predicate 99
10106 OPC_Decode, 156, 126, 142, 1, // 18240: decode to VFMSUB_VF using decoder 142
10107 // 18240: }
10108 43, 7, // 18245: case 0x2b: {
10109 OPC_CheckPredicate, 99, // 18247: check predicate 99
10110 OPC_Decode, 181, 126, 142, 1, // 18249: decode to VFNMSUB_VF using decoder 142
10111 // 18249: }
10112 44, 7, // 18254: case 0x2c: {
10113 OPC_CheckPredicate, 99, // 18256: check predicate 99
10114 OPC_Decode, 144, 126, 142, 1, // 18258: decode to VFMACC_VF using decoder 142
10115 // 18258: }
10116 45, 7, // 18263: case 0x2d: {
10117 OPC_CheckPredicate, 99, // 18265: check predicate 99
10118 OPC_Decode, 175, 126, 142, 1, // 18267: decode to VFNMACC_VF using decoder 142
10119 // 18267: }
10120 46, 7, // 18272: case 0x2e: {
10121 OPC_CheckPredicate, 99, // 18274: check predicate 99
10122 OPC_Decode, 154, 126, 142, 1, // 18276: decode to VFMSAC_VF using decoder 142
10123 // 18276: }
10124 47, 7, // 18281: case 0x2f: {
10125 OPC_CheckPredicate, 99, // 18283: check predicate 99
10126 OPC_Decode, 179, 126, 142, 1, // 18285: decode to VFNMSAC_VF using decoder 142
10127 // 18285: }
10128 48, 7, // 18290: case 0x30: {
10129 OPC_CheckPredicate, 99, // 18292: check predicate 99
10130 OPC_Decode, 209, 126, 138, 1, // 18294: decode to VFWADD_VF using decoder 138
10131 // 18294: }
10132 50, 7, // 18299: case 0x32: {
10133 OPC_CheckPredicate, 99, // 18301: check predicate 99
10134 OPC_Decode, 240, 126, 138, 1, // 18303: decode to VFWSUB_VF using decoder 138
10135 // 18303: }
10136 52, 7, // 18308: case 0x34: {
10137 OPC_CheckPredicate, 99, // 18310: check predicate 99
10138 OPC_Decode, 211, 126, 138, 1, // 18312: decode to VFWADD_WF using decoder 138
10139 // 18312: }
10140 54, 7, // 18317: case 0x36: {
10141 OPC_CheckPredicate, 99, // 18319: check predicate 99
10142 OPC_Decode, 242, 126, 138, 1, // 18321: decode to VFWSUB_WF using decoder 138
10143 // 18321: }
10144 56, 7, // 18326: case 0x38: {
10145 OPC_CheckPredicate, 99, // 18328: check predicate 99
10146 OPC_Decode, 232, 126, 138, 1, // 18330: decode to VFWMUL_VF using decoder 138
10147 // 18330: }
10148 59, 7, // 18335: case 0x3b: {
10149 OPC_CheckPredicate, 102, // 18337: check predicate 102
10150 OPC_Decode, 224, 126, 142, 1, // 18339: decode to VFWMACCBF16_VF using decoder 142
10151 // 18339: }
10152 60, 7, // 18344: case 0x3c: {
10153 OPC_CheckPredicate, 99, // 18346: check predicate 99
10154 OPC_Decode, 226, 126, 142, 1, // 18348: decode to VFWMACC_VF using decoder 142
10155 // 18348: }
10156 61, 7, // 18353: case 0x3d: {
10157 OPC_CheckPredicate, 99, // 18355: check predicate 99
10158 OPC_Decode, 234, 126, 142, 1, // 18357: decode to VFWNMACC_VF using decoder 142
10159 // 18357: }
10160 62, 7, // 18362: case 0x3e: {
10161 OPC_CheckPredicate, 99, // 18364: check predicate 99
10162 OPC_Decode, 230, 126, 142, 1, // 18366: decode to VFWMSAC_VF using decoder 142
10163 // 18366: }
10164 63, 0, // 18371: case 0x3f: {
10165 OPC_CheckPredicate, 99, // 18373: check predicate 99
10166 OPC_Decode, 236, 126, 142, 1, // 18375: decode to VFWNMSAC_VF using decoder 142
10167 // 18375: }
10168 // 18375: } // switch Inst[31:26]
10169 // 18375: }
10170 6, 139, 3, // 18380: case 0x6: {
10171 OPC_SwitchField, 26, 6, // 18383: switch Inst[31:26] {
10172 8, 7, // 18386: case 0x8: {
10173 OPC_CheckPredicate, 22, // 18388: check predicate 22
10174 OPC_Decode, 202, 125, 135, 1, // 18390: decode to VAADDU_VX using decoder 135
10175 // 18390: }
10176 9, 7, // 18395: case 0x9: {
10177 OPC_CheckPredicate, 22, // 18397: check predicate 22
10178 OPC_Decode, 204, 125, 135, 1, // 18399: decode to VAADD_VX using decoder 135
10179 // 18399: }
10180 10, 7, // 18404: case 0xa: {
10181 OPC_CheckPredicate, 22, // 18406: check predicate 22
10182 OPC_Decode, 231, 125, 135, 1, // 18408: decode to VASUBU_VX using decoder 135
10183 // 18408: }
10184 11, 7, // 18413: case 0xb: {
10185 OPC_CheckPredicate, 22, // 18415: check predicate 22
10186 OPC_Decode, 233, 125, 135, 1, // 18417: decode to VASUB_VX using decoder 135
10187 // 18417: }
10188 12, 7, // 18422: case 0xc: {
10189 OPC_CheckPredicate, 103, // 18424: check predicate 103
10190 OPC_Decode, 239, 125, 135, 1, // 18426: decode to VCLMUL_VX using decoder 135
10191 // 18426: }
10192 13, 7, // 18431: case 0xd: {
10193 OPC_CheckPredicate, 103, // 18433: check predicate 103
10194 OPC_Decode, 237, 125, 135, 1, // 18435: decode to VCLMULH_VX using decoder 135
10195 // 18435: }
10196 14, 8, // 18440: case 0xe: {
10197 OPC_CheckPredicate, 22, // 18442: check predicate 22
10198 OPC_Decode, 207, 129, 1, 135, 1, // 18444: decode to VSLIDE1UP_VX using decoder 135
10199 // 18444: }
10200 15, 8, // 18450: case 0xf: {
10201 OPC_CheckPredicate, 22, // 18452: check predicate 22
10202 OPC_Decode, 206, 129, 1, 135, 1, // 18454: decode to VSLIDE1DOWN_VX using decoder 135
10203 // 18454: }
10204 16, 12, // 18460: case 0x10: {
10205 OPC_CheckPredicate, 22, // 18462: check predicate 22
10206 OPC_CheckField, 20, 6, 32, // 18464: check Inst[25:20] == 0x20
10207 OPC_Decode, 252, 128, 1, 143, 1, // 18468: decode to VMV_S_X using decoder 143
10208 // 18468: }
10209 32, 7, // 18474: case 0x20: {
10210 OPC_CheckPredicate, 22, // 18476: check predicate 22
10211 OPC_Decode, 246, 125, 135, 1, // 18478: decode to VDIVU_VX using decoder 135
10212 // 18478: }
10213 33, 7, // 18483: case 0x21: {
10214 OPC_CheckPredicate, 22, // 18485: check predicate 22
10215 OPC_Decode, 248, 125, 135, 1, // 18487: decode to VDIV_VX using decoder 135
10216 // 18487: }
10217 34, 8, // 18492: case 0x22: {
10218 OPC_CheckPredicate, 22, // 18494: check predicate 22
10219 OPC_Decode, 166, 129, 1, 135, 1, // 18496: decode to VREMU_VX using decoder 135
10220 // 18496: }
10221 35, 8, // 18502: case 0x23: {
10222 OPC_CheckPredicate, 22, // 18504: check predicate 22
10223 OPC_Decode, 168, 129, 1, 135, 1, // 18506: decode to VREM_VX using decoder 135
10224 // 18506: }
10225 36, 8, // 18512: case 0x24: {
10226 OPC_CheckPredicate, 22, // 18514: check predicate 22
10227 OPC_Decode, 243, 128, 1, 135, 1, // 18516: decode to VMULHU_VX using decoder 135
10228 // 18516: }
10229 37, 8, // 18522: case 0x25: {
10230 OPC_CheckPredicate, 22, // 18524: check predicate 22
10231 OPC_Decode, 247, 128, 1, 135, 1, // 18526: decode to VMUL_VX using decoder 135
10232 // 18526: }
10233 38, 8, // 18532: case 0x26: {
10234 OPC_CheckPredicate, 22, // 18534: check predicate 22
10235 OPC_Decode, 241, 128, 1, 135, 1, // 18536: decode to VMULHSU_VX using decoder 135
10236 // 18536: }
10237 39, 8, // 18542: case 0x27: {
10238 OPC_CheckPredicate, 22, // 18544: check predicate 22
10239 OPC_Decode, 245, 128, 1, 135, 1, // 18546: decode to VMULH_VX using decoder 135
10240 // 18546: }
10241 40, 7, // 18552: case 0x28: {
10242 OPC_CheckPredicate, 105, // 18554: check predicate 105
10243 OPC_Decode, 253, 125, 144, 1, // 18556: decode to VDOT4AU_VX using decoder 144
10244 // 18556: }
10245 41, 8, // 18561: case 0x29: {
10246 OPC_CheckPredicate, 22, // 18563: check predicate 22
10247 OPC_Decode, 180, 128, 1, 145, 1, // 18565: decode to VMADD_VX using decoder 145
10248 // 18565: }
10249 42, 7, // 18571: case 0x2a: {
10250 OPC_CheckPredicate, 105, // 18573: check predicate 105
10251 OPC_Decode, 250, 125, 144, 1, // 18575: decode to VDOT4ASU_VX using decoder 144
10252 // 18575: }
10253 43, 8, // 18580: case 0x2b: {
10254 OPC_CheckPredicate, 22, // 18582: check predicate 22
10255 OPC_Decode, 140, 129, 1, 145, 1, // 18584: decode to VNMSUB_VX using decoder 145
10256 // 18584: }
10257 44, 7, // 18590: case 0x2c: {
10258 OPC_CheckPredicate, 105, // 18592: check predicate 105
10259 OPC_Decode, 255, 125, 144, 1, // 18594: decode to VDOT4A_VX using decoder 144
10260 // 18594: }
10261 45, 8, // 18599: case 0x2d: {
10262 OPC_CheckPredicate, 22, // 18601: check predicate 22
10263 OPC_Decode, 172, 128, 1, 145, 1, // 18603: decode to VMACC_VX using decoder 145
10264 // 18603: }
10265 46, 7, // 18609: case 0x2e: {
10266 OPC_CheckPredicate, 105, // 18611: check predicate 105
10267 OPC_Decode, 251, 125, 144, 1, // 18613: decode to VDOT4AUS_VX using decoder 144
10268 // 18613: }
10269 47, 8, // 18618: case 0x2f: {
10270 OPC_CheckPredicate, 22, // 18620: check predicate 22
10271 OPC_Decode, 138, 129, 1, 145, 1, // 18622: decode to VNMSAC_VX using decoder 145
10272 // 18622: }
10273 48, 8, // 18628: case 0x30: {
10274 OPC_CheckPredicate, 22, // 18630: check predicate 22
10275 OPC_Decode, 244, 130, 1, 135, 1, // 18632: decode to VWADDU_VX using decoder 135
10276 // 18632: }
10277 49, 8, // 18638: case 0x31: {
10278 OPC_CheckPredicate, 22, // 18640: check predicate 22
10279 OPC_Decode, 248, 130, 1, 135, 1, // 18642: decode to VWADD_VX using decoder 135
10280 // 18642: }
10281 50, 8, // 18648: case 0x32: {
10282 OPC_CheckPredicate, 22, // 18650: check predicate 22
10283 OPC_Decode, 143, 131, 1, 135, 1, // 18652: decode to VWSUBU_VX using decoder 135
10284 // 18652: }
10285 51, 8, // 18658: case 0x33: {
10286 OPC_CheckPredicate, 22, // 18660: check predicate 22
10287 OPC_Decode, 147, 131, 1, 135, 1, // 18662: decode to VWSUB_VX using decoder 135
10288 // 18662: }
10289 52, 8, // 18668: case 0x34: {
10290 OPC_CheckPredicate, 22, // 18670: check predicate 22
10291 OPC_Decode, 246, 130, 1, 135, 1, // 18672: decode to VWADDU_WX using decoder 135
10292 // 18672: }
10293 53, 8, // 18678: case 0x35: {
10294 OPC_CheckPredicate, 22, // 18680: check predicate 22
10295 OPC_Decode, 250, 130, 1, 135, 1, // 18682: decode to VWADD_WX using decoder 135
10296 // 18682: }
10297 54, 8, // 18688: case 0x36: {
10298 OPC_CheckPredicate, 22, // 18690: check predicate 22
10299 OPC_Decode, 145, 131, 1, 135, 1, // 18692: decode to VWSUBU_WX using decoder 135
10300 // 18692: }
10301 55, 8, // 18698: case 0x37: {
10302 OPC_CheckPredicate, 22, // 18700: check predicate 22
10303 OPC_Decode, 149, 131, 1, 135, 1, // 18702: decode to VWSUB_WX using decoder 135
10304 // 18702: }
10305 56, 8, // 18708: case 0x38: {
10306 OPC_CheckPredicate, 22, // 18710: check predicate 22
10307 OPC_Decode, 134, 131, 1, 135, 1, // 18712: decode to VWMULU_VX using decoder 135
10308 // 18712: }
10309 58, 8, // 18718: case 0x3a: {
10310 OPC_CheckPredicate, 22, // 18720: check predicate 22
10311 OPC_Decode, 132, 131, 1, 135, 1, // 18722: decode to VWMULSU_VX using decoder 135
10312 // 18722: }
10313 59, 8, // 18728: case 0x3b: {
10314 OPC_CheckPredicate, 22, // 18730: check predicate 22
10315 OPC_Decode, 136, 131, 1, 135, 1, // 18732: decode to VWMUL_VX using decoder 135
10316 // 18732: }
10317 60, 8, // 18738: case 0x3c: {
10318 OPC_CheckPredicate, 22, // 18740: check predicate 22
10319 OPC_Decode, 255, 130, 1, 145, 1, // 18742: decode to VWMACCU_VX using decoder 145
10320 // 18742: }
10321 61, 8, // 18748: case 0x3d: {
10322 OPC_CheckPredicate, 22, // 18750: check predicate 22
10323 OPC_Decode, 129, 131, 1, 145, 1, // 18752: decode to VWMACC_VX using decoder 145
10324 // 18752: }
10325 62, 8, // 18758: case 0x3e: {
10326 OPC_CheckPredicate, 22, // 18760: check predicate 22
10327 OPC_Decode, 253, 130, 1, 145, 1, // 18762: decode to VWMACCUS_VX using decoder 145
10328 // 18762: }
10329 63, 0, // 18768: case 0x3f: {
10330 OPC_CheckPredicate, 22, // 18770: check predicate 22
10331 OPC_Decode, 252, 130, 1, 145, 1, // 18772: decode to VWMACCSU_VX using decoder 145
10332 // 18772: }
10333 // 18772: } // switch Inst[31:26]
10334 // 18772: }
10335 7, 0, // 18778: case 0x7: {
10336 OPC_SwitchField, 31, 1, // 18780: switch Inst[31] {
10337 0, 8, // 18783: case 0x0: {
10338 OPC_CheckPredicate, 22, // 18785: check predicate 22
10339 OPC_Decode, 199, 129, 1, 146, 1, // 18787: decode to VSETVLI using decoder 146
10340 // 18787: }
10341 1, 0, // 18793: case 0x1: {
10342 OPC_SwitchField, 30, 1, // 18795: switch Inst[30] {
10343 0, 11, // 18798: case 0x0: {
10344 OPC_CheckPredicate, 22, // 18800: check predicate 22
10345 OPC_CheckField, 25, 5, 0, // 18802: check Inst[29:25] == 0x0
10346 OPC_Decode, 198, 129, 1, 31, // 18806: decode to VSETVL using decoder 31
10347 // 18806: }
10348 1, 0, // 18811: case 0x1: {
10349 OPC_CheckPredicate, 22, // 18813: check predicate 22
10350 OPC_Decode, 197, 129, 1, 147, 1, // 18815: decode to VSETIVLI using decoder 147
10351 // 18815: }
10352 // 18815: } // switch Inst[30]
10353 // 18815: }
10354 // 18815: } // switch Inst[31]
10355 // 18815: }
10356 // 18815: } // switch Inst[14:12]
10357 // 18815: }
10358 99, 63, // 18821: case 0x63: {
10359 OPC_SwitchField, 12, 3, // 18823: switch Inst[14:12] {
10360 0, 5, // 18826: case 0x0: {
10361 OPC_Decode, 181, 110, 148, 1, // 18828: decode to BEQ using decoder 148
10362 // 18828: }
10363 1, 5, // 18833: case 0x1: {
10364 OPC_Decode, 191, 110, 148, 1, // 18835: decode to BNE using decoder 148
10365 // 18835: }
10366 2, 7, // 18840: case 0x2: {
10367 OPC_CheckPredicate, 106, // 18842: check predicate 106
10368 OPC_Decode, 182, 110, 149, 1, // 18844: decode to BEQI using decoder 149
10369 // 18844: }
10370 3, 7, // 18849: case 0x3: {
10371 OPC_CheckPredicate, 106, // 18851: check predicate 106
10372 OPC_Decode, 192, 110, 149, 1, // 18853: decode to BNEI using decoder 149
10373 // 18853: }
10374 4, 5, // 18858: case 0x4: {
10375 OPC_Decode, 189, 110, 148, 1, // 18860: decode to BLT using decoder 148
10376 // 18860: }
10377 5, 5, // 18865: case 0x5: {
10378 OPC_Decode, 185, 110, 148, 1, // 18867: decode to BGE using decoder 148
10379 // 18867: }
10380 6, 5, // 18872: case 0x6: {
10381 OPC_Decode, 190, 110, 148, 1, // 18874: decode to BLTU using decoder 148
10382 // 18874: }
10383 7, 0, // 18879: case 0x7: {
10384 OPC_Decode, 186, 110, 148, 1, // 18881: decode to BGEU using decoder 148
10385 // 18881: }
10386 // 18881: } // switch Inst[14:12]
10387 // 18881: }
10388 103, 8, // 18886: case 0x67: {
10389 OPC_CheckField, 12, 3, 0, // 18888: check Inst[14:12] == 0x0
10390 OPC_Decode, 174, 116, 0, // 18892: decode to JALR using decoder 0
10391 // 18892: }
10392 111, 5, // 18896: case 0x6f: {
10393 OPC_Decode, 173, 116, 150, 1, // 18898: decode to JAL using decoder 150
10394 // 18898: }
10395 115, 218, 6, // 18903: case 0x73: {
10396 OPC_SwitchField, 12, 3, // 18906: switch Inst[14:12] {
10397 0, 246, 1, // 18909: case 0x0: {
10398 OPC_SwitchField, 25, 7, // 18912: switch Inst[31:25] {
10399 0, 51, // 18915: case 0x0: {
10400 OPC_SwitchField, 15, 10, // 18917: switch Inst[24:15] {
10401 0, 8, // 18920: case 0x0: {
10402 OPC_CheckField, 7, 5, 0, // 18922: check Inst[11:7] == 0x0
10403 OPC_Decode, 235, 113, 14, // 18926: decode to ECALL using decoder 14
10404 // 18926: }
10405 32, 8, // 18930: case 0x20: {
10406 OPC_CheckField, 7, 5, 0, // 18932: check Inst[11:7] == 0x0
10407 OPC_Decode, 234, 113, 14, // 18936: decode to EBREAK using decoder 14
10408 // 18936: }
10409 160, 3, 11, // 18940: case 0x1a0: {
10410 OPC_CheckPredicate, 107, // 18943: check predicate 107
10411 OPC_CheckField, 7, 5, 0, // 18945: check Inst[11:7] == 0x0
10412 OPC_Decode, 168, 131, 1, 14, // 18949: decode to WRS_NTO using decoder 14
10413 // 18949: }
10414 160, 7, 0, // 18954: case 0x3a0: {
10415 OPC_CheckPredicate, 107, // 18957: check predicate 107
10416 OPC_CheckField, 7, 5, 0, // 18959: check Inst[11:7] == 0x0
10417 OPC_Decode, 169, 131, 1, 14, // 18963: decode to WRS_STO using decoder 14
10418 // 18963: }
10419 // 18963: } // switch Inst[24:15]
10420 // 18963: }
10421 8, 38, // 18968: case 0x8: {
10422 OPC_SwitchField, 15, 10, // 18970: switch Inst[24:15] {
10423 64, 8, // 18973: case 0x40: {
10424 OPC_CheckField, 7, 5, 0, // 18975: check Inst[11:7] == 0x0
10425 OPC_Decode, 178, 124, 14, // 18979: decode to SRET using decoder 14
10426 // 18979: }
10427 128, 1, 10, // 18983: case 0x80: {
10428 OPC_CheckPredicate, 108, // 18986: check predicate 108
10429 OPC_CheckField, 7, 5, 0, // 18988: check Inst[11:7] == 0x0
10430 OPC_Decode, 155, 123, 14, // 18992: decode to SCTRCLR using decoder 14
10431 // 18992: }
10432 160, 1, 0, // 18996: case 0xa0: {
10433 OPC_CheckField, 7, 5, 0, // 18999: check Inst[11:7] == 0x0
10434 OPC_Decode, 161, 131, 1, 14, // 19003: decode to WFI using decoder 14
10435 // 19003: }
10436 // 19003: } // switch Inst[24:15]
10437 // 19003: }
10438 9, 9, // 19008: case 0x9: {
10439 OPC_CheckField, 7, 5, 0, // 19010: check Inst[11:7] == 0x0
10440 OPC_Decode, 171, 123, 151, 1, // 19014: decode to SFENCE_VMA using decoder 151
10441 // 19014: }
10442 11, 11, // 19019: case 0xb: {
10443 OPC_CheckPredicate, 109, // 19021: check predicate 109
10444 OPC_CheckField, 7, 5, 0, // 19023: check Inst[11:7] == 0x0
10445 OPC_Decode, 141, 124, 151, 1, // 19027: decode to SINVAL_VMA using decoder 151
10446 // 19027: }
10447 12, 27, // 19032: case 0xc: {
10448 OPC_SwitchField, 15, 10, // 19034: switch Inst[24:15] {
10449 0, 10, // 19037: case 0x0: {
10450 OPC_CheckPredicate, 109, // 19039: check predicate 109
10451 OPC_CheckField, 7, 5, 0, // 19041: check Inst[11:7] == 0x0
10452 OPC_Decode, 172, 123, 14, // 19045: decode to SFENCE_W_INVAL using decoder 14
10453 // 19045: }
10454 32, 0, // 19049: case 0x20: {
10455 OPC_CheckPredicate, 109, // 19051: check predicate 109
10456 OPC_CheckField, 7, 5, 0, // 19053: check Inst[11:7] == 0x0
10457 OPC_Decode, 170, 123, 14, // 19057: decode to SFENCE_INVAL_IR using decoder 14
10458 // 19057: }
10459 // 19057: } // switch Inst[24:15]
10460 // 19057: }
10461 17, 11, // 19061: case 0x11: {
10462 OPC_CheckPredicate, 110, // 19063: check predicate 110
10463 OPC_CheckField, 7, 5, 0, // 19065: check Inst[11:7] == 0x0
10464 OPC_Decode, 130, 116, 151, 1, // 19069: decode to HFENCE_VVMA using decoder 151
10465 // 19069: }
10466 19, 11, // 19074: case 0x13: {
10467 OPC_CheckPredicate, 109, // 19076: check predicate 109
10468 OPC_CheckField, 7, 5, 0, // 19078: check Inst[11:7] == 0x0
10469 OPC_Decode, 132, 116, 151, 1, // 19082: decode to HINVAL_VVMA using decoder 151
10470 // 19082: }
10471 24, 12, // 19087: case 0x18: {
10472 OPC_CheckField, 15, 10, 64, // 19089: check Inst[24:15] == 0x40
10473 OPC_CheckField, 7, 5, 0, // 19093: check Inst[11:7] == 0x0
10474 OPC_Decode, 169, 117, 14, // 19097: decode to MRET using decoder 14
10475 // 19097: }
10476 49, 11, // 19101: case 0x31: {
10477 OPC_CheckPredicate, 110, // 19103: check predicate 110
10478 OPC_CheckField, 7, 5, 0, // 19105: check Inst[11:7] == 0x0
10479 OPC_Decode, 129, 116, 151, 1, // 19109: decode to HFENCE_GVMA using decoder 151
10480 // 19109: }
10481 51, 11, // 19114: case 0x33: {
10482 OPC_CheckPredicate, 109, // 19116: check predicate 109
10483 OPC_CheckField, 7, 5, 0, // 19118: check Inst[11:7] == 0x0
10484 OPC_Decode, 131, 116, 151, 1, // 19122: decode to HINVAL_GVMA using decoder 151
10485 // 19122: }
10486 56, 14, // 19127: case 0x38: {
10487 OPC_CheckPredicate, 111, // 19129: check predicate 111
10488 OPC_CheckField, 15, 10, 64, // 19131: check Inst[24:15] == 0x40
10489 OPC_CheckField, 7, 5, 0, // 19135: check Inst[11:7] == 0x0
10490 OPC_Decode, 242, 116, 14, // 19139: decode to MNRET using decoder 14
10491 // 19139: }
10492 61, 0, // 19143: case 0x3d: {
10493 OPC_CheckField, 15, 10, 192, 4, // 19145: check Inst[24:15] == 0x240
10494 OPC_CheckField, 7, 5, 0, // 19150: check Inst[11:7] == 0x0
10495 OPC_Decode, 233, 113, 14, // 19154: decode to DRET using decoder 14
10496 // 19154: }
10497 // 19154: } // switch Inst[31:25]
10498 // 19154: }
10499 1, 21, // 19158: case 0x1: {
10500 OPC_Scope, 14, // 19160: try {
10501 OPC_CheckField, 7, 5, 0, // 19162: check Inst[11:7] == 0x0
10502 OPC_CheckField, 15, 17, 128, 128, 6, // 19166: check Inst[31:15] == 0x18000
10503 OPC_Decode, 192, 125, 14, // 19172: decode to UNIMP using decoder 14
10504 // 19172: } else try {
10505 OPC_Decode, 221, 110, 152, 1, // 19176: decode to CSRRW using decoder 152
10506 // 19176: }
10507 // 19176: }
10508 2, 5, // 19181: case 0x2: {
10509 OPC_Decode, 219, 110, 152, 1, // 19183: decode to CSRRS using decoder 152
10510 // 19183: }
10511 3, 5, // 19188: case 0x3: {
10512 OPC_Decode, 217, 110, 152, 1, // 19190: decode to CSRRC using decoder 152
10513 // 19190: }
10514 4, 161, 4, // 19195: case 0x4: {
10515 OPC_SwitchField, 25, 7, // 19198: switch Inst[31:25] {
10516 48, 19, // 19201: case 0x30: {
10517 OPC_SwitchField, 20, 5, // 19203: switch Inst[24:20] {
10518 0, 6, // 19206: case 0x0: {
10519 OPC_CheckPredicate, 110, // 19208: check predicate 110
10520 OPC_Decode, 135, 116, 17, // 19210: decode to HLV_B using decoder 17
10521 // 19210: }
10522 1, 0, // 19214: case 0x1: {
10523 OPC_CheckPredicate, 110, // 19216: check predicate 110
10524 OPC_Decode, 136, 116, 17, // 19218: decode to HLV_BU using decoder 17
10525 // 19218: }
10526 // 19218: } // switch Inst[24:20]
10527 // 19218: }
10528 49, 10, // 19222: case 0x31: {
10529 OPC_CheckPredicate, 110, // 19224: check predicate 110
10530 OPC_CheckField, 7, 5, 0, // 19226: check Inst[11:7] == 0x0
10531 OPC_Decode, 142, 116, 57, // 19230: decode to HSV_B using decoder 57
10532 // 19230: }
10533 50, 27, // 19234: case 0x32: {
10534 OPC_SwitchField, 20, 5, // 19236: switch Inst[24:20] {
10535 0, 6, // 19239: case 0x0: {
10536 OPC_CheckPredicate, 110, // 19241: check predicate 110
10537 OPC_Decode, 138, 116, 17, // 19243: decode to HLV_H using decoder 17
10538 // 19243: }
10539 1, 6, // 19247: case 0x1: {
10540 OPC_CheckPredicate, 110, // 19249: check predicate 110
10541 OPC_Decode, 139, 116, 17, // 19251: decode to HLV_HU using decoder 17
10542 // 19251: }
10543 3, 0, // 19255: case 0x3: {
10544 OPC_CheckPredicate, 110, // 19257: check predicate 110
10545 OPC_Decode, 133, 116, 17, // 19259: decode to HLVX_HU using decoder 17
10546 // 19259: }
10547 // 19259: } // switch Inst[24:20]
10548 // 19259: }
10549 51, 10, // 19263: case 0x33: {
10550 OPC_CheckPredicate, 110, // 19265: check predicate 110
10551 OPC_CheckField, 7, 5, 0, // 19267: check Inst[11:7] == 0x0
10552 OPC_Decode, 144, 116, 57, // 19271: decode to HSV_H using decoder 57
10553 // 19271: }
10554 52, 27, // 19275: case 0x34: {
10555 OPC_SwitchField, 20, 5, // 19277: switch Inst[24:20] {
10556 0, 6, // 19280: case 0x0: {
10557 OPC_CheckPredicate, 110, // 19282: check predicate 110
10558 OPC_Decode, 140, 116, 17, // 19284: decode to HLV_W using decoder 17
10559 // 19284: }
10560 1, 6, // 19288: case 0x1: {
10561 OPC_CheckPredicate, 112, // 19290: check predicate 112
10562 OPC_Decode, 141, 116, 17, // 19292: decode to HLV_WU using decoder 17
10563 // 19292: }
10564 3, 0, // 19296: case 0x3: {
10565 OPC_CheckPredicate, 110, // 19298: check predicate 110
10566 OPC_Decode, 134, 116, 17, // 19300: decode to HLVX_WU using decoder 17
10567 // 19300: }
10568 // 19300: } // switch Inst[24:20]
10569 // 19300: }
10570 53, 10, // 19304: case 0x35: {
10571 OPC_CheckPredicate, 110, // 19306: check predicate 110
10572 OPC_CheckField, 7, 5, 0, // 19308: check Inst[11:7] == 0x0
10573 OPC_Decode, 145, 116, 57, // 19312: decode to HSV_W using decoder 57
10574 // 19312: }
10575 54, 10, // 19316: case 0x36: {
10576 OPC_CheckPredicate, 112, // 19318: check predicate 112
10577 OPC_CheckField, 20, 5, 0, // 19320: check Inst[24:20] == 0x0
10578 OPC_Decode, 137, 116, 17, // 19324: decode to HLV_D using decoder 17
10579 // 19324: }
10580 55, 10, // 19328: case 0x37: {
10581 OPC_CheckPredicate, 112, // 19330: check predicate 112
10582 OPC_CheckField, 7, 5, 0, // 19332: check Inst[11:7] == 0x0
10583 OPC_Decode, 143, 116, 57, // 19336: decode to HSV_D using decoder 57
10584 // 19336: }
10585 64, 35, // 19340: case 0x40: {
10586 OPC_SwitchField, 20, 5, // 19342: switch Inst[24:20] {
10587 28, 6, // 19345: case 0x1c: {
10588 OPC_CheckPredicate, 113, // 19347: check predicate 113
10589 OPC_Decode, 251, 116, 17, // 19349: decode to MOP_R_0 using decoder 17
10590 // 19349: }
10591 29, 6, // 19353: case 0x1d: {
10592 OPC_CheckPredicate, 113, // 19355: check predicate 113
10593 OPC_Decode, 252, 116, 17, // 19357: decode to MOP_R_1 using decoder 17
10594 // 19357: }
10595 30, 6, // 19361: case 0x1e: {
10596 OPC_CheckPredicate, 113, // 19363: check predicate 113
10597 OPC_Decode, 135, 117, 17, // 19365: decode to MOP_R_2 using decoder 17
10598 // 19365: }
10599 31, 0, // 19369: case 0x1f: {
10600 OPC_CheckPredicate, 113, // 19371: check predicate 113
10601 OPC_Decode, 146, 117, 17, // 19373: decode to MOP_R_3 using decoder 17
10602 // 19373: }
10603 // 19373: } // switch Inst[24:20]
10604 // 19373: }
10605 65, 6, // 19377: case 0x41: {
10606 OPC_CheckPredicate, 113, // 19379: check predicate 113
10607 OPC_Decode, 243, 116, 31, // 19381: decode to MOP_RR_0 using decoder 31
10608 // 19381: }
10609 66, 35, // 19385: case 0x42: {
10610 OPC_SwitchField, 20, 5, // 19387: switch Inst[24:20] {
10611 28, 6, // 19390: case 0x1c: {
10612 OPC_CheckPredicate, 113, // 19392: check predicate 113
10613 OPC_Decode, 149, 117, 17, // 19394: decode to MOP_R_4 using decoder 17
10614 // 19394: }
10615 29, 6, // 19398: case 0x1d: {
10616 OPC_CheckPredicate, 113, // 19400: check predicate 113
10617 OPC_Decode, 150, 117, 17, // 19402: decode to MOP_R_5 using decoder 17
10618 // 19402: }
10619 30, 6, // 19406: case 0x1e: {
10620 OPC_CheckPredicate, 113, // 19408: check predicate 113
10621 OPC_Decode, 151, 117, 17, // 19410: decode to MOP_R_6 using decoder 17
10622 // 19410: }
10623 31, 0, // 19414: case 0x1f: {
10624 OPC_CheckPredicate, 113, // 19416: check predicate 113
10625 OPC_Decode, 152, 117, 17, // 19418: decode to MOP_R_7 using decoder 17
10626 // 19418: }
10627 // 19418: } // switch Inst[24:20]
10628 // 19418: }
10629 67, 6, // 19422: case 0x43: {
10630 OPC_CheckPredicate, 113, // 19424: check predicate 113
10631 OPC_Decode, 244, 116, 31, // 19426: decode to MOP_RR_1 using decoder 31
10632 // 19426: }
10633 68, 35, // 19430: case 0x44: {
10634 OPC_SwitchField, 20, 5, // 19432: switch Inst[24:20] {
10635 28, 6, // 19435: case 0x1c: {
10636 OPC_CheckPredicate, 113, // 19437: check predicate 113
10637 OPC_Decode, 153, 117, 17, // 19439: decode to MOP_R_8 using decoder 17
10638 // 19439: }
10639 29, 6, // 19443: case 0x1d: {
10640 OPC_CheckPredicate, 113, // 19445: check predicate 113
10641 OPC_Decode, 154, 117, 17, // 19447: decode to MOP_R_9 using decoder 17
10642 // 19447: }
10643 30, 6, // 19451: case 0x1e: {
10644 OPC_CheckPredicate, 113, // 19453: check predicate 113
10645 OPC_Decode, 253, 116, 17, // 19455: decode to MOP_R_10 using decoder 17
10646 // 19455: }
10647 31, 0, // 19459: case 0x1f: {
10648 OPC_CheckPredicate, 113, // 19461: check predicate 113
10649 OPC_Decode, 254, 116, 17, // 19463: decode to MOP_R_11 using decoder 17
10650 // 19463: }
10651 // 19463: } // switch Inst[24:20]
10652 // 19463: }
10653 69, 6, // 19467: case 0x45: {
10654 OPC_CheckPredicate, 113, // 19469: check predicate 113
10655 OPC_Decode, 245, 116, 31, // 19471: decode to MOP_RR_2 using decoder 31
10656 // 19471: }
10657 70, 35, // 19475: case 0x46: {
10658 OPC_SwitchField, 20, 5, // 19477: switch Inst[24:20] {
10659 28, 6, // 19480: case 0x1c: {
10660 OPC_CheckPredicate, 113, // 19482: check predicate 113
10661 OPC_Decode, 255, 116, 17, // 19484: decode to MOP_R_12 using decoder 17
10662 // 19484: }
10663 29, 6, // 19488: case 0x1d: {
10664 OPC_CheckPredicate, 113, // 19490: check predicate 113
10665 OPC_Decode, 128, 117, 17, // 19492: decode to MOP_R_13 using decoder 17
10666 // 19492: }
10667 30, 6, // 19496: case 0x1e: {
10668 OPC_CheckPredicate, 113, // 19498: check predicate 113
10669 OPC_Decode, 129, 117, 17, // 19500: decode to MOP_R_14 using decoder 17
10670 // 19500: }
10671 31, 0, // 19504: case 0x1f: {
10672 OPC_CheckPredicate, 113, // 19506: check predicate 113
10673 OPC_Decode, 130, 117, 17, // 19508: decode to MOP_R_15 using decoder 17
10674 // 19508: }
10675 // 19508: } // switch Inst[24:20]
10676 // 19508: }
10677 71, 6, // 19512: case 0x47: {
10678 OPC_CheckPredicate, 113, // 19514: check predicate 113
10679 OPC_Decode, 246, 116, 31, // 19516: decode to MOP_RR_3 using decoder 31
10680 // 19516: }
10681 96, 35, // 19520: case 0x60: {
10682 OPC_SwitchField, 20, 5, // 19522: switch Inst[24:20] {
10683 28, 6, // 19525: case 0x1c: {
10684 OPC_CheckPredicate, 113, // 19527: check predicate 113
10685 OPC_Decode, 131, 117, 17, // 19529: decode to MOP_R_16 using decoder 17
10686 // 19529: }
10687 29, 6, // 19533: case 0x1d: {
10688 OPC_CheckPredicate, 113, // 19535: check predicate 113
10689 OPC_Decode, 132, 117, 17, // 19537: decode to MOP_R_17 using decoder 17
10690 // 19537: }
10691 30, 6, // 19541: case 0x1e: {
10692 OPC_CheckPredicate, 113, // 19543: check predicate 113
10693 OPC_Decode, 133, 117, 17, // 19545: decode to MOP_R_18 using decoder 17
10694 // 19545: }
10695 31, 0, // 19549: case 0x1f: {
10696 OPC_CheckPredicate, 113, // 19551: check predicate 113
10697 OPC_Decode, 134, 117, 17, // 19553: decode to MOP_R_19 using decoder 17
10698 // 19553: }
10699 // 19553: } // switch Inst[24:20]
10700 // 19553: }
10701 97, 6, // 19557: case 0x61: {
10702 OPC_CheckPredicate, 113, // 19559: check predicate 113
10703 OPC_Decode, 247, 116, 31, // 19561: decode to MOP_RR_4 using decoder 31
10704 // 19561: }
10705 98, 35, // 19565: case 0x62: {
10706 OPC_SwitchField, 20, 5, // 19567: switch Inst[24:20] {
10707 28, 6, // 19570: case 0x1c: {
10708 OPC_CheckPredicate, 113, // 19572: check predicate 113
10709 OPC_Decode, 136, 117, 17, // 19574: decode to MOP_R_20 using decoder 17
10710 // 19574: }
10711 29, 6, // 19578: case 0x1d: {
10712 OPC_CheckPredicate, 113, // 19580: check predicate 113
10713 OPC_Decode, 137, 117, 17, // 19582: decode to MOP_R_21 using decoder 17
10714 // 19582: }
10715 30, 6, // 19586: case 0x1e: {
10716 OPC_CheckPredicate, 113, // 19588: check predicate 113
10717 OPC_Decode, 138, 117, 17, // 19590: decode to MOP_R_22 using decoder 17
10718 // 19590: }
10719 31, 0, // 19594: case 0x1f: {
10720 OPC_CheckPredicate, 113, // 19596: check predicate 113
10721 OPC_Decode, 139, 117, 17, // 19598: decode to MOP_R_23 using decoder 17
10722 // 19598: }
10723 // 19598: } // switch Inst[24:20]
10724 // 19598: }
10725 99, 6, // 19602: case 0x63: {
10726 OPC_CheckPredicate, 113, // 19604: check predicate 113
10727 OPC_Decode, 248, 116, 31, // 19606: decode to MOP_RR_5 using decoder 31
10728 // 19606: }
10729 100, 35, // 19610: case 0x64: {
10730 OPC_SwitchField, 20, 5, // 19612: switch Inst[24:20] {
10731 28, 6, // 19615: case 0x1c: {
10732 OPC_CheckPredicate, 113, // 19617: check predicate 113
10733 OPC_Decode, 140, 117, 17, // 19619: decode to MOP_R_24 using decoder 17
10734 // 19619: }
10735 29, 6, // 19623: case 0x1d: {
10736 OPC_CheckPredicate, 113, // 19625: check predicate 113
10737 OPC_Decode, 141, 117, 17, // 19627: decode to MOP_R_25 using decoder 17
10738 // 19627: }
10739 30, 6, // 19631: case 0x1e: {
10740 OPC_CheckPredicate, 113, // 19633: check predicate 113
10741 OPC_Decode, 142, 117, 17, // 19635: decode to MOP_R_26 using decoder 17
10742 // 19635: }
10743 31, 0, // 19639: case 0x1f: {
10744 OPC_CheckPredicate, 113, // 19641: check predicate 113
10745 OPC_Decode, 143, 117, 17, // 19643: decode to MOP_R_27 using decoder 17
10746 // 19643: }
10747 // 19643: } // switch Inst[24:20]
10748 // 19643: }
10749 101, 6, // 19647: case 0x65: {
10750 OPC_CheckPredicate, 113, // 19649: check predicate 113
10751 OPC_Decode, 249, 116, 31, // 19651: decode to MOP_RR_6 using decoder 31
10752 // 19651: }
10753 102, 61, // 19655: case 0x66: {
10754 OPC_SwitchField, 20, 5, // 19657: switch Inst[24:20] {
10755 28, 32, // 19660: case 0x1c: {
10756 OPC_Scope, 11, // 19662: try {
10757 OPC_CheckField, 7, 5, 0, // 19664: check Inst[11:7] == 0x0
10758 OPC_CheckPredicate, 113, // 19668: check predicate 113
10759 OPC_Decode, 199, 124, 153, 1, // 19670: decode to SSPOPCHK using decoder 153
10760 OPC_Scope, 11, // 19675: } else try {
10761 OPC_CheckField, 15, 5, 0, // 19677: check Inst[19:15] == 0x0
10762 OPC_CheckPredicate, 113, // 19681: check predicate 113
10763 OPC_Decode, 201, 124, 154, 1, // 19683: decode to SSRDP using decoder 154
10764 // 19683: } else try {
10765 OPC_CheckPredicate, 113, // 19688: check predicate 113
10766 OPC_Decode, 144, 117, 17, // 19690: decode to MOP_R_28 using decoder 17
10767 // 19690: }
10768 // 19690: }
10769 29, 6, // 19694: case 0x1d: {
10770 OPC_CheckPredicate, 113, // 19696: check predicate 113
10771 OPC_Decode, 145, 117, 17, // 19698: decode to MOP_R_29 using decoder 17
10772 // 19698: }
10773 30, 6, // 19702: case 0x1e: {
10774 OPC_CheckPredicate, 113, // 19704: check predicate 113
10775 OPC_Decode, 147, 117, 17, // 19706: decode to MOP_R_30 using decoder 17
10776 // 19706: }
10777 31, 0, // 19710: case 0x1f: {
10778 OPC_CheckPredicate, 113, // 19712: check predicate 113
10779 OPC_Decode, 148, 117, 17, // 19714: decode to MOP_R_31 using decoder 17
10780 // 19714: }
10781 // 19714: } // switch Inst[24:20]
10782 // 19714: }
10783 103, 0, // 19718: case 0x67: {
10784 OPC_Scope, 15, // 19720: try {
10785 OPC_CheckField, 7, 5, 0, // 19722: check Inst[11:7] == 0x0
10786 OPC_CheckPredicate, 113, // 19726: check predicate 113
10787 OPC_CheckField, 15, 5, 0, // 19728: check Inst[19:15] == 0x0
10788 OPC_Decode, 200, 124, 155, 1, // 19732: decode to SSPUSH using decoder 155
10789 // 19732: } else try {
10790 OPC_CheckPredicate, 113, // 19737: check predicate 113
10791 OPC_Decode, 250, 116, 31, // 19739: decode to MOP_RR_7 using decoder 31
10792 // 19739: }
10793 // 19739: }
10794 // 19739: } // switch Inst[31:25]
10795 // 19739: }
10796 5, 5, // 19743: case 0x5: {
10797 OPC_Decode, 222, 110, 156, 1, // 19745: decode to CSRRWI using decoder 156
10798 // 19745: }
10799 6, 5, // 19750: case 0x6: {
10800 OPC_Decode, 220, 110, 156, 1, // 19752: decode to CSRRSI using decoder 156
10801 // 19752: }
10802 7, 0, // 19757: case 0x7: {
10803 OPC_Decode, 218, 110, 156, 1, // 19759: decode to CSRRCI using decoder 156
10804 // 19759: }
10805 // 19759: } // switch Inst[14:12]
10806 // 19759: }
10807 119, 223, 3, // 19764: case 0x77: {
10808 OPC_SwitchField, 26, 6, // 19767: switch Inst[31:26] {
10809 32, 15, // 19770: case 0x20: {
10810 OPC_CheckPredicate, 114, // 19772: check predicate 114
10811 OPC_CheckField, 25, 1, 1, // 19774: check Inst[25] == 0x1
10812 OPC_CheckField, 12, 3, 2, // 19778: check Inst[14:12] == 0x2
10813 OPC_Decode, 216, 129, 1, 114, // 19782: decode to VSM3ME_VV using decoder 114
10814 // 19782: }
10815 33, 16, // 19787: case 0x21: {
10816 OPC_CheckPredicate, 115, // 19789: check predicate 115
10817 OPC_CheckField, 25, 1, 1, // 19791: check Inst[25] == 0x1
10818 OPC_CheckField, 12, 3, 2, // 19795: check Inst[14:12] == 0x2
10819 OPC_Decode, 217, 129, 1, 157, 1, // 19799: decode to VSM4K_VI using decoder 157
10820 // 19799: }
10821 34, 15, // 19805: case 0x22: {
10822 OPC_CheckPredicate, 116, // 19807: check predicate 116
10823 OPC_CheckField, 25, 1, 1, // 19809: check Inst[25] == 0x1
10824 OPC_CheckField, 12, 3, 2, // 19813: check Inst[14:12] == 0x2
10825 OPC_Decode, 222, 125, 157, 1, // 19817: decode to VAESKF1_VI using decoder 157
10826 // 19817: }
10827 35, 15, // 19822: case 0x23: {
10828 OPC_CheckPredicate, 117, // 19824: check predicate 117
10829 OPC_CheckField, 25, 1, 1, // 19826: check Inst[25] == 0x1
10830 OPC_CheckField, 12, 3, 2, // 19830: check Inst[14:12] == 0x2
10831 OPC_Decode, 244, 126, 158, 1, // 19834: decode to VGHSH_VS using decoder 158
10832 // 19834: }
10833 36, 10, // 19839: case 0x24: {
10834 OPC_CheckPredicate, 118, // 19841: check predicate 118
10835 OPC_CheckField, 12, 3, 1, // 19843: check Inst[14:12] == 0x1
10836 OPC_Decode, 222, 126, 124, // 19847: decode to VFWDOTA_VV using decoder 124
10837 // 19847: }
10838 38, 20, // 19851: case 0x26: {
10839 OPC_SwitchField, 12, 3, // 19853: switch Inst[14:12] {
10840 0, 7, // 19856: case 0x0: {
10841 OPC_CheckPredicate, 119, // 19858: check predicate 119
10842 OPC_Decode, 156, 129, 1, 124, // 19860: decode to VQWDOTAU_VV using decoder 124
10843 // 19860: }
10844 1, 0, // 19865: case 0x1: {
10845 OPC_CheckPredicate, 120, // 19867: check predicate 120
10846 OPC_Decode, 189, 126, 124, // 19869: decode to VFQWDOTA_VV using decoder 124
10847 // 19869: }
10848 // 19869: } // switch Inst[14:12]
10849 // 19869: }
10850 39, 20, // 19873: case 0x27: {
10851 OPC_SwitchField, 12, 3, // 19875: switch Inst[14:12] {
10852 0, 7, // 19878: case 0x0: {
10853 OPC_CheckPredicate, 119, // 19880: check predicate 119
10854 OPC_Decode, 155, 129, 1, 124, // 19882: decode to VQWDOTAS_VV using decoder 124
10855 // 19882: }
10856 1, 0, // 19887: case 0x1: {
10857 OPC_CheckPredicate, 120, // 19889: check predicate 120
10858 OPC_Decode, 188, 126, 124, // 19891: decode to VFQWDOTA_ALT_VV using decoder 124
10859 // 19891: }
10860 // 19891: } // switch Inst[14:12]
10861 // 19891: }
10862 40, 84, // 19895: case 0x28: {
10863 OPC_SwitchField, 12, 8, // 19897: switch Inst[19:12] {
10864 2, 11, // 19900: case 0x2: {
10865 OPC_CheckPredicate, 116, // 19902: check predicate 116
10866 OPC_CheckField, 25, 1, 1, // 19904: check Inst[25] == 0x1
10867 OPC_Decode, 217, 125, 159, 1, // 19908: decode to VAESDM_VV using decoder 159
10868 // 19908: }
10869 10, 11, // 19913: case 0xa: {
10870 OPC_CheckPredicate, 116, // 19915: check predicate 116
10871 OPC_CheckField, 25, 1, 1, // 19917: check Inst[25] == 0x1
10872 OPC_Decode, 215, 125, 159, 1, // 19921: decode to VAESDF_VV using decoder 159
10873 // 19921: }
10874 18, 11, // 19926: case 0x12: {
10875 OPC_CheckPredicate, 116, // 19928: check predicate 116
10876 OPC_CheckField, 25, 1, 1, // 19930: check Inst[25] == 0x1
10877 OPC_Decode, 221, 125, 159, 1, // 19934: decode to VAESEM_VV using decoder 159
10878 // 19934: }
10879 26, 11, // 19939: case 0x1a: {
10880 OPC_CheckPredicate, 116, // 19941: check predicate 116
10881 OPC_CheckField, 25, 1, 1, // 19943: check Inst[25] == 0x1
10882 OPC_Decode, 219, 125, 159, 1, // 19947: decode to VAESEF_VV using decoder 159
10883 // 19947: }
10884 130, 1, 12, // 19952: case 0x82: {
10885 OPC_CheckPredicate, 115, // 19955: check predicate 115
10886 OPC_CheckField, 25, 1, 1, // 19957: check Inst[25] == 0x1
10887 OPC_Decode, 219, 129, 1, 159, 1, // 19961: decode to VSM4R_VV using decoder 159
10888 // 19961: }
10889 138, 1, 0, // 19967: case 0x8a: {
10890 OPC_CheckPredicate, 121, // 19970: check predicate 121
10891 OPC_CheckField, 25, 1, 1, // 19972: check Inst[25] == 0x1
10892 OPC_Decode, 247, 126, 159, 1, // 19976: decode to VGMUL_VV using decoder 159
10893 // 19976: }
10894 // 19976: } // switch Inst[19:12]
10895 // 19976: }
10896 41, 97, // 19981: case 0x29: {
10897 OPC_SwitchField, 12, 8, // 19983: switch Inst[19:12] {
10898 2, 11, // 19986: case 0x2: {
10899 OPC_CheckPredicate, 116, // 19988: check predicate 116
10900 OPC_CheckField, 25, 1, 1, // 19990: check Inst[25] == 0x1
10901 OPC_Decode, 216, 125, 159, 1, // 19994: decode to VAESDM_VS using decoder 159
10902 // 19994: }
10903 10, 11, // 19999: case 0xa: {
10904 OPC_CheckPredicate, 116, // 20001: check predicate 116
10905 OPC_CheckField, 25, 1, 1, // 20003: check Inst[25] == 0x1
10906 OPC_Decode, 214, 125, 159, 1, // 20007: decode to VAESDF_VS using decoder 159
10907 // 20007: }
10908 18, 11, // 20012: case 0x12: {
10909 OPC_CheckPredicate, 116, // 20014: check predicate 116
10910 OPC_CheckField, 25, 1, 1, // 20016: check Inst[25] == 0x1
10911 OPC_Decode, 220, 125, 159, 1, // 20020: decode to VAESEM_VS using decoder 159
10912 // 20020: }
10913 26, 11, // 20025: case 0x1a: {
10914 OPC_CheckPredicate, 116, // 20027: check predicate 116
10915 OPC_CheckField, 25, 1, 1, // 20029: check Inst[25] == 0x1
10916 OPC_Decode, 218, 125, 159, 1, // 20033: decode to VAESEF_VS using decoder 159
10917 // 20033: }
10918 58, 11, // 20038: case 0x3a: {
10919 OPC_CheckPredicate, 116, // 20040: check predicate 116
10920 OPC_CheckField, 25, 1, 1, // 20042: check Inst[25] == 0x1
10921 OPC_Decode, 224, 125, 159, 1, // 20046: decode to VAESZ_VS using decoder 159
10922 // 20046: }
10923 130, 1, 12, // 20051: case 0x82: {
10924 OPC_CheckPredicate, 115, // 20054: check predicate 115
10925 OPC_CheckField, 25, 1, 1, // 20056: check Inst[25] == 0x1
10926 OPC_Decode, 218, 129, 1, 159, 1, // 20060: decode to VSM4R_VS using decoder 159
10927 // 20060: }
10928 138, 1, 0, // 20066: case 0x8a: {
10929 OPC_CheckPredicate, 117, // 20069: check predicate 117
10930 OPC_CheckField, 25, 1, 1, // 20071: check Inst[25] == 0x1
10931 OPC_Decode, 246, 126, 159, 1, // 20075: decode to VGMUL_VS using decoder 159
10932 // 20075: }
10933 // 20075: } // switch Inst[19:12]
10934 // 20075: }
10935 42, 15, // 20080: case 0x2a: {
10936 OPC_CheckPredicate, 116, // 20082: check predicate 116
10937 OPC_CheckField, 25, 1, 1, // 20084: check Inst[25] == 0x1
10938 OPC_CheckField, 12, 3, 2, // 20088: check Inst[14:12] == 0x2
10939 OPC_Decode, 223, 125, 160, 1, // 20092: decode to VAESKF2_VI using decoder 160
10940 // 20092: }
10941 43, 26, // 20097: case 0x2b: {
10942 OPC_SwitchField, 12, 3, // 20099: switch Inst[14:12] {
10943 1, 7, // 20102: case 0x1: {
10944 OPC_CheckPredicate, 122, // 20104: check predicate 122
10945 OPC_Decode, 133, 126, 161, 1, // 20106: decode to VFBDOTA_VV using decoder 161
10946 // 20106: }
10947 2, 0, // 20111: case 0x2: {
10948 OPC_CheckPredicate, 114, // 20113: check predicate 114
10949 OPC_CheckField, 25, 1, 1, // 20115: check Inst[25] == 0x1
10950 OPC_Decode, 215, 129, 1, 160, 1, // 20119: decode to VSM3C_VI using decoder 160
10951 // 20119: }
10952 // 20119: } // switch Inst[14:12]
10953 // 20119: }
10954 44, 25, // 20125: case 0x2c: {
10955 OPC_SwitchField, 12, 3, // 20127: switch Inst[14:12] {
10956 1, 7, // 20130: case 0x1: {
10957 OPC_CheckPredicate, 123, // 20132: check predicate 123
10958 OPC_Decode, 213, 126, 161, 1, // 20134: decode to VFWBDOTA_VV using decoder 161
10959 // 20134: }
10960 2, 0, // 20139: case 0x2: {
10961 OPC_CheckPredicate, 121, // 20141: check predicate 121
10962 OPC_CheckField, 25, 1, 1, // 20143: check Inst[25] == 0x1
10963 OPC_Decode, 245, 126, 158, 1, // 20147: decode to VGHSH_VV using decoder 158
10964 // 20147: }
10965 // 20147: } // switch Inst[14:12]
10966 // 20147: }
10967 45, 16, // 20152: case 0x2d: {
10968 OPC_CheckPredicate, 124, // 20154: check predicate 124
10969 OPC_CheckField, 25, 1, 1, // 20156: check Inst[25] == 0x1
10970 OPC_CheckField, 12, 3, 2, // 20160: check Inst[14:12] == 0x2
10971 OPC_Decode, 205, 129, 1, 158, 1, // 20164: decode to VSHA2MS_VV using decoder 158
10972 // 20164: }
10973 46, 36, // 20170: case 0x2e: {
10974 OPC_SwitchField, 12, 3, // 20172: switch Inst[14:12] {
10975 0, 8, // 20175: case 0x0: {
10976 OPC_CheckPredicate, 125, // 20177: check predicate 125
10977 OPC_Decode, 154, 129, 1, 161, 1, // 20179: decode to VQWBDOTAU_VV using decoder 161
10978 // 20179: }
10979 1, 7, // 20185: case 0x1: {
10980 OPC_CheckPredicate, 126, // 20187: check predicate 126
10981 OPC_Decode, 187, 126, 161, 1, // 20189: decode to VFQWBDOTA_VV using decoder 161
10982 // 20189: }
10983 2, 0, // 20194: case 0x2: {
10984 OPC_CheckPredicate, 124, // 20196: check predicate 124
10985 OPC_CheckField, 25, 1, 1, // 20198: check Inst[25] == 0x1
10986 OPC_Decode, 203, 129, 1, 158, 1, // 20202: decode to VSHA2CH_VV using decoder 158
10987 // 20202: }
10988 // 20202: } // switch Inst[14:12]
10989 // 20202: }
10990 47, 0, // 20208: case 0x2f: {
10991 OPC_SwitchField, 12, 3, // 20210: switch Inst[14:12] {
10992 0, 8, // 20213: case 0x0: {
10993 OPC_CheckPredicate, 125, // 20215: check predicate 125
10994 OPC_Decode, 153, 129, 1, 161, 1, // 20217: decode to VQWBDOTAS_VV using decoder 161
10995 // 20217: }
10996 1, 7, // 20223: case 0x1: {
10997 OPC_CheckPredicate, 126, // 20225: check predicate 126
10998 OPC_Decode, 186, 126, 161, 1, // 20227: decode to VFQWBDOTA_ALT_VV using decoder 161
10999 // 20227: }
11000 2, 0, // 20232: case 0x2: {
11001 OPC_CheckPredicate, 124, // 20234: check predicate 124
11002 OPC_CheckField, 25, 1, 1, // 20236: check Inst[25] == 0x1
11003 OPC_Decode, 204, 129, 1, 158, 1, // 20240: decode to VSHA2CL_VV using decoder 158
11004 // 20240: }
11005 // 20240: } // switch Inst[14:12]
11006 // 20240: }
11007 // 20240: } // switch Inst[31:26]
11008 // 20240: }
11009 123, 0, // 20246: case 0x7b: {
11010 OPC_SwitchField, 12, 3, // 20248: switch Inst[14:12] {
11011 0, 194, 1, // 20251: case 0x0: {
11012 OPC_SwitchField, 25, 7, // 20254: switch Inst[31:25] {
11013 1, 7, // 20257: case 0x1: {
11014 OPC_CheckPredicate, 127, // 20259: check predicate 127
11015 OPC_Decode, 170, 118, 162, 1, // 20261: decode to PACKY using decoder 162
11016 // 20261: }
11017 3, 22, // 20266: case 0x3: {
11018 OPC_Scope, 12, // 20268: try {
11019 OPC_CheckField, 20, 5, 0, // 20270: check Inst[24:20] == 0x0
11020 OPC_CheckPredicate, 127, // 20274: check predicate 127
11021 OPC_Decode, 196, 131, 1, 163, 1, // 20276: decode to YMV using decoder 163
11022 // 20276: } else try {
11023 OPC_CheckPredicate, 127, // 20282: check predicate 127
11024 OPC_Decode, 185, 131, 1, 164, 1, // 20284: decode to YADD using decoder 164
11025 // 20284: }
11026 // 20284: }
11027 6, 8, // 20290: case 0x6: {
11028 OPC_CheckPredicate, 127, // 20292: check predicate 127
11029 OPC_Decode, 194, 131, 1, 165, 1, // 20294: decode to YEQ using decoder 165
11030 // 20294: }
11031 7, 8, // 20300: case 0x7: {
11032 OPC_CheckPredicate, 127, // 20302: check predicate 127
11033 OPC_Decode, 200, 131, 1, 166, 1, // 20304: decode to YSUNSEAL using decoder 166
11034 // 20304: }
11035 11, 8, // 20310: case 0xb: {
11036 OPC_CheckPredicate, 127, // 20312: check predicate 127
11037 OPC_Decode, 187, 131, 1, 162, 1, // 20314: decode to YADDRW using decoder 162
11038 // 20314: }
11039 14, 8, // 20320: case 0xe: {
11040 OPC_CheckPredicate, 127, // 20322: check predicate 127
11041 OPC_Decode, 199, 131, 1, 165, 1, // 20324: decode to YSS using decoder 165
11042 // 20324: }
11043 15, 8, // 20330: case 0xf: {
11044 OPC_CheckPredicate, 127, // 20332: check predicate 127
11045 OPC_Decode, 190, 131, 1, 166, 1, // 20334: decode to YBLD using decoder 166
11046 // 20334: }
11047 19, 8, // 20340: case 0x13: {
11048 OPC_CheckPredicate, 127, // 20342: check predicate 127
11049 OPC_Decode, 197, 131, 1, 162, 1, // 20344: decode to YPERMC using decoder 162
11050 // 20344: }
11051 27, 8, // 20350: case 0x1b: {
11052 OPC_CheckPredicate, 127, // 20352: check predicate 127
11053 OPC_Decode, 192, 131, 1, 162, 1, // 20354: decode to YBNDSW using decoder 162
11054 // 20354: }
11055 35, 8, // 20360: case 0x23: {
11056 OPC_CheckPredicate, 127, // 20362: check predicate 127
11057 OPC_Decode, 191, 131, 1, 162, 1, // 20364: decode to YBNDSRW using decoder 162
11058 // 20364: }
11059 120, 11, // 20370: case 0x78: {
11060 OPC_CheckPredicate, 127, // 20372: check predicate 127
11061 OPC_CheckField, 20, 5, 0, // 20374: check Inst[24:20] == 0x0
11062 OPC_Decode, 188, 131, 1, 17, // 20378: decode to YAMASK using decoder 17
11063 // 20378: }
11064 122, 0, // 20383: case 0x7a: {
11065 OPC_SwitchField, 20, 5, // 20385: switch Inst[24:20] {
11066 0, 8, // 20388: case 0x0: {
11067 OPC_CheckPredicate, 127, // 20390: check predicate 127
11068 OPC_Decode, 189, 131, 1, 167, 1, // 20392: decode to YBASER using decoder 167
11069 // 20392: }
11070 1, 8, // 20398: case 0x1: {
11071 OPC_CheckPredicate, 127, // 20400: check predicate 127
11072 OPC_Decode, 198, 131, 1, 167, 1, // 20402: decode to YPERMR using decoder 167
11073 // 20402: }
11074 2, 8, // 20408: case 0x2: {
11075 OPC_CheckPredicate, 127, // 20410: check predicate 127
11076 OPC_Decode, 202, 131, 1, 167, 1, // 20412: decode to YTOPR using decoder 167
11077 // 20412: }
11078 3, 8, // 20418: case 0x3: {
11079 OPC_CheckPredicate, 127, // 20420: check predicate 127
11080 OPC_Decode, 195, 131, 1, 167, 1, // 20422: decode to YLENR using decoder 167
11081 // 20422: }
11082 4, 8, // 20428: case 0x4: {
11083 OPC_CheckPredicate, 127, // 20430: check predicate 127
11084 OPC_Decode, 201, 131, 1, 167, 1, // 20432: decode to YTAGR using decoder 167
11085 // 20432: }
11086 5, 0, // 20438: case 0x5: {
11087 OPC_CheckPredicate, 127, // 20440: check predicate 127
11088 OPC_Decode, 203, 131, 1, 167, 1, // 20442: decode to YTYPER using decoder 167
11089 // 20442: }
11090 // 20442: } // switch Inst[24:20]
11091 // 20442: }
11092 // 20442: } // switch Inst[31:25]
11093 // 20442: }
11094 4, 8, // 20448: case 0x4: {
11095 OPC_CheckPredicate, 127, // 20450: check predicate 127
11096 OPC_Decode, 186, 131, 1, 168, 1, // 20452: decode to YADDI using decoder 168
11097 // 20452: }
11098 5, 0, // 20458: case 0x5: {
11099 OPC_SwitchField, 29, 3, // 20460: switch Inst[31:29] {
11100 0, 11, // 20463: case 0x0: {
11101 OPC_CheckPredicate, 127, // 20465: check predicate 127
11102 OPC_CheckField, 27, 2, 0, // 20467: check Inst[28:27] == 0x0
11103 OPC_Decode, 182, 124, 169, 1, // 20471: decode to SRLIY using decoder 169
11104 // 20471: }
11105 7, 0, // 20476: case 0x7: {
11106 OPC_CheckPredicate, 127, // 20478: check predicate 127
11107 OPC_Decode, 193, 131, 1, 170, 1, // 20480: decode to YBNDSWI using decoder 170
11108 // 20480: }
11109 // 20480: } // switch Inst[31:29]
11110 // 20480: }
11111 // 20480: } // switch Inst[14:12]
11112 // 20480: }
11113 // 20480: } // 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, 148, 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, 155, 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, 149, 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, 156, 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, 202, 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, 176, 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, 203, 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, 177, 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, 198, 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, 213, 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, 191, 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, 207, 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, 196, 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, 193, 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, 197, 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, 198, 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, 194, 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, 195, 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, 182, 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, 167, 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, 169, 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, 172, 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, 170, 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, 171, 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, 197, 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, 212, 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, 199, 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, 214, 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, 190, 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, 206, 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, 192, 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, 208, 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, 186, 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, 202, 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, 187, 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, 203, 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, 198, 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, 175, 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, 150, 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, 156, 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, 162, 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, 170, 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, 171, 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, 172, 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, 175, 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, 221, 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, 228, 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, 177, 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, 225, 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, 230, 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, 182, 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, 179, 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, 226, 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, 223, 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, 183, 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, 180, 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, 227, 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, 224, 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, 176, 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, 222, 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, 229, 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, 184, 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, 185, 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, 155, 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, 161, 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, 157, 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, 163, 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, 177, 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, 251, 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, 161, 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, 162, 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, 163, 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, 166, 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, 169, 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, 172, 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, 214, 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, 215, 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, 216, 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, 219, 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, 222, 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, 225, 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, 185, 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, 250, 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, 225, 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, 243, 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, 227, 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, 241, 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, 245, 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, 231, 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, 236, 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, 237, 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, 230, 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, 239, 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, 233, 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, 224, 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, 242, 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, 226, 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, 240, 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, 244, 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, 229, 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, 234, 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, 235, 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, 228, 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, 238, 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, 232, 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, 244, 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, 184, 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, 183, 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, 243, 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, 241, 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, 165, 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, 164, 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, 168, 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, 167, 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, 171, 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, 170, 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, 218, 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, 217, 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, 221, 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, 220, 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, 224, 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, 223, 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, 249, 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, 233, 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, 179, 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, 178, 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, 177, 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, 176, 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, 211, 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, 210, 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, 209, 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, 208, 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, 130, 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, 129, 109, 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, 132, 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, 131, 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, 215, 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, 214, 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, 213, 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, 212, 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, 207, 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, 206, 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, 205, 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, 204, 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, 183, 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, 182, 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, 181, 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, 180, 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, 199, 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, 198, 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, 128, 109, 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, 216, 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, 197, 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, 196, 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, 191, 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, 190, 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, 189, 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, 188, 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, 203, 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, 202, 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, 201, 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, 200, 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, 195, 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, 194, 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, 193, 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, 192, 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, 187, 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, 186, 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, 185, 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, 184, 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, 221, 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, 246, 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, 254, 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, 186, 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, 193, 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, 201, 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, 200, 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, 248, 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, 253, 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, 223, 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, 222, 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, 232, 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, 202, 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, 212, 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, 213, 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, 245, 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, 238, 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, 203, 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, 247, 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, 240, 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, 239, 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, 236, 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, 197, 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, 196, 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, 195, 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, 194, 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, 155, 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, 154, 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, 153, 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, 209, 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, 208, 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, 229, 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, 227, 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, 228, 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, 204, 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, 205, 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, 192, 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, 189, 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, 191, 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, 188, 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, 190, 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, 187, 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, 206, 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, 178, 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, 231, 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, 237, 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, 235, 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, 249, 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, 250, 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, 255, 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, 234, 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, 210, 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, 160, 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, 176, 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, 159, 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, 230, 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, 207, 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, 211, 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, 251, 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, 247, 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, 252, 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, 248, 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, 246, 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, 218, 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, 217, 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, 219, 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, 220, 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, 175, 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, 182, 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, 158, 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, 173, 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, 179, 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, 156, 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, 174, 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, 181, 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, 157, 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, 180, 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, 226, 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, 144, 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, 143, 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, 145, 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, 133, 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, 134, 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, 135, 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, 130, 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, 131, 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, 132, 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, 141, 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, 139, 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, 138, 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, 142, 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, 140, 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, 136, 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, 137, 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, 254, 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, 253, 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, 128, 108, 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, 129, 108, 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, 255, 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, 150, 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, 149, 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, 148, 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, 152, 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, 151, 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, 146, 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, 147, 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, 199, 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, 252, 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, 198, 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, 242, 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, 228, 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, 244, 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, 245, 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, 128, 118, 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, 249, 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, 221, 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, 220, 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, 254, 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, 255, 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, 252, 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, 253, 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, 129, 118, 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, 130, 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, 131, 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, 234, 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, 251, 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, 236, 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, 232, 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, 250, 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, 231, 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, 235, 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, 247, 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, 237, 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, 233, 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, 246, 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, 248, 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, 222, 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, 224, 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, 223, 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, 225, 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, 213, 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, 238, 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, 239, 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, 216, 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, 229, 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, 240, 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, 241, 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, 218, 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, 219, 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, 242, 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, 230, 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, 243, 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, 217, 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, 214, 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, 215, 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, 129, 112, 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, 198, 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, 240, 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, 242, 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, 250, 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, 240, 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, 148, 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, 139, 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, 202, 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, 130, 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, 172, 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, 252, 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, 160, 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, 173, 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, 196, 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, 167, 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, 184, 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, 159, 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, 166, 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, 153, 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, 154, 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, 246, 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, 190, 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, 240, 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, 178, 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, 234, 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, 213, 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, 209, 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, 188, 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, 208, 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, 148, 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, 255, 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, 246, 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, 227, 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, 224, 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, 230, 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, 218, 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, 208, 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, 214, 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, 202, 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, 247, 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, 226, 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, 220, 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, 193, 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, 196, 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, 135, 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, 228, 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, 135, 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, 140, 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, 138, 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, 236, 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, 147, 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, 135, 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, 201, 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, 129, 111, 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, 171, 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, 251, 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, 159, 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, 172, 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, 195, 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, 166, 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, 183, 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, 158, 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, 165, 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, 152, 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, 153, 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, 245, 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, 189, 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, 239, 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, 177, 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, 233, 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, 187, 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, 147, 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, 245, 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, 226, 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, 223, 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, 229, 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, 217, 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, 207, 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, 213, 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, 201, 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, 246, 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, 225, 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, 219, 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, 195, 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, 194, 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, 138, 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, 144, 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, 228, 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, 232, 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, 230, 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, 234, 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, 214, 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, 210, 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, 128, 113, 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, 237, 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, 136, 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, 245, 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, 235, 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, 131, 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, 137, 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, 140, 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, 130, 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, 136, 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, 139, 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, 128, 112, 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, 134, 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, 255, 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, 133, 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, 200, 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, 230, 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, 146, 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, 199, 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, 229, 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, 145, 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, 241, 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, 243, 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, 251, 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, 136, 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, 141, 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, 197, 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, 248, 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, 249, 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, 142, 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, 207, 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, 225, 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, 231, 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, 232, 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, 164, 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, 165, 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, 150, 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, 151, 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, 238, 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, 239, 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, 236, 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, 237, 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, 143, 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, 145, 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, 144, 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, 146, 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, 229, 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, 233, 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, 231, 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, 235, 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, 252, 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, 132, 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, 254, 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, 134, 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, 141, 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, 178, 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, 251, 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, 131, 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, 253, 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, 133, 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, 244, 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, 254, 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, 183, 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, 179, 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, 184, 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, 180, 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, 244, 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, 152, 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, 143, 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, 206, 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, 134, 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, 176, 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, 128, 111, 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, 164, 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, 177, 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, 200, 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, 171, 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, 188, 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, 163, 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, 170, 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, 157, 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, 158, 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, 250, 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, 194, 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, 244, 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, 182, 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, 238, 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, 215, 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, 211, 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, 192, 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, 152, 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, 129, 113, 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, 250, 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, 238, 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, 137, 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, 228, 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, 234, 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, 222, 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, 212, 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, 218, 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, 206, 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, 253, 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, 132, 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, 185, 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, 181, 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, 186, 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, 182, 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, 243, 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, 151, 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, 142, 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, 205, 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, 133, 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, 175, 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, 255, 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, 163, 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, 176, 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, 199, 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, 170, 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, 187, 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, 162, 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, 169, 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, 156, 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, 157, 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, 249, 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, 193, 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, 243, 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, 181, 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, 237, 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, 191, 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, 151, 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, 249, 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, 227, 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, 233, 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, 221, 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, 211, 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, 217, 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, 205, 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, 252, 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, 137, 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, 146, 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, 142, 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, 147, 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, 143, 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, 242, 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, 150, 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, 141, 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, 204, 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, 132, 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, 174, 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, 254, 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, 162, 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, 175, 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, 198, 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, 169, 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, 186, 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, 161, 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, 168, 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, 155, 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, 156, 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, 248, 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, 192, 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, 242, 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, 180, 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, 236, 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, 216, 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, 212, 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, 190, 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, 150, 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, 130, 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, 248, 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, 239, 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, 138, 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, 226, 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, 232, 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, 220, 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, 210, 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, 216, 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, 204, 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, 227, 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, 139, 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, 148, 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, 144, 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, 149, 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, 145, 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, 241, 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, 149, 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, 140, 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, 203, 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, 131, 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, 173, 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, 253, 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, 161, 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, 174, 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, 197, 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, 168, 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, 185, 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, 160, 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, 167, 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, 154, 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, 155, 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, 247, 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, 191, 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, 241, 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, 179, 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, 235, 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, 189, 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, 149, 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, 247, 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, 225, 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, 231, 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, 219, 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, 209, 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, 215, 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, 203, 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, 221, 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, 222, 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, 223, 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, 224, 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, 239, 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, 235, 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, 234, 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, 238, 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, 233, 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, 236, 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, 237, 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, 240, 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, 241, 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[300] = {
14473 32, // 0: BitWidth 32
14474 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
14475 0, 50, // 4: case 0x0: {
14476 OPC_SwitchField, 25, 7, // 6: switch Inst[31:25] {
14477 113, 12, // 9: case 0x71: {
14478 OPC_CheckPredicate, 150, 1, // 11: check predicate 150
14479 OPC_CheckField, 0, 7, 43, // 14: check Inst[6:0] == 0x2b
14480 OPC_Decode, 170, 124, 234, 1, // 18: decode to SMT_VMADOTU using decoder 234
14481 // 18: }
14482 115, 0, // 23: case 0x73: {
14483 OPC_SwitchField, 15, 1, // 25: switch Inst[15] {
14484 0, 12, // 28: case 0x0: {
14485 OPC_CheckPredicate, 150, 1, // 30: check predicate 150
14486 OPC_CheckField, 0, 7, 43, // 33: check Inst[6:0] == 0x2b
14487 OPC_Decode, 159, 124, 235, 1, // 37: decode to SMT_VMADOT1U using decoder 235
14488 // 37: }
14489 1, 0, // 42: case 0x1: {
14490 OPC_CheckPredicate, 150, 1, // 44: check predicate 150
14491 OPC_CheckField, 0, 7, 43, // 47: check Inst[6:0] == 0x2b
14492 OPC_Decode, 167, 124, 235, 1, // 51: decode to SMT_VMADOT3U using decoder 235
14493 // 51: }
14494 // 51: } // switch Inst[15]
14495 // 51: }
14496 // 51: } // switch Inst[31:25]
14497 // 51: }
14498 1, 50, // 56: case 0x1: {
14499 OPC_SwitchField, 25, 7, // 58: switch Inst[31:25] {
14500 113, 12, // 61: case 0x71: {
14501 OPC_CheckPredicate, 150, 1, // 63: check predicate 150
14502 OPC_CheckField, 0, 7, 43, // 66: check Inst[6:0] == 0x2b
14503 OPC_Decode, 171, 124, 234, 1, // 70: decode to SMT_VMADOTUS using decoder 234
14504 // 70: }
14505 115, 0, // 75: case 0x73: {
14506 OPC_SwitchField, 15, 1, // 77: switch Inst[15] {
14507 0, 12, // 80: case 0x0: {
14508 OPC_CheckPredicate, 150, 1, // 82: check predicate 150
14509 OPC_CheckField, 0, 7, 43, // 85: check Inst[6:0] == 0x2b
14510 OPC_Decode, 160, 124, 235, 1, // 89: decode to SMT_VMADOT1US using decoder 235
14511 // 89: }
14512 1, 0, // 94: case 0x1: {
14513 OPC_CheckPredicate, 150, 1, // 96: check predicate 150
14514 OPC_CheckField, 0, 7, 43, // 99: check Inst[6:0] == 0x2b
14515 OPC_Decode, 168, 124, 235, 1, // 103: decode to SMT_VMADOT3US using decoder 235
14516 // 103: }
14517 // 103: } // switch Inst[15]
14518 // 103: }
14519 // 103: } // switch Inst[31:25]
14520 // 103: }
14521 2, 50, // 108: case 0x2: {
14522 OPC_SwitchField, 25, 7, // 110: switch Inst[31:25] {
14523 113, 12, // 113: case 0x71: {
14524 OPC_CheckPredicate, 150, 1, // 115: check predicate 150
14525 OPC_CheckField, 0, 7, 43, // 118: check Inst[6:0] == 0x2b
14526 OPC_Decode, 169, 124, 234, 1, // 122: decode to SMT_VMADOTSU using decoder 234
14527 // 122: }
14528 115, 0, // 127: case 0x73: {
14529 OPC_SwitchField, 15, 1, // 129: switch Inst[15] {
14530 0, 12, // 132: case 0x0: {
14531 OPC_CheckPredicate, 150, 1, // 134: check predicate 150
14532 OPC_CheckField, 0, 7, 43, // 137: check Inst[6:0] == 0x2b
14533 OPC_Decode, 158, 124, 235, 1, // 141: decode to SMT_VMADOT1SU using decoder 235
14534 // 141: }
14535 1, 0, // 146: case 0x1: {
14536 OPC_CheckPredicate, 150, 1, // 148: check predicate 150
14537 OPC_CheckField, 0, 7, 43, // 151: check Inst[6:0] == 0x2b
14538 OPC_Decode, 166, 124, 235, 1, // 155: decode to SMT_VMADOT3SU using decoder 235
14539 // 155: }
14540 // 155: } // switch Inst[15]
14541 // 155: }
14542 // 155: } // switch Inst[31:25]
14543 // 155: }
14544 3, 50, // 160: case 0x3: {
14545 OPC_SwitchField, 25, 7, // 162: switch Inst[31:25] {
14546 113, 12, // 165: case 0x71: {
14547 OPC_CheckPredicate, 150, 1, // 167: check predicate 150
14548 OPC_CheckField, 0, 7, 43, // 170: check Inst[6:0] == 0x2b
14549 OPC_Decode, 156, 124, 234, 1, // 174: decode to SMT_VMADOT using decoder 234
14550 // 174: }
14551 115, 0, // 179: case 0x73: {
14552 OPC_SwitchField, 15, 1, // 181: switch Inst[15] {
14553 0, 12, // 184: case 0x0: {
14554 OPC_CheckPredicate, 150, 1, // 186: check predicate 150
14555 OPC_CheckField, 0, 7, 43, // 189: check Inst[6:0] == 0x2b
14556 OPC_Decode, 157, 124, 235, 1, // 193: decode to SMT_VMADOT1 using decoder 235
14557 // 193: }
14558 1, 0, // 198: case 0x1: {
14559 OPC_CheckPredicate, 150, 1, // 200: check predicate 150
14560 OPC_CheckField, 0, 7, 43, // 203: check Inst[6:0] == 0x2b
14561 OPC_Decode, 165, 124, 235, 1, // 207: decode to SMT_VMADOT3 using decoder 235
14562 // 207: }
14563 // 207: } // switch Inst[15]
14564 // 207: }
14565 // 207: } // switch Inst[31:25]
14566 // 207: }
14567 4, 20, // 212: case 0x4: {
14568 OPC_CheckPredicate, 150, 1, // 214: check predicate 150
14569 OPC_CheckField, 25, 7, 115, // 217: check Inst[31:25] == 0x73
14570 OPC_CheckField, 15, 1, 0, // 221: check Inst[15] == 0x0
14571 OPC_CheckField, 0, 7, 43, // 225: check Inst[6:0] == 0x2b
14572 OPC_Decode, 163, 124, 235, 1, // 229: decode to SMT_VMADOT2U using decoder 235
14573 // 229: }
14574 5, 20, // 234: case 0x5: {
14575 OPC_CheckPredicate, 150, 1, // 236: check predicate 150
14576 OPC_CheckField, 25, 7, 115, // 239: check Inst[31:25] == 0x73
14577 OPC_CheckField, 15, 1, 0, // 243: check Inst[15] == 0x0
14578 OPC_CheckField, 0, 7, 43, // 247: check Inst[6:0] == 0x2b
14579 OPC_Decode, 164, 124, 235, 1, // 251: decode to SMT_VMADOT2US using decoder 235
14580 // 251: }
14581 6, 20, // 256: case 0x6: {
14582 OPC_CheckPredicate, 150, 1, // 258: check predicate 150
14583 OPC_CheckField, 25, 7, 115, // 261: check Inst[31:25] == 0x73
14584 OPC_CheckField, 15, 1, 0, // 265: check Inst[15] == 0x0
14585 OPC_CheckField, 0, 7, 43, // 269: check Inst[6:0] == 0x2b
14586 OPC_Decode, 162, 124, 235, 1, // 273: decode to SMT_VMADOT2SU using decoder 235
14587 // 273: }
14588 7, 0, // 278: case 0x7: {
14589 OPC_CheckPredicate, 150, 1, // 280: check predicate 150
14590 OPC_CheckField, 25, 7, 115, // 283: check Inst[31:25] == 0x73
14591 OPC_CheckField, 15, 1, 0, // 287: check Inst[15] == 0x0
14592 OPC_CheckField, 0, 7, 43, // 291: check Inst[6:0] == 0x2b
14593 OPC_Decode, 161, 124, 235, 1, // 295: decode to SMT_VMADOT2 using decoder 235
14594 // 295: }
14595 // 295: } // switch Inst[14:12]
14596};
14597static const uint8_t DecoderTableXSfcease32[16] = {
14598 32, // 0: BitWidth 32
14599 OPC_CheckPredicate, 151, 1, // 1: check predicate 151
14600 OPC_CheckField, 0, 32, 243, 128, 192, 130, 3,
14601 // 4: check Inst[31:0] == 0x30500073
14602 OPC_Decode, 174, 123, 14, // 12: decode to SF_CEASE using decoder 14
14603};
14604static const uint8_t DecoderTableXSfsystem32[32] = {
14605 32, // 0: BitWidth 32
14606 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
14607 192, 31, 11, // 4: case 0xfc0: {
14608 OPC_CheckPredicate, 152, 1, // 7: check predicate 152
14609 OPC_CheckField, 0, 15, 115, // 10: check Inst[14:0] == 0x73
14610 OPC_Decode, 175, 123, 15, // 14: decode to SF_CFLUSH_D_L1 using decoder 15
14611 // 14: }
14612 194, 31, 0, // 18: case 0xfc2: {
14613 OPC_CheckPredicate, 153, 1, // 21: check predicate 153
14614 OPC_CheckField, 0, 15, 115, // 24: check Inst[14:0] == 0x73
14615 OPC_Decode, 173, 123, 15, // 28: decode to SF_CDISCARD_D_L1 using decoder 15
14616 // 28: }
14617 // 28: } // switch Inst[31:20]
14618};
14619static const uint8_t DecoderTableXSfvector32[1129] = {
14620 32, // 0: BitWidth 32
14621 OPC_SwitchField, 28, 4, // 1: switch Inst[31:28] {
14622 0, 69, // 4: case 0x0: {
14623 OPC_SwitchField, 12, 3, // 6: switch Inst[14:12] {
14624 3, 31, // 9: case 0x3: {
14625 OPC_SwitchField, 25, 1, // 11: switch Inst[25] {
14626 0, 12, // 14: case 0x0: {
14627 OPC_CheckPredicate, 154, 1, // 16: check predicate 154
14628 OPC_CheckField, 0, 7, 91, // 19: check Inst[6:0] == 0x5b
14629 OPC_Decode, 198, 123, 236, 1, // 23: decode to SF_VC_V_I using decoder 236
14630 // 23: }
14631 1, 0, // 28: case 0x1: {
14632 OPC_CheckPredicate, 154, 1, // 30: check predicate 154
14633 OPC_CheckField, 0, 7, 91, // 33: check Inst[6:0] == 0x5b
14634 OPC_Decode, 188, 123, 237, 1, // 37: decode to SF_VC_I using decoder 237
14635 // 37: }
14636 // 37: } // switch Inst[25]
14637 // 37: }
14638 4, 0, // 42: case 0x4: {
14639 OPC_SwitchField, 25, 1, // 44: switch Inst[25] {
14640 0, 12, // 47: case 0x0: {
14641 OPC_CheckPredicate, 154, 1, // 49: check predicate 154
14642 OPC_CheckField, 0, 7, 91, // 52: check Inst[6:0] == 0x5b
14643 OPC_Decode, 205, 123, 238, 1, // 56: decode to SF_VC_V_X using decoder 238
14644 // 56: }
14645 1, 0, // 61: case 0x1: {
14646 OPC_CheckPredicate, 154, 1, // 63: check predicate 154
14647 OPC_CheckField, 0, 7, 91, // 66: check Inst[6:0] == 0x5b
14648 OPC_Decode, 209, 123, 239, 1, // 70: decode to SF_VC_X using decoder 239
14649 // 70: }
14650 // 70: } // switch Inst[25]
14651 // 70: }
14652 // 70: } // switch Inst[14:12]
14653 // 70: }
14654 1, 33, // 75: case 0x1: {
14655 OPC_SwitchField, 0, 15, // 77: switch Inst[14:0] {
14656 135, 224, 1, 11, // 80: case 0x7007: {
14657 OPC_CheckPredicate, 155, 1, // 84: check predicate 155
14658 OPC_CheckField, 25, 3, 1, // 87: check Inst[27:25] == 0x1
14659 OPC_Decode, 221, 123, 57, // 91: decode to SF_VLTE8 using decoder 57
14660 // 91: }
14661 167, 224, 1, 0, // 95: case 0x7027: {
14662 OPC_CheckPredicate, 155, 1, // 99: check predicate 155
14663 OPC_CheckField, 25, 3, 1, // 102: check Inst[27:25] == 0x1
14664 OPC_Decode, 236, 123, 57, // 106: decode to SF_VSTE8 using decoder 57
14665 // 106: }
14666 // 106: } // switch Inst[14:0]
14667 // 106: }
14668 2, 143, 1, // 110: case 0x2: {
14669 OPC_SwitchField, 12, 3, // 113: switch Inst[14:12] {
14670 0, 31, // 116: case 0x0: {
14671 OPC_SwitchField, 25, 1, // 118: switch Inst[25] {
14672 0, 12, // 121: case 0x0: {
14673 OPC_CheckPredicate, 154, 1, // 123: check predicate 154
14674 OPC_CheckField, 0, 7, 91, // 126: check Inst[6:0] == 0x5b
14675 OPC_Decode, 202, 123, 240, 1, // 130: decode to SF_VC_V_VV using decoder 240
14676 // 130: }
14677 1, 0, // 135: case 0x1: {
14678 OPC_CheckPredicate, 154, 1, // 137: check predicate 154
14679 OPC_CheckField, 0, 7, 91, // 140: check Inst[6:0] == 0x5b
14680 OPC_Decode, 192, 123, 241, 1, // 144: decode to SF_VC_VV using decoder 241
14681 // 144: }
14682 // 144: } // switch Inst[25]
14683 // 144: }
14684 3, 31, // 149: case 0x3: {
14685 OPC_SwitchField, 25, 1, // 151: switch Inst[25] {
14686 0, 12, // 154: case 0x0: {
14687 OPC_CheckPredicate, 154, 1, // 156: check predicate 154
14688 OPC_CheckField, 0, 7, 91, // 159: check Inst[6:0] == 0x5b
14689 OPC_Decode, 199, 123, 242, 1, // 163: decode to SF_VC_V_IV using decoder 242
14690 // 163: }
14691 1, 0, // 168: case 0x1: {
14692 OPC_CheckPredicate, 154, 1, // 170: check predicate 154
14693 OPC_CheckField, 0, 7, 91, // 173: check Inst[6:0] == 0x5b
14694 OPC_Decode, 189, 123, 243, 1, // 177: decode to SF_VC_IV using decoder 243
14695 // 177: }
14696 // 177: } // switch Inst[25]
14697 // 177: }
14698 4, 31, // 182: case 0x4: {
14699 OPC_SwitchField, 25, 1, // 184: switch Inst[25] {
14700 0, 12, // 187: case 0x0: {
14701 OPC_CheckPredicate, 154, 1, // 189: check predicate 154
14702 OPC_CheckField, 0, 7, 91, // 192: check Inst[6:0] == 0x5b
14703 OPC_Decode, 206, 123, 244, 1, // 196: decode to SF_VC_V_XV using decoder 244
14704 // 196: }
14705 1, 0, // 201: case 0x1: {
14706 OPC_CheckPredicate, 154, 1, // 203: check predicate 154
14707 OPC_CheckField, 0, 7, 91, // 206: check Inst[6:0] == 0x5b
14708 OPC_Decode, 210, 123, 245, 1, // 210: decode to SF_VC_XV using decoder 245
14709 // 210: }
14710 // 210: } // switch Inst[25]
14711 // 210: }
14712 5, 0, // 215: case 0x5: {
14713 OPC_SwitchField, 25, 1, // 217: switch Inst[25] {
14714 0, 16, // 220: case 0x0: {
14715 OPC_CheckPredicate, 154, 1, // 222: check predicate 154
14716 OPC_CheckField, 27, 1, 1, // 225: check Inst[27] == 0x1
14717 OPC_CheckField, 0, 7, 91, // 229: check Inst[6:0] == 0x5b
14718 OPC_Decode, 195, 123, 246, 1, // 233: decode to SF_VC_V_FV using decoder 246
14719 // 233: }
14720 1, 0, // 238: case 0x1: {
14721 OPC_CheckPredicate, 154, 1, // 240: check predicate 154
14722 OPC_CheckField, 27, 1, 1, // 243: check Inst[27] == 0x1
14723 OPC_CheckField, 0, 7, 91, // 247: check Inst[6:0] == 0x5b
14724 OPC_Decode, 185, 123, 247, 1, // 251: decode to SF_VC_FV using decoder 247
14725 // 251: }
14726 // 251: } // switch Inst[25]
14727 // 251: }
14728 // 251: } // switch Inst[14:12]
14729 // 251: }
14730 3, 33, // 256: case 0x3: {
14731 OPC_SwitchField, 0, 15, // 258: switch Inst[14:0] {
14732 135, 224, 1, 11, // 261: case 0x7007: {
14733 OPC_CheckPredicate, 155, 1, // 265: check predicate 155
14734 OPC_CheckField, 25, 3, 1, // 268: check Inst[27:25] == 0x1
14735 OPC_Decode, 218, 123, 57, // 272: decode to SF_VLTE16 using decoder 57
14736 // 272: }
14737 167, 224, 1, 0, // 276: case 0x7027: {
14738 OPC_CheckPredicate, 155, 1, // 280: check predicate 155
14739 OPC_CheckField, 25, 3, 1, // 283: check Inst[27:25] == 0x1
14740 OPC_Decode, 233, 123, 57, // 287: decode to SF_VSTE16 using decoder 57
14741 // 287: }
14742 // 287: } // switch Inst[14:0]
14743 // 287: }
14744 4, 95, // 291: case 0x4: {
14745 OPC_SwitchField, 12, 3, // 293: switch Inst[14:12] {
14746 1, 37, // 296: case 0x1: {
14747 OPC_SwitchField, 15, 5, // 298: switch Inst[19:15] {
14748 6, 15, // 301: case 0x6: {
14749 OPC_CheckPredicate, 156, 1, // 303: check predicate 156
14750 OPC_CheckField, 26, 2, 3, // 306: check Inst[27:26] == 0x3
14751 OPC_CheckField, 0, 7, 87, // 310: check Inst[6:0] == 0x57
14752 OPC_Decode, 213, 123, 119, // 314: decode to SF_VFEXPA_V using decoder 119
14753 // 314: }
14754 7, 0, // 318: case 0x7: {
14755 OPC_CheckPredicate, 157, 1, // 320: check predicate 157
14756 OPC_CheckField, 26, 2, 3, // 323: check Inst[27:26] == 0x3
14757 OPC_CheckField, 0, 7, 87, // 327: check Inst[6:0] == 0x57
14758 OPC_Decode, 214, 123, 119, // 331: decode to SF_VFEXP_V using decoder 119
14759 // 331: }
14760 // 331: } // switch Inst[19:15]
14761 // 331: }
14762 6, 0, // 335: case 0x6: {
14763 OPC_SwitchField, 20, 8, // 337: switch Inst[27:20] {
14764 60, 15, // 340: case 0x3c: {
14765 OPC_CheckPredicate, 155, 1, // 342: check predicate 155
14766 OPC_CheckField, 15, 5, 0, // 345: check Inst[19:15] == 0x0
14767 OPC_CheckField, 0, 12, 87, // 349: check Inst[11:0] == 0x57
14768 OPC_Decode, 237, 123, 14, // 353: decode to SF_VTDISCARD using decoder 14
14769 // 353: }
14770 62, 16, // 357: case 0x3e: {
14771 OPC_CheckPredicate, 155, 1, // 359: check predicate 155
14772 OPC_CheckField, 15, 5, 0, // 362: check Inst[19:15] == 0x0
14773 OPC_CheckField, 0, 8, 87, // 366: check Inst[7:0] == 0x57
14774 OPC_Decode, 240, 123, 248, 1, // 370: decode to SF_VTZERO_T using decoder 248
14775 // 370: }
14776 63, 0, // 375: case 0x3f: {
14777 OPC_CheckPredicate, 155, 1, // 377: check predicate 155
14778 OPC_CheckField, 0, 7, 87, // 380: check Inst[6:0] == 0x57
14779 OPC_Decode, 239, 123, 2, // 384: decode to SF_VTMV_V_T using decoder 2
14780 // 384: }
14781 // 384: } // switch Inst[27:20]
14782 // 384: }
14783 // 384: } // switch Inst[14:12]
14784 // 384: }
14785 5, 49, // 388: case 0x5: {
14786 OPC_SwitchField, 0, 15, // 390: switch Inst[14:0] {
14787 215, 192, 1, 12, // 393: case 0x6057: {
14788 OPC_CheckPredicate, 155, 1, // 397: check predicate 155
14789 OPC_CheckField, 25, 3, 7, // 400: check Inst[27:25] == 0x7
14790 OPC_Decode, 238, 123, 249, 1, // 404: decode to SF_VTMV_T_V using decoder 249
14791 // 404: }
14792 135, 224, 1, 11, // 409: case 0x7007: {
14793 OPC_CheckPredicate, 155, 1, // 413: check predicate 155
14794 OPC_CheckField, 25, 3, 1, // 416: check Inst[27:25] == 0x1
14795 OPC_Decode, 219, 123, 57, // 420: decode to SF_VLTE32 using decoder 57
14796 // 420: }
14797 167, 224, 1, 0, // 424: case 0x7027: {
14798 OPC_CheckPredicate, 155, 1, // 428: check predicate 155
14799 OPC_CheckField, 25, 3, 1, // 431: check Inst[27:25] == 0x1
14800 OPC_Decode, 234, 123, 57, // 435: decode to SF_VSTE32 using decoder 57
14801 // 435: }
14802 // 435: } // switch Inst[14:0]
14803 // 435: }
14804 7, 33, // 439: case 0x7: {
14805 OPC_SwitchField, 0, 15, // 441: switch Inst[14:0] {
14806 135, 224, 1, 11, // 444: case 0x7007: {
14807 OPC_CheckPredicate, 155, 1, // 448: check predicate 155
14808 OPC_CheckField, 25, 3, 1, // 451: check Inst[27:25] == 0x1
14809 OPC_Decode, 220, 123, 57, // 455: decode to SF_VLTE64 using decoder 57
14810 // 455: }
14811 167, 224, 1, 0, // 459: case 0x7027: {
14812 OPC_CheckPredicate, 155, 1, // 463: check predicate 155
14813 OPC_CheckField, 25, 3, 1, // 466: check Inst[27:25] == 0x1
14814 OPC_Decode, 235, 123, 57, // 470: decode to SF_VSTE64 using decoder 57
14815 // 470: }
14816 // 470: } // switch Inst[14:0]
14817 // 470: }
14818 8, 95, // 474: case 0x8: {
14819 OPC_SwitchField, 26, 2, // 476: switch Inst[27:26] {
14820 1, 54, // 479: case 0x1: {
14821 OPC_SwitchField, 20, 6, // 481: switch Inst[25:20] {
14822 0, 15, // 484: case 0x0: {
14823 OPC_CheckPredicate, 155, 1, // 486: check predicate 155
14824 OPC_CheckField, 12, 3, 7, // 489: check Inst[14:12] == 0x7
14825 OPC_CheckField, 0, 7, 87, // 493: check Inst[6:0] == 0x57
14826 OPC_Decode, 232, 123, 17, // 497: decode to SF_VSETTN using decoder 17
14827 // 497: }
14828 1, 15, // 501: case 0x1: {
14829 OPC_CheckPredicate, 155, 1, // 503: check predicate 155
14830 OPC_CheckField, 12, 3, 7, // 506: check Inst[14:12] == 0x7
14831 OPC_CheckField, 0, 7, 87, // 510: check Inst[6:0] == 0x57
14832 OPC_Decode, 231, 123, 17, // 514: decode to SF_VSETTM using decoder 17
14833 // 514: }
14834 2, 0, // 518: case 0x2: {
14835 OPC_CheckPredicate, 155, 1, // 520: check predicate 155
14836 OPC_CheckField, 12, 3, 7, // 523: check Inst[14:12] == 0x7
14837 OPC_CheckField, 0, 7, 87, // 527: check Inst[6:0] == 0x57
14838 OPC_Decode, 230, 123, 17, // 531: decode to SF_VSETTK using decoder 17
14839 // 531: }
14840 // 531: } // switch Inst[25:20]
14841 // 531: }
14842 2, 16, // 535: case 0x2: {
14843 OPC_CheckPredicate, 158, 1, // 537: check predicate 158
14844 OPC_CheckField, 12, 3, 5, // 540: check Inst[14:12] == 0x5
14845 OPC_CheckField, 0, 7, 91, // 544: check Inst[6:0] == 0x5b
14846 OPC_Decode, 215, 123, 138, 1, // 548: decode to SF_VFNRCLIP_XU_F_QF using decoder 138
14847 // 548: }
14848 3, 0, // 553: case 0x3: {
14849 OPC_CheckPredicate, 158, 1, // 555: check predicate 158
14850 OPC_CheckField, 12, 3, 5, // 558: check Inst[14:12] == 0x5
14851 OPC_CheckField, 0, 7, 91, // 562: check Inst[6:0] == 0x5b
14852 OPC_Decode, 216, 123, 138, 1, // 566: decode to SF_VFNRCLIP_X_F_QF using decoder 138
14853 // 566: }
14854 // 566: } // switch Inst[27:26]
14855 // 566: }
14856 10, 143, 1, // 571: case 0xa: {
14857 OPC_SwitchField, 12, 3, // 574: switch Inst[14:12] {
14858 0, 31, // 577: case 0x0: {
14859 OPC_SwitchField, 25, 1, // 579: switch Inst[25] {
14860 0, 12, // 582: case 0x0: {
14861 OPC_CheckPredicate, 154, 1, // 584: check predicate 154
14862 OPC_CheckField, 0, 7, 91, // 587: check Inst[6:0] == 0x5b
14863 OPC_Decode, 203, 123, 250, 1, // 591: decode to SF_VC_V_VVV using decoder 250
14864 // 591: }
14865 1, 0, // 596: case 0x1: {
14866 OPC_CheckPredicate, 154, 1, // 598: check predicate 154
14867 OPC_CheckField, 0, 7, 91, // 601: check Inst[6:0] == 0x5b
14868 OPC_Decode, 193, 123, 251, 1, // 605: decode to SF_VC_VVV using decoder 251
14869 // 605: }
14870 // 605: } // switch Inst[25]
14871 // 605: }
14872 3, 31, // 610: case 0x3: {
14873 OPC_SwitchField, 25, 1, // 612: switch Inst[25] {
14874 0, 12, // 615: case 0x0: {
14875 OPC_CheckPredicate, 154, 1, // 617: check predicate 154
14876 OPC_CheckField, 0, 7, 91, // 620: check Inst[6:0] == 0x5b
14877 OPC_Decode, 200, 123, 252, 1, // 624: decode to SF_VC_V_IVV using decoder 252
14878 // 624: }
14879 1, 0, // 629: case 0x1: {
14880 OPC_CheckPredicate, 154, 1, // 631: check predicate 154
14881 OPC_CheckField, 0, 7, 91, // 634: check Inst[6:0] == 0x5b
14882 OPC_Decode, 190, 123, 253, 1, // 638: decode to SF_VC_IVV using decoder 253
14883 // 638: }
14884 // 638: } // switch Inst[25]
14885 // 638: }
14886 4, 31, // 643: case 0x4: {
14887 OPC_SwitchField, 25, 1, // 645: switch Inst[25] {
14888 0, 12, // 648: case 0x0: {
14889 OPC_CheckPredicate, 154, 1, // 650: check predicate 154
14890 OPC_CheckField, 0, 7, 91, // 653: check Inst[6:0] == 0x5b
14891 OPC_Decode, 207, 123, 254, 1, // 657: decode to SF_VC_V_XVV using decoder 254
14892 // 657: }
14893 1, 0, // 662: case 0x1: {
14894 OPC_CheckPredicate, 154, 1, // 664: check predicate 154
14895 OPC_CheckField, 0, 7, 91, // 667: check Inst[6:0] == 0x5b
14896 OPC_Decode, 211, 123, 255, 1, // 671: decode to SF_VC_XVV using decoder 255
14897 // 671: }
14898 // 671: } // switch Inst[25]
14899 // 671: }
14900 5, 0, // 676: case 0x5: {
14901 OPC_SwitchField, 25, 1, // 678: switch Inst[25] {
14902 0, 16, // 681: case 0x0: {
14903 OPC_CheckPredicate, 154, 1, // 683: check predicate 154
14904 OPC_CheckField, 27, 1, 1, // 686: check Inst[27] == 0x1
14905 OPC_CheckField, 0, 7, 91, // 690: check Inst[6:0] == 0x5b
14906 OPC_Decode, 196, 123, 128, 2, // 694: decode to SF_VC_V_FVV using decoder 256
14907 // 694: }
14908 1, 0, // 699: case 0x1: {
14909 OPC_CheckPredicate, 154, 1, // 701: check predicate 154
14910 OPC_CheckField, 27, 1, 1, // 704: check Inst[27] == 0x1
14911 OPC_CheckField, 0, 7, 91, // 708: check Inst[6:0] == 0x5b
14912 OPC_Decode, 186, 123, 129, 2, // 712: decode to SF_VC_FVV using decoder 257
14913 // 712: }
14914 // 712: } // switch Inst[25]
14915 // 712: }
14916 // 712: } // switch Inst[14:12]
14917 // 712: }
14918 11, 71, // 717: case 0xb: {
14919 OPC_SwitchField, 25, 3, // 719: switch Inst[27:25] {
14920 1, 15, // 722: case 0x1: {
14921 OPC_CheckPredicate, 159, 1, // 724: check predicate 159
14922 OPC_CheckField, 12, 3, 2, // 727: check Inst[14:12] == 0x2
14923 OPC_CheckField, 0, 7, 91, // 731: check Inst[6:0] == 0x5b
14924 OPC_Decode, 226, 123, 116, // 735: decode to SF_VQMACCU_2x8x2 using decoder 116
14925 // 735: }
14926 3, 15, // 739: case 0x3: {
14927 OPC_CheckPredicate, 159, 1, // 741: check predicate 159
14928 OPC_CheckField, 12, 3, 2, // 744: check Inst[14:12] == 0x2
14929 OPC_CheckField, 0, 7, 91, // 748: check Inst[6:0] == 0x5b
14930 OPC_Decode, 228, 123, 116, // 752: decode to SF_VQMACC_2x8x2 using decoder 116
14931 // 752: }
14932 5, 15, // 756: case 0x5: {
14933 OPC_CheckPredicate, 159, 1, // 758: check predicate 159
14934 OPC_CheckField, 12, 3, 2, // 761: check Inst[14:12] == 0x2
14935 OPC_CheckField, 0, 7, 91, // 765: check Inst[6:0] == 0x5b
14936 OPC_Decode, 224, 123, 116, // 769: decode to SF_VQMACCUS_2x8x2 using decoder 116
14937 // 769: }
14938 7, 0, // 773: case 0x7: {
14939 OPC_CheckPredicate, 159, 1, // 775: check predicate 159
14940 OPC_CheckField, 12, 3, 2, // 778: check Inst[14:12] == 0x2
14941 OPC_CheckField, 0, 7, 91, // 782: check Inst[6:0] == 0x5b
14942 OPC_Decode, 222, 123, 116, // 786: decode to SF_VQMACCSU_2x8x2 using decoder 116
14943 // 786: }
14944 // 786: } // switch Inst[27:25]
14945 // 786: }
14946 15, 0, // 790: case 0xf: {
14947 OPC_SwitchField, 12, 3, // 792: switch Inst[14:12] {
14948 0, 83, // 795: case 0x0: {
14949 OPC_SwitchField, 0, 7, // 797: switch Inst[6:0] {
14950 91, 23, // 800: case 0x5b: {
14951 OPC_SwitchField, 25, 1, // 802: switch Inst[25] {
14952 0, 8, // 805: case 0x0: {
14953 OPC_CheckPredicate, 154, 1, // 807: check predicate 154
14954 OPC_Decode, 204, 123, 250, 1, // 810: decode to SF_VC_V_VVW using decoder 250
14955 // 810: }
14956 1, 0, // 815: case 0x1: {
14957 OPC_CheckPredicate, 154, 1, // 817: check predicate 154
14958 OPC_Decode, 194, 123, 251, 1, // 820: decode to SF_VC_VVW using decoder 251
14959 // 820: }
14960 // 820: } // switch Inst[25]
14961 // 820: }
14962 119, 0, // 825: case 0x77: {
14963 OPC_SwitchField, 7, 3, // 827: switch Inst[9:7] {
14964 0, 23, // 830: case 0x0: {
14965 OPC_SwitchField, 25, 3, // 832: switch Inst[27:25] {
14966 1, 8, // 835: case 0x1: {
14967 OPC_CheckPredicate, 160, 1, // 837: check predicate 160
14968 OPC_Decode, 184, 123, 130, 2, // 840: decode to SF_MM_U_U using decoder 258
14969 // 840: }
14970 3, 0, // 845: case 0x3: {
14971 OPC_CheckPredicate, 160, 1, // 847: check predicate 160
14972 OPC_Decode, 182, 123, 130, 2, // 850: decode to SF_MM_S_U using decoder 258
14973 // 850: }
14974 // 850: } // switch Inst[27:25]
14975 // 850: }
14976 1, 0, // 855: case 0x1: {
14977 OPC_SwitchField, 25, 3, // 857: switch Inst[27:25] {
14978 1, 8, // 860: case 0x1: {
14979 OPC_CheckPredicate, 160, 1, // 862: check predicate 160
14980 OPC_Decode, 183, 123, 130, 2, // 865: decode to SF_MM_U_S using decoder 258
14981 // 865: }
14982 3, 0, // 870: case 0x3: {
14983 OPC_CheckPredicate, 160, 1, // 872: check predicate 160
14984 OPC_Decode, 181, 123, 130, 2, // 875: decode to SF_MM_S_S using decoder 258
14985 // 875: }
14986 // 875: } // switch Inst[27:25]
14987 // 875: }
14988 // 875: } // switch Inst[9:7]
14989 // 875: }
14990 // 875: } // switch Inst[6:0]
14991 // 875: }
14992 1, 83, // 880: case 0x1: {
14993 OPC_SwitchField, 25, 3, // 882: switch Inst[27:25] {
14994 1, 26, // 885: case 0x1: {
14995 OPC_SwitchField, 0, 7, // 887: switch Inst[6:0] {
14996 91, 7, // 890: case 0x5b: {
14997 OPC_CheckPredicate, 161, 1, // 892: check predicate 161
14998 OPC_Decode, 217, 123, 116, // 895: decode to SF_VFWMACC_4x4x4 using decoder 116
14999 // 895: }
15000 119, 0, // 899: case 0x77: {
15001 OPC_CheckPredicate, 162, 1, // 901: check predicate 162
15002 OPC_CheckField, 7, 2, 0, // 904: check Inst[8:7] == 0x0
15003 OPC_Decode, 180, 123, 131, 2, // 908: decode to SF_MM_F_F using decoder 259
15004 // 908: }
15005 // 908: } // switch Inst[6:0]
15006 // 908: }
15007 5, 24, // 913: case 0x5: {
15008 OPC_SwitchField, 0, 10, // 915: switch Inst[9:0] {
15009 119, 8, // 918: case 0x77: {
15010 OPC_CheckPredicate, 163, 1, // 920: check predicate 163
15011 OPC_Decode, 179, 123, 130, 2, // 923: decode to SF_MM_E5M2_E5M2 using decoder 258
15012 // 923: }
15013 247, 1, 0, // 928: case 0xf7: {
15014 OPC_CheckPredicate, 163, 1, // 931: check predicate 163
15015 OPC_Decode, 178, 123, 130, 2, // 934: decode to SF_MM_E5M2_E4M3 using decoder 258
15016 // 934: }
15017 // 934: } // switch Inst[9:0]
15018 // 934: }
15019 7, 0, // 939: case 0x7: {
15020 OPC_SwitchField, 0, 10, // 941: switch Inst[9:0] {
15021 119, 8, // 944: case 0x77: {
15022 OPC_CheckPredicate, 163, 1, // 946: check predicate 163
15023 OPC_Decode, 177, 123, 130, 2, // 949: decode to SF_MM_E4M3_E5M2 using decoder 258
15024 // 949: }
15025 247, 1, 0, // 954: case 0xf7: {
15026 OPC_CheckPredicate, 163, 1, // 957: check predicate 163
15027 OPC_Decode, 176, 123, 130, 2, // 960: decode to SF_MM_E4M3_E4M3 using decoder 258
15028 // 960: }
15029 // 960: } // switch Inst[9:0]
15030 // 960: }
15031 // 960: } // switch Inst[27:25]
15032 // 960: }
15033 2, 55, // 965: case 0x2: {
15034 OPC_SwitchField, 25, 3, // 967: switch Inst[27:25] {
15035 1, 11, // 970: case 0x1: {
15036 OPC_CheckPredicate, 164, 1, // 972: check predicate 164
15037 OPC_CheckField, 0, 7, 91, // 975: check Inst[6:0] == 0x5b
15038 OPC_Decode, 227, 123, 116, // 979: decode to SF_VQMACCU_4x8x4 using decoder 116
15039 // 979: }
15040 3, 11, // 983: case 0x3: {
15041 OPC_CheckPredicate, 164, 1, // 985: check predicate 164
15042 OPC_CheckField, 0, 7, 91, // 988: check Inst[6:0] == 0x5b
15043 OPC_Decode, 229, 123, 116, // 992: decode to SF_VQMACC_4x8x4 using decoder 116
15044 // 992: }
15045 5, 11, // 996: case 0x5: {
15046 OPC_CheckPredicate, 164, 1, // 998: check predicate 164
15047 OPC_CheckField, 0, 7, 91, // 1001: check Inst[6:0] == 0x5b
15048 OPC_Decode, 225, 123, 116, // 1005: decode to SF_VQMACCUS_4x8x4 using decoder 116
15049 // 1005: }
15050 7, 0, // 1009: case 0x7: {
15051 OPC_CheckPredicate, 164, 1, // 1011: check predicate 164
15052 OPC_CheckField, 0, 7, 91, // 1014: check Inst[6:0] == 0x5b
15053 OPC_Decode, 223, 123, 116, // 1018: decode to SF_VQMACCSU_4x8x4 using decoder 116
15054 // 1018: }
15055 // 1018: } // switch Inst[27:25]
15056 // 1018: }
15057 3, 31, // 1022: case 0x3: {
15058 OPC_SwitchField, 25, 1, // 1024: switch Inst[25] {
15059 0, 12, // 1027: case 0x0: {
15060 OPC_CheckPredicate, 154, 1, // 1029: check predicate 154
15061 OPC_CheckField, 0, 7, 91, // 1032: check Inst[6:0] == 0x5b
15062 OPC_Decode, 201, 123, 252, 1, // 1036: decode to SF_VC_V_IVW using decoder 252
15063 // 1036: }
15064 1, 0, // 1041: case 0x1: {
15065 OPC_CheckPredicate, 154, 1, // 1043: check predicate 154
15066 OPC_CheckField, 0, 7, 91, // 1046: check Inst[6:0] == 0x5b
15067 OPC_Decode, 191, 123, 253, 1, // 1050: decode to SF_VC_IVW using decoder 253
15068 // 1050: }
15069 // 1050: } // switch Inst[25]
15070 // 1050: }
15071 4, 31, // 1055: case 0x4: {
15072 OPC_SwitchField, 25, 1, // 1057: switch Inst[25] {
15073 0, 12, // 1060: case 0x0: {
15074 OPC_CheckPredicate, 154, 1, // 1062: check predicate 154
15075 OPC_CheckField, 0, 7, 91, // 1065: check Inst[6:0] == 0x5b
15076 OPC_Decode, 208, 123, 254, 1, // 1069: decode to SF_VC_V_XVW using decoder 254
15077 // 1069: }
15078 1, 0, // 1074: case 0x1: {
15079 OPC_CheckPredicate, 154, 1, // 1076: check predicate 154
15080 OPC_CheckField, 0, 7, 91, // 1079: check Inst[6:0] == 0x5b
15081 OPC_Decode, 212, 123, 255, 1, // 1083: decode to SF_VC_XVW using decoder 255
15082 // 1083: }
15083 // 1083: } // switch Inst[25]
15084 // 1083: }
15085 5, 0, // 1088: case 0x5: {
15086 OPC_SwitchField, 25, 1, // 1090: switch Inst[25] {
15087 0, 16, // 1093: case 0x0: {
15088 OPC_CheckPredicate, 154, 1, // 1095: check predicate 154
15089 OPC_CheckField, 27, 1, 1, // 1098: check Inst[27] == 0x1
15090 OPC_CheckField, 0, 7, 91, // 1102: check Inst[6:0] == 0x5b
15091 OPC_Decode, 197, 123, 128, 2, // 1106: decode to SF_VC_V_FVW using decoder 256
15092 // 1106: }
15093 1, 0, // 1111: case 0x1: {
15094 OPC_CheckPredicate, 154, 1, // 1113: check predicate 154
15095 OPC_CheckField, 27, 1, 1, // 1116: check Inst[27] == 0x1
15096 OPC_CheckField, 0, 7, 91, // 1120: check Inst[6:0] == 0x5b
15097 OPC_Decode, 187, 123, 129, 2, // 1124: decode to SF_VC_FVW using decoder 257
15098 // 1124: }
15099 // 1124: } // switch Inst[25]
15100 // 1124: }
15101 // 1124: } // switch Inst[14:12]
15102 // 1124: }
15103 // 1124: } // switch Inst[31:28]
15104};
15105static const uint8_t DecoderTableXTHead32[1598] = {
15106 32, // 0: BitWidth 32
15107 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
15108 0, 235, 2, // 4: case 0x0: {
15109 OPC_SwitchField, 25, 7, // 7: switch Inst[31:25] {
15110 0, 168, 1, // 10: case 0x0: {
15111 OPC_SwitchField, 15, 10, // 13: switch Inst[24:15] {
15112 32, 11, // 16: case 0x20: {
15113 OPC_CheckPredicate, 165, 1, // 18: check predicate 165
15114 OPC_CheckField, 0, 12, 11, // 21: check Inst[11:0] == 0xb
15115 OPC_Decode, 212, 124, 14, // 25: decode to TH_DCACHE_CALL using decoder 14
15116 // 25: }
15117 64, 11, // 29: case 0x40: {
15118 OPC_CheckPredicate, 165, 1, // 31: check predicate 165
15119 OPC_CheckField, 0, 12, 11, // 34: check Inst[11:0] == 0xb
15120 OPC_Decode, 222, 124, 14, // 38: decode to TH_DCACHE_IALL using decoder 14
15121 // 38: }
15122 96, 11, // 42: case 0x60: {
15123 OPC_CheckPredicate, 165, 1, // 44: check predicate 165
15124 OPC_CheckField, 0, 12, 11, // 47: check Inst[11:0] == 0xb
15125 OPC_Decode, 213, 124, 14, // 51: decode to TH_DCACHE_CIALL using decoder 14
15126 // 51: }
15127 128, 4, 11, // 55: case 0x200: {
15128 OPC_CheckPredicate, 165, 1, // 58: check predicate 165
15129 OPC_CheckField, 0, 12, 11, // 61: check Inst[11:0] == 0xb
15130 OPC_Decode, 238, 124, 14, // 65: decode to TH_ICACHE_IALL using decoder 14
15131 // 65: }
15132 160, 4, 11, // 69: case 0x220: {
15133 OPC_CheckPredicate, 165, 1, // 72: check predicate 165
15134 OPC_CheckField, 0, 12, 11, // 75: check Inst[11:0] == 0xb
15135 OPC_Decode, 239, 124, 14, // 79: decode to TH_ICACHE_IALLS using decoder 14
15136 // 79: }
15137 160, 5, 11, // 83: case 0x2a0: {
15138 OPC_CheckPredicate, 165, 1, // 86: check predicate 165
15139 OPC_CheckField, 0, 12, 11, // 89: check Inst[11:0] == 0xb
15140 OPC_Decode, 242, 124, 14, // 93: decode to TH_L2CACHE_CALL using decoder 14
15141 // 93: }
15142 192, 5, 11, // 97: case 0x2c0: {
15143 OPC_CheckPredicate, 165, 1, // 100: check predicate 165
15144 OPC_CheckField, 0, 12, 11, // 103: check Inst[11:0] == 0xb
15145 OPC_Decode, 244, 124, 14, // 107: decode to TH_L2CACHE_IALL using decoder 14
15146 // 107: }
15147 224, 5, 11, // 111: case 0x2e0: {
15148 OPC_CheckPredicate, 165, 1, // 114: check predicate 165
15149 OPC_CheckField, 0, 12, 11, // 117: check Inst[11:0] == 0xb
15150 OPC_Decode, 243, 124, 14, // 121: decode to TH_L2CACHE_CIALL using decoder 14
15151 // 121: }
15152 128, 6, 11, // 125: case 0x300: {
15153 OPC_CheckPredicate, 166, 1, // 128: check predicate 166
15154 OPC_CheckField, 0, 12, 11, // 131: check Inst[11:0] == 0xb
15155 OPC_Decode, 179, 125, 14, // 135: decode to TH_SYNC using decoder 14
15156 // 135: }
15157 160, 6, 11, // 139: case 0x320: {
15158 OPC_CheckPredicate, 166, 1, // 142: check predicate 166
15159 OPC_CheckField, 0, 12, 11, // 145: check Inst[11:0] == 0xb
15160 OPC_Decode, 182, 125, 14, // 149: decode to TH_SYNC_S using decoder 14
15161 // 149: }
15162 192, 6, 11, // 153: case 0x340: {
15163 OPC_CheckPredicate, 166, 1, // 156: check predicate 166
15164 OPC_CheckField, 0, 12, 11, // 159: check Inst[11:0] == 0xb
15165 OPC_Decode, 180, 125, 14, // 163: decode to TH_SYNC_I using decoder 14
15166 // 163: }
15167 224, 6, 0, // 167: case 0x360: {
15168 OPC_CheckPredicate, 166, 1, // 170: check predicate 166
15169 OPC_CheckField, 0, 12, 11, // 173: check Inst[11:0] == 0xb
15170 OPC_Decode, 181, 125, 14, // 177: decode to TH_SYNC_IS using decoder 14
15171 // 177: }
15172 // 177: } // switch Inst[24:15]
15173 // 177: }
15174 1, 172, 1, // 181: case 0x1: {
15175 OPC_SwitchField, 20, 5, // 184: switch Inst[24:20] {
15176 1, 11, // 187: case 0x1: {
15177 OPC_CheckPredicate, 165, 1, // 189: check predicate 165
15178 OPC_CheckField, 0, 12, 11, // 192: check Inst[11:0] == 0xb
15179 OPC_Decode, 219, 124, 15, // 196: decode to TH_DCACHE_CSW using decoder 15
15180 // 196: }
15181 2, 11, // 200: case 0x2: {
15182 OPC_CheckPredicate, 165, 1, // 202: check predicate 165
15183 OPC_CheckField, 0, 12, 11, // 205: check Inst[11:0] == 0xb
15184 OPC_Decode, 224, 124, 15, // 209: decode to TH_DCACHE_ISW using decoder 15
15185 // 209: }
15186 3, 11, // 213: case 0x3: {
15187 OPC_CheckPredicate, 165, 1, // 215: check predicate 165
15188 OPC_CheckField, 0, 12, 11, // 218: check Inst[11:0] == 0xb
15189 OPC_Decode, 215, 124, 15, // 222: decode to TH_DCACHE_CISW using decoder 15
15190 // 222: }
15191 4, 11, // 226: case 0x4: {
15192 OPC_CheckPredicate, 165, 1, // 228: check predicate 165
15193 OPC_CheckField, 0, 12, 11, // 231: check Inst[11:0] == 0xb
15194 OPC_Decode, 221, 124, 15, // 235: decode to TH_DCACHE_CVAL1 using decoder 15
15195 // 235: }
15196 5, 11, // 239: case 0x5: {
15197 OPC_CheckPredicate, 165, 1, // 241: check predicate 165
15198 OPC_CheckField, 0, 12, 11, // 244: check Inst[11:0] == 0xb
15199 OPC_Decode, 220, 124, 15, // 248: decode to TH_DCACHE_CVA using decoder 15
15200 // 248: }
15201 6, 11, // 252: case 0x6: {
15202 OPC_CheckPredicate, 165, 1, // 254: check predicate 165
15203 OPC_CheckField, 0, 12, 11, // 257: check Inst[11:0] == 0xb
15204 OPC_Decode, 225, 124, 15, // 261: decode to TH_DCACHE_IVA using decoder 15
15205 // 261: }
15206 7, 11, // 265: case 0x7: {
15207 OPC_CheckPredicate, 165, 1, // 267: check predicate 165
15208 OPC_CheckField, 0, 12, 11, // 270: check Inst[11:0] == 0xb
15209 OPC_Decode, 216, 124, 15, // 274: decode to TH_DCACHE_CIVA using decoder 15
15210 // 274: }
15211 8, 11, // 278: case 0x8: {
15212 OPC_CheckPredicate, 165, 1, // 280: check predicate 165
15213 OPC_CheckField, 0, 12, 11, // 283: check Inst[11:0] == 0xb
15214 OPC_Decode, 218, 124, 15, // 287: decode to TH_DCACHE_CPAL1 using decoder 15
15215 // 287: }
15216 9, 11, // 291: case 0x9: {
15217 OPC_CheckPredicate, 165, 1, // 293: check predicate 165
15218 OPC_CheckField, 0, 12, 11, // 296: check Inst[11:0] == 0xb
15219 OPC_Decode, 217, 124, 15, // 300: decode to TH_DCACHE_CPA using decoder 15
15220 // 300: }
15221 10, 11, // 304: case 0xa: {
15222 OPC_CheckPredicate, 165, 1, // 306: check predicate 165
15223 OPC_CheckField, 0, 12, 11, // 309: check Inst[11:0] == 0xb
15224 OPC_Decode, 223, 124, 15, // 313: decode to TH_DCACHE_IPA using decoder 15
15225 // 313: }
15226 11, 11, // 317: case 0xb: {
15227 OPC_CheckPredicate, 165, 1, // 319: check predicate 165
15228 OPC_CheckField, 0, 12, 11, // 322: check Inst[11:0] == 0xb
15229 OPC_Decode, 214, 124, 15, // 326: decode to TH_DCACHE_CIPA using decoder 15
15230 // 326: }
15231 16, 11, // 330: case 0x10: {
15232 OPC_CheckPredicate, 165, 1, // 332: check predicate 165
15233 OPC_CheckField, 0, 12, 11, // 335: check Inst[11:0] == 0xb
15234 OPC_Decode, 241, 124, 15, // 339: decode to TH_ICACHE_IVA using decoder 15
15235 // 339: }
15236 24, 0, // 343: case 0x18: {
15237 OPC_CheckPredicate, 165, 1, // 345: check predicate 165
15238 OPC_CheckField, 0, 12, 11, // 348: check Inst[11:0] == 0xb
15239 OPC_Decode, 240, 124, 15, // 352: decode to TH_ICACHE_IPA using decoder 15
15240 // 352: }
15241 // 352: } // switch Inst[24:20]
15242 // 352: }
15243 2, 0, // 356: case 0x2: {
15244 OPC_CheckPredicate, 166, 1, // 358: check predicate 166
15245 OPC_CheckField, 0, 12, 11, // 361: check Inst[11:0] == 0xb
15246 OPC_Decode, 163, 125, 151, 1, // 365: decode to TH_SFENCE_VMAS using decoder 151
15247 // 365: }
15248 // 365: } // switch Inst[31:25]
15249 // 365: }
15250 1, 134, 2, // 370: case 0x1: {
15251 OPC_SwitchField, 27, 5, // 373: switch Inst[31:27] {
15252 0, 12, // 376: case 0x0: {
15253 OPC_CheckPredicate, 167, 1, // 378: check predicate 167
15254 OPC_CheckField, 0, 7, 11, // 381: check Inst[6:0] == 0xb
15255 OPC_Decode, 211, 124, 132, 2, // 385: decode to TH_ADDSL using decoder 260
15256 // 385: }
15257 2, 33, // 390: case 0x2: {
15258 OPC_SwitchField, 26, 1, // 392: switch Inst[26] {
15259 0, 11, // 395: case 0x0: {
15260 OPC_CheckPredicate, 168, 1, // 397: check predicate 168
15261 OPC_CheckField, 0, 7, 11, // 400: check Inst[6:0] == 0xb
15262 OPC_Decode, 169, 125, 16, // 404: decode to TH_SRRI using decoder 16
15263 // 404: }
15264 1, 0, // 408: case 0x1: {
15265 OPC_CheckPredicate, 169, 1, // 410: check predicate 169
15266 OPC_CheckField, 25, 1, 0, // 413: check Inst[25] == 0x0
15267 OPC_CheckField, 0, 7, 11, // 417: check Inst[6:0] == 0xb
15268 OPC_Decode, 170, 125, 21, // 421: decode to TH_SRRIW using decoder 21
15269 // 421: }
15270 // 421: } // switch Inst[26]
15271 // 421: }
15272 4, 55, // 425: case 0x4: {
15273 OPC_SwitchField, 25, 2, // 427: switch Inst[26:25] {
15274 0, 11, // 430: case 0x0: {
15275 OPC_CheckPredicate, 170, 1, // 432: check predicate 170
15276 OPC_CheckField, 0, 7, 11, // 435: check Inst[6:0] == 0xb
15277 OPC_Decode, 148, 125, 59, // 439: decode to TH_MULA using decoder 59
15278 // 439: }
15279 1, 11, // 443: case 0x1: {
15280 OPC_CheckPredicate, 170, 1, // 445: check predicate 170
15281 OPC_CheckField, 0, 7, 11, // 448: check Inst[6:0] == 0xb
15282 OPC_Decode, 151, 125, 59, // 452: decode to TH_MULS using decoder 59
15283 // 452: }
15284 2, 11, // 456: case 0x2: {
15285 OPC_CheckPredicate, 171, 1, // 458: check predicate 171
15286 OPC_CheckField, 0, 7, 11, // 461: check Inst[6:0] == 0xb
15287 OPC_Decode, 150, 125, 59, // 465: decode to TH_MULAW using decoder 59
15288 // 465: }
15289 3, 0, // 469: case 0x3: {
15290 OPC_CheckPredicate, 171, 1, // 471: check predicate 171
15291 OPC_CheckField, 0, 7, 11, // 474: check Inst[6:0] == 0xb
15292 OPC_Decode, 153, 125, 59, // 478: decode to TH_MULSW using decoder 59
15293 // 478: }
15294 // 478: } // switch Inst[26:25]
15295 // 478: }
15296 5, 29, // 482: case 0x5: {
15297 OPC_SwitchField, 25, 2, // 484: switch Inst[26:25] {
15298 0, 11, // 487: case 0x0: {
15299 OPC_CheckPredicate, 170, 1, // 489: check predicate 170
15300 OPC_CheckField, 0, 7, 11, // 492: check Inst[6:0] == 0xb
15301 OPC_Decode, 149, 125, 59, // 496: decode to TH_MULAH using decoder 59
15302 // 496: }
15303 1, 0, // 500: case 0x1: {
15304 OPC_CheckPredicate, 170, 1, // 502: check predicate 170
15305 OPC_CheckField, 0, 7, 11, // 505: check Inst[6:0] == 0xb
15306 OPC_Decode, 152, 125, 59, // 509: decode to TH_MULSH using decoder 59
15307 // 509: }
15308 // 509: } // switch Inst[26:25]
15309 // 509: }
15310 8, 29, // 513: case 0x8: {
15311 OPC_SwitchField, 25, 2, // 515: switch Inst[26:25] {
15312 0, 11, // 518: case 0x0: {
15313 OPC_CheckPredicate, 172, 1, // 520: check predicate 172
15314 OPC_CheckField, 0, 7, 11, // 523: check Inst[6:0] == 0xb
15315 OPC_Decode, 154, 125, 59, // 527: decode to TH_MVEQZ using decoder 59
15316 // 527: }
15317 1, 0, // 531: case 0x1: {
15318 OPC_CheckPredicate, 172, 1, // 533: check predicate 172
15319 OPC_CheckField, 0, 7, 11, // 536: check Inst[6:0] == 0xb
15320 OPC_Decode, 155, 125, 59, // 540: decode to TH_MVNEZ using decoder 59
15321 // 540: }
15322 // 540: } // switch Inst[26:25]
15323 // 540: }
15324 16, 55, // 544: case 0x10: {
15325 OPC_SwitchField, 20, 7, // 546: switch Inst[26:20] {
15326 0, 11, // 549: case 0x0: {
15327 OPC_CheckPredicate, 168, 1, // 551: check predicate 168
15328 OPC_CheckField, 0, 7, 11, // 554: check Inst[6:0] == 0xb
15329 OPC_Decode, 184, 125, 17, // 558: decode to TH_TSTNBZ using decoder 17
15330 // 558: }
15331 32, 11, // 562: case 0x20: {
15332 OPC_CheckPredicate, 168, 1, // 564: check predicate 168
15333 OPC_CheckField, 0, 7, 11, // 567: check Inst[6:0] == 0xb
15334 OPC_Decode, 156, 125, 17, // 571: decode to TH_REV using decoder 17
15335 // 571: }
15336 64, 11, // 575: case 0x40: {
15337 OPC_CheckPredicate, 168, 1, // 577: check predicate 168
15338 OPC_CheckField, 0, 7, 11, // 580: check Inst[6:0] == 0xb
15339 OPC_Decode, 228, 124, 17, // 584: decode to TH_FF0 using decoder 17
15340 // 584: }
15341 96, 0, // 588: case 0x60: {
15342 OPC_CheckPredicate, 168, 1, // 590: check predicate 168
15343 OPC_CheckField, 0, 7, 11, // 593: check Inst[6:0] == 0xb
15344 OPC_Decode, 229, 124, 17, // 597: decode to TH_FF1 using decoder 17
15345 // 597: }
15346 // 597: } // switch Inst[26:20]
15347 // 597: }
15348 17, 15, // 601: case 0x11: {
15349 OPC_CheckPredicate, 173, 1, // 603: check predicate 173
15350 OPC_CheckField, 26, 1, 0, // 606: check Inst[26] == 0x0
15351 OPC_CheckField, 0, 7, 11, // 610: check Inst[6:0] == 0xb
15352 OPC_Decode, 183, 125, 16, // 614: decode to TH_TST using decoder 16
15353 // 614: }
15354 18, 0, // 618: case 0x12: {
15355 OPC_CheckPredicate, 169, 1, // 620: check predicate 169
15356 OPC_CheckField, 20, 7, 0, // 623: check Inst[26:20] == 0x0
15357 OPC_CheckField, 0, 7, 11, // 627: check Inst[6:0] == 0xb
15358 OPC_Decode, 157, 125, 17, // 631: decode to TH_REVW using decoder 17
15359 // 631: }
15360 // 631: } // switch Inst[31:27]
15361 // 631: }
15362 2, 12, // 635: case 0x2: {
15363 OPC_CheckPredicate, 168, 1, // 637: check predicate 168
15364 OPC_CheckField, 0, 7, 11, // 640: check Inst[6:0] == 0xb
15365 OPC_Decode, 226, 124, 206, 1, // 644: decode to TH_EXT using decoder 206
15366 // 644: }
15367 3, 12, // 649: case 0x3: {
15368 OPC_CheckPredicate, 168, 1, // 651: check predicate 168
15369 OPC_CheckField, 0, 7, 11, // 654: check Inst[6:0] == 0xb
15370 OPC_Decode, 227, 124, 206, 1, // 658: decode to TH_EXTU using decoder 206
15371 // 658: }
15372 4, 181, 3, // 663: case 0x4: {
15373 OPC_SwitchField, 27, 5, // 666: switch Inst[31:27] {
15374 0, 12, // 669: case 0x0: {
15375 OPC_CheckPredicate, 174, 1, // 671: check predicate 174
15376 OPC_CheckField, 0, 7, 11, // 674: check Inst[6:0] == 0xb
15377 OPC_Decode, 128, 125, 132, 2, // 678: decode to TH_LRB using decoder 260
15378 // 678: }
15379 1, 12, // 683: case 0x1: {
15380 OPC_CheckPredicate, 174, 1, // 685: check predicate 174
15381 OPC_CheckField, 0, 7, 11, // 688: check Inst[6:0] == 0xb
15382 OPC_Decode, 246, 124, 133, 2, // 692: decode to TH_LBIB using decoder 261
15383 // 692: }
15384 2, 12, // 697: case 0x2: {
15385 OPC_CheckPredicate, 174, 1, // 699: check predicate 174
15386 OPC_CheckField, 0, 7, 11, // 702: check Inst[6:0] == 0xb
15387 OPC_Decode, 135, 125, 132, 2, // 706: decode to TH_LURB using decoder 260
15388 // 706: }
15389 3, 12, // 711: case 0x3: {
15390 OPC_CheckPredicate, 174, 1, // 713: check predicate 174
15391 OPC_CheckField, 0, 7, 11, // 716: check Inst[6:0] == 0xb
15392 OPC_Decode, 245, 124, 133, 2, // 720: decode to TH_LBIA using decoder 261
15393 // 720: }
15394 4, 12, // 725: case 0x4: {
15395 OPC_CheckPredicate, 174, 1, // 727: check predicate 174
15396 OPC_CheckField, 0, 7, 11, // 730: check Inst[6:0] == 0xb
15397 OPC_Decode, 131, 125, 132, 2, // 734: decode to TH_LRH using decoder 260
15398 // 734: }
15399 5, 12, // 739: case 0x5: {
15400 OPC_CheckPredicate, 174, 1, // 741: check predicate 174
15401 OPC_CheckField, 0, 7, 11, // 744: check Inst[6:0] == 0xb
15402 OPC_Decode, 253, 124, 133, 2, // 748: decode to TH_LHIB using decoder 261
15403 // 748: }
15404 6, 12, // 753: case 0x6: {
15405 OPC_CheckPredicate, 174, 1, // 755: check predicate 174
15406 OPC_CheckField, 0, 7, 11, // 758: check Inst[6:0] == 0xb
15407 OPC_Decode, 138, 125, 132, 2, // 762: decode to TH_LURH using decoder 260
15408 // 762: }
15409 7, 12, // 767: case 0x7: {
15410 OPC_CheckPredicate, 174, 1, // 769: check predicate 174
15411 OPC_CheckField, 0, 7, 11, // 772: check Inst[6:0] == 0xb
15412 OPC_Decode, 252, 124, 133, 2, // 776: decode to TH_LHIA using decoder 261
15413 // 776: }
15414 8, 12, // 781: case 0x8: {
15415 OPC_CheckPredicate, 174, 1, // 783: check predicate 174
15416 OPC_CheckField, 0, 7, 11, // 786: check Inst[6:0] == 0xb
15417 OPC_Decode, 133, 125, 132, 2, // 790: decode to TH_LRW using decoder 260
15418 // 790: }
15419 9, 12, // 795: case 0x9: {
15420 OPC_CheckPredicate, 174, 1, // 797: check predicate 174
15421 OPC_CheckField, 0, 7, 11, // 800: check Inst[6:0] == 0xb
15422 OPC_Decode, 144, 125, 133, 2, // 804: decode to TH_LWIB using decoder 261
15423 // 804: }
15424 10, 12, // 809: case 0xa: {
15425 OPC_CheckPredicate, 174, 1, // 811: check predicate 174
15426 OPC_CheckField, 0, 7, 11, // 814: check Inst[6:0] == 0xb
15427 OPC_Decode, 140, 125, 132, 2, // 818: decode to TH_LURW using decoder 260
15428 // 818: }
15429 11, 12, // 823: case 0xb: {
15430 OPC_CheckPredicate, 174, 1, // 825: check predicate 174
15431 OPC_CheckField, 0, 7, 11, // 828: check Inst[6:0] == 0xb
15432 OPC_Decode, 143, 125, 133, 2, // 832: decode to TH_LWIA using decoder 261
15433 // 832: }
15434 12, 12, // 837: case 0xc: {
15435 OPC_CheckPredicate, 175, 1, // 839: check predicate 175
15436 OPC_CheckField, 0, 7, 11, // 842: check Inst[6:0] == 0xb
15437 OPC_Decode, 130, 125, 132, 2, // 846: decode to TH_LRD using decoder 260
15438 // 846: }
15439 13, 12, // 851: case 0xd: {
15440 OPC_CheckPredicate, 175, 1, // 853: check predicate 175
15441 OPC_CheckField, 0, 7, 11, // 856: check Inst[6:0] == 0xb
15442 OPC_Decode, 251, 124, 133, 2, // 860: decode to TH_LDIB using decoder 261
15443 // 860: }
15444 14, 12, // 865: case 0xe: {
15445 OPC_CheckPredicate, 175, 1, // 867: check predicate 175
15446 OPC_CheckField, 0, 7, 11, // 870: check Inst[6:0] == 0xb
15447 OPC_Decode, 137, 125, 132, 2, // 874: decode to TH_LURD using decoder 260
15448 // 874: }
15449 15, 12, // 879: case 0xf: {
15450 OPC_CheckPredicate, 175, 1, // 881: check predicate 175
15451 OPC_CheckField, 0, 7, 11, // 884: check Inst[6:0] == 0xb
15452 OPC_Decode, 250, 124, 133, 2, // 888: decode to TH_LDIA using decoder 261
15453 // 888: }
15454 16, 12, // 893: case 0x10: {
15455 OPC_CheckPredicate, 174, 1, // 895: check predicate 174
15456 OPC_CheckField, 0, 7, 11, // 898: check Inst[6:0] == 0xb
15457 OPC_Decode, 129, 125, 132, 2, // 902: decode to TH_LRBU using decoder 260
15458 // 902: }
15459 17, 12, // 907: case 0x11: {
15460 OPC_CheckPredicate, 174, 1, // 909: check predicate 174
15461 OPC_CheckField, 0, 7, 11, // 912: check Inst[6:0] == 0xb
15462 OPC_Decode, 248, 124, 133, 2, // 916: decode to TH_LBUIB using decoder 261
15463 // 916: }
15464 18, 12, // 921: case 0x12: {
15465 OPC_CheckPredicate, 174, 1, // 923: check predicate 174
15466 OPC_CheckField, 0, 7, 11, // 926: check Inst[6:0] == 0xb
15467 OPC_Decode, 136, 125, 132, 2, // 930: decode to TH_LURBU using decoder 260
15468 // 930: }
15469 19, 12, // 935: case 0x13: {
15470 OPC_CheckPredicate, 174, 1, // 937: check predicate 174
15471 OPC_CheckField, 0, 7, 11, // 940: check Inst[6:0] == 0xb
15472 OPC_Decode, 247, 124, 133, 2, // 944: decode to TH_LBUIA using decoder 261
15473 // 944: }
15474 20, 12, // 949: case 0x14: {
15475 OPC_CheckPredicate, 174, 1, // 951: check predicate 174
15476 OPC_CheckField, 0, 7, 11, // 954: check Inst[6:0] == 0xb
15477 OPC_Decode, 132, 125, 132, 2, // 958: decode to TH_LRHU using decoder 260
15478 // 958: }
15479 21, 12, // 963: case 0x15: {
15480 OPC_CheckPredicate, 174, 1, // 965: check predicate 174
15481 OPC_CheckField, 0, 7, 11, // 968: check Inst[6:0] == 0xb
15482 OPC_Decode, 255, 124, 133, 2, // 972: decode to TH_LHUIB using decoder 261
15483 // 972: }
15484 22, 12, // 977: case 0x16: {
15485 OPC_CheckPredicate, 174, 1, // 979: check predicate 174
15486 OPC_CheckField, 0, 7, 11, // 982: check Inst[6:0] == 0xb
15487 OPC_Decode, 139, 125, 132, 2, // 986: decode to TH_LURHU using decoder 260
15488 // 986: }
15489 23, 12, // 991: case 0x17: {
15490 OPC_CheckPredicate, 174, 1, // 993: check predicate 174
15491 OPC_CheckField, 0, 7, 11, // 996: check Inst[6:0] == 0xb
15492 OPC_Decode, 254, 124, 133, 2, // 1000: decode to TH_LHUIA using decoder 261
15493 // 1000: }
15494 24, 12, // 1005: case 0x18: {
15495 OPC_CheckPredicate, 175, 1, // 1007: check predicate 175
15496 OPC_CheckField, 0, 7, 11, // 1010: check Inst[6:0] == 0xb
15497 OPC_Decode, 134, 125, 132, 2, // 1014: decode to TH_LRWU using decoder 260
15498 // 1014: }
15499 25, 12, // 1019: case 0x19: {
15500 OPC_CheckPredicate, 175, 1, // 1021: check predicate 175
15501 OPC_CheckField, 0, 7, 11, // 1024: check Inst[6:0] == 0xb
15502 OPC_Decode, 147, 125, 133, 2, // 1028: decode to TH_LWUIB using decoder 261
15503 // 1028: }
15504 26, 12, // 1033: case 0x1a: {
15505 OPC_CheckPredicate, 175, 1, // 1035: check predicate 175
15506 OPC_CheckField, 0, 7, 11, // 1038: check Inst[6:0] == 0xb
15507 OPC_Decode, 141, 125, 132, 2, // 1042: decode to TH_LURWU using decoder 260
15508 // 1042: }
15509 27, 12, // 1047: case 0x1b: {
15510 OPC_CheckPredicate, 175, 1, // 1049: check predicate 175
15511 OPC_CheckField, 0, 7, 11, // 1052: check Inst[6:0] == 0xb
15512 OPC_Decode, 146, 125, 133, 2, // 1056: decode to TH_LWUIA using decoder 261
15513 // 1056: }
15514 28, 12, // 1061: case 0x1c: {
15515 OPC_CheckPredicate, 176, 1, // 1063: check predicate 176
15516 OPC_CheckField, 0, 7, 11, // 1066: check Inst[6:0] == 0xb
15517 OPC_Decode, 142, 125, 134, 2, // 1070: decode to TH_LWD using decoder 262
15518 // 1070: }
15519 30, 12, // 1075: case 0x1e: {
15520 OPC_CheckPredicate, 176, 1, // 1077: check predicate 176
15521 OPC_CheckField, 0, 7, 11, // 1080: check Inst[6:0] == 0xb
15522 OPC_Decode, 145, 125, 134, 2, // 1084: decode to TH_LWUD using decoder 262
15523 // 1084: }
15524 31, 0, // 1089: case 0x1f: {
15525 OPC_CheckPredicate, 177, 1, // 1091: check predicate 177
15526 OPC_CheckField, 0, 7, 11, // 1094: check Inst[6:0] == 0xb
15527 OPC_Decode, 249, 124, 135, 2, // 1098: decode to TH_LDD using decoder 263
15528 // 1098: }
15529 // 1098: } // switch Inst[31:27]
15530 // 1098: }
15531 5, 255, 1, // 1103: case 0x5: {
15532 OPC_SwitchField, 27, 5, // 1106: switch Inst[31:27] {
15533 0, 12, // 1109: case 0x0: {
15534 OPC_CheckPredicate, 174, 1, // 1111: check predicate 174
15535 OPC_CheckField, 0, 7, 11, // 1114: check Inst[6:0] == 0xb
15536 OPC_Decode, 166, 125, 132, 2, // 1118: decode to TH_SRB using decoder 260
15537 // 1118: }
15538 1, 12, // 1123: case 0x1: {
15539 OPC_CheckPredicate, 174, 1, // 1125: check predicate 174
15540 OPC_CheckField, 0, 7, 11, // 1128: check Inst[6:0] == 0xb
15541 OPC_Decode, 159, 125, 136, 2, // 1132: decode to TH_SBIB using decoder 264
15542 // 1132: }
15543 2, 12, // 1137: case 0x2: {
15544 OPC_CheckPredicate, 174, 1, // 1139: check predicate 174
15545 OPC_CheckField, 0, 7, 11, // 1142: check Inst[6:0] == 0xb
15546 OPC_Decode, 172, 125, 132, 2, // 1146: decode to TH_SURB using decoder 260
15547 // 1146: }
15548 3, 12, // 1151: case 0x3: {
15549 OPC_CheckPredicate, 174, 1, // 1153: check predicate 174
15550 OPC_CheckField, 0, 7, 11, // 1156: check Inst[6:0] == 0xb
15551 OPC_Decode, 158, 125, 136, 2, // 1160: decode to TH_SBIA using decoder 264
15552 // 1160: }
15553 4, 12, // 1165: case 0x4: {
15554 OPC_CheckPredicate, 174, 1, // 1167: check predicate 174
15555 OPC_CheckField, 0, 7, 11, // 1170: check Inst[6:0] == 0xb
15556 OPC_Decode, 168, 125, 132, 2, // 1174: decode to TH_SRH using decoder 260
15557 // 1174: }
15558 5, 12, // 1179: case 0x5: {
15559 OPC_CheckPredicate, 174, 1, // 1181: check predicate 174
15560 OPC_CheckField, 0, 7, 11, // 1184: check Inst[6:0] == 0xb
15561 OPC_Decode, 165, 125, 136, 2, // 1188: decode to TH_SHIB using decoder 264
15562 // 1188: }
15563 6, 12, // 1193: case 0x6: {
15564 OPC_CheckPredicate, 174, 1, // 1195: check predicate 174
15565 OPC_CheckField, 0, 7, 11, // 1198: check Inst[6:0] == 0xb
15566 OPC_Decode, 174, 125, 132, 2, // 1202: decode to TH_SURH using decoder 260
15567 // 1202: }
15568 7, 12, // 1207: case 0x7: {
15569 OPC_CheckPredicate, 174, 1, // 1209: check predicate 174
15570 OPC_CheckField, 0, 7, 11, // 1212: check Inst[6:0] == 0xb
15571 OPC_Decode, 164, 125, 136, 2, // 1216: decode to TH_SHIA using decoder 264
15572 // 1216: }
15573 8, 12, // 1221: case 0x8: {
15574 OPC_CheckPredicate, 174, 1, // 1223: check predicate 174
15575 OPC_CheckField, 0, 7, 11, // 1226: check Inst[6:0] == 0xb
15576 OPC_Decode, 171, 125, 132, 2, // 1230: decode to TH_SRW using decoder 260
15577 // 1230: }
15578 9, 12, // 1235: case 0x9: {
15579 OPC_CheckPredicate, 174, 1, // 1237: check predicate 174
15580 OPC_CheckField, 0, 7, 11, // 1240: check Inst[6:0] == 0xb
15581 OPC_Decode, 178, 125, 136, 2, // 1244: decode to TH_SWIB using decoder 264
15582 // 1244: }
15583 10, 12, // 1249: case 0xa: {
15584 OPC_CheckPredicate, 174, 1, // 1251: check predicate 174
15585 OPC_CheckField, 0, 7, 11, // 1254: check Inst[6:0] == 0xb
15586 OPC_Decode, 175, 125, 132, 2, // 1258: decode to TH_SURW using decoder 260
15587 // 1258: }
15588 11, 12, // 1263: case 0xb: {
15589 OPC_CheckPredicate, 174, 1, // 1265: check predicate 174
15590 OPC_CheckField, 0, 7, 11, // 1268: check Inst[6:0] == 0xb
15591 OPC_Decode, 177, 125, 136, 2, // 1272: decode to TH_SWIA using decoder 264
15592 // 1272: }
15593 12, 12, // 1277: case 0xc: {
15594 OPC_CheckPredicate, 175, 1, // 1279: check predicate 175
15595 OPC_CheckField, 0, 7, 11, // 1282: check Inst[6:0] == 0xb
15596 OPC_Decode, 167, 125, 132, 2, // 1286: decode to TH_SRD using decoder 260
15597 // 1286: }
15598 13, 12, // 1291: case 0xd: {
15599 OPC_CheckPredicate, 175, 1, // 1293: check predicate 175
15600 OPC_CheckField, 0, 7, 11, // 1296: check Inst[6:0] == 0xb
15601 OPC_Decode, 162, 125, 136, 2, // 1300: decode to TH_SDIB using decoder 264
15602 // 1300: }
15603 14, 12, // 1305: case 0xe: {
15604 OPC_CheckPredicate, 175, 1, // 1307: check predicate 175
15605 OPC_CheckField, 0, 7, 11, // 1310: check Inst[6:0] == 0xb
15606 OPC_Decode, 173, 125, 132, 2, // 1314: decode to TH_SURD using decoder 260
15607 // 1314: }
15608 15, 12, // 1319: case 0xf: {
15609 OPC_CheckPredicate, 175, 1, // 1321: check predicate 175
15610 OPC_CheckField, 0, 7, 11, // 1324: check Inst[6:0] == 0xb
15611 OPC_Decode, 161, 125, 136, 2, // 1328: decode to TH_SDIA using decoder 264
15612 // 1328: }
15613 28, 12, // 1333: case 0x1c: {
15614 OPC_CheckPredicate, 176, 1, // 1335: check predicate 176
15615 OPC_CheckField, 0, 7, 11, // 1338: check Inst[6:0] == 0xb
15616 OPC_Decode, 176, 125, 134, 2, // 1342: decode to TH_SWD using decoder 262
15617 // 1342: }
15618 31, 0, // 1347: case 0x1f: {
15619 OPC_CheckPredicate, 177, 1, // 1349: check predicate 177
15620 OPC_CheckField, 0, 7, 11, // 1352: check Inst[6:0] == 0xb
15621 OPC_Decode, 160, 125, 135, 2, // 1356: decode to TH_SDD using decoder 263
15622 // 1356: }
15623 // 1356: } // switch Inst[31:27]
15624 // 1356: }
15625 6, 173, 1, // 1361: case 0x6: {
15626 OPC_SwitchField, 27, 5, // 1364: switch Inst[31:27] {
15627 8, 12, // 1367: case 0x8: {
15628 OPC_CheckPredicate, 178, 1, // 1369: check predicate 178
15629 OPC_CheckField, 0, 7, 11, // 1372: check Inst[6:0] == 0xb
15630 OPC_Decode, 231, 124, 137, 2, // 1376: decode to TH_FLRW using decoder 265
15631 // 1376: }
15632 10, 12, // 1381: case 0xa: {
15633 OPC_CheckPredicate, 179, 1, // 1383: check predicate 179
15634 OPC_CheckField, 0, 7, 11, // 1386: check Inst[6:0] == 0xb
15635 OPC_Decode, 233, 124, 137, 2, // 1390: decode to TH_FLURW using decoder 265
15636 // 1390: }
15637 12, 12, // 1395: case 0xc: {
15638 OPC_CheckPredicate, 180, 1, // 1397: check predicate 180
15639 OPC_CheckField, 0, 7, 11, // 1400: check Inst[6:0] == 0xb
15640 OPC_Decode, 230, 124, 138, 2, // 1404: decode to TH_FLRD using decoder 266
15641 // 1404: }
15642 14, 12, // 1409: case 0xe: {
15643 OPC_CheckPredicate, 181, 1, // 1411: check predicate 181
15644 OPC_CheckField, 0, 7, 11, // 1414: check Inst[6:0] == 0xb
15645 OPC_Decode, 232, 124, 138, 2, // 1418: decode to TH_FLURD using decoder 266
15646 // 1418: }
15647 16, 30, // 1423: case 0x10: {
15648 OPC_SwitchField, 26, 1, // 1425: switch Inst[26] {
15649 0, 11, // 1428: case 0x0: {
15650 OPC_CheckPredicate, 182, 1, // 1430: check predicate 182
15651 OPC_CheckField, 0, 7, 11, // 1433: check Inst[6:0] == 0xb
15652 OPC_Decode, 190, 125, 120, // 1437: decode to TH_VMAQA_VV using decoder 120
15653 // 1437: }
15654 1, 0, // 1441: case 0x1: {
15655 OPC_CheckPredicate, 182, 1, // 1443: check predicate 182
15656 OPC_CheckField, 0, 7, 11, // 1446: check Inst[6:0] == 0xb
15657 OPC_Decode, 191, 125, 145, 1, // 1450: decode to TH_VMAQA_VX using decoder 145
15658 // 1450: }
15659 // 1450: } // switch Inst[26]
15660 // 1450: }
15661 17, 30, // 1455: case 0x11: {
15662 OPC_SwitchField, 26, 1, // 1457: switch Inst[26] {
15663 0, 11, // 1460: case 0x0: {
15664 OPC_CheckPredicate, 182, 1, // 1462: check predicate 182
15665 OPC_CheckField, 0, 7, 11, // 1465: check Inst[6:0] == 0xb
15666 OPC_Decode, 188, 125, 120, // 1469: decode to TH_VMAQAU_VV using decoder 120
15667 // 1469: }
15668 1, 0, // 1473: case 0x1: {
15669 OPC_CheckPredicate, 182, 1, // 1475: check predicate 182
15670 OPC_CheckField, 0, 7, 11, // 1478: check Inst[6:0] == 0xb
15671 OPC_Decode, 189, 125, 145, 1, // 1482: decode to TH_VMAQAU_VX using decoder 145
15672 // 1482: }
15673 // 1482: } // switch Inst[26]
15674 // 1482: }
15675 18, 30, // 1487: case 0x12: {
15676 OPC_SwitchField, 26, 1, // 1489: switch Inst[26] {
15677 0, 11, // 1492: case 0x0: {
15678 OPC_CheckPredicate, 182, 1, // 1494: check predicate 182
15679 OPC_CheckField, 0, 7, 11, // 1497: check Inst[6:0] == 0xb
15680 OPC_Decode, 185, 125, 120, // 1501: decode to TH_VMAQASU_VV using decoder 120
15681 // 1501: }
15682 1, 0, // 1505: case 0x1: {
15683 OPC_CheckPredicate, 182, 1, // 1507: check predicate 182
15684 OPC_CheckField, 0, 7, 11, // 1510: check Inst[6:0] == 0xb
15685 OPC_Decode, 186, 125, 145, 1, // 1514: decode to TH_VMAQASU_VX using decoder 145
15686 // 1514: }
15687 // 1514: } // switch Inst[26]
15688 // 1514: }
15689 19, 0, // 1519: case 0x13: {
15690 OPC_CheckPredicate, 182, 1, // 1521: check predicate 182
15691 OPC_CheckField, 26, 1, 1, // 1524: check Inst[26] == 0x1
15692 OPC_CheckField, 0, 7, 11, // 1528: check Inst[6:0] == 0xb
15693 OPC_Decode, 187, 125, 145, 1, // 1532: decode to TH_VMAQAUS_VX using decoder 145
15694 // 1532: }
15695 // 1532: } // switch Inst[31:27]
15696 // 1532: }
15697 7, 0, // 1537: case 0x7: {
15698 OPC_SwitchField, 27, 5, // 1539: switch Inst[31:27] {
15699 8, 12, // 1542: case 0x8: {
15700 OPC_CheckPredicate, 178, 1, // 1544: check predicate 178
15701 OPC_CheckField, 0, 7, 11, // 1547: check Inst[6:0] == 0xb
15702 OPC_Decode, 235, 124, 137, 2, // 1551: decode to TH_FSRW using decoder 265
15703 // 1551: }
15704 10, 12, // 1556: case 0xa: {
15705 OPC_CheckPredicate, 179, 1, // 1558: check predicate 179
15706 OPC_CheckField, 0, 7, 11, // 1561: check Inst[6:0] == 0xb
15707 OPC_Decode, 237, 124, 137, 2, // 1565: decode to TH_FSURW using decoder 265
15708 // 1565: }
15709 12, 12, // 1570: case 0xc: {
15710 OPC_CheckPredicate, 180, 1, // 1572: check predicate 180
15711 OPC_CheckField, 0, 7, 11, // 1575: check Inst[6:0] == 0xb
15712 OPC_Decode, 234, 124, 138, 2, // 1579: decode to TH_FSRD using decoder 266
15713 // 1579: }
15714 14, 0, // 1584: case 0xe: {
15715 OPC_CheckPredicate, 181, 1, // 1586: check predicate 181
15716 OPC_CheckField, 0, 7, 11, // 1589: check Inst[6:0] == 0xb
15717 OPC_Decode, 236, 124, 138, 2, // 1593: decode to TH_FSURD using decoder 266
15718 // 1593: }
15719 // 1593: } // switch Inst[31:27]
15720 // 1593: }
15721 // 1593: } // switch Inst[14:12]
15722};
15723static const uint8_t DecoderTableXVentana32[40] = {
15724 32, // 0: BitWidth 32
15725 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
15726 6, 16, // 4: case 0x6: {
15727 OPC_CheckPredicate, 183, 1, // 6: check predicate 183
15728 OPC_CheckField, 25, 7, 0, // 9: check Inst[31:25] == 0x0
15729 OPC_CheckField, 0, 7, 123, // 13: check Inst[6:0] == 0x7b
15730 OPC_Decode, 237, 130, 1, 31, // 17: decode to VT_MASKC using decoder 31
15731 // 17: }
15732 7, 0, // 22: case 0x7: {
15733 OPC_CheckPredicate, 183, 1, // 24: check predicate 183
15734 OPC_CheckField, 25, 7, 0, // 27: check Inst[31:25] == 0x0
15735 OPC_CheckField, 0, 7, 123, // 31: check Inst[6:0] == 0x7b
15736 OPC_Decode, 238, 130, 1, 31, // 35: decode to VT_MASKCN using decoder 31
15737 // 35: }
15738 // 35: } // switch Inst[14:12]
15739};
15740static const uint8_t DecoderTableXqci32[1203] = {
15741 32, // 0: BitWidth 32
15742 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
15743 11, 143, 4, // 4: case 0xb: {
15744 OPC_SwitchField, 12, 3, // 7: switch Inst[14:12] {
15745 0, 22, // 10: case 0x0: {
15746 OPC_SwitchField, 31, 1, // 12: switch Inst[31] {
15747 0, 8, // 15: case 0x0: {
15748 OPC_CheckPredicate, 184, 1, // 17: check predicate 184
15749 OPC_Decode, 252, 122, 139, 2, // 20: decode to QC_WRAPI using decoder 267
15750 // 20: }
15751 1, 0, // 25: case 0x1: {
15752 OPC_CheckPredicate, 13, // 27: check predicate 13
15753 OPC_Decode, 186, 122, 140, 2, // 29: decode to QC_INSBRI using decoder 268
15754 // 29: }
15755 // 29: } // switch Inst[31]
15756 // 29: }
15757 1, 30, // 34: case 0x1: {
15758 OPC_SwitchField, 30, 2, // 36: switch Inst[31:30] {
15759 0, 7, // 39: case 0x0: {
15760 OPC_CheckPredicate, 13, // 41: check predicate 13
15761 OPC_Decode, 182, 122, 141, 2, // 43: decode to QC_INSBI using decoder 269
15762 // 43: }
15763 1, 7, // 48: case 0x1: {
15764 OPC_CheckPredicate, 13, // 50: check predicate 13
15765 OPC_Decode, 179, 122, 142, 2, // 52: decode to QC_INSB using decoder 270
15766 // 52: }
15767 2, 0, // 57: case 0x2: {
15768 OPC_CheckPredicate, 13, // 59: check predicate 13
15769 OPC_Decode, 180, 122, 142, 2, // 61: decode to QC_INSBH using decoder 270
15770 // 61: }
15771 // 61: } // switch Inst[31:30]
15772 // 61: }
15773 2, 39, // 66: case 0x2: {
15774 OPC_SwitchField, 30, 2, // 68: switch Inst[31:30] {
15775 0, 7, // 71: case 0x0: {
15776 OPC_CheckPredicate, 13, // 73: check predicate 13
15777 OPC_Decode, 153, 122, 143, 2, // 75: decode to QC_EXTU using decoder 271
15778 // 75: }
15779 1, 7, // 80: case 0x1: {
15780 OPC_CheckPredicate, 13, // 82: check predicate 13
15781 OPC_Decode, 144, 122, 143, 2, // 84: decode to QC_EXT using decoder 271
15782 // 84: }
15783 2, 7, // 89: case 0x2: {
15784 OPC_CheckPredicate, 13, // 91: check predicate 13
15785 OPC_Decode, 149, 122, 144, 2, // 93: decode to QC_EXTDU using decoder 272
15786 // 93: }
15787 3, 0, // 98: case 0x3: {
15788 OPC_CheckPredicate, 13, // 100: check predicate 13
15789 OPC_Decode, 145, 122, 144, 2, // 102: decode to QC_EXTD using decoder 272
15790 // 102: }
15791 // 102: } // switch Inst[31:30]
15792 // 102: }
15793 3, 183, 2, // 107: case 0x3: {
15794 OPC_SwitchField, 30, 2, // 110: switch Inst[31:30] {
15795 0, 168, 2, // 113: case 0x0: {
15796 OPC_SwitchField, 25, 5, // 116: switch Inst[29:25] {
15797 0, 20, // 119: case 0x0: {
15798 OPC_Scope, 11, // 121: try {
15799 OPC_CheckField, 20, 5, 0, // 123: check Inst[24:20] == 0x0
15800 OPC_CheckPredicate, 13, // 127: check predicate 13
15801 OPC_Decode, 245, 121, 145, 2, // 129: decode to QC_COMPRESS2 using decoder 273
15802 // 129: } else try {
15803 OPC_CheckPredicate, 13, // 134: check predicate 13
15804 OPC_Decode, 185, 122, 146, 2, // 136: decode to QC_INSBR using decoder 274
15805 // 136: }
15806 // 136: }
15807 1, 20, // 141: case 0x1: {
15808 OPC_Scope, 11, // 143: try {
15809 OPC_CheckField, 20, 5, 0, // 145: check Inst[24:20] == 0x0
15810 OPC_CheckPredicate, 13, // 149: check predicate 13
15811 OPC_Decode, 246, 121, 145, 2, // 151: decode to QC_COMPRESS3 using decoder 273
15812 // 151: } else try {
15813 OPC_CheckPredicate, 13, // 156: check predicate 13
15814 OPC_Decode, 181, 122, 146, 2, // 158: decode to QC_INSBHR using decoder 274
15815 // 158: }
15816 // 158: }
15817 2, 20, // 163: case 0x2: {
15818 OPC_Scope, 11, // 165: try {
15819 OPC_CheckField, 20, 5, 0, // 167: check Inst[24:20] == 0x0
15820 OPC_CheckPredicate, 13, // 171: check predicate 13
15821 OPC_Decode, 142, 122, 145, 2, // 173: decode to QC_EXPAND2 using decoder 273
15822 // 173: } else try {
15823 OPC_CheckPredicate, 13, // 178: check predicate 13
15824 OPC_Decode, 183, 122, 146, 2, // 180: decode to QC_INSBPR using decoder 274
15825 // 180: }
15826 // 180: }
15827 3, 20, // 185: case 0x3: {
15828 OPC_Scope, 11, // 187: try {
15829 OPC_CheckField, 20, 5, 0, // 189: check Inst[24:20] == 0x0
15830 OPC_CheckPredicate, 13, // 193: check predicate 13
15831 OPC_Decode, 143, 122, 145, 2, // 195: decode to QC_EXPAND3 using decoder 273
15832 // 195: } else try {
15833 OPC_CheckPredicate, 13, // 200: check predicate 13
15834 OPC_Decode, 184, 122, 146, 2, // 202: decode to QC_INSBPRH using decoder 274
15835 // 202: }
15836 // 202: }
15837 4, 20, // 207: case 0x4: {
15838 OPC_Scope, 11, // 209: try {
15839 OPC_CheckField, 20, 5, 0, // 211: check Inst[24:20] == 0x0
15840 OPC_CheckPredicate, 13, // 215: check predicate 13
15841 OPC_Decode, 234, 121, 145, 2, // 217: decode to QC_CLO using decoder 273
15842 // 217: } else try {
15843 OPC_CheckPredicate, 13, // 222: check predicate 13
15844 OPC_Decode, 152, 122, 147, 2, // 224: decode to QC_EXTDUR using decoder 275
15845 // 224: }
15846 // 224: }
15847 5, 20, // 229: case 0x5: {
15848 OPC_Scope, 11, // 231: try {
15849 OPC_CheckField, 20, 5, 0, // 233: check Inst[24:20] == 0x0
15850 OPC_CheckPredicate, 13, // 237: check predicate 13
15851 OPC_Decode, 249, 121, 145, 2, // 239: decode to QC_CTO using decoder 273
15852 // 239: } else try {
15853 OPC_CheckPredicate, 13, // 244: check predicate 13
15854 OPC_Decode, 148, 122, 147, 2, // 246: decode to QC_EXTDR using decoder 275
15855 // 246: }
15856 // 246: }
15857 6, 20, // 251: case 0x6: {
15858 OPC_Scope, 11, // 253: try {
15859 OPC_CheckField, 20, 5, 0, // 255: check Inst[24:20] == 0x0
15860 OPC_CheckPredicate, 13, // 259: check predicate 13
15861 OPC_Decode, 233, 121, 145, 2, // 261: decode to QC_BREV32 using decoder 273
15862 // 261: } else try {
15863 OPC_CheckPredicate, 13, // 266: check predicate 13
15864 OPC_Decode, 150, 122, 147, 2, // 268: decode to QC_EXTDUPR using decoder 275
15865 // 268: }
15866 // 268: }
15867 7, 21, // 273: case 0x7: {
15868 OPC_Scope, 12, // 275: try {
15869 OPC_CheckField, 20, 5, 0, // 277: check Inst[24:20] == 0x0
15870 OPC_CheckPredicate, 184, 1, // 281: check predicate 184
15871 OPC_Decode, 221, 122, 145, 2, // 284: decode to QC_NORM using decoder 273
15872 // 284: } else try {
15873 OPC_CheckPredicate, 13, // 289: check predicate 13
15874 OPC_Decode, 151, 122, 147, 2, // 291: decode to QC_EXTDUPRH using decoder 275
15875 // 291: }
15876 // 291: }
15877 8, 21, // 296: case 0x8: {
15878 OPC_Scope, 12, // 298: try {
15879 OPC_CheckField, 20, 5, 0, // 300: check Inst[24:20] == 0x0
15880 OPC_CheckPredicate, 184, 1, // 304: check predicate 184
15881 OPC_Decode, 223, 122, 145, 2, // 307: decode to QC_NORMU using decoder 273
15882 // 307: } else try {
15883 OPC_CheckPredicate, 13, // 312: check predicate 13
15884 OPC_Decode, 146, 122, 147, 2, // 314: decode to QC_EXTDPR using decoder 275
15885 // 314: }
15886 // 314: }
15887 9, 21, // 319: case 0x9: {
15888 OPC_Scope, 12, // 321: try {
15889 OPC_CheckField, 20, 5, 0, // 323: check Inst[24:20] == 0x0
15890 OPC_CheckPredicate, 184, 1, // 327: check predicate 184
15891 OPC_Decode, 222, 122, 145, 2, // 330: decode to QC_NORMEU using decoder 273
15892 // 330: } else try {
15893 OPC_CheckPredicate, 13, // 335: check predicate 13
15894 OPC_Decode, 147, 122, 147, 2, // 337: decode to QC_EXTDPRH using decoder 275
15895 // 337: }
15896 // 337: }
15897 10, 8, // 342: case 0xa: {
15898 OPC_CheckPredicate, 184, 1, // 344: check predicate 184
15899 OPC_Decode, 238, 122, 148, 2, // 347: decode to QC_SHLSAT using decoder 276
15900 // 347: }
15901 12, 8, // 352: case 0xc: {
15902 OPC_CheckPredicate, 184, 1, // 354: check predicate 184
15903 OPC_Decode, 239, 122, 148, 2, // 357: decode to QC_SHLUSAT using decoder 276
15904 // 357: }
15905 14, 8, // 362: case 0xe: {
15906 OPC_CheckPredicate, 184, 1, // 364: check predicate 184
15907 OPC_Decode, 225, 121, 148, 2, // 367: decode to QC_ADDSAT using decoder 276
15908 // 367: }
15909 15, 8, // 372: case 0xf: {
15910 OPC_CheckPredicate, 184, 1, // 374: check predicate 184
15911 OPC_Decode, 226, 121, 148, 2, // 377: decode to QC_ADDUSAT using decoder 276
15912 // 377: }
15913 16, 8, // 382: case 0x10: {
15914 OPC_CheckPredicate, 184, 1, // 384: check predicate 184
15915 OPC_Decode, 243, 122, 148, 2, // 387: decode to QC_SUBSAT using decoder 276
15916 // 387: }
15917 17, 8, // 392: case 0x11: {
15918 OPC_CheckPredicate, 184, 1, // 394: check predicate 184
15919 OPC_Decode, 244, 122, 148, 2, // 397: decode to QC_SUBUSAT using decoder 276
15920 // 397: }
15921 18, 0, // 402: case 0x12: {
15922 OPC_CheckPredicate, 184, 1, // 404: check predicate 184
15923 OPC_Decode, 251, 122, 149, 2, // 407: decode to QC_WRAP using decoder 277
15924 // 407: }
15925 // 407: } // switch Inst[29:25]
15926 // 407: }
15927 1, 0, // 412: case 0x1: {
15928 OPC_CheckPredicate, 14, // 414: check predicate 14
15929 OPC_Decode, 237, 122, 150, 2, // 416: decode to QC_SHLADD using decoder 278
15930 // 416: }
15931 // 416: } // switch Inst[31:30]
15932 // 416: }
15933 4, 8, // 421: case 0x4: {
15934 OPC_CheckPredicate, 185, 1, // 423: check predicate 185
15935 OPC_Decode, 224, 122, 151, 2, // 426: decode to QC_OUTW using decoder 279
15936 // 426: }
15937 5, 8, // 431: case 0x5: {
15938 OPC_CheckPredicate, 185, 1, // 433: check predicate 185
15939 OPC_Decode, 187, 122, 152, 2, // 436: decode to QC_INW using decoder 280
15940 // 436: }
15941 6, 7, // 441: case 0x6: {
15942 OPC_CheckPredicate, 14, // 443: check predicate 14
15943 OPC_Decode, 208, 122, 153, 2, // 445: decode to QC_MULIADD using decoder 281
15944 // 445: }
15945 7, 0, // 450: case 0x7: {
15946 OPC_SwitchField, 30, 2, // 452: switch Inst[31:30] {
15947 0, 8, // 455: case 0x0: {
15948 OPC_CheckPredicate, 186, 1, // 457: check predicate 186
15949 OPC_Decode, 206, 122, 154, 2, // 460: decode to QC_LWM using decoder 282
15950 // 460: }
15951 1, 8, // 465: case 0x1: {
15952 OPC_CheckPredicate, 186, 1, // 467: check predicate 186
15953 OPC_Decode, 207, 122, 155, 2, // 470: decode to QC_LWMI using decoder 283
15954 // 470: }
15955 2, 43, // 475: case 0x2: {
15956 OPC_SwitchField, 28, 2, // 477: switch Inst[29:28] {
15957 0, 8, // 480: case 0x0: {
15958 OPC_CheckPredicate, 187, 1, // 482: check predicate 187
15959 OPC_Decode, 201, 122, 156, 2, // 485: decode to QC_LRB using decoder 284
15960 // 485: }
15961 1, 8, // 490: case 0x1: {
15962 OPC_CheckPredicate, 187, 1, // 492: check predicate 187
15963 OPC_Decode, 203, 122, 156, 2, // 495: decode to QC_LRH using decoder 284
15964 // 495: }
15965 2, 8, // 500: case 0x2: {
15966 OPC_CheckPredicate, 187, 1, // 502: check predicate 187
15967 OPC_Decode, 205, 122, 156, 2, // 505: decode to QC_LRW using decoder 284
15968 // 505: }
15969 3, 0, // 510: case 0x3: {
15970 OPC_CheckPredicate, 187, 1, // 512: check predicate 187
15971 OPC_Decode, 202, 122, 156, 2, // 515: decode to QC_LRBU using decoder 284
15972 // 515: }
15973 // 515: } // switch Inst[29:28]
15974 // 515: }
15975 3, 0, // 520: case 0x3: {
15976 OPC_CheckPredicate, 187, 1, // 522: check predicate 187
15977 OPC_CheckField, 28, 2, 0, // 525: check Inst[29:28] == 0x0
15978 OPC_Decode, 204, 122, 156, 2, // 529: decode to QC_LRHU using decoder 284
15979 // 529: }
15980 // 529: } // switch Inst[31:30]
15981 // 529: }
15982 // 529: } // switch Inst[14:12]
15983 // 529: }
15984 19, 82, // 534: case 0x13: {
15985 OPC_SwitchField, 28, 4, // 536: switch Inst[31:28] {
15986 1, 15, // 539: case 0x1: {
15987 OPC_CheckPredicate, 15, // 541: check predicate 15
15988 OPC_CheckField, 25, 3, 0, // 543: check Inst[27:25] == 0x0
15989 OPC_CheckField, 7, 13, 96, // 547: check Inst[19:7] == 0x60
15990 OPC_Decode, 247, 122, 157, 2, // 551: decode to QC_SYNC using decoder 285
15991 // 551: }
15992 2, 15, // 556: case 0x2: {
15993 OPC_CheckPredicate, 15, // 558: check predicate 15
15994 OPC_CheckField, 25, 3, 0, // 560: check Inst[27:25] == 0x0
15995 OPC_CheckField, 7, 13, 96, // 564: check Inst[19:7] == 0x60
15996 OPC_Decode, 248, 122, 157, 2, // 568: decode to QC_SYNCR using decoder 285
15997 // 568: }
15998 4, 26, // 573: case 0x4: {
15999 OPC_SwitchField, 7, 13, // 575: switch Inst[19:7] {
16000 64, 8, // 578: case 0x40: {
16001 OPC_CheckPredicate, 188, 1, // 580: check predicate 188
16002 OPC_Decode, 225, 122, 158, 2, // 583: decode to QC_PPUTCI using decoder 286
16003 // 583: }
16004 96, 0, // 588: case 0x60: {
16005 OPC_CheckPredicate, 15, // 590: check predicate 15
16006 OPC_CheckField, 25, 3, 0, // 592: check Inst[27:25] == 0x0
16007 OPC_Decode, 249, 122, 157, 2, // 596: decode to QC_SYNCWF using decoder 285
16008 // 596: }
16009 // 596: } // switch Inst[19:7]
16010 // 596: }
16011 8, 0, // 601: case 0x8: {
16012 OPC_CheckPredicate, 15, // 603: check predicate 15
16013 OPC_CheckField, 25, 3, 0, // 605: check Inst[27:25] == 0x0
16014 OPC_CheckField, 7, 13, 96, // 609: check Inst[19:7] == 0x60
16015 OPC_Decode, 250, 122, 157, 2, // 613: decode to QC_SYNCWL using decoder 285
16016 // 613: }
16017 // 613: } // switch Inst[31:28]
16018 // 613: }
16019 27, 8, // 618: case 0x1b: {
16020 OPC_CheckPredicate, 189, 1, // 620: check predicate 189
16021 OPC_Decode, 188, 122, 159, 2, // 623: decode to QC_LI using decoder 287
16022 // 623: }
16023 43, 95, // 628: case 0x2b: {
16024 OPC_SwitchField, 30, 2, // 630: switch Inst[31:30] {
16025 0, 12, // 633: case 0x0: {
16026 OPC_CheckPredicate, 186, 1, // 635: check predicate 186
16027 OPC_CheckField, 12, 3, 7, // 638: check Inst[14:12] == 0x7
16028 OPC_Decode, 245, 122, 154, 2, // 642: decode to QC_SWM using decoder 282
16029 // 642: }
16030 1, 12, // 647: case 0x1: {
16031 OPC_CheckPredicate, 186, 1, // 649: check predicate 186
16032 OPC_CheckField, 12, 3, 7, // 652: check Inst[14:12] == 0x7
16033 OPC_Decode, 246, 122, 155, 2, // 656: decode to QC_SWMI using decoder 283
16034 // 656: }
16035 2, 12, // 661: case 0x2: {
16036 OPC_CheckPredicate, 186, 1, // 663: check predicate 186
16037 OPC_CheckField, 12, 3, 7, // 666: check Inst[14:12] == 0x7
16038 OPC_Decode, 235, 122, 160, 2, // 670: decode to QC_SETWM using decoder 288
16039 // 670: }
16040 3, 0, // 675: case 0x3: {
16041 OPC_SwitchField, 12, 3, // 677: switch Inst[14:12] {
16042 6, 33, // 680: case 0x6: {
16043 OPC_SwitchField, 28, 2, // 682: switch Inst[29:28] {
16044 1, 8, // 685: case 0x1: {
16045 OPC_CheckPredicate, 187, 1, // 687: check predicate 187
16046 OPC_Decode, 240, 122, 156, 2, // 690: decode to QC_SRB using decoder 284
16047 // 690: }
16048 2, 8, // 695: case 0x2: {
16049 OPC_CheckPredicate, 187, 1, // 697: check predicate 187
16050 OPC_Decode, 241, 122, 156, 2, // 700: decode to QC_SRH using decoder 284
16051 // 700: }
16052 3, 0, // 705: case 0x3: {
16053 OPC_CheckPredicate, 187, 1, // 707: check predicate 187
16054 OPC_Decode, 242, 122, 156, 2, // 710: decode to QC_SRW using decoder 284
16055 // 710: }
16056 // 710: } // switch Inst[29:28]
16057 // 710: }
16058 7, 0, // 715: case 0x7: {
16059 OPC_CheckPredicate, 186, 1, // 717: check predicate 186
16060 OPC_Decode, 236, 122, 161, 2, // 720: decode to QC_SETWMI using decoder 289
16061 // 720: }
16062 // 720: } // switch Inst[14:12]
16063 // 720: }
16064 // 720: } // switch Inst[31:30]
16065 // 720: }
16066 91, 223, 2, // 725: case 0x5b: {
16067 OPC_SwitchField, 12, 3, // 728: switch Inst[14:12] {
16068 0, 41, // 731: case 0x0: {
16069 OPC_SwitchField, 25, 2, // 733: switch Inst[26:25] {
16070 0, 7, // 736: case 0x0: {
16071 OPC_CheckPredicate, 16, // 738: check predicate 16
16072 OPC_Decode, 209, 122, 162, 2, // 740: decode to QC_MVEQ using decoder 290
16073 // 740: }
16074 1, 8, // 745: case 0x1: {
16075 OPC_CheckPredicate, 190, 1, // 747: check predicate 190
16076 OPC_Decode, 189, 122, 163, 2, // 750: decode to QC_LIEQ using decoder 291
16077 // 750: }
16078 2, 7, // 755: case 0x2: {
16079 OPC_CheckPredicate, 16, // 757: check predicate 16
16080 OPC_Decode, 210, 122, 164, 2, // 759: decode to QC_MVEQI using decoder 292
16081 // 759: }
16082 3, 0, // 764: case 0x3: {
16083 OPC_CheckPredicate, 190, 1, // 766: check predicate 190
16084 OPC_Decode, 190, 122, 165, 2, // 769: decode to QC_LIEQI using decoder 293
16085 // 769: }
16086 // 769: } // switch Inst[26:25]
16087 // 769: }
16088 1, 41, // 774: case 0x1: {
16089 OPC_SwitchField, 25, 2, // 776: switch Inst[26:25] {
16090 0, 7, // 779: case 0x0: {
16091 OPC_CheckPredicate, 16, // 781: check predicate 16
16092 OPC_Decode, 219, 122, 162, 2, // 783: decode to QC_MVNE using decoder 290
16093 // 783: }
16094 1, 8, // 788: case 0x1: {
16095 OPC_CheckPredicate, 190, 1, // 790: check predicate 190
16096 OPC_Decode, 199, 122, 163, 2, // 793: decode to QC_LINE using decoder 291
16097 // 793: }
16098 2, 7, // 798: case 0x2: {
16099 OPC_CheckPredicate, 16, // 800: check predicate 16
16100 OPC_Decode, 220, 122, 164, 2, // 802: decode to QC_MVNEI using decoder 292
16101 // 802: }
16102 3, 0, // 807: case 0x3: {
16103 OPC_CheckPredicate, 190, 1, // 809: check predicate 190
16104 OPC_Decode, 200, 122, 165, 2, // 812: decode to QC_LINEI using decoder 293
16105 // 812: }
16106 // 812: } // switch Inst[26:25]
16107 // 812: }
16108 2, 43, // 817: case 0x2: {
16109 OPC_SwitchField, 25, 2, // 819: switch Inst[26:25] {
16110 0, 8, // 822: case 0x0: {
16111 OPC_CheckPredicate, 191, 1, // 824: check predicate 191
16112 OPC_Decode, 229, 122, 165, 2, // 827: decode to QC_SELECTIIEQ using decoder 293
16113 // 827: }
16114 1, 8, // 832: case 0x1: {
16115 OPC_CheckPredicate, 191, 1, // 834: check predicate 191
16116 OPC_Decode, 227, 122, 163, 2, // 837: decode to QC_SELECTIEQ using decoder 291
16117 // 837: }
16118 2, 8, // 842: case 0x2: {
16119 OPC_CheckPredicate, 191, 1, // 844: check predicate 191
16120 OPC_Decode, 226, 122, 166, 2, // 847: decode to QC_SELECTEQI using decoder 294
16121 // 847: }
16122 3, 0, // 852: case 0x3: {
16123 OPC_CheckPredicate, 191, 1, // 854: check predicate 191
16124 OPC_Decode, 228, 122, 167, 2, // 857: decode to QC_SELECTIEQI using decoder 295
16125 // 857: }
16126 // 857: } // switch Inst[26:25]
16127 // 857: }
16128 3, 43, // 862: case 0x3: {
16129 OPC_SwitchField, 25, 2, // 864: switch Inst[26:25] {
16130 0, 8, // 867: case 0x0: {
16131 OPC_CheckPredicate, 191, 1, // 869: check predicate 191
16132 OPC_Decode, 230, 122, 165, 2, // 872: decode to QC_SELECTIINE using decoder 293
16133 // 872: }
16134 1, 8, // 877: case 0x1: {
16135 OPC_CheckPredicate, 191, 1, // 879: check predicate 191
16136 OPC_Decode, 231, 122, 163, 2, // 882: decode to QC_SELECTINE using decoder 291
16137 // 882: }
16138 2, 8, // 887: case 0x2: {
16139 OPC_CheckPredicate, 191, 1, // 889: check predicate 191
16140 OPC_Decode, 233, 122, 166, 2, // 892: decode to QC_SELECTNEI using decoder 294
16141 // 892: }
16142 3, 0, // 897: case 0x3: {
16143 OPC_CheckPredicate, 191, 1, // 899: check predicate 191
16144 OPC_Decode, 232, 122, 167, 2, // 902: decode to QC_SELECTINEI using decoder 295
16145 // 902: }
16146 // 902: } // switch Inst[26:25]
16147 // 902: }
16148 4, 41, // 907: case 0x4: {
16149 OPC_SwitchField, 25, 2, // 909: switch Inst[26:25] {
16150 0, 7, // 912: case 0x0: {
16151 OPC_CheckPredicate, 16, // 914: check predicate 16
16152 OPC_Decode, 215, 122, 162, 2, // 916: decode to QC_MVLT using decoder 290
16153 // 916: }
16154 1, 8, // 921: case 0x1: {
16155 OPC_CheckPredicate, 190, 1, // 923: check predicate 190
16156 OPC_Decode, 195, 122, 163, 2, // 926: decode to QC_LILT using decoder 291
16157 // 926: }
16158 2, 7, // 931: case 0x2: {
16159 OPC_CheckPredicate, 16, // 933: check predicate 16
16160 OPC_Decode, 216, 122, 164, 2, // 935: decode to QC_MVLTI using decoder 292
16161 // 935: }
16162 3, 0, // 940: case 0x3: {
16163 OPC_CheckPredicate, 190, 1, // 942: check predicate 190
16164 OPC_Decode, 196, 122, 165, 2, // 945: decode to QC_LILTI using decoder 293
16165 // 945: }
16166 // 945: } // switch Inst[26:25]
16167 // 945: }
16168 5, 41, // 950: case 0x5: {
16169 OPC_SwitchField, 25, 2, // 952: switch Inst[26:25] {
16170 0, 7, // 955: case 0x0: {
16171 OPC_CheckPredicate, 16, // 957: check predicate 16
16172 OPC_Decode, 211, 122, 162, 2, // 959: decode to QC_MVGE using decoder 290
16173 // 959: }
16174 1, 8, // 964: case 0x1: {
16175 OPC_CheckPredicate, 190, 1, // 966: check predicate 190
16176 OPC_Decode, 191, 122, 163, 2, // 969: decode to QC_LIGE using decoder 291
16177 // 969: }
16178 2, 7, // 974: case 0x2: {
16179 OPC_CheckPredicate, 16, // 976: check predicate 16
16180 OPC_Decode, 212, 122, 164, 2, // 978: decode to QC_MVGEI using decoder 292
16181 // 978: }
16182 3, 0, // 983: case 0x3: {
16183 OPC_CheckPredicate, 190, 1, // 985: check predicate 190
16184 OPC_Decode, 192, 122, 165, 2, // 988: decode to QC_LIGEI using decoder 293
16185 // 988: }
16186 // 988: } // switch Inst[26:25]
16187 // 988: }
16188 6, 41, // 993: case 0x6: {
16189 OPC_SwitchField, 25, 2, // 995: switch Inst[26:25] {
16190 0, 7, // 998: case 0x0: {
16191 OPC_CheckPredicate, 16, // 1000: check predicate 16
16192 OPC_Decode, 217, 122, 162, 2, // 1002: decode to QC_MVLTU using decoder 290
16193 // 1002: }
16194 1, 8, // 1007: case 0x1: {
16195 OPC_CheckPredicate, 190, 1, // 1009: check predicate 190
16196 OPC_Decode, 197, 122, 163, 2, // 1012: decode to QC_LILTU using decoder 291
16197 // 1012: }
16198 2, 7, // 1017: case 0x2: {
16199 OPC_CheckPredicate, 16, // 1019: check predicate 16
16200 OPC_Decode, 218, 122, 168, 2, // 1021: decode to QC_MVLTUI using decoder 296
16201 // 1021: }
16202 3, 0, // 1026: case 0x3: {
16203 OPC_CheckPredicate, 190, 1, // 1028: check predicate 190
16204 OPC_Decode, 198, 122, 169, 2, // 1031: decode to QC_LILTUI using decoder 297
16205 // 1031: }
16206 // 1031: } // switch Inst[26:25]
16207 // 1031: }
16208 7, 0, // 1036: case 0x7: {
16209 OPC_SwitchField, 25, 2, // 1038: switch Inst[26:25] {
16210 0, 7, // 1041: case 0x0: {
16211 OPC_CheckPredicate, 16, // 1043: check predicate 16
16212 OPC_Decode, 213, 122, 162, 2, // 1045: decode to QC_MVGEU using decoder 290
16213 // 1045: }
16214 1, 8, // 1050: case 0x1: {
16215 OPC_CheckPredicate, 190, 1, // 1052: check predicate 190
16216 OPC_Decode, 193, 122, 163, 2, // 1055: decode to QC_LIGEU using decoder 291
16217 // 1055: }
16218 2, 7, // 1060: case 0x2: {
16219 OPC_CheckPredicate, 16, // 1062: check predicate 16
16220 OPC_Decode, 214, 122, 168, 2, // 1064: decode to QC_MVGEUI using decoder 296
16221 // 1064: }
16222 3, 0, // 1069: case 0x3: {
16223 OPC_CheckPredicate, 190, 1, // 1071: check predicate 190
16224 OPC_Decode, 194, 122, 169, 2, // 1074: decode to QC_LIGEUI using decoder 297
16225 // 1074: }
16226 // 1074: } // switch Inst[26:25]
16227 // 1074: }
16228 // 1074: } // switch Inst[14:12]
16229 // 1074: }
16230 115, 57, // 1079: case 0x73: {
16231 OPC_SwitchField, 25, 7, // 1081: switch Inst[31:25] {
16232 70, 12, // 1084: case 0x46: {
16233 OPC_CheckPredicate, 192, 1, // 1086: check predicate 192
16234 OPC_CheckField, 12, 3, 0, // 1089: check Inst[14:12] == 0x0
16235 OPC_Decode, 247, 121, 170, 2, // 1093: decode to QC_CSRRWR using decoder 298
16236 // 1093: }
16237 71, 12, // 1098: case 0x47: {
16238 OPC_CheckPredicate, 192, 1, // 1100: check predicate 192
16239 OPC_CheckField, 12, 3, 0, // 1103: check Inst[14:12] == 0x0
16240 OPC_Decode, 248, 121, 171, 2, // 1107: decode to QC_CSRRWRI using decoder 299
16241 // 1107: }
16242 102, 11, // 1112: case 0x66: {
16243 OPC_CheckPredicate, 12, // 1114: check predicate 12
16244 OPC_CheckField, 7, 8, 0, // 1116: check Inst[14:7] == 0x0
16245 OPC_Decode, 234, 122, 172, 2, // 1120: decode to QC_SETINTI using decoder 300
16246 // 1120: }
16247 103, 0, // 1125: case 0x67: {
16248 OPC_CheckPredicate, 12, // 1127: check predicate 12
16249 OPC_CheckField, 7, 8, 0, // 1129: check Inst[14:7] == 0x0
16250 OPC_Decode, 235, 121, 172, 2, // 1133: decode to QC_CLRINTI using decoder 300
16251 // 1133: }
16252 // 1133: } // switch Inst[31:25]
16253 // 1133: }
16254 123, 0, // 1138: case 0x7b: {
16255 OPC_SwitchField, 12, 3, // 1140: switch Inst[14:12] {
16256 0, 8, // 1143: case 0x0: {
16257 OPC_CheckPredicate, 193, 1, // 1145: check predicate 193
16258 OPC_Decode, 227, 121, 173, 2, // 1148: decode to QC_BEQI using decoder 301
16259 // 1148: }
16260 1, 8, // 1153: case 0x1: {
16261 OPC_CheckPredicate, 193, 1, // 1155: check predicate 193
16262 OPC_Decode, 232, 121, 173, 2, // 1158: decode to QC_BNEI using decoder 301
16263 // 1158: }
16264 4, 8, // 1163: case 0x4: {
16265 OPC_CheckPredicate, 193, 1, // 1165: check predicate 193
16266 OPC_Decode, 230, 121, 173, 2, // 1168: decode to QC_BLTI using decoder 301
16267 // 1168: }
16268 5, 8, // 1173: case 0x5: {
16269 OPC_CheckPredicate, 193, 1, // 1175: check predicate 193
16270 OPC_Decode, 228, 121, 173, 2, // 1178: decode to QC_BGEI using decoder 301
16271 // 1178: }
16272 6, 8, // 1183: case 0x6: {
16273 OPC_CheckPredicate, 193, 1, // 1185: check predicate 193
16274 OPC_Decode, 231, 121, 174, 2, // 1188: decode to QC_BLTUI using decoder 302
16275 // 1188: }
16276 7, 0, // 1193: case 0x7: {
16277 OPC_CheckPredicate, 193, 1, // 1195: check predicate 193
16278 OPC_Decode, 229, 121, 174, 2, // 1198: decode to QC_BGEUI using decoder 302
16279 // 1198: }
16280 // 1198: } // switch Inst[14:12]
16281 // 1198: }
16282 // 1198: } // switch Inst[6:0]
16283};
16284static const uint8_t DecoderTableZdinxGPRPairRV3232[34] = {
16285 32, // 0: BitWidth 32
16286 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
16287 162, 8, 12, // 4: case 0x422: {
16288 OPC_CheckPredicate, 194, 1, // 7: check predicate 194
16289 OPC_CheckField, 0, 7, 83, // 10: check Inst[6:0] == 0x53
16290 OPC_Decode, 255, 113, 175, 2, // 14: decode to FCVT_D_H_IN32X using decoder 303
16291 // 14: }
16292 193, 8, 0, // 19: case 0x441: {
16293 OPC_CheckPredicate, 194, 1, // 22: check predicate 194
16294 OPC_CheckField, 0, 7, 83, // 25: check Inst[6:0] == 0x53
16295 OPC_Decode, 144, 114, 176, 2, // 29: decode to FCVT_H_D_IN32X using decoder 304
16296 // 29: }
16297 // 29: } // switch Inst[31:20]
16298};
16299static const uint8_t DecoderTableZdinxRV32Only32[310] = {
16300 32, // 0: BitWidth 32
16301 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16302 67, 12, // 4: case 0x43: {
16303 OPC_CheckPredicate, 195, 1, // 6: check predicate 195
16304 OPC_CheckField, 25, 2, 1, // 9: check Inst[26:25] == 0x1
16305 OPC_Decode, 131, 115, 177, 2, // 13: decode to FMADD_D_IN32X using decoder 305
16306 // 13: }
16307 71, 12, // 18: case 0x47: {
16308 OPC_CheckPredicate, 195, 1, // 20: check predicate 195
16309 OPC_CheckField, 25, 2, 1, // 23: check Inst[26:25] == 0x1
16310 OPC_Decode, 163, 115, 177, 2, // 27: decode to FMSUB_D_IN32X using decoder 305
16311 // 27: }
16312 75, 12, // 32: case 0x4b: {
16313 OPC_CheckPredicate, 195, 1, // 34: check predicate 195
16314 OPC_CheckField, 25, 2, 1, // 37: check Inst[26:25] == 0x1
16315 OPC_Decode, 198, 115, 177, 2, // 41: decode to FNMSUB_D_IN32X using decoder 305
16316 // 41: }
16317 79, 12, // 46: case 0x4f: {
16318 OPC_CheckPredicate, 195, 1, // 48: check predicate 195
16319 OPC_CheckField, 25, 2, 1, // 51: check Inst[26:25] == 0x1
16320 OPC_Decode, 190, 115, 177, 2, // 55: decode to FNMADD_D_IN32X using decoder 305
16321 // 55: }
16322 83, 0, // 60: case 0x53: {
16323 OPC_SwitchField, 25, 7, // 62: switch Inst[31:25] {
16324 1, 8, // 65: case 0x1: {
16325 OPC_CheckPredicate, 195, 1, // 67: check predicate 195
16326 OPC_Decode, 237, 113, 178, 2, // 70: decode to FADD_D_IN32X using decoder 306
16327 // 70: }
16328 5, 8, // 75: case 0x5: {
16329 OPC_CheckPredicate, 195, 1, // 77: check predicate 195
16330 OPC_Decode, 249, 115, 178, 2, // 80: decode to FSUB_D_IN32X using decoder 306
16331 // 80: }
16332 9, 8, // 85: case 0x9: {
16333 OPC_CheckPredicate, 195, 1, // 87: check predicate 195
16334 OPC_Decode, 171, 115, 178, 2, // 90: decode to FMUL_D_IN32X using decoder 306
16335 // 90: }
16336 13, 8, // 95: case 0xd: {
16337 OPC_CheckPredicate, 195, 1, // 97: check predicate 195
16338 OPC_Decode, 208, 114, 178, 2, // 100: decode to FDIV_D_IN32X using decoder 306
16339 // 100: }
16340 17, 33, // 105: case 0x11: {
16341 OPC_SwitchField, 12, 3, // 107: switch Inst[14:12] {
16342 0, 8, // 110: case 0x0: {
16343 OPC_CheckPredicate, 195, 1, // 112: check predicate 195
16344 OPC_Decode, 231, 115, 179, 2, // 115: decode to FSGNJ_D_IN32X using decoder 307
16345 // 115: }
16346 1, 8, // 120: case 0x1: {
16347 OPC_CheckPredicate, 195, 1, // 122: check predicate 195
16348 OPC_Decode, 215, 115, 179, 2, // 125: decode to FSGNJN_D_IN32X using decoder 307
16349 // 125: }
16350 2, 0, // 130: case 0x2: {
16351 OPC_CheckPredicate, 195, 1, // 132: check predicate 195
16352 OPC_Decode, 223, 115, 179, 2, // 135: decode to FSGNJX_D_IN32X using decoder 307
16353 // 135: }
16354 // 135: } // switch Inst[14:12]
16355 // 135: }
16356 21, 23, // 140: case 0x15: {
16357 OPC_SwitchField, 12, 3, // 142: switch Inst[14:12] {
16358 0, 8, // 145: case 0x0: {
16359 OPC_CheckPredicate, 195, 1, // 147: check predicate 195
16360 OPC_Decode, 155, 115, 179, 2, // 150: decode to FMIN_D_IN32X using decoder 307
16361 // 150: }
16362 1, 0, // 155: case 0x1: {
16363 OPC_CheckPredicate, 195, 1, // 157: check predicate 195
16364 OPC_Decode, 143, 115, 179, 2, // 160: decode to FMAX_D_IN32X using decoder 307
16365 // 160: }
16366 // 160: } // switch Inst[14:12]
16367 // 160: }
16368 32, 12, // 165: case 0x20: {
16369 OPC_CheckPredicate, 195, 1, // 167: check predicate 195
16370 OPC_CheckField, 20, 5, 1, // 170: check Inst[24:20] == 0x1
16371 OPC_Decode, 178, 114, 180, 2, // 174: decode to FCVT_S_D_IN32X using decoder 308
16372 // 174: }
16373 33, 12, // 179: case 0x21: {
16374 OPC_CheckPredicate, 195, 1, // 181: check predicate 195
16375 OPC_CheckField, 20, 5, 0, // 184: check Inst[24:20] == 0x0
16376 OPC_Decode, 135, 114, 181, 2, // 188: decode to FCVT_D_S_IN32X using decoder 309
16377 // 188: }
16378 45, 12, // 193: case 0x2d: {
16379 OPC_CheckPredicate, 195, 1, // 195: check predicate 195
16380 OPC_CheckField, 20, 5, 0, // 198: check Inst[24:20] == 0x0
16381 OPC_Decode, 241, 115, 182, 2, // 202: decode to FSQRT_D_IN32X using decoder 310
16382 // 202: }
16383 81, 33, // 207: case 0x51: {
16384 OPC_SwitchField, 12, 3, // 209: switch Inst[14:12] {
16385 0, 8, // 212: case 0x0: {
16386 OPC_CheckPredicate, 195, 1, // 214: check predicate 195
16387 OPC_Decode, 232, 114, 183, 2, // 217: decode to FLE_D_IN32X using decoder 311
16388 // 217: }
16389 1, 8, // 222: case 0x1: {
16390 OPC_CheckPredicate, 195, 1, // 224: check predicate 195
16391 OPC_Decode, 250, 114, 183, 2, // 227: decode to FLT_D_IN32X using decoder 311
16392 // 227: }
16393 2, 0, // 232: case 0x2: {
16394 OPC_CheckPredicate, 195, 1, // 234: check predicate 195
16395 OPC_Decode, 219, 114, 183, 2, // 237: decode to FEQ_D_IN32X using decoder 311
16396 // 237: }
16397 // 237: } // switch Inst[14:12]
16398 // 237: }
16399 97, 23, // 242: case 0x61: {
16400 OPC_SwitchField, 20, 5, // 244: switch Inst[24:20] {
16401 0, 8, // 247: case 0x0: {
16402 OPC_CheckPredicate, 195, 1, // 249: check predicate 195
16403 OPC_Decode, 200, 114, 184, 2, // 252: decode to FCVT_W_D_IN32X using decoder 312
16404 // 252: }
16405 1, 0, // 257: case 0x1: {
16406 OPC_CheckPredicate, 195, 1, // 259: check predicate 195
16407 OPC_Decode, 192, 114, 184, 2, // 262: decode to FCVT_WU_D_IN32X using decoder 312
16408 // 262: }
16409 // 262: } // switch Inst[24:20]
16410 // 262: }
16411 105, 23, // 267: case 0x69: {
16412 OPC_SwitchField, 20, 5, // 269: switch Inst[24:20] {
16413 0, 8, // 272: case 0x0: {
16414 OPC_CheckPredicate, 195, 1, // 274: check predicate 195
16415 OPC_Decode, 141, 114, 185, 2, // 277: decode to FCVT_D_W_IN32X using decoder 313
16416 // 277: }
16417 1, 0, // 282: case 0x1: {
16418 OPC_CheckPredicate, 195, 1, // 284: check predicate 195
16419 OPC_Decode, 139, 114, 185, 2, // 287: decode to FCVT_D_WU_IN32X using decoder 313
16420 // 287: }
16421 // 287: } // switch Inst[24:20]
16422 // 287: }
16423 113, 0, // 292: case 0x71: {
16424 OPC_CheckPredicate, 195, 1, // 294: check predicate 195
16425 OPC_CheckField, 20, 5, 0, // 297: check Inst[24:20] == 0x0
16426 OPC_CheckField, 12, 3, 1, // 301: check Inst[14:12] == 0x1
16427 OPC_Decode, 245, 113, 186, 2, // 305: decode to FCLASS_D_IN32X using decoder 314
16428 // 305: }
16429 // 305: } // switch Inst[31:25]
16430 // 305: }
16431 // 305: } // switch Inst[6:0]
16432};
16433static const uint8_t DecoderTableZfinx32[986] = {
16434 32, // 0: BitWidth 32
16435 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16436 67, 33, // 4: case 0x43: {
16437 OPC_SwitchField, 25, 2, // 6: switch Inst[26:25] {
16438 0, 8, // 9: case 0x0: {
16439 OPC_CheckPredicate, 196, 1, // 11: check predicate 196
16440 OPC_Decode, 137, 115, 187, 2, // 14: decode to FMADD_S_INX using decoder 315
16441 // 14: }
16442 1, 8, // 19: case 0x1: {
16443 OPC_CheckPredicate, 197, 1, // 21: check predicate 197
16444 OPC_Decode, 132, 115, 188, 2, // 24: decode to FMADD_D_INX using decoder 316
16445 // 24: }
16446 2, 0, // 29: case 0x2: {
16447 OPC_CheckPredicate, 198, 1, // 31: check predicate 198
16448 OPC_Decode, 134, 115, 189, 2, // 34: decode to FMADD_H_INX using decoder 317
16449 // 34: }
16450 // 34: } // switch Inst[26:25]
16451 // 34: }
16452 71, 33, // 39: case 0x47: {
16453 OPC_SwitchField, 25, 2, // 41: switch Inst[26:25] {
16454 0, 8, // 44: case 0x0: {
16455 OPC_CheckPredicate, 196, 1, // 46: check predicate 196
16456 OPC_Decode, 169, 115, 187, 2, // 49: decode to FMSUB_S_INX using decoder 315
16457 // 49: }
16458 1, 8, // 54: case 0x1: {
16459 OPC_CheckPredicate, 197, 1, // 56: check predicate 197
16460 OPC_Decode, 164, 115, 188, 2, // 59: decode to FMSUB_D_INX using decoder 316
16461 // 59: }
16462 2, 0, // 64: case 0x2: {
16463 OPC_CheckPredicate, 198, 1, // 66: check predicate 198
16464 OPC_Decode, 166, 115, 189, 2, // 69: decode to FMSUB_H_INX using decoder 317
16465 // 69: }
16466 // 69: } // switch Inst[26:25]
16467 // 69: }
16468 75, 33, // 74: case 0x4b: {
16469 OPC_SwitchField, 25, 2, // 76: switch Inst[26:25] {
16470 0, 8, // 79: case 0x0: {
16471 OPC_CheckPredicate, 196, 1, // 81: check predicate 196
16472 OPC_Decode, 204, 115, 187, 2, // 84: decode to FNMSUB_S_INX using decoder 315
16473 // 84: }
16474 1, 8, // 89: case 0x1: {
16475 OPC_CheckPredicate, 197, 1, // 91: check predicate 197
16476 OPC_Decode, 199, 115, 188, 2, // 94: decode to FNMSUB_D_INX using decoder 316
16477 // 94: }
16478 2, 0, // 99: case 0x2: {
16479 OPC_CheckPredicate, 198, 1, // 101: check predicate 198
16480 OPC_Decode, 201, 115, 189, 2, // 104: decode to FNMSUB_H_INX using decoder 317
16481 // 104: }
16482 // 104: } // switch Inst[26:25]
16483 // 104: }
16484 79, 33, // 109: case 0x4f: {
16485 OPC_SwitchField, 25, 2, // 111: switch Inst[26:25] {
16486 0, 8, // 114: case 0x0: {
16487 OPC_CheckPredicate, 196, 1, // 116: check predicate 196
16488 OPC_Decode, 196, 115, 187, 2, // 119: decode to FNMADD_S_INX using decoder 315
16489 // 119: }
16490 1, 8, // 124: case 0x1: {
16491 OPC_CheckPredicate, 197, 1, // 126: check predicate 197
16492 OPC_Decode, 191, 115, 188, 2, // 129: decode to FNMADD_D_INX using decoder 316
16493 // 129: }
16494 2, 0, // 134: case 0x2: {
16495 OPC_CheckPredicate, 198, 1, // 136: check predicate 198
16496 OPC_Decode, 193, 115, 189, 2, // 139: decode to FNMADD_H_INX using decoder 317
16497 // 139: }
16498 // 139: } // switch Inst[26:25]
16499 // 139: }
16500 83, 0, // 144: case 0x53: {
16501 OPC_SwitchField, 25, 7, // 146: switch Inst[31:25] {
16502 0, 8, // 149: case 0x0: {
16503 OPC_CheckPredicate, 196, 1, // 151: check predicate 196
16504 OPC_Decode, 243, 113, 190, 2, // 154: decode to FADD_S_INX using decoder 318
16505 // 154: }
16506 1, 8, // 159: case 0x1: {
16507 OPC_CheckPredicate, 197, 1, // 161: check predicate 197
16508 OPC_Decode, 238, 113, 191, 2, // 164: decode to FADD_D_INX using decoder 319
16509 // 164: }
16510 2, 8, // 169: case 0x2: {
16511 OPC_CheckPredicate, 198, 1, // 171: check predicate 198
16512 OPC_Decode, 240, 113, 192, 2, // 174: decode to FADD_H_INX using decoder 320
16513 // 174: }
16514 4, 8, // 179: case 0x4: {
16515 OPC_CheckPredicate, 196, 1, // 181: check predicate 196
16516 OPC_Decode, 255, 115, 190, 2, // 184: decode to FSUB_S_INX using decoder 318
16517 // 184: }
16518 5, 8, // 189: case 0x5: {
16519 OPC_CheckPredicate, 197, 1, // 191: check predicate 197
16520 OPC_Decode, 250, 115, 191, 2, // 194: decode to FSUB_D_INX using decoder 319
16521 // 194: }
16522 6, 8, // 199: case 0x6: {
16523 OPC_CheckPredicate, 198, 1, // 201: check predicate 198
16524 OPC_Decode, 252, 115, 192, 2, // 204: decode to FSUB_H_INX using decoder 320
16525 // 204: }
16526 8, 8, // 209: case 0x8: {
16527 OPC_CheckPredicate, 196, 1, // 211: check predicate 196
16528 OPC_Decode, 177, 115, 190, 2, // 214: decode to FMUL_S_INX using decoder 318
16529 // 214: }
16530 9, 8, // 219: case 0x9: {
16531 OPC_CheckPredicate, 197, 1, // 221: check predicate 197
16532 OPC_Decode, 172, 115, 191, 2, // 224: decode to FMUL_D_INX using decoder 319
16533 // 224: }
16534 10, 8, // 229: case 0xa: {
16535 OPC_CheckPredicate, 198, 1, // 231: check predicate 198
16536 OPC_Decode, 174, 115, 192, 2, // 234: decode to FMUL_H_INX using decoder 320
16537 // 234: }
16538 12, 8, // 239: case 0xc: {
16539 OPC_CheckPredicate, 196, 1, // 241: check predicate 196
16540 OPC_Decode, 214, 114, 190, 2, // 244: decode to FDIV_S_INX using decoder 318
16541 // 244: }
16542 13, 8, // 249: case 0xd: {
16543 OPC_CheckPredicate, 197, 1, // 251: check predicate 197
16544 OPC_Decode, 209, 114, 191, 2, // 254: decode to FDIV_D_INX using decoder 319
16545 // 254: }
16546 14, 8, // 259: case 0xe: {
16547 OPC_CheckPredicate, 198, 1, // 261: check predicate 198
16548 OPC_Decode, 211, 114, 192, 2, // 264: decode to FDIV_H_INX using decoder 320
16549 // 264: }
16550 16, 33, // 269: case 0x10: {
16551 OPC_SwitchField, 12, 3, // 271: switch Inst[14:12] {
16552 0, 8, // 274: case 0x0: {
16553 OPC_CheckPredicate, 196, 1, // 276: check predicate 196
16554 OPC_Decode, 237, 115, 193, 2, // 279: decode to FSGNJ_S_INX using decoder 321
16555 // 279: }
16556 1, 8, // 284: case 0x1: {
16557 OPC_CheckPredicate, 196, 1, // 286: check predicate 196
16558 OPC_Decode, 221, 115, 193, 2, // 289: decode to FSGNJN_S_INX using decoder 321
16559 // 289: }
16560 2, 0, // 294: case 0x2: {
16561 OPC_CheckPredicate, 196, 1, // 296: check predicate 196
16562 OPC_Decode, 229, 115, 193, 2, // 299: decode to FSGNJX_S_INX using decoder 321
16563 // 299: }
16564 // 299: } // switch Inst[14:12]
16565 // 299: }
16566 17, 30, // 304: case 0x11: {
16567 OPC_SwitchField, 12, 3, // 306: switch Inst[14:12] {
16568 0, 7, // 309: case 0x0: {
16569 OPC_CheckPredicate, 197, 1, // 311: check predicate 197
16570 OPC_Decode, 232, 115, 31, // 314: decode to FSGNJ_D_INX using decoder 31
16571 // 314: }
16572 1, 7, // 318: case 0x1: {
16573 OPC_CheckPredicate, 197, 1, // 320: check predicate 197
16574 OPC_Decode, 216, 115, 31, // 323: decode to FSGNJN_D_INX using decoder 31
16575 // 323: }
16576 2, 0, // 327: case 0x2: {
16577 OPC_CheckPredicate, 197, 1, // 329: check predicate 197
16578 OPC_Decode, 224, 115, 31, // 332: decode to FSGNJX_D_INX using decoder 31
16579 // 332: }
16580 // 332: } // switch Inst[14:12]
16581 // 332: }
16582 18, 33, // 336: case 0x12: {
16583 OPC_SwitchField, 12, 3, // 338: switch Inst[14:12] {
16584 0, 8, // 341: case 0x0: {
16585 OPC_CheckPredicate, 198, 1, // 343: check predicate 198
16586 OPC_Decode, 234, 115, 194, 2, // 346: decode to FSGNJ_H_INX using decoder 322
16587 // 346: }
16588 1, 8, // 351: case 0x1: {
16589 OPC_CheckPredicate, 198, 1, // 353: check predicate 198
16590 OPC_Decode, 218, 115, 194, 2, // 356: decode to FSGNJN_H_INX using decoder 322
16591 // 356: }
16592 2, 0, // 361: case 0x2: {
16593 OPC_CheckPredicate, 198, 1, // 363: check predicate 198
16594 OPC_Decode, 226, 115, 194, 2, // 366: decode to FSGNJX_H_INX using decoder 322
16595 // 366: }
16596 // 366: } // switch Inst[14:12]
16597 // 366: }
16598 20, 23, // 371: case 0x14: {
16599 OPC_SwitchField, 12, 3, // 373: switch Inst[14:12] {
16600 0, 8, // 376: case 0x0: {
16601 OPC_CheckPredicate, 196, 1, // 378: check predicate 196
16602 OPC_Decode, 161, 115, 193, 2, // 381: decode to FMIN_S_INX using decoder 321
16603 // 381: }
16604 1, 0, // 386: case 0x1: {
16605 OPC_CheckPredicate, 196, 1, // 388: check predicate 196
16606 OPC_Decode, 149, 115, 193, 2, // 391: decode to FMAX_S_INX using decoder 321
16607 // 391: }
16608 // 391: } // switch Inst[14:12]
16609 // 391: }
16610 21, 21, // 396: case 0x15: {
16611 OPC_SwitchField, 12, 3, // 398: switch Inst[14:12] {
16612 0, 7, // 401: case 0x0: {
16613 OPC_CheckPredicate, 197, 1, // 403: check predicate 197
16614 OPC_Decode, 156, 115, 31, // 406: decode to FMIN_D_INX using decoder 31
16615 // 406: }
16616 1, 0, // 410: case 0x1: {
16617 OPC_CheckPredicate, 197, 1, // 412: check predicate 197
16618 OPC_Decode, 144, 115, 31, // 415: decode to FMAX_D_INX using decoder 31
16619 // 415: }
16620 // 415: } // switch Inst[14:12]
16621 // 415: }
16622 22, 23, // 419: case 0x16: {
16623 OPC_SwitchField, 12, 3, // 421: switch Inst[14:12] {
16624 0, 8, // 424: case 0x0: {
16625 OPC_CheckPredicate, 198, 1, // 426: check predicate 198
16626 OPC_Decode, 158, 115, 194, 2, // 429: decode to FMIN_H_INX using decoder 322
16627 // 429: }
16628 1, 0, // 434: case 0x1: {
16629 OPC_CheckPredicate, 198, 1, // 436: check predicate 198
16630 OPC_Decode, 146, 115, 194, 2, // 439: decode to FMAX_H_INX using decoder 322
16631 // 439: }
16632 // 439: } // switch Inst[14:12]
16633 // 439: }
16634 32, 23, // 444: case 0x20: {
16635 OPC_SwitchField, 20, 5, // 446: switch Inst[24:20] {
16636 1, 8, // 449: case 0x1: {
16637 OPC_CheckPredicate, 197, 1, // 451: check predicate 197
16638 OPC_Decode, 179, 114, 195, 2, // 454: decode to FCVT_S_D_INX using decoder 323
16639 // 454: }
16640 2, 0, // 459: case 0x2: {
16641 OPC_CheckPredicate, 199, 1, // 461: check predicate 199
16642 OPC_Decode, 181, 114, 196, 2, // 464: decode to FCVT_S_H_INX using decoder 324
16643 // 464: }
16644 // 464: } // switch Inst[24:20]
16645 // 464: }
16646 33, 23, // 469: case 0x21: {
16647 OPC_SwitchField, 20, 5, // 471: switch Inst[24:20] {
16648 0, 8, // 474: case 0x0: {
16649 OPC_CheckPredicate, 197, 1, // 476: check predicate 197
16650 OPC_Decode, 136, 114, 197, 2, // 479: decode to FCVT_D_S_INX using decoder 325
16651 // 479: }
16652 2, 0, // 484: case 0x2: {
16653 OPC_CheckPredicate, 200, 1, // 486: check predicate 200
16654 OPC_Decode, 128, 114, 198, 2, // 489: decode to FCVT_D_H_INX using decoder 326
16655 // 489: }
16656 // 489: } // switch Inst[24:20]
16657 // 489: }
16658 34, 23, // 494: case 0x22: {
16659 OPC_SwitchField, 20, 5, // 496: switch Inst[24:20] {
16660 0, 8, // 499: case 0x0: {
16661 OPC_CheckPredicate, 199, 1, // 501: check predicate 199
16662 OPC_Decode, 151, 114, 199, 2, // 504: decode to FCVT_H_S_INX using decoder 327
16663 // 504: }
16664 1, 0, // 509: case 0x1: {
16665 OPC_CheckPredicate, 200, 1, // 511: check predicate 200
16666 OPC_Decode, 145, 114, 200, 2, // 514: decode to FCVT_H_D_INX using decoder 328
16667 // 514: }
16668 // 514: } // switch Inst[24:20]
16669 // 514: }
16670 44, 12, // 519: case 0x2c: {
16671 OPC_CheckPredicate, 196, 1, // 521: check predicate 196
16672 OPC_CheckField, 20, 5, 0, // 524: check Inst[24:20] == 0x0
16673 OPC_Decode, 247, 115, 201, 2, // 528: decode to FSQRT_S_INX using decoder 329
16674 // 528: }
16675 45, 12, // 533: case 0x2d: {
16676 OPC_CheckPredicate, 197, 1, // 535: check predicate 197
16677 OPC_CheckField, 20, 5, 0, // 538: check Inst[24:20] == 0x0
16678 OPC_Decode, 242, 115, 202, 2, // 542: decode to FSQRT_D_INX using decoder 330
16679 // 542: }
16680 46, 12, // 547: case 0x2e: {
16681 OPC_CheckPredicate, 198, 1, // 549: check predicate 198
16682 OPC_CheckField, 20, 5, 0, // 552: check Inst[24:20] == 0x0
16683 OPC_Decode, 244, 115, 203, 2, // 556: decode to FSQRT_H_INX using decoder 331
16684 // 556: }
16685 80, 33, // 561: case 0x50: {
16686 OPC_SwitchField, 12, 3, // 563: switch Inst[14:12] {
16687 0, 8, // 566: case 0x0: {
16688 OPC_CheckPredicate, 196, 1, // 568: check predicate 196
16689 OPC_Decode, 238, 114, 204, 2, // 571: decode to FLE_S_INX using decoder 332
16690 // 571: }
16691 1, 8, // 576: case 0x1: {
16692 OPC_CheckPredicate, 196, 1, // 578: check predicate 196
16693 OPC_Decode, 128, 115, 204, 2, // 581: decode to FLT_S_INX using decoder 332
16694 // 581: }
16695 2, 0, // 586: case 0x2: {
16696 OPC_CheckPredicate, 196, 1, // 588: check predicate 196
16697 OPC_Decode, 225, 114, 204, 2, // 591: decode to FEQ_S_INX using decoder 332
16698 // 591: }
16699 // 591: } // switch Inst[14:12]
16700 // 591: }
16701 81, 30, // 596: case 0x51: {
16702 OPC_SwitchField, 12, 3, // 598: switch Inst[14:12] {
16703 0, 7, // 601: case 0x0: {
16704 OPC_CheckPredicate, 197, 1, // 603: check predicate 197
16705 OPC_Decode, 233, 114, 31, // 606: decode to FLE_D_INX using decoder 31
16706 // 606: }
16707 1, 7, // 610: case 0x1: {
16708 OPC_CheckPredicate, 197, 1, // 612: check predicate 197
16709 OPC_Decode, 251, 114, 31, // 615: decode to FLT_D_INX using decoder 31
16710 // 615: }
16711 2, 0, // 619: case 0x2: {
16712 OPC_CheckPredicate, 197, 1, // 621: check predicate 197
16713 OPC_Decode, 220, 114, 31, // 624: decode to FEQ_D_INX using decoder 31
16714 // 624: }
16715 // 624: } // switch Inst[14:12]
16716 // 624: }
16717 82, 33, // 628: case 0x52: {
16718 OPC_SwitchField, 12, 3, // 630: switch Inst[14:12] {
16719 0, 8, // 633: case 0x0: {
16720 OPC_CheckPredicate, 198, 1, // 635: check predicate 198
16721 OPC_Decode, 235, 114, 205, 2, // 638: decode to FLE_H_INX using decoder 333
16722 // 638: }
16723 1, 8, // 643: case 0x1: {
16724 OPC_CheckPredicate, 198, 1, // 645: check predicate 198
16725 OPC_Decode, 253, 114, 205, 2, // 648: decode to FLT_H_INX using decoder 333
16726 // 648: }
16727 2, 0, // 653: case 0x2: {
16728 OPC_CheckPredicate, 198, 1, // 655: check predicate 198
16729 OPC_Decode, 222, 114, 205, 2, // 658: decode to FEQ_H_INX using decoder 333
16730 // 658: }
16731 // 658: } // switch Inst[14:12]
16732 // 658: }
16733 96, 43, // 663: case 0x60: {
16734 OPC_SwitchField, 20, 5, // 665: switch Inst[24:20] {
16735 0, 8, // 668: case 0x0: {
16736 OPC_CheckPredicate, 196, 1, // 670: check predicate 196
16737 OPC_Decode, 206, 114, 197, 2, // 673: decode to FCVT_W_S_INX using decoder 325
16738 // 673: }
16739 1, 8, // 678: case 0x1: {
16740 OPC_CheckPredicate, 196, 1, // 680: check predicate 196
16741 OPC_Decode, 198, 114, 197, 2, // 683: decode to FCVT_WU_S_INX using decoder 325
16742 // 683: }
16743 2, 8, // 688: case 0x2: {
16744 OPC_CheckPredicate, 201, 1, // 690: check predicate 201
16745 OPC_Decode, 169, 114, 197, 2, // 693: decode to FCVT_L_S_INX using decoder 325
16746 // 693: }
16747 3, 0, // 698: case 0x3: {
16748 OPC_CheckPredicate, 201, 1, // 700: check predicate 201
16749 OPC_Decode, 162, 114, 197, 2, // 703: decode to FCVT_LU_S_INX using decoder 325
16750 // 703: }
16751 // 703: } // switch Inst[24:20]
16752 // 703: }
16753 97, 43, // 708: case 0x61: {
16754 OPC_SwitchField, 20, 5, // 710: switch Inst[24:20] {
16755 0, 8, // 713: case 0x0: {
16756 OPC_CheckPredicate, 197, 1, // 715: check predicate 197
16757 OPC_Decode, 201, 114, 202, 2, // 718: decode to FCVT_W_D_INX using decoder 330
16758 // 718: }
16759 1, 8, // 723: case 0x1: {
16760 OPC_CheckPredicate, 197, 1, // 725: check predicate 197
16761 OPC_Decode, 193, 114, 202, 2, // 728: decode to FCVT_WU_D_INX using decoder 330
16762 // 728: }
16763 2, 8, // 733: case 0x2: {
16764 OPC_CheckPredicate, 202, 1, // 735: check predicate 202
16765 OPC_Decode, 164, 114, 202, 2, // 738: decode to FCVT_L_D_INX using decoder 330
16766 // 738: }
16767 3, 0, // 743: case 0x3: {
16768 OPC_CheckPredicate, 202, 1, // 745: check predicate 202
16769 OPC_Decode, 157, 114, 202, 2, // 748: decode to FCVT_LU_D_INX using decoder 330
16770 // 748: }
16771 // 748: } // switch Inst[24:20]
16772 // 748: }
16773 98, 43, // 753: case 0x62: {
16774 OPC_SwitchField, 20, 5, // 755: switch Inst[24:20] {
16775 0, 8, // 758: case 0x0: {
16776 OPC_CheckPredicate, 198, 1, // 760: check predicate 198
16777 OPC_Decode, 203, 114, 198, 2, // 763: decode to FCVT_W_H_INX using decoder 326
16778 // 763: }
16779 1, 8, // 768: case 0x1: {
16780 OPC_CheckPredicate, 198, 1, // 770: check predicate 198
16781 OPC_Decode, 195, 114, 198, 2, // 773: decode to FCVT_WU_H_INX using decoder 326
16782 // 773: }
16783 2, 8, // 778: case 0x2: {
16784 OPC_CheckPredicate, 203, 1, // 780: check predicate 203
16785 OPC_Decode, 166, 114, 198, 2, // 783: decode to FCVT_L_H_INX using decoder 326
16786 // 783: }
16787 3, 0, // 788: case 0x3: {
16788 OPC_CheckPredicate, 203, 1, // 790: check predicate 203
16789 OPC_Decode, 159, 114, 198, 2, // 793: decode to FCVT_LU_H_INX using decoder 326
16790 // 793: }
16791 // 793: } // switch Inst[24:20]
16792 // 793: }
16793 104, 43, // 798: case 0x68: {
16794 OPC_SwitchField, 20, 5, // 800: switch Inst[24:20] {
16795 0, 8, // 803: case 0x0: {
16796 OPC_CheckPredicate, 196, 1, // 805: check predicate 196
16797 OPC_Decode, 190, 114, 195, 2, // 808: decode to FCVT_S_W_INX using decoder 323
16798 // 808: }
16799 1, 8, // 813: case 0x1: {
16800 OPC_CheckPredicate, 196, 1, // 815: check predicate 196
16801 OPC_Decode, 189, 114, 195, 2, // 818: decode to FCVT_S_WU_INX using decoder 323
16802 // 818: }
16803 2, 8, // 823: case 0x2: {
16804 OPC_CheckPredicate, 201, 1, // 825: check predicate 201
16805 OPC_Decode, 185, 114, 195, 2, // 828: decode to FCVT_S_L_INX using decoder 323
16806 // 828: }
16807 3, 0, // 833: case 0x3: {
16808 OPC_CheckPredicate, 201, 1, // 835: check predicate 201
16809 OPC_Decode, 184, 114, 195, 2, // 838: decode to FCVT_S_LU_INX using decoder 323
16810 // 838: }
16811 // 838: } // switch Inst[24:20]
16812 // 838: }
16813 105, 43, // 843: case 0x69: {
16814 OPC_SwitchField, 20, 5, // 845: switch Inst[24:20] {
16815 0, 8, // 848: case 0x0: {
16816 OPC_CheckPredicate, 197, 1, // 850: check predicate 197
16817 OPC_Decode, 142, 114, 202, 2, // 853: decode to FCVT_D_W_INX using decoder 330
16818 // 853: }
16819 1, 8, // 858: case 0x1: {
16820 OPC_CheckPredicate, 197, 1, // 860: check predicate 197
16821 OPC_Decode, 140, 114, 202, 2, // 863: decode to FCVT_D_WU_INX using decoder 330
16822 // 863: }
16823 2, 8, // 868: case 0x2: {
16824 OPC_CheckPredicate, 202, 1, // 870: check predicate 202
16825 OPC_Decode, 132, 114, 202, 2, // 873: decode to FCVT_D_L_INX using decoder 330
16826 // 873: }
16827 3, 0, // 878: case 0x3: {
16828 OPC_CheckPredicate, 202, 1, // 880: check predicate 202
16829 OPC_Decode, 131, 114, 202, 2, // 883: decode to FCVT_D_LU_INX using decoder 330
16830 // 883: }
16831 // 883: } // switch Inst[24:20]
16832 // 883: }
16833 106, 43, // 888: case 0x6a: {
16834 OPC_SwitchField, 20, 5, // 890: switch Inst[24:20] {
16835 0, 8, // 893: case 0x0: {
16836 OPC_CheckPredicate, 198, 1, // 895: check predicate 198
16837 OPC_Decode, 155, 114, 200, 2, // 898: decode to FCVT_H_W_INX using decoder 328
16838 // 898: }
16839 1, 8, // 903: case 0x1: {
16840 OPC_CheckPredicate, 198, 1, // 905: check predicate 198
16841 OPC_Decode, 154, 114, 200, 2, // 908: decode to FCVT_H_WU_INX using decoder 328
16842 // 908: }
16843 2, 8, // 913: case 0x2: {
16844 OPC_CheckPredicate, 203, 1, // 915: check predicate 203
16845 OPC_Decode, 149, 114, 200, 2, // 918: decode to FCVT_H_L_INX using decoder 328
16846 // 918: }
16847 3, 0, // 923: case 0x3: {
16848 OPC_CheckPredicate, 203, 1, // 925: check predicate 203
16849 OPC_Decode, 148, 114, 200, 2, // 928: decode to FCVT_H_LU_INX using decoder 328
16850 // 928: }
16851 // 928: } // switch Inst[24:20]
16852 // 928: }
16853 112, 16, // 933: case 0x70: {
16854 OPC_CheckPredicate, 196, 1, // 935: check predicate 196
16855 OPC_CheckField, 20, 5, 0, // 938: check Inst[24:20] == 0x0
16856 OPC_CheckField, 12, 3, 1, // 942: check Inst[14:12] == 0x1
16857 OPC_Decode, 251, 113, 206, 2, // 946: decode to FCLASS_S_INX using decoder 334
16858 // 946: }
16859 113, 15, // 951: case 0x71: {
16860 OPC_CheckPredicate, 197, 1, // 953: check predicate 197
16861 OPC_CheckField, 20, 5, 0, // 956: check Inst[24:20] == 0x0
16862 OPC_CheckField, 12, 3, 1, // 960: check Inst[14:12] == 0x1
16863 OPC_Decode, 246, 113, 17, // 964: decode to FCLASS_D_INX using decoder 17
16864 // 964: }
16865 114, 0, // 968: case 0x72: {
16866 OPC_CheckPredicate, 198, 1, // 970: check predicate 198
16867 OPC_CheckField, 20, 5, 0, // 973: check Inst[24:20] == 0x0
16868 OPC_CheckField, 12, 3, 1, // 977: check Inst[14:12] == 0x1
16869 OPC_Decode, 248, 113, 207, 2, // 981: decode to FCLASS_H_INX using decoder 335
16870 // 981: }
16871 // 981: } // switch Inst[31:25]
16872 // 981: }
16873 // 981: } // switch Inst[6:0]
16874};
16875// Handling 336 cases.
16876template <typename InsnType>
16877static std::enable_if_t<InsnBitWidth<InsnType> == 32, DecodeStatus>
16878decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
16879 DecodeComplete = true;
16880 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
16881 TmpType tmp;
16882 switch (Idx) {
16883 default: llvm_unreachable("Invalid decoder index!");
16884 case 0:
16885 tmp = fieldFromInstruction(insn, 7, 5);
16886 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16887 tmp = fieldFromInstruction(insn, 15, 5);
16888 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16889 tmp = fieldFromInstruction(insn, 20, 12);
16890 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16891 return S;
16892 case 1:
16893 tmp = fieldFromInstruction(insn, 7, 5);
16894 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16895 tmp = fieldFromInstruction(insn, 15, 5);
16896 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16897 tmp = fieldFromInstruction(insn, 25, 1);
16898 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16899 return S;
16900 case 2:
16901 tmp = fieldFromInstruction(insn, 7, 5);
16902 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16903 tmp = fieldFromInstruction(insn, 15, 5);
16904 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16905 return S;
16906 case 3:
16907 tmp = fieldFromInstruction(insn, 7, 5);
16908 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16909 tmp = fieldFromInstruction(insn, 15, 5);
16910 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16911 tmp = fieldFromInstruction(insn, 20, 5);
16912 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16913 tmp = fieldFromInstruction(insn, 25, 1);
16914 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16915 return S;
16916 case 4:
16917 tmp = fieldFromInstruction(insn, 7, 5);
16918 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16919 tmp = fieldFromInstruction(insn, 15, 5);
16920 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16921 tmp = fieldFromInstruction(insn, 20, 5);
16922 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16923 tmp = fieldFromInstruction(insn, 25, 1);
16924 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16925 return S;
16926 case 5:
16927 tmp = fieldFromInstruction(insn, 7, 5);
16928 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16929 tmp = fieldFromInstruction(insn, 15, 5);
16930 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16931 return S;
16932 case 6:
16933 tmp = fieldFromInstruction(insn, 7, 5);
16934 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16935 tmp = fieldFromInstruction(insn, 15, 5);
16936 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16937 return S;
16938 case 7:
16939 tmp = fieldFromInstruction(insn, 7, 5);
16940 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16941 tmp = fieldFromInstruction(insn, 15, 5);
16942 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16943 return S;
16944 case 8:
16945 tmp = fieldFromInstruction(insn, 7, 5);
16946 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16947 tmp = fieldFromInstruction(insn, 15, 5);
16948 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16949 tmp = fieldFromInstruction(insn, 20, 12);
16950 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16951 return S;
16952 case 9:
16953 tmp = fieldFromInstruction(insn, 7, 5);
16954 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16955 tmp = fieldFromInstruction(insn, 15, 5);
16956 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16957 tmp = fieldFromInstruction(insn, 20, 12);
16958 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16959 return S;
16960 case 10:
16961 tmp = fieldFromInstruction(insn, 7, 5);
16962 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16963 tmp = fieldFromInstruction(insn, 15, 5);
16964 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16965 tmp = fieldFromInstruction(insn, 20, 12);
16966 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16967 return S;
16968 case 11:
16969 tmp = fieldFromInstruction(insn, 7, 5);
16970 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16971 tmp = fieldFromInstruction(insn, 15, 5);
16972 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16973 tmp = fieldFromInstruction(insn, 20, 12);
16974 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16975 return S;
16976 case 12:
16977 tmp = fieldFromInstruction(insn, 7, 5);
16978 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16979 tmp = fieldFromInstruction(insn, 15, 5);
16980 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16981 tmp = fieldFromInstruction(insn, 20, 5);
16982 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16983 tmp = fieldFromInstruction(insn, 29, 3);
16984 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16985 tmp = fieldFromInstruction(insn, 25, 1);
16986 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16987 return S;
16988 case 13:
16989 tmp = fieldFromInstruction(insn, 24, 4);
16990 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16991 tmp = fieldFromInstruction(insn, 20, 4);
16992 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16993 return S;
16994 case 14:
16995 return S;
16996 case 15:
16997 tmp = fieldFromInstruction(insn, 15, 5);
16998 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16999 return S;
17000 case 16:
17001 tmp = fieldFromInstruction(insn, 7, 5);
17002 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17003 tmp = fieldFromInstruction(insn, 15, 5);
17004 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17005 tmp = fieldFromInstruction(insn, 20, 6);
17006 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17007 return S;
17008 case 17:
17009 tmp = fieldFromInstruction(insn, 7, 5);
17010 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17011 tmp = fieldFromInstruction(insn, 15, 5);
17012 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17013 return S;
17014 case 18:
17015 tmp = fieldFromInstruction(insn, 7, 5);
17016 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17017 tmp = fieldFromInstruction(insn, 15, 5);
17018 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17019 tmp = fieldFromInstruction(insn, 20, 4);
17020 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17021 return S;
17022 case 19:
17023 tmp = fieldFromInstruction(insn, 15, 5);
17024 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17025 tmp = fieldFromInstruction(insn, 25, 7) << 5;
17026 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17027 return S;
17028 case 20:
17029 tmp = fieldFromInstruction(insn, 7, 5);
17030 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17031 tmp = fieldFromInstruction(insn, 12, 20);
17032 if (!Check(S, decodeUImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17033 return S;
17034 case 21:
17035 tmp = fieldFromInstruction(insn, 7, 5);
17036 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17037 tmp = fieldFromInstruction(insn, 15, 5);
17038 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17039 tmp = fieldFromInstruction(insn, 20, 5);
17040 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17041 return S;
17042 case 22:
17043 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17044 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17045 tmp = fieldFromInstruction(insn, 15, 5);
17046 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17047 tmp = fieldFromInstruction(insn, 20, 4);
17048 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17049 return S;
17050 case 23:
17051 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17052 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17053 tmp = fieldFromInstruction(insn, 15, 5);
17054 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17055 tmp = fieldFromInstruction(insn, 20, 5);
17056 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17057 return S;
17058 case 24:
17059 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17060 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17061 tmp = fieldFromInstruction(insn, 15, 5);
17062 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17063 tmp = fieldFromInstruction(insn, 20, 5);
17064 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17065 return S;
17066 case 25:
17067 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17068 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17069 tmp = fieldFromInstruction(insn, 15, 5);
17070 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17071 tmp = fieldFromInstruction(insn, 20, 6);
17072 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17073 return S;
17074 case 26:
17075 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17076 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17077 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17078 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17079 tmp = fieldFromInstruction(insn, 15, 5);
17080 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17081 tmp = fieldFromInstruction(insn, 20, 5);
17082 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17083 return S;
17084 case 27:
17085 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17086 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17087 tmp = 0x0;
17088 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
17089 tmp |= fieldFromInstruction(insn, 16, 9);
17090 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17091 return S;
17092 case 28:
17093 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17094 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17095 tmp = fieldFromInstruction(insn, 16, 8);
17096 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17097 return S;
17098 case 29:
17099 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17100 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17101 tmp = 0x0;
17102 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
17103 tmp |= fieldFromInstruction(insn, 24, 1);
17104 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17105 return S;
17106 case 30:
17107 tmp = fieldFromInstruction(insn, 7, 5);
17108 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17109 tmp = fieldFromInstruction(insn, 15, 5);
17110 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17111 tmp = fieldFromInstruction(insn, 20, 3);
17112 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17113 return S;
17114 case 31:
17115 tmp = fieldFromInstruction(insn, 7, 5);
17116 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17117 tmp = fieldFromInstruction(insn, 15, 5);
17118 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17119 tmp = fieldFromInstruction(insn, 20, 5);
17120 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17121 return S;
17122 case 32:
17123 tmp = fieldFromInstruction(insn, 7, 5);
17124 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17125 tmp = 0x0;
17126 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
17127 tmp |= fieldFromInstruction(insn, 16, 9);
17128 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17129 return S;
17130 case 33:
17131 tmp = fieldFromInstruction(insn, 7, 5);
17132 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17133 tmp = fieldFromInstruction(insn, 16, 8);
17134 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17135 return S;
17136 case 34:
17137 tmp = fieldFromInstruction(insn, 7, 5);
17138 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17139 tmp = 0x0;
17140 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
17141 tmp |= fieldFromInstruction(insn, 24, 1);
17142 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17143 return S;
17144 case 35:
17145 tmp = fieldFromInstruction(insn, 7, 5);
17146 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17147 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17148 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17149 tmp = fieldFromInstruction(insn, 20, 4);
17150 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17151 return S;
17152 case 36:
17153 tmp = fieldFromInstruction(insn, 7, 5);
17154 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17155 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17156 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17157 tmp = fieldFromInstruction(insn, 20, 5);
17158 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17159 return S;
17160 case 37:
17161 tmp = fieldFromInstruction(insn, 7, 5);
17162 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17163 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17164 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17165 tmp = fieldFromInstruction(insn, 20, 6);
17166 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17167 return S;
17168 case 38:
17169 tmp = fieldFromInstruction(insn, 7, 5);
17170 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17171 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17172 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17173 tmp = fieldFromInstruction(insn, 20, 5);
17174 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17175 return S;
17176 case 39:
17177 tmp = fieldFromInstruction(insn, 7, 5);
17178 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17179 tmp = fieldFromInstruction(insn, 15, 5);
17180 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17181 tmp = fieldFromInstruction(insn, 20, 6);
17182 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17183 return S;
17184 case 40:
17185 tmp = fieldFromInstruction(insn, 7, 5);
17186 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17187 tmp = fieldFromInstruction(insn, 15, 5);
17188 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17189 tmp = fieldFromInstruction(insn, 20, 4);
17190 if (!Check(S, decodeUImmPlus1Operand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17191 return S;
17192 case 41:
17193 tmp = fieldFromInstruction(insn, 7, 5);
17194 if (!Check(S, DecodeGPRRegisterClass(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 tmp = fieldFromInstruction(insn, 20, 5);
17198 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17199 return S;
17200 case 42:
17201 tmp = fieldFromInstruction(insn, 7, 5);
17202 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17203 tmp = fieldFromInstruction(insn, 15, 5);
17204 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17205 tmp = fieldFromInstruction(insn, 20, 6);
17206 if (!Check(S, decodeUImmPlus1Operand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17207 return S;
17208 case 43:
17209 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17210 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17211 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17212 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17213 tmp = fieldFromInstruction(insn, 20, 3);
17214 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17215 return S;
17216 case 44:
17217 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17218 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17219 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17220 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17221 tmp = fieldFromInstruction(insn, 20, 4);
17222 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17223 return S;
17224 case 45:
17225 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17226 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17227 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17228 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17229 tmp = fieldFromInstruction(insn, 20, 5);
17230 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17231 return S;
17232 case 46:
17233 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17234 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17235 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17236 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17237 tmp = fieldFromInstruction(insn, 20, 5);
17238 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17239 return S;
17240 case 47:
17241 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17242 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17243 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17244 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17245 return S;
17246 case 48:
17247 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17248 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17249 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17250 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17251 tmp = fieldFromInstruction(insn, 21, 4) << 1;
17252 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17253 return S;
17254 case 49:
17255 tmp = fieldFromInstruction(insn, 20, 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 = 0x0;
17260 tmp |= fieldFromInstruction(insn, 7, 5);
17261 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17262 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17263 return S;
17264 case 50:
17265 tmp = fieldFromInstruction(insn, 20, 5);
17266 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17267 tmp = fieldFromInstruction(insn, 15, 5);
17268 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17269 tmp = 0x0;
17270 tmp |= fieldFromInstruction(insn, 7, 5);
17271 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17272 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17273 return S;
17274 case 51:
17275 tmp = fieldFromInstruction(insn, 20, 5);
17276 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17277 tmp = fieldFromInstruction(insn, 15, 5);
17278 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17279 tmp = 0x0;
17280 tmp |= fieldFromInstruction(insn, 7, 5);
17281 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17282 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17283 return S;
17284 case 52:
17285 tmp = fieldFromInstruction(insn, 20, 5);
17286 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17287 tmp = fieldFromInstruction(insn, 15, 5);
17288 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17289 tmp = 0x0;
17290 tmp |= fieldFromInstruction(insn, 7, 5);
17291 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17292 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17293 return S;
17294 case 53:
17295 tmp = fieldFromInstruction(insn, 20, 5);
17296 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17297 tmp = fieldFromInstruction(insn, 15, 5);
17298 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17299 tmp = 0x0;
17300 tmp |= fieldFromInstruction(insn, 7, 5);
17301 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17302 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17303 return S;
17304 case 54:
17305 tmp = fieldFromInstruction(insn, 7, 5);
17306 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17307 tmp = fieldFromInstruction(insn, 20, 5);
17308 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17309 tmp = fieldFromInstruction(insn, 15, 5);
17310 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17311 return S;
17312 case 55:
17313 tmp = fieldFromInstruction(insn, 7, 5);
17314 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17315 tmp = fieldFromInstruction(insn, 7, 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 tmp = fieldFromInstruction(insn, 15, 5);
17320 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17321 return S;
17322 case 56:
17323 tmp = fieldFromInstruction(insn, 7, 5);
17324 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17325 tmp = fieldFromInstruction(insn, 7, 5);
17326 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17327 tmp = fieldFromInstruction(insn, 20, 5);
17328 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17329 tmp = fieldFromInstruction(insn, 15, 5);
17330 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17331 return S;
17332 case 57:
17333 tmp = fieldFromInstruction(insn, 20, 5);
17334 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17335 tmp = fieldFromInstruction(insn, 15, 5);
17336 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17337 return S;
17338 case 58:
17339 tmp = fieldFromInstruction(insn, 7, 5);
17340 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17341 tmp = fieldFromInstruction(insn, 15, 5);
17342 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17343 tmp = fieldFromInstruction(insn, 20, 5);
17344 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17345 tmp = fieldFromInstruction(insn, 30, 2);
17346 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17347 return S;
17348 case 59:
17349 tmp = fieldFromInstruction(insn, 7, 5);
17350 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17351 tmp = fieldFromInstruction(insn, 7, 5);
17352 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17353 tmp = fieldFromInstruction(insn, 15, 5);
17354 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17355 tmp = fieldFromInstruction(insn, 20, 5);
17356 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17357 return S;
17358 case 60:
17359 tmp = fieldFromInstruction(insn, 7, 5);
17360 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17361 tmp = fieldFromInstruction(insn, 15, 5);
17362 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17363 tmp = fieldFromInstruction(insn, 20, 5);
17364 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17365 tmp = fieldFromInstruction(insn, 27, 5);
17366 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17367 tmp = fieldFromInstruction(insn, 12, 3);
17368 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17369 return S;
17370 case 61:
17371 tmp = fieldFromInstruction(insn, 7, 5);
17372 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17373 tmp = fieldFromInstruction(insn, 15, 5);
17374 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17375 tmp = fieldFromInstruction(insn, 20, 5);
17376 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17377 tmp = fieldFromInstruction(insn, 27, 5);
17378 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17379 tmp = fieldFromInstruction(insn, 12, 3);
17380 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17381 return S;
17382 case 62:
17383 tmp = fieldFromInstruction(insn, 7, 5);
17384 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17385 tmp = fieldFromInstruction(insn, 15, 5);
17386 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17387 tmp = fieldFromInstruction(insn, 20, 5);
17388 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17389 tmp = fieldFromInstruction(insn, 27, 5);
17390 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17391 tmp = fieldFromInstruction(insn, 12, 3);
17392 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17393 return S;
17394 case 63:
17395 tmp = fieldFromInstruction(insn, 7, 5);
17396 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17397 tmp = fieldFromInstruction(insn, 15, 5);
17398 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17399 tmp = fieldFromInstruction(insn, 20, 5);
17400 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17401 tmp = fieldFromInstruction(insn, 27, 5);
17402 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17403 tmp = fieldFromInstruction(insn, 12, 3);
17404 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17405 return S;
17406 case 64:
17407 tmp = fieldFromInstruction(insn, 7, 5);
17408 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17409 tmp = fieldFromInstruction(insn, 15, 5);
17410 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17411 tmp = fieldFromInstruction(insn, 20, 5);
17412 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17413 tmp = fieldFromInstruction(insn, 12, 3);
17414 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17415 return S;
17416 case 65:
17417 tmp = fieldFromInstruction(insn, 7, 5);
17418 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17419 tmp = fieldFromInstruction(insn, 15, 5);
17420 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17421 tmp = fieldFromInstruction(insn, 20, 5);
17422 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17423 tmp = fieldFromInstruction(insn, 12, 3);
17424 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17425 return S;
17426 case 66:
17427 tmp = fieldFromInstruction(insn, 7, 5);
17428 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17429 tmp = fieldFromInstruction(insn, 15, 5);
17430 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17431 tmp = fieldFromInstruction(insn, 20, 5);
17432 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17433 tmp = fieldFromInstruction(insn, 12, 3);
17434 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17435 return S;
17436 case 67:
17437 tmp = fieldFromInstruction(insn, 7, 5);
17438 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17439 tmp = fieldFromInstruction(insn, 15, 5);
17440 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17441 tmp = fieldFromInstruction(insn, 20, 5);
17442 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17443 tmp = fieldFromInstruction(insn, 12, 3);
17444 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17445 return S;
17446 case 68:
17447 tmp = fieldFromInstruction(insn, 7, 5);
17448 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17449 tmp = fieldFromInstruction(insn, 15, 5);
17450 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17451 tmp = fieldFromInstruction(insn, 20, 5);
17452 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17453 return S;
17454 case 69:
17455 tmp = fieldFromInstruction(insn, 7, 5);
17456 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17457 tmp = fieldFromInstruction(insn, 15, 5);
17458 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17459 tmp = fieldFromInstruction(insn, 20, 5);
17460 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17461 return S;
17462 case 70:
17463 tmp = fieldFromInstruction(insn, 7, 5);
17464 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17465 tmp = fieldFromInstruction(insn, 15, 5);
17466 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17467 tmp = fieldFromInstruction(insn, 20, 5);
17468 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17469 return S;
17470 case 71:
17471 tmp = fieldFromInstruction(insn, 7, 5);
17472 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17473 tmp = fieldFromInstruction(insn, 15, 5);
17474 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17475 tmp = fieldFromInstruction(insn, 20, 5);
17476 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17477 return S;
17478 case 72:
17479 tmp = fieldFromInstruction(insn, 7, 5);
17480 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17481 tmp = fieldFromInstruction(insn, 15, 5);
17482 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17483 tmp = fieldFromInstruction(insn, 12, 3);
17484 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17485 return S;
17486 case 73:
17487 tmp = fieldFromInstruction(insn, 7, 5);
17488 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17489 tmp = fieldFromInstruction(insn, 15, 5);
17490 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17491 tmp = fieldFromInstruction(insn, 12, 3);
17492 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17493 return S;
17494 case 74:
17495 tmp = fieldFromInstruction(insn, 7, 5);
17496 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17497 tmp = fieldFromInstruction(insn, 15, 5);
17498 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17499 tmp = fieldFromInstruction(insn, 12, 3);
17500 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17501 return S;
17502 case 75:
17503 tmp = fieldFromInstruction(insn, 7, 5);
17504 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17505 tmp = fieldFromInstruction(insn, 15, 5);
17506 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17507 tmp = fieldFromInstruction(insn, 12, 3);
17508 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17509 return S;
17510 case 76:
17511 tmp = fieldFromInstruction(insn, 7, 5);
17512 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17513 tmp = fieldFromInstruction(insn, 15, 5);
17514 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17515 tmp = fieldFromInstruction(insn, 12, 3);
17516 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17517 return S;
17518 case 77:
17519 tmp = fieldFromInstruction(insn, 7, 5);
17520 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17521 tmp = fieldFromInstruction(insn, 15, 5);
17522 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17523 tmp = fieldFromInstruction(insn, 12, 3);
17524 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17525 return S;
17526 case 78:
17527 tmp = fieldFromInstruction(insn, 7, 5);
17528 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17529 tmp = fieldFromInstruction(insn, 15, 5);
17530 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17531 tmp = fieldFromInstruction(insn, 12, 3);
17532 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17533 return S;
17534 case 79:
17535 tmp = fieldFromInstruction(insn, 7, 5);
17536 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17537 tmp = fieldFromInstruction(insn, 15, 5);
17538 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17539 tmp = fieldFromInstruction(insn, 12, 3);
17540 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17541 return S;
17542 case 80:
17543 tmp = fieldFromInstruction(insn, 7, 5);
17544 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17545 tmp = fieldFromInstruction(insn, 15, 5);
17546 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17547 tmp = fieldFromInstruction(insn, 12, 3);
17548 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17549 return S;
17550 case 81:
17551 tmp = fieldFromInstruction(insn, 7, 5);
17552 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17553 tmp = fieldFromInstruction(insn, 15, 5);
17554 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17555 tmp = fieldFromInstruction(insn, 12, 3);
17556 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17557 return S;
17558 case 82:
17559 tmp = fieldFromInstruction(insn, 7, 5);
17560 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17561 tmp = fieldFromInstruction(insn, 15, 5);
17562 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17563 tmp = fieldFromInstruction(insn, 12, 3);
17564 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17565 return S;
17566 case 83:
17567 tmp = fieldFromInstruction(insn, 7, 5);
17568 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17569 tmp = fieldFromInstruction(insn, 15, 5);
17570 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17571 tmp = fieldFromInstruction(insn, 12, 3);
17572 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17573 return S;
17574 case 84:
17575 tmp = fieldFromInstruction(insn, 7, 5);
17576 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17577 tmp = fieldFromInstruction(insn, 15, 5);
17578 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17579 tmp = fieldFromInstruction(insn, 12, 3);
17580 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17581 return S;
17582 case 85:
17583 tmp = fieldFromInstruction(insn, 7, 5);
17584 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17585 tmp = fieldFromInstruction(insn, 15, 5);
17586 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17587 tmp = fieldFromInstruction(insn, 12, 3);
17588 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17589 return S;
17590 case 86:
17591 tmp = fieldFromInstruction(insn, 7, 5);
17592 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17593 tmp = fieldFromInstruction(insn, 15, 5);
17594 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17595 tmp = fieldFromInstruction(insn, 20, 5);
17596 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17597 return S;
17598 case 87:
17599 tmp = fieldFromInstruction(insn, 7, 5);
17600 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17601 tmp = fieldFromInstruction(insn, 15, 5);
17602 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17603 tmp = fieldFromInstruction(insn, 20, 5);
17604 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17605 return S;
17606 case 88:
17607 tmp = fieldFromInstruction(insn, 7, 5);
17608 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17609 tmp = fieldFromInstruction(insn, 15, 5);
17610 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17611 tmp = fieldFromInstruction(insn, 20, 5);
17612 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17613 return S;
17614 case 89:
17615 tmp = fieldFromInstruction(insn, 7, 5);
17616 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17617 tmp = fieldFromInstruction(insn, 15, 5);
17618 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17619 tmp = fieldFromInstruction(insn, 20, 5);
17620 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17621 return S;
17622 case 90:
17623 tmp = fieldFromInstruction(insn, 7, 5);
17624 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17625 tmp = fieldFromInstruction(insn, 15, 5);
17626 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17627 tmp = fieldFromInstruction(insn, 20, 5);
17628 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17629 return S;
17630 case 91:
17631 tmp = fieldFromInstruction(insn, 7, 5);
17632 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17633 tmp = fieldFromInstruction(insn, 15, 5);
17634 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17635 tmp = fieldFromInstruction(insn, 20, 5);
17636 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17637 return S;
17638 case 92:
17639 tmp = fieldFromInstruction(insn, 7, 5);
17640 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17641 tmp = fieldFromInstruction(insn, 15, 5);
17642 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17643 tmp = fieldFromInstruction(insn, 12, 3);
17644 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17645 return S;
17646 case 93:
17647 tmp = fieldFromInstruction(insn, 7, 5);
17648 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17649 tmp = fieldFromInstruction(insn, 15, 5);
17650 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17651 tmp = fieldFromInstruction(insn, 12, 3);
17652 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17653 return S;
17654 case 94:
17655 tmp = fieldFromInstruction(insn, 7, 5);
17656 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17657 tmp = fieldFromInstruction(insn, 15, 5);
17658 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17659 tmp = 0x1;
17660 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17661 return S;
17662 case 95:
17663 tmp = fieldFromInstruction(insn, 7, 5);
17664 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17665 tmp = fieldFromInstruction(insn, 15, 5);
17666 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 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 96:
17671 tmp = fieldFromInstruction(insn, 7, 5);
17672 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17673 tmp = fieldFromInstruction(insn, 15, 5);
17674 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17675 tmp = fieldFromInstruction(insn, 12, 3);
17676 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17677 return S;
17678 case 97:
17679 tmp = fieldFromInstruction(insn, 7, 5);
17680 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17681 tmp = fieldFromInstruction(insn, 15, 5);
17682 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17683 tmp = fieldFromInstruction(insn, 12, 3);
17684 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17685 return S;
17686 case 98:
17687 tmp = fieldFromInstruction(insn, 7, 5);
17688 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17689 tmp = fieldFromInstruction(insn, 15, 5);
17690 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17691 tmp = fieldFromInstruction(insn, 12, 3);
17692 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17693 return S;
17694 case 99:
17695 tmp = fieldFromInstruction(insn, 7, 5);
17696 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17697 tmp = fieldFromInstruction(insn, 15, 5);
17698 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17699 tmp = fieldFromInstruction(insn, 12, 3);
17700 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17701 return S;
17702 case 100:
17703 tmp = fieldFromInstruction(insn, 7, 5);
17704 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17705 tmp = fieldFromInstruction(insn, 15, 5);
17706 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17707 tmp = fieldFromInstruction(insn, 12, 3);
17708 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17709 return S;
17710 case 101:
17711 tmp = fieldFromInstruction(insn, 7, 5);
17712 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17713 tmp = fieldFromInstruction(insn, 15, 5);
17714 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17715 return S;
17716 case 102:
17717 tmp = fieldFromInstruction(insn, 7, 5);
17718 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17719 tmp = fieldFromInstruction(insn, 15, 5);
17720 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17721 return S;
17722 case 103:
17723 tmp = fieldFromInstruction(insn, 7, 5);
17724 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17725 tmp = fieldFromInstruction(insn, 15, 5);
17726 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17727 return S;
17728 case 104:
17729 tmp = fieldFromInstruction(insn, 7, 5);
17730 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17731 tmp = fieldFromInstruction(insn, 15, 5);
17732 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17733 return S;
17734 case 105:
17735 tmp = fieldFromInstruction(insn, 7, 5);
17736 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17737 tmp = fieldFromInstruction(insn, 15, 5);
17738 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17739 return S;
17740 case 106:
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 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
17745 return S;
17746 case 107:
17747 tmp = fieldFromInstruction(insn, 7, 5);
17748 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17749 tmp = fieldFromInstruction(insn, 15, 5);
17750 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17751 return S;
17752 case 108:
17753 tmp = fieldFromInstruction(insn, 7, 5);
17754 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17755 tmp = fieldFromInstruction(insn, 15, 5);
17756 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
17757 return S;
17758 case 109:
17759 tmp = fieldFromInstruction(insn, 7, 5);
17760 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17761 tmp = fieldFromInstruction(insn, 15, 5);
17762 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17763 return S;
17764 case 110:
17765 tmp = fieldFromInstruction(insn, 7, 5);
17766 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17767 tmp = fieldFromInstruction(insn, 15, 5);
17768 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
17769 return S;
17770 case 111:
17771 tmp = fieldFromInstruction(insn, 7, 5);
17772 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17773 tmp = fieldFromInstruction(insn, 15, 5);
17774 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
17775 return S;
17776 case 112:
17777 tmp = fieldFromInstruction(insn, 7, 5);
17778 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17779 tmp = fieldFromInstruction(insn, 20, 5);
17780 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17781 tmp = fieldFromInstruction(insn, 15, 5);
17782 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17783 tmp = fieldFromInstruction(insn, 25, 1);
17784 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17785 return S;
17786 case 113:
17787 tmp = fieldFromInstruction(insn, 7, 5);
17788 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17789 tmp = fieldFromInstruction(insn, 20, 5);
17790 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17791 tmp = fieldFromInstruction(insn, 15, 5);
17792 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17793 tmp = 0x0;
17794 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17795 return S;
17796 case 114:
17797 tmp = fieldFromInstruction(insn, 7, 5);
17798 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17799 tmp = fieldFromInstruction(insn, 20, 5);
17800 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17801 tmp = fieldFromInstruction(insn, 15, 5);
17802 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17803 return S;
17804 case 115:
17805 tmp = fieldFromInstruction(insn, 7, 5);
17806 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17807 tmp = fieldFromInstruction(insn, 15, 5);
17808 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17809 return S;
17810 case 116:
17811 tmp = fieldFromInstruction(insn, 7, 5);
17812 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17813 tmp = fieldFromInstruction(insn, 7, 5);
17814 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17815 tmp = fieldFromInstruction(insn, 15, 5);
17816 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17817 tmp = fieldFromInstruction(insn, 20, 5);
17818 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17819 return S;
17820 case 117:
17821 tmp = fieldFromInstruction(insn, 7, 5);
17822 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17823 tmp = fieldFromInstruction(insn, 7, 5);
17824 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17825 tmp = fieldFromInstruction(insn, 15, 5);
17826 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17827 tmp = fieldFromInstruction(insn, 20, 5);
17828 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17829 tmp = 0x0;
17830 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17831 return S;
17832 case 118:
17833 tmp = fieldFromInstruction(insn, 7, 5);
17834 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17835 tmp = fieldFromInstruction(insn, 20, 5);
17836 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17837 return S;
17838 case 119:
17839 tmp = fieldFromInstruction(insn, 7, 5);
17840 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17841 tmp = fieldFromInstruction(insn, 20, 5);
17842 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17843 tmp = fieldFromInstruction(insn, 25, 1);
17844 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17845 return S;
17846 case 120:
17847 tmp = fieldFromInstruction(insn, 7, 5);
17848 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17849 tmp = fieldFromInstruction(insn, 7, 5);
17850 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17851 tmp = fieldFromInstruction(insn, 15, 5);
17852 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17853 tmp = fieldFromInstruction(insn, 20, 5);
17854 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17855 tmp = fieldFromInstruction(insn, 25, 1);
17856 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17857 return S;
17858 case 121:
17859 tmp = fieldFromInstruction(insn, 7, 5);
17860 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17861 tmp = fieldFromInstruction(insn, 20, 5);
17862 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17863 return S;
17864 case 122:
17865 tmp = fieldFromInstruction(insn, 7, 5);
17866 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17867 tmp = fieldFromInstruction(insn, 20, 5);
17868 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17869 tmp = fieldFromInstruction(insn, 25, 1);
17870 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17871 return S;
17872 case 123:
17873 tmp = fieldFromInstruction(insn, 7, 5);
17874 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17875 tmp = fieldFromInstruction(insn, 25, 1);
17876 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17877 return S;
17878 case 124:
17879 tmp = fieldFromInstruction(insn, 7, 5);
17880 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17881 tmp = fieldFromInstruction(insn, 7, 5);
17882 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17883 tmp = fieldFromInstruction(insn, 20, 5);
17884 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17885 tmp = fieldFromInstruction(insn, 15, 5);
17886 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17887 tmp = fieldFromInstruction(insn, 25, 1);
17888 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17889 return S;
17890 case 125:
17891 tmp = fieldFromInstruction(insn, 7, 5);
17892 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17893 tmp = fieldFromInstruction(insn, 20, 5);
17894 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17895 tmp = fieldFromInstruction(insn, 15, 5);
17896 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17897 tmp = fieldFromInstruction(insn, 25, 1);
17898 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17899 return S;
17900 case 126:
17901 tmp = fieldFromInstruction(insn, 7, 5);
17902 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17903 tmp = fieldFromInstruction(insn, 20, 5);
17904 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17905 tmp = fieldFromInstruction(insn, 15, 5);
17906 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17907 tmp = fieldFromInstruction(insn, 25, 1);
17908 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17909 return S;
17910 case 127:
17911 tmp = fieldFromInstruction(insn, 7, 5);
17912 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17913 tmp = fieldFromInstruction(insn, 20, 5);
17914 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17915 tmp = fieldFromInstruction(insn, 15, 5);
17916 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17917 tmp = 0x0;
17918 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17919 return S;
17920 case 128:
17921 tmp = fieldFromInstruction(insn, 7, 5);
17922 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17923 tmp = fieldFromInstruction(insn, 20, 5);
17924 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17925 tmp = fieldFromInstruction(insn, 15, 5);
17926 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17927 return S;
17928 case 129:
17929 tmp = fieldFromInstruction(insn, 7, 5);
17930 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17931 tmp = fieldFromInstruction(insn, 20, 5);
17932 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17933 tmp = 0x0;
17934 tmp |= fieldFromInstruction(insn, 15, 5);
17935 tmp |= fieldFromInstruction(insn, 26, 1) << 5;
17936 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17937 tmp = fieldFromInstruction(insn, 25, 1);
17938 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17939 return S;
17940 case 130:
17941 tmp = fieldFromInstruction(insn, 7, 5);
17942 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17943 tmp = fieldFromInstruction(insn, 15, 5);
17944 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17945 return S;
17946 case 131:
17947 tmp = fieldFromInstruction(insn, 7, 5);
17948 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17949 tmp = fieldFromInstruction(insn, 20, 5);
17950 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17951 return S;
17952 case 132:
17953 tmp = fieldFromInstruction(insn, 7, 5);
17954 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17955 tmp = fieldFromInstruction(insn, 20, 5);
17956 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17957 return S;
17958 case 133:
17959 tmp = fieldFromInstruction(insn, 7, 5);
17960 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17961 tmp = fieldFromInstruction(insn, 20, 5);
17962 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17963 return S;
17964 case 134:
17965 tmp = fieldFromInstruction(insn, 7, 5);
17966 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17967 tmp = fieldFromInstruction(insn, 20, 5);
17968 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17969 return S;
17970 case 135:
17971 tmp = fieldFromInstruction(insn, 7, 5);
17972 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17973 tmp = fieldFromInstruction(insn, 20, 5);
17974 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17975 tmp = fieldFromInstruction(insn, 15, 5);
17976 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17977 tmp = fieldFromInstruction(insn, 25, 1);
17978 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17979 return S;
17980 case 136:
17981 tmp = fieldFromInstruction(insn, 7, 5);
17982 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17983 tmp = fieldFromInstruction(insn, 20, 5);
17984 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17985 tmp = fieldFromInstruction(insn, 15, 5);
17986 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17987 tmp = 0x0;
17988 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17989 return S;
17990 case 137:
17991 tmp = fieldFromInstruction(insn, 7, 5);
17992 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17993 tmp = fieldFromInstruction(insn, 20, 5);
17994 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17995 tmp = fieldFromInstruction(insn, 15, 5);
17996 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17997 return S;
17998 case 138:
17999 tmp = fieldFromInstruction(insn, 7, 5);
18000 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18001 tmp = fieldFromInstruction(insn, 20, 5);
18002 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18003 tmp = fieldFromInstruction(insn, 15, 5);
18004 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18005 tmp = fieldFromInstruction(insn, 25, 1);
18006 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18007 return S;
18008 case 139:
18009 tmp = fieldFromInstruction(insn, 7, 5);
18010 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18011 tmp = fieldFromInstruction(insn, 7, 5);
18012 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18013 tmp = fieldFromInstruction(insn, 15, 5);
18014 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18015 return S;
18016 case 140:
18017 tmp = fieldFromInstruction(insn, 7, 5);
18018 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18019 tmp = fieldFromInstruction(insn, 20, 5);
18020 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18021 tmp = fieldFromInstruction(insn, 15, 5);
18022 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18023 tmp = 0x0;
18024 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18025 return S;
18026 case 141:
18027 tmp = fieldFromInstruction(insn, 7, 5);
18028 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18029 tmp = fieldFromInstruction(insn, 15, 5);
18030 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18031 return S;
18032 case 142:
18033 tmp = fieldFromInstruction(insn, 7, 5);
18034 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18035 tmp = fieldFromInstruction(insn, 7, 5);
18036 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18037 tmp = fieldFromInstruction(insn, 15, 5);
18038 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18039 tmp = fieldFromInstruction(insn, 20, 5);
18040 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18041 tmp = fieldFromInstruction(insn, 25, 1);
18042 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18043 return S;
18044 case 143:
18045 tmp = fieldFromInstruction(insn, 7, 5);
18046 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18047 tmp = fieldFromInstruction(insn, 7, 5);
18048 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18049 tmp = fieldFromInstruction(insn, 15, 5);
18050 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18051 return S;
18052 case 144:
18053 tmp = fieldFromInstruction(insn, 7, 5);
18054 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18055 tmp = fieldFromInstruction(insn, 7, 5);
18056 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18057 tmp = fieldFromInstruction(insn, 20, 5);
18058 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18059 tmp = fieldFromInstruction(insn, 15, 5);
18060 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18061 tmp = fieldFromInstruction(insn, 25, 1);
18062 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18063 return S;
18064 case 145:
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, DecodeGPRRegisterClass(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 tmp = fieldFromInstruction(insn, 25, 1);
18074 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18075 return S;
18076 case 146:
18077 tmp = fieldFromInstruction(insn, 7, 5);
18078 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18079 tmp = fieldFromInstruction(insn, 15, 5);
18080 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18081 tmp = fieldFromInstruction(insn, 20, 11);
18082 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18083 return S;
18084 case 147:
18085 tmp = fieldFromInstruction(insn, 7, 5);
18086 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18087 tmp = fieldFromInstruction(insn, 15, 5);
18088 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18089 tmp = fieldFromInstruction(insn, 20, 10);
18090 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18091 return S;
18092 case 148:
18093 tmp = fieldFromInstruction(insn, 15, 5);
18094 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18095 tmp = fieldFromInstruction(insn, 20, 5);
18096 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18097 tmp = 0x0;
18098 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18099 tmp |= fieldFromInstruction(insn, 8, 4);
18100 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18101 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18102 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18103 return S;
18104 case 149:
18105 tmp = fieldFromInstruction(insn, 15, 5);
18106 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18107 tmp = fieldFromInstruction(insn, 20, 5);
18108 if (!Check(S, decodeImmZibiOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18109 tmp = 0x0;
18110 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18111 tmp |= fieldFromInstruction(insn, 8, 4);
18112 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18113 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18114 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18115 return S;
18116 case 150:
18117 tmp = fieldFromInstruction(insn, 7, 5);
18118 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18119 tmp = 0x0;
18120 tmp |= fieldFromInstruction(insn, 12, 8) << 11;
18121 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
18122 tmp |= fieldFromInstruction(insn, 21, 10);
18123 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
18124 if (!Check(S, decodeSImmOperandAndLslN<21, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18125 return S;
18126 case 151:
18127 tmp = fieldFromInstruction(insn, 15, 5);
18128 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18129 tmp = fieldFromInstruction(insn, 20, 5);
18130 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18131 return S;
18132 case 152:
18133 tmp = fieldFromInstruction(insn, 7, 5);
18134 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18135 tmp = fieldFromInstruction(insn, 20, 12);
18136 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18137 tmp = fieldFromInstruction(insn, 15, 5);
18138 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18139 return S;
18140 case 153:
18141 tmp = fieldFromInstruction(insn, 15, 5);
18142 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18143 return S;
18144 case 154:
18145 tmp = fieldFromInstruction(insn, 7, 5);
18146 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18147 return S;
18148 case 155:
18149 tmp = fieldFromInstruction(insn, 20, 5);
18150 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18151 return S;
18152 case 156:
18153 tmp = fieldFromInstruction(insn, 7, 5);
18154 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18155 tmp = fieldFromInstruction(insn, 20, 12);
18156 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18157 tmp = fieldFromInstruction(insn, 15, 5);
18158 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18159 return S;
18160 case 157:
18161 tmp = fieldFromInstruction(insn, 7, 5);
18162 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18163 tmp = fieldFromInstruction(insn, 20, 5);
18164 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18165 tmp = fieldFromInstruction(insn, 15, 5);
18166 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18167 return S;
18168 case 158:
18169 tmp = fieldFromInstruction(insn, 7, 5);
18170 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18171 tmp = fieldFromInstruction(insn, 7, 5);
18172 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18173 tmp = fieldFromInstruction(insn, 20, 5);
18174 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18175 tmp = fieldFromInstruction(insn, 15, 5);
18176 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18177 return S;
18178 case 159:
18179 tmp = fieldFromInstruction(insn, 7, 5);
18180 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18181 tmp = fieldFromInstruction(insn, 7, 5);
18182 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18183 tmp = fieldFromInstruction(insn, 20, 5);
18184 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18185 return S;
18186 case 160:
18187 tmp = fieldFromInstruction(insn, 7, 5);
18188 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18189 tmp = fieldFromInstruction(insn, 7, 5);
18190 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18191 tmp = fieldFromInstruction(insn, 20, 5);
18192 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18193 tmp = fieldFromInstruction(insn, 15, 5);
18194 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18195 return S;
18196 case 161:
18197 tmp = fieldFromInstruction(insn, 7, 5);
18198 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18199 tmp = fieldFromInstruction(insn, 7, 5);
18200 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18201 tmp = fieldFromInstruction(insn, 23, 2) << 3;
18202 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18203 tmp = fieldFromInstruction(insn, 15, 5);
18204 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18205 tmp = fieldFromInstruction(insn, 20, 3);
18206 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18207 tmp = fieldFromInstruction(insn, 25, 1);
18208 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18209 return S;
18210 case 162:
18211 tmp = fieldFromInstruction(insn, 7, 5);
18212 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18213 tmp = fieldFromInstruction(insn, 15, 5);
18214 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18215 tmp = fieldFromInstruction(insn, 20, 5);
18216 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18217 return S;
18218 case 163:
18219 tmp = fieldFromInstruction(insn, 7, 5);
18220 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18221 tmp = fieldFromInstruction(insn, 15, 5);
18222 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18223 return S;
18224 case 164:
18225 tmp = fieldFromInstruction(insn, 7, 5);
18226 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18227 tmp = fieldFromInstruction(insn, 15, 5);
18228 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18229 tmp = fieldFromInstruction(insn, 20, 5);
18230 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18231 return S;
18232 case 165:
18233 tmp = fieldFromInstruction(insn, 7, 5);
18234 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18235 tmp = fieldFromInstruction(insn, 15, 5);
18236 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18237 tmp = fieldFromInstruction(insn, 20, 5);
18238 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18239 return S;
18240 case 166:
18241 tmp = fieldFromInstruction(insn, 7, 5);
18242 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18243 tmp = fieldFromInstruction(insn, 15, 5);
18244 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18245 tmp = fieldFromInstruction(insn, 20, 5);
18246 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18247 return S;
18248 case 167:
18249 tmp = fieldFromInstruction(insn, 7, 5);
18250 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18251 tmp = fieldFromInstruction(insn, 15, 5);
18252 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18253 return S;
18254 case 168:
18255 tmp = fieldFromInstruction(insn, 7, 5);
18256 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18257 tmp = fieldFromInstruction(insn, 15, 5);
18258 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18259 tmp = fieldFromInstruction(insn, 20, 12);
18260 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18261 return S;
18262 case 169:
18263 tmp = fieldFromInstruction(insn, 7, 5);
18264 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18265 tmp = fieldFromInstruction(insn, 15, 5);
18266 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18267 tmp = fieldFromInstruction(insn, 20, 7);
18268 if (!Check(S, decodeUImm7EqXLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18269 return S;
18270 case 170:
18271 tmp = fieldFromInstruction(insn, 7, 5);
18272 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18273 tmp = fieldFromInstruction(insn, 15, 5);
18274 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18275 tmp = fieldFromInstruction(insn, 20, 9);
18276 if (!Check(S, DecodeYBNDSWImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18277 return S;
18278 case 171:
18279 tmp = fieldFromInstruction(insn, 7, 5);
18280 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18281 tmp = fieldFromInstruction(insn, 15, 5);
18282 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18283 tmp = fieldFromInstruction(insn, 20, 12);
18284 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18285 return S;
18286 case 172:
18287 tmp = fieldFromInstruction(insn, 20, 5);
18288 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18289 tmp = fieldFromInstruction(insn, 15, 5);
18290 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18291 tmp = 0x0;
18292 tmp |= fieldFromInstruction(insn, 7, 5);
18293 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18294 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18295 return S;
18296 case 173:
18297 tmp = fieldFromInstruction(insn, 7, 5);
18298 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18299 tmp = fieldFromInstruction(insn, 20, 12);
18300 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18301 tmp = fieldFromInstruction(insn, 15, 5);
18302 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18303 return S;
18304 case 174:
18305 tmp = fieldFromInstruction(insn, 7, 5);
18306 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18307 tmp = fieldFromInstruction(insn, 15, 5);
18308 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18309 tmp = fieldFromInstruction(insn, 20, 5);
18310 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18311 return S;
18312 case 175:
18313 tmp = fieldFromInstruction(insn, 7, 5);
18314 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18315 tmp = fieldFromInstruction(insn, 15, 5);
18316 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18317 tmp = fieldFromInstruction(insn, 20, 5);
18318 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18319 return S;
18320 case 176:
18321 tmp = fieldFromInstruction(insn, 7, 5);
18322 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 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 return S;
18326 case 177:
18327 tmp = fieldFromInstruction(insn, 20, 5);
18328 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18329 tmp = 0x0;
18330 tmp |= fieldFromInstruction(insn, 7, 5);
18331 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18332 if (!Check(S, decodeSImmOperand<12>(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 return S;
18336 case 178:
18337 tmp = fieldFromInstruction(insn, 7, 5);
18338 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18339 tmp = fieldFromInstruction(insn, 12, 20);
18340 if (!Check(S, decodeUImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18341 return S;
18342 case 179:
18343 tmp = fieldFromInstruction(insn, 7, 5);
18344 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18345 tmp = fieldFromInstruction(insn, 15, 5);
18346 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18347 tmp = 0x0;
18348 tmp |= fieldFromInstruction(insn, 20, 5);
18349 tmp |= fieldFromInstruction(insn, 27, 5) << 5;
18350 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18351 return S;
18352 case 180:
18353 tmp = fieldFromInstruction(insn, 7, 5);
18354 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18355 tmp = fieldFromInstruction(insn, 15, 5);
18356 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18357 tmp = fieldFromInstruction(insn, 20, 5);
18358 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18359 tmp = fieldFromInstruction(insn, 27, 5);
18360 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18361 return S;
18362 case 181:
18363 tmp = fieldFromInstruction(insn, 7, 5);
18364 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18365 tmp = fieldFromInstruction(insn, 15, 5);
18366 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18367 tmp = fieldFromInstruction(insn, 20, 5);
18368 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18369 tmp = fieldFromInstruction(insn, 27, 5);
18370 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18371 tmp = fieldFromInstruction(insn, 12, 3);
18372 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18373 return S;
18374 case 182:
18375 tmp = fieldFromInstruction(insn, 7, 5);
18376 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18377 tmp = fieldFromInstruction(insn, 15, 5);
18378 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18379 tmp = fieldFromInstruction(insn, 20, 5);
18380 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18381 return S;
18382 case 183:
18383 tmp = fieldFromInstruction(insn, 7, 5);
18384 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18385 tmp = fieldFromInstruction(insn, 15, 5);
18386 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18387 tmp = fieldFromInstruction(insn, 20, 5);
18388 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18389 tmp = fieldFromInstruction(insn, 12, 3);
18390 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18391 return S;
18392 case 184:
18393 tmp = fieldFromInstruction(insn, 7, 5);
18394 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18395 tmp = fieldFromInstruction(insn, 15, 5);
18396 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18397 return S;
18398 case 185:
18399 tmp = fieldFromInstruction(insn, 7, 5);
18400 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18401 tmp = fieldFromInstruction(insn, 15, 5);
18402 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18403 tmp = fieldFromInstruction(insn, 20, 5);
18404 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18405 return S;
18406 case 186:
18407 tmp = fieldFromInstruction(insn, 7, 5);
18408 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18409 tmp = fieldFromInstruction(insn, 15, 5);
18410 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18411 tmp = fieldFromInstruction(insn, 20, 5);
18412 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18413 return S;
18414 case 187:
18415 tmp = fieldFromInstruction(insn, 7, 5);
18416 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18417 tmp = fieldFromInstruction(insn, 15, 3);
18418 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18419 return S;
18420 case 188:
18421 tmp = fieldFromInstruction(insn, 7, 3);
18422 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18423 tmp = fieldFromInstruction(insn, 15, 5);
18424 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18425 tmp = 0x0;
18426 tmp |= fieldFromInstruction(insn, 12, 3);
18427 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18428 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18429 return S;
18430 case 189:
18431 tmp = fieldFromInstruction(insn, 7, 5);
18432 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18433 tmp = fieldFromInstruction(insn, 15, 5);
18434 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18435 tmp = fieldFromInstruction(insn, 12, 3);
18436 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18437 return S;
18438 case 190:
18439 tmp = fieldFromInstruction(insn, 7, 5);
18440 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18441 tmp = fieldFromInstruction(insn, 15, 3);
18442 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18443 tmp = fieldFromInstruction(insn, 20, 3);
18444 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18445 tmp = 0x0;
18446 tmp |= fieldFromInstruction(insn, 18, 2);
18447 tmp |= fieldFromInstruction(insn, 23, 2) << 2;
18448 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18449 return S;
18450 case 191:
18451 tmp = fieldFromInstruction(insn, 7, 3);
18452 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18453 tmp = fieldFromInstruction(insn, 15, 3);
18454 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18455 return S;
18456 case 192:
18457 tmp = fieldFromInstruction(insn, 7, 3);
18458 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18459 tmp = fieldFromInstruction(insn, 15, 3);
18460 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18461 tmp = fieldFromInstruction(insn, 20, 3);
18462 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18463 return S;
18464 case 193:
18465 tmp = fieldFromInstruction(insn, 7, 5);
18466 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18467 tmp = fieldFromInstruction(insn, 15, 5);
18468 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18469 return S;
18470 case 194:
18471 tmp = fieldFromInstruction(insn, 7, 5);
18472 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18473 return S;
18474 case 195:
18475 tmp = fieldFromInstruction(insn, 7, 5);
18476 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18477 tmp = fieldFromInstruction(insn, 15, 5);
18478 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18479 tmp = fieldFromInstruction(insn, 20, 3);
18480 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18481 return S;
18482 case 196:
18483 tmp = fieldFromInstruction(insn, 7, 5);
18484 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18485 tmp = fieldFromInstruction(insn, 15, 5);
18486 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18487 tmp = 0x0;
18488 tmp |= fieldFromInstruction(insn, 12, 3);
18489 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18490 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18491 return S;
18492 case 197:
18493 tmp = fieldFromInstruction(insn, 7, 5);
18494 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18495 tmp = 0x0;
18496 tmp |= fieldFromInstruction(insn, 14, 1);
18497 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
18498 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
18499 tmp |= fieldFromInstruction(insn, 20, 1) << 11;
18500 tmp |= fieldFromInstruction(insn, 21, 10) << 1;
18501 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
18502 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18503 return S;
18504 case 198:
18505 tmp = fieldFromInstruction(insn, 20, 5);
18506 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18507 tmp = 0x0;
18508 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18509 tmp |= fieldFromInstruction(insn, 8, 4);
18510 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
18511 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
18512 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18513 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18514 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18515 return S;
18516 case 199:
18517 tmp = fieldFromInstruction(insn, 20, 5);
18518 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18519 tmp = 0x0;
18520 tmp |= fieldFromInstruction(insn, 7, 1) << 9;
18521 tmp |= fieldFromInstruction(insn, 8, 1) << 15;
18522 tmp |= fieldFromInstruction(insn, 9, 3);
18523 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
18524 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
18525 tmp |= fieldFromInstruction(insn, 25, 6) << 3;
18526 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18527 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18528 return S;
18529 case 200:
18530 tmp = fieldFromInstruction(insn, 7, 5);
18531 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18532 tmp = fieldFromInstruction(insn, 20, 5);
18533 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18534 return S;
18535 case 201:
18536 tmp = fieldFromInstruction(insn, 7, 5);
18537 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18538 tmp = fieldFromInstruction(insn, 20, 5);
18539 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18540 return S;
18541 case 202:
18542 tmp = fieldFromInstruction(insn, 7, 5);
18543 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18544 tmp = fieldFromInstruction(insn, 15, 5);
18545 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18546 tmp = fieldFromInstruction(insn, 20, 5);
18547 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18548 tmp = fieldFromInstruction(insn, 25, 1);
18549 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18550 return S;
18551 case 203:
18552 tmp = fieldFromInstruction(insn, 7, 5);
18553 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18554 tmp = 0x0;
18555 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
18556 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
18557 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
18558 tmp |= fieldFromInstruction(insn, 21, 10);
18559 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18560 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18561 return S;
18562 case 204:
18563 tmp = fieldFromInstruction(insn, 15, 5);
18564 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18565 tmp = 0x0;
18566 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
18567 tmp |= fieldFromInstruction(insn, 20, 5);
18568 tmp |= fieldFromInstruction(insn, 30, 1) << 6;
18569 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18570 tmp = 0x0;
18571 tmp |= fieldFromInstruction(insn, 8, 4);
18572 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
18573 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
18574 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18575 return S;
18576 case 205:
18577 tmp = fieldFromInstruction(insn, 7, 5);
18578 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18579 tmp = 0x0;
18580 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
18581 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
18582 tmp |= fieldFromInstruction(insn, 20, 1) << 9;
18583 tmp |= fieldFromInstruction(insn, 21, 1) << 15;
18584 tmp |= fieldFromInstruction(insn, 22, 9);
18585 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18586 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18587 return S;
18588 case 206:
18589 tmp = fieldFromInstruction(insn, 7, 5);
18590 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18591 tmp = fieldFromInstruction(insn, 15, 5);
18592 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18593 tmp = fieldFromInstruction(insn, 26, 6);
18594 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18595 tmp = fieldFromInstruction(insn, 20, 6);
18596 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18597 return S;
18598 case 207:
18599 tmp = fieldFromInstruction(insn, 20, 5);
18600 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18601 tmp = 0x0;
18602 tmp |= fieldFromInstruction(insn, 7, 1) << 11;
18603 tmp |= fieldFromInstruction(insn, 8, 4) << 1;
18604 tmp |= fieldFromInstruction(insn, 14, 1);
18605 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
18606 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
18607 tmp |= fieldFromInstruction(insn, 25, 6) << 5;
18608 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
18609 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18610 return S;
18611 case 208:
18612 tmp = fieldFromInstruction(insn, 7, 5);
18613 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18614 tmp = 0x0;
18615 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
18616 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
18617 tmp |= fieldFromInstruction(insn, 20, 1) << 8;
18618 tmp |= fieldFromInstruction(insn, 21, 2) << 14;
18619 tmp |= fieldFromInstruction(insn, 23, 8);
18620 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18621 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18622 return S;
18623 case 209:
18624 tmp = fieldFromInstruction(insn, 20, 5);
18625 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18626 tmp = 0x0;
18627 tmp |= fieldFromInstruction(insn, 7, 1) << 8;
18628 tmp |= fieldFromInstruction(insn, 8, 2) << 14;
18629 tmp |= fieldFromInstruction(insn, 10, 2);
18630 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
18631 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
18632 tmp |= fieldFromInstruction(insn, 25, 6) << 2;
18633 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18634 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18635 return S;
18636 case 210:
18637 tmp = fieldFromInstruction(insn, 15, 5);
18638 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18639 tmp = 0x0;
18640 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
18641 tmp |= fieldFromInstruction(insn, 20, 5);
18642 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18643 tmp = 0x0;
18644 tmp |= fieldFromInstruction(insn, 8, 4);
18645 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
18646 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
18647 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18648 return S;
18649 case 211:
18650 tmp = fieldFromInstruction(insn, 7, 5);
18651 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18652 tmp = fieldFromInstruction(insn, 15, 5);
18653 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18654 tmp = fieldFromInstruction(insn, 15, 5);
18655 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18656 tmp = fieldFromInstruction(insn, 20, 12);
18657 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18658 return S;
18659 case 212:
18660 tmp = fieldFromInstruction(insn, 15, 5);
18661 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18662 tmp = fieldFromInstruction(insn, 20, 5);
18663 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18664 tmp = fieldFromInstruction(insn, 15, 5);
18665 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18666 tmp = 0x0;
18667 tmp |= fieldFromInstruction(insn, 7, 5);
18668 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18669 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18670 return S;
18671 case 213:
18672 tmp = fieldFromInstruction(insn, 7, 5);
18673 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18674 tmp = fieldFromInstruction(insn, 15, 5);
18675 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18676 tmp = fieldFromInstruction(insn, 25, 5);
18677 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18678 tmp = fieldFromInstruction(insn, 20, 5);
18679 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18680 return S;
18681 case 214:
18682 tmp = fieldFromInstruction(insn, 7, 5);
18683 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18684 tmp = fieldFromInstruction(insn, 7, 5);
18685 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18686 tmp = fieldFromInstruction(insn, 15, 5);
18687 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18688 tmp = fieldFromInstruction(insn, 25, 5);
18689 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18690 tmp = fieldFromInstruction(insn, 20, 5);
18691 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18692 return S;
18693 case 215:
18694 tmp = fieldFromInstruction(insn, 7, 5);
18695 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18696 tmp = fieldFromInstruction(insn, 15, 5);
18697 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18698 tmp = 0x0;
18699 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18700 tmp |= fieldFromInstruction(insn, 25, 1);
18701 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18702 return S;
18703 case 216:
18704 tmp = fieldFromInstruction(insn, 7, 5);
18705 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18706 tmp = fieldFromInstruction(insn, 15, 5);
18707 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18708 tmp = fieldFromInstruction(insn, 25, 5);
18709 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18710 tmp = fieldFromInstruction(insn, 20, 5);
18711 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18712 return S;
18713 case 217:
18714 tmp = fieldFromInstruction(insn, 7, 5);
18715 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18716 tmp = fieldFromInstruction(insn, 15, 5);
18717 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18718 tmp = fieldFromInstruction(insn, 20, 5);
18719 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18720 tmp = fieldFromInstruction(insn, 25, 5);
18721 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18722 return S;
18723 case 218:
18724 tmp = fieldFromInstruction(insn, 7, 5);
18725 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18726 tmp = fieldFromInstruction(insn, 15, 5);
18727 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18728 tmp = fieldFromInstruction(insn, 15, 5);
18729 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18730 tmp = fieldFromInstruction(insn, 20, 5);
18731 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18732 return S;
18733 case 219:
18734 tmp = fieldFromInstruction(insn, 15, 5);
18735 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18736 tmp = fieldFromInstruction(insn, 20, 5);
18737 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18738 tmp = fieldFromInstruction(insn, 15, 5);
18739 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18740 tmp = fieldFromInstruction(insn, 7, 5);
18741 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18742 return S;
18743 case 220:
18744 tmp = fieldFromInstruction(insn, 20, 5);
18745 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18746 tmp = fieldFromInstruction(insn, 15, 5);
18747 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18748 tmp = fieldFromInstruction(insn, 7, 5);
18749 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18750 return S;
18751 case 221:
18752 tmp = fieldFromInstruction(insn, 7, 5);
18753 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18754 tmp = fieldFromInstruction(insn, 7, 5);
18755 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18756 tmp = fieldFromInstruction(insn, 15, 5);
18757 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18758 tmp = 0x0;
18759 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18760 tmp |= fieldFromInstruction(insn, 25, 1);
18761 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18762 return S;
18763 case 222:
18764 tmp = fieldFromInstruction(insn, 15, 5);
18765 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18766 tmp = fieldFromInstruction(insn, 20, 5);
18767 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18768 tmp = 0x0;
18769 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18770 tmp |= fieldFromInstruction(insn, 8, 4);
18771 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18772 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18773 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18774 return S;
18775 case 223:
18776 tmp = fieldFromInstruction(insn, 7, 5);
18777 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18778 tmp = fieldFromInstruction(insn, 7, 5);
18779 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18780 tmp = fieldFromInstruction(insn, 15, 5);
18781 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18782 tmp = fieldFromInstruction(insn, 20, 5);
18783 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18784 tmp = fieldFromInstruction(insn, 25, 5);
18785 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18786 return S;
18787 case 224:
18788 tmp = fieldFromInstruction(insn, 7, 5);
18789 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18790 tmp = fieldFromInstruction(insn, 15, 5);
18791 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18792 tmp = 0x0;
18793 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18794 tmp |= fieldFromInstruction(insn, 25, 1);
18795 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18796 return S;
18797 case 225:
18798 tmp = fieldFromInstruction(insn, 7, 5);
18799 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18800 tmp = fieldFromInstruction(insn, 15, 5);
18801 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18802 tmp = 0x0;
18803 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18804 tmp |= fieldFromInstruction(insn, 25, 1);
18805 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18806 return S;
18807 case 226:
18808 tmp = fieldFromInstruction(insn, 7, 5);
18809 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18810 tmp = fieldFromInstruction(insn, 7, 5);
18811 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18812 tmp = fieldFromInstruction(insn, 15, 5);
18813 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18814 tmp = 0x0;
18815 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18816 tmp |= fieldFromInstruction(insn, 25, 1);
18817 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18818 return S;
18819 case 227:
18820 tmp = fieldFromInstruction(insn, 7, 5);
18821 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18822 tmp = fieldFromInstruction(insn, 15, 5);
18823 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18824 tmp = 0x0;
18825 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18826 tmp |= fieldFromInstruction(insn, 25, 1);
18827 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18828 return S;
18829 case 228:
18830 tmp = fieldFromInstruction(insn, 15, 5);
18831 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18832 tmp = fieldFromInstruction(insn, 20, 9);
18833 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18834 tmp = fieldFromInstruction(insn, 7, 5);
18835 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18836 return S;
18837 case 229:
18838 tmp = fieldFromInstruction(insn, 7, 5);
18839 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18840 tmp = fieldFromInstruction(insn, 15, 5);
18841 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18842 tmp = fieldFromInstruction(insn, 20, 5);
18843 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18844 tmp = fieldFromInstruction(insn, 27, 5);
18845 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18846 return S;
18847 case 230:
18848 tmp = fieldFromInstruction(insn, 7, 5);
18849 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18850 tmp = fieldFromInstruction(insn, 27, 5);
18851 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18852 tmp = fieldFromInstruction(insn, 15, 5);
18853 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18854 tmp = fieldFromInstruction(insn, 23, 4) << 3;
18855 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18856 return S;
18857 case 231:
18858 tmp = fieldFromInstruction(insn, 7, 5);
18859 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18860 tmp = fieldFromInstruction(insn, 27, 5);
18861 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18862 tmp = fieldFromInstruction(insn, 15, 5);
18863 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18864 tmp = fieldFromInstruction(insn, 22, 5) << 2;
18865 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18866 return S;
18867 case 232:
18868 tmp = fieldFromInstruction(insn, 20, 5);
18869 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18870 tmp = fieldFromInstruction(insn, 27, 5);
18871 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18872 tmp = fieldFromInstruction(insn, 15, 5);
18873 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18874 tmp = 0x0;
18875 tmp |= fieldFromInstruction(insn, 10, 2) << 3;
18876 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
18877 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18878 return S;
18879 case 233:
18880 tmp = fieldFromInstruction(insn, 20, 5);
18881 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18882 tmp = fieldFromInstruction(insn, 27, 5);
18883 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18884 tmp = fieldFromInstruction(insn, 15, 5);
18885 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18886 tmp = 0x0;
18887 tmp |= fieldFromInstruction(insn, 9, 3) << 2;
18888 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
18889 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18890 return S;
18891 case 234:
18892 tmp = fieldFromInstruction(insn, 7, 5);
18893 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18894 tmp = fieldFromInstruction(insn, 7, 5);
18895 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18896 tmp = fieldFromInstruction(insn, 15, 5);
18897 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18898 tmp = fieldFromInstruction(insn, 20, 5);
18899 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18900 return S;
18901 case 235:
18902 tmp = fieldFromInstruction(insn, 7, 5);
18903 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18904 tmp = fieldFromInstruction(insn, 7, 5);
18905 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18906 tmp = fieldFromInstruction(insn, 16, 4) << 1;
18907 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18908 tmp = fieldFromInstruction(insn, 20, 5);
18909 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18910 return S;
18911 case 236:
18912 tmp = fieldFromInstruction(insn, 7, 5);
18913 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18914 tmp = fieldFromInstruction(insn, 26, 2);
18915 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18916 tmp = fieldFromInstruction(insn, 20, 5);
18917 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18918 tmp = fieldFromInstruction(insn, 15, 5);
18919 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18920 return S;
18921 case 237:
18922 tmp = fieldFromInstruction(insn, 26, 2);
18923 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18924 tmp = fieldFromInstruction(insn, 20, 5);
18925 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18926 tmp = fieldFromInstruction(insn, 7, 5);
18927 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18928 tmp = fieldFromInstruction(insn, 15, 5);
18929 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18930 return S;
18931 case 238:
18932 tmp = fieldFromInstruction(insn, 7, 5);
18933 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18934 tmp = fieldFromInstruction(insn, 26, 2);
18935 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18936 tmp = fieldFromInstruction(insn, 20, 5);
18937 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18938 tmp = fieldFromInstruction(insn, 15, 5);
18939 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18940 return S;
18941 case 239:
18942 tmp = fieldFromInstruction(insn, 26, 2);
18943 if (!Check(S, decodeUImmOperand<2>(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 tmp = fieldFromInstruction(insn, 7, 5);
18947 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18948 tmp = fieldFromInstruction(insn, 15, 5);
18949 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18950 return S;
18951 case 240:
18952 tmp = fieldFromInstruction(insn, 7, 5);
18953 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18954 tmp = fieldFromInstruction(insn, 26, 2);
18955 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18956 tmp = fieldFromInstruction(insn, 20, 5);
18957 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18958 tmp = fieldFromInstruction(insn, 15, 5);
18959 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18960 return S;
18961 case 241:
18962 tmp = fieldFromInstruction(insn, 26, 2);
18963 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18964 tmp = fieldFromInstruction(insn, 7, 5);
18965 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18966 tmp = fieldFromInstruction(insn, 20, 5);
18967 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18968 tmp = fieldFromInstruction(insn, 15, 5);
18969 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18970 return S;
18971 case 242:
18972 tmp = fieldFromInstruction(insn, 7, 5);
18973 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18974 tmp = fieldFromInstruction(insn, 26, 2);
18975 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18976 tmp = fieldFromInstruction(insn, 20, 5);
18977 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18978 tmp = fieldFromInstruction(insn, 15, 5);
18979 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18980 return S;
18981 case 243:
18982 tmp = fieldFromInstruction(insn, 26, 2);
18983 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18984 tmp = fieldFromInstruction(insn, 7, 5);
18985 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18986 tmp = fieldFromInstruction(insn, 20, 5);
18987 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18988 tmp = fieldFromInstruction(insn, 15, 5);
18989 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18990 return S;
18991 case 244:
18992 tmp = fieldFromInstruction(insn, 7, 5);
18993 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18994 tmp = fieldFromInstruction(insn, 26, 2);
18995 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18996 tmp = fieldFromInstruction(insn, 20, 5);
18997 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18998 tmp = fieldFromInstruction(insn, 15, 5);
18999 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19000 return S;
19001 case 245:
19002 tmp = fieldFromInstruction(insn, 26, 2);
19003 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19004 tmp = fieldFromInstruction(insn, 7, 5);
19005 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19006 tmp = fieldFromInstruction(insn, 20, 5);
19007 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19008 tmp = fieldFromInstruction(insn, 15, 5);
19009 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19010 return S;
19011 case 246:
19012 tmp = fieldFromInstruction(insn, 7, 5);
19013 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19014 tmp = fieldFromInstruction(insn, 26, 1);
19015 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19016 tmp = fieldFromInstruction(insn, 20, 5);
19017 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19018 tmp = fieldFromInstruction(insn, 15, 5);
19019 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19020 return S;
19021 case 247:
19022 tmp = fieldFromInstruction(insn, 26, 1);
19023 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19024 tmp = fieldFromInstruction(insn, 7, 5);
19025 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19026 tmp = fieldFromInstruction(insn, 20, 5);
19027 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19028 tmp = fieldFromInstruction(insn, 15, 5);
19029 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19030 return S;
19031 case 248:
19032 tmp = fieldFromInstruction(insn, 8, 4);
19033 if (!Check(S, DecodeSimpleRegisterClass<RISCV::T0, 16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19034 return S;
19035 case 249:
19036 tmp = fieldFromInstruction(insn, 15, 5);
19037 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19038 tmp = fieldFromInstruction(insn, 20, 5);
19039 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19040 return S;
19041 case 250:
19042 tmp = fieldFromInstruction(insn, 7, 5);
19043 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19044 tmp = fieldFromInstruction(insn, 26, 2);
19045 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19046 tmp = fieldFromInstruction(insn, 7, 5);
19047 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19048 tmp = fieldFromInstruction(insn, 20, 5);
19049 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19050 tmp = fieldFromInstruction(insn, 15, 5);
19051 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19052 return S;
19053 case 251:
19054 tmp = fieldFromInstruction(insn, 26, 2);
19055 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19056 tmp = fieldFromInstruction(insn, 7, 5);
19057 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19058 tmp = fieldFromInstruction(insn, 20, 5);
19059 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19060 tmp = fieldFromInstruction(insn, 15, 5);
19061 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19062 return S;
19063 case 252:
19064 tmp = fieldFromInstruction(insn, 7, 5);
19065 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19066 tmp = fieldFromInstruction(insn, 26, 2);
19067 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19068 tmp = fieldFromInstruction(insn, 7, 5);
19069 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19070 tmp = fieldFromInstruction(insn, 20, 5);
19071 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19072 tmp = fieldFromInstruction(insn, 15, 5);
19073 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19074 return S;
19075 case 253:
19076 tmp = fieldFromInstruction(insn, 26, 2);
19077 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19078 tmp = fieldFromInstruction(insn, 7, 5);
19079 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19080 tmp = fieldFromInstruction(insn, 20, 5);
19081 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19082 tmp = fieldFromInstruction(insn, 15, 5);
19083 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19084 return S;
19085 case 254:
19086 tmp = fieldFromInstruction(insn, 7, 5);
19087 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19088 tmp = fieldFromInstruction(insn, 26, 2);
19089 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19090 tmp = fieldFromInstruction(insn, 7, 5);
19091 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19092 tmp = fieldFromInstruction(insn, 20, 5);
19093 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(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 return S;
19097 case 255:
19098 tmp = fieldFromInstruction(insn, 26, 2);
19099 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19100 tmp = fieldFromInstruction(insn, 7, 5);
19101 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19102 tmp = fieldFromInstruction(insn, 20, 5);
19103 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19104 tmp = fieldFromInstruction(insn, 15, 5);
19105 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19106 return S;
19107 case 256:
19108 tmp = fieldFromInstruction(insn, 7, 5);
19109 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19110 tmp = fieldFromInstruction(insn, 26, 1);
19111 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19112 tmp = fieldFromInstruction(insn, 7, 5);
19113 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19114 tmp = fieldFromInstruction(insn, 20, 5);
19115 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19116 tmp = fieldFromInstruction(insn, 15, 5);
19117 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19118 return S;
19119 case 257:
19120 tmp = fieldFromInstruction(insn, 26, 1);
19121 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19122 tmp = fieldFromInstruction(insn, 7, 5);
19123 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19124 tmp = fieldFromInstruction(insn, 20, 5);
19125 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19126 tmp = fieldFromInstruction(insn, 15, 5);
19127 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19128 return S;
19129 case 258:
19130 tmp = fieldFromInstruction(insn, 10, 2) << 2;
19131 if (!Check(S, DecodeTRM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19132 tmp = fieldFromInstruction(insn, 20, 5);
19133 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19134 tmp = fieldFromInstruction(insn, 15, 5);
19135 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19136 return S;
19137 case 259:
19138 tmp = fieldFromInstruction(insn, 9, 3) << 1;
19139 if (!Check(S, DecodeTRM2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19140 tmp = fieldFromInstruction(insn, 20, 5);
19141 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19142 tmp = fieldFromInstruction(insn, 15, 5);
19143 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19144 return S;
19145 case 260:
19146 tmp = fieldFromInstruction(insn, 7, 5);
19147 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19148 tmp = fieldFromInstruction(insn, 15, 5);
19149 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19150 tmp = fieldFromInstruction(insn, 20, 5);
19151 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19152 tmp = fieldFromInstruction(insn, 25, 2);
19153 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19154 return S;
19155 case 261:
19156 tmp = fieldFromInstruction(insn, 7, 5);
19157 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19158 tmp = fieldFromInstruction(insn, 15, 5);
19159 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19160 tmp = fieldFromInstruction(insn, 15, 5);
19161 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19162 tmp = fieldFromInstruction(insn, 20, 5);
19163 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19164 tmp = fieldFromInstruction(insn, 25, 2);
19165 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19166 return S;
19167 case 262:
19168 tmp = fieldFromInstruction(insn, 7, 5);
19169 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19170 tmp = fieldFromInstruction(insn, 20, 5);
19171 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19172 tmp = fieldFromInstruction(insn, 15, 5);
19173 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19174 tmp = fieldFromInstruction(insn, 25, 2);
19175 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19176 if (!Check(Out&: S, In: decodeImmThreeOperand(Inst&: MI, Decoder)))
19177 return MCDisassembler::Fail;
19178 return S;
19179 case 263:
19180 tmp = fieldFromInstruction(insn, 7, 5);
19181 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19182 tmp = fieldFromInstruction(insn, 20, 5);
19183 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19184 tmp = fieldFromInstruction(insn, 15, 5);
19185 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19186 tmp = fieldFromInstruction(insn, 25, 2);
19187 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19188 if (!Check(Out&: S, In: decodeImmFourOperand(Inst&: MI, Decoder)))
19189 return MCDisassembler::Fail;
19190 return S;
19191 case 264:
19192 tmp = fieldFromInstruction(insn, 15, 5);
19193 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19194 tmp = fieldFromInstruction(insn, 7, 5);
19195 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19196 tmp = fieldFromInstruction(insn, 15, 5);
19197 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19198 tmp = fieldFromInstruction(insn, 20, 5);
19199 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19200 tmp = fieldFromInstruction(insn, 25, 2);
19201 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19202 return S;
19203 case 265:
19204 tmp = fieldFromInstruction(insn, 7, 5);
19205 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19206 tmp = fieldFromInstruction(insn, 15, 5);
19207 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19208 tmp = fieldFromInstruction(insn, 20, 5);
19209 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19210 tmp = fieldFromInstruction(insn, 25, 2);
19211 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19212 return S;
19213 case 266:
19214 tmp = fieldFromInstruction(insn, 7, 5);
19215 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19216 tmp = fieldFromInstruction(insn, 15, 5);
19217 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19218 tmp = fieldFromInstruction(insn, 20, 5);
19219 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19220 tmp = fieldFromInstruction(insn, 25, 2);
19221 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19222 return S;
19223 case 267:
19224 tmp = fieldFromInstruction(insn, 7, 5);
19225 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19226 tmp = fieldFromInstruction(insn, 15, 5);
19227 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19228 tmp = fieldFromInstruction(insn, 20, 11);
19229 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19230 return S;
19231 case 268:
19232 tmp = fieldFromInstruction(insn, 7, 5);
19233 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19234 tmp = fieldFromInstruction(insn, 7, 5);
19235 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19236 tmp = fieldFromInstruction(insn, 15, 5);
19237 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19238 tmp = fieldFromInstruction(insn, 20, 11);
19239 if (!Check(S, decodeSImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19240 return S;
19241 case 269:
19242 tmp = fieldFromInstruction(insn, 7, 5);
19243 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19244 tmp = fieldFromInstruction(insn, 7, 5);
19245 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19246 tmp = fieldFromInstruction(insn, 15, 5);
19247 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19248 tmp = fieldFromInstruction(insn, 25, 5);
19249 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19250 tmp = fieldFromInstruction(insn, 20, 5);
19251 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19252 return S;
19253 case 270:
19254 tmp = fieldFromInstruction(insn, 7, 5);
19255 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19256 tmp = fieldFromInstruction(insn, 7, 5);
19257 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19258 tmp = fieldFromInstruction(insn, 15, 5);
19259 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19260 tmp = fieldFromInstruction(insn, 25, 5);
19261 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19262 tmp = fieldFromInstruction(insn, 20, 5);
19263 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19264 return S;
19265 case 271:
19266 tmp = fieldFromInstruction(insn, 7, 5);
19267 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19268 tmp = fieldFromInstruction(insn, 15, 5);
19269 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19270 tmp = fieldFromInstruction(insn, 25, 5);
19271 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19272 tmp = fieldFromInstruction(insn, 20, 5);
19273 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19274 return S;
19275 case 272:
19276 tmp = fieldFromInstruction(insn, 7, 5);
19277 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19278 tmp = fieldFromInstruction(insn, 15, 5);
19279 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19280 tmp = fieldFromInstruction(insn, 25, 5);
19281 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19282 tmp = fieldFromInstruction(insn, 20, 5);
19283 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19284 return S;
19285 case 273:
19286 tmp = fieldFromInstruction(insn, 7, 5);
19287 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19288 tmp = fieldFromInstruction(insn, 15, 5);
19289 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19290 return S;
19291 case 274:
19292 tmp = fieldFromInstruction(insn, 7, 5);
19293 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19294 tmp = fieldFromInstruction(insn, 7, 5);
19295 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19296 tmp = fieldFromInstruction(insn, 15, 5);
19297 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19298 tmp = fieldFromInstruction(insn, 20, 5);
19299 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19300 return S;
19301 case 275:
19302 tmp = fieldFromInstruction(insn, 7, 5);
19303 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19304 tmp = fieldFromInstruction(insn, 15, 5);
19305 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19306 tmp = fieldFromInstruction(insn, 20, 5);
19307 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19308 return S;
19309 case 276:
19310 tmp = fieldFromInstruction(insn, 7, 5);
19311 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19312 tmp = fieldFromInstruction(insn, 15, 5);
19313 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19314 tmp = fieldFromInstruction(insn, 20, 5);
19315 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19316 return S;
19317 case 277:
19318 tmp = fieldFromInstruction(insn, 7, 5);
19319 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19320 tmp = fieldFromInstruction(insn, 15, 5);
19321 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19322 tmp = fieldFromInstruction(insn, 20, 5);
19323 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19324 return S;
19325 case 278:
19326 tmp = fieldFromInstruction(insn, 7, 5);
19327 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19328 tmp = fieldFromInstruction(insn, 15, 5);
19329 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19330 tmp = fieldFromInstruction(insn, 20, 5);
19331 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19332 tmp = fieldFromInstruction(insn, 25, 5);
19333 if (!Check(S, decodeUImmOperandGE<5, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19334 return S;
19335 case 279:
19336 tmp = fieldFromInstruction(insn, 7, 5);
19337 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19338 tmp = fieldFromInstruction(insn, 15, 5);
19339 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19340 tmp = fieldFromInstruction(insn, 20, 12) << 2;
19341 if (!Check(S, decodeUImmOperand<14>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19342 return S;
19343 case 280:
19344 tmp = fieldFromInstruction(insn, 7, 5);
19345 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19346 tmp = fieldFromInstruction(insn, 15, 5);
19347 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19348 tmp = fieldFromInstruction(insn, 20, 12) << 2;
19349 if (!Check(S, decodeUImmOperand<14>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19350 return S;
19351 case 281:
19352 tmp = fieldFromInstruction(insn, 7, 5);
19353 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19354 tmp = fieldFromInstruction(insn, 7, 5);
19355 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19356 tmp = fieldFromInstruction(insn, 15, 5);
19357 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19358 tmp = fieldFromInstruction(insn, 20, 12);
19359 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19360 return S;
19361 case 282:
19362 tmp = fieldFromInstruction(insn, 7, 5);
19363 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19364 tmp = fieldFromInstruction(insn, 15, 5);
19365 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19366 tmp = fieldFromInstruction(insn, 20, 5);
19367 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19368 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19369 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19370 return S;
19371 case 283:
19372 tmp = fieldFromInstruction(insn, 7, 5);
19373 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19374 tmp = fieldFromInstruction(insn, 15, 5);
19375 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19376 tmp = fieldFromInstruction(insn, 20, 5);
19377 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19378 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19379 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19380 return S;
19381 case 284:
19382 tmp = fieldFromInstruction(insn, 7, 5);
19383 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19384 tmp = fieldFromInstruction(insn, 15, 5);
19385 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19386 tmp = fieldFromInstruction(insn, 20, 5);
19387 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19388 tmp = fieldFromInstruction(insn, 25, 3);
19389 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19390 return S;
19391 case 285:
19392 tmp = fieldFromInstruction(insn, 20, 5);
19393 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19394 return S;
19395 case 286:
19396 tmp = fieldFromInstruction(insn, 20, 8);
19397 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19398 return S;
19399 case 287:
19400 tmp = fieldFromInstruction(insn, 7, 5);
19401 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19402 tmp = 0x0;
19403 tmp |= fieldFromInstruction(insn, 12, 4) << 15;
19404 tmp |= fieldFromInstruction(insn, 16, 15);
19405 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
19406 if (!Check(S, decodeSImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19407 return S;
19408 case 288:
19409 tmp = fieldFromInstruction(insn, 7, 5);
19410 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19411 tmp = fieldFromInstruction(insn, 15, 5);
19412 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19413 tmp = fieldFromInstruction(insn, 20, 5);
19414 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19415 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19416 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19417 return S;
19418 case 289:
19419 tmp = fieldFromInstruction(insn, 7, 5);
19420 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19421 tmp = fieldFromInstruction(insn, 15, 5);
19422 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19423 tmp = fieldFromInstruction(insn, 20, 5);
19424 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19425 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19426 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19427 return S;
19428 case 290:
19429 tmp = fieldFromInstruction(insn, 7, 5);
19430 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19431 tmp = fieldFromInstruction(insn, 7, 5);
19432 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19433 tmp = fieldFromInstruction(insn, 15, 5);
19434 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19435 tmp = fieldFromInstruction(insn, 20, 5);
19436 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19437 tmp = fieldFromInstruction(insn, 27, 5);
19438 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19439 return S;
19440 case 291:
19441 tmp = fieldFromInstruction(insn, 7, 5);
19442 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19443 tmp = fieldFromInstruction(insn, 7, 5);
19444 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19445 tmp = fieldFromInstruction(insn, 15, 5);
19446 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19447 tmp = fieldFromInstruction(insn, 20, 5);
19448 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19449 tmp = fieldFromInstruction(insn, 27, 5);
19450 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19451 return S;
19452 case 292:
19453 tmp = fieldFromInstruction(insn, 7, 5);
19454 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19455 tmp = fieldFromInstruction(insn, 7, 5);
19456 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19457 tmp = fieldFromInstruction(insn, 15, 5);
19458 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19459 tmp = fieldFromInstruction(insn, 20, 5);
19460 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19461 tmp = fieldFromInstruction(insn, 27, 5);
19462 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19463 return S;
19464 case 293:
19465 tmp = fieldFromInstruction(insn, 7, 5);
19466 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19467 tmp = fieldFromInstruction(insn, 7, 5);
19468 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19469 tmp = fieldFromInstruction(insn, 15, 5);
19470 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19471 tmp = fieldFromInstruction(insn, 20, 5);
19472 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19473 tmp = fieldFromInstruction(insn, 27, 5);
19474 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19475 return S;
19476 case 294:
19477 tmp = fieldFromInstruction(insn, 7, 5);
19478 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19479 tmp = fieldFromInstruction(insn, 7, 5);
19480 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19481 tmp = fieldFromInstruction(insn, 15, 5);
19482 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19483 tmp = fieldFromInstruction(insn, 20, 5);
19484 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19485 tmp = fieldFromInstruction(insn, 27, 5);
19486 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19487 return S;
19488 case 295:
19489 tmp = fieldFromInstruction(insn, 7, 5);
19490 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19491 tmp = fieldFromInstruction(insn, 7, 5);
19492 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19493 tmp = fieldFromInstruction(insn, 15, 5);
19494 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19495 tmp = fieldFromInstruction(insn, 20, 5);
19496 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19497 tmp = fieldFromInstruction(insn, 27, 5);
19498 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19499 return S;
19500 case 296:
19501 tmp = fieldFromInstruction(insn, 7, 5);
19502 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19503 tmp = fieldFromInstruction(insn, 7, 5);
19504 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19505 tmp = fieldFromInstruction(insn, 15, 5);
19506 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19507 tmp = fieldFromInstruction(insn, 20, 5);
19508 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19509 tmp = fieldFromInstruction(insn, 27, 5);
19510 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19511 return S;
19512 case 297:
19513 tmp = fieldFromInstruction(insn, 7, 5);
19514 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19515 tmp = fieldFromInstruction(insn, 7, 5);
19516 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19517 tmp = fieldFromInstruction(insn, 15, 5);
19518 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19519 tmp = fieldFromInstruction(insn, 20, 5);
19520 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19521 tmp = fieldFromInstruction(insn, 27, 5);
19522 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19523 return S;
19524 case 298:
19525 tmp = fieldFromInstruction(insn, 7, 5);
19526 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19527 tmp = fieldFromInstruction(insn, 15, 5);
19528 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19529 tmp = fieldFromInstruction(insn, 20, 5);
19530 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19531 return S;
19532 case 299:
19533 tmp = fieldFromInstruction(insn, 7, 5);
19534 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19535 tmp = fieldFromInstruction(insn, 15, 5);
19536 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19537 tmp = fieldFromInstruction(insn, 20, 5);
19538 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19539 return S;
19540 case 300:
19541 tmp = fieldFromInstruction(insn, 15, 10);
19542 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19543 return S;
19544 case 301:
19545 tmp = fieldFromInstruction(insn, 15, 5);
19546 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19547 tmp = fieldFromInstruction(insn, 20, 5);
19548 if (!Check(S, decodeSImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19549 tmp = 0x0;
19550 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19551 tmp |= fieldFromInstruction(insn, 8, 4);
19552 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19553 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19554 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19555 return S;
19556 case 302:
19557 tmp = fieldFromInstruction(insn, 15, 5);
19558 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19559 tmp = fieldFromInstruction(insn, 20, 5);
19560 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19561 tmp = 0x0;
19562 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19563 tmp |= fieldFromInstruction(insn, 8, 4);
19564 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19565 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19566 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19567 return S;
19568 case 303:
19569 tmp = fieldFromInstruction(insn, 7, 5);
19570 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19571 tmp = fieldFromInstruction(insn, 15, 5);
19572 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19573 tmp = fieldFromInstruction(insn, 12, 3);
19574 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19575 return S;
19576 case 304:
19577 tmp = fieldFromInstruction(insn, 7, 5);
19578 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19579 tmp = fieldFromInstruction(insn, 15, 5);
19580 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19581 tmp = fieldFromInstruction(insn, 12, 3);
19582 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19583 return S;
19584 case 305:
19585 tmp = fieldFromInstruction(insn, 7, 5);
19586 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19587 tmp = fieldFromInstruction(insn, 15, 5);
19588 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19589 tmp = fieldFromInstruction(insn, 20, 5);
19590 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19591 tmp = fieldFromInstruction(insn, 27, 5);
19592 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19593 tmp = fieldFromInstruction(insn, 12, 3);
19594 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19595 return S;
19596 case 306:
19597 tmp = fieldFromInstruction(insn, 7, 5);
19598 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19599 tmp = fieldFromInstruction(insn, 15, 5);
19600 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19601 tmp = fieldFromInstruction(insn, 20, 5);
19602 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19603 tmp = fieldFromInstruction(insn, 12, 3);
19604 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19605 return S;
19606 case 307:
19607 tmp = fieldFromInstruction(insn, 7, 5);
19608 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19609 tmp = fieldFromInstruction(insn, 15, 5);
19610 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19611 tmp = fieldFromInstruction(insn, 20, 5);
19612 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19613 return S;
19614 case 308:
19615 tmp = fieldFromInstruction(insn, 7, 5);
19616 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19617 tmp = fieldFromInstruction(insn, 15, 5);
19618 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19619 tmp = fieldFromInstruction(insn, 12, 3);
19620 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19621 return S;
19622 case 309:
19623 tmp = fieldFromInstruction(insn, 7, 5);
19624 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19625 tmp = fieldFromInstruction(insn, 15, 5);
19626 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19627 tmp = fieldFromInstruction(insn, 12, 3);
19628 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19629 return S;
19630 case 310:
19631 tmp = fieldFromInstruction(insn, 7, 5);
19632 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19633 tmp = fieldFromInstruction(insn, 15, 5);
19634 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19635 tmp = fieldFromInstruction(insn, 12, 3);
19636 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19637 return S;
19638 case 311:
19639 tmp = fieldFromInstruction(insn, 7, 5);
19640 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19641 tmp = fieldFromInstruction(insn, 15, 5);
19642 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19643 tmp = fieldFromInstruction(insn, 20, 5);
19644 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19645 return S;
19646 case 312:
19647 tmp = fieldFromInstruction(insn, 7, 5);
19648 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19649 tmp = fieldFromInstruction(insn, 15, 5);
19650 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19651 tmp = fieldFromInstruction(insn, 12, 3);
19652 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19653 return S;
19654 case 313:
19655 tmp = fieldFromInstruction(insn, 7, 5);
19656 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19657 tmp = fieldFromInstruction(insn, 15, 5);
19658 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19659 tmp = fieldFromInstruction(insn, 12, 3);
19660 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19661 return S;
19662 case 314:
19663 tmp = fieldFromInstruction(insn, 7, 5);
19664 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19665 tmp = fieldFromInstruction(insn, 15, 5);
19666 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19667 return S;
19668 case 315:
19669 tmp = fieldFromInstruction(insn, 7, 5);
19670 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19671 tmp = fieldFromInstruction(insn, 15, 5);
19672 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19673 tmp = fieldFromInstruction(insn, 20, 5);
19674 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19675 tmp = fieldFromInstruction(insn, 27, 5);
19676 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19677 tmp = fieldFromInstruction(insn, 12, 3);
19678 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19679 return S;
19680 case 316:
19681 tmp = fieldFromInstruction(insn, 7, 5);
19682 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19683 tmp = fieldFromInstruction(insn, 15, 5);
19684 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19685 tmp = fieldFromInstruction(insn, 20, 5);
19686 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19687 tmp = fieldFromInstruction(insn, 27, 5);
19688 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19689 tmp = fieldFromInstruction(insn, 12, 3);
19690 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19691 return S;
19692 case 317:
19693 tmp = fieldFromInstruction(insn, 7, 5);
19694 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19695 tmp = fieldFromInstruction(insn, 15, 5);
19696 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19697 tmp = fieldFromInstruction(insn, 20, 5);
19698 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19699 tmp = fieldFromInstruction(insn, 27, 5);
19700 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19701 tmp = fieldFromInstruction(insn, 12, 3);
19702 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19703 return S;
19704 case 318:
19705 tmp = fieldFromInstruction(insn, 7, 5);
19706 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19707 tmp = fieldFromInstruction(insn, 15, 5);
19708 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19709 tmp = fieldFromInstruction(insn, 20, 5);
19710 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19711 tmp = fieldFromInstruction(insn, 12, 3);
19712 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19713 return S;
19714 case 319:
19715 tmp = fieldFromInstruction(insn, 7, 5);
19716 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19717 tmp = fieldFromInstruction(insn, 15, 5);
19718 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19719 tmp = fieldFromInstruction(insn, 20, 5);
19720 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19721 tmp = fieldFromInstruction(insn, 12, 3);
19722 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19723 return S;
19724 case 320:
19725 tmp = fieldFromInstruction(insn, 7, 5);
19726 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19727 tmp = fieldFromInstruction(insn, 15, 5);
19728 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19729 tmp = fieldFromInstruction(insn, 20, 5);
19730 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19731 tmp = fieldFromInstruction(insn, 12, 3);
19732 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19733 return S;
19734 case 321:
19735 tmp = fieldFromInstruction(insn, 7, 5);
19736 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19737 tmp = fieldFromInstruction(insn, 15, 5);
19738 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19739 tmp = fieldFromInstruction(insn, 20, 5);
19740 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19741 return S;
19742 case 322:
19743 tmp = fieldFromInstruction(insn, 7, 5);
19744 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19745 tmp = fieldFromInstruction(insn, 15, 5);
19746 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19747 tmp = fieldFromInstruction(insn, 20, 5);
19748 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19749 return S;
19750 case 323:
19751 tmp = fieldFromInstruction(insn, 7, 5);
19752 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(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, 12, 3);
19756 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19757 return S;
19758 case 324:
19759 tmp = fieldFromInstruction(insn, 7, 5);
19760 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19761 tmp = fieldFromInstruction(insn, 15, 5);
19762 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19763 tmp = fieldFromInstruction(insn, 12, 3);
19764 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19765 return S;
19766 case 325:
19767 tmp = fieldFromInstruction(insn, 7, 5);
19768 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19769 tmp = fieldFromInstruction(insn, 15, 5);
19770 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19771 tmp = fieldFromInstruction(insn, 12, 3);
19772 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19773 return S;
19774 case 326:
19775 tmp = fieldFromInstruction(insn, 7, 5);
19776 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19777 tmp = fieldFromInstruction(insn, 15, 5);
19778 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19779 tmp = fieldFromInstruction(insn, 12, 3);
19780 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19781 return S;
19782 case 327:
19783 tmp = fieldFromInstruction(insn, 7, 5);
19784 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19785 tmp = fieldFromInstruction(insn, 15, 5);
19786 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19787 tmp = fieldFromInstruction(insn, 12, 3);
19788 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19789 return S;
19790 case 328:
19791 tmp = fieldFromInstruction(insn, 7, 5);
19792 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19793 tmp = fieldFromInstruction(insn, 15, 5);
19794 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19795 tmp = fieldFromInstruction(insn, 12, 3);
19796 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19797 return S;
19798 case 329:
19799 tmp = fieldFromInstruction(insn, 7, 5);
19800 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19801 tmp = fieldFromInstruction(insn, 15, 5);
19802 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19803 tmp = fieldFromInstruction(insn, 12, 3);
19804 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19805 return S;
19806 case 330:
19807 tmp = fieldFromInstruction(insn, 7, 5);
19808 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19809 tmp = fieldFromInstruction(insn, 15, 5);
19810 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19811 tmp = fieldFromInstruction(insn, 12, 3);
19812 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19813 return S;
19814 case 331:
19815 tmp = fieldFromInstruction(insn, 7, 5);
19816 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19817 tmp = fieldFromInstruction(insn, 15, 5);
19818 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19819 tmp = fieldFromInstruction(insn, 12, 3);
19820 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19821 return S;
19822 case 332:
19823 tmp = fieldFromInstruction(insn, 7, 5);
19824 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19825 tmp = fieldFromInstruction(insn, 15, 5);
19826 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19827 tmp = fieldFromInstruction(insn, 20, 5);
19828 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19829 return S;
19830 case 333:
19831 tmp = fieldFromInstruction(insn, 7, 5);
19832 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19833 tmp = fieldFromInstruction(insn, 15, 5);
19834 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19835 tmp = fieldFromInstruction(insn, 20, 5);
19836 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19837 return S;
19838 case 334:
19839 tmp = fieldFromInstruction(insn, 7, 5);
19840 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19841 tmp = fieldFromInstruction(insn, 15, 5);
19842 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19843 return S;
19844 case 335:
19845 tmp = fieldFromInstruction(insn, 7, 5);
19846 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19847 tmp = fieldFromInstruction(insn, 15, 5);
19848 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19849 return S;
19850 }
19851}
19852static const uint8_t DecoderTableXqci48[368] = {
19853 48, // 0: BitWidth 48
19854 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
19855 0, 15, // 4: case 0x0: {
19856 OPC_CheckPredicate, 189, 1, // 6: check predicate 189
19857 OPC_CheckField, 15, 1, 0, // 9: check Inst[15] == 0x0
19858 OPC_CheckField, 0, 7, 31, // 13: check Inst[6:0] == 0x1f
19859 OPC_Decode, 170, 122, 0, // 17: decode to QC_E_LI using decoder 0
19860 // 17: }
19861 1, 29, // 21: case 0x1: {
19862 OPC_SwitchField, 15, 1, // 23: switch Inst[15] {
19863 0, 11, // 26: case 0x0: {
19864 OPC_CheckPredicate, 204, 1, // 28: check predicate 204
19865 OPC_CheckField, 0, 7, 31, // 31: check Inst[6:0] == 0x1f
19866 OPC_Decode, 177, 122, 1, // 35: decode to QC_E_XORAI using decoder 1
19867 // 35: }
19868 1, 0, // 39: case 0x1: {
19869 OPC_CheckPredicate, 204, 1, // 41: check predicate 204
19870 OPC_CheckField, 0, 7, 31, // 44: check Inst[6:0] == 0x1f
19871 OPC_Decode, 172, 122, 1, // 48: decode to QC_E_ORAI using decoder 1
19872 // 48: }
19873 // 48: } // switch Inst[15]
19874 // 48: }
19875 2, 29, // 52: case 0x2: {
19876 OPC_SwitchField, 15, 1, // 54: switch Inst[15] {
19877 0, 11, // 57: case 0x0: {
19878 OPC_CheckPredicate, 204, 1, // 59: check predicate 204
19879 OPC_CheckField, 0, 7, 31, // 62: check Inst[6:0] == 0x1f
19880 OPC_Decode, 154, 122, 1, // 66: decode to QC_E_ADDAI using decoder 1
19881 // 66: }
19882 1, 0, // 70: case 0x1: {
19883 OPC_CheckPredicate, 204, 1, // 72: check predicate 204
19884 OPC_CheckField, 0, 7, 31, // 75: check Inst[6:0] == 0x1f
19885 OPC_Decode, 156, 122, 1, // 79: decode to QC_E_ANDAI using decoder 1
19886 // 79: }
19887 // 79: } // switch Inst[15]
19888 // 79: }
19889 3, 55, // 83: case 0x3: {
19890 OPC_SwitchField, 30, 2, // 85: switch Inst[31:30] {
19891 0, 11, // 88: case 0x0: {
19892 OPC_CheckPredicate, 204, 1, // 90: check predicate 204
19893 OPC_CheckField, 0, 7, 31, // 93: check Inst[6:0] == 0x1f
19894 OPC_Decode, 178, 122, 2, // 97: decode to QC_E_XORI using decoder 2
19895 // 97: }
19896 1, 11, // 101: case 0x1: {
19897 OPC_CheckPredicate, 204, 1, // 103: check predicate 204
19898 OPC_CheckField, 0, 7, 31, // 106: check Inst[6:0] == 0x1f
19899 OPC_Decode, 173, 122, 2, // 110: decode to QC_E_ORI using decoder 2
19900 // 110: }
19901 2, 11, // 114: case 0x2: {
19902 OPC_CheckPredicate, 204, 1, // 116: check predicate 204
19903 OPC_CheckField, 0, 7, 31, // 119: check Inst[6:0] == 0x1f
19904 OPC_Decode, 155, 122, 2, // 123: decode to QC_E_ADDI using decoder 2
19905 // 123: }
19906 3, 0, // 127: case 0x3: {
19907 OPC_CheckPredicate, 204, 1, // 129: check predicate 204
19908 OPC_CheckField, 0, 7, 31, // 132: check Inst[6:0] == 0x1f
19909 OPC_Decode, 157, 122, 2, // 136: decode to QC_E_ANDI using decoder 2
19910 // 136: }
19911 // 136: } // switch Inst[31:30]
19912 // 136: }
19913 4, 112, // 140: case 0x4: {
19914 OPC_SwitchField, 20, 5, // 142: switch Inst[24:20] {
19915 0, 29, // 145: case 0x0: {
19916 OPC_SwitchField, 15, 2, // 147: switch Inst[16:15] {
19917 0, 11, // 150: case 0x0: {
19918 OPC_CheckPredicate, 205, 1, // 152: check predicate 205
19919 OPC_CheckField, 0, 7, 31, // 155: check Inst[6:0] == 0x1f
19920 OPC_Decode, 164, 122, 3, // 159: decode to QC_E_J using decoder 3
19921 // 159: }
19922 1, 0, // 163: case 0x1: {
19923 OPC_CheckPredicate, 205, 1, // 165: check predicate 205
19924 OPC_CheckField, 0, 7, 31, // 168: check Inst[6:0] == 0x1f
19925 OPC_Decode, 165, 122, 3, // 172: decode to QC_E_JAL using decoder 3
19926 // 172: }
19927 // 172: } // switch Inst[16:15]
19928 // 172: }
19929 24, 11, // 176: case 0x18: {
19930 OPC_CheckPredicate, 193, 1, // 178: check predicate 193
19931 OPC_CheckField, 0, 7, 31, // 181: check Inst[6:0] == 0x1f
19932 OPC_Decode, 158, 122, 4, // 185: decode to QC_E_BEQI using decoder 4
19933 // 185: }
19934 25, 11, // 189: case 0x19: {
19935 OPC_CheckPredicate, 193, 1, // 191: check predicate 193
19936 OPC_CheckField, 0, 7, 31, // 194: check Inst[6:0] == 0x1f
19937 OPC_Decode, 163, 122, 4, // 198: decode to QC_E_BNEI using decoder 4
19938 // 198: }
19939 28, 11, // 202: case 0x1c: {
19940 OPC_CheckPredicate, 193, 1, // 204: check predicate 193
19941 OPC_CheckField, 0, 7, 31, // 207: check Inst[6:0] == 0x1f
19942 OPC_Decode, 161, 122, 4, // 211: decode to QC_E_BLTI using decoder 4
19943 // 211: }
19944 29, 11, // 215: case 0x1d: {
19945 OPC_CheckPredicate, 193, 1, // 217: check predicate 193
19946 OPC_CheckField, 0, 7, 31, // 220: check Inst[6:0] == 0x1f
19947 OPC_Decode, 159, 122, 4, // 224: decode to QC_E_BGEI using decoder 4
19948 // 224: }
19949 30, 11, // 228: case 0x1e: {
19950 OPC_CheckPredicate, 193, 1, // 230: check predicate 193
19951 OPC_CheckField, 0, 7, 31, // 233: check Inst[6:0] == 0x1f
19952 OPC_Decode, 162, 122, 5, // 237: decode to QC_E_BLTUI using decoder 5
19953 // 237: }
19954 31, 0, // 241: case 0x1f: {
19955 OPC_CheckPredicate, 193, 1, // 243: check predicate 193
19956 OPC_CheckField, 0, 7, 31, // 246: check Inst[6:0] == 0x1f
19957 OPC_Decode, 160, 122, 5, // 250: decode to QC_E_BGEUI using decoder 5
19958 // 250: }
19959 // 250: } // switch Inst[24:20]
19960 // 250: }
19961 5, 55, // 254: case 0x5: {
19962 OPC_SwitchField, 30, 2, // 256: switch Inst[31:30] {
19963 0, 11, // 259: case 0x0: {
19964 OPC_CheckPredicate, 206, 1, // 261: check predicate 206
19965 OPC_CheckField, 0, 7, 31, // 264: check Inst[6:0] == 0x1f
19966 OPC_Decode, 166, 122, 6, // 268: decode to QC_E_LB using decoder 6
19967 // 268: }
19968 1, 11, // 272: case 0x1: {
19969 OPC_CheckPredicate, 206, 1, // 274: check predicate 206
19970 OPC_CheckField, 0, 7, 31, // 277: check Inst[6:0] == 0x1f
19971 OPC_Decode, 167, 122, 6, // 281: decode to QC_E_LBU using decoder 6
19972 // 281: }
19973 2, 11, // 285: case 0x2: {
19974 OPC_CheckPredicate, 206, 1, // 287: check predicate 206
19975 OPC_CheckField, 0, 7, 31, // 290: check Inst[6:0] == 0x1f
19976 OPC_Decode, 168, 122, 6, // 294: decode to QC_E_LH using decoder 6
19977 // 294: }
19978 3, 0, // 298: case 0x3: {
19979 OPC_CheckPredicate, 206, 1, // 300: check predicate 206
19980 OPC_CheckField, 0, 7, 31, // 303: check Inst[6:0] == 0x1f
19981 OPC_Decode, 169, 122, 6, // 307: decode to QC_E_LHU using decoder 6
19982 // 307: }
19983 // 307: } // switch Inst[31:30]
19984 // 307: }
19985 6, 0, // 311: case 0x6: {
19986 OPC_SwitchField, 30, 2, // 313: switch Inst[31:30] {
19987 0, 11, // 316: case 0x0: {
19988 OPC_CheckPredicate, 206, 1, // 318: check predicate 206
19989 OPC_CheckField, 0, 7, 31, // 321: check Inst[6:0] == 0x1f
19990 OPC_Decode, 171, 122, 6, // 325: decode to QC_E_LW using decoder 6
19991 // 325: }
19992 1, 11, // 329: case 0x1: {
19993 OPC_CheckPredicate, 206, 1, // 331: check predicate 206
19994 OPC_CheckField, 0, 7, 31, // 334: check Inst[6:0] == 0x1f
19995 OPC_Decode, 174, 122, 7, // 338: decode to QC_E_SB using decoder 7
19996 // 338: }
19997 2, 11, // 342: case 0x2: {
19998 OPC_CheckPredicate, 206, 1, // 344: check predicate 206
19999 OPC_CheckField, 0, 7, 31, // 347: check Inst[6:0] == 0x1f
20000 OPC_Decode, 175, 122, 7, // 351: decode to QC_E_SH using decoder 7
20001 // 351: }
20002 3, 0, // 355: case 0x3: {
20003 OPC_CheckPredicate, 206, 1, // 357: check predicate 206
20004 OPC_CheckField, 0, 7, 31, // 360: check Inst[6:0] == 0x1f
20005 OPC_Decode, 176, 122, 7, // 364: decode to QC_E_SW using decoder 7
20006 // 364: }
20007 // 364: } // switch Inst[31:30]
20008 // 364: }
20009 // 364: } // switch Inst[14:12]
20010};
20011// Handling 8 cases.
20012template <typename InsnType>
20013static std::enable_if_t<InsnBitWidth<InsnType> == 48, DecodeStatus>
20014decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
20015 DecodeComplete = true;
20016 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
20017 TmpType tmp;
20018 switch (Idx) {
20019 default: llvm_unreachable("Invalid decoder index!");
20020 case 0:
20021 tmp = fieldFromInstruction(insn, 7, 5);
20022 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20023 tmp = fieldFromInstruction(insn, 16, 32);
20024 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20025 return S;
20026 case 1:
20027 tmp = fieldFromInstruction(insn, 7, 5);
20028 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20029 tmp = fieldFromInstruction(insn, 7, 5);
20030 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20031 tmp = fieldFromInstruction(insn, 16, 32);
20032 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20033 return S;
20034 case 2:
20035 tmp = fieldFromInstruction(insn, 7, 5);
20036 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20037 tmp = fieldFromInstruction(insn, 15, 5);
20038 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20039 tmp = 0x0;
20040 tmp |= fieldFromInstruction(insn, 20, 10);
20041 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20042 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20043 return S;
20044 case 3:
20045 tmp = 0x0;
20046 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20047 tmp |= fieldFromInstruction(insn, 8, 4);
20048 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
20049 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20050 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20051 tmp |= fieldFromInstruction(insn, 32, 16) << 15;
20052 if (!Check(S, decodeSImmOperandAndLslN<32, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20053 return S;
20054 case 4:
20055 tmp = fieldFromInstruction(insn, 15, 5);
20056 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20057 tmp = fieldFromInstruction(insn, 32, 16);
20058 if (!Check(S, decodeSImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20059 tmp = 0x0;
20060 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20061 tmp |= fieldFromInstruction(insn, 8, 4);
20062 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20063 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20064 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20065 return S;
20066 case 5:
20067 tmp = fieldFromInstruction(insn, 15, 5);
20068 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20069 tmp = fieldFromInstruction(insn, 32, 16);
20070 if (!Check(S, decodeUImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20071 tmp = 0x0;
20072 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20073 tmp |= fieldFromInstruction(insn, 8, 4);
20074 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20075 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20076 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20077 return S;
20078 case 6:
20079 tmp = fieldFromInstruction(insn, 7, 5);
20080 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20081 tmp = fieldFromInstruction(insn, 15, 5);
20082 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20083 tmp = 0x0;
20084 tmp |= fieldFromInstruction(insn, 20, 10);
20085 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20086 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20087 return S;
20088 case 7:
20089 tmp = fieldFromInstruction(insn, 20, 5);
20090 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20091 tmp = fieldFromInstruction(insn, 15, 5);
20092 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20093 tmp = 0x0;
20094 tmp |= fieldFromInstruction(insn, 7, 5);
20095 tmp |= fieldFromInstruction(insn, 25, 5) << 5;
20096 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20097 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20098 return S;
20099 }
20100}
20101static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) {
20102 switch (Idx) {
20103 default: llvm_unreachable("Invalid index!");
20104 case 0:
20105 return FB[RISCV::FeatureStdExtZca];
20106 case 1:
20107 return FB[RISCV::FeatureStdExtZcd];
20108 case 2:
20109 return FB[RISCV::FeatureStdExtZca] && FB[RISCV::Feature64Bit];
20110 case 3:
20111 return FB[RISCV::FeatureStdExtZcmop];
20112 case 4:
20113 return FB[RISCV::FeatureStdExtZcb];
20114 case 5:
20115 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZmmul];
20116 case 6:
20117 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZbb];
20118 case 7:
20119 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
20120 case 8:
20121 return FB[RISCV::FeatureStdExtZcf] && !FB[RISCV::Feature64Bit];
20122 case 9:
20123 return FB[RISCV::FeatureStdExtZca] && !FB[RISCV::Feature64Bit];
20124 case 10:
20125 return FB[RISCV::FeatureVendorXqccmp];
20126 case 11:
20127 return FB[RISCV::FeatureVendorXqccmt];
20128 case 12:
20129 return FB[RISCV::FeatureVendorXqciint] && !FB[RISCV::Feature64Bit];
20130 case 13:
20131 return FB[RISCV::FeatureVendorXqcibm] && !FB[RISCV::Feature64Bit];
20132 case 14:
20133 return FB[RISCV::FeatureVendorXqciac] && !FB[RISCV::Feature64Bit];
20134 case 15:
20135 return FB[RISCV::FeatureVendorXqcisync] && !FB[RISCV::Feature64Bit];
20136 case 16:
20137 return FB[RISCV::FeatureVendorXqcicm] && !FB[RISCV::Feature64Bit];
20138 case 17:
20139 return FB[RISCV::FeatureVendorXwchc];
20140 case 18:
20141 return FB[RISCV::FeatureStdExtZclsd] && !FB[RISCV::Feature64Bit];
20142 case 19:
20143 return FB[RISCV::FeatureStdExtZcmt];
20144 case 20:
20145 return FB[RISCV::FeatureStdExtZcmp];
20146 case 21:
20147 return FB[RISCV::Feature64Bit];
20148 case 22:
20149 return FB[RISCV::FeatureStdExtZve32x];
20150 case 23:
20151 return FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZfhmin] || FB[RISCV::FeatureStdExtZfbfmin];
20152 case 24:
20153 return FB[RISCV::FeatureStdExtF];
20154 case 25:
20155 return FB[RISCV::FeatureStdExtD];
20156 case 26:
20157 return FB[RISCV::FeatureStdExtQ];
20158 case 27:
20159 return FB[RISCV::FeatureStdExtZve64x];
20160 case 28:
20161 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtZve64x];
20162 case 29:
20163 return FB[RISCV::FeatureStdExtZve64x] && FB[RISCV::Feature64Bit];
20164 case 30:
20165 return FB[RISCV::FeatureStdExtZvvmtls];
20166 case 31:
20167 return FB[RISCV::FeatureStdExtZvvmttls];
20168 case 32:
20169 return FB[RISCV::FeatureStdExtZicbom];
20170 case 33:
20171 return FB[RISCV::FeatureStdExtZicboz];
20172 case 34:
20173 return FB[RISCV::FeatureStdExtZbkb] && !FB[RISCV::Feature64Bit];
20174 case 35:
20175 return FB[RISCV::FeatureStdExtZknh];
20176 case 36:
20177 return FB[RISCV::FeatureStdExtZknh] && FB[RISCV::Feature64Bit];
20178 case 37:
20179 return FB[RISCV::FeatureStdExtZksh];
20180 case 38:
20181 return FB[RISCV::FeatureStdExtZbs];
20182 case 39:
20183 return FB[RISCV::FeatureStdExtZknd] && FB[RISCV::Feature64Bit];
20184 case 40:
20185 return (FB[RISCV::FeatureStdExtZknd] || FB[RISCV::FeatureStdExtZkne]) && FB[RISCV::Feature64Bit];
20186 case 41:
20187 return FB[RISCV::FeatureStdExtZbb];
20188 case 42:
20189 return FB[RISCV::FeatureStdExtP];
20190 case 43:
20191 return FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb];
20192 case 44:
20193 return FB[RISCV::FeatureStdExtZbkb];
20194 case 45:
20195 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && !FB[RISCV::Feature64Bit];
20196 case 46:
20197 return FB[RISCV::FeatureStdExtP] && !FB[RISCV::Feature64Bit];
20198 case 47:
20199 return FB[RISCV::FeatureStdExtP] && FB[RISCV::Feature64Bit];
20200 case 48:
20201 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && FB[RISCV::Feature64Bit];
20202 case 49:
20203 return FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
20204 case 50:
20205 return FB[RISCV::FeatureStdExtZbb] && FB[RISCV::Feature64Bit];
20206 case 51:
20207 return FB[RISCV::FeatureStdExtZabha];
20208 case 52:
20209 return FB[RISCV::FeatureStdExtZaamo];
20210 case 53:
20211 return FB[RISCV::FeatureStdExtZaamo] && FB[RISCV::Feature64Bit];
20212 case 54:
20213 return FB[RISCV::FeatureStdExtZalrsc];
20214 case 55:
20215 return FB[RISCV::FeatureStdExtZalrsc] && FB[RISCV::Feature64Bit];
20216 case 56:
20217 return FB[RISCV::FeatureStdExtZabha] && FB[RISCV::FeatureStdExtZacas];
20218 case 57:
20219 return FB[RISCV::FeatureStdExtZacas];
20220 case 58:
20221 return FB[RISCV::FeatureStdExtZacas] && FB[RISCV::Feature64Bit];
20222 case 59:
20223 return FB[RISCV::FeatureStdExtZalasr];
20224 case 60:
20225 return FB[RISCV::FeatureStdExtZalasr] && FB[RISCV::Feature64Bit];
20226 case 61:
20227 return FB[RISCV::FeatureStdExtZicfiss];
20228 case 62:
20229 return FB[RISCV::FeatureStdExtZicfiss] && FB[RISCV::Feature64Bit];
20230 case 63:
20231 return FB[RISCV::FeatureStdExtZmmul];
20232 case 64:
20233 return FB[RISCV::FeatureStdExtM];
20234 case 65:
20235 return FB[RISCV::FeatureStdExtZbkb] || FB[RISCV::FeatureStdExtP];
20236 case 66:
20237 return FB[RISCV::FeatureStdExtZbkc];
20238 case 67:
20239 return FB[RISCV::FeatureStdExtZbc];
20240 case 68:
20241 return FB[RISCV::FeatureStdExtZicond];
20242 case 69:
20243 return FB[RISCV::FeatureStdExtZknh] && !FB[RISCV::Feature64Bit];
20244 case 70:
20245 return FB[RISCV::FeatureStdExtZba];
20246 case 71:
20247 return FB[RISCV::FeatureStdExtZkne] && !FB[RISCV::Feature64Bit];
20248 case 72:
20249 return FB[RISCV::FeatureStdExtZbkx];
20250 case 73:
20251 return FB[RISCV::FeatureStdExtZknd] && !FB[RISCV::Feature64Bit];
20252 case 74:
20253 return FB[RISCV::FeatureStdExtZksed];
20254 case 75:
20255 return FB[RISCV::FeatureStdExtZkne] && FB[RISCV::Feature64Bit];
20256 case 76:
20257 return FB[RISCV::FeatureStdExtZmmul] && FB[RISCV::Feature64Bit];
20258 case 77:
20259 return FB[RISCV::FeatureStdExtM] && FB[RISCV::Feature64Bit];
20260 case 78:
20261 return FB[RISCV::FeatureStdExtZbkb] && FB[RISCV::Feature64Bit];
20262 case 79:
20263 return FB[RISCV::FeatureStdExtZfh];
20264 case 80:
20265 return FB[RISCV::FeatureStdExtZfa];
20266 case 81:
20267 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD];
20268 case 82:
20269 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtZfh];
20270 case 83:
20271 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ];
20272 case 84:
20273 return FB[RISCV::FeatureStdExtZfhmin];
20274 case 85:
20275 return FB[RISCV::FeatureStdExtZfbfmin];
20276 case 86:
20277 return FB[RISCV::FeatureStdExtZfhmin] && FB[RISCV::FeatureStdExtD];
20278 case 87:
20279 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD] && !FB[RISCV::Feature64Bit];
20280 case 88:
20281 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
20282 case 89:
20283 return FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
20284 case 90:
20285 return FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
20286 case 91:
20287 return FB[RISCV::FeatureStdExtZfh] && FB[RISCV::Feature64Bit];
20288 case 92:
20289 return FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
20290 case 93:
20291 return FB[RISCV::FeatureStdExtZfa] && (FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZvfh]);
20292 case 94:
20293 return FB[RISCV::FeatureStdExtZvkb];
20294 case 95:
20295 return FB[RISCV::FeatureStdExtZvzip];
20296 case 96:
20297 return FB[RISCV::FeatureStdExtZvbb];
20298 case 97:
20299 return FB[RISCV::FeatureStdExtZvvmm];
20300 case 98:
20301 return FB[RISCV::FeatureStdExtZvvfmm];
20302 case 99:
20303 return FB[RISCV::FeatureStdExtZve32f];
20304 case 100:
20305 return FB[RISCV::FeatureStdExtZvfbfmin] || FB[RISCV::FeatureStdExtZvfofp8min];
20306 case 101:
20307 return FB[RISCV::FeatureStdExtZvfofp8min];
20308 case 102:
20309 return FB[RISCV::FeatureStdExtZvfbfwma];
20310 case 103:
20311 return FB[RISCV::FeatureStdExtZvbc] || FB[RISCV::FeatureStdExtZvbc32e];
20312 case 104:
20313 return FB[RISCV::FeatureStdExtZvabd];
20314 case 105:
20315 return FB[RISCV::FeatureStdExtZvdot4a8i];
20316 case 106:
20317 return FB[RISCV::FeatureStdExtZibi];
20318 case 107:
20319 return FB[RISCV::FeatureStdExtZawrs];
20320 case 108:
20321 return FB[RISCV::FeatureStdExtSmctr] || FB[RISCV::FeatureStdExtSsctr];
20322 case 109:
20323 return FB[RISCV::FeatureStdExtSvinval];
20324 case 110:
20325 return FB[RISCV::FeatureStdExtH];
20326 case 111:
20327 return FB[RISCV::FeatureStdExtSmrnmi];
20328 case 112:
20329 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtH];
20330 case 113:
20331 return FB[RISCV::FeatureStdExtZimop];
20332 case 114:
20333 return FB[RISCV::FeatureStdExtZvksh];
20334 case 115:
20335 return FB[RISCV::FeatureStdExtZvksed];
20336 case 116:
20337 return FB[RISCV::FeatureStdExtZvkned];
20338 case 117:
20339 return FB[RISCV::FeatureStdExtZvkgs];
20340 case 118:
20341 return FB[RISCV::FeatureStdExtZvfwdota16bf];
20342 case 119:
20343 return FB[RISCV::FeatureStdExtZvqwdota8i] || FB[RISCV::FeatureStdExtZvqwdota16i];
20344 case 120:
20345 return FB[RISCV::FeatureStdExtZvfqwdota8f];
20346 case 121:
20347 return FB[RISCV::FeatureStdExtZvkg];
20348 case 122:
20349 return FB[RISCV::FeatureStdExtZvfbdota32f];
20350 case 123:
20351 return FB[RISCV::FeatureStdExtZvfwbdota16bf];
20352 case 124:
20353 return FB[RISCV::FeatureStdExtZvknha];
20354 case 125:
20355 return FB[RISCV::FeatureStdExtZvqwbdota8i] || FB[RISCV::FeatureStdExtZvqwbdota16i];
20356 case 126:
20357 return FB[RISCV::FeatureStdExtZvfqwbdota8f];
20358 case 127:
20359 return FB[RISCV::FeatureStdExtY];
20360 case 128:
20361 return FB[RISCV::FeatureStdExtZilsd] && !FB[RISCV::Feature64Bit];
20362 case 129:
20363 return FB[RISCV::FeatureStdExtZacas] && !FB[RISCV::Feature64Bit];
20364 case 130:
20365 return FB[RISCV::FeatureVendorXAIFET];
20366 case 131:
20367 return FB[RISCV::FeatureVendorXAndesPerf];
20368 case 132:
20369 return FB[RISCV::FeatureVendorXAndesVBFHCvt];
20370 case 133:
20371 return FB[RISCV::FeatureVendorXAndesBFHCvt];
20372 case 134:
20373 return FB[RISCV::FeatureVendorXAndesVSIntH];
20374 case 135:
20375 return FB[RISCV::FeatureVendorXAndesVSIntLoad];
20376 case 136:
20377 return FB[RISCV::FeatureVendorXAndesVPackFPH];
20378 case 137:
20379 return FB[RISCV::FeatureVendorXAndesPerf] && FB[RISCV::Feature64Bit];
20380 case 138:
20381 return FB[RISCV::FeatureVendorXAndesVDot];
20382 case 139:
20383 return FB[RISCV::FeatureVendorXCVmem] && !FB[RISCV::Feature64Bit];
20384 case 140:
20385 return FB[RISCV::FeatureVendorXCVbitmanip] && !FB[RISCV::Feature64Bit];
20386 case 141:
20387 return FB[RISCV::FeatureVendorXCVsimd] && !FB[RISCV::Feature64Bit];
20388 case 142:
20389 return FB[RISCV::FeatureVendorXCValu] && !FB[RISCV::Feature64Bit];
20390 case 143:
20391 return FB[RISCV::FeatureVendorXCVelw] && !FB[RISCV::Feature64Bit];
20392 case 144:
20393 return FB[RISCV::FeatureVendorXCVmac] && !FB[RISCV::Feature64Bit];
20394 case 145:
20395 return FB[RISCV::FeatureVendorXCVbi] && !FB[RISCV::Feature64Bit];
20396 case 146:
20397 return FB[RISCV::FeatureVendorXMIPSCBOP];
20398 case 147:
20399 return FB[RISCV::FeatureVendorXMIPSEXECTL];
20400 case 148:
20401 return FB[RISCV::FeatureVendorXMIPSCMov];
20402 case 149:
20403 return FB[RISCV::FeatureVendorXMIPSLSP];
20404 case 150:
20405 return FB[RISCV::FeatureVendorXSMTVDot] && FB[RISCV::Feature64Bit];
20406 case 151:
20407 return FB[RISCV::FeatureVendorXSfcease];
20408 case 152:
20409 return FB[RISCV::FeatureVendorXSiFivecflushdlone];
20410 case 153:
20411 return FB[RISCV::FeatureVendorXSiFivecdiscarddlone];
20412 case 154:
20413 return FB[RISCV::FeatureVendorXSfvcp];
20414 case 155:
20415 return FB[RISCV::FeatureVendorXSfmmbase];
20416 case 156:
20417 return FB[RISCV::FeatureVendorXSfvfexpa];
20418 case 157:
20419 return FB[RISCV::FeatureVendorXSfvfbfexp16e] || FB[RISCV::FeatureVendorXSfvfexp16e] || FB[RISCV::FeatureVendorXSfvfexp32e];
20420 case 158:
20421 return FB[RISCV::FeatureVendorXSfvfnrclipxfqf];
20422 case 159:
20423 return FB[RISCV::FeatureVendorXSfvqmaccdod];
20424 case 160:
20425 return FB[RISCV::FeatureVendorXSfmm32a8i];
20426 case 161:
20427 return FB[RISCV::FeatureVendorXSfvfwmaccqqq];
20428 case 162:
20429 return FB[RISCV::FeatureVendorXSfmm32a16f] || FB[RISCV::FeatureVendorXSfmm32a32f] || FB[RISCV::FeatureVendorXSfmm64a64f];
20430 case 163:
20431 return FB[RISCV::FeatureVendorXSfmm32a8f];
20432 case 164:
20433 return FB[RISCV::FeatureVendorXSfvqmaccqoq];
20434 case 165:
20435 return FB[RISCV::FeatureVendorXTHeadCmo];
20436 case 166:
20437 return FB[RISCV::FeatureVendorXTHeadSync];
20438 case 167:
20439 return FB[RISCV::FeatureVendorXTHeadBa];
20440 case 168:
20441 return FB[RISCV::FeatureVendorXTHeadBb];
20442 case 169:
20443 return FB[RISCV::FeatureVendorXTHeadBb] && FB[RISCV::Feature64Bit];
20444 case 170:
20445 return FB[RISCV::FeatureVendorXTHeadMac];
20446 case 171:
20447 return FB[RISCV::FeatureVendorXTHeadMac] && FB[RISCV::Feature64Bit];
20448 case 172:
20449 return FB[RISCV::FeatureVendorXTHeadCondMov];
20450 case 173:
20451 return FB[RISCV::FeatureVendorXTHeadBs];
20452 case 174:
20453 return FB[RISCV::FeatureVendorXTHeadMemIdx];
20454 case 175:
20455 return FB[RISCV::FeatureVendorXTHeadMemIdx] && FB[RISCV::Feature64Bit];
20456 case 176:
20457 return FB[RISCV::FeatureVendorXTHeadMemPair];
20458 case 177:
20459 return FB[RISCV::FeatureVendorXTHeadMemPair] && FB[RISCV::Feature64Bit];
20460 case 178:
20461 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF];
20462 case 179:
20463 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
20464 case 180:
20465 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD];
20466 case 181:
20467 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
20468 case 182:
20469 return FB[RISCV::FeatureVendorXTHeadVdot];
20470 case 183:
20471 return FB[RISCV::FeatureVendorXVentanaCondOps];
20472 case 184:
20473 return FB[RISCV::FeatureVendorXqcia] && !FB[RISCV::Feature64Bit];
20474 case 185:
20475 return FB[RISCV::FeatureVendorXqciio] && !FB[RISCV::Feature64Bit];
20476 case 186:
20477 return FB[RISCV::FeatureVendorXqcilsm] && !FB[RISCV::Feature64Bit];
20478 case 187:
20479 return FB[RISCV::FeatureVendorXqcisls] && !FB[RISCV::Feature64Bit];
20480 case 188:
20481 return FB[RISCV::FeatureVendorXqcisim] && !FB[RISCV::Feature64Bit];
20482 case 189:
20483 return FB[RISCV::FeatureVendorXqcili] && !FB[RISCV::Feature64Bit];
20484 case 190:
20485 return FB[RISCV::FeatureVendorXqcicli] && !FB[RISCV::Feature64Bit];
20486 case 191:
20487 return FB[RISCV::FeatureVendorXqcics] && !FB[RISCV::Feature64Bit];
20488 case 192:
20489 return FB[RISCV::FeatureVendorXqcicsr] && !FB[RISCV::Feature64Bit];
20490 case 193:
20491 return FB[RISCV::FeatureVendorXqcibi] && !FB[RISCV::Feature64Bit];
20492 case 194:
20493 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && !FB[RISCV::Feature64Bit];
20494 case 195:
20495 return FB[RISCV::FeatureStdExtZdinx] && !FB[RISCV::Feature64Bit];
20496 case 196:
20497 return FB[RISCV::FeatureStdExtZfinx];
20498 case 197:
20499 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
20500 case 198:
20501 return FB[RISCV::FeatureStdExtZhinx];
20502 case 199:
20503 return FB[RISCV::FeatureStdExtZhinxmin];
20504 case 200:
20505 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
20506 case 201:
20507 return FB[RISCV::FeatureStdExtZfinx] && FB[RISCV::Feature64Bit];
20508 case 202:
20509 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit] && FB[RISCV::Feature64Bit];
20510 case 203:
20511 return FB[RISCV::FeatureStdExtZhinx] && FB[RISCV::Feature64Bit];
20512 case 204:
20513 return FB[RISCV::FeatureVendorXqcilia] && !FB[RISCV::Feature64Bit];
20514 case 205:
20515 return FB[RISCV::FeatureVendorXqcilb] && !FB[RISCV::Feature64Bit];
20516 case 206:
20517 return FB[RISCV::FeatureVendorXqcilo] && !FB[RISCV::Feature64Bit];
20518 }
20519}
20520
20521
20522template <typename InsnType>
20523static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
20524 InsnType insn, uint64_t Address,
20525 const MCDisassembler *DisAsm,
20526 const MCSubtargetInfo &STI) {
20527 const FeatureBitset &Bits = STI.getFeatureBits();
20528 const uint8_t *Ptr = DecodeTable;
20529
20530 [[maybe_unused]] uint32_t BitWidth = decodeULEB128AndIncUnsafe(p&: Ptr);
20531 assert(InsnBitWidth<InsnType> == BitWidth &&
20532 "Table and instruction bitwidth mismatch");
20533
20534 SmallVector<const uint8_t *, 8> ScopeStack;
20535 DecodeStatus S = MCDisassembler::Success;
20536 while (true) {
20537 ptrdiff_t Loc = Ptr - DecodeTable;
20538 const uint8_t DecoderOp = *Ptr++;
20539 switch (DecoderOp) {
20540 default:
20541 errs() << Loc << ": Unexpected decode table opcode: "
20542 << (int)DecoderOp << '\n';
20543 return MCDisassembler::Fail;
20544 case OPC_Scope: {
20545 unsigned NumToSkip = decodeULEB128AndIncUnsafe(p&: Ptr);
20546 const uint8_t *SkipTo = Ptr + NumToSkip;
20547 ScopeStack.push_back(Elt: SkipTo);
20548 LLVM_DEBUG(dbgs() << Loc << ": OPC_Scope(" << SkipTo - DecodeTable
20549 << ")\n");
20550 continue;
20551 }
20552 case OPC_SwitchField: {
20553 // Decode the start value.
20554 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
20555 unsigned Len = *Ptr++;
20556 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
20557 uint64_t CaseValue;
20558 unsigned CaseSize;
20559 while (true) {
20560 CaseValue = decodeULEB128AndIncUnsafe(p&: Ptr);
20561 CaseSize = decodeULEB128AndIncUnsafe(p&: Ptr);
20562 if (FieldValue == CaseValue || !CaseSize)
20563 break;
20564 Ptr += CaseSize;
20565 }
20566 if (FieldValue == CaseValue) {
20567 LLVM_DEBUG(dbgs() << Loc << ": OPC_SwitchField(" << Start << ", " << Len
20568 << "): " << FieldValue << '\n');
20569 continue;
20570 }
20571 break;
20572 }
20573 case OPC_CheckField: {
20574 // Decode the start value.
20575 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
20576 unsigned Len = *Ptr;
20577 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
20578 // Decode the field value.
20579 unsigned PtrLen = 0;
20580 uint64_t ExpectedValue = decodeULEB128(p: ++Ptr, n: &PtrLen);
20581 Ptr += PtrLen;
20582 bool Failed = ExpectedValue != FieldValue;
20583
20584 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckField(" << Start << ", " << Len
20585 << ", " << ExpectedValue << "): FieldValue = "
20586 << FieldValue << ", ExpectedValue = " << ExpectedValue
20587 << ": " << (Failed ? "FAIL, " : "PASS\n"););
20588 if (!Failed)
20589 continue;
20590 break;
20591 }
20592 case OPC_CheckPredicate: {
20593 // Decode the Predicate Index value.
20594 unsigned PIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
20595 // Check the predicate.
20596 bool Failed = !checkDecoderPredicate(Idx: PIdx, FB: Bits);
20597
20598 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckPredicate(" << PIdx << "): "
20599 << (Failed ? "FAIL, " : "PASS\n"););
20600 if (!Failed)
20601 continue;
20602 break;
20603 }
20604 case OPC_Decode: {
20605 // Decode the Opcode value.
20606 unsigned Opc = decodeULEB128AndIncUnsafe(p&: Ptr);
20607 unsigned DecodeIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
20608
20609 MI.clear();
20610 MI.setOpcode(Opc);
20611 bool DecodeComplete;
20612 S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm,
20613 DecodeComplete);
20614 LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc
20615 << ", using decoder " << DecodeIdx << ": "
20616 << (S ? "PASS, " : "FAIL, "));
20617
20618 if (DecodeComplete) {
20619 LLVM_DEBUG(dbgs() << "decoding complete\n");
20620 return S;
20621 }
20622 assert(S == MCDisassembler::Fail);
20623 // Reset decode status. This also drops a SoftFail status that could be
20624 // set before the decode attempt.
20625 S = MCDisassembler::Success;
20626 break;
20627 }
20628 }
20629 if (ScopeStack.empty()) {
20630 LLVM_DEBUG(dbgs() << "returning Fail\n");
20631 return MCDisassembler::Fail;
20632 }
20633 Ptr = ScopeStack.pop_back_val();
20634 LLVM_DEBUG(dbgs() << "continuing at " << Ptr - DecodeTable << '\n');
20635 }
20636 llvm_unreachable("bogosity detected in disassembler state machine!");
20637}
20638
20639
20640} // namespace
20641