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, 139, 9, 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, 137, 9, 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, 141, 9, 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, 174, 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, 220, 23, 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, 222, 23, 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, 144, 9, 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, 146, 9, 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, 177, 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, 153, 19, 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, 154, 19, 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, 16, 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, 219, 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, 16, 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, 179, 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, 229, 23, 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, 180, 15, 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, 177, 15, 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, 179, 15, 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, 178, 15, 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, 219, 23, 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, 224, 23, 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, 218, 23, 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, 143, 9, 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, 228, 23, 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, 226, 23, 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, 218, 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, 180, 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, 203, 19, 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, 206, 24, 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, 187, 19, 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, 151, 19, 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, 214, 23, 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, 215, 23, 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, 152, 19, 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, 233, 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, 234, 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, 186, 19, 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, 206, 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, 248, 22, 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, 189, 15, 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, 234, 17, 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, 245, 21, 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, 186, 22, 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, 240, 15, 18, // 65: decode to LHU16_MM using decoder 18
295 // 65: }
296 11, 6, // 69: case 0xb: {
297 OPC_CheckPredicate, 1, // 71: check predicate 1
298 OPC_Decode, 129, 7, 19, // 73: decode to ANDI16_MM using decoder 19
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, 183, 19, 20, // 87: decode to NOT16_MM using decoder 20
305 // 87: }
306 1, 6, // 91: case 0x1: {
307 OPC_CheckPredicate, 1, // 93: check predicate 1
308 OPC_Decode, 192, 24, 21, // 95: decode to XOR16_MM using decoder 21
309 // 95: }
310 2, 6, // 99: case 0x2: {
311 OPC_CheckPredicate, 1, // 101: check predicate 1
312 OPC_Decode, 253, 6, 21, // 103: decode to AND16_MM using decoder 21
313 // 103: }
314 3, 6, // 107: case 0x3: {
315 OPC_CheckPredicate, 1, // 109: check predicate 1
316 OPC_Decode, 189, 19, 21, // 111: decode to OR16_MM using decoder 21
317 // 111: }
318 4, 6, // 115: case 0x4: {
319 OPC_CheckPredicate, 1, // 117: check predicate 1
320 OPC_Decode, 182, 16, 22, // 119: decode to LWM16_MM using decoder 22
321 // 119: }
322 5, 6, // 123: case 0x5: {
323 OPC_CheckPredicate, 1, // 125: check predicate 1
324 OPC_Decode, 176, 23, 22, // 127: decode to SWM16_MM using decoder 22
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, 161, 15, 23, // 140: decode to JR16_MM using decoder 23
331 // 140: }
332 1, 0, // 144: case 0x1: {
333 OPC_CheckPredicate, 1, // 146: check predicate 1
334 OPC_Decode, 164, 15, 23, // 148: decode to JRC16_MM using decoder 23
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, 136, 15, 23, // 161: decode to JALR16_MM using decoder 23
343 // 161: }
344 1, 0, // 165: case 0x1: {
345 OPC_CheckPredicate, 1, // 167: check predicate 1
346 OPC_Decode, 144, 15, 23, // 169: decode to JALRS16_MM using decoder 23
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, 178, 17, 23, // 181: decode to MFHI16_MM using decoder 23
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, 184, 17, 23, // 193: decode to MFLO16_MM using decoder 23
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, 242, 8, 24, // 205: decode to BREAK16_MM using decoder 24
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, 245, 20, 24, // 217: decode to SDBBP16_MM using decoder 24
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, 163, 15, 25, // 229: decode to JRADDIUSP using decoder 25
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, 196, 16, 26, // 237: decode to LWSP_MM using decoder 26
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, 173, 6, 27, // 250: decode to ADDIUS5_MM using decoder 27
386 // 250: }
387 1, 0, // 254: case 0x1: {
388 OPC_CheckPredicate, 2, // 256: check predicate 2
389 OPC_Decode, 174, 6, 28, // 258: decode to ADDIUSP_MM using decoder 28
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, 175, 16, 29, // 266: decode to LWGP_MM using decoder 29
396 // 266: }
397 26, 6, // 270: case 0x1a: {
398 OPC_CheckPredicate, 2, // 272: check predicate 2
399 OPC_Decode, 160, 16, 30, // 274: decode to LW16_MM using decoder 30
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, 170, 6, 31, // 287: decode to ADDIUR2_MM using decoder 31
406 // 287: }
407 1, 0, // 291: case 0x1: {
408 OPC_CheckPredicate, 2, // 293: check predicate 2
409 OPC_Decode, 168, 6, 32, // 295: decode to ADDIUR1SP_MM using decoder 32
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, 238, 17, 33, // 307: decode to MOVEP_MM using decoder 33
417 // 307: }
418 34, 6, // 311: case 0x22: {
419 OPC_CheckPredicate, 1, // 313: check predicate 1
420 OPC_Decode, 219, 20, 34, // 315: decode to SB16_MM using decoder 34
421 // 315: }
422 35, 6, // 319: case 0x23: {
423 OPC_CheckPredicate, 1, // 321: check predicate 1
424 OPC_Decode, 232, 7, 35, // 323: decode to BEQZ16_MM using decoder 35
425 // 323: }
426 42, 6, // 327: case 0x2a: {
427 OPC_CheckPredicate, 1, // 329: check predicate 1
428 OPC_Decode, 169, 21, 36, // 331: decode to SH16_MM using decoder 36
429 // 331: }
430 43, 6, // 335: case 0x2b: {
431 OPC_CheckPredicate, 1, // 337: check predicate 1
432 OPC_Decode, 219, 8, 35, // 339: decode to BNEZ16_MM using decoder 35
433 // 339: }
434 50, 6, // 343: case 0x32: {
435 OPC_CheckPredicate, 1, // 345: check predicate 1
436 OPC_Decode, 188, 23, 26, // 347: decode to SWSP_MM using decoder 26
437 // 347: }
438 51, 6, // 351: case 0x33: {
439 OPC_CheckPredicate, 2, // 353: check predicate 2
440 OPC_Decode, 181, 7, 37, // 355: decode to B16_MM using decoder 37
441 // 355: }
442 58, 6, // 359: case 0x3a: {
443 OPC_CheckPredicate, 1, // 361: check predicate 1
444 OPC_Decode, 154, 23, 38, // 363: decode to SW16_MM using decoder 38
445 // 363: }
446 59, 0, // 367: case 0x3b: {
447 OPC_CheckPredicate, 1, // 369: check predicate 1
448 OPC_Decode, 131, 16, 39, // 371: decode to LI16_MM using decoder 39
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, 207, 6, 40, // 12: decode to ADDU16_MMR6 using decoder 40
459 // 12: }
460 1, 0, // 16: case 0x1: {
461 OPC_CheckPredicate, 3, // 18: check predicate 3
462 OPC_Decode, 249, 22, 40, // 20: decode to SUBU16_MMR6 using decoder 40
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, 235, 17, 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, 246, 21, 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, 187, 22, 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, 130, 7, 19, // 57: decode to ANDI16_MMR6 using decoder 19
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, 184, 19, 41, // 81: decode to NOT16_MMR6 using decoder 41
495 // 81: }
496 1, 0, // 85: case 0x1: {
497 OPC_CheckPredicate, 3, // 87: check predicate 3
498 OPC_Decode, 193, 24, 42, // 89: decode to XOR16_MMR6 using decoder 42
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, 254, 6, 42, // 102: decode to AND16_MMR6 using decoder 42
507 // 102: }
508 1, 0, // 106: case 0x1: {
509 OPC_CheckPredicate, 3, // 108: check predicate 3
510 OPC_Decode, 190, 19, 42, // 110: decode to OR16_MMR6 using decoder 42
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, 183, 16, 43, // 123: decode to LWM16_MMR6 using decoder 43
519 // 123: }
520 1, 0, // 127: case 0x1: {
521 OPC_CheckPredicate, 3, // 129: check predicate 3
522 OPC_Decode, 177, 23, 43, // 131: decode to SWM16_MMR6 using decoder 43
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, 165, 15, 44, // 144: decode to JRC16_MMR6 using decoder 44
531 // 144: }
532 1, 6, // 148: case 0x1: {
533 OPC_CheckPredicate, 3, // 150: check predicate 3
534 OPC_Decode, 138, 15, 44, // 152: decode to JALRC16_MMR6 using decoder 44
535 // 152: }
536 2, 6, // 156: case 0x2: {
537 OPC_CheckPredicate, 3, // 158: check predicate 3
538 OPC_Decode, 166, 15, 45, // 160: decode to JRCADDIUSP_MMR6 using decoder 45
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, 243, 8, 46, // 173: decode to BREAK16_MMR6 using decoder 46
545 // 173: }
546 1, 0, // 177: case 0x1: {
547 OPC_CheckPredicate, 3, // 179: check predicate 3
548 OPC_Decode, 246, 20, 46, // 181: decode to SDBBP16_MMR6 using decoder 46
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, 239, 17, 33, // 189: decode to MOVEP_MMR6 using decoder 33
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, 220, 20, 34, // 197: decode to SB16_MMR6 using decoder 34
565 // 197: }
566 35, 6, // 201: case 0x23: {
567 OPC_CheckPredicate, 3, // 203: check predicate 3
568 OPC_Decode, 236, 7, 35, // 205: decode to BEQZC16_MMR6 using decoder 35
569 // 205: }
570 42, 6, // 209: case 0x2a: {
571 OPC_CheckPredicate, 3, // 211: check predicate 3
572 OPC_Decode, 170, 21, 36, // 213: decode to SH16_MMR6 using decoder 36
573 // 213: }
574 43, 6, // 217: case 0x2b: {
575 OPC_CheckPredicate, 3, // 219: check predicate 3
576 OPC_Decode, 223, 8, 35, // 221: decode to BNEZC16_MMR6 using decoder 35
577 // 221: }
578 50, 6, // 225: case 0x32: {
579 OPC_CheckPredicate, 3, // 227: check predicate 3
580 OPC_Decode, 189, 23, 26, // 229: decode to SWSP_MMR6 using decoder 26
581 // 229: }
582 51, 6, // 233: case 0x33: {
583 OPC_CheckPredicate, 3, // 235: check predicate 3
584 OPC_Decode, 198, 7, 37, // 237: decode to BC16_MMR6 using decoder 37
585 // 237: }
586 58, 6, // 241: case 0x3a: {
587 OPC_CheckPredicate, 3, // 243: check predicate 3
588 OPC_Decode, 155, 23, 38, // 245: decode to SW16_MMR6 using decoder 38
589 // 245: }
590 59, 0, // 249: case 0x3b: {
591 OPC_CheckPredicate, 3, // 251: check predicate 3
592 OPC_Decode, 132, 16, 39, // 253: decode to LI16_MMR6 using decoder 39
593 // 253: }
594 // 253: } // switch Inst[15:10]
595};
596static const uint8_t DecoderTableNanoMips16[454] = {
597 OPC_SwitchField, 10, 6, // 0: switch Inst[15:10] {
598 4, 39, // 3: case 0x4: {
599 OPC_Scope, 10, // 5: try {
600 OPC_CheckField, 2, 8, 2, // 7: check Inst[9:2] == 0x2
601 OPC_CheckPredicate, 4, // 11: check predicate 4
602 OPC_Decode, 208, 23, 47, // 13: decode to SYSCALL16_NM using decoder 47
603 OPC_Scope, 19, // 17: } else try {
604 OPC_SwitchField, 3, 7, // 19: switch Inst[9:3] {
605 2, 6, // 22: case 0x2: {
606 OPC_CheckPredicate, 4, // 24: check predicate 4
607 OPC_Decode, 244, 8, 48, // 26: decode to BREAK16_NM using decoder 48
608 // 26: }
609 3, 0, // 30: case 0x3: {
610 OPC_CheckPredicate, 4, // 32: check predicate 4
611 OPC_Decode, 247, 20, 48, // 34: decode to SDBBP16_NM using decoder 48
612 // 34: }
613 // 34: } // switch Inst[9:3]
614 // 34: } else try {
615 OPC_CheckPredicate, 4, // 38: check predicate 4
616 OPC_Decode, 241, 17, 49, // 40: decode to MOVE_NM using decoder 49
617 // 40: }
618 // 40: }
619 5, 6, // 44: case 0x5: {
620 OPC_CheckPredicate, 4, // 46: check predicate 4
621 OPC_Decode, 161, 16, 50, // 48: decode to LW16_NM using decoder 50
622 // 48: }
623 6, 6, // 52: case 0x6: {
624 OPC_CheckPredicate, 4, // 54: check predicate 4
625 OPC_Decode, 199, 7, 51, // 56: decode to BC16_NM using decoder 51
626 // 56: }
627 7, 19, // 60: case 0x7: {
628 OPC_SwitchField, 8, 1, // 62: switch Inst[8] {
629 0, 6, // 65: case 0x0: {
630 OPC_CheckPredicate, 4, // 67: check predicate 4
631 OPC_Decode, 216, 20, 52, // 69: decode to SAVE16_NM using decoder 52
632 // 69: }
633 1, 0, // 73: case 0x1: {
634 OPC_CheckPredicate, 4, // 75: check predicate 4
635 OPC_Decode, 173, 20, 52, // 77: decode to RESTOREJRC16_NM using decoder 52
636 // 77: }
637 // 77: } // switch Inst[8]
638 // 77: }
639 12, 19, // 81: case 0xc: {
640 OPC_SwitchField, 3, 1, // 83: switch Inst[3] {
641 0, 6, // 86: case 0x0: {
642 OPC_CheckPredicate, 4, // 88: check predicate 4
643 OPC_Decode, 247, 21, 53, // 90: decode to SLL16_NM using decoder 53
644 // 90: }
645 1, 0, // 94: case 0x1: {
646 OPC_CheckPredicate, 4, // 96: check predicate 4
647 OPC_Decode, 188, 22, 53, // 98: decode to SRL16_NM using decoder 53
648 // 98: }
649 // 98: } // switch Inst[3]
650 // 98: }
651 13, 6, // 102: case 0xd: {
652 OPC_CheckPredicate, 4, // 104: check predicate 4
653 OPC_Decode, 195, 16, 54, // 106: decode to LWSP16_NM using decoder 54
654 // 106: }
655 14, 6, // 110: case 0xe: {
656 OPC_CheckPredicate, 4, // 112: check predicate 4
657 OPC_Decode, 185, 7, 51, // 114: decode to BALC16_NM using decoder 51
658 // 114: }
659 15, 27, // 118: case 0xf: {
660 OPC_SwitchField, 3, 1, // 120: switch Inst[3] {
661 0, 10, // 123: case 0x0: {
662 OPC_CheckPredicate, 4, // 125: check predicate 4
663 OPC_CheckField, 8, 1, 0, // 127: check Inst[8] == 0x0
664 OPC_Decode, 244, 6, 55, // 131: decode to ADDu4x4_NM using decoder 55
665 // 131: }
666 1, 0, // 135: case 0x1: {
667 OPC_CheckPredicate, 4, // 137: check predicate 4
668 OPC_CheckField, 8, 1, 0, // 139: check Inst[8] == 0x0
669 OPC_Decode, 230, 18, 55, // 143: decode to MUL4x4_NM using decoder 55
670 // 143: }
671 // 143: } // switch Inst[3]
672 // 143: }
673 20, 48, // 147: case 0x14: {
674 OPC_SwitchField, 0, 1, // 149: switch Inst[0] {
675 0, 35, // 152: case 0x0: {
676 OPC_SwitchField, 1, 3, // 154: switch Inst[3:1] {
677 0, 6, // 157: case 0x0: {
678 OPC_CheckPredicate, 4, // 159: check predicate 4
679 OPC_Decode, 185, 19, 56, // 161: decode to NOT16_NM using decoder 56
680 // 161: }
681 2, 6, // 165: case 0x2: {
682 OPC_CheckPredicate, 4, // 167: check predicate 4
683 OPC_Decode, 194, 24, 57, // 169: decode to XOR16_NM using decoder 57
684 // 169: }
685 4, 6, // 173: case 0x4: {
686 OPC_CheckPredicate, 4, // 175: check predicate 4
687 OPC_Decode, 255, 6, 57, // 177: decode to AND16_NM using decoder 57
688 // 177: }
689 6, 0, // 181: case 0x6: {
690 OPC_CheckPredicate, 4, // 183: check predicate 4
691 OPC_Decode, 191, 19, 57, // 185: decode to OR16_NM using decoder 57
692 // 185: }
693 // 185: } // switch Inst[3:1]
694 // 185: }
695 1, 0, // 189: case 0x1: {
696 OPC_CheckPredicate, 4, // 191: check predicate 4
697 OPC_Decode, 202, 16, 58, // 193: decode to LWXS16_NM using decoder 58
698 // 193: }
699 // 193: } // switch Inst[0]
700 // 193: }
701 21, 6, // 197: case 0x15: {
702 OPC_CheckPredicate, 4, // 199: check predicate 4
703 OPC_Decode, 174, 16, 59, // 201: decode to LWGP16_NM using decoder 59
704 // 201: }
705 23, 27, // 205: case 0x17: {
706 OPC_SwitchField, 2, 2, // 207: switch Inst[3:2] {
707 0, 6, // 210: case 0x0: {
708 OPC_CheckPredicate, 4, // 212: check predicate 4
709 OPC_Decode, 184, 15, 60, // 214: decode to LB16_NM using decoder 60
710 // 214: }
711 1, 6, // 218: case 0x1: {
712 OPC_CheckPredicate, 4, // 220: check predicate 4
713 OPC_Decode, 221, 20, 61, // 222: decode to SB16_NM using decoder 61
714 // 222: }
715 2, 0, // 226: case 0x2: {
716 OPC_CheckPredicate, 4, // 228: check predicate 4
717 OPC_Decode, 190, 15, 60, // 230: decode to LBU16_NM using decoder 60
718 // 230: }
719 // 230: } // switch Inst[3:2]
720 // 230: }
721 28, 10, // 234: case 0x1c: {
722 OPC_CheckPredicate, 4, // 236: check predicate 4
723 OPC_CheckField, 6, 1, 1, // 238: check Inst[6] == 0x1
724 OPC_Decode, 169, 6, 62, // 242: decode to ADDIUR1SP_NM using decoder 62
725 // 242: }
726 29, 6, // 246: case 0x1d: {
727 OPC_CheckPredicate, 4, // 248: check predicate 4
728 OPC_Decode, 162, 16, 63, // 250: decode to LW4x4_NM using decoder 63
729 // 250: }
730 31, 36, // 254: case 0x1f: {
731 OPC_SwitchField, 0, 1, // 256: switch Inst[0] {
732 0, 19, // 259: case 0x0: {
733 OPC_SwitchField, 3, 1, // 261: switch Inst[3] {
734 0, 6, // 264: case 0x0: {
735 OPC_CheckPredicate, 4, // 266: check predicate 4
736 OPC_Decode, 235, 15, 64, // 268: decode to LH16_NM using decoder 64
737 // 268: }
738 1, 0, // 272: case 0x1: {
739 OPC_CheckPredicate, 4, // 274: check predicate 4
740 OPC_Decode, 241, 15, 64, // 276: decode to LHU16_NM using decoder 64
741 // 276: }
742 // 276: } // switch Inst[3]
743 // 276: }
744 1, 0, // 280: case 0x1: {
745 OPC_CheckPredicate, 4, // 282: check predicate 4
746 OPC_CheckField, 3, 1, 0, // 284: check Inst[3] == 0x0
747 OPC_Decode, 171, 21, 65, // 288: decode to SH16_NM using decoder 65
748 // 288: }
749 // 288: } // switch Inst[0]
750 // 288: }
751 36, 35, // 292: case 0x24: {
752 OPC_SwitchField, 3, 1, // 294: switch Inst[3] {
753 0, 6, // 297: case 0x0: {
754 OPC_CheckPredicate, 4, // 299: check predicate 4
755 OPC_Decode, 171, 6, 66, // 301: decode to ADDIUR2_NM using decoder 66
756 // 301: }
757 1, 0, // 305: case 0x1: {
758 OPC_Scope, 14, // 307: try {
759 OPC_CheckField, 0, 3, 0, // 309: check Inst[2:0] == 0x0
760 OPC_CheckPredicate, 4, // 313: check predicate 4
761 OPC_CheckField, 4, 6, 0, // 315: check Inst[9:4] == 0x0
762 OPC_Decode, 175, 19, 10, // 319: decode to NOP_NM using decoder 10
763 // 319: } else try {
764 OPC_CheckPredicate, 4, // 323: check predicate 4
765 OPC_Decode, 172, 6, 67, // 325: decode to ADDIURS5_NM using decoder 67
766 // 325: }
767 // 325: }
768 // 325: } // switch Inst[3]
769 // 325: }
770 37, 6, // 329: case 0x25: {
771 OPC_CheckPredicate, 4, // 331: check predicate 4
772 OPC_Decode, 156, 23, 68, // 333: decode to SW16_NM using decoder 68
773 // 333: }
774 38, 6, // 337: case 0x26: {
775 OPC_CheckPredicate, 4, // 339: check predicate 4
776 OPC_Decode, 237, 7, 69, // 341: decode to BEQZC16_NM using decoder 69
777 // 341: }
778 44, 19, // 345: case 0x2c: {
779 OPC_SwitchField, 0, 1, // 347: switch Inst[0] {
780 0, 6, // 350: case 0x0: {
781 OPC_CheckPredicate, 4, // 352: check predicate 4
782 OPC_Decode, 243, 6, 70, // 354: decode to ADDu16_NM using decoder 70
783 // 354: }
784 1, 0, // 358: case 0x1: {
785 OPC_CheckPredicate, 4, // 360: check predicate 4
786 OPC_Decode, 147, 23, 70, // 362: decode to SUBu16_NM using decoder 70
787 // 362: }
788 // 362: } // switch Inst[0]
789 // 362: }
790 45, 6, // 366: case 0x2d: {
791 OPC_CheckPredicate, 4, // 368: check predicate 4
792 OPC_Decode, 187, 23, 54, // 370: decode to SWSP16_NM using decoder 54
793 // 370: }
794 46, 6, // 374: case 0x2e: {
795 OPC_CheckPredicate, 4, // 376: check predicate 4
796 OPC_Decode, 224, 8, 69, // 378: decode to BNEZC16_NM using decoder 69
797 // 378: }
798 47, 6, // 382: case 0x2f: {
799 OPC_CheckPredicate, 4, // 384: check predicate 4
800 OPC_Decode, 240, 17, 71, // 386: decode to MOVEP_NM using decoder 71
801 // 386: }
802 52, 6, // 390: case 0x34: {
803 OPC_CheckPredicate, 4, // 392: check predicate 4
804 OPC_Decode, 133, 16, 72, // 394: decode to LI16_NM using decoder 72
805 // 394: }
806 53, 6, // 398: case 0x35: {
807 OPC_CheckPredicate, 4, // 400: check predicate 4
808 OPC_Decode, 169, 23, 73, // 402: decode to SWGP16_NM using decoder 73
809 // 402: }
810 54, 22, // 406: case 0x36: {
811 OPC_CheckField, 0, 4, 0, // 408: check Inst[3:0] == 0x0
812 OPC_Scope, 10, // 412: try {
813 OPC_CheckField, 4, 1, 0, // 414: check Inst[4] == 0x0
814 OPC_CheckPredicate, 4, // 418: check predicate 4
815 OPC_Decode, 167, 15, 44, // 420: decode to JRC_NM using decoder 44
816 // 420: } else try {
817 OPC_CheckPredicate, 4, // 424: check predicate 4
818 OPC_Decode, 139, 15, 74, // 426: decode to JALRC16_NM using decoder 74
819 // 426: }
820 // 426: }
821 60, 6, // 430: case 0x3c: {
822 OPC_CheckPredicate, 4, // 432: check predicate 4
823 OPC_Decode, 131, 7, 75, // 434: decode to ANDI16_NM using decoder 75
824 // 434: }
825 61, 6, // 438: case 0x3d: {
826 OPC_CheckPredicate, 4, // 440: check predicate 4
827 OPC_Decode, 157, 23, 76, // 442: decode to SW4x4_NM using decoder 76
828 // 442: }
829 63, 0, // 446: case 0x3f: {
830 OPC_CheckPredicate, 4, // 448: check predicate 4
831 OPC_Decode, 237, 17, 77, // 450: decode to MOVEPREV_NM using decoder 77
832 // 450: }
833 // 450: } // switch Inst[15:10]
834};
835static const uint8_t DecoderTable32[305] = {
836 OPC_SwitchField, 11, 5, // 0: switch Inst[15:11] {
837 1, 14, // 3: case 0x1: {
838 OPC_CheckPredicate, 0, // 5: check predicate 0
839 OPC_CheckField, 27, 5, 30, // 7: check Inst[31:27] == 0x1e
840 OPC_CheckField, 5, 3, 0, // 11: check Inst[7:5] == 0x0
841 OPC_Decode, 173, 7, 78, // 15: decode to AddiuRxPcImmX16 using decoder 78
842 // 15: }
843 2, 14, // 19: case 0x2: {
844 OPC_CheckPredicate, 0, // 21: check predicate 0
845 OPC_CheckField, 27, 5, 30, // 23: check Inst[31:27] == 0x1e
846 OPC_CheckField, 5, 6, 0, // 27: check Inst[10:5] == 0x0
847 OPC_Decode, 140, 9, 79, // 31: decode to BimmX16 using decoder 79
848 // 31: }
849 4, 14, // 35: case 0x4: {
850 OPC_CheckPredicate, 0, // 37: check predicate 0
851 OPC_CheckField, 27, 5, 30, // 39: check Inst[31:27] == 0x1e
852 OPC_CheckField, 5, 3, 0, // 43: check Inst[7:5] == 0x0
853 OPC_Decode, 138, 9, 80, // 47: decode to BeqzRxImmX16 using decoder 80
854 // 47: }
855 5, 14, // 51: case 0x5: {
856 OPC_CheckPredicate, 0, // 53: check predicate 0
857 OPC_CheckField, 27, 5, 30, // 55: check Inst[31:27] == 0x1e
858 OPC_CheckField, 5, 3, 0, // 59: check Inst[7:5] == 0x0
859 OPC_Decode, 142, 9, 80, // 63: decode to BnezRxImmX16 using decoder 80
860 // 63: }
861 6, 64, // 67: case 0x6: {
862 OPC_CheckField, 27, 5, 30, // 69: check Inst[31:27] == 0x1e
863 OPC_Scope, 31, // 73: try {
864 OPC_CheckField, 16, 5, 0, // 75: check Inst[20:16] == 0x0
865 OPC_SwitchField, 0, 5, // 79: switch Inst[4:0] {
866 0, 6, // 82: case 0x0: {
867 OPC_CheckPredicate, 0, // 84: check predicate 0
868 OPC_Decode, 217, 23, 81, // 86: decode to SllX16 using decoder 81
869 // 86: }
870 2, 6, // 90: case 0x2: {
871 OPC_CheckPredicate, 0, // 92: check predicate 0
872 OPC_Decode, 227, 23, 81, // 94: decode to SrlX16 using decoder 81
873 // 94: }
874 3, 0, // 98: case 0x3: {
875 OPC_CheckPredicate, 0, // 100: check predicate 0
876 OPC_Decode, 225, 23, 81, // 102: decode to SraX16 using decoder 81
877 // 102: }
878 // 102: } // switch Inst[4:0]
879 // 102: } else try {
880 OPC_SwitchField, 5, 6, // 106: switch Inst[10:5] {
881 0, 6, // 109: case 0x0: {
882 OPC_CheckPredicate, 0, // 111: check predicate 0
883 OPC_Decode, 145, 9, 82, // 113: decode to BteqzX16 using decoder 82
884 // 113: }
885 8, 6, // 117: case 0x8: {
886 OPC_CheckPredicate, 0, // 119: check predicate 0
887 OPC_Decode, 147, 9, 82, // 121: decode to BtnezX16 using decoder 82
888 // 121: }
889 24, 0, // 125: case 0x18: {
890 OPC_CheckPredicate, 0, // 127: check predicate 0
891 OPC_Decode, 178, 7, 82, // 129: decode to AddiuSpImmX16 using decoder 82
892 // 129: }
893 // 129: } // switch Inst[10:5]
894 // 129: }
895 // 129: }
896 8, 14, // 133: case 0x8: {
897 OPC_CheckPredicate, 0, // 135: check predicate 0
898 OPC_CheckField, 27, 5, 30, // 137: check Inst[31:27] == 0x1e
899 OPC_CheckField, 4, 1, 0, // 141: check Inst[4] == 0x0
900 OPC_Decode, 176, 7, 83, // 145: decode to AddiuRxRyOffMemX16 using decoder 83
901 // 145: }
902 9, 14, // 149: case 0x9: {
903 OPC_CheckPredicate, 0, // 151: check predicate 0
904 OPC_CheckField, 27, 5, 30, // 153: check Inst[31:27] == 0x1e
905 OPC_CheckField, 5, 3, 0, // 157: check Inst[7:5] == 0x0
906 OPC_Decode, 172, 7, 78, // 161: decode to AddiuRxImmX16 using decoder 78
907 // 161: }
908 10, 14, // 165: case 0xa: {
909 OPC_CheckPredicate, 0, // 167: check predicate 0
910 OPC_CheckField, 27, 5, 30, // 169: check Inst[31:27] == 0x1e
911 OPC_CheckField, 5, 3, 0, // 173: check Inst[7:5] == 0x0
912 OPC_Decode, 221, 23, 78, // 177: decode to SltiRxImmX16 using decoder 78
913 // 177: }
914 11, 14, // 181: case 0xb: {
915 OPC_CheckPredicate, 0, // 183: check predicate 0
916 OPC_CheckField, 27, 5, 30, // 185: check Inst[31:27] == 0x1e
917 OPC_CheckField, 5, 3, 0, // 189: check Inst[7:5] == 0x0
918 OPC_Decode, 223, 23, 78, // 193: decode to SltiuRxImmX16 using decoder 78
919 // 193: }
920 13, 14, // 197: case 0xd: {
921 OPC_CheckPredicate, 0, // 199: check predicate 0
922 OPC_CheckField, 27, 5, 30, // 201: check Inst[31:27] == 0x1e
923 OPC_CheckField, 5, 3, 0, // 205: check Inst[7:5] == 0x0
924 OPC_Decode, 218, 16, 78, // 209: decode to LiRxImmX16 using decoder 78
925 // 209: }
926 14, 14, // 213: case 0xe: {
927 OPC_CheckPredicate, 0, // 215: check predicate 0
928 OPC_CheckField, 27, 5, 30, // 217: check Inst[31:27] == 0x1e
929 OPC_CheckField, 5, 3, 0, // 221: check Inst[7:5] == 0x0
930 OPC_Decode, 220, 11, 78, // 225: decode to CmpiRxImmX16 using decoder 78
931 // 225: }
932 18, 10, // 229: case 0x12: {
933 OPC_CheckPredicate, 0, // 231: check predicate 0
934 OPC_CheckField, 27, 5, 30, // 233: check Inst[31:27] == 0x1e
935 OPC_Decode, 222, 16, 83, // 237: decode to LwRxSpImmX16 using decoder 83
936 // 237: }
937 22, 14, // 241: case 0x16: {
938 OPC_CheckPredicate, 0, // 243: check predicate 0
939 OPC_CheckField, 27, 5, 30, // 245: check Inst[31:27] == 0x1e
940 OPC_CheckField, 5, 3, 0, // 249: check Inst[7:5] == 0x0
941 OPC_Decode, 220, 16, 84, // 253: decode to LwRxPcTcpX16 using decoder 84
942 // 253: }
943 24, 10, // 257: case 0x18: {
944 OPC_CheckPredicate, 0, // 259: check predicate 0
945 OPC_CheckField, 27, 5, 30, // 261: check Inst[31:27] == 0x1e
946 OPC_Decode, 213, 23, 83, // 265: decode to SbRxRyOffMemX16 using decoder 83
947 // 265: }
948 25, 10, // 269: case 0x19: {
949 OPC_CheckPredicate, 0, // 271: check predicate 0
950 OPC_CheckField, 27, 5, 30, // 273: check Inst[31:27] == 0x1e
951 OPC_Decode, 216, 23, 83, // 277: decode to ShRxRyOffMemX16 using decoder 83
952 // 277: }
953 26, 10, // 281: case 0x1a: {
954 OPC_CheckPredicate, 0, // 283: check predicate 0
955 OPC_CheckField, 27, 5, 30, // 285: check Inst[31:27] == 0x1e
956 OPC_Decode, 231, 23, 83, // 289: decode to SwRxSpImmX16 using decoder 83
957 // 289: }
958 27, 0, // 293: case 0x1b: {
959 OPC_CheckPredicate, 0, // 295: check predicate 0
960 OPC_CheckField, 27, 5, 30, // 297: check Inst[31:27] == 0x1e
961 OPC_Decode, 230, 23, 83, // 301: decode to SwRxRyOffMemX16 using decoder 83
962 // 301: }
963 // 301: } // switch Inst[15:11]
964};
965static const uint8_t DecoderTableCOP3_32[35] = {
966 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
967 51, 6, // 3: case 0x33: {
968 OPC_CheckPredicate, 5, // 5: check predicate 5
969 OPC_Decode, 169, 16, 85, // 7: decode to LWC3 using decoder 85
970 // 7: }
971 55, 6, // 11: case 0x37: {
972 OPC_CheckPredicate, 6, // 13: check predicate 6
973 OPC_Decode, 217, 15, 85, // 15: decode to LDC3 using decoder 85
974 // 15: }
975 59, 6, // 19: case 0x3b: {
976 OPC_CheckPredicate, 5, // 21: check predicate 5
977 OPC_Decode, 164, 23, 85, // 23: decode to SWC3 using decoder 85
978 // 23: }
979 63, 0, // 27: case 0x3f: {
980 OPC_CheckPredicate, 6, // 29: check predicate 6
981 OPC_Decode, 132, 21, 85, // 31: decode to SDC3 using decoder 85
982 // 31: }
983 // 31: } // switch Inst[31:26]
984};
985static const uint8_t DecoderTableCnMips32[298] = {
986 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
987 18, 19, // 3: case 0x12: {
988 OPC_SwitchField, 21, 5, // 5: switch Inst[25:21] {
989 1, 6, // 8: case 0x1: {
990 OPC_CheckPredicate, 7, // 10: check predicate 7
991 OPC_Decode, 142, 12, 86, // 12: decode to DMFC2_OCTEON using decoder 86
992 // 12: }
993 5, 0, // 16: case 0x5: {
994 OPC_CheckPredicate, 7, // 18: check predicate 7
995 OPC_Decode, 150, 12, 86, // 20: decode to DMTC2_OCTEON using decoder 86
996 // 20: }
997 // 20: } // switch Inst[25:21]
998 // 20: }
999 28, 239, 1, // 24: case 0x1c: {
1000 OPC_SwitchField, 0, 6, // 27: switch Inst[5:0] {
1001 3, 10, // 30: case 0x3: {
1002 OPC_CheckPredicate, 7, // 32: check predicate 7
1003 OPC_CheckField, 6, 5, 0, // 34: check Inst[10:6] == 0x0
1004 OPC_Decode, 154, 12, 87, // 38: decode to DMUL using decoder 87
1005 // 38: }
1006 8, 10, // 42: case 0x8: {
1007 OPC_CheckPredicate, 7, // 44: check predicate 7
1008 OPC_CheckField, 6, 15, 0, // 46: check Inst[20:6] == 0x0
1009 OPC_Decode, 216, 18, 88, // 50: decode to MTM0 using decoder 88
1010 // 50: }
1011 9, 10, // 54: case 0x9: {
1012 OPC_CheckPredicate, 7, // 56: check predicate 7
1013 OPC_CheckField, 6, 15, 0, // 58: check Inst[20:6] == 0x0
1014 OPC_Decode, 219, 18, 88, // 62: decode to MTP0 using decoder 88
1015 // 62: }
1016 10, 10, // 66: case 0xa: {
1017 OPC_CheckPredicate, 7, // 68: check predicate 7
1018 OPC_CheckField, 6, 15, 0, // 70: check Inst[20:6] == 0x0
1019 OPC_Decode, 220, 18, 88, // 74: decode to MTP1 using decoder 88
1020 // 74: }
1021 11, 10, // 78: case 0xb: {
1022 OPC_CheckPredicate, 7, // 80: check predicate 7
1023 OPC_CheckField, 6, 15, 0, // 82: check Inst[20:6] == 0x0
1024 OPC_Decode, 221, 18, 88, // 86: decode to MTP2 using decoder 88
1025 // 86: }
1026 12, 10, // 90: case 0xc: {
1027 OPC_CheckPredicate, 7, // 92: check predicate 7
1028 OPC_CheckField, 6, 15, 0, // 94: check Inst[20:6] == 0x0
1029 OPC_Decode, 217, 18, 88, // 98: decode to MTM1 using decoder 88
1030 // 98: }
1031 13, 10, // 102: case 0xd: {
1032 OPC_CheckPredicate, 7, // 104: check predicate 7
1033 OPC_CheckField, 6, 15, 0, // 106: check Inst[20:6] == 0x0
1034 OPC_Decode, 218, 18, 88, // 110: decode to MTM2 using decoder 88
1035 // 110: }
1036 15, 10, // 114: case 0xf: {
1037 OPC_CheckPredicate, 7, // 116: check predicate 7
1038 OPC_CheckField, 6, 5, 0, // 118: check Inst[10:6] == 0x0
1039 OPC_Decode, 175, 24, 87, // 122: decode to VMULU using decoder 87
1040 // 122: }
1041 16, 10, // 126: case 0x10: {
1042 OPC_CheckPredicate, 7, // 128: check predicate 7
1043 OPC_CheckField, 6, 5, 0, // 130: check Inst[10:6] == 0x0
1044 OPC_Decode, 174, 24, 87, // 134: decode to VMM0 using decoder 87
1045 // 134: }
1046 17, 10, // 138: case 0x11: {
1047 OPC_CheckPredicate, 7, // 140: check predicate 7
1048 OPC_CheckField, 6, 5, 0, // 142: check Inst[10:6] == 0x0
1049 OPC_Decode, 173, 24, 87, // 146: decode to V3MULU using decoder 87
1050 // 146: }
1051 40, 10, // 150: case 0x28: {
1052 OPC_CheckPredicate, 7, // 152: check predicate 7
1053 OPC_CheckField, 6, 5, 0, // 154: check Inst[10:6] == 0x0
1054 OPC_Decode, 182, 7, 87, // 158: decode to BADDu using decoder 87
1055 // 158: }
1056 42, 10, // 162: case 0x2a: {
1057 OPC_CheckPredicate, 7, // 164: check predicate 7
1058 OPC_CheckField, 6, 5, 0, // 166: check Inst[10:6] == 0x0
1059 OPC_Decode, 165, 21, 87, // 170: decode to SEQ using decoder 87
1060 // 170: }
1061 43, 10, // 174: case 0x2b: {
1062 OPC_CheckPredicate, 7, // 176: check predicate 7
1063 OPC_CheckField, 6, 5, 0, // 178: check Inst[10:6] == 0x0
1064 OPC_Decode, 152, 22, 87, // 182: decode to SNE using decoder 87
1065 // 182: }
1066 44, 14, // 186: case 0x2c: {
1067 OPC_CheckPredicate, 7, // 188: check predicate 7
1068 OPC_CheckField, 16, 5, 0, // 190: check Inst[20:16] == 0x0
1069 OPC_CheckField, 6, 5, 0, // 194: check Inst[10:6] == 0x0
1070 OPC_Decode, 228, 19, 89, // 198: decode to POP using decoder 89
1071 // 198: }
1072 45, 14, // 202: case 0x2d: {
1073 OPC_CheckPredicate, 7, // 204: check predicate 7
1074 OPC_CheckField, 16, 5, 0, // 206: check Inst[20:16] == 0x0
1075 OPC_CheckField, 6, 5, 0, // 210: check Inst[10:6] == 0x0
1076 OPC_Decode, 187, 12, 90, // 214: decode to DPOP using decoder 90
1077 // 214: }
1078 46, 6, // 218: case 0x2e: {
1079 OPC_CheckPredicate, 7, // 220: check predicate 7
1080 OPC_Decode, 167, 21, 91, // 222: decode to SEQi using decoder 91
1081 // 222: }
1082 47, 6, // 226: case 0x2f: {
1083 OPC_CheckPredicate, 7, // 228: check predicate 7
1084 OPC_Decode, 153, 22, 91, // 230: decode to SNEi using decoder 91
1085 // 230: }
1086 50, 6, // 234: case 0x32: {
1087 OPC_CheckPredicate, 8, // 236: check predicate 8
1088 OPC_Decode, 178, 9, 92, // 238: decode to CINS using decoder 92
1089 // 238: }
1090 51, 6, // 242: case 0x33: {
1091 OPC_CheckPredicate, 8, // 244: check predicate 8
1092 OPC_Decode, 179, 9, 92, // 246: decode to CINS32 using decoder 92
1093 // 246: }
1094 58, 6, // 250: case 0x3a: {
1095 OPC_CheckPredicate, 8, // 252: check predicate 8
1096 OPC_Decode, 152, 13, 92, // 254: decode to EXTS using decoder 92
1097 // 254: }
1098 59, 0, // 258: case 0x3b: {
1099 OPC_CheckPredicate, 8, // 260: check predicate 8
1100 OPC_Decode, 153, 13, 92, // 262: decode to EXTS32 using decoder 92
1101 // 262: }
1102 // 262: } // switch Inst[5:0]
1103 // 262: }
1104 50, 6, // 266: case 0x32: {
1105 OPC_CheckPredicate, 7, // 268: check predicate 7
1106 OPC_Decode, 192, 7, 93, // 270: decode to BBIT0 using decoder 93
1107 // 270: }
1108 54, 6, // 274: case 0x36: {
1109 OPC_CheckPredicate, 7, // 276: check predicate 7
1110 OPC_Decode, 193, 7, 93, // 278: decode to BBIT032 using decoder 93
1111 // 278: }
1112 58, 6, // 282: case 0x3a: {
1113 OPC_CheckPredicate, 7, // 284: check predicate 7
1114 OPC_Decode, 194, 7, 93, // 286: decode to BBIT1 using decoder 93
1115 // 286: }
1116 62, 0, // 290: case 0x3e: {
1117 OPC_CheckPredicate, 7, // 292: check predicate 7
1118 OPC_Decode, 195, 7, 93, // 294: decode to BBIT132 using decoder 93
1119 // 294: }
1120 // 294: } // switch Inst[31:26]
1121};
1122static const uint8_t DecoderTableCnMipsP32[27] = {
1123 OPC_SwitchField, 0, 16, // 0: switch Inst[15:0] {
1124 24, 10, // 3: case 0x18: {
1125 OPC_CheckPredicate, 9, // 5: check predicate 9
1126 OPC_CheckField, 26, 6, 28, // 7: check Inst[31:26] == 0x1c
1127 OPC_Decode, 206, 20, 94, // 11: decode to SAA using decoder 94
1128 // 11: }
1129 25, 0, // 15: case 0x19: {
1130 OPC_CheckPredicate, 9, // 17: check predicate 9
1131 OPC_CheckField, 26, 6, 28, // 19: check Inst[31:26] == 0x1c
1132 OPC_Decode, 207, 20, 94, // 23: decode to SAAD using decoder 94
1133 // 23: }
1134 // 23: } // switch Inst[15:0]
1135};
1136static const uint8_t DecoderTableMicroMips32[4014] = {
1137 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
1138 0, 244, 17, // 3: case 0x0: {
1139 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
1140 0, 64, // 9: case 0x0: {
1141 OPC_SwitchField, 6, 5, // 11: switch Inst[10:6] {
1142 0, 35, // 14: case 0x0: {
1143 OPC_Scope, 27, // 16: try {
1144 OPC_SwitchField, 11, 15, // 18: switch Inst[25:11] {
1145 1, 6, // 21: case 0x1: {
1146 OPC_CheckPredicate, 2, // 23: check predicate 2
1147 OPC_Decode, 211, 22, 10, // 25: decode to SSNOP_MM using decoder 10
1148 // 25: }
1149 3, 6, // 29: case 0x3: {
1150 OPC_CheckPredicate, 2, // 31: check predicate 2
1151 OPC_Decode, 236, 12, 10, // 33: decode to EHB_MM using decoder 10
1152 // 33: }
1153 5, 0, // 37: case 0x5: {
1154 OPC_CheckPredicate, 2, // 39: check predicate 2
1155 OPC_Decode, 207, 19, 10, // 41: decode to PAUSE_MM using decoder 10
1156 // 41: }
1157 // 41: } // switch Inst[25:11]
1158 // 41: } else try {
1159 OPC_CheckPredicate, 2, // 45: check predicate 2
1160 OPC_Decode, 132, 22, 95, // 47: decode to SLL_MM using decoder 95
1161 // 47: }
1162 // 47: }
1163 1, 6, // 51: case 0x1: {
1164 OPC_CheckPredicate, 2, // 53: check predicate 2
1165 OPC_Decode, 207, 22, 95, // 55: decode to SRL_MM using decoder 95
1166 // 55: }
1167 2, 6, // 59: case 0x2: {
1168 OPC_CheckPredicate, 2, // 61: check predicate 2
1169 OPC_Decode, 182, 22, 95, // 63: decode to SRA_MM using decoder 95
1170 // 63: }
1171 3, 0, // 67: case 0x3: {
1172 OPC_CheckPredicate, 2, // 69: check predicate 2
1173 OPC_Decode, 184, 20, 95, // 71: decode to ROTR_MM using decoder 95
1174 // 71: }
1175 // 71: } // switch Inst[10:6]
1176 // 71: }
1177 5, 131, 1, // 75: case 0x5: {
1178 OPC_SwitchField, 6, 5, // 78: switch Inst[10:6] {
1179 0, 10, // 81: case 0x0: {
1180 OPC_CheckPredicate, 10, // 83: check predicate 10
1181 OPC_CheckField, 11, 5, 0, // 85: check Inst[15:11] == 0x0
1182 OPC_Decode, 251, 9, 96, // 89: decode to CMP_EQ_PH_MM using decoder 96
1183 // 89: }
1184 1, 10, // 93: case 0x1: {
1185 OPC_CheckPredicate, 10, // 95: check predicate 10
1186 OPC_CheckField, 11, 5, 0, // 97: check Inst[15:11] == 0x0
1187 OPC_Decode, 137, 10, 96, // 101: decode to CMP_LT_PH_MM using decoder 96
1188 // 101: }
1189 2, 10, // 105: case 0x2: {
1190 OPC_CheckPredicate, 10, // 107: check predicate 10
1191 OPC_CheckField, 11, 5, 0, // 109: check Inst[15:11] == 0x0
1192 OPC_Decode, 131, 10, 96, // 113: decode to CMP_LE_PH_MM using decoder 96
1193 // 113: }
1194 6, 6, // 117: case 0x6: {
1195 OPC_CheckPredicate, 11, // 119: check predicate 11
1196 OPC_Decode, 229, 9, 97, // 121: decode to CMPGDU_EQ_QB_MMR2 using decoder 97
1197 // 121: }
1198 7, 6, // 125: case 0x7: {
1199 OPC_CheckPredicate, 11, // 127: check predicate 11
1200 OPC_Decode, 233, 9, 97, // 129: decode to CMPGDU_LT_QB_MMR2 using decoder 97
1201 // 129: }
1202 8, 6, // 133: case 0x8: {
1203 OPC_CheckPredicate, 11, // 135: check predicate 11
1204 OPC_Decode, 231, 9, 97, // 137: decode to CMPGDU_LE_QB_MMR2 using decoder 97
1205 // 137: }
1206 9, 10, // 141: case 0x9: {
1207 OPC_CheckPredicate, 10, // 143: check predicate 10
1208 OPC_CheckField, 11, 5, 0, // 145: check Inst[15:11] == 0x0
1209 OPC_Decode, 241, 9, 96, // 149: decode to CMPU_EQ_QB_MM using decoder 96
1210 // 149: }
1211 10, 10, // 153: case 0xa: {
1212 OPC_CheckPredicate, 10, // 155: check predicate 10
1213 OPC_CheckField, 11, 5, 0, // 157: check Inst[15:11] == 0x0
1214 OPC_Decode, 245, 9, 96, // 161: decode to CMPU_LT_QB_MM using decoder 96
1215 // 161: }
1216 11, 10, // 165: case 0xb: {
1217 OPC_CheckPredicate, 10, // 167: check predicate 10
1218 OPC_CheckField, 11, 5, 0, // 169: check Inst[15:11] == 0x0
1219 OPC_Decode, 243, 9, 96, // 173: decode to CMPU_LE_QB_MM using decoder 96
1220 // 173: }
1221 12, 6, // 177: case 0xc: {
1222 OPC_CheckPredicate, 10, // 179: check predicate 10
1223 OPC_Decode, 190, 6, 98, // 181: decode to ADDQ_S_W_MM using decoder 98
1224 // 181: }
1225 13, 6, // 185: case 0xd: {
1226 OPC_CheckPredicate, 10, // 187: check predicate 10
1227 OPC_Decode, 231, 22, 98, // 189: decode to SUBQ_S_W_MM using decoder 98
1228 // 189: }
1229 14, 6, // 193: case 0xe: {
1230 OPC_CheckPredicate, 10, // 195: check predicate 10
1231 OPC_Decode, 193, 6, 98, // 197: decode to ADDSC_MM using decoder 98
1232 // 197: }
1233 15, 0, // 201: case 0xf: {
1234 OPC_CheckPredicate, 10, // 203: check predicate 10
1235 OPC_Decode, 230, 6, 98, // 205: decode to ADDWC_MM using decoder 98
1236 // 205: }
1237 // 205: } // switch Inst[10:6]
1238 // 205: }
1239 7, 6, // 209: case 0x7: {
1240 OPC_CheckPredicate, 2, // 211: check predicate 2
1241 OPC_Decode, 245, 8, 99, // 213: decode to BREAK_MM using decoder 99
1242 // 213: }
1243 12, 6, // 217: case 0xc: {
1244 OPC_CheckPredicate, 1, // 219: check predicate 1
1245 OPC_Decode, 130, 15, 100, // 221: decode to INS_MM using decoder 100
1246 // 221: }
1247 13, 243, 1, // 225: case 0xd: {
1248 OPC_SwitchField, 6, 5, // 228: switch Inst[10:6] {
1249 0, 6, // 231: case 0x0: {
1250 OPC_CheckPredicate, 10, // 233: check predicate 10
1251 OPC_Decode, 186, 6, 101, // 235: decode to ADDQ_PH_MM using decoder 101
1252 // 235: }
1253 1, 6, // 239: case 0x1: {
1254 OPC_CheckPredicate, 11, // 241: check predicate 11
1255 OPC_Decode, 178, 6, 101, // 243: decode to ADDQH_PH_MMR2 using decoder 101
1256 // 243: }
1257 2, 6, // 247: case 0x2: {
1258 OPC_CheckPredicate, 11, // 249: check predicate 11
1259 OPC_Decode, 184, 6, 98, // 251: decode to ADDQH_W_MMR2 using decoder 98
1260 // 251: }
1261 3, 6, // 255: case 0x3: {
1262 OPC_CheckPredicate, 10, // 257: check predicate 10
1263 OPC_Decode, 216, 6, 101, // 259: decode to ADDU_QB_MM using decoder 101
1264 // 259: }
1265 4, 6, // 263: case 0x4: {
1266 OPC_CheckPredicate, 11, // 265: check predicate 11
1267 OPC_Decode, 214, 6, 101, // 267: decode to ADDU_PH_MMR2 using decoder 101
1268 // 267: }
1269 5, 6, // 271: case 0x5: {
1270 OPC_CheckPredicate, 11, // 273: check predicate 11
1271 OPC_Decode, 209, 6, 101, // 275: decode to ADDUH_QB_MMR2 using decoder 101
1272 // 275: }
1273 6, 6, // 279: case 0x6: {
1274 OPC_CheckPredicate, 10, // 281: check predicate 10
1275 OPC_Decode, 200, 21, 102, // 283: decode to SHRAV_PH_MM using decoder 102
1276 // 283: }
1277 7, 6, // 287: case 0x7: {
1278 OPC_CheckPredicate, 11, // 289: check predicate 11
1279 OPC_Decode, 202, 21, 102, // 291: decode to SHRAV_QB_MMR2 using decoder 102
1280 // 291: }
1281 8, 6, // 295: case 0x8: {
1282 OPC_CheckPredicate, 10, // 297: check predicate 10
1283 OPC_Decode, 227, 22, 101, // 299: decode to SUBQ_PH_MM using decoder 101
1284 // 299: }
1285 9, 6, // 303: case 0x9: {
1286 OPC_CheckPredicate, 11, // 305: check predicate 11
1287 OPC_Decode, 219, 22, 101, // 307: decode to SUBQH_PH_MMR2 using decoder 101
1288 // 307: }
1289 10, 6, // 311: case 0xa: {
1290 OPC_CheckPredicate, 11, // 313: check predicate 11
1291 OPC_Decode, 225, 22, 98, // 315: decode to SUBQH_W_MMR2 using decoder 98
1292 // 315: }
1293 11, 6, // 319: case 0xb: {
1294 OPC_CheckPredicate, 10, // 321: check predicate 10
1295 OPC_Decode, 130, 23, 101, // 323: decode to SUBU_QB_MM using decoder 101
1296 // 323: }
1297 12, 6, // 327: case 0xc: {
1298 OPC_CheckPredicate, 11, // 329: check predicate 11
1299 OPC_Decode, 128, 23, 101, // 331: decode to SUBU_PH_MMR2 using decoder 101
1300 // 331: }
1301 13, 6, // 335: case 0xd: {
1302 OPC_CheckPredicate, 11, // 337: check predicate 11
1303 OPC_Decode, 251, 22, 101, // 339: decode to SUBUH_QB_MMR2 using decoder 101
1304 // 339: }
1305 15, 6, // 343: case 0xf: {
1306 OPC_CheckPredicate, 11, // 345: check predicate 11
1307 OPC_Decode, 132, 20, 103, // 347: decode to PRECR_SRA_PH_W_MMR2 using decoder 103
1308 // 347: }
1309 16, 6, // 351: case 0x10: {
1310 OPC_CheckPredicate, 10, // 353: check predicate 10
1311 OPC_Decode, 188, 6, 101, // 355: decode to ADDQ_S_PH_MM using decoder 101
1312 // 355: }
1313 17, 6, // 359: case 0x11: {
1314 OPC_CheckPredicate, 11, // 361: check predicate 11
1315 OPC_Decode, 180, 6, 101, // 363: decode to ADDQH_R_PH_MMR2 using decoder 101
1316 // 363: }
1317 18, 6, // 367: case 0x12: {
1318 OPC_CheckPredicate, 11, // 369: check predicate 11
1319 OPC_Decode, 182, 6, 98, // 371: decode to ADDQH_R_W_MMR2 using decoder 98
1320 // 371: }
1321 19, 6, // 375: case 0x13: {
1322 OPC_CheckPredicate, 10, // 377: check predicate 10
1323 OPC_Decode, 220, 6, 101, // 379: decode to ADDU_S_QB_MM using decoder 101
1324 // 379: }
1325 20, 6, // 383: case 0x14: {
1326 OPC_CheckPredicate, 11, // 385: check predicate 11
1327 OPC_Decode, 218, 6, 101, // 387: decode to ADDU_S_PH_MMR2 using decoder 101
1328 // 387: }
1329 21, 6, // 391: case 0x15: {
1330 OPC_CheckPredicate, 11, // 393: check predicate 11
1331 OPC_Decode, 211, 6, 101, // 395: decode to ADDUH_R_QB_MMR2 using decoder 101
1332 // 395: }
1333 22, 6, // 399: case 0x16: {
1334 OPC_CheckPredicate, 10, // 401: check predicate 10
1335 OPC_Decode, 204, 21, 102, // 403: decode to SHRAV_R_PH_MM using decoder 102
1336 // 403: }
1337 23, 6, // 407: case 0x17: {
1338 OPC_CheckPredicate, 11, // 409: check predicate 11
1339 OPC_Decode, 206, 21, 102, // 411: decode to SHRAV_R_QB_MMR2 using decoder 102
1340 // 411: }
1341 24, 6, // 415: case 0x18: {
1342 OPC_CheckPredicate, 10, // 417: check predicate 10
1343 OPC_Decode, 229, 22, 101, // 419: decode to SUBQ_S_PH_MM using decoder 101
1344 // 419: }
1345 25, 6, // 423: case 0x19: {
1346 OPC_CheckPredicate, 11, // 425: check predicate 11
1347 OPC_Decode, 221, 22, 101, // 427: decode to SUBQH_R_PH_MMR2 using decoder 101
1348 // 427: }
1349 26, 6, // 431: case 0x1a: {
1350 OPC_CheckPredicate, 11, // 433: check predicate 11
1351 OPC_Decode, 223, 22, 98, // 435: decode to SUBQH_R_W_MMR2 using decoder 98
1352 // 435: }
1353 27, 6, // 439: case 0x1b: {
1354 OPC_CheckPredicate, 10, // 441: check predicate 10
1355 OPC_Decode, 134, 23, 101, // 443: decode to SUBU_S_QB_MM using decoder 101
1356 // 443: }
1357 28, 6, // 447: case 0x1c: {
1358 OPC_CheckPredicate, 11, // 449: check predicate 11
1359 OPC_Decode, 132, 23, 101, // 451: decode to SUBU_S_PH_MMR2 using decoder 101
1360 // 451: }
1361 29, 6, // 455: case 0x1d: {
1362 OPC_CheckPredicate, 11, // 457: check predicate 11
1363 OPC_Decode, 253, 22, 101, // 459: decode to SUBUH_R_QB_MMR2 using decoder 101
1364 // 459: }
1365 31, 0, // 463: case 0x1f: {
1366 OPC_CheckPredicate, 11, // 465: check predicate 11
1367 OPC_Decode, 134, 20, 103, // 467: decode to PRECR_SRA_R_PH_W_MMR2 using decoder 103
1368 // 467: }
1369 // 467: } // switch Inst[10:6]
1370 // 467: }
1371 14, 19, // 471: case 0xe: {
1372 OPC_SwitchField, 6, 5, // 473: switch Inst[10:6] {
1373 0, 6, // 476: case 0x0: {
1374 OPC_CheckPredicate, 10, // 478: check predicate 10
1375 OPC_Decode, 184, 21, 102, // 480: decode to SHLLV_PH_MM using decoder 102
1376 // 480: }
1377 16, 0, // 484: case 0x10: {
1378 OPC_CheckPredicate, 10, // 486: check predicate 10
1379 OPC_Decode, 188, 21, 102, // 488: decode to SHLLV_S_PH_MM using decoder 102
1380 // 488: }
1381 // 488: } // switch Inst[10:6]
1382 // 488: }
1383 16, 123, // 492: case 0x10: {
1384 OPC_SwitchField, 6, 5, // 494: switch Inst[10:6] {
1385 0, 6, // 497: case 0x0: {
1386 OPC_CheckPredicate, 2, // 499: check predicate 2
1387 OPC_Decode, 255, 21, 104, // 501: decode to SLLV_MM using decoder 104
1388 // 501: }
1389 1, 6, // 505: case 0x1: {
1390 OPC_CheckPredicate, 2, // 507: check predicate 2
1391 OPC_Decode, 202, 22, 104, // 509: decode to SRLV_MM using decoder 104
1392 // 509: }
1393 2, 6, // 513: case 0x2: {
1394 OPC_CheckPredicate, 2, // 515: check predicate 2
1395 OPC_Decode, 177, 22, 104, // 517: decode to SRAV_MM using decoder 104
1396 // 517: }
1397 3, 6, // 521: case 0x3: {
1398 OPC_CheckPredicate, 2, // 523: check predicate 2
1399 OPC_Decode, 182, 20, 104, // 525: decode to ROTRV_MM using decoder 104
1400 // 525: }
1401 4, 6, // 529: case 0x4: {
1402 OPC_CheckPredicate, 1, // 531: check predicate 1
1403 OPC_Decode, 235, 6, 98, // 533: decode to ADD_MM using decoder 98
1404 // 533: }
1405 5, 6, // 537: case 0x5: {
1406 OPC_CheckPredicate, 1, // 539: check predicate 1
1407 OPC_Decode, 245, 6, 98, // 541: decode to ADDu_MM using decoder 98
1408 // 541: }
1409 6, 6, // 545: case 0x6: {
1410 OPC_CheckPredicate, 1, // 547: check predicate 1
1411 OPC_Decode, 143, 23, 98, // 549: decode to SUB_MM using decoder 98
1412 // 549: }
1413 7, 6, // 553: case 0x7: {
1414 OPC_CheckPredicate, 1, // 555: check predicate 1
1415 OPC_Decode, 148, 23, 98, // 557: decode to SUBu_MM using decoder 98
1416 // 557: }
1417 8, 6, // 561: case 0x8: {
1418 OPC_CheckPredicate, 1, // 563: check predicate 1
1419 OPC_Decode, 141, 19, 98, // 565: decode to MUL_MM using decoder 98
1420 // 565: }
1421 9, 6, // 569: case 0x9: {
1422 OPC_CheckPredicate, 1, // 571: check predicate 1
1423 OPC_Decode, 135, 7, 98, // 573: decode to AND_MM using decoder 98
1424 // 573: }
1425 10, 6, // 577: case 0xa: {
1426 OPC_CheckPredicate, 1, // 579: check predicate 1
1427 OPC_Decode, 196, 19, 98, // 581: decode to OR_MM using decoder 98
1428 // 581: }
1429 11, 6, // 585: case 0xb: {
1430 OPC_CheckPredicate, 1, // 587: check predicate 1
1431 OPC_Decode, 179, 19, 98, // 589: decode to NOR_MM using decoder 98
1432 // 589: }
1433 12, 6, // 593: case 0xc: {
1434 OPC_CheckPredicate, 1, // 595: check predicate 1
1435 OPC_Decode, 199, 24, 98, // 597: decode to XOR_MM using decoder 98
1436 // 597: }
1437 13, 6, // 601: case 0xd: {
1438 OPC_CheckPredicate, 2, // 603: check predicate 2
1439 OPC_Decode, 141, 22, 98, // 605: decode to SLT_MM using decoder 98
1440 // 605: }
1441 14, 0, // 609: case 0xe: {
1442 OPC_CheckPredicate, 2, // 611: check predicate 2
1443 OPC_Decode, 151, 22, 98, // 613: decode to SLTu_MM using decoder 98
1444 // 613: }
1445 // 613: } // switch Inst[10:6]
1446 // 613: }
1447 21, 115, // 617: case 0x15: {
1448 OPC_SwitchField, 6, 5, // 619: switch Inst[10:6] {
1449 2, 6, // 622: case 0x2: {
1450 OPC_CheckPredicate, 10, // 624: check predicate 10
1451 OPC_Decode, 236, 18, 101, // 626: decode to MULEU_S_PH_QBL_MM using decoder 101
1452 // 626: }
1453 3, 6, // 630: case 0x3: {
1454 OPC_CheckPredicate, 10, // 632: check predicate 10
1455 OPC_Decode, 238, 18, 101, // 634: decode to MULEU_S_PH_QBR_MM using decoder 101
1456 // 634: }
1457 4, 6, // 638: case 0x4: {
1458 OPC_CheckPredicate, 10, // 640: check predicate 10
1459 OPC_Decode, 240, 18, 101, // 642: decode to MULQ_RS_PH_MM using decoder 101
1460 // 642: }
1461 5, 6, // 646: case 0x5: {
1462 OPC_CheckPredicate, 11, // 648: check predicate 11
1463 OPC_Decode, 244, 18, 101, // 650: decode to MULQ_S_PH_MMR2 using decoder 101
1464 // 650: }
1465 6, 6, // 654: case 0x6: {
1466 OPC_CheckPredicate, 11, // 656: check predicate 11
1467 OPC_Decode, 242, 18, 98, // 658: decode to MULQ_RS_W_MMR2 using decoder 98
1468 // 658: }
1469 7, 6, // 662: case 0x7: {
1470 OPC_CheckPredicate, 11, // 664: check predicate 11
1471 OPC_Decode, 246, 18, 98, // 666: decode to MULQ_S_W_MMR2 using decoder 98
1472 // 666: }
1473 8, 6, // 670: case 0x8: {
1474 OPC_CheckPredicate, 11, // 672: check predicate 11
1475 OPC_Decode, 143, 7, 105, // 674: decode to APPEND_MMR2 using decoder 105
1476 // 674: }
1477 9, 6, // 678: case 0x9: {
1478 OPC_CheckPredicate, 11, // 680: check predicate 11
1479 OPC_Decode, 145, 20, 105, // 682: decode to PREPEND_MMR2 using decoder 105
1480 // 682: }
1481 10, 6, // 686: case 0xa: {
1482 OPC_CheckPredicate, 10, // 688: check predicate 10
1483 OPC_Decode, 220, 17, 98, // 690: decode to MODSUB_MM using decoder 98
1484 // 690: }
1485 11, 6, // 694: case 0xb: {
1486 OPC_CheckPredicate, 10, // 696: check predicate 10
1487 OPC_Decode, 208, 21, 104, // 698: decode to SHRAV_R_W_MM using decoder 104
1488 // 698: }
1489 12, 6, // 702: case 0xc: {
1490 OPC_CheckPredicate, 11, // 704: check predicate 11
1491 OPC_Decode, 220, 21, 102, // 706: decode to SHRLV_PH_MMR2 using decoder 102
1492 // 706: }
1493 13, 6, // 710: case 0xd: {
1494 OPC_CheckPredicate, 10, // 712: check predicate 10
1495 OPC_Decode, 222, 21, 102, // 714: decode to SHRLV_QB_MM using decoder 102
1496 // 714: }
1497 14, 6, // 718: case 0xe: {
1498 OPC_CheckPredicate, 10, // 720: check predicate 10
1499 OPC_Decode, 186, 21, 102, // 722: decode to SHLLV_QB_MM using decoder 102
1500 // 722: }
1501 15, 0, // 726: case 0xf: {
1502 OPC_CheckPredicate, 10, // 728: check predicate 10
1503 OPC_Decode, 190, 21, 104, // 730: decode to SHLLV_S_W_MM using decoder 104
1504 // 730: }
1505 // 730: } // switch Inst[10:6]
1506 // 730: }
1507 24, 27, // 734: case 0x18: {
1508 OPC_SwitchField, 6, 5, // 736: switch Inst[10:6] {
1509 0, 6, // 739: case 0x0: {
1510 OPC_CheckPredicate, 1, // 741: check predicate 1
1511 OPC_Decode, 132, 18, 106, // 743: decode to MOVN_I_MM using decoder 106
1512 // 743: }
1513 1, 6, // 747: case 0x1: {
1514 OPC_CheckPredicate, 1, // 749: check predicate 1
1515 OPC_Decode, 153, 18, 106, // 751: decode to MOVZ_I_MM using decoder 106
1516 // 751: }
1517 4, 0, // 755: case 0x4: {
1518 OPC_CheckPredicate, 2, // 757: check predicate 2
1519 OPC_Decode, 203, 16, 107, // 759: decode to LWXS_MM using decoder 107
1520 // 759: }
1521 // 759: } // switch Inst[10:6]
1522 // 759: }
1523 29, 14, // 763: case 0x1d: {
1524 OPC_CheckPredicate, 10, // 765: check predicate 10
1525 OPC_CheckField, 22, 4, 0, // 767: check Inst[25:22] == 0x0
1526 OPC_CheckField, 6, 8, 0, // 771: check Inst[13:6] == 0x0
1527 OPC_Decode, 182, 21, 108, // 775: decode to SHILO_MM using decoder 108
1528 // 775: }
1529 37, 43, // 779: case 0x25: {
1530 OPC_SwitchField, 6, 5, // 781: switch Inst[10:6] {
1531 0, 6, // 784: case 0x0: {
1532 OPC_CheckPredicate, 10, // 786: check predicate 10
1533 OPC_Decode, 232, 18, 97, // 788: decode to MULEQ_S_W_PHL_MM using decoder 97
1534 // 788: }
1535 1, 6, // 792: case 0x1: {
1536 OPC_CheckPredicate, 10, // 794: check predicate 10
1537 OPC_Decode, 234, 18, 97, // 796: decode to MULEQ_S_W_PHR_MM using decoder 97
1538 // 796: }
1539 5, 6, // 800: case 0x5: {
1540 OPC_CheckPredicate, 10, // 802: check predicate 10
1541 OPC_Decode, 249, 15, 107, // 804: decode to LHX_MM using decoder 107
1542 // 804: }
1543 6, 6, // 808: case 0x6: {
1544 OPC_CheckPredicate, 10, // 810: check predicate 10
1545 OPC_Decode, 205, 16, 107, // 812: decode to LWX_MM using decoder 107
1546 // 812: }
1547 8, 0, // 816: case 0x8: {
1548 OPC_CheckPredicate, 10, // 818: check predicate 10
1549 OPC_Decode, 193, 15, 107, // 820: decode to LBUX_MM using decoder 107
1550 // 820: }
1551 // 820: } // switch Inst[10:6]
1552 // 820: }
1553 44, 6, // 824: case 0x2c: {
1554 OPC_CheckPredicate, 1, // 826: check predicate 1
1555 OPC_Decode, 155, 13, 109, // 828: decode to EXT_MM using decoder 109
1556 // 828: }
1557 45, 83, // 832: case 0x2d: {
1558 OPC_SwitchField, 6, 5, // 834: switch Inst[10:6] {
1559 0, 6, // 837: case 0x0: {
1560 OPC_CheckPredicate, 11, // 839: check predicate 11
1561 OPC_Decode, 145, 19, 101, // 841: decode to MUL_PH_MMR2 using decoder 101
1562 // 841: }
1563 1, 6, // 845: case 0x1: {
1564 OPC_CheckPredicate, 11, // 847: check predicate 11
1565 OPC_Decode, 130, 20, 101, // 849: decode to PRECR_QB_PH_MMR2 using decoder 101
1566 // 849: }
1567 2, 6, // 853: case 0x2: {
1568 OPC_CheckPredicate, 10, // 855: check predicate 10
1569 OPC_Decode, 254, 19, 101, // 857: decode to PRECRQ_QB_PH_MM using decoder 101
1570 // 857: }
1571 3, 6, // 861: case 0x3: {
1572 OPC_CheckPredicate, 10, // 863: check predicate 10
1573 OPC_Decode, 252, 19, 110, // 865: decode to PRECRQ_PH_W_MM using decoder 110
1574 // 865: }
1575 4, 6, // 869: case 0x4: {
1576 OPC_CheckPredicate, 10, // 871: check predicate 10
1577 OPC_Decode, 128, 20, 110, // 873: decode to PRECRQ_RS_PH_W_MM using decoder 110
1578 // 873: }
1579 5, 6, // 877: case 0x5: {
1580 OPC_CheckPredicate, 10, // 879: check predicate 10
1581 OPC_Decode, 250, 19, 101, // 881: decode to PRECRQU_S_QB_PH_MM using decoder 101
1582 // 881: }
1583 6, 6, // 885: case 0x6: {
1584 OPC_CheckPredicate, 10, // 887: check predicate 10
1585 OPC_Decode, 205, 19, 101, // 889: decode to PACKRL_PH_MM using decoder 101
1586 // 889: }
1587 7, 6, // 893: case 0x7: {
1588 OPC_CheckPredicate, 10, // 895: check predicate 10
1589 OPC_Decode, 225, 19, 101, // 897: decode to PICK_QB_MM using decoder 101
1590 // 897: }
1591 8, 6, // 901: case 0x8: {
1592 OPC_CheckPredicate, 10, // 903: check predicate 10
1593 OPC_Decode, 223, 19, 101, // 905: decode to PICK_PH_MM using decoder 101
1594 // 905: }
1595 16, 0, // 909: case 0x10: {
1596 OPC_CheckPredicate, 11, // 911: check predicate 11
1597 OPC_Decode, 150, 19, 101, // 913: decode to MUL_S_PH_MMR2 using decoder 101
1598 // 913: }
1599 // 913: } // switch Inst[10:6]
1600 // 913: }
1601 52, 27, // 917: case 0x34: {
1602 OPC_SwitchField, 6, 5, // 919: switch Inst[10:6] {
1603 19, 10, // 922: case 0x13: {
1604 OPC_CheckPredicate, 12, // 924: check predicate 12
1605 OPC_CheckField, 14, 2, 0, // 926: check Inst[15:14] == 0x0
1606 OPC_Decode, 176, 17, 111, // 930: decode to MFHGC0_MM using decoder 111
1607 // 930: }
1608 27, 0, // 934: case 0x1b: {
1609 OPC_CheckPredicate, 12, // 936: check predicate 12
1610 OPC_CheckField, 14, 2, 0, // 938: check Inst[15:14] == 0x0
1611 OPC_Decode, 203, 18, 112, // 942: decode to MTHGC0_MM using decoder 112
1612 // 942: }
1613 // 942: } // switch Inst[10:6]
1614 // 942: }
1615 53, 64, // 946: case 0x35: {
1616 OPC_SwitchField, 6, 5, // 948: switch Inst[10:6] {
1617 11, 6, // 951: case 0xb: {
1618 OPC_CheckPredicate, 10, // 953: check predicate 10
1619 OPC_Decode, 218, 21, 95, // 955: decode to SHRA_R_W_MM using decoder 95
1620 // 955: }
1621 12, 10, // 959: case 0xc: {
1622 OPC_CheckPredicate, 10, // 961: check predicate 10
1623 OPC_CheckField, 11, 1, 0, // 963: check Inst[11] == 0x0
1624 OPC_Decode, 210, 21, 113, // 967: decode to SHRA_PH_MM using decoder 113
1625 // 967: }
1626 14, 19, // 971: case 0xe: {
1627 OPC_SwitchField, 11, 1, // 973: switch Inst[11] {
1628 0, 6, // 976: case 0x0: {
1629 OPC_CheckPredicate, 10, // 978: check predicate 10
1630 OPC_Decode, 192, 21, 113, // 980: decode to SHLL_PH_MM using decoder 113
1631 // 980: }
1632 1, 0, // 984: case 0x1: {
1633 OPC_CheckPredicate, 10, // 986: check predicate 10
1634 OPC_Decode, 196, 21, 113, // 988: decode to SHLL_S_PH_MM using decoder 113
1635 // 988: }
1636 // 988: } // switch Inst[11]
1637 // 988: }
1638 15, 6, // 992: case 0xf: {
1639 OPC_CheckPredicate, 10, // 994: check predicate 10
1640 OPC_Decode, 198, 21, 95, // 996: decode to SHLL_S_W_MM using decoder 95
1641 // 996: }
1642 28, 0, // 1000: case 0x1c: {
1643 OPC_CheckPredicate, 10, // 1002: check predicate 10
1644 OPC_CheckField, 11, 1, 0, // 1004: check Inst[11] == 0x0
1645 OPC_Decode, 214, 21, 113, // 1008: decode to SHRA_R_PH_MM using decoder 113
1646 // 1008: }
1647 // 1008: } // switch Inst[10:6]
1648 // 1008: }
1649 60, 246, 9, // 1012: case 0x3c: {
1650 OPC_SwitchField, 6, 5, // 1015: switch Inst[10:6] {
1651 0, 19, // 1018: case 0x0: {
1652 OPC_SwitchField, 11, 1, // 1020: switch Inst[11] {
1653 0, 6, // 1023: case 0x0: {
1654 OPC_CheckPredicate, 2, // 1025: check predicate 2
1655 OPC_Decode, 235, 23, 114, // 1027: decode to TEQ_MM using decoder 114
1656 // 1027: }
1657 1, 0, // 1031: case 0x1: {
1658 OPC_CheckPredicate, 2, // 1033: check predicate 2
1659 OPC_Decode, 147, 24, 114, // 1035: decode to TLT_MM using decoder 114
1660 // 1035: }
1661 // 1035: } // switch Inst[11]
1662 // 1035: }
1663 1, 77, // 1039: case 0x1: {
1664 OPC_SwitchField, 11, 2, // 1041: switch Inst[12:11] {
1665 0, 27, // 1044: case 0x0: {
1666 OPC_SwitchField, 13, 1, // 1046: switch Inst[13] {
1667 0, 10, // 1049: case 0x0: {
1668 OPC_CheckPredicate, 10, // 1051: check predicate 10
1669 OPC_CheckField, 21, 5, 0, // 1053: check Inst[25:21] == 0x0
1670 OPC_Decode, 181, 17, 115, // 1057: decode to MFHI_DSP_MM using decoder 115
1671 // 1057: }
1672 1, 0, // 1061: case 0x1: {
1673 OPC_CheckPredicate, 10, // 1063: check predicate 10
1674 OPC_CheckField, 21, 5, 0, // 1065: check Inst[25:21] == 0x0
1675 OPC_Decode, 207, 18, 116, // 1069: decode to MTHI_DSP_MM using decoder 116
1676 // 1069: }
1677 // 1069: } // switch Inst[13]
1678 // 1069: }
1679 1, 6, // 1073: case 0x1: {
1680 OPC_CheckPredicate, 10, // 1075: check predicate 10
1681 OPC_Decode, 194, 21, 117, // 1077: decode to SHLL_QB_MM using decoder 117
1682 // 1077: }
1683 2, 27, // 1081: case 0x2: {
1684 OPC_SwitchField, 13, 1, // 1083: switch Inst[13] {
1685 0, 10, // 1086: case 0x0: {
1686 OPC_CheckPredicate, 10, // 1088: check predicate 10
1687 OPC_CheckField, 21, 5, 0, // 1090: check Inst[25:21] == 0x0
1688 OPC_Decode, 187, 17, 115, // 1094: decode to MFLO_DSP_MM using decoder 115
1689 // 1094: }
1690 1, 0, // 1098: case 0x1: {
1691 OPC_CheckPredicate, 10, // 1100: check predicate 10
1692 OPC_CheckField, 21, 5, 0, // 1102: check Inst[25:21] == 0x0
1693 OPC_Decode, 214, 18, 118, // 1106: decode to MTLO_DSP_MM using decoder 118
1694 // 1106: }
1695 // 1106: } // switch Inst[13]
1696 // 1106: }
1697 3, 0, // 1110: case 0x3: {
1698 OPC_CheckPredicate, 10, // 1112: check predicate 10
1699 OPC_Decode, 226, 21, 117, // 1114: decode to SHRL_QB_MM using decoder 117
1700 // 1114: }
1701 // 1114: } // switch Inst[12:11]
1702 // 1114: }
1703 2, 59, // 1118: case 0x2: {
1704 OPC_SwitchField, 11, 3, // 1120: switch Inst[13:11] {
1705 0, 6, // 1123: case 0x0: {
1706 OPC_CheckPredicate, 11, // 1125: check predicate 11
1707 OPC_Decode, 186, 12, 119, // 1127: decode to DPA_W_PH_MMR2 using decoder 119
1708 // 1127: }
1709 1, 6, // 1131: case 0x1: {
1710 OPC_CheckPredicate, 11, // 1133: check predicate 11
1711 OPC_Decode, 189, 7, 120, // 1135: decode to BALIGN_MMR2 using decoder 120
1712 // 1135: }
1713 2, 6, // 1139: case 0x2: {
1714 OPC_CheckPredicate, 11, // 1141: check predicate 11
1715 OPC_Decode, 184, 12, 119, // 1143: decode to DPAX_W_PH_MMR2 using decoder 119
1716 // 1143: }
1717 4, 6, // 1147: case 0x4: {
1718 OPC_CheckPredicate, 10, // 1149: check predicate 10
1719 OPC_Decode, 180, 12, 119, // 1151: decode to DPAU_H_QBL_MM using decoder 119
1720 // 1151: }
1721 5, 6, // 1155: case 0x5: {
1722 OPC_CheckPredicate, 10, // 1157: check predicate 10
1723 OPC_Decode, 134, 13, 121, // 1159: decode to EXTPV_MM using decoder 121
1724 // 1159: }
1725 6, 6, // 1163: case 0x6: {
1726 OPC_CheckPredicate, 10, // 1165: check predicate 10
1727 OPC_Decode, 182, 12, 119, // 1167: decode to DPAU_H_QBR_MM using decoder 119
1728 // 1167: }
1729 7, 0, // 1171: case 0x7: {
1730 OPC_CheckPredicate, 10, // 1173: check predicate 10
1731 OPC_Decode, 131, 13, 121, // 1175: decode to EXTPDPV_MM using decoder 121
1732 // 1175: }
1733 // 1175: } // switch Inst[13:11]
1734 // 1175: }
1735 3, 10, // 1179: case 0x3: {
1736 OPC_CheckPredicate, 1, // 1181: check predicate 1
1737 OPC_CheckField, 14, 2, 0, // 1183: check Inst[15:14] == 0x0
1738 OPC_Decode, 157, 17, 111, // 1187: decode to MFC0_MM using decoder 111
1739 // 1187: }
1740 4, 99, // 1191: case 0x4: {
1741 OPC_SwitchField, 11, 5, // 1193: switch Inst[15:11] {
1742 0, 6, // 1196: case 0x0: {
1743 OPC_CheckPredicate, 11, // 1198: check predicate 11
1744 OPC_Decode, 154, 6, 122, // 1200: decode to ABSQ_S_QB_MMR2 using decoder 122
1745 // 1200: }
1746 2, 6, // 1204: case 0x2: {
1747 OPC_CheckPredicate, 10, // 1206: check predicate 10
1748 OPC_Decode, 152, 6, 122, // 1208: decode to ABSQ_S_PH_MM using decoder 122
1749 // 1208: }
1750 4, 6, // 1212: case 0x4: {
1751 OPC_CheckPredicate, 10, // 1214: check predicate 10
1752 OPC_Decode, 156, 6, 123, // 1216: decode to ABSQ_S_W_MM using decoder 123
1753 // 1216: }
1754 6, 6, // 1220: case 0x6: {
1755 OPC_CheckPredicate, 10, // 1222: check predicate 10
1756 OPC_Decode, 164, 8, 123, // 1224: decode to BITREV_MM using decoder 123
1757 // 1224: }
1758 8, 6, // 1228: case 0x8: {
1759 OPC_CheckPredicate, 10, // 1230: check predicate 10
1760 OPC_Decode, 129, 15, 124, // 1232: decode to INSV_MM using decoder 124
1761 // 1232: }
1762 10, 6, // 1236: case 0xa: {
1763 OPC_CheckPredicate, 10, // 1238: check predicate 10
1764 OPC_Decode, 238, 19, 125, // 1240: decode to PRECEQ_W_PHL_MM using decoder 125
1765 // 1240: }
1766 12, 6, // 1244: case 0xc: {
1767 OPC_CheckPredicate, 10, // 1246: check predicate 10
1768 OPC_Decode, 240, 19, 125, // 1248: decode to PRECEQ_W_PHR_MM using decoder 125
1769 // 1248: }
1770 14, 6, // 1252: case 0xe: {
1771 OPC_CheckPredicate, 10, // 1254: check predicate 10
1772 OPC_Decode, 232, 19, 122, // 1256: decode to PRECEQU_PH_QBL_MM using decoder 122
1773 // 1256: }
1774 18, 6, // 1260: case 0x12: {
1775 OPC_CheckPredicate, 10, // 1262: check predicate 10
1776 OPC_Decode, 236, 19, 122, // 1264: decode to PRECEQU_PH_QBR_MM using decoder 122
1777 // 1264: }
1778 22, 6, // 1268: case 0x16: {
1779 OPC_CheckPredicate, 10, // 1270: check predicate 10
1780 OPC_Decode, 244, 19, 122, // 1272: decode to PRECEU_PH_QBL_MM using decoder 122
1781 // 1272: }
1782 26, 6, // 1276: case 0x1a: {
1783 OPC_CheckPredicate, 10, // 1278: check predicate 10
1784 OPC_Decode, 248, 19, 122, // 1280: decode to PRECEU_PH_QBR_MM using decoder 122
1785 // 1280: }
1786 30, 0, // 1284: case 0x1e: {
1787 OPC_CheckPredicate, 10, // 1286: check predicate 10
1788 OPC_Decode, 149, 20, 125, // 1288: decode to RADDU_W_QB_MM using decoder 125
1789 // 1288: }
1790 // 1288: } // switch Inst[15:11]
1791 // 1288: }
1792 5, 51, // 1292: case 0x5: {
1793 OPC_SwitchField, 11, 15, // 1294: switch Inst[25:11] {
1794 0, 6, // 1297: case 0x0: {
1795 OPC_CheckPredicate, 12, // 1299: check predicate 12
1796 OPC_Decode, 250, 23, 10, // 1301: decode to TLBGP_MM using decoder 10
1797 // 1301: }
1798 2, 6, // 1305: case 0x2: {
1799 OPC_CheckPredicate, 12, // 1307: check predicate 12
1800 OPC_Decode, 252, 23, 10, // 1309: decode to TLBGR_MM using decoder 10
1801 // 1309: }
1802 4, 6, // 1313: case 0x4: {
1803 OPC_CheckPredicate, 12, // 1315: check predicate 12
1804 OPC_Decode, 254, 23, 10, // 1317: decode to TLBGWI_MM using decoder 10
1805 // 1317: }
1806 6, 6, // 1321: case 0x6: {
1807 OPC_CheckPredicate, 12, // 1323: check predicate 12
1808 OPC_Decode, 128, 24, 10, // 1325: decode to TLBGWR_MM using decoder 10
1809 // 1325: }
1810 8, 6, // 1329: case 0x8: {
1811 OPC_CheckPredicate, 12, // 1331: check predicate 12
1812 OPC_Decode, 248, 23, 10, // 1333: decode to TLBGINV_MM using decoder 10
1813 // 1333: }
1814 10, 0, // 1337: case 0xa: {
1815 OPC_CheckPredicate, 12, // 1339: check predicate 12
1816 OPC_Decode, 247, 23, 10, // 1341: decode to TLBGINVF_MM using decoder 10
1817 // 1341: }
1818 // 1341: } // switch Inst[25:11]
1819 // 1341: }
1820 7, 19, // 1345: case 0x7: {
1821 OPC_SwitchField, 11, 2, // 1347: switch Inst[12:11] {
1822 0, 6, // 1350: case 0x0: {
1823 OPC_CheckPredicate, 11, // 1352: check predicate 11
1824 OPC_Decode, 212, 21, 117, // 1354: decode to SHRA_QB_MMR2 using decoder 117
1825 // 1354: }
1826 2, 0, // 1358: case 0x2: {
1827 OPC_CheckPredicate, 11, // 1360: check predicate 11
1828 OPC_Decode, 216, 21, 117, // 1362: decode to SHRA_R_QB_MMR2 using decoder 117
1829 // 1362: }
1830 // 1362: } // switch Inst[12:11]
1831 // 1362: }
1832 8, 19, // 1366: case 0x8: {
1833 OPC_SwitchField, 11, 1, // 1368: switch Inst[11] {
1834 0, 6, // 1371: case 0x0: {
1835 OPC_CheckPredicate, 2, // 1373: check predicate 2
1836 OPC_Decode, 244, 23, 114, // 1375: decode to TGE_MM using decoder 114
1837 // 1375: }
1838 1, 0, // 1379: case 0x1: {
1839 OPC_CheckPredicate, 2, // 1381: check predicate 2
1840 OPC_Decode, 146, 24, 114, // 1383: decode to TLTU_MM using decoder 114
1841 // 1383: }
1842 // 1383: } // switch Inst[11]
1843 // 1383: }
1844 9, 59, // 1387: case 0x9: {
1845 OPC_SwitchField, 11, 3, // 1389: switch Inst[13:11] {
1846 0, 10, // 1392: case 0x0: {
1847 OPC_CheckPredicate, 10, // 1394: check predicate 10
1848 OPC_CheckField, 21, 5, 0, // 1396: check Inst[25:21] == 0x0
1849 OPC_Decode, 210, 18, 126, // 1400: decode to MTHLIP_MM using decoder 126
1850 // 1400: }
1851 1, 6, // 1404: case 0x1: {
1852 OPC_CheckPredicate, 10, // 1406: check predicate 10
1853 OPC_Decode, 255, 16, 119, // 1408: decode to MAQ_S_W_PHR_MM using decoder 119
1854 // 1408: }
1855 2, 10, // 1412: case 0x2: {
1856 OPC_CheckPredicate, 10, // 1414: check predicate 10
1857 OPC_CheckField, 21, 5, 0, // 1416: check Inst[25:21] == 0x0
1858 OPC_Decode, 181, 21, 126, // 1420: decode to SHILOV_MM using decoder 126
1859 // 1420: }
1860 3, 6, // 1424: case 0x3: {
1861 OPC_CheckPredicate, 10, // 1426: check predicate 10
1862 OPC_Decode, 253, 16, 119, // 1428: decode to MAQ_S_W_PHL_MM using decoder 119
1863 // 1428: }
1864 5, 6, // 1432: case 0x5: {
1865 OPC_CheckPredicate, 10, // 1434: check predicate 10
1866 OPC_Decode, 251, 16, 119, // 1436: decode to MAQ_SA_W_PHR_MM using decoder 119
1867 // 1436: }
1868 7, 0, // 1440: case 0x7: {
1869 OPC_CheckPredicate, 10, // 1442: check predicate 10
1870 OPC_Decode, 249, 16, 119, // 1444: decode to MAQ_SA_W_PHL_MM using decoder 119
1871 // 1444: }
1872 // 1444: } // switch Inst[13:11]
1873 // 1444: }
1874 10, 67, // 1448: case 0xa: {
1875 OPC_SwitchField, 11, 3, // 1450: switch Inst[13:11] {
1876 0, 6, // 1453: case 0x0: {
1877 OPC_CheckPredicate, 10, // 1455: check predicate 10
1878 OPC_Decode, 178, 12, 119, // 1457: decode to DPAQ_S_W_PH_MM using decoder 119
1879 // 1457: }
1880 1, 6, // 1461: case 0x1: {
1881 OPC_CheckPredicate, 10, // 1463: check predicate 10
1882 OPC_Decode, 242, 16, 127, // 1465: decode to MADD_DSP_MM using decoder 127
1883 // 1465: }
1884 2, 6, // 1469: case 0x2: {
1885 OPC_CheckPredicate, 10, // 1471: check predicate 10
1886 OPC_Decode, 176, 12, 119, // 1473: decode to DPAQ_SA_L_W_MM using decoder 119
1887 // 1473: }
1888 3, 6, // 1477: case 0x3: {
1889 OPC_CheckPredicate, 10, // 1479: check predicate 10
1890 OPC_Decode, 232, 16, 127, // 1481: decode to MADDU_DSP_MM using decoder 127
1891 // 1481: }
1892 4, 6, // 1485: case 0x4: {
1893 OPC_CheckPredicate, 11, // 1487: check predicate 11
1894 OPC_Decode, 174, 12, 119, // 1489: decode to DPAQX_S_W_PH_MMR2 using decoder 119
1895 // 1489: }
1896 5, 6, // 1493: case 0x5: {
1897 OPC_CheckPredicate, 10, // 1495: check predicate 10
1898 OPC_Decode, 176, 18, 127, // 1497: decode to MSUB_DSP_MM using decoder 127
1899 // 1497: }
1900 6, 6, // 1501: case 0x6: {
1901 OPC_CheckPredicate, 11, // 1503: check predicate 11
1902 OPC_Decode, 172, 12, 119, // 1505: decode to DPAQX_SA_W_PH_MMR2 using decoder 119
1903 // 1505: }
1904 7, 0, // 1509: case 0x7: {
1905 OPC_CheckPredicate, 10, // 1511: check predicate 10
1906 OPC_Decode, 166, 18, 127, // 1513: decode to MSUBU_DSP_MM using decoder 127
1907 // 1513: }
1908 // 1513: } // switch Inst[13:11]
1909 // 1513: }
1910 11, 10, // 1517: case 0xb: {
1911 OPC_CheckPredicate, 1, // 1519: check predicate 1
1912 OPC_CheckField, 14, 2, 0, // 1521: check Inst[15:14] == 0x0
1913 OPC_Decode, 183, 18, 112, // 1525: decode to MTC0_MM using decoder 112
1914 // 1525: }
1915 12, 174, 1, // 1529: case 0xc: {
1916 OPC_SwitchField, 11, 5, // 1532: switch Inst[15:11] {
1917 0, 7, // 1535: case 0x0: {
1918 OPC_CheckPredicate, 10, // 1537: check predicate 10
1919 OPC_Decode, 166, 20, 128, 1, // 1539: decode to REPLV_PH_MM using decoder 128
1920 // 1539: }
1921 2, 7, // 1544: case 0x2: {
1922 OPC_CheckPredicate, 10, // 1546: check predicate 10
1923 OPC_Decode, 168, 20, 128, 1, // 1548: decode to REPLV_QB_MM using decoder 128
1924 // 1548: }
1925 5, 6, // 1553: case 0x5: {
1926 OPC_CheckPredicate, 2, // 1555: check predicate 2
1927 OPC_Decode, 141, 21, 123, // 1557: decode to SEB_MM using decoder 123
1928 // 1557: }
1929 7, 6, // 1561: case 0x7: {
1930 OPC_CheckPredicate, 2, // 1563: check predicate 2
1931 OPC_Decode, 145, 21, 123, // 1565: decode to SEH_MM using decoder 123
1932 // 1565: }
1933 9, 6, // 1569: case 0x9: {
1934 OPC_CheckPredicate, 2, // 1571: check predicate 2
1935 OPC_Decode, 203, 9, 123, // 1573: decode to CLO_MM using decoder 123
1936 // 1573: }
1937 11, 6, // 1577: case 0xb: {
1938 OPC_CheckPredicate, 2, // 1579: check predicate 2
1939 OPC_Decode, 224, 9, 123, // 1581: decode to CLZ_MM using decoder 123
1940 // 1581: }
1941 13, 7, // 1585: case 0xd: {
1942 OPC_CheckPredicate, 1, // 1587: check predicate 1
1943 OPC_Decode, 154, 20, 129, 1, // 1589: decode to RDHWR_MM using decoder 129
1944 // 1589: }
1945 14, 6, // 1594: case 0xe: {
1946 OPC_CheckPredicate, 10, // 1596: check predicate 10
1947 OPC_Decode, 231, 19, 122, // 1598: decode to PRECEQU_PH_QBLA_MM using decoder 122
1948 // 1598: }
1949 15, 6, // 1602: case 0xf: {
1950 OPC_CheckPredicate, 2, // 1604: check predicate 2
1951 OPC_Decode, 189, 24, 123, // 1606: decode to WSBH_MM using decoder 123
1952 // 1606: }
1953 17, 7, // 1610: case 0x11: {
1954 OPC_CheckPredicate, 1, // 1612: check predicate 1
1955 OPC_Decode, 131, 19, 130, 1, // 1614: decode to MULT_MM using decoder 130
1956 // 1614: }
1957 18, 6, // 1619: case 0x12: {
1958 OPC_CheckPredicate, 10, // 1621: check predicate 10
1959 OPC_Decode, 235, 19, 122, // 1623: decode to PRECEQU_PH_QBRA_MM using decoder 122
1960 // 1623: }
1961 19, 7, // 1627: case 0x13: {
1962 OPC_CheckPredicate, 1, // 1629: check predicate 1
1963 OPC_Decode, 133, 19, 130, 1, // 1631: decode to MULTu_MM using decoder 130
1964 // 1631: }
1965 21, 7, // 1636: case 0x15: {
1966 OPC_CheckPredicate, 1, // 1638: check predicate 1
1967 OPC_Decode, 134, 21, 130, 1, // 1640: decode to SDIV_MM using decoder 130
1968 // 1640: }
1969 22, 6, // 1645: case 0x16: {
1970 OPC_CheckPredicate, 10, // 1647: check predicate 10
1971 OPC_Decode, 243, 19, 122, // 1649: decode to PRECEU_PH_QBLA_MM using decoder 122
1972 // 1649: }
1973 23, 7, // 1653: case 0x17: {
1974 OPC_CheckPredicate, 1, // 1655: check predicate 1
1975 OPC_Decode, 172, 24, 130, 1, // 1657: decode to UDIV_MM using decoder 130
1976 // 1657: }
1977 25, 7, // 1662: case 0x19: {
1978 OPC_CheckPredicate, 1, // 1664: check predicate 1
1979 OPC_Decode, 243, 16, 130, 1, // 1666: decode to MADD_MM using decoder 130
1980 // 1666: }
1981 26, 6, // 1671: case 0x1a: {
1982 OPC_CheckPredicate, 10, // 1673: check predicate 10
1983 OPC_Decode, 247, 19, 122, // 1675: decode to PRECEU_PH_QBRA_MM using decoder 122
1984 // 1675: }
1985 27, 7, // 1679: case 0x1b: {
1986 OPC_CheckPredicate, 1, // 1681: check predicate 1
1987 OPC_Decode, 233, 16, 130, 1, // 1683: decode to MADDU_MM using decoder 130
1988 // 1683: }
1989 29, 7, // 1688: case 0x1d: {
1990 OPC_CheckPredicate, 1, // 1690: check predicate 1
1991 OPC_Decode, 177, 18, 130, 1, // 1692: decode to MSUB_MM using decoder 130
1992 // 1692: }
1993 31, 0, // 1697: case 0x1f: {
1994 OPC_CheckPredicate, 1, // 1699: check predicate 1
1995 OPC_Decode, 167, 18, 130, 1, // 1701: decode to MSUBU_MM using decoder 130
1996 // 1701: }
1997 // 1701: } // switch Inst[15:11]
1998 // 1701: }
1999 13, 124, // 1706: case 0xd: {
2000 OPC_SwitchField, 11, 5, // 1708: switch Inst[15:11] {
2001 0, 10, // 1711: case 0x0: {
2002 OPC_CheckPredicate, 2, // 1713: check predicate 2
2003 OPC_CheckField, 16, 10, 0, // 1715: check Inst[25:16] == 0x0
2004 OPC_Decode, 134, 24, 10, // 1719: decode to TLBP_MM using decoder 10
2005 // 1719: }
2006 2, 10, // 1723: case 0x2: {
2007 OPC_CheckPredicate, 2, // 1725: check predicate 2
2008 OPC_CheckField, 16, 10, 0, // 1727: check Inst[25:16] == 0x0
2009 OPC_Decode, 136, 24, 10, // 1731: decode to TLBR_MM using decoder 10
2010 // 1731: }
2011 4, 10, // 1735: case 0x4: {
2012 OPC_CheckPredicate, 2, // 1737: check predicate 2
2013 OPC_CheckField, 16, 10, 0, // 1739: check Inst[25:16] == 0x0
2014 OPC_Decode, 138, 24, 10, // 1743: decode to TLBWI_MM using decoder 10
2015 // 1743: }
2016 6, 10, // 1747: case 0x6: {
2017 OPC_CheckPredicate, 2, // 1749: check predicate 2
2018 OPC_CheckField, 16, 10, 0, // 1751: check Inst[25:16] == 0x0
2019 OPC_Decode, 140, 24, 10, // 1755: decode to TLBWR_MM using decoder 10
2020 // 1755: }
2021 13, 11, // 1759: case 0xd: {
2022 OPC_CheckPredicate, 2, // 1761: check predicate 2
2023 OPC_CheckField, 21, 5, 0, // 1763: check Inst[25:21] == 0x0
2024 OPC_Decode, 204, 23, 131, 1, // 1767: decode to SYNC_MM using decoder 131
2025 // 1767: }
2026 17, 7, // 1772: case 0x11: {
2027 OPC_CheckPredicate, 2, // 1774: check predicate 2
2028 OPC_Decode, 209, 23, 132, 1, // 1776: decode to SYSCALL_MM using decoder 132
2029 // 1776: }
2030 18, 7, // 1781: case 0x12: {
2031 OPC_CheckPredicate, 2, // 1783: check predicate 2
2032 OPC_Decode, 181, 24, 132, 1, // 1785: decode to WAIT_MM using decoder 132
2033 // 1785: }
2034 24, 7, // 1790: case 0x18: {
2035 OPC_CheckPredicate, 12, // 1792: check predicate 12
2036 OPC_Decode, 230, 14, 132, 1, // 1794: decode to HYPCALL_MM using decoder 132
2037 // 1794: }
2038 27, 7, // 1799: case 0x1b: {
2039 OPC_CheckPredicate, 2, // 1801: check predicate 2
2040 OPC_Decode, 248, 20, 132, 1, // 1803: decode to SDBBP_MM using decoder 132
2041 // 1803: }
2042 28, 10, // 1808: case 0x1c: {
2043 OPC_CheckPredicate, 2, // 1810: check predicate 2
2044 OPC_CheckField, 16, 10, 0, // 1812: check Inst[25:16] == 0x0
2045 OPC_Decode, 237, 11, 10, // 1816: decode to DERET_MM using decoder 10
2046 // 1816: }
2047 30, 0, // 1820: case 0x1e: {
2048 OPC_CheckPredicate, 2, // 1822: check predicate 2
2049 OPC_CheckField, 16, 10, 0, // 1824: check Inst[25:16] == 0x0
2050 OPC_Decode, 248, 12, 10, // 1828: decode to ERET_MM using decoder 10
2051 // 1828: }
2052 // 1828: } // switch Inst[15:11]
2053 // 1828: }
2054 15, 10, // 1832: case 0xf: {
2055 OPC_CheckPredicate, 11, // 1834: check predicate 11
2056 OPC_CheckField, 11, 1, 0, // 1836: check Inst[11] == 0x0
2057 OPC_Decode, 224, 21, 113, // 1840: decode to SHRL_PH_MMR2 using decoder 113
2058 // 1840: }
2059 16, 19, // 1844: case 0x10: {
2060 OPC_SwitchField, 11, 1, // 1846: switch Inst[11] {
2061 0, 6, // 1849: case 0x0: {
2062 OPC_CheckPredicate, 2, // 1851: check predicate 2
2063 OPC_Decode, 243, 23, 114, // 1853: decode to TGEU_MM using decoder 114
2064 // 1853: }
2065 1, 0, // 1857: case 0x1: {
2066 OPC_CheckPredicate, 2, // 1859: check predicate 2
2067 OPC_Decode, 151, 24, 114, // 1861: decode to TNE_MM using decoder 114
2068 // 1861: }
2069 // 1861: } // switch Inst[11]
2070 // 1861: }
2071 18, 69, // 1865: case 0x12: {
2072 OPC_SwitchField, 11, 3, // 1867: switch Inst[13:11] {
2073 0, 6, // 1870: case 0x0: {
2074 OPC_CheckPredicate, 11, // 1872: check predicate 11
2075 OPC_Decode, 209, 12, 119, // 1874: decode to DPS_W_PH_MMR2 using decoder 119
2076 // 1874: }
2077 1, 7, // 1878: case 0x1: {
2078 OPC_CheckPredicate, 10, // 1880: check predicate 10
2079 OPC_Decode, 130, 19, 133, 1, // 1882: decode to MULT_DSP_MM using decoder 133
2080 // 1882: }
2081 2, 6, // 1887: case 0x2: {
2082 OPC_CheckPredicate, 11, // 1889: check predicate 11
2083 OPC_Decode, 207, 12, 119, // 1891: decode to DPSX_W_PH_MMR2 using decoder 119
2084 // 1891: }
2085 3, 7, // 1895: case 0x3: {
2086 OPC_CheckPredicate, 10, // 1897: check predicate 10
2087 OPC_Decode, 128, 19, 133, 1, // 1899: decode to MULTU_DSP_MM using decoder 133
2088 // 1899: }
2089 4, 6, // 1904: case 0x4: {
2090 OPC_CheckPredicate, 10, // 1906: check predicate 10
2091 OPC_Decode, 203, 12, 119, // 1908: decode to DPSU_H_QBL_MM using decoder 119
2092 // 1908: }
2093 5, 6, // 1912: case 0x5: {
2094 OPC_CheckPredicate, 11, // 1914: check predicate 11
2095 OPC_Decode, 253, 18, 119, // 1916: decode to MULSA_W_PH_MMR2 using decoder 119
2096 // 1916: }
2097 6, 6, // 1920: case 0x6: {
2098 OPC_CheckPredicate, 10, // 1922: check predicate 10
2099 OPC_Decode, 205, 12, 119, // 1924: decode to DPSU_H_QBR_MM using decoder 119
2100 // 1924: }
2101 7, 0, // 1928: case 0x7: {
2102 OPC_CheckPredicate, 10, // 1930: check predicate 10
2103 OPC_Decode, 251, 18, 119, // 1932: decode to MULSAQ_S_W_PH_MM using decoder 119
2104 // 1932: }
2105 // 1932: } // switch Inst[13:11]
2106 // 1932: }
2107 19, 10, // 1936: case 0x13: {
2108 OPC_CheckPredicate, 12, // 1938: check predicate 12
2109 OPC_CheckField, 14, 2, 0, // 1940: check Inst[15:14] == 0x0
2110 OPC_Decode, 167, 17, 111, // 1944: decode to MFGC0_MM using decoder 111
2111 // 1944: }
2112 20, 21, // 1948: case 0x14: {
2113 OPC_SwitchField, 11, 5, // 1950: switch Inst[15:11] {
2114 25, 7, // 1953: case 0x19: {
2115 OPC_CheckPredicate, 2, // 1955: check predicate 2
2116 OPC_Decode, 176, 9, 134, 1, // 1957: decode to CFC2_MM using decoder 134
2117 // 1957: }
2118 27, 0, // 1962: case 0x1b: {
2119 OPC_CheckPredicate, 2, // 1964: check predicate 2
2120 OPC_Decode, 211, 10, 135, 1, // 1966: decode to CTC2_MM using decoder 135
2121 // 1966: }
2122 // 1966: } // switch Inst[15:11]
2123 // 1966: }
2124 21, 55, // 1971: case 0x15: {
2125 OPC_SwitchField, 11, 5, // 1973: switch Inst[15:11] {
2126 1, 11, // 1976: case 0x1: {
2127 OPC_CheckPredicate, 1, // 1978: check predicate 1
2128 OPC_CheckField, 21, 5, 0, // 1980: check Inst[25:21] == 0x0
2129 OPC_Decode, 182, 17, 136, 1, // 1984: decode to MFHI_MM using decoder 136
2130 // 1984: }
2131 3, 11, // 1989: case 0x3: {
2132 OPC_CheckPredicate, 1, // 1991: check predicate 1
2133 OPC_CheckField, 21, 5, 0, // 1993: check Inst[25:21] == 0x0
2134 OPC_Decode, 188, 17, 136, 1, // 1997: decode to MFLO_MM using decoder 136
2135 // 1997: }
2136 5, 11, // 2002: case 0x5: {
2137 OPC_CheckPredicate, 1, // 2004: check predicate 1
2138 OPC_CheckField, 21, 5, 0, // 2006: check Inst[25:21] == 0x0
2139 OPC_Decode, 208, 18, 136, 1, // 2010: decode to MTHI_MM using decoder 136
2140 // 2010: }
2141 7, 0, // 2015: case 0x7: {
2142 OPC_CheckPredicate, 1, // 2017: check predicate 1
2143 OPC_CheckField, 21, 5, 0, // 2019: check Inst[25:21] == 0x0
2144 OPC_Decode, 215, 18, 136, 1, // 2023: decode to MTLO_MM using decoder 136
2145 // 2023: }
2146 // 2023: } // switch Inst[15:11]
2147 // 2023: }
2148 23, 11, // 2028: case 0x17: {
2149 OPC_CheckPredicate, 10, // 2030: check predicate 10
2150 OPC_CheckField, 11, 2, 0, // 2032: check Inst[12:11] == 0x0
2151 OPC_Decode, 172, 20, 137, 1, // 2036: decode to REPL_QB_MM using decoder 137
2152 // 2036: }
2153 25, 75, // 2041: case 0x19: {
2154 OPC_SwitchField, 11, 3, // 2043: switch Inst[13:11] {
2155 0, 7, // 2046: case 0x0: {
2156 OPC_CheckPredicate, 10, // 2048: check predicate 10
2157 OPC_Decode, 151, 20, 138, 1, // 2050: decode to RDDSP_MM using decoder 138
2158 // 2050: }
2159 1, 7, // 2055: case 0x1: {
2160 OPC_CheckPredicate, 10, // 2057: check predicate 10
2161 OPC_Decode, 151, 13, 139, 1, // 2059: decode to EXTR_W_MM using decoder 139
2162 // 2059: }
2163 2, 7, // 2064: case 0x2: {
2164 OPC_CheckPredicate, 10, // 2066: check predicate 10
2165 OPC_Decode, 185, 24, 138, 1, // 2068: decode to WRDSP_MM using decoder 138
2166 // 2068: }
2167 3, 7, // 2073: case 0x3: {
2168 OPC_CheckPredicate, 10, // 2075: check predicate 10
2169 OPC_Decode, 147, 13, 139, 1, // 2077: decode to EXTR_R_W_MM using decoder 139
2170 // 2077: }
2171 4, 7, // 2082: case 0x4: {
2172 OPC_CheckPredicate, 10, // 2084: check predicate 10
2173 OPC_Decode, 135, 13, 139, 1, // 2086: decode to EXTP_MM using decoder 139
2174 // 2086: }
2175 5, 7, // 2091: case 0x5: {
2176 OPC_CheckPredicate, 10, // 2093: check predicate 10
2177 OPC_Decode, 145, 13, 139, 1, // 2095: decode to EXTR_RS_W_MM using decoder 139
2178 // 2095: }
2179 6, 7, // 2100: case 0x6: {
2180 OPC_CheckPredicate, 10, // 2102: check predicate 10
2181 OPC_Decode, 132, 13, 139, 1, // 2104: decode to EXTPDP_MM using decoder 139
2182 // 2104: }
2183 7, 0, // 2109: case 0x7: {
2184 OPC_CheckPredicate, 10, // 2111: check predicate 10
2185 OPC_Decode, 149, 13, 139, 1, // 2113: decode to EXTR_S_H_MM using decoder 139
2186 // 2113: }
2187 // 2113: } // switch Inst[13:11]
2188 // 2113: }
2189 26, 67, // 2118: case 0x1a: {
2190 OPC_SwitchField, 11, 3, // 2120: switch Inst[13:11] {
2191 0, 6, // 2123: case 0x0: {
2192 OPC_CheckPredicate, 10, // 2125: check predicate 10
2193 OPC_Decode, 195, 12, 119, // 2127: decode to DPSQ_S_W_PH_MM using decoder 119
2194 // 2127: }
2195 1, 6, // 2131: case 0x1: {
2196 OPC_CheckPredicate, 10, // 2133: check predicate 10
2197 OPC_Decode, 143, 13, 121, // 2135: decode to EXTRV_W_MM using decoder 121
2198 // 2135: }
2199 2, 6, // 2139: case 0x2: {
2200 OPC_CheckPredicate, 10, // 2141: check predicate 10
2201 OPC_Decode, 193, 12, 119, // 2143: decode to DPSQ_SA_L_W_MM using decoder 119
2202 // 2143: }
2203 3, 6, // 2147: case 0x3: {
2204 OPC_CheckPredicate, 10, // 2149: check predicate 10
2205 OPC_Decode, 139, 13, 121, // 2151: decode to EXTRV_R_W_MM using decoder 121
2206 // 2151: }
2207 4, 6, // 2155: case 0x4: {
2208 OPC_CheckPredicate, 11, // 2157: check predicate 11
2209 OPC_Decode, 191, 12, 119, // 2159: decode to DPSQX_S_W_PH_MMR2 using decoder 119
2210 // 2159: }
2211 5, 6, // 2163: case 0x5: {
2212 OPC_CheckPredicate, 10, // 2165: check predicate 10
2213 OPC_Decode, 137, 13, 121, // 2167: decode to EXTRV_RS_W_MM using decoder 121
2214 // 2167: }
2215 6, 6, // 2171: case 0x6: {
2216 OPC_CheckPredicate, 11, // 2173: check predicate 11
2217 OPC_Decode, 189, 12, 119, // 2175: decode to DPSQX_SA_W_PH_MMR2 using decoder 119
2218 // 2175: }
2219 7, 0, // 2179: case 0x7: {
2220 OPC_CheckPredicate, 10, // 2181: check predicate 10
2221 OPC_Decode, 141, 13, 121, // 2183: decode to EXTRV_S_H_MM using decoder 121
2222 // 2183: }
2223 // 2183: } // switch Inst[13:11]
2224 // 2183: }
2225 27, 10, // 2187: case 0x1b: {
2226 OPC_CheckPredicate, 12, // 2189: check predicate 12
2227 OPC_CheckField, 14, 2, 0, // 2191: check Inst[15:14] == 0x0
2228 OPC_Decode, 194, 18, 112, // 2195: decode to MTGC0_MM using decoder 112
2229 // 2195: }
2230 28, 53, // 2199: case 0x1c: {
2231 OPC_SwitchField, 11, 5, // 2201: switch Inst[15:11] {
2232 1, 19, // 2204: case 0x1: {
2233 OPC_Scope, 11, // 2206: try {
2234 OPC_CheckField, 21, 5, 0, // 2208: check Inst[25:21] == 0x0
2235 OPC_CheckPredicate, 1, // 2212: check predicate 1
2236 OPC_Decode, 173, 15, 136, 1, // 2214: decode to JR_MM using decoder 136
2237 // 2214: } else try {
2238 OPC_CheckPredicate, 1, // 2219: check predicate 1
2239 OPC_Decode, 149, 15, 123, // 2221: decode to JALR_MM using decoder 123
2240 // 2221: }
2241 // 2221: }
2242 3, 19, // 2225: case 0x3: {
2243 OPC_Scope, 11, // 2227: try {
2244 OPC_CheckField, 21, 5, 0, // 2229: check Inst[25:21] == 0x0
2245 OPC_CheckPredicate, 1, // 2233: check predicate 1
2246 OPC_Decode, 171, 15, 136, 1, // 2235: decode to JR_HB_MM using decoder 136
2247 // 2235: } else try {
2248 OPC_CheckPredicate, 1, // 2240: check predicate 1
2249 OPC_Decode, 148, 15, 123, // 2242: decode to JALR_HB_MM using decoder 123
2250 // 2242: }
2251 // 2242: }
2252 9, 0, // 2246: case 0x9: {
2253 OPC_CheckPredicate, 1, // 2248: check predicate 1
2254 OPC_Decode, 145, 15, 123, // 2250: decode to JALRS_MM using decoder 123
2255 // 2250: }
2256 // 2250: } // switch Inst[15:11]
2257 // 2250: }
2258 29, 0, // 2254: case 0x1d: {
2259 OPC_SwitchField, 11, 5, // 2256: switch Inst[15:11] {
2260 8, 11, // 2259: case 0x8: {
2261 OPC_CheckPredicate, 2, // 2261: check predicate 2
2262 OPC_CheckField, 21, 5, 0, // 2263: check Inst[25:21] == 0x0
2263 OPC_Decode, 134, 12, 136, 1, // 2267: decode to DI_MM using decoder 136
2264 // 2267: }
2265 10, 0, // 2272: case 0xa: {
2266 OPC_CheckPredicate, 2, // 2274: check predicate 2
2267 OPC_CheckField, 21, 5, 0, // 2276: check Inst[25:21] == 0x0
2268 OPC_Decode, 240, 12, 136, 1, // 2280: decode to EI_MM using decoder 136
2269 // 2280: }
2270 // 2280: } // switch Inst[15:11]
2271 // 2280: }
2272 // 2280: } // switch Inst[10:6]
2273 // 2280: }
2274 61, 0, // 2285: case 0x3d: {
2275 OPC_CheckPredicate, 10, // 2287: check predicate 10
2276 OPC_CheckField, 6, 5, 0, // 2289: check Inst[10:6] == 0x0
2277 OPC_Decode, 170, 20, 140, 1, // 2293: decode to REPL_PH_MM using decoder 140
2278 // 2293: }
2279 // 2293: } // switch Inst[5:0]
2280 // 2293: }
2281 4, 7, // 2298: case 0x4: {
2282 OPC_CheckPredicate, 1, // 2300: check predicate 1
2283 OPC_Decode, 239, 6, 141, 1, // 2302: decode to ADDi_MM using decoder 141
2284 // 2302: }
2285 5, 7, // 2307: case 0x5: {
2286 OPC_CheckPredicate, 2, // 2309: check predicate 2
2287 OPC_Decode, 207, 15, 142, 1, // 2311: decode to LBu_MM using decoder 142
2288 // 2311: }
2289 6, 7, // 2316: case 0x6: {
2290 OPC_CheckPredicate, 2, // 2318: check predicate 2
2291 OPC_Decode, 227, 20, 142, 1, // 2320: decode to SB_MM using decoder 142
2292 // 2320: }
2293 7, 7, // 2325: case 0x7: {
2294 OPC_CheckPredicate, 2, // 2327: check predicate 2
2295 OPC_Decode, 199, 15, 142, 1, // 2329: decode to LB_MM using decoder 142
2296 // 2329: }
2297 8, 48, // 2334: case 0x8: {
2298 OPC_SwitchField, 12, 4, // 2336: switch Inst[15:12] {
2299 1, 7, // 2339: case 0x1: {
2300 OPC_CheckPredicate, 2, // 2341: check predicate 2
2301 OPC_Decode, 189, 16, 143, 1, // 2343: decode to LWP_MM using decoder 143
2302 // 2343: }
2303 5, 7, // 2348: case 0x5: {
2304 OPC_CheckPredicate, 2, // 2350: check predicate 2
2305 OPC_Decode, 184, 16, 144, 1, // 2352: decode to LWM32_MM using decoder 144
2306 // 2352: }
2307 6, 7, // 2357: case 0x6: {
2308 OPC_CheckPredicate, 1, // 2359: check predicate 1
2309 OPC_Decode, 151, 9, 145, 1, // 2361: decode to CACHE_MM using decoder 145
2310 // 2361: }
2311 9, 7, // 2366: case 0x9: {
2312 OPC_CheckPredicate, 2, // 2368: check predicate 2
2313 OPC_Decode, 181, 23, 143, 1, // 2370: decode to SWP_MM using decoder 143
2314 // 2370: }
2315 13, 0, // 2375: case 0xd: {
2316 OPC_CheckPredicate, 2, // 2377: check predicate 2
2317 OPC_Decode, 178, 23, 144, 1, // 2379: decode to SWM32_MM using decoder 144
2318 // 2379: }
2319 // 2379: } // switch Inst[15:12]
2320 // 2379: }
2321 12, 7, // 2384: case 0xc: {
2322 OPC_CheckPredicate, 1, // 2386: check predicate 1
2323 OPC_Decode, 241, 6, 141, 1, // 2388: decode to ADDiu_MM using decoder 141
2324 // 2388: }
2325 13, 7, // 2393: case 0xd: {
2326 OPC_CheckPredicate, 2, // 2395: check predicate 2
2327 OPC_Decode, 130, 16, 142, 1, // 2397: decode to LHu_MM using decoder 142
2328 // 2397: }
2329 14, 7, // 2402: case 0xe: {
2330 OPC_CheckPredicate, 2, // 2404: check predicate 2
2331 OPC_Decode, 229, 21, 142, 1, // 2406: decode to SH_MM using decoder 142
2332 // 2406: }
2333 15, 7, // 2411: case 0xf: {
2334 OPC_CheckPredicate, 2, // 2413: check predicate 2
2335 OPC_Decode, 251, 15, 142, 1, // 2415: decode to LH_MM using decoder 142
2336 // 2415: }
2337 16, 217, 1, // 2420: case 0x10: {
2338 OPC_SwitchField, 21, 5, // 2423: switch Inst[25:21] {
2339 0, 7, // 2426: case 0x0: {
2340 OPC_CheckPredicate, 1, // 2428: check predicate 1
2341 OPC_Decode, 198, 8, 146, 1, // 2430: decode to BLTZ_MM using decoder 146
2342 // 2430: }
2343 1, 7, // 2435: case 0x1: {
2344 OPC_CheckPredicate, 1, // 2437: check predicate 1
2345 OPC_Decode, 193, 8, 146, 1, // 2439: decode to BLTZAL_MM using decoder 146
2346 // 2439: }
2347 2, 7, // 2444: case 0x2: {
2348 OPC_CheckPredicate, 1, // 2446: check predicate 1
2349 OPC_Decode, 136, 8, 146, 1, // 2448: decode to BGEZ_MM using decoder 146
2350 // 2448: }
2351 3, 7, // 2453: case 0x3: {
2352 OPC_CheckPredicate, 1, // 2455: check predicate 1
2353 OPC_Decode, 131, 8, 146, 1, // 2457: decode to BGEZAL_MM using decoder 146
2354 // 2457: }
2355 4, 7, // 2462: case 0x4: {
2356 OPC_CheckPredicate, 1, // 2464: check predicate 1
2357 OPC_Decode, 175, 8, 146, 1, // 2466: decode to BLEZ_MM using decoder 146
2358 // 2466: }
2359 5, 7, // 2471: case 0x5: {
2360 OPC_CheckPredicate, 1, // 2473: check predicate 1
2361 OPC_Decode, 226, 8, 146, 1, // 2475: decode to BNEZC_MM using decoder 146
2362 // 2475: }
2363 6, 7, // 2480: case 0x6: {
2364 OPC_CheckPredicate, 1, // 2482: check predicate 1
2365 OPC_Decode, 145, 8, 146, 1, // 2484: decode to BGTZ_MM using decoder 146
2366 // 2484: }
2367 7, 7, // 2489: case 0x7: {
2368 OPC_CheckPredicate, 1, // 2491: check predicate 1
2369 OPC_Decode, 239, 7, 146, 1, // 2493: decode to BEQZC_MM using decoder 146
2370 // 2493: }
2371 8, 7, // 2498: case 0x8: {
2372 OPC_CheckPredicate, 1, // 2500: check predicate 1
2373 OPC_Decode, 144, 24, 147, 1, // 2502: decode to TLTI_MM using decoder 147
2374 // 2502: }
2375 9, 7, // 2507: case 0x9: {
2376 OPC_CheckPredicate, 1, // 2509: check predicate 1
2377 OPC_Decode, 241, 23, 147, 1, // 2511: decode to TGEI_MM using decoder 147
2378 // 2511: }
2379 10, 7, // 2516: case 0xa: {
2380 OPC_CheckPredicate, 1, // 2518: check predicate 1
2381 OPC_Decode, 143, 24, 147, 1, // 2520: decode to TLTIU_MM using decoder 147
2382 // 2520: }
2383 11, 7, // 2525: case 0xb: {
2384 OPC_CheckPredicate, 1, // 2527: check predicate 1
2385 OPC_Decode, 240, 23, 147, 1, // 2529: decode to TGEIU_MM using decoder 147
2386 // 2529: }
2387 12, 7, // 2534: case 0xc: {
2388 OPC_CheckPredicate, 1, // 2536: check predicate 1
2389 OPC_Decode, 150, 24, 147, 1, // 2538: decode to TNEI_MM using decoder 147
2390 // 2538: }
2391 13, 7, // 2543: case 0xd: {
2392 OPC_CheckPredicate, 1, // 2545: check predicate 1
2393 OPC_Decode, 158, 16, 148, 1, // 2547: decode to LUi_MM using decoder 148
2394 // 2547: }
2395 14, 7, // 2552: case 0xe: {
2396 OPC_CheckPredicate, 1, // 2554: check predicate 1
2397 OPC_Decode, 234, 23, 147, 1, // 2556: decode to TEQI_MM using decoder 147
2398 // 2556: }
2399 16, 7, // 2561: case 0x10: {
2400 OPC_CheckPredicate, 1, // 2563: check predicate 1
2401 OPC_Decode, 200, 23, 149, 1, // 2565: decode to SYNCI_MM using decoder 149
2402 // 2565: }
2403 17, 7, // 2570: case 0x11: {
2404 OPC_CheckPredicate, 1, // 2572: check predicate 1
2405 OPC_Decode, 192, 8, 146, 1, // 2574: decode to BLTZALS_MM using decoder 146
2406 // 2574: }
2407 19, 7, // 2579: case 0x13: {
2408 OPC_CheckPredicate, 1, // 2581: check predicate 1
2409 OPC_Decode, 130, 8, 146, 1, // 2583: decode to BGEZALS_MM using decoder 146
2410 // 2583: }
2411 25, 11, // 2588: case 0x19: {
2412 OPC_CheckPredicate, 13, // 2590: check predicate 13
2413 OPC_CheckField, 16, 5, 0, // 2592: check Inst[20:16] == 0x0
2414 OPC_Decode, 239, 8, 150, 1, // 2596: decode to BPOSGE32C_MMR3 using decoder 150
2415 // 2596: }
2416 27, 11, // 2601: case 0x1b: {
2417 OPC_CheckPredicate, 14, // 2603: check predicate 14
2418 OPC_CheckField, 16, 5, 0, // 2605: check Inst[20:16] == 0x0
2419 OPC_Decode, 240, 8, 151, 1, // 2609: decode to BPOSGE32_MM using decoder 151
2420 // 2609: }
2421 28, 11, // 2614: case 0x1c: {
2422 OPC_CheckPredicate, 15, // 2616: check predicate 15
2423 OPC_CheckField, 16, 2, 0, // 2618: check Inst[17:16] == 0x0
2424 OPC_Decode, 204, 7, 152, 1, // 2622: decode to BC1F_MM using decoder 152
2425 // 2622: }
2426 29, 0, // 2627: case 0x1d: {
2427 OPC_CheckPredicate, 15, // 2629: check predicate 15
2428 OPC_CheckField, 16, 2, 0, // 2631: check Inst[17:16] == 0x0
2429 OPC_Decode, 209, 7, 152, 1, // 2635: decode to BC1T_MM using decoder 152
2430 // 2635: }
2431 // 2635: } // switch Inst[25:21]
2432 // 2635: }
2433 20, 7, // 2640: case 0x14: {
2434 OPC_CheckPredicate, 1, // 2642: check predicate 1
2435 OPC_Decode, 202, 19, 153, 1, // 2644: decode to ORi_MM using decoder 153
2436 // 2644: }
2437 21, 177, 7, // 2649: case 0x15: {
2438 OPC_SwitchField, 0, 6, // 2652: switch Inst[5:0] {
2439 1, 7, // 2655: case 0x1: {
2440 OPC_CheckPredicate, 16, // 2657: check predicate 16
2441 OPC_Decode, 247, 16, 154, 1, // 2659: decode to MADD_S_MM using decoder 154
2442 // 2659: }
2443 2, 7, // 2664: case 0x2: {
2444 OPC_CheckPredicate, 16, // 2666: check predicate 16
2445 OPC_Decode, 168, 19, 154, 1, // 2668: decode to NMADD_S_MM using decoder 154
2446 // 2668: }
2447 8, 39, // 2673: case 0x8: {
2448 OPC_SwitchField, 6, 5, // 2675: switch Inst[10:6] {
2449 1, 7, // 2678: case 0x1: {
2450 OPC_CheckPredicate, 15, // 2680: check predicate 15
2451 OPC_Decode, 201, 16, 155, 1, // 2682: decode to LWXC1_MM using decoder 155
2452 // 2682: }
2453 2, 7, // 2687: case 0x2: {
2454 OPC_CheckPredicate, 15, // 2689: check predicate 15
2455 OPC_Decode, 191, 23, 155, 1, // 2691: decode to SWXC1_MM using decoder 155
2456 // 2691: }
2457 5, 7, // 2696: case 0x5: {
2458 OPC_CheckPredicate, 17, // 2698: check predicate 17
2459 OPC_Decode, 155, 16, 156, 1, // 2700: decode to LUXC1_MM using decoder 156
2460 // 2700: }
2461 6, 0, // 2705: case 0x6: {
2462 OPC_CheckPredicate, 17, // 2707: check predicate 17
2463 OPC_Decode, 152, 23, 156, 1, // 2709: decode to SUXC1_MM using decoder 156
2464 // 2709: }
2465 // 2709: } // switch Inst[10:6]
2466 // 2709: }
2467 9, 7, // 2714: case 0x9: {
2468 OPC_CheckPredicate, 18, // 2716: check predicate 18
2469 OPC_Decode, 239, 16, 157, 1, // 2718: decode to MADD_D32_MM using decoder 157
2470 // 2718: }
2471 10, 7, // 2723: case 0xa: {
2472 OPC_CheckPredicate, 18, // 2725: check predicate 18
2473 OPC_Decode, 165, 19, 157, 1, // 2727: decode to NMADD_D32_MM using decoder 157
2474 // 2727: }
2475 32, 64, // 2732: case 0x20: {
2476 OPC_SwitchField, 6, 5, // 2734: switch Inst[10:6] {
2477 0, 11, // 2737: case 0x0: {
2478 OPC_CheckPredicate, 15, // 2739: check predicate 15
2479 OPC_CheckField, 11, 2, 0, // 2741: check Inst[12:11] == 0x0
2480 OPC_Decode, 250, 17, 158, 1, // 2745: decode to MOVF_S_MM using decoder 158
2481 // 2745: }
2482 1, 11, // 2750: case 0x1: {
2483 OPC_CheckPredicate, 15, // 2752: check predicate 15
2484 OPC_CheckField, 11, 2, 0, // 2754: check Inst[12:11] == 0x0
2485 OPC_Decode, 143, 18, 158, 1, // 2758: decode to MOVT_S_MM using decoder 158
2486 // 2758: }
2487 6, 7, // 2763: case 0x6: {
2488 OPC_CheckPredicate, 1, // 2765: check predicate 1
2489 OPC_Decode, 138, 20, 159, 1, // 2767: decode to PREFX_MM using decoder 159
2490 // 2767: }
2491 8, 11, // 2772: case 0x8: {
2492 OPC_CheckPredicate, 19, // 2774: check predicate 19
2493 OPC_CheckField, 11, 2, 0, // 2776: check Inst[12:11] == 0x0
2494 OPC_Decode, 244, 17, 160, 1, // 2780: decode to MOVF_D32_MM using decoder 160
2495 // 2780: }
2496 9, 0, // 2785: case 0x9: {
2497 OPC_CheckPredicate, 19, // 2787: check predicate 19
2498 OPC_CheckField, 11, 2, 0, // 2789: check Inst[12:11] == 0x0
2499 OPC_Decode, 137, 18, 160, 1, // 2793: decode to MOVT_D32_MM using decoder 160
2500 // 2793: }
2501 // 2793: } // switch Inst[10:6]
2502 // 2793: }
2503 33, 7, // 2798: case 0x21: {
2504 OPC_CheckPredicate, 16, // 2800: check predicate 16
2505 OPC_Decode, 181, 18, 154, 1, // 2802: decode to MSUB_S_MM using decoder 154
2506 // 2802: }
2507 34, 7, // 2807: case 0x22: {
2508 OPC_CheckPredicate, 16, // 2809: check predicate 16
2509 OPC_Decode, 173, 19, 154, 1, // 2811: decode to NMSUB_S_MM using decoder 154
2510 // 2811: }
2511 41, 7, // 2816: case 0x29: {
2512 OPC_CheckPredicate, 18, // 2818: check predicate 18
2513 OPC_Decode, 173, 18, 157, 1, // 2820: decode to MSUB_D32_MM using decoder 157
2514 // 2820: }
2515 42, 7, // 2825: case 0x2a: {
2516 OPC_CheckPredicate, 18, // 2827: check predicate 18
2517 OPC_Decode, 170, 19, 157, 1, // 2829: decode to NMSUB_D32_MM using decoder 157
2518 // 2829: }
2519 48, 39, // 2834: case 0x30: {
2520 OPC_SwitchField, 6, 5, // 2836: switch Inst[10:6] {
2521 4, 7, // 2839: case 0x4: {
2522 OPC_CheckPredicate, 20, // 2841: check predicate 20
2523 OPC_Decode, 166, 13, 161, 1, // 2843: decode to FADD_D32_MM using decoder 161
2524 // 2843: }
2525 5, 7, // 2848: case 0x5: {
2526 OPC_CheckPredicate, 20, // 2850: check predicate 20
2527 OPC_Decode, 183, 14, 161, 1, // 2852: decode to FSUB_D32_MM using decoder 161
2528 // 2852: }
2529 6, 7, // 2857: case 0x6: {
2530 OPC_CheckPredicate, 20, // 2859: check predicate 20
2531 OPC_Decode, 139, 14, 161, 1, // 2861: decode to FMUL_D32_MM using decoder 161
2532 // 2861: }
2533 7, 0, // 2866: case 0x7: {
2534 OPC_CheckPredicate, 20, // 2868: check predicate 20
2535 OPC_Decode, 205, 13, 161, 1, // 2870: decode to FDIV_D32_MM using decoder 161
2536 // 2870: }
2537 // 2870: } // switch Inst[10:6]
2538 // 2870: }
2539 56, 39, // 2875: case 0x38: {
2540 OPC_SwitchField, 6, 4, // 2877: switch Inst[9:6] {
2541 0, 7, // 2880: case 0x0: {
2542 OPC_CheckPredicate, 15, // 2882: check predicate 15
2543 OPC_Decode, 134, 18, 162, 1, // 2884: decode to MOVN_I_S_MM using decoder 162
2544 // 2884: }
2545 1, 7, // 2889: case 0x1: {
2546 OPC_CheckPredicate, 15, // 2891: check predicate 15
2547 OPC_Decode, 155, 18, 162, 1, // 2893: decode to MOVZ_I_S_MM using decoder 162
2548 // 2893: }
2549 4, 7, // 2898: case 0x4: {
2550 OPC_CheckPredicate, 19, // 2900: check predicate 19
2551 OPC_Decode, 128, 18, 163, 1, // 2902: decode to MOVN_I_D32_MM using decoder 163
2552 // 2902: }
2553 5, 0, // 2907: case 0x5: {
2554 OPC_CheckPredicate, 19, // 2909: check predicate 19
2555 OPC_Decode, 149, 18, 163, 1, // 2911: decode to MOVZ_I_D32_MM using decoder 163
2556 // 2911: }
2557 // 2911: } // switch Inst[9:6]
2558 // 2911: }
2559 59, 129, 3, // 2916: case 0x3b: {
2560 OPC_SwitchField, 6, 7, // 2919: switch Inst[12:6] {
2561 0, 11, // 2922: case 0x0: {
2562 OPC_CheckPredicate, 21, // 2924: check predicate 21
2563 OPC_CheckField, 13, 3, 1, // 2926: check Inst[15:13] == 0x1
2564 OPC_Decode, 162, 17, 164, 1, // 2930: decode to MFC1_MM using decoder 164
2565 // 2930: }
2566 1, 11, // 2935: case 0x1: {
2567 OPC_CheckPredicate, 20, // 2937: check predicate 20
2568 OPC_CheckField, 13, 3, 1, // 2939: check Inst[15:13] == 0x1
2569 OPC_Decode, 128, 14, 165, 1, // 2943: decode to FMOV_D32_MM using decoder 165
2570 // 2943: }
2571 4, 21, // 2948: case 0x4: {
2572 OPC_SwitchField, 13, 3, // 2950: switch Inst[15:13] {
2573 0, 7, // 2953: case 0x0: {
2574 OPC_CheckPredicate, 22, // 2955: check predicate 22
2575 OPC_Decode, 227, 10, 166, 1, // 2957: decode to CVT_L_S_MM using decoder 166
2576 // 2957: }
2577 2, 0, // 2962: case 0x2: {
2578 OPC_CheckPredicate, 22, // 2964: check predicate 22
2579 OPC_Decode, 224, 10, 167, 1, // 2966: decode to CVT_L_D64_MM using decoder 167
2580 // 2966: }
2581 // 2966: } // switch Inst[15:13]
2582 // 2966: }
2583 5, 7, // 2971: case 0x5: {
2584 OPC_CheckPredicate, 15, // 2973: check predicate 15
2585 OPC_Decode, 248, 17, 168, 1, // 2975: decode to MOVF_I_MM using decoder 168
2586 // 2975: }
2587 8, 21, // 2980: case 0x8: {
2588 OPC_SwitchField, 13, 3, // 2982: switch Inst[15:13] {
2589 0, 7, // 2985: case 0x0: {
2590 OPC_CheckPredicate, 21, // 2987: check predicate 21
2591 OPC_Decode, 203, 20, 169, 1, // 2989: decode to RSQRT_S_MM using decoder 169
2592 // 2989: }
2593 2, 0, // 2994: case 0x2: {
2594 OPC_CheckPredicate, 20, // 2996: check predicate 20
2595 OPC_Decode, 199, 20, 165, 1, // 2998: decode to RSQRT_D32_MM using decoder 165
2596 // 2998: }
2597 // 2998: } // switch Inst[15:13]
2598 // 2998: }
2599 13, 21, // 3003: case 0xd: {
2600 OPC_SwitchField, 13, 3, // 3005: switch Inst[15:13] {
2601 0, 7, // 3008: case 0x0: {
2602 OPC_CheckPredicate, 21, // 3010: check predicate 21
2603 OPC_Decode, 163, 13, 169, 1, // 3012: decode to FABS_S_MM using decoder 169
2604 // 3012: }
2605 1, 0, // 3017: case 0x1: {
2606 OPC_CheckPredicate, 20, // 3019: check predicate 20
2607 OPC_Decode, 159, 13, 165, 1, // 3021: decode to FABS_D32_MM using decoder 165
2608 // 3021: }
2609 // 3021: } // switch Inst[15:13]
2610 // 3021: }
2611 32, 11, // 3026: case 0x20: {
2612 OPC_CheckPredicate, 21, // 3028: check predicate 21
2613 OPC_CheckField, 13, 3, 1, // 3030: check Inst[15:13] == 0x1
2614 OPC_Decode, 189, 18, 170, 1, // 3034: decode to MTC1_MM using decoder 170
2615 // 3034: }
2616 36, 21, // 3039: case 0x24: {
2617 OPC_SwitchField, 13, 3, // 3041: switch Inst[15:13] {
2618 0, 7, // 3044: case 0x0: {
2619 OPC_CheckPredicate, 21, // 3046: check predicate 21
2620 OPC_Decode, 248, 10, 169, 1, // 3048: decode to CVT_W_S_MM using decoder 169
2621 // 3048: }
2622 2, 0, // 3053: case 0x2: {
2623 OPC_CheckPredicate, 20, // 3055: check predicate 20
2624 OPC_Decode, 244, 10, 171, 1, // 3057: decode to CVT_W_D32_MM using decoder 171
2625 // 3057: }
2626 // 3057: } // switch Inst[15:13]
2627 // 3057: }
2628 37, 7, // 3062: case 0x25: {
2629 OPC_CheckPredicate, 15, // 3064: check predicate 15
2630 OPC_Decode, 141, 18, 168, 1, // 3066: decode to MOVT_I_MM using decoder 168
2631 // 3066: }
2632 40, 21, // 3071: case 0x28: {
2633 OPC_SwitchField, 13, 3, // 3073: switch Inst[15:13] {
2634 0, 7, // 3076: case 0x0: {
2635 OPC_CheckPredicate, 21, // 3078: check predicate 21
2636 OPC_Decode, 179, 14, 169, 1, // 3080: decode to FSQRT_S_MM using decoder 169
2637 // 3080: }
2638 2, 0, // 3085: case 0x2: {
2639 OPC_CheckPredicate, 20, // 3087: check predicate 20
2640 OPC_Decode, 175, 14, 165, 1, // 3089: decode to FSQRT_D32_MM using decoder 165
2641 // 3089: }
2642 // 3089: } // switch Inst[15:13]
2643 // 3089: }
2644 44, 39, // 3094: case 0x2c: {
2645 OPC_SwitchField, 13, 3, // 3096: switch Inst[15:13] {
2646 0, 7, // 3099: case 0x0: {
2647 OPC_CheckPredicate, 21, // 3101: check predicate 21
2648 OPC_Decode, 243, 13, 169, 1, // 3103: decode to FLOOR_W_S_MM using decoder 169
2649 // 3103: }
2650 1, 7, // 3108: case 0x1: {
2651 OPC_CheckPredicate, 21, // 3110: check predicate 21
2652 OPC_Decode, 162, 24, 169, 1, // 3112: decode to TRUNC_W_S_MM using decoder 169
2653 // 3112: }
2654 2, 7, // 3117: case 0x2: {
2655 OPC_CheckPredicate, 20, // 3119: check predicate 20
2656 OPC_Decode, 241, 13, 171, 1, // 3121: decode to FLOOR_W_MM using decoder 171
2657 // 3121: }
2658 3, 0, // 3126: case 0x3: {
2659 OPC_CheckPredicate, 20, // 3128: check predicate 20
2660 OPC_Decode, 160, 24, 171, 1, // 3130: decode to TRUNC_W_MM using decoder 171
2661 // 3130: }
2662 // 3130: } // switch Inst[15:13]
2663 // 3130: }
2664 45, 11, // 3135: case 0x2d: {
2665 OPC_CheckPredicate, 20, // 3137: check predicate 20
2666 OPC_CheckField, 13, 3, 1, // 3139: check Inst[15:13] == 0x1
2667 OPC_Decode, 148, 14, 165, 1, // 3143: decode to FNEG_D32_MM using decoder 165
2668 // 3143: }
2669 64, 21, // 3148: case 0x40: {
2670 OPC_SwitchField, 13, 3, // 3150: switch Inst[15:13] {
2671 0, 7, // 3153: case 0x0: {
2672 OPC_CheckPredicate, 21, // 3155: check predicate 21
2673 OPC_Decode, 175, 9, 172, 1, // 3157: decode to CFC1_MM using decoder 172
2674 // 3157: }
2675 1, 0, // 3162: case 0x1: {
2676 OPC_CheckPredicate, 20, // 3164: check predicate 20
2677 OPC_Decode, 171, 17, 173, 1, // 3166: decode to MFHC1_D32_MM using decoder 173
2678 // 3166: }
2679 // 3166: } // switch Inst[15:13]
2680 // 3166: }
2681 72, 21, // 3171: case 0x48: {
2682 OPC_SwitchField, 13, 3, // 3173: switch Inst[15:13] {
2683 0, 7, // 3176: case 0x0: {
2684 OPC_CheckPredicate, 21, // 3178: check predicate 21
2685 OPC_Decode, 164, 20, 169, 1, // 3180: decode to RECIP_S_MM using decoder 169
2686 // 3180: }
2687 2, 0, // 3185: case 0x2: {
2688 OPC_CheckPredicate, 20, // 3187: check predicate 20
2689 OPC_Decode, 160, 20, 165, 1, // 3189: decode to RECIP_D32_MM using decoder 165
2690 // 3189: }
2691 // 3189: } // switch Inst[15:13]
2692 // 3189: }
2693 77, 21, // 3194: case 0x4d: {
2694 OPC_SwitchField, 13, 3, // 3196: switch Inst[15:13] {
2695 0, 7, // 3199: case 0x0: {
2696 OPC_CheckPredicate, 20, // 3201: check predicate 20
2697 OPC_Decode, 214, 10, 174, 1, // 3203: decode to CVT_D32_S_MM using decoder 174
2698 // 3203: }
2699 1, 0, // 3208: case 0x1: {
2700 OPC_CheckPredicate, 20, // 3210: check predicate 20
2701 OPC_Decode, 216, 10, 174, 1, // 3212: decode to CVT_D32_W_MM using decoder 174
2702 // 3212: }
2703 // 3212: } // switch Inst[15:13]
2704 // 3212: }
2705 96, 21, // 3217: case 0x60: {
2706 OPC_SwitchField, 13, 3, // 3219: switch Inst[15:13] {
2707 0, 7, // 3222: case 0x0: {
2708 OPC_CheckPredicate, 21, // 3224: check predicate 21
2709 OPC_Decode, 210, 10, 175, 1, // 3226: decode to CTC1_MM using decoder 175
2710 // 3226: }
2711 1, 0, // 3231: case 0x1: {
2712 OPC_CheckPredicate, 20, // 3233: check predicate 20
2713 OPC_Decode, 198, 18, 176, 1, // 3235: decode to MTHC1_D32_MM using decoder 176
2714 // 3235: }
2715 // 3235: } // switch Inst[15:13]
2716 // 3235: }
2717 108, 39, // 3240: case 0x6c: {
2718 OPC_SwitchField, 13, 3, // 3242: switch Inst[15:13] {
2719 0, 7, // 3245: case 0x0: {
2720 OPC_CheckPredicate, 21, // 3247: check predicate 21
2721 OPC_Decode, 164, 9, 169, 1, // 3249: decode to CEIL_W_S_MM using decoder 169
2722 // 3249: }
2723 1, 7, // 3254: case 0x1: {
2724 OPC_CheckPredicate, 21, // 3256: check predicate 21
2725 OPC_Decode, 196, 20, 169, 1, // 3258: decode to ROUND_W_S_MM using decoder 169
2726 // 3258: }
2727 2, 7, // 3263: case 0x2: {
2728 OPC_CheckPredicate, 20, // 3265: check predicate 20
2729 OPC_Decode, 162, 9, 171, 1, // 3267: decode to CEIL_W_MM using decoder 171
2730 // 3267: }
2731 3, 0, // 3272: case 0x3: {
2732 OPC_CheckPredicate, 20, // 3274: check predicate 20
2733 OPC_Decode, 194, 20, 171, 1, // 3276: decode to ROUND_W_MM using decoder 171
2734 // 3276: }
2735 // 3276: } // switch Inst[15:13]
2736 // 3276: }
2737 109, 0, // 3281: case 0x6d: {
2738 OPC_SwitchField, 13, 3, // 3283: switch Inst[15:13] {
2739 0, 7, // 3286: case 0x0: {
2740 OPC_CheckPredicate, 20, // 3288: check predicate 20
2741 OPC_Decode, 233, 10, 171, 1, // 3290: decode to CVT_S_D32_MM using decoder 171
2742 // 3290: }
2743 1, 0, // 3295: case 0x1: {
2744 OPC_CheckPredicate, 21, // 3297: check predicate 21
2745 OPC_Decode, 241, 10, 169, 1, // 3299: decode to CVT_S_W_MM using decoder 169
2746 // 3299: }
2747 // 3299: } // switch Inst[15:13]
2748 // 3299: }
2749 // 3299: } // switch Inst[12:6]
2750 // 3299: }
2751 60, 0, // 3304: case 0x3c: {
2752 OPC_SwitchField, 6, 7, // 3306: switch Inst[12:6] {
2753 0, 7, // 3309: case 0x0: {
2754 OPC_CheckPredicate, 15, // 3311: check predicate 15
2755 OPC_Decode, 133, 11, 177, 1, // 3313: decode to C_F_S_MM using decoder 177
2756 // 3313: }
2757 1, 7, // 3318: case 0x1: {
2758 OPC_CheckPredicate, 15, // 3320: check predicate 15
2759 OPC_Decode, 217, 11, 177, 1, // 3322: decode to C_UN_S_MM using decoder 177
2760 // 3322: }
2761 2, 7, // 3327: case 0x2: {
2762 OPC_CheckPredicate, 15, // 3329: check predicate 15
2763 OPC_Decode, 255, 10, 177, 1, // 3331: decode to C_EQ_S_MM using decoder 177
2764 // 3331: }
2765 3, 7, // 3336: case 0x3: {
2766 OPC_CheckPredicate, 15, // 3338: check predicate 15
2767 OPC_Decode, 199, 11, 177, 1, // 3340: decode to C_UEQ_S_MM using decoder 177
2768 // 3340: }
2769 4, 7, // 3345: case 0x4: {
2770 OPC_CheckPredicate, 15, // 3347: check predicate 15
2771 OPC_Decode, 181, 11, 177, 1, // 3349: decode to C_OLT_S_MM using decoder 177
2772 // 3349: }
2773 5, 7, // 3354: case 0x5: {
2774 OPC_CheckPredicate, 15, // 3356: check predicate 15
2775 OPC_Decode, 211, 11, 177, 1, // 3358: decode to C_ULT_S_MM using decoder 177
2776 // 3358: }
2777 6, 7, // 3363: case 0x6: {
2778 OPC_CheckPredicate, 15, // 3365: check predicate 15
2779 OPC_Decode, 175, 11, 177, 1, // 3367: decode to C_OLE_S_MM using decoder 177
2780 // 3367: }
2781 7, 7, // 3372: case 0x7: {
2782 OPC_CheckPredicate, 15, // 3374: check predicate 15
2783 OPC_Decode, 205, 11, 177, 1, // 3376: decode to C_ULE_S_MM using decoder 177
2784 // 3376: }
2785 8, 7, // 3381: case 0x8: {
2786 OPC_CheckPredicate, 15, // 3383: check predicate 15
2787 OPC_Decode, 193, 11, 177, 1, // 3385: decode to C_SF_S_MM using decoder 177
2788 // 3385: }
2789 9, 7, // 3390: case 0x9: {
2790 OPC_CheckPredicate, 15, // 3392: check predicate 15
2791 OPC_Decode, 157, 11, 177, 1, // 3394: decode to C_NGLE_S_MM using decoder 177
2792 // 3394: }
2793 10, 7, // 3399: case 0xa: {
2794 OPC_CheckPredicate, 15, // 3401: check predicate 15
2795 OPC_Decode, 187, 11, 177, 1, // 3403: decode to C_SEQ_S_MM using decoder 177
2796 // 3403: }
2797 11, 7, // 3408: case 0xb: {
2798 OPC_CheckPredicate, 15, // 3410: check predicate 15
2799 OPC_Decode, 163, 11, 177, 1, // 3412: decode to C_NGL_S_MM using decoder 177
2800 // 3412: }
2801 12, 7, // 3417: case 0xc: {
2802 OPC_CheckPredicate, 15, // 3419: check predicate 15
2803 OPC_Decode, 145, 11, 177, 1, // 3421: decode to C_LT_S_MM using decoder 177
2804 // 3421: }
2805 13, 7, // 3426: case 0xd: {
2806 OPC_CheckPredicate, 15, // 3428: check predicate 15
2807 OPC_Decode, 151, 11, 177, 1, // 3430: decode to C_NGE_S_MM using decoder 177
2808 // 3430: }
2809 14, 7, // 3435: case 0xe: {
2810 OPC_CheckPredicate, 15, // 3437: check predicate 15
2811 OPC_Decode, 139, 11, 177, 1, // 3439: decode to C_LE_S_MM using decoder 177
2812 // 3439: }
2813 15, 7, // 3444: case 0xf: {
2814 OPC_CheckPredicate, 15, // 3446: check predicate 15
2815 OPC_Decode, 169, 11, 177, 1, // 3448: decode to C_NGT_S_MM using decoder 177
2816 // 3448: }
2817 16, 7, // 3453: case 0x10: {
2818 OPC_CheckPredicate, 19, // 3455: check predicate 19
2819 OPC_Decode, 129, 11, 178, 1, // 3457: decode to C_F_D32_MM using decoder 178
2820 // 3457: }
2821 17, 7, // 3462: case 0x11: {
2822 OPC_CheckPredicate, 19, // 3464: check predicate 19
2823 OPC_Decode, 213, 11, 178, 1, // 3466: decode to C_UN_D32_MM using decoder 178
2824 // 3466: }
2825 18, 7, // 3471: case 0x12: {
2826 OPC_CheckPredicate, 19, // 3473: check predicate 19
2827 OPC_Decode, 251, 10, 178, 1, // 3475: decode to C_EQ_D32_MM using decoder 178
2828 // 3475: }
2829 19, 7, // 3480: case 0x13: {
2830 OPC_CheckPredicate, 19, // 3482: check predicate 19
2831 OPC_Decode, 195, 11, 178, 1, // 3484: decode to C_UEQ_D32_MM using decoder 178
2832 // 3484: }
2833 20, 7, // 3489: case 0x14: {
2834 OPC_CheckPredicate, 19, // 3491: check predicate 19
2835 OPC_Decode, 177, 11, 178, 1, // 3493: decode to C_OLT_D32_MM using decoder 178
2836 // 3493: }
2837 21, 7, // 3498: case 0x15: {
2838 OPC_CheckPredicate, 19, // 3500: check predicate 19
2839 OPC_Decode, 207, 11, 178, 1, // 3502: decode to C_ULT_D32_MM using decoder 178
2840 // 3502: }
2841 22, 7, // 3507: case 0x16: {
2842 OPC_CheckPredicate, 19, // 3509: check predicate 19
2843 OPC_Decode, 171, 11, 178, 1, // 3511: decode to C_OLE_D32_MM using decoder 178
2844 // 3511: }
2845 23, 7, // 3516: case 0x17: {
2846 OPC_CheckPredicate, 19, // 3518: check predicate 19
2847 OPC_Decode, 201, 11, 178, 1, // 3520: decode to C_ULE_D32_MM using decoder 178
2848 // 3520: }
2849 24, 7, // 3525: case 0x18: {
2850 OPC_CheckPredicate, 19, // 3527: check predicate 19
2851 OPC_Decode, 189, 11, 178, 1, // 3529: decode to C_SF_D32_MM using decoder 178
2852 // 3529: }
2853 25, 7, // 3534: case 0x19: {
2854 OPC_CheckPredicate, 19, // 3536: check predicate 19
2855 OPC_Decode, 153, 11, 178, 1, // 3538: decode to C_NGLE_D32_MM using decoder 178
2856 // 3538: }
2857 26, 7, // 3543: case 0x1a: {
2858 OPC_CheckPredicate, 19, // 3545: check predicate 19
2859 OPC_Decode, 183, 11, 178, 1, // 3547: decode to C_SEQ_D32_MM using decoder 178
2860 // 3547: }
2861 27, 7, // 3552: case 0x1b: {
2862 OPC_CheckPredicate, 19, // 3554: check predicate 19
2863 OPC_Decode, 159, 11, 178, 1, // 3556: decode to C_NGL_D32_MM using decoder 178
2864 // 3556: }
2865 28, 7, // 3561: case 0x1c: {
2866 OPC_CheckPredicate, 19, // 3563: check predicate 19
2867 OPC_Decode, 141, 11, 178, 1, // 3565: decode to C_LT_D32_MM using decoder 178
2868 // 3565: }
2869 29, 7, // 3570: case 0x1d: {
2870 OPC_CheckPredicate, 19, // 3572: check predicate 19
2871 OPC_Decode, 147, 11, 178, 1, // 3574: decode to C_NGE_D32_MM using decoder 178
2872 // 3574: }
2873 30, 7, // 3579: case 0x1e: {
2874 OPC_CheckPredicate, 19, // 3581: check predicate 19
2875 OPC_Decode, 135, 11, 178, 1, // 3583: decode to C_LE_D32_MM using decoder 178
2876 // 3583: }
2877 31, 0, // 3588: case 0x1f: {
2878 OPC_CheckPredicate, 19, // 3590: check predicate 19
2879 OPC_Decode, 165, 11, 178, 1, // 3592: decode to C_NGT_D32_MM using decoder 178
2880 // 3592: }
2881 // 3592: } // switch Inst[12:6]
2882 // 3592: }
2883 // 3592: } // switch Inst[5:0]
2884 // 3592: }
2885 22, 30, // 3597: case 0x16: {
2886 OPC_SwitchField, 0, 11, // 3599: switch Inst[10:0] {
2887 197, 1, 6, // 3602: case 0xc5: {
2888 OPC_CheckPredicate, 10, // 3605: check predicate 10
2889 OPC_Decode, 235, 9, 97, // 3607: decode to CMPGU_EQ_QB_MM using decoder 97
2890 // 3607: }
2891 133, 2, 6, // 3611: case 0x105: {
2892 OPC_CheckPredicate, 10, // 3614: check predicate 10
2893 OPC_Decode, 239, 9, 97, // 3616: decode to CMPGU_LT_QB_MM using decoder 97
2894 // 3616: }
2895 197, 2, 0, // 3620: case 0x145: {
2896 OPC_CheckPredicate, 10, // 3623: check predicate 10
2897 OPC_Decode, 237, 9, 97, // 3625: decode to CMPGU_LE_QB_MM using decoder 97
2898 // 3625: }
2899 // 3625: } // switch Inst[10:0]
2900 // 3625: }
2901 24, 229, 1, // 3629: case 0x18: {
2902 OPC_SwitchField, 12, 4, // 3632: switch Inst[15:12] {
2903 0, 7, // 3635: case 0x0: {
2904 OPC_CheckPredicate, 1, // 3637: check predicate 1
2905 OPC_Decode, 181, 16, 179, 1, // 3639: decode to LWL_MM using decoder 179
2906 // 3639: }
2907 1, 7, // 3644: case 0x1: {
2908 OPC_CheckPredicate, 1, // 3646: check predicate 1
2909 OPC_Decode, 194, 16, 179, 1, // 3648: decode to LWR_MM using decoder 179
2910 // 3648: }
2911 2, 7, // 3653: case 0x2: {
2912 OPC_CheckPredicate, 1, // 3655: check predicate 1
2913 OPC_Decode, 139, 20, 145, 1, // 3657: decode to PREF_MM using decoder 145
2914 // 3657: }
2915 3, 7, // 3662: case 0x3: {
2916 OPC_CheckPredicate, 1, // 3664: check predicate 1
2917 OPC_Decode, 143, 16, 180, 1, // 3666: decode to LL_MM using decoder 180
2918 // 3666: }
2919 6, 75, // 3671: case 0x6: {
2920 OPC_SwitchField, 9, 3, // 3673: switch Inst[11:9] {
2921 0, 7, // 3676: case 0x0: {
2922 OPC_CheckPredicate, 23, // 3678: check predicate 23
2923 OPC_Decode, 206, 15, 181, 1, // 3680: decode to LBuE_MM using decoder 181
2924 // 3680: }
2925 1, 7, // 3685: case 0x1: {
2926 OPC_CheckPredicate, 23, // 3687: check predicate 23
2927 OPC_Decode, 129, 16, 182, 1, // 3689: decode to LHuE_MM using decoder 182
2928 // 3689: }
2929 2, 7, // 3694: case 0x2: {
2930 OPC_CheckPredicate, 24, // 3696: check predicate 24
2931 OPC_Decode, 180, 16, 183, 1, // 3698: decode to LWLE_MM using decoder 183
2932 // 3698: }
2933 3, 7, // 3703: case 0x3: {
2934 OPC_CheckPredicate, 24, // 3705: check predicate 24
2935 OPC_Decode, 193, 16, 183, 1, // 3707: decode to LWRE_MM using decoder 183
2936 // 3707: }
2937 4, 7, // 3712: case 0x4: {
2938 OPC_CheckPredicate, 23, // 3714: check predicate 23
2939 OPC_Decode, 187, 15, 181, 1, // 3716: decode to LBE_MM using decoder 181
2940 // 3716: }
2941 5, 7, // 3721: case 0x5: {
2942 OPC_CheckPredicate, 23, // 3723: check predicate 23
2943 OPC_Decode, 238, 15, 182, 1, // 3725: decode to LHE_MM using decoder 182
2944 // 3725: }
2945 6, 7, // 3730: case 0x6: {
2946 OPC_CheckPredicate, 23, // 3732: check predicate 23
2947 OPC_Decode, 141, 16, 182, 1, // 3734: decode to LLE_MM using decoder 182
2948 // 3734: }
2949 7, 0, // 3739: case 0x7: {
2950 OPC_CheckPredicate, 23, // 3741: check predicate 23
2951 OPC_Decode, 173, 16, 182, 1, // 3743: decode to LWE_MM using decoder 182
2952 // 3743: }
2953 // 3743: } // switch Inst[11:9]
2954 // 3743: }
2955 8, 7, // 3748: case 0x8: {
2956 OPC_CheckPredicate, 1, // 3750: check predicate 1
2957 OPC_Decode, 175, 23, 180, 1, // 3752: decode to SWL_MM using decoder 180
2958 // 3752: }
2959 9, 7, // 3757: case 0x9: {
2960 OPC_CheckPredicate, 1, // 3759: check predicate 1
2961 OPC_Decode, 186, 23, 180, 1, // 3761: decode to SWR_MM using decoder 180
2962 // 3761: }
2963 10, 75, // 3766: case 0xa: {
2964 OPC_SwitchField, 9, 3, // 3768: switch Inst[11:9] {
2965 0, 7, // 3771: case 0x0: {
2966 OPC_CheckPredicate, 24, // 3773: check predicate 24
2967 OPC_Decode, 174, 23, 182, 1, // 3775: decode to SWLE_MM using decoder 182
2968 // 3775: }
2969 1, 7, // 3780: case 0x1: {
2970 OPC_CheckPredicate, 24, // 3782: check predicate 24
2971 OPC_Decode, 185, 23, 182, 1, // 3784: decode to SWRE_MM using decoder 182
2972 // 3784: }
2973 2, 7, // 3789: case 0x2: {
2974 OPC_CheckPredicate, 23, // 3791: check predicate 23
2975 OPC_Decode, 137, 20, 184, 1, // 3793: decode to PREFE_MM using decoder 184
2976 // 3793: }
2977 3, 7, // 3798: case 0x3: {
2978 OPC_CheckPredicate, 23, // 3800: check predicate 23
2979 OPC_Decode, 150, 9, 184, 1, // 3802: decode to CACHEE_MM using decoder 184
2980 // 3802: }
2981 4, 7, // 3807: case 0x4: {
2982 OPC_CheckPredicate, 23, // 3809: check predicate 23
2983 OPC_Decode, 224, 20, 182, 1, // 3811: decode to SBE_MM using decoder 182
2984 // 3811: }
2985 5, 7, // 3816: case 0x5: {
2986 OPC_CheckPredicate, 23, // 3818: check predicate 23
2987 OPC_Decode, 174, 21, 182, 1, // 3820: decode to SHE_MM using decoder 182
2988 // 3820: }
2989 6, 7, // 3825: case 0x6: {
2990 OPC_CheckPredicate, 23, // 3827: check predicate 23
2991 OPC_Decode, 237, 20, 185, 1, // 3829: decode to SCE_MM using decoder 185
2992 // 3829: }
2993 7, 0, // 3834: case 0x7: {
2994 OPC_CheckPredicate, 23, // 3836: check predicate 23
2995 OPC_Decode, 168, 23, 182, 1, // 3838: decode to SWE_MM using decoder 182
2996 // 3838: }
2997 // 3838: } // switch Inst[11:9]
2998 // 3838: }
2999 11, 7, // 3843: case 0xb: {
3000 OPC_CheckPredicate, 1, // 3845: check predicate 1
3001 OPC_Decode, 239, 20, 186, 1, // 3847: decode to SC_MM using decoder 186
3002 // 3847: }
3003 14, 0, // 3852: case 0xe: {
3004 OPC_CheckPredicate, 1, // 3854: check predicate 1
3005 OPC_Decode, 198, 16, 180, 1, // 3856: decode to LWU_MM using decoder 180
3006 // 3856: }
3007 // 3856: } // switch Inst[15:12]
3008 // 3856: }
3009 28, 7, // 3861: case 0x1c: {
3010 OPC_CheckPredicate, 1, // 3863: check predicate 1
3011 OPC_Decode, 205, 24, 153, 1, // 3865: decode to XORi_MM using decoder 153
3012 // 3865: }
3013 29, 7, // 3870: case 0x1d: {
3014 OPC_CheckPredicate, 1, // 3872: check predicate 1
3015 OPC_Decode, 150, 15, 187, 1, // 3874: decode to JALS_MM using decoder 187
3016 // 3874: }
3017 30, 7, // 3879: case 0x1e: {
3018 OPC_CheckPredicate, 1, // 3881: check predicate 1
3019 OPC_Decode, 165, 6, 188, 1, // 3883: decode to ADDIUPC_MM using decoder 188
3020 // 3883: }
3021 36, 7, // 3888: case 0x24: {
3022 OPC_CheckPredicate, 2, // 3890: check predicate 2
3023 OPC_Decode, 145, 22, 141, 1, // 3892: decode to SLTi_MM using decoder 141
3024 // 3892: }
3025 37, 7, // 3897: case 0x25: {
3026 OPC_CheckPredicate, 1, // 3899: check predicate 1
3027 OPC_Decode, 241, 7, 189, 1, // 3901: decode to BEQ_MM using decoder 189
3028 // 3901: }
3029 38, 7, // 3906: case 0x26: {
3030 OPC_CheckPredicate, 21, // 3908: check predicate 21
3031 OPC_Decode, 160, 23, 190, 1, // 3910: decode to SWC1_MM using decoder 190
3032 // 3910: }
3033 39, 7, // 3915: case 0x27: {
3034 OPC_CheckPredicate, 21, // 3917: check predicate 21
3035 OPC_Decode, 165, 16, 190, 1, // 3919: decode to LWC1_MM using decoder 190
3036 // 3919: }
3037 44, 7, // 3924: case 0x2c: {
3038 OPC_CheckPredicate, 2, // 3926: check predicate 2
3039 OPC_Decode, 148, 22, 141, 1, // 3928: decode to SLTiu_MM using decoder 141
3040 // 3928: }
3041 45, 7, // 3933: case 0x2d: {
3042 OPC_CheckPredicate, 1, // 3935: check predicate 1
3043 OPC_Decode, 228, 8, 189, 1, // 3937: decode to BNE_MM using decoder 189
3044 // 3937: }
3045 46, 7, // 3942: case 0x2e: {
3046 OPC_CheckPredicate, 20, // 3944: check predicate 20
3047 OPC_Decode, 255, 20, 191, 1, // 3946: decode to SDC1_MM_D32 using decoder 191
3048 // 3946: }
3049 47, 7, // 3951: case 0x2f: {
3050 OPC_CheckPredicate, 20, // 3953: check predicate 20
3051 OPC_Decode, 212, 15, 191, 1, // 3955: decode to LDC1_MM_D32 using decoder 191
3052 // 3955: }
3053 52, 7, // 3960: case 0x34: {
3054 OPC_CheckPredicate, 1, // 3962: check predicate 1
3055 OPC_Decode, 141, 7, 153, 1, // 3964: decode to ANDi_MM using decoder 153
3056 // 3964: }
3057 53, 7, // 3969: case 0x35: {
3058 OPC_CheckPredicate, 1, // 3971: check predicate 1
3059 OPC_Decode, 174, 15, 187, 1, // 3973: decode to J_MM using decoder 187
3060 // 3973: }
3061 60, 7, // 3978: case 0x3c: {
3062 OPC_CheckPredicate, 1, // 3980: check predicate 1
3063 OPC_Decode, 152, 15, 192, 1, // 3982: decode to JALX_MM using decoder 192
3064 // 3982: }
3065 61, 7, // 3987: case 0x3d: {
3066 OPC_CheckPredicate, 1, // 3989: check predicate 1
3067 OPC_Decode, 153, 15, 187, 1, // 3991: decode to JAL_MM using decoder 187
3068 // 3991: }
3069 62, 7, // 3996: case 0x3e: {
3070 OPC_CheckPredicate, 2, // 3998: check predicate 2
3071 OPC_Decode, 194, 23, 142, 1, // 4000: decode to SW_MM using decoder 142
3072 // 4000: }
3073 63, 0, // 4005: case 0x3f: {
3074 OPC_CheckPredicate, 2, // 4007: check predicate 2
3075 OPC_Decode, 207, 16, 142, 1, // 4009: decode to LW_MM using decoder 142
3076 // 4009: }
3077 // 4009: } // switch Inst[31:26]
3078};
3079static const uint8_t DecoderTableMicroMipsDSP32[21] = {
3080 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
3081 62, 7, // 3: case 0x3e: {
3082 OPC_CheckPredicate, 10, // 5: check predicate 10
3083 OPC_Decode, 166, 23, 193, 1, // 7: decode to SWDSP_MM using decoder 193
3084 // 7: }
3085 63, 0, // 12: case 0x3f: {
3086 OPC_CheckPredicate, 10, // 14: check predicate 10
3087 OPC_Decode, 171, 16, 193, 1, // 16: decode to LWDSP_MM using decoder 193
3088 // 16: }
3089 // 16: } // switch Inst[31:26]
3090};
3091static const uint8_t DecoderTableMicroMipsFP6432[210] = {
3092 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
3093 21, 186, 1, // 3: case 0x15: {
3094 OPC_SwitchField, 0, 11, // 6: switch Inst[10:0] {
3095 59, 30, // 9: case 0x3b: {
3096 OPC_SwitchField, 11, 5, // 11: switch Inst[15:11] {
3097 5, 7, // 14: case 0x5: {
3098 OPC_CheckPredicate, 22, // 16: check predicate 22
3099 OPC_Decode, 188, 18, 194, 1, // 18: decode to MTC1_D64_MM using decoder 194
3100 // 18: }
3101 6, 7, // 23: case 0x6: {
3102 OPC_CheckPredicate, 22, // 25: check predicate 22
3103 OPC_Decode, 173, 17, 195, 1, // 27: decode to MFHC1_D64_MM using decoder 195
3104 // 27: }
3105 7, 0, // 32: case 0x7: {
3106 OPC_CheckPredicate, 22, // 34: check predicate 22
3107 OPC_Decode, 200, 18, 196, 1, // 36: decode to MTHC1_D64_MM using decoder 196
3108 // 36: }
3109 // 36: } // switch Inst[15:11]
3110 // 36: }
3111 123, 11, // 41: case 0x7b: {
3112 OPC_CheckPredicate, 22, // 43: check predicate 22
3113 OPC_CheckField, 11, 5, 4, // 45: check Inst[15:11] == 0x4
3114 OPC_Decode, 130, 14, 167, 1, // 49: decode to FMOV_D64_MM using decoder 167
3115 // 49: }
3116 176, 2, 7, // 54: case 0x130: {
3117 OPC_CheckPredicate, 22, // 57: check predicate 22
3118 OPC_Decode, 168, 13, 197, 1, // 59: decode to FADD_D64_MM using decoder 197
3119 // 59: }
3120 187, 2, 11, // 64: case 0x13b: {
3121 OPC_CheckPredicate, 22, // 67: check predicate 22
3122 OPC_CheckField, 11, 5, 9, // 69: check Inst[15:11] == 0x9
3123 OPC_Decode, 246, 10, 198, 1, // 73: decode to CVT_W_D64_MM using decoder 198
3124 // 73: }
3125 240, 2, 7, // 78: case 0x170: {
3126 OPC_CheckPredicate, 22, // 81: check predicate 22
3127 OPC_Decode, 185, 14, 197, 1, // 83: decode to FSUB_D64_MM using decoder 197
3128 // 83: }
3129 176, 3, 7, // 88: case 0x1b0: {
3130 OPC_CheckPredicate, 22, // 91: check predicate 22
3131 OPC_Decode, 141, 14, 197, 1, // 93: decode to FMUL_D64_MM using decoder 197
3132 // 93: }
3133 240, 3, 7, // 98: case 0x1f0: {
3134 OPC_CheckPredicate, 22, // 101: check predicate 22
3135 OPC_Decode, 207, 13, 197, 1, // 103: decode to FDIV_D64_MM using decoder 197
3136 // 103: }
3137 187, 4, 30, // 108: case 0x23b: {
3138 OPC_SwitchField, 11, 5, // 111: switch Inst[15:11] {
3139 8, 7, // 114: case 0x8: {
3140 OPC_CheckPredicate, 22, // 116: check predicate 22
3141 OPC_Decode, 201, 20, 167, 1, // 118: decode to RSQRT_D64_MM using decoder 167
3142 // 118: }
3143 9, 7, // 123: case 0x9: {
3144 OPC_CheckPredicate, 22, // 125: check predicate 22
3145 OPC_Decode, 177, 14, 167, 1, // 127: decode to FSQRT_D64_MM using decoder 167
3146 // 127: }
3147 10, 0, // 132: case 0xa: {
3148 OPC_CheckPredicate, 22, // 134: check predicate 22
3149 OPC_Decode, 162, 20, 167, 1, // 136: decode to RECIP_D64_MM using decoder 167
3150 // 136: }
3151 // 136: } // switch Inst[15:11]
3152 // 136: }
3153 251, 6, 0, // 141: case 0x37b: {
3154 OPC_SwitchField, 11, 5, // 144: switch Inst[15:11] {
3155 2, 7, // 147: case 0x2: {
3156 OPC_CheckPredicate, 22, // 149: check predicate 22
3157 OPC_Decode, 219, 10, 166, 1, // 151: decode to CVT_D64_S_MM using decoder 166
3158 // 151: }
3159 3, 7, // 156: case 0x3: {
3160 OPC_CheckPredicate, 22, // 158: check predicate 22
3161 OPC_Decode, 235, 10, 198, 1, // 160: decode to CVT_S_D64_MM using decoder 198
3162 // 160: }
3163 4, 7, // 165: case 0x4: {
3164 OPC_CheckPredicate, 22, // 167: check predicate 22
3165 OPC_Decode, 161, 13, 167, 1, // 169: decode to FABS_D64_MM using decoder 167
3166 // 169: }
3167 5, 7, // 174: case 0x5: {
3168 OPC_CheckPredicate, 22, // 176: check predicate 22
3169 OPC_Decode, 150, 14, 167, 1, // 178: decode to FNEG_D64_MM using decoder 167
3170 // 178: }
3171 6, 0, // 183: case 0x6: {
3172 OPC_CheckPredicate, 22, // 185: check predicate 22
3173 OPC_Decode, 221, 10, 166, 1, // 187: decode to CVT_D64_W_MM using decoder 166
3174 // 187: }
3175 // 187: } // switch Inst[15:11]
3176 // 187: }
3177 // 187: } // switch Inst[10:0]
3178 // 187: }
3179 46, 7, // 192: case 0x2e: {
3180 OPC_CheckPredicate, 25, // 194: check predicate 25
3181 OPC_Decode, 254, 20, 191, 1, // 196: decode to SDC1_D64_MMR6 using decoder 191
3182 // 196: }
3183 47, 0, // 201: case 0x2f: {
3184 OPC_CheckPredicate, 25, // 203: check predicate 25
3185 OPC_Decode, 211, 15, 191, 1, // 205: decode to LDC1_D64_MMR6 using decoder 191
3186 // 205: }
3187 // 205: } // switch Inst[31:26]
3188};
3189static const uint8_t DecoderTableMicroMipsR632[1993] = {
3190 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
3191 0, 159, 5, // 3: case 0x0: {
3192 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
3193 0, 69, // 9: case 0x0: {
3194 OPC_SwitchField, 6, 5, // 11: switch Inst[10:6] {
3195 0, 35, // 14: case 0x0: {
3196 OPC_Scope, 27, // 16: try {
3197 OPC_SwitchField, 11, 15, // 18: switch Inst[25:11] {
3198 1, 6, // 21: case 0x1: {
3199 OPC_CheckPredicate, 3, // 23: check predicate 3
3200 OPC_Decode, 212, 22, 10, // 25: decode to SSNOP_MMR6 using decoder 10
3201 // 25: }
3202 3, 6, // 29: case 0x3: {
3203 OPC_CheckPredicate, 3, // 31: check predicate 3
3204 OPC_Decode, 237, 12, 10, // 33: decode to EHB_MMR6 using decoder 10
3205 // 33: }
3206 5, 0, // 37: case 0x5: {
3207 OPC_CheckPredicate, 3, // 39: check predicate 3
3208 OPC_Decode, 208, 19, 10, // 41: decode to PAUSE_MMR6 using decoder 10
3209 // 41: }
3210 // 41: } // switch Inst[25:11]
3211 // 41: } else try {
3212 OPC_CheckPredicate, 3, // 45: check predicate 3
3213 OPC_Decode, 133, 22, 95, // 47: decode to SLL_MMR6 using decoder 95
3214 // 47: }
3215 // 47: }
3216 5, 6, // 51: case 0x5: {
3217 OPC_CheckPredicate, 3, // 53: check predicate 3
3218 OPC_Decode, 151, 21, 98, // 55: decode to SELEQZ_MMR6 using decoder 98
3219 // 55: }
3220 6, 6, // 59: case 0x6: {
3221 OPC_CheckPredicate, 3, // 61: check predicate 3
3222 OPC_Decode, 158, 21, 98, // 63: decode to SELNEZ_MMR6 using decoder 98
3223 // 63: }
3224 7, 0, // 67: case 0x7: {
3225 OPC_CheckPredicate, 3, // 69: check predicate 3
3226 OPC_CheckField, 14, 2, 0, // 71: check Inst[15:14] == 0x0
3227 OPC_Decode, 155, 20, 199, 1, // 75: decode to RDHWR_MMR6 using decoder 199
3228 // 75: }
3229 // 75: } // switch Inst[10:6]
3230 // 75: }
3231 7, 6, // 80: case 0x7: {
3232 OPC_CheckPredicate, 3, // 82: check predicate 3
3233 OPC_Decode, 246, 8, 99, // 84: decode to BREAK_MMR6 using decoder 99
3234 // 84: }
3235 12, 6, // 88: case 0xc: {
3236 OPC_CheckPredicate, 3, // 90: check predicate 3
3237 OPC_Decode, 131, 15, 100, // 92: decode to INS_MMR6 using decoder 100
3238 // 92: }
3239 15, 11, // 96: case 0xf: {
3240 OPC_CheckPredicate, 3, // 98: check predicate 3
3241 OPC_CheckField, 6, 3, 0, // 100: check Inst[8:6] == 0x0
3242 OPC_Decode, 148, 16, 200, 1, // 104: decode to LSA_MMR6 using decoder 200
3243 // 104: }
3244 16, 79, // 109: case 0x10: {
3245 OPC_SwitchField, 6, 5, // 111: switch Inst[10:6] {
3246 1, 10, // 114: case 0x1: {
3247 OPC_CheckPredicate, 3, // 116: check predicate 3
3248 OPC_CheckField, 16, 5, 0, // 118: check Inst[20:16] == 0x0
3249 OPC_Decode, 225, 9, 89, // 122: decode to CLZ_MMR6 using decoder 89
3250 // 122: }
3251 4, 6, // 126: case 0x4: {
3252 OPC_CheckPredicate, 3, // 128: check predicate 3
3253 OPC_Decode, 236, 6, 98, // 130: decode to ADD_MMR6 using decoder 98
3254 // 130: }
3255 5, 6, // 134: case 0x5: {
3256 OPC_CheckPredicate, 3, // 136: check predicate 3
3257 OPC_Decode, 212, 6, 98, // 138: decode to ADDU_MMR6 using decoder 98
3258 // 138: }
3259 6, 6, // 142: case 0x6: {
3260 OPC_CheckPredicate, 3, // 144: check predicate 3
3261 OPC_Decode, 144, 23, 98, // 146: decode to SUB_MMR6 using decoder 98
3262 // 146: }
3263 7, 6, // 150: case 0x7: {
3264 OPC_CheckPredicate, 3, // 152: check predicate 3
3265 OPC_Decode, 254, 22, 98, // 154: decode to SUBU_MMR6 using decoder 98
3266 // 154: }
3267 9, 6, // 158: case 0x9: {
3268 OPC_CheckPredicate, 3, // 160: check predicate 3
3269 OPC_Decode, 136, 7, 98, // 162: decode to AND_MMR6 using decoder 98
3270 // 162: }
3271 10, 6, // 166: case 0xa: {
3272 OPC_CheckPredicate, 3, // 168: check predicate 3
3273 OPC_Decode, 197, 19, 98, // 170: decode to OR_MMR6 using decoder 98
3274 // 170: }
3275 11, 6, // 174: case 0xb: {
3276 OPC_CheckPredicate, 3, // 176: check predicate 3
3277 OPC_Decode, 180, 19, 98, // 178: decode to NOR_MMR6 using decoder 98
3278 // 178: }
3279 12, 0, // 182: case 0xc: {
3280 OPC_CheckPredicate, 3, // 184: check predicate 3
3281 OPC_Decode, 200, 24, 98, // 186: decode to XOR_MMR6 using decoder 98
3282 // 186: }
3283 // 186: } // switch Inst[10:6]
3284 // 186: }
3285 24, 67, // 190: case 0x18: {
3286 OPC_SwitchField, 6, 5, // 192: switch Inst[10:6] {
3287 0, 6, // 195: case 0x0: {
3288 OPC_CheckPredicate, 3, // 197: check predicate 3
3289 OPC_Decode, 142, 19, 98, // 199: decode to MUL_MMR6 using decoder 98
3290 // 199: }
3291 1, 6, // 203: case 0x1: {
3292 OPC_CheckPredicate, 3, // 205: check predicate 3
3293 OPC_Decode, 227, 18, 98, // 207: decode to MUH_MMR6 using decoder 98
3294 // 207: }
3295 2, 6, // 211: case 0x2: {
3296 OPC_CheckPredicate, 3, // 213: check predicate 3
3297 OPC_Decode, 135, 19, 98, // 215: decode to MULU_MMR6 using decoder 98
3298 // 215: }
3299 3, 6, // 219: case 0x3: {
3300 OPC_CheckPredicate, 3, // 221: check predicate 3
3301 OPC_Decode, 225, 18, 98, // 223: decode to MUHU_MMR6 using decoder 98
3302 // 223: }
3303 4, 6, // 227: case 0x4: {
3304 OPC_CheckPredicate, 3, // 229: check predicate 3
3305 OPC_Decode, 252, 11, 98, // 231: decode to DIV_MMR6 using decoder 98
3306 // 231: }
3307 5, 6, // 235: case 0x5: {
3308 OPC_CheckPredicate, 3, // 237: check predicate 3
3309 OPC_Decode, 224, 17, 98, // 239: decode to MOD_MMR6 using decoder 98
3310 // 239: }
3311 6, 6, // 243: case 0x6: {
3312 OPC_CheckPredicate, 3, // 245: check predicate 3
3313 OPC_Decode, 250, 11, 98, // 247: decode to DIVU_MMR6 using decoder 98
3314 // 247: }
3315 7, 0, // 251: case 0x7: {
3316 OPC_CheckPredicate, 3, // 253: check predicate 3
3317 OPC_Decode, 222, 17, 98, // 255: decode to MODU_MMR6 using decoder 98
3318 // 255: }
3319 // 255: } // switch Inst[10:6]
3320 // 255: }
3321 31, 11, // 259: case 0x1f: {
3322 OPC_CheckPredicate, 3, // 261: check predicate 3
3323 OPC_CheckField, 6, 3, 0, // 263: check Inst[8:6] == 0x0
3324 OPC_Decode, 248, 6, 201, 1, // 267: decode to ALIGN_MMR6 using decoder 201
3325 // 267: }
3326 44, 6, // 272: case 0x2c: {
3327 OPC_CheckPredicate, 3, // 274: check predicate 3
3328 OPC_Decode, 156, 13, 109, // 276: decode to EXT_MMR6 using decoder 109
3329 // 276: }
3330 52, 27, // 280: case 0x34: {
3331 OPC_SwitchField, 6, 5, // 282: switch Inst[10:6] {
3332 3, 10, // 285: case 0x3: {
3333 OPC_CheckPredicate, 3, // 287: check predicate 3
3334 OPC_CheckField, 14, 2, 0, // 289: check Inst[15:14] == 0x0
3335 OPC_Decode, 168, 17, 111, // 293: decode to MFHC0_MMR6 using decoder 111
3336 // 293: }
3337 11, 0, // 297: case 0xb: {
3338 OPC_CheckPredicate, 3, // 299: check predicate 3
3339 OPC_CheckField, 14, 2, 0, // 301: check Inst[15:14] == 0x0
3340 OPC_Decode, 195, 18, 112, // 305: decode to MTHC0_MMR6 using decoder 112
3341 // 305: }
3342 // 305: } // switch Inst[10:6]
3343 // 305: }
3344 60, 224, 2, // 309: case 0x3c: {
3345 OPC_SwitchField, 14, 2, // 312: switch Inst[15:14] {
3346 0, 84, // 315: case 0x0: {
3347 OPC_SwitchField, 6, 5, // 317: switch Inst[10:6] {
3348 3, 6, // 320: case 0x3: {
3349 OPC_CheckPredicate, 3, // 322: check predicate 3
3350 OPC_Decode, 158, 17, 111, // 324: decode to MFC0_MMR6 using decoder 111
3351 // 324: }
3352 5, 29, // 328: case 0x5: {
3353 OPC_SwitchField, 11, 3, // 330: switch Inst[13:11] {
3354 3, 11, // 333: case 0x3: {
3355 OPC_CheckPredicate, 3, // 335: check predicate 3
3356 OPC_CheckField, 21, 5, 0, // 337: check Inst[25:21] == 0x0
3357 OPC_Decode, 231, 12, 136, 1, // 341: decode to DVP_MMR6 using decoder 136
3358 // 341: }
3359 7, 0, // 346: case 0x7: {
3360 OPC_CheckPredicate, 3, // 348: check predicate 3
3361 OPC_CheckField, 21, 5, 0, // 350: check Inst[25:21] == 0x0
3362 OPC_Decode, 253, 12, 136, 1, // 354: decode to EVP_MMR6 using decoder 136
3363 // 354: }
3364 // 354: } // switch Inst[13:11]
3365 // 354: }
3366 11, 6, // 359: case 0xb: {
3367 OPC_CheckPredicate, 3, // 361: check predicate 3
3368 OPC_Decode, 184, 18, 112, // 363: decode to MTC0_MMR6 using decoder 112
3369 // 363: }
3370 12, 11, // 367: case 0xc: {
3371 OPC_CheckPredicate, 3, // 369: check predicate 3
3372 OPC_CheckField, 11, 3, 1, // 371: check Inst[13:11] == 0x1
3373 OPC_Decode, 166, 8, 130, 1, // 375: decode to BITSWAP_MMR6 using decoder 130
3374 // 375: }
3375 28, 0, // 380: case 0x1c: {
3376 OPC_SwitchField, 11, 3, // 382: switch Inst[13:11] {
3377 1, 6, // 385: case 0x1: {
3378 OPC_CheckPredicate, 3, // 387: check predicate 3
3379 OPC_Decode, 142, 15, 123, // 389: decode to JALRC_MMR6 using decoder 123
3380 // 389: }
3381 3, 0, // 393: case 0x3: {
3382 OPC_CheckPredicate, 3, // 395: check predicate 3
3383 OPC_Decode, 141, 15, 123, // 397: decode to JALRC_HB_MMR6 using decoder 123
3384 // 397: }
3385 // 397: } // switch Inst[13:11]
3386 // 397: }
3387 // 397: } // switch Inst[10:6]
3388 // 397: }
3389 1, 161, 1, // 401: case 0x1: {
3390 OPC_SwitchField, 11, 3, // 404: switch Inst[13:11] {
3391 0, 28, // 407: case 0x0: {
3392 OPC_SwitchField, 6, 5, // 409: switch Inst[10:6] {
3393 13, 10, // 412: case 0xd: {
3394 OPC_CheckPredicate, 3, // 414: check predicate 3
3395 OPC_CheckField, 16, 10, 0, // 416: check Inst[25:16] == 0x0
3396 OPC_Decode, 132, 24, 10, // 420: decode to TLBINV_MMR6 using decoder 10
3397 // 420: }
3398 29, 0, // 424: case 0x1d: {
3399 OPC_CheckPredicate, 3, // 426: check predicate 3
3400 OPC_CheckField, 21, 5, 0, // 428: check Inst[25:21] == 0x0
3401 OPC_Decode, 135, 12, 136, 1, // 432: decode to DI_MMR6 using decoder 136
3402 // 432: }
3403 // 432: } // switch Inst[10:6]
3404 // 432: }
3405 1, 20, // 437: case 0x1: {
3406 OPC_SwitchField, 6, 5, // 439: switch Inst[10:6] {
3407 12, 6, // 442: case 0xc: {
3408 OPC_CheckPredicate, 3, // 444: check predicate 3
3409 OPC_Decode, 204, 9, 123, // 446: decode to CLO_MMR6 using decoder 123
3410 // 446: }
3411 20, 0, // 450: case 0x14: {
3412 OPC_CheckPredicate, 3, // 452: check predicate 3
3413 OPC_Decode, 165, 17, 134, 1, // 454: decode to MFC2_MMR6 using decoder 134
3414 // 454: }
3415 // 454: } // switch Inst[10:6]
3416 // 454: }
3417 2, 28, // 459: case 0x2: {
3418 OPC_SwitchField, 6, 5, // 461: switch Inst[10:6] {
3419 13, 10, // 464: case 0xd: {
3420 OPC_CheckPredicate, 3, // 466: check predicate 3
3421 OPC_CheckField, 16, 10, 0, // 468: check Inst[25:16] == 0x0
3422 OPC_Decode, 131, 24, 10, // 472: decode to TLBINVF_MMR6 using decoder 10
3423 // 472: }
3424 29, 0, // 476: case 0x1d: {
3425 OPC_CheckPredicate, 3, // 478: check predicate 3
3426 OPC_CheckField, 21, 5, 0, // 480: check Inst[25:21] == 0x0
3427 OPC_Decode, 241, 12, 136, 1, // 484: decode to EI_MMR6 using decoder 136
3428 // 484: }
3429 // 484: } // switch Inst[10:6]
3430 // 484: }
3431 3, 11, // 489: case 0x3: {
3432 OPC_CheckPredicate, 3, // 491: check predicate 3
3433 OPC_CheckField, 6, 5, 20, // 493: check Inst[10:6] == 0x14
3434 OPC_Decode, 192, 18, 135, 1, // 497: decode to MTC2_MMR6 using decoder 135
3435 // 497: }
3436 4, 15, // 502: case 0x4: {
3437 OPC_CheckPredicate, 26, // 504: check predicate 26
3438 OPC_CheckField, 21, 5, 0, // 506: check Inst[25:21] == 0x0
3439 OPC_CheckField, 6, 5, 5, // 510: check Inst[10:6] == 0x5
3440 OPC_Decode, 212, 14, 136, 1, // 514: decode to GINVI_MMR6 using decoder 136
3441 // 514: }
3442 5, 15, // 519: case 0x5: {
3443 OPC_CheckPredicate, 3, // 521: check predicate 3
3444 OPC_CheckField, 21, 5, 0, // 523: check Inst[25:21] == 0x0
3445 OPC_CheckField, 6, 5, 13, // 527: check Inst[10:6] == 0xd
3446 OPC_Decode, 205, 23, 131, 1, // 531: decode to SYNC_MMR6 using decoder 131
3447 // 531: }
3448 6, 15, // 536: case 0x6: {
3449 OPC_CheckPredicate, 26, // 538: check predicate 26
3450 OPC_CheckField, 21, 5, 0, // 540: check Inst[25:21] == 0x0
3451 OPC_CheckField, 6, 3, 5, // 544: check Inst[8:6] == 0x5
3452 OPC_Decode, 215, 14, 202, 1, // 548: decode to GINVT_MMR6 using decoder 202
3453 // 548: }
3454 7, 0, // 553: case 0x7: {
3455 OPC_CheckPredicate, 3, // 555: check predicate 3
3456 OPC_CheckField, 6, 5, 12, // 557: check Inst[10:6] == 0xc
3457 OPC_Decode, 190, 24, 123, // 561: decode to WSBH_MMR6 using decoder 123
3458 // 561: }
3459 // 561: } // switch Inst[13:11]
3460 // 561: }
3461 2, 30, // 565: case 0x2: {
3462 OPC_SwitchField, 6, 8, // 567: switch Inst[13:6] {
3463 52, 7, // 570: case 0x34: {
3464 OPC_CheckPredicate, 3, // 572: check predicate 3
3465 OPC_Decode, 174, 17, 134, 1, // 574: decode to MFHC2_MMR6 using decoder 134
3466 // 574: }
3467 77, 7, // 579: case 0x4d: {
3468 OPC_CheckPredicate, 3, // 581: check predicate 3
3469 OPC_Decode, 182, 24, 132, 1, // 583: decode to WAIT_MMR6 using decoder 132
3470 // 583: }
3471 116, 0, // 588: case 0x74: {
3472 OPC_CheckPredicate, 3, // 590: check predicate 3
3473 OPC_Decode, 201, 18, 135, 1, // 592: decode to MTHC2_MMR6 using decoder 135
3474 // 592: }
3475 // 592: } // switch Inst[13:6]
3476 // 592: }
3477 3, 0, // 597: case 0x3: {
3478 OPC_SwitchField, 6, 8, // 599: switch Inst[13:6] {
3479 109, 7, // 602: case 0x6d: {
3480 OPC_CheckPredicate, 3, // 604: check predicate 3
3481 OPC_Decode, 249, 20, 132, 1, // 606: decode to SDBBP_MMR6 using decoder 132
3482 // 606: }
3483 133, 1, 6, // 611: case 0x85: {
3484 OPC_CheckPredicate, 3, // 614: check predicate 3
3485 OPC_Decode, 157, 20, 123, // 616: decode to RDPGPR_MMR6 using decoder 123
3486 // 616: }
3487 141, 1, 10, // 620: case 0x8d: {
3488 OPC_CheckPredicate, 3, // 623: check predicate 3
3489 OPC_CheckField, 16, 10, 0, // 625: check Inst[25:16] == 0x0
3490 OPC_Decode, 238, 11, 10, // 629: decode to DERET_MMR6 using decoder 10
3491 // 629: }
3492 197, 1, 6, // 633: case 0xc5: {
3493 OPC_CheckPredicate, 3, // 636: check predicate 3
3494 OPC_Decode, 186, 24, 123, // 638: decode to WRPGPR_MMR6 using decoder 123
3495 // 638: }
3496 205, 1, 0, // 642: case 0xcd: {
3497 OPC_SwitchField, 16, 10, // 645: switch Inst[25:16] {
3498 0, 6, // 648: case 0x0: {
3499 OPC_CheckPredicate, 3, // 650: check predicate 3
3500 OPC_Decode, 249, 12, 10, // 652: decode to ERET_MMR6 using decoder 10
3501 // 652: }
3502 1, 0, // 656: case 0x1: {
3503 OPC_CheckPredicate, 3, // 658: check predicate 3
3504 OPC_Decode, 246, 12, 10, // 660: decode to ERETNC_MMR6 using decoder 10
3505 // 660: }
3506 // 660: } // switch Inst[25:16]
3507 // 660: }
3508 // 660: } // switch Inst[13:6]
3509 // 660: }
3510 // 660: } // switch Inst[15:14]
3511 // 660: }
3512 63, 0, // 664: case 0x3f: {
3513 OPC_CheckPredicate, 3, // 666: check predicate 3
3514 OPC_CheckField, 22, 4, 0, // 668: check Inst[25:22] == 0x0
3515 OPC_Decode, 234, 21, 203, 1, // 672: decode to SIGRIE_MMR6 using decoder 203
3516 // 672: }
3517 // 672: } // switch Inst[5:0]
3518 // 672: }
3519 4, 20, // 677: case 0x4: {
3520 OPC_Scope, 11, // 679: try {
3521 OPC_CheckField, 16, 5, 0, // 681: check Inst[20:16] == 0x0
3522 OPC_CheckPredicate, 3, // 685: check predicate 3
3523 OPC_Decode, 151, 16, 204, 1, // 687: decode to LUI_MMR6 using decoder 204
3524 // 687: } else try {
3525 OPC_CheckPredicate, 3, // 692: check predicate 3
3526 OPC_Decode, 155, 7, 153, 1, // 694: decode to AUI_MMR6 using decoder 153
3527 // 694: }
3528 // 694: }
3529 5, 7, // 699: case 0x5: {
3530 OPC_CheckPredicate, 3, // 701: check predicate 3
3531 OPC_Decode, 195, 15, 142, 1, // 703: decode to LBU_MMR6 using decoder 142
3532 // 703: }
3533 6, 7, // 708: case 0x6: {
3534 OPC_CheckPredicate, 3, // 710: check predicate 3
3535 OPC_Decode, 228, 20, 142, 1, // 712: decode to SB_MMR6 using decoder 142
3536 // 712: }
3537 7, 7, // 717: case 0x7: {
3538 OPC_CheckPredicate, 3, // 719: check predicate 3
3539 OPC_Decode, 200, 15, 142, 1, // 721: decode to LB_MMR6 using decoder 142
3540 // 721: }
3541 8, 64, // 726: case 0x8: {
3542 OPC_SwitchField, 12, 4, // 728: switch Inst[15:12] {
3543 0, 11, // 731: case 0x0: {
3544 OPC_CheckPredicate, 3, // 733: check predicate 3
3545 OPC_CheckField, 11, 1, 0, // 735: check Inst[11] == 0x0
3546 OPC_Decode, 167, 16, 205, 1, // 739: decode to LWC2_MMR6 using decoder 205
3547 // 739: }
3548 2, 11, // 744: case 0x2: {
3549 OPC_CheckPredicate, 3, // 746: check predicate 3
3550 OPC_CheckField, 11, 1, 0, // 748: check Inst[11] == 0x0
3551 OPC_Decode, 215, 15, 205, 1, // 752: decode to LDC2_MMR6 using decoder 205
3552 // 752: }
3553 6, 7, // 757: case 0x6: {
3554 OPC_CheckPredicate, 3, // 759: check predicate 3
3555 OPC_Decode, 152, 9, 145, 1, // 761: decode to CACHE_MMR6 using decoder 145
3556 // 761: }
3557 8, 11, // 766: case 0x8: {
3558 OPC_CheckPredicate, 3, // 768: check predicate 3
3559 OPC_CheckField, 11, 1, 0, // 770: check Inst[11] == 0x0
3560 OPC_Decode, 162, 23, 205, 1, // 774: decode to SWC2_MMR6 using decoder 205
3561 // 774: }
3562 10, 0, // 779: case 0xa: {
3563 OPC_CheckPredicate, 3, // 781: check predicate 3
3564 OPC_CheckField, 11, 1, 0, // 783: check Inst[11] == 0x0
3565 OPC_Decode, 130, 21, 205, 1, // 787: decode to SDC2_MMR6 using decoder 205
3566 // 787: }
3567 // 787: } // switch Inst[15:12]
3568 // 787: }
3569 12, 7, // 792: case 0xc: {
3570 OPC_CheckPredicate, 3, // 794: check predicate 3
3571 OPC_Decode, 175, 6, 141, 1, // 796: decode to ADDIU_MMR6 using decoder 141
3572 // 796: }
3573 14, 7, // 801: case 0xe: {
3574 OPC_CheckPredicate, 3, // 803: check predicate 3
3575 OPC_Decode, 230, 21, 142, 1, // 805: decode to SH_MMR6 using decoder 142
3576 // 805: }
3577 16, 48, // 810: case 0x10: {
3578 OPC_SwitchField, 21, 5, // 812: switch Inst[25:21] {
3579 8, 7, // 815: case 0x8: {
3580 OPC_CheckPredicate, 27, // 817: check predicate 27
3581 OPC_Decode, 201, 7, 206, 1, // 819: decode to BC1EQZC_MMR6 using decoder 206
3582 // 819: }
3583 9, 7, // 824: case 0x9: {
3584 OPC_CheckPredicate, 27, // 826: check predicate 27
3585 OPC_Decode, 206, 7, 206, 1, // 828: decode to BC1NEZC_MMR6 using decoder 206
3586 // 828: }
3587 10, 7, // 833: case 0xa: {
3588 OPC_CheckPredicate, 3, // 835: check predicate 3
3589 OPC_Decode, 211, 7, 207, 1, // 837: decode to BC2EQZC_MMR6 using decoder 207
3590 // 837: }
3591 11, 7, // 842: case 0xb: {
3592 OPC_CheckPredicate, 3, // 844: check predicate 3
3593 OPC_Decode, 213, 7, 207, 1, // 846: decode to BC2NEZC_MMR6 using decoder 207
3594 // 846: }
3595 12, 0, // 851: case 0xc: {
3596 OPC_CheckPredicate, 3, // 853: check predicate 3
3597 OPC_Decode, 201, 23, 149, 1, // 855: decode to SYNCI_MMR6 using decoder 149
3598 // 855: }
3599 // 855: } // switch Inst[25:21]
3600 // 855: }
3601 20, 7, // 860: case 0x14: {
3602 OPC_CheckPredicate, 3, // 862: check predicate 3
3603 OPC_Decode, 194, 19, 153, 1, // 864: decode to ORI_MMR6 using decoder 153
3604 // 864: }
3605 21, 217, 6, // 869: case 0x15: {
3606 OPC_SwitchField, 0, 11, // 872: switch Inst[10:0] {
3607 3, 7, // 875: case 0x3: {
3608 OPC_CheckPredicate, 27, // 877: check predicate 27
3609 OPC_Decode, 212, 17, 208, 1, // 879: decode to MIN_S_MMR6 using decoder 208
3610 // 879: }
3611 5, 7, // 884: case 0x5: {
3612 OPC_CheckPredicate, 27, // 886: check predicate 27
3613 OPC_Decode, 247, 9, 208, 1, // 888: decode to CMP_AF_S_MMR6 using decoder 208
3614 // 888: }
3615 11, 7, // 893: case 0xb: {
3616 OPC_CheckPredicate, 27, // 895: check predicate 27
3617 OPC_Decode, 150, 17, 208, 1, // 897: decode to MAX_S_MMR6 using decoder 208
3618 // 897: }
3619 21, 7, // 902: case 0x15: {
3620 OPC_CheckPredicate, 27, // 904: check predicate 27
3621 OPC_Decode, 246, 9, 197, 1, // 906: decode to CMP_AF_D_MMR6 using decoder 197
3622 // 906: }
3623 32, 11, // 911: case 0x20: {
3624 OPC_CheckPredicate, 3, // 913: check predicate 3
3625 OPC_CheckField, 11, 5, 0, // 915: check Inst[15:11] == 0x0
3626 OPC_Decode, 179, 20, 209, 1, // 919: decode to RINT_S_MMR6 using decoder 209
3627 // 919: }
3628 35, 7, // 924: case 0x23: {
3629 OPC_CheckPredicate, 27, // 926: check predicate 27
3630 OPC_Decode, 193, 17, 208, 1, // 928: decode to MINA_S_MMR6 using decoder 208
3631 // 928: }
3632 43, 7, // 933: case 0x2b: {
3633 OPC_CheckPredicate, 27, // 935: check predicate 27
3634 OPC_Decode, 131, 17, 208, 1, // 937: decode to MAXA_S_MMR6 using decoder 208
3635 // 937: }
3636 48, 7, // 942: case 0x30: {
3637 OPC_CheckPredicate, 27, // 944: check predicate 27
3638 OPC_Decode, 172, 13, 210, 1, // 946: decode to FADD_S_MMR6 using decoder 210
3639 // 946: }
3640 56, 7, // 951: case 0x38: {
3641 OPC_CheckPredicate, 3, // 953: check predicate 3
3642 OPC_Decode, 153, 21, 208, 1, // 955: decode to SELEQZ_S_MMR6 using decoder 208
3643 // 955: }
3644 59, 21, // 960: case 0x3b: {
3645 OPC_SwitchField, 11, 5, // 962: switch Inst[15:11] {
3646 4, 7, // 965: case 0x4: {
3647 OPC_CheckPredicate, 27, // 967: check predicate 27
3648 OPC_Decode, 163, 17, 164, 1, // 969: decode to MFC1_MMR6 using decoder 164
3649 // 969: }
3650 5, 0, // 974: case 0x5: {
3651 OPC_CheckPredicate, 27, // 976: check predicate 27
3652 OPC_Decode, 190, 18, 170, 1, // 978: decode to MTC1_MMR6 using decoder 170
3653 // 978: }
3654 // 978: } // switch Inst[15:11]
3655 // 978: }
3656 69, 7, // 983: case 0x45: {
3657 OPC_CheckPredicate, 27, // 985: check predicate 27
3658 OPC_Decode, 187, 10, 208, 1, // 987: decode to CMP_UN_S_MMR6 using decoder 208
3659 // 987: }
3660 85, 7, // 992: case 0x55: {
3661 OPC_CheckPredicate, 27, // 994: check predicate 27
3662 OPC_Decode, 185, 10, 197, 1, // 996: decode to CMP_UN_D_MMR6 using decoder 197
3663 // 996: }
3664 96, 11, // 1001: case 0x60: {
3665 OPC_CheckPredicate, 3, // 1003: check predicate 3
3666 OPC_CheckField, 11, 5, 0, // 1005: check Inst[15:11] == 0x0
3667 OPC_Decode, 185, 9, 209, 1, // 1009: decode to CLASS_S_MMR6 using decoder 209
3668 // 1009: }
3669 112, 7, // 1014: case 0x70: {
3670 OPC_CheckPredicate, 27, // 1016: check predicate 27
3671 OPC_Decode, 189, 14, 210, 1, // 1018: decode to FSUB_S_MMR6 using decoder 210
3672 // 1018: }
3673 120, 7, // 1023: case 0x78: {
3674 OPC_CheckPredicate, 3, // 1025: check predicate 3
3675 OPC_Decode, 160, 21, 208, 1, // 1027: decode to SELNEZ_S_MMR6 using decoder 208
3676 // 1027: }
3677 123, 21, // 1032: case 0x7b: {
3678 OPC_SwitchField, 11, 5, // 1034: switch Inst[15:11] {
3679 0, 7, // 1037: case 0x0: {
3680 OPC_CheckPredicate, 27, // 1039: check predicate 27
3681 OPC_Decode, 134, 14, 169, 1, // 1041: decode to FMOV_S_MMR6 using decoder 169
3682 // 1041: }
3683 4, 0, // 1046: case 0x4: {
3684 OPC_CheckPredicate, 27, // 1048: check predicate 27
3685 OPC_Decode, 131, 14, 167, 1, // 1050: decode to FMOV_D_MMR6 using decoder 167
3686 // 1050: }
3687 // 1050: } // switch Inst[15:11]
3688 // 1050: }
3689 133, 1, 7, // 1055: case 0x85: {
3690 OPC_CheckPredicate, 27, // 1058: check predicate 27
3691 OPC_Decode, 253, 9, 208, 1, // 1060: decode to CMP_EQ_S_MMR6 using decoder 208
3692 // 1060: }
3693 149, 1, 7, // 1065: case 0x95: {
3694 OPC_CheckPredicate, 27, // 1068: check predicate 27
3695 OPC_Decode, 249, 9, 197, 1, // 1070: decode to CMP_EQ_D_MMR6 using decoder 197
3696 // 1070: }
3697 176, 1, 7, // 1075: case 0xb0: {
3698 OPC_CheckPredicate, 27, // 1078: check predicate 27
3699 OPC_Decode, 145, 14, 210, 1, // 1080: decode to FMUL_S_MMR6 using decoder 210
3700 // 1080: }
3701 184, 1, 7, // 1085: case 0xb8: {
3702 OPC_CheckPredicate, 3, // 1088: check predicate 3
3703 OPC_Decode, 164, 21, 211, 1, // 1090: decode to SEL_S_MMR6 using decoder 211
3704 // 1090: }
3705 197, 1, 7, // 1095: case 0xc5: {
3706 OPC_CheckPredicate, 27, // 1098: check predicate 27
3707 OPC_Decode, 175, 10, 208, 1, // 1100: decode to CMP_UEQ_S_MMR6 using decoder 208
3708 // 1100: }
3709 213, 1, 7, // 1105: case 0xd5: {
3710 OPC_CheckPredicate, 27, // 1108: check predicate 27
3711 OPC_Decode, 173, 10, 197, 1, // 1110: decode to CMP_UEQ_D_MMR6 using decoder 197
3712 // 1110: }
3713 240, 1, 7, // 1115: case 0xf0: {
3714 OPC_CheckPredicate, 27, // 1118: check predicate 27
3715 OPC_Decode, 210, 13, 210, 1, // 1120: decode to FDIV_S_MMR6 using decoder 210
3716 // 1120: }
3717 133, 2, 7, // 1125: case 0x105: {
3718 OPC_CheckPredicate, 27, // 1128: check predicate 27
3719 OPC_Decode, 139, 10, 208, 1, // 1130: decode to CMP_LT_S_MMR6 using decoder 208
3720 // 1130: }
3721 149, 2, 7, // 1135: case 0x115: {
3722 OPC_CheckPredicate, 27, // 1138: check predicate 27
3723 OPC_Decode, 135, 10, 197, 1, // 1140: decode to CMP_LT_D_MMR6 using decoder 197
3724 // 1140: }
3725 187, 2, 30, // 1145: case 0x13b: {
3726 OPC_SwitchField, 11, 5, // 1148: switch Inst[15:11] {
3727 0, 7, // 1151: case 0x0: {
3728 OPC_CheckPredicate, 27, // 1153: check predicate 27
3729 OPC_Decode, 228, 10, 166, 1, // 1155: decode to CVT_L_S_MMR6 using decoder 166
3730 // 1155: }
3731 1, 7, // 1160: case 0x1: {
3732 OPC_CheckPredicate, 27, // 1162: check predicate 27
3733 OPC_Decode, 249, 10, 169, 1, // 1164: decode to CVT_W_S_MMR6 using decoder 169
3734 // 1164: }
3735 8, 0, // 1169: case 0x8: {
3736 OPC_CheckPredicate, 27, // 1171: check predicate 27
3737 OPC_Decode, 225, 10, 167, 1, // 1173: decode to CVT_L_D_MMR6 using decoder 167
3738 // 1173: }
3739 // 1173: } // switch Inst[15:11]
3740 // 1173: }
3741 197, 2, 7, // 1178: case 0x145: {
3742 OPC_CheckPredicate, 27, // 1181: check predicate 27
3743 OPC_Decode, 183, 10, 208, 1, // 1183: decode to CMP_ULT_S_MMR6 using decoder 208
3744 // 1183: }
3745 213, 2, 7, // 1188: case 0x155: {
3746 OPC_CheckPredicate, 27, // 1191: check predicate 27
3747 OPC_Decode, 181, 10, 197, 1, // 1193: decode to CMP_ULT_D_MMR6 using decoder 197
3748 // 1193: }
3749 133, 3, 7, // 1198: case 0x185: {
3750 OPC_CheckPredicate, 27, // 1201: check predicate 27
3751 OPC_Decode, 133, 10, 208, 1, // 1203: decode to CMP_LE_S_MMR6 using decoder 208
3752 // 1203: }
3753 149, 3, 7, // 1208: case 0x195: {
3754 OPC_CheckPredicate, 27, // 1211: check predicate 27
3755 OPC_Decode, 129, 10, 197, 1, // 1213: decode to CMP_LE_D_MMR6 using decoder 197
3756 // 1213: }
3757 184, 3, 7, // 1218: case 0x1b8: {
3758 OPC_CheckPredicate, 27, // 1221: check predicate 27
3759 OPC_Decode, 227, 16, 211, 1, // 1223: decode to MADDF_S_MMR6 using decoder 211
3760 // 1223: }
3761 197, 3, 7, // 1228: case 0x1c5: {
3762 OPC_CheckPredicate, 27, // 1231: check predicate 27
3763 OPC_Decode, 179, 10, 208, 1, // 1233: decode to CMP_ULE_S_MMR6 using decoder 208
3764 // 1233: }
3765 213, 3, 7, // 1238: case 0x1d5: {
3766 OPC_CheckPredicate, 27, // 1241: check predicate 27
3767 OPC_Decode, 177, 10, 197, 1, // 1243: decode to CMP_ULE_D_MMR6 using decoder 197
3768 // 1243: }
3769 248, 3, 7, // 1248: case 0x1f8: {
3770 OPC_CheckPredicate, 27, // 1251: check predicate 27
3771 OPC_Decode, 161, 18, 211, 1, // 1253: decode to MSUBF_S_MMR6 using decoder 211
3772 // 1253: }
3773 131, 4, 7, // 1258: case 0x203: {
3774 OPC_CheckPredicate, 27, // 1261: check predicate 27
3775 OPC_Decode, 207, 17, 197, 1, // 1263: decode to MIN_D_MMR6 using decoder 197
3776 // 1263: }
3777 133, 4, 7, // 1268: case 0x205: {
3778 OPC_CheckPredicate, 27, // 1271: check predicate 27
3779 OPC_Decode, 143, 10, 208, 1, // 1273: decode to CMP_SAF_S_MMR6 using decoder 208
3780 // 1273: }
3781 139, 4, 7, // 1278: case 0x20b: {
3782 OPC_CheckPredicate, 27, // 1281: check predicate 27
3783 OPC_Decode, 145, 17, 197, 1, // 1283: decode to MAX_D_MMR6 using decoder 197
3784 // 1283: }
3785 149, 4, 7, // 1288: case 0x215: {
3786 OPC_CheckPredicate, 27, // 1291: check predicate 27
3787 OPC_Decode, 141, 10, 197, 1, // 1293: decode to CMP_SAF_D_MMR6 using decoder 197
3788 // 1293: }
3789 160, 4, 11, // 1298: case 0x220: {
3790 OPC_CheckPredicate, 3, // 1301: check predicate 3
3791 OPC_CheckField, 11, 5, 0, // 1303: check Inst[15:11] == 0x0
3792 OPC_Decode, 177, 20, 212, 1, // 1307: decode to RINT_D_MMR6 using decoder 212
3793 // 1307: }
3794 163, 4, 7, // 1312: case 0x223: {
3795 OPC_CheckPredicate, 27, // 1315: check predicate 27
3796 OPC_Decode, 191, 17, 197, 1, // 1317: decode to MINA_D_MMR6 using decoder 197
3797 // 1317: }
3798 171, 4, 7, // 1322: case 0x22b: {
3799 OPC_CheckPredicate, 27, // 1325: check predicate 27
3800 OPC_Decode, 129, 17, 197, 1, // 1327: decode to MAXA_D_MMR6 using decoder 197
3801 // 1327: }
3802 184, 4, 7, // 1332: case 0x238: {
3803 OPC_CheckPredicate, 3, // 1335: check predicate 3
3804 OPC_Decode, 150, 21, 197, 1, // 1337: decode to SELEQZ_D_MMR6 using decoder 197
3805 // 1337: }
3806 197, 4, 7, // 1342: case 0x245: {
3807 OPC_CheckPredicate, 27, // 1345: check predicate 27
3808 OPC_Decode, 171, 10, 208, 1, // 1347: decode to CMP_SUN_S_MMR6 using decoder 208
3809 // 1347: }
3810 213, 4, 7, // 1352: case 0x255: {
3811 OPC_CheckPredicate, 27, // 1355: check predicate 27
3812 OPC_Decode, 169, 10, 197, 1, // 1357: decode to CMP_SUN_D_MMR6 using decoder 197
3813 // 1357: }
3814 224, 4, 11, // 1362: case 0x260: {
3815 OPC_CheckPredicate, 3, // 1365: check predicate 3
3816 OPC_CheckField, 11, 5, 0, // 1367: check Inst[15:11] == 0x0
3817 OPC_Decode, 183, 9, 212, 1, // 1371: decode to CLASS_D_MMR6 using decoder 212
3818 // 1371: }
3819 248, 4, 7, // 1376: case 0x278: {
3820 OPC_CheckPredicate, 3, // 1379: check predicate 3
3821 OPC_Decode, 157, 21, 197, 1, // 1381: decode to SELNEZ_D_MMR6 using decoder 197
3822 // 1381: }
3823 133, 5, 7, // 1386: case 0x285: {
3824 OPC_CheckPredicate, 27, // 1389: check predicate 27
3825 OPC_Decode, 147, 10, 208, 1, // 1391: decode to CMP_SEQ_S_MMR6 using decoder 208
3826 // 1391: }
3827 149, 5, 7, // 1396: case 0x295: {
3828 OPC_CheckPredicate, 27, // 1399: check predicate 27
3829 OPC_Decode, 145, 10, 197, 1, // 1401: decode to CMP_SEQ_D_MMR6 using decoder 197
3830 // 1401: }
3831 184, 5, 7, // 1406: case 0x2b8: {
3832 OPC_CheckPredicate, 3, // 1409: check predicate 3
3833 OPC_Decode, 162, 21, 213, 1, // 1411: decode to SEL_D_MMR6 using decoder 213
3834 // 1411: }
3835 197, 5, 7, // 1416: case 0x2c5: {
3836 OPC_CheckPredicate, 27, // 1419: check predicate 27
3837 OPC_Decode, 159, 10, 208, 1, // 1421: decode to CMP_SUEQ_S_MMR6 using decoder 208
3838 // 1421: }
3839 213, 5, 7, // 1426: case 0x2d5: {
3840 OPC_CheckPredicate, 27, // 1429: check predicate 27
3841 OPC_Decode, 157, 10, 197, 1, // 1431: decode to CMP_SUEQ_D_MMR6 using decoder 197
3842 // 1431: }
3843 133, 6, 7, // 1436: case 0x305: {
3844 OPC_CheckPredicate, 27, // 1439: check predicate 27
3845 OPC_Decode, 155, 10, 208, 1, // 1441: decode to CMP_SLT_S_MMR6 using decoder 208
3846 // 1441: }
3847 149, 6, 7, // 1446: case 0x315: {
3848 OPC_CheckPredicate, 27, // 1449: check predicate 27
3849 OPC_Decode, 153, 10, 197, 1, // 1451: decode to CMP_SLT_D_MMR6 using decoder 197
3850 // 1451: }
3851 187, 6, 147, 1, // 1456: case 0x33b: {
3852 OPC_SwitchField, 11, 5, // 1460: switch Inst[15:11] {
3853 0, 7, // 1463: case 0x0: {
3854 OPC_CheckPredicate, 27, // 1465: check predicate 27
3855 OPC_Decode, 237, 13, 166, 1, // 1467: decode to FLOOR_L_S_MMR6 using decoder 166
3856 // 1467: }
3857 1, 7, // 1472: case 0x1: {
3858 OPC_CheckPredicate, 27, // 1474: check predicate 27
3859 OPC_Decode, 244, 13, 169, 1, // 1476: decode to FLOOR_W_S_MMR6 using decoder 169
3860 // 1476: }
3861 2, 7, // 1481: case 0x2: {
3862 OPC_CheckPredicate, 27, // 1483: check predicate 27
3863 OPC_Decode, 158, 9, 166, 1, // 1485: decode to CEIL_L_S_MMR6 using decoder 166
3864 // 1485: }
3865 3, 7, // 1490: case 0x3: {
3866 OPC_CheckPredicate, 27, // 1492: check predicate 27
3867 OPC_Decode, 165, 9, 169, 1, // 1494: decode to CEIL_W_S_MMR6 using decoder 169
3868 // 1494: }
3869 4, 7, // 1499: case 0x4: {
3870 OPC_CheckPredicate, 27, // 1501: check predicate 27
3871 OPC_Decode, 156, 24, 166, 1, // 1503: decode to TRUNC_L_S_MMR6 using decoder 166
3872 // 1503: }
3873 5, 7, // 1508: case 0x5: {
3874 OPC_CheckPredicate, 27, // 1510: check predicate 27
3875 OPC_Decode, 163, 24, 169, 1, // 1512: decode to TRUNC_W_S_MMR6 using decoder 169
3876 // 1512: }
3877 6, 7, // 1517: case 0x6: {
3878 OPC_CheckPredicate, 27, // 1519: check predicate 27
3879 OPC_Decode, 190, 20, 166, 1, // 1521: decode to ROUND_L_S_MMR6 using decoder 166
3880 // 1521: }
3881 7, 7, // 1526: case 0x7: {
3882 OPC_CheckPredicate, 27, // 1528: check predicate 27
3883 OPC_Decode, 197, 20, 169, 1, // 1530: decode to ROUND_W_S_MMR6 using decoder 169
3884 // 1530: }
3885 8, 7, // 1535: case 0x8: {
3886 OPC_CheckPredicate, 27, // 1537: check predicate 27
3887 OPC_Decode, 235, 13, 167, 1, // 1539: decode to FLOOR_L_D_MMR6 using decoder 167
3888 // 1539: }
3889 9, 7, // 1544: case 0x9: {
3890 OPC_CheckPredicate, 27, // 1546: check predicate 27
3891 OPC_Decode, 240, 13, 171, 1, // 1548: decode to FLOOR_W_D_MMR6 using decoder 171
3892 // 1548: }
3893 10, 7, // 1553: case 0xa: {
3894 OPC_CheckPredicate, 27, // 1555: check predicate 27
3895 OPC_Decode, 156, 9, 167, 1, // 1557: decode to CEIL_L_D_MMR6 using decoder 167
3896 // 1557: }
3897 11, 7, // 1562: case 0xb: {
3898 OPC_CheckPredicate, 27, // 1564: check predicate 27
3899 OPC_Decode, 161, 9, 171, 1, // 1566: decode to CEIL_W_D_MMR6 using decoder 171
3900 // 1566: }
3901 12, 7, // 1571: case 0xc: {
3902 OPC_CheckPredicate, 27, // 1573: check predicate 27
3903 OPC_Decode, 154, 24, 167, 1, // 1575: decode to TRUNC_L_D_MMR6 using decoder 167
3904 // 1575: }
3905 13, 7, // 1580: case 0xd: {
3906 OPC_CheckPredicate, 27, // 1582: check predicate 27
3907 OPC_Decode, 159, 24, 198, 1, // 1584: decode to TRUNC_W_D_MMR6 using decoder 198
3908 // 1584: }
3909 14, 7, // 1589: case 0xe: {
3910 OPC_CheckPredicate, 27, // 1591: check predicate 27
3911 OPC_Decode, 188, 20, 167, 1, // 1593: decode to ROUND_L_D_MMR6 using decoder 167
3912 // 1593: }
3913 15, 0, // 1598: case 0xf: {
3914 OPC_CheckPredicate, 27, // 1600: check predicate 27
3915 OPC_Decode, 193, 20, 167, 1, // 1602: decode to ROUND_W_D_MMR6 using decoder 167
3916 // 1602: }
3917 // 1602: } // switch Inst[15:11]
3918 // 1602: }
3919 197, 6, 7, // 1607: case 0x345: {
3920 OPC_CheckPredicate, 27, // 1610: check predicate 27
3921 OPC_Decode, 167, 10, 208, 1, // 1612: decode to CMP_SULT_S_MMR6 using decoder 208
3922 // 1612: }
3923 213, 6, 7, // 1617: case 0x355: {
3924 OPC_CheckPredicate, 27, // 1620: check predicate 27
3925 OPC_Decode, 165, 10, 197, 1, // 1622: decode to CMP_SULT_D_MMR6 using decoder 197
3926 // 1622: }
3927 251, 6, 39, // 1627: case 0x37b: {
3928 OPC_SwitchField, 11, 5, // 1630: switch Inst[15:11] {
3929 1, 7, // 1633: case 0x1: {
3930 OPC_CheckPredicate, 27, // 1635: check predicate 27
3931 OPC_Decode, 153, 14, 169, 1, // 1637: decode to FNEG_S_MMR6 using decoder 169
3932 // 1637: }
3933 7, 7, // 1642: case 0x7: {
3934 OPC_CheckPredicate, 27, // 1644: check predicate 27
3935 OPC_Decode, 242, 10, 169, 1, // 1646: decode to CVT_S_W_MMR6 using decoder 169
3936 // 1646: }
3937 10, 7, // 1651: case 0xa: {
3938 OPC_CheckPredicate, 25, // 1653: check predicate 25
3939 OPC_Decode, 222, 10, 167, 1, // 1655: decode to CVT_D_L_MMR6 using decoder 167
3940 // 1655: }
3941 11, 0, // 1660: case 0xb: {
3942 OPC_CheckPredicate, 25, // 1662: check predicate 25
3943 OPC_Decode, 237, 10, 166, 1, // 1664: decode to CVT_S_L_MMR6 using decoder 166
3944 // 1664: }
3945 // 1664: } // switch Inst[15:11]
3946 // 1664: }
3947 133, 7, 7, // 1669: case 0x385: {
3948 OPC_CheckPredicate, 27, // 1672: check predicate 27
3949 OPC_Decode, 151, 10, 208, 1, // 1674: decode to CMP_SLE_S_MMR6 using decoder 208
3950 // 1674: }
3951 149, 7, 7, // 1679: case 0x395: {
3952 OPC_CheckPredicate, 27, // 1682: check predicate 27
3953 OPC_Decode, 149, 10, 197, 1, // 1684: decode to CMP_SLE_D_MMR6 using decoder 197
3954 // 1684: }
3955 184, 7, 7, // 1689: case 0x3b8: {
3956 OPC_CheckPredicate, 27, // 1692: check predicate 27
3957 OPC_Decode, 225, 16, 213, 1, // 1694: decode to MADDF_D_MMR6 using decoder 213
3958 // 1694: }
3959 197, 7, 7, // 1699: case 0x3c5: {
3960 OPC_CheckPredicate, 27, // 1702: check predicate 27
3961 OPC_Decode, 163, 10, 208, 1, // 1704: decode to CMP_SULE_S_MMR6 using decoder 208
3962 // 1704: }
3963 213, 7, 7, // 1709: case 0x3d5: {
3964 OPC_CheckPredicate, 27, // 1712: check predicate 27
3965 OPC_Decode, 161, 10, 197, 1, // 1714: decode to CMP_SULE_D_MMR6 using decoder 197
3966 // 1714: }
3967 248, 7, 0, // 1719: case 0x3f8: {
3968 OPC_CheckPredicate, 27, // 1722: check predicate 27
3969 OPC_Decode, 159, 18, 213, 1, // 1724: decode to MSUBF_D_MMR6 using decoder 213
3970 // 1724: }
3971 // 1724: } // switch Inst[10:0]
3972 // 1724: }
3973 24, 38, // 1729: case 0x18: {
3974 OPC_SwitchField, 12, 4, // 1731: switch Inst[15:12] {
3975 2, 7, // 1734: case 0x2: {
3976 OPC_CheckPredicate, 3, // 1736: check predicate 3
3977 OPC_Decode, 140, 20, 145, 1, // 1738: decode to PREF_MMR6 using decoder 145
3978 // 1738: }
3979 3, 11, // 1743: case 0x3: {
3980 OPC_CheckPredicate, 3, // 1745: check predicate 3
3981 OPC_CheckField, 9, 3, 0, // 1747: check Inst[11:9] == 0x0
3982 OPC_Decode, 144, 16, 182, 1, // 1751: decode to LL_MMR6 using decoder 182
3983 // 1751: }
3984 11, 0, // 1756: case 0xb: {
3985 OPC_CheckPredicate, 3, // 1758: check predicate 3
3986 OPC_CheckField, 9, 3, 0, // 1760: check Inst[11:9] == 0x0
3987 OPC_Decode, 240, 20, 185, 1, // 1764: decode to SC_MMR6 using decoder 185
3988 // 1764: }
3989 // 1764: } // switch Inst[15:12]
3990 // 1764: }
3991 28, 7, // 1769: case 0x1c: {
3992 OPC_CheckPredicate, 3, // 1771: check predicate 3
3993 OPC_Decode, 197, 24, 153, 1, // 1773: decode to XORI_MMR6 using decoder 153
3994 // 1773: }
3995 29, 20, // 1778: case 0x1d: {
3996 OPC_Scope, 11, // 1780: try {
3997 OPC_CheckField, 16, 5, 0, // 1782: check Inst[20:16] == 0x0
3998 OPC_CheckPredicate, 3, // 1786: check predicate 3
3999 OPC_Decode, 234, 7, 214, 1, // 1788: decode to BEQZALC_MMR6 using decoder 214
4000 // 1788: } else try {
4001 OPC_CheckPredicate, 3, // 1793: check predicate 3
4002 OPC_Decode, 228, 7, 214, 1, // 1795: decode to BEQC_MMR6 using decoder 214
4003 // 1795: }
4004 // 1795: }
4005 30, 44, // 1800: case 0x1e: {
4006 OPC_SwitchField, 19, 2, // 1802: switch Inst[20:19] {
4007 0, 7, // 1805: case 0x0: {
4008 OPC_CheckPredicate, 3, // 1807: check predicate 3
4009 OPC_Decode, 166, 6, 215, 1, // 1809: decode to ADDIUPC_MMR6 using decoder 215
4010 // 1809: }
4011 1, 7, // 1814: case 0x1: {
4012 OPC_CheckPredicate, 3, // 1816: check predicate 3
4013 OPC_Decode, 187, 16, 215, 1, // 1818: decode to LWPC_MMR6 using decoder 215
4014 // 1818: }
4015 3, 0, // 1823: case 0x3: {
4016 OPC_SwitchField, 16, 3, // 1825: switch Inst[18:16] {
4017 6, 7, // 1828: case 0x6: {
4018 OPC_CheckPredicate, 3, // 1830: check predicate 3
4019 OPC_Decode, 154, 7, 216, 1, // 1832: decode to AUIPC_MMR6 using decoder 216
4020 // 1832: }
4021 7, 0, // 1837: case 0x7: {
4022 OPC_CheckPredicate, 3, // 1839: check predicate 3
4023 OPC_Decode, 250, 6, 216, 1, // 1841: decode to ALUIPC_MMR6 using decoder 216
4024 // 1841: }
4025 // 1841: } // switch Inst[18:16]
4026 // 1841: }
4027 // 1841: } // switch Inst[20:19]
4028 // 1841: }
4029 31, 20, // 1846: case 0x1f: {
4030 OPC_Scope, 11, // 1848: try {
4031 OPC_CheckField, 16, 5, 0, // 1850: check Inst[20:16] == 0x0
4032 OPC_CheckPredicate, 3, // 1854: check predicate 3
4033 OPC_Decode, 221, 8, 217, 1, // 1856: decode to BNEZALC_MMR6 using decoder 217
4034 // 1856: } else try {
4035 OPC_CheckPredicate, 3, // 1861: check predicate 3
4036 OPC_Decode, 207, 8, 217, 1, // 1863: decode to BNEC_MMR6 using decoder 217
4037 // 1863: }
4038 // 1863: }
4039 32, 20, // 1868: case 0x20: {
4040 OPC_Scope, 11, // 1870: try {
4041 OPC_CheckField, 21, 5, 0, // 1872: check Inst[25:21] == 0x0
4042 OPC_CheckPredicate, 3, // 1876: check predicate 3
4043 OPC_Decode, 156, 15, 148, 1, // 1878: decode to JIALC_MMR6 using decoder 148
4044 // 1878: } else try {
4045 OPC_CheckPredicate, 3, // 1883: check predicate 3
4046 OPC_Decode, 240, 7, 218, 1, // 1885: decode to BEQZC_MMR6 using decoder 218
4047 // 1885: }
4048 // 1885: }
4049 37, 7, // 1890: case 0x25: {
4050 OPC_CheckPredicate, 3, // 1892: check predicate 3
4051 OPC_Decode, 222, 7, 219, 1, // 1894: decode to BC_MMR6 using decoder 219
4052 // 1894: }
4053 40, 20, // 1899: case 0x28: {
4054 OPC_Scope, 11, // 1901: try {
4055 OPC_CheckField, 21, 5, 0, // 1903: check Inst[25:21] == 0x0
4056 OPC_CheckPredicate, 3, // 1907: check predicate 3
4057 OPC_Decode, 159, 15, 148, 1, // 1909: decode to JIC_MMR6 using decoder 148
4058 // 1909: } else try {
4059 OPC_CheckPredicate, 3, // 1914: check predicate 3
4060 OPC_Decode, 227, 8, 218, 1, // 1916: decode to BNEZC_MMR6 using decoder 218
4061 // 1916: }
4062 // 1916: }
4063 45, 7, // 1921: case 0x2d: {
4064 OPC_CheckPredicate, 3, // 1923: check predicate 3
4065 OPC_Decode, 186, 7, 219, 1, // 1925: decode to BALC_MMR6 using decoder 219
4066 // 1925: }
4067 48, 7, // 1930: case 0x30: {
4068 OPC_CheckPredicate, 3, // 1932: check predicate 3
4069 OPC_Decode, 250, 7, 220, 1, // 1934: decode to BGEUC_MMR6 using decoder 220
4070 // 1934: }
4071 52, 7, // 1939: case 0x34: {
4072 OPC_CheckPredicate, 3, // 1941: check predicate 3
4073 OPC_Decode, 133, 7, 153, 1, // 1943: decode to ANDI_MMR6 using decoder 153
4074 // 1943: }
4075 53, 7, // 1948: case 0x35: {
4076 OPC_CheckPredicate, 3, // 1950: check predicate 3
4077 OPC_Decode, 178, 8, 221, 1, // 1952: decode to BLTC_MMR6 using decoder 221
4078 // 1952: }
4079 56, 7, // 1957: case 0x38: {
4080 OPC_CheckPredicate, 3, // 1959: check predicate 3
4081 OPC_Decode, 184, 8, 222, 1, // 1961: decode to BLTUC_MMR6 using decoder 222
4082 // 1961: }
4083 61, 7, // 1966: case 0x3d: {
4084 OPC_CheckPredicate, 3, // 1968: check predicate 3
4085 OPC_Decode, 244, 7, 223, 1, // 1970: decode to BGEC_MMR6 using decoder 223
4086 // 1970: }
4087 62, 7, // 1975: case 0x3e: {
4088 OPC_CheckPredicate, 3, // 1977: check predicate 3
4089 OPC_Decode, 195, 23, 142, 1, // 1979: decode to SW_MMR6 using decoder 142
4090 // 1979: }
4091 63, 0, // 1984: case 0x3f: {
4092 OPC_CheckPredicate, 3, // 1986: check predicate 3
4093 OPC_Decode, 208, 16, 142, 1, // 1988: decode to LW_MMR6 using decoder 142
4094 // 1988: }
4095 // 1988: } // switch Inst[31:26]
4096};
4097static const uint8_t DecoderTableMicroMipsR6_Ambiguous32[65] = {
4098 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
4099 29, 7, // 3: case 0x1d: {
4100 OPC_CheckPredicate, 3, // 5: check predicate 3
4101 OPC_Decode, 237, 8, 214, 1, // 7: decode to BOVC_MMR6 using decoder 214
4102 // 7: }
4103 31, 7, // 12: case 0x1f: {
4104 OPC_CheckPredicate, 3, // 14: check predicate 3
4105 OPC_Decode, 230, 8, 217, 1, // 16: decode to BNVC_MMR6 using decoder 217
4106 // 16: }
4107 48, 20, // 21: case 0x30: {
4108 OPC_Scope, 11, // 23: try {
4109 OPC_CheckField, 16, 5, 0, // 25: check Inst[20:16] == 0x0
4110 OPC_CheckPredicate, 3, // 29: check predicate 3
4111 OPC_Decode, 170, 8, 220, 1, // 31: decode to BLEZALC_MMR6 using decoder 220
4112 // 31: } else try {
4113 OPC_CheckPredicate, 3, // 36: check predicate 3
4114 OPC_Decode, 128, 8, 220, 1, // 38: decode to BGEZALC_MMR6 using decoder 220
4115 // 38: }
4116 // 38: }
4117 56, 0, // 43: case 0x38: {
4118 OPC_Scope, 11, // 45: try {
4119 OPC_CheckField, 16, 5, 0, // 47: check Inst[20:16] == 0x0
4120 OPC_CheckPredicate, 3, // 51: check predicate 3
4121 OPC_Decode, 140, 8, 222, 1, // 53: decode to BGTZALC_MMR6 using decoder 222
4122 // 53: } else try {
4123 OPC_CheckPredicate, 3, // 58: check predicate 3
4124 OPC_Decode, 190, 8, 222, 1, // 60: decode to BLTZALC_MMR6 using decoder 222
4125 // 60: }
4126 // 60: }
4127 // 60: } // switch Inst[31:26]
4128};
4129static const uint8_t DecoderTableMips32[10278] = {
4130 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
4131 0, 159, 5, // 3: case 0x0: {
4132 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
4133 0, 40, // 9: case 0x0: {
4134 OPC_CheckField, 21, 5, 0, // 11: check Inst[25:21] == 0x0
4135 OPC_Scope, 27, // 15: try {
4136 OPC_SwitchField, 6, 15, // 17: switch Inst[20:6] {
4137 1, 6, // 20: case 0x1: {
4138 OPC_CheckPredicate, 28, // 22: check predicate 28
4139 OPC_Decode, 210, 22, 10, // 24: decode to SSNOP using decoder 10
4140 // 24: }
4141 3, 6, // 28: case 0x3: {
4142 OPC_CheckPredicate, 28, // 30: check predicate 28
4143 OPC_Decode, 235, 12, 10, // 32: decode to EHB using decoder 10
4144 // 32: }
4145 5, 0, // 36: case 0x5: {
4146 OPC_CheckPredicate, 29, // 38: check predicate 29
4147 OPC_Decode, 206, 19, 10, // 40: decode to PAUSE using decoder 10
4148 // 40: }
4149 // 40: } // switch Inst[20:6]
4150 // 40: } else try {
4151 OPC_CheckPredicate, 28, // 44: check predicate 28
4152 OPC_Decode, 244, 21, 224, 1, // 46: decode to SLL using decoder 224
4153 // 46: }
4154 // 46: }
4155 1, 29, // 51: case 0x1: {
4156 OPC_SwitchField, 16, 2, // 53: switch Inst[17:16] {
4157 0, 11, // 56: case 0x0: {
4158 OPC_CheckPredicate, 30, // 58: check predicate 30
4159 OPC_CheckField, 6, 5, 0, // 60: check Inst[10:6] == 0x0
4160 OPC_Decode, 246, 17, 225, 1, // 64: decode to MOVF_I using decoder 225
4161 // 64: }
4162 1, 0, // 69: case 0x1: {
4163 OPC_CheckPredicate, 30, // 71: check predicate 30
4164 OPC_CheckField, 6, 5, 0, // 73: check Inst[10:6] == 0x0
4165 OPC_Decode, 139, 18, 225, 1, // 77: decode to MOVT_I using decoder 225
4166 // 77: }
4167 // 77: } // switch Inst[17:16]
4168 // 77: }
4169 2, 21, // 82: case 0x2: {
4170 OPC_SwitchField, 21, 5, // 84: switch Inst[25:21] {
4171 0, 7, // 87: case 0x0: {
4172 OPC_CheckPredicate, 28, // 89: check predicate 28
4173 OPC_Decode, 185, 22, 224, 1, // 91: decode to SRL using decoder 224
4174 // 91: }
4175 1, 0, // 96: case 0x1: {
4176 OPC_CheckPredicate, 29, // 98: check predicate 29
4177 OPC_Decode, 180, 20, 224, 1, // 100: decode to ROTR using decoder 224
4178 // 100: }
4179 // 100: } // switch Inst[25:21]
4180 // 100: }
4181 3, 11, // 105: case 0x3: {
4182 OPC_CheckPredicate, 28, // 107: check predicate 28
4183 OPC_CheckField, 21, 5, 0, // 109: check Inst[25:21] == 0x0
4184 OPC_Decode, 163, 22, 224, 1, // 113: decode to SRA using decoder 224
4185 // 113: }
4186 4, 10, // 118: case 0x4: {
4187 OPC_CheckPredicate, 28, // 120: check predicate 28
4188 OPC_CheckField, 6, 5, 0, // 122: check Inst[10:6] == 0x0
4189 OPC_Decode, 254, 21, 98, // 126: decode to SLLV using decoder 98
4190 // 126: }
4191 5, 11, // 130: case 0x5: {
4192 OPC_CheckPredicate, 31, // 132: check predicate 31
4193 OPC_CheckField, 8, 3, 0, // 134: check Inst[10:8] == 0x0
4194 OPC_Decode, 147, 16, 226, 1, // 138: decode to LSA using decoder 226
4195 // 138: }
4196 6, 19, // 143: case 0x6: {
4197 OPC_SwitchField, 6, 5, // 145: switch Inst[10:6] {
4198 0, 6, // 148: case 0x0: {
4199 OPC_CheckPredicate, 28, // 150: check predicate 28
4200 OPC_Decode, 201, 22, 98, // 152: decode to SRLV using decoder 98
4201 // 152: }
4202 1, 0, // 156: case 0x1: {
4203 OPC_CheckPredicate, 29, // 158: check predicate 29
4204 OPC_Decode, 181, 20, 98, // 160: decode to ROTRV using decoder 98
4205 // 160: }
4206 // 160: } // switch Inst[10:6]
4207 // 160: }
4208 7, 10, // 164: case 0x7: {
4209 OPC_CheckPredicate, 28, // 166: check predicate 28
4210 OPC_CheckField, 6, 5, 0, // 168: check Inst[10:6] == 0x0
4211 OPC_Decode, 176, 22, 98, // 172: decode to SRAV using decoder 98
4212 // 172: }
4213 8, 21, // 176: case 0x8: {
4214 OPC_SwitchField, 6, 15, // 178: switch Inst[20:6] {
4215 0, 7, // 181: case 0x0: {
4216 OPC_CheckPredicate, 32, // 183: check predicate 32
4217 OPC_Decode, 160, 15, 227, 1, // 185: decode to JR using decoder 227
4218 // 185: }
4219 16, 0, // 190: case 0x10: {
4220 OPC_CheckPredicate, 33, // 192: check predicate 33
4221 OPC_Decode, 168, 15, 227, 1, // 194: decode to JR_HB using decoder 227
4222 // 194: }
4223 // 194: } // switch Inst[20:6]
4224 // 194: }
4225 9, 27, // 199: case 0x9: {
4226 OPC_SwitchField, 6, 5, // 201: switch Inst[10:6] {
4227 0, 10, // 204: case 0x0: {
4228 OPC_CheckPredicate, 34, // 206: check predicate 34
4229 OPC_CheckField, 16, 5, 0, // 208: check Inst[20:16] == 0x0
4230 OPC_Decode, 135, 15, 89, // 212: decode to JALR using decoder 89
4231 // 212: }
4232 16, 0, // 216: case 0x10: {
4233 OPC_CheckPredicate, 35, // 218: check predicate 35
4234 OPC_CheckField, 16, 5, 0, // 220: check Inst[20:16] == 0x0
4235 OPC_Decode, 146, 15, 89, // 224: decode to JALR_HB using decoder 89
4236 // 224: }
4237 // 224: } // switch Inst[10:6]
4238 // 224: }
4239 10, 11, // 228: case 0xa: {
4240 OPC_CheckPredicate, 36, // 230: check predicate 36
4241 OPC_CheckField, 6, 5, 0, // 232: check Inst[10:6] == 0x0
4242 OPC_Decode, 151, 18, 228, 1, // 236: decode to MOVZ_I_I using decoder 228
4243 // 236: }
4244 11, 11, // 241: case 0xb: {
4245 OPC_CheckPredicate, 36, // 243: check predicate 36
4246 OPC_CheckField, 6, 5, 0, // 245: check Inst[10:6] == 0x0
4247 OPC_Decode, 130, 18, 228, 1, // 249: decode to MOVN_I_I using decoder 228
4248 // 249: }
4249 12, 7, // 254: case 0xc: {
4250 OPC_CheckPredicate, 28, // 256: check predicate 28
4251 OPC_Decode, 207, 23, 229, 1, // 258: decode to SYSCALL using decoder 229
4252 // 258: }
4253 13, 6, // 263: case 0xd: {
4254 OPC_CheckPredicate, 28, // 265: check predicate 28
4255 OPC_Decode, 241, 8, 99, // 267: decode to BREAK using decoder 99
4256 // 267: }
4257 15, 7, // 271: case 0xf: {
4258 OPC_CheckPredicate, 37, // 273: check predicate 37
4259 OPC_Decode, 198, 23, 230, 1, // 275: decode to SYNC using decoder 230
4260 // 275: }
4261 16, 32, // 280: case 0x10: {
4262 OPC_CheckField, 6, 5, 0, // 282: check Inst[10:6] == 0x0
4263 OPC_CheckField, 16, 5, 0, // 286: check Inst[20:16] == 0x0
4264 OPC_CheckField, 23, 3, 0, // 290: check Inst[25:23] == 0x0
4265 OPC_Scope, 11, // 294: try {
4266 OPC_CheckField, 21, 2, 0, // 296: check Inst[22:21] == 0x0
4267 OPC_CheckPredicate, 32, // 300: check predicate 32
4268 OPC_Decode, 177, 17, 231, 1, // 302: decode to MFHI using decoder 231
4269 // 302: } else try {
4270 OPC_CheckPredicate, 38, // 307: check predicate 38
4271 OPC_Decode, 180, 17, 232, 1, // 309: decode to MFHI_DSP using decoder 232
4272 // 309: }
4273 // 309: }
4274 17, 28, // 314: case 0x11: {
4275 OPC_CheckField, 6, 5, 0, // 316: check Inst[10:6] == 0x0
4276 OPC_CheckField, 13, 8, 0, // 320: check Inst[20:13] == 0x0
4277 OPC_Scope, 11, // 324: try {
4278 OPC_CheckField, 11, 2, 0, // 326: check Inst[12:11] == 0x0
4279 OPC_CheckPredicate, 32, // 330: check predicate 32
4280 OPC_Decode, 204, 18, 227, 1, // 332: decode to MTHI using decoder 227
4281 // 332: } else try {
4282 OPC_CheckPredicate, 38, // 337: check predicate 38
4283 OPC_Decode, 206, 18, 233, 1, // 339: decode to MTHI_DSP using decoder 233
4284 // 339: }
4285 // 339: }
4286 18, 32, // 344: case 0x12: {
4287 OPC_CheckField, 6, 5, 0, // 346: check Inst[10:6] == 0x0
4288 OPC_CheckField, 16, 5, 0, // 350: check Inst[20:16] == 0x0
4289 OPC_CheckField, 23, 3, 0, // 354: check Inst[25:23] == 0x0
4290 OPC_Scope, 11, // 358: try {
4291 OPC_CheckField, 21, 2, 0, // 360: check Inst[22:21] == 0x0
4292 OPC_CheckPredicate, 32, // 364: check predicate 32
4293 OPC_Decode, 183, 17, 231, 1, // 366: decode to MFLO using decoder 231
4294 // 366: } else try {
4295 OPC_CheckPredicate, 38, // 371: check predicate 38
4296 OPC_Decode, 186, 17, 232, 1, // 373: decode to MFLO_DSP using decoder 232
4297 // 373: }
4298 // 373: }
4299 19, 28, // 378: case 0x13: {
4300 OPC_CheckField, 6, 5, 0, // 380: check Inst[10:6] == 0x0
4301 OPC_CheckField, 13, 8, 0, // 384: check Inst[20:13] == 0x0
4302 OPC_Scope, 11, // 388: try {
4303 OPC_CheckField, 11, 2, 0, // 390: check Inst[12:11] == 0x0
4304 OPC_CheckPredicate, 32, // 394: check predicate 32
4305 OPC_Decode, 211, 18, 227, 1, // 396: decode to MTLO using decoder 227
4306 // 396: } else try {
4307 OPC_CheckPredicate, 38, // 401: check predicate 38
4308 OPC_Decode, 213, 18, 234, 1, // 403: decode to MTLO_DSP using decoder 234
4309 // 403: }
4310 // 403: }
4311 21, 11, // 408: case 0x15: {
4312 OPC_CheckPredicate, 39, // 410: check predicate 39
4313 OPC_CheckField, 8, 3, 0, // 412: check Inst[10:8] == 0x0
4314 OPC_Decode, 137, 12, 235, 1, // 416: decode to DLSA using decoder 235
4315 // 416: }
4316 24, 27, // 421: case 0x18: {
4317 OPC_CheckField, 6, 5, 0, // 423: check Inst[10:6] == 0x0
4318 OPC_CheckField, 13, 3, 0, // 427: check Inst[15:13] == 0x0
4319 OPC_Scope, 10, // 431: try {
4320 OPC_CheckField, 11, 2, 0, // 433: check Inst[12:11] == 0x0
4321 OPC_CheckPredicate, 32, // 437: check predicate 32
4322 OPC_Decode, 254, 18, 123, // 439: decode to MULT using decoder 123
4323 // 439: } else try {
4324 OPC_CheckPredicate, 38, // 443: check predicate 38
4325 OPC_Decode, 129, 19, 236, 1, // 445: decode to MULT_DSP using decoder 236
4326 // 445: }
4327 // 445: }
4328 25, 27, // 450: case 0x19: {
4329 OPC_CheckField, 6, 5, 0, // 452: check Inst[10:6] == 0x0
4330 OPC_CheckField, 13, 3, 0, // 456: check Inst[15:13] == 0x0
4331 OPC_Scope, 10, // 460: try {
4332 OPC_CheckField, 11, 2, 0, // 462: check Inst[12:11] == 0x0
4333 OPC_CheckPredicate, 32, // 466: check predicate 32
4334 OPC_Decode, 132, 19, 123, // 468: decode to MULTu using decoder 123
4335 // 468: } else try {
4336 OPC_CheckPredicate, 38, // 472: check predicate 38
4337 OPC_Decode, 255, 18, 236, 1, // 474: decode to MULTU_DSP using decoder 236
4338 // 474: }
4339 // 474: }
4340 26, 10, // 479: case 0x1a: {
4341 OPC_CheckPredicate, 32, // 481: check predicate 32
4342 OPC_CheckField, 6, 10, 0, // 483: check Inst[15:6] == 0x0
4343 OPC_Decode, 133, 21, 123, // 487: decode to SDIV using decoder 123
4344 // 487: }
4345 27, 10, // 491: case 0x1b: {
4346 OPC_CheckPredicate, 32, // 493: check predicate 32
4347 OPC_CheckField, 6, 10, 0, // 495: check Inst[15:6] == 0x0
4348 OPC_Decode, 171, 24, 123, // 499: decode to UDIV using decoder 123
4349 // 499: }
4350 32, 10, // 503: case 0x20: {
4351 OPC_CheckPredicate, 28, // 505: check predicate 28
4352 OPC_CheckField, 6, 5, 0, // 507: check Inst[10:6] == 0x0
4353 OPC_Decode, 157, 6, 104, // 511: decode to ADD using decoder 104
4354 // 511: }
4355 33, 10, // 515: case 0x21: {
4356 OPC_CheckPredicate, 28, // 517: check predicate 28
4357 OPC_CheckField, 6, 5, 0, // 519: check Inst[10:6] == 0x0
4358 OPC_Decode, 242, 6, 104, // 523: decode to ADDu using decoder 104
4359 // 523: }
4360 34, 10, // 527: case 0x22: {
4361 OPC_CheckPredicate, 28, // 529: check predicate 28
4362 OPC_CheckField, 6, 5, 0, // 531: check Inst[10:6] == 0x0
4363 OPC_Decode, 217, 22, 104, // 535: decode to SUB using decoder 104
4364 // 535: }
4365 35, 10, // 539: case 0x23: {
4366 OPC_CheckPredicate, 28, // 541: check predicate 28
4367 OPC_CheckField, 6, 5, 0, // 543: check Inst[10:6] == 0x0
4368 OPC_Decode, 146, 23, 104, // 547: decode to SUBu using decoder 104
4369 // 547: }
4370 36, 10, // 551: case 0x24: {
4371 OPC_CheckPredicate, 28, // 553: check predicate 28
4372 OPC_CheckField, 6, 5, 0, // 555: check Inst[10:6] == 0x0
4373 OPC_Decode, 252, 6, 104, // 559: decode to AND using decoder 104
4374 // 559: }
4375 37, 10, // 563: case 0x25: {
4376 OPC_CheckPredicate, 28, // 565: check predicate 28
4377 OPC_CheckField, 6, 5, 0, // 567: check Inst[10:6] == 0x0
4378 OPC_Decode, 188, 19, 104, // 571: decode to OR using decoder 104
4379 // 571: }
4380 38, 10, // 575: case 0x26: {
4381 OPC_CheckPredicate, 28, // 577: check predicate 28
4382 OPC_CheckField, 6, 5, 0, // 579: check Inst[10:6] == 0x0
4383 OPC_Decode, 191, 24, 104, // 583: decode to XOR using decoder 104
4384 // 583: }
4385 39, 10, // 587: case 0x27: {
4386 OPC_CheckPredicate, 28, // 589: check predicate 28
4387 OPC_CheckField, 6, 5, 0, // 591: check Inst[10:6] == 0x0
4388 OPC_Decode, 176, 19, 104, // 595: decode to NOR using decoder 104
4389 // 595: }
4390 42, 10, // 599: case 0x2a: {
4391 OPC_CheckPredicate, 28, // 601: check predicate 28
4392 OPC_CheckField, 6, 5, 0, // 603: check Inst[10:6] == 0x0
4393 OPC_Decode, 136, 22, 104, // 607: decode to SLT using decoder 104
4394 // 607: }
4395 43, 10, // 611: case 0x2b: {
4396 OPC_CheckPredicate, 28, // 613: check predicate 28
4397 OPC_CheckField, 6, 5, 0, // 615: check Inst[10:6] == 0x0
4398 OPC_Decode, 149, 22, 104, // 619: decode to SLTu using decoder 104
4399 // 619: }
4400 48, 7, // 623: case 0x30: {
4401 OPC_CheckPredicate, 37, // 625: check predicate 37
4402 OPC_Decode, 237, 23, 237, 1, // 627: decode to TGE using decoder 237
4403 // 627: }
4404 49, 7, // 632: case 0x31: {
4405 OPC_CheckPredicate, 37, // 634: check predicate 37
4406 OPC_Decode, 242, 23, 237, 1, // 636: decode to TGEU using decoder 237
4407 // 636: }
4408 50, 7, // 641: case 0x32: {
4409 OPC_CheckPredicate, 37, // 643: check predicate 37
4410 OPC_Decode, 141, 24, 237, 1, // 645: decode to TLT using decoder 237
4411 // 645: }
4412 51, 7, // 650: case 0x33: {
4413 OPC_CheckPredicate, 37, // 652: check predicate 37
4414 OPC_Decode, 145, 24, 237, 1, // 654: decode to TLTU using decoder 237
4415 // 654: }
4416 52, 7, // 659: case 0x34: {
4417 OPC_CheckPredicate, 37, // 661: check predicate 37
4418 OPC_Decode, 232, 23, 237, 1, // 663: decode to TEQ using decoder 237
4419 // 663: }
4420 54, 0, // 668: case 0x36: {
4421 OPC_CheckPredicate, 37, // 670: check predicate 37
4422 OPC_Decode, 148, 24, 237, 1, // 672: decode to TNE using decoder 237
4423 // 672: }
4424 // 672: } // switch Inst[5:0]
4425 // 672: }
4426 1, 151, 1, // 677: case 0x1: {
4427 OPC_SwitchField, 16, 5, // 680: switch Inst[20:16] {
4428 0, 7, // 683: case 0x0: {
4429 OPC_CheckPredicate, 28, // 685: check predicate 28
4430 OPC_Decode, 186, 8, 238, 1, // 687: decode to BLTZ using decoder 238
4431 // 687: }
4432 1, 7, // 692: case 0x1: {
4433 OPC_CheckPredicate, 28, // 694: check predicate 28
4434 OPC_Decode, 252, 7, 238, 1, // 696: decode to BGEZ using decoder 238
4435 // 696: }
4436 2, 7, // 701: case 0x2: {
4437 OPC_CheckPredicate, 40, // 703: check predicate 40
4438 OPC_Decode, 197, 8, 238, 1, // 705: decode to BLTZL using decoder 238
4439 // 705: }
4440 3, 7, // 710: case 0x3: {
4441 OPC_CheckPredicate, 40, // 712: check predicate 40
4442 OPC_Decode, 135, 8, 238, 1, // 714: decode to BGEZL using decoder 238
4443 // 714: }
4444 8, 7, // 719: case 0x8: {
4445 OPC_CheckPredicate, 40, // 721: check predicate 40
4446 OPC_Decode, 238, 23, 216, 1, // 723: decode to TGEI using decoder 216
4447 // 723: }
4448 9, 7, // 728: case 0x9: {
4449 OPC_CheckPredicate, 40, // 730: check predicate 40
4450 OPC_Decode, 239, 23, 216, 1, // 732: decode to TGEIU using decoder 216
4451 // 732: }
4452 10, 7, // 737: case 0xa: {
4453 OPC_CheckPredicate, 40, // 739: check predicate 40
4454 OPC_Decode, 142, 24, 216, 1, // 741: decode to TLTI using decoder 216
4455 // 741: }
4456 11, 7, // 746: case 0xb: {
4457 OPC_CheckPredicate, 40, // 748: check predicate 40
4458 OPC_Decode, 164, 24, 216, 1, // 750: decode to TTLTIU using decoder 216
4459 // 750: }
4460 12, 7, // 755: case 0xc: {
4461 OPC_CheckPredicate, 40, // 757: check predicate 40
4462 OPC_Decode, 233, 23, 216, 1, // 759: decode to TEQI using decoder 216
4463 // 759: }
4464 14, 7, // 764: case 0xe: {
4465 OPC_CheckPredicate, 40, // 766: check predicate 40
4466 OPC_Decode, 149, 24, 216, 1, // 768: decode to TNEI using decoder 216
4467 // 768: }
4468 16, 7, // 773: case 0x10: {
4469 OPC_CheckPredicate, 32, // 775: check predicate 32
4470 OPC_Decode, 188, 8, 238, 1, // 777: decode to BLTZAL using decoder 238
4471 // 777: }
4472 17, 7, // 782: case 0x11: {
4473 OPC_CheckPredicate, 32, // 784: check predicate 32
4474 OPC_Decode, 254, 7, 238, 1, // 786: decode to BGEZAL using decoder 238
4475 // 786: }
4476 18, 7, // 791: case 0x12: {
4477 OPC_CheckPredicate, 40, // 793: check predicate 40
4478 OPC_Decode, 191, 8, 238, 1, // 795: decode to BLTZALL using decoder 238
4479 // 795: }
4480 19, 7, // 800: case 0x13: {
4481 OPC_CheckPredicate, 40, // 802: check predicate 40
4482 OPC_Decode, 129, 8, 238, 1, // 804: decode to BGEZALL using decoder 238
4483 // 804: }
4484 28, 11, // 809: case 0x1c: {
4485 OPC_CheckPredicate, 41, // 811: check predicate 41
4486 OPC_CheckField, 21, 5, 0, // 813: check Inst[25:21] == 0x0
4487 OPC_Decode, 238, 8, 239, 1, // 817: decode to BPOSGE32 using decoder 239
4488 // 817: }
4489 31, 0, // 822: case 0x1f: {
4490 OPC_CheckPredicate, 29, // 824: check predicate 29
4491 OPC_Decode, 199, 23, 240, 1, // 826: decode to SYNCI using decoder 240
4492 // 826: }
4493 // 826: } // switch Inst[20:16]
4494 // 826: }
4495 2, 7, // 831: case 0x2: {
4496 OPC_CheckPredicate, 28, // 833: check predicate 28
4497 OPC_Decode, 133, 15, 241, 1, // 835: decode to J using decoder 241
4498 // 835: }
4499 3, 7, // 840: case 0x3: {
4500 OPC_CheckPredicate, 28, // 842: check predicate 28
4501 OPC_Decode, 134, 15, 241, 1, // 844: decode to JAL using decoder 241
4502 // 844: }
4503 4, 7, // 849: case 0x4: {
4504 OPC_CheckPredicate, 28, // 851: check predicate 28
4505 OPC_Decode, 224, 7, 242, 1, // 853: decode to BEQ using decoder 242
4506 // 853: }
4507 5, 7, // 858: case 0x5: {
4508 OPC_CheckPredicate, 28, // 860: check predicate 28
4509 OPC_Decode, 203, 8, 242, 1, // 862: decode to BNE using decoder 242
4510 // 862: }
4511 6, 11, // 867: case 0x6: {
4512 OPC_CheckPredicate, 28, // 869: check predicate 28
4513 OPC_CheckField, 16, 5, 0, // 871: check Inst[20:16] == 0x0
4514 OPC_Decode, 167, 8, 238, 1, // 875: decode to BLEZ using decoder 238
4515 // 875: }
4516 7, 11, // 880: case 0x7: {
4517 OPC_CheckPredicate, 28, // 882: check predicate 28
4518 OPC_CheckField, 16, 5, 0, // 884: check Inst[20:16] == 0x0
4519 OPC_Decode, 137, 8, 238, 1, // 888: decode to BGTZ using decoder 238
4520 // 888: }
4521 8, 7, // 893: case 0x8: {
4522 OPC_CheckPredicate, 32, // 895: check predicate 32
4523 OPC_Decode, 238, 6, 243, 1, // 897: decode to ADDi using decoder 243
4524 // 897: }
4525 9, 7, // 902: case 0x9: {
4526 OPC_CheckPredicate, 28, // 904: check predicate 28
4527 OPC_Decode, 240, 6, 243, 1, // 906: decode to ADDiu using decoder 243
4528 // 906: }
4529 10, 7, // 911: case 0xa: {
4530 OPC_CheckPredicate, 28, // 913: check predicate 28
4531 OPC_Decode, 143, 22, 243, 1, // 915: decode to SLTi using decoder 243
4532 // 915: }
4533 11, 7, // 920: case 0xb: {
4534 OPC_CheckPredicate, 28, // 922: check predicate 28
4535 OPC_Decode, 146, 22, 243, 1, // 924: decode to SLTiu using decoder 243
4536 // 924: }
4537 12, 7, // 929: case 0xc: {
4538 OPC_CheckPredicate, 28, // 931: check predicate 28
4539 OPC_Decode, 139, 7, 244, 1, // 933: decode to ANDi using decoder 244
4540 // 933: }
4541 13, 7, // 938: case 0xd: {
4542 OPC_CheckPredicate, 28, // 940: check predicate 28
4543 OPC_Decode, 200, 19, 244, 1, // 942: decode to ORi using decoder 244
4544 // 942: }
4545 14, 7, // 947: case 0xe: {
4546 OPC_CheckPredicate, 28, // 949: check predicate 28
4547 OPC_Decode, 203, 24, 244, 1, // 951: decode to XORi using decoder 244
4548 // 951: }
4549 15, 11, // 956: case 0xf: {
4550 OPC_CheckPredicate, 28, // 958: check predicate 28
4551 OPC_CheckField, 21, 5, 0, // 960: check Inst[25:21] == 0x0
4552 OPC_Decode, 156, 16, 148, 1, // 964: decode to LUi using decoder 148
4553 // 964: }
4554 16, 171, 3, // 969: case 0x10: {
4555 OPC_SwitchField, 3, 1, // 972: switch Inst[3] {
4556 0, 141, 2, // 975: case 0x0: {
4557 OPC_SwitchField, 21, 5, // 978: switch Inst[25:21] {
4558 0, 11, // 981: case 0x0: {
4559 OPC_CheckPredicate, 28, // 983: check predicate 28
4560 OPC_CheckField, 4, 7, 0, // 985: check Inst[10:4] == 0x0
4561 OPC_Decode, 156, 17, 245, 1, // 989: decode to MFC0 using decoder 245
4562 // 989: }
4563 3, 39, // 994: case 0x3: {
4564 OPC_SwitchField, 4, 7, // 996: switch Inst[10:4] {
4565 0, 7, // 999: case 0x0: {
4566 OPC_CheckPredicate, 42, // 1001: check predicate 42
4567 OPC_Decode, 166, 17, 245, 1, // 1003: decode to MFGC0 using decoder 245
4568 // 1003: }
4569 32, 7, // 1008: case 0x20: {
4570 OPC_CheckPredicate, 42, // 1010: check predicate 42
4571 OPC_Decode, 193, 18, 246, 1, // 1012: decode to MTGC0 using decoder 246
4572 // 1012: }
4573 64, 7, // 1017: case 0x40: {
4574 OPC_CheckPredicate, 42, // 1019: check predicate 42
4575 OPC_Decode, 175, 17, 245, 1, // 1021: decode to MFHGC0 using decoder 245
4576 // 1021: }
4577 96, 0, // 1026: case 0x60: {
4578 OPC_CheckPredicate, 42, // 1028: check predicate 42
4579 OPC_Decode, 202, 18, 246, 1, // 1030: decode to MTHGC0 using decoder 246
4580 // 1030: }
4581 // 1030: } // switch Inst[10:4]
4582 // 1030: }
4583 4, 11, // 1035: case 0x4: {
4584 OPC_CheckPredicate, 28, // 1037: check predicate 28
4585 OPC_CheckField, 4, 7, 0, // 1039: check Inst[10:4] == 0x0
4586 OPC_Decode, 182, 18, 246, 1, // 1043: decode to MTC0 using decoder 246
4587 // 1043: }
4588 8, 11, // 1048: case 0x8: {
4589 OPC_CheckPredicate, 43, // 1050: check predicate 43
4590 OPC_CheckField, 6, 5, 0, // 1052: check Inst[10:6] == 0x0
4591 OPC_Decode, 189, 17, 247, 1, // 1056: decode to MFTR using decoder 247
4592 // 1056: }
4593 11, 85, // 1061: case 0xb: {
4594 OPC_SwitchField, 4, 12, // 1063: switch Inst[15:4] {
4595 0, 11, // 1066: case 0x0: {
4596 OPC_CheckPredicate, 43, // 1068: check predicate 43
4597 OPC_CheckField, 0, 3, 1, // 1070: check Inst[2:0] == 0x1
4598 OPC_Decode, 230, 12, 136, 1, // 1074: decode to DVPE using decoder 136
4599 // 1074: }
4600 2, 11, // 1079: case 0x2: {
4601 OPC_CheckPredicate, 43, // 1081: check predicate 43
4602 OPC_CheckField, 0, 3, 1, // 1083: check Inst[2:0] == 0x1
4603 OPC_Decode, 252, 12, 136, 1, // 1087: decode to EVPE using decoder 136
4604 // 1087: }
4605 188, 1, 11, // 1092: case 0xbc: {
4606 OPC_CheckPredicate, 43, // 1095: check predicate 43
4607 OPC_CheckField, 0, 3, 1, // 1097: check Inst[2:0] == 0x1
4608 OPC_Decode, 146, 12, 136, 1, // 1101: decode to DMT using decoder 136
4609 // 1101: }
4610 190, 1, 11, // 1106: case 0xbe: {
4611 OPC_CheckPredicate, 43, // 1109: check predicate 43
4612 OPC_CheckField, 0, 3, 1, // 1111: check Inst[2:0] == 0x1
4613 OPC_Decode, 243, 12, 136, 1, // 1115: decode to EMT using decoder 136
4614 // 1115: }
4615 128, 12, 11, // 1120: case 0x600: {
4616 OPC_CheckPredicate, 29, // 1123: check predicate 29
4617 OPC_CheckField, 0, 3, 0, // 1125: check Inst[2:0] == 0x0
4618 OPC_Decode, 244, 11, 136, 1, // 1129: decode to DI using decoder 136
4619 // 1129: }
4620 130, 12, 0, // 1134: case 0x602: {
4621 OPC_CheckPredicate, 29, // 1137: check predicate 29
4622 OPC_CheckField, 0, 3, 0, // 1139: check Inst[2:0] == 0x0
4623 OPC_Decode, 239, 12, 136, 1, // 1143: decode to EI using decoder 136
4624 // 1143: }
4625 // 1143: } // switch Inst[15:4]
4626 // 1143: }
4627 12, 11, // 1148: case 0xc: {
4628 OPC_CheckPredicate, 43, // 1150: check predicate 43
4629 OPC_CheckField, 6, 5, 0, // 1152: check Inst[10:6] == 0x0
4630 OPC_Decode, 222, 18, 247, 1, // 1156: decode to MTTR using decoder 247
4631 // 1156: }
4632 16, 0, // 1161: case 0x10: {
4633 OPC_SwitchField, 0, 3, // 1163: switch Inst[2:0] {
4634 0, 19, // 1166: case 0x0: {
4635 OPC_SwitchField, 4, 17, // 1168: switch Inst[20:4] {
4636 1, 6, // 1171: case 0x1: {
4637 OPC_CheckPredicate, 42, // 1173: check predicate 42
4638 OPC_Decode, 249, 23, 10, // 1175: decode to TLBGP using decoder 10
4639 // 1175: }
4640 2, 0, // 1179: case 0x2: {
4641 OPC_CheckPredicate, 44, // 1181: check predicate 44
4642 OPC_Decode, 180, 24, 10, // 1183: decode to WAIT using decoder 10
4643 // 1183: }
4644 // 1183: } // switch Inst[20:4]
4645 // 1183: }
4646 1, 10, // 1187: case 0x1: {
4647 OPC_CheckPredicate, 28, // 1189: check predicate 28
4648 OPC_CheckField, 4, 17, 0, // 1191: check Inst[20:4] == 0x0
4649 OPC_Decode, 135, 24, 10, // 1195: decode to TLBR using decoder 10
4650 // 1195: }
4651 2, 10, // 1199: case 0x2: {
4652 OPC_CheckPredicate, 28, // 1201: check predicate 28
4653 OPC_CheckField, 4, 17, 0, // 1203: check Inst[20:4] == 0x0
4654 OPC_Decode, 137, 24, 10, // 1207: decode to TLBWI using decoder 10
4655 // 1207: }
4656 3, 10, // 1211: case 0x3: {
4657 OPC_CheckPredicate, 45, // 1213: check predicate 45
4658 OPC_CheckField, 4, 17, 0, // 1215: check Inst[20:4] == 0x0
4659 OPC_Decode, 129, 24, 10, // 1219: decode to TLBINV using decoder 10
4660 // 1219: }
4661 4, 10, // 1223: case 0x4: {
4662 OPC_CheckPredicate, 45, // 1225: check predicate 45
4663 OPC_CheckField, 4, 17, 0, // 1227: check Inst[20:4] == 0x0
4664 OPC_Decode, 130, 24, 10, // 1231: decode to TLBINVF using decoder 10
4665 // 1231: }
4666 6, 0, // 1235: case 0x6: {
4667 OPC_CheckPredicate, 28, // 1237: check predicate 28
4668 OPC_CheckField, 4, 17, 0, // 1239: check Inst[20:4] == 0x0
4669 OPC_Decode, 139, 24, 10, // 1243: decode to TLBWR using decoder 10
4670 // 1243: }
4671 // 1243: } // switch Inst[2:0]
4672 // 1243: }
4673 // 1243: } // switch Inst[25:21]
4674 // 1243: }
4675 1, 0, // 1247: case 0x1: {
4676 OPC_SwitchField, 0, 3, // 1249: switch Inst[2:0] {
4677 0, 55, // 1252: case 0x0: {
4678 OPC_SwitchField, 4, 2, // 1254: switch Inst[5:4] {
4679 0, 12, // 1257: case 0x0: {
4680 OPC_CheckPredicate, 28, // 1259: check predicate 28
4681 OPC_CheckField, 6, 20, 128, 128, 32, // 1261: check Inst[25:6] == 0x80000
4682 OPC_Decode, 133, 24, 10, // 1267: decode to TLBP using decoder 10
4683 // 1267: }
4684 1, 23, // 1271: case 0x1: {
4685 OPC_SwitchField, 6, 20, // 1273: switch Inst[25:6] {
4686 128, 128, 32, 6, // 1276: case 0x80000: {
4687 OPC_CheckPredicate, 44, // 1280: check predicate 44
4688 OPC_Decode, 244, 12, 10, // 1282: decode to ERET using decoder 10
4689 // 1282: }
4690 129, 128, 32, 0, // 1286: case 0x80001: {
4691 OPC_CheckPredicate, 46, // 1290: check predicate 46
4692 OPC_Decode, 245, 12, 10, // 1292: decode to ERETNC using decoder 10
4693 // 1292: }
4694 // 1292: } // switch Inst[25:6]
4695 // 1292: }
4696 2, 0, // 1296: case 0x2: {
4697 OPC_CheckPredicate, 42, // 1298: check predicate 42
4698 OPC_CheckField, 25, 1, 1, // 1300: check Inst[25] == 0x1
4699 OPC_Decode, 229, 14, 248, 1, // 1304: decode to HYPCALL using decoder 248
4700 // 1304: }
4701 // 1304: } // switch Inst[5:4]
4702 // 1304: }
4703 1, 13, // 1309: case 0x1: {
4704 OPC_CheckPredicate, 42, // 1311: check predicate 42
4705 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1313: check Inst[25:4] == 0x200000
4706 OPC_Decode, 251, 23, 10, // 1320: decode to TLBGR using decoder 10
4707 // 1320: }
4708 2, 13, // 1324: case 0x2: {
4709 OPC_CheckPredicate, 42, // 1326: check predicate 42
4710 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1328: check Inst[25:4] == 0x200000
4711 OPC_Decode, 253, 23, 10, // 1335: decode to TLBGWI using decoder 10
4712 // 1335: }
4713 3, 13, // 1339: case 0x3: {
4714 OPC_CheckPredicate, 42, // 1341: check predicate 42
4715 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1343: check Inst[25:4] == 0x200000
4716 OPC_Decode, 245, 23, 10, // 1350: decode to TLBGINV using decoder 10
4717 // 1350: }
4718 4, 13, // 1354: case 0x4: {
4719 OPC_CheckPredicate, 42, // 1356: check predicate 42
4720 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1358: check Inst[25:4] == 0x200000
4721 OPC_Decode, 246, 23, 10, // 1365: decode to TLBGINVF using decoder 10
4722 // 1365: }
4723 6, 13, // 1369: case 0x6: {
4724 OPC_CheckPredicate, 42, // 1371: check predicate 42
4725 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1373: check Inst[25:4] == 0x200000
4726 OPC_Decode, 255, 23, 10, // 1380: decode to TLBGWR using decoder 10
4727 // 1380: }
4728 7, 0, // 1384: case 0x7: {
4729 OPC_CheckPredicate, 47, // 1386: check predicate 47
4730 OPC_CheckField, 4, 22, 129, 128, 128, 1, // 1388: check Inst[25:4] == 0x200001
4731 OPC_Decode, 236, 11, 10, // 1395: decode to DERET using decoder 10
4732 // 1395: }
4733 // 1395: } // switch Inst[2:0]
4734 // 1395: }
4735 // 1395: } // switch Inst[3]
4736 // 1395: }
4737 17, 165, 9, // 1399: case 0x11: {
4738 OPC_SwitchField, 21, 5, // 1402: switch Inst[25:21] {
4739 0, 11, // 1405: case 0x0: {
4740 OPC_CheckPredicate, 48, // 1407: check predicate 48
4741 OPC_CheckField, 0, 11, 0, // 1409: check Inst[10:0] == 0x0
4742 OPC_Decode, 160, 17, 249, 1, // 1413: decode to MFC1 using decoder 249
4743 // 1413: }
4744 1, 11, // 1418: case 0x1: {
4745 OPC_CheckPredicate, 49, // 1420: check predicate 49
4746 OPC_CheckField, 0, 11, 0, // 1422: check Inst[10:0] == 0x0
4747 OPC_Decode, 140, 12, 250, 1, // 1426: decode to DMFC1 using decoder 250
4748 // 1426: }
4749 2, 11, // 1431: case 0x2: {
4750 OPC_CheckPredicate, 48, // 1433: check predicate 48
4751 OPC_CheckField, 0, 11, 0, // 1435: check Inst[10:0] == 0x0
4752 OPC_Decode, 174, 9, 251, 1, // 1439: decode to CFC1 using decoder 251
4753 // 1439: }
4754 3, 11, // 1444: case 0x3: {
4755 OPC_CheckPredicate, 50, // 1446: check predicate 50
4756 OPC_CheckField, 0, 11, 0, // 1448: check Inst[10:0] == 0x0
4757 OPC_Decode, 170, 17, 252, 1, // 1452: decode to MFHC1_D32 using decoder 252
4758 // 1452: }
4759 4, 11, // 1457: case 0x4: {
4760 OPC_CheckPredicate, 48, // 1459: check predicate 48
4761 OPC_CheckField, 0, 11, 0, // 1461: check Inst[10:0] == 0x0
4762 OPC_Decode, 186, 18, 253, 1, // 1465: decode to MTC1 using decoder 253
4763 // 1465: }
4764 5, 11, // 1470: case 0x5: {
4765 OPC_CheckPredicate, 49, // 1472: check predicate 49
4766 OPC_CheckField, 0, 11, 0, // 1474: check Inst[10:0] == 0x0
4767 OPC_Decode, 148, 12, 254, 1, // 1478: decode to DMTC1 using decoder 254
4768 // 1478: }
4769 6, 11, // 1483: case 0x6: {
4770 OPC_CheckPredicate, 48, // 1485: check predicate 48
4771 OPC_CheckField, 0, 11, 0, // 1487: check Inst[10:0] == 0x0
4772 OPC_Decode, 209, 10, 255, 1, // 1491: decode to CTC1 using decoder 255
4773 // 1491: }
4774 7, 11, // 1496: case 0x7: {
4775 OPC_CheckPredicate, 50, // 1498: check predicate 50
4776 OPC_CheckField, 0, 11, 0, // 1500: check Inst[10:0] == 0x0
4777 OPC_Decode, 197, 18, 128, 2, // 1504: decode to MTHC1_D32 using decoder 256
4778 // 1504: }
4779 8, 39, // 1509: case 0x8: {
4780 OPC_SwitchField, 16, 2, // 1511: switch Inst[17:16] {
4781 0, 7, // 1514: case 0x0: {
4782 OPC_CheckPredicate, 51, // 1516: check predicate 51
4783 OPC_Decode, 202, 7, 129, 2, // 1518: decode to BC1F using decoder 257
4784 // 1518: }
4785 1, 7, // 1523: case 0x1: {
4786 OPC_CheckPredicate, 51, // 1525: check predicate 51
4787 OPC_Decode, 207, 7, 129, 2, // 1527: decode to BC1T using decoder 257
4788 // 1527: }
4789 2, 7, // 1532: case 0x2: {
4790 OPC_CheckPredicate, 52, // 1534: check predicate 52
4791 OPC_Decode, 203, 7, 129, 2, // 1536: decode to BC1FL using decoder 257
4792 // 1536: }
4793 3, 0, // 1541: case 0x3: {
4794 OPC_CheckPredicate, 52, // 1543: check predicate 52
4795 OPC_Decode, 208, 7, 129, 2, // 1545: decode to BC1TL using decoder 257
4796 // 1545: }
4797 // 1545: } // switch Inst[17:16]
4798 // 1545: }
4799 11, 7, // 1550: case 0xb: {
4800 OPC_CheckPredicate, 31, // 1552: check predicate 31
4801 OPC_Decode, 135, 9, 130, 2, // 1554: decode to BZ_V using decoder 258
4802 // 1554: }
4803 15, 7, // 1559: case 0xf: {
4804 OPC_CheckPredicate, 31, // 1561: check predicate 31
4805 OPC_Decode, 234, 8, 130, 2, // 1563: decode to BNZ_V using decoder 258
4806 // 1563: }
4807 16, 201, 3, // 1568: case 0x10: {
4808 OPC_SwitchField, 0, 6, // 1571: switch Inst[5:0] {
4809 0, 7, // 1574: case 0x0: {
4810 OPC_CheckPredicate, 48, // 1576: check predicate 48
4811 OPC_Decode, 170, 13, 131, 2, // 1578: decode to FADD_S using decoder 259
4812 // 1578: }
4813 1, 7, // 1583: case 0x1: {
4814 OPC_CheckPredicate, 48, // 1585: check predicate 48
4815 OPC_Decode, 187, 14, 131, 2, // 1587: decode to FSUB_S using decoder 259
4816 // 1587: }
4817 2, 7, // 1592: case 0x2: {
4818 OPC_CheckPredicate, 48, // 1594: check predicate 48
4819 OPC_Decode, 143, 14, 131, 2, // 1596: decode to FMUL_S using decoder 259
4820 // 1596: }
4821 3, 7, // 1601: case 0x3: {
4822 OPC_CheckPredicate, 48, // 1603: check predicate 48
4823 OPC_Decode, 208, 13, 131, 2, // 1605: decode to FDIV_S using decoder 259
4824 // 1605: }
4825 4, 11, // 1610: case 0x4: {
4826 OPC_CheckPredicate, 53, // 1612: check predicate 53
4827 OPC_CheckField, 16, 5, 0, // 1614: check Inst[20:16] == 0x0
4828 OPC_Decode, 178, 14, 132, 2, // 1618: decode to FSQRT_S using decoder 260
4829 // 1618: }
4830 5, 11, // 1623: case 0x5: {
4831 OPC_CheckPredicate, 48, // 1625: check predicate 48
4832 OPC_CheckField, 16, 5, 0, // 1627: check Inst[20:16] == 0x0
4833 OPC_Decode, 162, 13, 132, 2, // 1631: decode to FABS_S using decoder 260
4834 // 1631: }
4835 6, 11, // 1636: case 0x6: {
4836 OPC_CheckPredicate, 48, // 1638: check predicate 48
4837 OPC_CheckField, 16, 5, 0, // 1640: check Inst[20:16] == 0x0
4838 OPC_Decode, 132, 14, 132, 2, // 1644: decode to FMOV_S using decoder 260
4839 // 1644: }
4840 7, 11, // 1649: case 0x7: {
4841 OPC_CheckPredicate, 54, // 1651: check predicate 54
4842 OPC_CheckField, 16, 5, 0, // 1653: check Inst[20:16] == 0x0
4843 OPC_Decode, 151, 14, 132, 2, // 1657: decode to FNEG_S using decoder 260
4844 // 1657: }
4845 12, 11, // 1662: case 0xc: {
4846 OPC_CheckPredicate, 55, // 1664: check predicate 55
4847 OPC_CheckField, 16, 5, 0, // 1666: check Inst[20:16] == 0x0
4848 OPC_Decode, 195, 20, 132, 2, // 1670: decode to ROUND_W_S using decoder 260
4849 // 1670: }
4850 13, 11, // 1675: case 0xd: {
4851 OPC_CheckPredicate, 55, // 1677: check predicate 55
4852 OPC_CheckField, 16, 5, 0, // 1679: check Inst[20:16] == 0x0
4853 OPC_Decode, 161, 24, 132, 2, // 1683: decode to TRUNC_W_S using decoder 260
4854 // 1683: }
4855 14, 11, // 1688: case 0xe: {
4856 OPC_CheckPredicate, 55, // 1690: check predicate 55
4857 OPC_CheckField, 16, 5, 0, // 1692: check Inst[20:16] == 0x0
4858 OPC_Decode, 163, 9, 132, 2, // 1696: decode to CEIL_W_S using decoder 260
4859 // 1696: }
4860 15, 11, // 1701: case 0xf: {
4861 OPC_CheckPredicate, 55, // 1703: check predicate 55
4862 OPC_CheckField, 16, 5, 0, // 1705: check Inst[20:16] == 0x0
4863 OPC_Decode, 242, 13, 132, 2, // 1709: decode to FLOOR_W_S using decoder 260
4864 // 1709: }
4865 17, 21, // 1714: case 0x11: {
4866 OPC_SwitchField, 16, 2, // 1716: switch Inst[17:16] {
4867 0, 7, // 1719: case 0x0: {
4868 OPC_CheckPredicate, 30, // 1721: check predicate 30
4869 OPC_Decode, 249, 17, 133, 2, // 1723: decode to MOVF_S using decoder 261
4870 // 1723: }
4871 1, 0, // 1728: case 0x1: {
4872 OPC_CheckPredicate, 30, // 1730: check predicate 30
4873 OPC_Decode, 142, 18, 133, 2, // 1732: decode to MOVT_S using decoder 261
4874 // 1732: }
4875 // 1732: } // switch Inst[17:16]
4876 // 1732: }
4877 18, 7, // 1737: case 0x12: {
4878 OPC_CheckPredicate, 30, // 1739: check predicate 30
4879 OPC_Decode, 154, 18, 134, 2, // 1741: decode to MOVZ_I_S using decoder 262
4880 // 1741: }
4881 19, 7, // 1746: case 0x13: {
4882 OPC_CheckPredicate, 30, // 1748: check predicate 30
4883 OPC_Decode, 133, 18, 134, 2, // 1750: decode to MOVN_I_S using decoder 262
4884 // 1750: }
4885 21, 11, // 1755: case 0x15: {
4886 OPC_CheckPredicate, 56, // 1757: check predicate 56
4887 OPC_CheckField, 16, 5, 0, // 1759: check Inst[20:16] == 0x0
4888 OPC_Decode, 163, 20, 132, 2, // 1763: decode to RECIP_S using decoder 260
4889 // 1763: }
4890 22, 11, // 1768: case 0x16: {
4891 OPC_CheckPredicate, 56, // 1770: check predicate 56
4892 OPC_CheckField, 16, 5, 0, // 1772: check Inst[20:16] == 0x0
4893 OPC_Decode, 202, 20, 132, 2, // 1776: decode to RSQRT_S using decoder 260
4894 // 1776: }
4895 33, 11, // 1781: case 0x21: {
4896 OPC_CheckPredicate, 57, // 1783: check predicate 57
4897 OPC_CheckField, 16, 5, 0, // 1785: check Inst[20:16] == 0x0
4898 OPC_Decode, 213, 10, 135, 2, // 1789: decode to CVT_D32_S using decoder 263
4899 // 1789: }
4900 36, 11, // 1794: case 0x24: {
4901 OPC_CheckPredicate, 48, // 1796: check predicate 48
4902 OPC_CheckField, 16, 5, 0, // 1798: check Inst[20:16] == 0x0
4903 OPC_Decode, 247, 10, 132, 2, // 1802: decode to CVT_W_S using decoder 260
4904 // 1802: }
4905 37, 11, // 1807: case 0x25: {
4906 OPC_CheckPredicate, 58, // 1809: check predicate 58
4907 OPC_CheckField, 16, 5, 0, // 1811: check Inst[20:16] == 0x0
4908 OPC_Decode, 226, 10, 136, 2, // 1815: decode to CVT_L_S using decoder 264
4909 // 1815: }
4910 48, 11, // 1820: case 0x30: {
4911 OPC_CheckPredicate, 51, // 1822: check predicate 51
4912 OPC_CheckField, 6, 2, 0, // 1824: check Inst[7:6] == 0x0
4913 OPC_Decode, 132, 11, 137, 2, // 1828: decode to C_F_S using decoder 265
4914 // 1828: }
4915 49, 11, // 1833: case 0x31: {
4916 OPC_CheckPredicate, 59, // 1835: check predicate 59
4917 OPC_CheckField, 6, 2, 0, // 1837: check Inst[7:6] == 0x0
4918 OPC_Decode, 216, 11, 137, 2, // 1841: decode to C_UN_S using decoder 265
4919 // 1841: }
4920 50, 11, // 1846: case 0x32: {
4921 OPC_CheckPredicate, 51, // 1848: check predicate 51
4922 OPC_CheckField, 6, 2, 0, // 1850: check Inst[7:6] == 0x0
4923 OPC_Decode, 254, 10, 137, 2, // 1854: decode to C_EQ_S using decoder 265
4924 // 1854: }
4925 51, 11, // 1859: case 0x33: {
4926 OPC_CheckPredicate, 59, // 1861: check predicate 59
4927 OPC_CheckField, 6, 2, 0, // 1863: check Inst[7:6] == 0x0
4928 OPC_Decode, 198, 11, 137, 2, // 1867: decode to C_UEQ_S using decoder 265
4929 // 1867: }
4930 52, 11, // 1872: case 0x34: {
4931 OPC_CheckPredicate, 51, // 1874: check predicate 51
4932 OPC_CheckField, 6, 2, 0, // 1876: check Inst[7:6] == 0x0
4933 OPC_Decode, 180, 11, 137, 2, // 1880: decode to C_OLT_S using decoder 265
4934 // 1880: }
4935 53, 11, // 1885: case 0x35: {
4936 OPC_CheckPredicate, 59, // 1887: check predicate 59
4937 OPC_CheckField, 6, 2, 0, // 1889: check Inst[7:6] == 0x0
4938 OPC_Decode, 210, 11, 137, 2, // 1893: decode to C_ULT_S using decoder 265
4939 // 1893: }
4940 54, 11, // 1898: case 0x36: {
4941 OPC_CheckPredicate, 51, // 1900: check predicate 51
4942 OPC_CheckField, 6, 2, 0, // 1902: check Inst[7:6] == 0x0
4943 OPC_Decode, 174, 11, 137, 2, // 1906: decode to C_OLE_S using decoder 265
4944 // 1906: }
4945 55, 11, // 1911: case 0x37: {
4946 OPC_CheckPredicate, 59, // 1913: check predicate 59
4947 OPC_CheckField, 6, 2, 0, // 1915: check Inst[7:6] == 0x0
4948 OPC_Decode, 204, 11, 137, 2, // 1919: decode to C_ULE_S using decoder 265
4949 // 1919: }
4950 56, 11, // 1924: case 0x38: {
4951 OPC_CheckPredicate, 59, // 1926: check predicate 59
4952 OPC_CheckField, 6, 2, 0, // 1928: check Inst[7:6] == 0x0
4953 OPC_Decode, 192, 11, 137, 2, // 1932: decode to C_SF_S using decoder 265
4954 // 1932: }
4955 57, 11, // 1937: case 0x39: {
4956 OPC_CheckPredicate, 59, // 1939: check predicate 59
4957 OPC_CheckField, 6, 2, 0, // 1941: check Inst[7:6] == 0x0
4958 OPC_Decode, 156, 11, 137, 2, // 1945: decode to C_NGLE_S using decoder 265
4959 // 1945: }
4960 58, 11, // 1950: case 0x3a: {
4961 OPC_CheckPredicate, 59, // 1952: check predicate 59
4962 OPC_CheckField, 6, 2, 0, // 1954: check Inst[7:6] == 0x0
4963 OPC_Decode, 186, 11, 137, 2, // 1958: decode to C_SEQ_S using decoder 265
4964 // 1958: }
4965 59, 11, // 1963: case 0x3b: {
4966 OPC_CheckPredicate, 59, // 1965: check predicate 59
4967 OPC_CheckField, 6, 2, 0, // 1967: check Inst[7:6] == 0x0
4968 OPC_Decode, 162, 11, 137, 2, // 1971: decode to C_NGL_S using decoder 265
4969 // 1971: }
4970 60, 11, // 1976: case 0x3c: {
4971 OPC_CheckPredicate, 59, // 1978: check predicate 59
4972 OPC_CheckField, 6, 2, 0, // 1980: check Inst[7:6] == 0x0
4973 OPC_Decode, 144, 11, 137, 2, // 1984: decode to C_LT_S using decoder 265
4974 // 1984: }
4975 61, 11, // 1989: case 0x3d: {
4976 OPC_CheckPredicate, 59, // 1991: check predicate 59
4977 OPC_CheckField, 6, 2, 0, // 1993: check Inst[7:6] == 0x0
4978 OPC_Decode, 150, 11, 137, 2, // 1997: decode to C_NGE_S using decoder 265
4979 // 1997: }
4980 62, 11, // 2002: case 0x3e: {
4981 OPC_CheckPredicate, 59, // 2004: check predicate 59
4982 OPC_CheckField, 6, 2, 0, // 2006: check Inst[7:6] == 0x0
4983 OPC_Decode, 138, 11, 137, 2, // 2010: decode to C_LE_S using decoder 265
4984 // 2010: }
4985 63, 0, // 2015: case 0x3f: {
4986 OPC_CheckPredicate, 59, // 2017: check predicate 59
4987 OPC_CheckField, 6, 2, 0, // 2019: check Inst[7:6] == 0x0
4988 OPC_Decode, 168, 11, 137, 2, // 2023: decode to C_NGT_S using decoder 265
4989 // 2023: }
4990 // 2023: } // switch Inst[5:0]
4991 // 2023: }
4992 17, 201, 3, // 2028: case 0x11: {
4993 OPC_SwitchField, 0, 6, // 2031: switch Inst[5:0] {
4994 0, 7, // 2034: case 0x0: {
4995 OPC_CheckPredicate, 57, // 2036: check predicate 57
4996 OPC_Decode, 165, 13, 138, 2, // 2038: decode to FADD_D32 using decoder 266
4997 // 2038: }
4998 1, 7, // 2043: case 0x1: {
4999 OPC_CheckPredicate, 57, // 2045: check predicate 57
5000 OPC_Decode, 182, 14, 138, 2, // 2047: decode to FSUB_D32 using decoder 266
5001 // 2047: }
5002 2, 7, // 2052: case 0x2: {
5003 OPC_CheckPredicate, 57, // 2054: check predicate 57
5004 OPC_Decode, 138, 14, 138, 2, // 2056: decode to FMUL_D32 using decoder 266
5005 // 2056: }
5006 3, 7, // 2061: case 0x3: {
5007 OPC_CheckPredicate, 57, // 2063: check predicate 57
5008 OPC_Decode, 204, 13, 138, 2, // 2065: decode to FDIV_D32 using decoder 266
5009 // 2065: }
5010 4, 11, // 2070: case 0x4: {
5011 OPC_CheckPredicate, 60, // 2072: check predicate 60
5012 OPC_CheckField, 16, 5, 0, // 2074: check Inst[20:16] == 0x0
5013 OPC_Decode, 174, 14, 139, 2, // 2078: decode to FSQRT_D32 using decoder 267
5014 // 2078: }
5015 5, 11, // 2083: case 0x5: {
5016 OPC_CheckPredicate, 57, // 2085: check predicate 57
5017 OPC_CheckField, 16, 5, 0, // 2087: check Inst[20:16] == 0x0
5018 OPC_Decode, 158, 13, 139, 2, // 2091: decode to FABS_D32 using decoder 267
5019 // 2091: }
5020 6, 11, // 2096: case 0x6: {
5021 OPC_CheckPredicate, 57, // 2098: check predicate 57
5022 OPC_CheckField, 16, 5, 0, // 2100: check Inst[20:16] == 0x0
5023 OPC_Decode, 255, 13, 139, 2, // 2104: decode to FMOV_D32 using decoder 267
5024 // 2104: }
5025 7, 11, // 2109: case 0x7: {
5026 OPC_CheckPredicate, 57, // 2111: check predicate 57
5027 OPC_CheckField, 16, 5, 0, // 2113: check Inst[20:16] == 0x0
5028 OPC_Decode, 147, 14, 139, 2, // 2117: decode to FNEG_D32 using decoder 267
5029 // 2117: }
5030 12, 11, // 2122: case 0xc: {
5031 OPC_CheckPredicate, 60, // 2124: check predicate 60
5032 OPC_CheckField, 16, 5, 0, // 2126: check Inst[20:16] == 0x0
5033 OPC_Decode, 191, 20, 140, 2, // 2130: decode to ROUND_W_D32 using decoder 268
5034 // 2130: }
5035 13, 11, // 2135: case 0xd: {
5036 OPC_CheckPredicate, 60, // 2137: check predicate 60
5037 OPC_CheckField, 16, 5, 0, // 2139: check Inst[20:16] == 0x0
5038 OPC_Decode, 157, 24, 140, 2, // 2143: decode to TRUNC_W_D32 using decoder 268
5039 // 2143: }
5040 14, 11, // 2148: case 0xe: {
5041 OPC_CheckPredicate, 60, // 2150: check predicate 60
5042 OPC_CheckField, 16, 5, 0, // 2152: check Inst[20:16] == 0x0
5043 OPC_Decode, 159, 9, 140, 2, // 2156: decode to CEIL_W_D32 using decoder 268
5044 // 2156: }
5045 15, 11, // 2161: case 0xf: {
5046 OPC_CheckPredicate, 60, // 2163: check predicate 60
5047 OPC_CheckField, 16, 5, 0, // 2165: check Inst[20:16] == 0x0
5048 OPC_Decode, 238, 13, 140, 2, // 2169: decode to FLOOR_W_D32 using decoder 268
5049 // 2169: }
5050 17, 21, // 2174: case 0x11: {
5051 OPC_SwitchField, 16, 2, // 2176: switch Inst[17:16] {
5052 0, 7, // 2179: case 0x0: {
5053 OPC_CheckPredicate, 61, // 2181: check predicate 61
5054 OPC_Decode, 243, 17, 141, 2, // 2183: decode to MOVF_D32 using decoder 269
5055 // 2183: }
5056 1, 0, // 2188: case 0x1: {
5057 OPC_CheckPredicate, 61, // 2190: check predicate 61
5058 OPC_Decode, 136, 18, 141, 2, // 2192: decode to MOVT_D32 using decoder 269
5059 // 2192: }
5060 // 2192: } // switch Inst[17:16]
5061 // 2192: }
5062 18, 7, // 2197: case 0x12: {
5063 OPC_CheckPredicate, 61, // 2199: check predicate 61
5064 OPC_Decode, 148, 18, 142, 2, // 2201: decode to MOVZ_I_D32 using decoder 270
5065 // 2201: }
5066 19, 7, // 2206: case 0x13: {
5067 OPC_CheckPredicate, 61, // 2208: check predicate 61
5068 OPC_Decode, 255, 17, 142, 2, // 2210: decode to MOVN_I_D32 using decoder 270
5069 // 2210: }
5070 21, 11, // 2215: case 0x15: {
5071 OPC_CheckPredicate, 62, // 2217: check predicate 62
5072 OPC_CheckField, 16, 5, 0, // 2219: check Inst[20:16] == 0x0
5073 OPC_Decode, 159, 20, 139, 2, // 2223: decode to RECIP_D32 using decoder 267
5074 // 2223: }
5075 22, 11, // 2228: case 0x16: {
5076 OPC_CheckPredicate, 62, // 2230: check predicate 62
5077 OPC_CheckField, 16, 5, 0, // 2232: check Inst[20:16] == 0x0
5078 OPC_Decode, 198, 20, 139, 2, // 2236: decode to RSQRT_D32 using decoder 267
5079 // 2236: }
5080 32, 11, // 2241: case 0x20: {
5081 OPC_CheckPredicate, 57, // 2243: check predicate 57
5082 OPC_CheckField, 16, 5, 0, // 2245: check Inst[20:16] == 0x0
5083 OPC_Decode, 232, 10, 140, 2, // 2249: decode to CVT_S_D32 using decoder 268
5084 // 2249: }
5085 36, 11, // 2254: case 0x24: {
5086 OPC_CheckPredicate, 57, // 2256: check predicate 57
5087 OPC_CheckField, 16, 5, 0, // 2258: check Inst[20:16] == 0x0
5088 OPC_Decode, 243, 10, 140, 2, // 2262: decode to CVT_W_D32 using decoder 268
5089 // 2262: }
5090 37, 11, // 2267: case 0x25: {
5091 OPC_CheckPredicate, 58, // 2269: check predicate 58
5092 OPC_CheckField, 16, 5, 0, // 2271: check Inst[20:16] == 0x0
5093 OPC_Decode, 223, 10, 143, 2, // 2275: decode to CVT_L_D64 using decoder 271
5094 // 2275: }
5095 48, 11, // 2280: case 0x30: {
5096 OPC_CheckPredicate, 63, // 2282: check predicate 63
5097 OPC_CheckField, 6, 2, 0, // 2284: check Inst[7:6] == 0x0
5098 OPC_Decode, 128, 11, 144, 2, // 2288: decode to C_F_D32 using decoder 272
5099 // 2288: }
5100 49, 11, // 2293: case 0x31: {
5101 OPC_CheckPredicate, 63, // 2295: check predicate 63
5102 OPC_CheckField, 6, 2, 0, // 2297: check Inst[7:6] == 0x0
5103 OPC_Decode, 212, 11, 144, 2, // 2301: decode to C_UN_D32 using decoder 272
5104 // 2301: }
5105 50, 11, // 2306: case 0x32: {
5106 OPC_CheckPredicate, 63, // 2308: check predicate 63
5107 OPC_CheckField, 6, 2, 0, // 2310: check Inst[7:6] == 0x0
5108 OPC_Decode, 250, 10, 144, 2, // 2314: decode to C_EQ_D32 using decoder 272
5109 // 2314: }
5110 51, 11, // 2319: case 0x33: {
5111 OPC_CheckPredicate, 63, // 2321: check predicate 63
5112 OPC_CheckField, 6, 2, 0, // 2323: check Inst[7:6] == 0x0
5113 OPC_Decode, 194, 11, 144, 2, // 2327: decode to C_UEQ_D32 using decoder 272
5114 // 2327: }
5115 52, 11, // 2332: case 0x34: {
5116 OPC_CheckPredicate, 63, // 2334: check predicate 63
5117 OPC_CheckField, 6, 2, 0, // 2336: check Inst[7:6] == 0x0
5118 OPC_Decode, 176, 11, 144, 2, // 2340: decode to C_OLT_D32 using decoder 272
5119 // 2340: }
5120 53, 11, // 2345: case 0x35: {
5121 OPC_CheckPredicate, 63, // 2347: check predicate 63
5122 OPC_CheckField, 6, 2, 0, // 2349: check Inst[7:6] == 0x0
5123 OPC_Decode, 206, 11, 144, 2, // 2353: decode to C_ULT_D32 using decoder 272
5124 // 2353: }
5125 54, 11, // 2358: case 0x36: {
5126 OPC_CheckPredicate, 63, // 2360: check predicate 63
5127 OPC_CheckField, 6, 2, 0, // 2362: check Inst[7:6] == 0x0
5128 OPC_Decode, 170, 11, 144, 2, // 2366: decode to C_OLE_D32 using decoder 272
5129 // 2366: }
5130 55, 11, // 2371: case 0x37: {
5131 OPC_CheckPredicate, 63, // 2373: check predicate 63
5132 OPC_CheckField, 6, 2, 0, // 2375: check Inst[7:6] == 0x0
5133 OPC_Decode, 200, 11, 144, 2, // 2379: decode to C_ULE_D32 using decoder 272
5134 // 2379: }
5135 56, 11, // 2384: case 0x38: {
5136 OPC_CheckPredicate, 63, // 2386: check predicate 63
5137 OPC_CheckField, 6, 2, 0, // 2388: check Inst[7:6] == 0x0
5138 OPC_Decode, 188, 11, 144, 2, // 2392: decode to C_SF_D32 using decoder 272
5139 // 2392: }
5140 57, 11, // 2397: case 0x39: {
5141 OPC_CheckPredicate, 63, // 2399: check predicate 63
5142 OPC_CheckField, 6, 2, 0, // 2401: check Inst[7:6] == 0x0
5143 OPC_Decode, 152, 11, 144, 2, // 2405: decode to C_NGLE_D32 using decoder 272
5144 // 2405: }
5145 58, 11, // 2410: case 0x3a: {
5146 OPC_CheckPredicate, 63, // 2412: check predicate 63
5147 OPC_CheckField, 6, 2, 0, // 2414: check Inst[7:6] == 0x0
5148 OPC_Decode, 182, 11, 144, 2, // 2418: decode to C_SEQ_D32 using decoder 272
5149 // 2418: }
5150 59, 11, // 2423: case 0x3b: {
5151 OPC_CheckPredicate, 63, // 2425: check predicate 63
5152 OPC_CheckField, 6, 2, 0, // 2427: check Inst[7:6] == 0x0
5153 OPC_Decode, 158, 11, 144, 2, // 2431: decode to C_NGL_D32 using decoder 272
5154 // 2431: }
5155 60, 11, // 2436: case 0x3c: {
5156 OPC_CheckPredicate, 63, // 2438: check predicate 63
5157 OPC_CheckField, 6, 2, 0, // 2440: check Inst[7:6] == 0x0
5158 OPC_Decode, 140, 11, 144, 2, // 2444: decode to C_LT_D32 using decoder 272
5159 // 2444: }
5160 61, 11, // 2449: case 0x3d: {
5161 OPC_CheckPredicate, 63, // 2451: check predicate 63
5162 OPC_CheckField, 6, 2, 0, // 2453: check Inst[7:6] == 0x0
5163 OPC_Decode, 146, 11, 144, 2, // 2457: decode to C_NGE_D32 using decoder 272
5164 // 2457: }
5165 62, 11, // 2462: case 0x3e: {
5166 OPC_CheckPredicate, 63, // 2464: check predicate 63
5167 OPC_CheckField, 6, 2, 0, // 2466: check Inst[7:6] == 0x0
5168 OPC_Decode, 134, 11, 144, 2, // 2470: decode to C_LE_D32 using decoder 272
5169 // 2470: }
5170 63, 0, // 2475: case 0x3f: {
5171 OPC_CheckPredicate, 63, // 2477: check predicate 63
5172 OPC_CheckField, 6, 2, 0, // 2479: check Inst[7:6] == 0x0
5173 OPC_Decode, 164, 11, 144, 2, // 2483: decode to C_NGT_D32 using decoder 272
5174 // 2483: }
5175 // 2483: } // switch Inst[5:0]
5176 // 2483: }
5177 20, 29, // 2488: case 0x14: {
5178 OPC_SwitchField, 0, 6, // 2490: switch Inst[5:0] {
5179 32, 11, // 2493: case 0x20: {
5180 OPC_CheckPredicate, 48, // 2495: check predicate 48
5181 OPC_CheckField, 16, 5, 0, // 2497: check Inst[20:16] == 0x0
5182 OPC_Decode, 240, 10, 132, 2, // 2501: decode to CVT_S_W using decoder 260
5183 // 2501: }
5184 33, 0, // 2506: case 0x21: {
5185 OPC_CheckPredicate, 57, // 2508: check predicate 57
5186 OPC_CheckField, 16, 5, 0, // 2510: check Inst[20:16] == 0x0
5187 OPC_Decode, 215, 10, 135, 2, // 2514: decode to CVT_D32_W using decoder 263
5188 // 2514: }
5189 // 2514: } // switch Inst[5:0]
5190 // 2514: }
5191 24, 7, // 2519: case 0x18: {
5192 OPC_CheckPredicate, 31, // 2521: check predicate 31
5193 OPC_Decode, 132, 9, 130, 2, // 2523: decode to BZ_B using decoder 258
5194 // 2523: }
5195 25, 7, // 2528: case 0x19: {
5196 OPC_CheckPredicate, 31, // 2530: check predicate 31
5197 OPC_Decode, 134, 9, 145, 2, // 2532: decode to BZ_H using decoder 273
5198 // 2532: }
5199 26, 7, // 2537: case 0x1a: {
5200 OPC_CheckPredicate, 31, // 2539: check predicate 31
5201 OPC_Decode, 136, 9, 146, 2, // 2541: decode to BZ_W using decoder 274
5202 // 2541: }
5203 27, 7, // 2546: case 0x1b: {
5204 OPC_CheckPredicate, 31, // 2548: check predicate 31
5205 OPC_Decode, 133, 9, 147, 2, // 2550: decode to BZ_D using decoder 275
5206 // 2550: }
5207 28, 7, // 2555: case 0x1c: {
5208 OPC_CheckPredicate, 31, // 2557: check predicate 31
5209 OPC_Decode, 231, 8, 130, 2, // 2559: decode to BNZ_B using decoder 258
5210 // 2559: }
5211 29, 7, // 2564: case 0x1d: {
5212 OPC_CheckPredicate, 31, // 2566: check predicate 31
5213 OPC_Decode, 233, 8, 145, 2, // 2568: decode to BNZ_H using decoder 273
5214 // 2568: }
5215 30, 7, // 2573: case 0x1e: {
5216 OPC_CheckPredicate, 31, // 2575: check predicate 31
5217 OPC_Decode, 235, 8, 146, 2, // 2577: decode to BNZ_W using decoder 274
5218 // 2577: }
5219 31, 0, // 2582: case 0x1f: {
5220 OPC_CheckPredicate, 31, // 2584: check predicate 31
5221 OPC_Decode, 232, 8, 147, 2, // 2586: decode to BNZ_D using decoder 275
5222 // 2586: }
5223 // 2586: } // switch Inst[25:21]
5224 // 2586: }
5225 18, 29, // 2591: case 0x12: {
5226 OPC_SwitchField, 21, 5, // 2593: switch Inst[25:21] {
5227 0, 11, // 2596: case 0x0: {
5228 OPC_CheckPredicate, 28, // 2598: check predicate 28
5229 OPC_CheckField, 3, 8, 0, // 2600: check Inst[10:3] == 0x0
5230 OPC_Decode, 164, 17, 148, 2, // 2604: decode to MFC2 using decoder 276
5231 // 2604: }
5232 4, 0, // 2609: case 0x4: {
5233 OPC_CheckPredicate, 28, // 2611: check predicate 28
5234 OPC_CheckField, 3, 8, 0, // 2613: check Inst[10:3] == 0x0
5235 OPC_Decode, 191, 18, 149, 2, // 2617: decode to MTC2 using decoder 277
5236 // 2617: }
5237 // 2617: } // switch Inst[25:21]
5238 // 2617: }
5239 19, 153, 1, // 2622: case 0x13: {
5240 OPC_SwitchField, 0, 6, // 2625: switch Inst[5:0] {
5241 0, 11, // 2628: case 0x0: {
5242 OPC_CheckPredicate, 64, // 2630: check predicate 64
5243 OPC_CheckField, 11, 5, 0, // 2632: check Inst[15:11] == 0x0
5244 OPC_Decode, 200, 16, 150, 2, // 2636: decode to LWXC1 using decoder 278
5245 // 2636: }
5246 1, 11, // 2641: case 0x1: {
5247 OPC_CheckPredicate, 65, // 2643: check predicate 65
5248 OPC_CheckField, 11, 5, 0, // 2645: check Inst[15:11] == 0x0
5249 OPC_Decode, 225, 15, 151, 2, // 2649: decode to LDXC1 using decoder 279
5250 // 2649: }
5251 5, 11, // 2654: case 0x5: {
5252 OPC_CheckPredicate, 66, // 2656: check predicate 66
5253 OPC_CheckField, 11, 5, 0, // 2658: check Inst[15:11] == 0x0
5254 OPC_Decode, 153, 16, 151, 2, // 2662: decode to LUXC1 using decoder 279
5255 // 2662: }
5256 8, 11, // 2667: case 0x8: {
5257 OPC_CheckPredicate, 64, // 2669: check predicate 64
5258 OPC_CheckField, 6, 5, 0, // 2671: check Inst[10:6] == 0x0
5259 OPC_Decode, 190, 23, 152, 2, // 2675: decode to SWXC1 using decoder 280
5260 // 2675: }
5261 9, 11, // 2680: case 0x9: {
5262 OPC_CheckPredicate, 65, // 2682: check predicate 65
5263 OPC_CheckField, 6, 5, 0, // 2684: check Inst[10:6] == 0x0
5264 OPC_Decode, 137, 21, 153, 2, // 2688: decode to SDXC1 using decoder 281
5265 // 2688: }
5266 13, 11, // 2693: case 0xd: {
5267 OPC_CheckPredicate, 66, // 2695: check predicate 66
5268 OPC_CheckField, 6, 5, 0, // 2697: check Inst[10:6] == 0x0
5269 OPC_Decode, 150, 23, 153, 2, // 2701: decode to SUXC1 using decoder 281
5270 // 2701: }
5271 32, 7, // 2706: case 0x20: {
5272 OPC_CheckPredicate, 67, // 2708: check predicate 67
5273 OPC_Decode, 246, 16, 154, 2, // 2710: decode to MADD_S using decoder 282
5274 // 2710: }
5275 33, 7, // 2715: case 0x21: {
5276 OPC_CheckPredicate, 68, // 2717: check predicate 68
5277 OPC_Decode, 238, 16, 155, 2, // 2719: decode to MADD_D32 using decoder 283
5278 // 2719: }
5279 40, 7, // 2724: case 0x28: {
5280 OPC_CheckPredicate, 67, // 2726: check predicate 67
5281 OPC_Decode, 180, 18, 154, 2, // 2728: decode to MSUB_S using decoder 282
5282 // 2728: }
5283 41, 7, // 2733: case 0x29: {
5284 OPC_CheckPredicate, 68, // 2735: check predicate 68
5285 OPC_Decode, 172, 18, 155, 2, // 2737: decode to MSUB_D32 using decoder 283
5286 // 2737: }
5287 48, 7, // 2742: case 0x30: {
5288 OPC_CheckPredicate, 69, // 2744: check predicate 69
5289 OPC_Decode, 167, 19, 154, 2, // 2746: decode to NMADD_S using decoder 282
5290 // 2746: }
5291 49, 7, // 2751: case 0x31: {
5292 OPC_CheckPredicate, 70, // 2753: check predicate 70
5293 OPC_Decode, 164, 19, 155, 2, // 2755: decode to NMADD_D32 using decoder 283
5294 // 2755: }
5295 56, 7, // 2760: case 0x38: {
5296 OPC_CheckPredicate, 69, // 2762: check predicate 69
5297 OPC_Decode, 172, 19, 154, 2, // 2764: decode to NMSUB_S using decoder 282
5298 // 2764: }
5299 57, 0, // 2769: case 0x39: {
5300 OPC_CheckPredicate, 70, // 2771: check predicate 70
5301 OPC_Decode, 169, 19, 155, 2, // 2773: decode to NMSUB_D32 using decoder 283
5302 // 2773: }
5303 // 2773: } // switch Inst[5:0]
5304 // 2773: }
5305 20, 7, // 2778: case 0x14: {
5306 OPC_CheckPredicate, 40, // 2780: check predicate 40
5307 OPC_Decode, 231, 7, 242, 1, // 2782: decode to BEQL using decoder 242
5308 // 2782: }
5309 21, 74, // 2787: case 0x15: {
5310 OPC_Scope, 22, // 2789: try {
5311 OPC_SwitchField, 0, 16, // 2791: switch Inst[15:0] {
5312 123, 7, // 2794: case 0x7b: {
5313 OPC_CheckPredicate, 21, // 2796: check predicate 21
5314 OPC_Decode, 133, 14, 169, 1, // 2798: decode to FMOV_S_MM using decoder 169
5315 // 2798: }
5316 251, 22, 0, // 2803: case 0xb7b: {
5317 OPC_CheckPredicate, 21, // 2806: check predicate 21
5318 OPC_Decode, 152, 14, 169, 1, // 2808: decode to FNEG_S_MM using decoder 169
5319 // 2808: }
5320 // 2808: } // switch Inst[15:0]
5321 OPC_Scope, 41, // 2813: } else try {
5322 OPC_SwitchField, 0, 11, // 2815: switch Inst[10:0] {
5323 48, 7, // 2818: case 0x30: {
5324 OPC_CheckPredicate, 21, // 2820: check predicate 21
5325 OPC_Decode, 171, 13, 208, 1, // 2822: decode to FADD_S_MM using decoder 208
5326 // 2822: }
5327 112, 7, // 2827: case 0x70: {
5328 OPC_CheckPredicate, 21, // 2829: check predicate 21
5329 OPC_Decode, 188, 14, 208, 1, // 2831: decode to FSUB_S_MM using decoder 208
5330 // 2831: }
5331 176, 1, 7, // 2836: case 0xb0: {
5332 OPC_CheckPredicate, 21, // 2839: check predicate 21
5333 OPC_Decode, 144, 14, 208, 1, // 2841: decode to FMUL_S_MM using decoder 208
5334 // 2841: }
5335 240, 1, 0, // 2846: case 0xf0: {
5336 OPC_CheckPredicate, 21, // 2849: check predicate 21
5337 OPC_Decode, 209, 13, 208, 1, // 2851: decode to FDIV_S_MM using decoder 208
5338 // 2851: }
5339 // 2851: } // switch Inst[10:0]
5340 // 2851: } else try {
5341 OPC_CheckPredicate, 40, // 2856: check predicate 40
5342 OPC_Decode, 218, 8, 242, 1, // 2858: decode to BNEL using decoder 242
5343 // 2858: }
5344 // 2858: }
5345 22, 11, // 2863: case 0x16: {
5346 OPC_CheckPredicate, 40, // 2865: check predicate 40
5347 OPC_CheckField, 16, 5, 0, // 2867: check Inst[20:16] == 0x0
5348 OPC_Decode, 174, 8, 238, 1, // 2871: decode to BLEZL using decoder 238
5349 // 2871: }
5350 23, 11, // 2876: case 0x17: {
5351 OPC_CheckPredicate, 40, // 2878: check predicate 40
5352 OPC_CheckField, 16, 5, 0, // 2880: check Inst[20:16] == 0x0
5353 OPC_Decode, 144, 8, 238, 1, // 2884: decode to BGTZL using decoder 238
5354 // 2884: }
5355 28, 166, 1, // 2889: case 0x1c: {
5356 OPC_SwitchField, 0, 6, // 2892: switch Inst[5:0] {
5357 0, 27, // 2895: case 0x0: {
5358 OPC_CheckField, 6, 5, 0, // 2897: check Inst[10:6] == 0x0
5359 OPC_CheckField, 13, 3, 0, // 2901: check Inst[15:13] == 0x0
5360 OPC_Scope, 10, // 2905: try {
5361 OPC_CheckField, 11, 2, 0, // 2907: check Inst[12:11] == 0x0
5362 OPC_CheckPredicate, 71, // 2911: check predicate 71
5363 OPC_Decode, 223, 16, 123, // 2913: decode to MADD using decoder 123
5364 // 2913: } else try {
5365 OPC_CheckPredicate, 38, // 2917: check predicate 38
5366 OPC_Decode, 241, 16, 156, 2, // 2919: decode to MADD_DSP using decoder 284
5367 // 2919: }
5368 // 2919: }
5369 1, 27, // 2924: case 0x1: {
5370 OPC_CheckField, 6, 5, 0, // 2926: check Inst[10:6] == 0x0
5371 OPC_CheckField, 13, 3, 0, // 2930: check Inst[15:13] == 0x0
5372 OPC_Scope, 10, // 2934: try {
5373 OPC_CheckField, 11, 2, 0, // 2936: check Inst[12:11] == 0x0
5374 OPC_CheckPredicate, 71, // 2940: check predicate 71
5375 OPC_Decode, 230, 16, 123, // 2942: decode to MADDU using decoder 123
5376 // 2942: } else try {
5377 OPC_CheckPredicate, 38, // 2946: check predicate 38
5378 OPC_Decode, 231, 16, 156, 2, // 2948: decode to MADDU_DSP using decoder 284
5379 // 2948: }
5380 // 2948: }
5381 2, 10, // 2953: case 0x2: {
5382 OPC_CheckPredicate, 71, // 2955: check predicate 71
5383 OPC_CheckField, 6, 5, 0, // 2957: check Inst[10:6] == 0x0
5384 OPC_Decode, 229, 18, 104, // 2961: decode to MUL using decoder 104
5385 // 2961: }
5386 4, 27, // 2965: case 0x4: {
5387 OPC_CheckField, 6, 5, 0, // 2967: check Inst[10:6] == 0x0
5388 OPC_CheckField, 13, 3, 0, // 2971: check Inst[15:13] == 0x0
5389 OPC_Scope, 10, // 2975: try {
5390 OPC_CheckField, 11, 2, 0, // 2977: check Inst[12:11] == 0x0
5391 OPC_CheckPredicate, 71, // 2981: check predicate 71
5392 OPC_Decode, 157, 18, 123, // 2983: decode to MSUB using decoder 123
5393 // 2983: } else try {
5394 OPC_CheckPredicate, 38, // 2987: check predicate 38
5395 OPC_Decode, 175, 18, 156, 2, // 2989: decode to MSUB_DSP using decoder 284
5396 // 2989: }
5397 // 2989: }
5398 5, 27, // 2994: case 0x5: {
5399 OPC_CheckField, 6, 5, 0, // 2996: check Inst[10:6] == 0x0
5400 OPC_CheckField, 13, 3, 0, // 3000: check Inst[15:13] == 0x0
5401 OPC_Scope, 10, // 3004: try {
5402 OPC_CheckField, 11, 2, 0, // 3006: check Inst[12:11] == 0x0
5403 OPC_CheckPredicate, 71, // 3010: check predicate 71
5404 OPC_Decode, 164, 18, 123, // 3012: decode to MSUBU using decoder 123
5405 // 3012: } else try {
5406 OPC_CheckPredicate, 38, // 3016: check predicate 38
5407 OPC_Decode, 165, 18, 156, 2, // 3018: decode to MSUBU_DSP using decoder 284
5408 // 3018: }
5409 // 3018: }
5410 32, 11, // 3023: case 0x20: {
5411 OPC_CheckPredicate, 71, // 3025: check predicate 71
5412 OPC_CheckField, 6, 5, 0, // 3027: check Inst[10:6] == 0x0
5413 OPC_Decode, 223, 9, 157, 2, // 3031: decode to CLZ using decoder 285
5414 // 3031: }
5415 33, 11, // 3036: case 0x21: {
5416 OPC_CheckPredicate, 71, // 3038: check predicate 71
5417 OPC_CheckField, 6, 5, 0, // 3040: check Inst[10:6] == 0x0
5418 OPC_Decode, 202, 9, 157, 2, // 3044: decode to CLO using decoder 285
5419 // 3044: }
5420 63, 0, // 3049: case 0x3f: {
5421 OPC_CheckPredicate, 71, // 3051: check predicate 71
5422 OPC_Decode, 244, 20, 229, 1, // 3053: decode to SDBBP using decoder 229
5423 // 3053: }
5424 // 3053: } // switch Inst[5:0]
5425 // 3053: }
5426 29, 7, // 3058: case 0x1d: {
5427 OPC_CheckPredicate, 71, // 3060: check predicate 71
5428 OPC_Decode, 151, 15, 241, 1, // 3062: decode to JALX using decoder 241
5429 // 3062: }
5430 30, 197, 39, // 3067: case 0x1e: {
5431 OPC_SwitchField, 0, 6, // 3070: switch Inst[5:0] {
5432 0, 39, // 3073: case 0x0: {
5433 OPC_SwitchField, 24, 2, // 3075: switch Inst[25:24] {
5434 0, 7, // 3078: case 0x0: {
5435 OPC_CheckPredicate, 31, // 3080: check predicate 31
5436 OPC_Decode, 132, 7, 158, 2, // 3082: decode to ANDI_B using decoder 286
5437 // 3082: }
5438 1, 7, // 3087: case 0x1: {
5439 OPC_CheckPredicate, 31, // 3089: check predicate 31
5440 OPC_Decode, 193, 19, 158, 2, // 3091: decode to ORI_B using decoder 286
5441 // 3091: }
5442 2, 7, // 3096: case 0x2: {
5443 OPC_CheckPredicate, 31, // 3098: check predicate 31
5444 OPC_Decode, 178, 19, 158, 2, // 3100: decode to NORI_B using decoder 286
5445 // 3100: }
5446 3, 0, // 3105: case 0x3: {
5447 OPC_CheckPredicate, 31, // 3107: check predicate 31
5448 OPC_Decode, 196, 24, 158, 2, // 3109: decode to XORI_B using decoder 286
5449 // 3109: }
5450 // 3109: } // switch Inst[25:24]
5451 // 3109: }
5452 1, 30, // 3114: case 0x1: {
5453 OPC_SwitchField, 24, 2, // 3116: switch Inst[25:24] {
5454 0, 7, // 3119: case 0x0: {
5455 OPC_CheckPredicate, 31, // 3121: check predicate 31
5456 OPC_Decode, 199, 8, 159, 2, // 3123: decode to BMNZI_B using decoder 287
5457 // 3123: }
5458 1, 7, // 3128: case 0x1: {
5459 OPC_CheckPredicate, 31, // 3130: check predicate 31
5460 OPC_Decode, 201, 8, 159, 2, // 3132: decode to BMZI_B using decoder 287
5461 // 3132: }
5462 2, 0, // 3137: case 0x2: {
5463 OPC_CheckPredicate, 31, // 3139: check predicate 31
5464 OPC_Decode, 249, 8, 159, 2, // 3141: decode to BSELI_B using decoder 287
5465 // 3141: }
5466 // 3141: } // switch Inst[25:24]
5467 // 3141: }
5468 2, 30, // 3146: case 0x2: {
5469 OPC_SwitchField, 24, 2, // 3148: switch Inst[25:24] {
5470 0, 7, // 3151: case 0x0: {
5471 OPC_CheckPredicate, 31, // 3153: check predicate 31
5472 OPC_Decode, 175, 21, 158, 2, // 3155: decode to SHF_B using decoder 286
5473 // 3155: }
5474 1, 7, // 3160: case 0x1: {
5475 OPC_CheckPredicate, 31, // 3162: check predicate 31
5476 OPC_Decode, 176, 21, 160, 2, // 3164: decode to SHF_H using decoder 288
5477 // 3164: }
5478 2, 0, // 3169: case 0x2: {
5479 OPC_CheckPredicate, 31, // 3171: check predicate 31
5480 OPC_Decode, 177, 21, 161, 2, // 3173: decode to SHF_W using decoder 289
5481 // 3173: }
5482 // 3173: } // switch Inst[25:24]
5483 // 3173: }
5484 6, 219, 1, // 3178: case 0x6: {
5485 OPC_SwitchField, 21, 5, // 3181: switch Inst[25:21] {
5486 0, 7, // 3184: case 0x0: {
5487 OPC_CheckPredicate, 31, // 3186: check predicate 31
5488 OPC_Decode, 221, 6, 162, 2, // 3188: decode to ADDVI_B using decoder 290
5489 // 3188: }
5490 1, 7, // 3193: case 0x1: {
5491 OPC_CheckPredicate, 31, // 3195: check predicate 31
5492 OPC_Decode, 223, 6, 163, 2, // 3197: decode to ADDVI_H using decoder 291
5493 // 3197: }
5494 2, 7, // 3202: case 0x2: {
5495 OPC_CheckPredicate, 31, // 3204: check predicate 31
5496 OPC_Decode, 224, 6, 164, 2, // 3206: decode to ADDVI_W using decoder 292
5497 // 3206: }
5498 3, 7, // 3211: case 0x3: {
5499 OPC_CheckPredicate, 31, // 3213: check predicate 31
5500 OPC_Decode, 222, 6, 165, 2, // 3215: decode to ADDVI_D using decoder 293
5501 // 3215: }
5502 4, 7, // 3220: case 0x4: {
5503 OPC_CheckPredicate, 31, // 3222: check predicate 31
5504 OPC_Decode, 135, 23, 162, 2, // 3224: decode to SUBVI_B using decoder 290
5505 // 3224: }
5506 5, 7, // 3229: case 0x5: {
5507 OPC_CheckPredicate, 31, // 3231: check predicate 31
5508 OPC_Decode, 137, 23, 163, 2, // 3233: decode to SUBVI_H using decoder 291
5509 // 3233: }
5510 6, 7, // 3238: case 0x6: {
5511 OPC_CheckPredicate, 31, // 3240: check predicate 31
5512 OPC_Decode, 138, 23, 164, 2, // 3242: decode to SUBVI_W using decoder 292
5513 // 3242: }
5514 7, 7, // 3247: case 0x7: {
5515 OPC_CheckPredicate, 31, // 3249: check predicate 31
5516 OPC_Decode, 136, 23, 165, 2, // 3251: decode to SUBVI_D using decoder 293
5517 // 3251: }
5518 8, 7, // 3256: case 0x8: {
5519 OPC_CheckPredicate, 31, // 3258: check predicate 31
5520 OPC_Decode, 132, 17, 162, 2, // 3260: decode to MAXI_S_B using decoder 290
5521 // 3260: }
5522 9, 7, // 3265: case 0x9: {
5523 OPC_CheckPredicate, 31, // 3267: check predicate 31
5524 OPC_Decode, 134, 17, 163, 2, // 3269: decode to MAXI_S_H using decoder 291
5525 // 3269: }
5526 10, 7, // 3274: case 0xa: {
5527 OPC_CheckPredicate, 31, // 3276: check predicate 31
5528 OPC_Decode, 135, 17, 164, 2, // 3278: decode to MAXI_S_W using decoder 292
5529 // 3278: }
5530 11, 7, // 3283: case 0xb: {
5531 OPC_CheckPredicate, 31, // 3285: check predicate 31
5532 OPC_Decode, 133, 17, 165, 2, // 3287: decode to MAXI_S_D using decoder 293
5533 // 3287: }
5534 12, 7, // 3292: case 0xc: {
5535 OPC_CheckPredicate, 31, // 3294: check predicate 31
5536 OPC_Decode, 136, 17, 162, 2, // 3296: decode to MAXI_U_B using decoder 290
5537 // 3296: }
5538 13, 7, // 3301: case 0xd: {
5539 OPC_CheckPredicate, 31, // 3303: check predicate 31
5540 OPC_Decode, 138, 17, 163, 2, // 3305: decode to MAXI_U_H using decoder 291
5541 // 3305: }
5542 14, 7, // 3310: case 0xe: {
5543 OPC_CheckPredicate, 31, // 3312: check predicate 31
5544 OPC_Decode, 139, 17, 164, 2, // 3314: decode to MAXI_U_W using decoder 292
5545 // 3314: }
5546 15, 7, // 3319: case 0xf: {
5547 OPC_CheckPredicate, 31, // 3321: check predicate 31
5548 OPC_Decode, 137, 17, 165, 2, // 3323: decode to MAXI_U_D using decoder 293
5549 // 3323: }
5550 16, 7, // 3328: case 0x10: {
5551 OPC_CheckPredicate, 31, // 3330: check predicate 31
5552 OPC_Decode, 194, 17, 162, 2, // 3332: decode to MINI_S_B using decoder 290
5553 // 3332: }
5554 17, 7, // 3337: case 0x11: {
5555 OPC_CheckPredicate, 31, // 3339: check predicate 31
5556 OPC_Decode, 196, 17, 163, 2, // 3341: decode to MINI_S_H using decoder 291
5557 // 3341: }
5558 18, 7, // 3346: case 0x12: {
5559 OPC_CheckPredicate, 31, // 3348: check predicate 31
5560 OPC_Decode, 197, 17, 164, 2, // 3350: decode to MINI_S_W using decoder 292
5561 // 3350: }
5562 19, 7, // 3355: case 0x13: {
5563 OPC_CheckPredicate, 31, // 3357: check predicate 31
5564 OPC_Decode, 195, 17, 165, 2, // 3359: decode to MINI_S_D using decoder 293
5565 // 3359: }
5566 20, 7, // 3364: case 0x14: {
5567 OPC_CheckPredicate, 31, // 3366: check predicate 31
5568 OPC_Decode, 198, 17, 162, 2, // 3368: decode to MINI_U_B using decoder 290
5569 // 3368: }
5570 21, 7, // 3373: case 0x15: {
5571 OPC_CheckPredicate, 31, // 3375: check predicate 31
5572 OPC_Decode, 200, 17, 163, 2, // 3377: decode to MINI_U_H using decoder 291
5573 // 3377: }
5574 22, 7, // 3382: case 0x16: {
5575 OPC_CheckPredicate, 31, // 3384: check predicate 31
5576 OPC_Decode, 201, 17, 164, 2, // 3386: decode to MINI_U_W using decoder 292
5577 // 3386: }
5578 23, 0, // 3391: case 0x17: {
5579 OPC_CheckPredicate, 31, // 3393: check predicate 31
5580 OPC_Decode, 199, 17, 165, 2, // 3395: decode to MINI_U_D using decoder 293
5581 // 3395: }
5582 // 3395: } // switch Inst[25:21]
5583 // 3395: }
5584 7, 219, 1, // 3400: case 0x7: {
5585 OPC_SwitchField, 21, 5, // 3403: switch Inst[25:21] {
5586 0, 7, // 3406: case 0x0: {
5587 OPC_CheckPredicate, 31, // 3408: check predicate 31
5588 OPC_Decode, 166, 9, 162, 2, // 3410: decode to CEQI_B using decoder 290
5589 // 3410: }
5590 1, 7, // 3415: case 0x1: {
5591 OPC_CheckPredicate, 31, // 3417: check predicate 31
5592 OPC_Decode, 168, 9, 163, 2, // 3419: decode to CEQI_H using decoder 291
5593 // 3419: }
5594 2, 7, // 3424: case 0x2: {
5595 OPC_CheckPredicate, 31, // 3426: check predicate 31
5596 OPC_Decode, 169, 9, 164, 2, // 3428: decode to CEQI_W using decoder 292
5597 // 3428: }
5598 3, 7, // 3433: case 0x3: {
5599 OPC_CheckPredicate, 31, // 3435: check predicate 31
5600 OPC_Decode, 167, 9, 165, 2, // 3437: decode to CEQI_D using decoder 293
5601 // 3437: }
5602 8, 7, // 3442: case 0x8: {
5603 OPC_CheckPredicate, 31, // 3444: check predicate 31
5604 OPC_Decode, 207, 9, 162, 2, // 3446: decode to CLTI_S_B using decoder 290
5605 // 3446: }
5606 9, 7, // 3451: case 0x9: {
5607 OPC_CheckPredicate, 31, // 3453: check predicate 31
5608 OPC_Decode, 209, 9, 163, 2, // 3455: decode to CLTI_S_H using decoder 291
5609 // 3455: }
5610 10, 7, // 3460: case 0xa: {
5611 OPC_CheckPredicate, 31, // 3462: check predicate 31
5612 OPC_Decode, 210, 9, 164, 2, // 3464: decode to CLTI_S_W using decoder 292
5613 // 3464: }
5614 11, 7, // 3469: case 0xb: {
5615 OPC_CheckPredicate, 31, // 3471: check predicate 31
5616 OPC_Decode, 208, 9, 165, 2, // 3473: decode to CLTI_S_D using decoder 293
5617 // 3473: }
5618 12, 7, // 3478: case 0xc: {
5619 OPC_CheckPredicate, 31, // 3480: check predicate 31
5620 OPC_Decode, 211, 9, 162, 2, // 3482: decode to CLTI_U_B using decoder 290
5621 // 3482: }
5622 13, 7, // 3487: case 0xd: {
5623 OPC_CheckPredicate, 31, // 3489: check predicate 31
5624 OPC_Decode, 213, 9, 163, 2, // 3491: decode to CLTI_U_H using decoder 291
5625 // 3491: }
5626 14, 7, // 3496: case 0xe: {
5627 OPC_CheckPredicate, 31, // 3498: check predicate 31
5628 OPC_Decode, 214, 9, 164, 2, // 3500: decode to CLTI_U_W using decoder 292
5629 // 3500: }
5630 15, 7, // 3505: case 0xf: {
5631 OPC_CheckPredicate, 31, // 3507: check predicate 31
5632 OPC_Decode, 212, 9, 165, 2, // 3509: decode to CLTI_U_D using decoder 293
5633 // 3509: }
5634 16, 7, // 3514: case 0x10: {
5635 OPC_CheckPredicate, 31, // 3516: check predicate 31
5636 OPC_Decode, 186, 9, 162, 2, // 3518: decode to CLEI_S_B using decoder 290
5637 // 3518: }
5638 17, 7, // 3523: case 0x11: {
5639 OPC_CheckPredicate, 31, // 3525: check predicate 31
5640 OPC_Decode, 188, 9, 163, 2, // 3527: decode to CLEI_S_H using decoder 291
5641 // 3527: }
5642 18, 7, // 3532: case 0x12: {
5643 OPC_CheckPredicate, 31, // 3534: check predicate 31
5644 OPC_Decode, 189, 9, 164, 2, // 3536: decode to CLEI_S_W using decoder 292
5645 // 3536: }
5646 19, 7, // 3541: case 0x13: {
5647 OPC_CheckPredicate, 31, // 3543: check predicate 31
5648 OPC_Decode, 187, 9, 165, 2, // 3545: decode to CLEI_S_D using decoder 293
5649 // 3545: }
5650 20, 7, // 3550: case 0x14: {
5651 OPC_CheckPredicate, 31, // 3552: check predicate 31
5652 OPC_Decode, 190, 9, 162, 2, // 3554: decode to CLEI_U_B using decoder 290
5653 // 3554: }
5654 21, 7, // 3559: case 0x15: {
5655 OPC_CheckPredicate, 31, // 3561: check predicate 31
5656 OPC_Decode, 192, 9, 163, 2, // 3563: decode to CLEI_U_H using decoder 291
5657 // 3563: }
5658 22, 7, // 3568: case 0x16: {
5659 OPC_CheckPredicate, 31, // 3570: check predicate 31
5660 OPC_Decode, 193, 9, 164, 2, // 3572: decode to CLEI_U_W using decoder 292
5661 // 3572: }
5662 23, 7, // 3577: case 0x17: {
5663 OPC_CheckPredicate, 31, // 3579: check predicate 31
5664 OPC_Decode, 191, 9, 165, 2, // 3581: decode to CLEI_U_D using decoder 293
5665 // 3581: }
5666 24, 7, // 3586: case 0x18: {
5667 OPC_CheckPredicate, 31, // 3588: check predicate 31
5668 OPC_Decode, 218, 15, 166, 2, // 3590: decode to LDI_B using decoder 294
5669 // 3590: }
5670 25, 7, // 3595: case 0x19: {
5671 OPC_CheckPredicate, 31, // 3597: check predicate 31
5672 OPC_Decode, 220, 15, 167, 2, // 3599: decode to LDI_H using decoder 295
5673 // 3599: }
5674 26, 7, // 3604: case 0x1a: {
5675 OPC_CheckPredicate, 31, // 3606: check predicate 31
5676 OPC_Decode, 221, 15, 168, 2, // 3608: decode to LDI_W using decoder 296
5677 // 3608: }
5678 27, 0, // 3613: case 0x1b: {
5679 OPC_CheckPredicate, 31, // 3615: check predicate 31
5680 OPC_Decode, 219, 15, 169, 2, // 3617: decode to LDI_D using decoder 297
5681 // 3617: }
5682 // 3617: } // switch Inst[25:21]
5683 // 3617: }
5684 9, 147, 3, // 3622: case 0x9: {
5685 OPC_SwitchField, 22, 4, // 3625: switch Inst[25:22] {
5686 0, 7, // 3628: case 0x0: {
5687 OPC_CheckPredicate, 31, // 3630: check predicate 31
5688 OPC_Decode, 251, 21, 170, 2, // 3632: decode to SLLI_D using decoder 298
5689 // 3632: }
5690 1, 39, // 3637: case 0x1: {
5691 OPC_SwitchField, 21, 1, // 3639: switch Inst[21] {
5692 0, 7, // 3642: case 0x0: {
5693 OPC_CheckPredicate, 31, // 3644: check predicate 31
5694 OPC_Decode, 253, 21, 164, 2, // 3646: decode to SLLI_W using decoder 292
5695 // 3646: }
5696 1, 0, // 3651: case 0x1: {
5697 OPC_SwitchField, 20, 1, // 3653: switch Inst[20] {
5698 0, 7, // 3656: case 0x0: {
5699 OPC_CheckPredicate, 31, // 3658: check predicate 31
5700 OPC_Decode, 252, 21, 171, 2, // 3660: decode to SLLI_H using decoder 299
5701 // 3660: }
5702 1, 0, // 3665: case 0x1: {
5703 OPC_CheckPredicate, 31, // 3667: check predicate 31
5704 OPC_CheckField, 19, 1, 0, // 3669: check Inst[19] == 0x0
5705 OPC_Decode, 250, 21, 172, 2, // 3673: decode to SLLI_B using decoder 300
5706 // 3673: }
5707 // 3673: } // switch Inst[20]
5708 // 3673: }
5709 // 3673: } // switch Inst[21]
5710 // 3673: }
5711 2, 7, // 3678: case 0x2: {
5712 OPC_CheckPredicate, 31, // 3680: check predicate 31
5713 OPC_Decode, 165, 22, 170, 2, // 3682: decode to SRAI_D using decoder 298
5714 // 3682: }
5715 3, 39, // 3687: case 0x3: {
5716 OPC_SwitchField, 21, 1, // 3689: switch Inst[21] {
5717 0, 7, // 3692: case 0x0: {
5718 OPC_CheckPredicate, 31, // 3694: check predicate 31
5719 OPC_Decode, 167, 22, 164, 2, // 3696: decode to SRAI_W using decoder 292
5720 // 3696: }
5721 1, 0, // 3701: case 0x1: {
5722 OPC_SwitchField, 20, 1, // 3703: switch Inst[20] {
5723 0, 7, // 3706: case 0x0: {
5724 OPC_CheckPredicate, 31, // 3708: check predicate 31
5725 OPC_Decode, 166, 22, 171, 2, // 3710: decode to SRAI_H using decoder 299
5726 // 3710: }
5727 1, 0, // 3715: case 0x1: {
5728 OPC_CheckPredicate, 31, // 3717: check predicate 31
5729 OPC_CheckField, 19, 1, 0, // 3719: check Inst[19] == 0x0
5730 OPC_Decode, 164, 22, 172, 2, // 3723: decode to SRAI_B using decoder 300
5731 // 3723: }
5732 // 3723: } // switch Inst[20]
5733 // 3723: }
5734 // 3723: } // switch Inst[21]
5735 // 3723: }
5736 4, 7, // 3728: case 0x4: {
5737 OPC_CheckPredicate, 31, // 3730: check predicate 31
5738 OPC_Decode, 190, 22, 170, 2, // 3732: decode to SRLI_D using decoder 298
5739 // 3732: }
5740 5, 39, // 3737: case 0x5: {
5741 OPC_SwitchField, 21, 1, // 3739: switch Inst[21] {
5742 0, 7, // 3742: case 0x0: {
5743 OPC_CheckPredicate, 31, // 3744: check predicate 31
5744 OPC_Decode, 192, 22, 164, 2, // 3746: decode to SRLI_W using decoder 292
5745 // 3746: }
5746 1, 0, // 3751: case 0x1: {
5747 OPC_SwitchField, 20, 1, // 3753: switch Inst[20] {
5748 0, 7, // 3756: case 0x0: {
5749 OPC_CheckPredicate, 31, // 3758: check predicate 31
5750 OPC_Decode, 191, 22, 171, 2, // 3760: decode to SRLI_H using decoder 299
5751 // 3760: }
5752 1, 0, // 3765: case 0x1: {
5753 OPC_CheckPredicate, 31, // 3767: check predicate 31
5754 OPC_CheckField, 19, 1, 0, // 3769: check Inst[19] == 0x0
5755 OPC_Decode, 189, 22, 172, 2, // 3773: decode to SRLI_B using decoder 300
5756 // 3773: }
5757 // 3773: } // switch Inst[20]
5758 // 3773: }
5759 // 3773: } // switch Inst[21]
5760 // 3773: }
5761 6, 7, // 3778: case 0x6: {
5762 OPC_CheckPredicate, 31, // 3780: check predicate 31
5763 OPC_Decode, 215, 7, 170, 2, // 3782: decode to BCLRI_D using decoder 298
5764 // 3782: }
5765 7, 39, // 3787: case 0x7: {
5766 OPC_SwitchField, 21, 1, // 3789: switch Inst[21] {
5767 0, 7, // 3792: case 0x0: {
5768 OPC_CheckPredicate, 31, // 3794: check predicate 31
5769 OPC_Decode, 217, 7, 164, 2, // 3796: decode to BCLRI_W using decoder 292
5770 // 3796: }
5771 1, 0, // 3801: case 0x1: {
5772 OPC_SwitchField, 20, 1, // 3803: switch Inst[20] {
5773 0, 7, // 3806: case 0x0: {
5774 OPC_CheckPredicate, 31, // 3808: check predicate 31
5775 OPC_Decode, 216, 7, 171, 2, // 3810: decode to BCLRI_H using decoder 299
5776 // 3810: }
5777 1, 0, // 3815: case 0x1: {
5778 OPC_CheckPredicate, 31, // 3817: check predicate 31
5779 OPC_CheckField, 19, 1, 0, // 3819: check Inst[19] == 0x0
5780 OPC_Decode, 214, 7, 172, 2, // 3823: decode to BCLRI_B using decoder 300
5781 // 3823: }
5782 // 3823: } // switch Inst[20]
5783 // 3823: }
5784 // 3823: } // switch Inst[21]
5785 // 3823: }
5786 8, 7, // 3828: case 0x8: {
5787 OPC_CheckPredicate, 31, // 3830: check predicate 31
5788 OPC_Decode, 252, 8, 170, 2, // 3832: decode to BSETI_D using decoder 298
5789 // 3832: }
5790 9, 39, // 3837: case 0x9: {
5791 OPC_SwitchField, 21, 1, // 3839: switch Inst[21] {
5792 0, 7, // 3842: case 0x0: {
5793 OPC_CheckPredicate, 31, // 3844: check predicate 31
5794 OPC_Decode, 254, 8, 164, 2, // 3846: decode to BSETI_W using decoder 292
5795 // 3846: }
5796 1, 0, // 3851: case 0x1: {
5797 OPC_SwitchField, 20, 1, // 3853: switch Inst[20] {
5798 0, 7, // 3856: case 0x0: {
5799 OPC_CheckPredicate, 31, // 3858: check predicate 31
5800 OPC_Decode, 253, 8, 171, 2, // 3860: decode to BSETI_H using decoder 299
5801 // 3860: }
5802 1, 0, // 3865: case 0x1: {
5803 OPC_CheckPredicate, 31, // 3867: check predicate 31
5804 OPC_CheckField, 19, 1, 0, // 3869: check Inst[19] == 0x0
5805 OPC_Decode, 251, 8, 172, 2, // 3873: decode to BSETI_B using decoder 300
5806 // 3873: }
5807 // 3873: } // switch Inst[20]
5808 // 3873: }
5809 // 3873: } // switch Inst[21]
5810 // 3873: }
5811 10, 7, // 3878: case 0xa: {
5812 OPC_CheckPredicate, 31, // 3880: check predicate 31
5813 OPC_Decode, 210, 8, 170, 2, // 3882: decode to BNEGI_D using decoder 298
5814 // 3882: }
5815 11, 39, // 3887: case 0xb: {
5816 OPC_SwitchField, 21, 1, // 3889: switch Inst[21] {
5817 0, 7, // 3892: case 0x0: {
5818 OPC_CheckPredicate, 31, // 3894: check predicate 31
5819 OPC_Decode, 212, 8, 164, 2, // 3896: decode to BNEGI_W using decoder 292
5820 // 3896: }
5821 1, 0, // 3901: case 0x1: {
5822 OPC_SwitchField, 20, 1, // 3903: switch Inst[20] {
5823 0, 7, // 3906: case 0x0: {
5824 OPC_CheckPredicate, 31, // 3908: check predicate 31
5825 OPC_Decode, 211, 8, 171, 2, // 3910: decode to BNEGI_H using decoder 299
5826 // 3910: }
5827 1, 0, // 3915: case 0x1: {
5828 OPC_CheckPredicate, 31, // 3917: check predicate 31
5829 OPC_CheckField, 19, 1, 0, // 3919: check Inst[19] == 0x0
5830 OPC_Decode, 209, 8, 172, 2, // 3923: decode to BNEGI_B using decoder 300
5831 // 3923: }
5832 // 3923: } // switch Inst[20]
5833 // 3923: }
5834 // 3923: } // switch Inst[21]
5835 // 3923: }
5836 12, 7, // 3928: case 0xc: {
5837 OPC_CheckPredicate, 31, // 3930: check predicate 31
5838 OPC_Decode, 147, 8, 173, 2, // 3932: decode to BINSLI_D using decoder 301
5839 // 3932: }
5840 13, 39, // 3937: case 0xd: {
5841 OPC_SwitchField, 21, 1, // 3939: switch Inst[21] {
5842 0, 7, // 3942: case 0x0: {
5843 OPC_CheckPredicate, 31, // 3944: check predicate 31
5844 OPC_Decode, 149, 8, 174, 2, // 3946: decode to BINSLI_W using decoder 302
5845 // 3946: }
5846 1, 0, // 3951: case 0x1: {
5847 OPC_SwitchField, 20, 1, // 3953: switch Inst[20] {
5848 0, 7, // 3956: case 0x0: {
5849 OPC_CheckPredicate, 31, // 3958: check predicate 31
5850 OPC_Decode, 148, 8, 175, 2, // 3960: decode to BINSLI_H using decoder 303
5851 // 3960: }
5852 1, 0, // 3965: case 0x1: {
5853 OPC_CheckPredicate, 31, // 3967: check predicate 31
5854 OPC_CheckField, 19, 1, 0, // 3969: check Inst[19] == 0x0
5855 OPC_Decode, 146, 8, 176, 2, // 3973: decode to BINSLI_B using decoder 304
5856 // 3973: }
5857 // 3973: } // switch Inst[20]
5858 // 3973: }
5859 // 3973: } // switch Inst[21]
5860 // 3973: }
5861 14, 7, // 3978: case 0xe: {
5862 OPC_CheckPredicate, 31, // 3980: check predicate 31
5863 OPC_Decode, 155, 8, 173, 2, // 3982: decode to BINSRI_D using decoder 301
5864 // 3982: }
5865 15, 0, // 3987: case 0xf: {
5866 OPC_SwitchField, 21, 1, // 3989: switch Inst[21] {
5867 0, 7, // 3992: case 0x0: {
5868 OPC_CheckPredicate, 31, // 3994: check predicate 31
5869 OPC_Decode, 157, 8, 174, 2, // 3996: decode to BINSRI_W using decoder 302
5870 // 3996: }
5871 1, 0, // 4001: case 0x1: {
5872 OPC_SwitchField, 20, 1, // 4003: switch Inst[20] {
5873 0, 7, // 4006: case 0x0: {
5874 OPC_CheckPredicate, 31, // 4008: check predicate 31
5875 OPC_Decode, 156, 8, 175, 2, // 4010: decode to BINSRI_H using decoder 303
5876 // 4010: }
5877 1, 0, // 4015: case 0x1: {
5878 OPC_CheckPredicate, 31, // 4017: check predicate 31
5879 OPC_CheckField, 19, 1, 0, // 4019: check Inst[19] == 0x0
5880 OPC_Decode, 154, 8, 176, 2, // 4023: decode to BINSRI_B using decoder 304
5881 // 4023: }
5882 // 4023: } // switch Inst[20]
5883 // 4023: }
5884 // 4023: } // switch Inst[21]
5885 // 4023: }
5886 // 4023: } // switch Inst[25:22]
5887 // 4023: }
5888 10, 203, 1, // 4028: case 0xa: {
5889 OPC_SwitchField, 22, 4, // 4031: switch Inst[25:22] {
5890 0, 7, // 4034: case 0x0: {
5891 OPC_CheckPredicate, 31, // 4036: check predicate 31
5892 OPC_Decode, 209, 20, 170, 2, // 4038: decode to SAT_S_D using decoder 298
5893 // 4038: }
5894 1, 39, // 4043: case 0x1: {
5895 OPC_SwitchField, 21, 1, // 4045: switch Inst[21] {
5896 0, 7, // 4048: case 0x0: {
5897 OPC_CheckPredicate, 31, // 4050: check predicate 31
5898 OPC_Decode, 211, 20, 164, 2, // 4052: decode to SAT_S_W using decoder 292
5899 // 4052: }
5900 1, 0, // 4057: case 0x1: {
5901 OPC_SwitchField, 20, 1, // 4059: switch Inst[20] {
5902 0, 7, // 4062: case 0x0: {
5903 OPC_CheckPredicate, 31, // 4064: check predicate 31
5904 OPC_Decode, 210, 20, 171, 2, // 4066: decode to SAT_S_H using decoder 299
5905 // 4066: }
5906 1, 0, // 4071: case 0x1: {
5907 OPC_CheckPredicate, 31, // 4073: check predicate 31
5908 OPC_CheckField, 19, 1, 0, // 4075: check Inst[19] == 0x0
5909 OPC_Decode, 208, 20, 172, 2, // 4079: decode to SAT_S_B using decoder 300
5910 // 4079: }
5911 // 4079: } // switch Inst[20]
5912 // 4079: }
5913 // 4079: } // switch Inst[21]
5914 // 4079: }
5915 2, 7, // 4084: case 0x2: {
5916 OPC_CheckPredicate, 31, // 4086: check predicate 31
5917 OPC_Decode, 213, 20, 170, 2, // 4088: decode to SAT_U_D using decoder 298
5918 // 4088: }
5919 3, 39, // 4093: case 0x3: {
5920 OPC_SwitchField, 21, 1, // 4095: switch Inst[21] {
5921 0, 7, // 4098: case 0x0: {
5922 OPC_CheckPredicate, 31, // 4100: check predicate 31
5923 OPC_Decode, 215, 20, 164, 2, // 4102: decode to SAT_U_W using decoder 292
5924 // 4102: }
5925 1, 0, // 4107: case 0x1: {
5926 OPC_SwitchField, 20, 1, // 4109: switch Inst[20] {
5927 0, 7, // 4112: case 0x0: {
5928 OPC_CheckPredicate, 31, // 4114: check predicate 31
5929 OPC_Decode, 214, 20, 171, 2, // 4116: decode to SAT_U_H using decoder 299
5930 // 4116: }
5931 1, 0, // 4121: case 0x1: {
5932 OPC_CheckPredicate, 31, // 4123: check predicate 31
5933 OPC_CheckField, 19, 1, 0, // 4125: check Inst[19] == 0x0
5934 OPC_Decode, 212, 20, 172, 2, // 4129: decode to SAT_U_B using decoder 300
5935 // 4129: }
5936 // 4129: } // switch Inst[20]
5937 // 4129: }
5938 // 4129: } // switch Inst[21]
5939 // 4129: }
5940 4, 7, // 4134: case 0x4: {
5941 OPC_CheckPredicate, 31, // 4136: check predicate 31
5942 OPC_Decode, 169, 22, 170, 2, // 4138: decode to SRARI_D using decoder 298
5943 // 4138: }
5944 5, 39, // 4143: case 0x5: {
5945 OPC_SwitchField, 21, 1, // 4145: switch Inst[21] {
5946 0, 7, // 4148: case 0x0: {
5947 OPC_CheckPredicate, 31, // 4150: check predicate 31
5948 OPC_Decode, 171, 22, 164, 2, // 4152: decode to SRARI_W using decoder 292
5949 // 4152: }
5950 1, 0, // 4157: case 0x1: {
5951 OPC_SwitchField, 20, 1, // 4159: switch Inst[20] {
5952 0, 7, // 4162: case 0x0: {
5953 OPC_CheckPredicate, 31, // 4164: check predicate 31
5954 OPC_Decode, 170, 22, 171, 2, // 4166: decode to SRARI_H using decoder 299
5955 // 4166: }
5956 1, 0, // 4171: case 0x1: {
5957 OPC_CheckPredicate, 31, // 4173: check predicate 31
5958 OPC_CheckField, 19, 1, 0, // 4175: check Inst[19] == 0x0
5959 OPC_Decode, 168, 22, 172, 2, // 4179: decode to SRARI_B using decoder 300
5960 // 4179: }
5961 // 4179: } // switch Inst[20]
5962 // 4179: }
5963 // 4179: } // switch Inst[21]
5964 // 4179: }
5965 6, 7, // 4184: case 0x6: {
5966 OPC_CheckPredicate, 31, // 4186: check predicate 31
5967 OPC_Decode, 194, 22, 170, 2, // 4188: decode to SRLRI_D using decoder 298
5968 // 4188: }
5969 7, 0, // 4193: case 0x7: {
5970 OPC_SwitchField, 21, 1, // 4195: switch Inst[21] {
5971 0, 7, // 4198: case 0x0: {
5972 OPC_CheckPredicate, 31, // 4200: check predicate 31
5973 OPC_Decode, 196, 22, 164, 2, // 4202: decode to SRLRI_W using decoder 292
5974 // 4202: }
5975 1, 0, // 4207: case 0x1: {
5976 OPC_SwitchField, 20, 1, // 4209: switch Inst[20] {
5977 0, 7, // 4212: case 0x0: {
5978 OPC_CheckPredicate, 31, // 4214: check predicate 31
5979 OPC_Decode, 195, 22, 171, 2, // 4216: decode to SRLRI_H using decoder 299
5980 // 4216: }
5981 1, 0, // 4221: case 0x1: {
5982 OPC_CheckPredicate, 31, // 4223: check predicate 31
5983 OPC_CheckField, 19, 1, 0, // 4225: check Inst[19] == 0x0
5984 OPC_Decode, 193, 22, 172, 2, // 4229: decode to SRLRI_B using decoder 300
5985 // 4229: }
5986 // 4229: } // switch Inst[20]
5987 // 4229: }
5988 // 4229: } // switch Inst[21]
5989 // 4229: }
5990 // 4229: } // switch Inst[25:22]
5991 // 4229: }
5992 13, 163, 2, // 4234: case 0xd: {
5993 OPC_SwitchField, 21, 5, // 4237: switch Inst[25:21] {
5994 0, 7, // 4240: case 0x0: {
5995 OPC_CheckPredicate, 31, // 4242: check predicate 31
5996 OPC_Decode, 129, 22, 177, 2, // 4244: decode to SLL_B using decoder 305
5997 // 4244: }
5998 1, 7, // 4249: case 0x1: {
5999 OPC_CheckPredicate, 31, // 4251: check predicate 31
6000 OPC_Decode, 131, 22, 178, 2, // 4253: decode to SLL_H using decoder 306
6001 // 4253: }
6002 2, 7, // 4258: case 0x2: {
6003 OPC_CheckPredicate, 31, // 4260: check predicate 31
6004 OPC_Decode, 135, 22, 179, 2, // 4262: decode to SLL_W using decoder 307
6005 // 4262: }
6006 3, 7, // 4267: case 0x3: {
6007 OPC_CheckPredicate, 31, // 4269: check predicate 31
6008 OPC_Decode, 130, 22, 180, 2, // 4271: decode to SLL_D using decoder 308
6009 // 4271: }
6010 4, 7, // 4276: case 0x4: {
6011 OPC_CheckPredicate, 31, // 4278: check predicate 31
6012 OPC_Decode, 179, 22, 177, 2, // 4280: decode to SRA_B using decoder 305
6013 // 4280: }
6014 5, 7, // 4285: case 0x5: {
6015 OPC_CheckPredicate, 31, // 4287: check predicate 31
6016 OPC_Decode, 181, 22, 178, 2, // 4289: decode to SRA_H using decoder 306
6017 // 4289: }
6018 6, 7, // 4294: case 0x6: {
6019 OPC_CheckPredicate, 31, // 4296: check predicate 31
6020 OPC_Decode, 184, 22, 179, 2, // 4298: decode to SRA_W using decoder 307
6021 // 4298: }
6022 7, 7, // 4303: case 0x7: {
6023 OPC_CheckPredicate, 31, // 4305: check predicate 31
6024 OPC_Decode, 180, 22, 180, 2, // 4307: decode to SRA_D using decoder 308
6025 // 4307: }
6026 8, 7, // 4312: case 0x8: {
6027 OPC_CheckPredicate, 31, // 4314: check predicate 31
6028 OPC_Decode, 204, 22, 177, 2, // 4316: decode to SRL_B using decoder 305
6029 // 4316: }
6030 9, 7, // 4321: case 0x9: {
6031 OPC_CheckPredicate, 31, // 4323: check predicate 31
6032 OPC_Decode, 206, 22, 178, 2, // 4325: decode to SRL_H using decoder 306
6033 // 4325: }
6034 10, 7, // 4330: case 0xa: {
6035 OPC_CheckPredicate, 31, // 4332: check predicate 31
6036 OPC_Decode, 209, 22, 179, 2, // 4334: decode to SRL_W using decoder 307
6037 // 4334: }
6038 11, 7, // 4339: case 0xb: {
6039 OPC_CheckPredicate, 31, // 4341: check predicate 31
6040 OPC_Decode, 205, 22, 180, 2, // 4343: decode to SRL_D using decoder 308
6041 // 4343: }
6042 12, 7, // 4348: case 0xc: {
6043 OPC_CheckPredicate, 31, // 4350: check predicate 31
6044 OPC_Decode, 218, 7, 177, 2, // 4352: decode to BCLR_B using decoder 305
6045 // 4352: }
6046 13, 7, // 4357: case 0xd: {
6047 OPC_CheckPredicate, 31, // 4359: check predicate 31
6048 OPC_Decode, 220, 7, 178, 2, // 4361: decode to BCLR_H using decoder 306
6049 // 4361: }
6050 14, 7, // 4366: case 0xe: {
6051 OPC_CheckPredicate, 31, // 4368: check predicate 31
6052 OPC_Decode, 221, 7, 179, 2, // 4370: decode to BCLR_W using decoder 307
6053 // 4370: }
6054 15, 7, // 4375: case 0xf: {
6055 OPC_CheckPredicate, 31, // 4377: check predicate 31
6056 OPC_Decode, 219, 7, 180, 2, // 4379: decode to BCLR_D using decoder 308
6057 // 4379: }
6058 16, 7, // 4384: case 0x10: {
6059 OPC_CheckPredicate, 31, // 4386: check predicate 31
6060 OPC_Decode, 255, 8, 177, 2, // 4388: decode to BSET_B using decoder 305
6061 // 4388: }
6062 17, 7, // 4393: case 0x11: {
6063 OPC_CheckPredicate, 31, // 4395: check predicate 31
6064 OPC_Decode, 129, 9, 178, 2, // 4397: decode to BSET_H using decoder 306
6065 // 4397: }
6066 18, 7, // 4402: case 0x12: {
6067 OPC_CheckPredicate, 31, // 4404: check predicate 31
6068 OPC_Decode, 130, 9, 179, 2, // 4406: decode to BSET_W using decoder 307
6069 // 4406: }
6070 19, 7, // 4411: case 0x13: {
6071 OPC_CheckPredicate, 31, // 4413: check predicate 31
6072 OPC_Decode, 128, 9, 180, 2, // 4415: decode to BSET_D using decoder 308
6073 // 4415: }
6074 20, 7, // 4420: case 0x14: {
6075 OPC_CheckPredicate, 31, // 4422: check predicate 31
6076 OPC_Decode, 213, 8, 177, 2, // 4424: decode to BNEG_B using decoder 305
6077 // 4424: }
6078 21, 7, // 4429: case 0x15: {
6079 OPC_CheckPredicate, 31, // 4431: check predicate 31
6080 OPC_Decode, 215, 8, 178, 2, // 4433: decode to BNEG_H using decoder 306
6081 // 4433: }
6082 22, 7, // 4438: case 0x16: {
6083 OPC_CheckPredicate, 31, // 4440: check predicate 31
6084 OPC_Decode, 216, 8, 179, 2, // 4442: decode to BNEG_W using decoder 307
6085 // 4442: }
6086 23, 7, // 4447: case 0x17: {
6087 OPC_CheckPredicate, 31, // 4449: check predicate 31
6088 OPC_Decode, 214, 8, 180, 2, // 4451: decode to BNEG_D using decoder 308
6089 // 4451: }
6090 24, 7, // 4456: case 0x18: {
6091 OPC_CheckPredicate, 31, // 4458: check predicate 31
6092 OPC_Decode, 150, 8, 181, 2, // 4460: decode to BINSL_B using decoder 309
6093 // 4460: }
6094 25, 7, // 4465: case 0x19: {
6095 OPC_CheckPredicate, 31, // 4467: check predicate 31
6096 OPC_Decode, 152, 8, 182, 2, // 4469: decode to BINSL_H using decoder 310
6097 // 4469: }
6098 26, 7, // 4474: case 0x1a: {
6099 OPC_CheckPredicate, 31, // 4476: check predicate 31
6100 OPC_Decode, 153, 8, 183, 2, // 4478: decode to BINSL_W using decoder 311
6101 // 4478: }
6102 27, 7, // 4483: case 0x1b: {
6103 OPC_CheckPredicate, 31, // 4485: check predicate 31
6104 OPC_Decode, 151, 8, 184, 2, // 4487: decode to BINSL_D using decoder 312
6105 // 4487: }
6106 28, 7, // 4492: case 0x1c: {
6107 OPC_CheckPredicate, 31, // 4494: check predicate 31
6108 OPC_Decode, 158, 8, 181, 2, // 4496: decode to BINSR_B using decoder 309
6109 // 4496: }
6110 29, 7, // 4501: case 0x1d: {
6111 OPC_CheckPredicate, 31, // 4503: check predicate 31
6112 OPC_Decode, 160, 8, 182, 2, // 4505: decode to BINSR_H using decoder 310
6113 // 4505: }
6114 30, 7, // 4510: case 0x1e: {
6115 OPC_CheckPredicate, 31, // 4512: check predicate 31
6116 OPC_Decode, 161, 8, 183, 2, // 4514: decode to BINSR_W using decoder 311
6117 // 4514: }
6118 31, 0, // 4519: case 0x1f: {
6119 OPC_CheckPredicate, 31, // 4521: check predicate 31
6120 OPC_Decode, 159, 8, 184, 2, // 4523: decode to BINSR_D using decoder 312
6121 // 4523: }
6122 // 4523: } // switch Inst[25:21]
6123 // 4523: }
6124 14, 163, 2, // 4528: case 0xe: {
6125 OPC_SwitchField, 21, 5, // 4531: switch Inst[25:21] {
6126 0, 7, // 4534: case 0x0: {
6127 OPC_CheckPredicate, 31, // 4536: check predicate 31
6128 OPC_Decode, 225, 6, 177, 2, // 4538: decode to ADDV_B using decoder 305
6129 // 4538: }
6130 1, 7, // 4543: case 0x1: {
6131 OPC_CheckPredicate, 31, // 4545: check predicate 31
6132 OPC_Decode, 227, 6, 178, 2, // 4547: decode to ADDV_H using decoder 306
6133 // 4547: }
6134 2, 7, // 4552: case 0x2: {
6135 OPC_CheckPredicate, 31, // 4554: check predicate 31
6136 OPC_Decode, 228, 6, 179, 2, // 4556: decode to ADDV_W using decoder 307
6137 // 4556: }
6138 3, 7, // 4561: case 0x3: {
6139 OPC_CheckPredicate, 31, // 4563: check predicate 31
6140 OPC_Decode, 226, 6, 180, 2, // 4565: decode to ADDV_D using decoder 308
6141 // 4565: }
6142 4, 7, // 4570: case 0x4: {
6143 OPC_CheckPredicate, 31, // 4572: check predicate 31
6144 OPC_Decode, 139, 23, 177, 2, // 4574: decode to SUBV_B using decoder 305
6145 // 4574: }
6146 5, 7, // 4579: case 0x5: {
6147 OPC_CheckPredicate, 31, // 4581: check predicate 31
6148 OPC_Decode, 141, 23, 178, 2, // 4583: decode to SUBV_H using decoder 306
6149 // 4583: }
6150 6, 7, // 4588: case 0x6: {
6151 OPC_CheckPredicate, 31, // 4590: check predicate 31
6152 OPC_Decode, 142, 23, 179, 2, // 4592: decode to SUBV_W using decoder 307
6153 // 4592: }
6154 7, 7, // 4597: case 0x7: {
6155 OPC_CheckPredicate, 31, // 4599: check predicate 31
6156 OPC_Decode, 140, 23, 180, 2, // 4601: decode to SUBV_D using decoder 308
6157 // 4601: }
6158 8, 7, // 4606: case 0x8: {
6159 OPC_CheckPredicate, 31, // 4608: check predicate 31
6160 OPC_Decode, 147, 17, 177, 2, // 4610: decode to MAX_S_B using decoder 305
6161 // 4610: }
6162 9, 7, // 4615: case 0x9: {
6163 OPC_CheckPredicate, 31, // 4617: check predicate 31
6164 OPC_Decode, 149, 17, 178, 2, // 4619: decode to MAX_S_H using decoder 306
6165 // 4619: }
6166 10, 7, // 4624: case 0xa: {
6167 OPC_CheckPredicate, 31, // 4626: check predicate 31
6168 OPC_Decode, 151, 17, 179, 2, // 4628: decode to MAX_S_W using decoder 307
6169 // 4628: }
6170 11, 7, // 4633: case 0xb: {
6171 OPC_CheckPredicate, 31, // 4635: check predicate 31
6172 OPC_Decode, 148, 17, 180, 2, // 4637: decode to MAX_S_D using decoder 308
6173 // 4637: }
6174 12, 7, // 4642: case 0xc: {
6175 OPC_CheckPredicate, 31, // 4644: check predicate 31
6176 OPC_Decode, 152, 17, 177, 2, // 4646: decode to MAX_U_B using decoder 305
6177 // 4646: }
6178 13, 7, // 4651: case 0xd: {
6179 OPC_CheckPredicate, 31, // 4653: check predicate 31
6180 OPC_Decode, 154, 17, 178, 2, // 4655: decode to MAX_U_H using decoder 306
6181 // 4655: }
6182 14, 7, // 4660: case 0xe: {
6183 OPC_CheckPredicate, 31, // 4662: check predicate 31
6184 OPC_Decode, 155, 17, 179, 2, // 4664: decode to MAX_U_W using decoder 307
6185 // 4664: }
6186 15, 7, // 4669: case 0xf: {
6187 OPC_CheckPredicate, 31, // 4671: check predicate 31
6188 OPC_Decode, 153, 17, 180, 2, // 4673: decode to MAX_U_D using decoder 308
6189 // 4673: }
6190 16, 7, // 4678: case 0x10: {
6191 OPC_CheckPredicate, 31, // 4680: check predicate 31
6192 OPC_Decode, 209, 17, 177, 2, // 4682: decode to MIN_S_B using decoder 305
6193 // 4682: }
6194 17, 7, // 4687: case 0x11: {
6195 OPC_CheckPredicate, 31, // 4689: check predicate 31
6196 OPC_Decode, 211, 17, 178, 2, // 4691: decode to MIN_S_H using decoder 306
6197 // 4691: }
6198 18, 7, // 4696: case 0x12: {
6199 OPC_CheckPredicate, 31, // 4698: check predicate 31
6200 OPC_Decode, 213, 17, 179, 2, // 4700: decode to MIN_S_W using decoder 307
6201 // 4700: }
6202 19, 7, // 4705: case 0x13: {
6203 OPC_CheckPredicate, 31, // 4707: check predicate 31
6204 OPC_Decode, 210, 17, 180, 2, // 4709: decode to MIN_S_D using decoder 308
6205 // 4709: }
6206 20, 7, // 4714: case 0x14: {
6207 OPC_CheckPredicate, 31, // 4716: check predicate 31
6208 OPC_Decode, 214, 17, 177, 2, // 4718: decode to MIN_U_B using decoder 305
6209 // 4718: }
6210 21, 7, // 4723: case 0x15: {
6211 OPC_CheckPredicate, 31, // 4725: check predicate 31
6212 OPC_Decode, 216, 17, 178, 2, // 4727: decode to MIN_U_H using decoder 306
6213 // 4727: }
6214 22, 7, // 4732: case 0x16: {
6215 OPC_CheckPredicate, 31, // 4734: check predicate 31
6216 OPC_Decode, 217, 17, 179, 2, // 4736: decode to MIN_U_W using decoder 307
6217 // 4736: }
6218 23, 7, // 4741: case 0x17: {
6219 OPC_CheckPredicate, 31, // 4743: check predicate 31
6220 OPC_Decode, 215, 17, 180, 2, // 4745: decode to MIN_U_D using decoder 308
6221 // 4745: }
6222 24, 7, // 4750: case 0x18: {
6223 OPC_CheckPredicate, 31, // 4752: check predicate 31
6224 OPC_Decode, 140, 17, 177, 2, // 4754: decode to MAX_A_B using decoder 305
6225 // 4754: }
6226 25, 7, // 4759: case 0x19: {
6227 OPC_CheckPredicate, 31, // 4761: check predicate 31
6228 OPC_Decode, 142, 17, 178, 2, // 4763: decode to MAX_A_H using decoder 306
6229 // 4763: }
6230 26, 7, // 4768: case 0x1a: {
6231 OPC_CheckPredicate, 31, // 4770: check predicate 31
6232 OPC_Decode, 143, 17, 179, 2, // 4772: decode to MAX_A_W using decoder 307
6233 // 4772: }
6234 27, 7, // 4777: case 0x1b: {
6235 OPC_CheckPredicate, 31, // 4779: check predicate 31
6236 OPC_Decode, 141, 17, 180, 2, // 4781: decode to MAX_A_D using decoder 308
6237 // 4781: }
6238 28, 7, // 4786: case 0x1c: {
6239 OPC_CheckPredicate, 31, // 4788: check predicate 31
6240 OPC_Decode, 202, 17, 177, 2, // 4790: decode to MIN_A_B using decoder 305
6241 // 4790: }
6242 29, 7, // 4795: case 0x1d: {
6243 OPC_CheckPredicate, 31, // 4797: check predicate 31
6244 OPC_Decode, 204, 17, 178, 2, // 4799: decode to MIN_A_H using decoder 306
6245 // 4799: }
6246 30, 7, // 4804: case 0x1e: {
6247 OPC_CheckPredicate, 31, // 4806: check predicate 31
6248 OPC_Decode, 205, 17, 179, 2, // 4808: decode to MIN_A_W using decoder 307
6249 // 4808: }
6250 31, 0, // 4813: case 0x1f: {
6251 OPC_CheckPredicate, 31, // 4815: check predicate 31
6252 OPC_Decode, 203, 17, 180, 2, // 4817: decode to MIN_A_D using decoder 308
6253 // 4817: }
6254 // 4817: } // switch Inst[25:21]
6255 // 4817: }
6256 15, 183, 1, // 4822: case 0xf: {
6257 OPC_SwitchField, 21, 5, // 4825: switch Inst[25:21] {
6258 0, 7, // 4828: case 0x0: {
6259 OPC_CheckPredicate, 31, // 4830: check predicate 31
6260 OPC_Decode, 170, 9, 177, 2, // 4832: decode to CEQ_B using decoder 305
6261 // 4832: }
6262 1, 7, // 4837: case 0x1: {
6263 OPC_CheckPredicate, 31, // 4839: check predicate 31
6264 OPC_Decode, 172, 9, 178, 2, // 4841: decode to CEQ_H using decoder 306
6265 // 4841: }
6266 2, 7, // 4846: case 0x2: {
6267 OPC_CheckPredicate, 31, // 4848: check predicate 31
6268 OPC_Decode, 173, 9, 179, 2, // 4850: decode to CEQ_W using decoder 307
6269 // 4850: }
6270 3, 7, // 4855: case 0x3: {
6271 OPC_CheckPredicate, 31, // 4857: check predicate 31
6272 OPC_Decode, 171, 9, 180, 2, // 4859: decode to CEQ_D using decoder 308
6273 // 4859: }
6274 8, 7, // 4864: case 0x8: {
6275 OPC_CheckPredicate, 31, // 4866: check predicate 31
6276 OPC_Decode, 215, 9, 177, 2, // 4868: decode to CLT_S_B using decoder 305
6277 // 4868: }
6278 9, 7, // 4873: case 0x9: {
6279 OPC_CheckPredicate, 31, // 4875: check predicate 31
6280 OPC_Decode, 217, 9, 178, 2, // 4877: decode to CLT_S_H using decoder 306
6281 // 4877: }
6282 10, 7, // 4882: case 0xa: {
6283 OPC_CheckPredicate, 31, // 4884: check predicate 31
6284 OPC_Decode, 218, 9, 179, 2, // 4886: decode to CLT_S_W using decoder 307
6285 // 4886: }
6286 11, 7, // 4891: case 0xb: {
6287 OPC_CheckPredicate, 31, // 4893: check predicate 31
6288 OPC_Decode, 216, 9, 180, 2, // 4895: decode to CLT_S_D using decoder 308
6289 // 4895: }
6290 12, 7, // 4900: case 0xc: {
6291 OPC_CheckPredicate, 31, // 4902: check predicate 31
6292 OPC_Decode, 219, 9, 177, 2, // 4904: decode to CLT_U_B using decoder 305
6293 // 4904: }
6294 13, 7, // 4909: case 0xd: {
6295 OPC_CheckPredicate, 31, // 4911: check predicate 31
6296 OPC_Decode, 221, 9, 178, 2, // 4913: decode to CLT_U_H using decoder 306
6297 // 4913: }
6298 14, 7, // 4918: case 0xe: {
6299 OPC_CheckPredicate, 31, // 4920: check predicate 31
6300 OPC_Decode, 222, 9, 179, 2, // 4922: decode to CLT_U_W using decoder 307
6301 // 4922: }
6302 15, 7, // 4927: case 0xf: {
6303 OPC_CheckPredicate, 31, // 4929: check predicate 31
6304 OPC_Decode, 220, 9, 180, 2, // 4931: decode to CLT_U_D using decoder 308
6305 // 4931: }
6306 16, 7, // 4936: case 0x10: {
6307 OPC_CheckPredicate, 31, // 4938: check predicate 31
6308 OPC_Decode, 194, 9, 177, 2, // 4940: decode to CLE_S_B using decoder 305
6309 // 4940: }
6310 17, 7, // 4945: case 0x11: {
6311 OPC_CheckPredicate, 31, // 4947: check predicate 31
6312 OPC_Decode, 196, 9, 178, 2, // 4949: decode to CLE_S_H using decoder 306
6313 // 4949: }
6314 18, 7, // 4954: case 0x12: {
6315 OPC_CheckPredicate, 31, // 4956: check predicate 31
6316 OPC_Decode, 197, 9, 179, 2, // 4958: decode to CLE_S_W using decoder 307
6317 // 4958: }
6318 19, 7, // 4963: case 0x13: {
6319 OPC_CheckPredicate, 31, // 4965: check predicate 31
6320 OPC_Decode, 195, 9, 180, 2, // 4967: decode to CLE_S_D using decoder 308
6321 // 4967: }
6322 20, 7, // 4972: case 0x14: {
6323 OPC_CheckPredicate, 31, // 4974: check predicate 31
6324 OPC_Decode, 198, 9, 177, 2, // 4976: decode to CLE_U_B using decoder 305
6325 // 4976: }
6326 21, 7, // 4981: case 0x15: {
6327 OPC_CheckPredicate, 31, // 4983: check predicate 31
6328 OPC_Decode, 200, 9, 178, 2, // 4985: decode to CLE_U_H using decoder 306
6329 // 4985: }
6330 22, 7, // 4990: case 0x16: {
6331 OPC_CheckPredicate, 31, // 4992: check predicate 31
6332 OPC_Decode, 201, 9, 179, 2, // 4994: decode to CLE_U_W using decoder 307
6333 // 4994: }
6334 23, 0, // 4999: case 0x17: {
6335 OPC_CheckPredicate, 31, // 5001: check predicate 31
6336 OPC_Decode, 199, 9, 180, 2, // 5003: decode to CLE_U_D using decoder 308
6337 // 5003: }
6338 // 5003: } // switch Inst[25:21]
6339 // 5003: }
6340 16, 163, 2, // 5008: case 0x10: {
6341 OPC_SwitchField, 21, 5, // 5011: switch Inst[25:21] {
6342 0, 7, // 5014: case 0x0: {
6343 OPC_CheckPredicate, 31, // 5016: check predicate 31
6344 OPC_Decode, 231, 6, 177, 2, // 5018: decode to ADD_A_B using decoder 305
6345 // 5018: }
6346 1, 7, // 5023: case 0x1: {
6347 OPC_CheckPredicate, 31, // 5025: check predicate 31
6348 OPC_Decode, 233, 6, 178, 2, // 5027: decode to ADD_A_H using decoder 306
6349 // 5027: }
6350 2, 7, // 5032: case 0x2: {
6351 OPC_CheckPredicate, 31, // 5034: check predicate 31
6352 OPC_Decode, 234, 6, 179, 2, // 5036: decode to ADD_A_W using decoder 307
6353 // 5036: }
6354 3, 7, // 5041: case 0x3: {
6355 OPC_CheckPredicate, 31, // 5043: check predicate 31
6356 OPC_Decode, 232, 6, 180, 2, // 5045: decode to ADD_A_D using decoder 308
6357 // 5045: }
6358 4, 7, // 5050: case 0x4: {
6359 OPC_CheckPredicate, 31, // 5052: check predicate 31
6360 OPC_Decode, 194, 6, 177, 2, // 5054: decode to ADDS_A_B using decoder 305
6361 // 5054: }
6362 5, 7, // 5059: case 0x5: {
6363 OPC_CheckPredicate, 31, // 5061: check predicate 31
6364 OPC_Decode, 196, 6, 178, 2, // 5063: decode to ADDS_A_H using decoder 306
6365 // 5063: }
6366 6, 7, // 5068: case 0x6: {
6367 OPC_CheckPredicate, 31, // 5070: check predicate 31
6368 OPC_Decode, 197, 6, 179, 2, // 5072: decode to ADDS_A_W using decoder 307
6369 // 5072: }
6370 7, 7, // 5077: case 0x7: {
6371 OPC_CheckPredicate, 31, // 5079: check predicate 31
6372 OPC_Decode, 195, 6, 180, 2, // 5081: decode to ADDS_A_D using decoder 308
6373 // 5081: }
6374 8, 7, // 5086: case 0x8: {
6375 OPC_CheckPredicate, 31, // 5088: check predicate 31
6376 OPC_Decode, 198, 6, 177, 2, // 5090: decode to ADDS_S_B using decoder 305
6377 // 5090: }
6378 9, 7, // 5095: case 0x9: {
6379 OPC_CheckPredicate, 31, // 5097: check predicate 31
6380 OPC_Decode, 200, 6, 178, 2, // 5099: decode to ADDS_S_H using decoder 306
6381 // 5099: }
6382 10, 7, // 5104: case 0xa: {
6383 OPC_CheckPredicate, 31, // 5106: check predicate 31
6384 OPC_Decode, 201, 6, 179, 2, // 5108: decode to ADDS_S_W using decoder 307
6385 // 5108: }
6386 11, 7, // 5113: case 0xb: {
6387 OPC_CheckPredicate, 31, // 5115: check predicate 31
6388 OPC_Decode, 199, 6, 180, 2, // 5117: decode to ADDS_S_D using decoder 308
6389 // 5117: }
6390 12, 7, // 5122: case 0xc: {
6391 OPC_CheckPredicate, 31, // 5124: check predicate 31
6392 OPC_Decode, 202, 6, 177, 2, // 5126: decode to ADDS_U_B using decoder 305
6393 // 5126: }
6394 13, 7, // 5131: case 0xd: {
6395 OPC_CheckPredicate, 31, // 5133: check predicate 31
6396 OPC_Decode, 204, 6, 178, 2, // 5135: decode to ADDS_U_H using decoder 306
6397 // 5135: }
6398 14, 7, // 5140: case 0xe: {
6399 OPC_CheckPredicate, 31, // 5142: check predicate 31
6400 OPC_Decode, 205, 6, 179, 2, // 5144: decode to ADDS_U_W using decoder 307
6401 // 5144: }
6402 15, 7, // 5149: case 0xf: {
6403 OPC_CheckPredicate, 31, // 5151: check predicate 31
6404 OPC_Decode, 203, 6, 180, 2, // 5153: decode to ADDS_U_D using decoder 308
6405 // 5153: }
6406 16, 7, // 5158: case 0x10: {
6407 OPC_CheckPredicate, 31, // 5160: check predicate 31
6408 OPC_Decode, 164, 7, 177, 2, // 5162: decode to AVE_S_B using decoder 305
6409 // 5162: }
6410 17, 7, // 5167: case 0x11: {
6411 OPC_CheckPredicate, 31, // 5169: check predicate 31
6412 OPC_Decode, 166, 7, 178, 2, // 5171: decode to AVE_S_H using decoder 306
6413 // 5171: }
6414 18, 7, // 5176: case 0x12: {
6415 OPC_CheckPredicate, 31, // 5178: check predicate 31
6416 OPC_Decode, 167, 7, 179, 2, // 5180: decode to AVE_S_W using decoder 307
6417 // 5180: }
6418 19, 7, // 5185: case 0x13: {
6419 OPC_CheckPredicate, 31, // 5187: check predicate 31
6420 OPC_Decode, 165, 7, 180, 2, // 5189: decode to AVE_S_D using decoder 308
6421 // 5189: }
6422 20, 7, // 5194: case 0x14: {
6423 OPC_CheckPredicate, 31, // 5196: check predicate 31
6424 OPC_Decode, 168, 7, 177, 2, // 5198: decode to AVE_U_B using decoder 305
6425 // 5198: }
6426 21, 7, // 5203: case 0x15: {
6427 OPC_CheckPredicate, 31, // 5205: check predicate 31
6428 OPC_Decode, 170, 7, 178, 2, // 5207: decode to AVE_U_H using decoder 306
6429 // 5207: }
6430 22, 7, // 5212: case 0x16: {
6431 OPC_CheckPredicate, 31, // 5214: check predicate 31
6432 OPC_Decode, 171, 7, 179, 2, // 5216: decode to AVE_U_W using decoder 307
6433 // 5216: }
6434 23, 7, // 5221: case 0x17: {
6435 OPC_CheckPredicate, 31, // 5223: check predicate 31
6436 OPC_Decode, 169, 7, 180, 2, // 5225: decode to AVE_U_D using decoder 308
6437 // 5225: }
6438 24, 7, // 5230: case 0x18: {
6439 OPC_CheckPredicate, 31, // 5232: check predicate 31
6440 OPC_Decode, 156, 7, 177, 2, // 5234: decode to AVER_S_B using decoder 305
6441 // 5234: }
6442 25, 7, // 5239: case 0x19: {
6443 OPC_CheckPredicate, 31, // 5241: check predicate 31
6444 OPC_Decode, 158, 7, 178, 2, // 5243: decode to AVER_S_H using decoder 306
6445 // 5243: }
6446 26, 7, // 5248: case 0x1a: {
6447 OPC_CheckPredicate, 31, // 5250: check predicate 31
6448 OPC_Decode, 159, 7, 179, 2, // 5252: decode to AVER_S_W using decoder 307
6449 // 5252: }
6450 27, 7, // 5257: case 0x1b: {
6451 OPC_CheckPredicate, 31, // 5259: check predicate 31
6452 OPC_Decode, 157, 7, 180, 2, // 5261: decode to AVER_S_D using decoder 308
6453 // 5261: }
6454 28, 7, // 5266: case 0x1c: {
6455 OPC_CheckPredicate, 31, // 5268: check predicate 31
6456 OPC_Decode, 160, 7, 177, 2, // 5270: decode to AVER_U_B using decoder 305
6457 // 5270: }
6458 29, 7, // 5275: case 0x1d: {
6459 OPC_CheckPredicate, 31, // 5277: check predicate 31
6460 OPC_Decode, 162, 7, 178, 2, // 5279: decode to AVER_U_H using decoder 306
6461 // 5279: }
6462 30, 7, // 5284: case 0x1e: {
6463 OPC_CheckPredicate, 31, // 5286: check predicate 31
6464 OPC_Decode, 163, 7, 179, 2, // 5288: decode to AVER_U_W using decoder 307
6465 // 5288: }
6466 31, 0, // 5293: case 0x1f: {
6467 OPC_CheckPredicate, 31, // 5295: check predicate 31
6468 OPC_Decode, 161, 7, 180, 2, // 5297: decode to AVER_U_D using decoder 308
6469 // 5297: }
6470 // 5297: } // switch Inst[25:21]
6471 // 5297: }
6472 17, 219, 1, // 5302: case 0x11: {
6473 OPC_SwitchField, 21, 5, // 5305: switch Inst[25:21] {
6474 0, 7, // 5308: case 0x0: {
6475 OPC_CheckPredicate, 31, // 5310: check predicate 31
6476 OPC_Decode, 240, 22, 177, 2, // 5312: decode to SUBS_S_B using decoder 305
6477 // 5312: }
6478 1, 7, // 5317: case 0x1: {
6479 OPC_CheckPredicate, 31, // 5319: check predicate 31
6480 OPC_Decode, 242, 22, 178, 2, // 5321: decode to SUBS_S_H using decoder 306
6481 // 5321: }
6482 2, 7, // 5326: case 0x2: {
6483 OPC_CheckPredicate, 31, // 5328: check predicate 31
6484 OPC_Decode, 243, 22, 179, 2, // 5330: decode to SUBS_S_W using decoder 307
6485 // 5330: }
6486 3, 7, // 5335: case 0x3: {
6487 OPC_CheckPredicate, 31, // 5337: check predicate 31
6488 OPC_Decode, 241, 22, 180, 2, // 5339: decode to SUBS_S_D using decoder 308
6489 // 5339: }
6490 4, 7, // 5344: case 0x4: {
6491 OPC_CheckPredicate, 31, // 5346: check predicate 31
6492 OPC_Decode, 244, 22, 177, 2, // 5348: decode to SUBS_U_B using decoder 305
6493 // 5348: }
6494 5, 7, // 5353: case 0x5: {
6495 OPC_CheckPredicate, 31, // 5355: check predicate 31
6496 OPC_Decode, 246, 22, 178, 2, // 5357: decode to SUBS_U_H using decoder 306
6497 // 5357: }
6498 6, 7, // 5362: case 0x6: {
6499 OPC_CheckPredicate, 31, // 5364: check predicate 31
6500 OPC_Decode, 247, 22, 179, 2, // 5366: decode to SUBS_U_W using decoder 307
6501 // 5366: }
6502 7, 7, // 5371: case 0x7: {
6503 OPC_CheckPredicate, 31, // 5373: check predicate 31
6504 OPC_Decode, 245, 22, 180, 2, // 5375: decode to SUBS_U_D using decoder 308
6505 // 5375: }
6506 8, 7, // 5380: case 0x8: {
6507 OPC_CheckPredicate, 31, // 5382: check predicate 31
6508 OPC_Decode, 232, 22, 177, 2, // 5384: decode to SUBSUS_U_B using decoder 305
6509 // 5384: }
6510 9, 7, // 5389: case 0x9: {
6511 OPC_CheckPredicate, 31, // 5391: check predicate 31
6512 OPC_Decode, 234, 22, 178, 2, // 5393: decode to SUBSUS_U_H using decoder 306
6513 // 5393: }
6514 10, 7, // 5398: case 0xa: {
6515 OPC_CheckPredicate, 31, // 5400: check predicate 31
6516 OPC_Decode, 235, 22, 179, 2, // 5402: decode to SUBSUS_U_W using decoder 307
6517 // 5402: }
6518 11, 7, // 5407: case 0xb: {
6519 OPC_CheckPredicate, 31, // 5409: check predicate 31
6520 OPC_Decode, 233, 22, 180, 2, // 5411: decode to SUBSUS_U_D using decoder 308
6521 // 5411: }
6522 12, 7, // 5416: case 0xc: {
6523 OPC_CheckPredicate, 31, // 5418: check predicate 31
6524 OPC_Decode, 236, 22, 177, 2, // 5420: decode to SUBSUU_S_B using decoder 305
6525 // 5420: }
6526 13, 7, // 5425: case 0xd: {
6527 OPC_CheckPredicate, 31, // 5427: check predicate 31
6528 OPC_Decode, 238, 22, 178, 2, // 5429: decode to SUBSUU_S_H using decoder 306
6529 // 5429: }
6530 14, 7, // 5434: case 0xe: {
6531 OPC_CheckPredicate, 31, // 5436: check predicate 31
6532 OPC_Decode, 239, 22, 179, 2, // 5438: decode to SUBSUU_S_W using decoder 307
6533 // 5438: }
6534 15, 7, // 5443: case 0xf: {
6535 OPC_CheckPredicate, 31, // 5445: check predicate 31
6536 OPC_Decode, 237, 22, 180, 2, // 5447: decode to SUBSUU_S_D using decoder 308
6537 // 5447: }
6538 16, 7, // 5452: case 0x10: {
6539 OPC_CheckPredicate, 31, // 5454: check predicate 31
6540 OPC_Decode, 144, 7, 177, 2, // 5456: decode to ASUB_S_B using decoder 305
6541 // 5456: }
6542 17, 7, // 5461: case 0x11: {
6543 OPC_CheckPredicate, 31, // 5463: check predicate 31
6544 OPC_Decode, 146, 7, 178, 2, // 5465: decode to ASUB_S_H using decoder 306
6545 // 5465: }
6546 18, 7, // 5470: case 0x12: {
6547 OPC_CheckPredicate, 31, // 5472: check predicate 31
6548 OPC_Decode, 147, 7, 179, 2, // 5474: decode to ASUB_S_W using decoder 307
6549 // 5474: }
6550 19, 7, // 5479: case 0x13: {
6551 OPC_CheckPredicate, 31, // 5481: check predicate 31
6552 OPC_Decode, 145, 7, 180, 2, // 5483: decode to ASUB_S_D using decoder 308
6553 // 5483: }
6554 20, 7, // 5488: case 0x14: {
6555 OPC_CheckPredicate, 31, // 5490: check predicate 31
6556 OPC_Decode, 148, 7, 177, 2, // 5492: decode to ASUB_U_B using decoder 305
6557 // 5492: }
6558 21, 7, // 5497: case 0x15: {
6559 OPC_CheckPredicate, 31, // 5499: check predicate 31
6560 OPC_Decode, 150, 7, 178, 2, // 5501: decode to ASUB_U_H using decoder 306
6561 // 5501: }
6562 22, 7, // 5506: case 0x16: {
6563 OPC_CheckPredicate, 31, // 5508: check predicate 31
6564 OPC_Decode, 151, 7, 179, 2, // 5510: decode to ASUB_U_W using decoder 307
6565 // 5510: }
6566 23, 0, // 5515: case 0x17: {
6567 OPC_CheckPredicate, 31, // 5517: check predicate 31
6568 OPC_Decode, 149, 7, 180, 2, // 5519: decode to ASUB_U_D using decoder 308
6569 // 5519: }
6570 // 5519: } // switch Inst[25:21]
6571 // 5519: }
6572 18, 255, 1, // 5524: case 0x12: {
6573 OPC_SwitchField, 21, 5, // 5527: switch Inst[25:21] {
6574 0, 7, // 5530: case 0x0: {
6575 OPC_CheckPredicate, 31, // 5532: check predicate 31
6576 OPC_Decode, 137, 19, 177, 2, // 5534: decode to MULV_B using decoder 305
6577 // 5534: }
6578 1, 7, // 5539: case 0x1: {
6579 OPC_CheckPredicate, 31, // 5541: check predicate 31
6580 OPC_Decode, 139, 19, 178, 2, // 5543: decode to MULV_H using decoder 306
6581 // 5543: }
6582 2, 7, // 5548: case 0x2: {
6583 OPC_CheckPredicate, 31, // 5550: check predicate 31
6584 OPC_Decode, 140, 19, 179, 2, // 5552: decode to MULV_W using decoder 307
6585 // 5552: }
6586 3, 7, // 5557: case 0x3: {
6587 OPC_CheckPredicate, 31, // 5559: check predicate 31
6588 OPC_Decode, 138, 19, 180, 2, // 5561: decode to MULV_D using decoder 308
6589 // 5561: }
6590 4, 7, // 5566: case 0x4: {
6591 OPC_CheckPredicate, 31, // 5568: check predicate 31
6592 OPC_Decode, 234, 16, 181, 2, // 5570: decode to MADDV_B using decoder 309
6593 // 5570: }
6594 5, 7, // 5575: case 0x5: {
6595 OPC_CheckPredicate, 31, // 5577: check predicate 31
6596 OPC_Decode, 236, 16, 182, 2, // 5579: decode to MADDV_H using decoder 310
6597 // 5579: }
6598 6, 7, // 5584: case 0x6: {
6599 OPC_CheckPredicate, 31, // 5586: check predicate 31
6600 OPC_Decode, 237, 16, 183, 2, // 5588: decode to MADDV_W using decoder 311
6601 // 5588: }
6602 7, 7, // 5593: case 0x7: {
6603 OPC_CheckPredicate, 31, // 5595: check predicate 31
6604 OPC_Decode, 235, 16, 184, 2, // 5597: decode to MADDV_D using decoder 312
6605 // 5597: }
6606 8, 7, // 5602: case 0x8: {
6607 OPC_CheckPredicate, 31, // 5604: check predicate 31
6608 OPC_Decode, 168, 18, 181, 2, // 5606: decode to MSUBV_B using decoder 309
6609 // 5606: }
6610 9, 7, // 5611: case 0x9: {
6611 OPC_CheckPredicate, 31, // 5613: check predicate 31
6612 OPC_Decode, 170, 18, 182, 2, // 5615: decode to MSUBV_H using decoder 310
6613 // 5615: }
6614 10, 7, // 5620: case 0xa: {
6615 OPC_CheckPredicate, 31, // 5622: check predicate 31
6616 OPC_Decode, 171, 18, 183, 2, // 5624: decode to MSUBV_W using decoder 311
6617 // 5624: }
6618 11, 7, // 5629: case 0xb: {
6619 OPC_CheckPredicate, 31, // 5631: check predicate 31
6620 OPC_Decode, 169, 18, 184, 2, // 5633: decode to MSUBV_D using decoder 312
6621 // 5633: }
6622 16, 7, // 5638: case 0x10: {
6623 OPC_CheckPredicate, 31, // 5640: check predicate 31
6624 OPC_Decode, 254, 11, 177, 2, // 5642: decode to DIV_S_B using decoder 305
6625 // 5642: }
6626 17, 7, // 5647: case 0x11: {
6627 OPC_CheckPredicate, 31, // 5649: check predicate 31
6628 OPC_Decode, 128, 12, 178, 2, // 5651: decode to DIV_S_H using decoder 306
6629 // 5651: }
6630 18, 7, // 5656: case 0x12: {
6631 OPC_CheckPredicate, 31, // 5658: check predicate 31
6632 OPC_Decode, 129, 12, 179, 2, // 5660: decode to DIV_S_W using decoder 307
6633 // 5660: }
6634 19, 7, // 5665: case 0x13: {
6635 OPC_CheckPredicate, 31, // 5667: check predicate 31
6636 OPC_Decode, 255, 11, 180, 2, // 5669: decode to DIV_S_D using decoder 308
6637 // 5669: }
6638 20, 7, // 5674: case 0x14: {
6639 OPC_CheckPredicate, 31, // 5676: check predicate 31
6640 OPC_Decode, 130, 12, 177, 2, // 5678: decode to DIV_U_B using decoder 305
6641 // 5678: }
6642 21, 7, // 5683: case 0x15: {
6643 OPC_CheckPredicate, 31, // 5685: check predicate 31
6644 OPC_Decode, 132, 12, 178, 2, // 5687: decode to DIV_U_H using decoder 306
6645 // 5687: }
6646 22, 7, // 5692: case 0x16: {
6647 OPC_CheckPredicate, 31, // 5694: check predicate 31
6648 OPC_Decode, 133, 12, 179, 2, // 5696: decode to DIV_U_W using decoder 307
6649 // 5696: }
6650 23, 7, // 5701: case 0x17: {
6651 OPC_CheckPredicate, 31, // 5703: check predicate 31
6652 OPC_Decode, 131, 12, 180, 2, // 5705: decode to DIV_U_D using decoder 308
6653 // 5705: }
6654 24, 7, // 5710: case 0x18: {
6655 OPC_CheckPredicate, 31, // 5712: check predicate 31
6656 OPC_Decode, 226, 17, 177, 2, // 5714: decode to MOD_S_B using decoder 305
6657 // 5714: }
6658 25, 7, // 5719: case 0x19: {
6659 OPC_CheckPredicate, 31, // 5721: check predicate 31
6660 OPC_Decode, 228, 17, 178, 2, // 5723: decode to MOD_S_H using decoder 306
6661 // 5723: }
6662 26, 7, // 5728: case 0x1a: {
6663 OPC_CheckPredicate, 31, // 5730: check predicate 31
6664 OPC_Decode, 229, 17, 179, 2, // 5732: decode to MOD_S_W using decoder 307
6665 // 5732: }
6666 27, 7, // 5737: case 0x1b: {
6667 OPC_CheckPredicate, 31, // 5739: check predicate 31
6668 OPC_Decode, 227, 17, 180, 2, // 5741: decode to MOD_S_D using decoder 308
6669 // 5741: }
6670 28, 7, // 5746: case 0x1c: {
6671 OPC_CheckPredicate, 31, // 5748: check predicate 31
6672 OPC_Decode, 230, 17, 177, 2, // 5750: decode to MOD_U_B using decoder 305
6673 // 5750: }
6674 29, 7, // 5755: case 0x1d: {
6675 OPC_CheckPredicate, 31, // 5757: check predicate 31
6676 OPC_Decode, 232, 17, 178, 2, // 5759: decode to MOD_U_H using decoder 306
6677 // 5759: }
6678 30, 7, // 5764: case 0x1e: {
6679 OPC_CheckPredicate, 31, // 5766: check predicate 31
6680 OPC_Decode, 233, 17, 179, 2, // 5768: decode to MOD_U_W using decoder 307
6681 // 5768: }
6682 31, 0, // 5773: case 0x1f: {
6683 OPC_CheckPredicate, 31, // 5775: check predicate 31
6684 OPC_Decode, 231, 17, 180, 2, // 5777: decode to MOD_U_D using decoder 308
6685 // 5777: }
6686 // 5777: } // switch Inst[25:21]
6687 // 5777: }
6688 19, 165, 1, // 5782: case 0x13: {
6689 OPC_SwitchField, 21, 5, // 5785: switch Inst[25:21] {
6690 1, 7, // 5788: case 0x1: {
6691 OPC_CheckPredicate, 31, // 5790: check predicate 31
6692 OPC_Decode, 160, 12, 185, 2, // 5792: decode to DOTP_S_H using decoder 313
6693 // 5792: }
6694 2, 7, // 5797: case 0x2: {
6695 OPC_CheckPredicate, 31, // 5799: check predicate 31
6696 OPC_Decode, 161, 12, 186, 2, // 5801: decode to DOTP_S_W using decoder 314
6697 // 5801: }
6698 3, 7, // 5806: case 0x3: {
6699 OPC_CheckPredicate, 31, // 5808: check predicate 31
6700 OPC_Decode, 159, 12, 187, 2, // 5810: decode to DOTP_S_D using decoder 315
6701 // 5810: }
6702 5, 7, // 5815: case 0x5: {
6703 OPC_CheckPredicate, 31, // 5817: check predicate 31
6704 OPC_Decode, 163, 12, 185, 2, // 5819: decode to DOTP_U_H using decoder 313
6705 // 5819: }
6706 6, 7, // 5824: case 0x6: {
6707 OPC_CheckPredicate, 31, // 5826: check predicate 31
6708 OPC_Decode, 164, 12, 186, 2, // 5828: decode to DOTP_U_W using decoder 314
6709 // 5828: }
6710 7, 7, // 5833: case 0x7: {
6711 OPC_CheckPredicate, 31, // 5835: check predicate 31
6712 OPC_Decode, 162, 12, 187, 2, // 5837: decode to DOTP_U_D using decoder 315
6713 // 5837: }
6714 9, 7, // 5842: case 0x9: {
6715 OPC_CheckPredicate, 31, // 5844: check predicate 31
6716 OPC_Decode, 166, 12, 188, 2, // 5846: decode to DPADD_S_H using decoder 316
6717 // 5846: }
6718 10, 7, // 5851: case 0xa: {
6719 OPC_CheckPredicate, 31, // 5853: check predicate 31
6720 OPC_Decode, 167, 12, 189, 2, // 5855: decode to DPADD_S_W using decoder 317
6721 // 5855: }
6722 11, 7, // 5860: case 0xb: {
6723 OPC_CheckPredicate, 31, // 5862: check predicate 31
6724 OPC_Decode, 165, 12, 190, 2, // 5864: decode to DPADD_S_D using decoder 318
6725 // 5864: }
6726 13, 7, // 5869: case 0xd: {
6727 OPC_CheckPredicate, 31, // 5871: check predicate 31
6728 OPC_Decode, 169, 12, 188, 2, // 5873: decode to DPADD_U_H using decoder 316
6729 // 5873: }
6730 14, 7, // 5878: case 0xe: {
6731 OPC_CheckPredicate, 31, // 5880: check predicate 31
6732 OPC_Decode, 170, 12, 189, 2, // 5882: decode to DPADD_U_W using decoder 317
6733 // 5882: }
6734 15, 7, // 5887: case 0xf: {
6735 OPC_CheckPredicate, 31, // 5889: check predicate 31
6736 OPC_Decode, 168, 12, 190, 2, // 5891: decode to DPADD_U_D using decoder 318
6737 // 5891: }
6738 17, 7, // 5896: case 0x11: {
6739 OPC_CheckPredicate, 31, // 5898: check predicate 31
6740 OPC_Decode, 197, 12, 188, 2, // 5900: decode to DPSUB_S_H using decoder 316
6741 // 5900: }
6742 18, 7, // 5905: case 0x12: {
6743 OPC_CheckPredicate, 31, // 5907: check predicate 31
6744 OPC_Decode, 198, 12, 189, 2, // 5909: decode to DPSUB_S_W using decoder 317
6745 // 5909: }
6746 19, 7, // 5914: case 0x13: {
6747 OPC_CheckPredicate, 31, // 5916: check predicate 31
6748 OPC_Decode, 196, 12, 190, 2, // 5918: decode to DPSUB_S_D using decoder 318
6749 // 5918: }
6750 21, 7, // 5923: case 0x15: {
6751 OPC_CheckPredicate, 31, // 5925: check predicate 31
6752 OPC_Decode, 200, 12, 188, 2, // 5927: decode to DPSUB_U_H using decoder 316
6753 // 5927: }
6754 22, 7, // 5932: case 0x16: {
6755 OPC_CheckPredicate, 31, // 5934: check predicate 31
6756 OPC_Decode, 201, 12, 189, 2, // 5936: decode to DPSUB_U_W using decoder 317
6757 // 5936: }
6758 23, 0, // 5941: case 0x17: {
6759 OPC_CheckPredicate, 31, // 5943: check predicate 31
6760 OPC_Decode, 199, 12, 190, 2, // 5945: decode to DPSUB_U_D using decoder 318
6761 // 5945: }
6762 // 5945: } // switch Inst[25:21]
6763 // 5945: }
6764 20, 163, 2, // 5950: case 0x14: {
6765 OPC_SwitchField, 21, 5, // 5953: switch Inst[25:21] {
6766 0, 7, // 5956: case 0x0: {
6767 OPC_CheckPredicate, 31, // 5958: check predicate 31
6768 OPC_Decode, 240, 21, 191, 2, // 5960: decode to SLD_B using decoder 319
6769 // 5960: }
6770 1, 7, // 5965: case 0x1: {
6771 OPC_CheckPredicate, 31, // 5967: check predicate 31
6772 OPC_Decode, 242, 21, 192, 2, // 5969: decode to SLD_H using decoder 320
6773 // 5969: }
6774 2, 7, // 5974: case 0x2: {
6775 OPC_CheckPredicate, 31, // 5976: check predicate 31
6776 OPC_Decode, 243, 21, 193, 2, // 5978: decode to SLD_W using decoder 321
6777 // 5978: }
6778 3, 7, // 5983: case 0x3: {
6779 OPC_CheckPredicate, 31, // 5985: check predicate 31
6780 OPC_Decode, 241, 21, 194, 2, // 5987: decode to SLD_D using decoder 322
6781 // 5987: }
6782 4, 7, // 5992: case 0x4: {
6783 OPC_CheckPredicate, 31, // 5994: check predicate 31
6784 OPC_Decode, 159, 22, 195, 2, // 5996: decode to SPLAT_B using decoder 323
6785 // 5996: }
6786 5, 7, // 6001: case 0x5: {
6787 OPC_CheckPredicate, 31, // 6003: check predicate 31
6788 OPC_Decode, 161, 22, 196, 2, // 6005: decode to SPLAT_H using decoder 324
6789 // 6005: }
6790 6, 7, // 6010: case 0x6: {
6791 OPC_CheckPredicate, 31, // 6012: check predicate 31
6792 OPC_Decode, 162, 22, 197, 2, // 6014: decode to SPLAT_W using decoder 325
6793 // 6014: }
6794 7, 7, // 6019: case 0x7: {
6795 OPC_CheckPredicate, 31, // 6021: check predicate 31
6796 OPC_Decode, 160, 22, 198, 2, // 6023: decode to SPLAT_D using decoder 326
6797 // 6023: }
6798 8, 7, // 6028: case 0x8: {
6799 OPC_CheckPredicate, 31, // 6030: check predicate 31
6800 OPC_Decode, 210, 19, 177, 2, // 6032: decode to PCKEV_B using decoder 305
6801 // 6032: }
6802 9, 7, // 6037: case 0x9: {
6803 OPC_CheckPredicate, 31, // 6039: check predicate 31
6804 OPC_Decode, 212, 19, 178, 2, // 6041: decode to PCKEV_H using decoder 306
6805 // 6041: }
6806 10, 7, // 6046: case 0xa: {
6807 OPC_CheckPredicate, 31, // 6048: check predicate 31
6808 OPC_Decode, 213, 19, 179, 2, // 6050: decode to PCKEV_W using decoder 307
6809 // 6050: }
6810 11, 7, // 6055: case 0xb: {
6811 OPC_CheckPredicate, 31, // 6057: check predicate 31
6812 OPC_Decode, 211, 19, 180, 2, // 6059: decode to PCKEV_D using decoder 308
6813 // 6059: }
6814 12, 7, // 6064: case 0xc: {
6815 OPC_CheckPredicate, 31, // 6066: check predicate 31
6816 OPC_Decode, 214, 19, 177, 2, // 6068: decode to PCKOD_B using decoder 305
6817 // 6068: }
6818 13, 7, // 6073: case 0xd: {
6819 OPC_CheckPredicate, 31, // 6075: check predicate 31
6820 OPC_Decode, 216, 19, 178, 2, // 6077: decode to PCKOD_H using decoder 306
6821 // 6077: }
6822 14, 7, // 6082: case 0xe: {
6823 OPC_CheckPredicate, 31, // 6084: check predicate 31
6824 OPC_Decode, 217, 19, 179, 2, // 6086: decode to PCKOD_W using decoder 307
6825 // 6086: }
6826 15, 7, // 6091: case 0xf: {
6827 OPC_CheckPredicate, 31, // 6093: check predicate 31
6828 OPC_Decode, 215, 19, 180, 2, // 6095: decode to PCKOD_D using decoder 308
6829 // 6095: }
6830 16, 7, // 6100: case 0x10: {
6831 OPC_CheckPredicate, 31, // 6102: check predicate 31
6832 OPC_Decode, 235, 14, 177, 2, // 6104: decode to ILVL_B using decoder 305
6833 // 6104: }
6834 17, 7, // 6109: case 0x11: {
6835 OPC_CheckPredicate, 31, // 6111: check predicate 31
6836 OPC_Decode, 237, 14, 178, 2, // 6113: decode to ILVL_H using decoder 306
6837 // 6113: }
6838 18, 7, // 6118: case 0x12: {
6839 OPC_CheckPredicate, 31, // 6120: check predicate 31
6840 OPC_Decode, 238, 14, 179, 2, // 6122: decode to ILVL_W using decoder 307
6841 // 6122: }
6842 19, 7, // 6127: case 0x13: {
6843 OPC_CheckPredicate, 31, // 6129: check predicate 31
6844 OPC_Decode, 236, 14, 180, 2, // 6131: decode to ILVL_D using decoder 308
6845 // 6131: }
6846 20, 7, // 6136: case 0x14: {
6847 OPC_CheckPredicate, 31, // 6138: check predicate 31
6848 OPC_Decode, 243, 14, 177, 2, // 6140: decode to ILVR_B using decoder 305
6849 // 6140: }
6850 21, 7, // 6145: case 0x15: {
6851 OPC_CheckPredicate, 31, // 6147: check predicate 31
6852 OPC_Decode, 245, 14, 178, 2, // 6149: decode to ILVR_H using decoder 306
6853 // 6149: }
6854 22, 7, // 6154: case 0x16: {
6855 OPC_CheckPredicate, 31, // 6156: check predicate 31
6856 OPC_Decode, 246, 14, 179, 2, // 6158: decode to ILVR_W using decoder 307
6857 // 6158: }
6858 23, 7, // 6163: case 0x17: {
6859 OPC_CheckPredicate, 31, // 6165: check predicate 31
6860 OPC_Decode, 244, 14, 180, 2, // 6167: decode to ILVR_D using decoder 308
6861 // 6167: }
6862 24, 7, // 6172: case 0x18: {
6863 OPC_CheckPredicate, 31, // 6174: check predicate 31
6864 OPC_Decode, 231, 14, 177, 2, // 6176: decode to ILVEV_B using decoder 305
6865 // 6176: }
6866 25, 7, // 6181: case 0x19: {
6867 OPC_CheckPredicate, 31, // 6183: check predicate 31
6868 OPC_Decode, 233, 14, 178, 2, // 6185: decode to ILVEV_H using decoder 306
6869 // 6185: }
6870 26, 7, // 6190: case 0x1a: {
6871 OPC_CheckPredicate, 31, // 6192: check predicate 31
6872 OPC_Decode, 234, 14, 179, 2, // 6194: decode to ILVEV_W using decoder 307
6873 // 6194: }
6874 27, 7, // 6199: case 0x1b: {
6875 OPC_CheckPredicate, 31, // 6201: check predicate 31
6876 OPC_Decode, 232, 14, 180, 2, // 6203: decode to ILVEV_D using decoder 308
6877 // 6203: }
6878 28, 7, // 6208: case 0x1c: {
6879 OPC_CheckPredicate, 31, // 6210: check predicate 31
6880 OPC_Decode, 239, 14, 177, 2, // 6212: decode to ILVOD_B using decoder 305
6881 // 6212: }
6882 29, 7, // 6217: case 0x1d: {
6883 OPC_CheckPredicate, 31, // 6219: check predicate 31
6884 OPC_Decode, 241, 14, 178, 2, // 6221: decode to ILVOD_H using decoder 306
6885 // 6221: }
6886 30, 7, // 6226: case 0x1e: {
6887 OPC_CheckPredicate, 31, // 6228: check predicate 31
6888 OPC_Decode, 242, 14, 179, 2, // 6230: decode to ILVOD_W using decoder 307
6889 // 6230: }
6890 31, 0, // 6235: case 0x1f: {
6891 OPC_CheckPredicate, 31, // 6237: check predicate 31
6892 OPC_Decode, 240, 14, 180, 2, // 6239: decode to ILVOD_D using decoder 308
6893 // 6239: }
6894 // 6239: } // switch Inst[25:21]
6895 // 6239: }
6896 21, 219, 1, // 6244: case 0x15: {
6897 OPC_SwitchField, 21, 5, // 6247: switch Inst[25:21] {
6898 0, 7, // 6250: case 0x0: {
6899 OPC_CheckPredicate, 31, // 6252: check predicate 31
6900 OPC_Decode, 176, 24, 181, 2, // 6254: decode to VSHF_B using decoder 309
6901 // 6254: }
6902 1, 7, // 6259: case 0x1: {
6903 OPC_CheckPredicate, 31, // 6261: check predicate 31
6904 OPC_Decode, 178, 24, 182, 2, // 6263: decode to VSHF_H using decoder 310
6905 // 6263: }
6906 2, 7, // 6268: case 0x2: {
6907 OPC_CheckPredicate, 31, // 6270: check predicate 31
6908 OPC_Decode, 179, 24, 183, 2, // 6272: decode to VSHF_W using decoder 311
6909 // 6272: }
6910 3, 7, // 6277: case 0x3: {
6911 OPC_CheckPredicate, 31, // 6279: check predicate 31
6912 OPC_Decode, 177, 24, 184, 2, // 6281: decode to VSHF_D using decoder 312
6913 // 6281: }
6914 4, 7, // 6286: case 0x4: {
6915 OPC_CheckPredicate, 31, // 6288: check predicate 31
6916 OPC_Decode, 172, 22, 177, 2, // 6290: decode to SRAR_B using decoder 305
6917 // 6290: }
6918 5, 7, // 6295: case 0x5: {
6919 OPC_CheckPredicate, 31, // 6297: check predicate 31
6920 OPC_Decode, 174, 22, 178, 2, // 6299: decode to SRAR_H using decoder 306
6921 // 6299: }
6922 6, 7, // 6304: case 0x6: {
6923 OPC_CheckPredicate, 31, // 6306: check predicate 31
6924 OPC_Decode, 175, 22, 179, 2, // 6308: decode to SRAR_W using decoder 307
6925 // 6308: }
6926 7, 7, // 6313: case 0x7: {
6927 OPC_CheckPredicate, 31, // 6315: check predicate 31
6928 OPC_Decode, 173, 22, 180, 2, // 6317: decode to SRAR_D using decoder 308
6929 // 6317: }
6930 8, 7, // 6322: case 0x8: {
6931 OPC_CheckPredicate, 31, // 6324: check predicate 31
6932 OPC_Decode, 197, 22, 177, 2, // 6326: decode to SRLR_B using decoder 305
6933 // 6326: }
6934 9, 7, // 6331: case 0x9: {
6935 OPC_CheckPredicate, 31, // 6333: check predicate 31
6936 OPC_Decode, 199, 22, 178, 2, // 6335: decode to SRLR_H using decoder 306
6937 // 6335: }
6938 10, 7, // 6340: case 0xa: {
6939 OPC_CheckPredicate, 31, // 6342: check predicate 31
6940 OPC_Decode, 200, 22, 179, 2, // 6344: decode to SRLR_W using decoder 307
6941 // 6344: }
6942 11, 7, // 6349: case 0xb: {
6943 OPC_CheckPredicate, 31, // 6351: check predicate 31
6944 OPC_Decode, 198, 22, 180, 2, // 6353: decode to SRLR_D using decoder 308
6945 // 6353: }
6946 17, 7, // 6358: case 0x11: {
6947 OPC_CheckPredicate, 31, // 6360: check predicate 31
6948 OPC_Decode, 218, 14, 185, 2, // 6362: decode to HADD_S_H using decoder 313
6949 // 6362: }
6950 18, 7, // 6367: case 0x12: {
6951 OPC_CheckPredicate, 31, // 6369: check predicate 31
6952 OPC_Decode, 219, 14, 186, 2, // 6371: decode to HADD_S_W using decoder 314
6953 // 6371: }
6954 19, 7, // 6376: case 0x13: {
6955 OPC_CheckPredicate, 31, // 6378: check predicate 31
6956 OPC_Decode, 217, 14, 187, 2, // 6380: decode to HADD_S_D using decoder 315
6957 // 6380: }
6958 21, 7, // 6385: case 0x15: {
6959 OPC_CheckPredicate, 31, // 6387: check predicate 31
6960 OPC_Decode, 221, 14, 185, 2, // 6389: decode to HADD_U_H using decoder 313
6961 // 6389: }
6962 22, 7, // 6394: case 0x16: {
6963 OPC_CheckPredicate, 31, // 6396: check predicate 31
6964 OPC_Decode, 222, 14, 186, 2, // 6398: decode to HADD_U_W using decoder 314
6965 // 6398: }
6966 23, 7, // 6403: case 0x17: {
6967 OPC_CheckPredicate, 31, // 6405: check predicate 31
6968 OPC_Decode, 220, 14, 187, 2, // 6407: decode to HADD_U_D using decoder 315
6969 // 6407: }
6970 25, 7, // 6412: case 0x19: {
6971 OPC_CheckPredicate, 31, // 6414: check predicate 31
6972 OPC_Decode, 224, 14, 185, 2, // 6416: decode to HSUB_S_H using decoder 313
6973 // 6416: }
6974 26, 7, // 6421: case 0x1a: {
6975 OPC_CheckPredicate, 31, // 6423: check predicate 31
6976 OPC_Decode, 225, 14, 186, 2, // 6425: decode to HSUB_S_W using decoder 314
6977 // 6425: }
6978 27, 7, // 6430: case 0x1b: {
6979 OPC_CheckPredicate, 31, // 6432: check predicate 31
6980 OPC_Decode, 223, 14, 187, 2, // 6434: decode to HSUB_S_D using decoder 315
6981 // 6434: }
6982 29, 7, // 6439: case 0x1d: {
6983 OPC_CheckPredicate, 31, // 6441: check predicate 31
6984 OPC_Decode, 227, 14, 185, 2, // 6443: decode to HSUB_U_H using decoder 313
6985 // 6443: }
6986 30, 7, // 6448: case 0x1e: {
6987 OPC_CheckPredicate, 31, // 6450: check predicate 31
6988 OPC_Decode, 228, 14, 186, 2, // 6452: decode to HSUB_U_W using decoder 314
6989 // 6452: }
6990 31, 0, // 6457: case 0x1f: {
6991 OPC_CheckPredicate, 31, // 6459: check predicate 31
6992 OPC_Decode, 226, 14, 187, 2, // 6461: decode to HSUB_U_D using decoder 315
6993 // 6461: }
6994 // 6461: } // switch Inst[25:21]
6995 // 6461: }
6996 25, 194, 2, // 6466: case 0x19: {
6997 OPC_SwitchField, 20, 6, // 6469: switch Inst[25:20] {
6998 0, 7, // 6472: case 0x0: {
6999 OPC_CheckPredicate, 31, // 6474: check predicate 31
7000 OPC_Decode, 236, 21, 199, 2, // 6476: decode to SLDI_B using decoder 327
7001 // 6476: }
7002 2, 11, // 6481: case 0x2: {
7003 OPC_CheckPredicate, 31, // 6483: check predicate 31
7004 OPC_CheckField, 19, 1, 0, // 6485: check Inst[19] == 0x0
7005 OPC_Decode, 238, 21, 200, 2, // 6489: decode to SLDI_H using decoder 328
7006 // 6489: }
7007 3, 38, // 6494: case 0x3: {
7008 OPC_SwitchField, 18, 2, // 6496: switch Inst[19:18] {
7009 0, 7, // 6499: case 0x0: {
7010 OPC_CheckPredicate, 31, // 6501: check predicate 31
7011 OPC_Decode, 239, 21, 201, 2, // 6503: decode to SLDI_W using decoder 329
7012 // 6503: }
7013 2, 11, // 6508: case 0x2: {
7014 OPC_CheckPredicate, 31, // 6510: check predicate 31
7015 OPC_CheckField, 17, 1, 0, // 6512: check Inst[17] == 0x0
7016 OPC_Decode, 237, 21, 202, 2, // 6516: decode to SLDI_D using decoder 330
7017 // 6516: }
7018 3, 0, // 6521: case 0x3: {
7019 OPC_CheckPredicate, 31, // 6523: check predicate 31
7020 OPC_CheckField, 16, 2, 2, // 6525: check Inst[17:16] == 0x2
7021 OPC_Decode, 212, 10, 203, 2, // 6529: decode to CTCMSA using decoder 331
7022 // 6529: }
7023 // 6529: } // switch Inst[19:18]
7024 // 6529: }
7025 4, 7, // 6534: case 0x4: {
7026 OPC_CheckPredicate, 31, // 6536: check predicate 31
7027 OPC_Decode, 155, 22, 204, 2, // 6538: decode to SPLATI_B using decoder 332
7028 // 6538: }
7029 6, 11, // 6543: case 0x6: {
7030 OPC_CheckPredicate, 31, // 6545: check predicate 31
7031 OPC_CheckField, 19, 1, 0, // 6547: check Inst[19] == 0x0
7032 OPC_Decode, 157, 22, 205, 2, // 6551: decode to SPLATI_H using decoder 333
7033 // 6551: }
7034 7, 38, // 6556: case 0x7: {
7035 OPC_SwitchField, 18, 2, // 6558: switch Inst[19:18] {
7036 0, 7, // 6561: case 0x0: {
7037 OPC_CheckPredicate, 31, // 6563: check predicate 31
7038 OPC_Decode, 158, 22, 206, 2, // 6565: decode to SPLATI_W using decoder 334
7039 // 6565: }
7040 2, 11, // 6570: case 0x2: {
7041 OPC_CheckPredicate, 31, // 6572: check predicate 31
7042 OPC_CheckField, 17, 1, 0, // 6574: check Inst[17] == 0x0
7043 OPC_Decode, 156, 22, 207, 2, // 6578: decode to SPLATI_D using decoder 335
7044 // 6578: }
7045 3, 0, // 6583: case 0x3: {
7046 OPC_CheckPredicate, 31, // 6585: check predicate 31
7047 OPC_CheckField, 16, 2, 2, // 6587: check Inst[17:16] == 0x2
7048 OPC_Decode, 177, 9, 208, 2, // 6591: decode to CFCMSA using decoder 336
7049 // 6591: }
7050 // 6591: } // switch Inst[19:18]
7051 // 6591: }
7052 8, 7, // 6596: case 0x8: {
7053 OPC_CheckPredicate, 31, // 6598: check predicate 31
7054 OPC_Decode, 188, 10, 209, 2, // 6600: decode to COPY_S_B using decoder 337
7055 // 6600: }
7056 10, 11, // 6605: case 0xa: {
7057 OPC_CheckPredicate, 31, // 6607: check predicate 31
7058 OPC_CheckField, 19, 1, 0, // 6609: check Inst[19] == 0x0
7059 OPC_Decode, 190, 10, 210, 2, // 6613: decode to COPY_S_H using decoder 338
7060 // 6613: }
7061 11, 38, // 6618: case 0xb: {
7062 OPC_SwitchField, 18, 2, // 6620: switch Inst[19:18] {
7063 0, 7, // 6623: case 0x0: {
7064 OPC_CheckPredicate, 31, // 6625: check predicate 31
7065 OPC_Decode, 191, 10, 211, 2, // 6627: decode to COPY_S_W using decoder 339
7066 // 6627: }
7067 2, 11, // 6632: case 0x2: {
7068 OPC_CheckPredicate, 39, // 6634: check predicate 39
7069 OPC_CheckField, 17, 1, 0, // 6636: check Inst[17] == 0x0
7070 OPC_Decode, 189, 10, 212, 2, // 6640: decode to COPY_S_D using decoder 340
7071 // 6640: }
7072 3, 0, // 6645: case 0x3: {
7073 OPC_CheckPredicate, 31, // 6647: check predicate 31
7074 OPC_CheckField, 16, 2, 2, // 6649: check Inst[17:16] == 0x2
7075 OPC_Decode, 242, 17, 213, 2, // 6653: decode to MOVE_V using decoder 341
7076 // 6653: }
7077 // 6653: } // switch Inst[19:18]
7078 // 6653: }
7079 12, 7, // 6658: case 0xc: {
7080 OPC_CheckPredicate, 31, // 6660: check predicate 31
7081 OPC_Decode, 192, 10, 209, 2, // 6662: decode to COPY_U_B using decoder 337
7082 // 6662: }
7083 14, 11, // 6667: case 0xe: {
7084 OPC_CheckPredicate, 31, // 6669: check predicate 31
7085 OPC_CheckField, 19, 1, 0, // 6671: check Inst[19] == 0x0
7086 OPC_Decode, 193, 10, 210, 2, // 6675: decode to COPY_U_H using decoder 338
7087 // 6675: }
7088 15, 11, // 6680: case 0xf: {
7089 OPC_CheckPredicate, 39, // 6682: check predicate 39
7090 OPC_CheckField, 18, 2, 0, // 6684: check Inst[19:18] == 0x0
7091 OPC_Decode, 194, 10, 211, 2, // 6688: decode to COPY_U_W using decoder 339
7092 // 6688: }
7093 16, 7, // 6693: case 0x10: {
7094 OPC_CheckPredicate, 31, // 6695: check predicate 31
7095 OPC_Decode, 248, 14, 214, 2, // 6697: decode to INSERT_B using decoder 342
7096 // 6697: }
7097 18, 11, // 6702: case 0x12: {
7098 OPC_CheckPredicate, 31, // 6704: check predicate 31
7099 OPC_CheckField, 19, 1, 0, // 6706: check Inst[19] == 0x0
7100 OPC_Decode, 250, 14, 215, 2, // 6710: decode to INSERT_H using decoder 343
7101 // 6710: }
7102 19, 25, // 6715: case 0x13: {
7103 OPC_SwitchField, 18, 2, // 6717: switch Inst[19:18] {
7104 0, 7, // 6720: case 0x0: {
7105 OPC_CheckPredicate, 31, // 6722: check predicate 31
7106 OPC_Decode, 251, 14, 216, 2, // 6724: decode to INSERT_W using decoder 344
7107 // 6724: }
7108 2, 0, // 6729: case 0x2: {
7109 OPC_CheckPredicate, 39, // 6731: check predicate 39
7110 OPC_CheckField, 17, 1, 0, // 6733: check Inst[17] == 0x0
7111 OPC_Decode, 249, 14, 217, 2, // 6737: decode to INSERT_D using decoder 345
7112 // 6737: }
7113 // 6737: } // switch Inst[19:18]
7114 // 6737: }
7115 20, 7, // 6742: case 0x14: {
7116 OPC_CheckPredicate, 31, // 6744: check predicate 31
7117 OPC_Decode, 253, 14, 218, 2, // 6746: decode to INSVE_B using decoder 346
7118 // 6746: }
7119 22, 11, // 6751: case 0x16: {
7120 OPC_CheckPredicate, 31, // 6753: check predicate 31
7121 OPC_CheckField, 19, 1, 0, // 6755: check Inst[19] == 0x0
7122 OPC_Decode, 255, 14, 218, 2, // 6759: decode to INSVE_H using decoder 346
7123 // 6759: }
7124 23, 0, // 6764: case 0x17: {
7125 OPC_SwitchField, 18, 2, // 6766: switch Inst[19:18] {
7126 0, 7, // 6769: case 0x0: {
7127 OPC_CheckPredicate, 31, // 6771: check predicate 31
7128 OPC_Decode, 128, 15, 218, 2, // 6773: decode to INSVE_W using decoder 346
7129 // 6773: }
7130 2, 0, // 6778: case 0x2: {
7131 OPC_CheckPredicate, 31, // 6780: check predicate 31
7132 OPC_CheckField, 17, 1, 0, // 6782: check Inst[17] == 0x0
7133 OPC_Decode, 254, 14, 218, 2, // 6786: decode to INSVE_D using decoder 346
7134 // 6786: }
7135 // 6786: } // switch Inst[19:18]
7136 // 6786: }
7137 // 6786: } // switch Inst[25:20]
7138 // 6786: }
7139 26, 163, 2, // 6791: case 0x1a: {
7140 OPC_SwitchField, 21, 5, // 6794: switch Inst[25:21] {
7141 0, 7, // 6797: case 0x0: {
7142 OPC_CheckPredicate, 31, // 6799: check predicate 31
7143 OPC_Decode, 175, 13, 179, 2, // 6801: decode to FCAF_W using decoder 307
7144 // 6801: }
7145 1, 7, // 6806: case 0x1: {
7146 OPC_CheckPredicate, 31, // 6808: check predicate 31
7147 OPC_Decode, 174, 13, 180, 2, // 6810: decode to FCAF_D using decoder 308
7148 // 6810: }
7149 2, 7, // 6815: case 0x2: {
7150 OPC_CheckPredicate, 31, // 6817: check predicate 31
7151 OPC_Decode, 202, 13, 179, 2, // 6819: decode to FCUN_W using decoder 307
7152 // 6819: }
7153 3, 7, // 6824: case 0x3: {
7154 OPC_CheckPredicate, 31, // 6826: check predicate 31
7155 OPC_Decode, 201, 13, 180, 2, // 6828: decode to FCUN_D using decoder 308
7156 // 6828: }
7157 4, 7, // 6833: case 0x4: {
7158 OPC_CheckPredicate, 31, // 6835: check predicate 31
7159 OPC_Decode, 177, 13, 179, 2, // 6837: decode to FCEQ_W using decoder 307
7160 // 6837: }
7161 5, 7, // 6842: case 0x5: {
7162 OPC_CheckPredicate, 31, // 6844: check predicate 31
7163 OPC_Decode, 176, 13, 180, 2, // 6846: decode to FCEQ_D using decoder 308
7164 // 6846: }
7165 6, 7, // 6851: case 0x6: {
7166 OPC_CheckPredicate, 31, // 6853: check predicate 31
7167 OPC_Decode, 194, 13, 179, 2, // 6855: decode to FCUEQ_W using decoder 307
7168 // 6855: }
7169 7, 7, // 6860: case 0x7: {
7170 OPC_CheckPredicate, 31, // 6862: check predicate 31
7171 OPC_Decode, 193, 13, 180, 2, // 6864: decode to FCUEQ_D using decoder 308
7172 // 6864: }
7173 8, 7, // 6869: case 0x8: {
7174 OPC_CheckPredicate, 31, // 6871: check predicate 31
7175 OPC_Decode, 183, 13, 179, 2, // 6873: decode to FCLT_W using decoder 307
7176 // 6873: }
7177 9, 7, // 6878: case 0x9: {
7178 OPC_CheckPredicate, 31, // 6880: check predicate 31
7179 OPC_Decode, 182, 13, 180, 2, // 6882: decode to FCLT_D using decoder 308
7180 // 6882: }
7181 10, 7, // 6887: case 0xa: {
7182 OPC_CheckPredicate, 31, // 6889: check predicate 31
7183 OPC_Decode, 198, 13, 179, 2, // 6891: decode to FCULT_W using decoder 307
7184 // 6891: }
7185 11, 7, // 6896: case 0xb: {
7186 OPC_CheckPredicate, 31, // 6898: check predicate 31
7187 OPC_Decode, 197, 13, 180, 2, // 6900: decode to FCULT_D using decoder 308
7188 // 6900: }
7189 12, 7, // 6905: case 0xc: {
7190 OPC_CheckPredicate, 31, // 6907: check predicate 31
7191 OPC_Decode, 181, 13, 179, 2, // 6909: decode to FCLE_W using decoder 307
7192 // 6909: }
7193 13, 7, // 6914: case 0xd: {
7194 OPC_CheckPredicate, 31, // 6916: check predicate 31
7195 OPC_Decode, 180, 13, 180, 2, // 6918: decode to FCLE_D using decoder 308
7196 // 6918: }
7197 14, 7, // 6923: case 0xe: {
7198 OPC_CheckPredicate, 31, // 6925: check predicate 31
7199 OPC_Decode, 196, 13, 179, 2, // 6927: decode to FCULE_W using decoder 307
7200 // 6927: }
7201 15, 7, // 6932: case 0xf: {
7202 OPC_CheckPredicate, 31, // 6934: check predicate 31
7203 OPC_Decode, 195, 13, 180, 2, // 6936: decode to FCULE_D using decoder 308
7204 // 6936: }
7205 16, 7, // 6941: case 0x10: {
7206 OPC_CheckPredicate, 31, // 6943: check predicate 31
7207 OPC_Decode, 162, 14, 179, 2, // 6945: decode to FSAF_W using decoder 307
7208 // 6945: }
7209 17, 7, // 6950: case 0x11: {
7210 OPC_CheckPredicate, 31, // 6952: check predicate 31
7211 OPC_Decode, 161, 14, 180, 2, // 6954: decode to FSAF_D using decoder 308
7212 // 6954: }
7213 18, 7, // 6959: case 0x12: {
7214 OPC_CheckPredicate, 31, // 6961: check predicate 31
7215 OPC_Decode, 200, 14, 179, 2, // 6963: decode to FSUN_W using decoder 307
7216 // 6963: }
7217 19, 7, // 6968: case 0x13: {
7218 OPC_CheckPredicate, 31, // 6970: check predicate 31
7219 OPC_Decode, 199, 14, 180, 2, // 6972: decode to FSUN_D using decoder 308
7220 // 6972: }
7221 20, 7, // 6977: case 0x14: {
7222 OPC_CheckPredicate, 31, // 6979: check predicate 31
7223 OPC_Decode, 164, 14, 179, 2, // 6981: decode to FSEQ_W using decoder 307
7224 // 6981: }
7225 21, 7, // 6986: case 0x15: {
7226 OPC_CheckPredicate, 31, // 6988: check predicate 31
7227 OPC_Decode, 163, 14, 180, 2, // 6990: decode to FSEQ_D using decoder 308
7228 // 6990: }
7229 22, 7, // 6995: case 0x16: {
7230 OPC_CheckPredicate, 31, // 6997: check predicate 31
7231 OPC_Decode, 192, 14, 179, 2, // 6999: decode to FSUEQ_W using decoder 307
7232 // 6999: }
7233 23, 7, // 7004: case 0x17: {
7234 OPC_CheckPredicate, 31, // 7006: check predicate 31
7235 OPC_Decode, 191, 14, 180, 2, // 7008: decode to FSUEQ_D using decoder 308
7236 // 7008: }
7237 24, 7, // 7013: case 0x18: {
7238 OPC_CheckPredicate, 31, // 7015: check predicate 31
7239 OPC_Decode, 168, 14, 179, 2, // 7017: decode to FSLT_W using decoder 307
7240 // 7017: }
7241 25, 7, // 7022: case 0x19: {
7242 OPC_CheckPredicate, 31, // 7024: check predicate 31
7243 OPC_Decode, 167, 14, 180, 2, // 7026: decode to FSLT_D using decoder 308
7244 // 7026: }
7245 26, 7, // 7031: case 0x1a: {
7246 OPC_CheckPredicate, 31, // 7033: check predicate 31
7247 OPC_Decode, 196, 14, 179, 2, // 7035: decode to FSULT_W using decoder 307
7248 // 7035: }
7249 27, 7, // 7040: case 0x1b: {
7250 OPC_CheckPredicate, 31, // 7042: check predicate 31
7251 OPC_Decode, 195, 14, 180, 2, // 7044: decode to FSULT_D using decoder 308
7252 // 7044: }
7253 28, 7, // 7049: case 0x1c: {
7254 OPC_CheckPredicate, 31, // 7051: check predicate 31
7255 OPC_Decode, 166, 14, 179, 2, // 7053: decode to FSLE_W using decoder 307
7256 // 7053: }
7257 29, 7, // 7058: case 0x1d: {
7258 OPC_CheckPredicate, 31, // 7060: check predicate 31
7259 OPC_Decode, 165, 14, 180, 2, // 7062: decode to FSLE_D using decoder 308
7260 // 7062: }
7261 30, 7, // 7067: case 0x1e: {
7262 OPC_CheckPredicate, 31, // 7069: check predicate 31
7263 OPC_Decode, 194, 14, 179, 2, // 7071: decode to FSULE_W using decoder 307
7264 // 7071: }
7265 31, 0, // 7076: case 0x1f: {
7266 OPC_CheckPredicate, 31, // 7078: check predicate 31
7267 OPC_Decode, 193, 14, 180, 2, // 7080: decode to FSULE_D using decoder 308
7268 // 7080: }
7269 // 7080: } // switch Inst[25:21]
7270 // 7080: }
7271 27, 237, 1, // 7085: case 0x1b: {
7272 OPC_SwitchField, 21, 5, // 7088: switch Inst[25:21] {
7273 0, 7, // 7091: case 0x0: {
7274 OPC_CheckPredicate, 31, // 7093: check predicate 31
7275 OPC_Decode, 173, 13, 179, 2, // 7095: decode to FADD_W using decoder 307
7276 // 7095: }
7277 1, 7, // 7100: case 0x1: {
7278 OPC_CheckPredicate, 31, // 7102: check predicate 31
7279 OPC_Decode, 164, 13, 180, 2, // 7104: decode to FADD_D using decoder 308
7280 // 7104: }
7281 2, 7, // 7109: case 0x2: {
7282 OPC_CheckPredicate, 31, // 7111: check predicate 31
7283 OPC_Decode, 190, 14, 179, 2, // 7113: decode to FSUB_W using decoder 307
7284 // 7113: }
7285 3, 7, // 7118: case 0x3: {
7286 OPC_CheckPredicate, 31, // 7120: check predicate 31
7287 OPC_Decode, 181, 14, 180, 2, // 7122: decode to FSUB_D using decoder 308
7288 // 7122: }
7289 4, 7, // 7127: case 0x4: {
7290 OPC_CheckPredicate, 31, // 7129: check predicate 31
7291 OPC_Decode, 146, 14, 179, 2, // 7131: decode to FMUL_W using decoder 307
7292 // 7131: }
7293 5, 7, // 7136: case 0x5: {
7294 OPC_CheckPredicate, 31, // 7138: check predicate 31
7295 OPC_Decode, 137, 14, 180, 2, // 7140: decode to FMUL_D using decoder 308
7296 // 7140: }
7297 6, 7, // 7145: case 0x6: {
7298 OPC_CheckPredicate, 31, // 7147: check predicate 31
7299 OPC_Decode, 211, 13, 179, 2, // 7149: decode to FDIV_W using decoder 307
7300 // 7149: }
7301 7, 7, // 7154: case 0x7: {
7302 OPC_CheckPredicate, 31, // 7156: check predicate 31
7303 OPC_Decode, 203, 13, 180, 2, // 7158: decode to FDIV_D using decoder 308
7304 // 7158: }
7305 8, 7, // 7163: case 0x8: {
7306 OPC_CheckPredicate, 31, // 7165: check predicate 31
7307 OPC_Decode, 246, 13, 183, 2, // 7167: decode to FMADD_W using decoder 311
7308 // 7167: }
7309 9, 7, // 7172: case 0x9: {
7310 OPC_CheckPredicate, 31, // 7174: check predicate 31
7311 OPC_Decode, 245, 13, 184, 2, // 7176: decode to FMADD_D using decoder 312
7312 // 7176: }
7313 10, 7, // 7181: case 0xa: {
7314 OPC_CheckPredicate, 31, // 7183: check predicate 31
7315 OPC_Decode, 136, 14, 183, 2, // 7185: decode to FMSUB_W using decoder 311
7316 // 7185: }
7317 11, 7, // 7190: case 0xb: {
7318 OPC_CheckPredicate, 31, // 7192: check predicate 31
7319 OPC_Decode, 135, 14, 184, 2, // 7194: decode to FMSUB_D using decoder 312
7320 // 7194: }
7321 14, 7, // 7199: case 0xe: {
7322 OPC_CheckPredicate, 31, // 7201: check predicate 31
7323 OPC_Decode, 215, 13, 179, 2, // 7203: decode to FEXP2_W using decoder 307
7324 // 7203: }
7325 15, 7, // 7208: case 0xf: {
7326 OPC_CheckPredicate, 31, // 7210: check predicate 31
7327 OPC_Decode, 214, 13, 180, 2, // 7212: decode to FEXP2_D using decoder 308
7328 // 7212: }
7329 16, 7, // 7217: case 0x10: {
7330 OPC_CheckPredicate, 31, // 7219: check predicate 31
7331 OPC_Decode, 212, 13, 219, 2, // 7221: decode to FEXDO_H using decoder 347
7332 // 7221: }
7333 17, 7, // 7226: case 0x11: {
7334 OPC_CheckPredicate, 31, // 7228: check predicate 31
7335 OPC_Decode, 213, 13, 220, 2, // 7230: decode to FEXDO_W using decoder 348
7336 // 7230: }
7337 20, 7, // 7235: case 0x14: {
7338 OPC_CheckPredicate, 31, // 7237: check predicate 31
7339 OPC_Decode, 205, 14, 219, 2, // 7239: decode to FTQ_H using decoder 347
7340 // 7239: }
7341 21, 7, // 7244: case 0x15: {
7342 OPC_CheckPredicate, 31, // 7246: check predicate 31
7343 OPC_Decode, 206, 14, 220, 2, // 7248: decode to FTQ_W using decoder 348
7344 // 7248: }
7345 24, 7, // 7253: case 0x18: {
7346 OPC_CheckPredicate, 31, // 7255: check predicate 31
7347 OPC_Decode, 254, 13, 179, 2, // 7257: decode to FMIN_W using decoder 307
7348 // 7257: }
7349 25, 7, // 7262: case 0x19: {
7350 OPC_CheckPredicate, 31, // 7264: check predicate 31
7351 OPC_Decode, 253, 13, 180, 2, // 7266: decode to FMIN_D using decoder 308
7352 // 7266: }
7353 26, 7, // 7271: case 0x1a: {
7354 OPC_CheckPredicate, 31, // 7273: check predicate 31
7355 OPC_Decode, 252, 13, 179, 2, // 7275: decode to FMIN_A_W using decoder 307
7356 // 7275: }
7357 27, 7, // 7280: case 0x1b: {
7358 OPC_CheckPredicate, 31, // 7282: check predicate 31
7359 OPC_Decode, 251, 13, 180, 2, // 7284: decode to FMIN_A_D using decoder 308
7360 // 7284: }
7361 28, 7, // 7289: case 0x1c: {
7362 OPC_CheckPredicate, 31, // 7291: check predicate 31
7363 OPC_Decode, 250, 13, 179, 2, // 7293: decode to FMAX_W using decoder 307
7364 // 7293: }
7365 29, 7, // 7298: case 0x1d: {
7366 OPC_CheckPredicate, 31, // 7300: check predicate 31
7367 OPC_Decode, 249, 13, 180, 2, // 7302: decode to FMAX_D using decoder 308
7368 // 7302: }
7369 30, 7, // 7307: case 0x1e: {
7370 OPC_CheckPredicate, 31, // 7309: check predicate 31
7371 OPC_Decode, 248, 13, 179, 2, // 7311: decode to FMAX_A_W using decoder 307
7372 // 7311: }
7373 31, 0, // 7316: case 0x1f: {
7374 OPC_CheckPredicate, 31, // 7318: check predicate 31
7375 OPC_Decode, 247, 13, 180, 2, // 7320: decode to FMAX_A_D using decoder 308
7376 // 7320: }
7377 // 7320: } // switch Inst[25:21]
7378 // 7320: }
7379 28, 219, 1, // 7325: case 0x1c: {
7380 OPC_SwitchField, 21, 5, // 7328: switch Inst[25:21] {
7381 2, 7, // 7331: case 0x2: {
7382 OPC_CheckPredicate, 31, // 7333: check predicate 31
7383 OPC_Decode, 192, 13, 179, 2, // 7335: decode to FCOR_W using decoder 307
7384 // 7335: }
7385 3, 7, // 7340: case 0x3: {
7386 OPC_CheckPredicate, 31, // 7342: check predicate 31
7387 OPC_Decode, 191, 13, 180, 2, // 7344: decode to FCOR_D using decoder 308
7388 // 7344: }
7389 4, 7, // 7349: case 0x4: {
7390 OPC_CheckPredicate, 31, // 7351: check predicate 31
7391 OPC_Decode, 200, 13, 179, 2, // 7353: decode to FCUNE_W using decoder 307
7392 // 7353: }
7393 5, 7, // 7358: case 0x5: {
7394 OPC_CheckPredicate, 31, // 7360: check predicate 31
7395 OPC_Decode, 199, 13, 180, 2, // 7362: decode to FCUNE_D using decoder 308
7396 // 7362: }
7397 6, 7, // 7367: case 0x6: {
7398 OPC_CheckPredicate, 31, // 7369: check predicate 31
7399 OPC_Decode, 190, 13, 179, 2, // 7371: decode to FCNE_W using decoder 307
7400 // 7371: }
7401 7, 7, // 7376: case 0x7: {
7402 OPC_CheckPredicate, 31, // 7378: check predicate 31
7403 OPC_Decode, 189, 13, 180, 2, // 7380: decode to FCNE_D using decoder 308
7404 // 7380: }
7405 8, 7, // 7385: case 0x8: {
7406 OPC_CheckPredicate, 31, // 7387: check predicate 31
7407 OPC_Decode, 146, 19, 178, 2, // 7389: decode to MUL_Q_H using decoder 306
7408 // 7389: }
7409 9, 7, // 7394: case 0x9: {
7410 OPC_CheckPredicate, 31, // 7396: check predicate 31
7411 OPC_Decode, 147, 19, 179, 2, // 7398: decode to MUL_Q_W using decoder 307
7412 // 7398: }
7413 10, 7, // 7403: case 0xa: {
7414 OPC_CheckPredicate, 31, // 7405: check predicate 31
7415 OPC_Decode, 244, 16, 182, 2, // 7407: decode to MADD_Q_H using decoder 310
7416 // 7407: }
7417 11, 7, // 7412: case 0xb: {
7418 OPC_CheckPredicate, 31, // 7414: check predicate 31
7419 OPC_Decode, 245, 16, 183, 2, // 7416: decode to MADD_Q_W using decoder 311
7420 // 7416: }
7421 12, 7, // 7421: case 0xc: {
7422 OPC_CheckPredicate, 31, // 7423: check predicate 31
7423 OPC_Decode, 178, 18, 182, 2, // 7425: decode to MSUB_Q_H using decoder 310
7424 // 7425: }
7425 13, 7, // 7430: case 0xd: {
7426 OPC_CheckPredicate, 31, // 7432: check predicate 31
7427 OPC_Decode, 179, 18, 183, 2, // 7434: decode to MSUB_Q_W using decoder 311
7428 // 7434: }
7429 18, 7, // 7439: case 0x12: {
7430 OPC_CheckPredicate, 31, // 7441: check predicate 31
7431 OPC_Decode, 172, 14, 179, 2, // 7443: decode to FSOR_W using decoder 307
7432 // 7443: }
7433 19, 7, // 7448: case 0x13: {
7434 OPC_CheckPredicate, 31, // 7450: check predicate 31
7435 OPC_Decode, 171, 14, 180, 2, // 7452: decode to FSOR_D using decoder 308
7436 // 7452: }
7437 20, 7, // 7457: case 0x14: {
7438 OPC_CheckPredicate, 31, // 7459: check predicate 31
7439 OPC_Decode, 198, 14, 179, 2, // 7461: decode to FSUNE_W using decoder 307
7440 // 7461: }
7441 21, 7, // 7466: case 0x15: {
7442 OPC_CheckPredicate, 31, // 7468: check predicate 31
7443 OPC_Decode, 197, 14, 180, 2, // 7470: decode to FSUNE_D using decoder 308
7444 // 7470: }
7445 22, 7, // 7475: case 0x16: {
7446 OPC_CheckPredicate, 31, // 7477: check predicate 31
7447 OPC_Decode, 170, 14, 179, 2, // 7479: decode to FSNE_W using decoder 307
7448 // 7479: }
7449 23, 7, // 7484: case 0x17: {
7450 OPC_CheckPredicate, 31, // 7486: check predicate 31
7451 OPC_Decode, 169, 14, 180, 2, // 7488: decode to FSNE_D using decoder 308
7452 // 7488: }
7453 24, 7, // 7493: case 0x18: {
7454 OPC_CheckPredicate, 31, // 7495: check predicate 31
7455 OPC_Decode, 248, 18, 178, 2, // 7497: decode to MULR_Q_H using decoder 306
7456 // 7497: }
7457 25, 7, // 7502: case 0x19: {
7458 OPC_CheckPredicate, 31, // 7504: check predicate 31
7459 OPC_Decode, 249, 18, 179, 2, // 7506: decode to MULR_Q_W using decoder 307
7460 // 7506: }
7461 26, 7, // 7511: case 0x1a: {
7462 OPC_CheckPredicate, 31, // 7513: check predicate 31
7463 OPC_Decode, 228, 16, 182, 2, // 7515: decode to MADDR_Q_H using decoder 310
7464 // 7515: }
7465 27, 7, // 7520: case 0x1b: {
7466 OPC_CheckPredicate, 31, // 7522: check predicate 31
7467 OPC_Decode, 229, 16, 183, 2, // 7524: decode to MADDR_Q_W using decoder 311
7468 // 7524: }
7469 28, 7, // 7529: case 0x1c: {
7470 OPC_CheckPredicate, 31, // 7531: check predicate 31
7471 OPC_Decode, 162, 18, 182, 2, // 7533: decode to MSUBR_Q_H using decoder 310
7472 // 7533: }
7473 29, 0, // 7538: case 0x1d: {
7474 OPC_CheckPredicate, 31, // 7540: check predicate 31
7475 OPC_Decode, 163, 18, 183, 2, // 7542: decode to MSUBR_Q_W using decoder 311
7476 // 7542: }
7477 // 7542: } // switch Inst[25:21]
7478 // 7542: }
7479 30, 253, 3, // 7547: case 0x1e: {
7480 OPC_SwitchField, 21, 5, // 7550: switch Inst[25:21] {
7481 0, 7, // 7553: case 0x0: {
7482 OPC_CheckPredicate, 31, // 7555: check predicate 31
7483 OPC_Decode, 138, 7, 177, 2, // 7557: decode to AND_V using decoder 305
7484 // 7557: }
7485 1, 7, // 7562: case 0x1: {
7486 OPC_CheckPredicate, 31, // 7564: check predicate 31
7487 OPC_Decode, 199, 19, 177, 2, // 7566: decode to OR_V using decoder 305
7488 // 7566: }
7489 2, 7, // 7571: case 0x2: {
7490 OPC_CheckPredicate, 31, // 7573: check predicate 31
7491 OPC_Decode, 182, 19, 177, 2, // 7575: decode to NOR_V using decoder 305
7492 // 7575: }
7493 3, 7, // 7580: case 0x3: {
7494 OPC_CheckPredicate, 31, // 7582: check predicate 31
7495 OPC_Decode, 202, 24, 177, 2, // 7584: decode to XOR_V using decoder 305
7496 // 7584: }
7497 4, 7, // 7589: case 0x4: {
7498 OPC_CheckPredicate, 31, // 7591: check predicate 31
7499 OPC_Decode, 200, 8, 181, 2, // 7593: decode to BMNZ_V using decoder 309
7500 // 7593: }
7501 5, 7, // 7598: case 0x5: {
7502 OPC_CheckPredicate, 31, // 7600: check predicate 31
7503 OPC_Decode, 202, 8, 181, 2, // 7602: decode to BMZ_V using decoder 309
7504 // 7602: }
7505 6, 7, // 7607: case 0x6: {
7506 OPC_CheckPredicate, 31, // 7609: check predicate 31
7507 OPC_Decode, 250, 8, 181, 2, // 7611: decode to BSEL_V using decoder 309
7508 // 7611: }
7509 24, 147, 1, // 7616: case 0x18: {
7510 OPC_SwitchField, 16, 5, // 7619: switch Inst[20:16] {
7511 0, 7, // 7622: case 0x0: {
7512 OPC_CheckPredicate, 31, // 7624: check predicate 31
7513 OPC_Decode, 228, 13, 221, 2, // 7626: decode to FILL_B using decoder 349
7514 // 7626: }
7515 1, 7, // 7631: case 0x1: {
7516 OPC_CheckPredicate, 31, // 7633: check predicate 31
7517 OPC_Decode, 230, 13, 222, 2, // 7635: decode to FILL_H using decoder 350
7518 // 7635: }
7519 2, 7, // 7640: case 0x2: {
7520 OPC_CheckPredicate, 31, // 7642: check predicate 31
7521 OPC_Decode, 231, 13, 223, 2, // 7644: decode to FILL_W using decoder 351
7522 // 7644: }
7523 3, 7, // 7649: case 0x3: {
7524 OPC_CheckPredicate, 39, // 7651: check predicate 39
7525 OPC_Decode, 229, 13, 224, 2, // 7653: decode to FILL_D using decoder 352
7526 // 7653: }
7527 4, 7, // 7658: case 0x4: {
7528 OPC_CheckPredicate, 31, // 7660: check predicate 31
7529 OPC_Decode, 218, 19, 213, 2, // 7662: decode to PCNT_B using decoder 341
7530 // 7662: }
7531 5, 7, // 7667: case 0x5: {
7532 OPC_CheckPredicate, 31, // 7669: check predicate 31
7533 OPC_Decode, 220, 19, 225, 2, // 7671: decode to PCNT_H using decoder 353
7534 // 7671: }
7535 6, 7, // 7676: case 0x6: {
7536 OPC_CheckPredicate, 31, // 7678: check predicate 31
7537 OPC_Decode, 221, 19, 226, 2, // 7680: decode to PCNT_W using decoder 354
7538 // 7680: }
7539 7, 7, // 7685: case 0x7: {
7540 OPC_CheckPredicate, 31, // 7687: check predicate 31
7541 OPC_Decode, 219, 19, 227, 2, // 7689: decode to PCNT_D using decoder 355
7542 // 7689: }
7543 8, 7, // 7694: case 0x8: {
7544 OPC_CheckPredicate, 31, // 7696: check predicate 31
7545 OPC_Decode, 156, 19, 213, 2, // 7698: decode to NLOC_B using decoder 341
7546 // 7698: }
7547 9, 7, // 7703: case 0x9: {
7548 OPC_CheckPredicate, 31, // 7705: check predicate 31
7549 OPC_Decode, 158, 19, 225, 2, // 7707: decode to NLOC_H using decoder 353
7550 // 7707: }
7551 10, 7, // 7712: case 0xa: {
7552 OPC_CheckPredicate, 31, // 7714: check predicate 31
7553 OPC_Decode, 159, 19, 226, 2, // 7716: decode to NLOC_W using decoder 354
7554 // 7716: }
7555 11, 7, // 7721: case 0xb: {
7556 OPC_CheckPredicate, 31, // 7723: check predicate 31
7557 OPC_Decode, 157, 19, 227, 2, // 7725: decode to NLOC_D using decoder 355
7558 // 7725: }
7559 12, 7, // 7730: case 0xc: {
7560 OPC_CheckPredicate, 31, // 7732: check predicate 31
7561 OPC_Decode, 160, 19, 213, 2, // 7734: decode to NLZC_B using decoder 341
7562 // 7734: }
7563 13, 7, // 7739: case 0xd: {
7564 OPC_CheckPredicate, 31, // 7741: check predicate 31
7565 OPC_Decode, 162, 19, 225, 2, // 7743: decode to NLZC_H using decoder 353
7566 // 7743: }
7567 14, 7, // 7748: case 0xe: {
7568 OPC_CheckPredicate, 31, // 7750: check predicate 31
7569 OPC_Decode, 163, 19, 226, 2, // 7752: decode to NLZC_W using decoder 354
7570 // 7752: }
7571 15, 0, // 7757: case 0xf: {
7572 OPC_CheckPredicate, 31, // 7759: check predicate 31
7573 OPC_Decode, 161, 19, 227, 2, // 7761: decode to NLZC_D using decoder 355
7574 // 7761: }
7575 // 7761: } // switch Inst[20:16]
7576 // 7761: }
7577 25, 0, // 7766: case 0x19: {
7578 OPC_SwitchField, 16, 5, // 7768: switch Inst[20:16] {
7579 0, 7, // 7771: case 0x0: {
7580 OPC_CheckPredicate, 31, // 7773: check predicate 31
7581 OPC_Decode, 179, 13, 226, 2, // 7775: decode to FCLASS_W using decoder 354
7582 // 7775: }
7583 1, 7, // 7780: case 0x1: {
7584 OPC_CheckPredicate, 31, // 7782: check predicate 31
7585 OPC_Decode, 178, 13, 227, 2, // 7784: decode to FCLASS_D using decoder 355
7586 // 7784: }
7587 2, 7, // 7789: case 0x2: {
7588 OPC_CheckPredicate, 31, // 7791: check predicate 31
7589 OPC_Decode, 208, 14, 226, 2, // 7793: decode to FTRUNC_S_W using decoder 354
7590 // 7793: }
7591 3, 7, // 7798: case 0x3: {
7592 OPC_CheckPredicate, 31, // 7800: check predicate 31
7593 OPC_Decode, 207, 14, 227, 2, // 7802: decode to FTRUNC_S_D using decoder 355
7594 // 7802: }
7595 4, 7, // 7807: case 0x4: {
7596 OPC_CheckPredicate, 31, // 7809: check predicate 31
7597 OPC_Decode, 210, 14, 226, 2, // 7811: decode to FTRUNC_U_W using decoder 354
7598 // 7811: }
7599 5, 7, // 7816: case 0x5: {
7600 OPC_CheckPredicate, 31, // 7818: check predicate 31
7601 OPC_Decode, 209, 14, 227, 2, // 7820: decode to FTRUNC_U_D using decoder 355
7602 // 7820: }
7603 6, 7, // 7825: case 0x6: {
7604 OPC_CheckPredicate, 31, // 7827: check predicate 31
7605 OPC_Decode, 180, 14, 226, 2, // 7829: decode to FSQRT_W using decoder 354
7606 // 7829: }
7607 7, 7, // 7834: case 0x7: {
7608 OPC_CheckPredicate, 31, // 7836: check predicate 31
7609 OPC_Decode, 173, 14, 227, 2, // 7838: decode to FSQRT_D using decoder 355
7610 // 7838: }
7611 8, 7, // 7843: case 0x8: {
7612 OPC_CheckPredicate, 31, // 7845: check predicate 31
7613 OPC_Decode, 160, 14, 226, 2, // 7847: decode to FRSQRT_W using decoder 354
7614 // 7847: }
7615 9, 7, // 7852: case 0x9: {
7616 OPC_CheckPredicate, 31, // 7854: check predicate 31
7617 OPC_Decode, 159, 14, 227, 2, // 7856: decode to FRSQRT_D using decoder 355
7618 // 7856: }
7619 10, 7, // 7861: case 0xa: {
7620 OPC_CheckPredicate, 31, // 7863: check predicate 31
7621 OPC_Decode, 156, 14, 226, 2, // 7865: decode to FRCP_W using decoder 354
7622 // 7865: }
7623 11, 7, // 7870: case 0xb: {
7624 OPC_CheckPredicate, 31, // 7872: check predicate 31
7625 OPC_Decode, 155, 14, 227, 2, // 7874: decode to FRCP_D using decoder 355
7626 // 7874: }
7627 12, 7, // 7879: case 0xc: {
7628 OPC_CheckPredicate, 31, // 7881: check predicate 31
7629 OPC_Decode, 158, 14, 226, 2, // 7883: decode to FRINT_W using decoder 354
7630 // 7883: }
7631 13, 7, // 7888: case 0xd: {
7632 OPC_CheckPredicate, 31, // 7890: check predicate 31
7633 OPC_Decode, 157, 14, 227, 2, // 7892: decode to FRINT_D using decoder 355
7634 // 7892: }
7635 14, 7, // 7897: case 0xe: {
7636 OPC_CheckPredicate, 31, // 7899: check predicate 31
7637 OPC_Decode, 233, 13, 226, 2, // 7901: decode to FLOG2_W using decoder 354
7638 // 7901: }
7639 15, 7, // 7906: case 0xf: {
7640 OPC_CheckPredicate, 31, // 7908: check predicate 31
7641 OPC_Decode, 232, 13, 227, 2, // 7910: decode to FLOG2_D using decoder 355
7642 // 7910: }
7643 16, 7, // 7915: case 0x10: {
7644 OPC_CheckPredicate, 31, // 7917: check predicate 31
7645 OPC_Decode, 217, 13, 228, 2, // 7919: decode to FEXUPL_W using decoder 356
7646 // 7919: }
7647 17, 7, // 7924: case 0x11: {
7648 OPC_CheckPredicate, 31, // 7926: check predicate 31
7649 OPC_Decode, 216, 13, 229, 2, // 7928: decode to FEXUPL_D using decoder 357
7650 // 7928: }
7651 18, 7, // 7933: case 0x12: {
7652 OPC_CheckPredicate, 31, // 7935: check predicate 31
7653 OPC_Decode, 219, 13, 228, 2, // 7937: decode to FEXUPR_W using decoder 356
7654 // 7937: }
7655 19, 7, // 7942: case 0x13: {
7656 OPC_CheckPredicate, 31, // 7944: check predicate 31
7657 OPC_Decode, 218, 13, 229, 2, // 7946: decode to FEXUPR_D using decoder 357
7658 // 7946: }
7659 20, 7, // 7951: case 0x14: {
7660 OPC_CheckPredicate, 31, // 7953: check predicate 31
7661 OPC_Decode, 225, 13, 228, 2, // 7955: decode to FFQL_W using decoder 356
7662 // 7955: }
7663 21, 7, // 7960: case 0x15: {
7664 OPC_CheckPredicate, 31, // 7962: check predicate 31
7665 OPC_Decode, 224, 13, 229, 2, // 7964: decode to FFQL_D using decoder 357
7666 // 7964: }
7667 22, 7, // 7969: case 0x16: {
7668 OPC_CheckPredicate, 31, // 7971: check predicate 31
7669 OPC_Decode, 227, 13, 228, 2, // 7973: decode to FFQR_W using decoder 356
7670 // 7973: }
7671 23, 7, // 7978: case 0x17: {
7672 OPC_CheckPredicate, 31, // 7980: check predicate 31
7673 OPC_Decode, 226, 13, 229, 2, // 7982: decode to FFQR_D using decoder 357
7674 // 7982: }
7675 24, 7, // 7987: case 0x18: {
7676 OPC_CheckPredicate, 31, // 7989: check predicate 31
7677 OPC_Decode, 202, 14, 226, 2, // 7991: decode to FTINT_S_W using decoder 354
7678 // 7991: }
7679 25, 7, // 7996: case 0x19: {
7680 OPC_CheckPredicate, 31, // 7998: check predicate 31
7681 OPC_Decode, 201, 14, 227, 2, // 8000: decode to FTINT_S_D using decoder 355
7682 // 8000: }
7683 26, 7, // 8005: case 0x1a: {
7684 OPC_CheckPredicate, 31, // 8007: check predicate 31
7685 OPC_Decode, 204, 14, 226, 2, // 8009: decode to FTINT_U_W using decoder 354
7686 // 8009: }
7687 27, 7, // 8014: case 0x1b: {
7688 OPC_CheckPredicate, 31, // 8016: check predicate 31
7689 OPC_Decode, 203, 14, 227, 2, // 8018: decode to FTINT_U_D using decoder 355
7690 // 8018: }
7691 28, 7, // 8023: case 0x1c: {
7692 OPC_CheckPredicate, 31, // 8025: check predicate 31
7693 OPC_Decode, 221, 13, 226, 2, // 8027: decode to FFINT_S_W using decoder 354
7694 // 8027: }
7695 29, 7, // 8032: case 0x1d: {
7696 OPC_CheckPredicate, 31, // 8034: check predicate 31
7697 OPC_Decode, 220, 13, 227, 2, // 8036: decode to FFINT_S_D using decoder 355
7698 // 8036: }
7699 30, 7, // 8041: case 0x1e: {
7700 OPC_CheckPredicate, 31, // 8043: check predicate 31
7701 OPC_Decode, 223, 13, 226, 2, // 8045: decode to FFINT_U_W using decoder 354
7702 // 8045: }
7703 31, 0, // 8050: case 0x1f: {
7704 OPC_CheckPredicate, 31, // 8052: check predicate 31
7705 OPC_Decode, 222, 13, 227, 2, // 8054: decode to FFINT_U_D using decoder 355
7706 // 8054: }
7707 // 8054: } // switch Inst[20:16]
7708 // 8054: }
7709 // 8054: } // switch Inst[25:21]
7710 // 8054: }
7711 32, 7, // 8059: case 0x20: {
7712 OPC_CheckPredicate, 31, // 8061: check predicate 31
7713 OPC_Decode, 227, 15, 230, 2, // 8063: decode to LD_B using decoder 358
7714 // 8063: }
7715 33, 7, // 8068: case 0x21: {
7716 OPC_CheckPredicate, 31, // 8070: check predicate 31
7717 OPC_Decode, 229, 15, 231, 2, // 8072: decode to LD_H using decoder 359
7718 // 8072: }
7719 34, 7, // 8077: case 0x22: {
7720 OPC_CheckPredicate, 31, // 8079: check predicate 31
7721 OPC_Decode, 230, 15, 232, 2, // 8081: decode to LD_W using decoder 360
7722 // 8081: }
7723 35, 7, // 8086: case 0x23: {
7724 OPC_CheckPredicate, 31, // 8088: check predicate 31
7725 OPC_Decode, 228, 15, 233, 2, // 8090: decode to LD_D using decoder 361
7726 // 8090: }
7727 36, 7, // 8095: case 0x24: {
7728 OPC_CheckPredicate, 31, // 8097: check predicate 31
7729 OPC_Decode, 213, 22, 230, 2, // 8099: decode to ST_B using decoder 358
7730 // 8099: }
7731 37, 7, // 8104: case 0x25: {
7732 OPC_CheckPredicate, 31, // 8106: check predicate 31
7733 OPC_Decode, 215, 22, 231, 2, // 8108: decode to ST_H using decoder 359
7734 // 8108: }
7735 38, 7, // 8113: case 0x26: {
7736 OPC_CheckPredicate, 31, // 8115: check predicate 31
7737 OPC_Decode, 216, 22, 232, 2, // 8117: decode to ST_W using decoder 360
7738 // 8117: }
7739 39, 0, // 8122: case 0x27: {
7740 OPC_CheckPredicate, 31, // 8124: check predicate 31
7741 OPC_Decode, 214, 22, 233, 2, // 8126: decode to ST_D using decoder 361
7742 // 8126: }
7743 // 8126: } // switch Inst[5:0]
7744 // 8126: }
7745 31, 136, 15, // 8131: case 0x1f: {
7746 OPC_SwitchField, 0, 6, // 8134: switch Inst[5:0] {
7747 0, 7, // 8137: case 0x0: {
7748 OPC_CheckPredicate, 29, // 8139: check predicate 29
7749 OPC_Decode, 255, 12, 234, 2, // 8141: decode to EXT using decoder 362
7750 // 8141: }
7751 4, 7, // 8146: case 0x4: {
7752 OPC_CheckPredicate, 29, // 8148: check predicate 29
7753 OPC_Decode, 247, 14, 235, 2, // 8150: decode to INS using decoder 363
7754 // 8150: }
7755 8, 11, // 8155: case 0x8: {
7756 OPC_CheckPredicate, 43, // 8157: check predicate 43
7757 OPC_CheckField, 6, 5, 0, // 8159: check Inst[10:6] == 0x0
7758 OPC_Decode, 154, 14, 236, 2, // 8163: decode to FORK using decoder 364
7759 // 8163: }
7760 9, 14, // 8168: case 0x9: {
7761 OPC_CheckPredicate, 43, // 8170: check predicate 43
7762 OPC_CheckField, 16, 5, 0, // 8172: check Inst[20:16] == 0x0
7763 OPC_CheckField, 6, 5, 0, // 8176: check Inst[10:6] == 0x0
7764 OPC_Decode, 207, 24, 89, // 8180: decode to YIELD using decoder 89
7765 // 8180: }
7766 10, 30, // 8184: case 0xa: {
7767 OPC_SwitchField, 6, 5, // 8186: switch Inst[10:6] {
7768 0, 7, // 8189: case 0x0: {
7769 OPC_CheckPredicate, 38, // 8191: check predicate 38
7770 OPC_Decode, 199, 16, 237, 2, // 8193: decode to LWX using decoder 365
7771 // 8193: }
7772 4, 7, // 8198: case 0x4: {
7773 OPC_CheckPredicate, 38, // 8200: check predicate 38
7774 OPC_Decode, 247, 15, 237, 2, // 8202: decode to LHX using decoder 365
7775 // 8202: }
7776 6, 0, // 8207: case 0x6: {
7777 OPC_CheckPredicate, 38, // 8209: check predicate 38
7778 OPC_Decode, 192, 15, 237, 2, // 8211: decode to LBUX using decoder 365
7779 // 8211: }
7780 // 8211: } // switch Inst[10:6]
7781 // 8211: }
7782 12, 11, // 8216: case 0xc: {
7783 OPC_CheckPredicate, 38, // 8218: check predicate 38
7784 OPC_CheckField, 6, 10, 0, // 8220: check Inst[15:6] == 0x0
7785 OPC_Decode, 252, 14, 238, 2, // 8224: decode to INSV using decoder 366
7786 // 8224: }
7787 16, 218, 1, // 8229: case 0x10: {
7788 OPC_SwitchField, 6, 5, // 8232: switch Inst[10:6] {
7789 0, 7, // 8235: case 0x0: {
7790 OPC_CheckPredicate, 38, // 8237: check predicate 38
7791 OPC_Decode, 215, 6, 239, 2, // 8239: decode to ADDU_QB using decoder 367
7792 // 8239: }
7793 1, 7, // 8244: case 0x1: {
7794 OPC_CheckPredicate, 38, // 8246: check predicate 38
7795 OPC_Decode, 129, 23, 239, 2, // 8248: decode to SUBU_QB using decoder 367
7796 // 8248: }
7797 4, 7, // 8253: case 0x4: {
7798 OPC_CheckPredicate, 38, // 8255: check predicate 38
7799 OPC_Decode, 219, 6, 239, 2, // 8257: decode to ADDU_S_QB using decoder 367
7800 // 8257: }
7801 5, 7, // 8262: case 0x5: {
7802 OPC_CheckPredicate, 38, // 8264: check predicate 38
7803 OPC_Decode, 133, 23, 239, 2, // 8266: decode to SUBU_S_QB using decoder 367
7804 // 8266: }
7805 6, 7, // 8271: case 0x6: {
7806 OPC_CheckPredicate, 38, // 8273: check predicate 38
7807 OPC_Decode, 235, 18, 239, 2, // 8275: decode to MULEU_S_PH_QBL using decoder 367
7808 // 8275: }
7809 7, 7, // 8280: case 0x7: {
7810 OPC_CheckPredicate, 38, // 8282: check predicate 38
7811 OPC_Decode, 237, 18, 239, 2, // 8284: decode to MULEU_S_PH_QBR using decoder 367
7812 // 8284: }
7813 8, 7, // 8289: case 0x8: {
7814 OPC_CheckPredicate, 72, // 8291: check predicate 72
7815 OPC_Decode, 213, 6, 239, 2, // 8293: decode to ADDU_PH using decoder 367
7816 // 8293: }
7817 9, 7, // 8298: case 0x9: {
7818 OPC_CheckPredicate, 72, // 8300: check predicate 72
7819 OPC_Decode, 255, 22, 239, 2, // 8302: decode to SUBU_PH using decoder 367
7820 // 8302: }
7821 10, 7, // 8307: case 0xa: {
7822 OPC_CheckPredicate, 38, // 8309: check predicate 38
7823 OPC_Decode, 185, 6, 239, 2, // 8311: decode to ADDQ_PH using decoder 367
7824 // 8311: }
7825 11, 7, // 8316: case 0xb: {
7826 OPC_CheckPredicate, 38, // 8318: check predicate 38
7827 OPC_Decode, 226, 22, 239, 2, // 8320: decode to SUBQ_PH using decoder 367
7828 // 8320: }
7829 12, 7, // 8325: case 0xc: {
7830 OPC_CheckPredicate, 72, // 8327: check predicate 72
7831 OPC_Decode, 217, 6, 239, 2, // 8329: decode to ADDU_S_PH using decoder 367
7832 // 8329: }
7833 13, 7, // 8334: case 0xd: {
7834 OPC_CheckPredicate, 72, // 8336: check predicate 72
7835 OPC_Decode, 131, 23, 239, 2, // 8338: decode to SUBU_S_PH using decoder 367
7836 // 8338: }
7837 14, 7, // 8343: case 0xe: {
7838 OPC_CheckPredicate, 38, // 8345: check predicate 38
7839 OPC_Decode, 187, 6, 239, 2, // 8347: decode to ADDQ_S_PH using decoder 367
7840 // 8347: }
7841 15, 7, // 8352: case 0xf: {
7842 OPC_CheckPredicate, 38, // 8354: check predicate 38
7843 OPC_Decode, 228, 22, 239, 2, // 8356: decode to SUBQ_S_PH using decoder 367
7844 // 8356: }
7845 16, 6, // 8361: case 0x10: {
7846 OPC_CheckPredicate, 38, // 8363: check predicate 38
7847 OPC_Decode, 192, 6, 104, // 8365: decode to ADDSC using decoder 104
7848 // 8365: }
7849 17, 6, // 8369: case 0x11: {
7850 OPC_CheckPredicate, 38, // 8371: check predicate 38
7851 OPC_Decode, 229, 6, 104, // 8373: decode to ADDWC using decoder 104
7852 // 8373: }
7853 18, 6, // 8377: case 0x12: {
7854 OPC_CheckPredicate, 38, // 8379: check predicate 38
7855 OPC_Decode, 219, 17, 104, // 8381: decode to MODSUB using decoder 104
7856 // 8381: }
7857 20, 11, // 8385: case 0x14: {
7858 OPC_CheckPredicate, 38, // 8387: check predicate 38
7859 OPC_CheckField, 16, 5, 0, // 8389: check Inst[20:16] == 0x0
7860 OPC_Decode, 148, 20, 240, 2, // 8393: decode to RADDU_W_QB using decoder 368
7861 // 8393: }
7862 22, 6, // 8398: case 0x16: {
7863 OPC_CheckPredicate, 38, // 8400: check predicate 38
7864 OPC_Decode, 189, 6, 104, // 8402: decode to ADDQ_S_W using decoder 104
7865 // 8402: }
7866 23, 6, // 8406: case 0x17: {
7867 OPC_CheckPredicate, 38, // 8408: check predicate 38
7868 OPC_Decode, 230, 22, 104, // 8410: decode to SUBQ_S_W using decoder 104
7869 // 8410: }
7870 28, 7, // 8414: case 0x1c: {
7871 OPC_CheckPredicate, 38, // 8416: check predicate 38
7872 OPC_Decode, 231, 18, 241, 2, // 8418: decode to MULEQ_S_W_PHL using decoder 369
7873 // 8418: }
7874 29, 7, // 8423: case 0x1d: {
7875 OPC_CheckPredicate, 38, // 8425: check predicate 38
7876 OPC_Decode, 233, 18, 241, 2, // 8427: decode to MULEQ_S_W_PHR using decoder 369
7877 // 8427: }
7878 30, 7, // 8432: case 0x1e: {
7879 OPC_CheckPredicate, 72, // 8434: check predicate 72
7880 OPC_Decode, 243, 18, 239, 2, // 8436: decode to MULQ_S_PH using decoder 367
7881 // 8436: }
7882 31, 0, // 8441: case 0x1f: {
7883 OPC_CheckPredicate, 38, // 8443: check predicate 38
7884 OPC_Decode, 239, 18, 239, 2, // 8445: decode to MULQ_RS_PH using decoder 367
7885 // 8445: }
7886 // 8445: } // switch Inst[10:6]
7887 // 8445: }
7888 17, 219, 1, // 8450: case 0x11: {
7889 OPC_SwitchField, 6, 5, // 8453: switch Inst[10:6] {
7890 0, 10, // 8456: case 0x0: {
7891 OPC_CheckPredicate, 38, // 8458: check predicate 38
7892 OPC_CheckField, 11, 5, 0, // 8460: check Inst[15:11] == 0x0
7893 OPC_Decode, 240, 9, 122, // 8464: decode to CMPU_EQ_QB using decoder 122
7894 // 8464: }
7895 1, 10, // 8468: case 0x1: {
7896 OPC_CheckPredicate, 38, // 8470: check predicate 38
7897 OPC_CheckField, 11, 5, 0, // 8472: check Inst[15:11] == 0x0
7898 OPC_Decode, 244, 9, 122, // 8476: decode to CMPU_LT_QB using decoder 122
7899 // 8476: }
7900 2, 10, // 8480: case 0x2: {
7901 OPC_CheckPredicate, 38, // 8482: check predicate 38
7902 OPC_CheckField, 11, 5, 0, // 8484: check Inst[15:11] == 0x0
7903 OPC_Decode, 242, 9, 122, // 8488: decode to CMPU_LE_QB using decoder 122
7904 // 8488: }
7905 3, 7, // 8492: case 0x3: {
7906 OPC_CheckPredicate, 38, // 8494: check predicate 38
7907 OPC_Decode, 224, 19, 239, 2, // 8496: decode to PICK_QB using decoder 367
7908 // 8496: }
7909 4, 7, // 8501: case 0x4: {
7910 OPC_CheckPredicate, 38, // 8503: check predicate 38
7911 OPC_Decode, 234, 9, 241, 2, // 8505: decode to CMPGU_EQ_QB using decoder 369
7912 // 8505: }
7913 5, 7, // 8510: case 0x5: {
7914 OPC_CheckPredicate, 38, // 8512: check predicate 38
7915 OPC_Decode, 238, 9, 241, 2, // 8514: decode to CMPGU_LT_QB using decoder 369
7916 // 8514: }
7917 6, 7, // 8519: case 0x6: {
7918 OPC_CheckPredicate, 38, // 8521: check predicate 38
7919 OPC_Decode, 236, 9, 241, 2, // 8523: decode to CMPGU_LE_QB using decoder 369
7920 // 8523: }
7921 8, 10, // 8528: case 0x8: {
7922 OPC_CheckPredicate, 38, // 8530: check predicate 38
7923 OPC_CheckField, 11, 5, 0, // 8532: check Inst[15:11] == 0x0
7924 OPC_Decode, 250, 9, 122, // 8536: decode to CMP_EQ_PH using decoder 122
7925 // 8536: }
7926 9, 10, // 8540: case 0x9: {
7927 OPC_CheckPredicate, 38, // 8542: check predicate 38
7928 OPC_CheckField, 11, 5, 0, // 8544: check Inst[15:11] == 0x0
7929 OPC_Decode, 136, 10, 122, // 8548: decode to CMP_LT_PH using decoder 122
7930 // 8548: }
7931 10, 10, // 8552: case 0xa: {
7932 OPC_CheckPredicate, 38, // 8554: check predicate 38
7933 OPC_CheckField, 11, 5, 0, // 8556: check Inst[15:11] == 0x0
7934 OPC_Decode, 130, 10, 122, // 8560: decode to CMP_LE_PH using decoder 122
7935 // 8560: }
7936 11, 7, // 8564: case 0xb: {
7937 OPC_CheckPredicate, 38, // 8566: check predicate 38
7938 OPC_Decode, 222, 19, 239, 2, // 8568: decode to PICK_PH using decoder 367
7939 // 8568: }
7940 12, 7, // 8573: case 0xc: {
7941 OPC_CheckPredicate, 38, // 8575: check predicate 38
7942 OPC_Decode, 253, 19, 239, 2, // 8577: decode to PRECRQ_QB_PH using decoder 367
7943 // 8577: }
7944 13, 7, // 8582: case 0xd: {
7945 OPC_CheckPredicate, 72, // 8584: check predicate 72
7946 OPC_Decode, 129, 20, 239, 2, // 8586: decode to PRECR_QB_PH using decoder 367
7947 // 8586: }
7948 14, 7, // 8591: case 0xe: {
7949 OPC_CheckPredicate, 38, // 8593: check predicate 38
7950 OPC_Decode, 204, 19, 239, 2, // 8595: decode to PACKRL_PH using decoder 367
7951 // 8595: }
7952 15, 7, // 8600: case 0xf: {
7953 OPC_CheckPredicate, 38, // 8602: check predicate 38
7954 OPC_Decode, 249, 19, 239, 2, // 8604: decode to PRECRQU_S_QB_PH using decoder 367
7955 // 8604: }
7956 20, 7, // 8609: case 0x14: {
7957 OPC_CheckPredicate, 38, // 8611: check predicate 38
7958 OPC_Decode, 251, 19, 242, 2, // 8613: decode to PRECRQ_PH_W using decoder 370
7959 // 8613: }
7960 21, 7, // 8618: case 0x15: {
7961 OPC_CheckPredicate, 38, // 8620: check predicate 38
7962 OPC_Decode, 255, 19, 242, 2, // 8622: decode to PRECRQ_RS_PH_W using decoder 370
7963 // 8622: }
7964 24, 7, // 8627: case 0x18: {
7965 OPC_CheckPredicate, 72, // 8629: check predicate 72
7966 OPC_Decode, 228, 9, 241, 2, // 8631: decode to CMPGDU_EQ_QB using decoder 369
7967 // 8631: }
7968 25, 7, // 8636: case 0x19: {
7969 OPC_CheckPredicate, 72, // 8638: check predicate 72
7970 OPC_Decode, 232, 9, 241, 2, // 8640: decode to CMPGDU_LT_QB using decoder 369
7971 // 8640: }
7972 26, 7, // 8645: case 0x1a: {
7973 OPC_CheckPredicate, 72, // 8647: check predicate 72
7974 OPC_Decode, 230, 9, 241, 2, // 8649: decode to CMPGDU_LE_QB using decoder 369
7975 // 8649: }
7976 30, 7, // 8654: case 0x1e: {
7977 OPC_CheckPredicate, 72, // 8656: check predicate 72
7978 OPC_Decode, 131, 20, 243, 2, // 8658: decode to PRECR_SRA_PH_W using decoder 371
7979 // 8658: }
7980 31, 0, // 8663: case 0x1f: {
7981 OPC_CheckPredicate, 72, // 8665: check predicate 72
7982 OPC_Decode, 133, 20, 243, 2, // 8667: decode to PRECR_SRA_R_PH_W using decoder 371
7983 // 8667: }
7984 // 8667: } // switch Inst[10:6]
7985 // 8667: }
7986 18, 229, 1, // 8672: case 0x12: {
7987 OPC_SwitchField, 6, 5, // 8675: switch Inst[10:6] {
7988 1, 11, // 8678: case 0x1: {
7989 OPC_CheckPredicate, 72, // 8680: check predicate 72
7990 OPC_CheckField, 21, 5, 0, // 8682: check Inst[25:21] == 0x0
7991 OPC_Decode, 153, 6, 244, 2, // 8686: decode to ABSQ_S_QB using decoder 372
7992 // 8686: }
7993 2, 7, // 8691: case 0x2: {
7994 OPC_CheckPredicate, 38, // 8693: check predicate 38
7995 OPC_Decode, 171, 20, 245, 2, // 8695: decode to REPL_QB using decoder 373
7996 // 8695: }
7997 3, 11, // 8700: case 0x3: {
7998 OPC_CheckPredicate, 38, // 8702: check predicate 38
7999 OPC_CheckField, 21, 5, 0, // 8704: check Inst[25:21] == 0x0
8000 OPC_Decode, 167, 20, 246, 2, // 8708: decode to REPLV_QB using decoder 374
8001 // 8708: }
8002 4, 11, // 8713: case 0x4: {
8003 OPC_CheckPredicate, 38, // 8715: check predicate 38
8004 OPC_CheckField, 21, 5, 0, // 8717: check Inst[25:21] == 0x0
8005 OPC_Decode, 229, 19, 244, 2, // 8721: decode to PRECEQU_PH_QBL using decoder 372
8006 // 8721: }
8007 5, 11, // 8726: case 0x5: {
8008 OPC_CheckPredicate, 38, // 8728: check predicate 38
8009 OPC_CheckField, 21, 5, 0, // 8730: check Inst[25:21] == 0x0
8010 OPC_Decode, 233, 19, 244, 2, // 8734: decode to PRECEQU_PH_QBR using decoder 372
8011 // 8734: }
8012 6, 11, // 8739: case 0x6: {
8013 OPC_CheckPredicate, 38, // 8741: check predicate 38
8014 OPC_CheckField, 21, 5, 0, // 8743: check Inst[25:21] == 0x0
8015 OPC_Decode, 230, 19, 244, 2, // 8747: decode to PRECEQU_PH_QBLA using decoder 372
8016 // 8747: }
8017 7, 11, // 8752: case 0x7: {
8018 OPC_CheckPredicate, 38, // 8754: check predicate 38
8019 OPC_CheckField, 21, 5, 0, // 8756: check Inst[25:21] == 0x0
8020 OPC_Decode, 234, 19, 244, 2, // 8760: decode to PRECEQU_PH_QBRA using decoder 372
8021 // 8760: }
8022 9, 11, // 8765: case 0x9: {
8023 OPC_CheckPredicate, 38, // 8767: check predicate 38
8024 OPC_CheckField, 21, 5, 0, // 8769: check Inst[25:21] == 0x0
8025 OPC_Decode, 151, 6, 244, 2, // 8773: decode to ABSQ_S_PH using decoder 372
8026 // 8773: }
8027 10, 7, // 8778: case 0xa: {
8028 OPC_CheckPredicate, 38, // 8780: check predicate 38
8029 OPC_Decode, 169, 20, 140, 1, // 8782: decode to REPL_PH using decoder 140
8030 // 8782: }
8031 11, 11, // 8787: case 0xb: {
8032 OPC_CheckPredicate, 38, // 8789: check predicate 38
8033 OPC_CheckField, 21, 5, 0, // 8791: check Inst[25:21] == 0x0
8034 OPC_Decode, 165, 20, 246, 2, // 8795: decode to REPLV_PH using decoder 374
8035 // 8795: }
8036 12, 11, // 8800: case 0xc: {
8037 OPC_CheckPredicate, 38, // 8802: check predicate 38
8038 OPC_CheckField, 21, 5, 0, // 8804: check Inst[25:21] == 0x0
8039 OPC_Decode, 237, 19, 247, 2, // 8808: decode to PRECEQ_W_PHL using decoder 375
8040 // 8808: }
8041 13, 11, // 8813: case 0xd: {
8042 OPC_CheckPredicate, 38, // 8815: check predicate 38
8043 OPC_CheckField, 21, 5, 0, // 8817: check Inst[25:21] == 0x0
8044 OPC_Decode, 239, 19, 247, 2, // 8821: decode to PRECEQ_W_PHR using decoder 375
8045 // 8821: }
8046 17, 11, // 8826: case 0x11: {
8047 OPC_CheckPredicate, 38, // 8828: check predicate 38
8048 OPC_CheckField, 21, 5, 0, // 8830: check Inst[25:21] == 0x0
8049 OPC_Decode, 155, 6, 248, 2, // 8834: decode to ABSQ_S_W using decoder 376
8050 // 8834: }
8051 27, 11, // 8839: case 0x1b: {
8052 OPC_CheckPredicate, 38, // 8841: check predicate 38
8053 OPC_CheckField, 21, 5, 0, // 8843: check Inst[25:21] == 0x0
8054 OPC_Decode, 162, 8, 248, 2, // 8847: decode to BITREV using decoder 376
8055 // 8847: }
8056 28, 11, // 8852: case 0x1c: {
8057 OPC_CheckPredicate, 38, // 8854: check predicate 38
8058 OPC_CheckField, 21, 5, 0, // 8856: check Inst[25:21] == 0x0
8059 OPC_Decode, 241, 19, 244, 2, // 8860: decode to PRECEU_PH_QBL using decoder 372
8060 // 8860: }
8061 29, 11, // 8865: case 0x1d: {
8062 OPC_CheckPredicate, 38, // 8867: check predicate 38
8063 OPC_CheckField, 21, 5, 0, // 8869: check Inst[25:21] == 0x0
8064 OPC_Decode, 245, 19, 244, 2, // 8873: decode to PRECEU_PH_QBR using decoder 372
8065 // 8873: }
8066 30, 11, // 8878: case 0x1e: {
8067 OPC_CheckPredicate, 38, // 8880: check predicate 38
8068 OPC_CheckField, 21, 5, 0, // 8882: check Inst[25:21] == 0x0
8069 OPC_Decode, 242, 19, 244, 2, // 8886: decode to PRECEU_PH_QBLA using decoder 372
8070 // 8886: }
8071 31, 0, // 8891: case 0x1f: {
8072 OPC_CheckPredicate, 38, // 8893: check predicate 38
8073 OPC_CheckField, 21, 5, 0, // 8895: check Inst[25:21] == 0x0
8074 OPC_Decode, 246, 19, 244, 2, // 8899: decode to PRECEU_PH_QBRA using decoder 372
8075 // 8899: }
8076 // 8899: } // switch Inst[10:6]
8077 // 8899: }
8078 19, 199, 1, // 8904: case 0x13: {
8079 OPC_SwitchField, 6, 5, // 8907: switch Inst[10:6] {
8080 0, 7, // 8910: case 0x0: {
8081 OPC_CheckPredicate, 38, // 8912: check predicate 38
8082 OPC_Decode, 193, 21, 249, 2, // 8914: decode to SHLL_QB using decoder 377
8083 // 8914: }
8084 1, 7, // 8919: case 0x1: {
8085 OPC_CheckPredicate, 38, // 8921: check predicate 38
8086 OPC_Decode, 225, 21, 249, 2, // 8923: decode to SHRL_QB using decoder 377
8087 // 8923: }
8088 2, 7, // 8928: case 0x2: {
8089 OPC_CheckPredicate, 38, // 8930: check predicate 38
8090 OPC_Decode, 185, 21, 250, 2, // 8932: decode to SHLLV_QB using decoder 378
8091 // 8932: }
8092 3, 7, // 8937: case 0x3: {
8093 OPC_CheckPredicate, 38, // 8939: check predicate 38
8094 OPC_Decode, 221, 21, 250, 2, // 8941: decode to SHRLV_QB using decoder 378
8095 // 8941: }
8096 4, 7, // 8946: case 0x4: {
8097 OPC_CheckPredicate, 72, // 8948: check predicate 72
8098 OPC_Decode, 211, 21, 249, 2, // 8950: decode to SHRA_QB using decoder 377
8099 // 8950: }
8100 5, 7, // 8955: case 0x5: {
8101 OPC_CheckPredicate, 72, // 8957: check predicate 72
8102 OPC_Decode, 215, 21, 249, 2, // 8959: decode to SHRA_R_QB using decoder 377
8103 // 8959: }
8104 6, 7, // 8964: case 0x6: {
8105 OPC_CheckPredicate, 72, // 8966: check predicate 72
8106 OPC_Decode, 201, 21, 250, 2, // 8968: decode to SHRAV_QB using decoder 378
8107 // 8968: }
8108 7, 7, // 8973: case 0x7: {
8109 OPC_CheckPredicate, 72, // 8975: check predicate 72
8110 OPC_Decode, 205, 21, 250, 2, // 8977: decode to SHRAV_R_QB using decoder 378
8111 // 8977: }
8112 8, 7, // 8982: case 0x8: {
8113 OPC_CheckPredicate, 38, // 8984: check predicate 38
8114 OPC_Decode, 191, 21, 249, 2, // 8986: decode to SHLL_PH using decoder 377
8115 // 8986: }
8116 9, 7, // 8991: case 0x9: {
8117 OPC_CheckPredicate, 38, // 8993: check predicate 38
8118 OPC_Decode, 209, 21, 249, 2, // 8995: decode to SHRA_PH using decoder 377
8119 // 8995: }
8120 10, 7, // 9000: case 0xa: {
8121 OPC_CheckPredicate, 38, // 9002: check predicate 38
8122 OPC_Decode, 183, 21, 250, 2, // 9004: decode to SHLLV_PH using decoder 378
8123 // 9004: }
8124 11, 7, // 9009: case 0xb: {
8125 OPC_CheckPredicate, 38, // 9011: check predicate 38
8126 OPC_Decode, 199, 21, 250, 2, // 9013: decode to SHRAV_PH using decoder 378
8127 // 9013: }
8128 12, 7, // 9018: case 0xc: {
8129 OPC_CheckPredicate, 38, // 9020: check predicate 38
8130 OPC_Decode, 195, 21, 249, 2, // 9022: decode to SHLL_S_PH using decoder 377
8131 // 9022: }
8132 13, 7, // 9027: case 0xd: {
8133 OPC_CheckPredicate, 38, // 9029: check predicate 38
8134 OPC_Decode, 213, 21, 249, 2, // 9031: decode to SHRA_R_PH using decoder 377
8135 // 9031: }
8136 14, 7, // 9036: case 0xe: {
8137 OPC_CheckPredicate, 38, // 9038: check predicate 38
8138 OPC_Decode, 187, 21, 250, 2, // 9040: decode to SHLLV_S_PH using decoder 378
8139 // 9040: }
8140 15, 7, // 9045: case 0xf: {
8141 OPC_CheckPredicate, 38, // 9047: check predicate 38
8142 OPC_Decode, 203, 21, 250, 2, // 9049: decode to SHRAV_R_PH using decoder 378
8143 // 9049: }
8144 20, 7, // 9054: case 0x14: {
8145 OPC_CheckPredicate, 38, // 9056: check predicate 38
8146 OPC_Decode, 197, 21, 251, 2, // 9058: decode to SHLL_S_W using decoder 379
8147 // 9058: }
8148 21, 7, // 9063: case 0x15: {
8149 OPC_CheckPredicate, 38, // 9065: check predicate 38
8150 OPC_Decode, 217, 21, 251, 2, // 9067: decode to SHRA_R_W using decoder 379
8151 // 9067: }
8152 22, 6, // 9072: case 0x16: {
8153 OPC_CheckPredicate, 38, // 9074: check predicate 38
8154 OPC_Decode, 189, 21, 98, // 9076: decode to SHLLV_S_W using decoder 98
8155 // 9076: }
8156 23, 6, // 9080: case 0x17: {
8157 OPC_CheckPredicate, 38, // 9082: check predicate 38
8158 OPC_Decode, 207, 21, 98, // 9084: decode to SHRAV_R_W using decoder 98
8159 // 9084: }
8160 25, 7, // 9088: case 0x19: {
8161 OPC_CheckPredicate, 72, // 9090: check predicate 72
8162 OPC_Decode, 223, 21, 249, 2, // 9092: decode to SHRL_PH using decoder 377
8163 // 9092: }
8164 27, 0, // 9097: case 0x1b: {
8165 OPC_CheckPredicate, 72, // 9099: check predicate 72
8166 OPC_Decode, 219, 21, 250, 2, // 9101: decode to SHRLV_PH using decoder 378
8167 // 9101: }
8168 // 9101: } // switch Inst[10:6]
8169 // 9101: }
8170 24, 141, 1, // 9106: case 0x18: {
8171 OPC_SwitchField, 6, 5, // 9109: switch Inst[10:6] {
8172 0, 7, // 9112: case 0x0: {
8173 OPC_CheckPredicate, 72, // 9114: check predicate 72
8174 OPC_Decode, 208, 6, 239, 2, // 9116: decode to ADDUH_QB using decoder 367
8175 // 9116: }
8176 1, 7, // 9121: case 0x1: {
8177 OPC_CheckPredicate, 72, // 9123: check predicate 72
8178 OPC_Decode, 250, 22, 239, 2, // 9125: decode to SUBUH_QB using decoder 367
8179 // 9125: }
8180 2, 7, // 9130: case 0x2: {
8181 OPC_CheckPredicate, 72, // 9132: check predicate 72
8182 OPC_Decode, 210, 6, 239, 2, // 9134: decode to ADDUH_R_QB using decoder 367
8183 // 9134: }
8184 3, 7, // 9139: case 0x3: {
8185 OPC_CheckPredicate, 72, // 9141: check predicate 72
8186 OPC_Decode, 252, 22, 239, 2, // 9143: decode to SUBUH_R_QB using decoder 367
8187 // 9143: }
8188 8, 7, // 9148: case 0x8: {
8189 OPC_CheckPredicate, 72, // 9150: check predicate 72
8190 OPC_Decode, 177, 6, 239, 2, // 9152: decode to ADDQH_PH using decoder 367
8191 // 9152: }
8192 9, 7, // 9157: case 0x9: {
8193 OPC_CheckPredicate, 72, // 9159: check predicate 72
8194 OPC_Decode, 218, 22, 239, 2, // 9161: decode to SUBQH_PH using decoder 367
8195 // 9161: }
8196 10, 7, // 9166: case 0xa: {
8197 OPC_CheckPredicate, 72, // 9168: check predicate 72
8198 OPC_Decode, 179, 6, 239, 2, // 9170: decode to ADDQH_R_PH using decoder 367
8199 // 9170: }
8200 11, 7, // 9175: case 0xb: {
8201 OPC_CheckPredicate, 72, // 9177: check predicate 72
8202 OPC_Decode, 220, 22, 239, 2, // 9179: decode to SUBQH_R_PH using decoder 367
8203 // 9179: }
8204 12, 7, // 9184: case 0xc: {
8205 OPC_CheckPredicate, 72, // 9186: check predicate 72
8206 OPC_Decode, 144, 19, 239, 2, // 9188: decode to MUL_PH using decoder 367
8207 // 9188: }
8208 14, 7, // 9193: case 0xe: {
8209 OPC_CheckPredicate, 72, // 9195: check predicate 72
8210 OPC_Decode, 149, 19, 239, 2, // 9197: decode to MUL_S_PH using decoder 367
8211 // 9197: }
8212 16, 6, // 9202: case 0x10: {
8213 OPC_CheckPredicate, 72, // 9204: check predicate 72
8214 OPC_Decode, 183, 6, 104, // 9206: decode to ADDQH_W using decoder 104
8215 // 9206: }
8216 17, 6, // 9210: case 0x11: {
8217 OPC_CheckPredicate, 72, // 9212: check predicate 72
8218 OPC_Decode, 224, 22, 104, // 9214: decode to SUBQH_W using decoder 104
8219 // 9214: }
8220 18, 6, // 9218: case 0x12: {
8221 OPC_CheckPredicate, 72, // 9220: check predicate 72
8222 OPC_Decode, 181, 6, 104, // 9222: decode to ADDQH_R_W using decoder 104
8223 // 9222: }
8224 19, 6, // 9226: case 0x13: {
8225 OPC_CheckPredicate, 72, // 9228: check predicate 72
8226 OPC_Decode, 222, 22, 104, // 9230: decode to SUBQH_R_W using decoder 104
8227 // 9230: }
8228 22, 6, // 9234: case 0x16: {
8229 OPC_CheckPredicate, 72, // 9236: check predicate 72
8230 OPC_Decode, 245, 18, 104, // 9238: decode to MULQ_S_W using decoder 104
8231 // 9238: }
8232 23, 0, // 9242: case 0x17: {
8233 OPC_CheckPredicate, 72, // 9244: check predicate 72
8234 OPC_Decode, 241, 18, 104, // 9246: decode to MULQ_RS_W using decoder 104
8235 // 9246: }
8236 // 9246: } // switch Inst[10:6]
8237 // 9246: }
8238 25, 11, // 9250: case 0x19: {
8239 OPC_CheckPredicate, 73, // 9252: check predicate 73
8240 OPC_CheckField, 6, 1, 0, // 9254: check Inst[6] == 0x0
8241 OPC_Decode, 179, 16, 252, 2, // 9258: decode to LWLE using decoder 380
8242 // 9258: }
8243 26, 11, // 9263: case 0x1a: {
8244 OPC_CheckPredicate, 73, // 9265: check predicate 73
8245 OPC_CheckField, 6, 1, 0, // 9267: check Inst[6] == 0x0
8246 OPC_Decode, 192, 16, 252, 2, // 9271: decode to LWRE using decoder 380
8247 // 9271: }
8248 27, 11, // 9276: case 0x1b: {
8249 OPC_CheckPredicate, 45, // 9278: check predicate 45
8250 OPC_CheckField, 6, 1, 0, // 9280: check Inst[6] == 0x0
8251 OPC_Decode, 149, 9, 253, 2, // 9284: decode to CACHEE using decoder 381
8252 // 9284: }
8253 28, 11, // 9289: case 0x1c: {
8254 OPC_CheckPredicate, 45, // 9291: check predicate 45
8255 OPC_CheckField, 6, 1, 0, // 9293: check Inst[6] == 0x0
8256 OPC_Decode, 223, 20, 254, 2, // 9297: decode to SBE using decoder 382
8257 // 9297: }
8258 29, 11, // 9302: case 0x1d: {
8259 OPC_CheckPredicate, 45, // 9304: check predicate 45
8260 OPC_CheckField, 6, 1, 0, // 9306: check Inst[6] == 0x0
8261 OPC_Decode, 173, 21, 254, 2, // 9310: decode to SHE using decoder 382
8262 // 9310: }
8263 30, 11, // 9315: case 0x1e: {
8264 OPC_CheckPredicate, 45, // 9317: check predicate 45
8265 OPC_CheckField, 6, 1, 0, // 9319: check Inst[6] == 0x0
8266 OPC_Decode, 236, 20, 255, 2, // 9323: decode to SCE using decoder 383
8267 // 9323: }
8268 31, 11, // 9328: case 0x1f: {
8269 OPC_CheckPredicate, 45, // 9330: check predicate 45
8270 OPC_CheckField, 6, 1, 0, // 9332: check Inst[6] == 0x0
8271 OPC_Decode, 167, 23, 254, 2, // 9336: decode to SWE using decoder 382
8272 // 9336: }
8273 32, 42, // 9341: case 0x20: {
8274 OPC_SwitchField, 6, 5, // 9343: switch Inst[10:6] {
8275 2, 11, // 9346: case 0x2: {
8276 OPC_CheckPredicate, 29, // 9348: check predicate 29
8277 OPC_CheckField, 21, 5, 0, // 9350: check Inst[25:21] == 0x0
8278 OPC_Decode, 188, 24, 248, 2, // 9354: decode to WSBH using decoder 376
8279 // 9354: }
8280 16, 11, // 9359: case 0x10: {
8281 OPC_CheckPredicate, 29, // 9361: check predicate 29
8282 OPC_CheckField, 21, 5, 0, // 9363: check Inst[25:21] == 0x0
8283 OPC_Decode, 139, 21, 248, 2, // 9367: decode to SEB using decoder 376
8284 // 9367: }
8285 24, 0, // 9372: case 0x18: {
8286 OPC_CheckPredicate, 29, // 9374: check predicate 29
8287 OPC_CheckField, 21, 5, 0, // 9376: check Inst[25:21] == 0x0
8288 OPC_Decode, 143, 21, 248, 2, // 9380: decode to SEH using decoder 376
8289 // 9380: }
8290 // 9380: } // switch Inst[10:6]
8291 // 9380: }
8292 33, 11, // 9385: case 0x21: {
8293 OPC_CheckPredicate, 73, // 9387: check predicate 73
8294 OPC_CheckField, 6, 1, 0, // 9389: check Inst[6] == 0x0
8295 OPC_Decode, 173, 23, 254, 2, // 9393: decode to SWLE using decoder 382
8296 // 9393: }
8297 34, 11, // 9398: case 0x22: {
8298 OPC_CheckPredicate, 73, // 9400: check predicate 73
8299 OPC_CheckField, 6, 1, 0, // 9402: check Inst[6] == 0x0
8300 OPC_Decode, 184, 23, 254, 2, // 9406: decode to SWRE using decoder 382
8301 // 9406: }
8302 35, 11, // 9411: case 0x23: {
8303 OPC_CheckPredicate, 45, // 9413: check predicate 45
8304 OPC_CheckField, 6, 1, 0, // 9415: check Inst[6] == 0x0
8305 OPC_Decode, 136, 20, 253, 2, // 9419: decode to PREFE using decoder 381
8306 // 9419: }
8307 40, 11, // 9424: case 0x28: {
8308 OPC_CheckPredicate, 45, // 9426: check predicate 45
8309 OPC_CheckField, 6, 1, 0, // 9428: check Inst[6] == 0x0
8310 OPC_Decode, 205, 15, 254, 2, // 9432: decode to LBuE using decoder 382
8311 // 9432: }
8312 41, 11, // 9437: case 0x29: {
8313 OPC_CheckPredicate, 45, // 9439: check predicate 45
8314 OPC_CheckField, 6, 1, 0, // 9441: check Inst[6] == 0x0
8315 OPC_Decode, 128, 16, 254, 2, // 9445: decode to LHuE using decoder 382
8316 // 9445: }
8317 44, 11, // 9450: case 0x2c: {
8318 OPC_CheckPredicate, 45, // 9452: check predicate 45
8319 OPC_CheckField, 6, 1, 0, // 9454: check Inst[6] == 0x0
8320 OPC_Decode, 186, 15, 254, 2, // 9458: decode to LBE using decoder 382
8321 // 9458: }
8322 45, 11, // 9463: case 0x2d: {
8323 OPC_CheckPredicate, 45, // 9465: check predicate 45
8324 OPC_CheckField, 6, 1, 0, // 9467: check Inst[6] == 0x0
8325 OPC_Decode, 237, 15, 254, 2, // 9471: decode to LHE using decoder 382
8326 // 9471: }
8327 46, 11, // 9476: case 0x2e: {
8328 OPC_CheckPredicate, 45, // 9478: check predicate 45
8329 OPC_CheckField, 6, 1, 0, // 9480: check Inst[6] == 0x0
8330 OPC_Decode, 140, 16, 254, 2, // 9484: decode to LLE using decoder 382
8331 // 9484: }
8332 47, 11, // 9489: case 0x2f: {
8333 OPC_CheckPredicate, 45, // 9491: check predicate 45
8334 OPC_CheckField, 6, 1, 0, // 9493: check Inst[6] == 0x0
8335 OPC_Decode, 172, 16, 254, 2, // 9497: decode to LWE using decoder 382
8336 // 9497: }
8337 48, 161, 2, // 9502: case 0x30: {
8338 OPC_SwitchField, 6, 5, // 9505: switch Inst[10:6] {
8339 0, 11, // 9508: case 0x0: {
8340 OPC_CheckPredicate, 72, // 9510: check predicate 72
8341 OPC_CheckField, 13, 3, 0, // 9512: check Inst[15:13] == 0x0
8342 OPC_Decode, 185, 12, 128, 3, // 9516: decode to DPA_W_PH using decoder 384
8343 // 9516: }
8344 1, 11, // 9521: case 0x1: {
8345 OPC_CheckPredicate, 72, // 9523: check predicate 72
8346 OPC_CheckField, 13, 3, 0, // 9525: check Inst[15:13] == 0x0
8347 OPC_Decode, 208, 12, 128, 3, // 9529: decode to DPS_W_PH using decoder 384
8348 // 9529: }
8349 2, 11, // 9534: case 0x2: {
8350 OPC_CheckPredicate, 72, // 9536: check predicate 72
8351 OPC_CheckField, 13, 3, 0, // 9538: check Inst[15:13] == 0x0
8352 OPC_Decode, 252, 18, 128, 3, // 9542: decode to MULSA_W_PH using decoder 384
8353 // 9542: }
8354 3, 11, // 9547: case 0x3: {
8355 OPC_CheckPredicate, 38, // 9549: check predicate 38
8356 OPC_CheckField, 13, 3, 0, // 9551: check Inst[15:13] == 0x0
8357 OPC_Decode, 179, 12, 128, 3, // 9555: decode to DPAU_H_QBL using decoder 384
8358 // 9555: }
8359 4, 11, // 9560: case 0x4: {
8360 OPC_CheckPredicate, 38, // 9562: check predicate 38
8361 OPC_CheckField, 13, 3, 0, // 9564: check Inst[15:13] == 0x0
8362 OPC_Decode, 177, 12, 128, 3, // 9568: decode to DPAQ_S_W_PH using decoder 384
8363 // 9568: }
8364 5, 11, // 9573: case 0x5: {
8365 OPC_CheckPredicate, 38, // 9575: check predicate 38
8366 OPC_CheckField, 13, 3, 0, // 9577: check Inst[15:13] == 0x0
8367 OPC_Decode, 194, 12, 128, 3, // 9581: decode to DPSQ_S_W_PH using decoder 384
8368 // 9581: }
8369 6, 11, // 9586: case 0x6: {
8370 OPC_CheckPredicate, 38, // 9588: check predicate 38
8371 OPC_CheckField, 13, 3, 0, // 9590: check Inst[15:13] == 0x0
8372 OPC_Decode, 250, 18, 128, 3, // 9594: decode to MULSAQ_S_W_PH using decoder 384
8373 // 9594: }
8374 7, 11, // 9599: case 0x7: {
8375 OPC_CheckPredicate, 38, // 9601: check predicate 38
8376 OPC_CheckField, 13, 3, 0, // 9603: check Inst[15:13] == 0x0
8377 OPC_Decode, 181, 12, 128, 3, // 9607: decode to DPAU_H_QBR using decoder 384
8378 // 9607: }
8379 8, 11, // 9612: case 0x8: {
8380 OPC_CheckPredicate, 72, // 9614: check predicate 72
8381 OPC_CheckField, 13, 3, 0, // 9616: check Inst[15:13] == 0x0
8382 OPC_Decode, 183, 12, 128, 3, // 9620: decode to DPAX_W_PH using decoder 384
8383 // 9620: }
8384 9, 11, // 9625: case 0x9: {
8385 OPC_CheckPredicate, 72, // 9627: check predicate 72
8386 OPC_CheckField, 13, 3, 0, // 9629: check Inst[15:13] == 0x0
8387 OPC_Decode, 206, 12, 128, 3, // 9633: decode to DPSX_W_PH using decoder 384
8388 // 9633: }
8389 11, 11, // 9638: case 0xb: {
8390 OPC_CheckPredicate, 38, // 9640: check predicate 38
8391 OPC_CheckField, 13, 3, 0, // 9642: check Inst[15:13] == 0x0
8392 OPC_Decode, 202, 12, 128, 3, // 9646: decode to DPSU_H_QBL using decoder 384
8393 // 9646: }
8394 12, 11, // 9651: case 0xc: {
8395 OPC_CheckPredicate, 38, // 9653: check predicate 38
8396 OPC_CheckField, 13, 3, 0, // 9655: check Inst[15:13] == 0x0
8397 OPC_Decode, 175, 12, 128, 3, // 9659: decode to DPAQ_SA_L_W using decoder 384
8398 // 9659: }
8399 13, 11, // 9664: case 0xd: {
8400 OPC_CheckPredicate, 38, // 9666: check predicate 38
8401 OPC_CheckField, 13, 3, 0, // 9668: check Inst[15:13] == 0x0
8402 OPC_Decode, 192, 12, 128, 3, // 9672: decode to DPSQ_SA_L_W using decoder 384
8403 // 9672: }
8404 15, 11, // 9677: case 0xf: {
8405 OPC_CheckPredicate, 38, // 9679: check predicate 38
8406 OPC_CheckField, 13, 3, 0, // 9681: check Inst[15:13] == 0x0
8407 OPC_Decode, 204, 12, 128, 3, // 9685: decode to DPSU_H_QBR using decoder 384
8408 // 9685: }
8409 16, 11, // 9690: case 0x10: {
8410 OPC_CheckPredicate, 38, // 9692: check predicate 38
8411 OPC_CheckField, 13, 3, 0, // 9694: check Inst[15:13] == 0x0
8412 OPC_Decode, 248, 16, 128, 3, // 9698: decode to MAQ_SA_W_PHL using decoder 384
8413 // 9698: }
8414 18, 11, // 9703: case 0x12: {
8415 OPC_CheckPredicate, 38, // 9705: check predicate 38
8416 OPC_CheckField, 13, 3, 0, // 9707: check Inst[15:13] == 0x0
8417 OPC_Decode, 250, 16, 128, 3, // 9711: decode to MAQ_SA_W_PHR using decoder 384
8418 // 9711: }
8419 20, 11, // 9716: case 0x14: {
8420 OPC_CheckPredicate, 38, // 9718: check predicate 38
8421 OPC_CheckField, 13, 3, 0, // 9720: check Inst[15:13] == 0x0
8422 OPC_Decode, 252, 16, 128, 3, // 9724: decode to MAQ_S_W_PHL using decoder 384
8423 // 9724: }
8424 22, 11, // 9729: case 0x16: {
8425 OPC_CheckPredicate, 38, // 9731: check predicate 38
8426 OPC_CheckField, 13, 3, 0, // 9733: check Inst[15:13] == 0x0
8427 OPC_Decode, 254, 16, 128, 3, // 9737: decode to MAQ_S_W_PHR using decoder 384
8428 // 9737: }
8429 24, 11, // 9742: case 0x18: {
8430 OPC_CheckPredicate, 72, // 9744: check predicate 72
8431 OPC_CheckField, 13, 3, 0, // 9746: check Inst[15:13] == 0x0
8432 OPC_Decode, 173, 12, 128, 3, // 9750: decode to DPAQX_S_W_PH using decoder 384
8433 // 9750: }
8434 25, 11, // 9755: case 0x19: {
8435 OPC_CheckPredicate, 72, // 9757: check predicate 72
8436 OPC_CheckField, 13, 3, 0, // 9759: check Inst[15:13] == 0x0
8437 OPC_Decode, 190, 12, 128, 3, // 9763: decode to DPSQX_S_W_PH using decoder 384
8438 // 9763: }
8439 26, 11, // 9768: case 0x1a: {
8440 OPC_CheckPredicate, 72, // 9770: check predicate 72
8441 OPC_CheckField, 13, 3, 0, // 9772: check Inst[15:13] == 0x0
8442 OPC_Decode, 171, 12, 128, 3, // 9776: decode to DPAQX_SA_W_PH using decoder 384
8443 // 9776: }
8444 27, 0, // 9781: case 0x1b: {
8445 OPC_CheckPredicate, 72, // 9783: check predicate 72
8446 OPC_CheckField, 13, 3, 0, // 9785: check Inst[15:13] == 0x0
8447 OPC_Decode, 188, 12, 128, 3, // 9789: decode to DPSQX_SA_W_PH using decoder 384
8448 // 9789: }
8449 // 9789: } // switch Inst[10:6]
8450 // 9789: }
8451 49, 30, // 9794: case 0x31: {
8452 OPC_SwitchField, 6, 5, // 9796: switch Inst[10:6] {
8453 0, 7, // 9799: case 0x0: {
8454 OPC_CheckPredicate, 72, // 9801: check predicate 72
8455 OPC_Decode, 142, 7, 129, 3, // 9803: decode to APPEND using decoder 385
8456 // 9803: }
8457 1, 7, // 9808: case 0x1: {
8458 OPC_CheckPredicate, 72, // 9810: check predicate 72
8459 OPC_Decode, 144, 20, 129, 3, // 9812: decode to PREPEND using decoder 385
8460 // 9812: }
8461 16, 0, // 9817: case 0x10: {
8462 OPC_CheckPredicate, 72, // 9819: check predicate 72
8463 OPC_Decode, 188, 7, 129, 3, // 9821: decode to BALIGN using decoder 385
8464 // 9821: }
8465 // 9821: } // switch Inst[10:6]
8466 // 9821: }
8467 56, 216, 1, // 9826: case 0x38: {
8468 OPC_SwitchField, 6, 5, // 9829: switch Inst[10:6] {
8469 0, 11, // 9832: case 0x0: {
8470 OPC_CheckPredicate, 38, // 9834: check predicate 38
8471 OPC_CheckField, 13, 3, 0, // 9836: check Inst[15:13] == 0x0
8472 OPC_Decode, 150, 13, 130, 3, // 9840: decode to EXTR_W using decoder 386
8473 // 9840: }
8474 1, 11, // 9845: case 0x1: {
8475 OPC_CheckPredicate, 38, // 9847: check predicate 38
8476 OPC_CheckField, 13, 3, 0, // 9849: check Inst[15:13] == 0x0
8477 OPC_Decode, 142, 13, 131, 3, // 9853: decode to EXTRV_W using decoder 387
8478 // 9853: }
8479 2, 11, // 9858: case 0x2: {
8480 OPC_CheckPredicate, 38, // 9860: check predicate 38
8481 OPC_CheckField, 13, 3, 0, // 9862: check Inst[15:13] == 0x0
8482 OPC_Decode, 128, 13, 130, 3, // 9866: decode to EXTP using decoder 386
8483 // 9866: }
8484 3, 11, // 9871: case 0x3: {
8485 OPC_CheckPredicate, 38, // 9873: check predicate 38
8486 OPC_CheckField, 13, 3, 0, // 9875: check Inst[15:13] == 0x0
8487 OPC_Decode, 133, 13, 131, 3, // 9879: decode to EXTPV using decoder 387
8488 // 9879: }
8489 4, 11, // 9884: case 0x4: {
8490 OPC_CheckPredicate, 38, // 9886: check predicate 38
8491 OPC_CheckField, 13, 3, 0, // 9888: check Inst[15:13] == 0x0
8492 OPC_Decode, 146, 13, 130, 3, // 9892: decode to EXTR_R_W using decoder 386
8493 // 9892: }
8494 5, 11, // 9897: case 0x5: {
8495 OPC_CheckPredicate, 38, // 9899: check predicate 38
8496 OPC_CheckField, 13, 3, 0, // 9901: check Inst[15:13] == 0x0
8497 OPC_Decode, 138, 13, 131, 3, // 9905: decode to EXTRV_R_W using decoder 387
8498 // 9905: }
8499 6, 11, // 9910: case 0x6: {
8500 OPC_CheckPredicate, 38, // 9912: check predicate 38
8501 OPC_CheckField, 13, 3, 0, // 9914: check Inst[15:13] == 0x0
8502 OPC_Decode, 144, 13, 130, 3, // 9918: decode to EXTR_RS_W using decoder 386
8503 // 9918: }
8504 7, 11, // 9923: case 0x7: {
8505 OPC_CheckPredicate, 38, // 9925: check predicate 38
8506 OPC_CheckField, 13, 3, 0, // 9927: check Inst[15:13] == 0x0
8507 OPC_Decode, 136, 13, 131, 3, // 9931: decode to EXTRV_RS_W using decoder 387
8508 // 9931: }
8509 10, 11, // 9936: case 0xa: {
8510 OPC_CheckPredicate, 38, // 9938: check predicate 38
8511 OPC_CheckField, 13, 3, 0, // 9940: check Inst[15:13] == 0x0
8512 OPC_Decode, 129, 13, 130, 3, // 9944: decode to EXTPDP using decoder 386
8513 // 9944: }
8514 11, 11, // 9949: case 0xb: {
8515 OPC_CheckPredicate, 38, // 9951: check predicate 38
8516 OPC_CheckField, 13, 3, 0, // 9953: check Inst[15:13] == 0x0
8517 OPC_Decode, 130, 13, 131, 3, // 9957: decode to EXTPDPV using decoder 387
8518 // 9957: }
8519 14, 11, // 9962: case 0xe: {
8520 OPC_CheckPredicate, 38, // 9964: check predicate 38
8521 OPC_CheckField, 13, 3, 0, // 9966: check Inst[15:13] == 0x0
8522 OPC_Decode, 148, 13, 130, 3, // 9970: decode to EXTR_S_H using decoder 386
8523 // 9970: }
8524 15, 11, // 9975: case 0xf: {
8525 OPC_CheckPredicate, 38, // 9977: check predicate 38
8526 OPC_CheckField, 13, 3, 0, // 9979: check Inst[15:13] == 0x0
8527 OPC_Decode, 140, 13, 131, 3, // 9983: decode to EXTRV_S_H using decoder 387
8528 // 9983: }
8529 18, 7, // 9988: case 0x12: {
8530 OPC_CheckPredicate, 38, // 9990: check predicate 38
8531 OPC_Decode, 150, 20, 132, 3, // 9992: decode to RDDSP using decoder 388
8532 // 9992: }
8533 19, 7, // 9997: case 0x13: {
8534 OPC_CheckPredicate, 41, // 9999: check predicate 41
8535 OPC_Decode, 184, 24, 133, 3, // 10001: decode to WRDSP using decoder 389
8536 // 10001: }
8537 26, 11, // 10006: case 0x1a: {
8538 OPC_CheckPredicate, 38, // 10008: check predicate 38
8539 OPC_CheckField, 13, 7, 0, // 10010: check Inst[19:13] == 0x0
8540 OPC_Decode, 179, 21, 134, 3, // 10014: decode to SHILO using decoder 390
8541 // 10014: }
8542 27, 11, // 10019: case 0x1b: {
8543 OPC_CheckPredicate, 38, // 10021: check predicate 38
8544 OPC_CheckField, 13, 8, 0, // 10023: check Inst[20:13] == 0x0
8545 OPC_Decode, 180, 21, 135, 3, // 10027: decode to SHILOV using decoder 391
8546 // 10027: }
8547 31, 0, // 10032: case 0x1f: {
8548 OPC_CheckPredicate, 38, // 10034: check predicate 38
8549 OPC_CheckField, 13, 8, 0, // 10036: check Inst[20:13] == 0x0
8550 OPC_Decode, 209, 18, 135, 3, // 10040: decode to MTHLIP using decoder 391
8551 // 10040: }
8552 // 10040: } // switch Inst[10:6]
8553 // 10040: }
8554 59, 0, // 10045: case 0x3b: {
8555 OPC_CheckPredicate, 28, // 10047: check predicate 28
8556 OPC_CheckField, 21, 5, 0, // 10049: check Inst[25:21] == 0x0
8557 OPC_CheckField, 9, 2, 0, // 10053: check Inst[10:9] == 0x0
8558 OPC_Decode, 152, 20, 136, 3, // 10057: decode to RDHWR using decoder 392
8559 // 10057: }
8560 // 10057: } // switch Inst[5:0]
8561 // 10057: }
8562 32, 7, // 10062: case 0x20: {
8563 OPC_CheckPredicate, 28, // 10064: check predicate 28
8564 OPC_Decode, 183, 15, 137, 3, // 10066: decode to LB using decoder 393
8565 // 10066: }
8566 33, 7, // 10071: case 0x21: {
8567 OPC_CheckPredicate, 28, // 10073: check predicate 28
8568 OPC_Decode, 234, 15, 137, 3, // 10075: decode to LH using decoder 393
8569 // 10075: }
8570 34, 7, // 10080: case 0x22: {
8571 OPC_CheckPredicate, 32, // 10082: check predicate 32
8572 OPC_Decode, 177, 16, 138, 3, // 10084: decode to LWL using decoder 394
8573 // 10084: }
8574 35, 7, // 10089: case 0x23: {
8575 OPC_CheckPredicate, 28, // 10091: check predicate 28
8576 OPC_Decode, 159, 16, 137, 3, // 10093: decode to LW using decoder 393
8577 // 10093: }
8578 36, 7, // 10098: case 0x24: {
8579 OPC_CheckPredicate, 28, // 10100: check predicate 28
8580 OPC_Decode, 203, 15, 137, 3, // 10102: decode to LBu using decoder 393
8581 // 10102: }
8582 37, 7, // 10107: case 0x25: {
8583 OPC_CheckPredicate, 28, // 10109: check predicate 28
8584 OPC_Decode, 254, 15, 137, 3, // 10111: decode to LHu using decoder 393
8585 // 10111: }
8586 38, 7, // 10116: case 0x26: {
8587 OPC_CheckPredicate, 32, // 10118: check predicate 32
8588 OPC_Decode, 190, 16, 138, 3, // 10120: decode to LWR using decoder 394
8589 // 10120: }
8590 40, 7, // 10125: case 0x28: {
8591 OPC_CheckPredicate, 28, // 10127: check predicate 28
8592 OPC_Decode, 218, 20, 137, 3, // 10129: decode to SB using decoder 393
8593 // 10129: }
8594 41, 7, // 10134: case 0x29: {
8595 OPC_CheckPredicate, 28, // 10136: check predicate 28
8596 OPC_Decode, 168, 21, 137, 3, // 10138: decode to SH using decoder 393
8597 // 10138: }
8598 42, 7, // 10143: case 0x2a: {
8599 OPC_CheckPredicate, 32, // 10145: check predicate 32
8600 OPC_Decode, 171, 23, 137, 3, // 10147: decode to SWL using decoder 393
8601 // 10147: }
8602 43, 7, // 10152: case 0x2b: {
8603 OPC_CheckPredicate, 28, // 10154: check predicate 28
8604 OPC_Decode, 153, 23, 137, 3, // 10156: decode to SW using decoder 393
8605 // 10156: }
8606 46, 7, // 10161: case 0x2e: {
8607 OPC_CheckPredicate, 32, // 10163: check predicate 32
8608 OPC_Decode, 182, 23, 137, 3, // 10165: decode to SWR using decoder 393
8609 // 10165: }
8610 47, 7, // 10170: case 0x2f: {
8611 OPC_CheckPredicate, 74, // 10172: check predicate 74
8612 OPC_Decode, 148, 9, 139, 3, // 10174: decode to CACHE using decoder 395
8613 // 10174: }
8614 48, 7, // 10179: case 0x30: {
8615 OPC_CheckPredicate, 75, // 10181: check predicate 75
8616 OPC_Decode, 135, 16, 137, 3, // 10183: decode to LL using decoder 393
8617 // 10183: }
8618 49, 7, // 10188: case 0x31: {
8619 OPC_CheckPredicate, 48, // 10190: check predicate 48
8620 OPC_Decode, 164, 16, 140, 3, // 10192: decode to LWC1 using decoder 396
8621 // 10192: }
8622 50, 7, // 10197: case 0x32: {
8623 OPC_CheckPredicate, 32, // 10199: check predicate 32
8624 OPC_Decode, 166, 16, 141, 3, // 10201: decode to LWC2 using decoder 397
8625 // 10201: }
8626 51, 7, // 10206: case 0x33: {
8627 OPC_CheckPredicate, 74, // 10208: check predicate 74
8628 OPC_Decode, 135, 20, 139, 3, // 10210: decode to PREF using decoder 395
8629 // 10210: }
8630 53, 7, // 10215: case 0x35: {
8631 OPC_CheckPredicate, 60, // 10217: check predicate 60
8632 OPC_Decode, 209, 15, 142, 3, // 10219: decode to LDC1 using decoder 398
8633 // 10219: }
8634 54, 7, // 10224: case 0x36: {
8635 OPC_CheckPredicate, 40, // 10226: check predicate 40
8636 OPC_Decode, 214, 15, 141, 3, // 10228: decode to LDC2 using decoder 397
8637 // 10228: }
8638 56, 7, // 10233: case 0x38: {
8639 OPC_CheckPredicate, 75, // 10235: check predicate 75
8640 OPC_Decode, 231, 20, 143, 3, // 10237: decode to SC using decoder 399
8641 // 10237: }
8642 57, 7, // 10242: case 0x39: {
8643 OPC_CheckPredicate, 48, // 10244: check predicate 48
8644 OPC_Decode, 159, 23, 140, 3, // 10246: decode to SWC1 using decoder 396
8645 // 10246: }
8646 58, 7, // 10251: case 0x3a: {
8647 OPC_CheckPredicate, 32, // 10253: check predicate 32
8648 OPC_Decode, 161, 23, 141, 3, // 10255: decode to SWC2 using decoder 397
8649 // 10255: }
8650 61, 7, // 10260: case 0x3d: {
8651 OPC_CheckPredicate, 60, // 10262: check predicate 60
8652 OPC_Decode, 252, 20, 142, 3, // 10264: decode to SDC1 using decoder 398
8653 // 10264: }
8654 62, 0, // 10269: case 0x3e: {
8655 OPC_CheckPredicate, 40, // 10271: check predicate 40
8656 OPC_Decode, 129, 21, 141, 3, // 10273: decode to SDC2 using decoder 397
8657 // 10273: }
8658 // 10273: } // switch Inst[31:26]
8659};
8660static const uint8_t DecoderTableMips32_64_PTR6432[33] = {
8661 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
8662 0, 10, // 3: case 0x0: {
8663 OPC_CheckPredicate, 76, // 5: check predicate 76
8664 OPC_CheckField, 0, 21, 8, // 7: check Inst[20:0] == 0x8
8665 OPC_Decode, 162, 15, 88, // 11: decode to JR64 using decoder 88
8666 // 11: }
8667 48, 7, // 15: case 0x30: {
8668 OPC_CheckPredicate, 77, // 17: check predicate 77
8669 OPC_Decode, 136, 16, 137, 3, // 19: decode to LL64 using decoder 393
8670 // 19: }
8671 56, 0, // 24: case 0x38: {
8672 OPC_CheckPredicate, 77, // 26: check predicate 77
8673 OPC_Decode, 232, 20, 143, 3, // 28: decode to SC64 using decoder 399
8674 // 28: }
8675 // 28: } // switch Inst[31:26]
8676};
8677static const uint8_t DecoderTableMips32r6_64r632[1500] = {
8678 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
8679 0, 179, 2, // 3: case 0x0: {
8680 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
8681 5, 11, // 9: case 0x5: {
8682 OPC_CheckPredicate, 78, // 11: check predicate 78
8683 OPC_CheckField, 8, 3, 0, // 13: check Inst[10:8] == 0x0
8684 OPC_Decode, 150, 16, 226, 1, // 17: decode to LSA_R6 using decoder 226
8685 // 17: }
8686 9, 11, // 22: case 0x9: {
8687 OPC_CheckPredicate, 78, // 24: check predicate 78
8688 OPC_CheckField, 6, 15, 16, // 26: check Inst[20:6] == 0x10
8689 OPC_Decode, 172, 15, 227, 1, // 30: decode to JR_HB_R6 using decoder 227
8690 // 30: }
8691 14, 7, // 35: case 0xe: {
8692 OPC_CheckPredicate, 79, // 37: check predicate 79
8693 OPC_Decode, 251, 20, 229, 1, // 39: decode to SDBBP_R6 using decoder 229
8694 // 39: }
8695 16, 14, // 44: case 0x10: {
8696 OPC_CheckPredicate, 78, // 46: check predicate 78
8697 OPC_CheckField, 16, 5, 0, // 48: check Inst[20:16] == 0x0
8698 OPC_CheckField, 6, 5, 1, // 52: check Inst[10:6] == 0x1
8699 OPC_Decode, 227, 9, 89, // 56: decode to CLZ_R6 using decoder 89
8700 // 56: }
8701 17, 14, // 60: case 0x11: {
8702 OPC_CheckPredicate, 78, // 62: check predicate 78
8703 OPC_CheckField, 16, 5, 0, // 64: check Inst[20:16] == 0x0
8704 OPC_CheckField, 6, 5, 1, // 68: check Inst[10:6] == 0x1
8705 OPC_Decode, 206, 9, 89, // 72: decode to CLO_R6 using decoder 89
8706 // 72: }
8707 18, 14, // 76: case 0x12: {
8708 OPC_CheckPredicate, 80, // 78: check predicate 80
8709 OPC_CheckField, 16, 5, 0, // 80: check Inst[20:16] == 0x0
8710 OPC_CheckField, 6, 5, 1, // 84: check Inst[10:6] == 0x1
8711 OPC_Decode, 233, 11, 90, // 88: decode to DCLZ_R6 using decoder 90
8712 // 88: }
8713 19, 14, // 92: case 0x13: {
8714 OPC_CheckPredicate, 80, // 94: check predicate 80
8715 OPC_CheckField, 16, 5, 0, // 96: check Inst[20:16] == 0x0
8716 OPC_CheckField, 6, 5, 1, // 100: check Inst[10:6] == 0x1
8717 OPC_Decode, 231, 11, 90, // 104: decode to DCLO_R6 using decoder 90
8718 // 104: }
8719 21, 11, // 108: case 0x15: {
8720 OPC_CheckPredicate, 80, // 110: check predicate 80
8721 OPC_CheckField, 8, 3, 0, // 112: check Inst[10:8] == 0x0
8722 OPC_Decode, 138, 12, 235, 1, // 116: decode to DLSA_R6 using decoder 235
8723 // 116: }
8724 24, 19, // 121: case 0x18: {
8725 OPC_SwitchField, 6, 5, // 123: switch Inst[10:6] {
8726 2, 6, // 126: case 0x2: {
8727 OPC_CheckPredicate, 79, // 128: check predicate 79
8728 OPC_Decode, 148, 19, 104, // 130: decode to MUL_R6 using decoder 104
8729 // 130: }
8730 3, 0, // 134: case 0x3: {
8731 OPC_CheckPredicate, 79, // 136: check predicate 79
8732 OPC_Decode, 223, 18, 104, // 138: decode to MUH using decoder 104
8733 // 138: }
8734 // 138: } // switch Inst[10:6]
8735 // 138: }
8736 25, 19, // 142: case 0x19: {
8737 OPC_SwitchField, 6, 5, // 144: switch Inst[10:6] {
8738 2, 6, // 147: case 0x2: {
8739 OPC_CheckPredicate, 79, // 149: check predicate 79
8740 OPC_Decode, 134, 19, 104, // 151: decode to MULU using decoder 104
8741 // 151: }
8742 3, 0, // 155: case 0x3: {
8743 OPC_CheckPredicate, 79, // 157: check predicate 79
8744 OPC_Decode, 224, 18, 104, // 159: decode to MUHU using decoder 104
8745 // 159: }
8746 // 159: } // switch Inst[10:6]
8747 // 159: }
8748 26, 19, // 163: case 0x1a: {
8749 OPC_SwitchField, 6, 5, // 165: switch Inst[10:6] {
8750 2, 6, // 168: case 0x2: {
8751 OPC_CheckPredicate, 79, // 170: check predicate 79
8752 OPC_Decode, 248, 11, 104, // 172: decode to DIV using decoder 104
8753 // 172: }
8754 3, 0, // 176: case 0x3: {
8755 OPC_CheckPredicate, 79, // 178: check predicate 79
8756 OPC_Decode, 218, 17, 104, // 180: decode to MOD using decoder 104
8757 // 180: }
8758 // 180: } // switch Inst[10:6]
8759 // 180: }
8760 27, 19, // 184: case 0x1b: {
8761 OPC_SwitchField, 6, 5, // 186: switch Inst[10:6] {
8762 2, 6, // 189: case 0x2: {
8763 OPC_CheckPredicate, 79, // 191: check predicate 79
8764 OPC_Decode, 249, 11, 104, // 193: decode to DIVU using decoder 104
8765 // 193: }
8766 3, 0, // 197: case 0x3: {
8767 OPC_CheckPredicate, 79, // 199: check predicate 79
8768 OPC_Decode, 221, 17, 104, // 201: decode to MODU using decoder 104
8769 // 201: }
8770 // 201: } // switch Inst[10:6]
8771 // 201: }
8772 28, 19, // 205: case 0x1c: {
8773 OPC_SwitchField, 6, 5, // 207: switch Inst[10:6] {
8774 2, 6, // 210: case 0x2: {
8775 OPC_CheckPredicate, 80, // 212: check predicate 80
8776 OPC_Decode, 158, 12, 87, // 214: decode to DMUL_R6 using decoder 87
8777 // 214: }
8778 3, 0, // 218: case 0x3: {
8779 OPC_CheckPredicate, 80, // 220: check predicate 80
8780 OPC_Decode, 152, 12, 87, // 222: decode to DMUH using decoder 87
8781 // 222: }
8782 // 222: } // switch Inst[10:6]
8783 // 222: }
8784 29, 19, // 226: case 0x1d: {
8785 OPC_SwitchField, 6, 5, // 228: switch Inst[10:6] {
8786 2, 6, // 231: case 0x2: {
8787 OPC_CheckPredicate, 80, // 233: check predicate 80
8788 OPC_Decode, 157, 12, 87, // 235: decode to DMULU using decoder 87
8789 // 235: }
8790 3, 0, // 239: case 0x3: {
8791 OPC_CheckPredicate, 80, // 241: check predicate 80
8792 OPC_Decode, 153, 12, 87, // 243: decode to DMUHU using decoder 87
8793 // 243: }
8794 // 243: } // switch Inst[10:6]
8795 // 243: }
8796 30, 19, // 247: case 0x1e: {
8797 OPC_SwitchField, 6, 5, // 249: switch Inst[10:6] {
8798 2, 6, // 252: case 0x2: {
8799 OPC_CheckPredicate, 80, // 254: check predicate 80
8800 OPC_Decode, 234, 11, 87, // 256: decode to DDIV using decoder 87
8801 // 256: }
8802 3, 0, // 260: case 0x3: {
8803 OPC_CheckPredicate, 80, // 262: check predicate 80
8804 OPC_Decode, 144, 12, 87, // 264: decode to DMOD using decoder 87
8805 // 264: }
8806 // 264: } // switch Inst[10:6]
8807 // 264: }
8808 31, 19, // 268: case 0x1f: {
8809 OPC_SwitchField, 6, 5, // 270: switch Inst[10:6] {
8810 2, 6, // 273: case 0x2: {
8811 OPC_CheckPredicate, 80, // 275: check predicate 80
8812 OPC_Decode, 235, 11, 87, // 277: decode to DDIVU using decoder 87
8813 // 277: }
8814 3, 0, // 281: case 0x3: {
8815 OPC_CheckPredicate, 80, // 283: check predicate 80
8816 OPC_Decode, 145, 12, 87, // 285: decode to DMODU using decoder 87
8817 // 285: }
8818 // 285: } // switch Inst[10:6]
8819 // 285: }
8820 53, 10, // 289: case 0x35: {
8821 OPC_CheckPredicate, 81, // 291: check predicate 81
8822 OPC_CheckField, 6, 5, 0, // 293: check Inst[10:6] == 0x0
8823 OPC_Decode, 147, 21, 104, // 297: decode to SELEQZ using decoder 104
8824 // 297: }
8825 55, 0, // 301: case 0x37: {
8826 OPC_CheckPredicate, 81, // 303: check predicate 81
8827 OPC_CheckField, 6, 5, 0, // 305: check Inst[10:6] == 0x0
8828 OPC_Decode, 154, 21, 104, // 309: decode to SELNEZ using decoder 104
8829 // 309: }
8830 // 309: } // switch Inst[5:0]
8831 // 309: }
8832 1, 63, // 313: case 0x1: {
8833 OPC_SwitchField, 16, 5, // 315: switch Inst[20:16] {
8834 6, 7, // 318: case 0x6: {
8835 OPC_CheckPredicate, 80, // 320: check predicate 80
8836 OPC_Decode, 225, 11, 144, 3, // 322: decode to DAHI using decoder 400
8837 // 322: }
8838 16, 14, // 327: case 0x10: {
8839 OPC_CheckPredicate, 78, // 329: check predicate 78
8840 OPC_CheckField, 21, 5, 0, // 331: check Inst[25:21] == 0x0
8841 OPC_CheckField, 0, 16, 0, // 335: check Inst[15:0] == 0x0
8842 OPC_Decode, 155, 19, 10, // 339: decode to NAL using decoder 10
8843 // 339: }
8844 17, 11, // 343: case 0x11: {
8845 OPC_CheckPredicate, 78, // 345: check predicate 78
8846 OPC_CheckField, 21, 5, 0, // 347: check Inst[25:21] == 0x0
8847 OPC_Decode, 183, 7, 239, 1, // 351: decode to BAL using decoder 239
8848 // 351: }
8849 23, 11, // 356: case 0x17: {
8850 OPC_CheckPredicate, 79, // 358: check predicate 79
8851 OPC_CheckField, 21, 5, 0, // 360: check Inst[25:21] == 0x0
8852 OPC_Decode, 233, 21, 145, 3, // 364: decode to SIGRIE using decoder 401
8853 // 364: }
8854 30, 0, // 369: case 0x1e: {
8855 OPC_CheckPredicate, 80, // 371: check predicate 80
8856 OPC_Decode, 227, 11, 144, 3, // 373: decode to DATI using decoder 400
8857 // 373: }
8858 // 373: } // switch Inst[20:16]
8859 // 373: }
8860 6, 7, // 378: case 0x6: {
8861 OPC_CheckPredicate, 79, // 380: check predicate 79
8862 OPC_Decode, 255, 7, 146, 3, // 382: decode to BGEZALC using decoder 402
8863 // 382: }
8864 7, 7, // 387: case 0x7: {
8865 OPC_CheckPredicate, 79, // 389: check predicate 79
8866 OPC_Decode, 189, 8, 147, 3, // 391: decode to BLTZALC using decoder 403
8867 // 391: }
8868 8, 7, // 396: case 0x8: {
8869 OPC_CheckPredicate, 79, // 398: check predicate 79
8870 OPC_Decode, 226, 7, 148, 3, // 400: decode to BEQC using decoder 404
8871 // 400: }
8872 15, 7, // 405: case 0xf: {
8873 OPC_CheckPredicate, 78, // 407: check predicate 78
8874 OPC_Decode, 152, 7, 244, 1, // 409: decode to AUI using decoder 244
8875 // 409: }
8876 16, 29, // 414: case 0x10: {
8877 OPC_SwitchField, 0, 16, // 416: switch Inst[15:0] {
8878 4, 11, // 419: case 0x4: {
8879 OPC_CheckPredicate, 78, // 421: check predicate 78
8880 OPC_CheckField, 21, 5, 11, // 423: check Inst[25:21] == 0xb
8881 OPC_Decode, 251, 12, 136, 1, // 427: decode to EVP using decoder 136
8882 // 427: }
8883 36, 0, // 432: case 0x24: {
8884 OPC_CheckPredicate, 78, // 434: check predicate 78
8885 OPC_CheckField, 21, 5, 11, // 436: check Inst[25:21] == 0xb
8886 OPC_Decode, 229, 12, 136, 1, // 440: decode to DVP using decoder 136
8887 // 440: }
8888 // 440: } // switch Inst[15:0]
8889 // 440: }
8890 17, 160, 4, // 445: case 0x11: {
8891 OPC_SwitchField, 21, 5, // 448: switch Inst[25:21] {
8892 9, 7, // 451: case 0x9: {
8893 OPC_CheckPredicate, 82, // 453: check predicate 82
8894 OPC_Decode, 200, 7, 149, 3, // 455: decode to BC1EQZ using decoder 405
8895 // 455: }
8896 13, 7, // 460: case 0xd: {
8897 OPC_CheckPredicate, 82, // 462: check predicate 82
8898 OPC_Decode, 205, 7, 149, 3, // 464: decode to BC1NEZ using decoder 405
8899 // 464: }
8900 16, 110, // 469: case 0x10: {
8901 OPC_SwitchField, 0, 6, // 471: switch Inst[5:0] {
8902 16, 7, // 474: case 0x10: {
8903 OPC_CheckPredicate, 82, // 476: check predicate 82
8904 OPC_Decode, 163, 21, 150, 3, // 478: decode to SEL_S using decoder 406
8905 // 478: }
8906 20, 7, // 483: case 0x14: {
8907 OPC_CheckPredicate, 82, // 485: check predicate 82
8908 OPC_Decode, 152, 21, 131, 2, // 487: decode to SELEQZ_S using decoder 259
8909 // 487: }
8910 23, 7, // 492: case 0x17: {
8911 OPC_CheckPredicate, 82, // 494: check predicate 82
8912 OPC_Decode, 159, 21, 131, 2, // 496: decode to SELNEZ_S using decoder 259
8913 // 496: }
8914 24, 7, // 501: case 0x18: {
8915 OPC_CheckPredicate, 82, // 503: check predicate 82
8916 OPC_Decode, 226, 16, 150, 3, // 505: decode to MADDF_S using decoder 406
8917 // 505: }
8918 25, 7, // 510: case 0x19: {
8919 OPC_CheckPredicate, 82, // 512: check predicate 82
8920 OPC_Decode, 160, 18, 150, 3, // 514: decode to MSUBF_S using decoder 406
8921 // 514: }
8922 26, 11, // 519: case 0x1a: {
8923 OPC_CheckPredicate, 82, // 521: check predicate 82
8924 OPC_CheckField, 16, 5, 0, // 523: check Inst[20:16] == 0x0
8925 OPC_Decode, 178, 20, 132, 2, // 527: decode to RINT_S using decoder 260
8926 // 527: }
8927 27, 11, // 532: case 0x1b: {
8928 OPC_CheckPredicate, 82, // 534: check predicate 82
8929 OPC_CheckField, 16, 5, 0, // 536: check Inst[20:16] == 0x0
8930 OPC_Decode, 184, 9, 132, 2, // 540: decode to CLASS_S using decoder 260
8931 // 540: }
8932 28, 7, // 545: case 0x1c: {
8933 OPC_CheckPredicate, 82, // 547: check predicate 82
8934 OPC_Decode, 208, 17, 131, 2, // 549: decode to MIN_S using decoder 259
8935 // 549: }
8936 29, 7, // 554: case 0x1d: {
8937 OPC_CheckPredicate, 82, // 556: check predicate 82
8938 OPC_Decode, 192, 17, 131, 2, // 558: decode to MINA_S using decoder 259
8939 // 558: }
8940 30, 7, // 563: case 0x1e: {
8941 OPC_CheckPredicate, 82, // 565: check predicate 82
8942 OPC_Decode, 146, 17, 131, 2, // 567: decode to MAX_S using decoder 259
8943 // 567: }
8944 31, 0, // 572: case 0x1f: {
8945 OPC_CheckPredicate, 82, // 574: check predicate 82
8946 OPC_Decode, 130, 17, 131, 2, // 576: decode to MAXA_S using decoder 259
8947 // 576: }
8948 // 576: } // switch Inst[5:0]
8949 // 576: }
8950 17, 110, // 581: case 0x11: {
8951 OPC_SwitchField, 0, 6, // 583: switch Inst[5:0] {
8952 16, 7, // 586: case 0x10: {
8953 OPC_CheckPredicate, 82, // 588: check predicate 82
8954 OPC_Decode, 161, 21, 151, 3, // 590: decode to SEL_D using decoder 407
8955 // 590: }
8956 20, 7, // 595: case 0x14: {
8957 OPC_CheckPredicate, 82, // 597: check predicate 82
8958 OPC_Decode, 149, 21, 152, 3, // 599: decode to SELEQZ_D using decoder 408
8959 // 599: }
8960 23, 7, // 604: case 0x17: {
8961 OPC_CheckPredicate, 82, // 606: check predicate 82
8962 OPC_Decode, 156, 21, 152, 3, // 608: decode to SELNEZ_D using decoder 408
8963 // 608: }
8964 24, 7, // 613: case 0x18: {
8965 OPC_CheckPredicate, 82, // 615: check predicate 82
8966 OPC_Decode, 224, 16, 151, 3, // 617: decode to MADDF_D using decoder 407
8967 // 617: }
8968 25, 7, // 622: case 0x19: {
8969 OPC_CheckPredicate, 82, // 624: check predicate 82
8970 OPC_Decode, 158, 18, 151, 3, // 626: decode to MSUBF_D using decoder 407
8971 // 626: }
8972 26, 11, // 631: case 0x1a: {
8973 OPC_CheckPredicate, 82, // 633: check predicate 82
8974 OPC_CheckField, 16, 5, 0, // 635: check Inst[20:16] == 0x0
8975 OPC_Decode, 176, 20, 143, 2, // 639: decode to RINT_D using decoder 271
8976 // 639: }
8977 27, 11, // 644: case 0x1b: {
8978 OPC_CheckPredicate, 82, // 646: check predicate 82
8979 OPC_CheckField, 16, 5, 0, // 648: check Inst[20:16] == 0x0
8980 OPC_Decode, 182, 9, 143, 2, // 652: decode to CLASS_D using decoder 271
8981 // 652: }
8982 28, 7, // 657: case 0x1c: {
8983 OPC_CheckPredicate, 82, // 659: check predicate 82
8984 OPC_Decode, 206, 17, 152, 3, // 661: decode to MIN_D using decoder 408
8985 // 661: }
8986 29, 7, // 666: case 0x1d: {
8987 OPC_CheckPredicate, 82, // 668: check predicate 82
8988 OPC_Decode, 190, 17, 152, 3, // 670: decode to MINA_D using decoder 408
8989 // 670: }
8990 30, 7, // 675: case 0x1e: {
8991 OPC_CheckPredicate, 82, // 677: check predicate 82
8992 OPC_Decode, 144, 17, 152, 3, // 679: decode to MAX_D using decoder 408
8993 // 679: }
8994 31, 0, // 684: case 0x1f: {
8995 OPC_CheckPredicate, 82, // 686: check predicate 82
8996 OPC_Decode, 128, 17, 152, 3, // 688: decode to MAXA_D using decoder 408
8997 // 688: }
8998 // 688: } // switch Inst[5:0]
8999 // 688: }
9000 20, 147, 1, // 693: case 0x14: {
9001 OPC_SwitchField, 0, 6, // 696: switch Inst[5:0] {
9002 0, 7, // 699: case 0x0: {
9003 OPC_CheckPredicate, 82, // 701: check predicate 82
9004 OPC_Decode, 255, 9, 131, 2, // 703: decode to CMP_F_S using decoder 259
9005 // 703: }
9006 1, 7, // 708: case 0x1: {
9007 OPC_CheckPredicate, 82, // 710: check predicate 82
9008 OPC_Decode, 186, 10, 131, 2, // 712: decode to CMP_UN_S using decoder 259
9009 // 712: }
9010 2, 7, // 717: case 0x2: {
9011 OPC_CheckPredicate, 82, // 719: check predicate 82
9012 OPC_Decode, 252, 9, 131, 2, // 721: decode to CMP_EQ_S using decoder 259
9013 // 721: }
9014 3, 7, // 726: case 0x3: {
9015 OPC_CheckPredicate, 82, // 728: check predicate 82
9016 OPC_Decode, 174, 10, 131, 2, // 730: decode to CMP_UEQ_S using decoder 259
9017 // 730: }
9018 4, 7, // 735: case 0x4: {
9019 OPC_CheckPredicate, 82, // 737: check predicate 82
9020 OPC_Decode, 138, 10, 131, 2, // 739: decode to CMP_LT_S using decoder 259
9021 // 739: }
9022 5, 7, // 744: case 0x5: {
9023 OPC_CheckPredicate, 82, // 746: check predicate 82
9024 OPC_Decode, 182, 10, 131, 2, // 748: decode to CMP_ULT_S using decoder 259
9025 // 748: }
9026 6, 7, // 753: case 0x6: {
9027 OPC_CheckPredicate, 82, // 755: check predicate 82
9028 OPC_Decode, 132, 10, 131, 2, // 757: decode to CMP_LE_S using decoder 259
9029 // 757: }
9030 7, 7, // 762: case 0x7: {
9031 OPC_CheckPredicate, 82, // 764: check predicate 82
9032 OPC_Decode, 178, 10, 131, 2, // 766: decode to CMP_ULE_S using decoder 259
9033 // 766: }
9034 8, 7, // 771: case 0x8: {
9035 OPC_CheckPredicate, 82, // 773: check predicate 82
9036 OPC_Decode, 142, 10, 131, 2, // 775: decode to CMP_SAF_S using decoder 259
9037 // 775: }
9038 9, 7, // 780: case 0x9: {
9039 OPC_CheckPredicate, 82, // 782: check predicate 82
9040 OPC_Decode, 170, 10, 131, 2, // 784: decode to CMP_SUN_S using decoder 259
9041 // 784: }
9042 10, 7, // 789: case 0xa: {
9043 OPC_CheckPredicate, 82, // 791: check predicate 82
9044 OPC_Decode, 146, 10, 131, 2, // 793: decode to CMP_SEQ_S using decoder 259
9045 // 793: }
9046 11, 7, // 798: case 0xb: {
9047 OPC_CheckPredicate, 82, // 800: check predicate 82
9048 OPC_Decode, 158, 10, 131, 2, // 802: decode to CMP_SUEQ_S using decoder 259
9049 // 802: }
9050 12, 7, // 807: case 0xc: {
9051 OPC_CheckPredicate, 82, // 809: check predicate 82
9052 OPC_Decode, 154, 10, 131, 2, // 811: decode to CMP_SLT_S using decoder 259
9053 // 811: }
9054 13, 7, // 816: case 0xd: {
9055 OPC_CheckPredicate, 82, // 818: check predicate 82
9056 OPC_Decode, 166, 10, 131, 2, // 820: decode to CMP_SULT_S using decoder 259
9057 // 820: }
9058 14, 7, // 825: case 0xe: {
9059 OPC_CheckPredicate, 82, // 827: check predicate 82
9060 OPC_Decode, 150, 10, 131, 2, // 829: decode to CMP_SLE_S using decoder 259
9061 // 829: }
9062 15, 0, // 834: case 0xf: {
9063 OPC_CheckPredicate, 82, // 836: check predicate 82
9064 OPC_Decode, 162, 10, 131, 2, // 838: decode to CMP_SULE_S using decoder 259
9065 // 838: }
9066 // 838: } // switch Inst[5:0]
9067 // 838: }
9068 21, 0, // 843: case 0x15: {
9069 OPC_SwitchField, 0, 6, // 845: switch Inst[5:0] {
9070 0, 7, // 848: case 0x0: {
9071 OPC_CheckPredicate, 82, // 850: check predicate 82
9072 OPC_Decode, 254, 9, 152, 3, // 852: decode to CMP_F_D using decoder 408
9073 // 852: }
9074 1, 7, // 857: case 0x1: {
9075 OPC_CheckPredicate, 82, // 859: check predicate 82
9076 OPC_Decode, 184, 10, 152, 3, // 861: decode to CMP_UN_D using decoder 408
9077 // 861: }
9078 2, 7, // 866: case 0x2: {
9079 OPC_CheckPredicate, 82, // 868: check predicate 82
9080 OPC_Decode, 248, 9, 152, 3, // 870: decode to CMP_EQ_D using decoder 408
9081 // 870: }
9082 3, 7, // 875: case 0x3: {
9083 OPC_CheckPredicate, 82, // 877: check predicate 82
9084 OPC_Decode, 172, 10, 152, 3, // 879: decode to CMP_UEQ_D using decoder 408
9085 // 879: }
9086 4, 7, // 884: case 0x4: {
9087 OPC_CheckPredicate, 82, // 886: check predicate 82
9088 OPC_Decode, 134, 10, 152, 3, // 888: decode to CMP_LT_D using decoder 408
9089 // 888: }
9090 5, 7, // 893: case 0x5: {
9091 OPC_CheckPredicate, 82, // 895: check predicate 82
9092 OPC_Decode, 180, 10, 152, 3, // 897: decode to CMP_ULT_D using decoder 408
9093 // 897: }
9094 6, 7, // 902: case 0x6: {
9095 OPC_CheckPredicate, 82, // 904: check predicate 82
9096 OPC_Decode, 128, 10, 152, 3, // 906: decode to CMP_LE_D using decoder 408
9097 // 906: }
9098 7, 7, // 911: case 0x7: {
9099 OPC_CheckPredicate, 82, // 913: check predicate 82
9100 OPC_Decode, 176, 10, 152, 3, // 915: decode to CMP_ULE_D using decoder 408
9101 // 915: }
9102 8, 7, // 920: case 0x8: {
9103 OPC_CheckPredicate, 82, // 922: check predicate 82
9104 OPC_Decode, 140, 10, 152, 3, // 924: decode to CMP_SAF_D using decoder 408
9105 // 924: }
9106 9, 7, // 929: case 0x9: {
9107 OPC_CheckPredicate, 82, // 931: check predicate 82
9108 OPC_Decode, 168, 10, 152, 3, // 933: decode to CMP_SUN_D using decoder 408
9109 // 933: }
9110 10, 7, // 938: case 0xa: {
9111 OPC_CheckPredicate, 82, // 940: check predicate 82
9112 OPC_Decode, 144, 10, 152, 3, // 942: decode to CMP_SEQ_D using decoder 408
9113 // 942: }
9114 11, 7, // 947: case 0xb: {
9115 OPC_CheckPredicate, 82, // 949: check predicate 82
9116 OPC_Decode, 156, 10, 152, 3, // 951: decode to CMP_SUEQ_D using decoder 408
9117 // 951: }
9118 12, 7, // 956: case 0xc: {
9119 OPC_CheckPredicate, 82, // 958: check predicate 82
9120 OPC_Decode, 152, 10, 152, 3, // 960: decode to CMP_SLT_D using decoder 408
9121 // 960: }
9122 13, 7, // 965: case 0xd: {
9123 OPC_CheckPredicate, 82, // 967: check predicate 82
9124 OPC_Decode, 164, 10, 152, 3, // 969: decode to CMP_SULT_D using decoder 408
9125 // 969: }
9126 14, 7, // 974: case 0xe: {
9127 OPC_CheckPredicate, 82, // 976: check predicate 82
9128 OPC_Decode, 148, 10, 152, 3, // 978: decode to CMP_SLE_D using decoder 408
9129 // 978: }
9130 15, 0, // 983: case 0xf: {
9131 OPC_CheckPredicate, 82, // 985: check predicate 82
9132 OPC_Decode, 160, 10, 152, 3, // 987: decode to CMP_SULE_D using decoder 408
9133 // 987: }
9134 // 987: } // switch Inst[5:0]
9135 // 987: }
9136 // 987: } // switch Inst[25:21]
9137 // 987: }
9138 18, 57, // 992: case 0x12: {
9139 OPC_SwitchField, 21, 5, // 994: switch Inst[25:21] {
9140 9, 7, // 997: case 0x9: {
9141 OPC_CheckPredicate, 79, // 999: check predicate 79
9142 OPC_Decode, 210, 7, 153, 3, // 1001: decode to BC2EQZ using decoder 409
9143 // 1001: }
9144 10, 7, // 1006: case 0xa: {
9145 OPC_CheckPredicate, 79, // 1008: check predicate 79
9146 OPC_Decode, 168, 16, 154, 3, // 1010: decode to LWC2_R6 using decoder 410
9147 // 1010: }
9148 11, 7, // 1015: case 0xb: {
9149 OPC_CheckPredicate, 79, // 1017: check predicate 79
9150 OPC_Decode, 163, 23, 154, 3, // 1019: decode to SWC2_R6 using decoder 410
9151 // 1019: }
9152 13, 7, // 1024: case 0xd: {
9153 OPC_CheckPredicate, 79, // 1026: check predicate 79
9154 OPC_Decode, 212, 7, 153, 3, // 1028: decode to BC2NEZ using decoder 409
9155 // 1028: }
9156 14, 7, // 1033: case 0xe: {
9157 OPC_CheckPredicate, 79, // 1035: check predicate 79
9158 OPC_Decode, 216, 15, 154, 3, // 1037: decode to LDC2_R6 using decoder 410
9159 // 1037: }
9160 15, 0, // 1042: case 0xf: {
9161 OPC_CheckPredicate, 79, // 1044: check predicate 79
9162 OPC_Decode, 131, 21, 154, 3, // 1046: decode to SDC2_R6 using decoder 410
9163 // 1046: }
9164 // 1046: } // switch Inst[25:21]
9165 // 1046: }
9166 22, 7, // 1051: case 0x16: {
9167 OPC_CheckPredicate, 79, // 1053: check predicate 79
9168 OPC_Decode, 132, 8, 155, 3, // 1055: decode to BGEZC using decoder 411
9169 // 1055: }
9170 23, 7, // 1060: case 0x17: {
9171 OPC_CheckPredicate, 79, // 1062: check predicate 79
9172 OPC_Decode, 194, 8, 156, 3, // 1064: decode to BLTZC using decoder 412
9173 // 1064: }
9174 24, 7, // 1069: case 0x18: {
9175 OPC_CheckPredicate, 79, // 1071: check predicate 79
9176 OPC_Decode, 205, 8, 157, 3, // 1073: decode to BNEC using decoder 413
9177 // 1073: }
9178 29, 7, // 1078: case 0x1d: {
9179 OPC_CheckPredicate, 80, // 1080: check predicate 80
9180 OPC_Decode, 228, 11, 158, 3, // 1082: decode to DAUI using decoder 414
9181 // 1082: }
9182 31, 235, 1, // 1087: case 0x1f: {
9183 OPC_SwitchField, 0, 6, // 1090: switch Inst[5:0] {
9184 15, 75, // 1093: case 0xf: {
9185 OPC_SwitchField, 6, 10, // 1095: switch Inst[15:6] {
9186 0, 7, // 1098: case 0x0: {
9187 OPC_CheckPredicate, 83, // 1100: check predicate 83
9188 OPC_Decode, 195, 10, 159, 3, // 1102: decode to CRC32B using decoder 415
9189 // 1102: }
9190 1, 7, // 1107: case 0x1: {
9191 OPC_CheckPredicate, 83, // 1109: check predicate 83
9192 OPC_Decode, 205, 10, 159, 3, // 1111: decode to CRC32H using decoder 415
9193 // 1111: }
9194 2, 7, // 1116: case 0x2: {
9195 OPC_CheckPredicate, 83, // 1118: check predicate 83
9196 OPC_Decode, 207, 10, 159, 3, // 1120: decode to CRC32W using decoder 415
9197 // 1120: }
9198 3, 7, // 1125: case 0x3: {
9199 OPC_CheckPredicate, 84, // 1127: check predicate 84
9200 OPC_Decode, 204, 10, 159, 3, // 1129: decode to CRC32D using decoder 415
9201 // 1129: }
9202 4, 7, // 1134: case 0x4: {
9203 OPC_CheckPredicate, 83, // 1136: check predicate 83
9204 OPC_Decode, 197, 10, 159, 3, // 1138: decode to CRC32CB using decoder 415
9205 // 1138: }
9206 5, 7, // 1143: case 0x5: {
9207 OPC_CheckPredicate, 83, // 1145: check predicate 83
9208 OPC_Decode, 200, 10, 159, 3, // 1147: decode to CRC32CH using decoder 415
9209 // 1147: }
9210 6, 7, // 1152: case 0x6: {
9211 OPC_CheckPredicate, 83, // 1154: check predicate 83
9212 OPC_Decode, 202, 10, 159, 3, // 1156: decode to CRC32CW using decoder 415
9213 // 1156: }
9214 7, 0, // 1161: case 0x7: {
9215 OPC_CheckPredicate, 84, // 1163: check predicate 84
9216 OPC_Decode, 199, 10, 159, 3, // 1165: decode to CRC32CD using decoder 415
9217 // 1165: }
9218 // 1165: } // switch Inst[15:6]
9219 // 1165: }
9220 32, 29, // 1170: case 0x20: {
9221 OPC_SwitchField, 8, 3, // 1172: switch Inst[10:8] {
9222 0, 15, // 1175: case 0x0: {
9223 OPC_CheckPredicate, 78, // 1177: check predicate 78
9224 OPC_CheckField, 21, 5, 0, // 1179: check Inst[25:21] == 0x0
9225 OPC_CheckField, 6, 2, 0, // 1183: check Inst[7:6] == 0x0
9226 OPC_Decode, 165, 8, 248, 2, // 1187: decode to BITSWAP using decoder 376
9227 // 1187: }
9228 2, 0, // 1192: case 0x2: {
9229 OPC_CheckPredicate, 78, // 1194: check predicate 78
9230 OPC_Decode, 247, 6, 160, 3, // 1196: decode to ALIGN using decoder 416
9231 // 1196: }
9232 // 1196: } // switch Inst[10:8]
9233 // 1196: }
9234 36, 29, // 1201: case 0x24: {
9235 OPC_SwitchField, 9, 2, // 1203: switch Inst[10:9] {
9236 0, 15, // 1206: case 0x0: {
9237 OPC_CheckPredicate, 80, // 1208: check predicate 80
9238 OPC_CheckField, 21, 5, 0, // 1210: check Inst[25:21] == 0x0
9239 OPC_CheckField, 6, 3, 0, // 1214: check Inst[8:6] == 0x0
9240 OPC_Decode, 229, 11, 161, 3, // 1218: decode to DBITSWAP using decoder 417
9241 // 1218: }
9242 1, 0, // 1223: case 0x1: {
9243 OPC_CheckPredicate, 80, // 1225: check predicate 80
9244 OPC_Decode, 226, 11, 162, 3, // 1227: decode to DALIGN using decoder 418
9245 // 1227: }
9246 // 1227: } // switch Inst[10:9]
9247 // 1227: }
9248 37, 11, // 1232: case 0x25: {
9249 OPC_CheckPredicate, 79, // 1234: check predicate 79
9250 OPC_CheckField, 6, 1, 0, // 1236: check Inst[6] == 0x0
9251 OPC_Decode, 154, 9, 253, 2, // 1240: decode to CACHE_R6 using decoder 381
9252 // 1240: }
9253 38, 7, // 1245: case 0x26: {
9254 OPC_CheckPredicate, 85, // 1247: check predicate 85
9255 OPC_Decode, 242, 20, 255, 2, // 1249: decode to SC_R6 using decoder 383
9256 // 1249: }
9257 39, 7, // 1254: case 0x27: {
9258 OPC_CheckPredicate, 78, // 1256: check predicate 78
9259 OPC_Decode, 235, 20, 163, 3, // 1258: decode to SCD_R6 using decoder 419
9260 // 1258: }
9261 53, 11, // 1263: case 0x35: {
9262 OPC_CheckPredicate, 79, // 1265: check predicate 79
9263 OPC_CheckField, 6, 1, 0, // 1267: check Inst[6] == 0x0
9264 OPC_Decode, 142, 20, 253, 2, // 1271: decode to PREF_R6 using decoder 381
9265 // 1271: }
9266 54, 7, // 1276: case 0x36: {
9267 OPC_CheckPredicate, 85, // 1278: check predicate 85
9268 OPC_Decode, 146, 16, 254, 2, // 1280: decode to LL_R6 using decoder 382
9269 // 1280: }
9270 55, 7, // 1285: case 0x37: {
9271 OPC_CheckPredicate, 80, // 1287: check predicate 80
9272 OPC_Decode, 139, 16, 164, 3, // 1289: decode to LLD_R6 using decoder 420
9273 // 1289: }
9274 61, 0, // 1294: case 0x3d: {
9275 OPC_SwitchField, 6, 2, // 1296: switch Inst[7:6] {
9276 0, 11, // 1299: case 0x0: {
9277 OPC_CheckPredicate, 86, // 1301: check predicate 86
9278 OPC_CheckField, 8, 13, 0, // 1303: check Inst[20:8] == 0x0
9279 OPC_Decode, 211, 14, 227, 1, // 1307: decode to GINVI using decoder 227
9280 // 1307: }
9281 2, 0, // 1312: case 0x2: {
9282 OPC_CheckPredicate, 86, // 1314: check predicate 86
9283 OPC_CheckField, 10, 11, 0, // 1316: check Inst[20:10] == 0x0
9284 OPC_Decode, 214, 14, 165, 3, // 1320: decode to GINVT using decoder 421
9285 // 1320: }
9286 // 1320: } // switch Inst[7:6]
9287 // 1320: }
9288 // 1320: } // switch Inst[5:0]
9289 // 1320: }
9290 50, 7, // 1325: case 0x32: {
9291 OPC_CheckPredicate, 79, // 1327: check predicate 79
9292 OPC_Decode, 197, 7, 166, 3, // 1329: decode to BC using decoder 422
9293 // 1329: }
9294 53, 20, // 1334: case 0x35: {
9295 OPC_Scope, 11, // 1336: try {
9296 OPC_CheckField, 16, 5, 0, // 1338: check Inst[20:16] == 0x0
9297 OPC_CheckPredicate, 3, // 1342: check predicate 3
9298 OPC_Decode, 143, 8, 221, 1, // 1344: decode to BGTZC_MMR6 using decoder 221
9299 // 1344: } else try {
9300 OPC_CheckPredicate, 3, // 1349: check predicate 3
9301 OPC_Decode, 196, 8, 221, 1, // 1351: decode to BLTZC_MMR6 using decoder 221
9302 // 1351: }
9303 // 1351: }
9304 54, 20, // 1356: case 0x36: {
9305 OPC_Scope, 11, // 1358: try {
9306 OPC_CheckField, 21, 5, 0, // 1360: check Inst[25:21] == 0x0
9307 OPC_CheckPredicate, 78, // 1364: check predicate 78
9308 OPC_Decode, 157, 15, 148, 1, // 1366: decode to JIC using decoder 148
9309 // 1366: } else try {
9310 OPC_CheckPredicate, 79, // 1371: check predicate 79
9311 OPC_Decode, 235, 7, 167, 3, // 1373: decode to BEQZC using decoder 423
9312 // 1373: }
9313 // 1373: }
9314 58, 7, // 1378: case 0x3a: {
9315 OPC_CheckPredicate, 78, // 1380: check predicate 78
9316 OPC_Decode, 184, 7, 166, 3, // 1382: decode to BALC using decoder 422
9317 // 1382: }
9318 59, 67, // 1387: case 0x3b: {
9319 OPC_SwitchField, 19, 2, // 1389: switch Inst[20:19] {
9320 0, 7, // 1392: case 0x0: {
9321 OPC_CheckPredicate, 78, // 1394: check predicate 78
9322 OPC_Decode, 163, 6, 215, 1, // 1396: decode to ADDIUPC using decoder 215
9323 // 1396: }
9324 1, 7, // 1401: case 0x1: {
9325 OPC_CheckPredicate, 78, // 1403: check predicate 78
9326 OPC_Decode, 186, 16, 215, 1, // 1405: decode to LWPC using decoder 215
9327 // 1405: }
9328 2, 7, // 1410: case 0x2: {
9329 OPC_CheckPredicate, 87, // 1412: check predicate 87
9330 OPC_Decode, 197, 16, 215, 1, // 1414: decode to LWUPC using decoder 215
9331 // 1414: }
9332 3, 0, // 1419: case 0x3: {
9333 OPC_SwitchField, 18, 1, // 1421: switch Inst[18] {
9334 0, 7, // 1424: case 0x0: {
9335 OPC_CheckPredicate, 87, // 1426: check predicate 87
9336 OPC_Decode, 223, 15, 168, 3, // 1428: decode to LDPC using decoder 424
9337 // 1428: }
9338 1, 0, // 1433: case 0x1: {
9339 OPC_SwitchField, 16, 2, // 1435: switch Inst[17:16] {
9340 2, 7, // 1438: case 0x2: {
9341 OPC_CheckPredicate, 78, // 1440: check predicate 78
9342 OPC_Decode, 153, 7, 216, 1, // 1442: decode to AUIPC using decoder 216
9343 // 1442: }
9344 3, 0, // 1447: case 0x3: {
9345 OPC_CheckPredicate, 78, // 1449: check predicate 78
9346 OPC_Decode, 249, 6, 216, 1, // 1451: decode to ALUIPC using decoder 216
9347 // 1451: }
9348 // 1451: } // switch Inst[17:16]
9349 // 1451: }
9350 // 1451: } // switch Inst[18]
9351 // 1451: }
9352 // 1451: } // switch Inst[20:19]
9353 // 1451: }
9354 61, 20, // 1456: case 0x3d: {
9355 OPC_Scope, 11, // 1458: try {
9356 OPC_CheckField, 16, 5, 0, // 1460: check Inst[20:16] == 0x0
9357 OPC_CheckPredicate, 3, // 1464: check predicate 3
9358 OPC_Decode, 173, 8, 223, 1, // 1466: decode to BLEZC_MMR6 using decoder 223
9359 // 1466: } else try {
9360 OPC_CheckPredicate, 3, // 1471: check predicate 3
9361 OPC_Decode, 134, 8, 223, 1, // 1473: decode to BGEZC_MMR6 using decoder 223
9362 // 1473: }
9363 // 1473: }
9364 62, 0, // 1478: case 0x3e: {
9365 OPC_Scope, 11, // 1480: try {
9366 OPC_CheckField, 21, 5, 0, // 1482: check Inst[25:21] == 0x0
9367 OPC_CheckPredicate, 78, // 1486: check predicate 78
9368 OPC_Decode, 154, 15, 148, 1, // 1488: decode to JIALC using decoder 148
9369 // 1488: } else try {
9370 OPC_CheckPredicate, 79, // 1493: check predicate 79
9371 OPC_Decode, 222, 8, 167, 3, // 1495: decode to BNEZC using decoder 423
9372 // 1495: }
9373 // 1495: }
9374 // 1495: } // switch Inst[31:26]
9375};
9376static const uint8_t DecoderTableMips32r6_64r6_Ambiguous32[135] = {
9377 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9378 6, 20, // 3: case 0x6: {
9379 OPC_Scope, 11, // 5: try {
9380 OPC_CheckField, 21, 5, 0, // 7: check Inst[25:21] == 0x0
9381 OPC_CheckPredicate, 79, // 11: check predicate 79
9382 OPC_Decode, 169, 8, 146, 3, // 13: decode to BLEZALC using decoder 402
9383 // 13: } else try {
9384 OPC_CheckPredicate, 79, // 18: check predicate 79
9385 OPC_Decode, 248, 7, 146, 3, // 20: decode to BGEUC using decoder 402
9386 // 20: }
9387 // 20: }
9388 7, 20, // 25: case 0x7: {
9389 OPC_Scope, 11, // 27: try {
9390 OPC_CheckField, 21, 5, 0, // 29: check Inst[25:21] == 0x0
9391 OPC_CheckPredicate, 79, // 33: check predicate 79
9392 OPC_Decode, 139, 8, 147, 3, // 35: decode to BGTZALC using decoder 403
9393 // 35: } else try {
9394 OPC_CheckPredicate, 79, // 40: check predicate 79
9395 OPC_Decode, 182, 8, 147, 3, // 42: decode to BLTUC using decoder 403
9396 // 42: }
9397 // 42: }
9398 8, 20, // 47: case 0x8: {
9399 OPC_Scope, 11, // 49: try {
9400 OPC_CheckField, 21, 5, 0, // 51: check Inst[25:21] == 0x0
9401 OPC_CheckPredicate, 79, // 55: check predicate 79
9402 OPC_Decode, 233, 7, 157, 3, // 57: decode to BEQZALC using decoder 413
9403 // 57: } else try {
9404 OPC_CheckPredicate, 79, // 62: check predicate 79
9405 OPC_Decode, 236, 8, 148, 3, // 64: decode to BOVC using decoder 404
9406 // 64: }
9407 // 64: }
9408 22, 20, // 69: case 0x16: {
9409 OPC_Scope, 11, // 71: try {
9410 OPC_CheckField, 21, 5, 0, // 73: check Inst[25:21] == 0x0
9411 OPC_CheckPredicate, 79, // 77: check predicate 79
9412 OPC_Decode, 171, 8, 155, 3, // 79: decode to BLEZC using decoder 411
9413 // 79: } else try {
9414 OPC_CheckPredicate, 79, // 84: check predicate 79
9415 OPC_Decode, 242, 7, 155, 3, // 86: decode to BGEC using decoder 411
9416 // 86: }
9417 // 86: }
9418 23, 20, // 91: case 0x17: {
9419 OPC_Scope, 11, // 93: try {
9420 OPC_CheckField, 21, 5, 0, // 95: check Inst[25:21] == 0x0
9421 OPC_CheckPredicate, 79, // 99: check predicate 79
9422 OPC_Decode, 141, 8, 156, 3, // 101: decode to BGTZC using decoder 412
9423 // 101: } else try {
9424 OPC_CheckPredicate, 79, // 106: check predicate 79
9425 OPC_Decode, 176, 8, 156, 3, // 108: decode to BLTC using decoder 412
9426 // 108: }
9427 // 108: }
9428 24, 0, // 113: case 0x18: {
9429 OPC_Scope, 11, // 115: try {
9430 OPC_CheckField, 21, 5, 0, // 117: check Inst[25:21] == 0x0
9431 OPC_CheckPredicate, 79, // 121: check predicate 79
9432 OPC_Decode, 220, 8, 157, 3, // 123: decode to BNEZALC using decoder 413
9433 // 123: } else try {
9434 OPC_CheckPredicate, 79, // 128: check predicate 79
9435 OPC_Decode, 229, 8, 157, 3, // 130: decode to BNVC using decoder 413
9436 // 130: }
9437 // 130: }
9438 // 130: } // switch Inst[31:26]
9439};
9440static const uint8_t DecoderTableMips32r6_64r6_BranchZero32[21] = {
9441 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9442 22, 7, // 3: case 0x16: {
9443 OPC_CheckPredicate, 88, // 5: check predicate 88
9444 OPC_Decode, 133, 8, 155, 3, // 7: decode to BGEZC64 using decoder 411
9445 // 7: }
9446 23, 0, // 12: case 0x17: {
9447 OPC_CheckPredicate, 88, // 14: check predicate 88
9448 OPC_Decode, 195, 8, 156, 3, // 16: decode to BLTZC64 using decoder 412
9449 // 16: }
9450 // 16: } // switch Inst[31:26]
9451};
9452static const uint8_t DecoderTableMips32r6_64r6_GP6432[159] = {
9453 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9454 0, 32, // 3: case 0x0: {
9455 OPC_SwitchField, 0, 11, // 5: switch Inst[10:0] {
9456 53, 6, // 8: case 0x35: {
9457 OPC_CheckPredicate, 89, // 10: check predicate 89
9458 OPC_Decode, 148, 21, 87, // 12: decode to SELEQZ64 using decoder 87
9459 // 12: }
9460 55, 6, // 16: case 0x37: {
9461 OPC_CheckPredicate, 89, // 18: check predicate 89
9462 OPC_Decode, 155, 21, 87, // 20: decode to SELNEZ64 using decoder 87
9463 // 20: }
9464 137, 8, 0, // 24: case 0x409: {
9465 OPC_CheckPredicate, 78, // 27: check predicate 78
9466 OPC_CheckField, 11, 10, 0, // 29: check Inst[20:11] == 0x0
9467 OPC_Decode, 170, 15, 88, // 33: decode to JR_HB64_R6 using decoder 88
9468 // 33: }
9469 // 33: } // switch Inst[10:0]
9470 // 33: }
9471 6, 7, // 37: case 0x6: {
9472 OPC_CheckPredicate, 88, // 39: check predicate 88
9473 OPC_Decode, 249, 7, 146, 3, // 41: decode to BGEUC64 using decoder 402
9474 // 41: }
9475 7, 7, // 46: case 0x7: {
9476 OPC_CheckPredicate, 88, // 48: check predicate 88
9477 OPC_Decode, 183, 8, 147, 3, // 50: decode to BLTUC64 using decoder 403
9478 // 50: }
9479 8, 7, // 55: case 0x8: {
9480 OPC_CheckPredicate, 88, // 57: check predicate 88
9481 OPC_Decode, 227, 7, 148, 3, // 59: decode to BEQC64 using decoder 404
9482 // 59: }
9483 22, 20, // 64: case 0x16: {
9484 OPC_Scope, 11, // 66: try {
9485 OPC_CheckField, 21, 5, 0, // 68: check Inst[25:21] == 0x0
9486 OPC_CheckPredicate, 88, // 72: check predicate 88
9487 OPC_Decode, 172, 8, 155, 3, // 74: decode to BLEZC64 using decoder 411
9488 // 74: } else try {
9489 OPC_CheckPredicate, 88, // 79: check predicate 88
9490 OPC_Decode, 243, 7, 155, 3, // 81: decode to BGEC64 using decoder 411
9491 // 81: }
9492 // 81: }
9493 23, 20, // 86: case 0x17: {
9494 OPC_Scope, 11, // 88: try {
9495 OPC_CheckField, 21, 5, 0, // 90: check Inst[25:21] == 0x0
9496 OPC_CheckPredicate, 88, // 94: check predicate 88
9497 OPC_Decode, 142, 8, 156, 3, // 96: decode to BGTZC64 using decoder 412
9498 // 96: } else try {
9499 OPC_CheckPredicate, 88, // 101: check predicate 88
9500 OPC_Decode, 177, 8, 156, 3, // 103: decode to BLTC64 using decoder 412
9501 // 103: }
9502 // 103: }
9503 24, 7, // 108: case 0x18: {
9504 OPC_CheckPredicate, 88, // 110: check predicate 88
9505 OPC_Decode, 206, 8, 157, 3, // 112: decode to BNEC64 using decoder 413
9506 // 112: }
9507 54, 19, // 117: case 0x36: {
9508 OPC_Scope, 10, // 119: try {
9509 OPC_CheckField, 21, 5, 0, // 121: check Inst[25:21] == 0x0
9510 OPC_CheckPredicate, 88, // 125: check predicate 88
9511 OPC_Decode, 158, 15, 86, // 127: decode to JIC64 using decoder 86
9512 // 127: } else try {
9513 OPC_CheckPredicate, 88, // 131: check predicate 88
9514 OPC_Decode, 238, 7, 169, 3, // 133: decode to BEQZC64 using decoder 425
9515 // 133: }
9516 // 133: }
9517 62, 0, // 138: case 0x3e: {
9518 OPC_Scope, 10, // 140: try {
9519 OPC_CheckField, 21, 5, 0, // 142: check Inst[25:21] == 0x0
9520 OPC_CheckPredicate, 88, // 146: check predicate 88
9521 OPC_Decode, 155, 15, 86, // 148: decode to JIALC64 using decoder 86
9522 // 148: } else try {
9523 OPC_CheckPredicate, 88, // 152: check predicate 88
9524 OPC_Decode, 225, 8, 169, 3, // 154: decode to BNEZC64 using decoder 425
9525 // 154: }
9526 // 154: }
9527 // 154: } // switch Inst[31:26]
9528};
9529static const uint8_t DecoderTableMips32r6_64r6_PTR6432[29] = {
9530 OPC_SwitchField, 0, 6, // 0: switch Inst[5:0] {
9531 38, 11, // 3: case 0x26: {
9532 OPC_CheckPredicate, 90, // 5: check predicate 90
9533 OPC_CheckField, 26, 6, 31, // 7: check Inst[31:26] == 0x1f
9534 OPC_Decode, 233, 20, 255, 2, // 11: decode to SC64_R6 using decoder 383
9535 // 11: }
9536 54, 0, // 16: case 0x36: {
9537 OPC_CheckPredicate, 90, // 18: check predicate 90
9538 OPC_CheckField, 26, 6, 31, // 20: check Inst[31:26] == 0x1f
9539 OPC_Decode, 137, 16, 254, 2, // 24: decode to LL64_R6 using decoder 382
9540 // 24: }
9541 // 24: } // switch Inst[5:0]
9542};
9543static const uint8_t DecoderTableMips6432[778] = {
9544 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9545 0, 163, 2, // 3: case 0x0: {
9546 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
9547 8, 10, // 9: case 0x8: {
9548 OPC_CheckPredicate, 91, // 11: check predicate 91
9549 OPC_CheckField, 6, 15, 16, // 13: check Inst[20:6] == 0x10
9550 OPC_Decode, 169, 15, 88, // 17: decode to JR_HB64 using decoder 88
9551 // 17: }
9552 9, 27, // 21: case 0x9: {
9553 OPC_SwitchField, 6, 5, // 23: switch Inst[10:6] {
9554 0, 10, // 26: case 0x0: {
9555 OPC_CheckPredicate, 92, // 28: check predicate 92
9556 OPC_CheckField, 16, 5, 0, // 30: check Inst[20:16] == 0x0
9557 OPC_Decode, 137, 15, 90, // 34: decode to JALR64 using decoder 90
9558 // 34: }
9559 16, 0, // 38: case 0x10: {
9560 OPC_CheckPredicate, 93, // 40: check predicate 93
9561 OPC_CheckField, 16, 5, 0, // 42: check Inst[20:16] == 0x0
9562 OPC_Decode, 147, 15, 90, // 46: decode to JALR_HB64 using decoder 90
9563 // 46: }
9564 // 46: } // switch Inst[10:6]
9565 // 46: }
9566 20, 11, // 50: case 0x14: {
9567 OPC_CheckPredicate, 94, // 52: check predicate 94
9568 OPC_CheckField, 6, 5, 0, // 54: check Inst[10:6] == 0x0
9569 OPC_Decode, 219, 12, 170, 3, // 58: decode to DSLLV using decoder 426
9570 // 58: }
9571 22, 21, // 63: case 0x16: {
9572 OPC_SwitchField, 6, 5, // 65: switch Inst[10:6] {
9573 0, 7, // 68: case 0x0: {
9574 OPC_CheckPredicate, 94, // 70: check predicate 94
9575 OPC_Decode, 225, 12, 170, 3, // 72: decode to DSRLV using decoder 426
9576 // 72: }
9577 1, 0, // 77: case 0x1: {
9578 OPC_CheckPredicate, 93, // 79: check predicate 93
9579 OPC_Decode, 212, 12, 170, 3, // 81: decode to DROTRV using decoder 426
9580 // 81: }
9581 // 81: } // switch Inst[10:6]
9582 // 81: }
9583 23, 11, // 86: case 0x17: {
9584 OPC_CheckPredicate, 94, // 88: check predicate 94
9585 OPC_CheckField, 6, 5, 0, // 90: check Inst[10:6] == 0x0
9586 OPC_Decode, 222, 12, 170, 3, // 94: decode to DSRAV using decoder 426
9587 // 94: }
9588 28, 11, // 99: case 0x1c: {
9589 OPC_CheckPredicate, 95, // 101: check predicate 95
9590 OPC_CheckField, 6, 10, 0, // 103: check Inst[15:6] == 0x0
9591 OPC_Decode, 155, 12, 171, 3, // 107: decode to DMULT using decoder 427
9592 // 107: }
9593 29, 11, // 112: case 0x1d: {
9594 OPC_CheckPredicate, 95, // 114: check predicate 95
9595 OPC_CheckField, 6, 10, 0, // 116: check Inst[15:6] == 0x0
9596 OPC_Decode, 156, 12, 171, 3, // 120: decode to DMULTu using decoder 427
9597 // 120: }
9598 30, 11, // 125: case 0x1e: {
9599 OPC_CheckPredicate, 95, // 127: check predicate 95
9600 OPC_CheckField, 6, 10, 0, // 129: check Inst[15:6] == 0x0
9601 OPC_Decode, 214, 12, 171, 3, // 133: decode to DSDIV using decoder 427
9602 // 133: }
9603 31, 11, // 138: case 0x1f: {
9604 OPC_CheckPredicate, 95, // 140: check predicate 95
9605 OPC_CheckField, 6, 10, 0, // 142: check Inst[15:6] == 0x0
9606 OPC_Decode, 228, 12, 171, 3, // 146: decode to DUDIV using decoder 427
9607 // 146: }
9608 44, 10, // 151: case 0x2c: {
9609 OPC_CheckPredicate, 94, // 153: check predicate 94
9610 OPC_CheckField, 6, 5, 0, // 155: check Inst[10:6] == 0x0
9611 OPC_Decode, 221, 11, 87, // 159: decode to DADD using decoder 87
9612 // 159: }
9613 45, 10, // 163: case 0x2d: {
9614 OPC_CheckPredicate, 94, // 165: check predicate 94
9615 OPC_CheckField, 6, 5, 0, // 167: check Inst[10:6] == 0x0
9616 OPC_Decode, 224, 11, 87, // 171: decode to DADDu using decoder 87
9617 // 171: }
9618 46, 10, // 175: case 0x2e: {
9619 OPC_CheckPredicate, 94, // 177: check predicate 94
9620 OPC_CheckField, 6, 5, 0, // 179: check Inst[10:6] == 0x0
9621 OPC_Decode, 226, 12, 87, // 183: decode to DSUB using decoder 87
9622 // 183: }
9623 47, 10, // 187: case 0x2f: {
9624 OPC_CheckPredicate, 94, // 189: check predicate 94
9625 OPC_CheckField, 6, 5, 0, // 191: check Inst[10:6] == 0x0
9626 OPC_Decode, 227, 12, 87, // 195: decode to DSUBu using decoder 87
9627 // 195: }
9628 56, 11, // 199: case 0x38: {
9629 OPC_CheckPredicate, 94, // 201: check predicate 94
9630 OPC_CheckField, 21, 5, 0, // 203: check Inst[25:21] == 0x0
9631 OPC_Decode, 216, 12, 172, 3, // 207: decode to DSLL using decoder 428
9632 // 207: }
9633 58, 21, // 212: case 0x3a: {
9634 OPC_SwitchField, 21, 5, // 214: switch Inst[25:21] {
9635 0, 7, // 217: case 0x0: {
9636 OPC_CheckPredicate, 94, // 219: check predicate 94
9637 OPC_Decode, 223, 12, 172, 3, // 221: decode to DSRL using decoder 428
9638 // 221: }
9639 1, 0, // 226: case 0x1: {
9640 OPC_CheckPredicate, 93, // 228: check predicate 93
9641 OPC_Decode, 210, 12, 172, 3, // 230: decode to DROTR using decoder 428
9642 // 230: }
9643 // 230: } // switch Inst[25:21]
9644 // 230: }
9645 59, 11, // 235: case 0x3b: {
9646 OPC_CheckPredicate, 94, // 237: check predicate 94
9647 OPC_CheckField, 21, 5, 0, // 239: check Inst[25:21] == 0x0
9648 OPC_Decode, 220, 12, 172, 3, // 243: decode to DSRA using decoder 428
9649 // 243: }
9650 60, 11, // 248: case 0x3c: {
9651 OPC_CheckPredicate, 94, // 250: check predicate 94
9652 OPC_CheckField, 21, 5, 0, // 252: check Inst[25:21] == 0x0
9653 OPC_Decode, 217, 12, 172, 3, // 256: decode to DSLL32 using decoder 428
9654 // 256: }
9655 62, 21, // 261: case 0x3e: {
9656 OPC_SwitchField, 21, 5, // 263: switch Inst[25:21] {
9657 0, 7, // 266: case 0x0: {
9658 OPC_CheckPredicate, 94, // 268: check predicate 94
9659 OPC_Decode, 224, 12, 172, 3, // 270: decode to DSRL32 using decoder 428
9660 // 270: }
9661 1, 0, // 275: case 0x1: {
9662 OPC_CheckPredicate, 93, // 277: check predicate 93
9663 OPC_Decode, 211, 12, 172, 3, // 279: decode to DROTR32 using decoder 428
9664 // 279: }
9665 // 279: } // switch Inst[25:21]
9666 // 279: }
9667 63, 0, // 284: case 0x3f: {
9668 OPC_CheckPredicate, 94, // 286: check predicate 94
9669 OPC_CheckField, 21, 5, 0, // 288: check Inst[25:21] == 0x0
9670 OPC_Decode, 221, 12, 172, 3, // 292: decode to DSRA32 using decoder 428
9671 // 292: }
9672 // 292: } // switch Inst[5:0]
9673 // 292: }
9674 16, 52, // 297: case 0x10: {
9675 OPC_SwitchField, 3, 8, // 299: switch Inst[10:3] {
9676 0, 21, // 302: case 0x0: {
9677 OPC_SwitchField, 21, 5, // 304: switch Inst[25:21] {
9678 1, 7, // 307: case 0x1: {
9679 OPC_CheckPredicate, 96, // 309: check predicate 96
9680 OPC_Decode, 139, 12, 173, 3, // 311: decode to DMFC0 using decoder 429
9681 // 311: }
9682 5, 0, // 316: case 0x5: {
9683 OPC_CheckPredicate, 96, // 318: check predicate 96
9684 OPC_Decode, 147, 12, 174, 3, // 320: decode to DMTC0 using decoder 430
9685 // 320: }
9686 // 320: } // switch Inst[25:21]
9687 // 320: }
9688 32, 11, // 325: case 0x20: {
9689 OPC_CheckPredicate, 97, // 327: check predicate 97
9690 OPC_CheckField, 21, 5, 3, // 329: check Inst[25:21] == 0x3
9691 OPC_Decode, 143, 12, 173, 3, // 333: decode to DMFGC0 using decoder 429
9692 // 333: }
9693 96, 0, // 338: case 0x60: {
9694 OPC_CheckPredicate, 97, // 340: check predicate 97
9695 OPC_CheckField, 21, 5, 3, // 342: check Inst[25:21] == 0x3
9696 OPC_Decode, 151, 12, 174, 3, // 346: decode to DMTGC0 using decoder 430
9697 // 346: }
9698 // 346: } // switch Inst[10:3]
9699 // 346: }
9700 18, 29, // 351: case 0x12: {
9701 OPC_SwitchField, 21, 5, // 353: switch Inst[25:21] {
9702 1, 11, // 356: case 0x1: {
9703 OPC_CheckPredicate, 96, // 358: check predicate 96
9704 OPC_CheckField, 3, 8, 0, // 360: check Inst[10:3] == 0x0
9705 OPC_Decode, 141, 12, 175, 3, // 364: decode to DMFC2 using decoder 431
9706 // 364: }
9707 5, 0, // 369: case 0x5: {
9708 OPC_CheckPredicate, 96, // 371: check predicate 96
9709 OPC_CheckField, 3, 8, 0, // 373: check Inst[10:3] == 0x0
9710 OPC_Decode, 149, 12, 176, 3, // 377: decode to DMTC2 using decoder 432
9711 // 377: }
9712 // 377: } // switch Inst[25:21]
9713 // 377: }
9714 21, 163, 1, // 382: case 0x15: {
9715 OPC_SwitchField, 0, 13, // 385: switch Inst[12:0] {
9716 188, 8, 7, // 388: case 0x43c: {
9717 OPC_CheckPredicate, 17, // 391: check predicate 17
9718 OPC_Decode, 131, 11, 177, 3, // 393: decode to C_F_D64_MM using decoder 433
9719 // 393: }
9720 252, 8, 7, // 398: case 0x47c: {
9721 OPC_CheckPredicate, 17, // 401: check predicate 17
9722 OPC_Decode, 215, 11, 177, 3, // 403: decode to C_UN_D64_MM using decoder 433
9723 // 403: }
9724 188, 9, 7, // 408: case 0x4bc: {
9725 OPC_CheckPredicate, 17, // 411: check predicate 17
9726 OPC_Decode, 253, 10, 177, 3, // 413: decode to C_EQ_D64_MM using decoder 433
9727 // 413: }
9728 252, 9, 7, // 418: case 0x4fc: {
9729 OPC_CheckPredicate, 17, // 421: check predicate 17
9730 OPC_Decode, 197, 11, 177, 3, // 423: decode to C_UEQ_D64_MM using decoder 433
9731 // 423: }
9732 188, 10, 7, // 428: case 0x53c: {
9733 OPC_CheckPredicate, 17, // 431: check predicate 17
9734 OPC_Decode, 179, 11, 177, 3, // 433: decode to C_OLT_D64_MM using decoder 433
9735 // 433: }
9736 252, 10, 7, // 438: case 0x57c: {
9737 OPC_CheckPredicate, 17, // 441: check predicate 17
9738 OPC_Decode, 209, 11, 177, 3, // 443: decode to C_ULT_D64_MM using decoder 433
9739 // 443: }
9740 188, 11, 7, // 448: case 0x5bc: {
9741 OPC_CheckPredicate, 17, // 451: check predicate 17
9742 OPC_Decode, 173, 11, 177, 3, // 453: decode to C_OLE_D64_MM using decoder 433
9743 // 453: }
9744 252, 11, 7, // 458: case 0x5fc: {
9745 OPC_CheckPredicate, 17, // 461: check predicate 17
9746 OPC_Decode, 203, 11, 177, 3, // 463: decode to C_ULE_D64_MM using decoder 433
9747 // 463: }
9748 188, 12, 7, // 468: case 0x63c: {
9749 OPC_CheckPredicate, 17, // 471: check predicate 17
9750 OPC_Decode, 191, 11, 177, 3, // 473: decode to C_SF_D64_MM using decoder 433
9751 // 473: }
9752 252, 12, 7, // 478: case 0x67c: {
9753 OPC_CheckPredicate, 17, // 481: check predicate 17
9754 OPC_Decode, 155, 11, 177, 3, // 483: decode to C_NGLE_D64_MM using decoder 433
9755 // 483: }
9756 188, 13, 7, // 488: case 0x6bc: {
9757 OPC_CheckPredicate, 17, // 491: check predicate 17
9758 OPC_Decode, 185, 11, 177, 3, // 493: decode to C_SEQ_D64_MM using decoder 433
9759 // 493: }
9760 252, 13, 7, // 498: case 0x6fc: {
9761 OPC_CheckPredicate, 17, // 501: check predicate 17
9762 OPC_Decode, 161, 11, 177, 3, // 503: decode to C_NGL_D64_MM using decoder 433
9763 // 503: }
9764 188, 14, 7, // 508: case 0x73c: {
9765 OPC_CheckPredicate, 17, // 511: check predicate 17
9766 OPC_Decode, 143, 11, 177, 3, // 513: decode to C_LT_D64_MM using decoder 433
9767 // 513: }
9768 252, 14, 7, // 518: case 0x77c: {
9769 OPC_CheckPredicate, 17, // 521: check predicate 17
9770 OPC_Decode, 149, 11, 177, 3, // 523: decode to C_NGE_D64_MM using decoder 433
9771 // 523: }
9772 188, 15, 7, // 528: case 0x7bc: {
9773 OPC_CheckPredicate, 17, // 531: check predicate 17
9774 OPC_Decode, 137, 11, 177, 3, // 533: decode to C_LE_D64_MM using decoder 433
9775 // 533: }
9776 252, 15, 0, // 538: case 0x7fc: {
9777 OPC_CheckPredicate, 17, // 541: check predicate 17
9778 OPC_Decode, 167, 11, 177, 3, // 543: decode to C_NGT_D64_MM using decoder 433
9779 // 543: }
9780 // 543: } // switch Inst[12:0]
9781 // 543: }
9782 24, 7, // 548: case 0x18: {
9783 OPC_CheckPredicate, 98, // 550: check predicate 98
9784 OPC_Decode, 222, 11, 178, 3, // 552: decode to DADDi using decoder 434
9785 // 552: }
9786 25, 7, // 557: case 0x19: {
9787 OPC_CheckPredicate, 94, // 559: check predicate 94
9788 OPC_Decode, 223, 11, 178, 3, // 561: decode to DADDiu using decoder 434
9789 // 561: }
9790 26, 7, // 566: case 0x1a: {
9791 OPC_CheckPredicate, 98, // 568: check predicate 98
9792 OPC_Decode, 222, 15, 179, 3, // 570: decode to LDL using decoder 435
9793 // 570: }
9794 27, 7, // 575: case 0x1b: {
9795 OPC_CheckPredicate, 98, // 577: check predicate 98
9796 OPC_Decode, 224, 15, 179, 3, // 579: decode to LDR using decoder 435
9797 // 579: }
9798 28, 21, // 584: case 0x1c: {
9799 OPC_SwitchField, 0, 11, // 586: switch Inst[10:0] {
9800 36, 7, // 589: case 0x24: {
9801 OPC_CheckPredicate, 99, // 591: check predicate 99
9802 OPC_Decode, 232, 11, 180, 3, // 593: decode to DCLZ using decoder 436
9803 // 593: }
9804 37, 0, // 598: case 0x25: {
9805 OPC_CheckPredicate, 99, // 600: check predicate 99
9806 OPC_Decode, 230, 11, 180, 3, // 602: decode to DCLO using decoder 436
9807 // 602: }
9808 // 602: } // switch Inst[10:0]
9809 // 602: }
9810 31, 88, // 607: case 0x1f: {
9811 OPC_SwitchField, 0, 6, // 609: switch Inst[5:0] {
9812 1, 7, // 612: case 0x1: {
9813 OPC_CheckPredicate, 93, // 614: check predicate 93
9814 OPC_Decode, 242, 11, 181, 3, // 616: decode to DEXTM using decoder 437
9815 // 616: }
9816 2, 7, // 621: case 0x2: {
9817 OPC_CheckPredicate, 93, // 623: check predicate 93
9818 OPC_Decode, 243, 11, 181, 3, // 625: decode to DEXTU using decoder 437
9819 // 625: }
9820 3, 7, // 630: case 0x3: {
9821 OPC_CheckPredicate, 93, // 632: check predicate 93
9822 OPC_Decode, 240, 11, 181, 3, // 634: decode to DEXT using decoder 437
9823 // 634: }
9824 5, 7, // 639: case 0x5: {
9825 OPC_CheckPredicate, 93, // 641: check predicate 93
9826 OPC_Decode, 246, 11, 182, 3, // 643: decode to DINSM using decoder 438
9827 // 643: }
9828 6, 7, // 648: case 0x6: {
9829 OPC_CheckPredicate, 93, // 650: check predicate 93
9830 OPC_Decode, 247, 11, 182, 3, // 652: decode to DINSU using decoder 438
9831 // 652: }
9832 7, 7, // 657: case 0x7: {
9833 OPC_CheckPredicate, 93, // 659: check predicate 93
9834 OPC_Decode, 245, 11, 182, 3, // 661: decode to DINS using decoder 438
9835 // 661: }
9836 36, 0, // 666: case 0x24: {
9837 OPC_SwitchField, 6, 5, // 668: switch Inst[10:6] {
9838 2, 11, // 671: case 0x2: {
9839 OPC_CheckPredicate, 93, // 673: check predicate 93
9840 OPC_CheckField, 21, 5, 0, // 675: check Inst[25:21] == 0x0
9841 OPC_Decode, 213, 12, 161, 3, // 679: decode to DSBH using decoder 417
9842 // 679: }
9843 5, 0, // 684: case 0x5: {
9844 OPC_CheckPredicate, 93, // 686: check predicate 93
9845 OPC_CheckField, 21, 5, 0, // 688: check Inst[25:21] == 0x0
9846 OPC_Decode, 215, 12, 161, 3, // 692: decode to DSHD using decoder 417
9847 // 692: }
9848 // 692: } // switch Inst[10:6]
9849 // 692: }
9850 // 692: } // switch Inst[5:0]
9851 // 692: }
9852 39, 7, // 697: case 0x27: {
9853 OPC_CheckPredicate, 94, // 699: check predicate 94
9854 OPC_Decode, 211, 16, 183, 3, // 701: decode to LWu using decoder 439
9855 // 701: }
9856 44, 7, // 706: case 0x2c: {
9857 OPC_CheckPredicate, 98, // 708: check predicate 98
9858 OPC_Decode, 135, 21, 183, 3, // 710: decode to SDL using decoder 439
9859 // 710: }
9860 45, 7, // 715: case 0x2d: {
9861 OPC_CheckPredicate, 98, // 717: check predicate 98
9862 OPC_Decode, 136, 21, 183, 3, // 719: decode to SDR using decoder 439
9863 // 719: }
9864 46, 7, // 724: case 0x2e: {
9865 OPC_CheckPredicate, 22, // 726: check predicate 22
9866 OPC_Decode, 128, 21, 191, 1, // 728: decode to SDC1_MM_D64 using decoder 191
9867 // 728: }
9868 47, 7, // 733: case 0x2f: {
9869 OPC_CheckPredicate, 22, // 735: check predicate 22
9870 OPC_Decode, 213, 15, 191, 1, // 737: decode to LDC1_MM_D64 using decoder 191
9871 // 737: }
9872 52, 7, // 742: case 0x34: {
9873 OPC_CheckPredicate, 95, // 744: check predicate 95
9874 OPC_Decode, 138, 16, 183, 3, // 746: decode to LLD using decoder 439
9875 // 746: }
9876 55, 7, // 751: case 0x37: {
9877 OPC_CheckPredicate, 94, // 753: check predicate 94
9878 OPC_Decode, 208, 15, 183, 3, // 755: decode to LD using decoder 439
9879 // 755: }
9880 60, 7, // 760: case 0x3c: {
9881 OPC_CheckPredicate, 100, // 762: check predicate 100
9882 OPC_Decode, 234, 20, 184, 3, // 764: decode to SCD using decoder 440
9883 // 764: }
9884 63, 0, // 769: case 0x3f: {
9885 OPC_CheckPredicate, 94, // 771: check predicate 94
9886 OPC_Decode, 243, 20, 183, 3, // 773: decode to SD using decoder 439
9887 // 773: }
9888 // 773: } // switch Inst[31:26]
9889};
9890static const uint8_t DecoderTableMipsDSP32[21] = {
9891 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9892 35, 7, // 3: case 0x23: {
9893 OPC_CheckPredicate, 101, // 5: check predicate 101
9894 OPC_Decode, 170, 16, 185, 3, // 7: decode to LWDSP using decoder 441
9895 // 7: }
9896 43, 0, // 12: case 0x2b: {
9897 OPC_CheckPredicate, 101, // 14: check predicate 101
9898 OPC_Decode, 165, 23, 185, 3, // 16: decode to SWDSP using decoder 441
9899 // 16: }
9900 // 16: } // switch Inst[31:26]
9901};
9902static const uint8_t DecoderTableMipsFP6432[1037] = {
9903 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9904 17, 152, 7, // 3: case 0x11: {
9905 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
9906 0, 73, // 9: case 0x0: {
9907 OPC_SwitchField, 21, 5, // 11: switch Inst[25:21] {
9908 0, 11, // 14: case 0x0: {
9909 OPC_CheckPredicate, 102, // 16: check predicate 102
9910 OPC_CheckField, 6, 5, 0, // 18: check Inst[10:6] == 0x0
9911 OPC_Decode, 161, 17, 186, 3, // 22: decode to MFC1_D64 using decoder 442
9912 // 22: }
9913 3, 11, // 27: case 0x3: {
9914 OPC_CheckPredicate, 103, // 29: check predicate 103
9915 OPC_CheckField, 6, 5, 0, // 31: check Inst[10:6] == 0x0
9916 OPC_Decode, 172, 17, 186, 3, // 35: decode to MFHC1_D64 using decoder 442
9917 // 35: }
9918 4, 11, // 40: case 0x4: {
9919 OPC_CheckPredicate, 102, // 42: check predicate 102
9920 OPC_CheckField, 6, 5, 0, // 44: check Inst[10:6] == 0x0
9921 OPC_Decode, 187, 18, 187, 3, // 48: decode to MTC1_D64 using decoder 443
9922 // 48: }
9923 7, 11, // 53: case 0x7: {
9924 OPC_CheckPredicate, 103, // 55: check predicate 103
9925 OPC_CheckField, 6, 5, 0, // 57: check Inst[10:6] == 0x0
9926 OPC_Decode, 199, 18, 188, 3, // 61: decode to MTHC1_D64 using decoder 444
9927 // 61: }
9928 17, 7, // 66: case 0x11: {
9929 OPC_CheckPredicate, 102, // 68: check predicate 102
9930 OPC_Decode, 167, 13, 152, 3, // 70: decode to FADD_D64 using decoder 408
9931 // 70: }
9932 22, 0, // 75: case 0x16: {
9933 OPC_CheckPredicate, 104, // 77: check predicate 104
9934 OPC_Decode, 169, 13, 152, 3, // 79: decode to FADD_PS64 using decoder 408
9935 // 79: }
9936 // 79: } // switch Inst[25:21]
9937 // 79: }
9938 1, 21, // 84: case 0x1: {
9939 OPC_SwitchField, 21, 5, // 86: switch Inst[25:21] {
9940 17, 7, // 89: case 0x11: {
9941 OPC_CheckPredicate, 102, // 91: check predicate 102
9942 OPC_Decode, 184, 14, 152, 3, // 93: decode to FSUB_D64 using decoder 408
9943 // 93: }
9944 22, 0, // 98: case 0x16: {
9945 OPC_CheckPredicate, 104, // 100: check predicate 104
9946 OPC_Decode, 186, 14, 152, 3, // 102: decode to FSUB_PS64 using decoder 408
9947 // 102: }
9948 // 102: } // switch Inst[25:21]
9949 // 102: }
9950 2, 21, // 107: case 0x2: {
9951 OPC_SwitchField, 21, 5, // 109: switch Inst[25:21] {
9952 17, 7, // 112: case 0x11: {
9953 OPC_CheckPredicate, 102, // 114: check predicate 102
9954 OPC_Decode, 140, 14, 152, 3, // 116: decode to FMUL_D64 using decoder 408
9955 // 116: }
9956 22, 0, // 121: case 0x16: {
9957 OPC_CheckPredicate, 104, // 123: check predicate 104
9958 OPC_Decode, 142, 14, 152, 3, // 125: decode to FMUL_PS64 using decoder 408
9959 // 125: }
9960 // 125: } // switch Inst[25:21]
9961 // 125: }
9962 3, 11, // 130: case 0x3: {
9963 OPC_CheckPredicate, 102, // 132: check predicate 102
9964 OPC_CheckField, 21, 5, 17, // 134: check Inst[25:21] == 0x11
9965 OPC_Decode, 206, 13, 152, 3, // 138: decode to FDIV_D64 using decoder 408
9966 // 138: }
9967 4, 12, // 143: case 0x4: {
9968 OPC_CheckPredicate, 105, // 145: check predicate 105
9969 OPC_CheckField, 16, 10, 160, 4, // 147: check Inst[25:16] == 0x220
9970 OPC_Decode, 176, 14, 143, 2, // 152: decode to FSQRT_D64 using decoder 271
9971 // 152: }
9972 5, 12, // 157: case 0x5: {
9973 OPC_CheckPredicate, 102, // 159: check predicate 102
9974 OPC_CheckField, 16, 10, 160, 4, // 161: check Inst[25:16] == 0x220
9975 OPC_Decode, 160, 13, 143, 2, // 166: decode to FABS_D64 using decoder 271
9976 // 166: }
9977 6, 12, // 171: case 0x6: {
9978 OPC_CheckPredicate, 102, // 173: check predicate 102
9979 OPC_CheckField, 16, 10, 160, 4, // 175: check Inst[25:16] == 0x220
9980 OPC_Decode, 129, 14, 143, 2, // 180: decode to FMOV_D64 using decoder 271
9981 // 180: }
9982 7, 12, // 185: case 0x7: {
9983 OPC_CheckPredicate, 102, // 187: check predicate 102
9984 OPC_CheckField, 16, 10, 160, 4, // 189: check Inst[25:16] == 0x220
9985 OPC_Decode, 149, 14, 143, 2, // 194: decode to FNEG_D64 using decoder 271
9986 // 194: }
9987 8, 23, // 199: case 0x8: {
9988 OPC_SwitchField, 16, 10, // 201: switch Inst[25:16] {
9989 128, 4, 7, // 204: case 0x200: {
9990 OPC_CheckPredicate, 105, // 207: check predicate 105
9991 OPC_Decode, 189, 20, 136, 2, // 209: decode to ROUND_L_S using decoder 264
9992 // 209: }
9993 160, 4, 0, // 214: case 0x220: {
9994 OPC_CheckPredicate, 106, // 217: check predicate 106
9995 OPC_Decode, 187, 20, 143, 2, // 219: decode to ROUND_L_D64 using decoder 271
9996 // 219: }
9997 // 219: } // switch Inst[25:16]
9998 // 219: }
9999 9, 23, // 224: case 0x9: {
10000 OPC_SwitchField, 16, 10, // 226: switch Inst[25:16] {
10001 128, 4, 7, // 229: case 0x200: {
10002 OPC_CheckPredicate, 105, // 232: check predicate 105
10003 OPC_Decode, 155, 24, 136, 2, // 234: decode to TRUNC_L_S using decoder 264
10004 // 234: }
10005 160, 4, 0, // 239: case 0x220: {
10006 OPC_CheckPredicate, 106, // 242: check predicate 106
10007 OPC_Decode, 153, 24, 143, 2, // 244: decode to TRUNC_L_D64 using decoder 271
10008 // 244: }
10009 // 244: } // switch Inst[25:16]
10010 // 244: }
10011 10, 23, // 249: case 0xa: {
10012 OPC_SwitchField, 16, 10, // 251: switch Inst[25:16] {
10013 128, 4, 7, // 254: case 0x200: {
10014 OPC_CheckPredicate, 105, // 257: check predicate 105
10015 OPC_Decode, 157, 9, 136, 2, // 259: decode to CEIL_L_S using decoder 264
10016 // 259: }
10017 160, 4, 0, // 264: case 0x220: {
10018 OPC_CheckPredicate, 106, // 267: check predicate 106
10019 OPC_Decode, 155, 9, 143, 2, // 269: decode to CEIL_L_D64 using decoder 271
10020 // 269: }
10021 // 269: } // switch Inst[25:16]
10022 // 269: }
10023 11, 23, // 274: case 0xb: {
10024 OPC_SwitchField, 16, 10, // 276: switch Inst[25:16] {
10025 128, 4, 7, // 279: case 0x200: {
10026 OPC_CheckPredicate, 105, // 282: check predicate 105
10027 OPC_Decode, 236, 13, 136, 2, // 284: decode to FLOOR_L_S using decoder 264
10028 // 284: }
10029 160, 4, 0, // 289: case 0x220: {
10030 OPC_CheckPredicate, 106, // 292: check predicate 106
10031 OPC_Decode, 234, 13, 143, 2, // 294: decode to FLOOR_L_D64 using decoder 271
10032 // 294: }
10033 // 294: } // switch Inst[25:16]
10034 // 294: }
10035 12, 12, // 299: case 0xc: {
10036 OPC_CheckPredicate, 105, // 301: check predicate 105
10037 OPC_CheckField, 16, 10, 160, 4, // 303: check Inst[25:16] == 0x220
10038 OPC_Decode, 192, 20, 189, 3, // 308: decode to ROUND_W_D64 using decoder 445
10039 // 308: }
10040 13, 12, // 313: case 0xd: {
10041 OPC_CheckPredicate, 105, // 315: check predicate 105
10042 OPC_CheckField, 16, 10, 160, 4, // 317: check Inst[25:16] == 0x220
10043 OPC_Decode, 158, 24, 189, 3, // 322: decode to TRUNC_W_D64 using decoder 445
10044 // 322: }
10045 14, 12, // 327: case 0xe: {
10046 OPC_CheckPredicate, 105, // 329: check predicate 105
10047 OPC_CheckField, 16, 10, 160, 4, // 331: check Inst[25:16] == 0x220
10048 OPC_Decode, 160, 9, 189, 3, // 336: decode to CEIL_W_D64 using decoder 445
10049 // 336: }
10050 15, 12, // 341: case 0xf: {
10051 OPC_CheckPredicate, 105, // 343: check predicate 105
10052 OPC_CheckField, 16, 10, 160, 4, // 345: check Inst[25:16] == 0x220
10053 OPC_Decode, 239, 13, 189, 3, // 350: decode to FLOOR_W_D64 using decoder 445
10054 // 350: }
10055 17, 29, // 355: case 0x11: {
10056 OPC_SwitchField, 16, 2, // 357: switch Inst[17:16] {
10057 0, 11, // 360: case 0x0: {
10058 OPC_CheckPredicate, 107, // 362: check predicate 107
10059 OPC_CheckField, 21, 5, 17, // 364: check Inst[25:21] == 0x11
10060 OPC_Decode, 245, 17, 190, 3, // 368: decode to MOVF_D64 using decoder 446
10061 // 368: }
10062 1, 0, // 373: case 0x1: {
10063 OPC_CheckPredicate, 107, // 375: check predicate 107
10064 OPC_CheckField, 21, 5, 17, // 377: check Inst[25:21] == 0x11
10065 OPC_Decode, 138, 18, 190, 3, // 381: decode to MOVT_D64 using decoder 446
10066 // 381: }
10067 // 381: } // switch Inst[17:16]
10068 // 381: }
10069 18, 11, // 386: case 0x12: {
10070 OPC_CheckPredicate, 107, // 388: check predicate 107
10071 OPC_CheckField, 21, 5, 17, // 390: check Inst[25:21] == 0x11
10072 OPC_Decode, 150, 18, 191, 3, // 394: decode to MOVZ_I_D64 using decoder 447
10073 // 394: }
10074 19, 11, // 399: case 0x13: {
10075 OPC_CheckPredicate, 107, // 401: check predicate 107
10076 OPC_CheckField, 21, 5, 17, // 403: check Inst[25:21] == 0x11
10077 OPC_Decode, 129, 18, 191, 3, // 407: decode to MOVN_I_D64 using decoder 447
10078 // 407: }
10079 21, 12, // 412: case 0x15: {
10080 OPC_CheckPredicate, 108, // 414: check predicate 108
10081 OPC_CheckField, 16, 10, 160, 4, // 416: check Inst[25:16] == 0x220
10082 OPC_Decode, 161, 20, 143, 2, // 421: decode to RECIP_D64 using decoder 271
10083 // 421: }
10084 22, 12, // 426: case 0x16: {
10085 OPC_CheckPredicate, 108, // 428: check predicate 108
10086 OPC_CheckField, 16, 10, 160, 4, // 430: check Inst[25:16] == 0x220
10087 OPC_Decode, 200, 20, 143, 2, // 435: decode to RSQRT_D64 using decoder 271
10088 // 435: }
10089 24, 11, // 440: case 0x18: {
10090 OPC_CheckPredicate, 109, // 442: check predicate 109
10091 OPC_CheckField, 21, 5, 22, // 444: check Inst[25:21] == 0x16
10092 OPC_Decode, 191, 6, 152, 3, // 448: decode to ADDR_PS64 using decoder 408
10093 // 448: }
10094 26, 11, // 453: case 0x1a: {
10095 OPC_CheckPredicate, 109, // 455: check predicate 109
10096 OPC_CheckField, 21, 5, 22, // 457: check Inst[25:21] == 0x16
10097 OPC_Decode, 247, 18, 152, 3, // 461: decode to MULR_PS64 using decoder 408
10098 // 461: }
10099 32, 33, // 466: case 0x20: {
10100 OPC_SwitchField, 16, 10, // 468: switch Inst[25:16] {
10101 160, 4, 7, // 471: case 0x220: {
10102 OPC_CheckPredicate, 102, // 474: check predicate 102
10103 OPC_Decode, 234, 10, 189, 3, // 476: decode to CVT_S_D64 using decoder 445
10104 // 476: }
10105 160, 5, 7, // 481: case 0x2a0: {
10106 OPC_CheckPredicate, 110, // 484: check predicate 110
10107 OPC_Decode, 236, 10, 189, 3, // 486: decode to CVT_S_L using decoder 445
10108 // 486: }
10109 192, 5, 0, // 491: case 0x2c0: {
10110 OPC_CheckPredicate, 104, // 494: check predicate 104
10111 OPC_Decode, 239, 10, 189, 3, // 496: decode to CVT_S_PU64 using decoder 445
10112 // 496: }
10113 // 496: } // switch Inst[25:16]
10114 // 496: }
10115 33, 33, // 501: case 0x21: {
10116 OPC_SwitchField, 16, 10, // 503: switch Inst[25:16] {
10117 128, 4, 7, // 506: case 0x200: {
10118 OPC_CheckPredicate, 102, // 509: check predicate 102
10119 OPC_Decode, 218, 10, 136, 2, // 511: decode to CVT_D64_S using decoder 264
10120 // 511: }
10121 128, 5, 7, // 516: case 0x280: {
10122 OPC_CheckPredicate, 102, // 519: check predicate 102
10123 OPC_Decode, 220, 10, 136, 2, // 521: decode to CVT_D64_W using decoder 264
10124 // 521: }
10125 160, 5, 0, // 526: case 0x2a0: {
10126 OPC_CheckPredicate, 110, // 529: check predicate 110
10127 OPC_Decode, 217, 10, 143, 2, // 531: decode to CVT_D64_L using decoder 271
10128 // 531: }
10129 // 531: } // switch Inst[25:16]
10130 // 531: }
10131 36, 23, // 536: case 0x24: {
10132 OPC_SwitchField, 16, 10, // 538: switch Inst[25:16] {
10133 160, 4, 7, // 541: case 0x220: {
10134 OPC_CheckPredicate, 102, // 544: check predicate 102
10135 OPC_Decode, 245, 10, 189, 3, // 546: decode to CVT_W_D64 using decoder 445
10136 // 546: }
10137 192, 5, 0, // 551: case 0x2c0: {
10138 OPC_CheckPredicate, 109, // 554: check predicate 109
10139 OPC_Decode, 231, 10, 143, 2, // 556: decode to CVT_PW_PS64 using decoder 271
10140 // 556: }
10141 // 556: } // switch Inst[25:16]
10142 // 556: }
10143 38, 25, // 561: case 0x26: {
10144 OPC_SwitchField, 21, 5, // 563: switch Inst[25:21] {
10145 16, 7, // 566: case 0x10: {
10146 OPC_CheckPredicate, 104, // 568: check predicate 104
10147 OPC_Decode, 230, 10, 192, 3, // 570: decode to CVT_PS_S64 using decoder 448
10148 // 570: }
10149 20, 0, // 575: case 0x14: {
10150 OPC_CheckPredicate, 109, // 577: check predicate 109
10151 OPC_CheckField, 16, 5, 0, // 579: check Inst[20:16] == 0x0
10152 OPC_Decode, 229, 10, 143, 2, // 583: decode to CVT_PS_PW64 using decoder 271
10153 // 583: }
10154 // 583: } // switch Inst[25:21]
10155 // 583: }
10156 40, 12, // 588: case 0x28: {
10157 OPC_CheckPredicate, 104, // 590: check predicate 104
10158 OPC_CheckField, 16, 10, 192, 5, // 592: check Inst[25:16] == 0x2c0
10159 OPC_Decode, 238, 10, 189, 3, // 597: decode to CVT_S_PL64 using decoder 445
10160 // 597: }
10161 44, 11, // 602: case 0x2c: {
10162 OPC_CheckPredicate, 104, // 604: check predicate 104
10163 OPC_CheckField, 21, 5, 22, // 606: check Inst[25:21] == 0x16
10164 OPC_Decode, 226, 19, 152, 3, // 610: decode to PLL_PS64 using decoder 408
10165 // 610: }
10166 45, 11, // 615: case 0x2d: {
10167 OPC_CheckPredicate, 104, // 617: check predicate 104
10168 OPC_CheckField, 21, 5, 22, // 619: check Inst[25:21] == 0x16
10169 OPC_Decode, 227, 19, 152, 3, // 623: decode to PLU_PS64 using decoder 408
10170 // 623: }
10171 46, 11, // 628: case 0x2e: {
10172 OPC_CheckPredicate, 104, // 630: check predicate 104
10173 OPC_CheckField, 21, 5, 22, // 632: check Inst[25:21] == 0x16
10174 OPC_Decode, 146, 20, 152, 3, // 636: decode to PUL_PS64 using decoder 408
10175 // 636: }
10176 47, 11, // 641: case 0x2f: {
10177 OPC_CheckPredicate, 104, // 643: check predicate 104
10178 OPC_CheckField, 21, 5, 22, // 645: check Inst[25:21] == 0x16
10179 OPC_Decode, 147, 20, 152, 3, // 649: decode to PUU_PS64 using decoder 408
10180 // 649: }
10181 48, 15, // 654: case 0x30: {
10182 OPC_CheckPredicate, 111, // 656: check predicate 111
10183 OPC_CheckField, 21, 5, 17, // 658: check Inst[25:21] == 0x11
10184 OPC_CheckField, 6, 2, 0, // 662: check Inst[7:6] == 0x0
10185 OPC_Decode, 130, 11, 193, 3, // 666: decode to C_F_D64 using decoder 449
10186 // 666: }
10187 49, 15, // 671: case 0x31: {
10188 OPC_CheckPredicate, 111, // 673: check predicate 111
10189 OPC_CheckField, 21, 5, 17, // 675: check Inst[25:21] == 0x11
10190 OPC_CheckField, 6, 2, 0, // 679: check Inst[7:6] == 0x0
10191 OPC_Decode, 214, 11, 193, 3, // 683: decode to C_UN_D64 using decoder 449
10192 // 683: }
10193 50, 15, // 688: case 0x32: {
10194 OPC_CheckPredicate, 111, // 690: check predicate 111
10195 OPC_CheckField, 21, 5, 17, // 692: check Inst[25:21] == 0x11
10196 OPC_CheckField, 6, 2, 0, // 696: check Inst[7:6] == 0x0
10197 OPC_Decode, 252, 10, 193, 3, // 700: decode to C_EQ_D64 using decoder 449
10198 // 700: }
10199 51, 15, // 705: case 0x33: {
10200 OPC_CheckPredicate, 111, // 707: check predicate 111
10201 OPC_CheckField, 21, 5, 17, // 709: check Inst[25:21] == 0x11
10202 OPC_CheckField, 6, 2, 0, // 713: check Inst[7:6] == 0x0
10203 OPC_Decode, 196, 11, 193, 3, // 717: decode to C_UEQ_D64 using decoder 449
10204 // 717: }
10205 52, 15, // 722: case 0x34: {
10206 OPC_CheckPredicate, 111, // 724: check predicate 111
10207 OPC_CheckField, 21, 5, 17, // 726: check Inst[25:21] == 0x11
10208 OPC_CheckField, 6, 2, 0, // 730: check Inst[7:6] == 0x0
10209 OPC_Decode, 178, 11, 193, 3, // 734: decode to C_OLT_D64 using decoder 449
10210 // 734: }
10211 53, 15, // 739: case 0x35: {
10212 OPC_CheckPredicate, 111, // 741: check predicate 111
10213 OPC_CheckField, 21, 5, 17, // 743: check Inst[25:21] == 0x11
10214 OPC_CheckField, 6, 2, 0, // 747: check Inst[7:6] == 0x0
10215 OPC_Decode, 208, 11, 193, 3, // 751: decode to C_ULT_D64 using decoder 449
10216 // 751: }
10217 54, 15, // 756: case 0x36: {
10218 OPC_CheckPredicate, 111, // 758: check predicate 111
10219 OPC_CheckField, 21, 5, 17, // 760: check Inst[25:21] == 0x11
10220 OPC_CheckField, 6, 2, 0, // 764: check Inst[7:6] == 0x0
10221 OPC_Decode, 172, 11, 193, 3, // 768: decode to C_OLE_D64 using decoder 449
10222 // 768: }
10223 55, 15, // 773: case 0x37: {
10224 OPC_CheckPredicate, 111, // 775: check predicate 111
10225 OPC_CheckField, 21, 5, 17, // 777: check Inst[25:21] == 0x11
10226 OPC_CheckField, 6, 2, 0, // 781: check Inst[7:6] == 0x0
10227 OPC_Decode, 202, 11, 193, 3, // 785: decode to C_ULE_D64 using decoder 449
10228 // 785: }
10229 56, 15, // 790: case 0x38: {
10230 OPC_CheckPredicate, 111, // 792: check predicate 111
10231 OPC_CheckField, 21, 5, 17, // 794: check Inst[25:21] == 0x11
10232 OPC_CheckField, 6, 2, 0, // 798: check Inst[7:6] == 0x0
10233 OPC_Decode, 190, 11, 193, 3, // 802: decode to C_SF_D64 using decoder 449
10234 // 802: }
10235 57, 15, // 807: case 0x39: {
10236 OPC_CheckPredicate, 111, // 809: check predicate 111
10237 OPC_CheckField, 21, 5, 17, // 811: check Inst[25:21] == 0x11
10238 OPC_CheckField, 6, 2, 0, // 815: check Inst[7:6] == 0x0
10239 OPC_Decode, 154, 11, 193, 3, // 819: decode to C_NGLE_D64 using decoder 449
10240 // 819: }
10241 58, 15, // 824: case 0x3a: {
10242 OPC_CheckPredicate, 111, // 826: check predicate 111
10243 OPC_CheckField, 21, 5, 17, // 828: check Inst[25:21] == 0x11
10244 OPC_CheckField, 6, 2, 0, // 832: check Inst[7:6] == 0x0
10245 OPC_Decode, 184, 11, 193, 3, // 836: decode to C_SEQ_D64 using decoder 449
10246 // 836: }
10247 59, 15, // 841: case 0x3b: {
10248 OPC_CheckPredicate, 111, // 843: check predicate 111
10249 OPC_CheckField, 21, 5, 17, // 845: check Inst[25:21] == 0x11
10250 OPC_CheckField, 6, 2, 0, // 849: check Inst[7:6] == 0x0
10251 OPC_Decode, 160, 11, 193, 3, // 853: decode to C_NGL_D64 using decoder 449
10252 // 853: }
10253 60, 15, // 858: case 0x3c: {
10254 OPC_CheckPredicate, 111, // 860: check predicate 111
10255 OPC_CheckField, 21, 5, 17, // 862: check Inst[25:21] == 0x11
10256 OPC_CheckField, 6, 2, 0, // 866: check Inst[7:6] == 0x0
10257 OPC_Decode, 142, 11, 193, 3, // 870: decode to C_LT_D64 using decoder 449
10258 // 870: }
10259 61, 15, // 875: case 0x3d: {
10260 OPC_CheckPredicate, 111, // 877: check predicate 111
10261 OPC_CheckField, 21, 5, 17, // 879: check Inst[25:21] == 0x11
10262 OPC_CheckField, 6, 2, 0, // 883: check Inst[7:6] == 0x0
10263 OPC_Decode, 148, 11, 193, 3, // 887: decode to C_NGE_D64 using decoder 449
10264 // 887: }
10265 62, 15, // 892: case 0x3e: {
10266 OPC_CheckPredicate, 111, // 894: check predicate 111
10267 OPC_CheckField, 21, 5, 17, // 896: check Inst[25:21] == 0x11
10268 OPC_CheckField, 6, 2, 0, // 900: check Inst[7:6] == 0x0
10269 OPC_Decode, 136, 11, 193, 3, // 904: decode to C_LE_D64 using decoder 449
10270 // 904: }
10271 63, 0, // 909: case 0x3f: {
10272 OPC_CheckPredicate, 111, // 911: check predicate 111
10273 OPC_CheckField, 21, 5, 17, // 913: check Inst[25:21] == 0x11
10274 OPC_CheckField, 6, 2, 0, // 917: check Inst[7:6] == 0x0
10275 OPC_Decode, 166, 11, 193, 3, // 921: decode to C_NGT_D64 using decoder 449
10276 // 921: }
10277 // 921: } // switch Inst[5:0]
10278 // 921: }
10279 19, 91, // 926: case 0x13: {
10280 OPC_SwitchField, 0, 6, // 928: switch Inst[5:0] {
10281 1, 11, // 931: case 0x1: {
10282 OPC_CheckPredicate, 112, // 933: check predicate 112
10283 OPC_CheckField, 11, 5, 0, // 935: check Inst[15:11] == 0x0
10284 OPC_Decode, 226, 15, 194, 3, // 939: decode to LDXC164 using decoder 450
10285 // 939: }
10286 5, 11, // 944: case 0x5: {
10287 OPC_CheckPredicate, 113, // 946: check predicate 113
10288 OPC_CheckField, 11, 5, 0, // 948: check Inst[15:11] == 0x0
10289 OPC_Decode, 154, 16, 194, 3, // 952: decode to LUXC164 using decoder 450
10290 // 952: }
10291 9, 11, // 957: case 0x9: {
10292 OPC_CheckPredicate, 112, // 959: check predicate 112
10293 OPC_CheckField, 6, 5, 0, // 961: check Inst[10:6] == 0x0
10294 OPC_Decode, 138, 21, 195, 3, // 965: decode to SDXC164 using decoder 451
10295 // 965: }
10296 13, 11, // 970: case 0xd: {
10297 OPC_CheckPredicate, 113, // 972: check predicate 113
10298 OPC_CheckField, 6, 5, 0, // 974: check Inst[10:6] == 0x0
10299 OPC_Decode, 151, 23, 195, 3, // 978: decode to SUXC164 using decoder 451
10300 // 978: }
10301 33, 7, // 983: case 0x21: {
10302 OPC_CheckPredicate, 114, // 985: check predicate 114
10303 OPC_Decode, 240, 16, 196, 3, // 987: decode to MADD_D64 using decoder 452
10304 // 987: }
10305 41, 7, // 992: case 0x29: {
10306 OPC_CheckPredicate, 114, // 994: check predicate 114
10307 OPC_Decode, 174, 18, 196, 3, // 996: decode to MSUB_D64 using decoder 452
10308 // 996: }
10309 49, 7, // 1001: case 0x31: {
10310 OPC_CheckPredicate, 115, // 1003: check predicate 115
10311 OPC_Decode, 166, 19, 196, 3, // 1005: decode to NMADD_D64 using decoder 452
10312 // 1005: }
10313 57, 0, // 1010: case 0x39: {
10314 OPC_CheckPredicate, 115, // 1012: check predicate 115
10315 OPC_Decode, 171, 19, 196, 3, // 1014: decode to NMSUB_D64 using decoder 452
10316 // 1014: }
10317 // 1014: } // switch Inst[5:0]
10318 // 1014: }
10319 53, 7, // 1019: case 0x35: {
10320 OPC_CheckPredicate, 105, // 1021: check predicate 105
10321 OPC_Decode, 210, 15, 142, 3, // 1023: decode to LDC164 using decoder 398
10322 // 1023: }
10323 61, 0, // 1028: case 0x3d: {
10324 OPC_CheckPredicate, 105, // 1030: check predicate 105
10325 OPC_Decode, 253, 20, 142, 3, // 1032: decode to SDC164 using decoder 398
10326 // 1032: }
10327 // 1032: } // switch Inst[31:26]
10328};
10329static const uint8_t DecoderTableNanoMips32[1722] = {
10330 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
10331 0, 52, // 3: case 0x0: {
10332 OPC_Scope, 11, // 5: try {
10333 OPC_CheckField, 18, 8, 2, // 7: check Inst[25:18] == 0x2
10334 OPC_CheckPredicate, 4, // 11: check predicate 4
10335 OPC_Decode, 210, 23, 197, 3, // 13: decode to SYSCALL_NM using decoder 453
10336 OPC_Scope, 30, // 18: } else try {
10337 OPC_SwitchField, 19, 7, // 20: switch Inst[25:19] {
10338 0, 7, // 23: case 0x0: {
10339 OPC_CheckPredicate, 4, // 25: check predicate 4
10340 OPC_Decode, 235, 21, 198, 3, // 27: decode to SIGRIE_NM using decoder 454
10341 // 27: }
10342 2, 7, // 32: case 0x2: {
10343 OPC_CheckPredicate, 4, // 34: check predicate 4
10344 OPC_Decode, 247, 8, 198, 3, // 36: decode to BREAK_NM using decoder 454
10345 // 36: }
10346 3, 0, // 41: case 0x3: {
10347 OPC_CheckPredicate, 4, // 43: check predicate 4
10348 OPC_Decode, 250, 20, 198, 3, // 45: decode to SDBBP_NM using decoder 454
10349 // 45: }
10350 // 45: } // switch Inst[25:19]
10351 // 45: } else try {
10352 OPC_CheckPredicate, 4, // 50: check predicate 4
10353 OPC_Decode, 176, 6, 153, 1, // 52: decode to ADDIU_NM using decoder 153
10354 // 52: }
10355 // 52: }
10356 1, 7, // 57: case 0x1: {
10357 OPC_CheckPredicate, 4, // 59: check predicate 4
10358 OPC_Decode, 181, 15, 199, 3, // 61: decode to LAPC32_NM using decoder 455
10359 // 61: }
10360 2, 7, // 66: case 0x2: {
10361 OPC_CheckPredicate, 4, // 68: check predicate 4
10362 OPC_Decode, 236, 17, 200, 3, // 70: decode to MOVEBALC_NM using decoder 456
10363 // 70: }
10364 8, 151, 5, // 75: case 0x8: {
10365 OPC_SwitchField, 0, 6, // 78: switch Inst[5:0] {
10366 0, 35, // 81: case 0x0: {
10367 OPC_SwitchField, 6, 4, // 83: switch Inst[9:6] {
10368 0, 21, // 86: case 0x0: {
10369 OPC_SwitchField, 10, 1, // 88: switch Inst[10] {
10370 0, 7, // 91: case 0x0: {
10371 OPC_CheckPredicate, 4, // 93: check predicate 4
10372 OPC_Decode, 236, 23, 201, 3, // 95: decode to TEQ_NM using decoder 457
10373 // 95: }
10374 1, 0, // 100: case 0x1: {
10375 OPC_CheckPredicate, 4, // 102: check predicate 4
10376 OPC_Decode, 152, 24, 201, 3, // 104: decode to TNE_NM using decoder 457
10377 // 104: }
10378 // 104: } // switch Inst[10]
10379 // 104: }
10380 7, 0, // 109: case 0x7: {
10381 OPC_CheckPredicate, 4, // 111: check predicate 4
10382 OPC_Decode, 156, 20, 202, 3, // 113: decode to RDHWR_NM using decoder 458
10383 // 113: }
10384 // 113: } // switch Inst[9:6]
10385 // 113: }
10386 7, 120, // 118: case 0x7: {
10387 OPC_SwitchField, 6, 5, // 120: switch Inst[10:6] {
10388 0, 7, // 123: case 0x0: {
10389 OPC_CheckPredicate, 4, // 125: check predicate 4
10390 OPC_Decode, 198, 15, 203, 3, // 127: decode to LBX_NM using decoder 459
10391 // 127: }
10392 2, 7, // 132: case 0x2: {
10393 OPC_CheckPredicate, 4, // 134: check predicate 4
10394 OPC_Decode, 226, 20, 203, 3, // 136: decode to SBX_NM using decoder 459
10395 // 136: }
10396 4, 7, // 141: case 0x4: {
10397 OPC_CheckPredicate, 4, // 143: check predicate 4
10398 OPC_Decode, 194, 15, 203, 3, // 145: decode to LBUX_NM using decoder 459
10399 // 145: }
10400 8, 7, // 150: case 0x8: {
10401 OPC_CheckPredicate, 4, // 152: check predicate 4
10402 OPC_Decode, 250, 15, 203, 3, // 154: decode to LHX_NM using decoder 459
10403 // 154: }
10404 9, 7, // 159: case 0x9: {
10405 OPC_CheckPredicate, 4, // 161: check predicate 4
10406 OPC_Decode, 248, 15, 203, 3, // 163: decode to LHXS_NM using decoder 459
10407 // 163: }
10408 10, 7, // 168: case 0xa: {
10409 OPC_CheckPredicate, 4, // 170: check predicate 4
10410 OPC_Decode, 228, 21, 203, 3, // 172: decode to SHX_NM using decoder 459
10411 // 172: }
10412 11, 7, // 177: case 0xb: {
10413 OPC_CheckPredicate, 4, // 179: check predicate 4
10414 OPC_Decode, 227, 21, 203, 3, // 181: decode to SHXS_NM using decoder 459
10415 // 181: }
10416 12, 7, // 186: case 0xc: {
10417 OPC_CheckPredicate, 4, // 188: check predicate 4
10418 OPC_Decode, 244, 15, 203, 3, // 190: decode to LHUX_NM using decoder 459
10419 // 190: }
10420 13, 7, // 195: case 0xd: {
10421 OPC_CheckPredicate, 4, // 197: check predicate 4
10422 OPC_Decode, 243, 15, 203, 3, // 199: decode to LHUXS_NM using decoder 459
10423 // 199: }
10424 16, 7, // 204: case 0x10: {
10425 OPC_CheckPredicate, 4, // 206: check predicate 4
10426 OPC_Decode, 206, 16, 203, 3, // 208: decode to LWX_NM using decoder 459
10427 // 208: }
10428 17, 7, // 213: case 0x11: {
10429 OPC_CheckPredicate, 4, // 215: check predicate 4
10430 OPC_Decode, 204, 16, 203, 3, // 217: decode to LWXS_NM using decoder 459
10431 // 217: }
10432 18, 7, // 222: case 0x12: {
10433 OPC_CheckPredicate, 4, // 224: check predicate 4
10434 OPC_Decode, 193, 23, 203, 3, // 226: decode to SWX_NM using decoder 459
10435 // 226: }
10436 19, 0, // 231: case 0x13: {
10437 OPC_CheckPredicate, 4, // 233: check predicate 4
10438 OPC_Decode, 192, 23, 203, 3, // 235: decode to SWXS_NM using decoder 459
10439 // 235: }
10440 // 235: } // switch Inst[10:6]
10441 // 235: }
10442 8, 19, // 240: case 0x8: {
10443 OPC_SwitchField, 6, 4, // 242: switch Inst[9:6] {
10444 0, 6, // 245: case 0x0: {
10445 OPC_CheckPredicate, 4, // 247: check predicate 4
10446 OPC_Decode, 142, 21, 123, // 249: decode to SEB_NM using decoder 123
10447 // 249: }
10448 1, 0, // 253: case 0x1: {
10449 OPC_CheckPredicate, 4, // 255: check predicate 4
10450 OPC_Decode, 146, 21, 123, // 257: decode to SEH_NM using decoder 123
10451 // 257: }
10452 // 257: } // switch Inst[9:6]
10453 // 257: }
10454 15, 7, // 261: case 0xf: {
10455 OPC_CheckPredicate, 4, // 263: check predicate 4
10456 OPC_Decode, 149, 16, 204, 3, // 265: decode to LSA_NM using decoder 460
10457 // 265: }
10458 16, 167, 1, // 270: case 0x10: {
10459 OPC_SwitchField, 6, 4, // 273: switch Inst[9:6] {
10460 0, 6, // 276: case 0x0: {
10461 OPC_CheckPredicate, 4, // 278: check predicate 4
10462 OPC_Decode, 128, 22, 98, // 280: decode to SLLV_NM using decoder 98
10463 // 280: }
10464 1, 6, // 284: case 0x1: {
10465 OPC_CheckPredicate, 4, // 286: check predicate 4
10466 OPC_Decode, 203, 22, 98, // 288: decode to SRLV_NM using decoder 98
10467 // 288: }
10468 2, 6, // 292: case 0x2: {
10469 OPC_CheckPredicate, 4, // 294: check predicate 4
10470 OPC_Decode, 178, 22, 98, // 296: decode to SRAV_NM using decoder 98
10471 // 296: }
10472 3, 6, // 300: case 0x3: {
10473 OPC_CheckPredicate, 4, // 302: check predicate 4
10474 OPC_Decode, 183, 20, 98, // 304: decode to ROTRV_NM using decoder 98
10475 // 304: }
10476 4, 6, // 308: case 0x4: {
10477 OPC_CheckPredicate, 4, // 310: check predicate 4
10478 OPC_Decode, 237, 6, 98, // 312: decode to ADD_NM using decoder 98
10479 // 312: }
10480 5, 6, // 316: case 0x5: {
10481 OPC_CheckPredicate, 4, // 318: check predicate 4
10482 OPC_Decode, 246, 6, 98, // 320: decode to ADDu_NM using decoder 98
10483 // 320: }
10484 6, 6, // 324: case 0x6: {
10485 OPC_CheckPredicate, 4, // 326: check predicate 4
10486 OPC_Decode, 145, 23, 98, // 328: decode to SUB_NM using decoder 98
10487 // 328: }
10488 7, 6, // 332: case 0x7: {
10489 OPC_CheckPredicate, 4, // 334: check predicate 4
10490 OPC_Decode, 149, 23, 98, // 336: decode to SUBu_NM using decoder 98
10491 // 336: }
10492 8, 19, // 340: case 0x8: {
10493 OPC_SwitchField, 10, 1, // 342: switch Inst[10] {
10494 0, 6, // 345: case 0x0: {
10495 OPC_CheckPredicate, 4, // 347: check predicate 4
10496 OPC_Decode, 156, 18, 106, // 349: decode to MOVZ_NM using decoder 106
10497 // 349: }
10498 1, 0, // 353: case 0x1: {
10499 OPC_CheckPredicate, 4, // 355: check predicate 4
10500 OPC_Decode, 135, 18, 106, // 357: decode to MOVN_NM using decoder 106
10501 // 357: }
10502 // 357: } // switch Inst[10]
10503 // 357: }
10504 9, 6, // 361: case 0x9: {
10505 OPC_CheckPredicate, 4, // 363: check predicate 4
10506 OPC_Decode, 137, 7, 98, // 365: decode to AND_NM using decoder 98
10507 // 365: }
10508 10, 6, // 369: case 0xa: {
10509 OPC_CheckPredicate, 4, // 371: check predicate 4
10510 OPC_Decode, 198, 19, 98, // 373: decode to OR_NM using decoder 98
10511 // 373: }
10512 11, 6, // 377: case 0xb: {
10513 OPC_CheckPredicate, 4, // 379: check predicate 4
10514 OPC_Decode, 181, 19, 98, // 381: decode to NOR_NM using decoder 98
10515 // 381: }
10516 12, 6, // 385: case 0xc: {
10517 OPC_CheckPredicate, 4, // 387: check predicate 4
10518 OPC_Decode, 201, 24, 98, // 389: decode to XOR_NM using decoder 98
10519 // 389: }
10520 13, 6, // 393: case 0xd: {
10521 OPC_CheckPredicate, 4, // 395: check predicate 4
10522 OPC_Decode, 142, 22, 98, // 397: decode to SLT_NM using decoder 98
10523 // 397: }
10524 14, 29, // 401: case 0xe: {
10525 OPC_Scope, 21, // 403: try {
10526 OPC_SwitchField, 10, 11, // 405: switch Inst[20:10] {
10527 0, 7, // 408: case 0x0: {
10528 OPC_CheckPredicate, 4, // 410: check predicate 4
10529 OPC_Decode, 232, 12, 227, 1, // 412: decode to DVP_NM using decoder 227
10530 // 412: }
10531 1, 0, // 417: case 0x1: {
10532 OPC_CheckPredicate, 4, // 419: check predicate 4
10533 OPC_Decode, 254, 12, 227, 1, // 421: decode to EVP_NM using decoder 227
10534 // 421: }
10535 // 421: } // switch Inst[20:10]
10536 // 421: } else try {
10537 OPC_CheckPredicate, 4, // 426: check predicate 4
10538 OPC_Decode, 140, 22, 98, // 428: decode to SLTU_NM using decoder 98
10539 // 428: }
10540 // 428: }
10541 15, 0, // 432: case 0xf: {
10542 OPC_CheckPredicate, 4, // 434: check predicate 4
10543 OPC_Decode, 154, 22, 98, // 436: decode to SOV_NM using decoder 98
10544 // 436: }
10545 // 436: } // switch Inst[9:6]
10546 // 436: }
10547 24, 67, // 440: case 0x18: {
10548 OPC_SwitchField, 6, 4, // 442: switch Inst[9:6] {
10549 0, 6, // 445: case 0x0: {
10550 OPC_CheckPredicate, 4, // 447: check predicate 4
10551 OPC_Decode, 143, 19, 98, // 449: decode to MUL_NM using decoder 98
10552 // 449: }
10553 1, 6, // 453: case 0x1: {
10554 OPC_CheckPredicate, 4, // 455: check predicate 4
10555 OPC_Decode, 228, 18, 98, // 457: decode to MUH_NM using decoder 98
10556 // 457: }
10557 2, 6, // 461: case 0x2: {
10558 OPC_CheckPredicate, 4, // 463: check predicate 4
10559 OPC_Decode, 136, 19, 98, // 465: decode to MULU_NM using decoder 98
10560 // 465: }
10561 3, 6, // 469: case 0x3: {
10562 OPC_CheckPredicate, 4, // 471: check predicate 4
10563 OPC_Decode, 226, 18, 98, // 473: decode to MUHU_NM using decoder 98
10564 // 473: }
10565 4, 6, // 477: case 0x4: {
10566 OPC_CheckPredicate, 4, // 479: check predicate 4
10567 OPC_Decode, 253, 11, 98, // 481: decode to DIV_NM using decoder 98
10568 // 481: }
10569 5, 6, // 485: case 0x5: {
10570 OPC_CheckPredicate, 4, // 487: check predicate 4
10571 OPC_Decode, 225, 17, 98, // 489: decode to MOD_NM using decoder 98
10572 // 489: }
10573 6, 6, // 493: case 0x6: {
10574 OPC_CheckPredicate, 4, // 495: check predicate 4
10575 OPC_Decode, 251, 11, 98, // 497: decode to DIVU_NM using decoder 98
10576 // 497: }
10577 7, 0, // 501: case 0x7: {
10578 OPC_CheckPredicate, 4, // 503: check predicate 4
10579 OPC_Decode, 223, 17, 98, // 505: decode to MODU_NM using decoder 98
10580 // 505: }
10581 // 505: } // switch Inst[9:6]
10582 // 505: }
10583 31, 7, // 509: case 0x1f: {
10584 OPC_CheckPredicate, 4, // 511: check predicate 4
10585 OPC_Decode, 154, 13, 205, 3, // 513: decode to EXTW_NM using decoder 461
10586 // 513: }
10587 40, 51, // 518: case 0x28: {
10588 OPC_SwitchField, 6, 7, // 520: switch Inst[12:6] {
10589 15, 6, // 523: case 0xf: {
10590 OPC_CheckPredicate, 116, // 525: check predicate 116
10591 OPC_Decode, 196, 10, 124, // 527: decode to CRC32B_NM using decoder 124
10592 // 527: }
10593 31, 6, // 531: case 0x1f: {
10594 OPC_CheckPredicate, 116, // 533: check predicate 116
10595 OPC_Decode, 206, 10, 124, // 535: decode to CRC32H_NM using decoder 124
10596 // 535: }
10597 47, 6, // 539: case 0x2f: {
10598 OPC_CheckPredicate, 116, // 541: check predicate 116
10599 OPC_Decode, 208, 10, 124, // 543: decode to CRC32W_NM using decoder 124
10600 // 543: }
10601 79, 6, // 547: case 0x4f: {
10602 OPC_CheckPredicate, 116, // 549: check predicate 116
10603 OPC_Decode, 198, 10, 124, // 551: decode to CRC32CB_NM using decoder 124
10604 // 551: }
10605 95, 6, // 555: case 0x5f: {
10606 OPC_CheckPredicate, 116, // 557: check predicate 116
10607 OPC_Decode, 201, 10, 124, // 559: decode to CRC32CH_NM using decoder 124
10608 // 559: }
10609 111, 0, // 563: case 0x6f: {
10610 OPC_CheckPredicate, 116, // 565: check predicate 116
10611 OPC_Decode, 203, 10, 124, // 567: decode to CRC32CW_NM using decoder 124
10612 // 567: }
10613 // 567: } // switch Inst[12:6]
10614 // 567: }
10615 48, 21, // 571: case 0x30: {
10616 OPC_SwitchField, 6, 4, // 573: switch Inst[9:6] {
10617 0, 7, // 576: case 0x0: {
10618 OPC_CheckPredicate, 4, // 578: check predicate 4
10619 OPC_Decode, 159, 17, 206, 3, // 580: decode to MFC0_NM using decoder 462
10620 // 580: }
10621 1, 0, // 585: case 0x1: {
10622 OPC_CheckPredicate, 4, // 587: check predicate 4
10623 OPC_Decode, 185, 18, 206, 3, // 589: decode to MTC0_NM using decoder 462
10624 // 589: }
10625 // 589: } // switch Inst[9:6]
10626 // 589: }
10627 56, 21, // 594: case 0x38: {
10628 OPC_SwitchField, 6, 4, // 596: switch Inst[9:6] {
10629 0, 7, // 599: case 0x0: {
10630 OPC_CheckPredicate, 4, // 601: check predicate 4
10631 OPC_Decode, 169, 17, 206, 3, // 603: decode to MFHC0_NM using decoder 462
10632 // 603: }
10633 1, 0, // 608: case 0x1: {
10634 OPC_CheckPredicate, 4, // 610: check predicate 4
10635 OPC_Decode, 196, 18, 206, 3, // 612: decode to MTHC0_NM using decoder 462
10636 // 612: }
10637 // 612: } // switch Inst[9:6]
10638 // 612: }
10639 63, 0, // 617: case 0x3f: {
10640 OPC_SwitchField, 6, 10, // 619: switch Inst[15:6] {
10641 61, 7, // 622: case 0x3d: {
10642 OPC_CheckPredicate, 117, // 624: check predicate 117
10643 OPC_Decode, 216, 14, 207, 3, // 626: decode to GINVT_NM using decoder 463
10644 // 626: }
10645 125, 7, // 631: case 0x7d: {
10646 OPC_CheckPredicate, 117, // 633: check predicate 117
10647 OPC_Decode, 213, 14, 136, 1, // 635: decode to GINVI_NM using decoder 136
10648 // 635: }
10649 157, 2, 7, // 640: case 0x11d: {
10650 OPC_CheckPredicate, 4, // 643: check predicate 4
10651 OPC_Decode, 136, 12, 227, 1, // 645: decode to DI_NM using decoder 227
10652 // 645: }
10653 172, 2, 6, // 650: case 0x12c: {
10654 OPC_CheckPredicate, 4, // 653: check predicate 4
10655 OPC_Decode, 205, 9, 123, // 655: decode to CLO_NM using decoder 123
10656 // 655: }
10657 221, 2, 7, // 659: case 0x15d: {
10658 OPC_CheckPredicate, 4, // 662: check predicate 4
10659 OPC_Decode, 242, 12, 227, 1, // 664: decode to EI_NM using decoder 227
10660 // 664: }
10661 236, 2, 6, // 669: case 0x16c: {
10662 OPC_CheckPredicate, 4, // 672: check predicate 4
10663 OPC_Decode, 226, 9, 123, // 674: decode to CLZ_NM using decoder 123
10664 // 674: }
10665 141, 6, 7, // 678: case 0x30d: {
10666 OPC_CheckPredicate, 4, // 681: check predicate 4
10667 OPC_Decode, 183, 24, 132, 1, // 683: decode to WAIT_NM using decoder 132
10668 // 683: }
10669 133, 7, 6, // 688: case 0x385: {
10670 OPC_CheckPredicate, 4, // 691: check predicate 4
10671 OPC_Decode, 158, 20, 123, // 693: decode to RDPGPR_NM using decoder 123
10672 // 693: }
10673 141, 7, 10, // 697: case 0x38d: {
10674 OPC_CheckPredicate, 4, // 700: check predicate 4
10675 OPC_CheckField, 16, 1, 0, // 702: check Inst[16] == 0x0
10676 OPC_Decode, 239, 11, 10, // 706: decode to DERET_NM using decoder 10
10677 // 706: }
10678 197, 7, 6, // 710: case 0x3c5: {
10679 OPC_CheckPredicate, 4, // 713: check predicate 4
10680 OPC_Decode, 187, 24, 123, // 715: decode to WRPGPR_NM using decoder 123
10681 // 715: }
10682 205, 7, 0, // 719: case 0x3cd: {
10683 OPC_SwitchField, 16, 1, // 722: switch Inst[16] {
10684 0, 6, // 725: case 0x0: {
10685 OPC_CheckPredicate, 4, // 727: check predicate 4
10686 OPC_Decode, 250, 12, 10, // 729: decode to ERET_NM using decoder 10
10687 // 729: }
10688 1, 0, // 733: case 0x1: {
10689 OPC_CheckPredicate, 4, // 735: check predicate 4
10690 OPC_Decode, 247, 12, 10, // 737: decode to ERETNC_NM using decoder 10
10691 // 737: }
10692 // 737: } // switch Inst[16]
10693 // 737: }
10694 // 737: } // switch Inst[15:6]
10695 // 737: }
10696 // 737: } // switch Inst[5:0]
10697 // 737: }
10698 10, 21, // 741: case 0xa: {
10699 OPC_SwitchField, 25, 1, // 743: switch Inst[25] {
10700 0, 7, // 746: case 0x0: {
10701 OPC_CheckPredicate, 4, // 748: check predicate 4
10702 OPC_Decode, 223, 7, 208, 3, // 750: decode to BC_NM using decoder 464
10703 // 750: }
10704 1, 0, // 755: case 0x1: {
10705 OPC_CheckPredicate, 4, // 757: check predicate 4
10706 OPC_Decode, 187, 7, 208, 3, // 759: decode to BALC_NM using decoder 464
10707 // 759: }
10708 // 759: } // switch Inst[25]
10709 // 759: }
10710 16, 30, // 764: case 0x10: {
10711 OPC_SwitchField, 0, 2, // 766: switch Inst[1:0] {
10712 0, 7, // 769: case 0x0: {
10713 OPC_CheckPredicate, 4, // 771: check predicate 4
10714 OPC_Decode, 161, 6, 209, 3, // 773: decode to ADDIUGPW_NM using decoder 465
10715 // 773: }
10716 2, 7, // 778: case 0x2: {
10717 OPC_CheckPredicate, 4, // 780: check predicate 4
10718 OPC_Decode, 176, 16, 210, 3, // 782: decode to LWGP_NM using decoder 466
10719 // 782: }
10720 3, 0, // 787: case 0x3: {
10721 OPC_CheckPredicate, 4, // 789: check predicate 4
10722 OPC_Decode, 170, 23, 210, 3, // 791: decode to SWGP_NM using decoder 466
10723 // 791: }
10724 // 791: } // switch Inst[1:0]
10725 // 791: }
10726 17, 75, // 796: case 0x11: {
10727 OPC_SwitchField, 18, 3, // 798: switch Inst[20:18] {
10728 0, 7, // 801: case 0x0: {
10729 OPC_CheckPredicate, 4, // 803: check predicate 4
10730 OPC_Decode, 188, 15, 211, 3, // 805: decode to LBGP_NM using decoder 467
10731 // 805: }
10732 1, 7, // 810: case 0x1: {
10733 OPC_CheckPredicate, 4, // 812: check predicate 4
10734 OPC_Decode, 225, 20, 211, 3, // 814: decode to SBGP_NM using decoder 467
10735 // 814: }
10736 2, 7, // 819: case 0x2: {
10737 OPC_CheckPredicate, 4, // 821: check predicate 4
10738 OPC_Decode, 191, 15, 211, 3, // 823: decode to LBUGP_NM using decoder 467
10739 // 823: }
10740 3, 7, // 828: case 0x3: {
10741 OPC_CheckPredicate, 4, // 830: check predicate 4
10742 OPC_Decode, 160, 6, 212, 3, // 832: decode to ADDIUGPB_NM using decoder 468
10743 // 832: }
10744 4, 21, // 837: case 0x4: {
10745 OPC_SwitchField, 0, 1, // 839: switch Inst[0] {
10746 0, 7, // 842: case 0x0: {
10747 OPC_CheckPredicate, 4, // 844: check predicate 4
10748 OPC_Decode, 239, 15, 213, 3, // 846: decode to LHGP_NM using decoder 469
10749 // 846: }
10750 1, 0, // 851: case 0x1: {
10751 OPC_CheckPredicate, 4, // 853: check predicate 4
10752 OPC_Decode, 242, 15, 213, 3, // 855: decode to LHUGP_NM using decoder 469
10753 // 855: }
10754 // 855: } // switch Inst[0]
10755 // 855: }
10756 5, 0, // 860: case 0x5: {
10757 OPC_CheckPredicate, 4, // 862: check predicate 4
10758 OPC_CheckField, 0, 1, 0, // 864: check Inst[0] == 0x0
10759 OPC_Decode, 178, 21, 213, 3, // 868: decode to SHGP_NM using decoder 469
10760 // 868: }
10761 // 868: } // switch Inst[20:18]
10762 // 868: }
10763 18, 41, // 873: case 0x12: {
10764 OPC_SwitchField, 12, 4, // 875: switch Inst[15:12] {
10765 0, 6, // 878: case 0x0: {
10766 OPC_CheckPredicate, 4, // 880: check predicate 4
10767 OPC_Decode, 143, 15, 123, // 882: decode to JALRC_NM using decoder 123
10768 // 882: }
10769 1, 6, // 886: case 0x1: {
10770 OPC_CheckPredicate, 4, // 888: check predicate 4
10771 OPC_Decode, 140, 15, 123, // 890: decode to JALRCHB_NM using decoder 123
10772 // 890: }
10773 8, 0, // 894: case 0x8: {
10774 OPC_Scope, 11, // 896: try {
10775 OPC_CheckField, 21, 5, 0, // 898: check Inst[25:21] == 0x0
10776 OPC_CheckPredicate, 4, // 902: check predicate 4
10777 OPC_Decode, 248, 8, 136, 1, // 904: decode to BRSC_NM using decoder 136
10778 // 904: } else try {
10779 OPC_CheckPredicate, 4, // 909: check predicate 4
10780 OPC_Decode, 190, 7, 214, 3, // 911: decode to BALRSC_NM using decoder 470
10781 // 911: }
10782 // 911: }
10783 // 911: } // switch Inst[15:12]
10784 // 911: }
10785 32, 157, 2, // 916: case 0x20: {
10786 OPC_SwitchField, 12, 4, // 919: switch Inst[15:12] {
10787 0, 7, // 922: case 0x0: {
10788 OPC_CheckPredicate, 4, // 924: check predicate 4
10789 OPC_Decode, 195, 19, 215, 3, // 926: decode to ORI_NM using decoder 471
10790 // 926: }
10791 1, 7, // 931: case 0x1: {
10792 OPC_CheckPredicate, 4, // 933: check predicate 4
10793 OPC_Decode, 198, 24, 215, 3, // 935: decode to XORI_NM using decoder 471
10794 // 935: }
10795 2, 7, // 940: case 0x2: {
10796 OPC_CheckPredicate, 4, // 942: check predicate 4
10797 OPC_Decode, 134, 7, 215, 3, // 944: decode to ANDI_NM using decoder 471
10798 // 944: }
10799 3, 42, // 949: case 0x3: {
10800 OPC_SwitchField, 0, 2, // 951: switch Inst[1:0] {
10801 0, 11, // 954: case 0x0: {
10802 OPC_CheckPredicate, 4, // 956: check predicate 4
10803 OPC_CheckField, 20, 1, 0, // 958: check Inst[20] == 0x0
10804 OPC_Decode, 217, 20, 216, 3, // 962: decode to SAVE_NM using decoder 472
10805 // 962: }
10806 2, 11, // 967: case 0x2: {
10807 OPC_CheckPredicate, 4, // 969: check predicate 4
10808 OPC_CheckField, 20, 1, 0, // 971: check Inst[20] == 0x0
10809 OPC_Decode, 175, 20, 216, 3, // 975: decode to RESTORE_NM using decoder 472
10810 // 975: }
10811 3, 0, // 980: case 0x3: {
10812 OPC_CheckPredicate, 4, // 982: check predicate 4
10813 OPC_CheckField, 20, 1, 0, // 984: check Inst[20] == 0x0
10814 OPC_Decode, 174, 20, 216, 3, // 988: decode to RESTOREJRC_NM using decoder 472
10815 // 988: }
10816 // 988: } // switch Inst[1:0]
10817 // 988: }
10818 4, 7, // 993: case 0x4: {
10819 OPC_CheckPredicate, 4, // 995: check predicate 4
10820 OPC_Decode, 139, 22, 215, 3, // 997: decode to SLTI_NM using decoder 471
10821 // 997: }
10822 5, 7, // 1002: case 0x5: {
10823 OPC_CheckPredicate, 4, // 1004: check predicate 4
10824 OPC_Decode, 138, 22, 215, 3, // 1006: decode to SLTIU_NM using decoder 471
10825 // 1006: }
10826 6, 7, // 1011: case 0x6: {
10827 OPC_CheckPredicate, 4, // 1013: check predicate 4
10828 OPC_Decode, 166, 21, 215, 3, // 1015: decode to SEQI_NM using decoder 471
10829 // 1015: }
10830 8, 7, // 1020: case 0x8: {
10831 OPC_CheckPredicate, 4, // 1022: check predicate 4
10832 OPC_Decode, 162, 6, 215, 3, // 1024: decode to ADDIUNEG_NM using decoder 471
10833 // 1024: }
10834 12, 93, // 1029: case 0xc: {
10835 OPC_SwitchField, 5, 4, // 1031: switch Inst[8:5] {
10836 0, 61, // 1034: case 0x0: {
10837 OPC_Scope, 52, // 1036: try {
10838 OPC_SwitchField, 0, 5, // 1038: switch Inst[4:0] {
10839 0, 10, // 1041: case 0x0: {
10840 OPC_CheckPredicate, 4, // 1043: check predicate 4
10841 OPC_CheckField, 16, 10, 0, // 1045: check Inst[25:16] == 0x0
10842 OPC_Decode, 174, 19, 10, // 1049: decode to NOP32_NM using decoder 10
10843 // 1049: }
10844 3, 10, // 1053: case 0x3: {
10845 OPC_CheckPredicate, 4, // 1055: check predicate 4
10846 OPC_CheckField, 16, 10, 0, // 1057: check Inst[25:16] == 0x0
10847 OPC_Decode, 238, 12, 10, // 1061: decode to EHB_NM using decoder 10
10848 // 1061: }
10849 5, 10, // 1065: case 0x5: {
10850 OPC_CheckPredicate, 4, // 1067: check predicate 4
10851 OPC_CheckField, 16, 10, 0, // 1069: check Inst[25:16] == 0x0
10852 OPC_Decode, 209, 19, 10, // 1073: decode to PAUSE_NM using decoder 10
10853 // 1073: }
10854 6, 0, // 1077: case 0x6: {
10855 OPC_CheckPredicate, 4, // 1079: check predicate 4
10856 OPC_CheckField, 21, 5, 0, // 1081: check Inst[25:21] == 0x0
10857 OPC_Decode, 206, 23, 131, 1, // 1085: decode to SYNC_NM using decoder 131
10858 // 1085: }
10859 // 1085: } // switch Inst[4:0]
10860 // 1085: } else try {
10861 OPC_CheckPredicate, 4, // 1090: check predicate 4
10862 OPC_Decode, 134, 22, 217, 3, // 1092: decode to SLL_NM using decoder 473
10863 // 1092: }
10864 // 1092: }
10865 2, 7, // 1097: case 0x2: {
10866 OPC_CheckPredicate, 4, // 1099: check predicate 4
10867 OPC_Decode, 208, 22, 217, 3, // 1101: decode to SRL_NM using decoder 473
10868 // 1101: }
10869 4, 7, // 1106: case 0x4: {
10870 OPC_CheckPredicate, 4, // 1108: check predicate 4
10871 OPC_Decode, 183, 22, 217, 3, // 1110: decode to SRA_NM using decoder 473
10872 // 1110: }
10873 6, 0, // 1115: case 0x6: {
10874 OPC_CheckPredicate, 4, // 1117: check predicate 4
10875 OPC_Decode, 185, 20, 217, 3, // 1119: decode to ROTR_NM using decoder 473
10876 // 1119: }
10877 // 1119: } // switch Inst[8:5]
10878 // 1119: }
10879 13, 44, // 1124: case 0xd: {
10880 OPC_CheckField, 5, 1, 0, // 1126: check Inst[5] == 0x0
10881 OPC_CheckField, 11, 1, 0, // 1130: check Inst[11] == 0x0
10882 OPC_Scope, 27, // 1134: try {
10883 OPC_SwitchField, 0, 5, // 1136: switch Inst[4:0] {
10884 24, 10, // 1139: case 0x18: {
10885 OPC_CheckPredicate, 4, // 1141: check predicate 4
10886 OPC_CheckField, 6, 5, 8, // 1143: check Inst[10:6] == 0x8
10887 OPC_Decode, 131, 9, 123, // 1147: decode to BYTEREVW_NM using decoder 123
10888 // 1147: }
10889 31, 0, // 1151: case 0x1f: {
10890 OPC_CheckPredicate, 4, // 1153: check predicate 4
10891 OPC_CheckField, 6, 5, 0, // 1155: check Inst[10:6] == 0x0
10892 OPC_Decode, 163, 8, 123, // 1159: decode to BITREVW_NM using decoder 123
10893 // 1159: }
10894 // 1159: } // switch Inst[4:0]
10895 // 1159: } else try {
10896 OPC_CheckPredicate, 4, // 1163: check predicate 4
10897 OPC_Decode, 186, 20, 218, 3, // 1165: decode to ROTX_NM using decoder 474
10898 // 1165: }
10899 // 1165: }
10900 14, 15, // 1170: case 0xe: {
10901 OPC_CheckPredicate, 4, // 1172: check predicate 4
10902 OPC_CheckField, 11, 1, 0, // 1174: check Inst[11] == 0x0
10903 OPC_CheckField, 5, 1, 0, // 1178: check Inst[5] == 0x0
10904 OPC_Decode, 132, 15, 219, 3, // 1182: decode to INS_NM using decoder 475
10905 // 1182: }
10906 15, 0, // 1187: case 0xf: {
10907 OPC_CheckPredicate, 4, // 1189: check predicate 4
10908 OPC_CheckField, 11, 1, 0, // 1191: check Inst[11] == 0x0
10909 OPC_CheckField, 5, 1, 0, // 1195: check Inst[5] == 0x0
10910 OPC_Decode, 157, 13, 220, 3, // 1199: decode to EXT_NM using decoder 476
10911 // 1199: }
10912 // 1199: } // switch Inst[15:12]
10913 // 1199: }
10914 33, 97, // 1204: case 0x21: {
10915 OPC_SwitchField, 12, 4, // 1206: switch Inst[15:12] {
10916 0, 7, // 1209: case 0x0: {
10917 OPC_CheckPredicate, 4, // 1211: check predicate 4
10918 OPC_Decode, 201, 15, 221, 3, // 1213: decode to LB_NM using decoder 477
10919 // 1213: }
10920 1, 7, // 1218: case 0x1: {
10921 OPC_CheckPredicate, 4, // 1220: check predicate 4
10922 OPC_Decode, 229, 20, 221, 3, // 1222: decode to SB_NM using decoder 477
10923 // 1222: }
10924 2, 7, // 1227: case 0x2: {
10925 OPC_CheckPredicate, 4, // 1229: check predicate 4
10926 OPC_Decode, 196, 15, 221, 3, // 1231: decode to LBU_NM using decoder 477
10927 // 1231: }
10928 3, 20, // 1236: case 0x3: {
10929 OPC_Scope, 11, // 1238: try {
10930 OPC_CheckField, 21, 5, 31, // 1240: check Inst[25:21] == 0x1f
10931 OPC_CheckPredicate, 4, // 1244: check predicate 4
10932 OPC_Decode, 202, 23, 222, 3, // 1246: decode to SYNCI_NM using decoder 478
10933 // 1246: } else try {
10934 OPC_CheckPredicate, 4, // 1251: check predicate 4
10935 OPC_Decode, 141, 20, 223, 3, // 1253: decode to PREF_NM using decoder 479
10936 // 1253: }
10937 // 1253: }
10938 4, 7, // 1258: case 0x4: {
10939 OPC_CheckPredicate, 4, // 1260: check predicate 4
10940 OPC_Decode, 252, 15, 221, 3, // 1262: decode to LH_NM using decoder 477
10941 // 1262: }
10942 5, 7, // 1267: case 0x5: {
10943 OPC_CheckPredicate, 4, // 1269: check predicate 4
10944 OPC_Decode, 231, 21, 221, 3, // 1271: decode to SH_NM using decoder 477
10945 // 1271: }
10946 6, 7, // 1276: case 0x6: {
10947 OPC_CheckPredicate, 4, // 1278: check predicate 4
10948 OPC_Decode, 245, 15, 221, 3, // 1280: decode to LHU_NM using decoder 477
10949 // 1280: }
10950 8, 7, // 1285: case 0x8: {
10951 OPC_CheckPredicate, 4, // 1287: check predicate 4
10952 OPC_Decode, 209, 16, 221, 3, // 1289: decode to LW_NM using decoder 477
10953 // 1289: }
10954 9, 0, // 1294: case 0x9: {
10955 OPC_CheckPredicate, 4, // 1296: check predicate 4
10956 OPC_Decode, 196, 23, 221, 3, // 1298: decode to SW_NM using decoder 477
10957 // 1298: }
10958 // 1298: } // switch Inst[15:12]
10959 // 1298: }
10960 34, 30, // 1303: case 0x22: {
10961 OPC_SwitchField, 14, 2, // 1305: switch Inst[15:14] {
10962 0, 7, // 1308: case 0x0: {
10963 OPC_CheckPredicate, 4, // 1310: check predicate 4
10964 OPC_Decode, 229, 7, 224, 3, // 1312: decode to BEQC_NM using decoder 480
10965 // 1312: }
10966 2, 7, // 1317: case 0x2: {
10967 OPC_CheckPredicate, 4, // 1319: check predicate 4
10968 OPC_Decode, 245, 7, 224, 3, // 1321: decode to BGEC_NM using decoder 480
10969 // 1321: }
10970 3, 0, // 1326: case 0x3: {
10971 OPC_CheckPredicate, 4, // 1328: check predicate 4
10972 OPC_Decode, 251, 7, 224, 3, // 1330: decode to BGEUC_NM using decoder 480
10973 // 1330: }
10974 // 1330: } // switch Inst[15:14]
10975 // 1330: }
10976 41, 252, 1, // 1335: case 0x29: {
10977 OPC_SwitchField, 8, 4, // 1338: switch Inst[11:8] {
10978 0, 48, // 1341: case 0x0: {
10979 OPC_SwitchField, 12, 3, // 1343: switch Inst[14:12] {
10980 0, 7, // 1346: case 0x0: {
10981 OPC_CheckPredicate, 4, // 1348: check predicate 4
10982 OPC_Decode, 202, 15, 225, 3, // 1350: decode to LBs9_NM using decoder 481
10983 // 1350: }
10984 1, 7, // 1355: case 0x1: {
10985 OPC_CheckPredicate, 4, // 1357: check predicate 4
10986 OPC_Decode, 197, 15, 225, 3, // 1359: decode to LBUs9_NM using decoder 481
10987 // 1359: }
10988 2, 7, // 1364: case 0x2: {
10989 OPC_CheckPredicate, 4, // 1366: check predicate 4
10990 OPC_Decode, 253, 15, 225, 3, // 1368: decode to LHs9_NM using decoder 481
10991 // 1368: }
10992 3, 7, // 1373: case 0x3: {
10993 OPC_CheckPredicate, 4, // 1375: check predicate 4
10994 OPC_Decode, 246, 15, 225, 3, // 1377: decode to LHUs9_NM using decoder 481
10995 // 1377: }
10996 4, 0, // 1382: case 0x4: {
10997 OPC_CheckPredicate, 4, // 1384: check predicate 4
10998 OPC_Decode, 210, 16, 225, 3, // 1386: decode to LWs9_NM using decoder 481
10999 // 1386: }
11000 // 1386: } // switch Inst[14:12]
11001 // 1386: }
11002 1, 35, // 1391: case 0x1: {
11003 OPC_SwitchField, 12, 3, // 1393: switch Inst[14:12] {
11004 2, 7, // 1396: case 0x2: {
11005 OPC_CheckPredicate, 4, // 1398: check predicate 4
11006 OPC_Decode, 165, 24, 226, 3, // 1400: decode to UALH_NM using decoder 482
11007 // 1400: }
11008 5, 0, // 1405: case 0x5: {
11009 OPC_SwitchField, 0, 2, // 1407: switch Inst[1:0] {
11010 0, 7, // 1410: case 0x0: {
11011 OPC_CheckPredicate, 4, // 1412: check predicate 4
11012 OPC_Decode, 145, 16, 227, 3, // 1414: decode to LL_NM using decoder 483
11013 // 1414: }
11014 1, 0, // 1419: case 0x1: {
11015 OPC_CheckPredicate, 4, // 1421: check predicate 4
11016 OPC_Decode, 142, 16, 228, 3, // 1423: decode to LLWP_NM using decoder 484
11017 // 1423: }
11018 // 1423: } // switch Inst[1:0]
11019 // 1423: }
11020 // 1423: } // switch Inst[14:12]
11021 // 1423: }
11022 4, 7, // 1428: case 0x4: {
11023 OPC_CheckPredicate, 4, // 1430: check predicate 4
11024 OPC_Decode, 185, 16, 229, 3, // 1432: decode to LWM_NM using decoder 485
11025 // 1432: }
11026 5, 20, // 1437: case 0x5: {
11027 OPC_Scope, 11, // 1439: try {
11028 OPC_CheckField, 12, 3, 1, // 1441: check Inst[14:12] == 0x1
11029 OPC_CheckPredicate, 4, // 1445: check predicate 4
11030 OPC_Decode, 167, 24, 226, 3, // 1447: decode to UALW_NM using decoder 482
11031 // 1447: } else try {
11032 OPC_CheckPredicate, 4, // 1452: check predicate 4
11033 OPC_Decode, 166, 24, 229, 3, // 1454: decode to UALWM_NM using decoder 485
11034 // 1454: }
11035 // 1454: }
11036 8, 52, // 1459: case 0x8: {
11037 OPC_SwitchField, 12, 3, // 1461: switch Inst[14:12] {
11038 0, 7, // 1464: case 0x0: {
11039 OPC_CheckPredicate, 4, // 1466: check predicate 4
11040 OPC_Decode, 230, 20, 225, 3, // 1468: decode to SBs9_NM using decoder 481
11041 // 1468: }
11042 1, 20, // 1473: case 0x1: {
11043 OPC_Scope, 11, // 1475: try {
11044 OPC_CheckField, 21, 5, 31, // 1477: check Inst[25:21] == 0x1f
11045 OPC_CheckPredicate, 4, // 1481: check predicate 4
11046 OPC_Decode, 203, 23, 230, 3, // 1483: decode to SYNCIs9_NM using decoder 486
11047 // 1483: } else try {
11048 OPC_CheckPredicate, 4, // 1488: check predicate 4
11049 OPC_Decode, 143, 20, 231, 3, // 1490: decode to PREFs9_NM using decoder 487
11050 // 1490: }
11051 // 1490: }
11052 2, 7, // 1495: case 0x2: {
11053 OPC_CheckPredicate, 4, // 1497: check predicate 4
11054 OPC_Decode, 232, 21, 225, 3, // 1499: decode to SHs9_NM using decoder 481
11055 // 1499: }
11056 4, 0, // 1504: case 0x4: {
11057 OPC_CheckPredicate, 4, // 1506: check predicate 4
11058 OPC_Decode, 197, 23, 225, 3, // 1508: decode to SWs9_NM using decoder 481
11059 // 1508: }
11060 // 1508: } // switch Inst[14:12]
11061 // 1508: }
11062 9, 44, // 1513: case 0x9: {
11063 OPC_SwitchField, 12, 3, // 1515: switch Inst[14:12] {
11064 2, 7, // 1518: case 0x2: {
11065 OPC_CheckPredicate, 4, // 1520: check predicate 4
11066 OPC_Decode, 168, 24, 225, 3, // 1522: decode to UASH_NM using decoder 481
11067 // 1522: }
11068 3, 7, // 1527: case 0x3: {
11069 OPC_CheckPredicate, 4, // 1529: check predicate 4
11070 OPC_Decode, 153, 9, 231, 3, // 1531: decode to CACHE_NM using decoder 487
11071 // 1531: }
11072 5, 0, // 1536: case 0x5: {
11073 OPC_SwitchField, 0, 2, // 1538: switch Inst[1:0] {
11074 0, 7, // 1541: case 0x0: {
11075 OPC_CheckPredicate, 4, // 1543: check predicate 4
11076 OPC_Decode, 241, 20, 232, 3, // 1545: decode to SC_NM using decoder 488
11077 // 1545: }
11078 1, 0, // 1550: case 0x1: {
11079 OPC_CheckPredicate, 4, // 1552: check predicate 4
11080 OPC_Decode, 238, 20, 233, 3, // 1554: decode to SCWP_NM using decoder 489
11081 // 1554: }
11082 // 1554: } // switch Inst[1:0]
11083 // 1554: }
11084 // 1554: } // switch Inst[14:12]
11085 // 1554: }
11086 12, 7, // 1559: case 0xc: {
11087 OPC_CheckPredicate, 4, // 1561: check predicate 4
11088 OPC_Decode, 179, 23, 229, 3, // 1563: decode to SWM_NM using decoder 485
11089 // 1563: }
11090 13, 0, // 1568: case 0xd: {
11091 OPC_Scope, 11, // 1570: try {
11092 OPC_CheckField, 12, 3, 1, // 1572: check Inst[14:12] == 0x1
11093 OPC_CheckPredicate, 4, // 1576: check predicate 4
11094 OPC_Decode, 170, 24, 225, 3, // 1578: decode to UASW_NM using decoder 481
11095 // 1578: } else try {
11096 OPC_CheckPredicate, 4, // 1583: check predicate 4
11097 OPC_Decode, 169, 24, 229, 3, // 1585: decode to UASWM_NM using decoder 485
11098 // 1585: }
11099 // 1585: }
11100 // 1585: } // switch Inst[11:8]
11101 // 1585: }
11102 42, 30, // 1590: case 0x2a: {
11103 OPC_SwitchField, 14, 2, // 1592: switch Inst[15:14] {
11104 0, 7, // 1595: case 0x0: {
11105 OPC_CheckPredicate, 4, // 1597: check predicate 4
11106 OPC_Decode, 208, 8, 224, 3, // 1599: decode to BNEC_NM using decoder 480
11107 // 1599: }
11108 2, 7, // 1604: case 0x2: {
11109 OPC_CheckPredicate, 4, // 1606: check predicate 4
11110 OPC_Decode, 179, 8, 224, 3, // 1608: decode to BLTC_NM using decoder 480
11111 // 1608: }
11112 3, 0, // 1613: case 0x3: {
11113 OPC_CheckPredicate, 4, // 1615: check predicate 4
11114 OPC_Decode, 185, 8, 224, 3, // 1617: decode to BLTUC_NM using decoder 480
11115 // 1617: }
11116 // 1617: } // switch Inst[15:14]
11117 // 1617: }
11118 50, 75, // 1622: case 0x32: {
11119 OPC_SwitchField, 18, 3, // 1624: switch Inst[20:18] {
11120 0, 7, // 1627: case 0x0: {
11121 OPC_CheckPredicate, 4, // 1629: check predicate 4
11122 OPC_Decode, 230, 7, 234, 3, // 1631: decode to BEQIC_NM using decoder 490
11123 // 1631: }
11124 1, 7, // 1636: case 0x1: {
11125 OPC_CheckPredicate, 4, // 1638: check predicate 4
11126 OPC_Decode, 191, 7, 235, 3, // 1640: decode to BBEQZC_NM using decoder 491
11127 // 1640: }
11128 2, 7, // 1645: case 0x2: {
11129 OPC_CheckPredicate, 4, // 1647: check predicate 4
11130 OPC_Decode, 246, 7, 234, 3, // 1649: decode to BGEIC_NM using decoder 490
11131 // 1649: }
11132 3, 7, // 1654: case 0x3: {
11133 OPC_CheckPredicate, 4, // 1656: check predicate 4
11134 OPC_Decode, 247, 7, 234, 3, // 1658: decode to BGEIUC_NM using decoder 490
11135 // 1658: }
11136 4, 7, // 1663: case 0x4: {
11137 OPC_CheckPredicate, 4, // 1665: check predicate 4
11138 OPC_Decode, 217, 8, 234, 3, // 1667: decode to BNEIC_NM using decoder 490
11139 // 1667: }
11140 5, 7, // 1672: case 0x5: {
11141 OPC_CheckPredicate, 4, // 1674: check predicate 4
11142 OPC_Decode, 196, 7, 235, 3, // 1676: decode to BBNEZC_NM using decoder 491
11143 // 1676: }
11144 6, 7, // 1681: case 0x6: {
11145 OPC_CheckPredicate, 4, // 1683: check predicate 4
11146 OPC_Decode, 180, 8, 234, 3, // 1685: decode to BLTIC_NM using decoder 490
11147 // 1685: }
11148 7, 0, // 1690: case 0x7: {
11149 OPC_CheckPredicate, 4, // 1692: check predicate 4
11150 OPC_Decode, 181, 8, 234, 3, // 1694: decode to BLTIUC_NM using decoder 490
11151 // 1694: }
11152 // 1694: } // switch Inst[20:18]
11153 // 1694: }
11154 56, 0, // 1699: case 0x38: {
11155 OPC_SwitchField, 1, 1, // 1701: switch Inst[1] {
11156 0, 7, // 1704: case 0x0: {
11157 OPC_CheckPredicate, 4, // 1706: check predicate 4
11158 OPC_Decode, 152, 16, 236, 3, // 1708: decode to LUI_NM using decoder 492
11159 // 1708: }
11160 1, 0, // 1713: case 0x1: {
11161 OPC_CheckPredicate, 4, // 1715: check predicate 4
11162 OPC_Decode, 251, 6, 236, 3, // 1717: decode to ALUIPC_NM using decoder 492
11163 // 1717: }
11164 // 1717: } // switch Inst[1]
11165 // 1717: }
11166 // 1717: } // switch Inst[31:26]
11167};
11168static const uint8_t DecoderTableNanoMips48[81] = {
11169 OPC_SwitchField, 32, 5, // 0: switch Inst[36:32] {
11170 0, 11, // 3: case 0x0: {
11171 OPC_CheckPredicate, 4, // 5: check predicate 4
11172 OPC_CheckField, 42, 6, 24, // 7: check Inst[47:42] == 0x18
11173 OPC_Decode, 134, 16, 237, 3, // 11: decode to LI48_NM using decoder 493
11174 // 11: }
11175 1, 11, // 16: case 0x1: {
11176 OPC_CheckPredicate, 4, // 18: check predicate 4
11177 OPC_CheckField, 42, 6, 24, // 20: check Inst[47:42] == 0x18
11178 OPC_Decode, 158, 6, 238, 3, // 24: decode to ADDIU48_NM using decoder 494
11179 // 24: }
11180 2, 11, // 29: case 0x2: {
11181 OPC_CheckPredicate, 4, // 31: check predicate 4
11182 OPC_CheckField, 42, 6, 24, // 33: check Inst[47:42] == 0x18
11183 OPC_Decode, 159, 6, 237, 3, // 37: decode to ADDIUGP48_NM using decoder 493
11184 // 37: }
11185 3, 11, // 42: case 0x3: {
11186 OPC_CheckPredicate, 4, // 44: check predicate 4
11187 OPC_CheckField, 42, 6, 24, // 46: check Inst[47:42] == 0x18
11188 OPC_Decode, 182, 15, 237, 3, // 50: decode to LAPC48_NM using decoder 493
11189 // 50: }
11190 11, 11, // 55: case 0xb: {
11191 OPC_CheckPredicate, 4, // 57: check predicate 4
11192 OPC_CheckField, 42, 6, 24, // 59: check Inst[47:42] == 0x18
11193 OPC_Decode, 188, 16, 237, 3, // 63: decode to LWPC_NM using decoder 493
11194 // 63: }
11195 15, 0, // 68: case 0xf: {
11196 OPC_CheckPredicate, 4, // 70: check predicate 4
11197 OPC_CheckField, 42, 6, 24, // 72: check Inst[47:42] == 0x18
11198 OPC_Decode, 180, 23, 237, 3, // 76: decode to SWPC_NM using decoder 493
11199 // 76: }
11200 // 76: } // switch Inst[36:32]
11201};
11202// Handling 495 cases.
11203template <typename InsnType>
11204static DecodeStatus decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
11205 DecodeComplete = true;
11206 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
11207 TmpType tmp;
11208 switch (Idx) {
11209 default: llvm_unreachable("Invalid decoder index!");
11210 case 0:
11211 tmp = fieldFromInstruction(insn, 0, 11);
11212 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11213 return S;
11214 case 1:
11215 tmp = fieldFromInstruction(insn, 8, 3);
11216 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11217 tmp = fieldFromInstruction(insn, 0, 8);
11218 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11219 return S;
11220 case 2:
11221 tmp = fieldFromInstruction(insn, 8, 3);
11222 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11223 tmp = fieldFromInstruction(insn, 8, 3);
11224 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11225 tmp = fieldFromInstruction(insn, 0, 8);
11226 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11227 return S;
11228 case 3:
11229 tmp = fieldFromInstruction(insn, 8, 3);
11230 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11231 tmp = fieldFromInstruction(insn, 0, 8);
11232 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11233 return S;
11234 case 4:
11235 tmp = fieldFromInstruction(insn, 0, 8);
11236 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11237 return S;
11238 case 5:
11239 tmp = 0x0;
11240 tmp |= fieldFromInstruction(insn, 3, 2) << 3;
11241 tmp |= fieldFromInstruction(insn, 5, 3);
11242 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11243 tmp = fieldFromInstruction(insn, 0, 3);
11244 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11245 return S;
11246 case 6:
11247 tmp = fieldFromInstruction(insn, 4, 4);
11248 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11249 tmp = fieldFromInstruction(insn, 0, 4);
11250 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11251 return S;
11252 case 7:
11253 tmp = fieldFromInstruction(insn, 8, 3);
11254 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11255 tmp = fieldFromInstruction(insn, 0, 8);
11256 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11257 return S;
11258 case 8:
11259 tmp = fieldFromInstruction(insn, 2, 3);
11260 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11261 tmp = fieldFromInstruction(insn, 8, 3);
11262 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11263 tmp = fieldFromInstruction(insn, 5, 3);
11264 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11265 return S;
11266 case 9:
11267 tmp = fieldFromInstruction(insn, 8, 3);
11268 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11269 return S;
11270 case 10:
11271 return S;
11272 case 11:
11273 tmp = fieldFromInstruction(insn, 8, 3);
11274 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11275 tmp = fieldFromInstruction(insn, 5, 3);
11276 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11277 return S;
11278 case 12:
11279 tmp = fieldFromInstruction(insn, 8, 3);
11280 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11281 tmp = fieldFromInstruction(insn, 8, 3);
11282 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11283 tmp = fieldFromInstruction(insn, 5, 3);
11284 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11285 return S;
11286 case 13:
11287 tmp = fieldFromInstruction(insn, 8, 3);
11288 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11289 tmp = fieldFromInstruction(insn, 8, 3);
11290 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11291 return S;
11292 case 14:
11293 tmp = fieldFromInstruction(insn, 7, 3);
11294 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11295 tmp = fieldFromInstruction(insn, 1, 3);
11296 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11297 tmp = fieldFromInstruction(insn, 4, 3);
11298 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11299 return S;
11300 case 15:
11301 tmp = fieldFromInstruction(insn, 7, 3);
11302 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11303 tmp = fieldFromInstruction(insn, 4, 3);
11304 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11305 tmp = fieldFromInstruction(insn, 0, 4);
11306 if (!Check(S, DecodeLBU16Offset(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11307 return S;
11308 case 16:
11309 tmp = fieldFromInstruction(insn, 5, 5);
11310 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11311 tmp = fieldFromInstruction(insn, 0, 5);
11312 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11313 return S;
11314 case 17:
11315 tmp = fieldFromInstruction(insn, 7, 3);
11316 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11317 tmp = fieldFromInstruction(insn, 4, 3);
11318 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11319 tmp = fieldFromInstruction(insn, 1, 3);
11320 if (!Check(S, DecodePOOL16BEncodedField(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11321 return S;
11322 case 18:
11323 tmp = fieldFromInstruction(insn, 7, 3);
11324 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11325 tmp = fieldFromInstruction(insn, 4, 3);
11326 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11327 tmp = fieldFromInstruction(insn, 0, 4);
11328 if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11329 return S;
11330 case 19:
11331 tmp = fieldFromInstruction(insn, 7, 3);
11332 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11333 tmp = fieldFromInstruction(insn, 4, 3);
11334 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11335 tmp = fieldFromInstruction(insn, 0, 4);
11336 if (!Check(S, DecodeANDI16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11337 return S;
11338 case 20:
11339 tmp = fieldFromInstruction(insn, 3, 3);
11340 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11341 tmp = fieldFromInstruction(insn, 0, 3);
11342 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11343 return S;
11344 case 21:
11345 tmp = fieldFromInstruction(insn, 3, 3);
11346 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11347 tmp = fieldFromInstruction(insn, 0, 3);
11348 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11349 tmp = fieldFromInstruction(insn, 3, 3);
11350 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11351 return S;
11352 case 22:
11353 tmp = fieldFromInstruction(insn, 4, 2);
11354 if (!Check(S, DecodeRegListOperand16(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11355 if (!Check(Out&: S, In: DecodeFixedPtrRegister<29>(Inst&: MI, Decoder)))
11356 return MCDisassembler::Fail;
11357 tmp = fieldFromInstruction(insn, 0, 4);
11358 if (!Check(S, DecodeSImmWithOffsetAndScale<4, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11359 return S;
11360 case 23:
11361 tmp = fieldFromInstruction(insn, 0, 5);
11362 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11363 return S;
11364 case 24:
11365 tmp = fieldFromInstruction(insn, 0, 4);
11366 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11367 return S;
11368 case 25:
11369 tmp = fieldFromInstruction(insn, 0, 5);
11370 if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11371 return S;
11372 case 26:
11373 tmp = fieldFromInstruction(insn, 5, 5);
11374 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11375 if (!Check(Out&: S, In: DecodeFixedPtrRegister<29>(Inst&: MI, Decoder)))
11376 return MCDisassembler::Fail;
11377 tmp = fieldFromInstruction(insn, 0, 5);
11378 if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11379 return S;
11380 case 27:
11381 tmp = fieldFromInstruction(insn, 5, 5);
11382 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11383 tmp = fieldFromInstruction(insn, 5, 5);
11384 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11385 tmp = fieldFromInstruction(insn, 1, 4);
11386 if (!Check(S, DecodeSImmWithOffsetAndScale<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11387 return S;
11388 case 28:
11389 tmp = fieldFromInstruction(insn, 1, 9);
11390 if (!Check(S, DecodeSimm9SP(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11391 return S;
11392 case 29:
11393 tmp = fieldFromInstruction(insn, 7, 3);
11394 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11395 if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder)))
11396 return MCDisassembler::Fail;
11397 tmp = fieldFromInstruction(insn, 0, 7);
11398 if (!Check(S, DecodeSImmWithOffsetAndScale<7, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11399 return S;
11400 case 30:
11401 tmp = fieldFromInstruction(insn, 7, 3);
11402 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11403 tmp = fieldFromInstruction(insn, 4, 3);
11404 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11405 tmp = fieldFromInstruction(insn, 0, 4);
11406 if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11407 return S;
11408 case 31:
11409 tmp = fieldFromInstruction(insn, 7, 3);
11410 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11411 tmp = fieldFromInstruction(insn, 4, 3);
11412 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11413 tmp = fieldFromInstruction(insn, 1, 3);
11414 if (!Check(S, DecodeAddiur2Simm7(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11415 return S;
11416 case 32:
11417 tmp = fieldFromInstruction(insn, 7, 3);
11418 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11419 tmp = fieldFromInstruction(insn, 1, 6);
11420 if (!Check(S, DecodeUImmWithOffsetAndScale<6, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11421 return S;
11422 case 33:
11423 if (!Check(S, DecodeMovePOperands(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11424 return S;
11425 case 34:
11426 tmp = fieldFromInstruction(insn, 7, 3);
11427 if (!Check(S, DecodeGPRMM16ZeroRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11428 tmp = fieldFromInstruction(insn, 4, 3);
11429 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11430 tmp = fieldFromInstruction(insn, 0, 4);
11431 if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11432 return S;
11433 case 35:
11434 tmp = fieldFromInstruction(insn, 7, 3);
11435 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11436 tmp = fieldFromInstruction(insn, 0, 7);
11437 if (!Check(S, DecodeBranchTarget7MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11438 return S;
11439 case 36:
11440 tmp = fieldFromInstruction(insn, 7, 3);
11441 if (!Check(S, DecodeGPRMM16ZeroRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11442 tmp = fieldFromInstruction(insn, 4, 3);
11443 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11444 tmp = fieldFromInstruction(insn, 0, 4);
11445 if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11446 return S;
11447 case 37:
11448 tmp = fieldFromInstruction(insn, 0, 10);
11449 if (!Check(S, DecodeBranchTarget10MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11450 return S;
11451 case 38:
11452 tmp = fieldFromInstruction(insn, 7, 3);
11453 if (!Check(S, DecodeGPRMM16ZeroRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11454 tmp = fieldFromInstruction(insn, 4, 3);
11455 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11456 tmp = fieldFromInstruction(insn, 0, 4);
11457 if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11458 return S;
11459 case 39:
11460 tmp = fieldFromInstruction(insn, 7, 3);
11461 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11462 tmp = fieldFromInstruction(insn, 0, 7);
11463 if (!Check(S, DecodeLi16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11464 return S;
11465 case 40:
11466 tmp = fieldFromInstruction(insn, 1, 3);
11467 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11468 tmp = fieldFromInstruction(insn, 7, 3);
11469 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11470 tmp = fieldFromInstruction(insn, 4, 3);
11471 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11472 return S;
11473 case 41:
11474 tmp = fieldFromInstruction(insn, 7, 3);
11475 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11476 tmp = fieldFromInstruction(insn, 4, 3);
11477 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11478 return S;
11479 case 42:
11480 tmp = fieldFromInstruction(insn, 7, 3);
11481 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11482 tmp = fieldFromInstruction(insn, 4, 3);
11483 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11484 tmp = fieldFromInstruction(insn, 7, 3);
11485 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11486 return S;
11487 case 43:
11488 tmp = fieldFromInstruction(insn, 8, 2);
11489 if (!Check(S, DecodeRegListOperand16(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11490 if (!Check(Out&: S, In: DecodeFixedPtrRegister<29>(Inst&: MI, Decoder)))
11491 return MCDisassembler::Fail;
11492 tmp = fieldFromInstruction(insn, 4, 4);
11493 if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11494 return S;
11495 case 44:
11496 tmp = fieldFromInstruction(insn, 5, 5);
11497 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11498 return S;
11499 case 45:
11500 tmp = fieldFromInstruction(insn, 5, 5);
11501 if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11502 return S;
11503 case 46:
11504 tmp = fieldFromInstruction(insn, 6, 4);
11505 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11506 return S;
11507 case 47:
11508 tmp = fieldFromInstruction(insn, 0, 2);
11509 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11510 return S;
11511 case 48:
11512 tmp = fieldFromInstruction(insn, 0, 3);
11513 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11514 return S;
11515 case 49:
11516 tmp = fieldFromInstruction(insn, 5, 5);
11517 if (!Check(S, DecodeGPR32NONZERORegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11518 tmp = fieldFromInstruction(insn, 0, 5);
11519 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11520 return S;
11521 case 50:
11522 tmp = fieldFromInstruction(insn, 7, 3);
11523 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11524 tmp = fieldFromInstruction(insn, 4, 3);
11525 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11526 tmp = fieldFromInstruction(insn, 0, 4) << 2;
11527 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11528 return S;
11529 case 51:
11530 tmp = 0x0;
11531 tmp |= fieldFromInstruction(insn, 0, 1) << 10;
11532 tmp |= fieldFromInstruction(insn, 1, 9) << 1;
11533 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11534 return S;
11535 case 52:
11536 tmp = fieldFromInstruction(insn, 4, 4) << 4;
11537 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11538 tmp = 0x0;
11539 tmp |= fieldFromInstruction(insn, 0, 4);
11540 tmp |= fieldFromInstruction(insn, 9, 1) << 4;
11541 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11542 return S;
11543 case 53:
11544 tmp = fieldFromInstruction(insn, 7, 3);
11545 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11546 tmp = fieldFromInstruction(insn, 4, 3);
11547 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11548 tmp = fieldFromInstruction(insn, 0, 3);
11549 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11550 return S;
11551 case 54:
11552 tmp = fieldFromInstruction(insn, 5, 5);
11553 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11554 if (!Check(Out&: S, In: DecodeFixedPtrRegister<29>(Inst&: MI, Decoder)))
11555 return MCDisassembler::Fail;
11556 tmp = fieldFromInstruction(insn, 0, 5) << 2;
11557 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11558 return S;
11559 case 55:
11560 tmp = 0x0;
11561 tmp |= fieldFromInstruction(insn, 5, 3);
11562 tmp |= fieldFromInstruction(insn, 9, 1) << 4;
11563 if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11564 tmp = 0x0;
11565 tmp |= fieldFromInstruction(insn, 5, 3);
11566 tmp |= fieldFromInstruction(insn, 9, 1) << 4;
11567 if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11568 tmp = 0x0;
11569 tmp |= fieldFromInstruction(insn, 0, 3);
11570 tmp |= fieldFromInstruction(insn, 4, 1) << 4;
11571 if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11572 return S;
11573 case 56:
11574 tmp = fieldFromInstruction(insn, 7, 3);
11575 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11576 tmp = fieldFromInstruction(insn, 4, 3);
11577 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11578 return S;
11579 case 57:
11580 tmp = fieldFromInstruction(insn, 7, 3);
11581 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11582 tmp = fieldFromInstruction(insn, 4, 3);
11583 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11584 tmp = fieldFromInstruction(insn, 7, 3);
11585 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11586 return S;
11587 case 58:
11588 tmp = fieldFromInstruction(insn, 1, 3);
11589 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11590 tmp = fieldFromInstruction(insn, 7, 3);
11591 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11592 tmp = fieldFromInstruction(insn, 4, 3);
11593 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11594 return S;
11595 case 59:
11596 tmp = fieldFromInstruction(insn, 7, 3);
11597 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11598 if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder)))
11599 return MCDisassembler::Fail;
11600 tmp = fieldFromInstruction(insn, 0, 7) << 2;
11601 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11602 return S;
11603 case 60:
11604 tmp = fieldFromInstruction(insn, 7, 3);
11605 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11606 tmp = fieldFromInstruction(insn, 4, 3);
11607 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11608 tmp = fieldFromInstruction(insn, 0, 2);
11609 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11610 return S;
11611 case 61:
11612 tmp = fieldFromInstruction(insn, 7, 3);
11613 if (!Check(S, DecodeGPRNM3ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11614 tmp = fieldFromInstruction(insn, 4, 3);
11615 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11616 tmp = fieldFromInstruction(insn, 0, 2);
11617 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11618 return S;
11619 case 62:
11620 tmp = fieldFromInstruction(insn, 7, 3);
11621 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11622 tmp = fieldFromInstruction(insn, 0, 6) << 2;
11623 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11624 return S;
11625 case 63:
11626 tmp = 0x0;
11627 tmp |= fieldFromInstruction(insn, 5, 3);
11628 tmp |= fieldFromInstruction(insn, 9, 1) << 4;
11629 if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11630 tmp = 0x0;
11631 tmp |= fieldFromInstruction(insn, 0, 3);
11632 tmp |= fieldFromInstruction(insn, 4, 1) << 4;
11633 if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11634 tmp = 0x0;
11635 tmp |= fieldFromInstruction(insn, 3, 1) << 3;
11636 tmp |= fieldFromInstruction(insn, 8, 1) << 2;
11637 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11638 return S;
11639 case 64:
11640 tmp = fieldFromInstruction(insn, 7, 3);
11641 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11642 tmp = fieldFromInstruction(insn, 4, 3);
11643 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11644 tmp = fieldFromInstruction(insn, 1, 2) << 1;
11645 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11646 return S;
11647 case 65:
11648 tmp = fieldFromInstruction(insn, 7, 3);
11649 if (!Check(S, DecodeGPRNM3ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11650 tmp = fieldFromInstruction(insn, 4, 3);
11651 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11652 tmp = fieldFromInstruction(insn, 1, 2) << 1;
11653 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11654 return S;
11655 case 66:
11656 tmp = fieldFromInstruction(insn, 7, 3);
11657 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11658 tmp = fieldFromInstruction(insn, 4, 3);
11659 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11660 tmp = fieldFromInstruction(insn, 0, 3) << 2;
11661 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11662 return S;
11663 case 67:
11664 tmp = fieldFromInstruction(insn, 5, 5);
11665 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11666 tmp = fieldFromInstruction(insn, 5, 5);
11667 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11668 tmp = 0x0;
11669 tmp |= fieldFromInstruction(insn, 0, 3);
11670 tmp |= fieldFromInstruction(insn, 4, 1) << 3;
11671 if (!Check(S, DecodeSImmWithOffsetAndScale<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11672 return S;
11673 case 68:
11674 tmp = fieldFromInstruction(insn, 7, 3);
11675 if (!Check(S, DecodeGPRNM3ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11676 tmp = fieldFromInstruction(insn, 4, 3);
11677 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11678 tmp = fieldFromInstruction(insn, 0, 4) << 2;
11679 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11680 return S;
11681 case 69:
11682 tmp = fieldFromInstruction(insn, 7, 3);
11683 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11684 tmp = 0x0;
11685 tmp |= fieldFromInstruction(insn, 0, 1) << 7;
11686 tmp |= fieldFromInstruction(insn, 1, 6) << 1;
11687 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11688 return S;
11689 case 70:
11690 tmp = fieldFromInstruction(insn, 1, 3);
11691 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11692 tmp = fieldFromInstruction(insn, 4, 3);
11693 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11694 tmp = fieldFromInstruction(insn, 7, 3);
11695 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11696 return S;
11697 case 71:
11698 tmp = 0x0;
11699 tmp |= fieldFromInstruction(insn, 3, 1) << 1;
11700 tmp |= fieldFromInstruction(insn, 8, 1);
11701 if (!Check(S, DecodeGPRNM2R1RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11702 tmp = 0x0;
11703 tmp |= fieldFromInstruction(insn, 0, 3);
11704 tmp |= fieldFromInstruction(insn, 4, 1) << 4;
11705 if (!Check(S, DecodeGPRNM4ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11706 tmp = 0x0;
11707 tmp |= fieldFromInstruction(insn, 5, 3);
11708 tmp |= fieldFromInstruction(insn, 9, 1) << 4;
11709 if (!Check(S, DecodeGPRNM4ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11710 return S;
11711 case 72:
11712 tmp = fieldFromInstruction(insn, 7, 3);
11713 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11714 tmp = fieldFromInstruction(insn, 0, 7);
11715 if (!Check(S, DecodeLi16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11716 return S;
11717 case 73:
11718 tmp = fieldFromInstruction(insn, 7, 3);
11719 if (!Check(S, DecodeGPRNM3ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11720 if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder)))
11721 return MCDisassembler::Fail;
11722 tmp = fieldFromInstruction(insn, 0, 7) << 2;
11723 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11724 return S;
11725 case 74:
11726 tmp = fieldFromInstruction(insn, 4, 1);
11727 if (!Check(S, DecodeGPRNMRARegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11728 tmp = fieldFromInstruction(insn, 5, 5);
11729 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11730 return S;
11731 case 75:
11732 tmp = fieldFromInstruction(insn, 7, 3);
11733 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11734 tmp = fieldFromInstruction(insn, 4, 3);
11735 if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11736 tmp = fieldFromInstruction(insn, 0, 4);
11737 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11738 return S;
11739 case 76:
11740 tmp = 0x0;
11741 tmp |= fieldFromInstruction(insn, 5, 3);
11742 tmp |= fieldFromInstruction(insn, 9, 1) << 4;
11743 if (!Check(S, DecodeGPRNM4ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11744 tmp = 0x0;
11745 tmp |= fieldFromInstruction(insn, 0, 3);
11746 tmp |= fieldFromInstruction(insn, 4, 1) << 4;
11747 if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11748 tmp = 0x0;
11749 tmp |= fieldFromInstruction(insn, 3, 1) << 3;
11750 tmp |= fieldFromInstruction(insn, 8, 1) << 2;
11751 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11752 return S;
11753 case 77:
11754 tmp = 0x0;
11755 tmp |= fieldFromInstruction(insn, 0, 3);
11756 tmp |= fieldFromInstruction(insn, 4, 1) << 4;
11757 if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11758 tmp = 0x0;
11759 tmp |= fieldFromInstruction(insn, 5, 3);
11760 tmp |= fieldFromInstruction(insn, 9, 1) << 4;
11761 if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11762 tmp = 0x0;
11763 tmp |= fieldFromInstruction(insn, 3, 1) << 1;
11764 tmp |= fieldFromInstruction(insn, 8, 1);
11765 if (!Check(S, DecodeGPRNM2R1RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11766 return S;
11767 case 78:
11768 tmp = fieldFromInstruction(insn, 8, 3);
11769 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11770 tmp = 0x0;
11771 tmp |= fieldFromInstruction(insn, 0, 5);
11772 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
11773 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
11774 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11775 return S;
11776 case 79:
11777 tmp = 0x0;
11778 tmp |= fieldFromInstruction(insn, 0, 5);
11779 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
11780 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
11781 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11782 return S;
11783 case 80:
11784 tmp = fieldFromInstruction(insn, 8, 3);
11785 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11786 tmp = 0x0;
11787 tmp |= fieldFromInstruction(insn, 0, 5);
11788 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
11789 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
11790 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11791 return S;
11792 case 81:
11793 tmp = fieldFromInstruction(insn, 8, 3);
11794 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11795 tmp = fieldFromInstruction(insn, 5, 3);
11796 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11797 tmp = 0x0;
11798 tmp |= fieldFromInstruction(insn, 21, 1) << 5;
11799 tmp |= fieldFromInstruction(insn, 22, 5);
11800 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11801 return S;
11802 case 82:
11803 tmp = 0x0;
11804 tmp |= fieldFromInstruction(insn, 0, 5);
11805 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
11806 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
11807 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11808 return S;
11809 case 83:
11810 if (!Check(S, DecodeFIXMEInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11811 return S;
11812 case 84:
11813 tmp = fieldFromInstruction(insn, 8, 3);
11814 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11815 tmp = 0x0;
11816 tmp |= fieldFromInstruction(insn, 0, 5);
11817 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
11818 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
11819 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11820 return S;
11821 case 85:
11822 tmp = fieldFromInstruction(insn, 16, 5);
11823 if (!Check(S, DecodeCOP3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11824 tmp = fieldFromInstruction(insn, 21, 5);
11825 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11826 tmp = fieldFromInstruction(insn, 0, 16);
11827 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11828 return S;
11829 case 86:
11830 tmp = fieldFromInstruction(insn, 16, 5);
11831 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11832 tmp = fieldFromInstruction(insn, 0, 16);
11833 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11834 return S;
11835 case 87:
11836 tmp = fieldFromInstruction(insn, 11, 5);
11837 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11838 tmp = fieldFromInstruction(insn, 21, 5);
11839 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11840 tmp = fieldFromInstruction(insn, 16, 5);
11841 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11842 return S;
11843 case 88:
11844 tmp = fieldFromInstruction(insn, 21, 5);
11845 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11846 return S;
11847 case 89:
11848 tmp = fieldFromInstruction(insn, 11, 5);
11849 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11850 tmp = fieldFromInstruction(insn, 21, 5);
11851 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11852 return S;
11853 case 90:
11854 tmp = fieldFromInstruction(insn, 11, 5);
11855 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11856 tmp = fieldFromInstruction(insn, 21, 5);
11857 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11858 return S;
11859 case 91:
11860 tmp = fieldFromInstruction(insn, 16, 5);
11861 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11862 tmp = fieldFromInstruction(insn, 21, 5);
11863 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11864 tmp = fieldFromInstruction(insn, 6, 10);
11865 if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11866 return S;
11867 case 92:
11868 tmp = fieldFromInstruction(insn, 16, 5);
11869 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11870 tmp = fieldFromInstruction(insn, 21, 5);
11871 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11872 tmp = fieldFromInstruction(insn, 6, 5);
11873 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11874 tmp = fieldFromInstruction(insn, 11, 5);
11875 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11876 return S;
11877 case 93:
11878 tmp = fieldFromInstruction(insn, 21, 5);
11879 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11880 tmp = fieldFromInstruction(insn, 16, 5);
11881 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11882 tmp = fieldFromInstruction(insn, 0, 16);
11883 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11884 return S;
11885 case 94:
11886 tmp = fieldFromInstruction(insn, 16, 5);
11887 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11888 tmp = fieldFromInstruction(insn, 21, 5);
11889 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11890 return S;
11891 case 95:
11892 tmp = fieldFromInstruction(insn, 21, 5);
11893 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11894 tmp = fieldFromInstruction(insn, 16, 5);
11895 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11896 tmp = fieldFromInstruction(insn, 11, 5);
11897 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11898 return S;
11899 case 96:
11900 tmp = fieldFromInstruction(insn, 16, 5);
11901 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11902 tmp = fieldFromInstruction(insn, 21, 5);
11903 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11904 return S;
11905 case 97:
11906 tmp = fieldFromInstruction(insn, 11, 5);
11907 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11908 tmp = fieldFromInstruction(insn, 16, 5);
11909 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11910 tmp = fieldFromInstruction(insn, 21, 5);
11911 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11912 return S;
11913 case 98:
11914 tmp = fieldFromInstruction(insn, 11, 5);
11915 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11916 tmp = fieldFromInstruction(insn, 16, 5);
11917 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11918 tmp = fieldFromInstruction(insn, 21, 5);
11919 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11920 return S;
11921 case 99:
11922 tmp = fieldFromInstruction(insn, 16, 10);
11923 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11924 tmp = fieldFromInstruction(insn, 6, 10);
11925 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11926 return S;
11927 case 100:
11928 tmp = fieldFromInstruction(insn, 21, 5);
11929 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11930 tmp = fieldFromInstruction(insn, 16, 5);
11931 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11932 tmp = fieldFromInstruction(insn, 6, 5);
11933 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11934 tmp = fieldFromInstruction(insn, 11, 5);
11935 if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11936 tmp = fieldFromInstruction(insn, 21, 5);
11937 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11938 return S;
11939 case 101:
11940 tmp = fieldFromInstruction(insn, 11, 5);
11941 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11942 tmp = fieldFromInstruction(insn, 16, 5);
11943 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11944 tmp = fieldFromInstruction(insn, 21, 5);
11945 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11946 return S;
11947 case 102:
11948 tmp = fieldFromInstruction(insn, 11, 5);
11949 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11950 tmp = fieldFromInstruction(insn, 21, 5);
11951 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11952 tmp = fieldFromInstruction(insn, 16, 5);
11953 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11954 return S;
11955 case 103:
11956 tmp = fieldFromInstruction(insn, 21, 5);
11957 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11958 tmp = fieldFromInstruction(insn, 16, 5);
11959 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11960 tmp = fieldFromInstruction(insn, 11, 5);
11961 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11962 tmp = fieldFromInstruction(insn, 21, 5);
11963 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11964 return S;
11965 case 104:
11966 tmp = fieldFromInstruction(insn, 11, 5);
11967 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11968 tmp = fieldFromInstruction(insn, 21, 5);
11969 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11970 tmp = fieldFromInstruction(insn, 16, 5);
11971 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11972 return S;
11973 case 105:
11974 tmp = fieldFromInstruction(insn, 21, 5);
11975 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11976 tmp = fieldFromInstruction(insn, 16, 5);
11977 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11978 tmp = fieldFromInstruction(insn, 11, 5);
11979 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11980 tmp = fieldFromInstruction(insn, 21, 5);
11981 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11982 return S;
11983 case 106:
11984 tmp = fieldFromInstruction(insn, 11, 5);
11985 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11986 tmp = fieldFromInstruction(insn, 16, 5);
11987 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11988 tmp = fieldFromInstruction(insn, 21, 5);
11989 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11990 tmp = fieldFromInstruction(insn, 11, 5);
11991 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11992 return S;
11993 case 107:
11994 tmp = fieldFromInstruction(insn, 11, 5);
11995 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11996 tmp = fieldFromInstruction(insn, 16, 5);
11997 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11998 tmp = fieldFromInstruction(insn, 21, 5);
11999 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12000 return S;
12001 case 108:
12002 tmp = fieldFromInstruction(insn, 14, 2);
12003 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12004 tmp = fieldFromInstruction(insn, 16, 6);
12005 if (!Check(S, DecodeSImmWithOffsetAndScale<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12006 tmp = fieldFromInstruction(insn, 14, 2);
12007 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12008 return S;
12009 case 109:
12010 tmp = fieldFromInstruction(insn, 21, 5);
12011 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12012 tmp = fieldFromInstruction(insn, 16, 5);
12013 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12014 tmp = fieldFromInstruction(insn, 6, 5);
12015 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12016 tmp = fieldFromInstruction(insn, 11, 5);
12017 if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12018 return S;
12019 case 110:
12020 tmp = fieldFromInstruction(insn, 11, 5);
12021 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12022 tmp = fieldFromInstruction(insn, 16, 5);
12023 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12024 tmp = fieldFromInstruction(insn, 21, 5);
12025 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12026 return S;
12027 case 111:
12028 tmp = fieldFromInstruction(insn, 21, 5);
12029 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12030 tmp = 0x0;
12031 tmp |= fieldFromInstruction(insn, 11, 3);
12032 tmp |= fieldFromInstruction(insn, 16, 5) << 5;
12033 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12034 return S;
12035 case 112:
12036 tmp = 0x0;
12037 tmp |= fieldFromInstruction(insn, 11, 3);
12038 tmp |= fieldFromInstruction(insn, 16, 5) << 5;
12039 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12040 tmp = fieldFromInstruction(insn, 21, 5);
12041 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12042 return S;
12043 case 113:
12044 tmp = fieldFromInstruction(insn, 21, 5);
12045 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12046 tmp = fieldFromInstruction(insn, 16, 5);
12047 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12048 tmp = fieldFromInstruction(insn, 12, 4);
12049 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12050 return S;
12051 case 114:
12052 tmp = fieldFromInstruction(insn, 16, 5);
12053 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12054 tmp = fieldFromInstruction(insn, 21, 5);
12055 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12056 tmp = fieldFromInstruction(insn, 12, 4);
12057 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12058 return S;
12059 case 115:
12060 tmp = fieldFromInstruction(insn, 16, 5);
12061 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12062 tmp = fieldFromInstruction(insn, 14, 2);
12063 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12064 return S;
12065 case 116:
12066 tmp = fieldFromInstruction(insn, 14, 2);
12067 if (!Check(S, DecodeHI32DSPRegisterClass(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 117:
12072 tmp = fieldFromInstruction(insn, 21, 5);
12073 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12074 tmp = fieldFromInstruction(insn, 16, 5);
12075 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12076 tmp = fieldFromInstruction(insn, 13, 3);
12077 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12078 return S;
12079 case 118:
12080 tmp = fieldFromInstruction(insn, 14, 2);
12081 if (!Check(S, DecodeLO32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12082 tmp = fieldFromInstruction(insn, 16, 5);
12083 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12084 return S;
12085 case 119:
12086 tmp = fieldFromInstruction(insn, 14, 2);
12087 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12088 tmp = fieldFromInstruction(insn, 16, 5);
12089 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12090 tmp = fieldFromInstruction(insn, 21, 5);
12091 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12092 tmp = fieldFromInstruction(insn, 14, 2);
12093 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12094 return S;
12095 case 120:
12096 tmp = fieldFromInstruction(insn, 21, 5);
12097 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12098 tmp = fieldFromInstruction(insn, 16, 5);
12099 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12100 tmp = fieldFromInstruction(insn, 14, 2);
12101 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12102 tmp = fieldFromInstruction(insn, 21, 5);
12103 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12104 return S;
12105 case 121:
12106 tmp = fieldFromInstruction(insn, 21, 5);
12107 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12108 tmp = fieldFromInstruction(insn, 14, 2);
12109 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12110 tmp = fieldFromInstruction(insn, 16, 5);
12111 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12112 return S;
12113 case 122:
12114 tmp = fieldFromInstruction(insn, 21, 5);
12115 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12116 tmp = fieldFromInstruction(insn, 16, 5);
12117 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12118 return S;
12119 case 123:
12120 tmp = fieldFromInstruction(insn, 21, 5);
12121 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12122 tmp = fieldFromInstruction(insn, 16, 5);
12123 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12124 return S;
12125 case 124:
12126 tmp = fieldFromInstruction(insn, 21, 5);
12127 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12128 tmp = fieldFromInstruction(insn, 21, 5);
12129 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12130 tmp = fieldFromInstruction(insn, 16, 5);
12131 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12132 return S;
12133 case 125:
12134 tmp = fieldFromInstruction(insn, 21, 5);
12135 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12136 tmp = fieldFromInstruction(insn, 16, 5);
12137 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12138 return S;
12139 case 126:
12140 tmp = fieldFromInstruction(insn, 14, 2);
12141 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12142 tmp = fieldFromInstruction(insn, 16, 5);
12143 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12144 tmp = fieldFromInstruction(insn, 14, 2);
12145 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12146 return S;
12147 case 127:
12148 tmp = fieldFromInstruction(insn, 14, 2);
12149 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12150 tmp = fieldFromInstruction(insn, 16, 5);
12151 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12152 tmp = fieldFromInstruction(insn, 21, 5);
12153 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12154 tmp = fieldFromInstruction(insn, 14, 2);
12155 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12156 return S;
12157 case 128:
12158 tmp = fieldFromInstruction(insn, 21, 5);
12159 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12160 tmp = fieldFromInstruction(insn, 16, 5);
12161 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12162 return S;
12163 case 129:
12164 tmp = fieldFromInstruction(insn, 21, 5);
12165 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12166 tmp = fieldFromInstruction(insn, 16, 5);
12167 if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12168 return S;
12169 case 130:
12170 tmp = fieldFromInstruction(insn, 16, 5);
12171 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12172 tmp = fieldFromInstruction(insn, 21, 5);
12173 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12174 return S;
12175 case 131:
12176 tmp = fieldFromInstruction(insn, 16, 5);
12177 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12178 return S;
12179 case 132:
12180 tmp = fieldFromInstruction(insn, 16, 10);
12181 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12182 return S;
12183 case 133:
12184 tmp = fieldFromInstruction(insn, 14, 2);
12185 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12186 tmp = fieldFromInstruction(insn, 16, 5);
12187 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12188 tmp = fieldFromInstruction(insn, 21, 5);
12189 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12190 return S;
12191 case 134:
12192 tmp = fieldFromInstruction(insn, 21, 5);
12193 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12194 tmp = fieldFromInstruction(insn, 16, 5);
12195 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12196 return S;
12197 case 135:
12198 tmp = fieldFromInstruction(insn, 16, 5);
12199 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12200 tmp = fieldFromInstruction(insn, 21, 5);
12201 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12202 return S;
12203 case 136:
12204 tmp = fieldFromInstruction(insn, 16, 5);
12205 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12206 return S;
12207 case 137:
12208 tmp = fieldFromInstruction(insn, 21, 5);
12209 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12210 tmp = fieldFromInstruction(insn, 13, 8);
12211 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12212 return S;
12213 case 138:
12214 tmp = fieldFromInstruction(insn, 21, 5);
12215 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12216 tmp = fieldFromInstruction(insn, 14, 7);
12217 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12218 return S;
12219 case 139:
12220 tmp = fieldFromInstruction(insn, 21, 5);
12221 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12222 tmp = fieldFromInstruction(insn, 14, 2);
12223 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12224 tmp = fieldFromInstruction(insn, 16, 5);
12225 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12226 return S;
12227 case 140:
12228 tmp = fieldFromInstruction(insn, 11, 5);
12229 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12230 tmp = fieldFromInstruction(insn, 16, 10);
12231 if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12232 return S;
12233 case 141:
12234 tmp = fieldFromInstruction(insn, 21, 5);
12235 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12236 tmp = fieldFromInstruction(insn, 16, 5);
12237 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12238 tmp = fieldFromInstruction(insn, 0, 16);
12239 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12240 return S;
12241 case 142:
12242 tmp = fieldFromInstruction(insn, 21, 5);
12243 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12244 tmp = fieldFromInstruction(insn, 16, 5);
12245 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12246 tmp = fieldFromInstruction(insn, 0, 16);
12247 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12248 return S;
12249 case 143:
12250 tmp = fieldFromInstruction(insn, 21, 5);
12251 if (!Check(S, DecodeGPR32Pair(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12252 tmp = fieldFromInstruction(insn, 16, 5);
12253 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12254 tmp = fieldFromInstruction(insn, 0, 12);
12255 if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12256 return S;
12257 case 144:
12258 tmp = fieldFromInstruction(insn, 21, 5);
12259 if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12260 tmp = fieldFromInstruction(insn, 16, 5);
12261 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12262 tmp = fieldFromInstruction(insn, 0, 12);
12263 if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12264 return S;
12265 case 145:
12266 tmp = fieldFromInstruction(insn, 16, 5);
12267 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12268 tmp = fieldFromInstruction(insn, 0, 12);
12269 if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12270 tmp = fieldFromInstruction(insn, 21, 5);
12271 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12272 return S;
12273 case 146:
12274 tmp = fieldFromInstruction(insn, 16, 5);
12275 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12276 tmp = fieldFromInstruction(insn, 0, 16);
12277 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12278 return S;
12279 case 147:
12280 tmp = fieldFromInstruction(insn, 16, 5);
12281 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12282 tmp = fieldFromInstruction(insn, 0, 16);
12283 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12284 return S;
12285 case 148:
12286 tmp = fieldFromInstruction(insn, 16, 5);
12287 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12288 tmp = fieldFromInstruction(insn, 0, 16);
12289 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12290 return S;
12291 case 149:
12292 tmp = fieldFromInstruction(insn, 16, 5);
12293 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12294 tmp = fieldFromInstruction(insn, 0, 16);
12295 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12296 return S;
12297 case 150:
12298 tmp = fieldFromInstruction(insn, 0, 16);
12299 if (!Check(S, DecodeBranchTarget1SImm16(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12300 return S;
12301 case 151:
12302 tmp = fieldFromInstruction(insn, 0, 16);
12303 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12304 return S;
12305 case 152:
12306 tmp = fieldFromInstruction(insn, 18, 3);
12307 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12308 tmp = fieldFromInstruction(insn, 0, 16);
12309 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12310 return S;
12311 case 153:
12312 tmp = fieldFromInstruction(insn, 21, 5);
12313 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12314 tmp = fieldFromInstruction(insn, 16, 5);
12315 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12316 tmp = fieldFromInstruction(insn, 0, 16);
12317 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12318 return S;
12319 case 154:
12320 tmp = fieldFromInstruction(insn, 11, 5);
12321 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12322 tmp = fieldFromInstruction(insn, 6, 5);
12323 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12324 tmp = fieldFromInstruction(insn, 16, 5);
12325 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12326 tmp = fieldFromInstruction(insn, 21, 5);
12327 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12328 return S;
12329 case 155:
12330 tmp = fieldFromInstruction(insn, 11, 5);
12331 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12332 tmp = fieldFromInstruction(insn, 16, 5);
12333 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12334 tmp = fieldFromInstruction(insn, 21, 5);
12335 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12336 return S;
12337 case 156:
12338 tmp = fieldFromInstruction(insn, 11, 5);
12339 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12340 tmp = fieldFromInstruction(insn, 16, 5);
12341 if (!Check(S, DecodePtrRegisterClass(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 return S;
12345 case 157:
12346 tmp = fieldFromInstruction(insn, 11, 5);
12347 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12348 tmp = fieldFromInstruction(insn, 6, 5);
12349 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12350 tmp = fieldFromInstruction(insn, 16, 5);
12351 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12352 tmp = fieldFromInstruction(insn, 21, 5);
12353 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12354 return S;
12355 case 158:
12356 tmp = fieldFromInstruction(insn, 21, 5);
12357 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12358 tmp = fieldFromInstruction(insn, 16, 5);
12359 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12360 tmp = fieldFromInstruction(insn, 13, 3);
12361 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12362 tmp = fieldFromInstruction(insn, 21, 5);
12363 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12364 return S;
12365 case 159:
12366 tmp = fieldFromInstruction(insn, 16, 5);
12367 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12368 tmp = fieldFromInstruction(insn, 21, 5);
12369 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12370 tmp = fieldFromInstruction(insn, 11, 5);
12371 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12372 return S;
12373 case 160:
12374 tmp = fieldFromInstruction(insn, 21, 5);
12375 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12376 tmp = fieldFromInstruction(insn, 16, 5);
12377 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12378 tmp = fieldFromInstruction(insn, 13, 3);
12379 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12380 tmp = fieldFromInstruction(insn, 21, 5);
12381 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12382 return S;
12383 case 161:
12384 tmp = fieldFromInstruction(insn, 11, 5);
12385 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12386 tmp = fieldFromInstruction(insn, 16, 5);
12387 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12388 tmp = fieldFromInstruction(insn, 21, 5);
12389 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12390 return S;
12391 case 162:
12392 tmp = fieldFromInstruction(insn, 11, 5);
12393 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12394 tmp = fieldFromInstruction(insn, 16, 5);
12395 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12396 tmp = fieldFromInstruction(insn, 21, 5);
12397 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12398 tmp = fieldFromInstruction(insn, 11, 5);
12399 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12400 return S;
12401 case 163:
12402 tmp = fieldFromInstruction(insn, 11, 5);
12403 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12404 tmp = fieldFromInstruction(insn, 16, 5);
12405 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12406 tmp = fieldFromInstruction(insn, 21, 5);
12407 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12408 tmp = fieldFromInstruction(insn, 11, 5);
12409 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12410 return S;
12411 case 164:
12412 tmp = fieldFromInstruction(insn, 21, 5);
12413 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12414 tmp = fieldFromInstruction(insn, 16, 5);
12415 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12416 return S;
12417 case 165:
12418 tmp = fieldFromInstruction(insn, 21, 5);
12419 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12420 tmp = fieldFromInstruction(insn, 16, 5);
12421 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12422 return S;
12423 case 166:
12424 tmp = fieldFromInstruction(insn, 21, 5);
12425 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12426 tmp = fieldFromInstruction(insn, 16, 5);
12427 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12428 return S;
12429 case 167:
12430 tmp = fieldFromInstruction(insn, 21, 5);
12431 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12432 tmp = fieldFromInstruction(insn, 16, 5);
12433 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12434 return S;
12435 case 168:
12436 tmp = fieldFromInstruction(insn, 21, 5);
12437 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12438 tmp = fieldFromInstruction(insn, 16, 5);
12439 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12440 tmp = fieldFromInstruction(insn, 13, 3);
12441 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12442 tmp = fieldFromInstruction(insn, 21, 5);
12443 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12444 return S;
12445 case 169:
12446 tmp = fieldFromInstruction(insn, 21, 5);
12447 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12448 tmp = fieldFromInstruction(insn, 16, 5);
12449 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12450 return S;
12451 case 170:
12452 tmp = fieldFromInstruction(insn, 16, 5);
12453 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12454 tmp = fieldFromInstruction(insn, 21, 5);
12455 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12456 return S;
12457 case 171:
12458 tmp = fieldFromInstruction(insn, 21, 5);
12459 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12460 tmp = fieldFromInstruction(insn, 16, 5);
12461 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12462 return S;
12463 case 172:
12464 tmp = fieldFromInstruction(insn, 21, 5);
12465 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12466 tmp = fieldFromInstruction(insn, 16, 5);
12467 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12468 return S;
12469 case 173:
12470 tmp = fieldFromInstruction(insn, 21, 5);
12471 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12472 tmp = fieldFromInstruction(insn, 16, 5);
12473 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12474 return S;
12475 case 174:
12476 tmp = fieldFromInstruction(insn, 21, 5);
12477 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12478 tmp = fieldFromInstruction(insn, 16, 5);
12479 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12480 return S;
12481 case 175:
12482 tmp = fieldFromInstruction(insn, 16, 5);
12483 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12484 tmp = fieldFromInstruction(insn, 21, 5);
12485 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12486 return S;
12487 case 176:
12488 tmp = fieldFromInstruction(insn, 16, 5);
12489 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12490 tmp = fieldFromInstruction(insn, 16, 5);
12491 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12492 tmp = fieldFromInstruction(insn, 21, 5);
12493 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12494 return S;
12495 case 177:
12496 tmp = fieldFromInstruction(insn, 13, 3);
12497 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12498 tmp = fieldFromInstruction(insn, 16, 5);
12499 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12500 tmp = fieldFromInstruction(insn, 21, 5);
12501 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12502 return S;
12503 case 178:
12504 tmp = fieldFromInstruction(insn, 13, 3);
12505 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12506 tmp = fieldFromInstruction(insn, 16, 5);
12507 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12508 tmp = fieldFromInstruction(insn, 21, 5);
12509 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12510 return S;
12511 case 179:
12512 tmp = fieldFromInstruction(insn, 21, 5);
12513 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12514 tmp = fieldFromInstruction(insn, 16, 5);
12515 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12516 tmp = fieldFromInstruction(insn, 0, 12);
12517 if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12518 tmp = fieldFromInstruction(insn, 21, 5);
12519 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12520 return S;
12521 case 180:
12522 tmp = fieldFromInstruction(insn, 21, 5);
12523 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12524 tmp = fieldFromInstruction(insn, 16, 5);
12525 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12526 tmp = fieldFromInstruction(insn, 0, 12);
12527 if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12528 return S;
12529 case 181:
12530 tmp = fieldFromInstruction(insn, 21, 5);
12531 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12532 tmp = fieldFromInstruction(insn, 16, 5);
12533 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12534 tmp = fieldFromInstruction(insn, 0, 9);
12535 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12536 return S;
12537 case 182:
12538 tmp = fieldFromInstruction(insn, 21, 5);
12539 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12540 tmp = fieldFromInstruction(insn, 16, 5);
12541 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12542 tmp = fieldFromInstruction(insn, 0, 9);
12543 if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12544 return S;
12545 case 183:
12546 tmp = fieldFromInstruction(insn, 21, 5);
12547 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12548 tmp = fieldFromInstruction(insn, 16, 5);
12549 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12550 tmp = fieldFromInstruction(insn, 0, 9);
12551 if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12552 tmp = fieldFromInstruction(insn, 21, 5);
12553 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12554 return S;
12555 case 184:
12556 tmp = fieldFromInstruction(insn, 16, 5);
12557 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12558 tmp = fieldFromInstruction(insn, 0, 9);
12559 if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12560 tmp = fieldFromInstruction(insn, 21, 5);
12561 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12562 return S;
12563 case 185:
12564 tmp = fieldFromInstruction(insn, 21, 5);
12565 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12566 tmp = fieldFromInstruction(insn, 21, 5);
12567 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12568 tmp = fieldFromInstruction(insn, 16, 5);
12569 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12570 tmp = fieldFromInstruction(insn, 0, 9);
12571 if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12572 return S;
12573 case 186:
12574 tmp = fieldFromInstruction(insn, 21, 5);
12575 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12576 tmp = fieldFromInstruction(insn, 21, 5);
12577 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12578 tmp = fieldFromInstruction(insn, 16, 5);
12579 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12580 tmp = fieldFromInstruction(insn, 0, 12);
12581 if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12582 return S;
12583 case 187:
12584 if (!Check(S, DecodeJumpTargetMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12585 return S;
12586 case 188:
12587 tmp = fieldFromInstruction(insn, 23, 3);
12588 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12589 tmp = fieldFromInstruction(insn, 0, 23);
12590 if (!Check(S, DecodeSimm23Lsl2(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12591 return S;
12592 case 189:
12593 tmp = fieldFromInstruction(insn, 16, 5);
12594 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12595 tmp = fieldFromInstruction(insn, 21, 5);
12596 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12597 tmp = fieldFromInstruction(insn, 0, 16);
12598 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12599 return S;
12600 case 190:
12601 tmp = fieldFromInstruction(insn, 21, 5);
12602 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12603 tmp = fieldFromInstruction(insn, 16, 5);
12604 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12605 tmp = fieldFromInstruction(insn, 0, 16);
12606 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12607 return S;
12608 case 191:
12609 tmp = fieldFromInstruction(insn, 21, 5);
12610 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12611 tmp = fieldFromInstruction(insn, 16, 5);
12612 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12613 tmp = fieldFromInstruction(insn, 0, 16);
12614 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12615 return S;
12616 case 192:
12617 if (!Check(S, DecodeJumpTargetXMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12618 return S;
12619 case 193:
12620 tmp = fieldFromInstruction(insn, 21, 5);
12621 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12622 tmp = fieldFromInstruction(insn, 16, 5);
12623 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12624 tmp = fieldFromInstruction(insn, 0, 16);
12625 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12626 return S;
12627 case 194:
12628 tmp = fieldFromInstruction(insn, 16, 5);
12629 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12630 tmp = fieldFromInstruction(insn, 21, 5);
12631 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12632 return S;
12633 case 195:
12634 tmp = fieldFromInstruction(insn, 21, 5);
12635 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12636 tmp = fieldFromInstruction(insn, 16, 5);
12637 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12638 return S;
12639 case 196:
12640 tmp = fieldFromInstruction(insn, 16, 5);
12641 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12642 tmp = fieldFromInstruction(insn, 16, 5);
12643 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12644 tmp = fieldFromInstruction(insn, 21, 5);
12645 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12646 return S;
12647 case 197:
12648 tmp = fieldFromInstruction(insn, 11, 5);
12649 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12650 tmp = fieldFromInstruction(insn, 16, 5);
12651 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12652 tmp = fieldFromInstruction(insn, 21, 5);
12653 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12654 return S;
12655 case 198:
12656 tmp = fieldFromInstruction(insn, 21, 5);
12657 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12658 tmp = fieldFromInstruction(insn, 16, 5);
12659 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12660 return S;
12661 case 199:
12662 tmp = fieldFromInstruction(insn, 21, 5);
12663 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12664 tmp = fieldFromInstruction(insn, 16, 5);
12665 if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12666 tmp = fieldFromInstruction(insn, 11, 3);
12667 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12668 return S;
12669 case 200:
12670 tmp = fieldFromInstruction(insn, 11, 5);
12671 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12672 tmp = fieldFromInstruction(insn, 16, 5);
12673 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12674 tmp = fieldFromInstruction(insn, 21, 5);
12675 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12676 tmp = fieldFromInstruction(insn, 9, 2);
12677 if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12678 return S;
12679 case 201:
12680 tmp = fieldFromInstruction(insn, 11, 5);
12681 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12682 tmp = fieldFromInstruction(insn, 21, 5);
12683 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12684 tmp = fieldFromInstruction(insn, 16, 5);
12685 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12686 tmp = fieldFromInstruction(insn, 9, 2);
12687 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12688 return S;
12689 case 202:
12690 tmp = fieldFromInstruction(insn, 16, 5);
12691 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12692 tmp = fieldFromInstruction(insn, 9, 2);
12693 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12694 return S;
12695 case 203:
12696 tmp = fieldFromInstruction(insn, 6, 16);
12697 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12698 return S;
12699 case 204:
12700 tmp = fieldFromInstruction(insn, 21, 5);
12701 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12702 tmp = fieldFromInstruction(insn, 0, 16);
12703 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12704 return S;
12705 case 205:
12706 tmp = fieldFromInstruction(insn, 21, 5);
12707 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12708 tmp = fieldFromInstruction(insn, 16, 5);
12709 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12710 tmp = fieldFromInstruction(insn, 0, 11);
12711 if (!Check(S, DecodeSImmWithOffsetAndScale<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12712 return S;
12713 case 206:
12714 tmp = fieldFromInstruction(insn, 16, 5);
12715 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12716 tmp = fieldFromInstruction(insn, 0, 16);
12717 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12718 return S;
12719 case 207:
12720 tmp = fieldFromInstruction(insn, 16, 5);
12721 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12722 tmp = fieldFromInstruction(insn, 0, 16);
12723 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12724 return S;
12725 case 208:
12726 tmp = fieldFromInstruction(insn, 11, 5);
12727 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12728 tmp = fieldFromInstruction(insn, 16, 5);
12729 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12730 tmp = fieldFromInstruction(insn, 21, 5);
12731 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12732 return S;
12733 case 209:
12734 tmp = fieldFromInstruction(insn, 16, 5);
12735 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12736 tmp = fieldFromInstruction(insn, 21, 5);
12737 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12738 return S;
12739 case 210:
12740 tmp = fieldFromInstruction(insn, 11, 5);
12741 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12742 tmp = fieldFromInstruction(insn, 21, 5);
12743 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12744 tmp = fieldFromInstruction(insn, 16, 5);
12745 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12746 return S;
12747 case 211:
12748 tmp = fieldFromInstruction(insn, 11, 5);
12749 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12750 tmp = fieldFromInstruction(insn, 11, 5);
12751 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12752 tmp = fieldFromInstruction(insn, 16, 5);
12753 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12754 tmp = fieldFromInstruction(insn, 21, 5);
12755 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12756 return S;
12757 case 212:
12758 tmp = fieldFromInstruction(insn, 16, 5);
12759 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12760 tmp = fieldFromInstruction(insn, 21, 5);
12761 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12762 return S;
12763 case 213:
12764 tmp = fieldFromInstruction(insn, 11, 5);
12765 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12766 tmp = fieldFromInstruction(insn, 11, 5);
12767 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12768 tmp = fieldFromInstruction(insn, 16, 5);
12769 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12770 tmp = fieldFromInstruction(insn, 21, 5);
12771 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12772 return S;
12773 case 214:
12774 if (!Check(S, DecodePOP35GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12775 return S;
12776 case 215:
12777 tmp = fieldFromInstruction(insn, 21, 5);
12778 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12779 tmp = fieldFromInstruction(insn, 0, 19);
12780 if (!Check(S, DecodeSimm19Lsl2(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12781 return S;
12782 case 216:
12783 tmp = fieldFromInstruction(insn, 21, 5);
12784 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12785 tmp = fieldFromInstruction(insn, 0, 16);
12786 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12787 return S;
12788 case 217:
12789 if (!Check(S, DecodePOP37GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12790 return S;
12791 case 218:
12792 tmp = fieldFromInstruction(insn, 21, 5);
12793 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12794 tmp = fieldFromInstruction(insn, 0, 21);
12795 if (!Check(S, DecodeBranchTarget21MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12796 return S;
12797 case 219:
12798 tmp = fieldFromInstruction(insn, 0, 26);
12799 if (!Check(S, DecodeBranchTarget26MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12800 return S;
12801 case 220:
12802 if (!Check(S, DecodeBlezGroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12803 return S;
12804 case 221:
12805 if (!Check(S, DecodePOP65GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12806 return S;
12807 case 222:
12808 if (!Check(S, DecodeBgtzGroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12809 return S;
12810 case 223:
12811 if (!Check(S, DecodePOP75GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12812 return S;
12813 case 224:
12814 tmp = fieldFromInstruction(insn, 11, 5);
12815 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12816 tmp = fieldFromInstruction(insn, 16, 5);
12817 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12818 tmp = fieldFromInstruction(insn, 6, 5);
12819 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12820 return S;
12821 case 225:
12822 tmp = fieldFromInstruction(insn, 11, 5);
12823 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12824 tmp = fieldFromInstruction(insn, 21, 5);
12825 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12826 tmp = fieldFromInstruction(insn, 18, 3);
12827 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12828 tmp = fieldFromInstruction(insn, 11, 5);
12829 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12830 return S;
12831 case 226:
12832 tmp = fieldFromInstruction(insn, 11, 5);
12833 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12834 tmp = fieldFromInstruction(insn, 21, 5);
12835 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12836 tmp = fieldFromInstruction(insn, 16, 5);
12837 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12838 tmp = fieldFromInstruction(insn, 6, 2);
12839 if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12840 return S;
12841 case 227:
12842 tmp = fieldFromInstruction(insn, 21, 5);
12843 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12844 return S;
12845 case 228:
12846 tmp = fieldFromInstruction(insn, 11, 5);
12847 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12848 tmp = fieldFromInstruction(insn, 21, 5);
12849 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12850 tmp = fieldFromInstruction(insn, 16, 5);
12851 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12852 tmp = fieldFromInstruction(insn, 11, 5);
12853 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12854 return S;
12855 case 229:
12856 tmp = fieldFromInstruction(insn, 6, 20);
12857 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12858 return S;
12859 case 230:
12860 tmp = fieldFromInstruction(insn, 6, 5);
12861 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12862 return S;
12863 case 231:
12864 tmp = fieldFromInstruction(insn, 11, 5);
12865 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12866 return S;
12867 case 232:
12868 tmp = fieldFromInstruction(insn, 11, 5);
12869 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12870 tmp = fieldFromInstruction(insn, 21, 2);
12871 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12872 return S;
12873 case 233:
12874 tmp = fieldFromInstruction(insn, 11, 2);
12875 if (!Check(S, DecodeHI32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12876 tmp = fieldFromInstruction(insn, 21, 5);
12877 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12878 return S;
12879 case 234:
12880 tmp = fieldFromInstruction(insn, 11, 2);
12881 if (!Check(S, DecodeLO32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12882 tmp = fieldFromInstruction(insn, 21, 5);
12883 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12884 return S;
12885 case 235:
12886 tmp = fieldFromInstruction(insn, 11, 5);
12887 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12888 tmp = fieldFromInstruction(insn, 21, 5);
12889 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12890 tmp = fieldFromInstruction(insn, 16, 5);
12891 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12892 tmp = fieldFromInstruction(insn, 6, 2);
12893 if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12894 return S;
12895 case 236:
12896 tmp = fieldFromInstruction(insn, 11, 2);
12897 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12898 tmp = fieldFromInstruction(insn, 21, 5);
12899 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12900 tmp = fieldFromInstruction(insn, 16, 5);
12901 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12902 return S;
12903 case 237:
12904 tmp = fieldFromInstruction(insn, 21, 5);
12905 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12906 tmp = fieldFromInstruction(insn, 16, 5);
12907 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12908 tmp = fieldFromInstruction(insn, 6, 10);
12909 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12910 return S;
12911 case 238:
12912 tmp = fieldFromInstruction(insn, 21, 5);
12913 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12914 tmp = fieldFromInstruction(insn, 0, 16);
12915 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12916 return S;
12917 case 239:
12918 tmp = fieldFromInstruction(insn, 0, 16);
12919 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12920 return S;
12921 case 240:
12922 tmp = fieldFromInstruction(insn, 21, 5);
12923 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12924 tmp = fieldFromInstruction(insn, 0, 16);
12925 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12926 return S;
12927 case 241:
12928 if (!Check(S, DecodeJumpTarget(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12929 return S;
12930 case 242:
12931 tmp = fieldFromInstruction(insn, 21, 5);
12932 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12933 tmp = fieldFromInstruction(insn, 16, 5);
12934 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12935 tmp = fieldFromInstruction(insn, 0, 16);
12936 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12937 return S;
12938 case 243:
12939 tmp = fieldFromInstruction(insn, 16, 5);
12940 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12941 tmp = fieldFromInstruction(insn, 21, 5);
12942 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12943 tmp = fieldFromInstruction(insn, 0, 16);
12944 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12945 return S;
12946 case 244:
12947 tmp = fieldFromInstruction(insn, 16, 5);
12948 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12949 tmp = fieldFromInstruction(insn, 21, 5);
12950 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12951 tmp = fieldFromInstruction(insn, 0, 16);
12952 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12953 return S;
12954 case 245:
12955 tmp = fieldFromInstruction(insn, 16, 5);
12956 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12957 tmp = 0x0;
12958 tmp |= fieldFromInstruction(insn, 0, 3);
12959 tmp |= fieldFromInstruction(insn, 11, 5) << 5;
12960 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12961 return S;
12962 case 246:
12963 tmp = 0x0;
12964 tmp |= fieldFromInstruction(insn, 0, 3);
12965 tmp |= fieldFromInstruction(insn, 11, 5) << 5;
12966 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12967 tmp = fieldFromInstruction(insn, 16, 5);
12968 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12969 return S;
12970 case 247:
12971 tmp = fieldFromInstruction(insn, 11, 5);
12972 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12973 tmp = fieldFromInstruction(insn, 16, 5);
12974 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12975 tmp = fieldFromInstruction(insn, 5, 1);
12976 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12977 tmp = fieldFromInstruction(insn, 0, 3);
12978 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12979 tmp = fieldFromInstruction(insn, 4, 1);
12980 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12981 return S;
12982 case 248:
12983 tmp = fieldFromInstruction(insn, 11, 10);
12984 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12985 return S;
12986 case 249:
12987 tmp = fieldFromInstruction(insn, 16, 5);
12988 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12989 tmp = fieldFromInstruction(insn, 11, 5);
12990 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12991 return S;
12992 case 250:
12993 tmp = fieldFromInstruction(insn, 16, 5);
12994 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12995 tmp = fieldFromInstruction(insn, 11, 5);
12996 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12997 return S;
12998 case 251:
12999 tmp = fieldFromInstruction(insn, 16, 5);
13000 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13001 tmp = fieldFromInstruction(insn, 11, 5);
13002 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13003 return S;
13004 case 252:
13005 tmp = fieldFromInstruction(insn, 16, 5);
13006 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13007 tmp = fieldFromInstruction(insn, 11, 5);
13008 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13009 return S;
13010 case 253:
13011 tmp = fieldFromInstruction(insn, 11, 5);
13012 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13013 tmp = fieldFromInstruction(insn, 16, 5);
13014 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13015 return S;
13016 case 254:
13017 tmp = fieldFromInstruction(insn, 11, 5);
13018 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13019 tmp = fieldFromInstruction(insn, 16, 5);
13020 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13021 return S;
13022 case 255:
13023 tmp = fieldFromInstruction(insn, 11, 5);
13024 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13025 tmp = fieldFromInstruction(insn, 16, 5);
13026 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13027 return S;
13028 case 256:
13029 tmp = fieldFromInstruction(insn, 11, 5);
13030 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13031 tmp = fieldFromInstruction(insn, 11, 5);
13032 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13033 tmp = fieldFromInstruction(insn, 16, 5);
13034 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13035 return S;
13036 case 257:
13037 tmp = fieldFromInstruction(insn, 18, 3);
13038 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13039 tmp = fieldFromInstruction(insn, 0, 16);
13040 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13041 return S;
13042 case 258:
13043 tmp = fieldFromInstruction(insn, 16, 5);
13044 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13045 tmp = fieldFromInstruction(insn, 0, 16);
13046 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13047 return S;
13048 case 259:
13049 tmp = fieldFromInstruction(insn, 6, 5);
13050 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13051 tmp = fieldFromInstruction(insn, 11, 5);
13052 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13053 tmp = fieldFromInstruction(insn, 16, 5);
13054 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13055 return S;
13056 case 260:
13057 tmp = fieldFromInstruction(insn, 6, 5);
13058 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13059 tmp = fieldFromInstruction(insn, 11, 5);
13060 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13061 return S;
13062 case 261:
13063 tmp = fieldFromInstruction(insn, 6, 5);
13064 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13065 tmp = fieldFromInstruction(insn, 11, 5);
13066 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13067 tmp = fieldFromInstruction(insn, 18, 3);
13068 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13069 tmp = fieldFromInstruction(insn, 6, 5);
13070 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13071 return S;
13072 case 262:
13073 tmp = fieldFromInstruction(insn, 6, 5);
13074 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13075 tmp = fieldFromInstruction(insn, 11, 5);
13076 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13077 tmp = fieldFromInstruction(insn, 16, 5);
13078 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13079 tmp = fieldFromInstruction(insn, 6, 5);
13080 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13081 return S;
13082 case 263:
13083 tmp = fieldFromInstruction(insn, 6, 5);
13084 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13085 tmp = fieldFromInstruction(insn, 11, 5);
13086 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13087 return S;
13088 case 264:
13089 tmp = fieldFromInstruction(insn, 6, 5);
13090 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13091 tmp = fieldFromInstruction(insn, 11, 5);
13092 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13093 return S;
13094 case 265:
13095 tmp = fieldFromInstruction(insn, 8, 3);
13096 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13097 tmp = fieldFromInstruction(insn, 11, 5);
13098 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13099 tmp = fieldFromInstruction(insn, 16, 5);
13100 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13101 return S;
13102 case 266:
13103 tmp = fieldFromInstruction(insn, 6, 5);
13104 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13105 tmp = fieldFromInstruction(insn, 11, 5);
13106 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13107 tmp = fieldFromInstruction(insn, 16, 5);
13108 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13109 return S;
13110 case 267:
13111 tmp = fieldFromInstruction(insn, 6, 5);
13112 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13113 tmp = fieldFromInstruction(insn, 11, 5);
13114 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13115 return S;
13116 case 268:
13117 tmp = fieldFromInstruction(insn, 6, 5);
13118 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13119 tmp = fieldFromInstruction(insn, 11, 5);
13120 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13121 return S;
13122 case 269:
13123 tmp = fieldFromInstruction(insn, 6, 5);
13124 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13125 tmp = fieldFromInstruction(insn, 11, 5);
13126 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13127 tmp = fieldFromInstruction(insn, 18, 3);
13128 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13129 tmp = fieldFromInstruction(insn, 6, 5);
13130 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13131 return S;
13132 case 270:
13133 tmp = fieldFromInstruction(insn, 6, 5);
13134 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13135 tmp = fieldFromInstruction(insn, 11, 5);
13136 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13137 tmp = fieldFromInstruction(insn, 16, 5);
13138 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13139 tmp = fieldFromInstruction(insn, 6, 5);
13140 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13141 return S;
13142 case 271:
13143 tmp = fieldFromInstruction(insn, 6, 5);
13144 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13145 tmp = fieldFromInstruction(insn, 11, 5);
13146 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13147 return S;
13148 case 272:
13149 tmp = fieldFromInstruction(insn, 8, 3);
13150 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13151 tmp = fieldFromInstruction(insn, 11, 5);
13152 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13153 tmp = fieldFromInstruction(insn, 16, 5);
13154 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13155 return S;
13156 case 273:
13157 tmp = fieldFromInstruction(insn, 16, 5);
13158 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13159 tmp = fieldFromInstruction(insn, 0, 16);
13160 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13161 return S;
13162 case 274:
13163 tmp = fieldFromInstruction(insn, 16, 5);
13164 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13165 tmp = fieldFromInstruction(insn, 0, 16);
13166 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13167 return S;
13168 case 275:
13169 tmp = fieldFromInstruction(insn, 16, 5);
13170 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13171 tmp = fieldFromInstruction(insn, 0, 16);
13172 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13173 return S;
13174 case 276:
13175 tmp = fieldFromInstruction(insn, 16, 5);
13176 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13177 tmp = fieldFromInstruction(insn, 11, 5);
13178 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13179 tmp = fieldFromInstruction(insn, 0, 3);
13180 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13181 return S;
13182 case 277:
13183 tmp = fieldFromInstruction(insn, 11, 5);
13184 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13185 tmp = fieldFromInstruction(insn, 16, 5);
13186 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13187 tmp = fieldFromInstruction(insn, 0, 3);
13188 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13189 return S;
13190 case 278:
13191 tmp = fieldFromInstruction(insn, 6, 5);
13192 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13193 tmp = fieldFromInstruction(insn, 21, 5);
13194 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13195 tmp = fieldFromInstruction(insn, 16, 5);
13196 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13197 return S;
13198 case 279:
13199 tmp = fieldFromInstruction(insn, 6, 5);
13200 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13201 tmp = fieldFromInstruction(insn, 21, 5);
13202 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13203 tmp = fieldFromInstruction(insn, 16, 5);
13204 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13205 return S;
13206 case 280:
13207 tmp = fieldFromInstruction(insn, 11, 5);
13208 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13209 tmp = fieldFromInstruction(insn, 21, 5);
13210 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13211 tmp = fieldFromInstruction(insn, 16, 5);
13212 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13213 return S;
13214 case 281:
13215 tmp = fieldFromInstruction(insn, 11, 5);
13216 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13217 tmp = fieldFromInstruction(insn, 21, 5);
13218 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13219 tmp = fieldFromInstruction(insn, 16, 5);
13220 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13221 return S;
13222 case 282:
13223 tmp = fieldFromInstruction(insn, 6, 5);
13224 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13225 tmp = fieldFromInstruction(insn, 21, 5);
13226 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13227 tmp = fieldFromInstruction(insn, 11, 5);
13228 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13229 tmp = fieldFromInstruction(insn, 16, 5);
13230 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13231 return S;
13232 case 283:
13233 tmp = fieldFromInstruction(insn, 6, 5);
13234 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13235 tmp = fieldFromInstruction(insn, 21, 5);
13236 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13237 tmp = fieldFromInstruction(insn, 11, 5);
13238 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13239 tmp = fieldFromInstruction(insn, 16, 5);
13240 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13241 return S;
13242 case 284:
13243 tmp = fieldFromInstruction(insn, 11, 2);
13244 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13245 tmp = fieldFromInstruction(insn, 21, 5);
13246 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13247 tmp = fieldFromInstruction(insn, 16, 5);
13248 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13249 tmp = fieldFromInstruction(insn, 11, 2);
13250 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13251 return S;
13252 case 285:
13253 tmp = 0x0;
13254 tmp |= fieldFromInstruction(insn, 11, 5);
13255 tmp |= fieldFromInstruction(insn, 16, 5);
13256 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13257 tmp = fieldFromInstruction(insn, 21, 5);
13258 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13259 return S;
13260 case 286:
13261 tmp = fieldFromInstruction(insn, 6, 5);
13262 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13263 tmp = fieldFromInstruction(insn, 11, 5);
13264 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13265 tmp = fieldFromInstruction(insn, 16, 8);
13266 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13267 return S;
13268 case 287:
13269 tmp = fieldFromInstruction(insn, 6, 5);
13270 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13271 tmp = fieldFromInstruction(insn, 6, 5);
13272 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13273 tmp = fieldFromInstruction(insn, 11, 5);
13274 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13275 tmp = fieldFromInstruction(insn, 16, 8);
13276 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13277 return S;
13278 case 288:
13279 tmp = fieldFromInstruction(insn, 6, 5);
13280 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13281 tmp = fieldFromInstruction(insn, 11, 5);
13282 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13283 tmp = fieldFromInstruction(insn, 16, 8);
13284 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13285 return S;
13286 case 289:
13287 tmp = fieldFromInstruction(insn, 6, 5);
13288 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13289 tmp = fieldFromInstruction(insn, 11, 5);
13290 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13291 tmp = fieldFromInstruction(insn, 16, 8);
13292 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13293 return S;
13294 case 290:
13295 tmp = fieldFromInstruction(insn, 6, 5);
13296 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13297 tmp = fieldFromInstruction(insn, 11, 5);
13298 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13299 tmp = fieldFromInstruction(insn, 16, 5);
13300 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13301 return S;
13302 case 291:
13303 tmp = fieldFromInstruction(insn, 6, 5);
13304 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13305 tmp = fieldFromInstruction(insn, 11, 5);
13306 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13307 tmp = fieldFromInstruction(insn, 16, 5);
13308 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13309 return S;
13310 case 292:
13311 tmp = fieldFromInstruction(insn, 6, 5);
13312 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13313 tmp = fieldFromInstruction(insn, 11, 5);
13314 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13315 tmp = fieldFromInstruction(insn, 16, 5);
13316 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13317 return S;
13318 case 293:
13319 tmp = fieldFromInstruction(insn, 6, 5);
13320 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13321 tmp = fieldFromInstruction(insn, 11, 5);
13322 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13323 tmp = fieldFromInstruction(insn, 16, 5);
13324 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13325 return S;
13326 case 294:
13327 tmp = fieldFromInstruction(insn, 6, 5);
13328 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13329 tmp = fieldFromInstruction(insn, 11, 10);
13330 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13331 return S;
13332 case 295:
13333 tmp = fieldFromInstruction(insn, 6, 5);
13334 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13335 tmp = fieldFromInstruction(insn, 11, 10);
13336 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13337 return S;
13338 case 296:
13339 tmp = fieldFromInstruction(insn, 6, 5);
13340 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13341 tmp = fieldFromInstruction(insn, 11, 10);
13342 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13343 return S;
13344 case 297:
13345 tmp = fieldFromInstruction(insn, 6, 5);
13346 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13347 tmp = fieldFromInstruction(insn, 11, 10);
13348 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13349 return S;
13350 case 298:
13351 tmp = fieldFromInstruction(insn, 6, 5);
13352 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13353 tmp = fieldFromInstruction(insn, 11, 5);
13354 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13355 tmp = fieldFromInstruction(insn, 16, 6);
13356 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13357 return S;
13358 case 299:
13359 tmp = fieldFromInstruction(insn, 6, 5);
13360 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13361 tmp = fieldFromInstruction(insn, 11, 5);
13362 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13363 tmp = fieldFromInstruction(insn, 16, 4);
13364 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13365 return S;
13366 case 300:
13367 tmp = fieldFromInstruction(insn, 6, 5);
13368 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13369 tmp = fieldFromInstruction(insn, 11, 5);
13370 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13371 tmp = fieldFromInstruction(insn, 16, 3);
13372 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13373 return S;
13374 case 301:
13375 tmp = fieldFromInstruction(insn, 6, 5);
13376 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13377 tmp = fieldFromInstruction(insn, 6, 5);
13378 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13379 tmp = fieldFromInstruction(insn, 11, 5);
13380 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13381 tmp = fieldFromInstruction(insn, 16, 6);
13382 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13383 return S;
13384 case 302:
13385 tmp = fieldFromInstruction(insn, 6, 5);
13386 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13387 tmp = fieldFromInstruction(insn, 6, 5);
13388 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13389 tmp = fieldFromInstruction(insn, 11, 5);
13390 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13391 tmp = fieldFromInstruction(insn, 16, 5);
13392 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13393 return S;
13394 case 303:
13395 tmp = fieldFromInstruction(insn, 6, 5);
13396 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13397 tmp = fieldFromInstruction(insn, 6, 5);
13398 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13399 tmp = fieldFromInstruction(insn, 11, 5);
13400 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13401 tmp = fieldFromInstruction(insn, 16, 4);
13402 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13403 return S;
13404 case 304:
13405 tmp = fieldFromInstruction(insn, 6, 5);
13406 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13407 tmp = fieldFromInstruction(insn, 6, 5);
13408 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13409 tmp = fieldFromInstruction(insn, 11, 5);
13410 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13411 tmp = fieldFromInstruction(insn, 16, 3);
13412 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13413 return S;
13414 case 305:
13415 tmp = fieldFromInstruction(insn, 6, 5);
13416 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13417 tmp = fieldFromInstruction(insn, 11, 5);
13418 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13419 tmp = fieldFromInstruction(insn, 16, 5);
13420 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13421 return S;
13422 case 306:
13423 tmp = fieldFromInstruction(insn, 6, 5);
13424 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13425 tmp = fieldFromInstruction(insn, 11, 5);
13426 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13427 tmp = fieldFromInstruction(insn, 16, 5);
13428 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13429 return S;
13430 case 307:
13431 tmp = fieldFromInstruction(insn, 6, 5);
13432 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13433 tmp = fieldFromInstruction(insn, 11, 5);
13434 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13435 tmp = fieldFromInstruction(insn, 16, 5);
13436 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13437 return S;
13438 case 308:
13439 tmp = fieldFromInstruction(insn, 6, 5);
13440 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13441 tmp = fieldFromInstruction(insn, 11, 5);
13442 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13443 tmp = fieldFromInstruction(insn, 16, 5);
13444 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13445 return S;
13446 case 309:
13447 tmp = fieldFromInstruction(insn, 6, 5);
13448 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13449 tmp = fieldFromInstruction(insn, 6, 5);
13450 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13451 tmp = fieldFromInstruction(insn, 11, 5);
13452 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13453 tmp = fieldFromInstruction(insn, 16, 5);
13454 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13455 return S;
13456 case 310:
13457 tmp = fieldFromInstruction(insn, 6, 5);
13458 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13459 tmp = fieldFromInstruction(insn, 6, 5);
13460 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13461 tmp = fieldFromInstruction(insn, 11, 5);
13462 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13463 tmp = fieldFromInstruction(insn, 16, 5);
13464 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13465 return S;
13466 case 311:
13467 tmp = fieldFromInstruction(insn, 6, 5);
13468 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13469 tmp = fieldFromInstruction(insn, 6, 5);
13470 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13471 tmp = fieldFromInstruction(insn, 11, 5);
13472 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13473 tmp = fieldFromInstruction(insn, 16, 5);
13474 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13475 return S;
13476 case 312:
13477 tmp = fieldFromInstruction(insn, 6, 5);
13478 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13479 tmp = fieldFromInstruction(insn, 6, 5);
13480 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13481 tmp = fieldFromInstruction(insn, 11, 5);
13482 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13483 tmp = fieldFromInstruction(insn, 16, 5);
13484 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13485 return S;
13486 case 313:
13487 tmp = fieldFromInstruction(insn, 6, 5);
13488 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13489 tmp = fieldFromInstruction(insn, 11, 5);
13490 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13491 tmp = fieldFromInstruction(insn, 16, 5);
13492 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13493 return S;
13494 case 314:
13495 tmp = fieldFromInstruction(insn, 6, 5);
13496 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13497 tmp = fieldFromInstruction(insn, 11, 5);
13498 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13499 tmp = fieldFromInstruction(insn, 16, 5);
13500 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13501 return S;
13502 case 315:
13503 tmp = fieldFromInstruction(insn, 6, 5);
13504 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13505 tmp = fieldFromInstruction(insn, 11, 5);
13506 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13507 tmp = fieldFromInstruction(insn, 16, 5);
13508 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13509 return S;
13510 case 316:
13511 tmp = fieldFromInstruction(insn, 6, 5);
13512 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13513 tmp = fieldFromInstruction(insn, 6, 5);
13514 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13515 tmp = fieldFromInstruction(insn, 11, 5);
13516 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13517 tmp = fieldFromInstruction(insn, 16, 5);
13518 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13519 return S;
13520 case 317:
13521 tmp = fieldFromInstruction(insn, 6, 5);
13522 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13523 tmp = fieldFromInstruction(insn, 6, 5);
13524 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13525 tmp = fieldFromInstruction(insn, 11, 5);
13526 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13527 tmp = fieldFromInstruction(insn, 16, 5);
13528 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13529 return S;
13530 case 318:
13531 tmp = fieldFromInstruction(insn, 6, 5);
13532 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13533 tmp = fieldFromInstruction(insn, 6, 5);
13534 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13535 tmp = fieldFromInstruction(insn, 11, 5);
13536 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13537 tmp = fieldFromInstruction(insn, 16, 5);
13538 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13539 return S;
13540 case 319:
13541 tmp = fieldFromInstruction(insn, 6, 5);
13542 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13543 tmp = fieldFromInstruction(insn, 6, 5);
13544 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13545 tmp = fieldFromInstruction(insn, 11, 5);
13546 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13547 tmp = fieldFromInstruction(insn, 16, 5);
13548 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13549 return S;
13550 case 320:
13551 tmp = fieldFromInstruction(insn, 6, 5);
13552 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13553 tmp = fieldFromInstruction(insn, 6, 5);
13554 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13555 tmp = fieldFromInstruction(insn, 11, 5);
13556 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13557 tmp = fieldFromInstruction(insn, 16, 5);
13558 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13559 return S;
13560 case 321:
13561 tmp = fieldFromInstruction(insn, 6, 5);
13562 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13563 tmp = fieldFromInstruction(insn, 6, 5);
13564 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13565 tmp = fieldFromInstruction(insn, 11, 5);
13566 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13567 tmp = fieldFromInstruction(insn, 16, 5);
13568 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13569 return S;
13570 case 322:
13571 tmp = fieldFromInstruction(insn, 6, 5);
13572 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13573 tmp = fieldFromInstruction(insn, 6, 5);
13574 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13575 tmp = fieldFromInstruction(insn, 11, 5);
13576 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13577 tmp = fieldFromInstruction(insn, 16, 5);
13578 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13579 return S;
13580 case 323:
13581 tmp = fieldFromInstruction(insn, 6, 5);
13582 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13583 tmp = fieldFromInstruction(insn, 11, 5);
13584 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13585 tmp = fieldFromInstruction(insn, 16, 5);
13586 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13587 return S;
13588 case 324:
13589 tmp = fieldFromInstruction(insn, 6, 5);
13590 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13591 tmp = fieldFromInstruction(insn, 11, 5);
13592 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13593 tmp = fieldFromInstruction(insn, 16, 5);
13594 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13595 return S;
13596 case 325:
13597 tmp = fieldFromInstruction(insn, 6, 5);
13598 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13599 tmp = fieldFromInstruction(insn, 11, 5);
13600 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13601 tmp = fieldFromInstruction(insn, 16, 5);
13602 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13603 return S;
13604 case 326:
13605 tmp = fieldFromInstruction(insn, 6, 5);
13606 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13607 tmp = fieldFromInstruction(insn, 11, 5);
13608 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13609 tmp = fieldFromInstruction(insn, 16, 5);
13610 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13611 return S;
13612 case 327:
13613 tmp = fieldFromInstruction(insn, 6, 5);
13614 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13615 tmp = fieldFromInstruction(insn, 6, 5);
13616 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13617 tmp = fieldFromInstruction(insn, 11, 5);
13618 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13619 tmp = fieldFromInstruction(insn, 16, 4);
13620 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13621 return S;
13622 case 328:
13623 tmp = fieldFromInstruction(insn, 6, 5);
13624 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13625 tmp = fieldFromInstruction(insn, 6, 5);
13626 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13627 tmp = fieldFromInstruction(insn, 11, 5);
13628 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13629 tmp = fieldFromInstruction(insn, 16, 3);
13630 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13631 return S;
13632 case 329:
13633 tmp = fieldFromInstruction(insn, 6, 5);
13634 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13635 tmp = fieldFromInstruction(insn, 6, 5);
13636 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13637 tmp = fieldFromInstruction(insn, 11, 5);
13638 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13639 tmp = fieldFromInstruction(insn, 16, 2);
13640 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13641 return S;
13642 case 330:
13643 tmp = fieldFromInstruction(insn, 6, 5);
13644 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13645 tmp = fieldFromInstruction(insn, 6, 5);
13646 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13647 tmp = fieldFromInstruction(insn, 11, 5);
13648 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13649 tmp = fieldFromInstruction(insn, 16, 1);
13650 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13651 return S;
13652 case 331:
13653 tmp = fieldFromInstruction(insn, 6, 5);
13654 if (!Check(S, DecodeMSACtrlRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13655 tmp = fieldFromInstruction(insn, 11, 5);
13656 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13657 return S;
13658 case 332:
13659 tmp = fieldFromInstruction(insn, 6, 5);
13660 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13661 tmp = fieldFromInstruction(insn, 11, 5);
13662 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13663 tmp = fieldFromInstruction(insn, 16, 4);
13664 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13665 return S;
13666 case 333:
13667 tmp = fieldFromInstruction(insn, 6, 5);
13668 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13669 tmp = fieldFromInstruction(insn, 11, 5);
13670 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13671 tmp = fieldFromInstruction(insn, 16, 3);
13672 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13673 return S;
13674 case 334:
13675 tmp = fieldFromInstruction(insn, 6, 5);
13676 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13677 tmp = fieldFromInstruction(insn, 11, 5);
13678 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13679 tmp = fieldFromInstruction(insn, 16, 2);
13680 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13681 return S;
13682 case 335:
13683 tmp = fieldFromInstruction(insn, 6, 5);
13684 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13685 tmp = fieldFromInstruction(insn, 11, 5);
13686 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13687 tmp = fieldFromInstruction(insn, 16, 1);
13688 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13689 return S;
13690 case 336:
13691 tmp = fieldFromInstruction(insn, 6, 5);
13692 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13693 tmp = fieldFromInstruction(insn, 11, 5);
13694 if (!Check(S, DecodeMSACtrlRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13695 return S;
13696 case 337:
13697 tmp = fieldFromInstruction(insn, 6, 5);
13698 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13699 tmp = fieldFromInstruction(insn, 11, 5);
13700 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13701 tmp = fieldFromInstruction(insn, 16, 4);
13702 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13703 return S;
13704 case 338:
13705 tmp = fieldFromInstruction(insn, 6, 5);
13706 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13707 tmp = fieldFromInstruction(insn, 11, 5);
13708 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13709 tmp = fieldFromInstruction(insn, 16, 3);
13710 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13711 return S;
13712 case 339:
13713 tmp = fieldFromInstruction(insn, 6, 5);
13714 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13715 tmp = fieldFromInstruction(insn, 11, 5);
13716 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13717 tmp = fieldFromInstruction(insn, 16, 2);
13718 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13719 return S;
13720 case 340:
13721 tmp = fieldFromInstruction(insn, 6, 5);
13722 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13723 tmp = fieldFromInstruction(insn, 11, 5);
13724 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13725 tmp = fieldFromInstruction(insn, 16, 1);
13726 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13727 return S;
13728 case 341:
13729 tmp = fieldFromInstruction(insn, 6, 5);
13730 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13731 tmp = fieldFromInstruction(insn, 11, 5);
13732 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13733 return S;
13734 case 342:
13735 tmp = fieldFromInstruction(insn, 6, 5);
13736 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13737 tmp = fieldFromInstruction(insn, 6, 5);
13738 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13739 tmp = fieldFromInstruction(insn, 11, 5);
13740 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13741 tmp = fieldFromInstruction(insn, 16, 4);
13742 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13743 return S;
13744 case 343:
13745 tmp = fieldFromInstruction(insn, 6, 5);
13746 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13747 tmp = fieldFromInstruction(insn, 6, 5);
13748 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13749 tmp = fieldFromInstruction(insn, 11, 5);
13750 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13751 tmp = fieldFromInstruction(insn, 16, 3);
13752 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13753 return S;
13754 case 344:
13755 tmp = fieldFromInstruction(insn, 6, 5);
13756 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13757 tmp = fieldFromInstruction(insn, 6, 5);
13758 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13759 tmp = fieldFromInstruction(insn, 11, 5);
13760 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13761 tmp = fieldFromInstruction(insn, 16, 2);
13762 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13763 return S;
13764 case 345:
13765 tmp = fieldFromInstruction(insn, 6, 5);
13766 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13767 tmp = fieldFromInstruction(insn, 6, 5);
13768 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13769 tmp = fieldFromInstruction(insn, 11, 5);
13770 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13771 tmp = fieldFromInstruction(insn, 16, 1);
13772 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13773 return S;
13774 case 346:
13775 if (!Check(S, DecodeINSVE_DF(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
13776 return S;
13777 case 347:
13778 tmp = fieldFromInstruction(insn, 6, 5);
13779 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13780 tmp = fieldFromInstruction(insn, 11, 5);
13781 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13782 tmp = fieldFromInstruction(insn, 16, 5);
13783 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13784 return S;
13785 case 348:
13786 tmp = fieldFromInstruction(insn, 6, 5);
13787 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13788 tmp = fieldFromInstruction(insn, 11, 5);
13789 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13790 tmp = fieldFromInstruction(insn, 16, 5);
13791 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13792 return S;
13793 case 349:
13794 tmp = fieldFromInstruction(insn, 6, 5);
13795 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13796 tmp = fieldFromInstruction(insn, 11, 5);
13797 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13798 return S;
13799 case 350:
13800 tmp = fieldFromInstruction(insn, 6, 5);
13801 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13802 tmp = fieldFromInstruction(insn, 11, 5);
13803 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13804 return S;
13805 case 351:
13806 tmp = fieldFromInstruction(insn, 6, 5);
13807 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13808 tmp = fieldFromInstruction(insn, 11, 5);
13809 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13810 return S;
13811 case 352:
13812 tmp = fieldFromInstruction(insn, 6, 5);
13813 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13814 tmp = fieldFromInstruction(insn, 11, 5);
13815 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13816 return S;
13817 case 353:
13818 tmp = fieldFromInstruction(insn, 6, 5);
13819 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13820 tmp = fieldFromInstruction(insn, 11, 5);
13821 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13822 return S;
13823 case 354:
13824 tmp = fieldFromInstruction(insn, 6, 5);
13825 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13826 tmp = fieldFromInstruction(insn, 11, 5);
13827 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13828 return S;
13829 case 355:
13830 tmp = fieldFromInstruction(insn, 6, 5);
13831 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13832 tmp = fieldFromInstruction(insn, 11, 5);
13833 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13834 return S;
13835 case 356:
13836 tmp = fieldFromInstruction(insn, 6, 5);
13837 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13838 tmp = fieldFromInstruction(insn, 11, 5);
13839 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13840 return S;
13841 case 357:
13842 tmp = fieldFromInstruction(insn, 6, 5);
13843 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13844 tmp = fieldFromInstruction(insn, 11, 5);
13845 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13846 return S;
13847 case 358:
13848 tmp = fieldFromInstruction(insn, 6, 5);
13849 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13850 tmp = fieldFromInstruction(insn, 11, 5);
13851 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13852 tmp = fieldFromInstruction(insn, 16, 10);
13853 if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13854 return S;
13855 case 359:
13856 tmp = fieldFromInstruction(insn, 6, 5);
13857 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13858 tmp = fieldFromInstruction(insn, 11, 5);
13859 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13860 tmp = fieldFromInstruction(insn, 16, 10);
13861 if (!Check(S, DecodeSImmWithOffsetAndScale<10, 0, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13862 return S;
13863 case 360:
13864 tmp = fieldFromInstruction(insn, 6, 5);
13865 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13866 tmp = fieldFromInstruction(insn, 11, 5);
13867 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13868 tmp = fieldFromInstruction(insn, 16, 10);
13869 if (!Check(S, DecodeSImmWithOffsetAndScale<10, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13870 return S;
13871 case 361:
13872 tmp = fieldFromInstruction(insn, 6, 5);
13873 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13874 tmp = fieldFromInstruction(insn, 11, 5);
13875 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13876 tmp = fieldFromInstruction(insn, 16, 10);
13877 if (!Check(S, DecodeSImmWithOffsetAndScale<10, 0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13878 return S;
13879 case 362:
13880 tmp = fieldFromInstruction(insn, 16, 5);
13881 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13882 tmp = fieldFromInstruction(insn, 21, 5);
13883 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13884 tmp = fieldFromInstruction(insn, 6, 5);
13885 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13886 tmp = fieldFromInstruction(insn, 11, 5);
13887 if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13888 return S;
13889 case 363:
13890 tmp = fieldFromInstruction(insn, 16, 5);
13891 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13892 tmp = fieldFromInstruction(insn, 21, 5);
13893 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13894 tmp = fieldFromInstruction(insn, 6, 5);
13895 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13896 tmp = fieldFromInstruction(insn, 11, 5);
13897 if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13898 tmp = fieldFromInstruction(insn, 16, 5);
13899 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13900 return S;
13901 case 364:
13902 tmp = fieldFromInstruction(insn, 21, 5);
13903 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13904 tmp = fieldFromInstruction(insn, 11, 5);
13905 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13906 tmp = fieldFromInstruction(insn, 16, 5);
13907 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13908 return S;
13909 case 365:
13910 tmp = fieldFromInstruction(insn, 11, 5);
13911 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13912 tmp = fieldFromInstruction(insn, 21, 5);
13913 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13914 tmp = fieldFromInstruction(insn, 16, 5);
13915 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13916 return S;
13917 case 366:
13918 tmp = fieldFromInstruction(insn, 16, 5);
13919 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13920 tmp = fieldFromInstruction(insn, 16, 5);
13921 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13922 tmp = fieldFromInstruction(insn, 21, 5);
13923 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13924 return S;
13925 case 367:
13926 tmp = fieldFromInstruction(insn, 11, 5);
13927 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13928 tmp = fieldFromInstruction(insn, 21, 5);
13929 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13930 tmp = fieldFromInstruction(insn, 16, 5);
13931 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13932 return S;
13933 case 368:
13934 tmp = fieldFromInstruction(insn, 11, 5);
13935 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13936 tmp = fieldFromInstruction(insn, 21, 5);
13937 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13938 return S;
13939 case 369:
13940 tmp = fieldFromInstruction(insn, 11, 5);
13941 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13942 tmp = fieldFromInstruction(insn, 21, 5);
13943 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13944 tmp = fieldFromInstruction(insn, 16, 5);
13945 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13946 return S;
13947 case 370:
13948 tmp = fieldFromInstruction(insn, 11, 5);
13949 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13950 tmp = fieldFromInstruction(insn, 21, 5);
13951 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13952 tmp = fieldFromInstruction(insn, 16, 5);
13953 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13954 return S;
13955 case 371:
13956 tmp = fieldFromInstruction(insn, 16, 5);
13957 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13958 tmp = fieldFromInstruction(insn, 21, 5);
13959 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13960 tmp = fieldFromInstruction(insn, 11, 5);
13961 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13962 tmp = fieldFromInstruction(insn, 16, 5);
13963 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13964 return S;
13965 case 372:
13966 tmp = fieldFromInstruction(insn, 11, 5);
13967 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13968 tmp = fieldFromInstruction(insn, 16, 5);
13969 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13970 return S;
13971 case 373:
13972 tmp = fieldFromInstruction(insn, 11, 5);
13973 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13974 tmp = fieldFromInstruction(insn, 16, 10);
13975 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
13976 return S;
13977 case 374:
13978 tmp = fieldFromInstruction(insn, 11, 5);
13979 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13980 tmp = fieldFromInstruction(insn, 16, 5);
13981 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13982 return S;
13983 case 375:
13984 tmp = fieldFromInstruction(insn, 11, 5);
13985 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13986 tmp = fieldFromInstruction(insn, 16, 5);
13987 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13988 return S;
13989 case 376:
13990 tmp = fieldFromInstruction(insn, 11, 5);
13991 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13992 tmp = fieldFromInstruction(insn, 16, 5);
13993 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13994 return S;
13995 case 377:
13996 tmp = fieldFromInstruction(insn, 11, 5);
13997 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
13998 tmp = fieldFromInstruction(insn, 16, 5);
13999 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14000 tmp = fieldFromInstruction(insn, 21, 5);
14001 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14002 return S;
14003 case 378:
14004 tmp = fieldFromInstruction(insn, 11, 5);
14005 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14006 tmp = fieldFromInstruction(insn, 16, 5);
14007 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14008 tmp = fieldFromInstruction(insn, 21, 5);
14009 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14010 return S;
14011 case 379:
14012 tmp = fieldFromInstruction(insn, 11, 5);
14013 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14014 tmp = fieldFromInstruction(insn, 16, 5);
14015 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14016 tmp = fieldFromInstruction(insn, 21, 5);
14017 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14018 return S;
14019 case 380:
14020 tmp = fieldFromInstruction(insn, 16, 5);
14021 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14022 tmp = fieldFromInstruction(insn, 21, 5);
14023 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14024 tmp = fieldFromInstruction(insn, 7, 9);
14025 if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14026 tmp = fieldFromInstruction(insn, 16, 5);
14027 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14028 return S;
14029 case 381:
14030 tmp = fieldFromInstruction(insn, 21, 5);
14031 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14032 tmp = fieldFromInstruction(insn, 7, 9);
14033 if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14034 tmp = fieldFromInstruction(insn, 16, 5);
14035 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14036 return S;
14037 case 382:
14038 tmp = fieldFromInstruction(insn, 16, 5);
14039 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14040 tmp = fieldFromInstruction(insn, 21, 5);
14041 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14042 tmp = fieldFromInstruction(insn, 7, 9);
14043 if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14044 return S;
14045 case 383:
14046 tmp = fieldFromInstruction(insn, 16, 5);
14047 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14048 tmp = fieldFromInstruction(insn, 16, 5);
14049 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14050 tmp = fieldFromInstruction(insn, 21, 5);
14051 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14052 tmp = fieldFromInstruction(insn, 7, 9);
14053 if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14054 return S;
14055 case 384:
14056 tmp = fieldFromInstruction(insn, 11, 2);
14057 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14058 tmp = fieldFromInstruction(insn, 21, 5);
14059 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14060 tmp = fieldFromInstruction(insn, 16, 5);
14061 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14062 tmp = fieldFromInstruction(insn, 11, 2);
14063 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14064 return S;
14065 case 385:
14066 tmp = fieldFromInstruction(insn, 16, 5);
14067 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14068 tmp = fieldFromInstruction(insn, 21, 5);
14069 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14070 tmp = fieldFromInstruction(insn, 11, 5);
14071 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14072 tmp = fieldFromInstruction(insn, 16, 5);
14073 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14074 return S;
14075 case 386:
14076 tmp = fieldFromInstruction(insn, 16, 5);
14077 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14078 tmp = fieldFromInstruction(insn, 11, 2);
14079 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14080 tmp = fieldFromInstruction(insn, 21, 5);
14081 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14082 return S;
14083 case 387:
14084 tmp = fieldFromInstruction(insn, 16, 5);
14085 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14086 tmp = fieldFromInstruction(insn, 11, 2);
14087 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14088 tmp = fieldFromInstruction(insn, 21, 5);
14089 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14090 return S;
14091 case 388:
14092 tmp = fieldFromInstruction(insn, 11, 5);
14093 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14094 tmp = fieldFromInstruction(insn, 16, 10);
14095 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14096 return S;
14097 case 389:
14098 tmp = fieldFromInstruction(insn, 21, 5);
14099 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14100 tmp = fieldFromInstruction(insn, 11, 10);
14101 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14102 return S;
14103 case 390:
14104 tmp = fieldFromInstruction(insn, 11, 2);
14105 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14106 tmp = fieldFromInstruction(insn, 20, 6);
14107 if (!Check(S, DecodeSImmWithOffsetAndScale<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14108 tmp = fieldFromInstruction(insn, 11, 2);
14109 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14110 return S;
14111 case 391:
14112 tmp = fieldFromInstruction(insn, 11, 2);
14113 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14114 tmp = fieldFromInstruction(insn, 21, 5);
14115 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14116 tmp = fieldFromInstruction(insn, 11, 2);
14117 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14118 return S;
14119 case 392:
14120 tmp = fieldFromInstruction(insn, 16, 5);
14121 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14122 tmp = fieldFromInstruction(insn, 11, 5);
14123 if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14124 tmp = fieldFromInstruction(insn, 6, 3);
14125 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14126 return S;
14127 case 393:
14128 tmp = fieldFromInstruction(insn, 16, 5);
14129 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14130 tmp = fieldFromInstruction(insn, 21, 5);
14131 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14132 tmp = fieldFromInstruction(insn, 0, 16);
14133 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14134 return S;
14135 case 394:
14136 tmp = fieldFromInstruction(insn, 16, 5);
14137 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14138 tmp = fieldFromInstruction(insn, 21, 5);
14139 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14140 tmp = fieldFromInstruction(insn, 0, 16);
14141 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14142 tmp = fieldFromInstruction(insn, 16, 5);
14143 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14144 return S;
14145 case 395:
14146 tmp = fieldFromInstruction(insn, 21, 5);
14147 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14148 tmp = fieldFromInstruction(insn, 0, 16);
14149 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14150 tmp = fieldFromInstruction(insn, 16, 5);
14151 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14152 return S;
14153 case 396:
14154 tmp = fieldFromInstruction(insn, 16, 5);
14155 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14156 tmp = fieldFromInstruction(insn, 21, 5);
14157 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14158 tmp = fieldFromInstruction(insn, 0, 16);
14159 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14160 return S;
14161 case 397:
14162 tmp = fieldFromInstruction(insn, 16, 5);
14163 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14164 tmp = fieldFromInstruction(insn, 21, 5);
14165 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14166 tmp = fieldFromInstruction(insn, 0, 16);
14167 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14168 return S;
14169 case 398:
14170 tmp = fieldFromInstruction(insn, 16, 5);
14171 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14172 tmp = fieldFromInstruction(insn, 21, 5);
14173 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14174 tmp = fieldFromInstruction(insn, 0, 16);
14175 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14176 return S;
14177 case 399:
14178 tmp = fieldFromInstruction(insn, 16, 5);
14179 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14180 tmp = fieldFromInstruction(insn, 16, 5);
14181 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14182 tmp = fieldFromInstruction(insn, 21, 5);
14183 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14184 tmp = fieldFromInstruction(insn, 0, 16);
14185 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14186 return S;
14187 case 400:
14188 if (!Check(S, DecodeDAHIDATI(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
14189 return S;
14190 case 401:
14191 tmp = fieldFromInstruction(insn, 0, 16);
14192 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14193 return S;
14194 case 402:
14195 if (!Check(S, DecodeBlezGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
14196 return S;
14197 case 403:
14198 if (!Check(S, DecodeBgtzGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
14199 return S;
14200 case 404:
14201 if (!Check(S, DecodeAddiGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
14202 return S;
14203 case 405:
14204 tmp = fieldFromInstruction(insn, 16, 5);
14205 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14206 tmp = fieldFromInstruction(insn, 0, 16);
14207 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14208 return S;
14209 case 406:
14210 tmp = fieldFromInstruction(insn, 6, 5);
14211 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14212 tmp = fieldFromInstruction(insn, 6, 5);
14213 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14214 tmp = fieldFromInstruction(insn, 11, 5);
14215 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14216 tmp = fieldFromInstruction(insn, 16, 5);
14217 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14218 return S;
14219 case 407:
14220 tmp = fieldFromInstruction(insn, 6, 5);
14221 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14222 tmp = fieldFromInstruction(insn, 6, 5);
14223 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14224 tmp = fieldFromInstruction(insn, 11, 5);
14225 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14226 tmp = fieldFromInstruction(insn, 16, 5);
14227 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14228 return S;
14229 case 408:
14230 tmp = fieldFromInstruction(insn, 6, 5);
14231 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14232 tmp = fieldFromInstruction(insn, 11, 5);
14233 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14234 tmp = fieldFromInstruction(insn, 16, 5);
14235 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14236 return S;
14237 case 409:
14238 tmp = fieldFromInstruction(insn, 16, 5);
14239 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14240 tmp = fieldFromInstruction(insn, 0, 16);
14241 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14242 return S;
14243 case 410:
14244 tmp = fieldFromInstruction(insn, 16, 5);
14245 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14246 tmp = fieldFromInstruction(insn, 11, 5);
14247 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14248 tmp = fieldFromInstruction(insn, 0, 11);
14249 if (!Check(S, DecodeSImmWithOffsetAndScale<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14250 return S;
14251 case 411:
14252 if (!Check(S, DecodeBlezlGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
14253 return S;
14254 case 412:
14255 if (!Check(S, DecodeBgtzlGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
14256 return S;
14257 case 413:
14258 if (!Check(S, DecodeDaddiGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
14259 return S;
14260 case 414:
14261 tmp = fieldFromInstruction(insn, 16, 5);
14262 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14263 tmp = fieldFromInstruction(insn, 21, 5);
14264 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14265 tmp = fieldFromInstruction(insn, 0, 16);
14266 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14267 return S;
14268 case 415:
14269 if (!Check(S, DecodeCRC(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
14270 return S;
14271 case 416:
14272 tmp = fieldFromInstruction(insn, 11, 5);
14273 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14274 tmp = fieldFromInstruction(insn, 21, 5);
14275 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14276 tmp = fieldFromInstruction(insn, 16, 5);
14277 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14278 tmp = fieldFromInstruction(insn, 6, 2);
14279 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14280 return S;
14281 case 417:
14282 tmp = fieldFromInstruction(insn, 11, 5);
14283 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14284 tmp = fieldFromInstruction(insn, 16, 5);
14285 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14286 return S;
14287 case 418:
14288 tmp = fieldFromInstruction(insn, 11, 5);
14289 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14290 tmp = fieldFromInstruction(insn, 21, 5);
14291 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14292 tmp = fieldFromInstruction(insn, 16, 5);
14293 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14294 tmp = fieldFromInstruction(insn, 6, 3);
14295 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14296 return S;
14297 case 419:
14298 tmp = fieldFromInstruction(insn, 16, 5);
14299 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14300 tmp = fieldFromInstruction(insn, 16, 5);
14301 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14302 tmp = fieldFromInstruction(insn, 21, 5);
14303 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14304 tmp = fieldFromInstruction(insn, 7, 9);
14305 if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14306 return S;
14307 case 420:
14308 tmp = fieldFromInstruction(insn, 16, 5);
14309 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14310 tmp = fieldFromInstruction(insn, 21, 5);
14311 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14312 tmp = fieldFromInstruction(insn, 7, 9);
14313 if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14314 return S;
14315 case 421:
14316 tmp = fieldFromInstruction(insn, 21, 5);
14317 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14318 tmp = fieldFromInstruction(insn, 8, 2);
14319 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14320 return S;
14321 case 422:
14322 tmp = fieldFromInstruction(insn, 0, 26);
14323 if (!Check(S, DecodeBranchTarget26(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14324 return S;
14325 case 423:
14326 tmp = fieldFromInstruction(insn, 21, 5);
14327 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14328 tmp = fieldFromInstruction(insn, 0, 21);
14329 if (!Check(S, DecodeBranchTarget21(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14330 return S;
14331 case 424:
14332 tmp = fieldFromInstruction(insn, 21, 5);
14333 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14334 tmp = fieldFromInstruction(insn, 0, 18);
14335 if (!Check(S, DecodeSimm18Lsl3(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14336 return S;
14337 case 425:
14338 tmp = fieldFromInstruction(insn, 21, 5);
14339 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14340 tmp = fieldFromInstruction(insn, 0, 21);
14341 if (!Check(S, DecodeBranchTarget21(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14342 return S;
14343 case 426:
14344 tmp = fieldFromInstruction(insn, 11, 5);
14345 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14346 tmp = fieldFromInstruction(insn, 16, 5);
14347 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14348 tmp = fieldFromInstruction(insn, 21, 5);
14349 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14350 return S;
14351 case 427:
14352 tmp = fieldFromInstruction(insn, 21, 5);
14353 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14354 tmp = fieldFromInstruction(insn, 16, 5);
14355 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14356 return S;
14357 case 428:
14358 tmp = fieldFromInstruction(insn, 11, 5);
14359 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14360 tmp = fieldFromInstruction(insn, 16, 5);
14361 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14362 tmp = fieldFromInstruction(insn, 6, 5);
14363 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14364 return S;
14365 case 429:
14366 tmp = fieldFromInstruction(insn, 16, 5);
14367 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14368 tmp = 0x0;
14369 tmp |= fieldFromInstruction(insn, 0, 3);
14370 tmp |= fieldFromInstruction(insn, 11, 5) << 5;
14371 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14372 return S;
14373 case 430:
14374 tmp = 0x0;
14375 tmp |= fieldFromInstruction(insn, 0, 3);
14376 tmp |= fieldFromInstruction(insn, 11, 5) << 5;
14377 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14378 tmp = fieldFromInstruction(insn, 16, 5);
14379 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14380 return S;
14381 case 431:
14382 tmp = fieldFromInstruction(insn, 16, 5);
14383 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14384 tmp = fieldFromInstruction(insn, 11, 5);
14385 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14386 tmp = fieldFromInstruction(insn, 0, 3);
14387 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14388 return S;
14389 case 432:
14390 tmp = fieldFromInstruction(insn, 11, 5);
14391 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14392 tmp = fieldFromInstruction(insn, 16, 5);
14393 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14394 tmp = fieldFromInstruction(insn, 0, 3);
14395 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14396 return S;
14397 case 433:
14398 tmp = fieldFromInstruction(insn, 13, 3);
14399 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14400 tmp = fieldFromInstruction(insn, 16, 5);
14401 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14402 tmp = fieldFromInstruction(insn, 21, 5);
14403 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14404 return S;
14405 case 434:
14406 tmp = fieldFromInstruction(insn, 16, 5);
14407 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14408 tmp = fieldFromInstruction(insn, 21, 5);
14409 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14410 tmp = fieldFromInstruction(insn, 0, 16);
14411 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14412 return S;
14413 case 435:
14414 tmp = fieldFromInstruction(insn, 16, 5);
14415 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14416 tmp = fieldFromInstruction(insn, 21, 5);
14417 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14418 tmp = fieldFromInstruction(insn, 0, 16);
14419 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14420 tmp = fieldFromInstruction(insn, 16, 5);
14421 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14422 return S;
14423 case 436:
14424 tmp = 0x0;
14425 tmp |= fieldFromInstruction(insn, 11, 5);
14426 tmp |= fieldFromInstruction(insn, 16, 5);
14427 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14428 tmp = fieldFromInstruction(insn, 21, 5);
14429 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14430 return S;
14431 case 437:
14432 if (!Check(S, DecodeDEXT(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
14433 return S;
14434 case 438:
14435 if (!Check(S, DecodeDINS(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
14436 return S;
14437 case 439:
14438 tmp = fieldFromInstruction(insn, 16, 5);
14439 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14440 tmp = fieldFromInstruction(insn, 21, 5);
14441 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14442 tmp = fieldFromInstruction(insn, 0, 16);
14443 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14444 return S;
14445 case 440:
14446 tmp = fieldFromInstruction(insn, 16, 5);
14447 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14448 tmp = fieldFromInstruction(insn, 16, 5);
14449 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14450 tmp = fieldFromInstruction(insn, 21, 5);
14451 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14452 tmp = fieldFromInstruction(insn, 0, 16);
14453 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14454 return S;
14455 case 441:
14456 tmp = fieldFromInstruction(insn, 16, 5);
14457 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14458 tmp = fieldFromInstruction(insn, 21, 5);
14459 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14460 tmp = fieldFromInstruction(insn, 0, 16);
14461 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14462 return S;
14463 case 442:
14464 tmp = fieldFromInstruction(insn, 16, 5);
14465 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14466 tmp = fieldFromInstruction(insn, 11, 5);
14467 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14468 return S;
14469 case 443:
14470 tmp = fieldFromInstruction(insn, 11, 5);
14471 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14472 tmp = fieldFromInstruction(insn, 16, 5);
14473 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14474 return S;
14475 case 444:
14476 tmp = fieldFromInstruction(insn, 11, 5);
14477 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14478 tmp = fieldFromInstruction(insn, 11, 5);
14479 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14480 tmp = fieldFromInstruction(insn, 16, 5);
14481 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14482 return S;
14483 case 445:
14484 tmp = fieldFromInstruction(insn, 6, 5);
14485 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14486 tmp = fieldFromInstruction(insn, 11, 5);
14487 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14488 return S;
14489 case 446:
14490 tmp = fieldFromInstruction(insn, 6, 5);
14491 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14492 tmp = fieldFromInstruction(insn, 11, 5);
14493 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14494 tmp = fieldFromInstruction(insn, 18, 3);
14495 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14496 tmp = fieldFromInstruction(insn, 6, 5);
14497 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14498 return S;
14499 case 447:
14500 tmp = fieldFromInstruction(insn, 6, 5);
14501 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14502 tmp = fieldFromInstruction(insn, 11, 5);
14503 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14504 tmp = fieldFromInstruction(insn, 16, 5);
14505 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14506 tmp = fieldFromInstruction(insn, 6, 5);
14507 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14508 return S;
14509 case 448:
14510 tmp = fieldFromInstruction(insn, 6, 5);
14511 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14512 tmp = fieldFromInstruction(insn, 11, 5);
14513 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14514 tmp = fieldFromInstruction(insn, 16, 5);
14515 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14516 return S;
14517 case 449:
14518 tmp = fieldFromInstruction(insn, 8, 3);
14519 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14520 tmp = fieldFromInstruction(insn, 11, 5);
14521 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14522 tmp = fieldFromInstruction(insn, 16, 5);
14523 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14524 return S;
14525 case 450:
14526 tmp = fieldFromInstruction(insn, 6, 5);
14527 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14528 tmp = fieldFromInstruction(insn, 21, 5);
14529 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14530 tmp = fieldFromInstruction(insn, 16, 5);
14531 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14532 return S;
14533 case 451:
14534 tmp = fieldFromInstruction(insn, 11, 5);
14535 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14536 tmp = fieldFromInstruction(insn, 21, 5);
14537 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14538 tmp = fieldFromInstruction(insn, 16, 5);
14539 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14540 return S;
14541 case 452:
14542 tmp = fieldFromInstruction(insn, 6, 5);
14543 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14544 tmp = fieldFromInstruction(insn, 21, 5);
14545 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14546 tmp = fieldFromInstruction(insn, 11, 5);
14547 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14548 tmp = fieldFromInstruction(insn, 16, 5);
14549 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14550 return S;
14551 case 453:
14552 tmp = fieldFromInstruction(insn, 0, 18);
14553 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14554 return S;
14555 case 454:
14556 tmp = fieldFromInstruction(insn, 0, 19);
14557 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14558 return S;
14559 case 455:
14560 tmp = fieldFromInstruction(insn, 21, 5);
14561 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14562 tmp = 0x0;
14563 tmp |= fieldFromInstruction(insn, 0, 1) << 21;
14564 tmp |= fieldFromInstruction(insn, 1, 20) << 1;
14565 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14566 return S;
14567 case 456:
14568 tmp = fieldFromInstruction(insn, 24, 1);
14569 if (!Check(S, DecodeGPRNM1R1RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14570 tmp = 0x0;
14571 tmp |= fieldFromInstruction(insn, 21, 3);
14572 tmp |= fieldFromInstruction(insn, 25, 1) << 4;
14573 if (!Check(S, DecodeGPRNM4ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14574 tmp = 0x0;
14575 tmp |= fieldFromInstruction(insn, 0, 1) << 21;
14576 tmp |= fieldFromInstruction(insn, 1, 20) << 1;
14577 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14578 return S;
14579 case 457:
14580 tmp = fieldFromInstruction(insn, 16, 5);
14581 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14582 tmp = fieldFromInstruction(insn, 21, 5);
14583 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14584 tmp = fieldFromInstruction(insn, 11, 5);
14585 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14586 return S;
14587 case 458:
14588 tmp = fieldFromInstruction(insn, 21, 5);
14589 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14590 tmp = fieldFromInstruction(insn, 16, 5);
14591 if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14592 tmp = fieldFromInstruction(insn, 11, 5);
14593 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14594 return S;
14595 case 459:
14596 tmp = fieldFromInstruction(insn, 11, 5);
14597 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14598 tmp = fieldFromInstruction(insn, 21, 5);
14599 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14600 tmp = fieldFromInstruction(insn, 16, 5);
14601 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14602 return S;
14603 case 460:
14604 tmp = fieldFromInstruction(insn, 11, 5);
14605 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14606 tmp = fieldFromInstruction(insn, 16, 5);
14607 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14608 tmp = fieldFromInstruction(insn, 21, 5);
14609 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14610 tmp = fieldFromInstruction(insn, 9, 2);
14611 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14612 return S;
14613 case 461:
14614 tmp = fieldFromInstruction(insn, 11, 5);
14615 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14616 tmp = fieldFromInstruction(insn, 16, 5);
14617 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14618 tmp = fieldFromInstruction(insn, 21, 5);
14619 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14620 tmp = fieldFromInstruction(insn, 6, 5);
14621 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14622 return S;
14623 case 462:
14624 tmp = fieldFromInstruction(insn, 21, 5);
14625 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14626 tmp = fieldFromInstruction(insn, 11, 10);
14627 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14628 return S;
14629 case 463:
14630 tmp = fieldFromInstruction(insn, 16, 5);
14631 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14632 tmp = fieldFromInstruction(insn, 21, 2);
14633 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14634 return S;
14635 case 464:
14636 tmp = 0x0;
14637 tmp |= fieldFromInstruction(insn, 0, 1) << 25;
14638 tmp |= fieldFromInstruction(insn, 1, 24) << 1;
14639 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14640 return S;
14641 case 465:
14642 tmp = fieldFromInstruction(insn, 21, 5);
14643 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14644 tmp = fieldFromInstruction(insn, 2, 19) << 2;
14645 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14646 return S;
14647 case 466:
14648 tmp = fieldFromInstruction(insn, 21, 5);
14649 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14650 if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder)))
14651 return MCDisassembler::Fail;
14652 tmp = fieldFromInstruction(insn, 2, 19) << 2;
14653 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14654 return S;
14655 case 467:
14656 tmp = fieldFromInstruction(insn, 21, 5);
14657 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14658 if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder)))
14659 return MCDisassembler::Fail;
14660 tmp = fieldFromInstruction(insn, 0, 18);
14661 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14662 return S;
14663 case 468:
14664 tmp = fieldFromInstruction(insn, 21, 5);
14665 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14666 tmp = fieldFromInstruction(insn, 0, 18);
14667 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14668 return S;
14669 case 469:
14670 tmp = fieldFromInstruction(insn, 21, 5);
14671 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14672 if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder)))
14673 return MCDisassembler::Fail;
14674 tmp = fieldFromInstruction(insn, 1, 17) << 1;
14675 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14676 return S;
14677 case 470:
14678 tmp = fieldFromInstruction(insn, 21, 5);
14679 if (!Check(S, DecodeGPR32NONZERORegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14680 tmp = fieldFromInstruction(insn, 16, 5);
14681 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14682 return S;
14683 case 471:
14684 tmp = fieldFromInstruction(insn, 21, 5);
14685 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14686 tmp = fieldFromInstruction(insn, 16, 5);
14687 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14688 tmp = fieldFromInstruction(insn, 0, 12);
14689 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14690 return S;
14691 case 472:
14692 tmp = fieldFromInstruction(insn, 3, 9) << 3;
14693 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14694 tmp = 0x0;
14695 tmp |= fieldFromInstruction(insn, 2, 1);
14696 tmp |= fieldFromInstruction(insn, 16, 4) << 1;
14697 tmp |= fieldFromInstruction(insn, 21, 5) << 5;
14698 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14699 return S;
14700 case 473:
14701 tmp = fieldFromInstruction(insn, 21, 5);
14702 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14703 tmp = fieldFromInstruction(insn, 16, 5);
14704 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14705 tmp = fieldFromInstruction(insn, 0, 5);
14706 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14707 return S;
14708 case 474:
14709 tmp = fieldFromInstruction(insn, 21, 5);
14710 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14711 tmp = fieldFromInstruction(insn, 16, 5);
14712 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14713 tmp = fieldFromInstruction(insn, 0, 5);
14714 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14715 tmp = fieldFromInstruction(insn, 7, 4) << 1;
14716 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14717 tmp = fieldFromInstruction(insn, 6, 1);
14718 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14719 return S;
14720 case 475:
14721 tmp = fieldFromInstruction(insn, 21, 5);
14722 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14723 tmp = fieldFromInstruction(insn, 16, 5);
14724 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14725 tmp = fieldFromInstruction(insn, 0, 5);
14726 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14727 tmp = fieldFromInstruction(insn, 6, 5);
14728 if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14729 tmp = fieldFromInstruction(insn, 21, 5);
14730 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14731 return S;
14732 case 476:
14733 tmp = fieldFromInstruction(insn, 21, 5);
14734 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14735 tmp = fieldFromInstruction(insn, 16, 5);
14736 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14737 tmp = fieldFromInstruction(insn, 0, 5);
14738 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14739 tmp = fieldFromInstruction(insn, 6, 5);
14740 if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14741 return S;
14742 case 477:
14743 tmp = fieldFromInstruction(insn, 21, 5);
14744 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14745 tmp = fieldFromInstruction(insn, 16, 5);
14746 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14747 tmp = fieldFromInstruction(insn, 0, 12);
14748 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14749 return S;
14750 case 478:
14751 tmp = fieldFromInstruction(insn, 16, 5);
14752 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14753 tmp = fieldFromInstruction(insn, 0, 12);
14754 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14755 return S;
14756 case 479:
14757 tmp = fieldFromInstruction(insn, 21, 5);
14758 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14759 tmp = fieldFromInstruction(insn, 16, 5);
14760 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14761 tmp = fieldFromInstruction(insn, 0, 12);
14762 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14763 return S;
14764 case 480:
14765 tmp = fieldFromInstruction(insn, 16, 5);
14766 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14767 tmp = fieldFromInstruction(insn, 21, 5);
14768 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14769 tmp = 0x0;
14770 tmp |= fieldFromInstruction(insn, 0, 1) << 14;
14771 tmp |= fieldFromInstruction(insn, 1, 13) << 1;
14772 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14773 return S;
14774 case 481:
14775 tmp = fieldFromInstruction(insn, 21, 5);
14776 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14777 tmp = fieldFromInstruction(insn, 16, 5);
14778 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14779 tmp = 0x0;
14780 tmp |= fieldFromInstruction(insn, 0, 8);
14781 tmp |= fieldFromInstruction(insn, 15, 1) << 8;
14782 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14783 return S;
14784 case 482:
14785 tmp = fieldFromInstruction(insn, 21, 5);
14786 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14787 tmp = fieldFromInstruction(insn, 16, 5);
14788 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14789 tmp = 0x0;
14790 tmp |= fieldFromInstruction(insn, 0, 8);
14791 tmp |= fieldFromInstruction(insn, 15, 1) << 8;
14792 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14793 tmp = fieldFromInstruction(insn, 21, 5);
14794 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14795 return S;
14796 case 483:
14797 tmp = fieldFromInstruction(insn, 21, 5);
14798 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14799 tmp = fieldFromInstruction(insn, 16, 5);
14800 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14801 tmp = 0x0;
14802 tmp |= fieldFromInstruction(insn, 2, 6) << 2;
14803 tmp |= fieldFromInstruction(insn, 15, 1) << 8;
14804 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14805 return S;
14806 case 484:
14807 tmp = fieldFromInstruction(insn, 21, 5);
14808 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14809 tmp = fieldFromInstruction(insn, 3, 5);
14810 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14811 tmp = fieldFromInstruction(insn, 16, 5);
14812 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14813 return S;
14814 case 485:
14815 tmp = fieldFromInstruction(insn, 21, 5);
14816 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14817 tmp = fieldFromInstruction(insn, 16, 5);
14818 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14819 tmp = 0x0;
14820 tmp |= fieldFromInstruction(insn, 0, 8);
14821 tmp |= fieldFromInstruction(insn, 15, 1) << 8;
14822 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14823 tmp = fieldFromInstruction(insn, 12, 3);
14824 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14825 return S;
14826 case 486:
14827 tmp = fieldFromInstruction(insn, 16, 5);
14828 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14829 tmp = 0x0;
14830 tmp |= fieldFromInstruction(insn, 0, 8);
14831 tmp |= fieldFromInstruction(insn, 15, 1) << 8;
14832 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14833 return S;
14834 case 487:
14835 tmp = fieldFromInstruction(insn, 21, 5);
14836 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14837 tmp = fieldFromInstruction(insn, 16, 5);
14838 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14839 tmp = 0x0;
14840 tmp |= fieldFromInstruction(insn, 0, 8);
14841 tmp |= fieldFromInstruction(insn, 15, 1) << 8;
14842 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14843 return S;
14844 case 488:
14845 tmp = fieldFromInstruction(insn, 21, 5);
14846 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14847 tmp = fieldFromInstruction(insn, 21, 5);
14848 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14849 tmp = fieldFromInstruction(insn, 16, 5);
14850 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14851 tmp = 0x0;
14852 tmp |= fieldFromInstruction(insn, 2, 6) << 2;
14853 tmp |= fieldFromInstruction(insn, 15, 1) << 8;
14854 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14855 return S;
14856 case 489:
14857 tmp = fieldFromInstruction(insn, 21, 5);
14858 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14859 tmp = fieldFromInstruction(insn, 21, 5);
14860 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14861 tmp = fieldFromInstruction(insn, 3, 5);
14862 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14863 tmp = fieldFromInstruction(insn, 16, 5);
14864 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14865 return S;
14866 case 490:
14867 tmp = fieldFromInstruction(insn, 21, 5);
14868 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14869 tmp = fieldFromInstruction(insn, 11, 7);
14870 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14871 tmp = 0x0;
14872 tmp |= fieldFromInstruction(insn, 0, 1) << 11;
14873 tmp |= fieldFromInstruction(insn, 1, 10) << 1;
14874 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14875 return S;
14876 case 491:
14877 tmp = fieldFromInstruction(insn, 21, 5);
14878 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14879 tmp = fieldFromInstruction(insn, 11, 6);
14880 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14881 tmp = 0x0;
14882 tmp |= fieldFromInstruction(insn, 0, 1) << 11;
14883 tmp |= fieldFromInstruction(insn, 1, 10) << 1;
14884 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14885 return S;
14886 case 492:
14887 tmp = fieldFromInstruction(insn, 21, 5);
14888 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14889 tmp = 0x0;
14890 tmp |= fieldFromInstruction(insn, 0, 1) << 19;
14891 tmp |= fieldFromInstruction(insn, 2, 10) << 9;
14892 tmp |= fieldFromInstruction(insn, 12, 9);
14893 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14894 return S;
14895 case 493:
14896 tmp = fieldFromInstruction(insn, 37, 5);
14897 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14898 tmp = 0x0;
14899 tmp |= fieldFromInstruction(insn, 0, 16) << 16;
14900 tmp |= fieldFromInstruction(insn, 16, 16);
14901 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14902 return S;
14903 case 494:
14904 tmp = fieldFromInstruction(insn, 37, 5);
14905 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14906 tmp = fieldFromInstruction(insn, 37, 5);
14907 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
14908 tmp = 0x0;
14909 tmp |= fieldFromInstruction(insn, 0, 16) << 16;
14910 tmp |= fieldFromInstruction(insn, 16, 16);
14911 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
14912 return S;
14913 }
14914}
14915static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) {
14916 switch (Idx) {
14917 default: llvm_unreachable("Invalid index!");
14918 case 0:
14919 return FB[Mips::FeatureMips16];
14920 case 1:
14921 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]);
14922 case 2:
14923 return FB[Mips::FeatureMicroMips];
14924 case 3:
14925 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6];
14926 case 4:
14927 return FB[Mips::FeatureNanoMips] && FB[Mips::FeatureNanoMips];
14928 case 5:
14929 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureCnMips]) && !(FB[Mips::FeatureMicroMips]);
14930 case 6:
14931 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureCnMips]) && !(FB[Mips::FeatureMicroMips]);
14932 case 7:
14933 return FB[Mips::FeatureCnMips];
14934 case 8:
14935 return FB[Mips::FeatureMips64] && FB[Mips::FeatureCnMips] && !(FB[Mips::FeatureMicroMips]);
14936 case 9:
14937 return FB[Mips::FeatureCnMipsP];
14938 case 10:
14939 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSP];
14940 case 11:
14941 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSPR2];
14942 case 12:
14943 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r5] && FB[Mips::FeatureVirt];
14944 case 13:
14945 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSPR3];
14946 case 14:
14947 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && FB[Mips::FeatureDSP];
14948 case 15:
14949 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]);
14950 case 16:
14951 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]);
14952 case 17:
14953 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]);
14954 case 18:
14955 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]);
14956 case 19:
14957 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]);
14958 case 20:
14959 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]);
14960 case 21:
14961 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureSoftFloat]);
14962 case 22:
14963 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]);
14964 case 23:
14965 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureEVA];
14966 case 24:
14967 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && FB[Mips::FeatureEVA];
14968 case 25:
14969 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureSoftFloat]);
14970 case 26:
14971 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureGINV];
14972 case 27:
14973 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureSoftFloat]);
14974 case 28:
14975 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMicroMips]);
14976 case 29:
14977 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMicroMips]);
14978 case 30:
14979 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
14980 case 31:
14981 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMSA];
14982 case 32:
14983 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
14984 case 33:
14985 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]);
14986 case 34:
14987 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMicroMips]) && !(FB[Mips::FeatureUseIndirectJumpsHazard]);
14988 case 35:
14989 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32];
14990 case 36:
14991 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
14992 case 37:
14993 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMicroMips]);
14994 case 38:
14995 return FB[Mips::FeatureDSP];
14996 case 39:
14997 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMSA] && FB[Mips::FeatureMips64];
14998 case 40:
14999 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
15000 case 41:
15001 return FB[Mips::FeatureDSP] && !(FB[Mips::FeatureMicroMips]);
15002 case 42:
15003 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r5] && FB[Mips::FeatureVirt] && !(FB[Mips::FeatureMicroMips]);
15004 case 43:
15005 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMT] && !(FB[Mips::FeatureMicroMips]);
15006 case 44:
15007 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3_32] && !(FB[Mips::FeatureMicroMips]);
15008 case 45:
15009 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r2] && FB[Mips::FeatureEVA] && !(FB[Mips::FeatureMicroMips]);
15010 case 46:
15011 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r5] && !(FB[Mips::FeatureMicroMips]);
15012 case 47:
15013 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32] && !(FB[Mips::FeatureMicroMips]);
15014 case 48:
15015 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15016 case 49:
15017 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureSingleFloat]);
15018 case 50:
15019 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15020 case 51:
15021 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15022 case 52:
15023 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15024 case 53:
15025 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15026 case 54:
15027 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureSoftFloat]);
15028 case 55:
15029 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15030 case 56:
15031 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15032 case 57:
15033 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15034 case 58:
15035 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15036 case 59:
15037 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15038 case 60:
15039 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15040 case 61:
15041 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15042 case 62:
15043 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15044 case 63:
15045 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15046 case 64:
15047 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]);
15048 case 65:
15049 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15050 case 66:
15051 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips5_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15052 case 67:
15053 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]) && !(FB[Mips::FeatureNoMadd4]);
15054 case 68:
15055 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]) && !(FB[Mips::FeatureNoMadd4]);
15056 case 69:
15057 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]) && !(FB[Mips::FeatureMicroMips]);
15058 case 70:
15059 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]) && !(FB[Mips::FeatureMicroMips]);
15060 case 71:
15061 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
15062 case 72:
15063 return FB[Mips::FeatureDSPR2];
15064 case 73:
15065 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && FB[Mips::FeatureEVA] && !(FB[Mips::FeatureMicroMips]);
15066 case 74:
15067 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
15068 case 75:
15069 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeaturePTR64Bit]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureMicroMips]);
15070 case 76:
15071 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeaturePTR64Bit] && !(FB[Mips::FeatureMicroMips]);
15072 case 77:
15073 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureMicroMips]);
15074 case 78:
15075 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r6];
15076 case 79:
15077 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureMicroMips]);
15078 case 80:
15079 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64r6] && !(FB[Mips::FeatureMicroMips]);
15080 case 81:
15081 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureGP64Bit]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureMicroMips]);
15082 case 82:
15083 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15084 case 83:
15085 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureCRC] && !(FB[Mips::FeatureMicroMips]);
15086 case 84:
15087 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64r6] && FB[Mips::FeatureCRC] && !(FB[Mips::FeatureMicroMips]);
15088 case 85:
15089 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeaturePTR64Bit]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureMicroMips]);
15090 case 86:
15091 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureGINV] && !(FB[Mips::FeatureMicroMips]);
15092 case 87:
15093 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64r6];
15094 case 88:
15095 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips64r6];
15096 case 89:
15097 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips32r6];
15098 case 90:
15099 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips64r6] && !(FB[Mips::FeatureMicroMips]);
15100 case 91:
15101 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64] && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
15102 case 92:
15103 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeaturePTR64Bit];
15104 case 93:
15105 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64r2] && !(FB[Mips::FeatureMicroMips]);
15106 case 94:
15107 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMicroMips]);
15108 case 95:
15109 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureMicroMips]);
15110 case 96:
15111 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips3];
15112 case 97:
15113 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64r5] && FB[Mips::FeatureVirt];
15114 case 98:
15115 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]);
15116 case 99:
15117 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips64] && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
15118 case 100:
15119 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]);
15120 case 101:
15121 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureDSP];
15122 case 102:
15123 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15124 case 103:
15125 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15126 case 104:
15127 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15128 case 105:
15129 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15130 case 106:
15131 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips3_32] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15132 case 107:
15133 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15134 case 108:
15135 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15136 case 109:
15137 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && FB[Mips::FeatureMips3D];
15138 case 110:
15139 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips3_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15140 case 111:
15141 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15142 case 112:
15143 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]);
15144 case 113:
15145 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips5_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
15146 case 114:
15147 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]) && !(FB[Mips::FeatureNoMadd4]);
15148 case 115:
15149 return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]) && !(FB[Mips::FeatureMicroMips]);
15150 case 116:
15151 return FB[Mips::FeatureNanoMips] && FB[Mips::FeatureNanoMips] && FB[Mips::FeatureCRC];
15152 case 117:
15153 return FB[Mips::FeatureNanoMips] && FB[Mips::FeatureNanoMips] && FB[Mips::FeatureGINV];
15154 }
15155}
15156
15157
15158template <typename InsnType>
15159static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
15160 InsnType insn, uint64_t Address,
15161 const MCDisassembler *DisAsm,
15162 const MCSubtargetInfo &STI) {
15163 const FeatureBitset &Bits = STI.getFeatureBits();
15164 const uint8_t *Ptr = DecodeTable;
15165
15166 SmallVector<const uint8_t *, 8> ScopeStack;
15167 DecodeStatus S = MCDisassembler::Success;
15168 while (true) {
15169 ptrdiff_t Loc = Ptr - DecodeTable;
15170 const uint8_t DecoderOp = *Ptr++;
15171 switch (DecoderOp) {
15172 default:
15173 errs() << Loc << ": Unexpected decode table opcode: "
15174 << (int)DecoderOp << '\n';
15175 return MCDisassembler::Fail;
15176 case OPC_Scope: {
15177 unsigned NumToSkip = decodeULEB128AndIncUnsafe(p&: Ptr);
15178 const uint8_t *SkipTo = Ptr + NumToSkip;
15179 ScopeStack.push_back(Elt: SkipTo);
15180 LLVM_DEBUG(dbgs() << Loc << ": OPC_Scope(" << SkipTo - DecodeTable
15181 << ")\n");
15182 continue;
15183 }
15184 case OPC_SwitchField: {
15185 // Decode the start value.
15186 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
15187 unsigned Len = *Ptr++;
15188 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
15189 uint64_t CaseValue;
15190 unsigned CaseSize;
15191 while (true) {
15192 CaseValue = decodeULEB128AndIncUnsafe(p&: Ptr);
15193 CaseSize = decodeULEB128AndIncUnsafe(p&: Ptr);
15194 if (FieldValue <= CaseValue || !CaseSize)
15195 break;
15196 Ptr += CaseSize;
15197 }
15198 if (FieldValue == CaseValue) {
15199 LLVM_DEBUG(dbgs() << Loc << ": OPC_SwitchField(" << Start << ", " << Len
15200 << "): " << FieldValue << '\n');
15201 continue;
15202 }
15203 break;
15204 }
15205 case OPC_CheckField: {
15206 // Decode the start value.
15207 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
15208 unsigned Len = *Ptr;
15209 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
15210 // Decode the field value.
15211 unsigned PtrLen = 0;
15212 uint64_t ExpectedValue = decodeULEB128(p: ++Ptr, n: &PtrLen);
15213 Ptr += PtrLen;
15214 bool Failed = ExpectedValue != FieldValue;
15215
15216 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckField(" << Start << ", " << Len
15217 << ", " << ExpectedValue << "): FieldValue = "
15218 << FieldValue << ", ExpectedValue = " << ExpectedValue
15219 << ": " << (Failed ? "FAIL, " : "PASS\n"););
15220 if (!Failed)
15221 continue;
15222 break;
15223 }
15224 case OPC_CheckPredicate: {
15225 // Decode the Predicate Index value.
15226 unsigned PIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
15227 // Check the predicate.
15228 bool Failed = !checkDecoderPredicate(Idx: PIdx, FB: Bits);
15229
15230 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckPredicate(" << PIdx << "): "
15231 << (Failed ? "FAIL, " : "PASS\n"););
15232 if (!Failed)
15233 continue;
15234 break;
15235 }
15236 case OPC_Decode: {
15237 // Decode the Opcode value.
15238 unsigned Opc = decodeULEB128AndIncUnsafe(p&: Ptr);
15239 unsigned DecodeIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
15240
15241 MI.clear();
15242 MI.setOpcode(Opc);
15243 bool DecodeComplete;
15244 S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm,
15245 DecodeComplete);
15246 LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc
15247 << ", using decoder " << DecodeIdx << ": "
15248 << (S ? "PASS, " : "FAIL, "));
15249
15250 if (DecodeComplete) {
15251 LLVM_DEBUG(dbgs() << "decoding complete\n");
15252 return S;
15253 }
15254 assert(S == MCDisassembler::Fail);
15255 // Reset decode status. This also drops a SoftFail status that could be
15256 // set before the decode attempt.
15257 S = MCDisassembler::Success;
15258 break;
15259 }
15260 }
15261 if (ScopeStack.empty()) {
15262 LLVM_DEBUG(dbgs() << "returning Fail\n");
15263 return MCDisassembler::Fail;
15264 }
15265 Ptr = ScopeStack.pop_back_val();
15266 LLVM_DEBUG(dbgs() << "continuing at " << Ptr - DecodeTable << '\n');
15267 }
15268 llvm_unreachable("bogosity detected in disassembler state machine!");
15269}
15270
15271
15272} // namespace
15273