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, 220, 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, 154, 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, 196, 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, 197, 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, 152, 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, 209, 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, 162, 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, 155, 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, 163, 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, 184, 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, 182, 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, 185, 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, 175, 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, 191, 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, 192, 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, 193, 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, 188, 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, 189, 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, 190, 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, 153, 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, 183, 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, 176, 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, 174, 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, 180, 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, 179, 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, 200, 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, 207, 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, 211, 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, 210, 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, 158, 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, 214, 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, 215, 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, 221, 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, 156, 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, 199, 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, 194, 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, 157, 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, 222, 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, 205, 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, 223, 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, 206, 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, 224, 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, 198, 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, 173, 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, 195, 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, 161, 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, 172, 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, 151, 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, 166, 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, 170, 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, 167, 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, 216, 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, 159, 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, 217, 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, 201, 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, 160, 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, 202, 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, 164, 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, 168, 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, 171, 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, 165, 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, 169, 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, 232, 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, 231, 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, 236, 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, 237, 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, 233, 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, 235, 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, 234, 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 DecoderTableXqci16[234] = {
434 16, // 0: BitWidth 16
435 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
436 0, 119, // 4: case 0x0: {
437 OPC_CheckField, 0, 2, 2, // 6: check Inst[1:0] == 0x2
438 OPC_CheckField, 12, 1, 1, // 10: check Inst[12] == 0x1
439 OPC_Scope, 66, // 14: try {
440 OPC_SwitchField, 2, 10, // 16: switch Inst[11:2] {
441 132, 4, 6, // 19: case 0x204: {
442 OPC_CheckPredicate, 11, // 22: check predicate 11
443 OPC_Decode, 251, 121, 0, // 24: decode to QC_C_MIENTER using decoder 0
444 // 24: }
445 164, 4, 6, // 28: case 0x224: {
446 OPC_CheckPredicate, 11, // 31: check predicate 11
447 OPC_Decode, 252, 121, 0, // 33: decode to QC_C_MIENTER_NEST using decoder 0
448 // 33: }
449 196, 4, 6, // 37: case 0x244: {
450 OPC_CheckPredicate, 11, // 40: check predicate 11
451 OPC_Decode, 255, 121, 0, // 42: decode to QC_C_MRET using decoder 0
452 // 42: }
453 228, 4, 6, // 46: case 0x264: {
454 OPC_CheckPredicate, 11, // 49: check predicate 11
455 OPC_Decode, 254, 121, 0, // 51: decode to QC_C_MNRET using decoder 0
456 // 51: }
457 132, 5, 6, // 55: case 0x284: {
458 OPC_CheckPredicate, 11, // 58: check predicate 11
459 OPC_Decode, 253, 121, 0, // 60: decode to QC_C_MILEAVERET using decoder 0
460 // 60: }
461 196, 5, 6, // 64: case 0x2c4: {
462 OPC_CheckPredicate, 11, // 67: check predicate 11
463 OPC_Decode, 246, 121, 0, // 69: decode to QC_C_DI using decoder 0
464 // 69: }
465 228, 5, 0, // 73: case 0x2e4: {
466 OPC_CheckPredicate, 11, // 76: check predicate 11
467 OPC_Decode, 248, 121, 0, // 78: decode to QC_C_EI using decoder 0
468 // 78: }
469 // 78: } // switch Inst[11:2]
470 OPC_Scope, 35, // 82: } else try {
471 OPC_SwitchField, 2, 5, // 84: switch Inst[6:2] {
472 0, 6, // 87: case 0x0: {
473 OPC_CheckPredicate, 11, // 89: check predicate 11
474 OPC_Decode, 247, 121, 20, // 91: decode to QC_C_DIR using decoder 20
475 // 91: }
476 1, 6, // 95: case 0x1: {
477 OPC_CheckPredicate, 11, // 97: check predicate 11
478 OPC_Decode, 249, 121, 20, // 99: decode to QC_C_EIR using decoder 20
479 // 99: }
480 2, 6, // 103: case 0x2: {
481 OPC_CheckPredicate, 11, // 105: check predicate 11
482 OPC_Decode, 130, 122, 20, // 107: decode to QC_C_SETINT using decoder 20
483 // 107: }
484 3, 0, // 111: case 0x3: {
485 OPC_CheckPredicate, 11, // 113: check predicate 11
486 OPC_Decode, 245, 121, 20, // 115: decode to QC_C_CLRINT using decoder 20
487 // 115: }
488 // 115: } // switch Inst[6:2]
489 // 115: } else try {
490 OPC_CheckPredicate, 12, // 119: check predicate 12
491 OPC_Decode, 250, 121, 34, // 121: decode to QC_C_EXTU using decoder 34
492 // 121: }
493 // 121: }
494 1, 10, // 125: case 0x1: {
495 OPC_CheckPredicate, 13, // 127: check predicate 13
496 OPC_CheckField, 0, 2, 2, // 129: check Inst[1:0] == 0x2
497 OPC_Decode, 128, 122, 35, // 133: decode to QC_C_MULIADD using decoder 35
498 // 133: }
499 4, 75, // 137: case 0x4: {
500 OPC_SwitchField, 10, 3, // 139: switch Inst[12:10] {
501 0, 10, // 142: case 0x0: {
502 OPC_CheckPredicate, 14, // 144: check predicate 14
503 OPC_CheckField, 0, 7, 1, // 146: check Inst[6:0] == 0x1
504 OPC_Decode, 131, 122, 36, // 150: decode to QC_C_SYNC using decoder 36
505 // 150: }
506 1, 10, // 154: case 0x1: {
507 OPC_CheckPredicate, 14, // 156: check predicate 14
508 OPC_CheckField, 0, 7, 1, // 158: check Inst[6:0] == 0x1
509 OPC_Decode, 132, 122, 36, // 162: decode to QC_C_SYNCR using decoder 36
510 // 162: }
511 4, 22, // 166: case 0x4: {
512 OPC_CheckField, 0, 2, 1, // 168: check Inst[1:0] == 0x1
513 OPC_Scope, 10, // 172: try {
514 OPC_CheckField, 2, 5, 0, // 174: check Inst[6:2] == 0x0
515 OPC_CheckPredicate, 14, // 178: check predicate 14
516 OPC_Decode, 133, 122, 36, // 180: decode to QC_C_SYNCWF using decoder 36
517 // 180: } else try {
518 OPC_CheckPredicate, 12, // 184: check predicate 12
519 OPC_Decode, 243, 121, 37, // 186: decode to QC_C_BEXTI using decoder 37
520 // 186: }
521 // 186: }
522 5, 0, // 190: case 0x5: {
523 OPC_CheckField, 0, 2, 1, // 192: check Inst[1:0] == 0x1
524 OPC_Scope, 10, // 196: try {
525 OPC_CheckField, 2, 5, 0, // 198: check Inst[6:2] == 0x0
526 OPC_CheckPredicate, 14, // 202: check predicate 14
527 OPC_Decode, 134, 122, 36, // 204: decode to QC_C_SYNCWL using decoder 36
528 // 204: } else try {
529 OPC_CheckPredicate, 12, // 208: check predicate 12
530 OPC_Decode, 244, 121, 37, // 210: decode to QC_C_BSETI using decoder 37
531 // 210: }
532 // 210: }
533 // 210: } // switch Inst[12:10]
534 // 210: }
535 5, 0, // 214: case 0x5: {
536 OPC_CheckPredicate, 15, // 216: check predicate 15
537 OPC_CheckField, 10, 3, 3, // 218: check Inst[12:10] == 0x3
538 OPC_CheckField, 5, 2, 0, // 222: check Inst[6:5] == 0x0
539 OPC_CheckField, 0, 2, 2, // 226: check Inst[1:0] == 0x2
540 OPC_Decode, 129, 122, 38, // 230: decode to QC_C_MVEQZ using decoder 38
541 // 230: }
542 // 230: } // switch Inst[15:13]
543};
544static const uint8_t DecoderTableXwchc16[115] = {
545 16, // 0: BitWidth 16
546 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
547 1, 19, // 4: case 0x1: {
548 OPC_SwitchField, 0, 2, // 6: switch Inst[1:0] {
549 0, 6, // 9: case 0x0: {
550 OPC_CheckPredicate, 16, // 11: check predicate 16
551 OPC_Decode, 246, 122, 39, // 13: decode to QK_C_LBU using decoder 39
552 // 13: }
553 2, 0, // 17: case 0x2: {
554 OPC_CheckPredicate, 16, // 19: check predicate 16
555 OPC_Decode, 248, 122, 40, // 21: decode to QK_C_LHU using decoder 40
556 // 21: }
557 // 21: } // switch Inst[1:0]
558 // 21: }
559 4, 67, // 25: case 0x4: {
560 OPC_SwitchField, 5, 2, // 27: switch Inst[6:5] {
561 0, 14, // 30: case 0x0: {
562 OPC_CheckPredicate, 16, // 32: check predicate 16
563 OPC_CheckField, 11, 2, 0, // 34: check Inst[12:11] == 0x0
564 OPC_CheckField, 0, 2, 0, // 38: check Inst[1:0] == 0x0
565 OPC_Decode, 247, 122, 41, // 42: decode to QK_C_LBUSP using decoder 41
566 // 42: }
567 1, 14, // 46: case 0x1: {
568 OPC_CheckPredicate, 16, // 48: check predicate 16
569 OPC_CheckField, 11, 2, 0, // 50: check Inst[12:11] == 0x0
570 OPC_CheckField, 0, 2, 0, // 54: check Inst[1:0] == 0x0
571 OPC_Decode, 249, 122, 42, // 58: decode to QK_C_LHUSP using decoder 42
572 // 58: }
573 2, 14, // 62: case 0x2: {
574 OPC_CheckPredicate, 16, // 64: check predicate 16
575 OPC_CheckField, 11, 2, 0, // 66: check Inst[12:11] == 0x0
576 OPC_CheckField, 0, 2, 0, // 70: check Inst[1:0] == 0x0
577 OPC_Decode, 251, 122, 41, // 74: decode to QK_C_SBSP using decoder 41
578 // 74: }
579 3, 0, // 78: case 0x3: {
580 OPC_CheckPredicate, 16, // 80: check predicate 16
581 OPC_CheckField, 11, 2, 0, // 82: check Inst[12:11] == 0x0
582 OPC_CheckField, 0, 2, 0, // 86: check Inst[1:0] == 0x0
583 OPC_Decode, 253, 122, 42, // 90: decode to QK_C_SHSP using decoder 42
584 // 90: }
585 // 90: } // switch Inst[6:5]
586 // 90: }
587 5, 0, // 94: case 0x5: {
588 OPC_SwitchField, 0, 2, // 96: switch Inst[1:0] {
589 0, 6, // 99: case 0x0: {
590 OPC_CheckPredicate, 16, // 101: check predicate 16
591 OPC_Decode, 250, 122, 39, // 103: decode to QK_C_SB using decoder 39
592 // 103: }
593 2, 0, // 107: case 0x2: {
594 OPC_CheckPredicate, 16, // 109: check predicate 16
595 OPC_Decode, 252, 122, 40, // 111: decode to QK_C_SH using decoder 40
596 // 111: }
597 // 111: } // switch Inst[1:0]
598 // 111: }
599 // 111: } // switch Inst[15:13]
600};
601static const uint8_t DecoderTableZcOverlap16[162] = {
602 16, // 0: BitWidth 16
603 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
604 3, 19, // 4: case 0x3: {
605 OPC_SwitchField, 0, 2, // 6: switch Inst[1:0] {
606 0, 6, // 9: case 0x0: {
607 OPC_CheckPredicate, 17, // 11: check predicate 17
608 OPC_Decode, 178, 113, 43, // 13: decode to C_LD_RV32 using decoder 43
609 // 13: }
610 2, 0, // 17: case 0x2: {
611 OPC_CheckPredicate, 17, // 19: check predicate 17
612 OPC_Decode, 177, 113, 44, // 21: decode to C_LDSP_RV32 using decoder 44
613 // 21: }
614 // 21: } // switch Inst[1:0]
615 // 21: }
616 5, 114, // 25: case 0x5: {
617 OPC_SwitchField, 10, 3, // 27: switch Inst[12:10] {
618 0, 22, // 30: case 0x0: {
619 OPC_CheckField, 0, 2, 2, // 32: check Inst[1:0] == 0x2
620 OPC_Scope, 10, // 36: try {
621 OPC_CheckField, 7, 3, 0, // 38: check Inst[9:7] == 0x0
622 OPC_CheckPredicate, 18, // 42: check predicate 18
623 OPC_Decode, 204, 110, 45, // 44: decode to CM_JT using decoder 45
624 // 44: } else try {
625 OPC_CheckPredicate, 18, // 48: check predicate 18
626 OPC_Decode, 203, 110, 46, // 50: decode to CM_JALT using decoder 46
627 // 50: }
628 // 50: }
629 3, 27, // 54: case 0x3: {
630 OPC_SwitchField, 5, 2, // 56: switch Inst[6:5] {
631 1, 10, // 59: case 0x1: {
632 OPC_CheckPredicate, 19, // 61: check predicate 19
633 OPC_CheckField, 0, 2, 2, // 63: check Inst[1:0] == 0x2
634 OPC_Decode, 206, 110, 31, // 67: decode to CM_MVSA01 using decoder 31
635 // 67: }
636 3, 0, // 71: case 0x3: {
637 OPC_CheckPredicate, 19, // 73: check predicate 19
638 OPC_CheckField, 0, 2, 2, // 75: check Inst[1:0] == 0x2
639 OPC_Decode, 205, 110, 31, // 79: decode to CM_MVA01S using decoder 31
640 // 79: }
641 // 79: } // switch Inst[6:5]
642 // 79: }
643 6, 27, // 83: case 0x6: {
644 OPC_SwitchField, 8, 2, // 85: switch Inst[9:8] {
645 0, 10, // 88: case 0x0: {
646 OPC_CheckPredicate, 19, // 90: check predicate 19
647 OPC_CheckField, 0, 2, 2, // 92: check Inst[1:0] == 0x2
648 OPC_Decode, 210, 110, 32, // 96: decode to CM_PUSH using decoder 32
649 // 96: }
650 2, 0, // 100: case 0x2: {
651 OPC_CheckPredicate, 19, // 102: check predicate 19
652 OPC_CheckField, 0, 2, 2, // 104: check Inst[1:0] == 0x2
653 OPC_Decode, 207, 110, 32, // 108: decode to CM_POP using decoder 32
654 // 108: }
655 // 108: } // switch Inst[9:8]
656 // 108: }
657 7, 0, // 112: case 0x7: {
658 OPC_SwitchField, 8, 2, // 114: switch Inst[9:8] {
659 0, 10, // 117: case 0x0: {
660 OPC_CheckPredicate, 19, // 119: check predicate 19
661 OPC_CheckField, 0, 2, 2, // 121: check Inst[1:0] == 0x2
662 OPC_Decode, 209, 110, 32, // 125: decode to CM_POPRETZ using decoder 32
663 // 125: }
664 2, 0, // 129: case 0x2: {
665 OPC_CheckPredicate, 19, // 131: check predicate 19
666 OPC_CheckField, 0, 2, 2, // 133: check Inst[1:0] == 0x2
667 OPC_Decode, 208, 110, 32, // 137: decode to CM_POPRET using decoder 32
668 // 137: }
669 // 137: } // switch Inst[9:8]
670 // 137: }
671 // 137: } // switch Inst[12:10]
672 // 137: }
673 7, 0, // 141: case 0x7: {
674 OPC_SwitchField, 0, 2, // 143: switch Inst[1:0] {
675 0, 6, // 146: case 0x0: {
676 OPC_CheckPredicate, 17, // 148: check predicate 17
677 OPC_Decode, 204, 113, 43, // 150: decode to C_SD_RV32 using decoder 43
678 // 150: }
679 2, 0, // 154: case 0x2: {
680 OPC_CheckPredicate, 17, // 156: check predicate 17
681 OPC_Decode, 203, 113, 47, // 158: decode to C_SDSP_RV32 using decoder 47
682 // 158: }
683 // 158: } // switch Inst[1:0]
684 // 158: }
685 // 158: } // switch Inst[15:13]
686};
687static const uint8_t DecoderTableZicfiss16[24] = {
688 16, // 0: BitWidth 16
689 OPC_SwitchField, 0, 16, // 1: switch Inst[15:0] {
690 129, 193, 1, 6, // 4: case 0x6081: {
691 OPC_CheckPredicate, 3, // 8: check predicate 3
692 OPC_Decode, 213, 113, 48, // 10: decode to C_SSPUSH using decoder 48
693 // 10: }
694 129, 197, 1, 0, // 14: case 0x6281: {
695 OPC_CheckPredicate, 3, // 18: check predicate 3
696 OPC_Decode, 212, 113, 49, // 20: decode to C_SSPOPCHK using decoder 49
697 // 20: }
698 // 20: } // switch Inst[15:0]
699};
700// Handling 50 cases.
701template <typename InsnType>
702static std::enable_if_t<InsnBitWidth<InsnType> == 16, DecodeStatus>
703decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
704 DecodeComplete = true;
705 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
706 TmpType tmp;
707 switch (Idx) {
708 default: llvm_unreachable("Invalid decoder index!");
709 case 0:
710 return S;
711 case 1:
712 tmp = fieldFromInstruction(insn, 2, 3);
713 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
714 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
715 return MCDisassembler::Fail;
716 tmp = 0x0;
717 tmp |= fieldFromInstruction(insn, 5, 1) << 3;
718 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
719 tmp |= fieldFromInstruction(insn, 7, 4) << 6;
720 tmp |= fieldFromInstruction(insn, 11, 2) << 4;
721 if (!Check(S, decodeUImmNonZeroOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
722 return S;
723 case 2:
724 tmp = 0x0;
725 tmp |= fieldFromInstruction(insn, 2, 5);
726 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
727 if (!Check(S, decodeSImmNonZeroOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
728 return S;
729 case 3:
730 tmp = fieldFromInstruction(insn, 7, 5);
731 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
732 tmp = fieldFromInstruction(insn, 7, 5);
733 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
734 tmp = 0x0;
735 tmp |= fieldFromInstruction(insn, 2, 5);
736 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
737 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
738 return S;
739 case 4:
740 tmp = fieldFromInstruction(insn, 7, 5);
741 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
742 tmp = fieldFromInstruction(insn, 7, 5);
743 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
744 tmp = 0x0;
745 tmp |= fieldFromInstruction(insn, 2, 5);
746 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
747 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
748 return S;
749 case 5:
750 tmp = fieldFromInstruction(insn, 2, 3);
751 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F8_D, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
752 tmp = fieldFromInstruction(insn, 7, 3);
753 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
754 tmp = 0x0;
755 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
756 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
757 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
758 return S;
759 case 6:
760 tmp = fieldFromInstruction(insn, 7, 5);
761 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
762 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
763 return MCDisassembler::Fail;
764 tmp = 0x0;
765 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
766 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
767 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
768 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
769 return S;
770 case 7:
771 tmp = fieldFromInstruction(insn, 2, 3);
772 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
773 tmp = fieldFromInstruction(insn, 7, 3);
774 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
775 tmp = 0x0;
776 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
777 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
778 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
779 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
780 return S;
781 case 8:
782 tmp = fieldFromInstruction(insn, 7, 5);
783 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
784 tmp = 0x0;
785 tmp |= fieldFromInstruction(insn, 2, 5);
786 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
787 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
788 return S;
789 case 9:
790 tmp = fieldFromInstruction(insn, 7, 5);
791 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
792 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
793 return MCDisassembler::Fail;
794 tmp = 0x0;
795 tmp |= fieldFromInstruction(insn, 2, 2) << 6;
796 tmp |= fieldFromInstruction(insn, 4, 3) << 2;
797 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
798 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
799 return S;
800 case 10:
801 tmp = fieldFromInstruction(insn, 2, 3);
802 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
803 tmp = fieldFromInstruction(insn, 7, 3);
804 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
805 tmp = 0x0;
806 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
807 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
808 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
809 return S;
810 case 11:
811 tmp = 0x2;
812 if (!Check(S, DecodeSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
813 tmp = 0x2;
814 if (!Check(S, DecodeSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
815 tmp = 0x0;
816 tmp |= fieldFromInstruction(insn, 2, 1) << 5;
817 tmp |= fieldFromInstruction(insn, 3, 2) << 7;
818 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
819 tmp |= fieldFromInstruction(insn, 6, 1) << 4;
820 tmp |= fieldFromInstruction(insn, 12, 1) << 9;
821 if (!Check(S, decodeSImmNonZeroOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
822 return S;
823 case 12:
824 tmp = fieldFromInstruction(insn, 7, 5);
825 if (!Check(S, DecodeGPRNoX2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
826 tmp = 0x0;
827 tmp |= fieldFromInstruction(insn, 2, 5);
828 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
829 if (!Check(S, decodeCLUIImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
830 return S;
831 case 13:
832 tmp = fieldFromInstruction(insn, 7, 5);
833 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
834 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
835 return MCDisassembler::Fail;
836 tmp = 0x0;
837 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
838 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
839 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
840 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
841 return S;
842 case 14:
843 tmp = fieldFromInstruction(insn, 2, 3);
844 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
845 tmp = fieldFromInstruction(insn, 7, 3);
846 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
847 tmp = 0x0;
848 tmp |= fieldFromInstruction(insn, 5, 1) << 1;
849 tmp |= fieldFromInstruction(insn, 6, 1);
850 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
851 return S;
852 case 15:
853 tmp = fieldFromInstruction(insn, 2, 3);
854 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
855 tmp = fieldFromInstruction(insn, 7, 3);
856 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
857 tmp = fieldFromInstruction(insn, 5, 1) << 1;
858 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
859 return S;
860 case 16:
861 tmp = fieldFromInstruction(insn, 7, 3);
862 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
863 tmp = fieldFromInstruction(insn, 7, 3);
864 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
865 tmp = 0x0;
866 tmp |= fieldFromInstruction(insn, 2, 5);
867 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
868 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
869 return S;
870 case 17:
871 tmp = fieldFromInstruction(insn, 7, 3);
872 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
873 tmp = fieldFromInstruction(insn, 7, 3);
874 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
875 tmp = 0x0;
876 tmp |= fieldFromInstruction(insn, 2, 5);
877 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
878 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
879 return S;
880 case 18:
881 tmp = fieldFromInstruction(insn, 7, 3);
882 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
883 tmp = fieldFromInstruction(insn, 7, 3);
884 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
885 tmp = fieldFromInstruction(insn, 2, 3);
886 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
887 return S;
888 case 19:
889 tmp = fieldFromInstruction(insn, 7, 3);
890 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
891 tmp = fieldFromInstruction(insn, 7, 3);
892 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
893 return S;
894 case 20:
895 tmp = fieldFromInstruction(insn, 7, 5);
896 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
897 return S;
898 case 21:
899 tmp = fieldFromInstruction(insn, 7, 5);
900 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
901 tmp = fieldFromInstruction(insn, 2, 5);
902 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
903 return S;
904 case 22:
905 tmp = fieldFromInstruction(insn, 7, 5);
906 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
907 tmp = fieldFromInstruction(insn, 7, 5);
908 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
909 tmp = fieldFromInstruction(insn, 2, 5);
910 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
911 return S;
912 case 23:
913 tmp = 0x0;
914 tmp |= fieldFromInstruction(insn, 2, 1) << 4;
915 tmp |= fieldFromInstruction(insn, 3, 3);
916 tmp |= fieldFromInstruction(insn, 6, 1) << 6;
917 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
918 tmp |= fieldFromInstruction(insn, 8, 1) << 9;
919 tmp |= fieldFromInstruction(insn, 9, 2) << 7;
920 tmp |= fieldFromInstruction(insn, 11, 1) << 3;
921 tmp |= fieldFromInstruction(insn, 12, 1) << 10;
922 if (!Check(S, decodeSImmOperandAndLslN<12, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
923 return S;
924 case 24:
925 tmp = fieldFromInstruction(insn, 2, 5);
926 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
927 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
928 return MCDisassembler::Fail;
929 tmp = 0x0;
930 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
931 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
932 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
933 return S;
934 case 25:
935 tmp = fieldFromInstruction(insn, 7, 3);
936 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
937 tmp = 0x0;
938 tmp |= fieldFromInstruction(insn, 2, 1) << 4;
939 tmp |= fieldFromInstruction(insn, 3, 2);
940 tmp |= fieldFromInstruction(insn, 5, 2) << 5;
941 tmp |= fieldFromInstruction(insn, 10, 2) << 2;
942 tmp |= fieldFromInstruction(insn, 12, 1) << 7;
943 if (!Check(S, decodeSImmOperandAndLslN<9, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
944 return S;
945 case 26:
946 tmp = fieldFromInstruction(insn, 2, 5);
947 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
948 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
949 return MCDisassembler::Fail;
950 tmp = 0x0;
951 tmp |= fieldFromInstruction(insn, 7, 2) << 6;
952 tmp |= fieldFromInstruction(insn, 9, 4) << 2;
953 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
954 return S;
955 case 27:
956 tmp = fieldFromInstruction(insn, 2, 5);
957 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
958 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
959 return MCDisassembler::Fail;
960 tmp = 0x0;
961 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
962 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
963 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
964 return S;
965 case 28:
966 tmp = fieldFromInstruction(insn, 2, 3);
967 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F8_F, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
968 tmp = fieldFromInstruction(insn, 7, 3);
969 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
970 tmp = 0x0;
971 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
972 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
973 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
974 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
975 return S;
976 case 29:
977 tmp = fieldFromInstruction(insn, 7, 5);
978 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
979 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
980 return MCDisassembler::Fail;
981 tmp = 0x0;
982 tmp |= fieldFromInstruction(insn, 2, 2) << 6;
983 tmp |= fieldFromInstruction(insn, 4, 3) << 2;
984 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
985 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
986 return S;
987 case 30:
988 tmp = fieldFromInstruction(insn, 2, 5);
989 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
990 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
991 return MCDisassembler::Fail;
992 tmp = 0x0;
993 tmp |= fieldFromInstruction(insn, 7, 2) << 6;
994 tmp |= fieldFromInstruction(insn, 9, 4) << 2;
995 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
996 return S;
997 case 31:
998 tmp = fieldFromInstruction(insn, 7, 3);
999 if (!Check(S, DecodeSR07RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1000 tmp = fieldFromInstruction(insn, 2, 3);
1001 if (!Check(S, DecodeSR07RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1002 return S;
1003 case 32:
1004 tmp = fieldFromInstruction(insn, 4, 4);
1005 if (!Check(S, decodeZcmpRlist(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1006 tmp = fieldFromInstruction(insn, 2, 2) << 4;
1007 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
1008 return S;
1009 case 33:
1010 tmp = fieldFromInstruction(insn, 4, 4);
1011 if (!Check(S, decodeXqccmpRlistS0(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1012 tmp = fieldFromInstruction(insn, 2, 2) << 4;
1013 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
1014 return S;
1015 case 34:
1016 tmp = fieldFromInstruction(insn, 7, 5);
1017 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1018 tmp = fieldFromInstruction(insn, 7, 5);
1019 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1020 tmp = fieldFromInstruction(insn, 2, 5);
1021 if (!Check(S, decodeUImmPlus1OperandGE<5,6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1022 return S;
1023 case 35:
1024 tmp = fieldFromInstruction(insn, 2, 3);
1025 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1026 tmp = fieldFromInstruction(insn, 2, 3);
1027 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1028 tmp = fieldFromInstruction(insn, 7, 3);
1029 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1030 tmp = 0x0;
1031 tmp |= fieldFromInstruction(insn, 5, 1) << 4;
1032 tmp |= fieldFromInstruction(insn, 6, 1);
1033 tmp |= fieldFromInstruction(insn, 10, 3) << 1;
1034 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1035 return S;
1036 case 36:
1037 tmp = fieldFromInstruction(insn, 7, 3);
1038 if (!Check(S, decodeUImmSlistOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1039 return S;
1040 case 37:
1041 tmp = fieldFromInstruction(insn, 7, 3);
1042 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1043 tmp = fieldFromInstruction(insn, 7, 3);
1044 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1045 tmp = fieldFromInstruction(insn, 2, 5);
1046 if (!Check(S, decodeUImmLog2XLenNonZeroOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1047 return S;
1048 case 38:
1049 tmp = fieldFromInstruction(insn, 2, 3);
1050 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1051 tmp = fieldFromInstruction(insn, 2, 3);
1052 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1053 tmp = fieldFromInstruction(insn, 7, 3);
1054 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1055 return S;
1056 case 39:
1057 tmp = fieldFromInstruction(insn, 2, 3);
1058 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1059 tmp = fieldFromInstruction(insn, 7, 3);
1060 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1061 tmp = 0x0;
1062 tmp |= fieldFromInstruction(insn, 5, 2) << 1;
1063 tmp |= fieldFromInstruction(insn, 10, 2) << 3;
1064 tmp |= fieldFromInstruction(insn, 12, 1);
1065 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1066 return S;
1067 case 40:
1068 tmp = fieldFromInstruction(insn, 2, 3);
1069 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1070 tmp = fieldFromInstruction(insn, 7, 3);
1071 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1072 tmp = 0x0;
1073 tmp |= fieldFromInstruction(insn, 5, 2) << 1;
1074 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1075 if (!Check(S, decodeUImmOperand<6>(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 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
1081 return MCDisassembler::Fail;
1082 tmp = fieldFromInstruction(insn, 7, 4);
1083 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1084 return S;
1085 case 42:
1086 tmp = fieldFromInstruction(insn, 2, 3);
1087 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1088 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
1089 return MCDisassembler::Fail;
1090 tmp = 0x0;
1091 tmp |= fieldFromInstruction(insn, 7, 1) << 4;
1092 tmp |= fieldFromInstruction(insn, 8, 3) << 1;
1093 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1094 return S;
1095 case 43:
1096 tmp = fieldFromInstruction(insn, 2, 3);
1097 if (!Check(S, DecodeGPRPairCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1098 tmp = fieldFromInstruction(insn, 7, 3);
1099 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1100 tmp = 0x0;
1101 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
1102 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1103 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1104 return S;
1105 case 44:
1106 tmp = fieldFromInstruction(insn, 7, 5);
1107 if (!Check(S, DecodeGPRPairNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1108 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
1109 return MCDisassembler::Fail;
1110 tmp = 0x0;
1111 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
1112 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
1113 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
1114 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1115 return S;
1116 case 45:
1117 tmp = fieldFromInstruction(insn, 2, 5);
1118 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1119 return S;
1120 case 46:
1121 tmp = fieldFromInstruction(insn, 2, 8);
1122 if (!Check(S, decodeUImmOperandGE<8, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1123 return S;
1124 case 47:
1125 tmp = fieldFromInstruction(insn, 2, 5);
1126 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1127 if (!Check(Out&: S, In: DecodeSPRegisterClass(Inst&: MI, Decoder)))
1128 return MCDisassembler::Fail;
1129 tmp = 0x0;
1130 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
1131 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1132 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1133 return S;
1134 case 48:
1135 if (!Check(Out&: S, In: DecodeGPRX1RegisterClass(Inst&: MI, Decoder)))
1136 return MCDisassembler::Fail;
1137 return S;
1138 case 49:
1139 if (!Check(Out&: S, In: DecodeGPRX5RegisterClass(Inst&: MI, Decoder)))
1140 return MCDisassembler::Fail;
1141 return S;
1142 }
1143}
1144static const uint8_t DecoderTable32[19996] = {
1145 32, // 0: BitWidth 32
1146 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
1147 3, 49, // 4: case 0x3: {
1148 OPC_SwitchField, 12, 3, // 6: switch Inst[14:12] {
1149 0, 4, // 9: case 0x0: {
1150 OPC_Decode, 171, 116, 0, // 11: decode to LB using decoder 0
1151 // 11: }
1152 1, 4, // 15: case 0x1: {
1153 OPC_Decode, 179, 116, 0, // 17: decode to LH using decoder 0
1154 // 17: }
1155 2, 4, // 21: case 0x2: {
1156 OPC_Decode, 193, 116, 0, // 23: decode to LW using decoder 0
1157 // 23: }
1158 3, 6, // 27: case 0x3: {
1159 OPC_CheckPredicate, 20, // 29: check predicate 20
1160 OPC_Decode, 175, 116, 0, // 31: decode to LD using decoder 0
1161 // 31: }
1162 4, 4, // 35: case 0x4: {
1163 OPC_Decode, 172, 116, 0, // 37: decode to LBU using decoder 0
1164 // 37: }
1165 5, 4, // 41: case 0x5: {
1166 OPC_Decode, 180, 116, 0, // 43: decode to LHU using decoder 0
1167 // 43: }
1168 6, 0, // 47: case 0x6: {
1169 OPC_CheckPredicate, 20, // 49: check predicate 20
1170 OPC_Decode, 194, 116, 0, // 51: decode to LWU using decoder 0
1171 // 51: }
1172 // 51: } // switch Inst[14:12]
1173 // 51: }
1174 7, 189, 13, // 55: case 0x7: {
1175 OPC_SwitchField, 12, 3, // 58: switch Inst[14:12] {
1176 0, 173, 3, // 61: case 0x0: {
1177 OPC_SwitchField, 26, 6, // 64: switch Inst[31:26] {
1178 0, 43, // 67: case 0x0: {
1179 OPC_SwitchField, 20, 5, // 69: switch Inst[24:20] {
1180 0, 6, // 72: case 0x0: {
1181 OPC_CheckPredicate, 21, // 74: check predicate 21
1182 OPC_Decode, 253, 126, 1, // 76: decode to VLE8_V using decoder 1
1183 // 76: }
1184 8, 10, // 80: case 0x8: {
1185 OPC_CheckPredicate, 21, // 82: check predicate 21
1186 OPC_CheckField, 25, 1, 1, // 84: check Inst[25] == 0x1
1187 OPC_Decode, 233, 126, 2, // 88: decode to VL1RE8_V using decoder 2
1188 // 88: }
1189 11, 10, // 92: case 0xb: {
1190 OPC_CheckPredicate, 21, // 94: check predicate 21
1191 OPC_CheckField, 25, 1, 1, // 96: check Inst[25] == 0x1
1192 OPC_Decode, 254, 126, 2, // 100: decode to VLM_V using decoder 2
1193 // 100: }
1194 16, 0, // 104: case 0x10: {
1195 OPC_CheckPredicate, 21, // 106: check predicate 21
1196 OPC_Decode, 252, 126, 1, // 108: decode to VLE8FF_V using decoder 1
1197 // 108: }
1198 // 108: } // switch Inst[24:20]
1199 // 108: }
1200 1, 6, // 112: case 0x1: {
1201 OPC_CheckPredicate, 21, // 114: check predicate 21
1202 OPC_Decode, 250, 127, 3, // 116: decode to VLUXEI8_V using decoder 3
1203 // 116: }
1204 2, 6, // 120: case 0x2: {
1205 OPC_CheckPredicate, 21, // 122: check predicate 21
1206 OPC_Decode, 162, 127, 4, // 124: decode to VLSE8_V using decoder 4
1207 // 124: }
1208 3, 6, // 128: case 0x3: {
1209 OPC_CheckPredicate, 21, // 130: check predicate 21
1210 OPC_Decode, 130, 127, 3, // 132: decode to VLOXEI8_V using decoder 3
1211 // 132: }
1212 8, 31, // 136: case 0x8: {
1213 OPC_SwitchField, 20, 5, // 138: switch Inst[24:20] {
1214 0, 6, // 141: case 0x0: {
1215 OPC_CheckPredicate, 21, // 143: check predicate 21
1216 OPC_Decode, 170, 127, 1, // 145: decode to VLSEG2E8_V using decoder 1
1217 // 145: }
1218 8, 10, // 149: case 0x8: {
1219 OPC_CheckPredicate, 21, // 151: check predicate 21
1220 OPC_CheckField, 25, 1, 1, // 153: check Inst[25] == 0x1
1221 OPC_Decode, 237, 126, 5, // 157: decode to VL2RE8_V using decoder 5
1222 // 157: }
1223 16, 0, // 161: case 0x10: {
1224 OPC_CheckPredicate, 21, // 163: check predicate 21
1225 OPC_Decode, 169, 127, 1, // 165: decode to VLSEG2E8FF_V using decoder 1
1226 // 165: }
1227 // 165: } // switch Inst[24:20]
1228 // 165: }
1229 9, 6, // 169: case 0x9: {
1230 OPC_CheckPredicate, 21, // 171: check predicate 21
1231 OPC_Decode, 254, 127, 3, // 173: decode to VLUXSEG2EI8_V using decoder 3
1232 // 173: }
1233 10, 6, // 177: case 0xa: {
1234 OPC_CheckPredicate, 21, // 179: check predicate 21
1235 OPC_Decode, 222, 127, 4, // 181: decode to VLSSEG2E8_V using decoder 4
1236 // 181: }
1237 11, 6, // 185: case 0xb: {
1238 OPC_CheckPredicate, 21, // 187: check predicate 21
1239 OPC_Decode, 134, 127, 3, // 189: decode to VLOXSEG2EI8_V using decoder 3
1240 // 189: }
1241 16, 19, // 193: case 0x10: {
1242 OPC_SwitchField, 20, 5, // 195: switch Inst[24:20] {
1243 0, 6, // 198: case 0x0: {
1244 OPC_CheckPredicate, 21, // 200: check predicate 21
1245 OPC_Decode, 178, 127, 1, // 202: decode to VLSEG3E8_V using decoder 1
1246 // 202: }
1247 16, 0, // 206: case 0x10: {
1248 OPC_CheckPredicate, 21, // 208: check predicate 21
1249 OPC_Decode, 177, 127, 1, // 210: decode to VLSEG3E8FF_V using decoder 1
1250 // 210: }
1251 // 210: } // switch Inst[24:20]
1252 // 210: }
1253 17, 7, // 214: case 0x11: {
1254 OPC_CheckPredicate, 21, // 216: check predicate 21
1255 OPC_Decode, 130, 128, 1, 3, // 218: decode to VLUXSEG3EI8_V using decoder 3
1256 // 218: }
1257 18, 6, // 223: case 0x12: {
1258 OPC_CheckPredicate, 21, // 225: check predicate 21
1259 OPC_Decode, 226, 127, 4, // 227: decode to VLSSEG3E8_V using decoder 4
1260 // 227: }
1261 19, 6, // 231: case 0x13: {
1262 OPC_CheckPredicate, 21, // 233: check predicate 21
1263 OPC_Decode, 138, 127, 3, // 235: decode to VLOXSEG3EI8_V using decoder 3
1264 // 235: }
1265 24, 31, // 239: case 0x18: {
1266 OPC_SwitchField, 20, 5, // 241: switch Inst[24:20] {
1267 0, 6, // 244: case 0x0: {
1268 OPC_CheckPredicate, 21, // 246: check predicate 21
1269 OPC_Decode, 186, 127, 1, // 248: decode to VLSEG4E8_V using decoder 1
1270 // 248: }
1271 8, 10, // 252: case 0x8: {
1272 OPC_CheckPredicate, 21, // 254: check predicate 21
1273 OPC_CheckField, 25, 1, 1, // 256: check Inst[25] == 0x1
1274 OPC_Decode, 241, 126, 6, // 260: decode to VL4RE8_V using decoder 6
1275 // 260: }
1276 16, 0, // 264: case 0x10: {
1277 OPC_CheckPredicate, 21, // 266: check predicate 21
1278 OPC_Decode, 185, 127, 1, // 268: decode to VLSEG4E8FF_V using decoder 1
1279 // 268: }
1280 // 268: } // switch Inst[24:20]
1281 // 268: }
1282 25, 7, // 272: case 0x19: {
1283 OPC_CheckPredicate, 21, // 274: check predicate 21
1284 OPC_Decode, 134, 128, 1, 3, // 276: decode to VLUXSEG4EI8_V using decoder 3
1285 // 276: }
1286 26, 6, // 281: case 0x1a: {
1287 OPC_CheckPredicate, 21, // 283: check predicate 21
1288 OPC_Decode, 230, 127, 4, // 285: decode to VLSSEG4E8_V using decoder 4
1289 // 285: }
1290 27, 6, // 289: case 0x1b: {
1291 OPC_CheckPredicate, 21, // 291: check predicate 21
1292 OPC_Decode, 142, 127, 3, // 293: decode to VLOXSEG4EI8_V using decoder 3
1293 // 293: }
1294 32, 19, // 297: case 0x20: {
1295 OPC_SwitchField, 20, 5, // 299: switch Inst[24:20] {
1296 0, 6, // 302: case 0x0: {
1297 OPC_CheckPredicate, 21, // 304: check predicate 21
1298 OPC_Decode, 194, 127, 1, // 306: decode to VLSEG5E8_V using decoder 1
1299 // 306: }
1300 16, 0, // 310: case 0x10: {
1301 OPC_CheckPredicate, 21, // 312: check predicate 21
1302 OPC_Decode, 193, 127, 1, // 314: decode to VLSEG5E8FF_V using decoder 1
1303 // 314: }
1304 // 314: } // switch Inst[24:20]
1305 // 314: }
1306 33, 7, // 318: case 0x21: {
1307 OPC_CheckPredicate, 21, // 320: check predicate 21
1308 OPC_Decode, 138, 128, 1, 3, // 322: decode to VLUXSEG5EI8_V using decoder 3
1309 // 322: }
1310 34, 6, // 327: case 0x22: {
1311 OPC_CheckPredicate, 21, // 329: check predicate 21
1312 OPC_Decode, 234, 127, 4, // 331: decode to VLSSEG5E8_V using decoder 4
1313 // 331: }
1314 35, 6, // 335: case 0x23: {
1315 OPC_CheckPredicate, 21, // 337: check predicate 21
1316 OPC_Decode, 146, 127, 3, // 339: decode to VLOXSEG5EI8_V using decoder 3
1317 // 339: }
1318 40, 19, // 343: case 0x28: {
1319 OPC_SwitchField, 20, 5, // 345: switch Inst[24:20] {
1320 0, 6, // 348: case 0x0: {
1321 OPC_CheckPredicate, 21, // 350: check predicate 21
1322 OPC_Decode, 202, 127, 1, // 352: decode to VLSEG6E8_V using decoder 1
1323 // 352: }
1324 16, 0, // 356: case 0x10: {
1325 OPC_CheckPredicate, 21, // 358: check predicate 21
1326 OPC_Decode, 201, 127, 1, // 360: decode to VLSEG6E8FF_V using decoder 1
1327 // 360: }
1328 // 360: } // switch Inst[24:20]
1329 // 360: }
1330 41, 7, // 364: case 0x29: {
1331 OPC_CheckPredicate, 21, // 366: check predicate 21
1332 OPC_Decode, 142, 128, 1, 3, // 368: decode to VLUXSEG6EI8_V using decoder 3
1333 // 368: }
1334 42, 6, // 373: case 0x2a: {
1335 OPC_CheckPredicate, 21, // 375: check predicate 21
1336 OPC_Decode, 238, 127, 4, // 377: decode to VLSSEG6E8_V using decoder 4
1337 // 377: }
1338 43, 6, // 381: case 0x2b: {
1339 OPC_CheckPredicate, 21, // 383: check predicate 21
1340 OPC_Decode, 150, 127, 3, // 385: decode to VLOXSEG6EI8_V using decoder 3
1341 // 385: }
1342 48, 19, // 389: case 0x30: {
1343 OPC_SwitchField, 20, 5, // 391: switch Inst[24:20] {
1344 0, 6, // 394: case 0x0: {
1345 OPC_CheckPredicate, 21, // 396: check predicate 21
1346 OPC_Decode, 210, 127, 1, // 398: decode to VLSEG7E8_V using decoder 1
1347 // 398: }
1348 16, 0, // 402: case 0x10: {
1349 OPC_CheckPredicate, 21, // 404: check predicate 21
1350 OPC_Decode, 209, 127, 1, // 406: decode to VLSEG7E8FF_V using decoder 1
1351 // 406: }
1352 // 406: } // switch Inst[24:20]
1353 // 406: }
1354 49, 7, // 410: case 0x31: {
1355 OPC_CheckPredicate, 21, // 412: check predicate 21
1356 OPC_Decode, 146, 128, 1, 3, // 414: decode to VLUXSEG7EI8_V using decoder 3
1357 // 414: }
1358 50, 6, // 419: case 0x32: {
1359 OPC_CheckPredicate, 21, // 421: check predicate 21
1360 OPC_Decode, 242, 127, 4, // 423: decode to VLSSEG7E8_V using decoder 4
1361 // 423: }
1362 51, 6, // 427: case 0x33: {
1363 OPC_CheckPredicate, 21, // 429: check predicate 21
1364 OPC_Decode, 154, 127, 3, // 431: decode to VLOXSEG7EI8_V using decoder 3
1365 // 431: }
1366 56, 31, // 435: case 0x38: {
1367 OPC_SwitchField, 20, 5, // 437: switch Inst[24:20] {
1368 0, 6, // 440: case 0x0: {
1369 OPC_CheckPredicate, 21, // 442: check predicate 21
1370 OPC_Decode, 218, 127, 1, // 444: decode to VLSEG8E8_V using decoder 1
1371 // 444: }
1372 8, 10, // 448: case 0x8: {
1373 OPC_CheckPredicate, 21, // 450: check predicate 21
1374 OPC_CheckField, 25, 1, 1, // 452: check Inst[25] == 0x1
1375 OPC_Decode, 245, 126, 7, // 456: decode to VL8RE8_V using decoder 7
1376 // 456: }
1377 16, 0, // 460: case 0x10: {
1378 OPC_CheckPredicate, 21, // 462: check predicate 21
1379 OPC_Decode, 217, 127, 1, // 464: decode to VLSEG8E8FF_V using decoder 1
1380 // 464: }
1381 // 464: } // switch Inst[24:20]
1382 // 464: }
1383 57, 7, // 468: case 0x39: {
1384 OPC_CheckPredicate, 21, // 470: check predicate 21
1385 OPC_Decode, 150, 128, 1, 3, // 472: decode to VLUXSEG8EI8_V using decoder 3
1386 // 472: }
1387 58, 6, // 477: case 0x3a: {
1388 OPC_CheckPredicate, 21, // 479: check predicate 21
1389 OPC_Decode, 246, 127, 4, // 481: decode to VLSSEG8E8_V using decoder 4
1390 // 481: }
1391 59, 0, // 485: case 0x3b: {
1392 OPC_CheckPredicate, 21, // 487: check predicate 21
1393 OPC_Decode, 158, 127, 3, // 489: decode to VLOXSEG8EI8_V using decoder 3
1394 // 489: }
1395 // 489: } // switch Inst[31:26]
1396 // 489: }
1397 1, 6, // 493: case 0x1: {
1398 OPC_CheckPredicate, 22, // 495: check predicate 22
1399 OPC_Decode, 235, 114, 8, // 497: decode to FLH using decoder 8
1400 // 497: }
1401 2, 6, // 501: case 0x2: {
1402 OPC_CheckPredicate, 23, // 503: check predicate 23
1403 OPC_Decode, 253, 114, 9, // 505: decode to FLW using decoder 9
1404 // 505: }
1405 3, 6, // 509: case 0x3: {
1406 OPC_CheckPredicate, 24, // 511: check predicate 24
1407 OPC_Decode, 222, 114, 10, // 513: decode to FLD using decoder 10
1408 // 513: }
1409 4, 6, // 517: case 0x4: {
1410 OPC_CheckPredicate, 25, // 519: check predicate 25
1411 OPC_Decode, 240, 114, 11, // 521: decode to FLQ using decoder 11
1412 // 521: }
1413 5, 160, 3, // 525: case 0x5: {
1414 OPC_SwitchField, 26, 6, // 528: switch Inst[31:26] {
1415 0, 31, // 531: case 0x0: {
1416 OPC_SwitchField, 20, 5, // 533: switch Inst[24:20] {
1417 0, 6, // 536: case 0x0: {
1418 OPC_CheckPredicate, 21, // 538: check predicate 21
1419 OPC_Decode, 247, 126, 1, // 540: decode to VLE16_V using decoder 1
1420 // 540: }
1421 8, 10, // 544: case 0x8: {
1422 OPC_CheckPredicate, 21, // 546: check predicate 21
1423 OPC_CheckField, 25, 1, 1, // 548: check Inst[25] == 0x1
1424 OPC_Decode, 230, 126, 2, // 552: decode to VL1RE16_V using decoder 2
1425 // 552: }
1426 16, 0, // 556: case 0x10: {
1427 OPC_CheckPredicate, 21, // 558: check predicate 21
1428 OPC_Decode, 246, 126, 1, // 560: decode to VLE16FF_V using decoder 1
1429 // 560: }
1430 // 560: } // switch Inst[24:20]
1431 // 560: }
1432 1, 6, // 564: case 0x1: {
1433 OPC_CheckPredicate, 21, // 566: check predicate 21
1434 OPC_Decode, 247, 127, 3, // 568: decode to VLUXEI16_V using decoder 3
1435 // 568: }
1436 2, 6, // 572: case 0x2: {
1437 OPC_CheckPredicate, 21, // 574: check predicate 21
1438 OPC_Decode, 159, 127, 4, // 576: decode to VLSE16_V using decoder 4
1439 // 576: }
1440 3, 6, // 580: case 0x3: {
1441 OPC_CheckPredicate, 21, // 582: check predicate 21
1442 OPC_Decode, 255, 126, 3, // 584: decode to VLOXEI16_V using decoder 3
1443 // 584: }
1444 8, 31, // 588: case 0x8: {
1445 OPC_SwitchField, 20, 5, // 590: switch Inst[24:20] {
1446 0, 6, // 593: case 0x0: {
1447 OPC_CheckPredicate, 21, // 595: check predicate 21
1448 OPC_Decode, 164, 127, 1, // 597: decode to VLSEG2E16_V using decoder 1
1449 // 597: }
1450 8, 10, // 601: case 0x8: {
1451 OPC_CheckPredicate, 21, // 603: check predicate 21
1452 OPC_CheckField, 25, 1, 1, // 605: check Inst[25] == 0x1
1453 OPC_Decode, 234, 126, 5, // 609: decode to VL2RE16_V using decoder 5
1454 // 609: }
1455 16, 0, // 613: case 0x10: {
1456 OPC_CheckPredicate, 21, // 615: check predicate 21
1457 OPC_Decode, 163, 127, 1, // 617: decode to VLSEG2E16FF_V using decoder 1
1458 // 617: }
1459 // 617: } // switch Inst[24:20]
1460 // 617: }
1461 9, 6, // 621: case 0x9: {
1462 OPC_CheckPredicate, 21, // 623: check predicate 21
1463 OPC_Decode, 251, 127, 3, // 625: decode to VLUXSEG2EI16_V using decoder 3
1464 // 625: }
1465 10, 6, // 629: case 0xa: {
1466 OPC_CheckPredicate, 21, // 631: check predicate 21
1467 OPC_Decode, 219, 127, 4, // 633: decode to VLSSEG2E16_V using decoder 4
1468 // 633: }
1469 11, 6, // 637: case 0xb: {
1470 OPC_CheckPredicate, 21, // 639: check predicate 21
1471 OPC_Decode, 131, 127, 3, // 641: decode to VLOXSEG2EI16_V using decoder 3
1472 // 641: }
1473 16, 19, // 645: case 0x10: {
1474 OPC_SwitchField, 20, 5, // 647: switch Inst[24:20] {
1475 0, 6, // 650: case 0x0: {
1476 OPC_CheckPredicate, 21, // 652: check predicate 21
1477 OPC_Decode, 172, 127, 1, // 654: decode to VLSEG3E16_V using decoder 1
1478 // 654: }
1479 16, 0, // 658: case 0x10: {
1480 OPC_CheckPredicate, 21, // 660: check predicate 21
1481 OPC_Decode, 171, 127, 1, // 662: decode to VLSEG3E16FF_V using decoder 1
1482 // 662: }
1483 // 662: } // switch Inst[24:20]
1484 // 662: }
1485 17, 6, // 666: case 0x11: {
1486 OPC_CheckPredicate, 21, // 668: check predicate 21
1487 OPC_Decode, 255, 127, 3, // 670: decode to VLUXSEG3EI16_V using decoder 3
1488 // 670: }
1489 18, 6, // 674: case 0x12: {
1490 OPC_CheckPredicate, 21, // 676: check predicate 21
1491 OPC_Decode, 223, 127, 4, // 678: decode to VLSSEG3E16_V using decoder 4
1492 // 678: }
1493 19, 6, // 682: case 0x13: {
1494 OPC_CheckPredicate, 21, // 684: check predicate 21
1495 OPC_Decode, 135, 127, 3, // 686: decode to VLOXSEG3EI16_V using decoder 3
1496 // 686: }
1497 24, 31, // 690: case 0x18: {
1498 OPC_SwitchField, 20, 5, // 692: switch Inst[24:20] {
1499 0, 6, // 695: case 0x0: {
1500 OPC_CheckPredicate, 21, // 697: check predicate 21
1501 OPC_Decode, 180, 127, 1, // 699: decode to VLSEG4E16_V using decoder 1
1502 // 699: }
1503 8, 10, // 703: case 0x8: {
1504 OPC_CheckPredicate, 21, // 705: check predicate 21
1505 OPC_CheckField, 25, 1, 1, // 707: check Inst[25] == 0x1
1506 OPC_Decode, 238, 126, 6, // 711: decode to VL4RE16_V using decoder 6
1507 // 711: }
1508 16, 0, // 715: case 0x10: {
1509 OPC_CheckPredicate, 21, // 717: check predicate 21
1510 OPC_Decode, 179, 127, 1, // 719: decode to VLSEG4E16FF_V using decoder 1
1511 // 719: }
1512 // 719: } // switch Inst[24:20]
1513 // 719: }
1514 25, 7, // 723: case 0x19: {
1515 OPC_CheckPredicate, 21, // 725: check predicate 21
1516 OPC_Decode, 131, 128, 1, 3, // 727: decode to VLUXSEG4EI16_V using decoder 3
1517 // 727: }
1518 26, 6, // 732: case 0x1a: {
1519 OPC_CheckPredicate, 21, // 734: check predicate 21
1520 OPC_Decode, 227, 127, 4, // 736: decode to VLSSEG4E16_V using decoder 4
1521 // 736: }
1522 27, 6, // 740: case 0x1b: {
1523 OPC_CheckPredicate, 21, // 742: check predicate 21
1524 OPC_Decode, 139, 127, 3, // 744: decode to VLOXSEG4EI16_V using decoder 3
1525 // 744: }
1526 32, 19, // 748: case 0x20: {
1527 OPC_SwitchField, 20, 5, // 750: switch Inst[24:20] {
1528 0, 6, // 753: case 0x0: {
1529 OPC_CheckPredicate, 21, // 755: check predicate 21
1530 OPC_Decode, 188, 127, 1, // 757: decode to VLSEG5E16_V using decoder 1
1531 // 757: }
1532 16, 0, // 761: case 0x10: {
1533 OPC_CheckPredicate, 21, // 763: check predicate 21
1534 OPC_Decode, 187, 127, 1, // 765: decode to VLSEG5E16FF_V using decoder 1
1535 // 765: }
1536 // 765: } // switch Inst[24:20]
1537 // 765: }
1538 33, 7, // 769: case 0x21: {
1539 OPC_CheckPredicate, 21, // 771: check predicate 21
1540 OPC_Decode, 135, 128, 1, 3, // 773: decode to VLUXSEG5EI16_V using decoder 3
1541 // 773: }
1542 34, 6, // 778: case 0x22: {
1543 OPC_CheckPredicate, 21, // 780: check predicate 21
1544 OPC_Decode, 231, 127, 4, // 782: decode to VLSSEG5E16_V using decoder 4
1545 // 782: }
1546 35, 6, // 786: case 0x23: {
1547 OPC_CheckPredicate, 21, // 788: check predicate 21
1548 OPC_Decode, 143, 127, 3, // 790: decode to VLOXSEG5EI16_V using decoder 3
1549 // 790: }
1550 40, 19, // 794: case 0x28: {
1551 OPC_SwitchField, 20, 5, // 796: switch Inst[24:20] {
1552 0, 6, // 799: case 0x0: {
1553 OPC_CheckPredicate, 21, // 801: check predicate 21
1554 OPC_Decode, 196, 127, 1, // 803: decode to VLSEG6E16_V using decoder 1
1555 // 803: }
1556 16, 0, // 807: case 0x10: {
1557 OPC_CheckPredicate, 21, // 809: check predicate 21
1558 OPC_Decode, 195, 127, 1, // 811: decode to VLSEG6E16FF_V using decoder 1
1559 // 811: }
1560 // 811: } // switch Inst[24:20]
1561 // 811: }
1562 41, 7, // 815: case 0x29: {
1563 OPC_CheckPredicate, 21, // 817: check predicate 21
1564 OPC_Decode, 139, 128, 1, 3, // 819: decode to VLUXSEG6EI16_V using decoder 3
1565 // 819: }
1566 42, 6, // 824: case 0x2a: {
1567 OPC_CheckPredicate, 21, // 826: check predicate 21
1568 OPC_Decode, 235, 127, 4, // 828: decode to VLSSEG6E16_V using decoder 4
1569 // 828: }
1570 43, 6, // 832: case 0x2b: {
1571 OPC_CheckPredicate, 21, // 834: check predicate 21
1572 OPC_Decode, 147, 127, 3, // 836: decode to VLOXSEG6EI16_V using decoder 3
1573 // 836: }
1574 48, 19, // 840: case 0x30: {
1575 OPC_SwitchField, 20, 5, // 842: switch Inst[24:20] {
1576 0, 6, // 845: case 0x0: {
1577 OPC_CheckPredicate, 21, // 847: check predicate 21
1578 OPC_Decode, 204, 127, 1, // 849: decode to VLSEG7E16_V using decoder 1
1579 // 849: }
1580 16, 0, // 853: case 0x10: {
1581 OPC_CheckPredicate, 21, // 855: check predicate 21
1582 OPC_Decode, 203, 127, 1, // 857: decode to VLSEG7E16FF_V using decoder 1
1583 // 857: }
1584 // 857: } // switch Inst[24:20]
1585 // 857: }
1586 49, 7, // 861: case 0x31: {
1587 OPC_CheckPredicate, 21, // 863: check predicate 21
1588 OPC_Decode, 143, 128, 1, 3, // 865: decode to VLUXSEG7EI16_V using decoder 3
1589 // 865: }
1590 50, 6, // 870: case 0x32: {
1591 OPC_CheckPredicate, 21, // 872: check predicate 21
1592 OPC_Decode, 239, 127, 4, // 874: decode to VLSSEG7E16_V using decoder 4
1593 // 874: }
1594 51, 6, // 878: case 0x33: {
1595 OPC_CheckPredicate, 21, // 880: check predicate 21
1596 OPC_Decode, 151, 127, 3, // 882: decode to VLOXSEG7EI16_V using decoder 3
1597 // 882: }
1598 56, 31, // 886: case 0x38: {
1599 OPC_SwitchField, 20, 5, // 888: switch Inst[24:20] {
1600 0, 6, // 891: case 0x0: {
1601 OPC_CheckPredicate, 21, // 893: check predicate 21
1602 OPC_Decode, 212, 127, 1, // 895: decode to VLSEG8E16_V using decoder 1
1603 // 895: }
1604 8, 10, // 899: case 0x8: {
1605 OPC_CheckPredicate, 21, // 901: check predicate 21
1606 OPC_CheckField, 25, 1, 1, // 903: check Inst[25] == 0x1
1607 OPC_Decode, 242, 126, 7, // 907: decode to VL8RE16_V using decoder 7
1608 // 907: }
1609 16, 0, // 911: case 0x10: {
1610 OPC_CheckPredicate, 21, // 913: check predicate 21
1611 OPC_Decode, 211, 127, 1, // 915: decode to VLSEG8E16FF_V using decoder 1
1612 // 915: }
1613 // 915: } // switch Inst[24:20]
1614 // 915: }
1615 57, 7, // 919: case 0x39: {
1616 OPC_CheckPredicate, 21, // 921: check predicate 21
1617 OPC_Decode, 147, 128, 1, 3, // 923: decode to VLUXSEG8EI16_V using decoder 3
1618 // 923: }
1619 58, 6, // 928: case 0x3a: {
1620 OPC_CheckPredicate, 21, // 930: check predicate 21
1621 OPC_Decode, 243, 127, 4, // 932: decode to VLSSEG8E16_V using decoder 4
1622 // 932: }
1623 59, 0, // 936: case 0x3b: {
1624 OPC_CheckPredicate, 21, // 938: check predicate 21
1625 OPC_Decode, 155, 127, 3, // 940: decode to VLOXSEG8EI16_V using decoder 3
1626 // 940: }
1627 // 940: } // switch Inst[31:26]
1628 // 940: }
1629 6, 161, 3, // 944: case 0x6: {
1630 OPC_SwitchField, 26, 6, // 947: switch Inst[31:26] {
1631 0, 31, // 950: case 0x0: {
1632 OPC_SwitchField, 20, 5, // 952: switch Inst[24:20] {
1633 0, 6, // 955: case 0x0: {
1634 OPC_CheckPredicate, 21, // 957: check predicate 21
1635 OPC_Decode, 249, 126, 1, // 959: decode to VLE32_V using decoder 1
1636 // 959: }
1637 8, 10, // 963: case 0x8: {
1638 OPC_CheckPredicate, 21, // 965: check predicate 21
1639 OPC_CheckField, 25, 1, 1, // 967: check Inst[25] == 0x1
1640 OPC_Decode, 231, 126, 2, // 971: decode to VL1RE32_V using decoder 2
1641 // 971: }
1642 16, 0, // 975: case 0x10: {
1643 OPC_CheckPredicate, 21, // 977: check predicate 21
1644 OPC_Decode, 248, 126, 1, // 979: decode to VLE32FF_V using decoder 1
1645 // 979: }
1646 // 979: } // switch Inst[24:20]
1647 // 979: }
1648 1, 6, // 983: case 0x1: {
1649 OPC_CheckPredicate, 21, // 985: check predicate 21
1650 OPC_Decode, 248, 127, 3, // 987: decode to VLUXEI32_V using decoder 3
1651 // 987: }
1652 2, 6, // 991: case 0x2: {
1653 OPC_CheckPredicate, 21, // 993: check predicate 21
1654 OPC_Decode, 160, 127, 4, // 995: decode to VLSE32_V using decoder 4
1655 // 995: }
1656 3, 6, // 999: case 0x3: {
1657 OPC_CheckPredicate, 21, // 1001: check predicate 21
1658 OPC_Decode, 128, 127, 3, // 1003: decode to VLOXEI32_V using decoder 3
1659 // 1003: }
1660 8, 31, // 1007: case 0x8: {
1661 OPC_SwitchField, 20, 5, // 1009: switch Inst[24:20] {
1662 0, 6, // 1012: case 0x0: {
1663 OPC_CheckPredicate, 21, // 1014: check predicate 21
1664 OPC_Decode, 166, 127, 1, // 1016: decode to VLSEG2E32_V using decoder 1
1665 // 1016: }
1666 8, 10, // 1020: case 0x8: {
1667 OPC_CheckPredicate, 21, // 1022: check predicate 21
1668 OPC_CheckField, 25, 1, 1, // 1024: check Inst[25] == 0x1
1669 OPC_Decode, 235, 126, 5, // 1028: decode to VL2RE32_V using decoder 5
1670 // 1028: }
1671 16, 0, // 1032: case 0x10: {
1672 OPC_CheckPredicate, 21, // 1034: check predicate 21
1673 OPC_Decode, 165, 127, 1, // 1036: decode to VLSEG2E32FF_V using decoder 1
1674 // 1036: }
1675 // 1036: } // switch Inst[24:20]
1676 // 1036: }
1677 9, 6, // 1040: case 0x9: {
1678 OPC_CheckPredicate, 21, // 1042: check predicate 21
1679 OPC_Decode, 252, 127, 3, // 1044: decode to VLUXSEG2EI32_V using decoder 3
1680 // 1044: }
1681 10, 6, // 1048: case 0xa: {
1682 OPC_CheckPredicate, 21, // 1050: check predicate 21
1683 OPC_Decode, 220, 127, 4, // 1052: decode to VLSSEG2E32_V using decoder 4
1684 // 1052: }
1685 11, 6, // 1056: case 0xb: {
1686 OPC_CheckPredicate, 21, // 1058: check predicate 21
1687 OPC_Decode, 132, 127, 3, // 1060: decode to VLOXSEG2EI32_V using decoder 3
1688 // 1060: }
1689 16, 19, // 1064: case 0x10: {
1690 OPC_SwitchField, 20, 5, // 1066: switch Inst[24:20] {
1691 0, 6, // 1069: case 0x0: {
1692 OPC_CheckPredicate, 21, // 1071: check predicate 21
1693 OPC_Decode, 174, 127, 1, // 1073: decode to VLSEG3E32_V using decoder 1
1694 // 1073: }
1695 16, 0, // 1077: case 0x10: {
1696 OPC_CheckPredicate, 21, // 1079: check predicate 21
1697 OPC_Decode, 173, 127, 1, // 1081: decode to VLSEG3E32FF_V using decoder 1
1698 // 1081: }
1699 // 1081: } // switch Inst[24:20]
1700 // 1081: }
1701 17, 7, // 1085: case 0x11: {
1702 OPC_CheckPredicate, 21, // 1087: check predicate 21
1703 OPC_Decode, 128, 128, 1, 3, // 1089: decode to VLUXSEG3EI32_V using decoder 3
1704 // 1089: }
1705 18, 6, // 1094: case 0x12: {
1706 OPC_CheckPredicate, 21, // 1096: check predicate 21
1707 OPC_Decode, 224, 127, 4, // 1098: decode to VLSSEG3E32_V using decoder 4
1708 // 1098: }
1709 19, 6, // 1102: case 0x13: {
1710 OPC_CheckPredicate, 21, // 1104: check predicate 21
1711 OPC_Decode, 136, 127, 3, // 1106: decode to VLOXSEG3EI32_V using decoder 3
1712 // 1106: }
1713 24, 31, // 1110: case 0x18: {
1714 OPC_SwitchField, 20, 5, // 1112: switch Inst[24:20] {
1715 0, 6, // 1115: case 0x0: {
1716 OPC_CheckPredicate, 21, // 1117: check predicate 21
1717 OPC_Decode, 182, 127, 1, // 1119: decode to VLSEG4E32_V using decoder 1
1718 // 1119: }
1719 8, 10, // 1123: case 0x8: {
1720 OPC_CheckPredicate, 21, // 1125: check predicate 21
1721 OPC_CheckField, 25, 1, 1, // 1127: check Inst[25] == 0x1
1722 OPC_Decode, 239, 126, 6, // 1131: decode to VL4RE32_V using decoder 6
1723 // 1131: }
1724 16, 0, // 1135: case 0x10: {
1725 OPC_CheckPredicate, 21, // 1137: check predicate 21
1726 OPC_Decode, 181, 127, 1, // 1139: decode to VLSEG4E32FF_V using decoder 1
1727 // 1139: }
1728 // 1139: } // switch Inst[24:20]
1729 // 1139: }
1730 25, 7, // 1143: case 0x19: {
1731 OPC_CheckPredicate, 21, // 1145: check predicate 21
1732 OPC_Decode, 132, 128, 1, 3, // 1147: decode to VLUXSEG4EI32_V using decoder 3
1733 // 1147: }
1734 26, 6, // 1152: case 0x1a: {
1735 OPC_CheckPredicate, 21, // 1154: check predicate 21
1736 OPC_Decode, 228, 127, 4, // 1156: decode to VLSSEG4E32_V using decoder 4
1737 // 1156: }
1738 27, 6, // 1160: case 0x1b: {
1739 OPC_CheckPredicate, 21, // 1162: check predicate 21
1740 OPC_Decode, 140, 127, 3, // 1164: decode to VLOXSEG4EI32_V using decoder 3
1741 // 1164: }
1742 32, 19, // 1168: case 0x20: {
1743 OPC_SwitchField, 20, 5, // 1170: switch Inst[24:20] {
1744 0, 6, // 1173: case 0x0: {
1745 OPC_CheckPredicate, 21, // 1175: check predicate 21
1746 OPC_Decode, 190, 127, 1, // 1177: decode to VLSEG5E32_V using decoder 1
1747 // 1177: }
1748 16, 0, // 1181: case 0x10: {
1749 OPC_CheckPredicate, 21, // 1183: check predicate 21
1750 OPC_Decode, 189, 127, 1, // 1185: decode to VLSEG5E32FF_V using decoder 1
1751 // 1185: }
1752 // 1185: } // switch Inst[24:20]
1753 // 1185: }
1754 33, 7, // 1189: case 0x21: {
1755 OPC_CheckPredicate, 21, // 1191: check predicate 21
1756 OPC_Decode, 136, 128, 1, 3, // 1193: decode to VLUXSEG5EI32_V using decoder 3
1757 // 1193: }
1758 34, 6, // 1198: case 0x22: {
1759 OPC_CheckPredicate, 21, // 1200: check predicate 21
1760 OPC_Decode, 232, 127, 4, // 1202: decode to VLSSEG5E32_V using decoder 4
1761 // 1202: }
1762 35, 6, // 1206: case 0x23: {
1763 OPC_CheckPredicate, 21, // 1208: check predicate 21
1764 OPC_Decode, 144, 127, 3, // 1210: decode to VLOXSEG5EI32_V using decoder 3
1765 // 1210: }
1766 40, 19, // 1214: case 0x28: {
1767 OPC_SwitchField, 20, 5, // 1216: switch Inst[24:20] {
1768 0, 6, // 1219: case 0x0: {
1769 OPC_CheckPredicate, 21, // 1221: check predicate 21
1770 OPC_Decode, 198, 127, 1, // 1223: decode to VLSEG6E32_V using decoder 1
1771 // 1223: }
1772 16, 0, // 1227: case 0x10: {
1773 OPC_CheckPredicate, 21, // 1229: check predicate 21
1774 OPC_Decode, 197, 127, 1, // 1231: decode to VLSEG6E32FF_V using decoder 1
1775 // 1231: }
1776 // 1231: } // switch Inst[24:20]
1777 // 1231: }
1778 41, 7, // 1235: case 0x29: {
1779 OPC_CheckPredicate, 21, // 1237: check predicate 21
1780 OPC_Decode, 140, 128, 1, 3, // 1239: decode to VLUXSEG6EI32_V using decoder 3
1781 // 1239: }
1782 42, 6, // 1244: case 0x2a: {
1783 OPC_CheckPredicate, 21, // 1246: check predicate 21
1784 OPC_Decode, 236, 127, 4, // 1248: decode to VLSSEG6E32_V using decoder 4
1785 // 1248: }
1786 43, 6, // 1252: case 0x2b: {
1787 OPC_CheckPredicate, 21, // 1254: check predicate 21
1788 OPC_Decode, 148, 127, 3, // 1256: decode to VLOXSEG6EI32_V using decoder 3
1789 // 1256: }
1790 48, 19, // 1260: case 0x30: {
1791 OPC_SwitchField, 20, 5, // 1262: switch Inst[24:20] {
1792 0, 6, // 1265: case 0x0: {
1793 OPC_CheckPredicate, 21, // 1267: check predicate 21
1794 OPC_Decode, 206, 127, 1, // 1269: decode to VLSEG7E32_V using decoder 1
1795 // 1269: }
1796 16, 0, // 1273: case 0x10: {
1797 OPC_CheckPredicate, 21, // 1275: check predicate 21
1798 OPC_Decode, 205, 127, 1, // 1277: decode to VLSEG7E32FF_V using decoder 1
1799 // 1277: }
1800 // 1277: } // switch Inst[24:20]
1801 // 1277: }
1802 49, 7, // 1281: case 0x31: {
1803 OPC_CheckPredicate, 21, // 1283: check predicate 21
1804 OPC_Decode, 144, 128, 1, 3, // 1285: decode to VLUXSEG7EI32_V using decoder 3
1805 // 1285: }
1806 50, 6, // 1290: case 0x32: {
1807 OPC_CheckPredicate, 21, // 1292: check predicate 21
1808 OPC_Decode, 240, 127, 4, // 1294: decode to VLSSEG7E32_V using decoder 4
1809 // 1294: }
1810 51, 6, // 1298: case 0x33: {
1811 OPC_CheckPredicate, 21, // 1300: check predicate 21
1812 OPC_Decode, 152, 127, 3, // 1302: decode to VLOXSEG7EI32_V using decoder 3
1813 // 1302: }
1814 56, 31, // 1306: case 0x38: {
1815 OPC_SwitchField, 20, 5, // 1308: switch Inst[24:20] {
1816 0, 6, // 1311: case 0x0: {
1817 OPC_CheckPredicate, 21, // 1313: check predicate 21
1818 OPC_Decode, 214, 127, 1, // 1315: decode to VLSEG8E32_V using decoder 1
1819 // 1315: }
1820 8, 10, // 1319: case 0x8: {
1821 OPC_CheckPredicate, 21, // 1321: check predicate 21
1822 OPC_CheckField, 25, 1, 1, // 1323: check Inst[25] == 0x1
1823 OPC_Decode, 243, 126, 7, // 1327: decode to VL8RE32_V using decoder 7
1824 // 1327: }
1825 16, 0, // 1331: case 0x10: {
1826 OPC_CheckPredicate, 21, // 1333: check predicate 21
1827 OPC_Decode, 213, 127, 1, // 1335: decode to VLSEG8E32FF_V using decoder 1
1828 // 1335: }
1829 // 1335: } // switch Inst[24:20]
1830 // 1335: }
1831 57, 7, // 1339: case 0x39: {
1832 OPC_CheckPredicate, 21, // 1341: check predicate 21
1833 OPC_Decode, 148, 128, 1, 3, // 1343: decode to VLUXSEG8EI32_V using decoder 3
1834 // 1343: }
1835 58, 6, // 1348: case 0x3a: {
1836 OPC_CheckPredicate, 21, // 1350: check predicate 21
1837 OPC_Decode, 244, 127, 4, // 1352: decode to VLSSEG8E32_V using decoder 4
1838 // 1352: }
1839 59, 0, // 1356: case 0x3b: {
1840 OPC_CheckPredicate, 21, // 1358: check predicate 21
1841 OPC_Decode, 156, 127, 3, // 1360: decode to VLOXSEG8EI32_V using decoder 3
1842 // 1360: }
1843 // 1360: } // switch Inst[31:26]
1844 // 1360: }
1845 7, 0, // 1364: case 0x7: {
1846 OPC_SwitchField, 26, 6, // 1366: switch Inst[31:26] {
1847 0, 31, // 1369: case 0x0: {
1848 OPC_SwitchField, 20, 5, // 1371: switch Inst[24:20] {
1849 0, 6, // 1374: case 0x0: {
1850 OPC_CheckPredicate, 26, // 1376: check predicate 26
1851 OPC_Decode, 251, 126, 1, // 1378: decode to VLE64_V using decoder 1
1852 // 1378: }
1853 8, 10, // 1382: case 0x8: {
1854 OPC_CheckPredicate, 26, // 1384: check predicate 26
1855 OPC_CheckField, 25, 1, 1, // 1386: check Inst[25] == 0x1
1856 OPC_Decode, 232, 126, 2, // 1390: decode to VL1RE64_V using decoder 2
1857 // 1390: }
1858 16, 0, // 1394: case 0x10: {
1859 OPC_CheckPredicate, 26, // 1396: check predicate 26
1860 OPC_Decode, 250, 126, 1, // 1398: decode to VLE64FF_V using decoder 1
1861 // 1398: }
1862 // 1398: } // switch Inst[24:20]
1863 // 1398: }
1864 1, 6, // 1402: case 0x1: {
1865 OPC_CheckPredicate, 27, // 1404: check predicate 27
1866 OPC_Decode, 249, 127, 3, // 1406: decode to VLUXEI64_V using decoder 3
1867 // 1406: }
1868 2, 6, // 1410: case 0x2: {
1869 OPC_CheckPredicate, 26, // 1412: check predicate 26
1870 OPC_Decode, 161, 127, 4, // 1414: decode to VLSE64_V using decoder 4
1871 // 1414: }
1872 3, 6, // 1418: case 0x3: {
1873 OPC_CheckPredicate, 27, // 1420: check predicate 27
1874 OPC_Decode, 129, 127, 3, // 1422: decode to VLOXEI64_V using decoder 3
1875 // 1422: }
1876 8, 31, // 1426: case 0x8: {
1877 OPC_SwitchField, 20, 5, // 1428: switch Inst[24:20] {
1878 0, 6, // 1431: case 0x0: {
1879 OPC_CheckPredicate, 26, // 1433: check predicate 26
1880 OPC_Decode, 168, 127, 1, // 1435: decode to VLSEG2E64_V using decoder 1
1881 // 1435: }
1882 8, 10, // 1439: case 0x8: {
1883 OPC_CheckPredicate, 26, // 1441: check predicate 26
1884 OPC_CheckField, 25, 1, 1, // 1443: check Inst[25] == 0x1
1885 OPC_Decode, 236, 126, 5, // 1447: decode to VL2RE64_V using decoder 5
1886 // 1447: }
1887 16, 0, // 1451: case 0x10: {
1888 OPC_CheckPredicate, 26, // 1453: check predicate 26
1889 OPC_Decode, 167, 127, 1, // 1455: decode to VLSEG2E64FF_V using decoder 1
1890 // 1455: }
1891 // 1455: } // switch Inst[24:20]
1892 // 1455: }
1893 9, 6, // 1459: case 0x9: {
1894 OPC_CheckPredicate, 28, // 1461: check predicate 28
1895 OPC_Decode, 253, 127, 3, // 1463: decode to VLUXSEG2EI64_V using decoder 3
1896 // 1463: }
1897 10, 6, // 1467: case 0xa: {
1898 OPC_CheckPredicate, 26, // 1469: check predicate 26
1899 OPC_Decode, 221, 127, 4, // 1471: decode to VLSSEG2E64_V using decoder 4
1900 // 1471: }
1901 11, 6, // 1475: case 0xb: {
1902 OPC_CheckPredicate, 28, // 1477: check predicate 28
1903 OPC_Decode, 133, 127, 3, // 1479: decode to VLOXSEG2EI64_V using decoder 3
1904 // 1479: }
1905 16, 19, // 1483: case 0x10: {
1906 OPC_SwitchField, 20, 5, // 1485: switch Inst[24:20] {
1907 0, 6, // 1488: case 0x0: {
1908 OPC_CheckPredicate, 26, // 1490: check predicate 26
1909 OPC_Decode, 176, 127, 1, // 1492: decode to VLSEG3E64_V using decoder 1
1910 // 1492: }
1911 16, 0, // 1496: case 0x10: {
1912 OPC_CheckPredicate, 26, // 1498: check predicate 26
1913 OPC_Decode, 175, 127, 1, // 1500: decode to VLSEG3E64FF_V using decoder 1
1914 // 1500: }
1915 // 1500: } // switch Inst[24:20]
1916 // 1500: }
1917 17, 7, // 1504: case 0x11: {
1918 OPC_CheckPredicate, 28, // 1506: check predicate 28
1919 OPC_Decode, 129, 128, 1, 3, // 1508: decode to VLUXSEG3EI64_V using decoder 3
1920 // 1508: }
1921 18, 6, // 1513: case 0x12: {
1922 OPC_CheckPredicate, 26, // 1515: check predicate 26
1923 OPC_Decode, 225, 127, 4, // 1517: decode to VLSSEG3E64_V using decoder 4
1924 // 1517: }
1925 19, 6, // 1521: case 0x13: {
1926 OPC_CheckPredicate, 28, // 1523: check predicate 28
1927 OPC_Decode, 137, 127, 3, // 1525: decode to VLOXSEG3EI64_V using decoder 3
1928 // 1525: }
1929 24, 31, // 1529: case 0x18: {
1930 OPC_SwitchField, 20, 5, // 1531: switch Inst[24:20] {
1931 0, 6, // 1534: case 0x0: {
1932 OPC_CheckPredicate, 26, // 1536: check predicate 26
1933 OPC_Decode, 184, 127, 1, // 1538: decode to VLSEG4E64_V using decoder 1
1934 // 1538: }
1935 8, 10, // 1542: case 0x8: {
1936 OPC_CheckPredicate, 26, // 1544: check predicate 26
1937 OPC_CheckField, 25, 1, 1, // 1546: check Inst[25] == 0x1
1938 OPC_Decode, 240, 126, 6, // 1550: decode to VL4RE64_V using decoder 6
1939 // 1550: }
1940 16, 0, // 1554: case 0x10: {
1941 OPC_CheckPredicate, 26, // 1556: check predicate 26
1942 OPC_Decode, 183, 127, 1, // 1558: decode to VLSEG4E64FF_V using decoder 1
1943 // 1558: }
1944 // 1558: } // switch Inst[24:20]
1945 // 1558: }
1946 25, 7, // 1562: case 0x19: {
1947 OPC_CheckPredicate, 28, // 1564: check predicate 28
1948 OPC_Decode, 133, 128, 1, 3, // 1566: decode to VLUXSEG4EI64_V using decoder 3
1949 // 1566: }
1950 26, 6, // 1571: case 0x1a: {
1951 OPC_CheckPredicate, 26, // 1573: check predicate 26
1952 OPC_Decode, 229, 127, 4, // 1575: decode to VLSSEG4E64_V using decoder 4
1953 // 1575: }
1954 27, 6, // 1579: case 0x1b: {
1955 OPC_CheckPredicate, 28, // 1581: check predicate 28
1956 OPC_Decode, 141, 127, 3, // 1583: decode to VLOXSEG4EI64_V using decoder 3
1957 // 1583: }
1958 32, 19, // 1587: case 0x20: {
1959 OPC_SwitchField, 20, 5, // 1589: switch Inst[24:20] {
1960 0, 6, // 1592: case 0x0: {
1961 OPC_CheckPredicate, 26, // 1594: check predicate 26
1962 OPC_Decode, 192, 127, 1, // 1596: decode to VLSEG5E64_V using decoder 1
1963 // 1596: }
1964 16, 0, // 1600: case 0x10: {
1965 OPC_CheckPredicate, 26, // 1602: check predicate 26
1966 OPC_Decode, 191, 127, 1, // 1604: decode to VLSEG5E64FF_V using decoder 1
1967 // 1604: }
1968 // 1604: } // switch Inst[24:20]
1969 // 1604: }
1970 33, 7, // 1608: case 0x21: {
1971 OPC_CheckPredicate, 28, // 1610: check predicate 28
1972 OPC_Decode, 137, 128, 1, 3, // 1612: decode to VLUXSEG5EI64_V using decoder 3
1973 // 1612: }
1974 34, 6, // 1617: case 0x22: {
1975 OPC_CheckPredicate, 26, // 1619: check predicate 26
1976 OPC_Decode, 233, 127, 4, // 1621: decode to VLSSEG5E64_V using decoder 4
1977 // 1621: }
1978 35, 6, // 1625: case 0x23: {
1979 OPC_CheckPredicate, 28, // 1627: check predicate 28
1980 OPC_Decode, 145, 127, 3, // 1629: decode to VLOXSEG5EI64_V using decoder 3
1981 // 1629: }
1982 40, 19, // 1633: case 0x28: {
1983 OPC_SwitchField, 20, 5, // 1635: switch Inst[24:20] {
1984 0, 6, // 1638: case 0x0: {
1985 OPC_CheckPredicate, 26, // 1640: check predicate 26
1986 OPC_Decode, 200, 127, 1, // 1642: decode to VLSEG6E64_V using decoder 1
1987 // 1642: }
1988 16, 0, // 1646: case 0x10: {
1989 OPC_CheckPredicate, 26, // 1648: check predicate 26
1990 OPC_Decode, 199, 127, 1, // 1650: decode to VLSEG6E64FF_V using decoder 1
1991 // 1650: }
1992 // 1650: } // switch Inst[24:20]
1993 // 1650: }
1994 41, 7, // 1654: case 0x29: {
1995 OPC_CheckPredicate, 28, // 1656: check predicate 28
1996 OPC_Decode, 141, 128, 1, 3, // 1658: decode to VLUXSEG6EI64_V using decoder 3
1997 // 1658: }
1998 42, 6, // 1663: case 0x2a: {
1999 OPC_CheckPredicate, 26, // 1665: check predicate 26
2000 OPC_Decode, 237, 127, 4, // 1667: decode to VLSSEG6E64_V using decoder 4
2001 // 1667: }
2002 43, 6, // 1671: case 0x2b: {
2003 OPC_CheckPredicate, 28, // 1673: check predicate 28
2004 OPC_Decode, 149, 127, 3, // 1675: decode to VLOXSEG6EI64_V using decoder 3
2005 // 1675: }
2006 48, 19, // 1679: case 0x30: {
2007 OPC_SwitchField, 20, 5, // 1681: switch Inst[24:20] {
2008 0, 6, // 1684: case 0x0: {
2009 OPC_CheckPredicate, 26, // 1686: check predicate 26
2010 OPC_Decode, 208, 127, 1, // 1688: decode to VLSEG7E64_V using decoder 1
2011 // 1688: }
2012 16, 0, // 1692: case 0x10: {
2013 OPC_CheckPredicate, 26, // 1694: check predicate 26
2014 OPC_Decode, 207, 127, 1, // 1696: decode to VLSEG7E64FF_V using decoder 1
2015 // 1696: }
2016 // 1696: } // switch Inst[24:20]
2017 // 1696: }
2018 49, 7, // 1700: case 0x31: {
2019 OPC_CheckPredicate, 28, // 1702: check predicate 28
2020 OPC_Decode, 145, 128, 1, 3, // 1704: decode to VLUXSEG7EI64_V using decoder 3
2021 // 1704: }
2022 50, 6, // 1709: case 0x32: {
2023 OPC_CheckPredicate, 26, // 1711: check predicate 26
2024 OPC_Decode, 241, 127, 4, // 1713: decode to VLSSEG7E64_V using decoder 4
2025 // 1713: }
2026 51, 6, // 1717: case 0x33: {
2027 OPC_CheckPredicate, 28, // 1719: check predicate 28
2028 OPC_Decode, 153, 127, 3, // 1721: decode to VLOXSEG7EI64_V using decoder 3
2029 // 1721: }
2030 56, 31, // 1725: case 0x38: {
2031 OPC_SwitchField, 20, 5, // 1727: switch Inst[24:20] {
2032 0, 6, // 1730: case 0x0: {
2033 OPC_CheckPredicate, 26, // 1732: check predicate 26
2034 OPC_Decode, 216, 127, 1, // 1734: decode to VLSEG8E64_V using decoder 1
2035 // 1734: }
2036 8, 10, // 1738: case 0x8: {
2037 OPC_CheckPredicate, 26, // 1740: check predicate 26
2038 OPC_CheckField, 25, 1, 1, // 1742: check Inst[25] == 0x1
2039 OPC_Decode, 244, 126, 7, // 1746: decode to VL8RE64_V using decoder 7
2040 // 1746: }
2041 16, 0, // 1750: case 0x10: {
2042 OPC_CheckPredicate, 26, // 1752: check predicate 26
2043 OPC_Decode, 215, 127, 1, // 1754: decode to VLSEG8E64FF_V using decoder 1
2044 // 1754: }
2045 // 1754: } // switch Inst[24:20]
2046 // 1754: }
2047 57, 7, // 1758: case 0x39: {
2048 OPC_CheckPredicate, 28, // 1760: check predicate 28
2049 OPC_Decode, 149, 128, 1, 3, // 1762: decode to VLUXSEG8EI64_V using decoder 3
2050 // 1762: }
2051 58, 6, // 1767: case 0x3a: {
2052 OPC_CheckPredicate, 26, // 1769: check predicate 26
2053 OPC_Decode, 245, 127, 4, // 1771: decode to VLSSEG8E64_V using decoder 4
2054 // 1771: }
2055 59, 0, // 1775: case 0x3b: {
2056 OPC_CheckPredicate, 28, // 1777: check predicate 28
2057 OPC_Decode, 157, 127, 3, // 1779: decode to VLOXSEG8EI64_V using decoder 3
2058 // 1779: }
2059 // 1779: } // switch Inst[31:26]
2060 // 1779: }
2061 // 1779: } // switch Inst[14:12]
2062 // 1779: }
2063 15, 76, // 1783: case 0xf: {
2064 OPC_SwitchField, 7, 8, // 1785: switch Inst[14:7] {
2065 0, 24, // 1788: case 0x0: {
2066 OPC_SwitchField, 28, 4, // 1790: switch Inst[31:28] {
2067 0, 8, // 1793: case 0x0: {
2068 OPC_CheckField, 15, 5, 0, // 1795: check Inst[19:15] == 0x0
2069 OPC_Decode, 211, 114, 12, // 1799: decode to FENCE using decoder 12
2070 // 1799: }
2071 8, 0, // 1803: case 0x8: {
2072 OPC_CheckField, 15, 13, 224, 12, // 1805: check Inst[27:15] == 0x660
2073 OPC_Decode, 213, 114, 13, // 1810: decode to FENCE_TSO using decoder 13
2074 // 1810: }
2075 // 1810: } // switch Inst[31:28]
2076 // 1810: }
2077 32, 8, // 1814: case 0x20: {
2078 OPC_CheckField, 15, 17, 0, // 1816: check Inst[31:15] == 0x0
2079 OPC_Decode, 212, 114, 13, // 1820: decode to FENCE_I using decoder 13
2080 // 1820: }
2081 64, 0, // 1824: case 0x40: {
2082 OPC_SwitchField, 20, 12, // 1826: switch Inst[31:20] {
2083 0, 6, // 1829: case 0x0: {
2084 OPC_CheckPredicate, 29, // 1831: check predicate 29
2085 OPC_Decode, 194, 110, 14, // 1833: decode to CBO_INVAL using decoder 14
2086 // 1833: }
2087 1, 6, // 1837: case 0x1: {
2088 OPC_CheckPredicate, 29, // 1839: check predicate 29
2089 OPC_Decode, 192, 110, 14, // 1841: decode to CBO_CLEAN using decoder 14
2090 // 1841: }
2091 2, 6, // 1845: case 0x2: {
2092 OPC_CheckPredicate, 29, // 1847: check predicate 29
2093 OPC_Decode, 193, 110, 14, // 1849: decode to CBO_FLUSH using decoder 14
2094 // 1849: }
2095 4, 0, // 1853: case 0x4: {
2096 OPC_CheckPredicate, 30, // 1855: check predicate 30
2097 OPC_Decode, 195, 110, 14, // 1857: decode to CBO_ZERO using decoder 14
2098 // 1857: }
2099 // 1857: } // switch Inst[31:20]
2100 // 1857: }
2101 // 1857: } // switch Inst[14:7]
2102 // 1857: }
2103 19, 155, 3, // 1861: case 0x13: {
2104 OPC_SwitchField, 12, 3, // 1864: switch Inst[14:12] {
2105 0, 4, // 1867: case 0x0: {
2106 OPC_Decode, 157, 107, 0, // 1869: decode to ADDI using decoder 0
2107 // 1869: }
2108 1, 217, 1, // 1873: case 0x1: {
2109 OPC_SwitchField, 26, 6, // 1876: switch Inst[31:26] {
2110 0, 4, // 1879: case 0x0: {
2111 OPC_Decode, 142, 124, 15, // 1881: decode to SLLI using decoder 15
2112 // 1881: }
2113 2, 11, // 1885: case 0x2: {
2114 OPC_CheckPredicate, 31, // 1887: check predicate 31
2115 OPC_CheckField, 20, 6, 15, // 1889: check Inst[25:20] == 0xf
2116 OPC_Decode, 160, 131, 1, 16, // 1893: decode to ZIP_RV32 using decoder 16
2117 // 1893: }
2118 4, 83, // 1898: case 0x4: {
2119 OPC_SwitchField, 20, 6, // 1900: switch Inst[25:20] {
2120 0, 6, // 1903: case 0x0: {
2121 OPC_CheckPredicate, 32, // 1905: check predicate 32
2122 OPC_Decode, 250, 123, 16, // 1907: decode to SHA256SUM0 using decoder 16
2123 // 1907: }
2124 1, 6, // 1911: case 0x1: {
2125 OPC_CheckPredicate, 32, // 1913: check predicate 32
2126 OPC_Decode, 251, 123, 16, // 1915: decode to SHA256SUM1 using decoder 16
2127 // 1915: }
2128 2, 6, // 1919: case 0x2: {
2129 OPC_CheckPredicate, 32, // 1921: check predicate 32
2130 OPC_Decode, 248, 123, 16, // 1923: decode to SHA256SIG0 using decoder 16
2131 // 1923: }
2132 3, 6, // 1927: case 0x3: {
2133 OPC_CheckPredicate, 32, // 1929: check predicate 32
2134 OPC_Decode, 249, 123, 16, // 1931: decode to SHA256SIG1 using decoder 16
2135 // 1931: }
2136 4, 6, // 1935: case 0x4: {
2137 OPC_CheckPredicate, 33, // 1937: check predicate 33
2138 OPC_Decode, 130, 124, 16, // 1939: decode to SHA512SUM0 using decoder 16
2139 // 1939: }
2140 5, 6, // 1943: case 0x5: {
2141 OPC_CheckPredicate, 33, // 1945: check predicate 33
2142 OPC_Decode, 132, 124, 16, // 1947: decode to SHA512SUM1 using decoder 16
2143 // 1947: }
2144 6, 6, // 1951: case 0x6: {
2145 OPC_CheckPredicate, 33, // 1953: check predicate 33
2146 OPC_Decode, 252, 123, 16, // 1955: decode to SHA512SIG0 using decoder 16
2147 // 1955: }
2148 7, 6, // 1959: case 0x7: {
2149 OPC_CheckPredicate, 33, // 1961: check predicate 33
2150 OPC_Decode, 255, 123, 16, // 1963: decode to SHA512SIG1 using decoder 16
2151 // 1963: }
2152 8, 6, // 1967: case 0x8: {
2153 OPC_CheckPredicate, 34, // 1969: check predicate 34
2154 OPC_Decode, 151, 124, 16, // 1971: decode to SM3P0 using decoder 16
2155 // 1971: }
2156 9, 0, // 1975: case 0x9: {
2157 OPC_CheckPredicate, 34, // 1977: check predicate 34
2158 OPC_Decode, 152, 124, 16, // 1979: decode to SM3P1 using decoder 16
2159 // 1979: }
2160 // 1979: } // switch Inst[25:20]
2161 // 1979: }
2162 10, 6, // 1983: case 0xa: {
2163 OPC_CheckPredicate, 35, // 1985: check predicate 35
2164 OPC_Decode, 191, 110, 15, // 1987: decode to BSETI using decoder 15
2165 // 1987: }
2166 12, 23, // 1991: case 0xc: {
2167 OPC_SwitchField, 24, 2, // 1993: switch Inst[25:24] {
2168 0, 10, // 1996: case 0x0: {
2169 OPC_CheckPredicate, 36, // 1998: check predicate 36
2170 OPC_CheckField, 20, 4, 0, // 2000: check Inst[23:20] == 0x0
2171 OPC_Decode, 169, 107, 16, // 2004: decode to AES64IM using decoder 16
2172 // 2004: }
2173 1, 0, // 2008: case 0x1: {
2174 OPC_CheckPredicate, 37, // 2010: check predicate 37
2175 OPC_Decode, 170, 107, 17, // 2012: decode to AES64KS1I using decoder 17
2176 // 2012: }
2177 // 2012: } // switch Inst[25:24]
2178 // 2012: }
2179 18, 6, // 2016: case 0x12: {
2180 OPC_CheckPredicate, 35, // 2018: check predicate 35
2181 OPC_Decode, 176, 110, 15, // 2020: decode to BCLRI using decoder 15
2182 // 2020: }
2183 24, 59, // 2024: case 0x18: {
2184 OPC_SwitchField, 20, 6, // 2026: switch Inst[25:20] {
2185 0, 6, // 2029: case 0x0: {
2186 OPC_CheckPredicate, 38, // 2031: check predicate 38
2187 OPC_Decode, 201, 110, 16, // 2033: decode to CLZ using decoder 16
2188 // 2033: }
2189 1, 6, // 2037: case 0x1: {
2190 OPC_CheckPredicate, 38, // 2039: check predicate 38
2191 OPC_Decode, 219, 110, 16, // 2041: decode to CTZ using decoder 16
2192 // 2041: }
2193 2, 6, // 2045: case 0x2: {
2194 OPC_CheckPredicate, 38, // 2047: check predicate 38
2195 OPC_Decode, 211, 110, 16, // 2049: decode to CPOP using decoder 16
2196 // 2049: }
2197 3, 6, // 2053: case 0x3: {
2198 OPC_CheckPredicate, 39, // 2055: check predicate 39
2199 OPC_Decode, 199, 110, 16, // 2057: decode to CLS using decoder 16
2200 // 2057: }
2201 4, 6, // 2061: case 0x4: {
2202 OPC_CheckPredicate, 38, // 2063: check predicate 38
2203 OPC_Decode, 167, 123, 16, // 2065: decode to SEXT_B using decoder 16
2204 // 2065: }
2205 5, 6, // 2069: case 0x5: {
2206 OPC_CheckPredicate, 38, // 2071: check predicate 38
2207 OPC_Decode, 168, 123, 16, // 2073: decode to SEXT_H using decoder 16
2208 // 2073: }
2209 7, 0, // 2077: case 0x7: {
2210 OPC_CheckPredicate, 39, // 2079: check predicate 39
2211 OPC_Decode, 153, 107, 16, // 2081: decode to ABS using decoder 16
2212 // 2081: }
2213 // 2081: } // switch Inst[25:20]
2214 // 2081: }
2215 26, 0, // 2085: case 0x1a: {
2216 OPC_CheckPredicate, 35, // 2087: check predicate 35
2217 OPC_Decode, 184, 110, 15, // 2089: decode to BINVI using decoder 15
2218 // 2089: }
2219 // 2089: } // switch Inst[31:26]
2220 // 2089: }
2221 2, 4, // 2093: case 0x2: {
2222 OPC_Decode, 147, 124, 0, // 2095: decode to SLTI using decoder 0
2223 // 2095: }
2224 3, 4, // 2099: case 0x3: {
2225 OPC_Decode, 148, 124, 0, // 2101: decode to SLTIU using decoder 0
2226 // 2101: }
2227 4, 5, // 2105: case 0x4: {
2228 OPC_Decode, 151, 131, 1, 0, // 2107: decode to XORI using decoder 0
2229 // 2107: }
2230 5, 108, // 2112: case 0x5: {
2231 OPC_SwitchField, 26, 6, // 2114: switch Inst[31:26] {
2232 0, 4, // 2117: case 0x0: {
2233 OPC_Decode, 179, 124, 15, // 2119: decode to SRLI using decoder 15
2234 // 2119: }
2235 2, 10, // 2123: case 0x2: {
2236 OPC_CheckPredicate, 31, // 2125: check predicate 31
2237 OPC_CheckField, 20, 6, 15, // 2127: check Inst[25:20] == 0xf
2238 OPC_Decode, 195, 125, 16, // 2131: decode to UNZIP_RV32 using decoder 16
2239 // 2131: }
2240 10, 10, // 2135: case 0xa: {
2241 OPC_CheckPredicate, 38, // 2137: check predicate 38
2242 OPC_CheckField, 20, 6, 7, // 2139: check Inst[25:20] == 0x7
2243 OPC_Decode, 135, 118, 16, // 2143: decode to ORC_B using decoder 16
2244 // 2143: }
2245 16, 4, // 2147: case 0x10: {
2246 OPC_Decode, 172, 124, 15, // 2149: decode to SRAI using decoder 15
2247 // 2149: }
2248 18, 6, // 2153: case 0x12: {
2249 OPC_CheckPredicate, 35, // 2155: check predicate 35
2250 OPC_Decode, 180, 110, 15, // 2157: decode to BEXTI using decoder 15
2251 // 2157: }
2252 24, 6, // 2161: case 0x18: {
2253 OPC_CheckPredicate, 40, // 2163: check predicate 40
2254 OPC_Decode, 144, 123, 15, // 2165: decode to RORI using decoder 15
2255 // 2165: }
2256 26, 0, // 2169: case 0x1a: {
2257 OPC_SwitchField, 20, 6, // 2171: switch Inst[25:20] {
2258 7, 6, // 2174: case 0x7: {
2259 OPC_CheckPredicate, 41, // 2176: check predicate 41
2260 OPC_Decode, 189, 110, 16, // 2178: decode to BREV8 using decoder 16
2261 // 2178: }
2262 24, 6, // 2182: case 0x18: {
2263 OPC_CheckPredicate, 42, // 2184: check predicate 42
2264 OPC_Decode, 131, 123, 16, // 2186: decode to REV8_RV32 using decoder 16
2265 // 2186: }
2266 31, 6, // 2190: case 0x1f: {
2267 OPC_CheckPredicate, 43, // 2192: check predicate 43
2268 OPC_Decode, 133, 123, 16, // 2194: decode to REV_RV32 using decoder 16
2269 // 2194: }
2270 48, 6, // 2198: case 0x30: {
2271 OPC_CheckPredicate, 44, // 2200: check predicate 44
2272 OPC_Decode, 130, 123, 16, // 2202: decode to REV16 using decoder 16
2273 // 2202: }
2274 56, 6, // 2206: case 0x38: {
2275 OPC_CheckPredicate, 45, // 2208: check predicate 45
2276 OPC_Decode, 132, 123, 16, // 2210: decode to REV8_RV64 using decoder 16
2277 // 2210: }
2278 63, 0, // 2214: case 0x3f: {
2279 OPC_CheckPredicate, 44, // 2216: check predicate 44
2280 OPC_Decode, 134, 123, 16, // 2218: decode to REV_RV64 using decoder 16
2281 // 2218: }
2282 // 2218: } // switch Inst[25:20]
2283 // 2218: }
2284 // 2218: } // switch Inst[31:26]
2285 // 2218: }
2286 6, 45, // 2222: case 0x6: {
2287 OPC_Scope, 39, // 2224: try {
2288 OPC_SwitchField, 20, 5, // 2226: switch Inst[24:20] {
2289 0, 10, // 2229: case 0x0: {
2290 OPC_CheckPredicate, 46, // 2231: check predicate 46
2291 OPC_CheckField, 7, 5, 0, // 2233: check Inst[11:7] == 0x0
2292 OPC_Decode, 187, 120, 18, // 2237: decode to PREFETCH_I using decoder 18
2293 // 2237: }
2294 1, 10, // 2241: case 0x1: {
2295 OPC_CheckPredicate, 46, // 2243: check predicate 46
2296 OPC_CheckField, 7, 5, 0, // 2245: check Inst[11:7] == 0x0
2297 OPC_Decode, 188, 120, 18, // 2249: decode to PREFETCH_R using decoder 18
2298 // 2249: }
2299 3, 0, // 2253: case 0x3: {
2300 OPC_CheckPredicate, 46, // 2255: check predicate 46
2301 OPC_CheckField, 7, 5, 0, // 2257: check Inst[11:7] == 0x0
2302 OPC_Decode, 189, 120, 18, // 2261: decode to PREFETCH_W using decoder 18
2303 // 2261: }
2304 // 2261: } // switch Inst[24:20]
2305 // 2261: } else try {
2306 OPC_Decode, 136, 118, 0, // 2265: decode to ORI using decoder 0
2307 // 2265: }
2308 // 2265: }
2309 7, 0, // 2269: case 0x7: {
2310 OPC_Decode, 170, 110, 0, // 2271: decode to ANDI using decoder 0
2311 // 2271: }
2312 // 2271: } // switch Inst[14:12]
2313 // 2271: }
2314 23, 4, // 2275: case 0x17: {
2315 OPC_Decode, 174, 110, 19, // 2277: decode to AUIPC using decoder 19
2316 // 2277: }
2317 27, 145, 37, // 2281: case 0x1b: {
2318 OPC_SwitchField, 12, 3, // 2284: switch Inst[14:12] {
2319 0, 6, // 2287: case 0x0: {
2320 OPC_CheckPredicate, 20, // 2289: check predicate 20
2321 OPC_Decode, 158, 107, 0, // 2291: decode to ADDIW using decoder 0
2322 // 2291: }
2323 1, 68, // 2295: case 0x1: {
2324 OPC_SwitchField, 26, 6, // 2297: switch Inst[31:26] {
2325 0, 10, // 2300: case 0x0: {
2326 OPC_CheckPredicate, 20, // 2302: check predicate 20
2327 OPC_CheckField, 25, 1, 0, // 2304: check Inst[25] == 0x0
2328 OPC_Decode, 143, 124, 20, // 2308: decode to SLLIW using decoder 20
2329 // 2308: }
2330 2, 6, // 2312: case 0x2: {
2331 OPC_CheckPredicate, 47, // 2314: check predicate 47
2332 OPC_Decode, 144, 124, 15, // 2316: decode to SLLI_UW using decoder 15
2333 // 2316: }
2334 24, 0, // 2320: case 0x18: {
2335 OPC_SwitchField, 20, 6, // 2322: switch Inst[25:20] {
2336 0, 6, // 2325: case 0x0: {
2337 OPC_CheckPredicate, 48, // 2327: check predicate 48
2338 OPC_Decode, 202, 110, 16, // 2329: decode to CLZW using decoder 16
2339 // 2329: }
2340 1, 6, // 2333: case 0x1: {
2341 OPC_CheckPredicate, 48, // 2335: check predicate 48
2342 OPC_Decode, 220, 110, 16, // 2337: decode to CTZW using decoder 16
2343 // 2337: }
2344 2, 6, // 2341: case 0x2: {
2345 OPC_CheckPredicate, 48, // 2343: check predicate 48
2346 OPC_Decode, 212, 110, 16, // 2345: decode to CPOPW using decoder 16
2347 // 2345: }
2348 3, 6, // 2349: case 0x3: {
2349 OPC_CheckPredicate, 44, // 2351: check predicate 44
2350 OPC_Decode, 200, 110, 16, // 2353: decode to CLSW using decoder 16
2351 // 2353: }
2352 7, 0, // 2357: case 0x7: {
2353 OPC_CheckPredicate, 44, // 2359: check predicate 44
2354 OPC_Decode, 154, 107, 16, // 2361: decode to ABSW using decoder 16
2355 // 2361: }
2356 // 2361: } // switch Inst[25:20]
2357 // 2361: }
2358 // 2361: } // switch Inst[31:26]
2359 // 2361: }
2360 2, 209, 10, // 2365: case 0x2: {
2361 OPC_SwitchField, 26, 6, // 2368: switch Inst[31:26] {
2362 0, 50, // 2371: case 0x0: {
2363 OPC_SwitchField, 7, 1, // 2373: switch Inst[7] {
2364 0, 23, // 2376: case 0x0: {
2365 OPC_SwitchField, 25, 1, // 2378: switch Inst[25] {
2366 0, 10, // 2381: case 0x0: {
2367 OPC_CheckPredicate, 43, // 2383: check predicate 43
2368 OPC_CheckField, 24, 1, 1, // 2385: check Inst[24] == 0x1
2369 OPC_Decode, 208, 121, 21, // 2389: decode to PWSLLI_B using decoder 21
2370 // 2389: }
2371 1, 0, // 2393: case 0x1: {
2372 OPC_CheckPredicate, 43, // 2395: check predicate 43
2373 OPC_Decode, 209, 121, 22, // 2397: decode to PWSLLI_H using decoder 22
2374 // 2397: }
2375 // 2397: } // switch Inst[25]
2376 // 2397: }
2377 1, 0, // 2401: case 0x1: {
2378 OPC_SwitchField, 25, 1, // 2403: switch Inst[25] {
2379 0, 6, // 2406: case 0x0: {
2380 OPC_CheckPredicate, 43, // 2408: check predicate 43
2381 OPC_Decode, 194, 121, 23, // 2410: decode to PWADD_H using decoder 23
2382 // 2410: }
2383 1, 0, // 2414: case 0x1: {
2384 OPC_CheckPredicate, 43, // 2416: check predicate 43
2385 OPC_Decode, 254, 130, 1, 23, // 2418: decode to WADD using decoder 23
2386 // 2418: }
2387 // 2418: } // switch Inst[25]
2388 // 2418: }
2389 // 2418: } // switch Inst[7]
2390 // 2418: }
2391 1, 33, // 2423: case 0x1: {
2392 OPC_SwitchField, 7, 1, // 2425: switch Inst[7] {
2393 0, 7, // 2428: case 0x0: {
2394 OPC_CheckPredicate, 43, // 2430: check predicate 43
2395 OPC_Decode, 142, 131, 1, 24, // 2432: decode to WSLLI using decoder 24
2396 // 2432: }
2397 1, 0, // 2437: case 0x1: {
2398 OPC_SwitchField, 25, 1, // 2439: switch Inst[25] {
2399 0, 6, // 2442: case 0x0: {
2400 OPC_CheckPredicate, 43, // 2444: check predicate 43
2401 OPC_Decode, 193, 121, 23, // 2446: decode to PWADD_B using decoder 23
2402 // 2446: }
2403 1, 0, // 2450: case 0x1: {
2404 OPC_CheckPredicate, 43, // 2452: check predicate 43
2405 OPC_Decode, 236, 118, 23, // 2454: decode to PM2WADD_H using decoder 23
2406 // 2454: }
2407 // 2454: } // switch Inst[25]
2408 // 2454: }
2409 // 2454: } // switch Inst[7]
2410 // 2454: }
2411 2, 46, // 2458: case 0x2: {
2412 OPC_SwitchField, 7, 1, // 2460: switch Inst[7] {
2413 0, 19, // 2463: case 0x0: {
2414 OPC_SwitchField, 25, 1, // 2465: switch Inst[25] {
2415 0, 6, // 2468: case 0x0: {
2416 OPC_CheckPredicate, 43, // 2470: check predicate 43
2417 OPC_Decode, 210, 121, 23, // 2472: decode to PWSLL_BS using decoder 23
2418 // 2472: }
2419 1, 0, // 2476: case 0x1: {
2420 OPC_CheckPredicate, 43, // 2478: check predicate 43
2421 OPC_Decode, 211, 121, 23, // 2480: decode to PWSLL_HS using decoder 23
2422 // 2480: }
2423 // 2480: } // switch Inst[25]
2424 // 2480: }
2425 1, 0, // 2484: case 0x1: {
2426 OPC_SwitchField, 25, 1, // 2486: switch Inst[25] {
2427 0, 6, // 2489: case 0x0: {
2428 OPC_CheckPredicate, 43, // 2491: check predicate 43
2429 OPC_Decode, 190, 121, 25, // 2493: decode to PWADDA_H using decoder 25
2430 // 2493: }
2431 1, 0, // 2497: case 0x1: {
2432 OPC_CheckPredicate, 43, // 2499: check predicate 43
2433 OPC_Decode, 255, 130, 1, 25, // 2501: decode to WADDA using decoder 25
2434 // 2501: }
2435 // 2501: } // switch Inst[25]
2436 // 2501: }
2437 // 2501: } // switch Inst[7]
2438 // 2501: }
2439 3, 37, // 2506: case 0x3: {
2440 OPC_SwitchField, 7, 1, // 2508: switch Inst[7] {
2441 0, 11, // 2511: case 0x0: {
2442 OPC_CheckPredicate, 43, // 2513: check predicate 43
2443 OPC_CheckField, 25, 1, 1, // 2515: check Inst[25] == 0x1
2444 OPC_Decode, 141, 131, 1, 23, // 2519: decode to WSLL using decoder 23
2445 // 2519: }
2446 1, 0, // 2524: case 0x1: {
2447 OPC_SwitchField, 25, 1, // 2526: switch Inst[25] {
2448 0, 6, // 2529: case 0x0: {
2449 OPC_CheckPredicate, 43, // 2531: check predicate 43
2450 OPC_Decode, 189, 121, 25, // 2533: decode to PWADDA_B using decoder 25
2451 // 2533: }
2452 1, 0, // 2537: case 0x1: {
2453 OPC_CheckPredicate, 43, // 2539: check predicate 43
2454 OPC_Decode, 232, 118, 25, // 2541: decode to PM2WADDA_H using decoder 25
2455 // 2541: }
2456 // 2541: } // switch Inst[25]
2457 // 2541: }
2458 // 2541: } // switch Inst[7]
2459 // 2541: }
2460 4, 28, // 2545: case 0x4: {
2461 OPC_SwitchField, 25, 1, // 2547: switch Inst[25] {
2462 0, 10, // 2550: case 0x0: {
2463 OPC_CheckPredicate, 43, // 2552: check predicate 43
2464 OPC_CheckField, 7, 1, 1, // 2554: check Inst[7] == 0x1
2465 OPC_Decode, 192, 121, 23, // 2558: decode to PWADDU_H using decoder 23
2466 // 2558: }
2467 1, 0, // 2562: case 0x1: {
2468 OPC_CheckPredicate, 43, // 2564: check predicate 43
2469 OPC_CheckField, 7, 1, 1, // 2566: check Inst[7] == 0x1
2470 OPC_Decode, 129, 131, 1, 23, // 2570: decode to WADDU using decoder 23
2471 // 2570: }
2472 // 2570: } // switch Inst[25]
2473 // 2570: }
2474 5, 27, // 2575: case 0x5: {
2475 OPC_SwitchField, 25, 1, // 2577: switch Inst[25] {
2476 0, 10, // 2580: case 0x0: {
2477 OPC_CheckPredicate, 43, // 2582: check predicate 43
2478 OPC_CheckField, 7, 1, 1, // 2584: check Inst[7] == 0x1
2479 OPC_Decode, 191, 121, 23, // 2588: decode to PWADDU_B using decoder 23
2480 // 2588: }
2481 1, 0, // 2592: case 0x1: {
2482 OPC_CheckPredicate, 43, // 2594: check predicate 43
2483 OPC_CheckField, 7, 1, 1, // 2596: check Inst[7] == 0x1
2484 OPC_Decode, 237, 118, 23, // 2600: decode to PM2WADD_HX using decoder 23
2485 // 2600: }
2486 // 2600: } // switch Inst[25]
2487 // 2600: }
2488 6, 28, // 2604: case 0x6: {
2489 OPC_SwitchField, 25, 1, // 2606: switch Inst[25] {
2490 0, 10, // 2609: case 0x0: {
2491 OPC_CheckPredicate, 43, // 2611: check predicate 43
2492 OPC_CheckField, 7, 1, 1, // 2613: check Inst[7] == 0x1
2493 OPC_Decode, 188, 121, 25, // 2617: decode to PWADDAU_H using decoder 25
2494 // 2617: }
2495 1, 0, // 2621: case 0x1: {
2496 OPC_CheckPredicate, 43, // 2623: check predicate 43
2497 OPC_CheckField, 7, 1, 1, // 2625: check Inst[7] == 0x1
2498 OPC_Decode, 128, 131, 1, 25, // 2629: decode to WADDAU using decoder 25
2499 // 2629: }
2500 // 2629: } // switch Inst[25]
2501 // 2629: }
2502 7, 27, // 2634: case 0x7: {
2503 OPC_SwitchField, 25, 1, // 2636: switch Inst[25] {
2504 0, 10, // 2639: case 0x0: {
2505 OPC_CheckPredicate, 43, // 2641: check predicate 43
2506 OPC_CheckField, 7, 1, 1, // 2643: check Inst[7] == 0x1
2507 OPC_Decode, 187, 121, 25, // 2647: decode to PWADDAU_B using decoder 25
2508 // 2647: }
2509 1, 0, // 2651: case 0x1: {
2510 OPC_CheckPredicate, 43, // 2653: check predicate 43
2511 OPC_CheckField, 7, 1, 1, // 2655: check Inst[7] == 0x1
2512 OPC_Decode, 233, 118, 25, // 2659: decode to PM2WADDA_HX using decoder 25
2513 // 2659: }
2514 // 2659: } // switch Inst[25]
2515 // 2659: }
2516 8, 28, // 2663: case 0x8: {
2517 OPC_SwitchField, 25, 1, // 2665: switch Inst[25] {
2518 0, 10, // 2668: case 0x0: {
2519 OPC_CheckPredicate, 43, // 2670: check predicate 43
2520 OPC_CheckField, 7, 1, 1, // 2672: check Inst[7] == 0x1
2521 OPC_Decode, 203, 121, 23, // 2676: decode to PWMUL_H using decoder 23
2522 // 2676: }
2523 1, 0, // 2680: case 0x1: {
2524 OPC_CheckPredicate, 43, // 2682: check predicate 43
2525 OPC_CheckField, 7, 1, 1, // 2684: check Inst[7] == 0x1
2526 OPC_Decode, 134, 131, 1, 23, // 2688: decode to WMUL using decoder 23
2527 // 2688: }
2528 // 2688: } // switch Inst[25]
2529 // 2688: }
2530 9, 27, // 2693: case 0x9: {
2531 OPC_SwitchField, 25, 1, // 2695: switch Inst[25] {
2532 0, 10, // 2698: case 0x0: {
2533 OPC_CheckPredicate, 43, // 2700: check predicate 43
2534 OPC_CheckField, 7, 1, 1, // 2702: check Inst[7] == 0x1
2535 OPC_Decode, 202, 121, 23, // 2706: decode to PWMUL_B using decoder 23
2536 // 2706: }
2537 1, 0, // 2710: case 0x1: {
2538 OPC_CheckPredicate, 43, // 2712: check predicate 43
2539 OPC_CheckField, 7, 1, 1, // 2714: check Inst[7] == 0x1
2540 OPC_Decode, 235, 118, 23, // 2718: decode to PM2WADDU_H using decoder 23
2541 // 2718: }
2542 // 2718: } // switch Inst[25]
2543 // 2718: }
2544 10, 28, // 2722: case 0xa: {
2545 OPC_SwitchField, 25, 1, // 2724: switch Inst[25] {
2546 0, 10, // 2727: case 0x0: {
2547 OPC_CheckPredicate, 43, // 2729: check predicate 43
2548 OPC_CheckField, 7, 1, 1, // 2731: check Inst[7] == 0x1
2549 OPC_Decode, 197, 121, 25, // 2735: decode to PWMACC_H using decoder 25
2550 // 2735: }
2551 1, 0, // 2739: case 0x1: {
2552 OPC_CheckPredicate, 43, // 2741: check predicate 43
2553 OPC_CheckField, 7, 1, 1, // 2743: check Inst[7] == 0x1
2554 OPC_Decode, 131, 131, 1, 25, // 2747: decode to WMACC using decoder 25
2555 // 2747: }
2556 // 2747: } // switch Inst[25]
2557 // 2747: }
2558 11, 14, // 2752: case 0xb: {
2559 OPC_CheckPredicate, 43, // 2754: check predicate 43
2560 OPC_CheckField, 25, 1, 1, // 2756: check Inst[25] == 0x1
2561 OPC_CheckField, 7, 1, 1, // 2760: check Inst[7] == 0x1
2562 OPC_Decode, 231, 118, 25, // 2764: decode to PM2WADDAU_H using decoder 25
2563 // 2764: }
2564 12, 37, // 2768: case 0xc: {
2565 OPC_SwitchField, 7, 1, // 2770: switch Inst[7] {
2566 0, 10, // 2773: case 0x0: {
2567 OPC_CheckPredicate, 43, // 2775: check predicate 43
2568 OPC_CheckField, 25, 1, 0, // 2777: check Inst[25] == 0x0
2569 OPC_Decode, 198, 118, 26, // 2781: decode to PLI_DH using decoder 26
2570 // 2781: }
2571 1, 0, // 2785: case 0x1: {
2572 OPC_SwitchField, 25, 1, // 2787: switch Inst[25] {
2573 0, 6, // 2790: case 0x0: {
2574 OPC_CheckPredicate, 43, // 2792: check predicate 43
2575 OPC_Decode, 201, 121, 23, // 2794: decode to PWMULU_H using decoder 23
2576 // 2794: }
2577 1, 0, // 2798: case 0x1: {
2578 OPC_CheckPredicate, 43, // 2800: check predicate 43
2579 OPC_Decode, 136, 131, 1, 23, // 2802: decode to WMULU using decoder 23
2580 // 2802: }
2581 // 2802: } // switch Inst[25]
2582 // 2802: }
2583 // 2802: } // switch Inst[7]
2584 // 2802: }
2585 13, 31, // 2807: case 0xd: {
2586 OPC_SwitchField, 7, 1, // 2809: switch Inst[7] {
2587 0, 14, // 2812: case 0x0: {
2588 OPC_CheckPredicate, 43, // 2814: check predicate 43
2589 OPC_CheckField, 24, 2, 0, // 2816: check Inst[25:24] == 0x0
2590 OPC_CheckField, 15, 1, 0, // 2820: check Inst[15] == 0x0
2591 OPC_Decode, 197, 118, 27, // 2824: decode to PLI_DB using decoder 27
2592 // 2824: }
2593 1, 0, // 2828: case 0x1: {
2594 OPC_CheckPredicate, 43, // 2830: check predicate 43
2595 OPC_CheckField, 25, 1, 0, // 2832: check Inst[25] == 0x0
2596 OPC_Decode, 200, 121, 23, // 2836: decode to PWMULU_B using decoder 23
2597 // 2836: }
2598 // 2836: } // switch Inst[7]
2599 // 2836: }
2600 14, 28, // 2840: case 0xe: {
2601 OPC_SwitchField, 25, 1, // 2842: switch Inst[25] {
2602 0, 10, // 2845: case 0x0: {
2603 OPC_CheckPredicate, 43, // 2847: check predicate 43
2604 OPC_CheckField, 7, 1, 1, // 2849: check Inst[7] == 0x1
2605 OPC_Decode, 196, 121, 25, // 2853: decode to PWMACCU_H using decoder 25
2606 // 2853: }
2607 1, 0, // 2857: case 0x1: {
2608 OPC_CheckPredicate, 43, // 2859: check predicate 43
2609 OPC_CheckField, 7, 1, 1, // 2861: check Inst[7] == 0x1
2610 OPC_Decode, 133, 131, 1, 25, // 2865: decode to WMACCU using decoder 25
2611 // 2865: }
2612 // 2865: } // switch Inst[25]
2613 // 2865: }
2614 16, 50, // 2870: case 0x10: {
2615 OPC_SwitchField, 7, 1, // 2872: switch Inst[7] {
2616 0, 23, // 2875: case 0x0: {
2617 OPC_SwitchField, 25, 1, // 2877: switch Inst[25] {
2618 0, 10, // 2880: case 0x0: {
2619 OPC_CheckPredicate, 43, // 2882: check predicate 43
2620 OPC_CheckField, 24, 1, 1, // 2884: check Inst[24] == 0x1
2621 OPC_Decode, 204, 121, 21, // 2888: decode to PWSLAI_B using decoder 21
2622 // 2888: }
2623 1, 0, // 2892: case 0x1: {
2624 OPC_CheckPredicate, 43, // 2894: check predicate 43
2625 OPC_Decode, 205, 121, 22, // 2896: decode to PWSLAI_H using decoder 22
2626 // 2896: }
2627 // 2896: } // switch Inst[25]
2628 // 2896: }
2629 1, 0, // 2900: case 0x1: {
2630 OPC_SwitchField, 25, 1, // 2902: switch Inst[25] {
2631 0, 6, // 2905: case 0x0: {
2632 OPC_CheckPredicate, 43, // 2907: check predicate 43
2633 OPC_Decode, 219, 121, 23, // 2909: decode to PWSUB_H using decoder 23
2634 // 2909: }
2635 1, 0, // 2913: case 0x1: {
2636 OPC_CheckPredicate, 43, // 2915: check predicate 43
2637 OPC_Decode, 143, 131, 1, 23, // 2917: decode to WSUB using decoder 23
2638 // 2917: }
2639 // 2917: } // switch Inst[25]
2640 // 2917: }
2641 // 2917: } // switch Inst[7]
2642 // 2917: }
2643 17, 33, // 2922: case 0x11: {
2644 OPC_SwitchField, 7, 1, // 2924: switch Inst[7] {
2645 0, 7, // 2927: case 0x0: {
2646 OPC_CheckPredicate, 43, // 2929: check predicate 43
2647 OPC_Decode, 140, 131, 1, 24, // 2931: decode to WSLAI using decoder 24
2648 // 2931: }
2649 1, 0, // 2936: case 0x1: {
2650 OPC_SwitchField, 25, 1, // 2938: switch Inst[25] {
2651 0, 6, // 2941: case 0x0: {
2652 OPC_CheckPredicate, 43, // 2943: check predicate 43
2653 OPC_Decode, 218, 121, 23, // 2945: decode to PWSUB_B using decoder 23
2654 // 2945: }
2655 1, 0, // 2949: case 0x1: {
2656 OPC_CheckPredicate, 43, // 2951: check predicate 43
2657 OPC_Decode, 240, 118, 23, // 2953: decode to PM2WSUB_H using decoder 23
2658 // 2953: }
2659 // 2953: } // switch Inst[25]
2660 // 2953: }
2661 // 2953: } // switch Inst[7]
2662 // 2953: }
2663 18, 46, // 2957: case 0x12: {
2664 OPC_SwitchField, 7, 1, // 2959: switch Inst[7] {
2665 0, 19, // 2962: case 0x0: {
2666 OPC_SwitchField, 25, 1, // 2964: switch Inst[25] {
2667 0, 6, // 2967: case 0x0: {
2668 OPC_CheckPredicate, 43, // 2969: check predicate 43
2669 OPC_Decode, 206, 121, 23, // 2971: decode to PWSLA_BS using decoder 23
2670 // 2971: }
2671 1, 0, // 2975: case 0x1: {
2672 OPC_CheckPredicate, 43, // 2977: check predicate 43
2673 OPC_Decode, 207, 121, 23, // 2979: decode to PWSLA_HS using decoder 23
2674 // 2979: }
2675 // 2979: } // switch Inst[25]
2676 // 2979: }
2677 1, 0, // 2983: case 0x1: {
2678 OPC_SwitchField, 25, 1, // 2985: switch Inst[25] {
2679 0, 6, // 2988: case 0x0: {
2680 OPC_CheckPredicate, 43, // 2990: check predicate 43
2681 OPC_Decode, 215, 121, 25, // 2992: decode to PWSUBA_H using decoder 25
2682 // 2992: }
2683 1, 0, // 2996: case 0x1: {
2684 OPC_CheckPredicate, 43, // 2998: check predicate 43
2685 OPC_Decode, 144, 131, 1, 25, // 3000: decode to WSUBA using decoder 25
2686 // 3000: }
2687 // 3000: } // switch Inst[25]
2688 // 3000: }
2689 // 3000: } // switch Inst[7]
2690 // 3000: }
2691 19, 37, // 3005: case 0x13: {
2692 OPC_SwitchField, 7, 1, // 3007: switch Inst[7] {
2693 0, 11, // 3010: case 0x0: {
2694 OPC_CheckPredicate, 43, // 3012: check predicate 43
2695 OPC_CheckField, 25, 1, 1, // 3014: check Inst[25] == 0x1
2696 OPC_Decode, 139, 131, 1, 23, // 3018: decode to WSLA using decoder 23
2697 // 3018: }
2698 1, 0, // 3023: case 0x1: {
2699 OPC_SwitchField, 25, 1, // 3025: switch Inst[25] {
2700 0, 6, // 3028: case 0x0: {
2701 OPC_CheckPredicate, 43, // 3030: check predicate 43
2702 OPC_Decode, 214, 121, 25, // 3032: decode to PWSUBA_B using decoder 25
2703 // 3032: }
2704 1, 0, // 3036: case 0x1: {
2705 OPC_CheckPredicate, 43, // 3038: check predicate 43
2706 OPC_Decode, 238, 118, 25, // 3040: decode to PM2WSUBA_H using decoder 25
2707 // 3040: }
2708 // 3040: } // switch Inst[25]
2709 // 3040: }
2710 // 3040: } // switch Inst[7]
2711 // 3040: }
2712 20, 28, // 3044: case 0x14: {
2713 OPC_SwitchField, 25, 1, // 3046: switch Inst[25] {
2714 0, 10, // 3049: case 0x0: {
2715 OPC_CheckPredicate, 43, // 3051: check predicate 43
2716 OPC_CheckField, 7, 1, 1, // 3053: check Inst[7] == 0x1
2717 OPC_Decode, 217, 121, 23, // 3057: decode to PWSUBU_H using decoder 23
2718 // 3057: }
2719 1, 0, // 3061: case 0x1: {
2720 OPC_CheckPredicate, 43, // 3063: check predicate 43
2721 OPC_CheckField, 7, 1, 1, // 3065: check Inst[7] == 0x1
2722 OPC_Decode, 146, 131, 1, 23, // 3069: decode to WSUBU using decoder 23
2723 // 3069: }
2724 // 3069: } // switch Inst[25]
2725 // 3069: }
2726 21, 27, // 3074: case 0x15: {
2727 OPC_SwitchField, 25, 1, // 3076: switch Inst[25] {
2728 0, 10, // 3079: case 0x0: {
2729 OPC_CheckPredicate, 43, // 3081: check predicate 43
2730 OPC_CheckField, 7, 1, 1, // 3083: check Inst[7] == 0x1
2731 OPC_Decode, 216, 121, 23, // 3087: decode to PWSUBU_B using decoder 23
2732 // 3087: }
2733 1, 0, // 3091: case 0x1: {
2734 OPC_CheckPredicate, 43, // 3093: check predicate 43
2735 OPC_CheckField, 7, 1, 1, // 3095: check Inst[7] == 0x1
2736 OPC_Decode, 241, 118, 23, // 3099: decode to PM2WSUB_HX using decoder 23
2737 // 3099: }
2738 // 3099: } // switch Inst[25]
2739 // 3099: }
2740 22, 28, // 3103: case 0x16: {
2741 OPC_SwitchField, 25, 1, // 3105: switch Inst[25] {
2742 0, 10, // 3108: case 0x0: {
2743 OPC_CheckPredicate, 43, // 3110: check predicate 43
2744 OPC_CheckField, 7, 1, 1, // 3112: check Inst[7] == 0x1
2745 OPC_Decode, 213, 121, 25, // 3116: decode to PWSUBAU_H using decoder 25
2746 // 3116: }
2747 1, 0, // 3120: case 0x1: {
2748 OPC_CheckPredicate, 43, // 3122: check predicate 43
2749 OPC_CheckField, 7, 1, 1, // 3124: check Inst[7] == 0x1
2750 OPC_Decode, 145, 131, 1, 25, // 3128: decode to WSUBAU using decoder 25
2751 // 3128: }
2752 // 3128: } // switch Inst[25]
2753 // 3128: }
2754 23, 27, // 3133: case 0x17: {
2755 OPC_SwitchField, 25, 1, // 3135: switch Inst[25] {
2756 0, 10, // 3138: case 0x0: {
2757 OPC_CheckPredicate, 43, // 3140: check predicate 43
2758 OPC_CheckField, 7, 1, 1, // 3142: check Inst[7] == 0x1
2759 OPC_Decode, 212, 121, 25, // 3146: decode to PWSUBAU_B using decoder 25
2760 // 3146: }
2761 1, 0, // 3150: case 0x1: {
2762 OPC_CheckPredicate, 43, // 3152: check predicate 43
2763 OPC_CheckField, 7, 1, 1, // 3154: check Inst[7] == 0x1
2764 OPC_Decode, 239, 118, 25, // 3158: decode to PM2WSUBA_HX using decoder 25
2765 // 3158: }
2766 // 3158: } // switch Inst[25]
2767 // 3158: }
2768 24, 28, // 3162: case 0x18: {
2769 OPC_SwitchField, 25, 1, // 3164: switch Inst[25] {
2770 0, 10, // 3167: case 0x0: {
2771 OPC_CheckPredicate, 43, // 3169: check predicate 43
2772 OPC_CheckField, 7, 1, 1, // 3171: check Inst[7] == 0x1
2773 OPC_Decode, 199, 121, 23, // 3175: decode to PWMULSU_H using decoder 23
2774 // 3175: }
2775 1, 0, // 3179: case 0x1: {
2776 OPC_CheckPredicate, 43, // 3181: check predicate 43
2777 OPC_CheckField, 7, 1, 1, // 3183: check Inst[7] == 0x1
2778 OPC_Decode, 135, 131, 1, 23, // 3187: decode to WMULSU using decoder 23
2779 // 3187: }
2780 // 3187: } // switch Inst[25]
2781 // 3187: }
2782 25, 27, // 3192: case 0x19: {
2783 OPC_SwitchField, 25, 1, // 3194: switch Inst[25] {
2784 0, 10, // 3197: case 0x0: {
2785 OPC_CheckPredicate, 43, // 3199: check predicate 43
2786 OPC_CheckField, 7, 1, 1, // 3201: check Inst[7] == 0x1
2787 OPC_Decode, 198, 121, 23, // 3205: decode to PWMULSU_B using decoder 23
2788 // 3205: }
2789 1, 0, // 3209: case 0x1: {
2790 OPC_CheckPredicate, 43, // 3211: check predicate 43
2791 OPC_CheckField, 7, 1, 1, // 3213: check Inst[7] == 0x1
2792 OPC_Decode, 234, 118, 23, // 3217: decode to PM2WADDSU_H using decoder 23
2793 // 3217: }
2794 // 3217: } // switch Inst[25]
2795 // 3217: }
2796 26, 28, // 3221: case 0x1a: {
2797 OPC_SwitchField, 25, 1, // 3223: switch Inst[25] {
2798 0, 10, // 3226: case 0x0: {
2799 OPC_CheckPredicate, 43, // 3228: check predicate 43
2800 OPC_CheckField, 7, 1, 1, // 3230: check Inst[7] == 0x1
2801 OPC_Decode, 195, 121, 25, // 3234: decode to PWMACCSU_H using decoder 25
2802 // 3234: }
2803 1, 0, // 3238: case 0x1: {
2804 OPC_CheckPredicate, 43, // 3240: check predicate 43
2805 OPC_CheckField, 7, 1, 1, // 3242: check Inst[7] == 0x1
2806 OPC_Decode, 132, 131, 1, 25, // 3246: decode to WMACCSU using decoder 25
2807 // 3246: }
2808 // 3246: } // switch Inst[25]
2809 // 3246: }
2810 27, 14, // 3251: case 0x1b: {
2811 OPC_CheckPredicate, 43, // 3253: check predicate 43
2812 OPC_CheckField, 25, 1, 1, // 3255: check Inst[25] == 0x1
2813 OPC_CheckField, 7, 1, 1, // 3259: check Inst[7] == 0x1
2814 OPC_Decode, 230, 118, 25, // 3263: decode to PM2WADDASU_H using decoder 25
2815 // 3263: }
2816 28, 14, // 3267: case 0x1c: {
2817 OPC_CheckPredicate, 43, // 3269: check predicate 43
2818 OPC_CheckField, 25, 1, 0, // 3271: check Inst[25] == 0x0
2819 OPC_CheckField, 7, 1, 0, // 3275: check Inst[7] == 0x0
2820 OPC_Decode, 201, 118, 28, // 3279: decode to PLUI_DH using decoder 28
2821 // 3279: }
2822 30, 47, // 3283: case 0x1e: {
2823 OPC_SwitchField, 7, 1, // 3285: switch Inst[7] {
2824 0, 21, // 3288: case 0x0: {
2825 OPC_SwitchField, 25, 1, // 3290: switch Inst[25] {
2826 0, 7, // 3293: case 0x0: {
2827 OPC_CheckPredicate, 43, // 3295: check predicate 43
2828 OPC_Decode, 148, 131, 1, 23, // 3297: decode to WZIP8P using decoder 23
2829 // 3297: }
2830 1, 0, // 3302: case 0x1: {
2831 OPC_CheckPredicate, 43, // 3304: check predicate 43
2832 OPC_Decode, 147, 131, 1, 23, // 3306: decode to WZIP16P using decoder 23
2833 // 3306: }
2834 // 3306: } // switch Inst[25]
2835 // 3306: }
2836 1, 0, // 3311: case 0x1: {
2837 OPC_SwitchField, 25, 1, // 3313: switch Inst[25] {
2838 0, 6, // 3316: case 0x0: {
2839 OPC_CheckPredicate, 43, // 3318: check predicate 43
2840 OPC_Decode, 193, 119, 25, // 3320: decode to PMQWACC_H using decoder 25
2841 // 3320: }
2842 1, 0, // 3324: case 0x1: {
2843 OPC_CheckPredicate, 43, // 3326: check predicate 43
2844 OPC_Decode, 164, 117, 25, // 3328: decode to MQWACC using decoder 25
2845 // 3328: }
2846 // 3328: } // switch Inst[25]
2847 // 3328: }
2848 // 3328: } // switch Inst[7]
2849 // 3328: }
2850 31, 27, // 3332: case 0x1f: {
2851 OPC_SwitchField, 25, 1, // 3334: switch Inst[25] {
2852 0, 10, // 3337: case 0x0: {
2853 OPC_CheckPredicate, 43, // 3339: check predicate 43
2854 OPC_CheckField, 7, 1, 1, // 3341: check Inst[7] == 0x1
2855 OPC_Decode, 192, 119, 25, // 3345: decode to PMQRWACC_H using decoder 25
2856 // 3345: }
2857 1, 0, // 3349: case 0x1: {
2858 OPC_CheckPredicate, 43, // 3351: check predicate 43
2859 OPC_CheckField, 7, 1, 1, // 3353: check Inst[7] == 0x1
2860 OPC_Decode, 163, 117, 25, // 3357: decode to MQRWACC using decoder 25
2861 // 3357: }
2862 // 3357: } // switch Inst[25]
2863 // 3357: }
2864 32, 36, // 3361: case 0x20: {
2865 OPC_SwitchField, 25, 1, // 3363: switch Inst[25] {
2866 0, 23, // 3366: case 0x0: {
2867 OPC_SwitchField, 24, 1, // 3368: switch Inst[24] {
2868 0, 10, // 3371: case 0x0: {
2869 OPC_CheckPredicate, 39, // 3373: check predicate 39
2870 OPC_CheckField, 23, 1, 1, // 3375: check Inst[23] == 0x1
2871 OPC_Decode, 226, 120, 29, // 3379: decode to PSLLI_B using decoder 29
2872 // 3379: }
2873 1, 0, // 3383: case 0x1: {
2874 OPC_CheckPredicate, 39, // 3385: check predicate 39
2875 OPC_Decode, 230, 120, 17, // 3387: decode to PSLLI_H using decoder 17
2876 // 3387: }
2877 // 3387: } // switch Inst[24]
2878 // 3387: }
2879 1, 0, // 3391: case 0x1: {
2880 OPC_CheckPredicate, 44, // 3393: check predicate 44
2881 OPC_Decode, 231, 120, 20, // 3395: decode to PSLLI_W using decoder 20
2882 // 3395: }
2883 // 3395: } // switch Inst[25]
2884 // 3395: }
2885 34, 19, // 3399: case 0x22: {
2886 OPC_SwitchField, 25, 1, // 3401: switch Inst[25] {
2887 0, 6, // 3404: case 0x0: {
2888 OPC_CheckPredicate, 39, // 3406: check predicate 39
2889 OPC_Decode, 236, 120, 30, // 3408: decode to PSLL_HS using decoder 30
2890 // 3408: }
2891 1, 0, // 3412: case 0x1: {
2892 OPC_CheckPredicate, 44, // 3414: check predicate 44
2893 OPC_Decode, 237, 120, 30, // 3416: decode to PSLL_WS using decoder 30
2894 // 3416: }
2895 // 3416: } // switch Inst[25]
2896 // 3416: }
2897 35, 10, // 3420: case 0x23: {
2898 OPC_CheckPredicate, 39, // 3422: check predicate 39
2899 OPC_CheckField, 25, 1, 0, // 3424: check Inst[25] == 0x0
2900 OPC_Decode, 232, 120, 30, // 3428: decode to PSLL_BS using decoder 30
2901 // 3428: }
2902 38, 19, // 3432: case 0x26: {
2903 OPC_SwitchField, 25, 1, // 3434: switch Inst[25] {
2904 0, 6, // 3437: case 0x0: {
2905 OPC_CheckPredicate, 39, // 3439: check predicate 39
2906 OPC_Decode, 175, 118, 30, // 3441: decode to PADD_HS using decoder 30
2907 // 3441: }
2908 1, 0, // 3445: case 0x1: {
2909 OPC_CheckPredicate, 44, // 3447: check predicate 44
2910 OPC_Decode, 177, 118, 30, // 3449: decode to PADD_WS using decoder 30
2911 // 3449: }
2912 // 3449: } // switch Inst[25]
2913 // 3449: }
2914 39, 10, // 3453: case 0x27: {
2915 OPC_CheckPredicate, 39, // 3455: check predicate 39
2916 OPC_CheckField, 25, 1, 0, // 3457: check Inst[25] == 0x0
2917 OPC_Decode, 167, 118, 30, // 3461: decode to PADD_BS using decoder 30
2918 // 3461: }
2919 42, 19, // 3465: case 0x2a: {
2920 OPC_SwitchField, 25, 1, // 3467: switch Inst[25] {
2921 0, 6, // 3470: case 0x0: {
2922 OPC_CheckPredicate, 39, // 3472: check predicate 39
2923 OPC_Decode, 159, 121, 30, // 3474: decode to PSSHL_HS using decoder 30
2924 // 3474: }
2925 1, 0, // 3478: case 0x1: {
2926 OPC_CheckPredicate, 44, // 3480: check predicate 44
2927 OPC_Decode, 160, 121, 30, // 3482: decode to PSSHL_WS using decoder 30
2928 // 3482: }
2929 // 3482: } // switch Inst[25]
2930 // 3482: }
2931 43, 10, // 3486: case 0x2b: {
2932 OPC_CheckPredicate, 44, // 3488: check predicate 44
2933 OPC_CheckField, 25, 1, 1, // 3490: check Inst[25] == 0x1
2934 OPC_Decode, 135, 124, 30, // 3494: decode to SHL using decoder 30
2935 // 3494: }
2936 44, 19, // 3498: case 0x2c: {
2937 OPC_SwitchField, 25, 1, // 3500: switch Inst[25] {
2938 0, 6, // 3503: case 0x0: {
2939 OPC_CheckPredicate, 39, // 3505: check predicate 39
2940 OPC_Decode, 199, 118, 31, // 3507: decode to PLI_H using decoder 31
2941 // 3507: }
2942 1, 0, // 3511: case 0x1: {
2943 OPC_CheckPredicate, 44, // 3513: check predicate 44
2944 OPC_Decode, 200, 118, 31, // 3515: decode to PLI_W using decoder 31
2945 // 3515: }
2946 // 3515: } // switch Inst[25]
2947 // 3515: }
2948 45, 14, // 3519: case 0x2d: {
2949 OPC_CheckPredicate, 39, // 3521: check predicate 39
2950 OPC_CheckField, 24, 2, 0, // 3523: check Inst[25:24] == 0x0
2951 OPC_CheckField, 15, 1, 0, // 3527: check Inst[15] == 0x0
2952 OPC_Decode, 196, 118, 32, // 3531: decode to PLI_B using decoder 32
2953 // 3531: }
2954 46, 19, // 3535: case 0x2e: {
2955 OPC_SwitchField, 25, 1, // 3537: switch Inst[25] {
2956 0, 6, // 3540: case 0x0: {
2957 OPC_CheckPredicate, 39, // 3542: check predicate 39
2958 OPC_Decode, 155, 121, 30, // 3544: decode to PSSHLR_HS using decoder 30
2959 // 3544: }
2960 1, 0, // 3548: case 0x1: {
2961 OPC_CheckPredicate, 44, // 3550: check predicate 44
2962 OPC_Decode, 156, 121, 30, // 3552: decode to PSSHLR_WS using decoder 30
2963 // 3552: }
2964 // 3552: } // switch Inst[25]
2965 // 3552: }
2966 47, 10, // 3556: case 0x2f: {
2967 OPC_CheckPredicate, 44, // 3558: check predicate 44
2968 OPC_CheckField, 25, 1, 1, // 3560: check Inst[25] == 0x1
2969 OPC_Decode, 136, 124, 30, // 3564: decode to SHLR using decoder 30
2970 // 3564: }
2971 52, 23, // 3568: case 0x34: {
2972 OPC_SwitchField, 25, 1, // 3570: switch Inst[25] {
2973 0, 10, // 3573: case 0x0: {
2974 OPC_CheckPredicate, 39, // 3575: check predicate 39
2975 OPC_CheckField, 24, 1, 1, // 3577: check Inst[24] == 0x1
2976 OPC_Decode, 163, 121, 17, // 3581: decode to PSSLAI_H using decoder 17
2977 // 3581: }
2978 1, 0, // 3585: case 0x1: {
2979 OPC_CheckPredicate, 44, // 3587: check predicate 44
2980 OPC_Decode, 164, 121, 20, // 3589: decode to PSSLAI_W using decoder 20
2981 // 3589: }
2982 // 3589: } // switch Inst[25]
2983 // 3589: }
2984 56, 35, // 3593: case 0x38: {
2985 OPC_SwitchField, 20, 6, // 3595: switch Inst[25:20] {
2986 4, 6, // 3598: case 0x4: {
2987 OPC_CheckPredicate, 39, // 3600: check predicate 39
2988 OPC_Decode, 219, 120, 16, // 3602: decode to PSEXT_H_B using decoder 16
2989 // 3602: }
2990 7, 6, // 3606: case 0x7: {
2991 OPC_CheckPredicate, 39, // 3608: check predicate 39
2992 OPC_Decode, 193, 120, 16, // 3610: decode to PSABS_H using decoder 16
2993 // 3610: }
2994 36, 6, // 3614: case 0x24: {
2995 OPC_CheckPredicate, 44, // 3616: check predicate 44
2996 OPC_Decode, 220, 120, 16, // 3618: decode to PSEXT_W_B using decoder 16
2997 // 3618: }
2998 37, 0, // 3622: case 0x25: {
2999 OPC_CheckPredicate, 44, // 3624: check predicate 44
3000 OPC_Decode, 221, 120, 16, // 3626: decode to PSEXT_W_H using decoder 16
3001 // 3626: }
3002 // 3626: } // switch Inst[25:20]
3003 // 3626: }
3004 57, 10, // 3630: case 0x39: {
3005 OPC_CheckPredicate, 39, // 3632: check predicate 39
3006 OPC_CheckField, 20, 6, 7, // 3634: check Inst[25:20] == 0x7
3007 OPC_Decode, 190, 120, 16, // 3638: decode to PSABS_B using decoder 16
3008 // 3638: }
3009 58, 19, // 3642: case 0x3a: {
3010 OPC_SwitchField, 25, 1, // 3644: switch Inst[25] {
3011 0, 6, // 3647: case 0x0: {
3012 OPC_CheckPredicate, 39, // 3649: check predicate 39
3013 OPC_Decode, 151, 121, 30, // 3651: decode to PSSHA_HS using decoder 30
3014 // 3651: }
3015 1, 0, // 3655: case 0x1: {
3016 OPC_CheckPredicate, 44, // 3657: check predicate 44
3017 OPC_Decode, 152, 121, 30, // 3659: decode to PSSHA_WS using decoder 30
3018 // 3659: }
3019 // 3659: } // switch Inst[25]
3020 // 3659: }
3021 59, 10, // 3663: case 0x3b: {
3022 OPC_CheckPredicate, 44, // 3665: check predicate 44
3023 OPC_CheckField, 25, 1, 1, // 3667: check Inst[25] == 0x1
3024 OPC_Decode, 247, 123, 30, // 3671: decode to SHA using decoder 30
3025 // 3671: }
3026 60, 19, // 3675: case 0x3c: {
3027 OPC_SwitchField, 25, 1, // 3677: switch Inst[25] {
3028 0, 6, // 3680: case 0x0: {
3029 OPC_CheckPredicate, 39, // 3682: check predicate 39
3030 OPC_Decode, 202, 118, 33, // 3684: decode to PLUI_H using decoder 33
3031 // 3684: }
3032 1, 0, // 3688: case 0x1: {
3033 OPC_CheckPredicate, 44, // 3690: check predicate 44
3034 OPC_Decode, 203, 118, 33, // 3692: decode to PLUI_W using decoder 33
3035 // 3692: }
3036 // 3692: } // switch Inst[25]
3037 // 3692: }
3038 62, 19, // 3696: case 0x3e: {
3039 OPC_SwitchField, 25, 1, // 3698: switch Inst[25] {
3040 0, 6, // 3701: case 0x0: {
3041 OPC_CheckPredicate, 39, // 3703: check predicate 39
3042 OPC_Decode, 147, 121, 30, // 3705: decode to PSSHAR_HS using decoder 30
3043 // 3705: }
3044 1, 0, // 3709: case 0x1: {
3045 OPC_CheckPredicate, 44, // 3711: check predicate 44
3046 OPC_Decode, 148, 121, 30, // 3713: decode to PSSHAR_WS using decoder 30
3047 // 3713: }
3048 // 3713: } // switch Inst[25]
3049 // 3713: }
3050 63, 0, // 3717: case 0x3f: {
3051 OPC_CheckPredicate, 44, // 3719: check predicate 44
3052 OPC_CheckField, 25, 1, 1, // 3721: check Inst[25] == 0x1
3053 OPC_Decode, 134, 124, 30, // 3725: decode to SHAR using decoder 30
3054 // 3725: }
3055 // 3725: } // switch Inst[31:26]
3056 // 3725: }
3057 4, 226, 7, // 3729: case 0x4: {
3058 OPC_SwitchField, 26, 6, // 3732: switch Inst[31:26] {
3059 0, 31, // 3735: case 0x0: {
3060 OPC_SwitchField, 25, 1, // 3737: switch Inst[25] {
3061 0, 14, // 3740: case 0x0: {
3062 OPC_CheckPredicate, 43, // 3742: check predicate 43
3063 OPC_CheckField, 24, 1, 1, // 3744: check Inst[24] == 0x1
3064 OPC_CheckField, 15, 1, 1, // 3748: check Inst[15] == 0x1
3065 OPC_Decode, 154, 120, 34, // 3752: decode to PNSRLI_B using decoder 34
3066 // 3752: }
3067 1, 0, // 3756: case 0x1: {
3068 OPC_CheckPredicate, 43, // 3758: check predicate 43
3069 OPC_CheckField, 15, 1, 1, // 3760: check Inst[15] == 0x1
3070 OPC_Decode, 155, 120, 35, // 3764: decode to PNSRLI_H using decoder 35
3071 // 3764: }
3072 // 3764: } // switch Inst[25]
3073 // 3764: }
3074 1, 10, // 3768: case 0x1: {
3075 OPC_CheckPredicate, 43, // 3770: check predicate 43
3076 OPC_CheckField, 15, 1, 1, // 3772: check Inst[15] == 0x1
3077 OPC_Decode, 133, 118, 36, // 3776: decode to NSRLI using decoder 36
3078 // 3776: }
3079 2, 27, // 3780: case 0x2: {
3080 OPC_SwitchField, 25, 1, // 3782: switch Inst[25] {
3081 0, 10, // 3785: case 0x0: {
3082 OPC_CheckPredicate, 43, // 3787: check predicate 43
3083 OPC_CheckField, 15, 1, 1, // 3789: check Inst[15] == 0x1
3084 OPC_Decode, 156, 120, 37, // 3793: decode to PNSRL_BS using decoder 37
3085 // 3793: }
3086 1, 0, // 3797: case 0x1: {
3087 OPC_CheckPredicate, 43, // 3799: check predicate 43
3088 OPC_CheckField, 15, 1, 1, // 3801: check Inst[15] == 0x1
3089 OPC_Decode, 157, 120, 37, // 3805: decode to PNSRL_HS using decoder 37
3090 // 3805: }
3091 // 3805: } // switch Inst[25]
3092 // 3805: }
3093 3, 14, // 3809: case 0x3: {
3094 OPC_CheckPredicate, 43, // 3811: check predicate 43
3095 OPC_CheckField, 25, 1, 1, // 3813: check Inst[25] == 0x1
3096 OPC_CheckField, 15, 1, 1, // 3817: check Inst[15] == 0x1
3097 OPC_Decode, 132, 118, 37, // 3821: decode to NSRL using decoder 37
3098 // 3821: }
3099 6, 14, // 3825: case 0x6: {
3100 OPC_CheckPredicate, 43, // 3827: check predicate 43
3101 OPC_CheckField, 25, 1, 0, // 3829: check Inst[25] == 0x0
3102 OPC_CheckField, 15, 1, 0, // 3833: check Inst[15] == 0x0
3103 OPC_Decode, 184, 120, 37, // 3837: decode to PREDSUM_DHS using decoder 37
3104 // 3837: }
3105 7, 14, // 3841: case 0x7: {
3106 OPC_CheckPredicate, 43, // 3843: check predicate 43
3107 OPC_CheckField, 25, 1, 0, // 3845: check Inst[25] == 0x0
3108 OPC_CheckField, 15, 1, 0, // 3849: check Inst[15] == 0x0
3109 OPC_Decode, 183, 120, 37, // 3853: decode to PREDSUM_DBS using decoder 37
3110 // 3853: }
3111 8, 31, // 3857: case 0x8: {
3112 OPC_SwitchField, 25, 1, // 3859: switch Inst[25] {
3113 0, 14, // 3862: case 0x0: {
3114 OPC_CheckPredicate, 43, // 3864: check predicate 43
3115 OPC_CheckField, 24, 1, 1, // 3866: check Inst[24] == 0x1
3116 OPC_CheckField, 15, 1, 1, // 3870: check Inst[15] == 0x1
3117 OPC_Decode, 252, 119, 34, // 3874: decode to PNCLIPIU_B using decoder 34
3118 // 3874: }
3119 1, 0, // 3878: case 0x1: {
3120 OPC_CheckPredicate, 43, // 3880: check predicate 43
3121 OPC_CheckField, 15, 1, 1, // 3882: check Inst[15] == 0x1
3122 OPC_Decode, 253, 119, 35, // 3886: decode to PNCLIPIU_H using decoder 35
3123 // 3886: }
3124 // 3886: } // switch Inst[25]
3125 // 3886: }
3126 9, 10, // 3890: case 0x9: {
3127 OPC_CheckPredicate, 43, // 3892: check predicate 43
3128 OPC_CheckField, 15, 1, 1, // 3894: check Inst[15] == 0x1
3129 OPC_Decode, 203, 117, 36, // 3898: decode to NCLIPIU using decoder 36
3130 // 3898: }
3131 10, 27, // 3902: case 0xa: {
3132 OPC_SwitchField, 25, 1, // 3904: switch Inst[25] {
3133 0, 10, // 3907: case 0x0: {
3134 OPC_CheckPredicate, 43, // 3909: check predicate 43
3135 OPC_CheckField, 15, 1, 1, // 3911: check Inst[15] == 0x1
3136 OPC_Decode, 142, 120, 37, // 3915: decode to PNCLIPU_BS using decoder 37
3137 // 3915: }
3138 1, 0, // 3919: case 0x1: {
3139 OPC_CheckPredicate, 43, // 3921: check predicate 43
3140 OPC_CheckField, 15, 1, 1, // 3923: check Inst[15] == 0x1
3141 OPC_Decode, 143, 120, 37, // 3927: decode to PNCLIPU_HS using decoder 37
3142 // 3927: }
3143 // 3927: } // switch Inst[25]
3144 // 3927: }
3145 11, 14, // 3931: case 0xb: {
3146 OPC_CheckPredicate, 43, // 3933: check predicate 43
3147 OPC_CheckField, 25, 1, 1, // 3935: check Inst[25] == 0x1
3148 OPC_CheckField, 15, 1, 1, // 3939: check Inst[15] == 0x1
3149 OPC_Decode, 208, 117, 37, // 3943: decode to NCLIPU using decoder 37
3150 // 3943: }
3151 12, 31, // 3947: case 0xc: {
3152 OPC_SwitchField, 25, 1, // 3949: switch Inst[25] {
3153 0, 14, // 3952: case 0x0: {
3154 OPC_CheckPredicate, 43, // 3954: check predicate 43
3155 OPC_CheckField, 24, 1, 1, // 3956: check Inst[24] == 0x1
3156 OPC_CheckField, 15, 1, 1, // 3960: check Inst[15] == 0x1
3157 OPC_Decode, 131, 120, 34, // 3964: decode to PNCLIPRIU_B using decoder 34
3158 // 3964: }
3159 1, 0, // 3968: case 0x1: {
3160 OPC_CheckPredicate, 43, // 3970: check predicate 43
3161 OPC_CheckField, 15, 1, 1, // 3972: check Inst[15] == 0x1
3162 OPC_Decode, 132, 120, 35, // 3976: decode to PNCLIPRIU_H using decoder 35
3163 // 3976: }
3164 // 3976: } // switch Inst[25]
3165 // 3976: }
3166 13, 10, // 3980: case 0xd: {
3167 OPC_CheckPredicate, 43, // 3982: check predicate 43
3168 OPC_CheckField, 15, 1, 1, // 3984: check Inst[15] == 0x1
3169 OPC_Decode, 206, 117, 36, // 3988: decode to NCLIPRIU using decoder 36
3170 // 3988: }
3171 14, 36, // 3992: case 0xe: {
3172 OPC_SwitchField, 15, 1, // 3994: switch Inst[15] {
3173 0, 10, // 3997: case 0x0: {
3174 OPC_CheckPredicate, 43, // 3999: check predicate 43
3175 OPC_CheckField, 25, 1, 0, // 4001: check Inst[25] == 0x0
3176 OPC_Decode, 179, 120, 37, // 4005: decode to PREDSUMU_DHS using decoder 37
3177 // 4005: }
3178 1, 0, // 4009: case 0x1: {
3179 OPC_SwitchField, 25, 1, // 4011: switch Inst[25] {
3180 0, 6, // 4014: case 0x0: {
3181 OPC_CheckPredicate, 43, // 4016: check predicate 43
3182 OPC_Decode, 135, 120, 37, // 4018: decode to PNCLIPRU_BS using decoder 37
3183 // 4018: }
3184 1, 0, // 4022: case 0x1: {
3185 OPC_CheckPredicate, 43, // 4024: check predicate 43
3186 OPC_Decode, 136, 120, 37, // 4026: decode to PNCLIPRU_HS using decoder 37
3187 // 4026: }
3188 // 4026: } // switch Inst[25]
3189 // 4026: }
3190 // 4026: } // switch Inst[15]
3191 // 4026: }
3192 15, 27, // 4030: case 0xf: {
3193 OPC_SwitchField, 15, 1, // 4032: switch Inst[15] {
3194 0, 10, // 4035: case 0x0: {
3195 OPC_CheckPredicate, 43, // 4037: check predicate 43
3196 OPC_CheckField, 25, 1, 0, // 4039: check Inst[25] == 0x0
3197 OPC_Decode, 178, 120, 37, // 4043: decode to PREDSUMU_DBS using decoder 37
3198 // 4043: }
3199 1, 0, // 4047: case 0x1: {
3200 OPC_CheckPredicate, 43, // 4049: check predicate 43
3201 OPC_CheckField, 25, 1, 1, // 4051: check Inst[25] == 0x1
3202 OPC_Decode, 207, 117, 37, // 4055: decode to NCLIPRU using decoder 37
3203 // 4055: }
3204 // 4055: } // switch Inst[15]
3205 // 4055: }
3206 16, 31, // 4059: case 0x10: {
3207 OPC_SwitchField, 25, 1, // 4061: switch Inst[25] {
3208 0, 14, // 4064: case 0x0: {
3209 OPC_CheckPredicate, 43, // 4066: check predicate 43
3210 OPC_CheckField, 24, 1, 1, // 4068: check Inst[24] == 0x1
3211 OPC_CheckField, 15, 1, 1, // 4072: check Inst[15] == 0x1
3212 OPC_Decode, 146, 120, 34, // 4076: decode to PNSRAI_B using decoder 34
3213 // 4076: }
3214 1, 0, // 4080: case 0x1: {
3215 OPC_CheckPredicate, 43, // 4082: check predicate 43
3216 OPC_CheckField, 15, 1, 1, // 4084: check Inst[15] == 0x1
3217 OPC_Decode, 147, 120, 35, // 4088: decode to PNSRAI_H using decoder 35
3218 // 4088: }
3219 // 4088: } // switch Inst[25]
3220 // 4088: }
3221 17, 10, // 4092: case 0x11: {
3222 OPC_CheckPredicate, 43, // 4094: check predicate 43
3223 OPC_CheckField, 15, 1, 1, // 4096: check Inst[15] == 0x1
3224 OPC_Decode, 129, 118, 36, // 4100: decode to NSRAI using decoder 36
3225 // 4100: }
3226 18, 27, // 4104: case 0x12: {
3227 OPC_SwitchField, 25, 1, // 4106: switch Inst[25] {
3228 0, 10, // 4109: case 0x0: {
3229 OPC_CheckPredicate, 43, // 4111: check predicate 43
3230 OPC_CheckField, 15, 1, 1, // 4113: check Inst[15] == 0x1
3231 OPC_Decode, 152, 120, 37, // 4117: decode to PNSRA_BS using decoder 37
3232 // 4117: }
3233 1, 0, // 4121: case 0x1: {
3234 OPC_CheckPredicate, 43, // 4123: check predicate 43
3235 OPC_CheckField, 15, 1, 1, // 4125: check Inst[15] == 0x1
3236 OPC_Decode, 153, 120, 37, // 4129: decode to PNSRA_HS using decoder 37
3237 // 4129: }
3238 // 4129: } // switch Inst[25]
3239 // 4129: }
3240 19, 14, // 4133: case 0x13: {
3241 OPC_CheckPredicate, 43, // 4135: check predicate 43
3242 OPC_CheckField, 25, 1, 1, // 4137: check Inst[25] == 0x1
3243 OPC_CheckField, 15, 1, 1, // 4141: check Inst[15] == 0x1
3244 OPC_Decode, 128, 118, 37, // 4145: decode to NSRA using decoder 37
3245 // 4145: }
3246 20, 31, // 4149: case 0x14: {
3247 OPC_SwitchField, 25, 1, // 4151: switch Inst[25] {
3248 0, 14, // 4154: case 0x0: {
3249 OPC_CheckPredicate, 43, // 4156: check predicate 43
3250 OPC_CheckField, 24, 1, 1, // 4158: check Inst[24] == 0x1
3251 OPC_CheckField, 15, 1, 1, // 4162: check Inst[15] == 0x1
3252 OPC_Decode, 148, 120, 34, // 4166: decode to PNSRARI_B using decoder 34
3253 // 4166: }
3254 1, 0, // 4170: case 0x1: {
3255 OPC_CheckPredicate, 43, // 4172: check predicate 43
3256 OPC_CheckField, 15, 1, 1, // 4174: check Inst[15] == 0x1
3257 OPC_Decode, 149, 120, 35, // 4178: decode to PNSRARI_H using decoder 35
3258 // 4178: }
3259 // 4178: } // switch Inst[25]
3260 // 4178: }
3261 21, 10, // 4182: case 0x15: {
3262 OPC_CheckPredicate, 43, // 4184: check predicate 43
3263 OPC_CheckField, 15, 1, 1, // 4186: check Inst[15] == 0x1
3264 OPC_Decode, 131, 118, 36, // 4190: decode to NSRARI using decoder 36
3265 // 4190: }
3266 22, 27, // 4194: case 0x16: {
3267 OPC_SwitchField, 25, 1, // 4196: switch Inst[25] {
3268 0, 10, // 4199: case 0x0: {
3269 OPC_CheckPredicate, 43, // 4201: check predicate 43
3270 OPC_CheckField, 15, 1, 1, // 4203: check Inst[15] == 0x1
3271 OPC_Decode, 150, 120, 37, // 4207: decode to PNSRAR_BS using decoder 37
3272 // 4207: }
3273 1, 0, // 4211: case 0x1: {
3274 OPC_CheckPredicate, 43, // 4213: check predicate 43
3275 OPC_CheckField, 15, 1, 1, // 4215: check Inst[15] == 0x1
3276 OPC_Decode, 151, 120, 37, // 4219: decode to PNSRAR_HS using decoder 37
3277 // 4219: }
3278 // 4219: } // switch Inst[25]
3279 // 4219: }
3280 23, 14, // 4223: case 0x17: {
3281 OPC_CheckPredicate, 43, // 4225: check predicate 43
3282 OPC_CheckField, 25, 1, 1, // 4227: check Inst[25] == 0x1
3283 OPC_CheckField, 15, 1, 1, // 4231: check Inst[15] == 0x1
3284 OPC_Decode, 130, 118, 37, // 4235: decode to NSRAR using decoder 37
3285 // 4235: }
3286 24, 31, // 4239: case 0x18: {
3287 OPC_SwitchField, 25, 1, // 4241: switch Inst[25] {
3288 0, 14, // 4244: case 0x0: {
3289 OPC_CheckPredicate, 43, // 4246: check predicate 43
3290 OPC_CheckField, 24, 1, 1, // 4248: check Inst[24] == 0x1
3291 OPC_CheckField, 15, 1, 1, // 4252: check Inst[15] == 0x1
3292 OPC_Decode, 254, 119, 34, // 4256: decode to PNCLIPI_B using decoder 34
3293 // 4256: }
3294 1, 0, // 4260: case 0x1: {
3295 OPC_CheckPredicate, 43, // 4262: check predicate 43
3296 OPC_CheckField, 15, 1, 1, // 4264: check Inst[15] == 0x1
3297 OPC_Decode, 255, 119, 35, // 4268: decode to PNCLIPI_H using decoder 35
3298 // 4268: }
3299 // 4268: } // switch Inst[25]
3300 // 4268: }
3301 25, 10, // 4272: case 0x19: {
3302 OPC_CheckPredicate, 43, // 4274: check predicate 43
3303 OPC_CheckField, 15, 1, 1, // 4276: check Inst[15] == 0x1
3304 OPC_Decode, 202, 117, 36, // 4280: decode to NCLIPI using decoder 36
3305 // 4280: }
3306 26, 27, // 4284: case 0x1a: {
3307 OPC_SwitchField, 25, 1, // 4286: switch Inst[25] {
3308 0, 10, // 4289: case 0x0: {
3309 OPC_CheckPredicate, 43, // 4291: check predicate 43
3310 OPC_CheckField, 15, 1, 1, // 4293: check Inst[15] == 0x1
3311 OPC_Decode, 144, 120, 37, // 4297: decode to PNCLIP_BS using decoder 37
3312 // 4297: }
3313 1, 0, // 4301: case 0x1: {
3314 OPC_CheckPredicate, 43, // 4303: check predicate 43
3315 OPC_CheckField, 15, 1, 1, // 4305: check Inst[15] == 0x1
3316 OPC_Decode, 145, 120, 37, // 4309: decode to PNCLIP_HS using decoder 37
3317 // 4309: }
3318 // 4309: } // switch Inst[25]
3319 // 4309: }
3320 27, 14, // 4313: case 0x1b: {
3321 OPC_CheckPredicate, 43, // 4315: check predicate 43
3322 OPC_CheckField, 25, 1, 1, // 4317: check Inst[25] == 0x1
3323 OPC_CheckField, 15, 1, 1, // 4321: check Inst[15] == 0x1
3324 OPC_Decode, 201, 117, 37, // 4325: decode to NCLIP using decoder 37
3325 // 4325: }
3326 28, 31, // 4329: case 0x1c: {
3327 OPC_SwitchField, 25, 1, // 4331: switch Inst[25] {
3328 0, 14, // 4334: case 0x0: {
3329 OPC_CheckPredicate, 43, // 4336: check predicate 43
3330 OPC_CheckField, 24, 1, 1, // 4338: check Inst[24] == 0x1
3331 OPC_CheckField, 15, 1, 1, // 4342: check Inst[15] == 0x1
3332 OPC_Decode, 133, 120, 34, // 4346: decode to PNCLIPRI_B using decoder 34
3333 // 4346: }
3334 1, 0, // 4350: case 0x1: {
3335 OPC_CheckPredicate, 43, // 4352: check predicate 43
3336 OPC_CheckField, 15, 1, 1, // 4354: check Inst[15] == 0x1
3337 OPC_Decode, 134, 120, 35, // 4358: decode to PNCLIPRI_H using decoder 35
3338 // 4358: }
3339 // 4358: } // switch Inst[25]
3340 // 4358: }
3341 29, 10, // 4362: case 0x1d: {
3342 OPC_CheckPredicate, 43, // 4364: check predicate 43
3343 OPC_CheckField, 15, 1, 1, // 4366: check Inst[15] == 0x1
3344 OPC_Decode, 205, 117, 36, // 4370: decode to NCLIPRI using decoder 36
3345 // 4370: }
3346 30, 27, // 4374: case 0x1e: {
3347 OPC_SwitchField, 25, 1, // 4376: switch Inst[25] {
3348 0, 10, // 4379: case 0x0: {
3349 OPC_CheckPredicate, 43, // 4381: check predicate 43
3350 OPC_CheckField, 15, 1, 1, // 4383: check Inst[15] == 0x1
3351 OPC_Decode, 137, 120, 37, // 4387: decode to PNCLIPR_BS using decoder 37
3352 // 4387: }
3353 1, 0, // 4391: case 0x1: {
3354 OPC_CheckPredicate, 43, // 4393: check predicate 43
3355 OPC_CheckField, 15, 1, 1, // 4395: check Inst[15] == 0x1
3356 OPC_Decode, 138, 120, 37, // 4399: decode to PNCLIPR_HS using decoder 37
3357 // 4399: }
3358 // 4399: } // switch Inst[25]
3359 // 4399: }
3360 31, 14, // 4403: case 0x1f: {
3361 OPC_CheckPredicate, 43, // 4405: check predicate 43
3362 OPC_CheckField, 25, 1, 1, // 4407: check Inst[25] == 0x1
3363 OPC_CheckField, 15, 1, 1, // 4411: check Inst[15] == 0x1
3364 OPC_Decode, 204, 117, 37, // 4415: decode to NCLIPR using decoder 37
3365 // 4415: }
3366 32, 36, // 4419: case 0x20: {
3367 OPC_SwitchField, 25, 1, // 4421: switch Inst[25] {
3368 0, 23, // 4424: case 0x0: {
3369 OPC_SwitchField, 24, 1, // 4426: switch Inst[24] {
3370 0, 10, // 4429: case 0x0: {
3371 OPC_CheckPredicate, 39, // 4431: check predicate 39
3372 OPC_CheckField, 23, 1, 1, // 4433: check Inst[23] == 0x1
3373 OPC_Decode, 254, 120, 29, // 4437: decode to PSRLI_B using decoder 29
3374 // 4437: }
3375 1, 0, // 4441: case 0x1: {
3376 OPC_CheckPredicate, 39, // 4443: check predicate 39
3377 OPC_Decode, 130, 121, 17, // 4445: decode to PSRLI_H using decoder 17
3378 // 4445: }
3379 // 4445: } // switch Inst[24]
3380 // 4445: }
3381 1, 0, // 4449: case 0x1: {
3382 OPC_CheckPredicate, 44, // 4451: check predicate 44
3383 OPC_Decode, 131, 121, 20, // 4453: decode to PSRLI_W using decoder 20
3384 // 4453: }
3385 // 4453: } // switch Inst[25]
3386 // 4453: }
3387 34, 19, // 4457: case 0x22: {
3388 OPC_SwitchField, 25, 1, // 4459: switch Inst[25] {
3389 0, 6, // 4462: case 0x0: {
3390 OPC_CheckPredicate, 39, // 4464: check predicate 39
3391 OPC_Decode, 136, 121, 30, // 4466: decode to PSRL_HS using decoder 30
3392 // 4466: }
3393 1, 0, // 4470: case 0x1: {
3394 OPC_CheckPredicate, 44, // 4472: check predicate 44
3395 OPC_Decode, 137, 121, 30, // 4474: decode to PSRL_WS using decoder 30
3396 // 4474: }
3397 // 4474: } // switch Inst[25]
3398 // 4474: }
3399 35, 10, // 4478: case 0x23: {
3400 OPC_CheckPredicate, 39, // 4480: check predicate 39
3401 OPC_CheckField, 25, 1, 0, // 4482: check Inst[25] == 0x0
3402 OPC_Decode, 132, 121, 30, // 4486: decode to PSRL_BS using decoder 30
3403 // 4486: }
3404 38, 19, // 4490: case 0x26: {
3405 OPC_SwitchField, 25, 1, // 4492: switch Inst[25] {
3406 0, 6, // 4495: case 0x0: {
3407 OPC_CheckPredicate, 39, // 4497: check predicate 39
3408 OPC_Decode, 185, 120, 30, // 4499: decode to PREDSUM_HS using decoder 30
3409 // 4499: }
3410 1, 0, // 4503: case 0x1: {
3411 OPC_CheckPredicate, 44, // 4505: check predicate 44
3412 OPC_Decode, 186, 120, 30, // 4507: decode to PREDSUM_WS using decoder 30
3413 // 4507: }
3414 // 4507: } // switch Inst[25]
3415 // 4507: }
3416 39, 10, // 4511: case 0x27: {
3417 OPC_CheckPredicate, 39, // 4513: check predicate 39
3418 OPC_CheckField, 25, 1, 0, // 4515: check Inst[25] == 0x0
3419 OPC_Decode, 182, 120, 30, // 4519: decode to PREDSUM_BS using decoder 30
3420 // 4519: }
3421 40, 23, // 4523: case 0x28: {
3422 OPC_SwitchField, 25, 1, // 4525: switch Inst[25] {
3423 0, 10, // 4528: case 0x0: {
3424 OPC_CheckPredicate, 39, // 4530: check predicate 39
3425 OPC_CheckField, 24, 1, 1, // 4532: check Inst[24] == 0x1
3426 OPC_Decode, 185, 121, 17, // 4536: decode to PUSATI_H using decoder 17
3427 // 4536: }
3428 1, 0, // 4540: case 0x1: {
3429 OPC_CheckPredicate, 44, // 4542: check predicate 44
3430 OPC_Decode, 186, 121, 20, // 4544: decode to PUSATI_W using decoder 20
3431 // 4544: }
3432 // 4544: } // switch Inst[25]
3433 // 4544: }
3434 41, 6, // 4548: case 0x29: {
3435 OPC_CheckPredicate, 44, // 4550: check predicate 44
3436 OPC_Decode, 197, 125, 38, // 4552: decode to USATI_RV64 using decoder 38
3437 // 4552: }
3438 46, 19, // 4556: case 0x2e: {
3439 OPC_SwitchField, 25, 1, // 4558: switch Inst[25] {
3440 0, 6, // 4561: case 0x0: {
3441 OPC_CheckPredicate, 39, // 4563: check predicate 39
3442 OPC_Decode, 180, 120, 30, // 4565: decode to PREDSUMU_HS using decoder 30
3443 // 4565: }
3444 1, 0, // 4569: case 0x1: {
3445 OPC_CheckPredicate, 44, // 4571: check predicate 44
3446 OPC_Decode, 181, 120, 30, // 4573: decode to PREDSUMU_WS using decoder 30
3447 // 4573: }
3448 // 4573: } // switch Inst[25]
3449 // 4573: }
3450 47, 10, // 4577: case 0x2f: {
3451 OPC_CheckPredicate, 39, // 4579: check predicate 39
3452 OPC_CheckField, 25, 1, 0, // 4581: check Inst[25] == 0x0
3453 OPC_Decode, 177, 120, 30, // 4585: decode to PREDSUMU_BS using decoder 30
3454 // 4585: }
3455 48, 36, // 4589: case 0x30: {
3456 OPC_SwitchField, 25, 1, // 4591: switch Inst[25] {
3457 0, 23, // 4594: case 0x0: {
3458 OPC_SwitchField, 24, 1, // 4596: switch Inst[24] {
3459 0, 10, // 4599: case 0x0: {
3460 OPC_CheckPredicate, 39, // 4601: check predicate 39
3461 OPC_CheckField, 23, 1, 1, // 4603: check Inst[23] == 0x1
3462 OPC_Decode, 238, 120, 29, // 4607: decode to PSRAI_B using decoder 29
3463 // 4607: }
3464 1, 0, // 4611: case 0x1: {
3465 OPC_CheckPredicate, 39, // 4613: check predicate 39
3466 OPC_Decode, 242, 120, 17, // 4615: decode to PSRAI_H using decoder 17
3467 // 4615: }
3468 // 4615: } // switch Inst[24]
3469 // 4615: }
3470 1, 0, // 4619: case 0x1: {
3471 OPC_CheckPredicate, 44, // 4621: check predicate 44
3472 OPC_Decode, 243, 120, 20, // 4623: decode to PSRAI_W using decoder 20
3473 // 4623: }
3474 // 4623: } // switch Inst[25]
3475 // 4623: }
3476 50, 19, // 4627: case 0x32: {
3477 OPC_SwitchField, 25, 1, // 4629: switch Inst[25] {
3478 0, 6, // 4632: case 0x0: {
3479 OPC_CheckPredicate, 39, // 4634: check predicate 39
3480 OPC_Decode, 252, 120, 30, // 4636: decode to PSRA_HS using decoder 30
3481 // 4636: }
3482 1, 0, // 4640: case 0x1: {
3483 OPC_CheckPredicate, 44, // 4642: check predicate 44
3484 OPC_Decode, 253, 120, 30, // 4644: decode to PSRA_WS using decoder 30
3485 // 4644: }
3486 // 4644: } // switch Inst[25]
3487 // 4644: }
3488 51, 10, // 4648: case 0x33: {
3489 OPC_CheckPredicate, 39, // 4650: check predicate 39
3490 OPC_CheckField, 25, 1, 0, // 4652: check Inst[25] == 0x0
3491 OPC_Decode, 248, 120, 30, // 4656: decode to PSRA_BS using decoder 30
3492 // 4656: }
3493 52, 23, // 4660: case 0x34: {
3494 OPC_SwitchField, 25, 1, // 4662: switch Inst[25] {
3495 0, 10, // 4665: case 0x0: {
3496 OPC_CheckPredicate, 39, // 4667: check predicate 39
3497 OPC_CheckField, 24, 1, 1, // 4669: check Inst[24] == 0x1
3498 OPC_Decode, 246, 120, 17, // 4673: decode to PSRARI_H using decoder 17
3499 // 4673: }
3500 1, 0, // 4677: case 0x1: {
3501 OPC_CheckPredicate, 44, // 4679: check predicate 44
3502 OPC_Decode, 247, 120, 20, // 4681: decode to PSRARI_W using decoder 20
3503 // 4681: }
3504 // 4681: } // switch Inst[25]
3505 // 4681: }
3506 53, 6, // 4685: case 0x35: {
3507 OPC_CheckPredicate, 44, // 4687: check predicate 44
3508 OPC_Decode, 175, 124, 38, // 4689: decode to SRARI_RV64 using decoder 38
3509 // 4689: }
3510 56, 23, // 4693: case 0x38: {
3511 OPC_SwitchField, 25, 1, // 4695: switch Inst[25] {
3512 0, 10, // 4698: case 0x0: {
3513 OPC_CheckPredicate, 39, // 4700: check predicate 39
3514 OPC_CheckField, 24, 1, 1, // 4702: check Inst[24] == 0x1
3515 OPC_Decode, 211, 120, 39, // 4706: decode to PSATI_H using decoder 39
3516 // 4706: }
3517 1, 0, // 4710: case 0x1: {
3518 OPC_CheckPredicate, 44, // 4712: check predicate 44
3519 OPC_Decode, 212, 120, 40, // 4714: decode to PSATI_W using decoder 40
3520 // 4714: }
3521 // 4714: } // switch Inst[25]
3522 // 4714: }
3523 57, 0, // 4718: case 0x39: {
3524 OPC_CheckPredicate, 44, // 4720: check predicate 44
3525 OPC_Decode, 150, 123, 41, // 4722: decode to SATI_RV64 using decoder 41
3526 // 4722: }
3527 // 4722: } // switch Inst[31:26]
3528 // 4722: }
3529 5, 27, // 4726: case 0x5: {
3530 OPC_SwitchField, 25, 7, // 4728: switch Inst[31:25] {
3531 0, 6, // 4731: case 0x0: {
3532 OPC_CheckPredicate, 20, // 4733: check predicate 20
3533 OPC_Decode, 180, 124, 20, // 4735: decode to SRLIW using decoder 20
3534 // 4735: }
3535 32, 6, // 4739: case 0x20: {
3536 OPC_CheckPredicate, 20, // 4741: check predicate 20
3537 OPC_Decode, 173, 124, 20, // 4743: decode to SRAIW using decoder 20
3538 // 4743: }
3539 48, 0, // 4747: case 0x30: {
3540 OPC_CheckPredicate, 45, // 4749: check predicate 45
3541 OPC_Decode, 145, 123, 20, // 4751: decode to RORIW using decoder 20
3542 // 4751: }
3543 // 4751: } // switch Inst[31:25]
3544 // 4751: }
3545 6, 0, // 4755: case 0x6: {
3546 OPC_SwitchField, 25, 6, // 4757: switch Inst[30:25] {
3547 0, 124, // 4760: case 0x0: {
3548 OPC_SwitchField, 15, 1, // 4762: switch Inst[15] {
3549 0, 52, // 4765: case 0x0: {
3550 OPC_SwitchField, 31, 1, // 4767: switch Inst[31] {
3551 0, 31, // 4770: case 0x0: {
3552 OPC_SwitchField, 24, 1, // 4772: switch Inst[24] {
3553 0, 14, // 4775: case 0x0: {
3554 OPC_CheckPredicate, 43, // 4777: check predicate 43
3555 OPC_CheckField, 23, 1, 1, // 4779: check Inst[23] == 0x1
3556 OPC_CheckField, 7, 1, 0, // 4783: check Inst[7] == 0x0
3557 OPC_Decode, 227, 120, 42, // 4787: decode to PSLLI_DB using decoder 42
3558 // 4787: }
3559 1, 0, // 4791: case 0x1: {
3560 OPC_CheckPredicate, 43, // 4793: check predicate 43
3561 OPC_CheckField, 7, 1, 0, // 4795: check Inst[7] == 0x0
3562 OPC_Decode, 228, 120, 43, // 4799: decode to PSLLI_DH using decoder 43
3563 // 4799: }
3564 // 4799: } // switch Inst[24]
3565 // 4799: }
3566 1, 0, // 4803: case 0x1: {
3567 OPC_CheckPredicate, 43, // 4805: check predicate 43
3568 OPC_CheckField, 20, 1, 0, // 4807: check Inst[20] == 0x0
3569 OPC_CheckField, 7, 1, 0, // 4811: check Inst[7] == 0x0
3570 OPC_Decode, 170, 118, 44, // 4815: decode to PADD_DH using decoder 44
3571 // 4815: }
3572 // 4815: } // switch Inst[31]
3573 // 4815: }
3574 1, 0, // 4819: case 0x1: {
3575 OPC_SwitchField, 31, 1, // 4821: switch Inst[31] {
3576 0, 31, // 4824: case 0x0: {
3577 OPC_SwitchField, 24, 1, // 4826: switch Inst[24] {
3578 0, 14, // 4829: case 0x0: {
3579 OPC_CheckPredicate, 43, // 4831: check predicate 43
3580 OPC_CheckField, 23, 1, 1, // 4833: check Inst[23] == 0x1
3581 OPC_CheckField, 7, 1, 0, // 4837: check Inst[7] == 0x0
3582 OPC_Decode, 255, 120, 42, // 4841: decode to PSRLI_DB using decoder 42
3583 // 4841: }
3584 1, 0, // 4845: case 0x1: {
3585 OPC_CheckPredicate, 43, // 4847: check predicate 43
3586 OPC_CheckField, 7, 1, 0, // 4849: check Inst[7] == 0x0
3587 OPC_Decode, 128, 121, 43, // 4853: decode to PSRLI_DH using decoder 43
3588 // 4853: }
3589 // 4853: } // switch Inst[24]
3590 // 4853: }
3591 1, 0, // 4857: case 0x1: {
3592 OPC_SwitchField, 20, 1, // 4859: switch Inst[20] {
3593 0, 10, // 4862: case 0x0: {
3594 OPC_CheckPredicate, 43, // 4864: check predicate 43
3595 OPC_CheckField, 7, 1, 0, // 4866: check Inst[7] == 0x0
3596 OPC_Decode, 164, 120, 44, // 4870: decode to PPAIRE_DB using decoder 44
3597 // 4870: }
3598 1, 0, // 4874: case 0x1: {
3599 OPC_CheckPredicate, 43, // 4876: check predicate 43
3600 OPC_CheckField, 7, 1, 0, // 4878: check Inst[7] == 0x0
3601 OPC_Decode, 193, 118, 44, // 4882: decode to PAS_DHX using decoder 44
3602 // 4882: }
3603 // 4882: } // switch Inst[20]
3604 // 4882: }
3605 // 4882: } // switch Inst[31]
3606 // 4882: }
3607 // 4882: } // switch Inst[15]
3608 // 4882: }
3609 1, 69, // 4886: case 0x1: {
3610 OPC_SwitchField, 15, 1, // 4888: switch Inst[15] {
3611 0, 31, // 4891: case 0x0: {
3612 OPC_SwitchField, 31, 1, // 4893: switch Inst[31] {
3613 0, 10, // 4896: case 0x0: {
3614 OPC_CheckPredicate, 43, // 4898: check predicate 43
3615 OPC_CheckField, 7, 1, 0, // 4900: check Inst[7] == 0x0
3616 OPC_Decode, 229, 120, 45, // 4904: decode to PSLLI_DW using decoder 45
3617 // 4904: }
3618 1, 0, // 4908: case 0x1: {
3619 OPC_CheckPredicate, 43, // 4910: check predicate 43
3620 OPC_CheckField, 20, 1, 0, // 4912: check Inst[20] == 0x0
3621 OPC_CheckField, 7, 1, 0, // 4916: check Inst[7] == 0x0
3622 OPC_Decode, 172, 118, 44, // 4920: decode to PADD_DW using decoder 44
3623 // 4920: }
3624 // 4920: } // switch Inst[31]
3625 // 4920: }
3626 1, 0, // 4924: case 0x1: {
3627 OPC_SwitchField, 31, 1, // 4926: switch Inst[31] {
3628 0, 10, // 4929: case 0x0: {
3629 OPC_CheckPredicate, 43, // 4931: check predicate 43
3630 OPC_CheckField, 7, 1, 0, // 4933: check Inst[7] == 0x0
3631 OPC_Decode, 129, 121, 45, // 4937: decode to PSRLI_DW using decoder 45
3632 // 4937: }
3633 1, 0, // 4941: case 0x1: {
3634 OPC_CheckPredicate, 43, // 4943: check predicate 43
3635 OPC_CheckField, 20, 1, 0, // 4945: check Inst[20] == 0x0
3636 OPC_CheckField, 7, 1, 0, // 4949: check Inst[7] == 0x0
3637 OPC_Decode, 165, 120, 44, // 4953: decode to PPAIRE_DH using decoder 44
3638 // 4953: }
3639 // 4953: } // switch Inst[31]
3640 // 4953: }
3641 // 4953: } // switch Inst[15]
3642 // 4953: }
3643 2, 43, // 4957: case 0x2: {
3644 OPC_SwitchField, 15, 1, // 4959: switch Inst[15] {
3645 0, 18, // 4962: case 0x0: {
3646 OPC_CheckPredicate, 43, // 4964: check predicate 43
3647 OPC_CheckField, 31, 1, 1, // 4966: check Inst[31] == 0x1
3648 OPC_CheckField, 20, 1, 0, // 4970: check Inst[20] == 0x0
3649 OPC_CheckField, 7, 1, 0, // 4974: check Inst[7] == 0x0
3650 OPC_Decode, 168, 118, 44, // 4978: decode to PADD_DB using decoder 44
3651 // 4978: }
3652 1, 0, // 4982: case 0x1: {
3653 OPC_CheckPredicate, 43, // 4984: check predicate 43
3654 OPC_CheckField, 31, 1, 1, // 4986: check Inst[31] == 0x1
3655 OPC_CheckField, 20, 1, 1, // 4990: check Inst[20] == 0x1
3656 OPC_CheckField, 7, 1, 0, // 4994: check Inst[7] == 0x0
3657 OPC_Decode, 213, 120, 44, // 4998: decode to PSA_DHX using decoder 44
3658 // 4998: }
3659 // 4998: } // switch Inst[15]
3660 // 4998: }
3661 3, 22, // 5002: case 0x3: {
3662 OPC_CheckPredicate, 43, // 5004: check predicate 43
3663 OPC_CheckField, 31, 1, 1, // 5006: check Inst[31] == 0x1
3664 OPC_CheckField, 20, 1, 0, // 5010: check Inst[20] == 0x0
3665 OPC_CheckField, 15, 1, 0, // 5014: check Inst[15] == 0x0
3666 OPC_CheckField, 7, 1, 0, // 5018: check Inst[7] == 0x0
3667 OPC_Decode, 156, 107, 44, // 5022: decode to ADDD using decoder 44
3668 // 5022: }
3669 4, 27, // 5026: case 0x4: {
3670 OPC_SwitchField, 15, 1, // 5028: switch Inst[15] {
3671 0, 10, // 5031: case 0x0: {
3672 OPC_CheckPredicate, 43, // 5033: check predicate 43
3673 OPC_CheckField, 7, 1, 0, // 5035: check Inst[7] == 0x0
3674 OPC_Decode, 234, 120, 46, // 5039: decode to PSLL_DHS using decoder 46
3675 // 5039: }
3676 1, 0, // 5043: case 0x1: {
3677 OPC_CheckPredicate, 43, // 5045: check predicate 43
3678 OPC_CheckField, 7, 1, 0, // 5047: check Inst[7] == 0x0
3679 OPC_Decode, 134, 121, 46, // 5051: decode to PSRL_DHS using decoder 46
3680 // 5051: }
3681 // 5051: } // switch Inst[15]
3682 // 5051: }
3683 5, 27, // 5055: case 0x5: {
3684 OPC_SwitchField, 15, 1, // 5057: switch Inst[15] {
3685 0, 10, // 5060: case 0x0: {
3686 OPC_CheckPredicate, 43, // 5062: check predicate 43
3687 OPC_CheckField, 7, 1, 0, // 5064: check Inst[7] == 0x0
3688 OPC_Decode, 235, 120, 46, // 5068: decode to PSLL_DWS using decoder 46
3689 // 5068: }
3690 1, 0, // 5072: case 0x1: {
3691 OPC_CheckPredicate, 43, // 5074: check predicate 43
3692 OPC_CheckField, 7, 1, 0, // 5076: check Inst[7] == 0x0
3693 OPC_Decode, 135, 121, 46, // 5080: decode to PSRL_DWS using decoder 46
3694 // 5080: }
3695 // 5080: } // switch Inst[15]
3696 // 5080: }
3697 6, 27, // 5084: case 0x6: {
3698 OPC_SwitchField, 15, 1, // 5086: switch Inst[15] {
3699 0, 10, // 5089: case 0x0: {
3700 OPC_CheckPredicate, 43, // 5091: check predicate 43
3701 OPC_CheckField, 7, 1, 0, // 5093: check Inst[7] == 0x0
3702 OPC_Decode, 233, 120, 46, // 5097: decode to PSLL_DBS using decoder 46
3703 // 5097: }
3704 1, 0, // 5101: case 0x1: {
3705 OPC_CheckPredicate, 43, // 5103: check predicate 43
3706 OPC_CheckField, 7, 1, 0, // 5105: check Inst[7] == 0x0
3707 OPC_Decode, 133, 121, 46, // 5109: decode to PSRL_DBS using decoder 46
3708 // 5109: }
3709 // 5109: } // switch Inst[15]
3710 // 5109: }
3711 8, 60, // 5113: case 0x8: {
3712 OPC_SwitchField, 15, 1, // 5115: switch Inst[15] {
3713 0, 18, // 5118: case 0x0: {
3714 OPC_CheckPredicate, 43, // 5120: check predicate 43
3715 OPC_CheckField, 31, 1, 1, // 5122: check Inst[31] == 0x1
3716 OPC_CheckField, 20, 1, 0, // 5126: check Inst[20] == 0x0
3717 OPC_CheckField, 7, 1, 0, // 5130: check Inst[7] == 0x0
3718 OPC_Decode, 202, 120, 44, // 5134: decode to PSADD_DH using decoder 44
3719 // 5134: }
3720 1, 0, // 5138: case 0x1: {
3721 OPC_SwitchField, 20, 1, // 5140: switch Inst[20] {
3722 0, 14, // 5143: case 0x0: {
3723 OPC_CheckPredicate, 43, // 5145: check predicate 43
3724 OPC_CheckField, 31, 1, 1, // 5147: check Inst[31] == 0x1
3725 OPC_CheckField, 7, 1, 0, // 5151: check Inst[7] == 0x0
3726 OPC_Decode, 159, 120, 44, // 5155: decode to PPAIREO_DB using decoder 44
3727 // 5155: }
3728 1, 0, // 5159: case 0x1: {
3729 OPC_CheckPredicate, 43, // 5161: check predicate 43
3730 OPC_CheckField, 31, 1, 1, // 5163: check Inst[31] == 0x1
3731 OPC_CheckField, 7, 1, 0, // 5167: check Inst[7] == 0x0
3732 OPC_Decode, 206, 120, 44, // 5171: decode to PSAS_DHX using decoder 44
3733 // 5171: }
3734 // 5171: } // switch Inst[20]
3735 // 5171: }
3736 // 5171: } // switch Inst[15]
3737 // 5171: }
3738 9, 43, // 5175: case 0x9: {
3739 OPC_SwitchField, 15, 1, // 5177: switch Inst[15] {
3740 0, 18, // 5180: case 0x0: {
3741 OPC_CheckPredicate, 43, // 5182: check predicate 43
3742 OPC_CheckField, 31, 1, 1, // 5184: check Inst[31] == 0x1
3743 OPC_CheckField, 20, 1, 0, // 5188: check Inst[20] == 0x0
3744 OPC_CheckField, 7, 1, 0, // 5192: check Inst[7] == 0x0
3745 OPC_Decode, 203, 120, 44, // 5196: decode to PSADD_DW using decoder 44
3746 // 5196: }
3747 1, 0, // 5200: case 0x1: {
3748 OPC_CheckPredicate, 43, // 5202: check predicate 43
3749 OPC_CheckField, 31, 1, 1, // 5204: check Inst[31] == 0x1
3750 OPC_CheckField, 20, 1, 0, // 5208: check Inst[20] == 0x0
3751 OPC_CheckField, 7, 1, 0, // 5212: check Inst[7] == 0x0
3752 OPC_Decode, 160, 120, 44, // 5216: decode to PPAIREO_DH using decoder 44
3753 // 5216: }
3754 // 5216: } // switch Inst[15]
3755 // 5216: }
3756 10, 43, // 5220: case 0xa: {
3757 OPC_SwitchField, 15, 1, // 5222: switch Inst[15] {
3758 0, 18, // 5225: case 0x0: {
3759 OPC_CheckPredicate, 43, // 5227: check predicate 43
3760 OPC_CheckField, 31, 1, 1, // 5229: check Inst[31] == 0x1
3761 OPC_CheckField, 20, 1, 0, // 5233: check Inst[20] == 0x0
3762 OPC_CheckField, 7, 1, 0, // 5237: check Inst[7] == 0x0
3763 OPC_Decode, 201, 120, 44, // 5241: decode to PSADD_DB using decoder 44
3764 // 5241: }
3765 1, 0, // 5245: case 0x1: {
3766 OPC_CheckPredicate, 43, // 5247: check predicate 43
3767 OPC_CheckField, 31, 1, 1, // 5249: check Inst[31] == 0x1
3768 OPC_CheckField, 20, 1, 1, // 5253: check Inst[20] == 0x1
3769 OPC_CheckField, 7, 1, 0, // 5257: check Inst[7] == 0x0
3770 OPC_Decode, 138, 121, 44, // 5261: decode to PSSA_DHX using decoder 44
3771 // 5261: }
3772 // 5261: } // switch Inst[15]
3773 // 5261: }
3774 12, 51, // 5265: case 0xc: {
3775 OPC_SwitchField, 15, 1, // 5267: switch Inst[15] {
3776 0, 26, // 5270: case 0x0: {
3777 OPC_CheckField, 7, 1, 0, // 5272: check Inst[7] == 0x0
3778 OPC_Scope, 14, // 5276: try {
3779 OPC_CheckField, 20, 1, 0, // 5278: check Inst[20] == 0x0
3780 OPC_CheckPredicate, 43, // 5282: check predicate 43
3781 OPC_CheckField, 31, 1, 1, // 5284: check Inst[31] == 0x1
3782 OPC_Decode, 146, 118, 44, // 5288: decode to PAADD_DH using decoder 44
3783 // 5288: } else try {
3784 OPC_CheckPredicate, 43, // 5292: check predicate 43
3785 OPC_Decode, 171, 118, 46, // 5294: decode to PADD_DHS using decoder 46
3786 // 5294: }
3787 // 5294: }
3788 1, 0, // 5298: case 0x1: {
3789 OPC_CheckPredicate, 43, // 5300: check predicate 43
3790 OPC_CheckField, 31, 1, 1, // 5302: check Inst[31] == 0x1
3791 OPC_CheckField, 20, 1, 1, // 5306: check Inst[20] == 0x1
3792 OPC_CheckField, 7, 1, 0, // 5310: check Inst[7] == 0x0
3793 OPC_Decode, 150, 118, 44, // 5314: decode to PAAS_DHX using decoder 44
3794 // 5314: }
3795 // 5314: } // switch Inst[15]
3796 // 5314: }
3797 13, 30, // 5318: case 0xd: {
3798 OPC_CheckField, 7, 1, 0, // 5320: check Inst[7] == 0x0
3799 OPC_CheckField, 15, 1, 0, // 5324: check Inst[15] == 0x0
3800 OPC_Scope, 14, // 5328: try {
3801 OPC_CheckField, 20, 1, 0, // 5330: check Inst[20] == 0x0
3802 OPC_CheckPredicate, 43, // 5334: check predicate 43
3803 OPC_CheckField, 31, 1, 1, // 5336: check Inst[31] == 0x1
3804 OPC_Decode, 147, 118, 44, // 5340: decode to PAADD_DW using decoder 44
3805 // 5340: } else try {
3806 OPC_CheckPredicate, 43, // 5344: check predicate 43
3807 OPC_Decode, 173, 118, 46, // 5346: decode to PADD_DWS using decoder 46
3808 // 5346: }
3809 // 5346: }
3810 14, 51, // 5350: case 0xe: {
3811 OPC_SwitchField, 15, 1, // 5352: switch Inst[15] {
3812 0, 26, // 5355: case 0x0: {
3813 OPC_CheckField, 7, 1, 0, // 5357: check Inst[7] == 0x0
3814 OPC_Scope, 14, // 5361: try {
3815 OPC_CheckField, 20, 1, 0, // 5363: check Inst[20] == 0x0
3816 OPC_CheckPredicate, 43, // 5367: check predicate 43
3817 OPC_CheckField, 31, 1, 1, // 5369: check Inst[31] == 0x1
3818 OPC_Decode, 145, 118, 44, // 5373: decode to PAADD_DB using decoder 44
3819 // 5373: } else try {
3820 OPC_CheckPredicate, 43, // 5377: check predicate 43
3821 OPC_Decode, 169, 118, 46, // 5379: decode to PADD_DBS using decoder 46
3822 // 5379: }
3823 // 5379: }
3824 1, 0, // 5383: case 0x1: {
3825 OPC_CheckPredicate, 43, // 5385: check predicate 43
3826 OPC_CheckField, 31, 1, 1, // 5387: check Inst[31] == 0x1
3827 OPC_CheckField, 20, 1, 1, // 5391: check Inst[20] == 0x1
3828 OPC_CheckField, 7, 1, 0, // 5395: check Inst[7] == 0x0
3829 OPC_Decode, 178, 118, 44, // 5399: decode to PASA_DHX using decoder 44
3830 // 5399: }
3831 // 5399: } // switch Inst[15]
3832 // 5399: }
3833 16, 60, // 5403: case 0x10: {
3834 OPC_SwitchField, 15, 1, // 5405: switch Inst[15] {
3835 0, 18, // 5408: case 0x0: {
3836 OPC_CheckPredicate, 43, // 5410: check predicate 43
3837 OPC_CheckField, 31, 1, 1, // 5412: check Inst[31] == 0x1
3838 OPC_CheckField, 20, 1, 1, // 5416: check Inst[20] == 0x1
3839 OPC_CheckField, 7, 1, 0, // 5420: check Inst[7] == 0x0
3840 OPC_Decode, 222, 120, 44, // 5424: decode to PSH1ADD_DH using decoder 44
3841 // 5424: }
3842 1, 0, // 5428: case 0x1: {
3843 OPC_SwitchField, 31, 1, // 5430: switch Inst[31] {
3844 0, 14, // 5433: case 0x0: {
3845 OPC_CheckPredicate, 43, // 5435: check predicate 43
3846 OPC_CheckField, 24, 1, 1, // 5437: check Inst[24] == 0x1
3847 OPC_CheckField, 7, 1, 0, // 5441: check Inst[7] == 0x0
3848 OPC_Decode, 183, 121, 43, // 5445: decode to PUSATI_DH using decoder 43
3849 // 5445: }
3850 1, 0, // 5449: case 0x1: {
3851 OPC_CheckPredicate, 43, // 5451: check predicate 43
3852 OPC_CheckField, 20, 1, 0, // 5453: check Inst[20] == 0x0
3853 OPC_CheckField, 7, 1, 0, // 5457: check Inst[7] == 0x0
3854 OPC_Decode, 168, 120, 44, // 5461: decode to PPAIROE_DB using decoder 44
3855 // 5461: }
3856 // 5461: } // switch Inst[31]
3857 // 5461: }
3858 // 5461: } // switch Inst[15]
3859 // 5461: }
3860 17, 56, // 5465: case 0x11: {
3861 OPC_SwitchField, 15, 1, // 5467: switch Inst[15] {
3862 0, 18, // 5470: case 0x0: {
3863 OPC_CheckPredicate, 43, // 5472: check predicate 43
3864 OPC_CheckField, 31, 1, 1, // 5474: check Inst[31] == 0x1
3865 OPC_CheckField, 20, 1, 1, // 5478: check Inst[20] == 0x1
3866 OPC_CheckField, 7, 1, 0, // 5482: check Inst[7] == 0x0
3867 OPC_Decode, 223, 120, 44, // 5486: decode to PSH1ADD_DW using decoder 44
3868 // 5486: }
3869 1, 0, // 5490: case 0x1: {
3870 OPC_SwitchField, 31, 1, // 5492: switch Inst[31] {
3871 0, 10, // 5495: case 0x0: {
3872 OPC_CheckPredicate, 43, // 5497: check predicate 43
3873 OPC_CheckField, 7, 1, 0, // 5499: check Inst[7] == 0x0
3874 OPC_Decode, 184, 121, 45, // 5503: decode to PUSATI_DW using decoder 45
3875 // 5503: }
3876 1, 0, // 5507: case 0x1: {
3877 OPC_CheckPredicate, 43, // 5509: check predicate 43
3878 OPC_CheckField, 20, 1, 0, // 5511: check Inst[20] == 0x0
3879 OPC_CheckField, 7, 1, 0, // 5515: check Inst[7] == 0x0
3880 OPC_Decode, 169, 120, 44, // 5519: decode to PPAIROE_DH using decoder 44
3881 // 5519: }
3882 // 5519: } // switch Inst[31]
3883 // 5519: }
3884 // 5519: } // switch Inst[15]
3885 // 5519: }
3886 20, 14, // 5523: case 0x14: {
3887 OPC_CheckPredicate, 43, // 5525: check predicate 43
3888 OPC_CheckField, 15, 1, 0, // 5527: check Inst[15] == 0x0
3889 OPC_CheckField, 7, 1, 0, // 5531: check Inst[7] == 0x0
3890 OPC_Decode, 157, 121, 46, // 5535: decode to PSSHL_DHS using decoder 46
3891 // 5535: }
3892 21, 14, // 5539: case 0x15: {
3893 OPC_CheckPredicate, 43, // 5541: check predicate 43
3894 OPC_CheckField, 15, 1, 0, // 5543: check Inst[15] == 0x0
3895 OPC_CheckField, 7, 1, 0, // 5547: check Inst[7] == 0x0
3896 OPC_Decode, 158, 121, 46, // 5551: decode to PSSHL_DWS using decoder 46
3897 // 5551: }
3898 24, 60, // 5555: case 0x18: {
3899 OPC_SwitchField, 15, 1, // 5557: switch Inst[15] {
3900 0, 35, // 5560: case 0x0: {
3901 OPC_SwitchField, 20, 1, // 5562: switch Inst[20] {
3902 0, 14, // 5565: case 0x0: {
3903 OPC_CheckPredicate, 43, // 5567: check predicate 43
3904 OPC_CheckField, 31, 1, 1, // 5569: check Inst[31] == 0x1
3905 OPC_CheckField, 7, 1, 0, // 5573: check Inst[7] == 0x0
3906 OPC_Decode, 196, 120, 44, // 5577: decode to PSADDU_DH using decoder 44
3907 // 5577: }
3908 1, 0, // 5581: case 0x1: {
3909 OPC_CheckPredicate, 43, // 5583: check predicate 43
3910 OPC_CheckField, 31, 1, 1, // 5585: check Inst[31] == 0x1
3911 OPC_CheckField, 7, 1, 0, // 5589: check Inst[7] == 0x0
3912 OPC_Decode, 141, 121, 44, // 5593: decode to PSSH1SADD_DH using decoder 44
3913 // 5593: }
3914 // 5593: } // switch Inst[20]
3915 // 5593: }
3916 1, 0, // 5597: case 0x1: {
3917 OPC_CheckPredicate, 43, // 5599: check predicate 43
3918 OPC_CheckField, 31, 1, 1, // 5601: check Inst[31] == 0x1
3919 OPC_CheckField, 20, 1, 0, // 5605: check Inst[20] == 0x0
3920 OPC_CheckField, 7, 1, 0, // 5609: check Inst[7] == 0x0
3921 OPC_Decode, 173, 120, 44, // 5613: decode to PPAIRO_DB using decoder 44
3922 // 5613: }
3923 // 5613: } // switch Inst[15]
3924 // 5613: }
3925 25, 60, // 5617: case 0x19: {
3926 OPC_SwitchField, 15, 1, // 5619: switch Inst[15] {
3927 0, 35, // 5622: case 0x0: {
3928 OPC_SwitchField, 20, 1, // 5624: switch Inst[20] {
3929 0, 14, // 5627: case 0x0: {
3930 OPC_CheckPredicate, 43, // 5629: check predicate 43
3931 OPC_CheckField, 31, 1, 1, // 5631: check Inst[31] == 0x1
3932 OPC_CheckField, 7, 1, 0, // 5635: check Inst[7] == 0x0
3933 OPC_Decode, 197, 120, 44, // 5639: decode to PSADDU_DW using decoder 44
3934 // 5639: }
3935 1, 0, // 5643: case 0x1: {
3936 OPC_CheckPredicate, 43, // 5645: check predicate 43
3937 OPC_CheckField, 31, 1, 1, // 5647: check Inst[31] == 0x1
3938 OPC_CheckField, 7, 1, 0, // 5651: check Inst[7] == 0x0
3939 OPC_Decode, 142, 121, 44, // 5655: decode to PSSH1SADD_DW using decoder 44
3940 // 5655: }
3941 // 5655: } // switch Inst[20]
3942 // 5655: }
3943 1, 0, // 5659: case 0x1: {
3944 OPC_CheckPredicate, 43, // 5661: check predicate 43
3945 OPC_CheckField, 31, 1, 1, // 5663: check Inst[31] == 0x1
3946 OPC_CheckField, 20, 1, 0, // 5667: check Inst[20] == 0x0
3947 OPC_CheckField, 7, 1, 0, // 5671: check Inst[7] == 0x0
3948 OPC_Decode, 174, 120, 44, // 5675: decode to PPAIRO_DH using decoder 44
3949 // 5675: }
3950 // 5675: } // switch Inst[15]
3951 // 5675: }
3952 26, 22, // 5679: case 0x1a: {
3953 OPC_CheckPredicate, 43, // 5681: check predicate 43
3954 OPC_CheckField, 31, 1, 1, // 5683: check Inst[31] == 0x1
3955 OPC_CheckField, 20, 1, 0, // 5687: check Inst[20] == 0x0
3956 OPC_CheckField, 15, 1, 0, // 5691: check Inst[15] == 0x0
3957 OPC_CheckField, 7, 1, 0, // 5695: check Inst[7] == 0x0
3958 OPC_Decode, 195, 120, 44, // 5699: decode to PSADDU_DB using decoder 44
3959 // 5699: }
3960 28, 30, // 5703: case 0x1c: {
3961 OPC_CheckField, 7, 1, 0, // 5705: check Inst[7] == 0x0
3962 OPC_CheckField, 15, 1, 0, // 5709: check Inst[15] == 0x0
3963 OPC_Scope, 14, // 5713: try {
3964 OPC_CheckField, 20, 1, 0, // 5715: check Inst[20] == 0x0
3965 OPC_CheckPredicate, 43, // 5719: check predicate 43
3966 OPC_CheckField, 31, 1, 1, // 5721: check Inst[31] == 0x1
3967 OPC_Decode, 140, 118, 44, // 5725: decode to PAADDU_DH using decoder 44
3968 // 5725: } else try {
3969 OPC_CheckPredicate, 43, // 5729: check predicate 43
3970 OPC_Decode, 153, 121, 46, // 5731: decode to PSSHLR_DHS using decoder 46
3971 // 5731: }
3972 // 5731: }
3973 29, 30, // 5735: case 0x1d: {
3974 OPC_CheckField, 7, 1, 0, // 5737: check Inst[7] == 0x0
3975 OPC_CheckField, 15, 1, 0, // 5741: check Inst[15] == 0x0
3976 OPC_Scope, 14, // 5745: try {
3977 OPC_CheckField, 20, 1, 0, // 5747: check Inst[20] == 0x0
3978 OPC_CheckPredicate, 43, // 5751: check predicate 43
3979 OPC_CheckField, 31, 1, 1, // 5753: check Inst[31] == 0x1
3980 OPC_Decode, 141, 118, 44, // 5757: decode to PAADDU_DW using decoder 44
3981 // 5757: } else try {
3982 OPC_CheckPredicate, 43, // 5761: check predicate 43
3983 OPC_Decode, 154, 121, 46, // 5763: decode to PSSHLR_DWS using decoder 46
3984 // 5763: }
3985 // 5763: }
3986 30, 22, // 5767: case 0x1e: {
3987 OPC_CheckPredicate, 43, // 5769: check predicate 43
3988 OPC_CheckField, 31, 1, 1, // 5771: check Inst[31] == 0x1
3989 OPC_CheckField, 20, 1, 0, // 5775: check Inst[20] == 0x0
3990 OPC_CheckField, 15, 1, 0, // 5779: check Inst[15] == 0x0
3991 OPC_CheckField, 7, 1, 0, // 5783: check Inst[7] == 0x0
3992 OPC_Decode, 139, 118, 44, // 5787: decode to PAADDU_DB using decoder 44
3993 // 5787: }
3994 32, 77, // 5791: case 0x20: {
3995 OPC_SwitchField, 15, 1, // 5793: switch Inst[15] {
3996 0, 18, // 5796: case 0x0: {
3997 OPC_CheckPredicate, 43, // 5798: check predicate 43
3998 OPC_CheckField, 31, 1, 1, // 5800: check Inst[31] == 0x1
3999 OPC_CheckField, 20, 1, 0, // 5804: check Inst[20] == 0x0
4000 OPC_CheckField, 7, 1, 0, // 5808: check Inst[7] == 0x0
4001 OPC_Decode, 179, 121, 44, // 5812: decode to PSUB_DH using decoder 44
4002 // 5812: }
4003 1, 0, // 5816: case 0x1: {
4004 OPC_SwitchField, 31, 1, // 5818: switch Inst[31] {
4005 0, 31, // 5821: case 0x0: {
4006 OPC_SwitchField, 24, 1, // 5823: switch Inst[24] {
4007 0, 14, // 5826: case 0x0: {
4008 OPC_CheckPredicate, 43, // 5828: check predicate 43
4009 OPC_CheckField, 23, 1, 1, // 5830: check Inst[23] == 0x1
4010 OPC_CheckField, 7, 1, 0, // 5834: check Inst[7] == 0x0
4011 OPC_Decode, 239, 120, 42, // 5838: decode to PSRAI_DB using decoder 42
4012 // 5838: }
4013 1, 0, // 5842: case 0x1: {
4014 OPC_CheckPredicate, 43, // 5844: check predicate 43
4015 OPC_CheckField, 7, 1, 0, // 5846: check Inst[7] == 0x0
4016 OPC_Decode, 240, 120, 43, // 5850: decode to PSRAI_DH using decoder 43
4017 // 5850: }
4018 // 5850: } // switch Inst[24]
4019 // 5850: }
4020 1, 0, // 5854: case 0x1: {
4021 OPC_CheckPredicate, 43, // 5856: check predicate 43
4022 OPC_CheckField, 20, 1, 1, // 5858: check Inst[20] == 0x1
4023 OPC_CheckField, 7, 1, 0, // 5862: check Inst[7] == 0x0
4024 OPC_Decode, 196, 119, 44, // 5866: decode to PMSEQ_DH using decoder 44
4025 // 5866: }
4026 // 5866: } // switch Inst[31]
4027 // 5866: }
4028 // 5866: } // switch Inst[15]
4029 // 5866: }
4030 33, 56, // 5870: case 0x21: {
4031 OPC_SwitchField, 15, 1, // 5872: switch Inst[15] {
4032 0, 18, // 5875: case 0x0: {
4033 OPC_CheckPredicate, 43, // 5877: check predicate 43
4034 OPC_CheckField, 31, 1, 1, // 5879: check Inst[31] == 0x1
4035 OPC_CheckField, 20, 1, 0, // 5883: check Inst[20] == 0x0
4036 OPC_CheckField, 7, 1, 0, // 5887: check Inst[7] == 0x0
4037 OPC_Decode, 180, 121, 44, // 5891: decode to PSUB_DW using decoder 44
4038 // 5891: }
4039 1, 0, // 5895: case 0x1: {
4040 OPC_SwitchField, 31, 1, // 5897: switch Inst[31] {
4041 0, 10, // 5900: case 0x0: {
4042 OPC_CheckPredicate, 43, // 5902: check predicate 43
4043 OPC_CheckField, 7, 1, 0, // 5904: check Inst[7] == 0x0
4044 OPC_Decode, 241, 120, 45, // 5908: decode to PSRAI_DW using decoder 45
4045 // 5908: }
4046 1, 0, // 5912: case 0x1: {
4047 OPC_CheckPredicate, 43, // 5914: check predicate 43
4048 OPC_CheckField, 20, 1, 1, // 5916: check Inst[20] == 0x1
4049 OPC_CheckField, 7, 1, 0, // 5920: check Inst[7] == 0x0
4050 OPC_Decode, 197, 119, 44, // 5924: decode to PMSEQ_DW using decoder 44
4051 // 5924: }
4052 // 5924: } // switch Inst[31]
4053 // 5924: }
4054 // 5924: } // switch Inst[15]
4055 // 5924: }
4056 34, 43, // 5928: case 0x22: {
4057 OPC_SwitchField, 15, 1, // 5930: switch Inst[15] {
4058 0, 18, // 5933: case 0x0: {
4059 OPC_CheckPredicate, 43, // 5935: check predicate 43
4060 OPC_CheckField, 31, 1, 1, // 5937: check Inst[31] == 0x1
4061 OPC_CheckField, 20, 1, 0, // 5941: check Inst[20] == 0x0
4062 OPC_CheckField, 7, 1, 0, // 5945: check Inst[7] == 0x0
4063 OPC_Decode, 178, 121, 44, // 5949: decode to PSUB_DB using decoder 44
4064 // 5949: }
4065 1, 0, // 5953: case 0x1: {
4066 OPC_CheckPredicate, 43, // 5955: check predicate 43
4067 OPC_CheckField, 31, 1, 1, // 5957: check Inst[31] == 0x1
4068 OPC_CheckField, 20, 1, 1, // 5961: check Inst[20] == 0x1
4069 OPC_CheckField, 7, 1, 0, // 5965: check Inst[7] == 0x0
4070 OPC_Decode, 195, 119, 44, // 5969: decode to PMSEQ_DB using decoder 44
4071 // 5969: }
4072 // 5969: } // switch Inst[15]
4073 // 5969: }
4074 35, 22, // 5973: case 0x23: {
4075 OPC_CheckPredicate, 43, // 5975: check predicate 43
4076 OPC_CheckField, 31, 1, 1, // 5977: check Inst[31] == 0x1
4077 OPC_CheckField, 20, 1, 0, // 5981: check Inst[20] == 0x0
4078 OPC_CheckField, 15, 1, 0, // 5985: check Inst[15] == 0x0
4079 OPC_CheckField, 7, 1, 0, // 5989: check Inst[7] == 0x0
4080 OPC_Decode, 203, 124, 44, // 5993: decode to SUBD using decoder 44
4081 // 5993: }
4082 36, 35, // 5997: case 0x24: {
4083 OPC_SwitchField, 15, 1, // 5999: switch Inst[15] {
4084 0, 18, // 6002: case 0x0: {
4085 OPC_CheckPredicate, 43, // 6004: check predicate 43
4086 OPC_CheckField, 31, 1, 1, // 6006: check Inst[31] == 0x1
4087 OPC_CheckField, 20, 1, 0, // 6010: check Inst[20] == 0x0
4088 OPC_CheckField, 7, 1, 0, // 6014: check Inst[7] == 0x0
4089 OPC_Decode, 161, 118, 44, // 6018: decode to PABD_DH using decoder 44
4090 // 6018: }
4091 1, 0, // 6022: case 0x1: {
4092 OPC_CheckPredicate, 43, // 6024: check predicate 43
4093 OPC_CheckField, 7, 1, 0, // 6026: check Inst[7] == 0x0
4094 OPC_Decode, 250, 120, 46, // 6030: decode to PSRA_DHS using decoder 46
4095 // 6030: }
4096 // 6030: } // switch Inst[15]
4097 // 6030: }
4098 37, 14, // 6034: case 0x25: {
4099 OPC_CheckPredicate, 43, // 6036: check predicate 43
4100 OPC_CheckField, 15, 1, 1, // 6038: check Inst[15] == 0x1
4101 OPC_CheckField, 7, 1, 0, // 6042: check Inst[7] == 0x0
4102 OPC_Decode, 251, 120, 46, // 6046: decode to PSRA_DWS using decoder 46
4103 // 6046: }
4104 38, 35, // 6050: case 0x26: {
4105 OPC_SwitchField, 15, 1, // 6052: switch Inst[15] {
4106 0, 18, // 6055: case 0x0: {
4107 OPC_CheckPredicate, 43, // 6057: check predicate 43
4108 OPC_CheckField, 31, 1, 1, // 6059: check Inst[31] == 0x1
4109 OPC_CheckField, 20, 1, 0, // 6063: check Inst[20] == 0x0
4110 OPC_CheckField, 7, 1, 0, // 6067: check Inst[7] == 0x0
4111 OPC_Decode, 160, 118, 44, // 6071: decode to PABD_DB using decoder 44
4112 // 6071: }
4113 1, 0, // 6075: case 0x1: {
4114 OPC_CheckPredicate, 43, // 6077: check predicate 43
4115 OPC_CheckField, 7, 1, 0, // 6079: check Inst[7] == 0x0
4116 OPC_Decode, 249, 120, 46, // 6083: decode to PSRA_DBS using decoder 46
4117 // 6083: }
4118 // 6083: } // switch Inst[15]
4119 // 6083: }
4120 40, 77, // 6087: case 0x28: {
4121 OPC_SwitchField, 15, 1, // 6089: switch Inst[15] {
4122 0, 35, // 6092: case 0x0: {
4123 OPC_SwitchField, 31, 1, // 6094: switch Inst[31] {
4124 0, 14, // 6097: case 0x0: {
4125 OPC_CheckPredicate, 43, // 6099: check predicate 43
4126 OPC_CheckField, 24, 1, 1, // 6101: check Inst[24] == 0x1
4127 OPC_CheckField, 7, 1, 0, // 6105: check Inst[7] == 0x0
4128 OPC_Decode, 161, 121, 43, // 6109: decode to PSSLAI_DH using decoder 43
4129 // 6109: }
4130 1, 0, // 6113: case 0x1: {
4131 OPC_CheckPredicate, 43, // 6115: check predicate 43
4132 OPC_CheckField, 20, 1, 0, // 6117: check Inst[20] == 0x0
4133 OPC_CheckField, 7, 1, 0, // 6121: check Inst[7] == 0x0
4134 OPC_Decode, 173, 121, 44, // 6125: decode to PSSUB_DH using decoder 44
4135 // 6125: }
4136 // 6125: } // switch Inst[31]
4137 // 6125: }
4138 1, 0, // 6129: case 0x1: {
4139 OPC_SwitchField, 31, 1, // 6131: switch Inst[31] {
4140 0, 14, // 6134: case 0x0: {
4141 OPC_CheckPredicate, 43, // 6136: check predicate 43
4142 OPC_CheckField, 24, 1, 1, // 6138: check Inst[24] == 0x1
4143 OPC_CheckField, 7, 1, 0, // 6142: check Inst[7] == 0x0
4144 OPC_Decode, 244, 120, 43, // 6146: decode to PSRARI_DH using decoder 43
4145 // 6146: }
4146 1, 0, // 6150: case 0x1: {
4147 OPC_CheckPredicate, 43, // 6152: check predicate 43
4148 OPC_CheckField, 20, 1, 1, // 6154: check Inst[20] == 0x1
4149 OPC_CheckField, 7, 1, 0, // 6158: check Inst[7] == 0x0
4150 OPC_Decode, 208, 119, 44, // 6162: decode to PMSLT_DH using decoder 44
4151 // 6162: }
4152 // 6162: } // switch Inst[31]
4153 // 6162: }
4154 // 6162: } // switch Inst[15]
4155 // 6162: }
4156 41, 69, // 6166: case 0x29: {
4157 OPC_SwitchField, 15, 1, // 6168: switch Inst[15] {
4158 0, 31, // 6171: case 0x0: {
4159 OPC_SwitchField, 31, 1, // 6173: switch Inst[31] {
4160 0, 10, // 6176: case 0x0: {
4161 OPC_CheckPredicate, 43, // 6178: check predicate 43
4162 OPC_CheckField, 7, 1, 0, // 6180: check Inst[7] == 0x0
4163 OPC_Decode, 162, 121, 45, // 6184: decode to PSSLAI_DW using decoder 45
4164 // 6184: }
4165 1, 0, // 6188: case 0x1: {
4166 OPC_CheckPredicate, 43, // 6190: check predicate 43
4167 OPC_CheckField, 20, 1, 0, // 6192: check Inst[20] == 0x0
4168 OPC_CheckField, 7, 1, 0, // 6196: check Inst[7] == 0x0
4169 OPC_Decode, 174, 121, 44, // 6200: decode to PSSUB_DW using decoder 44
4170 // 6200: }
4171 // 6200: } // switch Inst[31]
4172 // 6200: }
4173 1, 0, // 6204: case 0x1: {
4174 OPC_SwitchField, 31, 1, // 6206: switch Inst[31] {
4175 0, 10, // 6209: case 0x0: {
4176 OPC_CheckPredicate, 43, // 6211: check predicate 43
4177 OPC_CheckField, 7, 1, 0, // 6213: check Inst[7] == 0x0
4178 OPC_Decode, 245, 120, 45, // 6217: decode to PSRARI_DW using decoder 45
4179 // 6217: }
4180 1, 0, // 6221: case 0x1: {
4181 OPC_CheckPredicate, 43, // 6223: check predicate 43
4182 OPC_CheckField, 20, 1, 1, // 6225: check Inst[20] == 0x1
4183 OPC_CheckField, 7, 1, 0, // 6229: check Inst[7] == 0x0
4184 OPC_Decode, 209, 119, 44, // 6233: decode to PMSLT_DW using decoder 44
4185 // 6233: }
4186 // 6233: } // switch Inst[31]
4187 // 6233: }
4188 // 6233: } // switch Inst[15]
4189 // 6233: }
4190 42, 43, // 6237: case 0x2a: {
4191 OPC_SwitchField, 15, 1, // 6239: switch Inst[15] {
4192 0, 18, // 6242: case 0x0: {
4193 OPC_CheckPredicate, 43, // 6244: check predicate 43
4194 OPC_CheckField, 31, 1, 1, // 6246: check Inst[31] == 0x1
4195 OPC_CheckField, 20, 1, 0, // 6250: check Inst[20] == 0x0
4196 OPC_CheckField, 7, 1, 0, // 6254: check Inst[7] == 0x0
4197 OPC_Decode, 172, 121, 44, // 6258: decode to PSSUB_DB using decoder 44
4198 // 6258: }
4199 1, 0, // 6262: case 0x1: {
4200 OPC_CheckPredicate, 43, // 6264: check predicate 43
4201 OPC_CheckField, 31, 1, 1, // 6266: check Inst[31] == 0x1
4202 OPC_CheckField, 20, 1, 1, // 6270: check Inst[20] == 0x1
4203 OPC_CheckField, 7, 1, 0, // 6274: check Inst[7] == 0x0
4204 OPC_Decode, 207, 119, 44, // 6278: decode to PMSLT_DB using decoder 44
4205 // 6278: }
4206 // 6278: } // switch Inst[15]
4207 // 6278: }
4208 44, 43, // 6282: case 0x2c: {
4209 OPC_SwitchField, 15, 1, // 6284: switch Inst[15] {
4210 0, 18, // 6287: case 0x0: {
4211 OPC_CheckPredicate, 43, // 6289: check predicate 43
4212 OPC_CheckField, 31, 1, 1, // 6291: check Inst[31] == 0x1
4213 OPC_CheckField, 20, 1, 0, // 6295: check Inst[20] == 0x0
4214 OPC_CheckField, 7, 1, 0, // 6299: check Inst[7] == 0x0
4215 OPC_Decode, 189, 118, 44, // 6303: decode to PASUB_DH using decoder 44
4216 // 6303: }
4217 1, 0, // 6307: case 0x1: {
4218 OPC_CheckPredicate, 43, // 6309: check predicate 43
4219 OPC_CheckField, 31, 1, 1, // 6311: check Inst[31] == 0x1
4220 OPC_CheckField, 20, 1, 1, // 6315: check Inst[20] == 0x1
4221 OPC_CheckField, 7, 1, 0, // 6319: check Inst[7] == 0x0
4222 OPC_Decode, 202, 119, 44, // 6323: decode to PMSLTU_DH using decoder 44
4223 // 6323: }
4224 // 6323: } // switch Inst[15]
4225 // 6323: }
4226 45, 43, // 6327: case 0x2d: {
4227 OPC_SwitchField, 15, 1, // 6329: switch Inst[15] {
4228 0, 18, // 6332: case 0x0: {
4229 OPC_CheckPredicate, 43, // 6334: check predicate 43
4230 OPC_CheckField, 31, 1, 1, // 6336: check Inst[31] == 0x1
4231 OPC_CheckField, 20, 1, 0, // 6340: check Inst[20] == 0x0
4232 OPC_CheckField, 7, 1, 0, // 6344: check Inst[7] == 0x0
4233 OPC_Decode, 190, 118, 44, // 6348: decode to PASUB_DW using decoder 44
4234 // 6348: }
4235 1, 0, // 6352: case 0x1: {
4236 OPC_CheckPredicate, 43, // 6354: check predicate 43
4237 OPC_CheckField, 31, 1, 1, // 6356: check Inst[31] == 0x1
4238 OPC_CheckField, 20, 1, 1, // 6360: check Inst[20] == 0x1
4239 OPC_CheckField, 7, 1, 0, // 6364: check Inst[7] == 0x0
4240 OPC_Decode, 203, 119, 44, // 6368: decode to PMSLTU_DW using decoder 44
4241 // 6368: }
4242 // 6368: } // switch Inst[15]
4243 // 6368: }
4244 46, 43, // 6372: case 0x2e: {
4245 OPC_SwitchField, 15, 1, // 6374: switch Inst[15] {
4246 0, 18, // 6377: case 0x0: {
4247 OPC_CheckPredicate, 43, // 6379: check predicate 43
4248 OPC_CheckField, 31, 1, 1, // 6381: check Inst[31] == 0x1
4249 OPC_CheckField, 20, 1, 0, // 6385: check Inst[20] == 0x0
4250 OPC_CheckField, 7, 1, 0, // 6389: check Inst[7] == 0x0
4251 OPC_Decode, 188, 118, 44, // 6393: decode to PASUB_DB using decoder 44
4252 // 6393: }
4253 1, 0, // 6397: case 0x1: {
4254 OPC_CheckPredicate, 43, // 6399: check predicate 43
4255 OPC_CheckField, 31, 1, 1, // 6401: check Inst[31] == 0x1
4256 OPC_CheckField, 20, 1, 1, // 6405: check Inst[20] == 0x1
4257 OPC_CheckField, 7, 1, 0, // 6409: check Inst[7] == 0x0
4258 OPC_Decode, 201, 119, 44, // 6413: decode to PMSLTU_DB using decoder 44
4259 // 6413: }
4260 // 6413: } // switch Inst[15]
4261 // 6413: }
4262 48, 77, // 6417: case 0x30: {
4263 OPC_SwitchField, 15, 1, // 6419: switch Inst[15] {
4264 0, 35, // 6422: case 0x0: {
4265 OPC_SwitchField, 20, 5, // 6424: switch Inst[24:20] {
4266 4, 14, // 6427: case 0x4: {
4267 OPC_CheckPredicate, 43, // 6429: check predicate 43
4268 OPC_CheckField, 31, 1, 0, // 6431: check Inst[31] == 0x0
4269 OPC_CheckField, 7, 1, 0, // 6435: check Inst[7] == 0x0
4270 OPC_Decode, 216, 120, 47, // 6439: decode to PSEXT_DH_B using decoder 47
4271 // 6439: }
4272 7, 0, // 6443: case 0x7: {
4273 OPC_CheckPredicate, 43, // 6445: check predicate 43
4274 OPC_CheckField, 31, 1, 0, // 6447: check Inst[31] == 0x0
4275 OPC_CheckField, 7, 1, 0, // 6451: check Inst[7] == 0x0
4276 OPC_Decode, 192, 120, 47, // 6455: decode to PSABS_DH using decoder 47
4277 // 6455: }
4278 // 6455: } // switch Inst[24:20]
4279 // 6455: }
4280 1, 0, // 6459: case 0x1: {
4281 OPC_SwitchField, 31, 1, // 6461: switch Inst[31] {
4282 0, 14, // 6464: case 0x0: {
4283 OPC_CheckPredicate, 43, // 6466: check predicate 43
4284 OPC_CheckField, 24, 1, 1, // 6468: check Inst[24] == 0x1
4285 OPC_CheckField, 7, 1, 0, // 6472: check Inst[7] == 0x0
4286 OPC_Decode, 209, 120, 43, // 6476: decode to PSATI_DH using decoder 43
4287 // 6476: }
4288 1, 0, // 6480: case 0x1: {
4289 OPC_CheckPredicate, 43, // 6482: check predicate 43
4290 OPC_CheckField, 20, 1, 1, // 6484: check Inst[20] == 0x1
4291 OPC_CheckField, 7, 1, 0, // 6488: check Inst[7] == 0x0
4292 OPC_Decode, 174, 119, 44, // 6492: decode to PMIN_DH using decoder 44
4293 // 6492: }
4294 // 6492: } // switch Inst[31]
4295 // 6492: }
4296 // 6492: } // switch Inst[15]
4297 // 6492: }
4298 49, 73, // 6496: case 0x31: {
4299 OPC_SwitchField, 15, 1, // 6498: switch Inst[15] {
4300 0, 35, // 6501: case 0x0: {
4301 OPC_SwitchField, 20, 5, // 6503: switch Inst[24:20] {
4302 4, 14, // 6506: case 0x4: {
4303 OPC_CheckPredicate, 43, // 6508: check predicate 43
4304 OPC_CheckField, 31, 1, 0, // 6510: check Inst[31] == 0x0
4305 OPC_CheckField, 7, 1, 0, // 6514: check Inst[7] == 0x0
4306 OPC_Decode, 217, 120, 47, // 6518: decode to PSEXT_DW_B using decoder 47
4307 // 6518: }
4308 5, 0, // 6522: case 0x5: {
4309 OPC_CheckPredicate, 43, // 6524: check predicate 43
4310 OPC_CheckField, 31, 1, 0, // 6526: check Inst[31] == 0x0
4311 OPC_CheckField, 7, 1, 0, // 6530: check Inst[7] == 0x0
4312 OPC_Decode, 218, 120, 47, // 6534: decode to PSEXT_DW_H using decoder 47
4313 // 6534: }
4314 // 6534: } // switch Inst[24:20]
4315 // 6534: }
4316 1, 0, // 6538: case 0x1: {
4317 OPC_SwitchField, 31, 1, // 6540: switch Inst[31] {
4318 0, 10, // 6543: case 0x0: {
4319 OPC_CheckPredicate, 43, // 6545: check predicate 43
4320 OPC_CheckField, 7, 1, 0, // 6547: check Inst[7] == 0x0
4321 OPC_Decode, 210, 120, 45, // 6551: decode to PSATI_DW using decoder 45
4322 // 6551: }
4323 1, 0, // 6555: case 0x1: {
4324 OPC_CheckPredicate, 43, // 6557: check predicate 43
4325 OPC_CheckField, 20, 1, 1, // 6559: check Inst[20] == 0x1
4326 OPC_CheckField, 7, 1, 0, // 6563: check Inst[7] == 0x0
4327 OPC_Decode, 175, 119, 44, // 6567: decode to PMIN_DW using decoder 44
4328 // 6567: }
4329 // 6567: } // switch Inst[31]
4330 // 6567: }
4331 // 6567: } // switch Inst[15]
4332 // 6567: }
4333 50, 43, // 6571: case 0x32: {
4334 OPC_SwitchField, 15, 1, // 6573: switch Inst[15] {
4335 0, 18, // 6576: case 0x0: {
4336 OPC_CheckPredicate, 43, // 6578: check predicate 43
4337 OPC_CheckField, 31, 1, 0, // 6580: check Inst[31] == 0x0
4338 OPC_CheckField, 20, 5, 7, // 6584: check Inst[24:20] == 0x7
4339 OPC_CheckField, 7, 1, 0, // 6588: check Inst[7] == 0x0
4340 OPC_Decode, 191, 120, 47, // 6592: decode to PSABS_DB using decoder 47
4341 // 6592: }
4342 1, 0, // 6596: case 0x1: {
4343 OPC_CheckPredicate, 43, // 6598: check predicate 43
4344 OPC_CheckField, 31, 1, 1, // 6600: check Inst[31] == 0x1
4345 OPC_CheckField, 20, 1, 1, // 6604: check Inst[20] == 0x1
4346 OPC_CheckField, 7, 1, 0, // 6608: check Inst[7] == 0x0
4347 OPC_Decode, 173, 119, 44, // 6612: decode to PMIN_DB using decoder 44
4348 // 6612: }
4349 // 6612: } // switch Inst[15]
4350 // 6612: }
4351 52, 51, // 6616: case 0x34: {
4352 OPC_SwitchField, 15, 1, // 6618: switch Inst[15] {
4353 0, 26, // 6621: case 0x0: {
4354 OPC_CheckField, 7, 1, 0, // 6623: check Inst[7] == 0x0
4355 OPC_Scope, 14, // 6627: try {
4356 OPC_CheckField, 20, 1, 0, // 6629: check Inst[20] == 0x0
4357 OPC_CheckPredicate, 43, // 6633: check predicate 43
4358 OPC_CheckField, 31, 1, 1, // 6635: check Inst[31] == 0x1
4359 OPC_Decode, 157, 118, 44, // 6639: decode to PABDU_DH using decoder 44
4360 // 6639: } else try {
4361 OPC_CheckPredicate, 43, // 6643: check predicate 43
4362 OPC_Decode, 149, 121, 46, // 6645: decode to PSSHA_DHS using decoder 46
4363 // 6645: }
4364 // 6645: }
4365 1, 0, // 6649: case 0x1: {
4366 OPC_CheckPredicate, 43, // 6651: check predicate 43
4367 OPC_CheckField, 31, 1, 1, // 6653: check Inst[31] == 0x1
4368 OPC_CheckField, 20, 1, 1, // 6657: check Inst[20] == 0x1
4369 OPC_CheckField, 7, 1, 0, // 6661: check Inst[7] == 0x0
4370 OPC_Decode, 168, 119, 44, // 6665: decode to PMINU_DH using decoder 44
4371 // 6665: }
4372 // 6665: } // switch Inst[15]
4373 // 6665: }
4374 53, 35, // 6669: case 0x35: {
4375 OPC_SwitchField, 15, 1, // 6671: switch Inst[15] {
4376 0, 10, // 6674: case 0x0: {
4377 OPC_CheckPredicate, 43, // 6676: check predicate 43
4378 OPC_CheckField, 7, 1, 0, // 6678: check Inst[7] == 0x0
4379 OPC_Decode, 150, 121, 46, // 6682: decode to PSSHA_DWS using decoder 46
4380 // 6682: }
4381 1, 0, // 6686: case 0x1: {
4382 OPC_CheckPredicate, 43, // 6688: check predicate 43
4383 OPC_CheckField, 31, 1, 1, // 6690: check Inst[31] == 0x1
4384 OPC_CheckField, 20, 1, 1, // 6694: check Inst[20] == 0x1
4385 OPC_CheckField, 7, 1, 0, // 6698: check Inst[7] == 0x0
4386 OPC_Decode, 169, 119, 44, // 6702: decode to PMINU_DW using decoder 44
4387 // 6702: }
4388 // 6702: } // switch Inst[15]
4389 // 6702: }
4390 54, 43, // 6706: case 0x36: {
4391 OPC_SwitchField, 15, 1, // 6708: switch Inst[15] {
4392 0, 18, // 6711: case 0x0: {
4393 OPC_CheckPredicate, 43, // 6713: check predicate 43
4394 OPC_CheckField, 31, 1, 1, // 6715: check Inst[31] == 0x1
4395 OPC_CheckField, 20, 1, 0, // 6719: check Inst[20] == 0x0
4396 OPC_CheckField, 7, 1, 0, // 6723: check Inst[7] == 0x0
4397 OPC_Decode, 156, 118, 44, // 6727: decode to PABDU_DB using decoder 44
4398 // 6727: }
4399 1, 0, // 6731: case 0x1: {
4400 OPC_CheckPredicate, 43, // 6733: check predicate 43
4401 OPC_CheckField, 31, 1, 1, // 6735: check Inst[31] == 0x1
4402 OPC_CheckField, 20, 1, 1, // 6739: check Inst[20] == 0x1
4403 OPC_CheckField, 7, 1, 0, // 6743: check Inst[7] == 0x0
4404 OPC_Decode, 167, 119, 44, // 6747: decode to PMINU_DB using decoder 44
4405 // 6747: }
4406 // 6747: } // switch Inst[15]
4407 // 6747: }
4408 56, 43, // 6751: case 0x38: {
4409 OPC_SwitchField, 15, 1, // 6753: switch Inst[15] {
4410 0, 18, // 6756: case 0x0: {
4411 OPC_CheckPredicate, 43, // 6758: check predicate 43
4412 OPC_CheckField, 31, 1, 1, // 6760: check Inst[31] == 0x1
4413 OPC_CheckField, 20, 1, 0, // 6764: check Inst[20] == 0x0
4414 OPC_CheckField, 7, 1, 0, // 6768: check Inst[7] == 0x0
4415 OPC_Decode, 167, 121, 44, // 6772: decode to PSSUBU_DH using decoder 44
4416 // 6772: }
4417 1, 0, // 6776: case 0x1: {
4418 OPC_CheckPredicate, 43, // 6778: check predicate 43
4419 OPC_CheckField, 31, 1, 1, // 6780: check Inst[31] == 0x1
4420 OPC_CheckField, 20, 1, 1, // 6784: check Inst[20] == 0x1
4421 OPC_CheckField, 7, 1, 0, // 6788: check Inst[7] == 0x0
4422 OPC_Decode, 142, 119, 44, // 6792: decode to PMAX_DH using decoder 44
4423 // 6792: }
4424 // 6792: } // switch Inst[15]
4425 // 6792: }
4426 57, 43, // 6796: case 0x39: {
4427 OPC_SwitchField, 15, 1, // 6798: switch Inst[15] {
4428 0, 18, // 6801: case 0x0: {
4429 OPC_CheckPredicate, 43, // 6803: check predicate 43
4430 OPC_CheckField, 31, 1, 1, // 6805: check Inst[31] == 0x1
4431 OPC_CheckField, 20, 1, 0, // 6809: check Inst[20] == 0x0
4432 OPC_CheckField, 7, 1, 0, // 6813: check Inst[7] == 0x0
4433 OPC_Decode, 168, 121, 44, // 6817: decode to PSSUBU_DW using decoder 44
4434 // 6817: }
4435 1, 0, // 6821: case 0x1: {
4436 OPC_CheckPredicate, 43, // 6823: check predicate 43
4437 OPC_CheckField, 31, 1, 1, // 6825: check Inst[31] == 0x1
4438 OPC_CheckField, 20, 1, 1, // 6829: check Inst[20] == 0x1
4439 OPC_CheckField, 7, 1, 0, // 6833: check Inst[7] == 0x0
4440 OPC_Decode, 143, 119, 44, // 6837: decode to PMAX_DW using decoder 44
4441 // 6837: }
4442 // 6837: } // switch Inst[15]
4443 // 6837: }
4444 58, 43, // 6841: case 0x3a: {
4445 OPC_SwitchField, 15, 1, // 6843: switch Inst[15] {
4446 0, 18, // 6846: case 0x0: {
4447 OPC_CheckPredicate, 43, // 6848: check predicate 43
4448 OPC_CheckField, 31, 1, 1, // 6850: check Inst[31] == 0x1
4449 OPC_CheckField, 20, 1, 0, // 6854: check Inst[20] == 0x0
4450 OPC_CheckField, 7, 1, 0, // 6858: check Inst[7] == 0x0
4451 OPC_Decode, 166, 121, 44, // 6862: decode to PSSUBU_DB using decoder 44
4452 // 6862: }
4453 1, 0, // 6866: case 0x1: {
4454 OPC_CheckPredicate, 43, // 6868: check predicate 43
4455 OPC_CheckField, 31, 1, 1, // 6870: check Inst[31] == 0x1
4456 OPC_CheckField, 20, 1, 1, // 6874: check Inst[20] == 0x1
4457 OPC_CheckField, 7, 1, 0, // 6878: check Inst[7] == 0x0
4458 OPC_Decode, 141, 119, 44, // 6882: decode to PMAX_DB using decoder 44
4459 // 6882: }
4460 // 6882: } // switch Inst[15]
4461 // 6882: }
4462 60, 51, // 6886: case 0x3c: {
4463 OPC_SwitchField, 15, 1, // 6888: switch Inst[15] {
4464 0, 26, // 6891: case 0x0: {
4465 OPC_CheckField, 7, 1, 0, // 6893: check Inst[7] == 0x0
4466 OPC_Scope, 14, // 6897: try {
4467 OPC_CheckField, 20, 1, 0, // 6899: check Inst[20] == 0x0
4468 OPC_CheckPredicate, 43, // 6903: check predicate 43
4469 OPC_CheckField, 31, 1, 1, // 6905: check Inst[31] == 0x1
4470 OPC_Decode, 183, 118, 44, // 6909: decode to PASUBU_DH using decoder 44
4471 // 6909: } else try {
4472 OPC_CheckPredicate, 43, // 6913: check predicate 43
4473 OPC_Decode, 145, 121, 46, // 6915: decode to PSSHAR_DHS using decoder 46
4474 // 6915: }
4475 // 6915: }
4476 1, 0, // 6919: case 0x1: {
4477 OPC_CheckPredicate, 43, // 6921: check predicate 43
4478 OPC_CheckField, 31, 1, 1, // 6923: check Inst[31] == 0x1
4479 OPC_CheckField, 20, 1, 1, // 6927: check Inst[20] == 0x1
4480 OPC_CheckField, 7, 1, 0, // 6931: check Inst[7] == 0x0
4481 OPC_Decode, 136, 119, 44, // 6935: decode to PMAXU_DH using decoder 44
4482 // 6935: }
4483 // 6935: } // switch Inst[15]
4484 // 6935: }
4485 61, 51, // 6939: case 0x3d: {
4486 OPC_SwitchField, 15, 1, // 6941: switch Inst[15] {
4487 0, 26, // 6944: case 0x0: {
4488 OPC_CheckField, 7, 1, 0, // 6946: check Inst[7] == 0x0
4489 OPC_Scope, 14, // 6950: try {
4490 OPC_CheckField, 20, 1, 0, // 6952: check Inst[20] == 0x0
4491 OPC_CheckPredicate, 43, // 6956: check predicate 43
4492 OPC_CheckField, 31, 1, 1, // 6958: check Inst[31] == 0x1
4493 OPC_Decode, 184, 118, 44, // 6962: decode to PASUBU_DW using decoder 44
4494 // 6962: } else try {
4495 OPC_CheckPredicate, 43, // 6966: check predicate 43
4496 OPC_Decode, 146, 121, 46, // 6968: decode to PSSHAR_DWS using decoder 46
4497 // 6968: }
4498 // 6968: }
4499 1, 0, // 6972: case 0x1: {
4500 OPC_CheckPredicate, 43, // 6974: check predicate 43
4501 OPC_CheckField, 31, 1, 1, // 6976: check Inst[31] == 0x1
4502 OPC_CheckField, 20, 1, 1, // 6980: check Inst[20] == 0x1
4503 OPC_CheckField, 7, 1, 0, // 6984: check Inst[7] == 0x0
4504 OPC_Decode, 137, 119, 44, // 6988: decode to PMAXU_DW using decoder 44
4505 // 6988: }
4506 // 6988: } // switch Inst[15]
4507 // 6988: }
4508 62, 0, // 6992: case 0x3e: {
4509 OPC_SwitchField, 15, 1, // 6994: switch Inst[15] {
4510 0, 18, // 6997: case 0x0: {
4511 OPC_CheckPredicate, 43, // 6999: check predicate 43
4512 OPC_CheckField, 31, 1, 1, // 7001: check Inst[31] == 0x1
4513 OPC_CheckField, 20, 1, 0, // 7005: check Inst[20] == 0x0
4514 OPC_CheckField, 7, 1, 0, // 7009: check Inst[7] == 0x0
4515 OPC_Decode, 182, 118, 44, // 7013: decode to PASUBU_DB using decoder 44
4516 // 7013: }
4517 1, 0, // 7017: case 0x1: {
4518 OPC_CheckPredicate, 43, // 7019: check predicate 43
4519 OPC_CheckField, 31, 1, 1, // 7021: check Inst[31] == 0x1
4520 OPC_CheckField, 20, 1, 1, // 7025: check Inst[20] == 0x1
4521 OPC_CheckField, 7, 1, 0, // 7029: check Inst[7] == 0x0
4522 OPC_Decode, 135, 119, 44, // 7033: decode to PMAXU_DB using decoder 44
4523 // 7033: }
4524 // 7033: } // switch Inst[15]
4525 // 7033: }
4526 // 7033: } // switch Inst[30:25]
4527 // 7033: }
4528 // 7033: } // switch Inst[14:12]
4529 // 7033: }
4530 35, 29, // 7037: case 0x23: {
4531 OPC_SwitchField, 12, 3, // 7039: switch Inst[14:12] {
4532 0, 4, // 7042: case 0x0: {
4533 OPC_Decode, 151, 123, 48, // 7044: decode to SB using decoder 48
4534 // 7044: }
4535 1, 4, // 7048: case 0x1: {
4536 OPC_Decode, 240, 123, 48, // 7050: decode to SH using decoder 48
4537 // 7050: }
4538 2, 4, // 7054: case 0x2: {
4539 OPC_Decode, 205, 124, 48, // 7056: decode to SW using decoder 48
4540 // 7056: }
4541 3, 0, // 7060: case 0x3: {
4542 OPC_CheckPredicate, 20, // 7062: check predicate 20
4543 OPC_Decode, 163, 123, 48, // 7064: decode to SD using decoder 48
4544 // 7064: }
4545 // 7064: } // switch Inst[14:12]
4546 // 7064: }
4547 39, 255, 10, // 7068: case 0x27: {
4548 OPC_SwitchField, 12, 3, // 7071: switch Inst[14:12] {
4549 0, 136, 3, // 7074: case 0x0: {
4550 OPC_SwitchField, 26, 6, // 7077: switch Inst[31:26] {
4551 0, 38, // 7080: case 0x0: {
4552 OPC_SwitchField, 20, 5, // 7082: switch Inst[24:20] {
4553 0, 7, // 7085: case 0x0: {
4554 OPC_CheckPredicate, 21, // 7087: check predicate 21
4555 OPC_Decode, 166, 129, 1, 1, // 7089: decode to VSE8_V using decoder 1
4556 // 7089: }
4557 8, 11, // 7094: case 0x8: {
4558 OPC_CheckPredicate, 21, // 7096: check predicate 21
4559 OPC_CheckField, 25, 1, 1, // 7098: check Inst[25] == 0x1
4560 OPC_Decode, 151, 129, 1, 2, // 7102: decode to VS1R_V using decoder 2
4561 // 7102: }
4562 11, 0, // 7107: case 0xb: {
4563 OPC_CheckPredicate, 21, // 7109: check predicate 21
4564 OPC_CheckField, 25, 1, 1, // 7111: check Inst[25] == 0x1
4565 OPC_Decode, 192, 129, 1, 2, // 7115: decode to VSM_V using decoder 2
4566 // 7115: }
4567 // 7115: } // switch Inst[24:20]
4568 // 7115: }
4569 1, 7, // 7120: case 0x1: {
4570 OPC_CheckPredicate, 21, // 7122: check predicate 21
4571 OPC_Decode, 178, 130, 1, 3, // 7124: decode to VSUXEI8_V using decoder 3
4572 // 7124: }
4573 2, 7, // 7129: case 0x2: {
4574 OPC_CheckPredicate, 21, // 7131: check predicate 21
4575 OPC_Decode, 234, 129, 1, 4, // 7133: decode to VSSE8_V using decoder 4
4576 // 7133: }
4577 3, 7, // 7138: case 0x3: {
4578 OPC_CheckPredicate, 21, // 7140: check predicate 21
4579 OPC_Decode, 196, 129, 1, 3, // 7142: decode to VSOXEI8_V using decoder 3
4580 // 7142: }
4581 8, 25, // 7147: case 0x8: {
4582 OPC_SwitchField, 20, 5, // 7149: switch Inst[24:20] {
4583 0, 7, // 7152: case 0x0: {
4584 OPC_CheckPredicate, 21, // 7154: check predicate 21
4585 OPC_Decode, 238, 129, 1, 1, // 7156: decode to VSSEG2E8_V using decoder 1
4586 // 7156: }
4587 8, 0, // 7161: case 0x8: {
4588 OPC_CheckPredicate, 21, // 7163: check predicate 21
4589 OPC_CheckField, 25, 1, 1, // 7165: check Inst[25] == 0x1
4590 OPC_Decode, 152, 129, 1, 5, // 7169: decode to VS2R_V using decoder 5
4591 // 7169: }
4592 // 7169: } // switch Inst[24:20]
4593 // 7169: }
4594 9, 7, // 7174: case 0x9: {
4595 OPC_CheckPredicate, 21, // 7176: check predicate 21
4596 OPC_Decode, 182, 130, 1, 3, // 7178: decode to VSUXSEG2EI8_V using decoder 3
4597 // 7178: }
4598 10, 7, // 7183: case 0xa: {
4599 OPC_CheckPredicate, 21, // 7185: check predicate 21
4600 OPC_Decode, 144, 130, 1, 4, // 7187: decode to VSSSEG2E8_V using decoder 4
4601 // 7187: }
4602 11, 7, // 7192: case 0xb: {
4603 OPC_CheckPredicate, 21, // 7194: check predicate 21
4604 OPC_Decode, 200, 129, 1, 3, // 7196: decode to VSOXSEG2EI8_V using decoder 3
4605 // 7196: }
4606 16, 11, // 7201: case 0x10: {
4607 OPC_CheckPredicate, 21, // 7203: check predicate 21
4608 OPC_CheckField, 20, 5, 0, // 7205: check Inst[24:20] == 0x0
4609 OPC_Decode, 242, 129, 1, 1, // 7209: decode to VSSEG3E8_V using decoder 1
4610 // 7209: }
4611 17, 7, // 7214: case 0x11: {
4612 OPC_CheckPredicate, 21, // 7216: check predicate 21
4613 OPC_Decode, 186, 130, 1, 3, // 7218: decode to VSUXSEG3EI8_V using decoder 3
4614 // 7218: }
4615 18, 7, // 7223: case 0x12: {
4616 OPC_CheckPredicate, 21, // 7225: check predicate 21
4617 OPC_Decode, 148, 130, 1, 4, // 7227: decode to VSSSEG3E8_V using decoder 4
4618 // 7227: }
4619 19, 7, // 7232: case 0x13: {
4620 OPC_CheckPredicate, 21, // 7234: check predicate 21
4621 OPC_Decode, 204, 129, 1, 3, // 7236: decode to VSOXSEG3EI8_V using decoder 3
4622 // 7236: }
4623 24, 25, // 7241: case 0x18: {
4624 OPC_SwitchField, 20, 5, // 7243: switch Inst[24:20] {
4625 0, 7, // 7246: case 0x0: {
4626 OPC_CheckPredicate, 21, // 7248: check predicate 21
4627 OPC_Decode, 246, 129, 1, 1, // 7250: decode to VSSEG4E8_V using decoder 1
4628 // 7250: }
4629 8, 0, // 7255: case 0x8: {
4630 OPC_CheckPredicate, 21, // 7257: check predicate 21
4631 OPC_CheckField, 25, 1, 1, // 7259: check Inst[25] == 0x1
4632 OPC_Decode, 153, 129, 1, 6, // 7263: decode to VS4R_V using decoder 6
4633 // 7263: }
4634 // 7263: } // switch Inst[24:20]
4635 // 7263: }
4636 25, 7, // 7268: case 0x19: {
4637 OPC_CheckPredicate, 21, // 7270: check predicate 21
4638 OPC_Decode, 190, 130, 1, 3, // 7272: decode to VSUXSEG4EI8_V using decoder 3
4639 // 7272: }
4640 26, 7, // 7277: case 0x1a: {
4641 OPC_CheckPredicate, 21, // 7279: check predicate 21
4642 OPC_Decode, 152, 130, 1, 4, // 7281: decode to VSSSEG4E8_V using decoder 4
4643 // 7281: }
4644 27, 7, // 7286: case 0x1b: {
4645 OPC_CheckPredicate, 21, // 7288: check predicate 21
4646 OPC_Decode, 208, 129, 1, 3, // 7290: decode to VSOXSEG4EI8_V using decoder 3
4647 // 7290: }
4648 32, 11, // 7295: case 0x20: {
4649 OPC_CheckPredicate, 21, // 7297: check predicate 21
4650 OPC_CheckField, 20, 5, 0, // 7299: check Inst[24:20] == 0x0
4651 OPC_Decode, 250, 129, 1, 1, // 7303: decode to VSSEG5E8_V using decoder 1
4652 // 7303: }
4653 33, 7, // 7308: case 0x21: {
4654 OPC_CheckPredicate, 21, // 7310: check predicate 21
4655 OPC_Decode, 194, 130, 1, 3, // 7312: decode to VSUXSEG5EI8_V using decoder 3
4656 // 7312: }
4657 34, 7, // 7317: case 0x22: {
4658 OPC_CheckPredicate, 21, // 7319: check predicate 21
4659 OPC_Decode, 156, 130, 1, 4, // 7321: decode to VSSSEG5E8_V using decoder 4
4660 // 7321: }
4661 35, 7, // 7326: case 0x23: {
4662 OPC_CheckPredicate, 21, // 7328: check predicate 21
4663 OPC_Decode, 212, 129, 1, 3, // 7330: decode to VSOXSEG5EI8_V using decoder 3
4664 // 7330: }
4665 40, 11, // 7335: case 0x28: {
4666 OPC_CheckPredicate, 21, // 7337: check predicate 21
4667 OPC_CheckField, 20, 5, 0, // 7339: check Inst[24:20] == 0x0
4668 OPC_Decode, 254, 129, 1, 1, // 7343: decode to VSSEG6E8_V using decoder 1
4669 // 7343: }
4670 41, 7, // 7348: case 0x29: {
4671 OPC_CheckPredicate, 21, // 7350: check predicate 21
4672 OPC_Decode, 198, 130, 1, 3, // 7352: decode to VSUXSEG6EI8_V using decoder 3
4673 // 7352: }
4674 42, 7, // 7357: case 0x2a: {
4675 OPC_CheckPredicate, 21, // 7359: check predicate 21
4676 OPC_Decode, 160, 130, 1, 4, // 7361: decode to VSSSEG6E8_V using decoder 4
4677 // 7361: }
4678 43, 7, // 7366: case 0x2b: {
4679 OPC_CheckPredicate, 21, // 7368: check predicate 21
4680 OPC_Decode, 216, 129, 1, 3, // 7370: decode to VSOXSEG6EI8_V using decoder 3
4681 // 7370: }
4682 48, 11, // 7375: case 0x30: {
4683 OPC_CheckPredicate, 21, // 7377: check predicate 21
4684 OPC_CheckField, 20, 5, 0, // 7379: check Inst[24:20] == 0x0
4685 OPC_Decode, 130, 130, 1, 1, // 7383: decode to VSSEG7E8_V using decoder 1
4686 // 7383: }
4687 49, 7, // 7388: case 0x31: {
4688 OPC_CheckPredicate, 21, // 7390: check predicate 21
4689 OPC_Decode, 202, 130, 1, 3, // 7392: decode to VSUXSEG7EI8_V using decoder 3
4690 // 7392: }
4691 50, 7, // 7397: case 0x32: {
4692 OPC_CheckPredicate, 21, // 7399: check predicate 21
4693 OPC_Decode, 164, 130, 1, 4, // 7401: decode to VSSSEG7E8_V using decoder 4
4694 // 7401: }
4695 51, 7, // 7406: case 0x33: {
4696 OPC_CheckPredicate, 21, // 7408: check predicate 21
4697 OPC_Decode, 220, 129, 1, 3, // 7410: decode to VSOXSEG7EI8_V using decoder 3
4698 // 7410: }
4699 56, 25, // 7415: case 0x38: {
4700 OPC_SwitchField, 20, 5, // 7417: switch Inst[24:20] {
4701 0, 7, // 7420: case 0x0: {
4702 OPC_CheckPredicate, 21, // 7422: check predicate 21
4703 OPC_Decode, 134, 130, 1, 1, // 7424: decode to VSSEG8E8_V using decoder 1
4704 // 7424: }
4705 8, 0, // 7429: case 0x8: {
4706 OPC_CheckPredicate, 21, // 7431: check predicate 21
4707 OPC_CheckField, 25, 1, 1, // 7433: check Inst[25] == 0x1
4708 OPC_Decode, 154, 129, 1, 7, // 7437: decode to VS8R_V using decoder 7
4709 // 7437: }
4710 // 7437: } // switch Inst[24:20]
4711 // 7437: }
4712 57, 7, // 7442: case 0x39: {
4713 OPC_CheckPredicate, 21, // 7444: check predicate 21
4714 OPC_Decode, 206, 130, 1, 3, // 7446: decode to VSUXSEG8EI8_V using decoder 3
4715 // 7446: }
4716 58, 7, // 7451: case 0x3a: {
4717 OPC_CheckPredicate, 21, // 7453: check predicate 21
4718 OPC_Decode, 168, 130, 1, 4, // 7455: decode to VSSSEG8E8_V using decoder 4
4719 // 7455: }
4720 59, 0, // 7460: case 0x3b: {
4721 OPC_CheckPredicate, 21, // 7462: check predicate 21
4722 OPC_Decode, 224, 129, 1, 3, // 7464: decode to VSOXSEG8EI8_V using decoder 3
4723 // 7464: }
4724 // 7464: } // switch Inst[31:26]
4725 // 7464: }
4726 1, 6, // 7469: case 0x1: {
4727 OPC_CheckPredicate, 22, // 7471: check predicate 22
4728 OPC_Decode, 234, 115, 49, // 7473: decode to FSH using decoder 49
4729 // 7473: }
4730 2, 6, // 7477: case 0x2: {
4731 OPC_CheckPredicate, 23, // 7479: check predicate 23
4732 OPC_Decode, 252, 115, 50, // 7481: decode to FSW using decoder 50
4733 // 7481: }
4734 3, 6, // 7485: case 0x3: {
4735 OPC_CheckPredicate, 24, // 7487: check predicate 24
4736 OPC_Decode, 209, 115, 51, // 7489: decode to FSD using decoder 51
4737 // 7489: }
4738 4, 6, // 7493: case 0x4: {
4739 OPC_CheckPredicate, 25, // 7495: check predicate 25
4740 OPC_Decode, 235, 115, 52, // 7497: decode to FSQ using decoder 52
4741 // 7497: }
4742 5, 195, 2, // 7501: case 0x5: {
4743 OPC_SwitchField, 26, 6, // 7504: switch Inst[31:26] {
4744 0, 11, // 7507: case 0x0: {
4745 OPC_CheckPredicate, 21, // 7509: check predicate 21
4746 OPC_CheckField, 20, 5, 0, // 7511: check Inst[24:20] == 0x0
4747 OPC_Decode, 163, 129, 1, 1, // 7515: decode to VSE16_V using decoder 1
4748 // 7515: }
4749 1, 7, // 7520: case 0x1: {
4750 OPC_CheckPredicate, 21, // 7522: check predicate 21
4751 OPC_Decode, 175, 130, 1, 3, // 7524: decode to VSUXEI16_V using decoder 3
4752 // 7524: }
4753 2, 7, // 7529: case 0x2: {
4754 OPC_CheckPredicate, 21, // 7531: check predicate 21
4755 OPC_Decode, 231, 129, 1, 4, // 7533: decode to VSSE16_V using decoder 4
4756 // 7533: }
4757 3, 7, // 7538: case 0x3: {
4758 OPC_CheckPredicate, 21, // 7540: check predicate 21
4759 OPC_Decode, 193, 129, 1, 3, // 7542: decode to VSOXEI16_V using decoder 3
4760 // 7542: }
4761 8, 11, // 7547: case 0x8: {
4762 OPC_CheckPredicate, 21, // 7549: check predicate 21
4763 OPC_CheckField, 20, 5, 0, // 7551: check Inst[24:20] == 0x0
4764 OPC_Decode, 235, 129, 1, 1, // 7555: decode to VSSEG2E16_V using decoder 1
4765 // 7555: }
4766 9, 7, // 7560: case 0x9: {
4767 OPC_CheckPredicate, 21, // 7562: check predicate 21
4768 OPC_Decode, 179, 130, 1, 3, // 7564: decode to VSUXSEG2EI16_V using decoder 3
4769 // 7564: }
4770 10, 7, // 7569: case 0xa: {
4771 OPC_CheckPredicate, 21, // 7571: check predicate 21
4772 OPC_Decode, 141, 130, 1, 4, // 7573: decode to VSSSEG2E16_V using decoder 4
4773 // 7573: }
4774 11, 7, // 7578: case 0xb: {
4775 OPC_CheckPredicate, 21, // 7580: check predicate 21
4776 OPC_Decode, 197, 129, 1, 3, // 7582: decode to VSOXSEG2EI16_V using decoder 3
4777 // 7582: }
4778 16, 11, // 7587: case 0x10: {
4779 OPC_CheckPredicate, 21, // 7589: check predicate 21
4780 OPC_CheckField, 20, 5, 0, // 7591: check Inst[24:20] == 0x0
4781 OPC_Decode, 239, 129, 1, 1, // 7595: decode to VSSEG3E16_V using decoder 1
4782 // 7595: }
4783 17, 7, // 7600: case 0x11: {
4784 OPC_CheckPredicate, 21, // 7602: check predicate 21
4785 OPC_Decode, 183, 130, 1, 3, // 7604: decode to VSUXSEG3EI16_V using decoder 3
4786 // 7604: }
4787 18, 7, // 7609: case 0x12: {
4788 OPC_CheckPredicate, 21, // 7611: check predicate 21
4789 OPC_Decode, 145, 130, 1, 4, // 7613: decode to VSSSEG3E16_V using decoder 4
4790 // 7613: }
4791 19, 7, // 7618: case 0x13: {
4792 OPC_CheckPredicate, 21, // 7620: check predicate 21
4793 OPC_Decode, 201, 129, 1, 3, // 7622: decode to VSOXSEG3EI16_V using decoder 3
4794 // 7622: }
4795 24, 11, // 7627: case 0x18: {
4796 OPC_CheckPredicate, 21, // 7629: check predicate 21
4797 OPC_CheckField, 20, 5, 0, // 7631: check Inst[24:20] == 0x0
4798 OPC_Decode, 243, 129, 1, 1, // 7635: decode to VSSEG4E16_V using decoder 1
4799 // 7635: }
4800 25, 7, // 7640: case 0x19: {
4801 OPC_CheckPredicate, 21, // 7642: check predicate 21
4802 OPC_Decode, 187, 130, 1, 3, // 7644: decode to VSUXSEG4EI16_V using decoder 3
4803 // 7644: }
4804 26, 7, // 7649: case 0x1a: {
4805 OPC_CheckPredicate, 21, // 7651: check predicate 21
4806 OPC_Decode, 149, 130, 1, 4, // 7653: decode to VSSSEG4E16_V using decoder 4
4807 // 7653: }
4808 27, 7, // 7658: case 0x1b: {
4809 OPC_CheckPredicate, 21, // 7660: check predicate 21
4810 OPC_Decode, 205, 129, 1, 3, // 7662: decode to VSOXSEG4EI16_V using decoder 3
4811 // 7662: }
4812 32, 11, // 7667: case 0x20: {
4813 OPC_CheckPredicate, 21, // 7669: check predicate 21
4814 OPC_CheckField, 20, 5, 0, // 7671: check Inst[24:20] == 0x0
4815 OPC_Decode, 247, 129, 1, 1, // 7675: decode to VSSEG5E16_V using decoder 1
4816 // 7675: }
4817 33, 7, // 7680: case 0x21: {
4818 OPC_CheckPredicate, 21, // 7682: check predicate 21
4819 OPC_Decode, 191, 130, 1, 3, // 7684: decode to VSUXSEG5EI16_V using decoder 3
4820 // 7684: }
4821 34, 7, // 7689: case 0x22: {
4822 OPC_CheckPredicate, 21, // 7691: check predicate 21
4823 OPC_Decode, 153, 130, 1, 4, // 7693: decode to VSSSEG5E16_V using decoder 4
4824 // 7693: }
4825 35, 7, // 7698: case 0x23: {
4826 OPC_CheckPredicate, 21, // 7700: check predicate 21
4827 OPC_Decode, 209, 129, 1, 3, // 7702: decode to VSOXSEG5EI16_V using decoder 3
4828 // 7702: }
4829 40, 11, // 7707: case 0x28: {
4830 OPC_CheckPredicate, 21, // 7709: check predicate 21
4831 OPC_CheckField, 20, 5, 0, // 7711: check Inst[24:20] == 0x0
4832 OPC_Decode, 251, 129, 1, 1, // 7715: decode to VSSEG6E16_V using decoder 1
4833 // 7715: }
4834 41, 7, // 7720: case 0x29: {
4835 OPC_CheckPredicate, 21, // 7722: check predicate 21
4836 OPC_Decode, 195, 130, 1, 3, // 7724: decode to VSUXSEG6EI16_V using decoder 3
4837 // 7724: }
4838 42, 7, // 7729: case 0x2a: {
4839 OPC_CheckPredicate, 21, // 7731: check predicate 21
4840 OPC_Decode, 157, 130, 1, 4, // 7733: decode to VSSSEG6E16_V using decoder 4
4841 // 7733: }
4842 43, 7, // 7738: case 0x2b: {
4843 OPC_CheckPredicate, 21, // 7740: check predicate 21
4844 OPC_Decode, 213, 129, 1, 3, // 7742: decode to VSOXSEG6EI16_V using decoder 3
4845 // 7742: }
4846 48, 11, // 7747: case 0x30: {
4847 OPC_CheckPredicate, 21, // 7749: check predicate 21
4848 OPC_CheckField, 20, 5, 0, // 7751: check Inst[24:20] == 0x0
4849 OPC_Decode, 255, 129, 1, 1, // 7755: decode to VSSEG7E16_V using decoder 1
4850 // 7755: }
4851 49, 7, // 7760: case 0x31: {
4852 OPC_CheckPredicate, 21, // 7762: check predicate 21
4853 OPC_Decode, 199, 130, 1, 3, // 7764: decode to VSUXSEG7EI16_V using decoder 3
4854 // 7764: }
4855 50, 7, // 7769: case 0x32: {
4856 OPC_CheckPredicate, 21, // 7771: check predicate 21
4857 OPC_Decode, 161, 130, 1, 4, // 7773: decode to VSSSEG7E16_V using decoder 4
4858 // 7773: }
4859 51, 7, // 7778: case 0x33: {
4860 OPC_CheckPredicate, 21, // 7780: check predicate 21
4861 OPC_Decode, 217, 129, 1, 3, // 7782: decode to VSOXSEG7EI16_V using decoder 3
4862 // 7782: }
4863 56, 11, // 7787: case 0x38: {
4864 OPC_CheckPredicate, 21, // 7789: check predicate 21
4865 OPC_CheckField, 20, 5, 0, // 7791: check Inst[24:20] == 0x0
4866 OPC_Decode, 131, 130, 1, 1, // 7795: decode to VSSEG8E16_V using decoder 1
4867 // 7795: }
4868 57, 7, // 7800: case 0x39: {
4869 OPC_CheckPredicate, 21, // 7802: check predicate 21
4870 OPC_Decode, 203, 130, 1, 3, // 7804: decode to VSUXSEG8EI16_V using decoder 3
4871 // 7804: }
4872 58, 7, // 7809: case 0x3a: {
4873 OPC_CheckPredicate, 21, // 7811: check predicate 21
4874 OPC_Decode, 165, 130, 1, 4, // 7813: decode to VSSSEG8E16_V using decoder 4
4875 // 7813: }
4876 59, 0, // 7818: case 0x3b: {
4877 OPC_CheckPredicate, 21, // 7820: check predicate 21
4878 OPC_Decode, 221, 129, 1, 3, // 7822: decode to VSOXSEG8EI16_V using decoder 3
4879 // 7822: }
4880 // 7822: } // switch Inst[31:26]
4881 // 7822: }
4882 6, 195, 2, // 7827: case 0x6: {
4883 OPC_SwitchField, 26, 6, // 7830: switch Inst[31:26] {
4884 0, 11, // 7833: case 0x0: {
4885 OPC_CheckPredicate, 21, // 7835: check predicate 21
4886 OPC_CheckField, 20, 5, 0, // 7837: check Inst[24:20] == 0x0
4887 OPC_Decode, 164, 129, 1, 1, // 7841: decode to VSE32_V using decoder 1
4888 // 7841: }
4889 1, 7, // 7846: case 0x1: {
4890 OPC_CheckPredicate, 21, // 7848: check predicate 21
4891 OPC_Decode, 176, 130, 1, 3, // 7850: decode to VSUXEI32_V using decoder 3
4892 // 7850: }
4893 2, 7, // 7855: case 0x2: {
4894 OPC_CheckPredicate, 21, // 7857: check predicate 21
4895 OPC_Decode, 232, 129, 1, 4, // 7859: decode to VSSE32_V using decoder 4
4896 // 7859: }
4897 3, 7, // 7864: case 0x3: {
4898 OPC_CheckPredicate, 21, // 7866: check predicate 21
4899 OPC_Decode, 194, 129, 1, 3, // 7868: decode to VSOXEI32_V using decoder 3
4900 // 7868: }
4901 8, 11, // 7873: case 0x8: {
4902 OPC_CheckPredicate, 21, // 7875: check predicate 21
4903 OPC_CheckField, 20, 5, 0, // 7877: check Inst[24:20] == 0x0
4904 OPC_Decode, 236, 129, 1, 1, // 7881: decode to VSSEG2E32_V using decoder 1
4905 // 7881: }
4906 9, 7, // 7886: case 0x9: {
4907 OPC_CheckPredicate, 21, // 7888: check predicate 21
4908 OPC_Decode, 180, 130, 1, 3, // 7890: decode to VSUXSEG2EI32_V using decoder 3
4909 // 7890: }
4910 10, 7, // 7895: case 0xa: {
4911 OPC_CheckPredicate, 21, // 7897: check predicate 21
4912 OPC_Decode, 142, 130, 1, 4, // 7899: decode to VSSSEG2E32_V using decoder 4
4913 // 7899: }
4914 11, 7, // 7904: case 0xb: {
4915 OPC_CheckPredicate, 21, // 7906: check predicate 21
4916 OPC_Decode, 198, 129, 1, 3, // 7908: decode to VSOXSEG2EI32_V using decoder 3
4917 // 7908: }
4918 16, 11, // 7913: case 0x10: {
4919 OPC_CheckPredicate, 21, // 7915: check predicate 21
4920 OPC_CheckField, 20, 5, 0, // 7917: check Inst[24:20] == 0x0
4921 OPC_Decode, 240, 129, 1, 1, // 7921: decode to VSSEG3E32_V using decoder 1
4922 // 7921: }
4923 17, 7, // 7926: case 0x11: {
4924 OPC_CheckPredicate, 21, // 7928: check predicate 21
4925 OPC_Decode, 184, 130, 1, 3, // 7930: decode to VSUXSEG3EI32_V using decoder 3
4926 // 7930: }
4927 18, 7, // 7935: case 0x12: {
4928 OPC_CheckPredicate, 21, // 7937: check predicate 21
4929 OPC_Decode, 146, 130, 1, 4, // 7939: decode to VSSSEG3E32_V using decoder 4
4930 // 7939: }
4931 19, 7, // 7944: case 0x13: {
4932 OPC_CheckPredicate, 21, // 7946: check predicate 21
4933 OPC_Decode, 202, 129, 1, 3, // 7948: decode to VSOXSEG3EI32_V using decoder 3
4934 // 7948: }
4935 24, 11, // 7953: case 0x18: {
4936 OPC_CheckPredicate, 21, // 7955: check predicate 21
4937 OPC_CheckField, 20, 5, 0, // 7957: check Inst[24:20] == 0x0
4938 OPC_Decode, 244, 129, 1, 1, // 7961: decode to VSSEG4E32_V using decoder 1
4939 // 7961: }
4940 25, 7, // 7966: case 0x19: {
4941 OPC_CheckPredicate, 21, // 7968: check predicate 21
4942 OPC_Decode, 188, 130, 1, 3, // 7970: decode to VSUXSEG4EI32_V using decoder 3
4943 // 7970: }
4944 26, 7, // 7975: case 0x1a: {
4945 OPC_CheckPredicate, 21, // 7977: check predicate 21
4946 OPC_Decode, 150, 130, 1, 4, // 7979: decode to VSSSEG4E32_V using decoder 4
4947 // 7979: }
4948 27, 7, // 7984: case 0x1b: {
4949 OPC_CheckPredicate, 21, // 7986: check predicate 21
4950 OPC_Decode, 206, 129, 1, 3, // 7988: decode to VSOXSEG4EI32_V using decoder 3
4951 // 7988: }
4952 32, 11, // 7993: case 0x20: {
4953 OPC_CheckPredicate, 21, // 7995: check predicate 21
4954 OPC_CheckField, 20, 5, 0, // 7997: check Inst[24:20] == 0x0
4955 OPC_Decode, 248, 129, 1, 1, // 8001: decode to VSSEG5E32_V using decoder 1
4956 // 8001: }
4957 33, 7, // 8006: case 0x21: {
4958 OPC_CheckPredicate, 21, // 8008: check predicate 21
4959 OPC_Decode, 192, 130, 1, 3, // 8010: decode to VSUXSEG5EI32_V using decoder 3
4960 // 8010: }
4961 34, 7, // 8015: case 0x22: {
4962 OPC_CheckPredicate, 21, // 8017: check predicate 21
4963 OPC_Decode, 154, 130, 1, 4, // 8019: decode to VSSSEG5E32_V using decoder 4
4964 // 8019: }
4965 35, 7, // 8024: case 0x23: {
4966 OPC_CheckPredicate, 21, // 8026: check predicate 21
4967 OPC_Decode, 210, 129, 1, 3, // 8028: decode to VSOXSEG5EI32_V using decoder 3
4968 // 8028: }
4969 40, 11, // 8033: case 0x28: {
4970 OPC_CheckPredicate, 21, // 8035: check predicate 21
4971 OPC_CheckField, 20, 5, 0, // 8037: check Inst[24:20] == 0x0
4972 OPC_Decode, 252, 129, 1, 1, // 8041: decode to VSSEG6E32_V using decoder 1
4973 // 8041: }
4974 41, 7, // 8046: case 0x29: {
4975 OPC_CheckPredicate, 21, // 8048: check predicate 21
4976 OPC_Decode, 196, 130, 1, 3, // 8050: decode to VSUXSEG6EI32_V using decoder 3
4977 // 8050: }
4978 42, 7, // 8055: case 0x2a: {
4979 OPC_CheckPredicate, 21, // 8057: check predicate 21
4980 OPC_Decode, 158, 130, 1, 4, // 8059: decode to VSSSEG6E32_V using decoder 4
4981 // 8059: }
4982 43, 7, // 8064: case 0x2b: {
4983 OPC_CheckPredicate, 21, // 8066: check predicate 21
4984 OPC_Decode, 214, 129, 1, 3, // 8068: decode to VSOXSEG6EI32_V using decoder 3
4985 // 8068: }
4986 48, 11, // 8073: case 0x30: {
4987 OPC_CheckPredicate, 21, // 8075: check predicate 21
4988 OPC_CheckField, 20, 5, 0, // 8077: check Inst[24:20] == 0x0
4989 OPC_Decode, 128, 130, 1, 1, // 8081: decode to VSSEG7E32_V using decoder 1
4990 // 8081: }
4991 49, 7, // 8086: case 0x31: {
4992 OPC_CheckPredicate, 21, // 8088: check predicate 21
4993 OPC_Decode, 200, 130, 1, 3, // 8090: decode to VSUXSEG7EI32_V using decoder 3
4994 // 8090: }
4995 50, 7, // 8095: case 0x32: {
4996 OPC_CheckPredicate, 21, // 8097: check predicate 21
4997 OPC_Decode, 162, 130, 1, 4, // 8099: decode to VSSSEG7E32_V using decoder 4
4998 // 8099: }
4999 51, 7, // 8104: case 0x33: {
5000 OPC_CheckPredicate, 21, // 8106: check predicate 21
5001 OPC_Decode, 218, 129, 1, 3, // 8108: decode to VSOXSEG7EI32_V using decoder 3
5002 // 8108: }
5003 56, 11, // 8113: case 0x38: {
5004 OPC_CheckPredicate, 21, // 8115: check predicate 21
5005 OPC_CheckField, 20, 5, 0, // 8117: check Inst[24:20] == 0x0
5006 OPC_Decode, 132, 130, 1, 1, // 8121: decode to VSSEG8E32_V using decoder 1
5007 // 8121: }
5008 57, 7, // 8126: case 0x39: {
5009 OPC_CheckPredicate, 21, // 8128: check predicate 21
5010 OPC_Decode, 204, 130, 1, 3, // 8130: decode to VSUXSEG8EI32_V using decoder 3
5011 // 8130: }
5012 58, 7, // 8135: case 0x3a: {
5013 OPC_CheckPredicate, 21, // 8137: check predicate 21
5014 OPC_Decode, 166, 130, 1, 4, // 8139: decode to VSSSEG8E32_V using decoder 4
5015 // 8139: }
5016 59, 0, // 8144: case 0x3b: {
5017 OPC_CheckPredicate, 21, // 8146: check predicate 21
5018 OPC_Decode, 222, 129, 1, 3, // 8148: decode to VSOXSEG8EI32_V using decoder 3
5019 // 8148: }
5020 // 8148: } // switch Inst[31:26]
5021 // 8148: }
5022 7, 0, // 8153: case 0x7: {
5023 OPC_SwitchField, 26, 6, // 8155: switch Inst[31:26] {
5024 0, 11, // 8158: case 0x0: {
5025 OPC_CheckPredicate, 26, // 8160: check predicate 26
5026 OPC_CheckField, 20, 5, 0, // 8162: check Inst[24:20] == 0x0
5027 OPC_Decode, 165, 129, 1, 1, // 8166: decode to VSE64_V using decoder 1
5028 // 8166: }
5029 1, 7, // 8171: case 0x1: {
5030 OPC_CheckPredicate, 27, // 8173: check predicate 27
5031 OPC_Decode, 177, 130, 1, 3, // 8175: decode to VSUXEI64_V using decoder 3
5032 // 8175: }
5033 2, 7, // 8180: case 0x2: {
5034 OPC_CheckPredicate, 26, // 8182: check predicate 26
5035 OPC_Decode, 233, 129, 1, 4, // 8184: decode to VSSE64_V using decoder 4
5036 // 8184: }
5037 3, 7, // 8189: case 0x3: {
5038 OPC_CheckPredicate, 27, // 8191: check predicate 27
5039 OPC_Decode, 195, 129, 1, 3, // 8193: decode to VSOXEI64_V using decoder 3
5040 // 8193: }
5041 8, 11, // 8198: case 0x8: {
5042 OPC_CheckPredicate, 26, // 8200: check predicate 26
5043 OPC_CheckField, 20, 5, 0, // 8202: check Inst[24:20] == 0x0
5044 OPC_Decode, 237, 129, 1, 1, // 8206: decode to VSSEG2E64_V using decoder 1
5045 // 8206: }
5046 9, 7, // 8211: case 0x9: {
5047 OPC_CheckPredicate, 28, // 8213: check predicate 28
5048 OPC_Decode, 181, 130, 1, 3, // 8215: decode to VSUXSEG2EI64_V using decoder 3
5049 // 8215: }
5050 10, 7, // 8220: case 0xa: {
5051 OPC_CheckPredicate, 26, // 8222: check predicate 26
5052 OPC_Decode, 143, 130, 1, 4, // 8224: decode to VSSSEG2E64_V using decoder 4
5053 // 8224: }
5054 11, 7, // 8229: case 0xb: {
5055 OPC_CheckPredicate, 28, // 8231: check predicate 28
5056 OPC_Decode, 199, 129, 1, 3, // 8233: decode to VSOXSEG2EI64_V using decoder 3
5057 // 8233: }
5058 16, 11, // 8238: case 0x10: {
5059 OPC_CheckPredicate, 26, // 8240: check predicate 26
5060 OPC_CheckField, 20, 5, 0, // 8242: check Inst[24:20] == 0x0
5061 OPC_Decode, 241, 129, 1, 1, // 8246: decode to VSSEG3E64_V using decoder 1
5062 // 8246: }
5063 17, 7, // 8251: case 0x11: {
5064 OPC_CheckPredicate, 28, // 8253: check predicate 28
5065 OPC_Decode, 185, 130, 1, 3, // 8255: decode to VSUXSEG3EI64_V using decoder 3
5066 // 8255: }
5067 18, 7, // 8260: case 0x12: {
5068 OPC_CheckPredicate, 26, // 8262: check predicate 26
5069 OPC_Decode, 147, 130, 1, 4, // 8264: decode to VSSSEG3E64_V using decoder 4
5070 // 8264: }
5071 19, 7, // 8269: case 0x13: {
5072 OPC_CheckPredicate, 28, // 8271: check predicate 28
5073 OPC_Decode, 203, 129, 1, 3, // 8273: decode to VSOXSEG3EI64_V using decoder 3
5074 // 8273: }
5075 24, 11, // 8278: case 0x18: {
5076 OPC_CheckPredicate, 26, // 8280: check predicate 26
5077 OPC_CheckField, 20, 5, 0, // 8282: check Inst[24:20] == 0x0
5078 OPC_Decode, 245, 129, 1, 1, // 8286: decode to VSSEG4E64_V using decoder 1
5079 // 8286: }
5080 25, 7, // 8291: case 0x19: {
5081 OPC_CheckPredicate, 28, // 8293: check predicate 28
5082 OPC_Decode, 189, 130, 1, 3, // 8295: decode to VSUXSEG4EI64_V using decoder 3
5083 // 8295: }
5084 26, 7, // 8300: case 0x1a: {
5085 OPC_CheckPredicate, 26, // 8302: check predicate 26
5086 OPC_Decode, 151, 130, 1, 4, // 8304: decode to VSSSEG4E64_V using decoder 4
5087 // 8304: }
5088 27, 7, // 8309: case 0x1b: {
5089 OPC_CheckPredicate, 28, // 8311: check predicate 28
5090 OPC_Decode, 207, 129, 1, 3, // 8313: decode to VSOXSEG4EI64_V using decoder 3
5091 // 8313: }
5092 32, 11, // 8318: case 0x20: {
5093 OPC_CheckPredicate, 26, // 8320: check predicate 26
5094 OPC_CheckField, 20, 5, 0, // 8322: check Inst[24:20] == 0x0
5095 OPC_Decode, 249, 129, 1, 1, // 8326: decode to VSSEG5E64_V using decoder 1
5096 // 8326: }
5097 33, 7, // 8331: case 0x21: {
5098 OPC_CheckPredicate, 28, // 8333: check predicate 28
5099 OPC_Decode, 193, 130, 1, 3, // 8335: decode to VSUXSEG5EI64_V using decoder 3
5100 // 8335: }
5101 34, 7, // 8340: case 0x22: {
5102 OPC_CheckPredicate, 26, // 8342: check predicate 26
5103 OPC_Decode, 155, 130, 1, 4, // 8344: decode to VSSSEG5E64_V using decoder 4
5104 // 8344: }
5105 35, 7, // 8349: case 0x23: {
5106 OPC_CheckPredicate, 28, // 8351: check predicate 28
5107 OPC_Decode, 211, 129, 1, 3, // 8353: decode to VSOXSEG5EI64_V using decoder 3
5108 // 8353: }
5109 40, 11, // 8358: case 0x28: {
5110 OPC_CheckPredicate, 26, // 8360: check predicate 26
5111 OPC_CheckField, 20, 5, 0, // 8362: check Inst[24:20] == 0x0
5112 OPC_Decode, 253, 129, 1, 1, // 8366: decode to VSSEG6E64_V using decoder 1
5113 // 8366: }
5114 41, 7, // 8371: case 0x29: {
5115 OPC_CheckPredicate, 28, // 8373: check predicate 28
5116 OPC_Decode, 197, 130, 1, 3, // 8375: decode to VSUXSEG6EI64_V using decoder 3
5117 // 8375: }
5118 42, 7, // 8380: case 0x2a: {
5119 OPC_CheckPredicate, 26, // 8382: check predicate 26
5120 OPC_Decode, 159, 130, 1, 4, // 8384: decode to VSSSEG6E64_V using decoder 4
5121 // 8384: }
5122 43, 7, // 8389: case 0x2b: {
5123 OPC_CheckPredicate, 28, // 8391: check predicate 28
5124 OPC_Decode, 215, 129, 1, 3, // 8393: decode to VSOXSEG6EI64_V using decoder 3
5125 // 8393: }
5126 48, 11, // 8398: case 0x30: {
5127 OPC_CheckPredicate, 26, // 8400: check predicate 26
5128 OPC_CheckField, 20, 5, 0, // 8402: check Inst[24:20] == 0x0
5129 OPC_Decode, 129, 130, 1, 1, // 8406: decode to VSSEG7E64_V using decoder 1
5130 // 8406: }
5131 49, 7, // 8411: case 0x31: {
5132 OPC_CheckPredicate, 28, // 8413: check predicate 28
5133 OPC_Decode, 201, 130, 1, 3, // 8415: decode to VSUXSEG7EI64_V using decoder 3
5134 // 8415: }
5135 50, 7, // 8420: case 0x32: {
5136 OPC_CheckPredicate, 26, // 8422: check predicate 26
5137 OPC_Decode, 163, 130, 1, 4, // 8424: decode to VSSSEG7E64_V using decoder 4
5138 // 8424: }
5139 51, 7, // 8429: case 0x33: {
5140 OPC_CheckPredicate, 28, // 8431: check predicate 28
5141 OPC_Decode, 219, 129, 1, 3, // 8433: decode to VSOXSEG7EI64_V using decoder 3
5142 // 8433: }
5143 56, 11, // 8438: case 0x38: {
5144 OPC_CheckPredicate, 26, // 8440: check predicate 26
5145 OPC_CheckField, 20, 5, 0, // 8442: check Inst[24:20] == 0x0
5146 OPC_Decode, 133, 130, 1, 1, // 8446: decode to VSSEG8E64_V using decoder 1
5147 // 8446: }
5148 57, 7, // 8451: case 0x39: {
5149 OPC_CheckPredicate, 28, // 8453: check predicate 28
5150 OPC_Decode, 205, 130, 1, 3, // 8455: decode to VSUXSEG8EI64_V using decoder 3
5151 // 8455: }
5152 58, 7, // 8460: case 0x3a: {
5153 OPC_CheckPredicate, 26, // 8462: check predicate 26
5154 OPC_Decode, 167, 130, 1, 4, // 8464: decode to VSSSEG8E64_V using decoder 4
5155 // 8464: }
5156 59, 0, // 8469: case 0x3b: {
5157 OPC_CheckPredicate, 28, // 8471: check predicate 28
5158 OPC_Decode, 223, 129, 1, 3, // 8473: decode to VSOXSEG8EI64_V using decoder 3
5159 // 8473: }
5160 // 8473: } // switch Inst[31:26]
5161 // 8473: }
5162 // 8473: } // switch Inst[14:12]
5163 // 8473: }
5164 47, 187, 15, // 8478: case 0x2f: {
5165 OPC_SwitchField, 25, 7, // 8481: switch Inst[31:25] {
5166 0, 35, // 8484: case 0x0: {
5167 OPC_SwitchField, 12, 3, // 8486: switch Inst[14:12] {
5168 0, 6, // 8489: case 0x0: {
5169 OPC_CheckPredicate, 49, // 8491: check predicate 49
5170 OPC_Decode, 129, 109, 53, // 8493: decode to AMOADD_B using decoder 53
5171 // 8493: }
5172 1, 6, // 8497: case 0x1: {
5173 OPC_CheckPredicate, 49, // 8499: check predicate 49
5174 OPC_Decode, 137, 109, 53, // 8501: decode to AMOADD_H using decoder 53
5175 // 8501: }
5176 2, 6, // 8505: case 0x2: {
5177 OPC_CheckPredicate, 50, // 8507: check predicate 50
5178 OPC_Decode, 141, 109, 53, // 8509: decode to AMOADD_W using decoder 53
5179 // 8509: }
5180 3, 0, // 8513: case 0x3: {
5181 OPC_CheckPredicate, 51, // 8515: check predicate 51
5182 OPC_Decode, 133, 109, 53, // 8517: decode to AMOADD_D using decoder 53
5183 // 8517: }
5184 // 8517: } // switch Inst[14:12]
5185 // 8517: }
5186 1, 35, // 8521: case 0x1: {
5187 OPC_SwitchField, 12, 3, // 8523: switch Inst[14:12] {
5188 0, 6, // 8526: case 0x0: {
5189 OPC_CheckPredicate, 49, // 8528: check predicate 49
5190 OPC_Decode, 132, 109, 53, // 8530: decode to AMOADD_B_RL using decoder 53
5191 // 8530: }
5192 1, 6, // 8534: case 0x1: {
5193 OPC_CheckPredicate, 49, // 8536: check predicate 49
5194 OPC_Decode, 140, 109, 53, // 8538: decode to AMOADD_H_RL using decoder 53
5195 // 8538: }
5196 2, 6, // 8542: case 0x2: {
5197 OPC_CheckPredicate, 50, // 8544: check predicate 50
5198 OPC_Decode, 144, 109, 53, // 8546: decode to AMOADD_W_RL using decoder 53
5199 // 8546: }
5200 3, 0, // 8550: case 0x3: {
5201 OPC_CheckPredicate, 51, // 8552: check predicate 51
5202 OPC_Decode, 136, 109, 53, // 8554: decode to AMOADD_D_RL using decoder 53
5203 // 8554: }
5204 // 8554: } // switch Inst[14:12]
5205 // 8554: }
5206 2, 35, // 8558: case 0x2: {
5207 OPC_SwitchField, 12, 3, // 8560: switch Inst[14:12] {
5208 0, 6, // 8563: case 0x0: {
5209 OPC_CheckPredicate, 49, // 8565: check predicate 49
5210 OPC_Decode, 130, 109, 53, // 8567: decode to AMOADD_B_AQ using decoder 53
5211 // 8567: }
5212 1, 6, // 8571: case 0x1: {
5213 OPC_CheckPredicate, 49, // 8573: check predicate 49
5214 OPC_Decode, 138, 109, 53, // 8575: decode to AMOADD_H_AQ using decoder 53
5215 // 8575: }
5216 2, 6, // 8579: case 0x2: {
5217 OPC_CheckPredicate, 50, // 8581: check predicate 50
5218 OPC_Decode, 142, 109, 53, // 8583: decode to AMOADD_W_AQ using decoder 53
5219 // 8583: }
5220 3, 0, // 8587: case 0x3: {
5221 OPC_CheckPredicate, 51, // 8589: check predicate 51
5222 OPC_Decode, 134, 109, 53, // 8591: decode to AMOADD_D_AQ using decoder 53
5223 // 8591: }
5224 // 8591: } // switch Inst[14:12]
5225 // 8591: }
5226 3, 35, // 8595: case 0x3: {
5227 OPC_SwitchField, 12, 3, // 8597: switch Inst[14:12] {
5228 0, 6, // 8600: case 0x0: {
5229 OPC_CheckPredicate, 49, // 8602: check predicate 49
5230 OPC_Decode, 131, 109, 53, // 8604: decode to AMOADD_B_AQRL using decoder 53
5231 // 8604: }
5232 1, 6, // 8608: case 0x1: {
5233 OPC_CheckPredicate, 49, // 8610: check predicate 49
5234 OPC_Decode, 139, 109, 53, // 8612: decode to AMOADD_H_AQRL using decoder 53
5235 // 8612: }
5236 2, 6, // 8616: case 0x2: {
5237 OPC_CheckPredicate, 50, // 8618: check predicate 50
5238 OPC_Decode, 143, 109, 53, // 8620: decode to AMOADD_W_AQRL using decoder 53
5239 // 8620: }
5240 3, 0, // 8624: case 0x3: {
5241 OPC_CheckPredicate, 51, // 8626: check predicate 51
5242 OPC_Decode, 135, 109, 53, // 8628: decode to AMOADD_D_AQRL using decoder 53
5243 // 8628: }
5244 // 8628: } // switch Inst[14:12]
5245 // 8628: }
5246 4, 35, // 8632: case 0x4: {
5247 OPC_SwitchField, 12, 3, // 8634: switch Inst[14:12] {
5248 0, 6, // 8637: case 0x0: {
5249 OPC_CheckPredicate, 49, // 8639: check predicate 49
5250 OPC_Decode, 137, 110, 53, // 8641: decode to AMOSWAP_B using decoder 53
5251 // 8641: }
5252 1, 6, // 8645: case 0x1: {
5253 OPC_CheckPredicate, 49, // 8647: check predicate 49
5254 OPC_Decode, 145, 110, 53, // 8649: decode to AMOSWAP_H using decoder 53
5255 // 8649: }
5256 2, 6, // 8653: case 0x2: {
5257 OPC_CheckPredicate, 50, // 8655: check predicate 50
5258 OPC_Decode, 149, 110, 53, // 8657: decode to AMOSWAP_W using decoder 53
5259 // 8657: }
5260 3, 0, // 8661: case 0x3: {
5261 OPC_CheckPredicate, 51, // 8663: check predicate 51
5262 OPC_Decode, 141, 110, 53, // 8665: decode to AMOSWAP_D using decoder 53
5263 // 8665: }
5264 // 8665: } // switch Inst[14:12]
5265 // 8665: }
5266 5, 35, // 8669: case 0x5: {
5267 OPC_SwitchField, 12, 3, // 8671: switch Inst[14:12] {
5268 0, 6, // 8674: case 0x0: {
5269 OPC_CheckPredicate, 49, // 8676: check predicate 49
5270 OPC_Decode, 140, 110, 53, // 8678: decode to AMOSWAP_B_RL using decoder 53
5271 // 8678: }
5272 1, 6, // 8682: case 0x1: {
5273 OPC_CheckPredicate, 49, // 8684: check predicate 49
5274 OPC_Decode, 148, 110, 53, // 8686: decode to AMOSWAP_H_RL using decoder 53
5275 // 8686: }
5276 2, 6, // 8690: case 0x2: {
5277 OPC_CheckPredicate, 50, // 8692: check predicate 50
5278 OPC_Decode, 152, 110, 53, // 8694: decode to AMOSWAP_W_RL using decoder 53
5279 // 8694: }
5280 3, 0, // 8698: case 0x3: {
5281 OPC_CheckPredicate, 51, // 8700: check predicate 51
5282 OPC_Decode, 144, 110, 53, // 8702: decode to AMOSWAP_D_RL using decoder 53
5283 // 8702: }
5284 // 8702: } // switch Inst[14:12]
5285 // 8702: }
5286 6, 35, // 8706: case 0x6: {
5287 OPC_SwitchField, 12, 3, // 8708: switch Inst[14:12] {
5288 0, 6, // 8711: case 0x0: {
5289 OPC_CheckPredicate, 49, // 8713: check predicate 49
5290 OPC_Decode, 138, 110, 53, // 8715: decode to AMOSWAP_B_AQ using decoder 53
5291 // 8715: }
5292 1, 6, // 8719: case 0x1: {
5293 OPC_CheckPredicate, 49, // 8721: check predicate 49
5294 OPC_Decode, 146, 110, 53, // 8723: decode to AMOSWAP_H_AQ using decoder 53
5295 // 8723: }
5296 2, 6, // 8727: case 0x2: {
5297 OPC_CheckPredicate, 50, // 8729: check predicate 50
5298 OPC_Decode, 150, 110, 53, // 8731: decode to AMOSWAP_W_AQ using decoder 53
5299 // 8731: }
5300 3, 0, // 8735: case 0x3: {
5301 OPC_CheckPredicate, 51, // 8737: check predicate 51
5302 OPC_Decode, 142, 110, 53, // 8739: decode to AMOSWAP_D_AQ using decoder 53
5303 // 8739: }
5304 // 8739: } // switch Inst[14:12]
5305 // 8739: }
5306 7, 35, // 8743: case 0x7: {
5307 OPC_SwitchField, 12, 3, // 8745: switch Inst[14:12] {
5308 0, 6, // 8748: case 0x0: {
5309 OPC_CheckPredicate, 49, // 8750: check predicate 49
5310 OPC_Decode, 139, 110, 53, // 8752: decode to AMOSWAP_B_AQRL using decoder 53
5311 // 8752: }
5312 1, 6, // 8756: case 0x1: {
5313 OPC_CheckPredicate, 49, // 8758: check predicate 49
5314 OPC_Decode, 147, 110, 53, // 8760: decode to AMOSWAP_H_AQRL using decoder 53
5315 // 8760: }
5316 2, 6, // 8764: case 0x2: {
5317 OPC_CheckPredicate, 50, // 8766: check predicate 50
5318 OPC_Decode, 151, 110, 53, // 8768: decode to AMOSWAP_W_AQRL using decoder 53
5319 // 8768: }
5320 3, 0, // 8772: case 0x3: {
5321 OPC_CheckPredicate, 51, // 8774: check predicate 51
5322 OPC_Decode, 143, 110, 53, // 8776: decode to AMOSWAP_D_AQRL using decoder 53
5323 // 8776: }
5324 // 8776: } // switch Inst[14:12]
5325 // 8776: }
5326 8, 27, // 8780: case 0x8: {
5327 OPC_SwitchField, 12, 3, // 8782: switch Inst[14:12] {
5328 2, 10, // 8785: case 0x2: {
5329 OPC_CheckPredicate, 52, // 8787: check predicate 52
5330 OPC_CheckField, 20, 5, 0, // 8789: check Inst[24:20] == 0x0
5331 OPC_Decode, 188, 116, 16, // 8793: decode to LR_W using decoder 16
5332 // 8793: }
5333 3, 0, // 8797: case 0x3: {
5334 OPC_CheckPredicate, 53, // 8799: check predicate 53
5335 OPC_CheckField, 20, 5, 0, // 8801: check Inst[24:20] == 0x0
5336 OPC_Decode, 184, 116, 16, // 8805: decode to LR_D using decoder 16
5337 // 8805: }
5338 // 8805: } // switch Inst[14:12]
5339 // 8805: }
5340 9, 27, // 8809: case 0x9: {
5341 OPC_SwitchField, 12, 3, // 8811: switch Inst[14:12] {
5342 2, 10, // 8814: case 0x2: {
5343 OPC_CheckPredicate, 52, // 8816: check predicate 52
5344 OPC_CheckField, 20, 5, 0, // 8818: check Inst[24:20] == 0x0
5345 OPC_Decode, 191, 116, 16, // 8822: decode to LR_W_RL using decoder 16
5346 // 8822: }
5347 3, 0, // 8826: case 0x3: {
5348 OPC_CheckPredicate, 53, // 8828: check predicate 53
5349 OPC_CheckField, 20, 5, 0, // 8830: check Inst[24:20] == 0x0
5350 OPC_Decode, 187, 116, 16, // 8834: decode to LR_D_RL using decoder 16
5351 // 8834: }
5352 // 8834: } // switch Inst[14:12]
5353 // 8834: }
5354 10, 27, // 8838: case 0xa: {
5355 OPC_SwitchField, 12, 3, // 8840: switch Inst[14:12] {
5356 2, 10, // 8843: case 0x2: {
5357 OPC_CheckPredicate, 52, // 8845: check predicate 52
5358 OPC_CheckField, 20, 5, 0, // 8847: check Inst[24:20] == 0x0
5359 OPC_Decode, 189, 116, 16, // 8851: decode to LR_W_AQ using decoder 16
5360 // 8851: }
5361 3, 0, // 8855: case 0x3: {
5362 OPC_CheckPredicate, 53, // 8857: check predicate 53
5363 OPC_CheckField, 20, 5, 0, // 8859: check Inst[24:20] == 0x0
5364 OPC_Decode, 185, 116, 16, // 8863: decode to LR_D_AQ using decoder 16
5365 // 8863: }
5366 // 8863: } // switch Inst[14:12]
5367 // 8863: }
5368 11, 27, // 8867: case 0xb: {
5369 OPC_SwitchField, 12, 3, // 8869: switch Inst[14:12] {
5370 2, 10, // 8872: case 0x2: {
5371 OPC_CheckPredicate, 52, // 8874: check predicate 52
5372 OPC_CheckField, 20, 5, 0, // 8876: check Inst[24:20] == 0x0
5373 OPC_Decode, 190, 116, 16, // 8880: decode to LR_W_AQRL using decoder 16
5374 // 8880: }
5375 3, 0, // 8884: case 0x3: {
5376 OPC_CheckPredicate, 53, // 8886: check predicate 53
5377 OPC_CheckField, 20, 5, 0, // 8888: check Inst[24:20] == 0x0
5378 OPC_Decode, 186, 116, 16, // 8892: decode to LR_D_AQRL using decoder 16
5379 // 8892: }
5380 // 8892: } // switch Inst[14:12]
5381 // 8892: }
5382 12, 19, // 8896: case 0xc: {
5383 OPC_SwitchField, 12, 3, // 8898: switch Inst[14:12] {
5384 2, 6, // 8901: case 0x2: {
5385 OPC_CheckPredicate, 52, // 8903: check predicate 52
5386 OPC_Decode, 159, 123, 53, // 8905: decode to SC_W using decoder 53
5387 // 8905: }
5388 3, 0, // 8909: case 0x3: {
5389 OPC_CheckPredicate, 53, // 8911: check predicate 53
5390 OPC_Decode, 155, 123, 53, // 8913: decode to SC_D using decoder 53
5391 // 8913: }
5392 // 8913: } // switch Inst[14:12]
5393 // 8913: }
5394 13, 19, // 8917: case 0xd: {
5395 OPC_SwitchField, 12, 3, // 8919: switch Inst[14:12] {
5396 2, 6, // 8922: case 0x2: {
5397 OPC_CheckPredicate, 52, // 8924: check predicate 52
5398 OPC_Decode, 162, 123, 53, // 8926: decode to SC_W_RL using decoder 53
5399 // 8926: }
5400 3, 0, // 8930: case 0x3: {
5401 OPC_CheckPredicate, 53, // 8932: check predicate 53
5402 OPC_Decode, 158, 123, 53, // 8934: decode to SC_D_RL using decoder 53
5403 // 8934: }
5404 // 8934: } // switch Inst[14:12]
5405 // 8934: }
5406 14, 19, // 8938: case 0xe: {
5407 OPC_SwitchField, 12, 3, // 8940: switch Inst[14:12] {
5408 2, 6, // 8943: case 0x2: {
5409 OPC_CheckPredicate, 52, // 8945: check predicate 52
5410 OPC_Decode, 160, 123, 53, // 8947: decode to SC_W_AQ using decoder 53
5411 // 8947: }
5412 3, 0, // 8951: case 0x3: {
5413 OPC_CheckPredicate, 53, // 8953: check predicate 53
5414 OPC_Decode, 156, 123, 53, // 8955: decode to SC_D_AQ using decoder 53
5415 // 8955: }
5416 // 8955: } // switch Inst[14:12]
5417 // 8955: }
5418 15, 19, // 8959: case 0xf: {
5419 OPC_SwitchField, 12, 3, // 8961: switch Inst[14:12] {
5420 2, 6, // 8964: case 0x2: {
5421 OPC_CheckPredicate, 52, // 8966: check predicate 52
5422 OPC_Decode, 161, 123, 53, // 8968: decode to SC_W_AQRL using decoder 53
5423 // 8968: }
5424 3, 0, // 8972: case 0x3: {
5425 OPC_CheckPredicate, 53, // 8974: check predicate 53
5426 OPC_Decode, 157, 123, 53, // 8976: decode to SC_D_AQRL using decoder 53
5427 // 8976: }
5428 // 8976: } // switch Inst[14:12]
5429 // 8976: }
5430 16, 35, // 8980: case 0x10: {
5431 OPC_SwitchField, 12, 3, // 8982: switch Inst[14:12] {
5432 0, 6, // 8985: case 0x0: {
5433 OPC_CheckPredicate, 49, // 8987: check predicate 49
5434 OPC_Decode, 153, 110, 53, // 8989: decode to AMOXOR_B using decoder 53
5435 // 8989: }
5436 1, 6, // 8993: case 0x1: {
5437 OPC_CheckPredicate, 49, // 8995: check predicate 49
5438 OPC_Decode, 161, 110, 53, // 8997: decode to AMOXOR_H using decoder 53
5439 // 8997: }
5440 2, 6, // 9001: case 0x2: {
5441 OPC_CheckPredicate, 50, // 9003: check predicate 50
5442 OPC_Decode, 165, 110, 53, // 9005: decode to AMOXOR_W using decoder 53
5443 // 9005: }
5444 3, 0, // 9009: case 0x3: {
5445 OPC_CheckPredicate, 51, // 9011: check predicate 51
5446 OPC_Decode, 157, 110, 53, // 9013: decode to AMOXOR_D using decoder 53
5447 // 9013: }
5448 // 9013: } // switch Inst[14:12]
5449 // 9013: }
5450 17, 35, // 9017: case 0x11: {
5451 OPC_SwitchField, 12, 3, // 9019: switch Inst[14:12] {
5452 0, 6, // 9022: case 0x0: {
5453 OPC_CheckPredicate, 49, // 9024: check predicate 49
5454 OPC_Decode, 156, 110, 53, // 9026: decode to AMOXOR_B_RL using decoder 53
5455 // 9026: }
5456 1, 6, // 9030: case 0x1: {
5457 OPC_CheckPredicate, 49, // 9032: check predicate 49
5458 OPC_Decode, 164, 110, 53, // 9034: decode to AMOXOR_H_RL using decoder 53
5459 // 9034: }
5460 2, 6, // 9038: case 0x2: {
5461 OPC_CheckPredicate, 50, // 9040: check predicate 50
5462 OPC_Decode, 168, 110, 53, // 9042: decode to AMOXOR_W_RL using decoder 53
5463 // 9042: }
5464 3, 0, // 9046: case 0x3: {
5465 OPC_CheckPredicate, 51, // 9048: check predicate 51
5466 OPC_Decode, 160, 110, 53, // 9050: decode to AMOXOR_D_RL using decoder 53
5467 // 9050: }
5468 // 9050: } // switch Inst[14:12]
5469 // 9050: }
5470 18, 35, // 9054: case 0x12: {
5471 OPC_SwitchField, 12, 3, // 9056: switch Inst[14:12] {
5472 0, 6, // 9059: case 0x0: {
5473 OPC_CheckPredicate, 49, // 9061: check predicate 49
5474 OPC_Decode, 154, 110, 53, // 9063: decode to AMOXOR_B_AQ using decoder 53
5475 // 9063: }
5476 1, 6, // 9067: case 0x1: {
5477 OPC_CheckPredicate, 49, // 9069: check predicate 49
5478 OPC_Decode, 162, 110, 53, // 9071: decode to AMOXOR_H_AQ using decoder 53
5479 // 9071: }
5480 2, 6, // 9075: case 0x2: {
5481 OPC_CheckPredicate, 50, // 9077: check predicate 50
5482 OPC_Decode, 166, 110, 53, // 9079: decode to AMOXOR_W_AQ using decoder 53
5483 // 9079: }
5484 3, 0, // 9083: case 0x3: {
5485 OPC_CheckPredicate, 51, // 9085: check predicate 51
5486 OPC_Decode, 158, 110, 53, // 9087: decode to AMOXOR_D_AQ using decoder 53
5487 // 9087: }
5488 // 9087: } // switch Inst[14:12]
5489 // 9087: }
5490 19, 35, // 9091: case 0x13: {
5491 OPC_SwitchField, 12, 3, // 9093: switch Inst[14:12] {
5492 0, 6, // 9096: case 0x0: {
5493 OPC_CheckPredicate, 49, // 9098: check predicate 49
5494 OPC_Decode, 155, 110, 53, // 9100: decode to AMOXOR_B_AQRL using decoder 53
5495 // 9100: }
5496 1, 6, // 9104: case 0x1: {
5497 OPC_CheckPredicate, 49, // 9106: check predicate 49
5498 OPC_Decode, 163, 110, 53, // 9108: decode to AMOXOR_H_AQRL using decoder 53
5499 // 9108: }
5500 2, 6, // 9112: case 0x2: {
5501 OPC_CheckPredicate, 50, // 9114: check predicate 50
5502 OPC_Decode, 167, 110, 53, // 9116: decode to AMOXOR_W_AQRL using decoder 53
5503 // 9116: }
5504 3, 0, // 9120: case 0x3: {
5505 OPC_CheckPredicate, 51, // 9122: check predicate 51
5506 OPC_Decode, 159, 110, 53, // 9124: decode to AMOXOR_D_AQRL using decoder 53
5507 // 9124: }
5508 // 9124: } // switch Inst[14:12]
5509 // 9124: }
5510 20, 43, // 9128: case 0x14: {
5511 OPC_SwitchField, 12, 3, // 9130: switch Inst[14:12] {
5512 0, 6, // 9133: case 0x0: {
5513 OPC_CheckPredicate, 54, // 9135: check predicate 54
5514 OPC_Decode, 161, 109, 54, // 9137: decode to AMOCAS_B using decoder 54
5515 // 9137: }
5516 1, 6, // 9141: case 0x1: {
5517 OPC_CheckPredicate, 54, // 9143: check predicate 54
5518 OPC_Decode, 173, 109, 54, // 9145: decode to AMOCAS_H using decoder 54
5519 // 9145: }
5520 2, 6, // 9149: case 0x2: {
5521 OPC_CheckPredicate, 55, // 9151: check predicate 55
5522 OPC_Decode, 181, 109, 54, // 9153: decode to AMOCAS_W using decoder 54
5523 // 9153: }
5524 3, 6, // 9157: case 0x3: {
5525 OPC_CheckPredicate, 56, // 9159: check predicate 56
5526 OPC_Decode, 169, 109, 54, // 9161: decode to AMOCAS_D_RV64 using decoder 54
5527 // 9161: }
5528 4, 0, // 9165: case 0x4: {
5529 OPC_CheckPredicate, 56, // 9167: check predicate 56
5530 OPC_Decode, 177, 109, 55, // 9169: decode to AMOCAS_Q using decoder 55
5531 // 9169: }
5532 // 9169: } // switch Inst[14:12]
5533 // 9169: }
5534 21, 43, // 9173: case 0x15: {
5535 OPC_SwitchField, 12, 3, // 9175: switch Inst[14:12] {
5536 0, 6, // 9178: case 0x0: {
5537 OPC_CheckPredicate, 54, // 9180: check predicate 54
5538 OPC_Decode, 164, 109, 54, // 9182: decode to AMOCAS_B_RL using decoder 54
5539 // 9182: }
5540 1, 6, // 9186: case 0x1: {
5541 OPC_CheckPredicate, 54, // 9188: check predicate 54
5542 OPC_Decode, 176, 109, 54, // 9190: decode to AMOCAS_H_RL using decoder 54
5543 // 9190: }
5544 2, 6, // 9194: case 0x2: {
5545 OPC_CheckPredicate, 55, // 9196: check predicate 55
5546 OPC_Decode, 184, 109, 54, // 9198: decode to AMOCAS_W_RL using decoder 54
5547 // 9198: }
5548 3, 6, // 9202: case 0x3: {
5549 OPC_CheckPredicate, 56, // 9204: check predicate 56
5550 OPC_Decode, 172, 109, 54, // 9206: decode to AMOCAS_D_RV64_RL using decoder 54
5551 // 9206: }
5552 4, 0, // 9210: case 0x4: {
5553 OPC_CheckPredicate, 56, // 9212: check predicate 56
5554 OPC_Decode, 180, 109, 55, // 9214: decode to AMOCAS_Q_RL using decoder 55
5555 // 9214: }
5556 // 9214: } // switch Inst[14:12]
5557 // 9214: }
5558 22, 43, // 9218: case 0x16: {
5559 OPC_SwitchField, 12, 3, // 9220: switch Inst[14:12] {
5560 0, 6, // 9223: case 0x0: {
5561 OPC_CheckPredicate, 54, // 9225: check predicate 54
5562 OPC_Decode, 162, 109, 54, // 9227: decode to AMOCAS_B_AQ using decoder 54
5563 // 9227: }
5564 1, 6, // 9231: case 0x1: {
5565 OPC_CheckPredicate, 54, // 9233: check predicate 54
5566 OPC_Decode, 174, 109, 54, // 9235: decode to AMOCAS_H_AQ using decoder 54
5567 // 9235: }
5568 2, 6, // 9239: case 0x2: {
5569 OPC_CheckPredicate, 55, // 9241: check predicate 55
5570 OPC_Decode, 182, 109, 54, // 9243: decode to AMOCAS_W_AQ using decoder 54
5571 // 9243: }
5572 3, 6, // 9247: case 0x3: {
5573 OPC_CheckPredicate, 56, // 9249: check predicate 56
5574 OPC_Decode, 170, 109, 54, // 9251: decode to AMOCAS_D_RV64_AQ using decoder 54
5575 // 9251: }
5576 4, 0, // 9255: case 0x4: {
5577 OPC_CheckPredicate, 56, // 9257: check predicate 56
5578 OPC_Decode, 178, 109, 55, // 9259: decode to AMOCAS_Q_AQ using decoder 55
5579 // 9259: }
5580 // 9259: } // switch Inst[14:12]
5581 // 9259: }
5582 23, 43, // 9263: case 0x17: {
5583 OPC_SwitchField, 12, 3, // 9265: switch Inst[14:12] {
5584 0, 6, // 9268: case 0x0: {
5585 OPC_CheckPredicate, 54, // 9270: check predicate 54
5586 OPC_Decode, 163, 109, 54, // 9272: decode to AMOCAS_B_AQRL using decoder 54
5587 // 9272: }
5588 1, 6, // 9276: case 0x1: {
5589 OPC_CheckPredicate, 54, // 9278: check predicate 54
5590 OPC_Decode, 175, 109, 54, // 9280: decode to AMOCAS_H_AQRL using decoder 54
5591 // 9280: }
5592 2, 6, // 9284: case 0x2: {
5593 OPC_CheckPredicate, 55, // 9286: check predicate 55
5594 OPC_Decode, 183, 109, 54, // 9288: decode to AMOCAS_W_AQRL using decoder 54
5595 // 9288: }
5596 3, 6, // 9292: case 0x3: {
5597 OPC_CheckPredicate, 56, // 9294: check predicate 56
5598 OPC_Decode, 171, 109, 54, // 9296: decode to AMOCAS_D_RV64_AQRL using decoder 54
5599 // 9296: }
5600 4, 0, // 9300: case 0x4: {
5601 OPC_CheckPredicate, 56, // 9302: check predicate 56
5602 OPC_Decode, 179, 109, 55, // 9304: decode to AMOCAS_Q_AQRL using decoder 55
5603 // 9304: }
5604 // 9304: } // switch Inst[14:12]
5605 // 9304: }
5606 26, 51, // 9308: case 0x1a: {
5607 OPC_SwitchField, 12, 3, // 9310: switch Inst[14:12] {
5608 0, 10, // 9313: case 0x0: {
5609 OPC_CheckPredicate, 57, // 9315: check predicate 57
5610 OPC_CheckField, 20, 5, 0, // 9317: check Inst[24:20] == 0x0
5611 OPC_Decode, 173, 116, 16, // 9321: decode to LB_AQ using decoder 16
5612 // 9321: }
5613 1, 10, // 9325: case 0x1: {
5614 OPC_CheckPredicate, 57, // 9327: check predicate 57
5615 OPC_CheckField, 20, 5, 0, // 9329: check Inst[24:20] == 0x0
5616 OPC_Decode, 181, 116, 16, // 9333: decode to LH_AQ using decoder 16
5617 // 9333: }
5618 2, 10, // 9337: case 0x2: {
5619 OPC_CheckPredicate, 57, // 9339: check predicate 57
5620 OPC_CheckField, 20, 5, 0, // 9341: check Inst[24:20] == 0x0
5621 OPC_Decode, 195, 116, 16, // 9345: decode to LW_AQ using decoder 16
5622 // 9345: }
5623 3, 0, // 9349: case 0x3: {
5624 OPC_CheckPredicate, 58, // 9351: check predicate 58
5625 OPC_CheckField, 20, 5, 0, // 9353: check Inst[24:20] == 0x0
5626 OPC_Decode, 176, 116, 16, // 9357: decode to LD_AQ using decoder 16
5627 // 9357: }
5628 // 9357: } // switch Inst[14:12]
5629 // 9357: }
5630 27, 51, // 9361: case 0x1b: {
5631 OPC_SwitchField, 12, 3, // 9363: switch Inst[14:12] {
5632 0, 10, // 9366: case 0x0: {
5633 OPC_CheckPredicate, 57, // 9368: check predicate 57
5634 OPC_CheckField, 20, 5, 0, // 9370: check Inst[24:20] == 0x0
5635 OPC_Decode, 174, 116, 16, // 9374: decode to LB_AQRL using decoder 16
5636 // 9374: }
5637 1, 10, // 9378: case 0x1: {
5638 OPC_CheckPredicate, 57, // 9380: check predicate 57
5639 OPC_CheckField, 20, 5, 0, // 9382: check Inst[24:20] == 0x0
5640 OPC_Decode, 182, 116, 16, // 9386: decode to LH_AQRL using decoder 16
5641 // 9386: }
5642 2, 10, // 9390: case 0x2: {
5643 OPC_CheckPredicate, 57, // 9392: check predicate 57
5644 OPC_CheckField, 20, 5, 0, // 9394: check Inst[24:20] == 0x0
5645 OPC_Decode, 196, 116, 16, // 9398: decode to LW_AQRL using decoder 16
5646 // 9398: }
5647 3, 0, // 9402: case 0x3: {
5648 OPC_CheckPredicate, 58, // 9404: check predicate 58
5649 OPC_CheckField, 20, 5, 0, // 9406: check Inst[24:20] == 0x0
5650 OPC_Decode, 177, 116, 16, // 9410: decode to LD_AQRL using decoder 16
5651 // 9410: }
5652 // 9410: } // switch Inst[14:12]
5653 // 9410: }
5654 29, 35, // 9414: case 0x1d: {
5655 OPC_SwitchField, 7, 8, // 9416: switch Inst[14:7] {
5656 0, 6, // 9419: case 0x0: {
5657 OPC_CheckPredicate, 57, // 9421: check predicate 57
5658 OPC_Decode, 153, 123, 56, // 9423: decode to SB_RL using decoder 56
5659 // 9423: }
5660 32, 6, // 9427: case 0x20: {
5661 OPC_CheckPredicate, 57, // 9429: check predicate 57
5662 OPC_Decode, 139, 124, 56, // 9431: decode to SH_RL using decoder 56
5663 // 9431: }
5664 64, 6, // 9435: case 0x40: {
5665 OPC_CheckPredicate, 57, // 9437: check predicate 57
5666 OPC_Decode, 208, 124, 56, // 9439: decode to SW_RL using decoder 56
5667 // 9439: }
5668 96, 0, // 9443: case 0x60: {
5669 OPC_CheckPredicate, 58, // 9445: check predicate 58
5670 OPC_Decode, 165, 123, 56, // 9447: decode to SD_RL using decoder 56
5671 // 9447: }
5672 // 9447: } // switch Inst[14:7]
5673 // 9447: }
5674 31, 35, // 9451: case 0x1f: {
5675 OPC_SwitchField, 7, 8, // 9453: switch Inst[14:7] {
5676 0, 6, // 9456: case 0x0: {
5677 OPC_CheckPredicate, 57, // 9458: check predicate 57
5678 OPC_Decode, 152, 123, 56, // 9460: decode to SB_AQRL using decoder 56
5679 // 9460: }
5680 32, 6, // 9464: case 0x20: {
5681 OPC_CheckPredicate, 57, // 9466: check predicate 57
5682 OPC_Decode, 137, 124, 56, // 9468: decode to SH_AQRL using decoder 56
5683 // 9468: }
5684 64, 6, // 9472: case 0x40: {
5685 OPC_CheckPredicate, 57, // 9474: check predicate 57
5686 OPC_Decode, 206, 124, 56, // 9476: decode to SW_AQRL using decoder 56
5687 // 9476: }
5688 96, 0, // 9480: case 0x60: {
5689 OPC_CheckPredicate, 58, // 9482: check predicate 58
5690 OPC_Decode, 164, 123, 56, // 9484: decode to SD_AQRL using decoder 56
5691 // 9484: }
5692 // 9484: } // switch Inst[14:7]
5693 // 9484: }
5694 32, 35, // 9488: case 0x20: {
5695 OPC_SwitchField, 12, 3, // 9490: switch Inst[14:12] {
5696 0, 6, // 9493: case 0x0: {
5697 OPC_CheckPredicate, 49, // 9495: check predicate 49
5698 OPC_Decode, 249, 109, 53, // 9497: decode to AMOOR_B using decoder 53
5699 // 9497: }
5700 1, 6, // 9501: case 0x1: {
5701 OPC_CheckPredicate, 49, // 9503: check predicate 49
5702 OPC_Decode, 129, 110, 53, // 9505: decode to AMOOR_H using decoder 53
5703 // 9505: }
5704 2, 6, // 9509: case 0x2: {
5705 OPC_CheckPredicate, 50, // 9511: check predicate 50
5706 OPC_Decode, 133, 110, 53, // 9513: decode to AMOOR_W using decoder 53
5707 // 9513: }
5708 3, 0, // 9517: case 0x3: {
5709 OPC_CheckPredicate, 51, // 9519: check predicate 51
5710 OPC_Decode, 253, 109, 53, // 9521: decode to AMOOR_D using decoder 53
5711 // 9521: }
5712 // 9521: } // switch Inst[14:12]
5713 // 9521: }
5714 33, 35, // 9525: case 0x21: {
5715 OPC_SwitchField, 12, 3, // 9527: switch Inst[14:12] {
5716 0, 6, // 9530: case 0x0: {
5717 OPC_CheckPredicate, 49, // 9532: check predicate 49
5718 OPC_Decode, 252, 109, 53, // 9534: decode to AMOOR_B_RL using decoder 53
5719 // 9534: }
5720 1, 6, // 9538: case 0x1: {
5721 OPC_CheckPredicate, 49, // 9540: check predicate 49
5722 OPC_Decode, 132, 110, 53, // 9542: decode to AMOOR_H_RL using decoder 53
5723 // 9542: }
5724 2, 6, // 9546: case 0x2: {
5725 OPC_CheckPredicate, 50, // 9548: check predicate 50
5726 OPC_Decode, 136, 110, 53, // 9550: decode to AMOOR_W_RL using decoder 53
5727 // 9550: }
5728 3, 0, // 9554: case 0x3: {
5729 OPC_CheckPredicate, 51, // 9556: check predicate 51
5730 OPC_Decode, 128, 110, 53, // 9558: decode to AMOOR_D_RL using decoder 53
5731 // 9558: }
5732 // 9558: } // switch Inst[14:12]
5733 // 9558: }
5734 34, 35, // 9562: case 0x22: {
5735 OPC_SwitchField, 12, 3, // 9564: switch Inst[14:12] {
5736 0, 6, // 9567: case 0x0: {
5737 OPC_CheckPredicate, 49, // 9569: check predicate 49
5738 OPC_Decode, 250, 109, 53, // 9571: decode to AMOOR_B_AQ using decoder 53
5739 // 9571: }
5740 1, 6, // 9575: case 0x1: {
5741 OPC_CheckPredicate, 49, // 9577: check predicate 49
5742 OPC_Decode, 130, 110, 53, // 9579: decode to AMOOR_H_AQ using decoder 53
5743 // 9579: }
5744 2, 6, // 9583: case 0x2: {
5745 OPC_CheckPredicate, 50, // 9585: check predicate 50
5746 OPC_Decode, 134, 110, 53, // 9587: decode to AMOOR_W_AQ using decoder 53
5747 // 9587: }
5748 3, 0, // 9591: case 0x3: {
5749 OPC_CheckPredicate, 51, // 9593: check predicate 51
5750 OPC_Decode, 254, 109, 53, // 9595: decode to AMOOR_D_AQ using decoder 53
5751 // 9595: }
5752 // 9595: } // switch Inst[14:12]
5753 // 9595: }
5754 35, 35, // 9599: case 0x23: {
5755 OPC_SwitchField, 12, 3, // 9601: switch Inst[14:12] {
5756 0, 6, // 9604: case 0x0: {
5757 OPC_CheckPredicate, 49, // 9606: check predicate 49
5758 OPC_Decode, 251, 109, 53, // 9608: decode to AMOOR_B_AQRL using decoder 53
5759 // 9608: }
5760 1, 6, // 9612: case 0x1: {
5761 OPC_CheckPredicate, 49, // 9614: check predicate 49
5762 OPC_Decode, 131, 110, 53, // 9616: decode to AMOOR_H_AQRL using decoder 53
5763 // 9616: }
5764 2, 6, // 9620: case 0x2: {
5765 OPC_CheckPredicate, 50, // 9622: check predicate 50
5766 OPC_Decode, 135, 110, 53, // 9624: decode to AMOOR_W_AQRL using decoder 53
5767 // 9624: }
5768 3, 0, // 9628: case 0x3: {
5769 OPC_CheckPredicate, 51, // 9630: check predicate 51
5770 OPC_Decode, 255, 109, 53, // 9632: decode to AMOOR_D_AQRL using decoder 53
5771 // 9632: }
5772 // 9632: } // switch Inst[14:12]
5773 // 9632: }
5774 36, 19, // 9636: case 0x24: {
5775 OPC_SwitchField, 12, 3, // 9638: switch Inst[14:12] {
5776 2, 6, // 9641: case 0x2: {
5777 OPC_CheckPredicate, 59, // 9643: check predicate 59
5778 OPC_Decode, 187, 124, 53, // 9645: decode to SSAMOSWAP_W using decoder 53
5779 // 9645: }
5780 3, 0, // 9649: case 0x3: {
5781 OPC_CheckPredicate, 60, // 9651: check predicate 60
5782 OPC_Decode, 183, 124, 53, // 9653: decode to SSAMOSWAP_D using decoder 53
5783 // 9653: }
5784 // 9653: } // switch Inst[14:12]
5785 // 9653: }
5786 37, 19, // 9657: case 0x25: {
5787 OPC_SwitchField, 12, 3, // 9659: switch Inst[14:12] {
5788 2, 6, // 9662: case 0x2: {
5789 OPC_CheckPredicate, 59, // 9664: check predicate 59
5790 OPC_Decode, 190, 124, 53, // 9666: decode to SSAMOSWAP_W_RL using decoder 53
5791 // 9666: }
5792 3, 0, // 9670: case 0x3: {
5793 OPC_CheckPredicate, 60, // 9672: check predicate 60
5794 OPC_Decode, 186, 124, 53, // 9674: decode to SSAMOSWAP_D_RL using decoder 53
5795 // 9674: }
5796 // 9674: } // switch Inst[14:12]
5797 // 9674: }
5798 38, 19, // 9678: case 0x26: {
5799 OPC_SwitchField, 12, 3, // 9680: switch Inst[14:12] {
5800 2, 6, // 9683: case 0x2: {
5801 OPC_CheckPredicate, 59, // 9685: check predicate 59
5802 OPC_Decode, 188, 124, 53, // 9687: decode to SSAMOSWAP_W_AQ using decoder 53
5803 // 9687: }
5804 3, 0, // 9691: case 0x3: {
5805 OPC_CheckPredicate, 60, // 9693: check predicate 60
5806 OPC_Decode, 184, 124, 53, // 9695: decode to SSAMOSWAP_D_AQ using decoder 53
5807 // 9695: }
5808 // 9695: } // switch Inst[14:12]
5809 // 9695: }
5810 39, 19, // 9699: case 0x27: {
5811 OPC_SwitchField, 12, 3, // 9701: switch Inst[14:12] {
5812 2, 6, // 9704: case 0x2: {
5813 OPC_CheckPredicate, 59, // 9706: check predicate 59
5814 OPC_Decode, 189, 124, 53, // 9708: decode to SSAMOSWAP_W_AQRL using decoder 53
5815 // 9708: }
5816 3, 0, // 9712: case 0x3: {
5817 OPC_CheckPredicate, 60, // 9714: check predicate 60
5818 OPC_Decode, 185, 124, 53, // 9716: decode to SSAMOSWAP_D_AQRL using decoder 53
5819 // 9716: }
5820 // 9716: } // switch Inst[14:12]
5821 // 9716: }
5822 48, 35, // 9720: case 0x30: {
5823 OPC_SwitchField, 12, 3, // 9722: switch Inst[14:12] {
5824 0, 6, // 9725: case 0x0: {
5825 OPC_CheckPredicate, 49, // 9727: check predicate 49
5826 OPC_Decode, 145, 109, 53, // 9729: decode to AMOAND_B using decoder 53
5827 // 9729: }
5828 1, 6, // 9733: case 0x1: {
5829 OPC_CheckPredicate, 49, // 9735: check predicate 49
5830 OPC_Decode, 153, 109, 53, // 9737: decode to AMOAND_H using decoder 53
5831 // 9737: }
5832 2, 6, // 9741: case 0x2: {
5833 OPC_CheckPredicate, 50, // 9743: check predicate 50
5834 OPC_Decode, 157, 109, 53, // 9745: decode to AMOAND_W using decoder 53
5835 // 9745: }
5836 3, 0, // 9749: case 0x3: {
5837 OPC_CheckPredicate, 51, // 9751: check predicate 51
5838 OPC_Decode, 149, 109, 53, // 9753: decode to AMOAND_D using decoder 53
5839 // 9753: }
5840 // 9753: } // switch Inst[14:12]
5841 // 9753: }
5842 49, 35, // 9757: case 0x31: {
5843 OPC_SwitchField, 12, 3, // 9759: switch Inst[14:12] {
5844 0, 6, // 9762: case 0x0: {
5845 OPC_CheckPredicate, 49, // 9764: check predicate 49
5846 OPC_Decode, 148, 109, 53, // 9766: decode to AMOAND_B_RL using decoder 53
5847 // 9766: }
5848 1, 6, // 9770: case 0x1: {
5849 OPC_CheckPredicate, 49, // 9772: check predicate 49
5850 OPC_Decode, 156, 109, 53, // 9774: decode to AMOAND_H_RL using decoder 53
5851 // 9774: }
5852 2, 6, // 9778: case 0x2: {
5853 OPC_CheckPredicate, 50, // 9780: check predicate 50
5854 OPC_Decode, 160, 109, 53, // 9782: decode to AMOAND_W_RL using decoder 53
5855 // 9782: }
5856 3, 0, // 9786: case 0x3: {
5857 OPC_CheckPredicate, 51, // 9788: check predicate 51
5858 OPC_Decode, 152, 109, 53, // 9790: decode to AMOAND_D_RL using decoder 53
5859 // 9790: }
5860 // 9790: } // switch Inst[14:12]
5861 // 9790: }
5862 50, 35, // 9794: case 0x32: {
5863 OPC_SwitchField, 12, 3, // 9796: switch Inst[14:12] {
5864 0, 6, // 9799: case 0x0: {
5865 OPC_CheckPredicate, 49, // 9801: check predicate 49
5866 OPC_Decode, 146, 109, 53, // 9803: decode to AMOAND_B_AQ using decoder 53
5867 // 9803: }
5868 1, 6, // 9807: case 0x1: {
5869 OPC_CheckPredicate, 49, // 9809: check predicate 49
5870 OPC_Decode, 154, 109, 53, // 9811: decode to AMOAND_H_AQ using decoder 53
5871 // 9811: }
5872 2, 6, // 9815: case 0x2: {
5873 OPC_CheckPredicate, 50, // 9817: check predicate 50
5874 OPC_Decode, 158, 109, 53, // 9819: decode to AMOAND_W_AQ using decoder 53
5875 // 9819: }
5876 3, 0, // 9823: case 0x3: {
5877 OPC_CheckPredicate, 51, // 9825: check predicate 51
5878 OPC_Decode, 150, 109, 53, // 9827: decode to AMOAND_D_AQ using decoder 53
5879 // 9827: }
5880 // 9827: } // switch Inst[14:12]
5881 // 9827: }
5882 51, 35, // 9831: case 0x33: {
5883 OPC_SwitchField, 12, 3, // 9833: switch Inst[14:12] {
5884 0, 6, // 9836: case 0x0: {
5885 OPC_CheckPredicate, 49, // 9838: check predicate 49
5886 OPC_Decode, 147, 109, 53, // 9840: decode to AMOAND_B_AQRL using decoder 53
5887 // 9840: }
5888 1, 6, // 9844: case 0x1: {
5889 OPC_CheckPredicate, 49, // 9846: check predicate 49
5890 OPC_Decode, 155, 109, 53, // 9848: decode to AMOAND_H_AQRL using decoder 53
5891 // 9848: }
5892 2, 6, // 9852: case 0x2: {
5893 OPC_CheckPredicate, 50, // 9854: check predicate 50
5894 OPC_Decode, 159, 109, 53, // 9856: decode to AMOAND_W_AQRL using decoder 53
5895 // 9856: }
5896 3, 0, // 9860: case 0x3: {
5897 OPC_CheckPredicate, 51, // 9862: check predicate 51
5898 OPC_Decode, 151, 109, 53, // 9864: decode to AMOAND_D_AQRL using decoder 53
5899 // 9864: }
5900 // 9864: } // switch Inst[14:12]
5901 // 9864: }
5902 64, 35, // 9868: case 0x40: {
5903 OPC_SwitchField, 12, 3, // 9870: switch Inst[14:12] {
5904 0, 6, // 9873: case 0x0: {
5905 OPC_CheckPredicate, 49, // 9875: check predicate 49
5906 OPC_Decode, 233, 109, 53, // 9877: decode to AMOMIN_B using decoder 53
5907 // 9877: }
5908 1, 6, // 9881: case 0x1: {
5909 OPC_CheckPredicate, 49, // 9883: check predicate 49
5910 OPC_Decode, 241, 109, 53, // 9885: decode to AMOMIN_H using decoder 53
5911 // 9885: }
5912 2, 6, // 9889: case 0x2: {
5913 OPC_CheckPredicate, 50, // 9891: check predicate 50
5914 OPC_Decode, 245, 109, 53, // 9893: decode to AMOMIN_W using decoder 53
5915 // 9893: }
5916 3, 0, // 9897: case 0x3: {
5917 OPC_CheckPredicate, 51, // 9899: check predicate 51
5918 OPC_Decode, 237, 109, 53, // 9901: decode to AMOMIN_D using decoder 53
5919 // 9901: }
5920 // 9901: } // switch Inst[14:12]
5921 // 9901: }
5922 65, 35, // 9905: case 0x41: {
5923 OPC_SwitchField, 12, 3, // 9907: switch Inst[14:12] {
5924 0, 6, // 9910: case 0x0: {
5925 OPC_CheckPredicate, 49, // 9912: check predicate 49
5926 OPC_Decode, 236, 109, 53, // 9914: decode to AMOMIN_B_RL using decoder 53
5927 // 9914: }
5928 1, 6, // 9918: case 0x1: {
5929 OPC_CheckPredicate, 49, // 9920: check predicate 49
5930 OPC_Decode, 244, 109, 53, // 9922: decode to AMOMIN_H_RL using decoder 53
5931 // 9922: }
5932 2, 6, // 9926: case 0x2: {
5933 OPC_CheckPredicate, 50, // 9928: check predicate 50
5934 OPC_Decode, 248, 109, 53, // 9930: decode to AMOMIN_W_RL using decoder 53
5935 // 9930: }
5936 3, 0, // 9934: case 0x3: {
5937 OPC_CheckPredicate, 51, // 9936: check predicate 51
5938 OPC_Decode, 240, 109, 53, // 9938: decode to AMOMIN_D_RL using decoder 53
5939 // 9938: }
5940 // 9938: } // switch Inst[14:12]
5941 // 9938: }
5942 66, 35, // 9942: case 0x42: {
5943 OPC_SwitchField, 12, 3, // 9944: switch Inst[14:12] {
5944 0, 6, // 9947: case 0x0: {
5945 OPC_CheckPredicate, 49, // 9949: check predicate 49
5946 OPC_Decode, 234, 109, 53, // 9951: decode to AMOMIN_B_AQ using decoder 53
5947 // 9951: }
5948 1, 6, // 9955: case 0x1: {
5949 OPC_CheckPredicate, 49, // 9957: check predicate 49
5950 OPC_Decode, 242, 109, 53, // 9959: decode to AMOMIN_H_AQ using decoder 53
5951 // 9959: }
5952 2, 6, // 9963: case 0x2: {
5953 OPC_CheckPredicate, 50, // 9965: check predicate 50
5954 OPC_Decode, 246, 109, 53, // 9967: decode to AMOMIN_W_AQ using decoder 53
5955 // 9967: }
5956 3, 0, // 9971: case 0x3: {
5957 OPC_CheckPredicate, 51, // 9973: check predicate 51
5958 OPC_Decode, 238, 109, 53, // 9975: decode to AMOMIN_D_AQ using decoder 53
5959 // 9975: }
5960 // 9975: } // switch Inst[14:12]
5961 // 9975: }
5962 67, 35, // 9979: case 0x43: {
5963 OPC_SwitchField, 12, 3, // 9981: switch Inst[14:12] {
5964 0, 6, // 9984: case 0x0: {
5965 OPC_CheckPredicate, 49, // 9986: check predicate 49
5966 OPC_Decode, 235, 109, 53, // 9988: decode to AMOMIN_B_AQRL using decoder 53
5967 // 9988: }
5968 1, 6, // 9992: case 0x1: {
5969 OPC_CheckPredicate, 49, // 9994: check predicate 49
5970 OPC_Decode, 243, 109, 53, // 9996: decode to AMOMIN_H_AQRL using decoder 53
5971 // 9996: }
5972 2, 6, // 10000: case 0x2: {
5973 OPC_CheckPredicate, 50, // 10002: check predicate 50
5974 OPC_Decode, 247, 109, 53, // 10004: decode to AMOMIN_W_AQRL using decoder 53
5975 // 10004: }
5976 3, 0, // 10008: case 0x3: {
5977 OPC_CheckPredicate, 51, // 10010: check predicate 51
5978 OPC_Decode, 239, 109, 53, // 10012: decode to AMOMIN_D_AQRL using decoder 53
5979 // 10012: }
5980 // 10012: } // switch Inst[14:12]
5981 // 10012: }
5982 80, 35, // 10016: case 0x50: {
5983 OPC_SwitchField, 12, 3, // 10018: switch Inst[14:12] {
5984 0, 6, // 10021: case 0x0: {
5985 OPC_CheckPredicate, 49, // 10023: check predicate 49
5986 OPC_Decode, 201, 109, 53, // 10025: decode to AMOMAX_B using decoder 53
5987 // 10025: }
5988 1, 6, // 10029: case 0x1: {
5989 OPC_CheckPredicate, 49, // 10031: check predicate 49
5990 OPC_Decode, 209, 109, 53, // 10033: decode to AMOMAX_H using decoder 53
5991 // 10033: }
5992 2, 6, // 10037: case 0x2: {
5993 OPC_CheckPredicate, 50, // 10039: check predicate 50
5994 OPC_Decode, 213, 109, 53, // 10041: decode to AMOMAX_W using decoder 53
5995 // 10041: }
5996 3, 0, // 10045: case 0x3: {
5997 OPC_CheckPredicate, 51, // 10047: check predicate 51
5998 OPC_Decode, 205, 109, 53, // 10049: decode to AMOMAX_D using decoder 53
5999 // 10049: }
6000 // 10049: } // switch Inst[14:12]
6001 // 10049: }
6002 81, 35, // 10053: case 0x51: {
6003 OPC_SwitchField, 12, 3, // 10055: switch Inst[14:12] {
6004 0, 6, // 10058: case 0x0: {
6005 OPC_CheckPredicate, 49, // 10060: check predicate 49
6006 OPC_Decode, 204, 109, 53, // 10062: decode to AMOMAX_B_RL using decoder 53
6007 // 10062: }
6008 1, 6, // 10066: case 0x1: {
6009 OPC_CheckPredicate, 49, // 10068: check predicate 49
6010 OPC_Decode, 212, 109, 53, // 10070: decode to AMOMAX_H_RL using decoder 53
6011 // 10070: }
6012 2, 6, // 10074: case 0x2: {
6013 OPC_CheckPredicate, 50, // 10076: check predicate 50
6014 OPC_Decode, 216, 109, 53, // 10078: decode to AMOMAX_W_RL using decoder 53
6015 // 10078: }
6016 3, 0, // 10082: case 0x3: {
6017 OPC_CheckPredicate, 51, // 10084: check predicate 51
6018 OPC_Decode, 208, 109, 53, // 10086: decode to AMOMAX_D_RL using decoder 53
6019 // 10086: }
6020 // 10086: } // switch Inst[14:12]
6021 // 10086: }
6022 82, 35, // 10090: case 0x52: {
6023 OPC_SwitchField, 12, 3, // 10092: switch Inst[14:12] {
6024 0, 6, // 10095: case 0x0: {
6025 OPC_CheckPredicate, 49, // 10097: check predicate 49
6026 OPC_Decode, 202, 109, 53, // 10099: decode to AMOMAX_B_AQ using decoder 53
6027 // 10099: }
6028 1, 6, // 10103: case 0x1: {
6029 OPC_CheckPredicate, 49, // 10105: check predicate 49
6030 OPC_Decode, 210, 109, 53, // 10107: decode to AMOMAX_H_AQ using decoder 53
6031 // 10107: }
6032 2, 6, // 10111: case 0x2: {
6033 OPC_CheckPredicate, 50, // 10113: check predicate 50
6034 OPC_Decode, 214, 109, 53, // 10115: decode to AMOMAX_W_AQ using decoder 53
6035 // 10115: }
6036 3, 0, // 10119: case 0x3: {
6037 OPC_CheckPredicate, 51, // 10121: check predicate 51
6038 OPC_Decode, 206, 109, 53, // 10123: decode to AMOMAX_D_AQ using decoder 53
6039 // 10123: }
6040 // 10123: } // switch Inst[14:12]
6041 // 10123: }
6042 83, 35, // 10127: case 0x53: {
6043 OPC_SwitchField, 12, 3, // 10129: switch Inst[14:12] {
6044 0, 6, // 10132: case 0x0: {
6045 OPC_CheckPredicate, 49, // 10134: check predicate 49
6046 OPC_Decode, 203, 109, 53, // 10136: decode to AMOMAX_B_AQRL using decoder 53
6047 // 10136: }
6048 1, 6, // 10140: case 0x1: {
6049 OPC_CheckPredicate, 49, // 10142: check predicate 49
6050 OPC_Decode, 211, 109, 53, // 10144: decode to AMOMAX_H_AQRL using decoder 53
6051 // 10144: }
6052 2, 6, // 10148: case 0x2: {
6053 OPC_CheckPredicate, 50, // 10150: check predicate 50
6054 OPC_Decode, 215, 109, 53, // 10152: decode to AMOMAX_W_AQRL using decoder 53
6055 // 10152: }
6056 3, 0, // 10156: case 0x3: {
6057 OPC_CheckPredicate, 51, // 10158: check predicate 51
6058 OPC_Decode, 207, 109, 53, // 10160: decode to AMOMAX_D_AQRL using decoder 53
6059 // 10160: }
6060 // 10160: } // switch Inst[14:12]
6061 // 10160: }
6062 96, 35, // 10164: case 0x60: {
6063 OPC_SwitchField, 12, 3, // 10166: switch Inst[14:12] {
6064 0, 6, // 10169: case 0x0: {
6065 OPC_CheckPredicate, 49, // 10171: check predicate 49
6066 OPC_Decode, 217, 109, 53, // 10173: decode to AMOMINU_B using decoder 53
6067 // 10173: }
6068 1, 6, // 10177: case 0x1: {
6069 OPC_CheckPredicate, 49, // 10179: check predicate 49
6070 OPC_Decode, 225, 109, 53, // 10181: decode to AMOMINU_H using decoder 53
6071 // 10181: }
6072 2, 6, // 10185: case 0x2: {
6073 OPC_CheckPredicate, 50, // 10187: check predicate 50
6074 OPC_Decode, 229, 109, 53, // 10189: decode to AMOMINU_W using decoder 53
6075 // 10189: }
6076 3, 0, // 10193: case 0x3: {
6077 OPC_CheckPredicate, 51, // 10195: check predicate 51
6078 OPC_Decode, 221, 109, 53, // 10197: decode to AMOMINU_D using decoder 53
6079 // 10197: }
6080 // 10197: } // switch Inst[14:12]
6081 // 10197: }
6082 97, 35, // 10201: case 0x61: {
6083 OPC_SwitchField, 12, 3, // 10203: switch Inst[14:12] {
6084 0, 6, // 10206: case 0x0: {
6085 OPC_CheckPredicate, 49, // 10208: check predicate 49
6086 OPC_Decode, 220, 109, 53, // 10210: decode to AMOMINU_B_RL using decoder 53
6087 // 10210: }
6088 1, 6, // 10214: case 0x1: {
6089 OPC_CheckPredicate, 49, // 10216: check predicate 49
6090 OPC_Decode, 228, 109, 53, // 10218: decode to AMOMINU_H_RL using decoder 53
6091 // 10218: }
6092 2, 6, // 10222: case 0x2: {
6093 OPC_CheckPredicate, 50, // 10224: check predicate 50
6094 OPC_Decode, 232, 109, 53, // 10226: decode to AMOMINU_W_RL using decoder 53
6095 // 10226: }
6096 3, 0, // 10230: case 0x3: {
6097 OPC_CheckPredicate, 51, // 10232: check predicate 51
6098 OPC_Decode, 224, 109, 53, // 10234: decode to AMOMINU_D_RL using decoder 53
6099 // 10234: }
6100 // 10234: } // switch Inst[14:12]
6101 // 10234: }
6102 98, 35, // 10238: case 0x62: {
6103 OPC_SwitchField, 12, 3, // 10240: switch Inst[14:12] {
6104 0, 6, // 10243: case 0x0: {
6105 OPC_CheckPredicate, 49, // 10245: check predicate 49
6106 OPC_Decode, 218, 109, 53, // 10247: decode to AMOMINU_B_AQ using decoder 53
6107 // 10247: }
6108 1, 6, // 10251: case 0x1: {
6109 OPC_CheckPredicate, 49, // 10253: check predicate 49
6110 OPC_Decode, 226, 109, 53, // 10255: decode to AMOMINU_H_AQ using decoder 53
6111 // 10255: }
6112 2, 6, // 10259: case 0x2: {
6113 OPC_CheckPredicate, 50, // 10261: check predicate 50
6114 OPC_Decode, 230, 109, 53, // 10263: decode to AMOMINU_W_AQ using decoder 53
6115 // 10263: }
6116 3, 0, // 10267: case 0x3: {
6117 OPC_CheckPredicate, 51, // 10269: check predicate 51
6118 OPC_Decode, 222, 109, 53, // 10271: decode to AMOMINU_D_AQ using decoder 53
6119 // 10271: }
6120 // 10271: } // switch Inst[14:12]
6121 // 10271: }
6122 99, 35, // 10275: case 0x63: {
6123 OPC_SwitchField, 12, 3, // 10277: switch Inst[14:12] {
6124 0, 6, // 10280: case 0x0: {
6125 OPC_CheckPredicate, 49, // 10282: check predicate 49
6126 OPC_Decode, 219, 109, 53, // 10284: decode to AMOMINU_B_AQRL using decoder 53
6127 // 10284: }
6128 1, 6, // 10288: case 0x1: {
6129 OPC_CheckPredicate, 49, // 10290: check predicate 49
6130 OPC_Decode, 227, 109, 53, // 10292: decode to AMOMINU_H_AQRL using decoder 53
6131 // 10292: }
6132 2, 6, // 10296: case 0x2: {
6133 OPC_CheckPredicate, 50, // 10298: check predicate 50
6134 OPC_Decode, 231, 109, 53, // 10300: decode to AMOMINU_W_AQRL using decoder 53
6135 // 10300: }
6136 3, 0, // 10304: case 0x3: {
6137 OPC_CheckPredicate, 51, // 10306: check predicate 51
6138 OPC_Decode, 223, 109, 53, // 10308: decode to AMOMINU_D_AQRL using decoder 53
6139 // 10308: }
6140 // 10308: } // switch Inst[14:12]
6141 // 10308: }
6142 112, 35, // 10312: case 0x70: {
6143 OPC_SwitchField, 12, 3, // 10314: switch Inst[14:12] {
6144 0, 6, // 10317: case 0x0: {
6145 OPC_CheckPredicate, 49, // 10319: check predicate 49
6146 OPC_Decode, 185, 109, 53, // 10321: decode to AMOMAXU_B using decoder 53
6147 // 10321: }
6148 1, 6, // 10325: case 0x1: {
6149 OPC_CheckPredicate, 49, // 10327: check predicate 49
6150 OPC_Decode, 193, 109, 53, // 10329: decode to AMOMAXU_H using decoder 53
6151 // 10329: }
6152 2, 6, // 10333: case 0x2: {
6153 OPC_CheckPredicate, 50, // 10335: check predicate 50
6154 OPC_Decode, 197, 109, 53, // 10337: decode to AMOMAXU_W using decoder 53
6155 // 10337: }
6156 3, 0, // 10341: case 0x3: {
6157 OPC_CheckPredicate, 51, // 10343: check predicate 51
6158 OPC_Decode, 189, 109, 53, // 10345: decode to AMOMAXU_D using decoder 53
6159 // 10345: }
6160 // 10345: } // switch Inst[14:12]
6161 // 10345: }
6162 113, 35, // 10349: case 0x71: {
6163 OPC_SwitchField, 12, 3, // 10351: switch Inst[14:12] {
6164 0, 6, // 10354: case 0x0: {
6165 OPC_CheckPredicate, 49, // 10356: check predicate 49
6166 OPC_Decode, 188, 109, 53, // 10358: decode to AMOMAXU_B_RL using decoder 53
6167 // 10358: }
6168 1, 6, // 10362: case 0x1: {
6169 OPC_CheckPredicate, 49, // 10364: check predicate 49
6170 OPC_Decode, 196, 109, 53, // 10366: decode to AMOMAXU_H_RL using decoder 53
6171 // 10366: }
6172 2, 6, // 10370: case 0x2: {
6173 OPC_CheckPredicate, 50, // 10372: check predicate 50
6174 OPC_Decode, 200, 109, 53, // 10374: decode to AMOMAXU_W_RL using decoder 53
6175 // 10374: }
6176 3, 0, // 10378: case 0x3: {
6177 OPC_CheckPredicate, 51, // 10380: check predicate 51
6178 OPC_Decode, 192, 109, 53, // 10382: decode to AMOMAXU_D_RL using decoder 53
6179 // 10382: }
6180 // 10382: } // switch Inst[14:12]
6181 // 10382: }
6182 114, 35, // 10386: case 0x72: {
6183 OPC_SwitchField, 12, 3, // 10388: switch Inst[14:12] {
6184 0, 6, // 10391: case 0x0: {
6185 OPC_CheckPredicate, 49, // 10393: check predicate 49
6186 OPC_Decode, 186, 109, 53, // 10395: decode to AMOMAXU_B_AQ using decoder 53
6187 // 10395: }
6188 1, 6, // 10399: case 0x1: {
6189 OPC_CheckPredicate, 49, // 10401: check predicate 49
6190 OPC_Decode, 194, 109, 53, // 10403: decode to AMOMAXU_H_AQ using decoder 53
6191 // 10403: }
6192 2, 6, // 10407: case 0x2: {
6193 OPC_CheckPredicate, 50, // 10409: check predicate 50
6194 OPC_Decode, 198, 109, 53, // 10411: decode to AMOMAXU_W_AQ using decoder 53
6195 // 10411: }
6196 3, 0, // 10415: case 0x3: {
6197 OPC_CheckPredicate, 51, // 10417: check predicate 51
6198 OPC_Decode, 190, 109, 53, // 10419: decode to AMOMAXU_D_AQ using decoder 53
6199 // 10419: }
6200 // 10419: } // switch Inst[14:12]
6201 // 10419: }
6202 115, 0, // 10423: case 0x73: {
6203 OPC_SwitchField, 12, 3, // 10425: switch Inst[14:12] {
6204 0, 6, // 10428: case 0x0: {
6205 OPC_CheckPredicate, 49, // 10430: check predicate 49
6206 OPC_Decode, 187, 109, 53, // 10432: decode to AMOMAXU_B_AQRL using decoder 53
6207 // 10432: }
6208 1, 6, // 10436: case 0x1: {
6209 OPC_CheckPredicate, 49, // 10438: check predicate 49
6210 OPC_Decode, 195, 109, 53, // 10440: decode to AMOMAXU_H_AQRL using decoder 53
6211 // 10440: }
6212 2, 6, // 10444: case 0x2: {
6213 OPC_CheckPredicate, 50, // 10446: check predicate 50
6214 OPC_Decode, 199, 109, 53, // 10448: decode to AMOMAXU_W_AQRL using decoder 53
6215 // 10448: }
6216 3, 0, // 10452: case 0x3: {
6217 OPC_CheckPredicate, 51, // 10454: check predicate 51
6218 OPC_Decode, 191, 109, 53, // 10456: decode to AMOMAXU_D_AQRL using decoder 53
6219 // 10456: }
6220 // 10456: } // switch Inst[14:12]
6221 // 10456: }
6222 // 10456: } // switch Inst[31:25]
6223 // 10456: }
6224 51, 138, 6, // 10460: case 0x33: {
6225 OPC_SwitchField, 25, 5, // 10463: switch Inst[29:25] {
6226 0, 126, // 10466: case 0x0: {
6227 OPC_SwitchField, 12, 3, // 10468: switch Inst[14:12] {
6228 0, 15, // 10471: case 0x0: {
6229 OPC_SwitchField, 30, 2, // 10473: switch Inst[31:30] {
6230 0, 4, // 10476: case 0x0: {
6231 OPC_Decode, 155, 107, 30, // 10478: decode to ADD using decoder 30
6232 // 10478: }
6233 1, 0, // 10482: case 0x1: {
6234 OPC_Decode, 202, 124, 30, // 10484: decode to SUB using decoder 30
6235 // 10484: }
6236 // 10484: } // switch Inst[31:30]
6237 // 10484: }
6238 1, 8, // 10488: case 0x1: {
6239 OPC_CheckField, 30, 2, 0, // 10490: check Inst[31:30] == 0x0
6240 OPC_Decode, 141, 124, 30, // 10494: decode to SLL using decoder 30
6241 // 10494: }
6242 2, 8, // 10498: case 0x2: {
6243 OPC_CheckField, 30, 2, 0, // 10500: check Inst[31:30] == 0x0
6244 OPC_Decode, 146, 124, 30, // 10504: decode to SLT using decoder 30
6245 // 10504: }
6246 3, 8, // 10508: case 0x3: {
6247 OPC_CheckField, 30, 2, 0, // 10510: check Inst[31:30] == 0x0
6248 OPC_Decode, 149, 124, 30, // 10514: decode to SLTU using decoder 30
6249 // 10514: }
6250 4, 19, // 10518: case 0x4: {
6251 OPC_SwitchField, 30, 2, // 10520: switch Inst[31:30] {
6252 0, 5, // 10523: case 0x0: {
6253 OPC_Decode, 150, 131, 1, 30, // 10525: decode to XOR using decoder 30
6254 // 10525: }
6255 1, 0, // 10530: case 0x1: {
6256 OPC_CheckPredicate, 40, // 10532: check predicate 40
6257 OPC_Decode, 149, 131, 1, 30, // 10534: decode to XNOR using decoder 30
6258 // 10534: }
6259 // 10534: } // switch Inst[31:30]
6260 // 10534: }
6261 5, 15, // 10539: case 0x5: {
6262 OPC_SwitchField, 30, 2, // 10541: switch Inst[31:30] {
6263 0, 4, // 10544: case 0x0: {
6264 OPC_Decode, 178, 124, 30, // 10546: decode to SRL using decoder 30
6265 // 10546: }
6266 1, 0, // 10550: case 0x1: {
6267 OPC_Decode, 171, 124, 30, // 10552: decode to SRA using decoder 30
6268 // 10552: }
6269 // 10552: } // switch Inst[31:30]
6270 // 10552: }
6271 6, 17, // 10556: case 0x6: {
6272 OPC_SwitchField, 30, 2, // 10558: switch Inst[31:30] {
6273 0, 4, // 10561: case 0x0: {
6274 OPC_Decode, 134, 118, 30, // 10563: decode to OR using decoder 30
6275 // 10563: }
6276 1, 0, // 10567: case 0x1: {
6277 OPC_CheckPredicate, 40, // 10569: check predicate 40
6278 OPC_Decode, 137, 118, 30, // 10571: decode to ORN using decoder 30
6279 // 10571: }
6280 // 10571: } // switch Inst[31:30]
6281 // 10571: }
6282 7, 0, // 10575: case 0x7: {
6283 OPC_SwitchField, 30, 2, // 10577: switch Inst[31:30] {
6284 0, 4, // 10580: case 0x0: {
6285 OPC_Decode, 169, 110, 30, // 10582: decode to AND using decoder 30
6286 // 10582: }
6287 1, 0, // 10586: case 0x1: {
6288 OPC_CheckPredicate, 40, // 10588: check predicate 40
6289 OPC_Decode, 171, 110, 30, // 10590: decode to ANDN using decoder 30
6290 // 10590: }
6291 // 10590: } // switch Inst[31:30]
6292 // 10590: }
6293 // 10590: } // switch Inst[14:12]
6294 // 10590: }
6295 1, 99, // 10594: case 0x1: {
6296 OPC_SwitchField, 12, 3, // 10596: switch Inst[14:12] {
6297 0, 10, // 10599: case 0x0: {
6298 OPC_CheckPredicate, 61, // 10601: check predicate 61
6299 OPC_CheckField, 30, 2, 0, // 10603: check Inst[31:30] == 0x0
6300 OPC_Decode, 169, 117, 30, // 10607: decode to MUL using decoder 30
6301 // 10607: }
6302 1, 10, // 10611: case 0x1: {
6303 OPC_CheckPredicate, 61, // 10613: check predicate 61
6304 OPC_CheckField, 30, 2, 0, // 10615: check Inst[31:30] == 0x0
6305 OPC_Decode, 170, 117, 30, // 10619: decode to MULH using decoder 30
6306 // 10619: }
6307 2, 10, // 10623: case 0x2: {
6308 OPC_CheckPredicate, 61, // 10625: check predicate 61
6309 OPC_CheckField, 30, 2, 0, // 10627: check Inst[31:30] == 0x0
6310 OPC_Decode, 174, 117, 30, // 10631: decode to MULHSU using decoder 30
6311 // 10631: }
6312 3, 10, // 10635: case 0x3: {
6313 OPC_CheckPredicate, 61, // 10637: check predicate 61
6314 OPC_CheckField, 30, 2, 0, // 10639: check Inst[31:30] == 0x0
6315 OPC_Decode, 177, 117, 30, // 10643: decode to MULHU using decoder 30
6316 // 10643: }
6317 4, 10, // 10647: case 0x4: {
6318 OPC_CheckPredicate, 62, // 10649: check predicate 62
6319 OPC_CheckField, 30, 2, 0, // 10651: check Inst[31:30] == 0x0
6320 OPC_Decode, 225, 113, 30, // 10655: decode to DIV using decoder 30
6321 // 10655: }
6322 5, 10, // 10659: case 0x5: {
6323 OPC_CheckPredicate, 62, // 10661: check predicate 62
6324 OPC_CheckField, 30, 2, 0, // 10663: check Inst[31:30] == 0x0
6325 OPC_Decode, 226, 113, 30, // 10667: decode to DIVU using decoder 30
6326 // 10667: }
6327 6, 10, // 10671: case 0x6: {
6328 OPC_CheckPredicate, 62, // 10673: check predicate 62
6329 OPC_CheckField, 30, 2, 0, // 10675: check Inst[31:30] == 0x0
6330 OPC_Decode, 254, 122, 30, // 10679: decode to REM using decoder 30
6331 // 10679: }
6332 7, 0, // 10683: case 0x7: {
6333 OPC_CheckPredicate, 62, // 10685: check predicate 62
6334 OPC_CheckField, 30, 2, 0, // 10687: check Inst[31:30] == 0x0
6335 OPC_Decode, 255, 122, 30, // 10691: decode to REMU using decoder 30
6336 // 10691: }
6337 // 10691: } // switch Inst[14:12]
6338 // 10691: }
6339 4, 64, // 10695: case 0x4: {
6340 OPC_SwitchField, 12, 3, // 10697: switch Inst[14:12] {
6341 1, 10, // 10700: case 0x1: {
6342 OPC_CheckPredicate, 35, // 10702: check predicate 35
6343 OPC_CheckField, 30, 2, 1, // 10704: check Inst[31:30] == 0x1
6344 OPC_Decode, 175, 110, 30, // 10708: decode to BCLR using decoder 30
6345 // 10708: }
6346 4, 23, // 10712: case 0x4: {
6347 OPC_CheckField, 30, 2, 0, // 10714: check Inst[31:30] == 0x0
6348 OPC_Scope, 11, // 10718: try {
6349 OPC_CheckField, 20, 5, 0, // 10720: check Inst[24:20] == 0x0
6350 OPC_CheckPredicate, 42, // 10724: check predicate 42
6351 OPC_Decode, 154, 131, 1, 16, // 10726: decode to ZEXT_H_RV32 using decoder 16
6352 // 10726: } else try {
6353 OPC_CheckPredicate, 63, // 10731: check predicate 63
6354 OPC_Decode, 163, 118, 30, // 10733: decode to PACK using decoder 30
6355 // 10733: }
6356 // 10733: }
6357 5, 10, // 10737: case 0x5: {
6358 OPC_CheckPredicate, 35, // 10739: check predicate 35
6359 OPC_CheckField, 30, 2, 1, // 10741: check Inst[31:30] == 0x1
6360 OPC_Decode, 179, 110, 30, // 10745: decode to BEXT using decoder 30
6361 // 10745: }
6362 7, 0, // 10749: case 0x7: {
6363 OPC_CheckPredicate, 41, // 10751: check predicate 41
6364 OPC_CheckField, 30, 2, 0, // 10753: check Inst[31:30] == 0x0
6365 OPC_Decode, 164, 118, 30, // 10757: decode to PACKH using decoder 30
6366 // 10757: }
6367 // 10757: } // switch Inst[14:12]
6368 // 10757: }
6369 5, 87, // 10761: case 0x5: {
6370 OPC_SwitchField, 12, 3, // 10763: switch Inst[14:12] {
6371 1, 10, // 10766: case 0x1: {
6372 OPC_CheckPredicate, 64, // 10768: check predicate 64
6373 OPC_CheckField, 30, 2, 0, // 10770: check Inst[31:30] == 0x0
6374 OPC_Decode, 196, 110, 30, // 10774: decode to CLMUL using decoder 30
6375 // 10774: }
6376 2, 10, // 10778: case 0x2: {
6377 OPC_CheckPredicate, 65, // 10780: check predicate 65
6378 OPC_CheckField, 30, 2, 0, // 10782: check Inst[31:30] == 0x0
6379 OPC_Decode, 198, 110, 30, // 10786: decode to CLMULR using decoder 30
6380 // 10786: }
6381 3, 10, // 10790: case 0x3: {
6382 OPC_CheckPredicate, 64, // 10792: check predicate 64
6383 OPC_CheckField, 30, 2, 0, // 10794: check Inst[31:30] == 0x0
6384 OPC_Decode, 197, 110, 30, // 10798: decode to CLMULH using decoder 30
6385 // 10798: }
6386 4, 10, // 10802: case 0x4: {
6387 OPC_CheckPredicate, 38, // 10804: check predicate 38
6388 OPC_CheckField, 30, 2, 0, // 10806: check Inst[31:30] == 0x0
6389 OPC_Decode, 227, 116, 30, // 10810: decode to MIN using decoder 30
6390 // 10810: }
6391 5, 10, // 10814: case 0x5: {
6392 OPC_CheckPredicate, 38, // 10816: check predicate 38
6393 OPC_CheckField, 30, 2, 0, // 10818: check Inst[31:30] == 0x0
6394 OPC_Decode, 228, 116, 30, // 10822: decode to MINU using decoder 30
6395 // 10822: }
6396 6, 10, // 10826: case 0x6: {
6397 OPC_CheckPredicate, 38, // 10828: check predicate 38
6398 OPC_CheckField, 30, 2, 0, // 10830: check Inst[31:30] == 0x0
6399 OPC_Decode, 214, 116, 30, // 10834: decode to MAX using decoder 30
6400 // 10834: }
6401 7, 0, // 10838: case 0x7: {
6402 OPC_CheckPredicate, 38, // 10840: check predicate 38
6403 OPC_CheckField, 30, 2, 0, // 10842: check Inst[31:30] == 0x0
6404 OPC_Decode, 215, 116, 30, // 10846: decode to MAXU using decoder 30
6405 // 10846: }
6406 // 10846: } // switch Inst[14:12]
6407 // 10846: }
6408 7, 27, // 10850: case 0x7: {
6409 OPC_SwitchField, 12, 3, // 10852: switch Inst[14:12] {
6410 5, 10, // 10855: case 0x5: {
6411 OPC_CheckPredicate, 66, // 10857: check predicate 66
6412 OPC_CheckField, 30, 2, 0, // 10859: check Inst[31:30] == 0x0
6413 OPC_Decode, 149, 113, 30, // 10863: decode to CZERO_EQZ using decoder 30
6414 // 10863: }
6415 7, 0, // 10867: case 0x7: {
6416 OPC_CheckPredicate, 66, // 10869: check predicate 66
6417 OPC_CheckField, 30, 2, 0, // 10871: check Inst[31:30] == 0x0
6418 OPC_Decode, 150, 113, 30, // 10875: decode to CZERO_NEZ using decoder 30
6419 // 10875: }
6420 // 10875: } // switch Inst[14:12]
6421 // 10875: }
6422 8, 14, // 10879: case 0x8: {
6423 OPC_CheckPredicate, 67, // 10881: check predicate 67
6424 OPC_CheckField, 30, 2, 1, // 10883: check Inst[31:30] == 0x1
6425 OPC_CheckField, 12, 3, 0, // 10887: check Inst[14:12] == 0x0
6426 OPC_Decode, 131, 124, 30, // 10891: decode to SHA512SUM0R using decoder 30
6427 // 10891: }
6428 9, 14, // 10895: case 0x9: {
6429 OPC_CheckPredicate, 67, // 10897: check predicate 67
6430 OPC_CheckField, 30, 2, 1, // 10899: check Inst[31:30] == 0x1
6431 OPC_CheckField, 12, 3, 0, // 10903: check Inst[14:12] == 0x0
6432 OPC_Decode, 133, 124, 30, // 10907: decode to SHA512SUM1R using decoder 30
6433 // 10907: }
6434 10, 14, // 10911: case 0xa: {
6435 OPC_CheckPredicate, 67, // 10913: check predicate 67
6436 OPC_CheckField, 30, 2, 1, // 10915: check Inst[31:30] == 0x1
6437 OPC_CheckField, 12, 3, 0, // 10919: check Inst[14:12] == 0x0
6438 OPC_Decode, 254, 123, 30, // 10923: decode to SHA512SIG0L using decoder 30
6439 // 10923: }
6440 11, 14, // 10927: case 0xb: {
6441 OPC_CheckPredicate, 67, // 10929: check predicate 67
6442 OPC_CheckField, 30, 2, 1, // 10931: check Inst[31:30] == 0x1
6443 OPC_CheckField, 12, 3, 0, // 10935: check Inst[14:12] == 0x0
6444 OPC_Decode, 129, 124, 30, // 10939: decode to SHA512SIG1L using decoder 30
6445 // 10939: }
6446 14, 14, // 10943: case 0xe: {
6447 OPC_CheckPredicate, 67, // 10945: check predicate 67
6448 OPC_CheckField, 30, 2, 1, // 10947: check Inst[31:30] == 0x1
6449 OPC_CheckField, 12, 3, 0, // 10951: check Inst[14:12] == 0x0
6450 OPC_Decode, 253, 123, 30, // 10955: decode to SHA512SIG0H using decoder 30
6451 // 10955: }
6452 15, 14, // 10959: case 0xf: {
6453 OPC_CheckPredicate, 67, // 10961: check predicate 67
6454 OPC_CheckField, 30, 2, 1, // 10963: check Inst[31:30] == 0x1
6455 OPC_CheckField, 12, 3, 0, // 10967: check Inst[14:12] == 0x0
6456 OPC_Decode, 128, 124, 30, // 10971: decode to SHA512SIG1H using decoder 30
6457 // 10971: }
6458 16, 63, // 10975: case 0x10: {
6459 OPC_SwitchField, 12, 3, // 10977: switch Inst[14:12] {
6460 1, 10, // 10980: case 0x1: {
6461 OPC_CheckPredicate, 40, // 10982: check predicate 40
6462 OPC_CheckField, 30, 2, 1, // 10984: check Inst[31:30] == 0x1
6463 OPC_Decode, 141, 123, 30, // 10988: decode to ROL using decoder 30
6464 // 10988: }
6465 2, 10, // 10992: case 0x2: {
6466 OPC_CheckPredicate, 68, // 10994: check predicate 68
6467 OPC_CheckField, 30, 2, 0, // 10996: check Inst[31:30] == 0x0
6468 OPC_Decode, 241, 123, 30, // 11000: decode to SH1ADD using decoder 30
6469 // 11000: }
6470 4, 10, // 11004: case 0x4: {
6471 OPC_CheckPredicate, 68, // 11006: check predicate 68
6472 OPC_CheckField, 30, 2, 0, // 11008: check Inst[31:30] == 0x0
6473 OPC_Decode, 243, 123, 30, // 11012: decode to SH2ADD using decoder 30
6474 // 11012: }
6475 5, 10, // 11016: case 0x5: {
6476 OPC_CheckPredicate, 40, // 11018: check predicate 40
6477 OPC_CheckField, 30, 2, 1, // 11020: check Inst[31:30] == 0x1
6478 OPC_Decode, 143, 123, 30, // 11024: decode to ROR using decoder 30
6479 // 11024: }
6480 6, 0, // 11028: case 0x6: {
6481 OPC_CheckPredicate, 68, // 11030: check predicate 68
6482 OPC_CheckField, 30, 2, 0, // 11032: check Inst[31:30] == 0x0
6483 OPC_Decode, 245, 123, 30, // 11036: decode to SH3ADD using decoder 30
6484 // 11036: }
6485 // 11036: } // switch Inst[14:12]
6486 // 11036: }
6487 17, 10, // 11040: case 0x11: {
6488 OPC_CheckPredicate, 69, // 11042: check predicate 69
6489 OPC_CheckField, 12, 3, 0, // 11044: check Inst[14:12] == 0x0
6490 OPC_Decode, 163, 107, 57, // 11048: decode to AES32ESI using decoder 57
6491 // 11048: }
6492 19, 10, // 11052: case 0x13: {
6493 OPC_CheckPredicate, 69, // 11054: check predicate 69
6494 OPC_CheckField, 12, 3, 0, // 11056: check Inst[14:12] == 0x0
6495 OPC_Decode, 164, 107, 57, // 11060: decode to AES32ESMI using decoder 57
6496 // 11060: }
6497 20, 50, // 11064: case 0x14: {
6498 OPC_SwitchField, 12, 3, // 11066: switch Inst[14:12] {
6499 1, 19, // 11069: case 0x1: {
6500 OPC_SwitchField, 30, 2, // 11071: switch Inst[31:30] {
6501 0, 6, // 11074: case 0x0: {
6502 OPC_CheckPredicate, 35, // 11076: check predicate 35
6503 OPC_Decode, 190, 110, 30, // 11078: decode to BSET using decoder 30
6504 // 11078: }
6505 1, 0, // 11082: case 0x1: {
6506 OPC_CheckPredicate, 35, // 11084: check predicate 35
6507 OPC_Decode, 183, 110, 30, // 11086: decode to BINV using decoder 30
6508 // 11086: }
6509 // 11086: } // switch Inst[31:30]
6510 // 11086: }
6511 2, 11, // 11090: case 0x2: {
6512 OPC_CheckPredicate, 70, // 11092: check predicate 70
6513 OPC_CheckField, 30, 2, 0, // 11094: check Inst[31:30] == 0x0
6514 OPC_Decode, 152, 131, 1, 30, // 11098: decode to XPERM4 using decoder 30
6515 // 11098: }
6516 4, 0, // 11103: case 0x4: {
6517 OPC_CheckPredicate, 70, // 11105: check predicate 70
6518 OPC_CheckField, 30, 2, 0, // 11107: check Inst[31:30] == 0x0
6519 OPC_Decode, 153, 131, 1, 30, // 11111: decode to XPERM8 using decoder 30
6520 // 11111: }
6521 // 11111: } // switch Inst[14:12]
6522 // 11111: }
6523 21, 10, // 11116: case 0x15: {
6524 OPC_CheckPredicate, 71, // 11118: check predicate 71
6525 OPC_CheckField, 12, 3, 0, // 11120: check Inst[14:12] == 0x0
6526 OPC_Decode, 161, 107, 57, // 11124: decode to AES32DSI using decoder 57
6527 // 11124: }
6528 23, 10, // 11128: case 0x17: {
6529 OPC_CheckPredicate, 71, // 11130: check predicate 71
6530 OPC_CheckField, 12, 3, 0, // 11132: check Inst[14:12] == 0x0
6531 OPC_Decode, 162, 107, 57, // 11136: decode to AES32DSMI using decoder 57
6532 // 11136: }
6533 24, 10, // 11140: case 0x18: {
6534 OPC_CheckPredicate, 72, // 11142: check predicate 72
6535 OPC_CheckField, 12, 3, 0, // 11144: check Inst[14:12] == 0x0
6536 OPC_Decode, 153, 124, 57, // 11148: decode to SM4ED using decoder 57
6537 // 11148: }
6538 25, 14, // 11152: case 0x19: {
6539 OPC_CheckPredicate, 73, // 11154: check predicate 73
6540 OPC_CheckField, 30, 2, 0, // 11156: check Inst[31:30] == 0x0
6541 OPC_CheckField, 12, 3, 0, // 11160: check Inst[14:12] == 0x0
6542 OPC_Decode, 167, 107, 30, // 11164: decode to AES64ES using decoder 30
6543 // 11164: }
6544 26, 10, // 11168: case 0x1a: {
6545 OPC_CheckPredicate, 72, // 11170: check predicate 72
6546 OPC_CheckField, 12, 3, 0, // 11172: check Inst[14:12] == 0x0
6547 OPC_Decode, 154, 124, 57, // 11176: decode to SM4KS using decoder 57
6548 // 11176: }
6549 27, 14, // 11180: case 0x1b: {
6550 OPC_CheckPredicate, 73, // 11182: check predicate 73
6551 OPC_CheckField, 30, 2, 0, // 11184: check Inst[31:30] == 0x0
6552 OPC_CheckField, 12, 3, 0, // 11188: check Inst[14:12] == 0x0
6553 OPC_Decode, 168, 107, 30, // 11192: decode to AES64ESM using decoder 30
6554 // 11192: }
6555 29, 14, // 11196: case 0x1d: {
6556 OPC_CheckPredicate, 36, // 11198: check predicate 36
6557 OPC_CheckField, 30, 2, 0, // 11200: check Inst[31:30] == 0x0
6558 OPC_CheckField, 12, 3, 0, // 11204: check Inst[14:12] == 0x0
6559 OPC_Decode, 165, 107, 30, // 11208: decode to AES64DS using decoder 30
6560 // 11208: }
6561 31, 0, // 11212: case 0x1f: {
6562 OPC_SwitchField, 30, 2, // 11214: switch Inst[31:30] {
6563 0, 10, // 11217: case 0x0: {
6564 OPC_CheckPredicate, 36, // 11219: check predicate 36
6565 OPC_CheckField, 12, 3, 0, // 11221: check Inst[14:12] == 0x0
6566 OPC_Decode, 166, 107, 30, // 11225: decode to AES64DSM using decoder 30
6567 // 11225: }
6568 1, 0, // 11229: case 0x1: {
6569 OPC_CheckPredicate, 37, // 11231: check predicate 37
6570 OPC_CheckField, 12, 3, 0, // 11233: check Inst[14:12] == 0x0
6571 OPC_Decode, 171, 107, 30, // 11237: decode to AES64KS2 using decoder 30
6572 // 11237: }
6573 // 11237: } // switch Inst[31:30]
6574 // 11237: }
6575 // 11237: } // switch Inst[29:25]
6576 // 11237: }
6577 55, 4, // 11241: case 0x37: {
6578 OPC_Decode, 192, 116, 19, // 11243: decode to LUI using decoder 19
6579 // 11243: }
6580 59, 155, 19, // 11247: case 0x3b: {
6581 OPC_SwitchField, 25, 7, // 11250: switch Inst[31:25] {
6582 0, 27, // 11253: case 0x0: {
6583 OPC_SwitchField, 12, 3, // 11255: switch Inst[14:12] {
6584 0, 6, // 11258: case 0x0: {
6585 OPC_CheckPredicate, 20, // 11260: check predicate 20
6586 OPC_Decode, 159, 107, 30, // 11262: decode to ADDW using decoder 30
6587 // 11262: }
6588 1, 6, // 11266: case 0x1: {
6589 OPC_CheckPredicate, 20, // 11268: check predicate 20
6590 OPC_Decode, 145, 124, 30, // 11270: decode to SLLW using decoder 30
6591 // 11270: }
6592 5, 0, // 11274: case 0x5: {
6593 OPC_CheckPredicate, 20, // 11276: check predicate 20
6594 OPC_Decode, 181, 124, 30, // 11278: decode to SRLW using decoder 30
6595 // 11278: }
6596 // 11278: } // switch Inst[14:12]
6597 // 11278: }
6598 1, 43, // 11282: case 0x1: {
6599 OPC_SwitchField, 12, 3, // 11284: switch Inst[14:12] {
6600 0, 6, // 11287: case 0x0: {
6601 OPC_CheckPredicate, 74, // 11289: check predicate 74
6602 OPC_Decode, 192, 117, 30, // 11291: decode to MULW using decoder 30
6603 // 11291: }
6604 4, 6, // 11295: case 0x4: {
6605 OPC_CheckPredicate, 75, // 11297: check predicate 75
6606 OPC_Decode, 228, 113, 30, // 11299: decode to DIVW using decoder 30
6607 // 11299: }
6608 5, 6, // 11303: case 0x5: {
6609 OPC_CheckPredicate, 75, // 11305: check predicate 75
6610 OPC_Decode, 227, 113, 30, // 11307: decode to DIVUW using decoder 30
6611 // 11307: }
6612 6, 6, // 11311: case 0x6: {
6613 OPC_CheckPredicate, 75, // 11313: check predicate 75
6614 OPC_Decode, 129, 123, 30, // 11315: decode to REMW using decoder 30
6615 // 11315: }
6616 7, 0, // 11319: case 0x7: {
6617 OPC_CheckPredicate, 75, // 11321: check predicate 75
6618 OPC_Decode, 128, 123, 30, // 11323: decode to REMUW using decoder 30
6619 // 11323: }
6620 // 11323: } // switch Inst[14:12]
6621 // 11323: }
6622 4, 32, // 11327: case 0x4: {
6623 OPC_SwitchField, 12, 3, // 11329: switch Inst[14:12] {
6624 0, 6, // 11332: case 0x0: {
6625 OPC_CheckPredicate, 47, // 11334: check predicate 47
6626 OPC_Decode, 160, 107, 30, // 11336: decode to ADD_UW using decoder 30
6627 // 11336: }
6628 4, 0, // 11340: case 0x4: {
6629 OPC_Scope, 11, // 11342: try {
6630 OPC_CheckField, 20, 5, 0, // 11344: check Inst[24:20] == 0x0
6631 OPC_CheckPredicate, 45, // 11348: check predicate 45
6632 OPC_Decode, 155, 131, 1, 16, // 11350: decode to ZEXT_H_RV64 using decoder 16
6633 // 11350: } else try {
6634 OPC_CheckPredicate, 76, // 11355: check predicate 76
6635 OPC_Decode, 165, 118, 30, // 11357: decode to PACKW using decoder 30
6636 // 11357: }
6637 // 11357: }
6638 // 11357: } // switch Inst[14:12]
6639 // 11357: }
6640 16, 27, // 11361: case 0x10: {
6641 OPC_SwitchField, 12, 3, // 11363: switch Inst[14:12] {
6642 2, 6, // 11366: case 0x2: {
6643 OPC_CheckPredicate, 47, // 11368: check predicate 47
6644 OPC_Decode, 242, 123, 30, // 11370: decode to SH1ADD_UW using decoder 30
6645 // 11370: }
6646 4, 6, // 11374: case 0x4: {
6647 OPC_CheckPredicate, 47, // 11376: check predicate 47
6648 OPC_Decode, 244, 123, 30, // 11378: decode to SH2ADD_UW using decoder 30
6649 // 11378: }
6650 6, 0, // 11382: case 0x6: {
6651 OPC_CheckPredicate, 47, // 11384: check predicate 47
6652 OPC_Decode, 246, 123, 30, // 11386: decode to SH3ADD_UW using decoder 30
6653 // 11386: }
6654 // 11386: } // switch Inst[14:12]
6655 // 11386: }
6656 32, 19, // 11390: case 0x20: {
6657 OPC_SwitchField, 12, 3, // 11392: switch Inst[14:12] {
6658 0, 6, // 11395: case 0x0: {
6659 OPC_CheckPredicate, 20, // 11397: check predicate 20
6660 OPC_Decode, 204, 124, 30, // 11399: decode to SUBW using decoder 30
6661 // 11399: }
6662 5, 0, // 11403: case 0x5: {
6663 OPC_CheckPredicate, 20, // 11405: check predicate 20
6664 OPC_Decode, 176, 124, 30, // 11407: decode to SRAW using decoder 30
6665 // 11407: }
6666 // 11407: } // switch Inst[14:12]
6667 // 11407: }
6668 48, 19, // 11411: case 0x30: {
6669 OPC_SwitchField, 12, 3, // 11413: switch Inst[14:12] {
6670 1, 6, // 11416: case 0x1: {
6671 OPC_CheckPredicate, 45, // 11418: check predicate 45
6672 OPC_Decode, 142, 123, 30, // 11420: decode to ROLW using decoder 30
6673 // 11420: }
6674 5, 0, // 11424: case 0x5: {
6675 OPC_CheckPredicate, 45, // 11426: check predicate 45
6676 OPC_Decode, 146, 123, 30, // 11428: decode to RORW using decoder 30
6677 // 11428: }
6678 // 11428: } // switch Inst[14:12]
6679 // 11428: }
6680 64, 59, // 11432: case 0x40: {
6681 OPC_SwitchField, 12, 3, // 11434: switch Inst[14:12] {
6682 0, 6, // 11437: case 0x0: {
6683 OPC_CheckPredicate, 39, // 11439: check predicate 39
6684 OPC_Decode, 174, 118, 30, // 11441: decode to PADD_H using decoder 30
6685 // 11441: }
6686 2, 6, // 11445: case 0x2: {
6687 OPC_CheckPredicate, 44, // 11447: check predicate 44
6688 OPC_Decode, 139, 120, 30, // 11449: decode to PNCLIPUP_B using decoder 30
6689 // 11449: }
6690 3, 6, // 11453: case 0x3: {
6691 OPC_CheckPredicate, 39, // 11455: check predicate 39
6692 OPC_Decode, 246, 119, 30, // 11457: decode to PMUL_H_B00 using decoder 30
6693 // 11457: }
6694 4, 6, // 11461: case 0x4: {
6695 OPC_CheckPredicate, 39, // 11463: check predicate 39
6696 OPC_Decode, 163, 120, 30, // 11465: decode to PPAIRE_B using decoder 30
6697 // 11465: }
6698 5, 6, // 11469: case 0x5: {
6699 OPC_CheckPredicate, 39, // 11471: check predicate 39
6700 OPC_Decode, 216, 118, 30, // 11473: decode to PM2ADD_H using decoder 30
6701 // 11473: }
6702 6, 6, // 11477: case 0x6: {
6703 OPC_CheckPredicate, 39, // 11479: check predicate 39
6704 OPC_Decode, 194, 118, 30, // 11481: decode to PAS_HX using decoder 30
6705 // 11481: }
6706 7, 0, // 11485: case 0x7: {
6707 OPC_CheckPredicate, 39, // 11487: check predicate 39
6708 OPC_Decode, 226, 119, 30, // 11489: decode to PMULH_H using decoder 30
6709 // 11489: }
6710 // 11489: } // switch Inst[14:12]
6711 // 11489: }
6712 65, 59, // 11493: case 0x41: {
6713 OPC_SwitchField, 12, 3, // 11495: switch Inst[14:12] {
6714 0, 6, // 11498: case 0x0: {
6715 OPC_CheckPredicate, 44, // 11500: check predicate 44
6716 OPC_Decode, 176, 118, 30, // 11502: decode to PADD_W using decoder 30
6717 // 11502: }
6718 2, 6, // 11506: case 0x2: {
6719 OPC_CheckPredicate, 44, // 11508: check predicate 44
6720 OPC_Decode, 140, 120, 30, // 11510: decode to PNCLIPUP_H using decoder 30
6721 // 11510: }
6722 3, 6, // 11514: case 0x3: {
6723 OPC_CheckPredicate, 44, // 11516: check predicate 44
6724 OPC_Decode, 249, 119, 30, // 11518: decode to PMUL_W_H00 using decoder 30
6725 // 11518: }
6726 4, 6, // 11522: case 0x4: {
6727 OPC_CheckPredicate, 44, // 11524: check predicate 44
6728 OPC_Decode, 166, 120, 30, // 11526: decode to PPAIRE_H using decoder 30
6729 // 11526: }
6730 5, 6, // 11530: case 0x5: {
6731 OPC_CheckPredicate, 44, // 11532: check predicate 44
6732 OPC_Decode, 218, 118, 30, // 11534: decode to PM2ADD_W using decoder 30
6733 // 11534: }
6734 6, 6, // 11538: case 0x6: {
6735 OPC_CheckPredicate, 44, // 11540: check predicate 44
6736 OPC_Decode, 195, 118, 30, // 11542: decode to PAS_WX using decoder 30
6737 // 11542: }
6738 7, 0, // 11546: case 0x7: {
6739 OPC_CheckPredicate, 44, // 11548: check predicate 44
6740 OPC_Decode, 229, 119, 30, // 11550: decode to PMULH_W using decoder 30
6741 // 11550: }
6742 // 11550: } // switch Inst[14:12]
6743 // 11550: }
6744 66, 35, // 11554: case 0x42: {
6745 OPC_SwitchField, 12, 3, // 11556: switch Inst[14:12] {
6746 0, 6, // 11559: case 0x0: {
6747 OPC_CheckPredicate, 39, // 11561: check predicate 39
6748 OPC_Decode, 166, 118, 30, // 11563: decode to PADD_B using decoder 30
6749 // 11563: }
6750 5, 6, // 11567: case 0x5: {
6751 OPC_CheckPredicate, 39, // 11569: check predicate 39
6752 OPC_Decode, 252, 118, 30, // 11571: decode to PM4ADD_B using decoder 30
6753 // 11571: }
6754 6, 6, // 11575: case 0x6: {
6755 OPC_CheckPredicate, 39, // 11577: check predicate 39
6756 OPC_Decode, 214, 120, 30, // 11579: decode to PSA_HX using decoder 30
6757 // 11579: }
6758 7, 0, // 11583: case 0x7: {
6759 OPC_CheckPredicate, 39, // 11585: check predicate 39
6760 OPC_Decode, 216, 119, 30, // 11587: decode to PMULHR_H using decoder 30
6761 // 11587: }
6762 // 11587: } // switch Inst[14:12]
6763 // 11587: }
6764 67, 43, // 11591: case 0x43: {
6765 OPC_SwitchField, 12, 3, // 11593: switch Inst[14:12] {
6766 2, 6, // 11596: case 0x2: {
6767 OPC_CheckPredicate, 44, // 11598: check predicate 44
6768 OPC_Decode, 141, 120, 30, // 11600: decode to PNCLIPUP_W using decoder 30
6769 // 11600: }
6770 3, 6, // 11604: case 0x3: {
6771 OPC_CheckPredicate, 44, // 11606: check predicate 44
6772 OPC_Decode, 196, 117, 30, // 11608: decode to MUL_W00 using decoder 30
6773 // 11608: }
6774 5, 6, // 11612: case 0x5: {
6775 OPC_CheckPredicate, 44, // 11614: check predicate 44
6776 OPC_Decode, 253, 118, 30, // 11616: decode to PM4ADD_H using decoder 30
6777 // 11616: }
6778 6, 6, // 11620: case 0x6: {
6779 OPC_CheckPredicate, 44, // 11622: check predicate 44
6780 OPC_Decode, 215, 120, 30, // 11624: decode to PSA_WX using decoder 30
6781 // 11624: }
6782 7, 0, // 11628: case 0x7: {
6783 OPC_CheckPredicate, 44, // 11630: check predicate 44
6784 OPC_Decode, 217, 119, 30, // 11632: decode to PMULHR_W using decoder 30
6785 // 11632: }
6786 // 11632: } // switch Inst[14:12]
6787 // 11632: }
6788 68, 19, // 11636: case 0x44: {
6789 OPC_SwitchField, 12, 3, // 11638: switch Inst[14:12] {
6790 5, 6, // 11641: case 0x5: {
6791 OPC_CheckPredicate, 39, // 11643: check predicate 39
6792 OPC_Decode, 208, 118, 58, // 11645: decode to PM2ADDA_H using decoder 58
6793 // 11645: }
6794 7, 0, // 11649: case 0x7: {
6795 OPC_CheckPredicate, 39, // 11651: check predicate 39
6796 OPC_Decode, 154, 119, 58, // 11653: decode to PMHACC_H using decoder 58
6797 // 11653: }
6798 // 11653: } // switch Inst[14:12]
6799 // 11653: }
6800 69, 27, // 11657: case 0x45: {
6801 OPC_SwitchField, 12, 3, // 11659: switch Inst[14:12] {
6802 3, 6, // 11662: case 0x3: {
6803 OPC_CheckPredicate, 44, // 11664: check predicate 44
6804 OPC_Decode, 131, 119, 58, // 11666: decode to PMACC_W_H00 using decoder 58
6805 // 11666: }
6806 5, 6, // 11670: case 0x5: {
6807 OPC_CheckPredicate, 44, // 11672: check predicate 44
6808 OPC_Decode, 210, 118, 58, // 11674: decode to PM2ADDA_W using decoder 58
6809 // 11674: }
6810 7, 0, // 11678: case 0x7: {
6811 OPC_CheckPredicate, 44, // 11680: check predicate 44
6812 OPC_Decode, 157, 119, 58, // 11682: decode to PMHACC_W using decoder 58
6813 // 11682: }
6814 // 11682: } // switch Inst[14:12]
6815 // 11682: }
6816 70, 19, // 11686: case 0x46: {
6817 OPC_SwitchField, 12, 3, // 11688: switch Inst[14:12] {
6818 5, 6, // 11691: case 0x5: {
6819 OPC_CheckPredicate, 39, // 11693: check predicate 39
6820 OPC_Decode, 246, 118, 58, // 11695: decode to PM4ADDA_B using decoder 58
6821 // 11695: }
6822 7, 0, // 11699: case 0x7: {
6823 OPC_CheckPredicate, 39, // 11701: check predicate 39
6824 OPC_Decode, 164, 119, 58, // 11703: decode to PMHRACC_H using decoder 58
6825 // 11703: }
6826 // 11703: } // switch Inst[14:12]
6827 // 11703: }
6828 71, 35, // 11707: case 0x47: {
6829 OPC_SwitchField, 12, 3, // 11709: switch Inst[14:12] {
6830 1, 6, // 11712: case 0x1: {
6831 OPC_CheckPredicate, 39, // 11714: check predicate 39
6832 OPC_Decode, 150, 124, 58, // 11716: decode to SLX using decoder 58
6833 // 11716: }
6834 3, 6, // 11720: case 0x3: {
6835 OPC_CheckPredicate, 44, // 11722: check predicate 44
6836 OPC_Decode, 211, 116, 58, // 11724: decode to MACC_W00 using decoder 58
6837 // 11724: }
6838 5, 6, // 11728: case 0x5: {
6839 OPC_CheckPredicate, 44, // 11730: check predicate 44
6840 OPC_Decode, 247, 118, 58, // 11732: decode to PM4ADDA_H using decoder 58
6841 // 11732: }
6842 7, 0, // 11736: case 0x7: {
6843 OPC_CheckPredicate, 44, // 11738: check predicate 44
6844 OPC_Decode, 165, 119, 58, // 11740: decode to PMHRACC_W using decoder 58
6845 // 11740: }
6846 // 11740: } // switch Inst[14:12]
6847 // 11740: }
6848 72, 59, // 11744: case 0x48: {
6849 OPC_SwitchField, 12, 3, // 11746: switch Inst[14:12] {
6850 0, 6, // 11749: case 0x0: {
6851 OPC_CheckPredicate, 39, // 11751: check predicate 39
6852 OPC_Decode, 204, 120, 30, // 11753: decode to PSADD_H using decoder 30
6853 // 11753: }
6854 1, 6, // 11757: case 0x1: {
6855 OPC_CheckPredicate, 39, // 11759: check predicate 39
6856 OPC_Decode, 247, 119, 30, // 11761: decode to PMUL_H_B01 using decoder 30
6857 // 11761: }
6858 3, 6, // 11765: case 0x3: {
6859 OPC_CheckPredicate, 39, // 11767: check predicate 39
6860 OPC_Decode, 248, 119, 30, // 11769: decode to PMUL_H_B11 using decoder 30
6861 // 11769: }
6862 4, 6, // 11773: case 0x4: {
6863 OPC_CheckPredicate, 39, // 11775: check predicate 39
6864 OPC_Decode, 158, 120, 30, // 11777: decode to PPAIREO_B using decoder 30
6865 // 11777: }
6866 5, 6, // 11781: case 0x5: {
6867 OPC_CheckPredicate, 39, // 11783: check predicate 39
6868 OPC_Decode, 217, 118, 30, // 11785: decode to PM2ADD_HX using decoder 30
6869 // 11785: }
6870 6, 6, // 11789: case 0x6: {
6871 OPC_CheckPredicate, 39, // 11791: check predicate 39
6872 OPC_Decode, 207, 120, 30, // 11793: decode to PSAS_HX using decoder 30
6873 // 11793: }
6874 7, 0, // 11797: case 0x7: {
6875 OPC_CheckPredicate, 39, // 11799: check predicate 39
6876 OPC_Decode, 224, 119, 30, // 11801: decode to PMULHU_H using decoder 30
6877 // 11801: }
6878 // 11801: } // switch Inst[14:12]
6879 // 11801: }
6880 73, 59, // 11805: case 0x49: {
6881 OPC_SwitchField, 12, 3, // 11807: switch Inst[14:12] {
6882 0, 6, // 11810: case 0x0: {
6883 OPC_CheckPredicate, 44, // 11812: check predicate 44
6884 OPC_Decode, 205, 120, 30, // 11814: decode to PSADD_W using decoder 30
6885 // 11814: }
6886 1, 6, // 11818: case 0x1: {
6887 OPC_CheckPredicate, 44, // 11820: check predicate 44
6888 OPC_Decode, 250, 119, 30, // 11822: decode to PMUL_W_H01 using decoder 30
6889 // 11822: }
6890 3, 6, // 11826: case 0x3: {
6891 OPC_CheckPredicate, 44, // 11828: check predicate 44
6892 OPC_Decode, 251, 119, 30, // 11830: decode to PMUL_W_H11 using decoder 30
6893 // 11830: }
6894 4, 6, // 11834: case 0x4: {
6895 OPC_CheckPredicate, 39, // 11836: check predicate 39
6896 OPC_Decode, 161, 120, 30, // 11838: decode to PPAIREO_H using decoder 30
6897 // 11838: }
6898 5, 6, // 11842: case 0x5: {
6899 OPC_CheckPredicate, 44, // 11844: check predicate 44
6900 OPC_Decode, 219, 118, 30, // 11846: decode to PM2ADD_WX using decoder 30
6901 // 11846: }
6902 6, 6, // 11850: case 0x6: {
6903 OPC_CheckPredicate, 44, // 11852: check predicate 44
6904 OPC_Decode, 208, 120, 30, // 11854: decode to PSAS_WX using decoder 30
6905 // 11854: }
6906 7, 0, // 11858: case 0x7: {
6907 OPC_CheckPredicate, 44, // 11860: check predicate 44
6908 OPC_Decode, 225, 119, 30, // 11862: decode to PMULHU_W using decoder 30
6909 // 11862: }
6910 // 11862: } // switch Inst[14:12]
6911 // 11862: }
6912 74, 27, // 11866: case 0x4a: {
6913 OPC_SwitchField, 12, 3, // 11868: switch Inst[14:12] {
6914 0, 6, // 11871: case 0x0: {
6915 OPC_CheckPredicate, 39, // 11873: check predicate 39
6916 OPC_Decode, 200, 120, 30, // 11875: decode to PSADD_B using decoder 30
6917 // 11875: }
6918 6, 6, // 11879: case 0x6: {
6919 OPC_CheckPredicate, 39, // 11881: check predicate 39
6920 OPC_Decode, 139, 121, 30, // 11883: decode to PSSA_HX using decoder 30
6921 // 11883: }
6922 7, 0, // 11887: case 0x7: {
6923 OPC_CheckPredicate, 39, // 11889: check predicate 39
6924 OPC_Decode, 214, 119, 30, // 11891: decode to PMULHRU_H using decoder 30
6925 // 11891: }
6926 // 11891: } // switch Inst[14:12]
6927 // 11891: }
6928 75, 43, // 11895: case 0x4b: {
6929 OPC_SwitchField, 12, 3, // 11897: switch Inst[14:12] {
6930 1, 6, // 11900: case 0x1: {
6931 OPC_CheckPredicate, 44, // 11902: check predicate 44
6932 OPC_Decode, 197, 117, 30, // 11904: decode to MUL_W01 using decoder 30
6933 // 11904: }
6934 3, 6, // 11908: case 0x3: {
6935 OPC_CheckPredicate, 44, // 11910: check predicate 44
6936 OPC_Decode, 198, 117, 30, // 11912: decode to MUL_W11 using decoder 30
6937 // 11912: }
6938 4, 6, // 11916: case 0x4: {
6939 OPC_CheckPredicate, 44, // 11918: check predicate 44
6940 OPC_Decode, 162, 120, 30, // 11920: decode to PPAIREO_W using decoder 30
6941 // 11920: }
6942 6, 6, // 11924: case 0x6: {
6943 OPC_CheckPredicate, 44, // 11926: check predicate 44
6944 OPC_Decode, 140, 121, 30, // 11928: decode to PSSA_WX using decoder 30
6945 // 11928: }
6946 7, 0, // 11932: case 0x7: {
6947 OPC_CheckPredicate, 44, // 11934: check predicate 44
6948 OPC_Decode, 215, 119, 30, // 11936: decode to PMULHRU_W using decoder 30
6949 // 11936: }
6950 // 11936: } // switch Inst[14:12]
6951 // 11936: }
6952 76, 35, // 11940: case 0x4c: {
6953 OPC_SwitchField, 12, 3, // 11942: switch Inst[14:12] {
6954 0, 6, // 11945: case 0x0: {
6955 OPC_CheckPredicate, 39, // 11947: check predicate 39
6956 OPC_Decode, 148, 118, 30, // 11949: decode to PAADD_H using decoder 30
6957 // 11949: }
6958 5, 6, // 11953: case 0x5: {
6959 OPC_CheckPredicate, 39, // 11955: check predicate 39
6960 OPC_Decode, 209, 118, 58, // 11957: decode to PM2ADDA_HX using decoder 58
6961 // 11957: }
6962 6, 6, // 11961: case 0x6: {
6963 OPC_CheckPredicate, 39, // 11963: check predicate 39
6964 OPC_Decode, 151, 118, 30, // 11965: decode to PAAS_HX using decoder 30
6965 // 11965: }
6966 7, 0, // 11969: case 0x7: {
6967 OPC_CheckPredicate, 39, // 11971: check predicate 39
6968 OPC_Decode, 152, 119, 58, // 11973: decode to PMHACCU_H using decoder 58
6969 // 11973: }
6970 // 11973: } // switch Inst[14:12]
6971 // 11973: }
6972 77, 51, // 11977: case 0x4d: {
6973 OPC_SwitchField, 12, 3, // 11979: switch Inst[14:12] {
6974 0, 6, // 11982: case 0x0: {
6975 OPC_CheckPredicate, 44, // 11984: check predicate 44
6976 OPC_Decode, 149, 118, 30, // 11986: decode to PAADD_W using decoder 30
6977 // 11986: }
6978 1, 6, // 11990: case 0x1: {
6979 OPC_CheckPredicate, 44, // 11992: check predicate 44
6980 OPC_Decode, 132, 119, 58, // 11994: decode to PMACC_W_H01 using decoder 58
6981 // 11994: }
6982 3, 6, // 11998: case 0x3: {
6983 OPC_CheckPredicate, 44, // 12000: check predicate 44
6984 OPC_Decode, 133, 119, 58, // 12002: decode to PMACC_W_H11 using decoder 58
6985 // 12002: }
6986 5, 6, // 12006: case 0x5: {
6987 OPC_CheckPredicate, 44, // 12008: check predicate 44
6988 OPC_Decode, 211, 118, 58, // 12010: decode to PM2ADDA_WX using decoder 58
6989 // 12010: }
6990 6, 6, // 12014: case 0x6: {
6991 OPC_CheckPredicate, 44, // 12016: check predicate 44
6992 OPC_Decode, 152, 118, 30, // 12018: decode to PAAS_WX using decoder 30
6993 // 12018: }
6994 7, 0, // 12022: case 0x7: {
6995 OPC_CheckPredicate, 44, // 12024: check predicate 44
6996 OPC_Decode, 153, 119, 58, // 12026: decode to PMHACCU_W using decoder 58
6997 // 12026: }
6998 // 12026: } // switch Inst[14:12]
6999 // 12026: }
7000 78, 27, // 12030: case 0x4e: {
7001 OPC_SwitchField, 12, 3, // 12032: switch Inst[14:12] {
7002 0, 6, // 12035: case 0x0: {
7003 OPC_CheckPredicate, 39, // 12037: check predicate 39
7004 OPC_Decode, 144, 118, 30, // 12039: decode to PAADD_B using decoder 30
7005 // 12039: }
7006 6, 6, // 12043: case 0x6: {
7007 OPC_CheckPredicate, 39, // 12045: check predicate 39
7008 OPC_Decode, 179, 118, 30, // 12047: decode to PASA_HX using decoder 30
7009 // 12047: }
7010 7, 0, // 12051: case 0x7: {
7011 OPC_CheckPredicate, 39, // 12053: check predicate 39
7012 OPC_Decode, 162, 119, 58, // 12055: decode to PMHRACCU_H using decoder 58
7013 // 12055: }
7014 // 12055: } // switch Inst[14:12]
7015 // 12055: }
7016 79, 35, // 12059: case 0x4f: {
7017 OPC_SwitchField, 12, 3, // 12061: switch Inst[14:12] {
7018 1, 6, // 12064: case 0x1: {
7019 OPC_CheckPredicate, 44, // 12066: check predicate 44
7020 OPC_Decode, 212, 116, 58, // 12068: decode to MACC_W01 using decoder 58
7021 // 12068: }
7022 3, 6, // 12072: case 0x3: {
7023 OPC_CheckPredicate, 44, // 12074: check predicate 44
7024 OPC_Decode, 213, 116, 58, // 12076: decode to MACC_W11 using decoder 58
7025 // 12076: }
7026 6, 6, // 12080: case 0x6: {
7027 OPC_CheckPredicate, 44, // 12082: check predicate 44
7028 OPC_Decode, 180, 118, 30, // 12084: decode to PASA_WX using decoder 30
7029 // 12084: }
7030 7, 0, // 12088: case 0x7: {
7031 OPC_CheckPredicate, 44, // 12090: check predicate 44
7032 OPC_Decode, 163, 119, 58, // 12092: decode to PMHRACCU_W using decoder 58
7033 // 12092: }
7034 // 12092: } // switch Inst[14:12]
7035 // 12092: }
7036 80, 43, // 12096: case 0x50: {
7037 OPC_SwitchField, 12, 3, // 12098: switch Inst[14:12] {
7038 2, 6, // 12101: case 0x2: {
7039 OPC_CheckPredicate, 39, // 12103: check predicate 39
7040 OPC_Decode, 224, 120, 30, // 12105: decode to PSH1ADD_H using decoder 30
7041 // 12105: }
7042 3, 6, // 12109: case 0x3: {
7043 OPC_CheckPredicate, 39, // 12111: check predicate 39
7044 OPC_Decode, 240, 119, 30, // 12113: decode to PMULU_H_B00 using decoder 30
7045 // 12113: }
7046 4, 6, // 12117: case 0x4: {
7047 OPC_CheckPredicate, 39, // 12119: check predicate 39
7048 OPC_Decode, 167, 120, 30, // 12121: decode to PPAIROE_B using decoder 30
7049 // 12121: }
7050 5, 6, // 12125: case 0x5: {
7051 OPC_CheckPredicate, 39, // 12127: check predicate 39
7052 OPC_Decode, 214, 118, 30, // 12129: decode to PM2ADDU_H using decoder 30
7053 // 12129: }
7054 7, 0, // 12133: case 0x7: {
7055 OPC_CheckPredicate, 39, // 12135: check predicate 39
7056 OPC_Decode, 227, 119, 30, // 12137: decode to PMULH_H_B0 using decoder 30
7057 // 12137: }
7058 // 12137: } // switch Inst[14:12]
7059 // 12137: }
7060 81, 43, // 12141: case 0x51: {
7061 OPC_SwitchField, 12, 3, // 12143: switch Inst[14:12] {
7062 2, 6, // 12146: case 0x2: {
7063 OPC_CheckPredicate, 44, // 12148: check predicate 44
7064 OPC_Decode, 225, 120, 30, // 12150: decode to PSH1ADD_W using decoder 30
7065 // 12150: }
7066 3, 6, // 12154: case 0x3: {
7067 OPC_CheckPredicate, 44, // 12156: check predicate 44
7068 OPC_Decode, 243, 119, 30, // 12158: decode to PMULU_W_H00 using decoder 30
7069 // 12158: }
7070 4, 6, // 12162: case 0x4: {
7071 OPC_CheckPredicate, 39, // 12164: check predicate 39
7072 OPC_Decode, 170, 120, 30, // 12166: decode to PPAIROE_H using decoder 30
7073 // 12166: }
7074 5, 6, // 12170: case 0x5: {
7075 OPC_CheckPredicate, 44, // 12172: check predicate 44
7076 OPC_Decode, 215, 118, 30, // 12174: decode to PM2ADDU_W using decoder 30
7077 // 12174: }
7078 7, 0, // 12178: case 0x7: {
7079 OPC_CheckPredicate, 44, // 12180: check predicate 44
7080 OPC_Decode, 230, 119, 30, // 12182: decode to PMULH_W_H0 using decoder 30
7081 // 12182: }
7082 // 12182: } // switch Inst[14:12]
7083 // 12182: }
7084 82, 19, // 12186: case 0x52: {
7085 OPC_SwitchField, 12, 3, // 12188: switch Inst[14:12] {
7086 5, 6, // 12191: case 0x5: {
7087 OPC_CheckPredicate, 39, // 12193: check predicate 39
7088 OPC_Decode, 250, 118, 30, // 12195: decode to PM4ADDU_B using decoder 30
7089 // 12195: }
7090 7, 0, // 12199: case 0x7: {
7091 OPC_CheckPredicate, 39, // 12201: check predicate 39
7092 OPC_Decode, 219, 119, 30, // 12203: decode to PMULHSU_H_B0 using decoder 30
7093 // 12203: }
7094 // 12203: } // switch Inst[14:12]
7095 // 12203: }
7096 83, 35, // 12207: case 0x53: {
7097 OPC_SwitchField, 12, 3, // 12209: switch Inst[14:12] {
7098 3, 6, // 12212: case 0x3: {
7099 OPC_CheckPredicate, 44, // 12214: check predicate 44
7100 OPC_Decode, 189, 117, 30, // 12216: decode to MULU_W00 using decoder 30
7101 // 12216: }
7102 4, 6, // 12220: case 0x4: {
7103 OPC_CheckPredicate, 44, // 12222: check predicate 44
7104 OPC_Decode, 171, 120, 30, // 12224: decode to PPAIROE_W using decoder 30
7105 // 12224: }
7106 5, 6, // 12228: case 0x5: {
7107 OPC_CheckPredicate, 44, // 12230: check predicate 44
7108 OPC_Decode, 251, 118, 30, // 12232: decode to PM4ADDU_H using decoder 30
7109 // 12232: }
7110 7, 0, // 12236: case 0x7: {
7111 OPC_CheckPredicate, 44, // 12238: check predicate 44
7112 OPC_Decode, 222, 119, 30, // 12240: decode to PMULHSU_W_H0 using decoder 30
7113 // 12240: }
7114 // 12240: } // switch Inst[14:12]
7115 // 12240: }
7116 84, 27, // 12244: case 0x54: {
7117 OPC_SwitchField, 12, 3, // 12246: switch Inst[14:12] {
7118 1, 6, // 12249: case 0x1: {
7119 OPC_CheckPredicate, 39, // 12251: check predicate 39
7120 OPC_Decode, 199, 117, 58, // 12253: decode to MVM using decoder 58
7121 // 12253: }
7122 5, 6, // 12257: case 0x5: {
7123 OPC_CheckPredicate, 39, // 12259: check predicate 39
7124 OPC_Decode, 206, 118, 58, // 12261: decode to PM2ADDAU_H using decoder 58
7125 // 12261: }
7126 7, 0, // 12265: case 0x7: {
7127 OPC_CheckPredicate, 39, // 12267: check predicate 39
7128 OPC_Decode, 155, 119, 58, // 12269: decode to PMHACC_H_B0 using decoder 58
7129 // 12269: }
7130 // 12269: } // switch Inst[14:12]
7131 // 12269: }
7132 85, 35, // 12273: case 0x55: {
7133 OPC_SwitchField, 12, 3, // 12275: switch Inst[14:12] {
7134 1, 6, // 12278: case 0x1: {
7135 OPC_CheckPredicate, 39, // 12280: check predicate 39
7136 OPC_Decode, 200, 117, 58, // 12282: decode to MVMN using decoder 58
7137 // 12282: }
7138 3, 6, // 12286: case 0x3: {
7139 OPC_CheckPredicate, 44, // 12288: check predicate 44
7140 OPC_Decode, 128, 119, 58, // 12290: decode to PMACCU_W_H00 using decoder 58
7141 // 12290: }
7142 5, 6, // 12294: case 0x5: {
7143 OPC_CheckPredicate, 44, // 12296: check predicate 44
7144 OPC_Decode, 207, 118, 58, // 12298: decode to PM2ADDAU_W using decoder 58
7145 // 12298: }
7146 7, 0, // 12302: case 0x7: {
7147 OPC_CheckPredicate, 44, // 12304: check predicate 44
7148 OPC_Decode, 158, 119, 58, // 12306: decode to PMHACC_W_H0 using decoder 58
7149 // 12306: }
7150 // 12306: } // switch Inst[14:12]
7151 // 12306: }
7152 86, 27, // 12310: case 0x56: {
7153 OPC_SwitchField, 12, 3, // 12312: switch Inst[14:12] {
7154 1, 6, // 12315: case 0x1: {
7155 OPC_CheckPredicate, 39, // 12317: check predicate 39
7156 OPC_Decode, 216, 116, 58, // 12319: decode to MERGE using decoder 58
7157 // 12319: }
7158 5, 6, // 12323: case 0x5: {
7159 OPC_CheckPredicate, 39, // 12325: check predicate 39
7160 OPC_Decode, 244, 118, 58, // 12327: decode to PM4ADDAU_B using decoder 58
7161 // 12327: }
7162 7, 0, // 12331: case 0x7: {
7163 OPC_CheckPredicate, 39, // 12333: check predicate 39
7164 OPC_Decode, 147, 119, 58, // 12335: decode to PMHACCSU_H_B0 using decoder 58
7165 // 12335: }
7166 // 12335: } // switch Inst[14:12]
7167 // 12335: }
7168 87, 35, // 12339: case 0x57: {
7169 OPC_SwitchField, 12, 3, // 12341: switch Inst[14:12] {
7170 1, 6, // 12344: case 0x1: {
7171 OPC_CheckPredicate, 39, // 12346: check predicate 39
7172 OPC_Decode, 182, 124, 58, // 12348: decode to SRX using decoder 58
7173 // 12348: }
7174 3, 6, // 12352: case 0x3: {
7175 OPC_CheckPredicate, 44, // 12354: check predicate 44
7176 OPC_Decode, 205, 116, 58, // 12356: decode to MACCU_W00 using decoder 58
7177 // 12356: }
7178 5, 6, // 12360: case 0x5: {
7179 OPC_CheckPredicate, 44, // 12362: check predicate 44
7180 OPC_Decode, 245, 118, 58, // 12364: decode to PM4ADDAU_H using decoder 58
7181 // 12364: }
7182 7, 0, // 12368: case 0x7: {
7183 OPC_CheckPredicate, 44, // 12370: check predicate 44
7184 OPC_Decode, 150, 119, 58, // 12372: decode to PMHACCSU_W_H0 using decoder 58
7185 // 12372: }
7186 // 12372: } // switch Inst[14:12]
7187 // 12372: }
7188 88, 59, // 12376: case 0x58: {
7189 OPC_SwitchField, 12, 3, // 12378: switch Inst[14:12] {
7190 0, 6, // 12381: case 0x0: {
7191 OPC_CheckPredicate, 39, // 12383: check predicate 39
7192 OPC_Decode, 198, 120, 30, // 12385: decode to PSADDU_H using decoder 30
7193 // 12385: }
7194 1, 6, // 12389: case 0x1: {
7195 OPC_CheckPredicate, 39, // 12391: check predicate 39
7196 OPC_Decode, 241, 119, 30, // 12393: decode to PMULU_H_B01 using decoder 30
7197 // 12393: }
7198 2, 6, // 12397: case 0x2: {
7199 OPC_CheckPredicate, 39, // 12399: check predicate 39
7200 OPC_Decode, 143, 121, 30, // 12401: decode to PSSH1SADD_H using decoder 30
7201 // 12401: }
7202 3, 6, // 12405: case 0x3: {
7203 OPC_CheckPredicate, 39, // 12407: check predicate 39
7204 OPC_Decode, 242, 119, 30, // 12409: decode to PMULU_H_B11 using decoder 30
7205 // 12409: }
7206 4, 6, // 12413: case 0x4: {
7207 OPC_CheckPredicate, 39, // 12415: check predicate 39
7208 OPC_Decode, 172, 120, 30, // 12417: decode to PPAIRO_B using decoder 30
7209 // 12417: }
7210 5, 6, // 12421: case 0x5: {
7211 OPC_CheckPredicate, 39, // 12423: check predicate 39
7212 OPC_Decode, 180, 119, 30, // 12425: decode to PMQ2ADD_H using decoder 30
7213 // 12425: }
7214 7, 0, // 12429: case 0x7: {
7215 OPC_CheckPredicate, 39, // 12431: check predicate 39
7216 OPC_Decode, 228, 119, 30, // 12433: decode to PMULH_H_B1 using decoder 30
7217 // 12433: }
7218 // 12433: } // switch Inst[14:12]
7219 // 12433: }
7220 89, 59, // 12437: case 0x59: {
7221 OPC_SwitchField, 12, 3, // 12439: switch Inst[14:12] {
7222 0, 6, // 12442: case 0x0: {
7223 OPC_CheckPredicate, 44, // 12444: check predicate 44
7224 OPC_Decode, 199, 120, 30, // 12446: decode to PSADDU_W using decoder 30
7225 // 12446: }
7226 1, 6, // 12450: case 0x1: {
7227 OPC_CheckPredicate, 44, // 12452: check predicate 44
7228 OPC_Decode, 244, 119, 30, // 12454: decode to PMULU_W_H01 using decoder 30
7229 // 12454: }
7230 2, 6, // 12458: case 0x2: {
7231 OPC_CheckPredicate, 44, // 12460: check predicate 44
7232 OPC_Decode, 144, 121, 30, // 12462: decode to PSSH1SADD_W using decoder 30
7233 // 12462: }
7234 3, 6, // 12466: case 0x3: {
7235 OPC_CheckPredicate, 44, // 12468: check predicate 44
7236 OPC_Decode, 245, 119, 30, // 12470: decode to PMULU_W_H11 using decoder 30
7237 // 12470: }
7238 4, 6, // 12474: case 0x4: {
7239 OPC_CheckPredicate, 39, // 12476: check predicate 39
7240 OPC_Decode, 175, 120, 30, // 12478: decode to PPAIRO_H using decoder 30
7241 // 12478: }
7242 5, 6, // 12482: case 0x5: {
7243 OPC_CheckPredicate, 44, // 12484: check predicate 44
7244 OPC_Decode, 181, 119, 30, // 12486: decode to PMQ2ADD_W using decoder 30
7245 // 12486: }
7246 7, 0, // 12490: case 0x7: {
7247 OPC_CheckPredicate, 44, // 12492: check predicate 44
7248 OPC_Decode, 231, 119, 30, // 12494: decode to PMULH_W_H1 using decoder 30
7249 // 12494: }
7250 // 12494: } // switch Inst[14:12]
7251 // 12494: }
7252 90, 35, // 12498: case 0x5a: {
7253 OPC_SwitchField, 12, 3, // 12500: switch Inst[14:12] {
7254 0, 6, // 12503: case 0x0: {
7255 OPC_CheckPredicate, 39, // 12505: check predicate 39
7256 OPC_Decode, 194, 120, 30, // 12507: decode to PSADDU_B using decoder 30
7257 // 12507: }
7258 1, 6, // 12511: case 0x1: {
7259 OPC_CheckPredicate, 39, // 12513: check predicate 39
7260 OPC_Decode, 154, 118, 30, // 12515: decode to PABDSUMU_B using decoder 30
7261 // 12515: }
7262 5, 6, // 12519: case 0x5: {
7263 OPC_CheckPredicate, 39, // 12521: check predicate 39
7264 OPC_Decode, 187, 119, 30, // 12523: decode to PMQR2ADD_H using decoder 30
7265 // 12523: }
7266 7, 0, // 12527: case 0x7: {
7267 OPC_CheckPredicate, 39, // 12529: check predicate 39
7268 OPC_Decode, 220, 119, 30, // 12531: decode to PMULHSU_H_B1 using decoder 30
7269 // 12531: }
7270 // 12531: } // switch Inst[14:12]
7271 // 12531: }
7272 91, 43, // 12535: case 0x5b: {
7273 OPC_SwitchField, 12, 3, // 12537: switch Inst[14:12] {
7274 1, 6, // 12540: case 0x1: {
7275 OPC_CheckPredicate, 44, // 12542: check predicate 44
7276 OPC_Decode, 190, 117, 30, // 12544: decode to MULU_W01 using decoder 30
7277 // 12544: }
7278 3, 6, // 12548: case 0x3: {
7279 OPC_CheckPredicate, 44, // 12550: check predicate 44
7280 OPC_Decode, 191, 117, 30, // 12552: decode to MULU_W11 using decoder 30
7281 // 12552: }
7282 4, 6, // 12556: case 0x4: {
7283 OPC_CheckPredicate, 44, // 12558: check predicate 44
7284 OPC_Decode, 176, 120, 30, // 12560: decode to PPAIRO_W using decoder 30
7285 // 12560: }
7286 5, 6, // 12564: case 0x5: {
7287 OPC_CheckPredicate, 44, // 12566: check predicate 44
7288 OPC_Decode, 188, 119, 30, // 12568: decode to PMQR2ADD_W using decoder 30
7289 // 12568: }
7290 7, 0, // 12572: case 0x7: {
7291 OPC_CheckPredicate, 44, // 12574: check predicate 44
7292 OPC_Decode, 223, 119, 30, // 12576: decode to PMULHSU_W_H1 using decoder 30
7293 // 12576: }
7294 // 12576: } // switch Inst[14:12]
7295 // 12576: }
7296 92, 27, // 12580: case 0x5c: {
7297 OPC_SwitchField, 12, 3, // 12582: switch Inst[14:12] {
7298 0, 6, // 12585: case 0x0: {
7299 OPC_CheckPredicate, 39, // 12587: check predicate 39
7300 OPC_Decode, 142, 118, 30, // 12589: decode to PAADDU_H using decoder 30
7301 // 12589: }
7302 5, 6, // 12593: case 0x5: {
7303 OPC_CheckPredicate, 39, // 12595: check predicate 39
7304 OPC_Decode, 178, 119, 58, // 12597: decode to PMQ2ADDA_H using decoder 58
7305 // 12597: }
7306 7, 0, // 12601: case 0x7: {
7307 OPC_CheckPredicate, 39, // 12603: check predicate 39
7308 OPC_Decode, 156, 119, 58, // 12605: decode to PMHACC_H_B1 using decoder 58
7309 // 12605: }
7310 // 12605: } // switch Inst[14:12]
7311 // 12605: }
7312 93, 43, // 12609: case 0x5d: {
7313 OPC_SwitchField, 12, 3, // 12611: switch Inst[14:12] {
7314 0, 6, // 12614: case 0x0: {
7315 OPC_CheckPredicate, 44, // 12616: check predicate 44
7316 OPC_Decode, 143, 118, 30, // 12618: decode to PAADDU_W using decoder 30
7317 // 12618: }
7318 1, 6, // 12622: case 0x1: {
7319 OPC_CheckPredicate, 44, // 12624: check predicate 44
7320 OPC_Decode, 129, 119, 58, // 12626: decode to PMACCU_W_H01 using decoder 58
7321 // 12626: }
7322 3, 6, // 12630: case 0x3: {
7323 OPC_CheckPredicate, 44, // 12632: check predicate 44
7324 OPC_Decode, 130, 119, 58, // 12634: decode to PMACCU_W_H11 using decoder 58
7325 // 12634: }
7326 5, 6, // 12638: case 0x5: {
7327 OPC_CheckPredicate, 44, // 12640: check predicate 44
7328 OPC_Decode, 179, 119, 58, // 12642: decode to PMQ2ADDA_W using decoder 58
7329 // 12642: }
7330 7, 0, // 12646: case 0x7: {
7331 OPC_CheckPredicate, 44, // 12648: check predicate 44
7332 OPC_Decode, 159, 119, 58, // 12650: decode to PMHACC_W_H1 using decoder 58
7333 // 12650: }
7334 // 12650: } // switch Inst[14:12]
7335 // 12650: }
7336 94, 35, // 12654: case 0x5e: {
7337 OPC_SwitchField, 12, 3, // 12656: switch Inst[14:12] {
7338 0, 6, // 12659: case 0x0: {
7339 OPC_CheckPredicate, 39, // 12661: check predicate 39
7340 OPC_Decode, 138, 118, 30, // 12663: decode to PAADDU_B using decoder 30
7341 // 12663: }
7342 1, 6, // 12667: case 0x1: {
7343 OPC_CheckPredicate, 39, // 12669: check predicate 39
7344 OPC_Decode, 153, 118, 58, // 12671: decode to PABDSUMAU_B using decoder 58
7345 // 12671: }
7346 5, 6, // 12675: case 0x5: {
7347 OPC_CheckPredicate, 39, // 12677: check predicate 39
7348 OPC_Decode, 185, 119, 58, // 12679: decode to PMQR2ADDA_H using decoder 58
7349 // 12679: }
7350 7, 0, // 12683: case 0x7: {
7351 OPC_CheckPredicate, 39, // 12685: check predicate 39
7352 OPC_Decode, 148, 119, 58, // 12687: decode to PMHACCSU_H_B1 using decoder 58
7353 // 12687: }
7354 // 12687: } // switch Inst[14:12]
7355 // 12687: }
7356 95, 35, // 12691: case 0x5f: {
7357 OPC_SwitchField, 12, 3, // 12693: switch Inst[14:12] {
7358 1, 6, // 12696: case 0x1: {
7359 OPC_CheckPredicate, 44, // 12698: check predicate 44
7360 OPC_Decode, 206, 116, 58, // 12700: decode to MACCU_W01 using decoder 58
7361 // 12700: }
7362 3, 6, // 12704: case 0x3: {
7363 OPC_CheckPredicate, 44, // 12706: check predicate 44
7364 OPC_Decode, 207, 116, 58, // 12708: decode to MACCU_W11 using decoder 58
7365 // 12708: }
7366 5, 6, // 12712: case 0x5: {
7367 OPC_CheckPredicate, 44, // 12714: check predicate 44
7368 OPC_Decode, 186, 119, 58, // 12716: decode to PMQR2ADDA_W using decoder 58
7369 // 12716: }
7370 7, 0, // 12720: case 0x7: {
7371 OPC_CheckPredicate, 44, // 12722: check predicate 44
7372 OPC_Decode, 151, 119, 58, // 12724: decode to PMHACCSU_W_H1 using decoder 58
7373 // 12724: }
7374 // 12724: } // switch Inst[14:12]
7375 // 12724: }
7376 96, 43, // 12728: case 0x60: {
7377 OPC_SwitchField, 12, 3, // 12730: switch Inst[14:12] {
7378 0, 6, // 12733: case 0x0: {
7379 OPC_CheckPredicate, 39, // 12735: check predicate 39
7380 OPC_Decode, 181, 121, 30, // 12737: decode to PSUB_H using decoder 30
7381 // 12737: }
7382 2, 6, // 12741: case 0x2: {
7383 OPC_CheckPredicate, 44, // 12743: check predicate 44
7384 OPC_Decode, 128, 120, 30, // 12745: decode to PNCLIPP_B using decoder 30
7385 // 12745: }
7386 5, 6, // 12749: case 0x5: {
7387 OPC_CheckPredicate, 39, // 12751: check predicate 39
7388 OPC_Decode, 226, 118, 30, // 12753: decode to PM2SUB_H using decoder 30
7389 // 12753: }
7390 6, 6, // 12757: case 0x6: {
7391 OPC_CheckPredicate, 39, // 12759: check predicate 39
7392 OPC_Decode, 198, 119, 30, // 12761: decode to PMSEQ_H using decoder 30
7393 // 12761: }
7394 7, 0, // 12765: case 0x7: {
7395 OPC_CheckPredicate, 39, // 12767: check predicate 39
7396 OPC_Decode, 218, 119, 30, // 12769: decode to PMULHSU_H using decoder 30
7397 // 12769: }
7398 // 12769: } // switch Inst[14:12]
7399 // 12769: }
7400 97, 43, // 12773: case 0x61: {
7401 OPC_SwitchField, 12, 3, // 12775: switch Inst[14:12] {
7402 0, 6, // 12778: case 0x0: {
7403 OPC_CheckPredicate, 44, // 12780: check predicate 44
7404 OPC_Decode, 182, 121, 30, // 12782: decode to PSUB_W using decoder 30
7405 // 12782: }
7406 2, 6, // 12786: case 0x2: {
7407 OPC_CheckPredicate, 44, // 12788: check predicate 44
7408 OPC_Decode, 129, 120, 30, // 12790: decode to PNCLIPP_H using decoder 30
7409 // 12790: }
7410 5, 6, // 12794: case 0x5: {
7411 OPC_CheckPredicate, 44, // 12796: check predicate 44
7412 OPC_Decode, 228, 118, 30, // 12798: decode to PM2SUB_W using decoder 30
7413 // 12798: }
7414 6, 6, // 12802: case 0x6: {
7415 OPC_CheckPredicate, 44, // 12804: check predicate 44
7416 OPC_Decode, 199, 119, 30, // 12806: decode to PMSEQ_W using decoder 30
7417 // 12806: }
7418 7, 0, // 12810: case 0x7: {
7419 OPC_CheckPredicate, 44, // 12812: check predicate 44
7420 OPC_Decode, 221, 119, 30, // 12814: decode to PMULHSU_W using decoder 30
7421 // 12814: }
7422 // 12814: } // switch Inst[14:12]
7423 // 12814: }
7424 98, 35, // 12818: case 0x62: {
7425 OPC_SwitchField, 12, 3, // 12820: switch Inst[14:12] {
7426 0, 6, // 12823: case 0x0: {
7427 OPC_CheckPredicate, 39, // 12825: check predicate 39
7428 OPC_Decode, 177, 121, 30, // 12827: decode to PSUB_B using decoder 30
7429 // 12827: }
7430 5, 6, // 12831: case 0x5: {
7431 OPC_CheckPredicate, 39, // 12833: check predicate 39
7432 OPC_Decode, 220, 118, 30, // 12835: decode to PM2SADD_H using decoder 30
7433 // 12835: }
7434 6, 6, // 12839: case 0x6: {
7435 OPC_CheckPredicate, 39, // 12841: check predicate 39
7436 OPC_Decode, 194, 119, 30, // 12843: decode to PMSEQ_B using decoder 30
7437 // 12843: }
7438 7, 0, // 12847: case 0x7: {
7439 OPC_CheckPredicate, 39, // 12849: check predicate 39
7440 OPC_Decode, 212, 119, 30, // 12851: decode to PMULHRSU_H using decoder 30
7441 // 12851: }
7442 // 12851: } // switch Inst[14:12]
7443 // 12851: }
7444 99, 19, // 12855: case 0x63: {
7445 OPC_SwitchField, 12, 3, // 12857: switch Inst[14:12] {
7446 2, 6, // 12860: case 0x2: {
7447 OPC_CheckPredicate, 44, // 12862: check predicate 44
7448 OPC_Decode, 130, 120, 30, // 12864: decode to PNCLIPP_W using decoder 30
7449 // 12864: }
7450 7, 0, // 12868: case 0x7: {
7451 OPC_CheckPredicate, 44, // 12870: check predicate 44
7452 OPC_Decode, 213, 119, 30, // 12872: decode to PMULHRSU_W using decoder 30
7453 // 12872: }
7454 // 12872: } // switch Inst[14:12]
7455 // 12872: }
7456 100, 27, // 12876: case 0x64: {
7457 OPC_SwitchField, 12, 3, // 12878: switch Inst[14:12] {
7458 0, 6, // 12881: case 0x0: {
7459 OPC_CheckPredicate, 39, // 12883: check predicate 39
7460 OPC_Decode, 162, 118, 30, // 12885: decode to PABD_H using decoder 30
7461 // 12885: }
7462 5, 6, // 12889: case 0x5: {
7463 OPC_CheckPredicate, 39, // 12891: check predicate 39
7464 OPC_Decode, 222, 118, 58, // 12893: decode to PM2SUBA_H using decoder 58
7465 // 12893: }
7466 7, 0, // 12897: case 0x7: {
7467 OPC_CheckPredicate, 39, // 12899: check predicate 39
7468 OPC_Decode, 146, 119, 58, // 12901: decode to PMHACCSU_H using decoder 58
7469 // 12901: }
7470 // 12901: } // switch Inst[14:12]
7471 // 12901: }
7472 101, 19, // 12905: case 0x65: {
7473 OPC_SwitchField, 12, 3, // 12907: switch Inst[14:12] {
7474 5, 6, // 12910: case 0x5: {
7475 OPC_CheckPredicate, 44, // 12912: check predicate 44
7476 OPC_Decode, 224, 118, 58, // 12914: decode to PM2SUBA_W using decoder 58
7477 // 12914: }
7478 7, 0, // 12918: case 0x7: {
7479 OPC_CheckPredicate, 44, // 12920: check predicate 44
7480 OPC_Decode, 149, 119, 58, // 12922: decode to PMHACCSU_W using decoder 58
7481 // 12922: }
7482 // 12922: } // switch Inst[14:12]
7483 // 12922: }
7484 102, 19, // 12926: case 0x66: {
7485 OPC_SwitchField, 12, 3, // 12928: switch Inst[14:12] {
7486 0, 6, // 12931: case 0x0: {
7487 OPC_CheckPredicate, 39, // 12933: check predicate 39
7488 OPC_Decode, 159, 118, 30, // 12935: decode to PABD_B using decoder 30
7489 // 12935: }
7490 7, 0, // 12939: case 0x7: {
7491 OPC_CheckPredicate, 39, // 12941: check predicate 39
7492 OPC_Decode, 160, 119, 58, // 12943: decode to PMHRACCSU_H using decoder 58
7493 // 12943: }
7494 // 12943: } // switch Inst[14:12]
7495 // 12943: }
7496 103, 10, // 12947: case 0x67: {
7497 OPC_CheckPredicate, 44, // 12949: check predicate 44
7498 OPC_CheckField, 12, 3, 7, // 12951: check Inst[14:12] == 0x7
7499 OPC_Decode, 161, 119, 58, // 12955: decode to PMHRACCSU_W using decoder 58
7500 // 12955: }
7501 104, 35, // 12959: case 0x68: {
7502 OPC_SwitchField, 12, 3, // 12961: switch Inst[14:12] {
7503 0, 6, // 12964: case 0x0: {
7504 OPC_CheckPredicate, 39, // 12966: check predicate 39
7505 OPC_Decode, 175, 121, 30, // 12968: decode to PSSUB_H using decoder 30
7506 // 12968: }
7507 5, 6, // 12972: case 0x5: {
7508 OPC_CheckPredicate, 39, // 12974: check predicate 39
7509 OPC_Decode, 227, 118, 30, // 12976: decode to PM2SUB_HX using decoder 30
7510 // 12976: }
7511 6, 6, // 12980: case 0x6: {
7512 OPC_CheckPredicate, 39, // 12982: check predicate 39
7513 OPC_Decode, 210, 119, 30, // 12984: decode to PMSLT_H using decoder 30
7514 // 12984: }
7515 7, 0, // 12988: case 0x7: {
7516 OPC_CheckPredicate, 39, // 12990: check predicate 39
7517 OPC_Decode, 234, 119, 30, // 12992: decode to PMULQ_H using decoder 30
7518 // 12992: }
7519 // 12992: } // switch Inst[14:12]
7520 // 12992: }
7521 105, 35, // 12996: case 0x69: {
7522 OPC_SwitchField, 12, 3, // 12998: switch Inst[14:12] {
7523 0, 6, // 13001: case 0x0: {
7524 OPC_CheckPredicate, 44, // 13003: check predicate 44
7525 OPC_Decode, 176, 121, 30, // 13005: decode to PSSUB_W using decoder 30
7526 // 13005: }
7527 5, 6, // 13009: case 0x5: {
7528 OPC_CheckPredicate, 44, // 13011: check predicate 44
7529 OPC_Decode, 229, 118, 30, // 13013: decode to PM2SUB_WX using decoder 30
7530 // 13013: }
7531 6, 6, // 13017: case 0x6: {
7532 OPC_CheckPredicate, 44, // 13019: check predicate 44
7533 OPC_Decode, 211, 119, 30, // 13021: decode to PMSLT_W using decoder 30
7534 // 13021: }
7535 7, 0, // 13025: case 0x7: {
7536 OPC_CheckPredicate, 44, // 13027: check predicate 44
7537 OPC_Decode, 235, 119, 30, // 13029: decode to PMULQ_W using decoder 30
7538 // 13029: }
7539 // 13029: } // switch Inst[14:12]
7540 // 13029: }
7541 106, 35, // 13033: case 0x6a: {
7542 OPC_SwitchField, 12, 3, // 13035: switch Inst[14:12] {
7543 0, 6, // 13038: case 0x0: {
7544 OPC_CheckPredicate, 39, // 13040: check predicate 39
7545 OPC_Decode, 171, 121, 30, // 13042: decode to PSSUB_B using decoder 30
7546 // 13042: }
7547 5, 6, // 13046: case 0x5: {
7548 OPC_CheckPredicate, 39, // 13048: check predicate 39
7549 OPC_Decode, 221, 118, 30, // 13050: decode to PM2SADD_HX using decoder 30
7550 // 13050: }
7551 6, 6, // 13054: case 0x6: {
7552 OPC_CheckPredicate, 39, // 13056: check predicate 39
7553 OPC_Decode, 206, 119, 30, // 13058: decode to PMSLT_B using decoder 30
7554 // 13058: }
7555 7, 0, // 13062: case 0x7: {
7556 OPC_CheckPredicate, 39, // 13064: check predicate 39
7557 OPC_Decode, 232, 119, 30, // 13066: decode to PMULQR_H using decoder 30
7558 // 13066: }
7559 // 13066: } // switch Inst[14:12]
7560 // 13066: }
7561 107, 10, // 13070: case 0x6b: {
7562 OPC_CheckPredicate, 44, // 13072: check predicate 44
7563 OPC_CheckField, 12, 3, 7, // 13074: check Inst[14:12] == 0x7
7564 OPC_Decode, 233, 119, 30, // 13078: decode to PMULQR_W using decoder 30
7565 // 13078: }
7566 108, 27, // 13082: case 0x6c: {
7567 OPC_SwitchField, 12, 3, // 13084: switch Inst[14:12] {
7568 0, 6, // 13087: case 0x0: {
7569 OPC_CheckPredicate, 39, // 13089: check predicate 39
7570 OPC_Decode, 191, 118, 30, // 13091: decode to PASUB_H using decoder 30
7571 // 13091: }
7572 5, 6, // 13095: case 0x5: {
7573 OPC_CheckPredicate, 39, // 13097: check predicate 39
7574 OPC_Decode, 223, 118, 58, // 13099: decode to PM2SUBA_HX using decoder 58
7575 // 13099: }
7576 6, 0, // 13103: case 0x6: {
7577 OPC_CheckPredicate, 39, // 13105: check predicate 39
7578 OPC_Decode, 204, 119, 30, // 13107: decode to PMSLTU_H using decoder 30
7579 // 13107: }
7580 // 13107: } // switch Inst[14:12]
7581 // 13107: }
7582 109, 27, // 13111: case 0x6d: {
7583 OPC_SwitchField, 12, 3, // 13113: switch Inst[14:12] {
7584 0, 6, // 13116: case 0x0: {
7585 OPC_CheckPredicate, 44, // 13118: check predicate 44
7586 OPC_Decode, 192, 118, 30, // 13120: decode to PASUB_W using decoder 30
7587 // 13120: }
7588 5, 6, // 13124: case 0x5: {
7589 OPC_CheckPredicate, 44, // 13126: check predicate 44
7590 OPC_Decode, 225, 118, 58, // 13128: decode to PM2SUBA_WX using decoder 58
7591 // 13128: }
7592 6, 0, // 13132: case 0x6: {
7593 OPC_CheckPredicate, 44, // 13134: check predicate 44
7594 OPC_Decode, 205, 119, 30, // 13136: decode to PMSLTU_W using decoder 30
7595 // 13136: }
7596 // 13136: } // switch Inst[14:12]
7597 // 13136: }
7598 110, 19, // 13140: case 0x6e: {
7599 OPC_SwitchField, 12, 3, // 13142: switch Inst[14:12] {
7600 0, 6, // 13145: case 0x0: {
7601 OPC_CheckPredicate, 39, // 13147: check predicate 39
7602 OPC_Decode, 187, 118, 30, // 13149: decode to PASUB_B using decoder 30
7603 // 13149: }
7604 6, 0, // 13153: case 0x6: {
7605 OPC_CheckPredicate, 39, // 13155: check predicate 39
7606 OPC_Decode, 200, 119, 30, // 13157: decode to PMSLTU_B using decoder 30
7607 // 13157: }
7608 // 13157: } // switch Inst[14:12]
7609 // 13157: }
7610 112, 35, // 13161: case 0x70: {
7611 OPC_SwitchField, 12, 3, // 13163: switch Inst[14:12] {
7612 2, 6, // 13166: case 0x2: {
7613 OPC_CheckPredicate, 44, // 13168: check predicate 44
7614 OPC_Decode, 194, 125, 30, // 13170: decode to UNZIP8P using decoder 30
7615 // 13170: }
7616 3, 6, // 13174: case 0x3: {
7617 OPC_CheckPredicate, 39, // 13176: check predicate 39
7618 OPC_Decode, 236, 119, 30, // 13178: decode to PMULSU_H_B00 using decoder 30
7619 // 13178: }
7620 5, 6, // 13182: case 0x5: {
7621 OPC_CheckPredicate, 39, // 13184: check predicate 39
7622 OPC_Decode, 212, 118, 30, // 13186: decode to PM2ADDSU_H using decoder 30
7623 // 13186: }
7624 6, 0, // 13190: case 0x6: {
7625 OPC_CheckPredicate, 39, // 13192: check predicate 39
7626 OPC_Decode, 176, 119, 30, // 13194: decode to PMIN_H using decoder 30
7627 // 13194: }
7628 // 13194: } // switch Inst[14:12]
7629 // 13194: }
7630 113, 35, // 13198: case 0x71: {
7631 OPC_SwitchField, 12, 3, // 13200: switch Inst[14:12] {
7632 2, 6, // 13203: case 0x2: {
7633 OPC_CheckPredicate, 44, // 13205: check predicate 44
7634 OPC_Decode, 192, 125, 30, // 13207: decode to UNZIP16P using decoder 30
7635 // 13207: }
7636 3, 6, // 13211: case 0x3: {
7637 OPC_CheckPredicate, 44, // 13213: check predicate 44
7638 OPC_Decode, 238, 119, 30, // 13215: decode to PMULSU_W_H00 using decoder 30
7639 // 13215: }
7640 5, 6, // 13219: case 0x5: {
7641 OPC_CheckPredicate, 44, // 13221: check predicate 44
7642 OPC_Decode, 213, 118, 30, // 13223: decode to PM2ADDSU_W using decoder 30
7643 // 13223: }
7644 6, 0, // 13227: case 0x6: {
7645 OPC_CheckPredicate, 44, // 13229: check predicate 44
7646 OPC_Decode, 177, 119, 30, // 13231: decode to PMIN_W using decoder 30
7647 // 13231: }
7648 // 13231: } // switch Inst[14:12]
7649 // 13231: }
7650 114, 27, // 13235: case 0x72: {
7651 OPC_SwitchField, 12, 3, // 13237: switch Inst[14:12] {
7652 2, 6, // 13240: case 0x2: {
7653 OPC_CheckPredicate, 44, // 13242: check predicate 44
7654 OPC_Decode, 193, 125, 30, // 13244: decode to UNZIP8HP using decoder 30
7655 // 13244: }
7656 5, 6, // 13248: case 0x5: {
7657 OPC_CheckPredicate, 39, // 13250: check predicate 39
7658 OPC_Decode, 248, 118, 30, // 13252: decode to PM4ADDSU_B using decoder 30
7659 // 13252: }
7660 6, 0, // 13256: case 0x6: {
7661 OPC_CheckPredicate, 39, // 13258: check predicate 39
7662 OPC_Decode, 172, 119, 30, // 13260: decode to PMIN_B using decoder 30
7663 // 13260: }
7664 // 13260: } // switch Inst[14:12]
7665 // 13260: }
7666 115, 27, // 13264: case 0x73: {
7667 OPC_SwitchField, 12, 3, // 13266: switch Inst[14:12] {
7668 2, 6, // 13269: case 0x2: {
7669 OPC_CheckPredicate, 44, // 13271: check predicate 44
7670 OPC_Decode, 191, 125, 30, // 13273: decode to UNZIP16HP using decoder 30
7671 // 13273: }
7672 3, 6, // 13277: case 0x3: {
7673 OPC_CheckPredicate, 44, // 13279: check predicate 44
7674 OPC_Decode, 184, 117, 30, // 13281: decode to MULSU_W00 using decoder 30
7675 // 13281: }
7676 5, 0, // 13285: case 0x5: {
7677 OPC_CheckPredicate, 44, // 13287: check predicate 44
7678 OPC_Decode, 249, 118, 30, // 13289: decode to PM4ADDSU_H using decoder 30
7679 // 13289: }
7680 // 13289: } // switch Inst[14:12]
7681 // 13289: }
7682 116, 35, // 13293: case 0x74: {
7683 OPC_SwitchField, 12, 3, // 13295: switch Inst[14:12] {
7684 0, 6, // 13298: case 0x0: {
7685 OPC_CheckPredicate, 39, // 13300: check predicate 39
7686 OPC_Decode, 158, 118, 30, // 13302: decode to PABDU_H using decoder 30
7687 // 13302: }
7688 5, 6, // 13306: case 0x5: {
7689 OPC_CheckPredicate, 39, // 13308: check predicate 39
7690 OPC_Decode, 204, 118, 58, // 13310: decode to PM2ADDASU_H using decoder 58
7691 // 13310: }
7692 6, 6, // 13314: case 0x6: {
7693 OPC_CheckPredicate, 39, // 13316: check predicate 39
7694 OPC_Decode, 170, 119, 30, // 13318: decode to PMINU_H using decoder 30
7695 // 13318: }
7696 7, 0, // 13322: case 0x7: {
7697 OPC_CheckPredicate, 44, // 13324: check predicate 44
7698 OPC_Decode, 182, 119, 58, // 13326: decode to PMQACC_W_H00 using decoder 58
7699 // 13326: }
7700 // 13326: } // switch Inst[14:12]
7701 // 13326: }
7702 117, 35, // 13330: case 0x75: {
7703 OPC_SwitchField, 12, 3, // 13332: switch Inst[14:12] {
7704 3, 6, // 13335: case 0x3: {
7705 OPC_CheckPredicate, 44, // 13337: check predicate 44
7706 OPC_Decode, 254, 118, 58, // 13339: decode to PMACCSU_W_H00 using decoder 58
7707 // 13339: }
7708 5, 6, // 13343: case 0x5: {
7709 OPC_CheckPredicate, 44, // 13345: check predicate 44
7710 OPC_Decode, 205, 118, 58, // 13347: decode to PM2ADDASU_W using decoder 58
7711 // 13347: }
7712 6, 6, // 13351: case 0x6: {
7713 OPC_CheckPredicate, 44, // 13353: check predicate 44
7714 OPC_Decode, 171, 119, 30, // 13355: decode to PMINU_W using decoder 30
7715 // 13355: }
7716 7, 0, // 13359: case 0x7: {
7717 OPC_CheckPredicate, 44, // 13361: check predicate 44
7718 OPC_Decode, 154, 117, 58, // 13363: decode to MQACC_W00 using decoder 58
7719 // 13363: }
7720 // 13363: } // switch Inst[14:12]
7721 // 13363: }
7722 118, 35, // 13367: case 0x76: {
7723 OPC_SwitchField, 12, 3, // 13369: switch Inst[14:12] {
7724 0, 6, // 13372: case 0x0: {
7725 OPC_CheckPredicate, 39, // 13374: check predicate 39
7726 OPC_Decode, 155, 118, 30, // 13376: decode to PABDU_B using decoder 30
7727 // 13376: }
7728 5, 6, // 13380: case 0x5: {
7729 OPC_CheckPredicate, 39, // 13382: check predicate 39
7730 OPC_Decode, 242, 118, 58, // 13384: decode to PM4ADDASU_B using decoder 58
7731 // 13384: }
7732 6, 6, // 13388: case 0x6: {
7733 OPC_CheckPredicate, 39, // 13390: check predicate 39
7734 OPC_Decode, 166, 119, 30, // 13392: decode to PMINU_B using decoder 30
7735 // 13392: }
7736 7, 0, // 13396: case 0x7: {
7737 OPC_CheckPredicate, 44, // 13398: check predicate 44
7738 OPC_Decode, 189, 119, 58, // 13400: decode to PMQRACC_W_H00 using decoder 58
7739 // 13400: }
7740 // 13400: } // switch Inst[14:12]
7741 // 13400: }
7742 119, 27, // 13404: case 0x77: {
7743 OPC_SwitchField, 12, 3, // 13406: switch Inst[14:12] {
7744 3, 6, // 13409: case 0x3: {
7745 OPC_CheckPredicate, 44, // 13411: check predicate 44
7746 OPC_Decode, 200, 116, 58, // 13413: decode to MACCSU_W00 using decoder 58
7747 // 13413: }
7748 5, 6, // 13417: case 0x5: {
7749 OPC_CheckPredicate, 44, // 13419: check predicate 44
7750 OPC_Decode, 243, 118, 58, // 13421: decode to PM4ADDASU_H using decoder 58
7751 // 13421: }
7752 7, 0, // 13425: case 0x7: {
7753 OPC_CheckPredicate, 44, // 13427: check predicate 44
7754 OPC_Decode, 160, 117, 58, // 13429: decode to MQRACC_W00 using decoder 58
7755 // 13429: }
7756 // 13429: } // switch Inst[14:12]
7757 // 13429: }
7758 120, 36, // 13433: case 0x78: {
7759 OPC_SwitchField, 12, 3, // 13435: switch Inst[14:12] {
7760 0, 6, // 13438: case 0x0: {
7761 OPC_CheckPredicate, 39, // 13440: check predicate 39
7762 OPC_Decode, 169, 121, 30, // 13442: decode to PSSUBU_H using decoder 30
7763 // 13442: }
7764 2, 7, // 13446: case 0x2: {
7765 OPC_CheckPredicate, 44, // 13448: check predicate 44
7766 OPC_Decode, 159, 131, 1, 30, // 13450: decode to ZIP8P using decoder 30
7767 // 13450: }
7768 3, 6, // 13455: case 0x3: {
7769 OPC_CheckPredicate, 39, // 13457: check predicate 39
7770 OPC_Decode, 237, 119, 30, // 13459: decode to PMULSU_H_B11 using decoder 30
7771 // 13459: }
7772 6, 0, // 13463: case 0x6: {
7773 OPC_CheckPredicate, 39, // 13465: check predicate 39
7774 OPC_Decode, 144, 119, 30, // 13467: decode to PMAX_H using decoder 30
7775 // 13467: }
7776 // 13467: } // switch Inst[14:12]
7777 // 13467: }
7778 121, 36, // 13471: case 0x79: {
7779 OPC_SwitchField, 12, 3, // 13473: switch Inst[14:12] {
7780 0, 6, // 13476: case 0x0: {
7781 OPC_CheckPredicate, 44, // 13478: check predicate 44
7782 OPC_Decode, 170, 121, 30, // 13480: decode to PSSUBU_W using decoder 30
7783 // 13480: }
7784 2, 7, // 13484: case 0x2: {
7785 OPC_CheckPredicate, 44, // 13486: check predicate 44
7786 OPC_Decode, 157, 131, 1, 30, // 13488: decode to ZIP16P using decoder 30
7787 // 13488: }
7788 3, 6, // 13493: case 0x3: {
7789 OPC_CheckPredicate, 44, // 13495: check predicate 44
7790 OPC_Decode, 239, 119, 30, // 13497: decode to PMULSU_W_H11 using decoder 30
7791 // 13497: }
7792 6, 0, // 13501: case 0x6: {
7793 OPC_CheckPredicate, 44, // 13503: check predicate 44
7794 OPC_Decode, 145, 119, 30, // 13505: decode to PMAX_W using decoder 30
7795 // 13505: }
7796 // 13505: } // switch Inst[14:12]
7797 // 13505: }
7798 122, 28, // 13509: case 0x7a: {
7799 OPC_SwitchField, 12, 3, // 13511: switch Inst[14:12] {
7800 0, 6, // 13514: case 0x0: {
7801 OPC_CheckPredicate, 39, // 13516: check predicate 39
7802 OPC_Decode, 165, 121, 30, // 13518: decode to PSSUBU_B using decoder 30
7803 // 13518: }
7804 2, 7, // 13522: case 0x2: {
7805 OPC_CheckPredicate, 44, // 13524: check predicate 44
7806 OPC_Decode, 158, 131, 1, 30, // 13526: decode to ZIP8HP using decoder 30
7807 // 13526: }
7808 6, 0, // 13531: case 0x6: {
7809 OPC_CheckPredicate, 39, // 13533: check predicate 39
7810 OPC_Decode, 140, 119, 30, // 13535: decode to PMAX_B using decoder 30
7811 // 13535: }
7812 // 13535: } // switch Inst[14:12]
7813 // 13535: }
7814 123, 20, // 13539: case 0x7b: {
7815 OPC_SwitchField, 12, 3, // 13541: switch Inst[14:12] {
7816 2, 7, // 13544: case 0x2: {
7817 OPC_CheckPredicate, 44, // 13546: check predicate 44
7818 OPC_Decode, 156, 131, 1, 30, // 13548: decode to ZIP16HP using decoder 30
7819 // 13548: }
7820 3, 0, // 13553: case 0x3: {
7821 OPC_CheckPredicate, 44, // 13555: check predicate 44
7822 OPC_Decode, 185, 117, 30, // 13557: decode to MULSU_W11 using decoder 30
7823 // 13557: }
7824 // 13557: } // switch Inst[14:12]
7825 // 13557: }
7826 124, 35, // 13561: case 0x7c: {
7827 OPC_SwitchField, 12, 3, // 13563: switch Inst[14:12] {
7828 0, 6, // 13566: case 0x0: {
7829 OPC_CheckPredicate, 39, // 13568: check predicate 39
7830 OPC_Decode, 185, 118, 30, // 13570: decode to PASUBU_H using decoder 30
7831 // 13570: }
7832 5, 6, // 13574: case 0x5: {
7833 OPC_CheckPredicate, 44, // 13576: check predicate 44
7834 OPC_Decode, 183, 119, 58, // 13578: decode to PMQACC_W_H01 using decoder 58
7835 // 13578: }
7836 6, 6, // 13582: case 0x6: {
7837 OPC_CheckPredicate, 39, // 13584: check predicate 39
7838 OPC_Decode, 138, 119, 30, // 13586: decode to PMAXU_H using decoder 30
7839 // 13586: }
7840 7, 0, // 13590: case 0x7: {
7841 OPC_CheckPredicate, 44, // 13592: check predicate 44
7842 OPC_Decode, 184, 119, 58, // 13594: decode to PMQACC_W_H11 using decoder 58
7843 // 13594: }
7844 // 13594: } // switch Inst[14:12]
7845 // 13594: }
7846 125, 43, // 13598: case 0x7d: {
7847 OPC_SwitchField, 12, 3, // 13600: switch Inst[14:12] {
7848 0, 6, // 13603: case 0x0: {
7849 OPC_CheckPredicate, 44, // 13605: check predicate 44
7850 OPC_Decode, 186, 118, 30, // 13607: decode to PASUBU_W using decoder 30
7851 // 13607: }
7852 3, 6, // 13611: case 0x3: {
7853 OPC_CheckPredicate, 44, // 13613: check predicate 44
7854 OPC_Decode, 255, 118, 58, // 13615: decode to PMACCSU_W_H11 using decoder 58
7855 // 13615: }
7856 5, 6, // 13619: case 0x5: {
7857 OPC_CheckPredicate, 44, // 13621: check predicate 44
7858 OPC_Decode, 155, 117, 58, // 13623: decode to MQACC_W01 using decoder 58
7859 // 13623: }
7860 6, 6, // 13627: case 0x6: {
7861 OPC_CheckPredicate, 44, // 13629: check predicate 44
7862 OPC_Decode, 139, 119, 30, // 13631: decode to PMAXU_W using decoder 30
7863 // 13631: }
7864 7, 0, // 13635: case 0x7: {
7865 OPC_CheckPredicate, 44, // 13637: check predicate 44
7866 OPC_Decode, 156, 117, 58, // 13639: decode to MQACC_W11 using decoder 58
7867 // 13639: }
7868 // 13639: } // switch Inst[14:12]
7869 // 13639: }
7870 126, 35, // 13643: case 0x7e: {
7871 OPC_SwitchField, 12, 3, // 13645: switch Inst[14:12] {
7872 0, 6, // 13648: case 0x0: {
7873 OPC_CheckPredicate, 39, // 13650: check predicate 39
7874 OPC_Decode, 181, 118, 30, // 13652: decode to PASUBU_B using decoder 30
7875 // 13652: }
7876 5, 6, // 13656: case 0x5: {
7877 OPC_CheckPredicate, 44, // 13658: check predicate 44
7878 OPC_Decode, 190, 119, 58, // 13660: decode to PMQRACC_W_H01 using decoder 58
7879 // 13660: }
7880 6, 6, // 13664: case 0x6: {
7881 OPC_CheckPredicate, 39, // 13666: check predicate 39
7882 OPC_Decode, 134, 119, 30, // 13668: decode to PMAXU_B using decoder 30
7883 // 13668: }
7884 7, 0, // 13672: case 0x7: {
7885 OPC_CheckPredicate, 44, // 13674: check predicate 44
7886 OPC_Decode, 191, 119, 58, // 13676: decode to PMQRACC_W_H11 using decoder 58
7887 // 13676: }
7888 // 13676: } // switch Inst[14:12]
7889 // 13676: }
7890 127, 0, // 13680: case 0x7f: {
7891 OPC_SwitchField, 12, 3, // 13682: switch Inst[14:12] {
7892 3, 6, // 13685: case 0x3: {
7893 OPC_CheckPredicate, 44, // 13687: check predicate 44
7894 OPC_Decode, 201, 116, 58, // 13689: decode to MACCSU_W11 using decoder 58
7895 // 13689: }
7896 5, 6, // 13693: case 0x5: {
7897 OPC_CheckPredicate, 44, // 13695: check predicate 44
7898 OPC_Decode, 161, 117, 58, // 13697: decode to MQRACC_W01 using decoder 58
7899 // 13697: }
7900 7, 0, // 13701: case 0x7: {
7901 OPC_CheckPredicate, 44, // 13703: check predicate 44
7902 OPC_Decode, 162, 117, 58, // 13705: decode to MQRACC_W11 using decoder 58
7903 // 13705: }
7904 // 13705: } // switch Inst[14:12]
7905 // 13705: }
7906 // 13705: } // switch Inst[31:25]
7907 // 13705: }
7908 67, 35, // 13709: case 0x43: {
7909 OPC_SwitchField, 25, 2, // 13711: switch Inst[26:25] {
7910 0, 6, // 13714: case 0x0: {
7911 OPC_CheckPredicate, 23, // 13716: check predicate 23
7912 OPC_Decode, 132, 115, 59, // 13718: decode to FMADD_S using decoder 59
7913 // 13718: }
7914 1, 6, // 13722: case 0x1: {
7915 OPC_CheckPredicate, 24, // 13724: check predicate 24
7916 OPC_Decode, 254, 114, 60, // 13726: decode to FMADD_D using decoder 60
7917 // 13726: }
7918 2, 6, // 13730: case 0x2: {
7919 OPC_CheckPredicate, 77, // 13732: check predicate 77
7920 OPC_Decode, 129, 115, 61, // 13734: decode to FMADD_H using decoder 61
7921 // 13734: }
7922 3, 0, // 13738: case 0x3: {
7923 OPC_CheckPredicate, 25, // 13740: check predicate 25
7924 OPC_Decode, 131, 115, 62, // 13742: decode to FMADD_Q using decoder 62
7925 // 13742: }
7926 // 13742: } // switch Inst[26:25]
7927 // 13742: }
7928 71, 35, // 13746: case 0x47: {
7929 OPC_SwitchField, 25, 2, // 13748: switch Inst[26:25] {
7930 0, 6, // 13751: case 0x0: {
7931 OPC_CheckPredicate, 23, // 13753: check predicate 23
7932 OPC_Decode, 164, 115, 59, // 13755: decode to FMSUB_S using decoder 59
7933 // 13755: }
7934 1, 6, // 13759: case 0x1: {
7935 OPC_CheckPredicate, 24, // 13761: check predicate 24
7936 OPC_Decode, 158, 115, 60, // 13763: decode to FMSUB_D using decoder 60
7937 // 13763: }
7938 2, 6, // 13767: case 0x2: {
7939 OPC_CheckPredicate, 77, // 13769: check predicate 77
7940 OPC_Decode, 161, 115, 61, // 13771: decode to FMSUB_H using decoder 61
7941 // 13771: }
7942 3, 0, // 13775: case 0x3: {
7943 OPC_CheckPredicate, 25, // 13777: check predicate 25
7944 OPC_Decode, 163, 115, 62, // 13779: decode to FMSUB_Q using decoder 62
7945 // 13779: }
7946 // 13779: } // switch Inst[26:25]
7947 // 13779: }
7948 75, 35, // 13783: case 0x4b: {
7949 OPC_SwitchField, 25, 2, // 13785: switch Inst[26:25] {
7950 0, 6, // 13788: case 0x0: {
7951 OPC_CheckPredicate, 23, // 13790: check predicate 23
7952 OPC_Decode, 199, 115, 59, // 13792: decode to FNMSUB_S using decoder 59
7953 // 13792: }
7954 1, 6, // 13796: case 0x1: {
7955 OPC_CheckPredicate, 24, // 13798: check predicate 24
7956 OPC_Decode, 193, 115, 60, // 13800: decode to FNMSUB_D using decoder 60
7957 // 13800: }
7958 2, 6, // 13804: case 0x2: {
7959 OPC_CheckPredicate, 77, // 13806: check predicate 77
7960 OPC_Decode, 196, 115, 61, // 13808: decode to FNMSUB_H using decoder 61
7961 // 13808: }
7962 3, 0, // 13812: case 0x3: {
7963 OPC_CheckPredicate, 25, // 13814: check predicate 25
7964 OPC_Decode, 198, 115, 62, // 13816: decode to FNMSUB_Q using decoder 62
7965 // 13816: }
7966 // 13816: } // switch Inst[26:25]
7967 // 13816: }
7968 79, 35, // 13820: case 0x4f: {
7969 OPC_SwitchField, 25, 2, // 13822: switch Inst[26:25] {
7970 0, 6, // 13825: case 0x0: {
7971 OPC_CheckPredicate, 23, // 13827: check predicate 23
7972 OPC_Decode, 191, 115, 59, // 13829: decode to FNMADD_S using decoder 59
7973 // 13829: }
7974 1, 6, // 13833: case 0x1: {
7975 OPC_CheckPredicate, 24, // 13835: check predicate 24
7976 OPC_Decode, 185, 115, 60, // 13837: decode to FNMADD_D using decoder 60
7977 // 13837: }
7978 2, 6, // 13841: case 0x2: {
7979 OPC_CheckPredicate, 77, // 13843: check predicate 77
7980 OPC_Decode, 188, 115, 61, // 13845: decode to FNMADD_H using decoder 61
7981 // 13845: }
7982 3, 0, // 13849: case 0x3: {
7983 OPC_CheckPredicate, 25, // 13851: check predicate 25
7984 OPC_Decode, 190, 115, 62, // 13853: decode to FNMADD_Q using decoder 62
7985 // 13853: }
7986 // 13853: } // switch Inst[26:25]
7987 // 13853: }
7988 83, 211, 10, // 13857: case 0x53: {
7989 OPC_SwitchField, 25, 7, // 13860: switch Inst[31:25] {
7990 0, 6, // 13863: case 0x0: {
7991 OPC_CheckPredicate, 23, // 13865: check predicate 23
7992 OPC_Decode, 238, 113, 63, // 13867: decode to FADD_S using decoder 63
7993 // 13867: }
7994 1, 6, // 13871: case 0x1: {
7995 OPC_CheckPredicate, 24, // 13873: check predicate 24
7996 OPC_Decode, 232, 113, 64, // 13875: decode to FADD_D using decoder 64
7997 // 13875: }
7998 2, 6, // 13879: case 0x2: {
7999 OPC_CheckPredicate, 77, // 13881: check predicate 77
8000 OPC_Decode, 235, 113, 65, // 13883: decode to FADD_H using decoder 65
8001 // 13883: }
8002 3, 6, // 13887: case 0x3: {
8003 OPC_CheckPredicate, 25, // 13889: check predicate 25
8004 OPC_Decode, 237, 113, 66, // 13891: decode to FADD_Q using decoder 66
8005 // 13891: }
8006 4, 6, // 13895: case 0x4: {
8007 OPC_CheckPredicate, 23, // 13897: check predicate 23
8008 OPC_Decode, 250, 115, 63, // 13899: decode to FSUB_S using decoder 63
8009 // 13899: }
8010 5, 6, // 13903: case 0x5: {
8011 OPC_CheckPredicate, 24, // 13905: check predicate 24
8012 OPC_Decode, 244, 115, 64, // 13907: decode to FSUB_D using decoder 64
8013 // 13907: }
8014 6, 6, // 13911: case 0x6: {
8015 OPC_CheckPredicate, 77, // 13913: check predicate 77
8016 OPC_Decode, 247, 115, 65, // 13915: decode to FSUB_H using decoder 65
8017 // 13915: }
8018 7, 6, // 13919: case 0x7: {
8019 OPC_CheckPredicate, 25, // 13921: check predicate 25
8020 OPC_Decode, 249, 115, 66, // 13923: decode to FSUB_Q using decoder 66
8021 // 13923: }
8022 8, 6, // 13927: case 0x8: {
8023 OPC_CheckPredicate, 23, // 13929: check predicate 23
8024 OPC_Decode, 172, 115, 63, // 13931: decode to FMUL_S using decoder 63
8025 // 13931: }
8026 9, 6, // 13935: case 0x9: {
8027 OPC_CheckPredicate, 24, // 13937: check predicate 24
8028 OPC_Decode, 166, 115, 64, // 13939: decode to FMUL_D using decoder 64
8029 // 13939: }
8030 10, 6, // 13943: case 0xa: {
8031 OPC_CheckPredicate, 77, // 13945: check predicate 77
8032 OPC_Decode, 169, 115, 65, // 13947: decode to FMUL_H using decoder 65
8033 // 13947: }
8034 11, 6, // 13951: case 0xb: {
8035 OPC_CheckPredicate, 25, // 13953: check predicate 25
8036 OPC_Decode, 171, 115, 66, // 13955: decode to FMUL_Q using decoder 66
8037 // 13955: }
8038 12, 6, // 13959: case 0xc: {
8039 OPC_CheckPredicate, 23, // 13961: check predicate 23
8040 OPC_Decode, 209, 114, 63, // 13963: decode to FDIV_S using decoder 63
8041 // 13963: }
8042 13, 6, // 13967: case 0xd: {
8043 OPC_CheckPredicate, 24, // 13969: check predicate 24
8044 OPC_Decode, 203, 114, 64, // 13971: decode to FDIV_D using decoder 64
8045 // 13971: }
8046 14, 6, // 13975: case 0xe: {
8047 OPC_CheckPredicate, 77, // 13977: check predicate 77
8048 OPC_Decode, 206, 114, 65, // 13979: decode to FDIV_H using decoder 65
8049 // 13979: }
8050 15, 6, // 13983: case 0xf: {
8051 OPC_CheckPredicate, 25, // 13985: check predicate 25
8052 OPC_Decode, 208, 114, 66, // 13987: decode to FDIV_Q using decoder 66
8053 // 13987: }
8054 16, 27, // 13991: case 0x10: {
8055 OPC_SwitchField, 12, 3, // 13993: switch Inst[14:12] {
8056 0, 6, // 13996: case 0x0: {
8057 OPC_CheckPredicate, 23, // 13998: check predicate 23
8058 OPC_Decode, 232, 115, 67, // 14000: decode to FSGNJ_S using decoder 67
8059 // 14000: }
8060 1, 6, // 14004: case 0x1: {
8061 OPC_CheckPredicate, 23, // 14006: check predicate 23
8062 OPC_Decode, 216, 115, 67, // 14008: decode to FSGNJN_S using decoder 67
8063 // 14008: }
8064 2, 0, // 14012: case 0x2: {
8065 OPC_CheckPredicate, 23, // 14014: check predicate 23
8066 OPC_Decode, 224, 115, 67, // 14016: decode to FSGNJX_S using decoder 67
8067 // 14016: }
8068 // 14016: } // switch Inst[14:12]
8069 // 14016: }
8070 17, 27, // 14020: case 0x11: {
8071 OPC_SwitchField, 12, 3, // 14022: switch Inst[14:12] {
8072 0, 6, // 14025: case 0x0: {
8073 OPC_CheckPredicate, 24, // 14027: check predicate 24
8074 OPC_Decode, 226, 115, 68, // 14029: decode to FSGNJ_D using decoder 68
8075 // 14029: }
8076 1, 6, // 14033: case 0x1: {
8077 OPC_CheckPredicate, 24, // 14035: check predicate 24
8078 OPC_Decode, 210, 115, 68, // 14037: decode to FSGNJN_D using decoder 68
8079 // 14037: }
8080 2, 0, // 14041: case 0x2: {
8081 OPC_CheckPredicate, 24, // 14043: check predicate 24
8082 OPC_Decode, 218, 115, 68, // 14045: decode to FSGNJX_D using decoder 68
8083 // 14045: }
8084 // 14045: } // switch Inst[14:12]
8085 // 14045: }
8086 18, 27, // 14049: case 0x12: {
8087 OPC_SwitchField, 12, 3, // 14051: switch Inst[14:12] {
8088 0, 6, // 14054: case 0x0: {
8089 OPC_CheckPredicate, 77, // 14056: check predicate 77
8090 OPC_Decode, 229, 115, 69, // 14058: decode to FSGNJ_H using decoder 69
8091 // 14058: }
8092 1, 6, // 14062: case 0x1: {
8093 OPC_CheckPredicate, 77, // 14064: check predicate 77
8094 OPC_Decode, 213, 115, 69, // 14066: decode to FSGNJN_H using decoder 69
8095 // 14066: }
8096 2, 0, // 14070: case 0x2: {
8097 OPC_CheckPredicate, 77, // 14072: check predicate 77
8098 OPC_Decode, 221, 115, 69, // 14074: decode to FSGNJX_H using decoder 69
8099 // 14074: }
8100 // 14074: } // switch Inst[14:12]
8101 // 14074: }
8102 19, 27, // 14078: case 0x13: {
8103 OPC_SwitchField, 12, 3, // 14080: switch Inst[14:12] {
8104 0, 6, // 14083: case 0x0: {
8105 OPC_CheckPredicate, 25, // 14085: check predicate 25
8106 OPC_Decode, 231, 115, 70, // 14087: decode to FSGNJ_Q using decoder 70
8107 // 14087: }
8108 1, 6, // 14091: case 0x1: {
8109 OPC_CheckPredicate, 25, // 14093: check predicate 25
8110 OPC_Decode, 215, 115, 70, // 14095: decode to FSGNJN_Q using decoder 70
8111 // 14095: }
8112 2, 0, // 14099: case 0x2: {
8113 OPC_CheckPredicate, 25, // 14101: check predicate 25
8114 OPC_Decode, 223, 115, 70, // 14103: decode to FSGNJX_Q using decoder 70
8115 // 14103: }
8116 // 14103: } // switch Inst[14:12]
8117 // 14103: }
8118 20, 35, // 14107: case 0x14: {
8119 OPC_SwitchField, 12, 3, // 14109: switch Inst[14:12] {
8120 0, 6, // 14112: case 0x0: {
8121 OPC_CheckPredicate, 23, // 14114: check predicate 23
8122 OPC_Decode, 156, 115, 67, // 14116: decode to FMIN_S using decoder 67
8123 // 14116: }
8124 1, 6, // 14120: case 0x1: {
8125 OPC_CheckPredicate, 23, // 14122: check predicate 23
8126 OPC_Decode, 144, 115, 67, // 14124: decode to FMAX_S using decoder 67
8127 // 14124: }
8128 2, 6, // 14128: case 0x2: {
8129 OPC_CheckPredicate, 78, // 14130: check predicate 78
8130 OPC_Decode, 149, 115, 67, // 14132: decode to FMINM_S using decoder 67
8131 // 14132: }
8132 3, 0, // 14136: case 0x3: {
8133 OPC_CheckPredicate, 78, // 14138: check predicate 78
8134 OPC_Decode, 137, 115, 67, // 14140: decode to FMAXM_S using decoder 67
8135 // 14140: }
8136 // 14140: } // switch Inst[14:12]
8137 // 14140: }
8138 21, 35, // 14144: case 0x15: {
8139 OPC_SwitchField, 12, 3, // 14146: switch Inst[14:12] {
8140 0, 6, // 14149: case 0x0: {
8141 OPC_CheckPredicate, 24, // 14151: check predicate 24
8142 OPC_Decode, 150, 115, 68, // 14153: decode to FMIN_D using decoder 68
8143 // 14153: }
8144 1, 6, // 14157: case 0x1: {
8145 OPC_CheckPredicate, 24, // 14159: check predicate 24
8146 OPC_Decode, 138, 115, 68, // 14161: decode to FMAX_D using decoder 68
8147 // 14161: }
8148 2, 6, // 14165: case 0x2: {
8149 OPC_CheckPredicate, 79, // 14167: check predicate 79
8150 OPC_Decode, 146, 115, 68, // 14169: decode to FMINM_D using decoder 68
8151 // 14169: }
8152 3, 0, // 14173: case 0x3: {
8153 OPC_CheckPredicate, 79, // 14175: check predicate 79
8154 OPC_Decode, 134, 115, 68, // 14177: decode to FMAXM_D using decoder 68
8155 // 14177: }
8156 // 14177: } // switch Inst[14:12]
8157 // 14177: }
8158 22, 35, // 14181: case 0x16: {
8159 OPC_SwitchField, 12, 3, // 14183: switch Inst[14:12] {
8160 0, 6, // 14186: case 0x0: {
8161 OPC_CheckPredicate, 77, // 14188: check predicate 77
8162 OPC_Decode, 153, 115, 69, // 14190: decode to FMIN_H using decoder 69
8163 // 14190: }
8164 1, 6, // 14194: case 0x1: {
8165 OPC_CheckPredicate, 77, // 14196: check predicate 77
8166 OPC_Decode, 141, 115, 69, // 14198: decode to FMAX_H using decoder 69
8167 // 14198: }
8168 2, 6, // 14202: case 0x2: {
8169 OPC_CheckPredicate, 80, // 14204: check predicate 80
8170 OPC_Decode, 147, 115, 69, // 14206: decode to FMINM_H using decoder 69
8171 // 14206: }
8172 3, 0, // 14210: case 0x3: {
8173 OPC_CheckPredicate, 80, // 14212: check predicate 80
8174 OPC_Decode, 135, 115, 69, // 14214: decode to FMAXM_H using decoder 69
8175 // 14214: }
8176 // 14214: } // switch Inst[14:12]
8177 // 14214: }
8178 23, 35, // 14218: case 0x17: {
8179 OPC_SwitchField, 12, 3, // 14220: switch Inst[14:12] {
8180 0, 6, // 14223: case 0x0: {
8181 OPC_CheckPredicate, 25, // 14225: check predicate 25
8182 OPC_Decode, 155, 115, 70, // 14227: decode to FMIN_Q using decoder 70
8183 // 14227: }
8184 1, 6, // 14231: case 0x1: {
8185 OPC_CheckPredicate, 25, // 14233: check predicate 25
8186 OPC_Decode, 143, 115, 70, // 14235: decode to FMAX_Q using decoder 70
8187 // 14235: }
8188 2, 6, // 14239: case 0x2: {
8189 OPC_CheckPredicate, 81, // 14241: check predicate 81
8190 OPC_Decode, 148, 115, 70, // 14243: decode to FMINM_Q using decoder 70
8191 // 14243: }
8192 3, 0, // 14247: case 0x3: {
8193 OPC_CheckPredicate, 81, // 14249: check predicate 81
8194 OPC_Decode, 136, 115, 70, // 14251: decode to FMAXM_Q using decoder 70
8195 // 14251: }
8196 // 14251: } // switch Inst[14:12]
8197 // 14251: }
8198 32, 51, // 14255: case 0x20: {
8199 OPC_SwitchField, 20, 5, // 14257: switch Inst[24:20] {
8200 1, 6, // 14260: case 0x1: {
8201 OPC_CheckPredicate, 24, // 14262: check predicate 24
8202 OPC_Decode, 173, 114, 71, // 14264: decode to FCVT_S_D using decoder 71
8203 // 14264: }
8204 2, 6, // 14268: case 0x2: {
8205 OPC_CheckPredicate, 82, // 14270: check predicate 82
8206 OPC_Decode, 176, 114, 72, // 14272: decode to FCVT_S_H using decoder 72
8207 // 14272: }
8208 3, 6, // 14276: case 0x3: {
8209 OPC_CheckPredicate, 25, // 14278: check predicate 25
8210 OPC_Decode, 182, 114, 73, // 14280: decode to FCVT_S_Q using decoder 73
8211 // 14280: }
8212 4, 6, // 14284: case 0x4: {
8213 OPC_CheckPredicate, 78, // 14286: check predicate 78
8214 OPC_Decode, 208, 115, 74, // 14288: decode to FROUND_S using decoder 74
8215 // 14288: }
8216 5, 6, // 14292: case 0x5: {
8217 OPC_CheckPredicate, 78, // 14294: check predicate 78
8218 OPC_Decode, 204, 115, 74, // 14296: decode to FROUNDNX_S using decoder 74
8219 // 14296: }
8220 6, 0, // 14300: case 0x6: {
8221 OPC_CheckPredicate, 83, // 14302: check predicate 83
8222 OPC_Decode, 172, 114, 72, // 14304: decode to FCVT_S_BF16 using decoder 72
8223 // 14304: }
8224 // 14304: } // switch Inst[24:20]
8225 // 14304: }
8226 33, 43, // 14308: case 0x21: {
8227 OPC_SwitchField, 20, 5, // 14310: switch Inst[24:20] {
8228 0, 6, // 14313: case 0x0: {
8229 OPC_CheckPredicate, 24, // 14315: check predicate 24
8230 OPC_Decode, 130, 114, 75, // 14317: decode to FCVT_D_S using decoder 75
8231 // 14317: }
8232 2, 6, // 14321: case 0x2: {
8233 OPC_CheckPredicate, 84, // 14323: check predicate 84
8234 OPC_Decode, 250, 113, 76, // 14325: decode to FCVT_D_H using decoder 76
8235 // 14325: }
8236 3, 6, // 14329: case 0x3: {
8237 OPC_CheckPredicate, 25, // 14331: check predicate 25
8238 OPC_Decode, 129, 114, 77, // 14333: decode to FCVT_D_Q using decoder 77
8239 // 14333: }
8240 4, 6, // 14337: case 0x4: {
8241 OPC_CheckPredicate, 79, // 14339: check predicate 79
8242 OPC_Decode, 205, 115, 78, // 14341: decode to FROUND_D using decoder 78
8243 // 14341: }
8244 5, 0, // 14345: case 0x5: {
8245 OPC_CheckPredicate, 79, // 14347: check predicate 79
8246 OPC_Decode, 201, 115, 78, // 14349: decode to FROUNDNX_D using decoder 78
8247 // 14349: }
8248 // 14349: } // switch Inst[24:20]
8249 // 14349: }
8250 34, 43, // 14353: case 0x22: {
8251 OPC_SwitchField, 20, 5, // 14355: switch Inst[24:20] {
8252 0, 6, // 14358: case 0x0: {
8253 OPC_CheckPredicate, 82, // 14360: check predicate 82
8254 OPC_Decode, 146, 114, 79, // 14362: decode to FCVT_H_S using decoder 79
8255 // 14362: }
8256 1, 6, // 14366: case 0x1: {
8257 OPC_CheckPredicate, 84, // 14368: check predicate 84
8258 OPC_Decode, 139, 114, 80, // 14370: decode to FCVT_H_D using decoder 80
8259 // 14370: }
8260 4, 6, // 14374: case 0x4: {
8261 OPC_CheckPredicate, 80, // 14376: check predicate 80
8262 OPC_Decode, 206, 115, 81, // 14378: decode to FROUND_H using decoder 81
8263 // 14378: }
8264 5, 6, // 14382: case 0x5: {
8265 OPC_CheckPredicate, 80, // 14384: check predicate 80
8266 OPC_Decode, 202, 115, 81, // 14386: decode to FROUNDNX_H using decoder 81
8267 // 14386: }
8268 8, 0, // 14390: case 0x8: {
8269 OPC_CheckPredicate, 83, // 14392: check predicate 83
8270 OPC_Decode, 249, 113, 79, // 14394: decode to FCVT_BF16_S using decoder 79
8271 // 14394: }
8272 // 14394: } // switch Inst[24:20]
8273 // 14394: }
8274 35, 35, // 14398: case 0x23: {
8275 OPC_SwitchField, 20, 5, // 14400: switch Inst[24:20] {
8276 0, 6, // 14403: case 0x0: {
8277 OPC_CheckPredicate, 25, // 14405: check predicate 25
8278 OPC_Decode, 169, 114, 82, // 14407: decode to FCVT_Q_S using decoder 82
8279 // 14407: }
8280 1, 6, // 14411: case 0x1: {
8281 OPC_CheckPredicate, 25, // 14413: check predicate 25
8282 OPC_Decode, 166, 114, 83, // 14415: decode to FCVT_Q_D using decoder 83
8283 // 14415: }
8284 4, 6, // 14419: case 0x4: {
8285 OPC_CheckPredicate, 81, // 14421: check predicate 81
8286 OPC_Decode, 207, 115, 84, // 14423: decode to FROUND_Q using decoder 84
8287 // 14423: }
8288 5, 0, // 14427: case 0x5: {
8289 OPC_CheckPredicate, 81, // 14429: check predicate 81
8290 OPC_Decode, 203, 115, 84, // 14431: decode to FROUNDNX_Q using decoder 84
8291 // 14431: }
8292 // 14431: } // switch Inst[24:20]
8293 // 14431: }
8294 44, 10, // 14435: case 0x2c: {
8295 OPC_CheckPredicate, 23, // 14437: check predicate 23
8296 OPC_CheckField, 20, 5, 0, // 14439: check Inst[24:20] == 0x0
8297 OPC_Decode, 242, 115, 74, // 14443: decode to FSQRT_S using decoder 74
8298 // 14443: }
8299 45, 10, // 14447: case 0x2d: {
8300 OPC_CheckPredicate, 24, // 14449: check predicate 24
8301 OPC_CheckField, 20, 5, 0, // 14451: check Inst[24:20] == 0x0
8302 OPC_Decode, 236, 115, 78, // 14455: decode to FSQRT_D using decoder 78
8303 // 14455: }
8304 46, 10, // 14459: case 0x2e: {
8305 OPC_CheckPredicate, 77, // 14461: check predicate 77
8306 OPC_CheckField, 20, 5, 0, // 14463: check Inst[24:20] == 0x0
8307 OPC_Decode, 239, 115, 81, // 14467: decode to FSQRT_H using decoder 81
8308 // 14467: }
8309 47, 10, // 14471: case 0x2f: {
8310 OPC_CheckPredicate, 25, // 14473: check predicate 25
8311 OPC_CheckField, 20, 5, 0, // 14475: check Inst[24:20] == 0x0
8312 OPC_Decode, 241, 115, 84, // 14479: decode to FSQRT_Q using decoder 84
8313 // 14479: }
8314 80, 43, // 14483: case 0x50: {
8315 OPC_SwitchField, 12, 3, // 14485: switch Inst[14:12] {
8316 0, 6, // 14488: case 0x0: {
8317 OPC_CheckPredicate, 23, // 14490: check predicate 23
8318 OPC_Decode, 233, 114, 85, // 14492: decode to FLE_S using decoder 85
8319 // 14492: }
8320 1, 6, // 14496: case 0x1: {
8321 OPC_CheckPredicate, 23, // 14498: check predicate 23
8322 OPC_Decode, 251, 114, 85, // 14500: decode to FLT_S using decoder 85
8323 // 14500: }
8324 2, 6, // 14504: case 0x2: {
8325 OPC_CheckPredicate, 23, // 14506: check predicate 23
8326 OPC_Decode, 220, 114, 85, // 14508: decode to FEQ_S using decoder 85
8327 // 14508: }
8328 4, 6, // 14512: case 0x4: {
8329 OPC_CheckPredicate, 78, // 14514: check predicate 78
8330 OPC_Decode, 226, 114, 85, // 14516: decode to FLEQ_S using decoder 85
8331 // 14516: }
8332 5, 0, // 14520: case 0x5: {
8333 OPC_CheckPredicate, 78, // 14522: check predicate 78
8334 OPC_Decode, 244, 114, 85, // 14524: decode to FLTQ_S using decoder 85
8335 // 14524: }
8336 // 14524: } // switch Inst[14:12]
8337 // 14524: }
8338 81, 43, // 14528: case 0x51: {
8339 OPC_SwitchField, 12, 3, // 14530: switch Inst[14:12] {
8340 0, 6, // 14533: case 0x0: {
8341 OPC_CheckPredicate, 24, // 14535: check predicate 24
8342 OPC_Decode, 227, 114, 86, // 14537: decode to FLE_D using decoder 86
8343 // 14537: }
8344 1, 6, // 14541: case 0x1: {
8345 OPC_CheckPredicate, 24, // 14543: check predicate 24
8346 OPC_Decode, 245, 114, 86, // 14545: decode to FLT_D using decoder 86
8347 // 14545: }
8348 2, 6, // 14549: case 0x2: {
8349 OPC_CheckPredicate, 24, // 14551: check predicate 24
8350 OPC_Decode, 214, 114, 86, // 14553: decode to FEQ_D using decoder 86
8351 // 14553: }
8352 4, 6, // 14557: case 0x4: {
8353 OPC_CheckPredicate, 79, // 14559: check predicate 79
8354 OPC_Decode, 223, 114, 86, // 14561: decode to FLEQ_D using decoder 86
8355 // 14561: }
8356 5, 0, // 14565: case 0x5: {
8357 OPC_CheckPredicate, 79, // 14567: check predicate 79
8358 OPC_Decode, 241, 114, 86, // 14569: decode to FLTQ_D using decoder 86
8359 // 14569: }
8360 // 14569: } // switch Inst[14:12]
8361 // 14569: }
8362 82, 43, // 14573: case 0x52: {
8363 OPC_SwitchField, 12, 3, // 14575: switch Inst[14:12] {
8364 0, 6, // 14578: case 0x0: {
8365 OPC_CheckPredicate, 77, // 14580: check predicate 77
8366 OPC_Decode, 230, 114, 87, // 14582: decode to FLE_H using decoder 87
8367 // 14582: }
8368 1, 6, // 14586: case 0x1: {
8369 OPC_CheckPredicate, 77, // 14588: check predicate 77
8370 OPC_Decode, 248, 114, 87, // 14590: decode to FLT_H using decoder 87
8371 // 14590: }
8372 2, 6, // 14594: case 0x2: {
8373 OPC_CheckPredicate, 77, // 14596: check predicate 77
8374 OPC_Decode, 217, 114, 87, // 14598: decode to FEQ_H using decoder 87
8375 // 14598: }
8376 4, 6, // 14602: case 0x4: {
8377 OPC_CheckPredicate, 80, // 14604: check predicate 80
8378 OPC_Decode, 224, 114, 87, // 14606: decode to FLEQ_H using decoder 87
8379 // 14606: }
8380 5, 0, // 14610: case 0x5: {
8381 OPC_CheckPredicate, 80, // 14612: check predicate 80
8382 OPC_Decode, 242, 114, 87, // 14614: decode to FLTQ_H using decoder 87
8383 // 14614: }
8384 // 14614: } // switch Inst[14:12]
8385 // 14614: }
8386 83, 43, // 14618: case 0x53: {
8387 OPC_SwitchField, 12, 3, // 14620: switch Inst[14:12] {
8388 0, 6, // 14623: case 0x0: {
8389 OPC_CheckPredicate, 25, // 14625: check predicate 25
8390 OPC_Decode, 232, 114, 88, // 14627: decode to FLE_Q using decoder 88
8391 // 14627: }
8392 1, 6, // 14631: case 0x1: {
8393 OPC_CheckPredicate, 25, // 14633: check predicate 25
8394 OPC_Decode, 250, 114, 88, // 14635: decode to FLT_Q using decoder 88
8395 // 14635: }
8396 2, 6, // 14639: case 0x2: {
8397 OPC_CheckPredicate, 25, // 14641: check predicate 25
8398 OPC_Decode, 219, 114, 88, // 14643: decode to FEQ_Q using decoder 88
8399 // 14643: }
8400 4, 6, // 14647: case 0x4: {
8401 OPC_CheckPredicate, 81, // 14649: check predicate 81
8402 OPC_Decode, 225, 114, 88, // 14651: decode to FLEQ_Q using decoder 88
8403 // 14651: }
8404 5, 0, // 14655: case 0x5: {
8405 OPC_CheckPredicate, 81, // 14657: check predicate 81
8406 OPC_Decode, 243, 114, 88, // 14659: decode to FLTQ_Q using decoder 88
8407 // 14659: }
8408 // 14659: } // switch Inst[14:12]
8409 // 14659: }
8410 89, 10, // 14663: case 0x59: {
8411 OPC_CheckPredicate, 85, // 14665: check predicate 85
8412 OPC_CheckField, 12, 3, 0, // 14667: check Inst[14:12] == 0x0
8413 OPC_Decode, 176, 115, 89, // 14671: decode to FMVP_D_X using decoder 89
8414 // 14671: }
8415 91, 10, // 14675: case 0x5b: {
8416 OPC_CheckPredicate, 86, // 14677: check predicate 86
8417 OPC_CheckField, 12, 3, 0, // 14679: check Inst[14:12] == 0x0
8418 OPC_Decode, 177, 115, 90, // 14683: decode to FMVP_Q_X using decoder 90
8419 // 14683: }
8420 96, 35, // 14687: case 0x60: {
8421 OPC_SwitchField, 20, 5, // 14689: switch Inst[24:20] {
8422 0, 6, // 14692: case 0x0: {
8423 OPC_CheckPredicate, 23, // 14694: check predicate 23
8424 OPC_Decode, 201, 114, 91, // 14696: decode to FCVT_W_S using decoder 91
8425 // 14696: }
8426 1, 6, // 14700: case 0x1: {
8427 OPC_CheckPredicate, 23, // 14702: check predicate 23
8428 OPC_Decode, 193, 114, 91, // 14704: decode to FCVT_WU_S using decoder 91
8429 // 14704: }
8430 2, 6, // 14708: case 0x2: {
8431 OPC_CheckPredicate, 87, // 14710: check predicate 87
8432 OPC_Decode, 164, 114, 91, // 14712: decode to FCVT_L_S using decoder 91
8433 // 14712: }
8434 3, 0, // 14716: case 0x3: {
8435 OPC_CheckPredicate, 87, // 14718: check predicate 87
8436 OPC_Decode, 157, 114, 91, // 14720: decode to FCVT_LU_S using decoder 91
8437 // 14720: }
8438 // 14720: } // switch Inst[24:20]
8439 // 14720: }
8440 97, 47, // 14724: case 0x61: {
8441 OPC_SwitchField, 20, 5, // 14726: switch Inst[24:20] {
8442 0, 6, // 14729: case 0x0: {
8443 OPC_CheckPredicate, 24, // 14731: check predicate 24
8444 OPC_Decode, 195, 114, 92, // 14733: decode to FCVT_W_D using decoder 92
8445 // 14733: }
8446 1, 6, // 14737: case 0x1: {
8447 OPC_CheckPredicate, 24, // 14739: check predicate 24
8448 OPC_Decode, 187, 114, 92, // 14741: decode to FCVT_WU_D using decoder 92
8449 // 14741: }
8450 2, 6, // 14745: case 0x2: {
8451 OPC_CheckPredicate, 88, // 14747: check predicate 88
8452 OPC_Decode, 159, 114, 92, // 14749: decode to FCVT_L_D using decoder 92
8453 // 14749: }
8454 3, 6, // 14753: case 0x3: {
8455 OPC_CheckPredicate, 88, // 14755: check predicate 88
8456 OPC_Decode, 152, 114, 92, // 14757: decode to FCVT_LU_D using decoder 92
8457 // 14757: }
8458 8, 0, // 14761: case 0x8: {
8459 OPC_CheckPredicate, 79, // 14763: check predicate 79
8460 OPC_CheckField, 12, 3, 1, // 14765: check Inst[14:12] == 0x1
8461 OPC_Decode, 248, 113, 93, // 14769: decode to FCVTMOD_W_D using decoder 93
8462 // 14769: }
8463 // 14769: } // switch Inst[24:20]
8464 // 14769: }
8465 98, 35, // 14773: case 0x62: {
8466 OPC_SwitchField, 20, 5, // 14775: switch Inst[24:20] {
8467 0, 6, // 14778: case 0x0: {
8468 OPC_CheckPredicate, 77, // 14780: check predicate 77
8469 OPC_Decode, 198, 114, 94, // 14782: decode to FCVT_W_H using decoder 94
8470 // 14782: }
8471 1, 6, // 14786: case 0x1: {
8472 OPC_CheckPredicate, 77, // 14788: check predicate 77
8473 OPC_Decode, 190, 114, 94, // 14790: decode to FCVT_WU_H using decoder 94
8474 // 14790: }
8475 2, 6, // 14794: case 0x2: {
8476 OPC_CheckPredicate, 89, // 14796: check predicate 89
8477 OPC_Decode, 161, 114, 94, // 14798: decode to FCVT_L_H using decoder 94
8478 // 14798: }
8479 3, 0, // 14802: case 0x3: {
8480 OPC_CheckPredicate, 89, // 14804: check predicate 89
8481 OPC_Decode, 154, 114, 94, // 14806: decode to FCVT_LU_H using decoder 94
8482 // 14806: }
8483 // 14806: } // switch Inst[24:20]
8484 // 14806: }
8485 99, 35, // 14810: case 0x63: {
8486 OPC_SwitchField, 20, 5, // 14812: switch Inst[24:20] {
8487 0, 6, // 14815: case 0x0: {
8488 OPC_CheckPredicate, 25, // 14817: check predicate 25
8489 OPC_Decode, 200, 114, 95, // 14819: decode to FCVT_W_Q using decoder 95
8490 // 14819: }
8491 1, 6, // 14823: case 0x1: {
8492 OPC_CheckPredicate, 25, // 14825: check predicate 25
8493 OPC_Decode, 192, 114, 95, // 14827: decode to FCVT_WU_Q using decoder 95
8494 // 14827: }
8495 2, 6, // 14831: case 0x2: {
8496 OPC_CheckPredicate, 90, // 14833: check predicate 90
8497 OPC_Decode, 163, 114, 95, // 14835: decode to FCVT_L_Q using decoder 95
8498 // 14835: }
8499 3, 0, // 14839: case 0x3: {
8500 OPC_CheckPredicate, 90, // 14841: check predicate 90
8501 OPC_Decode, 156, 114, 95, // 14843: decode to FCVT_LU_Q using decoder 95
8502 // 14843: }
8503 // 14843: } // switch Inst[24:20]
8504 // 14843: }
8505 104, 35, // 14847: case 0x68: {
8506 OPC_SwitchField, 20, 5, // 14849: switch Inst[24:20] {
8507 0, 6, // 14852: case 0x0: {
8508 OPC_CheckPredicate, 23, // 14854: check predicate 23
8509 OPC_Decode, 183, 114, 96, // 14856: decode to FCVT_S_W using decoder 96
8510 // 14856: }
8511 1, 6, // 14860: case 0x1: {
8512 OPC_CheckPredicate, 23, // 14862: check predicate 23
8513 OPC_Decode, 184, 114, 96, // 14864: decode to FCVT_S_WU using decoder 96
8514 // 14864: }
8515 2, 6, // 14868: case 0x2: {
8516 OPC_CheckPredicate, 87, // 14870: check predicate 87
8517 OPC_Decode, 178, 114, 96, // 14872: decode to FCVT_S_L using decoder 96
8518 // 14872: }
8519 3, 0, // 14876: case 0x3: {
8520 OPC_CheckPredicate, 87, // 14878: check predicate 87
8521 OPC_Decode, 179, 114, 96, // 14880: decode to FCVT_S_LU using decoder 96
8522 // 14880: }
8523 // 14880: } // switch Inst[24:20]
8524 // 14880: }
8525 105, 35, // 14884: case 0x69: {
8526 OPC_SwitchField, 20, 5, // 14886: switch Inst[24:20] {
8527 0, 6, // 14889: case 0x0: {
8528 OPC_CheckPredicate, 24, // 14891: check predicate 24
8529 OPC_Decode, 133, 114, 97, // 14893: decode to FCVT_D_W using decoder 97
8530 // 14893: }
8531 1, 6, // 14897: case 0x1: {
8532 OPC_CheckPredicate, 24, // 14899: check predicate 24
8533 OPC_Decode, 134, 114, 97, // 14901: decode to FCVT_D_WU using decoder 97
8534 // 14901: }
8535 2, 6, // 14905: case 0x2: {
8536 OPC_CheckPredicate, 88, // 14907: check predicate 88
8537 OPC_Decode, 253, 113, 97, // 14909: decode to FCVT_D_L using decoder 97
8538 // 14909: }
8539 3, 0, // 14913: case 0x3: {
8540 OPC_CheckPredicate, 88, // 14915: check predicate 88
8541 OPC_Decode, 254, 113, 97, // 14917: decode to FCVT_D_LU using decoder 97
8542 // 14917: }
8543 // 14917: } // switch Inst[24:20]
8544 // 14917: }
8545 106, 35, // 14921: case 0x6a: {
8546 OPC_SwitchField, 20, 5, // 14923: switch Inst[24:20] {
8547 0, 6, // 14926: case 0x0: {
8548 OPC_CheckPredicate, 77, // 14928: check predicate 77
8549 OPC_Decode, 148, 114, 98, // 14930: decode to FCVT_H_W using decoder 98
8550 // 14930: }
8551 1, 6, // 14934: case 0x1: {
8552 OPC_CheckPredicate, 77, // 14936: check predicate 77
8553 OPC_Decode, 149, 114, 98, // 14938: decode to FCVT_H_WU using decoder 98
8554 // 14938: }
8555 2, 6, // 14942: case 0x2: {
8556 OPC_CheckPredicate, 89, // 14944: check predicate 89
8557 OPC_Decode, 142, 114, 98, // 14946: decode to FCVT_H_L using decoder 98
8558 // 14946: }
8559 3, 0, // 14950: case 0x3: {
8560 OPC_CheckPredicate, 89, // 14952: check predicate 89
8561 OPC_Decode, 143, 114, 98, // 14954: decode to FCVT_H_LU using decoder 98
8562 // 14954: }
8563 // 14954: } // switch Inst[24:20]
8564 // 14954: }
8565 107, 35, // 14958: case 0x6b: {
8566 OPC_SwitchField, 20, 5, // 14960: switch Inst[24:20] {
8567 0, 6, // 14963: case 0x0: {
8568 OPC_CheckPredicate, 25, // 14965: check predicate 25
8569 OPC_Decode, 170, 114, 99, // 14967: decode to FCVT_Q_W using decoder 99
8570 // 14967: }
8571 1, 6, // 14971: case 0x1: {
8572 OPC_CheckPredicate, 25, // 14973: check predicate 25
8573 OPC_Decode, 171, 114, 99, // 14975: decode to FCVT_Q_WU using decoder 99
8574 // 14975: }
8575 2, 6, // 14979: case 0x2: {
8576 OPC_CheckPredicate, 90, // 14981: check predicate 90
8577 OPC_Decode, 167, 114, 99, // 14983: decode to FCVT_Q_L using decoder 99
8578 // 14983: }
8579 3, 0, // 14987: case 0x3: {
8580 OPC_CheckPredicate, 90, // 14989: check predicate 90
8581 OPC_Decode, 168, 114, 99, // 14991: decode to FCVT_Q_LU using decoder 99
8582 // 14991: }
8583 // 14991: } // switch Inst[24:20]
8584 // 14991: }
8585 112, 27, // 14995: case 0x70: {
8586 OPC_SwitchField, 12, 3, // 14997: switch Inst[14:12] {
8587 0, 10, // 15000: case 0x0: {
8588 OPC_CheckPredicate, 23, // 15002: check predicate 23
8589 OPC_CheckField, 20, 5, 0, // 15004: check Inst[24:20] == 0x0
8590 OPC_Decode, 183, 115, 100, // 15008: decode to FMV_X_W using decoder 100
8591 // 15008: }
8592 1, 0, // 15012: case 0x1: {
8593 OPC_CheckPredicate, 23, // 15014: check predicate 23
8594 OPC_CheckField, 20, 5, 0, // 15016: check Inst[24:20] == 0x0
8595 OPC_Decode, 246, 113, 100, // 15020: decode to FCLASS_S using decoder 100
8596 // 15020: }
8597 // 15020: } // switch Inst[14:12]
8598 // 15020: }
8599 113, 36, // 15024: case 0x71: {
8600 OPC_SwitchField, 12, 3, // 15026: switch Inst[14:12] {
8601 0, 19, // 15029: case 0x0: {
8602 OPC_SwitchField, 20, 5, // 15031: switch Inst[24:20] {
8603 0, 6, // 15034: case 0x0: {
8604 OPC_CheckPredicate, 88, // 15036: check predicate 88
8605 OPC_Decode, 181, 115, 101, // 15038: decode to FMV_X_D using decoder 101
8606 // 15038: }
8607 1, 0, // 15042: case 0x1: {
8608 OPC_CheckPredicate, 85, // 15044: check predicate 85
8609 OPC_Decode, 174, 115, 101, // 15046: decode to FMVH_X_D using decoder 101
8610 // 15046: }
8611 // 15046: } // switch Inst[24:20]
8612 // 15046: }
8613 1, 0, // 15050: case 0x1: {
8614 OPC_CheckPredicate, 24, // 15052: check predicate 24
8615 OPC_CheckField, 20, 5, 0, // 15054: check Inst[24:20] == 0x0
8616 OPC_Decode, 240, 113, 101, // 15058: decode to FCLASS_D using decoder 101
8617 // 15058: }
8618 // 15058: } // switch Inst[14:12]
8619 // 15058: }
8620 114, 27, // 15062: case 0x72: {
8621 OPC_SwitchField, 12, 3, // 15064: switch Inst[14:12] {
8622 0, 10, // 15067: case 0x0: {
8623 OPC_CheckPredicate, 22, // 15069: check predicate 22
8624 OPC_CheckField, 20, 5, 0, // 15071: check Inst[24:20] == 0x0
8625 OPC_Decode, 182, 115, 102, // 15075: decode to FMV_X_H using decoder 102
8626 // 15075: }
8627 1, 0, // 15079: case 0x1: {
8628 OPC_CheckPredicate, 77, // 15081: check predicate 77
8629 OPC_CheckField, 20, 5, 0, // 15083: check Inst[24:20] == 0x0
8630 OPC_Decode, 243, 113, 102, // 15087: decode to FCLASS_H using decoder 102
8631 // 15087: }
8632 // 15087: } // switch Inst[14:12]
8633 // 15087: }
8634 115, 27, // 15091: case 0x73: {
8635 OPC_SwitchField, 12, 3, // 15093: switch Inst[14:12] {
8636 0, 10, // 15096: case 0x0: {
8637 OPC_CheckPredicate, 86, // 15098: check predicate 86
8638 OPC_CheckField, 20, 5, 1, // 15100: check Inst[24:20] == 0x1
8639 OPC_Decode, 175, 115, 103, // 15104: decode to FMVH_X_Q using decoder 103
8640 // 15104: }
8641 1, 0, // 15108: case 0x1: {
8642 OPC_CheckPredicate, 25, // 15110: check predicate 25
8643 OPC_CheckField, 20, 5, 0, // 15112: check Inst[24:20] == 0x0
8644 OPC_Decode, 245, 113, 103, // 15116: decode to FCLASS_Q using decoder 103
8645 // 15116: }
8646 // 15116: } // switch Inst[14:12]
8647 // 15116: }
8648 120, 27, // 15120: case 0x78: {
8649 OPC_SwitchField, 20, 5, // 15122: switch Inst[24:20] {
8650 0, 10, // 15125: case 0x0: {
8651 OPC_CheckPredicate, 23, // 15127: check predicate 23
8652 OPC_CheckField, 12, 3, 0, // 15129: check Inst[14:12] == 0x0
8653 OPC_Decode, 180, 115, 104, // 15133: decode to FMV_W_X using decoder 104
8654 // 15133: }
8655 1, 0, // 15137: case 0x1: {
8656 OPC_CheckPredicate, 78, // 15139: check predicate 78
8657 OPC_CheckField, 12, 3, 0, // 15141: check Inst[14:12] == 0x0
8658 OPC_Decode, 239, 114, 105, // 15145: decode to FLI_S using decoder 105
8659 // 15145: }
8660 // 15145: } // switch Inst[24:20]
8661 // 15145: }
8662 121, 27, // 15149: case 0x79: {
8663 OPC_SwitchField, 20, 5, // 15151: switch Inst[24:20] {
8664 0, 10, // 15154: case 0x0: {
8665 OPC_CheckPredicate, 88, // 15156: check predicate 88
8666 OPC_CheckField, 12, 3, 0, // 15158: check Inst[14:12] == 0x0
8667 OPC_Decode, 178, 115, 106, // 15162: decode to FMV_D_X using decoder 106
8668 // 15162: }
8669 1, 0, // 15166: case 0x1: {
8670 OPC_CheckPredicate, 79, // 15168: check predicate 79
8671 OPC_CheckField, 12, 3, 0, // 15170: check Inst[14:12] == 0x0
8672 OPC_Decode, 236, 114, 107, // 15174: decode to FLI_D using decoder 107
8673 // 15174: }
8674 // 15174: } // switch Inst[24:20]
8675 // 15174: }
8676 122, 27, // 15178: case 0x7a: {
8677 OPC_SwitchField, 20, 5, // 15180: switch Inst[24:20] {
8678 0, 10, // 15183: case 0x0: {
8679 OPC_CheckPredicate, 22, // 15185: check predicate 22
8680 OPC_CheckField, 12, 3, 0, // 15187: check Inst[14:12] == 0x0
8681 OPC_Decode, 179, 115, 108, // 15191: decode to FMV_H_X using decoder 108
8682 // 15191: }
8683 1, 0, // 15195: case 0x1: {
8684 OPC_CheckPredicate, 91, // 15197: check predicate 91
8685 OPC_CheckField, 12, 3, 0, // 15199: check Inst[14:12] == 0x0
8686 OPC_Decode, 237, 114, 109, // 15203: decode to FLI_H using decoder 109
8687 // 15203: }
8688 // 15203: } // switch Inst[24:20]
8689 // 15203: }
8690 123, 0, // 15207: case 0x7b: {
8691 OPC_CheckPredicate, 81, // 15209: check predicate 81
8692 OPC_CheckField, 20, 5, 1, // 15211: check Inst[24:20] == 0x1
8693 OPC_CheckField, 12, 3, 0, // 15215: check Inst[14:12] == 0x0
8694 OPC_Decode, 238, 114, 110, // 15219: decode to FLI_Q using decoder 110
8695 // 15219: }
8696 // 15219: } // switch Inst[31:25]
8697 // 15219: }
8698 87, 226, 27, // 15223: case 0x57: {
8699 OPC_SwitchField, 12, 3, // 15226: switch Inst[14:12] {
8700 0, 184, 3, // 15229: case 0x0: {
8701 OPC_SwitchField, 26, 6, // 15232: switch Inst[31:26] {
8702 0, 6, // 15235: case 0x0: {
8703 OPC_CheckPredicate, 21, // 15237: check predicate 21
8704 OPC_Decode, 209, 125, 111, // 15239: decode to VADD_VV using decoder 111
8705 // 15239: }
8706 1, 6, // 15243: case 0x1: {
8707 OPC_CheckPredicate, 92, // 15245: check predicate 92
8708 OPC_Decode, 222, 125, 111, // 15247: decode to VANDN_VV using decoder 111
8709 // 15247: }
8710 2, 7, // 15251: case 0x2: {
8711 OPC_CheckPredicate, 21, // 15253: check predicate 21
8712 OPC_Decode, 173, 130, 1, 111, // 15255: decode to VSUB_VV using decoder 111
8713 // 15255: }
8714 4, 7, // 15260: case 0x4: {
8715 OPC_CheckPredicate, 21, // 15262: check predicate 21
8716 OPC_Decode, 180, 128, 1, 111, // 15264: decode to VMINU_VV using decoder 111
8717 // 15264: }
8718 5, 7, // 15269: case 0x5: {
8719 OPC_CheckPredicate, 21, // 15271: check predicate 21
8720 OPC_Decode, 182, 128, 1, 111, // 15273: decode to VMIN_VV using decoder 111
8721 // 15273: }
8722 6, 7, // 15278: case 0x6: {
8723 OPC_CheckPredicate, 21, // 15280: check predicate 21
8724 OPC_Decode, 163, 128, 1, 111, // 15282: decode to VMAXU_VV using decoder 111
8725 // 15282: }
8726 7, 7, // 15287: case 0x7: {
8727 OPC_CheckPredicate, 21, // 15289: check predicate 21
8728 OPC_Decode, 165, 128, 1, 111, // 15291: decode to VMAX_VV using decoder 111
8729 // 15291: }
8730 9, 6, // 15296: case 0x9: {
8731 OPC_CheckPredicate, 21, // 15298: check predicate 21
8732 OPC_Decode, 225, 125, 111, // 15300: decode to VAND_VV using decoder 111
8733 // 15300: }
8734 10, 7, // 15304: case 0xa: {
8735 OPC_CheckPredicate, 21, // 15306: check predicate 21
8736 OPC_Decode, 251, 128, 1, 111, // 15308: decode to VOR_VV using decoder 111
8737 // 15308: }
8738 11, 7, // 15313: case 0xb: {
8739 OPC_CheckPredicate, 21, // 15315: check predicate 21
8740 OPC_Decode, 248, 130, 1, 111, // 15317: decode to VXOR_VV using decoder 111
8741 // 15317: }
8742 12, 7, // 15322: case 0xc: {
8743 OPC_CheckPredicate, 21, // 15324: check predicate 21
8744 OPC_Decode, 142, 129, 1, 111, // 15326: decode to VRGATHER_VV using decoder 111
8745 // 15326: }
8746 14, 7, // 15331: case 0xe: {
8747 OPC_CheckPredicate, 21, // 15333: check predicate 21
8748 OPC_Decode, 140, 129, 1, 111, // 15335: decode to VRGATHEREI16_VV using decoder 111
8749 // 15335: }
8750 15, 7, // 15340: case 0xf: {
8751 OPC_CheckPredicate, 93, // 15342: check predicate 93
8752 OPC_Decode, 253, 128, 1, 111, // 15344: decode to VPAIRE_VV using decoder 111
8753 // 15344: }
8754 16, 10, // 15349: case 0x10: {
8755 OPC_CheckPredicate, 21, // 15351: check predicate 21
8756 OPC_CheckField, 25, 1, 0, // 15353: check Inst[25] == 0x0
8757 OPC_Decode, 206, 125, 112, // 15357: decode to VADC_VVM using decoder 112
8758 // 15357: }
8759 17, 21, // 15361: case 0x11: {
8760 OPC_SwitchField, 25, 1, // 15363: switch Inst[25] {
8761 0, 7, // 15366: case 0x0: {
8762 OPC_CheckPredicate, 21, // 15368: check predicate 21
8763 OPC_Decode, 156, 128, 1, 112, // 15370: decode to VMADC_VVM using decoder 112
8764 // 15370: }
8765 1, 0, // 15375: case 0x1: {
8766 OPC_CheckPredicate, 21, // 15377: check predicate 21
8767 OPC_Decode, 155, 128, 1, 113, // 15379: decode to VMADC_VV using decoder 113
8768 // 15379: }
8769 // 15379: } // switch Inst[25]
8770 // 15379: }
8771 18, 11, // 15384: case 0x12: {
8772 OPC_CheckPredicate, 21, // 15386: check predicate 21
8773 OPC_CheckField, 25, 1, 0, // 15388: check Inst[25] == 0x0
8774 OPC_Decode, 161, 129, 1, 112, // 15392: decode to VSBC_VVM using decoder 112
8775 // 15392: }
8776 19, 21, // 15397: case 0x13: {
8777 OPC_SwitchField, 25, 1, // 15399: switch Inst[25] {
8778 0, 7, // 15402: case 0x0: {
8779 OPC_CheckPredicate, 21, // 15404: check predicate 21
8780 OPC_Decode, 189, 128, 1, 112, // 15406: decode to VMSBC_VVM using decoder 112
8781 // 15406: }
8782 1, 0, // 15411: case 0x1: {
8783 OPC_CheckPredicate, 21, // 15413: check predicate 21
8784 OPC_Decode, 188, 128, 1, 113, // 15415: decode to VMSBC_VV using decoder 113
8785 // 15415: }
8786 // 15415: } // switch Inst[25]
8787 // 15415: }
8788 20, 7, // 15420: case 0x14: {
8789 OPC_CheckPredicate, 92, // 15422: check predicate 92
8790 OPC_Decode, 147, 129, 1, 111, // 15424: decode to VROR_VV using decoder 111
8791 // 15424: }
8792 21, 7, // 15429: case 0x15: {
8793 OPC_CheckPredicate, 92, // 15431: check predicate 92
8794 OPC_Decode, 144, 129, 1, 111, // 15433: decode to VROL_VV using decoder 111
8795 // 15433: }
8796 23, 25, // 15438: case 0x17: {
8797 OPC_SwitchField, 25, 1, // 15440: switch Inst[25] {
8798 0, 7, // 15443: case 0x0: {
8799 OPC_CheckPredicate, 21, // 15445: check predicate 21
8800 OPC_Decode, 168, 128, 1, 112, // 15447: decode to VMERGE_VVM using decoder 112
8801 // 15447: }
8802 1, 0, // 15452: case 0x1: {
8803 OPC_CheckPredicate, 21, // 15454: check predicate 21
8804 OPC_CheckField, 20, 5, 0, // 15456: check Inst[24:20] == 0x0
8805 OPC_Decode, 229, 128, 1, 114, // 15460: decode to VMV_V_V using decoder 114
8806 // 15460: }
8807 // 15460: } // switch Inst[25]
8808 // 15460: }
8809 24, 7, // 15465: case 0x18: {
8810 OPC_CheckPredicate, 21, // 15467: check predicate 21
8811 OPC_Decode, 194, 128, 1, 111, // 15469: decode to VMSEQ_VV using decoder 111
8812 // 15469: }
8813 25, 7, // 15474: case 0x19: {
8814 OPC_CheckPredicate, 21, // 15476: check predicate 21
8815 OPC_Decode, 212, 128, 1, 111, // 15478: decode to VMSNE_VV using decoder 111
8816 // 15478: }
8817 26, 7, // 15483: case 0x1a: {
8818 OPC_CheckPredicate, 21, // 15485: check predicate 21
8819 OPC_Decode, 207, 128, 1, 111, // 15487: decode to VMSLTU_VV using decoder 111
8820 // 15487: }
8821 27, 7, // 15492: case 0x1b: {
8822 OPC_CheckPredicate, 21, // 15494: check predicate 21
8823 OPC_Decode, 209, 128, 1, 111, // 15496: decode to VMSLT_VV using decoder 111
8824 // 15496: }
8825 28, 7, // 15501: case 0x1c: {
8826 OPC_CheckPredicate, 21, // 15503: check predicate 21
8827 OPC_Decode, 202, 128, 1, 111, // 15505: decode to VMSLEU_VV using decoder 111
8828 // 15505: }
8829 29, 7, // 15510: case 0x1d: {
8830 OPC_CheckPredicate, 21, // 15512: check predicate 21
8831 OPC_Decode, 205, 128, 1, 111, // 15514: decode to VMSLE_VV using decoder 111
8832 // 15514: }
8833 32, 7, // 15519: case 0x20: {
8834 OPC_CheckPredicate, 21, // 15521: check predicate 21
8835 OPC_Decode, 156, 129, 1, 111, // 15523: decode to VSADDU_VV using decoder 111
8836 // 15523: }
8837 33, 7, // 15528: case 0x21: {
8838 OPC_CheckPredicate, 21, // 15530: check predicate 21
8839 OPC_Decode, 159, 129, 1, 111, // 15532: decode to VSADD_VV using decoder 111
8840 // 15532: }
8841 34, 7, // 15537: case 0x22: {
8842 OPC_CheckPredicate, 21, // 15539: check predicate 21
8843 OPC_Decode, 169, 130, 1, 111, // 15541: decode to VSSUBU_VV using decoder 111
8844 // 15541: }
8845 35, 7, // 15546: case 0x23: {
8846 OPC_CheckPredicate, 21, // 15548: check predicate 21
8847 OPC_Decode, 171, 130, 1, 111, // 15550: decode to VSSUB_VV using decoder 111
8848 // 15550: }
8849 37, 7, // 15555: case 0x25: {
8850 OPC_CheckPredicate, 21, // 15557: check predicate 21
8851 OPC_Decode, 183, 129, 1, 111, // 15559: decode to VSLL_VV using decoder 111
8852 // 15559: }
8853 39, 7, // 15564: case 0x27: {
8854 OPC_CheckPredicate, 21, // 15566: check predicate 21
8855 OPC_Decode, 190, 129, 1, 111, // 15568: decode to VSMUL_VV using decoder 111
8856 // 15568: }
8857 40, 7, // 15573: case 0x28: {
8858 OPC_CheckPredicate, 21, // 15575: check predicate 21
8859 OPC_Decode, 229, 129, 1, 111, // 15577: decode to VSRL_VV using decoder 111
8860 // 15577: }
8861 41, 7, // 15582: case 0x29: {
8862 OPC_CheckPredicate, 21, // 15584: check predicate 21
8863 OPC_Decode, 226, 129, 1, 111, // 15586: decode to VSRA_VV using decoder 111
8864 // 15586: }
8865 42, 7, // 15591: case 0x2a: {
8866 OPC_CheckPredicate, 21, // 15593: check predicate 21
8867 OPC_Decode, 139, 130, 1, 111, // 15595: decode to VSSRL_VV using decoder 111
8868 // 15595: }
8869 43, 7, // 15600: case 0x2b: {
8870 OPC_CheckPredicate, 21, // 15602: check predicate 21
8871 OPC_Decode, 136, 130, 1, 111, // 15604: decode to VSSRA_VV using decoder 111
8872 // 15604: }
8873 44, 7, // 15609: case 0x2c: {
8874 OPC_CheckPredicate, 21, // 15611: check predicate 21
8875 OPC_Decode, 248, 128, 1, 111, // 15613: decode to VNSRL_WV using decoder 111
8876 // 15613: }
8877 45, 7, // 15618: case 0x2d: {
8878 OPC_CheckPredicate, 21, // 15620: check predicate 21
8879 OPC_Decode, 245, 128, 1, 111, // 15622: decode to VNSRA_WV using decoder 111
8880 // 15622: }
8881 46, 7, // 15627: case 0x2e: {
8882 OPC_CheckPredicate, 21, // 15629: check predicate 21
8883 OPC_Decode, 235, 128, 1, 111, // 15631: decode to VNCLIPU_WV using decoder 111
8884 // 15631: }
8885 47, 7, // 15636: case 0x2f: {
8886 OPC_CheckPredicate, 21, // 15638: check predicate 21
8887 OPC_Decode, 238, 128, 1, 111, // 15640: decode to VNCLIP_WV using decoder 111
8888 // 15640: }
8889 48, 7, // 15645: case 0x30: {
8890 OPC_CheckPredicate, 21, // 15647: check predicate 21
8891 OPC_Decode, 234, 130, 1, 111, // 15649: decode to VWREDSUMU_VS using decoder 111
8892 // 15649: }
8893 49, 7, // 15654: case 0x31: {
8894 OPC_CheckPredicate, 21, // 15656: check predicate 21
8895 OPC_Decode, 235, 130, 1, 111, // 15658: decode to VWREDSUM_VS using decoder 111
8896 // 15658: }
8897 53, 0, // 15663: case 0x35: {
8898 OPC_CheckPredicate, 94, // 15665: check predicate 94
8899 OPC_Decode, 237, 130, 1, 111, // 15667: decode to VWSLL_VV using decoder 111
8900 // 15667: }
8901 // 15667: } // switch Inst[31:26]
8902 // 15667: }
8903 1, 186, 4, // 15672: case 0x1: {
8904 OPC_SwitchField, 26, 6, // 15675: switch Inst[31:26] {
8905 0, 6, // 15678: case 0x0: {
8906 OPC_CheckPredicate, 95, // 15680: check predicate 95
8907 OPC_Decode, 254, 125, 111, // 15682: decode to VFADD_VV using decoder 111
8908 // 15682: }
8909 1, 6, // 15686: case 0x1: {
8910 OPC_CheckPredicate, 95, // 15688: check predicate 95
8911 OPC_Decode, 180, 126, 111, // 15690: decode to VFREDUSUM_VS using decoder 111
8912 // 15690: }
8913 2, 6, // 15694: case 0x2: {
8914 OPC_CheckPredicate, 95, // 15696: check predicate 95
8915 OPC_Decode, 193, 126, 111, // 15698: decode to VFSUB_VV using decoder 111
8916 // 15698: }
8917 3, 6, // 15702: case 0x3: {
8918 OPC_CheckPredicate, 95, // 15704: check predicate 95
8919 OPC_Decode, 179, 126, 111, // 15706: decode to VFREDOSUM_VS using decoder 111
8920 // 15706: }
8921 4, 6, // 15710: case 0x4: {
8922 OPC_CheckPredicate, 95, // 15712: check predicate 95
8923 OPC_Decode, 145, 126, 111, // 15714: decode to VFMIN_VV using decoder 111
8924 // 15714: }
8925 5, 6, // 15718: case 0x5: {
8926 OPC_CheckPredicate, 95, // 15720: check predicate 95
8927 OPC_Decode, 178, 126, 111, // 15722: decode to VFREDMIN_VS using decoder 111
8928 // 15722: }
8929 6, 6, // 15726: case 0x6: {
8930 OPC_CheckPredicate, 95, // 15728: check predicate 95
8931 OPC_Decode, 142, 126, 111, // 15730: decode to VFMAX_VV using decoder 111
8932 // 15730: }
8933 7, 6, // 15734: case 0x7: {
8934 OPC_CheckPredicate, 95, // 15736: check predicate 95
8935 OPC_Decode, 177, 126, 111, // 15738: decode to VFREDMAX_VS using decoder 111
8936 // 15738: }
8937 8, 6, // 15742: case 0x8: {
8938 OPC_CheckPredicate, 95, // 15744: check predicate 95
8939 OPC_Decode, 188, 126, 111, // 15746: decode to VFSGNJ_VV using decoder 111
8940 // 15746: }
8941 9, 6, // 15750: case 0x9: {
8942 OPC_CheckPredicate, 95, // 15752: check predicate 95
8943 OPC_Decode, 184, 126, 111, // 15754: decode to VFSGNJN_VV using decoder 111
8944 // 15754: }
8945 10, 6, // 15758: case 0xa: {
8946 OPC_CheckPredicate, 95, // 15760: check predicate 95
8947 OPC_Decode, 186, 126, 111, // 15762: decode to VFSGNJX_VV using decoder 111
8948 // 15762: }
8949 16, 14, // 15766: case 0x10: {
8950 OPC_CheckPredicate, 95, // 15768: check predicate 95
8951 OPC_CheckField, 25, 1, 1, // 15770: check Inst[25] == 0x1
8952 OPC_CheckField, 15, 5, 0, // 15774: check Inst[19:15] == 0x0
8953 OPC_Decode, 152, 126, 115, // 15778: decode to VFMV_F_S using decoder 115
8954 // 15778: }
8955 18, 211, 1, // 15782: case 0x12: {
8956 OPC_SwitchField, 15, 5, // 15785: switch Inst[19:15] {
8957 0, 6, // 15788: case 0x0: {
8958 OPC_CheckPredicate, 95, // 15790: check predicate 95
8959 OPC_Decode, 132, 126, 116, // 15792: decode to VFCVT_XU_F_V using decoder 116
8960 // 15792: }
8961 1, 6, // 15796: case 0x1: {
8962 OPC_CheckPredicate, 95, // 15798: check predicate 95
8963 OPC_Decode, 133, 126, 116, // 15800: decode to VFCVT_X_F_V using decoder 116
8964 // 15800: }
8965 2, 6, // 15804: case 0x2: {
8966 OPC_CheckPredicate, 95, // 15806: check predicate 95
8967 OPC_Decode, 128, 126, 116, // 15808: decode to VFCVT_F_XU_V using decoder 116
8968 // 15808: }
8969 3, 6, // 15812: case 0x3: {
8970 OPC_CheckPredicate, 95, // 15814: check predicate 95
8971 OPC_Decode, 129, 126, 116, // 15816: decode to VFCVT_F_X_V using decoder 116
8972 // 15816: }
8973 6, 6, // 15820: case 0x6: {
8974 OPC_CheckPredicate, 95, // 15822: check predicate 95
8975 OPC_Decode, 130, 126, 116, // 15824: decode to VFCVT_RTZ_XU_F_V using decoder 116
8976 // 15824: }
8977 7, 6, // 15828: case 0x7: {
8978 OPC_CheckPredicate, 95, // 15830: check predicate 95
8979 OPC_Decode, 131, 126, 116, // 15832: decode to VFCVT_RTZ_X_F_V using decoder 116
8980 // 15832: }
8981 8, 6, // 15836: case 0x8: {
8982 OPC_CheckPredicate, 95, // 15838: check predicate 95
8983 OPC_Decode, 204, 126, 116, // 15840: decode to VFWCVT_XU_F_V using decoder 116
8984 // 15840: }
8985 9, 6, // 15844: case 0x9: {
8986 OPC_CheckPredicate, 95, // 15846: check predicate 95
8987 OPC_Decode, 205, 126, 116, // 15848: decode to VFWCVT_X_F_V using decoder 116
8988 // 15848: }
8989 10, 6, // 15852: case 0xa: {
8990 OPC_CheckPredicate, 95, // 15854: check predicate 95
8991 OPC_Decode, 200, 126, 116, // 15856: decode to VFWCVT_F_XU_V using decoder 116
8992 // 15856: }
8993 11, 6, // 15860: case 0xb: {
8994 OPC_CheckPredicate, 95, // 15862: check predicate 95
8995 OPC_Decode, 201, 126, 116, // 15864: decode to VFWCVT_F_X_V using decoder 116
8996 // 15864: }
8997 12, 6, // 15868: case 0xc: {
8998 OPC_CheckPredicate, 95, // 15870: check predicate 95
8999 OPC_Decode, 199, 126, 116, // 15872: decode to VFWCVT_F_F_V using decoder 116
9000 // 15872: }
9001 13, 6, // 15876: case 0xd: {
9002 OPC_CheckPredicate, 96, // 15878: check predicate 96
9003 OPC_Decode, 198, 126, 116, // 15880: decode to VFWCVTBF16_F_F_V using decoder 116
9004 // 15880: }
9005 14, 6, // 15884: case 0xe: {
9006 OPC_CheckPredicate, 95, // 15886: check predicate 95
9007 OPC_Decode, 202, 126, 116, // 15888: decode to VFWCVT_RTZ_XU_F_V using decoder 116
9008 // 15888: }
9009 15, 6, // 15892: case 0xf: {
9010 OPC_CheckPredicate, 95, // 15894: check predicate 95
9011 OPC_Decode, 203, 126, 116, // 15896: decode to VFWCVT_RTZ_X_F_V using decoder 116
9012 // 15896: }
9013 16, 6, // 15900: case 0x10: {
9014 OPC_CheckPredicate, 95, // 15902: check predicate 95
9015 OPC_Decode, 165, 126, 116, // 15904: decode to VFNCVT_XU_F_W using decoder 116
9016 // 15904: }
9017 17, 6, // 15908: case 0x11: {
9018 OPC_CheckPredicate, 95, // 15910: check predicate 95
9019 OPC_Decode, 166, 126, 116, // 15912: decode to VFNCVT_X_F_W using decoder 116
9020 // 15912: }
9021 18, 6, // 15916: case 0x12: {
9022 OPC_CheckPredicate, 95, // 15918: check predicate 95
9023 OPC_Decode, 159, 126, 116, // 15920: decode to VFNCVT_F_XU_W using decoder 116
9024 // 15920: }
9025 19, 6, // 15924: case 0x13: {
9026 OPC_CheckPredicate, 95, // 15926: check predicate 95
9027 OPC_Decode, 160, 126, 116, // 15928: decode to VFNCVT_F_X_W using decoder 116
9028 // 15928: }
9029 20, 6, // 15932: case 0x14: {
9030 OPC_CheckPredicate, 95, // 15934: check predicate 95
9031 OPC_Decode, 158, 126, 116, // 15936: decode to VFNCVT_F_F_W using decoder 116
9032 // 15936: }
9033 21, 6, // 15940: case 0x15: {
9034 OPC_CheckPredicate, 95, // 15942: check predicate 95
9035 OPC_Decode, 161, 126, 116, // 15944: decode to VFNCVT_ROD_F_F_W using decoder 116
9036 // 15944: }
9037 22, 6, // 15948: case 0x16: {
9038 OPC_CheckPredicate, 95, // 15950: check predicate 95
9039 OPC_Decode, 162, 126, 116, // 15952: decode to VFNCVT_RTZ_XU_F_W using decoder 116
9040 // 15952: }
9041 23, 6, // 15956: case 0x17: {
9042 OPC_CheckPredicate, 95, // 15958: check predicate 95
9043 OPC_Decode, 163, 126, 116, // 15960: decode to VFNCVT_RTZ_X_F_W using decoder 116
9044 // 15960: }
9045 25, 6, // 15964: case 0x19: {
9046 OPC_CheckPredicate, 97, // 15966: check predicate 97
9047 OPC_Decode, 157, 126, 116, // 15968: decode to VFNCVT_F_F_Q using decoder 116
9048 // 15968: }
9049 27, 6, // 15972: case 0x1b: {
9050 OPC_CheckPredicate, 97, // 15974: check predicate 97
9051 OPC_Decode, 164, 126, 116, // 15976: decode to VFNCVT_SAT_F_F_Q using decoder 116
9052 // 15976: }
9053 29, 6, // 15980: case 0x1d: {
9054 OPC_CheckPredicate, 96, // 15982: check predicate 96
9055 OPC_Decode, 155, 126, 116, // 15984: decode to VFNCVTBF16_F_F_W using decoder 116
9056 // 15984: }
9057 31, 0, // 15988: case 0x1f: {
9058 OPC_CheckPredicate, 97, // 15990: check predicate 97
9059 OPC_Decode, 156, 126, 116, // 15992: decode to VFNCVTBF16_SAT_F_F_W using decoder 116
9060 // 15992: }
9061 // 15992: } // switch Inst[19:15]
9062 // 15992: }
9063 19, 35, // 15996: case 0x13: {
9064 OPC_SwitchField, 15, 5, // 15998: switch Inst[19:15] {
9065 0, 6, // 16001: case 0x0: {
9066 OPC_CheckPredicate, 95, // 16003: check predicate 95
9067 OPC_Decode, 191, 126, 116, // 16005: decode to VFSQRT_V using decoder 116
9068 // 16005: }
9069 4, 6, // 16009: case 0x4: {
9070 OPC_CheckPredicate, 95, // 16011: check predicate 95
9071 OPC_Decode, 181, 126, 116, // 16013: decode to VFRSQRT7_V using decoder 116
9072 // 16013: }
9073 5, 6, // 16017: case 0x5: {
9074 OPC_CheckPredicate, 95, // 16019: check predicate 95
9075 OPC_Decode, 176, 126, 116, // 16021: decode to VFREC7_V using decoder 116
9076 // 16021: }
9077 16, 0, // 16025: case 0x10: {
9078 OPC_CheckPredicate, 95, // 16027: check predicate 95
9079 OPC_Decode, 255, 125, 116, // 16029: decode to VFCLASS_V using decoder 116
9080 // 16029: }
9081 // 16029: } // switch Inst[19:15]
9082 // 16029: }
9083 24, 7, // 16033: case 0x18: {
9084 OPC_CheckPredicate, 95, // 16035: check predicate 95
9085 OPC_Decode, 171, 128, 1, 111, // 16037: decode to VMFEQ_VV using decoder 111
9086 // 16037: }
9087 25, 7, // 16042: case 0x19: {
9088 OPC_CheckPredicate, 95, // 16044: check predicate 95
9089 OPC_Decode, 175, 128, 1, 111, // 16046: decode to VMFLE_VV using decoder 111
9090 // 16046: }
9091 27, 7, // 16051: case 0x1b: {
9092 OPC_CheckPredicate, 95, // 16053: check predicate 95
9093 OPC_Decode, 177, 128, 1, 111, // 16055: decode to VMFLT_VV using decoder 111
9094 // 16055: }
9095 28, 7, // 16060: case 0x1c: {
9096 OPC_CheckPredicate, 95, // 16062: check predicate 95
9097 OPC_Decode, 179, 128, 1, 111, // 16064: decode to VMFNE_VV using decoder 111
9098 // 16064: }
9099 32, 6, // 16069: case 0x20: {
9100 OPC_CheckPredicate, 95, // 16071: check predicate 95
9101 OPC_Decode, 135, 126, 111, // 16073: decode to VFDIV_VV using decoder 111
9102 // 16073: }
9103 36, 6, // 16077: case 0x24: {
9104 OPC_CheckPredicate, 95, // 16079: check predicate 95
9105 OPC_Decode, 151, 126, 111, // 16081: decode to VFMUL_VV using decoder 111
9106 // 16081: }
9107 40, 6, // 16085: case 0x28: {
9108 OPC_CheckPredicate, 95, // 16087: check predicate 95
9109 OPC_Decode, 140, 126, 117, // 16089: decode to VFMADD_VV using decoder 117
9110 // 16089: }
9111 41, 6, // 16093: case 0x29: {
9112 OPC_CheckPredicate, 95, // 16095: check predicate 95
9113 OPC_Decode, 170, 126, 117, // 16097: decode to VFNMADD_VV using decoder 117
9114 // 16097: }
9115 42, 6, // 16101: case 0x2a: {
9116 OPC_CheckPredicate, 95, // 16103: check predicate 95
9117 OPC_Decode, 149, 126, 117, // 16105: decode to VFMSUB_VV using decoder 117
9118 // 16105: }
9119 43, 6, // 16109: case 0x2b: {
9120 OPC_CheckPredicate, 95, // 16111: check predicate 95
9121 OPC_Decode, 174, 126, 117, // 16113: decode to VFNMSUB_VV using decoder 117
9122 // 16113: }
9123 44, 6, // 16117: case 0x2c: {
9124 OPC_CheckPredicate, 95, // 16119: check predicate 95
9125 OPC_Decode, 138, 126, 117, // 16121: decode to VFMACC_VV using decoder 117
9126 // 16121: }
9127 45, 6, // 16125: case 0x2d: {
9128 OPC_CheckPredicate, 95, // 16127: check predicate 95
9129 OPC_Decode, 168, 126, 117, // 16129: decode to VFNMACC_VV using decoder 117
9130 // 16129: }
9131 46, 6, // 16133: case 0x2e: {
9132 OPC_CheckPredicate, 95, // 16135: check predicate 95
9133 OPC_Decode, 147, 126, 117, // 16137: decode to VFMSAC_VV using decoder 117
9134 // 16137: }
9135 47, 6, // 16141: case 0x2f: {
9136 OPC_CheckPredicate, 95, // 16143: check predicate 95
9137 OPC_Decode, 172, 126, 117, // 16145: decode to VFNMSAC_VV using decoder 117
9138 // 16145: }
9139 48, 6, // 16149: case 0x30: {
9140 OPC_CheckPredicate, 95, // 16151: check predicate 95
9141 OPC_Decode, 195, 126, 111, // 16153: decode to VFWADD_VV using decoder 111
9142 // 16153: }
9143 49, 6, // 16157: case 0x31: {
9144 OPC_CheckPredicate, 95, // 16159: check predicate 95
9145 OPC_Decode, 219, 126, 111, // 16161: decode to VFWREDUSUM_VS using decoder 111
9146 // 16161: }
9147 50, 6, // 16165: case 0x32: {
9148 OPC_CheckPredicate, 95, // 16167: check predicate 95
9149 OPC_Decode, 221, 126, 111, // 16169: decode to VFWSUB_VV using decoder 111
9150 // 16169: }
9151 51, 6, // 16173: case 0x33: {
9152 OPC_CheckPredicate, 95, // 16175: check predicate 95
9153 OPC_Decode, 218, 126, 111, // 16177: decode to VFWREDOSUM_VS using decoder 111
9154 // 16177: }
9155 52, 6, // 16181: case 0x34: {
9156 OPC_CheckPredicate, 95, // 16183: check predicate 95
9157 OPC_Decode, 197, 126, 111, // 16185: decode to VFWADD_WV using decoder 111
9158 // 16185: }
9159 54, 6, // 16189: case 0x36: {
9160 OPC_CheckPredicate, 95, // 16191: check predicate 95
9161 OPC_Decode, 223, 126, 111, // 16193: decode to VFWSUB_WV using decoder 111
9162 // 16193: }
9163 56, 6, // 16197: case 0x38: {
9164 OPC_CheckPredicate, 95, // 16199: check predicate 95
9165 OPC_Decode, 213, 126, 111, // 16201: decode to VFWMUL_VV using decoder 111
9166 // 16201: }
9167 59, 6, // 16205: case 0x3b: {
9168 OPC_CheckPredicate, 98, // 16207: check predicate 98
9169 OPC_Decode, 207, 126, 117, // 16209: decode to VFWMACCBF16_VV using decoder 117
9170 // 16209: }
9171 60, 6, // 16213: case 0x3c: {
9172 OPC_CheckPredicate, 95, // 16215: check predicate 95
9173 OPC_Decode, 209, 126, 117, // 16217: decode to VFWMACC_VV using decoder 117
9174 // 16217: }
9175 61, 6, // 16221: case 0x3d: {
9176 OPC_CheckPredicate, 95, // 16223: check predicate 95
9177 OPC_Decode, 215, 126, 117, // 16225: decode to VFWNMACC_VV using decoder 117
9178 // 16225: }
9179 62, 6, // 16229: case 0x3e: {
9180 OPC_CheckPredicate, 95, // 16231: check predicate 95
9181 OPC_Decode, 211, 126, 117, // 16233: decode to VFWMSAC_VV using decoder 117
9182 // 16233: }
9183 63, 0, // 16237: case 0x3f: {
9184 OPC_CheckPredicate, 95, // 16239: check predicate 95
9185 OPC_Decode, 217, 126, 117, // 16241: decode to VFWNMSAC_VV using decoder 117
9186 // 16241: }
9187 // 16241: } // switch Inst[31:26]
9188 // 16241: }
9189 2, 128, 6, // 16245: case 0x2: {
9190 OPC_SwitchField, 26, 6, // 16248: switch Inst[31:26] {
9191 0, 7, // 16251: case 0x0: {
9192 OPC_CheckPredicate, 21, // 16253: check predicate 21
9193 OPC_Decode, 133, 129, 1, 111, // 16255: decode to VREDSUM_VS using decoder 111
9194 // 16255: }
9195 1, 7, // 16260: case 0x1: {
9196 OPC_CheckPredicate, 21, // 16262: check predicate 21
9197 OPC_Decode, 255, 128, 1, 111, // 16264: decode to VREDAND_VS using decoder 111
9198 // 16264: }
9199 2, 7, // 16269: case 0x2: {
9200 OPC_CheckPredicate, 21, // 16271: check predicate 21
9201 OPC_Decode, 132, 129, 1, 111, // 16273: decode to VREDOR_VS using decoder 111
9202 // 16273: }
9203 3, 7, // 16278: case 0x3: {
9204 OPC_CheckPredicate, 21, // 16280: check predicate 21
9205 OPC_Decode, 134, 129, 1, 111, // 16282: decode to VREDXOR_VS using decoder 111
9206 // 16282: }
9207 4, 7, // 16287: case 0x4: {
9208 OPC_CheckPredicate, 21, // 16289: check predicate 21
9209 OPC_Decode, 130, 129, 1, 111, // 16291: decode to VREDMINU_VS using decoder 111
9210 // 16291: }
9211 5, 7, // 16296: case 0x5: {
9212 OPC_CheckPredicate, 21, // 16298: check predicate 21
9213 OPC_Decode, 131, 129, 1, 111, // 16300: decode to VREDMIN_VS using decoder 111
9214 // 16300: }
9215 6, 7, // 16305: case 0x6: {
9216 OPC_CheckPredicate, 21, // 16307: check predicate 21
9217 OPC_Decode, 128, 129, 1, 111, // 16309: decode to VREDMAXU_VS using decoder 111
9218 // 16309: }
9219 7, 7, // 16314: case 0x7: {
9220 OPC_CheckPredicate, 21, // 16316: check predicate 21
9221 OPC_Decode, 129, 129, 1, 111, // 16318: decode to VREDMAX_VS using decoder 111
9222 // 16318: }
9223 8, 6, // 16323: case 0x8: {
9224 OPC_CheckPredicate, 21, // 16325: check predicate 21
9225 OPC_Decode, 198, 125, 111, // 16327: decode to VAADDU_VV using decoder 111
9226 // 16327: }
9227 9, 6, // 16331: case 0x9: {
9228 OPC_CheckPredicate, 21, // 16333: check predicate 21
9229 OPC_Decode, 200, 125, 111, // 16335: decode to VAADD_VV using decoder 111
9230 // 16335: }
9231 10, 6, // 16339: case 0xa: {
9232 OPC_CheckPredicate, 21, // 16341: check predicate 21
9233 OPC_Decode, 227, 125, 111, // 16343: decode to VASUBU_VV using decoder 111
9234 // 16343: }
9235 11, 6, // 16347: case 0xb: {
9236 OPC_CheckPredicate, 21, // 16349: check predicate 21
9237 OPC_Decode, 229, 125, 111, // 16351: decode to VASUB_VV using decoder 111
9238 // 16351: }
9239 12, 6, // 16355: case 0xc: {
9240 OPC_CheckPredicate, 99, // 16357: check predicate 99
9241 OPC_Decode, 235, 125, 111, // 16359: decode to VCLMUL_VV using decoder 111
9242 // 16359: }
9243 13, 6, // 16363: case 0xd: {
9244 OPC_CheckPredicate, 99, // 16365: check predicate 99
9245 OPC_Decode, 233, 125, 111, // 16367: decode to VCLMULH_VV using decoder 111
9246 // 16367: }
9247 15, 7, // 16371: case 0xf: {
9248 OPC_CheckPredicate, 93, // 16373: check predicate 93
9249 OPC_Decode, 254, 128, 1, 111, // 16375: decode to VPAIRO_VV using decoder 111
9250 // 16375: }
9251 16, 32, // 16380: case 0x10: {
9252 OPC_SwitchField, 15, 5, // 16382: switch Inst[19:15] {
9253 0, 11, // 16385: case 0x0: {
9254 OPC_CheckPredicate, 21, // 16387: check predicate 21
9255 OPC_CheckField, 25, 1, 1, // 16389: check Inst[25] == 0x1
9256 OPC_Decode, 231, 128, 1, 118, // 16393: decode to VMV_X_S using decoder 118
9257 // 16393: }
9258 16, 6, // 16398: case 0x10: {
9259 OPC_CheckPredicate, 21, // 16400: check predicate 21
9260 OPC_Decode, 239, 125, 119, // 16402: decode to VCPOP_M using decoder 119
9261 // 16402: }
9262 17, 0, // 16406: case 0x11: {
9263 OPC_CheckPredicate, 21, // 16408: check predicate 21
9264 OPC_Decode, 136, 126, 119, // 16410: decode to VFIRST_M using decoder 119
9265 // 16410: }
9266 // 16410: } // switch Inst[19:15]
9267 // 16410: }
9268 17, 6, // 16414: case 0x11: {
9269 OPC_CheckPredicate, 100, // 16416: check predicate 100
9270 OPC_Decode, 203, 125, 111, // 16418: decode to VABD_VV using decoder 111
9271 // 16418: }
9272 18, 132, 1, // 16422: case 0x12: {
9273 OPC_SwitchField, 15, 5, // 16425: switch Inst[19:15] {
9274 2, 7, // 16428: case 0x2: {
9275 OPC_CheckPredicate, 21, // 16430: check predicate 21
9276 OPC_Decode, 252, 130, 1, 116, // 16432: decode to VZEXT_VF8 using decoder 116
9277 // 16432: }
9278 3, 7, // 16437: case 0x3: {
9279 OPC_CheckPredicate, 21, // 16439: check predicate 21
9280 OPC_Decode, 172, 129, 1, 116, // 16441: decode to VSEXT_VF8 using decoder 116
9281 // 16441: }
9282 4, 7, // 16446: case 0x4: {
9283 OPC_CheckPredicate, 21, // 16448: check predicate 21
9284 OPC_Decode, 251, 130, 1, 116, // 16450: decode to VZEXT_VF4 using decoder 116
9285 // 16450: }
9286 5, 7, // 16455: case 0x5: {
9287 OPC_CheckPredicate, 21, // 16457: check predicate 21
9288 OPC_Decode, 171, 129, 1, 116, // 16459: decode to VSEXT_VF4 using decoder 116
9289 // 16459: }
9290 6, 7, // 16464: case 0x6: {
9291 OPC_CheckPredicate, 21, // 16466: check predicate 21
9292 OPC_Decode, 250, 130, 1, 116, // 16468: decode to VZEXT_VF2 using decoder 116
9293 // 16468: }
9294 7, 7, // 16473: case 0x7: {
9295 OPC_CheckPredicate, 21, // 16475: check predicate 21
9296 OPC_Decode, 170, 129, 1, 116, // 16477: decode to VSEXT_VF2 using decoder 116
9297 // 16477: }
9298 8, 6, // 16482: case 0x8: {
9299 OPC_CheckPredicate, 92, // 16484: check predicate 92
9300 OPC_Decode, 231, 125, 116, // 16486: decode to VBREV8_V using decoder 116
9301 // 16486: }
9302 9, 7, // 16490: case 0x9: {
9303 OPC_CheckPredicate, 92, // 16492: check predicate 92
9304 OPC_Decode, 139, 129, 1, 116, // 16494: decode to VREV8_V using decoder 116
9305 // 16494: }
9306 10, 6, // 16499: case 0xa: {
9307 OPC_CheckPredicate, 94, // 16501: check predicate 94
9308 OPC_Decode, 232, 125, 116, // 16503: decode to VBREV_V using decoder 116
9309 // 16503: }
9310 11, 7, // 16507: case 0xb: {
9311 OPC_CheckPredicate, 93, // 16509: check predicate 93
9312 OPC_Decode, 209, 130, 1, 116, // 16511: decode to VUNZIPE_V using decoder 116
9313 // 16511: }
9314 12, 6, // 16516: case 0xc: {
9315 OPC_CheckPredicate, 94, // 16518: check predicate 94
9316 OPC_Decode, 237, 125, 116, // 16520: decode to VCLZ_V using decoder 116
9317 // 16520: }
9318 13, 6, // 16524: case 0xd: {
9319 OPC_CheckPredicate, 94, // 16526: check predicate 94
9320 OPC_Decode, 241, 125, 116, // 16528: decode to VCTZ_V using decoder 116
9321 // 16528: }
9322 14, 6, // 16532: case 0xe: {
9323 OPC_CheckPredicate, 94, // 16534: check predicate 94
9324 OPC_Decode, 240, 125, 116, // 16536: decode to VCPOP_V using decoder 116
9325 // 16536: }
9326 15, 7, // 16540: case 0xf: {
9327 OPC_CheckPredicate, 93, // 16542: check predicate 93
9328 OPC_Decode, 210, 130, 1, 116, // 16544: decode to VUNZIPO_V using decoder 116
9329 // 16544: }
9330 16, 0, // 16549: case 0x10: {
9331 OPC_CheckPredicate, 100, // 16551: check predicate 100
9332 OPC_Decode, 204, 125, 116, // 16553: decode to VABS_V using decoder 116
9333 // 16553: }
9334 // 16553: } // switch Inst[19:15]
9335 // 16553: }
9336 19, 6, // 16557: case 0x13: {
9337 OPC_CheckPredicate, 100, // 16559: check predicate 100
9338 OPC_Decode, 202, 125, 111, // 16561: decode to VABDU_VV using decoder 111
9339 // 16561: }
9340 20, 50, // 16565: case 0x14: {
9341 OPC_SwitchField, 15, 5, // 16567: switch Inst[19:15] {
9342 1, 7, // 16570: case 0x1: {
9343 OPC_CheckPredicate, 21, // 16572: check predicate 21
9344 OPC_Decode, 192, 128, 1, 116, // 16574: decode to VMSBF_M using decoder 116
9345 // 16574: }
9346 2, 7, // 16579: case 0x2: {
9347 OPC_CheckPredicate, 21, // 16581: check predicate 21
9348 OPC_Decode, 214, 128, 1, 116, // 16583: decode to VMSOF_M using decoder 116
9349 // 16583: }
9350 3, 7, // 16588: case 0x3: {
9351 OPC_CheckPredicate, 21, // 16590: check predicate 21
9352 OPC_Decode, 200, 128, 1, 116, // 16592: decode to VMSIF_M using decoder 116
9353 // 16592: }
9354 16, 6, // 16597: case 0x10: {
9355 OPC_CheckPredicate, 21, // 16599: check predicate 21
9356 OPC_Decode, 229, 126, 116, // 16601: decode to VIOTA_M using decoder 116
9357 // 16601: }
9358 17, 0, // 16605: case 0x11: {
9359 OPC_CheckPredicate, 21, // 16607: check predicate 21
9360 OPC_CheckField, 20, 5, 0, // 16609: check Inst[24:20] == 0x0
9361 OPC_Decode, 228, 126, 120, // 16613: decode to VID_V using decoder 120
9362 // 16613: }
9363 // 16613: } // switch Inst[19:15]
9364 // 16613: }
9365 21, 7, // 16617: case 0x15: {
9366 OPC_CheckPredicate, 100, // 16619: check predicate 100
9367 OPC_Decode, 212, 130, 1, 111, // 16621: decode to VWABDA_VV using decoder 111
9368 // 16621: }
9369 22, 7, // 16626: case 0x16: {
9370 OPC_CheckPredicate, 100, // 16628: check predicate 100
9371 OPC_Decode, 211, 130, 1, 111, // 16630: decode to VWABDAU_VV using decoder 111
9372 // 16630: }
9373 23, 10, // 16635: case 0x17: {
9374 OPC_CheckPredicate, 21, // 16637: check predicate 21
9375 OPC_CheckField, 25, 1, 1, // 16639: check Inst[25] == 0x1
9376 OPC_Decode, 238, 125, 113, // 16643: decode to VCOMPRESS_VM using decoder 113
9377 // 16643: }
9378 24, 11, // 16647: case 0x18: {
9379 OPC_CheckPredicate, 21, // 16649: check predicate 21
9380 OPC_CheckField, 25, 1, 1, // 16651: check Inst[25] == 0x1
9381 OPC_Decode, 161, 128, 1, 113, // 16655: decode to VMANDN_MM using decoder 113
9382 // 16655: }
9383 25, 11, // 16660: case 0x19: {
9384 OPC_CheckPredicate, 21, // 16662: check predicate 21
9385 OPC_CheckField, 25, 1, 1, // 16664: check Inst[25] == 0x1
9386 OPC_Decode, 162, 128, 1, 113, // 16668: decode to VMAND_MM using decoder 113
9387 // 16668: }
9388 26, 11, // 16673: case 0x1a: {
9389 OPC_CheckPredicate, 21, // 16675: check predicate 21
9390 OPC_CheckField, 25, 1, 1, // 16677: check Inst[25] == 0x1
9391 OPC_Decode, 187, 128, 1, 113, // 16681: decode to VMOR_MM using decoder 113
9392 // 16681: }
9393 27, 11, // 16686: case 0x1b: {
9394 OPC_CheckPredicate, 21, // 16688: check predicate 21
9395 OPC_CheckField, 25, 1, 1, // 16690: check Inst[25] == 0x1
9396 OPC_Decode, 233, 128, 1, 113, // 16694: decode to VMXOR_MM using decoder 113
9397 // 16694: }
9398 28, 11, // 16699: case 0x1c: {
9399 OPC_CheckPredicate, 21, // 16701: check predicate 21
9400 OPC_CheckField, 25, 1, 1, // 16703: check Inst[25] == 0x1
9401 OPC_Decode, 186, 128, 1, 113, // 16707: decode to VMORN_MM using decoder 113
9402 // 16707: }
9403 29, 11, // 16712: case 0x1d: {
9404 OPC_CheckPredicate, 21, // 16714: check predicate 21
9405 OPC_CheckField, 25, 1, 1, // 16716: check Inst[25] == 0x1
9406 OPC_Decode, 184, 128, 1, 113, // 16720: decode to VMNAND_MM using decoder 113
9407 // 16720: }
9408 30, 11, // 16725: case 0x1e: {
9409 OPC_CheckPredicate, 21, // 16727: check predicate 21
9410 OPC_CheckField, 25, 1, 1, // 16729: check Inst[25] == 0x1
9411 OPC_Decode, 185, 128, 1, 113, // 16733: decode to VMNOR_MM using decoder 113
9412 // 16733: }
9413 31, 11, // 16738: case 0x1f: {
9414 OPC_CheckPredicate, 21, // 16740: check predicate 21
9415 OPC_CheckField, 25, 1, 1, // 16742: check Inst[25] == 0x1
9416 OPC_Decode, 232, 128, 1, 113, // 16746: decode to VMXNOR_MM using decoder 113
9417 // 16746: }
9418 32, 6, // 16751: case 0x20: {
9419 OPC_CheckPredicate, 21, // 16753: check predicate 21
9420 OPC_Decode, 242, 125, 111, // 16755: decode to VDIVU_VV using decoder 111
9421 // 16755: }
9422 33, 6, // 16759: case 0x21: {
9423 OPC_CheckPredicate, 21, // 16761: check predicate 21
9424 OPC_Decode, 244, 125, 111, // 16763: decode to VDIV_VV using decoder 111
9425 // 16763: }
9426 34, 7, // 16767: case 0x22: {
9427 OPC_CheckPredicate, 21, // 16769: check predicate 21
9428 OPC_Decode, 135, 129, 1, 111, // 16771: decode to VREMU_VV using decoder 111
9429 // 16771: }
9430 35, 7, // 16776: case 0x23: {
9431 OPC_CheckPredicate, 21, // 16778: check predicate 21
9432 OPC_Decode, 137, 129, 1, 111, // 16780: decode to VREM_VV using decoder 111
9433 // 16780: }
9434 36, 7, // 16785: case 0x24: {
9435 OPC_CheckPredicate, 21, // 16787: check predicate 21
9436 OPC_Decode, 217, 128, 1, 111, // 16789: decode to VMULHU_VV using decoder 111
9437 // 16789: }
9438 37, 7, // 16794: case 0x25: {
9439 OPC_CheckPredicate, 21, // 16796: check predicate 21
9440 OPC_Decode, 221, 128, 1, 111, // 16798: decode to VMUL_VV using decoder 111
9441 // 16798: }
9442 38, 7, // 16803: case 0x26: {
9443 OPC_CheckPredicate, 21, // 16805: check predicate 21
9444 OPC_Decode, 215, 128, 1, 111, // 16807: decode to VMULHSU_VV using decoder 111
9445 // 16807: }
9446 39, 7, // 16812: case 0x27: {
9447 OPC_CheckPredicate, 21, // 16814: check predicate 21
9448 OPC_Decode, 219, 128, 1, 111, // 16816: decode to VMULH_VV using decoder 111
9449 // 16816: }
9450 40, 6, // 16821: case 0x28: {
9451 OPC_CheckPredicate, 101, // 16823: check predicate 101
9452 OPC_Decode, 249, 125, 121, // 16825: decode to VDOTA4U_VV using decoder 121
9453 // 16825: }
9454 41, 7, // 16829: case 0x29: {
9455 OPC_CheckPredicate, 21, // 16831: check predicate 21
9456 OPC_Decode, 159, 128, 1, 117, // 16833: decode to VMADD_VV using decoder 117
9457 // 16833: }
9458 42, 6, // 16838: case 0x2a: {
9459 OPC_CheckPredicate, 101, // 16840: check predicate 101
9460 OPC_Decode, 246, 125, 121, // 16842: decode to VDOTA4SU_VV using decoder 121
9461 // 16842: }
9462 43, 7, // 16846: case 0x2b: {
9463 OPC_CheckPredicate, 21, // 16848: check predicate 21
9464 OPC_Decode, 242, 128, 1, 117, // 16850: decode to VNMSUB_VV using decoder 117
9465 // 16850: }
9466 44, 6, // 16855: case 0x2c: {
9467 OPC_CheckPredicate, 101, // 16857: check predicate 101
9468 OPC_Decode, 251, 125, 121, // 16859: decode to VDOTA4_VV using decoder 121
9469 // 16859: }
9470 45, 7, // 16863: case 0x2d: {
9471 OPC_CheckPredicate, 21, // 16865: check predicate 21
9472 OPC_Decode, 151, 128, 1, 117, // 16867: decode to VMACC_VV using decoder 117
9473 // 16867: }
9474 47, 7, // 16872: case 0x2f: {
9475 OPC_CheckPredicate, 21, // 16874: check predicate 21
9476 OPC_Decode, 240, 128, 1, 117, // 16876: decode to VNMSAC_VV using decoder 117
9477 // 16876: }
9478 48, 7, // 16881: case 0x30: {
9479 OPC_CheckPredicate, 21, // 16883: check predicate 21
9480 OPC_Decode, 213, 130, 1, 111, // 16885: decode to VWADDU_VV using decoder 111
9481 // 16885: }
9482 49, 7, // 16890: case 0x31: {
9483 OPC_CheckPredicate, 21, // 16892: check predicate 21
9484 OPC_Decode, 217, 130, 1, 111, // 16894: decode to VWADD_VV using decoder 111
9485 // 16894: }
9486 50, 7, // 16899: case 0x32: {
9487 OPC_CheckPredicate, 21, // 16901: check predicate 21
9488 OPC_Decode, 239, 130, 1, 111, // 16903: decode to VWSUBU_VV using decoder 111
9489 // 16903: }
9490 51, 7, // 16908: case 0x33: {
9491 OPC_CheckPredicate, 21, // 16910: check predicate 21
9492 OPC_Decode, 243, 130, 1, 111, // 16912: decode to VWSUB_VV using decoder 111
9493 // 16912: }
9494 52, 7, // 16917: case 0x34: {
9495 OPC_CheckPredicate, 21, // 16919: check predicate 21
9496 OPC_Decode, 215, 130, 1, 111, // 16921: decode to VWADDU_WV using decoder 111
9497 // 16921: }
9498 53, 7, // 16926: case 0x35: {
9499 OPC_CheckPredicate, 21, // 16928: check predicate 21
9500 OPC_Decode, 219, 130, 1, 111, // 16930: decode to VWADD_WV using decoder 111
9501 // 16930: }
9502 54, 7, // 16935: case 0x36: {
9503 OPC_CheckPredicate, 21, // 16937: check predicate 21
9504 OPC_Decode, 241, 130, 1, 111, // 16939: decode to VWSUBU_WV using decoder 111
9505 // 16939: }
9506 55, 7, // 16944: case 0x37: {
9507 OPC_CheckPredicate, 21, // 16946: check predicate 21
9508 OPC_Decode, 245, 130, 1, 111, // 16948: decode to VWSUB_WV using decoder 111
9509 // 16948: }
9510 56, 7, // 16953: case 0x38: {
9511 OPC_CheckPredicate, 21, // 16955: check predicate 21
9512 OPC_Decode, 230, 130, 1, 111, // 16957: decode to VWMULU_VV using decoder 111
9513 // 16957: }
9514 58, 7, // 16962: case 0x3a: {
9515 OPC_CheckPredicate, 21, // 16964: check predicate 21
9516 OPC_Decode, 228, 130, 1, 111, // 16966: decode to VWMULSU_VV using decoder 111
9517 // 16966: }
9518 59, 7, // 16971: case 0x3b: {
9519 OPC_CheckPredicate, 21, // 16973: check predicate 21
9520 OPC_Decode, 232, 130, 1, 111, // 16975: decode to VWMUL_VV using decoder 111
9521 // 16975: }
9522 60, 7, // 16980: case 0x3c: {
9523 OPC_CheckPredicate, 21, // 16982: check predicate 21
9524 OPC_Decode, 224, 130, 1, 117, // 16984: decode to VWMACCU_VV using decoder 117
9525 // 16984: }
9526 61, 7, // 16989: case 0x3d: {
9527 OPC_CheckPredicate, 21, // 16991: check predicate 21
9528 OPC_Decode, 226, 130, 1, 117, // 16993: decode to VWMACC_VV using decoder 117
9529 // 16993: }
9530 62, 7, // 16998: case 0x3e: {
9531 OPC_CheckPredicate, 93, // 17000: check predicate 93
9532 OPC_Decode, 253, 130, 1, 111, // 17002: decode to VZIP_VV using decoder 111
9533 // 17002: }
9534 63, 0, // 17007: case 0x3f: {
9535 OPC_CheckPredicate, 21, // 17009: check predicate 21
9536 OPC_Decode, 221, 130, 1, 117, // 17011: decode to VWMACCSU_VV using decoder 117
9537 // 17011: }
9538 // 17011: } // switch Inst[31:26]
9539 // 17011: }
9540 3, 181, 3, // 17016: case 0x3: {
9541 OPC_SwitchField, 27, 5, // 17019: switch Inst[31:27] {
9542 0, 10, // 17022: case 0x0: {
9543 OPC_CheckPredicate, 21, // 17024: check predicate 21
9544 OPC_CheckField, 26, 1, 0, // 17026: check Inst[26] == 0x0
9545 OPC_Decode, 208, 125, 122, // 17030: decode to VADD_VI using decoder 122
9546 // 17030: }
9547 1, 11, // 17034: case 0x1: {
9548 OPC_CheckPredicate, 21, // 17036: check predicate 21
9549 OPC_CheckField, 26, 1, 1, // 17038: check Inst[26] == 0x1
9550 OPC_Decode, 149, 129, 1, 122, // 17042: decode to VRSUB_VI using decoder 122
9551 // 17042: }
9552 4, 10, // 17047: case 0x4: {
9553 OPC_CheckPredicate, 21, // 17049: check predicate 21
9554 OPC_CheckField, 26, 1, 1, // 17051: check Inst[26] == 0x1
9555 OPC_Decode, 224, 125, 122, // 17055: decode to VAND_VI using decoder 122
9556 // 17055: }
9557 5, 21, // 17059: case 0x5: {
9558 OPC_SwitchField, 26, 1, // 17061: switch Inst[26] {
9559 0, 7, // 17064: case 0x0: {
9560 OPC_CheckPredicate, 21, // 17066: check predicate 21
9561 OPC_Decode, 250, 128, 1, 122, // 17068: decode to VOR_VI using decoder 122
9562 // 17068: }
9563 1, 0, // 17073: case 0x1: {
9564 OPC_CheckPredicate, 21, // 17075: check predicate 21
9565 OPC_Decode, 247, 130, 1, 122, // 17077: decode to VXOR_VI using decoder 122
9566 // 17077: }
9567 // 17077: } // switch Inst[26]
9568 // 17077: }
9569 6, 11, // 17082: case 0x6: {
9570 OPC_CheckPredicate, 21, // 17084: check predicate 21
9571 OPC_CheckField, 26, 1, 0, // 17086: check Inst[26] == 0x0
9572 OPC_Decode, 141, 129, 1, 123, // 17090: decode to VRGATHER_VI using decoder 123
9573 // 17090: }
9574 7, 21, // 17095: case 0x7: {
9575 OPC_SwitchField, 26, 1, // 17097: switch Inst[26] {
9576 0, 7, // 17100: case 0x0: {
9577 OPC_CheckPredicate, 21, // 17102: check predicate 21
9578 OPC_Decode, 180, 129, 1, 123, // 17104: decode to VSLIDEUP_VI using decoder 123
9579 // 17104: }
9580 1, 0, // 17109: case 0x1: {
9581 OPC_CheckPredicate, 21, // 17111: check predicate 21
9582 OPC_Decode, 178, 129, 1, 123, // 17113: decode to VSLIDEDOWN_VI using decoder 123
9583 // 17113: }
9584 // 17113: } // switch Inst[26]
9585 // 17113: }
9586 8, 29, // 17118: case 0x8: {
9587 OPC_SwitchField, 25, 2, // 17120: switch Inst[26:25] {
9588 0, 6, // 17123: case 0x0: {
9589 OPC_CheckPredicate, 21, // 17125: check predicate 21
9590 OPC_Decode, 205, 125, 124, // 17127: decode to VADC_VIM using decoder 124
9591 // 17127: }
9592 2, 7, // 17131: case 0x2: {
9593 OPC_CheckPredicate, 21, // 17133: check predicate 21
9594 OPC_Decode, 154, 128, 1, 124, // 17135: decode to VMADC_VIM using decoder 124
9595 // 17135: }
9596 3, 0, // 17140: case 0x3: {
9597 OPC_CheckPredicate, 21, // 17142: check predicate 21
9598 OPC_Decode, 153, 128, 1, 125, // 17144: decode to VMADC_VI using decoder 125
9599 // 17144: }
9600 // 17144: } // switch Inst[26:25]
9601 // 17144: }
9602 10, 7, // 17149: case 0xa: {
9603 OPC_CheckPredicate, 92, // 17151: check predicate 92
9604 OPC_Decode, 146, 129, 1, 126, // 17153: decode to VROR_VI using decoder 126
9605 // 17153: }
9606 11, 25, // 17158: case 0xb: {
9607 OPC_SwitchField, 25, 2, // 17160: switch Inst[26:25] {
9608 2, 7, // 17163: case 0x2: {
9609 OPC_CheckPredicate, 21, // 17165: check predicate 21
9610 OPC_Decode, 167, 128, 1, 124, // 17167: decode to VMERGE_VIM using decoder 124
9611 // 17167: }
9612 3, 0, // 17172: case 0x3: {
9613 OPC_CheckPredicate, 21, // 17174: check predicate 21
9614 OPC_CheckField, 20, 5, 0, // 17176: check Inst[24:20] == 0x0
9615 OPC_Decode, 228, 128, 1, 127, // 17180: decode to VMV_V_I using decoder 127
9616 // 17180: }
9617 // 17180: } // switch Inst[26:25]
9618 // 17180: }
9619 12, 21, // 17185: case 0xc: {
9620 OPC_SwitchField, 26, 1, // 17187: switch Inst[26] {
9621 0, 7, // 17190: case 0x0: {
9622 OPC_CheckPredicate, 21, // 17192: check predicate 21
9623 OPC_Decode, 193, 128, 1, 122, // 17194: decode to VMSEQ_VI using decoder 122
9624 // 17194: }
9625 1, 0, // 17199: case 0x1: {
9626 OPC_CheckPredicate, 21, // 17201: check predicate 21
9627 OPC_Decode, 211, 128, 1, 122, // 17203: decode to VMSNE_VI using decoder 122
9628 // 17203: }
9629 // 17203: } // switch Inst[26]
9630 // 17203: }
9631 14, 21, // 17208: case 0xe: {
9632 OPC_SwitchField, 26, 1, // 17210: switch Inst[26] {
9633 0, 7, // 17213: case 0x0: {
9634 OPC_CheckPredicate, 21, // 17215: check predicate 21
9635 OPC_Decode, 201, 128, 1, 122, // 17217: decode to VMSLEU_VI using decoder 122
9636 // 17217: }
9637 1, 0, // 17222: case 0x1: {
9638 OPC_CheckPredicate, 21, // 17224: check predicate 21
9639 OPC_Decode, 204, 128, 1, 122, // 17226: decode to VMSLE_VI using decoder 122
9640 // 17226: }
9641 // 17226: } // switch Inst[26]
9642 // 17226: }
9643 15, 21, // 17231: case 0xf: {
9644 OPC_SwitchField, 26, 1, // 17233: switch Inst[26] {
9645 0, 7, // 17236: case 0x0: {
9646 OPC_CheckPredicate, 21, // 17238: check predicate 21
9647 OPC_Decode, 196, 128, 1, 122, // 17240: decode to VMSGTU_VI using decoder 122
9648 // 17240: }
9649 1, 0, // 17245: case 0x1: {
9650 OPC_CheckPredicate, 21, // 17247: check predicate 21
9651 OPC_Decode, 198, 128, 1, 122, // 17249: decode to VMSGT_VI using decoder 122
9652 // 17249: }
9653 // 17249: } // switch Inst[26]
9654 // 17249: }
9655 16, 21, // 17254: case 0x10: {
9656 OPC_SwitchField, 26, 1, // 17256: switch Inst[26] {
9657 0, 7, // 17259: case 0x0: {
9658 OPC_CheckPredicate, 21, // 17261: check predicate 21
9659 OPC_Decode, 155, 129, 1, 122, // 17263: decode to VSADDU_VI using decoder 122
9660 // 17263: }
9661 1, 0, // 17268: case 0x1: {
9662 OPC_CheckPredicate, 21, // 17270: check predicate 21
9663 OPC_Decode, 158, 129, 1, 122, // 17272: decode to VSADD_VI using decoder 122
9664 // 17272: }
9665 // 17272: } // switch Inst[26]
9666 // 17272: }
9667 18, 11, // 17277: case 0x12: {
9668 OPC_CheckPredicate, 21, // 17279: check predicate 21
9669 OPC_CheckField, 26, 1, 1, // 17281: check Inst[26] == 0x1
9670 OPC_Decode, 182, 129, 1, 123, // 17285: decode to VSLL_VI using decoder 123
9671 // 17285: }
9672 19, 59, // 17290: case 0x13: {
9673 OPC_SwitchField, 15, 5, // 17292: switch Inst[19:15] {
9674 0, 12, // 17295: case 0x0: {
9675 OPC_CheckPredicate, 21, // 17297: check predicate 21
9676 OPC_CheckField, 25, 2, 3, // 17299: check Inst[26:25] == 0x3
9677 OPC_Decode, 223, 128, 1, 128, 1, // 17303: decode to VMV1R_V using decoder 128
9678 // 17303: }
9679 1, 12, // 17309: case 0x1: {
9680 OPC_CheckPredicate, 21, // 17311: check predicate 21
9681 OPC_CheckField, 25, 2, 3, // 17313: check Inst[26:25] == 0x3
9682 OPC_Decode, 224, 128, 1, 129, 1, // 17317: decode to VMV2R_V using decoder 129
9683 // 17317: }
9684 3, 12, // 17323: case 0x3: {
9685 OPC_CheckPredicate, 21, // 17325: check predicate 21
9686 OPC_CheckField, 25, 2, 3, // 17327: check Inst[26:25] == 0x3
9687 OPC_Decode, 225, 128, 1, 130, 1, // 17331: decode to VMV4R_V using decoder 130
9688 // 17331: }
9689 7, 0, // 17337: case 0x7: {
9690 OPC_CheckPredicate, 21, // 17339: check predicate 21
9691 OPC_CheckField, 25, 2, 3, // 17341: check Inst[26:25] == 0x3
9692 OPC_Decode, 226, 128, 1, 131, 1, // 17345: decode to VMV8R_V using decoder 131
9693 // 17345: }
9694 // 17345: } // switch Inst[19:15]
9695 // 17345: }
9696 20, 21, // 17351: case 0x14: {
9697 OPC_SwitchField, 26, 1, // 17353: switch Inst[26] {
9698 0, 7, // 17356: case 0x0: {
9699 OPC_CheckPredicate, 21, // 17358: check predicate 21
9700 OPC_Decode, 228, 129, 1, 123, // 17360: decode to VSRL_VI using decoder 123
9701 // 17360: }
9702 1, 0, // 17365: case 0x1: {
9703 OPC_CheckPredicate, 21, // 17367: check predicate 21
9704 OPC_Decode, 225, 129, 1, 123, // 17369: decode to VSRA_VI using decoder 123
9705 // 17369: }
9706 // 17369: } // switch Inst[26]
9707 // 17369: }
9708 21, 21, // 17374: case 0x15: {
9709 OPC_SwitchField, 26, 1, // 17376: switch Inst[26] {
9710 0, 7, // 17379: case 0x0: {
9711 OPC_CheckPredicate, 21, // 17381: check predicate 21
9712 OPC_Decode, 138, 130, 1, 123, // 17383: decode to VSSRL_VI using decoder 123
9713 // 17383: }
9714 1, 0, // 17388: case 0x1: {
9715 OPC_CheckPredicate, 21, // 17390: check predicate 21
9716 OPC_Decode, 135, 130, 1, 123, // 17392: decode to VSSRA_VI using decoder 123
9717 // 17392: }
9718 // 17392: } // switch Inst[26]
9719 // 17392: }
9720 22, 21, // 17397: case 0x16: {
9721 OPC_SwitchField, 26, 1, // 17399: switch Inst[26] {
9722 0, 7, // 17402: case 0x0: {
9723 OPC_CheckPredicate, 21, // 17404: check predicate 21
9724 OPC_Decode, 247, 128, 1, 123, // 17406: decode to VNSRL_WI using decoder 123
9725 // 17406: }
9726 1, 0, // 17411: case 0x1: {
9727 OPC_CheckPredicate, 21, // 17413: check predicate 21
9728 OPC_Decode, 244, 128, 1, 123, // 17415: decode to VNSRA_WI using decoder 123
9729 // 17415: }
9730 // 17415: } // switch Inst[26]
9731 // 17415: }
9732 23, 21, // 17420: case 0x17: {
9733 OPC_SwitchField, 26, 1, // 17422: switch Inst[26] {
9734 0, 7, // 17425: case 0x0: {
9735 OPC_CheckPredicate, 21, // 17427: check predicate 21
9736 OPC_Decode, 234, 128, 1, 123, // 17429: decode to VNCLIPU_WI using decoder 123
9737 // 17429: }
9738 1, 0, // 17434: case 0x1: {
9739 OPC_CheckPredicate, 21, // 17436: check predicate 21
9740 OPC_Decode, 237, 128, 1, 123, // 17438: decode to VNCLIP_WI using decoder 123
9741 // 17438: }
9742 // 17438: } // switch Inst[26]
9743 // 17438: }
9744 26, 0, // 17443: case 0x1a: {
9745 OPC_CheckPredicate, 94, // 17445: check predicate 94
9746 OPC_CheckField, 26, 1, 1, // 17447: check Inst[26] == 0x1
9747 OPC_Decode, 236, 130, 1, 123, // 17451: decode to VWSLL_VI using decoder 123
9748 // 17451: }
9749 // 17451: } // switch Inst[31:27]
9750 // 17451: }
9751 4, 239, 3, // 17456: case 0x4: {
9752 OPC_SwitchField, 26, 6, // 17459: switch Inst[31:26] {
9753 0, 7, // 17462: case 0x0: {
9754 OPC_CheckPredicate, 21, // 17464: check predicate 21
9755 OPC_Decode, 210, 125, 132, 1, // 17466: decode to VADD_VX using decoder 132
9756 // 17466: }
9757 1, 7, // 17471: case 0x1: {
9758 OPC_CheckPredicate, 92, // 17473: check predicate 92
9759 OPC_Decode, 223, 125, 132, 1, // 17475: decode to VANDN_VX using decoder 132
9760 // 17475: }
9761 2, 8, // 17480: case 0x2: {
9762 OPC_CheckPredicate, 21, // 17482: check predicate 21
9763 OPC_Decode, 174, 130, 1, 132, 1, // 17484: decode to VSUB_VX using decoder 132
9764 // 17484: }
9765 3, 8, // 17490: case 0x3: {
9766 OPC_CheckPredicate, 21, // 17492: check predicate 21
9767 OPC_Decode, 150, 129, 1, 132, 1, // 17494: decode to VRSUB_VX using decoder 132
9768 // 17494: }
9769 4, 8, // 17500: case 0x4: {
9770 OPC_CheckPredicate, 21, // 17502: check predicate 21
9771 OPC_Decode, 181, 128, 1, 132, 1, // 17504: decode to VMINU_VX using decoder 132
9772 // 17504: }
9773 5, 8, // 17510: case 0x5: {
9774 OPC_CheckPredicate, 21, // 17512: check predicate 21
9775 OPC_Decode, 183, 128, 1, 132, 1, // 17514: decode to VMIN_VX using decoder 132
9776 // 17514: }
9777 6, 8, // 17520: case 0x6: {
9778 OPC_CheckPredicate, 21, // 17522: check predicate 21
9779 OPC_Decode, 164, 128, 1, 132, 1, // 17524: decode to VMAXU_VX using decoder 132
9780 // 17524: }
9781 7, 8, // 17530: case 0x7: {
9782 OPC_CheckPredicate, 21, // 17532: check predicate 21
9783 OPC_Decode, 166, 128, 1, 132, 1, // 17534: decode to VMAX_VX using decoder 132
9784 // 17534: }
9785 9, 7, // 17540: case 0x9: {
9786 OPC_CheckPredicate, 21, // 17542: check predicate 21
9787 OPC_Decode, 226, 125, 132, 1, // 17544: decode to VAND_VX using decoder 132
9788 // 17544: }
9789 10, 8, // 17549: case 0xa: {
9790 OPC_CheckPredicate, 21, // 17551: check predicate 21
9791 OPC_Decode, 252, 128, 1, 132, 1, // 17553: decode to VOR_VX using decoder 132
9792 // 17553: }
9793 11, 8, // 17559: case 0xb: {
9794 OPC_CheckPredicate, 21, // 17561: check predicate 21
9795 OPC_Decode, 249, 130, 1, 132, 1, // 17563: decode to VXOR_VX using decoder 132
9796 // 17563: }
9797 12, 8, // 17569: case 0xc: {
9798 OPC_CheckPredicate, 21, // 17571: check predicate 21
9799 OPC_Decode, 143, 129, 1, 132, 1, // 17573: decode to VRGATHER_VX using decoder 132
9800 // 17573: }
9801 14, 8, // 17579: case 0xe: {
9802 OPC_CheckPredicate, 21, // 17581: check predicate 21
9803 OPC_Decode, 181, 129, 1, 132, 1, // 17583: decode to VSLIDEUP_VX using decoder 132
9804 // 17583: }
9805 15, 8, // 17589: case 0xf: {
9806 OPC_CheckPredicate, 21, // 17591: check predicate 21
9807 OPC_Decode, 179, 129, 1, 132, 1, // 17593: decode to VSLIDEDOWN_VX using decoder 132
9808 // 17593: }
9809 16, 11, // 17599: case 0x10: {
9810 OPC_CheckPredicate, 21, // 17601: check predicate 21
9811 OPC_CheckField, 25, 1, 0, // 17603: check Inst[25] == 0x0
9812 OPC_Decode, 207, 125, 133, 1, // 17607: decode to VADC_VXM using decoder 133
9813 // 17607: }
9814 17, 23, // 17612: case 0x11: {
9815 OPC_SwitchField, 25, 1, // 17614: switch Inst[25] {
9816 0, 8, // 17617: case 0x0: {
9817 OPC_CheckPredicate, 21, // 17619: check predicate 21
9818 OPC_Decode, 158, 128, 1, 133, 1, // 17621: decode to VMADC_VXM using decoder 133
9819 // 17621: }
9820 1, 0, // 17627: case 0x1: {
9821 OPC_CheckPredicate, 21, // 17629: check predicate 21
9822 OPC_Decode, 157, 128, 1, 134, 1, // 17631: decode to VMADC_VX using decoder 134
9823 // 17631: }
9824 // 17631: } // switch Inst[25]
9825 // 17631: }
9826 18, 12, // 17637: case 0x12: {
9827 OPC_CheckPredicate, 21, // 17639: check predicate 21
9828 OPC_CheckField, 25, 1, 0, // 17641: check Inst[25] == 0x0
9829 OPC_Decode, 162, 129, 1, 133, 1, // 17645: decode to VSBC_VXM using decoder 133
9830 // 17645: }
9831 19, 23, // 17651: case 0x13: {
9832 OPC_SwitchField, 25, 1, // 17653: switch Inst[25] {
9833 0, 8, // 17656: case 0x0: {
9834 OPC_CheckPredicate, 21, // 17658: check predicate 21
9835 OPC_Decode, 191, 128, 1, 133, 1, // 17660: decode to VMSBC_VXM using decoder 133
9836 // 17660: }
9837 1, 0, // 17666: case 0x1: {
9838 OPC_CheckPredicate, 21, // 17668: check predicate 21
9839 OPC_Decode, 190, 128, 1, 134, 1, // 17670: decode to VMSBC_VX using decoder 134
9840 // 17670: }
9841 // 17670: } // switch Inst[25]
9842 // 17670: }
9843 20, 8, // 17676: case 0x14: {
9844 OPC_CheckPredicate, 92, // 17678: check predicate 92
9845 OPC_Decode, 148, 129, 1, 132, 1, // 17680: decode to VROR_VX using decoder 132
9846 // 17680: }
9847 21, 8, // 17686: case 0x15: {
9848 OPC_CheckPredicate, 92, // 17688: check predicate 92
9849 OPC_Decode, 145, 129, 1, 132, 1, // 17690: decode to VROL_VX using decoder 132
9850 // 17690: }
9851 23, 26, // 17696: case 0x17: {
9852 OPC_SwitchField, 25, 1, // 17698: switch Inst[25] {
9853 0, 8, // 17701: case 0x0: {
9854 OPC_CheckPredicate, 21, // 17703: check predicate 21
9855 OPC_Decode, 169, 128, 1, 133, 1, // 17705: decode to VMERGE_VXM using decoder 133
9856 // 17705: }
9857 1, 0, // 17711: case 0x1: {
9858 OPC_CheckPredicate, 21, // 17713: check predicate 21
9859 OPC_CheckField, 20, 5, 0, // 17715: check Inst[24:20] == 0x0
9860 OPC_Decode, 230, 128, 1, 2, // 17719: decode to VMV_V_X using decoder 2
9861 // 17719: }
9862 // 17719: } // switch Inst[25]
9863 // 17719: }
9864 24, 8, // 17724: case 0x18: {
9865 OPC_CheckPredicate, 21, // 17726: check predicate 21
9866 OPC_Decode, 195, 128, 1, 132, 1, // 17728: decode to VMSEQ_VX using decoder 132
9867 // 17728: }
9868 25, 8, // 17734: case 0x19: {
9869 OPC_CheckPredicate, 21, // 17736: check predicate 21
9870 OPC_Decode, 213, 128, 1, 132, 1, // 17738: decode to VMSNE_VX using decoder 132
9871 // 17738: }
9872 26, 8, // 17744: case 0x1a: {
9873 OPC_CheckPredicate, 21, // 17746: check predicate 21
9874 OPC_Decode, 208, 128, 1, 132, 1, // 17748: decode to VMSLTU_VX using decoder 132
9875 // 17748: }
9876 27, 8, // 17754: case 0x1b: {
9877 OPC_CheckPredicate, 21, // 17756: check predicate 21
9878 OPC_Decode, 210, 128, 1, 132, 1, // 17758: decode to VMSLT_VX using decoder 132
9879 // 17758: }
9880 28, 8, // 17764: case 0x1c: {
9881 OPC_CheckPredicate, 21, // 17766: check predicate 21
9882 OPC_Decode, 203, 128, 1, 132, 1, // 17768: decode to VMSLEU_VX using decoder 132
9883 // 17768: }
9884 29, 8, // 17774: case 0x1d: {
9885 OPC_CheckPredicate, 21, // 17776: check predicate 21
9886 OPC_Decode, 206, 128, 1, 132, 1, // 17778: decode to VMSLE_VX using decoder 132
9887 // 17778: }
9888 30, 8, // 17784: case 0x1e: {
9889 OPC_CheckPredicate, 21, // 17786: check predicate 21
9890 OPC_Decode, 197, 128, 1, 132, 1, // 17788: decode to VMSGTU_VX using decoder 132
9891 // 17788: }
9892 31, 8, // 17794: case 0x1f: {
9893 OPC_CheckPredicate, 21, // 17796: check predicate 21
9894 OPC_Decode, 199, 128, 1, 132, 1, // 17798: decode to VMSGT_VX using decoder 132
9895 // 17798: }
9896 32, 8, // 17804: case 0x20: {
9897 OPC_CheckPredicate, 21, // 17806: check predicate 21
9898 OPC_Decode, 157, 129, 1, 132, 1, // 17808: decode to VSADDU_VX using decoder 132
9899 // 17808: }
9900 33, 8, // 17814: case 0x21: {
9901 OPC_CheckPredicate, 21, // 17816: check predicate 21
9902 OPC_Decode, 160, 129, 1, 132, 1, // 17818: decode to VSADD_VX using decoder 132
9903 // 17818: }
9904 34, 8, // 17824: case 0x22: {
9905 OPC_CheckPredicate, 21, // 17826: check predicate 21
9906 OPC_Decode, 170, 130, 1, 132, 1, // 17828: decode to VSSUBU_VX using decoder 132
9907 // 17828: }
9908 35, 8, // 17834: case 0x23: {
9909 OPC_CheckPredicate, 21, // 17836: check predicate 21
9910 OPC_Decode, 172, 130, 1, 132, 1, // 17838: decode to VSSUB_VX using decoder 132
9911 // 17838: }
9912 37, 8, // 17844: case 0x25: {
9913 OPC_CheckPredicate, 21, // 17846: check predicate 21
9914 OPC_Decode, 184, 129, 1, 132, 1, // 17848: decode to VSLL_VX using decoder 132
9915 // 17848: }
9916 39, 8, // 17854: case 0x27: {
9917 OPC_CheckPredicate, 21, // 17856: check predicate 21
9918 OPC_Decode, 191, 129, 1, 132, 1, // 17858: decode to VSMUL_VX using decoder 132
9919 // 17858: }
9920 40, 8, // 17864: case 0x28: {
9921 OPC_CheckPredicate, 21, // 17866: check predicate 21
9922 OPC_Decode, 230, 129, 1, 132, 1, // 17868: decode to VSRL_VX using decoder 132
9923 // 17868: }
9924 41, 8, // 17874: case 0x29: {
9925 OPC_CheckPredicate, 21, // 17876: check predicate 21
9926 OPC_Decode, 227, 129, 1, 132, 1, // 17878: decode to VSRA_VX using decoder 132
9927 // 17878: }
9928 42, 8, // 17884: case 0x2a: {
9929 OPC_CheckPredicate, 21, // 17886: check predicate 21
9930 OPC_Decode, 140, 130, 1, 132, 1, // 17888: decode to VSSRL_VX using decoder 132
9931 // 17888: }
9932 43, 8, // 17894: case 0x2b: {
9933 OPC_CheckPredicate, 21, // 17896: check predicate 21
9934 OPC_Decode, 137, 130, 1, 132, 1, // 17898: decode to VSSRA_VX using decoder 132
9935 // 17898: }
9936 44, 8, // 17904: case 0x2c: {
9937 OPC_CheckPredicate, 21, // 17906: check predicate 21
9938 OPC_Decode, 249, 128, 1, 132, 1, // 17908: decode to VNSRL_WX using decoder 132
9939 // 17908: }
9940 45, 8, // 17914: case 0x2d: {
9941 OPC_CheckPredicate, 21, // 17916: check predicate 21
9942 OPC_Decode, 246, 128, 1, 132, 1, // 17918: decode to VNSRA_WX using decoder 132
9943 // 17918: }
9944 46, 8, // 17924: case 0x2e: {
9945 OPC_CheckPredicate, 21, // 17926: check predicate 21
9946 OPC_Decode, 236, 128, 1, 132, 1, // 17928: decode to VNCLIPU_WX using decoder 132
9947 // 17928: }
9948 47, 8, // 17934: case 0x2f: {
9949 OPC_CheckPredicate, 21, // 17936: check predicate 21
9950 OPC_Decode, 239, 128, 1, 132, 1, // 17938: decode to VNCLIP_WX using decoder 132
9951 // 17938: }
9952 53, 0, // 17944: case 0x35: {
9953 OPC_CheckPredicate, 94, // 17946: check predicate 94
9954 OPC_Decode, 238, 130, 1, 132, 1, // 17948: decode to VWSLL_VX using decoder 132
9955 // 17948: }
9956 // 17948: } // switch Inst[31:26]
9957 // 17948: }
9958 5, 254, 2, // 17954: case 0x5: {
9959 OPC_SwitchField, 26, 6, // 17957: switch Inst[31:26] {
9960 0, 7, // 17960: case 0x0: {
9961 OPC_CheckPredicate, 95, // 17962: check predicate 95
9962 OPC_Decode, 253, 125, 135, 1, // 17964: decode to VFADD_VF using decoder 135
9963 // 17964: }
9964 2, 7, // 17969: case 0x2: {
9965 OPC_CheckPredicate, 95, // 17971: check predicate 95
9966 OPC_Decode, 192, 126, 135, 1, // 17973: decode to VFSUB_VF using decoder 135
9967 // 17973: }
9968 4, 7, // 17978: case 0x4: {
9969 OPC_CheckPredicate, 95, // 17980: check predicate 95
9970 OPC_Decode, 144, 126, 135, 1, // 17982: decode to VFMIN_VF using decoder 135
9971 // 17982: }
9972 6, 7, // 17987: case 0x6: {
9973 OPC_CheckPredicate, 95, // 17989: check predicate 95
9974 OPC_Decode, 141, 126, 135, 1, // 17991: decode to VFMAX_VF using decoder 135
9975 // 17991: }
9976 8, 7, // 17996: case 0x8: {
9977 OPC_CheckPredicate, 95, // 17998: check predicate 95
9978 OPC_Decode, 187, 126, 135, 1, // 18000: decode to VFSGNJ_VF using decoder 135
9979 // 18000: }
9980 9, 7, // 18005: case 0x9: {
9981 OPC_CheckPredicate, 95, // 18007: check predicate 95
9982 OPC_Decode, 183, 126, 135, 1, // 18009: decode to VFSGNJN_VF using decoder 135
9983 // 18009: }
9984 10, 7, // 18014: case 0xa: {
9985 OPC_CheckPredicate, 95, // 18016: check predicate 95
9986 OPC_Decode, 185, 126, 135, 1, // 18018: decode to VFSGNJX_VF using decoder 135
9987 // 18018: }
9988 14, 7, // 18023: case 0xe: {
9989 OPC_CheckPredicate, 95, // 18025: check predicate 95
9990 OPC_Decode, 190, 126, 135, 1, // 18027: decode to VFSLIDE1UP_VF using decoder 135
9991 // 18027: }
9992 15, 7, // 18032: case 0xf: {
9993 OPC_CheckPredicate, 95, // 18034: check predicate 95
9994 OPC_Decode, 189, 126, 135, 1, // 18036: decode to VFSLIDE1DOWN_VF using decoder 135
9995 // 18036: }
9996 16, 11, // 18041: case 0x10: {
9997 OPC_CheckPredicate, 95, // 18043: check predicate 95
9998 OPC_CheckField, 20, 6, 32, // 18045: check Inst[25:20] == 0x20
9999 OPC_Decode, 153, 126, 136, 1, // 18049: decode to VFMV_S_F using decoder 136
10000 // 18049: }
10001 23, 25, // 18054: case 0x17: {
10002 OPC_SwitchField, 25, 1, // 18056: switch Inst[25] {
10003 0, 7, // 18059: case 0x0: {
10004 OPC_CheckPredicate, 95, // 18061: check predicate 95
10005 OPC_Decode, 143, 126, 137, 1, // 18063: decode to VFMERGE_VFM using decoder 137
10006 // 18063: }
10007 1, 0, // 18068: case 0x1: {
10008 OPC_CheckPredicate, 95, // 18070: check predicate 95
10009 OPC_CheckField, 20, 5, 0, // 18072: check Inst[24:20] == 0x0
10010 OPC_Decode, 154, 126, 138, 1, // 18076: decode to VFMV_V_F using decoder 138
10011 // 18076: }
10012 // 18076: } // switch Inst[25]
10013 // 18076: }
10014 24, 8, // 18081: case 0x18: {
10015 OPC_CheckPredicate, 95, // 18083: check predicate 95
10016 OPC_Decode, 170, 128, 1, 135, 1, // 18085: decode to VMFEQ_VF using decoder 135
10017 // 18085: }
10018 25, 8, // 18091: case 0x19: {
10019 OPC_CheckPredicate, 95, // 18093: check predicate 95
10020 OPC_Decode, 174, 128, 1, 135, 1, // 18095: decode to VMFLE_VF using decoder 135
10021 // 18095: }
10022 27, 8, // 18101: case 0x1b: {
10023 OPC_CheckPredicate, 95, // 18103: check predicate 95
10024 OPC_Decode, 176, 128, 1, 135, 1, // 18105: decode to VMFLT_VF using decoder 135
10025 // 18105: }
10026 28, 8, // 18111: case 0x1c: {
10027 OPC_CheckPredicate, 95, // 18113: check predicate 95
10028 OPC_Decode, 178, 128, 1, 135, 1, // 18115: decode to VMFNE_VF using decoder 135
10029 // 18115: }
10030 29, 8, // 18121: case 0x1d: {
10031 OPC_CheckPredicate, 95, // 18123: check predicate 95
10032 OPC_Decode, 173, 128, 1, 135, 1, // 18125: decode to VMFGT_VF using decoder 135
10033 // 18125: }
10034 31, 8, // 18131: case 0x1f: {
10035 OPC_CheckPredicate, 95, // 18133: check predicate 95
10036 OPC_Decode, 172, 128, 1, 135, 1, // 18135: decode to VMFGE_VF using decoder 135
10037 // 18135: }
10038 32, 7, // 18141: case 0x20: {
10039 OPC_CheckPredicate, 95, // 18143: check predicate 95
10040 OPC_Decode, 134, 126, 135, 1, // 18145: decode to VFDIV_VF using decoder 135
10041 // 18145: }
10042 33, 7, // 18150: case 0x21: {
10043 OPC_CheckPredicate, 95, // 18152: check predicate 95
10044 OPC_Decode, 175, 126, 135, 1, // 18154: decode to VFRDIV_VF using decoder 135
10045 // 18154: }
10046 36, 7, // 18159: case 0x24: {
10047 OPC_CheckPredicate, 95, // 18161: check predicate 95
10048 OPC_Decode, 150, 126, 135, 1, // 18163: decode to VFMUL_VF using decoder 135
10049 // 18163: }
10050 39, 7, // 18168: case 0x27: {
10051 OPC_CheckPredicate, 95, // 18170: check predicate 95
10052 OPC_Decode, 182, 126, 135, 1, // 18172: decode to VFRSUB_VF using decoder 135
10053 // 18172: }
10054 40, 7, // 18177: case 0x28: {
10055 OPC_CheckPredicate, 95, // 18179: check predicate 95
10056 OPC_Decode, 139, 126, 139, 1, // 18181: decode to VFMADD_VF using decoder 139
10057 // 18181: }
10058 41, 7, // 18186: case 0x29: {
10059 OPC_CheckPredicate, 95, // 18188: check predicate 95
10060 OPC_Decode, 169, 126, 139, 1, // 18190: decode to VFNMADD_VF using decoder 139
10061 // 18190: }
10062 42, 7, // 18195: case 0x2a: {
10063 OPC_CheckPredicate, 95, // 18197: check predicate 95
10064 OPC_Decode, 148, 126, 139, 1, // 18199: decode to VFMSUB_VF using decoder 139
10065 // 18199: }
10066 43, 7, // 18204: case 0x2b: {
10067 OPC_CheckPredicate, 95, // 18206: check predicate 95
10068 OPC_Decode, 173, 126, 139, 1, // 18208: decode to VFNMSUB_VF using decoder 139
10069 // 18208: }
10070 44, 7, // 18213: case 0x2c: {
10071 OPC_CheckPredicate, 95, // 18215: check predicate 95
10072 OPC_Decode, 137, 126, 139, 1, // 18217: decode to VFMACC_VF using decoder 139
10073 // 18217: }
10074 45, 7, // 18222: case 0x2d: {
10075 OPC_CheckPredicate, 95, // 18224: check predicate 95
10076 OPC_Decode, 167, 126, 139, 1, // 18226: decode to VFNMACC_VF using decoder 139
10077 // 18226: }
10078 46, 7, // 18231: case 0x2e: {
10079 OPC_CheckPredicate, 95, // 18233: check predicate 95
10080 OPC_Decode, 146, 126, 139, 1, // 18235: decode to VFMSAC_VF using decoder 139
10081 // 18235: }
10082 47, 7, // 18240: case 0x2f: {
10083 OPC_CheckPredicate, 95, // 18242: check predicate 95
10084 OPC_Decode, 171, 126, 139, 1, // 18244: decode to VFNMSAC_VF using decoder 139
10085 // 18244: }
10086 48, 7, // 18249: case 0x30: {
10087 OPC_CheckPredicate, 95, // 18251: check predicate 95
10088 OPC_Decode, 194, 126, 135, 1, // 18253: decode to VFWADD_VF using decoder 135
10089 // 18253: }
10090 50, 7, // 18258: case 0x32: {
10091 OPC_CheckPredicate, 95, // 18260: check predicate 95
10092 OPC_Decode, 220, 126, 135, 1, // 18262: decode to VFWSUB_VF using decoder 135
10093 // 18262: }
10094 52, 7, // 18267: case 0x34: {
10095 OPC_CheckPredicate, 95, // 18269: check predicate 95
10096 OPC_Decode, 196, 126, 135, 1, // 18271: decode to VFWADD_WF using decoder 135
10097 // 18271: }
10098 54, 7, // 18276: case 0x36: {
10099 OPC_CheckPredicate, 95, // 18278: check predicate 95
10100 OPC_Decode, 222, 126, 135, 1, // 18280: decode to VFWSUB_WF using decoder 135
10101 // 18280: }
10102 56, 7, // 18285: case 0x38: {
10103 OPC_CheckPredicate, 95, // 18287: check predicate 95
10104 OPC_Decode, 212, 126, 135, 1, // 18289: decode to VFWMUL_VF using decoder 135
10105 // 18289: }
10106 59, 7, // 18294: case 0x3b: {
10107 OPC_CheckPredicate, 98, // 18296: check predicate 98
10108 OPC_Decode, 206, 126, 139, 1, // 18298: decode to VFWMACCBF16_VF using decoder 139
10109 // 18298: }
10110 60, 7, // 18303: case 0x3c: {
10111 OPC_CheckPredicate, 95, // 18305: check predicate 95
10112 OPC_Decode, 208, 126, 139, 1, // 18307: decode to VFWMACC_VF using decoder 139
10113 // 18307: }
10114 61, 7, // 18312: case 0x3d: {
10115 OPC_CheckPredicate, 95, // 18314: check predicate 95
10116 OPC_Decode, 214, 126, 139, 1, // 18316: decode to VFWNMACC_VF using decoder 139
10117 // 18316: }
10118 62, 7, // 18321: case 0x3e: {
10119 OPC_CheckPredicate, 95, // 18323: check predicate 95
10120 OPC_Decode, 210, 126, 139, 1, // 18325: decode to VFWMSAC_VF using decoder 139
10121 // 18325: }
10122 63, 0, // 18330: case 0x3f: {
10123 OPC_CheckPredicate, 95, // 18332: check predicate 95
10124 OPC_Decode, 216, 126, 139, 1, // 18334: decode to VFWNMSAC_VF using decoder 139
10125 // 18334: }
10126 // 18334: } // switch Inst[31:26]
10127 // 18334: }
10128 6, 139, 3, // 18339: case 0x6: {
10129 OPC_SwitchField, 26, 6, // 18342: switch Inst[31:26] {
10130 8, 7, // 18345: case 0x8: {
10131 OPC_CheckPredicate, 21, // 18347: check predicate 21
10132 OPC_Decode, 199, 125, 132, 1, // 18349: decode to VAADDU_VX using decoder 132
10133 // 18349: }
10134 9, 7, // 18354: case 0x9: {
10135 OPC_CheckPredicate, 21, // 18356: check predicate 21
10136 OPC_Decode, 201, 125, 132, 1, // 18358: decode to VAADD_VX using decoder 132
10137 // 18358: }
10138 10, 7, // 18363: case 0xa: {
10139 OPC_CheckPredicate, 21, // 18365: check predicate 21
10140 OPC_Decode, 228, 125, 132, 1, // 18367: decode to VASUBU_VX using decoder 132
10141 // 18367: }
10142 11, 7, // 18372: case 0xb: {
10143 OPC_CheckPredicate, 21, // 18374: check predicate 21
10144 OPC_Decode, 230, 125, 132, 1, // 18376: decode to VASUB_VX using decoder 132
10145 // 18376: }
10146 12, 7, // 18381: case 0xc: {
10147 OPC_CheckPredicate, 99, // 18383: check predicate 99
10148 OPC_Decode, 236, 125, 132, 1, // 18385: decode to VCLMUL_VX using decoder 132
10149 // 18385: }
10150 13, 7, // 18390: case 0xd: {
10151 OPC_CheckPredicate, 99, // 18392: check predicate 99
10152 OPC_Decode, 234, 125, 132, 1, // 18394: decode to VCLMULH_VX using decoder 132
10153 // 18394: }
10154 14, 8, // 18399: case 0xe: {
10155 OPC_CheckPredicate, 21, // 18401: check predicate 21
10156 OPC_Decode, 177, 129, 1, 132, 1, // 18403: decode to VSLIDE1UP_VX using decoder 132
10157 // 18403: }
10158 15, 8, // 18409: case 0xf: {
10159 OPC_CheckPredicate, 21, // 18411: check predicate 21
10160 OPC_Decode, 176, 129, 1, 132, 1, // 18413: decode to VSLIDE1DOWN_VX using decoder 132
10161 // 18413: }
10162 16, 12, // 18419: case 0x10: {
10163 OPC_CheckPredicate, 21, // 18421: check predicate 21
10164 OPC_CheckField, 20, 6, 32, // 18423: check Inst[25:20] == 0x20
10165 OPC_Decode, 227, 128, 1, 140, 1, // 18427: decode to VMV_S_X using decoder 140
10166 // 18427: }
10167 32, 7, // 18433: case 0x20: {
10168 OPC_CheckPredicate, 21, // 18435: check predicate 21
10169 OPC_Decode, 243, 125, 132, 1, // 18437: decode to VDIVU_VX using decoder 132
10170 // 18437: }
10171 33, 7, // 18442: case 0x21: {
10172 OPC_CheckPredicate, 21, // 18444: check predicate 21
10173 OPC_Decode, 245, 125, 132, 1, // 18446: decode to VDIV_VX using decoder 132
10174 // 18446: }
10175 34, 8, // 18451: case 0x22: {
10176 OPC_CheckPredicate, 21, // 18453: check predicate 21
10177 OPC_Decode, 136, 129, 1, 132, 1, // 18455: decode to VREMU_VX using decoder 132
10178 // 18455: }
10179 35, 8, // 18461: case 0x23: {
10180 OPC_CheckPredicate, 21, // 18463: check predicate 21
10181 OPC_Decode, 138, 129, 1, 132, 1, // 18465: decode to VREM_VX using decoder 132
10182 // 18465: }
10183 36, 8, // 18471: case 0x24: {
10184 OPC_CheckPredicate, 21, // 18473: check predicate 21
10185 OPC_Decode, 218, 128, 1, 132, 1, // 18475: decode to VMULHU_VX using decoder 132
10186 // 18475: }
10187 37, 8, // 18481: case 0x25: {
10188 OPC_CheckPredicate, 21, // 18483: check predicate 21
10189 OPC_Decode, 222, 128, 1, 132, 1, // 18485: decode to VMUL_VX using decoder 132
10190 // 18485: }
10191 38, 8, // 18491: case 0x26: {
10192 OPC_CheckPredicate, 21, // 18493: check predicate 21
10193 OPC_Decode, 216, 128, 1, 132, 1, // 18495: decode to VMULHSU_VX using decoder 132
10194 // 18495: }
10195 39, 8, // 18501: case 0x27: {
10196 OPC_CheckPredicate, 21, // 18503: check predicate 21
10197 OPC_Decode, 220, 128, 1, 132, 1, // 18505: decode to VMULH_VX using decoder 132
10198 // 18505: }
10199 40, 7, // 18511: case 0x28: {
10200 OPC_CheckPredicate, 101, // 18513: check predicate 101
10201 OPC_Decode, 250, 125, 141, 1, // 18515: decode to VDOTA4U_VX using decoder 141
10202 // 18515: }
10203 41, 8, // 18520: case 0x29: {
10204 OPC_CheckPredicate, 21, // 18522: check predicate 21
10205 OPC_Decode, 160, 128, 1, 142, 1, // 18524: decode to VMADD_VX using decoder 142
10206 // 18524: }
10207 42, 7, // 18530: case 0x2a: {
10208 OPC_CheckPredicate, 101, // 18532: check predicate 101
10209 OPC_Decode, 247, 125, 141, 1, // 18534: decode to VDOTA4SU_VX using decoder 141
10210 // 18534: }
10211 43, 8, // 18539: case 0x2b: {
10212 OPC_CheckPredicate, 21, // 18541: check predicate 21
10213 OPC_Decode, 243, 128, 1, 142, 1, // 18543: decode to VNMSUB_VX using decoder 142
10214 // 18543: }
10215 44, 7, // 18549: case 0x2c: {
10216 OPC_CheckPredicate, 101, // 18551: check predicate 101
10217 OPC_Decode, 252, 125, 141, 1, // 18553: decode to VDOTA4_VX using decoder 141
10218 // 18553: }
10219 45, 8, // 18558: case 0x2d: {
10220 OPC_CheckPredicate, 21, // 18560: check predicate 21
10221 OPC_Decode, 152, 128, 1, 142, 1, // 18562: decode to VMACC_VX using decoder 142
10222 // 18562: }
10223 46, 7, // 18568: case 0x2e: {
10224 OPC_CheckPredicate, 101, // 18570: check predicate 101
10225 OPC_Decode, 248, 125, 141, 1, // 18572: decode to VDOTA4US_VX using decoder 141
10226 // 18572: }
10227 47, 8, // 18577: case 0x2f: {
10228 OPC_CheckPredicate, 21, // 18579: check predicate 21
10229 OPC_Decode, 241, 128, 1, 142, 1, // 18581: decode to VNMSAC_VX using decoder 142
10230 // 18581: }
10231 48, 8, // 18587: case 0x30: {
10232 OPC_CheckPredicate, 21, // 18589: check predicate 21
10233 OPC_Decode, 214, 130, 1, 132, 1, // 18591: decode to VWADDU_VX using decoder 132
10234 // 18591: }
10235 49, 8, // 18597: case 0x31: {
10236 OPC_CheckPredicate, 21, // 18599: check predicate 21
10237 OPC_Decode, 218, 130, 1, 132, 1, // 18601: decode to VWADD_VX using decoder 132
10238 // 18601: }
10239 50, 8, // 18607: case 0x32: {
10240 OPC_CheckPredicate, 21, // 18609: check predicate 21
10241 OPC_Decode, 240, 130, 1, 132, 1, // 18611: decode to VWSUBU_VX using decoder 132
10242 // 18611: }
10243 51, 8, // 18617: case 0x33: {
10244 OPC_CheckPredicate, 21, // 18619: check predicate 21
10245 OPC_Decode, 244, 130, 1, 132, 1, // 18621: decode to VWSUB_VX using decoder 132
10246 // 18621: }
10247 52, 8, // 18627: case 0x34: {
10248 OPC_CheckPredicate, 21, // 18629: check predicate 21
10249 OPC_Decode, 216, 130, 1, 132, 1, // 18631: decode to VWADDU_WX using decoder 132
10250 // 18631: }
10251 53, 8, // 18637: case 0x35: {
10252 OPC_CheckPredicate, 21, // 18639: check predicate 21
10253 OPC_Decode, 220, 130, 1, 132, 1, // 18641: decode to VWADD_WX using decoder 132
10254 // 18641: }
10255 54, 8, // 18647: case 0x36: {
10256 OPC_CheckPredicate, 21, // 18649: check predicate 21
10257 OPC_Decode, 242, 130, 1, 132, 1, // 18651: decode to VWSUBU_WX using decoder 132
10258 // 18651: }
10259 55, 8, // 18657: case 0x37: {
10260 OPC_CheckPredicate, 21, // 18659: check predicate 21
10261 OPC_Decode, 246, 130, 1, 132, 1, // 18661: decode to VWSUB_WX using decoder 132
10262 // 18661: }
10263 56, 8, // 18667: case 0x38: {
10264 OPC_CheckPredicate, 21, // 18669: check predicate 21
10265 OPC_Decode, 231, 130, 1, 132, 1, // 18671: decode to VWMULU_VX using decoder 132
10266 // 18671: }
10267 58, 8, // 18677: case 0x3a: {
10268 OPC_CheckPredicate, 21, // 18679: check predicate 21
10269 OPC_Decode, 229, 130, 1, 132, 1, // 18681: decode to VWMULSU_VX using decoder 132
10270 // 18681: }
10271 59, 8, // 18687: case 0x3b: {
10272 OPC_CheckPredicate, 21, // 18689: check predicate 21
10273 OPC_Decode, 233, 130, 1, 132, 1, // 18691: decode to VWMUL_VX using decoder 132
10274 // 18691: }
10275 60, 8, // 18697: case 0x3c: {
10276 OPC_CheckPredicate, 21, // 18699: check predicate 21
10277 OPC_Decode, 225, 130, 1, 142, 1, // 18701: decode to VWMACCU_VX using decoder 142
10278 // 18701: }
10279 61, 8, // 18707: case 0x3d: {
10280 OPC_CheckPredicate, 21, // 18709: check predicate 21
10281 OPC_Decode, 227, 130, 1, 142, 1, // 18711: decode to VWMACC_VX using decoder 142
10282 // 18711: }
10283 62, 8, // 18717: case 0x3e: {
10284 OPC_CheckPredicate, 21, // 18719: check predicate 21
10285 OPC_Decode, 223, 130, 1, 142, 1, // 18721: decode to VWMACCUS_VX using decoder 142
10286 // 18721: }
10287 63, 0, // 18727: case 0x3f: {
10288 OPC_CheckPredicate, 21, // 18729: check predicate 21
10289 OPC_Decode, 222, 130, 1, 142, 1, // 18731: decode to VWMACCSU_VX using decoder 142
10290 // 18731: }
10291 // 18731: } // switch Inst[31:26]
10292 // 18731: }
10293 7, 0, // 18737: case 0x7: {
10294 OPC_SwitchField, 31, 1, // 18739: switch Inst[31] {
10295 0, 8, // 18742: case 0x0: {
10296 OPC_CheckPredicate, 21, // 18744: check predicate 21
10297 OPC_Decode, 169, 129, 1, 143, 1, // 18746: decode to VSETVLI using decoder 143
10298 // 18746: }
10299 1, 0, // 18752: case 0x1: {
10300 OPC_SwitchField, 30, 1, // 18754: switch Inst[30] {
10301 0, 11, // 18757: case 0x0: {
10302 OPC_CheckPredicate, 21, // 18759: check predicate 21
10303 OPC_CheckField, 25, 5, 0, // 18761: check Inst[29:25] == 0x0
10304 OPC_Decode, 168, 129, 1, 30, // 18765: decode to VSETVL using decoder 30
10305 // 18765: }
10306 1, 0, // 18770: case 0x1: {
10307 OPC_CheckPredicate, 21, // 18772: check predicate 21
10308 OPC_Decode, 167, 129, 1, 144, 1, // 18774: decode to VSETIVLI using decoder 144
10309 // 18774: }
10310 // 18774: } // switch Inst[30]
10311 // 18774: }
10312 // 18774: } // switch Inst[31]
10313 // 18774: }
10314 // 18774: } // switch Inst[14:12]
10315 // 18774: }
10316 99, 63, // 18780: case 0x63: {
10317 OPC_SwitchField, 12, 3, // 18782: switch Inst[14:12] {
10318 0, 5, // 18785: case 0x0: {
10319 OPC_Decode, 177, 110, 145, 1, // 18787: decode to BEQ using decoder 145
10320 // 18787: }
10321 1, 5, // 18792: case 0x1: {
10322 OPC_Decode, 187, 110, 145, 1, // 18794: decode to BNE using decoder 145
10323 // 18794: }
10324 2, 7, // 18799: case 0x2: {
10325 OPC_CheckPredicate, 102, // 18801: check predicate 102
10326 OPC_Decode, 178, 110, 146, 1, // 18803: decode to BEQI using decoder 146
10327 // 18803: }
10328 3, 7, // 18808: case 0x3: {
10329 OPC_CheckPredicate, 102, // 18810: check predicate 102
10330 OPC_Decode, 188, 110, 146, 1, // 18812: decode to BNEI using decoder 146
10331 // 18812: }
10332 4, 5, // 18817: case 0x4: {
10333 OPC_Decode, 185, 110, 145, 1, // 18819: decode to BLT using decoder 145
10334 // 18819: }
10335 5, 5, // 18824: case 0x5: {
10336 OPC_Decode, 181, 110, 145, 1, // 18826: decode to BGE using decoder 145
10337 // 18826: }
10338 6, 5, // 18831: case 0x6: {
10339 OPC_Decode, 186, 110, 145, 1, // 18833: decode to BLTU using decoder 145
10340 // 18833: }
10341 7, 0, // 18838: case 0x7: {
10342 OPC_Decode, 182, 110, 145, 1, // 18840: decode to BGEU using decoder 145
10343 // 18840: }
10344 // 18840: } // switch Inst[14:12]
10345 // 18840: }
10346 103, 8, // 18845: case 0x67: {
10347 OPC_CheckField, 12, 3, 0, // 18847: check Inst[14:12] == 0x0
10348 OPC_Decode, 170, 116, 0, // 18851: decode to JALR using decoder 0
10349 // 18851: }
10350 111, 5, // 18855: case 0x6f: {
10351 OPC_Decode, 169, 116, 147, 1, // 18857: decode to JAL using decoder 147
10352 // 18857: }
10353 115, 218, 6, // 18862: case 0x73: {
10354 OPC_SwitchField, 12, 3, // 18865: switch Inst[14:12] {
10355 0, 246, 1, // 18868: case 0x0: {
10356 OPC_SwitchField, 25, 7, // 18871: switch Inst[31:25] {
10357 0, 51, // 18874: case 0x0: {
10358 OPC_SwitchField, 15, 10, // 18876: switch Inst[24:15] {
10359 0, 8, // 18879: case 0x0: {
10360 OPC_CheckField, 7, 5, 0, // 18881: check Inst[11:7] == 0x0
10361 OPC_Decode, 231, 113, 13, // 18885: decode to ECALL using decoder 13
10362 // 18885: }
10363 32, 8, // 18889: case 0x20: {
10364 OPC_CheckField, 7, 5, 0, // 18891: check Inst[11:7] == 0x0
10365 OPC_Decode, 230, 113, 13, // 18895: decode to EBREAK using decoder 13
10366 // 18895: }
10367 160, 3, 11, // 18899: case 0x1a0: {
10368 OPC_CheckPredicate, 103, // 18902: check predicate 103
10369 OPC_CheckField, 7, 5, 0, // 18904: check Inst[11:7] == 0x0
10370 OPC_Decode, 137, 131, 1, 13, // 18908: decode to WRS_NTO using decoder 13
10371 // 18908: }
10372 160, 7, 0, // 18913: case 0x3a0: {
10373 OPC_CheckPredicate, 103, // 18916: check predicate 103
10374 OPC_CheckField, 7, 5, 0, // 18918: check Inst[11:7] == 0x0
10375 OPC_Decode, 138, 131, 1, 13, // 18922: decode to WRS_STO using decoder 13
10376 // 18922: }
10377 // 18922: } // switch Inst[24:15]
10378 // 18922: }
10379 8, 38, // 18927: case 0x8: {
10380 OPC_SwitchField, 15, 10, // 18929: switch Inst[24:15] {
10381 64, 8, // 18932: case 0x40: {
10382 OPC_CheckField, 7, 5, 0, // 18934: check Inst[11:7] == 0x0
10383 OPC_Decode, 177, 124, 13, // 18938: decode to SRET using decoder 13
10384 // 18938: }
10385 128, 1, 10, // 18942: case 0x80: {
10386 OPC_CheckPredicate, 104, // 18945: check predicate 104
10387 OPC_CheckField, 7, 5, 0, // 18947: check Inst[11:7] == 0x0
10388 OPC_Decode, 154, 123, 13, // 18951: decode to SCTRCLR using decoder 13
10389 // 18951: }
10390 160, 1, 0, // 18955: case 0xa0: {
10391 OPC_CheckField, 7, 5, 0, // 18958: check Inst[11:7] == 0x0
10392 OPC_Decode, 130, 131, 1, 13, // 18962: decode to WFI using decoder 13
10393 // 18962: }
10394 // 18962: } // switch Inst[24:15]
10395 // 18962: }
10396 9, 9, // 18967: case 0x9: {
10397 OPC_CheckField, 7, 5, 0, // 18969: check Inst[11:7] == 0x0
10398 OPC_Decode, 170, 123, 148, 1, // 18973: decode to SFENCE_VMA using decoder 148
10399 // 18973: }
10400 11, 11, // 18978: case 0xb: {
10401 OPC_CheckPredicate, 105, // 18980: check predicate 105
10402 OPC_CheckField, 7, 5, 0, // 18982: check Inst[11:7] == 0x0
10403 OPC_Decode, 140, 124, 148, 1, // 18986: decode to SINVAL_VMA using decoder 148
10404 // 18986: }
10405 12, 27, // 18991: case 0xc: {
10406 OPC_SwitchField, 15, 10, // 18993: switch Inst[24:15] {
10407 0, 10, // 18996: case 0x0: {
10408 OPC_CheckPredicate, 105, // 18998: check predicate 105
10409 OPC_CheckField, 7, 5, 0, // 19000: check Inst[11:7] == 0x0
10410 OPC_Decode, 171, 123, 13, // 19004: decode to SFENCE_W_INVAL using decoder 13
10411 // 19004: }
10412 32, 0, // 19008: case 0x20: {
10413 OPC_CheckPredicate, 105, // 19010: check predicate 105
10414 OPC_CheckField, 7, 5, 0, // 19012: check Inst[11:7] == 0x0
10415 OPC_Decode, 169, 123, 13, // 19016: decode to SFENCE_INVAL_IR using decoder 13
10416 // 19016: }
10417 // 19016: } // switch Inst[24:15]
10418 // 19016: }
10419 17, 11, // 19020: case 0x11: {
10420 OPC_CheckPredicate, 106, // 19022: check predicate 106
10421 OPC_CheckField, 7, 5, 0, // 19024: check Inst[11:7] == 0x0
10422 OPC_Decode, 254, 115, 148, 1, // 19028: decode to HFENCE_VVMA using decoder 148
10423 // 19028: }
10424 19, 11, // 19033: case 0x13: {
10425 OPC_CheckPredicate, 105, // 19035: check predicate 105
10426 OPC_CheckField, 7, 5, 0, // 19037: check Inst[11:7] == 0x0
10427 OPC_Decode, 128, 116, 148, 1, // 19041: decode to HINVAL_VVMA using decoder 148
10428 // 19041: }
10429 24, 12, // 19046: case 0x18: {
10430 OPC_CheckField, 15, 10, 64, // 19048: check Inst[24:15] == 0x40
10431 OPC_CheckField, 7, 5, 0, // 19052: check Inst[11:7] == 0x0
10432 OPC_Decode, 165, 117, 13, // 19056: decode to MRET using decoder 13
10433 // 19056: }
10434 49, 11, // 19060: case 0x31: {
10435 OPC_CheckPredicate, 106, // 19062: check predicate 106
10436 OPC_CheckField, 7, 5, 0, // 19064: check Inst[11:7] == 0x0
10437 OPC_Decode, 253, 115, 148, 1, // 19068: decode to HFENCE_GVMA using decoder 148
10438 // 19068: }
10439 51, 11, // 19073: case 0x33: {
10440 OPC_CheckPredicate, 105, // 19075: check predicate 105
10441 OPC_CheckField, 7, 5, 0, // 19077: check Inst[11:7] == 0x0
10442 OPC_Decode, 255, 115, 148, 1, // 19081: decode to HINVAL_GVMA using decoder 148
10443 // 19081: }
10444 56, 14, // 19086: case 0x38: {
10445 OPC_CheckPredicate, 107, // 19088: check predicate 107
10446 OPC_CheckField, 15, 10, 64, // 19090: check Inst[24:15] == 0x40
10447 OPC_CheckField, 7, 5, 0, // 19094: check Inst[11:7] == 0x0
10448 OPC_Decode, 238, 116, 13, // 19098: decode to MNRET using decoder 13
10449 // 19098: }
10450 61, 0, // 19102: case 0x3d: {
10451 OPC_CheckField, 15, 10, 192, 4, // 19104: check Inst[24:15] == 0x240
10452 OPC_CheckField, 7, 5, 0, // 19109: check Inst[11:7] == 0x0
10453 OPC_Decode, 229, 113, 13, // 19113: decode to DRET using decoder 13
10454 // 19113: }
10455 // 19113: } // switch Inst[31:25]
10456 // 19113: }
10457 1, 21, // 19117: case 0x1: {
10458 OPC_Scope, 14, // 19119: try {
10459 OPC_CheckField, 7, 5, 0, // 19121: check Inst[11:7] == 0x0
10460 OPC_CheckField, 15, 17, 128, 128, 6, // 19125: check Inst[31:15] == 0x18000
10461 OPC_Decode, 190, 125, 13, // 19131: decode to UNIMP using decoder 13
10462 // 19131: } else try {
10463 OPC_Decode, 217, 110, 149, 1, // 19135: decode to CSRRW using decoder 149
10464 // 19135: }
10465 // 19135: }
10466 2, 5, // 19140: case 0x2: {
10467 OPC_Decode, 215, 110, 149, 1, // 19142: decode to CSRRS using decoder 149
10468 // 19142: }
10469 3, 5, // 19147: case 0x3: {
10470 OPC_Decode, 213, 110, 149, 1, // 19149: decode to CSRRC using decoder 149
10471 // 19149: }
10472 4, 161, 4, // 19154: case 0x4: {
10473 OPC_SwitchField, 25, 7, // 19157: switch Inst[31:25] {
10474 48, 19, // 19160: case 0x30: {
10475 OPC_SwitchField, 20, 5, // 19162: switch Inst[24:20] {
10476 0, 6, // 19165: case 0x0: {
10477 OPC_CheckPredicate, 106, // 19167: check predicate 106
10478 OPC_Decode, 131, 116, 16, // 19169: decode to HLV_B using decoder 16
10479 // 19169: }
10480 1, 0, // 19173: case 0x1: {
10481 OPC_CheckPredicate, 106, // 19175: check predicate 106
10482 OPC_Decode, 132, 116, 16, // 19177: decode to HLV_BU using decoder 16
10483 // 19177: }
10484 // 19177: } // switch Inst[24:20]
10485 // 19177: }
10486 49, 10, // 19181: case 0x31: {
10487 OPC_CheckPredicate, 106, // 19183: check predicate 106
10488 OPC_CheckField, 7, 5, 0, // 19185: check Inst[11:7] == 0x0
10489 OPC_Decode, 138, 116, 56, // 19189: decode to HSV_B using decoder 56
10490 // 19189: }
10491 50, 27, // 19193: case 0x32: {
10492 OPC_SwitchField, 20, 5, // 19195: switch Inst[24:20] {
10493 0, 6, // 19198: case 0x0: {
10494 OPC_CheckPredicate, 106, // 19200: check predicate 106
10495 OPC_Decode, 134, 116, 16, // 19202: decode to HLV_H using decoder 16
10496 // 19202: }
10497 1, 6, // 19206: case 0x1: {
10498 OPC_CheckPredicate, 106, // 19208: check predicate 106
10499 OPC_Decode, 135, 116, 16, // 19210: decode to HLV_HU using decoder 16
10500 // 19210: }
10501 3, 0, // 19214: case 0x3: {
10502 OPC_CheckPredicate, 106, // 19216: check predicate 106
10503 OPC_Decode, 129, 116, 16, // 19218: decode to HLVX_HU using decoder 16
10504 // 19218: }
10505 // 19218: } // switch Inst[24:20]
10506 // 19218: }
10507 51, 10, // 19222: case 0x33: {
10508 OPC_CheckPredicate, 106, // 19224: check predicate 106
10509 OPC_CheckField, 7, 5, 0, // 19226: check Inst[11:7] == 0x0
10510 OPC_Decode, 140, 116, 56, // 19230: decode to HSV_H using decoder 56
10511 // 19230: }
10512 52, 27, // 19234: case 0x34: {
10513 OPC_SwitchField, 20, 5, // 19236: switch Inst[24:20] {
10514 0, 6, // 19239: case 0x0: {
10515 OPC_CheckPredicate, 106, // 19241: check predicate 106
10516 OPC_Decode, 136, 116, 16, // 19243: decode to HLV_W using decoder 16
10517 // 19243: }
10518 1, 6, // 19247: case 0x1: {
10519 OPC_CheckPredicate, 108, // 19249: check predicate 108
10520 OPC_Decode, 137, 116, 16, // 19251: decode to HLV_WU using decoder 16
10521 // 19251: }
10522 3, 0, // 19255: case 0x3: {
10523 OPC_CheckPredicate, 106, // 19257: check predicate 106
10524 OPC_Decode, 130, 116, 16, // 19259: decode to HLVX_WU using decoder 16
10525 // 19259: }
10526 // 19259: } // switch Inst[24:20]
10527 // 19259: }
10528 53, 10, // 19263: case 0x35: {
10529 OPC_CheckPredicate, 106, // 19265: check predicate 106
10530 OPC_CheckField, 7, 5, 0, // 19267: check Inst[11:7] == 0x0
10531 OPC_Decode, 141, 116, 56, // 19271: decode to HSV_W using decoder 56
10532 // 19271: }
10533 54, 10, // 19275: case 0x36: {
10534 OPC_CheckPredicate, 108, // 19277: check predicate 108
10535 OPC_CheckField, 20, 5, 0, // 19279: check Inst[24:20] == 0x0
10536 OPC_Decode, 133, 116, 16, // 19283: decode to HLV_D using decoder 16
10537 // 19283: }
10538 55, 10, // 19287: case 0x37: {
10539 OPC_CheckPredicate, 108, // 19289: check predicate 108
10540 OPC_CheckField, 7, 5, 0, // 19291: check Inst[11:7] == 0x0
10541 OPC_Decode, 139, 116, 56, // 19295: decode to HSV_D using decoder 56
10542 // 19295: }
10543 64, 35, // 19299: case 0x40: {
10544 OPC_SwitchField, 20, 5, // 19301: switch Inst[24:20] {
10545 28, 6, // 19304: case 0x1c: {
10546 OPC_CheckPredicate, 109, // 19306: check predicate 109
10547 OPC_Decode, 247, 116, 16, // 19308: decode to MOP_R_0 using decoder 16
10548 // 19308: }
10549 29, 6, // 19312: case 0x1d: {
10550 OPC_CheckPredicate, 109, // 19314: check predicate 109
10551 OPC_Decode, 248, 116, 16, // 19316: decode to MOP_R_1 using decoder 16
10552 // 19316: }
10553 30, 6, // 19320: case 0x1e: {
10554 OPC_CheckPredicate, 109, // 19322: check predicate 109
10555 OPC_Decode, 131, 117, 16, // 19324: decode to MOP_R_2 using decoder 16
10556 // 19324: }
10557 31, 0, // 19328: case 0x1f: {
10558 OPC_CheckPredicate, 109, // 19330: check predicate 109
10559 OPC_Decode, 142, 117, 16, // 19332: decode to MOP_R_3 using decoder 16
10560 // 19332: }
10561 // 19332: } // switch Inst[24:20]
10562 // 19332: }
10563 65, 6, // 19336: case 0x41: {
10564 OPC_CheckPredicate, 109, // 19338: check predicate 109
10565 OPC_Decode, 239, 116, 30, // 19340: decode to MOP_RR_0 using decoder 30
10566 // 19340: }
10567 66, 35, // 19344: case 0x42: {
10568 OPC_SwitchField, 20, 5, // 19346: switch Inst[24:20] {
10569 28, 6, // 19349: case 0x1c: {
10570 OPC_CheckPredicate, 109, // 19351: check predicate 109
10571 OPC_Decode, 145, 117, 16, // 19353: decode to MOP_R_4 using decoder 16
10572 // 19353: }
10573 29, 6, // 19357: case 0x1d: {
10574 OPC_CheckPredicate, 109, // 19359: check predicate 109
10575 OPC_Decode, 146, 117, 16, // 19361: decode to MOP_R_5 using decoder 16
10576 // 19361: }
10577 30, 6, // 19365: case 0x1e: {
10578 OPC_CheckPredicate, 109, // 19367: check predicate 109
10579 OPC_Decode, 147, 117, 16, // 19369: decode to MOP_R_6 using decoder 16
10580 // 19369: }
10581 31, 0, // 19373: case 0x1f: {
10582 OPC_CheckPredicate, 109, // 19375: check predicate 109
10583 OPC_Decode, 148, 117, 16, // 19377: decode to MOP_R_7 using decoder 16
10584 // 19377: }
10585 // 19377: } // switch Inst[24:20]
10586 // 19377: }
10587 67, 6, // 19381: case 0x43: {
10588 OPC_CheckPredicate, 109, // 19383: check predicate 109
10589 OPC_Decode, 240, 116, 30, // 19385: decode to MOP_RR_1 using decoder 30
10590 // 19385: }
10591 68, 35, // 19389: case 0x44: {
10592 OPC_SwitchField, 20, 5, // 19391: switch Inst[24:20] {
10593 28, 6, // 19394: case 0x1c: {
10594 OPC_CheckPredicate, 109, // 19396: check predicate 109
10595 OPC_Decode, 149, 117, 16, // 19398: decode to MOP_R_8 using decoder 16
10596 // 19398: }
10597 29, 6, // 19402: case 0x1d: {
10598 OPC_CheckPredicate, 109, // 19404: check predicate 109
10599 OPC_Decode, 150, 117, 16, // 19406: decode to MOP_R_9 using decoder 16
10600 // 19406: }
10601 30, 6, // 19410: case 0x1e: {
10602 OPC_CheckPredicate, 109, // 19412: check predicate 109
10603 OPC_Decode, 249, 116, 16, // 19414: decode to MOP_R_10 using decoder 16
10604 // 19414: }
10605 31, 0, // 19418: case 0x1f: {
10606 OPC_CheckPredicate, 109, // 19420: check predicate 109
10607 OPC_Decode, 250, 116, 16, // 19422: decode to MOP_R_11 using decoder 16
10608 // 19422: }
10609 // 19422: } // switch Inst[24:20]
10610 // 19422: }
10611 69, 6, // 19426: case 0x45: {
10612 OPC_CheckPredicate, 109, // 19428: check predicate 109
10613 OPC_Decode, 241, 116, 30, // 19430: decode to MOP_RR_2 using decoder 30
10614 // 19430: }
10615 70, 35, // 19434: case 0x46: {
10616 OPC_SwitchField, 20, 5, // 19436: switch Inst[24:20] {
10617 28, 6, // 19439: case 0x1c: {
10618 OPC_CheckPredicate, 109, // 19441: check predicate 109
10619 OPC_Decode, 251, 116, 16, // 19443: decode to MOP_R_12 using decoder 16
10620 // 19443: }
10621 29, 6, // 19447: case 0x1d: {
10622 OPC_CheckPredicate, 109, // 19449: check predicate 109
10623 OPC_Decode, 252, 116, 16, // 19451: decode to MOP_R_13 using decoder 16
10624 // 19451: }
10625 30, 6, // 19455: case 0x1e: {
10626 OPC_CheckPredicate, 109, // 19457: check predicate 109
10627 OPC_Decode, 253, 116, 16, // 19459: decode to MOP_R_14 using decoder 16
10628 // 19459: }
10629 31, 0, // 19463: case 0x1f: {
10630 OPC_CheckPredicate, 109, // 19465: check predicate 109
10631 OPC_Decode, 254, 116, 16, // 19467: decode to MOP_R_15 using decoder 16
10632 // 19467: }
10633 // 19467: } // switch Inst[24:20]
10634 // 19467: }
10635 71, 6, // 19471: case 0x47: {
10636 OPC_CheckPredicate, 109, // 19473: check predicate 109
10637 OPC_Decode, 242, 116, 30, // 19475: decode to MOP_RR_3 using decoder 30
10638 // 19475: }
10639 96, 35, // 19479: case 0x60: {
10640 OPC_SwitchField, 20, 5, // 19481: switch Inst[24:20] {
10641 28, 6, // 19484: case 0x1c: {
10642 OPC_CheckPredicate, 109, // 19486: check predicate 109
10643 OPC_Decode, 255, 116, 16, // 19488: decode to MOP_R_16 using decoder 16
10644 // 19488: }
10645 29, 6, // 19492: case 0x1d: {
10646 OPC_CheckPredicate, 109, // 19494: check predicate 109
10647 OPC_Decode, 128, 117, 16, // 19496: decode to MOP_R_17 using decoder 16
10648 // 19496: }
10649 30, 6, // 19500: case 0x1e: {
10650 OPC_CheckPredicate, 109, // 19502: check predicate 109
10651 OPC_Decode, 129, 117, 16, // 19504: decode to MOP_R_18 using decoder 16
10652 // 19504: }
10653 31, 0, // 19508: case 0x1f: {
10654 OPC_CheckPredicate, 109, // 19510: check predicate 109
10655 OPC_Decode, 130, 117, 16, // 19512: decode to MOP_R_19 using decoder 16
10656 // 19512: }
10657 // 19512: } // switch Inst[24:20]
10658 // 19512: }
10659 97, 6, // 19516: case 0x61: {
10660 OPC_CheckPredicate, 109, // 19518: check predicate 109
10661 OPC_Decode, 243, 116, 30, // 19520: decode to MOP_RR_4 using decoder 30
10662 // 19520: }
10663 98, 35, // 19524: case 0x62: {
10664 OPC_SwitchField, 20, 5, // 19526: switch Inst[24:20] {
10665 28, 6, // 19529: case 0x1c: {
10666 OPC_CheckPredicate, 109, // 19531: check predicate 109
10667 OPC_Decode, 132, 117, 16, // 19533: decode to MOP_R_20 using decoder 16
10668 // 19533: }
10669 29, 6, // 19537: case 0x1d: {
10670 OPC_CheckPredicate, 109, // 19539: check predicate 109
10671 OPC_Decode, 133, 117, 16, // 19541: decode to MOP_R_21 using decoder 16
10672 // 19541: }
10673 30, 6, // 19545: case 0x1e: {
10674 OPC_CheckPredicate, 109, // 19547: check predicate 109
10675 OPC_Decode, 134, 117, 16, // 19549: decode to MOP_R_22 using decoder 16
10676 // 19549: }
10677 31, 0, // 19553: case 0x1f: {
10678 OPC_CheckPredicate, 109, // 19555: check predicate 109
10679 OPC_Decode, 135, 117, 16, // 19557: decode to MOP_R_23 using decoder 16
10680 // 19557: }
10681 // 19557: } // switch Inst[24:20]
10682 // 19557: }
10683 99, 6, // 19561: case 0x63: {
10684 OPC_CheckPredicate, 109, // 19563: check predicate 109
10685 OPC_Decode, 244, 116, 30, // 19565: decode to MOP_RR_5 using decoder 30
10686 // 19565: }
10687 100, 35, // 19569: case 0x64: {
10688 OPC_SwitchField, 20, 5, // 19571: switch Inst[24:20] {
10689 28, 6, // 19574: case 0x1c: {
10690 OPC_CheckPredicate, 109, // 19576: check predicate 109
10691 OPC_Decode, 136, 117, 16, // 19578: decode to MOP_R_24 using decoder 16
10692 // 19578: }
10693 29, 6, // 19582: case 0x1d: {
10694 OPC_CheckPredicate, 109, // 19584: check predicate 109
10695 OPC_Decode, 137, 117, 16, // 19586: decode to MOP_R_25 using decoder 16
10696 // 19586: }
10697 30, 6, // 19590: case 0x1e: {
10698 OPC_CheckPredicate, 109, // 19592: check predicate 109
10699 OPC_Decode, 138, 117, 16, // 19594: decode to MOP_R_26 using decoder 16
10700 // 19594: }
10701 31, 0, // 19598: case 0x1f: {
10702 OPC_CheckPredicate, 109, // 19600: check predicate 109
10703 OPC_Decode, 139, 117, 16, // 19602: decode to MOP_R_27 using decoder 16
10704 // 19602: }
10705 // 19602: } // switch Inst[24:20]
10706 // 19602: }
10707 101, 6, // 19606: case 0x65: {
10708 OPC_CheckPredicate, 109, // 19608: check predicate 109
10709 OPC_Decode, 245, 116, 30, // 19610: decode to MOP_RR_6 using decoder 30
10710 // 19610: }
10711 102, 61, // 19614: case 0x66: {
10712 OPC_SwitchField, 20, 5, // 19616: switch Inst[24:20] {
10713 28, 32, // 19619: case 0x1c: {
10714 OPC_Scope, 11, // 19621: try {
10715 OPC_CheckField, 7, 5, 0, // 19623: check Inst[11:7] == 0x0
10716 OPC_CheckPredicate, 109, // 19627: check predicate 109
10717 OPC_Decode, 197, 124, 150, 1, // 19629: decode to SSPOPCHK using decoder 150
10718 OPC_Scope, 11, // 19634: } else try {
10719 OPC_CheckField, 15, 5, 0, // 19636: check Inst[19:15] == 0x0
10720 OPC_CheckPredicate, 109, // 19640: check predicate 109
10721 OPC_Decode, 199, 124, 151, 1, // 19642: decode to SSRDP using decoder 151
10722 // 19642: } else try {
10723 OPC_CheckPredicate, 109, // 19647: check predicate 109
10724 OPC_Decode, 140, 117, 16, // 19649: decode to MOP_R_28 using decoder 16
10725 // 19649: }
10726 // 19649: }
10727 29, 6, // 19653: case 0x1d: {
10728 OPC_CheckPredicate, 109, // 19655: check predicate 109
10729 OPC_Decode, 141, 117, 16, // 19657: decode to MOP_R_29 using decoder 16
10730 // 19657: }
10731 30, 6, // 19661: case 0x1e: {
10732 OPC_CheckPredicate, 109, // 19663: check predicate 109
10733 OPC_Decode, 143, 117, 16, // 19665: decode to MOP_R_30 using decoder 16
10734 // 19665: }
10735 31, 0, // 19669: case 0x1f: {
10736 OPC_CheckPredicate, 109, // 19671: check predicate 109
10737 OPC_Decode, 144, 117, 16, // 19673: decode to MOP_R_31 using decoder 16
10738 // 19673: }
10739 // 19673: } // switch Inst[24:20]
10740 // 19673: }
10741 103, 0, // 19677: case 0x67: {
10742 OPC_Scope, 15, // 19679: try {
10743 OPC_CheckField, 7, 5, 0, // 19681: check Inst[11:7] == 0x0
10744 OPC_CheckPredicate, 109, // 19685: check predicate 109
10745 OPC_CheckField, 15, 5, 0, // 19687: check Inst[19:15] == 0x0
10746 OPC_Decode, 198, 124, 152, 1, // 19691: decode to SSPUSH using decoder 152
10747 // 19691: } else try {
10748 OPC_CheckPredicate, 109, // 19696: check predicate 109
10749 OPC_Decode, 246, 116, 30, // 19698: decode to MOP_RR_7 using decoder 30
10750 // 19698: }
10751 // 19698: }
10752 // 19698: } // switch Inst[31:25]
10753 // 19698: }
10754 5, 5, // 19702: case 0x5: {
10755 OPC_Decode, 218, 110, 153, 1, // 19704: decode to CSRRWI using decoder 153
10756 // 19704: }
10757 6, 5, // 19709: case 0x6: {
10758 OPC_Decode, 216, 110, 153, 1, // 19711: decode to CSRRSI using decoder 153
10759 // 19711: }
10760 7, 0, // 19716: case 0x7: {
10761 OPC_Decode, 214, 110, 153, 1, // 19718: decode to CSRRCI using decoder 153
10762 // 19718: }
10763 // 19718: } // switch Inst[14:12]
10764 // 19718: }
10765 119, 0, // 19723: case 0x77: {
10766 OPC_SwitchField, 25, 7, // 19725: switch Inst[31:25] {
10767 65, 11, // 19728: case 0x41: {
10768 OPC_CheckPredicate, 110, // 19730: check predicate 110
10769 OPC_CheckField, 12, 3, 2, // 19732: check Inst[14:12] == 0x2
10770 OPC_Decode, 186, 129, 1, 113, // 19736: decode to VSM3ME_VV using decoder 113
10771 // 19736: }
10772 67, 12, // 19741: case 0x43: {
10773 OPC_CheckPredicate, 111, // 19743: check predicate 111
10774 OPC_CheckField, 12, 3, 2, // 19745: check Inst[14:12] == 0x2
10775 OPC_Decode, 187, 129, 1, 154, 1, // 19749: decode to VSM4K_VI using decoder 154
10776 // 19749: }
10777 69, 11, // 19755: case 0x45: {
10778 OPC_CheckPredicate, 112, // 19757: check predicate 112
10779 OPC_CheckField, 12, 3, 2, // 19759: check Inst[14:12] == 0x2
10780 OPC_Decode, 219, 125, 154, 1, // 19763: decode to VAESKF1_VI using decoder 154
10781 // 19763: }
10782 71, 11, // 19768: case 0x47: {
10783 OPC_CheckPredicate, 113, // 19770: check predicate 113
10784 OPC_CheckField, 12, 3, 2, // 19772: check Inst[14:12] == 0x2
10785 OPC_Decode, 224, 126, 155, 1, // 19776: decode to VGHSH_VS using decoder 155
10786 // 19776: }
10787 81, 60, // 19781: case 0x51: {
10788 OPC_SwitchField, 12, 8, // 19783: switch Inst[19:12] {
10789 2, 7, // 19786: case 0x2: {
10790 OPC_CheckPredicate, 112, // 19788: check predicate 112
10791 OPC_Decode, 214, 125, 156, 1, // 19790: decode to VAESDM_VV using decoder 156
10792 // 19790: }
10793 10, 7, // 19795: case 0xa: {
10794 OPC_CheckPredicate, 112, // 19797: check predicate 112
10795 OPC_Decode, 212, 125, 156, 1, // 19799: decode to VAESDF_VV using decoder 156
10796 // 19799: }
10797 18, 7, // 19804: case 0x12: {
10798 OPC_CheckPredicate, 112, // 19806: check predicate 112
10799 OPC_Decode, 218, 125, 156, 1, // 19808: decode to VAESEM_VV using decoder 156
10800 // 19808: }
10801 26, 7, // 19813: case 0x1a: {
10802 OPC_CheckPredicate, 112, // 19815: check predicate 112
10803 OPC_Decode, 216, 125, 156, 1, // 19817: decode to VAESEF_VV using decoder 156
10804 // 19817: }
10805 130, 1, 8, // 19822: case 0x82: {
10806 OPC_CheckPredicate, 111, // 19825: check predicate 111
10807 OPC_Decode, 189, 129, 1, 156, 1, // 19827: decode to VSM4R_VV using decoder 156
10808 // 19827: }
10809 138, 1, 0, // 19833: case 0x8a: {
10810 OPC_CheckPredicate, 114, // 19836: check predicate 114
10811 OPC_Decode, 227, 126, 156, 1, // 19838: decode to VGMUL_VV using decoder 156
10812 // 19838: }
10813 // 19838: } // switch Inst[19:12]
10814 // 19838: }
10815 83, 69, // 19843: case 0x53: {
10816 OPC_SwitchField, 12, 8, // 19845: switch Inst[19:12] {
10817 2, 7, // 19848: case 0x2: {
10818 OPC_CheckPredicate, 112, // 19850: check predicate 112
10819 OPC_Decode, 213, 125, 156, 1, // 19852: decode to VAESDM_VS using decoder 156
10820 // 19852: }
10821 10, 7, // 19857: case 0xa: {
10822 OPC_CheckPredicate, 112, // 19859: check predicate 112
10823 OPC_Decode, 211, 125, 156, 1, // 19861: decode to VAESDF_VS using decoder 156
10824 // 19861: }
10825 18, 7, // 19866: case 0x12: {
10826 OPC_CheckPredicate, 112, // 19868: check predicate 112
10827 OPC_Decode, 217, 125, 156, 1, // 19870: decode to VAESEM_VS using decoder 156
10828 // 19870: }
10829 26, 7, // 19875: case 0x1a: {
10830 OPC_CheckPredicate, 112, // 19877: check predicate 112
10831 OPC_Decode, 215, 125, 156, 1, // 19879: decode to VAESEF_VS using decoder 156
10832 // 19879: }
10833 58, 7, // 19884: case 0x3a: {
10834 OPC_CheckPredicate, 112, // 19886: check predicate 112
10835 OPC_Decode, 221, 125, 156, 1, // 19888: decode to VAESZ_VS using decoder 156
10836 // 19888: }
10837 130, 1, 8, // 19893: case 0x82: {
10838 OPC_CheckPredicate, 111, // 19896: check predicate 111
10839 OPC_Decode, 188, 129, 1, 156, 1, // 19898: decode to VSM4R_VS using decoder 156
10840 // 19898: }
10841 138, 1, 0, // 19904: case 0x8a: {
10842 OPC_CheckPredicate, 113, // 19907: check predicate 113
10843 OPC_Decode, 226, 126, 156, 1, // 19909: decode to VGMUL_VS using decoder 156
10844 // 19909: }
10845 // 19909: } // switch Inst[19:12]
10846 // 19909: }
10847 85, 11, // 19914: case 0x55: {
10848 OPC_CheckPredicate, 112, // 19916: check predicate 112
10849 OPC_CheckField, 12, 3, 2, // 19918: check Inst[14:12] == 0x2
10850 OPC_Decode, 220, 125, 157, 1, // 19922: decode to VAESKF2_VI using decoder 157
10851 // 19922: }
10852 87, 12, // 19927: case 0x57: {
10853 OPC_CheckPredicate, 110, // 19929: check predicate 110
10854 OPC_CheckField, 12, 3, 2, // 19931: check Inst[14:12] == 0x2
10855 OPC_Decode, 185, 129, 1, 157, 1, // 19935: decode to VSM3C_VI using decoder 157
10856 // 19935: }
10857 89, 11, // 19941: case 0x59: {
10858 OPC_CheckPredicate, 114, // 19943: check predicate 114
10859 OPC_CheckField, 12, 3, 2, // 19945: check Inst[14:12] == 0x2
10860 OPC_Decode, 225, 126, 155, 1, // 19949: decode to VGHSH_VV using decoder 155
10861 // 19949: }
10862 91, 12, // 19954: case 0x5b: {
10863 OPC_CheckPredicate, 115, // 19956: check predicate 115
10864 OPC_CheckField, 12, 3, 2, // 19958: check Inst[14:12] == 0x2
10865 OPC_Decode, 175, 129, 1, 155, 1, // 19962: decode to VSHA2MS_VV using decoder 155
10866 // 19962: }
10867 93, 12, // 19968: case 0x5d: {
10868 OPC_CheckPredicate, 115, // 19970: check predicate 115
10869 OPC_CheckField, 12, 3, 2, // 19972: check Inst[14:12] == 0x2
10870 OPC_Decode, 173, 129, 1, 155, 1, // 19976: decode to VSHA2CH_VV using decoder 155
10871 // 19976: }
10872 95, 0, // 19982: case 0x5f: {
10873 OPC_CheckPredicate, 115, // 19984: check predicate 115
10874 OPC_CheckField, 12, 3, 2, // 19986: check Inst[14:12] == 0x2
10875 OPC_Decode, 174, 129, 1, 155, 1, // 19990: decode to VSHA2CL_VV using decoder 155
10876 // 19990: }
10877 // 19990: } // switch Inst[31:25]
10878 // 19990: }
10879 // 19990: } // switch Inst[6:0]
10880};
10881static const uint8_t DecoderTableRV32Only32[789] = {
10882 32, // 0: BitWidth 32
10883 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
10884 0, 99, // 4: case 0x0: {
10885 OPC_SwitchField, 25, 7, // 6: switch Inst[31:25] {
10886 73, 10, // 9: case 0x49: {
10887 OPC_CheckPredicate, 43, // 11: check predicate 43
10888 OPC_CheckField, 0, 7, 59, // 13: check Inst[6:0] == 0x3b
10889 OPC_Decode, 147, 123, 30, // 17: decode to SADD using decoder 30
10890 // 17: }
10891 77, 10, // 21: case 0x4d: {
10892 OPC_CheckPredicate, 43, // 23: check predicate 43
10893 OPC_CheckField, 0, 7, 59, // 25: check Inst[6:0] == 0x3b
10894 OPC_Decode, 151, 107, 30, // 29: decode to AADD using decoder 30
10895 // 29: }
10896 89, 10, // 33: case 0x59: {
10897 OPC_CheckPredicate, 43, // 35: check predicate 43
10898 OPC_CheckField, 0, 7, 59, // 37: check Inst[6:0] == 0x3b
10899 OPC_Decode, 148, 123, 30, // 41: decode to SADDU using decoder 30
10900 // 41: }
10901 93, 10, // 45: case 0x5d: {
10902 OPC_CheckPredicate, 43, // 47: check predicate 43
10903 OPC_CheckField, 0, 7, 59, // 49: check Inst[6:0] == 0x3b
10904 OPC_Decode, 152, 107, 30, // 53: decode to AADDU using decoder 30
10905 // 53: }
10906 105, 10, // 57: case 0x69: {
10907 OPC_CheckPredicate, 43, // 59: check predicate 43
10908 OPC_CheckField, 0, 7, 59, // 61: check Inst[6:0] == 0x3b
10909 OPC_Decode, 200, 124, 30, // 65: decode to SSUB using decoder 30
10910 // 65: }
10911 109, 10, // 69: case 0x6d: {
10912 OPC_CheckPredicate, 43, // 71: check predicate 43
10913 OPC_CheckField, 0, 7, 59, // 73: check Inst[6:0] == 0x3b
10914 OPC_Decode, 172, 110, 30, // 77: decode to ASUB using decoder 30
10915 // 77: }
10916 121, 10, // 81: case 0x79: {
10917 OPC_CheckPredicate, 43, // 83: check predicate 43
10918 OPC_CheckField, 0, 7, 59, // 85: check Inst[6:0] == 0x3b
10919 OPC_Decode, 201, 124, 30, // 89: decode to SSUBU using decoder 30
10920 // 89: }
10921 125, 0, // 93: case 0x7d: {
10922 OPC_CheckPredicate, 43, // 95: check predicate 43
10923 OPC_CheckField, 0, 7, 59, // 97: check Inst[6:0] == 0x3b
10924 OPC_Decode, 173, 110, 30, // 101: decode to ASUBU using decoder 30
10925 // 101: }
10926 // 101: } // switch Inst[31:25]
10927 // 101: }
10928 1, 51, // 105: case 0x1: {
10929 OPC_SwitchField, 25, 7, // 107: switch Inst[31:25] {
10930 73, 10, // 110: case 0x49: {
10931 OPC_CheckPredicate, 43, // 112: check predicate 43
10932 OPC_CheckField, 0, 7, 59, // 114: check Inst[6:0] == 0x3b
10933 OPC_Decode, 194, 117, 30, // 118: decode to MUL_H01 using decoder 30
10934 // 118: }
10935 77, 10, // 122: case 0x4d: {
10936 OPC_CheckPredicate, 43, // 124: check predicate 43
10937 OPC_CheckField, 0, 7, 59, // 126: check Inst[6:0] == 0x3b
10938 OPC_Decode, 209, 116, 58, // 130: decode to MACC_H01 using decoder 58
10939 // 130: }
10940 89, 10, // 134: case 0x59: {
10941 OPC_CheckPredicate, 43, // 136: check predicate 43
10942 OPC_CheckField, 0, 7, 59, // 138: check Inst[6:0] == 0x3b
10943 OPC_Decode, 187, 117, 30, // 142: decode to MULU_H01 using decoder 30
10944 // 142: }
10945 93, 0, // 146: case 0x5d: {
10946 OPC_CheckPredicate, 43, // 148: check predicate 43
10947 OPC_CheckField, 0, 7, 59, // 150: check Inst[6:0] == 0x3b
10948 OPC_Decode, 203, 116, 58, // 154: decode to MACCU_H01 using decoder 58
10949 // 154: }
10950 // 154: } // switch Inst[31:25]
10951 // 154: }
10952 2, 75, // 158: case 0x2: {
10953 OPC_SwitchField, 25, 7, // 160: switch Inst[31:25] {
10954 85, 10, // 163: case 0x55: {
10955 OPC_CheckPredicate, 43, // 165: check predicate 43
10956 OPC_CheckField, 0, 7, 27, // 167: check Inst[6:0] == 0x1b
10957 OPC_Decode, 194, 124, 30, // 171: decode to SSHL using decoder 30
10958 // 171: }
10959 89, 10, // 175: case 0x59: {
10960 OPC_CheckPredicate, 43, // 177: check predicate 43
10961 OPC_CheckField, 0, 7, 59, // 179: check Inst[6:0] == 0x3b
10962 OPC_Decode, 191, 124, 30, // 183: decode to SSH1SADD using decoder 30
10963 // 183: }
10964 93, 10, // 187: case 0x5d: {
10965 OPC_CheckPredicate, 43, // 189: check predicate 43
10966 OPC_CheckField, 0, 7, 27, // 191: check Inst[6:0] == 0x1b
10967 OPC_Decode, 195, 124, 30, // 195: decode to SSHLR using decoder 30
10968 // 195: }
10969 105, 10, // 199: case 0x69: {
10970 OPC_CheckPredicate, 43, // 201: check predicate 43
10971 OPC_CheckField, 0, 7, 27, // 203: check Inst[6:0] == 0x1b
10972 OPC_Decode, 196, 124, 20, // 207: decode to SSLAI using decoder 20
10973 // 207: }
10974 117, 10, // 211: case 0x75: {
10975 OPC_CheckPredicate, 43, // 213: check predicate 43
10976 OPC_CheckField, 0, 7, 27, // 215: check Inst[6:0] == 0x1b
10977 OPC_Decode, 192, 124, 30, // 219: decode to SSHA using decoder 30
10978 // 219: }
10979 125, 0, // 223: case 0x7d: {
10980 OPC_CheckPredicate, 43, // 225: check predicate 43
10981 OPC_CheckField, 0, 7, 27, // 227: check Inst[6:0] == 0x1b
10982 OPC_Decode, 193, 124, 30, // 231: decode to SSHAR using decoder 30
10983 // 231: }
10984 // 231: } // switch Inst[31:25]
10985 // 231: }
10986 3, 159, 1, // 235: case 0x3: {
10987 OPC_SwitchField, 0, 7, // 238: switch Inst[6:0] {
10988 3, 7, // 241: case 0x3: {
10989 OPC_CheckPredicate, 116, // 243: check predicate 116
10990 OPC_Decode, 178, 116, 158, 1, // 245: decode to LD_RV32 using decoder 158
10991 // 245: }
10992 35, 7, // 250: case 0x23: {
10993 OPC_CheckPredicate, 116, // 252: check predicate 116
10994 OPC_Decode, 166, 123, 159, 1, // 254: decode to SD_RV32 using decoder 159
10995 // 254: }
10996 47, 35, // 259: case 0x2f: {
10997 OPC_SwitchField, 25, 7, // 261: switch Inst[31:25] {
10998 20, 6, // 264: case 0x14: {
10999 OPC_CheckPredicate, 117, // 266: check predicate 117
11000 OPC_Decode, 165, 109, 55, // 268: decode to AMOCAS_D_RV32 using decoder 55
11001 // 268: }
11002 21, 6, // 272: case 0x15: {
11003 OPC_CheckPredicate, 117, // 274: check predicate 117
11004 OPC_Decode, 168, 109, 55, // 276: decode to AMOCAS_D_RV32_RL using decoder 55
11005 // 276: }
11006 22, 6, // 280: case 0x16: {
11007 OPC_CheckPredicate, 117, // 282: check predicate 117
11008 OPC_Decode, 166, 109, 55, // 284: decode to AMOCAS_D_RV32_AQ using decoder 55
11009 // 284: }
11010 23, 0, // 288: case 0x17: {
11011 OPC_CheckPredicate, 117, // 290: check predicate 117
11012 OPC_Decode, 167, 109, 55, // 292: decode to AMOCAS_D_RV32_AQRL using decoder 55
11013 // 292: }
11014 // 292: } // switch Inst[31:25]
11015 // 292: }
11016 59, 0, // 296: case 0x3b: {
11017 OPC_SwitchField, 25, 7, // 298: switch Inst[31:25] {
11018 65, 6, // 301: case 0x41: {
11019 OPC_CheckPredicate, 43, // 303: check predicate 43
11020 OPC_Decode, 193, 117, 30, // 305: decode to MUL_H00 using decoder 30
11021 // 305: }
11022 69, 6, // 309: case 0x45: {
11023 OPC_CheckPredicate, 43, // 311: check predicate 43
11024 OPC_Decode, 208, 116, 58, // 313: decode to MACC_H00 using decoder 58
11025 // 313: }
11026 73, 6, // 317: case 0x49: {
11027 OPC_CheckPredicate, 43, // 319: check predicate 43
11028 OPC_Decode, 195, 117, 30, // 321: decode to MUL_H11 using decoder 30
11029 // 321: }
11030 77, 6, // 325: case 0x4d: {
11031 OPC_CheckPredicate, 43, // 327: check predicate 43
11032 OPC_Decode, 210, 116, 58, // 329: decode to MACC_H11 using decoder 58
11033 // 329: }
11034 81, 6, // 333: case 0x51: {
11035 OPC_CheckPredicate, 43, // 335: check predicate 43
11036 OPC_Decode, 186, 117, 30, // 337: decode to MULU_H00 using decoder 30
11037 // 337: }
11038 85, 6, // 341: case 0x55: {
11039 OPC_CheckPredicate, 43, // 343: check predicate 43
11040 OPC_Decode, 202, 116, 58, // 345: decode to MACCU_H00 using decoder 58
11041 // 345: }
11042 89, 6, // 349: case 0x59: {
11043 OPC_CheckPredicate, 43, // 351: check predicate 43
11044 OPC_Decode, 188, 117, 30, // 353: decode to MULU_H11 using decoder 30
11045 // 353: }
11046 93, 6, // 357: case 0x5d: {
11047 OPC_CheckPredicate, 43, // 359: check predicate 43
11048 OPC_Decode, 204, 116, 58, // 361: decode to MACCU_H11 using decoder 58
11049 // 361: }
11050 113, 6, // 365: case 0x71: {
11051 OPC_CheckPredicate, 43, // 367: check predicate 43
11052 OPC_Decode, 182, 117, 30, // 369: decode to MULSU_H00 using decoder 30
11053 // 369: }
11054 117, 6, // 373: case 0x75: {
11055 OPC_CheckPredicate, 43, // 375: check predicate 43
11056 OPC_Decode, 198, 116, 58, // 377: decode to MACCSU_H00 using decoder 58
11057 // 377: }
11058 121, 6, // 381: case 0x79: {
11059 OPC_CheckPredicate, 43, // 383: check predicate 43
11060 OPC_Decode, 183, 117, 30, // 385: decode to MULSU_H11 using decoder 30
11061 // 385: }
11062 125, 0, // 389: case 0x7d: {
11063 OPC_CheckPredicate, 43, // 391: check predicate 43
11064 OPC_Decode, 199, 116, 58, // 393: decode to MACCSU_H11 using decoder 58
11065 // 393: }
11066 // 393: } // switch Inst[31:25]
11067 // 393: }
11068 // 393: } // switch Inst[6:0]
11069 // 393: }
11070 4, 39, // 397: case 0x4: {
11071 OPC_SwitchField, 25, 7, // 399: switch Inst[31:25] {
11072 81, 10, // 402: case 0x51: {
11073 OPC_CheckPredicate, 43, // 404: check predicate 43
11074 OPC_CheckField, 0, 7, 27, // 406: check Inst[6:0] == 0x1b
11075 OPC_Decode, 196, 125, 20, // 410: decode to USATI_RV32 using decoder 20
11076 // 410: }
11077 105, 10, // 414: case 0x69: {
11078 OPC_CheckPredicate, 43, // 416: check predicate 43
11079 OPC_CheckField, 0, 7, 27, // 418: check Inst[6:0] == 0x1b
11080 OPC_Decode, 174, 124, 20, // 422: decode to SRARI_RV32 using decoder 20
11081 // 422: }
11082 113, 0, // 426: case 0x71: {
11083 OPC_CheckPredicate, 43, // 428: check predicate 43
11084 OPC_CheckField, 0, 7, 27, // 430: check Inst[6:0] == 0x1b
11085 OPC_Decode, 149, 123, 40, // 434: decode to SATI_RV32 using decoder 40
11086 // 434: }
11087 // 434: } // switch Inst[31:25]
11088 // 434: }
11089 5, 27, // 438: case 0x5: {
11090 OPC_SwitchField, 25, 7, // 440: switch Inst[31:25] {
11091 124, 10, // 443: case 0x7c: {
11092 OPC_CheckPredicate, 43, // 445: check predicate 43
11093 OPC_CheckField, 0, 7, 59, // 447: check Inst[6:0] == 0x3b
11094 OPC_Decode, 152, 117, 58, // 451: decode to MQACC_H01 using decoder 58
11095 // 451: }
11096 126, 0, // 455: case 0x7e: {
11097 OPC_CheckPredicate, 43, // 457: check predicate 43
11098 OPC_CheckField, 0, 7, 59, // 459: check Inst[6:0] == 0x3b
11099 OPC_Decode, 158, 117, 58, // 463: decode to MQRACC_H01 using decoder 58
11100 // 463: }
11101 // 463: } // switch Inst[31:25]
11102 // 463: }
11103 6, 39, // 467: case 0x6: {
11104 OPC_SwitchField, 25, 7, // 469: switch Inst[31:25] {
11105 97, 10, // 472: case 0x61: {
11106 OPC_CheckPredicate, 43, // 474: check predicate 43
11107 OPC_CheckField, 0, 7, 59, // 476: check Inst[6:0] == 0x3b
11108 OPC_Decode, 166, 117, 30, // 480: decode to MSEQ using decoder 30
11109 // 480: }
11110 105, 10, // 484: case 0x69: {
11111 OPC_CheckPredicate, 43, // 486: check predicate 43
11112 OPC_CheckField, 0, 7, 59, // 488: check Inst[6:0] == 0x3b
11113 OPC_Decode, 167, 117, 30, // 492: decode to MSLT using decoder 30
11114 // 492: }
11115 109, 0, // 496: case 0x6d: {
11116 OPC_CheckPredicate, 43, // 498: check predicate 43
11117 OPC_CheckField, 0, 7, 59, // 500: check Inst[6:0] == 0x3b
11118 OPC_Decode, 168, 117, 30, // 504: decode to MSLTU using decoder 30
11119 // 504: }
11120 // 504: } // switch Inst[31:25]
11121 // 504: }
11122 7, 0, // 508: case 0x7: {
11123 OPC_SwitchField, 25, 7, // 510: switch Inst[31:25] {
11124 67, 10, // 513: case 0x43: {
11125 OPC_CheckPredicate, 43, // 515: check predicate 43
11126 OPC_CheckField, 0, 7, 59, // 517: check Inst[6:0] == 0x3b
11127 OPC_Decode, 171, 117, 30, // 521: decode to MULHR using decoder 30
11128 // 521: }
11129 69, 10, // 525: case 0x45: {
11130 OPC_CheckPredicate, 43, // 527: check predicate 43
11131 OPC_CheckField, 0, 7, 59, // 529: check Inst[6:0] == 0x3b
11132 OPC_Decode, 217, 116, 58, // 533: decode to MHACC using decoder 58
11133 // 533: }
11134 71, 10, // 537: case 0x47: {
11135 OPC_CheckPredicate, 43, // 539: check predicate 43
11136 OPC_CheckField, 0, 7, 59, // 541: check Inst[6:0] == 0x3b
11137 OPC_Decode, 224, 116, 58, // 545: decode to MHRACC using decoder 58
11138 // 545: }
11139 75, 10, // 549: case 0x4b: {
11140 OPC_CheckPredicate, 43, // 551: check predicate 43
11141 OPC_CheckField, 0, 7, 59, // 553: check Inst[6:0] == 0x3b
11142 OPC_Decode, 173, 117, 30, // 557: decode to MULHRU using decoder 30
11143 // 557: }
11144 77, 10, // 561: case 0x4d: {
11145 OPC_CheckPredicate, 43, // 563: check predicate 43
11146 OPC_CheckField, 0, 7, 59, // 565: check Inst[6:0] == 0x3b
11147 OPC_Decode, 221, 116, 58, // 569: decode to MHACCU using decoder 58
11148 // 569: }
11149 79, 10, // 573: case 0x4f: {
11150 OPC_CheckPredicate, 43, // 575: check predicate 43
11151 OPC_CheckField, 0, 7, 59, // 577: check Inst[6:0] == 0x3b
11152 OPC_Decode, 226, 116, 58, // 581: decode to MHRACCU using decoder 58
11153 // 581: }
11154 81, 10, // 585: case 0x51: {
11155 OPC_CheckPredicate, 43, // 587: check predicate 43
11156 OPC_CheckField, 0, 7, 59, // 589: check Inst[6:0] == 0x3b
11157 OPC_Decode, 178, 117, 30, // 593: decode to MULH_H0 using decoder 30
11158 // 593: }
11159 83, 10, // 597: case 0x53: {
11160 OPC_CheckPredicate, 43, // 599: check predicate 43
11161 OPC_CheckField, 0, 7, 59, // 601: check Inst[6:0] == 0x3b
11162 OPC_Decode, 175, 117, 30, // 605: decode to MULHSU_H0 using decoder 30
11163 // 605: }
11164 85, 10, // 609: case 0x55: {
11165 OPC_CheckPredicate, 43, // 611: check predicate 43
11166 OPC_CheckField, 0, 7, 59, // 613: check Inst[6:0] == 0x3b
11167 OPC_Decode, 222, 116, 58, // 617: decode to MHACC_H0 using decoder 58
11168 // 617: }
11169 87, 10, // 621: case 0x57: {
11170 OPC_CheckPredicate, 43, // 623: check predicate 43
11171 OPC_CheckField, 0, 7, 59, // 625: check Inst[6:0] == 0x3b
11172 OPC_Decode, 219, 116, 58, // 629: decode to MHACCSU_H0 using decoder 58
11173 // 629: }
11174 89, 10, // 633: case 0x59: {
11175 OPC_CheckPredicate, 43, // 635: check predicate 43
11176 OPC_CheckField, 0, 7, 59, // 637: check Inst[6:0] == 0x3b
11177 OPC_Decode, 179, 117, 30, // 641: decode to MULH_H1 using decoder 30
11178 // 641: }
11179 91, 10, // 645: case 0x5b: {
11180 OPC_CheckPredicate, 43, // 647: check predicate 43
11181 OPC_CheckField, 0, 7, 59, // 649: check Inst[6:0] == 0x3b
11182 OPC_Decode, 176, 117, 30, // 653: decode to MULHSU_H1 using decoder 30
11183 // 653: }
11184 93, 10, // 657: case 0x5d: {
11185 OPC_CheckPredicate, 43, // 659: check predicate 43
11186 OPC_CheckField, 0, 7, 59, // 661: check Inst[6:0] == 0x3b
11187 OPC_Decode, 223, 116, 58, // 665: decode to MHACC_H1 using decoder 58
11188 // 665: }
11189 95, 10, // 669: case 0x5f: {
11190 OPC_CheckPredicate, 43, // 671: check predicate 43
11191 OPC_CheckField, 0, 7, 59, // 673: check Inst[6:0] == 0x3b
11192 OPC_Decode, 220, 116, 58, // 677: decode to MHACCSU_H1 using decoder 58
11193 // 677: }
11194 99, 10, // 681: case 0x63: {
11195 OPC_CheckPredicate, 43, // 683: check predicate 43
11196 OPC_CheckField, 0, 7, 59, // 685: check Inst[6:0] == 0x3b
11197 OPC_Decode, 172, 117, 30, // 689: decode to MULHRSU using decoder 30
11198 // 689: }
11199 101, 10, // 693: case 0x65: {
11200 OPC_CheckPredicate, 43, // 695: check predicate 43
11201 OPC_CheckField, 0, 7, 59, // 697: check Inst[6:0] == 0x3b
11202 OPC_Decode, 218, 116, 58, // 701: decode to MHACCSU using decoder 58
11203 // 701: }
11204 103, 10, // 705: case 0x67: {
11205 OPC_CheckPredicate, 43, // 707: check predicate 43
11206 OPC_CheckField, 0, 7, 59, // 709: check Inst[6:0] == 0x3b
11207 OPC_Decode, 225, 116, 58, // 713: decode to MHRACCSU using decoder 58
11208 // 713: }
11209 105, 10, // 717: case 0x69: {
11210 OPC_CheckPredicate, 43, // 719: check predicate 43
11211 OPC_CheckField, 0, 7, 59, // 721: check Inst[6:0] == 0x3b
11212 OPC_Decode, 180, 117, 30, // 725: decode to MULQ using decoder 30
11213 // 725: }
11214 107, 10, // 729: case 0x6b: {
11215 OPC_CheckPredicate, 43, // 731: check predicate 43
11216 OPC_CheckField, 0, 7, 59, // 733: check Inst[6:0] == 0x3b
11217 OPC_Decode, 181, 117, 30, // 737: decode to MULQR using decoder 30
11218 // 737: }
11219 116, 10, // 741: case 0x74: {
11220 OPC_CheckPredicate, 43, // 743: check predicate 43
11221 OPC_CheckField, 0, 7, 59, // 745: check Inst[6:0] == 0x3b
11222 OPC_Decode, 151, 117, 58, // 749: decode to MQACC_H00 using decoder 58
11223 // 749: }
11224 118, 10, // 753: case 0x76: {
11225 OPC_CheckPredicate, 43, // 755: check predicate 43
11226 OPC_CheckField, 0, 7, 59, // 757: check Inst[6:0] == 0x3b
11227 OPC_Decode, 157, 117, 58, // 761: decode to MQRACC_H00 using decoder 58
11228 // 761: }
11229 124, 10, // 765: case 0x7c: {
11230 OPC_CheckPredicate, 43, // 767: check predicate 43
11231 OPC_CheckField, 0, 7, 59, // 769: check Inst[6:0] == 0x3b
11232 OPC_Decode, 153, 117, 58, // 773: decode to MQACC_H11 using decoder 58
11233 // 773: }
11234 126, 0, // 777: case 0x7e: {
11235 OPC_CheckPredicate, 43, // 779: check predicate 43
11236 OPC_CheckField, 0, 7, 59, // 781: check Inst[6:0] == 0x3b
11237 OPC_Decode, 159, 117, 58, // 785: decode to MQRACC_H11 using decoder 58
11238 // 785: }
11239 // 785: } // switch Inst[31:25]
11240 // 785: }
11241 // 785: } // switch Inst[14:12]
11242};
11243static const uint8_t DecoderTableXAIF32[2399] = {
11244 32, // 0: BitWidth 32
11245 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
11246 7, 11, // 4: case 0x7: {
11247 OPC_CheckPredicate, 118, // 6: check predicate 118
11248 OPC_CheckField, 12, 3, 5, // 8: check Inst[14:12] == 0x5
11249 OPC_Decode, 173, 108, 160, 1, // 12: decode to AIF_FLQ2 using decoder 160
11250 // 12: }
11251 11, 141, 4, // 17: case 0xb: {
11252 OPC_SwitchField, 12, 3, // 20: switch Inst[14:12] {
11253 0, 7, // 23: case 0x0: {
11254 OPC_CheckPredicate, 118, // 25: check predicate 118
11255 OPC_Decode, 247, 107, 160, 1, // 27: decode to AIF_FBC_PS using decoder 160
11256 // 27: }
11257 1, 111, // 32: case 0x1: {
11258 OPC_SwitchField, 25, 7, // 34: switch Inst[31:25] {
11259 4, 7, // 37: case 0x4: {
11260 OPC_CheckPredicate, 118, // 39: check predicate 118
11261 OPC_Decode, 157, 108, 161, 1, // 41: decode to AIF_FG32B_PS using decoder 161
11262 // 41: }
11263 8, 7, // 46: case 0x8: {
11264 OPC_CheckPredicate, 118, // 48: check predicate 118
11265 OPC_Decode, 158, 108, 161, 1, // 50: decode to AIF_FG32H_PS using decoder 161
11266 // 50: }
11267 16, 7, // 55: case 0x10: {
11268 OPC_CheckPredicate, 118, // 57: check predicate 118
11269 OPC_Decode, 159, 108, 161, 1, // 59: decode to AIF_FG32W_PS using decoder 161
11270 // 59: }
11271 36, 7, // 64: case 0x24: {
11272 OPC_CheckPredicate, 118, // 66: check predicate 118
11273 OPC_Decode, 162, 108, 162, 1, // 68: decode to AIF_FGB_PS using decoder 162
11274 // 68: }
11275 40, 7, // 73: case 0x28: {
11276 OPC_CheckPredicate, 118, // 75: check predicate 118
11277 OPC_Decode, 165, 108, 162, 1, // 77: decode to AIF_FGH_PS using decoder 162
11278 // 77: }
11279 48, 7, // 82: case 0x30: {
11280 OPC_CheckPredicate, 118, // 84: check predicate 118
11281 OPC_Decode, 168, 108, 162, 1, // 86: decode to AIF_FGW_PS using decoder 162
11282 // 86: }
11283 68, 7, // 91: case 0x44: {
11284 OPC_CheckPredicate, 118, // 93: check predicate 118
11285 OPC_Decode, 210, 108, 161, 1, // 95: decode to AIF_FSC32B_PS using decoder 161
11286 // 95: }
11287 72, 7, // 100: case 0x48: {
11288 OPC_CheckPredicate, 118, // 102: check predicate 118
11289 OPC_Decode, 211, 108, 161, 1, // 104: decode to AIF_FSC32H_PS using decoder 161
11290 // 104: }
11291 80, 7, // 109: case 0x50: {
11292 OPC_CheckPredicate, 118, // 111: check predicate 118
11293 OPC_Decode, 212, 108, 161, 1, // 113: decode to AIF_FSC32W_PS using decoder 161
11294 // 113: }
11295 100, 7, // 118: case 0x64: {
11296 OPC_CheckPredicate, 118, // 120: check predicate 118
11297 OPC_Decode, 215, 108, 162, 1, // 122: decode to AIF_FSCB_PS using decoder 162
11298 // 122: }
11299 104, 7, // 127: case 0x68: {
11300 OPC_CheckPredicate, 118, // 129: check predicate 118
11301 OPC_Decode, 218, 108, 162, 1, // 131: decode to AIF_FSCH_PS using decoder 162
11302 // 131: }
11303 112, 0, // 136: case 0x70: {
11304 OPC_CheckPredicate, 118, // 138: check predicate 118
11305 OPC_Decode, 221, 108, 162, 1, // 140: decode to AIF_FSCW_PS using decoder 162
11306 // 140: }
11307 // 140: } // switch Inst[31:25]
11308 // 140: }
11309 2, 7, // 145: case 0x2: {
11310 OPC_CheckPredicate, 118, // 147: check predicate 118
11311 OPC_Decode, 181, 108, 160, 1, // 149: decode to AIF_FLW_PS using decoder 160
11312 // 149: }
11313 3, 11, // 154: case 0x3: {
11314 OPC_CheckPredicate, 118, // 156: check predicate 118
11315 OPC_CheckField, 20, 12, 0, // 158: check Inst[31:20] == 0x0
11316 OPC_Decode, 246, 107, 163, 1, // 162: decode to AIF_FBCX_PS using decoder 163
11317 // 162: }
11318 4, 201, 1, // 167: case 0x4: {
11319 OPC_SwitchField, 25, 7, // 170: switch Inst[31:25] {
11320 3, 7, // 173: case 0x3: {
11321 OPC_CheckPredicate, 118, // 175: check predicate 118
11322 OPC_Decode, 221, 107, 162, 1, // 177: decode to AIF_FAMOADDL_PI using decoder 162
11323 // 177: }
11324 7, 7, // 182: case 0x7: {
11325 OPC_CheckPredicate, 118, // 184: check predicate 118
11326 OPC_Decode, 239, 107, 162, 1, // 186: decode to AIF_FAMOSWAPL_PI using decoder 162
11327 // 186: }
11328 11, 7, // 191: case 0xb: {
11329 OPC_CheckPredicate, 118, // 193: check predicate 118
11330 OPC_Decode, 223, 107, 162, 1, // 195: decode to AIF_FAMOANDL_PI using decoder 162
11331 // 195: }
11332 15, 7, // 200: case 0xf: {
11333 OPC_CheckPredicate, 118, // 202: check predicate 118
11334 OPC_Decode, 237, 107, 162, 1, // 204: decode to AIF_FAMOORL_PI using decoder 162
11335 // 204: }
11336 19, 7, // 209: case 0x13: {
11337 OPC_CheckPredicate, 118, // 211: check predicate 118
11338 OPC_Decode, 241, 107, 162, 1, // 213: decode to AIF_FAMOXORL_PI using decoder 162
11339 // 213: }
11340 20, 7, // 218: case 0x14: {
11341 OPC_CheckPredicate, 118, // 220: check predicate 118
11342 OPC_Decode, 227, 107, 162, 1, // 222: decode to AIF_FAMOMAXL_PS using decoder 162
11343 // 222: }
11344 23, 7, // 227: case 0x17: {
11345 OPC_CheckPredicate, 118, // 229: check predicate 118
11346 OPC_Decode, 232, 107, 162, 1, // 231: decode to AIF_FAMOMINL_PI using decoder 162
11347 // 231: }
11348 24, 7, // 236: case 0x18: {
11349 OPC_CheckPredicate, 118, // 238: check predicate 118
11350 OPC_Decode, 233, 107, 162, 1, // 240: decode to AIF_FAMOMINL_PS using decoder 162
11351 // 240: }
11352 27, 7, // 245: case 0x1b: {
11353 OPC_CheckPredicate, 118, // 247: check predicate 118
11354 OPC_Decode, 226, 107, 162, 1, // 249: decode to AIF_FAMOMAXL_PI using decoder 162
11355 // 249: }
11356 31, 7, // 254: case 0x1f: {
11357 OPC_CheckPredicate, 118, // 256: check predicate 118
11358 OPC_Decode, 235, 107, 162, 1, // 258: decode to AIF_FAMOMINUL_PI using decoder 162
11359 // 258: }
11360 35, 7, // 263: case 0x23: {
11361 OPC_CheckPredicate, 118, // 265: check predicate 118
11362 OPC_Decode, 229, 107, 162, 1, // 267: decode to AIF_FAMOMAXUL_PI using decoder 162
11363 // 267: }
11364 67, 7, // 272: case 0x43: {
11365 OPC_CheckPredicate, 118, // 274: check predicate 118
11366 OPC_Decode, 220, 107, 162, 1, // 276: decode to AIF_FAMOADDG_PI using decoder 162
11367 // 276: }
11368 71, 7, // 281: case 0x47: {
11369 OPC_CheckPredicate, 118, // 283: check predicate 118
11370 OPC_Decode, 238, 107, 162, 1, // 285: decode to AIF_FAMOSWAPG_PI using decoder 162
11371 // 285: }
11372 75, 7, // 290: case 0x4b: {
11373 OPC_CheckPredicate, 118, // 292: check predicate 118
11374 OPC_Decode, 222, 107, 162, 1, // 294: decode to AIF_FAMOANDG_PI using decoder 162
11375 // 294: }
11376 79, 7, // 299: case 0x4f: {
11377 OPC_CheckPredicate, 118, // 301: check predicate 118
11378 OPC_Decode, 236, 107, 162, 1, // 303: decode to AIF_FAMOORG_PI using decoder 162
11379 // 303: }
11380 83, 7, // 308: case 0x53: {
11381 OPC_CheckPredicate, 118, // 310: check predicate 118
11382 OPC_Decode, 240, 107, 162, 1, // 312: decode to AIF_FAMOXORG_PI using decoder 162
11383 // 312: }
11384 84, 7, // 317: case 0x54: {
11385 OPC_CheckPredicate, 118, // 319: check predicate 118
11386 OPC_Decode, 225, 107, 162, 1, // 321: decode to AIF_FAMOMAXG_PS using decoder 162
11387 // 321: }
11388 87, 7, // 326: case 0x57: {
11389 OPC_CheckPredicate, 118, // 328: check predicate 118
11390 OPC_Decode, 230, 107, 162, 1, // 330: decode to AIF_FAMOMING_PI using decoder 162
11391 // 330: }
11392 88, 7, // 335: case 0x58: {
11393 OPC_CheckPredicate, 118, // 337: check predicate 118
11394 OPC_Decode, 231, 107, 162, 1, // 339: decode to AIF_FAMOMING_PS using decoder 162
11395 // 339: }
11396 91, 7, // 344: case 0x5b: {
11397 OPC_CheckPredicate, 118, // 346: check predicate 118
11398 OPC_Decode, 224, 107, 162, 1, // 348: decode to AIF_FAMOMAXG_PI using decoder 162
11399 // 348: }
11400 95, 7, // 353: case 0x5f: {
11401 OPC_CheckPredicate, 118, // 355: check predicate 118
11402 OPC_Decode, 234, 107, 162, 1, // 357: decode to AIF_FAMOMINUG_PI using decoder 162
11403 // 357: }
11404 99, 0, // 362: case 0x63: {
11405 OPC_CheckPredicate, 118, // 364: check predicate 118
11406 OPC_Decode, 228, 107, 162, 1, // 366: decode to AIF_FAMOMAXUG_PI using decoder 162
11407 // 366: }
11408 // 366: } // switch Inst[31:25]
11409 // 366: }
11410 6, 7, // 371: case 0x6: {
11411 OPC_CheckPredicate, 118, // 373: check predicate 118
11412 OPC_Decode, 240, 108, 164, 1, // 375: decode to AIF_FSW_PS using decoder 164
11413 // 375: }
11414 7, 0, // 380: case 0x7: {
11415 OPC_SwitchField, 25, 7, // 382: switch Inst[31:25] {
11416 8, 11, // 385: case 0x8: {
11417 OPC_CheckPredicate, 118, // 387: check predicate 118
11418 OPC_CheckField, 20, 5, 0, // 389: check Inst[24:20] == 0x0
11419 OPC_Decode, 180, 108, 163, 1, // 393: decode to AIF_FLWL_PS using decoder 163
11420 // 393: }
11421 9, 11, // 398: case 0x9: {
11422 OPC_CheckPredicate, 118, // 400: check predicate 118
11423 OPC_CheckField, 20, 5, 0, // 402: check Inst[24:20] == 0x0
11424 OPC_Decode, 179, 108, 163, 1, // 406: decode to AIF_FLWG_PS using decoder 163
11425 // 406: }
11426 40, 11, // 411: case 0x28: {
11427 OPC_CheckPredicate, 118, // 413: check predicate 118
11428 OPC_CheckField, 20, 5, 0, // 415: check Inst[24:20] == 0x0
11429 OPC_Decode, 239, 108, 163, 1, // 419: decode to AIF_FSWL_PS using decoder 163
11430 // 419: }
11431 41, 11, // 424: case 0x29: {
11432 OPC_CheckPredicate, 118, // 426: check predicate 118
11433 OPC_CheckField, 20, 5, 0, // 428: check Inst[24:20] == 0x0
11434 OPC_Decode, 237, 108, 163, 1, // 432: decode to AIF_FSWG_PS using decoder 163
11435 // 432: }
11436 64, 7, // 437: case 0x40: {
11437 OPC_CheckPredicate, 118, // 439: check predicate 118
11438 OPC_Decode, 161, 108, 162, 1, // 441: decode to AIF_FGBL_PS using decoder 162
11439 // 441: }
11440 65, 7, // 446: case 0x41: {
11441 OPC_CheckPredicate, 118, // 448: check predicate 118
11442 OPC_Decode, 160, 108, 162, 1, // 450: decode to AIF_FGBG_PS using decoder 162
11443 // 450: }
11444 68, 7, // 455: case 0x44: {
11445 OPC_CheckPredicate, 118, // 457: check predicate 118
11446 OPC_Decode, 164, 108, 162, 1, // 459: decode to AIF_FGHL_PS using decoder 162
11447 // 459: }
11448 69, 7, // 464: case 0x45: {
11449 OPC_CheckPredicate, 118, // 466: check predicate 118
11450 OPC_Decode, 163, 108, 162, 1, // 468: decode to AIF_FGHG_PS using decoder 162
11451 // 468: }
11452 72, 7, // 473: case 0x48: {
11453 OPC_CheckPredicate, 118, // 475: check predicate 118
11454 OPC_Decode, 167, 108, 162, 1, // 477: decode to AIF_FGWL_PS using decoder 162
11455 // 477: }
11456 73, 7, // 482: case 0x49: {
11457 OPC_CheckPredicate, 118, // 484: check predicate 118
11458 OPC_Decode, 166, 108, 162, 1, // 486: decode to AIF_FGWG_PS using decoder 162
11459 // 486: }
11460 96, 7, // 491: case 0x60: {
11461 OPC_CheckPredicate, 118, // 493: check predicate 118
11462 OPC_Decode, 214, 108, 162, 1, // 495: decode to AIF_FSCBL_PS using decoder 162
11463 // 495: }
11464 97, 7, // 500: case 0x61: {
11465 OPC_CheckPredicate, 118, // 502: check predicate 118
11466 OPC_Decode, 213, 108, 162, 1, // 504: decode to AIF_FSCBG_PS using decoder 162
11467 // 504: }
11468 100, 7, // 509: case 0x64: {
11469 OPC_CheckPredicate, 118, // 511: check predicate 118
11470 OPC_Decode, 217, 108, 162, 1, // 513: decode to AIF_FSCHL_PS using decoder 162
11471 // 513: }
11472 101, 7, // 518: case 0x65: {
11473 OPC_CheckPredicate, 118, // 520: check predicate 118
11474 OPC_Decode, 216, 108, 162, 1, // 522: decode to AIF_FSCHG_PS using decoder 162
11475 // 522: }
11476 104, 7, // 527: case 0x68: {
11477 OPC_CheckPredicate, 118, // 529: check predicate 118
11478 OPC_Decode, 220, 108, 162, 1, // 531: decode to AIF_FSCWL_PS using decoder 162
11479 // 531: }
11480 105, 0, // 536: case 0x69: {
11481 OPC_CheckPredicate, 118, // 538: check predicate 118
11482 OPC_Decode, 219, 108, 162, 1, // 540: decode to AIF_FSCWG_PS using decoder 162
11483 // 540: }
11484 // 540: } // switch Inst[31:25]
11485 // 540: }
11486 // 540: } // switch Inst[14:12]
11487 // 540: }
11488 31, 7, // 545: case 0x1f: {
11489 OPC_CheckPredicate, 118, // 547: check predicate 118
11490 OPC_Decode, 245, 107, 165, 1, // 549: decode to AIF_FBCI_PS using decoder 165
11491 // 549: }
11492 39, 11, // 554: case 0x27: {
11493 OPC_CheckPredicate, 118, // 556: check predicate 118
11494 OPC_CheckField, 12, 3, 5, // 558: check Inst[14:12] == 0x5
11495 OPC_Decode, 229, 108, 164, 1, // 562: decode to AIF_FSQ2 using decoder 164
11496 // 562: }
11497 59, 231, 3, // 567: case 0x3b: {
11498 OPC_SwitchField, 25, 7, // 570: switch Inst[31:25] {
11499 0, 19, // 573: case 0x0: {
11500 OPC_SwitchField, 12, 3, // 575: switch Inst[14:12] {
11501 2, 6, // 578: case 0x2: {
11502 OPC_CheckPredicate, 118, // 580: check predicate 118
11503 OPC_Decode, 175, 107, 53, // 582: decode to AIF_AMOADDL_W using decoder 53
11504 // 582: }
11505 3, 0, // 586: case 0x3: {
11506 OPC_CheckPredicate, 118, // 588: check predicate 118
11507 OPC_Decode, 174, 107, 53, // 590: decode to AIF_AMOADDL_D using decoder 53
11508 // 590: }
11509 // 590: } // switch Inst[14:12]
11510 // 590: }
11511 1, 19, // 594: case 0x1: {
11512 OPC_SwitchField, 12, 3, // 596: switch Inst[14:12] {
11513 2, 6, // 599: case 0x2: {
11514 OPC_CheckPredicate, 118, // 601: check predicate 118
11515 OPC_Decode, 173, 107, 53, // 603: decode to AIF_AMOADDG_W using decoder 53
11516 // 603: }
11517 3, 0, // 607: case 0x3: {
11518 OPC_CheckPredicate, 118, // 609: check predicate 118
11519 OPC_Decode, 172, 107, 53, // 611: decode to AIF_AMOADDG_D using decoder 53
11520 // 611: }
11521 // 611: } // switch Inst[14:12]
11522 // 611: }
11523 4, 19, // 615: case 0x4: {
11524 OPC_SwitchField, 12, 3, // 617: switch Inst[14:12] {
11525 2, 6, // 620: case 0x2: {
11526 OPC_CheckPredicate, 118, // 622: check predicate 118
11527 OPC_Decode, 207, 107, 53, // 624: decode to AIF_AMOSWAPL_W using decoder 53
11528 // 624: }
11529 3, 0, // 628: case 0x3: {
11530 OPC_CheckPredicate, 118, // 630: check predicate 118
11531 OPC_Decode, 206, 107, 53, // 632: decode to AIF_AMOSWAPL_D using decoder 53
11532 // 632: }
11533 // 632: } // switch Inst[14:12]
11534 // 632: }
11535 5, 19, // 636: case 0x5: {
11536 OPC_SwitchField, 12, 3, // 638: switch Inst[14:12] {
11537 2, 6, // 641: case 0x2: {
11538 OPC_CheckPredicate, 118, // 643: check predicate 118
11539 OPC_Decode, 205, 107, 53, // 645: decode to AIF_AMOSWAPG_W using decoder 53
11540 // 645: }
11541 3, 0, // 649: case 0x3: {
11542 OPC_CheckPredicate, 118, // 651: check predicate 118
11543 OPC_Decode, 204, 107, 53, // 653: decode to AIF_AMOSWAPG_D using decoder 53
11544 // 653: }
11545 // 653: } // switch Inst[14:12]
11546 // 653: }
11547 8, 10, // 657: case 0x8: {
11548 OPC_CheckPredicate, 118, // 659: check predicate 118
11549 OPC_CheckField, 7, 8, 96, // 661: check Inst[14:7] == 0x60
11550 OPC_Decode, 254, 108, 56, // 665: decode to AIF_SBL using decoder 56
11551 // 665: }
11552 9, 10, // 669: case 0x9: {
11553 OPC_CheckPredicate, 118, // 671: check predicate 118
11554 OPC_CheckField, 7, 8, 96, // 673: check Inst[14:7] == 0x60
11555 OPC_Decode, 253, 108, 56, // 677: decode to AIF_SBG using decoder 56
11556 // 677: }
11557 12, 10, // 681: case 0xc: {
11558 OPC_CheckPredicate, 118, // 683: check predicate 118
11559 OPC_CheckField, 7, 8, 96, // 685: check Inst[14:7] == 0x60
11560 OPC_Decode, 128, 109, 56, // 689: decode to AIF_SHL using decoder 56
11561 // 689: }
11562 13, 10, // 693: case 0xd: {
11563 OPC_CheckPredicate, 118, // 695: check predicate 118
11564 OPC_CheckField, 7, 8, 96, // 697: check Inst[14:7] == 0x60
11565 OPC_Decode, 255, 108, 56, // 701: decode to AIF_SHG using decoder 56
11566 // 701: }
11567 16, 19, // 705: case 0x10: {
11568 OPC_SwitchField, 12, 3, // 707: switch Inst[14:12] {
11569 2, 6, // 710: case 0x2: {
11570 OPC_CheckPredicate, 118, // 712: check predicate 118
11571 OPC_Decode, 211, 107, 53, // 714: decode to AIF_AMOXORL_W using decoder 53
11572 // 714: }
11573 3, 0, // 718: case 0x3: {
11574 OPC_CheckPredicate, 118, // 720: check predicate 118
11575 OPC_Decode, 210, 107, 53, // 722: decode to AIF_AMOXORL_D using decoder 53
11576 // 722: }
11577 // 722: } // switch Inst[14:12]
11578 // 722: }
11579 17, 19, // 726: case 0x11: {
11580 OPC_SwitchField, 12, 3, // 728: switch Inst[14:12] {
11581 2, 6, // 731: case 0x2: {
11582 OPC_CheckPredicate, 118, // 733: check predicate 118
11583 OPC_Decode, 209, 107, 53, // 735: decode to AIF_AMOXORG_W using decoder 53
11584 // 735: }
11585 3, 0, // 739: case 0x3: {
11586 OPC_CheckPredicate, 118, // 741: check predicate 118
11587 OPC_Decode, 208, 107, 53, // 743: decode to AIF_AMOXORG_D using decoder 53
11588 // 743: }
11589 // 743: } // switch Inst[14:12]
11590 // 743: }
11591 32, 19, // 747: case 0x20: {
11592 OPC_SwitchField, 12, 3, // 749: switch Inst[14:12] {
11593 2, 6, // 752: case 0x2: {
11594 OPC_CheckPredicate, 118, // 754: check predicate 118
11595 OPC_Decode, 203, 107, 53, // 756: decode to AIF_AMOORL_W using decoder 53
11596 // 756: }
11597 3, 0, // 760: case 0x3: {
11598 OPC_CheckPredicate, 118, // 762: check predicate 118
11599 OPC_Decode, 202, 107, 53, // 764: decode to AIF_AMOORL_D using decoder 53
11600 // 764: }
11601 // 764: } // switch Inst[14:12]
11602 // 764: }
11603 33, 19, // 768: case 0x21: {
11604 OPC_SwitchField, 12, 3, // 770: switch Inst[14:12] {
11605 2, 6, // 773: case 0x2: {
11606 OPC_CheckPredicate, 118, // 775: check predicate 118
11607 OPC_Decode, 201, 107, 53, // 777: decode to AIF_AMOORG_W using decoder 53
11608 // 777: }
11609 3, 0, // 781: case 0x3: {
11610 OPC_CheckPredicate, 118, // 783: check predicate 118
11611 OPC_Decode, 200, 107, 53, // 785: decode to AIF_AMOORG_D using decoder 53
11612 // 785: }
11613 // 785: } // switch Inst[14:12]
11614 // 785: }
11615 48, 19, // 789: case 0x30: {
11616 OPC_SwitchField, 12, 3, // 791: switch Inst[14:12] {
11617 2, 6, // 794: case 0x2: {
11618 OPC_CheckPredicate, 118, // 796: check predicate 118
11619 OPC_Decode, 179, 107, 53, // 798: decode to AIF_AMOANDL_W using decoder 53
11620 // 798: }
11621 3, 0, // 802: case 0x3: {
11622 OPC_CheckPredicate, 118, // 804: check predicate 118
11623 OPC_Decode, 178, 107, 53, // 806: decode to AIF_AMOANDL_D using decoder 53
11624 // 806: }
11625 // 806: } // switch Inst[14:12]
11626 // 806: }
11627 49, 19, // 810: case 0x31: {
11628 OPC_SwitchField, 12, 3, // 812: switch Inst[14:12] {
11629 2, 6, // 815: case 0x2: {
11630 OPC_CheckPredicate, 118, // 817: check predicate 118
11631 OPC_Decode, 177, 107, 53, // 819: decode to AIF_AMOANDG_W using decoder 53
11632 // 819: }
11633 3, 0, // 823: case 0x3: {
11634 OPC_CheckPredicate, 118, // 825: check predicate 118
11635 OPC_Decode, 176, 107, 53, // 827: decode to AIF_AMOANDG_D using decoder 53
11636 // 827: }
11637 // 827: } // switch Inst[14:12]
11638 // 827: }
11639 64, 35, // 831: case 0x40: {
11640 OPC_SwitchField, 12, 3, // 833: switch Inst[14:12] {
11641 2, 6, // 836: case 0x2: {
11642 OPC_CheckPredicate, 118, // 838: check predicate 118
11643 OPC_Decode, 195, 107, 53, // 840: decode to AIF_AMOMINL_W using decoder 53
11644 // 840: }
11645 3, 6, // 844: case 0x3: {
11646 OPC_CheckPredicate, 118, // 846: check predicate 118
11647 OPC_Decode, 194, 107, 53, // 848: decode to AIF_AMOMINL_D using decoder 53
11648 // 848: }
11649 6, 6, // 852: case 0x6: {
11650 OPC_CheckPredicate, 118, // 854: check predicate 118
11651 OPC_Decode, 252, 108, 30, // 856: decode to AIF_PACKB using decoder 30
11652 // 856: }
11653 7, 0, // 860: case 0x7: {
11654 OPC_CheckPredicate, 118, // 862: check predicate 118
11655 OPC_Decode, 212, 107, 30, // 864: decode to AIF_BITMIXB using decoder 30
11656 // 864: }
11657 // 864: } // switch Inst[14:12]
11658 // 864: }
11659 65, 19, // 868: case 0x41: {
11660 OPC_SwitchField, 12, 3, // 870: switch Inst[14:12] {
11661 2, 6, // 873: case 0x2: {
11662 OPC_CheckPredicate, 118, // 875: check predicate 118
11663 OPC_Decode, 193, 107, 53, // 877: decode to AIF_AMOMING_W using decoder 53
11664 // 877: }
11665 3, 0, // 881: case 0x3: {
11666 OPC_CheckPredicate, 118, // 883: check predicate 118
11667 OPC_Decode, 192, 107, 53, // 885: decode to AIF_AMOMING_D using decoder 53
11668 // 885: }
11669 // 885: } // switch Inst[14:12]
11670 // 885: }
11671 80, 19, // 889: case 0x50: {
11672 OPC_SwitchField, 12, 3, // 891: switch Inst[14:12] {
11673 2, 6, // 894: case 0x2: {
11674 OPC_CheckPredicate, 118, // 896: check predicate 118
11675 OPC_Decode, 187, 107, 53, // 898: decode to AIF_AMOMAXL_W using decoder 53
11676 // 898: }
11677 3, 0, // 902: case 0x3: {
11678 OPC_CheckPredicate, 118, // 904: check predicate 118
11679 OPC_Decode, 186, 107, 53, // 906: decode to AIF_AMOMAXL_D using decoder 53
11680 // 906: }
11681 // 906: } // switch Inst[14:12]
11682 // 906: }
11683 81, 19, // 910: case 0x51: {
11684 OPC_SwitchField, 12, 3, // 912: switch Inst[14:12] {
11685 2, 6, // 915: case 0x2: {
11686 OPC_CheckPredicate, 118, // 917: check predicate 118
11687 OPC_Decode, 185, 107, 53, // 919: decode to AIF_AMOMAXG_W using decoder 53
11688 // 919: }
11689 3, 0, // 923: case 0x3: {
11690 OPC_CheckPredicate, 118, // 925: check predicate 118
11691 OPC_Decode, 184, 107, 53, // 927: decode to AIF_AMOMAXG_D using decoder 53
11692 // 927: }
11693 // 927: } // switch Inst[14:12]
11694 // 927: }
11695 96, 19, // 931: case 0x60: {
11696 OPC_SwitchField, 12, 3, // 933: switch Inst[14:12] {
11697 2, 6, // 936: case 0x2: {
11698 OPC_CheckPredicate, 118, // 938: check predicate 118
11699 OPC_Decode, 199, 107, 53, // 940: decode to AIF_AMOMINUL_W using decoder 53
11700 // 940: }
11701 3, 0, // 944: case 0x3: {
11702 OPC_CheckPredicate, 118, // 946: check predicate 118
11703 OPC_Decode, 198, 107, 53, // 948: decode to AIF_AMOMINUL_D using decoder 53
11704 // 948: }
11705 // 948: } // switch Inst[14:12]
11706 // 948: }
11707 97, 19, // 952: case 0x61: {
11708 OPC_SwitchField, 12, 3, // 954: switch Inst[14:12] {
11709 2, 6, // 957: case 0x2: {
11710 OPC_CheckPredicate, 118, // 959: check predicate 118
11711 OPC_Decode, 197, 107, 53, // 961: decode to AIF_AMOMINUG_W using decoder 53
11712 // 961: }
11713 3, 0, // 965: case 0x3: {
11714 OPC_CheckPredicate, 118, // 967: check predicate 118
11715 OPC_Decode, 196, 107, 53, // 969: decode to AIF_AMOMINUG_D using decoder 53
11716 // 969: }
11717 // 969: } // switch Inst[14:12]
11718 // 969: }
11719 112, 19, // 973: case 0x70: {
11720 OPC_SwitchField, 12, 3, // 975: switch Inst[14:12] {
11721 2, 6, // 978: case 0x2: {
11722 OPC_CheckPredicate, 118, // 980: check predicate 118
11723 OPC_Decode, 191, 107, 53, // 982: decode to AIF_AMOMAXUL_W using decoder 53
11724 // 982: }
11725 3, 0, // 986: case 0x3: {
11726 OPC_CheckPredicate, 118, // 988: check predicate 118
11727 OPC_Decode, 190, 107, 53, // 990: decode to AIF_AMOMAXUL_D using decoder 53
11728 // 990: }
11729 // 990: } // switch Inst[14:12]
11730 // 990: }
11731 113, 19, // 994: case 0x71: {
11732 OPC_SwitchField, 12, 3, // 996: switch Inst[14:12] {
11733 2, 6, // 999: case 0x2: {
11734 OPC_CheckPredicate, 118, // 1001: check predicate 118
11735 OPC_Decode, 189, 107, 53, // 1003: decode to AIF_AMOMAXUG_W using decoder 53
11736 // 1003: }
11737 3, 0, // 1007: case 0x3: {
11738 OPC_CheckPredicate, 118, // 1009: check predicate 118
11739 OPC_Decode, 188, 107, 53, // 1011: decode to AIF_AMOMAXUG_D using decoder 53
11740 // 1011: }
11741 // 1011: } // switch Inst[14:12]
11742 // 1011: }
11743 120, 19, // 1015: case 0x78: {
11744 OPC_SwitchField, 12, 3, // 1017: switch Inst[14:12] {
11745 2, 6, // 1020: case 0x2: {
11746 OPC_CheckPredicate, 118, // 1022: check predicate 118
11747 OPC_Decode, 183, 107, 53, // 1024: decode to AIF_AMOCMPSWAPL_W using decoder 53
11748 // 1024: }
11749 3, 0, // 1028: case 0x3: {
11750 OPC_CheckPredicate, 118, // 1030: check predicate 118
11751 OPC_Decode, 182, 107, 53, // 1032: decode to AIF_AMOCMPSWAPL_D using decoder 53
11752 // 1032: }
11753 // 1032: } // switch Inst[14:12]
11754 // 1032: }
11755 121, 0, // 1036: case 0x79: {
11756 OPC_SwitchField, 12, 3, // 1038: switch Inst[14:12] {
11757 2, 6, // 1041: case 0x2: {
11758 OPC_CheckPredicate, 118, // 1043: check predicate 118
11759 OPC_Decode, 181, 107, 53, // 1045: decode to AIF_AMOCMPSWAPG_W using decoder 53
11760 // 1045: }
11761 3, 0, // 1049: case 0x3: {
11762 OPC_CheckPredicate, 118, // 1051: check predicate 118
11763 OPC_Decode, 180, 107, 53, // 1053: decode to AIF_AMOCMPSWAPG_D using decoder 53
11764 // 1053: }
11765 // 1053: } // switch Inst[14:12]
11766 // 1053: }
11767 // 1053: } // switch Inst[31:25]
11768 // 1053: }
11769 63, 42, // 1057: case 0x3f: {
11770 OPC_SwitchField, 12, 3, // 1059: switch Inst[14:12] {
11771 0, 11, // 1062: case 0x0: {
11772 OPC_CheckPredicate, 118, // 1064: check predicate 118
11773 OPC_CheckField, 25, 2, 2, // 1066: check Inst[26:25] == 0x2
11774 OPC_Decode, 217, 107, 166, 1, // 1070: decode to AIF_FADDI_PI using decoder 166
11775 // 1070: }
11776 1, 11, // 1075: case 0x1: {
11777 OPC_CheckPredicate, 118, // 1077: check predicate 118
11778 OPC_CheckField, 25, 2, 2, // 1079: check Inst[26:25] == 0x2
11779 OPC_Decode, 242, 107, 166, 1, // 1083: decode to AIF_FANDI_PI using decoder 166
11780 // 1083: }
11781 2, 0, // 1088: case 0x2: {
11782 OPC_CheckPredicate, 118, // 1090: check predicate 118
11783 OPC_CheckField, 25, 2, 2, // 1092: check Inst[26:25] == 0x2
11784 OPC_Decode, 250, 107, 167, 1, // 1096: decode to AIF_FCMOV_PS using decoder 167
11785 // 1096: }
11786 // 1096: } // switch Inst[14:12]
11787 // 1096: }
11788 91, 39, // 1101: case 0x5b: {
11789 OPC_SwitchField, 25, 2, // 1103: switch Inst[26:25] {
11790 0, 7, // 1106: case 0x0: {
11791 OPC_CheckPredicate, 118, // 1108: check predicate 118
11792 OPC_Decode, 182, 108, 168, 1, // 1110: decode to AIF_FMADD_PS using decoder 168
11793 // 1110: }
11794 1, 7, // 1115: case 0x1: {
11795 OPC_CheckPredicate, 118, // 1117: check predicate 118
11796 OPC_Decode, 189, 108, 168, 1, // 1119: decode to AIF_FMSUB_PS using decoder 168
11797 // 1119: }
11798 2, 7, // 1124: case 0x2: {
11799 OPC_CheckPredicate, 118, // 1126: check predicate 118
11800 OPC_Decode, 197, 108, 168, 1, // 1128: decode to AIF_FNMSUB_PS using decoder 168
11801 // 1128: }
11802 3, 0, // 1133: case 0x3: {
11803 OPC_CheckPredicate, 118, // 1135: check predicate 118
11804 OPC_Decode, 196, 108, 168, 1, // 1137: decode to AIF_FNMADD_PS using decoder 168
11805 // 1137: }
11806 // 1137: } // switch Inst[26:25]
11807 // 1137: }
11808 95, 7, // 1142: case 0x5f: {
11809 OPC_CheckPredicate, 118, // 1144: check predicate 118
11810 OPC_Decode, 244, 107, 165, 1, // 1146: decode to AIF_FBCI_PI using decoder 165
11811 // 1146: }
11812 119, 15, // 1151: case 0x77: {
11813 OPC_CheckPredicate, 118, // 1153: check predicate 118
11814 OPC_CheckField, 25, 7, 0, // 1155: check Inst[31:25] == 0x0
11815 OPC_CheckField, 12, 3, 0, // 1159: check Inst[14:12] == 0x0
11816 OPC_Decode, 249, 107, 169, 1, // 1163: decode to AIF_FCMOVM_PS using decoder 169
11817 // 1163: }
11818 123, 0, // 1168: case 0x7b: {
11819 OPC_SwitchField, 25, 7, // 1170: switch Inst[31:25] {
11820 0, 7, // 1173: case 0x0: {
11821 OPC_CheckPredicate, 118, // 1175: check predicate 118
11822 OPC_Decode, 219, 107, 170, 1, // 1177: decode to AIF_FADD_PS using decoder 170
11823 // 1177: }
11824 3, 93, // 1182: case 0x3: {
11825 OPC_SwitchField, 12, 3, // 1184: switch Inst[14:12] {
11826 0, 7, // 1187: case 0x0: {
11827 OPC_CheckPredicate, 118, // 1189: check predicate 118
11828 OPC_Decode, 218, 107, 169, 1, // 1191: decode to AIF_FADD_PI using decoder 169
11829 // 1191: }
11830 1, 7, // 1196: case 0x1: {
11831 OPC_CheckPredicate, 118, // 1198: check predicate 118
11832 OPC_Decode, 228, 108, 169, 1, // 1200: decode to AIF_FSLL_PI using decoder 169
11833 // 1200: }
11834 2, 11, // 1205: case 0x2: {
11835 OPC_CheckPredicate, 118, // 1207: check predicate 118
11836 OPC_CheckField, 20, 5, 0, // 1209: check Inst[24:20] == 0x0
11837 OPC_Decode, 198, 108, 171, 1, // 1213: decode to AIF_FNOT_PI using decoder 171
11838 // 1213: }
11839 3, 21, // 1218: case 0x3: {
11840 OPC_SwitchField, 20, 5, // 1220: switch Inst[24:20] {
11841 0, 7, // 1223: case 0x0: {
11842 OPC_CheckPredicate, 118, // 1225: check predicate 118
11843 OPC_Decode, 208, 108, 171, 1, // 1227: decode to AIF_FSAT8_PI using decoder 171
11844 // 1227: }
11845 1, 0, // 1232: case 0x1: {
11846 OPC_CheckPredicate, 118, // 1234: check predicate 118
11847 OPC_Decode, 209, 108, 171, 1, // 1236: decode to AIF_FSATU8_PI using decoder 171
11848 // 1236: }
11849 // 1236: } // switch Inst[24:20]
11850 // 1236: }
11851 4, 7, // 1241: case 0x4: {
11852 OPC_CheckPredicate, 118, // 1243: check predicate 118
11853 OPC_Decode, 241, 108, 169, 1, // 1245: decode to AIF_FXOR_PI using decoder 169
11854 // 1245: }
11855 5, 7, // 1250: case 0x5: {
11856 OPC_CheckPredicate, 118, // 1252: check predicate 118
11857 OPC_Decode, 234, 108, 169, 1, // 1254: decode to AIF_FSRL_PI using decoder 169
11858 // 1254: }
11859 6, 7, // 1259: case 0x6: {
11860 OPC_CheckPredicate, 118, // 1261: check predicate 118
11861 OPC_Decode, 199, 108, 169, 1, // 1263: decode to AIF_FOR_PI using decoder 169
11862 // 1263: }
11863 7, 0, // 1268: case 0x7: {
11864 OPC_CheckPredicate, 118, // 1270: check predicate 118
11865 OPC_Decode, 243, 107, 169, 1, // 1272: decode to AIF_FAND_PI using decoder 169
11866 // 1272: }
11867 // 1272: } // switch Inst[14:12]
11868 // 1272: }
11869 4, 7, // 1277: case 0x4: {
11870 OPC_CheckPredicate, 118, // 1279: check predicate 118
11871 OPC_Decode, 236, 108, 170, 1, // 1281: decode to AIF_FSUB_PS using decoder 170
11872 // 1281: }
11873 7, 21, // 1286: case 0x7: {
11874 OPC_SwitchField, 12, 3, // 1288: switch Inst[14:12] {
11875 0, 7, // 1291: case 0x0: {
11876 OPC_CheckPredicate, 118, // 1293: check predicate 118
11877 OPC_Decode, 235, 108, 169, 1, // 1295: decode to AIF_FSUB_PI using decoder 169
11878 // 1295: }
11879 5, 0, // 1300: case 0x5: {
11880 OPC_CheckPredicate, 118, // 1302: check predicate 118
11881 OPC_Decode, 232, 108, 169, 1, // 1304: decode to AIF_FSRA_PI using decoder 169
11882 // 1304: }
11883 // 1304: } // switch Inst[14:12]
11884 // 1304: }
11885 8, 7, // 1309: case 0x8: {
11886 OPC_CheckPredicate, 118, // 1311: check predicate 118
11887 OPC_Decode, 193, 108, 170, 1, // 1313: decode to AIF_FMUL_PS using decoder 170
11888 // 1313: }
11889 11, 30, // 1318: case 0xb: {
11890 OPC_SwitchField, 12, 3, // 1320: switch Inst[14:12] {
11891 0, 7, // 1323: case 0x0: {
11892 OPC_CheckPredicate, 118, // 1325: check predicate 118
11893 OPC_Decode, 192, 108, 169, 1, // 1327: decode to AIF_FMUL_PI using decoder 169
11894 // 1327: }
11895 1, 7, // 1332: case 0x1: {
11896 OPC_CheckPredicate, 118, // 1334: check predicate 118
11897 OPC_Decode, 191, 108, 169, 1, // 1336: decode to AIF_FMULH_PI using decoder 169
11898 // 1336: }
11899 2, 0, // 1341: case 0x2: {
11900 OPC_CheckPredicate, 118, // 1343: check predicate 118
11901 OPC_Decode, 190, 108, 169, 1, // 1345: decode to AIF_FMULHU_PI using decoder 169
11902 // 1345: }
11903 // 1345: } // switch Inst[14:12]
11904 // 1345: }
11905 12, 7, // 1350: case 0xc: {
11906 OPC_CheckPredicate, 118, // 1352: check predicate 118
11907 OPC_Decode, 151, 108, 170, 1, // 1354: decode to AIF_FDIV_PS using decoder 170
11908 // 1354: }
11909 15, 39, // 1359: case 0xf: {
11910 OPC_SwitchField, 12, 3, // 1361: switch Inst[14:12] {
11911 0, 7, // 1364: case 0x0: {
11912 OPC_CheckPredicate, 118, // 1366: check predicate 118
11913 OPC_Decode, 150, 108, 169, 1, // 1368: decode to AIF_FDIV_PI using decoder 169
11914 // 1368: }
11915 1, 7, // 1373: case 0x1: {
11916 OPC_CheckPredicate, 118, // 1375: check predicate 118
11917 OPC_Decode, 149, 108, 169, 1, // 1377: decode to AIF_FDIVU_PI using decoder 169
11918 // 1377: }
11919 2, 7, // 1382: case 0x2: {
11920 OPC_CheckPredicate, 118, // 1384: check predicate 118
11921 OPC_Decode, 205, 108, 169, 1, // 1386: decode to AIF_FREM_PI using decoder 169
11922 // 1386: }
11923 3, 0, // 1391: case 0x3: {
11924 OPC_CheckPredicate, 118, // 1393: check predicate 118
11925 OPC_Decode, 204, 108, 169, 1, // 1395: decode to AIF_FREMU_PI using decoder 169
11926 // 1395: }
11927 // 1395: } // switch Inst[14:12]
11928 // 1395: }
11929 16, 30, // 1400: case 0x10: {
11930 OPC_SwitchField, 12, 3, // 1402: switch Inst[14:12] {
11931 0, 7, // 1405: case 0x0: {
11932 OPC_CheckPredicate, 118, // 1407: check predicate 118
11933 OPC_Decode, 225, 108, 169, 1, // 1409: decode to AIF_FSGNJ_PS using decoder 169
11934 // 1409: }
11935 1, 7, // 1414: case 0x1: {
11936 OPC_CheckPredicate, 118, // 1416: check predicate 118
11937 OPC_Decode, 223, 108, 169, 1, // 1418: decode to AIF_FSGNJN_PS using decoder 169
11938 // 1418: }
11939 2, 0, // 1423: case 0x2: {
11940 OPC_CheckPredicate, 118, // 1425: check predicate 118
11941 OPC_Decode, 224, 108, 169, 1, // 1427: decode to AIF_FSGNJX_PS using decoder 169
11942 // 1427: }
11943 // 1427: } // switch Inst[14:12]
11944 // 1427: }
11945 19, 29, // 1432: case 0x13: {
11946 OPC_SwitchField, 12, 3, // 1434: switch Inst[14:12] {
11947 0, 11, // 1437: case 0x0: {
11948 OPC_CheckPredicate, 118, // 1439: check predicate 118
11949 OPC_CheckField, 20, 5, 0, // 1441: check Inst[24:20] == 0x0
11950 OPC_Decode, 200, 108, 171, 1, // 1445: decode to AIF_FPACKREPB_PI using decoder 171
11951 // 1445: }
11952 1, 0, // 1450: case 0x1: {
11953 OPC_CheckPredicate, 118, // 1452: check predicate 118
11954 OPC_CheckField, 20, 5, 0, // 1454: check Inst[24:20] == 0x0
11955 OPC_Decode, 201, 108, 171, 1, // 1458: decode to AIF_FPACKREPH_PI using decoder 171
11956 // 1458: }
11957 // 1458: } // switch Inst[14:12]
11958 // 1458: }
11959 20, 21, // 1463: case 0x14: {
11960 OPC_SwitchField, 12, 3, // 1465: switch Inst[14:12] {
11961 0, 7, // 1468: case 0x0: {
11962 OPC_CheckPredicate, 118, // 1470: check predicate 118
11963 OPC_Decode, 188, 108, 169, 1, // 1472: decode to AIF_FMIN_PS using decoder 169
11964 // 1472: }
11965 1, 0, // 1477: case 0x1: {
11966 OPC_CheckPredicate, 118, // 1479: check predicate 118
11967 OPC_Decode, 185, 108, 169, 1, // 1481: decode to AIF_FMAX_PS using decoder 169
11968 // 1481: }
11969 // 1481: } // switch Inst[14:12]
11970 // 1481: }
11971 23, 39, // 1486: case 0x17: {
11972 OPC_SwitchField, 12, 3, // 1488: switch Inst[14:12] {
11973 0, 7, // 1491: case 0x0: {
11974 OPC_CheckPredicate, 118, // 1493: check predicate 118
11975 OPC_Decode, 187, 108, 169, 1, // 1495: decode to AIF_FMIN_PI using decoder 169
11976 // 1495: }
11977 1, 7, // 1500: case 0x1: {
11978 OPC_CheckPredicate, 118, // 1502: check predicate 118
11979 OPC_Decode, 184, 108, 169, 1, // 1504: decode to AIF_FMAX_PI using decoder 169
11980 // 1504: }
11981 2, 7, // 1509: case 0x2: {
11982 OPC_CheckPredicate, 118, // 1511: check predicate 118
11983 OPC_Decode, 186, 108, 169, 1, // 1513: decode to AIF_FMINU_PI using decoder 169
11984 // 1513: }
11985 3, 0, // 1518: case 0x3: {
11986 OPC_CheckPredicate, 118, // 1520: check predicate 118
11987 OPC_Decode, 183, 108, 169, 1, // 1522: decode to AIF_FMAXU_PI using decoder 169
11988 // 1522: }
11989 // 1522: } // switch Inst[14:12]
11990 // 1522: }
11991 24, 11, // 1527: case 0x18: {
11992 OPC_CheckPredicate, 118, // 1529: check predicate 118
11993 OPC_CheckField, 12, 3, 0, // 1531: check Inst[14:12] == 0x0
11994 OPC_Decode, 202, 108, 169, 1, // 1535: decode to AIF_FRCP_FIX_RAST using decoder 169
11995 // 1535: }
11996 31, 11, // 1540: case 0x1f: {
11997 OPC_CheckPredicate, 118, // 1542: check predicate 118
11998 OPC_CheckField, 12, 3, 0, // 1544: check Inst[14:12] == 0x0
11999 OPC_Decode, 174, 108, 172, 1, // 1548: decode to AIF_FLTM_PI using decoder 172
12000 // 1548: }
12001 39, 30, // 1553: case 0x27: {
12002 OPC_SwitchField, 12, 3, // 1555: switch Inst[14:12] {
12003 1, 7, // 1558: case 0x1: {
12004 OPC_CheckPredicate, 118, // 1560: check predicate 118
12005 OPC_Decode, 227, 108, 173, 1, // 1562: decode to AIF_FSLLI_PI using decoder 173
12006 // 1562: }
12007 5, 7, // 1567: case 0x5: {
12008 OPC_CheckPredicate, 118, // 1569: check predicate 118
12009 OPC_Decode, 233, 108, 173, 1, // 1571: decode to AIF_FSRLI_PI using decoder 173
12010 // 1571: }
12011 7, 0, // 1576: case 0x7: {
12012 OPC_CheckPredicate, 118, // 1578: check predicate 118
12013 OPC_Decode, 231, 108, 173, 1, // 1580: decode to AIF_FSRAI_PI using decoder 173
12014 // 1580: }
12015 // 1580: } // switch Inst[14:12]
12016 // 1580: }
12017 41, 15, // 1585: case 0x29: {
12018 OPC_CheckPredicate, 118, // 1587: check predicate 118
12019 OPC_CheckField, 18, 7, 0, // 1589: check Inst[24:18] == 0x0
12020 OPC_CheckField, 12, 3, 0, // 1593: check Inst[14:12] == 0x0
12021 OPC_Decode, 245, 108, 174, 1, // 1597: decode to AIF_MASKPOPC using decoder 174
12022 // 1597: }
12023 42, 15, // 1602: case 0x2a: {
12024 OPC_CheckPredicate, 118, // 1604: check predicate 118
12025 OPC_CheckField, 18, 7, 0, // 1606: check Inst[24:18] == 0x0
12026 OPC_CheckField, 12, 3, 0, // 1610: check Inst[14:12] == 0x0
12027 OPC_Decode, 246, 108, 174, 1, // 1614: decode to AIF_MASKPOPCZ using decoder 174
12028 // 1614: }
12029 43, 11, // 1619: case 0x2b: {
12030 OPC_CheckPredicate, 118, // 1621: check predicate 118
12031 OPC_CheckField, 10, 2, 0, // 1623: check Inst[11:10] == 0x0
12032 OPC_Decode, 251, 108, 175, 1, // 1627: decode to AIF_MOV_M_X using decoder 175
12033 // 1627: }
12034 44, 103, // 1632: case 0x2c: {
12035 OPC_SwitchField, 20, 5, // 1634: switch Inst[24:20] {
12036 0, 11, // 1637: case 0x0: {
12037 OPC_CheckPredicate, 118, // 1639: check predicate 118
12038 OPC_CheckField, 12, 3, 0, // 1641: check Inst[14:12] == 0x0
12039 OPC_Decode, 230, 108, 171, 1, // 1645: decode to AIF_FSQRT_PS using decoder 171
12040 // 1645: }
12041 1, 7, // 1650: case 0x1: {
12042 OPC_CheckPredicate, 118, // 1652: check predicate 118
12043 OPC_Decode, 206, 108, 176, 1, // 1654: decode to AIF_FROUND_PS using decoder 176
12044 // 1654: }
12045 2, 11, // 1659: case 0x2: {
12046 OPC_CheckPredicate, 118, // 1661: check predicate 118
12047 OPC_CheckField, 12, 3, 0, // 1663: check Inst[14:12] == 0x0
12048 OPC_Decode, 156, 108, 171, 1, // 1667: decode to AIF_FFRC_PS using decoder 171
12049 // 1667: }
12050 3, 11, // 1672: case 0x3: {
12051 OPC_CheckPredicate, 118, // 1674: check predicate 118
12052 OPC_CheckField, 12, 3, 0, // 1676: check Inst[14:12] == 0x0
12053 OPC_Decode, 172, 108, 171, 1, // 1680: decode to AIF_FLOG_PS using decoder 171
12054 // 1680: }
12055 4, 11, // 1685: case 0x4: {
12056 OPC_CheckPredicate, 118, // 1687: check predicate 118
12057 OPC_CheckField, 12, 3, 0, // 1689: check Inst[14:12] == 0x0
12058 OPC_Decode, 155, 108, 171, 1, // 1693: decode to AIF_FEXP_PS using decoder 171
12059 // 1693: }
12060 6, 11, // 1698: case 0x6: {
12061 OPC_CheckPredicate, 118, // 1700: check predicate 118
12062 OPC_CheckField, 12, 3, 0, // 1702: check Inst[14:12] == 0x0
12063 OPC_Decode, 226, 108, 171, 1, // 1706: decode to AIF_FSIN_PS using decoder 171
12064 // 1706: }
12065 7, 11, // 1711: case 0x7: {
12066 OPC_CheckPredicate, 118, // 1713: check predicate 118
12067 OPC_CheckField, 12, 3, 0, // 1715: check Inst[14:12] == 0x0
12068 OPC_Decode, 203, 108, 171, 1, // 1719: decode to AIF_FRCP_PS using decoder 171
12069 // 1719: }
12070 8, 0, // 1724: case 0x8: {
12071 OPC_CheckPredicate, 118, // 1726: check predicate 118
12072 OPC_CheckField, 12, 3, 0, // 1728: check Inst[14:12] == 0x0
12073 OPC_Decode, 207, 108, 171, 1, // 1732: decode to AIF_FRSQ_PS using decoder 171
12074 // 1732: }
12075 // 1732: } // switch Inst[24:20]
12076 // 1732: }
12077 47, 11, // 1737: case 0x2f: {
12078 OPC_CheckPredicate, 118, // 1739: check predicate 118
12079 OPC_CheckField, 12, 3, 0, // 1741: check Inst[14:12] == 0x0
12080 OPC_Decode, 247, 108, 177, 1, // 1745: decode to AIF_MASKPOPC_ET_RAST using decoder 177
12081 // 1745: }
12082 51, 67, // 1750: case 0x33: {
12083 OPC_SwitchField, 10, 5, // 1752: switch Inst[14:10] {
12084 8, 11, // 1755: case 0x8: {
12085 OPC_CheckPredicate, 118, // 1757: check predicate 118
12086 OPC_CheckField, 18, 7, 0, // 1759: check Inst[24:18] == 0x0
12087 OPC_Decode, 243, 108, 178, 1, // 1763: decode to AIF_MASKNOT using decoder 178
12088 // 1763: }
12089 16, 15, // 1768: case 0x10: {
12090 OPC_CheckPredicate, 118, // 1770: check predicate 118
12091 OPC_CheckField, 23, 2, 0, // 1772: check Inst[24:23] == 0x0
12092 OPC_CheckField, 18, 2, 0, // 1776: check Inst[19:18] == 0x0
12093 OPC_Decode, 248, 108, 179, 1, // 1780: decode to AIF_MASKXOR using decoder 179
12094 // 1780: }
12095 24, 15, // 1785: case 0x18: {
12096 OPC_CheckPredicate, 118, // 1787: check predicate 118
12097 OPC_CheckField, 23, 2, 0, // 1789: check Inst[24:23] == 0x0
12098 OPC_CheckField, 18, 2, 0, // 1793: check Inst[19:18] == 0x0
12099 OPC_Decode, 244, 108, 179, 1, // 1797: decode to AIF_MASKOR using decoder 179
12100 // 1797: }
12101 28, 0, // 1802: case 0x1c: {
12102 OPC_CheckPredicate, 118, // 1804: check predicate 118
12103 OPC_CheckField, 23, 2, 0, // 1806: check Inst[24:23] == 0x0
12104 OPC_CheckField, 18, 2, 0, // 1810: check Inst[19:18] == 0x0
12105 OPC_Decode, 242, 108, 179, 1, // 1814: decode to AIF_MASKAND using decoder 179
12106 // 1814: }
12107 // 1814: } // switch Inst[14:10]
12108 // 1814: }
12109 68, 39, // 1819: case 0x44: {
12110 OPC_SwitchField, 12, 3, // 1821: switch Inst[14:12] {
12111 0, 7, // 1824: case 0x0: {
12112 OPC_CheckPredicate, 118, // 1826: check predicate 118
12113 OPC_Decode, 214, 107, 169, 1, // 1828: decode to AIF_CUBEFACE_PS using decoder 169
12114 // 1828: }
12115 1, 7, // 1833: case 0x1: {
12116 OPC_CheckPredicate, 118, // 1835: check predicate 118
12117 OPC_Decode, 213, 107, 169, 1, // 1837: decode to AIF_CUBEFACEIDX_PS using decoder 169
12118 // 1837: }
12119 2, 7, // 1842: case 0x2: {
12120 OPC_CheckPredicate, 118, // 1844: check predicate 118
12121 OPC_Decode, 215, 107, 169, 1, // 1846: decode to AIF_CUBESGNSC_PS using decoder 169
12122 // 1846: }
12123 3, 0, // 1851: case 0x3: {
12124 OPC_CheckPredicate, 118, // 1853: check predicate 118
12125 OPC_Decode, 216, 107, 169, 1, // 1855: decode to AIF_CUBESGNTC_PS using decoder 169
12126 // 1855: }
12127 // 1855: } // switch Inst[14:12]
12128 // 1855: }
12129 80, 57, // 1860: case 0x50: {
12130 OPC_SwitchField, 12, 3, // 1862: switch Inst[14:12] {
12131 0, 7, // 1865: case 0x0: {
12132 OPC_CheckPredicate, 118, // 1867: check predicate 118
12133 OPC_Decode, 171, 108, 169, 1, // 1869: decode to AIF_FLE_PS using decoder 169
12134 // 1869: }
12135 1, 7, // 1874: case 0x1: {
12136 OPC_CheckPredicate, 118, // 1876: check predicate 118
12137 OPC_Decode, 178, 108, 169, 1, // 1878: decode to AIF_FLT_PS using decoder 169
12138 // 1878: }
12139 2, 7, // 1883: case 0x2: {
12140 OPC_CheckPredicate, 118, // 1885: check predicate 118
12141 OPC_Decode, 154, 108, 169, 1, // 1887: decode to AIF_FEQ_PS using decoder 169
12142 // 1887: }
12143 4, 7, // 1892: case 0x4: {
12144 OPC_CheckPredicate, 118, // 1894: check predicate 118
12145 OPC_Decode, 169, 108, 172, 1, // 1896: decode to AIF_FLEM_PS using decoder 172
12146 // 1896: }
12147 5, 7, // 1901: case 0x5: {
12148 OPC_CheckPredicate, 118, // 1903: check predicate 118
12149 OPC_Decode, 175, 108, 172, 1, // 1905: decode to AIF_FLTM_PS using decoder 172
12150 // 1905: }
12151 6, 0, // 1910: case 0x6: {
12152 OPC_CheckPredicate, 118, // 1912: check predicate 118
12153 OPC_Decode, 152, 108, 172, 1, // 1914: decode to AIF_FEQM_PS using decoder 172
12154 // 1914: }
12155 // 1914: } // switch Inst[14:12]
12156 // 1914: }
12157 83, 52, // 1919: case 0x53: {
12158 OPC_SwitchField, 12, 3, // 1921: switch Inst[14:12] {
12159 0, 7, // 1924: case 0x0: {
12160 OPC_CheckPredicate, 118, // 1926: check predicate 118
12161 OPC_Decode, 170, 108, 169, 1, // 1928: decode to AIF_FLE_PI using decoder 169
12162 // 1928: }
12163 1, 7, // 1933: case 0x1: {
12164 OPC_CheckPredicate, 118, // 1935: check predicate 118
12165 OPC_Decode, 177, 108, 169, 1, // 1937: decode to AIF_FLT_PI using decoder 169
12166 // 1937: }
12167 2, 7, // 1942: case 0x2: {
12168 OPC_CheckPredicate, 118, // 1944: check predicate 118
12169 OPC_Decode, 153, 108, 169, 1, // 1946: decode to AIF_FEQ_PI using decoder 169
12170 // 1946: }
12171 3, 7, // 1951: case 0x3: {
12172 OPC_CheckPredicate, 118, // 1953: check predicate 118
12173 OPC_Decode, 176, 108, 169, 1, // 1955: decode to AIF_FLTU_PI using decoder 169
12174 // 1955: }
12175 4, 0, // 1960: case 0x4: {
12176 OPC_CheckPredicate, 118, // 1962: check predicate 118
12177 OPC_CheckField, 20, 5, 0, // 1964: check Inst[24:20] == 0x0
12178 OPC_Decode, 222, 108, 180, 1, // 1968: decode to AIF_FSETM_PI using decoder 180
12179 // 1968: }
12180 // 1968: } // switch Inst[14:12]
12181 // 1968: }
12182 96, 34, // 1973: case 0x60: {
12183 OPC_SwitchField, 20, 5, // 1975: switch Inst[24:20] {
12184 0, 7, // 1978: case 0x0: {
12185 OPC_CheckPredicate, 118, // 1980: check predicate 118
12186 OPC_Decode, 140, 108, 176, 1, // 1982: decode to AIF_FCVT_PW_PS using decoder 176
12187 // 1982: }
12188 1, 7, // 1987: case 0x1: {
12189 OPC_CheckPredicate, 118, // 1989: check predicate 118
12190 OPC_Decode, 139, 108, 176, 1, // 1991: decode to AIF_FCVT_PWU_PS using decoder 176
12191 // 1991: }
12192 2, 0, // 1996: case 0x2: {
12193 OPC_CheckPredicate, 118, // 1998: check predicate 118
12194 OPC_CheckField, 12, 3, 0, // 2000: check Inst[14:12] == 0x0
12195 OPC_Decode, 141, 108, 171, 1, // 2004: decode to AIF_FCVT_RAST_PS using decoder 171
12196 // 2004: }
12197 // 2004: } // switch Inst[24:20]
12198 // 2004: }
12199 104, 164, 1, // 2009: case 0x68: {
12200 OPC_SwitchField, 20, 5, // 2012: switch Inst[24:20] {
12201 0, 7, // 2015: case 0x0: {
12202 OPC_CheckPredicate, 118, // 2017: check predicate 118
12203 OPC_Decode, 129, 108, 176, 1, // 2019: decode to AIF_FCVT_PS_PW using decoder 176
12204 // 2019: }
12205 1, 7, // 2024: case 0x1: {
12206 OPC_CheckPredicate, 118, // 2026: check predicate 118
12207 OPC_Decode, 130, 108, 176, 1, // 2028: decode to AIF_FCVT_PS_PWU using decoder 176
12208 // 2028: }
12209 2, 11, // 2033: case 0x2: {
12210 OPC_CheckPredicate, 118, // 2035: check predicate 118
12211 OPC_CheckField, 12, 3, 0, // 2037: check Inst[14:12] == 0x0
12212 OPC_Decode, 131, 108, 171, 1, // 2041: decode to AIF_FCVT_PS_RAST using decoder 171
12213 // 2041: }
12214 8, 11, // 2046: case 0x8: {
12215 OPC_CheckPredicate, 118, // 2048: check predicate 118
12216 OPC_CheckField, 12, 3, 0, // 2050: check Inst[14:12] == 0x0
12217 OPC_Decode, 254, 107, 171, 1, // 2054: decode to AIF_FCVT_PS_F10 using decoder 171
12218 // 2054: }
12219 9, 11, // 2059: case 0x9: {
12220 OPC_CheckPredicate, 118, // 2061: check predicate 118
12221 OPC_CheckField, 12, 3, 0, // 2063: check Inst[14:12] == 0x0
12222 OPC_Decode, 255, 107, 171, 1, // 2067: decode to AIF_FCVT_PS_F11 using decoder 171
12223 // 2067: }
12224 10, 11, // 2072: case 0xa: {
12225 OPC_CheckPredicate, 118, // 2074: check predicate 118
12226 OPC_CheckField, 12, 3, 0, // 2076: check Inst[14:12] == 0x0
12227 OPC_Decode, 128, 108, 171, 1, // 2080: decode to AIF_FCVT_PS_F16 using decoder 171
12228 // 2080: }
12229 16, 11, // 2085: case 0x10: {
12230 OPC_CheckPredicate, 118, // 2087: check predicate 118
12231 OPC_CheckField, 12, 3, 0, // 2089: check Inst[14:12] == 0x0
12232 OPC_Decode, 137, 108, 171, 1, // 2093: decode to AIF_FCVT_PS_UN24 using decoder 171
12233 // 2093: }
12234 17, 11, // 2098: case 0x11: {
12235 OPC_CheckPredicate, 118, // 2100: check predicate 118
12236 OPC_CheckField, 12, 3, 0, // 2102: check Inst[14:12] == 0x0
12237 OPC_Decode, 135, 108, 171, 1, // 2106: decode to AIF_FCVT_PS_UN16 using decoder 171
12238 // 2106: }
12239 18, 11, // 2111: case 0x12: {
12240 OPC_CheckPredicate, 118, // 2113: check predicate 118
12241 OPC_CheckField, 12, 3, 0, // 2115: check Inst[14:12] == 0x0
12242 OPC_Decode, 134, 108, 171, 1, // 2119: decode to AIF_FCVT_PS_UN10 using decoder 171
12243 // 2119: }
12244 19, 11, // 2124: case 0x13: {
12245 OPC_CheckPredicate, 118, // 2126: check predicate 118
12246 OPC_CheckField, 12, 3, 0, // 2128: check Inst[14:12] == 0x0
12247 OPC_Decode, 138, 108, 171, 1, // 2132: decode to AIF_FCVT_PS_UN8 using decoder 171
12248 // 2132: }
12249 23, 11, // 2137: case 0x17: {
12250 OPC_CheckPredicate, 118, // 2139: check predicate 118
12251 OPC_CheckField, 12, 3, 0, // 2141: check Inst[14:12] == 0x0
12252 OPC_Decode, 136, 108, 171, 1, // 2145: decode to AIF_FCVT_PS_UN2 using decoder 171
12253 // 2145: }
12254 25, 11, // 2150: case 0x19: {
12255 OPC_CheckPredicate, 118, // 2152: check predicate 118
12256 OPC_CheckField, 12, 3, 0, // 2154: check Inst[14:12] == 0x0
12257 OPC_Decode, 132, 108, 171, 1, // 2158: decode to AIF_FCVT_PS_SN16 using decoder 171
12258 // 2158: }
12259 27, 0, // 2163: case 0x1b: {
12260 OPC_CheckPredicate, 118, // 2165: check predicate 118
12261 OPC_CheckField, 12, 3, 0, // 2167: check Inst[14:12] == 0x0
12262 OPC_Decode, 133, 108, 171, 1, // 2171: decode to AIF_FCVT_PS_SN8 using decoder 171
12263 // 2171: }
12264 // 2171: } // switch Inst[24:20]
12265 // 2171: }
12266 107, 32, // 2176: case 0x6b: {
12267 OPC_SwitchField, 12, 3, // 2178: switch Inst[14:12] {
12268 0, 11, // 2181: case 0x0: {
12269 OPC_CheckPredicate, 118, // 2183: check predicate 118
12270 OPC_CheckField, 15, 10, 0, // 2185: check Inst[24:15] == 0x0
12271 OPC_Decode, 250, 108, 181, 1, // 2189: decode to AIF_MOVA_X_M using decoder 181
12272 // 2189: }
12273 1, 0, // 2194: case 0x1: {
12274 OPC_CheckPredicate, 118, // 2196: check predicate 118
12275 OPC_CheckField, 20, 5, 0, // 2198: check Inst[24:20] == 0x0
12276 OPC_CheckField, 7, 5, 0, // 2202: check Inst[11:7] == 0x0
12277 OPC_Decode, 249, 108, 14, // 2206: decode to AIF_MOVA_M_X using decoder 14
12278 // 2206: }
12279 // 2206: } // switch Inst[14:12]
12280 // 2206: }
12281 108, 133, 1, // 2210: case 0x6c: {
12282 OPC_SwitchField, 20, 5, // 2213: switch Inst[24:20] {
12283 8, 11, // 2216: case 0x8: {
12284 OPC_CheckPredicate, 118, // 2218: check predicate 118
12285 OPC_CheckField, 12, 3, 0, // 2220: check Inst[14:12] == 0x0
12286 OPC_Decode, 252, 107, 171, 1, // 2224: decode to AIF_FCVT_F11_PS using decoder 171
12287 // 2224: }
12288 9, 11, // 2229: case 0x9: {
12289 OPC_CheckPredicate, 118, // 2231: check predicate 118
12290 OPC_CheckField, 12, 3, 0, // 2233: check Inst[14:12] == 0x0
12291 OPC_Decode, 253, 107, 171, 1, // 2237: decode to AIF_FCVT_F16_PS using decoder 171
12292 // 2237: }
12293 11, 11, // 2242: case 0xb: {
12294 OPC_CheckPredicate, 118, // 2244: check predicate 118
12295 OPC_CheckField, 12, 3, 0, // 2246: check Inst[14:12] == 0x0
12296 OPC_Decode, 251, 107, 171, 1, // 2250: decode to AIF_FCVT_F10_PS using decoder 171
12297 // 2250: }
12298 16, 11, // 2255: case 0x10: {
12299 OPC_CheckPredicate, 118, // 2257: check predicate 118
12300 OPC_CheckField, 12, 3, 0, // 2259: check Inst[14:12] == 0x0
12301 OPC_Decode, 146, 108, 171, 1, // 2263: decode to AIF_FCVT_UN24_PS using decoder 171
12302 // 2263: }
12303 17, 11, // 2268: case 0x11: {
12304 OPC_CheckPredicate, 118, // 2270: check predicate 118
12305 OPC_CheckField, 12, 3, 0, // 2272: check Inst[14:12] == 0x0
12306 OPC_Decode, 145, 108, 171, 1, // 2276: decode to AIF_FCVT_UN16_PS using decoder 171
12307 // 2276: }
12308 18, 11, // 2281: case 0x12: {
12309 OPC_CheckPredicate, 118, // 2283: check predicate 118
12310 OPC_CheckField, 12, 3, 0, // 2285: check Inst[14:12] == 0x0
12311 OPC_Decode, 144, 108, 171, 1, // 2289: decode to AIF_FCVT_UN10_PS using decoder 171
12312 // 2289: }
12313 19, 11, // 2294: case 0x13: {
12314 OPC_CheckPredicate, 118, // 2296: check predicate 118
12315 OPC_CheckField, 12, 3, 0, // 2298: check Inst[14:12] == 0x0
12316 OPC_Decode, 148, 108, 171, 1, // 2302: decode to AIF_FCVT_UN8_PS using decoder 171
12317 // 2302: }
12318 23, 11, // 2307: case 0x17: {
12319 OPC_CheckPredicate, 118, // 2309: check predicate 118
12320 OPC_CheckField, 12, 3, 0, // 2311: check Inst[14:12] == 0x0
12321 OPC_Decode, 147, 108, 171, 1, // 2315: decode to AIF_FCVT_UN2_PS using decoder 171
12322 // 2315: }
12323 25, 11, // 2320: case 0x19: {
12324 OPC_CheckPredicate, 118, // 2322: check predicate 118
12325 OPC_CheckField, 12, 3, 0, // 2324: check Inst[14:12] == 0x0
12326 OPC_Decode, 142, 108, 171, 1, // 2328: decode to AIF_FCVT_SN16_PS using decoder 171
12327 // 2328: }
12328 27, 0, // 2333: case 0x1b: {
12329 OPC_CheckPredicate, 118, // 2335: check predicate 118
12330 OPC_CheckField, 12, 3, 0, // 2337: check Inst[14:12] == 0x0
12331 OPC_Decode, 143, 108, 171, 1, // 2341: decode to AIF_FCVT_SN8_PS using decoder 171
12332 // 2341: }
12333 // 2341: } // switch Inst[24:20]
12334 // 2341: }
12335 112, 42, // 2346: case 0x70: {
12336 OPC_SwitchField, 12, 3, // 2348: switch Inst[14:12] {
12337 0, 11, // 2351: case 0x0: {
12338 OPC_CheckPredicate, 118, // 2353: check predicate 118
12339 OPC_CheckField, 23, 2, 0, // 2355: check Inst[24:23] == 0x0
12340 OPC_Decode, 195, 108, 182, 1, // 2359: decode to AIF_FMVZ_X_PS using decoder 182
12341 // 2359: }
12342 1, 11, // 2364: case 0x1: {
12343 OPC_CheckPredicate, 118, // 2366: check predicate 118
12344 OPC_CheckField, 20, 5, 0, // 2368: check Inst[24:20] == 0x0
12345 OPC_Decode, 248, 107, 171, 1, // 2372: decode to AIF_FCLASS_PS using decoder 171
12346 // 2372: }
12347 2, 0, // 2377: case 0x2: {
12348 OPC_CheckPredicate, 118, // 2379: check predicate 118
12349 OPC_CheckField, 23, 2, 0, // 2381: check Inst[24:23] == 0x0
12350 OPC_Decode, 194, 108, 182, 1, // 2385: decode to AIF_FMVS_X_PS using decoder 182
12351 // 2385: }
12352 // 2385: } // switch Inst[14:12]
12353 // 2385: }
12354 115, 0, // 2390: case 0x73: {
12355 OPC_CheckPredicate, 118, // 2392: check predicate 118
12356 OPC_Decode, 238, 108, 183, 1, // 2394: decode to AIF_FSWIZZ_PS using decoder 183
12357 // 2394: }
12358 // 2394: } // switch Inst[31:25]
12359 // 2394: }
12360 // 2394: } // switch Inst[6:0]
12361};
12362static const uint8_t DecoderTableXAndes32[567] = {
12363 32, // 0: BitWidth 32
12364 OPC_SwitchField, 12, 2, // 1: switch Inst[13:12] {
12365 0, 248, 2, // 4: case 0x0: {
12366 OPC_SwitchField, 0, 7, // 7: switch Inst[6:0] {
12367 11, 7, // 10: case 0xb: {
12368 OPC_CheckPredicate, 119, // 12: check predicate 119
12369 OPC_Decode, 224, 117, 184, 1, // 14: decode to NDS_LBGP using decoder 184
12370 // 14: }
12371 43, 21, // 19: case 0x2b: {
12372 OPC_SwitchField, 14, 1, // 21: switch Inst[14] {
12373 0, 7, // 24: case 0x0: {
12374 OPC_CheckPredicate, 119, // 26: check predicate 119
12375 OPC_Decode, 240, 117, 185, 1, // 28: decode to NDS_SHGP using decoder 185
12376 // 28: }
12377 1, 0, // 33: case 0x1: {
12378 OPC_CheckPredicate, 119, // 35: check predicate 119
12379 OPC_Decode, 241, 117, 186, 1, // 37: decode to NDS_SWGP using decoder 186
12380 // 37: }
12381 // 37: } // switch Inst[14]
12382 // 37: }
12383 91, 0, // 42: case 0x5b: {
12384 OPC_SwitchField, 26, 6, // 44: switch Inst[31:26] {
12385 0, 87, // 47: case 0x0: {
12386 OPC_SwitchField, 14, 6, // 49: switch Inst[19:14] {
12387 1, 11, // 52: case 0x1: {
12388 OPC_CheckPredicate, 120, // 54: check predicate 120
12389 OPC_CheckField, 25, 1, 0, // 56: check Inst[25] == 0x0
12390 OPC_Decode, 252, 117, 128, 1, // 60: decode to NDS_VFWCVT_S_BF16 using decoder 128
12391 // 60: }
12392 3, 11, // 65: case 0x3: {
12393 OPC_CheckPredicate, 120, // 67: check predicate 120
12394 OPC_CheckField, 25, 1, 0, // 69: check Inst[25] == 0x0
12395 OPC_Decode, 245, 117, 128, 1, // 73: decode to NDS_VFNCVT_BF16_S using decoder 128
12396 // 73: }
12397 5, 11, // 78: case 0x5: {
12398 OPC_CheckPredicate, 121, // 80: check predicate 121
12399 OPC_CheckField, 25, 1, 0, // 82: check Inst[25] == 0x0
12400 OPC_Decode, 217, 117, 187, 1, // 86: decode to NDS_FCVT_S_BF16 using decoder 187
12401 // 86: }
12402 7, 11, // 91: case 0x7: {
12403 OPC_CheckPredicate, 121, // 93: check predicate 121
12404 OPC_CheckField, 25, 1, 0, // 95: check Inst[25] == 0x0
12405 OPC_Decode, 216, 117, 188, 1, // 99: decode to NDS_FCVT_BF16_S using decoder 188
12406 // 99: }
12407 9, 6, // 104: case 0x9: {
12408 OPC_CheckPredicate, 122, // 106: check predicate 122
12409 OPC_Decode, 250, 117, 116, // 108: decode to NDS_VFWCVT_F_N using decoder 116
12410 // 108: }
12411 11, 6, // 112: case 0xb: {
12412 OPC_CheckPredicate, 122, // 114: check predicate 122
12413 OPC_Decode, 251, 117, 116, // 116: decode to NDS_VFWCVT_F_NU using decoder 116
12414 // 116: }
12415 13, 6, // 120: case 0xd: {
12416 OPC_CheckPredicate, 122, // 122: check predicate 122
12417 OPC_Decode, 248, 117, 116, // 124: decode to NDS_VFWCVT_F_B using decoder 116
12418 // 124: }
12419 15, 0, // 128: case 0xf: {
12420 OPC_CheckPredicate, 122, // 130: check predicate 122
12421 OPC_Decode, 249, 117, 116, // 132: decode to NDS_VFWCVT_F_BU using decoder 116
12422 // 132: }
12423 // 132: } // switch Inst[19:14]
12424 // 132: }
12425 1, 43, // 136: case 0x1: {
12426 OPC_SwitchField, 20, 5, // 138: switch Inst[24:20] {
12427 0, 14, // 141: case 0x0: {
12428 OPC_CheckPredicate, 122, // 143: check predicate 122
12429 OPC_CheckField, 25, 1, 1, // 145: check Inst[25] == 0x1
12430 OPC_CheckField, 14, 1, 1, // 149: check Inst[14] == 0x1
12431 OPC_Decode, 253, 117, 2, // 153: decode to NDS_VLE4_V using decoder 2
12432 // 153: }
12433 2, 10, // 157: case 0x2: {
12434 OPC_CheckPredicate, 123, // 159: check predicate 123
12435 OPC_CheckField, 14, 1, 1, // 161: check Inst[14] == 0x1
12436 OPC_Decode, 254, 117, 1, // 165: decode to NDS_VLN8_V using decoder 1
12437 // 165: }
12438 3, 0, // 169: case 0x3: {
12439 OPC_CheckPredicate, 123, // 171: check predicate 123
12440 OPC_CheckField, 14, 1, 1, // 173: check Inst[14] == 0x1
12441 OPC_Decode, 255, 117, 1, // 177: decode to NDS_VLNU8_V using decoder 1
12442 // 177: }
12443 // 177: } // switch Inst[24:20]
12444 // 177: }
12445 2, 24, // 181: case 0x2: {
12446 OPC_SwitchField, 14, 1, // 183: switch Inst[14] {
12447 0, 10, // 186: case 0x0: {
12448 OPC_CheckPredicate, 119, // 188: check predicate 119
12449 OPC_CheckField, 25, 1, 1, // 190: check Inst[25] == 0x1
12450 OPC_Decode, 230, 117, 53, // 194: decode to NDS_LEA_H using decoder 53
12451 // 194: }
12452 1, 0, // 198: case 0x1: {
12453 OPC_CheckPredicate, 124, // 200: check predicate 124
12454 OPC_Decode, 247, 117, 135, 1, // 202: decode to NDS_VFPMADT_VF using decoder 135
12455 // 202: }
12456 // 202: } // switch Inst[14]
12457 // 202: }
12458 3, 33, // 207: case 0x3: {
12459 OPC_SwitchField, 14, 1, // 209: switch Inst[14] {
12460 0, 19, // 212: case 0x0: {
12461 OPC_SwitchField, 25, 1, // 214: switch Inst[25] {
12462 0, 6, // 217: case 0x0: {
12463 OPC_CheckPredicate, 119, // 219: check predicate 119
12464 OPC_Decode, 232, 117, 53, // 221: decode to NDS_LEA_W using decoder 53
12465 // 221: }
12466 1, 0, // 225: case 0x1: {
12467 OPC_CheckPredicate, 119, // 227: check predicate 119
12468 OPC_Decode, 228, 117, 53, // 229: decode to NDS_LEA_D using decoder 53
12469 // 229: }
12470 // 229: } // switch Inst[25]
12471 // 229: }
12472 1, 0, // 233: case 0x1: {
12473 OPC_CheckPredicate, 124, // 235: check predicate 124
12474 OPC_Decode, 246, 117, 135, 1, // 237: decode to NDS_VFPMADB_VF using decoder 135
12475 // 237: }
12476 // 237: } // switch Inst[14]
12477 // 237: }
12478 4, 33, // 242: case 0x4: {
12479 OPC_SwitchField, 14, 1, // 244: switch Inst[14] {
12480 0, 19, // 247: case 0x0: {
12481 OPC_SwitchField, 25, 1, // 249: switch Inst[25] {
12482 0, 6, // 252: case 0x0: {
12483 OPC_CheckPredicate, 125, // 254: check predicate 125
12484 OPC_Decode, 227, 117, 53, // 256: decode to NDS_LEA_B_ZE using decoder 53
12485 // 256: }
12486 1, 0, // 260: case 0x1: {
12487 OPC_CheckPredicate, 125, // 262: check predicate 125
12488 OPC_Decode, 231, 117, 53, // 264: decode to NDS_LEA_H_ZE using decoder 53
12489 // 264: }
12490 // 264: } // switch Inst[25]
12491 // 264: }
12492 1, 0, // 268: case 0x1: {
12493 OPC_CheckPredicate, 126, // 270: check predicate 126
12494 OPC_Decode, 243, 117, 189, 1, // 272: decode to NDS_VD4DOTS_VV using decoder 189
12495 // 272: }
12496 // 272: } // switch Inst[14]
12497 // 272: }
12498 5, 33, // 277: case 0x5: {
12499 OPC_SwitchField, 14, 1, // 279: switch Inst[14] {
12500 0, 19, // 282: case 0x0: {
12501 OPC_SwitchField, 25, 1, // 284: switch Inst[25] {
12502 0, 6, // 287: case 0x0: {
12503 OPC_CheckPredicate, 125, // 289: check predicate 125
12504 OPC_Decode, 233, 117, 53, // 291: decode to NDS_LEA_W_ZE using decoder 53
12505 // 291: }
12506 1, 0, // 295: case 0x1: {
12507 OPC_CheckPredicate, 125, // 297: check predicate 125
12508 OPC_Decode, 229, 117, 53, // 299: decode to NDS_LEA_D_ZE using decoder 53
12509 // 299: }
12510 // 299: } // switch Inst[25]
12511 // 299: }
12512 1, 0, // 303: case 0x1: {
12513 OPC_CheckPredicate, 126, // 305: check predicate 126
12514 OPC_Decode, 242, 117, 189, 1, // 307: decode to NDS_VD4DOTSU_VV using decoder 189
12515 // 307: }
12516 // 307: } // switch Inst[14]
12517 // 307: }
12518 7, 11, // 312: case 0x7: {
12519 OPC_CheckPredicate, 126, // 314: check predicate 126
12520 OPC_CheckField, 14, 1, 1, // 316: check Inst[14] == 0x1
12521 OPC_Decode, 244, 117, 189, 1, // 320: decode to NDS_VD4DOTU_VV using decoder 189
12522 // 320: }
12523 8, 27, // 325: case 0x8: {
12524 OPC_SwitchField, 25, 1, // 327: switch Inst[25] {
12525 0, 10, // 330: case 0x0: {
12526 OPC_CheckPredicate, 119, // 332: check predicate 119
12527 OPC_CheckField, 14, 1, 0, // 334: check Inst[14] == 0x0
12528 OPC_Decode, 218, 117, 30, // 338: decode to NDS_FFB using decoder 30
12529 // 338: }
12530 1, 0, // 342: case 0x1: {
12531 OPC_CheckPredicate, 119, // 344: check predicate 119
12532 OPC_CheckField, 14, 1, 0, // 346: check Inst[14] == 0x0
12533 OPC_Decode, 220, 117, 30, // 350: decode to NDS_FFZMISM using decoder 30
12534 // 350: }
12535 // 350: } // switch Inst[25]
12536 // 350: }
12537 9, 0, // 354: case 0x9: {
12538 OPC_SwitchField, 25, 1, // 356: switch Inst[25] {
12539 0, 10, // 359: case 0x0: {
12540 OPC_CheckPredicate, 119, // 361: check predicate 119
12541 OPC_CheckField, 14, 1, 0, // 363: check Inst[14] == 0x0
12542 OPC_Decode, 219, 117, 30, // 367: decode to NDS_FFMISM using decoder 30
12543 // 367: }
12544 1, 0, // 371: case 0x1: {
12545 OPC_CheckPredicate, 119, // 373: check predicate 119
12546 OPC_CheckField, 14, 1, 0, // 375: check Inst[14] == 0x0
12547 OPC_Decode, 221, 117, 30, // 379: decode to NDS_FLMISM using decoder 30
12548 // 379: }
12549 // 379: } // switch Inst[25]
12550 // 379: }
12551 // 379: } // switch Inst[31:26]
12552 // 379: }
12553 // 379: } // switch Inst[6:0]
12554 // 379: }
12555 1, 48, // 383: case 0x1: {
12556 OPC_SwitchField, 0, 7, // 385: switch Inst[6:0] {
12557 11, 7, // 388: case 0xb: {
12558 OPC_CheckPredicate, 119, // 390: check predicate 119
12559 OPC_Decode, 209, 117, 184, 1, // 392: decode to NDS_ADDIGP using decoder 184
12560 // 392: }
12561 43, 21, // 397: case 0x2b: {
12562 OPC_SwitchField, 14, 1, // 399: switch Inst[14] {
12563 0, 7, // 402: case 0x0: {
12564 OPC_CheckPredicate, 119, // 404: check predicate 119
12565 OPC_Decode, 234, 117, 190, 1, // 406: decode to NDS_LHGP using decoder 190
12566 // 406: }
12567 1, 0, // 411: case 0x1: {
12568 OPC_CheckPredicate, 119, // 413: check predicate 119
12569 OPC_Decode, 235, 117, 190, 1, // 415: decode to NDS_LHUGP using decoder 190
12570 // 415: }
12571 // 415: } // switch Inst[14]
12572 // 415: }
12573 91, 0, // 420: case 0x5b: {
12574 OPC_CheckPredicate, 119, // 422: check predicate 119
12575 OPC_CheckField, 14, 1, 1, // 424: check Inst[14] == 0x1
12576 OPC_Decode, 212, 117, 191, 1, // 428: decode to NDS_BEQC using decoder 191
12577 // 428: }
12578 // 428: } // switch Inst[6:0]
12579 // 428: }
12580 2, 58, // 433: case 0x2: {
12581 OPC_SwitchField, 0, 7, // 435: switch Inst[6:0] {
12582 11, 7, // 438: case 0xb: {
12583 OPC_CheckPredicate, 119, // 440: check predicate 119
12584 OPC_Decode, 225, 117, 184, 1, // 442: decode to NDS_LBUGP using decoder 184
12585 // 442: }
12586 43, 21, // 447: case 0x2b: {
12587 OPC_SwitchField, 14, 1, // 449: switch Inst[14] {
12588 0, 7, // 452: case 0x0: {
12589 OPC_CheckPredicate, 119, // 454: check predicate 119
12590 OPC_Decode, 236, 117, 192, 1, // 456: decode to NDS_LWGP using decoder 192
12591 // 456: }
12592 1, 0, // 461: case 0x1: {
12593 OPC_CheckPredicate, 125, // 463: check predicate 125
12594 OPC_Decode, 237, 117, 192, 1, // 465: decode to NDS_LWUGP using decoder 192
12595 // 465: }
12596 // 465: } // switch Inst[14]
12597 // 465: }
12598 91, 0, // 470: case 0x5b: {
12599 OPC_SwitchField, 14, 1, // 472: switch Inst[14] {
12600 0, 7, // 475: case 0x0: {
12601 OPC_CheckPredicate, 119, // 477: check predicate 119
12602 OPC_Decode, 214, 117, 193, 1, // 479: decode to NDS_BFOZ using decoder 193
12603 // 479: }
12604 1, 0, // 484: case 0x1: {
12605 OPC_CheckPredicate, 119, // 486: check predicate 119
12606 OPC_Decode, 215, 117, 191, 1, // 488: decode to NDS_BNEC using decoder 191
12607 // 488: }
12608 // 488: } // switch Inst[14]
12609 // 488: }
12610 // 488: } // switch Inst[6:0]
12611 // 488: }
12612 3, 0, // 493: case 0x3: {
12613 OPC_SwitchField, 0, 7, // 495: switch Inst[6:0] {
12614 11, 7, // 498: case 0xb: {
12615 OPC_CheckPredicate, 119, // 500: check predicate 119
12616 OPC_Decode, 238, 117, 194, 1, // 502: decode to NDS_SBGP using decoder 194
12617 // 502: }
12618 43, 21, // 507: case 0x2b: {
12619 OPC_SwitchField, 14, 1, // 509: switch Inst[14] {
12620 0, 7, // 512: case 0x0: {
12621 OPC_CheckPredicate, 125, // 514: check predicate 125
12622 OPC_Decode, 226, 117, 195, 1, // 516: decode to NDS_LDGP using decoder 195
12623 // 516: }
12624 1, 0, // 521: case 0x1: {
12625 OPC_CheckPredicate, 125, // 523: check predicate 125
12626 OPC_Decode, 239, 117, 196, 1, // 525: decode to NDS_SDGP using decoder 196
12627 // 525: }
12628 // 525: } // switch Inst[14]
12629 // 525: }
12630 91, 0, // 530: case 0x5b: {
12631 OPC_SwitchField, 14, 1, // 532: switch Inst[14] {
12632 0, 7, // 535: case 0x0: {
12633 OPC_CheckPredicate, 119, // 537: check predicate 119
12634 OPC_Decode, 213, 117, 193, 1, // 539: decode to NDS_BFOS using decoder 193
12635 // 539: }
12636 1, 0, // 544: case 0x1: {
12637 OPC_SwitchField, 30, 1, // 546: switch Inst[30] {
12638 0, 7, // 549: case 0x0: {
12639 OPC_CheckPredicate, 119, // 551: check predicate 119
12640 OPC_Decode, 210, 117, 197, 1, // 553: decode to NDS_BBC using decoder 197
12641 // 553: }
12642 1, 0, // 558: case 0x1: {
12643 OPC_CheckPredicate, 119, // 560: check predicate 119
12644 OPC_Decode, 211, 117, 197, 1, // 562: decode to NDS_BBS using decoder 197
12645 // 562: }
12646 // 562: } // switch Inst[30]
12647 // 562: }
12648 // 562: } // switch Inst[14]
12649 // 562: }
12650 // 562: } // switch Inst[6:0]
12651 // 562: }
12652 // 562: } // switch Inst[13:12]
12653};
12654static const uint8_t DecoderTableXCV32[3656] = {
12655 32, // 0: BitWidth 32
12656 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
12657 0, 188, 4, // 4: case 0x0: {
12658 OPC_SwitchField, 0, 7, // 7: switch Inst[6:0] {
12659 11, 7, // 10: case 0xb: {
12660 OPC_CheckPredicate, 127, // 12: check predicate 127
12661 OPC_Decode, 253, 111, 198, 1, // 14: decode to CV_LB_ri_inc using decoder 198
12662 // 14: }
12663 43, 7, // 19: case 0x2b: {
12664 OPC_CheckPredicate, 127, // 21: check predicate 127
12665 OPC_Decode, 194, 112, 199, 1, // 23: decode to CV_SB_ri_inc using decoder 199
12666 // 23: }
12667 91, 33, // 28: case 0x5b: {
12668 OPC_SwitchField, 30, 2, // 30: switch Inst[31:30] {
12669 0, 8, // 33: case 0x0: {
12670 OPC_CheckPredicate, 128, 1, // 35: check predicate 128
12671 OPC_Decode, 236, 111, 200, 1, // 38: decode to CV_EXTRACT using decoder 200
12672 // 38: }
12673 1, 8, // 43: case 0x1: {
12674 OPC_CheckPredicate, 128, 1, // 45: check predicate 128
12675 OPC_Decode, 238, 111, 200, 1, // 48: decode to CV_EXTRACTU using decoder 200
12676 // 48: }
12677 2, 0, // 53: case 0x2: {
12678 OPC_CheckPredicate, 128, 1, // 55: check predicate 128
12679 OPC_Decode, 246, 111, 201, 1, // 58: decode to CV_INSERT using decoder 201
12680 // 58: }
12681 // 58: } // switch Inst[31:30]
12682 // 58: }
12683 123, 0, // 63: case 0x7b: {
12684 OPC_SwitchField, 26, 6, // 65: switch Inst[31:26] {
12685 0, 11, // 68: case 0x0: {
12686 OPC_CheckPredicate, 129, 1, // 70: check predicate 129
12687 OPC_CheckField, 25, 1, 0, // 73: check Inst[25] == 0x0
12688 OPC_Decode, 236, 110, 30, // 77: decode to CV_ADD_H using decoder 30
12689 // 77: }
12690 1, 11, // 81: case 0x1: {
12691 OPC_CheckPredicate, 129, 1, // 83: check predicate 129
12692 OPC_CheckField, 25, 1, 0, // 86: check Inst[25] == 0x0
12693 OPC_Decode, 144, 111, 30, // 90: decode to CV_CMPEQ_H using decoder 30
12694 // 90: }
12695 2, 11, // 94: case 0x2: {
12696 OPC_CheckPredicate, 129, 1, // 96: check predicate 129
12697 OPC_CheckField, 25, 1, 0, // 99: check Inst[25] == 0x0
12698 OPC_Decode, 135, 113, 30, // 103: decode to CV_SUB_H using decoder 30
12699 // 103: }
12700 3, 11, // 107: case 0x3: {
12701 OPC_CheckPredicate, 129, 1, // 109: check predicate 129
12702 OPC_CheckField, 25, 1, 0, // 112: check Inst[25] == 0x0
12703 OPC_Decode, 198, 111, 30, // 116: decode to CV_CMPNE_H using decoder 30
12704 // 116: }
12705 4, 11, // 120: case 0x4: {
12706 OPC_CheckPredicate, 129, 1, // 122: check predicate 129
12707 OPC_CheckField, 25, 1, 0, // 125: check Inst[25] == 0x0
12708 OPC_Decode, 254, 110, 30, // 129: decode to CV_AVG_H using decoder 30
12709 // 129: }
12710 5, 11, // 133: case 0x5: {
12711 OPC_CheckPredicate, 129, 1, // 135: check predicate 129
12712 OPC_CheckField, 25, 1, 0, // 138: check Inst[25] == 0x0
12713 OPC_Decode, 168, 111, 30, // 142: decode to CV_CMPGT_H using decoder 30
12714 // 142: }
12715 6, 11, // 146: case 0x6: {
12716 OPC_CheckPredicate, 129, 1, // 148: check predicate 129
12717 OPC_CheckField, 25, 1, 0, // 151: check Inst[25] == 0x0
12718 OPC_Decode, 248, 110, 30, // 155: decode to CV_AVGU_H using decoder 30
12719 // 155: }
12720 7, 11, // 159: case 0x7: {
12721 OPC_CheckPredicate, 129, 1, // 161: check predicate 129
12722 OPC_CheckField, 25, 1, 0, // 164: check Inst[25] == 0x0
12723 OPC_Decode, 156, 111, 30, // 168: decode to CV_CMPGE_H using decoder 30
12724 // 168: }
12725 8, 11, // 172: case 0x8: {
12726 OPC_CheckPredicate, 129, 1, // 174: check predicate 129
12727 OPC_CheckField, 25, 1, 0, // 177: check Inst[25] == 0x0
12728 OPC_Decode, 169, 112, 30, // 181: decode to CV_MIN_H using decoder 30
12729 // 181: }
12730 9, 11, // 185: case 0x9: {
12731 OPC_CheckPredicate, 129, 1, // 187: check predicate 129
12732 OPC_CheckField, 25, 1, 0, // 190: check Inst[25] == 0x0
12733 OPC_Decode, 192, 111, 30, // 194: decode to CV_CMPLT_H using decoder 30
12734 // 194: }
12735 10, 11, // 198: case 0xa: {
12736 OPC_CheckPredicate, 129, 1, // 200: check predicate 129
12737 OPC_CheckField, 25, 1, 0, // 203: check Inst[25] == 0x0
12738 OPC_Decode, 163, 112, 30, // 207: decode to CV_MINU_H using decoder 30
12739 // 207: }
12740 11, 11, // 211: case 0xb: {
12741 OPC_CheckPredicate, 129, 1, // 213: check predicate 129
12742 OPC_CheckField, 25, 1, 0, // 216: check Inst[25] == 0x0
12743 OPC_Decode, 180, 111, 30, // 220: decode to CV_CMPLE_H using decoder 30
12744 // 220: }
12745 12, 11, // 224: case 0xc: {
12746 OPC_CheckPredicate, 129, 1, // 226: check predicate 129
12747 OPC_CheckField, 25, 1, 0, // 229: check Inst[25] == 0x0
12748 OPC_Decode, 155, 112, 30, // 233: decode to CV_MAX_H using decoder 30
12749 // 233: }
12750 13, 11, // 237: case 0xd: {
12751 OPC_CheckPredicate, 129, 1, // 239: check predicate 129
12752 OPC_CheckField, 25, 1, 0, // 242: check Inst[25] == 0x0
12753 OPC_Decode, 162, 111, 30, // 246: decode to CV_CMPGTU_H using decoder 30
12754 // 246: }
12755 14, 11, // 250: case 0xe: {
12756 OPC_CheckPredicate, 129, 1, // 252: check predicate 129
12757 OPC_CheckField, 25, 1, 0, // 255: check Inst[25] == 0x0
12758 OPC_Decode, 149, 112, 30, // 259: decode to CV_MAXU_H using decoder 30
12759 // 259: }
12760 15, 11, // 263: case 0xf: {
12761 OPC_CheckPredicate, 129, 1, // 265: check predicate 129
12762 OPC_CheckField, 25, 1, 0, // 268: check Inst[25] == 0x0
12763 OPC_Decode, 150, 111, 30, // 272: decode to CV_CMPGEU_H using decoder 30
12764 // 272: }
12765 16, 11, // 276: case 0x10: {
12766 OPC_CheckPredicate, 129, 1, // 278: check predicate 129
12767 OPC_CheckField, 25, 1, 0, // 281: check Inst[25] == 0x0
12768 OPC_Decode, 242, 112, 30, // 285: decode to CV_SRL_H using decoder 30
12769 // 285: }
12770 17, 11, // 289: case 0x11: {
12771 OPC_CheckPredicate, 129, 1, // 291: check predicate 129
12772 OPC_CheckField, 25, 1, 0, // 294: check Inst[25] == 0x0
12773 OPC_Decode, 186, 111, 30, // 298: decode to CV_CMPLTU_H using decoder 30
12774 // 298: }
12775 18, 11, // 302: case 0x12: {
12776 OPC_CheckPredicate, 129, 1, // 304: check predicate 129
12777 OPC_CheckField, 25, 1, 0, // 307: check Inst[25] == 0x0
12778 OPC_Decode, 236, 112, 30, // 311: decode to CV_SRA_H using decoder 30
12779 // 311: }
12780 19, 11, // 315: case 0x13: {
12781 OPC_CheckPredicate, 129, 1, // 317: check predicate 129
12782 OPC_CheckField, 25, 1, 0, // 320: check Inst[25] == 0x0
12783 OPC_Decode, 174, 111, 30, // 324: decode to CV_CMPLEU_H using decoder 30
12784 // 324: }
12785 20, 11, // 328: case 0x14: {
12786 OPC_CheckPredicate, 129, 1, // 330: check predicate 129
12787 OPC_CheckField, 25, 1, 0, // 333: check Inst[25] == 0x0
12788 OPC_Decode, 230, 112, 30, // 337: decode to CV_SLL_H using decoder 30
12789 // 337: }
12790 21, 21, // 341: case 0x15: {
12791 OPC_SwitchField, 25, 1, // 343: switch Inst[25] {
12792 0, 7, // 346: case 0x0: {
12793 OPC_CheckPredicate, 129, 1, // 348: check predicate 129
12794 OPC_Decode, 209, 111, 58, // 351: decode to CV_CPLXMUL_R using decoder 58
12795 // 351: }
12796 1, 0, // 355: case 0x1: {
12797 OPC_CheckPredicate, 129, 1, // 357: check predicate 129
12798 OPC_Decode, 205, 111, 58, // 360: decode to CV_CPLXMUL_I using decoder 58
12799 // 360: }
12800 // 360: } // switch Inst[25]
12801 // 360: }
12802 22, 11, // 364: case 0x16: {
12803 OPC_CheckPredicate, 129, 1, // 366: check predicate 129
12804 OPC_CheckField, 25, 1, 0, // 369: check Inst[25] == 0x0
12805 OPC_Decode, 184, 112, 30, // 373: decode to CV_OR_H using decoder 30
12806 // 373: }
12807 23, 11, // 377: case 0x17: {
12808 OPC_CheckPredicate, 129, 1, // 379: check predicate 129
12809 OPC_CheckField, 20, 6, 0, // 382: check Inst[25:20] == 0x0
12810 OPC_Decode, 204, 111, 16, // 386: decode to CV_CPLXCONJ using decoder 16
12811 // 386: }
12812 24, 11, // 390: case 0x18: {
12813 OPC_CheckPredicate, 129, 1, // 392: check predicate 129
12814 OPC_CheckField, 25, 1, 0, // 395: check Inst[25] == 0x0
12815 OPC_Decode, 144, 113, 30, // 399: decode to CV_XOR_H using decoder 30
12816 // 399: }
12817 25, 11, // 403: case 0x19: {
12818 OPC_CheckPredicate, 129, 1, // 405: check predicate 129
12819 OPC_CheckField, 25, 1, 0, // 408: check Inst[25] == 0x0
12820 OPC_Decode, 251, 112, 30, // 412: decode to CV_SUBROTMJ using decoder 30
12821 // 412: }
12822 26, 11, // 416: case 0x1a: {
12823 OPC_CheckPredicate, 129, 1, // 418: check predicate 129
12824 OPC_CheckField, 25, 1, 0, // 421: check Inst[25] == 0x0
12825 OPC_Decode, 242, 110, 30, // 425: decode to CV_AND_H using decoder 30
12826 // 425: }
12827 28, 11, // 429: case 0x1c: {
12828 OPC_CheckPredicate, 129, 1, // 431: check predicate 129
12829 OPC_CheckField, 20, 6, 0, // 434: check Inst[25:20] == 0x0
12830 OPC_Decode, 223, 110, 16, // 438: decode to CV_ABS_H using decoder 16
12831 // 438: }
12832 32, 11, // 442: case 0x20: {
12833 OPC_CheckPredicate, 129, 1, // 444: check predicate 129
12834 OPC_CheckField, 25, 1, 0, // 447: check Inst[25] == 0x0
12835 OPC_Decode, 220, 111, 30, // 451: decode to CV_DOTUP_H using decoder 30
12836 // 451: }
12837 34, 11, // 455: case 0x22: {
12838 OPC_CheckPredicate, 129, 1, // 457: check predicate 129
12839 OPC_CheckField, 25, 1, 0, // 460: check Inst[25] == 0x0
12840 OPC_Decode, 226, 111, 30, // 464: decode to CV_DOTUSP_H using decoder 30
12841 // 464: }
12842 36, 11, // 468: case 0x24: {
12843 OPC_CheckPredicate, 129, 1, // 470: check predicate 129
12844 OPC_CheckField, 25, 1, 0, // 473: check Inst[25] == 0x0
12845 OPC_Decode, 214, 111, 30, // 477: decode to CV_DOTSP_H using decoder 30
12846 // 477: }
12847 38, 11, // 481: case 0x26: {
12848 OPC_CheckPredicate, 129, 1, // 483: check predicate 129
12849 OPC_CheckField, 25, 1, 0, // 486: check Inst[25] == 0x0
12850 OPC_Decode, 204, 112, 58, // 490: decode to CV_SDOTUP_H using decoder 58
12851 // 490: }
12852 40, 11, // 494: case 0x28: {
12853 OPC_CheckPredicate, 129, 1, // 496: check predicate 129
12854 OPC_CheckField, 25, 1, 0, // 499: check Inst[25] == 0x0
12855 OPC_Decode, 210, 112, 58, // 503: decode to CV_SDOTUSP_H using decoder 58
12856 // 503: }
12857 42, 11, // 507: case 0x2a: {
12858 OPC_CheckPredicate, 129, 1, // 509: check predicate 129
12859 OPC_CheckField, 25, 1, 0, // 512: check Inst[25] == 0x0
12860 OPC_Decode, 198, 112, 58, // 516: decode to CV_SDOTSP_H using decoder 58
12861 // 516: }
12862 46, 8, // 520: case 0x2e: {
12863 OPC_CheckPredicate, 129, 1, // 522: check predicate 129
12864 OPC_Decode, 243, 111, 202, 1, // 525: decode to CV_EXTRACT_H using decoder 202
12865 // 525: }
12866 48, 11, // 530: case 0x30: {
12867 OPC_CheckPredicate, 129, 1, // 532: check predicate 129
12868 OPC_CheckField, 25, 1, 0, // 535: check Inst[25] == 0x0
12869 OPC_Decode, 222, 112, 30, // 539: decode to CV_SHUFFLE_H using decoder 30
12870 // 539: }
12871 56, 11, // 543: case 0x38: {
12872 OPC_CheckPredicate, 129, 1, // 545: check predicate 129
12873 OPC_CheckField, 25, 1, 0, // 548: check Inst[25] == 0x0
12874 OPC_Decode, 216, 112, 58, // 552: decode to CV_SHUFFLE2_H using decoder 58
12875 // 552: }
12876 60, 0, // 556: case 0x3c: {
12877 OPC_SwitchField, 25, 1, // 558: switch Inst[25] {
12878 0, 7, // 561: case 0x0: {
12879 OPC_CheckPredicate, 129, 1, // 563: check predicate 129
12880 OPC_Decode, 189, 112, 30, // 566: decode to CV_PACK using decoder 30
12881 // 566: }
12882 1, 0, // 570: case 0x1: {
12883 OPC_CheckPredicate, 129, 1, // 572: check predicate 129
12884 OPC_Decode, 192, 112, 30, // 575: decode to CV_PACK_H using decoder 30
12885 // 575: }
12886 // 575: } // switch Inst[25]
12887 // 575: }
12888 // 575: } // switch Inst[31:26]
12889 // 575: }
12890 // 575: } // switch Inst[6:0]
12891 // 575: }
12892 1, 139, 4, // 579: case 0x1: {
12893 OPC_SwitchField, 0, 7, // 582: switch Inst[6:0] {
12894 11, 7, // 585: case 0xb: {
12895 OPC_CheckPredicate, 127, // 587: check predicate 127
12896 OPC_Decode, 131, 112, 198, 1, // 589: decode to CV_LH_ri_inc using decoder 198
12897 // 589: }
12898 43, 7, // 594: case 0x2b: {
12899 OPC_CheckPredicate, 127, // 596: check predicate 127
12900 OPC_Decode, 224, 112, 199, 1, // 598: decode to CV_SH_ri_inc using decoder 199
12901 // 598: }
12902 91, 33, // 603: case 0x5b: {
12903 OPC_SwitchField, 30, 2, // 605: switch Inst[31:30] {
12904 0, 8, // 608: case 0x0: {
12905 OPC_CheckPredicate, 128, 1, // 610: check predicate 128
12906 OPC_Decode, 131, 111, 200, 1, // 613: decode to CV_BCLR using decoder 200
12907 // 613: }
12908 1, 8, // 618: case 0x1: {
12909 OPC_CheckPredicate, 128, 1, // 620: check predicate 128
12910 OPC_Decode, 136, 111, 200, 1, // 623: decode to CV_BSET using decoder 200
12911 // 623: }
12912 3, 0, // 628: case 0x3: {
12913 OPC_CheckPredicate, 128, 1, // 630: check predicate 128
12914 OPC_Decode, 134, 111, 203, 1, // 633: decode to CV_BITREV using decoder 203
12915 // 633: }
12916 // 633: } // switch Inst[31:30]
12917 // 633: }
12918 123, 0, // 638: case 0x7b: {
12919 OPC_SwitchField, 26, 6, // 640: switch Inst[31:26] {
12920 0, 11, // 643: case 0x0: {
12921 OPC_CheckPredicate, 129, 1, // 645: check predicate 129
12922 OPC_CheckField, 25, 1, 0, // 648: check Inst[25] == 0x0
12923 OPC_Decode, 232, 110, 30, // 652: decode to CV_ADD_B using decoder 30
12924 // 652: }
12925 1, 11, // 656: case 0x1: {
12926 OPC_CheckPredicate, 129, 1, // 658: check predicate 129
12927 OPC_CheckField, 25, 1, 0, // 661: check Inst[25] == 0x0
12928 OPC_Decode, 143, 111, 30, // 665: decode to CV_CMPEQ_B using decoder 30
12929 // 665: }
12930 2, 11, // 669: case 0x2: {
12931 OPC_CheckPredicate, 129, 1, // 671: check predicate 129
12932 OPC_CheckField, 25, 1, 0, // 674: check Inst[25] == 0x0
12933 OPC_Decode, 131, 113, 30, // 678: decode to CV_SUB_B using decoder 30
12934 // 678: }
12935 3, 11, // 682: case 0x3: {
12936 OPC_CheckPredicate, 129, 1, // 684: check predicate 129
12937 OPC_CheckField, 25, 1, 0, // 687: check Inst[25] == 0x0
12938 OPC_Decode, 197, 111, 30, // 691: decode to CV_CMPNE_B using decoder 30
12939 // 691: }
12940 4, 11, // 695: case 0x4: {
12941 OPC_CheckPredicate, 129, 1, // 697: check predicate 129
12942 OPC_CheckField, 25, 1, 0, // 700: check Inst[25] == 0x0
12943 OPC_Decode, 253, 110, 30, // 704: decode to CV_AVG_B using decoder 30
12944 // 704: }
12945 5, 11, // 708: case 0x5: {
12946 OPC_CheckPredicate, 129, 1, // 710: check predicate 129
12947 OPC_CheckField, 25, 1, 0, // 713: check Inst[25] == 0x0
12948 OPC_Decode, 167, 111, 30, // 717: decode to CV_CMPGT_B using decoder 30
12949 // 717: }
12950 6, 11, // 721: case 0x6: {
12951 OPC_CheckPredicate, 129, 1, // 723: check predicate 129
12952 OPC_CheckField, 25, 1, 0, // 726: check Inst[25] == 0x0
12953 OPC_Decode, 247, 110, 30, // 730: decode to CV_AVGU_B using decoder 30
12954 // 730: }
12955 7, 11, // 734: case 0x7: {
12956 OPC_CheckPredicate, 129, 1, // 736: check predicate 129
12957 OPC_CheckField, 25, 1, 0, // 739: check Inst[25] == 0x0
12958 OPC_Decode, 155, 111, 30, // 743: decode to CV_CMPGE_B using decoder 30
12959 // 743: }
12960 8, 11, // 747: case 0x8: {
12961 OPC_CheckPredicate, 129, 1, // 749: check predicate 129
12962 OPC_CheckField, 25, 1, 0, // 752: check Inst[25] == 0x0
12963 OPC_Decode, 168, 112, 30, // 756: decode to CV_MIN_B using decoder 30
12964 // 756: }
12965 9, 11, // 760: case 0x9: {
12966 OPC_CheckPredicate, 129, 1, // 762: check predicate 129
12967 OPC_CheckField, 25, 1, 0, // 765: check Inst[25] == 0x0
12968 OPC_Decode, 191, 111, 30, // 769: decode to CV_CMPLT_B using decoder 30
12969 // 769: }
12970 10, 11, // 773: case 0xa: {
12971 OPC_CheckPredicate, 129, 1, // 775: check predicate 129
12972 OPC_CheckField, 25, 1, 0, // 778: check Inst[25] == 0x0
12973 OPC_Decode, 162, 112, 30, // 782: decode to CV_MINU_B using decoder 30
12974 // 782: }
12975 11, 11, // 786: case 0xb: {
12976 OPC_CheckPredicate, 129, 1, // 788: check predicate 129
12977 OPC_CheckField, 25, 1, 0, // 791: check Inst[25] == 0x0
12978 OPC_Decode, 179, 111, 30, // 795: decode to CV_CMPLE_B using decoder 30
12979 // 795: }
12980 12, 11, // 799: case 0xc: {
12981 OPC_CheckPredicate, 129, 1, // 801: check predicate 129
12982 OPC_CheckField, 25, 1, 0, // 804: check Inst[25] == 0x0
12983 OPC_Decode, 154, 112, 30, // 808: decode to CV_MAX_B using decoder 30
12984 // 808: }
12985 13, 11, // 812: case 0xd: {
12986 OPC_CheckPredicate, 129, 1, // 814: check predicate 129
12987 OPC_CheckField, 25, 1, 0, // 817: check Inst[25] == 0x0
12988 OPC_Decode, 161, 111, 30, // 821: decode to CV_CMPGTU_B using decoder 30
12989 // 821: }
12990 14, 11, // 825: case 0xe: {
12991 OPC_CheckPredicate, 129, 1, // 827: check predicate 129
12992 OPC_CheckField, 25, 1, 0, // 830: check Inst[25] == 0x0
12993 OPC_Decode, 148, 112, 30, // 834: decode to CV_MAXU_B using decoder 30
12994 // 834: }
12995 15, 11, // 838: case 0xf: {
12996 OPC_CheckPredicate, 129, 1, // 840: check predicate 129
12997 OPC_CheckField, 25, 1, 0, // 843: check Inst[25] == 0x0
12998 OPC_Decode, 149, 111, 30, // 847: decode to CV_CMPGEU_B using decoder 30
12999 // 847: }
13000 16, 11, // 851: case 0x10: {
13001 OPC_CheckPredicate, 129, 1, // 853: check predicate 129
13002 OPC_CheckField, 25, 1, 0, // 856: check Inst[25] == 0x0
13003 OPC_Decode, 241, 112, 30, // 860: decode to CV_SRL_B using decoder 30
13004 // 860: }
13005 17, 11, // 864: case 0x11: {
13006 OPC_CheckPredicate, 129, 1, // 866: check predicate 129
13007 OPC_CheckField, 25, 1, 0, // 869: check Inst[25] == 0x0
13008 OPC_Decode, 185, 111, 30, // 873: decode to CV_CMPLTU_B using decoder 30
13009 // 873: }
13010 18, 11, // 877: case 0x12: {
13011 OPC_CheckPredicate, 129, 1, // 879: check predicate 129
13012 OPC_CheckField, 25, 1, 0, // 882: check Inst[25] == 0x0
13013 OPC_Decode, 235, 112, 30, // 886: decode to CV_SRA_B using decoder 30
13014 // 886: }
13015 19, 11, // 890: case 0x13: {
13016 OPC_CheckPredicate, 129, 1, // 892: check predicate 129
13017 OPC_CheckField, 25, 1, 0, // 895: check Inst[25] == 0x0
13018 OPC_Decode, 173, 111, 30, // 899: decode to CV_CMPLEU_B using decoder 30
13019 // 899: }
13020 20, 11, // 903: case 0x14: {
13021 OPC_CheckPredicate, 129, 1, // 905: check predicate 129
13022 OPC_CheckField, 25, 1, 0, // 908: check Inst[25] == 0x0
13023 OPC_Decode, 229, 112, 30, // 912: decode to CV_SLL_B using decoder 30
13024 // 912: }
13025 22, 11, // 916: case 0x16: {
13026 OPC_CheckPredicate, 129, 1, // 918: check predicate 129
13027 OPC_CheckField, 25, 1, 0, // 921: check Inst[25] == 0x0
13028 OPC_Decode, 183, 112, 30, // 925: decode to CV_OR_B using decoder 30
13029 // 925: }
13030 24, 11, // 929: case 0x18: {
13031 OPC_CheckPredicate, 129, 1, // 931: check predicate 129
13032 OPC_CheckField, 25, 1, 0, // 934: check Inst[25] == 0x0
13033 OPC_Decode, 143, 113, 30, // 938: decode to CV_XOR_B using decoder 30
13034 // 938: }
13035 26, 11, // 942: case 0x1a: {
13036 OPC_CheckPredicate, 129, 1, // 944: check predicate 129
13037 OPC_CheckField, 25, 1, 0, // 947: check Inst[25] == 0x0
13038 OPC_Decode, 241, 110, 30, // 951: decode to CV_AND_B using decoder 30
13039 // 951: }
13040 28, 11, // 955: case 0x1c: {
13041 OPC_CheckPredicate, 129, 1, // 957: check predicate 129
13042 OPC_CheckField, 20, 6, 0, // 960: check Inst[25:20] == 0x0
13043 OPC_Decode, 222, 110, 16, // 964: decode to CV_ABS_B using decoder 16
13044 // 964: }
13045 32, 11, // 968: case 0x20: {
13046 OPC_CheckPredicate, 129, 1, // 970: check predicate 129
13047 OPC_CheckField, 25, 1, 0, // 973: check Inst[25] == 0x0
13048 OPC_Decode, 219, 111, 30, // 977: decode to CV_DOTUP_B using decoder 30
13049 // 977: }
13050 34, 11, // 981: case 0x22: {
13051 OPC_CheckPredicate, 129, 1, // 983: check predicate 129
13052 OPC_CheckField, 25, 1, 0, // 986: check Inst[25] == 0x0
13053 OPC_Decode, 225, 111, 30, // 990: decode to CV_DOTUSP_B using decoder 30
13054 // 990: }
13055 36, 11, // 994: case 0x24: {
13056 OPC_CheckPredicate, 129, 1, // 996: check predicate 129
13057 OPC_CheckField, 25, 1, 0, // 999: check Inst[25] == 0x0
13058 OPC_Decode, 213, 111, 30, // 1003: decode to CV_DOTSP_B using decoder 30
13059 // 1003: }
13060 38, 11, // 1007: case 0x26: {
13061 OPC_CheckPredicate, 129, 1, // 1009: check predicate 129
13062 OPC_CheckField, 25, 1, 0, // 1012: check Inst[25] == 0x0
13063 OPC_Decode, 203, 112, 58, // 1016: decode to CV_SDOTUP_B using decoder 58
13064 // 1016: }
13065 40, 11, // 1020: case 0x28: {
13066 OPC_CheckPredicate, 129, 1, // 1022: check predicate 129
13067 OPC_CheckField, 25, 1, 0, // 1025: check Inst[25] == 0x0
13068 OPC_Decode, 209, 112, 58, // 1029: decode to CV_SDOTUSP_B using decoder 58
13069 // 1029: }
13070 42, 11, // 1033: case 0x2a: {
13071 OPC_CheckPredicate, 129, 1, // 1035: check predicate 129
13072 OPC_CheckField, 25, 1, 0, // 1038: check Inst[25] == 0x0
13073 OPC_Decode, 197, 112, 58, // 1042: decode to CV_SDOTSP_B using decoder 58
13074 // 1042: }
13075 46, 8, // 1046: case 0x2e: {
13076 OPC_CheckPredicate, 129, 1, // 1048: check predicate 129
13077 OPC_Decode, 242, 111, 202, 1, // 1051: decode to CV_EXTRACT_B using decoder 202
13078 // 1051: }
13079 48, 11, // 1056: case 0x30: {
13080 OPC_CheckPredicate, 129, 1, // 1058: check predicate 129
13081 OPC_CheckField, 25, 1, 0, // 1061: check Inst[25] == 0x0
13082 OPC_Decode, 221, 112, 30, // 1065: decode to CV_SHUFFLE_B using decoder 30
13083 // 1065: }
13084 56, 11, // 1069: case 0x38: {
13085 OPC_CheckPredicate, 129, 1, // 1071: check predicate 129
13086 OPC_CheckField, 25, 1, 0, // 1074: check Inst[25] == 0x0
13087 OPC_Decode, 215, 112, 58, // 1078: decode to CV_SHUFFLE2_B using decoder 58
13088 // 1078: }
13089 62, 0, // 1082: case 0x3e: {
13090 OPC_SwitchField, 25, 1, // 1084: switch Inst[25] {
13091 0, 7, // 1087: case 0x0: {
13092 OPC_CheckPredicate, 129, 1, // 1089: check predicate 129
13093 OPC_Decode, 191, 112, 58, // 1092: decode to CV_PACKLO_B using decoder 58
13094 // 1092: }
13095 1, 0, // 1096: case 0x1: {
13096 OPC_CheckPredicate, 129, 1, // 1098: check predicate 129
13097 OPC_Decode, 190, 112, 58, // 1101: decode to CV_PACKHI_B using decoder 58
13098 // 1101: }
13099 // 1101: } // switch Inst[25]
13100 // 1101: }
13101 // 1101: } // switch Inst[31:26]
13102 // 1101: }
13103 // 1101: } // switch Inst[6:0]
13104 // 1101: }
13105 2, 143, 1, // 1105: case 0x2: {
13106 OPC_SwitchField, 0, 7, // 1108: switch Inst[6:0] {
13107 11, 7, // 1111: case 0xb: {
13108 OPC_CheckPredicate, 127, // 1113: check predicate 127
13109 OPC_Decode, 134, 112, 198, 1, // 1115: decode to CV_LW_ri_inc using decoder 198
13110 // 1115: }
13111 43, 7, // 1120: case 0x2b: {
13112 OPC_CheckPredicate, 127, // 1122: check predicate 127
13113 OPC_Decode, 140, 113, 199, 1, // 1124: decode to CV_SW_ri_inc using decoder 199
13114 // 1124: }
13115 91, 43, // 1129: case 0x5b: {
13116 OPC_SwitchField, 30, 2, // 1131: switch Inst[31:30] {
13117 0, 8, // 1134: case 0x0: {
13118 OPC_CheckPredicate, 130, 1, // 1136: check predicate 130
13119 OPC_Decode, 224, 110, 204, 1, // 1139: decode to CV_ADDN using decoder 204
13120 // 1139: }
13121 1, 8, // 1144: case 0x1: {
13122 OPC_CheckPredicate, 130, 1, // 1146: check predicate 130
13123 OPC_Decode, 228, 110, 204, 1, // 1149: decode to CV_ADDUN using decoder 204
13124 // 1149: }
13125 2, 8, // 1154: case 0x2: {
13126 OPC_CheckPredicate, 130, 1, // 1156: check predicate 130
13127 OPC_Decode, 226, 110, 204, 1, // 1159: decode to CV_ADDRN using decoder 204
13128 // 1159: }
13129 3, 0, // 1164: case 0x3: {
13130 OPC_CheckPredicate, 130, 1, // 1166: check predicate 130
13131 OPC_Decode, 230, 110, 204, 1, // 1169: decode to CV_ADDURN using decoder 204
13132 // 1169: }
13133 // 1169: } // switch Inst[31:30]
13134 // 1169: }
13135 123, 0, // 1174: case 0x7b: {
13136 OPC_SwitchField, 26, 6, // 1176: switch Inst[31:26] {
13137 21, 21, // 1179: case 0x15: {
13138 OPC_SwitchField, 25, 1, // 1181: switch Inst[25] {
13139 0, 7, // 1184: case 0x0: {
13140 OPC_CheckPredicate, 129, 1, // 1186: check predicate 129
13141 OPC_Decode, 210, 111, 58, // 1189: decode to CV_CPLXMUL_R_DIV2 using decoder 58
13142 // 1189: }
13143 1, 0, // 1193: case 0x1: {
13144 OPC_CheckPredicate, 129, 1, // 1195: check predicate 129
13145 OPC_Decode, 206, 111, 58, // 1198: decode to CV_CPLXMUL_I_DIV2 using decoder 58
13146 // 1198: }
13147 // 1198: } // switch Inst[25]
13148 // 1198: }
13149 25, 11, // 1202: case 0x19: {
13150 OPC_CheckPredicate, 129, 1, // 1204: check predicate 129
13151 OPC_CheckField, 25, 1, 0, // 1207: check Inst[25] == 0x0
13152 OPC_Decode, 252, 112, 30, // 1211: decode to CV_SUBROTMJ_DIV2 using decoder 30
13153 // 1211: }
13154 27, 11, // 1215: case 0x1b: {
13155 OPC_CheckPredicate, 129, 1, // 1217: check predicate 129
13156 OPC_CheckField, 25, 1, 0, // 1220: check Inst[25] == 0x0
13157 OPC_Decode, 233, 110, 30, // 1224: decode to CV_ADD_DIV2 using decoder 30
13158 // 1224: }
13159 29, 11, // 1228: case 0x1d: {
13160 OPC_CheckPredicate, 129, 1, // 1230: check predicate 129
13161 OPC_CheckField, 25, 1, 0, // 1233: check Inst[25] == 0x0
13162 OPC_Decode, 132, 113, 30, // 1237: decode to CV_SUB_DIV2 using decoder 30
13163 // 1237: }
13164 46, 0, // 1241: case 0x2e: {
13165 OPC_CheckPredicate, 129, 1, // 1243: check predicate 129
13166 OPC_Decode, 241, 111, 202, 1, // 1246: decode to CV_EXTRACTU_H using decoder 202
13167 // 1246: }
13168 // 1246: } // switch Inst[31:26]
13169 // 1246: }
13170 // 1246: } // switch Inst[6:0]
13171 // 1246: }
13172 3, 183, 4, // 1251: case 0x3: {
13173 OPC_SwitchField, 0, 7, // 1254: switch Inst[6:0] {
13174 11, 7, // 1257: case 0xb: {
13175 OPC_CheckPredicate, 131, 1, // 1259: check predicate 131
13176 OPC_Decode, 231, 111, 0, // 1262: decode to CV_ELW using decoder 0
13177 // 1262: }
13178 43, 237, 3, // 1266: case 0x2b: {
13179 OPC_SwitchField, 25, 7, // 1269: switch Inst[31:25] {
13180 0, 7, // 1272: case 0x0: {
13181 OPC_CheckPredicate, 127, // 1274: check predicate 127
13182 OPC_Decode, 255, 111, 205, 1, // 1276: decode to CV_LB_rr_inc using decoder 205
13183 // 1276: }
13184 1, 7, // 1281: case 0x1: {
13185 OPC_CheckPredicate, 127, // 1283: check predicate 127
13186 OPC_Decode, 133, 112, 205, 1, // 1285: decode to CV_LH_rr_inc using decoder 205
13187 // 1285: }
13188 2, 7, // 1290: case 0x2: {
13189 OPC_CheckPredicate, 127, // 1292: check predicate 127
13190 OPC_Decode, 136, 112, 205, 1, // 1294: decode to CV_LW_rr_inc using decoder 205
13191 // 1294: }
13192 4, 6, // 1299: case 0x4: {
13193 OPC_CheckPredicate, 127, // 1301: check predicate 127
13194 OPC_Decode, 254, 111, 30, // 1303: decode to CV_LB_rr using decoder 30
13195 // 1303: }
13196 5, 6, // 1307: case 0x5: {
13197 OPC_CheckPredicate, 127, // 1309: check predicate 127
13198 OPC_Decode, 132, 112, 30, // 1311: decode to CV_LH_rr using decoder 30
13199 // 1311: }
13200 6, 6, // 1315: case 0x6: {
13201 OPC_CheckPredicate, 127, // 1317: check predicate 127
13202 OPC_Decode, 135, 112, 30, // 1319: decode to CV_LW_rr using decoder 30
13203 // 1319: }
13204 8, 7, // 1323: case 0x8: {
13205 OPC_CheckPredicate, 127, // 1325: check predicate 127
13206 OPC_Decode, 252, 111, 205, 1, // 1327: decode to CV_LBU_rr_inc using decoder 205
13207 // 1327: }
13208 9, 7, // 1332: case 0x9: {
13209 OPC_CheckPredicate, 127, // 1334: check predicate 127
13210 OPC_Decode, 130, 112, 205, 1, // 1336: decode to CV_LHU_rr_inc using decoder 205
13211 // 1336: }
13212 12, 6, // 1341: case 0xc: {
13213 OPC_CheckPredicate, 127, // 1343: check predicate 127
13214 OPC_Decode, 251, 111, 30, // 1345: decode to CV_LBU_rr using decoder 30
13215 // 1345: }
13216 13, 6, // 1349: case 0xd: {
13217 OPC_CheckPredicate, 127, // 1351: check predicate 127
13218 OPC_Decode, 129, 112, 30, // 1353: decode to CV_LHU_rr using decoder 30
13219 // 1353: }
13220 16, 7, // 1357: case 0x10: {
13221 OPC_CheckPredicate, 127, // 1359: check predicate 127
13222 OPC_Decode, 196, 112, 206, 1, // 1361: decode to CV_SB_rr_inc using decoder 206
13223 // 1361: }
13224 17, 7, // 1366: case 0x11: {
13225 OPC_CheckPredicate, 127, // 1368: check predicate 127
13226 OPC_Decode, 226, 112, 206, 1, // 1370: decode to CV_SH_rr_inc using decoder 206
13227 // 1370: }
13228 18, 7, // 1375: case 0x12: {
13229 OPC_CheckPredicate, 127, // 1377: check predicate 127
13230 OPC_Decode, 142, 113, 206, 1, // 1379: decode to CV_SW_rr_inc using decoder 206
13231 // 1379: }
13232 20, 7, // 1384: case 0x14: {
13233 OPC_CheckPredicate, 127, // 1386: check predicate 127
13234 OPC_Decode, 195, 112, 207, 1, // 1388: decode to CV_SB_rr using decoder 207
13235 // 1388: }
13236 21, 7, // 1393: case 0x15: {
13237 OPC_CheckPredicate, 127, // 1395: check predicate 127
13238 OPC_Decode, 225, 112, 207, 1, // 1397: decode to CV_SH_rr using decoder 207
13239 // 1397: }
13240 22, 7, // 1402: case 0x16: {
13241 OPC_CheckPredicate, 127, // 1404: check predicate 127
13242 OPC_Decode, 141, 113, 207, 1, // 1406: decode to CV_SW_rr using decoder 207
13243 // 1406: }
13244 24, 7, // 1411: case 0x18: {
13245 OPC_CheckPredicate, 128, 1, // 1413: check predicate 128
13246 OPC_Decode, 237, 111, 30, // 1416: decode to CV_EXTRACTR using decoder 30
13247 // 1416: }
13248 25, 7, // 1420: case 0x19: {
13249 OPC_CheckPredicate, 128, 1, // 1422: check predicate 128
13250 OPC_Decode, 239, 111, 30, // 1425: decode to CV_EXTRACTUR using decoder 30
13251 // 1425: }
13252 26, 7, // 1429: case 0x1a: {
13253 OPC_CheckPredicate, 128, 1, // 1431: check predicate 128
13254 OPC_Decode, 247, 111, 58, // 1434: decode to CV_INSERTR using decoder 58
13255 // 1434: }
13256 28, 7, // 1438: case 0x1c: {
13257 OPC_CheckPredicate, 128, 1, // 1440: check predicate 128
13258 OPC_Decode, 132, 111, 30, // 1443: decode to CV_BCLRR using decoder 30
13259 // 1443: }
13260 29, 7, // 1447: case 0x1d: {
13261 OPC_CheckPredicate, 128, 1, // 1449: check predicate 128
13262 OPC_Decode, 137, 111, 30, // 1452: decode to CV_BSETR using decoder 30
13263 // 1452: }
13264 32, 7, // 1456: case 0x20: {
13265 OPC_CheckPredicate, 128, 1, // 1458: check predicate 128
13266 OPC_Decode, 193, 112, 30, // 1461: decode to CV_ROR using decoder 30
13267 // 1461: }
13268 33, 11, // 1465: case 0x21: {
13269 OPC_CheckPredicate, 128, 1, // 1467: check predicate 128
13270 OPC_CheckField, 20, 5, 0, // 1470: check Inst[24:20] == 0x0
13271 OPC_Decode, 244, 111, 16, // 1474: decode to CV_FF1 using decoder 16
13272 // 1474: }
13273 34, 11, // 1478: case 0x22: {
13274 OPC_CheckPredicate, 128, 1, // 1480: check predicate 128
13275 OPC_CheckField, 20, 5, 0, // 1483: check Inst[24:20] == 0x0
13276 OPC_Decode, 245, 111, 16, // 1487: decode to CV_FL1 using decoder 16
13277 // 1487: }
13278 35, 11, // 1491: case 0x23: {
13279 OPC_CheckPredicate, 128, 1, // 1493: check predicate 128
13280 OPC_CheckField, 20, 5, 0, // 1496: check Inst[24:20] == 0x0
13281 OPC_Decode, 138, 111, 16, // 1500: decode to CV_CLB using decoder 16
13282 // 1500: }
13283 36, 11, // 1504: case 0x24: {
13284 OPC_CheckPredicate, 128, 1, // 1506: check predicate 128
13285 OPC_CheckField, 20, 5, 0, // 1509: check Inst[24:20] == 0x0
13286 OPC_Decode, 203, 111, 16, // 1513: decode to CV_CNT using decoder 16
13287 // 1513: }
13288 40, 11, // 1517: case 0x28: {
13289 OPC_CheckPredicate, 130, 1, // 1519: check predicate 130
13290 OPC_CheckField, 20, 5, 0, // 1522: check Inst[24:20] == 0x0
13291 OPC_Decode, 221, 110, 16, // 1526: decode to CV_ABS using decoder 16
13292 // 1526: }
13293 41, 7, // 1530: case 0x29: {
13294 OPC_CheckPredicate, 130, 1, // 1532: check predicate 130
13295 OPC_Decode, 227, 112, 30, // 1535: decode to CV_SLE using decoder 30
13296 // 1535: }
13297 42, 7, // 1539: case 0x2a: {
13298 OPC_CheckPredicate, 130, 1, // 1541: check predicate 130
13299 OPC_Decode, 228, 112, 30, // 1544: decode to CV_SLEU using decoder 30
13300 // 1544: }
13301 43, 7, // 1548: case 0x2b: {
13302 OPC_CheckPredicate, 130, 1, // 1550: check predicate 130
13303 OPC_Decode, 160, 112, 30, // 1553: decode to CV_MIN using decoder 30
13304 // 1553: }
13305 44, 7, // 1557: case 0x2c: {
13306 OPC_CheckPredicate, 130, 1, // 1559: check predicate 130
13307 OPC_Decode, 161, 112, 30, // 1562: decode to CV_MINU using decoder 30
13308 // 1562: }
13309 45, 7, // 1566: case 0x2d: {
13310 OPC_CheckPredicate, 130, 1, // 1568: check predicate 130
13311 OPC_Decode, 146, 112, 30, // 1571: decode to CV_MAX using decoder 30
13312 // 1571: }
13313 46, 7, // 1575: case 0x2e: {
13314 OPC_CheckPredicate, 130, 1, // 1577: check predicate 130
13315 OPC_Decode, 147, 112, 30, // 1580: decode to CV_MAXU using decoder 30
13316 // 1580: }
13317 48, 11, // 1584: case 0x30: {
13318 OPC_CheckPredicate, 130, 1, // 1586: check predicate 130
13319 OPC_CheckField, 20, 5, 0, // 1589: check Inst[24:20] == 0x0
13320 OPC_Decode, 234, 111, 16, // 1593: decode to CV_EXTHS using decoder 16
13321 // 1593: }
13322 49, 11, // 1597: case 0x31: {
13323 OPC_CheckPredicate, 130, 1, // 1599: check predicate 130
13324 OPC_CheckField, 20, 5, 0, // 1602: check Inst[24:20] == 0x0
13325 OPC_Decode, 235, 111, 16, // 1606: decode to CV_EXTHZ using decoder 16
13326 // 1606: }
13327 50, 11, // 1610: case 0x32: {
13328 OPC_CheckPredicate, 130, 1, // 1612: check predicate 130
13329 OPC_CheckField, 20, 5, 0, // 1615: check Inst[24:20] == 0x0
13330 OPC_Decode, 232, 111, 16, // 1619: decode to CV_EXTBS using decoder 16
13331 // 1619: }
13332 51, 11, // 1623: case 0x33: {
13333 OPC_CheckPredicate, 130, 1, // 1625: check predicate 130
13334 OPC_CheckField, 20, 5, 0, // 1628: check Inst[24:20] == 0x0
13335 OPC_Decode, 233, 111, 16, // 1632: decode to CV_EXTBZ using decoder 16
13336 // 1632: }
13337 56, 7, // 1636: case 0x38: {
13338 OPC_CheckPredicate, 130, 1, // 1638: check predicate 130
13339 OPC_Decode, 139, 111, 20, // 1641: decode to CV_CLIP using decoder 20
13340 // 1641: }
13341 57, 7, // 1645: case 0x39: {
13342 OPC_CheckPredicate, 130, 1, // 1647: check predicate 130
13343 OPC_Decode, 141, 111, 20, // 1650: decode to CV_CLIPU using decoder 20
13344 // 1650: }
13345 58, 7, // 1654: case 0x3a: {
13346 OPC_CheckPredicate, 130, 1, // 1656: check predicate 130
13347 OPC_Decode, 140, 111, 30, // 1659: decode to CV_CLIPR using decoder 30
13348 // 1659: }
13349 59, 7, // 1663: case 0x3b: {
13350 OPC_CheckPredicate, 130, 1, // 1665: check predicate 130
13351 OPC_Decode, 142, 111, 30, // 1668: decode to CV_CLIPUR using decoder 30
13352 // 1668: }
13353 64, 7, // 1672: case 0x40: {
13354 OPC_CheckPredicate, 130, 1, // 1674: check predicate 130
13355 OPC_Decode, 225, 110, 58, // 1677: decode to CV_ADDNR using decoder 58
13356 // 1677: }
13357 65, 7, // 1681: case 0x41: {
13358 OPC_CheckPredicate, 130, 1, // 1683: check predicate 130
13359 OPC_Decode, 229, 110, 58, // 1686: decode to CV_ADDUNR using decoder 58
13360 // 1686: }
13361 66, 7, // 1690: case 0x42: {
13362 OPC_CheckPredicate, 130, 1, // 1692: check predicate 130
13363 OPC_Decode, 227, 110, 58, // 1695: decode to CV_ADDRNR using decoder 58
13364 // 1695: }
13365 67, 7, // 1699: case 0x43: {
13366 OPC_CheckPredicate, 130, 1, // 1701: check predicate 130
13367 OPC_Decode, 231, 110, 58, // 1704: decode to CV_ADDURNR using decoder 58
13368 // 1704: }
13369 68, 7, // 1708: case 0x44: {
13370 OPC_CheckPredicate, 130, 1, // 1710: check predicate 130
13371 OPC_Decode, 248, 112, 58, // 1713: decode to CV_SUBNR using decoder 58
13372 // 1713: }
13373 69, 7, // 1717: case 0x45: {
13374 OPC_CheckPredicate, 130, 1, // 1719: check predicate 130
13375 OPC_Decode, 128, 113, 58, // 1722: decode to CV_SUBUNR using decoder 58
13376 // 1722: }
13377 70, 7, // 1726: case 0x46: {
13378 OPC_CheckPredicate, 130, 1, // 1728: check predicate 130
13379 OPC_Decode, 250, 112, 58, // 1731: decode to CV_SUBRNR using decoder 58
13380 // 1731: }
13381 71, 7, // 1735: case 0x47: {
13382 OPC_CheckPredicate, 130, 1, // 1737: check predicate 130
13383 OPC_Decode, 130, 113, 58, // 1740: decode to CV_SUBURNR using decoder 58
13384 // 1740: }
13385 72, 7, // 1744: case 0x48: {
13386 OPC_CheckPredicate, 132, 1, // 1746: check predicate 132
13387 OPC_Decode, 137, 112, 58, // 1749: decode to CV_MAC using decoder 58
13388 // 1749: }
13389 73, 0, // 1753: case 0x49: {
13390 OPC_CheckPredicate, 132, 1, // 1755: check predicate 132
13391 OPC_Decode, 174, 112, 58, // 1758: decode to CV_MSU using decoder 58
13392 // 1758: }
13393 // 1758: } // switch Inst[31:25]
13394 // 1758: }
13395 91, 43, // 1762: case 0x5b: {
13396 OPC_SwitchField, 30, 2, // 1764: switch Inst[31:30] {
13397 0, 8, // 1767: case 0x0: {
13398 OPC_CheckPredicate, 130, 1, // 1769: check predicate 130
13399 OPC_Decode, 247, 112, 204, 1, // 1772: decode to CV_SUBN using decoder 204
13400 // 1772: }
13401 1, 8, // 1777: case 0x1: {
13402 OPC_CheckPredicate, 130, 1, // 1779: check predicate 130
13403 OPC_Decode, 255, 112, 204, 1, // 1782: decode to CV_SUBUN using decoder 204
13404 // 1782: }
13405 2, 8, // 1787: case 0x2: {
13406 OPC_CheckPredicate, 130, 1, // 1789: check predicate 130
13407 OPC_Decode, 249, 112, 204, 1, // 1792: decode to CV_SUBRN using decoder 204
13408 // 1792: }
13409 3, 0, // 1797: case 0x3: {
13410 OPC_CheckPredicate, 130, 1, // 1799: check predicate 130
13411 OPC_Decode, 129, 113, 204, 1, // 1802: decode to CV_SUBURN using decoder 204
13412 // 1802: }
13413 // 1802: } // switch Inst[31:30]
13414 // 1802: }
13415 123, 0, // 1807: case 0x7b: {
13416 OPC_CheckPredicate, 129, 1, // 1809: check predicate 129
13417 OPC_CheckField, 26, 6, 46, // 1812: check Inst[31:26] == 0x2e
13418 OPC_Decode, 240, 111, 202, 1, // 1816: decode to CV_EXTRACTU_B using decoder 202
13419 // 1816: }
13420 // 1816: } // switch Inst[6:0]
13421 // 1816: }
13422 4, 140, 4, // 1821: case 0x4: {
13423 OPC_SwitchField, 0, 7, // 1824: switch Inst[6:0] {
13424 11, 7, // 1827: case 0xb: {
13425 OPC_CheckPredicate, 127, // 1829: check predicate 127
13426 OPC_Decode, 250, 111, 198, 1, // 1831: decode to CV_LBU_ri_inc using decoder 198
13427 // 1831: }
13428 91, 43, // 1836: case 0x5b: {
13429 OPC_SwitchField, 30, 2, // 1838: switch Inst[31:30] {
13430 0, 8, // 1841: case 0x0: {
13431 OPC_CheckPredicate, 132, 1, // 1843: check predicate 132
13432 OPC_Decode, 179, 112, 204, 1, // 1846: decode to CV_MULSN using decoder 204
13433 // 1846: }
13434 1, 8, // 1851: case 0x1: {
13435 OPC_CheckPredicate, 132, 1, // 1853: check predicate 132
13436 OPC_Decode, 175, 112, 204, 1, // 1856: decode to CV_MULHHSN using decoder 204
13437 // 1856: }
13438 2, 8, // 1861: case 0x2: {
13439 OPC_CheckPredicate, 132, 1, // 1863: check predicate 132
13440 OPC_Decode, 180, 112, 204, 1, // 1866: decode to CV_MULSRN using decoder 204
13441 // 1866: }
13442 3, 0, // 1871: case 0x3: {
13443 OPC_CheckPredicate, 132, 1, // 1873: check predicate 132
13444 OPC_Decode, 176, 112, 204, 1, // 1876: decode to CV_MULHHSRN using decoder 204
13445 // 1876: }
13446 // 1876: } // switch Inst[31:30]
13447 // 1876: }
13448 123, 0, // 1881: case 0x7b: {
13449 OPC_SwitchField, 26, 6, // 1883: switch Inst[31:26] {
13450 0, 11, // 1886: case 0x0: {
13451 OPC_CheckPredicate, 129, 1, // 1888: check predicate 129
13452 OPC_CheckField, 25, 1, 0, // 1891: check Inst[25] == 0x0
13453 OPC_Decode, 240, 110, 30, // 1895: decode to CV_ADD_SC_H using decoder 30
13454 // 1895: }
13455 1, 11, // 1899: case 0x1: {
13456 OPC_CheckPredicate, 129, 1, // 1901: check predicate 129
13457 OPC_CheckField, 25, 1, 0, // 1904: check Inst[25] == 0x0
13458 OPC_Decode, 148, 111, 30, // 1908: decode to CV_CMPEQ_SC_H using decoder 30
13459 // 1908: }
13460 2, 11, // 1912: case 0x2: {
13461 OPC_CheckPredicate, 129, 1, // 1914: check predicate 129
13462 OPC_CheckField, 25, 1, 0, // 1917: check Inst[25] == 0x0
13463 OPC_Decode, 139, 113, 30, // 1921: decode to CV_SUB_SC_H using decoder 30
13464 // 1921: }
13465 3, 11, // 1925: case 0x3: {
13466 OPC_CheckPredicate, 129, 1, // 1927: check predicate 129
13467 OPC_CheckField, 25, 1, 0, // 1930: check Inst[25] == 0x0
13468 OPC_Decode, 202, 111, 30, // 1934: decode to CV_CMPNE_SC_H using decoder 30
13469 // 1934: }
13470 4, 11, // 1938: case 0x4: {
13471 OPC_CheckPredicate, 129, 1, // 1940: check predicate 129
13472 OPC_CheckField, 25, 1, 0, // 1943: check Inst[25] == 0x0
13473 OPC_Decode, 130, 111, 30, // 1947: decode to CV_AVG_SC_H using decoder 30
13474 // 1947: }
13475 5, 11, // 1951: case 0x5: {
13476 OPC_CheckPredicate, 129, 1, // 1953: check predicate 129
13477 OPC_CheckField, 25, 1, 0, // 1956: check Inst[25] == 0x0
13478 OPC_Decode, 172, 111, 30, // 1960: decode to CV_CMPGT_SC_H using decoder 30
13479 // 1960: }
13480 6, 11, // 1964: case 0x6: {
13481 OPC_CheckPredicate, 129, 1, // 1966: check predicate 129
13482 OPC_CheckField, 25, 1, 0, // 1969: check Inst[25] == 0x0
13483 OPC_Decode, 252, 110, 30, // 1973: decode to CV_AVGU_SC_H using decoder 30
13484 // 1973: }
13485 7, 11, // 1977: case 0x7: {
13486 OPC_CheckPredicate, 129, 1, // 1979: check predicate 129
13487 OPC_CheckField, 25, 1, 0, // 1982: check Inst[25] == 0x0
13488 OPC_Decode, 160, 111, 30, // 1986: decode to CV_CMPGE_SC_H using decoder 30
13489 // 1986: }
13490 8, 11, // 1990: case 0x8: {
13491 OPC_CheckPredicate, 129, 1, // 1992: check predicate 129
13492 OPC_CheckField, 25, 1, 0, // 1995: check Inst[25] == 0x0
13493 OPC_Decode, 173, 112, 30, // 1999: decode to CV_MIN_SC_H using decoder 30
13494 // 1999: }
13495 9, 11, // 2003: case 0x9: {
13496 OPC_CheckPredicate, 129, 1, // 2005: check predicate 129
13497 OPC_CheckField, 25, 1, 0, // 2008: check Inst[25] == 0x0
13498 OPC_Decode, 196, 111, 30, // 2012: decode to CV_CMPLT_SC_H using decoder 30
13499 // 2012: }
13500 10, 11, // 2016: case 0xa: {
13501 OPC_CheckPredicate, 129, 1, // 2018: check predicate 129
13502 OPC_CheckField, 25, 1, 0, // 2021: check Inst[25] == 0x0
13503 OPC_Decode, 167, 112, 30, // 2025: decode to CV_MINU_SC_H using decoder 30
13504 // 2025: }
13505 11, 11, // 2029: case 0xb: {
13506 OPC_CheckPredicate, 129, 1, // 2031: check predicate 129
13507 OPC_CheckField, 25, 1, 0, // 2034: check Inst[25] == 0x0
13508 OPC_Decode, 184, 111, 30, // 2038: decode to CV_CMPLE_SC_H using decoder 30
13509 // 2038: }
13510 12, 11, // 2042: case 0xc: {
13511 OPC_CheckPredicate, 129, 1, // 2044: check predicate 129
13512 OPC_CheckField, 25, 1, 0, // 2047: check Inst[25] == 0x0
13513 OPC_Decode, 159, 112, 30, // 2051: decode to CV_MAX_SC_H using decoder 30
13514 // 2051: }
13515 13, 11, // 2055: case 0xd: {
13516 OPC_CheckPredicate, 129, 1, // 2057: check predicate 129
13517 OPC_CheckField, 25, 1, 0, // 2060: check Inst[25] == 0x0
13518 OPC_Decode, 166, 111, 30, // 2064: decode to CV_CMPGTU_SC_H using decoder 30
13519 // 2064: }
13520 14, 11, // 2068: case 0xe: {
13521 OPC_CheckPredicate, 129, 1, // 2070: check predicate 129
13522 OPC_CheckField, 25, 1, 0, // 2073: check Inst[25] == 0x0
13523 OPC_Decode, 153, 112, 30, // 2077: decode to CV_MAXU_SC_H using decoder 30
13524 // 2077: }
13525 15, 11, // 2081: case 0xf: {
13526 OPC_CheckPredicate, 129, 1, // 2083: check predicate 129
13527 OPC_CheckField, 25, 1, 0, // 2086: check Inst[25] == 0x0
13528 OPC_Decode, 154, 111, 30, // 2090: decode to CV_CMPGEU_SC_H using decoder 30
13529 // 2090: }
13530 16, 11, // 2094: case 0x10: {
13531 OPC_CheckPredicate, 129, 1, // 2096: check predicate 129
13532 OPC_CheckField, 25, 1, 0, // 2099: check Inst[25] == 0x0
13533 OPC_Decode, 246, 112, 30, // 2103: decode to CV_SRL_SC_H using decoder 30
13534 // 2103: }
13535 17, 11, // 2107: case 0x11: {
13536 OPC_CheckPredicate, 129, 1, // 2109: check predicate 129
13537 OPC_CheckField, 25, 1, 0, // 2112: check Inst[25] == 0x0
13538 OPC_Decode, 190, 111, 30, // 2116: decode to CV_CMPLTU_SC_H using decoder 30
13539 // 2116: }
13540 18, 11, // 2120: case 0x12: {
13541 OPC_CheckPredicate, 129, 1, // 2122: check predicate 129
13542 OPC_CheckField, 25, 1, 0, // 2125: check Inst[25] == 0x0
13543 OPC_Decode, 240, 112, 30, // 2129: decode to CV_SRA_SC_H using decoder 30
13544 // 2129: }
13545 19, 11, // 2133: case 0x13: {
13546 OPC_CheckPredicate, 129, 1, // 2135: check predicate 129
13547 OPC_CheckField, 25, 1, 0, // 2138: check Inst[25] == 0x0
13548 OPC_Decode, 178, 111, 30, // 2142: decode to CV_CMPLEU_SC_H using decoder 30
13549 // 2142: }
13550 20, 11, // 2146: case 0x14: {
13551 OPC_CheckPredicate, 129, 1, // 2148: check predicate 129
13552 OPC_CheckField, 25, 1, 0, // 2151: check Inst[25] == 0x0
13553 OPC_Decode, 234, 112, 30, // 2155: decode to CV_SLL_SC_H using decoder 30
13554 // 2155: }
13555 21, 21, // 2159: case 0x15: {
13556 OPC_SwitchField, 25, 1, // 2161: switch Inst[25] {
13557 0, 7, // 2164: case 0x0: {
13558 OPC_CheckPredicate, 129, 1, // 2166: check predicate 129
13559 OPC_Decode, 211, 111, 58, // 2169: decode to CV_CPLXMUL_R_DIV4 using decoder 58
13560 // 2169: }
13561 1, 0, // 2173: case 0x1: {
13562 OPC_CheckPredicate, 129, 1, // 2175: check predicate 129
13563 OPC_Decode, 207, 111, 58, // 2178: decode to CV_CPLXMUL_I_DIV4 using decoder 58
13564 // 2178: }
13565 // 2178: } // switch Inst[25]
13566 // 2178: }
13567 22, 11, // 2182: case 0x16: {
13568 OPC_CheckPredicate, 129, 1, // 2184: check predicate 129
13569 OPC_CheckField, 25, 1, 0, // 2187: check Inst[25] == 0x0
13570 OPC_Decode, 188, 112, 30, // 2191: decode to CV_OR_SC_H using decoder 30
13571 // 2191: }
13572 24, 11, // 2195: case 0x18: {
13573 OPC_CheckPredicate, 129, 1, // 2197: check predicate 129
13574 OPC_CheckField, 25, 1, 0, // 2200: check Inst[25] == 0x0
13575 OPC_Decode, 148, 113, 30, // 2204: decode to CV_XOR_SC_H using decoder 30
13576 // 2204: }
13577 25, 11, // 2208: case 0x19: {
13578 OPC_CheckPredicate, 129, 1, // 2210: check predicate 129
13579 OPC_CheckField, 25, 1, 0, // 2213: check Inst[25] == 0x0
13580 OPC_Decode, 253, 112, 30, // 2217: decode to CV_SUBROTMJ_DIV4 using decoder 30
13581 // 2217: }
13582 26, 11, // 2221: case 0x1a: {
13583 OPC_CheckPredicate, 129, 1, // 2223: check predicate 129
13584 OPC_CheckField, 25, 1, 0, // 2226: check Inst[25] == 0x0
13585 OPC_Decode, 246, 110, 30, // 2230: decode to CV_AND_SC_H using decoder 30
13586 // 2230: }
13587 27, 11, // 2234: case 0x1b: {
13588 OPC_CheckPredicate, 129, 1, // 2236: check predicate 129
13589 OPC_CheckField, 25, 1, 0, // 2239: check Inst[25] == 0x0
13590 OPC_Decode, 234, 110, 30, // 2243: decode to CV_ADD_DIV4 using decoder 30
13591 // 2243: }
13592 29, 11, // 2247: case 0x1d: {
13593 OPC_CheckPredicate, 129, 1, // 2249: check predicate 129
13594 OPC_CheckField, 25, 1, 0, // 2252: check Inst[25] == 0x0
13595 OPC_Decode, 133, 113, 30, // 2256: decode to CV_SUB_DIV4 using decoder 30
13596 // 2256: }
13597 32, 11, // 2260: case 0x20: {
13598 OPC_CheckPredicate, 129, 1, // 2262: check predicate 129
13599 OPC_CheckField, 25, 1, 0, // 2265: check Inst[25] == 0x0
13600 OPC_Decode, 224, 111, 30, // 2269: decode to CV_DOTUP_SC_H using decoder 30
13601 // 2269: }
13602 34, 11, // 2273: case 0x22: {
13603 OPC_CheckPredicate, 129, 1, // 2275: check predicate 129
13604 OPC_CheckField, 25, 1, 0, // 2278: check Inst[25] == 0x0
13605 OPC_Decode, 230, 111, 30, // 2282: decode to CV_DOTUSP_SC_H using decoder 30
13606 // 2282: }
13607 36, 11, // 2286: case 0x24: {
13608 OPC_CheckPredicate, 129, 1, // 2288: check predicate 129
13609 OPC_CheckField, 25, 1, 0, // 2291: check Inst[25] == 0x0
13610 OPC_Decode, 218, 111, 30, // 2295: decode to CV_DOTSP_SC_H using decoder 30
13611 // 2295: }
13612 38, 11, // 2299: case 0x26: {
13613 OPC_CheckPredicate, 129, 1, // 2301: check predicate 129
13614 OPC_CheckField, 25, 1, 0, // 2304: check Inst[25] == 0x0
13615 OPC_Decode, 208, 112, 58, // 2308: decode to CV_SDOTUP_SC_H using decoder 58
13616 // 2308: }
13617 40, 11, // 2312: case 0x28: {
13618 OPC_CheckPredicate, 129, 1, // 2314: check predicate 129
13619 OPC_CheckField, 25, 1, 0, // 2317: check Inst[25] == 0x0
13620 OPC_Decode, 214, 112, 58, // 2321: decode to CV_SDOTUSP_SC_H using decoder 58
13621 // 2321: }
13622 42, 11, // 2325: case 0x2a: {
13623 OPC_CheckPredicate, 129, 1, // 2327: check predicate 129
13624 OPC_CheckField, 25, 1, 0, // 2330: check Inst[25] == 0x0
13625 OPC_Decode, 202, 112, 58, // 2334: decode to CV_SDOTSP_SC_H using decoder 58
13626 // 2334: }
13627 46, 0, // 2338: case 0x2e: {
13628 OPC_CheckPredicate, 129, 1, // 2340: check predicate 129
13629 OPC_Decode, 249, 111, 208, 1, // 2343: decode to CV_INSERT_H using decoder 208
13630 // 2343: }
13631 // 2343: } // switch Inst[31:26]
13632 // 2343: }
13633 // 2343: } // switch Inst[6:0]
13634 // 2343: }
13635 5, 206, 3, // 2348: case 0x5: {
13636 OPC_SwitchField, 0, 7, // 2351: switch Inst[6:0] {
13637 11, 7, // 2354: case 0xb: {
13638 OPC_CheckPredicate, 127, // 2356: check predicate 127
13639 OPC_Decode, 128, 112, 198, 1, // 2358: decode to CV_LHU_ri_inc using decoder 198
13640 // 2358: }
13641 91, 43, // 2363: case 0x5b: {
13642 OPC_SwitchField, 30, 2, // 2365: switch Inst[31:30] {
13643 0, 8, // 2368: case 0x0: {
13644 OPC_CheckPredicate, 132, 1, // 2370: check predicate 132
13645 OPC_Decode, 181, 112, 204, 1, // 2373: decode to CV_MULUN using decoder 204
13646 // 2373: }
13647 1, 8, // 2378: case 0x1: {
13648 OPC_CheckPredicate, 132, 1, // 2380: check predicate 132
13649 OPC_Decode, 177, 112, 204, 1, // 2383: decode to CV_MULHHUN using decoder 204
13650 // 2383: }
13651 2, 8, // 2388: case 0x2: {
13652 OPC_CheckPredicate, 132, 1, // 2390: check predicate 132
13653 OPC_Decode, 182, 112, 204, 1, // 2393: decode to CV_MULURN using decoder 204
13654 // 2393: }
13655 3, 0, // 2398: case 0x3: {
13656 OPC_CheckPredicate, 132, 1, // 2400: check predicate 132
13657 OPC_Decode, 178, 112, 204, 1, // 2403: decode to CV_MULHHURN using decoder 204
13658 // 2403: }
13659 // 2403: } // switch Inst[31:30]
13660 // 2403: }
13661 123, 0, // 2408: case 0x7b: {
13662 OPC_SwitchField, 26, 6, // 2410: switch Inst[31:26] {
13663 0, 11, // 2413: case 0x0: {
13664 OPC_CheckPredicate, 129, 1, // 2415: check predicate 129
13665 OPC_CheckField, 25, 1, 0, // 2418: check Inst[25] == 0x0
13666 OPC_Decode, 239, 110, 30, // 2422: decode to CV_ADD_SC_B using decoder 30
13667 // 2422: }
13668 1, 11, // 2426: case 0x1: {
13669 OPC_CheckPredicate, 129, 1, // 2428: check predicate 129
13670 OPC_CheckField, 25, 1, 0, // 2431: check Inst[25] == 0x0
13671 OPC_Decode, 147, 111, 30, // 2435: decode to CV_CMPEQ_SC_B using decoder 30
13672 // 2435: }
13673 2, 11, // 2439: case 0x2: {
13674 OPC_CheckPredicate, 129, 1, // 2441: check predicate 129
13675 OPC_CheckField, 25, 1, 0, // 2444: check Inst[25] == 0x0
13676 OPC_Decode, 138, 113, 30, // 2448: decode to CV_SUB_SC_B using decoder 30
13677 // 2448: }
13678 3, 11, // 2452: case 0x3: {
13679 OPC_CheckPredicate, 129, 1, // 2454: check predicate 129
13680 OPC_CheckField, 25, 1, 0, // 2457: check Inst[25] == 0x0
13681 OPC_Decode, 201, 111, 30, // 2461: decode to CV_CMPNE_SC_B using decoder 30
13682 // 2461: }
13683 4, 11, // 2465: case 0x4: {
13684 OPC_CheckPredicate, 129, 1, // 2467: check predicate 129
13685 OPC_CheckField, 25, 1, 0, // 2470: check Inst[25] == 0x0
13686 OPC_Decode, 129, 111, 30, // 2474: decode to CV_AVG_SC_B using decoder 30
13687 // 2474: }
13688 5, 11, // 2478: case 0x5: {
13689 OPC_CheckPredicate, 129, 1, // 2480: check predicate 129
13690 OPC_CheckField, 25, 1, 0, // 2483: check Inst[25] == 0x0
13691 OPC_Decode, 171, 111, 30, // 2487: decode to CV_CMPGT_SC_B using decoder 30
13692 // 2487: }
13693 6, 11, // 2491: case 0x6: {
13694 OPC_CheckPredicate, 129, 1, // 2493: check predicate 129
13695 OPC_CheckField, 25, 1, 0, // 2496: check Inst[25] == 0x0
13696 OPC_Decode, 251, 110, 30, // 2500: decode to CV_AVGU_SC_B using decoder 30
13697 // 2500: }
13698 7, 11, // 2504: case 0x7: {
13699 OPC_CheckPredicate, 129, 1, // 2506: check predicate 129
13700 OPC_CheckField, 25, 1, 0, // 2509: check Inst[25] == 0x0
13701 OPC_Decode, 159, 111, 30, // 2513: decode to CV_CMPGE_SC_B using decoder 30
13702 // 2513: }
13703 8, 11, // 2517: case 0x8: {
13704 OPC_CheckPredicate, 129, 1, // 2519: check predicate 129
13705 OPC_CheckField, 25, 1, 0, // 2522: check Inst[25] == 0x0
13706 OPC_Decode, 172, 112, 30, // 2526: decode to CV_MIN_SC_B using decoder 30
13707 // 2526: }
13708 9, 11, // 2530: case 0x9: {
13709 OPC_CheckPredicate, 129, 1, // 2532: check predicate 129
13710 OPC_CheckField, 25, 1, 0, // 2535: check Inst[25] == 0x0
13711 OPC_Decode, 195, 111, 30, // 2539: decode to CV_CMPLT_SC_B using decoder 30
13712 // 2539: }
13713 10, 11, // 2543: case 0xa: {
13714 OPC_CheckPredicate, 129, 1, // 2545: check predicate 129
13715 OPC_CheckField, 25, 1, 0, // 2548: check Inst[25] == 0x0
13716 OPC_Decode, 166, 112, 30, // 2552: decode to CV_MINU_SC_B using decoder 30
13717 // 2552: }
13718 11, 11, // 2556: case 0xb: {
13719 OPC_CheckPredicate, 129, 1, // 2558: check predicate 129
13720 OPC_CheckField, 25, 1, 0, // 2561: check Inst[25] == 0x0
13721 OPC_Decode, 183, 111, 30, // 2565: decode to CV_CMPLE_SC_B using decoder 30
13722 // 2565: }
13723 12, 11, // 2569: case 0xc: {
13724 OPC_CheckPredicate, 129, 1, // 2571: check predicate 129
13725 OPC_CheckField, 25, 1, 0, // 2574: check Inst[25] == 0x0
13726 OPC_Decode, 158, 112, 30, // 2578: decode to CV_MAX_SC_B using decoder 30
13727 // 2578: }
13728 13, 11, // 2582: case 0xd: {
13729 OPC_CheckPredicate, 129, 1, // 2584: check predicate 129
13730 OPC_CheckField, 25, 1, 0, // 2587: check Inst[25] == 0x0
13731 OPC_Decode, 165, 111, 30, // 2591: decode to CV_CMPGTU_SC_B using decoder 30
13732 // 2591: }
13733 14, 11, // 2595: case 0xe: {
13734 OPC_CheckPredicate, 129, 1, // 2597: check predicate 129
13735 OPC_CheckField, 25, 1, 0, // 2600: check Inst[25] == 0x0
13736 OPC_Decode, 152, 112, 30, // 2604: decode to CV_MAXU_SC_B using decoder 30
13737 // 2604: }
13738 15, 11, // 2608: case 0xf: {
13739 OPC_CheckPredicate, 129, 1, // 2610: check predicate 129
13740 OPC_CheckField, 25, 1, 0, // 2613: check Inst[25] == 0x0
13741 OPC_Decode, 153, 111, 30, // 2617: decode to CV_CMPGEU_SC_B using decoder 30
13742 // 2617: }
13743 16, 11, // 2621: case 0x10: {
13744 OPC_CheckPredicate, 129, 1, // 2623: check predicate 129
13745 OPC_CheckField, 25, 1, 0, // 2626: check Inst[25] == 0x0
13746 OPC_Decode, 245, 112, 30, // 2630: decode to CV_SRL_SC_B using decoder 30
13747 // 2630: }
13748 17, 11, // 2634: case 0x11: {
13749 OPC_CheckPredicate, 129, 1, // 2636: check predicate 129
13750 OPC_CheckField, 25, 1, 0, // 2639: check Inst[25] == 0x0
13751 OPC_Decode, 189, 111, 30, // 2643: decode to CV_CMPLTU_SC_B using decoder 30
13752 // 2643: }
13753 18, 11, // 2647: case 0x12: {
13754 OPC_CheckPredicate, 129, 1, // 2649: check predicate 129
13755 OPC_CheckField, 25, 1, 0, // 2652: check Inst[25] == 0x0
13756 OPC_Decode, 239, 112, 30, // 2656: decode to CV_SRA_SC_B using decoder 30
13757 // 2656: }
13758 19, 11, // 2660: case 0x13: {
13759 OPC_CheckPredicate, 129, 1, // 2662: check predicate 129
13760 OPC_CheckField, 25, 1, 0, // 2665: check Inst[25] == 0x0
13761 OPC_Decode, 177, 111, 30, // 2669: decode to CV_CMPLEU_SC_B using decoder 30
13762 // 2669: }
13763 20, 11, // 2673: case 0x14: {
13764 OPC_CheckPredicate, 129, 1, // 2675: check predicate 129
13765 OPC_CheckField, 25, 1, 0, // 2678: check Inst[25] == 0x0
13766 OPC_Decode, 233, 112, 30, // 2682: decode to CV_SLL_SC_B using decoder 30
13767 // 2682: }
13768 22, 11, // 2686: case 0x16: {
13769 OPC_CheckPredicate, 129, 1, // 2688: check predicate 129
13770 OPC_CheckField, 25, 1, 0, // 2691: check Inst[25] == 0x0
13771 OPC_Decode, 187, 112, 30, // 2695: decode to CV_OR_SC_B using decoder 30
13772 // 2695: }
13773 24, 11, // 2699: case 0x18: {
13774 OPC_CheckPredicate, 129, 1, // 2701: check predicate 129
13775 OPC_CheckField, 25, 1, 0, // 2704: check Inst[25] == 0x0
13776 OPC_Decode, 147, 113, 30, // 2708: decode to CV_XOR_SC_B using decoder 30
13777 // 2708: }
13778 26, 11, // 2712: case 0x1a: {
13779 OPC_CheckPredicate, 129, 1, // 2714: check predicate 129
13780 OPC_CheckField, 25, 1, 0, // 2717: check Inst[25] == 0x0
13781 OPC_Decode, 245, 110, 30, // 2721: decode to CV_AND_SC_B using decoder 30
13782 // 2721: }
13783 32, 11, // 2725: case 0x20: {
13784 OPC_CheckPredicate, 129, 1, // 2727: check predicate 129
13785 OPC_CheckField, 25, 1, 0, // 2730: check Inst[25] == 0x0
13786 OPC_Decode, 223, 111, 30, // 2734: decode to CV_DOTUP_SC_B using decoder 30
13787 // 2734: }
13788 34, 11, // 2738: case 0x22: {
13789 OPC_CheckPredicate, 129, 1, // 2740: check predicate 129
13790 OPC_CheckField, 25, 1, 0, // 2743: check Inst[25] == 0x0
13791 OPC_Decode, 229, 111, 30, // 2747: decode to CV_DOTUSP_SC_B using decoder 30
13792 // 2747: }
13793 36, 11, // 2751: case 0x24: {
13794 OPC_CheckPredicate, 129, 1, // 2753: check predicate 129
13795 OPC_CheckField, 25, 1, 0, // 2756: check Inst[25] == 0x0
13796 OPC_Decode, 217, 111, 30, // 2760: decode to CV_DOTSP_SC_B using decoder 30
13797 // 2760: }
13798 38, 11, // 2764: case 0x26: {
13799 OPC_CheckPredicate, 129, 1, // 2766: check predicate 129
13800 OPC_CheckField, 25, 1, 0, // 2769: check Inst[25] == 0x0
13801 OPC_Decode, 207, 112, 58, // 2773: decode to CV_SDOTUP_SC_B using decoder 58
13802 // 2773: }
13803 40, 11, // 2777: case 0x28: {
13804 OPC_CheckPredicate, 129, 1, // 2779: check predicate 129
13805 OPC_CheckField, 25, 1, 0, // 2782: check Inst[25] == 0x0
13806 OPC_Decode, 213, 112, 58, // 2786: decode to CV_SDOTUSP_SC_B using decoder 58
13807 // 2786: }
13808 42, 11, // 2790: case 0x2a: {
13809 OPC_CheckPredicate, 129, 1, // 2792: check predicate 129
13810 OPC_CheckField, 25, 1, 0, // 2795: check Inst[25] == 0x0
13811 OPC_Decode, 201, 112, 58, // 2799: decode to CV_SDOTSP_SC_B using decoder 58
13812 // 2799: }
13813 46, 0, // 2803: case 0x2e: {
13814 OPC_CheckPredicate, 129, 1, // 2805: check predicate 129
13815 OPC_Decode, 248, 111, 208, 1, // 2808: decode to CV_INSERT_B using decoder 208
13816 // 2808: }
13817 // 2808: } // switch Inst[31:26]
13818 // 2808: }
13819 // 2808: } // switch Inst[6:0]
13820 // 2808: }
13821 6, 179, 3, // 2813: case 0x6: {
13822 OPC_SwitchField, 0, 7, // 2816: switch Inst[6:0] {
13823 11, 8, // 2819: case 0xb: {
13824 OPC_CheckPredicate, 133, 1, // 2821: check predicate 133
13825 OPC_Decode, 133, 111, 209, 1, // 2824: decode to CV_BEQIMM using decoder 209
13826 // 2824: }
13827 91, 43, // 2829: case 0x5b: {
13828 OPC_SwitchField, 30, 2, // 2831: switch Inst[31:30] {
13829 0, 8, // 2834: case 0x0: {
13830 OPC_CheckPredicate, 132, 1, // 2836: check predicate 132
13831 OPC_Decode, 142, 112, 210, 1, // 2839: decode to CV_MACSN using decoder 210
13832 // 2839: }
13833 1, 8, // 2844: case 0x1: {
13834 OPC_CheckPredicate, 132, 1, // 2846: check predicate 132
13835 OPC_Decode, 138, 112, 210, 1, // 2849: decode to CV_MACHHSN using decoder 210
13836 // 2849: }
13837 2, 8, // 2854: case 0x2: {
13838 OPC_CheckPredicate, 132, 1, // 2856: check predicate 132
13839 OPC_Decode, 143, 112, 210, 1, // 2859: decode to CV_MACSRN using decoder 210
13840 // 2859: }
13841 3, 0, // 2864: case 0x3: {
13842 OPC_CheckPredicate, 132, 1, // 2866: check predicate 132
13843 OPC_Decode, 139, 112, 210, 1, // 2869: decode to CV_MACHHSRN using decoder 210
13844 // 2869: }
13845 // 2869: } // switch Inst[31:30]
13846 // 2869: }
13847 123, 0, // 2874: case 0x7b: {
13848 OPC_SwitchField, 26, 6, // 2876: switch Inst[31:26] {
13849 0, 8, // 2879: case 0x0: {
13850 OPC_CheckPredicate, 129, 1, // 2881: check predicate 129
13851 OPC_Decode, 238, 110, 211, 1, // 2884: decode to CV_ADD_SCI_H using decoder 211
13852 // 2884: }
13853 1, 8, // 2889: case 0x1: {
13854 OPC_CheckPredicate, 129, 1, // 2891: check predicate 129
13855 OPC_Decode, 146, 111, 211, 1, // 2894: decode to CV_CMPEQ_SCI_H using decoder 211
13856 // 2894: }
13857 2, 8, // 2899: case 0x2: {
13858 OPC_CheckPredicate, 129, 1, // 2901: check predicate 129
13859 OPC_Decode, 137, 113, 211, 1, // 2904: decode to CV_SUB_SCI_H using decoder 211
13860 // 2904: }
13861 3, 8, // 2909: case 0x3: {
13862 OPC_CheckPredicate, 129, 1, // 2911: check predicate 129
13863 OPC_Decode, 200, 111, 211, 1, // 2914: decode to CV_CMPNE_SCI_H using decoder 211
13864 // 2914: }
13865 4, 8, // 2919: case 0x4: {
13866 OPC_CheckPredicate, 129, 1, // 2921: check predicate 129
13867 OPC_Decode, 128, 111, 211, 1, // 2924: decode to CV_AVG_SCI_H using decoder 211
13868 // 2924: }
13869 5, 8, // 2929: case 0x5: {
13870 OPC_CheckPredicate, 129, 1, // 2931: check predicate 129
13871 OPC_Decode, 170, 111, 211, 1, // 2934: decode to CV_CMPGT_SCI_H using decoder 211
13872 // 2934: }
13873 6, 8, // 2939: case 0x6: {
13874 OPC_CheckPredicate, 129, 1, // 2941: check predicate 129
13875 OPC_Decode, 250, 110, 202, 1, // 2944: decode to CV_AVGU_SCI_H using decoder 202
13876 // 2944: }
13877 7, 8, // 2949: case 0x7: {
13878 OPC_CheckPredicate, 129, 1, // 2951: check predicate 129
13879 OPC_Decode, 158, 111, 211, 1, // 2954: decode to CV_CMPGE_SCI_H using decoder 211
13880 // 2954: }
13881 8, 8, // 2959: case 0x8: {
13882 OPC_CheckPredicate, 129, 1, // 2961: check predicate 129
13883 OPC_Decode, 171, 112, 211, 1, // 2964: decode to CV_MIN_SCI_H using decoder 211
13884 // 2964: }
13885 9, 8, // 2969: case 0x9: {
13886 OPC_CheckPredicate, 129, 1, // 2971: check predicate 129
13887 OPC_Decode, 194, 111, 211, 1, // 2974: decode to CV_CMPLT_SCI_H using decoder 211
13888 // 2974: }
13889 10, 8, // 2979: case 0xa: {
13890 OPC_CheckPredicate, 129, 1, // 2981: check predicate 129
13891 OPC_Decode, 165, 112, 202, 1, // 2984: decode to CV_MINU_SCI_H using decoder 202
13892 // 2984: }
13893 11, 8, // 2989: case 0xb: {
13894 OPC_CheckPredicate, 129, 1, // 2991: check predicate 129
13895 OPC_Decode, 182, 111, 211, 1, // 2994: decode to CV_CMPLE_SCI_H using decoder 211
13896 // 2994: }
13897 12, 8, // 2999: case 0xc: {
13898 OPC_CheckPredicate, 129, 1, // 3001: check predicate 129
13899 OPC_Decode, 157, 112, 211, 1, // 3004: decode to CV_MAX_SCI_H using decoder 211
13900 // 3004: }
13901 13, 8, // 3009: case 0xd: {
13902 OPC_CheckPredicate, 129, 1, // 3011: check predicate 129
13903 OPC_Decode, 164, 111, 202, 1, // 3014: decode to CV_CMPGTU_SCI_H using decoder 202
13904 // 3014: }
13905 14, 8, // 3019: case 0xe: {
13906 OPC_CheckPredicate, 129, 1, // 3021: check predicate 129
13907 OPC_Decode, 151, 112, 202, 1, // 3024: decode to CV_MAXU_SCI_H using decoder 202
13908 // 3024: }
13909 15, 8, // 3029: case 0xf: {
13910 OPC_CheckPredicate, 129, 1, // 3031: check predicate 129
13911 OPC_Decode, 152, 111, 202, 1, // 3034: decode to CV_CMPGEU_SCI_H using decoder 202
13912 // 3034: }
13913 16, 8, // 3039: case 0x10: {
13914 OPC_CheckPredicate, 129, 1, // 3041: check predicate 129
13915 OPC_Decode, 244, 112, 212, 1, // 3044: decode to CV_SRL_SCI_H using decoder 212
13916 // 3044: }
13917 17, 8, // 3049: case 0x11: {
13918 OPC_CheckPredicate, 129, 1, // 3051: check predicate 129
13919 OPC_Decode, 188, 111, 202, 1, // 3054: decode to CV_CMPLTU_SCI_H using decoder 202
13920 // 3054: }
13921 18, 8, // 3059: case 0x12: {
13922 OPC_CheckPredicate, 129, 1, // 3061: check predicate 129
13923 OPC_Decode, 238, 112, 212, 1, // 3064: decode to CV_SRA_SCI_H using decoder 212
13924 // 3064: }
13925 19, 8, // 3069: case 0x13: {
13926 OPC_CheckPredicate, 129, 1, // 3071: check predicate 129
13927 OPC_Decode, 176, 111, 202, 1, // 3074: decode to CV_CMPLEU_SCI_H using decoder 202
13928 // 3074: }
13929 20, 8, // 3079: case 0x14: {
13930 OPC_CheckPredicate, 129, 1, // 3081: check predicate 129
13931 OPC_Decode, 232, 112, 212, 1, // 3084: decode to CV_SLL_SCI_H using decoder 212
13932 // 3084: }
13933 21, 21, // 3089: case 0x15: {
13934 OPC_SwitchField, 25, 1, // 3091: switch Inst[25] {
13935 0, 7, // 3094: case 0x0: {
13936 OPC_CheckPredicate, 129, 1, // 3096: check predicate 129
13937 OPC_Decode, 212, 111, 58, // 3099: decode to CV_CPLXMUL_R_DIV8 using decoder 58
13938 // 3099: }
13939 1, 0, // 3103: case 0x1: {
13940 OPC_CheckPredicate, 129, 1, // 3105: check predicate 129
13941 OPC_Decode, 208, 111, 58, // 3108: decode to CV_CPLXMUL_I_DIV8 using decoder 58
13942 // 3108: }
13943 // 3108: } // switch Inst[25]
13944 // 3108: }
13945 22, 8, // 3112: case 0x16: {
13946 OPC_CheckPredicate, 129, 1, // 3114: check predicate 129
13947 OPC_Decode, 186, 112, 211, 1, // 3117: decode to CV_OR_SCI_H using decoder 211
13948 // 3117: }
13949 24, 8, // 3122: case 0x18: {
13950 OPC_CheckPredicate, 129, 1, // 3124: check predicate 129
13951 OPC_Decode, 146, 113, 211, 1, // 3127: decode to CV_XOR_SCI_H using decoder 211
13952 // 3127: }
13953 25, 11, // 3132: case 0x19: {
13954 OPC_CheckPredicate, 129, 1, // 3134: check predicate 129
13955 OPC_CheckField, 25, 1, 0, // 3137: check Inst[25] == 0x0
13956 OPC_Decode, 254, 112, 30, // 3141: decode to CV_SUBROTMJ_DIV8 using decoder 30
13957 // 3141: }
13958 26, 8, // 3145: case 0x1a: {
13959 OPC_CheckPredicate, 129, 1, // 3147: check predicate 129
13960 OPC_Decode, 244, 110, 211, 1, // 3150: decode to CV_AND_SCI_H using decoder 211
13961 // 3150: }
13962 27, 11, // 3155: case 0x1b: {
13963 OPC_CheckPredicate, 129, 1, // 3157: check predicate 129
13964 OPC_CheckField, 25, 1, 0, // 3160: check Inst[25] == 0x0
13965 OPC_Decode, 235, 110, 30, // 3164: decode to CV_ADD_DIV8 using decoder 30
13966 // 3164: }
13967 29, 11, // 3168: case 0x1d: {
13968 OPC_CheckPredicate, 129, 1, // 3170: check predicate 129
13969 OPC_CheckField, 25, 1, 0, // 3173: check Inst[25] == 0x0
13970 OPC_Decode, 134, 113, 30, // 3177: decode to CV_SUB_DIV8 using decoder 30
13971 // 3177: }
13972 32, 8, // 3181: case 0x20: {
13973 OPC_CheckPredicate, 129, 1, // 3183: check predicate 129
13974 OPC_Decode, 222, 111, 202, 1, // 3186: decode to CV_DOTUP_SCI_H using decoder 202
13975 // 3186: }
13976 34, 8, // 3191: case 0x22: {
13977 OPC_CheckPredicate, 129, 1, // 3193: check predicate 129
13978 OPC_Decode, 228, 111, 211, 1, // 3196: decode to CV_DOTUSP_SCI_H using decoder 211
13979 // 3196: }
13980 36, 8, // 3201: case 0x24: {
13981 OPC_CheckPredicate, 129, 1, // 3203: check predicate 129
13982 OPC_Decode, 216, 111, 211, 1, // 3206: decode to CV_DOTSP_SCI_H using decoder 211
13983 // 3206: }
13984 38, 8, // 3211: case 0x26: {
13985 OPC_CheckPredicate, 129, 1, // 3213: check predicate 129
13986 OPC_Decode, 206, 112, 208, 1, // 3216: decode to CV_SDOTUP_SCI_H using decoder 208
13987 // 3216: }
13988 40, 8, // 3221: case 0x28: {
13989 OPC_CheckPredicate, 129, 1, // 3223: check predicate 129
13990 OPC_Decode, 212, 112, 213, 1, // 3226: decode to CV_SDOTUSP_SCI_H using decoder 213
13991 // 3226: }
13992 42, 8, // 3231: case 0x2a: {
13993 OPC_CheckPredicate, 129, 1, // 3233: check predicate 129
13994 OPC_Decode, 200, 112, 213, 1, // 3236: decode to CV_SDOTSP_SCI_H using decoder 213
13995 // 3236: }
13996 48, 0, // 3241: case 0x30: {
13997 OPC_CheckPredicate, 129, 1, // 3243: check predicate 129
13998 OPC_Decode, 223, 112, 202, 1, // 3246: decode to CV_SHUFFLE_SCI_H using decoder 202
13999 // 3246: }
14000 // 3246: } // switch Inst[31:26]
14001 // 3246: }
14002 // 3246: } // switch Inst[6:0]
14003 // 3246: }
14004 7, 0, // 3251: case 0x7: {
14005 OPC_SwitchField, 0, 7, // 3253: switch Inst[6:0] {
14006 11, 8, // 3256: case 0xb: {
14007 OPC_CheckPredicate, 133, 1, // 3258: check predicate 133
14008 OPC_Decode, 135, 111, 209, 1, // 3261: decode to CV_BNEIMM using decoder 209
14009 // 3261: }
14010 91, 43, // 3266: case 0x5b: {
14011 OPC_SwitchField, 30, 2, // 3268: switch Inst[31:30] {
14012 0, 8, // 3271: case 0x0: {
14013 OPC_CheckPredicate, 132, 1, // 3273: check predicate 132
14014 OPC_Decode, 144, 112, 210, 1, // 3276: decode to CV_MACUN using decoder 210
14015 // 3276: }
14016 1, 8, // 3281: case 0x1: {
14017 OPC_CheckPredicate, 132, 1, // 3283: check predicate 132
14018 OPC_Decode, 140, 112, 210, 1, // 3286: decode to CV_MACHHUN using decoder 210
14019 // 3286: }
14020 2, 8, // 3291: case 0x2: {
14021 OPC_CheckPredicate, 132, 1, // 3293: check predicate 132
14022 OPC_Decode, 145, 112, 210, 1, // 3296: decode to CV_MACURN using decoder 210
14023 // 3296: }
14024 3, 0, // 3301: case 0x3: {
14025 OPC_CheckPredicate, 132, 1, // 3303: check predicate 132
14026 OPC_Decode, 141, 112, 210, 1, // 3306: decode to CV_MACHHURN using decoder 210
14027 // 3306: }
14028 // 3306: } // switch Inst[31:30]
14029 // 3306: }
14030 123, 0, // 3311: case 0x7b: {
14031 OPC_SwitchField, 26, 6, // 3313: switch Inst[31:26] {
14032 0, 8, // 3316: case 0x0: {
14033 OPC_CheckPredicate, 129, 1, // 3318: check predicate 129
14034 OPC_Decode, 237, 110, 211, 1, // 3321: decode to CV_ADD_SCI_B using decoder 211
14035 // 3321: }
14036 1, 8, // 3326: case 0x1: {
14037 OPC_CheckPredicate, 129, 1, // 3328: check predicate 129
14038 OPC_Decode, 145, 111, 211, 1, // 3331: decode to CV_CMPEQ_SCI_B using decoder 211
14039 // 3331: }
14040 2, 8, // 3336: case 0x2: {
14041 OPC_CheckPredicate, 129, 1, // 3338: check predicate 129
14042 OPC_Decode, 136, 113, 211, 1, // 3341: decode to CV_SUB_SCI_B using decoder 211
14043 // 3341: }
14044 3, 8, // 3346: case 0x3: {
14045 OPC_CheckPredicate, 129, 1, // 3348: check predicate 129
14046 OPC_Decode, 199, 111, 211, 1, // 3351: decode to CV_CMPNE_SCI_B using decoder 211
14047 // 3351: }
14048 4, 8, // 3356: case 0x4: {
14049 OPC_CheckPredicate, 129, 1, // 3358: check predicate 129
14050 OPC_Decode, 255, 110, 211, 1, // 3361: decode to CV_AVG_SCI_B using decoder 211
14051 // 3361: }
14052 5, 8, // 3366: case 0x5: {
14053 OPC_CheckPredicate, 129, 1, // 3368: check predicate 129
14054 OPC_Decode, 169, 111, 211, 1, // 3371: decode to CV_CMPGT_SCI_B using decoder 211
14055 // 3371: }
14056 6, 8, // 3376: case 0x6: {
14057 OPC_CheckPredicate, 129, 1, // 3378: check predicate 129
14058 OPC_Decode, 249, 110, 202, 1, // 3381: decode to CV_AVGU_SCI_B using decoder 202
14059 // 3381: }
14060 7, 8, // 3386: case 0x7: {
14061 OPC_CheckPredicate, 129, 1, // 3388: check predicate 129
14062 OPC_Decode, 157, 111, 211, 1, // 3391: decode to CV_CMPGE_SCI_B using decoder 211
14063 // 3391: }
14064 8, 8, // 3396: case 0x8: {
14065 OPC_CheckPredicate, 129, 1, // 3398: check predicate 129
14066 OPC_Decode, 170, 112, 211, 1, // 3401: decode to CV_MIN_SCI_B using decoder 211
14067 // 3401: }
14068 9, 8, // 3406: case 0x9: {
14069 OPC_CheckPredicate, 129, 1, // 3408: check predicate 129
14070 OPC_Decode, 193, 111, 211, 1, // 3411: decode to CV_CMPLT_SCI_B using decoder 211
14071 // 3411: }
14072 10, 8, // 3416: case 0xa: {
14073 OPC_CheckPredicate, 129, 1, // 3418: check predicate 129
14074 OPC_Decode, 164, 112, 202, 1, // 3421: decode to CV_MINU_SCI_B using decoder 202
14075 // 3421: }
14076 11, 8, // 3426: case 0xb: {
14077 OPC_CheckPredicate, 129, 1, // 3428: check predicate 129
14078 OPC_Decode, 181, 111, 211, 1, // 3431: decode to CV_CMPLE_SCI_B using decoder 211
14079 // 3431: }
14080 12, 8, // 3436: case 0xc: {
14081 OPC_CheckPredicate, 129, 1, // 3438: check predicate 129
14082 OPC_Decode, 156, 112, 211, 1, // 3441: decode to CV_MAX_SCI_B using decoder 211
14083 // 3441: }
14084 13, 8, // 3446: case 0xd: {
14085 OPC_CheckPredicate, 129, 1, // 3448: check predicate 129
14086 OPC_Decode, 163, 111, 202, 1, // 3451: decode to CV_CMPGTU_SCI_B using decoder 202
14087 // 3451: }
14088 14, 8, // 3456: case 0xe: {
14089 OPC_CheckPredicate, 129, 1, // 3458: check predicate 129
14090 OPC_Decode, 150, 112, 202, 1, // 3461: decode to CV_MAXU_SCI_B using decoder 202
14091 // 3461: }
14092 15, 8, // 3466: case 0xf: {
14093 OPC_CheckPredicate, 129, 1, // 3468: check predicate 129
14094 OPC_Decode, 151, 111, 202, 1, // 3471: decode to CV_CMPGEU_SCI_B using decoder 202
14095 // 3471: }
14096 16, 8, // 3476: case 0x10: {
14097 OPC_CheckPredicate, 129, 1, // 3478: check predicate 129
14098 OPC_Decode, 243, 112, 214, 1, // 3481: decode to CV_SRL_SCI_B using decoder 214
14099 // 3481: }
14100 17, 8, // 3486: case 0x11: {
14101 OPC_CheckPredicate, 129, 1, // 3488: check predicate 129
14102 OPC_Decode, 187, 111, 202, 1, // 3491: decode to CV_CMPLTU_SCI_B using decoder 202
14103 // 3491: }
14104 18, 8, // 3496: case 0x12: {
14105 OPC_CheckPredicate, 129, 1, // 3498: check predicate 129
14106 OPC_Decode, 237, 112, 214, 1, // 3501: decode to CV_SRA_SCI_B using decoder 214
14107 // 3501: }
14108 19, 8, // 3506: case 0x13: {
14109 OPC_CheckPredicate, 129, 1, // 3508: check predicate 129
14110 OPC_Decode, 175, 111, 202, 1, // 3511: decode to CV_CMPLEU_SCI_B using decoder 202
14111 // 3511: }
14112 20, 8, // 3516: case 0x14: {
14113 OPC_CheckPredicate, 129, 1, // 3518: check predicate 129
14114 OPC_Decode, 231, 112, 214, 1, // 3521: decode to CV_SLL_SCI_B using decoder 214
14115 // 3521: }
14116 22, 8, // 3526: case 0x16: {
14117 OPC_CheckPredicate, 129, 1, // 3528: check predicate 129
14118 OPC_Decode, 185, 112, 211, 1, // 3531: decode to CV_OR_SCI_B using decoder 211
14119 // 3531: }
14120 24, 8, // 3536: case 0x18: {
14121 OPC_CheckPredicate, 129, 1, // 3538: check predicate 129
14122 OPC_Decode, 145, 113, 211, 1, // 3541: decode to CV_XOR_SCI_B using decoder 211
14123 // 3541: }
14124 26, 8, // 3546: case 0x1a: {
14125 OPC_CheckPredicate, 129, 1, // 3548: check predicate 129
14126 OPC_Decode, 243, 110, 211, 1, // 3551: decode to CV_AND_SCI_B using decoder 211
14127 // 3551: }
14128 32, 8, // 3556: case 0x20: {
14129 OPC_CheckPredicate, 129, 1, // 3558: check predicate 129
14130 OPC_Decode, 221, 111, 202, 1, // 3561: decode to CV_DOTUP_SCI_B using decoder 202
14131 // 3561: }
14132 34, 8, // 3566: case 0x22: {
14133 OPC_CheckPredicate, 129, 1, // 3568: check predicate 129
14134 OPC_Decode, 227, 111, 211, 1, // 3571: decode to CV_DOTUSP_SCI_B using decoder 211
14135 // 3571: }
14136 36, 8, // 3576: case 0x24: {
14137 OPC_CheckPredicate, 129, 1, // 3578: check predicate 129
14138 OPC_Decode, 215, 111, 211, 1, // 3581: decode to CV_DOTSP_SCI_B using decoder 211
14139 // 3581: }
14140 38, 8, // 3586: case 0x26: {
14141 OPC_CheckPredicate, 129, 1, // 3588: check predicate 129
14142 OPC_Decode, 205, 112, 208, 1, // 3591: decode to CV_SDOTUP_SCI_B using decoder 208
14143 // 3591: }
14144 40, 8, // 3596: case 0x28: {
14145 OPC_CheckPredicate, 129, 1, // 3598: check predicate 129
14146 OPC_Decode, 211, 112, 213, 1, // 3601: decode to CV_SDOTUSP_SCI_B using decoder 213
14147 // 3601: }
14148 42, 8, // 3606: case 0x2a: {
14149 OPC_CheckPredicate, 129, 1, // 3608: check predicate 129
14150 OPC_Decode, 199, 112, 213, 1, // 3611: decode to CV_SDOTSP_SCI_B using decoder 213
14151 // 3611: }
14152 48, 8, // 3616: case 0x30: {
14153 OPC_CheckPredicate, 129, 1, // 3618: check predicate 129
14154 OPC_Decode, 217, 112, 202, 1, // 3621: decode to CV_SHUFFLEI0_SCI_B using decoder 202
14155 // 3621: }
14156 50, 8, // 3626: case 0x32: {
14157 OPC_CheckPredicate, 129, 1, // 3628: check predicate 129
14158 OPC_Decode, 218, 112, 202, 1, // 3631: decode to CV_SHUFFLEI1_SCI_B using decoder 202
14159 // 3631: }
14160 52, 8, // 3636: case 0x34: {
14161 OPC_CheckPredicate, 129, 1, // 3638: check predicate 129
14162 OPC_Decode, 219, 112, 202, 1, // 3641: decode to CV_SHUFFLEI2_SCI_B using decoder 202
14163 // 3641: }
14164 54, 0, // 3646: case 0x36: {
14165 OPC_CheckPredicate, 129, 1, // 3648: check predicate 129
14166 OPC_Decode, 220, 112, 202, 1, // 3651: decode to CV_SHUFFLEI3_SCI_B using decoder 202
14167 // 3651: }
14168 // 3651: } // switch Inst[31:26]
14169 // 3651: }
14170 // 3651: } // switch Inst[6:0]
14171 // 3651: }
14172 // 3651: } // switch Inst[14:12]
14173};
14174static const uint8_t DecoderTableXMIPS32[152] = {
14175 32, // 0: BitWidth 32
14176 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
14177 0, 16, // 4: case 0x0: {
14178 OPC_CheckPredicate, 134, 1, // 6: check predicate 134
14179 OPC_CheckField, 29, 3, 0, // 9: check Inst[31:29] == 0x0
14180 OPC_CheckField, 0, 7, 11, // 13: check Inst[6:0] == 0xb
14181 OPC_Decode, 235, 116, 215, 1, // 17: decode to MIPS_PREF using decoder 215
14182 // 17: }
14183 1, 43, // 22: case 0x1: {
14184 OPC_SwitchField, 15, 17, // 24: switch Inst[31:15] {
14185 32, 11, // 27: case 0x20: {
14186 OPC_CheckPredicate, 135, 1, // 29: check predicate 135
14187 OPC_CheckField, 0, 12, 19, // 32: check Inst[11:0] == 0x13
14188 OPC_Decode, 231, 116, 13, // 36: decode to MIPS_IHB using decoder 13
14189 // 36: }
14190 96, 11, // 40: case 0x60: {
14191 OPC_CheckPredicate, 135, 1, // 42: check predicate 135
14192 OPC_CheckField, 0, 12, 19, // 45: check Inst[11:0] == 0x13
14193 OPC_Decode, 230, 116, 13, // 49: decode to MIPS_EHB using decoder 13
14194 // 49: }
14195 160, 1, 0, // 53: case 0xa0: {
14196 OPC_CheckPredicate, 135, 1, // 56: check predicate 135
14197 OPC_CheckField, 0, 12, 19, // 59: check Inst[11:0] == 0x13
14198 OPC_Decode, 234, 116, 13, // 63: decode to MIPS_PAUSE using decoder 13
14199 // 63: }
14200 // 63: } // switch Inst[31:15]
14201 // 63: }
14202 3, 16, // 67: case 0x3: {
14203 OPC_CheckPredicate, 136, 1, // 69: check predicate 136
14204 OPC_CheckField, 25, 2, 3, // 72: check Inst[26:25] == 0x3
14205 OPC_CheckField, 0, 7, 11, // 76: check Inst[6:0] == 0xb
14206 OPC_Decode, 229, 116, 216, 1, // 80: decode to MIPS_CCMOV using decoder 216
14207 // 80: }
14208 4, 35, // 85: case 0x4: {
14209 OPC_SwitchField, 20, 2, // 87: switch Inst[21:20] {
14210 0, 16, // 90: case 0x0: {
14211 OPC_CheckPredicate, 137, 1, // 92: check predicate 137
14212 OPC_CheckField, 22, 1, 0, // 95: check Inst[22] == 0x0
14213 OPC_CheckField, 0, 7, 11, // 99: check Inst[6:0] == 0xb
14214 OPC_Decode, 232, 116, 217, 1, // 103: decode to MIPS_LDP using decoder 217
14215 // 103: }
14216 1, 0, // 108: case 0x1: {
14217 OPC_CheckPredicate, 137, 1, // 110: check predicate 137
14218 OPC_CheckField, 0, 7, 11, // 113: check Inst[6:0] == 0xb
14219 OPC_Decode, 233, 116, 218, 1, // 117: decode to MIPS_LWP using decoder 218
14220 // 117: }
14221 // 117: } // switch Inst[21:20]
14222 // 117: }
14223 5, 0, // 122: case 0x5: {
14224 OPC_SwitchField, 0, 9, // 124: switch Inst[8:0] {
14225 11, 12, // 127: case 0xb: {
14226 OPC_CheckPredicate, 137, 1, // 129: check predicate 137
14227 OPC_CheckField, 9, 1, 0, // 132: check Inst[9] == 0x0
14228 OPC_Decode, 236, 116, 219, 1, // 136: decode to MIPS_SDP using decoder 219
14229 // 136: }
14230 139, 1, 0, // 141: case 0x8b: {
14231 OPC_CheckPredicate, 137, 1, // 144: check predicate 137
14232 OPC_Decode, 237, 116, 220, 1, // 147: decode to MIPS_SWP using decoder 220
14233 // 147: }
14234 // 147: } // switch Inst[8:0]
14235 // 147: }
14236 // 147: } // switch Inst[14:12]
14237};
14238static const uint8_t DecoderTableXRivos32[106] = {
14239 32, // 0: BitWidth 32
14240 OPC_SwitchField, 26, 6, // 1: switch Inst[31:26] {
14241 4, 15, // 4: case 0x4: {
14242 OPC_CheckPredicate, 138, 1, // 6: check predicate 138
14243 OPC_CheckField, 12, 3, 0, // 9: check Inst[14:12] == 0x0
14244 OPC_CheckField, 0, 7, 91, // 13: check Inst[6:0] == 0x5b
14245 OPC_Decode, 137, 123, 111, // 17: decode to RI_VZIP2A_VV using decoder 111
14246 // 17: }
14247 8, 15, // 21: case 0x8: {
14248 OPC_CheckPredicate, 138, 1, // 23: check predicate 138
14249 OPC_CheckField, 12, 3, 0, // 26: check Inst[14:12] == 0x0
14250 OPC_CheckField, 0, 7, 91, // 30: check Inst[6:0] == 0x5b
14251 OPC_Decode, 135, 123, 111, // 34: decode to RI_VUNZIP2A_VV using decoder 111
14252 // 34: }
14253 12, 15, // 38: case 0xc: {
14254 OPC_CheckPredicate, 138, 1, // 40: check predicate 138
14255 OPC_CheckField, 12, 3, 0, // 43: check Inst[14:12] == 0x0
14256 OPC_CheckField, 0, 7, 91, // 47: check Inst[6:0] == 0x5b
14257 OPC_Decode, 139, 123, 111, // 51: decode to RI_VZIPEVEN_VV using decoder 111
14258 // 51: }
14259 20, 15, // 55: case 0x14: {
14260 OPC_CheckPredicate, 138, 1, // 57: check predicate 138
14261 OPC_CheckField, 12, 3, 0, // 60: check Inst[14:12] == 0x0
14262 OPC_CheckField, 0, 7, 91, // 64: check Inst[6:0] == 0x5b
14263 OPC_Decode, 138, 123, 111, // 68: decode to RI_VZIP2B_VV using decoder 111
14264 // 68: }
14265 24, 15, // 72: case 0x18: {
14266 OPC_CheckPredicate, 138, 1, // 74: check predicate 138
14267 OPC_CheckField, 12, 3, 0, // 77: check Inst[14:12] == 0x0
14268 OPC_CheckField, 0, 7, 91, // 81: check Inst[6:0] == 0x5b
14269 OPC_Decode, 136, 123, 111, // 85: decode to RI_VUNZIP2B_VV using decoder 111
14270 // 85: }
14271 28, 0, // 89: case 0x1c: {
14272 OPC_CheckPredicate, 138, 1, // 91: check predicate 138
14273 OPC_CheckField, 12, 3, 0, // 94: check Inst[14:12] == 0x0
14274 OPC_CheckField, 0, 7, 91, // 98: check Inst[6:0] == 0x5b
14275 OPC_Decode, 140, 123, 111, // 102: decode to RI_VZIPODD_VV using decoder 111
14276 // 102: }
14277 // 102: } // switch Inst[31:26]
14278};
14279static const uint8_t DecoderTableXSMT32[300] = {
14280 32, // 0: BitWidth 32
14281 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
14282 0, 50, // 4: case 0x0: {
14283 OPC_SwitchField, 25, 7, // 6: switch Inst[31:25] {
14284 113, 12, // 9: case 0x71: {
14285 OPC_CheckPredicate, 139, 1, // 11: check predicate 139
14286 OPC_CheckField, 0, 7, 43, // 14: check Inst[6:0] == 0x2b
14287 OPC_Decode, 169, 124, 221, 1, // 18: decode to SMT_VMADOTU using decoder 221
14288 // 18: }
14289 115, 0, // 23: case 0x73: {
14290 OPC_SwitchField, 15, 1, // 25: switch Inst[15] {
14291 0, 12, // 28: case 0x0: {
14292 OPC_CheckPredicate, 139, 1, // 30: check predicate 139
14293 OPC_CheckField, 0, 7, 43, // 33: check Inst[6:0] == 0x2b
14294 OPC_Decode, 158, 124, 222, 1, // 37: decode to SMT_VMADOT1U using decoder 222
14295 // 37: }
14296 1, 0, // 42: case 0x1: {
14297 OPC_CheckPredicate, 139, 1, // 44: check predicate 139
14298 OPC_CheckField, 0, 7, 43, // 47: check Inst[6:0] == 0x2b
14299 OPC_Decode, 166, 124, 222, 1, // 51: decode to SMT_VMADOT3U using decoder 222
14300 // 51: }
14301 // 51: } // switch Inst[15]
14302 // 51: }
14303 // 51: } // switch Inst[31:25]
14304 // 51: }
14305 1, 50, // 56: case 0x1: {
14306 OPC_SwitchField, 25, 7, // 58: switch Inst[31:25] {
14307 113, 12, // 61: case 0x71: {
14308 OPC_CheckPredicate, 139, 1, // 63: check predicate 139
14309 OPC_CheckField, 0, 7, 43, // 66: check Inst[6:0] == 0x2b
14310 OPC_Decode, 170, 124, 221, 1, // 70: decode to SMT_VMADOTUS using decoder 221
14311 // 70: }
14312 115, 0, // 75: case 0x73: {
14313 OPC_SwitchField, 15, 1, // 77: switch Inst[15] {
14314 0, 12, // 80: case 0x0: {
14315 OPC_CheckPredicate, 139, 1, // 82: check predicate 139
14316 OPC_CheckField, 0, 7, 43, // 85: check Inst[6:0] == 0x2b
14317 OPC_Decode, 159, 124, 222, 1, // 89: decode to SMT_VMADOT1US using decoder 222
14318 // 89: }
14319 1, 0, // 94: case 0x1: {
14320 OPC_CheckPredicate, 139, 1, // 96: check predicate 139
14321 OPC_CheckField, 0, 7, 43, // 99: check Inst[6:0] == 0x2b
14322 OPC_Decode, 167, 124, 222, 1, // 103: decode to SMT_VMADOT3US using decoder 222
14323 // 103: }
14324 // 103: } // switch Inst[15]
14325 // 103: }
14326 // 103: } // switch Inst[31:25]
14327 // 103: }
14328 2, 50, // 108: case 0x2: {
14329 OPC_SwitchField, 25, 7, // 110: switch Inst[31:25] {
14330 113, 12, // 113: case 0x71: {
14331 OPC_CheckPredicate, 139, 1, // 115: check predicate 139
14332 OPC_CheckField, 0, 7, 43, // 118: check Inst[6:0] == 0x2b
14333 OPC_Decode, 168, 124, 221, 1, // 122: decode to SMT_VMADOTSU using decoder 221
14334 // 122: }
14335 115, 0, // 127: case 0x73: {
14336 OPC_SwitchField, 15, 1, // 129: switch Inst[15] {
14337 0, 12, // 132: case 0x0: {
14338 OPC_CheckPredicate, 139, 1, // 134: check predicate 139
14339 OPC_CheckField, 0, 7, 43, // 137: check Inst[6:0] == 0x2b
14340 OPC_Decode, 157, 124, 222, 1, // 141: decode to SMT_VMADOT1SU using decoder 222
14341 // 141: }
14342 1, 0, // 146: case 0x1: {
14343 OPC_CheckPredicate, 139, 1, // 148: check predicate 139
14344 OPC_CheckField, 0, 7, 43, // 151: check Inst[6:0] == 0x2b
14345 OPC_Decode, 165, 124, 222, 1, // 155: decode to SMT_VMADOT3SU using decoder 222
14346 // 155: }
14347 // 155: } // switch Inst[15]
14348 // 155: }
14349 // 155: } // switch Inst[31:25]
14350 // 155: }
14351 3, 50, // 160: case 0x3: {
14352 OPC_SwitchField, 25, 7, // 162: switch Inst[31:25] {
14353 113, 12, // 165: case 0x71: {
14354 OPC_CheckPredicate, 139, 1, // 167: check predicate 139
14355 OPC_CheckField, 0, 7, 43, // 170: check Inst[6:0] == 0x2b
14356 OPC_Decode, 155, 124, 221, 1, // 174: decode to SMT_VMADOT using decoder 221
14357 // 174: }
14358 115, 0, // 179: case 0x73: {
14359 OPC_SwitchField, 15, 1, // 181: switch Inst[15] {
14360 0, 12, // 184: case 0x0: {
14361 OPC_CheckPredicate, 139, 1, // 186: check predicate 139
14362 OPC_CheckField, 0, 7, 43, // 189: check Inst[6:0] == 0x2b
14363 OPC_Decode, 156, 124, 222, 1, // 193: decode to SMT_VMADOT1 using decoder 222
14364 // 193: }
14365 1, 0, // 198: case 0x1: {
14366 OPC_CheckPredicate, 139, 1, // 200: check predicate 139
14367 OPC_CheckField, 0, 7, 43, // 203: check Inst[6:0] == 0x2b
14368 OPC_Decode, 164, 124, 222, 1, // 207: decode to SMT_VMADOT3 using decoder 222
14369 // 207: }
14370 // 207: } // switch Inst[15]
14371 // 207: }
14372 // 207: } // switch Inst[31:25]
14373 // 207: }
14374 4, 20, // 212: case 0x4: {
14375 OPC_CheckPredicate, 139, 1, // 214: check predicate 139
14376 OPC_CheckField, 25, 7, 115, // 217: check Inst[31:25] == 0x73
14377 OPC_CheckField, 15, 1, 0, // 221: check Inst[15] == 0x0
14378 OPC_CheckField, 0, 7, 43, // 225: check Inst[6:0] == 0x2b
14379 OPC_Decode, 162, 124, 222, 1, // 229: decode to SMT_VMADOT2U using decoder 222
14380 // 229: }
14381 5, 20, // 234: case 0x5: {
14382 OPC_CheckPredicate, 139, 1, // 236: check predicate 139
14383 OPC_CheckField, 25, 7, 115, // 239: check Inst[31:25] == 0x73
14384 OPC_CheckField, 15, 1, 0, // 243: check Inst[15] == 0x0
14385 OPC_CheckField, 0, 7, 43, // 247: check Inst[6:0] == 0x2b
14386 OPC_Decode, 163, 124, 222, 1, // 251: decode to SMT_VMADOT2US using decoder 222
14387 // 251: }
14388 6, 20, // 256: case 0x6: {
14389 OPC_CheckPredicate, 139, 1, // 258: check predicate 139
14390 OPC_CheckField, 25, 7, 115, // 261: check Inst[31:25] == 0x73
14391 OPC_CheckField, 15, 1, 0, // 265: check Inst[15] == 0x0
14392 OPC_CheckField, 0, 7, 43, // 269: check Inst[6:0] == 0x2b
14393 OPC_Decode, 161, 124, 222, 1, // 273: decode to SMT_VMADOT2SU using decoder 222
14394 // 273: }
14395 7, 0, // 278: case 0x7: {
14396 OPC_CheckPredicate, 139, 1, // 280: check predicate 139
14397 OPC_CheckField, 25, 7, 115, // 283: check Inst[31:25] == 0x73
14398 OPC_CheckField, 15, 1, 0, // 287: check Inst[15] == 0x0
14399 OPC_CheckField, 0, 7, 43, // 291: check Inst[6:0] == 0x2b
14400 OPC_Decode, 160, 124, 222, 1, // 295: decode to SMT_VMADOT2 using decoder 222
14401 // 295: }
14402 // 295: } // switch Inst[14:12]
14403};
14404static const uint8_t DecoderTableXSfcease32[16] = {
14405 32, // 0: BitWidth 32
14406 OPC_CheckPredicate, 140, 1, // 1: check predicate 140
14407 OPC_CheckField, 0, 32, 243, 128, 192, 130, 3,
14408 // 4: check Inst[31:0] == 0x30500073
14409 OPC_Decode, 173, 123, 13, // 12: decode to SF_CEASE using decoder 13
14410};
14411static const uint8_t DecoderTableXSfsystem32[32] = {
14412 32, // 0: BitWidth 32
14413 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
14414 192, 31, 11, // 4: case 0xfc0: {
14415 OPC_CheckPredicate, 141, 1, // 7: check predicate 141
14416 OPC_CheckField, 0, 15, 115, // 10: check Inst[14:0] == 0x73
14417 OPC_Decode, 174, 123, 14, // 14: decode to SF_CFLUSH_D_L1 using decoder 14
14418 // 14: }
14419 194, 31, 0, // 18: case 0xfc2: {
14420 OPC_CheckPredicate, 142, 1, // 21: check predicate 142
14421 OPC_CheckField, 0, 15, 115, // 24: check Inst[14:0] == 0x73
14422 OPC_Decode, 172, 123, 14, // 28: decode to SF_CDISCARD_D_L1 using decoder 14
14423 // 28: }
14424 // 28: } // switch Inst[31:20]
14425};
14426static const uint8_t DecoderTableXSfvector32[1138] = {
14427 32, // 0: BitWidth 32
14428 OPC_SwitchField, 28, 4, // 1: switch Inst[31:28] {
14429 0, 69, // 4: case 0x0: {
14430 OPC_SwitchField, 12, 3, // 6: switch Inst[14:12] {
14431 3, 31, // 9: case 0x3: {
14432 OPC_SwitchField, 25, 1, // 11: switch Inst[25] {
14433 0, 12, // 14: case 0x0: {
14434 OPC_CheckPredicate, 143, 1, // 16: check predicate 143
14435 OPC_CheckField, 0, 7, 91, // 19: check Inst[6:0] == 0x5b
14436 OPC_Decode, 197, 123, 223, 1, // 23: decode to SF_VC_V_I using decoder 223
14437 // 23: }
14438 1, 0, // 28: case 0x1: {
14439 OPC_CheckPredicate, 143, 1, // 30: check predicate 143
14440 OPC_CheckField, 0, 7, 91, // 33: check Inst[6:0] == 0x5b
14441 OPC_Decode, 187, 123, 224, 1, // 37: decode to SF_VC_I using decoder 224
14442 // 37: }
14443 // 37: } // switch Inst[25]
14444 // 37: }
14445 4, 0, // 42: case 0x4: {
14446 OPC_SwitchField, 25, 1, // 44: switch Inst[25] {
14447 0, 12, // 47: case 0x0: {
14448 OPC_CheckPredicate, 143, 1, // 49: check predicate 143
14449 OPC_CheckField, 0, 7, 91, // 52: check Inst[6:0] == 0x5b
14450 OPC_Decode, 204, 123, 225, 1, // 56: decode to SF_VC_V_X using decoder 225
14451 // 56: }
14452 1, 0, // 61: case 0x1: {
14453 OPC_CheckPredicate, 143, 1, // 63: check predicate 143
14454 OPC_CheckField, 0, 7, 91, // 66: check Inst[6:0] == 0x5b
14455 OPC_Decode, 208, 123, 226, 1, // 70: decode to SF_VC_X using decoder 226
14456 // 70: }
14457 // 70: } // switch Inst[25]
14458 // 70: }
14459 // 70: } // switch Inst[14:12]
14460 // 70: }
14461 1, 33, // 75: case 0x1: {
14462 OPC_SwitchField, 0, 15, // 77: switch Inst[14:0] {
14463 135, 224, 1, 11, // 80: case 0x7007: {
14464 OPC_CheckPredicate, 144, 1, // 84: check predicate 144
14465 OPC_CheckField, 25, 3, 1, // 87: check Inst[27:25] == 0x1
14466 OPC_Decode, 220, 123, 56, // 91: decode to SF_VLTE8 using decoder 56
14467 // 91: }
14468 167, 224, 1, 0, // 95: case 0x7027: {
14469 OPC_CheckPredicate, 144, 1, // 99: check predicate 144
14470 OPC_CheckField, 25, 3, 1, // 102: check Inst[27:25] == 0x1
14471 OPC_Decode, 235, 123, 56, // 106: decode to SF_VSTE8 using decoder 56
14472 // 106: }
14473 // 106: } // switch Inst[14:0]
14474 // 106: }
14475 2, 143, 1, // 110: case 0x2: {
14476 OPC_SwitchField, 12, 3, // 113: switch Inst[14:12] {
14477 0, 31, // 116: case 0x0: {
14478 OPC_SwitchField, 25, 1, // 118: switch Inst[25] {
14479 0, 12, // 121: case 0x0: {
14480 OPC_CheckPredicate, 143, 1, // 123: check predicate 143
14481 OPC_CheckField, 0, 7, 91, // 126: check Inst[6:0] == 0x5b
14482 OPC_Decode, 201, 123, 227, 1, // 130: decode to SF_VC_V_VV using decoder 227
14483 // 130: }
14484 1, 0, // 135: case 0x1: {
14485 OPC_CheckPredicate, 143, 1, // 137: check predicate 143
14486 OPC_CheckField, 0, 7, 91, // 140: check Inst[6:0] == 0x5b
14487 OPC_Decode, 191, 123, 228, 1, // 144: decode to SF_VC_VV using decoder 228
14488 // 144: }
14489 // 144: } // switch Inst[25]
14490 // 144: }
14491 3, 31, // 149: case 0x3: {
14492 OPC_SwitchField, 25, 1, // 151: switch Inst[25] {
14493 0, 12, // 154: case 0x0: {
14494 OPC_CheckPredicate, 143, 1, // 156: check predicate 143
14495 OPC_CheckField, 0, 7, 91, // 159: check Inst[6:0] == 0x5b
14496 OPC_Decode, 198, 123, 229, 1, // 163: decode to SF_VC_V_IV using decoder 229
14497 // 163: }
14498 1, 0, // 168: case 0x1: {
14499 OPC_CheckPredicate, 143, 1, // 170: check predicate 143
14500 OPC_CheckField, 0, 7, 91, // 173: check Inst[6:0] == 0x5b
14501 OPC_Decode, 188, 123, 230, 1, // 177: decode to SF_VC_IV using decoder 230
14502 // 177: }
14503 // 177: } // switch Inst[25]
14504 // 177: }
14505 4, 31, // 182: case 0x4: {
14506 OPC_SwitchField, 25, 1, // 184: switch Inst[25] {
14507 0, 12, // 187: case 0x0: {
14508 OPC_CheckPredicate, 143, 1, // 189: check predicate 143
14509 OPC_CheckField, 0, 7, 91, // 192: check Inst[6:0] == 0x5b
14510 OPC_Decode, 205, 123, 231, 1, // 196: decode to SF_VC_V_XV using decoder 231
14511 // 196: }
14512 1, 0, // 201: case 0x1: {
14513 OPC_CheckPredicate, 143, 1, // 203: check predicate 143
14514 OPC_CheckField, 0, 7, 91, // 206: check Inst[6:0] == 0x5b
14515 OPC_Decode, 209, 123, 232, 1, // 210: decode to SF_VC_XV using decoder 232
14516 // 210: }
14517 // 210: } // switch Inst[25]
14518 // 210: }
14519 5, 0, // 215: case 0x5: {
14520 OPC_SwitchField, 25, 1, // 217: switch Inst[25] {
14521 0, 16, // 220: case 0x0: {
14522 OPC_CheckPredicate, 143, 1, // 222: check predicate 143
14523 OPC_CheckField, 27, 1, 1, // 225: check Inst[27] == 0x1
14524 OPC_CheckField, 0, 7, 91, // 229: check Inst[6:0] == 0x5b
14525 OPC_Decode, 194, 123, 233, 1, // 233: decode to SF_VC_V_FV using decoder 233
14526 // 233: }
14527 1, 0, // 238: case 0x1: {
14528 OPC_CheckPredicate, 143, 1, // 240: check predicate 143
14529 OPC_CheckField, 27, 1, 1, // 243: check Inst[27] == 0x1
14530 OPC_CheckField, 0, 7, 91, // 247: check Inst[6:0] == 0x5b
14531 OPC_Decode, 184, 123, 234, 1, // 251: decode to SF_VC_FV using decoder 234
14532 // 251: }
14533 // 251: } // switch Inst[25]
14534 // 251: }
14535 // 251: } // switch Inst[14:12]
14536 // 251: }
14537 3, 33, // 256: case 0x3: {
14538 OPC_SwitchField, 0, 15, // 258: switch Inst[14:0] {
14539 135, 224, 1, 11, // 261: case 0x7007: {
14540 OPC_CheckPredicate, 144, 1, // 265: check predicate 144
14541 OPC_CheckField, 25, 3, 1, // 268: check Inst[27:25] == 0x1
14542 OPC_Decode, 217, 123, 56, // 272: decode to SF_VLTE16 using decoder 56
14543 // 272: }
14544 167, 224, 1, 0, // 276: case 0x7027: {
14545 OPC_CheckPredicate, 144, 1, // 280: check predicate 144
14546 OPC_CheckField, 25, 3, 1, // 283: check Inst[27:25] == 0x1
14547 OPC_Decode, 232, 123, 56, // 287: decode to SF_VSTE16 using decoder 56
14548 // 287: }
14549 // 287: } // switch Inst[14:0]
14550 // 287: }
14551 4, 95, // 291: case 0x4: {
14552 OPC_SwitchField, 12, 3, // 293: switch Inst[14:12] {
14553 1, 37, // 296: case 0x1: {
14554 OPC_SwitchField, 15, 5, // 298: switch Inst[19:15] {
14555 6, 15, // 301: case 0x6: {
14556 OPC_CheckPredicate, 145, 1, // 303: check predicate 145
14557 OPC_CheckField, 26, 2, 3, // 306: check Inst[27:26] == 0x3
14558 OPC_CheckField, 0, 7, 87, // 310: check Inst[6:0] == 0x57
14559 OPC_Decode, 212, 123, 116, // 314: decode to SF_VFEXPA_V using decoder 116
14560 // 314: }
14561 7, 0, // 318: case 0x7: {
14562 OPC_CheckPredicate, 146, 1, // 320: check predicate 146
14563 OPC_CheckField, 26, 2, 3, // 323: check Inst[27:26] == 0x3
14564 OPC_CheckField, 0, 7, 87, // 327: check Inst[6:0] == 0x57
14565 OPC_Decode, 213, 123, 116, // 331: decode to SF_VFEXP_V using decoder 116
14566 // 331: }
14567 // 331: } // switch Inst[19:15]
14568 // 331: }
14569 6, 0, // 335: case 0x6: {
14570 OPC_SwitchField, 20, 8, // 337: switch Inst[27:20] {
14571 60, 15, // 340: case 0x3c: {
14572 OPC_CheckPredicate, 144, 1, // 342: check predicate 144
14573 OPC_CheckField, 15, 5, 0, // 345: check Inst[19:15] == 0x0
14574 OPC_CheckField, 0, 12, 87, // 349: check Inst[11:0] == 0x57
14575 OPC_Decode, 236, 123, 13, // 353: decode to SF_VTDISCARD using decoder 13
14576 // 353: }
14577 62, 16, // 357: case 0x3e: {
14578 OPC_CheckPredicate, 144, 1, // 359: check predicate 144
14579 OPC_CheckField, 15, 5, 0, // 362: check Inst[19:15] == 0x0
14580 OPC_CheckField, 0, 8, 87, // 366: check Inst[7:0] == 0x57
14581 OPC_Decode, 239, 123, 235, 1, // 370: decode to SF_VTZERO_T using decoder 235
14582 // 370: }
14583 63, 0, // 375: case 0x3f: {
14584 OPC_CheckPredicate, 144, 1, // 377: check predicate 144
14585 OPC_CheckField, 0, 7, 87, // 380: check Inst[6:0] == 0x57
14586 OPC_Decode, 238, 123, 2, // 384: decode to SF_VTMV_V_T using decoder 2
14587 // 384: }
14588 // 384: } // switch Inst[27:20]
14589 // 384: }
14590 // 384: } // switch Inst[14:12]
14591 // 384: }
14592 5, 49, // 388: case 0x5: {
14593 OPC_SwitchField, 0, 15, // 390: switch Inst[14:0] {
14594 215, 192, 1, 12, // 393: case 0x6057: {
14595 OPC_CheckPredicate, 144, 1, // 397: check predicate 144
14596 OPC_CheckField, 25, 3, 7, // 400: check Inst[27:25] == 0x7
14597 OPC_Decode, 237, 123, 236, 1, // 404: decode to SF_VTMV_T_V using decoder 236
14598 // 404: }
14599 135, 224, 1, 11, // 409: case 0x7007: {
14600 OPC_CheckPredicate, 144, 1, // 413: check predicate 144
14601 OPC_CheckField, 25, 3, 1, // 416: check Inst[27:25] == 0x1
14602 OPC_Decode, 218, 123, 56, // 420: decode to SF_VLTE32 using decoder 56
14603 // 420: }
14604 167, 224, 1, 0, // 424: case 0x7027: {
14605 OPC_CheckPredicate, 144, 1, // 428: check predicate 144
14606 OPC_CheckField, 25, 3, 1, // 431: check Inst[27:25] == 0x1
14607 OPC_Decode, 233, 123, 56, // 435: decode to SF_VSTE32 using decoder 56
14608 // 435: }
14609 // 435: } // switch Inst[14:0]
14610 // 435: }
14611 7, 33, // 439: case 0x7: {
14612 OPC_SwitchField, 0, 15, // 441: switch Inst[14:0] {
14613 135, 224, 1, 11, // 444: case 0x7007: {
14614 OPC_CheckPredicate, 144, 1, // 448: check predicate 144
14615 OPC_CheckField, 25, 3, 1, // 451: check Inst[27:25] == 0x1
14616 OPC_Decode, 219, 123, 56, // 455: decode to SF_VLTE64 using decoder 56
14617 // 455: }
14618 167, 224, 1, 0, // 459: case 0x7027: {
14619 OPC_CheckPredicate, 144, 1, // 463: check predicate 144
14620 OPC_CheckField, 25, 3, 1, // 466: check Inst[27:25] == 0x1
14621 OPC_Decode, 234, 123, 56, // 470: decode to SF_VSTE64 using decoder 56
14622 // 470: }
14623 // 470: } // switch Inst[14:0]
14624 // 470: }
14625 8, 95, // 474: case 0x8: {
14626 OPC_SwitchField, 26, 2, // 476: switch Inst[27:26] {
14627 1, 54, // 479: case 0x1: {
14628 OPC_SwitchField, 20, 6, // 481: switch Inst[25:20] {
14629 0, 15, // 484: case 0x0: {
14630 OPC_CheckPredicate, 144, 1, // 486: check predicate 144
14631 OPC_CheckField, 12, 3, 7, // 489: check Inst[14:12] == 0x7
14632 OPC_CheckField, 0, 7, 87, // 493: check Inst[6:0] == 0x57
14633 OPC_Decode, 231, 123, 16, // 497: decode to SF_VSETTN using decoder 16
14634 // 497: }
14635 1, 15, // 501: case 0x1: {
14636 OPC_CheckPredicate, 144, 1, // 503: check predicate 144
14637 OPC_CheckField, 12, 3, 7, // 506: check Inst[14:12] == 0x7
14638 OPC_CheckField, 0, 7, 87, // 510: check Inst[6:0] == 0x57
14639 OPC_Decode, 230, 123, 16, // 514: decode to SF_VSETTM using decoder 16
14640 // 514: }
14641 2, 0, // 518: case 0x2: {
14642 OPC_CheckPredicate, 144, 1, // 520: check predicate 144
14643 OPC_CheckField, 12, 3, 7, // 523: check Inst[14:12] == 0x7
14644 OPC_CheckField, 0, 7, 87, // 527: check Inst[6:0] == 0x57
14645 OPC_Decode, 229, 123, 16, // 531: decode to SF_VSETTK using decoder 16
14646 // 531: }
14647 // 531: } // switch Inst[25:20]
14648 // 531: }
14649 2, 16, // 535: case 0x2: {
14650 OPC_CheckPredicate, 147, 1, // 537: check predicate 147
14651 OPC_CheckField, 12, 3, 5, // 540: check Inst[14:12] == 0x5
14652 OPC_CheckField, 0, 7, 91, // 544: check Inst[6:0] == 0x5b
14653 OPC_Decode, 214, 123, 135, 1, // 548: decode to SF_VFNRCLIP_XU_F_QF using decoder 135
14654 // 548: }
14655 3, 0, // 553: case 0x3: {
14656 OPC_CheckPredicate, 147, 1, // 555: check predicate 147
14657 OPC_CheckField, 12, 3, 5, // 558: check Inst[14:12] == 0x5
14658 OPC_CheckField, 0, 7, 91, // 562: check Inst[6:0] == 0x5b
14659 OPC_Decode, 215, 123, 135, 1, // 566: decode to SF_VFNRCLIP_X_F_QF using decoder 135
14660 // 566: }
14661 // 566: } // switch Inst[27:26]
14662 // 566: }
14663 10, 143, 1, // 571: case 0xa: {
14664 OPC_SwitchField, 12, 3, // 574: switch Inst[14:12] {
14665 0, 31, // 577: case 0x0: {
14666 OPC_SwitchField, 25, 1, // 579: switch Inst[25] {
14667 0, 12, // 582: case 0x0: {
14668 OPC_CheckPredicate, 143, 1, // 584: check predicate 143
14669 OPC_CheckField, 0, 7, 91, // 587: check Inst[6:0] == 0x5b
14670 OPC_Decode, 202, 123, 237, 1, // 591: decode to SF_VC_V_VVV using decoder 237
14671 // 591: }
14672 1, 0, // 596: case 0x1: {
14673 OPC_CheckPredicate, 143, 1, // 598: check predicate 143
14674 OPC_CheckField, 0, 7, 91, // 601: check Inst[6:0] == 0x5b
14675 OPC_Decode, 192, 123, 238, 1, // 605: decode to SF_VC_VVV using decoder 238
14676 // 605: }
14677 // 605: } // switch Inst[25]
14678 // 605: }
14679 3, 31, // 610: case 0x3: {
14680 OPC_SwitchField, 25, 1, // 612: switch Inst[25] {
14681 0, 12, // 615: case 0x0: {
14682 OPC_CheckPredicate, 143, 1, // 617: check predicate 143
14683 OPC_CheckField, 0, 7, 91, // 620: check Inst[6:0] == 0x5b
14684 OPC_Decode, 199, 123, 239, 1, // 624: decode to SF_VC_V_IVV using decoder 239
14685 // 624: }
14686 1, 0, // 629: case 0x1: {
14687 OPC_CheckPredicate, 143, 1, // 631: check predicate 143
14688 OPC_CheckField, 0, 7, 91, // 634: check Inst[6:0] == 0x5b
14689 OPC_Decode, 189, 123, 240, 1, // 638: decode to SF_VC_IVV using decoder 240
14690 // 638: }
14691 // 638: } // switch Inst[25]
14692 // 638: }
14693 4, 31, // 643: case 0x4: {
14694 OPC_SwitchField, 25, 1, // 645: switch Inst[25] {
14695 0, 12, // 648: case 0x0: {
14696 OPC_CheckPredicate, 143, 1, // 650: check predicate 143
14697 OPC_CheckField, 0, 7, 91, // 653: check Inst[6:0] == 0x5b
14698 OPC_Decode, 206, 123, 241, 1, // 657: decode to SF_VC_V_XVV using decoder 241
14699 // 657: }
14700 1, 0, // 662: case 0x1: {
14701 OPC_CheckPredicate, 143, 1, // 664: check predicate 143
14702 OPC_CheckField, 0, 7, 91, // 667: check Inst[6:0] == 0x5b
14703 OPC_Decode, 210, 123, 242, 1, // 671: decode to SF_VC_XVV using decoder 242
14704 // 671: }
14705 // 671: } // switch Inst[25]
14706 // 671: }
14707 5, 0, // 676: case 0x5: {
14708 OPC_SwitchField, 25, 1, // 678: switch Inst[25] {
14709 0, 16, // 681: case 0x0: {
14710 OPC_CheckPredicate, 143, 1, // 683: check predicate 143
14711 OPC_CheckField, 27, 1, 1, // 686: check Inst[27] == 0x1
14712 OPC_CheckField, 0, 7, 91, // 690: check Inst[6:0] == 0x5b
14713 OPC_Decode, 195, 123, 243, 1, // 694: decode to SF_VC_V_FVV using decoder 243
14714 // 694: }
14715 1, 0, // 699: case 0x1: {
14716 OPC_CheckPredicate, 143, 1, // 701: check predicate 143
14717 OPC_CheckField, 27, 1, 1, // 704: check Inst[27] == 0x1
14718 OPC_CheckField, 0, 7, 91, // 708: check Inst[6:0] == 0x5b
14719 OPC_Decode, 185, 123, 244, 1, // 712: decode to SF_VC_FVV using decoder 244
14720 // 712: }
14721 // 712: } // switch Inst[25]
14722 // 712: }
14723 // 712: } // switch Inst[14:12]
14724 // 712: }
14725 11, 75, // 717: case 0xb: {
14726 OPC_SwitchField, 25, 3, // 719: switch Inst[27:25] {
14727 1, 16, // 722: case 0x1: {
14728 OPC_CheckPredicate, 148, 1, // 724: check predicate 148
14729 OPC_CheckField, 12, 3, 2, // 727: check Inst[14:12] == 0x2
14730 OPC_CheckField, 0, 7, 91, // 731: check Inst[6:0] == 0x5b
14731 OPC_Decode, 225, 123, 245, 1, // 735: decode to SF_VQMACCU_2x8x2 using decoder 245
14732 // 735: }
14733 3, 16, // 740: case 0x3: {
14734 OPC_CheckPredicate, 148, 1, // 742: check predicate 148
14735 OPC_CheckField, 12, 3, 2, // 745: check Inst[14:12] == 0x2
14736 OPC_CheckField, 0, 7, 91, // 749: check Inst[6:0] == 0x5b
14737 OPC_Decode, 227, 123, 245, 1, // 753: decode to SF_VQMACC_2x8x2 using decoder 245
14738 // 753: }
14739 5, 16, // 758: case 0x5: {
14740 OPC_CheckPredicate, 148, 1, // 760: check predicate 148
14741 OPC_CheckField, 12, 3, 2, // 763: check Inst[14:12] == 0x2
14742 OPC_CheckField, 0, 7, 91, // 767: check Inst[6:0] == 0x5b
14743 OPC_Decode, 223, 123, 245, 1, // 771: decode to SF_VQMACCUS_2x8x2 using decoder 245
14744 // 771: }
14745 7, 0, // 776: case 0x7: {
14746 OPC_CheckPredicate, 148, 1, // 778: check predicate 148
14747 OPC_CheckField, 12, 3, 2, // 781: check Inst[14:12] == 0x2
14748 OPC_CheckField, 0, 7, 91, // 785: check Inst[6:0] == 0x5b
14749 OPC_Decode, 221, 123, 245, 1, // 789: decode to SF_VQMACCSU_2x8x2 using decoder 245
14750 // 789: }
14751 // 789: } // switch Inst[27:25]
14752 // 789: }
14753 15, 0, // 794: case 0xf: {
14754 OPC_SwitchField, 12, 3, // 796: switch Inst[14:12] {
14755 0, 83, // 799: case 0x0: {
14756 OPC_SwitchField, 0, 7, // 801: switch Inst[6:0] {
14757 91, 23, // 804: case 0x5b: {
14758 OPC_SwitchField, 25, 1, // 806: switch Inst[25] {
14759 0, 8, // 809: case 0x0: {
14760 OPC_CheckPredicate, 143, 1, // 811: check predicate 143
14761 OPC_Decode, 203, 123, 237, 1, // 814: decode to SF_VC_V_VVW using decoder 237
14762 // 814: }
14763 1, 0, // 819: case 0x1: {
14764 OPC_CheckPredicate, 143, 1, // 821: check predicate 143
14765 OPC_Decode, 193, 123, 238, 1, // 824: decode to SF_VC_VVW using decoder 238
14766 // 824: }
14767 // 824: } // switch Inst[25]
14768 // 824: }
14769 119, 0, // 829: case 0x77: {
14770 OPC_SwitchField, 7, 3, // 831: switch Inst[9:7] {
14771 0, 23, // 834: case 0x0: {
14772 OPC_SwitchField, 25, 3, // 836: switch Inst[27:25] {
14773 1, 8, // 839: case 0x1: {
14774 OPC_CheckPredicate, 149, 1, // 841: check predicate 149
14775 OPC_Decode, 183, 123, 246, 1, // 844: decode to SF_MM_U_U using decoder 246
14776 // 844: }
14777 3, 0, // 849: case 0x3: {
14778 OPC_CheckPredicate, 149, 1, // 851: check predicate 149
14779 OPC_Decode, 181, 123, 246, 1, // 854: decode to SF_MM_S_U using decoder 246
14780 // 854: }
14781 // 854: } // switch Inst[27:25]
14782 // 854: }
14783 1, 0, // 859: case 0x1: {
14784 OPC_SwitchField, 25, 3, // 861: switch Inst[27:25] {
14785 1, 8, // 864: case 0x1: {
14786 OPC_CheckPredicate, 149, 1, // 866: check predicate 149
14787 OPC_Decode, 182, 123, 246, 1, // 869: decode to SF_MM_U_S using decoder 246
14788 // 869: }
14789 3, 0, // 874: case 0x3: {
14790 OPC_CheckPredicate, 149, 1, // 876: check predicate 149
14791 OPC_Decode, 180, 123, 246, 1, // 879: decode to SF_MM_S_S using decoder 246
14792 // 879: }
14793 // 879: } // switch Inst[27:25]
14794 // 879: }
14795 // 879: } // switch Inst[9:7]
14796 // 879: }
14797 // 879: } // switch Inst[6:0]
14798 // 879: }
14799 1, 84, // 884: case 0x1: {
14800 OPC_SwitchField, 25, 3, // 886: switch Inst[27:25] {
14801 1, 27, // 889: case 0x1: {
14802 OPC_SwitchField, 0, 7, // 891: switch Inst[6:0] {
14803 91, 8, // 894: case 0x5b: {
14804 OPC_CheckPredicate, 150, 1, // 896: check predicate 150
14805 OPC_Decode, 216, 123, 245, 1, // 899: decode to SF_VFWMACC_4x4x4 using decoder 245
14806 // 899: }
14807 119, 0, // 904: case 0x77: {
14808 OPC_CheckPredicate, 151, 1, // 906: check predicate 151
14809 OPC_CheckField, 7, 2, 0, // 909: check Inst[8:7] == 0x0
14810 OPC_Decode, 179, 123, 247, 1, // 913: decode to SF_MM_F_F using decoder 247
14811 // 913: }
14812 // 913: } // switch Inst[6:0]
14813 // 913: }
14814 5, 24, // 918: case 0x5: {
14815 OPC_SwitchField, 0, 10, // 920: switch Inst[9:0] {
14816 119, 8, // 923: case 0x77: {
14817 OPC_CheckPredicate, 152, 1, // 925: check predicate 152
14818 OPC_Decode, 178, 123, 246, 1, // 928: decode to SF_MM_E5M2_E5M2 using decoder 246
14819 // 928: }
14820 247, 1, 0, // 933: case 0xf7: {
14821 OPC_CheckPredicate, 152, 1, // 936: check predicate 152
14822 OPC_Decode, 177, 123, 246, 1, // 939: decode to SF_MM_E5M2_E4M3 using decoder 246
14823 // 939: }
14824 // 939: } // switch Inst[9:0]
14825 // 939: }
14826 7, 0, // 944: case 0x7: {
14827 OPC_SwitchField, 0, 10, // 946: switch Inst[9:0] {
14828 119, 8, // 949: case 0x77: {
14829 OPC_CheckPredicate, 152, 1, // 951: check predicate 152
14830 OPC_Decode, 176, 123, 246, 1, // 954: decode to SF_MM_E4M3_E5M2 using decoder 246
14831 // 954: }
14832 247, 1, 0, // 959: case 0xf7: {
14833 OPC_CheckPredicate, 152, 1, // 962: check predicate 152
14834 OPC_Decode, 175, 123, 246, 1, // 965: decode to SF_MM_E4M3_E4M3 using decoder 246
14835 // 965: }
14836 // 965: } // switch Inst[9:0]
14837 // 965: }
14838 // 965: } // switch Inst[27:25]
14839 // 965: }
14840 2, 59, // 970: case 0x2: {
14841 OPC_SwitchField, 25, 3, // 972: switch Inst[27:25] {
14842 1, 12, // 975: case 0x1: {
14843 OPC_CheckPredicate, 153, 1, // 977: check predicate 153
14844 OPC_CheckField, 0, 7, 91, // 980: check Inst[6:0] == 0x5b
14845 OPC_Decode, 226, 123, 245, 1, // 984: decode to SF_VQMACCU_4x8x4 using decoder 245
14846 // 984: }
14847 3, 12, // 989: case 0x3: {
14848 OPC_CheckPredicate, 153, 1, // 991: check predicate 153
14849 OPC_CheckField, 0, 7, 91, // 994: check Inst[6:0] == 0x5b
14850 OPC_Decode, 228, 123, 245, 1, // 998: decode to SF_VQMACC_4x8x4 using decoder 245
14851 // 998: }
14852 5, 12, // 1003: case 0x5: {
14853 OPC_CheckPredicate, 153, 1, // 1005: check predicate 153
14854 OPC_CheckField, 0, 7, 91, // 1008: check Inst[6:0] == 0x5b
14855 OPC_Decode, 224, 123, 245, 1, // 1012: decode to SF_VQMACCUS_4x8x4 using decoder 245
14856 // 1012: }
14857 7, 0, // 1017: case 0x7: {
14858 OPC_CheckPredicate, 153, 1, // 1019: check predicate 153
14859 OPC_CheckField, 0, 7, 91, // 1022: check Inst[6:0] == 0x5b
14860 OPC_Decode, 222, 123, 245, 1, // 1026: decode to SF_VQMACCSU_4x8x4 using decoder 245
14861 // 1026: }
14862 // 1026: } // switch Inst[27:25]
14863 // 1026: }
14864 3, 31, // 1031: case 0x3: {
14865 OPC_SwitchField, 25, 1, // 1033: switch Inst[25] {
14866 0, 12, // 1036: case 0x0: {
14867 OPC_CheckPredicate, 143, 1, // 1038: check predicate 143
14868 OPC_CheckField, 0, 7, 91, // 1041: check Inst[6:0] == 0x5b
14869 OPC_Decode, 200, 123, 239, 1, // 1045: decode to SF_VC_V_IVW using decoder 239
14870 // 1045: }
14871 1, 0, // 1050: case 0x1: {
14872 OPC_CheckPredicate, 143, 1, // 1052: check predicate 143
14873 OPC_CheckField, 0, 7, 91, // 1055: check Inst[6:0] == 0x5b
14874 OPC_Decode, 190, 123, 240, 1, // 1059: decode to SF_VC_IVW using decoder 240
14875 // 1059: }
14876 // 1059: } // switch Inst[25]
14877 // 1059: }
14878 4, 31, // 1064: case 0x4: {
14879 OPC_SwitchField, 25, 1, // 1066: switch Inst[25] {
14880 0, 12, // 1069: case 0x0: {
14881 OPC_CheckPredicate, 143, 1, // 1071: check predicate 143
14882 OPC_CheckField, 0, 7, 91, // 1074: check Inst[6:0] == 0x5b
14883 OPC_Decode, 207, 123, 241, 1, // 1078: decode to SF_VC_V_XVW using decoder 241
14884 // 1078: }
14885 1, 0, // 1083: case 0x1: {
14886 OPC_CheckPredicate, 143, 1, // 1085: check predicate 143
14887 OPC_CheckField, 0, 7, 91, // 1088: check Inst[6:0] == 0x5b
14888 OPC_Decode, 211, 123, 242, 1, // 1092: decode to SF_VC_XVW using decoder 242
14889 // 1092: }
14890 // 1092: } // switch Inst[25]
14891 // 1092: }
14892 5, 0, // 1097: case 0x5: {
14893 OPC_SwitchField, 25, 1, // 1099: switch Inst[25] {
14894 0, 16, // 1102: case 0x0: {
14895 OPC_CheckPredicate, 143, 1, // 1104: check predicate 143
14896 OPC_CheckField, 27, 1, 1, // 1107: check Inst[27] == 0x1
14897 OPC_CheckField, 0, 7, 91, // 1111: check Inst[6:0] == 0x5b
14898 OPC_Decode, 196, 123, 243, 1, // 1115: decode to SF_VC_V_FVW using decoder 243
14899 // 1115: }
14900 1, 0, // 1120: case 0x1: {
14901 OPC_CheckPredicate, 143, 1, // 1122: check predicate 143
14902 OPC_CheckField, 27, 1, 1, // 1125: check Inst[27] == 0x1
14903 OPC_CheckField, 0, 7, 91, // 1129: check Inst[6:0] == 0x5b
14904 OPC_Decode, 186, 123, 244, 1, // 1133: decode to SF_VC_FVW using decoder 244
14905 // 1133: }
14906 // 1133: } // switch Inst[25]
14907 // 1133: }
14908 // 1133: } // switch Inst[14:12]
14909 // 1133: }
14910 // 1133: } // switch Inst[31:28]
14911};
14912static const uint8_t DecoderTableXTHead32[1598] = {
14913 32, // 0: BitWidth 32
14914 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
14915 0, 235, 2, // 4: case 0x0: {
14916 OPC_SwitchField, 25, 7, // 7: switch Inst[31:25] {
14917 0, 168, 1, // 10: case 0x0: {
14918 OPC_SwitchField, 15, 10, // 13: switch Inst[24:15] {
14919 32, 11, // 16: case 0x20: {
14920 OPC_CheckPredicate, 154, 1, // 18: check predicate 154
14921 OPC_CheckField, 0, 12, 11, // 21: check Inst[11:0] == 0xb
14922 OPC_Decode, 210, 124, 13, // 25: decode to TH_DCACHE_CALL using decoder 13
14923 // 25: }
14924 64, 11, // 29: case 0x40: {
14925 OPC_CheckPredicate, 154, 1, // 31: check predicate 154
14926 OPC_CheckField, 0, 12, 11, // 34: check Inst[11:0] == 0xb
14927 OPC_Decode, 220, 124, 13, // 38: decode to TH_DCACHE_IALL using decoder 13
14928 // 38: }
14929 96, 11, // 42: case 0x60: {
14930 OPC_CheckPredicate, 154, 1, // 44: check predicate 154
14931 OPC_CheckField, 0, 12, 11, // 47: check Inst[11:0] == 0xb
14932 OPC_Decode, 211, 124, 13, // 51: decode to TH_DCACHE_CIALL using decoder 13
14933 // 51: }
14934 128, 4, 11, // 55: case 0x200: {
14935 OPC_CheckPredicate, 154, 1, // 58: check predicate 154
14936 OPC_CheckField, 0, 12, 11, // 61: check Inst[11:0] == 0xb
14937 OPC_Decode, 236, 124, 13, // 65: decode to TH_ICACHE_IALL using decoder 13
14938 // 65: }
14939 160, 4, 11, // 69: case 0x220: {
14940 OPC_CheckPredicate, 154, 1, // 72: check predicate 154
14941 OPC_CheckField, 0, 12, 11, // 75: check Inst[11:0] == 0xb
14942 OPC_Decode, 237, 124, 13, // 79: decode to TH_ICACHE_IALLS using decoder 13
14943 // 79: }
14944 160, 5, 11, // 83: case 0x2a0: {
14945 OPC_CheckPredicate, 154, 1, // 86: check predicate 154
14946 OPC_CheckField, 0, 12, 11, // 89: check Inst[11:0] == 0xb
14947 OPC_Decode, 240, 124, 13, // 93: decode to TH_L2CACHE_CALL using decoder 13
14948 // 93: }
14949 192, 5, 11, // 97: case 0x2c0: {
14950 OPC_CheckPredicate, 154, 1, // 100: check predicate 154
14951 OPC_CheckField, 0, 12, 11, // 103: check Inst[11:0] == 0xb
14952 OPC_Decode, 242, 124, 13, // 107: decode to TH_L2CACHE_IALL using decoder 13
14953 // 107: }
14954 224, 5, 11, // 111: case 0x2e0: {
14955 OPC_CheckPredicate, 154, 1, // 114: check predicate 154
14956 OPC_CheckField, 0, 12, 11, // 117: check Inst[11:0] == 0xb
14957 OPC_Decode, 241, 124, 13, // 121: decode to TH_L2CACHE_CIALL using decoder 13
14958 // 121: }
14959 128, 6, 11, // 125: case 0x300: {
14960 OPC_CheckPredicate, 155, 1, // 128: check predicate 155
14961 OPC_CheckField, 0, 12, 11, // 131: check Inst[11:0] == 0xb
14962 OPC_Decode, 177, 125, 13, // 135: decode to TH_SYNC using decoder 13
14963 // 135: }
14964 160, 6, 11, // 139: case 0x320: {
14965 OPC_CheckPredicate, 155, 1, // 142: check predicate 155
14966 OPC_CheckField, 0, 12, 11, // 145: check Inst[11:0] == 0xb
14967 OPC_Decode, 180, 125, 13, // 149: decode to TH_SYNC_S using decoder 13
14968 // 149: }
14969 192, 6, 11, // 153: case 0x340: {
14970 OPC_CheckPredicate, 155, 1, // 156: check predicate 155
14971 OPC_CheckField, 0, 12, 11, // 159: check Inst[11:0] == 0xb
14972 OPC_Decode, 178, 125, 13, // 163: decode to TH_SYNC_I using decoder 13
14973 // 163: }
14974 224, 6, 0, // 167: case 0x360: {
14975 OPC_CheckPredicate, 155, 1, // 170: check predicate 155
14976 OPC_CheckField, 0, 12, 11, // 173: check Inst[11:0] == 0xb
14977 OPC_Decode, 179, 125, 13, // 177: decode to TH_SYNC_IS using decoder 13
14978 // 177: }
14979 // 177: } // switch Inst[24:15]
14980 // 177: }
14981 1, 172, 1, // 181: case 0x1: {
14982 OPC_SwitchField, 20, 5, // 184: switch Inst[24:20] {
14983 1, 11, // 187: case 0x1: {
14984 OPC_CheckPredicate, 154, 1, // 189: check predicate 154
14985 OPC_CheckField, 0, 12, 11, // 192: check Inst[11:0] == 0xb
14986 OPC_Decode, 217, 124, 14, // 196: decode to TH_DCACHE_CSW using decoder 14
14987 // 196: }
14988 2, 11, // 200: case 0x2: {
14989 OPC_CheckPredicate, 154, 1, // 202: check predicate 154
14990 OPC_CheckField, 0, 12, 11, // 205: check Inst[11:0] == 0xb
14991 OPC_Decode, 222, 124, 14, // 209: decode to TH_DCACHE_ISW using decoder 14
14992 // 209: }
14993 3, 11, // 213: case 0x3: {
14994 OPC_CheckPredicate, 154, 1, // 215: check predicate 154
14995 OPC_CheckField, 0, 12, 11, // 218: check Inst[11:0] == 0xb
14996 OPC_Decode, 213, 124, 14, // 222: decode to TH_DCACHE_CISW using decoder 14
14997 // 222: }
14998 4, 11, // 226: case 0x4: {
14999 OPC_CheckPredicate, 154, 1, // 228: check predicate 154
15000 OPC_CheckField, 0, 12, 11, // 231: check Inst[11:0] == 0xb
15001 OPC_Decode, 219, 124, 14, // 235: decode to TH_DCACHE_CVAL1 using decoder 14
15002 // 235: }
15003 5, 11, // 239: case 0x5: {
15004 OPC_CheckPredicate, 154, 1, // 241: check predicate 154
15005 OPC_CheckField, 0, 12, 11, // 244: check Inst[11:0] == 0xb
15006 OPC_Decode, 218, 124, 14, // 248: decode to TH_DCACHE_CVA using decoder 14
15007 // 248: }
15008 6, 11, // 252: case 0x6: {
15009 OPC_CheckPredicate, 154, 1, // 254: check predicate 154
15010 OPC_CheckField, 0, 12, 11, // 257: check Inst[11:0] == 0xb
15011 OPC_Decode, 223, 124, 14, // 261: decode to TH_DCACHE_IVA using decoder 14
15012 // 261: }
15013 7, 11, // 265: case 0x7: {
15014 OPC_CheckPredicate, 154, 1, // 267: check predicate 154
15015 OPC_CheckField, 0, 12, 11, // 270: check Inst[11:0] == 0xb
15016 OPC_Decode, 214, 124, 14, // 274: decode to TH_DCACHE_CIVA using decoder 14
15017 // 274: }
15018 8, 11, // 278: case 0x8: {
15019 OPC_CheckPredicate, 154, 1, // 280: check predicate 154
15020 OPC_CheckField, 0, 12, 11, // 283: check Inst[11:0] == 0xb
15021 OPC_Decode, 216, 124, 14, // 287: decode to TH_DCACHE_CPAL1 using decoder 14
15022 // 287: }
15023 9, 11, // 291: case 0x9: {
15024 OPC_CheckPredicate, 154, 1, // 293: check predicate 154
15025 OPC_CheckField, 0, 12, 11, // 296: check Inst[11:0] == 0xb
15026 OPC_Decode, 215, 124, 14, // 300: decode to TH_DCACHE_CPA using decoder 14
15027 // 300: }
15028 10, 11, // 304: case 0xa: {
15029 OPC_CheckPredicate, 154, 1, // 306: check predicate 154
15030 OPC_CheckField, 0, 12, 11, // 309: check Inst[11:0] == 0xb
15031 OPC_Decode, 221, 124, 14, // 313: decode to TH_DCACHE_IPA using decoder 14
15032 // 313: }
15033 11, 11, // 317: case 0xb: {
15034 OPC_CheckPredicate, 154, 1, // 319: check predicate 154
15035 OPC_CheckField, 0, 12, 11, // 322: check Inst[11:0] == 0xb
15036 OPC_Decode, 212, 124, 14, // 326: decode to TH_DCACHE_CIPA using decoder 14
15037 // 326: }
15038 16, 11, // 330: case 0x10: {
15039 OPC_CheckPredicate, 154, 1, // 332: check predicate 154
15040 OPC_CheckField, 0, 12, 11, // 335: check Inst[11:0] == 0xb
15041 OPC_Decode, 239, 124, 14, // 339: decode to TH_ICACHE_IVA using decoder 14
15042 // 339: }
15043 24, 0, // 343: case 0x18: {
15044 OPC_CheckPredicate, 154, 1, // 345: check predicate 154
15045 OPC_CheckField, 0, 12, 11, // 348: check Inst[11:0] == 0xb
15046 OPC_Decode, 238, 124, 14, // 352: decode to TH_ICACHE_IPA using decoder 14
15047 // 352: }
15048 // 352: } // switch Inst[24:20]
15049 // 352: }
15050 2, 0, // 356: case 0x2: {
15051 OPC_CheckPredicate, 155, 1, // 358: check predicate 155
15052 OPC_CheckField, 0, 12, 11, // 361: check Inst[11:0] == 0xb
15053 OPC_Decode, 161, 125, 148, 1, // 365: decode to TH_SFENCE_VMAS using decoder 148
15054 // 365: }
15055 // 365: } // switch Inst[31:25]
15056 // 365: }
15057 1, 134, 2, // 370: case 0x1: {
15058 OPC_SwitchField, 27, 5, // 373: switch Inst[31:27] {
15059 0, 12, // 376: case 0x0: {
15060 OPC_CheckPredicate, 156, 1, // 378: check predicate 156
15061 OPC_CheckField, 0, 7, 11, // 381: check Inst[6:0] == 0xb
15062 OPC_Decode, 209, 124, 248, 1, // 385: decode to TH_ADDSL using decoder 248
15063 // 385: }
15064 2, 33, // 390: case 0x2: {
15065 OPC_SwitchField, 26, 1, // 392: switch Inst[26] {
15066 0, 11, // 395: case 0x0: {
15067 OPC_CheckPredicate, 157, 1, // 397: check predicate 157
15068 OPC_CheckField, 0, 7, 11, // 400: check Inst[6:0] == 0xb
15069 OPC_Decode, 167, 125, 15, // 404: decode to TH_SRRI using decoder 15
15070 // 404: }
15071 1, 0, // 408: case 0x1: {
15072 OPC_CheckPredicate, 158, 1, // 410: check predicate 158
15073 OPC_CheckField, 25, 1, 0, // 413: check Inst[25] == 0x0
15074 OPC_CheckField, 0, 7, 11, // 417: check Inst[6:0] == 0xb
15075 OPC_Decode, 168, 125, 20, // 421: decode to TH_SRRIW using decoder 20
15076 // 421: }
15077 // 421: } // switch Inst[26]
15078 // 421: }
15079 4, 55, // 425: case 0x4: {
15080 OPC_SwitchField, 25, 2, // 427: switch Inst[26:25] {
15081 0, 11, // 430: case 0x0: {
15082 OPC_CheckPredicate, 159, 1, // 432: check predicate 159
15083 OPC_CheckField, 0, 7, 11, // 435: check Inst[6:0] == 0xb
15084 OPC_Decode, 146, 125, 58, // 439: decode to TH_MULA using decoder 58
15085 // 439: }
15086 1, 11, // 443: case 0x1: {
15087 OPC_CheckPredicate, 159, 1, // 445: check predicate 159
15088 OPC_CheckField, 0, 7, 11, // 448: check Inst[6:0] == 0xb
15089 OPC_Decode, 149, 125, 58, // 452: decode to TH_MULS using decoder 58
15090 // 452: }
15091 2, 11, // 456: case 0x2: {
15092 OPC_CheckPredicate, 160, 1, // 458: check predicate 160
15093 OPC_CheckField, 0, 7, 11, // 461: check Inst[6:0] == 0xb
15094 OPC_Decode, 148, 125, 58, // 465: decode to TH_MULAW using decoder 58
15095 // 465: }
15096 3, 0, // 469: case 0x3: {
15097 OPC_CheckPredicate, 160, 1, // 471: check predicate 160
15098 OPC_CheckField, 0, 7, 11, // 474: check Inst[6:0] == 0xb
15099 OPC_Decode, 151, 125, 58, // 478: decode to TH_MULSW using decoder 58
15100 // 478: }
15101 // 478: } // switch Inst[26:25]
15102 // 478: }
15103 5, 29, // 482: case 0x5: {
15104 OPC_SwitchField, 25, 2, // 484: switch Inst[26:25] {
15105 0, 11, // 487: case 0x0: {
15106 OPC_CheckPredicate, 159, 1, // 489: check predicate 159
15107 OPC_CheckField, 0, 7, 11, // 492: check Inst[6:0] == 0xb
15108 OPC_Decode, 147, 125, 58, // 496: decode to TH_MULAH using decoder 58
15109 // 496: }
15110 1, 0, // 500: case 0x1: {
15111 OPC_CheckPredicate, 159, 1, // 502: check predicate 159
15112 OPC_CheckField, 0, 7, 11, // 505: check Inst[6:0] == 0xb
15113 OPC_Decode, 150, 125, 58, // 509: decode to TH_MULSH using decoder 58
15114 // 509: }
15115 // 509: } // switch Inst[26:25]
15116 // 509: }
15117 8, 29, // 513: case 0x8: {
15118 OPC_SwitchField, 25, 2, // 515: switch Inst[26:25] {
15119 0, 11, // 518: case 0x0: {
15120 OPC_CheckPredicate, 161, 1, // 520: check predicate 161
15121 OPC_CheckField, 0, 7, 11, // 523: check Inst[6:0] == 0xb
15122 OPC_Decode, 152, 125, 58, // 527: decode to TH_MVEQZ using decoder 58
15123 // 527: }
15124 1, 0, // 531: case 0x1: {
15125 OPC_CheckPredicate, 161, 1, // 533: check predicate 161
15126 OPC_CheckField, 0, 7, 11, // 536: check Inst[6:0] == 0xb
15127 OPC_Decode, 153, 125, 58, // 540: decode to TH_MVNEZ using decoder 58
15128 // 540: }
15129 // 540: } // switch Inst[26:25]
15130 // 540: }
15131 16, 55, // 544: case 0x10: {
15132 OPC_SwitchField, 20, 7, // 546: switch Inst[26:20] {
15133 0, 11, // 549: case 0x0: {
15134 OPC_CheckPredicate, 157, 1, // 551: check predicate 157
15135 OPC_CheckField, 0, 7, 11, // 554: check Inst[6:0] == 0xb
15136 OPC_Decode, 182, 125, 16, // 558: decode to TH_TSTNBZ using decoder 16
15137 // 558: }
15138 32, 11, // 562: case 0x20: {
15139 OPC_CheckPredicate, 157, 1, // 564: check predicate 157
15140 OPC_CheckField, 0, 7, 11, // 567: check Inst[6:0] == 0xb
15141 OPC_Decode, 154, 125, 16, // 571: decode to TH_REV using decoder 16
15142 // 571: }
15143 64, 11, // 575: case 0x40: {
15144 OPC_CheckPredicate, 157, 1, // 577: check predicate 157
15145 OPC_CheckField, 0, 7, 11, // 580: check Inst[6:0] == 0xb
15146 OPC_Decode, 226, 124, 16, // 584: decode to TH_FF0 using decoder 16
15147 // 584: }
15148 96, 0, // 588: case 0x60: {
15149 OPC_CheckPredicate, 157, 1, // 590: check predicate 157
15150 OPC_CheckField, 0, 7, 11, // 593: check Inst[6:0] == 0xb
15151 OPC_Decode, 227, 124, 16, // 597: decode to TH_FF1 using decoder 16
15152 // 597: }
15153 // 597: } // switch Inst[26:20]
15154 // 597: }
15155 17, 15, // 601: case 0x11: {
15156 OPC_CheckPredicate, 162, 1, // 603: check predicate 162
15157 OPC_CheckField, 26, 1, 0, // 606: check Inst[26] == 0x0
15158 OPC_CheckField, 0, 7, 11, // 610: check Inst[6:0] == 0xb
15159 OPC_Decode, 181, 125, 15, // 614: decode to TH_TST using decoder 15
15160 // 614: }
15161 18, 0, // 618: case 0x12: {
15162 OPC_CheckPredicate, 158, 1, // 620: check predicate 158
15163 OPC_CheckField, 20, 7, 0, // 623: check Inst[26:20] == 0x0
15164 OPC_CheckField, 0, 7, 11, // 627: check Inst[6:0] == 0xb
15165 OPC_Decode, 155, 125, 16, // 631: decode to TH_REVW using decoder 16
15166 // 631: }
15167 // 631: } // switch Inst[31:27]
15168 // 631: }
15169 2, 12, // 635: case 0x2: {
15170 OPC_CheckPredicate, 157, 1, // 637: check predicate 157
15171 OPC_CheckField, 0, 7, 11, // 640: check Inst[6:0] == 0xb
15172 OPC_Decode, 224, 124, 193, 1, // 644: decode to TH_EXT using decoder 193
15173 // 644: }
15174 3, 12, // 649: case 0x3: {
15175 OPC_CheckPredicate, 157, 1, // 651: check predicate 157
15176 OPC_CheckField, 0, 7, 11, // 654: check Inst[6:0] == 0xb
15177 OPC_Decode, 225, 124, 193, 1, // 658: decode to TH_EXTU using decoder 193
15178 // 658: }
15179 4, 181, 3, // 663: case 0x4: {
15180 OPC_SwitchField, 27, 5, // 666: switch Inst[31:27] {
15181 0, 12, // 669: case 0x0: {
15182 OPC_CheckPredicate, 163, 1, // 671: check predicate 163
15183 OPC_CheckField, 0, 7, 11, // 674: check Inst[6:0] == 0xb
15184 OPC_Decode, 254, 124, 248, 1, // 678: decode to TH_LRB using decoder 248
15185 // 678: }
15186 1, 12, // 683: case 0x1: {
15187 OPC_CheckPredicate, 163, 1, // 685: check predicate 163
15188 OPC_CheckField, 0, 7, 11, // 688: check Inst[6:0] == 0xb
15189 OPC_Decode, 244, 124, 249, 1, // 692: decode to TH_LBIB using decoder 249
15190 // 692: }
15191 2, 12, // 697: case 0x2: {
15192 OPC_CheckPredicate, 163, 1, // 699: check predicate 163
15193 OPC_CheckField, 0, 7, 11, // 702: check Inst[6:0] == 0xb
15194 OPC_Decode, 133, 125, 248, 1, // 706: decode to TH_LURB using decoder 248
15195 // 706: }
15196 3, 12, // 711: case 0x3: {
15197 OPC_CheckPredicate, 163, 1, // 713: check predicate 163
15198 OPC_CheckField, 0, 7, 11, // 716: check Inst[6:0] == 0xb
15199 OPC_Decode, 243, 124, 249, 1, // 720: decode to TH_LBIA using decoder 249
15200 // 720: }
15201 4, 12, // 725: case 0x4: {
15202 OPC_CheckPredicate, 163, 1, // 727: check predicate 163
15203 OPC_CheckField, 0, 7, 11, // 730: check Inst[6:0] == 0xb
15204 OPC_Decode, 129, 125, 248, 1, // 734: decode to TH_LRH using decoder 248
15205 // 734: }
15206 5, 12, // 739: case 0x5: {
15207 OPC_CheckPredicate, 163, 1, // 741: check predicate 163
15208 OPC_CheckField, 0, 7, 11, // 744: check Inst[6:0] == 0xb
15209 OPC_Decode, 251, 124, 249, 1, // 748: decode to TH_LHIB using decoder 249
15210 // 748: }
15211 6, 12, // 753: case 0x6: {
15212 OPC_CheckPredicate, 163, 1, // 755: check predicate 163
15213 OPC_CheckField, 0, 7, 11, // 758: check Inst[6:0] == 0xb
15214 OPC_Decode, 136, 125, 248, 1, // 762: decode to TH_LURH using decoder 248
15215 // 762: }
15216 7, 12, // 767: case 0x7: {
15217 OPC_CheckPredicate, 163, 1, // 769: check predicate 163
15218 OPC_CheckField, 0, 7, 11, // 772: check Inst[6:0] == 0xb
15219 OPC_Decode, 250, 124, 249, 1, // 776: decode to TH_LHIA using decoder 249
15220 // 776: }
15221 8, 12, // 781: case 0x8: {
15222 OPC_CheckPredicate, 163, 1, // 783: check predicate 163
15223 OPC_CheckField, 0, 7, 11, // 786: check Inst[6:0] == 0xb
15224 OPC_Decode, 131, 125, 248, 1, // 790: decode to TH_LRW using decoder 248
15225 // 790: }
15226 9, 12, // 795: case 0x9: {
15227 OPC_CheckPredicate, 163, 1, // 797: check predicate 163
15228 OPC_CheckField, 0, 7, 11, // 800: check Inst[6:0] == 0xb
15229 OPC_Decode, 142, 125, 249, 1, // 804: decode to TH_LWIB using decoder 249
15230 // 804: }
15231 10, 12, // 809: case 0xa: {
15232 OPC_CheckPredicate, 163, 1, // 811: check predicate 163
15233 OPC_CheckField, 0, 7, 11, // 814: check Inst[6:0] == 0xb
15234 OPC_Decode, 138, 125, 248, 1, // 818: decode to TH_LURW using decoder 248
15235 // 818: }
15236 11, 12, // 823: case 0xb: {
15237 OPC_CheckPredicate, 163, 1, // 825: check predicate 163
15238 OPC_CheckField, 0, 7, 11, // 828: check Inst[6:0] == 0xb
15239 OPC_Decode, 141, 125, 249, 1, // 832: decode to TH_LWIA using decoder 249
15240 // 832: }
15241 12, 12, // 837: case 0xc: {
15242 OPC_CheckPredicate, 164, 1, // 839: check predicate 164
15243 OPC_CheckField, 0, 7, 11, // 842: check Inst[6:0] == 0xb
15244 OPC_Decode, 128, 125, 248, 1, // 846: decode to TH_LRD using decoder 248
15245 // 846: }
15246 13, 12, // 851: case 0xd: {
15247 OPC_CheckPredicate, 164, 1, // 853: check predicate 164
15248 OPC_CheckField, 0, 7, 11, // 856: check Inst[6:0] == 0xb
15249 OPC_Decode, 249, 124, 249, 1, // 860: decode to TH_LDIB using decoder 249
15250 // 860: }
15251 14, 12, // 865: case 0xe: {
15252 OPC_CheckPredicate, 164, 1, // 867: check predicate 164
15253 OPC_CheckField, 0, 7, 11, // 870: check Inst[6:0] == 0xb
15254 OPC_Decode, 135, 125, 248, 1, // 874: decode to TH_LURD using decoder 248
15255 // 874: }
15256 15, 12, // 879: case 0xf: {
15257 OPC_CheckPredicate, 164, 1, // 881: check predicate 164
15258 OPC_CheckField, 0, 7, 11, // 884: check Inst[6:0] == 0xb
15259 OPC_Decode, 248, 124, 249, 1, // 888: decode to TH_LDIA using decoder 249
15260 // 888: }
15261 16, 12, // 893: case 0x10: {
15262 OPC_CheckPredicate, 163, 1, // 895: check predicate 163
15263 OPC_CheckField, 0, 7, 11, // 898: check Inst[6:0] == 0xb
15264 OPC_Decode, 255, 124, 248, 1, // 902: decode to TH_LRBU using decoder 248
15265 // 902: }
15266 17, 12, // 907: case 0x11: {
15267 OPC_CheckPredicate, 163, 1, // 909: check predicate 163
15268 OPC_CheckField, 0, 7, 11, // 912: check Inst[6:0] == 0xb
15269 OPC_Decode, 246, 124, 249, 1, // 916: decode to TH_LBUIB using decoder 249
15270 // 916: }
15271 18, 12, // 921: case 0x12: {
15272 OPC_CheckPredicate, 163, 1, // 923: check predicate 163
15273 OPC_CheckField, 0, 7, 11, // 926: check Inst[6:0] == 0xb
15274 OPC_Decode, 134, 125, 248, 1, // 930: decode to TH_LURBU using decoder 248
15275 // 930: }
15276 19, 12, // 935: case 0x13: {
15277 OPC_CheckPredicate, 163, 1, // 937: check predicate 163
15278 OPC_CheckField, 0, 7, 11, // 940: check Inst[6:0] == 0xb
15279 OPC_Decode, 245, 124, 249, 1, // 944: decode to TH_LBUIA using decoder 249
15280 // 944: }
15281 20, 12, // 949: case 0x14: {
15282 OPC_CheckPredicate, 163, 1, // 951: check predicate 163
15283 OPC_CheckField, 0, 7, 11, // 954: check Inst[6:0] == 0xb
15284 OPC_Decode, 130, 125, 248, 1, // 958: decode to TH_LRHU using decoder 248
15285 // 958: }
15286 21, 12, // 963: case 0x15: {
15287 OPC_CheckPredicate, 163, 1, // 965: check predicate 163
15288 OPC_CheckField, 0, 7, 11, // 968: check Inst[6:0] == 0xb
15289 OPC_Decode, 253, 124, 249, 1, // 972: decode to TH_LHUIB using decoder 249
15290 // 972: }
15291 22, 12, // 977: case 0x16: {
15292 OPC_CheckPredicate, 163, 1, // 979: check predicate 163
15293 OPC_CheckField, 0, 7, 11, // 982: check Inst[6:0] == 0xb
15294 OPC_Decode, 137, 125, 248, 1, // 986: decode to TH_LURHU using decoder 248
15295 // 986: }
15296 23, 12, // 991: case 0x17: {
15297 OPC_CheckPredicate, 163, 1, // 993: check predicate 163
15298 OPC_CheckField, 0, 7, 11, // 996: check Inst[6:0] == 0xb
15299 OPC_Decode, 252, 124, 249, 1, // 1000: decode to TH_LHUIA using decoder 249
15300 // 1000: }
15301 24, 12, // 1005: case 0x18: {
15302 OPC_CheckPredicate, 164, 1, // 1007: check predicate 164
15303 OPC_CheckField, 0, 7, 11, // 1010: check Inst[6:0] == 0xb
15304 OPC_Decode, 132, 125, 248, 1, // 1014: decode to TH_LRWU using decoder 248
15305 // 1014: }
15306 25, 12, // 1019: case 0x19: {
15307 OPC_CheckPredicate, 164, 1, // 1021: check predicate 164
15308 OPC_CheckField, 0, 7, 11, // 1024: check Inst[6:0] == 0xb
15309 OPC_Decode, 145, 125, 249, 1, // 1028: decode to TH_LWUIB using decoder 249
15310 // 1028: }
15311 26, 12, // 1033: case 0x1a: {
15312 OPC_CheckPredicate, 164, 1, // 1035: check predicate 164
15313 OPC_CheckField, 0, 7, 11, // 1038: check Inst[6:0] == 0xb
15314 OPC_Decode, 139, 125, 248, 1, // 1042: decode to TH_LURWU using decoder 248
15315 // 1042: }
15316 27, 12, // 1047: case 0x1b: {
15317 OPC_CheckPredicate, 164, 1, // 1049: check predicate 164
15318 OPC_CheckField, 0, 7, 11, // 1052: check Inst[6:0] == 0xb
15319 OPC_Decode, 144, 125, 249, 1, // 1056: decode to TH_LWUIA using decoder 249
15320 // 1056: }
15321 28, 12, // 1061: case 0x1c: {
15322 OPC_CheckPredicate, 165, 1, // 1063: check predicate 165
15323 OPC_CheckField, 0, 7, 11, // 1066: check Inst[6:0] == 0xb
15324 OPC_Decode, 140, 125, 250, 1, // 1070: decode to TH_LWD using decoder 250
15325 // 1070: }
15326 30, 12, // 1075: case 0x1e: {
15327 OPC_CheckPredicate, 165, 1, // 1077: check predicate 165
15328 OPC_CheckField, 0, 7, 11, // 1080: check Inst[6:0] == 0xb
15329 OPC_Decode, 143, 125, 250, 1, // 1084: decode to TH_LWUD using decoder 250
15330 // 1084: }
15331 31, 0, // 1089: case 0x1f: {
15332 OPC_CheckPredicate, 166, 1, // 1091: check predicate 166
15333 OPC_CheckField, 0, 7, 11, // 1094: check Inst[6:0] == 0xb
15334 OPC_Decode, 247, 124, 251, 1, // 1098: decode to TH_LDD using decoder 251
15335 // 1098: }
15336 // 1098: } // switch Inst[31:27]
15337 // 1098: }
15338 5, 255, 1, // 1103: case 0x5: {
15339 OPC_SwitchField, 27, 5, // 1106: switch Inst[31:27] {
15340 0, 12, // 1109: case 0x0: {
15341 OPC_CheckPredicate, 163, 1, // 1111: check predicate 163
15342 OPC_CheckField, 0, 7, 11, // 1114: check Inst[6:0] == 0xb
15343 OPC_Decode, 164, 125, 248, 1, // 1118: decode to TH_SRB using decoder 248
15344 // 1118: }
15345 1, 12, // 1123: case 0x1: {
15346 OPC_CheckPredicate, 163, 1, // 1125: check predicate 163
15347 OPC_CheckField, 0, 7, 11, // 1128: check Inst[6:0] == 0xb
15348 OPC_Decode, 157, 125, 252, 1, // 1132: decode to TH_SBIB using decoder 252
15349 // 1132: }
15350 2, 12, // 1137: case 0x2: {
15351 OPC_CheckPredicate, 163, 1, // 1139: check predicate 163
15352 OPC_CheckField, 0, 7, 11, // 1142: check Inst[6:0] == 0xb
15353 OPC_Decode, 170, 125, 248, 1, // 1146: decode to TH_SURB using decoder 248
15354 // 1146: }
15355 3, 12, // 1151: case 0x3: {
15356 OPC_CheckPredicate, 163, 1, // 1153: check predicate 163
15357 OPC_CheckField, 0, 7, 11, // 1156: check Inst[6:0] == 0xb
15358 OPC_Decode, 156, 125, 252, 1, // 1160: decode to TH_SBIA using decoder 252
15359 // 1160: }
15360 4, 12, // 1165: case 0x4: {
15361 OPC_CheckPredicate, 163, 1, // 1167: check predicate 163
15362 OPC_CheckField, 0, 7, 11, // 1170: check Inst[6:0] == 0xb
15363 OPC_Decode, 166, 125, 248, 1, // 1174: decode to TH_SRH using decoder 248
15364 // 1174: }
15365 5, 12, // 1179: case 0x5: {
15366 OPC_CheckPredicate, 163, 1, // 1181: check predicate 163
15367 OPC_CheckField, 0, 7, 11, // 1184: check Inst[6:0] == 0xb
15368 OPC_Decode, 163, 125, 252, 1, // 1188: decode to TH_SHIB using decoder 252
15369 // 1188: }
15370 6, 12, // 1193: case 0x6: {
15371 OPC_CheckPredicate, 163, 1, // 1195: check predicate 163
15372 OPC_CheckField, 0, 7, 11, // 1198: check Inst[6:0] == 0xb
15373 OPC_Decode, 172, 125, 248, 1, // 1202: decode to TH_SURH using decoder 248
15374 // 1202: }
15375 7, 12, // 1207: case 0x7: {
15376 OPC_CheckPredicate, 163, 1, // 1209: check predicate 163
15377 OPC_CheckField, 0, 7, 11, // 1212: check Inst[6:0] == 0xb
15378 OPC_Decode, 162, 125, 252, 1, // 1216: decode to TH_SHIA using decoder 252
15379 // 1216: }
15380 8, 12, // 1221: case 0x8: {
15381 OPC_CheckPredicate, 163, 1, // 1223: check predicate 163
15382 OPC_CheckField, 0, 7, 11, // 1226: check Inst[6:0] == 0xb
15383 OPC_Decode, 169, 125, 248, 1, // 1230: decode to TH_SRW using decoder 248
15384 // 1230: }
15385 9, 12, // 1235: case 0x9: {
15386 OPC_CheckPredicate, 163, 1, // 1237: check predicate 163
15387 OPC_CheckField, 0, 7, 11, // 1240: check Inst[6:0] == 0xb
15388 OPC_Decode, 176, 125, 252, 1, // 1244: decode to TH_SWIB using decoder 252
15389 // 1244: }
15390 10, 12, // 1249: case 0xa: {
15391 OPC_CheckPredicate, 163, 1, // 1251: check predicate 163
15392 OPC_CheckField, 0, 7, 11, // 1254: check Inst[6:0] == 0xb
15393 OPC_Decode, 173, 125, 248, 1, // 1258: decode to TH_SURW using decoder 248
15394 // 1258: }
15395 11, 12, // 1263: case 0xb: {
15396 OPC_CheckPredicate, 163, 1, // 1265: check predicate 163
15397 OPC_CheckField, 0, 7, 11, // 1268: check Inst[6:0] == 0xb
15398 OPC_Decode, 175, 125, 252, 1, // 1272: decode to TH_SWIA using decoder 252
15399 // 1272: }
15400 12, 12, // 1277: case 0xc: {
15401 OPC_CheckPredicate, 164, 1, // 1279: check predicate 164
15402 OPC_CheckField, 0, 7, 11, // 1282: check Inst[6:0] == 0xb
15403 OPC_Decode, 165, 125, 248, 1, // 1286: decode to TH_SRD using decoder 248
15404 // 1286: }
15405 13, 12, // 1291: case 0xd: {
15406 OPC_CheckPredicate, 164, 1, // 1293: check predicate 164
15407 OPC_CheckField, 0, 7, 11, // 1296: check Inst[6:0] == 0xb
15408 OPC_Decode, 160, 125, 252, 1, // 1300: decode to TH_SDIB using decoder 252
15409 // 1300: }
15410 14, 12, // 1305: case 0xe: {
15411 OPC_CheckPredicate, 164, 1, // 1307: check predicate 164
15412 OPC_CheckField, 0, 7, 11, // 1310: check Inst[6:0] == 0xb
15413 OPC_Decode, 171, 125, 248, 1, // 1314: decode to TH_SURD using decoder 248
15414 // 1314: }
15415 15, 12, // 1319: case 0xf: {
15416 OPC_CheckPredicate, 164, 1, // 1321: check predicate 164
15417 OPC_CheckField, 0, 7, 11, // 1324: check Inst[6:0] == 0xb
15418 OPC_Decode, 159, 125, 252, 1, // 1328: decode to TH_SDIA using decoder 252
15419 // 1328: }
15420 28, 12, // 1333: case 0x1c: {
15421 OPC_CheckPredicate, 165, 1, // 1335: check predicate 165
15422 OPC_CheckField, 0, 7, 11, // 1338: check Inst[6:0] == 0xb
15423 OPC_Decode, 174, 125, 250, 1, // 1342: decode to TH_SWD using decoder 250
15424 // 1342: }
15425 31, 0, // 1347: case 0x1f: {
15426 OPC_CheckPredicate, 166, 1, // 1349: check predicate 166
15427 OPC_CheckField, 0, 7, 11, // 1352: check Inst[6:0] == 0xb
15428 OPC_Decode, 158, 125, 251, 1, // 1356: decode to TH_SDD using decoder 251
15429 // 1356: }
15430 // 1356: } // switch Inst[31:27]
15431 // 1356: }
15432 6, 173, 1, // 1361: case 0x6: {
15433 OPC_SwitchField, 27, 5, // 1364: switch Inst[31:27] {
15434 8, 12, // 1367: case 0x8: {
15435 OPC_CheckPredicate, 167, 1, // 1369: check predicate 167
15436 OPC_CheckField, 0, 7, 11, // 1372: check Inst[6:0] == 0xb
15437 OPC_Decode, 229, 124, 253, 1, // 1376: decode to TH_FLRW using decoder 253
15438 // 1376: }
15439 10, 12, // 1381: case 0xa: {
15440 OPC_CheckPredicate, 168, 1, // 1383: check predicate 168
15441 OPC_CheckField, 0, 7, 11, // 1386: check Inst[6:0] == 0xb
15442 OPC_Decode, 231, 124, 253, 1, // 1390: decode to TH_FLURW using decoder 253
15443 // 1390: }
15444 12, 12, // 1395: case 0xc: {
15445 OPC_CheckPredicate, 169, 1, // 1397: check predicate 169
15446 OPC_CheckField, 0, 7, 11, // 1400: check Inst[6:0] == 0xb
15447 OPC_Decode, 228, 124, 254, 1, // 1404: decode to TH_FLRD using decoder 254
15448 // 1404: }
15449 14, 12, // 1409: case 0xe: {
15450 OPC_CheckPredicate, 170, 1, // 1411: check predicate 170
15451 OPC_CheckField, 0, 7, 11, // 1414: check Inst[6:0] == 0xb
15452 OPC_Decode, 230, 124, 254, 1, // 1418: decode to TH_FLURD using decoder 254
15453 // 1418: }
15454 16, 30, // 1423: case 0x10: {
15455 OPC_SwitchField, 26, 1, // 1425: switch Inst[26] {
15456 0, 11, // 1428: case 0x0: {
15457 OPC_CheckPredicate, 171, 1, // 1430: check predicate 171
15458 OPC_CheckField, 0, 7, 11, // 1433: check Inst[6:0] == 0xb
15459 OPC_Decode, 188, 125, 117, // 1437: decode to TH_VMAQA_VV using decoder 117
15460 // 1437: }
15461 1, 0, // 1441: case 0x1: {
15462 OPC_CheckPredicate, 171, 1, // 1443: check predicate 171
15463 OPC_CheckField, 0, 7, 11, // 1446: check Inst[6:0] == 0xb
15464 OPC_Decode, 189, 125, 142, 1, // 1450: decode to TH_VMAQA_VX using decoder 142
15465 // 1450: }
15466 // 1450: } // switch Inst[26]
15467 // 1450: }
15468 17, 30, // 1455: case 0x11: {
15469 OPC_SwitchField, 26, 1, // 1457: switch Inst[26] {
15470 0, 11, // 1460: case 0x0: {
15471 OPC_CheckPredicate, 171, 1, // 1462: check predicate 171
15472 OPC_CheckField, 0, 7, 11, // 1465: check Inst[6:0] == 0xb
15473 OPC_Decode, 186, 125, 117, // 1469: decode to TH_VMAQAU_VV using decoder 117
15474 // 1469: }
15475 1, 0, // 1473: case 0x1: {
15476 OPC_CheckPredicate, 171, 1, // 1475: check predicate 171
15477 OPC_CheckField, 0, 7, 11, // 1478: check Inst[6:0] == 0xb
15478 OPC_Decode, 187, 125, 142, 1, // 1482: decode to TH_VMAQAU_VX using decoder 142
15479 // 1482: }
15480 // 1482: } // switch Inst[26]
15481 // 1482: }
15482 18, 30, // 1487: case 0x12: {
15483 OPC_SwitchField, 26, 1, // 1489: switch Inst[26] {
15484 0, 11, // 1492: case 0x0: {
15485 OPC_CheckPredicate, 171, 1, // 1494: check predicate 171
15486 OPC_CheckField, 0, 7, 11, // 1497: check Inst[6:0] == 0xb
15487 OPC_Decode, 183, 125, 117, // 1501: decode to TH_VMAQASU_VV using decoder 117
15488 // 1501: }
15489 1, 0, // 1505: case 0x1: {
15490 OPC_CheckPredicate, 171, 1, // 1507: check predicate 171
15491 OPC_CheckField, 0, 7, 11, // 1510: check Inst[6:0] == 0xb
15492 OPC_Decode, 184, 125, 142, 1, // 1514: decode to TH_VMAQASU_VX using decoder 142
15493 // 1514: }
15494 // 1514: } // switch Inst[26]
15495 // 1514: }
15496 19, 0, // 1519: case 0x13: {
15497 OPC_CheckPredicate, 171, 1, // 1521: check predicate 171
15498 OPC_CheckField, 26, 1, 1, // 1524: check Inst[26] == 0x1
15499 OPC_CheckField, 0, 7, 11, // 1528: check Inst[6:0] == 0xb
15500 OPC_Decode, 185, 125, 142, 1, // 1532: decode to TH_VMAQAUS_VX using decoder 142
15501 // 1532: }
15502 // 1532: } // switch Inst[31:27]
15503 // 1532: }
15504 7, 0, // 1537: case 0x7: {
15505 OPC_SwitchField, 27, 5, // 1539: switch Inst[31:27] {
15506 8, 12, // 1542: case 0x8: {
15507 OPC_CheckPredicate, 167, 1, // 1544: check predicate 167
15508 OPC_CheckField, 0, 7, 11, // 1547: check Inst[6:0] == 0xb
15509 OPC_Decode, 233, 124, 253, 1, // 1551: decode to TH_FSRW using decoder 253
15510 // 1551: }
15511 10, 12, // 1556: case 0xa: {
15512 OPC_CheckPredicate, 168, 1, // 1558: check predicate 168
15513 OPC_CheckField, 0, 7, 11, // 1561: check Inst[6:0] == 0xb
15514 OPC_Decode, 235, 124, 253, 1, // 1565: decode to TH_FSURW using decoder 253
15515 // 1565: }
15516 12, 12, // 1570: case 0xc: {
15517 OPC_CheckPredicate, 169, 1, // 1572: check predicate 169
15518 OPC_CheckField, 0, 7, 11, // 1575: check Inst[6:0] == 0xb
15519 OPC_Decode, 232, 124, 254, 1, // 1579: decode to TH_FSRD using decoder 254
15520 // 1579: }
15521 14, 0, // 1584: case 0xe: {
15522 OPC_CheckPredicate, 170, 1, // 1586: check predicate 170
15523 OPC_CheckField, 0, 7, 11, // 1589: check Inst[6:0] == 0xb
15524 OPC_Decode, 234, 124, 254, 1, // 1593: decode to TH_FSURD using decoder 254
15525 // 1593: }
15526 // 1593: } // switch Inst[31:27]
15527 // 1593: }
15528 // 1593: } // switch Inst[14:12]
15529};
15530static const uint8_t DecoderTableXVentana32[40] = {
15531 32, // 0: BitWidth 32
15532 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
15533 6, 16, // 4: case 0x6: {
15534 OPC_CheckPredicate, 172, 1, // 6: check predicate 172
15535 OPC_CheckField, 25, 7, 0, // 9: check Inst[31:25] == 0x0
15536 OPC_CheckField, 0, 7, 123, // 13: check Inst[6:0] == 0x7b
15537 OPC_Decode, 207, 130, 1, 30, // 17: decode to VT_MASKC using decoder 30
15538 // 17: }
15539 7, 0, // 22: case 0x7: {
15540 OPC_CheckPredicate, 172, 1, // 24: check predicate 172
15541 OPC_CheckField, 25, 7, 0, // 27: check Inst[31:25] == 0x0
15542 OPC_CheckField, 0, 7, 123, // 31: check Inst[6:0] == 0x7b
15543 OPC_Decode, 208, 130, 1, 30, // 35: decode to VT_MASKCN using decoder 30
15544 // 35: }
15545 // 35: } // switch Inst[14:12]
15546};
15547static const uint8_t DecoderTableXqci32[1203] = {
15548 32, // 0: BitWidth 32
15549 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
15550 11, 143, 4, // 4: case 0xb: {
15551 OPC_SwitchField, 12, 3, // 7: switch Inst[14:12] {
15552 0, 22, // 10: case 0x0: {
15553 OPC_SwitchField, 31, 1, // 12: switch Inst[31] {
15554 0, 8, // 15: case 0x0: {
15555 OPC_CheckPredicate, 173, 1, // 17: check predicate 173
15556 OPC_Decode, 245, 122, 255, 1, // 20: decode to QC_WRAPI using decoder 255
15557 // 20: }
15558 1, 0, // 25: case 0x1: {
15559 OPC_CheckPredicate, 12, // 27: check predicate 12
15560 OPC_Decode, 179, 122, 128, 2, // 29: decode to QC_INSBRI using decoder 256
15561 // 29: }
15562 // 29: } // switch Inst[31]
15563 // 29: }
15564 1, 30, // 34: case 0x1: {
15565 OPC_SwitchField, 30, 2, // 36: switch Inst[31:30] {
15566 0, 7, // 39: case 0x0: {
15567 OPC_CheckPredicate, 12, // 41: check predicate 12
15568 OPC_Decode, 175, 122, 129, 2, // 43: decode to QC_INSBI using decoder 257
15569 // 43: }
15570 1, 7, // 48: case 0x1: {
15571 OPC_CheckPredicate, 12, // 50: check predicate 12
15572 OPC_Decode, 172, 122, 130, 2, // 52: decode to QC_INSB using decoder 258
15573 // 52: }
15574 2, 0, // 57: case 0x2: {
15575 OPC_CheckPredicate, 12, // 59: check predicate 12
15576 OPC_Decode, 173, 122, 130, 2, // 61: decode to QC_INSBH using decoder 258
15577 // 61: }
15578 // 61: } // switch Inst[31:30]
15579 // 61: }
15580 2, 39, // 66: case 0x2: {
15581 OPC_SwitchField, 30, 2, // 68: switch Inst[31:30] {
15582 0, 7, // 71: case 0x0: {
15583 OPC_CheckPredicate, 12, // 73: check predicate 12
15584 OPC_Decode, 146, 122, 131, 2, // 75: decode to QC_EXTU using decoder 259
15585 // 75: }
15586 1, 7, // 80: case 0x1: {
15587 OPC_CheckPredicate, 12, // 82: check predicate 12
15588 OPC_Decode, 137, 122, 131, 2, // 84: decode to QC_EXT using decoder 259
15589 // 84: }
15590 2, 7, // 89: case 0x2: {
15591 OPC_CheckPredicate, 12, // 91: check predicate 12
15592 OPC_Decode, 142, 122, 132, 2, // 93: decode to QC_EXTDU using decoder 260
15593 // 93: }
15594 3, 0, // 98: case 0x3: {
15595 OPC_CheckPredicate, 12, // 100: check predicate 12
15596 OPC_Decode, 138, 122, 132, 2, // 102: decode to QC_EXTD using decoder 260
15597 // 102: }
15598 // 102: } // switch Inst[31:30]
15599 // 102: }
15600 3, 183, 2, // 107: case 0x3: {
15601 OPC_SwitchField, 30, 2, // 110: switch Inst[31:30] {
15602 0, 168, 2, // 113: case 0x0: {
15603 OPC_SwitchField, 25, 5, // 116: switch Inst[29:25] {
15604 0, 20, // 119: case 0x0: {
15605 OPC_Scope, 11, // 121: try {
15606 OPC_CheckField, 20, 5, 0, // 123: check Inst[24:20] == 0x0
15607 OPC_CheckPredicate, 12, // 127: check predicate 12
15608 OPC_Decode, 238, 121, 133, 2, // 129: decode to QC_COMPRESS2 using decoder 261
15609 // 129: } else try {
15610 OPC_CheckPredicate, 12, // 134: check predicate 12
15611 OPC_Decode, 178, 122, 134, 2, // 136: decode to QC_INSBR using decoder 262
15612 // 136: }
15613 // 136: }
15614 1, 20, // 141: case 0x1: {
15615 OPC_Scope, 11, // 143: try {
15616 OPC_CheckField, 20, 5, 0, // 145: check Inst[24:20] == 0x0
15617 OPC_CheckPredicate, 12, // 149: check predicate 12
15618 OPC_Decode, 239, 121, 133, 2, // 151: decode to QC_COMPRESS3 using decoder 261
15619 // 151: } else try {
15620 OPC_CheckPredicate, 12, // 156: check predicate 12
15621 OPC_Decode, 174, 122, 134, 2, // 158: decode to QC_INSBHR using decoder 262
15622 // 158: }
15623 // 158: }
15624 2, 20, // 163: case 0x2: {
15625 OPC_Scope, 11, // 165: try {
15626 OPC_CheckField, 20, 5, 0, // 167: check Inst[24:20] == 0x0
15627 OPC_CheckPredicate, 12, // 171: check predicate 12
15628 OPC_Decode, 135, 122, 133, 2, // 173: decode to QC_EXPAND2 using decoder 261
15629 // 173: } else try {
15630 OPC_CheckPredicate, 12, // 178: check predicate 12
15631 OPC_Decode, 176, 122, 134, 2, // 180: decode to QC_INSBPR using decoder 262
15632 // 180: }
15633 // 180: }
15634 3, 20, // 185: case 0x3: {
15635 OPC_Scope, 11, // 187: try {
15636 OPC_CheckField, 20, 5, 0, // 189: check Inst[24:20] == 0x0
15637 OPC_CheckPredicate, 12, // 193: check predicate 12
15638 OPC_Decode, 136, 122, 133, 2, // 195: decode to QC_EXPAND3 using decoder 261
15639 // 195: } else try {
15640 OPC_CheckPredicate, 12, // 200: check predicate 12
15641 OPC_Decode, 177, 122, 134, 2, // 202: decode to QC_INSBPRH using decoder 262
15642 // 202: }
15643 // 202: }
15644 4, 20, // 207: case 0x4: {
15645 OPC_Scope, 11, // 209: try {
15646 OPC_CheckField, 20, 5, 0, // 211: check Inst[24:20] == 0x0
15647 OPC_CheckPredicate, 12, // 215: check predicate 12
15648 OPC_Decode, 229, 121, 133, 2, // 217: decode to QC_CLO using decoder 261
15649 // 217: } else try {
15650 OPC_CheckPredicate, 12, // 222: check predicate 12
15651 OPC_Decode, 145, 122, 135, 2, // 224: decode to QC_EXTDUR using decoder 263
15652 // 224: }
15653 // 224: }
15654 5, 20, // 229: case 0x5: {
15655 OPC_Scope, 11, // 231: try {
15656 OPC_CheckField, 20, 5, 0, // 233: check Inst[24:20] == 0x0
15657 OPC_CheckPredicate, 12, // 237: check predicate 12
15658 OPC_Decode, 242, 121, 133, 2, // 239: decode to QC_CTO using decoder 261
15659 // 239: } else try {
15660 OPC_CheckPredicate, 12, // 244: check predicate 12
15661 OPC_Decode, 141, 122, 135, 2, // 246: decode to QC_EXTDR using decoder 263
15662 // 246: }
15663 // 246: }
15664 6, 20, // 251: case 0x6: {
15665 OPC_Scope, 11, // 253: try {
15666 OPC_CheckField, 20, 5, 0, // 255: check Inst[24:20] == 0x0
15667 OPC_CheckPredicate, 12, // 259: check predicate 12
15668 OPC_Decode, 228, 121, 133, 2, // 261: decode to QC_BREV32 using decoder 261
15669 // 261: } else try {
15670 OPC_CheckPredicate, 12, // 266: check predicate 12
15671 OPC_Decode, 143, 122, 135, 2, // 268: decode to QC_EXTDUPR using decoder 263
15672 // 268: }
15673 // 268: }
15674 7, 21, // 273: case 0x7: {
15675 OPC_Scope, 12, // 275: try {
15676 OPC_CheckField, 20, 5, 0, // 277: check Inst[24:20] == 0x0
15677 OPC_CheckPredicate, 173, 1, // 281: check predicate 173
15678 OPC_Decode, 214, 122, 133, 2, // 284: decode to QC_NORM using decoder 261
15679 // 284: } else try {
15680 OPC_CheckPredicate, 12, // 289: check predicate 12
15681 OPC_Decode, 144, 122, 135, 2, // 291: decode to QC_EXTDUPRH using decoder 263
15682 // 291: }
15683 // 291: }
15684 8, 21, // 296: case 0x8: {
15685 OPC_Scope, 12, // 298: try {
15686 OPC_CheckField, 20, 5, 0, // 300: check Inst[24:20] == 0x0
15687 OPC_CheckPredicate, 173, 1, // 304: check predicate 173
15688 OPC_Decode, 216, 122, 133, 2, // 307: decode to QC_NORMU using decoder 261
15689 // 307: } else try {
15690 OPC_CheckPredicate, 12, // 312: check predicate 12
15691 OPC_Decode, 139, 122, 135, 2, // 314: decode to QC_EXTDPR using decoder 263
15692 // 314: }
15693 // 314: }
15694 9, 21, // 319: case 0x9: {
15695 OPC_Scope, 12, // 321: try {
15696 OPC_CheckField, 20, 5, 0, // 323: check Inst[24:20] == 0x0
15697 OPC_CheckPredicate, 173, 1, // 327: check predicate 173
15698 OPC_Decode, 215, 122, 133, 2, // 330: decode to QC_NORMEU using decoder 261
15699 // 330: } else try {
15700 OPC_CheckPredicate, 12, // 335: check predicate 12
15701 OPC_Decode, 140, 122, 135, 2, // 337: decode to QC_EXTDPRH using decoder 263
15702 // 337: }
15703 // 337: }
15704 10, 8, // 342: case 0xa: {
15705 OPC_CheckPredicate, 173, 1, // 344: check predicate 173
15706 OPC_Decode, 231, 122, 136, 2, // 347: decode to QC_SHLSAT using decoder 264
15707 // 347: }
15708 12, 8, // 352: case 0xc: {
15709 OPC_CheckPredicate, 173, 1, // 354: check predicate 173
15710 OPC_Decode, 232, 122, 136, 2, // 357: decode to QC_SHLUSAT using decoder 264
15711 // 357: }
15712 14, 8, // 362: case 0xe: {
15713 OPC_CheckPredicate, 173, 1, // 364: check predicate 173
15714 OPC_Decode, 220, 121, 136, 2, // 367: decode to QC_ADDSAT using decoder 264
15715 // 367: }
15716 15, 8, // 372: case 0xf: {
15717 OPC_CheckPredicate, 173, 1, // 374: check predicate 173
15718 OPC_Decode, 221, 121, 136, 2, // 377: decode to QC_ADDUSAT using decoder 264
15719 // 377: }
15720 16, 8, // 382: case 0x10: {
15721 OPC_CheckPredicate, 173, 1, // 384: check predicate 173
15722 OPC_Decode, 236, 122, 136, 2, // 387: decode to QC_SUBSAT using decoder 264
15723 // 387: }
15724 17, 8, // 392: case 0x11: {
15725 OPC_CheckPredicate, 173, 1, // 394: check predicate 173
15726 OPC_Decode, 237, 122, 136, 2, // 397: decode to QC_SUBUSAT using decoder 264
15727 // 397: }
15728 18, 0, // 402: case 0x12: {
15729 OPC_CheckPredicate, 173, 1, // 404: check predicate 173
15730 OPC_Decode, 244, 122, 137, 2, // 407: decode to QC_WRAP using decoder 265
15731 // 407: }
15732 // 407: } // switch Inst[29:25]
15733 // 407: }
15734 1, 0, // 412: case 0x1: {
15735 OPC_CheckPredicate, 13, // 414: check predicate 13
15736 OPC_Decode, 230, 122, 138, 2, // 416: decode to QC_SHLADD using decoder 266
15737 // 416: }
15738 // 416: } // switch Inst[31:30]
15739 // 416: }
15740 4, 8, // 421: case 0x4: {
15741 OPC_CheckPredicate, 174, 1, // 423: check predicate 174
15742 OPC_Decode, 217, 122, 139, 2, // 426: decode to QC_OUTW using decoder 267
15743 // 426: }
15744 5, 8, // 431: case 0x5: {
15745 OPC_CheckPredicate, 174, 1, // 433: check predicate 174
15746 OPC_Decode, 180, 122, 140, 2, // 436: decode to QC_INW using decoder 268
15747 // 436: }
15748 6, 7, // 441: case 0x6: {
15749 OPC_CheckPredicate, 13, // 443: check predicate 13
15750 OPC_Decode, 201, 122, 141, 2, // 445: decode to QC_MULIADD using decoder 269
15751 // 445: }
15752 7, 0, // 450: case 0x7: {
15753 OPC_SwitchField, 30, 2, // 452: switch Inst[31:30] {
15754 0, 8, // 455: case 0x0: {
15755 OPC_CheckPredicate, 175, 1, // 457: check predicate 175
15756 OPC_Decode, 199, 122, 142, 2, // 460: decode to QC_LWM using decoder 270
15757 // 460: }
15758 1, 8, // 465: case 0x1: {
15759 OPC_CheckPredicate, 175, 1, // 467: check predicate 175
15760 OPC_Decode, 200, 122, 143, 2, // 470: decode to QC_LWMI using decoder 271
15761 // 470: }
15762 2, 43, // 475: case 0x2: {
15763 OPC_SwitchField, 28, 2, // 477: switch Inst[29:28] {
15764 0, 8, // 480: case 0x0: {
15765 OPC_CheckPredicate, 176, 1, // 482: check predicate 176
15766 OPC_Decode, 194, 122, 144, 2, // 485: decode to QC_LRB using decoder 272
15767 // 485: }
15768 1, 8, // 490: case 0x1: {
15769 OPC_CheckPredicate, 176, 1, // 492: check predicate 176
15770 OPC_Decode, 196, 122, 144, 2, // 495: decode to QC_LRH using decoder 272
15771 // 495: }
15772 2, 8, // 500: case 0x2: {
15773 OPC_CheckPredicate, 176, 1, // 502: check predicate 176
15774 OPC_Decode, 198, 122, 144, 2, // 505: decode to QC_LRW using decoder 272
15775 // 505: }
15776 3, 0, // 510: case 0x3: {
15777 OPC_CheckPredicate, 176, 1, // 512: check predicate 176
15778 OPC_Decode, 195, 122, 144, 2, // 515: decode to QC_LRBU using decoder 272
15779 // 515: }
15780 // 515: } // switch Inst[29:28]
15781 // 515: }
15782 3, 0, // 520: case 0x3: {
15783 OPC_CheckPredicate, 176, 1, // 522: check predicate 176
15784 OPC_CheckField, 28, 2, 0, // 525: check Inst[29:28] == 0x0
15785 OPC_Decode, 197, 122, 144, 2, // 529: decode to QC_LRHU using decoder 272
15786 // 529: }
15787 // 529: } // switch Inst[31:30]
15788 // 529: }
15789 // 529: } // switch Inst[14:12]
15790 // 529: }
15791 19, 82, // 534: case 0x13: {
15792 OPC_SwitchField, 28, 4, // 536: switch Inst[31:28] {
15793 1, 15, // 539: case 0x1: {
15794 OPC_CheckPredicate, 14, // 541: check predicate 14
15795 OPC_CheckField, 25, 3, 0, // 543: check Inst[27:25] == 0x0
15796 OPC_CheckField, 7, 13, 96, // 547: check Inst[19:7] == 0x60
15797 OPC_Decode, 240, 122, 145, 2, // 551: decode to QC_SYNC using decoder 273
15798 // 551: }
15799 2, 15, // 556: case 0x2: {
15800 OPC_CheckPredicate, 14, // 558: check predicate 14
15801 OPC_CheckField, 25, 3, 0, // 560: check Inst[27:25] == 0x0
15802 OPC_CheckField, 7, 13, 96, // 564: check Inst[19:7] == 0x60
15803 OPC_Decode, 241, 122, 145, 2, // 568: decode to QC_SYNCR using decoder 273
15804 // 568: }
15805 4, 26, // 573: case 0x4: {
15806 OPC_SwitchField, 7, 13, // 575: switch Inst[19:7] {
15807 64, 8, // 578: case 0x40: {
15808 OPC_CheckPredicate, 177, 1, // 580: check predicate 177
15809 OPC_Decode, 218, 122, 146, 2, // 583: decode to QC_PPUTCI using decoder 274
15810 // 583: }
15811 96, 0, // 588: case 0x60: {
15812 OPC_CheckPredicate, 14, // 590: check predicate 14
15813 OPC_CheckField, 25, 3, 0, // 592: check Inst[27:25] == 0x0
15814 OPC_Decode, 242, 122, 145, 2, // 596: decode to QC_SYNCWF using decoder 273
15815 // 596: }
15816 // 596: } // switch Inst[19:7]
15817 // 596: }
15818 8, 0, // 601: case 0x8: {
15819 OPC_CheckPredicate, 14, // 603: check predicate 14
15820 OPC_CheckField, 25, 3, 0, // 605: check Inst[27:25] == 0x0
15821 OPC_CheckField, 7, 13, 96, // 609: check Inst[19:7] == 0x60
15822 OPC_Decode, 243, 122, 145, 2, // 613: decode to QC_SYNCWL using decoder 273
15823 // 613: }
15824 // 613: } // switch Inst[31:28]
15825 // 613: }
15826 27, 8, // 618: case 0x1b: {
15827 OPC_CheckPredicate, 178, 1, // 620: check predicate 178
15828 OPC_Decode, 181, 122, 147, 2, // 623: decode to QC_LI using decoder 275
15829 // 623: }
15830 43, 95, // 628: case 0x2b: {
15831 OPC_SwitchField, 30, 2, // 630: switch Inst[31:30] {
15832 0, 12, // 633: case 0x0: {
15833 OPC_CheckPredicate, 175, 1, // 635: check predicate 175
15834 OPC_CheckField, 12, 3, 7, // 638: check Inst[14:12] == 0x7
15835 OPC_Decode, 238, 122, 142, 2, // 642: decode to QC_SWM using decoder 270
15836 // 642: }
15837 1, 12, // 647: case 0x1: {
15838 OPC_CheckPredicate, 175, 1, // 649: check predicate 175
15839 OPC_CheckField, 12, 3, 7, // 652: check Inst[14:12] == 0x7
15840 OPC_Decode, 239, 122, 143, 2, // 656: decode to QC_SWMI using decoder 271
15841 // 656: }
15842 2, 12, // 661: case 0x2: {
15843 OPC_CheckPredicate, 175, 1, // 663: check predicate 175
15844 OPC_CheckField, 12, 3, 7, // 666: check Inst[14:12] == 0x7
15845 OPC_Decode, 228, 122, 148, 2, // 670: decode to QC_SETWM using decoder 276
15846 // 670: }
15847 3, 0, // 675: case 0x3: {
15848 OPC_SwitchField, 12, 3, // 677: switch Inst[14:12] {
15849 6, 33, // 680: case 0x6: {
15850 OPC_SwitchField, 28, 2, // 682: switch Inst[29:28] {
15851 1, 8, // 685: case 0x1: {
15852 OPC_CheckPredicate, 176, 1, // 687: check predicate 176
15853 OPC_Decode, 233, 122, 144, 2, // 690: decode to QC_SRB using decoder 272
15854 // 690: }
15855 2, 8, // 695: case 0x2: {
15856 OPC_CheckPredicate, 176, 1, // 697: check predicate 176
15857 OPC_Decode, 234, 122, 144, 2, // 700: decode to QC_SRH using decoder 272
15858 // 700: }
15859 3, 0, // 705: case 0x3: {
15860 OPC_CheckPredicate, 176, 1, // 707: check predicate 176
15861 OPC_Decode, 235, 122, 144, 2, // 710: decode to QC_SRW using decoder 272
15862 // 710: }
15863 // 710: } // switch Inst[29:28]
15864 // 710: }
15865 7, 0, // 715: case 0x7: {
15866 OPC_CheckPredicate, 175, 1, // 717: check predicate 175
15867 OPC_Decode, 229, 122, 149, 2, // 720: decode to QC_SETWMI using decoder 277
15868 // 720: }
15869 // 720: } // switch Inst[14:12]
15870 // 720: }
15871 // 720: } // switch Inst[31:30]
15872 // 720: }
15873 91, 223, 2, // 725: case 0x5b: {
15874 OPC_SwitchField, 12, 3, // 728: switch Inst[14:12] {
15875 0, 41, // 731: case 0x0: {
15876 OPC_SwitchField, 25, 2, // 733: switch Inst[26:25] {
15877 0, 7, // 736: case 0x0: {
15878 OPC_CheckPredicate, 15, // 738: check predicate 15
15879 OPC_Decode, 202, 122, 150, 2, // 740: decode to QC_MVEQ using decoder 278
15880 // 740: }
15881 1, 8, // 745: case 0x1: {
15882 OPC_CheckPredicate, 179, 1, // 747: check predicate 179
15883 OPC_Decode, 182, 122, 151, 2, // 750: decode to QC_LIEQ using decoder 279
15884 // 750: }
15885 2, 7, // 755: case 0x2: {
15886 OPC_CheckPredicate, 15, // 757: check predicate 15
15887 OPC_Decode, 203, 122, 152, 2, // 759: decode to QC_MVEQI using decoder 280
15888 // 759: }
15889 3, 0, // 764: case 0x3: {
15890 OPC_CheckPredicate, 179, 1, // 766: check predicate 179
15891 OPC_Decode, 183, 122, 153, 2, // 769: decode to QC_LIEQI using decoder 281
15892 // 769: }
15893 // 769: } // switch Inst[26:25]
15894 // 769: }
15895 1, 41, // 774: case 0x1: {
15896 OPC_SwitchField, 25, 2, // 776: switch Inst[26:25] {
15897 0, 7, // 779: case 0x0: {
15898 OPC_CheckPredicate, 15, // 781: check predicate 15
15899 OPC_Decode, 212, 122, 150, 2, // 783: decode to QC_MVNE using decoder 278
15900 // 783: }
15901 1, 8, // 788: case 0x1: {
15902 OPC_CheckPredicate, 179, 1, // 790: check predicate 179
15903 OPC_Decode, 192, 122, 151, 2, // 793: decode to QC_LINE using decoder 279
15904 // 793: }
15905 2, 7, // 798: case 0x2: {
15906 OPC_CheckPredicate, 15, // 800: check predicate 15
15907 OPC_Decode, 213, 122, 152, 2, // 802: decode to QC_MVNEI using decoder 280
15908 // 802: }
15909 3, 0, // 807: case 0x3: {
15910 OPC_CheckPredicate, 179, 1, // 809: check predicate 179
15911 OPC_Decode, 193, 122, 153, 2, // 812: decode to QC_LINEI using decoder 281
15912 // 812: }
15913 // 812: } // switch Inst[26:25]
15914 // 812: }
15915 2, 43, // 817: case 0x2: {
15916 OPC_SwitchField, 25, 2, // 819: switch Inst[26:25] {
15917 0, 8, // 822: case 0x0: {
15918 OPC_CheckPredicate, 180, 1, // 824: check predicate 180
15919 OPC_Decode, 222, 122, 153, 2, // 827: decode to QC_SELECTIIEQ using decoder 281
15920 // 827: }
15921 1, 8, // 832: case 0x1: {
15922 OPC_CheckPredicate, 180, 1, // 834: check predicate 180
15923 OPC_Decode, 220, 122, 151, 2, // 837: decode to QC_SELECTIEQ using decoder 279
15924 // 837: }
15925 2, 8, // 842: case 0x2: {
15926 OPC_CheckPredicate, 180, 1, // 844: check predicate 180
15927 OPC_Decode, 219, 122, 154, 2, // 847: decode to QC_SELECTEQI using decoder 282
15928 // 847: }
15929 3, 0, // 852: case 0x3: {
15930 OPC_CheckPredicate, 180, 1, // 854: check predicate 180
15931 OPC_Decode, 221, 122, 155, 2, // 857: decode to QC_SELECTIEQI using decoder 283
15932 // 857: }
15933 // 857: } // switch Inst[26:25]
15934 // 857: }
15935 3, 43, // 862: case 0x3: {
15936 OPC_SwitchField, 25, 2, // 864: switch Inst[26:25] {
15937 0, 8, // 867: case 0x0: {
15938 OPC_CheckPredicate, 180, 1, // 869: check predicate 180
15939 OPC_Decode, 223, 122, 153, 2, // 872: decode to QC_SELECTIINE using decoder 281
15940 // 872: }
15941 1, 8, // 877: case 0x1: {
15942 OPC_CheckPredicate, 180, 1, // 879: check predicate 180
15943 OPC_Decode, 224, 122, 151, 2, // 882: decode to QC_SELECTINE using decoder 279
15944 // 882: }
15945 2, 8, // 887: case 0x2: {
15946 OPC_CheckPredicate, 180, 1, // 889: check predicate 180
15947 OPC_Decode, 226, 122, 154, 2, // 892: decode to QC_SELECTNEI using decoder 282
15948 // 892: }
15949 3, 0, // 897: case 0x3: {
15950 OPC_CheckPredicate, 180, 1, // 899: check predicate 180
15951 OPC_Decode, 225, 122, 155, 2, // 902: decode to QC_SELECTINEI using decoder 283
15952 // 902: }
15953 // 902: } // switch Inst[26:25]
15954 // 902: }
15955 4, 41, // 907: case 0x4: {
15956 OPC_SwitchField, 25, 2, // 909: switch Inst[26:25] {
15957 0, 7, // 912: case 0x0: {
15958 OPC_CheckPredicate, 15, // 914: check predicate 15
15959 OPC_Decode, 208, 122, 150, 2, // 916: decode to QC_MVLT using decoder 278
15960 // 916: }
15961 1, 8, // 921: case 0x1: {
15962 OPC_CheckPredicate, 179, 1, // 923: check predicate 179
15963 OPC_Decode, 188, 122, 151, 2, // 926: decode to QC_LILT using decoder 279
15964 // 926: }
15965 2, 7, // 931: case 0x2: {
15966 OPC_CheckPredicate, 15, // 933: check predicate 15
15967 OPC_Decode, 209, 122, 152, 2, // 935: decode to QC_MVLTI using decoder 280
15968 // 935: }
15969 3, 0, // 940: case 0x3: {
15970 OPC_CheckPredicate, 179, 1, // 942: check predicate 179
15971 OPC_Decode, 189, 122, 153, 2, // 945: decode to QC_LILTI using decoder 281
15972 // 945: }
15973 // 945: } // switch Inst[26:25]
15974 // 945: }
15975 5, 41, // 950: case 0x5: {
15976 OPC_SwitchField, 25, 2, // 952: switch Inst[26:25] {
15977 0, 7, // 955: case 0x0: {
15978 OPC_CheckPredicate, 15, // 957: check predicate 15
15979 OPC_Decode, 204, 122, 150, 2, // 959: decode to QC_MVGE using decoder 278
15980 // 959: }
15981 1, 8, // 964: case 0x1: {
15982 OPC_CheckPredicate, 179, 1, // 966: check predicate 179
15983 OPC_Decode, 184, 122, 151, 2, // 969: decode to QC_LIGE using decoder 279
15984 // 969: }
15985 2, 7, // 974: case 0x2: {
15986 OPC_CheckPredicate, 15, // 976: check predicate 15
15987 OPC_Decode, 205, 122, 152, 2, // 978: decode to QC_MVGEI using decoder 280
15988 // 978: }
15989 3, 0, // 983: case 0x3: {
15990 OPC_CheckPredicate, 179, 1, // 985: check predicate 179
15991 OPC_Decode, 185, 122, 153, 2, // 988: decode to QC_LIGEI using decoder 281
15992 // 988: }
15993 // 988: } // switch Inst[26:25]
15994 // 988: }
15995 6, 41, // 993: case 0x6: {
15996 OPC_SwitchField, 25, 2, // 995: switch Inst[26:25] {
15997 0, 7, // 998: case 0x0: {
15998 OPC_CheckPredicate, 15, // 1000: check predicate 15
15999 OPC_Decode, 210, 122, 150, 2, // 1002: decode to QC_MVLTU using decoder 278
16000 // 1002: }
16001 1, 8, // 1007: case 0x1: {
16002 OPC_CheckPredicate, 179, 1, // 1009: check predicate 179
16003 OPC_Decode, 190, 122, 151, 2, // 1012: decode to QC_LILTU using decoder 279
16004 // 1012: }
16005 2, 7, // 1017: case 0x2: {
16006 OPC_CheckPredicate, 15, // 1019: check predicate 15
16007 OPC_Decode, 211, 122, 156, 2, // 1021: decode to QC_MVLTUI using decoder 284
16008 // 1021: }
16009 3, 0, // 1026: case 0x3: {
16010 OPC_CheckPredicate, 179, 1, // 1028: check predicate 179
16011 OPC_Decode, 191, 122, 157, 2, // 1031: decode to QC_LILTUI using decoder 285
16012 // 1031: }
16013 // 1031: } // switch Inst[26:25]
16014 // 1031: }
16015 7, 0, // 1036: case 0x7: {
16016 OPC_SwitchField, 25, 2, // 1038: switch Inst[26:25] {
16017 0, 7, // 1041: case 0x0: {
16018 OPC_CheckPredicate, 15, // 1043: check predicate 15
16019 OPC_Decode, 206, 122, 150, 2, // 1045: decode to QC_MVGEU using decoder 278
16020 // 1045: }
16021 1, 8, // 1050: case 0x1: {
16022 OPC_CheckPredicate, 179, 1, // 1052: check predicate 179
16023 OPC_Decode, 186, 122, 151, 2, // 1055: decode to QC_LIGEU using decoder 279
16024 // 1055: }
16025 2, 7, // 1060: case 0x2: {
16026 OPC_CheckPredicate, 15, // 1062: check predicate 15
16027 OPC_Decode, 207, 122, 156, 2, // 1064: decode to QC_MVGEUI using decoder 284
16028 // 1064: }
16029 3, 0, // 1069: case 0x3: {
16030 OPC_CheckPredicate, 179, 1, // 1071: check predicate 179
16031 OPC_Decode, 187, 122, 157, 2, // 1074: decode to QC_LIGEUI using decoder 285
16032 // 1074: }
16033 // 1074: } // switch Inst[26:25]
16034 // 1074: }
16035 // 1074: } // switch Inst[14:12]
16036 // 1074: }
16037 115, 57, // 1079: case 0x73: {
16038 OPC_SwitchField, 25, 7, // 1081: switch Inst[31:25] {
16039 70, 12, // 1084: case 0x46: {
16040 OPC_CheckPredicate, 181, 1, // 1086: check predicate 181
16041 OPC_CheckField, 12, 3, 0, // 1089: check Inst[14:12] == 0x0
16042 OPC_Decode, 240, 121, 158, 2, // 1093: decode to QC_CSRRWR using decoder 286
16043 // 1093: }
16044 71, 12, // 1098: case 0x47: {
16045 OPC_CheckPredicate, 181, 1, // 1100: check predicate 181
16046 OPC_CheckField, 12, 3, 0, // 1103: check Inst[14:12] == 0x0
16047 OPC_Decode, 241, 121, 159, 2, // 1107: decode to QC_CSRRWRI using decoder 287
16048 // 1107: }
16049 102, 11, // 1112: case 0x66: {
16050 OPC_CheckPredicate, 11, // 1114: check predicate 11
16051 OPC_CheckField, 7, 8, 0, // 1116: check Inst[14:7] == 0x0
16052 OPC_Decode, 227, 122, 160, 2, // 1120: decode to QC_SETINTI using decoder 288
16053 // 1120: }
16054 103, 0, // 1125: case 0x67: {
16055 OPC_CheckPredicate, 11, // 1127: check predicate 11
16056 OPC_CheckField, 7, 8, 0, // 1129: check Inst[14:7] == 0x0
16057 OPC_Decode, 230, 121, 160, 2, // 1133: decode to QC_CLRINTI using decoder 288
16058 // 1133: }
16059 // 1133: } // switch Inst[31:25]
16060 // 1133: }
16061 123, 0, // 1138: case 0x7b: {
16062 OPC_SwitchField, 12, 3, // 1140: switch Inst[14:12] {
16063 0, 8, // 1143: case 0x0: {
16064 OPC_CheckPredicate, 182, 1, // 1145: check predicate 182
16065 OPC_Decode, 222, 121, 161, 2, // 1148: decode to QC_BEQI using decoder 289
16066 // 1148: }
16067 1, 8, // 1153: case 0x1: {
16068 OPC_CheckPredicate, 182, 1, // 1155: check predicate 182
16069 OPC_Decode, 227, 121, 161, 2, // 1158: decode to QC_BNEI using decoder 289
16070 // 1158: }
16071 4, 8, // 1163: case 0x4: {
16072 OPC_CheckPredicate, 182, 1, // 1165: check predicate 182
16073 OPC_Decode, 225, 121, 161, 2, // 1168: decode to QC_BLTI using decoder 289
16074 // 1168: }
16075 5, 8, // 1173: case 0x5: {
16076 OPC_CheckPredicate, 182, 1, // 1175: check predicate 182
16077 OPC_Decode, 223, 121, 161, 2, // 1178: decode to QC_BGEI using decoder 289
16078 // 1178: }
16079 6, 8, // 1183: case 0x6: {
16080 OPC_CheckPredicate, 182, 1, // 1185: check predicate 182
16081 OPC_Decode, 226, 121, 162, 2, // 1188: decode to QC_BLTUI using decoder 290
16082 // 1188: }
16083 7, 0, // 1193: case 0x7: {
16084 OPC_CheckPredicate, 182, 1, // 1195: check predicate 182
16085 OPC_Decode, 224, 121, 162, 2, // 1198: decode to QC_BGEUI using decoder 290
16086 // 1198: }
16087 // 1198: } // switch Inst[14:12]
16088 // 1198: }
16089 // 1198: } // switch Inst[6:0]
16090};
16091static const uint8_t DecoderTableZdinxGPRPairRV3232[34] = {
16092 32, // 0: BitWidth 32
16093 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
16094 162, 8, 12, // 4: case 0x422: {
16095 OPC_CheckPredicate, 183, 1, // 7: check predicate 183
16096 OPC_CheckField, 0, 7, 83, // 10: check Inst[6:0] == 0x53
16097 OPC_Decode, 251, 113, 163, 2, // 14: decode to FCVT_D_H_IN32X using decoder 291
16098 // 14: }
16099 193, 8, 0, // 19: case 0x441: {
16100 OPC_CheckPredicate, 183, 1, // 22: check predicate 183
16101 OPC_CheckField, 0, 7, 83, // 25: check Inst[6:0] == 0x53
16102 OPC_Decode, 140, 114, 164, 2, // 29: decode to FCVT_H_D_IN32X using decoder 292
16103 // 29: }
16104 // 29: } // switch Inst[31:20]
16105};
16106static const uint8_t DecoderTableZdinxRV32Only32[310] = {
16107 32, // 0: BitWidth 32
16108 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16109 67, 12, // 4: case 0x43: {
16110 OPC_CheckPredicate, 184, 1, // 6: check predicate 184
16111 OPC_CheckField, 25, 2, 1, // 9: check Inst[26:25] == 0x1
16112 OPC_Decode, 255, 114, 165, 2, // 13: decode to FMADD_D_IN32X using decoder 293
16113 // 13: }
16114 71, 12, // 18: case 0x47: {
16115 OPC_CheckPredicate, 184, 1, // 20: check predicate 184
16116 OPC_CheckField, 25, 2, 1, // 23: check Inst[26:25] == 0x1
16117 OPC_Decode, 159, 115, 165, 2, // 27: decode to FMSUB_D_IN32X using decoder 293
16118 // 27: }
16119 75, 12, // 32: case 0x4b: {
16120 OPC_CheckPredicate, 184, 1, // 34: check predicate 184
16121 OPC_CheckField, 25, 2, 1, // 37: check Inst[26:25] == 0x1
16122 OPC_Decode, 194, 115, 165, 2, // 41: decode to FNMSUB_D_IN32X using decoder 293
16123 // 41: }
16124 79, 12, // 46: case 0x4f: {
16125 OPC_CheckPredicate, 184, 1, // 48: check predicate 184
16126 OPC_CheckField, 25, 2, 1, // 51: check Inst[26:25] == 0x1
16127 OPC_Decode, 186, 115, 165, 2, // 55: decode to FNMADD_D_IN32X using decoder 293
16128 // 55: }
16129 83, 0, // 60: case 0x53: {
16130 OPC_SwitchField, 25, 7, // 62: switch Inst[31:25] {
16131 1, 8, // 65: case 0x1: {
16132 OPC_CheckPredicate, 184, 1, // 67: check predicate 184
16133 OPC_Decode, 233, 113, 166, 2, // 70: decode to FADD_D_IN32X using decoder 294
16134 // 70: }
16135 5, 8, // 75: case 0x5: {
16136 OPC_CheckPredicate, 184, 1, // 77: check predicate 184
16137 OPC_Decode, 245, 115, 166, 2, // 80: decode to FSUB_D_IN32X using decoder 294
16138 // 80: }
16139 9, 8, // 85: case 0x9: {
16140 OPC_CheckPredicate, 184, 1, // 87: check predicate 184
16141 OPC_Decode, 167, 115, 166, 2, // 90: decode to FMUL_D_IN32X using decoder 294
16142 // 90: }
16143 13, 8, // 95: case 0xd: {
16144 OPC_CheckPredicate, 184, 1, // 97: check predicate 184
16145 OPC_Decode, 204, 114, 166, 2, // 100: decode to FDIV_D_IN32X using decoder 294
16146 // 100: }
16147 17, 33, // 105: case 0x11: {
16148 OPC_SwitchField, 12, 3, // 107: switch Inst[14:12] {
16149 0, 8, // 110: case 0x0: {
16150 OPC_CheckPredicate, 184, 1, // 112: check predicate 184
16151 OPC_Decode, 227, 115, 167, 2, // 115: decode to FSGNJ_D_IN32X using decoder 295
16152 // 115: }
16153 1, 8, // 120: case 0x1: {
16154 OPC_CheckPredicate, 184, 1, // 122: check predicate 184
16155 OPC_Decode, 211, 115, 167, 2, // 125: decode to FSGNJN_D_IN32X using decoder 295
16156 // 125: }
16157 2, 0, // 130: case 0x2: {
16158 OPC_CheckPredicate, 184, 1, // 132: check predicate 184
16159 OPC_Decode, 219, 115, 167, 2, // 135: decode to FSGNJX_D_IN32X using decoder 295
16160 // 135: }
16161 // 135: } // switch Inst[14:12]
16162 // 135: }
16163 21, 23, // 140: case 0x15: {
16164 OPC_SwitchField, 12, 3, // 142: switch Inst[14:12] {
16165 0, 8, // 145: case 0x0: {
16166 OPC_CheckPredicate, 184, 1, // 147: check predicate 184
16167 OPC_Decode, 151, 115, 167, 2, // 150: decode to FMIN_D_IN32X using decoder 295
16168 // 150: }
16169 1, 0, // 155: case 0x1: {
16170 OPC_CheckPredicate, 184, 1, // 157: check predicate 184
16171 OPC_Decode, 139, 115, 167, 2, // 160: decode to FMAX_D_IN32X using decoder 295
16172 // 160: }
16173 // 160: } // switch Inst[14:12]
16174 // 160: }
16175 32, 12, // 165: case 0x20: {
16176 OPC_CheckPredicate, 184, 1, // 167: check predicate 184
16177 OPC_CheckField, 20, 5, 1, // 170: check Inst[24:20] == 0x1
16178 OPC_Decode, 174, 114, 168, 2, // 174: decode to FCVT_S_D_IN32X using decoder 296
16179 // 174: }
16180 33, 12, // 179: case 0x21: {
16181 OPC_CheckPredicate, 184, 1, // 181: check predicate 184
16182 OPC_CheckField, 20, 5, 0, // 184: check Inst[24:20] == 0x0
16183 OPC_Decode, 131, 114, 169, 2, // 188: decode to FCVT_D_S_IN32X using decoder 297
16184 // 188: }
16185 45, 12, // 193: case 0x2d: {
16186 OPC_CheckPredicate, 184, 1, // 195: check predicate 184
16187 OPC_CheckField, 20, 5, 0, // 198: check Inst[24:20] == 0x0
16188 OPC_Decode, 237, 115, 170, 2, // 202: decode to FSQRT_D_IN32X using decoder 298
16189 // 202: }
16190 81, 33, // 207: case 0x51: {
16191 OPC_SwitchField, 12, 3, // 209: switch Inst[14:12] {
16192 0, 8, // 212: case 0x0: {
16193 OPC_CheckPredicate, 184, 1, // 214: check predicate 184
16194 OPC_Decode, 228, 114, 171, 2, // 217: decode to FLE_D_IN32X using decoder 299
16195 // 217: }
16196 1, 8, // 222: case 0x1: {
16197 OPC_CheckPredicate, 184, 1, // 224: check predicate 184
16198 OPC_Decode, 246, 114, 171, 2, // 227: decode to FLT_D_IN32X using decoder 299
16199 // 227: }
16200 2, 0, // 232: case 0x2: {
16201 OPC_CheckPredicate, 184, 1, // 234: check predicate 184
16202 OPC_Decode, 215, 114, 171, 2, // 237: decode to FEQ_D_IN32X using decoder 299
16203 // 237: }
16204 // 237: } // switch Inst[14:12]
16205 // 237: }
16206 97, 23, // 242: case 0x61: {
16207 OPC_SwitchField, 20, 5, // 244: switch Inst[24:20] {
16208 0, 8, // 247: case 0x0: {
16209 OPC_CheckPredicate, 184, 1, // 249: check predicate 184
16210 OPC_Decode, 196, 114, 172, 2, // 252: decode to FCVT_W_D_IN32X using decoder 300
16211 // 252: }
16212 1, 0, // 257: case 0x1: {
16213 OPC_CheckPredicate, 184, 1, // 259: check predicate 184
16214 OPC_Decode, 188, 114, 172, 2, // 262: decode to FCVT_WU_D_IN32X using decoder 300
16215 // 262: }
16216 // 262: } // switch Inst[24:20]
16217 // 262: }
16218 105, 23, // 267: case 0x69: {
16219 OPC_SwitchField, 20, 5, // 269: switch Inst[24:20] {
16220 0, 8, // 272: case 0x0: {
16221 OPC_CheckPredicate, 184, 1, // 274: check predicate 184
16222 OPC_Decode, 137, 114, 173, 2, // 277: decode to FCVT_D_W_IN32X using decoder 301
16223 // 277: }
16224 1, 0, // 282: case 0x1: {
16225 OPC_CheckPredicate, 184, 1, // 284: check predicate 184
16226 OPC_Decode, 135, 114, 173, 2, // 287: decode to FCVT_D_WU_IN32X using decoder 301
16227 // 287: }
16228 // 287: } // switch Inst[24:20]
16229 // 287: }
16230 113, 0, // 292: case 0x71: {
16231 OPC_CheckPredicate, 184, 1, // 294: check predicate 184
16232 OPC_CheckField, 20, 5, 0, // 297: check Inst[24:20] == 0x0
16233 OPC_CheckField, 12, 3, 1, // 301: check Inst[14:12] == 0x1
16234 OPC_Decode, 241, 113, 174, 2, // 305: decode to FCLASS_D_IN32X using decoder 302
16235 // 305: }
16236 // 305: } // switch Inst[31:25]
16237 // 305: }
16238 // 305: } // switch Inst[6:0]
16239};
16240static const uint8_t DecoderTableZfinx32[986] = {
16241 32, // 0: BitWidth 32
16242 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16243 67, 33, // 4: case 0x43: {
16244 OPC_SwitchField, 25, 2, // 6: switch Inst[26:25] {
16245 0, 8, // 9: case 0x0: {
16246 OPC_CheckPredicate, 185, 1, // 11: check predicate 185
16247 OPC_Decode, 133, 115, 175, 2, // 14: decode to FMADD_S_INX using decoder 303
16248 // 14: }
16249 1, 8, // 19: case 0x1: {
16250 OPC_CheckPredicate, 186, 1, // 21: check predicate 186
16251 OPC_Decode, 128, 115, 176, 2, // 24: decode to FMADD_D_INX using decoder 304
16252 // 24: }
16253 2, 0, // 29: case 0x2: {
16254 OPC_CheckPredicate, 187, 1, // 31: check predicate 187
16255 OPC_Decode, 130, 115, 177, 2, // 34: decode to FMADD_H_INX using decoder 305
16256 // 34: }
16257 // 34: } // switch Inst[26:25]
16258 // 34: }
16259 71, 33, // 39: case 0x47: {
16260 OPC_SwitchField, 25, 2, // 41: switch Inst[26:25] {
16261 0, 8, // 44: case 0x0: {
16262 OPC_CheckPredicate, 185, 1, // 46: check predicate 185
16263 OPC_Decode, 165, 115, 175, 2, // 49: decode to FMSUB_S_INX using decoder 303
16264 // 49: }
16265 1, 8, // 54: case 0x1: {
16266 OPC_CheckPredicate, 186, 1, // 56: check predicate 186
16267 OPC_Decode, 160, 115, 176, 2, // 59: decode to FMSUB_D_INX using decoder 304
16268 // 59: }
16269 2, 0, // 64: case 0x2: {
16270 OPC_CheckPredicate, 187, 1, // 66: check predicate 187
16271 OPC_Decode, 162, 115, 177, 2, // 69: decode to FMSUB_H_INX using decoder 305
16272 // 69: }
16273 // 69: } // switch Inst[26:25]
16274 // 69: }
16275 75, 33, // 74: case 0x4b: {
16276 OPC_SwitchField, 25, 2, // 76: switch Inst[26:25] {
16277 0, 8, // 79: case 0x0: {
16278 OPC_CheckPredicate, 185, 1, // 81: check predicate 185
16279 OPC_Decode, 200, 115, 175, 2, // 84: decode to FNMSUB_S_INX using decoder 303
16280 // 84: }
16281 1, 8, // 89: case 0x1: {
16282 OPC_CheckPredicate, 186, 1, // 91: check predicate 186
16283 OPC_Decode, 195, 115, 176, 2, // 94: decode to FNMSUB_D_INX using decoder 304
16284 // 94: }
16285 2, 0, // 99: case 0x2: {
16286 OPC_CheckPredicate, 187, 1, // 101: check predicate 187
16287 OPC_Decode, 197, 115, 177, 2, // 104: decode to FNMSUB_H_INX using decoder 305
16288 // 104: }
16289 // 104: } // switch Inst[26:25]
16290 // 104: }
16291 79, 33, // 109: case 0x4f: {
16292 OPC_SwitchField, 25, 2, // 111: switch Inst[26:25] {
16293 0, 8, // 114: case 0x0: {
16294 OPC_CheckPredicate, 185, 1, // 116: check predicate 185
16295 OPC_Decode, 192, 115, 175, 2, // 119: decode to FNMADD_S_INX using decoder 303
16296 // 119: }
16297 1, 8, // 124: case 0x1: {
16298 OPC_CheckPredicate, 186, 1, // 126: check predicate 186
16299 OPC_Decode, 187, 115, 176, 2, // 129: decode to FNMADD_D_INX using decoder 304
16300 // 129: }
16301 2, 0, // 134: case 0x2: {
16302 OPC_CheckPredicate, 187, 1, // 136: check predicate 187
16303 OPC_Decode, 189, 115, 177, 2, // 139: decode to FNMADD_H_INX using decoder 305
16304 // 139: }
16305 // 139: } // switch Inst[26:25]
16306 // 139: }
16307 83, 0, // 144: case 0x53: {
16308 OPC_SwitchField, 25, 7, // 146: switch Inst[31:25] {
16309 0, 8, // 149: case 0x0: {
16310 OPC_CheckPredicate, 185, 1, // 151: check predicate 185
16311 OPC_Decode, 239, 113, 178, 2, // 154: decode to FADD_S_INX using decoder 306
16312 // 154: }
16313 1, 8, // 159: case 0x1: {
16314 OPC_CheckPredicate, 186, 1, // 161: check predicate 186
16315 OPC_Decode, 234, 113, 179, 2, // 164: decode to FADD_D_INX using decoder 307
16316 // 164: }
16317 2, 8, // 169: case 0x2: {
16318 OPC_CheckPredicate, 187, 1, // 171: check predicate 187
16319 OPC_Decode, 236, 113, 180, 2, // 174: decode to FADD_H_INX using decoder 308
16320 // 174: }
16321 4, 8, // 179: case 0x4: {
16322 OPC_CheckPredicate, 185, 1, // 181: check predicate 185
16323 OPC_Decode, 251, 115, 178, 2, // 184: decode to FSUB_S_INX using decoder 306
16324 // 184: }
16325 5, 8, // 189: case 0x5: {
16326 OPC_CheckPredicate, 186, 1, // 191: check predicate 186
16327 OPC_Decode, 246, 115, 179, 2, // 194: decode to FSUB_D_INX using decoder 307
16328 // 194: }
16329 6, 8, // 199: case 0x6: {
16330 OPC_CheckPredicate, 187, 1, // 201: check predicate 187
16331 OPC_Decode, 248, 115, 180, 2, // 204: decode to FSUB_H_INX using decoder 308
16332 // 204: }
16333 8, 8, // 209: case 0x8: {
16334 OPC_CheckPredicate, 185, 1, // 211: check predicate 185
16335 OPC_Decode, 173, 115, 178, 2, // 214: decode to FMUL_S_INX using decoder 306
16336 // 214: }
16337 9, 8, // 219: case 0x9: {
16338 OPC_CheckPredicate, 186, 1, // 221: check predicate 186
16339 OPC_Decode, 168, 115, 179, 2, // 224: decode to FMUL_D_INX using decoder 307
16340 // 224: }
16341 10, 8, // 229: case 0xa: {
16342 OPC_CheckPredicate, 187, 1, // 231: check predicate 187
16343 OPC_Decode, 170, 115, 180, 2, // 234: decode to FMUL_H_INX using decoder 308
16344 // 234: }
16345 12, 8, // 239: case 0xc: {
16346 OPC_CheckPredicate, 185, 1, // 241: check predicate 185
16347 OPC_Decode, 210, 114, 178, 2, // 244: decode to FDIV_S_INX using decoder 306
16348 // 244: }
16349 13, 8, // 249: case 0xd: {
16350 OPC_CheckPredicate, 186, 1, // 251: check predicate 186
16351 OPC_Decode, 205, 114, 179, 2, // 254: decode to FDIV_D_INX using decoder 307
16352 // 254: }
16353 14, 8, // 259: case 0xe: {
16354 OPC_CheckPredicate, 187, 1, // 261: check predicate 187
16355 OPC_Decode, 207, 114, 180, 2, // 264: decode to FDIV_H_INX using decoder 308
16356 // 264: }
16357 16, 33, // 269: case 0x10: {
16358 OPC_SwitchField, 12, 3, // 271: switch Inst[14:12] {
16359 0, 8, // 274: case 0x0: {
16360 OPC_CheckPredicate, 185, 1, // 276: check predicate 185
16361 OPC_Decode, 233, 115, 181, 2, // 279: decode to FSGNJ_S_INX using decoder 309
16362 // 279: }
16363 1, 8, // 284: case 0x1: {
16364 OPC_CheckPredicate, 185, 1, // 286: check predicate 185
16365 OPC_Decode, 217, 115, 181, 2, // 289: decode to FSGNJN_S_INX using decoder 309
16366 // 289: }
16367 2, 0, // 294: case 0x2: {
16368 OPC_CheckPredicate, 185, 1, // 296: check predicate 185
16369 OPC_Decode, 225, 115, 181, 2, // 299: decode to FSGNJX_S_INX using decoder 309
16370 // 299: }
16371 // 299: } // switch Inst[14:12]
16372 // 299: }
16373 17, 30, // 304: case 0x11: {
16374 OPC_SwitchField, 12, 3, // 306: switch Inst[14:12] {
16375 0, 7, // 309: case 0x0: {
16376 OPC_CheckPredicate, 186, 1, // 311: check predicate 186
16377 OPC_Decode, 228, 115, 30, // 314: decode to FSGNJ_D_INX using decoder 30
16378 // 314: }
16379 1, 7, // 318: case 0x1: {
16380 OPC_CheckPredicate, 186, 1, // 320: check predicate 186
16381 OPC_Decode, 212, 115, 30, // 323: decode to FSGNJN_D_INX using decoder 30
16382 // 323: }
16383 2, 0, // 327: case 0x2: {
16384 OPC_CheckPredicate, 186, 1, // 329: check predicate 186
16385 OPC_Decode, 220, 115, 30, // 332: decode to FSGNJX_D_INX using decoder 30
16386 // 332: }
16387 // 332: } // switch Inst[14:12]
16388 // 332: }
16389 18, 33, // 336: case 0x12: {
16390 OPC_SwitchField, 12, 3, // 338: switch Inst[14:12] {
16391 0, 8, // 341: case 0x0: {
16392 OPC_CheckPredicate, 187, 1, // 343: check predicate 187
16393 OPC_Decode, 230, 115, 182, 2, // 346: decode to FSGNJ_H_INX using decoder 310
16394 // 346: }
16395 1, 8, // 351: case 0x1: {
16396 OPC_CheckPredicate, 187, 1, // 353: check predicate 187
16397 OPC_Decode, 214, 115, 182, 2, // 356: decode to FSGNJN_H_INX using decoder 310
16398 // 356: }
16399 2, 0, // 361: case 0x2: {
16400 OPC_CheckPredicate, 187, 1, // 363: check predicate 187
16401 OPC_Decode, 222, 115, 182, 2, // 366: decode to FSGNJX_H_INX using decoder 310
16402 // 366: }
16403 // 366: } // switch Inst[14:12]
16404 // 366: }
16405 20, 23, // 371: case 0x14: {
16406 OPC_SwitchField, 12, 3, // 373: switch Inst[14:12] {
16407 0, 8, // 376: case 0x0: {
16408 OPC_CheckPredicate, 185, 1, // 378: check predicate 185
16409 OPC_Decode, 157, 115, 181, 2, // 381: decode to FMIN_S_INX using decoder 309
16410 // 381: }
16411 1, 0, // 386: case 0x1: {
16412 OPC_CheckPredicate, 185, 1, // 388: check predicate 185
16413 OPC_Decode, 145, 115, 181, 2, // 391: decode to FMAX_S_INX using decoder 309
16414 // 391: }
16415 // 391: } // switch Inst[14:12]
16416 // 391: }
16417 21, 21, // 396: case 0x15: {
16418 OPC_SwitchField, 12, 3, // 398: switch Inst[14:12] {
16419 0, 7, // 401: case 0x0: {
16420 OPC_CheckPredicate, 186, 1, // 403: check predicate 186
16421 OPC_Decode, 152, 115, 30, // 406: decode to FMIN_D_INX using decoder 30
16422 // 406: }
16423 1, 0, // 410: case 0x1: {
16424 OPC_CheckPredicate, 186, 1, // 412: check predicate 186
16425 OPC_Decode, 140, 115, 30, // 415: decode to FMAX_D_INX using decoder 30
16426 // 415: }
16427 // 415: } // switch Inst[14:12]
16428 // 415: }
16429 22, 23, // 419: case 0x16: {
16430 OPC_SwitchField, 12, 3, // 421: switch Inst[14:12] {
16431 0, 8, // 424: case 0x0: {
16432 OPC_CheckPredicate, 187, 1, // 426: check predicate 187
16433 OPC_Decode, 154, 115, 182, 2, // 429: decode to FMIN_H_INX using decoder 310
16434 // 429: }
16435 1, 0, // 434: case 0x1: {
16436 OPC_CheckPredicate, 187, 1, // 436: check predicate 187
16437 OPC_Decode, 142, 115, 182, 2, // 439: decode to FMAX_H_INX using decoder 310
16438 // 439: }
16439 // 439: } // switch Inst[14:12]
16440 // 439: }
16441 32, 23, // 444: case 0x20: {
16442 OPC_SwitchField, 20, 5, // 446: switch Inst[24:20] {
16443 1, 8, // 449: case 0x1: {
16444 OPC_CheckPredicate, 186, 1, // 451: check predicate 186
16445 OPC_Decode, 175, 114, 183, 2, // 454: decode to FCVT_S_D_INX using decoder 311
16446 // 454: }
16447 2, 0, // 459: case 0x2: {
16448 OPC_CheckPredicate, 188, 1, // 461: check predicate 188
16449 OPC_Decode, 177, 114, 184, 2, // 464: decode to FCVT_S_H_INX using decoder 312
16450 // 464: }
16451 // 464: } // switch Inst[24:20]
16452 // 464: }
16453 33, 23, // 469: case 0x21: {
16454 OPC_SwitchField, 20, 5, // 471: switch Inst[24:20] {
16455 0, 8, // 474: case 0x0: {
16456 OPC_CheckPredicate, 186, 1, // 476: check predicate 186
16457 OPC_Decode, 132, 114, 185, 2, // 479: decode to FCVT_D_S_INX using decoder 313
16458 // 479: }
16459 2, 0, // 484: case 0x2: {
16460 OPC_CheckPredicate, 189, 1, // 486: check predicate 189
16461 OPC_Decode, 252, 113, 186, 2, // 489: decode to FCVT_D_H_INX using decoder 314
16462 // 489: }
16463 // 489: } // switch Inst[24:20]
16464 // 489: }
16465 34, 23, // 494: case 0x22: {
16466 OPC_SwitchField, 20, 5, // 496: switch Inst[24:20] {
16467 0, 8, // 499: case 0x0: {
16468 OPC_CheckPredicate, 188, 1, // 501: check predicate 188
16469 OPC_Decode, 147, 114, 187, 2, // 504: decode to FCVT_H_S_INX using decoder 315
16470 // 504: }
16471 1, 0, // 509: case 0x1: {
16472 OPC_CheckPredicate, 189, 1, // 511: check predicate 189
16473 OPC_Decode, 141, 114, 188, 2, // 514: decode to FCVT_H_D_INX using decoder 316
16474 // 514: }
16475 // 514: } // switch Inst[24:20]
16476 // 514: }
16477 44, 12, // 519: case 0x2c: {
16478 OPC_CheckPredicate, 185, 1, // 521: check predicate 185
16479 OPC_CheckField, 20, 5, 0, // 524: check Inst[24:20] == 0x0
16480 OPC_Decode, 243, 115, 189, 2, // 528: decode to FSQRT_S_INX using decoder 317
16481 // 528: }
16482 45, 12, // 533: case 0x2d: {
16483 OPC_CheckPredicate, 186, 1, // 535: check predicate 186
16484 OPC_CheckField, 20, 5, 0, // 538: check Inst[24:20] == 0x0
16485 OPC_Decode, 238, 115, 190, 2, // 542: decode to FSQRT_D_INX using decoder 318
16486 // 542: }
16487 46, 12, // 547: case 0x2e: {
16488 OPC_CheckPredicate, 187, 1, // 549: check predicate 187
16489 OPC_CheckField, 20, 5, 0, // 552: check Inst[24:20] == 0x0
16490 OPC_Decode, 240, 115, 191, 2, // 556: decode to FSQRT_H_INX using decoder 319
16491 // 556: }
16492 80, 33, // 561: case 0x50: {
16493 OPC_SwitchField, 12, 3, // 563: switch Inst[14:12] {
16494 0, 8, // 566: case 0x0: {
16495 OPC_CheckPredicate, 185, 1, // 568: check predicate 185
16496 OPC_Decode, 234, 114, 192, 2, // 571: decode to FLE_S_INX using decoder 320
16497 // 571: }
16498 1, 8, // 576: case 0x1: {
16499 OPC_CheckPredicate, 185, 1, // 578: check predicate 185
16500 OPC_Decode, 252, 114, 192, 2, // 581: decode to FLT_S_INX using decoder 320
16501 // 581: }
16502 2, 0, // 586: case 0x2: {
16503 OPC_CheckPredicate, 185, 1, // 588: check predicate 185
16504 OPC_Decode, 221, 114, 192, 2, // 591: decode to FEQ_S_INX using decoder 320
16505 // 591: }
16506 // 591: } // switch Inst[14:12]
16507 // 591: }
16508 81, 30, // 596: case 0x51: {
16509 OPC_SwitchField, 12, 3, // 598: switch Inst[14:12] {
16510 0, 7, // 601: case 0x0: {
16511 OPC_CheckPredicate, 186, 1, // 603: check predicate 186
16512 OPC_Decode, 229, 114, 30, // 606: decode to FLE_D_INX using decoder 30
16513 // 606: }
16514 1, 7, // 610: case 0x1: {
16515 OPC_CheckPredicate, 186, 1, // 612: check predicate 186
16516 OPC_Decode, 247, 114, 30, // 615: decode to FLT_D_INX using decoder 30
16517 // 615: }
16518 2, 0, // 619: case 0x2: {
16519 OPC_CheckPredicate, 186, 1, // 621: check predicate 186
16520 OPC_Decode, 216, 114, 30, // 624: decode to FEQ_D_INX using decoder 30
16521 // 624: }
16522 // 624: } // switch Inst[14:12]
16523 // 624: }
16524 82, 33, // 628: case 0x52: {
16525 OPC_SwitchField, 12, 3, // 630: switch Inst[14:12] {
16526 0, 8, // 633: case 0x0: {
16527 OPC_CheckPredicate, 187, 1, // 635: check predicate 187
16528 OPC_Decode, 231, 114, 193, 2, // 638: decode to FLE_H_INX using decoder 321
16529 // 638: }
16530 1, 8, // 643: case 0x1: {
16531 OPC_CheckPredicate, 187, 1, // 645: check predicate 187
16532 OPC_Decode, 249, 114, 193, 2, // 648: decode to FLT_H_INX using decoder 321
16533 // 648: }
16534 2, 0, // 653: case 0x2: {
16535 OPC_CheckPredicate, 187, 1, // 655: check predicate 187
16536 OPC_Decode, 218, 114, 193, 2, // 658: decode to FEQ_H_INX using decoder 321
16537 // 658: }
16538 // 658: } // switch Inst[14:12]
16539 // 658: }
16540 96, 43, // 663: case 0x60: {
16541 OPC_SwitchField, 20, 5, // 665: switch Inst[24:20] {
16542 0, 8, // 668: case 0x0: {
16543 OPC_CheckPredicate, 185, 1, // 670: check predicate 185
16544 OPC_Decode, 202, 114, 185, 2, // 673: decode to FCVT_W_S_INX using decoder 313
16545 // 673: }
16546 1, 8, // 678: case 0x1: {
16547 OPC_CheckPredicate, 185, 1, // 680: check predicate 185
16548 OPC_Decode, 194, 114, 185, 2, // 683: decode to FCVT_WU_S_INX using decoder 313
16549 // 683: }
16550 2, 8, // 688: case 0x2: {
16551 OPC_CheckPredicate, 190, 1, // 690: check predicate 190
16552 OPC_Decode, 165, 114, 185, 2, // 693: decode to FCVT_L_S_INX using decoder 313
16553 // 693: }
16554 3, 0, // 698: case 0x3: {
16555 OPC_CheckPredicate, 190, 1, // 700: check predicate 190
16556 OPC_Decode, 158, 114, 185, 2, // 703: decode to FCVT_LU_S_INX using decoder 313
16557 // 703: }
16558 // 703: } // switch Inst[24:20]
16559 // 703: }
16560 97, 43, // 708: case 0x61: {
16561 OPC_SwitchField, 20, 5, // 710: switch Inst[24:20] {
16562 0, 8, // 713: case 0x0: {
16563 OPC_CheckPredicate, 186, 1, // 715: check predicate 186
16564 OPC_Decode, 197, 114, 190, 2, // 718: decode to FCVT_W_D_INX using decoder 318
16565 // 718: }
16566 1, 8, // 723: case 0x1: {
16567 OPC_CheckPredicate, 186, 1, // 725: check predicate 186
16568 OPC_Decode, 189, 114, 190, 2, // 728: decode to FCVT_WU_D_INX using decoder 318
16569 // 728: }
16570 2, 8, // 733: case 0x2: {
16571 OPC_CheckPredicate, 191, 1, // 735: check predicate 191
16572 OPC_Decode, 160, 114, 190, 2, // 738: decode to FCVT_L_D_INX using decoder 318
16573 // 738: }
16574 3, 0, // 743: case 0x3: {
16575 OPC_CheckPredicate, 191, 1, // 745: check predicate 191
16576 OPC_Decode, 153, 114, 190, 2, // 748: decode to FCVT_LU_D_INX using decoder 318
16577 // 748: }
16578 // 748: } // switch Inst[24:20]
16579 // 748: }
16580 98, 43, // 753: case 0x62: {
16581 OPC_SwitchField, 20, 5, // 755: switch Inst[24:20] {
16582 0, 8, // 758: case 0x0: {
16583 OPC_CheckPredicate, 187, 1, // 760: check predicate 187
16584 OPC_Decode, 199, 114, 186, 2, // 763: decode to FCVT_W_H_INX using decoder 314
16585 // 763: }
16586 1, 8, // 768: case 0x1: {
16587 OPC_CheckPredicate, 187, 1, // 770: check predicate 187
16588 OPC_Decode, 191, 114, 186, 2, // 773: decode to FCVT_WU_H_INX using decoder 314
16589 // 773: }
16590 2, 8, // 778: case 0x2: {
16591 OPC_CheckPredicate, 192, 1, // 780: check predicate 192
16592 OPC_Decode, 162, 114, 186, 2, // 783: decode to FCVT_L_H_INX using decoder 314
16593 // 783: }
16594 3, 0, // 788: case 0x3: {
16595 OPC_CheckPredicate, 192, 1, // 790: check predicate 192
16596 OPC_Decode, 155, 114, 186, 2, // 793: decode to FCVT_LU_H_INX using decoder 314
16597 // 793: }
16598 // 793: } // switch Inst[24:20]
16599 // 793: }
16600 104, 43, // 798: case 0x68: {
16601 OPC_SwitchField, 20, 5, // 800: switch Inst[24:20] {
16602 0, 8, // 803: case 0x0: {
16603 OPC_CheckPredicate, 185, 1, // 805: check predicate 185
16604 OPC_Decode, 186, 114, 183, 2, // 808: decode to FCVT_S_W_INX using decoder 311
16605 // 808: }
16606 1, 8, // 813: case 0x1: {
16607 OPC_CheckPredicate, 185, 1, // 815: check predicate 185
16608 OPC_Decode, 185, 114, 183, 2, // 818: decode to FCVT_S_WU_INX using decoder 311
16609 // 818: }
16610 2, 8, // 823: case 0x2: {
16611 OPC_CheckPredicate, 190, 1, // 825: check predicate 190
16612 OPC_Decode, 181, 114, 183, 2, // 828: decode to FCVT_S_L_INX using decoder 311
16613 // 828: }
16614 3, 0, // 833: case 0x3: {
16615 OPC_CheckPredicate, 190, 1, // 835: check predicate 190
16616 OPC_Decode, 180, 114, 183, 2, // 838: decode to FCVT_S_LU_INX using decoder 311
16617 // 838: }
16618 // 838: } // switch Inst[24:20]
16619 // 838: }
16620 105, 43, // 843: case 0x69: {
16621 OPC_SwitchField, 20, 5, // 845: switch Inst[24:20] {
16622 0, 8, // 848: case 0x0: {
16623 OPC_CheckPredicate, 186, 1, // 850: check predicate 186
16624 OPC_Decode, 138, 114, 190, 2, // 853: decode to FCVT_D_W_INX using decoder 318
16625 // 853: }
16626 1, 8, // 858: case 0x1: {
16627 OPC_CheckPredicate, 186, 1, // 860: check predicate 186
16628 OPC_Decode, 136, 114, 190, 2, // 863: decode to FCVT_D_WU_INX using decoder 318
16629 // 863: }
16630 2, 8, // 868: case 0x2: {
16631 OPC_CheckPredicate, 191, 1, // 870: check predicate 191
16632 OPC_Decode, 128, 114, 190, 2, // 873: decode to FCVT_D_L_INX using decoder 318
16633 // 873: }
16634 3, 0, // 878: case 0x3: {
16635 OPC_CheckPredicate, 191, 1, // 880: check predicate 191
16636 OPC_Decode, 255, 113, 190, 2, // 883: decode to FCVT_D_LU_INX using decoder 318
16637 // 883: }
16638 // 883: } // switch Inst[24:20]
16639 // 883: }
16640 106, 43, // 888: case 0x6a: {
16641 OPC_SwitchField, 20, 5, // 890: switch Inst[24:20] {
16642 0, 8, // 893: case 0x0: {
16643 OPC_CheckPredicate, 187, 1, // 895: check predicate 187
16644 OPC_Decode, 151, 114, 188, 2, // 898: decode to FCVT_H_W_INX using decoder 316
16645 // 898: }
16646 1, 8, // 903: case 0x1: {
16647 OPC_CheckPredicate, 187, 1, // 905: check predicate 187
16648 OPC_Decode, 150, 114, 188, 2, // 908: decode to FCVT_H_WU_INX using decoder 316
16649 // 908: }
16650 2, 8, // 913: case 0x2: {
16651 OPC_CheckPredicate, 192, 1, // 915: check predicate 192
16652 OPC_Decode, 145, 114, 188, 2, // 918: decode to FCVT_H_L_INX using decoder 316
16653 // 918: }
16654 3, 0, // 923: case 0x3: {
16655 OPC_CheckPredicate, 192, 1, // 925: check predicate 192
16656 OPC_Decode, 144, 114, 188, 2, // 928: decode to FCVT_H_LU_INX using decoder 316
16657 // 928: }
16658 // 928: } // switch Inst[24:20]
16659 // 928: }
16660 112, 16, // 933: case 0x70: {
16661 OPC_CheckPredicate, 185, 1, // 935: check predicate 185
16662 OPC_CheckField, 20, 5, 0, // 938: check Inst[24:20] == 0x0
16663 OPC_CheckField, 12, 3, 1, // 942: check Inst[14:12] == 0x1
16664 OPC_Decode, 247, 113, 194, 2, // 946: decode to FCLASS_S_INX using decoder 322
16665 // 946: }
16666 113, 15, // 951: case 0x71: {
16667 OPC_CheckPredicate, 186, 1, // 953: check predicate 186
16668 OPC_CheckField, 20, 5, 0, // 956: check Inst[24:20] == 0x0
16669 OPC_CheckField, 12, 3, 1, // 960: check Inst[14:12] == 0x1
16670 OPC_Decode, 242, 113, 16, // 964: decode to FCLASS_D_INX using decoder 16
16671 // 964: }
16672 114, 0, // 968: case 0x72: {
16673 OPC_CheckPredicate, 187, 1, // 970: check predicate 187
16674 OPC_CheckField, 20, 5, 0, // 973: check Inst[24:20] == 0x0
16675 OPC_CheckField, 12, 3, 1, // 977: check Inst[14:12] == 0x1
16676 OPC_Decode, 244, 113, 195, 2, // 981: decode to FCLASS_H_INX using decoder 323
16677 // 981: }
16678 // 981: } // switch Inst[31:25]
16679 // 981: }
16680 // 981: } // switch Inst[6:0]
16681};
16682// Handling 324 cases.
16683template <typename InsnType>
16684static std::enable_if_t<InsnBitWidth<InsnType> == 32, DecodeStatus>
16685decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
16686 DecodeComplete = true;
16687 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
16688 TmpType tmp;
16689 switch (Idx) {
16690 default: llvm_unreachable("Invalid decoder index!");
16691 case 0:
16692 tmp = fieldFromInstruction(insn, 7, 5);
16693 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16694 tmp = fieldFromInstruction(insn, 15, 5);
16695 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16696 tmp = fieldFromInstruction(insn, 20, 12);
16697 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16698 return S;
16699 case 1:
16700 tmp = fieldFromInstruction(insn, 7, 5);
16701 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16702 tmp = fieldFromInstruction(insn, 15, 5);
16703 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16704 tmp = fieldFromInstruction(insn, 25, 1);
16705 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16706 return S;
16707 case 2:
16708 tmp = fieldFromInstruction(insn, 7, 5);
16709 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16710 tmp = fieldFromInstruction(insn, 15, 5);
16711 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16712 return S;
16713 case 3:
16714 tmp = fieldFromInstruction(insn, 7, 5);
16715 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16716 tmp = fieldFromInstruction(insn, 15, 5);
16717 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16718 tmp = fieldFromInstruction(insn, 20, 5);
16719 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16720 tmp = fieldFromInstruction(insn, 25, 1);
16721 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16722 return S;
16723 case 4:
16724 tmp = fieldFromInstruction(insn, 7, 5);
16725 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16726 tmp = fieldFromInstruction(insn, 15, 5);
16727 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16728 tmp = fieldFromInstruction(insn, 20, 5);
16729 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16730 tmp = fieldFromInstruction(insn, 25, 1);
16731 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16732 return S;
16733 case 5:
16734 tmp = fieldFromInstruction(insn, 7, 5);
16735 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16736 tmp = fieldFromInstruction(insn, 15, 5);
16737 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16738 return S;
16739 case 6:
16740 tmp = fieldFromInstruction(insn, 7, 5);
16741 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16742 tmp = fieldFromInstruction(insn, 15, 5);
16743 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16744 return S;
16745 case 7:
16746 tmp = fieldFromInstruction(insn, 7, 5);
16747 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16748 tmp = fieldFromInstruction(insn, 15, 5);
16749 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16750 return S;
16751 case 8:
16752 tmp = fieldFromInstruction(insn, 7, 5);
16753 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16754 tmp = fieldFromInstruction(insn, 15, 5);
16755 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16756 tmp = fieldFromInstruction(insn, 20, 12);
16757 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16758 return S;
16759 case 9:
16760 tmp = fieldFromInstruction(insn, 7, 5);
16761 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16762 tmp = fieldFromInstruction(insn, 15, 5);
16763 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16764 tmp = fieldFromInstruction(insn, 20, 12);
16765 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16766 return S;
16767 case 10:
16768 tmp = fieldFromInstruction(insn, 7, 5);
16769 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16770 tmp = fieldFromInstruction(insn, 15, 5);
16771 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16772 tmp = fieldFromInstruction(insn, 20, 12);
16773 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16774 return S;
16775 case 11:
16776 tmp = fieldFromInstruction(insn, 7, 5);
16777 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16778 tmp = fieldFromInstruction(insn, 15, 5);
16779 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16780 tmp = fieldFromInstruction(insn, 20, 12);
16781 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16782 return S;
16783 case 12:
16784 tmp = fieldFromInstruction(insn, 24, 4);
16785 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16786 tmp = fieldFromInstruction(insn, 20, 4);
16787 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16788 return S;
16789 case 13:
16790 return S;
16791 case 14:
16792 tmp = fieldFromInstruction(insn, 15, 5);
16793 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16794 return S;
16795 case 15:
16796 tmp = fieldFromInstruction(insn, 7, 5);
16797 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16798 tmp = fieldFromInstruction(insn, 15, 5);
16799 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16800 tmp = fieldFromInstruction(insn, 20, 6);
16801 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16802 return S;
16803 case 16:
16804 tmp = fieldFromInstruction(insn, 7, 5);
16805 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16806 tmp = fieldFromInstruction(insn, 15, 5);
16807 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16808 return S;
16809 case 17:
16810 tmp = fieldFromInstruction(insn, 7, 5);
16811 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16812 tmp = fieldFromInstruction(insn, 15, 5);
16813 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16814 tmp = fieldFromInstruction(insn, 20, 4);
16815 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16816 return S;
16817 case 18:
16818 tmp = fieldFromInstruction(insn, 15, 5);
16819 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16820 tmp = fieldFromInstruction(insn, 25, 7) << 5;
16821 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16822 return S;
16823 case 19:
16824 tmp = fieldFromInstruction(insn, 7, 5);
16825 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16826 tmp = fieldFromInstruction(insn, 12, 20);
16827 if (!Check(S, decodeUImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16828 return S;
16829 case 20:
16830 tmp = fieldFromInstruction(insn, 7, 5);
16831 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16832 tmp = fieldFromInstruction(insn, 15, 5);
16833 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16834 tmp = fieldFromInstruction(insn, 20, 5);
16835 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16836 return S;
16837 case 21:
16838 tmp = fieldFromInstruction(insn, 8, 4) << 1;
16839 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16840 tmp = fieldFromInstruction(insn, 15, 5);
16841 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16842 tmp = fieldFromInstruction(insn, 20, 4);
16843 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16844 return S;
16845 case 22:
16846 tmp = fieldFromInstruction(insn, 8, 4) << 1;
16847 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16848 tmp = fieldFromInstruction(insn, 15, 5);
16849 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16850 tmp = fieldFromInstruction(insn, 20, 5);
16851 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16852 return S;
16853 case 23:
16854 tmp = fieldFromInstruction(insn, 8, 4) << 1;
16855 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16856 tmp = fieldFromInstruction(insn, 15, 5);
16857 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16858 tmp = fieldFromInstruction(insn, 20, 5);
16859 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16860 return S;
16861 case 24:
16862 tmp = fieldFromInstruction(insn, 8, 4) << 1;
16863 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16864 tmp = fieldFromInstruction(insn, 15, 5);
16865 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16866 tmp = fieldFromInstruction(insn, 20, 6);
16867 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16868 return S;
16869 case 25:
16870 tmp = fieldFromInstruction(insn, 8, 4) << 1;
16871 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16872 tmp = fieldFromInstruction(insn, 8, 4) << 1;
16873 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16874 tmp = fieldFromInstruction(insn, 15, 5);
16875 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16876 tmp = fieldFromInstruction(insn, 20, 5);
16877 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16878 return S;
16879 case 26:
16880 tmp = fieldFromInstruction(insn, 8, 4) << 1;
16881 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16882 tmp = 0x0;
16883 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
16884 tmp |= fieldFromInstruction(insn, 16, 9);
16885 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16886 return S;
16887 case 27:
16888 tmp = fieldFromInstruction(insn, 8, 4) << 1;
16889 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16890 tmp = fieldFromInstruction(insn, 16, 8);
16891 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16892 return S;
16893 case 28:
16894 tmp = fieldFromInstruction(insn, 8, 4) << 1;
16895 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16896 tmp = 0x0;
16897 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
16898 tmp |= fieldFromInstruction(insn, 24, 1);
16899 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16900 return S;
16901 case 29:
16902 tmp = fieldFromInstruction(insn, 7, 5);
16903 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16904 tmp = fieldFromInstruction(insn, 15, 5);
16905 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16906 tmp = fieldFromInstruction(insn, 20, 3);
16907 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16908 return S;
16909 case 30:
16910 tmp = fieldFromInstruction(insn, 7, 5);
16911 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16912 tmp = fieldFromInstruction(insn, 15, 5);
16913 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16914 tmp = fieldFromInstruction(insn, 20, 5);
16915 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16916 return S;
16917 case 31:
16918 tmp = fieldFromInstruction(insn, 7, 5);
16919 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16920 tmp = 0x0;
16921 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
16922 tmp |= fieldFromInstruction(insn, 16, 9);
16923 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16924 return S;
16925 case 32:
16926 tmp = fieldFromInstruction(insn, 7, 5);
16927 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16928 tmp = fieldFromInstruction(insn, 16, 8);
16929 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16930 return S;
16931 case 33:
16932 tmp = fieldFromInstruction(insn, 7, 5);
16933 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16934 tmp = 0x0;
16935 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
16936 tmp |= fieldFromInstruction(insn, 24, 1);
16937 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16938 return S;
16939 case 34:
16940 tmp = fieldFromInstruction(insn, 7, 5);
16941 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16942 tmp = fieldFromInstruction(insn, 16, 4) << 1;
16943 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16944 tmp = fieldFromInstruction(insn, 20, 4);
16945 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16946 return S;
16947 case 35:
16948 tmp = fieldFromInstruction(insn, 7, 5);
16949 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16950 tmp = fieldFromInstruction(insn, 16, 4) << 1;
16951 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16952 tmp = fieldFromInstruction(insn, 20, 5);
16953 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16954 return S;
16955 case 36:
16956 tmp = fieldFromInstruction(insn, 7, 5);
16957 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16958 tmp = fieldFromInstruction(insn, 16, 4) << 1;
16959 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16960 tmp = fieldFromInstruction(insn, 20, 6);
16961 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16962 return S;
16963 case 37:
16964 tmp = fieldFromInstruction(insn, 7, 5);
16965 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16966 tmp = fieldFromInstruction(insn, 16, 4) << 1;
16967 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16968 tmp = fieldFromInstruction(insn, 20, 5);
16969 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16970 return S;
16971 case 38:
16972 tmp = fieldFromInstruction(insn, 7, 5);
16973 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16974 tmp = fieldFromInstruction(insn, 15, 5);
16975 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16976 tmp = fieldFromInstruction(insn, 20, 6);
16977 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16978 return S;
16979 case 39:
16980 tmp = fieldFromInstruction(insn, 7, 5);
16981 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16982 tmp = fieldFromInstruction(insn, 15, 5);
16983 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16984 tmp = fieldFromInstruction(insn, 20, 4);
16985 if (!Check(S, decodeUImmPlus1Operand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16986 return S;
16987 case 40:
16988 tmp = fieldFromInstruction(insn, 7, 5);
16989 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16990 tmp = fieldFromInstruction(insn, 15, 5);
16991 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16992 tmp = fieldFromInstruction(insn, 20, 5);
16993 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16994 return S;
16995 case 41:
16996 tmp = fieldFromInstruction(insn, 7, 5);
16997 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
16998 tmp = fieldFromInstruction(insn, 15, 5);
16999 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17000 tmp = fieldFromInstruction(insn, 20, 6);
17001 if (!Check(S, decodeUImmPlus1Operand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17002 return S;
17003 case 42:
17004 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17005 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17006 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17007 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17008 tmp = fieldFromInstruction(insn, 20, 3);
17009 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17010 return S;
17011 case 43:
17012 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17013 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17014 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17015 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17016 tmp = fieldFromInstruction(insn, 20, 4);
17017 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17018 return S;
17019 case 44:
17020 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17021 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17022 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17023 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17024 tmp = fieldFromInstruction(insn, 21, 4) << 1;
17025 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17026 return S;
17027 case 45:
17028 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17029 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17030 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17031 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17032 tmp = fieldFromInstruction(insn, 20, 5);
17033 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17034 return S;
17035 case 46:
17036 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17037 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17038 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17039 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17040 tmp = fieldFromInstruction(insn, 20, 5);
17041 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17042 return S;
17043 case 47:
17044 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17045 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17046 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17047 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17048 return S;
17049 case 48:
17050 tmp = fieldFromInstruction(insn, 20, 5);
17051 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17052 tmp = fieldFromInstruction(insn, 15, 5);
17053 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17054 tmp = 0x0;
17055 tmp |= fieldFromInstruction(insn, 7, 5);
17056 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17057 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17058 return S;
17059 case 49:
17060 tmp = fieldFromInstruction(insn, 20, 5);
17061 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17062 tmp = fieldFromInstruction(insn, 15, 5);
17063 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17064 tmp = 0x0;
17065 tmp |= fieldFromInstruction(insn, 7, 5);
17066 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17067 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17068 return S;
17069 case 50:
17070 tmp = fieldFromInstruction(insn, 20, 5);
17071 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17072 tmp = fieldFromInstruction(insn, 15, 5);
17073 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17074 tmp = 0x0;
17075 tmp |= fieldFromInstruction(insn, 7, 5);
17076 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17077 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17078 return S;
17079 case 51:
17080 tmp = fieldFromInstruction(insn, 20, 5);
17081 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17082 tmp = fieldFromInstruction(insn, 15, 5);
17083 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17084 tmp = 0x0;
17085 tmp |= fieldFromInstruction(insn, 7, 5);
17086 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17087 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17088 return S;
17089 case 52:
17090 tmp = fieldFromInstruction(insn, 20, 5);
17091 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17092 tmp = fieldFromInstruction(insn, 15, 5);
17093 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17094 tmp = 0x0;
17095 tmp |= fieldFromInstruction(insn, 7, 5);
17096 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17097 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17098 return S;
17099 case 53:
17100 tmp = fieldFromInstruction(insn, 7, 5);
17101 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17102 tmp = fieldFromInstruction(insn, 20, 5);
17103 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17104 tmp = fieldFromInstruction(insn, 15, 5);
17105 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17106 return S;
17107 case 54:
17108 tmp = fieldFromInstruction(insn, 7, 5);
17109 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17110 tmp = fieldFromInstruction(insn, 7, 5);
17111 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17112 tmp = fieldFromInstruction(insn, 20, 5);
17113 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17114 tmp = fieldFromInstruction(insn, 15, 5);
17115 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17116 return S;
17117 case 55:
17118 tmp = fieldFromInstruction(insn, 7, 5);
17119 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17120 tmp = fieldFromInstruction(insn, 7, 5);
17121 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17122 tmp = fieldFromInstruction(insn, 20, 5);
17123 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17124 tmp = fieldFromInstruction(insn, 15, 5);
17125 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17126 return S;
17127 case 56:
17128 tmp = fieldFromInstruction(insn, 20, 5);
17129 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17130 tmp = fieldFromInstruction(insn, 15, 5);
17131 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17132 return S;
17133 case 57:
17134 tmp = fieldFromInstruction(insn, 7, 5);
17135 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17136 tmp = fieldFromInstruction(insn, 15, 5);
17137 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17138 tmp = fieldFromInstruction(insn, 20, 5);
17139 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17140 tmp = fieldFromInstruction(insn, 30, 2);
17141 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17142 return S;
17143 case 58:
17144 tmp = fieldFromInstruction(insn, 7, 5);
17145 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17146 tmp = fieldFromInstruction(insn, 7, 5);
17147 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17148 tmp = fieldFromInstruction(insn, 15, 5);
17149 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17150 tmp = fieldFromInstruction(insn, 20, 5);
17151 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17152 return S;
17153 case 59:
17154 tmp = fieldFromInstruction(insn, 7, 5);
17155 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17156 tmp = fieldFromInstruction(insn, 15, 5);
17157 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17158 tmp = fieldFromInstruction(insn, 20, 5);
17159 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17160 tmp = fieldFromInstruction(insn, 27, 5);
17161 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17162 tmp = fieldFromInstruction(insn, 12, 3);
17163 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17164 return S;
17165 case 60:
17166 tmp = fieldFromInstruction(insn, 7, 5);
17167 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17168 tmp = fieldFromInstruction(insn, 15, 5);
17169 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17170 tmp = fieldFromInstruction(insn, 20, 5);
17171 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17172 tmp = fieldFromInstruction(insn, 27, 5);
17173 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17174 tmp = fieldFromInstruction(insn, 12, 3);
17175 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17176 return S;
17177 case 61:
17178 tmp = fieldFromInstruction(insn, 7, 5);
17179 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17180 tmp = fieldFromInstruction(insn, 15, 5);
17181 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17182 tmp = fieldFromInstruction(insn, 20, 5);
17183 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17184 tmp = fieldFromInstruction(insn, 27, 5);
17185 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17186 tmp = fieldFromInstruction(insn, 12, 3);
17187 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17188 return S;
17189 case 62:
17190 tmp = fieldFromInstruction(insn, 7, 5);
17191 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17192 tmp = fieldFromInstruction(insn, 15, 5);
17193 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17194 tmp = fieldFromInstruction(insn, 20, 5);
17195 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17196 tmp = fieldFromInstruction(insn, 27, 5);
17197 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17198 tmp = fieldFromInstruction(insn, 12, 3);
17199 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17200 return S;
17201 case 63:
17202 tmp = fieldFromInstruction(insn, 7, 5);
17203 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17204 tmp = fieldFromInstruction(insn, 15, 5);
17205 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17206 tmp = fieldFromInstruction(insn, 20, 5);
17207 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17208 tmp = fieldFromInstruction(insn, 12, 3);
17209 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17210 return S;
17211 case 64:
17212 tmp = fieldFromInstruction(insn, 7, 5);
17213 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17214 tmp = fieldFromInstruction(insn, 15, 5);
17215 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17216 tmp = fieldFromInstruction(insn, 20, 5);
17217 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17218 tmp = fieldFromInstruction(insn, 12, 3);
17219 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17220 return S;
17221 case 65:
17222 tmp = fieldFromInstruction(insn, 7, 5);
17223 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17224 tmp = fieldFromInstruction(insn, 15, 5);
17225 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17226 tmp = fieldFromInstruction(insn, 20, 5);
17227 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17228 tmp = fieldFromInstruction(insn, 12, 3);
17229 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17230 return S;
17231 case 66:
17232 tmp = fieldFromInstruction(insn, 7, 5);
17233 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17234 tmp = fieldFromInstruction(insn, 15, 5);
17235 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17236 tmp = fieldFromInstruction(insn, 20, 5);
17237 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17238 tmp = fieldFromInstruction(insn, 12, 3);
17239 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17240 return S;
17241 case 67:
17242 tmp = fieldFromInstruction(insn, 7, 5);
17243 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17244 tmp = fieldFromInstruction(insn, 15, 5);
17245 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17246 tmp = fieldFromInstruction(insn, 20, 5);
17247 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17248 return S;
17249 case 68:
17250 tmp = fieldFromInstruction(insn, 7, 5);
17251 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17252 tmp = fieldFromInstruction(insn, 15, 5);
17253 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17254 tmp = fieldFromInstruction(insn, 20, 5);
17255 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17256 return S;
17257 case 69:
17258 tmp = fieldFromInstruction(insn, 7, 5);
17259 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17260 tmp = fieldFromInstruction(insn, 15, 5);
17261 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17262 tmp = fieldFromInstruction(insn, 20, 5);
17263 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17264 return S;
17265 case 70:
17266 tmp = fieldFromInstruction(insn, 7, 5);
17267 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17268 tmp = fieldFromInstruction(insn, 15, 5);
17269 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17270 tmp = fieldFromInstruction(insn, 20, 5);
17271 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17272 return S;
17273 case 71:
17274 tmp = fieldFromInstruction(insn, 7, 5);
17275 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17276 tmp = fieldFromInstruction(insn, 15, 5);
17277 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17278 tmp = fieldFromInstruction(insn, 12, 3);
17279 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17280 return S;
17281 case 72:
17282 tmp = fieldFromInstruction(insn, 7, 5);
17283 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17284 tmp = fieldFromInstruction(insn, 15, 5);
17285 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17286 tmp = fieldFromInstruction(insn, 12, 3);
17287 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17288 return S;
17289 case 73:
17290 tmp = fieldFromInstruction(insn, 7, 5);
17291 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17292 tmp = fieldFromInstruction(insn, 15, 5);
17293 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17294 tmp = fieldFromInstruction(insn, 12, 3);
17295 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17296 return S;
17297 case 74:
17298 tmp = fieldFromInstruction(insn, 7, 5);
17299 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17300 tmp = fieldFromInstruction(insn, 15, 5);
17301 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17302 tmp = fieldFromInstruction(insn, 12, 3);
17303 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17304 return S;
17305 case 75:
17306 tmp = fieldFromInstruction(insn, 7, 5);
17307 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17308 tmp = fieldFromInstruction(insn, 15, 5);
17309 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17310 tmp = fieldFromInstruction(insn, 12, 3);
17311 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17312 return S;
17313 case 76:
17314 tmp = fieldFromInstruction(insn, 7, 5);
17315 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17316 tmp = fieldFromInstruction(insn, 15, 5);
17317 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17318 tmp = fieldFromInstruction(insn, 12, 3);
17319 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17320 return S;
17321 case 77:
17322 tmp = fieldFromInstruction(insn, 7, 5);
17323 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17324 tmp = fieldFromInstruction(insn, 15, 5);
17325 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17326 tmp = fieldFromInstruction(insn, 12, 3);
17327 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17328 return S;
17329 case 78:
17330 tmp = fieldFromInstruction(insn, 7, 5);
17331 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17332 tmp = fieldFromInstruction(insn, 15, 5);
17333 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17334 tmp = fieldFromInstruction(insn, 12, 3);
17335 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17336 return S;
17337 case 79:
17338 tmp = fieldFromInstruction(insn, 7, 5);
17339 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17340 tmp = fieldFromInstruction(insn, 15, 5);
17341 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17342 tmp = fieldFromInstruction(insn, 12, 3);
17343 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17344 return S;
17345 case 80:
17346 tmp = fieldFromInstruction(insn, 7, 5);
17347 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17348 tmp = fieldFromInstruction(insn, 15, 5);
17349 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17350 tmp = fieldFromInstruction(insn, 12, 3);
17351 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17352 return S;
17353 case 81:
17354 tmp = fieldFromInstruction(insn, 7, 5);
17355 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17356 tmp = fieldFromInstruction(insn, 15, 5);
17357 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17358 tmp = fieldFromInstruction(insn, 12, 3);
17359 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17360 return S;
17361 case 82:
17362 tmp = fieldFromInstruction(insn, 7, 5);
17363 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17364 tmp = fieldFromInstruction(insn, 15, 5);
17365 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17366 tmp = fieldFromInstruction(insn, 12, 3);
17367 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17368 return S;
17369 case 83:
17370 tmp = fieldFromInstruction(insn, 7, 5);
17371 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17372 tmp = fieldFromInstruction(insn, 15, 5);
17373 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17374 tmp = fieldFromInstruction(insn, 12, 3);
17375 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17376 return S;
17377 case 84:
17378 tmp = fieldFromInstruction(insn, 7, 5);
17379 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17380 tmp = fieldFromInstruction(insn, 15, 5);
17381 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17382 tmp = fieldFromInstruction(insn, 12, 3);
17383 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17384 return S;
17385 case 85:
17386 tmp = fieldFromInstruction(insn, 7, 5);
17387 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17388 tmp = fieldFromInstruction(insn, 15, 5);
17389 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17390 tmp = fieldFromInstruction(insn, 20, 5);
17391 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17392 return S;
17393 case 86:
17394 tmp = fieldFromInstruction(insn, 7, 5);
17395 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17396 tmp = fieldFromInstruction(insn, 15, 5);
17397 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17398 tmp = fieldFromInstruction(insn, 20, 5);
17399 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17400 return S;
17401 case 87:
17402 tmp = fieldFromInstruction(insn, 7, 5);
17403 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17404 tmp = fieldFromInstruction(insn, 15, 5);
17405 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17406 tmp = fieldFromInstruction(insn, 20, 5);
17407 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17408 return S;
17409 case 88:
17410 tmp = fieldFromInstruction(insn, 7, 5);
17411 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17412 tmp = fieldFromInstruction(insn, 15, 5);
17413 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17414 tmp = fieldFromInstruction(insn, 20, 5);
17415 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17416 return S;
17417 case 89:
17418 tmp = fieldFromInstruction(insn, 7, 5);
17419 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17420 tmp = fieldFromInstruction(insn, 15, 5);
17421 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17422 tmp = fieldFromInstruction(insn, 20, 5);
17423 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17424 return S;
17425 case 90:
17426 tmp = fieldFromInstruction(insn, 7, 5);
17427 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17428 tmp = fieldFromInstruction(insn, 15, 5);
17429 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17430 tmp = fieldFromInstruction(insn, 20, 5);
17431 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17432 return S;
17433 case 91:
17434 tmp = fieldFromInstruction(insn, 7, 5);
17435 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17436 tmp = fieldFromInstruction(insn, 15, 5);
17437 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17438 tmp = fieldFromInstruction(insn, 12, 3);
17439 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17440 return S;
17441 case 92:
17442 tmp = fieldFromInstruction(insn, 7, 5);
17443 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17444 tmp = fieldFromInstruction(insn, 15, 5);
17445 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17446 tmp = fieldFromInstruction(insn, 12, 3);
17447 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17448 return S;
17449 case 93:
17450 tmp = fieldFromInstruction(insn, 7, 5);
17451 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17452 tmp = fieldFromInstruction(insn, 15, 5);
17453 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17454 tmp = 0x1;
17455 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17456 return S;
17457 case 94:
17458 tmp = fieldFromInstruction(insn, 7, 5);
17459 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17460 tmp = fieldFromInstruction(insn, 15, 5);
17461 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17462 tmp = fieldFromInstruction(insn, 12, 3);
17463 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17464 return S;
17465 case 95:
17466 tmp = fieldFromInstruction(insn, 7, 5);
17467 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17468 tmp = fieldFromInstruction(insn, 15, 5);
17469 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17470 tmp = fieldFromInstruction(insn, 12, 3);
17471 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17472 return S;
17473 case 96:
17474 tmp = fieldFromInstruction(insn, 7, 5);
17475 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17476 tmp = fieldFromInstruction(insn, 15, 5);
17477 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17478 tmp = fieldFromInstruction(insn, 12, 3);
17479 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17480 return S;
17481 case 97:
17482 tmp = fieldFromInstruction(insn, 7, 5);
17483 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17484 tmp = fieldFromInstruction(insn, 15, 5);
17485 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17486 tmp = fieldFromInstruction(insn, 12, 3);
17487 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17488 return S;
17489 case 98:
17490 tmp = fieldFromInstruction(insn, 7, 5);
17491 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17492 tmp = fieldFromInstruction(insn, 15, 5);
17493 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17494 tmp = fieldFromInstruction(insn, 12, 3);
17495 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17496 return S;
17497 case 99:
17498 tmp = fieldFromInstruction(insn, 7, 5);
17499 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17500 tmp = fieldFromInstruction(insn, 15, 5);
17501 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17502 tmp = fieldFromInstruction(insn, 12, 3);
17503 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17504 return S;
17505 case 100:
17506 tmp = fieldFromInstruction(insn, 7, 5);
17507 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17508 tmp = fieldFromInstruction(insn, 15, 5);
17509 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17510 return S;
17511 case 101:
17512 tmp = fieldFromInstruction(insn, 7, 5);
17513 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17514 tmp = fieldFromInstruction(insn, 15, 5);
17515 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17516 return S;
17517 case 102:
17518 tmp = fieldFromInstruction(insn, 7, 5);
17519 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17520 tmp = fieldFromInstruction(insn, 15, 5);
17521 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17522 return S;
17523 case 103:
17524 tmp = fieldFromInstruction(insn, 7, 5);
17525 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17526 tmp = fieldFromInstruction(insn, 15, 5);
17527 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17528 return S;
17529 case 104:
17530 tmp = fieldFromInstruction(insn, 7, 5);
17531 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17532 tmp = fieldFromInstruction(insn, 15, 5);
17533 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17534 return S;
17535 case 105:
17536 tmp = fieldFromInstruction(insn, 7, 5);
17537 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17538 tmp = fieldFromInstruction(insn, 15, 5);
17539 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
17540 return S;
17541 case 106:
17542 tmp = fieldFromInstruction(insn, 7, 5);
17543 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17544 tmp = fieldFromInstruction(insn, 15, 5);
17545 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17546 return S;
17547 case 107:
17548 tmp = fieldFromInstruction(insn, 7, 5);
17549 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17550 tmp = fieldFromInstruction(insn, 15, 5);
17551 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
17552 return S;
17553 case 108:
17554 tmp = fieldFromInstruction(insn, 7, 5);
17555 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17556 tmp = fieldFromInstruction(insn, 15, 5);
17557 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17558 return S;
17559 case 109:
17560 tmp = fieldFromInstruction(insn, 7, 5);
17561 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17562 tmp = fieldFromInstruction(insn, 15, 5);
17563 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
17564 return S;
17565 case 110:
17566 tmp = fieldFromInstruction(insn, 7, 5);
17567 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17568 tmp = fieldFromInstruction(insn, 15, 5);
17569 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
17570 return S;
17571 case 111:
17572 tmp = fieldFromInstruction(insn, 7, 5);
17573 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17574 tmp = fieldFromInstruction(insn, 20, 5);
17575 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17576 tmp = fieldFromInstruction(insn, 15, 5);
17577 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17578 tmp = fieldFromInstruction(insn, 25, 1);
17579 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17580 return S;
17581 case 112:
17582 tmp = fieldFromInstruction(insn, 7, 5);
17583 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17584 tmp = fieldFromInstruction(insn, 20, 5);
17585 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17586 tmp = fieldFromInstruction(insn, 15, 5);
17587 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17588 tmp = 0x0;
17589 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17590 return S;
17591 case 113:
17592 tmp = fieldFromInstruction(insn, 7, 5);
17593 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17594 tmp = fieldFromInstruction(insn, 20, 5);
17595 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17596 tmp = fieldFromInstruction(insn, 15, 5);
17597 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17598 return S;
17599 case 114:
17600 tmp = fieldFromInstruction(insn, 7, 5);
17601 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17602 tmp = fieldFromInstruction(insn, 15, 5);
17603 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17604 return S;
17605 case 115:
17606 tmp = fieldFromInstruction(insn, 7, 5);
17607 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17608 tmp = fieldFromInstruction(insn, 20, 5);
17609 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17610 return S;
17611 case 116:
17612 tmp = fieldFromInstruction(insn, 7, 5);
17613 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17614 tmp = fieldFromInstruction(insn, 20, 5);
17615 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17616 tmp = fieldFromInstruction(insn, 25, 1);
17617 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17618 return S;
17619 case 117:
17620 tmp = fieldFromInstruction(insn, 7, 5);
17621 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17622 tmp = fieldFromInstruction(insn, 7, 5);
17623 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17624 tmp = fieldFromInstruction(insn, 15, 5);
17625 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17626 tmp = fieldFromInstruction(insn, 20, 5);
17627 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17628 tmp = fieldFromInstruction(insn, 25, 1);
17629 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17630 return S;
17631 case 118:
17632 tmp = fieldFromInstruction(insn, 7, 5);
17633 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17634 tmp = fieldFromInstruction(insn, 20, 5);
17635 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17636 return S;
17637 case 119:
17638 tmp = fieldFromInstruction(insn, 7, 5);
17639 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17640 tmp = fieldFromInstruction(insn, 20, 5);
17641 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17642 tmp = fieldFromInstruction(insn, 25, 1);
17643 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17644 return S;
17645 case 120:
17646 tmp = fieldFromInstruction(insn, 7, 5);
17647 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17648 tmp = fieldFromInstruction(insn, 25, 1);
17649 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17650 return S;
17651 case 121:
17652 tmp = fieldFromInstruction(insn, 7, 5);
17653 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17654 tmp = fieldFromInstruction(insn, 7, 5);
17655 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17656 tmp = fieldFromInstruction(insn, 20, 5);
17657 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17658 tmp = fieldFromInstruction(insn, 15, 5);
17659 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17660 tmp = fieldFromInstruction(insn, 25, 1);
17661 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17662 return S;
17663 case 122:
17664 tmp = fieldFromInstruction(insn, 7, 5);
17665 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17666 tmp = fieldFromInstruction(insn, 20, 5);
17667 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17668 tmp = fieldFromInstruction(insn, 15, 5);
17669 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17670 tmp = fieldFromInstruction(insn, 25, 1);
17671 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17672 return S;
17673 case 123:
17674 tmp = fieldFromInstruction(insn, 7, 5);
17675 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17676 tmp = fieldFromInstruction(insn, 20, 5);
17677 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17678 tmp = fieldFromInstruction(insn, 15, 5);
17679 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17680 tmp = fieldFromInstruction(insn, 25, 1);
17681 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17682 return S;
17683 case 124:
17684 tmp = fieldFromInstruction(insn, 7, 5);
17685 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17686 tmp = fieldFromInstruction(insn, 20, 5);
17687 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17688 tmp = fieldFromInstruction(insn, 15, 5);
17689 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17690 tmp = 0x0;
17691 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17692 return S;
17693 case 125:
17694 tmp = fieldFromInstruction(insn, 7, 5);
17695 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17696 tmp = fieldFromInstruction(insn, 20, 5);
17697 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17698 tmp = fieldFromInstruction(insn, 15, 5);
17699 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17700 return S;
17701 case 126:
17702 tmp = fieldFromInstruction(insn, 7, 5);
17703 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17704 tmp = fieldFromInstruction(insn, 20, 5);
17705 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17706 tmp = 0x0;
17707 tmp |= fieldFromInstruction(insn, 15, 5);
17708 tmp |= fieldFromInstruction(insn, 26, 1) << 5;
17709 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17710 tmp = fieldFromInstruction(insn, 25, 1);
17711 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17712 return S;
17713 case 127:
17714 tmp = fieldFromInstruction(insn, 7, 5);
17715 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17716 tmp = fieldFromInstruction(insn, 15, 5);
17717 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17718 return S;
17719 case 128:
17720 tmp = fieldFromInstruction(insn, 7, 5);
17721 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17722 tmp = fieldFromInstruction(insn, 20, 5);
17723 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17724 return S;
17725 case 129:
17726 tmp = fieldFromInstruction(insn, 7, 5);
17727 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17728 tmp = fieldFromInstruction(insn, 20, 5);
17729 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17730 return S;
17731 case 130:
17732 tmp = fieldFromInstruction(insn, 7, 5);
17733 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17734 tmp = fieldFromInstruction(insn, 20, 5);
17735 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17736 return S;
17737 case 131:
17738 tmp = fieldFromInstruction(insn, 7, 5);
17739 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17740 tmp = fieldFromInstruction(insn, 20, 5);
17741 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17742 return S;
17743 case 132:
17744 tmp = fieldFromInstruction(insn, 7, 5);
17745 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17746 tmp = fieldFromInstruction(insn, 20, 5);
17747 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17748 tmp = fieldFromInstruction(insn, 15, 5);
17749 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17750 tmp = fieldFromInstruction(insn, 25, 1);
17751 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17752 return S;
17753 case 133:
17754 tmp = fieldFromInstruction(insn, 7, 5);
17755 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17756 tmp = fieldFromInstruction(insn, 20, 5);
17757 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17758 tmp = fieldFromInstruction(insn, 15, 5);
17759 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17760 tmp = 0x0;
17761 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17762 return S;
17763 case 134:
17764 tmp = fieldFromInstruction(insn, 7, 5);
17765 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17766 tmp = fieldFromInstruction(insn, 20, 5);
17767 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17768 tmp = fieldFromInstruction(insn, 15, 5);
17769 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17770 return S;
17771 case 135:
17772 tmp = fieldFromInstruction(insn, 7, 5);
17773 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17774 tmp = fieldFromInstruction(insn, 20, 5);
17775 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17776 tmp = fieldFromInstruction(insn, 15, 5);
17777 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17778 tmp = fieldFromInstruction(insn, 25, 1);
17779 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17780 return S;
17781 case 136:
17782 tmp = fieldFromInstruction(insn, 7, 5);
17783 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17784 tmp = fieldFromInstruction(insn, 7, 5);
17785 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17786 tmp = fieldFromInstruction(insn, 15, 5);
17787 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17788 return S;
17789 case 137:
17790 tmp = fieldFromInstruction(insn, 7, 5);
17791 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17792 tmp = fieldFromInstruction(insn, 20, 5);
17793 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17794 tmp = fieldFromInstruction(insn, 15, 5);
17795 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17796 tmp = 0x0;
17797 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17798 return S;
17799 case 138:
17800 tmp = fieldFromInstruction(insn, 7, 5);
17801 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17802 tmp = fieldFromInstruction(insn, 15, 5);
17803 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17804 return S;
17805 case 139:
17806 tmp = fieldFromInstruction(insn, 7, 5);
17807 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17808 tmp = fieldFromInstruction(insn, 7, 5);
17809 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17810 tmp = fieldFromInstruction(insn, 15, 5);
17811 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17812 tmp = fieldFromInstruction(insn, 20, 5);
17813 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17814 tmp = fieldFromInstruction(insn, 25, 1);
17815 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17816 return S;
17817 case 140:
17818 tmp = fieldFromInstruction(insn, 7, 5);
17819 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17820 tmp = fieldFromInstruction(insn, 7, 5);
17821 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17822 tmp = fieldFromInstruction(insn, 15, 5);
17823 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17824 return S;
17825 case 141:
17826 tmp = fieldFromInstruction(insn, 7, 5);
17827 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17828 tmp = fieldFromInstruction(insn, 7, 5);
17829 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17830 tmp = fieldFromInstruction(insn, 20, 5);
17831 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17832 tmp = fieldFromInstruction(insn, 15, 5);
17833 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17834 tmp = fieldFromInstruction(insn, 25, 1);
17835 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17836 return S;
17837 case 142:
17838 tmp = fieldFromInstruction(insn, 7, 5);
17839 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17840 tmp = fieldFromInstruction(insn, 7, 5);
17841 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17842 tmp = fieldFromInstruction(insn, 15, 5);
17843 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17844 tmp = fieldFromInstruction(insn, 20, 5);
17845 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17846 tmp = fieldFromInstruction(insn, 25, 1);
17847 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17848 return S;
17849 case 143:
17850 tmp = fieldFromInstruction(insn, 7, 5);
17851 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17852 tmp = fieldFromInstruction(insn, 15, 5);
17853 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17854 tmp = fieldFromInstruction(insn, 20, 11);
17855 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17856 return S;
17857 case 144:
17858 tmp = fieldFromInstruction(insn, 7, 5);
17859 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17860 tmp = fieldFromInstruction(insn, 15, 5);
17861 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17862 tmp = fieldFromInstruction(insn, 20, 10);
17863 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17864 return S;
17865 case 145:
17866 tmp = fieldFromInstruction(insn, 15, 5);
17867 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17868 tmp = fieldFromInstruction(insn, 20, 5);
17869 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17870 tmp = 0x0;
17871 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
17872 tmp |= fieldFromInstruction(insn, 8, 4);
17873 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
17874 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
17875 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17876 return S;
17877 case 146:
17878 tmp = fieldFromInstruction(insn, 15, 5);
17879 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17880 tmp = fieldFromInstruction(insn, 20, 5);
17881 if (!Check(S, decodeImmZibiOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17882 tmp = 0x0;
17883 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
17884 tmp |= fieldFromInstruction(insn, 8, 4);
17885 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
17886 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
17887 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17888 return S;
17889 case 147:
17890 tmp = fieldFromInstruction(insn, 7, 5);
17891 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17892 tmp = 0x0;
17893 tmp |= fieldFromInstruction(insn, 12, 8) << 11;
17894 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
17895 tmp |= fieldFromInstruction(insn, 21, 10);
17896 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
17897 if (!Check(S, decodeSImmOperandAndLslN<21, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17898 return S;
17899 case 148:
17900 tmp = fieldFromInstruction(insn, 15, 5);
17901 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17902 tmp = fieldFromInstruction(insn, 20, 5);
17903 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17904 return S;
17905 case 149:
17906 tmp = fieldFromInstruction(insn, 7, 5);
17907 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17908 tmp = fieldFromInstruction(insn, 20, 12);
17909 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17910 tmp = fieldFromInstruction(insn, 15, 5);
17911 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17912 return S;
17913 case 150:
17914 tmp = fieldFromInstruction(insn, 15, 5);
17915 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17916 return S;
17917 case 151:
17918 tmp = fieldFromInstruction(insn, 7, 5);
17919 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17920 return S;
17921 case 152:
17922 tmp = fieldFromInstruction(insn, 20, 5);
17923 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17924 return S;
17925 case 153:
17926 tmp = fieldFromInstruction(insn, 7, 5);
17927 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17928 tmp = fieldFromInstruction(insn, 20, 12);
17929 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17930 tmp = fieldFromInstruction(insn, 15, 5);
17931 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17932 return S;
17933 case 154:
17934 tmp = fieldFromInstruction(insn, 7, 5);
17935 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17936 tmp = fieldFromInstruction(insn, 20, 5);
17937 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17938 tmp = fieldFromInstruction(insn, 15, 5);
17939 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17940 return S;
17941 case 155:
17942 tmp = fieldFromInstruction(insn, 7, 5);
17943 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17944 tmp = fieldFromInstruction(insn, 7, 5);
17945 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17946 tmp = fieldFromInstruction(insn, 20, 5);
17947 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17948 tmp = fieldFromInstruction(insn, 15, 5);
17949 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17950 return S;
17951 case 156:
17952 tmp = fieldFromInstruction(insn, 7, 5);
17953 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17954 tmp = fieldFromInstruction(insn, 7, 5);
17955 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17956 tmp = fieldFromInstruction(insn, 20, 5);
17957 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17958 return S;
17959 case 157:
17960 tmp = fieldFromInstruction(insn, 7, 5);
17961 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17962 tmp = fieldFromInstruction(insn, 7, 5);
17963 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17964 tmp = fieldFromInstruction(insn, 20, 5);
17965 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17966 tmp = fieldFromInstruction(insn, 15, 5);
17967 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17968 return S;
17969 case 158:
17970 tmp = fieldFromInstruction(insn, 7, 5);
17971 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17972 tmp = fieldFromInstruction(insn, 15, 5);
17973 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17974 tmp = fieldFromInstruction(insn, 20, 12);
17975 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17976 return S;
17977 case 159:
17978 tmp = fieldFromInstruction(insn, 20, 5);
17979 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17980 tmp = fieldFromInstruction(insn, 15, 5);
17981 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17982 tmp = 0x0;
17983 tmp |= fieldFromInstruction(insn, 7, 5);
17984 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17985 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17986 return S;
17987 case 160:
17988 tmp = fieldFromInstruction(insn, 7, 5);
17989 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17990 tmp = fieldFromInstruction(insn, 20, 12);
17991 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17992 tmp = fieldFromInstruction(insn, 15, 5);
17993 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17994 return S;
17995 case 161:
17996 tmp = fieldFromInstruction(insn, 7, 5);
17997 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17998 tmp = fieldFromInstruction(insn, 15, 5);
17999 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18000 tmp = fieldFromInstruction(insn, 20, 5);
18001 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18002 return S;
18003 case 162:
18004 tmp = fieldFromInstruction(insn, 7, 5);
18005 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18006 tmp = fieldFromInstruction(insn, 15, 5);
18007 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18008 tmp = fieldFromInstruction(insn, 20, 5);
18009 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18010 return S;
18011 case 163:
18012 tmp = fieldFromInstruction(insn, 7, 5);
18013 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18014 tmp = fieldFromInstruction(insn, 15, 5);
18015 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18016 return S;
18017 case 164:
18018 tmp = fieldFromInstruction(insn, 20, 5);
18019 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18020 tmp = 0x0;
18021 tmp |= fieldFromInstruction(insn, 7, 5);
18022 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18023 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18024 tmp = fieldFromInstruction(insn, 15, 5);
18025 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18026 return S;
18027 case 165:
18028 tmp = fieldFromInstruction(insn, 7, 5);
18029 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18030 tmp = fieldFromInstruction(insn, 12, 20);
18031 if (!Check(S, decodeUImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18032 return S;
18033 case 166:
18034 tmp = fieldFromInstruction(insn, 7, 5);
18035 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18036 tmp = fieldFromInstruction(insn, 15, 5);
18037 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18038 tmp = 0x0;
18039 tmp |= fieldFromInstruction(insn, 20, 5);
18040 tmp |= fieldFromInstruction(insn, 27, 5) << 5;
18041 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18042 return S;
18043 case 167:
18044 tmp = fieldFromInstruction(insn, 7, 5);
18045 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18046 tmp = fieldFromInstruction(insn, 15, 5);
18047 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18048 tmp = fieldFromInstruction(insn, 20, 5);
18049 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18050 tmp = fieldFromInstruction(insn, 27, 5);
18051 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18052 return S;
18053 case 168:
18054 tmp = fieldFromInstruction(insn, 7, 5);
18055 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18056 tmp = fieldFromInstruction(insn, 15, 5);
18057 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18058 tmp = fieldFromInstruction(insn, 20, 5);
18059 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18060 tmp = fieldFromInstruction(insn, 27, 5);
18061 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18062 tmp = fieldFromInstruction(insn, 12, 3);
18063 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18064 return S;
18065 case 169:
18066 tmp = fieldFromInstruction(insn, 7, 5);
18067 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18068 tmp = fieldFromInstruction(insn, 15, 5);
18069 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18070 tmp = fieldFromInstruction(insn, 20, 5);
18071 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18072 return S;
18073 case 170:
18074 tmp = fieldFromInstruction(insn, 7, 5);
18075 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18076 tmp = fieldFromInstruction(insn, 15, 5);
18077 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18078 tmp = fieldFromInstruction(insn, 20, 5);
18079 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18080 tmp = fieldFromInstruction(insn, 12, 3);
18081 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18082 return S;
18083 case 171:
18084 tmp = fieldFromInstruction(insn, 7, 5);
18085 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18086 tmp = fieldFromInstruction(insn, 15, 5);
18087 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18088 return S;
18089 case 172:
18090 tmp = fieldFromInstruction(insn, 7, 5);
18091 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18092 tmp = fieldFromInstruction(insn, 15, 5);
18093 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18094 tmp = fieldFromInstruction(insn, 20, 5);
18095 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18096 return S;
18097 case 173:
18098 tmp = fieldFromInstruction(insn, 7, 5);
18099 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18100 tmp = fieldFromInstruction(insn, 15, 5);
18101 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18102 tmp = fieldFromInstruction(insn, 20, 5);
18103 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18104 return S;
18105 case 174:
18106 tmp = fieldFromInstruction(insn, 7, 5);
18107 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18108 tmp = fieldFromInstruction(insn, 15, 3);
18109 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18110 return S;
18111 case 175:
18112 tmp = fieldFromInstruction(insn, 7, 3);
18113 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18114 tmp = fieldFromInstruction(insn, 15, 5);
18115 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18116 tmp = 0x0;
18117 tmp |= fieldFromInstruction(insn, 12, 3);
18118 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18119 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18120 return S;
18121 case 176:
18122 tmp = fieldFromInstruction(insn, 7, 5);
18123 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18124 tmp = fieldFromInstruction(insn, 15, 5);
18125 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18126 tmp = fieldFromInstruction(insn, 12, 3);
18127 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18128 return S;
18129 case 177:
18130 tmp = fieldFromInstruction(insn, 7, 5);
18131 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18132 tmp = fieldFromInstruction(insn, 15, 3);
18133 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18134 tmp = fieldFromInstruction(insn, 20, 3);
18135 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18136 tmp = 0x0;
18137 tmp |= fieldFromInstruction(insn, 18, 2);
18138 tmp |= fieldFromInstruction(insn, 23, 2) << 2;
18139 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18140 return S;
18141 case 178:
18142 tmp = fieldFromInstruction(insn, 7, 3);
18143 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18144 tmp = fieldFromInstruction(insn, 15, 3);
18145 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18146 return S;
18147 case 179:
18148 tmp = fieldFromInstruction(insn, 7, 3);
18149 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18150 tmp = fieldFromInstruction(insn, 15, 3);
18151 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18152 tmp = fieldFromInstruction(insn, 20, 3);
18153 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18154 return S;
18155 case 180:
18156 tmp = fieldFromInstruction(insn, 7, 5);
18157 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18158 tmp = fieldFromInstruction(insn, 15, 5);
18159 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18160 return S;
18161 case 181:
18162 tmp = fieldFromInstruction(insn, 7, 5);
18163 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18164 return S;
18165 case 182:
18166 tmp = fieldFromInstruction(insn, 7, 5);
18167 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18168 tmp = fieldFromInstruction(insn, 15, 5);
18169 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18170 tmp = fieldFromInstruction(insn, 20, 3);
18171 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18172 return S;
18173 case 183:
18174 tmp = fieldFromInstruction(insn, 7, 5);
18175 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18176 tmp = fieldFromInstruction(insn, 15, 5);
18177 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18178 tmp = 0x0;
18179 tmp |= fieldFromInstruction(insn, 12, 3);
18180 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18181 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18182 return S;
18183 case 184:
18184 tmp = fieldFromInstruction(insn, 7, 5);
18185 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18186 tmp = 0x0;
18187 tmp |= fieldFromInstruction(insn, 14, 1);
18188 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
18189 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
18190 tmp |= fieldFromInstruction(insn, 20, 1) << 11;
18191 tmp |= fieldFromInstruction(insn, 21, 10) << 1;
18192 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
18193 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18194 return S;
18195 case 185:
18196 tmp = fieldFromInstruction(insn, 20, 5);
18197 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18198 tmp = 0x0;
18199 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18200 tmp |= fieldFromInstruction(insn, 8, 4);
18201 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
18202 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
18203 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18204 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18205 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18206 return S;
18207 case 186:
18208 tmp = fieldFromInstruction(insn, 20, 5);
18209 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18210 tmp = 0x0;
18211 tmp |= fieldFromInstruction(insn, 7, 1) << 9;
18212 tmp |= fieldFromInstruction(insn, 8, 1) << 15;
18213 tmp |= fieldFromInstruction(insn, 9, 3);
18214 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
18215 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
18216 tmp |= fieldFromInstruction(insn, 25, 6) << 3;
18217 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18218 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18219 return S;
18220 case 187:
18221 tmp = fieldFromInstruction(insn, 7, 5);
18222 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18223 tmp = fieldFromInstruction(insn, 20, 5);
18224 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18225 return S;
18226 case 188:
18227 tmp = fieldFromInstruction(insn, 7, 5);
18228 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18229 tmp = fieldFromInstruction(insn, 20, 5);
18230 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18231 return S;
18232 case 189:
18233 tmp = fieldFromInstruction(insn, 7, 5);
18234 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18235 tmp = fieldFromInstruction(insn, 15, 5);
18236 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18237 tmp = fieldFromInstruction(insn, 20, 5);
18238 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18239 tmp = fieldFromInstruction(insn, 25, 1);
18240 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18241 return S;
18242 case 190:
18243 tmp = fieldFromInstruction(insn, 7, 5);
18244 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18245 tmp = 0x0;
18246 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
18247 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
18248 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
18249 tmp |= fieldFromInstruction(insn, 21, 10);
18250 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18251 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18252 return S;
18253 case 191:
18254 tmp = fieldFromInstruction(insn, 15, 5);
18255 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18256 tmp = 0x0;
18257 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
18258 tmp |= fieldFromInstruction(insn, 20, 5);
18259 tmp |= fieldFromInstruction(insn, 30, 1) << 6;
18260 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18261 tmp = 0x0;
18262 tmp |= fieldFromInstruction(insn, 8, 4);
18263 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
18264 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
18265 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18266 return S;
18267 case 192:
18268 tmp = fieldFromInstruction(insn, 7, 5);
18269 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18270 tmp = 0x0;
18271 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
18272 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
18273 tmp |= fieldFromInstruction(insn, 20, 1) << 9;
18274 tmp |= fieldFromInstruction(insn, 21, 1) << 15;
18275 tmp |= fieldFromInstruction(insn, 22, 9);
18276 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18277 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18278 return S;
18279 case 193:
18280 tmp = fieldFromInstruction(insn, 7, 5);
18281 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18282 tmp = fieldFromInstruction(insn, 15, 5);
18283 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18284 tmp = fieldFromInstruction(insn, 26, 6);
18285 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18286 tmp = fieldFromInstruction(insn, 20, 6);
18287 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18288 return S;
18289 case 194:
18290 tmp = fieldFromInstruction(insn, 20, 5);
18291 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18292 tmp = 0x0;
18293 tmp |= fieldFromInstruction(insn, 7, 1) << 11;
18294 tmp |= fieldFromInstruction(insn, 8, 4) << 1;
18295 tmp |= fieldFromInstruction(insn, 14, 1);
18296 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
18297 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
18298 tmp |= fieldFromInstruction(insn, 25, 6) << 5;
18299 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
18300 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18301 return S;
18302 case 195:
18303 tmp = fieldFromInstruction(insn, 7, 5);
18304 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18305 tmp = 0x0;
18306 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
18307 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
18308 tmp |= fieldFromInstruction(insn, 20, 1) << 8;
18309 tmp |= fieldFromInstruction(insn, 21, 2) << 14;
18310 tmp |= fieldFromInstruction(insn, 23, 8);
18311 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18312 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18313 return S;
18314 case 196:
18315 tmp = fieldFromInstruction(insn, 20, 5);
18316 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18317 tmp = 0x0;
18318 tmp |= fieldFromInstruction(insn, 7, 1) << 8;
18319 tmp |= fieldFromInstruction(insn, 8, 2) << 14;
18320 tmp |= fieldFromInstruction(insn, 10, 2);
18321 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
18322 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
18323 tmp |= fieldFromInstruction(insn, 25, 6) << 2;
18324 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18325 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18326 return S;
18327 case 197:
18328 tmp = fieldFromInstruction(insn, 15, 5);
18329 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18330 tmp = 0x0;
18331 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
18332 tmp |= fieldFromInstruction(insn, 20, 5);
18333 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18334 tmp = 0x0;
18335 tmp |= fieldFromInstruction(insn, 8, 4);
18336 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
18337 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
18338 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18339 return S;
18340 case 198:
18341 tmp = fieldFromInstruction(insn, 7, 5);
18342 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18343 tmp = fieldFromInstruction(insn, 15, 5);
18344 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18345 tmp = fieldFromInstruction(insn, 15, 5);
18346 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18347 tmp = fieldFromInstruction(insn, 20, 12);
18348 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18349 return S;
18350 case 199:
18351 tmp = fieldFromInstruction(insn, 15, 5);
18352 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18353 tmp = fieldFromInstruction(insn, 20, 5);
18354 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18355 tmp = fieldFromInstruction(insn, 15, 5);
18356 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18357 tmp = 0x0;
18358 tmp |= fieldFromInstruction(insn, 7, 5);
18359 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18360 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18361 return S;
18362 case 200:
18363 tmp = fieldFromInstruction(insn, 7, 5);
18364 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18365 tmp = fieldFromInstruction(insn, 15, 5);
18366 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18367 tmp = fieldFromInstruction(insn, 25, 5);
18368 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18369 tmp = fieldFromInstruction(insn, 20, 5);
18370 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18371 return S;
18372 case 201:
18373 tmp = fieldFromInstruction(insn, 7, 5);
18374 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18375 tmp = fieldFromInstruction(insn, 7, 5);
18376 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18377 tmp = fieldFromInstruction(insn, 15, 5);
18378 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18379 tmp = fieldFromInstruction(insn, 25, 5);
18380 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18381 tmp = fieldFromInstruction(insn, 20, 5);
18382 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18383 return S;
18384 case 202:
18385 tmp = fieldFromInstruction(insn, 7, 5);
18386 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18387 tmp = fieldFromInstruction(insn, 15, 5);
18388 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18389 tmp = 0x0;
18390 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18391 tmp |= fieldFromInstruction(insn, 25, 1);
18392 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18393 return S;
18394 case 203:
18395 tmp = fieldFromInstruction(insn, 7, 5);
18396 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18397 tmp = fieldFromInstruction(insn, 15, 5);
18398 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18399 tmp = fieldFromInstruction(insn, 25, 5);
18400 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18401 tmp = fieldFromInstruction(insn, 20, 5);
18402 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18403 return S;
18404 case 204:
18405 tmp = fieldFromInstruction(insn, 7, 5);
18406 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18407 tmp = fieldFromInstruction(insn, 15, 5);
18408 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18409 tmp = fieldFromInstruction(insn, 20, 5);
18410 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18411 tmp = fieldFromInstruction(insn, 25, 5);
18412 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18413 return S;
18414 case 205:
18415 tmp = fieldFromInstruction(insn, 7, 5);
18416 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18417 tmp = fieldFromInstruction(insn, 15, 5);
18418 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18419 tmp = fieldFromInstruction(insn, 15, 5);
18420 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18421 tmp = fieldFromInstruction(insn, 20, 5);
18422 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18423 return S;
18424 case 206:
18425 tmp = fieldFromInstruction(insn, 15, 5);
18426 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18427 tmp = fieldFromInstruction(insn, 20, 5);
18428 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18429 tmp = fieldFromInstruction(insn, 15, 5);
18430 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18431 tmp = fieldFromInstruction(insn, 7, 5);
18432 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18433 return S;
18434 case 207:
18435 tmp = fieldFromInstruction(insn, 20, 5);
18436 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18437 tmp = fieldFromInstruction(insn, 15, 5);
18438 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18439 tmp = fieldFromInstruction(insn, 7, 5);
18440 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18441 return S;
18442 case 208:
18443 tmp = fieldFromInstruction(insn, 7, 5);
18444 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18445 tmp = fieldFromInstruction(insn, 7, 5);
18446 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18447 tmp = fieldFromInstruction(insn, 15, 5);
18448 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18449 tmp = 0x0;
18450 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18451 tmp |= fieldFromInstruction(insn, 25, 1);
18452 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18453 return S;
18454 case 209:
18455 tmp = fieldFromInstruction(insn, 15, 5);
18456 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18457 tmp = fieldFromInstruction(insn, 20, 5);
18458 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18459 tmp = 0x0;
18460 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18461 tmp |= fieldFromInstruction(insn, 8, 4);
18462 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18463 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18464 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18465 return S;
18466 case 210:
18467 tmp = fieldFromInstruction(insn, 7, 5);
18468 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18469 tmp = fieldFromInstruction(insn, 7, 5);
18470 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18471 tmp = fieldFromInstruction(insn, 15, 5);
18472 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18473 tmp = fieldFromInstruction(insn, 20, 5);
18474 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18475 tmp = fieldFromInstruction(insn, 25, 5);
18476 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18477 return S;
18478 case 211:
18479 tmp = fieldFromInstruction(insn, 7, 5);
18480 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18481 tmp = fieldFromInstruction(insn, 15, 5);
18482 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18483 tmp = 0x0;
18484 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18485 tmp |= fieldFromInstruction(insn, 25, 1);
18486 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18487 return S;
18488 case 212:
18489 tmp = fieldFromInstruction(insn, 7, 5);
18490 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18491 tmp = fieldFromInstruction(insn, 15, 5);
18492 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18493 tmp = 0x0;
18494 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18495 tmp |= fieldFromInstruction(insn, 25, 1);
18496 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18497 return S;
18498 case 213:
18499 tmp = fieldFromInstruction(insn, 7, 5);
18500 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18501 tmp = fieldFromInstruction(insn, 7, 5);
18502 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18503 tmp = fieldFromInstruction(insn, 15, 5);
18504 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18505 tmp = 0x0;
18506 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18507 tmp |= fieldFromInstruction(insn, 25, 1);
18508 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18509 return S;
18510 case 214:
18511 tmp = fieldFromInstruction(insn, 7, 5);
18512 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18513 tmp = fieldFromInstruction(insn, 15, 5);
18514 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18515 tmp = 0x0;
18516 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
18517 tmp |= fieldFromInstruction(insn, 25, 1);
18518 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18519 return S;
18520 case 215:
18521 tmp = fieldFromInstruction(insn, 15, 5);
18522 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18523 tmp = fieldFromInstruction(insn, 20, 9);
18524 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18525 tmp = fieldFromInstruction(insn, 7, 5);
18526 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18527 return S;
18528 case 216:
18529 tmp = fieldFromInstruction(insn, 7, 5);
18530 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18531 tmp = fieldFromInstruction(insn, 15, 5);
18532 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18533 tmp = fieldFromInstruction(insn, 20, 5);
18534 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18535 tmp = fieldFromInstruction(insn, 27, 5);
18536 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18537 return S;
18538 case 217:
18539 tmp = fieldFromInstruction(insn, 7, 5);
18540 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18541 tmp = fieldFromInstruction(insn, 27, 5);
18542 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18543 tmp = fieldFromInstruction(insn, 15, 5);
18544 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18545 tmp = fieldFromInstruction(insn, 23, 4) << 3;
18546 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18547 return S;
18548 case 218:
18549 tmp = fieldFromInstruction(insn, 7, 5);
18550 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18551 tmp = fieldFromInstruction(insn, 27, 5);
18552 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18553 tmp = fieldFromInstruction(insn, 15, 5);
18554 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18555 tmp = fieldFromInstruction(insn, 22, 5) << 2;
18556 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18557 return S;
18558 case 219:
18559 tmp = fieldFromInstruction(insn, 20, 5);
18560 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18561 tmp = fieldFromInstruction(insn, 27, 5);
18562 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
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, 10, 2) << 3;
18567 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
18568 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18569 return S;
18570 case 220:
18571 tmp = fieldFromInstruction(insn, 20, 5);
18572 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18573 tmp = fieldFromInstruction(insn, 27, 5);
18574 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18575 tmp = fieldFromInstruction(insn, 15, 5);
18576 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18577 tmp = 0x0;
18578 tmp |= fieldFromInstruction(insn, 9, 3) << 2;
18579 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
18580 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18581 return S;
18582 case 221:
18583 tmp = fieldFromInstruction(insn, 7, 5);
18584 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18585 tmp = fieldFromInstruction(insn, 7, 5);
18586 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18587 tmp = fieldFromInstruction(insn, 15, 5);
18588 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18589 tmp = fieldFromInstruction(insn, 20, 5);
18590 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18591 return S;
18592 case 222:
18593 tmp = fieldFromInstruction(insn, 7, 5);
18594 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18595 tmp = fieldFromInstruction(insn, 7, 5);
18596 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18597 tmp = fieldFromInstruction(insn, 16, 4) << 1;
18598 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18599 tmp = fieldFromInstruction(insn, 20, 5);
18600 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18601 return S;
18602 case 223:
18603 tmp = fieldFromInstruction(insn, 7, 5);
18604 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18605 tmp = fieldFromInstruction(insn, 26, 2);
18606 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18607 tmp = fieldFromInstruction(insn, 20, 5);
18608 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18609 tmp = fieldFromInstruction(insn, 15, 5);
18610 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18611 return S;
18612 case 224:
18613 tmp = fieldFromInstruction(insn, 26, 2);
18614 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18615 tmp = fieldFromInstruction(insn, 20, 5);
18616 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18617 tmp = fieldFromInstruction(insn, 7, 5);
18618 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18619 tmp = fieldFromInstruction(insn, 15, 5);
18620 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18621 return S;
18622 case 225:
18623 tmp = fieldFromInstruction(insn, 7, 5);
18624 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18625 tmp = fieldFromInstruction(insn, 26, 2);
18626 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18627 tmp = fieldFromInstruction(insn, 20, 5);
18628 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18629 tmp = fieldFromInstruction(insn, 15, 5);
18630 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18631 return S;
18632 case 226:
18633 tmp = fieldFromInstruction(insn, 26, 2);
18634 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18635 tmp = fieldFromInstruction(insn, 20, 5);
18636 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18637 tmp = fieldFromInstruction(insn, 7, 5);
18638 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18639 tmp = fieldFromInstruction(insn, 15, 5);
18640 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18641 return S;
18642 case 227:
18643 tmp = fieldFromInstruction(insn, 7, 5);
18644 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18645 tmp = fieldFromInstruction(insn, 26, 2);
18646 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18647 tmp = fieldFromInstruction(insn, 20, 5);
18648 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18649 tmp = fieldFromInstruction(insn, 15, 5);
18650 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18651 return S;
18652 case 228:
18653 tmp = fieldFromInstruction(insn, 26, 2);
18654 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18655 tmp = fieldFromInstruction(insn, 7, 5);
18656 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18657 tmp = fieldFromInstruction(insn, 20, 5);
18658 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18659 tmp = fieldFromInstruction(insn, 15, 5);
18660 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18661 return S;
18662 case 229:
18663 tmp = fieldFromInstruction(insn, 7, 5);
18664 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18665 tmp = fieldFromInstruction(insn, 26, 2);
18666 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18667 tmp = fieldFromInstruction(insn, 20, 5);
18668 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18669 tmp = fieldFromInstruction(insn, 15, 5);
18670 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18671 return S;
18672 case 230:
18673 tmp = fieldFromInstruction(insn, 26, 2);
18674 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18675 tmp = fieldFromInstruction(insn, 7, 5);
18676 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18677 tmp = fieldFromInstruction(insn, 20, 5);
18678 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18679 tmp = fieldFromInstruction(insn, 15, 5);
18680 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18681 return S;
18682 case 231:
18683 tmp = fieldFromInstruction(insn, 7, 5);
18684 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18685 tmp = fieldFromInstruction(insn, 26, 2);
18686 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18687 tmp = fieldFromInstruction(insn, 20, 5);
18688 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18689 tmp = fieldFromInstruction(insn, 15, 5);
18690 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18691 return S;
18692 case 232:
18693 tmp = fieldFromInstruction(insn, 26, 2);
18694 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18695 tmp = fieldFromInstruction(insn, 7, 5);
18696 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18697 tmp = fieldFromInstruction(insn, 20, 5);
18698 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18699 tmp = fieldFromInstruction(insn, 15, 5);
18700 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18701 return S;
18702 case 233:
18703 tmp = fieldFromInstruction(insn, 7, 5);
18704 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18705 tmp = fieldFromInstruction(insn, 26, 1);
18706 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18707 tmp = fieldFromInstruction(insn, 20, 5);
18708 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18709 tmp = fieldFromInstruction(insn, 15, 5);
18710 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18711 return S;
18712 case 234:
18713 tmp = fieldFromInstruction(insn, 26, 1);
18714 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18715 tmp = fieldFromInstruction(insn, 7, 5);
18716 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18717 tmp = fieldFromInstruction(insn, 20, 5);
18718 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18719 tmp = fieldFromInstruction(insn, 15, 5);
18720 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18721 return S;
18722 case 235:
18723 tmp = fieldFromInstruction(insn, 8, 4);
18724 if (!Check(S, DecodeSimpleRegisterClass<RISCV::T0, 16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18725 return S;
18726 case 236:
18727 tmp = fieldFromInstruction(insn, 15, 5);
18728 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18729 tmp = fieldFromInstruction(insn, 20, 5);
18730 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18731 return S;
18732 case 237:
18733 tmp = fieldFromInstruction(insn, 7, 5);
18734 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18735 tmp = fieldFromInstruction(insn, 26, 2);
18736 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18737 tmp = fieldFromInstruction(insn, 7, 5);
18738 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18739 tmp = fieldFromInstruction(insn, 20, 5);
18740 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18741 tmp = fieldFromInstruction(insn, 15, 5);
18742 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18743 return S;
18744 case 238:
18745 tmp = fieldFromInstruction(insn, 26, 2);
18746 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18747 tmp = fieldFromInstruction(insn, 7, 5);
18748 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18749 tmp = fieldFromInstruction(insn, 20, 5);
18750 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18751 tmp = fieldFromInstruction(insn, 15, 5);
18752 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18753 return S;
18754 case 239:
18755 tmp = fieldFromInstruction(insn, 7, 5);
18756 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18757 tmp = fieldFromInstruction(insn, 26, 2);
18758 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18759 tmp = fieldFromInstruction(insn, 7, 5);
18760 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18761 tmp = fieldFromInstruction(insn, 20, 5);
18762 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18763 tmp = fieldFromInstruction(insn, 15, 5);
18764 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18765 return S;
18766 case 240:
18767 tmp = fieldFromInstruction(insn, 26, 2);
18768 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18769 tmp = fieldFromInstruction(insn, 7, 5);
18770 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18771 tmp = fieldFromInstruction(insn, 20, 5);
18772 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18773 tmp = fieldFromInstruction(insn, 15, 5);
18774 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18775 return S;
18776 case 241:
18777 tmp = fieldFromInstruction(insn, 7, 5);
18778 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18779 tmp = fieldFromInstruction(insn, 26, 2);
18780 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18781 tmp = fieldFromInstruction(insn, 7, 5);
18782 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18783 tmp = fieldFromInstruction(insn, 20, 5);
18784 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18785 tmp = fieldFromInstruction(insn, 15, 5);
18786 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18787 return S;
18788 case 242:
18789 tmp = fieldFromInstruction(insn, 26, 2);
18790 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18791 tmp = fieldFromInstruction(insn, 7, 5);
18792 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18793 tmp = fieldFromInstruction(insn, 20, 5);
18794 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18795 tmp = fieldFromInstruction(insn, 15, 5);
18796 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18797 return S;
18798 case 243:
18799 tmp = fieldFromInstruction(insn, 7, 5);
18800 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18801 tmp = fieldFromInstruction(insn, 26, 1);
18802 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18803 tmp = fieldFromInstruction(insn, 7, 5);
18804 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18805 tmp = fieldFromInstruction(insn, 20, 5);
18806 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18807 tmp = fieldFromInstruction(insn, 15, 5);
18808 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18809 return S;
18810 case 244:
18811 tmp = fieldFromInstruction(insn, 26, 1);
18812 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18813 tmp = fieldFromInstruction(insn, 7, 5);
18814 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18815 tmp = fieldFromInstruction(insn, 20, 5);
18816 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18817 tmp = fieldFromInstruction(insn, 15, 5);
18818 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18819 return S;
18820 case 245:
18821 tmp = fieldFromInstruction(insn, 7, 5);
18822 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18823 tmp = fieldFromInstruction(insn, 7, 5);
18824 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18825 tmp = fieldFromInstruction(insn, 15, 5);
18826 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18827 tmp = fieldFromInstruction(insn, 20, 5);
18828 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18829 return S;
18830 case 246:
18831 tmp = fieldFromInstruction(insn, 10, 2) << 2;
18832 if (!Check(S, DecodeTRM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18833 tmp = fieldFromInstruction(insn, 20, 5);
18834 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18835 tmp = fieldFromInstruction(insn, 15, 5);
18836 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18837 return S;
18838 case 247:
18839 tmp = fieldFromInstruction(insn, 9, 3) << 1;
18840 if (!Check(S, DecodeTRM2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18841 tmp = fieldFromInstruction(insn, 20, 5);
18842 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18843 tmp = fieldFromInstruction(insn, 15, 5);
18844 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18845 return S;
18846 case 248:
18847 tmp = fieldFromInstruction(insn, 7, 5);
18848 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18849 tmp = fieldFromInstruction(insn, 15, 5);
18850 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18851 tmp = fieldFromInstruction(insn, 20, 5);
18852 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18853 tmp = fieldFromInstruction(insn, 25, 2);
18854 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18855 return S;
18856 case 249:
18857 tmp = fieldFromInstruction(insn, 7, 5);
18858 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18859 tmp = fieldFromInstruction(insn, 15, 5);
18860 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18861 tmp = fieldFromInstruction(insn, 15, 5);
18862 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18863 tmp = fieldFromInstruction(insn, 20, 5);
18864 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18865 tmp = fieldFromInstruction(insn, 25, 2);
18866 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18867 return S;
18868 case 250:
18869 tmp = fieldFromInstruction(insn, 7, 5);
18870 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18871 tmp = fieldFromInstruction(insn, 20, 5);
18872 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18873 tmp = fieldFromInstruction(insn, 15, 5);
18874 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18875 tmp = fieldFromInstruction(insn, 25, 2);
18876 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18877 if (!Check(Out&: S, In: decodeImmThreeOperand(Inst&: MI, Decoder)))
18878 return MCDisassembler::Fail;
18879 return S;
18880 case 251:
18881 tmp = fieldFromInstruction(insn, 7, 5);
18882 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18883 tmp = fieldFromInstruction(insn, 20, 5);
18884 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18885 tmp = fieldFromInstruction(insn, 15, 5);
18886 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18887 tmp = fieldFromInstruction(insn, 25, 2);
18888 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18889 if (!Check(Out&: S, In: decodeImmFourOperand(Inst&: MI, Decoder)))
18890 return MCDisassembler::Fail;
18891 return S;
18892 case 252:
18893 tmp = fieldFromInstruction(insn, 15, 5);
18894 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18895 tmp = fieldFromInstruction(insn, 7, 5);
18896 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18897 tmp = fieldFromInstruction(insn, 15, 5);
18898 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18899 tmp = fieldFromInstruction(insn, 20, 5);
18900 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18901 tmp = fieldFromInstruction(insn, 25, 2);
18902 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18903 return S;
18904 case 253:
18905 tmp = fieldFromInstruction(insn, 7, 5);
18906 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18907 tmp = fieldFromInstruction(insn, 15, 5);
18908 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18909 tmp = fieldFromInstruction(insn, 20, 5);
18910 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18911 tmp = fieldFromInstruction(insn, 25, 2);
18912 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18913 return S;
18914 case 254:
18915 tmp = fieldFromInstruction(insn, 7, 5);
18916 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18917 tmp = fieldFromInstruction(insn, 15, 5);
18918 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18919 tmp = fieldFromInstruction(insn, 20, 5);
18920 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18921 tmp = fieldFromInstruction(insn, 25, 2);
18922 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18923 return S;
18924 case 255:
18925 tmp = fieldFromInstruction(insn, 7, 5);
18926 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18927 tmp = fieldFromInstruction(insn, 15, 5);
18928 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18929 tmp = fieldFromInstruction(insn, 20, 11);
18930 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18931 return S;
18932 case 256:
18933 tmp = fieldFromInstruction(insn, 7, 5);
18934 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18935 tmp = fieldFromInstruction(insn, 7, 5);
18936 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18937 tmp = fieldFromInstruction(insn, 15, 5);
18938 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18939 tmp = fieldFromInstruction(insn, 20, 11);
18940 if (!Check(S, decodeSImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18941 return S;
18942 case 257:
18943 tmp = fieldFromInstruction(insn, 7, 5);
18944 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18945 tmp = fieldFromInstruction(insn, 7, 5);
18946 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18947 tmp = fieldFromInstruction(insn, 15, 5);
18948 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18949 tmp = fieldFromInstruction(insn, 25, 5);
18950 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18951 tmp = fieldFromInstruction(insn, 20, 5);
18952 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18953 return S;
18954 case 258:
18955 tmp = fieldFromInstruction(insn, 7, 5);
18956 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18957 tmp = fieldFromInstruction(insn, 7, 5);
18958 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18959 tmp = fieldFromInstruction(insn, 15, 5);
18960 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18961 tmp = fieldFromInstruction(insn, 25, 5);
18962 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18963 tmp = fieldFromInstruction(insn, 20, 5);
18964 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18965 return S;
18966 case 259:
18967 tmp = fieldFromInstruction(insn, 7, 5);
18968 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18969 tmp = fieldFromInstruction(insn, 15, 5);
18970 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18971 tmp = fieldFromInstruction(insn, 25, 5);
18972 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18973 tmp = fieldFromInstruction(insn, 20, 5);
18974 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18975 return S;
18976 case 260:
18977 tmp = fieldFromInstruction(insn, 7, 5);
18978 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18979 tmp = fieldFromInstruction(insn, 15, 5);
18980 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18981 tmp = fieldFromInstruction(insn, 25, 5);
18982 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18983 tmp = fieldFromInstruction(insn, 20, 5);
18984 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18985 return S;
18986 case 261:
18987 tmp = fieldFromInstruction(insn, 7, 5);
18988 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18989 tmp = fieldFromInstruction(insn, 15, 5);
18990 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18991 return S;
18992 case 262:
18993 tmp = fieldFromInstruction(insn, 7, 5);
18994 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18995 tmp = fieldFromInstruction(insn, 7, 5);
18996 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18997 tmp = fieldFromInstruction(insn, 15, 5);
18998 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18999 tmp = fieldFromInstruction(insn, 20, 5);
19000 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19001 return S;
19002 case 263:
19003 tmp = fieldFromInstruction(insn, 7, 5);
19004 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19005 tmp = fieldFromInstruction(insn, 15, 5);
19006 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19007 tmp = fieldFromInstruction(insn, 20, 5);
19008 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19009 return S;
19010 case 264:
19011 tmp = fieldFromInstruction(insn, 7, 5);
19012 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19013 tmp = fieldFromInstruction(insn, 15, 5);
19014 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19015 tmp = fieldFromInstruction(insn, 20, 5);
19016 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19017 return S;
19018 case 265:
19019 tmp = fieldFromInstruction(insn, 7, 5);
19020 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19021 tmp = fieldFromInstruction(insn, 15, 5);
19022 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19023 tmp = fieldFromInstruction(insn, 20, 5);
19024 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19025 return S;
19026 case 266:
19027 tmp = fieldFromInstruction(insn, 7, 5);
19028 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19029 tmp = fieldFromInstruction(insn, 15, 5);
19030 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19031 tmp = fieldFromInstruction(insn, 20, 5);
19032 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19033 tmp = fieldFromInstruction(insn, 25, 5);
19034 if (!Check(S, decodeUImmOperandGE<5, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19035 return S;
19036 case 267:
19037 tmp = fieldFromInstruction(insn, 7, 5);
19038 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19039 tmp = fieldFromInstruction(insn, 15, 5);
19040 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19041 tmp = fieldFromInstruction(insn, 20, 12) << 2;
19042 if (!Check(S, decodeUImmOperand<14>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19043 return S;
19044 case 268:
19045 tmp = fieldFromInstruction(insn, 7, 5);
19046 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19047 tmp = fieldFromInstruction(insn, 15, 5);
19048 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19049 tmp = fieldFromInstruction(insn, 20, 12) << 2;
19050 if (!Check(S, decodeUImmOperand<14>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19051 return S;
19052 case 269:
19053 tmp = fieldFromInstruction(insn, 7, 5);
19054 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19055 tmp = fieldFromInstruction(insn, 7, 5);
19056 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19057 tmp = fieldFromInstruction(insn, 15, 5);
19058 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19059 tmp = fieldFromInstruction(insn, 20, 12);
19060 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19061 return S;
19062 case 270:
19063 tmp = fieldFromInstruction(insn, 7, 5);
19064 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19065 tmp = fieldFromInstruction(insn, 15, 5);
19066 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19067 tmp = fieldFromInstruction(insn, 20, 5);
19068 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19069 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19070 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19071 return S;
19072 case 271:
19073 tmp = fieldFromInstruction(insn, 7, 5);
19074 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19075 tmp = fieldFromInstruction(insn, 15, 5);
19076 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19077 tmp = fieldFromInstruction(insn, 20, 5);
19078 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19079 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19080 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19081 return S;
19082 case 272:
19083 tmp = fieldFromInstruction(insn, 7, 5);
19084 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19085 tmp = fieldFromInstruction(insn, 15, 5);
19086 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19087 tmp = fieldFromInstruction(insn, 20, 5);
19088 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19089 tmp = fieldFromInstruction(insn, 25, 3);
19090 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19091 return S;
19092 case 273:
19093 tmp = fieldFromInstruction(insn, 20, 5);
19094 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19095 return S;
19096 case 274:
19097 tmp = fieldFromInstruction(insn, 20, 8);
19098 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19099 return S;
19100 case 275:
19101 tmp = fieldFromInstruction(insn, 7, 5);
19102 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19103 tmp = 0x0;
19104 tmp |= fieldFromInstruction(insn, 12, 4) << 15;
19105 tmp |= fieldFromInstruction(insn, 16, 15);
19106 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
19107 if (!Check(S, decodeSImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19108 return S;
19109 case 276:
19110 tmp = fieldFromInstruction(insn, 7, 5);
19111 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19112 tmp = fieldFromInstruction(insn, 15, 5);
19113 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19114 tmp = fieldFromInstruction(insn, 20, 5);
19115 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19116 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19117 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19118 return S;
19119 case 277:
19120 tmp = fieldFromInstruction(insn, 7, 5);
19121 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19122 tmp = fieldFromInstruction(insn, 15, 5);
19123 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19124 tmp = fieldFromInstruction(insn, 20, 5);
19125 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19126 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19127 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19128 return S;
19129 case 278:
19130 tmp = fieldFromInstruction(insn, 7, 5);
19131 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19132 tmp = fieldFromInstruction(insn, 7, 5);
19133 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19134 tmp = fieldFromInstruction(insn, 15, 5);
19135 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19136 tmp = fieldFromInstruction(insn, 20, 5);
19137 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19138 tmp = fieldFromInstruction(insn, 27, 5);
19139 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19140 return S;
19141 case 279:
19142 tmp = fieldFromInstruction(insn, 7, 5);
19143 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19144 tmp = fieldFromInstruction(insn, 7, 5);
19145 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19146 tmp = fieldFromInstruction(insn, 15, 5);
19147 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19148 tmp = fieldFromInstruction(insn, 20, 5);
19149 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19150 tmp = fieldFromInstruction(insn, 27, 5);
19151 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19152 return S;
19153 case 280:
19154 tmp = fieldFromInstruction(insn, 7, 5);
19155 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19156 tmp = fieldFromInstruction(insn, 7, 5);
19157 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19158 tmp = fieldFromInstruction(insn, 15, 5);
19159 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19160 tmp = fieldFromInstruction(insn, 20, 5);
19161 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19162 tmp = fieldFromInstruction(insn, 27, 5);
19163 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19164 return S;
19165 case 281:
19166 tmp = fieldFromInstruction(insn, 7, 5);
19167 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19168 tmp = fieldFromInstruction(insn, 7, 5);
19169 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19170 tmp = fieldFromInstruction(insn, 15, 5);
19171 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19172 tmp = fieldFromInstruction(insn, 20, 5);
19173 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19174 tmp = fieldFromInstruction(insn, 27, 5);
19175 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19176 return S;
19177 case 282:
19178 tmp = fieldFromInstruction(insn, 7, 5);
19179 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19180 tmp = fieldFromInstruction(insn, 7, 5);
19181 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19182 tmp = fieldFromInstruction(insn, 15, 5);
19183 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19184 tmp = fieldFromInstruction(insn, 20, 5);
19185 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19186 tmp = fieldFromInstruction(insn, 27, 5);
19187 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19188 return S;
19189 case 283:
19190 tmp = fieldFromInstruction(insn, 7, 5);
19191 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19192 tmp = fieldFromInstruction(insn, 7, 5);
19193 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19194 tmp = fieldFromInstruction(insn, 15, 5);
19195 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19196 tmp = fieldFromInstruction(insn, 20, 5);
19197 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19198 tmp = fieldFromInstruction(insn, 27, 5);
19199 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19200 return S;
19201 case 284:
19202 tmp = fieldFromInstruction(insn, 7, 5);
19203 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19204 tmp = fieldFromInstruction(insn, 7, 5);
19205 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19206 tmp = fieldFromInstruction(insn, 15, 5);
19207 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19208 tmp = fieldFromInstruction(insn, 20, 5);
19209 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19210 tmp = fieldFromInstruction(insn, 27, 5);
19211 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19212 return S;
19213 case 285:
19214 tmp = fieldFromInstruction(insn, 7, 5);
19215 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19216 tmp = fieldFromInstruction(insn, 7, 5);
19217 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19218 tmp = fieldFromInstruction(insn, 15, 5);
19219 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19220 tmp = fieldFromInstruction(insn, 20, 5);
19221 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19222 tmp = fieldFromInstruction(insn, 27, 5);
19223 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19224 return S;
19225 case 286:
19226 tmp = fieldFromInstruction(insn, 7, 5);
19227 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19228 tmp = fieldFromInstruction(insn, 15, 5);
19229 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19230 tmp = fieldFromInstruction(insn, 20, 5);
19231 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19232 return S;
19233 case 287:
19234 tmp = fieldFromInstruction(insn, 7, 5);
19235 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19236 tmp = fieldFromInstruction(insn, 15, 5);
19237 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19238 tmp = fieldFromInstruction(insn, 20, 5);
19239 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19240 return S;
19241 case 288:
19242 tmp = fieldFromInstruction(insn, 15, 10);
19243 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19244 return S;
19245 case 289:
19246 tmp = fieldFromInstruction(insn, 15, 5);
19247 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19248 tmp = fieldFromInstruction(insn, 20, 5);
19249 if (!Check(S, decodeSImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19250 tmp = 0x0;
19251 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19252 tmp |= fieldFromInstruction(insn, 8, 4);
19253 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19254 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19255 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19256 return S;
19257 case 290:
19258 tmp = fieldFromInstruction(insn, 15, 5);
19259 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19260 tmp = fieldFromInstruction(insn, 20, 5);
19261 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19262 tmp = 0x0;
19263 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19264 tmp |= fieldFromInstruction(insn, 8, 4);
19265 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19266 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19267 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19268 return S;
19269 case 291:
19270 tmp = fieldFromInstruction(insn, 7, 5);
19271 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19272 tmp = fieldFromInstruction(insn, 15, 5);
19273 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19274 tmp = fieldFromInstruction(insn, 12, 3);
19275 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19276 return S;
19277 case 292:
19278 tmp = fieldFromInstruction(insn, 7, 5);
19279 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19280 tmp = fieldFromInstruction(insn, 15, 5);
19281 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19282 tmp = fieldFromInstruction(insn, 12, 3);
19283 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19284 return S;
19285 case 293:
19286 tmp = fieldFromInstruction(insn, 7, 5);
19287 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19288 tmp = fieldFromInstruction(insn, 15, 5);
19289 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19290 tmp = fieldFromInstruction(insn, 20, 5);
19291 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19292 tmp = fieldFromInstruction(insn, 27, 5);
19293 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19294 tmp = fieldFromInstruction(insn, 12, 3);
19295 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19296 return S;
19297 case 294:
19298 tmp = fieldFromInstruction(insn, 7, 5);
19299 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19300 tmp = fieldFromInstruction(insn, 15, 5);
19301 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19302 tmp = fieldFromInstruction(insn, 20, 5);
19303 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19304 tmp = fieldFromInstruction(insn, 12, 3);
19305 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19306 return S;
19307 case 295:
19308 tmp = fieldFromInstruction(insn, 7, 5);
19309 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19310 tmp = fieldFromInstruction(insn, 15, 5);
19311 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19312 tmp = fieldFromInstruction(insn, 20, 5);
19313 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19314 return S;
19315 case 296:
19316 tmp = fieldFromInstruction(insn, 7, 5);
19317 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19318 tmp = fieldFromInstruction(insn, 15, 5);
19319 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19320 tmp = fieldFromInstruction(insn, 12, 3);
19321 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19322 return S;
19323 case 297:
19324 tmp = fieldFromInstruction(insn, 7, 5);
19325 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19326 tmp = fieldFromInstruction(insn, 15, 5);
19327 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19328 tmp = fieldFromInstruction(insn, 12, 3);
19329 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19330 return S;
19331 case 298:
19332 tmp = fieldFromInstruction(insn, 7, 5);
19333 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19334 tmp = fieldFromInstruction(insn, 15, 5);
19335 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19336 tmp = fieldFromInstruction(insn, 12, 3);
19337 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19338 return S;
19339 case 299:
19340 tmp = fieldFromInstruction(insn, 7, 5);
19341 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19342 tmp = fieldFromInstruction(insn, 15, 5);
19343 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19344 tmp = fieldFromInstruction(insn, 20, 5);
19345 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19346 return S;
19347 case 300:
19348 tmp = fieldFromInstruction(insn, 7, 5);
19349 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19350 tmp = fieldFromInstruction(insn, 15, 5);
19351 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19352 tmp = fieldFromInstruction(insn, 12, 3);
19353 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19354 return S;
19355 case 301:
19356 tmp = fieldFromInstruction(insn, 7, 5);
19357 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19358 tmp = fieldFromInstruction(insn, 15, 5);
19359 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19360 tmp = fieldFromInstruction(insn, 12, 3);
19361 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19362 return S;
19363 case 302:
19364 tmp = fieldFromInstruction(insn, 7, 5);
19365 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19366 tmp = fieldFromInstruction(insn, 15, 5);
19367 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19368 return S;
19369 case 303:
19370 tmp = fieldFromInstruction(insn, 7, 5);
19371 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19372 tmp = fieldFromInstruction(insn, 15, 5);
19373 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19374 tmp = fieldFromInstruction(insn, 20, 5);
19375 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19376 tmp = fieldFromInstruction(insn, 27, 5);
19377 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19378 tmp = fieldFromInstruction(insn, 12, 3);
19379 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19380 return S;
19381 case 304:
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, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19388 tmp = fieldFromInstruction(insn, 27, 5);
19389 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19390 tmp = fieldFromInstruction(insn, 12, 3);
19391 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19392 return S;
19393 case 305:
19394 tmp = fieldFromInstruction(insn, 7, 5);
19395 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19396 tmp = fieldFromInstruction(insn, 15, 5);
19397 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19398 tmp = fieldFromInstruction(insn, 20, 5);
19399 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19400 tmp = fieldFromInstruction(insn, 27, 5);
19401 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19402 tmp = fieldFromInstruction(insn, 12, 3);
19403 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19404 return S;
19405 case 306:
19406 tmp = fieldFromInstruction(insn, 7, 5);
19407 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19408 tmp = fieldFromInstruction(insn, 15, 5);
19409 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19410 tmp = fieldFromInstruction(insn, 20, 5);
19411 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19412 tmp = fieldFromInstruction(insn, 12, 3);
19413 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19414 return S;
19415 case 307:
19416 tmp = fieldFromInstruction(insn, 7, 5);
19417 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19418 tmp = fieldFromInstruction(insn, 15, 5);
19419 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19420 tmp = fieldFromInstruction(insn, 20, 5);
19421 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19422 tmp = fieldFromInstruction(insn, 12, 3);
19423 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19424 return S;
19425 case 308:
19426 tmp = fieldFromInstruction(insn, 7, 5);
19427 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19428 tmp = fieldFromInstruction(insn, 15, 5);
19429 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19430 tmp = fieldFromInstruction(insn, 20, 5);
19431 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19432 tmp = fieldFromInstruction(insn, 12, 3);
19433 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19434 return S;
19435 case 309:
19436 tmp = fieldFromInstruction(insn, 7, 5);
19437 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19438 tmp = fieldFromInstruction(insn, 15, 5);
19439 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19440 tmp = fieldFromInstruction(insn, 20, 5);
19441 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19442 return S;
19443 case 310:
19444 tmp = fieldFromInstruction(insn, 7, 5);
19445 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19446 tmp = fieldFromInstruction(insn, 15, 5);
19447 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19448 tmp = fieldFromInstruction(insn, 20, 5);
19449 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19450 return S;
19451 case 311:
19452 tmp = fieldFromInstruction(insn, 7, 5);
19453 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19454 tmp = fieldFromInstruction(insn, 15, 5);
19455 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19456 tmp = fieldFromInstruction(insn, 12, 3);
19457 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19458 return S;
19459 case 312:
19460 tmp = fieldFromInstruction(insn, 7, 5);
19461 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19462 tmp = fieldFromInstruction(insn, 15, 5);
19463 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19464 tmp = fieldFromInstruction(insn, 12, 3);
19465 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19466 return S;
19467 case 313:
19468 tmp = fieldFromInstruction(insn, 7, 5);
19469 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19470 tmp = fieldFromInstruction(insn, 15, 5);
19471 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19472 tmp = fieldFromInstruction(insn, 12, 3);
19473 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19474 return S;
19475 case 314:
19476 tmp = fieldFromInstruction(insn, 7, 5);
19477 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19478 tmp = fieldFromInstruction(insn, 15, 5);
19479 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19480 tmp = fieldFromInstruction(insn, 12, 3);
19481 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19482 return S;
19483 case 315:
19484 tmp = fieldFromInstruction(insn, 7, 5);
19485 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19486 tmp = fieldFromInstruction(insn, 15, 5);
19487 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19488 tmp = fieldFromInstruction(insn, 12, 3);
19489 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19490 return S;
19491 case 316:
19492 tmp = fieldFromInstruction(insn, 7, 5);
19493 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19494 tmp = fieldFromInstruction(insn, 15, 5);
19495 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19496 tmp = fieldFromInstruction(insn, 12, 3);
19497 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19498 return S;
19499 case 317:
19500 tmp = fieldFromInstruction(insn, 7, 5);
19501 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19502 tmp = fieldFromInstruction(insn, 15, 5);
19503 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19504 tmp = fieldFromInstruction(insn, 12, 3);
19505 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19506 return S;
19507 case 318:
19508 tmp = fieldFromInstruction(insn, 7, 5);
19509 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19510 tmp = fieldFromInstruction(insn, 15, 5);
19511 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19512 tmp = fieldFromInstruction(insn, 12, 3);
19513 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19514 return S;
19515 case 319:
19516 tmp = fieldFromInstruction(insn, 7, 5);
19517 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19518 tmp = fieldFromInstruction(insn, 15, 5);
19519 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19520 tmp = fieldFromInstruction(insn, 12, 3);
19521 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19522 return S;
19523 case 320:
19524 tmp = fieldFromInstruction(insn, 7, 5);
19525 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19526 tmp = fieldFromInstruction(insn, 15, 5);
19527 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19528 tmp = fieldFromInstruction(insn, 20, 5);
19529 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19530 return S;
19531 case 321:
19532 tmp = fieldFromInstruction(insn, 7, 5);
19533 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19534 tmp = fieldFromInstruction(insn, 15, 5);
19535 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19536 tmp = fieldFromInstruction(insn, 20, 5);
19537 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19538 return S;
19539 case 322:
19540 tmp = fieldFromInstruction(insn, 7, 5);
19541 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19542 tmp = fieldFromInstruction(insn, 15, 5);
19543 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19544 return S;
19545 case 323:
19546 tmp = fieldFromInstruction(insn, 7, 5);
19547 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19548 tmp = fieldFromInstruction(insn, 15, 5);
19549 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19550 return S;
19551 }
19552}
19553static const uint8_t DecoderTableXqci48[368] = {
19554 48, // 0: BitWidth 48
19555 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
19556 0, 15, // 4: case 0x0: {
19557 OPC_CheckPredicate, 178, 1, // 6: check predicate 178
19558 OPC_CheckField, 15, 1, 0, // 9: check Inst[15] == 0x0
19559 OPC_CheckField, 0, 7, 31, // 13: check Inst[6:0] == 0x1f
19560 OPC_Decode, 163, 122, 0, // 17: decode to QC_E_LI using decoder 0
19561 // 17: }
19562 1, 29, // 21: case 0x1: {
19563 OPC_SwitchField, 15, 1, // 23: switch Inst[15] {
19564 0, 11, // 26: case 0x0: {
19565 OPC_CheckPredicate, 193, 1, // 28: check predicate 193
19566 OPC_CheckField, 0, 7, 31, // 31: check Inst[6:0] == 0x1f
19567 OPC_Decode, 170, 122, 1, // 35: decode to QC_E_XORAI using decoder 1
19568 // 35: }
19569 1, 0, // 39: case 0x1: {
19570 OPC_CheckPredicate, 193, 1, // 41: check predicate 193
19571 OPC_CheckField, 0, 7, 31, // 44: check Inst[6:0] == 0x1f
19572 OPC_Decode, 165, 122, 1, // 48: decode to QC_E_ORAI using decoder 1
19573 // 48: }
19574 // 48: } // switch Inst[15]
19575 // 48: }
19576 2, 29, // 52: case 0x2: {
19577 OPC_SwitchField, 15, 1, // 54: switch Inst[15] {
19578 0, 11, // 57: case 0x0: {
19579 OPC_CheckPredicate, 193, 1, // 59: check predicate 193
19580 OPC_CheckField, 0, 7, 31, // 62: check Inst[6:0] == 0x1f
19581 OPC_Decode, 147, 122, 1, // 66: decode to QC_E_ADDAI using decoder 1
19582 // 66: }
19583 1, 0, // 70: case 0x1: {
19584 OPC_CheckPredicate, 193, 1, // 72: check predicate 193
19585 OPC_CheckField, 0, 7, 31, // 75: check Inst[6:0] == 0x1f
19586 OPC_Decode, 149, 122, 1, // 79: decode to QC_E_ANDAI using decoder 1
19587 // 79: }
19588 // 79: } // switch Inst[15]
19589 // 79: }
19590 3, 55, // 83: case 0x3: {
19591 OPC_SwitchField, 30, 2, // 85: switch Inst[31:30] {
19592 0, 11, // 88: case 0x0: {
19593 OPC_CheckPredicate, 193, 1, // 90: check predicate 193
19594 OPC_CheckField, 0, 7, 31, // 93: check Inst[6:0] == 0x1f
19595 OPC_Decode, 171, 122, 2, // 97: decode to QC_E_XORI using decoder 2
19596 // 97: }
19597 1, 11, // 101: case 0x1: {
19598 OPC_CheckPredicate, 193, 1, // 103: check predicate 193
19599 OPC_CheckField, 0, 7, 31, // 106: check Inst[6:0] == 0x1f
19600 OPC_Decode, 166, 122, 2, // 110: decode to QC_E_ORI using decoder 2
19601 // 110: }
19602 2, 11, // 114: case 0x2: {
19603 OPC_CheckPredicate, 193, 1, // 116: check predicate 193
19604 OPC_CheckField, 0, 7, 31, // 119: check Inst[6:0] == 0x1f
19605 OPC_Decode, 148, 122, 2, // 123: decode to QC_E_ADDI using decoder 2
19606 // 123: }
19607 3, 0, // 127: case 0x3: {
19608 OPC_CheckPredicate, 193, 1, // 129: check predicate 193
19609 OPC_CheckField, 0, 7, 31, // 132: check Inst[6:0] == 0x1f
19610 OPC_Decode, 150, 122, 2, // 136: decode to QC_E_ANDI using decoder 2
19611 // 136: }
19612 // 136: } // switch Inst[31:30]
19613 // 136: }
19614 4, 112, // 140: case 0x4: {
19615 OPC_SwitchField, 20, 5, // 142: switch Inst[24:20] {
19616 0, 29, // 145: case 0x0: {
19617 OPC_SwitchField, 15, 2, // 147: switch Inst[16:15] {
19618 0, 11, // 150: case 0x0: {
19619 OPC_CheckPredicate, 194, 1, // 152: check predicate 194
19620 OPC_CheckField, 0, 7, 31, // 155: check Inst[6:0] == 0x1f
19621 OPC_Decode, 157, 122, 3, // 159: decode to QC_E_J using decoder 3
19622 // 159: }
19623 1, 0, // 163: case 0x1: {
19624 OPC_CheckPredicate, 194, 1, // 165: check predicate 194
19625 OPC_CheckField, 0, 7, 31, // 168: check Inst[6:0] == 0x1f
19626 OPC_Decode, 158, 122, 3, // 172: decode to QC_E_JAL using decoder 3
19627 // 172: }
19628 // 172: } // switch Inst[16:15]
19629 // 172: }
19630 24, 11, // 176: case 0x18: {
19631 OPC_CheckPredicate, 182, 1, // 178: check predicate 182
19632 OPC_CheckField, 0, 7, 31, // 181: check Inst[6:0] == 0x1f
19633 OPC_Decode, 151, 122, 4, // 185: decode to QC_E_BEQI using decoder 4
19634 // 185: }
19635 25, 11, // 189: case 0x19: {
19636 OPC_CheckPredicate, 182, 1, // 191: check predicate 182
19637 OPC_CheckField, 0, 7, 31, // 194: check Inst[6:0] == 0x1f
19638 OPC_Decode, 156, 122, 4, // 198: decode to QC_E_BNEI using decoder 4
19639 // 198: }
19640 28, 11, // 202: case 0x1c: {
19641 OPC_CheckPredicate, 182, 1, // 204: check predicate 182
19642 OPC_CheckField, 0, 7, 31, // 207: check Inst[6:0] == 0x1f
19643 OPC_Decode, 154, 122, 4, // 211: decode to QC_E_BLTI using decoder 4
19644 // 211: }
19645 29, 11, // 215: case 0x1d: {
19646 OPC_CheckPredicate, 182, 1, // 217: check predicate 182
19647 OPC_CheckField, 0, 7, 31, // 220: check Inst[6:0] == 0x1f
19648 OPC_Decode, 152, 122, 4, // 224: decode to QC_E_BGEI using decoder 4
19649 // 224: }
19650 30, 11, // 228: case 0x1e: {
19651 OPC_CheckPredicate, 182, 1, // 230: check predicate 182
19652 OPC_CheckField, 0, 7, 31, // 233: check Inst[6:0] == 0x1f
19653 OPC_Decode, 155, 122, 5, // 237: decode to QC_E_BLTUI using decoder 5
19654 // 237: }
19655 31, 0, // 241: case 0x1f: {
19656 OPC_CheckPredicate, 182, 1, // 243: check predicate 182
19657 OPC_CheckField, 0, 7, 31, // 246: check Inst[6:0] == 0x1f
19658 OPC_Decode, 153, 122, 5, // 250: decode to QC_E_BGEUI using decoder 5
19659 // 250: }
19660 // 250: } // switch Inst[24:20]
19661 // 250: }
19662 5, 55, // 254: case 0x5: {
19663 OPC_SwitchField, 30, 2, // 256: switch Inst[31:30] {
19664 0, 11, // 259: case 0x0: {
19665 OPC_CheckPredicate, 195, 1, // 261: check predicate 195
19666 OPC_CheckField, 0, 7, 31, // 264: check Inst[6:0] == 0x1f
19667 OPC_Decode, 159, 122, 6, // 268: decode to QC_E_LB using decoder 6
19668 // 268: }
19669 1, 11, // 272: case 0x1: {
19670 OPC_CheckPredicate, 195, 1, // 274: check predicate 195
19671 OPC_CheckField, 0, 7, 31, // 277: check Inst[6:0] == 0x1f
19672 OPC_Decode, 160, 122, 6, // 281: decode to QC_E_LBU using decoder 6
19673 // 281: }
19674 2, 11, // 285: case 0x2: {
19675 OPC_CheckPredicate, 195, 1, // 287: check predicate 195
19676 OPC_CheckField, 0, 7, 31, // 290: check Inst[6:0] == 0x1f
19677 OPC_Decode, 161, 122, 6, // 294: decode to QC_E_LH using decoder 6
19678 // 294: }
19679 3, 0, // 298: case 0x3: {
19680 OPC_CheckPredicate, 195, 1, // 300: check predicate 195
19681 OPC_CheckField, 0, 7, 31, // 303: check Inst[6:0] == 0x1f
19682 OPC_Decode, 162, 122, 6, // 307: decode to QC_E_LHU using decoder 6
19683 // 307: }
19684 // 307: } // switch Inst[31:30]
19685 // 307: }
19686 6, 0, // 311: case 0x6: {
19687 OPC_SwitchField, 30, 2, // 313: switch Inst[31:30] {
19688 0, 11, // 316: case 0x0: {
19689 OPC_CheckPredicate, 195, 1, // 318: check predicate 195
19690 OPC_CheckField, 0, 7, 31, // 321: check Inst[6:0] == 0x1f
19691 OPC_Decode, 164, 122, 6, // 325: decode to QC_E_LW using decoder 6
19692 // 325: }
19693 1, 11, // 329: case 0x1: {
19694 OPC_CheckPredicate, 195, 1, // 331: check predicate 195
19695 OPC_CheckField, 0, 7, 31, // 334: check Inst[6:0] == 0x1f
19696 OPC_Decode, 167, 122, 7, // 338: decode to QC_E_SB using decoder 7
19697 // 338: }
19698 2, 11, // 342: case 0x2: {
19699 OPC_CheckPredicate, 195, 1, // 344: check predicate 195
19700 OPC_CheckField, 0, 7, 31, // 347: check Inst[6:0] == 0x1f
19701 OPC_Decode, 168, 122, 7, // 351: decode to QC_E_SH using decoder 7
19702 // 351: }
19703 3, 0, // 355: case 0x3: {
19704 OPC_CheckPredicate, 195, 1, // 357: check predicate 195
19705 OPC_CheckField, 0, 7, 31, // 360: check Inst[6:0] == 0x1f
19706 OPC_Decode, 169, 122, 7, // 364: decode to QC_E_SW using decoder 7
19707 // 364: }
19708 // 364: } // switch Inst[31:30]
19709 // 364: }
19710 // 364: } // switch Inst[14:12]
19711};
19712// Handling 8 cases.
19713template <typename InsnType>
19714static std::enable_if_t<InsnBitWidth<InsnType> == 48, DecodeStatus>
19715decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
19716 DecodeComplete = true;
19717 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
19718 TmpType tmp;
19719 switch (Idx) {
19720 default: llvm_unreachable("Invalid decoder index!");
19721 case 0:
19722 tmp = fieldFromInstruction(insn, 7, 5);
19723 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19724 tmp = fieldFromInstruction(insn, 16, 32);
19725 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19726 return S;
19727 case 1:
19728 tmp = fieldFromInstruction(insn, 7, 5);
19729 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19730 tmp = fieldFromInstruction(insn, 7, 5);
19731 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19732 tmp = fieldFromInstruction(insn, 16, 32);
19733 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19734 return S;
19735 case 2:
19736 tmp = fieldFromInstruction(insn, 7, 5);
19737 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19738 tmp = fieldFromInstruction(insn, 15, 5);
19739 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19740 tmp = 0x0;
19741 tmp |= fieldFromInstruction(insn, 20, 10);
19742 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
19743 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19744 return S;
19745 case 3:
19746 tmp = 0x0;
19747 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19748 tmp |= fieldFromInstruction(insn, 8, 4);
19749 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
19750 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19751 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19752 tmp |= fieldFromInstruction(insn, 32, 16) << 15;
19753 if (!Check(S, decodeSImmOperandAndLslN<32, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19754 return S;
19755 case 4:
19756 tmp = fieldFromInstruction(insn, 15, 5);
19757 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19758 tmp = fieldFromInstruction(insn, 32, 16);
19759 if (!Check(S, decodeSImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19760 tmp = 0x0;
19761 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19762 tmp |= fieldFromInstruction(insn, 8, 4);
19763 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19764 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19765 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19766 return S;
19767 case 5:
19768 tmp = fieldFromInstruction(insn, 15, 5);
19769 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19770 tmp = fieldFromInstruction(insn, 32, 16);
19771 if (!Check(S, decodeUImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19772 tmp = 0x0;
19773 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19774 tmp |= fieldFromInstruction(insn, 8, 4);
19775 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19776 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19777 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19778 return S;
19779 case 6:
19780 tmp = fieldFromInstruction(insn, 7, 5);
19781 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19782 tmp = fieldFromInstruction(insn, 15, 5);
19783 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19784 tmp = 0x0;
19785 tmp |= fieldFromInstruction(insn, 20, 10);
19786 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
19787 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19788 return S;
19789 case 7:
19790 tmp = fieldFromInstruction(insn, 20, 5);
19791 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19792 tmp = fieldFromInstruction(insn, 15, 5);
19793 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19794 tmp = 0x0;
19795 tmp |= fieldFromInstruction(insn, 7, 5);
19796 tmp |= fieldFromInstruction(insn, 25, 5) << 5;
19797 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
19798 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19799 return S;
19800 }
19801}
19802static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) {
19803 switch (Idx) {
19804 default: llvm_unreachable("Invalid index!");
19805 case 0:
19806 return FB[RISCV::FeatureStdExtZca];
19807 case 1:
19808 return FB[RISCV::FeatureStdExtZcd];
19809 case 2:
19810 return FB[RISCV::FeatureStdExtZca] && FB[RISCV::Feature64Bit];
19811 case 3:
19812 return FB[RISCV::FeatureStdExtZcmop];
19813 case 4:
19814 return FB[RISCV::FeatureStdExtZcb];
19815 case 5:
19816 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZmmul];
19817 case 6:
19818 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZbb];
19819 case 7:
19820 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
19821 case 8:
19822 return FB[RISCV::FeatureStdExtZcf] && !FB[RISCV::Feature64Bit];
19823 case 9:
19824 return FB[RISCV::FeatureStdExtZca] && !FB[RISCV::Feature64Bit];
19825 case 10:
19826 return FB[RISCV::FeatureVendorXqccmp];
19827 case 11:
19828 return FB[RISCV::FeatureVendorXqciint] && !FB[RISCV::Feature64Bit];
19829 case 12:
19830 return FB[RISCV::FeatureVendorXqcibm] && !FB[RISCV::Feature64Bit];
19831 case 13:
19832 return FB[RISCV::FeatureVendorXqciac] && !FB[RISCV::Feature64Bit];
19833 case 14:
19834 return FB[RISCV::FeatureVendorXqcisync] && !FB[RISCV::Feature64Bit];
19835 case 15:
19836 return FB[RISCV::FeatureVendorXqcicm] && !FB[RISCV::Feature64Bit];
19837 case 16:
19838 return FB[RISCV::FeatureVendorXwchc];
19839 case 17:
19840 return FB[RISCV::FeatureStdExtZclsd] && !FB[RISCV::Feature64Bit];
19841 case 18:
19842 return FB[RISCV::FeatureStdExtZcmt];
19843 case 19:
19844 return FB[RISCV::FeatureStdExtZcmp];
19845 case 20:
19846 return FB[RISCV::Feature64Bit];
19847 case 21:
19848 return FB[RISCV::FeatureStdExtZve32x];
19849 case 22:
19850 return FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZfhmin] || FB[RISCV::FeatureStdExtZfbfmin];
19851 case 23:
19852 return FB[RISCV::FeatureStdExtF];
19853 case 24:
19854 return FB[RISCV::FeatureStdExtD];
19855 case 25:
19856 return FB[RISCV::FeatureStdExtQ];
19857 case 26:
19858 return FB[RISCV::FeatureStdExtZve64x];
19859 case 27:
19860 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtZve64x];
19861 case 28:
19862 return FB[RISCV::FeatureStdExtZve64x] && FB[RISCV::Feature64Bit];
19863 case 29:
19864 return FB[RISCV::FeatureStdExtZicbom];
19865 case 30:
19866 return FB[RISCV::FeatureStdExtZicboz];
19867 case 31:
19868 return FB[RISCV::FeatureStdExtZbkb] && !FB[RISCV::Feature64Bit];
19869 case 32:
19870 return FB[RISCV::FeatureStdExtZknh];
19871 case 33:
19872 return FB[RISCV::FeatureStdExtZknh] && FB[RISCV::Feature64Bit];
19873 case 34:
19874 return FB[RISCV::FeatureStdExtZksh];
19875 case 35:
19876 return FB[RISCV::FeatureStdExtZbs];
19877 case 36:
19878 return FB[RISCV::FeatureStdExtZknd] && FB[RISCV::Feature64Bit];
19879 case 37:
19880 return (FB[RISCV::FeatureStdExtZknd] || FB[RISCV::FeatureStdExtZkne]) && FB[RISCV::Feature64Bit];
19881 case 38:
19882 return FB[RISCV::FeatureStdExtZbb];
19883 case 39:
19884 return FB[RISCV::FeatureStdExtP];
19885 case 40:
19886 return FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb];
19887 case 41:
19888 return FB[RISCV::FeatureStdExtZbkb];
19889 case 42:
19890 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && !FB[RISCV::Feature64Bit];
19891 case 43:
19892 return FB[RISCV::FeatureStdExtP] && !FB[RISCV::Feature64Bit];
19893 case 44:
19894 return FB[RISCV::FeatureStdExtP] && FB[RISCV::Feature64Bit];
19895 case 45:
19896 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && FB[RISCV::Feature64Bit];
19897 case 46:
19898 return FB[RISCV::FeatureStdExtZicbop];
19899 case 47:
19900 return FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
19901 case 48:
19902 return FB[RISCV::FeatureStdExtZbb] && FB[RISCV::Feature64Bit];
19903 case 49:
19904 return FB[RISCV::FeatureStdExtZabha];
19905 case 50:
19906 return FB[RISCV::FeatureStdExtZaamo];
19907 case 51:
19908 return FB[RISCV::FeatureStdExtZaamo] && FB[RISCV::Feature64Bit];
19909 case 52:
19910 return FB[RISCV::FeatureStdExtZalrsc];
19911 case 53:
19912 return FB[RISCV::FeatureStdExtZalrsc] && FB[RISCV::Feature64Bit];
19913 case 54:
19914 return FB[RISCV::FeatureStdExtZabha] && FB[RISCV::FeatureStdExtZacas];
19915 case 55:
19916 return FB[RISCV::FeatureStdExtZacas];
19917 case 56:
19918 return FB[RISCV::FeatureStdExtZacas] && FB[RISCV::Feature64Bit];
19919 case 57:
19920 return FB[RISCV::FeatureStdExtZalasr];
19921 case 58:
19922 return FB[RISCV::FeatureStdExtZalasr] && FB[RISCV::Feature64Bit];
19923 case 59:
19924 return FB[RISCV::FeatureStdExtZicfiss];
19925 case 60:
19926 return FB[RISCV::FeatureStdExtZicfiss] && FB[RISCV::Feature64Bit];
19927 case 61:
19928 return FB[RISCV::FeatureStdExtZmmul];
19929 case 62:
19930 return FB[RISCV::FeatureStdExtM];
19931 case 63:
19932 return FB[RISCV::FeatureStdExtZbkb] || FB[RISCV::FeatureStdExtP];
19933 case 64:
19934 return FB[RISCV::FeatureStdExtZbkc];
19935 case 65:
19936 return FB[RISCV::FeatureStdExtZbc];
19937 case 66:
19938 return FB[RISCV::FeatureStdExtZicond];
19939 case 67:
19940 return FB[RISCV::FeatureStdExtZknh] && !FB[RISCV::Feature64Bit];
19941 case 68:
19942 return FB[RISCV::FeatureStdExtZba];
19943 case 69:
19944 return FB[RISCV::FeatureStdExtZkne] && !FB[RISCV::Feature64Bit];
19945 case 70:
19946 return FB[RISCV::FeatureStdExtZbkx];
19947 case 71:
19948 return FB[RISCV::FeatureStdExtZknd] && !FB[RISCV::Feature64Bit];
19949 case 72:
19950 return FB[RISCV::FeatureStdExtZksed];
19951 case 73:
19952 return FB[RISCV::FeatureStdExtZkne] && FB[RISCV::Feature64Bit];
19953 case 74:
19954 return FB[RISCV::FeatureStdExtZmmul] && FB[RISCV::Feature64Bit];
19955 case 75:
19956 return FB[RISCV::FeatureStdExtM] && FB[RISCV::Feature64Bit];
19957 case 76:
19958 return FB[RISCV::FeatureStdExtZbkb] && FB[RISCV::Feature64Bit];
19959 case 77:
19960 return FB[RISCV::FeatureStdExtZfh];
19961 case 78:
19962 return FB[RISCV::FeatureStdExtZfa];
19963 case 79:
19964 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD];
19965 case 80:
19966 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtZfh];
19967 case 81:
19968 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ];
19969 case 82:
19970 return FB[RISCV::FeatureStdExtZfhmin];
19971 case 83:
19972 return FB[RISCV::FeatureStdExtZfbfmin];
19973 case 84:
19974 return FB[RISCV::FeatureStdExtZfhmin] && FB[RISCV::FeatureStdExtD];
19975 case 85:
19976 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD] && !FB[RISCV::Feature64Bit];
19977 case 86:
19978 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
19979 case 87:
19980 return FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
19981 case 88:
19982 return FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
19983 case 89:
19984 return FB[RISCV::FeatureStdExtZfh] && FB[RISCV::Feature64Bit];
19985 case 90:
19986 return FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
19987 case 91:
19988 return FB[RISCV::FeatureStdExtZfa] && (FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZvfh]);
19989 case 92:
19990 return FB[RISCV::FeatureStdExtZvkb];
19991 case 93:
19992 return FB[RISCV::FeatureStdExtZvzip];
19993 case 94:
19994 return FB[RISCV::FeatureStdExtZvbb];
19995 case 95:
19996 return FB[RISCV::FeatureStdExtZve32f];
19997 case 96:
19998 return FB[RISCV::FeatureStdExtZvfbfmin] || FB[RISCV::FeatureStdExtZvfofp8min];
19999 case 97:
20000 return FB[RISCV::FeatureStdExtZvfofp8min];
20001 case 98:
20002 return FB[RISCV::FeatureStdExtZvfbfwma];
20003 case 99:
20004 return FB[RISCV::FeatureStdExtZvbc] || FB[RISCV::FeatureStdExtZvbc32e];
20005 case 100:
20006 return FB[RISCV::FeatureStdExtZvabd];
20007 case 101:
20008 return FB[RISCV::FeatureStdExtZvdot4a8i];
20009 case 102:
20010 return FB[RISCV::FeatureStdExtZibi];
20011 case 103:
20012 return FB[RISCV::FeatureStdExtZawrs];
20013 case 104:
20014 return FB[RISCV::FeatureStdExtSmctr] || FB[RISCV::FeatureStdExtSsctr];
20015 case 105:
20016 return FB[RISCV::FeatureStdExtSvinval];
20017 case 106:
20018 return FB[RISCV::FeatureStdExtH];
20019 case 107:
20020 return FB[RISCV::FeatureStdExtSmrnmi];
20021 case 108:
20022 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtH];
20023 case 109:
20024 return FB[RISCV::FeatureStdExtZimop];
20025 case 110:
20026 return FB[RISCV::FeatureStdExtZvksh];
20027 case 111:
20028 return FB[RISCV::FeatureStdExtZvksed];
20029 case 112:
20030 return FB[RISCV::FeatureStdExtZvkned];
20031 case 113:
20032 return FB[RISCV::FeatureStdExtZvkgs];
20033 case 114:
20034 return FB[RISCV::FeatureStdExtZvkg];
20035 case 115:
20036 return FB[RISCV::FeatureStdExtZvknha];
20037 case 116:
20038 return FB[RISCV::FeatureStdExtZilsd] && !FB[RISCV::Feature64Bit];
20039 case 117:
20040 return FB[RISCV::FeatureStdExtZacas] && !FB[RISCV::Feature64Bit];
20041 case 118:
20042 return FB[RISCV::FeatureVendorXAIFET];
20043 case 119:
20044 return FB[RISCV::FeatureVendorXAndesPerf];
20045 case 120:
20046 return FB[RISCV::FeatureVendorXAndesVBFHCvt];
20047 case 121:
20048 return FB[RISCV::FeatureVendorXAndesBFHCvt];
20049 case 122:
20050 return FB[RISCV::FeatureVendorXAndesVSIntH];
20051 case 123:
20052 return FB[RISCV::FeatureVendorXAndesVSIntLoad];
20053 case 124:
20054 return FB[RISCV::FeatureVendorXAndesVPackFPH];
20055 case 125:
20056 return FB[RISCV::FeatureVendorXAndesPerf] && FB[RISCV::Feature64Bit];
20057 case 126:
20058 return FB[RISCV::FeatureVendorXAndesVDot];
20059 case 127:
20060 return FB[RISCV::FeatureVendorXCVmem] && !FB[RISCV::Feature64Bit];
20061 case 128:
20062 return FB[RISCV::FeatureVendorXCVbitmanip] && !FB[RISCV::Feature64Bit];
20063 case 129:
20064 return FB[RISCV::FeatureVendorXCVsimd] && !FB[RISCV::Feature64Bit];
20065 case 130:
20066 return FB[RISCV::FeatureVendorXCValu] && !FB[RISCV::Feature64Bit];
20067 case 131:
20068 return FB[RISCV::FeatureVendorXCVelw] && !FB[RISCV::Feature64Bit];
20069 case 132:
20070 return FB[RISCV::FeatureVendorXCVmac] && !FB[RISCV::Feature64Bit];
20071 case 133:
20072 return FB[RISCV::FeatureVendorXCVbi] && !FB[RISCV::Feature64Bit];
20073 case 134:
20074 return FB[RISCV::FeatureVendorXMIPSCBOP];
20075 case 135:
20076 return FB[RISCV::FeatureVendorXMIPSEXECTL];
20077 case 136:
20078 return FB[RISCV::FeatureVendorXMIPSCMov];
20079 case 137:
20080 return FB[RISCV::FeatureVendorXMIPSLSP];
20081 case 138:
20082 return FB[RISCV::FeatureVendorXRivosVizip];
20083 case 139:
20084 return FB[RISCV::FeatureVendorXSMTVDot] && FB[RISCV::Feature64Bit];
20085 case 140:
20086 return FB[RISCV::FeatureVendorXSfcease];
20087 case 141:
20088 return FB[RISCV::FeatureVendorXSiFivecflushdlone];
20089 case 142:
20090 return FB[RISCV::FeatureVendorXSiFivecdiscarddlone];
20091 case 143:
20092 return FB[RISCV::FeatureVendorXSfvcp];
20093 case 144:
20094 return FB[RISCV::FeatureVendorXSfmmbase];
20095 case 145:
20096 return FB[RISCV::FeatureVendorXSfvfexpa];
20097 case 146:
20098 return FB[RISCV::FeatureVendorXSfvfbfexp16e] || FB[RISCV::FeatureVendorXSfvfexp16e] || FB[RISCV::FeatureVendorXSfvfexp32e];
20099 case 147:
20100 return FB[RISCV::FeatureVendorXSfvfnrclipxfqf];
20101 case 148:
20102 return FB[RISCV::FeatureVendorXSfvqmaccdod];
20103 case 149:
20104 return FB[RISCV::FeatureVendorXSfmm32a8i];
20105 case 150:
20106 return FB[RISCV::FeatureVendorXSfvfwmaccqqq];
20107 case 151:
20108 return FB[RISCV::FeatureVendorXSfmm32a16f] || FB[RISCV::FeatureVendorXSfmm32a32f] || FB[RISCV::FeatureVendorXSfmm64a64f];
20109 case 152:
20110 return FB[RISCV::FeatureVendorXSfmm32a8f];
20111 case 153:
20112 return FB[RISCV::FeatureVendorXSfvqmaccqoq];
20113 case 154:
20114 return FB[RISCV::FeatureVendorXTHeadCmo];
20115 case 155:
20116 return FB[RISCV::FeatureVendorXTHeadSync];
20117 case 156:
20118 return FB[RISCV::FeatureVendorXTHeadBa];
20119 case 157:
20120 return FB[RISCV::FeatureVendorXTHeadBb];
20121 case 158:
20122 return FB[RISCV::FeatureVendorXTHeadBb] && FB[RISCV::Feature64Bit];
20123 case 159:
20124 return FB[RISCV::FeatureVendorXTHeadMac];
20125 case 160:
20126 return FB[RISCV::FeatureVendorXTHeadMac] && FB[RISCV::Feature64Bit];
20127 case 161:
20128 return FB[RISCV::FeatureVendorXTHeadCondMov];
20129 case 162:
20130 return FB[RISCV::FeatureVendorXTHeadBs];
20131 case 163:
20132 return FB[RISCV::FeatureVendorXTHeadMemIdx];
20133 case 164:
20134 return FB[RISCV::FeatureVendorXTHeadMemIdx] && FB[RISCV::Feature64Bit];
20135 case 165:
20136 return FB[RISCV::FeatureVendorXTHeadMemPair];
20137 case 166:
20138 return FB[RISCV::FeatureVendorXTHeadMemPair] && FB[RISCV::Feature64Bit];
20139 case 167:
20140 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF];
20141 case 168:
20142 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
20143 case 169:
20144 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD];
20145 case 170:
20146 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
20147 case 171:
20148 return FB[RISCV::FeatureVendorXTHeadVdot];
20149 case 172:
20150 return FB[RISCV::FeatureVendorXVentanaCondOps];
20151 case 173:
20152 return FB[RISCV::FeatureVendorXqcia] && !FB[RISCV::Feature64Bit];
20153 case 174:
20154 return FB[RISCV::FeatureVendorXqciio] && !FB[RISCV::Feature64Bit];
20155 case 175:
20156 return FB[RISCV::FeatureVendorXqcilsm] && !FB[RISCV::Feature64Bit];
20157 case 176:
20158 return FB[RISCV::FeatureVendorXqcisls] && !FB[RISCV::Feature64Bit];
20159 case 177:
20160 return FB[RISCV::FeatureVendorXqcisim] && !FB[RISCV::Feature64Bit];
20161 case 178:
20162 return FB[RISCV::FeatureVendorXqcili] && !FB[RISCV::Feature64Bit];
20163 case 179:
20164 return FB[RISCV::FeatureVendorXqcicli] && !FB[RISCV::Feature64Bit];
20165 case 180:
20166 return FB[RISCV::FeatureVendorXqcics] && !FB[RISCV::Feature64Bit];
20167 case 181:
20168 return FB[RISCV::FeatureVendorXqcicsr] && !FB[RISCV::Feature64Bit];
20169 case 182:
20170 return FB[RISCV::FeatureVendorXqcibi] && !FB[RISCV::Feature64Bit];
20171 case 183:
20172 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && !FB[RISCV::Feature64Bit];
20173 case 184:
20174 return FB[RISCV::FeatureStdExtZdinx] && !FB[RISCV::Feature64Bit];
20175 case 185:
20176 return FB[RISCV::FeatureStdExtZfinx];
20177 case 186:
20178 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
20179 case 187:
20180 return FB[RISCV::FeatureStdExtZhinx];
20181 case 188:
20182 return FB[RISCV::FeatureStdExtZhinxmin];
20183 case 189:
20184 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
20185 case 190:
20186 return FB[RISCV::FeatureStdExtZfinx] && FB[RISCV::Feature64Bit];
20187 case 191:
20188 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit] && FB[RISCV::Feature64Bit];
20189 case 192:
20190 return FB[RISCV::FeatureStdExtZhinx] && FB[RISCV::Feature64Bit];
20191 case 193:
20192 return FB[RISCV::FeatureVendorXqcilia] && !FB[RISCV::Feature64Bit];
20193 case 194:
20194 return FB[RISCV::FeatureVendorXqcilb] && !FB[RISCV::Feature64Bit];
20195 case 195:
20196 return FB[RISCV::FeatureVendorXqcilo] && !FB[RISCV::Feature64Bit];
20197 }
20198}
20199
20200
20201template <typename InsnType>
20202static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
20203 InsnType insn, uint64_t Address,
20204 const MCDisassembler *DisAsm,
20205 const MCSubtargetInfo &STI) {
20206 const FeatureBitset &Bits = STI.getFeatureBits();
20207 const uint8_t *Ptr = DecodeTable;
20208
20209 [[maybe_unused]] uint32_t BitWidth = decodeULEB128AndIncUnsafe(p&: Ptr);
20210 assert(InsnBitWidth<InsnType> == BitWidth &&
20211 "Table and instruction bitwidth mismatch");
20212
20213 SmallVector<const uint8_t *, 8> ScopeStack;
20214 DecodeStatus S = MCDisassembler::Success;
20215 while (true) {
20216 ptrdiff_t Loc = Ptr - DecodeTable;
20217 const uint8_t DecoderOp = *Ptr++;
20218 switch (DecoderOp) {
20219 default:
20220 errs() << Loc << ": Unexpected decode table opcode: "
20221 << (int)DecoderOp << '\n';
20222 return MCDisassembler::Fail;
20223 case OPC_Scope: {
20224 unsigned NumToSkip = decodeULEB128AndIncUnsafe(p&: Ptr);
20225 const uint8_t *SkipTo = Ptr + NumToSkip;
20226 ScopeStack.push_back(Elt: SkipTo);
20227 LLVM_DEBUG(dbgs() << Loc << ": OPC_Scope(" << SkipTo - DecodeTable
20228 << ")\n");
20229 continue;
20230 }
20231 case OPC_SwitchField: {
20232 // Decode the start value.
20233 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
20234 unsigned Len = *Ptr++;
20235 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
20236 uint64_t CaseValue;
20237 unsigned CaseSize;
20238 while (true) {
20239 CaseValue = decodeULEB128AndIncUnsafe(p&: Ptr);
20240 CaseSize = decodeULEB128AndIncUnsafe(p&: Ptr);
20241 if (FieldValue == CaseValue || !CaseSize)
20242 break;
20243 Ptr += CaseSize;
20244 }
20245 if (FieldValue == CaseValue) {
20246 LLVM_DEBUG(dbgs() << Loc << ": OPC_SwitchField(" << Start << ", " << Len
20247 << "): " << FieldValue << '\n');
20248 continue;
20249 }
20250 break;
20251 }
20252 case OPC_CheckField: {
20253 // Decode the start value.
20254 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
20255 unsigned Len = *Ptr;
20256 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
20257 // Decode the field value.
20258 unsigned PtrLen = 0;
20259 uint64_t ExpectedValue = decodeULEB128(p: ++Ptr, n: &PtrLen);
20260 Ptr += PtrLen;
20261 bool Failed = ExpectedValue != FieldValue;
20262
20263 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckField(" << Start << ", " << Len
20264 << ", " << ExpectedValue << "): FieldValue = "
20265 << FieldValue << ", ExpectedValue = " << ExpectedValue
20266 << ": " << (Failed ? "FAIL, " : "PASS\n"););
20267 if (!Failed)
20268 continue;
20269 break;
20270 }
20271 case OPC_CheckPredicate: {
20272 // Decode the Predicate Index value.
20273 unsigned PIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
20274 // Check the predicate.
20275 bool Failed = !checkDecoderPredicate(Idx: PIdx, FB: Bits);
20276
20277 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckPredicate(" << PIdx << "): "
20278 << (Failed ? "FAIL, " : "PASS\n"););
20279 if (!Failed)
20280 continue;
20281 break;
20282 }
20283 case OPC_Decode: {
20284 // Decode the Opcode value.
20285 unsigned Opc = decodeULEB128AndIncUnsafe(p&: Ptr);
20286 unsigned DecodeIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
20287
20288 MI.clear();
20289 MI.setOpcode(Opc);
20290 bool DecodeComplete;
20291 S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm,
20292 DecodeComplete);
20293 LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc
20294 << ", using decoder " << DecodeIdx << ": "
20295 << (S ? "PASS, " : "FAIL, "));
20296
20297 if (DecodeComplete) {
20298 LLVM_DEBUG(dbgs() << "decoding complete\n");
20299 return S;
20300 }
20301 assert(S == MCDisassembler::Fail);
20302 // Reset decode status. This also drops a SoftFail status that could be
20303 // set before the decode attempt.
20304 S = MCDisassembler::Success;
20305 break;
20306 }
20307 }
20308 if (ScopeStack.empty()) {
20309 LLVM_DEBUG(dbgs() << "returning Fail\n");
20310 return MCDisassembler::Fail;
20311 }
20312 Ptr = ScopeStack.pop_back_val();
20313 LLVM_DEBUG(dbgs() << "continuing at " << Ptr - DecodeTable << '\n');
20314 }
20315 llvm_unreachable("bogosity detected in disassembler state machine!");
20316}
20317
20318
20319} // namespace
20320