1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* * Mips 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
28[[maybe_unused]]
29static DecodeStatus Decodemips_ptr_rcRegClassByHwMode(MCInst &Inst, unsigned Imm, uint64_t Addr, const MCDisassembler *Decoder) {
30 switch (Decoder->getSubtargetInfo().getHwMode(type: MCSubtargetInfo::HwMode_RegInfo)) {
31 case 0: // DefaultMode
32 return DecodeGPR32RegisterClass(Inst, RegNo: Imm, Address: Addr, Decoder);
33 case 1: // MIPS64
34 return DecodeGPR64RegisterClass(Inst, RegNo: Imm, Address: Addr, Decoder);
35 default:
36 llvm_unreachable("no decoder for hwmode");
37 }
38}
39
40[[maybe_unused]]
41static DecodeStatus Decodeptr_gp_rcRegClassByHwMode(MCInst &Inst, unsigned Imm, uint64_t Addr, const MCDisassembler *Decoder) {
42 switch (Decoder->getSubtargetInfo().getHwMode(type: MCSubtargetInfo::HwMode_RegInfo)) {
43 case 0: // DefaultMode
44 return DecodeGP32RegisterClass(Inst, RegNo: Imm, Address: Addr, Decoder);
45 case 1: // MIPS64
46 return DecodeGP64RegisterClass(Inst, RegNo: Imm, Address: Addr, Decoder);
47 default:
48 llvm_unreachable("no decoder for hwmode");
49 }
50}
51
52[[maybe_unused]]
53static DecodeStatus Decodeptr_gpr16mm_rcRegClassByHwMode(MCInst &Inst, unsigned Imm, uint64_t Addr, const MCDisassembler *Decoder) {
54 switch (Decoder->getSubtargetInfo().getHwMode(type: MCSubtargetInfo::HwMode_RegInfo)) {
55 case 0: // DefaultMode
56 return DecodeGPRMM16RegisterClass(Inst, RegNo: Imm, Address: Addr, Decoder);
57 case 1: // MIPS64
58 return DecodeGPRMM16RegisterClass(Inst, RegNo: Imm, Address: Addr, Decoder);
59 default:
60 llvm_unreachable("no decoder for hwmode");
61 }
62}
63
64[[maybe_unused]]
65static DecodeStatus Decodeptr_sp_rcRegClassByHwMode(MCInst &Inst, unsigned Imm, uint64_t Addr, const MCDisassembler *Decoder) {
66 switch (Decoder->getSubtargetInfo().getHwMode(type: MCSubtargetInfo::HwMode_RegInfo)) {
67 case 0: // DefaultMode
68 return DecodeSP32RegisterClass(Inst, RegNo: Imm, Address: Addr, Decoder);
69 case 1: // MIPS64
70 return DecodeSP64RegisterClass(Inst, RegNo: Imm, Address: Addr, Decoder);
71 default:
72 llvm_unreachable("no decoder for hwmode");
73 }
74}
75
76
77static const uint8_t DecoderTable16[352] = {
78 OPC_SwitchField, 11, 5, // 0: switch Inst[15:11] {
79 2, 6, // 3: case 0x2: {
80 OPC_CheckPredicate, 0, // 5: check predicate 0
81 OPC_Decode, 211, 8, 0, // 7: decode to Bimm16 using decoder 0
82 // 7: }
83 4, 6, // 11: case 0x4: {
84 OPC_CheckPredicate, 0, // 13: check predicate 0
85 OPC_Decode, 209, 8, 1, // 15: decode to BeqzRxImm16 using decoder 1
86 // 15: }
87 5, 6, // 19: case 0x5: {
88 OPC_CheckPredicate, 0, // 21: check predicate 0
89 OPC_Decode, 213, 8, 1, // 23: decode to BnezRxImm16 using decoder 1
90 // 23: }
91 9, 6, // 27: case 0x9: {
92 OPC_CheckPredicate, 0, // 29: check predicate 0
93 OPC_Decode, 144, 7, 2, // 31: decode to AddiuRxRxImm16 using decoder 2
94 // 31: }
95 10, 6, // 35: case 0xa: {
96 OPC_CheckPredicate, 0, // 37: check predicate 0
97 OPC_Decode, 130, 22, 3, // 39: decode to SltiRxImm16 using decoder 3
98 // 39: }
99 11, 6, // 43: case 0xb: {
100 OPC_CheckPredicate, 0, // 45: check predicate 0
101 OPC_Decode, 132, 22, 3, // 47: decode to SltiuRxImm16 using decoder 3
102 // 47: }
103 12, 43, // 51: case 0xc: {
104 OPC_SwitchField, 8, 3, // 53: switch Inst[10:8] {
105 0, 6, // 56: case 0x0: {
106 OPC_CheckPredicate, 0, // 58: check predicate 0
107 OPC_Decode, 216, 8, 4, // 60: decode to Bteqz16 using decoder 4
108 // 60: }
109 1, 6, // 64: case 0x1: {
110 OPC_CheckPredicate, 0, // 66: check predicate 0
111 OPC_Decode, 218, 8, 4, // 68: decode to Btnez16 using decoder 4
112 // 68: }
113 3, 6, // 72: case 0x3: {
114 OPC_CheckPredicate, 0, // 74: check predicate 0
115 OPC_Decode, 147, 7, 4, // 76: decode to AddiuSpImm16 using decoder 4
116 // 76: }
117 5, 6, // 80: case 0x5: {
118 OPC_CheckPredicate, 0, // 82: check predicate 0
119 OPC_Decode, 134, 18, 5, // 84: decode to Move32R16 using decoder 5
120 // 84: }
121 7, 0, // 88: case 0x7: {
122 OPC_CheckPredicate, 0, // 90: check predicate 0
123 OPC_Decode, 135, 18, 6, // 92: decode to MoveR3216 using decoder 6
124 // 92: }
125 // 92: } // switch Inst[10:8]
126 // 92: }
127 13, 6, // 96: case 0xd: {
128 OPC_CheckPredicate, 0, // 98: check predicate 0
129 OPC_Decode, 216, 15, 3, // 100: decode to LiRxImm16 using decoder 3
130 // 100: }
131 14, 6, // 104: case 0xe: {
132 OPC_CheckPredicate, 0, // 106: check predicate 0
133 OPC_Decode, 154, 11, 3, // 108: decode to CmpiRxImm16 using decoder 3
134 // 108: }
135 22, 6, // 112: case 0x16: {
136 OPC_CheckPredicate, 0, // 114: check predicate 0
137 OPC_Decode, 219, 15, 7, // 116: decode to LwRxPcTcp16 using decoder 7
138 // 116: }
139 28, 19, // 120: case 0x1c: {
140 OPC_SwitchField, 0, 2, // 122: switch Inst[1:0] {
141 1, 6, // 125: case 0x1: {
142 OPC_CheckPredicate, 0, // 127: check predicate 0
143 OPC_Decode, 149, 7, 8, // 129: decode to AdduRxRyRz16 using decoder 8
144 // 129: }
145 3, 0, // 133: case 0x3: {
146 OPC_CheckPredicate, 0, // 135: check predicate 0
147 OPC_Decode, 139, 22, 8, // 137: decode to SubuRxRyRz16 using decoder 8
148 // 137: }
149 // 137: } // switch Inst[1:0]
150 // 137: }
151 29, 0, // 141: case 0x1d: {
152 OPC_SwitchField, 0, 5, // 143: switch Inst[4:0] {
153 0, 43, // 146: case 0x0: {
154 OPC_SwitchField, 5, 3, // 148: switch Inst[7:5] {
155 0, 6, // 151: case 0x0: {
156 OPC_CheckPredicate, 0, // 153: check predicate 0
157 OPC_Decode, 222, 14, 9, // 155: decode to JumpLinkReg16 using decoder 9
158 // 155: }
159 1, 10, // 159: case 0x1: {
160 OPC_CheckPredicate, 0, // 161: check predicate 0
161 OPC_CheckField, 8, 3, 0, // 163: check Inst[10:8] == 0x0
162 OPC_Decode, 219, 14, 10, // 167: decode to JrRa16 using decoder 10
163 // 167: }
164 6, 6, // 171: case 0x6: {
165 OPC_CheckPredicate, 0, // 173: check predicate 0
166 OPC_Decode, 221, 14, 9, // 175: decode to JrcRx16 using decoder 9
167 // 175: }
168 7, 0, // 179: case 0x7: {
169 OPC_CheckPredicate, 0, // 181: check predicate 0
170 OPC_CheckField, 8, 3, 0, // 183: check Inst[10:8] == 0x0
171 OPC_Decode, 220, 14, 10, // 187: decode to JrcRa16 using decoder 10
172 // 187: }
173 // 187: } // switch Inst[7:5]
174 // 187: }
175 2, 6, // 191: case 0x2: {
176 OPC_CheckPredicate, 0, // 193: check predicate 0
177 OPC_Decode, 129, 22, 11, // 195: decode to SltRxRy16 using decoder 11
178 // 195: }
179 3, 6, // 199: case 0x3: {
180 OPC_CheckPredicate, 0, // 201: check predicate 0
181 OPC_Decode, 134, 22, 11, // 203: decode to SltuRxRy16 using decoder 11
182 // 203: }
183 4, 6, // 207: case 0x4: {
184 OPC_CheckPredicate, 0, // 209: check predicate 0
185 OPC_Decode, 128, 22, 12, // 211: decode to SllvRxRy16 using decoder 12
186 // 211: }
187 5, 10, // 215: case 0x5: {
188 OPC_CheckPredicate, 0, // 217: check predicate 0
189 OPC_CheckField, 5, 6, 0, // 219: check Inst[10:5] == 0x0
190 OPC_Decode, 215, 8, 10, // 223: decode to Break16 using decoder 10
191 // 223: }
192 6, 6, // 227: case 0x6: {
193 OPC_CheckPredicate, 0, // 229: check predicate 0
194 OPC_Decode, 138, 22, 12, // 231: decode to SrlvRxRy16 using decoder 12
195 // 231: }
196 7, 6, // 235: case 0x7: {
197 OPC_CheckPredicate, 0, // 237: check predicate 0
198 OPC_Decode, 136, 22, 12, // 239: decode to SravRxRy16 using decoder 12
199 // 239: }
200 10, 6, // 243: case 0xa: {
201 OPC_CheckPredicate, 0, // 245: check predicate 0
202 OPC_Decode, 153, 11, 11, // 247: decode to CmpRxRy16 using decoder 11
203 // 247: }
204 12, 6, // 251: case 0xc: {
205 OPC_CheckPredicate, 0, // 253: check predicate 0
206 OPC_Decode, 150, 7, 12, // 255: decode to AndRxRxRy16 using decoder 12
207 // 255: }
208 13, 6, // 259: case 0xd: {
209 OPC_CheckPredicate, 0, // 261: check predicate 0
210 OPC_Decode, 177, 18, 12, // 263: decode to OrRxRxRy16 using decoder 12
211 // 263: }
212 14, 6, // 267: case 0xe: {
213 OPC_CheckPredicate, 0, // 269: check predicate 0
214 OPC_Decode, 231, 22, 12, // 271: decode to XorRxRxRy16 using decoder 12
215 // 271: }
216 15, 6, // 275: case 0xf: {
217 OPC_CheckPredicate, 0, // 277: check predicate 0
218 OPC_Decode, 164, 18, 11, // 279: decode to NotRxRy16 using decoder 11
219 // 279: }
220 16, 10, // 283: case 0x10: {
221 OPC_CheckPredicate, 0, // 285: check predicate 0
222 OPC_CheckField, 5, 3, 0, // 287: check Inst[7:5] == 0x0
223 OPC_Decode, 132, 18, 9, // 291: decode to Mfhi16 using decoder 9
224 // 291: }
225 17, 19, // 295: case 0x11: {
226 OPC_SwitchField, 5, 3, // 297: switch Inst[7:5] {
227 4, 6, // 300: case 0x4: {
228 OPC_CheckPredicate, 0, // 302: check predicate 0
229 OPC_Decode, 252, 21, 13, // 304: decode to SebRx16 using decoder 13
230 // 304: }
231 5, 0, // 308: case 0x5: {
232 OPC_CheckPredicate, 0, // 310: check predicate 0
233 OPC_Decode, 253, 21, 13, // 312: decode to SehRx16 using decoder 13
234 // 312: }
235 // 312: } // switch Inst[7:5]
236 // 312: }
237 18, 10, // 316: case 0x12: {
238 OPC_CheckPredicate, 0, // 318: check predicate 0
239 OPC_CheckField, 5, 3, 0, // 320: check Inst[7:5] == 0x0
240 OPC_Decode, 133, 18, 9, // 324: decode to Mflo16 using decoder 9
241 // 324: }
242 26, 6, // 328: case 0x1a: {
243 OPC_CheckPredicate, 0, // 330: check predicate 0
244 OPC_Decode, 163, 12, 11, // 332: decode to DivRxRy16 using decoder 11
245 // 332: }
246 27, 6, // 336: case 0x1b: {
247 OPC_CheckPredicate, 0, // 338: check predicate 0
248 OPC_Decode, 164, 12, 11, // 340: decode to DivuRxRy16 using decoder 11
249 // 340: }
250 29, 0, // 344: case 0x1d: {
251 OPC_CheckPredicate, 0, // 346: check predicate 0
252 OPC_Decode, 163, 18, 11, // 348: decode to NegRxRy16 using decoder 11
253 // 348: }
254 // 348: } // switch Inst[4:0]
255 // 348: }
256 // 348: } // switch Inst[15:11]
257};
258static const uint8_t DecoderTableMicroMips16[375] = {
259 OPC_SwitchField, 10, 6, // 0: switch Inst[15:10] {
260 1, 19, // 3: case 0x1: {
261 OPC_SwitchField, 0, 1, // 5: switch Inst[0] {
262 0, 6, // 8: case 0x0: {
263 OPC_CheckPredicate, 1, // 10: check predicate 1
264 OPC_Decode, 185, 6, 14, // 12: decode to ADDU16_MM using decoder 14
265 // 12: }
266 1, 0, // 16: case 0x1: {
267 OPC_CheckPredicate, 1, // 18: check predicate 1
268 OPC_Decode, 177, 21, 14, // 20: decode to SUBU16_MM using decoder 14
269 // 20: }
270 // 20: } // switch Inst[0]
271 // 20: }
272 2, 6, // 24: case 0x2: {
273 OPC_CheckPredicate, 2, // 26: check predicate 2
274 OPC_Decode, 227, 14, 15, // 28: decode to LBU16_MM using decoder 15
275 // 28: }
276 3, 6, // 32: case 0x3: {
277 OPC_CheckPredicate, 1, // 34: check predicate 1
278 OPC_Decode, 229, 16, 16, // 36: decode to MOVE16_MM using decoder 16
279 // 36: }
280 9, 19, // 40: case 0x9: {
281 OPC_SwitchField, 0, 1, // 42: switch Inst[0] {
282 0, 6, // 45: case 0x0: {
283 OPC_CheckPredicate, 1, // 47: check predicate 1
284 OPC_Decode, 187, 20, 17, // 49: decode to SLL16_MM using decoder 17
285 // 49: }
286 1, 0, // 53: case 0x1: {
287 OPC_CheckPredicate, 1, // 55: check predicate 1
288 OPC_Decode, 246, 20, 17, // 57: decode to SRL16_MM using decoder 17
289 // 57: }
290 // 57: } // switch Inst[0]
291 // 57: }
292 10, 6, // 61: case 0xa: {
293 OPC_CheckPredicate, 2, // 63: check predicate 2
294 OPC_Decode, 140, 15, 15, // 65: decode to LHU16_MM using decoder 15
295 // 65: }
296 11, 6, // 69: case 0xb: {
297 OPC_CheckPredicate, 1, // 71: check predicate 1
298 OPC_Decode, 230, 6, 18, // 73: decode to ANDI16_MM using decoder 18
299 // 73: }
300 17, 153, 1, // 77: case 0x11: {
301 OPC_SwitchField, 6, 4, // 80: switch Inst[9:6] {
302 0, 6, // 83: case 0x0: {
303 OPC_CheckPredicate, 1, // 85: check predicate 1
304 OPC_Decode, 161, 18, 19, // 87: decode to NOT16_MM using decoder 19
305 // 87: }
306 1, 6, // 91: case 0x1: {
307 OPC_CheckPredicate, 1, // 93: check predicate 1
308 OPC_Decode, 220, 22, 20, // 95: decode to XOR16_MM using decoder 20
309 // 95: }
310 2, 6, // 99: case 0x2: {
311 OPC_CheckPredicate, 1, // 101: check predicate 1
312 OPC_Decode, 227, 6, 20, // 103: decode to AND16_MM using decoder 20
313 // 103: }
314 3, 6, // 107: case 0x3: {
315 OPC_CheckPredicate, 1, // 109: check predicate 1
316 OPC_Decode, 166, 18, 20, // 111: decode to OR16_MM using decoder 20
317 // 111: }
318 4, 6, // 115: case 0x4: {
319 OPC_CheckPredicate, 1, // 117: check predicate 1
320 OPC_Decode, 190, 15, 21, // 119: decode to LWM16_MM using decoder 21
321 // 119: }
322 5, 6, // 123: case 0x5: {
323 OPC_CheckPredicate, 1, // 125: check predicate 1
324 OPC_Decode, 226, 21, 21, // 127: decode to SWM16_MM using decoder 21
325 // 127: }
326 6, 19, // 131: case 0x6: {
327 OPC_SwitchField, 5, 1, // 133: switch Inst[5] {
328 0, 6, // 136: case 0x0: {
329 OPC_CheckPredicate, 1, // 138: check predicate 1
330 OPC_Decode, 205, 14, 22, // 140: decode to JR16_MM using decoder 22
331 // 140: }
332 1, 0, // 144: case 0x1: {
333 OPC_CheckPredicate, 1, // 146: check predicate 1
334 OPC_Decode, 208, 14, 22, // 148: decode to JRC16_MM using decoder 22
335 // 148: }
336 // 148: } // switch Inst[5]
337 // 148: }
338 7, 19, // 152: case 0x7: {
339 OPC_SwitchField, 5, 1, // 154: switch Inst[5] {
340 0, 6, // 157: case 0x0: {
341 OPC_CheckPredicate, 1, // 159: check predicate 1
342 OPC_Decode, 184, 14, 22, // 161: decode to JALR16_MM using decoder 22
343 // 161: }
344 1, 0, // 165: case 0x1: {
345 OPC_CheckPredicate, 1, // 167: check predicate 1
346 OPC_Decode, 189, 14, 22, // 169: decode to JALRS16_MM using decoder 22
347 // 169: }
348 // 169: } // switch Inst[5]
349 // 169: }
350 8, 10, // 173: case 0x8: {
351 OPC_CheckPredicate, 1, // 175: check predicate 1
352 OPC_CheckField, 5, 1, 0, // 177: check Inst[5] == 0x0
353 OPC_Decode, 175, 16, 22, // 181: decode to MFHI16_MM using decoder 22
354 // 181: }
355 9, 10, // 185: case 0x9: {
356 OPC_CheckPredicate, 1, // 187: check predicate 1
357 OPC_CheckField, 5, 1, 0, // 189: check Inst[5] == 0x0
358 OPC_Decode, 181, 16, 22, // 193: decode to MFLO16_MM using decoder 22
359 // 193: }
360 10, 10, // 197: case 0xa: {
361 OPC_CheckPredicate, 1, // 199: check predicate 1
362 OPC_CheckField, 4, 2, 0, // 201: check Inst[5:4] == 0x0
363 OPC_Decode, 190, 8, 23, // 205: decode to BREAK16_MM using decoder 23
364 // 205: }
365 11, 10, // 209: case 0xb: {
366 OPC_CheckPredicate, 1, // 211: check predicate 1
367 OPC_CheckField, 4, 2, 0, // 213: check Inst[5:4] == 0x0
368 OPC_Decode, 199, 19, 23, // 217: decode to SDBBP16_MM using decoder 23
369 // 217: }
370 12, 0, // 221: case 0xc: {
371 OPC_CheckPredicate, 1, // 223: check predicate 1
372 OPC_CheckField, 5, 1, 0, // 225: check Inst[5] == 0x0
373 OPC_Decode, 207, 14, 24, // 229: decode to JRADDIUSP using decoder 24
374 // 229: }
375 // 229: } // switch Inst[9:6]
376 // 229: }
377 18, 6, // 233: case 0x12: {
378 OPC_CheckPredicate, 2, // 235: check predicate 2
379 OPC_Decode, 201, 15, 25, // 237: decode to LWSP_MM using decoder 25
380 // 237: }
381 19, 19, // 241: case 0x13: {
382 OPC_SwitchField, 0, 1, // 243: switch Inst[0] {
383 0, 6, // 246: case 0x0: {
384 OPC_CheckPredicate, 2, // 248: check predicate 2
385 OPC_Decode, 153, 6, 26, // 250: decode to ADDIUS5_MM using decoder 26
386 // 250: }
387 1, 0, // 254: case 0x1: {
388 OPC_CheckPredicate, 2, // 256: check predicate 2
389 OPC_Decode, 154, 6, 27, // 258: decode to ADDIUSP_MM using decoder 27
390 // 258: }
391 // 258: } // switch Inst[0]
392 // 258: }
393 25, 6, // 262: case 0x19: {
394 OPC_CheckPredicate, 2, // 264: check predicate 2
395 OPC_Decode, 184, 15, 28, // 266: decode to LWGP_MM using decoder 28
396 // 266: }
397 26, 6, // 270: case 0x1a: {
398 OPC_CheckPredicate, 2, // 272: check predicate 2
399 OPC_Decode, 172, 15, 15, // 274: decode to LW16_MM using decoder 15
400 // 274: }
401 27, 19, // 278: case 0x1b: {
402 OPC_SwitchField, 0, 1, // 280: switch Inst[0] {
403 0, 6, // 283: case 0x0: {
404 OPC_CheckPredicate, 2, // 285: check predicate 2
405 OPC_Decode, 152, 6, 29, // 287: decode to ADDIUR2_MM using decoder 29
406 // 287: }
407 1, 0, // 291: case 0x1: {
408 OPC_CheckPredicate, 2, // 293: check predicate 2
409 OPC_Decode, 151, 6, 30, // 295: decode to ADDIUR1SP_MM using decoder 30
410 // 295: }
411 // 295: } // switch Inst[0]
412 // 295: }
413 33, 10, // 299: case 0x21: {
414 OPC_CheckPredicate, 1, // 301: check predicate 1
415 OPC_CheckField, 0, 1, 0, // 303: check Inst[0] == 0x0
416 OPC_Decode, 231, 16, 31, // 307: decode to MOVEP_MM using decoder 31
417 // 307: }
418 34, 6, // 311: case 0x22: {
419 OPC_CheckPredicate, 1, // 313: check predicate 1
420 OPC_Decode, 180, 19, 15, // 315: decode to SB16_MM using decoder 15
421 // 315: }
422 35, 6, // 319: case 0x23: {
423 OPC_CheckPredicate, 1, // 321: check predicate 1
424 OPC_Decode, 193, 7, 32, // 323: decode to BEQZ16_MM using decoder 32
425 // 323: }
426 42, 6, // 327: case 0x2a: {
427 OPC_CheckPredicate, 1, // 329: check predicate 1
428 OPC_Decode, 246, 19, 15, // 331: decode to SH16_MM using decoder 15
429 // 331: }
430 43, 6, // 335: case 0x2b: {
431 OPC_CheckPredicate, 1, // 337: check predicate 1
432 OPC_Decode, 168, 8, 32, // 339: decode to BNEZ16_MM using decoder 32
433 // 339: }
434 50, 6, // 343: case 0x32: {
435 OPC_CheckPredicate, 1, // 345: check predicate 1
436 OPC_Decode, 235, 21, 25, // 347: decode to SWSP_MM using decoder 25
437 // 347: }
438 51, 6, // 351: case 0x33: {
439 OPC_CheckPredicate, 2, // 353: check predicate 2
440 OPC_Decode, 151, 7, 33, // 355: decode to B16_MM using decoder 33
441 // 355: }
442 58, 6, // 359: case 0x3a: {
443 OPC_CheckPredicate, 1, // 361: check predicate 1
444 OPC_Decode, 208, 21, 15, // 363: decode to SW16_MM using decoder 15
445 // 363: }
446 59, 0, // 367: case 0x3b: {
447 OPC_CheckPredicate, 1, // 369: check predicate 1
448 OPC_Decode, 149, 15, 34, // 371: decode to LI16_MM using decoder 34
449 // 371: }
450 // 371: } // switch Inst[15:10]
451};
452static const uint8_t DecoderTableMicroMipsR616[257] = {
453 OPC_SwitchField, 10, 6, // 0: switch Inst[15:10] {
454 1, 19, // 3: case 0x1: {
455 OPC_SwitchField, 0, 1, // 5: switch Inst[0] {
456 0, 6, // 8: case 0x0: {
457 OPC_CheckPredicate, 3, // 10: check predicate 3
458 OPC_Decode, 186, 6, 35, // 12: decode to ADDU16_MMR6 using decoder 35
459 // 12: }
460 1, 0, // 16: case 0x1: {
461 OPC_CheckPredicate, 3, // 18: check predicate 3
462 OPC_Decode, 178, 21, 35, // 20: decode to SUBU16_MMR6 using decoder 35
463 // 20: }
464 // 20: } // switch Inst[0]
465 // 20: }
466 3, 6, // 24: case 0x3: {
467 OPC_CheckPredicate, 3, // 26: check predicate 3
468 OPC_Decode, 230, 16, 16, // 28: decode to MOVE16_MMR6 using decoder 16
469 // 28: }
470 9, 19, // 32: case 0x9: {
471 OPC_SwitchField, 0, 1, // 34: switch Inst[0] {
472 0, 6, // 37: case 0x0: {
473 OPC_CheckPredicate, 3, // 39: check predicate 3
474 OPC_Decode, 188, 20, 17, // 41: decode to SLL16_MMR6 using decoder 17
475 // 41: }
476 1, 0, // 45: case 0x1: {
477 OPC_CheckPredicate, 3, // 47: check predicate 3
478 OPC_Decode, 247, 20, 17, // 49: decode to SRL16_MMR6 using decoder 17
479 // 49: }
480 // 49: } // switch Inst[0]
481 // 49: }
482 11, 6, // 53: case 0xb: {
483 OPC_CheckPredicate, 3, // 55: check predicate 3
484 OPC_Decode, 231, 6, 18, // 57: decode to ANDI16_MMR6 using decoder 18
485 // 57: }
486 17, 129, 1, // 61: case 0x11: {
487 OPC_SwitchField, 2, 1, // 64: switch Inst[2] {
488 0, 116, // 67: case 0x0: {
489 OPC_SwitchField, 0, 2, // 69: switch Inst[1:0] {
490 0, 19, // 72: case 0x0: {
491 OPC_SwitchField, 3, 1, // 74: switch Inst[3] {
492 0, 6, // 77: case 0x0: {
493 OPC_CheckPredicate, 3, // 79: check predicate 3
494 OPC_Decode, 162, 18, 36, // 81: decode to NOT16_MMR6 using decoder 36
495 // 81: }
496 1, 0, // 85: case 0x1: {
497 OPC_CheckPredicate, 3, // 87: check predicate 3
498 OPC_Decode, 221, 22, 37, // 89: decode to XOR16_MMR6 using decoder 37
499 // 89: }
500 // 89: } // switch Inst[3]
501 // 89: }
502 1, 19, // 93: case 0x1: {
503 OPC_SwitchField, 3, 1, // 95: switch Inst[3] {
504 0, 6, // 98: case 0x0: {
505 OPC_CheckPredicate, 3, // 100: check predicate 3
506 OPC_Decode, 228, 6, 37, // 102: decode to AND16_MMR6 using decoder 37
507 // 102: }
508 1, 0, // 106: case 0x1: {
509 OPC_CheckPredicate, 3, // 108: check predicate 3
510 OPC_Decode, 167, 18, 37, // 110: decode to OR16_MMR6 using decoder 37
511 // 110: }
512 // 110: } // switch Inst[3]
513 // 110: }
514 2, 19, // 114: case 0x2: {
515 OPC_SwitchField, 3, 1, // 116: switch Inst[3] {
516 0, 6, // 119: case 0x0: {
517 OPC_CheckPredicate, 3, // 121: check predicate 3
518 OPC_Decode, 191, 15, 21, // 123: decode to LWM16_MMR6 using decoder 21
519 // 123: }
520 1, 0, // 127: case 0x1: {
521 OPC_CheckPredicate, 3, // 129: check predicate 3
522 OPC_Decode, 227, 21, 21, // 131: decode to SWM16_MMR6 using decoder 21
523 // 131: }
524 // 131: } // switch Inst[3]
525 // 131: }
526 3, 0, // 135: case 0x3: {
527 OPC_SwitchField, 3, 2, // 137: switch Inst[4:3] {
528 0, 6, // 140: case 0x0: {
529 OPC_CheckPredicate, 3, // 142: check predicate 3
530 OPC_Decode, 209, 14, 38, // 144: decode to JRC16_MMR6 using decoder 38
531 // 144: }
532 1, 6, // 148: case 0x1: {
533 OPC_CheckPredicate, 3, // 150: check predicate 3
534 OPC_Decode, 186, 14, 38, // 152: decode to JALRC16_MMR6 using decoder 38
535 // 152: }
536 2, 6, // 156: case 0x2: {
537 OPC_CheckPredicate, 3, // 158: check predicate 3
538 OPC_Decode, 210, 14, 39, // 160: decode to JRCADDIUSP_MMR6 using decoder 39
539 // 160: }
540 3, 0, // 164: case 0x3: {
541 OPC_SwitchField, 5, 1, // 166: switch Inst[5] {
542 0, 6, // 169: case 0x0: {
543 OPC_CheckPredicate, 3, // 171: check predicate 3
544 OPC_Decode, 191, 8, 40, // 173: decode to BREAK16_MMR6 using decoder 40
545 // 173: }
546 1, 0, // 177: case 0x1: {
547 OPC_CheckPredicate, 3, // 179: check predicate 3
548 OPC_Decode, 200, 19, 40, // 181: decode to SDBBP16_MMR6 using decoder 40
549 // 181: }
550 // 181: } // switch Inst[5]
551 // 181: }
552 // 181: } // switch Inst[4:3]
553 // 181: }
554 // 181: } // switch Inst[1:0]
555 // 181: }
556 1, 0, // 185: case 0x1: {
557 OPC_CheckPredicate, 3, // 187: check predicate 3
558 OPC_Decode, 232, 16, 31, // 189: decode to MOVEP_MMR6 using decoder 31
559 // 189: }
560 // 189: } // switch Inst[2]
561 // 189: }
562 34, 6, // 193: case 0x22: {
563 OPC_CheckPredicate, 3, // 195: check predicate 3
564 OPC_Decode, 181, 19, 15, // 197: decode to SB16_MMR6 using decoder 15
565 // 197: }
566 35, 6, // 201: case 0x23: {
567 OPC_CheckPredicate, 3, // 203: check predicate 3
568 OPC_Decode, 197, 7, 32, // 205: decode to BEQZC16_MMR6 using decoder 32
569 // 205: }
570 42, 6, // 209: case 0x2a: {
571 OPC_CheckPredicate, 3, // 211: check predicate 3
572 OPC_Decode, 247, 19, 15, // 213: decode to SH16_MMR6 using decoder 15
573 // 213: }
574 43, 6, // 217: case 0x2b: {
575 OPC_CheckPredicate, 3, // 219: check predicate 3
576 OPC_Decode, 172, 8, 32, // 221: decode to BNEZC16_MMR6 using decoder 32
577 // 221: }
578 50, 6, // 225: case 0x32: {
579 OPC_CheckPredicate, 3, // 227: check predicate 3
580 OPC_Decode, 236, 21, 25, // 229: decode to SWSP_MMR6 using decoder 25
581 // 229: }
582 51, 6, // 233: case 0x33: {
583 OPC_CheckPredicate, 3, // 235: check predicate 3
584 OPC_Decode, 163, 7, 33, // 237: decode to BC16_MMR6 using decoder 33
585 // 237: }
586 58, 6, // 241: case 0x3a: {
587 OPC_CheckPredicate, 3, // 243: check predicate 3
588 OPC_Decode, 209, 21, 15, // 245: decode to SW16_MMR6 using decoder 15
589 // 245: }
590 59, 0, // 249: case 0x3b: {
591 OPC_CheckPredicate, 3, // 251: check predicate 3
592 OPC_Decode, 150, 15, 34, // 253: decode to LI16_MMR6 using decoder 34
593 // 253: }
594 // 253: } // switch Inst[15:10]
595};
596static const uint8_t DecoderTable32[305] = {
597 OPC_SwitchField, 11, 5, // 0: switch Inst[15:11] {
598 1, 14, // 3: case 0x1: {
599 OPC_CheckPredicate, 0, // 5: check predicate 0
600 OPC_CheckField, 27, 5, 30, // 7: check Inst[31:27] == 0x1e
601 OPC_CheckField, 5, 3, 0, // 11: check Inst[7:5] == 0x0
602 OPC_Decode, 143, 7, 41, // 15: decode to AddiuRxPcImmX16 using decoder 41
603 // 15: }
604 2, 14, // 19: case 0x2: {
605 OPC_CheckPredicate, 0, // 21: check predicate 0
606 OPC_CheckField, 27, 5, 30, // 23: check Inst[31:27] == 0x1e
607 OPC_CheckField, 5, 6, 0, // 27: check Inst[10:5] == 0x0
608 OPC_Decode, 212, 8, 42, // 31: decode to BimmX16 using decoder 42
609 // 31: }
610 4, 14, // 35: case 0x4: {
611 OPC_CheckPredicate, 0, // 37: check predicate 0
612 OPC_CheckField, 27, 5, 30, // 39: check Inst[31:27] == 0x1e
613 OPC_CheckField, 5, 3, 0, // 43: check Inst[7:5] == 0x0
614 OPC_Decode, 210, 8, 43, // 47: decode to BeqzRxImmX16 using decoder 43
615 // 47: }
616 5, 14, // 51: case 0x5: {
617 OPC_CheckPredicate, 0, // 53: check predicate 0
618 OPC_CheckField, 27, 5, 30, // 55: check Inst[31:27] == 0x1e
619 OPC_CheckField, 5, 3, 0, // 59: check Inst[7:5] == 0x0
620 OPC_Decode, 214, 8, 43, // 63: decode to BnezRxImmX16 using decoder 43
621 // 63: }
622 6, 64, // 67: case 0x6: {
623 OPC_CheckField, 27, 5, 30, // 69: check Inst[31:27] == 0x1e
624 OPC_Scope, 31, // 73: try {
625 OPC_CheckField, 16, 5, 0, // 75: check Inst[20:16] == 0x0
626 OPC_SwitchField, 0, 5, // 79: switch Inst[4:0] {
627 0, 6, // 82: case 0x0: {
628 OPC_CheckPredicate, 0, // 84: check predicate 0
629 OPC_Decode, 255, 21, 44, // 86: decode to SllX16 using decoder 44
630 // 86: }
631 2, 6, // 90: case 0x2: {
632 OPC_CheckPredicate, 0, // 92: check predicate 0
633 OPC_Decode, 137, 22, 44, // 94: decode to SrlX16 using decoder 44
634 // 94: }
635 3, 0, // 98: case 0x3: {
636 OPC_CheckPredicate, 0, // 100: check predicate 0
637 OPC_Decode, 135, 22, 44, // 102: decode to SraX16 using decoder 44
638 // 102: }
639 // 102: } // switch Inst[4:0]
640 // 102: } else try {
641 OPC_SwitchField, 5, 6, // 106: switch Inst[10:5] {
642 0, 6, // 109: case 0x0: {
643 OPC_CheckPredicate, 0, // 111: check predicate 0
644 OPC_Decode, 217, 8, 45, // 113: decode to BteqzX16 using decoder 45
645 // 113: }
646 8, 6, // 117: case 0x8: {
647 OPC_CheckPredicate, 0, // 119: check predicate 0
648 OPC_Decode, 219, 8, 45, // 121: decode to BtnezX16 using decoder 45
649 // 121: }
650 24, 0, // 125: case 0x18: {
651 OPC_CheckPredicate, 0, // 127: check predicate 0
652 OPC_Decode, 148, 7, 45, // 129: decode to AddiuSpImmX16 using decoder 45
653 // 129: }
654 // 129: } // switch Inst[10:5]
655 // 129: }
656 // 129: }
657 8, 14, // 133: case 0x8: {
658 OPC_CheckPredicate, 0, // 135: check predicate 0
659 OPC_CheckField, 27, 5, 30, // 137: check Inst[31:27] == 0x1e
660 OPC_CheckField, 4, 1, 0, // 141: check Inst[4] == 0x0
661 OPC_Decode, 146, 7, 46, // 145: decode to AddiuRxRyOffMemX16 using decoder 46
662 // 145: }
663 9, 14, // 149: case 0x9: {
664 OPC_CheckPredicate, 0, // 151: check predicate 0
665 OPC_CheckField, 27, 5, 30, // 153: check Inst[31:27] == 0x1e
666 OPC_CheckField, 5, 3, 0, // 157: check Inst[7:5] == 0x0
667 OPC_Decode, 142, 7, 41, // 161: decode to AddiuRxImmX16 using decoder 41
668 // 161: }
669 10, 14, // 165: case 0xa: {
670 OPC_CheckPredicate, 0, // 167: check predicate 0
671 OPC_CheckField, 27, 5, 30, // 169: check Inst[31:27] == 0x1e
672 OPC_CheckField, 5, 3, 0, // 173: check Inst[7:5] == 0x0
673 OPC_Decode, 131, 22, 41, // 177: decode to SltiRxImmX16 using decoder 41
674 // 177: }
675 11, 14, // 181: case 0xb: {
676 OPC_CheckPredicate, 0, // 183: check predicate 0
677 OPC_CheckField, 27, 5, 30, // 185: check Inst[31:27] == 0x1e
678 OPC_CheckField, 5, 3, 0, // 189: check Inst[7:5] == 0x0
679 OPC_Decode, 133, 22, 41, // 193: decode to SltiuRxImmX16 using decoder 41
680 // 193: }
681 13, 14, // 197: case 0xd: {
682 OPC_CheckPredicate, 0, // 199: check predicate 0
683 OPC_CheckField, 27, 5, 30, // 201: check Inst[31:27] == 0x1e
684 OPC_CheckField, 5, 3, 0, // 205: check Inst[7:5] == 0x0
685 OPC_Decode, 218, 15, 41, // 209: decode to LiRxImmX16 using decoder 41
686 // 209: }
687 14, 14, // 213: case 0xe: {
688 OPC_CheckPredicate, 0, // 215: check predicate 0
689 OPC_CheckField, 27, 5, 30, // 217: check Inst[31:27] == 0x1e
690 OPC_CheckField, 5, 3, 0, // 221: check Inst[7:5] == 0x0
691 OPC_Decode, 155, 11, 41, // 225: decode to CmpiRxImmX16 using decoder 41
692 // 225: }
693 18, 10, // 229: case 0x12: {
694 OPC_CheckPredicate, 0, // 231: check predicate 0
695 OPC_CheckField, 27, 5, 30, // 233: check Inst[31:27] == 0x1e
696 OPC_Decode, 222, 15, 46, // 237: decode to LwRxSpImmX16 using decoder 46
697 // 237: }
698 22, 14, // 241: case 0x16: {
699 OPC_CheckPredicate, 0, // 243: check predicate 0
700 OPC_CheckField, 27, 5, 30, // 245: check Inst[31:27] == 0x1e
701 OPC_CheckField, 5, 3, 0, // 249: check Inst[7:5] == 0x0
702 OPC_Decode, 220, 15, 47, // 253: decode to LwRxPcTcpX16 using decoder 47
703 // 253: }
704 24, 10, // 257: case 0x18: {
705 OPC_CheckPredicate, 0, // 259: check predicate 0
706 OPC_CheckField, 27, 5, 30, // 261: check Inst[31:27] == 0x1e
707 OPC_Decode, 251, 21, 46, // 265: decode to SbRxRyOffMemX16 using decoder 46
708 // 265: }
709 25, 10, // 269: case 0x19: {
710 OPC_CheckPredicate, 0, // 271: check predicate 0
711 OPC_CheckField, 27, 5, 30, // 273: check Inst[31:27] == 0x1e
712 OPC_Decode, 254, 21, 46, // 277: decode to ShRxRyOffMemX16 using decoder 46
713 // 277: }
714 26, 10, // 281: case 0x1a: {
715 OPC_CheckPredicate, 0, // 283: check predicate 0
716 OPC_CheckField, 27, 5, 30, // 285: check Inst[31:27] == 0x1e
717 OPC_Decode, 141, 22, 46, // 289: decode to SwRxSpImmX16 using decoder 46
718 // 289: }
719 27, 0, // 293: case 0x1b: {
720 OPC_CheckPredicate, 0, // 295: check predicate 0
721 OPC_CheckField, 27, 5, 30, // 297: check Inst[31:27] == 0x1e
722 OPC_Decode, 140, 22, 46, // 301: decode to SwRxRyOffMemX16 using decoder 46
723 // 301: }
724 // 301: } // switch Inst[15:11]
725};
726static const uint8_t DecoderTableCOP3_32[35] = {
727 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
728 51, 6, // 3: case 0x33: {
729 OPC_CheckPredicate, 4, // 5: check predicate 4
730 OPC_Decode, 179, 15, 48, // 7: decode to LWC3 using decoder 48
731 // 7: }
732 55, 6, // 11: case 0x37: {
733 OPC_CheckPredicate, 5, // 13: check predicate 5
734 OPC_Decode, 247, 14, 48, // 15: decode to LDC3 using decoder 48
735 // 15: }
736 59, 6, // 19: case 0x3b: {
737 OPC_CheckPredicate, 4, // 21: check predicate 4
738 OPC_Decode, 216, 21, 48, // 23: decode to SWC3 using decoder 48
739 // 23: }
740 63, 0, // 27: case 0x3f: {
741 OPC_CheckPredicate, 5, // 29: check predicate 5
742 OPC_Decode, 212, 19, 48, // 31: decode to SDC3 using decoder 48
743 // 31: }
744 // 31: } // switch Inst[31:26]
745};
746static const uint8_t DecoderTableCnMips32[298] = {
747 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
748 18, 19, // 3: case 0x12: {
749 OPC_SwitchField, 21, 5, // 5: switch Inst[25:21] {
750 1, 6, // 8: case 0x1: {
751 OPC_CheckPredicate, 6, // 10: check predicate 6
752 OPC_Decode, 201, 11, 49, // 12: decode to DMFC2_OCTEON using decoder 49
753 // 12: }
754 5, 0, // 16: case 0x5: {
755 OPC_CheckPredicate, 6, // 18: check predicate 6
756 OPC_Decode, 209, 11, 49, // 20: decode to DMTC2_OCTEON using decoder 49
757 // 20: }
758 // 20: } // switch Inst[25:21]
759 // 20: }
760 28, 239, 1, // 24: case 0x1c: {
761 OPC_SwitchField, 0, 6, // 27: switch Inst[5:0] {
762 3, 10, // 30: case 0x3: {
763 OPC_CheckPredicate, 6, // 32: check predicate 6
764 OPC_CheckField, 6, 5, 0, // 34: check Inst[10:6] == 0x0
765 OPC_Decode, 213, 11, 50, // 38: decode to DMUL using decoder 50
766 // 38: }
767 8, 10, // 42: case 0x8: {
768 OPC_CheckPredicate, 6, // 44: check predicate 6
769 OPC_CheckField, 6, 15, 0, // 46: check Inst[20:6] == 0x0
770 OPC_Decode, 202, 17, 51, // 50: decode to MTM0 using decoder 51
771 // 50: }
772 9, 10, // 54: case 0x9: {
773 OPC_CheckPredicate, 6, // 56: check predicate 6
774 OPC_CheckField, 6, 15, 0, // 58: check Inst[20:6] == 0x0
775 OPC_Decode, 205, 17, 51, // 62: decode to MTP0 using decoder 51
776 // 62: }
777 10, 10, // 66: case 0xa: {
778 OPC_CheckPredicate, 6, // 68: check predicate 6
779 OPC_CheckField, 6, 15, 0, // 70: check Inst[20:6] == 0x0
780 OPC_Decode, 206, 17, 51, // 74: decode to MTP1 using decoder 51
781 // 74: }
782 11, 10, // 78: case 0xb: {
783 OPC_CheckPredicate, 6, // 80: check predicate 6
784 OPC_CheckField, 6, 15, 0, // 82: check Inst[20:6] == 0x0
785 OPC_Decode, 207, 17, 51, // 86: decode to MTP2 using decoder 51
786 // 86: }
787 12, 10, // 90: case 0xc: {
788 OPC_CheckPredicate, 6, // 92: check predicate 6
789 OPC_CheckField, 6, 15, 0, // 94: check Inst[20:6] == 0x0
790 OPC_Decode, 203, 17, 51, // 98: decode to MTM1 using decoder 51
791 // 98: }
792 13, 10, // 102: case 0xd: {
793 OPC_CheckPredicate, 6, // 104: check predicate 6
794 OPC_CheckField, 6, 15, 0, // 106: check Inst[20:6] == 0x0
795 OPC_Decode, 204, 17, 51, // 110: decode to MTM2 using decoder 51
796 // 110: }
797 15, 10, // 114: case 0xf: {
798 OPC_CheckPredicate, 6, // 116: check predicate 6
799 OPC_CheckField, 6, 5, 0, // 118: check Inst[10:6] == 0x0
800 OPC_Decode, 205, 22, 50, // 122: decode to VMULU using decoder 50
801 // 122: }
802 16, 10, // 126: case 0x10: {
803 OPC_CheckPredicate, 6, // 128: check predicate 6
804 OPC_CheckField, 6, 5, 0, // 130: check Inst[10:6] == 0x0
805 OPC_Decode, 204, 22, 50, // 134: decode to VMM0 using decoder 50
806 // 134: }
807 17, 10, // 138: case 0x11: {
808 OPC_CheckPredicate, 6, // 140: check predicate 6
809 OPC_CheckField, 6, 5, 0, // 142: check Inst[10:6] == 0x0
810 OPC_Decode, 203, 22, 50, // 146: decode to V3MULU using decoder 50
811 // 146: }
812 40, 10, // 150: case 0x28: {
813 OPC_CheckPredicate, 6, // 152: check predicate 6
814 OPC_CheckField, 6, 5, 0, // 154: check Inst[10:6] == 0x0
815 OPC_Decode, 152, 7, 50, // 158: decode to BADDu using decoder 50
816 // 158: }
817 42, 10, // 162: case 0x2a: {
818 OPC_CheckPredicate, 6, // 164: check predicate 6
819 OPC_CheckField, 6, 5, 0, // 166: check Inst[10:6] == 0x0
820 OPC_Decode, 243, 19, 50, // 170: decode to SEQ using decoder 50
821 // 170: }
822 43, 10, // 174: case 0x2b: {
823 OPC_CheckPredicate, 6, // 176: check predicate 6
824 OPC_CheckField, 6, 5, 0, // 178: check Inst[10:6] == 0x0
825 OPC_Decode, 215, 20, 50, // 182: decode to SNE using decoder 50
826 // 182: }
827 44, 14, // 186: case 0x2c: {
828 OPC_CheckPredicate, 6, // 188: check predicate 6
829 OPC_CheckField, 16, 5, 0, // 190: check Inst[20:16] == 0x0
830 OPC_CheckField, 6, 5, 0, // 194: check Inst[10:6] == 0x0
831 OPC_Decode, 201, 18, 52, // 198: decode to POP using decoder 52
832 // 198: }
833 45, 14, // 202: case 0x2d: {
834 OPC_CheckPredicate, 6, // 204: check predicate 6
835 OPC_CheckField, 16, 5, 0, // 206: check Inst[20:16] == 0x0
836 OPC_CheckField, 6, 5, 0, // 210: check Inst[10:6] == 0x0
837 OPC_Decode, 246, 11, 53, // 214: decode to DPOP using decoder 53
838 // 214: }
839 46, 6, // 218: case 0x2e: {
840 OPC_CheckPredicate, 6, // 220: check predicate 6
841 OPC_Decode, 244, 19, 54, // 222: decode to SEQi using decoder 54
842 // 222: }
843 47, 6, // 226: case 0x2f: {
844 OPC_CheckPredicate, 6, // 228: check predicate 6
845 OPC_Decode, 216, 20, 54, // 230: decode to SNEi using decoder 54
846 // 230: }
847 50, 6, // 234: case 0x32: {
848 OPC_CheckPredicate, 7, // 236: check predicate 7
849 OPC_Decode, 249, 8, 55, // 238: decode to CINS using decoder 55
850 // 238: }
851 51, 6, // 242: case 0x33: {
852 OPC_CheckPredicate, 7, // 244: check predicate 7
853 OPC_Decode, 250, 8, 55, // 246: decode to CINS32 using decoder 55
854 // 246: }
855 58, 6, // 250: case 0x3a: {
856 OPC_CheckPredicate, 7, // 252: check predicate 7
857 OPC_Decode, 205, 12, 55, // 254: decode to EXTS using decoder 55
858 // 254: }
859 59, 0, // 258: case 0x3b: {
860 OPC_CheckPredicate, 7, // 260: check predicate 7
861 OPC_Decode, 206, 12, 55, // 262: decode to EXTS32 using decoder 55
862 // 262: }
863 // 262: } // switch Inst[5:0]
864 // 262: }
865 50, 6, // 266: case 0x32: {
866 OPC_CheckPredicate, 6, // 268: check predicate 6
867 OPC_Decode, 158, 7, 56, // 270: decode to BBIT0 using decoder 56
868 // 270: }
869 54, 6, // 274: case 0x36: {
870 OPC_CheckPredicate, 6, // 276: check predicate 6
871 OPC_Decode, 159, 7, 56, // 278: decode to BBIT032 using decoder 56
872 // 278: }
873 58, 6, // 282: case 0x3a: {
874 OPC_CheckPredicate, 6, // 284: check predicate 6
875 OPC_Decode, 160, 7, 56, // 286: decode to BBIT1 using decoder 56
876 // 286: }
877 62, 0, // 290: case 0x3e: {
878 OPC_CheckPredicate, 6, // 292: check predicate 6
879 OPC_Decode, 161, 7, 56, // 294: decode to BBIT132 using decoder 56
880 // 294: }
881 // 294: } // switch Inst[31:26]
882};
883static const uint8_t DecoderTableCnMipsP32[27] = {
884 OPC_SwitchField, 0, 16, // 0: switch Inst[15:0] {
885 24, 10, // 3: case 0x18: {
886 OPC_CheckPredicate, 8, // 5: check predicate 8
887 OPC_CheckField, 26, 6, 28, // 7: check Inst[31:26] == 0x1c
888 OPC_Decode, 169, 19, 57, // 11: decode to SAA using decoder 57
889 // 11: }
890 25, 0, // 15: case 0x19: {
891 OPC_CheckPredicate, 8, // 17: check predicate 8
892 OPC_CheckField, 26, 6, 28, // 19: check Inst[31:26] == 0x1c
893 OPC_Decode, 170, 19, 57, // 23: decode to SAAD using decoder 57
894 // 23: }
895 // 23: } // switch Inst[15:0]
896};
897static const uint8_t DecoderTableMicroMips32[3850] = {
898 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
899 0, 162, 17, // 3: case 0x0: {
900 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
901 0, 64, // 9: case 0x0: {
902 OPC_SwitchField, 6, 5, // 11: switch Inst[10:6] {
903 0, 35, // 14: case 0x0: {
904 OPC_Scope, 27, // 16: try {
905 OPC_SwitchField, 11, 15, // 18: switch Inst[25:11] {
906 1, 6, // 21: case 0x1: {
907 OPC_CheckPredicate, 2, // 23: check predicate 2
908 OPC_Decode, 140, 21, 10, // 25: decode to SSNOP_MM using decoder 10
909 // 25: }
910 3, 6, // 29: case 0x3: {
911 OPC_CheckPredicate, 2, // 31: check predicate 2
912 OPC_Decode, 166, 12, 10, // 33: decode to EHB_MM using decoder 10
913 // 33: }
914 5, 0, // 37: case 0x5: {
915 OPC_CheckPredicate, 2, // 39: check predicate 2
916 OPC_Decode, 181, 18, 10, // 41: decode to PAUSE_MM using decoder 10
917 // 41: }
918 // 41: } // switch Inst[25:11]
919 // 41: } else try {
920 OPC_CheckPredicate, 2, // 45: check predicate 2
921 OPC_Decode, 200, 20, 58, // 47: decode to SLL_MM using decoder 58
922 // 47: }
923 // 47: }
924 1, 6, // 51: case 0x1: {
925 OPC_CheckPredicate, 2, // 53: check predicate 2
926 OPC_Decode, 137, 21, 58, // 55: decode to SRL_MM using decoder 58
927 // 55: }
928 2, 6, // 59: case 0x2: {
929 OPC_CheckPredicate, 2, // 61: check predicate 2
930 OPC_Decode, 243, 20, 58, // 63: decode to SRA_MM using decoder 58
931 // 63: }
932 3, 0, // 67: case 0x3: {
933 OPC_CheckPredicate, 2, // 69: check predicate 2
934 OPC_Decode, 149, 19, 58, // 71: decode to ROTR_MM using decoder 58
935 // 71: }
936 // 71: } // switch Inst[10:6]
937 // 71: }
938 5, 131, 1, // 75: case 0x5: {
939 OPC_SwitchField, 6, 5, // 78: switch Inst[10:6] {
940 0, 10, // 81: case 0x0: {
941 OPC_CheckPredicate, 9, // 83: check predicate 9
942 OPC_CheckField, 11, 5, 0, // 85: check Inst[15:11] == 0x0
943 OPC_Decode, 192, 9, 59, // 89: decode to CMP_EQ_PH_MM using decoder 59
944 // 89: }
945 1, 10, // 93: case 0x1: {
946 OPC_CheckPredicate, 9, // 95: check predicate 9
947 OPC_CheckField, 11, 5, 0, // 97: check Inst[15:11] == 0x0
948 OPC_Decode, 206, 9, 59, // 101: decode to CMP_LT_PH_MM using decoder 59
949 // 101: }
950 2, 10, // 105: case 0x2: {
951 OPC_CheckPredicate, 9, // 107: check predicate 9
952 OPC_CheckField, 11, 5, 0, // 109: check Inst[15:11] == 0x0
953 OPC_Decode, 200, 9, 59, // 113: decode to CMP_LE_PH_MM using decoder 59
954 // 113: }
955 6, 6, // 117: case 0x6: {
956 OPC_CheckPredicate, 10, // 119: check predicate 10
957 OPC_Decode, 170, 9, 60, // 121: decode to CMPGDU_EQ_QB_MMR2 using decoder 60
958 // 121: }
959 7, 6, // 125: case 0x7: {
960 OPC_CheckPredicate, 10, // 127: check predicate 10
961 OPC_Decode, 174, 9, 60, // 129: decode to CMPGDU_LT_QB_MMR2 using decoder 60
962 // 129: }
963 8, 6, // 133: case 0x8: {
964 OPC_CheckPredicate, 10, // 135: check predicate 10
965 OPC_Decode, 172, 9, 60, // 137: decode to CMPGDU_LE_QB_MMR2 using decoder 60
966 // 137: }
967 9, 10, // 141: case 0x9: {
968 OPC_CheckPredicate, 9, // 143: check predicate 9
969 OPC_CheckField, 11, 5, 0, // 145: check Inst[15:11] == 0x0
970 OPC_Decode, 182, 9, 59, // 149: decode to CMPU_EQ_QB_MM using decoder 59
971 // 149: }
972 10, 10, // 153: case 0xa: {
973 OPC_CheckPredicate, 9, // 155: check predicate 9
974 OPC_CheckField, 11, 5, 0, // 157: check Inst[15:11] == 0x0
975 OPC_Decode, 186, 9, 59, // 161: decode to CMPU_LT_QB_MM using decoder 59
976 // 161: }
977 11, 10, // 165: case 0xb: {
978 OPC_CheckPredicate, 9, // 167: check predicate 9
979 OPC_CheckField, 11, 5, 0, // 169: check Inst[15:11] == 0x0
980 OPC_Decode, 184, 9, 59, // 173: decode to CMPU_LE_QB_MM using decoder 59
981 // 173: }
982 12, 6, // 177: case 0xc: {
983 OPC_CheckPredicate, 9, // 179: check predicate 9
984 OPC_Decode, 169, 6, 61, // 181: decode to ADDQ_S_W_MM using decoder 61
985 // 181: }
986 13, 6, // 185: case 0xd: {
987 OPC_CheckPredicate, 9, // 187: check predicate 9
988 OPC_Decode, 160, 21, 61, // 189: decode to SUBQ_S_W_MM using decoder 61
989 // 189: }
990 14, 6, // 193: case 0xe: {
991 OPC_CheckPredicate, 9, // 195: check predicate 9
992 OPC_Decode, 172, 6, 61, // 197: decode to ADDSC_MM using decoder 61
993 // 197: }
994 15, 0, // 201: case 0xf: {
995 OPC_CheckPredicate, 9, // 203: check predicate 9
996 OPC_Decode, 209, 6, 61, // 205: decode to ADDWC_MM using decoder 61
997 // 205: }
998 // 205: } // switch Inst[10:6]
999 // 205: }
1000 7, 6, // 209: case 0x7: {
1001 OPC_CheckPredicate, 2, // 211: check predicate 2
1002 OPC_Decode, 192, 8, 62, // 213: decode to BREAK_MM using decoder 62
1003 // 213: }
1004 12, 6, // 217: case 0xc: {
1005 OPC_CheckPredicate, 1, // 219: check predicate 1
1006 OPC_Decode, 179, 14, 63, // 221: decode to INS_MM using decoder 63
1007 // 221: }
1008 13, 243, 1, // 225: case 0xd: {
1009 OPC_SwitchField, 6, 5, // 228: switch Inst[10:6] {
1010 0, 6, // 231: case 0x0: {
1011 OPC_CheckPredicate, 9, // 233: check predicate 9
1012 OPC_Decode, 165, 6, 64, // 235: decode to ADDQ_PH_MM using decoder 64
1013 // 235: }
1014 1, 6, // 239: case 0x1: {
1015 OPC_CheckPredicate, 10, // 241: check predicate 10
1016 OPC_Decode, 157, 6, 64, // 243: decode to ADDQH_PH_MMR2 using decoder 64
1017 // 243: }
1018 2, 6, // 247: case 0x2: {
1019 OPC_CheckPredicate, 10, // 249: check predicate 10
1020 OPC_Decode, 163, 6, 61, // 251: decode to ADDQH_W_MMR2 using decoder 61
1021 // 251: }
1022 3, 6, // 255: case 0x3: {
1023 OPC_CheckPredicate, 9, // 257: check predicate 9
1024 OPC_Decode, 195, 6, 64, // 259: decode to ADDU_QB_MM using decoder 64
1025 // 259: }
1026 4, 6, // 263: case 0x4: {
1027 OPC_CheckPredicate, 10, // 265: check predicate 10
1028 OPC_Decode, 193, 6, 64, // 267: decode to ADDU_PH_MMR2 using decoder 64
1029 // 267: }
1030 5, 6, // 271: case 0x5: {
1031 OPC_CheckPredicate, 10, // 273: check predicate 10
1032 OPC_Decode, 188, 6, 64, // 275: decode to ADDUH_QB_MMR2 using decoder 64
1033 // 275: }
1034 6, 6, // 279: case 0x6: {
1035 OPC_CheckPredicate, 9, // 281: check predicate 9
1036 OPC_Decode, 147, 20, 65, // 283: decode to SHRAV_PH_MM using decoder 65
1037 // 283: }
1038 7, 6, // 287: case 0x7: {
1039 OPC_CheckPredicate, 10, // 289: check predicate 10
1040 OPC_Decode, 149, 20, 65, // 291: decode to SHRAV_QB_MMR2 using decoder 65
1041 // 291: }
1042 8, 6, // 295: case 0x8: {
1043 OPC_CheckPredicate, 9, // 297: check predicate 9
1044 OPC_Decode, 156, 21, 64, // 299: decode to SUBQ_PH_MM using decoder 64
1045 // 299: }
1046 9, 6, // 303: case 0x9: {
1047 OPC_CheckPredicate, 10, // 305: check predicate 10
1048 OPC_Decode, 148, 21, 64, // 307: decode to SUBQH_PH_MMR2 using decoder 64
1049 // 307: }
1050 10, 6, // 311: case 0xa: {
1051 OPC_CheckPredicate, 10, // 313: check predicate 10
1052 OPC_Decode, 154, 21, 61, // 315: decode to SUBQH_W_MMR2 using decoder 61
1053 // 315: }
1054 11, 6, // 319: case 0xb: {
1055 OPC_CheckPredicate, 9, // 321: check predicate 9
1056 OPC_Decode, 187, 21, 64, // 323: decode to SUBU_QB_MM using decoder 64
1057 // 323: }
1058 12, 6, // 327: case 0xc: {
1059 OPC_CheckPredicate, 10, // 329: check predicate 10
1060 OPC_Decode, 185, 21, 64, // 331: decode to SUBU_PH_MMR2 using decoder 64
1061 // 331: }
1062 13, 6, // 335: case 0xd: {
1063 OPC_CheckPredicate, 10, // 337: check predicate 10
1064 OPC_Decode, 180, 21, 64, // 339: decode to SUBUH_QB_MMR2 using decoder 64
1065 // 339: }
1066 15, 6, // 343: case 0xf: {
1067 OPC_CheckPredicate, 10, // 345: check predicate 10
1068 OPC_Decode, 233, 18, 66, // 347: decode to PRECR_SRA_PH_W_MMR2 using decoder 66
1069 // 347: }
1070 16, 6, // 351: case 0x10: {
1071 OPC_CheckPredicate, 9, // 353: check predicate 9
1072 OPC_Decode, 167, 6, 64, // 355: decode to ADDQ_S_PH_MM using decoder 64
1073 // 355: }
1074 17, 6, // 359: case 0x11: {
1075 OPC_CheckPredicate, 10, // 361: check predicate 10
1076 OPC_Decode, 159, 6, 64, // 363: decode to ADDQH_R_PH_MMR2 using decoder 64
1077 // 363: }
1078 18, 6, // 367: case 0x12: {
1079 OPC_CheckPredicate, 10, // 369: check predicate 10
1080 OPC_Decode, 161, 6, 61, // 371: decode to ADDQH_R_W_MMR2 using decoder 61
1081 // 371: }
1082 19, 6, // 375: case 0x13: {
1083 OPC_CheckPredicate, 9, // 377: check predicate 9
1084 OPC_Decode, 199, 6, 64, // 379: decode to ADDU_S_QB_MM using decoder 64
1085 // 379: }
1086 20, 6, // 383: case 0x14: {
1087 OPC_CheckPredicate, 10, // 385: check predicate 10
1088 OPC_Decode, 197, 6, 64, // 387: decode to ADDU_S_PH_MMR2 using decoder 64
1089 // 387: }
1090 21, 6, // 391: case 0x15: {
1091 OPC_CheckPredicate, 10, // 393: check predicate 10
1092 OPC_Decode, 190, 6, 64, // 395: decode to ADDUH_R_QB_MMR2 using decoder 64
1093 // 395: }
1094 22, 6, // 399: case 0x16: {
1095 OPC_CheckPredicate, 9, // 401: check predicate 9
1096 OPC_Decode, 151, 20, 65, // 403: decode to SHRAV_R_PH_MM using decoder 65
1097 // 403: }
1098 23, 6, // 407: case 0x17: {
1099 OPC_CheckPredicate, 10, // 409: check predicate 10
1100 OPC_Decode, 153, 20, 65, // 411: decode to SHRAV_R_QB_MMR2 using decoder 65
1101 // 411: }
1102 24, 6, // 415: case 0x18: {
1103 OPC_CheckPredicate, 9, // 417: check predicate 9
1104 OPC_Decode, 158, 21, 64, // 419: decode to SUBQ_S_PH_MM using decoder 64
1105 // 419: }
1106 25, 6, // 423: case 0x19: {
1107 OPC_CheckPredicate, 10, // 425: check predicate 10
1108 OPC_Decode, 150, 21, 64, // 427: decode to SUBQH_R_PH_MMR2 using decoder 64
1109 // 427: }
1110 26, 6, // 431: case 0x1a: {
1111 OPC_CheckPredicate, 10, // 433: check predicate 10
1112 OPC_Decode, 152, 21, 61, // 435: decode to SUBQH_R_W_MMR2 using decoder 61
1113 // 435: }
1114 27, 6, // 439: case 0x1b: {
1115 OPC_CheckPredicate, 9, // 441: check predicate 9
1116 OPC_Decode, 191, 21, 64, // 443: decode to SUBU_S_QB_MM using decoder 64
1117 // 443: }
1118 28, 6, // 447: case 0x1c: {
1119 OPC_CheckPredicate, 10, // 449: check predicate 10
1120 OPC_Decode, 189, 21, 64, // 451: decode to SUBU_S_PH_MMR2 using decoder 64
1121 // 451: }
1122 29, 6, // 455: case 0x1d: {
1123 OPC_CheckPredicate, 10, // 457: check predicate 10
1124 OPC_Decode, 182, 21, 64, // 459: decode to SUBUH_R_QB_MMR2 using decoder 64
1125 // 459: }
1126 31, 0, // 463: case 0x1f: {
1127 OPC_CheckPredicate, 10, // 465: check predicate 10
1128 OPC_Decode, 235, 18, 66, // 467: decode to PRECR_SRA_R_PH_W_MMR2 using decoder 66
1129 // 467: }
1130 // 467: } // switch Inst[10:6]
1131 // 467: }
1132 14, 19, // 471: case 0xe: {
1133 OPC_SwitchField, 6, 5, // 473: switch Inst[10:6] {
1134 0, 6, // 476: case 0x0: {
1135 OPC_CheckPredicate, 9, // 478: check predicate 9
1136 OPC_Decode, 131, 20, 65, // 480: decode to SHLLV_PH_MM using decoder 65
1137 // 480: }
1138 16, 0, // 484: case 0x10: {
1139 OPC_CheckPredicate, 9, // 486: check predicate 9
1140 OPC_Decode, 135, 20, 65, // 488: decode to SHLLV_S_PH_MM using decoder 65
1141 // 488: }
1142 // 488: } // switch Inst[10:6]
1143 // 488: }
1144 16, 123, // 492: case 0x10: {
1145 OPC_SwitchField, 6, 5, // 494: switch Inst[10:6] {
1146 0, 6, // 497: case 0x0: {
1147 OPC_CheckPredicate, 2, // 499: check predicate 2
1148 OPC_Decode, 196, 20, 67, // 501: decode to SLLV_MM using decoder 67
1149 // 501: }
1150 1, 6, // 505: case 0x1: {
1151 OPC_CheckPredicate, 2, // 507: check predicate 2
1152 OPC_Decode, 133, 21, 67, // 509: decode to SRLV_MM using decoder 67
1153 // 509: }
1154 2, 6, // 513: case 0x2: {
1155 OPC_CheckPredicate, 2, // 515: check predicate 2
1156 OPC_Decode, 239, 20, 67, // 517: decode to SRAV_MM using decoder 67
1157 // 517: }
1158 3, 6, // 521: case 0x3: {
1159 OPC_CheckPredicate, 2, // 523: check predicate 2
1160 OPC_Decode, 148, 19, 67, // 525: decode to ROTRV_MM using decoder 67
1161 // 525: }
1162 4, 6, // 529: case 0x4: {
1163 OPC_CheckPredicate, 1, // 531: check predicate 1
1164 OPC_Decode, 214, 6, 61, // 533: decode to ADD_MM using decoder 61
1165 // 533: }
1166 5, 6, // 537: case 0x5: {
1167 OPC_CheckPredicate, 1, // 539: check predicate 1
1168 OPC_Decode, 221, 6, 61, // 541: decode to ADDu_MM using decoder 61
1169 // 541: }
1170 6, 6, // 545: case 0x6: {
1171 OPC_CheckPredicate, 1, // 547: check predicate 1
1172 OPC_Decode, 200, 21, 61, // 549: decode to SUB_MM using decoder 61
1173 // 549: }
1174 7, 6, // 553: case 0x7: {
1175 OPC_CheckPredicate, 1, // 555: check predicate 1
1176 OPC_Decode, 203, 21, 61, // 557: decode to SUBu_MM using decoder 61
1177 // 557: }
1178 8, 6, // 561: case 0x8: {
1179 OPC_CheckPredicate, 1, // 563: check predicate 1
1180 OPC_Decode, 251, 17, 61, // 565: decode to MUL_MM using decoder 61
1181 // 565: }
1182 9, 6, // 569: case 0x9: {
1183 OPC_CheckPredicate, 1, // 571: check predicate 1
1184 OPC_Decode, 234, 6, 61, // 573: decode to AND_MM using decoder 61
1185 // 573: }
1186 10, 6, // 577: case 0xa: {
1187 OPC_CheckPredicate, 1, // 579: check predicate 1
1188 OPC_Decode, 171, 18, 61, // 581: decode to OR_MM using decoder 61
1189 // 581: }
1190 11, 6, // 585: case 0xb: {
1191 OPC_CheckPredicate, 1, // 587: check predicate 1
1192 OPC_Decode, 158, 18, 61, // 589: decode to NOR_MM using decoder 61
1193 // 589: }
1194 12, 6, // 593: case 0xc: {
1195 OPC_CheckPredicate, 1, // 595: check predicate 1
1196 OPC_Decode, 225, 22, 61, // 597: decode to XOR_MM using decoder 61
1197 // 597: }
1198 13, 6, // 601: case 0xd: {
1199 OPC_CheckPredicate, 2, // 603: check predicate 2
1200 OPC_Decode, 205, 20, 61, // 605: decode to SLT_MM using decoder 61
1201 // 605: }
1202 14, 0, // 609: case 0xe: {
1203 OPC_CheckPredicate, 2, // 611: check predicate 2
1204 OPC_Decode, 214, 20, 61, // 613: decode to SLTu_MM using decoder 61
1205 // 613: }
1206 // 613: } // switch Inst[10:6]
1207 // 613: }
1208 21, 115, // 617: case 0x15: {
1209 OPC_SwitchField, 6, 5, // 619: switch Inst[10:6] {
1210 2, 6, // 622: case 0x2: {
1211 OPC_CheckPredicate, 9, // 624: check predicate 9
1212 OPC_Decode, 219, 17, 64, // 626: decode to MULEU_S_PH_QBL_MM using decoder 64
1213 // 626: }
1214 3, 6, // 630: case 0x3: {
1215 OPC_CheckPredicate, 9, // 632: check predicate 9
1216 OPC_Decode, 221, 17, 64, // 634: decode to MULEU_S_PH_QBR_MM using decoder 64
1217 // 634: }
1218 4, 6, // 638: case 0x4: {
1219 OPC_CheckPredicate, 9, // 640: check predicate 9
1220 OPC_Decode, 223, 17, 64, // 642: decode to MULQ_RS_PH_MM using decoder 64
1221 // 642: }
1222 5, 6, // 646: case 0x5: {
1223 OPC_CheckPredicate, 10, // 648: check predicate 10
1224 OPC_Decode, 227, 17, 64, // 650: decode to MULQ_S_PH_MMR2 using decoder 64
1225 // 650: }
1226 6, 6, // 654: case 0x6: {
1227 OPC_CheckPredicate, 10, // 656: check predicate 10
1228 OPC_Decode, 225, 17, 61, // 658: decode to MULQ_RS_W_MMR2 using decoder 61
1229 // 658: }
1230 7, 6, // 662: case 0x7: {
1231 OPC_CheckPredicate, 10, // 664: check predicate 10
1232 OPC_Decode, 229, 17, 61, // 666: decode to MULQ_S_W_MMR2 using decoder 61
1233 // 666: }
1234 8, 6, // 670: case 0x8: {
1235 OPC_CheckPredicate, 10, // 672: check predicate 10
1236 OPC_Decode, 241, 6, 68, // 674: decode to APPEND_MMR2 using decoder 68
1237 // 674: }
1238 9, 6, // 678: case 0x9: {
1239 OPC_CheckPredicate, 10, // 680: check predicate 10
1240 OPC_Decode, 244, 18, 68, // 682: decode to PREPEND_MMR2 using decoder 68
1241 // 682: }
1242 10, 6, // 686: case 0xa: {
1243 OPC_CheckPredicate, 9, // 688: check predicate 9
1244 OPC_Decode, 217, 16, 61, // 690: decode to MODSUB_MM using decoder 61
1245 // 690: }
1246 11, 6, // 694: case 0xb: {
1247 OPC_CheckPredicate, 9, // 696: check predicate 9
1248 OPC_Decode, 155, 20, 67, // 698: decode to SHRAV_R_W_MM using decoder 67
1249 // 698: }
1250 12, 6, // 702: case 0xc: {
1251 OPC_CheckPredicate, 10, // 704: check predicate 10
1252 OPC_Decode, 167, 20, 65, // 706: decode to SHRLV_PH_MMR2 using decoder 65
1253 // 706: }
1254 13, 6, // 710: case 0xd: {
1255 OPC_CheckPredicate, 9, // 712: check predicate 9
1256 OPC_Decode, 169, 20, 65, // 714: decode to SHRLV_QB_MM using decoder 65
1257 // 714: }
1258 14, 6, // 718: case 0xe: {
1259 OPC_CheckPredicate, 9, // 720: check predicate 9
1260 OPC_Decode, 133, 20, 65, // 722: decode to SHLLV_QB_MM using decoder 65
1261 // 722: }
1262 15, 0, // 726: case 0xf: {
1263 OPC_CheckPredicate, 9, // 728: check predicate 9
1264 OPC_Decode, 137, 20, 67, // 730: decode to SHLLV_S_W_MM using decoder 67
1265 // 730: }
1266 // 730: } // switch Inst[10:6]
1267 // 730: }
1268 24, 27, // 734: case 0x18: {
1269 OPC_SwitchField, 6, 5, // 736: switch Inst[10:6] {
1270 0, 6, // 739: case 0x0: {
1271 OPC_CheckPredicate, 1, // 741: check predicate 1
1272 OPC_Decode, 251, 16, 69, // 743: decode to MOVN_I_MM using decoder 69
1273 // 743: }
1274 1, 6, // 747: case 0x1: {
1275 OPC_CheckPredicate, 1, // 749: check predicate 1
1276 OPC_Decode, 143, 17, 69, // 751: decode to MOVZ_I_MM using decoder 69
1277 // 751: }
1278 4, 0, // 755: case 0x4: {
1279 OPC_CheckPredicate, 2, // 757: check predicate 2
1280 OPC_Decode, 207, 15, 70, // 759: decode to LWXS_MM using decoder 70
1281 // 759: }
1282 // 759: } // switch Inst[10:6]
1283 // 759: }
1284 29, 14, // 763: case 0x1d: {
1285 OPC_CheckPredicate, 9, // 765: check predicate 9
1286 OPC_CheckField, 22, 4, 0, // 767: check Inst[25:22] == 0x0
1287 OPC_CheckField, 6, 8, 0, // 771: check Inst[13:6] == 0x0
1288 OPC_Decode, 129, 20, 71, // 775: decode to SHILO_MM using decoder 71
1289 // 775: }
1290 37, 43, // 779: case 0x25: {
1291 OPC_SwitchField, 6, 5, // 781: switch Inst[10:6] {
1292 0, 6, // 784: case 0x0: {
1293 OPC_CheckPredicate, 9, // 786: check predicate 9
1294 OPC_Decode, 215, 17, 60, // 788: decode to MULEQ_S_W_PHL_MM using decoder 60
1295 // 788: }
1296 1, 6, // 792: case 0x1: {
1297 OPC_CheckPredicate, 9, // 794: check predicate 9
1298 OPC_Decode, 217, 17, 60, // 796: decode to MULEQ_S_W_PHR_MM using decoder 60
1299 // 796: }
1300 5, 6, // 800: case 0x5: {
1301 OPC_CheckPredicate, 9, // 802: check predicate 9
1302 OPC_Decode, 142, 15, 70, // 804: decode to LHX_MM using decoder 70
1303 // 804: }
1304 6, 6, // 808: case 0x6: {
1305 OPC_CheckPredicate, 9, // 810: check predicate 9
1306 OPC_Decode, 208, 15, 70, // 812: decode to LWX_MM using decoder 70
1307 // 812: }
1308 8, 0, // 816: case 0x8: {
1309 OPC_CheckPredicate, 9, // 818: check predicate 9
1310 OPC_Decode, 229, 14, 70, // 820: decode to LBUX_MM using decoder 70
1311 // 820: }
1312 // 820: } // switch Inst[10:6]
1313 // 820: }
1314 44, 6, // 824: case 0x2c: {
1315 OPC_CheckPredicate, 1, // 826: check predicate 1
1316 OPC_Decode, 207, 12, 72, // 828: decode to EXT_MM using decoder 72
1317 // 828: }
1318 45, 83, // 832: case 0x2d: {
1319 OPC_SwitchField, 6, 5, // 834: switch Inst[10:6] {
1320 0, 6, // 837: case 0x0: {
1321 OPC_CheckPredicate, 10, // 839: check predicate 10
1322 OPC_Decode, 254, 17, 64, // 841: decode to MUL_PH_MMR2 using decoder 64
1323 // 841: }
1324 1, 6, // 845: case 0x1: {
1325 OPC_CheckPredicate, 10, // 847: check predicate 10
1326 OPC_Decode, 231, 18, 64, // 849: decode to PRECR_QB_PH_MMR2 using decoder 64
1327 // 849: }
1328 2, 6, // 853: case 0x2: {
1329 OPC_CheckPredicate, 9, // 855: check predicate 9
1330 OPC_Decode, 227, 18, 64, // 857: decode to PRECRQ_QB_PH_MM using decoder 64
1331 // 857: }
1332 3, 6, // 861: case 0x3: {
1333 OPC_CheckPredicate, 9, // 863: check predicate 9
1334 OPC_Decode, 225, 18, 73, // 865: decode to PRECRQ_PH_W_MM using decoder 73
1335 // 865: }
1336 4, 6, // 869: case 0x4: {
1337 OPC_CheckPredicate, 9, // 871: check predicate 9
1338 OPC_Decode, 229, 18, 73, // 873: decode to PRECRQ_RS_PH_W_MM using decoder 73
1339 // 873: }
1340 5, 6, // 877: case 0x5: {
1341 OPC_CheckPredicate, 9, // 879: check predicate 9
1342 OPC_Decode, 223, 18, 64, // 881: decode to PRECRQU_S_QB_PH_MM using decoder 64
1343 // 881: }
1344 6, 6, // 885: case 0x6: {
1345 OPC_CheckPredicate, 9, // 887: check predicate 9
1346 OPC_Decode, 179, 18, 64, // 889: decode to PACKRL_PH_MM using decoder 64
1347 // 889: }
1348 7, 6, // 893: case 0x7: {
1349 OPC_CheckPredicate, 9, // 895: check predicate 9
1350 OPC_Decode, 198, 18, 64, // 897: decode to PICK_QB_MM using decoder 64
1351 // 897: }
1352 8, 6, // 901: case 0x8: {
1353 OPC_CheckPredicate, 9, // 903: check predicate 9
1354 OPC_Decode, 196, 18, 64, // 905: decode to PICK_PH_MM using decoder 64
1355 // 905: }
1356 16, 0, // 909: case 0x10: {
1357 OPC_CheckPredicate, 10, // 911: check predicate 10
1358 OPC_Decode, 131, 18, 64, // 913: decode to MUL_S_PH_MMR2 using decoder 64
1359 // 913: }
1360 // 913: } // switch Inst[10:6]
1361 // 913: }
1362 52, 27, // 917: case 0x34: {
1363 OPC_SwitchField, 6, 5, // 919: switch Inst[10:6] {
1364 19, 10, // 922: case 0x13: {
1365 OPC_CheckPredicate, 11, // 924: check predicate 11
1366 OPC_CheckField, 14, 2, 0, // 926: check Inst[15:14] == 0x0
1367 OPC_Decode, 173, 16, 74, // 930: decode to MFHGC0_MM using decoder 74
1368 // 930: }
1369 27, 0, // 934: case 0x1b: {
1370 OPC_CheckPredicate, 11, // 936: check predicate 11
1371 OPC_CheckField, 14, 2, 0, // 938: check Inst[15:14] == 0x0
1372 OPC_Decode, 189, 17, 75, // 942: decode to MTHGC0_MM using decoder 75
1373 // 942: }
1374 // 942: } // switch Inst[10:6]
1375 // 942: }
1376 53, 64, // 946: case 0x35: {
1377 OPC_SwitchField, 6, 5, // 948: switch Inst[10:6] {
1378 11, 6, // 951: case 0xb: {
1379 OPC_CheckPredicate, 9, // 953: check predicate 9
1380 OPC_Decode, 165, 20, 58, // 955: decode to SHRA_R_W_MM using decoder 58
1381 // 955: }
1382 12, 10, // 959: case 0xc: {
1383 OPC_CheckPredicate, 9, // 961: check predicate 9
1384 OPC_CheckField, 11, 1, 0, // 963: check Inst[11] == 0x0
1385 OPC_Decode, 157, 20, 76, // 967: decode to SHRA_PH_MM using decoder 76
1386 // 967: }
1387 14, 19, // 971: case 0xe: {
1388 OPC_SwitchField, 11, 1, // 973: switch Inst[11] {
1389 0, 6, // 976: case 0x0: {
1390 OPC_CheckPredicate, 9, // 978: check predicate 9
1391 OPC_Decode, 139, 20, 76, // 980: decode to SHLL_PH_MM using decoder 76
1392 // 980: }
1393 1, 0, // 984: case 0x1: {
1394 OPC_CheckPredicate, 9, // 986: check predicate 9
1395 OPC_Decode, 143, 20, 76, // 988: decode to SHLL_S_PH_MM using decoder 76
1396 // 988: }
1397 // 988: } // switch Inst[11]
1398 // 988: }
1399 15, 6, // 992: case 0xf: {
1400 OPC_CheckPredicate, 9, // 994: check predicate 9
1401 OPC_Decode, 145, 20, 58, // 996: decode to SHLL_S_W_MM using decoder 58
1402 // 996: }
1403 28, 0, // 1000: case 0x1c: {
1404 OPC_CheckPredicate, 9, // 1002: check predicate 9
1405 OPC_CheckField, 11, 1, 0, // 1004: check Inst[11] == 0x0
1406 OPC_Decode, 161, 20, 76, // 1008: decode to SHRA_R_PH_MM using decoder 76
1407 // 1008: }
1408 // 1008: } // switch Inst[10:6]
1409 // 1008: }
1410 60, 165, 9, // 1012: case 0x3c: {
1411 OPC_SwitchField, 6, 5, // 1015: switch Inst[10:6] {
1412 0, 19, // 1018: case 0x0: {
1413 OPC_SwitchField, 11, 1, // 1020: switch Inst[11] {
1414 0, 6, // 1023: case 0x0: {
1415 OPC_CheckPredicate, 2, // 1025: check predicate 2
1416 OPC_Decode, 145, 22, 77, // 1027: decode to TEQ_MM using decoder 77
1417 // 1027: }
1418 1, 0, // 1031: case 0x1: {
1419 OPC_CheckPredicate, 2, // 1033: check predicate 2
1420 OPC_Decode, 184, 22, 77, // 1035: decode to TLT_MM using decoder 77
1421 // 1035: }
1422 // 1035: } // switch Inst[11]
1423 // 1035: }
1424 1, 77, // 1039: case 0x1: {
1425 OPC_SwitchField, 11, 2, // 1041: switch Inst[12:11] {
1426 0, 27, // 1044: case 0x0: {
1427 OPC_SwitchField, 13, 1, // 1046: switch Inst[13] {
1428 0, 10, // 1049: case 0x0: {
1429 OPC_CheckPredicate, 9, // 1051: check predicate 9
1430 OPC_CheckField, 21, 5, 0, // 1053: check Inst[25:21] == 0x0
1431 OPC_Decode, 178, 16, 78, // 1057: decode to MFHI_DSP_MM using decoder 78
1432 // 1057: }
1433 1, 0, // 1061: case 0x1: {
1434 OPC_CheckPredicate, 9, // 1063: check predicate 9
1435 OPC_CheckField, 21, 5, 0, // 1065: check Inst[25:21] == 0x0
1436 OPC_Decode, 193, 17, 79, // 1069: decode to MTHI_DSP_MM using decoder 79
1437 // 1069: }
1438 // 1069: } // switch Inst[13]
1439 // 1069: }
1440 1, 6, // 1073: case 0x1: {
1441 OPC_CheckPredicate, 9, // 1075: check predicate 9
1442 OPC_Decode, 141, 20, 80, // 1077: decode to SHLL_QB_MM using decoder 80
1443 // 1077: }
1444 2, 27, // 1081: case 0x2: {
1445 OPC_SwitchField, 13, 1, // 1083: switch Inst[13] {
1446 0, 10, // 1086: case 0x0: {
1447 OPC_CheckPredicate, 9, // 1088: check predicate 9
1448 OPC_CheckField, 21, 5, 0, // 1090: check Inst[25:21] == 0x0
1449 OPC_Decode, 184, 16, 78, // 1094: decode to MFLO_DSP_MM using decoder 78
1450 // 1094: }
1451 1, 0, // 1098: case 0x1: {
1452 OPC_CheckPredicate, 9, // 1100: check predicate 9
1453 OPC_CheckField, 21, 5, 0, // 1102: check Inst[25:21] == 0x0
1454 OPC_Decode, 200, 17, 81, // 1106: decode to MTLO_DSP_MM using decoder 81
1455 // 1106: }
1456 // 1106: } // switch Inst[13]
1457 // 1106: }
1458 3, 0, // 1110: case 0x3: {
1459 OPC_CheckPredicate, 9, // 1112: check predicate 9
1460 OPC_Decode, 173, 20, 80, // 1114: decode to SHRL_QB_MM using decoder 80
1461 // 1114: }
1462 // 1114: } // switch Inst[12:11]
1463 // 1114: }
1464 2, 59, // 1118: case 0x2: {
1465 OPC_SwitchField, 11, 3, // 1120: switch Inst[13:11] {
1466 0, 6, // 1123: case 0x0: {
1467 OPC_CheckPredicate, 10, // 1125: check predicate 10
1468 OPC_Decode, 245, 11, 82, // 1127: decode to DPA_W_PH_MMR2 using decoder 82
1469 // 1127: }
1470 1, 6, // 1131: case 0x1: {
1471 OPC_CheckPredicate, 10, // 1133: check predicate 10
1472 OPC_Decode, 157, 7, 83, // 1135: decode to BALIGN_MMR2 using decoder 83
1473 // 1135: }
1474 2, 6, // 1139: case 0x2: {
1475 OPC_CheckPredicate, 10, // 1141: check predicate 10
1476 OPC_Decode, 243, 11, 82, // 1143: decode to DPAX_W_PH_MMR2 using decoder 82
1477 // 1143: }
1478 4, 6, // 1147: case 0x4: {
1479 OPC_CheckPredicate, 9, // 1149: check predicate 9
1480 OPC_Decode, 239, 11, 82, // 1151: decode to DPAU_H_QBL_MM using decoder 82
1481 // 1151: }
1482 5, 6, // 1155: case 0x5: {
1483 OPC_CheckPredicate, 9, // 1157: check predicate 9
1484 OPC_Decode, 187, 12, 84, // 1159: decode to EXTPV_MM using decoder 84
1485 // 1159: }
1486 6, 6, // 1163: case 0x6: {
1487 OPC_CheckPredicate, 9, // 1165: check predicate 9
1488 OPC_Decode, 241, 11, 82, // 1167: decode to DPAU_H_QBR_MM using decoder 82
1489 // 1167: }
1490 7, 0, // 1171: case 0x7: {
1491 OPC_CheckPredicate, 9, // 1173: check predicate 9
1492 OPC_Decode, 184, 12, 84, // 1175: decode to EXTPDPV_MM using decoder 84
1493 // 1175: }
1494 // 1175: } // switch Inst[13:11]
1495 // 1175: }
1496 4, 99, // 1179: case 0x4: {
1497 OPC_SwitchField, 11, 5, // 1181: switch Inst[15:11] {
1498 0, 6, // 1184: case 0x0: {
1499 OPC_CheckPredicate, 10, // 1186: check predicate 10
1500 OPC_Decode, 144, 6, 85, // 1188: decode to ABSQ_S_QB_MMR2 using decoder 85
1501 // 1188: }
1502 2, 6, // 1192: case 0x2: {
1503 OPC_CheckPredicate, 9, // 1194: check predicate 9
1504 OPC_Decode, 142, 6, 85, // 1196: decode to ABSQ_S_PH_MM using decoder 85
1505 // 1196: }
1506 4, 6, // 1200: case 0x4: {
1507 OPC_CheckPredicate, 9, // 1202: check predicate 9
1508 OPC_Decode, 146, 6, 86, // 1204: decode to ABSQ_S_W_MM using decoder 86
1509 // 1204: }
1510 6, 6, // 1208: case 0x6: {
1511 OPC_CheckPredicate, 9, // 1210: check predicate 9
1512 OPC_Decode, 247, 7, 86, // 1212: decode to BITREV_MM using decoder 86
1513 // 1212: }
1514 8, 6, // 1216: case 0x8: {
1515 OPC_CheckPredicate, 9, // 1218: check predicate 9
1516 OPC_Decode, 178, 14, 87, // 1220: decode to INSV_MM using decoder 87
1517 // 1220: }
1518 10, 6, // 1224: case 0xa: {
1519 OPC_CheckPredicate, 9, // 1226: check predicate 9
1520 OPC_Decode, 211, 18, 88, // 1228: decode to PRECEQ_W_PHL_MM using decoder 88
1521 // 1228: }
1522 12, 6, // 1232: case 0xc: {
1523 OPC_CheckPredicate, 9, // 1234: check predicate 9
1524 OPC_Decode, 213, 18, 88, // 1236: decode to PRECEQ_W_PHR_MM using decoder 88
1525 // 1236: }
1526 14, 6, // 1240: case 0xe: {
1527 OPC_CheckPredicate, 9, // 1242: check predicate 9
1528 OPC_Decode, 205, 18, 85, // 1244: decode to PRECEQU_PH_QBL_MM using decoder 85
1529 // 1244: }
1530 18, 6, // 1248: case 0x12: {
1531 OPC_CheckPredicate, 9, // 1250: check predicate 9
1532 OPC_Decode, 209, 18, 85, // 1252: decode to PRECEQU_PH_QBR_MM using decoder 85
1533 // 1252: }
1534 22, 6, // 1256: case 0x16: {
1535 OPC_CheckPredicate, 9, // 1258: check predicate 9
1536 OPC_Decode, 217, 18, 85, // 1260: decode to PRECEU_PH_QBL_MM using decoder 85
1537 // 1260: }
1538 26, 6, // 1264: case 0x1a: {
1539 OPC_CheckPredicate, 9, // 1266: check predicate 9
1540 OPC_Decode, 221, 18, 85, // 1268: decode to PRECEU_PH_QBR_MM using decoder 85
1541 // 1268: }
1542 30, 0, // 1272: case 0x1e: {
1543 OPC_CheckPredicate, 9, // 1274: check predicate 9
1544 OPC_Decode, 248, 18, 88, // 1276: decode to RADDU_W_QB_MM using decoder 88
1545 // 1276: }
1546 // 1276: } // switch Inst[15:11]
1547 // 1276: }
1548 5, 51, // 1280: case 0x5: {
1549 OPC_SwitchField, 11, 15, // 1282: switch Inst[25:11] {
1550 0, 6, // 1285: case 0x0: {
1551 OPC_CheckPredicate, 11, // 1287: check predicate 11
1552 OPC_Decode, 159, 22, 10, // 1289: decode to TLBGP_MM using decoder 10
1553 // 1289: }
1554 2, 6, // 1293: case 0x2: {
1555 OPC_CheckPredicate, 11, // 1295: check predicate 11
1556 OPC_Decode, 161, 22, 10, // 1297: decode to TLBGR_MM using decoder 10
1557 // 1297: }
1558 4, 6, // 1301: case 0x4: {
1559 OPC_CheckPredicate, 11, // 1303: check predicate 11
1560 OPC_Decode, 163, 22, 10, // 1305: decode to TLBGWI_MM using decoder 10
1561 // 1305: }
1562 6, 6, // 1309: case 0x6: {
1563 OPC_CheckPredicate, 11, // 1311: check predicate 11
1564 OPC_Decode, 165, 22, 10, // 1313: decode to TLBGWR_MM using decoder 10
1565 // 1313: }
1566 8, 6, // 1317: case 0x8: {
1567 OPC_CheckPredicate, 11, // 1319: check predicate 11
1568 OPC_Decode, 157, 22, 10, // 1321: decode to TLBGINV_MM using decoder 10
1569 // 1321: }
1570 10, 0, // 1325: case 0xa: {
1571 OPC_CheckPredicate, 11, // 1327: check predicate 11
1572 OPC_Decode, 156, 22, 10, // 1329: decode to TLBGINVF_MM using decoder 10
1573 // 1329: }
1574 // 1329: } // switch Inst[25:11]
1575 // 1329: }
1576 7, 19, // 1333: case 0x7: {
1577 OPC_SwitchField, 11, 2, // 1335: switch Inst[12:11] {
1578 0, 6, // 1338: case 0x0: {
1579 OPC_CheckPredicate, 10, // 1340: check predicate 10
1580 OPC_Decode, 159, 20, 80, // 1342: decode to SHRA_QB_MMR2 using decoder 80
1581 // 1342: }
1582 2, 0, // 1346: case 0x2: {
1583 OPC_CheckPredicate, 10, // 1348: check predicate 10
1584 OPC_Decode, 163, 20, 80, // 1350: decode to SHRA_R_QB_MMR2 using decoder 80
1585 // 1350: }
1586 // 1350: } // switch Inst[12:11]
1587 // 1350: }
1588 8, 19, // 1354: case 0x8: {
1589 OPC_SwitchField, 11, 1, // 1356: switch Inst[11] {
1590 0, 6, // 1359: case 0x0: {
1591 OPC_CheckPredicate, 2, // 1361: check predicate 2
1592 OPC_Decode, 153, 22, 77, // 1363: decode to TGE_MM using decoder 77
1593 // 1363: }
1594 1, 0, // 1367: case 0x1: {
1595 OPC_CheckPredicate, 2, // 1369: check predicate 2
1596 OPC_Decode, 183, 22, 77, // 1371: decode to TLTU_MM using decoder 77
1597 // 1371: }
1598 // 1371: } // switch Inst[11]
1599 // 1371: }
1600 9, 59, // 1375: case 0x9: {
1601 OPC_SwitchField, 11, 3, // 1377: switch Inst[13:11] {
1602 0, 10, // 1380: case 0x0: {
1603 OPC_CheckPredicate, 9, // 1382: check predicate 9
1604 OPC_CheckField, 21, 5, 0, // 1384: check Inst[25:21] == 0x0
1605 OPC_Decode, 196, 17, 89, // 1388: decode to MTHLIP_MM using decoder 89
1606 // 1388: }
1607 1, 6, // 1392: case 0x1: {
1608 OPC_CheckPredicate, 9, // 1394: check predicate 9
1609 OPC_Decode, 255, 15, 82, // 1396: decode to MAQ_S_W_PHR_MM using decoder 82
1610 // 1396: }
1611 2, 10, // 1400: case 0x2: {
1612 OPC_CheckPredicate, 9, // 1402: check predicate 9
1613 OPC_CheckField, 21, 5, 0, // 1404: check Inst[25:21] == 0x0
1614 OPC_Decode, 128, 20, 89, // 1408: decode to SHILOV_MM using decoder 89
1615 // 1408: }
1616 3, 6, // 1412: case 0x3: {
1617 OPC_CheckPredicate, 9, // 1414: check predicate 9
1618 OPC_Decode, 253, 15, 82, // 1416: decode to MAQ_S_W_PHL_MM using decoder 82
1619 // 1416: }
1620 5, 6, // 1420: case 0x5: {
1621 OPC_CheckPredicate, 9, // 1422: check predicate 9
1622 OPC_Decode, 251, 15, 82, // 1424: decode to MAQ_SA_W_PHR_MM using decoder 82
1623 // 1424: }
1624 7, 0, // 1428: case 0x7: {
1625 OPC_CheckPredicate, 9, // 1430: check predicate 9
1626 OPC_Decode, 249, 15, 82, // 1432: decode to MAQ_SA_W_PHL_MM using decoder 82
1627 // 1432: }
1628 // 1432: } // switch Inst[13:11]
1629 // 1432: }
1630 10, 67, // 1436: case 0xa: {
1631 OPC_SwitchField, 11, 3, // 1438: switch Inst[13:11] {
1632 0, 6, // 1441: case 0x0: {
1633 OPC_CheckPredicate, 9, // 1443: check predicate 9
1634 OPC_Decode, 237, 11, 82, // 1445: decode to DPAQ_S_W_PH_MM using decoder 82
1635 // 1445: }
1636 1, 6, // 1449: case 0x1: {
1637 OPC_CheckPredicate, 9, // 1451: check predicate 9
1638 OPC_Decode, 242, 15, 90, // 1453: decode to MADD_DSP_MM using decoder 90
1639 // 1453: }
1640 2, 6, // 1457: case 0x2: {
1641 OPC_CheckPredicate, 9, // 1459: check predicate 9
1642 OPC_Decode, 235, 11, 82, // 1461: decode to DPAQ_SA_L_W_MM using decoder 82
1643 // 1461: }
1644 3, 6, // 1465: case 0x3: {
1645 OPC_CheckPredicate, 9, // 1467: check predicate 9
1646 OPC_Decode, 232, 15, 90, // 1469: decode to MADDU_DSP_MM using decoder 90
1647 // 1469: }
1648 4, 6, // 1473: case 0x4: {
1649 OPC_CheckPredicate, 10, // 1475: check predicate 10
1650 OPC_Decode, 233, 11, 82, // 1477: decode to DPAQX_S_W_PH_MMR2 using decoder 82
1651 // 1477: }
1652 5, 6, // 1481: case 0x5: {
1653 OPC_CheckPredicate, 9, // 1483: check predicate 9
1654 OPC_Decode, 165, 17, 90, // 1485: decode to MSUB_DSP_MM using decoder 90
1655 // 1485: }
1656 6, 6, // 1489: case 0x6: {
1657 OPC_CheckPredicate, 10, // 1491: check predicate 10
1658 OPC_Decode, 231, 11, 82, // 1493: decode to DPAQX_SA_W_PH_MMR2 using decoder 82
1659 // 1493: }
1660 7, 0, // 1497: case 0x7: {
1661 OPC_CheckPredicate, 9, // 1499: check predicate 9
1662 OPC_Decode, 155, 17, 90, // 1501: decode to MSUBU_DSP_MM using decoder 90
1663 // 1501: }
1664 // 1501: } // switch Inst[13:11]
1665 // 1501: }
1666 12, 163, 1, // 1505: case 0xc: {
1667 OPC_SwitchField, 11, 5, // 1508: switch Inst[15:11] {
1668 0, 6, // 1511: case 0x0: {
1669 OPC_CheckPredicate, 9, // 1513: check predicate 9
1670 OPC_Decode, 135, 19, 91, // 1515: decode to REPLV_PH_MM using decoder 91
1671 // 1515: }
1672 2, 6, // 1519: case 0x2: {
1673 OPC_CheckPredicate, 9, // 1521: check predicate 9
1674 OPC_Decode, 137, 19, 91, // 1523: decode to REPLV_QB_MM using decoder 91
1675 // 1523: }
1676 5, 6, // 1527: case 0x5: {
1677 OPC_CheckPredicate, 2, // 1529: check predicate 2
1678 OPC_Decode, 221, 19, 86, // 1531: decode to SEB_MM using decoder 86
1679 // 1531: }
1680 7, 6, // 1535: case 0x7: {
1681 OPC_CheckPredicate, 2, // 1537: check predicate 2
1682 OPC_Decode, 224, 19, 86, // 1539: decode to SEH_MM using decoder 86
1683 // 1539: }
1684 9, 6, // 1543: case 0x9: {
1685 OPC_CheckPredicate, 2, // 1545: check predicate 2
1686 OPC_Decode, 146, 9, 86, // 1547: decode to CLO_MM using decoder 86
1687 // 1547: }
1688 11, 6, // 1551: case 0xb: {
1689 OPC_CheckPredicate, 2, // 1553: check predicate 2
1690 OPC_Decode, 166, 9, 86, // 1555: decode to CLZ_MM using decoder 86
1691 // 1555: }
1692 13, 6, // 1559: case 0xd: {
1693 OPC_CheckPredicate, 1, // 1561: check predicate 1
1694 OPC_Decode, 253, 18, 92, // 1563: decode to RDHWR_MM using decoder 92
1695 // 1563: }
1696 14, 6, // 1567: case 0xe: {
1697 OPC_CheckPredicate, 9, // 1569: check predicate 9
1698 OPC_Decode, 204, 18, 85, // 1571: decode to PRECEQU_PH_QBLA_MM using decoder 85
1699 // 1571: }
1700 15, 6, // 1575: case 0xf: {
1701 OPC_CheckPredicate, 2, // 1577: check predicate 2
1702 OPC_Decode, 217, 22, 86, // 1579: decode to WSBH_MM using decoder 86
1703 // 1579: }
1704 17, 6, // 1583: case 0x11: {
1705 OPC_CheckPredicate, 1, // 1585: check predicate 1
1706 OPC_Decode, 242, 17, 93, // 1587: decode to MULT_MM using decoder 93
1707 // 1587: }
1708 18, 6, // 1591: case 0x12: {
1709 OPC_CheckPredicate, 9, // 1593: check predicate 9
1710 OPC_Decode, 208, 18, 85, // 1595: decode to PRECEQU_PH_QBRA_MM using decoder 85
1711 // 1595: }
1712 19, 6, // 1599: case 0x13: {
1713 OPC_CheckPredicate, 1, // 1601: check predicate 1
1714 OPC_Decode, 244, 17, 93, // 1603: decode to MULTu_MM using decoder 93
1715 // 1603: }
1716 21, 6, // 1607: case 0x15: {
1717 OPC_CheckPredicate, 1, // 1609: check predicate 1
1718 OPC_Decode, 214, 19, 93, // 1611: decode to SDIV_MM using decoder 93
1719 // 1611: }
1720 22, 6, // 1615: case 0x16: {
1721 OPC_CheckPredicate, 9, // 1617: check predicate 9
1722 OPC_Decode, 216, 18, 85, // 1619: decode to PRECEU_PH_QBLA_MM using decoder 85
1723 // 1619: }
1724 23, 6, // 1623: case 0x17: {
1725 OPC_CheckPredicate, 1, // 1625: check predicate 1
1726 OPC_Decode, 202, 22, 93, // 1627: decode to UDIV_MM using decoder 93
1727 // 1627: }
1728 25, 6, // 1631: case 0x19: {
1729 OPC_CheckPredicate, 1, // 1633: check predicate 1
1730 OPC_Decode, 243, 15, 93, // 1635: decode to MADD_MM using decoder 93
1731 // 1635: }
1732 26, 6, // 1639: case 0x1a: {
1733 OPC_CheckPredicate, 9, // 1641: check predicate 9
1734 OPC_Decode, 220, 18, 85, // 1643: decode to PRECEU_PH_QBRA_MM using decoder 85
1735 // 1643: }
1736 27, 6, // 1647: case 0x1b: {
1737 OPC_CheckPredicate, 1, // 1649: check predicate 1
1738 OPC_Decode, 233, 15, 93, // 1651: decode to MADDU_MM using decoder 93
1739 // 1651: }
1740 29, 6, // 1655: case 0x1d: {
1741 OPC_CheckPredicate, 1, // 1657: check predicate 1
1742 OPC_Decode, 166, 17, 93, // 1659: decode to MSUB_MM using decoder 93
1743 // 1659: }
1744 31, 0, // 1663: case 0x1f: {
1745 OPC_CheckPredicate, 1, // 1665: check predicate 1
1746 OPC_Decode, 156, 17, 93, // 1667: decode to MSUBU_MM using decoder 93
1747 // 1667: }
1748 // 1667: } // switch Inst[15:11]
1749 // 1667: }
1750 13, 119, // 1671: case 0xd: {
1751 OPC_SwitchField, 11, 5, // 1673: switch Inst[15:11] {
1752 0, 10, // 1676: case 0x0: {
1753 OPC_CheckPredicate, 2, // 1678: check predicate 2
1754 OPC_CheckField, 16, 10, 0, // 1680: check Inst[25:16] == 0x0
1755 OPC_Decode, 171, 22, 10, // 1684: decode to TLBP_MM using decoder 10
1756 // 1684: }
1757 2, 10, // 1688: case 0x2: {
1758 OPC_CheckPredicate, 2, // 1690: check predicate 2
1759 OPC_CheckField, 16, 10, 0, // 1692: check Inst[25:16] == 0x0
1760 OPC_Decode, 173, 22, 10, // 1696: decode to TLBR_MM using decoder 10
1761 // 1696: }
1762 4, 10, // 1700: case 0x4: {
1763 OPC_CheckPredicate, 2, // 1702: check predicate 2
1764 OPC_CheckField, 16, 10, 0, // 1704: check Inst[25:16] == 0x0
1765 OPC_Decode, 175, 22, 10, // 1708: decode to TLBWI_MM using decoder 10
1766 // 1708: }
1767 6, 10, // 1712: case 0x6: {
1768 OPC_CheckPredicate, 2, // 1714: check predicate 2
1769 OPC_CheckField, 16, 10, 0, // 1716: check Inst[25:16] == 0x0
1770 OPC_Decode, 177, 22, 10, // 1720: decode to TLBWR_MM using decoder 10
1771 // 1720: }
1772 13, 10, // 1724: case 0xd: {
1773 OPC_CheckPredicate, 2, // 1726: check predicate 2
1774 OPC_CheckField, 21, 5, 0, // 1728: check Inst[25:21] == 0x0
1775 OPC_Decode, 245, 21, 94, // 1732: decode to SYNC_MM using decoder 94
1776 // 1732: }
1777 17, 6, // 1736: case 0x11: {
1778 OPC_CheckPredicate, 2, // 1738: check predicate 2
1779 OPC_Decode, 248, 21, 95, // 1740: decode to SYSCALL_MM using decoder 95
1780 // 1740: }
1781 18, 6, // 1744: case 0x12: {
1782 OPC_CheckPredicate, 2, // 1746: check predicate 2
1783 OPC_Decode, 211, 22, 95, // 1748: decode to WAIT_MM using decoder 95
1784 // 1748: }
1785 24, 6, // 1752: case 0x18: {
1786 OPC_CheckPredicate, 11, // 1754: check predicate 11
1787 OPC_Decode, 151, 14, 95, // 1756: decode to HYPCALL_MM using decoder 95
1788 // 1756: }
1789 27, 6, // 1760: case 0x1b: {
1790 OPC_CheckPredicate, 2, // 1762: check predicate 2
1791 OPC_Decode, 201, 19, 95, // 1764: decode to SDBBP_MM using decoder 95
1792 // 1764: }
1793 28, 10, // 1768: case 0x1c: {
1794 OPC_CheckPredicate, 2, // 1770: check predicate 2
1795 OPC_CheckField, 16, 10, 0, // 1772: check Inst[25:16] == 0x0
1796 OPC_Decode, 172, 11, 10, // 1776: decode to DERET_MM using decoder 10
1797 // 1776: }
1798 30, 0, // 1780: case 0x1e: {
1799 OPC_CheckPredicate, 2, // 1782: check predicate 2
1800 OPC_CheckField, 16, 10, 0, // 1784: check Inst[25:16] == 0x0
1801 OPC_Decode, 175, 12, 10, // 1788: decode to ERET_MM using decoder 10
1802 // 1788: }
1803 // 1788: } // switch Inst[15:11]
1804 // 1788: }
1805 15, 10, // 1792: case 0xf: {
1806 OPC_CheckPredicate, 10, // 1794: check predicate 10
1807 OPC_CheckField, 11, 1, 0, // 1796: check Inst[11] == 0x0
1808 OPC_Decode, 171, 20, 76, // 1800: decode to SHRL_PH_MMR2 using decoder 76
1809 // 1800: }
1810 16, 19, // 1804: case 0x10: {
1811 OPC_SwitchField, 11, 1, // 1806: switch Inst[11] {
1812 0, 6, // 1809: case 0x0: {
1813 OPC_CheckPredicate, 2, // 1811: check predicate 2
1814 OPC_Decode, 152, 22, 77, // 1813: decode to TGEU_MM using decoder 77
1815 // 1813: }
1816 1, 0, // 1817: case 0x1: {
1817 OPC_CheckPredicate, 2, // 1819: check predicate 2
1818 OPC_Decode, 188, 22, 77, // 1821: decode to TNE_MM using decoder 77
1819 // 1821: }
1820 // 1821: } // switch Inst[11]
1821 // 1821: }
1822 18, 67, // 1825: case 0x12: {
1823 OPC_SwitchField, 11, 3, // 1827: switch Inst[13:11] {
1824 0, 6, // 1830: case 0x0: {
1825 OPC_CheckPredicate, 10, // 1832: check predicate 10
1826 OPC_Decode, 140, 12, 82, // 1834: decode to DPS_W_PH_MMR2 using decoder 82
1827 // 1834: }
1828 1, 6, // 1838: case 0x1: {
1829 OPC_CheckPredicate, 9, // 1840: check predicate 9
1830 OPC_Decode, 241, 17, 96, // 1842: decode to MULT_DSP_MM using decoder 96
1831 // 1842: }
1832 2, 6, // 1846: case 0x2: {
1833 OPC_CheckPredicate, 10, // 1848: check predicate 10
1834 OPC_Decode, 138, 12, 82, // 1850: decode to DPSX_W_PH_MMR2 using decoder 82
1835 // 1850: }
1836 3, 6, // 1854: case 0x3: {
1837 OPC_CheckPredicate, 9, // 1856: check predicate 9
1838 OPC_Decode, 239, 17, 96, // 1858: decode to MULTU_DSP_MM using decoder 96
1839 // 1858: }
1840 4, 6, // 1862: case 0x4: {
1841 OPC_CheckPredicate, 9, // 1864: check predicate 9
1842 OPC_Decode, 134, 12, 82, // 1866: decode to DPSU_H_QBL_MM using decoder 82
1843 // 1866: }
1844 5, 6, // 1870: case 0x5: {
1845 OPC_CheckPredicate, 10, // 1872: check predicate 10
1846 OPC_Decode, 236, 17, 82, // 1874: decode to MULSA_W_PH_MMR2 using decoder 82
1847 // 1874: }
1848 6, 6, // 1878: case 0x6: {
1849 OPC_CheckPredicate, 9, // 1880: check predicate 9
1850 OPC_Decode, 136, 12, 82, // 1882: decode to DPSU_H_QBR_MM using decoder 82
1851 // 1882: }
1852 7, 0, // 1886: case 0x7: {
1853 OPC_CheckPredicate, 9, // 1888: check predicate 9
1854 OPC_Decode, 234, 17, 82, // 1890: decode to MULSAQ_S_W_PH_MM using decoder 82
1855 // 1890: }
1856 // 1890: } // switch Inst[13:11]
1857 // 1890: }
1858 19, 10, // 1894: case 0x13: {
1859 OPC_CheckPredicate, 11, // 1896: check predicate 11
1860 OPC_CheckField, 14, 2, 0, // 1898: check Inst[15:14] == 0x0
1861 OPC_Decode, 165, 16, 74, // 1902: decode to MFGC0_MM using decoder 74
1862 // 1902: }
1863 20, 19, // 1906: case 0x14: {
1864 OPC_SwitchField, 11, 5, // 1908: switch Inst[15:11] {
1865 25, 6, // 1911: case 0x19: {
1866 OPC_CheckPredicate, 2, // 1913: check predicate 2
1867 OPC_Decode, 247, 8, 97, // 1915: decode to CFC2_MM using decoder 97
1868 // 1915: }
1869 27, 0, // 1919: case 0x1b: {
1870 OPC_CheckPredicate, 2, // 1921: check predicate 2
1871 OPC_Decode, 146, 10, 98, // 1923: decode to CTC2_MM using decoder 98
1872 // 1923: }
1873 // 1923: } // switch Inst[15:11]
1874 // 1923: }
1875 21, 51, // 1927: case 0x15: {
1876 OPC_SwitchField, 11, 5, // 1929: switch Inst[15:11] {
1877 1, 10, // 1932: case 0x1: {
1878 OPC_CheckPredicate, 1, // 1934: check predicate 1
1879 OPC_CheckField, 21, 5, 0, // 1936: check Inst[25:21] == 0x0
1880 OPC_Decode, 179, 16, 99, // 1940: decode to MFHI_MM using decoder 99
1881 // 1940: }
1882 3, 10, // 1944: case 0x3: {
1883 OPC_CheckPredicate, 1, // 1946: check predicate 1
1884 OPC_CheckField, 21, 5, 0, // 1948: check Inst[25:21] == 0x0
1885 OPC_Decode, 185, 16, 99, // 1952: decode to MFLO_MM using decoder 99
1886 // 1952: }
1887 5, 10, // 1956: case 0x5: {
1888 OPC_CheckPredicate, 1, // 1958: check predicate 1
1889 OPC_CheckField, 21, 5, 0, // 1960: check Inst[25:21] == 0x0
1890 OPC_Decode, 194, 17, 99, // 1964: decode to MTHI_MM using decoder 99
1891 // 1964: }
1892 7, 0, // 1968: case 0x7: {
1893 OPC_CheckPredicate, 1, // 1970: check predicate 1
1894 OPC_CheckField, 21, 5, 0, // 1972: check Inst[25:21] == 0x0
1895 OPC_Decode, 201, 17, 99, // 1976: decode to MTLO_MM using decoder 99
1896 // 1976: }
1897 // 1976: } // switch Inst[15:11]
1898 // 1976: }
1899 23, 10, // 1980: case 0x17: {
1900 OPC_CheckPredicate, 9, // 1982: check predicate 9
1901 OPC_CheckField, 11, 2, 0, // 1984: check Inst[12:11] == 0x0
1902 OPC_Decode, 141, 19, 100, // 1988: decode to REPL_QB_MM using decoder 100
1903 // 1988: }
1904 25, 67, // 1992: case 0x19: {
1905 OPC_SwitchField, 11, 3, // 1994: switch Inst[13:11] {
1906 0, 6, // 1997: case 0x0: {
1907 OPC_CheckPredicate, 9, // 1999: check predicate 9
1908 OPC_Decode, 250, 18, 101, // 2001: decode to RDDSP_MM using decoder 101
1909 // 2001: }
1910 1, 6, // 2005: case 0x1: {
1911 OPC_CheckPredicate, 9, // 2007: check predicate 9
1912 OPC_Decode, 204, 12, 102, // 2009: decode to EXTR_W_MM using decoder 102
1913 // 2009: }
1914 2, 6, // 2013: case 0x2: {
1915 OPC_CheckPredicate, 9, // 2015: check predicate 9
1916 OPC_Decode, 214, 22, 101, // 2017: decode to WRDSP_MM using decoder 101
1917 // 2017: }
1918 3, 6, // 2021: case 0x3: {
1919 OPC_CheckPredicate, 9, // 2023: check predicate 9
1920 OPC_Decode, 200, 12, 102, // 2025: decode to EXTR_R_W_MM using decoder 102
1921 // 2025: }
1922 4, 6, // 2029: case 0x4: {
1923 OPC_CheckPredicate, 9, // 2031: check predicate 9
1924 OPC_Decode, 188, 12, 102, // 2033: decode to EXTP_MM using decoder 102
1925 // 2033: }
1926 5, 6, // 2037: case 0x5: {
1927 OPC_CheckPredicate, 9, // 2039: check predicate 9
1928 OPC_Decode, 198, 12, 102, // 2041: decode to EXTR_RS_W_MM using decoder 102
1929 // 2041: }
1930 6, 6, // 2045: case 0x6: {
1931 OPC_CheckPredicate, 9, // 2047: check predicate 9
1932 OPC_Decode, 185, 12, 102, // 2049: decode to EXTPDP_MM using decoder 102
1933 // 2049: }
1934 7, 0, // 2053: case 0x7: {
1935 OPC_CheckPredicate, 9, // 2055: check predicate 9
1936 OPC_Decode, 202, 12, 102, // 2057: decode to EXTR_S_H_MM using decoder 102
1937 // 2057: }
1938 // 2057: } // switch Inst[13:11]
1939 // 2057: }
1940 26, 67, // 2061: case 0x1a: {
1941 OPC_SwitchField, 11, 3, // 2063: switch Inst[13:11] {
1942 0, 6, // 2066: case 0x0: {
1943 OPC_CheckPredicate, 9, // 2068: check predicate 9
1944 OPC_Decode, 254, 11, 82, // 2070: decode to DPSQ_S_W_PH_MM using decoder 82
1945 // 2070: }
1946 1, 6, // 2074: case 0x1: {
1947 OPC_CheckPredicate, 9, // 2076: check predicate 9
1948 OPC_Decode, 196, 12, 84, // 2078: decode to EXTRV_W_MM using decoder 84
1949 // 2078: }
1950 2, 6, // 2082: case 0x2: {
1951 OPC_CheckPredicate, 9, // 2084: check predicate 9
1952 OPC_Decode, 252, 11, 82, // 2086: decode to DPSQ_SA_L_W_MM using decoder 82
1953 // 2086: }
1954 3, 6, // 2090: case 0x3: {
1955 OPC_CheckPredicate, 9, // 2092: check predicate 9
1956 OPC_Decode, 192, 12, 84, // 2094: decode to EXTRV_R_W_MM using decoder 84
1957 // 2094: }
1958 4, 6, // 2098: case 0x4: {
1959 OPC_CheckPredicate, 10, // 2100: check predicate 10
1960 OPC_Decode, 250, 11, 82, // 2102: decode to DPSQX_S_W_PH_MMR2 using decoder 82
1961 // 2102: }
1962 5, 6, // 2106: case 0x5: {
1963 OPC_CheckPredicate, 9, // 2108: check predicate 9
1964 OPC_Decode, 190, 12, 84, // 2110: decode to EXTRV_RS_W_MM using decoder 84
1965 // 2110: }
1966 6, 6, // 2114: case 0x6: {
1967 OPC_CheckPredicate, 10, // 2116: check predicate 10
1968 OPC_Decode, 248, 11, 82, // 2118: decode to DPSQX_SA_W_PH_MMR2 using decoder 82
1969 // 2118: }
1970 7, 0, // 2122: case 0x7: {
1971 OPC_CheckPredicate, 9, // 2124: check predicate 9
1972 OPC_Decode, 194, 12, 84, // 2126: decode to EXTRV_S_H_MM using decoder 84
1973 // 2126: }
1974 // 2126: } // switch Inst[13:11]
1975 // 2126: }
1976 27, 10, // 2130: case 0x1b: {
1977 OPC_CheckPredicate, 11, // 2132: check predicate 11
1978 OPC_CheckField, 14, 2, 0, // 2134: check Inst[15:14] == 0x0
1979 OPC_Decode, 181, 17, 75, // 2138: decode to MTGC0_MM using decoder 75
1980 // 2138: }
1981 28, 31, // 2142: case 0x1c: {
1982 OPC_SwitchField, 11, 5, // 2144: switch Inst[15:11] {
1983 1, 18, // 2147: case 0x1: {
1984 OPC_Scope, 10, // 2149: try {
1985 OPC_CheckField, 21, 5, 0, // 2151: check Inst[25:21] == 0x0
1986 OPC_CheckPredicate, 1, // 2155: check predicate 1
1987 OPC_Decode, 215, 14, 99, // 2157: decode to JR_MM using decoder 99
1988 // 2157: } else try {
1989 OPC_CheckPredicate, 1, // 2161: check predicate 1
1990 OPC_Decode, 193, 14, 86, // 2163: decode to JALR_MM using decoder 86
1991 // 2163: }
1992 // 2163: }
1993 9, 0, // 2167: case 0x9: {
1994 OPC_CheckPredicate, 1, // 2169: check predicate 1
1995 OPC_Decode, 190, 14, 86, // 2171: decode to JALRS_MM using decoder 86
1996 // 2171: }
1997 // 2171: } // switch Inst[15:11]
1998 // 2171: }
1999 29, 0, // 2175: case 0x1d: {
2000 OPC_SwitchField, 11, 5, // 2177: switch Inst[15:11] {
2001 8, 10, // 2180: case 0x8: {
2002 OPC_CheckPredicate, 2, // 2182: check predicate 2
2003 OPC_CheckField, 21, 5, 0, // 2184: check Inst[25:21] == 0x0
2004 OPC_Decode, 194, 11, 99, // 2188: decode to DI_MM using decoder 99
2005 // 2188: }
2006 10, 0, // 2192: case 0xa: {
2007 OPC_CheckPredicate, 2, // 2194: check predicate 2
2008 OPC_CheckField, 21, 5, 0, // 2196: check Inst[25:21] == 0x0
2009 OPC_Decode, 169, 12, 99, // 2200: decode to EI_MM using decoder 99
2010 // 2200: }
2011 // 2200: } // switch Inst[15:11]
2012 // 2200: }
2013 // 2200: } // switch Inst[10:6]
2014 // 2200: }
2015 61, 0, // 2204: case 0x3d: {
2016 OPC_CheckPredicate, 9, // 2206: check predicate 9
2017 OPC_CheckField, 6, 5, 0, // 2208: check Inst[10:6] == 0x0
2018 OPC_Decode, 139, 19, 103, // 2212: decode to REPL_PH_MM using decoder 103
2019 // 2212: }
2020 // 2212: } // switch Inst[5:0]
2021 // 2212: }
2022 4, 6, // 2216: case 0x4: {
2023 OPC_CheckPredicate, 1, // 2218: check predicate 1
2024 OPC_Decode, 217, 6, 104, // 2220: decode to ADDi_MM using decoder 104
2025 // 2220: }
2026 5, 6, // 2224: case 0x5: {
2027 OPC_CheckPredicate, 2, // 2226: check predicate 2
2028 OPC_Decode, 237, 14, 105, // 2228: decode to LBu_MM using decoder 105
2029 // 2228: }
2030 6, 6, // 2232: case 0x6: {
2031 OPC_CheckPredicate, 2, // 2234: check predicate 2
2032 OPC_Decode, 185, 19, 105, // 2236: decode to SB_MM using decoder 105
2033 // 2236: }
2034 7, 6, // 2240: case 0x7: {
2035 OPC_CheckPredicate, 2, // 2242: check predicate 2
2036 OPC_Decode, 231, 14, 105, // 2244: decode to LB_MM using decoder 105
2037 // 2244: }
2038 8, 43, // 2248: case 0x8: {
2039 OPC_SwitchField, 12, 4, // 2250: switch Inst[15:12] {
2040 1, 6, // 2253: case 0x1: {
2041 OPC_CheckPredicate, 2, // 2255: check predicate 2
2042 OPC_Decode, 195, 15, 106, // 2257: decode to LWP_MM using decoder 106
2043 // 2257: }
2044 5, 6, // 2261: case 0x5: {
2045 OPC_CheckPredicate, 2, // 2263: check predicate 2
2046 OPC_Decode, 192, 15, 106, // 2265: decode to LWM32_MM using decoder 106
2047 // 2265: }
2048 6, 6, // 2269: case 0x6: {
2049 OPC_CheckPredicate, 1, // 2271: check predicate 1
2050 OPC_Decode, 223, 8, 107, // 2273: decode to CACHE_MM using decoder 107
2051 // 2273: }
2052 9, 6, // 2277: case 0x9: {
2053 OPC_CheckPredicate, 2, // 2279: check predicate 2
2054 OPC_Decode, 229, 21, 106, // 2281: decode to SWP_MM using decoder 106
2055 // 2281: }
2056 13, 0, // 2285: case 0xd: {
2057 OPC_CheckPredicate, 2, // 2287: check predicate 2
2058 OPC_Decode, 228, 21, 106, // 2289: decode to SWM32_MM using decoder 106
2059 // 2289: }
2060 // 2289: } // switch Inst[15:12]
2061 // 2289: }
2062 12, 6, // 2293: case 0xc: {
2063 OPC_CheckPredicate, 1, // 2295: check predicate 1
2064 OPC_Decode, 219, 6, 104, // 2297: decode to ADDiu_MM using decoder 104
2065 // 2297: }
2066 13, 6, // 2301: case 0xd: {
2067 OPC_CheckPredicate, 2, // 2303: check predicate 2
2068 OPC_Decode, 148, 15, 105, // 2305: decode to LHu_MM using decoder 105
2069 // 2305: }
2070 14, 6, // 2309: case 0xe: {
2071 OPC_CheckPredicate, 2, // 2311: check predicate 2
2072 OPC_Decode, 174, 20, 105, // 2313: decode to SH_MM using decoder 105
2073 // 2313: }
2074 15, 6, // 2317: case 0xf: {
2075 OPC_CheckPredicate, 2, // 2319: check predicate 2
2076 OPC_Decode, 143, 15, 105, // 2321: decode to LH_MM using decoder 105
2077 // 2321: }
2078 16, 195, 1, // 2325: case 0x10: {
2079 OPC_SwitchField, 21, 5, // 2328: switch Inst[25:21] {
2080 0, 6, // 2331: case 0x0: {
2081 OPC_CheckPredicate, 1, // 2333: check predicate 1
2082 OPC_Decode, 149, 8, 108, // 2335: decode to BLTZ_MM using decoder 108
2083 // 2335: }
2084 1, 6, // 2339: case 0x1: {
2085 OPC_CheckPredicate, 1, // 2341: check predicate 1
2086 OPC_Decode, 144, 8, 108, // 2343: decode to BLTZAL_MM using decoder 108
2087 // 2343: }
2088 2, 6, // 2347: case 0x2: {
2089 OPC_CheckPredicate, 1, // 2349: check predicate 1
2090 OPC_Decode, 220, 7, 108, // 2351: decode to BGEZ_MM using decoder 108
2091 // 2351: }
2092 3, 6, // 2355: case 0x3: {
2093 OPC_CheckPredicate, 1, // 2357: check predicate 1
2094 OPC_Decode, 215, 7, 108, // 2359: decode to BGEZAL_MM using decoder 108
2095 // 2359: }
2096 4, 6, // 2363: case 0x4: {
2097 OPC_CheckPredicate, 1, // 2365: check predicate 1
2098 OPC_Decode, 130, 8, 108, // 2367: decode to BLEZ_MM using decoder 108
2099 // 2367: }
2100 5, 6, // 2371: case 0x5: {
2101 OPC_CheckPredicate, 1, // 2373: check predicate 1
2102 OPC_Decode, 174, 8, 108, // 2375: decode to BNEZC_MM using decoder 108
2103 // 2375: }
2104 6, 6, // 2379: case 0x6: {
2105 OPC_CheckPredicate, 1, // 2381: check predicate 1
2106 OPC_Decode, 229, 7, 108, // 2383: decode to BGTZ_MM using decoder 108
2107 // 2383: }
2108 7, 6, // 2387: case 0x7: {
2109 OPC_CheckPredicate, 1, // 2389: check predicate 1
2110 OPC_Decode, 199, 7, 108, // 2391: decode to BEQZC_MM using decoder 108
2111 // 2391: }
2112 8, 6, // 2395: case 0x8: {
2113 OPC_CheckPredicate, 1, // 2397: check predicate 1
2114 OPC_Decode, 181, 22, 109, // 2399: decode to TLTI_MM using decoder 109
2115 // 2399: }
2116 9, 6, // 2403: case 0x9: {
2117 OPC_CheckPredicate, 1, // 2405: check predicate 1
2118 OPC_Decode, 150, 22, 109, // 2407: decode to TGEI_MM using decoder 109
2119 // 2407: }
2120 10, 6, // 2411: case 0xa: {
2121 OPC_CheckPredicate, 1, // 2413: check predicate 1
2122 OPC_Decode, 180, 22, 109, // 2415: decode to TLTIU_MM using decoder 109
2123 // 2415: }
2124 11, 6, // 2419: case 0xb: {
2125 OPC_CheckPredicate, 1, // 2421: check predicate 1
2126 OPC_Decode, 149, 22, 109, // 2423: decode to TGEIU_MM using decoder 109
2127 // 2423: }
2128 12, 6, // 2427: case 0xc: {
2129 OPC_CheckPredicate, 1, // 2429: check predicate 1
2130 OPC_Decode, 187, 22, 109, // 2431: decode to TNEI_MM using decoder 109
2131 // 2431: }
2132 13, 6, // 2435: case 0xd: {
2133 OPC_CheckPredicate, 1, // 2437: check predicate 1
2134 OPC_Decode, 170, 15, 110, // 2439: decode to LUi_MM using decoder 110
2135 // 2439: }
2136 14, 6, // 2443: case 0xe: {
2137 OPC_CheckPredicate, 1, // 2445: check predicate 1
2138 OPC_Decode, 144, 22, 109, // 2447: decode to TEQI_MM using decoder 109
2139 // 2447: }
2140 16, 6, // 2451: case 0x10: {
2141 OPC_CheckPredicate, 1, // 2453: check predicate 1
2142 OPC_Decode, 243, 21, 111, // 2455: decode to SYNCI_MM using decoder 111
2143 // 2455: }
2144 17, 6, // 2459: case 0x11: {
2145 OPC_CheckPredicate, 1, // 2461: check predicate 1
2146 OPC_Decode, 143, 8, 108, // 2463: decode to BLTZALS_MM using decoder 108
2147 // 2463: }
2148 19, 6, // 2467: case 0x13: {
2149 OPC_CheckPredicate, 1, // 2469: check predicate 1
2150 OPC_Decode, 214, 7, 108, // 2471: decode to BGEZALS_MM using decoder 108
2151 // 2471: }
2152 25, 10, // 2475: case 0x19: {
2153 OPC_CheckPredicate, 12, // 2477: check predicate 12
2154 OPC_CheckField, 16, 5, 0, // 2479: check Inst[20:16] == 0x0
2155 OPC_Decode, 187, 8, 112, // 2483: decode to BPOSGE32C_MMR3 using decoder 112
2156 // 2483: }
2157 27, 10, // 2487: case 0x1b: {
2158 OPC_CheckPredicate, 13, // 2489: check predicate 13
2159 OPC_CheckField, 16, 5, 0, // 2491: check Inst[20:16] == 0x0
2160 OPC_Decode, 188, 8, 113, // 2495: decode to BPOSGE32_MM using decoder 113
2161 // 2495: }
2162 28, 10, // 2499: case 0x1c: {
2163 OPC_CheckPredicate, 14, // 2501: check predicate 14
2164 OPC_CheckField, 16, 2, 0, // 2503: check Inst[17:16] == 0x0
2165 OPC_Decode, 168, 7, 114, // 2507: decode to BC1F_MM using decoder 114
2166 // 2507: }
2167 29, 0, // 2511: case 0x1d: {
2168 OPC_CheckPredicate, 14, // 2513: check predicate 14
2169 OPC_CheckField, 16, 2, 0, // 2515: check Inst[17:16] == 0x0
2170 OPC_Decode, 173, 7, 114, // 2519: decode to BC1T_MM using decoder 114
2171 // 2519: }
2172 // 2519: } // switch Inst[25:21]
2173 // 2519: }
2174 20, 6, // 2523: case 0x14: {
2175 OPC_CheckPredicate, 1, // 2525: check predicate 1
2176 OPC_Decode, 176, 18, 115, // 2527: decode to ORi_MM using decoder 115
2177 // 2527: }
2178 21, 145, 7, // 2531: case 0x15: {
2179 OPC_SwitchField, 0, 6, // 2534: switch Inst[5:0] {
2180 1, 6, // 2537: case 0x1: {
2181 OPC_CheckPredicate, 15, // 2539: check predicate 15
2182 OPC_Decode, 247, 15, 116, // 2541: decode to MADD_S_MM using decoder 116
2183 // 2541: }
2184 2, 6, // 2545: case 0x2: {
2185 OPC_CheckPredicate, 15, // 2547: check predicate 15
2186 OPC_Decode, 149, 18, 116, // 2549: decode to NMADD_S_MM using decoder 116
2187 // 2549: }
2188 8, 35, // 2553: case 0x8: {
2189 OPC_SwitchField, 6, 5, // 2555: switch Inst[10:6] {
2190 1, 6, // 2558: case 0x1: {
2191 OPC_CheckPredicate, 14, // 2560: check predicate 14
2192 OPC_Decode, 206, 15, 117, // 2562: decode to LWXC1_MM using decoder 117
2193 // 2562: }
2194 2, 6, // 2566: case 0x2: {
2195 OPC_CheckPredicate, 14, // 2568: check predicate 14
2196 OPC_Decode, 238, 21, 117, // 2570: decode to SWXC1_MM using decoder 117
2197 // 2570: }
2198 5, 6, // 2574: case 0x5: {
2199 OPC_CheckPredicate, 16, // 2576: check predicate 16
2200 OPC_Decode, 167, 15, 118, // 2578: decode to LUXC1_MM using decoder 118
2201 // 2578: }
2202 6, 0, // 2582: case 0x6: {
2203 OPC_CheckPredicate, 16, // 2584: check predicate 16
2204 OPC_Decode, 206, 21, 118, // 2586: decode to SUXC1_MM using decoder 118
2205 // 2586: }
2206 // 2586: } // switch Inst[10:6]
2207 // 2586: }
2208 9, 6, // 2590: case 0x9: {
2209 OPC_CheckPredicate, 17, // 2592: check predicate 17
2210 OPC_Decode, 239, 15, 119, // 2594: decode to MADD_D32_MM using decoder 119
2211 // 2594: }
2212 10, 6, // 2598: case 0xa: {
2213 OPC_CheckPredicate, 17, // 2600: check predicate 17
2214 OPC_Decode, 146, 18, 119, // 2602: decode to NMADD_D32_MM using decoder 119
2215 // 2602: }
2216 32, 59, // 2606: case 0x20: {
2217 OPC_SwitchField, 6, 5, // 2608: switch Inst[10:6] {
2218 0, 10, // 2611: case 0x0: {
2219 OPC_CheckPredicate, 14, // 2613: check predicate 14
2220 OPC_CheckField, 11, 2, 0, // 2615: check Inst[12:11] == 0x0
2221 OPC_Decode, 241, 16, 120, // 2619: decode to MOVF_S_MM using decoder 120
2222 // 2619: }
2223 1, 10, // 2623: case 0x1: {
2224 OPC_CheckPredicate, 14, // 2625: check predicate 14
2225 OPC_CheckField, 11, 2, 0, // 2627: check Inst[12:11] == 0x0
2226 OPC_Decode, 133, 17, 120, // 2631: decode to MOVT_S_MM using decoder 120
2227 // 2631: }
2228 6, 6, // 2635: case 0x6: {
2229 OPC_CheckPredicate, 1, // 2637: check predicate 1
2230 OPC_Decode, 239, 18, 121, // 2639: decode to PREFX_MM using decoder 121
2231 // 2639: }
2232 8, 10, // 2643: case 0x8: {
2233 OPC_CheckPredicate, 18, // 2645: check predicate 18
2234 OPC_CheckField, 11, 2, 0, // 2647: check Inst[12:11] == 0x0
2235 OPC_Decode, 235, 16, 122, // 2651: decode to MOVF_D32_MM using decoder 122
2236 // 2651: }
2237 9, 0, // 2655: case 0x9: {
2238 OPC_CheckPredicate, 18, // 2657: check predicate 18
2239 OPC_CheckField, 11, 2, 0, // 2659: check Inst[12:11] == 0x0
2240 OPC_Decode, 255, 16, 122, // 2663: decode to MOVT_D32_MM using decoder 122
2241 // 2663: }
2242 // 2663: } // switch Inst[10:6]
2243 // 2663: }
2244 33, 6, // 2667: case 0x21: {
2245 OPC_CheckPredicate, 15, // 2669: check predicate 15
2246 OPC_Decode, 170, 17, 116, // 2671: decode to MSUB_S_MM using decoder 116
2247 // 2671: }
2248 34, 6, // 2675: case 0x22: {
2249 OPC_CheckPredicate, 15, // 2677: check predicate 15
2250 OPC_Decode, 154, 18, 116, // 2679: decode to NMSUB_S_MM using decoder 116
2251 // 2679: }
2252 41, 6, // 2683: case 0x29: {
2253 OPC_CheckPredicate, 17, // 2685: check predicate 17
2254 OPC_Decode, 162, 17, 119, // 2687: decode to MSUB_D32_MM using decoder 119
2255 // 2687: }
2256 42, 6, // 2691: case 0x2a: {
2257 OPC_CheckPredicate, 17, // 2693: check predicate 17
2258 OPC_Decode, 151, 18, 119, // 2695: decode to NMSUB_D32_MM using decoder 119
2259 // 2695: }
2260 48, 35, // 2699: case 0x30: {
2261 OPC_SwitchField, 6, 5, // 2701: switch Inst[10:6] {
2262 4, 6, // 2704: case 0x4: {
2263 OPC_CheckPredicate, 19, // 2706: check predicate 19
2264 OPC_Decode, 217, 12, 123, // 2708: decode to FADD_D32_MM using decoder 123
2265 // 2708: }
2266 5, 6, // 2712: case 0x5: {
2267 OPC_CheckPredicate, 19, // 2714: check predicate 19
2268 OPC_Decode, 234, 13, 123, // 2716: decode to FSUB_D32_MM using decoder 123
2269 // 2716: }
2270 6, 6, // 2720: case 0x6: {
2271 OPC_CheckPredicate, 19, // 2722: check predicate 19
2272 OPC_Decode, 190, 13, 123, // 2724: decode to FMUL_D32_MM using decoder 123
2273 // 2724: }
2274 7, 0, // 2728: case 0x7: {
2275 OPC_CheckPredicate, 19, // 2730: check predicate 19
2276 OPC_Decode, 128, 13, 123, // 2732: decode to FDIV_D32_MM using decoder 123
2277 // 2732: }
2278 // 2732: } // switch Inst[10:6]
2279 // 2732: }
2280 56, 35, // 2736: case 0x38: {
2281 OPC_SwitchField, 6, 4, // 2738: switch Inst[9:6] {
2282 0, 6, // 2741: case 0x0: {
2283 OPC_CheckPredicate, 14, // 2743: check predicate 14
2284 OPC_Decode, 253, 16, 124, // 2745: decode to MOVN_I_S_MM using decoder 124
2285 // 2745: }
2286 1, 6, // 2749: case 0x1: {
2287 OPC_CheckPredicate, 14, // 2751: check predicate 14
2288 OPC_Decode, 145, 17, 124, // 2753: decode to MOVZ_I_S_MM using decoder 124
2289 // 2753: }
2290 4, 6, // 2757: case 0x4: {
2291 OPC_CheckPredicate, 18, // 2759: check predicate 18
2292 OPC_Decode, 247, 16, 125, // 2761: decode to MOVN_I_D32_MM using decoder 125
2293 // 2761: }
2294 5, 0, // 2765: case 0x5: {
2295 OPC_CheckPredicate, 18, // 2767: check predicate 18
2296 OPC_Decode, 139, 17, 125, // 2769: decode to MOVZ_I_D32_MM using decoder 125
2297 // 2769: }
2298 // 2769: } // switch Inst[9:6]
2299 // 2769: }
2300 59, 250, 2, // 2773: case 0x3b: {
2301 OPC_SwitchField, 6, 7, // 2776: switch Inst[12:6] {
2302 0, 10, // 2779: case 0x0: {
2303 OPC_CheckPredicate, 20, // 2781: check predicate 20
2304 OPC_CheckField, 13, 3, 1, // 2783: check Inst[15:13] == 0x1
2305 OPC_Decode, 160, 16, 126, // 2787: decode to MFC1_MM using decoder 126
2306 // 2787: }
2307 1, 10, // 2791: case 0x1: {
2308 OPC_CheckPredicate, 19, // 2793: check predicate 19
2309 OPC_CheckField, 13, 3, 1, // 2795: check Inst[15:13] == 0x1
2310 OPC_Decode, 179, 13, 127, // 2799: decode to FMOV_D32_MM using decoder 127
2311 // 2799: }
2312 4, 21, // 2803: case 0x4: {
2313 OPC_SwitchField, 13, 3, // 2805: switch Inst[15:13] {
2314 0, 7, // 2808: case 0x0: {
2315 OPC_CheckPredicate, 21, // 2810: check predicate 21
2316 OPC_Decode, 162, 10, 128, 1, // 2812: decode to CVT_L_S_MM using decoder 128
2317 // 2812: }
2318 2, 0, // 2817: case 0x2: {
2319 OPC_CheckPredicate, 21, // 2819: check predicate 21
2320 OPC_Decode, 159, 10, 129, 1, // 2821: decode to CVT_L_D64_MM using decoder 129
2321 // 2821: }
2322 // 2821: } // switch Inst[15:13]
2323 // 2821: }
2324 5, 7, // 2826: case 0x5: {
2325 OPC_CheckPredicate, 14, // 2828: check predicate 14
2326 OPC_Decode, 239, 16, 130, 1, // 2830: decode to MOVF_I_MM using decoder 130
2327 // 2830: }
2328 8, 20, // 2835: case 0x8: {
2329 OPC_SwitchField, 13, 3, // 2837: switch Inst[15:13] {
2330 0, 7, // 2840: case 0x0: {
2331 OPC_CheckPredicate, 20, // 2842: check predicate 20
2332 OPC_Decode, 166, 19, 131, 1, // 2844: decode to RSQRT_S_MM using decoder 131
2333 // 2844: }
2334 2, 0, // 2849: case 0x2: {
2335 OPC_CheckPredicate, 19, // 2851: check predicate 19
2336 OPC_Decode, 162, 19, 127, // 2853: decode to RSQRT_D32_MM using decoder 127
2337 // 2853: }
2338 // 2853: } // switch Inst[15:13]
2339 // 2853: }
2340 13, 20, // 2857: case 0xd: {
2341 OPC_SwitchField, 13, 3, // 2859: switch Inst[15:13] {
2342 0, 7, // 2862: case 0x0: {
2343 OPC_CheckPredicate, 20, // 2864: check predicate 20
2344 OPC_Decode, 214, 12, 131, 1, // 2866: decode to FABS_S_MM using decoder 131
2345 // 2866: }
2346 1, 0, // 2871: case 0x1: {
2347 OPC_CheckPredicate, 19, // 2873: check predicate 19
2348 OPC_Decode, 210, 12, 127, // 2875: decode to FABS_D32_MM using decoder 127
2349 // 2875: }
2350 // 2875: } // switch Inst[15:13]
2351 // 2875: }
2352 32, 11, // 2879: case 0x20: {
2353 OPC_CheckPredicate, 20, // 2881: check predicate 20
2354 OPC_CheckField, 13, 3, 1, // 2883: check Inst[15:13] == 0x1
2355 OPC_Decode, 176, 17, 132, 1, // 2887: decode to MTC1_MM using decoder 132
2356 // 2887: }
2357 36, 21, // 2892: case 0x24: {
2358 OPC_SwitchField, 13, 3, // 2894: switch Inst[15:13] {
2359 0, 7, // 2897: case 0x0: {
2360 OPC_CheckPredicate, 20, // 2899: check predicate 20
2361 OPC_Decode, 183, 10, 131, 1, // 2901: decode to CVT_W_S_MM using decoder 131
2362 // 2901: }
2363 2, 0, // 2906: case 0x2: {
2364 OPC_CheckPredicate, 19, // 2908: check predicate 19
2365 OPC_Decode, 179, 10, 133, 1, // 2910: decode to CVT_W_D32_MM using decoder 133
2366 // 2910: }
2367 // 2910: } // switch Inst[15:13]
2368 // 2910: }
2369 37, 7, // 2915: case 0x25: {
2370 OPC_CheckPredicate, 14, // 2917: check predicate 14
2371 OPC_Decode, 131, 17, 130, 1, // 2919: decode to MOVT_I_MM using decoder 130
2372 // 2919: }
2373 40, 20, // 2924: case 0x28: {
2374 OPC_SwitchField, 13, 3, // 2926: switch Inst[15:13] {
2375 0, 7, // 2929: case 0x0: {
2376 OPC_CheckPredicate, 20, // 2931: check predicate 20
2377 OPC_Decode, 230, 13, 131, 1, // 2933: decode to FSQRT_S_MM using decoder 131
2378 // 2933: }
2379 2, 0, // 2938: case 0x2: {
2380 OPC_CheckPredicate, 19, // 2940: check predicate 19
2381 OPC_Decode, 226, 13, 127, // 2942: decode to FSQRT_D32_MM using decoder 127
2382 // 2942: }
2383 // 2942: } // switch Inst[15:13]
2384 // 2942: }
2385 44, 39, // 2946: case 0x2c: {
2386 OPC_SwitchField, 13, 3, // 2948: switch Inst[15:13] {
2387 0, 7, // 2951: case 0x0: {
2388 OPC_CheckPredicate, 20, // 2953: check predicate 20
2389 OPC_Decode, 166, 13, 131, 1, // 2955: decode to FLOOR_W_S_MM using decoder 131
2390 // 2955: }
2391 1, 7, // 2960: case 0x1: {
2392 OPC_CheckPredicate, 20, // 2962: check predicate 20
2393 OPC_Decode, 198, 22, 131, 1, // 2964: decode to TRUNC_W_S_MM using decoder 131
2394 // 2964: }
2395 2, 7, // 2969: case 0x2: {
2396 OPC_CheckPredicate, 19, // 2971: check predicate 19
2397 OPC_Decode, 164, 13, 133, 1, // 2973: decode to FLOOR_W_MM using decoder 133
2398 // 2973: }
2399 3, 0, // 2978: case 0x3: {
2400 OPC_CheckPredicate, 19, // 2980: check predicate 19
2401 OPC_Decode, 196, 22, 133, 1, // 2982: decode to TRUNC_W_MM using decoder 133
2402 // 2982: }
2403 // 2982: } // switch Inst[15:13]
2404 // 2982: }
2405 45, 10, // 2987: case 0x2d: {
2406 OPC_CheckPredicate, 19, // 2989: check predicate 19
2407 OPC_CheckField, 13, 3, 1, // 2991: check Inst[15:13] == 0x1
2408 OPC_Decode, 199, 13, 127, // 2995: decode to FNEG_D32_MM using decoder 127
2409 // 2995: }
2410 64, 21, // 2999: case 0x40: {
2411 OPC_SwitchField, 13, 3, // 3001: switch Inst[15:13] {
2412 0, 7, // 3004: case 0x0: {
2413 OPC_CheckPredicate, 20, // 3006: check predicate 20
2414 OPC_Decode, 246, 8, 134, 1, // 3008: decode to CFC1_MM using decoder 134
2415 // 3008: }
2416 1, 0, // 3013: case 0x1: {
2417 OPC_CheckPredicate, 19, // 3015: check predicate 19
2418 OPC_Decode, 168, 16, 135, 1, // 3017: decode to MFHC1_D32_MM using decoder 135
2419 // 3017: }
2420 // 3017: } // switch Inst[15:13]
2421 // 3017: }
2422 72, 20, // 3022: case 0x48: {
2423 OPC_SwitchField, 13, 3, // 3024: switch Inst[15:13] {
2424 0, 7, // 3027: case 0x0: {
2425 OPC_CheckPredicate, 20, // 3029: check predicate 20
2426 OPC_Decode, 133, 19, 131, 1, // 3031: decode to RECIP_S_MM using decoder 131
2427 // 3031: }
2428 2, 0, // 3036: case 0x2: {
2429 OPC_CheckPredicate, 19, // 3038: check predicate 19
2430 OPC_Decode, 129, 19, 127, // 3040: decode to RECIP_D32_MM using decoder 127
2431 // 3040: }
2432 // 3040: } // switch Inst[15:13]
2433 // 3040: }
2434 77, 21, // 3044: case 0x4d: {
2435 OPC_SwitchField, 13, 3, // 3046: switch Inst[15:13] {
2436 0, 7, // 3049: case 0x0: {
2437 OPC_CheckPredicate, 19, // 3051: check predicate 19
2438 OPC_Decode, 149, 10, 136, 1, // 3053: decode to CVT_D32_S_MM using decoder 136
2439 // 3053: }
2440 1, 0, // 3058: case 0x1: {
2441 OPC_CheckPredicate, 19, // 3060: check predicate 19
2442 OPC_Decode, 151, 10, 136, 1, // 3062: decode to CVT_D32_W_MM using decoder 136
2443 // 3062: }
2444 // 3062: } // switch Inst[15:13]
2445 // 3062: }
2446 96, 21, // 3067: case 0x60: {
2447 OPC_SwitchField, 13, 3, // 3069: switch Inst[15:13] {
2448 0, 7, // 3072: case 0x0: {
2449 OPC_CheckPredicate, 20, // 3074: check predicate 20
2450 OPC_Decode, 145, 10, 137, 1, // 3076: decode to CTC1_MM using decoder 137
2451 // 3076: }
2452 1, 0, // 3081: case 0x1: {
2453 OPC_CheckPredicate, 19, // 3083: check predicate 19
2454 OPC_Decode, 184, 17, 138, 1, // 3085: decode to MTHC1_D32_MM using decoder 138
2455 // 3085: }
2456 // 3085: } // switch Inst[15:13]
2457 // 3085: }
2458 108, 39, // 3090: case 0x6c: {
2459 OPC_SwitchField, 13, 3, // 3092: switch Inst[15:13] {
2460 0, 7, // 3095: case 0x0: {
2461 OPC_CheckPredicate, 20, // 3097: check predicate 20
2462 OPC_Decode, 235, 8, 131, 1, // 3099: decode to CEIL_W_S_MM using decoder 131
2463 // 3099: }
2464 1, 7, // 3104: case 0x1: {
2465 OPC_CheckPredicate, 20, // 3106: check predicate 20
2466 OPC_Decode, 159, 19, 131, 1, // 3108: decode to ROUND_W_S_MM using decoder 131
2467 // 3108: }
2468 2, 7, // 3113: case 0x2: {
2469 OPC_CheckPredicate, 19, // 3115: check predicate 19
2470 OPC_Decode, 233, 8, 133, 1, // 3117: decode to CEIL_W_MM using decoder 133
2471 // 3117: }
2472 3, 0, // 3122: case 0x3: {
2473 OPC_CheckPredicate, 19, // 3124: check predicate 19
2474 OPC_Decode, 157, 19, 133, 1, // 3126: decode to ROUND_W_MM using decoder 133
2475 // 3126: }
2476 // 3126: } // switch Inst[15:13]
2477 // 3126: }
2478 109, 0, // 3131: case 0x6d: {
2479 OPC_SwitchField, 13, 3, // 3133: switch Inst[15:13] {
2480 0, 7, // 3136: case 0x0: {
2481 OPC_CheckPredicate, 19, // 3138: check predicate 19
2482 OPC_Decode, 168, 10, 133, 1, // 3140: decode to CVT_S_D32_MM using decoder 133
2483 // 3140: }
2484 1, 0, // 3145: case 0x1: {
2485 OPC_CheckPredicate, 20, // 3147: check predicate 20
2486 OPC_Decode, 176, 10, 131, 1, // 3149: decode to CVT_S_W_MM using decoder 131
2487 // 3149: }
2488 // 3149: } // switch Inst[15:13]
2489 // 3149: }
2490 // 3149: } // switch Inst[12:6]
2491 // 3149: }
2492 60, 0, // 3154: case 0x3c: {
2493 OPC_SwitchField, 6, 7, // 3156: switch Inst[12:6] {
2494 0, 7, // 3159: case 0x0: {
2495 OPC_CheckPredicate, 14, // 3161: check predicate 14
2496 OPC_Decode, 196, 10, 139, 1, // 3163: decode to C_F_S_MM using decoder 139
2497 // 3163: }
2498 1, 7, // 3168: case 0x1: {
2499 OPC_CheckPredicate, 14, // 3170: check predicate 14
2500 OPC_Decode, 152, 11, 139, 1, // 3172: decode to C_UN_S_MM using decoder 139
2501 // 3172: }
2502 2, 7, // 3177: case 0x2: {
2503 OPC_CheckPredicate, 14, // 3179: check predicate 14
2504 OPC_Decode, 190, 10, 139, 1, // 3181: decode to C_EQ_S_MM using decoder 139
2505 // 3181: }
2506 3, 7, // 3186: case 0x3: {
2507 OPC_CheckPredicate, 14, // 3188: check predicate 14
2508 OPC_Decode, 134, 11, 139, 1, // 3190: decode to C_UEQ_S_MM using decoder 139
2509 // 3190: }
2510 4, 7, // 3195: case 0x4: {
2511 OPC_CheckPredicate, 14, // 3197: check predicate 14
2512 OPC_Decode, 244, 10, 139, 1, // 3199: decode to C_OLT_S_MM using decoder 139
2513 // 3199: }
2514 5, 7, // 3204: case 0x5: {
2515 OPC_CheckPredicate, 14, // 3206: check predicate 14
2516 OPC_Decode, 146, 11, 139, 1, // 3208: decode to C_ULT_S_MM using decoder 139
2517 // 3208: }
2518 6, 7, // 3213: case 0x6: {
2519 OPC_CheckPredicate, 14, // 3215: check predicate 14
2520 OPC_Decode, 238, 10, 139, 1, // 3217: decode to C_OLE_S_MM using decoder 139
2521 // 3217: }
2522 7, 7, // 3222: case 0x7: {
2523 OPC_CheckPredicate, 14, // 3224: check predicate 14
2524 OPC_Decode, 140, 11, 139, 1, // 3226: decode to C_ULE_S_MM using decoder 139
2525 // 3226: }
2526 8, 7, // 3231: case 0x8: {
2527 OPC_CheckPredicate, 14, // 3233: check predicate 14
2528 OPC_Decode, 128, 11, 139, 1, // 3235: decode to C_SF_S_MM using decoder 139
2529 // 3235: }
2530 9, 7, // 3240: case 0x9: {
2531 OPC_CheckPredicate, 14, // 3242: check predicate 14
2532 OPC_Decode, 220, 10, 139, 1, // 3244: decode to C_NGLE_S_MM using decoder 139
2533 // 3244: }
2534 10, 7, // 3249: case 0xa: {
2535 OPC_CheckPredicate, 14, // 3251: check predicate 14
2536 OPC_Decode, 250, 10, 139, 1, // 3253: decode to C_SEQ_S_MM using decoder 139
2537 // 3253: }
2538 11, 7, // 3258: case 0xb: {
2539 OPC_CheckPredicate, 14, // 3260: check predicate 14
2540 OPC_Decode, 226, 10, 139, 1, // 3262: decode to C_NGL_S_MM using decoder 139
2541 // 3262: }
2542 12, 7, // 3267: case 0xc: {
2543 OPC_CheckPredicate, 14, // 3269: check predicate 14
2544 OPC_Decode, 208, 10, 139, 1, // 3271: decode to C_LT_S_MM using decoder 139
2545 // 3271: }
2546 13, 7, // 3276: case 0xd: {
2547 OPC_CheckPredicate, 14, // 3278: check predicate 14
2548 OPC_Decode, 214, 10, 139, 1, // 3280: decode to C_NGE_S_MM using decoder 139
2549 // 3280: }
2550 14, 7, // 3285: case 0xe: {
2551 OPC_CheckPredicate, 14, // 3287: check predicate 14
2552 OPC_Decode, 202, 10, 139, 1, // 3289: decode to C_LE_S_MM using decoder 139
2553 // 3289: }
2554 15, 7, // 3294: case 0xf: {
2555 OPC_CheckPredicate, 14, // 3296: check predicate 14
2556 OPC_Decode, 232, 10, 139, 1, // 3298: decode to C_NGT_S_MM using decoder 139
2557 // 3298: }
2558 16, 7, // 3303: case 0x10: {
2559 OPC_CheckPredicate, 18, // 3305: check predicate 18
2560 OPC_Decode, 192, 10, 140, 1, // 3307: decode to C_F_D32_MM using decoder 140
2561 // 3307: }
2562 17, 7, // 3312: case 0x11: {
2563 OPC_CheckPredicate, 18, // 3314: check predicate 18
2564 OPC_Decode, 148, 11, 140, 1, // 3316: decode to C_UN_D32_MM using decoder 140
2565 // 3316: }
2566 18, 7, // 3321: case 0x12: {
2567 OPC_CheckPredicate, 18, // 3323: check predicate 18
2568 OPC_Decode, 186, 10, 140, 1, // 3325: decode to C_EQ_D32_MM using decoder 140
2569 // 3325: }
2570 19, 7, // 3330: case 0x13: {
2571 OPC_CheckPredicate, 18, // 3332: check predicate 18
2572 OPC_Decode, 130, 11, 140, 1, // 3334: decode to C_UEQ_D32_MM using decoder 140
2573 // 3334: }
2574 20, 7, // 3339: case 0x14: {
2575 OPC_CheckPredicate, 18, // 3341: check predicate 18
2576 OPC_Decode, 240, 10, 140, 1, // 3343: decode to C_OLT_D32_MM using decoder 140
2577 // 3343: }
2578 21, 7, // 3348: case 0x15: {
2579 OPC_CheckPredicate, 18, // 3350: check predicate 18
2580 OPC_Decode, 142, 11, 140, 1, // 3352: decode to C_ULT_D32_MM using decoder 140
2581 // 3352: }
2582 22, 7, // 3357: case 0x16: {
2583 OPC_CheckPredicate, 18, // 3359: check predicate 18
2584 OPC_Decode, 234, 10, 140, 1, // 3361: decode to C_OLE_D32_MM using decoder 140
2585 // 3361: }
2586 23, 7, // 3366: case 0x17: {
2587 OPC_CheckPredicate, 18, // 3368: check predicate 18
2588 OPC_Decode, 136, 11, 140, 1, // 3370: decode to C_ULE_D32_MM using decoder 140
2589 // 3370: }
2590 24, 7, // 3375: case 0x18: {
2591 OPC_CheckPredicate, 18, // 3377: check predicate 18
2592 OPC_Decode, 252, 10, 140, 1, // 3379: decode to C_SF_D32_MM using decoder 140
2593 // 3379: }
2594 25, 7, // 3384: case 0x19: {
2595 OPC_CheckPredicate, 18, // 3386: check predicate 18
2596 OPC_Decode, 216, 10, 140, 1, // 3388: decode to C_NGLE_D32_MM using decoder 140
2597 // 3388: }
2598 26, 7, // 3393: case 0x1a: {
2599 OPC_CheckPredicate, 18, // 3395: check predicate 18
2600 OPC_Decode, 246, 10, 140, 1, // 3397: decode to C_SEQ_D32_MM using decoder 140
2601 // 3397: }
2602 27, 7, // 3402: case 0x1b: {
2603 OPC_CheckPredicate, 18, // 3404: check predicate 18
2604 OPC_Decode, 222, 10, 140, 1, // 3406: decode to C_NGL_D32_MM using decoder 140
2605 // 3406: }
2606 28, 7, // 3411: case 0x1c: {
2607 OPC_CheckPredicate, 18, // 3413: check predicate 18
2608 OPC_Decode, 204, 10, 140, 1, // 3415: decode to C_LT_D32_MM using decoder 140
2609 // 3415: }
2610 29, 7, // 3420: case 0x1d: {
2611 OPC_CheckPredicate, 18, // 3422: check predicate 18
2612 OPC_Decode, 210, 10, 140, 1, // 3424: decode to C_NGE_D32_MM using decoder 140
2613 // 3424: }
2614 30, 7, // 3429: case 0x1e: {
2615 OPC_CheckPredicate, 18, // 3431: check predicate 18
2616 OPC_Decode, 198, 10, 140, 1, // 3433: decode to C_LE_D32_MM using decoder 140
2617 // 3433: }
2618 31, 0, // 3438: case 0x1f: {
2619 OPC_CheckPredicate, 18, // 3440: check predicate 18
2620 OPC_Decode, 228, 10, 140, 1, // 3442: decode to C_NGT_D32_MM using decoder 140
2621 // 3442: }
2622 // 3442: } // switch Inst[12:6]
2623 // 3442: }
2624 // 3442: } // switch Inst[5:0]
2625 // 3442: }
2626 22, 30, // 3447: case 0x16: {
2627 OPC_SwitchField, 0, 11, // 3449: switch Inst[10:0] {
2628 197, 1, 6, // 3452: case 0xc5: {
2629 OPC_CheckPredicate, 9, // 3455: check predicate 9
2630 OPC_Decode, 176, 9, 60, // 3457: decode to CMPGU_EQ_QB_MM using decoder 60
2631 // 3457: }
2632 133, 2, 6, // 3461: case 0x105: {
2633 OPC_CheckPredicate, 9, // 3464: check predicate 9
2634 OPC_Decode, 180, 9, 60, // 3466: decode to CMPGU_LT_QB_MM using decoder 60
2635 // 3466: }
2636 197, 2, 0, // 3470: case 0x145: {
2637 OPC_CheckPredicate, 9, // 3473: check predicate 9
2638 OPC_Decode, 178, 9, 60, // 3475: decode to CMPGU_LE_QB_MM using decoder 60
2639 // 3475: }
2640 // 3475: } // switch Inst[10:0]
2641 // 3475: }
2642 24, 221, 1, // 3479: case 0x18: {
2643 OPC_SwitchField, 12, 4, // 3482: switch Inst[15:12] {
2644 0, 6, // 3485: case 0x0: {
2645 OPC_CheckPredicate, 1, // 3487: check predicate 1
2646 OPC_Decode, 189, 15, 106, // 3489: decode to LWL_MM using decoder 106
2647 // 3489: }
2648 1, 6, // 3493: case 0x1: {
2649 OPC_CheckPredicate, 1, // 3495: check predicate 1
2650 OPC_Decode, 200, 15, 106, // 3497: decode to LWR_MM using decoder 106
2651 // 3497: }
2652 2, 6, // 3501: case 0x2: {
2653 OPC_CheckPredicate, 1, // 3503: check predicate 1
2654 OPC_Decode, 240, 18, 107, // 3505: decode to PREF_MM using decoder 107
2655 // 3505: }
2656 3, 6, // 3509: case 0x3: {
2657 OPC_CheckPredicate, 1, // 3511: check predicate 1
2658 OPC_Decode, 158, 15, 106, // 3513: decode to LL_MM using decoder 106
2659 // 3513: }
2660 6, 75, // 3517: case 0x6: {
2661 OPC_SwitchField, 9, 3, // 3519: switch Inst[11:9] {
2662 0, 7, // 3522: case 0x0: {
2663 OPC_CheckPredicate, 22, // 3524: check predicate 22
2664 OPC_Decode, 236, 14, 141, 1, // 3526: decode to LBuE_MM using decoder 141
2665 // 3526: }
2666 1, 7, // 3531: case 0x1: {
2667 OPC_CheckPredicate, 22, // 3533: check predicate 22
2668 OPC_Decode, 147, 15, 141, 1, // 3535: decode to LHuE_MM using decoder 141
2669 // 3535: }
2670 2, 7, // 3540: case 0x2: {
2671 OPC_CheckPredicate, 23, // 3542: check predicate 23
2672 OPC_Decode, 188, 15, 141, 1, // 3544: decode to LWLE_MM using decoder 141
2673 // 3544: }
2674 3, 7, // 3549: case 0x3: {
2675 OPC_CheckPredicate, 23, // 3551: check predicate 23
2676 OPC_Decode, 199, 15, 141, 1, // 3553: decode to LWRE_MM using decoder 141
2677 // 3553: }
2678 4, 7, // 3558: case 0x4: {
2679 OPC_CheckPredicate, 22, // 3560: check predicate 22
2680 OPC_Decode, 226, 14, 141, 1, // 3562: decode to LBE_MM using decoder 141
2681 // 3562: }
2682 5, 7, // 3567: case 0x5: {
2683 OPC_CheckPredicate, 22, // 3569: check predicate 22
2684 OPC_Decode, 139, 15, 141, 1, // 3571: decode to LHE_MM using decoder 141
2685 // 3571: }
2686 6, 7, // 3576: case 0x6: {
2687 OPC_CheckPredicate, 22, // 3578: check predicate 22
2688 OPC_Decode, 157, 15, 141, 1, // 3580: decode to LLE_MM using decoder 141
2689 // 3580: }
2690 7, 0, // 3585: case 0x7: {
2691 OPC_CheckPredicate, 22, // 3587: check predicate 22
2692 OPC_Decode, 183, 15, 141, 1, // 3589: decode to LWE_MM using decoder 141
2693 // 3589: }
2694 // 3589: } // switch Inst[11:9]
2695 // 3589: }
2696 8, 6, // 3594: case 0x8: {
2697 OPC_CheckPredicate, 1, // 3596: check predicate 1
2698 OPC_Decode, 225, 21, 106, // 3598: decode to SWL_MM using decoder 106
2699 // 3598: }
2700 9, 6, // 3602: case 0x9: {
2701 OPC_CheckPredicate, 1, // 3604: check predicate 1
2702 OPC_Decode, 234, 21, 106, // 3606: decode to SWR_MM using decoder 106
2703 // 3606: }
2704 10, 75, // 3610: case 0xa: {
2705 OPC_SwitchField, 9, 3, // 3612: switch Inst[11:9] {
2706 0, 7, // 3615: case 0x0: {
2707 OPC_CheckPredicate, 23, // 3617: check predicate 23
2708 OPC_Decode, 224, 21, 141, 1, // 3619: decode to SWLE_MM using decoder 141
2709 // 3619: }
2710 1, 7, // 3624: case 0x1: {
2711 OPC_CheckPredicate, 23, // 3626: check predicate 23
2712 OPC_Decode, 233, 21, 141, 1, // 3628: decode to SWRE_MM using decoder 141
2713 // 3628: }
2714 2, 7, // 3633: case 0x2: {
2715 OPC_CheckPredicate, 22, // 3635: check predicate 22
2716 OPC_Decode, 238, 18, 142, 1, // 3637: decode to PREFE_MM using decoder 142
2717 // 3637: }
2718 3, 7, // 3642: case 0x3: {
2719 OPC_CheckPredicate, 22, // 3644: check predicate 22
2720 OPC_Decode, 222, 8, 142, 1, // 3646: decode to CACHEE_MM using decoder 142
2721 // 3646: }
2722 4, 7, // 3651: case 0x4: {
2723 OPC_CheckPredicate, 22, // 3653: check predicate 22
2724 OPC_Decode, 184, 19, 141, 1, // 3655: decode to SBE_MM using decoder 141
2725 // 3655: }
2726 5, 7, // 3660: case 0x5: {
2727 OPC_CheckPredicate, 22, // 3662: check predicate 22
2728 OPC_Decode, 250, 19, 141, 1, // 3664: decode to SHE_MM using decoder 141
2729 // 3664: }
2730 6, 7, // 3669: case 0x6: {
2731 OPC_CheckPredicate, 22, // 3671: check predicate 22
2732 OPC_Decode, 193, 19, 141, 1, // 3673: decode to SCE_MM using decoder 141
2733 // 3673: }
2734 7, 0, // 3678: case 0x7: {
2735 OPC_CheckPredicate, 22, // 3680: check predicate 22
2736 OPC_Decode, 220, 21, 141, 1, // 3682: decode to SWE_MM using decoder 141
2737 // 3682: }
2738 // 3682: } // switch Inst[11:9]
2739 // 3682: }
2740 11, 6, // 3687: case 0xb: {
2741 OPC_CheckPredicate, 1, // 3689: check predicate 1
2742 OPC_Decode, 194, 19, 106, // 3691: decode to SC_MM using decoder 106
2743 // 3691: }
2744 14, 0, // 3695: case 0xe: {
2745 OPC_CheckPredicate, 1, // 3697: check predicate 1
2746 OPC_Decode, 203, 15, 106, // 3699: decode to LWU_MM using decoder 106
2747 // 3699: }
2748 // 3699: } // switch Inst[15:12]
2749 // 3699: }
2750 28, 6, // 3703: case 0x1c: {
2751 OPC_CheckPredicate, 1, // 3705: check predicate 1
2752 OPC_Decode, 230, 22, 115, // 3707: decode to XORi_MM using decoder 115
2753 // 3707: }
2754 29, 7, // 3711: case 0x1d: {
2755 OPC_CheckPredicate, 1, // 3713: check predicate 1
2756 OPC_Decode, 194, 14, 143, 1, // 3715: decode to JALS_MM using decoder 143
2757 // 3715: }
2758 30, 7, // 3720: case 0x1e: {
2759 OPC_CheckPredicate, 1, // 3722: check predicate 1
2760 OPC_Decode, 149, 6, 144, 1, // 3724: decode to ADDIUPC_MM using decoder 144
2761 // 3724: }
2762 36, 6, // 3729: case 0x24: {
2763 OPC_CheckPredicate, 2, // 3731: check predicate 2
2764 OPC_Decode, 208, 20, 104, // 3733: decode to SLTi_MM using decoder 104
2765 // 3733: }
2766 37, 7, // 3737: case 0x25: {
2767 OPC_CheckPredicate, 1, // 3739: check predicate 1
2768 OPC_Decode, 201, 7, 145, 1, // 3741: decode to BEQ_MM using decoder 145
2769 // 3741: }
2770 38, 7, // 3746: case 0x26: {
2771 OPC_CheckPredicate, 20, // 3748: check predicate 20
2772 OPC_Decode, 212, 21, 146, 1, // 3750: decode to SWC1_MM using decoder 146
2773 // 3750: }
2774 39, 7, // 3755: case 0x27: {
2775 OPC_CheckPredicate, 20, // 3757: check predicate 20
2776 OPC_Decode, 175, 15, 146, 1, // 3759: decode to LWC1_MM using decoder 146
2777 // 3759: }
2778 44, 6, // 3764: case 0x2c: {
2779 OPC_CheckPredicate, 2, // 3766: check predicate 2
2780 OPC_Decode, 211, 20, 104, // 3768: decode to SLTiu_MM using decoder 104
2781 // 3768: }
2782 45, 7, // 3772: case 0x2d: {
2783 OPC_CheckPredicate, 1, // 3774: check predicate 1
2784 OPC_Decode, 176, 8, 145, 1, // 3776: decode to BNE_MM using decoder 145
2785 // 3776: }
2786 46, 7, // 3781: case 0x2e: {
2787 OPC_CheckPredicate, 19, // 3783: check predicate 19
2788 OPC_Decode, 207, 19, 146, 1, // 3785: decode to SDC1_MM_D32 using decoder 146
2789 // 3785: }
2790 47, 7, // 3790: case 0x2f: {
2791 OPC_CheckPredicate, 19, // 3792: check predicate 19
2792 OPC_Decode, 242, 14, 146, 1, // 3794: decode to LDC1_MM_D32 using decoder 146
2793 // 3794: }
2794 52, 6, // 3799: case 0x34: {
2795 OPC_CheckPredicate, 1, // 3801: check predicate 1
2796 OPC_Decode, 239, 6, 115, // 3803: decode to ANDi_MM using decoder 115
2797 // 3803: }
2798 53, 7, // 3807: case 0x35: {
2799 OPC_CheckPredicate, 1, // 3809: check predicate 1
2800 OPC_Decode, 216, 14, 143, 1, // 3811: decode to J_MM using decoder 143
2801 // 3811: }
2802 60, 7, // 3816: case 0x3c: {
2803 OPC_CheckPredicate, 1, // 3818: check predicate 1
2804 OPC_Decode, 196, 14, 147, 1, // 3820: decode to JALX_MM using decoder 147
2805 // 3820: }
2806 61, 7, // 3825: case 0x3d: {
2807 OPC_CheckPredicate, 1, // 3827: check predicate 1
2808 OPC_Decode, 197, 14, 143, 1, // 3829: decode to JAL_MM using decoder 143
2809 // 3829: }
2810 62, 6, // 3834: case 0x3e: {
2811 OPC_CheckPredicate, 2, // 3836: check predicate 2
2812 OPC_Decode, 239, 21, 105, // 3838: decode to SW_MM using decoder 105
2813 // 3838: }
2814 63, 0, // 3842: case 0x3f: {
2815 OPC_CheckPredicate, 2, // 3844: check predicate 2
2816 OPC_Decode, 209, 15, 105, // 3846: decode to LW_MM using decoder 105
2817 // 3846: }
2818 // 3846: } // switch Inst[31:26]
2819};
2820static const uint8_t DecoderTableMicroMipsDSP32[21] = {
2821 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
2822 62, 7, // 3: case 0x3e: {
2823 OPC_CheckPredicate, 9, // 5: check predicate 9
2824 OPC_Decode, 218, 21, 148, 1, // 7: decode to SWDSP_MM using decoder 148
2825 // 7: }
2826 63, 0, // 12: case 0x3f: {
2827 OPC_CheckPredicate, 9, // 14: check predicate 9
2828 OPC_Decode, 181, 15, 148, 1, // 16: decode to LWDSP_MM using decoder 148
2829 // 16: }
2830 // 16: } // switch Inst[31:26]
2831};
2832static const uint8_t DecoderTableMicroMipsFP6432[210] = {
2833 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
2834 21, 186, 1, // 3: case 0x15: {
2835 OPC_SwitchField, 0, 11, // 6: switch Inst[10:0] {
2836 59, 30, // 9: case 0x3b: {
2837 OPC_SwitchField, 11, 5, // 11: switch Inst[15:11] {
2838 5, 7, // 14: case 0x5: {
2839 OPC_CheckPredicate, 21, // 16: check predicate 21
2840 OPC_Decode, 175, 17, 149, 1, // 18: decode to MTC1_D64_MM using decoder 149
2841 // 18: }
2842 6, 7, // 23: case 0x6: {
2843 OPC_CheckPredicate, 21, // 25: check predicate 21
2844 OPC_Decode, 170, 16, 150, 1, // 27: decode to MFHC1_D64_MM using decoder 150
2845 // 27: }
2846 7, 0, // 32: case 0x7: {
2847 OPC_CheckPredicate, 21, // 34: check predicate 21
2848 OPC_Decode, 186, 17, 151, 1, // 36: decode to MTHC1_D64_MM using decoder 151
2849 // 36: }
2850 // 36: } // switch Inst[15:11]
2851 // 36: }
2852 123, 11, // 41: case 0x7b: {
2853 OPC_CheckPredicate, 21, // 43: check predicate 21
2854 OPC_CheckField, 11, 5, 4, // 45: check Inst[15:11] == 0x4
2855 OPC_Decode, 181, 13, 129, 1, // 49: decode to FMOV_D64_MM using decoder 129
2856 // 49: }
2857 176, 2, 7, // 54: case 0x130: {
2858 OPC_CheckPredicate, 21, // 57: check predicate 21
2859 OPC_Decode, 219, 12, 152, 1, // 59: decode to FADD_D64_MM using decoder 152
2860 // 59: }
2861 187, 2, 11, // 64: case 0x13b: {
2862 OPC_CheckPredicate, 21, // 67: check predicate 21
2863 OPC_CheckField, 11, 5, 9, // 69: check Inst[15:11] == 0x9
2864 OPC_Decode, 181, 10, 153, 1, // 73: decode to CVT_W_D64_MM using decoder 153
2865 // 73: }
2866 240, 2, 7, // 78: case 0x170: {
2867 OPC_CheckPredicate, 21, // 81: check predicate 21
2868 OPC_Decode, 236, 13, 152, 1, // 83: decode to FSUB_D64_MM using decoder 152
2869 // 83: }
2870 176, 3, 7, // 88: case 0x1b0: {
2871 OPC_CheckPredicate, 21, // 91: check predicate 21
2872 OPC_Decode, 192, 13, 152, 1, // 93: decode to FMUL_D64_MM using decoder 152
2873 // 93: }
2874 240, 3, 7, // 98: case 0x1f0: {
2875 OPC_CheckPredicate, 21, // 101: check predicate 21
2876 OPC_Decode, 130, 13, 152, 1, // 103: decode to FDIV_D64_MM using decoder 152
2877 // 103: }
2878 187, 4, 30, // 108: case 0x23b: {
2879 OPC_SwitchField, 11, 5, // 111: switch Inst[15:11] {
2880 8, 7, // 114: case 0x8: {
2881 OPC_CheckPredicate, 21, // 116: check predicate 21
2882 OPC_Decode, 164, 19, 129, 1, // 118: decode to RSQRT_D64_MM using decoder 129
2883 // 118: }
2884 9, 7, // 123: case 0x9: {
2885 OPC_CheckPredicate, 21, // 125: check predicate 21
2886 OPC_Decode, 228, 13, 129, 1, // 127: decode to FSQRT_D64_MM using decoder 129
2887 // 127: }
2888 10, 0, // 132: case 0xa: {
2889 OPC_CheckPredicate, 21, // 134: check predicate 21
2890 OPC_Decode, 131, 19, 129, 1, // 136: decode to RECIP_D64_MM using decoder 129
2891 // 136: }
2892 // 136: } // switch Inst[15:11]
2893 // 136: }
2894 251, 6, 0, // 141: case 0x37b: {
2895 OPC_SwitchField, 11, 5, // 144: switch Inst[15:11] {
2896 2, 7, // 147: case 0x2: {
2897 OPC_CheckPredicate, 21, // 149: check predicate 21
2898 OPC_Decode, 154, 10, 128, 1, // 151: decode to CVT_D64_S_MM using decoder 128
2899 // 151: }
2900 3, 7, // 156: case 0x3: {
2901 OPC_CheckPredicate, 21, // 158: check predicate 21
2902 OPC_Decode, 170, 10, 153, 1, // 160: decode to CVT_S_D64_MM using decoder 153
2903 // 160: }
2904 4, 7, // 165: case 0x4: {
2905 OPC_CheckPredicate, 21, // 167: check predicate 21
2906 OPC_Decode, 212, 12, 129, 1, // 169: decode to FABS_D64_MM using decoder 129
2907 // 169: }
2908 5, 7, // 174: case 0x5: {
2909 OPC_CheckPredicate, 21, // 176: check predicate 21
2910 OPC_Decode, 201, 13, 129, 1, // 178: decode to FNEG_D64_MM using decoder 129
2911 // 178: }
2912 6, 0, // 183: case 0x6: {
2913 OPC_CheckPredicate, 21, // 185: check predicate 21
2914 OPC_Decode, 156, 10, 128, 1, // 187: decode to CVT_D64_W_MM using decoder 128
2915 // 187: }
2916 // 187: } // switch Inst[15:11]
2917 // 187: }
2918 // 187: } // switch Inst[10:0]
2919 // 187: }
2920 46, 7, // 192: case 0x2e: {
2921 OPC_CheckPredicate, 24, // 194: check predicate 24
2922 OPC_Decode, 206, 19, 146, 1, // 196: decode to SDC1_D64_MMR6 using decoder 146
2923 // 196: }
2924 47, 0, // 201: case 0x2f: {
2925 OPC_CheckPredicate, 24, // 203: check predicate 24
2926 OPC_Decode, 241, 14, 146, 1, // 205: decode to LDC1_D64_MMR6 using decoder 146
2927 // 205: }
2928 // 205: } // switch Inst[31:26]
2929};
2930static const uint8_t DecoderTableMicroMipsR632[1966] = {
2931 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
2932 0, 146, 5, // 3: case 0x0: {
2933 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
2934 0, 69, // 9: case 0x0: {
2935 OPC_SwitchField, 6, 5, // 11: switch Inst[10:6] {
2936 0, 35, // 14: case 0x0: {
2937 OPC_Scope, 27, // 16: try {
2938 OPC_SwitchField, 11, 15, // 18: switch Inst[25:11] {
2939 1, 6, // 21: case 0x1: {
2940 OPC_CheckPredicate, 3, // 23: check predicate 3
2941 OPC_Decode, 141, 21, 10, // 25: decode to SSNOP_MMR6 using decoder 10
2942 // 25: }
2943 3, 6, // 29: case 0x3: {
2944 OPC_CheckPredicate, 3, // 31: check predicate 3
2945 OPC_Decode, 167, 12, 10, // 33: decode to EHB_MMR6 using decoder 10
2946 // 33: }
2947 5, 0, // 37: case 0x5: {
2948 OPC_CheckPredicate, 3, // 39: check predicate 3
2949 OPC_Decode, 182, 18, 10, // 41: decode to PAUSE_MMR6 using decoder 10
2950 // 41: }
2951 // 41: } // switch Inst[25:11]
2952 // 41: } else try {
2953 OPC_CheckPredicate, 3, // 45: check predicate 3
2954 OPC_Decode, 201, 20, 58, // 47: decode to SLL_MMR6 using decoder 58
2955 // 47: }
2956 // 47: }
2957 5, 6, // 51: case 0x5: {
2958 OPC_CheckPredicate, 3, // 53: check predicate 3
2959 OPC_Decode, 229, 19, 61, // 55: decode to SELEQZ_MMR6 using decoder 61
2960 // 55: }
2961 6, 6, // 59: case 0x6: {
2962 OPC_CheckPredicate, 3, // 61: check predicate 3
2963 OPC_Decode, 236, 19, 61, // 63: decode to SELNEZ_MMR6 using decoder 61
2964 // 63: }
2965 7, 0, // 67: case 0x7: {
2966 OPC_CheckPredicate, 3, // 69: check predicate 3
2967 OPC_CheckField, 14, 2, 0, // 71: check Inst[15:14] == 0x0
2968 OPC_Decode, 254, 18, 154, 1, // 75: decode to RDHWR_MMR6 using decoder 154
2969 // 75: }
2970 // 75: } // switch Inst[10:6]
2971 // 75: }
2972 7, 6, // 80: case 0x7: {
2973 OPC_CheckPredicate, 3, // 82: check predicate 3
2974 OPC_Decode, 193, 8, 62, // 84: decode to BREAK_MMR6 using decoder 62
2975 // 84: }
2976 12, 6, // 88: case 0xc: {
2977 OPC_CheckPredicate, 3, // 90: check predicate 3
2978 OPC_Decode, 180, 14, 63, // 92: decode to INS_MMR6 using decoder 63
2979 // 92: }
2980 15, 11, // 96: case 0xf: {
2981 OPC_CheckPredicate, 3, // 98: check predicate 3
2982 OPC_CheckField, 6, 3, 0, // 100: check Inst[8:6] == 0x0
2983 OPC_Decode, 162, 15, 155, 1, // 104: decode to LSA_MMR6 using decoder 155
2984 // 104: }
2985 16, 79, // 109: case 0x10: {
2986 OPC_SwitchField, 6, 5, // 111: switch Inst[10:6] {
2987 1, 10, // 114: case 0x1: {
2988 OPC_CheckPredicate, 3, // 116: check predicate 3
2989 OPC_CheckField, 16, 5, 0, // 118: check Inst[20:16] == 0x0
2990 OPC_Decode, 167, 9, 52, // 122: decode to CLZ_MMR6 using decoder 52
2991 // 122: }
2992 4, 6, // 126: case 0x4: {
2993 OPC_CheckPredicate, 3, // 128: check predicate 3
2994 OPC_Decode, 215, 6, 61, // 130: decode to ADD_MMR6 using decoder 61
2995 // 130: }
2996 5, 6, // 134: case 0x5: {
2997 OPC_CheckPredicate, 3, // 136: check predicate 3
2998 OPC_Decode, 191, 6, 61, // 138: decode to ADDU_MMR6 using decoder 61
2999 // 138: }
3000 6, 6, // 142: case 0x6: {
3001 OPC_CheckPredicate, 3, // 144: check predicate 3
3002 OPC_Decode, 201, 21, 61, // 146: decode to SUB_MMR6 using decoder 61
3003 // 146: }
3004 7, 6, // 150: case 0x7: {
3005 OPC_CheckPredicate, 3, // 152: check predicate 3
3006 OPC_Decode, 183, 21, 61, // 154: decode to SUBU_MMR6 using decoder 61
3007 // 154: }
3008 9, 6, // 158: case 0x9: {
3009 OPC_CheckPredicate, 3, // 160: check predicate 3
3010 OPC_Decode, 235, 6, 61, // 162: decode to AND_MMR6 using decoder 61
3011 // 162: }
3012 10, 6, // 166: case 0xa: {
3013 OPC_CheckPredicate, 3, // 168: check predicate 3
3014 OPC_Decode, 172, 18, 61, // 170: decode to OR_MMR6 using decoder 61
3015 // 170: }
3016 11, 6, // 174: case 0xb: {
3017 OPC_CheckPredicate, 3, // 176: check predicate 3
3018 OPC_Decode, 159, 18, 61, // 178: decode to NOR_MMR6 using decoder 61
3019 // 178: }
3020 12, 0, // 182: case 0xc: {
3021 OPC_CheckPredicate, 3, // 184: check predicate 3
3022 OPC_Decode, 226, 22, 61, // 186: decode to XOR_MMR6 using decoder 61
3023 // 186: }
3024 // 186: } // switch Inst[10:6]
3025 // 186: }
3026 24, 67, // 190: case 0x18: {
3027 OPC_SwitchField, 6, 5, // 192: switch Inst[10:6] {
3028 0, 6, // 195: case 0x0: {
3029 OPC_CheckPredicate, 3, // 197: check predicate 3
3030 OPC_Decode, 252, 17, 61, // 199: decode to MUL_MMR6 using decoder 61
3031 // 199: }
3032 1, 6, // 203: case 0x1: {
3033 OPC_CheckPredicate, 3, // 205: check predicate 3
3034 OPC_Decode, 212, 17, 61, // 207: decode to MUH_MMR6 using decoder 61
3035 // 207: }
3036 2, 6, // 211: case 0x2: {
3037 OPC_CheckPredicate, 3, // 213: check predicate 3
3038 OPC_Decode, 246, 17, 61, // 215: decode to MULU_MMR6 using decoder 61
3039 // 215: }
3040 3, 6, // 219: case 0x3: {
3041 OPC_CheckPredicate, 3, // 221: check predicate 3
3042 OPC_Decode, 211, 17, 61, // 223: decode to MUHU_MMR6 using decoder 61
3043 // 223: }
3044 4, 6, // 227: case 0x4: {
3045 OPC_CheckPredicate, 3, // 229: check predicate 3
3046 OPC_Decode, 185, 11, 61, // 231: decode to DIV_MMR6 using decoder 61
3047 // 231: }
3048 5, 6, // 235: case 0x5: {
3049 OPC_CheckPredicate, 3, // 237: check predicate 3
3050 OPC_Decode, 220, 16, 61, // 239: decode to MOD_MMR6 using decoder 61
3051 // 239: }
3052 6, 6, // 243: case 0x6: {
3053 OPC_CheckPredicate, 3, // 245: check predicate 3
3054 OPC_Decode, 184, 11, 61, // 247: decode to DIVU_MMR6 using decoder 61
3055 // 247: }
3056 7, 0, // 251: case 0x7: {
3057 OPC_CheckPredicate, 3, // 253: check predicate 3
3058 OPC_Decode, 219, 16, 61, // 255: decode to MODU_MMR6 using decoder 61
3059 // 255: }
3060 // 255: } // switch Inst[10:6]
3061 // 255: }
3062 31, 11, // 259: case 0x1f: {
3063 OPC_CheckPredicate, 3, // 261: check predicate 3
3064 OPC_CheckField, 6, 3, 0, // 263: check Inst[8:6] == 0x0
3065 OPC_Decode, 223, 6, 156, 1, // 267: decode to ALIGN_MMR6 using decoder 156
3066 // 267: }
3067 44, 6, // 272: case 0x2c: {
3068 OPC_CheckPredicate, 3, // 274: check predicate 3
3069 OPC_Decode, 208, 12, 72, // 276: decode to EXT_MMR6 using decoder 72
3070 // 276: }
3071 52, 27, // 280: case 0x34: {
3072 OPC_SwitchField, 6, 5, // 282: switch Inst[10:6] {
3073 3, 10, // 285: case 0x3: {
3074 OPC_CheckPredicate, 3, // 287: check predicate 3
3075 OPC_CheckField, 14, 2, 0, // 289: check Inst[15:14] == 0x0
3076 OPC_Decode, 166, 16, 74, // 293: decode to MFHC0_MMR6 using decoder 74
3077 // 293: }
3078 11, 0, // 297: case 0xb: {
3079 OPC_CheckPredicate, 3, // 299: check predicate 3
3080 OPC_CheckField, 14, 2, 0, // 301: check Inst[15:14] == 0x0
3081 OPC_Decode, 182, 17, 75, // 305: decode to MTHC0_MMR6 using decoder 75
3082 // 305: }
3083 // 305: } // switch Inst[10:6]
3084 // 305: }
3085 60, 211, 2, // 309: case 0x3c: {
3086 OPC_SwitchField, 14, 2, // 312: switch Inst[15:14] {
3087 0, 81, // 315: case 0x0: {
3088 OPC_SwitchField, 6, 5, // 317: switch Inst[10:6] {
3089 3, 6, // 320: case 0x3: {
3090 OPC_CheckPredicate, 3, // 322: check predicate 3
3091 OPC_Decode, 157, 16, 74, // 324: decode to MFC0_MMR6 using decoder 74
3092 // 324: }
3093 5, 27, // 328: case 0x5: {
3094 OPC_SwitchField, 11, 3, // 330: switch Inst[13:11] {
3095 3, 10, // 333: case 0x3: {
3096 OPC_CheckPredicate, 3, // 335: check predicate 3
3097 OPC_CheckField, 21, 5, 0, // 337: check Inst[25:21] == 0x0
3098 OPC_Decode, 162, 12, 99, // 341: decode to DVP_MMR6 using decoder 99
3099 // 341: }
3100 7, 0, // 345: case 0x7: {
3101 OPC_CheckPredicate, 3, // 347: check predicate 3
3102 OPC_CheckField, 21, 5, 0, // 349: check Inst[25:21] == 0x0
3103 OPC_Decode, 179, 12, 99, // 353: decode to EVP_MMR6 using decoder 99
3104 // 353: }
3105 // 353: } // switch Inst[13:11]
3106 // 353: }
3107 11, 6, // 357: case 0xb: {
3108 OPC_CheckPredicate, 3, // 359: check predicate 3
3109 OPC_Decode, 172, 17, 75, // 361: decode to MTC0_MMR6 using decoder 75
3110 // 361: }
3111 12, 10, // 365: case 0xc: {
3112 OPC_CheckPredicate, 3, // 367: check predicate 3
3113 OPC_CheckField, 11, 3, 1, // 369: check Inst[13:11] == 0x1
3114 OPC_Decode, 249, 7, 93, // 373: decode to BITSWAP_MMR6 using decoder 93
3115 // 373: }
3116 28, 0, // 377: case 0x1c: {
3117 OPC_SwitchField, 11, 3, // 379: switch Inst[13:11] {
3118 1, 6, // 382: case 0x1: {
3119 OPC_CheckPredicate, 3, // 384: check predicate 3
3120 OPC_Decode, 188, 14, 86, // 386: decode to JALRC_MMR6 using decoder 86
3121 // 386: }
3122 3, 0, // 390: case 0x3: {
3123 OPC_CheckPredicate, 3, // 392: check predicate 3
3124 OPC_Decode, 187, 14, 86, // 394: decode to JALRC_HB_MMR6 using decoder 86
3125 // 394: }
3126 // 394: } // switch Inst[13:11]
3127 // 394: }
3128 // 394: } // switch Inst[10:6]
3129 // 394: }
3130 1, 155, 1, // 398: case 0x1: {
3131 OPC_SwitchField, 11, 3, // 401: switch Inst[13:11] {
3132 0, 27, // 404: case 0x0: {
3133 OPC_SwitchField, 6, 5, // 406: switch Inst[10:6] {
3134 13, 10, // 409: case 0xd: {
3135 OPC_CheckPredicate, 3, // 411: check predicate 3
3136 OPC_CheckField, 16, 10, 0, // 413: check Inst[25:16] == 0x0
3137 OPC_Decode, 169, 22, 10, // 417: decode to TLBINV_MMR6 using decoder 10
3138 // 417: }
3139 29, 0, // 421: case 0x1d: {
3140 OPC_CheckPredicate, 3, // 423: check predicate 3
3141 OPC_CheckField, 21, 5, 0, // 425: check Inst[25:21] == 0x0
3142 OPC_Decode, 195, 11, 99, // 429: decode to DI_MMR6 using decoder 99
3143 // 429: }
3144 // 429: } // switch Inst[10:6]
3145 // 429: }
3146 1, 19, // 433: case 0x1: {
3147 OPC_SwitchField, 6, 5, // 435: switch Inst[10:6] {
3148 12, 6, // 438: case 0xc: {
3149 OPC_CheckPredicate, 3, // 440: check predicate 3
3150 OPC_Decode, 147, 9, 86, // 442: decode to CLO_MMR6 using decoder 86
3151 // 442: }
3152 20, 0, // 446: case 0x14: {
3153 OPC_CheckPredicate, 3, // 448: check predicate 3
3154 OPC_Decode, 163, 16, 97, // 450: decode to MFC2_MMR6 using decoder 97
3155 // 450: }
3156 // 450: } // switch Inst[10:6]
3157 // 450: }
3158 2, 27, // 454: case 0x2: {
3159 OPC_SwitchField, 6, 5, // 456: switch Inst[10:6] {
3160 13, 10, // 459: case 0xd: {
3161 OPC_CheckPredicate, 3, // 461: check predicate 3
3162 OPC_CheckField, 16, 10, 0, // 463: check Inst[25:16] == 0x0
3163 OPC_Decode, 168, 22, 10, // 467: decode to TLBINVF_MMR6 using decoder 10
3164 // 467: }
3165 29, 0, // 471: case 0x1d: {
3166 OPC_CheckPredicate, 3, // 473: check predicate 3
3167 OPC_CheckField, 21, 5, 0, // 475: check Inst[25:21] == 0x0
3168 OPC_Decode, 170, 12, 99, // 479: decode to EI_MMR6 using decoder 99
3169 // 479: }
3170 // 479: } // switch Inst[10:6]
3171 // 479: }
3172 3, 10, // 483: case 0x3: {
3173 OPC_CheckPredicate, 3, // 485: check predicate 3
3174 OPC_CheckField, 6, 5, 20, // 487: check Inst[10:6] == 0x14
3175 OPC_Decode, 179, 17, 98, // 491: decode to MTC2_MMR6 using decoder 98
3176 // 491: }
3177 4, 14, // 495: case 0x4: {
3178 OPC_CheckPredicate, 25, // 497: check predicate 25
3179 OPC_CheckField, 21, 5, 0, // 499: check Inst[25:21] == 0x0
3180 OPC_CheckField, 6, 5, 5, // 503: check Inst[10:6] == 0x5
3181 OPC_Decode, 135, 14, 99, // 507: decode to GINVI_MMR6 using decoder 99
3182 // 507: }
3183 5, 14, // 511: case 0x5: {
3184 OPC_CheckPredicate, 3, // 513: check predicate 3
3185 OPC_CheckField, 21, 5, 0, // 515: check Inst[25:21] == 0x0
3186 OPC_CheckField, 6, 5, 13, // 519: check Inst[10:6] == 0xd
3187 OPC_Decode, 246, 21, 94, // 523: decode to SYNC_MMR6 using decoder 94
3188 // 523: }
3189 6, 15, // 527: case 0x6: {
3190 OPC_CheckPredicate, 25, // 529: check predicate 25
3191 OPC_CheckField, 21, 5, 0, // 531: check Inst[25:21] == 0x0
3192 OPC_CheckField, 6, 3, 5, // 535: check Inst[8:6] == 0x5
3193 OPC_Decode, 137, 14, 157, 1, // 539: decode to GINVT_MMR6 using decoder 157
3194 // 539: }
3195 7, 0, // 544: case 0x7: {
3196 OPC_CheckPredicate, 3, // 546: check predicate 3
3197 OPC_CheckField, 6, 5, 12, // 548: check Inst[10:6] == 0xc
3198 OPC_Decode, 218, 22, 86, // 552: decode to WSBH_MMR6 using decoder 86
3199 // 552: }
3200 // 552: } // switch Inst[13:11]
3201 // 552: }
3202 2, 27, // 556: case 0x2: {
3203 OPC_SwitchField, 6, 8, // 558: switch Inst[13:6] {
3204 52, 6, // 561: case 0x34: {
3205 OPC_CheckPredicate, 3, // 563: check predicate 3
3206 OPC_Decode, 171, 16, 97, // 565: decode to MFHC2_MMR6 using decoder 97
3207 // 565: }
3208 77, 6, // 569: case 0x4d: {
3209 OPC_CheckPredicate, 3, // 571: check predicate 3
3210 OPC_Decode, 212, 22, 95, // 573: decode to WAIT_MMR6 using decoder 95
3211 // 573: }
3212 116, 0, // 577: case 0x74: {
3213 OPC_CheckPredicate, 3, // 579: check predicate 3
3214 OPC_Decode, 187, 17, 98, // 581: decode to MTHC2_MMR6 using decoder 98
3215 // 581: }
3216 // 581: } // switch Inst[13:6]
3217 // 581: }
3218 3, 0, // 585: case 0x3: {
3219 OPC_SwitchField, 6, 8, // 587: switch Inst[13:6] {
3220 109, 6, // 590: case 0x6d: {
3221 OPC_CheckPredicate, 3, // 592: check predicate 3
3222 OPC_Decode, 202, 19, 95, // 594: decode to SDBBP_MMR6 using decoder 95
3223 // 594: }
3224 133, 1, 6, // 598: case 0x85: {
3225 OPC_CheckPredicate, 3, // 601: check predicate 3
3226 OPC_Decode, 255, 18, 86, // 603: decode to RDPGPR_MMR6 using decoder 86
3227 // 603: }
3228 141, 1, 10, // 607: case 0x8d: {
3229 OPC_CheckPredicate, 3, // 610: check predicate 3
3230 OPC_CheckField, 16, 10, 0, // 612: check Inst[25:16] == 0x0
3231 OPC_Decode, 173, 11, 10, // 616: decode to DERET_MMR6 using decoder 10
3232 // 616: }
3233 197, 1, 6, // 620: case 0xc5: {
3234 OPC_CheckPredicate, 3, // 623: check predicate 3
3235 OPC_Decode, 215, 22, 86, // 625: decode to WRPGPR_MMR6 using decoder 86
3236 // 625: }
3237 205, 1, 0, // 629: case 0xcd: {
3238 OPC_SwitchField, 16, 10, // 632: switch Inst[25:16] {
3239 0, 6, // 635: case 0x0: {
3240 OPC_CheckPredicate, 3, // 637: check predicate 3
3241 OPC_Decode, 176, 12, 10, // 639: decode to ERET_MMR6 using decoder 10
3242 // 639: }
3243 1, 0, // 643: case 0x1: {
3244 OPC_CheckPredicate, 3, // 645: check predicate 3
3245 OPC_Decode, 174, 12, 10, // 647: decode to ERETNC_MMR6 using decoder 10
3246 // 647: }
3247 // 647: } // switch Inst[25:16]
3248 // 647: }
3249 // 647: } // switch Inst[13:6]
3250 // 647: }
3251 // 647: } // switch Inst[15:14]
3252 // 647: }
3253 63, 0, // 651: case 0x3f: {
3254 OPC_CheckPredicate, 3, // 653: check predicate 3
3255 OPC_CheckField, 22, 4, 0, // 655: check Inst[25:22] == 0x0
3256 OPC_Decode, 177, 20, 158, 1, // 659: decode to SIGRIE_MMR6 using decoder 158
3257 // 659: }
3258 // 659: } // switch Inst[5:0]
3259 // 659: }
3260 4, 19, // 664: case 0x4: {
3261 OPC_Scope, 11, // 666: try {
3262 OPC_CheckField, 16, 5, 0, // 668: check Inst[20:16] == 0x0
3263 OPC_CheckPredicate, 3, // 672: check predicate 3
3264 OPC_Decode, 164, 15, 159, 1, // 674: decode to LUI_MMR6 using decoder 159
3265 // 674: } else try {
3266 OPC_CheckPredicate, 3, // 679: check predicate 3
3267 OPC_Decode, 253, 6, 115, // 681: decode to AUI_MMR6 using decoder 115
3268 // 681: }
3269 // 681: }
3270 5, 7, // 685: case 0x5: {
3271 OPC_CheckPredicate, 3, // 687: check predicate 3
3272 OPC_Decode, 230, 14, 160, 1, // 689: decode to LBU_MMR6 using decoder 160
3273 // 689: }
3274 6, 6, // 694: case 0x6: {
3275 OPC_CheckPredicate, 3, // 696: check predicate 3
3276 OPC_Decode, 186, 19, 105, // 698: decode to SB_MMR6 using decoder 105
3277 // 698: }
3278 7, 7, // 702: case 0x7: {
3279 OPC_CheckPredicate, 3, // 704: check predicate 3
3280 OPC_Decode, 232, 14, 160, 1, // 706: decode to LB_MMR6 using decoder 160
3281 // 706: }
3282 8, 63, // 711: case 0x8: {
3283 OPC_SwitchField, 12, 4, // 713: switch Inst[15:12] {
3284 0, 11, // 716: case 0x0: {
3285 OPC_CheckPredicate, 3, // 718: check predicate 3
3286 OPC_CheckField, 11, 1, 0, // 720: check Inst[11] == 0x0
3287 OPC_Decode, 177, 15, 161, 1, // 724: decode to LWC2_MMR6 using decoder 161
3288 // 724: }
3289 2, 11, // 729: case 0x2: {
3290 OPC_CheckPredicate, 3, // 731: check predicate 3
3291 OPC_CheckField, 11, 1, 0, // 733: check Inst[11] == 0x0
3292 OPC_Decode, 245, 14, 161, 1, // 737: decode to LDC2_MMR6 using decoder 161
3293 // 737: }
3294 6, 6, // 742: case 0x6: {
3295 OPC_CheckPredicate, 3, // 744: check predicate 3
3296 OPC_Decode, 224, 8, 107, // 746: decode to CACHE_MMR6 using decoder 107
3297 // 746: }
3298 8, 11, // 750: case 0x8: {
3299 OPC_CheckPredicate, 3, // 752: check predicate 3
3300 OPC_CheckField, 11, 1, 0, // 754: check Inst[11] == 0x0
3301 OPC_Decode, 214, 21, 161, 1, // 758: decode to SWC2_MMR6 using decoder 161
3302 // 758: }
3303 10, 0, // 763: case 0xa: {
3304 OPC_CheckPredicate, 3, // 765: check predicate 3
3305 OPC_CheckField, 11, 1, 0, // 767: check Inst[11] == 0x0
3306 OPC_Decode, 210, 19, 161, 1, // 771: decode to SDC2_MMR6 using decoder 161
3307 // 771: }
3308 // 771: } // switch Inst[15:12]
3309 // 771: }
3310 12, 6, // 776: case 0xc: {
3311 OPC_CheckPredicate, 3, // 778: check predicate 3
3312 OPC_Decode, 155, 6, 104, // 780: decode to ADDIU_MMR6 using decoder 104
3313 // 780: }
3314 14, 6, // 784: case 0xe: {
3315 OPC_CheckPredicate, 3, // 786: check predicate 3
3316 OPC_Decode, 175, 20, 105, // 788: decode to SH_MMR6 using decoder 105
3317 // 788: }
3318 16, 48, // 792: case 0x10: {
3319 OPC_SwitchField, 21, 5, // 794: switch Inst[25:21] {
3320 8, 7, // 797: case 0x8: {
3321 OPC_CheckPredicate, 26, // 799: check predicate 26
3322 OPC_Decode, 165, 7, 162, 1, // 801: decode to BC1EQZC_MMR6 using decoder 162
3323 // 801: }
3324 9, 7, // 806: case 0x9: {
3325 OPC_CheckPredicate, 26, // 808: check predicate 26
3326 OPC_Decode, 170, 7, 162, 1, // 810: decode to BC1NEZC_MMR6 using decoder 162
3327 // 810: }
3328 10, 7, // 815: case 0xa: {
3329 OPC_CheckPredicate, 3, // 817: check predicate 3
3330 OPC_Decode, 175, 7, 163, 1, // 819: decode to BC2EQZC_MMR6 using decoder 163
3331 // 819: }
3332 11, 7, // 824: case 0xb: {
3333 OPC_CheckPredicate, 3, // 826: check predicate 3
3334 OPC_Decode, 177, 7, 163, 1, // 828: decode to BC2NEZC_MMR6 using decoder 163
3335 // 828: }
3336 12, 0, // 833: case 0xc: {
3337 OPC_CheckPredicate, 3, // 835: check predicate 3
3338 OPC_Decode, 244, 21, 164, 1, // 837: decode to SYNCI_MMR6 using decoder 164
3339 // 837: }
3340 // 837: } // switch Inst[25:21]
3341 // 837: }
3342 20, 6, // 842: case 0x14: {
3343 OPC_CheckPredicate, 3, // 844: check predicate 3
3344 OPC_Decode, 170, 18, 115, // 846: decode to ORI_MMR6 using decoder 115
3345 // 846: }
3346 21, 216, 6, // 850: case 0x15: {
3347 OPC_SwitchField, 0, 11, // 853: switch Inst[10:0] {
3348 3, 7, // 856: case 0x3: {
3349 OPC_CheckPredicate, 26, // 858: check predicate 26
3350 OPC_Decode, 209, 16, 165, 1, // 860: decode to MIN_S_MMR6 using decoder 165
3351 // 860: }
3352 5, 7, // 865: case 0x5: {
3353 OPC_CheckPredicate, 26, // 867: check predicate 26
3354 OPC_Decode, 188, 9, 166, 1, // 869: decode to CMP_AF_S_MMR6 using decoder 166
3355 // 869: }
3356 11, 7, // 874: case 0xb: {
3357 OPC_CheckPredicate, 26, // 876: check predicate 26
3358 OPC_Decode, 150, 16, 165, 1, // 878: decode to MAX_S_MMR6 using decoder 165
3359 // 878: }
3360 21, 7, // 883: case 0x15: {
3361 OPC_CheckPredicate, 26, // 885: check predicate 26
3362 OPC_Decode, 187, 9, 167, 1, // 887: decode to CMP_AF_D_MMR6 using decoder 167
3363 // 887: }
3364 32, 11, // 892: case 0x20: {
3365 OPC_CheckPredicate, 3, // 894: check predicate 3
3366 OPC_CheckField, 11, 5, 0, // 896: check Inst[15:11] == 0x0
3367 OPC_Decode, 145, 19, 168, 1, // 900: decode to RINT_S_MMR6 using decoder 168
3368 // 900: }
3369 35, 7, // 905: case 0x23: {
3370 OPC_CheckPredicate, 26, // 907: check predicate 26
3371 OPC_Decode, 190, 16, 165, 1, // 909: decode to MINA_S_MMR6 using decoder 165
3372 // 909: }
3373 43, 7, // 914: case 0x2b: {
3374 OPC_CheckPredicate, 26, // 916: check predicate 26
3375 OPC_Decode, 131, 16, 165, 1, // 918: decode to MAXA_S_MMR6 using decoder 165
3376 // 918: }
3377 48, 7, // 923: case 0x30: {
3378 OPC_CheckPredicate, 26, // 925: check predicate 26
3379 OPC_Decode, 223, 12, 169, 1, // 927: decode to FADD_S_MMR6 using decoder 169
3380 // 927: }
3381 56, 7, // 932: case 0x38: {
3382 OPC_CheckPredicate, 3, // 934: check predicate 3
3383 OPC_Decode, 231, 19, 165, 1, // 936: decode to SELEQZ_S_MMR6 using decoder 165
3384 // 936: }
3385 59, 20, // 941: case 0x3b: {
3386 OPC_SwitchField, 11, 5, // 943: switch Inst[15:11] {
3387 4, 6, // 946: case 0x4: {
3388 OPC_CheckPredicate, 26, // 948: check predicate 26
3389 OPC_Decode, 161, 16, 126, // 950: decode to MFC1_MMR6 using decoder 126
3390 // 950: }
3391 5, 0, // 954: case 0x5: {
3392 OPC_CheckPredicate, 26, // 956: check predicate 26
3393 OPC_Decode, 177, 17, 132, 1, // 958: decode to MTC1_MMR6 using decoder 132
3394 // 958: }
3395 // 958: } // switch Inst[15:11]
3396 // 958: }
3397 69, 7, // 963: case 0x45: {
3398 OPC_CheckPredicate, 26, // 965: check predicate 26
3399 OPC_Decode, 128, 10, 166, 1, // 967: decode to CMP_UN_S_MMR6 using decoder 166
3400 // 967: }
3401 85, 7, // 972: case 0x55: {
3402 OPC_CheckPredicate, 26, // 974: check predicate 26
3403 OPC_Decode, 254, 9, 167, 1, // 976: decode to CMP_UN_D_MMR6 using decoder 167
3404 // 976: }
3405 96, 11, // 981: case 0x60: {
3406 OPC_CheckPredicate, 3, // 983: check predicate 3
3407 OPC_CheckField, 11, 5, 0, // 985: check Inst[15:11] == 0x0
3408 OPC_Decode, 128, 9, 168, 1, // 989: decode to CLASS_S_MMR6 using decoder 168
3409 // 989: }
3410 112, 7, // 994: case 0x70: {
3411 OPC_CheckPredicate, 26, // 996: check predicate 26
3412 OPC_Decode, 240, 13, 169, 1, // 998: decode to FSUB_S_MMR6 using decoder 169
3413 // 998: }
3414 120, 7, // 1003: case 0x78: {
3415 OPC_CheckPredicate, 3, // 1005: check predicate 3
3416 OPC_Decode, 238, 19, 165, 1, // 1007: decode to SELNEZ_S_MMR6 using decoder 165
3417 // 1007: }
3418 123, 21, // 1012: case 0x7b: {
3419 OPC_SwitchField, 11, 5, // 1014: switch Inst[15:11] {
3420 0, 7, // 1017: case 0x0: {
3421 OPC_CheckPredicate, 26, // 1019: check predicate 26
3422 OPC_Decode, 185, 13, 131, 1, // 1021: decode to FMOV_S_MMR6 using decoder 131
3423 // 1021: }
3424 4, 0, // 1026: case 0x4: {
3425 OPC_CheckPredicate, 26, // 1028: check predicate 26
3426 OPC_Decode, 182, 13, 129, 1, // 1030: decode to FMOV_D_MMR6 using decoder 129
3427 // 1030: }
3428 // 1030: } // switch Inst[15:11]
3429 // 1030: }
3430 133, 1, 7, // 1035: case 0x85: {
3431 OPC_CheckPredicate, 26, // 1038: check predicate 26
3432 OPC_Decode, 194, 9, 166, 1, // 1040: decode to CMP_EQ_S_MMR6 using decoder 166
3433 // 1040: }
3434 149, 1, 7, // 1045: case 0x95: {
3435 OPC_CheckPredicate, 26, // 1048: check predicate 26
3436 OPC_Decode, 190, 9, 167, 1, // 1050: decode to CMP_EQ_D_MMR6 using decoder 167
3437 // 1050: }
3438 176, 1, 7, // 1055: case 0xb0: {
3439 OPC_CheckPredicate, 26, // 1058: check predicate 26
3440 OPC_Decode, 196, 13, 169, 1, // 1060: decode to FMUL_S_MMR6 using decoder 169
3441 // 1060: }
3442 184, 1, 7, // 1065: case 0xb8: {
3443 OPC_CheckPredicate, 3, // 1068: check predicate 3
3444 OPC_Decode, 242, 19, 170, 1, // 1070: decode to SEL_S_MMR6 using decoder 170
3445 // 1070: }
3446 197, 1, 7, // 1075: case 0xc5: {
3447 OPC_CheckPredicate, 26, // 1078: check predicate 26
3448 OPC_Decode, 244, 9, 166, 1, // 1080: decode to CMP_UEQ_S_MMR6 using decoder 166
3449 // 1080: }
3450 213, 1, 7, // 1085: case 0xd5: {
3451 OPC_CheckPredicate, 26, // 1088: check predicate 26
3452 OPC_Decode, 242, 9, 167, 1, // 1090: decode to CMP_UEQ_D_MMR6 using decoder 167
3453 // 1090: }
3454 240, 1, 7, // 1095: case 0xf0: {
3455 OPC_CheckPredicate, 26, // 1098: check predicate 26
3456 OPC_Decode, 133, 13, 169, 1, // 1100: decode to FDIV_S_MMR6 using decoder 169
3457 // 1100: }
3458 133, 2, 7, // 1105: case 0x105: {
3459 OPC_CheckPredicate, 26, // 1108: check predicate 26
3460 OPC_Decode, 208, 9, 166, 1, // 1110: decode to CMP_LT_S_MMR6 using decoder 166
3461 // 1110: }
3462 149, 2, 7, // 1115: case 0x115: {
3463 OPC_CheckPredicate, 26, // 1118: check predicate 26
3464 OPC_Decode, 204, 9, 167, 1, // 1120: decode to CMP_LT_D_MMR6 using decoder 167
3465 // 1120: }
3466 187, 2, 30, // 1125: case 0x13b: {
3467 OPC_SwitchField, 11, 5, // 1128: switch Inst[15:11] {
3468 0, 7, // 1131: case 0x0: {
3469 OPC_CheckPredicate, 26, // 1133: check predicate 26
3470 OPC_Decode, 163, 10, 128, 1, // 1135: decode to CVT_L_S_MMR6 using decoder 128
3471 // 1135: }
3472 1, 7, // 1140: case 0x1: {
3473 OPC_CheckPredicate, 26, // 1142: check predicate 26
3474 OPC_Decode, 184, 10, 131, 1, // 1144: decode to CVT_W_S_MMR6 using decoder 131
3475 // 1144: }
3476 8, 0, // 1149: case 0x8: {
3477 OPC_CheckPredicate, 26, // 1151: check predicate 26
3478 OPC_Decode, 160, 10, 129, 1, // 1153: decode to CVT_L_D_MMR6 using decoder 129
3479 // 1153: }
3480 // 1153: } // switch Inst[15:11]
3481 // 1153: }
3482 197, 2, 7, // 1158: case 0x145: {
3483 OPC_CheckPredicate, 26, // 1161: check predicate 26
3484 OPC_Decode, 252, 9, 166, 1, // 1163: decode to CMP_ULT_S_MMR6 using decoder 166
3485 // 1163: }
3486 213, 2, 7, // 1168: case 0x155: {
3487 OPC_CheckPredicate, 26, // 1171: check predicate 26
3488 OPC_Decode, 250, 9, 167, 1, // 1173: decode to CMP_ULT_D_MMR6 using decoder 167
3489 // 1173: }
3490 133, 3, 7, // 1178: case 0x185: {
3491 OPC_CheckPredicate, 26, // 1181: check predicate 26
3492 OPC_Decode, 202, 9, 166, 1, // 1183: decode to CMP_LE_S_MMR6 using decoder 166
3493 // 1183: }
3494 149, 3, 7, // 1188: case 0x195: {
3495 OPC_CheckPredicate, 26, // 1191: check predicate 26
3496 OPC_Decode, 198, 9, 167, 1, // 1193: decode to CMP_LE_D_MMR6 using decoder 167
3497 // 1193: }
3498 184, 3, 7, // 1198: case 0x1b8: {
3499 OPC_CheckPredicate, 26, // 1201: check predicate 26
3500 OPC_Decode, 227, 15, 171, 1, // 1203: decode to MADDF_S_MMR6 using decoder 171
3501 // 1203: }
3502 197, 3, 7, // 1208: case 0x1c5: {
3503 OPC_CheckPredicate, 26, // 1211: check predicate 26
3504 OPC_Decode, 248, 9, 166, 1, // 1213: decode to CMP_ULE_S_MMR6 using decoder 166
3505 // 1213: }
3506 213, 3, 7, // 1218: case 0x1d5: {
3507 OPC_CheckPredicate, 26, // 1221: check predicate 26
3508 OPC_Decode, 246, 9, 167, 1, // 1223: decode to CMP_ULE_D_MMR6 using decoder 167
3509 // 1223: }
3510 248, 3, 7, // 1228: case 0x1f8: {
3511 OPC_CheckPredicate, 26, // 1231: check predicate 26
3512 OPC_Decode, 150, 17, 171, 1, // 1233: decode to MSUBF_S_MMR6 using decoder 171
3513 // 1233: }
3514 131, 4, 7, // 1238: case 0x203: {
3515 OPC_CheckPredicate, 26, // 1241: check predicate 26
3516 OPC_Decode, 204, 16, 152, 1, // 1243: decode to MIN_D_MMR6 using decoder 152
3517 // 1243: }
3518 133, 4, 7, // 1248: case 0x205: {
3519 OPC_CheckPredicate, 26, // 1251: check predicate 26
3520 OPC_Decode, 212, 9, 166, 1, // 1253: decode to CMP_SAF_S_MMR6 using decoder 166
3521 // 1253: }
3522 139, 4, 7, // 1258: case 0x20b: {
3523 OPC_CheckPredicate, 26, // 1261: check predicate 26
3524 OPC_Decode, 145, 16, 152, 1, // 1263: decode to MAX_D_MMR6 using decoder 152
3525 // 1263: }
3526 149, 4, 7, // 1268: case 0x215: {
3527 OPC_CheckPredicate, 26, // 1271: check predicate 26
3528 OPC_Decode, 210, 9, 167, 1, // 1273: decode to CMP_SAF_D_MMR6 using decoder 167
3529 // 1273: }
3530 160, 4, 11, // 1278: case 0x220: {
3531 OPC_CheckPredicate, 3, // 1281: check predicate 3
3532 OPC_CheckField, 11, 5, 0, // 1283: check Inst[15:11] == 0x0
3533 OPC_Decode, 143, 19, 172, 1, // 1287: decode to RINT_D_MMR6 using decoder 172
3534 // 1287: }
3535 163, 4, 7, // 1292: case 0x223: {
3536 OPC_CheckPredicate, 26, // 1295: check predicate 26
3537 OPC_Decode, 188, 16, 152, 1, // 1297: decode to MINA_D_MMR6 using decoder 152
3538 // 1297: }
3539 171, 4, 7, // 1302: case 0x22b: {
3540 OPC_CheckPredicate, 26, // 1305: check predicate 26
3541 OPC_Decode, 129, 16, 152, 1, // 1307: decode to MAXA_D_MMR6 using decoder 152
3542 // 1307: }
3543 184, 4, 7, // 1312: case 0x238: {
3544 OPC_CheckPredicate, 3, // 1315: check predicate 3
3545 OPC_Decode, 228, 19, 152, 1, // 1317: decode to SELEQZ_D_MMR6 using decoder 152
3546 // 1317: }
3547 197, 4, 7, // 1322: case 0x245: {
3548 OPC_CheckPredicate, 26, // 1325: check predicate 26
3549 OPC_Decode, 240, 9, 166, 1, // 1327: decode to CMP_SUN_S_MMR6 using decoder 166
3550 // 1327: }
3551 213, 4, 7, // 1332: case 0x255: {
3552 OPC_CheckPredicate, 26, // 1335: check predicate 26
3553 OPC_Decode, 238, 9, 167, 1, // 1337: decode to CMP_SUN_D_MMR6 using decoder 167
3554 // 1337: }
3555 224, 4, 11, // 1342: case 0x260: {
3556 OPC_CheckPredicate, 3, // 1345: check predicate 3
3557 OPC_CheckField, 11, 5, 0, // 1347: check Inst[15:11] == 0x0
3558 OPC_Decode, 254, 8, 172, 1, // 1351: decode to CLASS_D_MMR6 using decoder 172
3559 // 1351: }
3560 248, 4, 7, // 1356: case 0x278: {
3561 OPC_CheckPredicate, 3, // 1359: check predicate 3
3562 OPC_Decode, 235, 19, 152, 1, // 1361: decode to SELNEZ_D_MMR6 using decoder 152
3563 // 1361: }
3564 133, 5, 7, // 1366: case 0x285: {
3565 OPC_CheckPredicate, 26, // 1369: check predicate 26
3566 OPC_Decode, 216, 9, 166, 1, // 1371: decode to CMP_SEQ_S_MMR6 using decoder 166
3567 // 1371: }
3568 149, 5, 7, // 1376: case 0x295: {
3569 OPC_CheckPredicate, 26, // 1379: check predicate 26
3570 OPC_Decode, 214, 9, 167, 1, // 1381: decode to CMP_SEQ_D_MMR6 using decoder 167
3571 // 1381: }
3572 184, 5, 7, // 1386: case 0x2b8: {
3573 OPC_CheckPredicate, 3, // 1389: check predicate 3
3574 OPC_Decode, 240, 19, 173, 1, // 1391: decode to SEL_D_MMR6 using decoder 173
3575 // 1391: }
3576 197, 5, 7, // 1396: case 0x2c5: {
3577 OPC_CheckPredicate, 26, // 1399: check predicate 26
3578 OPC_Decode, 228, 9, 166, 1, // 1401: decode to CMP_SUEQ_S_MMR6 using decoder 166
3579 // 1401: }
3580 213, 5, 7, // 1406: case 0x2d5: {
3581 OPC_CheckPredicate, 26, // 1409: check predicate 26
3582 OPC_Decode, 226, 9, 167, 1, // 1411: decode to CMP_SUEQ_D_MMR6 using decoder 167
3583 // 1411: }
3584 133, 6, 7, // 1416: case 0x305: {
3585 OPC_CheckPredicate, 26, // 1419: check predicate 26
3586 OPC_Decode, 224, 9, 166, 1, // 1421: decode to CMP_SLT_S_MMR6 using decoder 166
3587 // 1421: }
3588 149, 6, 7, // 1426: case 0x315: {
3589 OPC_CheckPredicate, 26, // 1429: check predicate 26
3590 OPC_Decode, 222, 9, 167, 1, // 1431: decode to CMP_SLT_D_MMR6 using decoder 167
3591 // 1431: }
3592 187, 6, 147, 1, // 1436: case 0x33b: {
3593 OPC_SwitchField, 11, 5, // 1440: switch Inst[15:11] {
3594 0, 7, // 1443: case 0x0: {
3595 OPC_CheckPredicate, 26, // 1445: check predicate 26
3596 OPC_Decode, 160, 13, 128, 1, // 1447: decode to FLOOR_L_S_MMR6 using decoder 128
3597 // 1447: }
3598 1, 7, // 1452: case 0x1: {
3599 OPC_CheckPredicate, 26, // 1454: check predicate 26
3600 OPC_Decode, 167, 13, 131, 1, // 1456: decode to FLOOR_W_S_MMR6 using decoder 131
3601 // 1456: }
3602 2, 7, // 1461: case 0x2: {
3603 OPC_CheckPredicate, 26, // 1463: check predicate 26
3604 OPC_Decode, 229, 8, 128, 1, // 1465: decode to CEIL_L_S_MMR6 using decoder 128
3605 // 1465: }
3606 3, 7, // 1470: case 0x3: {
3607 OPC_CheckPredicate, 26, // 1472: check predicate 26
3608 OPC_Decode, 236, 8, 131, 1, // 1474: decode to CEIL_W_S_MMR6 using decoder 131
3609 // 1474: }
3610 4, 7, // 1479: case 0x4: {
3611 OPC_CheckPredicate, 26, // 1481: check predicate 26
3612 OPC_Decode, 192, 22, 128, 1, // 1483: decode to TRUNC_L_S_MMR6 using decoder 128
3613 // 1483: }
3614 5, 7, // 1488: case 0x5: {
3615 OPC_CheckPredicate, 26, // 1490: check predicate 26
3616 OPC_Decode, 199, 22, 131, 1, // 1492: decode to TRUNC_W_S_MMR6 using decoder 131
3617 // 1492: }
3618 6, 7, // 1497: case 0x6: {
3619 OPC_CheckPredicate, 26, // 1499: check predicate 26
3620 OPC_Decode, 153, 19, 128, 1, // 1501: decode to ROUND_L_S_MMR6 using decoder 128
3621 // 1501: }
3622 7, 7, // 1506: case 0x7: {
3623 OPC_CheckPredicate, 26, // 1508: check predicate 26
3624 OPC_Decode, 160, 19, 131, 1, // 1510: decode to ROUND_W_S_MMR6 using decoder 131
3625 // 1510: }
3626 8, 7, // 1515: case 0x8: {
3627 OPC_CheckPredicate, 26, // 1517: check predicate 26
3628 OPC_Decode, 158, 13, 129, 1, // 1519: decode to FLOOR_L_D_MMR6 using decoder 129
3629 // 1519: }
3630 9, 7, // 1524: case 0x9: {
3631 OPC_CheckPredicate, 26, // 1526: check predicate 26
3632 OPC_Decode, 163, 13, 133, 1, // 1528: decode to FLOOR_W_D_MMR6 using decoder 133
3633 // 1528: }
3634 10, 7, // 1533: case 0xa: {
3635 OPC_CheckPredicate, 26, // 1535: check predicate 26
3636 OPC_Decode, 227, 8, 129, 1, // 1537: decode to CEIL_L_D_MMR6 using decoder 129
3637 // 1537: }
3638 11, 7, // 1542: case 0xb: {
3639 OPC_CheckPredicate, 26, // 1544: check predicate 26
3640 OPC_Decode, 232, 8, 133, 1, // 1546: decode to CEIL_W_D_MMR6 using decoder 133
3641 // 1546: }
3642 12, 7, // 1551: case 0xc: {
3643 OPC_CheckPredicate, 26, // 1553: check predicate 26
3644 OPC_Decode, 190, 22, 129, 1, // 1555: decode to TRUNC_L_D_MMR6 using decoder 129
3645 // 1555: }
3646 13, 7, // 1560: case 0xd: {
3647 OPC_CheckPredicate, 26, // 1562: check predicate 26
3648 OPC_Decode, 195, 22, 153, 1, // 1564: decode to TRUNC_W_D_MMR6 using decoder 153
3649 // 1564: }
3650 14, 7, // 1569: case 0xe: {
3651 OPC_CheckPredicate, 26, // 1571: check predicate 26
3652 OPC_Decode, 151, 19, 129, 1, // 1573: decode to ROUND_L_D_MMR6 using decoder 129
3653 // 1573: }
3654 15, 0, // 1578: case 0xf: {
3655 OPC_CheckPredicate, 26, // 1580: check predicate 26
3656 OPC_Decode, 156, 19, 129, 1, // 1582: decode to ROUND_W_D_MMR6 using decoder 129
3657 // 1582: }
3658 // 1582: } // switch Inst[15:11]
3659 // 1582: }
3660 197, 6, 7, // 1587: case 0x345: {
3661 OPC_CheckPredicate, 26, // 1590: check predicate 26
3662 OPC_Decode, 236, 9, 166, 1, // 1592: decode to CMP_SULT_S_MMR6 using decoder 166
3663 // 1592: }
3664 213, 6, 7, // 1597: case 0x355: {
3665 OPC_CheckPredicate, 26, // 1600: check predicate 26
3666 OPC_Decode, 234, 9, 167, 1, // 1602: decode to CMP_SULT_D_MMR6 using decoder 167
3667 // 1602: }
3668 251, 6, 39, // 1607: case 0x37b: {
3669 OPC_SwitchField, 11, 5, // 1610: switch Inst[15:11] {
3670 1, 7, // 1613: case 0x1: {
3671 OPC_CheckPredicate, 26, // 1615: check predicate 26
3672 OPC_Decode, 204, 13, 131, 1, // 1617: decode to FNEG_S_MMR6 using decoder 131
3673 // 1617: }
3674 7, 7, // 1622: case 0x7: {
3675 OPC_CheckPredicate, 26, // 1624: check predicate 26
3676 OPC_Decode, 177, 10, 131, 1, // 1626: decode to CVT_S_W_MMR6 using decoder 131
3677 // 1626: }
3678 10, 7, // 1631: case 0xa: {
3679 OPC_CheckPredicate, 24, // 1633: check predicate 24
3680 OPC_Decode, 157, 10, 129, 1, // 1635: decode to CVT_D_L_MMR6 using decoder 129
3681 // 1635: }
3682 11, 0, // 1640: case 0xb: {
3683 OPC_CheckPredicate, 24, // 1642: check predicate 24
3684 OPC_Decode, 172, 10, 128, 1, // 1644: decode to CVT_S_L_MMR6 using decoder 128
3685 // 1644: }
3686 // 1644: } // switch Inst[15:11]
3687 // 1644: }
3688 133, 7, 7, // 1649: case 0x385: {
3689 OPC_CheckPredicate, 26, // 1652: check predicate 26
3690 OPC_Decode, 220, 9, 166, 1, // 1654: decode to CMP_SLE_S_MMR6 using decoder 166
3691 // 1654: }
3692 149, 7, 7, // 1659: case 0x395: {
3693 OPC_CheckPredicate, 26, // 1662: check predicate 26
3694 OPC_Decode, 218, 9, 167, 1, // 1664: decode to CMP_SLE_D_MMR6 using decoder 167
3695 // 1664: }
3696 184, 7, 7, // 1669: case 0x3b8: {
3697 OPC_CheckPredicate, 26, // 1672: check predicate 26
3698 OPC_Decode, 225, 15, 174, 1, // 1674: decode to MADDF_D_MMR6 using decoder 174
3699 // 1674: }
3700 197, 7, 7, // 1679: case 0x3c5: {
3701 OPC_CheckPredicate, 26, // 1682: check predicate 26
3702 OPC_Decode, 232, 9, 166, 1, // 1684: decode to CMP_SULE_S_MMR6 using decoder 166
3703 // 1684: }
3704 213, 7, 7, // 1689: case 0x3d5: {
3705 OPC_CheckPredicate, 26, // 1692: check predicate 26
3706 OPC_Decode, 230, 9, 167, 1, // 1694: decode to CMP_SULE_D_MMR6 using decoder 167
3707 // 1694: }
3708 248, 7, 0, // 1699: case 0x3f8: {
3709 OPC_CheckPredicate, 26, // 1702: check predicate 26
3710 OPC_Decode, 148, 17, 174, 1, // 1704: decode to MSUBF_D_MMR6 using decoder 174
3711 // 1704: }
3712 // 1704: } // switch Inst[10:0]
3713 // 1704: }
3714 24, 37, // 1709: case 0x18: {
3715 OPC_SwitchField, 12, 4, // 1711: switch Inst[15:12] {
3716 2, 6, // 1714: case 0x2: {
3717 OPC_CheckPredicate, 3, // 1716: check predicate 3
3718 OPC_Decode, 241, 18, 107, // 1718: decode to PREF_MMR6 using decoder 107
3719 // 1718: }
3720 3, 11, // 1722: case 0x3: {
3721 OPC_CheckPredicate, 3, // 1724: check predicate 3
3722 OPC_CheckField, 9, 3, 0, // 1726: check Inst[11:9] == 0x0
3723 OPC_Decode, 159, 15, 141, 1, // 1730: decode to LL_MMR6 using decoder 141
3724 // 1730: }
3725 11, 0, // 1735: case 0xb: {
3726 OPC_CheckPredicate, 3, // 1737: check predicate 3
3727 OPC_CheckField, 9, 3, 0, // 1739: check Inst[11:9] == 0x0
3728 OPC_Decode, 195, 19, 141, 1, // 1743: decode to SC_MMR6 using decoder 141
3729 // 1743: }
3730 // 1743: } // switch Inst[15:12]
3731 // 1743: }
3732 28, 6, // 1748: case 0x1c: {
3733 OPC_CheckPredicate, 3, // 1750: check predicate 3
3734 OPC_Decode, 224, 22, 115, // 1752: decode to XORI_MMR6 using decoder 115
3735 // 1752: }
3736 29, 20, // 1756: case 0x1d: {
3737 OPC_Scope, 11, // 1758: try {
3738 OPC_CheckField, 16, 5, 0, // 1760: check Inst[20:16] == 0x0
3739 OPC_CheckPredicate, 3, // 1764: check predicate 3
3740 OPC_Decode, 195, 7, 175, 1, // 1766: decode to BEQZALC_MMR6 using decoder 175
3741 // 1766: } else try {
3742 OPC_CheckPredicate, 3, // 1771: check predicate 3
3743 OPC_Decode, 191, 7, 175, 1, // 1773: decode to BEQC_MMR6 using decoder 175
3744 // 1773: }
3745 // 1773: }
3746 30, 44, // 1778: case 0x1e: {
3747 OPC_SwitchField, 19, 2, // 1780: switch Inst[20:19] {
3748 0, 7, // 1783: case 0x0: {
3749 OPC_CheckPredicate, 3, // 1785: check predicate 3
3750 OPC_Decode, 150, 6, 176, 1, // 1787: decode to ADDIUPC_MMR6 using decoder 176
3751 // 1787: }
3752 1, 7, // 1792: case 0x1: {
3753 OPC_CheckPredicate, 3, // 1794: check predicate 3
3754 OPC_Decode, 194, 15, 176, 1, // 1796: decode to LWPC_MMR6 using decoder 176
3755 // 1796: }
3756 3, 0, // 1801: case 0x3: {
3757 OPC_SwitchField, 16, 3, // 1803: switch Inst[18:16] {
3758 6, 7, // 1806: case 0x6: {
3759 OPC_CheckPredicate, 3, // 1808: check predicate 3
3760 OPC_Decode, 252, 6, 177, 1, // 1810: decode to AUIPC_MMR6 using decoder 177
3761 // 1810: }
3762 7, 0, // 1815: case 0x7: {
3763 OPC_CheckPredicate, 3, // 1817: check predicate 3
3764 OPC_Decode, 225, 6, 177, 1, // 1819: decode to ALUIPC_MMR6 using decoder 177
3765 // 1819: }
3766 // 1819: } // switch Inst[18:16]
3767 // 1819: }
3768 // 1819: } // switch Inst[20:19]
3769 // 1819: }
3770 31, 20, // 1824: case 0x1f: {
3771 OPC_Scope, 11, // 1826: try {
3772 OPC_CheckField, 16, 5, 0, // 1828: check Inst[20:16] == 0x0
3773 OPC_CheckPredicate, 3, // 1832: check predicate 3
3774 OPC_Decode, 170, 8, 178, 1, // 1834: decode to BNEZALC_MMR6 using decoder 178
3775 // 1834: } else try {
3776 OPC_CheckPredicate, 3, // 1839: check predicate 3
3777 OPC_Decode, 158, 8, 178, 1, // 1841: decode to BNEC_MMR6 using decoder 178
3778 // 1841: }
3779 // 1841: }
3780 32, 19, // 1846: case 0x20: {
3781 OPC_Scope, 10, // 1848: try {
3782 OPC_CheckField, 21, 5, 0, // 1850: check Inst[25:21] == 0x0
3783 OPC_CheckPredicate, 3, // 1854: check predicate 3
3784 OPC_Decode, 200, 14, 110, // 1856: decode to JIALC_MMR6 using decoder 110
3785 // 1856: } else try {
3786 OPC_CheckPredicate, 3, // 1860: check predicate 3
3787 OPC_Decode, 200, 7, 179, 1, // 1862: decode to BEQZC_MMR6 using decoder 179
3788 // 1862: }
3789 // 1862: }
3790 37, 7, // 1867: case 0x25: {
3791 OPC_CheckPredicate, 3, // 1869: check predicate 3
3792 OPC_Decode, 186, 7, 180, 1, // 1871: decode to BC_MMR6 using decoder 180
3793 // 1871: }
3794 40, 19, // 1876: case 0x28: {
3795 OPC_Scope, 10, // 1878: try {
3796 OPC_CheckField, 21, 5, 0, // 1880: check Inst[25:21] == 0x0
3797 OPC_CheckPredicate, 3, // 1884: check predicate 3
3798 OPC_Decode, 203, 14, 110, // 1886: decode to JIC_MMR6 using decoder 110
3799 // 1886: } else try {
3800 OPC_CheckPredicate, 3, // 1890: check predicate 3
3801 OPC_Decode, 175, 8, 179, 1, // 1892: decode to BNEZC_MMR6 using decoder 179
3802 // 1892: }
3803 // 1892: }
3804 45, 7, // 1897: case 0x2d: {
3805 OPC_CheckPredicate, 3, // 1899: check predicate 3
3806 OPC_Decode, 155, 7, 180, 1, // 1901: decode to BALC_MMR6 using decoder 180
3807 // 1901: }
3808 48, 7, // 1906: case 0x30: {
3809 OPC_CheckPredicate, 3, // 1908: check predicate 3
3810 OPC_Decode, 207, 7, 181, 1, // 1910: decode to BGEUC_MMR6 using decoder 181
3811 // 1910: }
3812 52, 6, // 1915: case 0x34: {
3813 OPC_CheckPredicate, 3, // 1917: check predicate 3
3814 OPC_Decode, 233, 6, 115, // 1919: decode to ANDI_MMR6 using decoder 115
3815 // 1919: }
3816 53, 7, // 1923: case 0x35: {
3817 OPC_CheckPredicate, 3, // 1925: check predicate 3
3818 OPC_Decode, 133, 8, 182, 1, // 1927: decode to BLTC_MMR6 using decoder 182
3819 // 1927: }
3820 56, 7, // 1932: case 0x38: {
3821 OPC_CheckPredicate, 3, // 1934: check predicate 3
3822 OPC_Decode, 136, 8, 183, 1, // 1936: decode to BLTUC_MMR6 using decoder 183
3823 // 1936: }
3824 61, 7, // 1941: case 0x3d: {
3825 OPC_CheckPredicate, 3, // 1943: check predicate 3
3826 OPC_Decode, 204, 7, 184, 1, // 1945: decode to BGEC_MMR6 using decoder 184
3827 // 1945: }
3828 62, 6, // 1950: case 0x3e: {
3829 OPC_CheckPredicate, 3, // 1952: check predicate 3
3830 OPC_Decode, 240, 21, 105, // 1954: decode to SW_MMR6 using decoder 105
3831 // 1954: }
3832 63, 0, // 1958: case 0x3f: {
3833 OPC_CheckPredicate, 3, // 1960: check predicate 3
3834 OPC_Decode, 210, 15, 105, // 1962: decode to LW_MMR6 using decoder 105
3835 // 1962: }
3836 // 1962: } // switch Inst[31:26]
3837};
3838static const uint8_t DecoderTableMicroMipsR6_Ambiguous32[65] = {
3839 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
3840 29, 7, // 3: case 0x1d: {
3841 OPC_CheckPredicate, 3, // 5: check predicate 3
3842 OPC_Decode, 185, 8, 175, 1, // 7: decode to BOVC_MMR6 using decoder 175
3843 // 7: }
3844 31, 7, // 12: case 0x1f: {
3845 OPC_CheckPredicate, 3, // 14: check predicate 3
3846 OPC_Decode, 178, 8, 178, 1, // 16: decode to BNVC_MMR6 using decoder 178
3847 // 16: }
3848 48, 20, // 21: case 0x30: {
3849 OPC_Scope, 11, // 23: try {
3850 OPC_CheckField, 16, 5, 0, // 25: check Inst[20:16] == 0x0
3851 OPC_CheckPredicate, 3, // 29: check predicate 3
3852 OPC_Decode, 253, 7, 181, 1, // 31: decode to BLEZALC_MMR6 using decoder 181
3853 // 31: } else try {
3854 OPC_CheckPredicate, 3, // 36: check predicate 3
3855 OPC_Decode, 212, 7, 181, 1, // 38: decode to BGEZALC_MMR6 using decoder 181
3856 // 38: }
3857 // 38: }
3858 56, 0, // 43: case 0x38: {
3859 OPC_Scope, 11, // 45: try {
3860 OPC_CheckField, 16, 5, 0, // 47: check Inst[20:16] == 0x0
3861 OPC_CheckPredicate, 3, // 51: check predicate 3
3862 OPC_Decode, 224, 7, 183, 1, // 53: decode to BGTZALC_MMR6 using decoder 183
3863 // 53: } else try {
3864 OPC_CheckPredicate, 3, // 58: check predicate 3
3865 OPC_Decode, 141, 8, 183, 1, // 60: decode to BLTZALC_MMR6 using decoder 183
3866 // 60: }
3867 // 60: }
3868 // 60: } // switch Inst[31:26]
3869};
3870static const uint8_t DecoderTableMips32[10270] = {
3871 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
3872 0, 159, 5, // 3: case 0x0: {
3873 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
3874 0, 40, // 9: case 0x0: {
3875 OPC_CheckField, 21, 5, 0, // 11: check Inst[25:21] == 0x0
3876 OPC_Scope, 27, // 15: try {
3877 OPC_SwitchField, 6, 15, // 17: switch Inst[20:6] {
3878 1, 6, // 20: case 0x1: {
3879 OPC_CheckPredicate, 27, // 22: check predicate 27
3880 OPC_Decode, 139, 21, 10, // 24: decode to SSNOP using decoder 10
3881 // 24: }
3882 3, 6, // 28: case 0x3: {
3883 OPC_CheckPredicate, 27, // 30: check predicate 27
3884 OPC_Decode, 165, 12, 10, // 32: decode to EHB using decoder 10
3885 // 32: }
3886 5, 0, // 36: case 0x5: {
3887 OPC_CheckPredicate, 28, // 38: check predicate 28
3888 OPC_Decode, 180, 18, 10, // 40: decode to PAUSE using decoder 10
3889 // 40: }
3890 // 40: } // switch Inst[20:6]
3891 // 40: } else try {
3892 OPC_CheckPredicate, 27, // 44: check predicate 27
3893 OPC_Decode, 186, 20, 185, 1, // 46: decode to SLL using decoder 185
3894 // 46: }
3895 // 46: }
3896 1, 29, // 51: case 0x1: {
3897 OPC_SwitchField, 16, 2, // 53: switch Inst[17:16] {
3898 0, 11, // 56: case 0x0: {
3899 OPC_CheckPredicate, 29, // 58: check predicate 29
3900 OPC_CheckField, 6, 5, 0, // 60: check Inst[10:6] == 0x0
3901 OPC_Decode, 237, 16, 186, 1, // 64: decode to MOVF_I using decoder 186
3902 // 64: }
3903 1, 0, // 69: case 0x1: {
3904 OPC_CheckPredicate, 29, // 71: check predicate 29
3905 OPC_CheckField, 6, 5, 0, // 73: check Inst[10:6] == 0x0
3906 OPC_Decode, 129, 17, 186, 1, // 77: decode to MOVT_I using decoder 186
3907 // 77: }
3908 // 77: } // switch Inst[17:16]
3909 // 77: }
3910 2, 21, // 82: case 0x2: {
3911 OPC_SwitchField, 21, 5, // 84: switch Inst[25:21] {
3912 0, 7, // 87: case 0x0: {
3913 OPC_CheckPredicate, 27, // 89: check predicate 27
3914 OPC_Decode, 245, 20, 185, 1, // 91: decode to SRL using decoder 185
3915 // 91: }
3916 1, 0, // 96: case 0x1: {
3917 OPC_CheckPredicate, 28, // 98: check predicate 28
3918 OPC_Decode, 146, 19, 185, 1, // 100: decode to ROTR using decoder 185
3919 // 100: }
3920 // 100: } // switch Inst[25:21]
3921 // 100: }
3922 3, 11, // 105: case 0x3: {
3923 OPC_CheckPredicate, 27, // 107: check predicate 27
3924 OPC_CheckField, 21, 5, 0, // 109: check Inst[25:21] == 0x0
3925 OPC_Decode, 225, 20, 185, 1, // 113: decode to SRA using decoder 185
3926 // 113: }
3927 4, 10, // 118: case 0x4: {
3928 OPC_CheckPredicate, 27, // 120: check predicate 27
3929 OPC_CheckField, 6, 5, 0, // 122: check Inst[10:6] == 0x0
3930 OPC_Decode, 195, 20, 61, // 126: decode to SLLV using decoder 61
3931 // 126: }
3932 5, 11, // 130: case 0x5: {
3933 OPC_CheckPredicate, 30, // 132: check predicate 30
3934 OPC_CheckField, 8, 3, 0, // 134: check Inst[10:8] == 0x0
3935 OPC_Decode, 161, 15, 187, 1, // 138: decode to LSA using decoder 187
3936 // 138: }
3937 6, 19, // 143: case 0x6: {
3938 OPC_SwitchField, 6, 5, // 145: switch Inst[10:6] {
3939 0, 6, // 148: case 0x0: {
3940 OPC_CheckPredicate, 27, // 150: check predicate 27
3941 OPC_Decode, 132, 21, 61, // 152: decode to SRLV using decoder 61
3942 // 152: }
3943 1, 0, // 156: case 0x1: {
3944 OPC_CheckPredicate, 28, // 158: check predicate 28
3945 OPC_Decode, 147, 19, 61, // 160: decode to ROTRV using decoder 61
3946 // 160: }
3947 // 160: } // switch Inst[10:6]
3948 // 160: }
3949 7, 10, // 164: case 0x7: {
3950 OPC_CheckPredicate, 27, // 166: check predicate 27
3951 OPC_CheckField, 6, 5, 0, // 168: check Inst[10:6] == 0x0
3952 OPC_Decode, 238, 20, 61, // 172: decode to SRAV using decoder 61
3953 // 172: }
3954 8, 21, // 176: case 0x8: {
3955 OPC_SwitchField, 6, 15, // 178: switch Inst[20:6] {
3956 0, 7, // 181: case 0x0: {
3957 OPC_CheckPredicate, 31, // 183: check predicate 31
3958 OPC_Decode, 204, 14, 188, 1, // 185: decode to JR using decoder 188
3959 // 185: }
3960 16, 0, // 190: case 0x10: {
3961 OPC_CheckPredicate, 32, // 192: check predicate 32
3962 OPC_Decode, 211, 14, 188, 1, // 194: decode to JR_HB using decoder 188
3963 // 194: }
3964 // 194: } // switch Inst[20:6]
3965 // 194: }
3966 9, 27, // 199: case 0x9: {
3967 OPC_SwitchField, 6, 5, // 201: switch Inst[10:6] {
3968 0, 10, // 204: case 0x0: {
3969 OPC_CheckPredicate, 33, // 206: check predicate 33
3970 OPC_CheckField, 16, 5, 0, // 208: check Inst[20:16] == 0x0
3971 OPC_Decode, 183, 14, 52, // 212: decode to JALR using decoder 52
3972 // 212: }
3973 16, 0, // 216: case 0x10: {
3974 OPC_CheckPredicate, 34, // 218: check predicate 34
3975 OPC_CheckField, 16, 5, 0, // 220: check Inst[20:16] == 0x0
3976 OPC_Decode, 191, 14, 52, // 224: decode to JALR_HB using decoder 52
3977 // 224: }
3978 // 224: } // switch Inst[10:6]
3979 // 224: }
3980 10, 11, // 228: case 0xa: {
3981 OPC_CheckPredicate, 35, // 230: check predicate 35
3982 OPC_CheckField, 6, 5, 0, // 232: check Inst[10:6] == 0x0
3983 OPC_Decode, 141, 17, 189, 1, // 236: decode to MOVZ_I_I using decoder 189
3984 // 236: }
3985 11, 11, // 241: case 0xb: {
3986 OPC_CheckPredicate, 35, // 243: check predicate 35
3987 OPC_CheckField, 6, 5, 0, // 245: check Inst[10:6] == 0x0
3988 OPC_Decode, 249, 16, 189, 1, // 249: decode to MOVN_I_I using decoder 189
3989 // 249: }
3990 12, 7, // 254: case 0xc: {
3991 OPC_CheckPredicate, 27, // 256: check predicate 27
3992 OPC_Decode, 247, 21, 190, 1, // 258: decode to SYSCALL using decoder 190
3993 // 258: }
3994 13, 6, // 263: case 0xd: {
3995 OPC_CheckPredicate, 27, // 265: check predicate 27
3996 OPC_Decode, 189, 8, 62, // 267: decode to BREAK using decoder 62
3997 // 267: }
3998 15, 7, // 271: case 0xf: {
3999 OPC_CheckPredicate, 36, // 273: check predicate 36
4000 OPC_Decode, 241, 21, 191, 1, // 275: decode to SYNC using decoder 191
4001 // 275: }
4002 16, 32, // 280: case 0x10: {
4003 OPC_CheckField, 6, 5, 0, // 282: check Inst[10:6] == 0x0
4004 OPC_CheckField, 16, 5, 0, // 286: check Inst[20:16] == 0x0
4005 OPC_CheckField, 23, 3, 0, // 290: check Inst[25:23] == 0x0
4006 OPC_Scope, 11, // 294: try {
4007 OPC_CheckField, 21, 2, 0, // 296: check Inst[22:21] == 0x0
4008 OPC_CheckPredicate, 31, // 300: check predicate 31
4009 OPC_Decode, 174, 16, 192, 1, // 302: decode to MFHI using decoder 192
4010 // 302: } else try {
4011 OPC_CheckPredicate, 37, // 307: check predicate 37
4012 OPC_Decode, 177, 16, 193, 1, // 309: decode to MFHI_DSP using decoder 193
4013 // 309: }
4014 // 309: }
4015 17, 28, // 314: case 0x11: {
4016 OPC_CheckField, 6, 5, 0, // 316: check Inst[10:6] == 0x0
4017 OPC_CheckField, 13, 8, 0, // 320: check Inst[20:13] == 0x0
4018 OPC_Scope, 11, // 324: try {
4019 OPC_CheckField, 11, 2, 0, // 326: check Inst[12:11] == 0x0
4020 OPC_CheckPredicate, 31, // 330: check predicate 31
4021 OPC_Decode, 190, 17, 188, 1, // 332: decode to MTHI using decoder 188
4022 // 332: } else try {
4023 OPC_CheckPredicate, 37, // 337: check predicate 37
4024 OPC_Decode, 192, 17, 194, 1, // 339: decode to MTHI_DSP using decoder 194
4025 // 339: }
4026 // 339: }
4027 18, 32, // 344: case 0x12: {
4028 OPC_CheckField, 6, 5, 0, // 346: check Inst[10:6] == 0x0
4029 OPC_CheckField, 16, 5, 0, // 350: check Inst[20:16] == 0x0
4030 OPC_CheckField, 23, 3, 0, // 354: check Inst[25:23] == 0x0
4031 OPC_Scope, 11, // 358: try {
4032 OPC_CheckField, 21, 2, 0, // 360: check Inst[22:21] == 0x0
4033 OPC_CheckPredicate, 31, // 364: check predicate 31
4034 OPC_Decode, 180, 16, 192, 1, // 366: decode to MFLO using decoder 192
4035 // 366: } else try {
4036 OPC_CheckPredicate, 37, // 371: check predicate 37
4037 OPC_Decode, 183, 16, 193, 1, // 373: decode to MFLO_DSP using decoder 193
4038 // 373: }
4039 // 373: }
4040 19, 28, // 378: case 0x13: {
4041 OPC_CheckField, 6, 5, 0, // 380: check Inst[10:6] == 0x0
4042 OPC_CheckField, 13, 8, 0, // 384: check Inst[20:13] == 0x0
4043 OPC_Scope, 11, // 388: try {
4044 OPC_CheckField, 11, 2, 0, // 390: check Inst[12:11] == 0x0
4045 OPC_CheckPredicate, 31, // 394: check predicate 31
4046 OPC_Decode, 197, 17, 188, 1, // 396: decode to MTLO using decoder 188
4047 // 396: } else try {
4048 OPC_CheckPredicate, 37, // 401: check predicate 37
4049 OPC_Decode, 199, 17, 195, 1, // 403: decode to MTLO_DSP using decoder 195
4050 // 403: }
4051 // 403: }
4052 21, 11, // 408: case 0x15: {
4053 OPC_CheckPredicate, 38, // 410: check predicate 38
4054 OPC_CheckField, 8, 3, 0, // 412: check Inst[10:8] == 0x0
4055 OPC_Decode, 196, 11, 196, 1, // 416: decode to DLSA using decoder 196
4056 // 416: }
4057 24, 27, // 421: case 0x18: {
4058 OPC_CheckField, 6, 5, 0, // 423: check Inst[10:6] == 0x0
4059 OPC_CheckField, 13, 3, 0, // 427: check Inst[15:13] == 0x0
4060 OPC_Scope, 10, // 431: try {
4061 OPC_CheckField, 11, 2, 0, // 433: check Inst[12:11] == 0x0
4062 OPC_CheckPredicate, 31, // 437: check predicate 31
4063 OPC_Decode, 237, 17, 86, // 439: decode to MULT using decoder 86
4064 // 439: } else try {
4065 OPC_CheckPredicate, 37, // 443: check predicate 37
4066 OPC_Decode, 240, 17, 197, 1, // 445: decode to MULT_DSP using decoder 197
4067 // 445: }
4068 // 445: }
4069 25, 27, // 450: case 0x19: {
4070 OPC_CheckField, 6, 5, 0, // 452: check Inst[10:6] == 0x0
4071 OPC_CheckField, 13, 3, 0, // 456: check Inst[15:13] == 0x0
4072 OPC_Scope, 10, // 460: try {
4073 OPC_CheckField, 11, 2, 0, // 462: check Inst[12:11] == 0x0
4074 OPC_CheckPredicate, 31, // 466: check predicate 31
4075 OPC_Decode, 243, 17, 86, // 468: decode to MULTu using decoder 86
4076 // 468: } else try {
4077 OPC_CheckPredicate, 37, // 472: check predicate 37
4078 OPC_Decode, 238, 17, 197, 1, // 474: decode to MULTU_DSP using decoder 197
4079 // 474: }
4080 // 474: }
4081 26, 10, // 479: case 0x1a: {
4082 OPC_CheckPredicate, 31, // 481: check predicate 31
4083 OPC_CheckField, 6, 10, 0, // 483: check Inst[15:6] == 0x0
4084 OPC_Decode, 213, 19, 86, // 487: decode to SDIV using decoder 86
4085 // 487: }
4086 27, 10, // 491: case 0x1b: {
4087 OPC_CheckPredicate, 31, // 493: check predicate 31
4088 OPC_CheckField, 6, 10, 0, // 495: check Inst[15:6] == 0x0
4089 OPC_Decode, 201, 22, 86, // 499: decode to UDIV using decoder 86
4090 // 499: }
4091 32, 10, // 503: case 0x20: {
4092 OPC_CheckPredicate, 27, // 505: check predicate 27
4093 OPC_CheckField, 6, 5, 0, // 507: check Inst[10:6] == 0x0
4094 OPC_Decode, 147, 6, 67, // 511: decode to ADD using decoder 67
4095 // 511: }
4096 33, 10, // 515: case 0x21: {
4097 OPC_CheckPredicate, 27, // 517: check predicate 27
4098 OPC_CheckField, 6, 5, 0, // 519: check Inst[10:6] == 0x0
4099 OPC_Decode, 220, 6, 67, // 523: decode to ADDu using decoder 67
4100 // 523: }
4101 34, 10, // 527: case 0x22: {
4102 OPC_CheckPredicate, 27, // 529: check predicate 27
4103 OPC_CheckField, 6, 5, 0, // 531: check Inst[10:6] == 0x0
4104 OPC_Decode, 146, 21, 67, // 535: decode to SUB using decoder 67
4105 // 535: }
4106 35, 10, // 539: case 0x23: {
4107 OPC_CheckPredicate, 27, // 541: check predicate 27
4108 OPC_CheckField, 6, 5, 0, // 543: check Inst[10:6] == 0x0
4109 OPC_Decode, 202, 21, 67, // 547: decode to SUBu using decoder 67
4110 // 547: }
4111 36, 10, // 551: case 0x24: {
4112 OPC_CheckPredicate, 27, // 553: check predicate 27
4113 OPC_CheckField, 6, 5, 0, // 555: check Inst[10:6] == 0x0
4114 OPC_Decode, 226, 6, 67, // 559: decode to AND using decoder 67
4115 // 559: }
4116 37, 10, // 563: case 0x25: {
4117 OPC_CheckPredicate, 27, // 565: check predicate 27
4118 OPC_CheckField, 6, 5, 0, // 567: check Inst[10:6] == 0x0
4119 OPC_Decode, 165, 18, 67, // 571: decode to OR using decoder 67
4120 // 571: }
4121 38, 10, // 575: case 0x26: {
4122 OPC_CheckPredicate, 27, // 577: check predicate 27
4123 OPC_CheckField, 6, 5, 0, // 579: check Inst[10:6] == 0x0
4124 OPC_Decode, 219, 22, 67, // 583: decode to XOR using decoder 67
4125 // 583: }
4126 39, 10, // 587: case 0x27: {
4127 OPC_CheckPredicate, 27, // 589: check predicate 27
4128 OPC_CheckField, 6, 5, 0, // 591: check Inst[10:6] == 0x0
4129 OPC_Decode, 155, 18, 67, // 595: decode to NOR using decoder 67
4130 // 595: }
4131 42, 10, // 599: case 0x2a: {
4132 OPC_CheckPredicate, 27, // 601: check predicate 27
4133 OPC_CheckField, 6, 5, 0, // 603: check Inst[10:6] == 0x0
4134 OPC_Decode, 203, 20, 67, // 607: decode to SLT using decoder 67
4135 // 607: }
4136 43, 10, // 611: case 0x2b: {
4137 OPC_CheckPredicate, 27, // 613: check predicate 27
4138 OPC_CheckField, 6, 5, 0, // 615: check Inst[10:6] == 0x0
4139 OPC_Decode, 212, 20, 67, // 619: decode to SLTu using decoder 67
4140 // 619: }
4141 48, 7, // 623: case 0x30: {
4142 OPC_CheckPredicate, 36, // 625: check predicate 36
4143 OPC_Decode, 146, 22, 198, 1, // 627: decode to TGE using decoder 198
4144 // 627: }
4145 49, 7, // 632: case 0x31: {
4146 OPC_CheckPredicate, 36, // 634: check predicate 36
4147 OPC_Decode, 151, 22, 198, 1, // 636: decode to TGEU using decoder 198
4148 // 636: }
4149 50, 7, // 641: case 0x32: {
4150 OPC_CheckPredicate, 36, // 643: check predicate 36
4151 OPC_Decode, 178, 22, 198, 1, // 645: decode to TLT using decoder 198
4152 // 645: }
4153 51, 7, // 650: case 0x33: {
4154 OPC_CheckPredicate, 36, // 652: check predicate 36
4155 OPC_Decode, 182, 22, 198, 1, // 654: decode to TLTU using decoder 198
4156 // 654: }
4157 52, 7, // 659: case 0x34: {
4158 OPC_CheckPredicate, 36, // 661: check predicate 36
4159 OPC_Decode, 142, 22, 198, 1, // 663: decode to TEQ using decoder 198
4160 // 663: }
4161 54, 0, // 668: case 0x36: {
4162 OPC_CheckPredicate, 36, // 670: check predicate 36
4163 OPC_Decode, 185, 22, 198, 1, // 672: decode to TNE using decoder 198
4164 // 672: }
4165 // 672: } // switch Inst[5:0]
4166 // 672: }
4167 1, 151, 1, // 677: case 0x1: {
4168 OPC_SwitchField, 16, 5, // 680: switch Inst[20:16] {
4169 0, 7, // 683: case 0x0: {
4170 OPC_CheckPredicate, 27, // 685: check predicate 27
4171 OPC_Decode, 137, 8, 199, 1, // 687: decode to BLTZ using decoder 199
4172 // 687: }
4173 1, 7, // 692: case 0x1: {
4174 OPC_CheckPredicate, 27, // 694: check predicate 27
4175 OPC_Decode, 208, 7, 199, 1, // 696: decode to BGEZ using decoder 199
4176 // 696: }
4177 2, 7, // 701: case 0x2: {
4178 OPC_CheckPredicate, 39, // 703: check predicate 39
4179 OPC_Decode, 148, 8, 199, 1, // 705: decode to BLTZL using decoder 199
4180 // 705: }
4181 3, 7, // 710: case 0x3: {
4182 OPC_CheckPredicate, 39, // 712: check predicate 39
4183 OPC_Decode, 219, 7, 199, 1, // 714: decode to BGEZL using decoder 199
4184 // 714: }
4185 8, 7, // 719: case 0x8: {
4186 OPC_CheckPredicate, 39, // 721: check predicate 39
4187 OPC_Decode, 147, 22, 177, 1, // 723: decode to TGEI using decoder 177
4188 // 723: }
4189 9, 7, // 728: case 0x9: {
4190 OPC_CheckPredicate, 39, // 730: check predicate 39
4191 OPC_Decode, 148, 22, 177, 1, // 732: decode to TGEIU using decoder 177
4192 // 732: }
4193 10, 7, // 737: case 0xa: {
4194 OPC_CheckPredicate, 39, // 739: check predicate 39
4195 OPC_Decode, 179, 22, 177, 1, // 741: decode to TLTI using decoder 177
4196 // 741: }
4197 11, 7, // 746: case 0xb: {
4198 OPC_CheckPredicate, 39, // 748: check predicate 39
4199 OPC_Decode, 200, 22, 177, 1, // 750: decode to TTLTIU using decoder 177
4200 // 750: }
4201 12, 7, // 755: case 0xc: {
4202 OPC_CheckPredicate, 39, // 757: check predicate 39
4203 OPC_Decode, 143, 22, 177, 1, // 759: decode to TEQI using decoder 177
4204 // 759: }
4205 14, 7, // 764: case 0xe: {
4206 OPC_CheckPredicate, 39, // 766: check predicate 39
4207 OPC_Decode, 186, 22, 177, 1, // 768: decode to TNEI using decoder 177
4208 // 768: }
4209 16, 7, // 773: case 0x10: {
4210 OPC_CheckPredicate, 31, // 775: check predicate 31
4211 OPC_Decode, 139, 8, 199, 1, // 777: decode to BLTZAL using decoder 199
4212 // 777: }
4213 17, 7, // 782: case 0x11: {
4214 OPC_CheckPredicate, 31, // 784: check predicate 31
4215 OPC_Decode, 210, 7, 199, 1, // 786: decode to BGEZAL using decoder 199
4216 // 786: }
4217 18, 7, // 791: case 0x12: {
4218 OPC_CheckPredicate, 39, // 793: check predicate 39
4219 OPC_Decode, 142, 8, 199, 1, // 795: decode to BLTZALL using decoder 199
4220 // 795: }
4221 19, 7, // 800: case 0x13: {
4222 OPC_CheckPredicate, 39, // 802: check predicate 39
4223 OPC_Decode, 213, 7, 199, 1, // 804: decode to BGEZALL using decoder 199
4224 // 804: }
4225 28, 11, // 809: case 0x1c: {
4226 OPC_CheckPredicate, 40, // 811: check predicate 40
4227 OPC_CheckField, 21, 5, 0, // 813: check Inst[25:21] == 0x0
4228 OPC_Decode, 186, 8, 200, 1, // 817: decode to BPOSGE32 using decoder 200
4229 // 817: }
4230 31, 0, // 822: case 0x1f: {
4231 OPC_CheckPredicate, 28, // 824: check predicate 28
4232 OPC_Decode, 242, 21, 201, 1, // 826: decode to SYNCI using decoder 201
4233 // 826: }
4234 // 826: } // switch Inst[20:16]
4235 // 826: }
4236 2, 7, // 831: case 0x2: {
4237 OPC_CheckPredicate, 27, // 833: check predicate 27
4238 OPC_Decode, 181, 14, 202, 1, // 835: decode to J using decoder 202
4239 // 835: }
4240 3, 7, // 840: case 0x3: {
4241 OPC_CheckPredicate, 27, // 842: check predicate 27
4242 OPC_Decode, 182, 14, 202, 1, // 844: decode to JAL using decoder 202
4243 // 844: }
4244 4, 7, // 849: case 0x4: {
4245 OPC_CheckPredicate, 27, // 851: check predicate 27
4246 OPC_Decode, 187, 7, 203, 1, // 853: decode to BEQ using decoder 203
4247 // 853: }
4248 5, 7, // 858: case 0x5: {
4249 OPC_CheckPredicate, 27, // 860: check predicate 27
4250 OPC_Decode, 154, 8, 203, 1, // 862: decode to BNE using decoder 203
4251 // 862: }
4252 6, 11, // 867: case 0x6: {
4253 OPC_CheckPredicate, 27, // 869: check predicate 27
4254 OPC_CheckField, 16, 5, 0, // 871: check Inst[20:16] == 0x0
4255 OPC_Decode, 250, 7, 199, 1, // 875: decode to BLEZ using decoder 199
4256 // 875: }
4257 7, 11, // 880: case 0x7: {
4258 OPC_CheckPredicate, 27, // 882: check predicate 27
4259 OPC_CheckField, 16, 5, 0, // 884: check Inst[20:16] == 0x0
4260 OPC_Decode, 221, 7, 199, 1, // 888: decode to BGTZ using decoder 199
4261 // 888: }
4262 8, 7, // 893: case 0x8: {
4263 OPC_CheckPredicate, 31, // 895: check predicate 31
4264 OPC_Decode, 216, 6, 204, 1, // 897: decode to ADDi using decoder 204
4265 // 897: }
4266 9, 7, // 902: case 0x9: {
4267 OPC_CheckPredicate, 27, // 904: check predicate 27
4268 OPC_Decode, 218, 6, 204, 1, // 906: decode to ADDiu using decoder 204
4269 // 906: }
4270 10, 7, // 911: case 0xa: {
4271 OPC_CheckPredicate, 27, // 913: check predicate 27
4272 OPC_Decode, 206, 20, 204, 1, // 915: decode to SLTi using decoder 204
4273 // 915: }
4274 11, 7, // 920: case 0xb: {
4275 OPC_CheckPredicate, 27, // 922: check predicate 27
4276 OPC_Decode, 209, 20, 204, 1, // 924: decode to SLTiu using decoder 204
4277 // 924: }
4278 12, 7, // 929: case 0xc: {
4279 OPC_CheckPredicate, 27, // 931: check predicate 27
4280 OPC_Decode, 237, 6, 205, 1, // 933: decode to ANDi using decoder 205
4281 // 933: }
4282 13, 7, // 938: case 0xd: {
4283 OPC_CheckPredicate, 27, // 940: check predicate 27
4284 OPC_Decode, 174, 18, 205, 1, // 942: decode to ORi using decoder 205
4285 // 942: }
4286 14, 7, // 947: case 0xe: {
4287 OPC_CheckPredicate, 27, // 949: check predicate 27
4288 OPC_Decode, 228, 22, 205, 1, // 951: decode to XORi using decoder 205
4289 // 951: }
4290 15, 10, // 956: case 0xf: {
4291 OPC_CheckPredicate, 27, // 958: check predicate 27
4292 OPC_CheckField, 21, 5, 0, // 960: check Inst[25:21] == 0x0
4293 OPC_Decode, 168, 15, 110, // 964: decode to LUi using decoder 110
4294 // 964: }
4295 16, 165, 3, // 968: case 0x10: {
4296 OPC_SwitchField, 3, 1, // 971: switch Inst[3] {
4297 0, 135, 2, // 974: case 0x0: {
4298 OPC_SwitchField, 21, 5, // 977: switch Inst[25:21] {
4299 0, 11, // 980: case 0x0: {
4300 OPC_CheckPredicate, 27, // 982: check predicate 27
4301 OPC_CheckField, 4, 7, 0, // 984: check Inst[10:4] == 0x0
4302 OPC_Decode, 156, 16, 206, 1, // 988: decode to MFC0 using decoder 206
4303 // 988: }
4304 3, 39, // 993: case 0x3: {
4305 OPC_SwitchField, 4, 7, // 995: switch Inst[10:4] {
4306 0, 7, // 998: case 0x0: {
4307 OPC_CheckPredicate, 41, // 1000: check predicate 41
4308 OPC_Decode, 164, 16, 206, 1, // 1002: decode to MFGC0 using decoder 206
4309 // 1002: }
4310 32, 7, // 1007: case 0x20: {
4311 OPC_CheckPredicate, 41, // 1009: check predicate 41
4312 OPC_Decode, 180, 17, 207, 1, // 1011: decode to MTGC0 using decoder 207
4313 // 1011: }
4314 64, 7, // 1016: case 0x40: {
4315 OPC_CheckPredicate, 41, // 1018: check predicate 41
4316 OPC_Decode, 172, 16, 206, 1, // 1020: decode to MFHGC0 using decoder 206
4317 // 1020: }
4318 96, 0, // 1025: case 0x60: {
4319 OPC_CheckPredicate, 41, // 1027: check predicate 41
4320 OPC_Decode, 188, 17, 207, 1, // 1029: decode to MTHGC0 using decoder 207
4321 // 1029: }
4322 // 1029: } // switch Inst[10:4]
4323 // 1029: }
4324 4, 11, // 1034: case 0x4: {
4325 OPC_CheckPredicate, 27, // 1036: check predicate 27
4326 OPC_CheckField, 4, 7, 0, // 1038: check Inst[10:4] == 0x0
4327 OPC_Decode, 171, 17, 207, 1, // 1042: decode to MTC0 using decoder 207
4328 // 1042: }
4329 8, 11, // 1047: case 0x8: {
4330 OPC_CheckPredicate, 42, // 1049: check predicate 42
4331 OPC_CheckField, 6, 5, 0, // 1051: check Inst[10:6] == 0x0
4332 OPC_Decode, 186, 16, 208, 1, // 1055: decode to MFTR using decoder 208
4333 // 1055: }
4334 11, 79, // 1060: case 0xb: {
4335 OPC_SwitchField, 4, 12, // 1062: switch Inst[15:4] {
4336 0, 10, // 1065: case 0x0: {
4337 OPC_CheckPredicate, 42, // 1067: check predicate 42
4338 OPC_CheckField, 0, 3, 1, // 1069: check Inst[2:0] == 0x1
4339 OPC_Decode, 161, 12, 99, // 1073: decode to DVPE using decoder 99
4340 // 1073: }
4341 2, 10, // 1077: case 0x2: {
4342 OPC_CheckPredicate, 42, // 1079: check predicate 42
4343 OPC_CheckField, 0, 3, 1, // 1081: check Inst[2:0] == 0x1
4344 OPC_Decode, 178, 12, 99, // 1085: decode to EVPE using decoder 99
4345 // 1085: }
4346 188, 1, 10, // 1089: case 0xbc: {
4347 OPC_CheckPredicate, 42, // 1092: check predicate 42
4348 OPC_CheckField, 0, 3, 1, // 1094: check Inst[2:0] == 0x1
4349 OPC_Decode, 205, 11, 99, // 1098: decode to DMT using decoder 99
4350 // 1098: }
4351 190, 1, 10, // 1102: case 0xbe: {
4352 OPC_CheckPredicate, 42, // 1105: check predicate 42
4353 OPC_CheckField, 0, 3, 1, // 1107: check Inst[2:0] == 0x1
4354 OPC_Decode, 171, 12, 99, // 1111: decode to EMT using decoder 99
4355 // 1111: }
4356 128, 12, 10, // 1115: case 0x600: {
4357 OPC_CheckPredicate, 28, // 1118: check predicate 28
4358 OPC_CheckField, 0, 3, 0, // 1120: check Inst[2:0] == 0x0
4359 OPC_Decode, 178, 11, 99, // 1124: decode to DI using decoder 99
4360 // 1124: }
4361 130, 12, 0, // 1128: case 0x602: {
4362 OPC_CheckPredicate, 28, // 1131: check predicate 28
4363 OPC_CheckField, 0, 3, 0, // 1133: check Inst[2:0] == 0x0
4364 OPC_Decode, 168, 12, 99, // 1137: decode to EI using decoder 99
4365 // 1137: }
4366 // 1137: } // switch Inst[15:4]
4367 // 1137: }
4368 12, 11, // 1141: case 0xc: {
4369 OPC_CheckPredicate, 42, // 1143: check predicate 42
4370 OPC_CheckField, 6, 5, 0, // 1145: check Inst[10:6] == 0x0
4371 OPC_Decode, 208, 17, 208, 1, // 1149: decode to MTTR using decoder 208
4372 // 1149: }
4373 16, 0, // 1154: case 0x10: {
4374 OPC_SwitchField, 0, 3, // 1156: switch Inst[2:0] {
4375 0, 19, // 1159: case 0x0: {
4376 OPC_SwitchField, 4, 17, // 1161: switch Inst[20:4] {
4377 1, 6, // 1164: case 0x1: {
4378 OPC_CheckPredicate, 41, // 1166: check predicate 41
4379 OPC_Decode, 158, 22, 10, // 1168: decode to TLBGP using decoder 10
4380 // 1168: }
4381 2, 0, // 1172: case 0x2: {
4382 OPC_CheckPredicate, 43, // 1174: check predicate 43
4383 OPC_Decode, 210, 22, 10, // 1176: decode to WAIT using decoder 10
4384 // 1176: }
4385 // 1176: } // switch Inst[20:4]
4386 // 1176: }
4387 1, 10, // 1180: case 0x1: {
4388 OPC_CheckPredicate, 27, // 1182: check predicate 27
4389 OPC_CheckField, 4, 17, 0, // 1184: check Inst[20:4] == 0x0
4390 OPC_Decode, 172, 22, 10, // 1188: decode to TLBR using decoder 10
4391 // 1188: }
4392 2, 10, // 1192: case 0x2: {
4393 OPC_CheckPredicate, 27, // 1194: check predicate 27
4394 OPC_CheckField, 4, 17, 0, // 1196: check Inst[20:4] == 0x0
4395 OPC_Decode, 174, 22, 10, // 1200: decode to TLBWI using decoder 10
4396 // 1200: }
4397 3, 10, // 1204: case 0x3: {
4398 OPC_CheckPredicate, 44, // 1206: check predicate 44
4399 OPC_CheckField, 4, 17, 0, // 1208: check Inst[20:4] == 0x0
4400 OPC_Decode, 166, 22, 10, // 1212: decode to TLBINV using decoder 10
4401 // 1212: }
4402 4, 10, // 1216: case 0x4: {
4403 OPC_CheckPredicate, 44, // 1218: check predicate 44
4404 OPC_CheckField, 4, 17, 0, // 1220: check Inst[20:4] == 0x0
4405 OPC_Decode, 167, 22, 10, // 1224: decode to TLBINVF using decoder 10
4406 // 1224: }
4407 6, 0, // 1228: case 0x6: {
4408 OPC_CheckPredicate, 27, // 1230: check predicate 27
4409 OPC_CheckField, 4, 17, 0, // 1232: check Inst[20:4] == 0x0
4410 OPC_Decode, 176, 22, 10, // 1236: decode to TLBWR using decoder 10
4411 // 1236: }
4412 // 1236: } // switch Inst[2:0]
4413 // 1236: }
4414 // 1236: } // switch Inst[25:21]
4415 // 1236: }
4416 1, 0, // 1240: case 0x1: {
4417 OPC_SwitchField, 0, 3, // 1242: switch Inst[2:0] {
4418 0, 55, // 1245: case 0x0: {
4419 OPC_SwitchField, 4, 2, // 1247: switch Inst[5:4] {
4420 0, 12, // 1250: case 0x0: {
4421 OPC_CheckPredicate, 27, // 1252: check predicate 27
4422 OPC_CheckField, 6, 20, 128, 128, 32, // 1254: check Inst[25:6] == 0x80000
4423 OPC_Decode, 170, 22, 10, // 1260: decode to TLBP using decoder 10
4424 // 1260: }
4425 1, 23, // 1264: case 0x1: {
4426 OPC_SwitchField, 6, 20, // 1266: switch Inst[25:6] {
4427 128, 128, 32, 6, // 1269: case 0x80000: {
4428 OPC_CheckPredicate, 43, // 1273: check predicate 43
4429 OPC_Decode, 172, 12, 10, // 1275: decode to ERET using decoder 10
4430 // 1275: }
4431 129, 128, 32, 0, // 1279: case 0x80001: {
4432 OPC_CheckPredicate, 45, // 1283: check predicate 45
4433 OPC_Decode, 173, 12, 10, // 1285: decode to ERETNC using decoder 10
4434 // 1285: }
4435 // 1285: } // switch Inst[25:6]
4436 // 1285: }
4437 2, 0, // 1289: case 0x2: {
4438 OPC_CheckPredicate, 41, // 1291: check predicate 41
4439 OPC_CheckField, 25, 1, 1, // 1293: check Inst[25] == 0x1
4440 OPC_Decode, 150, 14, 209, 1, // 1297: decode to HYPCALL using decoder 209
4441 // 1297: }
4442 // 1297: } // switch Inst[5:4]
4443 // 1297: }
4444 1, 13, // 1302: case 0x1: {
4445 OPC_CheckPredicate, 41, // 1304: check predicate 41
4446 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1306: check Inst[25:4] == 0x200000
4447 OPC_Decode, 160, 22, 10, // 1313: decode to TLBGR using decoder 10
4448 // 1313: }
4449 2, 13, // 1317: case 0x2: {
4450 OPC_CheckPredicate, 41, // 1319: check predicate 41
4451 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1321: check Inst[25:4] == 0x200000
4452 OPC_Decode, 162, 22, 10, // 1328: decode to TLBGWI using decoder 10
4453 // 1328: }
4454 3, 13, // 1332: case 0x3: {
4455 OPC_CheckPredicate, 41, // 1334: check predicate 41
4456 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1336: check Inst[25:4] == 0x200000
4457 OPC_Decode, 154, 22, 10, // 1343: decode to TLBGINV using decoder 10
4458 // 1343: }
4459 4, 13, // 1347: case 0x4: {
4460 OPC_CheckPredicate, 41, // 1349: check predicate 41
4461 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1351: check Inst[25:4] == 0x200000
4462 OPC_Decode, 155, 22, 10, // 1358: decode to TLBGINVF using decoder 10
4463 // 1358: }
4464 6, 13, // 1362: case 0x6: {
4465 OPC_CheckPredicate, 41, // 1364: check predicate 41
4466 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1366: check Inst[25:4] == 0x200000
4467 OPC_Decode, 164, 22, 10, // 1373: decode to TLBGWR using decoder 10
4468 // 1373: }
4469 7, 0, // 1377: case 0x7: {
4470 OPC_CheckPredicate, 46, // 1379: check predicate 46
4471 OPC_CheckField, 4, 22, 129, 128, 128, 1, // 1381: check Inst[25:4] == 0x200001
4472 OPC_Decode, 171, 11, 10, // 1388: decode to DERET using decoder 10
4473 // 1388: }
4474 // 1388: } // switch Inst[2:0]
4475 // 1388: }
4476 // 1388: } // switch Inst[3]
4477 // 1388: }
4478 17, 165, 9, // 1392: case 0x11: {
4479 OPC_SwitchField, 21, 5, // 1395: switch Inst[25:21] {
4480 0, 11, // 1398: case 0x0: {
4481 OPC_CheckPredicate, 47, // 1400: check predicate 47
4482 OPC_CheckField, 0, 11, 0, // 1402: check Inst[10:0] == 0x0
4483 OPC_Decode, 158, 16, 210, 1, // 1406: decode to MFC1 using decoder 210
4484 // 1406: }
4485 1, 11, // 1411: case 0x1: {
4486 OPC_CheckPredicate, 48, // 1413: check predicate 48
4487 OPC_CheckField, 0, 11, 0, // 1415: check Inst[10:0] == 0x0
4488 OPC_Decode, 199, 11, 211, 1, // 1419: decode to DMFC1 using decoder 211
4489 // 1419: }
4490 2, 11, // 1424: case 0x2: {
4491 OPC_CheckPredicate, 47, // 1426: check predicate 47
4492 OPC_CheckField, 0, 11, 0, // 1428: check Inst[10:0] == 0x0
4493 OPC_Decode, 245, 8, 212, 1, // 1432: decode to CFC1 using decoder 212
4494 // 1432: }
4495 3, 11, // 1437: case 0x3: {
4496 OPC_CheckPredicate, 49, // 1439: check predicate 49
4497 OPC_CheckField, 0, 11, 0, // 1441: check Inst[10:0] == 0x0
4498 OPC_Decode, 167, 16, 213, 1, // 1445: decode to MFHC1_D32 using decoder 213
4499 // 1445: }
4500 4, 11, // 1450: case 0x4: {
4501 OPC_CheckPredicate, 47, // 1452: check predicate 47
4502 OPC_CheckField, 0, 11, 0, // 1454: check Inst[10:0] == 0x0
4503 OPC_Decode, 173, 17, 214, 1, // 1458: decode to MTC1 using decoder 214
4504 // 1458: }
4505 5, 11, // 1463: case 0x5: {
4506 OPC_CheckPredicate, 48, // 1465: check predicate 48
4507 OPC_CheckField, 0, 11, 0, // 1467: check Inst[10:0] == 0x0
4508 OPC_Decode, 207, 11, 215, 1, // 1471: decode to DMTC1 using decoder 215
4509 // 1471: }
4510 6, 11, // 1476: case 0x6: {
4511 OPC_CheckPredicate, 47, // 1478: check predicate 47
4512 OPC_CheckField, 0, 11, 0, // 1480: check Inst[10:0] == 0x0
4513 OPC_Decode, 144, 10, 216, 1, // 1484: decode to CTC1 using decoder 216
4514 // 1484: }
4515 7, 11, // 1489: case 0x7: {
4516 OPC_CheckPredicate, 49, // 1491: check predicate 49
4517 OPC_CheckField, 0, 11, 0, // 1493: check Inst[10:0] == 0x0
4518 OPC_Decode, 183, 17, 217, 1, // 1497: decode to MTHC1_D32 using decoder 217
4519 // 1497: }
4520 8, 39, // 1502: case 0x8: {
4521 OPC_SwitchField, 16, 2, // 1504: switch Inst[17:16] {
4522 0, 7, // 1507: case 0x0: {
4523 OPC_CheckPredicate, 50, // 1509: check predicate 50
4524 OPC_Decode, 166, 7, 218, 1, // 1511: decode to BC1F using decoder 218
4525 // 1511: }
4526 1, 7, // 1516: case 0x1: {
4527 OPC_CheckPredicate, 50, // 1518: check predicate 50
4528 OPC_Decode, 171, 7, 218, 1, // 1520: decode to BC1T using decoder 218
4529 // 1520: }
4530 2, 7, // 1525: case 0x2: {
4531 OPC_CheckPredicate, 51, // 1527: check predicate 51
4532 OPC_Decode, 167, 7, 218, 1, // 1529: decode to BC1FL using decoder 218
4533 // 1529: }
4534 3, 0, // 1534: case 0x3: {
4535 OPC_CheckPredicate, 51, // 1536: check predicate 51
4536 OPC_Decode, 172, 7, 218, 1, // 1538: decode to BC1TL using decoder 218
4537 // 1538: }
4538 // 1538: } // switch Inst[17:16]
4539 // 1538: }
4540 11, 7, // 1543: case 0xb: {
4541 OPC_CheckPredicate, 30, // 1545: check predicate 30
4542 OPC_Decode, 207, 8, 219, 1, // 1547: decode to BZ_V using decoder 219
4543 // 1547: }
4544 15, 7, // 1552: case 0xf: {
4545 OPC_CheckPredicate, 30, // 1554: check predicate 30
4546 OPC_Decode, 182, 8, 219, 1, // 1556: decode to BNZ_V using decoder 219
4547 // 1556: }
4548 16, 201, 3, // 1561: case 0x10: {
4549 OPC_SwitchField, 0, 6, // 1564: switch Inst[5:0] {
4550 0, 7, // 1567: case 0x0: {
4551 OPC_CheckPredicate, 47, // 1569: check predicate 47
4552 OPC_Decode, 221, 12, 220, 1, // 1571: decode to FADD_S using decoder 220
4553 // 1571: }
4554 1, 7, // 1576: case 0x1: {
4555 OPC_CheckPredicate, 47, // 1578: check predicate 47
4556 OPC_Decode, 238, 13, 220, 1, // 1580: decode to FSUB_S using decoder 220
4557 // 1580: }
4558 2, 7, // 1585: case 0x2: {
4559 OPC_CheckPredicate, 47, // 1587: check predicate 47
4560 OPC_Decode, 194, 13, 220, 1, // 1589: decode to FMUL_S using decoder 220
4561 // 1589: }
4562 3, 7, // 1594: case 0x3: {
4563 OPC_CheckPredicate, 47, // 1596: check predicate 47
4564 OPC_Decode, 131, 13, 220, 1, // 1598: decode to FDIV_S using decoder 220
4565 // 1598: }
4566 4, 11, // 1603: case 0x4: {
4567 OPC_CheckPredicate, 52, // 1605: check predicate 52
4568 OPC_CheckField, 16, 5, 0, // 1607: check Inst[20:16] == 0x0
4569 OPC_Decode, 229, 13, 221, 1, // 1611: decode to FSQRT_S using decoder 221
4570 // 1611: }
4571 5, 11, // 1616: case 0x5: {
4572 OPC_CheckPredicate, 47, // 1618: check predicate 47
4573 OPC_CheckField, 16, 5, 0, // 1620: check Inst[20:16] == 0x0
4574 OPC_Decode, 213, 12, 221, 1, // 1624: decode to FABS_S using decoder 221
4575 // 1624: }
4576 6, 11, // 1629: case 0x6: {
4577 OPC_CheckPredicate, 47, // 1631: check predicate 47
4578 OPC_CheckField, 16, 5, 0, // 1633: check Inst[20:16] == 0x0
4579 OPC_Decode, 183, 13, 221, 1, // 1637: decode to FMOV_S using decoder 221
4580 // 1637: }
4581 7, 11, // 1642: case 0x7: {
4582 OPC_CheckPredicate, 53, // 1644: check predicate 53
4583 OPC_CheckField, 16, 5, 0, // 1646: check Inst[20:16] == 0x0
4584 OPC_Decode, 202, 13, 221, 1, // 1650: decode to FNEG_S using decoder 221
4585 // 1650: }
4586 12, 11, // 1655: case 0xc: {
4587 OPC_CheckPredicate, 52, // 1657: check predicate 52
4588 OPC_CheckField, 16, 5, 0, // 1659: check Inst[20:16] == 0x0
4589 OPC_Decode, 158, 19, 221, 1, // 1663: decode to ROUND_W_S using decoder 221
4590 // 1663: }
4591 13, 11, // 1668: case 0xd: {
4592 OPC_CheckPredicate, 52, // 1670: check predicate 52
4593 OPC_CheckField, 16, 5, 0, // 1672: check Inst[20:16] == 0x0
4594 OPC_Decode, 197, 22, 221, 1, // 1676: decode to TRUNC_W_S using decoder 221
4595 // 1676: }
4596 14, 11, // 1681: case 0xe: {
4597 OPC_CheckPredicate, 52, // 1683: check predicate 52
4598 OPC_CheckField, 16, 5, 0, // 1685: check Inst[20:16] == 0x0
4599 OPC_Decode, 234, 8, 221, 1, // 1689: decode to CEIL_W_S using decoder 221
4600 // 1689: }
4601 15, 11, // 1694: case 0xf: {
4602 OPC_CheckPredicate, 52, // 1696: check predicate 52
4603 OPC_CheckField, 16, 5, 0, // 1698: check Inst[20:16] == 0x0
4604 OPC_Decode, 165, 13, 221, 1, // 1702: decode to FLOOR_W_S using decoder 221
4605 // 1702: }
4606 17, 21, // 1707: case 0x11: {
4607 OPC_SwitchField, 16, 2, // 1709: switch Inst[17:16] {
4608 0, 7, // 1712: case 0x0: {
4609 OPC_CheckPredicate, 29, // 1714: check predicate 29
4610 OPC_Decode, 240, 16, 222, 1, // 1716: decode to MOVF_S using decoder 222
4611 // 1716: }
4612 1, 0, // 1721: case 0x1: {
4613 OPC_CheckPredicate, 29, // 1723: check predicate 29
4614 OPC_Decode, 132, 17, 222, 1, // 1725: decode to MOVT_S using decoder 222
4615 // 1725: }
4616 // 1725: } // switch Inst[17:16]
4617 // 1725: }
4618 18, 7, // 1730: case 0x12: {
4619 OPC_CheckPredicate, 29, // 1732: check predicate 29
4620 OPC_Decode, 144, 17, 223, 1, // 1734: decode to MOVZ_I_S using decoder 223
4621 // 1734: }
4622 19, 7, // 1739: case 0x13: {
4623 OPC_CheckPredicate, 29, // 1741: check predicate 29
4624 OPC_Decode, 252, 16, 223, 1, // 1743: decode to MOVN_I_S using decoder 223
4625 // 1743: }
4626 21, 11, // 1748: case 0x15: {
4627 OPC_CheckPredicate, 54, // 1750: check predicate 54
4628 OPC_CheckField, 16, 5, 0, // 1752: check Inst[20:16] == 0x0
4629 OPC_Decode, 132, 19, 221, 1, // 1756: decode to RECIP_S using decoder 221
4630 // 1756: }
4631 22, 11, // 1761: case 0x16: {
4632 OPC_CheckPredicate, 54, // 1763: check predicate 54
4633 OPC_CheckField, 16, 5, 0, // 1765: check Inst[20:16] == 0x0
4634 OPC_Decode, 165, 19, 221, 1, // 1769: decode to RSQRT_S using decoder 221
4635 // 1769: }
4636 33, 11, // 1774: case 0x21: {
4637 OPC_CheckPredicate, 55, // 1776: check predicate 55
4638 OPC_CheckField, 16, 5, 0, // 1778: check Inst[20:16] == 0x0
4639 OPC_Decode, 148, 10, 224, 1, // 1782: decode to CVT_D32_S using decoder 224
4640 // 1782: }
4641 36, 11, // 1787: case 0x24: {
4642 OPC_CheckPredicate, 47, // 1789: check predicate 47
4643 OPC_CheckField, 16, 5, 0, // 1791: check Inst[20:16] == 0x0
4644 OPC_Decode, 182, 10, 221, 1, // 1795: decode to CVT_W_S using decoder 221
4645 // 1795: }
4646 37, 11, // 1800: case 0x25: {
4647 OPC_CheckPredicate, 56, // 1802: check predicate 56
4648 OPC_CheckField, 16, 5, 0, // 1804: check Inst[20:16] == 0x0
4649 OPC_Decode, 161, 10, 225, 1, // 1808: decode to CVT_L_S using decoder 225
4650 // 1808: }
4651 48, 11, // 1813: case 0x30: {
4652 OPC_CheckPredicate, 50, // 1815: check predicate 50
4653 OPC_CheckField, 6, 2, 0, // 1817: check Inst[7:6] == 0x0
4654 OPC_Decode, 195, 10, 226, 1, // 1821: decode to C_F_S using decoder 226
4655 // 1821: }
4656 49, 11, // 1826: case 0x31: {
4657 OPC_CheckPredicate, 50, // 1828: check predicate 50
4658 OPC_CheckField, 6, 2, 0, // 1830: check Inst[7:6] == 0x0
4659 OPC_Decode, 151, 11, 226, 1, // 1834: decode to C_UN_S using decoder 226
4660 // 1834: }
4661 50, 11, // 1839: case 0x32: {
4662 OPC_CheckPredicate, 50, // 1841: check predicate 50
4663 OPC_CheckField, 6, 2, 0, // 1843: check Inst[7:6] == 0x0
4664 OPC_Decode, 189, 10, 226, 1, // 1847: decode to C_EQ_S using decoder 226
4665 // 1847: }
4666 51, 11, // 1852: case 0x33: {
4667 OPC_CheckPredicate, 50, // 1854: check predicate 50
4668 OPC_CheckField, 6, 2, 0, // 1856: check Inst[7:6] == 0x0
4669 OPC_Decode, 133, 11, 226, 1, // 1860: decode to C_UEQ_S using decoder 226
4670 // 1860: }
4671 52, 11, // 1865: case 0x34: {
4672 OPC_CheckPredicate, 50, // 1867: check predicate 50
4673 OPC_CheckField, 6, 2, 0, // 1869: check Inst[7:6] == 0x0
4674 OPC_Decode, 243, 10, 226, 1, // 1873: decode to C_OLT_S using decoder 226
4675 // 1873: }
4676 53, 11, // 1878: case 0x35: {
4677 OPC_CheckPredicate, 50, // 1880: check predicate 50
4678 OPC_CheckField, 6, 2, 0, // 1882: check Inst[7:6] == 0x0
4679 OPC_Decode, 145, 11, 226, 1, // 1886: decode to C_ULT_S using decoder 226
4680 // 1886: }
4681 54, 11, // 1891: case 0x36: {
4682 OPC_CheckPredicate, 50, // 1893: check predicate 50
4683 OPC_CheckField, 6, 2, 0, // 1895: check Inst[7:6] == 0x0
4684 OPC_Decode, 237, 10, 226, 1, // 1899: decode to C_OLE_S using decoder 226
4685 // 1899: }
4686 55, 11, // 1904: case 0x37: {
4687 OPC_CheckPredicate, 50, // 1906: check predicate 50
4688 OPC_CheckField, 6, 2, 0, // 1908: check Inst[7:6] == 0x0
4689 OPC_Decode, 139, 11, 226, 1, // 1912: decode to C_ULE_S using decoder 226
4690 // 1912: }
4691 56, 11, // 1917: case 0x38: {
4692 OPC_CheckPredicate, 50, // 1919: check predicate 50
4693 OPC_CheckField, 6, 2, 0, // 1921: check Inst[7:6] == 0x0
4694 OPC_Decode, 255, 10, 226, 1, // 1925: decode to C_SF_S using decoder 226
4695 // 1925: }
4696 57, 11, // 1930: case 0x39: {
4697 OPC_CheckPredicate, 50, // 1932: check predicate 50
4698 OPC_CheckField, 6, 2, 0, // 1934: check Inst[7:6] == 0x0
4699 OPC_Decode, 219, 10, 226, 1, // 1938: decode to C_NGLE_S using decoder 226
4700 // 1938: }
4701 58, 11, // 1943: case 0x3a: {
4702 OPC_CheckPredicate, 50, // 1945: check predicate 50
4703 OPC_CheckField, 6, 2, 0, // 1947: check Inst[7:6] == 0x0
4704 OPC_Decode, 249, 10, 226, 1, // 1951: decode to C_SEQ_S using decoder 226
4705 // 1951: }
4706 59, 11, // 1956: case 0x3b: {
4707 OPC_CheckPredicate, 50, // 1958: check predicate 50
4708 OPC_CheckField, 6, 2, 0, // 1960: check Inst[7:6] == 0x0
4709 OPC_Decode, 225, 10, 226, 1, // 1964: decode to C_NGL_S using decoder 226
4710 // 1964: }
4711 60, 11, // 1969: case 0x3c: {
4712 OPC_CheckPredicate, 50, // 1971: check predicate 50
4713 OPC_CheckField, 6, 2, 0, // 1973: check Inst[7:6] == 0x0
4714 OPC_Decode, 207, 10, 226, 1, // 1977: decode to C_LT_S using decoder 226
4715 // 1977: }
4716 61, 11, // 1982: case 0x3d: {
4717 OPC_CheckPredicate, 50, // 1984: check predicate 50
4718 OPC_CheckField, 6, 2, 0, // 1986: check Inst[7:6] == 0x0
4719 OPC_Decode, 213, 10, 226, 1, // 1990: decode to C_NGE_S using decoder 226
4720 // 1990: }
4721 62, 11, // 1995: case 0x3e: {
4722 OPC_CheckPredicate, 50, // 1997: check predicate 50
4723 OPC_CheckField, 6, 2, 0, // 1999: check Inst[7:6] == 0x0
4724 OPC_Decode, 201, 10, 226, 1, // 2003: decode to C_LE_S using decoder 226
4725 // 2003: }
4726 63, 0, // 2008: case 0x3f: {
4727 OPC_CheckPredicate, 50, // 2010: check predicate 50
4728 OPC_CheckField, 6, 2, 0, // 2012: check Inst[7:6] == 0x0
4729 OPC_Decode, 231, 10, 226, 1, // 2016: decode to C_NGT_S using decoder 226
4730 // 2016: }
4731 // 2016: } // switch Inst[5:0]
4732 // 2016: }
4733 17, 201, 3, // 2021: case 0x11: {
4734 OPC_SwitchField, 0, 6, // 2024: switch Inst[5:0] {
4735 0, 7, // 2027: case 0x0: {
4736 OPC_CheckPredicate, 55, // 2029: check predicate 55
4737 OPC_Decode, 216, 12, 227, 1, // 2031: decode to FADD_D32 using decoder 227
4738 // 2031: }
4739 1, 7, // 2036: case 0x1: {
4740 OPC_CheckPredicate, 55, // 2038: check predicate 55
4741 OPC_Decode, 233, 13, 227, 1, // 2040: decode to FSUB_D32 using decoder 227
4742 // 2040: }
4743 2, 7, // 2045: case 0x2: {
4744 OPC_CheckPredicate, 55, // 2047: check predicate 55
4745 OPC_Decode, 189, 13, 227, 1, // 2049: decode to FMUL_D32 using decoder 227
4746 // 2049: }
4747 3, 7, // 2054: case 0x3: {
4748 OPC_CheckPredicate, 55, // 2056: check predicate 55
4749 OPC_Decode, 255, 12, 227, 1, // 2058: decode to FDIV_D32 using decoder 227
4750 // 2058: }
4751 4, 11, // 2063: case 0x4: {
4752 OPC_CheckPredicate, 57, // 2065: check predicate 57
4753 OPC_CheckField, 16, 5, 0, // 2067: check Inst[20:16] == 0x0
4754 OPC_Decode, 225, 13, 228, 1, // 2071: decode to FSQRT_D32 using decoder 228
4755 // 2071: }
4756 5, 11, // 2076: case 0x5: {
4757 OPC_CheckPredicate, 55, // 2078: check predicate 55
4758 OPC_CheckField, 16, 5, 0, // 2080: check Inst[20:16] == 0x0
4759 OPC_Decode, 209, 12, 228, 1, // 2084: decode to FABS_D32 using decoder 228
4760 // 2084: }
4761 6, 11, // 2089: case 0x6: {
4762 OPC_CheckPredicate, 55, // 2091: check predicate 55
4763 OPC_CheckField, 16, 5, 0, // 2093: check Inst[20:16] == 0x0
4764 OPC_Decode, 178, 13, 228, 1, // 2097: decode to FMOV_D32 using decoder 228
4765 // 2097: }
4766 7, 11, // 2102: case 0x7: {
4767 OPC_CheckPredicate, 55, // 2104: check predicate 55
4768 OPC_CheckField, 16, 5, 0, // 2106: check Inst[20:16] == 0x0
4769 OPC_Decode, 198, 13, 228, 1, // 2110: decode to FNEG_D32 using decoder 228
4770 // 2110: }
4771 12, 11, // 2115: case 0xc: {
4772 OPC_CheckPredicate, 57, // 2117: check predicate 57
4773 OPC_CheckField, 16, 5, 0, // 2119: check Inst[20:16] == 0x0
4774 OPC_Decode, 154, 19, 229, 1, // 2123: decode to ROUND_W_D32 using decoder 229
4775 // 2123: }
4776 13, 11, // 2128: case 0xd: {
4777 OPC_CheckPredicate, 57, // 2130: check predicate 57
4778 OPC_CheckField, 16, 5, 0, // 2132: check Inst[20:16] == 0x0
4779 OPC_Decode, 193, 22, 229, 1, // 2136: decode to TRUNC_W_D32 using decoder 229
4780 // 2136: }
4781 14, 11, // 2141: case 0xe: {
4782 OPC_CheckPredicate, 57, // 2143: check predicate 57
4783 OPC_CheckField, 16, 5, 0, // 2145: check Inst[20:16] == 0x0
4784 OPC_Decode, 230, 8, 229, 1, // 2149: decode to CEIL_W_D32 using decoder 229
4785 // 2149: }
4786 15, 11, // 2154: case 0xf: {
4787 OPC_CheckPredicate, 57, // 2156: check predicate 57
4788 OPC_CheckField, 16, 5, 0, // 2158: check Inst[20:16] == 0x0
4789 OPC_Decode, 161, 13, 229, 1, // 2162: decode to FLOOR_W_D32 using decoder 229
4790 // 2162: }
4791 17, 21, // 2167: case 0x11: {
4792 OPC_SwitchField, 16, 2, // 2169: switch Inst[17:16] {
4793 0, 7, // 2172: case 0x0: {
4794 OPC_CheckPredicate, 58, // 2174: check predicate 58
4795 OPC_Decode, 234, 16, 230, 1, // 2176: decode to MOVF_D32 using decoder 230
4796 // 2176: }
4797 1, 0, // 2181: case 0x1: {
4798 OPC_CheckPredicate, 58, // 2183: check predicate 58
4799 OPC_Decode, 254, 16, 230, 1, // 2185: decode to MOVT_D32 using decoder 230
4800 // 2185: }
4801 // 2185: } // switch Inst[17:16]
4802 // 2185: }
4803 18, 7, // 2190: case 0x12: {
4804 OPC_CheckPredicate, 58, // 2192: check predicate 58
4805 OPC_Decode, 138, 17, 231, 1, // 2194: decode to MOVZ_I_D32 using decoder 231
4806 // 2194: }
4807 19, 7, // 2199: case 0x13: {
4808 OPC_CheckPredicate, 58, // 2201: check predicate 58
4809 OPC_Decode, 246, 16, 231, 1, // 2203: decode to MOVN_I_D32 using decoder 231
4810 // 2203: }
4811 21, 11, // 2208: case 0x15: {
4812 OPC_CheckPredicate, 59, // 2210: check predicate 59
4813 OPC_CheckField, 16, 5, 0, // 2212: check Inst[20:16] == 0x0
4814 OPC_Decode, 128, 19, 228, 1, // 2216: decode to RECIP_D32 using decoder 228
4815 // 2216: }
4816 22, 11, // 2221: case 0x16: {
4817 OPC_CheckPredicate, 59, // 2223: check predicate 59
4818 OPC_CheckField, 16, 5, 0, // 2225: check Inst[20:16] == 0x0
4819 OPC_Decode, 161, 19, 228, 1, // 2229: decode to RSQRT_D32 using decoder 228
4820 // 2229: }
4821 32, 11, // 2234: case 0x20: {
4822 OPC_CheckPredicate, 55, // 2236: check predicate 55
4823 OPC_CheckField, 16, 5, 0, // 2238: check Inst[20:16] == 0x0
4824 OPC_Decode, 167, 10, 229, 1, // 2242: decode to CVT_S_D32 using decoder 229
4825 // 2242: }
4826 36, 11, // 2247: case 0x24: {
4827 OPC_CheckPredicate, 55, // 2249: check predicate 55
4828 OPC_CheckField, 16, 5, 0, // 2251: check Inst[20:16] == 0x0
4829 OPC_Decode, 178, 10, 229, 1, // 2255: decode to CVT_W_D32 using decoder 229
4830 // 2255: }
4831 37, 11, // 2260: case 0x25: {
4832 OPC_CheckPredicate, 56, // 2262: check predicate 56
4833 OPC_CheckField, 16, 5, 0, // 2264: check Inst[20:16] == 0x0
4834 OPC_Decode, 158, 10, 232, 1, // 2268: decode to CVT_L_D64 using decoder 232
4835 // 2268: }
4836 48, 11, // 2273: case 0x30: {
4837 OPC_CheckPredicate, 60, // 2275: check predicate 60
4838 OPC_CheckField, 6, 2, 0, // 2277: check Inst[7:6] == 0x0
4839 OPC_Decode, 191, 10, 233, 1, // 2281: decode to C_F_D32 using decoder 233
4840 // 2281: }
4841 49, 11, // 2286: case 0x31: {
4842 OPC_CheckPredicate, 60, // 2288: check predicate 60
4843 OPC_CheckField, 6, 2, 0, // 2290: check Inst[7:6] == 0x0
4844 OPC_Decode, 147, 11, 233, 1, // 2294: decode to C_UN_D32 using decoder 233
4845 // 2294: }
4846 50, 11, // 2299: case 0x32: {
4847 OPC_CheckPredicate, 60, // 2301: check predicate 60
4848 OPC_CheckField, 6, 2, 0, // 2303: check Inst[7:6] == 0x0
4849 OPC_Decode, 185, 10, 233, 1, // 2307: decode to C_EQ_D32 using decoder 233
4850 // 2307: }
4851 51, 11, // 2312: case 0x33: {
4852 OPC_CheckPredicate, 60, // 2314: check predicate 60
4853 OPC_CheckField, 6, 2, 0, // 2316: check Inst[7:6] == 0x0
4854 OPC_Decode, 129, 11, 233, 1, // 2320: decode to C_UEQ_D32 using decoder 233
4855 // 2320: }
4856 52, 11, // 2325: case 0x34: {
4857 OPC_CheckPredicate, 60, // 2327: check predicate 60
4858 OPC_CheckField, 6, 2, 0, // 2329: check Inst[7:6] == 0x0
4859 OPC_Decode, 239, 10, 233, 1, // 2333: decode to C_OLT_D32 using decoder 233
4860 // 2333: }
4861 53, 11, // 2338: case 0x35: {
4862 OPC_CheckPredicate, 60, // 2340: check predicate 60
4863 OPC_CheckField, 6, 2, 0, // 2342: check Inst[7:6] == 0x0
4864 OPC_Decode, 141, 11, 233, 1, // 2346: decode to C_ULT_D32 using decoder 233
4865 // 2346: }
4866 54, 11, // 2351: case 0x36: {
4867 OPC_CheckPredicate, 60, // 2353: check predicate 60
4868 OPC_CheckField, 6, 2, 0, // 2355: check Inst[7:6] == 0x0
4869 OPC_Decode, 233, 10, 233, 1, // 2359: decode to C_OLE_D32 using decoder 233
4870 // 2359: }
4871 55, 11, // 2364: case 0x37: {
4872 OPC_CheckPredicate, 60, // 2366: check predicate 60
4873 OPC_CheckField, 6, 2, 0, // 2368: check Inst[7:6] == 0x0
4874 OPC_Decode, 135, 11, 233, 1, // 2372: decode to C_ULE_D32 using decoder 233
4875 // 2372: }
4876 56, 11, // 2377: case 0x38: {
4877 OPC_CheckPredicate, 60, // 2379: check predicate 60
4878 OPC_CheckField, 6, 2, 0, // 2381: check Inst[7:6] == 0x0
4879 OPC_Decode, 251, 10, 233, 1, // 2385: decode to C_SF_D32 using decoder 233
4880 // 2385: }
4881 57, 11, // 2390: case 0x39: {
4882 OPC_CheckPredicate, 60, // 2392: check predicate 60
4883 OPC_CheckField, 6, 2, 0, // 2394: check Inst[7:6] == 0x0
4884 OPC_Decode, 215, 10, 233, 1, // 2398: decode to C_NGLE_D32 using decoder 233
4885 // 2398: }
4886 58, 11, // 2403: case 0x3a: {
4887 OPC_CheckPredicate, 60, // 2405: check predicate 60
4888 OPC_CheckField, 6, 2, 0, // 2407: check Inst[7:6] == 0x0
4889 OPC_Decode, 245, 10, 233, 1, // 2411: decode to C_SEQ_D32 using decoder 233
4890 // 2411: }
4891 59, 11, // 2416: case 0x3b: {
4892 OPC_CheckPredicate, 60, // 2418: check predicate 60
4893 OPC_CheckField, 6, 2, 0, // 2420: check Inst[7:6] == 0x0
4894 OPC_Decode, 221, 10, 233, 1, // 2424: decode to C_NGL_D32 using decoder 233
4895 // 2424: }
4896 60, 11, // 2429: case 0x3c: {
4897 OPC_CheckPredicate, 60, // 2431: check predicate 60
4898 OPC_CheckField, 6, 2, 0, // 2433: check Inst[7:6] == 0x0
4899 OPC_Decode, 203, 10, 233, 1, // 2437: decode to C_LT_D32 using decoder 233
4900 // 2437: }
4901 61, 11, // 2442: case 0x3d: {
4902 OPC_CheckPredicate, 60, // 2444: check predicate 60
4903 OPC_CheckField, 6, 2, 0, // 2446: check Inst[7:6] == 0x0
4904 OPC_Decode, 209, 10, 233, 1, // 2450: decode to C_NGE_D32 using decoder 233
4905 // 2450: }
4906 62, 11, // 2455: case 0x3e: {
4907 OPC_CheckPredicate, 60, // 2457: check predicate 60
4908 OPC_CheckField, 6, 2, 0, // 2459: check Inst[7:6] == 0x0
4909 OPC_Decode, 197, 10, 233, 1, // 2463: decode to C_LE_D32 using decoder 233
4910 // 2463: }
4911 63, 0, // 2468: case 0x3f: {
4912 OPC_CheckPredicate, 60, // 2470: check predicate 60
4913 OPC_CheckField, 6, 2, 0, // 2472: check Inst[7:6] == 0x0
4914 OPC_Decode, 227, 10, 233, 1, // 2476: decode to C_NGT_D32 using decoder 233
4915 // 2476: }
4916 // 2476: } // switch Inst[5:0]
4917 // 2476: }
4918 20, 29, // 2481: case 0x14: {
4919 OPC_SwitchField, 0, 6, // 2483: switch Inst[5:0] {
4920 32, 11, // 2486: case 0x20: {
4921 OPC_CheckPredicate, 47, // 2488: check predicate 47
4922 OPC_CheckField, 16, 5, 0, // 2490: check Inst[20:16] == 0x0
4923 OPC_Decode, 175, 10, 221, 1, // 2494: decode to CVT_S_W using decoder 221
4924 // 2494: }
4925 33, 0, // 2499: case 0x21: {
4926 OPC_CheckPredicate, 55, // 2501: check predicate 55
4927 OPC_CheckField, 16, 5, 0, // 2503: check Inst[20:16] == 0x0
4928 OPC_Decode, 150, 10, 224, 1, // 2507: decode to CVT_D32_W using decoder 224
4929 // 2507: }
4930 // 2507: } // switch Inst[5:0]
4931 // 2507: }
4932 24, 7, // 2512: case 0x18: {
4933 OPC_CheckPredicate, 30, // 2514: check predicate 30
4934 OPC_Decode, 204, 8, 219, 1, // 2516: decode to BZ_B using decoder 219
4935 // 2516: }
4936 25, 7, // 2521: case 0x19: {
4937 OPC_CheckPredicate, 30, // 2523: check predicate 30
4938 OPC_Decode, 206, 8, 234, 1, // 2525: decode to BZ_H using decoder 234
4939 // 2525: }
4940 26, 7, // 2530: case 0x1a: {
4941 OPC_CheckPredicate, 30, // 2532: check predicate 30
4942 OPC_Decode, 208, 8, 235, 1, // 2534: decode to BZ_W using decoder 235
4943 // 2534: }
4944 27, 7, // 2539: case 0x1b: {
4945 OPC_CheckPredicate, 30, // 2541: check predicate 30
4946 OPC_Decode, 205, 8, 236, 1, // 2543: decode to BZ_D using decoder 236
4947 // 2543: }
4948 28, 7, // 2548: case 0x1c: {
4949 OPC_CheckPredicate, 30, // 2550: check predicate 30
4950 OPC_Decode, 179, 8, 219, 1, // 2552: decode to BNZ_B using decoder 219
4951 // 2552: }
4952 29, 7, // 2557: case 0x1d: {
4953 OPC_CheckPredicate, 30, // 2559: check predicate 30
4954 OPC_Decode, 181, 8, 234, 1, // 2561: decode to BNZ_H using decoder 234
4955 // 2561: }
4956 30, 7, // 2566: case 0x1e: {
4957 OPC_CheckPredicate, 30, // 2568: check predicate 30
4958 OPC_Decode, 183, 8, 235, 1, // 2570: decode to BNZ_W using decoder 235
4959 // 2570: }
4960 31, 0, // 2575: case 0x1f: {
4961 OPC_CheckPredicate, 30, // 2577: check predicate 30
4962 OPC_Decode, 180, 8, 236, 1, // 2579: decode to BNZ_D using decoder 236
4963 // 2579: }
4964 // 2579: } // switch Inst[25:21]
4965 // 2579: }
4966 18, 29, // 2584: case 0x12: {
4967 OPC_SwitchField, 21, 5, // 2586: switch Inst[25:21] {
4968 0, 11, // 2589: case 0x0: {
4969 OPC_CheckPredicate, 27, // 2591: check predicate 27
4970 OPC_CheckField, 3, 8, 0, // 2593: check Inst[10:3] == 0x0
4971 OPC_Decode, 162, 16, 237, 1, // 2597: decode to MFC2 using decoder 237
4972 // 2597: }
4973 4, 0, // 2602: case 0x4: {
4974 OPC_CheckPredicate, 27, // 2604: check predicate 27
4975 OPC_CheckField, 3, 8, 0, // 2606: check Inst[10:3] == 0x0
4976 OPC_Decode, 178, 17, 238, 1, // 2610: decode to MTC2 using decoder 238
4977 // 2610: }
4978 // 2610: } // switch Inst[25:21]
4979 // 2610: }
4980 19, 153, 1, // 2615: case 0x13: {
4981 OPC_SwitchField, 0, 6, // 2618: switch Inst[5:0] {
4982 0, 11, // 2621: case 0x0: {
4983 OPC_CheckPredicate, 61, // 2623: check predicate 61
4984 OPC_CheckField, 11, 5, 0, // 2625: check Inst[15:11] == 0x0
4985 OPC_Decode, 205, 15, 239, 1, // 2629: decode to LWXC1 using decoder 239
4986 // 2629: }
4987 1, 11, // 2634: case 0x1: {
4988 OPC_CheckPredicate, 62, // 2636: check predicate 62
4989 OPC_CheckField, 11, 5, 0, // 2638: check Inst[15:11] == 0x0
4990 OPC_Decode, 255, 14, 240, 1, // 2642: decode to LDXC1 using decoder 240
4991 // 2642: }
4992 5, 11, // 2647: case 0x5: {
4993 OPC_CheckPredicate, 63, // 2649: check predicate 63
4994 OPC_CheckField, 11, 5, 0, // 2651: check Inst[15:11] == 0x0
4995 OPC_Decode, 165, 15, 240, 1, // 2655: decode to LUXC1 using decoder 240
4996 // 2655: }
4997 8, 11, // 2660: case 0x8: {
4998 OPC_CheckPredicate, 61, // 2662: check predicate 61
4999 OPC_CheckField, 6, 5, 0, // 2664: check Inst[10:6] == 0x0
5000 OPC_Decode, 237, 21, 241, 1, // 2668: decode to SWXC1 using decoder 241
5001 // 2668: }
5002 9, 11, // 2673: case 0x9: {
5003 OPC_CheckPredicate, 62, // 2675: check predicate 62
5004 OPC_CheckField, 6, 5, 0, // 2677: check Inst[10:6] == 0x0
5005 OPC_Decode, 217, 19, 242, 1, // 2681: decode to SDXC1 using decoder 242
5006 // 2681: }
5007 13, 11, // 2686: case 0xd: {
5008 OPC_CheckPredicate, 63, // 2688: check predicate 63
5009 OPC_CheckField, 6, 5, 0, // 2690: check Inst[10:6] == 0x0
5010 OPC_Decode, 204, 21, 242, 1, // 2694: decode to SUXC1 using decoder 242
5011 // 2694: }
5012 32, 7, // 2699: case 0x20: {
5013 OPC_CheckPredicate, 64, // 2701: check predicate 64
5014 OPC_Decode, 246, 15, 243, 1, // 2703: decode to MADD_S using decoder 243
5015 // 2703: }
5016 33, 7, // 2708: case 0x21: {
5017 OPC_CheckPredicate, 65, // 2710: check predicate 65
5018 OPC_Decode, 238, 15, 244, 1, // 2712: decode to MADD_D32 using decoder 244
5019 // 2712: }
5020 40, 7, // 2717: case 0x28: {
5021 OPC_CheckPredicate, 64, // 2719: check predicate 64
5022 OPC_Decode, 169, 17, 243, 1, // 2721: decode to MSUB_S using decoder 243
5023 // 2721: }
5024 41, 7, // 2726: case 0x29: {
5025 OPC_CheckPredicate, 65, // 2728: check predicate 65
5026 OPC_Decode, 161, 17, 244, 1, // 2730: decode to MSUB_D32 using decoder 244
5027 // 2730: }
5028 48, 7, // 2735: case 0x30: {
5029 OPC_CheckPredicate, 66, // 2737: check predicate 66
5030 OPC_Decode, 148, 18, 243, 1, // 2739: decode to NMADD_S using decoder 243
5031 // 2739: }
5032 49, 7, // 2744: case 0x31: {
5033 OPC_CheckPredicate, 67, // 2746: check predicate 67
5034 OPC_Decode, 145, 18, 244, 1, // 2748: decode to NMADD_D32 using decoder 244
5035 // 2748: }
5036 56, 7, // 2753: case 0x38: {
5037 OPC_CheckPredicate, 66, // 2755: check predicate 66
5038 OPC_Decode, 153, 18, 243, 1, // 2757: decode to NMSUB_S using decoder 243
5039 // 2757: }
5040 57, 0, // 2762: case 0x39: {
5041 OPC_CheckPredicate, 67, // 2764: check predicate 67
5042 OPC_Decode, 150, 18, 244, 1, // 2766: decode to NMSUB_D32 using decoder 244
5043 // 2766: }
5044 // 2766: } // switch Inst[5:0]
5045 // 2766: }
5046 20, 7, // 2771: case 0x14: {
5047 OPC_CheckPredicate, 39, // 2773: check predicate 39
5048 OPC_Decode, 192, 7, 203, 1, // 2775: decode to BEQL using decoder 203
5049 // 2775: }
5050 21, 74, // 2780: case 0x15: {
5051 OPC_Scope, 22, // 2782: try {
5052 OPC_SwitchField, 0, 16, // 2784: switch Inst[15:0] {
5053 123, 7, // 2787: case 0x7b: {
5054 OPC_CheckPredicate, 20, // 2789: check predicate 20
5055 OPC_Decode, 184, 13, 131, 1, // 2791: decode to FMOV_S_MM using decoder 131
5056 // 2791: }
5057 251, 22, 0, // 2796: case 0xb7b: {
5058 OPC_CheckPredicate, 20, // 2799: check predicate 20
5059 OPC_Decode, 203, 13, 131, 1, // 2801: decode to FNEG_S_MM using decoder 131
5060 // 2801: }
5061 // 2801: } // switch Inst[15:0]
5062 OPC_Scope, 41, // 2806: } else try {
5063 OPC_SwitchField, 0, 11, // 2808: switch Inst[10:0] {
5064 48, 7, // 2811: case 0x30: {
5065 OPC_CheckPredicate, 20, // 2813: check predicate 20
5066 OPC_Decode, 222, 12, 165, 1, // 2815: decode to FADD_S_MM using decoder 165
5067 // 2815: }
5068 112, 7, // 2820: case 0x70: {
5069 OPC_CheckPredicate, 20, // 2822: check predicate 20
5070 OPC_Decode, 239, 13, 165, 1, // 2824: decode to FSUB_S_MM using decoder 165
5071 // 2824: }
5072 176, 1, 7, // 2829: case 0xb0: {
5073 OPC_CheckPredicate, 20, // 2832: check predicate 20
5074 OPC_Decode, 195, 13, 165, 1, // 2834: decode to FMUL_S_MM using decoder 165
5075 // 2834: }
5076 240, 1, 0, // 2839: case 0xf0: {
5077 OPC_CheckPredicate, 20, // 2842: check predicate 20
5078 OPC_Decode, 132, 13, 165, 1, // 2844: decode to FDIV_S_MM using decoder 165
5079 // 2844: }
5080 // 2844: } // switch Inst[10:0]
5081 // 2844: } else try {
5082 OPC_CheckPredicate, 39, // 2849: check predicate 39
5083 OPC_Decode, 167, 8, 203, 1, // 2851: decode to BNEL using decoder 203
5084 // 2851: }
5085 // 2851: }
5086 22, 11, // 2856: case 0x16: {
5087 OPC_CheckPredicate, 39, // 2858: check predicate 39
5088 OPC_CheckField, 16, 5, 0, // 2860: check Inst[20:16] == 0x0
5089 OPC_Decode, 129, 8, 199, 1, // 2864: decode to BLEZL using decoder 199
5090 // 2864: }
5091 23, 11, // 2869: case 0x17: {
5092 OPC_CheckPredicate, 39, // 2871: check predicate 39
5093 OPC_CheckField, 16, 5, 0, // 2873: check Inst[20:16] == 0x0
5094 OPC_Decode, 228, 7, 199, 1, // 2877: decode to BGTZL using decoder 199
5095 // 2877: }
5096 28, 166, 1, // 2882: case 0x1c: {
5097 OPC_SwitchField, 0, 6, // 2885: switch Inst[5:0] {
5098 0, 27, // 2888: case 0x0: {
5099 OPC_CheckField, 6, 5, 0, // 2890: check Inst[10:6] == 0x0
5100 OPC_CheckField, 13, 3, 0, // 2894: check Inst[15:13] == 0x0
5101 OPC_Scope, 10, // 2898: try {
5102 OPC_CheckField, 11, 2, 0, // 2900: check Inst[12:11] == 0x0
5103 OPC_CheckPredicate, 68, // 2904: check predicate 68
5104 OPC_Decode, 223, 15, 86, // 2906: decode to MADD using decoder 86
5105 // 2906: } else try {
5106 OPC_CheckPredicate, 37, // 2910: check predicate 37
5107 OPC_Decode, 241, 15, 245, 1, // 2912: decode to MADD_DSP using decoder 245
5108 // 2912: }
5109 // 2912: }
5110 1, 27, // 2917: case 0x1: {
5111 OPC_CheckField, 6, 5, 0, // 2919: check Inst[10:6] == 0x0
5112 OPC_CheckField, 13, 3, 0, // 2923: check Inst[15:13] == 0x0
5113 OPC_Scope, 10, // 2927: try {
5114 OPC_CheckField, 11, 2, 0, // 2929: check Inst[12:11] == 0x0
5115 OPC_CheckPredicate, 68, // 2933: check predicate 68
5116 OPC_Decode, 230, 15, 86, // 2935: decode to MADDU using decoder 86
5117 // 2935: } else try {
5118 OPC_CheckPredicate, 37, // 2939: check predicate 37
5119 OPC_Decode, 231, 15, 245, 1, // 2941: decode to MADDU_DSP using decoder 245
5120 // 2941: }
5121 // 2941: }
5122 2, 10, // 2946: case 0x2: {
5123 OPC_CheckPredicate, 68, // 2948: check predicate 68
5124 OPC_CheckField, 6, 5, 0, // 2950: check Inst[10:6] == 0x0
5125 OPC_Decode, 213, 17, 67, // 2954: decode to MUL using decoder 67
5126 // 2954: }
5127 4, 27, // 2958: case 0x4: {
5128 OPC_CheckField, 6, 5, 0, // 2960: check Inst[10:6] == 0x0
5129 OPC_CheckField, 13, 3, 0, // 2964: check Inst[15:13] == 0x0
5130 OPC_Scope, 10, // 2968: try {
5131 OPC_CheckField, 11, 2, 0, // 2970: check Inst[12:11] == 0x0
5132 OPC_CheckPredicate, 68, // 2974: check predicate 68
5133 OPC_Decode, 146, 17, 86, // 2976: decode to MSUB using decoder 86
5134 // 2976: } else try {
5135 OPC_CheckPredicate, 37, // 2980: check predicate 37
5136 OPC_Decode, 164, 17, 245, 1, // 2982: decode to MSUB_DSP using decoder 245
5137 // 2982: }
5138 // 2982: }
5139 5, 27, // 2987: case 0x5: {
5140 OPC_CheckField, 6, 5, 0, // 2989: check Inst[10:6] == 0x0
5141 OPC_CheckField, 13, 3, 0, // 2993: check Inst[15:13] == 0x0
5142 OPC_Scope, 10, // 2997: try {
5143 OPC_CheckField, 11, 2, 0, // 2999: check Inst[12:11] == 0x0
5144 OPC_CheckPredicate, 68, // 3003: check predicate 68
5145 OPC_Decode, 153, 17, 86, // 3005: decode to MSUBU using decoder 86
5146 // 3005: } else try {
5147 OPC_CheckPredicate, 37, // 3009: check predicate 37
5148 OPC_Decode, 154, 17, 245, 1, // 3011: decode to MSUBU_DSP using decoder 245
5149 // 3011: }
5150 // 3011: }
5151 32, 11, // 3016: case 0x20: {
5152 OPC_CheckPredicate, 68, // 3018: check predicate 68
5153 OPC_CheckField, 6, 5, 0, // 3020: check Inst[10:6] == 0x0
5154 OPC_Decode, 165, 9, 246, 1, // 3024: decode to CLZ using decoder 246
5155 // 3024: }
5156 33, 11, // 3029: case 0x21: {
5157 OPC_CheckPredicate, 68, // 3031: check predicate 68
5158 OPC_CheckField, 6, 5, 0, // 3033: check Inst[10:6] == 0x0
5159 OPC_Decode, 145, 9, 246, 1, // 3037: decode to CLO using decoder 246
5160 // 3037: }
5161 63, 0, // 3042: case 0x3f: {
5162 OPC_CheckPredicate, 68, // 3044: check predicate 68
5163 OPC_Decode, 198, 19, 190, 1, // 3046: decode to SDBBP using decoder 190
5164 // 3046: }
5165 // 3046: } // switch Inst[5:0]
5166 // 3046: }
5167 29, 7, // 3051: case 0x1d: {
5168 OPC_CheckPredicate, 68, // 3053: check predicate 68
5169 OPC_Decode, 195, 14, 202, 1, // 3055: decode to JALX using decoder 202
5170 // 3055: }
5171 30, 197, 39, // 3060: case 0x1e: {
5172 OPC_SwitchField, 0, 6, // 3063: switch Inst[5:0] {
5173 0, 39, // 3066: case 0x0: {
5174 OPC_SwitchField, 24, 2, // 3068: switch Inst[25:24] {
5175 0, 7, // 3071: case 0x0: {
5176 OPC_CheckPredicate, 30, // 3073: check predicate 30
5177 OPC_Decode, 232, 6, 247, 1, // 3075: decode to ANDI_B using decoder 247
5178 // 3075: }
5179 1, 7, // 3080: case 0x1: {
5180 OPC_CheckPredicate, 30, // 3082: check predicate 30
5181 OPC_Decode, 169, 18, 247, 1, // 3084: decode to ORI_B using decoder 247
5182 // 3084: }
5183 2, 7, // 3089: case 0x2: {
5184 OPC_CheckPredicate, 30, // 3091: check predicate 30
5185 OPC_Decode, 157, 18, 247, 1, // 3093: decode to NORI_B using decoder 247
5186 // 3093: }
5187 3, 0, // 3098: case 0x3: {
5188 OPC_CheckPredicate, 30, // 3100: check predicate 30
5189 OPC_Decode, 223, 22, 247, 1, // 3102: decode to XORI_B using decoder 247
5190 // 3102: }
5191 // 3102: } // switch Inst[25:24]
5192 // 3102: }
5193 1, 30, // 3107: case 0x1: {
5194 OPC_SwitchField, 24, 2, // 3109: switch Inst[25:24] {
5195 0, 7, // 3112: case 0x0: {
5196 OPC_CheckPredicate, 30, // 3114: check predicate 30
5197 OPC_Decode, 150, 8, 248, 1, // 3116: decode to BMNZI_B using decoder 248
5198 // 3116: }
5199 1, 7, // 3121: case 0x1: {
5200 OPC_CheckPredicate, 30, // 3123: check predicate 30
5201 OPC_Decode, 152, 8, 248, 1, // 3125: decode to BMZI_B using decoder 248
5202 // 3125: }
5203 2, 0, // 3130: case 0x2: {
5204 OPC_CheckPredicate, 30, // 3132: check predicate 30
5205 OPC_Decode, 194, 8, 248, 1, // 3134: decode to BSELI_B using decoder 248
5206 // 3134: }
5207 // 3134: } // switch Inst[25:24]
5208 // 3134: }
5209 2, 30, // 3139: case 0x2: {
5210 OPC_SwitchField, 24, 2, // 3141: switch Inst[25:24] {
5211 0, 7, // 3144: case 0x0: {
5212 OPC_CheckPredicate, 30, // 3146: check predicate 30
5213 OPC_Decode, 251, 19, 247, 1, // 3148: decode to SHF_B using decoder 247
5214 // 3148: }
5215 1, 7, // 3153: case 0x1: {
5216 OPC_CheckPredicate, 30, // 3155: check predicate 30
5217 OPC_Decode, 252, 19, 249, 1, // 3157: decode to SHF_H using decoder 249
5218 // 3157: }
5219 2, 0, // 3162: case 0x2: {
5220 OPC_CheckPredicate, 30, // 3164: check predicate 30
5221 OPC_Decode, 253, 19, 250, 1, // 3166: decode to SHF_W using decoder 250
5222 // 3166: }
5223 // 3166: } // switch Inst[25:24]
5224 // 3166: }
5225 6, 219, 1, // 3171: case 0x6: {
5226 OPC_SwitchField, 21, 5, // 3174: switch Inst[25:21] {
5227 0, 7, // 3177: case 0x0: {
5228 OPC_CheckPredicate, 30, // 3179: check predicate 30
5229 OPC_Decode, 200, 6, 251, 1, // 3181: decode to ADDVI_B using decoder 251
5230 // 3181: }
5231 1, 7, // 3186: case 0x1: {
5232 OPC_CheckPredicate, 30, // 3188: check predicate 30
5233 OPC_Decode, 202, 6, 252, 1, // 3190: decode to ADDVI_H using decoder 252
5234 // 3190: }
5235 2, 7, // 3195: case 0x2: {
5236 OPC_CheckPredicate, 30, // 3197: check predicate 30
5237 OPC_Decode, 203, 6, 253, 1, // 3199: decode to ADDVI_W using decoder 253
5238 // 3199: }
5239 3, 7, // 3204: case 0x3: {
5240 OPC_CheckPredicate, 30, // 3206: check predicate 30
5241 OPC_Decode, 201, 6, 254, 1, // 3208: decode to ADDVI_D using decoder 254
5242 // 3208: }
5243 4, 7, // 3213: case 0x4: {
5244 OPC_CheckPredicate, 30, // 3215: check predicate 30
5245 OPC_Decode, 192, 21, 251, 1, // 3217: decode to SUBVI_B using decoder 251
5246 // 3217: }
5247 5, 7, // 3222: case 0x5: {
5248 OPC_CheckPredicate, 30, // 3224: check predicate 30
5249 OPC_Decode, 194, 21, 252, 1, // 3226: decode to SUBVI_H using decoder 252
5250 // 3226: }
5251 6, 7, // 3231: case 0x6: {
5252 OPC_CheckPredicate, 30, // 3233: check predicate 30
5253 OPC_Decode, 195, 21, 253, 1, // 3235: decode to SUBVI_W using decoder 253
5254 // 3235: }
5255 7, 7, // 3240: case 0x7: {
5256 OPC_CheckPredicate, 30, // 3242: check predicate 30
5257 OPC_Decode, 193, 21, 254, 1, // 3244: decode to SUBVI_D using decoder 254
5258 // 3244: }
5259 8, 7, // 3249: case 0x8: {
5260 OPC_CheckPredicate, 30, // 3251: check predicate 30
5261 OPC_Decode, 132, 16, 251, 1, // 3253: decode to MAXI_S_B using decoder 251
5262 // 3253: }
5263 9, 7, // 3258: case 0x9: {
5264 OPC_CheckPredicate, 30, // 3260: check predicate 30
5265 OPC_Decode, 134, 16, 252, 1, // 3262: decode to MAXI_S_H using decoder 252
5266 // 3262: }
5267 10, 7, // 3267: case 0xa: {
5268 OPC_CheckPredicate, 30, // 3269: check predicate 30
5269 OPC_Decode, 135, 16, 253, 1, // 3271: decode to MAXI_S_W using decoder 253
5270 // 3271: }
5271 11, 7, // 3276: case 0xb: {
5272 OPC_CheckPredicate, 30, // 3278: check predicate 30
5273 OPC_Decode, 133, 16, 254, 1, // 3280: decode to MAXI_S_D using decoder 254
5274 // 3280: }
5275 12, 7, // 3285: case 0xc: {
5276 OPC_CheckPredicate, 30, // 3287: check predicate 30
5277 OPC_Decode, 136, 16, 251, 1, // 3289: decode to MAXI_U_B using decoder 251
5278 // 3289: }
5279 13, 7, // 3294: case 0xd: {
5280 OPC_CheckPredicate, 30, // 3296: check predicate 30
5281 OPC_Decode, 138, 16, 252, 1, // 3298: decode to MAXI_U_H using decoder 252
5282 // 3298: }
5283 14, 7, // 3303: case 0xe: {
5284 OPC_CheckPredicate, 30, // 3305: check predicate 30
5285 OPC_Decode, 139, 16, 253, 1, // 3307: decode to MAXI_U_W using decoder 253
5286 // 3307: }
5287 15, 7, // 3312: case 0xf: {
5288 OPC_CheckPredicate, 30, // 3314: check predicate 30
5289 OPC_Decode, 137, 16, 254, 1, // 3316: decode to MAXI_U_D using decoder 254
5290 // 3316: }
5291 16, 7, // 3321: case 0x10: {
5292 OPC_CheckPredicate, 30, // 3323: check predicate 30
5293 OPC_Decode, 191, 16, 251, 1, // 3325: decode to MINI_S_B using decoder 251
5294 // 3325: }
5295 17, 7, // 3330: case 0x11: {
5296 OPC_CheckPredicate, 30, // 3332: check predicate 30
5297 OPC_Decode, 193, 16, 252, 1, // 3334: decode to MINI_S_H using decoder 252
5298 // 3334: }
5299 18, 7, // 3339: case 0x12: {
5300 OPC_CheckPredicate, 30, // 3341: check predicate 30
5301 OPC_Decode, 194, 16, 253, 1, // 3343: decode to MINI_S_W using decoder 253
5302 // 3343: }
5303 19, 7, // 3348: case 0x13: {
5304 OPC_CheckPredicate, 30, // 3350: check predicate 30
5305 OPC_Decode, 192, 16, 254, 1, // 3352: decode to MINI_S_D using decoder 254
5306 // 3352: }
5307 20, 7, // 3357: case 0x14: {
5308 OPC_CheckPredicate, 30, // 3359: check predicate 30
5309 OPC_Decode, 195, 16, 251, 1, // 3361: decode to MINI_U_B using decoder 251
5310 // 3361: }
5311 21, 7, // 3366: case 0x15: {
5312 OPC_CheckPredicate, 30, // 3368: check predicate 30
5313 OPC_Decode, 197, 16, 252, 1, // 3370: decode to MINI_U_H using decoder 252
5314 // 3370: }
5315 22, 7, // 3375: case 0x16: {
5316 OPC_CheckPredicate, 30, // 3377: check predicate 30
5317 OPC_Decode, 198, 16, 253, 1, // 3379: decode to MINI_U_W using decoder 253
5318 // 3379: }
5319 23, 0, // 3384: case 0x17: {
5320 OPC_CheckPredicate, 30, // 3386: check predicate 30
5321 OPC_Decode, 196, 16, 254, 1, // 3388: decode to MINI_U_D using decoder 254
5322 // 3388: }
5323 // 3388: } // switch Inst[25:21]
5324 // 3388: }
5325 7, 219, 1, // 3393: case 0x7: {
5326 OPC_SwitchField, 21, 5, // 3396: switch Inst[25:21] {
5327 0, 7, // 3399: case 0x0: {
5328 OPC_CheckPredicate, 30, // 3401: check predicate 30
5329 OPC_Decode, 237, 8, 251, 1, // 3403: decode to CEQI_B using decoder 251
5330 // 3403: }
5331 1, 7, // 3408: case 0x1: {
5332 OPC_CheckPredicate, 30, // 3410: check predicate 30
5333 OPC_Decode, 239, 8, 252, 1, // 3412: decode to CEQI_H using decoder 252
5334 // 3412: }
5335 2, 7, // 3417: case 0x2: {
5336 OPC_CheckPredicate, 30, // 3419: check predicate 30
5337 OPC_Decode, 240, 8, 253, 1, // 3421: decode to CEQI_W using decoder 253
5338 // 3421: }
5339 3, 7, // 3426: case 0x3: {
5340 OPC_CheckPredicate, 30, // 3428: check predicate 30
5341 OPC_Decode, 238, 8, 254, 1, // 3430: decode to CEQI_D using decoder 254
5342 // 3430: }
5343 8, 7, // 3435: case 0x8: {
5344 OPC_CheckPredicate, 30, // 3437: check predicate 30
5345 OPC_Decode, 149, 9, 251, 1, // 3439: decode to CLTI_S_B using decoder 251
5346 // 3439: }
5347 9, 7, // 3444: case 0x9: {
5348 OPC_CheckPredicate, 30, // 3446: check predicate 30
5349 OPC_Decode, 151, 9, 252, 1, // 3448: decode to CLTI_S_H using decoder 252
5350 // 3448: }
5351 10, 7, // 3453: case 0xa: {
5352 OPC_CheckPredicate, 30, // 3455: check predicate 30
5353 OPC_Decode, 152, 9, 253, 1, // 3457: decode to CLTI_S_W using decoder 253
5354 // 3457: }
5355 11, 7, // 3462: case 0xb: {
5356 OPC_CheckPredicate, 30, // 3464: check predicate 30
5357 OPC_Decode, 150, 9, 254, 1, // 3466: decode to CLTI_S_D using decoder 254
5358 // 3466: }
5359 12, 7, // 3471: case 0xc: {
5360 OPC_CheckPredicate, 30, // 3473: check predicate 30
5361 OPC_Decode, 153, 9, 251, 1, // 3475: decode to CLTI_U_B using decoder 251
5362 // 3475: }
5363 13, 7, // 3480: case 0xd: {
5364 OPC_CheckPredicate, 30, // 3482: check predicate 30
5365 OPC_Decode, 155, 9, 252, 1, // 3484: decode to CLTI_U_H using decoder 252
5366 // 3484: }
5367 14, 7, // 3489: case 0xe: {
5368 OPC_CheckPredicate, 30, // 3491: check predicate 30
5369 OPC_Decode, 156, 9, 253, 1, // 3493: decode to CLTI_U_W using decoder 253
5370 // 3493: }
5371 15, 7, // 3498: case 0xf: {
5372 OPC_CheckPredicate, 30, // 3500: check predicate 30
5373 OPC_Decode, 154, 9, 254, 1, // 3502: decode to CLTI_U_D using decoder 254
5374 // 3502: }
5375 16, 7, // 3507: case 0x10: {
5376 OPC_CheckPredicate, 30, // 3509: check predicate 30
5377 OPC_Decode, 129, 9, 251, 1, // 3511: decode to CLEI_S_B using decoder 251
5378 // 3511: }
5379 17, 7, // 3516: case 0x11: {
5380 OPC_CheckPredicate, 30, // 3518: check predicate 30
5381 OPC_Decode, 131, 9, 252, 1, // 3520: decode to CLEI_S_H using decoder 252
5382 // 3520: }
5383 18, 7, // 3525: case 0x12: {
5384 OPC_CheckPredicate, 30, // 3527: check predicate 30
5385 OPC_Decode, 132, 9, 253, 1, // 3529: decode to CLEI_S_W using decoder 253
5386 // 3529: }
5387 19, 7, // 3534: case 0x13: {
5388 OPC_CheckPredicate, 30, // 3536: check predicate 30
5389 OPC_Decode, 130, 9, 254, 1, // 3538: decode to CLEI_S_D using decoder 254
5390 // 3538: }
5391 20, 7, // 3543: case 0x14: {
5392 OPC_CheckPredicate, 30, // 3545: check predicate 30
5393 OPC_Decode, 133, 9, 251, 1, // 3547: decode to CLEI_U_B using decoder 251
5394 // 3547: }
5395 21, 7, // 3552: case 0x15: {
5396 OPC_CheckPredicate, 30, // 3554: check predicate 30
5397 OPC_Decode, 135, 9, 252, 1, // 3556: decode to CLEI_U_H using decoder 252
5398 // 3556: }
5399 22, 7, // 3561: case 0x16: {
5400 OPC_CheckPredicate, 30, // 3563: check predicate 30
5401 OPC_Decode, 136, 9, 253, 1, // 3565: decode to CLEI_U_W using decoder 253
5402 // 3565: }
5403 23, 7, // 3570: case 0x17: {
5404 OPC_CheckPredicate, 30, // 3572: check predicate 30
5405 OPC_Decode, 134, 9, 254, 1, // 3574: decode to CLEI_U_D using decoder 254
5406 // 3574: }
5407 24, 7, // 3579: case 0x18: {
5408 OPC_CheckPredicate, 30, // 3581: check predicate 30
5409 OPC_Decode, 248, 14, 255, 1, // 3583: decode to LDI_B using decoder 255
5410 // 3583: }
5411 25, 7, // 3588: case 0x19: {
5412 OPC_CheckPredicate, 30, // 3590: check predicate 30
5413 OPC_Decode, 250, 14, 128, 2, // 3592: decode to LDI_H using decoder 256
5414 // 3592: }
5415 26, 7, // 3597: case 0x1a: {
5416 OPC_CheckPredicate, 30, // 3599: check predicate 30
5417 OPC_Decode, 251, 14, 129, 2, // 3601: decode to LDI_W using decoder 257
5418 // 3601: }
5419 27, 0, // 3606: case 0x1b: {
5420 OPC_CheckPredicate, 30, // 3608: check predicate 30
5421 OPC_Decode, 249, 14, 130, 2, // 3610: decode to LDI_D using decoder 258
5422 // 3610: }
5423 // 3610: } // switch Inst[25:21]
5424 // 3610: }
5425 9, 147, 3, // 3615: case 0x9: {
5426 OPC_SwitchField, 22, 4, // 3618: switch Inst[25:22] {
5427 0, 7, // 3621: case 0x0: {
5428 OPC_CheckPredicate, 30, // 3623: check predicate 30
5429 OPC_Decode, 192, 20, 131, 2, // 3625: decode to SLLI_D using decoder 259
5430 // 3625: }
5431 1, 39, // 3630: case 0x1: {
5432 OPC_SwitchField, 21, 1, // 3632: switch Inst[21] {
5433 0, 7, // 3635: case 0x0: {
5434 OPC_CheckPredicate, 30, // 3637: check predicate 30
5435 OPC_Decode, 194, 20, 253, 1, // 3639: decode to SLLI_W using decoder 253
5436 // 3639: }
5437 1, 0, // 3644: case 0x1: {
5438 OPC_SwitchField, 20, 1, // 3646: switch Inst[20] {
5439 0, 7, // 3649: case 0x0: {
5440 OPC_CheckPredicate, 30, // 3651: check predicate 30
5441 OPC_Decode, 193, 20, 132, 2, // 3653: decode to SLLI_H using decoder 260
5442 // 3653: }
5443 1, 0, // 3658: case 0x1: {
5444 OPC_CheckPredicate, 30, // 3660: check predicate 30
5445 OPC_CheckField, 19, 1, 0, // 3662: check Inst[19] == 0x0
5446 OPC_Decode, 191, 20, 133, 2, // 3666: decode to SLLI_B using decoder 261
5447 // 3666: }
5448 // 3666: } // switch Inst[20]
5449 // 3666: }
5450 // 3666: } // switch Inst[21]
5451 // 3666: }
5452 2, 7, // 3671: case 0x2: {
5453 OPC_CheckPredicate, 30, // 3673: check predicate 30
5454 OPC_Decode, 227, 20, 131, 2, // 3675: decode to SRAI_D using decoder 259
5455 // 3675: }
5456 3, 39, // 3680: case 0x3: {
5457 OPC_SwitchField, 21, 1, // 3682: switch Inst[21] {
5458 0, 7, // 3685: case 0x0: {
5459 OPC_CheckPredicate, 30, // 3687: check predicate 30
5460 OPC_Decode, 229, 20, 253, 1, // 3689: decode to SRAI_W using decoder 253
5461 // 3689: }
5462 1, 0, // 3694: case 0x1: {
5463 OPC_SwitchField, 20, 1, // 3696: switch Inst[20] {
5464 0, 7, // 3699: case 0x0: {
5465 OPC_CheckPredicate, 30, // 3701: check predicate 30
5466 OPC_Decode, 228, 20, 132, 2, // 3703: decode to SRAI_H using decoder 260
5467 // 3703: }
5468 1, 0, // 3708: case 0x1: {
5469 OPC_CheckPredicate, 30, // 3710: check predicate 30
5470 OPC_CheckField, 19, 1, 0, // 3712: check Inst[19] == 0x0
5471 OPC_Decode, 226, 20, 133, 2, // 3716: decode to SRAI_B using decoder 261
5472 // 3716: }
5473 // 3716: } // switch Inst[20]
5474 // 3716: }
5475 // 3716: } // switch Inst[21]
5476 // 3716: }
5477 4, 7, // 3721: case 0x4: {
5478 OPC_CheckPredicate, 30, // 3723: check predicate 30
5479 OPC_Decode, 249, 20, 131, 2, // 3725: decode to SRLI_D using decoder 259
5480 // 3725: }
5481 5, 39, // 3730: case 0x5: {
5482 OPC_SwitchField, 21, 1, // 3732: switch Inst[21] {
5483 0, 7, // 3735: case 0x0: {
5484 OPC_CheckPredicate, 30, // 3737: check predicate 30
5485 OPC_Decode, 251, 20, 253, 1, // 3739: decode to SRLI_W using decoder 253
5486 // 3739: }
5487 1, 0, // 3744: case 0x1: {
5488 OPC_SwitchField, 20, 1, // 3746: switch Inst[20] {
5489 0, 7, // 3749: case 0x0: {
5490 OPC_CheckPredicate, 30, // 3751: check predicate 30
5491 OPC_Decode, 250, 20, 132, 2, // 3753: decode to SRLI_H using decoder 260
5492 // 3753: }
5493 1, 0, // 3758: case 0x1: {
5494 OPC_CheckPredicate, 30, // 3760: check predicate 30
5495 OPC_CheckField, 19, 1, 0, // 3762: check Inst[19] == 0x0
5496 OPC_Decode, 248, 20, 133, 2, // 3766: decode to SRLI_B using decoder 261
5497 // 3766: }
5498 // 3766: } // switch Inst[20]
5499 // 3766: }
5500 // 3766: } // switch Inst[21]
5501 // 3766: }
5502 6, 7, // 3771: case 0x6: {
5503 OPC_CheckPredicate, 30, // 3773: check predicate 30
5504 OPC_Decode, 179, 7, 131, 2, // 3775: decode to BCLRI_D using decoder 259
5505 // 3775: }
5506 7, 39, // 3780: case 0x7: {
5507 OPC_SwitchField, 21, 1, // 3782: switch Inst[21] {
5508 0, 7, // 3785: case 0x0: {
5509 OPC_CheckPredicate, 30, // 3787: check predicate 30
5510 OPC_Decode, 181, 7, 253, 1, // 3789: decode to BCLRI_W using decoder 253
5511 // 3789: }
5512 1, 0, // 3794: case 0x1: {
5513 OPC_SwitchField, 20, 1, // 3796: switch Inst[20] {
5514 0, 7, // 3799: case 0x0: {
5515 OPC_CheckPredicate, 30, // 3801: check predicate 30
5516 OPC_Decode, 180, 7, 132, 2, // 3803: decode to BCLRI_H using decoder 260
5517 // 3803: }
5518 1, 0, // 3808: case 0x1: {
5519 OPC_CheckPredicate, 30, // 3810: check predicate 30
5520 OPC_CheckField, 19, 1, 0, // 3812: check Inst[19] == 0x0
5521 OPC_Decode, 178, 7, 133, 2, // 3816: decode to BCLRI_B using decoder 261
5522 // 3816: }
5523 // 3816: } // switch Inst[20]
5524 // 3816: }
5525 // 3816: } // switch Inst[21]
5526 // 3816: }
5527 8, 7, // 3821: case 0x8: {
5528 OPC_CheckPredicate, 30, // 3823: check predicate 30
5529 OPC_Decode, 197, 8, 131, 2, // 3825: decode to BSETI_D using decoder 259
5530 // 3825: }
5531 9, 39, // 3830: case 0x9: {
5532 OPC_SwitchField, 21, 1, // 3832: switch Inst[21] {
5533 0, 7, // 3835: case 0x0: {
5534 OPC_CheckPredicate, 30, // 3837: check predicate 30
5535 OPC_Decode, 199, 8, 253, 1, // 3839: decode to BSETI_W using decoder 253
5536 // 3839: }
5537 1, 0, // 3844: case 0x1: {
5538 OPC_SwitchField, 20, 1, // 3846: switch Inst[20] {
5539 0, 7, // 3849: case 0x0: {
5540 OPC_CheckPredicate, 30, // 3851: check predicate 30
5541 OPC_Decode, 198, 8, 132, 2, // 3853: decode to BSETI_H using decoder 260
5542 // 3853: }
5543 1, 0, // 3858: case 0x1: {
5544 OPC_CheckPredicate, 30, // 3860: check predicate 30
5545 OPC_CheckField, 19, 1, 0, // 3862: check Inst[19] == 0x0
5546 OPC_Decode, 196, 8, 133, 2, // 3866: decode to BSETI_B using decoder 261
5547 // 3866: }
5548 // 3866: } // switch Inst[20]
5549 // 3866: }
5550 // 3866: } // switch Inst[21]
5551 // 3866: }
5552 10, 7, // 3871: case 0xa: {
5553 OPC_CheckPredicate, 30, // 3873: check predicate 30
5554 OPC_Decode, 160, 8, 131, 2, // 3875: decode to BNEGI_D using decoder 259
5555 // 3875: }
5556 11, 39, // 3880: case 0xb: {
5557 OPC_SwitchField, 21, 1, // 3882: switch Inst[21] {
5558 0, 7, // 3885: case 0x0: {
5559 OPC_CheckPredicate, 30, // 3887: check predicate 30
5560 OPC_Decode, 162, 8, 253, 1, // 3889: decode to BNEGI_W using decoder 253
5561 // 3889: }
5562 1, 0, // 3894: case 0x1: {
5563 OPC_SwitchField, 20, 1, // 3896: switch Inst[20] {
5564 0, 7, // 3899: case 0x0: {
5565 OPC_CheckPredicate, 30, // 3901: check predicate 30
5566 OPC_Decode, 161, 8, 132, 2, // 3903: decode to BNEGI_H using decoder 260
5567 // 3903: }
5568 1, 0, // 3908: case 0x1: {
5569 OPC_CheckPredicate, 30, // 3910: check predicate 30
5570 OPC_CheckField, 19, 1, 0, // 3912: check Inst[19] == 0x0
5571 OPC_Decode, 159, 8, 133, 2, // 3916: decode to BNEGI_B using decoder 261
5572 // 3916: }
5573 // 3916: } // switch Inst[20]
5574 // 3916: }
5575 // 3916: } // switch Inst[21]
5576 // 3916: }
5577 12, 7, // 3921: case 0xc: {
5578 OPC_CheckPredicate, 30, // 3923: check predicate 30
5579 OPC_Decode, 231, 7, 134, 2, // 3925: decode to BINSLI_D using decoder 262
5580 // 3925: }
5581 13, 39, // 3930: case 0xd: {
5582 OPC_SwitchField, 21, 1, // 3932: switch Inst[21] {
5583 0, 7, // 3935: case 0x0: {
5584 OPC_CheckPredicate, 30, // 3937: check predicate 30
5585 OPC_Decode, 233, 7, 135, 2, // 3939: decode to BINSLI_W using decoder 263
5586 // 3939: }
5587 1, 0, // 3944: case 0x1: {
5588 OPC_SwitchField, 20, 1, // 3946: switch Inst[20] {
5589 0, 7, // 3949: case 0x0: {
5590 OPC_CheckPredicate, 30, // 3951: check predicate 30
5591 OPC_Decode, 232, 7, 136, 2, // 3953: decode to BINSLI_H using decoder 264
5592 // 3953: }
5593 1, 0, // 3958: case 0x1: {
5594 OPC_CheckPredicate, 30, // 3960: check predicate 30
5595 OPC_CheckField, 19, 1, 0, // 3962: check Inst[19] == 0x0
5596 OPC_Decode, 230, 7, 137, 2, // 3966: decode to BINSLI_B using decoder 265
5597 // 3966: }
5598 // 3966: } // switch Inst[20]
5599 // 3966: }
5600 // 3966: } // switch Inst[21]
5601 // 3966: }
5602 14, 7, // 3971: case 0xe: {
5603 OPC_CheckPredicate, 30, // 3973: check predicate 30
5604 OPC_Decode, 239, 7, 134, 2, // 3975: decode to BINSRI_D using decoder 262
5605 // 3975: }
5606 15, 0, // 3980: case 0xf: {
5607 OPC_SwitchField, 21, 1, // 3982: switch Inst[21] {
5608 0, 7, // 3985: case 0x0: {
5609 OPC_CheckPredicate, 30, // 3987: check predicate 30
5610 OPC_Decode, 241, 7, 135, 2, // 3989: decode to BINSRI_W using decoder 263
5611 // 3989: }
5612 1, 0, // 3994: case 0x1: {
5613 OPC_SwitchField, 20, 1, // 3996: switch Inst[20] {
5614 0, 7, // 3999: case 0x0: {
5615 OPC_CheckPredicate, 30, // 4001: check predicate 30
5616 OPC_Decode, 240, 7, 136, 2, // 4003: decode to BINSRI_H using decoder 264
5617 // 4003: }
5618 1, 0, // 4008: case 0x1: {
5619 OPC_CheckPredicate, 30, // 4010: check predicate 30
5620 OPC_CheckField, 19, 1, 0, // 4012: check Inst[19] == 0x0
5621 OPC_Decode, 238, 7, 137, 2, // 4016: decode to BINSRI_B using decoder 265
5622 // 4016: }
5623 // 4016: } // switch Inst[20]
5624 // 4016: }
5625 // 4016: } // switch Inst[21]
5626 // 4016: }
5627 // 4016: } // switch Inst[25:22]
5628 // 4016: }
5629 10, 203, 1, // 4021: case 0xa: {
5630 OPC_SwitchField, 22, 4, // 4024: switch Inst[25:22] {
5631 0, 7, // 4027: case 0x0: {
5632 OPC_CheckPredicate, 30, // 4029: check predicate 30
5633 OPC_Decode, 172, 19, 131, 2, // 4031: decode to SAT_S_D using decoder 259
5634 // 4031: }
5635 1, 39, // 4036: case 0x1: {
5636 OPC_SwitchField, 21, 1, // 4038: switch Inst[21] {
5637 0, 7, // 4041: case 0x0: {
5638 OPC_CheckPredicate, 30, // 4043: check predicate 30
5639 OPC_Decode, 174, 19, 253, 1, // 4045: decode to SAT_S_W using decoder 253
5640 // 4045: }
5641 1, 0, // 4050: case 0x1: {
5642 OPC_SwitchField, 20, 1, // 4052: switch Inst[20] {
5643 0, 7, // 4055: case 0x0: {
5644 OPC_CheckPredicate, 30, // 4057: check predicate 30
5645 OPC_Decode, 173, 19, 132, 2, // 4059: decode to SAT_S_H using decoder 260
5646 // 4059: }
5647 1, 0, // 4064: case 0x1: {
5648 OPC_CheckPredicate, 30, // 4066: check predicate 30
5649 OPC_CheckField, 19, 1, 0, // 4068: check Inst[19] == 0x0
5650 OPC_Decode, 171, 19, 133, 2, // 4072: decode to SAT_S_B using decoder 261
5651 // 4072: }
5652 // 4072: } // switch Inst[20]
5653 // 4072: }
5654 // 4072: } // switch Inst[21]
5655 // 4072: }
5656 2, 7, // 4077: case 0x2: {
5657 OPC_CheckPredicate, 30, // 4079: check predicate 30
5658 OPC_Decode, 176, 19, 131, 2, // 4081: decode to SAT_U_D using decoder 259
5659 // 4081: }
5660 3, 39, // 4086: case 0x3: {
5661 OPC_SwitchField, 21, 1, // 4088: switch Inst[21] {
5662 0, 7, // 4091: case 0x0: {
5663 OPC_CheckPredicate, 30, // 4093: check predicate 30
5664 OPC_Decode, 178, 19, 253, 1, // 4095: decode to SAT_U_W using decoder 253
5665 // 4095: }
5666 1, 0, // 4100: case 0x1: {
5667 OPC_SwitchField, 20, 1, // 4102: switch Inst[20] {
5668 0, 7, // 4105: case 0x0: {
5669 OPC_CheckPredicate, 30, // 4107: check predicate 30
5670 OPC_Decode, 177, 19, 132, 2, // 4109: decode to SAT_U_H using decoder 260
5671 // 4109: }
5672 1, 0, // 4114: case 0x1: {
5673 OPC_CheckPredicate, 30, // 4116: check predicate 30
5674 OPC_CheckField, 19, 1, 0, // 4118: check Inst[19] == 0x0
5675 OPC_Decode, 175, 19, 133, 2, // 4122: decode to SAT_U_B using decoder 261
5676 // 4122: }
5677 // 4122: } // switch Inst[20]
5678 // 4122: }
5679 // 4122: } // switch Inst[21]
5680 // 4122: }
5681 4, 7, // 4127: case 0x4: {
5682 OPC_CheckPredicate, 30, // 4129: check predicate 30
5683 OPC_Decode, 231, 20, 131, 2, // 4131: decode to SRARI_D using decoder 259
5684 // 4131: }
5685 5, 39, // 4136: case 0x5: {
5686 OPC_SwitchField, 21, 1, // 4138: switch Inst[21] {
5687 0, 7, // 4141: case 0x0: {
5688 OPC_CheckPredicate, 30, // 4143: check predicate 30
5689 OPC_Decode, 233, 20, 253, 1, // 4145: decode to SRARI_W using decoder 253
5690 // 4145: }
5691 1, 0, // 4150: case 0x1: {
5692 OPC_SwitchField, 20, 1, // 4152: switch Inst[20] {
5693 0, 7, // 4155: case 0x0: {
5694 OPC_CheckPredicate, 30, // 4157: check predicate 30
5695 OPC_Decode, 232, 20, 132, 2, // 4159: decode to SRARI_H using decoder 260
5696 // 4159: }
5697 1, 0, // 4164: case 0x1: {
5698 OPC_CheckPredicate, 30, // 4166: check predicate 30
5699 OPC_CheckField, 19, 1, 0, // 4168: check Inst[19] == 0x0
5700 OPC_Decode, 230, 20, 133, 2, // 4172: decode to SRARI_B using decoder 261
5701 // 4172: }
5702 // 4172: } // switch Inst[20]
5703 // 4172: }
5704 // 4172: } // switch Inst[21]
5705 // 4172: }
5706 6, 7, // 4177: case 0x6: {
5707 OPC_CheckPredicate, 30, // 4179: check predicate 30
5708 OPC_Decode, 253, 20, 131, 2, // 4181: decode to SRLRI_D using decoder 259
5709 // 4181: }
5710 7, 0, // 4186: case 0x7: {
5711 OPC_SwitchField, 21, 1, // 4188: switch Inst[21] {
5712 0, 7, // 4191: case 0x0: {
5713 OPC_CheckPredicate, 30, // 4193: check predicate 30
5714 OPC_Decode, 255, 20, 253, 1, // 4195: decode to SRLRI_W using decoder 253
5715 // 4195: }
5716 1, 0, // 4200: case 0x1: {
5717 OPC_SwitchField, 20, 1, // 4202: switch Inst[20] {
5718 0, 7, // 4205: case 0x0: {
5719 OPC_CheckPredicate, 30, // 4207: check predicate 30
5720 OPC_Decode, 254, 20, 132, 2, // 4209: decode to SRLRI_H using decoder 260
5721 // 4209: }
5722 1, 0, // 4214: case 0x1: {
5723 OPC_CheckPredicate, 30, // 4216: check predicate 30
5724 OPC_CheckField, 19, 1, 0, // 4218: check Inst[19] == 0x0
5725 OPC_Decode, 252, 20, 133, 2, // 4222: decode to SRLRI_B using decoder 261
5726 // 4222: }
5727 // 4222: } // switch Inst[20]
5728 // 4222: }
5729 // 4222: } // switch Inst[21]
5730 // 4222: }
5731 // 4222: } // switch Inst[25:22]
5732 // 4222: }
5733 13, 163, 2, // 4227: case 0xd: {
5734 OPC_SwitchField, 21, 5, // 4230: switch Inst[25:21] {
5735 0, 7, // 4233: case 0x0: {
5736 OPC_CheckPredicate, 30, // 4235: check predicate 30
5737 OPC_Decode, 197, 20, 138, 2, // 4237: decode to SLL_B using decoder 266
5738 // 4237: }
5739 1, 7, // 4242: case 0x1: {
5740 OPC_CheckPredicate, 30, // 4244: check predicate 30
5741 OPC_Decode, 199, 20, 139, 2, // 4246: decode to SLL_H using decoder 267
5742 // 4246: }
5743 2, 7, // 4251: case 0x2: {
5744 OPC_CheckPredicate, 30, // 4253: check predicate 30
5745 OPC_Decode, 202, 20, 140, 2, // 4255: decode to SLL_W using decoder 268
5746 // 4255: }
5747 3, 7, // 4260: case 0x3: {
5748 OPC_CheckPredicate, 30, // 4262: check predicate 30
5749 OPC_Decode, 198, 20, 141, 2, // 4264: decode to SLL_D using decoder 269
5750 // 4264: }
5751 4, 7, // 4269: case 0x4: {
5752 OPC_CheckPredicate, 30, // 4271: check predicate 30
5753 OPC_Decode, 240, 20, 138, 2, // 4273: decode to SRA_B using decoder 266
5754 // 4273: }
5755 5, 7, // 4278: case 0x5: {
5756 OPC_CheckPredicate, 30, // 4280: check predicate 30
5757 OPC_Decode, 242, 20, 139, 2, // 4282: decode to SRA_H using decoder 267
5758 // 4282: }
5759 6, 7, // 4287: case 0x6: {
5760 OPC_CheckPredicate, 30, // 4289: check predicate 30
5761 OPC_Decode, 244, 20, 140, 2, // 4291: decode to SRA_W using decoder 268
5762 // 4291: }
5763 7, 7, // 4296: case 0x7: {
5764 OPC_CheckPredicate, 30, // 4298: check predicate 30
5765 OPC_Decode, 241, 20, 141, 2, // 4300: decode to SRA_D using decoder 269
5766 // 4300: }
5767 8, 7, // 4305: case 0x8: {
5768 OPC_CheckPredicate, 30, // 4307: check predicate 30
5769 OPC_Decode, 134, 21, 138, 2, // 4309: decode to SRL_B using decoder 266
5770 // 4309: }
5771 9, 7, // 4314: case 0x9: {
5772 OPC_CheckPredicate, 30, // 4316: check predicate 30
5773 OPC_Decode, 136, 21, 139, 2, // 4318: decode to SRL_H using decoder 267
5774 // 4318: }
5775 10, 7, // 4323: case 0xa: {
5776 OPC_CheckPredicate, 30, // 4325: check predicate 30
5777 OPC_Decode, 138, 21, 140, 2, // 4327: decode to SRL_W using decoder 268
5778 // 4327: }
5779 11, 7, // 4332: case 0xb: {
5780 OPC_CheckPredicate, 30, // 4334: check predicate 30
5781 OPC_Decode, 135, 21, 141, 2, // 4336: decode to SRL_D using decoder 269
5782 // 4336: }
5783 12, 7, // 4341: case 0xc: {
5784 OPC_CheckPredicate, 30, // 4343: check predicate 30
5785 OPC_Decode, 182, 7, 138, 2, // 4345: decode to BCLR_B using decoder 266
5786 // 4345: }
5787 13, 7, // 4350: case 0xd: {
5788 OPC_CheckPredicate, 30, // 4352: check predicate 30
5789 OPC_Decode, 184, 7, 139, 2, // 4354: decode to BCLR_H using decoder 267
5790 // 4354: }
5791 14, 7, // 4359: case 0xe: {
5792 OPC_CheckPredicate, 30, // 4361: check predicate 30
5793 OPC_Decode, 185, 7, 140, 2, // 4363: decode to BCLR_W using decoder 268
5794 // 4363: }
5795 15, 7, // 4368: case 0xf: {
5796 OPC_CheckPredicate, 30, // 4370: check predicate 30
5797 OPC_Decode, 183, 7, 141, 2, // 4372: decode to BCLR_D using decoder 269
5798 // 4372: }
5799 16, 7, // 4377: case 0x10: {
5800 OPC_CheckPredicate, 30, // 4379: check predicate 30
5801 OPC_Decode, 200, 8, 138, 2, // 4381: decode to BSET_B using decoder 266
5802 // 4381: }
5803 17, 7, // 4386: case 0x11: {
5804 OPC_CheckPredicate, 30, // 4388: check predicate 30
5805 OPC_Decode, 202, 8, 139, 2, // 4390: decode to BSET_H using decoder 267
5806 // 4390: }
5807 18, 7, // 4395: case 0x12: {
5808 OPC_CheckPredicate, 30, // 4397: check predicate 30
5809 OPC_Decode, 203, 8, 140, 2, // 4399: decode to BSET_W using decoder 268
5810 // 4399: }
5811 19, 7, // 4404: case 0x13: {
5812 OPC_CheckPredicate, 30, // 4406: check predicate 30
5813 OPC_Decode, 201, 8, 141, 2, // 4408: decode to BSET_D using decoder 269
5814 // 4408: }
5815 20, 7, // 4413: case 0x14: {
5816 OPC_CheckPredicate, 30, // 4415: check predicate 30
5817 OPC_Decode, 163, 8, 138, 2, // 4417: decode to BNEG_B using decoder 266
5818 // 4417: }
5819 21, 7, // 4422: case 0x15: {
5820 OPC_CheckPredicate, 30, // 4424: check predicate 30
5821 OPC_Decode, 165, 8, 139, 2, // 4426: decode to BNEG_H using decoder 267
5822 // 4426: }
5823 22, 7, // 4431: case 0x16: {
5824 OPC_CheckPredicate, 30, // 4433: check predicate 30
5825 OPC_Decode, 166, 8, 140, 2, // 4435: decode to BNEG_W using decoder 268
5826 // 4435: }
5827 23, 7, // 4440: case 0x17: {
5828 OPC_CheckPredicate, 30, // 4442: check predicate 30
5829 OPC_Decode, 164, 8, 141, 2, // 4444: decode to BNEG_D using decoder 269
5830 // 4444: }
5831 24, 7, // 4449: case 0x18: {
5832 OPC_CheckPredicate, 30, // 4451: check predicate 30
5833 OPC_Decode, 234, 7, 142, 2, // 4453: decode to BINSL_B using decoder 270
5834 // 4453: }
5835 25, 7, // 4458: case 0x19: {
5836 OPC_CheckPredicate, 30, // 4460: check predicate 30
5837 OPC_Decode, 236, 7, 143, 2, // 4462: decode to BINSL_H using decoder 271
5838 // 4462: }
5839 26, 7, // 4467: case 0x1a: {
5840 OPC_CheckPredicate, 30, // 4469: check predicate 30
5841 OPC_Decode, 237, 7, 144, 2, // 4471: decode to BINSL_W using decoder 272
5842 // 4471: }
5843 27, 7, // 4476: case 0x1b: {
5844 OPC_CheckPredicate, 30, // 4478: check predicate 30
5845 OPC_Decode, 235, 7, 145, 2, // 4480: decode to BINSL_D using decoder 273
5846 // 4480: }
5847 28, 7, // 4485: case 0x1c: {
5848 OPC_CheckPredicate, 30, // 4487: check predicate 30
5849 OPC_Decode, 242, 7, 142, 2, // 4489: decode to BINSR_B using decoder 270
5850 // 4489: }
5851 29, 7, // 4494: case 0x1d: {
5852 OPC_CheckPredicate, 30, // 4496: check predicate 30
5853 OPC_Decode, 244, 7, 143, 2, // 4498: decode to BINSR_H using decoder 271
5854 // 4498: }
5855 30, 7, // 4503: case 0x1e: {
5856 OPC_CheckPredicate, 30, // 4505: check predicate 30
5857 OPC_Decode, 245, 7, 144, 2, // 4507: decode to BINSR_W using decoder 272
5858 // 4507: }
5859 31, 0, // 4512: case 0x1f: {
5860 OPC_CheckPredicate, 30, // 4514: check predicate 30
5861 OPC_Decode, 243, 7, 145, 2, // 4516: decode to BINSR_D using decoder 273
5862 // 4516: }
5863 // 4516: } // switch Inst[25:21]
5864 // 4516: }
5865 14, 163, 2, // 4521: case 0xe: {
5866 OPC_SwitchField, 21, 5, // 4524: switch Inst[25:21] {
5867 0, 7, // 4527: case 0x0: {
5868 OPC_CheckPredicate, 30, // 4529: check predicate 30
5869 OPC_Decode, 204, 6, 138, 2, // 4531: decode to ADDV_B using decoder 266
5870 // 4531: }
5871 1, 7, // 4536: case 0x1: {
5872 OPC_CheckPredicate, 30, // 4538: check predicate 30
5873 OPC_Decode, 206, 6, 139, 2, // 4540: decode to ADDV_H using decoder 267
5874 // 4540: }
5875 2, 7, // 4545: case 0x2: {
5876 OPC_CheckPredicate, 30, // 4547: check predicate 30
5877 OPC_Decode, 207, 6, 140, 2, // 4549: decode to ADDV_W using decoder 268
5878 // 4549: }
5879 3, 7, // 4554: case 0x3: {
5880 OPC_CheckPredicate, 30, // 4556: check predicate 30
5881 OPC_Decode, 205, 6, 141, 2, // 4558: decode to ADDV_D using decoder 269
5882 // 4558: }
5883 4, 7, // 4563: case 0x4: {
5884 OPC_CheckPredicate, 30, // 4565: check predicate 30
5885 OPC_Decode, 196, 21, 138, 2, // 4567: decode to SUBV_B using decoder 266
5886 // 4567: }
5887 5, 7, // 4572: case 0x5: {
5888 OPC_CheckPredicate, 30, // 4574: check predicate 30
5889 OPC_Decode, 198, 21, 139, 2, // 4576: decode to SUBV_H using decoder 267
5890 // 4576: }
5891 6, 7, // 4581: case 0x6: {
5892 OPC_CheckPredicate, 30, // 4583: check predicate 30
5893 OPC_Decode, 199, 21, 140, 2, // 4585: decode to SUBV_W using decoder 268
5894 // 4585: }
5895 7, 7, // 4590: case 0x7: {
5896 OPC_CheckPredicate, 30, // 4592: check predicate 30
5897 OPC_Decode, 197, 21, 141, 2, // 4594: decode to SUBV_D using decoder 269
5898 // 4594: }
5899 8, 7, // 4599: case 0x8: {
5900 OPC_CheckPredicate, 30, // 4601: check predicate 30
5901 OPC_Decode, 147, 16, 138, 2, // 4603: decode to MAX_S_B using decoder 266
5902 // 4603: }
5903 9, 7, // 4608: case 0x9: {
5904 OPC_CheckPredicate, 30, // 4610: check predicate 30
5905 OPC_Decode, 149, 16, 139, 2, // 4612: decode to MAX_S_H using decoder 267
5906 // 4612: }
5907 10, 7, // 4617: case 0xa: {
5908 OPC_CheckPredicate, 30, // 4619: check predicate 30
5909 OPC_Decode, 151, 16, 140, 2, // 4621: decode to MAX_S_W using decoder 268
5910 // 4621: }
5911 11, 7, // 4626: case 0xb: {
5912 OPC_CheckPredicate, 30, // 4628: check predicate 30
5913 OPC_Decode, 148, 16, 141, 2, // 4630: decode to MAX_S_D using decoder 269
5914 // 4630: }
5915 12, 7, // 4635: case 0xc: {
5916 OPC_CheckPredicate, 30, // 4637: check predicate 30
5917 OPC_Decode, 152, 16, 138, 2, // 4639: decode to MAX_U_B using decoder 266
5918 // 4639: }
5919 13, 7, // 4644: case 0xd: {
5920 OPC_CheckPredicate, 30, // 4646: check predicate 30
5921 OPC_Decode, 154, 16, 139, 2, // 4648: decode to MAX_U_H using decoder 267
5922 // 4648: }
5923 14, 7, // 4653: case 0xe: {
5924 OPC_CheckPredicate, 30, // 4655: check predicate 30
5925 OPC_Decode, 155, 16, 140, 2, // 4657: decode to MAX_U_W using decoder 268
5926 // 4657: }
5927 15, 7, // 4662: case 0xf: {
5928 OPC_CheckPredicate, 30, // 4664: check predicate 30
5929 OPC_Decode, 153, 16, 141, 2, // 4666: decode to MAX_U_D using decoder 269
5930 // 4666: }
5931 16, 7, // 4671: case 0x10: {
5932 OPC_CheckPredicate, 30, // 4673: check predicate 30
5933 OPC_Decode, 206, 16, 138, 2, // 4675: decode to MIN_S_B using decoder 266
5934 // 4675: }
5935 17, 7, // 4680: case 0x11: {
5936 OPC_CheckPredicate, 30, // 4682: check predicate 30
5937 OPC_Decode, 208, 16, 139, 2, // 4684: decode to MIN_S_H using decoder 267
5938 // 4684: }
5939 18, 7, // 4689: case 0x12: {
5940 OPC_CheckPredicate, 30, // 4691: check predicate 30
5941 OPC_Decode, 210, 16, 140, 2, // 4693: decode to MIN_S_W using decoder 268
5942 // 4693: }
5943 19, 7, // 4698: case 0x13: {
5944 OPC_CheckPredicate, 30, // 4700: check predicate 30
5945 OPC_Decode, 207, 16, 141, 2, // 4702: decode to MIN_S_D using decoder 269
5946 // 4702: }
5947 20, 7, // 4707: case 0x14: {
5948 OPC_CheckPredicate, 30, // 4709: check predicate 30
5949 OPC_Decode, 211, 16, 138, 2, // 4711: decode to MIN_U_B using decoder 266
5950 // 4711: }
5951 21, 7, // 4716: case 0x15: {
5952 OPC_CheckPredicate, 30, // 4718: check predicate 30
5953 OPC_Decode, 213, 16, 139, 2, // 4720: decode to MIN_U_H using decoder 267
5954 // 4720: }
5955 22, 7, // 4725: case 0x16: {
5956 OPC_CheckPredicate, 30, // 4727: check predicate 30
5957 OPC_Decode, 214, 16, 140, 2, // 4729: decode to MIN_U_W using decoder 268
5958 // 4729: }
5959 23, 7, // 4734: case 0x17: {
5960 OPC_CheckPredicate, 30, // 4736: check predicate 30
5961 OPC_Decode, 212, 16, 141, 2, // 4738: decode to MIN_U_D using decoder 269
5962 // 4738: }
5963 24, 7, // 4743: case 0x18: {
5964 OPC_CheckPredicate, 30, // 4745: check predicate 30
5965 OPC_Decode, 140, 16, 138, 2, // 4747: decode to MAX_A_B using decoder 266
5966 // 4747: }
5967 25, 7, // 4752: case 0x19: {
5968 OPC_CheckPredicate, 30, // 4754: check predicate 30
5969 OPC_Decode, 142, 16, 139, 2, // 4756: decode to MAX_A_H using decoder 267
5970 // 4756: }
5971 26, 7, // 4761: case 0x1a: {
5972 OPC_CheckPredicate, 30, // 4763: check predicate 30
5973 OPC_Decode, 143, 16, 140, 2, // 4765: decode to MAX_A_W using decoder 268
5974 // 4765: }
5975 27, 7, // 4770: case 0x1b: {
5976 OPC_CheckPredicate, 30, // 4772: check predicate 30
5977 OPC_Decode, 141, 16, 141, 2, // 4774: decode to MAX_A_D using decoder 269
5978 // 4774: }
5979 28, 7, // 4779: case 0x1c: {
5980 OPC_CheckPredicate, 30, // 4781: check predicate 30
5981 OPC_Decode, 199, 16, 138, 2, // 4783: decode to MIN_A_B using decoder 266
5982 // 4783: }
5983 29, 7, // 4788: case 0x1d: {
5984 OPC_CheckPredicate, 30, // 4790: check predicate 30
5985 OPC_Decode, 201, 16, 139, 2, // 4792: decode to MIN_A_H using decoder 267
5986 // 4792: }
5987 30, 7, // 4797: case 0x1e: {
5988 OPC_CheckPredicate, 30, // 4799: check predicate 30
5989 OPC_Decode, 202, 16, 140, 2, // 4801: decode to MIN_A_W using decoder 268
5990 // 4801: }
5991 31, 0, // 4806: case 0x1f: {
5992 OPC_CheckPredicate, 30, // 4808: check predicate 30
5993 OPC_Decode, 200, 16, 141, 2, // 4810: decode to MIN_A_D using decoder 269
5994 // 4810: }
5995 // 4810: } // switch Inst[25:21]
5996 // 4810: }
5997 15, 183, 1, // 4815: case 0xf: {
5998 OPC_SwitchField, 21, 5, // 4818: switch Inst[25:21] {
5999 0, 7, // 4821: case 0x0: {
6000 OPC_CheckPredicate, 30, // 4823: check predicate 30
6001 OPC_Decode, 241, 8, 138, 2, // 4825: decode to CEQ_B using decoder 266
6002 // 4825: }
6003 1, 7, // 4830: case 0x1: {
6004 OPC_CheckPredicate, 30, // 4832: check predicate 30
6005 OPC_Decode, 243, 8, 139, 2, // 4834: decode to CEQ_H using decoder 267
6006 // 4834: }
6007 2, 7, // 4839: case 0x2: {
6008 OPC_CheckPredicate, 30, // 4841: check predicate 30
6009 OPC_Decode, 244, 8, 140, 2, // 4843: decode to CEQ_W using decoder 268
6010 // 4843: }
6011 3, 7, // 4848: case 0x3: {
6012 OPC_CheckPredicate, 30, // 4850: check predicate 30
6013 OPC_Decode, 242, 8, 141, 2, // 4852: decode to CEQ_D using decoder 269
6014 // 4852: }
6015 8, 7, // 4857: case 0x8: {
6016 OPC_CheckPredicate, 30, // 4859: check predicate 30
6017 OPC_Decode, 157, 9, 138, 2, // 4861: decode to CLT_S_B using decoder 266
6018 // 4861: }
6019 9, 7, // 4866: case 0x9: {
6020 OPC_CheckPredicate, 30, // 4868: check predicate 30
6021 OPC_Decode, 159, 9, 139, 2, // 4870: decode to CLT_S_H using decoder 267
6022 // 4870: }
6023 10, 7, // 4875: case 0xa: {
6024 OPC_CheckPredicate, 30, // 4877: check predicate 30
6025 OPC_Decode, 160, 9, 140, 2, // 4879: decode to CLT_S_W using decoder 268
6026 // 4879: }
6027 11, 7, // 4884: case 0xb: {
6028 OPC_CheckPredicate, 30, // 4886: check predicate 30
6029 OPC_Decode, 158, 9, 141, 2, // 4888: decode to CLT_S_D using decoder 269
6030 // 4888: }
6031 12, 7, // 4893: case 0xc: {
6032 OPC_CheckPredicate, 30, // 4895: check predicate 30
6033 OPC_Decode, 161, 9, 138, 2, // 4897: decode to CLT_U_B using decoder 266
6034 // 4897: }
6035 13, 7, // 4902: case 0xd: {
6036 OPC_CheckPredicate, 30, // 4904: check predicate 30
6037 OPC_Decode, 163, 9, 139, 2, // 4906: decode to CLT_U_H using decoder 267
6038 // 4906: }
6039 14, 7, // 4911: case 0xe: {
6040 OPC_CheckPredicate, 30, // 4913: check predicate 30
6041 OPC_Decode, 164, 9, 140, 2, // 4915: decode to CLT_U_W using decoder 268
6042 // 4915: }
6043 15, 7, // 4920: case 0xf: {
6044 OPC_CheckPredicate, 30, // 4922: check predicate 30
6045 OPC_Decode, 162, 9, 141, 2, // 4924: decode to CLT_U_D using decoder 269
6046 // 4924: }
6047 16, 7, // 4929: case 0x10: {
6048 OPC_CheckPredicate, 30, // 4931: check predicate 30
6049 OPC_Decode, 137, 9, 138, 2, // 4933: decode to CLE_S_B using decoder 266
6050 // 4933: }
6051 17, 7, // 4938: case 0x11: {
6052 OPC_CheckPredicate, 30, // 4940: check predicate 30
6053 OPC_Decode, 139, 9, 139, 2, // 4942: decode to CLE_S_H using decoder 267
6054 // 4942: }
6055 18, 7, // 4947: case 0x12: {
6056 OPC_CheckPredicate, 30, // 4949: check predicate 30
6057 OPC_Decode, 140, 9, 140, 2, // 4951: decode to CLE_S_W using decoder 268
6058 // 4951: }
6059 19, 7, // 4956: case 0x13: {
6060 OPC_CheckPredicate, 30, // 4958: check predicate 30
6061 OPC_Decode, 138, 9, 141, 2, // 4960: decode to CLE_S_D using decoder 269
6062 // 4960: }
6063 20, 7, // 4965: case 0x14: {
6064 OPC_CheckPredicate, 30, // 4967: check predicate 30
6065 OPC_Decode, 141, 9, 138, 2, // 4969: decode to CLE_U_B using decoder 266
6066 // 4969: }
6067 21, 7, // 4974: case 0x15: {
6068 OPC_CheckPredicate, 30, // 4976: check predicate 30
6069 OPC_Decode, 143, 9, 139, 2, // 4978: decode to CLE_U_H using decoder 267
6070 // 4978: }
6071 22, 7, // 4983: case 0x16: {
6072 OPC_CheckPredicate, 30, // 4985: check predicate 30
6073 OPC_Decode, 144, 9, 140, 2, // 4987: decode to CLE_U_W using decoder 268
6074 // 4987: }
6075 23, 0, // 4992: case 0x17: {
6076 OPC_CheckPredicate, 30, // 4994: check predicate 30
6077 OPC_Decode, 142, 9, 141, 2, // 4996: decode to CLE_U_D using decoder 269
6078 // 4996: }
6079 // 4996: } // switch Inst[25:21]
6080 // 4996: }
6081 16, 163, 2, // 5001: case 0x10: {
6082 OPC_SwitchField, 21, 5, // 5004: switch Inst[25:21] {
6083 0, 7, // 5007: case 0x0: {
6084 OPC_CheckPredicate, 30, // 5009: check predicate 30
6085 OPC_Decode, 210, 6, 138, 2, // 5011: decode to ADD_A_B using decoder 266
6086 // 5011: }
6087 1, 7, // 5016: case 0x1: {
6088 OPC_CheckPredicate, 30, // 5018: check predicate 30
6089 OPC_Decode, 212, 6, 139, 2, // 5020: decode to ADD_A_H using decoder 267
6090 // 5020: }
6091 2, 7, // 5025: case 0x2: {
6092 OPC_CheckPredicate, 30, // 5027: check predicate 30
6093 OPC_Decode, 213, 6, 140, 2, // 5029: decode to ADD_A_W using decoder 268
6094 // 5029: }
6095 3, 7, // 5034: case 0x3: {
6096 OPC_CheckPredicate, 30, // 5036: check predicate 30
6097 OPC_Decode, 211, 6, 141, 2, // 5038: decode to ADD_A_D using decoder 269
6098 // 5038: }
6099 4, 7, // 5043: case 0x4: {
6100 OPC_CheckPredicate, 30, // 5045: check predicate 30
6101 OPC_Decode, 173, 6, 138, 2, // 5047: decode to ADDS_A_B using decoder 266
6102 // 5047: }
6103 5, 7, // 5052: case 0x5: {
6104 OPC_CheckPredicate, 30, // 5054: check predicate 30
6105 OPC_Decode, 175, 6, 139, 2, // 5056: decode to ADDS_A_H using decoder 267
6106 // 5056: }
6107 6, 7, // 5061: case 0x6: {
6108 OPC_CheckPredicate, 30, // 5063: check predicate 30
6109 OPC_Decode, 176, 6, 140, 2, // 5065: decode to ADDS_A_W using decoder 268
6110 // 5065: }
6111 7, 7, // 5070: case 0x7: {
6112 OPC_CheckPredicate, 30, // 5072: check predicate 30
6113 OPC_Decode, 174, 6, 141, 2, // 5074: decode to ADDS_A_D using decoder 269
6114 // 5074: }
6115 8, 7, // 5079: case 0x8: {
6116 OPC_CheckPredicate, 30, // 5081: check predicate 30
6117 OPC_Decode, 177, 6, 138, 2, // 5083: decode to ADDS_S_B using decoder 266
6118 // 5083: }
6119 9, 7, // 5088: case 0x9: {
6120 OPC_CheckPredicate, 30, // 5090: check predicate 30
6121 OPC_Decode, 179, 6, 139, 2, // 5092: decode to ADDS_S_H using decoder 267
6122 // 5092: }
6123 10, 7, // 5097: case 0xa: {
6124 OPC_CheckPredicate, 30, // 5099: check predicate 30
6125 OPC_Decode, 180, 6, 140, 2, // 5101: decode to ADDS_S_W using decoder 268
6126 // 5101: }
6127 11, 7, // 5106: case 0xb: {
6128 OPC_CheckPredicate, 30, // 5108: check predicate 30
6129 OPC_Decode, 178, 6, 141, 2, // 5110: decode to ADDS_S_D using decoder 269
6130 // 5110: }
6131 12, 7, // 5115: case 0xc: {
6132 OPC_CheckPredicate, 30, // 5117: check predicate 30
6133 OPC_Decode, 181, 6, 138, 2, // 5119: decode to ADDS_U_B using decoder 266
6134 // 5119: }
6135 13, 7, // 5124: case 0xd: {
6136 OPC_CheckPredicate, 30, // 5126: check predicate 30
6137 OPC_Decode, 183, 6, 139, 2, // 5128: decode to ADDS_U_H using decoder 267
6138 // 5128: }
6139 14, 7, // 5133: case 0xe: {
6140 OPC_CheckPredicate, 30, // 5135: check predicate 30
6141 OPC_Decode, 184, 6, 140, 2, // 5137: decode to ADDS_U_W using decoder 268
6142 // 5137: }
6143 15, 7, // 5142: case 0xf: {
6144 OPC_CheckPredicate, 30, // 5144: check predicate 30
6145 OPC_Decode, 182, 6, 141, 2, // 5146: decode to ADDS_U_D using decoder 269
6146 // 5146: }
6147 16, 7, // 5151: case 0x10: {
6148 OPC_CheckPredicate, 30, // 5153: check predicate 30
6149 OPC_Decode, 134, 7, 138, 2, // 5155: decode to AVE_S_B using decoder 266
6150 // 5155: }
6151 17, 7, // 5160: case 0x11: {
6152 OPC_CheckPredicate, 30, // 5162: check predicate 30
6153 OPC_Decode, 136, 7, 139, 2, // 5164: decode to AVE_S_H using decoder 267
6154 // 5164: }
6155 18, 7, // 5169: case 0x12: {
6156 OPC_CheckPredicate, 30, // 5171: check predicate 30
6157 OPC_Decode, 137, 7, 140, 2, // 5173: decode to AVE_S_W using decoder 268
6158 // 5173: }
6159 19, 7, // 5178: case 0x13: {
6160 OPC_CheckPredicate, 30, // 5180: check predicate 30
6161 OPC_Decode, 135, 7, 141, 2, // 5182: decode to AVE_S_D using decoder 269
6162 // 5182: }
6163 20, 7, // 5187: case 0x14: {
6164 OPC_CheckPredicate, 30, // 5189: check predicate 30
6165 OPC_Decode, 138, 7, 138, 2, // 5191: decode to AVE_U_B using decoder 266
6166 // 5191: }
6167 21, 7, // 5196: case 0x15: {
6168 OPC_CheckPredicate, 30, // 5198: check predicate 30
6169 OPC_Decode, 140, 7, 139, 2, // 5200: decode to AVE_U_H using decoder 267
6170 // 5200: }
6171 22, 7, // 5205: case 0x16: {
6172 OPC_CheckPredicate, 30, // 5207: check predicate 30
6173 OPC_Decode, 141, 7, 140, 2, // 5209: decode to AVE_U_W using decoder 268
6174 // 5209: }
6175 23, 7, // 5214: case 0x17: {
6176 OPC_CheckPredicate, 30, // 5216: check predicate 30
6177 OPC_Decode, 139, 7, 141, 2, // 5218: decode to AVE_U_D using decoder 269
6178 // 5218: }
6179 24, 7, // 5223: case 0x18: {
6180 OPC_CheckPredicate, 30, // 5225: check predicate 30
6181 OPC_Decode, 254, 6, 138, 2, // 5227: decode to AVER_S_B using decoder 266
6182 // 5227: }
6183 25, 7, // 5232: case 0x19: {
6184 OPC_CheckPredicate, 30, // 5234: check predicate 30
6185 OPC_Decode, 128, 7, 139, 2, // 5236: decode to AVER_S_H using decoder 267
6186 // 5236: }
6187 26, 7, // 5241: case 0x1a: {
6188 OPC_CheckPredicate, 30, // 5243: check predicate 30
6189 OPC_Decode, 129, 7, 140, 2, // 5245: decode to AVER_S_W using decoder 268
6190 // 5245: }
6191 27, 7, // 5250: case 0x1b: {
6192 OPC_CheckPredicate, 30, // 5252: check predicate 30
6193 OPC_Decode, 255, 6, 141, 2, // 5254: decode to AVER_S_D using decoder 269
6194 // 5254: }
6195 28, 7, // 5259: case 0x1c: {
6196 OPC_CheckPredicate, 30, // 5261: check predicate 30
6197 OPC_Decode, 130, 7, 138, 2, // 5263: decode to AVER_U_B using decoder 266
6198 // 5263: }
6199 29, 7, // 5268: case 0x1d: {
6200 OPC_CheckPredicate, 30, // 5270: check predicate 30
6201 OPC_Decode, 132, 7, 139, 2, // 5272: decode to AVER_U_H using decoder 267
6202 // 5272: }
6203 30, 7, // 5277: case 0x1e: {
6204 OPC_CheckPredicate, 30, // 5279: check predicate 30
6205 OPC_Decode, 133, 7, 140, 2, // 5281: decode to AVER_U_W using decoder 268
6206 // 5281: }
6207 31, 0, // 5286: case 0x1f: {
6208 OPC_CheckPredicate, 30, // 5288: check predicate 30
6209 OPC_Decode, 131, 7, 141, 2, // 5290: decode to AVER_U_D using decoder 269
6210 // 5290: }
6211 // 5290: } // switch Inst[25:21]
6212 // 5290: }
6213 17, 219, 1, // 5295: case 0x11: {
6214 OPC_SwitchField, 21, 5, // 5298: switch Inst[25:21] {
6215 0, 7, // 5301: case 0x0: {
6216 OPC_CheckPredicate, 30, // 5303: check predicate 30
6217 OPC_Decode, 169, 21, 138, 2, // 5305: decode to SUBS_S_B using decoder 266
6218 // 5305: }
6219 1, 7, // 5310: case 0x1: {
6220 OPC_CheckPredicate, 30, // 5312: check predicate 30
6221 OPC_Decode, 171, 21, 139, 2, // 5314: decode to SUBS_S_H using decoder 267
6222 // 5314: }
6223 2, 7, // 5319: case 0x2: {
6224 OPC_CheckPredicate, 30, // 5321: check predicate 30
6225 OPC_Decode, 172, 21, 140, 2, // 5323: decode to SUBS_S_W using decoder 268
6226 // 5323: }
6227 3, 7, // 5328: case 0x3: {
6228 OPC_CheckPredicate, 30, // 5330: check predicate 30
6229 OPC_Decode, 170, 21, 141, 2, // 5332: decode to SUBS_S_D using decoder 269
6230 // 5332: }
6231 4, 7, // 5337: case 0x4: {
6232 OPC_CheckPredicate, 30, // 5339: check predicate 30
6233 OPC_Decode, 173, 21, 138, 2, // 5341: decode to SUBS_U_B using decoder 266
6234 // 5341: }
6235 5, 7, // 5346: case 0x5: {
6236 OPC_CheckPredicate, 30, // 5348: check predicate 30
6237 OPC_Decode, 175, 21, 139, 2, // 5350: decode to SUBS_U_H using decoder 267
6238 // 5350: }
6239 6, 7, // 5355: case 0x6: {
6240 OPC_CheckPredicate, 30, // 5357: check predicate 30
6241 OPC_Decode, 176, 21, 140, 2, // 5359: decode to SUBS_U_W using decoder 268
6242 // 5359: }
6243 7, 7, // 5364: case 0x7: {
6244 OPC_CheckPredicate, 30, // 5366: check predicate 30
6245 OPC_Decode, 174, 21, 141, 2, // 5368: decode to SUBS_U_D using decoder 269
6246 // 5368: }
6247 8, 7, // 5373: case 0x8: {
6248 OPC_CheckPredicate, 30, // 5375: check predicate 30
6249 OPC_Decode, 161, 21, 138, 2, // 5377: decode to SUBSUS_U_B using decoder 266
6250 // 5377: }
6251 9, 7, // 5382: case 0x9: {
6252 OPC_CheckPredicate, 30, // 5384: check predicate 30
6253 OPC_Decode, 163, 21, 139, 2, // 5386: decode to SUBSUS_U_H using decoder 267
6254 // 5386: }
6255 10, 7, // 5391: case 0xa: {
6256 OPC_CheckPredicate, 30, // 5393: check predicate 30
6257 OPC_Decode, 164, 21, 140, 2, // 5395: decode to SUBSUS_U_W using decoder 268
6258 // 5395: }
6259 11, 7, // 5400: case 0xb: {
6260 OPC_CheckPredicate, 30, // 5402: check predicate 30
6261 OPC_Decode, 162, 21, 141, 2, // 5404: decode to SUBSUS_U_D using decoder 269
6262 // 5404: }
6263 12, 7, // 5409: case 0xc: {
6264 OPC_CheckPredicate, 30, // 5411: check predicate 30
6265 OPC_Decode, 165, 21, 138, 2, // 5413: decode to SUBSUU_S_B using decoder 266
6266 // 5413: }
6267 13, 7, // 5418: case 0xd: {
6268 OPC_CheckPredicate, 30, // 5420: check predicate 30
6269 OPC_Decode, 167, 21, 139, 2, // 5422: decode to SUBSUU_S_H using decoder 267
6270 // 5422: }
6271 14, 7, // 5427: case 0xe: {
6272 OPC_CheckPredicate, 30, // 5429: check predicate 30
6273 OPC_Decode, 168, 21, 140, 2, // 5431: decode to SUBSUU_S_W using decoder 268
6274 // 5431: }
6275 15, 7, // 5436: case 0xf: {
6276 OPC_CheckPredicate, 30, // 5438: check predicate 30
6277 OPC_Decode, 166, 21, 141, 2, // 5440: decode to SUBSUU_S_D using decoder 269
6278 // 5440: }
6279 16, 7, // 5445: case 0x10: {
6280 OPC_CheckPredicate, 30, // 5447: check predicate 30
6281 OPC_Decode, 242, 6, 138, 2, // 5449: decode to ASUB_S_B using decoder 266
6282 // 5449: }
6283 17, 7, // 5454: case 0x11: {
6284 OPC_CheckPredicate, 30, // 5456: check predicate 30
6285 OPC_Decode, 244, 6, 139, 2, // 5458: decode to ASUB_S_H using decoder 267
6286 // 5458: }
6287 18, 7, // 5463: case 0x12: {
6288 OPC_CheckPredicate, 30, // 5465: check predicate 30
6289 OPC_Decode, 245, 6, 140, 2, // 5467: decode to ASUB_S_W using decoder 268
6290 // 5467: }
6291 19, 7, // 5472: case 0x13: {
6292 OPC_CheckPredicate, 30, // 5474: check predicate 30
6293 OPC_Decode, 243, 6, 141, 2, // 5476: decode to ASUB_S_D using decoder 269
6294 // 5476: }
6295 20, 7, // 5481: case 0x14: {
6296 OPC_CheckPredicate, 30, // 5483: check predicate 30
6297 OPC_Decode, 246, 6, 138, 2, // 5485: decode to ASUB_U_B using decoder 266
6298 // 5485: }
6299 21, 7, // 5490: case 0x15: {
6300 OPC_CheckPredicate, 30, // 5492: check predicate 30
6301 OPC_Decode, 248, 6, 139, 2, // 5494: decode to ASUB_U_H using decoder 267
6302 // 5494: }
6303 22, 7, // 5499: case 0x16: {
6304 OPC_CheckPredicate, 30, // 5501: check predicate 30
6305 OPC_Decode, 249, 6, 140, 2, // 5503: decode to ASUB_U_W using decoder 268
6306 // 5503: }
6307 23, 0, // 5508: case 0x17: {
6308 OPC_CheckPredicate, 30, // 5510: check predicate 30
6309 OPC_Decode, 247, 6, 141, 2, // 5512: decode to ASUB_U_D using decoder 269
6310 // 5512: }
6311 // 5512: } // switch Inst[25:21]
6312 // 5512: }
6313 18, 255, 1, // 5517: case 0x12: {
6314 OPC_SwitchField, 21, 5, // 5520: switch Inst[25:21] {
6315 0, 7, // 5523: case 0x0: {
6316 OPC_CheckPredicate, 30, // 5525: check predicate 30
6317 OPC_Decode, 247, 17, 138, 2, // 5527: decode to MULV_B using decoder 266
6318 // 5527: }
6319 1, 7, // 5532: case 0x1: {
6320 OPC_CheckPredicate, 30, // 5534: check predicate 30
6321 OPC_Decode, 249, 17, 139, 2, // 5536: decode to MULV_H using decoder 267
6322 // 5536: }
6323 2, 7, // 5541: case 0x2: {
6324 OPC_CheckPredicate, 30, // 5543: check predicate 30
6325 OPC_Decode, 250, 17, 140, 2, // 5545: decode to MULV_W using decoder 268
6326 // 5545: }
6327 3, 7, // 5550: case 0x3: {
6328 OPC_CheckPredicate, 30, // 5552: check predicate 30
6329 OPC_Decode, 248, 17, 141, 2, // 5554: decode to MULV_D using decoder 269
6330 // 5554: }
6331 4, 7, // 5559: case 0x4: {
6332 OPC_CheckPredicate, 30, // 5561: check predicate 30
6333 OPC_Decode, 234, 15, 142, 2, // 5563: decode to MADDV_B using decoder 270
6334 // 5563: }
6335 5, 7, // 5568: case 0x5: {
6336 OPC_CheckPredicate, 30, // 5570: check predicate 30
6337 OPC_Decode, 236, 15, 143, 2, // 5572: decode to MADDV_H using decoder 271
6338 // 5572: }
6339 6, 7, // 5577: case 0x6: {
6340 OPC_CheckPredicate, 30, // 5579: check predicate 30
6341 OPC_Decode, 237, 15, 144, 2, // 5581: decode to MADDV_W using decoder 272
6342 // 5581: }
6343 7, 7, // 5586: case 0x7: {
6344 OPC_CheckPredicate, 30, // 5588: check predicate 30
6345 OPC_Decode, 235, 15, 145, 2, // 5590: decode to MADDV_D using decoder 273
6346 // 5590: }
6347 8, 7, // 5595: case 0x8: {
6348 OPC_CheckPredicate, 30, // 5597: check predicate 30
6349 OPC_Decode, 157, 17, 142, 2, // 5599: decode to MSUBV_B using decoder 270
6350 // 5599: }
6351 9, 7, // 5604: case 0x9: {
6352 OPC_CheckPredicate, 30, // 5606: check predicate 30
6353 OPC_Decode, 159, 17, 143, 2, // 5608: decode to MSUBV_H using decoder 271
6354 // 5608: }
6355 10, 7, // 5613: case 0xa: {
6356 OPC_CheckPredicate, 30, // 5615: check predicate 30
6357 OPC_Decode, 160, 17, 144, 2, // 5617: decode to MSUBV_W using decoder 272
6358 // 5617: }
6359 11, 7, // 5622: case 0xb: {
6360 OPC_CheckPredicate, 30, // 5624: check predicate 30
6361 OPC_Decode, 158, 17, 145, 2, // 5626: decode to MSUBV_D using decoder 273
6362 // 5626: }
6363 16, 7, // 5631: case 0x10: {
6364 OPC_CheckPredicate, 30, // 5633: check predicate 30
6365 OPC_Decode, 186, 11, 138, 2, // 5635: decode to DIV_S_B using decoder 266
6366 // 5635: }
6367 17, 7, // 5640: case 0x11: {
6368 OPC_CheckPredicate, 30, // 5642: check predicate 30
6369 OPC_Decode, 188, 11, 139, 2, // 5644: decode to DIV_S_H using decoder 267
6370 // 5644: }
6371 18, 7, // 5649: case 0x12: {
6372 OPC_CheckPredicate, 30, // 5651: check predicate 30
6373 OPC_Decode, 189, 11, 140, 2, // 5653: decode to DIV_S_W using decoder 268
6374 // 5653: }
6375 19, 7, // 5658: case 0x13: {
6376 OPC_CheckPredicate, 30, // 5660: check predicate 30
6377 OPC_Decode, 187, 11, 141, 2, // 5662: decode to DIV_S_D using decoder 269
6378 // 5662: }
6379 20, 7, // 5667: case 0x14: {
6380 OPC_CheckPredicate, 30, // 5669: check predicate 30
6381 OPC_Decode, 190, 11, 138, 2, // 5671: decode to DIV_U_B using decoder 266
6382 // 5671: }
6383 21, 7, // 5676: case 0x15: {
6384 OPC_CheckPredicate, 30, // 5678: check predicate 30
6385 OPC_Decode, 192, 11, 139, 2, // 5680: decode to DIV_U_H using decoder 267
6386 // 5680: }
6387 22, 7, // 5685: case 0x16: {
6388 OPC_CheckPredicate, 30, // 5687: check predicate 30
6389 OPC_Decode, 193, 11, 140, 2, // 5689: decode to DIV_U_W using decoder 268
6390 // 5689: }
6391 23, 7, // 5694: case 0x17: {
6392 OPC_CheckPredicate, 30, // 5696: check predicate 30
6393 OPC_Decode, 191, 11, 141, 2, // 5698: decode to DIV_U_D using decoder 269
6394 // 5698: }
6395 24, 7, // 5703: case 0x18: {
6396 OPC_CheckPredicate, 30, // 5705: check predicate 30
6397 OPC_Decode, 221, 16, 138, 2, // 5707: decode to MOD_S_B using decoder 266
6398 // 5707: }
6399 25, 7, // 5712: case 0x19: {
6400 OPC_CheckPredicate, 30, // 5714: check predicate 30
6401 OPC_Decode, 223, 16, 139, 2, // 5716: decode to MOD_S_H using decoder 267
6402 // 5716: }
6403 26, 7, // 5721: case 0x1a: {
6404 OPC_CheckPredicate, 30, // 5723: check predicate 30
6405 OPC_Decode, 224, 16, 140, 2, // 5725: decode to MOD_S_W using decoder 268
6406 // 5725: }
6407 27, 7, // 5730: case 0x1b: {
6408 OPC_CheckPredicate, 30, // 5732: check predicate 30
6409 OPC_Decode, 222, 16, 141, 2, // 5734: decode to MOD_S_D using decoder 269
6410 // 5734: }
6411 28, 7, // 5739: case 0x1c: {
6412 OPC_CheckPredicate, 30, // 5741: check predicate 30
6413 OPC_Decode, 225, 16, 138, 2, // 5743: decode to MOD_U_B using decoder 266
6414 // 5743: }
6415 29, 7, // 5748: case 0x1d: {
6416 OPC_CheckPredicate, 30, // 5750: check predicate 30
6417 OPC_Decode, 227, 16, 139, 2, // 5752: decode to MOD_U_H using decoder 267
6418 // 5752: }
6419 30, 7, // 5757: case 0x1e: {
6420 OPC_CheckPredicate, 30, // 5759: check predicate 30
6421 OPC_Decode, 228, 16, 140, 2, // 5761: decode to MOD_U_W using decoder 268
6422 // 5761: }
6423 31, 0, // 5766: case 0x1f: {
6424 OPC_CheckPredicate, 30, // 5768: check predicate 30
6425 OPC_Decode, 226, 16, 141, 2, // 5770: decode to MOD_U_D using decoder 269
6426 // 5770: }
6427 // 5770: } // switch Inst[25:21]
6428 // 5770: }
6429 19, 165, 1, // 5775: case 0x13: {
6430 OPC_SwitchField, 21, 5, // 5778: switch Inst[25:21] {
6431 1, 7, // 5781: case 0x1: {
6432 OPC_CheckPredicate, 30, // 5783: check predicate 30
6433 OPC_Decode, 219, 11, 146, 2, // 5785: decode to DOTP_S_H using decoder 274
6434 // 5785: }
6435 2, 7, // 5790: case 0x2: {
6436 OPC_CheckPredicate, 30, // 5792: check predicate 30
6437 OPC_Decode, 220, 11, 147, 2, // 5794: decode to DOTP_S_W using decoder 275
6438 // 5794: }
6439 3, 7, // 5799: case 0x3: {
6440 OPC_CheckPredicate, 30, // 5801: check predicate 30
6441 OPC_Decode, 218, 11, 148, 2, // 5803: decode to DOTP_S_D using decoder 276
6442 // 5803: }
6443 5, 7, // 5808: case 0x5: {
6444 OPC_CheckPredicate, 30, // 5810: check predicate 30
6445 OPC_Decode, 222, 11, 146, 2, // 5812: decode to DOTP_U_H using decoder 274
6446 // 5812: }
6447 6, 7, // 5817: case 0x6: {
6448 OPC_CheckPredicate, 30, // 5819: check predicate 30
6449 OPC_Decode, 223, 11, 147, 2, // 5821: decode to DOTP_U_W using decoder 275
6450 // 5821: }
6451 7, 7, // 5826: case 0x7: {
6452 OPC_CheckPredicate, 30, // 5828: check predicate 30
6453 OPC_Decode, 221, 11, 148, 2, // 5830: decode to DOTP_U_D using decoder 276
6454 // 5830: }
6455 9, 7, // 5835: case 0x9: {
6456 OPC_CheckPredicate, 30, // 5837: check predicate 30
6457 OPC_Decode, 225, 11, 149, 2, // 5839: decode to DPADD_S_H using decoder 277
6458 // 5839: }
6459 10, 7, // 5844: case 0xa: {
6460 OPC_CheckPredicate, 30, // 5846: check predicate 30
6461 OPC_Decode, 226, 11, 150, 2, // 5848: decode to DPADD_S_W using decoder 278
6462 // 5848: }
6463 11, 7, // 5853: case 0xb: {
6464 OPC_CheckPredicate, 30, // 5855: check predicate 30
6465 OPC_Decode, 224, 11, 151, 2, // 5857: decode to DPADD_S_D using decoder 279
6466 // 5857: }
6467 13, 7, // 5862: case 0xd: {
6468 OPC_CheckPredicate, 30, // 5864: check predicate 30
6469 OPC_Decode, 228, 11, 149, 2, // 5866: decode to DPADD_U_H using decoder 277
6470 // 5866: }
6471 14, 7, // 5871: case 0xe: {
6472 OPC_CheckPredicate, 30, // 5873: check predicate 30
6473 OPC_Decode, 229, 11, 150, 2, // 5875: decode to DPADD_U_W using decoder 278
6474 // 5875: }
6475 15, 7, // 5880: case 0xf: {
6476 OPC_CheckPredicate, 30, // 5882: check predicate 30
6477 OPC_Decode, 227, 11, 151, 2, // 5884: decode to DPADD_U_D using decoder 279
6478 // 5884: }
6479 17, 7, // 5889: case 0x11: {
6480 OPC_CheckPredicate, 30, // 5891: check predicate 30
6481 OPC_Decode, 128, 12, 149, 2, // 5893: decode to DPSUB_S_H using decoder 277
6482 // 5893: }
6483 18, 7, // 5898: case 0x12: {
6484 OPC_CheckPredicate, 30, // 5900: check predicate 30
6485 OPC_Decode, 129, 12, 150, 2, // 5902: decode to DPSUB_S_W using decoder 278
6486 // 5902: }
6487 19, 7, // 5907: case 0x13: {
6488 OPC_CheckPredicate, 30, // 5909: check predicate 30
6489 OPC_Decode, 255, 11, 151, 2, // 5911: decode to DPSUB_S_D using decoder 279
6490 // 5911: }
6491 21, 7, // 5916: case 0x15: {
6492 OPC_CheckPredicate, 30, // 5918: check predicate 30
6493 OPC_Decode, 131, 12, 149, 2, // 5920: decode to DPSUB_U_H using decoder 277
6494 // 5920: }
6495 22, 7, // 5925: case 0x16: {
6496 OPC_CheckPredicate, 30, // 5927: check predicate 30
6497 OPC_Decode, 132, 12, 150, 2, // 5929: decode to DPSUB_U_W using decoder 278
6498 // 5929: }
6499 23, 0, // 5934: case 0x17: {
6500 OPC_CheckPredicate, 30, // 5936: check predicate 30
6501 OPC_Decode, 130, 12, 151, 2, // 5938: decode to DPSUB_U_D using decoder 279
6502 // 5938: }
6503 // 5938: } // switch Inst[25:21]
6504 // 5938: }
6505 20, 163, 2, // 5943: case 0x14: {
6506 OPC_SwitchField, 21, 5, // 5946: switch Inst[25:21] {
6507 0, 7, // 5949: case 0x0: {
6508 OPC_CheckPredicate, 30, // 5951: check predicate 30
6509 OPC_Decode, 182, 20, 152, 2, // 5953: decode to SLD_B using decoder 280
6510 // 5953: }
6511 1, 7, // 5958: case 0x1: {
6512 OPC_CheckPredicate, 30, // 5960: check predicate 30
6513 OPC_Decode, 184, 20, 153, 2, // 5962: decode to SLD_H using decoder 281
6514 // 5962: }
6515 2, 7, // 5967: case 0x2: {
6516 OPC_CheckPredicate, 30, // 5969: check predicate 30
6517 OPC_Decode, 185, 20, 154, 2, // 5971: decode to SLD_W using decoder 282
6518 // 5971: }
6519 3, 7, // 5976: case 0x3: {
6520 OPC_CheckPredicate, 30, // 5978: check predicate 30
6521 OPC_Decode, 183, 20, 155, 2, // 5980: decode to SLD_D using decoder 283
6522 // 5980: }
6523 4, 7, // 5985: case 0x4: {
6524 OPC_CheckPredicate, 30, // 5987: check predicate 30
6525 OPC_Decode, 221, 20, 156, 2, // 5989: decode to SPLAT_B using decoder 284
6526 // 5989: }
6527 5, 7, // 5994: case 0x5: {
6528 OPC_CheckPredicate, 30, // 5996: check predicate 30
6529 OPC_Decode, 223, 20, 157, 2, // 5998: decode to SPLAT_H using decoder 285
6530 // 5998: }
6531 6, 7, // 6003: case 0x6: {
6532 OPC_CheckPredicate, 30, // 6005: check predicate 30
6533 OPC_Decode, 224, 20, 158, 2, // 6007: decode to SPLAT_W using decoder 286
6534 // 6007: }
6535 7, 7, // 6012: case 0x7: {
6536 OPC_CheckPredicate, 30, // 6014: check predicate 30
6537 OPC_Decode, 222, 20, 159, 2, // 6016: decode to SPLAT_D using decoder 287
6538 // 6016: }
6539 8, 7, // 6021: case 0x8: {
6540 OPC_CheckPredicate, 30, // 6023: check predicate 30
6541 OPC_Decode, 183, 18, 138, 2, // 6025: decode to PCKEV_B using decoder 266
6542 // 6025: }
6543 9, 7, // 6030: case 0x9: {
6544 OPC_CheckPredicate, 30, // 6032: check predicate 30
6545 OPC_Decode, 185, 18, 139, 2, // 6034: decode to PCKEV_H using decoder 267
6546 // 6034: }
6547 10, 7, // 6039: case 0xa: {
6548 OPC_CheckPredicate, 30, // 6041: check predicate 30
6549 OPC_Decode, 186, 18, 140, 2, // 6043: decode to PCKEV_W using decoder 268
6550 // 6043: }
6551 11, 7, // 6048: case 0xb: {
6552 OPC_CheckPredicate, 30, // 6050: check predicate 30
6553 OPC_Decode, 184, 18, 141, 2, // 6052: decode to PCKEV_D using decoder 269
6554 // 6052: }
6555 12, 7, // 6057: case 0xc: {
6556 OPC_CheckPredicate, 30, // 6059: check predicate 30
6557 OPC_Decode, 187, 18, 138, 2, // 6061: decode to PCKOD_B using decoder 266
6558 // 6061: }
6559 13, 7, // 6066: case 0xd: {
6560 OPC_CheckPredicate, 30, // 6068: check predicate 30
6561 OPC_Decode, 189, 18, 139, 2, // 6070: decode to PCKOD_H using decoder 267
6562 // 6070: }
6563 14, 7, // 6075: case 0xe: {
6564 OPC_CheckPredicate, 30, // 6077: check predicate 30
6565 OPC_Decode, 190, 18, 140, 2, // 6079: decode to PCKOD_W using decoder 268
6566 // 6079: }
6567 15, 7, // 6084: case 0xf: {
6568 OPC_CheckPredicate, 30, // 6086: check predicate 30
6569 OPC_Decode, 188, 18, 141, 2, // 6088: decode to PCKOD_D using decoder 269
6570 // 6088: }
6571 16, 7, // 6093: case 0x10: {
6572 OPC_CheckPredicate, 30, // 6095: check predicate 30
6573 OPC_Decode, 156, 14, 138, 2, // 6097: decode to ILVL_B using decoder 266
6574 // 6097: }
6575 17, 7, // 6102: case 0x11: {
6576 OPC_CheckPredicate, 30, // 6104: check predicate 30
6577 OPC_Decode, 158, 14, 139, 2, // 6106: decode to ILVL_H using decoder 267
6578 // 6106: }
6579 18, 7, // 6111: case 0x12: {
6580 OPC_CheckPredicate, 30, // 6113: check predicate 30
6581 OPC_Decode, 159, 14, 140, 2, // 6115: decode to ILVL_W using decoder 268
6582 // 6115: }
6583 19, 7, // 6120: case 0x13: {
6584 OPC_CheckPredicate, 30, // 6122: check predicate 30
6585 OPC_Decode, 157, 14, 141, 2, // 6124: decode to ILVL_D using decoder 269
6586 // 6124: }
6587 20, 7, // 6129: case 0x14: {
6588 OPC_CheckPredicate, 30, // 6131: check predicate 30
6589 OPC_Decode, 164, 14, 138, 2, // 6133: decode to ILVR_B using decoder 266
6590 // 6133: }
6591 21, 7, // 6138: case 0x15: {
6592 OPC_CheckPredicate, 30, // 6140: check predicate 30
6593 OPC_Decode, 166, 14, 139, 2, // 6142: decode to ILVR_H using decoder 267
6594 // 6142: }
6595 22, 7, // 6147: case 0x16: {
6596 OPC_CheckPredicate, 30, // 6149: check predicate 30
6597 OPC_Decode, 167, 14, 140, 2, // 6151: decode to ILVR_W using decoder 268
6598 // 6151: }
6599 23, 7, // 6156: case 0x17: {
6600 OPC_CheckPredicate, 30, // 6158: check predicate 30
6601 OPC_Decode, 165, 14, 141, 2, // 6160: decode to ILVR_D using decoder 269
6602 // 6160: }
6603 24, 7, // 6165: case 0x18: {
6604 OPC_CheckPredicate, 30, // 6167: check predicate 30
6605 OPC_Decode, 152, 14, 138, 2, // 6169: decode to ILVEV_B using decoder 266
6606 // 6169: }
6607 25, 7, // 6174: case 0x19: {
6608 OPC_CheckPredicate, 30, // 6176: check predicate 30
6609 OPC_Decode, 154, 14, 139, 2, // 6178: decode to ILVEV_H using decoder 267
6610 // 6178: }
6611 26, 7, // 6183: case 0x1a: {
6612 OPC_CheckPredicate, 30, // 6185: check predicate 30
6613 OPC_Decode, 155, 14, 140, 2, // 6187: decode to ILVEV_W using decoder 268
6614 // 6187: }
6615 27, 7, // 6192: case 0x1b: {
6616 OPC_CheckPredicate, 30, // 6194: check predicate 30
6617 OPC_Decode, 153, 14, 141, 2, // 6196: decode to ILVEV_D using decoder 269
6618 // 6196: }
6619 28, 7, // 6201: case 0x1c: {
6620 OPC_CheckPredicate, 30, // 6203: check predicate 30
6621 OPC_Decode, 160, 14, 138, 2, // 6205: decode to ILVOD_B using decoder 266
6622 // 6205: }
6623 29, 7, // 6210: case 0x1d: {
6624 OPC_CheckPredicate, 30, // 6212: check predicate 30
6625 OPC_Decode, 162, 14, 139, 2, // 6214: decode to ILVOD_H using decoder 267
6626 // 6214: }
6627 30, 7, // 6219: case 0x1e: {
6628 OPC_CheckPredicate, 30, // 6221: check predicate 30
6629 OPC_Decode, 163, 14, 140, 2, // 6223: decode to ILVOD_W using decoder 268
6630 // 6223: }
6631 31, 0, // 6228: case 0x1f: {
6632 OPC_CheckPredicate, 30, // 6230: check predicate 30
6633 OPC_Decode, 161, 14, 141, 2, // 6232: decode to ILVOD_D using decoder 269
6634 // 6232: }
6635 // 6232: } // switch Inst[25:21]
6636 // 6232: }
6637 21, 219, 1, // 6237: case 0x15: {
6638 OPC_SwitchField, 21, 5, // 6240: switch Inst[25:21] {
6639 0, 7, // 6243: case 0x0: {
6640 OPC_CheckPredicate, 30, // 6245: check predicate 30
6641 OPC_Decode, 206, 22, 142, 2, // 6247: decode to VSHF_B using decoder 270
6642 // 6247: }
6643 1, 7, // 6252: case 0x1: {
6644 OPC_CheckPredicate, 30, // 6254: check predicate 30
6645 OPC_Decode, 208, 22, 143, 2, // 6256: decode to VSHF_H using decoder 271
6646 // 6256: }
6647 2, 7, // 6261: case 0x2: {
6648 OPC_CheckPredicate, 30, // 6263: check predicate 30
6649 OPC_Decode, 209, 22, 144, 2, // 6265: decode to VSHF_W using decoder 272
6650 // 6265: }
6651 3, 7, // 6270: case 0x3: {
6652 OPC_CheckPredicate, 30, // 6272: check predicate 30
6653 OPC_Decode, 207, 22, 145, 2, // 6274: decode to VSHF_D using decoder 273
6654 // 6274: }
6655 4, 7, // 6279: case 0x4: {
6656 OPC_CheckPredicate, 30, // 6281: check predicate 30
6657 OPC_Decode, 234, 20, 138, 2, // 6283: decode to SRAR_B using decoder 266
6658 // 6283: }
6659 5, 7, // 6288: case 0x5: {
6660 OPC_CheckPredicate, 30, // 6290: check predicate 30
6661 OPC_Decode, 236, 20, 139, 2, // 6292: decode to SRAR_H using decoder 267
6662 // 6292: }
6663 6, 7, // 6297: case 0x6: {
6664 OPC_CheckPredicate, 30, // 6299: check predicate 30
6665 OPC_Decode, 237, 20, 140, 2, // 6301: decode to SRAR_W using decoder 268
6666 // 6301: }
6667 7, 7, // 6306: case 0x7: {
6668 OPC_CheckPredicate, 30, // 6308: check predicate 30
6669 OPC_Decode, 235, 20, 141, 2, // 6310: decode to SRAR_D using decoder 269
6670 // 6310: }
6671 8, 7, // 6315: case 0x8: {
6672 OPC_CheckPredicate, 30, // 6317: check predicate 30
6673 OPC_Decode, 128, 21, 138, 2, // 6319: decode to SRLR_B using decoder 266
6674 // 6319: }
6675 9, 7, // 6324: case 0x9: {
6676 OPC_CheckPredicate, 30, // 6326: check predicate 30
6677 OPC_Decode, 130, 21, 139, 2, // 6328: decode to SRLR_H using decoder 267
6678 // 6328: }
6679 10, 7, // 6333: case 0xa: {
6680 OPC_CheckPredicate, 30, // 6335: check predicate 30
6681 OPC_Decode, 131, 21, 140, 2, // 6337: decode to SRLR_W using decoder 268
6682 // 6337: }
6683 11, 7, // 6342: case 0xb: {
6684 OPC_CheckPredicate, 30, // 6344: check predicate 30
6685 OPC_Decode, 129, 21, 141, 2, // 6346: decode to SRLR_D using decoder 269
6686 // 6346: }
6687 17, 7, // 6351: case 0x11: {
6688 OPC_CheckPredicate, 30, // 6353: check predicate 30
6689 OPC_Decode, 139, 14, 146, 2, // 6355: decode to HADD_S_H using decoder 274
6690 // 6355: }
6691 18, 7, // 6360: case 0x12: {
6692 OPC_CheckPredicate, 30, // 6362: check predicate 30
6693 OPC_Decode, 140, 14, 147, 2, // 6364: decode to HADD_S_W using decoder 275
6694 // 6364: }
6695 19, 7, // 6369: case 0x13: {
6696 OPC_CheckPredicate, 30, // 6371: check predicate 30
6697 OPC_Decode, 138, 14, 148, 2, // 6373: decode to HADD_S_D using decoder 276
6698 // 6373: }
6699 21, 7, // 6378: case 0x15: {
6700 OPC_CheckPredicate, 30, // 6380: check predicate 30
6701 OPC_Decode, 142, 14, 146, 2, // 6382: decode to HADD_U_H using decoder 274
6702 // 6382: }
6703 22, 7, // 6387: case 0x16: {
6704 OPC_CheckPredicate, 30, // 6389: check predicate 30
6705 OPC_Decode, 143, 14, 147, 2, // 6391: decode to HADD_U_W using decoder 275
6706 // 6391: }
6707 23, 7, // 6396: case 0x17: {
6708 OPC_CheckPredicate, 30, // 6398: check predicate 30
6709 OPC_Decode, 141, 14, 148, 2, // 6400: decode to HADD_U_D using decoder 276
6710 // 6400: }
6711 25, 7, // 6405: case 0x19: {
6712 OPC_CheckPredicate, 30, // 6407: check predicate 30
6713 OPC_Decode, 145, 14, 146, 2, // 6409: decode to HSUB_S_H using decoder 274
6714 // 6409: }
6715 26, 7, // 6414: case 0x1a: {
6716 OPC_CheckPredicate, 30, // 6416: check predicate 30
6717 OPC_Decode, 146, 14, 147, 2, // 6418: decode to HSUB_S_W using decoder 275
6718 // 6418: }
6719 27, 7, // 6423: case 0x1b: {
6720 OPC_CheckPredicate, 30, // 6425: check predicate 30
6721 OPC_Decode, 144, 14, 148, 2, // 6427: decode to HSUB_S_D using decoder 276
6722 // 6427: }
6723 29, 7, // 6432: case 0x1d: {
6724 OPC_CheckPredicate, 30, // 6434: check predicate 30
6725 OPC_Decode, 148, 14, 146, 2, // 6436: decode to HSUB_U_H using decoder 274
6726 // 6436: }
6727 30, 7, // 6441: case 0x1e: {
6728 OPC_CheckPredicate, 30, // 6443: check predicate 30
6729 OPC_Decode, 149, 14, 147, 2, // 6445: decode to HSUB_U_W using decoder 275
6730 // 6445: }
6731 31, 0, // 6450: case 0x1f: {
6732 OPC_CheckPredicate, 30, // 6452: check predicate 30
6733 OPC_Decode, 147, 14, 148, 2, // 6454: decode to HSUB_U_D using decoder 276
6734 // 6454: }
6735 // 6454: } // switch Inst[25:21]
6736 // 6454: }
6737 25, 194, 2, // 6459: case 0x19: {
6738 OPC_SwitchField, 20, 6, // 6462: switch Inst[25:20] {
6739 0, 7, // 6465: case 0x0: {
6740 OPC_CheckPredicate, 30, // 6467: check predicate 30
6741 OPC_Decode, 178, 20, 160, 2, // 6469: decode to SLDI_B using decoder 288
6742 // 6469: }
6743 2, 11, // 6474: case 0x2: {
6744 OPC_CheckPredicate, 30, // 6476: check predicate 30
6745 OPC_CheckField, 19, 1, 0, // 6478: check Inst[19] == 0x0
6746 OPC_Decode, 180, 20, 161, 2, // 6482: decode to SLDI_H using decoder 289
6747 // 6482: }
6748 3, 38, // 6487: case 0x3: {
6749 OPC_SwitchField, 18, 2, // 6489: switch Inst[19:18] {
6750 0, 7, // 6492: case 0x0: {
6751 OPC_CheckPredicate, 30, // 6494: check predicate 30
6752 OPC_Decode, 181, 20, 162, 2, // 6496: decode to SLDI_W using decoder 290
6753 // 6496: }
6754 2, 11, // 6501: case 0x2: {
6755 OPC_CheckPredicate, 30, // 6503: check predicate 30
6756 OPC_CheckField, 17, 1, 0, // 6505: check Inst[17] == 0x0
6757 OPC_Decode, 179, 20, 163, 2, // 6509: decode to SLDI_D using decoder 291
6758 // 6509: }
6759 3, 0, // 6514: case 0x3: {
6760 OPC_CheckPredicate, 30, // 6516: check predicate 30
6761 OPC_CheckField, 16, 2, 2, // 6518: check Inst[17:16] == 0x2
6762 OPC_Decode, 147, 10, 164, 2, // 6522: decode to CTCMSA using decoder 292
6763 // 6522: }
6764 // 6522: } // switch Inst[19:18]
6765 // 6522: }
6766 4, 7, // 6527: case 0x4: {
6767 OPC_CheckPredicate, 30, // 6529: check predicate 30
6768 OPC_Decode, 217, 20, 165, 2, // 6531: decode to SPLATI_B using decoder 293
6769 // 6531: }
6770 6, 11, // 6536: case 0x6: {
6771 OPC_CheckPredicate, 30, // 6538: check predicate 30
6772 OPC_CheckField, 19, 1, 0, // 6540: check Inst[19] == 0x0
6773 OPC_Decode, 219, 20, 166, 2, // 6544: decode to SPLATI_H using decoder 294
6774 // 6544: }
6775 7, 38, // 6549: case 0x7: {
6776 OPC_SwitchField, 18, 2, // 6551: switch Inst[19:18] {
6777 0, 7, // 6554: case 0x0: {
6778 OPC_CheckPredicate, 30, // 6556: check predicate 30
6779 OPC_Decode, 220, 20, 167, 2, // 6558: decode to SPLATI_W using decoder 295
6780 // 6558: }
6781 2, 11, // 6563: case 0x2: {
6782 OPC_CheckPredicate, 30, // 6565: check predicate 30
6783 OPC_CheckField, 17, 1, 0, // 6567: check Inst[17] == 0x0
6784 OPC_Decode, 218, 20, 168, 2, // 6571: decode to SPLATI_D using decoder 296
6785 // 6571: }
6786 3, 0, // 6576: case 0x3: {
6787 OPC_CheckPredicate, 30, // 6578: check predicate 30
6788 OPC_CheckField, 16, 2, 2, // 6580: check Inst[17:16] == 0x2
6789 OPC_Decode, 248, 8, 169, 2, // 6584: decode to CFCMSA using decoder 297
6790 // 6584: }
6791 // 6584: } // switch Inst[19:18]
6792 // 6584: }
6793 8, 7, // 6589: case 0x8: {
6794 OPC_CheckPredicate, 30, // 6591: check predicate 30
6795 OPC_Decode, 129, 10, 170, 2, // 6593: decode to COPY_S_B using decoder 298
6796 // 6593: }
6797 10, 11, // 6598: case 0xa: {
6798 OPC_CheckPredicate, 30, // 6600: check predicate 30
6799 OPC_CheckField, 19, 1, 0, // 6602: check Inst[19] == 0x0
6800 OPC_Decode, 131, 10, 171, 2, // 6606: decode to COPY_S_H using decoder 299
6801 // 6606: }
6802 11, 38, // 6611: case 0xb: {
6803 OPC_SwitchField, 18, 2, // 6613: switch Inst[19:18] {
6804 0, 7, // 6616: case 0x0: {
6805 OPC_CheckPredicate, 30, // 6618: check predicate 30
6806 OPC_Decode, 132, 10, 172, 2, // 6620: decode to COPY_S_W using decoder 300
6807 // 6620: }
6808 2, 11, // 6625: case 0x2: {
6809 OPC_CheckPredicate, 38, // 6627: check predicate 38
6810 OPC_CheckField, 17, 1, 0, // 6629: check Inst[17] == 0x0
6811 OPC_Decode, 130, 10, 173, 2, // 6633: decode to COPY_S_D using decoder 301
6812 // 6633: }
6813 3, 0, // 6638: case 0x3: {
6814 OPC_CheckPredicate, 30, // 6640: check predicate 30
6815 OPC_CheckField, 16, 2, 2, // 6642: check Inst[17:16] == 0x2
6816 OPC_Decode, 233, 16, 174, 2, // 6646: decode to MOVE_V using decoder 302
6817 // 6646: }
6818 // 6646: } // switch Inst[19:18]
6819 // 6646: }
6820 12, 7, // 6651: case 0xc: {
6821 OPC_CheckPredicate, 30, // 6653: check predicate 30
6822 OPC_Decode, 133, 10, 170, 2, // 6655: decode to COPY_U_B using decoder 298
6823 // 6655: }
6824 14, 11, // 6660: case 0xe: {
6825 OPC_CheckPredicate, 30, // 6662: check predicate 30
6826 OPC_CheckField, 19, 1, 0, // 6664: check Inst[19] == 0x0
6827 OPC_Decode, 134, 10, 171, 2, // 6668: decode to COPY_U_H using decoder 299
6828 // 6668: }
6829 15, 11, // 6673: case 0xf: {
6830 OPC_CheckPredicate, 38, // 6675: check predicate 38
6831 OPC_CheckField, 18, 2, 0, // 6677: check Inst[19:18] == 0x0
6832 OPC_Decode, 135, 10, 172, 2, // 6681: decode to COPY_U_W using decoder 300
6833 // 6681: }
6834 16, 7, // 6686: case 0x10: {
6835 OPC_CheckPredicate, 30, // 6688: check predicate 30
6836 OPC_Decode, 169, 14, 175, 2, // 6690: decode to INSERT_B using decoder 303
6837 // 6690: }
6838 18, 11, // 6695: case 0x12: {
6839 OPC_CheckPredicate, 30, // 6697: check predicate 30
6840 OPC_CheckField, 19, 1, 0, // 6699: check Inst[19] == 0x0
6841 OPC_Decode, 171, 14, 176, 2, // 6703: decode to INSERT_H using decoder 304
6842 // 6703: }
6843 19, 25, // 6708: case 0x13: {
6844 OPC_SwitchField, 18, 2, // 6710: switch Inst[19:18] {
6845 0, 7, // 6713: case 0x0: {
6846 OPC_CheckPredicate, 30, // 6715: check predicate 30
6847 OPC_Decode, 172, 14, 177, 2, // 6717: decode to INSERT_W using decoder 305
6848 // 6717: }
6849 2, 0, // 6722: case 0x2: {
6850 OPC_CheckPredicate, 38, // 6724: check predicate 38
6851 OPC_CheckField, 17, 1, 0, // 6726: check Inst[17] == 0x0
6852 OPC_Decode, 170, 14, 178, 2, // 6730: decode to INSERT_D using decoder 306
6853 // 6730: }
6854 // 6730: } // switch Inst[19:18]
6855 // 6730: }
6856 20, 7, // 6735: case 0x14: {
6857 OPC_CheckPredicate, 30, // 6737: check predicate 30
6858 OPC_Decode, 174, 14, 179, 2, // 6739: decode to INSVE_B using decoder 307
6859 // 6739: }
6860 22, 11, // 6744: case 0x16: {
6861 OPC_CheckPredicate, 30, // 6746: check predicate 30
6862 OPC_CheckField, 19, 1, 0, // 6748: check Inst[19] == 0x0
6863 OPC_Decode, 176, 14, 179, 2, // 6752: decode to INSVE_H using decoder 307
6864 // 6752: }
6865 23, 0, // 6757: case 0x17: {
6866 OPC_SwitchField, 18, 2, // 6759: switch Inst[19:18] {
6867 0, 7, // 6762: case 0x0: {
6868 OPC_CheckPredicate, 30, // 6764: check predicate 30
6869 OPC_Decode, 177, 14, 179, 2, // 6766: decode to INSVE_W using decoder 307
6870 // 6766: }
6871 2, 0, // 6771: case 0x2: {
6872 OPC_CheckPredicate, 30, // 6773: check predicate 30
6873 OPC_CheckField, 17, 1, 0, // 6775: check Inst[17] == 0x0
6874 OPC_Decode, 175, 14, 179, 2, // 6779: decode to INSVE_D using decoder 307
6875 // 6779: }
6876 // 6779: } // switch Inst[19:18]
6877 // 6779: }
6878 // 6779: } // switch Inst[25:20]
6879 // 6779: }
6880 26, 163, 2, // 6784: case 0x1a: {
6881 OPC_SwitchField, 21, 5, // 6787: switch Inst[25:21] {
6882 0, 7, // 6790: case 0x0: {
6883 OPC_CheckPredicate, 30, // 6792: check predicate 30
6884 OPC_Decode, 226, 12, 140, 2, // 6794: decode to FCAF_W using decoder 268
6885 // 6794: }
6886 1, 7, // 6799: case 0x1: {
6887 OPC_CheckPredicate, 30, // 6801: check predicate 30
6888 OPC_Decode, 225, 12, 141, 2, // 6803: decode to FCAF_D using decoder 269
6889 // 6803: }
6890 2, 7, // 6808: case 0x2: {
6891 OPC_CheckPredicate, 30, // 6810: check predicate 30
6892 OPC_Decode, 253, 12, 140, 2, // 6812: decode to FCUN_W using decoder 268
6893 // 6812: }
6894 3, 7, // 6817: case 0x3: {
6895 OPC_CheckPredicate, 30, // 6819: check predicate 30
6896 OPC_Decode, 252, 12, 141, 2, // 6821: decode to FCUN_D using decoder 269
6897 // 6821: }
6898 4, 7, // 6826: case 0x4: {
6899 OPC_CheckPredicate, 30, // 6828: check predicate 30
6900 OPC_Decode, 228, 12, 140, 2, // 6830: decode to FCEQ_W using decoder 268
6901 // 6830: }
6902 5, 7, // 6835: case 0x5: {
6903 OPC_CheckPredicate, 30, // 6837: check predicate 30
6904 OPC_Decode, 227, 12, 141, 2, // 6839: decode to FCEQ_D using decoder 269
6905 // 6839: }
6906 6, 7, // 6844: case 0x6: {
6907 OPC_CheckPredicate, 30, // 6846: check predicate 30
6908 OPC_Decode, 245, 12, 140, 2, // 6848: decode to FCUEQ_W using decoder 268
6909 // 6848: }
6910 7, 7, // 6853: case 0x7: {
6911 OPC_CheckPredicate, 30, // 6855: check predicate 30
6912 OPC_Decode, 244, 12, 141, 2, // 6857: decode to FCUEQ_D using decoder 269
6913 // 6857: }
6914 8, 7, // 6862: case 0x8: {
6915 OPC_CheckPredicate, 30, // 6864: check predicate 30
6916 OPC_Decode, 234, 12, 140, 2, // 6866: decode to FCLT_W using decoder 268
6917 // 6866: }
6918 9, 7, // 6871: case 0x9: {
6919 OPC_CheckPredicate, 30, // 6873: check predicate 30
6920 OPC_Decode, 233, 12, 141, 2, // 6875: decode to FCLT_D using decoder 269
6921 // 6875: }
6922 10, 7, // 6880: case 0xa: {
6923 OPC_CheckPredicate, 30, // 6882: check predicate 30
6924 OPC_Decode, 249, 12, 140, 2, // 6884: decode to FCULT_W using decoder 268
6925 // 6884: }
6926 11, 7, // 6889: case 0xb: {
6927 OPC_CheckPredicate, 30, // 6891: check predicate 30
6928 OPC_Decode, 248, 12, 141, 2, // 6893: decode to FCULT_D using decoder 269
6929 // 6893: }
6930 12, 7, // 6898: case 0xc: {
6931 OPC_CheckPredicate, 30, // 6900: check predicate 30
6932 OPC_Decode, 232, 12, 140, 2, // 6902: decode to FCLE_W using decoder 268
6933 // 6902: }
6934 13, 7, // 6907: case 0xd: {
6935 OPC_CheckPredicate, 30, // 6909: check predicate 30
6936 OPC_Decode, 231, 12, 141, 2, // 6911: decode to FCLE_D using decoder 269
6937 // 6911: }
6938 14, 7, // 6916: case 0xe: {
6939 OPC_CheckPredicate, 30, // 6918: check predicate 30
6940 OPC_Decode, 247, 12, 140, 2, // 6920: decode to FCULE_W using decoder 268
6941 // 6920: }
6942 15, 7, // 6925: case 0xf: {
6943 OPC_CheckPredicate, 30, // 6927: check predicate 30
6944 OPC_Decode, 246, 12, 141, 2, // 6929: decode to FCULE_D using decoder 269
6945 // 6929: }
6946 16, 7, // 6934: case 0x10: {
6947 OPC_CheckPredicate, 30, // 6936: check predicate 30
6948 OPC_Decode, 213, 13, 140, 2, // 6938: decode to FSAF_W using decoder 268
6949 // 6938: }
6950 17, 7, // 6943: case 0x11: {
6951 OPC_CheckPredicate, 30, // 6945: check predicate 30
6952 OPC_Decode, 212, 13, 141, 2, // 6947: decode to FSAF_D using decoder 269
6953 // 6947: }
6954 18, 7, // 6952: case 0x12: {
6955 OPC_CheckPredicate, 30, // 6954: check predicate 30
6956 OPC_Decode, 251, 13, 140, 2, // 6956: decode to FSUN_W using decoder 268
6957 // 6956: }
6958 19, 7, // 6961: case 0x13: {
6959 OPC_CheckPredicate, 30, // 6963: check predicate 30
6960 OPC_Decode, 250, 13, 141, 2, // 6965: decode to FSUN_D using decoder 269
6961 // 6965: }
6962 20, 7, // 6970: case 0x14: {
6963 OPC_CheckPredicate, 30, // 6972: check predicate 30
6964 OPC_Decode, 215, 13, 140, 2, // 6974: decode to FSEQ_W using decoder 268
6965 // 6974: }
6966 21, 7, // 6979: case 0x15: {
6967 OPC_CheckPredicate, 30, // 6981: check predicate 30
6968 OPC_Decode, 214, 13, 141, 2, // 6983: decode to FSEQ_D using decoder 269
6969 // 6983: }
6970 22, 7, // 6988: case 0x16: {
6971 OPC_CheckPredicate, 30, // 6990: check predicate 30
6972 OPC_Decode, 243, 13, 140, 2, // 6992: decode to FSUEQ_W using decoder 268
6973 // 6992: }
6974 23, 7, // 6997: case 0x17: {
6975 OPC_CheckPredicate, 30, // 6999: check predicate 30
6976 OPC_Decode, 242, 13, 141, 2, // 7001: decode to FSUEQ_D using decoder 269
6977 // 7001: }
6978 24, 7, // 7006: case 0x18: {
6979 OPC_CheckPredicate, 30, // 7008: check predicate 30
6980 OPC_Decode, 219, 13, 140, 2, // 7010: decode to FSLT_W using decoder 268
6981 // 7010: }
6982 25, 7, // 7015: case 0x19: {
6983 OPC_CheckPredicate, 30, // 7017: check predicate 30
6984 OPC_Decode, 218, 13, 141, 2, // 7019: decode to FSLT_D using decoder 269
6985 // 7019: }
6986 26, 7, // 7024: case 0x1a: {
6987 OPC_CheckPredicate, 30, // 7026: check predicate 30
6988 OPC_Decode, 247, 13, 140, 2, // 7028: decode to FSULT_W using decoder 268
6989 // 7028: }
6990 27, 7, // 7033: case 0x1b: {
6991 OPC_CheckPredicate, 30, // 7035: check predicate 30
6992 OPC_Decode, 246, 13, 141, 2, // 7037: decode to FSULT_D using decoder 269
6993 // 7037: }
6994 28, 7, // 7042: case 0x1c: {
6995 OPC_CheckPredicate, 30, // 7044: check predicate 30
6996 OPC_Decode, 217, 13, 140, 2, // 7046: decode to FSLE_W using decoder 268
6997 // 7046: }
6998 29, 7, // 7051: case 0x1d: {
6999 OPC_CheckPredicate, 30, // 7053: check predicate 30
7000 OPC_Decode, 216, 13, 141, 2, // 7055: decode to FSLE_D using decoder 269
7001 // 7055: }
7002 30, 7, // 7060: case 0x1e: {
7003 OPC_CheckPredicate, 30, // 7062: check predicate 30
7004 OPC_Decode, 245, 13, 140, 2, // 7064: decode to FSULE_W using decoder 268
7005 // 7064: }
7006 31, 0, // 7069: case 0x1f: {
7007 OPC_CheckPredicate, 30, // 7071: check predicate 30
7008 OPC_Decode, 244, 13, 141, 2, // 7073: decode to FSULE_D using decoder 269
7009 // 7073: }
7010 // 7073: } // switch Inst[25:21]
7011 // 7073: }
7012 27, 237, 1, // 7078: case 0x1b: {
7013 OPC_SwitchField, 21, 5, // 7081: switch Inst[25:21] {
7014 0, 7, // 7084: case 0x0: {
7015 OPC_CheckPredicate, 30, // 7086: check predicate 30
7016 OPC_Decode, 224, 12, 140, 2, // 7088: decode to FADD_W using decoder 268
7017 // 7088: }
7018 1, 7, // 7093: case 0x1: {
7019 OPC_CheckPredicate, 30, // 7095: check predicate 30
7020 OPC_Decode, 215, 12, 141, 2, // 7097: decode to FADD_D using decoder 269
7021 // 7097: }
7022 2, 7, // 7102: case 0x2: {
7023 OPC_CheckPredicate, 30, // 7104: check predicate 30
7024 OPC_Decode, 241, 13, 140, 2, // 7106: decode to FSUB_W using decoder 268
7025 // 7106: }
7026 3, 7, // 7111: case 0x3: {
7027 OPC_CheckPredicate, 30, // 7113: check predicate 30
7028 OPC_Decode, 232, 13, 141, 2, // 7115: decode to FSUB_D using decoder 269
7029 // 7115: }
7030 4, 7, // 7120: case 0x4: {
7031 OPC_CheckPredicate, 30, // 7122: check predicate 30
7032 OPC_Decode, 197, 13, 140, 2, // 7124: decode to FMUL_W using decoder 268
7033 // 7124: }
7034 5, 7, // 7129: case 0x5: {
7035 OPC_CheckPredicate, 30, // 7131: check predicate 30
7036 OPC_Decode, 188, 13, 141, 2, // 7133: decode to FMUL_D using decoder 269
7037 // 7133: }
7038 6, 7, // 7138: case 0x6: {
7039 OPC_CheckPredicate, 30, // 7140: check predicate 30
7040 OPC_Decode, 134, 13, 140, 2, // 7142: decode to FDIV_W using decoder 268
7041 // 7142: }
7042 7, 7, // 7147: case 0x7: {
7043 OPC_CheckPredicate, 30, // 7149: check predicate 30
7044 OPC_Decode, 254, 12, 141, 2, // 7151: decode to FDIV_D using decoder 269
7045 // 7151: }
7046 8, 7, // 7156: case 0x8: {
7047 OPC_CheckPredicate, 30, // 7158: check predicate 30
7048 OPC_Decode, 169, 13, 144, 2, // 7160: decode to FMADD_W using decoder 272
7049 // 7160: }
7050 9, 7, // 7165: case 0x9: {
7051 OPC_CheckPredicate, 30, // 7167: check predicate 30
7052 OPC_Decode, 168, 13, 145, 2, // 7169: decode to FMADD_D using decoder 273
7053 // 7169: }
7054 10, 7, // 7174: case 0xa: {
7055 OPC_CheckPredicate, 30, // 7176: check predicate 30
7056 OPC_Decode, 187, 13, 144, 2, // 7178: decode to FMSUB_W using decoder 272
7057 // 7178: }
7058 11, 7, // 7183: case 0xb: {
7059 OPC_CheckPredicate, 30, // 7185: check predicate 30
7060 OPC_Decode, 186, 13, 145, 2, // 7187: decode to FMSUB_D using decoder 273
7061 // 7187: }
7062 14, 7, // 7192: case 0xe: {
7063 OPC_CheckPredicate, 30, // 7194: check predicate 30
7064 OPC_Decode, 138, 13, 140, 2, // 7196: decode to FEXP2_W using decoder 268
7065 // 7196: }
7066 15, 7, // 7201: case 0xf: {
7067 OPC_CheckPredicate, 30, // 7203: check predicate 30
7068 OPC_Decode, 137, 13, 141, 2, // 7205: decode to FEXP2_D using decoder 269
7069 // 7205: }
7070 16, 7, // 7210: case 0x10: {
7071 OPC_CheckPredicate, 30, // 7212: check predicate 30
7072 OPC_Decode, 135, 13, 180, 2, // 7214: decode to FEXDO_H using decoder 308
7073 // 7214: }
7074 17, 7, // 7219: case 0x11: {
7075 OPC_CheckPredicate, 30, // 7221: check predicate 30
7076 OPC_Decode, 136, 13, 181, 2, // 7223: decode to FEXDO_W using decoder 309
7077 // 7223: }
7078 20, 7, // 7228: case 0x14: {
7079 OPC_CheckPredicate, 30, // 7230: check predicate 30
7080 OPC_Decode, 128, 14, 180, 2, // 7232: decode to FTQ_H using decoder 308
7081 // 7232: }
7082 21, 7, // 7237: case 0x15: {
7083 OPC_CheckPredicate, 30, // 7239: check predicate 30
7084 OPC_Decode, 129, 14, 181, 2, // 7241: decode to FTQ_W using decoder 309
7085 // 7241: }
7086 24, 7, // 7246: case 0x18: {
7087 OPC_CheckPredicate, 30, // 7248: check predicate 30
7088 OPC_Decode, 177, 13, 140, 2, // 7250: decode to FMIN_W using decoder 268
7089 // 7250: }
7090 25, 7, // 7255: case 0x19: {
7091 OPC_CheckPredicate, 30, // 7257: check predicate 30
7092 OPC_Decode, 176, 13, 141, 2, // 7259: decode to FMIN_D using decoder 269
7093 // 7259: }
7094 26, 7, // 7264: case 0x1a: {
7095 OPC_CheckPredicate, 30, // 7266: check predicate 30
7096 OPC_Decode, 175, 13, 140, 2, // 7268: decode to FMIN_A_W using decoder 268
7097 // 7268: }
7098 27, 7, // 7273: case 0x1b: {
7099 OPC_CheckPredicate, 30, // 7275: check predicate 30
7100 OPC_Decode, 174, 13, 141, 2, // 7277: decode to FMIN_A_D using decoder 269
7101 // 7277: }
7102 28, 7, // 7282: case 0x1c: {
7103 OPC_CheckPredicate, 30, // 7284: check predicate 30
7104 OPC_Decode, 173, 13, 140, 2, // 7286: decode to FMAX_W using decoder 268
7105 // 7286: }
7106 29, 7, // 7291: case 0x1d: {
7107 OPC_CheckPredicate, 30, // 7293: check predicate 30
7108 OPC_Decode, 172, 13, 141, 2, // 7295: decode to FMAX_D using decoder 269
7109 // 7295: }
7110 30, 7, // 7300: case 0x1e: {
7111 OPC_CheckPredicate, 30, // 7302: check predicate 30
7112 OPC_Decode, 171, 13, 140, 2, // 7304: decode to FMAX_A_W using decoder 268
7113 // 7304: }
7114 31, 0, // 7309: case 0x1f: {
7115 OPC_CheckPredicate, 30, // 7311: check predicate 30
7116 OPC_Decode, 170, 13, 141, 2, // 7313: decode to FMAX_A_D using decoder 269
7117 // 7313: }
7118 // 7313: } // switch Inst[25:21]
7119 // 7313: }
7120 28, 219, 1, // 7318: case 0x1c: {
7121 OPC_SwitchField, 21, 5, // 7321: switch Inst[25:21] {
7122 2, 7, // 7324: case 0x2: {
7123 OPC_CheckPredicate, 30, // 7326: check predicate 30
7124 OPC_Decode, 243, 12, 140, 2, // 7328: decode to FCOR_W using decoder 268
7125 // 7328: }
7126 3, 7, // 7333: case 0x3: {
7127 OPC_CheckPredicate, 30, // 7335: check predicate 30
7128 OPC_Decode, 242, 12, 141, 2, // 7337: decode to FCOR_D using decoder 269
7129 // 7337: }
7130 4, 7, // 7342: case 0x4: {
7131 OPC_CheckPredicate, 30, // 7344: check predicate 30
7132 OPC_Decode, 251, 12, 140, 2, // 7346: decode to FCUNE_W using decoder 268
7133 // 7346: }
7134 5, 7, // 7351: case 0x5: {
7135 OPC_CheckPredicate, 30, // 7353: check predicate 30
7136 OPC_Decode, 250, 12, 141, 2, // 7355: decode to FCUNE_D using decoder 269
7137 // 7355: }
7138 6, 7, // 7360: case 0x6: {
7139 OPC_CheckPredicate, 30, // 7362: check predicate 30
7140 OPC_Decode, 241, 12, 140, 2, // 7364: decode to FCNE_W using decoder 268
7141 // 7364: }
7142 7, 7, // 7369: case 0x7: {
7143 OPC_CheckPredicate, 30, // 7371: check predicate 30
7144 OPC_Decode, 240, 12, 141, 2, // 7373: decode to FCNE_D using decoder 269
7145 // 7373: }
7146 8, 7, // 7378: case 0x8: {
7147 OPC_CheckPredicate, 30, // 7380: check predicate 30
7148 OPC_Decode, 255, 17, 139, 2, // 7382: decode to MUL_Q_H using decoder 267
7149 // 7382: }
7150 9, 7, // 7387: case 0x9: {
7151 OPC_CheckPredicate, 30, // 7389: check predicate 30
7152 OPC_Decode, 128, 18, 140, 2, // 7391: decode to MUL_Q_W using decoder 268
7153 // 7391: }
7154 10, 7, // 7396: case 0xa: {
7155 OPC_CheckPredicate, 30, // 7398: check predicate 30
7156 OPC_Decode, 244, 15, 143, 2, // 7400: decode to MADD_Q_H using decoder 271
7157 // 7400: }
7158 11, 7, // 7405: case 0xb: {
7159 OPC_CheckPredicate, 30, // 7407: check predicate 30
7160 OPC_Decode, 245, 15, 144, 2, // 7409: decode to MADD_Q_W using decoder 272
7161 // 7409: }
7162 12, 7, // 7414: case 0xc: {
7163 OPC_CheckPredicate, 30, // 7416: check predicate 30
7164 OPC_Decode, 167, 17, 143, 2, // 7418: decode to MSUB_Q_H using decoder 271
7165 // 7418: }
7166 13, 7, // 7423: case 0xd: {
7167 OPC_CheckPredicate, 30, // 7425: check predicate 30
7168 OPC_Decode, 168, 17, 144, 2, // 7427: decode to MSUB_Q_W using decoder 272
7169 // 7427: }
7170 18, 7, // 7432: case 0x12: {
7171 OPC_CheckPredicate, 30, // 7434: check predicate 30
7172 OPC_Decode, 223, 13, 140, 2, // 7436: decode to FSOR_W using decoder 268
7173 // 7436: }
7174 19, 7, // 7441: case 0x13: {
7175 OPC_CheckPredicate, 30, // 7443: check predicate 30
7176 OPC_Decode, 222, 13, 141, 2, // 7445: decode to FSOR_D using decoder 269
7177 // 7445: }
7178 20, 7, // 7450: case 0x14: {
7179 OPC_CheckPredicate, 30, // 7452: check predicate 30
7180 OPC_Decode, 249, 13, 140, 2, // 7454: decode to FSUNE_W using decoder 268
7181 // 7454: }
7182 21, 7, // 7459: case 0x15: {
7183 OPC_CheckPredicate, 30, // 7461: check predicate 30
7184 OPC_Decode, 248, 13, 141, 2, // 7463: decode to FSUNE_D using decoder 269
7185 // 7463: }
7186 22, 7, // 7468: case 0x16: {
7187 OPC_CheckPredicate, 30, // 7470: check predicate 30
7188 OPC_Decode, 221, 13, 140, 2, // 7472: decode to FSNE_W using decoder 268
7189 // 7472: }
7190 23, 7, // 7477: case 0x17: {
7191 OPC_CheckPredicate, 30, // 7479: check predicate 30
7192 OPC_Decode, 220, 13, 141, 2, // 7481: decode to FSNE_D using decoder 269
7193 // 7481: }
7194 24, 7, // 7486: case 0x18: {
7195 OPC_CheckPredicate, 30, // 7488: check predicate 30
7196 OPC_Decode, 231, 17, 139, 2, // 7490: decode to MULR_Q_H using decoder 267
7197 // 7490: }
7198 25, 7, // 7495: case 0x19: {
7199 OPC_CheckPredicate, 30, // 7497: check predicate 30
7200 OPC_Decode, 232, 17, 140, 2, // 7499: decode to MULR_Q_W using decoder 268
7201 // 7499: }
7202 26, 7, // 7504: case 0x1a: {
7203 OPC_CheckPredicate, 30, // 7506: check predicate 30
7204 OPC_Decode, 228, 15, 143, 2, // 7508: decode to MADDR_Q_H using decoder 271
7205 // 7508: }
7206 27, 7, // 7513: case 0x1b: {
7207 OPC_CheckPredicate, 30, // 7515: check predicate 30
7208 OPC_Decode, 229, 15, 144, 2, // 7517: decode to MADDR_Q_W using decoder 272
7209 // 7517: }
7210 28, 7, // 7522: case 0x1c: {
7211 OPC_CheckPredicate, 30, // 7524: check predicate 30
7212 OPC_Decode, 151, 17, 143, 2, // 7526: decode to MSUBR_Q_H using decoder 271
7213 // 7526: }
7214 29, 0, // 7531: case 0x1d: {
7215 OPC_CheckPredicate, 30, // 7533: check predicate 30
7216 OPC_Decode, 152, 17, 144, 2, // 7535: decode to MSUBR_Q_W using decoder 272
7217 // 7535: }
7218 // 7535: } // switch Inst[25:21]
7219 // 7535: }
7220 30, 253, 3, // 7540: case 0x1e: {
7221 OPC_SwitchField, 21, 5, // 7543: switch Inst[25:21] {
7222 0, 7, // 7546: case 0x0: {
7223 OPC_CheckPredicate, 30, // 7548: check predicate 30
7224 OPC_Decode, 236, 6, 138, 2, // 7550: decode to AND_V using decoder 266
7225 // 7550: }
7226 1, 7, // 7555: case 0x1: {
7227 OPC_CheckPredicate, 30, // 7557: check predicate 30
7228 OPC_Decode, 173, 18, 138, 2, // 7559: decode to OR_V using decoder 266
7229 // 7559: }
7230 2, 7, // 7564: case 0x2: {
7231 OPC_CheckPredicate, 30, // 7566: check predicate 30
7232 OPC_Decode, 160, 18, 138, 2, // 7568: decode to NOR_V using decoder 266
7233 // 7568: }
7234 3, 7, // 7573: case 0x3: {
7235 OPC_CheckPredicate, 30, // 7575: check predicate 30
7236 OPC_Decode, 227, 22, 138, 2, // 7577: decode to XOR_V using decoder 266
7237 // 7577: }
7238 4, 7, // 7582: case 0x4: {
7239 OPC_CheckPredicate, 30, // 7584: check predicate 30
7240 OPC_Decode, 151, 8, 142, 2, // 7586: decode to BMNZ_V using decoder 270
7241 // 7586: }
7242 5, 7, // 7591: case 0x5: {
7243 OPC_CheckPredicate, 30, // 7593: check predicate 30
7244 OPC_Decode, 153, 8, 142, 2, // 7595: decode to BMZ_V using decoder 270
7245 // 7595: }
7246 6, 7, // 7600: case 0x6: {
7247 OPC_CheckPredicate, 30, // 7602: check predicate 30
7248 OPC_Decode, 195, 8, 142, 2, // 7604: decode to BSEL_V using decoder 270
7249 // 7604: }
7250 24, 147, 1, // 7609: case 0x18: {
7251 OPC_SwitchField, 16, 5, // 7612: switch Inst[20:16] {
7252 0, 7, // 7615: case 0x0: {
7253 OPC_CheckPredicate, 30, // 7617: check predicate 30
7254 OPC_Decode, 151, 13, 182, 2, // 7619: decode to FILL_B using decoder 310
7255 // 7619: }
7256 1, 7, // 7624: case 0x1: {
7257 OPC_CheckPredicate, 30, // 7626: check predicate 30
7258 OPC_Decode, 153, 13, 183, 2, // 7628: decode to FILL_H using decoder 311
7259 // 7628: }
7260 2, 7, // 7633: case 0x2: {
7261 OPC_CheckPredicate, 30, // 7635: check predicate 30
7262 OPC_Decode, 154, 13, 184, 2, // 7637: decode to FILL_W using decoder 312
7263 // 7637: }
7264 3, 7, // 7642: case 0x3: {
7265 OPC_CheckPredicate, 38, // 7644: check predicate 38
7266 OPC_Decode, 152, 13, 185, 2, // 7646: decode to FILL_D using decoder 313
7267 // 7646: }
7268 4, 7, // 7651: case 0x4: {
7269 OPC_CheckPredicate, 30, // 7653: check predicate 30
7270 OPC_Decode, 191, 18, 174, 2, // 7655: decode to PCNT_B using decoder 302
7271 // 7655: }
7272 5, 7, // 7660: case 0x5: {
7273 OPC_CheckPredicate, 30, // 7662: check predicate 30
7274 OPC_Decode, 193, 18, 186, 2, // 7664: decode to PCNT_H using decoder 314
7275 // 7664: }
7276 6, 7, // 7669: case 0x6: {
7277 OPC_CheckPredicate, 30, // 7671: check predicate 30
7278 OPC_Decode, 194, 18, 187, 2, // 7673: decode to PCNT_W using decoder 315
7279 // 7673: }
7280 7, 7, // 7678: case 0x7: {
7281 OPC_CheckPredicate, 30, // 7680: check predicate 30
7282 OPC_Decode, 192, 18, 188, 2, // 7682: decode to PCNT_D using decoder 316
7283 // 7682: }
7284 8, 7, // 7687: case 0x8: {
7285 OPC_CheckPredicate, 30, // 7689: check predicate 30
7286 OPC_Decode, 137, 18, 174, 2, // 7691: decode to NLOC_B using decoder 302
7287 // 7691: }
7288 9, 7, // 7696: case 0x9: {
7289 OPC_CheckPredicate, 30, // 7698: check predicate 30
7290 OPC_Decode, 139, 18, 186, 2, // 7700: decode to NLOC_H using decoder 314
7291 // 7700: }
7292 10, 7, // 7705: case 0xa: {
7293 OPC_CheckPredicate, 30, // 7707: check predicate 30
7294 OPC_Decode, 140, 18, 187, 2, // 7709: decode to NLOC_W using decoder 315
7295 // 7709: }
7296 11, 7, // 7714: case 0xb: {
7297 OPC_CheckPredicate, 30, // 7716: check predicate 30
7298 OPC_Decode, 138, 18, 188, 2, // 7718: decode to NLOC_D using decoder 316
7299 // 7718: }
7300 12, 7, // 7723: case 0xc: {
7301 OPC_CheckPredicate, 30, // 7725: check predicate 30
7302 OPC_Decode, 141, 18, 174, 2, // 7727: decode to NLZC_B using decoder 302
7303 // 7727: }
7304 13, 7, // 7732: case 0xd: {
7305 OPC_CheckPredicate, 30, // 7734: check predicate 30
7306 OPC_Decode, 143, 18, 186, 2, // 7736: decode to NLZC_H using decoder 314
7307 // 7736: }
7308 14, 7, // 7741: case 0xe: {
7309 OPC_CheckPredicate, 30, // 7743: check predicate 30
7310 OPC_Decode, 144, 18, 187, 2, // 7745: decode to NLZC_W using decoder 315
7311 // 7745: }
7312 15, 0, // 7750: case 0xf: {
7313 OPC_CheckPredicate, 30, // 7752: check predicate 30
7314 OPC_Decode, 142, 18, 188, 2, // 7754: decode to NLZC_D using decoder 316
7315 // 7754: }
7316 // 7754: } // switch Inst[20:16]
7317 // 7754: }
7318 25, 0, // 7759: case 0x19: {
7319 OPC_SwitchField, 16, 5, // 7761: switch Inst[20:16] {
7320 0, 7, // 7764: case 0x0: {
7321 OPC_CheckPredicate, 30, // 7766: check predicate 30
7322 OPC_Decode, 230, 12, 187, 2, // 7768: decode to FCLASS_W using decoder 315
7323 // 7768: }
7324 1, 7, // 7773: case 0x1: {
7325 OPC_CheckPredicate, 30, // 7775: check predicate 30
7326 OPC_Decode, 229, 12, 188, 2, // 7777: decode to FCLASS_D using decoder 316
7327 // 7777: }
7328 2, 7, // 7782: case 0x2: {
7329 OPC_CheckPredicate, 30, // 7784: check predicate 30
7330 OPC_Decode, 131, 14, 187, 2, // 7786: decode to FTRUNC_S_W using decoder 315
7331 // 7786: }
7332 3, 7, // 7791: case 0x3: {
7333 OPC_CheckPredicate, 30, // 7793: check predicate 30
7334 OPC_Decode, 130, 14, 188, 2, // 7795: decode to FTRUNC_S_D using decoder 316
7335 // 7795: }
7336 4, 7, // 7800: case 0x4: {
7337 OPC_CheckPredicate, 30, // 7802: check predicate 30
7338 OPC_Decode, 133, 14, 187, 2, // 7804: decode to FTRUNC_U_W using decoder 315
7339 // 7804: }
7340 5, 7, // 7809: case 0x5: {
7341 OPC_CheckPredicate, 30, // 7811: check predicate 30
7342 OPC_Decode, 132, 14, 188, 2, // 7813: decode to FTRUNC_U_D using decoder 316
7343 // 7813: }
7344 6, 7, // 7818: case 0x6: {
7345 OPC_CheckPredicate, 30, // 7820: check predicate 30
7346 OPC_Decode, 231, 13, 187, 2, // 7822: decode to FSQRT_W using decoder 315
7347 // 7822: }
7348 7, 7, // 7827: case 0x7: {
7349 OPC_CheckPredicate, 30, // 7829: check predicate 30
7350 OPC_Decode, 224, 13, 188, 2, // 7831: decode to FSQRT_D using decoder 316
7351 // 7831: }
7352 8, 7, // 7836: case 0x8: {
7353 OPC_CheckPredicate, 30, // 7838: check predicate 30
7354 OPC_Decode, 211, 13, 187, 2, // 7840: decode to FRSQRT_W using decoder 315
7355 // 7840: }
7356 9, 7, // 7845: case 0x9: {
7357 OPC_CheckPredicate, 30, // 7847: check predicate 30
7358 OPC_Decode, 210, 13, 188, 2, // 7849: decode to FRSQRT_D using decoder 316
7359 // 7849: }
7360 10, 7, // 7854: case 0xa: {
7361 OPC_CheckPredicate, 30, // 7856: check predicate 30
7362 OPC_Decode, 207, 13, 187, 2, // 7858: decode to FRCP_W using decoder 315
7363 // 7858: }
7364 11, 7, // 7863: case 0xb: {
7365 OPC_CheckPredicate, 30, // 7865: check predicate 30
7366 OPC_Decode, 206, 13, 188, 2, // 7867: decode to FRCP_D using decoder 316
7367 // 7867: }
7368 12, 7, // 7872: case 0xc: {
7369 OPC_CheckPredicate, 30, // 7874: check predicate 30
7370 OPC_Decode, 209, 13, 187, 2, // 7876: decode to FRINT_W using decoder 315
7371 // 7876: }
7372 13, 7, // 7881: case 0xd: {
7373 OPC_CheckPredicate, 30, // 7883: check predicate 30
7374 OPC_Decode, 208, 13, 188, 2, // 7885: decode to FRINT_D using decoder 316
7375 // 7885: }
7376 14, 7, // 7890: case 0xe: {
7377 OPC_CheckPredicate, 30, // 7892: check predicate 30
7378 OPC_Decode, 156, 13, 187, 2, // 7894: decode to FLOG2_W using decoder 315
7379 // 7894: }
7380 15, 7, // 7899: case 0xf: {
7381 OPC_CheckPredicate, 30, // 7901: check predicate 30
7382 OPC_Decode, 155, 13, 188, 2, // 7903: decode to FLOG2_D using decoder 316
7383 // 7903: }
7384 16, 7, // 7908: case 0x10: {
7385 OPC_CheckPredicate, 30, // 7910: check predicate 30
7386 OPC_Decode, 140, 13, 189, 2, // 7912: decode to FEXUPL_W using decoder 317
7387 // 7912: }
7388 17, 7, // 7917: case 0x11: {
7389 OPC_CheckPredicate, 30, // 7919: check predicate 30
7390 OPC_Decode, 139, 13, 190, 2, // 7921: decode to FEXUPL_D using decoder 318
7391 // 7921: }
7392 18, 7, // 7926: case 0x12: {
7393 OPC_CheckPredicate, 30, // 7928: check predicate 30
7394 OPC_Decode, 142, 13, 189, 2, // 7930: decode to FEXUPR_W using decoder 317
7395 // 7930: }
7396 19, 7, // 7935: case 0x13: {
7397 OPC_CheckPredicate, 30, // 7937: check predicate 30
7398 OPC_Decode, 141, 13, 190, 2, // 7939: decode to FEXUPR_D using decoder 318
7399 // 7939: }
7400 20, 7, // 7944: case 0x14: {
7401 OPC_CheckPredicate, 30, // 7946: check predicate 30
7402 OPC_Decode, 148, 13, 189, 2, // 7948: decode to FFQL_W using decoder 317
7403 // 7948: }
7404 21, 7, // 7953: case 0x15: {
7405 OPC_CheckPredicate, 30, // 7955: check predicate 30
7406 OPC_Decode, 147, 13, 190, 2, // 7957: decode to FFQL_D using decoder 318
7407 // 7957: }
7408 22, 7, // 7962: case 0x16: {
7409 OPC_CheckPredicate, 30, // 7964: check predicate 30
7410 OPC_Decode, 150, 13, 189, 2, // 7966: decode to FFQR_W using decoder 317
7411 // 7966: }
7412 23, 7, // 7971: case 0x17: {
7413 OPC_CheckPredicate, 30, // 7973: check predicate 30
7414 OPC_Decode, 149, 13, 190, 2, // 7975: decode to FFQR_D using decoder 318
7415 // 7975: }
7416 24, 7, // 7980: case 0x18: {
7417 OPC_CheckPredicate, 30, // 7982: check predicate 30
7418 OPC_Decode, 253, 13, 187, 2, // 7984: decode to FTINT_S_W using decoder 315
7419 // 7984: }
7420 25, 7, // 7989: case 0x19: {
7421 OPC_CheckPredicate, 30, // 7991: check predicate 30
7422 OPC_Decode, 252, 13, 188, 2, // 7993: decode to FTINT_S_D using decoder 316
7423 // 7993: }
7424 26, 7, // 7998: case 0x1a: {
7425 OPC_CheckPredicate, 30, // 8000: check predicate 30
7426 OPC_Decode, 255, 13, 187, 2, // 8002: decode to FTINT_U_W using decoder 315
7427 // 8002: }
7428 27, 7, // 8007: case 0x1b: {
7429 OPC_CheckPredicate, 30, // 8009: check predicate 30
7430 OPC_Decode, 254, 13, 188, 2, // 8011: decode to FTINT_U_D using decoder 316
7431 // 8011: }
7432 28, 7, // 8016: case 0x1c: {
7433 OPC_CheckPredicate, 30, // 8018: check predicate 30
7434 OPC_Decode, 144, 13, 187, 2, // 8020: decode to FFINT_S_W using decoder 315
7435 // 8020: }
7436 29, 7, // 8025: case 0x1d: {
7437 OPC_CheckPredicate, 30, // 8027: check predicate 30
7438 OPC_Decode, 143, 13, 188, 2, // 8029: decode to FFINT_S_D using decoder 316
7439 // 8029: }
7440 30, 7, // 8034: case 0x1e: {
7441 OPC_CheckPredicate, 30, // 8036: check predicate 30
7442 OPC_Decode, 146, 13, 187, 2, // 8038: decode to FFINT_U_W using decoder 315
7443 // 8038: }
7444 31, 0, // 8043: case 0x1f: {
7445 OPC_CheckPredicate, 30, // 8045: check predicate 30
7446 OPC_Decode, 145, 13, 188, 2, // 8047: decode to FFINT_U_D using decoder 316
7447 // 8047: }
7448 // 8047: } // switch Inst[20:16]
7449 // 8047: }
7450 // 8047: } // switch Inst[25:21]
7451 // 8047: }
7452 32, 7, // 8052: case 0x20: {
7453 OPC_CheckPredicate, 30, // 8054: check predicate 30
7454 OPC_Decode, 129, 15, 191, 2, // 8056: decode to LD_B using decoder 319
7455 // 8056: }
7456 33, 7, // 8061: case 0x21: {
7457 OPC_CheckPredicate, 30, // 8063: check predicate 30
7458 OPC_Decode, 131, 15, 191, 2, // 8065: decode to LD_H using decoder 319
7459 // 8065: }
7460 34, 7, // 8070: case 0x22: {
7461 OPC_CheckPredicate, 30, // 8072: check predicate 30
7462 OPC_Decode, 132, 15, 191, 2, // 8074: decode to LD_W using decoder 319
7463 // 8074: }
7464 35, 7, // 8079: case 0x23: {
7465 OPC_CheckPredicate, 30, // 8081: check predicate 30
7466 OPC_Decode, 130, 15, 191, 2, // 8083: decode to LD_D using decoder 319
7467 // 8083: }
7468 36, 7, // 8088: case 0x24: {
7469 OPC_CheckPredicate, 30, // 8090: check predicate 30
7470 OPC_Decode, 142, 21, 191, 2, // 8092: decode to ST_B using decoder 319
7471 // 8092: }
7472 37, 7, // 8097: case 0x25: {
7473 OPC_CheckPredicate, 30, // 8099: check predicate 30
7474 OPC_Decode, 144, 21, 191, 2, // 8101: decode to ST_H using decoder 319
7475 // 8101: }
7476 38, 7, // 8106: case 0x26: {
7477 OPC_CheckPredicate, 30, // 8108: check predicate 30
7478 OPC_Decode, 145, 21, 191, 2, // 8110: decode to ST_W using decoder 319
7479 // 8110: }
7480 39, 0, // 8115: case 0x27: {
7481 OPC_CheckPredicate, 30, // 8117: check predicate 30
7482 OPC_Decode, 143, 21, 191, 2, // 8119: decode to ST_D using decoder 319
7483 // 8119: }
7484 // 8119: } // switch Inst[5:0]
7485 // 8119: }
7486 31, 135, 15, // 8124: case 0x1f: {
7487 OPC_SwitchField, 0, 6, // 8127: switch Inst[5:0] {
7488 0, 7, // 8130: case 0x0: {
7489 OPC_CheckPredicate, 28, // 8132: check predicate 28
7490 OPC_Decode, 180, 12, 192, 2, // 8134: decode to EXT using decoder 320
7491 // 8134: }
7492 4, 7, // 8139: case 0x4: {
7493 OPC_CheckPredicate, 28, // 8141: check predicate 28
7494 OPC_Decode, 168, 14, 193, 2, // 8143: decode to INS using decoder 321
7495 // 8143: }
7496 8, 11, // 8148: case 0x8: {
7497 OPC_CheckPredicate, 42, // 8150: check predicate 42
7498 OPC_CheckField, 6, 5, 0, // 8152: check Inst[10:6] == 0x0
7499 OPC_Decode, 205, 13, 194, 2, // 8156: decode to FORK using decoder 322
7500 // 8156: }
7501 9, 14, // 8161: case 0x9: {
7502 OPC_CheckPredicate, 42, // 8163: check predicate 42
7503 OPC_CheckField, 16, 5, 0, // 8165: check Inst[20:16] == 0x0
7504 OPC_CheckField, 6, 5, 0, // 8169: check Inst[10:6] == 0x0
7505 OPC_Decode, 232, 22, 52, // 8173: decode to YIELD using decoder 52
7506 // 8173: }
7507 10, 30, // 8177: case 0xa: {
7508 OPC_SwitchField, 6, 5, // 8179: switch Inst[10:6] {
7509 0, 7, // 8182: case 0x0: {
7510 OPC_CheckPredicate, 37, // 8184: check predicate 37
7511 OPC_Decode, 204, 15, 195, 2, // 8186: decode to LWX using decoder 323
7512 // 8186: }
7513 4, 7, // 8191: case 0x4: {
7514 OPC_CheckPredicate, 37, // 8193: check predicate 37
7515 OPC_Decode, 141, 15, 195, 2, // 8195: decode to LHX using decoder 323
7516 // 8195: }
7517 6, 0, // 8200: case 0x6: {
7518 OPC_CheckPredicate, 37, // 8202: check predicate 37
7519 OPC_Decode, 228, 14, 195, 2, // 8204: decode to LBUX using decoder 323
7520 // 8204: }
7521 // 8204: } // switch Inst[10:6]
7522 // 8204: }
7523 12, 11, // 8209: case 0xc: {
7524 OPC_CheckPredicate, 37, // 8211: check predicate 37
7525 OPC_CheckField, 6, 10, 0, // 8213: check Inst[15:6] == 0x0
7526 OPC_Decode, 173, 14, 196, 2, // 8217: decode to INSV using decoder 324
7527 // 8217: }
7528 16, 218, 1, // 8222: case 0x10: {
7529 OPC_SwitchField, 6, 5, // 8225: switch Inst[10:6] {
7530 0, 7, // 8228: case 0x0: {
7531 OPC_CheckPredicate, 37, // 8230: check predicate 37
7532 OPC_Decode, 194, 6, 197, 2, // 8232: decode to ADDU_QB using decoder 325
7533 // 8232: }
7534 1, 7, // 8237: case 0x1: {
7535 OPC_CheckPredicate, 37, // 8239: check predicate 37
7536 OPC_Decode, 186, 21, 197, 2, // 8241: decode to SUBU_QB using decoder 325
7537 // 8241: }
7538 4, 7, // 8246: case 0x4: {
7539 OPC_CheckPredicate, 37, // 8248: check predicate 37
7540 OPC_Decode, 198, 6, 197, 2, // 8250: decode to ADDU_S_QB using decoder 325
7541 // 8250: }
7542 5, 7, // 8255: case 0x5: {
7543 OPC_CheckPredicate, 37, // 8257: check predicate 37
7544 OPC_Decode, 190, 21, 197, 2, // 8259: decode to SUBU_S_QB using decoder 325
7545 // 8259: }
7546 6, 7, // 8264: case 0x6: {
7547 OPC_CheckPredicate, 37, // 8266: check predicate 37
7548 OPC_Decode, 218, 17, 197, 2, // 8268: decode to MULEU_S_PH_QBL using decoder 325
7549 // 8268: }
7550 7, 7, // 8273: case 0x7: {
7551 OPC_CheckPredicate, 37, // 8275: check predicate 37
7552 OPC_Decode, 220, 17, 197, 2, // 8277: decode to MULEU_S_PH_QBR using decoder 325
7553 // 8277: }
7554 8, 7, // 8282: case 0x8: {
7555 OPC_CheckPredicate, 69, // 8284: check predicate 69
7556 OPC_Decode, 192, 6, 197, 2, // 8286: decode to ADDU_PH using decoder 325
7557 // 8286: }
7558 9, 7, // 8291: case 0x9: {
7559 OPC_CheckPredicate, 69, // 8293: check predicate 69
7560 OPC_Decode, 184, 21, 197, 2, // 8295: decode to SUBU_PH using decoder 325
7561 // 8295: }
7562 10, 7, // 8300: case 0xa: {
7563 OPC_CheckPredicate, 37, // 8302: check predicate 37
7564 OPC_Decode, 164, 6, 197, 2, // 8304: decode to ADDQ_PH using decoder 325
7565 // 8304: }
7566 11, 7, // 8309: case 0xb: {
7567 OPC_CheckPredicate, 37, // 8311: check predicate 37
7568 OPC_Decode, 155, 21, 197, 2, // 8313: decode to SUBQ_PH using decoder 325
7569 // 8313: }
7570 12, 7, // 8318: case 0xc: {
7571 OPC_CheckPredicate, 69, // 8320: check predicate 69
7572 OPC_Decode, 196, 6, 197, 2, // 8322: decode to ADDU_S_PH using decoder 325
7573 // 8322: }
7574 13, 7, // 8327: case 0xd: {
7575 OPC_CheckPredicate, 69, // 8329: check predicate 69
7576 OPC_Decode, 188, 21, 197, 2, // 8331: decode to SUBU_S_PH using decoder 325
7577 // 8331: }
7578 14, 7, // 8336: case 0xe: {
7579 OPC_CheckPredicate, 37, // 8338: check predicate 37
7580 OPC_Decode, 166, 6, 197, 2, // 8340: decode to ADDQ_S_PH using decoder 325
7581 // 8340: }
7582 15, 7, // 8345: case 0xf: {
7583 OPC_CheckPredicate, 37, // 8347: check predicate 37
7584 OPC_Decode, 157, 21, 197, 2, // 8349: decode to SUBQ_S_PH using decoder 325
7585 // 8349: }
7586 16, 6, // 8354: case 0x10: {
7587 OPC_CheckPredicate, 37, // 8356: check predicate 37
7588 OPC_Decode, 171, 6, 67, // 8358: decode to ADDSC using decoder 67
7589 // 8358: }
7590 17, 6, // 8362: case 0x11: {
7591 OPC_CheckPredicate, 37, // 8364: check predicate 37
7592 OPC_Decode, 208, 6, 67, // 8366: decode to ADDWC using decoder 67
7593 // 8366: }
7594 18, 6, // 8370: case 0x12: {
7595 OPC_CheckPredicate, 37, // 8372: check predicate 37
7596 OPC_Decode, 216, 16, 67, // 8374: decode to MODSUB using decoder 67
7597 // 8374: }
7598 20, 11, // 8378: case 0x14: {
7599 OPC_CheckPredicate, 37, // 8380: check predicate 37
7600 OPC_CheckField, 16, 5, 0, // 8382: check Inst[20:16] == 0x0
7601 OPC_Decode, 247, 18, 198, 2, // 8386: decode to RADDU_W_QB using decoder 326
7602 // 8386: }
7603 22, 6, // 8391: case 0x16: {
7604 OPC_CheckPredicate, 37, // 8393: check predicate 37
7605 OPC_Decode, 168, 6, 67, // 8395: decode to ADDQ_S_W using decoder 67
7606 // 8395: }
7607 23, 6, // 8399: case 0x17: {
7608 OPC_CheckPredicate, 37, // 8401: check predicate 37
7609 OPC_Decode, 159, 21, 67, // 8403: decode to SUBQ_S_W using decoder 67
7610 // 8403: }
7611 28, 7, // 8407: case 0x1c: {
7612 OPC_CheckPredicate, 37, // 8409: check predicate 37
7613 OPC_Decode, 214, 17, 199, 2, // 8411: decode to MULEQ_S_W_PHL using decoder 327
7614 // 8411: }
7615 29, 7, // 8416: case 0x1d: {
7616 OPC_CheckPredicate, 37, // 8418: check predicate 37
7617 OPC_Decode, 216, 17, 199, 2, // 8420: decode to MULEQ_S_W_PHR using decoder 327
7618 // 8420: }
7619 30, 7, // 8425: case 0x1e: {
7620 OPC_CheckPredicate, 69, // 8427: check predicate 69
7621 OPC_Decode, 226, 17, 197, 2, // 8429: decode to MULQ_S_PH using decoder 325
7622 // 8429: }
7623 31, 0, // 8434: case 0x1f: {
7624 OPC_CheckPredicate, 37, // 8436: check predicate 37
7625 OPC_Decode, 222, 17, 197, 2, // 8438: decode to MULQ_RS_PH using decoder 325
7626 // 8438: }
7627 // 8438: } // switch Inst[10:6]
7628 // 8438: }
7629 17, 219, 1, // 8443: case 0x11: {
7630 OPC_SwitchField, 6, 5, // 8446: switch Inst[10:6] {
7631 0, 10, // 8449: case 0x0: {
7632 OPC_CheckPredicate, 37, // 8451: check predicate 37
7633 OPC_CheckField, 11, 5, 0, // 8453: check Inst[15:11] == 0x0
7634 OPC_Decode, 181, 9, 85, // 8457: decode to CMPU_EQ_QB using decoder 85
7635 // 8457: }
7636 1, 10, // 8461: case 0x1: {
7637 OPC_CheckPredicate, 37, // 8463: check predicate 37
7638 OPC_CheckField, 11, 5, 0, // 8465: check Inst[15:11] == 0x0
7639 OPC_Decode, 185, 9, 85, // 8469: decode to CMPU_LT_QB using decoder 85
7640 // 8469: }
7641 2, 10, // 8473: case 0x2: {
7642 OPC_CheckPredicate, 37, // 8475: check predicate 37
7643 OPC_CheckField, 11, 5, 0, // 8477: check Inst[15:11] == 0x0
7644 OPC_Decode, 183, 9, 85, // 8481: decode to CMPU_LE_QB using decoder 85
7645 // 8481: }
7646 3, 7, // 8485: case 0x3: {
7647 OPC_CheckPredicate, 37, // 8487: check predicate 37
7648 OPC_Decode, 197, 18, 197, 2, // 8489: decode to PICK_QB using decoder 325
7649 // 8489: }
7650 4, 7, // 8494: case 0x4: {
7651 OPC_CheckPredicate, 37, // 8496: check predicate 37
7652 OPC_Decode, 175, 9, 199, 2, // 8498: decode to CMPGU_EQ_QB using decoder 327
7653 // 8498: }
7654 5, 7, // 8503: case 0x5: {
7655 OPC_CheckPredicate, 37, // 8505: check predicate 37
7656 OPC_Decode, 179, 9, 199, 2, // 8507: decode to CMPGU_LT_QB using decoder 327
7657 // 8507: }
7658 6, 7, // 8512: case 0x6: {
7659 OPC_CheckPredicate, 37, // 8514: check predicate 37
7660 OPC_Decode, 177, 9, 199, 2, // 8516: decode to CMPGU_LE_QB using decoder 327
7661 // 8516: }
7662 8, 10, // 8521: case 0x8: {
7663 OPC_CheckPredicate, 37, // 8523: check predicate 37
7664 OPC_CheckField, 11, 5, 0, // 8525: check Inst[15:11] == 0x0
7665 OPC_Decode, 191, 9, 85, // 8529: decode to CMP_EQ_PH using decoder 85
7666 // 8529: }
7667 9, 10, // 8533: case 0x9: {
7668 OPC_CheckPredicate, 37, // 8535: check predicate 37
7669 OPC_CheckField, 11, 5, 0, // 8537: check Inst[15:11] == 0x0
7670 OPC_Decode, 205, 9, 85, // 8541: decode to CMP_LT_PH using decoder 85
7671 // 8541: }
7672 10, 10, // 8545: case 0xa: {
7673 OPC_CheckPredicate, 37, // 8547: check predicate 37
7674 OPC_CheckField, 11, 5, 0, // 8549: check Inst[15:11] == 0x0
7675 OPC_Decode, 199, 9, 85, // 8553: decode to CMP_LE_PH using decoder 85
7676 // 8553: }
7677 11, 7, // 8557: case 0xb: {
7678 OPC_CheckPredicate, 37, // 8559: check predicate 37
7679 OPC_Decode, 195, 18, 197, 2, // 8561: decode to PICK_PH using decoder 325
7680 // 8561: }
7681 12, 7, // 8566: case 0xc: {
7682 OPC_CheckPredicate, 37, // 8568: check predicate 37
7683 OPC_Decode, 226, 18, 197, 2, // 8570: decode to PRECRQ_QB_PH using decoder 325
7684 // 8570: }
7685 13, 7, // 8575: case 0xd: {
7686 OPC_CheckPredicate, 69, // 8577: check predicate 69
7687 OPC_Decode, 230, 18, 197, 2, // 8579: decode to PRECR_QB_PH using decoder 325
7688 // 8579: }
7689 14, 7, // 8584: case 0xe: {
7690 OPC_CheckPredicate, 37, // 8586: check predicate 37
7691 OPC_Decode, 178, 18, 197, 2, // 8588: decode to PACKRL_PH using decoder 325
7692 // 8588: }
7693 15, 7, // 8593: case 0xf: {
7694 OPC_CheckPredicate, 37, // 8595: check predicate 37
7695 OPC_Decode, 222, 18, 197, 2, // 8597: decode to PRECRQU_S_QB_PH using decoder 325
7696 // 8597: }
7697 20, 7, // 8602: case 0x14: {
7698 OPC_CheckPredicate, 37, // 8604: check predicate 37
7699 OPC_Decode, 224, 18, 200, 2, // 8606: decode to PRECRQ_PH_W using decoder 328
7700 // 8606: }
7701 21, 7, // 8611: case 0x15: {
7702 OPC_CheckPredicate, 37, // 8613: check predicate 37
7703 OPC_Decode, 228, 18, 200, 2, // 8615: decode to PRECRQ_RS_PH_W using decoder 328
7704 // 8615: }
7705 24, 7, // 8620: case 0x18: {
7706 OPC_CheckPredicate, 69, // 8622: check predicate 69
7707 OPC_Decode, 169, 9, 199, 2, // 8624: decode to CMPGDU_EQ_QB using decoder 327
7708 // 8624: }
7709 25, 7, // 8629: case 0x19: {
7710 OPC_CheckPredicate, 69, // 8631: check predicate 69
7711 OPC_Decode, 173, 9, 199, 2, // 8633: decode to CMPGDU_LT_QB using decoder 327
7712 // 8633: }
7713 26, 7, // 8638: case 0x1a: {
7714 OPC_CheckPredicate, 69, // 8640: check predicate 69
7715 OPC_Decode, 171, 9, 199, 2, // 8642: decode to CMPGDU_LE_QB using decoder 327
7716 // 8642: }
7717 30, 7, // 8647: case 0x1e: {
7718 OPC_CheckPredicate, 69, // 8649: check predicate 69
7719 OPC_Decode, 232, 18, 201, 2, // 8651: decode to PRECR_SRA_PH_W using decoder 329
7720 // 8651: }
7721 31, 0, // 8656: case 0x1f: {
7722 OPC_CheckPredicate, 69, // 8658: check predicate 69
7723 OPC_Decode, 234, 18, 201, 2, // 8660: decode to PRECR_SRA_R_PH_W using decoder 329
7724 // 8660: }
7725 // 8660: } // switch Inst[10:6]
7726 // 8660: }
7727 18, 228, 1, // 8665: case 0x12: {
7728 OPC_SwitchField, 6, 5, // 8668: switch Inst[10:6] {
7729 1, 11, // 8671: case 0x1: {
7730 OPC_CheckPredicate, 69, // 8673: check predicate 69
7731 OPC_CheckField, 21, 5, 0, // 8675: check Inst[25:21] == 0x0
7732 OPC_Decode, 143, 6, 202, 2, // 8679: decode to ABSQ_S_QB using decoder 330
7733 // 8679: }
7734 2, 7, // 8684: case 0x2: {
7735 OPC_CheckPredicate, 37, // 8686: check predicate 37
7736 OPC_Decode, 140, 19, 203, 2, // 8688: decode to REPL_QB using decoder 331
7737 // 8688: }
7738 3, 11, // 8693: case 0x3: {
7739 OPC_CheckPredicate, 37, // 8695: check predicate 37
7740 OPC_CheckField, 21, 5, 0, // 8697: check Inst[25:21] == 0x0
7741 OPC_Decode, 136, 19, 204, 2, // 8701: decode to REPLV_QB using decoder 332
7742 // 8701: }
7743 4, 11, // 8706: case 0x4: {
7744 OPC_CheckPredicate, 37, // 8708: check predicate 37
7745 OPC_CheckField, 21, 5, 0, // 8710: check Inst[25:21] == 0x0
7746 OPC_Decode, 202, 18, 202, 2, // 8714: decode to PRECEQU_PH_QBL using decoder 330
7747 // 8714: }
7748 5, 11, // 8719: case 0x5: {
7749 OPC_CheckPredicate, 37, // 8721: check predicate 37
7750 OPC_CheckField, 21, 5, 0, // 8723: check Inst[25:21] == 0x0
7751 OPC_Decode, 206, 18, 202, 2, // 8727: decode to PRECEQU_PH_QBR using decoder 330
7752 // 8727: }
7753 6, 11, // 8732: case 0x6: {
7754 OPC_CheckPredicate, 37, // 8734: check predicate 37
7755 OPC_CheckField, 21, 5, 0, // 8736: check Inst[25:21] == 0x0
7756 OPC_Decode, 203, 18, 202, 2, // 8740: decode to PRECEQU_PH_QBLA using decoder 330
7757 // 8740: }
7758 7, 11, // 8745: case 0x7: {
7759 OPC_CheckPredicate, 37, // 8747: check predicate 37
7760 OPC_CheckField, 21, 5, 0, // 8749: check Inst[25:21] == 0x0
7761 OPC_Decode, 207, 18, 202, 2, // 8753: decode to PRECEQU_PH_QBRA using decoder 330
7762 // 8753: }
7763 9, 11, // 8758: case 0x9: {
7764 OPC_CheckPredicate, 37, // 8760: check predicate 37
7765 OPC_CheckField, 21, 5, 0, // 8762: check Inst[25:21] == 0x0
7766 OPC_Decode, 141, 6, 202, 2, // 8766: decode to ABSQ_S_PH using decoder 330
7767 // 8766: }
7768 10, 6, // 8771: case 0xa: {
7769 OPC_CheckPredicate, 37, // 8773: check predicate 37
7770 OPC_Decode, 138, 19, 103, // 8775: decode to REPL_PH using decoder 103
7771 // 8775: }
7772 11, 11, // 8779: case 0xb: {
7773 OPC_CheckPredicate, 37, // 8781: check predicate 37
7774 OPC_CheckField, 21, 5, 0, // 8783: check Inst[25:21] == 0x0
7775 OPC_Decode, 134, 19, 204, 2, // 8787: decode to REPLV_PH using decoder 332
7776 // 8787: }
7777 12, 11, // 8792: case 0xc: {
7778 OPC_CheckPredicate, 37, // 8794: check predicate 37
7779 OPC_CheckField, 21, 5, 0, // 8796: check Inst[25:21] == 0x0
7780 OPC_Decode, 210, 18, 205, 2, // 8800: decode to PRECEQ_W_PHL using decoder 333
7781 // 8800: }
7782 13, 11, // 8805: case 0xd: {
7783 OPC_CheckPredicate, 37, // 8807: check predicate 37
7784 OPC_CheckField, 21, 5, 0, // 8809: check Inst[25:21] == 0x0
7785 OPC_Decode, 212, 18, 205, 2, // 8813: decode to PRECEQ_W_PHR using decoder 333
7786 // 8813: }
7787 17, 11, // 8818: case 0x11: {
7788 OPC_CheckPredicate, 37, // 8820: check predicate 37
7789 OPC_CheckField, 21, 5, 0, // 8822: check Inst[25:21] == 0x0
7790 OPC_Decode, 145, 6, 206, 2, // 8826: decode to ABSQ_S_W using decoder 334
7791 // 8826: }
7792 27, 11, // 8831: case 0x1b: {
7793 OPC_CheckPredicate, 37, // 8833: check predicate 37
7794 OPC_CheckField, 21, 5, 0, // 8835: check Inst[25:21] == 0x0
7795 OPC_Decode, 246, 7, 206, 2, // 8839: decode to BITREV using decoder 334
7796 // 8839: }
7797 28, 11, // 8844: case 0x1c: {
7798 OPC_CheckPredicate, 37, // 8846: check predicate 37
7799 OPC_CheckField, 21, 5, 0, // 8848: check Inst[25:21] == 0x0
7800 OPC_Decode, 214, 18, 202, 2, // 8852: decode to PRECEU_PH_QBL using decoder 330
7801 // 8852: }
7802 29, 11, // 8857: case 0x1d: {
7803 OPC_CheckPredicate, 37, // 8859: check predicate 37
7804 OPC_CheckField, 21, 5, 0, // 8861: check Inst[25:21] == 0x0
7805 OPC_Decode, 218, 18, 202, 2, // 8865: decode to PRECEU_PH_QBR using decoder 330
7806 // 8865: }
7807 30, 11, // 8870: case 0x1e: {
7808 OPC_CheckPredicate, 37, // 8872: check predicate 37
7809 OPC_CheckField, 21, 5, 0, // 8874: check Inst[25:21] == 0x0
7810 OPC_Decode, 215, 18, 202, 2, // 8878: decode to PRECEU_PH_QBLA using decoder 330
7811 // 8878: }
7812 31, 0, // 8883: case 0x1f: {
7813 OPC_CheckPredicate, 37, // 8885: check predicate 37
7814 OPC_CheckField, 21, 5, 0, // 8887: check Inst[25:21] == 0x0
7815 OPC_Decode, 219, 18, 202, 2, // 8891: decode to PRECEU_PH_QBRA using decoder 330
7816 // 8891: }
7817 // 8891: } // switch Inst[10:6]
7818 // 8891: }
7819 19, 199, 1, // 8896: case 0x13: {
7820 OPC_SwitchField, 6, 5, // 8899: switch Inst[10:6] {
7821 0, 7, // 8902: case 0x0: {
7822 OPC_CheckPredicate, 37, // 8904: check predicate 37
7823 OPC_Decode, 140, 20, 207, 2, // 8906: decode to SHLL_QB using decoder 335
7824 // 8906: }
7825 1, 7, // 8911: case 0x1: {
7826 OPC_CheckPredicate, 37, // 8913: check predicate 37
7827 OPC_Decode, 172, 20, 207, 2, // 8915: decode to SHRL_QB using decoder 335
7828 // 8915: }
7829 2, 7, // 8920: case 0x2: {
7830 OPC_CheckPredicate, 37, // 8922: check predicate 37
7831 OPC_Decode, 132, 20, 208, 2, // 8924: decode to SHLLV_QB using decoder 336
7832 // 8924: }
7833 3, 7, // 8929: case 0x3: {
7834 OPC_CheckPredicate, 37, // 8931: check predicate 37
7835 OPC_Decode, 168, 20, 208, 2, // 8933: decode to SHRLV_QB using decoder 336
7836 // 8933: }
7837 4, 7, // 8938: case 0x4: {
7838 OPC_CheckPredicate, 69, // 8940: check predicate 69
7839 OPC_Decode, 158, 20, 207, 2, // 8942: decode to SHRA_QB using decoder 335
7840 // 8942: }
7841 5, 7, // 8947: case 0x5: {
7842 OPC_CheckPredicate, 69, // 8949: check predicate 69
7843 OPC_Decode, 162, 20, 207, 2, // 8951: decode to SHRA_R_QB using decoder 335
7844 // 8951: }
7845 6, 7, // 8956: case 0x6: {
7846 OPC_CheckPredicate, 69, // 8958: check predicate 69
7847 OPC_Decode, 148, 20, 208, 2, // 8960: decode to SHRAV_QB using decoder 336
7848 // 8960: }
7849 7, 7, // 8965: case 0x7: {
7850 OPC_CheckPredicate, 69, // 8967: check predicate 69
7851 OPC_Decode, 152, 20, 208, 2, // 8969: decode to SHRAV_R_QB using decoder 336
7852 // 8969: }
7853 8, 7, // 8974: case 0x8: {
7854 OPC_CheckPredicate, 37, // 8976: check predicate 37
7855 OPC_Decode, 138, 20, 207, 2, // 8978: decode to SHLL_PH using decoder 335
7856 // 8978: }
7857 9, 7, // 8983: case 0x9: {
7858 OPC_CheckPredicate, 37, // 8985: check predicate 37
7859 OPC_Decode, 156, 20, 207, 2, // 8987: decode to SHRA_PH using decoder 335
7860 // 8987: }
7861 10, 7, // 8992: case 0xa: {
7862 OPC_CheckPredicate, 37, // 8994: check predicate 37
7863 OPC_Decode, 130, 20, 208, 2, // 8996: decode to SHLLV_PH using decoder 336
7864 // 8996: }
7865 11, 7, // 9001: case 0xb: {
7866 OPC_CheckPredicate, 37, // 9003: check predicate 37
7867 OPC_Decode, 146, 20, 208, 2, // 9005: decode to SHRAV_PH using decoder 336
7868 // 9005: }
7869 12, 7, // 9010: case 0xc: {
7870 OPC_CheckPredicate, 37, // 9012: check predicate 37
7871 OPC_Decode, 142, 20, 207, 2, // 9014: decode to SHLL_S_PH using decoder 335
7872 // 9014: }
7873 13, 7, // 9019: case 0xd: {
7874 OPC_CheckPredicate, 37, // 9021: check predicate 37
7875 OPC_Decode, 160, 20, 207, 2, // 9023: decode to SHRA_R_PH using decoder 335
7876 // 9023: }
7877 14, 7, // 9028: case 0xe: {
7878 OPC_CheckPredicate, 37, // 9030: check predicate 37
7879 OPC_Decode, 134, 20, 208, 2, // 9032: decode to SHLLV_S_PH using decoder 336
7880 // 9032: }
7881 15, 7, // 9037: case 0xf: {
7882 OPC_CheckPredicate, 37, // 9039: check predicate 37
7883 OPC_Decode, 150, 20, 208, 2, // 9041: decode to SHRAV_R_PH using decoder 336
7884 // 9041: }
7885 20, 7, // 9046: case 0x14: {
7886 OPC_CheckPredicate, 37, // 9048: check predicate 37
7887 OPC_Decode, 144, 20, 209, 2, // 9050: decode to SHLL_S_W using decoder 337
7888 // 9050: }
7889 21, 7, // 9055: case 0x15: {
7890 OPC_CheckPredicate, 37, // 9057: check predicate 37
7891 OPC_Decode, 164, 20, 209, 2, // 9059: decode to SHRA_R_W using decoder 337
7892 // 9059: }
7893 22, 6, // 9064: case 0x16: {
7894 OPC_CheckPredicate, 37, // 9066: check predicate 37
7895 OPC_Decode, 136, 20, 61, // 9068: decode to SHLLV_S_W using decoder 61
7896 // 9068: }
7897 23, 6, // 9072: case 0x17: {
7898 OPC_CheckPredicate, 37, // 9074: check predicate 37
7899 OPC_Decode, 154, 20, 61, // 9076: decode to SHRAV_R_W using decoder 61
7900 // 9076: }
7901 25, 7, // 9080: case 0x19: {
7902 OPC_CheckPredicate, 69, // 9082: check predicate 69
7903 OPC_Decode, 170, 20, 207, 2, // 9084: decode to SHRL_PH using decoder 335
7904 // 9084: }
7905 27, 0, // 9089: case 0x1b: {
7906 OPC_CheckPredicate, 69, // 9091: check predicate 69
7907 OPC_Decode, 166, 20, 208, 2, // 9093: decode to SHRLV_PH using decoder 336
7908 // 9093: }
7909 // 9093: } // switch Inst[10:6]
7910 // 9093: }
7911 24, 141, 1, // 9098: case 0x18: {
7912 OPC_SwitchField, 6, 5, // 9101: switch Inst[10:6] {
7913 0, 7, // 9104: case 0x0: {
7914 OPC_CheckPredicate, 69, // 9106: check predicate 69
7915 OPC_Decode, 187, 6, 197, 2, // 9108: decode to ADDUH_QB using decoder 325
7916 // 9108: }
7917 1, 7, // 9113: case 0x1: {
7918 OPC_CheckPredicate, 69, // 9115: check predicate 69
7919 OPC_Decode, 179, 21, 197, 2, // 9117: decode to SUBUH_QB using decoder 325
7920 // 9117: }
7921 2, 7, // 9122: case 0x2: {
7922 OPC_CheckPredicate, 69, // 9124: check predicate 69
7923 OPC_Decode, 189, 6, 197, 2, // 9126: decode to ADDUH_R_QB using decoder 325
7924 // 9126: }
7925 3, 7, // 9131: case 0x3: {
7926 OPC_CheckPredicate, 69, // 9133: check predicate 69
7927 OPC_Decode, 181, 21, 197, 2, // 9135: decode to SUBUH_R_QB using decoder 325
7928 // 9135: }
7929 8, 7, // 9140: case 0x8: {
7930 OPC_CheckPredicate, 69, // 9142: check predicate 69
7931 OPC_Decode, 156, 6, 197, 2, // 9144: decode to ADDQH_PH using decoder 325
7932 // 9144: }
7933 9, 7, // 9149: case 0x9: {
7934 OPC_CheckPredicate, 69, // 9151: check predicate 69
7935 OPC_Decode, 147, 21, 197, 2, // 9153: decode to SUBQH_PH using decoder 325
7936 // 9153: }
7937 10, 7, // 9158: case 0xa: {
7938 OPC_CheckPredicate, 69, // 9160: check predicate 69
7939 OPC_Decode, 158, 6, 197, 2, // 9162: decode to ADDQH_R_PH using decoder 325
7940 // 9162: }
7941 11, 7, // 9167: case 0xb: {
7942 OPC_CheckPredicate, 69, // 9169: check predicate 69
7943 OPC_Decode, 149, 21, 197, 2, // 9171: decode to SUBQH_R_PH using decoder 325
7944 // 9171: }
7945 12, 7, // 9176: case 0xc: {
7946 OPC_CheckPredicate, 69, // 9178: check predicate 69
7947 OPC_Decode, 253, 17, 197, 2, // 9180: decode to MUL_PH using decoder 325
7948 // 9180: }
7949 14, 7, // 9185: case 0xe: {
7950 OPC_CheckPredicate, 69, // 9187: check predicate 69
7951 OPC_Decode, 130, 18, 197, 2, // 9189: decode to MUL_S_PH using decoder 325
7952 // 9189: }
7953 16, 6, // 9194: case 0x10: {
7954 OPC_CheckPredicate, 69, // 9196: check predicate 69
7955 OPC_Decode, 162, 6, 67, // 9198: decode to ADDQH_W using decoder 67
7956 // 9198: }
7957 17, 6, // 9202: case 0x11: {
7958 OPC_CheckPredicate, 69, // 9204: check predicate 69
7959 OPC_Decode, 153, 21, 67, // 9206: decode to SUBQH_W using decoder 67
7960 // 9206: }
7961 18, 6, // 9210: case 0x12: {
7962 OPC_CheckPredicate, 69, // 9212: check predicate 69
7963 OPC_Decode, 160, 6, 67, // 9214: decode to ADDQH_R_W using decoder 67
7964 // 9214: }
7965 19, 6, // 9218: case 0x13: {
7966 OPC_CheckPredicate, 69, // 9220: check predicate 69
7967 OPC_Decode, 151, 21, 67, // 9222: decode to SUBQH_R_W using decoder 67
7968 // 9222: }
7969 22, 6, // 9226: case 0x16: {
7970 OPC_CheckPredicate, 69, // 9228: check predicate 69
7971 OPC_Decode, 228, 17, 67, // 9230: decode to MULQ_S_W using decoder 67
7972 // 9230: }
7973 23, 0, // 9234: case 0x17: {
7974 OPC_CheckPredicate, 69, // 9236: check predicate 69
7975 OPC_Decode, 224, 17, 67, // 9238: decode to MULQ_RS_W using decoder 67
7976 // 9238: }
7977 // 9238: } // switch Inst[10:6]
7978 // 9238: }
7979 25, 11, // 9242: case 0x19: {
7980 OPC_CheckPredicate, 70, // 9244: check predicate 70
7981 OPC_CheckField, 6, 1, 0, // 9246: check Inst[6] == 0x0
7982 OPC_Decode, 187, 15, 210, 2, // 9250: decode to LWLE using decoder 338
7983 // 9250: }
7984 26, 11, // 9255: case 0x1a: {
7985 OPC_CheckPredicate, 70, // 9257: check predicate 70
7986 OPC_CheckField, 6, 1, 0, // 9259: check Inst[6] == 0x0
7987 OPC_Decode, 198, 15, 210, 2, // 9263: decode to LWRE using decoder 338
7988 // 9263: }
7989 27, 11, // 9268: case 0x1b: {
7990 OPC_CheckPredicate, 44, // 9270: check predicate 44
7991 OPC_CheckField, 6, 1, 0, // 9272: check Inst[6] == 0x0
7992 OPC_Decode, 221, 8, 211, 2, // 9276: decode to CACHEE using decoder 339
7993 // 9276: }
7994 28, 11, // 9281: case 0x1c: {
7995 OPC_CheckPredicate, 44, // 9283: check predicate 44
7996 OPC_CheckField, 6, 1, 0, // 9285: check Inst[6] == 0x0
7997 OPC_Decode, 183, 19, 210, 2, // 9289: decode to SBE using decoder 338
7998 // 9289: }
7999 29, 11, // 9294: case 0x1d: {
8000 OPC_CheckPredicate, 44, // 9296: check predicate 44
8001 OPC_CheckField, 6, 1, 0, // 9298: check Inst[6] == 0x0
8002 OPC_Decode, 249, 19, 210, 2, // 9302: decode to SHE using decoder 338
8003 // 9302: }
8004 30, 11, // 9307: case 0x1e: {
8005 OPC_CheckPredicate, 44, // 9309: check predicate 44
8006 OPC_CheckField, 6, 1, 0, // 9311: check Inst[6] == 0x0
8007 OPC_Decode, 192, 19, 210, 2, // 9315: decode to SCE using decoder 338
8008 // 9315: }
8009 31, 11, // 9320: case 0x1f: {
8010 OPC_CheckPredicate, 44, // 9322: check predicate 44
8011 OPC_CheckField, 6, 1, 0, // 9324: check Inst[6] == 0x0
8012 OPC_Decode, 219, 21, 210, 2, // 9328: decode to SWE using decoder 338
8013 // 9328: }
8014 32, 42, // 9333: case 0x20: {
8015 OPC_SwitchField, 6, 5, // 9335: switch Inst[10:6] {
8016 2, 11, // 9338: case 0x2: {
8017 OPC_CheckPredicate, 28, // 9340: check predicate 28
8018 OPC_CheckField, 21, 5, 0, // 9342: check Inst[25:21] == 0x0
8019 OPC_Decode, 216, 22, 206, 2, // 9346: decode to WSBH using decoder 334
8020 // 9346: }
8021 16, 11, // 9351: case 0x10: {
8022 OPC_CheckPredicate, 28, // 9353: check predicate 28
8023 OPC_CheckField, 21, 5, 0, // 9355: check Inst[25:21] == 0x0
8024 OPC_Decode, 219, 19, 206, 2, // 9359: decode to SEB using decoder 334
8025 // 9359: }
8026 24, 0, // 9364: case 0x18: {
8027 OPC_CheckPredicate, 28, // 9366: check predicate 28
8028 OPC_CheckField, 21, 5, 0, // 9368: check Inst[25:21] == 0x0
8029 OPC_Decode, 222, 19, 206, 2, // 9372: decode to SEH using decoder 334
8030 // 9372: }
8031 // 9372: } // switch Inst[10:6]
8032 // 9372: }
8033 33, 11, // 9377: case 0x21: {
8034 OPC_CheckPredicate, 70, // 9379: check predicate 70
8035 OPC_CheckField, 6, 1, 0, // 9381: check Inst[6] == 0x0
8036 OPC_Decode, 223, 21, 210, 2, // 9385: decode to SWLE using decoder 338
8037 // 9385: }
8038 34, 11, // 9390: case 0x22: {
8039 OPC_CheckPredicate, 70, // 9392: check predicate 70
8040 OPC_CheckField, 6, 1, 0, // 9394: check Inst[6] == 0x0
8041 OPC_Decode, 232, 21, 210, 2, // 9398: decode to SWRE using decoder 338
8042 // 9398: }
8043 35, 11, // 9403: case 0x23: {
8044 OPC_CheckPredicate, 44, // 9405: check predicate 44
8045 OPC_CheckField, 6, 1, 0, // 9407: check Inst[6] == 0x0
8046 OPC_Decode, 237, 18, 211, 2, // 9411: decode to PREFE using decoder 339
8047 // 9411: }
8048 40, 11, // 9416: case 0x28: {
8049 OPC_CheckPredicate, 44, // 9418: check predicate 44
8050 OPC_CheckField, 6, 1, 0, // 9420: check Inst[6] == 0x0
8051 OPC_Decode, 235, 14, 210, 2, // 9424: decode to LBuE using decoder 338
8052 // 9424: }
8053 41, 11, // 9429: case 0x29: {
8054 OPC_CheckPredicate, 44, // 9431: check predicate 44
8055 OPC_CheckField, 6, 1, 0, // 9433: check Inst[6] == 0x0
8056 OPC_Decode, 146, 15, 210, 2, // 9437: decode to LHuE using decoder 338
8057 // 9437: }
8058 44, 11, // 9442: case 0x2c: {
8059 OPC_CheckPredicate, 44, // 9444: check predicate 44
8060 OPC_CheckField, 6, 1, 0, // 9446: check Inst[6] == 0x0
8061 OPC_Decode, 225, 14, 210, 2, // 9450: decode to LBE using decoder 338
8062 // 9450: }
8063 45, 11, // 9455: case 0x2d: {
8064 OPC_CheckPredicate, 44, // 9457: check predicate 44
8065 OPC_CheckField, 6, 1, 0, // 9459: check Inst[6] == 0x0
8066 OPC_Decode, 138, 15, 210, 2, // 9463: decode to LHE using decoder 338
8067 // 9463: }
8068 46, 11, // 9468: case 0x2e: {
8069 OPC_CheckPredicate, 44, // 9470: check predicate 44
8070 OPC_CheckField, 6, 1, 0, // 9472: check Inst[6] == 0x0
8071 OPC_Decode, 156, 15, 210, 2, // 9476: decode to LLE using decoder 338
8072 // 9476: }
8073 47, 11, // 9481: case 0x2f: {
8074 OPC_CheckPredicate, 44, // 9483: check predicate 44
8075 OPC_CheckField, 6, 1, 0, // 9485: check Inst[6] == 0x0
8076 OPC_Decode, 182, 15, 210, 2, // 9489: decode to LWE using decoder 338
8077 // 9489: }
8078 48, 161, 2, // 9494: case 0x30: {
8079 OPC_SwitchField, 6, 5, // 9497: switch Inst[10:6] {
8080 0, 11, // 9500: case 0x0: {
8081 OPC_CheckPredicate, 69, // 9502: check predicate 69
8082 OPC_CheckField, 13, 3, 0, // 9504: check Inst[15:13] == 0x0
8083 OPC_Decode, 244, 11, 212, 2, // 9508: decode to DPA_W_PH using decoder 340
8084 // 9508: }
8085 1, 11, // 9513: case 0x1: {
8086 OPC_CheckPredicate, 69, // 9515: check predicate 69
8087 OPC_CheckField, 13, 3, 0, // 9517: check Inst[15:13] == 0x0
8088 OPC_Decode, 139, 12, 212, 2, // 9521: decode to DPS_W_PH using decoder 340
8089 // 9521: }
8090 2, 11, // 9526: case 0x2: {
8091 OPC_CheckPredicate, 69, // 9528: check predicate 69
8092 OPC_CheckField, 13, 3, 0, // 9530: check Inst[15:13] == 0x0
8093 OPC_Decode, 235, 17, 212, 2, // 9534: decode to MULSA_W_PH using decoder 340
8094 // 9534: }
8095 3, 11, // 9539: case 0x3: {
8096 OPC_CheckPredicate, 37, // 9541: check predicate 37
8097 OPC_CheckField, 13, 3, 0, // 9543: check Inst[15:13] == 0x0
8098 OPC_Decode, 238, 11, 212, 2, // 9547: decode to DPAU_H_QBL using decoder 340
8099 // 9547: }
8100 4, 11, // 9552: case 0x4: {
8101 OPC_CheckPredicate, 37, // 9554: check predicate 37
8102 OPC_CheckField, 13, 3, 0, // 9556: check Inst[15:13] == 0x0
8103 OPC_Decode, 236, 11, 212, 2, // 9560: decode to DPAQ_S_W_PH using decoder 340
8104 // 9560: }
8105 5, 11, // 9565: case 0x5: {
8106 OPC_CheckPredicate, 37, // 9567: check predicate 37
8107 OPC_CheckField, 13, 3, 0, // 9569: check Inst[15:13] == 0x0
8108 OPC_Decode, 253, 11, 212, 2, // 9573: decode to DPSQ_S_W_PH using decoder 340
8109 // 9573: }
8110 6, 11, // 9578: case 0x6: {
8111 OPC_CheckPredicate, 37, // 9580: check predicate 37
8112 OPC_CheckField, 13, 3, 0, // 9582: check Inst[15:13] == 0x0
8113 OPC_Decode, 233, 17, 212, 2, // 9586: decode to MULSAQ_S_W_PH using decoder 340
8114 // 9586: }
8115 7, 11, // 9591: case 0x7: {
8116 OPC_CheckPredicate, 37, // 9593: check predicate 37
8117 OPC_CheckField, 13, 3, 0, // 9595: check Inst[15:13] == 0x0
8118 OPC_Decode, 240, 11, 212, 2, // 9599: decode to DPAU_H_QBR using decoder 340
8119 // 9599: }
8120 8, 11, // 9604: case 0x8: {
8121 OPC_CheckPredicate, 69, // 9606: check predicate 69
8122 OPC_CheckField, 13, 3, 0, // 9608: check Inst[15:13] == 0x0
8123 OPC_Decode, 242, 11, 212, 2, // 9612: decode to DPAX_W_PH using decoder 340
8124 // 9612: }
8125 9, 11, // 9617: case 0x9: {
8126 OPC_CheckPredicate, 69, // 9619: check predicate 69
8127 OPC_CheckField, 13, 3, 0, // 9621: check Inst[15:13] == 0x0
8128 OPC_Decode, 137, 12, 212, 2, // 9625: decode to DPSX_W_PH using decoder 340
8129 // 9625: }
8130 11, 11, // 9630: case 0xb: {
8131 OPC_CheckPredicate, 37, // 9632: check predicate 37
8132 OPC_CheckField, 13, 3, 0, // 9634: check Inst[15:13] == 0x0
8133 OPC_Decode, 133, 12, 212, 2, // 9638: decode to DPSU_H_QBL using decoder 340
8134 // 9638: }
8135 12, 11, // 9643: case 0xc: {
8136 OPC_CheckPredicate, 37, // 9645: check predicate 37
8137 OPC_CheckField, 13, 3, 0, // 9647: check Inst[15:13] == 0x0
8138 OPC_Decode, 234, 11, 212, 2, // 9651: decode to DPAQ_SA_L_W using decoder 340
8139 // 9651: }
8140 13, 11, // 9656: case 0xd: {
8141 OPC_CheckPredicate, 37, // 9658: check predicate 37
8142 OPC_CheckField, 13, 3, 0, // 9660: check Inst[15:13] == 0x0
8143 OPC_Decode, 251, 11, 212, 2, // 9664: decode to DPSQ_SA_L_W using decoder 340
8144 // 9664: }
8145 15, 11, // 9669: case 0xf: {
8146 OPC_CheckPredicate, 37, // 9671: check predicate 37
8147 OPC_CheckField, 13, 3, 0, // 9673: check Inst[15:13] == 0x0
8148 OPC_Decode, 135, 12, 212, 2, // 9677: decode to DPSU_H_QBR using decoder 340
8149 // 9677: }
8150 16, 11, // 9682: case 0x10: {
8151 OPC_CheckPredicate, 37, // 9684: check predicate 37
8152 OPC_CheckField, 13, 3, 0, // 9686: check Inst[15:13] == 0x0
8153 OPC_Decode, 248, 15, 212, 2, // 9690: decode to MAQ_SA_W_PHL using decoder 340
8154 // 9690: }
8155 18, 11, // 9695: case 0x12: {
8156 OPC_CheckPredicate, 37, // 9697: check predicate 37
8157 OPC_CheckField, 13, 3, 0, // 9699: check Inst[15:13] == 0x0
8158 OPC_Decode, 250, 15, 212, 2, // 9703: decode to MAQ_SA_W_PHR using decoder 340
8159 // 9703: }
8160 20, 11, // 9708: case 0x14: {
8161 OPC_CheckPredicate, 37, // 9710: check predicate 37
8162 OPC_CheckField, 13, 3, 0, // 9712: check Inst[15:13] == 0x0
8163 OPC_Decode, 252, 15, 212, 2, // 9716: decode to MAQ_S_W_PHL using decoder 340
8164 // 9716: }
8165 22, 11, // 9721: case 0x16: {
8166 OPC_CheckPredicate, 37, // 9723: check predicate 37
8167 OPC_CheckField, 13, 3, 0, // 9725: check Inst[15:13] == 0x0
8168 OPC_Decode, 254, 15, 212, 2, // 9729: decode to MAQ_S_W_PHR using decoder 340
8169 // 9729: }
8170 24, 11, // 9734: case 0x18: {
8171 OPC_CheckPredicate, 69, // 9736: check predicate 69
8172 OPC_CheckField, 13, 3, 0, // 9738: check Inst[15:13] == 0x0
8173 OPC_Decode, 232, 11, 212, 2, // 9742: decode to DPAQX_S_W_PH using decoder 340
8174 // 9742: }
8175 25, 11, // 9747: case 0x19: {
8176 OPC_CheckPredicate, 69, // 9749: check predicate 69
8177 OPC_CheckField, 13, 3, 0, // 9751: check Inst[15:13] == 0x0
8178 OPC_Decode, 249, 11, 212, 2, // 9755: decode to DPSQX_S_W_PH using decoder 340
8179 // 9755: }
8180 26, 11, // 9760: case 0x1a: {
8181 OPC_CheckPredicate, 69, // 9762: check predicate 69
8182 OPC_CheckField, 13, 3, 0, // 9764: check Inst[15:13] == 0x0
8183 OPC_Decode, 230, 11, 212, 2, // 9768: decode to DPAQX_SA_W_PH using decoder 340
8184 // 9768: }
8185 27, 0, // 9773: case 0x1b: {
8186 OPC_CheckPredicate, 69, // 9775: check predicate 69
8187 OPC_CheckField, 13, 3, 0, // 9777: check Inst[15:13] == 0x0
8188 OPC_Decode, 247, 11, 212, 2, // 9781: decode to DPSQX_SA_W_PH using decoder 340
8189 // 9781: }
8190 // 9781: } // switch Inst[10:6]
8191 // 9781: }
8192 49, 30, // 9786: case 0x31: {
8193 OPC_SwitchField, 6, 5, // 9788: switch Inst[10:6] {
8194 0, 7, // 9791: case 0x0: {
8195 OPC_CheckPredicate, 69, // 9793: check predicate 69
8196 OPC_Decode, 240, 6, 213, 2, // 9795: decode to APPEND using decoder 341
8197 // 9795: }
8198 1, 7, // 9800: case 0x1: {
8199 OPC_CheckPredicate, 69, // 9802: check predicate 69
8200 OPC_Decode, 243, 18, 213, 2, // 9804: decode to PREPEND using decoder 341
8201 // 9804: }
8202 16, 0, // 9809: case 0x10: {
8203 OPC_CheckPredicate, 69, // 9811: check predicate 69
8204 OPC_Decode, 156, 7, 213, 2, // 9813: decode to BALIGN using decoder 341
8205 // 9813: }
8206 // 9813: } // switch Inst[10:6]
8207 // 9813: }
8208 56, 216, 1, // 9818: case 0x38: {
8209 OPC_SwitchField, 6, 5, // 9821: switch Inst[10:6] {
8210 0, 11, // 9824: case 0x0: {
8211 OPC_CheckPredicate, 37, // 9826: check predicate 37
8212 OPC_CheckField, 13, 3, 0, // 9828: check Inst[15:13] == 0x0
8213 OPC_Decode, 203, 12, 214, 2, // 9832: decode to EXTR_W using decoder 342
8214 // 9832: }
8215 1, 11, // 9837: case 0x1: {
8216 OPC_CheckPredicate, 37, // 9839: check predicate 37
8217 OPC_CheckField, 13, 3, 0, // 9841: check Inst[15:13] == 0x0
8218 OPC_Decode, 195, 12, 215, 2, // 9845: decode to EXTRV_W using decoder 343
8219 // 9845: }
8220 2, 11, // 9850: case 0x2: {
8221 OPC_CheckPredicate, 37, // 9852: check predicate 37
8222 OPC_CheckField, 13, 3, 0, // 9854: check Inst[15:13] == 0x0
8223 OPC_Decode, 181, 12, 214, 2, // 9858: decode to EXTP using decoder 342
8224 // 9858: }
8225 3, 11, // 9863: case 0x3: {
8226 OPC_CheckPredicate, 37, // 9865: check predicate 37
8227 OPC_CheckField, 13, 3, 0, // 9867: check Inst[15:13] == 0x0
8228 OPC_Decode, 186, 12, 215, 2, // 9871: decode to EXTPV using decoder 343
8229 // 9871: }
8230 4, 11, // 9876: case 0x4: {
8231 OPC_CheckPredicate, 37, // 9878: check predicate 37
8232 OPC_CheckField, 13, 3, 0, // 9880: check Inst[15:13] == 0x0
8233 OPC_Decode, 199, 12, 214, 2, // 9884: decode to EXTR_R_W using decoder 342
8234 // 9884: }
8235 5, 11, // 9889: case 0x5: {
8236 OPC_CheckPredicate, 37, // 9891: check predicate 37
8237 OPC_CheckField, 13, 3, 0, // 9893: check Inst[15:13] == 0x0
8238 OPC_Decode, 191, 12, 215, 2, // 9897: decode to EXTRV_R_W using decoder 343
8239 // 9897: }
8240 6, 11, // 9902: case 0x6: {
8241 OPC_CheckPredicate, 37, // 9904: check predicate 37
8242 OPC_CheckField, 13, 3, 0, // 9906: check Inst[15:13] == 0x0
8243 OPC_Decode, 197, 12, 214, 2, // 9910: decode to EXTR_RS_W using decoder 342
8244 // 9910: }
8245 7, 11, // 9915: case 0x7: {
8246 OPC_CheckPredicate, 37, // 9917: check predicate 37
8247 OPC_CheckField, 13, 3, 0, // 9919: check Inst[15:13] == 0x0
8248 OPC_Decode, 189, 12, 215, 2, // 9923: decode to EXTRV_RS_W using decoder 343
8249 // 9923: }
8250 10, 11, // 9928: case 0xa: {
8251 OPC_CheckPredicate, 37, // 9930: check predicate 37
8252 OPC_CheckField, 13, 3, 0, // 9932: check Inst[15:13] == 0x0
8253 OPC_Decode, 182, 12, 214, 2, // 9936: decode to EXTPDP using decoder 342
8254 // 9936: }
8255 11, 11, // 9941: case 0xb: {
8256 OPC_CheckPredicate, 37, // 9943: check predicate 37
8257 OPC_CheckField, 13, 3, 0, // 9945: check Inst[15:13] == 0x0
8258 OPC_Decode, 183, 12, 215, 2, // 9949: decode to EXTPDPV using decoder 343
8259 // 9949: }
8260 14, 11, // 9954: case 0xe: {
8261 OPC_CheckPredicate, 37, // 9956: check predicate 37
8262 OPC_CheckField, 13, 3, 0, // 9958: check Inst[15:13] == 0x0
8263 OPC_Decode, 201, 12, 214, 2, // 9962: decode to EXTR_S_H using decoder 342
8264 // 9962: }
8265 15, 11, // 9967: case 0xf: {
8266 OPC_CheckPredicate, 37, // 9969: check predicate 37
8267 OPC_CheckField, 13, 3, 0, // 9971: check Inst[15:13] == 0x0
8268 OPC_Decode, 193, 12, 215, 2, // 9975: decode to EXTRV_S_H using decoder 343
8269 // 9975: }
8270 18, 7, // 9980: case 0x12: {
8271 OPC_CheckPredicate, 37, // 9982: check predicate 37
8272 OPC_Decode, 249, 18, 216, 2, // 9984: decode to RDDSP using decoder 344
8273 // 9984: }
8274 19, 7, // 9989: case 0x13: {
8275 OPC_CheckPredicate, 40, // 9991: check predicate 40
8276 OPC_Decode, 213, 22, 217, 2, // 9993: decode to WRDSP using decoder 345
8277 // 9993: }
8278 26, 11, // 9998: case 0x1a: {
8279 OPC_CheckPredicate, 37, // 10000: check predicate 37
8280 OPC_CheckField, 13, 7, 0, // 10002: check Inst[19:13] == 0x0
8281 OPC_Decode, 254, 19, 218, 2, // 10006: decode to SHILO using decoder 346
8282 // 10006: }
8283 27, 11, // 10011: case 0x1b: {
8284 OPC_CheckPredicate, 37, // 10013: check predicate 37
8285 OPC_CheckField, 13, 8, 0, // 10015: check Inst[20:13] == 0x0
8286 OPC_Decode, 255, 19, 219, 2, // 10019: decode to SHILOV using decoder 347
8287 // 10019: }
8288 31, 0, // 10024: case 0x1f: {
8289 OPC_CheckPredicate, 37, // 10026: check predicate 37
8290 OPC_CheckField, 13, 8, 0, // 10028: check Inst[20:13] == 0x0
8291 OPC_Decode, 195, 17, 219, 2, // 10032: decode to MTHLIP using decoder 347
8292 // 10032: }
8293 // 10032: } // switch Inst[10:6]
8294 // 10032: }
8295 59, 0, // 10037: case 0x3b: {
8296 OPC_CheckPredicate, 27, // 10039: check predicate 27
8297 OPC_CheckField, 21, 5, 0, // 10041: check Inst[25:21] == 0x0
8298 OPC_CheckField, 9, 2, 0, // 10045: check Inst[10:9] == 0x0
8299 OPC_Decode, 251, 18, 220, 2, // 10049: decode to RDHWR using decoder 348
8300 // 10049: }
8301 // 10049: } // switch Inst[5:0]
8302 // 10049: }
8303 32, 7, // 10054: case 0x20: {
8304 OPC_CheckPredicate, 27, // 10056: check predicate 27
8305 OPC_Decode, 223, 14, 148, 1, // 10058: decode to LB using decoder 148
8306 // 10058: }
8307 33, 7, // 10063: case 0x21: {
8308 OPC_CheckPredicate, 27, // 10065: check predicate 27
8309 OPC_Decode, 136, 15, 148, 1, // 10067: decode to LH using decoder 148
8310 // 10067: }
8311 34, 7, // 10072: case 0x22: {
8312 OPC_CheckPredicate, 31, // 10074: check predicate 31
8313 OPC_Decode, 185, 15, 148, 1, // 10076: decode to LWL using decoder 148
8314 // 10076: }
8315 35, 7, // 10081: case 0x23: {
8316 OPC_CheckPredicate, 27, // 10083: check predicate 27
8317 OPC_Decode, 171, 15, 148, 1, // 10085: decode to LW using decoder 148
8318 // 10085: }
8319 36, 7, // 10090: case 0x24: {
8320 OPC_CheckPredicate, 27, // 10092: check predicate 27
8321 OPC_Decode, 233, 14, 148, 1, // 10094: decode to LBu using decoder 148
8322 // 10094: }
8323 37, 7, // 10099: case 0x25: {
8324 OPC_CheckPredicate, 27, // 10101: check predicate 27
8325 OPC_Decode, 144, 15, 148, 1, // 10103: decode to LHu using decoder 148
8326 // 10103: }
8327 38, 7, // 10108: case 0x26: {
8328 OPC_CheckPredicate, 31, // 10110: check predicate 31
8329 OPC_Decode, 196, 15, 148, 1, // 10112: decode to LWR using decoder 148
8330 // 10112: }
8331 40, 7, // 10117: case 0x28: {
8332 OPC_CheckPredicate, 27, // 10119: check predicate 27
8333 OPC_Decode, 179, 19, 148, 1, // 10121: decode to SB using decoder 148
8334 // 10121: }
8335 41, 7, // 10126: case 0x29: {
8336 OPC_CheckPredicate, 27, // 10128: check predicate 27
8337 OPC_Decode, 245, 19, 148, 1, // 10130: decode to SH using decoder 148
8338 // 10130: }
8339 42, 7, // 10135: case 0x2a: {
8340 OPC_CheckPredicate, 31, // 10137: check predicate 31
8341 OPC_Decode, 221, 21, 148, 1, // 10139: decode to SWL using decoder 148
8342 // 10139: }
8343 43, 7, // 10144: case 0x2b: {
8344 OPC_CheckPredicate, 27, // 10146: check predicate 27
8345 OPC_Decode, 207, 21, 148, 1, // 10148: decode to SW using decoder 148
8346 // 10148: }
8347 46, 7, // 10153: case 0x2e: {
8348 OPC_CheckPredicate, 31, // 10155: check predicate 31
8349 OPC_Decode, 230, 21, 148, 1, // 10157: decode to SWR using decoder 148
8350 // 10157: }
8351 47, 7, // 10162: case 0x2f: {
8352 OPC_CheckPredicate, 71, // 10164: check predicate 71
8353 OPC_Decode, 220, 8, 221, 2, // 10166: decode to CACHE using decoder 349
8354 // 10166: }
8355 48, 7, // 10171: case 0x30: {
8356 OPC_CheckPredicate, 72, // 10173: check predicate 72
8357 OPC_Decode, 151, 15, 148, 1, // 10175: decode to LL using decoder 148
8358 // 10175: }
8359 49, 7, // 10180: case 0x31: {
8360 OPC_CheckPredicate, 47, // 10182: check predicate 47
8361 OPC_Decode, 174, 15, 222, 2, // 10184: decode to LWC1 using decoder 350
8362 // 10184: }
8363 50, 7, // 10189: case 0x32: {
8364 OPC_CheckPredicate, 31, // 10191: check predicate 31
8365 OPC_Decode, 176, 15, 223, 2, // 10193: decode to LWC2 using decoder 351
8366 // 10193: }
8367 51, 7, // 10198: case 0x33: {
8368 OPC_CheckPredicate, 71, // 10200: check predicate 71
8369 OPC_Decode, 236, 18, 221, 2, // 10202: decode to PREF using decoder 349
8370 // 10202: }
8371 53, 7, // 10207: case 0x35: {
8372 OPC_CheckPredicate, 57, // 10209: check predicate 57
8373 OPC_Decode, 239, 14, 222, 2, // 10211: decode to LDC1 using decoder 350
8374 // 10211: }
8375 54, 7, // 10216: case 0x36: {
8376 OPC_CheckPredicate, 39, // 10218: check predicate 39
8377 OPC_Decode, 244, 14, 223, 2, // 10220: decode to LDC2 using decoder 351
8378 // 10220: }
8379 56, 7, // 10225: case 0x38: {
8380 OPC_CheckPredicate, 72, // 10227: check predicate 72
8381 OPC_Decode, 187, 19, 148, 1, // 10229: decode to SC using decoder 148
8382 // 10229: }
8383 57, 7, // 10234: case 0x39: {
8384 OPC_CheckPredicate, 47, // 10236: check predicate 47
8385 OPC_Decode, 211, 21, 222, 2, // 10238: decode to SWC1 using decoder 350
8386 // 10238: }
8387 58, 7, // 10243: case 0x3a: {
8388 OPC_CheckPredicate, 31, // 10245: check predicate 31
8389 OPC_Decode, 213, 21, 223, 2, // 10247: decode to SWC2 using decoder 351
8390 // 10247: }
8391 61, 7, // 10252: case 0x3d: {
8392 OPC_CheckPredicate, 57, // 10254: check predicate 57
8393 OPC_Decode, 204, 19, 222, 2, // 10256: decode to SDC1 using decoder 350
8394 // 10256: }
8395 62, 0, // 10261: case 0x3e: {
8396 OPC_CheckPredicate, 39, // 10263: check predicate 39
8397 OPC_Decode, 209, 19, 223, 2, // 10265: decode to SDC2 using decoder 351
8398 // 10265: }
8399 // 10265: } // switch Inst[31:26]
8400};
8401static const uint8_t DecoderTableMips32_64_PTR6432[33] = {
8402 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
8403 0, 10, // 3: case 0x0: {
8404 OPC_CheckPredicate, 73, // 5: check predicate 73
8405 OPC_CheckField, 0, 21, 8, // 7: check Inst[20:0] == 0x8
8406 OPC_Decode, 206, 14, 51, // 11: decode to JR64 using decoder 51
8407 // 11: }
8408 48, 7, // 15: case 0x30: {
8409 OPC_CheckPredicate, 74, // 17: check predicate 74
8410 OPC_Decode, 152, 15, 148, 1, // 19: decode to LL64 using decoder 148
8411 // 19: }
8412 56, 0, // 24: case 0x38: {
8413 OPC_CheckPredicate, 74, // 26: check predicate 74
8414 OPC_Decode, 188, 19, 148, 1, // 28: decode to SC64 using decoder 148
8415 // 28: }
8416 // 28: } // switch Inst[31:26]
8417};
8418static const uint8_t DecoderTableMips32r6_64r632[1496] = {
8419 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
8420 0, 179, 2, // 3: case 0x0: {
8421 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
8422 5, 11, // 9: case 0x5: {
8423 OPC_CheckPredicate, 75, // 11: check predicate 75
8424 OPC_CheckField, 8, 3, 0, // 13: check Inst[10:8] == 0x0
8425 OPC_Decode, 163, 15, 187, 1, // 17: decode to LSA_R6 using decoder 187
8426 // 17: }
8427 9, 11, // 22: case 0x9: {
8428 OPC_CheckPredicate, 75, // 24: check predicate 75
8429 OPC_CheckField, 6, 15, 16, // 26: check Inst[20:6] == 0x10
8430 OPC_Decode, 214, 14, 188, 1, // 30: decode to JR_HB_R6 using decoder 188
8431 // 30: }
8432 14, 7, // 35: case 0xe: {
8433 OPC_CheckPredicate, 76, // 37: check predicate 76
8434 OPC_Decode, 203, 19, 190, 1, // 39: decode to SDBBP_R6 using decoder 190
8435 // 39: }
8436 16, 14, // 44: case 0x10: {
8437 OPC_CheckPredicate, 75, // 46: check predicate 75
8438 OPC_CheckField, 16, 5, 0, // 48: check Inst[20:16] == 0x0
8439 OPC_CheckField, 6, 5, 1, // 52: check Inst[10:6] == 0x1
8440 OPC_Decode, 168, 9, 52, // 56: decode to CLZ_R6 using decoder 52
8441 // 56: }
8442 17, 14, // 60: case 0x11: {
8443 OPC_CheckPredicate, 75, // 62: check predicate 75
8444 OPC_CheckField, 16, 5, 0, // 64: check Inst[20:16] == 0x0
8445 OPC_CheckField, 6, 5, 1, // 68: check Inst[10:6] == 0x1
8446 OPC_Decode, 148, 9, 52, // 72: decode to CLO_R6 using decoder 52
8447 // 72: }
8448 18, 14, // 76: case 0x12: {
8449 OPC_CheckPredicate, 77, // 78: check predicate 77
8450 OPC_CheckField, 16, 5, 0, // 80: check Inst[20:16] == 0x0
8451 OPC_CheckField, 6, 5, 1, // 84: check Inst[10:6] == 0x1
8452 OPC_Decode, 168, 11, 53, // 88: decode to DCLZ_R6 using decoder 53
8453 // 88: }
8454 19, 14, // 92: case 0x13: {
8455 OPC_CheckPredicate, 77, // 94: check predicate 77
8456 OPC_CheckField, 16, 5, 0, // 96: check Inst[20:16] == 0x0
8457 OPC_CheckField, 6, 5, 1, // 100: check Inst[10:6] == 0x1
8458 OPC_Decode, 166, 11, 53, // 104: decode to DCLO_R6 using decoder 53
8459 // 104: }
8460 21, 11, // 108: case 0x15: {
8461 OPC_CheckPredicate, 77, // 110: check predicate 77
8462 OPC_CheckField, 8, 3, 0, // 112: check Inst[10:8] == 0x0
8463 OPC_Decode, 197, 11, 196, 1, // 116: decode to DLSA_R6 using decoder 196
8464 // 116: }
8465 24, 19, // 121: case 0x18: {
8466 OPC_SwitchField, 6, 5, // 123: switch Inst[10:6] {
8467 2, 6, // 126: case 0x2: {
8468 OPC_CheckPredicate, 76, // 128: check predicate 76
8469 OPC_Decode, 129, 18, 67, // 130: decode to MUL_R6 using decoder 67
8470 // 130: }
8471 3, 0, // 134: case 0x3: {
8472 OPC_CheckPredicate, 76, // 136: check predicate 76
8473 OPC_Decode, 209, 17, 67, // 138: decode to MUH using decoder 67
8474 // 138: }
8475 // 138: } // switch Inst[10:6]
8476 // 138: }
8477 25, 19, // 142: case 0x19: {
8478 OPC_SwitchField, 6, 5, // 144: switch Inst[10:6] {
8479 2, 6, // 147: case 0x2: {
8480 OPC_CheckPredicate, 76, // 149: check predicate 76
8481 OPC_Decode, 245, 17, 67, // 151: decode to MULU using decoder 67
8482 // 151: }
8483 3, 0, // 155: case 0x3: {
8484 OPC_CheckPredicate, 76, // 157: check predicate 76
8485 OPC_Decode, 210, 17, 67, // 159: decode to MUHU using decoder 67
8486 // 159: }
8487 // 159: } // switch Inst[10:6]
8488 // 159: }
8489 26, 19, // 163: case 0x1a: {
8490 OPC_SwitchField, 6, 5, // 165: switch Inst[10:6] {
8491 2, 6, // 168: case 0x2: {
8492 OPC_CheckPredicate, 76, // 170: check predicate 76
8493 OPC_Decode, 182, 11, 67, // 172: decode to DIV using decoder 67
8494 // 172: }
8495 3, 0, // 176: case 0x3: {
8496 OPC_CheckPredicate, 76, // 178: check predicate 76
8497 OPC_Decode, 215, 16, 67, // 180: decode to MOD using decoder 67
8498 // 180: }
8499 // 180: } // switch Inst[10:6]
8500 // 180: }
8501 27, 19, // 184: case 0x1b: {
8502 OPC_SwitchField, 6, 5, // 186: switch Inst[10:6] {
8503 2, 6, // 189: case 0x2: {
8504 OPC_CheckPredicate, 76, // 191: check predicate 76
8505 OPC_Decode, 183, 11, 67, // 193: decode to DIVU using decoder 67
8506 // 193: }
8507 3, 0, // 197: case 0x3: {
8508 OPC_CheckPredicate, 76, // 199: check predicate 76
8509 OPC_Decode, 218, 16, 67, // 201: decode to MODU using decoder 67
8510 // 201: }
8511 // 201: } // switch Inst[10:6]
8512 // 201: }
8513 28, 19, // 205: case 0x1c: {
8514 OPC_SwitchField, 6, 5, // 207: switch Inst[10:6] {
8515 2, 6, // 210: case 0x2: {
8516 OPC_CheckPredicate, 77, // 212: check predicate 77
8517 OPC_Decode, 217, 11, 50, // 214: decode to DMUL_R6 using decoder 50
8518 // 214: }
8519 3, 0, // 218: case 0x3: {
8520 OPC_CheckPredicate, 77, // 220: check predicate 77
8521 OPC_Decode, 211, 11, 50, // 222: decode to DMUH using decoder 50
8522 // 222: }
8523 // 222: } // switch Inst[10:6]
8524 // 222: }
8525 29, 19, // 226: case 0x1d: {
8526 OPC_SwitchField, 6, 5, // 228: switch Inst[10:6] {
8527 2, 6, // 231: case 0x2: {
8528 OPC_CheckPredicate, 77, // 233: check predicate 77
8529 OPC_Decode, 216, 11, 50, // 235: decode to DMULU using decoder 50
8530 // 235: }
8531 3, 0, // 239: case 0x3: {
8532 OPC_CheckPredicate, 77, // 241: check predicate 77
8533 OPC_Decode, 212, 11, 50, // 243: decode to DMUHU using decoder 50
8534 // 243: }
8535 // 243: } // switch Inst[10:6]
8536 // 243: }
8537 30, 19, // 247: case 0x1e: {
8538 OPC_SwitchField, 6, 5, // 249: switch Inst[10:6] {
8539 2, 6, // 252: case 0x2: {
8540 OPC_CheckPredicate, 77, // 254: check predicate 77
8541 OPC_Decode, 169, 11, 50, // 256: decode to DDIV using decoder 50
8542 // 256: }
8543 3, 0, // 260: case 0x3: {
8544 OPC_CheckPredicate, 77, // 262: check predicate 77
8545 OPC_Decode, 203, 11, 50, // 264: decode to DMOD using decoder 50
8546 // 264: }
8547 // 264: } // switch Inst[10:6]
8548 // 264: }
8549 31, 19, // 268: case 0x1f: {
8550 OPC_SwitchField, 6, 5, // 270: switch Inst[10:6] {
8551 2, 6, // 273: case 0x2: {
8552 OPC_CheckPredicate, 77, // 275: check predicate 77
8553 OPC_Decode, 170, 11, 50, // 277: decode to DDIVU using decoder 50
8554 // 277: }
8555 3, 0, // 281: case 0x3: {
8556 OPC_CheckPredicate, 77, // 283: check predicate 77
8557 OPC_Decode, 204, 11, 50, // 285: decode to DMODU using decoder 50
8558 // 285: }
8559 // 285: } // switch Inst[10:6]
8560 // 285: }
8561 53, 10, // 289: case 0x35: {
8562 OPC_CheckPredicate, 78, // 291: check predicate 78
8563 OPC_CheckField, 6, 5, 0, // 293: check Inst[10:6] == 0x0
8564 OPC_Decode, 225, 19, 67, // 297: decode to SELEQZ using decoder 67
8565 // 297: }
8566 55, 0, // 301: case 0x37: {
8567 OPC_CheckPredicate, 78, // 303: check predicate 78
8568 OPC_CheckField, 6, 5, 0, // 305: check Inst[10:6] == 0x0
8569 OPC_Decode, 232, 19, 67, // 309: decode to SELNEZ using decoder 67
8570 // 309: }
8571 // 309: } // switch Inst[5:0]
8572 // 309: }
8573 1, 63, // 313: case 0x1: {
8574 OPC_SwitchField, 16, 5, // 315: switch Inst[20:16] {
8575 6, 7, // 318: case 0x6: {
8576 OPC_CheckPredicate, 77, // 320: check predicate 77
8577 OPC_Decode, 160, 11, 224, 2, // 322: decode to DAHI using decoder 352
8578 // 322: }
8579 16, 14, // 327: case 0x10: {
8580 OPC_CheckPredicate, 75, // 329: check predicate 75
8581 OPC_CheckField, 21, 5, 0, // 331: check Inst[25:21] == 0x0
8582 OPC_CheckField, 0, 16, 0, // 335: check Inst[15:0] == 0x0
8583 OPC_Decode, 136, 18, 10, // 339: decode to NAL using decoder 10
8584 // 339: }
8585 17, 11, // 343: case 0x11: {
8586 OPC_CheckPredicate, 75, // 345: check predicate 75
8587 OPC_CheckField, 21, 5, 0, // 347: check Inst[25:21] == 0x0
8588 OPC_Decode, 153, 7, 200, 1, // 351: decode to BAL using decoder 200
8589 // 351: }
8590 23, 11, // 356: case 0x17: {
8591 OPC_CheckPredicate, 76, // 358: check predicate 76
8592 OPC_CheckField, 21, 5, 0, // 360: check Inst[25:21] == 0x0
8593 OPC_Decode, 176, 20, 225, 2, // 364: decode to SIGRIE using decoder 353
8594 // 364: }
8595 30, 0, // 369: case 0x1e: {
8596 OPC_CheckPredicate, 77, // 371: check predicate 77
8597 OPC_Decode, 162, 11, 224, 2, // 373: decode to DATI using decoder 352
8598 // 373: }
8599 // 373: } // switch Inst[20:16]
8600 // 373: }
8601 6, 7, // 378: case 0x6: {
8602 OPC_CheckPredicate, 76, // 380: check predicate 76
8603 OPC_Decode, 211, 7, 226, 2, // 382: decode to BGEZALC using decoder 354
8604 // 382: }
8605 7, 7, // 387: case 0x7: {
8606 OPC_CheckPredicate, 76, // 389: check predicate 76
8607 OPC_Decode, 140, 8, 227, 2, // 391: decode to BLTZALC using decoder 355
8608 // 391: }
8609 8, 7, // 396: case 0x8: {
8610 OPC_CheckPredicate, 76, // 398: check predicate 76
8611 OPC_Decode, 189, 7, 228, 2, // 400: decode to BEQC using decoder 356
8612 // 400: }
8613 15, 7, // 405: case 0xf: {
8614 OPC_CheckPredicate, 75, // 407: check predicate 75
8615 OPC_Decode, 250, 6, 205, 1, // 409: decode to AUI using decoder 205
8616 // 409: }
8617 16, 27, // 414: case 0x10: {
8618 OPC_SwitchField, 0, 16, // 416: switch Inst[15:0] {
8619 4, 10, // 419: case 0x4: {
8620 OPC_CheckPredicate, 75, // 421: check predicate 75
8621 OPC_CheckField, 21, 5, 11, // 423: check Inst[25:21] == 0xb
8622 OPC_Decode, 177, 12, 99, // 427: decode to EVP using decoder 99
8623 // 427: }
8624 36, 0, // 431: case 0x24: {
8625 OPC_CheckPredicate, 75, // 433: check predicate 75
8626 OPC_CheckField, 21, 5, 11, // 435: check Inst[25:21] == 0xb
8627 OPC_Decode, 160, 12, 99, // 439: decode to DVP using decoder 99
8628 // 439: }
8629 // 439: } // switch Inst[15:0]
8630 // 439: }
8631 17, 160, 4, // 443: case 0x11: {
8632 OPC_SwitchField, 21, 5, // 446: switch Inst[25:21] {
8633 9, 7, // 449: case 0x9: {
8634 OPC_CheckPredicate, 79, // 451: check predicate 79
8635 OPC_Decode, 164, 7, 229, 2, // 453: decode to BC1EQZ using decoder 357
8636 // 453: }
8637 13, 7, // 458: case 0xd: {
8638 OPC_CheckPredicate, 79, // 460: check predicate 79
8639 OPC_Decode, 169, 7, 229, 2, // 462: decode to BC1NEZ using decoder 357
8640 // 462: }
8641 16, 110, // 467: case 0x10: {
8642 OPC_SwitchField, 0, 6, // 469: switch Inst[5:0] {
8643 16, 7, // 472: case 0x10: {
8644 OPC_CheckPredicate, 79, // 474: check predicate 79
8645 OPC_Decode, 241, 19, 230, 2, // 476: decode to SEL_S using decoder 358
8646 // 476: }
8647 20, 7, // 481: case 0x14: {
8648 OPC_CheckPredicate, 79, // 483: check predicate 79
8649 OPC_Decode, 230, 19, 220, 1, // 485: decode to SELEQZ_S using decoder 220
8650 // 485: }
8651 23, 7, // 490: case 0x17: {
8652 OPC_CheckPredicate, 79, // 492: check predicate 79
8653 OPC_Decode, 237, 19, 220, 1, // 494: decode to SELNEZ_S using decoder 220
8654 // 494: }
8655 24, 7, // 499: case 0x18: {
8656 OPC_CheckPredicate, 79, // 501: check predicate 79
8657 OPC_Decode, 226, 15, 231, 2, // 503: decode to MADDF_S using decoder 359
8658 // 503: }
8659 25, 7, // 508: case 0x19: {
8660 OPC_CheckPredicate, 79, // 510: check predicate 79
8661 OPC_Decode, 149, 17, 231, 2, // 512: decode to MSUBF_S using decoder 359
8662 // 512: }
8663 26, 11, // 517: case 0x1a: {
8664 OPC_CheckPredicate, 79, // 519: check predicate 79
8665 OPC_CheckField, 16, 5, 0, // 521: check Inst[20:16] == 0x0
8666 OPC_Decode, 144, 19, 221, 1, // 525: decode to RINT_S using decoder 221
8667 // 525: }
8668 27, 11, // 530: case 0x1b: {
8669 OPC_CheckPredicate, 79, // 532: check predicate 79
8670 OPC_CheckField, 16, 5, 0, // 534: check Inst[20:16] == 0x0
8671 OPC_Decode, 255, 8, 221, 1, // 538: decode to CLASS_S using decoder 221
8672 // 538: }
8673 28, 7, // 543: case 0x1c: {
8674 OPC_CheckPredicate, 79, // 545: check predicate 79
8675 OPC_Decode, 205, 16, 220, 1, // 547: decode to MIN_S using decoder 220
8676 // 547: }
8677 29, 7, // 552: case 0x1d: {
8678 OPC_CheckPredicate, 79, // 554: check predicate 79
8679 OPC_Decode, 189, 16, 220, 1, // 556: decode to MINA_S using decoder 220
8680 // 556: }
8681 30, 7, // 561: case 0x1e: {
8682 OPC_CheckPredicate, 79, // 563: check predicate 79
8683 OPC_Decode, 146, 16, 220, 1, // 565: decode to MAX_S using decoder 220
8684 // 565: }
8685 31, 0, // 570: case 0x1f: {
8686 OPC_CheckPredicate, 79, // 572: check predicate 79
8687 OPC_Decode, 130, 16, 220, 1, // 574: decode to MAXA_S using decoder 220
8688 // 574: }
8689 // 574: } // switch Inst[5:0]
8690 // 574: }
8691 17, 110, // 579: case 0x11: {
8692 OPC_SwitchField, 0, 6, // 581: switch Inst[5:0] {
8693 16, 7, // 584: case 0x10: {
8694 OPC_CheckPredicate, 79, // 586: check predicate 79
8695 OPC_Decode, 239, 19, 232, 2, // 588: decode to SEL_D using decoder 360
8696 // 588: }
8697 20, 7, // 593: case 0x14: {
8698 OPC_CheckPredicate, 79, // 595: check predicate 79
8699 OPC_Decode, 227, 19, 233, 2, // 597: decode to SELEQZ_D using decoder 361
8700 // 597: }
8701 23, 7, // 602: case 0x17: {
8702 OPC_CheckPredicate, 79, // 604: check predicate 79
8703 OPC_Decode, 234, 19, 233, 2, // 606: decode to SELNEZ_D using decoder 361
8704 // 606: }
8705 24, 7, // 611: case 0x18: {
8706 OPC_CheckPredicate, 79, // 613: check predicate 79
8707 OPC_Decode, 224, 15, 234, 2, // 615: decode to MADDF_D using decoder 362
8708 // 615: }
8709 25, 7, // 620: case 0x19: {
8710 OPC_CheckPredicate, 79, // 622: check predicate 79
8711 OPC_Decode, 147, 17, 234, 2, // 624: decode to MSUBF_D using decoder 362
8712 // 624: }
8713 26, 11, // 629: case 0x1a: {
8714 OPC_CheckPredicate, 79, // 631: check predicate 79
8715 OPC_CheckField, 16, 5, 0, // 633: check Inst[20:16] == 0x0
8716 OPC_Decode, 142, 19, 232, 1, // 637: decode to RINT_D using decoder 232
8717 // 637: }
8718 27, 11, // 642: case 0x1b: {
8719 OPC_CheckPredicate, 79, // 644: check predicate 79
8720 OPC_CheckField, 16, 5, 0, // 646: check Inst[20:16] == 0x0
8721 OPC_Decode, 253, 8, 232, 1, // 650: decode to CLASS_D using decoder 232
8722 // 650: }
8723 28, 7, // 655: case 0x1c: {
8724 OPC_CheckPredicate, 79, // 657: check predicate 79
8725 OPC_Decode, 203, 16, 233, 2, // 659: decode to MIN_D using decoder 361
8726 // 659: }
8727 29, 7, // 664: case 0x1d: {
8728 OPC_CheckPredicate, 79, // 666: check predicate 79
8729 OPC_Decode, 187, 16, 233, 2, // 668: decode to MINA_D using decoder 361
8730 // 668: }
8731 30, 7, // 673: case 0x1e: {
8732 OPC_CheckPredicate, 79, // 675: check predicate 79
8733 OPC_Decode, 144, 16, 233, 2, // 677: decode to MAX_D using decoder 361
8734 // 677: }
8735 31, 0, // 682: case 0x1f: {
8736 OPC_CheckPredicate, 79, // 684: check predicate 79
8737 OPC_Decode, 128, 16, 233, 2, // 686: decode to MAXA_D using decoder 361
8738 // 686: }
8739 // 686: } // switch Inst[5:0]
8740 // 686: }
8741 20, 147, 1, // 691: case 0x14: {
8742 OPC_SwitchField, 0, 6, // 694: switch Inst[5:0] {
8743 0, 7, // 697: case 0x0: {
8744 OPC_CheckPredicate, 79, // 699: check predicate 79
8745 OPC_Decode, 196, 9, 235, 2, // 701: decode to CMP_F_S using decoder 363
8746 // 701: }
8747 1, 7, // 706: case 0x1: {
8748 OPC_CheckPredicate, 79, // 708: check predicate 79
8749 OPC_Decode, 255, 9, 235, 2, // 710: decode to CMP_UN_S using decoder 363
8750 // 710: }
8751 2, 7, // 715: case 0x2: {
8752 OPC_CheckPredicate, 79, // 717: check predicate 79
8753 OPC_Decode, 193, 9, 235, 2, // 719: decode to CMP_EQ_S using decoder 363
8754 // 719: }
8755 3, 7, // 724: case 0x3: {
8756 OPC_CheckPredicate, 79, // 726: check predicate 79
8757 OPC_Decode, 243, 9, 235, 2, // 728: decode to CMP_UEQ_S using decoder 363
8758 // 728: }
8759 4, 7, // 733: case 0x4: {
8760 OPC_CheckPredicate, 79, // 735: check predicate 79
8761 OPC_Decode, 207, 9, 235, 2, // 737: decode to CMP_LT_S using decoder 363
8762 // 737: }
8763 5, 7, // 742: case 0x5: {
8764 OPC_CheckPredicate, 79, // 744: check predicate 79
8765 OPC_Decode, 251, 9, 235, 2, // 746: decode to CMP_ULT_S using decoder 363
8766 // 746: }
8767 6, 7, // 751: case 0x6: {
8768 OPC_CheckPredicate, 79, // 753: check predicate 79
8769 OPC_Decode, 201, 9, 235, 2, // 755: decode to CMP_LE_S using decoder 363
8770 // 755: }
8771 7, 7, // 760: case 0x7: {
8772 OPC_CheckPredicate, 79, // 762: check predicate 79
8773 OPC_Decode, 247, 9, 235, 2, // 764: decode to CMP_ULE_S using decoder 363
8774 // 764: }
8775 8, 7, // 769: case 0x8: {
8776 OPC_CheckPredicate, 79, // 771: check predicate 79
8777 OPC_Decode, 211, 9, 235, 2, // 773: decode to CMP_SAF_S using decoder 363
8778 // 773: }
8779 9, 7, // 778: case 0x9: {
8780 OPC_CheckPredicate, 79, // 780: check predicate 79
8781 OPC_Decode, 239, 9, 235, 2, // 782: decode to CMP_SUN_S using decoder 363
8782 // 782: }
8783 10, 7, // 787: case 0xa: {
8784 OPC_CheckPredicate, 79, // 789: check predicate 79
8785 OPC_Decode, 215, 9, 235, 2, // 791: decode to CMP_SEQ_S using decoder 363
8786 // 791: }
8787 11, 7, // 796: case 0xb: {
8788 OPC_CheckPredicate, 79, // 798: check predicate 79
8789 OPC_Decode, 227, 9, 235, 2, // 800: decode to CMP_SUEQ_S using decoder 363
8790 // 800: }
8791 12, 7, // 805: case 0xc: {
8792 OPC_CheckPredicate, 79, // 807: check predicate 79
8793 OPC_Decode, 223, 9, 235, 2, // 809: decode to CMP_SLT_S using decoder 363
8794 // 809: }
8795 13, 7, // 814: case 0xd: {
8796 OPC_CheckPredicate, 79, // 816: check predicate 79
8797 OPC_Decode, 235, 9, 235, 2, // 818: decode to CMP_SULT_S using decoder 363
8798 // 818: }
8799 14, 7, // 823: case 0xe: {
8800 OPC_CheckPredicate, 79, // 825: check predicate 79
8801 OPC_Decode, 219, 9, 235, 2, // 827: decode to CMP_SLE_S using decoder 363
8802 // 827: }
8803 15, 0, // 832: case 0xf: {
8804 OPC_CheckPredicate, 79, // 834: check predicate 79
8805 OPC_Decode, 231, 9, 235, 2, // 836: decode to CMP_SULE_S using decoder 363
8806 // 836: }
8807 // 836: } // switch Inst[5:0]
8808 // 836: }
8809 21, 0, // 841: case 0x15: {
8810 OPC_SwitchField, 0, 6, // 843: switch Inst[5:0] {
8811 0, 7, // 846: case 0x0: {
8812 OPC_CheckPredicate, 79, // 848: check predicate 79
8813 OPC_Decode, 195, 9, 236, 2, // 850: decode to CMP_F_D using decoder 364
8814 // 850: }
8815 1, 7, // 855: case 0x1: {
8816 OPC_CheckPredicate, 79, // 857: check predicate 79
8817 OPC_Decode, 253, 9, 236, 2, // 859: decode to CMP_UN_D using decoder 364
8818 // 859: }
8819 2, 7, // 864: case 0x2: {
8820 OPC_CheckPredicate, 79, // 866: check predicate 79
8821 OPC_Decode, 189, 9, 236, 2, // 868: decode to CMP_EQ_D using decoder 364
8822 // 868: }
8823 3, 7, // 873: case 0x3: {
8824 OPC_CheckPredicate, 79, // 875: check predicate 79
8825 OPC_Decode, 241, 9, 236, 2, // 877: decode to CMP_UEQ_D using decoder 364
8826 // 877: }
8827 4, 7, // 882: case 0x4: {
8828 OPC_CheckPredicate, 79, // 884: check predicate 79
8829 OPC_Decode, 203, 9, 236, 2, // 886: decode to CMP_LT_D using decoder 364
8830 // 886: }
8831 5, 7, // 891: case 0x5: {
8832 OPC_CheckPredicate, 79, // 893: check predicate 79
8833 OPC_Decode, 249, 9, 236, 2, // 895: decode to CMP_ULT_D using decoder 364
8834 // 895: }
8835 6, 7, // 900: case 0x6: {
8836 OPC_CheckPredicate, 79, // 902: check predicate 79
8837 OPC_Decode, 197, 9, 236, 2, // 904: decode to CMP_LE_D using decoder 364
8838 // 904: }
8839 7, 7, // 909: case 0x7: {
8840 OPC_CheckPredicate, 79, // 911: check predicate 79
8841 OPC_Decode, 245, 9, 236, 2, // 913: decode to CMP_ULE_D using decoder 364
8842 // 913: }
8843 8, 7, // 918: case 0x8: {
8844 OPC_CheckPredicate, 79, // 920: check predicate 79
8845 OPC_Decode, 209, 9, 236, 2, // 922: decode to CMP_SAF_D using decoder 364
8846 // 922: }
8847 9, 7, // 927: case 0x9: {
8848 OPC_CheckPredicate, 79, // 929: check predicate 79
8849 OPC_Decode, 237, 9, 236, 2, // 931: decode to CMP_SUN_D using decoder 364
8850 // 931: }
8851 10, 7, // 936: case 0xa: {
8852 OPC_CheckPredicate, 79, // 938: check predicate 79
8853 OPC_Decode, 213, 9, 236, 2, // 940: decode to CMP_SEQ_D using decoder 364
8854 // 940: }
8855 11, 7, // 945: case 0xb: {
8856 OPC_CheckPredicate, 79, // 947: check predicate 79
8857 OPC_Decode, 225, 9, 236, 2, // 949: decode to CMP_SUEQ_D using decoder 364
8858 // 949: }
8859 12, 7, // 954: case 0xc: {
8860 OPC_CheckPredicate, 79, // 956: check predicate 79
8861 OPC_Decode, 221, 9, 236, 2, // 958: decode to CMP_SLT_D using decoder 364
8862 // 958: }
8863 13, 7, // 963: case 0xd: {
8864 OPC_CheckPredicate, 79, // 965: check predicate 79
8865 OPC_Decode, 233, 9, 236, 2, // 967: decode to CMP_SULT_D using decoder 364
8866 // 967: }
8867 14, 7, // 972: case 0xe: {
8868 OPC_CheckPredicate, 79, // 974: check predicate 79
8869 OPC_Decode, 217, 9, 236, 2, // 976: decode to CMP_SLE_D using decoder 364
8870 // 976: }
8871 15, 0, // 981: case 0xf: {
8872 OPC_CheckPredicate, 79, // 983: check predicate 79
8873 OPC_Decode, 229, 9, 236, 2, // 985: decode to CMP_SULE_D using decoder 364
8874 // 985: }
8875 // 985: } // switch Inst[5:0]
8876 // 985: }
8877 // 985: } // switch Inst[25:21]
8878 // 985: }
8879 18, 57, // 990: case 0x12: {
8880 OPC_SwitchField, 21, 5, // 992: switch Inst[25:21] {
8881 9, 7, // 995: case 0x9: {
8882 OPC_CheckPredicate, 76, // 997: check predicate 76
8883 OPC_Decode, 174, 7, 237, 2, // 999: decode to BC2EQZ using decoder 365
8884 // 999: }
8885 10, 7, // 1004: case 0xa: {
8886 OPC_CheckPredicate, 76, // 1006: check predicate 76
8887 OPC_Decode, 178, 15, 238, 2, // 1008: decode to LWC2_R6 using decoder 366
8888 // 1008: }
8889 11, 7, // 1013: case 0xb: {
8890 OPC_CheckPredicate, 76, // 1015: check predicate 76
8891 OPC_Decode, 215, 21, 238, 2, // 1017: decode to SWC2_R6 using decoder 366
8892 // 1017: }
8893 13, 7, // 1022: case 0xd: {
8894 OPC_CheckPredicate, 76, // 1024: check predicate 76
8895 OPC_Decode, 176, 7, 237, 2, // 1026: decode to BC2NEZ using decoder 365
8896 // 1026: }
8897 14, 7, // 1031: case 0xe: {
8898 OPC_CheckPredicate, 76, // 1033: check predicate 76
8899 OPC_Decode, 246, 14, 238, 2, // 1035: decode to LDC2_R6 using decoder 366
8900 // 1035: }
8901 15, 0, // 1040: case 0xf: {
8902 OPC_CheckPredicate, 76, // 1042: check predicate 76
8903 OPC_Decode, 211, 19, 238, 2, // 1044: decode to SDC2_R6 using decoder 366
8904 // 1044: }
8905 // 1044: } // switch Inst[25:21]
8906 // 1044: }
8907 22, 7, // 1049: case 0x16: {
8908 OPC_CheckPredicate, 76, // 1051: check predicate 76
8909 OPC_Decode, 216, 7, 239, 2, // 1053: decode to BGEZC using decoder 367
8910 // 1053: }
8911 23, 7, // 1058: case 0x17: {
8912 OPC_CheckPredicate, 76, // 1060: check predicate 76
8913 OPC_Decode, 145, 8, 240, 2, // 1062: decode to BLTZC using decoder 368
8914 // 1062: }
8915 24, 7, // 1067: case 0x18: {
8916 OPC_CheckPredicate, 76, // 1069: check predicate 76
8917 OPC_Decode, 156, 8, 241, 2, // 1071: decode to BNEC using decoder 369
8918 // 1071: }
8919 29, 7, // 1076: case 0x1d: {
8920 OPC_CheckPredicate, 77, // 1078: check predicate 77
8921 OPC_Decode, 163, 11, 242, 2, // 1080: decode to DAUI using decoder 370
8922 // 1080: }
8923 31, 235, 1, // 1085: case 0x1f: {
8924 OPC_SwitchField, 0, 6, // 1088: switch Inst[5:0] {
8925 15, 75, // 1091: case 0xf: {
8926 OPC_SwitchField, 6, 10, // 1093: switch Inst[15:6] {
8927 0, 7, // 1096: case 0x0: {
8928 OPC_CheckPredicate, 80, // 1098: check predicate 80
8929 OPC_Decode, 136, 10, 243, 2, // 1100: decode to CRC32B using decoder 371
8930 // 1100: }
8931 1, 7, // 1105: case 0x1: {
8932 OPC_CheckPredicate, 80, // 1107: check predicate 80
8933 OPC_Decode, 142, 10, 243, 2, // 1109: decode to CRC32H using decoder 371
8934 // 1109: }
8935 2, 7, // 1114: case 0x2: {
8936 OPC_CheckPredicate, 80, // 1116: check predicate 80
8937 OPC_Decode, 143, 10, 243, 2, // 1118: decode to CRC32W using decoder 371
8938 // 1118: }
8939 3, 7, // 1123: case 0x3: {
8940 OPC_CheckPredicate, 81, // 1125: check predicate 81
8941 OPC_Decode, 141, 10, 243, 2, // 1127: decode to CRC32D using decoder 371
8942 // 1127: }
8943 4, 7, // 1132: case 0x4: {
8944 OPC_CheckPredicate, 80, // 1134: check predicate 80
8945 OPC_Decode, 137, 10, 243, 2, // 1136: decode to CRC32CB using decoder 371
8946 // 1136: }
8947 5, 7, // 1141: case 0x5: {
8948 OPC_CheckPredicate, 80, // 1143: check predicate 80
8949 OPC_Decode, 139, 10, 243, 2, // 1145: decode to CRC32CH using decoder 371
8950 // 1145: }
8951 6, 7, // 1150: case 0x6: {
8952 OPC_CheckPredicate, 80, // 1152: check predicate 80
8953 OPC_Decode, 140, 10, 243, 2, // 1154: decode to CRC32CW using decoder 371
8954 // 1154: }
8955 7, 0, // 1159: case 0x7: {
8956 OPC_CheckPredicate, 81, // 1161: check predicate 81
8957 OPC_Decode, 138, 10, 243, 2, // 1163: decode to CRC32CD using decoder 371
8958 // 1163: }
8959 // 1163: } // switch Inst[15:6]
8960 // 1163: }
8961 32, 29, // 1168: case 0x20: {
8962 OPC_SwitchField, 8, 3, // 1170: switch Inst[10:8] {
8963 0, 15, // 1173: case 0x0: {
8964 OPC_CheckPredicate, 75, // 1175: check predicate 75
8965 OPC_CheckField, 21, 5, 0, // 1177: check Inst[25:21] == 0x0
8966 OPC_CheckField, 6, 2, 0, // 1181: check Inst[7:6] == 0x0
8967 OPC_Decode, 248, 7, 206, 2, // 1185: decode to BITSWAP using decoder 334
8968 // 1185: }
8969 2, 0, // 1190: case 0x2: {
8970 OPC_CheckPredicate, 75, // 1192: check predicate 75
8971 OPC_Decode, 222, 6, 244, 2, // 1194: decode to ALIGN using decoder 372
8972 // 1194: }
8973 // 1194: } // switch Inst[10:8]
8974 // 1194: }
8975 36, 29, // 1199: case 0x24: {
8976 OPC_SwitchField, 9, 2, // 1201: switch Inst[10:9] {
8977 0, 15, // 1204: case 0x0: {
8978 OPC_CheckPredicate, 77, // 1206: check predicate 77
8979 OPC_CheckField, 21, 5, 0, // 1208: check Inst[25:21] == 0x0
8980 OPC_CheckField, 6, 3, 0, // 1212: check Inst[8:6] == 0x0
8981 OPC_Decode, 164, 11, 245, 2, // 1216: decode to DBITSWAP using decoder 373
8982 // 1216: }
8983 1, 0, // 1221: case 0x1: {
8984 OPC_CheckPredicate, 77, // 1223: check predicate 77
8985 OPC_Decode, 161, 11, 246, 2, // 1225: decode to DALIGN using decoder 374
8986 // 1225: }
8987 // 1225: } // switch Inst[10:9]
8988 // 1225: }
8989 37, 11, // 1230: case 0x25: {
8990 OPC_CheckPredicate, 76, // 1232: check predicate 76
8991 OPC_CheckField, 6, 1, 0, // 1234: check Inst[6] == 0x0
8992 OPC_Decode, 225, 8, 211, 2, // 1238: decode to CACHE_R6 using decoder 339
8993 // 1238: }
8994 38, 7, // 1243: case 0x26: {
8995 OPC_CheckPredicate, 82, // 1245: check predicate 82
8996 OPC_Decode, 196, 19, 247, 2, // 1247: decode to SC_R6 using decoder 375
8997 // 1247: }
8998 39, 7, // 1252: case 0x27: {
8999 OPC_CheckPredicate, 75, // 1254: check predicate 75
9000 OPC_Decode, 191, 19, 247, 2, // 1256: decode to SCD_R6 using decoder 375
9001 // 1256: }
9002 53, 11, // 1261: case 0x35: {
9003 OPC_CheckPredicate, 76, // 1263: check predicate 76
9004 OPC_CheckField, 6, 1, 0, // 1265: check Inst[6] == 0x0
9005 OPC_Decode, 242, 18, 211, 2, // 1269: decode to PREF_R6 using decoder 339
9006 // 1269: }
9007 54, 7, // 1274: case 0x36: {
9008 OPC_CheckPredicate, 82, // 1276: check predicate 82
9009 OPC_Decode, 160, 15, 247, 2, // 1278: decode to LL_R6 using decoder 375
9010 // 1278: }
9011 55, 7, // 1283: case 0x37: {
9012 OPC_CheckPredicate, 77, // 1285: check predicate 77
9013 OPC_Decode, 155, 15, 247, 2, // 1287: decode to LLD_R6 using decoder 375
9014 // 1287: }
9015 61, 0, // 1292: case 0x3d: {
9016 OPC_SwitchField, 6, 2, // 1294: switch Inst[7:6] {
9017 0, 11, // 1297: case 0x0: {
9018 OPC_CheckPredicate, 83, // 1299: check predicate 83
9019 OPC_CheckField, 8, 13, 0, // 1301: check Inst[20:8] == 0x0
9020 OPC_Decode, 134, 14, 188, 1, // 1305: decode to GINVI using decoder 188
9021 // 1305: }
9022 2, 0, // 1310: case 0x2: {
9023 OPC_CheckPredicate, 83, // 1312: check predicate 83
9024 OPC_CheckField, 10, 11, 0, // 1314: check Inst[20:10] == 0x0
9025 OPC_Decode, 136, 14, 248, 2, // 1318: decode to GINVT using decoder 376
9026 // 1318: }
9027 // 1318: } // switch Inst[7:6]
9028 // 1318: }
9029 // 1318: } // switch Inst[5:0]
9030 // 1318: }
9031 50, 7, // 1323: case 0x32: {
9032 OPC_CheckPredicate, 76, // 1325: check predicate 76
9033 OPC_Decode, 162, 7, 249, 2, // 1327: decode to BC using decoder 377
9034 // 1327: }
9035 53, 20, // 1332: case 0x35: {
9036 OPC_Scope, 11, // 1334: try {
9037 OPC_CheckField, 16, 5, 0, // 1336: check Inst[20:16] == 0x0
9038 OPC_CheckPredicate, 3, // 1340: check predicate 3
9039 OPC_Decode, 227, 7, 182, 1, // 1342: decode to BGTZC_MMR6 using decoder 182
9040 // 1342: } else try {
9041 OPC_CheckPredicate, 3, // 1347: check predicate 3
9042 OPC_Decode, 147, 8, 182, 1, // 1349: decode to BLTZC_MMR6 using decoder 182
9043 // 1349: }
9044 // 1349: }
9045 54, 19, // 1354: case 0x36: {
9046 OPC_Scope, 10, // 1356: try {
9047 OPC_CheckField, 21, 5, 0, // 1358: check Inst[25:21] == 0x0
9048 OPC_CheckPredicate, 75, // 1362: check predicate 75
9049 OPC_Decode, 201, 14, 110, // 1364: decode to JIC using decoder 110
9050 // 1364: } else try {
9051 OPC_CheckPredicate, 76, // 1368: check predicate 76
9052 OPC_Decode, 196, 7, 250, 2, // 1370: decode to BEQZC using decoder 378
9053 // 1370: }
9054 // 1370: }
9055 58, 7, // 1375: case 0x3a: {
9056 OPC_CheckPredicate, 75, // 1377: check predicate 75
9057 OPC_Decode, 154, 7, 249, 2, // 1379: decode to BALC using decoder 377
9058 // 1379: }
9059 59, 67, // 1384: case 0x3b: {
9060 OPC_SwitchField, 19, 2, // 1386: switch Inst[20:19] {
9061 0, 7, // 1389: case 0x0: {
9062 OPC_CheckPredicate, 75, // 1391: check predicate 75
9063 OPC_Decode, 148, 6, 176, 1, // 1393: decode to ADDIUPC using decoder 176
9064 // 1393: }
9065 1, 7, // 1398: case 0x1: {
9066 OPC_CheckPredicate, 75, // 1400: check predicate 75
9067 OPC_Decode, 193, 15, 176, 1, // 1402: decode to LWPC using decoder 176
9068 // 1402: }
9069 2, 7, // 1407: case 0x2: {
9070 OPC_CheckPredicate, 84, // 1409: check predicate 84
9071 OPC_Decode, 202, 15, 176, 1, // 1411: decode to LWUPC using decoder 176
9072 // 1411: }
9073 3, 0, // 1416: case 0x3: {
9074 OPC_SwitchField, 18, 1, // 1418: switch Inst[18] {
9075 0, 7, // 1421: case 0x0: {
9076 OPC_CheckPredicate, 84, // 1423: check predicate 84
9077 OPC_Decode, 253, 14, 251, 2, // 1425: decode to LDPC using decoder 379
9078 // 1425: }
9079 1, 0, // 1430: case 0x1: {
9080 OPC_SwitchField, 16, 2, // 1432: switch Inst[17:16] {
9081 2, 7, // 1435: case 0x2: {
9082 OPC_CheckPredicate, 75, // 1437: check predicate 75
9083 OPC_Decode, 251, 6, 177, 1, // 1439: decode to AUIPC using decoder 177
9084 // 1439: }
9085 3, 0, // 1444: case 0x3: {
9086 OPC_CheckPredicate, 75, // 1446: check predicate 75
9087 OPC_Decode, 224, 6, 177, 1, // 1448: decode to ALUIPC using decoder 177
9088 // 1448: }
9089 // 1448: } // switch Inst[17:16]
9090 // 1448: }
9091 // 1448: } // switch Inst[18]
9092 // 1448: }
9093 // 1448: } // switch Inst[20:19]
9094 // 1448: }
9095 61, 20, // 1453: case 0x3d: {
9096 OPC_Scope, 11, // 1455: try {
9097 OPC_CheckField, 16, 5, 0, // 1457: check Inst[20:16] == 0x0
9098 OPC_CheckPredicate, 3, // 1461: check predicate 3
9099 OPC_Decode, 128, 8, 184, 1, // 1463: decode to BLEZC_MMR6 using decoder 184
9100 // 1463: } else try {
9101 OPC_CheckPredicate, 3, // 1468: check predicate 3
9102 OPC_Decode, 218, 7, 184, 1, // 1470: decode to BGEZC_MMR6 using decoder 184
9103 // 1470: }
9104 // 1470: }
9105 62, 0, // 1475: case 0x3e: {
9106 OPC_Scope, 10, // 1477: try {
9107 OPC_CheckField, 21, 5, 0, // 1479: check Inst[25:21] == 0x0
9108 OPC_CheckPredicate, 75, // 1483: check predicate 75
9109 OPC_Decode, 198, 14, 110, // 1485: decode to JIALC using decoder 110
9110 // 1485: } else try {
9111 OPC_CheckPredicate, 76, // 1489: check predicate 76
9112 OPC_Decode, 171, 8, 250, 2, // 1491: decode to BNEZC using decoder 378
9113 // 1491: }
9114 // 1491: }
9115 // 1491: } // switch Inst[31:26]
9116};
9117static const uint8_t DecoderTableMips32r6_64r6_Ambiguous32[135] = {
9118 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9119 6, 20, // 3: case 0x6: {
9120 OPC_Scope, 11, // 5: try {
9121 OPC_CheckField, 21, 5, 0, // 7: check Inst[25:21] == 0x0
9122 OPC_CheckPredicate, 76, // 11: check predicate 76
9123 OPC_Decode, 252, 7, 226, 2, // 13: decode to BLEZALC using decoder 354
9124 // 13: } else try {
9125 OPC_CheckPredicate, 76, // 18: check predicate 76
9126 OPC_Decode, 205, 7, 226, 2, // 20: decode to BGEUC using decoder 354
9127 // 20: }
9128 // 20: }
9129 7, 20, // 25: case 0x7: {
9130 OPC_Scope, 11, // 27: try {
9131 OPC_CheckField, 21, 5, 0, // 29: check Inst[25:21] == 0x0
9132 OPC_CheckPredicate, 76, // 33: check predicate 76
9133 OPC_Decode, 223, 7, 227, 2, // 35: decode to BGTZALC using decoder 355
9134 // 35: } else try {
9135 OPC_CheckPredicate, 76, // 40: check predicate 76
9136 OPC_Decode, 134, 8, 227, 2, // 42: decode to BLTUC using decoder 355
9137 // 42: }
9138 // 42: }
9139 8, 20, // 47: case 0x8: {
9140 OPC_Scope, 11, // 49: try {
9141 OPC_CheckField, 21, 5, 0, // 51: check Inst[25:21] == 0x0
9142 OPC_CheckPredicate, 76, // 55: check predicate 76
9143 OPC_Decode, 194, 7, 241, 2, // 57: decode to BEQZALC using decoder 369
9144 // 57: } else try {
9145 OPC_CheckPredicate, 76, // 62: check predicate 76
9146 OPC_Decode, 184, 8, 228, 2, // 64: decode to BOVC using decoder 356
9147 // 64: }
9148 // 64: }
9149 22, 20, // 69: case 0x16: {
9150 OPC_Scope, 11, // 71: try {
9151 OPC_CheckField, 21, 5, 0, // 73: check Inst[25:21] == 0x0
9152 OPC_CheckPredicate, 76, // 77: check predicate 76
9153 OPC_Decode, 254, 7, 239, 2, // 79: decode to BLEZC using decoder 367
9154 // 79: } else try {
9155 OPC_CheckPredicate, 76, // 84: check predicate 76
9156 OPC_Decode, 202, 7, 239, 2, // 86: decode to BGEC using decoder 367
9157 // 86: }
9158 // 86: }
9159 23, 20, // 91: case 0x17: {
9160 OPC_Scope, 11, // 93: try {
9161 OPC_CheckField, 21, 5, 0, // 95: check Inst[25:21] == 0x0
9162 OPC_CheckPredicate, 76, // 99: check predicate 76
9163 OPC_Decode, 225, 7, 240, 2, // 101: decode to BGTZC using decoder 368
9164 // 101: } else try {
9165 OPC_CheckPredicate, 76, // 106: check predicate 76
9166 OPC_Decode, 131, 8, 240, 2, // 108: decode to BLTC using decoder 368
9167 // 108: }
9168 // 108: }
9169 24, 0, // 113: case 0x18: {
9170 OPC_Scope, 11, // 115: try {
9171 OPC_CheckField, 21, 5, 0, // 117: check Inst[25:21] == 0x0
9172 OPC_CheckPredicate, 76, // 121: check predicate 76
9173 OPC_Decode, 169, 8, 241, 2, // 123: decode to BNEZALC using decoder 369
9174 // 123: } else try {
9175 OPC_CheckPredicate, 76, // 128: check predicate 76
9176 OPC_Decode, 177, 8, 241, 2, // 130: decode to BNVC using decoder 369
9177 // 130: }
9178 // 130: }
9179 // 130: } // switch Inst[31:26]
9180};
9181static const uint8_t DecoderTableMips32r6_64r6_BranchZero32[21] = {
9182 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9183 22, 7, // 3: case 0x16: {
9184 OPC_CheckPredicate, 85, // 5: check predicate 85
9185 OPC_Decode, 217, 7, 239, 2, // 7: decode to BGEZC64 using decoder 367
9186 // 7: }
9187 23, 0, // 12: case 0x17: {
9188 OPC_CheckPredicate, 85, // 14: check predicate 85
9189 OPC_Decode, 146, 8, 240, 2, // 16: decode to BLTZC64 using decoder 368
9190 // 16: }
9191 // 16: } // switch Inst[31:26]
9192};
9193static const uint8_t DecoderTableMips32r6_64r6_GP6432[159] = {
9194 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9195 0, 32, // 3: case 0x0: {
9196 OPC_SwitchField, 0, 11, // 5: switch Inst[10:0] {
9197 53, 6, // 8: case 0x35: {
9198 OPC_CheckPredicate, 86, // 10: check predicate 86
9199 OPC_Decode, 226, 19, 50, // 12: decode to SELEQZ64 using decoder 50
9200 // 12: }
9201 55, 6, // 16: case 0x37: {
9202 OPC_CheckPredicate, 86, // 18: check predicate 86
9203 OPC_Decode, 233, 19, 50, // 20: decode to SELNEZ64 using decoder 50
9204 // 20: }
9205 137, 8, 0, // 24: case 0x409: {
9206 OPC_CheckPredicate, 75, // 27: check predicate 75
9207 OPC_CheckField, 11, 10, 0, // 29: check Inst[20:11] == 0x0
9208 OPC_Decode, 213, 14, 51, // 33: decode to JR_HB64_R6 using decoder 51
9209 // 33: }
9210 // 33: } // switch Inst[10:0]
9211 // 33: }
9212 6, 7, // 37: case 0x6: {
9213 OPC_CheckPredicate, 85, // 39: check predicate 85
9214 OPC_Decode, 206, 7, 226, 2, // 41: decode to BGEUC64 using decoder 354
9215 // 41: }
9216 7, 7, // 46: case 0x7: {
9217 OPC_CheckPredicate, 85, // 48: check predicate 85
9218 OPC_Decode, 135, 8, 227, 2, // 50: decode to BLTUC64 using decoder 355
9219 // 50: }
9220 8, 7, // 55: case 0x8: {
9221 OPC_CheckPredicate, 85, // 57: check predicate 85
9222 OPC_Decode, 190, 7, 228, 2, // 59: decode to BEQC64 using decoder 356
9223 // 59: }
9224 22, 20, // 64: case 0x16: {
9225 OPC_Scope, 11, // 66: try {
9226 OPC_CheckField, 21, 5, 0, // 68: check Inst[25:21] == 0x0
9227 OPC_CheckPredicate, 85, // 72: check predicate 85
9228 OPC_Decode, 255, 7, 239, 2, // 74: decode to BLEZC64 using decoder 367
9229 // 74: } else try {
9230 OPC_CheckPredicate, 85, // 79: check predicate 85
9231 OPC_Decode, 203, 7, 239, 2, // 81: decode to BGEC64 using decoder 367
9232 // 81: }
9233 // 81: }
9234 23, 20, // 86: case 0x17: {
9235 OPC_Scope, 11, // 88: try {
9236 OPC_CheckField, 21, 5, 0, // 90: check Inst[25:21] == 0x0
9237 OPC_CheckPredicate, 85, // 94: check predicate 85
9238 OPC_Decode, 226, 7, 240, 2, // 96: decode to BGTZC64 using decoder 368
9239 // 96: } else try {
9240 OPC_CheckPredicate, 85, // 101: check predicate 85
9241 OPC_Decode, 132, 8, 240, 2, // 103: decode to BLTC64 using decoder 368
9242 // 103: }
9243 // 103: }
9244 24, 7, // 108: case 0x18: {
9245 OPC_CheckPredicate, 85, // 110: check predicate 85
9246 OPC_Decode, 157, 8, 241, 2, // 112: decode to BNEC64 using decoder 369
9247 // 112: }
9248 54, 19, // 117: case 0x36: {
9249 OPC_Scope, 10, // 119: try {
9250 OPC_CheckField, 21, 5, 0, // 121: check Inst[25:21] == 0x0
9251 OPC_CheckPredicate, 85, // 125: check predicate 85
9252 OPC_Decode, 202, 14, 49, // 127: decode to JIC64 using decoder 49
9253 // 127: } else try {
9254 OPC_CheckPredicate, 85, // 131: check predicate 85
9255 OPC_Decode, 198, 7, 252, 2, // 133: decode to BEQZC64 using decoder 380
9256 // 133: }
9257 // 133: }
9258 62, 0, // 138: case 0x3e: {
9259 OPC_Scope, 10, // 140: try {
9260 OPC_CheckField, 21, 5, 0, // 142: check Inst[25:21] == 0x0
9261 OPC_CheckPredicate, 85, // 146: check predicate 85
9262 OPC_Decode, 199, 14, 49, // 148: decode to JIALC64 using decoder 49
9263 // 148: } else try {
9264 OPC_CheckPredicate, 85, // 152: check predicate 85
9265 OPC_Decode, 173, 8, 252, 2, // 154: decode to BNEZC64 using decoder 380
9266 // 154: }
9267 // 154: }
9268 // 154: } // switch Inst[31:26]
9269};
9270static const uint8_t DecoderTableMips32r6_64r6_PTR6432[29] = {
9271 OPC_SwitchField, 0, 6, // 0: switch Inst[5:0] {
9272 38, 11, // 3: case 0x26: {
9273 OPC_CheckPredicate, 87, // 5: check predicate 87
9274 OPC_CheckField, 26, 6, 31, // 7: check Inst[31:26] == 0x1f
9275 OPC_Decode, 189, 19, 247, 2, // 11: decode to SC64_R6 using decoder 375
9276 // 11: }
9277 54, 0, // 16: case 0x36: {
9278 OPC_CheckPredicate, 87, // 18: check predicate 87
9279 OPC_CheckField, 26, 6, 31, // 20: check Inst[31:26] == 0x1f
9280 OPC_Decode, 153, 15, 247, 2, // 24: decode to LL64_R6 using decoder 375
9281 // 24: }
9282 // 24: } // switch Inst[5:0]
9283};
9284static const uint8_t DecoderTableMips6432[778] = {
9285 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9286 0, 163, 2, // 3: case 0x0: {
9287 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
9288 8, 10, // 9: case 0x8: {
9289 OPC_CheckPredicate, 88, // 11: check predicate 88
9290 OPC_CheckField, 6, 15, 16, // 13: check Inst[20:6] == 0x10
9291 OPC_Decode, 212, 14, 51, // 17: decode to JR_HB64 using decoder 51
9292 // 17: }
9293 9, 27, // 21: case 0x9: {
9294 OPC_SwitchField, 6, 5, // 23: switch Inst[10:6] {
9295 0, 10, // 26: case 0x0: {
9296 OPC_CheckPredicate, 89, // 28: check predicate 89
9297 OPC_CheckField, 16, 5, 0, // 30: check Inst[20:16] == 0x0
9298 OPC_Decode, 185, 14, 53, // 34: decode to JALR64 using decoder 53
9299 // 34: }
9300 16, 0, // 38: case 0x10: {
9301 OPC_CheckPredicate, 90, // 40: check predicate 90
9302 OPC_CheckField, 16, 5, 0, // 42: check Inst[20:16] == 0x0
9303 OPC_Decode, 192, 14, 53, // 46: decode to JALR_HB64 using decoder 53
9304 // 46: }
9305 // 46: } // switch Inst[10:6]
9306 // 46: }
9307 20, 11, // 50: case 0x14: {
9308 OPC_CheckPredicate, 91, // 52: check predicate 91
9309 OPC_CheckField, 6, 5, 0, // 54: check Inst[10:6] == 0x0
9310 OPC_Decode, 150, 12, 253, 2, // 58: decode to DSLLV using decoder 381
9311 // 58: }
9312 22, 21, // 63: case 0x16: {
9313 OPC_SwitchField, 6, 5, // 65: switch Inst[10:6] {
9314 0, 7, // 68: case 0x0: {
9315 OPC_CheckPredicate, 91, // 70: check predicate 91
9316 OPC_Decode, 156, 12, 253, 2, // 72: decode to DSRLV using decoder 381
9317 // 72: }
9318 1, 0, // 77: case 0x1: {
9319 OPC_CheckPredicate, 90, // 79: check predicate 90
9320 OPC_Decode, 143, 12, 253, 2, // 81: decode to DROTRV using decoder 381
9321 // 81: }
9322 // 81: } // switch Inst[10:6]
9323 // 81: }
9324 23, 11, // 86: case 0x17: {
9325 OPC_CheckPredicate, 91, // 88: check predicate 91
9326 OPC_CheckField, 6, 5, 0, // 90: check Inst[10:6] == 0x0
9327 OPC_Decode, 153, 12, 253, 2, // 94: decode to DSRAV using decoder 381
9328 // 94: }
9329 28, 11, // 99: case 0x1c: {
9330 OPC_CheckPredicate, 92, // 101: check predicate 92
9331 OPC_CheckField, 6, 10, 0, // 103: check Inst[15:6] == 0x0
9332 OPC_Decode, 214, 11, 254, 2, // 107: decode to DMULT using decoder 382
9333 // 107: }
9334 29, 11, // 112: case 0x1d: {
9335 OPC_CheckPredicate, 92, // 114: check predicate 92
9336 OPC_CheckField, 6, 10, 0, // 116: check Inst[15:6] == 0x0
9337 OPC_Decode, 215, 11, 254, 2, // 120: decode to DMULTu using decoder 382
9338 // 120: }
9339 30, 11, // 125: case 0x1e: {
9340 OPC_CheckPredicate, 92, // 127: check predicate 92
9341 OPC_CheckField, 6, 10, 0, // 129: check Inst[15:6] == 0x0
9342 OPC_Decode, 145, 12, 254, 2, // 133: decode to DSDIV using decoder 382
9343 // 133: }
9344 31, 11, // 138: case 0x1f: {
9345 OPC_CheckPredicate, 92, // 140: check predicate 92
9346 OPC_CheckField, 6, 10, 0, // 142: check Inst[15:6] == 0x0
9347 OPC_Decode, 159, 12, 254, 2, // 146: decode to DUDIV using decoder 382
9348 // 146: }
9349 44, 10, // 151: case 0x2c: {
9350 OPC_CheckPredicate, 91, // 153: check predicate 91
9351 OPC_CheckField, 6, 5, 0, // 155: check Inst[10:6] == 0x0
9352 OPC_Decode, 156, 11, 50, // 159: decode to DADD using decoder 50
9353 // 159: }
9354 45, 10, // 163: case 0x2d: {
9355 OPC_CheckPredicate, 91, // 165: check predicate 91
9356 OPC_CheckField, 6, 5, 0, // 167: check Inst[10:6] == 0x0
9357 OPC_Decode, 159, 11, 50, // 171: decode to DADDu using decoder 50
9358 // 171: }
9359 46, 10, // 175: case 0x2e: {
9360 OPC_CheckPredicate, 91, // 177: check predicate 91
9361 OPC_CheckField, 6, 5, 0, // 179: check Inst[10:6] == 0x0
9362 OPC_Decode, 157, 12, 50, // 183: decode to DSUB using decoder 50
9363 // 183: }
9364 47, 10, // 187: case 0x2f: {
9365 OPC_CheckPredicate, 91, // 189: check predicate 91
9366 OPC_CheckField, 6, 5, 0, // 191: check Inst[10:6] == 0x0
9367 OPC_Decode, 158, 12, 50, // 195: decode to DSUBu using decoder 50
9368 // 195: }
9369 56, 11, // 199: case 0x38: {
9370 OPC_CheckPredicate, 91, // 201: check predicate 91
9371 OPC_CheckField, 21, 5, 0, // 203: check Inst[25:21] == 0x0
9372 OPC_Decode, 147, 12, 255, 2, // 207: decode to DSLL using decoder 383
9373 // 207: }
9374 58, 21, // 212: case 0x3a: {
9375 OPC_SwitchField, 21, 5, // 214: switch Inst[25:21] {
9376 0, 7, // 217: case 0x0: {
9377 OPC_CheckPredicate, 91, // 219: check predicate 91
9378 OPC_Decode, 154, 12, 255, 2, // 221: decode to DSRL using decoder 383
9379 // 221: }
9380 1, 0, // 226: case 0x1: {
9381 OPC_CheckPredicate, 90, // 228: check predicate 90
9382 OPC_Decode, 141, 12, 255, 2, // 230: decode to DROTR using decoder 383
9383 // 230: }
9384 // 230: } // switch Inst[25:21]
9385 // 230: }
9386 59, 11, // 235: case 0x3b: {
9387 OPC_CheckPredicate, 91, // 237: check predicate 91
9388 OPC_CheckField, 21, 5, 0, // 239: check Inst[25:21] == 0x0
9389 OPC_Decode, 151, 12, 255, 2, // 243: decode to DSRA using decoder 383
9390 // 243: }
9391 60, 11, // 248: case 0x3c: {
9392 OPC_CheckPredicate, 91, // 250: check predicate 91
9393 OPC_CheckField, 21, 5, 0, // 252: check Inst[25:21] == 0x0
9394 OPC_Decode, 148, 12, 255, 2, // 256: decode to DSLL32 using decoder 383
9395 // 256: }
9396 62, 21, // 261: case 0x3e: {
9397 OPC_SwitchField, 21, 5, // 263: switch Inst[25:21] {
9398 0, 7, // 266: case 0x0: {
9399 OPC_CheckPredicate, 91, // 268: check predicate 91
9400 OPC_Decode, 155, 12, 255, 2, // 270: decode to DSRL32 using decoder 383
9401 // 270: }
9402 1, 0, // 275: case 0x1: {
9403 OPC_CheckPredicate, 90, // 277: check predicate 90
9404 OPC_Decode, 142, 12, 255, 2, // 279: decode to DROTR32 using decoder 383
9405 // 279: }
9406 // 279: } // switch Inst[25:21]
9407 // 279: }
9408 63, 0, // 284: case 0x3f: {
9409 OPC_CheckPredicate, 91, // 286: check predicate 91
9410 OPC_CheckField, 21, 5, 0, // 288: check Inst[25:21] == 0x0
9411 OPC_Decode, 152, 12, 255, 2, // 292: decode to DSRA32 using decoder 383
9412 // 292: }
9413 // 292: } // switch Inst[5:0]
9414 // 292: }
9415 16, 52, // 297: case 0x10: {
9416 OPC_SwitchField, 3, 8, // 299: switch Inst[10:3] {
9417 0, 21, // 302: case 0x0: {
9418 OPC_SwitchField, 21, 5, // 304: switch Inst[25:21] {
9419 1, 7, // 307: case 0x1: {
9420 OPC_CheckPredicate, 93, // 309: check predicate 93
9421 OPC_Decode, 198, 11, 128, 3, // 311: decode to DMFC0 using decoder 384
9422 // 311: }
9423 5, 0, // 316: case 0x5: {
9424 OPC_CheckPredicate, 93, // 318: check predicate 93
9425 OPC_Decode, 206, 11, 129, 3, // 320: decode to DMTC0 using decoder 385
9426 // 320: }
9427 // 320: } // switch Inst[25:21]
9428 // 320: }
9429 32, 11, // 325: case 0x20: {
9430 OPC_CheckPredicate, 94, // 327: check predicate 94
9431 OPC_CheckField, 21, 5, 3, // 329: check Inst[25:21] == 0x3
9432 OPC_Decode, 202, 11, 128, 3, // 333: decode to DMFGC0 using decoder 384
9433 // 333: }
9434 96, 0, // 338: case 0x60: {
9435 OPC_CheckPredicate, 94, // 340: check predicate 94
9436 OPC_CheckField, 21, 5, 3, // 342: check Inst[25:21] == 0x3
9437 OPC_Decode, 210, 11, 129, 3, // 346: decode to DMTGC0 using decoder 385
9438 // 346: }
9439 // 346: } // switch Inst[10:3]
9440 // 346: }
9441 18, 29, // 351: case 0x12: {
9442 OPC_SwitchField, 21, 5, // 353: switch Inst[25:21] {
9443 1, 11, // 356: case 0x1: {
9444 OPC_CheckPredicate, 93, // 358: check predicate 93
9445 OPC_CheckField, 3, 8, 0, // 360: check Inst[10:3] == 0x0
9446 OPC_Decode, 200, 11, 130, 3, // 364: decode to DMFC2 using decoder 386
9447 // 364: }
9448 5, 0, // 369: case 0x5: {
9449 OPC_CheckPredicate, 93, // 371: check predicate 93
9450 OPC_CheckField, 3, 8, 0, // 373: check Inst[10:3] == 0x0
9451 OPC_Decode, 208, 11, 131, 3, // 377: decode to DMTC2 using decoder 387
9452 // 377: }
9453 // 377: } // switch Inst[25:21]
9454 // 377: }
9455 21, 163, 1, // 382: case 0x15: {
9456 OPC_SwitchField, 0, 13, // 385: switch Inst[12:0] {
9457 188, 8, 7, // 388: case 0x43c: {
9458 OPC_CheckPredicate, 16, // 391: check predicate 16
9459 OPC_Decode, 194, 10, 132, 3, // 393: decode to C_F_D64_MM using decoder 388
9460 // 393: }
9461 252, 8, 7, // 398: case 0x47c: {
9462 OPC_CheckPredicate, 16, // 401: check predicate 16
9463 OPC_Decode, 150, 11, 132, 3, // 403: decode to C_UN_D64_MM using decoder 388
9464 // 403: }
9465 188, 9, 7, // 408: case 0x4bc: {
9466 OPC_CheckPredicate, 16, // 411: check predicate 16
9467 OPC_Decode, 188, 10, 132, 3, // 413: decode to C_EQ_D64_MM using decoder 388
9468 // 413: }
9469 252, 9, 7, // 418: case 0x4fc: {
9470 OPC_CheckPredicate, 16, // 421: check predicate 16
9471 OPC_Decode, 132, 11, 132, 3, // 423: decode to C_UEQ_D64_MM using decoder 388
9472 // 423: }
9473 188, 10, 7, // 428: case 0x53c: {
9474 OPC_CheckPredicate, 16, // 431: check predicate 16
9475 OPC_Decode, 242, 10, 132, 3, // 433: decode to C_OLT_D64_MM using decoder 388
9476 // 433: }
9477 252, 10, 7, // 438: case 0x57c: {
9478 OPC_CheckPredicate, 16, // 441: check predicate 16
9479 OPC_Decode, 144, 11, 132, 3, // 443: decode to C_ULT_D64_MM using decoder 388
9480 // 443: }
9481 188, 11, 7, // 448: case 0x5bc: {
9482 OPC_CheckPredicate, 16, // 451: check predicate 16
9483 OPC_Decode, 236, 10, 132, 3, // 453: decode to C_OLE_D64_MM using decoder 388
9484 // 453: }
9485 252, 11, 7, // 458: case 0x5fc: {
9486 OPC_CheckPredicate, 16, // 461: check predicate 16
9487 OPC_Decode, 138, 11, 132, 3, // 463: decode to C_ULE_D64_MM using decoder 388
9488 // 463: }
9489 188, 12, 7, // 468: case 0x63c: {
9490 OPC_CheckPredicate, 16, // 471: check predicate 16
9491 OPC_Decode, 254, 10, 132, 3, // 473: decode to C_SF_D64_MM using decoder 388
9492 // 473: }
9493 252, 12, 7, // 478: case 0x67c: {
9494 OPC_CheckPredicate, 16, // 481: check predicate 16
9495 OPC_Decode, 218, 10, 132, 3, // 483: decode to C_NGLE_D64_MM using decoder 388
9496 // 483: }
9497 188, 13, 7, // 488: case 0x6bc: {
9498 OPC_CheckPredicate, 16, // 491: check predicate 16
9499 OPC_Decode, 248, 10, 132, 3, // 493: decode to C_SEQ_D64_MM using decoder 388
9500 // 493: }
9501 252, 13, 7, // 498: case 0x6fc: {
9502 OPC_CheckPredicate, 16, // 501: check predicate 16
9503 OPC_Decode, 224, 10, 132, 3, // 503: decode to C_NGL_D64_MM using decoder 388
9504 // 503: }
9505 188, 14, 7, // 508: case 0x73c: {
9506 OPC_CheckPredicate, 16, // 511: check predicate 16
9507 OPC_Decode, 206, 10, 132, 3, // 513: decode to C_LT_D64_MM using decoder 388
9508 // 513: }
9509 252, 14, 7, // 518: case 0x77c: {
9510 OPC_CheckPredicate, 16, // 521: check predicate 16
9511 OPC_Decode, 212, 10, 132, 3, // 523: decode to C_NGE_D64_MM using decoder 388
9512 // 523: }
9513 188, 15, 7, // 528: case 0x7bc: {
9514 OPC_CheckPredicate, 16, // 531: check predicate 16
9515 OPC_Decode, 200, 10, 132, 3, // 533: decode to C_LE_D64_MM using decoder 388
9516 // 533: }
9517 252, 15, 0, // 538: case 0x7fc: {
9518 OPC_CheckPredicate, 16, // 541: check predicate 16
9519 OPC_Decode, 230, 10, 132, 3, // 543: decode to C_NGT_D64_MM using decoder 388
9520 // 543: }
9521 // 543: } // switch Inst[12:0]
9522 // 543: }
9523 24, 7, // 548: case 0x18: {
9524 OPC_CheckPredicate, 95, // 550: check predicate 95
9525 OPC_Decode, 157, 11, 133, 3, // 552: decode to DADDi using decoder 389
9526 // 552: }
9527 25, 7, // 557: case 0x19: {
9528 OPC_CheckPredicate, 91, // 559: check predicate 91
9529 OPC_Decode, 158, 11, 133, 3, // 561: decode to DADDiu using decoder 389
9530 // 561: }
9531 26, 7, // 566: case 0x1a: {
9532 OPC_CheckPredicate, 95, // 568: check predicate 95
9533 OPC_Decode, 252, 14, 148, 1, // 570: decode to LDL using decoder 148
9534 // 570: }
9535 27, 7, // 575: case 0x1b: {
9536 OPC_CheckPredicate, 95, // 577: check predicate 95
9537 OPC_Decode, 254, 14, 148, 1, // 579: decode to LDR using decoder 148
9538 // 579: }
9539 28, 21, // 584: case 0x1c: {
9540 OPC_SwitchField, 0, 11, // 586: switch Inst[10:0] {
9541 36, 7, // 589: case 0x24: {
9542 OPC_CheckPredicate, 96, // 591: check predicate 96
9543 OPC_Decode, 167, 11, 134, 3, // 593: decode to DCLZ using decoder 390
9544 // 593: }
9545 37, 0, // 598: case 0x25: {
9546 OPC_CheckPredicate, 96, // 600: check predicate 96
9547 OPC_Decode, 165, 11, 134, 3, // 602: decode to DCLO using decoder 390
9548 // 602: }
9549 // 602: } // switch Inst[10:0]
9550 // 602: }
9551 31, 88, // 607: case 0x1f: {
9552 OPC_SwitchField, 0, 6, // 609: switch Inst[5:0] {
9553 1, 7, // 612: case 0x1: {
9554 OPC_CheckPredicate, 90, // 614: check predicate 90
9555 OPC_Decode, 176, 11, 135, 3, // 616: decode to DEXTM using decoder 391
9556 // 616: }
9557 2, 7, // 621: case 0x2: {
9558 OPC_CheckPredicate, 90, // 623: check predicate 90
9559 OPC_Decode, 177, 11, 135, 3, // 625: decode to DEXTU using decoder 391
9560 // 625: }
9561 3, 7, // 630: case 0x3: {
9562 OPC_CheckPredicate, 90, // 632: check predicate 90
9563 OPC_Decode, 174, 11, 135, 3, // 634: decode to DEXT using decoder 391
9564 // 634: }
9565 5, 7, // 639: case 0x5: {
9566 OPC_CheckPredicate, 90, // 641: check predicate 90
9567 OPC_Decode, 180, 11, 136, 3, // 643: decode to DINSM using decoder 392
9568 // 643: }
9569 6, 7, // 648: case 0x6: {
9570 OPC_CheckPredicate, 90, // 650: check predicate 90
9571 OPC_Decode, 181, 11, 136, 3, // 652: decode to DINSU using decoder 392
9572 // 652: }
9573 7, 7, // 657: case 0x7: {
9574 OPC_CheckPredicate, 90, // 659: check predicate 90
9575 OPC_Decode, 179, 11, 136, 3, // 661: decode to DINS using decoder 392
9576 // 661: }
9577 36, 0, // 666: case 0x24: {
9578 OPC_SwitchField, 6, 5, // 668: switch Inst[10:6] {
9579 2, 11, // 671: case 0x2: {
9580 OPC_CheckPredicate, 90, // 673: check predicate 90
9581 OPC_CheckField, 21, 5, 0, // 675: check Inst[25:21] == 0x0
9582 OPC_Decode, 144, 12, 245, 2, // 679: decode to DSBH using decoder 373
9583 // 679: }
9584 5, 0, // 684: case 0x5: {
9585 OPC_CheckPredicate, 90, // 686: check predicate 90
9586 OPC_CheckField, 21, 5, 0, // 688: check Inst[25:21] == 0x0
9587 OPC_Decode, 146, 12, 245, 2, // 692: decode to DSHD using decoder 373
9588 // 692: }
9589 // 692: } // switch Inst[10:6]
9590 // 692: }
9591 // 692: } // switch Inst[5:0]
9592 // 692: }
9593 39, 7, // 697: case 0x27: {
9594 OPC_CheckPredicate, 91, // 699: check predicate 91
9595 OPC_Decode, 211, 15, 148, 1, // 701: decode to LWu using decoder 148
9596 // 701: }
9597 44, 7, // 706: case 0x2c: {
9598 OPC_CheckPredicate, 95, // 708: check predicate 95
9599 OPC_Decode, 215, 19, 148, 1, // 710: decode to SDL using decoder 148
9600 // 710: }
9601 45, 7, // 715: case 0x2d: {
9602 OPC_CheckPredicate, 95, // 717: check predicate 95
9603 OPC_Decode, 216, 19, 148, 1, // 719: decode to SDR using decoder 148
9604 // 719: }
9605 46, 7, // 724: case 0x2e: {
9606 OPC_CheckPredicate, 21, // 726: check predicate 21
9607 OPC_Decode, 208, 19, 146, 1, // 728: decode to SDC1_MM_D64 using decoder 146
9608 // 728: }
9609 47, 7, // 733: case 0x2f: {
9610 OPC_CheckPredicate, 21, // 735: check predicate 21
9611 OPC_Decode, 243, 14, 146, 1, // 737: decode to LDC1_MM_D64 using decoder 146
9612 // 737: }
9613 52, 7, // 742: case 0x34: {
9614 OPC_CheckPredicate, 92, // 744: check predicate 92
9615 OPC_Decode, 154, 15, 148, 1, // 746: decode to LLD using decoder 148
9616 // 746: }
9617 55, 7, // 751: case 0x37: {
9618 OPC_CheckPredicate, 91, // 753: check predicate 91
9619 OPC_Decode, 238, 14, 148, 1, // 755: decode to LD using decoder 148
9620 // 755: }
9621 60, 7, // 760: case 0x3c: {
9622 OPC_CheckPredicate, 97, // 762: check predicate 97
9623 OPC_Decode, 190, 19, 148, 1, // 764: decode to SCD using decoder 148
9624 // 764: }
9625 63, 0, // 769: case 0x3f: {
9626 OPC_CheckPredicate, 91, // 771: check predicate 91
9627 OPC_Decode, 197, 19, 148, 1, // 773: decode to SD using decoder 148
9628 // 773: }
9629 // 773: } // switch Inst[31:26]
9630};
9631static const uint8_t DecoderTableMipsDSP32[21] = {
9632 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9633 35, 7, // 3: case 0x23: {
9634 OPC_CheckPredicate, 98, // 5: check predicate 98
9635 OPC_Decode, 180, 15, 148, 1, // 7: decode to LWDSP using decoder 148
9636 // 7: }
9637 43, 0, // 12: case 0x2b: {
9638 OPC_CheckPredicate, 98, // 14: check predicate 98
9639 OPC_Decode, 217, 21, 148, 1, // 16: decode to SWDSP using decoder 148
9640 // 16: }
9641 // 16: } // switch Inst[31:26]
9642};
9643static const uint8_t DecoderTableMipsFP6432[1037] = {
9644 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9645 17, 152, 7, // 3: case 0x11: {
9646 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
9647 0, 73, // 9: case 0x0: {
9648 OPC_SwitchField, 21, 5, // 11: switch Inst[25:21] {
9649 0, 11, // 14: case 0x0: {
9650 OPC_CheckPredicate, 99, // 16: check predicate 99
9651 OPC_CheckField, 6, 5, 0, // 18: check Inst[10:6] == 0x0
9652 OPC_Decode, 159, 16, 137, 3, // 22: decode to MFC1_D64 using decoder 393
9653 // 22: }
9654 3, 11, // 27: case 0x3: {
9655 OPC_CheckPredicate, 100, // 29: check predicate 100
9656 OPC_CheckField, 6, 5, 0, // 31: check Inst[10:6] == 0x0
9657 OPC_Decode, 169, 16, 137, 3, // 35: decode to MFHC1_D64 using decoder 393
9658 // 35: }
9659 4, 11, // 40: case 0x4: {
9660 OPC_CheckPredicate, 99, // 42: check predicate 99
9661 OPC_CheckField, 6, 5, 0, // 44: check Inst[10:6] == 0x0
9662 OPC_Decode, 174, 17, 138, 3, // 48: decode to MTC1_D64 using decoder 394
9663 // 48: }
9664 7, 11, // 53: case 0x7: {
9665 OPC_CheckPredicate, 100, // 55: check predicate 100
9666 OPC_CheckField, 6, 5, 0, // 57: check Inst[10:6] == 0x0
9667 OPC_Decode, 185, 17, 139, 3, // 61: decode to MTHC1_D64 using decoder 395
9668 // 61: }
9669 17, 7, // 66: case 0x11: {
9670 OPC_CheckPredicate, 99, // 68: check predicate 99
9671 OPC_Decode, 218, 12, 233, 2, // 70: decode to FADD_D64 using decoder 361
9672 // 70: }
9673 22, 0, // 75: case 0x16: {
9674 OPC_CheckPredicate, 101, // 77: check predicate 101
9675 OPC_Decode, 220, 12, 233, 2, // 79: decode to FADD_PS64 using decoder 361
9676 // 79: }
9677 // 79: } // switch Inst[25:21]
9678 // 79: }
9679 1, 21, // 84: case 0x1: {
9680 OPC_SwitchField, 21, 5, // 86: switch Inst[25:21] {
9681 17, 7, // 89: case 0x11: {
9682 OPC_CheckPredicate, 99, // 91: check predicate 99
9683 OPC_Decode, 235, 13, 233, 2, // 93: decode to FSUB_D64 using decoder 361
9684 // 93: }
9685 22, 0, // 98: case 0x16: {
9686 OPC_CheckPredicate, 101, // 100: check predicate 101
9687 OPC_Decode, 237, 13, 233, 2, // 102: decode to FSUB_PS64 using decoder 361
9688 // 102: }
9689 // 102: } // switch Inst[25:21]
9690 // 102: }
9691 2, 21, // 107: case 0x2: {
9692 OPC_SwitchField, 21, 5, // 109: switch Inst[25:21] {
9693 17, 7, // 112: case 0x11: {
9694 OPC_CheckPredicate, 99, // 114: check predicate 99
9695 OPC_Decode, 191, 13, 233, 2, // 116: decode to FMUL_D64 using decoder 361
9696 // 116: }
9697 22, 0, // 121: case 0x16: {
9698 OPC_CheckPredicate, 101, // 123: check predicate 101
9699 OPC_Decode, 193, 13, 233, 2, // 125: decode to FMUL_PS64 using decoder 361
9700 // 125: }
9701 // 125: } // switch Inst[25:21]
9702 // 125: }
9703 3, 11, // 130: case 0x3: {
9704 OPC_CheckPredicate, 99, // 132: check predicate 99
9705 OPC_CheckField, 21, 5, 17, // 134: check Inst[25:21] == 0x11
9706 OPC_Decode, 129, 13, 233, 2, // 138: decode to FDIV_D64 using decoder 361
9707 // 138: }
9708 4, 12, // 143: case 0x4: {
9709 OPC_CheckPredicate, 102, // 145: check predicate 102
9710 OPC_CheckField, 16, 10, 160, 4, // 147: check Inst[25:16] == 0x220
9711 OPC_Decode, 227, 13, 232, 1, // 152: decode to FSQRT_D64 using decoder 232
9712 // 152: }
9713 5, 12, // 157: case 0x5: {
9714 OPC_CheckPredicate, 99, // 159: check predicate 99
9715 OPC_CheckField, 16, 10, 160, 4, // 161: check Inst[25:16] == 0x220
9716 OPC_Decode, 211, 12, 232, 1, // 166: decode to FABS_D64 using decoder 232
9717 // 166: }
9718 6, 12, // 171: case 0x6: {
9719 OPC_CheckPredicate, 99, // 173: check predicate 99
9720 OPC_CheckField, 16, 10, 160, 4, // 175: check Inst[25:16] == 0x220
9721 OPC_Decode, 180, 13, 232, 1, // 180: decode to FMOV_D64 using decoder 232
9722 // 180: }
9723 7, 12, // 185: case 0x7: {
9724 OPC_CheckPredicate, 99, // 187: check predicate 99
9725 OPC_CheckField, 16, 10, 160, 4, // 189: check Inst[25:16] == 0x220
9726 OPC_Decode, 200, 13, 232, 1, // 194: decode to FNEG_D64 using decoder 232
9727 // 194: }
9728 8, 23, // 199: case 0x8: {
9729 OPC_SwitchField, 16, 10, // 201: switch Inst[25:16] {
9730 128, 4, 7, // 204: case 0x200: {
9731 OPC_CheckPredicate, 102, // 207: check predicate 102
9732 OPC_Decode, 152, 19, 225, 1, // 209: decode to ROUND_L_S using decoder 225
9733 // 209: }
9734 160, 4, 0, // 214: case 0x220: {
9735 OPC_CheckPredicate, 103, // 217: check predicate 103
9736 OPC_Decode, 150, 19, 232, 1, // 219: decode to ROUND_L_D64 using decoder 232
9737 // 219: }
9738 // 219: } // switch Inst[25:16]
9739 // 219: }
9740 9, 23, // 224: case 0x9: {
9741 OPC_SwitchField, 16, 10, // 226: switch Inst[25:16] {
9742 128, 4, 7, // 229: case 0x200: {
9743 OPC_CheckPredicate, 102, // 232: check predicate 102
9744 OPC_Decode, 191, 22, 225, 1, // 234: decode to TRUNC_L_S using decoder 225
9745 // 234: }
9746 160, 4, 0, // 239: case 0x220: {
9747 OPC_CheckPredicate, 103, // 242: check predicate 103
9748 OPC_Decode, 189, 22, 232, 1, // 244: decode to TRUNC_L_D64 using decoder 232
9749 // 244: }
9750 // 244: } // switch Inst[25:16]
9751 // 244: }
9752 10, 23, // 249: case 0xa: {
9753 OPC_SwitchField, 16, 10, // 251: switch Inst[25:16] {
9754 128, 4, 7, // 254: case 0x200: {
9755 OPC_CheckPredicate, 102, // 257: check predicate 102
9756 OPC_Decode, 228, 8, 225, 1, // 259: decode to CEIL_L_S using decoder 225
9757 // 259: }
9758 160, 4, 0, // 264: case 0x220: {
9759 OPC_CheckPredicate, 103, // 267: check predicate 103
9760 OPC_Decode, 226, 8, 232, 1, // 269: decode to CEIL_L_D64 using decoder 232
9761 // 269: }
9762 // 269: } // switch Inst[25:16]
9763 // 269: }
9764 11, 23, // 274: case 0xb: {
9765 OPC_SwitchField, 16, 10, // 276: switch Inst[25:16] {
9766 128, 4, 7, // 279: case 0x200: {
9767 OPC_CheckPredicate, 102, // 282: check predicate 102
9768 OPC_Decode, 159, 13, 225, 1, // 284: decode to FLOOR_L_S using decoder 225
9769 // 284: }
9770 160, 4, 0, // 289: case 0x220: {
9771 OPC_CheckPredicate, 103, // 292: check predicate 103
9772 OPC_Decode, 157, 13, 232, 1, // 294: decode to FLOOR_L_D64 using decoder 232
9773 // 294: }
9774 // 294: } // switch Inst[25:16]
9775 // 294: }
9776 12, 12, // 299: case 0xc: {
9777 OPC_CheckPredicate, 102, // 301: check predicate 102
9778 OPC_CheckField, 16, 10, 160, 4, // 303: check Inst[25:16] == 0x220
9779 OPC_Decode, 155, 19, 140, 3, // 308: decode to ROUND_W_D64 using decoder 396
9780 // 308: }
9781 13, 12, // 313: case 0xd: {
9782 OPC_CheckPredicate, 102, // 315: check predicate 102
9783 OPC_CheckField, 16, 10, 160, 4, // 317: check Inst[25:16] == 0x220
9784 OPC_Decode, 194, 22, 140, 3, // 322: decode to TRUNC_W_D64 using decoder 396
9785 // 322: }
9786 14, 12, // 327: case 0xe: {
9787 OPC_CheckPredicate, 102, // 329: check predicate 102
9788 OPC_CheckField, 16, 10, 160, 4, // 331: check Inst[25:16] == 0x220
9789 OPC_Decode, 231, 8, 140, 3, // 336: decode to CEIL_W_D64 using decoder 396
9790 // 336: }
9791 15, 12, // 341: case 0xf: {
9792 OPC_CheckPredicate, 102, // 343: check predicate 102
9793 OPC_CheckField, 16, 10, 160, 4, // 345: check Inst[25:16] == 0x220
9794 OPC_Decode, 162, 13, 140, 3, // 350: decode to FLOOR_W_D64 using decoder 396
9795 // 350: }
9796 17, 29, // 355: case 0x11: {
9797 OPC_SwitchField, 16, 2, // 357: switch Inst[17:16] {
9798 0, 11, // 360: case 0x0: {
9799 OPC_CheckPredicate, 104, // 362: check predicate 104
9800 OPC_CheckField, 21, 5, 17, // 364: check Inst[25:21] == 0x11
9801 OPC_Decode, 236, 16, 141, 3, // 368: decode to MOVF_D64 using decoder 397
9802 // 368: }
9803 1, 0, // 373: case 0x1: {
9804 OPC_CheckPredicate, 104, // 375: check predicate 104
9805 OPC_CheckField, 21, 5, 17, // 377: check Inst[25:21] == 0x11
9806 OPC_Decode, 128, 17, 141, 3, // 381: decode to MOVT_D64 using decoder 397
9807 // 381: }
9808 // 381: } // switch Inst[17:16]
9809 // 381: }
9810 18, 11, // 386: case 0x12: {
9811 OPC_CheckPredicate, 104, // 388: check predicate 104
9812 OPC_CheckField, 21, 5, 17, // 390: check Inst[25:21] == 0x11
9813 OPC_Decode, 140, 17, 142, 3, // 394: decode to MOVZ_I_D64 using decoder 398
9814 // 394: }
9815 19, 11, // 399: case 0x13: {
9816 OPC_CheckPredicate, 104, // 401: check predicate 104
9817 OPC_CheckField, 21, 5, 17, // 403: check Inst[25:21] == 0x11
9818 OPC_Decode, 248, 16, 142, 3, // 407: decode to MOVN_I_D64 using decoder 398
9819 // 407: }
9820 21, 12, // 412: case 0x15: {
9821 OPC_CheckPredicate, 105, // 414: check predicate 105
9822 OPC_CheckField, 16, 10, 160, 4, // 416: check Inst[25:16] == 0x220
9823 OPC_Decode, 130, 19, 232, 1, // 421: decode to RECIP_D64 using decoder 232
9824 // 421: }
9825 22, 12, // 426: case 0x16: {
9826 OPC_CheckPredicate, 105, // 428: check predicate 105
9827 OPC_CheckField, 16, 10, 160, 4, // 430: check Inst[25:16] == 0x220
9828 OPC_Decode, 163, 19, 232, 1, // 435: decode to RSQRT_D64 using decoder 232
9829 // 435: }
9830 24, 11, // 440: case 0x18: {
9831 OPC_CheckPredicate, 106, // 442: check predicate 106
9832 OPC_CheckField, 21, 5, 22, // 444: check Inst[25:21] == 0x16
9833 OPC_Decode, 170, 6, 233, 2, // 448: decode to ADDR_PS64 using decoder 361
9834 // 448: }
9835 26, 11, // 453: case 0x1a: {
9836 OPC_CheckPredicate, 106, // 455: check predicate 106
9837 OPC_CheckField, 21, 5, 22, // 457: check Inst[25:21] == 0x16
9838 OPC_Decode, 230, 17, 233, 2, // 461: decode to MULR_PS64 using decoder 361
9839 // 461: }
9840 32, 33, // 466: case 0x20: {
9841 OPC_SwitchField, 16, 10, // 468: switch Inst[25:16] {
9842 160, 4, 7, // 471: case 0x220: {
9843 OPC_CheckPredicate, 99, // 474: check predicate 99
9844 OPC_Decode, 169, 10, 140, 3, // 476: decode to CVT_S_D64 using decoder 396
9845 // 476: }
9846 160, 5, 7, // 481: case 0x2a0: {
9847 OPC_CheckPredicate, 107, // 484: check predicate 107
9848 OPC_Decode, 171, 10, 140, 3, // 486: decode to CVT_S_L using decoder 396
9849 // 486: }
9850 192, 5, 0, // 491: case 0x2c0: {
9851 OPC_CheckPredicate, 101, // 494: check predicate 101
9852 OPC_Decode, 174, 10, 140, 3, // 496: decode to CVT_S_PU64 using decoder 396
9853 // 496: }
9854 // 496: } // switch Inst[25:16]
9855 // 496: }
9856 33, 33, // 501: case 0x21: {
9857 OPC_SwitchField, 16, 10, // 503: switch Inst[25:16] {
9858 128, 4, 7, // 506: case 0x200: {
9859 OPC_CheckPredicate, 99, // 509: check predicate 99
9860 OPC_Decode, 153, 10, 225, 1, // 511: decode to CVT_D64_S using decoder 225
9861 // 511: }
9862 128, 5, 7, // 516: case 0x280: {
9863 OPC_CheckPredicate, 99, // 519: check predicate 99
9864 OPC_Decode, 155, 10, 225, 1, // 521: decode to CVT_D64_W using decoder 225
9865 // 521: }
9866 160, 5, 0, // 526: case 0x2a0: {
9867 OPC_CheckPredicate, 107, // 529: check predicate 107
9868 OPC_Decode, 152, 10, 232, 1, // 531: decode to CVT_D64_L using decoder 232
9869 // 531: }
9870 // 531: } // switch Inst[25:16]
9871 // 531: }
9872 36, 23, // 536: case 0x24: {
9873 OPC_SwitchField, 16, 10, // 538: switch Inst[25:16] {
9874 160, 4, 7, // 541: case 0x220: {
9875 OPC_CheckPredicate, 99, // 544: check predicate 99
9876 OPC_Decode, 180, 10, 140, 3, // 546: decode to CVT_W_D64 using decoder 396
9877 // 546: }
9878 192, 5, 0, // 551: case 0x2c0: {
9879 OPC_CheckPredicate, 106, // 554: check predicate 106
9880 OPC_Decode, 166, 10, 232, 1, // 556: decode to CVT_PW_PS64 using decoder 232
9881 // 556: }
9882 // 556: } // switch Inst[25:16]
9883 // 556: }
9884 38, 25, // 561: case 0x26: {
9885 OPC_SwitchField, 21, 5, // 563: switch Inst[25:21] {
9886 16, 7, // 566: case 0x10: {
9887 OPC_CheckPredicate, 101, // 568: check predicate 101
9888 OPC_Decode, 165, 10, 143, 3, // 570: decode to CVT_PS_S64 using decoder 399
9889 // 570: }
9890 20, 0, // 575: case 0x14: {
9891 OPC_CheckPredicate, 106, // 577: check predicate 106
9892 OPC_CheckField, 16, 5, 0, // 579: check Inst[20:16] == 0x0
9893 OPC_Decode, 164, 10, 232, 1, // 583: decode to CVT_PS_PW64 using decoder 232
9894 // 583: }
9895 // 583: } // switch Inst[25:21]
9896 // 583: }
9897 40, 12, // 588: case 0x28: {
9898 OPC_CheckPredicate, 101, // 590: check predicate 101
9899 OPC_CheckField, 16, 10, 192, 5, // 592: check Inst[25:16] == 0x2c0
9900 OPC_Decode, 173, 10, 140, 3, // 597: decode to CVT_S_PL64 using decoder 396
9901 // 597: }
9902 44, 11, // 602: case 0x2c: {
9903 OPC_CheckPredicate, 101, // 604: check predicate 101
9904 OPC_CheckField, 21, 5, 22, // 606: check Inst[25:21] == 0x16
9905 OPC_Decode, 199, 18, 233, 2, // 610: decode to PLL_PS64 using decoder 361
9906 // 610: }
9907 45, 11, // 615: case 0x2d: {
9908 OPC_CheckPredicate, 101, // 617: check predicate 101
9909 OPC_CheckField, 21, 5, 22, // 619: check Inst[25:21] == 0x16
9910 OPC_Decode, 200, 18, 233, 2, // 623: decode to PLU_PS64 using decoder 361
9911 // 623: }
9912 46, 11, // 628: case 0x2e: {
9913 OPC_CheckPredicate, 101, // 630: check predicate 101
9914 OPC_CheckField, 21, 5, 22, // 632: check Inst[25:21] == 0x16
9915 OPC_Decode, 245, 18, 233, 2, // 636: decode to PUL_PS64 using decoder 361
9916 // 636: }
9917 47, 11, // 641: case 0x2f: {
9918 OPC_CheckPredicate, 101, // 643: check predicate 101
9919 OPC_CheckField, 21, 5, 22, // 645: check Inst[25:21] == 0x16
9920 OPC_Decode, 246, 18, 233, 2, // 649: decode to PUU_PS64 using decoder 361
9921 // 649: }
9922 48, 15, // 654: case 0x30: {
9923 OPC_CheckPredicate, 108, // 656: check predicate 108
9924 OPC_CheckField, 21, 5, 17, // 658: check Inst[25:21] == 0x11
9925 OPC_CheckField, 6, 2, 0, // 662: check Inst[7:6] == 0x0
9926 OPC_Decode, 193, 10, 144, 3, // 666: decode to C_F_D64 using decoder 400
9927 // 666: }
9928 49, 15, // 671: case 0x31: {
9929 OPC_CheckPredicate, 108, // 673: check predicate 108
9930 OPC_CheckField, 21, 5, 17, // 675: check Inst[25:21] == 0x11
9931 OPC_CheckField, 6, 2, 0, // 679: check Inst[7:6] == 0x0
9932 OPC_Decode, 149, 11, 144, 3, // 683: decode to C_UN_D64 using decoder 400
9933 // 683: }
9934 50, 15, // 688: case 0x32: {
9935 OPC_CheckPredicate, 108, // 690: check predicate 108
9936 OPC_CheckField, 21, 5, 17, // 692: check Inst[25:21] == 0x11
9937 OPC_CheckField, 6, 2, 0, // 696: check Inst[7:6] == 0x0
9938 OPC_Decode, 187, 10, 144, 3, // 700: decode to C_EQ_D64 using decoder 400
9939 // 700: }
9940 51, 15, // 705: case 0x33: {
9941 OPC_CheckPredicate, 108, // 707: check predicate 108
9942 OPC_CheckField, 21, 5, 17, // 709: check Inst[25:21] == 0x11
9943 OPC_CheckField, 6, 2, 0, // 713: check Inst[7:6] == 0x0
9944 OPC_Decode, 131, 11, 144, 3, // 717: decode to C_UEQ_D64 using decoder 400
9945 // 717: }
9946 52, 15, // 722: case 0x34: {
9947 OPC_CheckPredicate, 108, // 724: check predicate 108
9948 OPC_CheckField, 21, 5, 17, // 726: check Inst[25:21] == 0x11
9949 OPC_CheckField, 6, 2, 0, // 730: check Inst[7:6] == 0x0
9950 OPC_Decode, 241, 10, 144, 3, // 734: decode to C_OLT_D64 using decoder 400
9951 // 734: }
9952 53, 15, // 739: case 0x35: {
9953 OPC_CheckPredicate, 108, // 741: check predicate 108
9954 OPC_CheckField, 21, 5, 17, // 743: check Inst[25:21] == 0x11
9955 OPC_CheckField, 6, 2, 0, // 747: check Inst[7:6] == 0x0
9956 OPC_Decode, 143, 11, 144, 3, // 751: decode to C_ULT_D64 using decoder 400
9957 // 751: }
9958 54, 15, // 756: case 0x36: {
9959 OPC_CheckPredicate, 108, // 758: check predicate 108
9960 OPC_CheckField, 21, 5, 17, // 760: check Inst[25:21] == 0x11
9961 OPC_CheckField, 6, 2, 0, // 764: check Inst[7:6] == 0x0
9962 OPC_Decode, 235, 10, 144, 3, // 768: decode to C_OLE_D64 using decoder 400
9963 // 768: }
9964 55, 15, // 773: case 0x37: {
9965 OPC_CheckPredicate, 108, // 775: check predicate 108
9966 OPC_CheckField, 21, 5, 17, // 777: check Inst[25:21] == 0x11
9967 OPC_CheckField, 6, 2, 0, // 781: check Inst[7:6] == 0x0
9968 OPC_Decode, 137, 11, 144, 3, // 785: decode to C_ULE_D64 using decoder 400
9969 // 785: }
9970 56, 15, // 790: case 0x38: {
9971 OPC_CheckPredicate, 108, // 792: check predicate 108
9972 OPC_CheckField, 21, 5, 17, // 794: check Inst[25:21] == 0x11
9973 OPC_CheckField, 6, 2, 0, // 798: check Inst[7:6] == 0x0
9974 OPC_Decode, 253, 10, 144, 3, // 802: decode to C_SF_D64 using decoder 400
9975 // 802: }
9976 57, 15, // 807: case 0x39: {
9977 OPC_CheckPredicate, 108, // 809: check predicate 108
9978 OPC_CheckField, 21, 5, 17, // 811: check Inst[25:21] == 0x11
9979 OPC_CheckField, 6, 2, 0, // 815: check Inst[7:6] == 0x0
9980 OPC_Decode, 217, 10, 144, 3, // 819: decode to C_NGLE_D64 using decoder 400
9981 // 819: }
9982 58, 15, // 824: case 0x3a: {
9983 OPC_CheckPredicate, 108, // 826: check predicate 108
9984 OPC_CheckField, 21, 5, 17, // 828: check Inst[25:21] == 0x11
9985 OPC_CheckField, 6, 2, 0, // 832: check Inst[7:6] == 0x0
9986 OPC_Decode, 247, 10, 144, 3, // 836: decode to C_SEQ_D64 using decoder 400
9987 // 836: }
9988 59, 15, // 841: case 0x3b: {
9989 OPC_CheckPredicate, 108, // 843: check predicate 108
9990 OPC_CheckField, 21, 5, 17, // 845: check Inst[25:21] == 0x11
9991 OPC_CheckField, 6, 2, 0, // 849: check Inst[7:6] == 0x0
9992 OPC_Decode, 223, 10, 144, 3, // 853: decode to C_NGL_D64 using decoder 400
9993 // 853: }
9994 60, 15, // 858: case 0x3c: {
9995 OPC_CheckPredicate, 108, // 860: check predicate 108
9996 OPC_CheckField, 21, 5, 17, // 862: check Inst[25:21] == 0x11
9997 OPC_CheckField, 6, 2, 0, // 866: check Inst[7:6] == 0x0
9998 OPC_Decode, 205, 10, 144, 3, // 870: decode to C_LT_D64 using decoder 400
9999 // 870: }
10000 61, 15, // 875: case 0x3d: {
10001 OPC_CheckPredicate, 108, // 877: check predicate 108
10002 OPC_CheckField, 21, 5, 17, // 879: check Inst[25:21] == 0x11
10003 OPC_CheckField, 6, 2, 0, // 883: check Inst[7:6] == 0x0
10004 OPC_Decode, 211, 10, 144, 3, // 887: decode to C_NGE_D64 using decoder 400
10005 // 887: }
10006 62, 15, // 892: case 0x3e: {
10007 OPC_CheckPredicate, 108, // 894: check predicate 108
10008 OPC_CheckField, 21, 5, 17, // 896: check Inst[25:21] == 0x11
10009 OPC_CheckField, 6, 2, 0, // 900: check Inst[7:6] == 0x0
10010 OPC_Decode, 199, 10, 144, 3, // 904: decode to C_LE_D64 using decoder 400
10011 // 904: }
10012 63, 0, // 909: case 0x3f: {
10013 OPC_CheckPredicate, 108, // 911: check predicate 108
10014 OPC_CheckField, 21, 5, 17, // 913: check Inst[25:21] == 0x11
10015 OPC_CheckField, 6, 2, 0, // 917: check Inst[7:6] == 0x0
10016 OPC_Decode, 229, 10, 144, 3, // 921: decode to C_NGT_D64 using decoder 400
10017 // 921: }
10018 // 921: } // switch Inst[5:0]
10019 // 921: }
10020 19, 91, // 926: case 0x13: {
10021 OPC_SwitchField, 0, 6, // 928: switch Inst[5:0] {
10022 1, 11, // 931: case 0x1: {
10023 OPC_CheckPredicate, 109, // 933: check predicate 109
10024 OPC_CheckField, 11, 5, 0, // 935: check Inst[15:11] == 0x0
10025 OPC_Decode, 128, 15, 145, 3, // 939: decode to LDXC164 using decoder 401
10026 // 939: }
10027 5, 11, // 944: case 0x5: {
10028 OPC_CheckPredicate, 110, // 946: check predicate 110
10029 OPC_CheckField, 11, 5, 0, // 948: check Inst[15:11] == 0x0
10030 OPC_Decode, 166, 15, 145, 3, // 952: decode to LUXC164 using decoder 401
10031 // 952: }
10032 9, 11, // 957: case 0x9: {
10033 OPC_CheckPredicate, 109, // 959: check predicate 109
10034 OPC_CheckField, 6, 5, 0, // 961: check Inst[10:6] == 0x0
10035 OPC_Decode, 218, 19, 146, 3, // 965: decode to SDXC164 using decoder 402
10036 // 965: }
10037 13, 11, // 970: case 0xd: {
10038 OPC_CheckPredicate, 110, // 972: check predicate 110
10039 OPC_CheckField, 6, 5, 0, // 974: check Inst[10:6] == 0x0
10040 OPC_Decode, 205, 21, 146, 3, // 978: decode to SUXC164 using decoder 402
10041 // 978: }
10042 33, 7, // 983: case 0x21: {
10043 OPC_CheckPredicate, 111, // 985: check predicate 111
10044 OPC_Decode, 240, 15, 147, 3, // 987: decode to MADD_D64 using decoder 403
10045 // 987: }
10046 41, 7, // 992: case 0x29: {
10047 OPC_CheckPredicate, 111, // 994: check predicate 111
10048 OPC_Decode, 163, 17, 147, 3, // 996: decode to MSUB_D64 using decoder 403
10049 // 996: }
10050 49, 7, // 1001: case 0x31: {
10051 OPC_CheckPredicate, 112, // 1003: check predicate 112
10052 OPC_Decode, 147, 18, 147, 3, // 1005: decode to NMADD_D64 using decoder 403
10053 // 1005: }
10054 57, 0, // 1010: case 0x39: {
10055 OPC_CheckPredicate, 112, // 1012: check predicate 112
10056 OPC_Decode, 152, 18, 147, 3, // 1014: decode to NMSUB_D64 using decoder 403
10057 // 1014: }
10058 // 1014: } // switch Inst[5:0]
10059 // 1014: }
10060 53, 7, // 1019: case 0x35: {
10061 OPC_CheckPredicate, 102, // 1021: check predicate 102
10062 OPC_Decode, 240, 14, 222, 2, // 1023: decode to LDC164 using decoder 350
10063 // 1023: }
10064 61, 0, // 1028: case 0x3d: {
10065 OPC_CheckPredicate, 102, // 1030: check predicate 102
10066 OPC_Decode, 205, 19, 222, 2, // 1032: decode to SDC164 using decoder 350
10067 // 1032: }
10068 // 1032: } // switch Inst[31:26]
10069};
10070// Handling 404 cases.
10071template <typename InsnType>
10072static DecodeStatus decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
10073 DecodeComplete = true;
10074 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
10075 TmpType tmp;
10076 switch (Idx) {
10077 default: llvm_unreachable("Invalid decoder index!");
10078 case 0:
10079 tmp = fieldFromInstruction(insn, 0, 11);
10080 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10081 return S;
10082 case 1:
10083 tmp = fieldFromInstruction(insn, 8, 3);
10084 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10085 tmp = fieldFromInstruction(insn, 0, 8);
10086 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10087 return S;
10088 case 2:
10089 tmp = fieldFromInstruction(insn, 8, 3);
10090 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10091 tmp = fieldFromInstruction(insn, 8, 3);
10092 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10093 tmp = fieldFromInstruction(insn, 0, 8);
10094 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10095 return S;
10096 case 3:
10097 tmp = fieldFromInstruction(insn, 8, 3);
10098 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10099 tmp = fieldFromInstruction(insn, 0, 8);
10100 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10101 return S;
10102 case 4:
10103 tmp = fieldFromInstruction(insn, 0, 8);
10104 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10105 return S;
10106 case 5:
10107 tmp = 0x0;
10108 tmp |= fieldFromInstruction(insn, 3, 2) << 3;
10109 tmp |= fieldFromInstruction(insn, 5, 3);
10110 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10111 tmp = fieldFromInstruction(insn, 0, 3);
10112 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10113 return S;
10114 case 6:
10115 tmp = fieldFromInstruction(insn, 4, 4);
10116 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10117 tmp = fieldFromInstruction(insn, 0, 4);
10118 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10119 return S;
10120 case 7:
10121 tmp = fieldFromInstruction(insn, 8, 3);
10122 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10123 tmp = fieldFromInstruction(insn, 0, 8);
10124 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10125 return S;
10126 case 8:
10127 tmp = fieldFromInstruction(insn, 2, 3);
10128 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10129 tmp = fieldFromInstruction(insn, 8, 3);
10130 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10131 tmp = fieldFromInstruction(insn, 5, 3);
10132 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10133 return S;
10134 case 9:
10135 tmp = fieldFromInstruction(insn, 8, 3);
10136 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10137 return S;
10138 case 10:
10139 return S;
10140 case 11:
10141 tmp = fieldFromInstruction(insn, 8, 3);
10142 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10143 tmp = fieldFromInstruction(insn, 5, 3);
10144 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10145 return S;
10146 case 12:
10147 tmp = fieldFromInstruction(insn, 8, 3);
10148 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10149 tmp = fieldFromInstruction(insn, 8, 3);
10150 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10151 tmp = fieldFromInstruction(insn, 5, 3);
10152 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10153 return S;
10154 case 13:
10155 tmp = fieldFromInstruction(insn, 8, 3);
10156 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10157 tmp = fieldFromInstruction(insn, 8, 3);
10158 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10159 return S;
10160 case 14:
10161 tmp = fieldFromInstruction(insn, 7, 3);
10162 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10163 tmp = fieldFromInstruction(insn, 1, 3);
10164 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10165 tmp = fieldFromInstruction(insn, 4, 3);
10166 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10167 return S;
10168 case 15:
10169 if (!Check(S, DecodeMemMMImm4(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10170 return S;
10171 case 16:
10172 tmp = fieldFromInstruction(insn, 5, 5);
10173 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10174 tmp = fieldFromInstruction(insn, 0, 5);
10175 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10176 return S;
10177 case 17:
10178 tmp = fieldFromInstruction(insn, 7, 3);
10179 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10180 tmp = fieldFromInstruction(insn, 4, 3);
10181 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10182 tmp = fieldFromInstruction(insn, 1, 3);
10183 if (!Check(S, DecodePOOL16BEncodedField(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10184 return S;
10185 case 18:
10186 tmp = fieldFromInstruction(insn, 7, 3);
10187 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10188 tmp = fieldFromInstruction(insn, 4, 3);
10189 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10190 tmp = fieldFromInstruction(insn, 0, 4);
10191 if (!Check(S, DecodeANDI16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10192 return S;
10193 case 19:
10194 tmp = fieldFromInstruction(insn, 3, 3);
10195 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10196 tmp = fieldFromInstruction(insn, 0, 3);
10197 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10198 return S;
10199 case 20:
10200 tmp = fieldFromInstruction(insn, 3, 3);
10201 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10202 tmp = fieldFromInstruction(insn, 0, 3);
10203 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10204 tmp = fieldFromInstruction(insn, 3, 3);
10205 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10206 return S;
10207 case 21:
10208 if (!Check(S, DecodeMemMMReglistImm4Lsl2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10209 return S;
10210 case 22:
10211 tmp = fieldFromInstruction(insn, 0, 5);
10212 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10213 return S;
10214 case 23:
10215 tmp = fieldFromInstruction(insn, 0, 4);
10216 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10217 return S;
10218 case 24:
10219 tmp = fieldFromInstruction(insn, 0, 5);
10220 if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10221 return S;
10222 case 25:
10223 if (!Check(S, DecodeMemMMSPImm5Lsl2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10224 return S;
10225 case 26:
10226 tmp = fieldFromInstruction(insn, 5, 5);
10227 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10228 tmp = fieldFromInstruction(insn, 5, 5);
10229 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10230 tmp = fieldFromInstruction(insn, 1, 4);
10231 if (!Check(S, DecodeSImmWithOffsetAndScale<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10232 return S;
10233 case 27:
10234 tmp = fieldFromInstruction(insn, 1, 9);
10235 if (!Check(S, DecodeSimm9SP(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10236 return S;
10237 case 28:
10238 if (!Check(S, DecodeMemMMGPImm7Lsl2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10239 return S;
10240 case 29:
10241 tmp = fieldFromInstruction(insn, 7, 3);
10242 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10243 tmp = fieldFromInstruction(insn, 4, 3);
10244 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10245 tmp = fieldFromInstruction(insn, 1, 3);
10246 if (!Check(S, DecodeAddiur2Simm7(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10247 return S;
10248 case 30:
10249 tmp = fieldFromInstruction(insn, 7, 3);
10250 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10251 tmp = fieldFromInstruction(insn, 1, 6);
10252 if (!Check(S, DecodeUImmWithOffsetAndScale<6, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10253 return S;
10254 case 31:
10255 if (!Check(S, DecodeMovePOperands(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10256 return S;
10257 case 32:
10258 tmp = fieldFromInstruction(insn, 7, 3);
10259 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10260 tmp = fieldFromInstruction(insn, 0, 7);
10261 if (!Check(S, DecodeBranchTarget7MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10262 return S;
10263 case 33:
10264 tmp = fieldFromInstruction(insn, 0, 10);
10265 if (!Check(S, DecodeBranchTarget10MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10266 return S;
10267 case 34:
10268 tmp = fieldFromInstruction(insn, 7, 3);
10269 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10270 tmp = fieldFromInstruction(insn, 0, 7);
10271 if (!Check(S, DecodeLi16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10272 return S;
10273 case 35:
10274 tmp = fieldFromInstruction(insn, 1, 3);
10275 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10276 tmp = fieldFromInstruction(insn, 7, 3);
10277 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10278 tmp = fieldFromInstruction(insn, 4, 3);
10279 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10280 return S;
10281 case 36:
10282 tmp = fieldFromInstruction(insn, 7, 3);
10283 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10284 tmp = fieldFromInstruction(insn, 4, 3);
10285 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10286 return S;
10287 case 37:
10288 tmp = fieldFromInstruction(insn, 7, 3);
10289 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10290 tmp = fieldFromInstruction(insn, 4, 3);
10291 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10292 tmp = fieldFromInstruction(insn, 7, 3);
10293 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10294 return S;
10295 case 38:
10296 tmp = fieldFromInstruction(insn, 5, 5);
10297 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10298 return S;
10299 case 39:
10300 tmp = fieldFromInstruction(insn, 5, 5);
10301 if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10302 return S;
10303 case 40:
10304 tmp = fieldFromInstruction(insn, 6, 4);
10305 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10306 return S;
10307 case 41:
10308 tmp = fieldFromInstruction(insn, 8, 3);
10309 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10310 tmp = 0x0;
10311 tmp |= fieldFromInstruction(insn, 0, 5);
10312 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
10313 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
10314 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10315 return S;
10316 case 42:
10317 tmp = 0x0;
10318 tmp |= fieldFromInstruction(insn, 0, 5);
10319 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
10320 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
10321 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10322 return S;
10323 case 43:
10324 tmp = fieldFromInstruction(insn, 8, 3);
10325 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10326 tmp = 0x0;
10327 tmp |= fieldFromInstruction(insn, 0, 5);
10328 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
10329 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
10330 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10331 return S;
10332 case 44:
10333 tmp = fieldFromInstruction(insn, 8, 3);
10334 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10335 tmp = fieldFromInstruction(insn, 5, 3);
10336 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10337 tmp = 0x0;
10338 tmp |= fieldFromInstruction(insn, 21, 1) << 5;
10339 tmp |= fieldFromInstruction(insn, 22, 5);
10340 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10341 return S;
10342 case 45:
10343 tmp = 0x0;
10344 tmp |= fieldFromInstruction(insn, 0, 5);
10345 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
10346 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
10347 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10348 return S;
10349 case 46:
10350 if (!Check(S, DecodeFIXMEInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10351 return S;
10352 case 47:
10353 tmp = fieldFromInstruction(insn, 8, 3);
10354 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10355 tmp = 0x0;
10356 tmp |= fieldFromInstruction(insn, 0, 5);
10357 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
10358 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
10359 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10360 return S;
10361 case 48:
10362 if (!Check(S, DecodeFMem3(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10363 return S;
10364 case 49:
10365 tmp = fieldFromInstruction(insn, 16, 5);
10366 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10367 tmp = fieldFromInstruction(insn, 0, 16);
10368 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10369 return S;
10370 case 50:
10371 tmp = fieldFromInstruction(insn, 11, 5);
10372 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10373 tmp = fieldFromInstruction(insn, 21, 5);
10374 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10375 tmp = fieldFromInstruction(insn, 16, 5);
10376 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10377 return S;
10378 case 51:
10379 tmp = fieldFromInstruction(insn, 21, 5);
10380 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10381 return S;
10382 case 52:
10383 tmp = fieldFromInstruction(insn, 11, 5);
10384 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10385 tmp = fieldFromInstruction(insn, 21, 5);
10386 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10387 return S;
10388 case 53:
10389 tmp = fieldFromInstruction(insn, 11, 5);
10390 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10391 tmp = fieldFromInstruction(insn, 21, 5);
10392 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10393 return S;
10394 case 54:
10395 tmp = fieldFromInstruction(insn, 16, 5);
10396 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10397 tmp = fieldFromInstruction(insn, 21, 5);
10398 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10399 tmp = fieldFromInstruction(insn, 6, 10);
10400 if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10401 return S;
10402 case 55:
10403 tmp = fieldFromInstruction(insn, 16, 5);
10404 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10405 tmp = fieldFromInstruction(insn, 21, 5);
10406 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10407 tmp = fieldFromInstruction(insn, 6, 5);
10408 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10409 tmp = fieldFromInstruction(insn, 11, 5);
10410 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10411 return S;
10412 case 56:
10413 tmp = fieldFromInstruction(insn, 21, 5);
10414 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10415 tmp = fieldFromInstruction(insn, 16, 5);
10416 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10417 tmp = fieldFromInstruction(insn, 0, 16);
10418 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10419 return S;
10420 case 57:
10421 tmp = fieldFromInstruction(insn, 16, 5);
10422 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10423 tmp = fieldFromInstruction(insn, 21, 5);
10424 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10425 return S;
10426 case 58:
10427 tmp = fieldFromInstruction(insn, 21, 5);
10428 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10429 tmp = fieldFromInstruction(insn, 16, 5);
10430 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10431 tmp = fieldFromInstruction(insn, 11, 5);
10432 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10433 return S;
10434 case 59:
10435 tmp = fieldFromInstruction(insn, 16, 5);
10436 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10437 tmp = fieldFromInstruction(insn, 21, 5);
10438 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10439 return S;
10440 case 60:
10441 tmp = fieldFromInstruction(insn, 11, 5);
10442 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10443 tmp = fieldFromInstruction(insn, 16, 5);
10444 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10445 tmp = fieldFromInstruction(insn, 21, 5);
10446 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10447 return S;
10448 case 61:
10449 tmp = fieldFromInstruction(insn, 11, 5);
10450 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10451 tmp = fieldFromInstruction(insn, 16, 5);
10452 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10453 tmp = fieldFromInstruction(insn, 21, 5);
10454 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10455 return S;
10456 case 62:
10457 tmp = fieldFromInstruction(insn, 16, 10);
10458 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10459 tmp = fieldFromInstruction(insn, 6, 10);
10460 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10461 return S;
10462 case 63:
10463 tmp = fieldFromInstruction(insn, 21, 5);
10464 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10465 tmp = fieldFromInstruction(insn, 16, 5);
10466 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10467 tmp = fieldFromInstruction(insn, 6, 5);
10468 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10469 tmp = fieldFromInstruction(insn, 11, 5);
10470 if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10471 tmp = fieldFromInstruction(insn, 21, 5);
10472 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10473 return S;
10474 case 64:
10475 tmp = fieldFromInstruction(insn, 11, 5);
10476 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10477 tmp = fieldFromInstruction(insn, 16, 5);
10478 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10479 tmp = fieldFromInstruction(insn, 21, 5);
10480 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10481 return S;
10482 case 65:
10483 tmp = fieldFromInstruction(insn, 11, 5);
10484 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10485 tmp = fieldFromInstruction(insn, 21, 5);
10486 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10487 tmp = fieldFromInstruction(insn, 16, 5);
10488 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10489 return S;
10490 case 66:
10491 tmp = fieldFromInstruction(insn, 21, 5);
10492 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10493 tmp = fieldFromInstruction(insn, 16, 5);
10494 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10495 tmp = fieldFromInstruction(insn, 11, 5);
10496 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10497 tmp = fieldFromInstruction(insn, 21, 5);
10498 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10499 return S;
10500 case 67:
10501 tmp = fieldFromInstruction(insn, 11, 5);
10502 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10503 tmp = fieldFromInstruction(insn, 21, 5);
10504 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10505 tmp = fieldFromInstruction(insn, 16, 5);
10506 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10507 return S;
10508 case 68:
10509 tmp = fieldFromInstruction(insn, 21, 5);
10510 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10511 tmp = fieldFromInstruction(insn, 16, 5);
10512 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10513 tmp = fieldFromInstruction(insn, 11, 5);
10514 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10515 tmp = fieldFromInstruction(insn, 21, 5);
10516 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10517 return S;
10518 case 69:
10519 tmp = fieldFromInstruction(insn, 11, 5);
10520 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10521 tmp = fieldFromInstruction(insn, 16, 5);
10522 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10523 tmp = fieldFromInstruction(insn, 21, 5);
10524 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10525 tmp = fieldFromInstruction(insn, 11, 5);
10526 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10527 return S;
10528 case 70:
10529 tmp = fieldFromInstruction(insn, 11, 5);
10530 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10531 tmp = fieldFromInstruction(insn, 16, 5);
10532 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10533 tmp = fieldFromInstruction(insn, 21, 5);
10534 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10535 return S;
10536 case 71:
10537 tmp = fieldFromInstruction(insn, 14, 2);
10538 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10539 tmp = fieldFromInstruction(insn, 16, 6);
10540 if (!Check(S, DecodeSImmWithOffsetAndScale<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10541 tmp = fieldFromInstruction(insn, 14, 2);
10542 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10543 return S;
10544 case 72:
10545 tmp = fieldFromInstruction(insn, 21, 5);
10546 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10547 tmp = fieldFromInstruction(insn, 16, 5);
10548 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10549 tmp = fieldFromInstruction(insn, 6, 5);
10550 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10551 tmp = fieldFromInstruction(insn, 11, 5);
10552 if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10553 return S;
10554 case 73:
10555 tmp = fieldFromInstruction(insn, 11, 5);
10556 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10557 tmp = fieldFromInstruction(insn, 16, 5);
10558 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10559 tmp = fieldFromInstruction(insn, 21, 5);
10560 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10561 return S;
10562 case 74:
10563 tmp = fieldFromInstruction(insn, 21, 5);
10564 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10565 tmp = fieldFromInstruction(insn, 16, 5);
10566 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10567 tmp = fieldFromInstruction(insn, 11, 3);
10568 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10569 return S;
10570 case 75:
10571 tmp = fieldFromInstruction(insn, 16, 5);
10572 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10573 tmp = fieldFromInstruction(insn, 21, 5);
10574 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10575 tmp = fieldFromInstruction(insn, 11, 3);
10576 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10577 return S;
10578 case 76:
10579 tmp = fieldFromInstruction(insn, 21, 5);
10580 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10581 tmp = fieldFromInstruction(insn, 16, 5);
10582 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10583 tmp = fieldFromInstruction(insn, 12, 4);
10584 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10585 return S;
10586 case 77:
10587 tmp = fieldFromInstruction(insn, 16, 5);
10588 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10589 tmp = fieldFromInstruction(insn, 21, 5);
10590 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10591 tmp = fieldFromInstruction(insn, 12, 4);
10592 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10593 return S;
10594 case 78:
10595 tmp = fieldFromInstruction(insn, 16, 5);
10596 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10597 tmp = fieldFromInstruction(insn, 14, 2);
10598 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10599 return S;
10600 case 79:
10601 tmp = fieldFromInstruction(insn, 14, 2);
10602 if (!Check(S, DecodeHI32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10603 tmp = fieldFromInstruction(insn, 16, 5);
10604 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10605 return S;
10606 case 80:
10607 tmp = fieldFromInstruction(insn, 21, 5);
10608 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10609 tmp = fieldFromInstruction(insn, 16, 5);
10610 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10611 tmp = fieldFromInstruction(insn, 13, 3);
10612 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10613 return S;
10614 case 81:
10615 tmp = fieldFromInstruction(insn, 14, 2);
10616 if (!Check(S, DecodeLO32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10617 tmp = fieldFromInstruction(insn, 16, 5);
10618 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10619 return S;
10620 case 82:
10621 tmp = fieldFromInstruction(insn, 14, 2);
10622 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10623 tmp = fieldFromInstruction(insn, 16, 5);
10624 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10625 tmp = fieldFromInstruction(insn, 21, 5);
10626 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10627 tmp = fieldFromInstruction(insn, 14, 2);
10628 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10629 return S;
10630 case 83:
10631 tmp = fieldFromInstruction(insn, 21, 5);
10632 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10633 tmp = fieldFromInstruction(insn, 16, 5);
10634 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10635 tmp = fieldFromInstruction(insn, 14, 2);
10636 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10637 tmp = fieldFromInstruction(insn, 21, 5);
10638 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10639 return S;
10640 case 84:
10641 tmp = fieldFromInstruction(insn, 21, 5);
10642 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10643 tmp = fieldFromInstruction(insn, 14, 2);
10644 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10645 tmp = fieldFromInstruction(insn, 16, 5);
10646 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10647 return S;
10648 case 85:
10649 tmp = fieldFromInstruction(insn, 21, 5);
10650 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10651 tmp = fieldFromInstruction(insn, 16, 5);
10652 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10653 return S;
10654 case 86:
10655 tmp = fieldFromInstruction(insn, 21, 5);
10656 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10657 tmp = fieldFromInstruction(insn, 16, 5);
10658 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10659 return S;
10660 case 87:
10661 tmp = fieldFromInstruction(insn, 21, 5);
10662 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10663 tmp = fieldFromInstruction(insn, 21, 5);
10664 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10665 tmp = fieldFromInstruction(insn, 16, 5);
10666 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10667 return S;
10668 case 88:
10669 tmp = fieldFromInstruction(insn, 21, 5);
10670 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10671 tmp = fieldFromInstruction(insn, 16, 5);
10672 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10673 return S;
10674 case 89:
10675 tmp = fieldFromInstruction(insn, 14, 2);
10676 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10677 tmp = fieldFromInstruction(insn, 16, 5);
10678 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10679 tmp = fieldFromInstruction(insn, 14, 2);
10680 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10681 return S;
10682 case 90:
10683 tmp = fieldFromInstruction(insn, 14, 2);
10684 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10685 tmp = fieldFromInstruction(insn, 16, 5);
10686 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10687 tmp = fieldFromInstruction(insn, 21, 5);
10688 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10689 tmp = fieldFromInstruction(insn, 14, 2);
10690 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10691 return S;
10692 case 91:
10693 tmp = fieldFromInstruction(insn, 21, 5);
10694 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10695 tmp = fieldFromInstruction(insn, 16, 5);
10696 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10697 return S;
10698 case 92:
10699 tmp = fieldFromInstruction(insn, 21, 5);
10700 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10701 tmp = fieldFromInstruction(insn, 16, 5);
10702 if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10703 return S;
10704 case 93:
10705 tmp = fieldFromInstruction(insn, 16, 5);
10706 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10707 tmp = fieldFromInstruction(insn, 21, 5);
10708 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10709 return S;
10710 case 94:
10711 tmp = fieldFromInstruction(insn, 16, 5);
10712 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10713 return S;
10714 case 95:
10715 tmp = fieldFromInstruction(insn, 16, 10);
10716 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10717 return S;
10718 case 96:
10719 tmp = fieldFromInstruction(insn, 14, 2);
10720 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10721 tmp = fieldFromInstruction(insn, 16, 5);
10722 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10723 tmp = fieldFromInstruction(insn, 21, 5);
10724 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10725 return S;
10726 case 97:
10727 tmp = fieldFromInstruction(insn, 21, 5);
10728 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10729 tmp = fieldFromInstruction(insn, 16, 5);
10730 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10731 return S;
10732 case 98:
10733 tmp = fieldFromInstruction(insn, 16, 5);
10734 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10735 tmp = fieldFromInstruction(insn, 21, 5);
10736 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10737 return S;
10738 case 99:
10739 tmp = fieldFromInstruction(insn, 16, 5);
10740 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10741 return S;
10742 case 100:
10743 tmp = fieldFromInstruction(insn, 21, 5);
10744 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10745 tmp = fieldFromInstruction(insn, 13, 8);
10746 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10747 return S;
10748 case 101:
10749 tmp = fieldFromInstruction(insn, 21, 5);
10750 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10751 tmp = fieldFromInstruction(insn, 14, 7);
10752 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10753 return S;
10754 case 102:
10755 tmp = fieldFromInstruction(insn, 21, 5);
10756 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10757 tmp = fieldFromInstruction(insn, 14, 2);
10758 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10759 tmp = fieldFromInstruction(insn, 16, 5);
10760 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10761 return S;
10762 case 103:
10763 tmp = fieldFromInstruction(insn, 11, 5);
10764 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10765 tmp = fieldFromInstruction(insn, 16, 10);
10766 if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10767 return S;
10768 case 104:
10769 tmp = fieldFromInstruction(insn, 21, 5);
10770 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10771 tmp = fieldFromInstruction(insn, 16, 5);
10772 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10773 tmp = fieldFromInstruction(insn, 0, 16);
10774 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10775 return S;
10776 case 105:
10777 if (!Check(S, DecodeMemMMImm16(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10778 return S;
10779 case 106:
10780 if (!Check(S, DecodeMemMMImm12(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10781 return S;
10782 case 107:
10783 if (!Check(S, DecodeCacheOpMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10784 return S;
10785 case 108:
10786 tmp = fieldFromInstruction(insn, 16, 5);
10787 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10788 tmp = fieldFromInstruction(insn, 0, 16);
10789 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10790 return S;
10791 case 109:
10792 tmp = fieldFromInstruction(insn, 16, 5);
10793 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10794 tmp = fieldFromInstruction(insn, 0, 16);
10795 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10796 return S;
10797 case 110:
10798 tmp = fieldFromInstruction(insn, 16, 5);
10799 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10800 tmp = fieldFromInstruction(insn, 0, 16);
10801 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10802 return S;
10803 case 111:
10804 if (!Check(S, DecodeSyncI_MM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10805 return S;
10806 case 112:
10807 tmp = fieldFromInstruction(insn, 0, 16);
10808 if (!Check(S, DecodeBranchTarget1SImm16(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10809 return S;
10810 case 113:
10811 tmp = fieldFromInstruction(insn, 0, 16);
10812 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10813 return S;
10814 case 114:
10815 tmp = fieldFromInstruction(insn, 18, 3);
10816 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10817 tmp = fieldFromInstruction(insn, 0, 16);
10818 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10819 return S;
10820 case 115:
10821 tmp = fieldFromInstruction(insn, 21, 5);
10822 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10823 tmp = fieldFromInstruction(insn, 16, 5);
10824 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10825 tmp = fieldFromInstruction(insn, 0, 16);
10826 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10827 return S;
10828 case 116:
10829 tmp = fieldFromInstruction(insn, 11, 5);
10830 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10831 tmp = fieldFromInstruction(insn, 6, 5);
10832 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10833 tmp = fieldFromInstruction(insn, 16, 5);
10834 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10835 tmp = fieldFromInstruction(insn, 21, 5);
10836 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10837 return S;
10838 case 117:
10839 tmp = fieldFromInstruction(insn, 11, 5);
10840 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10841 tmp = fieldFromInstruction(insn, 16, 5);
10842 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10843 tmp = fieldFromInstruction(insn, 21, 5);
10844 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10845 return S;
10846 case 118:
10847 tmp = fieldFromInstruction(insn, 11, 5);
10848 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10849 tmp = fieldFromInstruction(insn, 16, 5);
10850 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10851 tmp = fieldFromInstruction(insn, 21, 5);
10852 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10853 return S;
10854 case 119:
10855 tmp = fieldFromInstruction(insn, 11, 5);
10856 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10857 tmp = fieldFromInstruction(insn, 6, 5);
10858 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10859 tmp = fieldFromInstruction(insn, 16, 5);
10860 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10861 tmp = fieldFromInstruction(insn, 21, 5);
10862 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10863 return S;
10864 case 120:
10865 tmp = fieldFromInstruction(insn, 21, 5);
10866 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10867 tmp = fieldFromInstruction(insn, 16, 5);
10868 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10869 tmp = fieldFromInstruction(insn, 13, 3);
10870 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10871 tmp = fieldFromInstruction(insn, 21, 5);
10872 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10873 return S;
10874 case 121:
10875 tmp = fieldFromInstruction(insn, 16, 5);
10876 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10877 tmp = fieldFromInstruction(insn, 21, 5);
10878 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10879 tmp = fieldFromInstruction(insn, 11, 5);
10880 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10881 return S;
10882 case 122:
10883 tmp = fieldFromInstruction(insn, 21, 5);
10884 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10885 tmp = fieldFromInstruction(insn, 16, 5);
10886 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10887 tmp = fieldFromInstruction(insn, 13, 3);
10888 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10889 tmp = fieldFromInstruction(insn, 21, 5);
10890 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10891 return S;
10892 case 123:
10893 tmp = fieldFromInstruction(insn, 11, 5);
10894 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10895 tmp = fieldFromInstruction(insn, 16, 5);
10896 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10897 tmp = fieldFromInstruction(insn, 21, 5);
10898 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10899 return S;
10900 case 124:
10901 tmp = fieldFromInstruction(insn, 11, 5);
10902 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10903 tmp = fieldFromInstruction(insn, 16, 5);
10904 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10905 tmp = fieldFromInstruction(insn, 21, 5);
10906 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10907 tmp = fieldFromInstruction(insn, 11, 5);
10908 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10909 return S;
10910 case 125:
10911 tmp = fieldFromInstruction(insn, 11, 5);
10912 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10913 tmp = fieldFromInstruction(insn, 16, 5);
10914 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10915 tmp = fieldFromInstruction(insn, 21, 5);
10916 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10917 tmp = fieldFromInstruction(insn, 11, 5);
10918 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10919 return S;
10920 case 126:
10921 tmp = fieldFromInstruction(insn, 21, 5);
10922 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10923 tmp = fieldFromInstruction(insn, 16, 5);
10924 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10925 return S;
10926 case 127:
10927 tmp = fieldFromInstruction(insn, 21, 5);
10928 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10929 tmp = fieldFromInstruction(insn, 16, 5);
10930 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10931 return S;
10932 case 128:
10933 tmp = fieldFromInstruction(insn, 21, 5);
10934 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10935 tmp = fieldFromInstruction(insn, 16, 5);
10936 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10937 return S;
10938 case 129:
10939 tmp = fieldFromInstruction(insn, 21, 5);
10940 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10941 tmp = fieldFromInstruction(insn, 16, 5);
10942 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10943 return S;
10944 case 130:
10945 tmp = fieldFromInstruction(insn, 21, 5);
10946 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10947 tmp = fieldFromInstruction(insn, 16, 5);
10948 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10949 tmp = fieldFromInstruction(insn, 13, 3);
10950 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10951 tmp = fieldFromInstruction(insn, 21, 5);
10952 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10953 return S;
10954 case 131:
10955 tmp = fieldFromInstruction(insn, 21, 5);
10956 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10957 tmp = fieldFromInstruction(insn, 16, 5);
10958 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10959 return S;
10960 case 132:
10961 tmp = fieldFromInstruction(insn, 16, 5);
10962 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10963 tmp = fieldFromInstruction(insn, 21, 5);
10964 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10965 return S;
10966 case 133:
10967 tmp = fieldFromInstruction(insn, 21, 5);
10968 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10969 tmp = fieldFromInstruction(insn, 16, 5);
10970 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10971 return S;
10972 case 134:
10973 tmp = fieldFromInstruction(insn, 21, 5);
10974 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10975 tmp = fieldFromInstruction(insn, 16, 5);
10976 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10977 return S;
10978 case 135:
10979 tmp = fieldFromInstruction(insn, 21, 5);
10980 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10981 tmp = fieldFromInstruction(insn, 16, 5);
10982 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10983 return S;
10984 case 136:
10985 tmp = fieldFromInstruction(insn, 21, 5);
10986 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10987 tmp = fieldFromInstruction(insn, 16, 5);
10988 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10989 return S;
10990 case 137:
10991 tmp = fieldFromInstruction(insn, 16, 5);
10992 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10993 tmp = fieldFromInstruction(insn, 21, 5);
10994 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10995 return S;
10996 case 138:
10997 tmp = fieldFromInstruction(insn, 16, 5);
10998 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10999 tmp = fieldFromInstruction(insn, 16, 5);
11000 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11001 tmp = fieldFromInstruction(insn, 21, 5);
11002 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11003 return S;
11004 case 139:
11005 tmp = fieldFromInstruction(insn, 13, 3);
11006 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11007 tmp = fieldFromInstruction(insn, 16, 5);
11008 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11009 tmp = fieldFromInstruction(insn, 21, 5);
11010 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11011 return S;
11012 case 140:
11013 tmp = fieldFromInstruction(insn, 13, 3);
11014 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11015 tmp = fieldFromInstruction(insn, 16, 5);
11016 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11017 tmp = fieldFromInstruction(insn, 21, 5);
11018 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11019 return S;
11020 case 141:
11021 if (!Check(S, DecodeMemMMImm9(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11022 return S;
11023 case 142:
11024 if (!Check(S, DecodePrefeOpMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11025 return S;
11026 case 143:
11027 if (!Check(S, DecodeJumpTargetMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11028 return S;
11029 case 144:
11030 tmp = fieldFromInstruction(insn, 23, 3);
11031 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11032 tmp = fieldFromInstruction(insn, 0, 23);
11033 if (!Check(S, DecodeSimm23Lsl2(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11034 return S;
11035 case 145:
11036 tmp = fieldFromInstruction(insn, 16, 5);
11037 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11038 tmp = fieldFromInstruction(insn, 21, 5);
11039 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11040 tmp = fieldFromInstruction(insn, 0, 16);
11041 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11042 return S;
11043 case 146:
11044 if (!Check(S, DecodeFMemMMR2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11045 return S;
11046 case 147:
11047 if (!Check(S, DecodeJumpTargetXMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11048 return S;
11049 case 148:
11050 if (!Check(S, DecodeMem(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11051 return S;
11052 case 149:
11053 tmp = fieldFromInstruction(insn, 16, 5);
11054 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11055 tmp = fieldFromInstruction(insn, 21, 5);
11056 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11057 return S;
11058 case 150:
11059 tmp = fieldFromInstruction(insn, 21, 5);
11060 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11061 tmp = fieldFromInstruction(insn, 16, 5);
11062 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11063 return S;
11064 case 151:
11065 tmp = fieldFromInstruction(insn, 16, 5);
11066 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11067 tmp = fieldFromInstruction(insn, 16, 5);
11068 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11069 tmp = fieldFromInstruction(insn, 21, 5);
11070 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11071 return S;
11072 case 152:
11073 tmp = fieldFromInstruction(insn, 11, 5);
11074 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11075 tmp = fieldFromInstruction(insn, 16, 5);
11076 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11077 tmp = fieldFromInstruction(insn, 21, 5);
11078 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11079 return S;
11080 case 153:
11081 tmp = fieldFromInstruction(insn, 21, 5);
11082 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11083 tmp = fieldFromInstruction(insn, 16, 5);
11084 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11085 return S;
11086 case 154:
11087 tmp = fieldFromInstruction(insn, 21, 5);
11088 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11089 tmp = fieldFromInstruction(insn, 16, 5);
11090 if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11091 tmp = fieldFromInstruction(insn, 11, 3);
11092 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11093 return S;
11094 case 155:
11095 tmp = fieldFromInstruction(insn, 11, 5);
11096 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11097 tmp = fieldFromInstruction(insn, 16, 5);
11098 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11099 tmp = fieldFromInstruction(insn, 21, 5);
11100 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11101 tmp = fieldFromInstruction(insn, 9, 2);
11102 if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11103 return S;
11104 case 156:
11105 tmp = fieldFromInstruction(insn, 11, 5);
11106 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11107 tmp = fieldFromInstruction(insn, 21, 5);
11108 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11109 tmp = fieldFromInstruction(insn, 16, 5);
11110 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11111 tmp = fieldFromInstruction(insn, 9, 2);
11112 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11113 return S;
11114 case 157:
11115 tmp = fieldFromInstruction(insn, 16, 5);
11116 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11117 tmp = fieldFromInstruction(insn, 9, 2);
11118 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11119 return S;
11120 case 158:
11121 tmp = fieldFromInstruction(insn, 6, 16);
11122 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11123 return S;
11124 case 159:
11125 tmp = fieldFromInstruction(insn, 21, 5);
11126 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11127 tmp = fieldFromInstruction(insn, 0, 16);
11128 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11129 return S;
11130 case 160:
11131 if (!Check(S, DecodeLoadByte15(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11132 return S;
11133 case 161:
11134 if (!Check(S, DecodeFMemCop2MMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11135 return S;
11136 case 162:
11137 tmp = fieldFromInstruction(insn, 16, 5);
11138 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11139 tmp = fieldFromInstruction(insn, 0, 16);
11140 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11141 return S;
11142 case 163:
11143 tmp = fieldFromInstruction(insn, 16, 5);
11144 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11145 tmp = fieldFromInstruction(insn, 0, 16);
11146 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11147 return S;
11148 case 164:
11149 if (!Check(S, DecodeSynciR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11150 return S;
11151 case 165:
11152 tmp = fieldFromInstruction(insn, 11, 5);
11153 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11154 tmp = fieldFromInstruction(insn, 16, 5);
11155 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11156 tmp = fieldFromInstruction(insn, 21, 5);
11157 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11158 return S;
11159 case 166:
11160 tmp = fieldFromInstruction(insn, 11, 5);
11161 if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11162 tmp = fieldFromInstruction(insn, 16, 5);
11163 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11164 tmp = fieldFromInstruction(insn, 21, 5);
11165 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11166 return S;
11167 case 167:
11168 tmp = fieldFromInstruction(insn, 11, 5);
11169 if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11170 tmp = fieldFromInstruction(insn, 16, 5);
11171 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11172 tmp = fieldFromInstruction(insn, 21, 5);
11173 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11174 return S;
11175 case 168:
11176 tmp = fieldFromInstruction(insn, 16, 5);
11177 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11178 tmp = fieldFromInstruction(insn, 21, 5);
11179 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11180 return S;
11181 case 169:
11182 tmp = fieldFromInstruction(insn, 11, 5);
11183 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11184 tmp = fieldFromInstruction(insn, 21, 5);
11185 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11186 tmp = fieldFromInstruction(insn, 16, 5);
11187 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11188 return S;
11189 case 170:
11190 tmp = fieldFromInstruction(insn, 11, 5);
11191 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11192 tmp = fieldFromInstruction(insn, 11, 5);
11193 if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11194 tmp = fieldFromInstruction(insn, 16, 5);
11195 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11196 tmp = fieldFromInstruction(insn, 21, 5);
11197 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11198 return S;
11199 case 171:
11200 tmp = fieldFromInstruction(insn, 11, 5);
11201 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11202 tmp = fieldFromInstruction(insn, 11, 5);
11203 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11204 tmp = fieldFromInstruction(insn, 16, 5);
11205 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11206 tmp = fieldFromInstruction(insn, 21, 5);
11207 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11208 return S;
11209 case 172:
11210 tmp = fieldFromInstruction(insn, 16, 5);
11211 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11212 tmp = fieldFromInstruction(insn, 21, 5);
11213 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11214 return S;
11215 case 173:
11216 tmp = fieldFromInstruction(insn, 11, 5);
11217 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11218 tmp = fieldFromInstruction(insn, 11, 5);
11219 if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11220 tmp = fieldFromInstruction(insn, 16, 5);
11221 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11222 tmp = fieldFromInstruction(insn, 21, 5);
11223 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11224 return S;
11225 case 174:
11226 tmp = fieldFromInstruction(insn, 11, 5);
11227 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11228 tmp = fieldFromInstruction(insn, 11, 5);
11229 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11230 tmp = fieldFromInstruction(insn, 16, 5);
11231 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11232 tmp = fieldFromInstruction(insn, 21, 5);
11233 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11234 return S;
11235 case 175:
11236 if (!Check(S, DecodePOP35GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11237 return S;
11238 case 176:
11239 tmp = fieldFromInstruction(insn, 21, 5);
11240 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11241 tmp = fieldFromInstruction(insn, 0, 19);
11242 if (!Check(S, DecodeSimm19Lsl2(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11243 return S;
11244 case 177:
11245 tmp = fieldFromInstruction(insn, 21, 5);
11246 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11247 tmp = fieldFromInstruction(insn, 0, 16);
11248 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11249 return S;
11250 case 178:
11251 if (!Check(S, DecodePOP37GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11252 return S;
11253 case 179:
11254 tmp = fieldFromInstruction(insn, 21, 5);
11255 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11256 tmp = fieldFromInstruction(insn, 0, 21);
11257 if (!Check(S, DecodeBranchTarget21MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11258 return S;
11259 case 180:
11260 tmp = fieldFromInstruction(insn, 0, 26);
11261 if (!Check(S, DecodeBranchTarget26MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11262 return S;
11263 case 181:
11264 if (!Check(S, DecodeBlezGroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11265 return S;
11266 case 182:
11267 if (!Check(S, DecodePOP65GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11268 return S;
11269 case 183:
11270 if (!Check(S, DecodeBgtzGroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11271 return S;
11272 case 184:
11273 if (!Check(S, DecodePOP75GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11274 return S;
11275 case 185:
11276 tmp = fieldFromInstruction(insn, 11, 5);
11277 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11278 tmp = fieldFromInstruction(insn, 16, 5);
11279 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11280 tmp = fieldFromInstruction(insn, 6, 5);
11281 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11282 return S;
11283 case 186:
11284 tmp = fieldFromInstruction(insn, 11, 5);
11285 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11286 tmp = fieldFromInstruction(insn, 21, 5);
11287 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11288 tmp = fieldFromInstruction(insn, 18, 3);
11289 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11290 tmp = fieldFromInstruction(insn, 11, 5);
11291 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11292 return S;
11293 case 187:
11294 tmp = fieldFromInstruction(insn, 11, 5);
11295 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11296 tmp = fieldFromInstruction(insn, 21, 5);
11297 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11298 tmp = fieldFromInstruction(insn, 16, 5);
11299 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11300 tmp = fieldFromInstruction(insn, 6, 2);
11301 if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11302 return S;
11303 case 188:
11304 tmp = fieldFromInstruction(insn, 21, 5);
11305 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11306 return S;
11307 case 189:
11308 tmp = fieldFromInstruction(insn, 11, 5);
11309 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11310 tmp = fieldFromInstruction(insn, 21, 5);
11311 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11312 tmp = fieldFromInstruction(insn, 16, 5);
11313 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11314 tmp = fieldFromInstruction(insn, 11, 5);
11315 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11316 return S;
11317 case 190:
11318 tmp = fieldFromInstruction(insn, 6, 20);
11319 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11320 return S;
11321 case 191:
11322 tmp = fieldFromInstruction(insn, 6, 5);
11323 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11324 return S;
11325 case 192:
11326 tmp = fieldFromInstruction(insn, 11, 5);
11327 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11328 return S;
11329 case 193:
11330 tmp = fieldFromInstruction(insn, 11, 5);
11331 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11332 tmp = fieldFromInstruction(insn, 21, 2);
11333 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11334 return S;
11335 case 194:
11336 tmp = fieldFromInstruction(insn, 11, 2);
11337 if (!Check(S, DecodeHI32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11338 tmp = fieldFromInstruction(insn, 21, 5);
11339 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11340 return S;
11341 case 195:
11342 tmp = fieldFromInstruction(insn, 11, 2);
11343 if (!Check(S, DecodeLO32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11344 tmp = fieldFromInstruction(insn, 21, 5);
11345 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11346 return S;
11347 case 196:
11348 tmp = fieldFromInstruction(insn, 11, 5);
11349 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11350 tmp = fieldFromInstruction(insn, 21, 5);
11351 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11352 tmp = fieldFromInstruction(insn, 16, 5);
11353 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11354 tmp = fieldFromInstruction(insn, 6, 2);
11355 if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11356 return S;
11357 case 197:
11358 tmp = fieldFromInstruction(insn, 11, 2);
11359 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11360 tmp = fieldFromInstruction(insn, 21, 5);
11361 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11362 tmp = fieldFromInstruction(insn, 16, 5);
11363 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11364 return S;
11365 case 198:
11366 tmp = fieldFromInstruction(insn, 21, 5);
11367 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11368 tmp = fieldFromInstruction(insn, 16, 5);
11369 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11370 tmp = fieldFromInstruction(insn, 6, 10);
11371 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11372 return S;
11373 case 199:
11374 tmp = fieldFromInstruction(insn, 21, 5);
11375 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11376 tmp = fieldFromInstruction(insn, 0, 16);
11377 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11378 return S;
11379 case 200:
11380 tmp = fieldFromInstruction(insn, 0, 16);
11381 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11382 return S;
11383 case 201:
11384 if (!Check(S, DecodeSyncI(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11385 return S;
11386 case 202:
11387 if (!Check(S, DecodeJumpTarget(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11388 return S;
11389 case 203:
11390 tmp = fieldFromInstruction(insn, 21, 5);
11391 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11392 tmp = fieldFromInstruction(insn, 16, 5);
11393 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11394 tmp = fieldFromInstruction(insn, 0, 16);
11395 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11396 return S;
11397 case 204:
11398 tmp = fieldFromInstruction(insn, 16, 5);
11399 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11400 tmp = fieldFromInstruction(insn, 21, 5);
11401 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11402 tmp = fieldFromInstruction(insn, 0, 16);
11403 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11404 return S;
11405 case 205:
11406 tmp = fieldFromInstruction(insn, 16, 5);
11407 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11408 tmp = fieldFromInstruction(insn, 21, 5);
11409 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11410 tmp = fieldFromInstruction(insn, 0, 16);
11411 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11412 return S;
11413 case 206:
11414 tmp = fieldFromInstruction(insn, 16, 5);
11415 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11416 tmp = fieldFromInstruction(insn, 11, 5);
11417 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11418 tmp = fieldFromInstruction(insn, 0, 3);
11419 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11420 return S;
11421 case 207:
11422 tmp = fieldFromInstruction(insn, 11, 5);
11423 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11424 tmp = fieldFromInstruction(insn, 16, 5);
11425 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11426 tmp = fieldFromInstruction(insn, 0, 3);
11427 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11428 return S;
11429 case 208:
11430 tmp = fieldFromInstruction(insn, 11, 5);
11431 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11432 tmp = fieldFromInstruction(insn, 16, 5);
11433 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11434 tmp = fieldFromInstruction(insn, 5, 1);
11435 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11436 tmp = fieldFromInstruction(insn, 0, 3);
11437 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11438 tmp = fieldFromInstruction(insn, 4, 1);
11439 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11440 return S;
11441 case 209:
11442 tmp = fieldFromInstruction(insn, 11, 10);
11443 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11444 return S;
11445 case 210:
11446 tmp = fieldFromInstruction(insn, 16, 5);
11447 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11448 tmp = fieldFromInstruction(insn, 11, 5);
11449 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11450 return S;
11451 case 211:
11452 tmp = fieldFromInstruction(insn, 16, 5);
11453 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11454 tmp = fieldFromInstruction(insn, 11, 5);
11455 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11456 return S;
11457 case 212:
11458 tmp = fieldFromInstruction(insn, 16, 5);
11459 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11460 tmp = fieldFromInstruction(insn, 11, 5);
11461 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11462 return S;
11463 case 213:
11464 tmp = fieldFromInstruction(insn, 16, 5);
11465 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11466 tmp = fieldFromInstruction(insn, 11, 5);
11467 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11468 return S;
11469 case 214:
11470 tmp = fieldFromInstruction(insn, 11, 5);
11471 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11472 tmp = fieldFromInstruction(insn, 16, 5);
11473 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11474 return S;
11475 case 215:
11476 tmp = fieldFromInstruction(insn, 11, 5);
11477 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11478 tmp = fieldFromInstruction(insn, 16, 5);
11479 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11480 return S;
11481 case 216:
11482 tmp = fieldFromInstruction(insn, 11, 5);
11483 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11484 tmp = fieldFromInstruction(insn, 16, 5);
11485 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11486 return S;
11487 case 217:
11488 tmp = fieldFromInstruction(insn, 11, 5);
11489 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11490 tmp = fieldFromInstruction(insn, 11, 5);
11491 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11492 tmp = fieldFromInstruction(insn, 16, 5);
11493 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11494 return S;
11495 case 218:
11496 tmp = fieldFromInstruction(insn, 18, 3);
11497 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11498 tmp = fieldFromInstruction(insn, 0, 16);
11499 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11500 return S;
11501 case 219:
11502 tmp = fieldFromInstruction(insn, 16, 5);
11503 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11504 tmp = fieldFromInstruction(insn, 0, 16);
11505 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11506 return S;
11507 case 220:
11508 tmp = fieldFromInstruction(insn, 6, 5);
11509 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11510 tmp = fieldFromInstruction(insn, 11, 5);
11511 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11512 tmp = fieldFromInstruction(insn, 16, 5);
11513 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11514 return S;
11515 case 221:
11516 tmp = fieldFromInstruction(insn, 6, 5);
11517 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11518 tmp = fieldFromInstruction(insn, 11, 5);
11519 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11520 return S;
11521 case 222:
11522 tmp = fieldFromInstruction(insn, 6, 5);
11523 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11524 tmp = fieldFromInstruction(insn, 11, 5);
11525 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11526 tmp = fieldFromInstruction(insn, 18, 3);
11527 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11528 tmp = fieldFromInstruction(insn, 6, 5);
11529 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11530 return S;
11531 case 223:
11532 tmp = fieldFromInstruction(insn, 6, 5);
11533 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11534 tmp = fieldFromInstruction(insn, 11, 5);
11535 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11536 tmp = fieldFromInstruction(insn, 16, 5);
11537 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11538 tmp = fieldFromInstruction(insn, 6, 5);
11539 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11540 return S;
11541 case 224:
11542 tmp = fieldFromInstruction(insn, 6, 5);
11543 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11544 tmp = fieldFromInstruction(insn, 11, 5);
11545 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11546 return S;
11547 case 225:
11548 tmp = fieldFromInstruction(insn, 6, 5);
11549 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11550 tmp = fieldFromInstruction(insn, 11, 5);
11551 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11552 return S;
11553 case 226:
11554 tmp = fieldFromInstruction(insn, 8, 3);
11555 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11556 tmp = fieldFromInstruction(insn, 11, 5);
11557 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11558 tmp = fieldFromInstruction(insn, 16, 5);
11559 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11560 return S;
11561 case 227:
11562 tmp = fieldFromInstruction(insn, 6, 5);
11563 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11564 tmp = fieldFromInstruction(insn, 11, 5);
11565 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11566 tmp = fieldFromInstruction(insn, 16, 5);
11567 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11568 return S;
11569 case 228:
11570 tmp = fieldFromInstruction(insn, 6, 5);
11571 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11572 tmp = fieldFromInstruction(insn, 11, 5);
11573 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11574 return S;
11575 case 229:
11576 tmp = fieldFromInstruction(insn, 6, 5);
11577 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11578 tmp = fieldFromInstruction(insn, 11, 5);
11579 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11580 return S;
11581 case 230:
11582 tmp = fieldFromInstruction(insn, 6, 5);
11583 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11584 tmp = fieldFromInstruction(insn, 11, 5);
11585 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11586 tmp = fieldFromInstruction(insn, 18, 3);
11587 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11588 tmp = fieldFromInstruction(insn, 6, 5);
11589 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11590 return S;
11591 case 231:
11592 tmp = fieldFromInstruction(insn, 6, 5);
11593 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11594 tmp = fieldFromInstruction(insn, 11, 5);
11595 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11596 tmp = fieldFromInstruction(insn, 16, 5);
11597 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11598 tmp = fieldFromInstruction(insn, 6, 5);
11599 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11600 return S;
11601 case 232:
11602 tmp = fieldFromInstruction(insn, 6, 5);
11603 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11604 tmp = fieldFromInstruction(insn, 11, 5);
11605 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11606 return S;
11607 case 233:
11608 tmp = fieldFromInstruction(insn, 8, 3);
11609 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11610 tmp = fieldFromInstruction(insn, 11, 5);
11611 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11612 tmp = fieldFromInstruction(insn, 16, 5);
11613 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11614 return S;
11615 case 234:
11616 tmp = fieldFromInstruction(insn, 16, 5);
11617 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11618 tmp = fieldFromInstruction(insn, 0, 16);
11619 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11620 return S;
11621 case 235:
11622 tmp = fieldFromInstruction(insn, 16, 5);
11623 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11624 tmp = fieldFromInstruction(insn, 0, 16);
11625 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11626 return S;
11627 case 236:
11628 tmp = fieldFromInstruction(insn, 16, 5);
11629 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11630 tmp = fieldFromInstruction(insn, 0, 16);
11631 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11632 return S;
11633 case 237:
11634 tmp = fieldFromInstruction(insn, 16, 5);
11635 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11636 tmp = fieldFromInstruction(insn, 11, 5);
11637 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11638 tmp = fieldFromInstruction(insn, 0, 3);
11639 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11640 return S;
11641 case 238:
11642 tmp = fieldFromInstruction(insn, 11, 5);
11643 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11644 tmp = fieldFromInstruction(insn, 16, 5);
11645 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11646 tmp = fieldFromInstruction(insn, 0, 3);
11647 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11648 return S;
11649 case 239:
11650 tmp = fieldFromInstruction(insn, 6, 5);
11651 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11652 tmp = fieldFromInstruction(insn, 21, 5);
11653 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11654 tmp = fieldFromInstruction(insn, 16, 5);
11655 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11656 return S;
11657 case 240:
11658 tmp = fieldFromInstruction(insn, 6, 5);
11659 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11660 tmp = fieldFromInstruction(insn, 21, 5);
11661 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11662 tmp = fieldFromInstruction(insn, 16, 5);
11663 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11664 return S;
11665 case 241:
11666 tmp = fieldFromInstruction(insn, 11, 5);
11667 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11668 tmp = fieldFromInstruction(insn, 21, 5);
11669 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11670 tmp = fieldFromInstruction(insn, 16, 5);
11671 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11672 return S;
11673 case 242:
11674 tmp = fieldFromInstruction(insn, 11, 5);
11675 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11676 tmp = fieldFromInstruction(insn, 21, 5);
11677 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11678 tmp = fieldFromInstruction(insn, 16, 5);
11679 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11680 return S;
11681 case 243:
11682 tmp = fieldFromInstruction(insn, 6, 5);
11683 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11684 tmp = fieldFromInstruction(insn, 21, 5);
11685 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11686 tmp = fieldFromInstruction(insn, 11, 5);
11687 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11688 tmp = fieldFromInstruction(insn, 16, 5);
11689 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11690 return S;
11691 case 244:
11692 tmp = fieldFromInstruction(insn, 6, 5);
11693 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11694 tmp = fieldFromInstruction(insn, 21, 5);
11695 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11696 tmp = fieldFromInstruction(insn, 11, 5);
11697 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11698 tmp = fieldFromInstruction(insn, 16, 5);
11699 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11700 return S;
11701 case 245:
11702 tmp = fieldFromInstruction(insn, 11, 2);
11703 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11704 tmp = fieldFromInstruction(insn, 21, 5);
11705 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11706 tmp = fieldFromInstruction(insn, 16, 5);
11707 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11708 tmp = fieldFromInstruction(insn, 11, 2);
11709 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11710 return S;
11711 case 246:
11712 tmp = 0x0;
11713 tmp |= fieldFromInstruction(insn, 11, 5);
11714 tmp |= fieldFromInstruction(insn, 16, 5);
11715 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11716 tmp = fieldFromInstruction(insn, 21, 5);
11717 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11718 return S;
11719 case 247:
11720 tmp = fieldFromInstruction(insn, 6, 5);
11721 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11722 tmp = fieldFromInstruction(insn, 11, 5);
11723 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11724 tmp = fieldFromInstruction(insn, 16, 8);
11725 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11726 return S;
11727 case 248:
11728 tmp = fieldFromInstruction(insn, 6, 5);
11729 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11730 tmp = fieldFromInstruction(insn, 6, 5);
11731 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11732 tmp = fieldFromInstruction(insn, 11, 5);
11733 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11734 tmp = fieldFromInstruction(insn, 16, 8);
11735 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11736 return S;
11737 case 249:
11738 tmp = fieldFromInstruction(insn, 6, 5);
11739 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11740 tmp = fieldFromInstruction(insn, 11, 5);
11741 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11742 tmp = fieldFromInstruction(insn, 16, 8);
11743 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11744 return S;
11745 case 250:
11746 tmp = fieldFromInstruction(insn, 6, 5);
11747 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11748 tmp = fieldFromInstruction(insn, 11, 5);
11749 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11750 tmp = fieldFromInstruction(insn, 16, 8);
11751 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11752 return S;
11753 case 251:
11754 tmp = fieldFromInstruction(insn, 6, 5);
11755 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11756 tmp = fieldFromInstruction(insn, 11, 5);
11757 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11758 tmp = fieldFromInstruction(insn, 16, 5);
11759 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11760 return S;
11761 case 252:
11762 tmp = fieldFromInstruction(insn, 6, 5);
11763 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11764 tmp = fieldFromInstruction(insn, 11, 5);
11765 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11766 tmp = fieldFromInstruction(insn, 16, 5);
11767 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11768 return S;
11769 case 253:
11770 tmp = fieldFromInstruction(insn, 6, 5);
11771 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11772 tmp = fieldFromInstruction(insn, 11, 5);
11773 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11774 tmp = fieldFromInstruction(insn, 16, 5);
11775 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11776 return S;
11777 case 254:
11778 tmp = fieldFromInstruction(insn, 6, 5);
11779 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11780 tmp = fieldFromInstruction(insn, 11, 5);
11781 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11782 tmp = fieldFromInstruction(insn, 16, 5);
11783 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11784 return S;
11785 case 255:
11786 tmp = fieldFromInstruction(insn, 6, 5);
11787 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11788 tmp = fieldFromInstruction(insn, 11, 10);
11789 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11790 return S;
11791 case 256:
11792 tmp = fieldFromInstruction(insn, 6, 5);
11793 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11794 tmp = fieldFromInstruction(insn, 11, 10);
11795 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11796 return S;
11797 case 257:
11798 tmp = fieldFromInstruction(insn, 6, 5);
11799 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11800 tmp = fieldFromInstruction(insn, 11, 10);
11801 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11802 return S;
11803 case 258:
11804 tmp = fieldFromInstruction(insn, 6, 5);
11805 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11806 tmp = fieldFromInstruction(insn, 11, 10);
11807 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11808 return S;
11809 case 259:
11810 tmp = fieldFromInstruction(insn, 6, 5);
11811 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11812 tmp = fieldFromInstruction(insn, 11, 5);
11813 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11814 tmp = fieldFromInstruction(insn, 16, 6);
11815 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11816 return S;
11817 case 260:
11818 tmp = fieldFromInstruction(insn, 6, 5);
11819 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11820 tmp = fieldFromInstruction(insn, 11, 5);
11821 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11822 tmp = fieldFromInstruction(insn, 16, 4);
11823 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11824 return S;
11825 case 261:
11826 tmp = fieldFromInstruction(insn, 6, 5);
11827 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11828 tmp = fieldFromInstruction(insn, 11, 5);
11829 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11830 tmp = fieldFromInstruction(insn, 16, 3);
11831 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11832 return S;
11833 case 262:
11834 tmp = fieldFromInstruction(insn, 6, 5);
11835 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11836 tmp = fieldFromInstruction(insn, 6, 5);
11837 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11838 tmp = fieldFromInstruction(insn, 11, 5);
11839 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11840 tmp = fieldFromInstruction(insn, 16, 6);
11841 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11842 return S;
11843 case 263:
11844 tmp = fieldFromInstruction(insn, 6, 5);
11845 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11846 tmp = fieldFromInstruction(insn, 6, 5);
11847 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11848 tmp = fieldFromInstruction(insn, 11, 5);
11849 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11850 tmp = fieldFromInstruction(insn, 16, 5);
11851 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11852 return S;
11853 case 264:
11854 tmp = fieldFromInstruction(insn, 6, 5);
11855 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11856 tmp = fieldFromInstruction(insn, 6, 5);
11857 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11858 tmp = fieldFromInstruction(insn, 11, 5);
11859 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11860 tmp = fieldFromInstruction(insn, 16, 4);
11861 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11862 return S;
11863 case 265:
11864 tmp = fieldFromInstruction(insn, 6, 5);
11865 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11866 tmp = fieldFromInstruction(insn, 6, 5);
11867 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11868 tmp = fieldFromInstruction(insn, 11, 5);
11869 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11870 tmp = fieldFromInstruction(insn, 16, 3);
11871 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11872 return S;
11873 case 266:
11874 tmp = fieldFromInstruction(insn, 6, 5);
11875 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11876 tmp = fieldFromInstruction(insn, 11, 5);
11877 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11878 tmp = fieldFromInstruction(insn, 16, 5);
11879 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11880 return S;
11881 case 267:
11882 tmp = fieldFromInstruction(insn, 6, 5);
11883 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11884 tmp = fieldFromInstruction(insn, 11, 5);
11885 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11886 tmp = fieldFromInstruction(insn, 16, 5);
11887 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11888 return S;
11889 case 268:
11890 tmp = fieldFromInstruction(insn, 6, 5);
11891 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11892 tmp = fieldFromInstruction(insn, 11, 5);
11893 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11894 tmp = fieldFromInstruction(insn, 16, 5);
11895 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11896 return S;
11897 case 269:
11898 tmp = fieldFromInstruction(insn, 6, 5);
11899 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11900 tmp = fieldFromInstruction(insn, 11, 5);
11901 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11902 tmp = fieldFromInstruction(insn, 16, 5);
11903 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11904 return S;
11905 case 270:
11906 tmp = fieldFromInstruction(insn, 6, 5);
11907 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11908 tmp = fieldFromInstruction(insn, 6, 5);
11909 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11910 tmp = fieldFromInstruction(insn, 11, 5);
11911 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11912 tmp = fieldFromInstruction(insn, 16, 5);
11913 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11914 return S;
11915 case 271:
11916 tmp = fieldFromInstruction(insn, 6, 5);
11917 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11918 tmp = fieldFromInstruction(insn, 6, 5);
11919 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11920 tmp = fieldFromInstruction(insn, 11, 5);
11921 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11922 tmp = fieldFromInstruction(insn, 16, 5);
11923 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11924 return S;
11925 case 272:
11926 tmp = fieldFromInstruction(insn, 6, 5);
11927 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11928 tmp = fieldFromInstruction(insn, 6, 5);
11929 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11930 tmp = fieldFromInstruction(insn, 11, 5);
11931 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11932 tmp = fieldFromInstruction(insn, 16, 5);
11933 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11934 return S;
11935 case 273:
11936 tmp = fieldFromInstruction(insn, 6, 5);
11937 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11938 tmp = fieldFromInstruction(insn, 6, 5);
11939 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11940 tmp = fieldFromInstruction(insn, 11, 5);
11941 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11942 tmp = fieldFromInstruction(insn, 16, 5);
11943 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11944 return S;
11945 case 274:
11946 tmp = fieldFromInstruction(insn, 6, 5);
11947 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11948 tmp = fieldFromInstruction(insn, 11, 5);
11949 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11950 tmp = fieldFromInstruction(insn, 16, 5);
11951 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11952 return S;
11953 case 275:
11954 tmp = fieldFromInstruction(insn, 6, 5);
11955 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11956 tmp = fieldFromInstruction(insn, 11, 5);
11957 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11958 tmp = fieldFromInstruction(insn, 16, 5);
11959 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11960 return S;
11961 case 276:
11962 tmp = fieldFromInstruction(insn, 6, 5);
11963 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11964 tmp = fieldFromInstruction(insn, 11, 5);
11965 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11966 tmp = fieldFromInstruction(insn, 16, 5);
11967 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11968 return S;
11969 case 277:
11970 tmp = fieldFromInstruction(insn, 6, 5);
11971 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11972 tmp = fieldFromInstruction(insn, 6, 5);
11973 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11974 tmp = fieldFromInstruction(insn, 11, 5);
11975 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11976 tmp = fieldFromInstruction(insn, 16, 5);
11977 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11978 return S;
11979 case 278:
11980 tmp = fieldFromInstruction(insn, 6, 5);
11981 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11982 tmp = fieldFromInstruction(insn, 6, 5);
11983 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11984 tmp = fieldFromInstruction(insn, 11, 5);
11985 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11986 tmp = fieldFromInstruction(insn, 16, 5);
11987 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11988 return S;
11989 case 279:
11990 tmp = fieldFromInstruction(insn, 6, 5);
11991 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11992 tmp = fieldFromInstruction(insn, 6, 5);
11993 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11994 tmp = fieldFromInstruction(insn, 11, 5);
11995 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11996 tmp = fieldFromInstruction(insn, 16, 5);
11997 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11998 return S;
11999 case 280:
12000 tmp = fieldFromInstruction(insn, 6, 5);
12001 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12002 tmp = fieldFromInstruction(insn, 6, 5);
12003 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12004 tmp = fieldFromInstruction(insn, 11, 5);
12005 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12006 tmp = fieldFromInstruction(insn, 16, 5);
12007 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12008 return S;
12009 case 281:
12010 tmp = fieldFromInstruction(insn, 6, 5);
12011 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12012 tmp = fieldFromInstruction(insn, 6, 5);
12013 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12014 tmp = fieldFromInstruction(insn, 11, 5);
12015 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12016 tmp = fieldFromInstruction(insn, 16, 5);
12017 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12018 return S;
12019 case 282:
12020 tmp = fieldFromInstruction(insn, 6, 5);
12021 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12022 tmp = fieldFromInstruction(insn, 6, 5);
12023 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12024 tmp = fieldFromInstruction(insn, 11, 5);
12025 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12026 tmp = fieldFromInstruction(insn, 16, 5);
12027 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12028 return S;
12029 case 283:
12030 tmp = fieldFromInstruction(insn, 6, 5);
12031 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12032 tmp = fieldFromInstruction(insn, 6, 5);
12033 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12034 tmp = fieldFromInstruction(insn, 11, 5);
12035 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12036 tmp = fieldFromInstruction(insn, 16, 5);
12037 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12038 return S;
12039 case 284:
12040 tmp = fieldFromInstruction(insn, 6, 5);
12041 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12042 tmp = fieldFromInstruction(insn, 11, 5);
12043 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12044 tmp = fieldFromInstruction(insn, 16, 5);
12045 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12046 return S;
12047 case 285:
12048 tmp = fieldFromInstruction(insn, 6, 5);
12049 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12050 tmp = fieldFromInstruction(insn, 11, 5);
12051 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12052 tmp = fieldFromInstruction(insn, 16, 5);
12053 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12054 return S;
12055 case 286:
12056 tmp = fieldFromInstruction(insn, 6, 5);
12057 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12058 tmp = fieldFromInstruction(insn, 11, 5);
12059 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12060 tmp = fieldFromInstruction(insn, 16, 5);
12061 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12062 return S;
12063 case 287:
12064 tmp = fieldFromInstruction(insn, 6, 5);
12065 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12066 tmp = fieldFromInstruction(insn, 11, 5);
12067 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12068 tmp = fieldFromInstruction(insn, 16, 5);
12069 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12070 return S;
12071 case 288:
12072 tmp = fieldFromInstruction(insn, 6, 5);
12073 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12074 tmp = fieldFromInstruction(insn, 6, 5);
12075 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12076 tmp = fieldFromInstruction(insn, 11, 5);
12077 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12078 tmp = fieldFromInstruction(insn, 16, 4);
12079 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12080 return S;
12081 case 289:
12082 tmp = fieldFromInstruction(insn, 6, 5);
12083 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12084 tmp = fieldFromInstruction(insn, 6, 5);
12085 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12086 tmp = fieldFromInstruction(insn, 11, 5);
12087 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12088 tmp = fieldFromInstruction(insn, 16, 3);
12089 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12090 return S;
12091 case 290:
12092 tmp = fieldFromInstruction(insn, 6, 5);
12093 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12094 tmp = fieldFromInstruction(insn, 6, 5);
12095 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12096 tmp = fieldFromInstruction(insn, 11, 5);
12097 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12098 tmp = fieldFromInstruction(insn, 16, 2);
12099 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12100 return S;
12101 case 291:
12102 tmp = fieldFromInstruction(insn, 6, 5);
12103 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12104 tmp = fieldFromInstruction(insn, 6, 5);
12105 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12106 tmp = fieldFromInstruction(insn, 11, 5);
12107 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12108 tmp = fieldFromInstruction(insn, 16, 1);
12109 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12110 return S;
12111 case 292:
12112 tmp = fieldFromInstruction(insn, 6, 5);
12113 if (!Check(S, DecodeMSACtrlRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12114 tmp = fieldFromInstruction(insn, 11, 5);
12115 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12116 return S;
12117 case 293:
12118 tmp = fieldFromInstruction(insn, 6, 5);
12119 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12120 tmp = fieldFromInstruction(insn, 11, 5);
12121 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12122 tmp = fieldFromInstruction(insn, 16, 4);
12123 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12124 return S;
12125 case 294:
12126 tmp = fieldFromInstruction(insn, 6, 5);
12127 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12128 tmp = fieldFromInstruction(insn, 11, 5);
12129 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12130 tmp = fieldFromInstruction(insn, 16, 3);
12131 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12132 return S;
12133 case 295:
12134 tmp = fieldFromInstruction(insn, 6, 5);
12135 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12136 tmp = fieldFromInstruction(insn, 11, 5);
12137 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12138 tmp = fieldFromInstruction(insn, 16, 2);
12139 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12140 return S;
12141 case 296:
12142 tmp = fieldFromInstruction(insn, 6, 5);
12143 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12144 tmp = fieldFromInstruction(insn, 11, 5);
12145 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12146 tmp = fieldFromInstruction(insn, 16, 1);
12147 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12148 return S;
12149 case 297:
12150 tmp = fieldFromInstruction(insn, 6, 5);
12151 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12152 tmp = fieldFromInstruction(insn, 11, 5);
12153 if (!Check(S, DecodeMSACtrlRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12154 return S;
12155 case 298:
12156 tmp = fieldFromInstruction(insn, 6, 5);
12157 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12158 tmp = fieldFromInstruction(insn, 11, 5);
12159 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12160 tmp = fieldFromInstruction(insn, 16, 4);
12161 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12162 return S;
12163 case 299:
12164 tmp = fieldFromInstruction(insn, 6, 5);
12165 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12166 tmp = fieldFromInstruction(insn, 11, 5);
12167 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12168 tmp = fieldFromInstruction(insn, 16, 3);
12169 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12170 return S;
12171 case 300:
12172 tmp = fieldFromInstruction(insn, 6, 5);
12173 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12174 tmp = fieldFromInstruction(insn, 11, 5);
12175 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12176 tmp = fieldFromInstruction(insn, 16, 2);
12177 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12178 return S;
12179 case 301:
12180 tmp = fieldFromInstruction(insn, 6, 5);
12181 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12182 tmp = fieldFromInstruction(insn, 11, 5);
12183 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12184 tmp = fieldFromInstruction(insn, 16, 1);
12185 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12186 return S;
12187 case 302:
12188 tmp = fieldFromInstruction(insn, 6, 5);
12189 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12190 tmp = fieldFromInstruction(insn, 11, 5);
12191 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12192 return S;
12193 case 303:
12194 tmp = fieldFromInstruction(insn, 6, 5);
12195 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12196 tmp = fieldFromInstruction(insn, 6, 5);
12197 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12198 tmp = fieldFromInstruction(insn, 11, 5);
12199 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12200 tmp = fieldFromInstruction(insn, 16, 4);
12201 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12202 return S;
12203 case 304:
12204 tmp = fieldFromInstruction(insn, 6, 5);
12205 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12206 tmp = fieldFromInstruction(insn, 6, 5);
12207 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12208 tmp = fieldFromInstruction(insn, 11, 5);
12209 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12210 tmp = fieldFromInstruction(insn, 16, 3);
12211 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12212 return S;
12213 case 305:
12214 tmp = fieldFromInstruction(insn, 6, 5);
12215 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12216 tmp = fieldFromInstruction(insn, 6, 5);
12217 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12218 tmp = fieldFromInstruction(insn, 11, 5);
12219 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12220 tmp = fieldFromInstruction(insn, 16, 2);
12221 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12222 return S;
12223 case 306:
12224 tmp = fieldFromInstruction(insn, 6, 5);
12225 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12226 tmp = fieldFromInstruction(insn, 6, 5);
12227 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12228 tmp = fieldFromInstruction(insn, 11, 5);
12229 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12230 tmp = fieldFromInstruction(insn, 16, 1);
12231 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12232 return S;
12233 case 307:
12234 if (!Check(S, DecodeINSVE_DF(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12235 return S;
12236 case 308:
12237 tmp = fieldFromInstruction(insn, 6, 5);
12238 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12239 tmp = fieldFromInstruction(insn, 11, 5);
12240 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12241 tmp = fieldFromInstruction(insn, 16, 5);
12242 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12243 return S;
12244 case 309:
12245 tmp = fieldFromInstruction(insn, 6, 5);
12246 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12247 tmp = fieldFromInstruction(insn, 11, 5);
12248 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12249 tmp = fieldFromInstruction(insn, 16, 5);
12250 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12251 return S;
12252 case 310:
12253 tmp = fieldFromInstruction(insn, 6, 5);
12254 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12255 tmp = fieldFromInstruction(insn, 11, 5);
12256 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12257 return S;
12258 case 311:
12259 tmp = fieldFromInstruction(insn, 6, 5);
12260 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12261 tmp = fieldFromInstruction(insn, 11, 5);
12262 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12263 return S;
12264 case 312:
12265 tmp = fieldFromInstruction(insn, 6, 5);
12266 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12267 tmp = fieldFromInstruction(insn, 11, 5);
12268 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12269 return S;
12270 case 313:
12271 tmp = fieldFromInstruction(insn, 6, 5);
12272 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12273 tmp = fieldFromInstruction(insn, 11, 5);
12274 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12275 return S;
12276 case 314:
12277 tmp = fieldFromInstruction(insn, 6, 5);
12278 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12279 tmp = fieldFromInstruction(insn, 11, 5);
12280 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12281 return S;
12282 case 315:
12283 tmp = fieldFromInstruction(insn, 6, 5);
12284 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12285 tmp = fieldFromInstruction(insn, 11, 5);
12286 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12287 return S;
12288 case 316:
12289 tmp = fieldFromInstruction(insn, 6, 5);
12290 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12291 tmp = fieldFromInstruction(insn, 11, 5);
12292 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12293 return S;
12294 case 317:
12295 tmp = fieldFromInstruction(insn, 6, 5);
12296 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12297 tmp = fieldFromInstruction(insn, 11, 5);
12298 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12299 return S;
12300 case 318:
12301 tmp = fieldFromInstruction(insn, 6, 5);
12302 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12303 tmp = fieldFromInstruction(insn, 11, 5);
12304 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12305 return S;
12306 case 319:
12307 if (!Check(S, DecodeMSA128Mem(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12308 return S;
12309 case 320:
12310 tmp = fieldFromInstruction(insn, 16, 5);
12311 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12312 tmp = fieldFromInstruction(insn, 21, 5);
12313 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12314 tmp = fieldFromInstruction(insn, 6, 5);
12315 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12316 tmp = fieldFromInstruction(insn, 11, 5);
12317 if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12318 return S;
12319 case 321:
12320 tmp = fieldFromInstruction(insn, 16, 5);
12321 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12322 tmp = fieldFromInstruction(insn, 21, 5);
12323 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12324 tmp = fieldFromInstruction(insn, 6, 5);
12325 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12326 tmp = fieldFromInstruction(insn, 11, 5);
12327 if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12328 tmp = fieldFromInstruction(insn, 16, 5);
12329 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12330 return S;
12331 case 322:
12332 tmp = fieldFromInstruction(insn, 21, 5);
12333 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12334 tmp = fieldFromInstruction(insn, 11, 5);
12335 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12336 tmp = fieldFromInstruction(insn, 16, 5);
12337 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12338 return S;
12339 case 323:
12340 tmp = fieldFromInstruction(insn, 11, 5);
12341 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12342 tmp = fieldFromInstruction(insn, 21, 5);
12343 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12344 tmp = fieldFromInstruction(insn, 16, 5);
12345 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12346 return S;
12347 case 324:
12348 tmp = fieldFromInstruction(insn, 16, 5);
12349 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12350 tmp = fieldFromInstruction(insn, 16, 5);
12351 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12352 tmp = fieldFromInstruction(insn, 21, 5);
12353 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12354 return S;
12355 case 325:
12356 tmp = fieldFromInstruction(insn, 11, 5);
12357 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12358 tmp = fieldFromInstruction(insn, 21, 5);
12359 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12360 tmp = fieldFromInstruction(insn, 16, 5);
12361 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12362 return S;
12363 case 326:
12364 tmp = fieldFromInstruction(insn, 11, 5);
12365 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12366 tmp = fieldFromInstruction(insn, 21, 5);
12367 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12368 return S;
12369 case 327:
12370 tmp = fieldFromInstruction(insn, 11, 5);
12371 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12372 tmp = fieldFromInstruction(insn, 21, 5);
12373 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12374 tmp = fieldFromInstruction(insn, 16, 5);
12375 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12376 return S;
12377 case 328:
12378 tmp = fieldFromInstruction(insn, 11, 5);
12379 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12380 tmp = fieldFromInstruction(insn, 21, 5);
12381 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12382 tmp = fieldFromInstruction(insn, 16, 5);
12383 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12384 return S;
12385 case 329:
12386 tmp = fieldFromInstruction(insn, 16, 5);
12387 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12388 tmp = fieldFromInstruction(insn, 21, 5);
12389 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12390 tmp = fieldFromInstruction(insn, 11, 5);
12391 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12392 tmp = fieldFromInstruction(insn, 16, 5);
12393 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12394 return S;
12395 case 330:
12396 tmp = fieldFromInstruction(insn, 11, 5);
12397 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12398 tmp = fieldFromInstruction(insn, 16, 5);
12399 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12400 return S;
12401 case 331:
12402 tmp = fieldFromInstruction(insn, 11, 5);
12403 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12404 tmp = fieldFromInstruction(insn, 16, 10);
12405 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12406 return S;
12407 case 332:
12408 tmp = fieldFromInstruction(insn, 11, 5);
12409 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12410 tmp = fieldFromInstruction(insn, 16, 5);
12411 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12412 return S;
12413 case 333:
12414 tmp = fieldFromInstruction(insn, 11, 5);
12415 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12416 tmp = fieldFromInstruction(insn, 16, 5);
12417 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12418 return S;
12419 case 334:
12420 tmp = fieldFromInstruction(insn, 11, 5);
12421 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12422 tmp = fieldFromInstruction(insn, 16, 5);
12423 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12424 return S;
12425 case 335:
12426 tmp = fieldFromInstruction(insn, 11, 5);
12427 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12428 tmp = fieldFromInstruction(insn, 16, 5);
12429 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12430 tmp = fieldFromInstruction(insn, 21, 5);
12431 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12432 return S;
12433 case 336:
12434 tmp = fieldFromInstruction(insn, 11, 5);
12435 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12436 tmp = fieldFromInstruction(insn, 16, 5);
12437 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12438 tmp = fieldFromInstruction(insn, 21, 5);
12439 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12440 return S;
12441 case 337:
12442 tmp = fieldFromInstruction(insn, 11, 5);
12443 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12444 tmp = fieldFromInstruction(insn, 16, 5);
12445 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12446 tmp = fieldFromInstruction(insn, 21, 5);
12447 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12448 return S;
12449 case 338:
12450 if (!Check(S, DecodeMemEVA(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12451 return S;
12452 case 339:
12453 if (!Check(S, DecodeCacheeOp_CacheOpR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12454 return S;
12455 case 340:
12456 tmp = fieldFromInstruction(insn, 11, 2);
12457 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12458 tmp = fieldFromInstruction(insn, 21, 5);
12459 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12460 tmp = fieldFromInstruction(insn, 16, 5);
12461 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12462 tmp = fieldFromInstruction(insn, 11, 2);
12463 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12464 return S;
12465 case 341:
12466 tmp = fieldFromInstruction(insn, 16, 5);
12467 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12468 tmp = fieldFromInstruction(insn, 21, 5);
12469 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12470 tmp = fieldFromInstruction(insn, 11, 5);
12471 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12472 tmp = fieldFromInstruction(insn, 16, 5);
12473 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12474 return S;
12475 case 342:
12476 tmp = fieldFromInstruction(insn, 16, 5);
12477 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12478 tmp = fieldFromInstruction(insn, 11, 2);
12479 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12480 tmp = fieldFromInstruction(insn, 21, 5);
12481 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12482 return S;
12483 case 343:
12484 tmp = fieldFromInstruction(insn, 16, 5);
12485 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12486 tmp = fieldFromInstruction(insn, 11, 2);
12487 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12488 tmp = fieldFromInstruction(insn, 21, 5);
12489 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12490 return S;
12491 case 344:
12492 tmp = fieldFromInstruction(insn, 11, 5);
12493 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12494 tmp = fieldFromInstruction(insn, 16, 10);
12495 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12496 return S;
12497 case 345:
12498 tmp = fieldFromInstruction(insn, 21, 5);
12499 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12500 tmp = fieldFromInstruction(insn, 11, 10);
12501 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12502 return S;
12503 case 346:
12504 tmp = fieldFromInstruction(insn, 11, 2);
12505 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12506 tmp = fieldFromInstruction(insn, 20, 6);
12507 if (!Check(S, DecodeSImmWithOffsetAndScale<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12508 tmp = fieldFromInstruction(insn, 11, 2);
12509 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12510 return S;
12511 case 347:
12512 tmp = fieldFromInstruction(insn, 11, 2);
12513 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12514 tmp = fieldFromInstruction(insn, 21, 5);
12515 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12516 tmp = fieldFromInstruction(insn, 11, 2);
12517 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12518 return S;
12519 case 348:
12520 tmp = fieldFromInstruction(insn, 16, 5);
12521 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12522 tmp = fieldFromInstruction(insn, 11, 5);
12523 if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12524 tmp = fieldFromInstruction(insn, 6, 3);
12525 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12526 return S;
12527 case 349:
12528 if (!Check(S, DecodeCacheOp(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12529 return S;
12530 case 350:
12531 if (!Check(S, DecodeFMem(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12532 return S;
12533 case 351:
12534 if (!Check(S, DecodeFMem2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12535 return S;
12536 case 352:
12537 if (!Check(S, DecodeDAHIDATI(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12538 return S;
12539 case 353:
12540 tmp = fieldFromInstruction(insn, 0, 16);
12541 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12542 return S;
12543 case 354:
12544 if (!Check(S, DecodeBlezGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12545 return S;
12546 case 355:
12547 if (!Check(S, DecodeBgtzGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12548 return S;
12549 case 356:
12550 if (!Check(S, DecodeAddiGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12551 return S;
12552 case 357:
12553 tmp = fieldFromInstruction(insn, 16, 5);
12554 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12555 tmp = fieldFromInstruction(insn, 0, 16);
12556 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12557 return S;
12558 case 358:
12559 tmp = fieldFromInstruction(insn, 6, 5);
12560 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12561 tmp = fieldFromInstruction(insn, 6, 5);
12562 if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12563 tmp = fieldFromInstruction(insn, 11, 5);
12564 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12565 tmp = fieldFromInstruction(insn, 16, 5);
12566 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12567 return S;
12568 case 359:
12569 tmp = fieldFromInstruction(insn, 6, 5);
12570 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12571 tmp = fieldFromInstruction(insn, 6, 5);
12572 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12573 tmp = fieldFromInstruction(insn, 11, 5);
12574 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12575 tmp = fieldFromInstruction(insn, 16, 5);
12576 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12577 return S;
12578 case 360:
12579 tmp = fieldFromInstruction(insn, 6, 5);
12580 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12581 tmp = fieldFromInstruction(insn, 6, 5);
12582 if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12583 tmp = fieldFromInstruction(insn, 11, 5);
12584 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12585 tmp = fieldFromInstruction(insn, 16, 5);
12586 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12587 return S;
12588 case 361:
12589 tmp = fieldFromInstruction(insn, 6, 5);
12590 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12591 tmp = fieldFromInstruction(insn, 11, 5);
12592 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12593 tmp = fieldFromInstruction(insn, 16, 5);
12594 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12595 return S;
12596 case 362:
12597 tmp = fieldFromInstruction(insn, 6, 5);
12598 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12599 tmp = fieldFromInstruction(insn, 6, 5);
12600 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12601 tmp = fieldFromInstruction(insn, 11, 5);
12602 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12603 tmp = fieldFromInstruction(insn, 16, 5);
12604 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12605 return S;
12606 case 363:
12607 tmp = fieldFromInstruction(insn, 6, 5);
12608 if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12609 tmp = fieldFromInstruction(insn, 11, 5);
12610 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12611 tmp = fieldFromInstruction(insn, 16, 5);
12612 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12613 return S;
12614 case 364:
12615 tmp = fieldFromInstruction(insn, 6, 5);
12616 if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12617 tmp = fieldFromInstruction(insn, 11, 5);
12618 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12619 tmp = fieldFromInstruction(insn, 16, 5);
12620 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12621 return S;
12622 case 365:
12623 tmp = fieldFromInstruction(insn, 16, 5);
12624 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12625 tmp = fieldFromInstruction(insn, 0, 16);
12626 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12627 return S;
12628 case 366:
12629 if (!Check(S, DecodeFMemCop2R6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12630 return S;
12631 case 367:
12632 if (!Check(S, DecodeBlezlGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12633 return S;
12634 case 368:
12635 if (!Check(S, DecodeBgtzlGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12636 return S;
12637 case 369:
12638 if (!Check(S, DecodeDaddiGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12639 return S;
12640 case 370:
12641 tmp = fieldFromInstruction(insn, 16, 5);
12642 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12643 tmp = fieldFromInstruction(insn, 21, 5);
12644 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12645 tmp = fieldFromInstruction(insn, 0, 16);
12646 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12647 return S;
12648 case 371:
12649 if (!Check(S, DecodeCRC(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12650 return S;
12651 case 372:
12652 tmp = fieldFromInstruction(insn, 11, 5);
12653 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12654 tmp = fieldFromInstruction(insn, 21, 5);
12655 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12656 tmp = fieldFromInstruction(insn, 16, 5);
12657 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12658 tmp = fieldFromInstruction(insn, 6, 2);
12659 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12660 return S;
12661 case 373:
12662 tmp = fieldFromInstruction(insn, 11, 5);
12663 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12664 tmp = fieldFromInstruction(insn, 16, 5);
12665 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12666 return S;
12667 case 374:
12668 tmp = fieldFromInstruction(insn, 11, 5);
12669 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12670 tmp = fieldFromInstruction(insn, 21, 5);
12671 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12672 tmp = fieldFromInstruction(insn, 16, 5);
12673 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12674 tmp = fieldFromInstruction(insn, 6, 3);
12675 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12676 return S;
12677 case 375:
12678 if (!Check(S, DecodeSpecial3LlSc(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12679 return S;
12680 case 376:
12681 tmp = fieldFromInstruction(insn, 21, 5);
12682 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12683 tmp = fieldFromInstruction(insn, 8, 2);
12684 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12685 return S;
12686 case 377:
12687 tmp = fieldFromInstruction(insn, 0, 26);
12688 if (!Check(S, DecodeBranchTarget26(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12689 return S;
12690 case 378:
12691 tmp = fieldFromInstruction(insn, 21, 5);
12692 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12693 tmp = fieldFromInstruction(insn, 0, 21);
12694 if (!Check(S, DecodeBranchTarget21(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12695 return S;
12696 case 379:
12697 tmp = fieldFromInstruction(insn, 21, 5);
12698 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12699 tmp = fieldFromInstruction(insn, 0, 18);
12700 if (!Check(S, DecodeSimm18Lsl3(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12701 return S;
12702 case 380:
12703 tmp = fieldFromInstruction(insn, 21, 5);
12704 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12705 tmp = fieldFromInstruction(insn, 0, 21);
12706 if (!Check(S, DecodeBranchTarget21(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12707 return S;
12708 case 381:
12709 tmp = fieldFromInstruction(insn, 11, 5);
12710 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12711 tmp = fieldFromInstruction(insn, 16, 5);
12712 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12713 tmp = fieldFromInstruction(insn, 21, 5);
12714 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12715 return S;
12716 case 382:
12717 tmp = fieldFromInstruction(insn, 21, 5);
12718 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12719 tmp = fieldFromInstruction(insn, 16, 5);
12720 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12721 return S;
12722 case 383:
12723 tmp = fieldFromInstruction(insn, 11, 5);
12724 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12725 tmp = fieldFromInstruction(insn, 16, 5);
12726 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12727 tmp = fieldFromInstruction(insn, 6, 5);
12728 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12729 return S;
12730 case 384:
12731 tmp = fieldFromInstruction(insn, 16, 5);
12732 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12733 tmp = fieldFromInstruction(insn, 11, 5);
12734 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12735 tmp = fieldFromInstruction(insn, 0, 3);
12736 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12737 return S;
12738 case 385:
12739 tmp = fieldFromInstruction(insn, 11, 5);
12740 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12741 tmp = fieldFromInstruction(insn, 16, 5);
12742 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12743 tmp = fieldFromInstruction(insn, 0, 3);
12744 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12745 return S;
12746 case 386:
12747 tmp = fieldFromInstruction(insn, 16, 5);
12748 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12749 tmp = fieldFromInstruction(insn, 11, 5);
12750 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12751 tmp = fieldFromInstruction(insn, 0, 3);
12752 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12753 return S;
12754 case 387:
12755 tmp = fieldFromInstruction(insn, 11, 5);
12756 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12757 tmp = fieldFromInstruction(insn, 16, 5);
12758 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12759 tmp = fieldFromInstruction(insn, 0, 3);
12760 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12761 return S;
12762 case 388:
12763 tmp = fieldFromInstruction(insn, 13, 3);
12764 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12765 tmp = fieldFromInstruction(insn, 16, 5);
12766 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12767 tmp = fieldFromInstruction(insn, 21, 5);
12768 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12769 return S;
12770 case 389:
12771 tmp = fieldFromInstruction(insn, 16, 5);
12772 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12773 tmp = fieldFromInstruction(insn, 21, 5);
12774 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12775 tmp = fieldFromInstruction(insn, 0, 16);
12776 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12777 return S;
12778 case 390:
12779 tmp = 0x0;
12780 tmp |= fieldFromInstruction(insn, 11, 5);
12781 tmp |= fieldFromInstruction(insn, 16, 5);
12782 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12783 tmp = fieldFromInstruction(insn, 21, 5);
12784 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12785 return S;
12786 case 391:
12787 if (!Check(S, DecodeDEXT(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12788 return S;
12789 case 392:
12790 if (!Check(S, DecodeDINS(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12791 return S;
12792 case 393:
12793 tmp = fieldFromInstruction(insn, 16, 5);
12794 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12795 tmp = fieldFromInstruction(insn, 11, 5);
12796 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12797 return S;
12798 case 394:
12799 tmp = fieldFromInstruction(insn, 11, 5);
12800 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12801 tmp = fieldFromInstruction(insn, 16, 5);
12802 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12803 return S;
12804 case 395:
12805 tmp = fieldFromInstruction(insn, 11, 5);
12806 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12807 tmp = fieldFromInstruction(insn, 11, 5);
12808 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12809 tmp = fieldFromInstruction(insn, 16, 5);
12810 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12811 return S;
12812 case 396:
12813 tmp = fieldFromInstruction(insn, 6, 5);
12814 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12815 tmp = fieldFromInstruction(insn, 11, 5);
12816 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12817 return S;
12818 case 397:
12819 tmp = fieldFromInstruction(insn, 6, 5);
12820 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12821 tmp = fieldFromInstruction(insn, 11, 5);
12822 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12823 tmp = fieldFromInstruction(insn, 18, 3);
12824 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12825 tmp = fieldFromInstruction(insn, 6, 5);
12826 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12827 return S;
12828 case 398:
12829 tmp = fieldFromInstruction(insn, 6, 5);
12830 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12831 tmp = fieldFromInstruction(insn, 11, 5);
12832 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12833 tmp = fieldFromInstruction(insn, 16, 5);
12834 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12835 tmp = fieldFromInstruction(insn, 6, 5);
12836 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12837 return S;
12838 case 399:
12839 tmp = fieldFromInstruction(insn, 6, 5);
12840 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12841 tmp = fieldFromInstruction(insn, 11, 5);
12842 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12843 tmp = fieldFromInstruction(insn, 16, 5);
12844 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12845 return S;
12846 case 400:
12847 tmp = fieldFromInstruction(insn, 8, 3);
12848 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12849 tmp = fieldFromInstruction(insn, 11, 5);
12850 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12851 tmp = fieldFromInstruction(insn, 16, 5);
12852 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12853 return S;
12854 case 401:
12855 tmp = fieldFromInstruction(insn, 6, 5);
12856 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12857 tmp = fieldFromInstruction(insn, 21, 5);
12858 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12859 tmp = fieldFromInstruction(insn, 16, 5);
12860 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12861 return S;
12862 case 402:
12863 tmp = fieldFromInstruction(insn, 11, 5);
12864 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12865 tmp = fieldFromInstruction(insn, 21, 5);
12866 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12867 tmp = fieldFromInstruction(insn, 16, 5);
12868 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12869 return S;
12870 case 403:
12871 tmp = fieldFromInstruction(insn, 6, 5);
12872 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12873 tmp = fieldFromInstruction(insn, 21, 5);
12874 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12875 tmp = fieldFromInstruction(insn, 11, 5);
12876 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12877 tmp = fieldFromInstruction(insn, 16, 5);
12878 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12879 return S;
12880 }
12881}
12882static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) {
12883 switch (Idx) {
12884 default: llvm_unreachable("Invalid index!");
12885 case 0:
12886 return FB[Mips::FeatureMips16];
12887 case 1:
12888 return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureMips32r6];
12889 case 2:
12890 return FB[Mips::FeatureMicroMips];
12891 case 3:
12892 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6];
12893 case 4:
12894 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureR5900] && !FB[Mips::FeatureCnMips] && !FB[Mips::FeatureMicroMips];
12895 case 5:
12896 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureR5900] && !FB[Mips::FeatureCnMips] && !FB[Mips::FeatureMicroMips];
12897 case 6:
12898 return FB[Mips::FeatureCnMips];
12899 case 7:
12900 return FB[Mips::FeatureMips64] && FB[Mips::FeatureCnMips] && !FB[Mips::FeatureMicroMips];
12901 case 8:
12902 return FB[Mips::FeatureCnMipsP];
12903 case 9:
12904 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSP];
12905 case 10:
12906 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSPR2];
12907 case 11:
12908 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r5] && FB[Mips::FeatureVirt];
12909 case 12:
12910 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSPR3];
12911 case 13:
12912 return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureMips32r6] && FB[Mips::FeatureDSP];
12913 case 14:
12914 return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat];
12915 case 15:
12916 return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureNoMadd4];
12917 case 16:
12918 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat];
12919 case 17:
12920 return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureNoMadd4];
12921 case 18:
12922 return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat];
12923 case 19:
12924 return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureSoftFloat];
12925 case 20:
12926 return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureSoftFloat];
12927 case 21:
12928 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureSoftFloat];
12929 case 22:
12930 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureEVA];
12931 case 23:
12932 return FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureMips32r6] && FB[Mips::FeatureEVA];
12933 case 24:
12934 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat];
12935 case 25:
12936 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureGINV];
12937 case 26:
12938 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat];
12939 case 27:
12940 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureMicroMips];
12941 case 28:
12942 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureMicroMips];
12943 case 29:
12944 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
12945 case 30:
12946 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMSA];
12947 case 31:
12948 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
12949 case 32:
12950 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6];
12951 case 33:
12952 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureUseIndirectJumpsHazard];
12953 case 34:
12954 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32];
12955 case 35:
12956 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
12957 case 36:
12958 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureMicroMips];
12959 case 37:
12960 return FB[Mips::FeatureDSP];
12961 case 38:
12962 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMSA] && FB[Mips::FeatureMips64];
12963 case 39:
12964 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
12965 case 40:
12966 return FB[Mips::FeatureDSP] && !FB[Mips::FeatureMicroMips];
12967 case 41:
12968 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r5] && FB[Mips::FeatureVirt] && !FB[Mips::FeatureMicroMips];
12969 case 42:
12970 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMT] && !FB[Mips::FeatureMicroMips];
12971 case 43:
12972 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3_32] && !FB[Mips::FeatureMicroMips];
12973 case 44:
12974 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r2] && FB[Mips::FeatureEVA] && !FB[Mips::FeatureMicroMips];
12975 case 45:
12976 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r5] && !FB[Mips::FeatureMicroMips];
12977 case 46:
12978 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32] && !FB[Mips::FeatureMicroMips];
12979 case 47:
12980 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
12981 case 48:
12982 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
12983 case 49:
12984 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
12985 case 50:
12986 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
12987 case 51:
12988 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
12989 case 52:
12990 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
12991 case 53:
12992 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureSoftFloat];
12993 case 54:
12994 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
12995 case 55:
12996 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
12997 case 56:
12998 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3_32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
12999 case 57:
13000 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13001 case 58:
13002 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13003 case 59:
13004 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13005 case 60:
13006 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13007 case 61:
13008 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat];
13009 case 62:
13010 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13011 case 63:
13012 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips5_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13013 case 64:
13014 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureNoMadd4];
13015 case 65:
13016 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureNoMadd4];
13017 case 66:
13018 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureNoMadd4] && !FB[Mips::FeatureMicroMips];
13019 case 67:
13020 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureNoMadd4] && !FB[Mips::FeatureMicroMips];
13021 case 68:
13022 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
13023 case 69:
13024 return FB[Mips::FeatureDSPR2];
13025 case 70:
13026 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && FB[Mips::FeatureEVA] && !FB[Mips::FeatureMicroMips];
13027 case 71:
13028 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3_32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
13029 case 72:
13030 return !FB[Mips::FeatureMips16] && !FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureR5900] && !FB[Mips::FeatureMicroMips];
13031 case 73:
13032 return !FB[Mips::FeatureMips16] && FB[Mips::FeaturePTR64Bit] && !FB[Mips::FeatureMicroMips];
13033 case 74:
13034 return !FB[Mips::FeatureMips16] && FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureR5900] && !FB[Mips::FeatureMicroMips];
13035 case 75:
13036 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r6];
13037 case 76:
13038 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMicroMips];
13039 case 77:
13040 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
13041 case 78:
13042 return !FB[Mips::FeatureMips16] && !FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMicroMips];
13043 case 79:
13044 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13045 case 80:
13046 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureCRC] && !FB[Mips::FeatureMicroMips];
13047 case 81:
13048 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64r6] && FB[Mips::FeatureCRC] && !FB[Mips::FeatureMicroMips];
13049 case 82:
13050 return !FB[Mips::FeatureMips16] && !FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMicroMips];
13051 case 83:
13052 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureGINV] && !FB[Mips::FeatureMicroMips];
13053 case 84:
13054 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64r6];
13055 case 85:
13056 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips64r6];
13057 case 86:
13058 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips32r6];
13059 case 87:
13060 return !FB[Mips::FeatureMips16] && FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
13061 case 88:
13062 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
13063 case 89:
13064 return !FB[Mips::FeatureMips16] && FB[Mips::FeaturePTR64Bit];
13065 case 90:
13066 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64r2] && !FB[Mips::FeatureMicroMips];
13067 case 91:
13068 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3] && !FB[Mips::FeatureMicroMips];
13069 case 92:
13070 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureR5900] && !FB[Mips::FeatureMicroMips];
13071 case 93:
13072 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips3];
13073 case 94:
13074 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips64r5] && FB[Mips::FeatureVirt];
13075 case 95:
13076 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6];
13077 case 96:
13078 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips64] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureMicroMips];
13079 case 97:
13080 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureMips3] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureR5900];
13081 case 98:
13082 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureDSP];
13083 case 99:
13084 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13085 case 100:
13086 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13087 case 101:
13088 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13089 case 102:
13090 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13091 case 103:
13092 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips3_32] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13093 case 104:
13094 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13095 case 105:
13096 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13097 case 106:
13098 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && FB[Mips::FeatureMips3D];
13099 case 107:
13100 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips3_32r2] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13101 case 108:
13102 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13103 case 109:
13104 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat];
13105 case 110:
13106 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips5_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips];
13107 case 111:
13108 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureMicroMips] && !FB[Mips::FeatureNoMadd4];
13109 case 112:
13110 return !FB[Mips::FeatureMips16] && FB[Mips::FeatureFP64Bit] && FB[Mips::FeatureMips4_32r2] && !FB[Mips::FeatureMips32r6] && !FB[Mips::FeatureMips64r6] && !FB[Mips::FeatureSoftFloat] && !FB[Mips::FeatureNoMadd4] && !FB[Mips::FeatureMicroMips];
13111 }
13112}
13113
13114
13115template <typename InsnType>
13116static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
13117 InsnType insn, uint64_t Address,
13118 const MCDisassembler *DisAsm,
13119 const MCSubtargetInfo &STI) {
13120 const FeatureBitset &Bits = STI.getFeatureBits();
13121 const uint8_t *Ptr = DecodeTable;
13122
13123 SmallVector<const uint8_t *, 8> ScopeStack;
13124 DecodeStatus S = MCDisassembler::Success;
13125 while (true) {
13126 ptrdiff_t Loc = Ptr - DecodeTable;
13127 const uint8_t DecoderOp = *Ptr++;
13128 switch (DecoderOp) {
13129 default:
13130 errs() << Loc << ": Unexpected decode table opcode: "
13131 << (int)DecoderOp << '\n';
13132 return MCDisassembler::Fail;
13133 case OPC_Scope: {
13134 unsigned NumToSkip = decodeULEB128AndIncUnsafe(p&: Ptr);
13135 const uint8_t *SkipTo = Ptr + NumToSkip;
13136 ScopeStack.push_back(Elt: SkipTo);
13137 LLVM_DEBUG(dbgs() << Loc << ": OPC_Scope(" << SkipTo - DecodeTable
13138 << ")\n");
13139 continue;
13140 }
13141 case OPC_SwitchField: {
13142 // Decode the start value.
13143 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
13144 unsigned Len = *Ptr++;
13145 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
13146 uint64_t CaseValue;
13147 unsigned CaseSize;
13148 while (true) {
13149 CaseValue = decodeULEB128AndIncUnsafe(p&: Ptr);
13150 CaseSize = decodeULEB128AndIncUnsafe(p&: Ptr);
13151 if (FieldValue == CaseValue || !CaseSize)
13152 break;
13153 Ptr += CaseSize;
13154 }
13155 if (FieldValue == CaseValue) {
13156 LLVM_DEBUG(dbgs() << Loc << ": OPC_SwitchField(" << Start << ", " << Len
13157 << "): " << FieldValue << '\n');
13158 continue;
13159 }
13160 break;
13161 }
13162 case OPC_CheckField: {
13163 // Decode the start value.
13164 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
13165 unsigned Len = *Ptr;
13166 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
13167 // Decode the field value.
13168 unsigned PtrLen = 0;
13169 uint64_t ExpectedValue = decodeULEB128(p: ++Ptr, n: &PtrLen);
13170 Ptr += PtrLen;
13171 bool Failed = ExpectedValue != FieldValue;
13172
13173 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckField(" << Start << ", " << Len
13174 << ", " << ExpectedValue << "): FieldValue = "
13175 << FieldValue << ", ExpectedValue = " << ExpectedValue
13176 << ": " << (Failed ? "FAIL, " : "PASS\n"););
13177 if (!Failed)
13178 continue;
13179 break;
13180 }
13181 case OPC_CheckPredicate: {
13182 // Decode the Predicate Index value.
13183 unsigned PIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
13184 // Check the predicate.
13185 bool Failed = !checkDecoderPredicate(Idx: PIdx, FB: Bits);
13186
13187 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckPredicate(" << PIdx << "): "
13188 << (Failed ? "FAIL, " : "PASS\n"););
13189 if (!Failed)
13190 continue;
13191 break;
13192 }
13193 case OPC_Decode: {
13194 // Decode the Opcode value.
13195 unsigned Opc = decodeULEB128AndIncUnsafe(p&: Ptr);
13196 unsigned DecodeIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
13197
13198 MI.clear();
13199 MI.setOpcode(Opc);
13200 bool DecodeComplete;
13201 S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm,
13202 DecodeComplete);
13203 LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc
13204 << ", using decoder " << DecodeIdx << ": "
13205 << (S ? "PASS, " : "FAIL, "));
13206
13207 if (DecodeComplete) {
13208 LLVM_DEBUG(dbgs() << "decoding complete\n");
13209 return S;
13210 }
13211 assert(S == MCDisassembler::Fail);
13212 // Reset decode status. This also drops a SoftFail status that could be
13213 // set before the decode attempt.
13214 S = MCDisassembler::Success;
13215 break;
13216 }
13217 }
13218 if (ScopeStack.empty()) {
13219 LLVM_DEBUG(dbgs() << "returning Fail\n");
13220 return MCDisassembler::Fail;
13221 }
13222 Ptr = ScopeStack.pop_back_val();
13223 LLVM_DEBUG(dbgs() << "continuing at " << Ptr - DecodeTable << '\n');
13224 }
13225 llvm_unreachable("bogosity detected in disassembler state machine!");
13226}
13227
13228
13229} // namespace
13230