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, 218, 8, 0, // 7: decode to Bimm16 using decoder 0
82 // 7: }
83 4, 6, // 11: case 0x4: {
84 OPC_CheckPredicate, 0, // 13: check predicate 0
85 OPC_Decode, 216, 8, 1, // 15: decode to BeqzRxImm16 using decoder 1
86 // 15: }
87 5, 6, // 19: case 0x5: {
88 OPC_CheckPredicate, 0, // 21: check predicate 0
89 OPC_Decode, 220, 8, 1, // 23: decode to BnezRxImm16 using decoder 1
90 // 23: }
91 9, 6, // 27: case 0x9: {
92 OPC_CheckPredicate, 0, // 29: check predicate 0
93 OPC_Decode, 151, 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, 141, 22, 3, // 39: decode to SltiRxImm16 using decoder 3
98 // 39: }
99 11, 6, // 43: case 0xb: {
100 OPC_CheckPredicate, 0, // 45: check predicate 0
101 OPC_Decode, 143, 22, 3, // 47: decode to SltiuRxImm16 using decoder 3
102 // 47: }
103 12, 43, // 51: case 0xc: {
104 OPC_SwitchField, 8, 3, // 53: switch Inst[10:8] {
105 0, 6, // 56: case 0x0: {
106 OPC_CheckPredicate, 0, // 58: check predicate 0
107 OPC_Decode, 223, 8, 4, // 60: decode to Bteqz16 using decoder 4
108 // 60: }
109 1, 6, // 64: case 0x1: {
110 OPC_CheckPredicate, 0, // 66: check predicate 0
111 OPC_Decode, 225, 8, 4, // 68: decode to Btnez16 using decoder 4
112 // 68: }
113 3, 6, // 72: case 0x3: {
114 OPC_CheckPredicate, 0, // 74: check predicate 0
115 OPC_Decode, 154, 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, 145, 18, 5, // 84: decode to Move32R16 using decoder 5
120 // 84: }
121 7, 0, // 88: case 0x7: {
122 OPC_CheckPredicate, 0, // 90: check predicate 0
123 OPC_Decode, 146, 18, 6, // 92: decode to MoveR3216 using decoder 6
124 // 92: }
125 // 92: } // switch Inst[10:8]
126 // 92: }
127 13, 6, // 96: case 0xd: {
128 OPC_CheckPredicate, 0, // 98: check predicate 0
129 OPC_Decode, 225, 15, 3, // 100: decode to LiRxImm16 using decoder 3
130 // 100: }
131 14, 6, // 104: case 0xe: {
132 OPC_CheckPredicate, 0, // 106: check predicate 0
133 OPC_Decode, 161, 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, 228, 15, 7, // 116: decode to LwRxPcTcp16 using decoder 7
138 // 116: }
139 28, 19, // 120: case 0x1c: {
140 OPC_SwitchField, 0, 2, // 122: switch Inst[1:0] {
141 1, 6, // 125: case 0x1: {
142 OPC_CheckPredicate, 0, // 127: check predicate 0
143 OPC_Decode, 156, 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, 150, 22, 8, // 137: decode to SubuRxRyRz16 using decoder 8
148 // 137: }
149 // 137: } // switch Inst[1:0]
150 // 137: }
151 29, 0, // 141: case 0x1d: {
152 OPC_SwitchField, 0, 5, // 143: switch Inst[4:0] {
153 0, 43, // 146: case 0x0: {
154 OPC_SwitchField, 5, 3, // 148: switch Inst[7:5] {
155 0, 6, // 151: case 0x0: {
156 OPC_CheckPredicate, 0, // 153: check predicate 0
157 OPC_Decode, 231, 14, 9, // 155: decode to JumpLinkReg16 using decoder 9
158 // 155: }
159 1, 10, // 159: case 0x1: {
160 OPC_CheckPredicate, 0, // 161: check predicate 0
161 OPC_CheckField, 8, 3, 0, // 163: check Inst[10:8] == 0x0
162 OPC_Decode, 228, 14, 10, // 167: decode to JrRa16 using decoder 10
163 // 167: }
164 6, 6, // 171: case 0x6: {
165 OPC_CheckPredicate, 0, // 173: check predicate 0
166 OPC_Decode, 230, 14, 9, // 175: decode to JrcRx16 using decoder 9
167 // 175: }
168 7, 0, // 179: case 0x7: {
169 OPC_CheckPredicate, 0, // 181: check predicate 0
170 OPC_CheckField, 8, 3, 0, // 183: check Inst[10:8] == 0x0
171 OPC_Decode, 229, 14, 10, // 187: decode to JrcRa16 using decoder 10
172 // 187: }
173 // 187: } // switch Inst[7:5]
174 // 187: }
175 2, 6, // 191: case 0x2: {
176 OPC_CheckPredicate, 0, // 193: check predicate 0
177 OPC_Decode, 140, 22, 11, // 195: decode to SltRxRy16 using decoder 11
178 // 195: }
179 3, 6, // 199: case 0x3: {
180 OPC_CheckPredicate, 0, // 201: check predicate 0
181 OPC_Decode, 145, 22, 11, // 203: decode to SltuRxRy16 using decoder 11
182 // 203: }
183 4, 6, // 207: case 0x4: {
184 OPC_CheckPredicate, 0, // 209: check predicate 0
185 OPC_Decode, 139, 22, 12, // 211: decode to SllvRxRy16 using decoder 12
186 // 211: }
187 5, 10, // 215: case 0x5: {
188 OPC_CheckPredicate, 0, // 217: check predicate 0
189 OPC_CheckField, 5, 6, 0, // 219: check Inst[10:5] == 0x0
190 OPC_Decode, 222, 8, 10, // 223: decode to Break16 using decoder 10
191 // 223: }
192 6, 6, // 227: case 0x6: {
193 OPC_CheckPredicate, 0, // 229: check predicate 0
194 OPC_Decode, 149, 22, 12, // 231: decode to SrlvRxRy16 using decoder 12
195 // 231: }
196 7, 6, // 235: case 0x7: {
197 OPC_CheckPredicate, 0, // 237: check predicate 0
198 OPC_Decode, 147, 22, 12, // 239: decode to SravRxRy16 using decoder 12
199 // 239: }
200 10, 6, // 243: case 0xa: {
201 OPC_CheckPredicate, 0, // 245: check predicate 0
202 OPC_Decode, 160, 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, 157, 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, 188, 18, 12, // 263: decode to OrRxRxRy16 using decoder 12
211 // 263: }
212 14, 6, // 267: case 0xe: {
213 OPC_CheckPredicate, 0, // 269: check predicate 0
214 OPC_Decode, 242, 22, 12, // 271: decode to XorRxRxRy16 using decoder 12
215 // 271: }
216 15, 6, // 275: case 0xf: {
217 OPC_CheckPredicate, 0, // 277: check predicate 0
218 OPC_Decode, 175, 18, 11, // 279: decode to NotRxRy16 using decoder 11
219 // 279: }
220 16, 10, // 283: case 0x10: {
221 OPC_CheckPredicate, 0, // 285: check predicate 0
222 OPC_CheckField, 5, 3, 0, // 287: check Inst[7:5] == 0x0
223 OPC_Decode, 143, 18, 9, // 291: decode to Mfhi16 using decoder 9
224 // 291: }
225 17, 19, // 295: case 0x11: {
226 OPC_SwitchField, 5, 3, // 297: switch Inst[7:5] {
227 4, 6, // 300: case 0x4: {
228 OPC_CheckPredicate, 0, // 302: check predicate 0
229 OPC_Decode, 135, 22, 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, 136, 22, 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, 144, 18, 9, // 324: decode to Mflo16 using decoder 9
241 // 324: }
242 26, 6, // 328: case 0x1a: {
243 OPC_CheckPredicate, 0, // 330: check predicate 0
244 OPC_Decode, 170, 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, 171, 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, 174, 18, 11, // 348: decode to NegRxRy16 using decoder 11
253 // 348: }
254 // 348: } // switch Inst[4:0]
255 // 348: }
256 // 348: } // switch Inst[15:11]
257};
258static const uint8_t DecoderTableMicroMips16[375] = {
259 OPC_SwitchField, 10, 6, // 0: switch Inst[15:10] {
260 1, 19, // 3: case 0x1: {
261 OPC_SwitchField, 0, 1, // 5: switch Inst[0] {
262 0, 6, // 8: case 0x0: {
263 OPC_CheckPredicate, 1, // 10: check predicate 1
264 OPC_Decode, 192, 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, 188, 21, 14, // 20: decode to SUBU16_MM using decoder 14
269 // 20: }
270 // 20: } // switch Inst[0]
271 // 20: }
272 2, 6, // 24: case 0x2: {
273 OPC_CheckPredicate, 2, // 26: check predicate 2
274 OPC_Decode, 236, 14, 15, // 28: decode to LBU16_MM using decoder 15
275 // 28: }
276 3, 6, // 32: case 0x3: {
277 OPC_CheckPredicate, 1, // 34: check predicate 1
278 OPC_Decode, 239, 16, 16, // 36: decode to MOVE16_MM using decoder 16
279 // 36: }
280 9, 19, // 40: case 0x9: {
281 OPC_SwitchField, 0, 1, // 42: switch Inst[0] {
282 0, 6, // 45: case 0x0: {
283 OPC_CheckPredicate, 1, // 47: check predicate 1
284 OPC_Decode, 198, 20, 17, // 49: decode to SLL16_MM using decoder 17
285 // 49: }
286 1, 0, // 53: case 0x1: {
287 OPC_CheckPredicate, 1, // 55: check predicate 1
288 OPC_Decode, 129, 21, 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, 149, 15, 15, // 65: decode to LHU16_MM using decoder 15
295 // 65: }
296 11, 6, // 69: case 0xb: {
297 OPC_CheckPredicate, 1, // 71: check predicate 1
298 OPC_Decode, 237, 6, 18, // 73: decode to ANDI16_MM using decoder 18
299 // 73: }
300 17, 153, 1, // 77: case 0x11: {
301 OPC_SwitchField, 6, 4, // 80: switch Inst[9:6] {
302 0, 6, // 83: case 0x0: {
303 OPC_CheckPredicate, 1, // 85: check predicate 1
304 OPC_Decode, 172, 18, 19, // 87: decode to NOT16_MM using decoder 19
305 // 87: }
306 1, 6, // 91: case 0x1: {
307 OPC_CheckPredicate, 1, // 93: check predicate 1
308 OPC_Decode, 231, 22, 20, // 95: decode to XOR16_MM using decoder 20
309 // 95: }
310 2, 6, // 99: case 0x2: {
311 OPC_CheckPredicate, 1, // 101: check predicate 1
312 OPC_Decode, 234, 6, 20, // 103: decode to AND16_MM using decoder 20
313 // 103: }
314 3, 6, // 107: case 0x3: {
315 OPC_CheckPredicate, 1, // 109: check predicate 1
316 OPC_Decode, 177, 18, 20, // 111: decode to OR16_MM using decoder 20
317 // 111: }
318 4, 6, // 115: case 0x4: {
319 OPC_CheckPredicate, 1, // 117: check predicate 1
320 OPC_Decode, 199, 15, 21, // 119: decode to LWM16_MM using decoder 21
321 // 119: }
322 5, 6, // 123: case 0x5: {
323 OPC_CheckPredicate, 1, // 125: check predicate 1
324 OPC_Decode, 237, 21, 21, // 127: decode to SWM16_MM using decoder 21
325 // 127: }
326 6, 19, // 131: case 0x6: {
327 OPC_SwitchField, 5, 1, // 133: switch Inst[5] {
328 0, 6, // 136: case 0x0: {
329 OPC_CheckPredicate, 1, // 138: check predicate 1
330 OPC_Decode, 213, 14, 22, // 140: decode to JR16_MM using decoder 22
331 // 140: }
332 1, 0, // 144: case 0x1: {
333 OPC_CheckPredicate, 1, // 146: check predicate 1
334 OPC_Decode, 216, 14, 22, // 148: decode to JRC16_MM using decoder 22
335 // 148: }
336 // 148: } // switch Inst[5]
337 // 148: }
338 7, 19, // 152: case 0x7: {
339 OPC_SwitchField, 5, 1, // 154: switch Inst[5] {
340 0, 6, // 157: case 0x0: {
341 OPC_CheckPredicate, 1, // 159: check predicate 1
342 OPC_Decode, 191, 14, 22, // 161: decode to JALR16_MM using decoder 22
343 // 161: }
344 1, 0, // 165: case 0x1: {
345 OPC_CheckPredicate, 1, // 167: check predicate 1
346 OPC_Decode, 196, 14, 22, // 169: decode to JALRS16_MM using decoder 22
347 // 169: }
348 // 169: } // switch Inst[5]
349 // 169: }
350 8, 10, // 173: case 0x8: {
351 OPC_CheckPredicate, 1, // 175: check predicate 1
352 OPC_CheckField, 5, 1, 0, // 177: check Inst[5] == 0x0
353 OPC_Decode, 185, 16, 22, // 181: decode to MFHI16_MM using decoder 22
354 // 181: }
355 9, 10, // 185: case 0x9: {
356 OPC_CheckPredicate, 1, // 187: check predicate 1
357 OPC_CheckField, 5, 1, 0, // 189: check Inst[5] == 0x0
358 OPC_Decode, 191, 16, 22, // 193: decode to MFLO16_MM using decoder 22
359 // 193: }
360 10, 10, // 197: case 0xa: {
361 OPC_CheckPredicate, 1, // 199: check predicate 1
362 OPC_CheckField, 4, 2, 0, // 201: check Inst[5:4] == 0x0
363 OPC_Decode, 197, 8, 23, // 205: decode to BREAK16_MM using decoder 23
364 // 205: }
365 11, 10, // 209: case 0xb: {
366 OPC_CheckPredicate, 1, // 211: check predicate 1
367 OPC_CheckField, 4, 2, 0, // 213: check Inst[5:4] == 0x0
368 OPC_Decode, 210, 19, 23, // 217: decode to SDBBP16_MM using decoder 23
369 // 217: }
370 12, 0, // 221: case 0xc: {
371 OPC_CheckPredicate, 1, // 223: check predicate 1
372 OPC_CheckField, 5, 1, 0, // 225: check Inst[5] == 0x0
373 OPC_Decode, 215, 14, 24, // 229: decode to JRADDIUSP using decoder 24
374 // 229: }
375 // 229: } // switch Inst[9:6]
376 // 229: }
377 18, 6, // 233: case 0x12: {
378 OPC_CheckPredicate, 2, // 235: check predicate 2
379 OPC_Decode, 210, 15, 25, // 237: decode to LWSP_MM using decoder 25
380 // 237: }
381 19, 19, // 241: case 0x13: {
382 OPC_SwitchField, 0, 1, // 243: switch Inst[0] {
383 0, 6, // 246: case 0x0: {
384 OPC_CheckPredicate, 2, // 248: check predicate 2
385 OPC_Decode, 160, 6, 26, // 250: decode to ADDIUS5_MM using decoder 26
386 // 250: }
387 1, 0, // 254: case 0x1: {
388 OPC_CheckPredicate, 2, // 256: check predicate 2
389 OPC_Decode, 161, 6, 27, // 258: decode to ADDIUSP_MM using decoder 27
390 // 258: }
391 // 258: } // switch Inst[0]
392 // 258: }
393 25, 6, // 262: case 0x19: {
394 OPC_CheckPredicate, 2, // 264: check predicate 2
395 OPC_Decode, 193, 15, 28, // 266: decode to LWGP_MM using decoder 28
396 // 266: }
397 26, 6, // 270: case 0x1a: {
398 OPC_CheckPredicate, 2, // 272: check predicate 2
399 OPC_Decode, 181, 15, 15, // 274: decode to LW16_MM using decoder 15
400 // 274: }
401 27, 19, // 278: case 0x1b: {
402 OPC_SwitchField, 0, 1, // 280: switch Inst[0] {
403 0, 6, // 283: case 0x0: {
404 OPC_CheckPredicate, 2, // 285: check predicate 2
405 OPC_Decode, 159, 6, 29, // 287: decode to ADDIUR2_MM using decoder 29
406 // 287: }
407 1, 0, // 291: case 0x1: {
408 OPC_CheckPredicate, 2, // 293: check predicate 2
409 OPC_Decode, 158, 6, 30, // 295: decode to ADDIUR1SP_MM using decoder 30
410 // 295: }
411 // 295: } // switch Inst[0]
412 // 295: }
413 33, 10, // 299: case 0x21: {
414 OPC_CheckPredicate, 1, // 301: check predicate 1
415 OPC_CheckField, 0, 1, 0, // 303: check Inst[0] == 0x0
416 OPC_Decode, 241, 16, 31, // 307: decode to MOVEP_MM using decoder 31
417 // 307: }
418 34, 6, // 311: case 0x22: {
419 OPC_CheckPredicate, 1, // 313: check predicate 1
420 OPC_Decode, 191, 19, 15, // 315: decode to SB16_MM using decoder 15
421 // 315: }
422 35, 6, // 319: case 0x23: {
423 OPC_CheckPredicate, 1, // 321: check predicate 1
424 OPC_Decode, 200, 7, 32, // 323: decode to BEQZ16_MM using decoder 32
425 // 323: }
426 42, 6, // 327: case 0x2a: {
427 OPC_CheckPredicate, 1, // 329: check predicate 1
428 OPC_Decode, 129, 20, 15, // 331: decode to SH16_MM using decoder 15
429 // 331: }
430 43, 6, // 335: case 0x2b: {
431 OPC_CheckPredicate, 1, // 337: check predicate 1
432 OPC_Decode, 175, 8, 32, // 339: decode to BNEZ16_MM using decoder 32
433 // 339: }
434 50, 6, // 343: case 0x32: {
435 OPC_CheckPredicate, 1, // 345: check predicate 1
436 OPC_Decode, 246, 21, 25, // 347: decode to SWSP_MM using decoder 25
437 // 347: }
438 51, 6, // 351: case 0x33: {
439 OPC_CheckPredicate, 2, // 353: check predicate 2
440 OPC_Decode, 158, 7, 33, // 355: decode to B16_MM using decoder 33
441 // 355: }
442 58, 6, // 359: case 0x3a: {
443 OPC_CheckPredicate, 1, // 361: check predicate 1
444 OPC_Decode, 219, 21, 15, // 363: decode to SW16_MM using decoder 15
445 // 363: }
446 59, 0, // 367: case 0x3b: {
447 OPC_CheckPredicate, 1, // 369: check predicate 1
448 OPC_Decode, 158, 15, 34, // 371: decode to LI16_MM using decoder 34
449 // 371: }
450 // 371: } // switch Inst[15:10]
451};
452static const uint8_t DecoderTableMicroMipsR616[257] = {
453 OPC_SwitchField, 10, 6, // 0: switch Inst[15:10] {
454 1, 19, // 3: case 0x1: {
455 OPC_SwitchField, 0, 1, // 5: switch Inst[0] {
456 0, 6, // 8: case 0x0: {
457 OPC_CheckPredicate, 3, // 10: check predicate 3
458 OPC_Decode, 193, 6, 35, // 12: decode to ADDU16_MMR6 using decoder 35
459 // 12: }
460 1, 0, // 16: case 0x1: {
461 OPC_CheckPredicate, 3, // 18: check predicate 3
462 OPC_Decode, 189, 21, 35, // 20: decode to SUBU16_MMR6 using decoder 35
463 // 20: }
464 // 20: } // switch Inst[0]
465 // 20: }
466 3, 6, // 24: case 0x3: {
467 OPC_CheckPredicate, 3, // 26: check predicate 3
468 OPC_Decode, 240, 16, 16, // 28: decode to MOVE16_MMR6 using decoder 16
469 // 28: }
470 9, 19, // 32: case 0x9: {
471 OPC_SwitchField, 0, 1, // 34: switch Inst[0] {
472 0, 6, // 37: case 0x0: {
473 OPC_CheckPredicate, 3, // 39: check predicate 3
474 OPC_Decode, 199, 20, 17, // 41: decode to SLL16_MMR6 using decoder 17
475 // 41: }
476 1, 0, // 45: case 0x1: {
477 OPC_CheckPredicate, 3, // 47: check predicate 3
478 OPC_Decode, 130, 21, 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, 238, 6, 18, // 57: decode to ANDI16_MMR6 using decoder 18
485 // 57: }
486 17, 129, 1, // 61: case 0x11: {
487 OPC_SwitchField, 2, 1, // 64: switch Inst[2] {
488 0, 116, // 67: case 0x0: {
489 OPC_SwitchField, 0, 2, // 69: switch Inst[1:0] {
490 0, 19, // 72: case 0x0: {
491 OPC_SwitchField, 3, 1, // 74: switch Inst[3] {
492 0, 6, // 77: case 0x0: {
493 OPC_CheckPredicate, 3, // 79: check predicate 3
494 OPC_Decode, 173, 18, 36, // 81: decode to NOT16_MMR6 using decoder 36
495 // 81: }
496 1, 0, // 85: case 0x1: {
497 OPC_CheckPredicate, 3, // 87: check predicate 3
498 OPC_Decode, 232, 22, 37, // 89: decode to XOR16_MMR6 using decoder 37
499 // 89: }
500 // 89: } // switch Inst[3]
501 // 89: }
502 1, 19, // 93: case 0x1: {
503 OPC_SwitchField, 3, 1, // 95: switch Inst[3] {
504 0, 6, // 98: case 0x0: {
505 OPC_CheckPredicate, 3, // 100: check predicate 3
506 OPC_Decode, 235, 6, 37, // 102: decode to AND16_MMR6 using decoder 37
507 // 102: }
508 1, 0, // 106: case 0x1: {
509 OPC_CheckPredicate, 3, // 108: check predicate 3
510 OPC_Decode, 178, 18, 37, // 110: decode to OR16_MMR6 using decoder 37
511 // 110: }
512 // 110: } // switch Inst[3]
513 // 110: }
514 2, 19, // 114: case 0x2: {
515 OPC_SwitchField, 3, 1, // 116: switch Inst[3] {
516 0, 6, // 119: case 0x0: {
517 OPC_CheckPredicate, 3, // 121: check predicate 3
518 OPC_Decode, 200, 15, 21, // 123: decode to LWM16_MMR6 using decoder 21
519 // 123: }
520 1, 0, // 127: case 0x1: {
521 OPC_CheckPredicate, 3, // 129: check predicate 3
522 OPC_Decode, 238, 21, 21, // 131: decode to SWM16_MMR6 using decoder 21
523 // 131: }
524 // 131: } // switch Inst[3]
525 // 131: }
526 3, 0, // 135: case 0x3: {
527 OPC_SwitchField, 3, 2, // 137: switch Inst[4:3] {
528 0, 6, // 140: case 0x0: {
529 OPC_CheckPredicate, 3, // 142: check predicate 3
530 OPC_Decode, 217, 14, 38, // 144: decode to JRC16_MMR6 using decoder 38
531 // 144: }
532 1, 6, // 148: case 0x1: {
533 OPC_CheckPredicate, 3, // 150: check predicate 3
534 OPC_Decode, 193, 14, 38, // 152: decode to JALRC16_MMR6 using decoder 38
535 // 152: }
536 2, 6, // 156: case 0x2: {
537 OPC_CheckPredicate, 3, // 158: check predicate 3
538 OPC_Decode, 218, 14, 39, // 160: decode to JRCADDIUSP_MMR6 using decoder 39
539 // 160: }
540 3, 0, // 164: case 0x3: {
541 OPC_SwitchField, 5, 1, // 166: switch Inst[5] {
542 0, 6, // 169: case 0x0: {
543 OPC_CheckPredicate, 3, // 171: check predicate 3
544 OPC_Decode, 198, 8, 40, // 173: decode to BREAK16_MMR6 using decoder 40
545 // 173: }
546 1, 0, // 177: case 0x1: {
547 OPC_CheckPredicate, 3, // 179: check predicate 3
548 OPC_Decode, 211, 19, 40, // 181: decode to SDBBP16_MMR6 using decoder 40
549 // 181: }
550 // 181: } // switch Inst[5]
551 // 181: }
552 // 181: } // switch Inst[4:3]
553 // 181: }
554 // 181: } // switch Inst[1:0]
555 // 181: }
556 1, 0, // 185: case 0x1: {
557 OPC_CheckPredicate, 3, // 187: check predicate 3
558 OPC_Decode, 242, 16, 31, // 189: decode to MOVEP_MMR6 using decoder 31
559 // 189: }
560 // 189: } // switch Inst[2]
561 // 189: }
562 34, 6, // 193: case 0x22: {
563 OPC_CheckPredicate, 3, // 195: check predicate 3
564 OPC_Decode, 192, 19, 15, // 197: decode to SB16_MMR6 using decoder 15
565 // 197: }
566 35, 6, // 201: case 0x23: {
567 OPC_CheckPredicate, 3, // 203: check predicate 3
568 OPC_Decode, 204, 7, 32, // 205: decode to BEQZC16_MMR6 using decoder 32
569 // 205: }
570 42, 6, // 209: case 0x2a: {
571 OPC_CheckPredicate, 3, // 211: check predicate 3
572 OPC_Decode, 130, 20, 15, // 213: decode to SH16_MMR6 using decoder 15
573 // 213: }
574 43, 6, // 217: case 0x2b: {
575 OPC_CheckPredicate, 3, // 219: check predicate 3
576 OPC_Decode, 179, 8, 32, // 221: decode to BNEZC16_MMR6 using decoder 32
577 // 221: }
578 50, 6, // 225: case 0x32: {
579 OPC_CheckPredicate, 3, // 227: check predicate 3
580 OPC_Decode, 247, 21, 25, // 229: decode to SWSP_MMR6 using decoder 25
581 // 229: }
582 51, 6, // 233: case 0x33: {
583 OPC_CheckPredicate, 3, // 235: check predicate 3
584 OPC_Decode, 170, 7, 33, // 237: decode to BC16_MMR6 using decoder 33
585 // 237: }
586 58, 6, // 241: case 0x3a: {
587 OPC_CheckPredicate, 3, // 243: check predicate 3
588 OPC_Decode, 220, 21, 15, // 245: decode to SW16_MMR6 using decoder 15
589 // 245: }
590 59, 0, // 249: case 0x3b: {
591 OPC_CheckPredicate, 3, // 251: check predicate 3
592 OPC_Decode, 159, 15, 34, // 253: decode to LI16_MMR6 using decoder 34
593 // 253: }
594 // 253: } // switch Inst[15:10]
595};
596static const uint8_t DecoderTable32[305] = {
597 OPC_SwitchField, 11, 5, // 0: switch Inst[15:11] {
598 1, 14, // 3: case 0x1: {
599 OPC_CheckPredicate, 0, // 5: check predicate 0
600 OPC_CheckField, 27, 5, 30, // 7: check Inst[31:27] == 0x1e
601 OPC_CheckField, 5, 3, 0, // 11: check Inst[7:5] == 0x0
602 OPC_Decode, 150, 7, 41, // 15: decode to AddiuRxPcImmX16 using decoder 41
603 // 15: }
604 2, 14, // 19: case 0x2: {
605 OPC_CheckPredicate, 0, // 21: check predicate 0
606 OPC_CheckField, 27, 5, 30, // 23: check Inst[31:27] == 0x1e
607 OPC_CheckField, 5, 6, 0, // 27: check Inst[10:5] == 0x0
608 OPC_Decode, 219, 8, 42, // 31: decode to BimmX16 using decoder 42
609 // 31: }
610 4, 14, // 35: case 0x4: {
611 OPC_CheckPredicate, 0, // 37: check predicate 0
612 OPC_CheckField, 27, 5, 30, // 39: check Inst[31:27] == 0x1e
613 OPC_CheckField, 5, 3, 0, // 43: check Inst[7:5] == 0x0
614 OPC_Decode, 217, 8, 43, // 47: decode to BeqzRxImmX16 using decoder 43
615 // 47: }
616 5, 14, // 51: case 0x5: {
617 OPC_CheckPredicate, 0, // 53: check predicate 0
618 OPC_CheckField, 27, 5, 30, // 55: check Inst[31:27] == 0x1e
619 OPC_CheckField, 5, 3, 0, // 59: check Inst[7:5] == 0x0
620 OPC_Decode, 221, 8, 43, // 63: decode to BnezRxImmX16 using decoder 43
621 // 63: }
622 6, 64, // 67: case 0x6: {
623 OPC_CheckField, 27, 5, 30, // 69: check Inst[31:27] == 0x1e
624 OPC_Scope, 31, // 73: try {
625 OPC_CheckField, 16, 5, 0, // 75: check Inst[20:16] == 0x0
626 OPC_SwitchField, 0, 5, // 79: switch Inst[4:0] {
627 0, 6, // 82: case 0x0: {
628 OPC_CheckPredicate, 0, // 84: check predicate 0
629 OPC_Decode, 138, 22, 44, // 86: decode to SllX16 using decoder 44
630 // 86: }
631 2, 6, // 90: case 0x2: {
632 OPC_CheckPredicate, 0, // 92: check predicate 0
633 OPC_Decode, 148, 22, 44, // 94: decode to SrlX16 using decoder 44
634 // 94: }
635 3, 0, // 98: case 0x3: {
636 OPC_CheckPredicate, 0, // 100: check predicate 0
637 OPC_Decode, 146, 22, 44, // 102: decode to SraX16 using decoder 44
638 // 102: }
639 // 102: } // switch Inst[4:0]
640 // 102: } else try {
641 OPC_SwitchField, 5, 6, // 106: switch Inst[10:5] {
642 0, 6, // 109: case 0x0: {
643 OPC_CheckPredicate, 0, // 111: check predicate 0
644 OPC_Decode, 224, 8, 45, // 113: decode to BteqzX16 using decoder 45
645 // 113: }
646 8, 6, // 117: case 0x8: {
647 OPC_CheckPredicate, 0, // 119: check predicate 0
648 OPC_Decode, 226, 8, 45, // 121: decode to BtnezX16 using decoder 45
649 // 121: }
650 24, 0, // 125: case 0x18: {
651 OPC_CheckPredicate, 0, // 127: check predicate 0
652 OPC_Decode, 155, 7, 45, // 129: decode to AddiuSpImmX16 using decoder 45
653 // 129: }
654 // 129: } // switch Inst[10:5]
655 // 129: }
656 // 129: }
657 8, 14, // 133: case 0x8: {
658 OPC_CheckPredicate, 0, // 135: check predicate 0
659 OPC_CheckField, 27, 5, 30, // 137: check Inst[31:27] == 0x1e
660 OPC_CheckField, 4, 1, 0, // 141: check Inst[4] == 0x0
661 OPC_Decode, 153, 7, 46, // 145: decode to AddiuRxRyOffMemX16 using decoder 46
662 // 145: }
663 9, 14, // 149: case 0x9: {
664 OPC_CheckPredicate, 0, // 151: check predicate 0
665 OPC_CheckField, 27, 5, 30, // 153: check Inst[31:27] == 0x1e
666 OPC_CheckField, 5, 3, 0, // 157: check Inst[7:5] == 0x0
667 OPC_Decode, 149, 7, 41, // 161: decode to AddiuRxImmX16 using decoder 41
668 // 161: }
669 10, 14, // 165: case 0xa: {
670 OPC_CheckPredicate, 0, // 167: check predicate 0
671 OPC_CheckField, 27, 5, 30, // 169: check Inst[31:27] == 0x1e
672 OPC_CheckField, 5, 3, 0, // 173: check Inst[7:5] == 0x0
673 OPC_Decode, 142, 22, 41, // 177: decode to SltiRxImmX16 using decoder 41
674 // 177: }
675 11, 14, // 181: case 0xb: {
676 OPC_CheckPredicate, 0, // 183: check predicate 0
677 OPC_CheckField, 27, 5, 30, // 185: check Inst[31:27] == 0x1e
678 OPC_CheckField, 5, 3, 0, // 189: check Inst[7:5] == 0x0
679 OPC_Decode, 144, 22, 41, // 193: decode to SltiuRxImmX16 using decoder 41
680 // 193: }
681 13, 14, // 197: case 0xd: {
682 OPC_CheckPredicate, 0, // 199: check predicate 0
683 OPC_CheckField, 27, 5, 30, // 201: check Inst[31:27] == 0x1e
684 OPC_CheckField, 5, 3, 0, // 205: check Inst[7:5] == 0x0
685 OPC_Decode, 227, 15, 41, // 209: decode to LiRxImmX16 using decoder 41
686 // 209: }
687 14, 14, // 213: case 0xe: {
688 OPC_CheckPredicate, 0, // 215: check predicate 0
689 OPC_CheckField, 27, 5, 30, // 217: check Inst[31:27] == 0x1e
690 OPC_CheckField, 5, 3, 0, // 221: check Inst[7:5] == 0x0
691 OPC_Decode, 162, 11, 41, // 225: decode to CmpiRxImmX16 using decoder 41
692 // 225: }
693 18, 10, // 229: case 0x12: {
694 OPC_CheckPredicate, 0, // 231: check predicate 0
695 OPC_CheckField, 27, 5, 30, // 233: check Inst[31:27] == 0x1e
696 OPC_Decode, 231, 15, 46, // 237: decode to LwRxSpImmX16 using decoder 46
697 // 237: }
698 22, 14, // 241: case 0x16: {
699 OPC_CheckPredicate, 0, // 243: check predicate 0
700 OPC_CheckField, 27, 5, 30, // 245: check Inst[31:27] == 0x1e
701 OPC_CheckField, 5, 3, 0, // 249: check Inst[7:5] == 0x0
702 OPC_Decode, 229, 15, 47, // 253: decode to LwRxPcTcpX16 using decoder 47
703 // 253: }
704 24, 10, // 257: case 0x18: {
705 OPC_CheckPredicate, 0, // 259: check predicate 0
706 OPC_CheckField, 27, 5, 30, // 261: check Inst[31:27] == 0x1e
707 OPC_Decode, 134, 22, 46, // 265: decode to SbRxRyOffMemX16 using decoder 46
708 // 265: }
709 25, 10, // 269: case 0x19: {
710 OPC_CheckPredicate, 0, // 271: check predicate 0
711 OPC_CheckField, 27, 5, 30, // 273: check Inst[31:27] == 0x1e
712 OPC_Decode, 137, 22, 46, // 277: decode to ShRxRyOffMemX16 using decoder 46
713 // 277: }
714 26, 10, // 281: case 0x1a: {
715 OPC_CheckPredicate, 0, // 283: check predicate 0
716 OPC_CheckField, 27, 5, 30, // 285: check Inst[31:27] == 0x1e
717 OPC_Decode, 152, 22, 46, // 289: decode to SwRxSpImmX16 using decoder 46
718 // 289: }
719 27, 0, // 293: case 0x1b: {
720 OPC_CheckPredicate, 0, // 295: check predicate 0
721 OPC_CheckField, 27, 5, 30, // 297: check Inst[31:27] == 0x1e
722 OPC_Decode, 151, 22, 46, // 301: decode to SwRxRyOffMemX16 using decoder 46
723 // 301: }
724 // 301: } // switch Inst[15:11]
725};
726static const uint8_t DecoderTableCOP3_32[35] = {
727 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
728 51, 6, // 3: case 0x33: {
729 OPC_CheckPredicate, 4, // 5: check predicate 4
730 OPC_Decode, 188, 15, 48, // 7: decode to LWC3 using decoder 48
731 // 7: }
732 55, 6, // 11: case 0x37: {
733 OPC_CheckPredicate, 5, // 13: check predicate 5
734 OPC_Decode, 128, 15, 48, // 15: decode to LDC3 using decoder 48
735 // 15: }
736 59, 6, // 19: case 0x3b: {
737 OPC_CheckPredicate, 4, // 21: check predicate 4
738 OPC_Decode, 227, 21, 48, // 23: decode to SWC3 using decoder 48
739 // 23: }
740 63, 0, // 27: case 0x3f: {
741 OPC_CheckPredicate, 5, // 29: check predicate 5
742 OPC_Decode, 223, 19, 48, // 31: decode to SDC3 using decoder 48
743 // 31: }
744 // 31: } // switch Inst[31:26]
745};
746static const uint8_t DecoderTableCnMips32[298] = {
747 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
748 18, 19, // 3: case 0x12: {
749 OPC_SwitchField, 21, 5, // 5: switch Inst[25:21] {
750 1, 6, // 8: case 0x1: {
751 OPC_CheckPredicate, 6, // 10: check predicate 6
752 OPC_Decode, 208, 11, 49, // 12: decode to DMFC2_OCTEON using decoder 49
753 // 12: }
754 5, 0, // 16: case 0x5: {
755 OPC_CheckPredicate, 6, // 18: check predicate 6
756 OPC_Decode, 216, 11, 49, // 20: decode to DMTC2_OCTEON using decoder 49
757 // 20: }
758 // 20: } // switch Inst[25:21]
759 // 20: }
760 28, 239, 1, // 24: case 0x1c: {
761 OPC_SwitchField, 0, 6, // 27: switch Inst[5:0] {
762 3, 10, // 30: case 0x3: {
763 OPC_CheckPredicate, 6, // 32: check predicate 6
764 OPC_CheckField, 6, 5, 0, // 34: check Inst[10:6] == 0x0
765 OPC_Decode, 220, 11, 50, // 38: decode to DMUL using decoder 50
766 // 38: }
767 8, 10, // 42: case 0x8: {
768 OPC_CheckPredicate, 6, // 44: check predicate 6
769 OPC_CheckField, 6, 15, 0, // 46: check Inst[20:6] == 0x0
770 OPC_Decode, 213, 17, 51, // 50: decode to MTM0 using decoder 51
771 // 50: }
772 9, 10, // 54: case 0x9: {
773 OPC_CheckPredicate, 6, // 56: check predicate 6
774 OPC_CheckField, 6, 15, 0, // 58: check Inst[20:6] == 0x0
775 OPC_Decode, 216, 17, 51, // 62: decode to MTP0 using decoder 51
776 // 62: }
777 10, 10, // 66: case 0xa: {
778 OPC_CheckPredicate, 6, // 68: check predicate 6
779 OPC_CheckField, 6, 15, 0, // 70: check Inst[20:6] == 0x0
780 OPC_Decode, 217, 17, 51, // 74: decode to MTP1 using decoder 51
781 // 74: }
782 11, 10, // 78: case 0xb: {
783 OPC_CheckPredicate, 6, // 80: check predicate 6
784 OPC_CheckField, 6, 15, 0, // 82: check Inst[20:6] == 0x0
785 OPC_Decode, 218, 17, 51, // 86: decode to MTP2 using decoder 51
786 // 86: }
787 12, 10, // 90: case 0xc: {
788 OPC_CheckPredicate, 6, // 92: check predicate 6
789 OPC_CheckField, 6, 15, 0, // 94: check Inst[20:6] == 0x0
790 OPC_Decode, 214, 17, 51, // 98: decode to MTM1 using decoder 51
791 // 98: }
792 13, 10, // 102: case 0xd: {
793 OPC_CheckPredicate, 6, // 104: check predicate 6
794 OPC_CheckField, 6, 15, 0, // 106: check Inst[20:6] == 0x0
795 OPC_Decode, 215, 17, 51, // 110: decode to MTM2 using decoder 51
796 // 110: }
797 15, 10, // 114: case 0xf: {
798 OPC_CheckPredicate, 6, // 116: check predicate 6
799 OPC_CheckField, 6, 5, 0, // 118: check Inst[10:6] == 0x0
800 OPC_Decode, 216, 22, 50, // 122: decode to VMULU using decoder 50
801 // 122: }
802 16, 10, // 126: case 0x10: {
803 OPC_CheckPredicate, 6, // 128: check predicate 6
804 OPC_CheckField, 6, 5, 0, // 130: check Inst[10:6] == 0x0
805 OPC_Decode, 215, 22, 50, // 134: decode to VMM0 using decoder 50
806 // 134: }
807 17, 10, // 138: case 0x11: {
808 OPC_CheckPredicate, 6, // 140: check predicate 6
809 OPC_CheckField, 6, 5, 0, // 142: check Inst[10:6] == 0x0
810 OPC_Decode, 214, 22, 50, // 146: decode to V3MULU using decoder 50
811 // 146: }
812 40, 10, // 150: case 0x28: {
813 OPC_CheckPredicate, 6, // 152: check predicate 6
814 OPC_CheckField, 6, 5, 0, // 154: check Inst[10:6] == 0x0
815 OPC_Decode, 159, 7, 50, // 158: decode to BADDu using decoder 50
816 // 158: }
817 42, 10, // 162: case 0x2a: {
818 OPC_CheckPredicate, 6, // 164: check predicate 6
819 OPC_CheckField, 6, 5, 0, // 166: check Inst[10:6] == 0x0
820 OPC_Decode, 254, 19, 50, // 170: decode to SEQ using decoder 50
821 // 170: }
822 43, 10, // 174: case 0x2b: {
823 OPC_CheckPredicate, 6, // 176: check predicate 6
824 OPC_CheckField, 6, 5, 0, // 178: check Inst[10:6] == 0x0
825 OPC_Decode, 226, 20, 50, // 182: decode to SNE using decoder 50
826 // 182: }
827 44, 14, // 186: case 0x2c: {
828 OPC_CheckPredicate, 6, // 188: check predicate 6
829 OPC_CheckField, 16, 5, 0, // 190: check Inst[20:16] == 0x0
830 OPC_CheckField, 6, 5, 0, // 194: check Inst[10:6] == 0x0
831 OPC_Decode, 212, 18, 52, // 198: decode to POP using decoder 52
832 // 198: }
833 45, 14, // 202: case 0x2d: {
834 OPC_CheckPredicate, 6, // 204: check predicate 6
835 OPC_CheckField, 16, 5, 0, // 206: check Inst[20:16] == 0x0
836 OPC_CheckField, 6, 5, 0, // 210: check Inst[10:6] == 0x0
837 OPC_Decode, 253, 11, 53, // 214: decode to DPOP using decoder 53
838 // 214: }
839 46, 6, // 218: case 0x2e: {
840 OPC_CheckPredicate, 6, // 220: check predicate 6
841 OPC_Decode, 255, 19, 54, // 222: decode to SEQi using decoder 54
842 // 222: }
843 47, 6, // 226: case 0x2f: {
844 OPC_CheckPredicate, 6, // 228: check predicate 6
845 OPC_Decode, 227, 20, 54, // 230: decode to SNEi using decoder 54
846 // 230: }
847 50, 6, // 234: case 0x32: {
848 OPC_CheckPredicate, 7, // 236: check predicate 7
849 OPC_Decode, 128, 9, 55, // 238: decode to CINS using decoder 55
850 // 238: }
851 51, 6, // 242: case 0x33: {
852 OPC_CheckPredicate, 7, // 244: check predicate 7
853 OPC_Decode, 129, 9, 55, // 246: decode to CINS32 using decoder 55
854 // 246: }
855 58, 6, // 250: case 0x3a: {
856 OPC_CheckPredicate, 7, // 252: check predicate 7
857 OPC_Decode, 212, 12, 55, // 254: decode to EXTS using decoder 55
858 // 254: }
859 59, 0, // 258: case 0x3b: {
860 OPC_CheckPredicate, 7, // 260: check predicate 7
861 OPC_Decode, 213, 12, 55, // 262: decode to EXTS32 using decoder 55
862 // 262: }
863 // 262: } // switch Inst[5:0]
864 // 262: }
865 50, 6, // 266: case 0x32: {
866 OPC_CheckPredicate, 6, // 268: check predicate 6
867 OPC_Decode, 165, 7, 56, // 270: decode to BBIT0 using decoder 56
868 // 270: }
869 54, 6, // 274: case 0x36: {
870 OPC_CheckPredicate, 6, // 276: check predicate 6
871 OPC_Decode, 166, 7, 56, // 278: decode to BBIT032 using decoder 56
872 // 278: }
873 58, 6, // 282: case 0x3a: {
874 OPC_CheckPredicate, 6, // 284: check predicate 6
875 OPC_Decode, 167, 7, 56, // 286: decode to BBIT1 using decoder 56
876 // 286: }
877 62, 0, // 290: case 0x3e: {
878 OPC_CheckPredicate, 6, // 292: check predicate 6
879 OPC_Decode, 168, 7, 56, // 294: decode to BBIT132 using decoder 56
880 // 294: }
881 // 294: } // switch Inst[31:26]
882};
883static const uint8_t DecoderTableCnMipsP32[27] = {
884 OPC_SwitchField, 0, 16, // 0: switch Inst[15:0] {
885 24, 10, // 3: case 0x18: {
886 OPC_CheckPredicate, 8, // 5: check predicate 8
887 OPC_CheckField, 26, 6, 28, // 7: check Inst[31:26] == 0x1c
888 OPC_Decode, 180, 19, 57, // 11: decode to SAA using decoder 57
889 // 11: }
890 25, 0, // 15: case 0x19: {
891 OPC_CheckPredicate, 8, // 17: check predicate 8
892 OPC_CheckField, 26, 6, 28, // 19: check Inst[31:26] == 0x1c
893 OPC_Decode, 181, 19, 57, // 23: decode to SAAD using decoder 57
894 // 23: }
895 // 23: } // switch Inst[15:0]
896};
897static const uint8_t DecoderTableMicroMips32[3894] = {
898 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
899 0, 206, 17, // 3: case 0x0: {
900 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
901 0, 64, // 9: case 0x0: {
902 OPC_SwitchField, 6, 5, // 11: switch Inst[10:6] {
903 0, 35, // 14: case 0x0: {
904 OPC_Scope, 27, // 16: try {
905 OPC_SwitchField, 11, 15, // 18: switch Inst[25:11] {
906 1, 6, // 21: case 0x1: {
907 OPC_CheckPredicate, 2, // 23: check predicate 2
908 OPC_Decode, 151, 21, 10, // 25: decode to SSNOP_MM using decoder 10
909 // 25: }
910 3, 6, // 29: case 0x3: {
911 OPC_CheckPredicate, 2, // 31: check predicate 2
912 OPC_Decode, 173, 12, 10, // 33: decode to EHB_MM using decoder 10
913 // 33: }
914 5, 0, // 37: case 0x5: {
915 OPC_CheckPredicate, 2, // 39: check predicate 2
916 OPC_Decode, 192, 18, 10, // 41: decode to PAUSE_MM using decoder 10
917 // 41: }
918 // 41: } // switch Inst[25:11]
919 // 41: } else try {
920 OPC_CheckPredicate, 2, // 45: check predicate 2
921 OPC_Decode, 211, 20, 58, // 47: decode to SLL_MM using decoder 58
922 // 47: }
923 // 47: }
924 1, 6, // 51: case 0x1: {
925 OPC_CheckPredicate, 2, // 53: check predicate 2
926 OPC_Decode, 148, 21, 58, // 55: decode to SRL_MM using decoder 58
927 // 55: }
928 2, 6, // 59: case 0x2: {
929 OPC_CheckPredicate, 2, // 61: check predicate 2
930 OPC_Decode, 254, 20, 58, // 63: decode to SRA_MM using decoder 58
931 // 63: }
932 3, 0, // 67: case 0x3: {
933 OPC_CheckPredicate, 2, // 69: check predicate 2
934 OPC_Decode, 160, 19, 58, // 71: decode to ROTR_MM using decoder 58
935 // 71: }
936 // 71: } // switch Inst[10:6]
937 // 71: }
938 5, 131, 1, // 75: case 0x5: {
939 OPC_SwitchField, 6, 5, // 78: switch Inst[10:6] {
940 0, 10, // 81: case 0x0: {
941 OPC_CheckPredicate, 9, // 83: check predicate 9
942 OPC_CheckField, 11, 5, 0, // 85: check Inst[15:11] == 0x0
943 OPC_Decode, 199, 9, 59, // 89: decode to CMP_EQ_PH_MM using decoder 59
944 // 89: }
945 1, 10, // 93: case 0x1: {
946 OPC_CheckPredicate, 9, // 95: check predicate 9
947 OPC_CheckField, 11, 5, 0, // 97: check Inst[15:11] == 0x0
948 OPC_Decode, 213, 9, 59, // 101: decode to CMP_LT_PH_MM using decoder 59
949 // 101: }
950 2, 10, // 105: case 0x2: {
951 OPC_CheckPredicate, 9, // 107: check predicate 9
952 OPC_CheckField, 11, 5, 0, // 109: check Inst[15:11] == 0x0
953 OPC_Decode, 207, 9, 59, // 113: decode to CMP_LE_PH_MM using decoder 59
954 // 113: }
955 6, 6, // 117: case 0x6: {
956 OPC_CheckPredicate, 10, // 119: check predicate 10
957 OPC_Decode, 177, 9, 60, // 121: decode to CMPGDU_EQ_QB_MMR2 using decoder 60
958 // 121: }
959 7, 6, // 125: case 0x7: {
960 OPC_CheckPredicate, 10, // 127: check predicate 10
961 OPC_Decode, 181, 9, 60, // 129: decode to CMPGDU_LT_QB_MMR2 using decoder 60
962 // 129: }
963 8, 6, // 133: case 0x8: {
964 OPC_CheckPredicate, 10, // 135: check predicate 10
965 OPC_Decode, 179, 9, 60, // 137: decode to CMPGDU_LE_QB_MMR2 using decoder 60
966 // 137: }
967 9, 10, // 141: case 0x9: {
968 OPC_CheckPredicate, 9, // 143: check predicate 9
969 OPC_CheckField, 11, 5, 0, // 145: check Inst[15:11] == 0x0
970 OPC_Decode, 189, 9, 59, // 149: decode to CMPU_EQ_QB_MM using decoder 59
971 // 149: }
972 10, 10, // 153: case 0xa: {
973 OPC_CheckPredicate, 9, // 155: check predicate 9
974 OPC_CheckField, 11, 5, 0, // 157: check Inst[15:11] == 0x0
975 OPC_Decode, 193, 9, 59, // 161: decode to CMPU_LT_QB_MM using decoder 59
976 // 161: }
977 11, 10, // 165: case 0xb: {
978 OPC_CheckPredicate, 9, // 167: check predicate 9
979 OPC_CheckField, 11, 5, 0, // 169: check Inst[15:11] == 0x0
980 OPC_Decode, 191, 9, 59, // 173: decode to CMPU_LE_QB_MM using decoder 59
981 // 173: }
982 12, 6, // 177: case 0xc: {
983 OPC_CheckPredicate, 9, // 179: check predicate 9
984 OPC_Decode, 176, 6, 61, // 181: decode to ADDQ_S_W_MM using decoder 61
985 // 181: }
986 13, 6, // 185: case 0xd: {
987 OPC_CheckPredicate, 9, // 187: check predicate 9
988 OPC_Decode, 171, 21, 61, // 189: decode to SUBQ_S_W_MM using decoder 61
989 // 189: }
990 14, 6, // 193: case 0xe: {
991 OPC_CheckPredicate, 9, // 195: check predicate 9
992 OPC_Decode, 179, 6, 61, // 197: decode to ADDSC_MM using decoder 61
993 // 197: }
994 15, 0, // 201: case 0xf: {
995 OPC_CheckPredicate, 9, // 203: check predicate 9
996 OPC_Decode, 216, 6, 61, // 205: decode to ADDWC_MM using decoder 61
997 // 205: }
998 // 205: } // switch Inst[10:6]
999 // 205: }
1000 7, 6, // 209: case 0x7: {
1001 OPC_CheckPredicate, 2, // 211: check predicate 2
1002 OPC_Decode, 199, 8, 62, // 213: decode to BREAK_MM using decoder 62
1003 // 213: }
1004 12, 6, // 217: case 0xc: {
1005 OPC_CheckPredicate, 1, // 219: check predicate 1
1006 OPC_Decode, 186, 14, 63, // 221: decode to INS_MM using decoder 63
1007 // 221: }
1008 13, 243, 1, // 225: case 0xd: {
1009 OPC_SwitchField, 6, 5, // 228: switch Inst[10:6] {
1010 0, 6, // 231: case 0x0: {
1011 OPC_CheckPredicate, 9, // 233: check predicate 9
1012 OPC_Decode, 172, 6, 64, // 235: decode to ADDQ_PH_MM using decoder 64
1013 // 235: }
1014 1, 6, // 239: case 0x1: {
1015 OPC_CheckPredicate, 10, // 241: check predicate 10
1016 OPC_Decode, 164, 6, 64, // 243: decode to ADDQH_PH_MMR2 using decoder 64
1017 // 243: }
1018 2, 6, // 247: case 0x2: {
1019 OPC_CheckPredicate, 10, // 249: check predicate 10
1020 OPC_Decode, 170, 6, 61, // 251: decode to ADDQH_W_MMR2 using decoder 61
1021 // 251: }
1022 3, 6, // 255: case 0x3: {
1023 OPC_CheckPredicate, 9, // 257: check predicate 9
1024 OPC_Decode, 202, 6, 64, // 259: decode to ADDU_QB_MM using decoder 64
1025 // 259: }
1026 4, 6, // 263: case 0x4: {
1027 OPC_CheckPredicate, 10, // 265: check predicate 10
1028 OPC_Decode, 200, 6, 64, // 267: decode to ADDU_PH_MMR2 using decoder 64
1029 // 267: }
1030 5, 6, // 271: case 0x5: {
1031 OPC_CheckPredicate, 10, // 273: check predicate 10
1032 OPC_Decode, 195, 6, 64, // 275: decode to ADDUH_QB_MMR2 using decoder 64
1033 // 275: }
1034 6, 6, // 279: case 0x6: {
1035 OPC_CheckPredicate, 9, // 281: check predicate 9
1036 OPC_Decode, 158, 20, 65, // 283: decode to SHRAV_PH_MM using decoder 65
1037 // 283: }
1038 7, 6, // 287: case 0x7: {
1039 OPC_CheckPredicate, 10, // 289: check predicate 10
1040 OPC_Decode, 160, 20, 65, // 291: decode to SHRAV_QB_MMR2 using decoder 65
1041 // 291: }
1042 8, 6, // 295: case 0x8: {
1043 OPC_CheckPredicate, 9, // 297: check predicate 9
1044 OPC_Decode, 167, 21, 64, // 299: decode to SUBQ_PH_MM using decoder 64
1045 // 299: }
1046 9, 6, // 303: case 0x9: {
1047 OPC_CheckPredicate, 10, // 305: check predicate 10
1048 OPC_Decode, 159, 21, 64, // 307: decode to SUBQH_PH_MMR2 using decoder 64
1049 // 307: }
1050 10, 6, // 311: case 0xa: {
1051 OPC_CheckPredicate, 10, // 313: check predicate 10
1052 OPC_Decode, 165, 21, 61, // 315: decode to SUBQH_W_MMR2 using decoder 61
1053 // 315: }
1054 11, 6, // 319: case 0xb: {
1055 OPC_CheckPredicate, 9, // 321: check predicate 9
1056 OPC_Decode, 198, 21, 64, // 323: decode to SUBU_QB_MM using decoder 64
1057 // 323: }
1058 12, 6, // 327: case 0xc: {
1059 OPC_CheckPredicate, 10, // 329: check predicate 10
1060 OPC_Decode, 196, 21, 64, // 331: decode to SUBU_PH_MMR2 using decoder 64
1061 // 331: }
1062 13, 6, // 335: case 0xd: {
1063 OPC_CheckPredicate, 10, // 337: check predicate 10
1064 OPC_Decode, 191, 21, 64, // 339: decode to SUBUH_QB_MMR2 using decoder 64
1065 // 339: }
1066 15, 6, // 343: case 0xf: {
1067 OPC_CheckPredicate, 10, // 345: check predicate 10
1068 OPC_Decode, 244, 18, 66, // 347: decode to PRECR_SRA_PH_W_MMR2 using decoder 66
1069 // 347: }
1070 16, 6, // 351: case 0x10: {
1071 OPC_CheckPredicate, 9, // 353: check predicate 9
1072 OPC_Decode, 174, 6, 64, // 355: decode to ADDQ_S_PH_MM using decoder 64
1073 // 355: }
1074 17, 6, // 359: case 0x11: {
1075 OPC_CheckPredicate, 10, // 361: check predicate 10
1076 OPC_Decode, 166, 6, 64, // 363: decode to ADDQH_R_PH_MMR2 using decoder 64
1077 // 363: }
1078 18, 6, // 367: case 0x12: {
1079 OPC_CheckPredicate, 10, // 369: check predicate 10
1080 OPC_Decode, 168, 6, 61, // 371: decode to ADDQH_R_W_MMR2 using decoder 61
1081 // 371: }
1082 19, 6, // 375: case 0x13: {
1083 OPC_CheckPredicate, 9, // 377: check predicate 9
1084 OPC_Decode, 206, 6, 64, // 379: decode to ADDU_S_QB_MM using decoder 64
1085 // 379: }
1086 20, 6, // 383: case 0x14: {
1087 OPC_CheckPredicate, 10, // 385: check predicate 10
1088 OPC_Decode, 204, 6, 64, // 387: decode to ADDU_S_PH_MMR2 using decoder 64
1089 // 387: }
1090 21, 6, // 391: case 0x15: {
1091 OPC_CheckPredicate, 10, // 393: check predicate 10
1092 OPC_Decode, 197, 6, 64, // 395: decode to ADDUH_R_QB_MMR2 using decoder 64
1093 // 395: }
1094 22, 6, // 399: case 0x16: {
1095 OPC_CheckPredicate, 9, // 401: check predicate 9
1096 OPC_Decode, 162, 20, 65, // 403: decode to SHRAV_R_PH_MM using decoder 65
1097 // 403: }
1098 23, 6, // 407: case 0x17: {
1099 OPC_CheckPredicate, 10, // 409: check predicate 10
1100 OPC_Decode, 164, 20, 65, // 411: decode to SHRAV_R_QB_MMR2 using decoder 65
1101 // 411: }
1102 24, 6, // 415: case 0x18: {
1103 OPC_CheckPredicate, 9, // 417: check predicate 9
1104 OPC_Decode, 169, 21, 64, // 419: decode to SUBQ_S_PH_MM using decoder 64
1105 // 419: }
1106 25, 6, // 423: case 0x19: {
1107 OPC_CheckPredicate, 10, // 425: check predicate 10
1108 OPC_Decode, 161, 21, 64, // 427: decode to SUBQH_R_PH_MMR2 using decoder 64
1109 // 427: }
1110 26, 6, // 431: case 0x1a: {
1111 OPC_CheckPredicate, 10, // 433: check predicate 10
1112 OPC_Decode, 163, 21, 61, // 435: decode to SUBQH_R_W_MMR2 using decoder 61
1113 // 435: }
1114 27, 6, // 439: case 0x1b: {
1115 OPC_CheckPredicate, 9, // 441: check predicate 9
1116 OPC_Decode, 202, 21, 64, // 443: decode to SUBU_S_QB_MM using decoder 64
1117 // 443: }
1118 28, 6, // 447: case 0x1c: {
1119 OPC_CheckPredicate, 10, // 449: check predicate 10
1120 OPC_Decode, 200, 21, 64, // 451: decode to SUBU_S_PH_MMR2 using decoder 64
1121 // 451: }
1122 29, 6, // 455: case 0x1d: {
1123 OPC_CheckPredicate, 10, // 457: check predicate 10
1124 OPC_Decode, 193, 21, 64, // 459: decode to SUBUH_R_QB_MMR2 using decoder 64
1125 // 459: }
1126 31, 0, // 463: case 0x1f: {
1127 OPC_CheckPredicate, 10, // 465: check predicate 10
1128 OPC_Decode, 246, 18, 66, // 467: decode to PRECR_SRA_R_PH_W_MMR2 using decoder 66
1129 // 467: }
1130 // 467: } // switch Inst[10:6]
1131 // 467: }
1132 14, 19, // 471: case 0xe: {
1133 OPC_SwitchField, 6, 5, // 473: switch Inst[10:6] {
1134 0, 6, // 476: case 0x0: {
1135 OPC_CheckPredicate, 9, // 478: check predicate 9
1136 OPC_Decode, 142, 20, 65, // 480: decode to SHLLV_PH_MM using decoder 65
1137 // 480: }
1138 16, 0, // 484: case 0x10: {
1139 OPC_CheckPredicate, 9, // 486: check predicate 9
1140 OPC_Decode, 146, 20, 65, // 488: decode to SHLLV_S_PH_MM using decoder 65
1141 // 488: }
1142 // 488: } // switch Inst[10:6]
1143 // 488: }
1144 16, 123, // 492: case 0x10: {
1145 OPC_SwitchField, 6, 5, // 494: switch Inst[10:6] {
1146 0, 6, // 497: case 0x0: {
1147 OPC_CheckPredicate, 2, // 499: check predicate 2
1148 OPC_Decode, 207, 20, 67, // 501: decode to SLLV_MM using decoder 67
1149 // 501: }
1150 1, 6, // 505: case 0x1: {
1151 OPC_CheckPredicate, 2, // 507: check predicate 2
1152 OPC_Decode, 144, 21, 67, // 509: decode to SRLV_MM using decoder 67
1153 // 509: }
1154 2, 6, // 513: case 0x2: {
1155 OPC_CheckPredicate, 2, // 515: check predicate 2
1156 OPC_Decode, 250, 20, 67, // 517: decode to SRAV_MM using decoder 67
1157 // 517: }
1158 3, 6, // 521: case 0x3: {
1159 OPC_CheckPredicate, 2, // 523: check predicate 2
1160 OPC_Decode, 159, 19, 67, // 525: decode to ROTRV_MM using decoder 67
1161 // 525: }
1162 4, 6, // 529: case 0x4: {
1163 OPC_CheckPredicate, 1, // 531: check predicate 1
1164 OPC_Decode, 221, 6, 61, // 533: decode to ADD_MM using decoder 61
1165 // 533: }
1166 5, 6, // 537: case 0x5: {
1167 OPC_CheckPredicate, 1, // 539: check predicate 1
1168 OPC_Decode, 228, 6, 61, // 541: decode to ADDu_MM using decoder 61
1169 // 541: }
1170 6, 6, // 545: case 0x6: {
1171 OPC_CheckPredicate, 1, // 547: check predicate 1
1172 OPC_Decode, 211, 21, 61, // 549: decode to SUB_MM using decoder 61
1173 // 549: }
1174 7, 6, // 553: case 0x7: {
1175 OPC_CheckPredicate, 1, // 555: check predicate 1
1176 OPC_Decode, 214, 21, 61, // 557: decode to SUBu_MM using decoder 61
1177 // 557: }
1178 8, 6, // 561: case 0x8: {
1179 OPC_CheckPredicate, 1, // 563: check predicate 1
1180 OPC_Decode, 134, 18, 61, // 565: decode to MUL_MM using decoder 61
1181 // 565: }
1182 9, 6, // 569: case 0x9: {
1183 OPC_CheckPredicate, 1, // 571: check predicate 1
1184 OPC_Decode, 241, 6, 61, // 573: decode to AND_MM using decoder 61
1185 // 573: }
1186 10, 6, // 577: case 0xa: {
1187 OPC_CheckPredicate, 1, // 579: check predicate 1
1188 OPC_Decode, 182, 18, 61, // 581: decode to OR_MM using decoder 61
1189 // 581: }
1190 11, 6, // 585: case 0xb: {
1191 OPC_CheckPredicate, 1, // 587: check predicate 1
1192 OPC_Decode, 169, 18, 61, // 589: decode to NOR_MM using decoder 61
1193 // 589: }
1194 12, 6, // 593: case 0xc: {
1195 OPC_CheckPredicate, 1, // 595: check predicate 1
1196 OPC_Decode, 236, 22, 61, // 597: decode to XOR_MM using decoder 61
1197 // 597: }
1198 13, 6, // 601: case 0xd: {
1199 OPC_CheckPredicate, 2, // 603: check predicate 2
1200 OPC_Decode, 216, 20, 61, // 605: decode to SLT_MM using decoder 61
1201 // 605: }
1202 14, 0, // 609: case 0xe: {
1203 OPC_CheckPredicate, 2, // 611: check predicate 2
1204 OPC_Decode, 225, 20, 61, // 613: decode to SLTu_MM using decoder 61
1205 // 613: }
1206 // 613: } // switch Inst[10:6]
1207 // 613: }
1208 21, 115, // 617: case 0x15: {
1209 OPC_SwitchField, 6, 5, // 619: switch Inst[10:6] {
1210 2, 6, // 622: case 0x2: {
1211 OPC_CheckPredicate, 9, // 624: check predicate 9
1212 OPC_Decode, 230, 17, 64, // 626: decode to MULEU_S_PH_QBL_MM using decoder 64
1213 // 626: }
1214 3, 6, // 630: case 0x3: {
1215 OPC_CheckPredicate, 9, // 632: check predicate 9
1216 OPC_Decode, 232, 17, 64, // 634: decode to MULEU_S_PH_QBR_MM using decoder 64
1217 // 634: }
1218 4, 6, // 638: case 0x4: {
1219 OPC_CheckPredicate, 9, // 640: check predicate 9
1220 OPC_Decode, 234, 17, 64, // 642: decode to MULQ_RS_PH_MM using decoder 64
1221 // 642: }
1222 5, 6, // 646: case 0x5: {
1223 OPC_CheckPredicate, 10, // 648: check predicate 10
1224 OPC_Decode, 238, 17, 64, // 650: decode to MULQ_S_PH_MMR2 using decoder 64
1225 // 650: }
1226 6, 6, // 654: case 0x6: {
1227 OPC_CheckPredicate, 10, // 656: check predicate 10
1228 OPC_Decode, 236, 17, 61, // 658: decode to MULQ_RS_W_MMR2 using decoder 61
1229 // 658: }
1230 7, 6, // 662: case 0x7: {
1231 OPC_CheckPredicate, 10, // 664: check predicate 10
1232 OPC_Decode, 240, 17, 61, // 666: decode to MULQ_S_W_MMR2 using decoder 61
1233 // 666: }
1234 8, 6, // 670: case 0x8: {
1235 OPC_CheckPredicate, 10, // 672: check predicate 10
1236 OPC_Decode, 248, 6, 68, // 674: decode to APPEND_MMR2 using decoder 68
1237 // 674: }
1238 9, 6, // 678: case 0x9: {
1239 OPC_CheckPredicate, 10, // 680: check predicate 10
1240 OPC_Decode, 255, 18, 68, // 682: decode to PREPEND_MMR2 using decoder 68
1241 // 682: }
1242 10, 6, // 686: case 0xa: {
1243 OPC_CheckPredicate, 9, // 688: check predicate 9
1244 OPC_Decode, 227, 16, 61, // 690: decode to MODSUB_MM using decoder 61
1245 // 690: }
1246 11, 6, // 694: case 0xb: {
1247 OPC_CheckPredicate, 9, // 696: check predicate 9
1248 OPC_Decode, 166, 20, 67, // 698: decode to SHRAV_R_W_MM using decoder 67
1249 // 698: }
1250 12, 6, // 702: case 0xc: {
1251 OPC_CheckPredicate, 10, // 704: check predicate 10
1252 OPC_Decode, 178, 20, 65, // 706: decode to SHRLV_PH_MMR2 using decoder 65
1253 // 706: }
1254 13, 6, // 710: case 0xd: {
1255 OPC_CheckPredicate, 9, // 712: check predicate 9
1256 OPC_Decode, 180, 20, 65, // 714: decode to SHRLV_QB_MM using decoder 65
1257 // 714: }
1258 14, 6, // 718: case 0xe: {
1259 OPC_CheckPredicate, 9, // 720: check predicate 9
1260 OPC_Decode, 144, 20, 65, // 722: decode to SHLLV_QB_MM using decoder 65
1261 // 722: }
1262 15, 0, // 726: case 0xf: {
1263 OPC_CheckPredicate, 9, // 728: check predicate 9
1264 OPC_Decode, 148, 20, 67, // 730: decode to SHLLV_S_W_MM using decoder 67
1265 // 730: }
1266 // 730: } // switch Inst[10:6]
1267 // 730: }
1268 24, 27, // 734: case 0x18: {
1269 OPC_SwitchField, 6, 5, // 736: switch Inst[10:6] {
1270 0, 6, // 739: case 0x0: {
1271 OPC_CheckPredicate, 1, // 741: check predicate 1
1272 OPC_Decode, 133, 17, 69, // 743: decode to MOVN_I_MM using decoder 69
1273 // 743: }
1274 1, 6, // 747: case 0x1: {
1275 OPC_CheckPredicate, 1, // 749: check predicate 1
1276 OPC_Decode, 153, 17, 69, // 751: decode to MOVZ_I_MM using decoder 69
1277 // 751: }
1278 4, 0, // 755: case 0x4: {
1279 OPC_CheckPredicate, 2, // 757: check predicate 2
1280 OPC_Decode, 216, 15, 70, // 759: decode to LWXS_MM using decoder 70
1281 // 759: }
1282 // 759: } // switch Inst[10:6]
1283 // 759: }
1284 29, 14, // 763: case 0x1d: {
1285 OPC_CheckPredicate, 9, // 765: check predicate 9
1286 OPC_CheckField, 22, 4, 0, // 767: check Inst[25:22] == 0x0
1287 OPC_CheckField, 6, 8, 0, // 771: check Inst[13:6] == 0x0
1288 OPC_Decode, 140, 20, 71, // 775: decode to SHILO_MM using decoder 71
1289 // 775: }
1290 37, 43, // 779: case 0x25: {
1291 OPC_SwitchField, 6, 5, // 781: switch Inst[10:6] {
1292 0, 6, // 784: case 0x0: {
1293 OPC_CheckPredicate, 9, // 786: check predicate 9
1294 OPC_Decode, 226, 17, 60, // 788: decode to MULEQ_S_W_PHL_MM using decoder 60
1295 // 788: }
1296 1, 6, // 792: case 0x1: {
1297 OPC_CheckPredicate, 9, // 794: check predicate 9
1298 OPC_Decode, 228, 17, 60, // 796: decode to MULEQ_S_W_PHR_MM using decoder 60
1299 // 796: }
1300 5, 6, // 800: case 0x5: {
1301 OPC_CheckPredicate, 9, // 802: check predicate 9
1302 OPC_Decode, 151, 15, 70, // 804: decode to LHX_MM using decoder 70
1303 // 804: }
1304 6, 6, // 808: case 0x6: {
1305 OPC_CheckPredicate, 9, // 810: check predicate 9
1306 OPC_Decode, 217, 15, 70, // 812: decode to LWX_MM using decoder 70
1307 // 812: }
1308 8, 0, // 816: case 0x8: {
1309 OPC_CheckPredicate, 9, // 818: check predicate 9
1310 OPC_Decode, 238, 14, 70, // 820: decode to LBUX_MM using decoder 70
1311 // 820: }
1312 // 820: } // switch Inst[10:6]
1313 // 820: }
1314 44, 6, // 824: case 0x2c: {
1315 OPC_CheckPredicate, 1, // 826: check predicate 1
1316 OPC_Decode, 214, 12, 72, // 828: decode to EXT_MM using decoder 72
1317 // 828: }
1318 45, 83, // 832: case 0x2d: {
1319 OPC_SwitchField, 6, 5, // 834: switch Inst[10:6] {
1320 0, 6, // 837: case 0x0: {
1321 OPC_CheckPredicate, 10, // 839: check predicate 10
1322 OPC_Decode, 137, 18, 64, // 841: decode to MUL_PH_MMR2 using decoder 64
1323 // 841: }
1324 1, 6, // 845: case 0x1: {
1325 OPC_CheckPredicate, 10, // 847: check predicate 10
1326 OPC_Decode, 242, 18, 64, // 849: decode to PRECR_QB_PH_MMR2 using decoder 64
1327 // 849: }
1328 2, 6, // 853: case 0x2: {
1329 OPC_CheckPredicate, 9, // 855: check predicate 9
1330 OPC_Decode, 238, 18, 64, // 857: decode to PRECRQ_QB_PH_MM using decoder 64
1331 // 857: }
1332 3, 6, // 861: case 0x3: {
1333 OPC_CheckPredicate, 9, // 863: check predicate 9
1334 OPC_Decode, 236, 18, 73, // 865: decode to PRECRQ_PH_W_MM using decoder 73
1335 // 865: }
1336 4, 6, // 869: case 0x4: {
1337 OPC_CheckPredicate, 9, // 871: check predicate 9
1338 OPC_Decode, 240, 18, 73, // 873: decode to PRECRQ_RS_PH_W_MM using decoder 73
1339 // 873: }
1340 5, 6, // 877: case 0x5: {
1341 OPC_CheckPredicate, 9, // 879: check predicate 9
1342 OPC_Decode, 234, 18, 64, // 881: decode to PRECRQU_S_QB_PH_MM using decoder 64
1343 // 881: }
1344 6, 6, // 885: case 0x6: {
1345 OPC_CheckPredicate, 9, // 887: check predicate 9
1346 OPC_Decode, 190, 18, 64, // 889: decode to PACKRL_PH_MM using decoder 64
1347 // 889: }
1348 7, 6, // 893: case 0x7: {
1349 OPC_CheckPredicate, 9, // 895: check predicate 9
1350 OPC_Decode, 209, 18, 64, // 897: decode to PICK_QB_MM using decoder 64
1351 // 897: }
1352 8, 6, // 901: case 0x8: {
1353 OPC_CheckPredicate, 9, // 903: check predicate 9
1354 OPC_Decode, 207, 18, 64, // 905: decode to PICK_PH_MM using decoder 64
1355 // 905: }
1356 16, 0, // 909: case 0x10: {
1357 OPC_CheckPredicate, 10, // 911: check predicate 10
1358 OPC_Decode, 142, 18, 64, // 913: decode to MUL_S_PH_MMR2 using decoder 64
1359 // 913: }
1360 // 913: } // switch Inst[10:6]
1361 // 913: }
1362 52, 27, // 917: case 0x34: {
1363 OPC_SwitchField, 6, 5, // 919: switch Inst[10:6] {
1364 19, 10, // 922: case 0x13: {
1365 OPC_CheckPredicate, 11, // 924: check predicate 11
1366 OPC_CheckField, 14, 2, 0, // 926: check Inst[15:14] == 0x0
1367 OPC_Decode, 183, 16, 74, // 930: decode to MFHGC0_MM using decoder 74
1368 // 930: }
1369 27, 0, // 934: case 0x1b: {
1370 OPC_CheckPredicate, 11, // 936: check predicate 11
1371 OPC_CheckField, 14, 2, 0, // 938: check Inst[15:14] == 0x0
1372 OPC_Decode, 200, 17, 75, // 942: decode to MTHGC0_MM using decoder 75
1373 // 942: }
1374 // 942: } // switch Inst[10:6]
1375 // 942: }
1376 53, 64, // 946: case 0x35: {
1377 OPC_SwitchField, 6, 5, // 948: switch Inst[10:6] {
1378 11, 6, // 951: case 0xb: {
1379 OPC_CheckPredicate, 9, // 953: check predicate 9
1380 OPC_Decode, 176, 20, 58, // 955: decode to SHRA_R_W_MM using decoder 58
1381 // 955: }
1382 12, 10, // 959: case 0xc: {
1383 OPC_CheckPredicate, 9, // 961: check predicate 9
1384 OPC_CheckField, 11, 1, 0, // 963: check Inst[11] == 0x0
1385 OPC_Decode, 168, 20, 76, // 967: decode to SHRA_PH_MM using decoder 76
1386 // 967: }
1387 14, 19, // 971: case 0xe: {
1388 OPC_SwitchField, 11, 1, // 973: switch Inst[11] {
1389 0, 6, // 976: case 0x0: {
1390 OPC_CheckPredicate, 9, // 978: check predicate 9
1391 OPC_Decode, 150, 20, 76, // 980: decode to SHLL_PH_MM using decoder 76
1392 // 980: }
1393 1, 0, // 984: case 0x1: {
1394 OPC_CheckPredicate, 9, // 986: check predicate 9
1395 OPC_Decode, 154, 20, 76, // 988: decode to SHLL_S_PH_MM using decoder 76
1396 // 988: }
1397 // 988: } // switch Inst[11]
1398 // 988: }
1399 15, 6, // 992: case 0xf: {
1400 OPC_CheckPredicate, 9, // 994: check predicate 9
1401 OPC_Decode, 156, 20, 58, // 996: decode to SHLL_S_W_MM using decoder 58
1402 // 996: }
1403 28, 0, // 1000: case 0x1c: {
1404 OPC_CheckPredicate, 9, // 1002: check predicate 9
1405 OPC_CheckField, 11, 1, 0, // 1004: check Inst[11] == 0x0
1406 OPC_Decode, 172, 20, 76, // 1008: decode to SHRA_R_PH_MM using decoder 76
1407 // 1008: }
1408 // 1008: } // switch Inst[10:6]
1409 // 1008: }
1410 60, 209, 9, // 1012: case 0x3c: {
1411 OPC_SwitchField, 6, 5, // 1015: switch Inst[10:6] {
1412 0, 19, // 1018: case 0x0: {
1413 OPC_SwitchField, 11, 1, // 1020: switch Inst[11] {
1414 0, 6, // 1023: case 0x0: {
1415 OPC_CheckPredicate, 2, // 1025: check predicate 2
1416 OPC_Decode, 156, 22, 77, // 1027: decode to TEQ_MM using decoder 77
1417 // 1027: }
1418 1, 0, // 1031: case 0x1: {
1419 OPC_CheckPredicate, 2, // 1033: check predicate 2
1420 OPC_Decode, 195, 22, 77, // 1035: decode to TLT_MM using decoder 77
1421 // 1035: }
1422 // 1035: } // switch Inst[11]
1423 // 1035: }
1424 1, 77, // 1039: case 0x1: {
1425 OPC_SwitchField, 11, 2, // 1041: switch Inst[12:11] {
1426 0, 27, // 1044: case 0x0: {
1427 OPC_SwitchField, 13, 1, // 1046: switch Inst[13] {
1428 0, 10, // 1049: case 0x0: {
1429 OPC_CheckPredicate, 9, // 1051: check predicate 9
1430 OPC_CheckField, 21, 5, 0, // 1053: check Inst[25:21] == 0x0
1431 OPC_Decode, 188, 16, 78, // 1057: decode to MFHI_DSP_MM using decoder 78
1432 // 1057: }
1433 1, 0, // 1061: case 0x1: {
1434 OPC_CheckPredicate, 9, // 1063: check predicate 9
1435 OPC_CheckField, 21, 5, 0, // 1065: check Inst[25:21] == 0x0
1436 OPC_Decode, 204, 17, 79, // 1069: decode to MTHI_DSP_MM using decoder 79
1437 // 1069: }
1438 // 1069: } // switch Inst[13]
1439 // 1069: }
1440 1, 6, // 1073: case 0x1: {
1441 OPC_CheckPredicate, 9, // 1075: check predicate 9
1442 OPC_Decode, 152, 20, 80, // 1077: decode to SHLL_QB_MM using decoder 80
1443 // 1077: }
1444 2, 27, // 1081: case 0x2: {
1445 OPC_SwitchField, 13, 1, // 1083: switch Inst[13] {
1446 0, 10, // 1086: case 0x0: {
1447 OPC_CheckPredicate, 9, // 1088: check predicate 9
1448 OPC_CheckField, 21, 5, 0, // 1090: check Inst[25:21] == 0x0
1449 OPC_Decode, 194, 16, 78, // 1094: decode to MFLO_DSP_MM using decoder 78
1450 // 1094: }
1451 1, 0, // 1098: case 0x1: {
1452 OPC_CheckPredicate, 9, // 1100: check predicate 9
1453 OPC_CheckField, 21, 5, 0, // 1102: check Inst[25:21] == 0x0
1454 OPC_Decode, 211, 17, 81, // 1106: decode to MTLO_DSP_MM using decoder 81
1455 // 1106: }
1456 // 1106: } // switch Inst[13]
1457 // 1106: }
1458 3, 0, // 1110: case 0x3: {
1459 OPC_CheckPredicate, 9, // 1112: check predicate 9
1460 OPC_Decode, 184, 20, 80, // 1114: decode to SHRL_QB_MM using decoder 80
1461 // 1114: }
1462 // 1114: } // switch Inst[12:11]
1463 // 1114: }
1464 2, 59, // 1118: case 0x2: {
1465 OPC_SwitchField, 11, 3, // 1120: switch Inst[13:11] {
1466 0, 6, // 1123: case 0x0: {
1467 OPC_CheckPredicate, 10, // 1125: check predicate 10
1468 OPC_Decode, 252, 11, 82, // 1127: decode to DPA_W_PH_MMR2 using decoder 82
1469 // 1127: }
1470 1, 6, // 1131: case 0x1: {
1471 OPC_CheckPredicate, 10, // 1133: check predicate 10
1472 OPC_Decode, 164, 7, 83, // 1135: decode to BALIGN_MMR2 using decoder 83
1473 // 1135: }
1474 2, 6, // 1139: case 0x2: {
1475 OPC_CheckPredicate, 10, // 1141: check predicate 10
1476 OPC_Decode, 250, 11, 82, // 1143: decode to DPAX_W_PH_MMR2 using decoder 82
1477 // 1143: }
1478 4, 6, // 1147: case 0x4: {
1479 OPC_CheckPredicate, 9, // 1149: check predicate 9
1480 OPC_Decode, 246, 11, 82, // 1151: decode to DPAU_H_QBL_MM using decoder 82
1481 // 1151: }
1482 5, 6, // 1155: case 0x5: {
1483 OPC_CheckPredicate, 9, // 1157: check predicate 9
1484 OPC_Decode, 194, 12, 84, // 1159: decode to EXTPV_MM using decoder 84
1485 // 1159: }
1486 6, 6, // 1163: case 0x6: {
1487 OPC_CheckPredicate, 9, // 1165: check predicate 9
1488 OPC_Decode, 248, 11, 82, // 1167: decode to DPAU_H_QBR_MM using decoder 82
1489 // 1167: }
1490 7, 0, // 1171: case 0x7: {
1491 OPC_CheckPredicate, 9, // 1173: check predicate 9
1492 OPC_Decode, 191, 12, 84, // 1175: decode to EXTPDPV_MM using decoder 84
1493 // 1175: }
1494 // 1175: } // switch Inst[13:11]
1495 // 1175: }
1496 3, 10, // 1179: case 0x3: {
1497 OPC_CheckPredicate, 1, // 1181: check predicate 1
1498 OPC_CheckField, 14, 2, 0, // 1183: check Inst[15:14] == 0x0
1499 OPC_Decode, 166, 16, 74, // 1187: decode to MFC0_MM using decoder 74
1500 // 1187: }
1501 4, 99, // 1191: case 0x4: {
1502 OPC_SwitchField, 11, 5, // 1193: switch Inst[15:11] {
1503 0, 6, // 1196: case 0x0: {
1504 OPC_CheckPredicate, 10, // 1198: check predicate 10
1505 OPC_Decode, 151, 6, 85, // 1200: decode to ABSQ_S_QB_MMR2 using decoder 85
1506 // 1200: }
1507 2, 6, // 1204: case 0x2: {
1508 OPC_CheckPredicate, 9, // 1206: check predicate 9
1509 OPC_Decode, 149, 6, 85, // 1208: decode to ABSQ_S_PH_MM using decoder 85
1510 // 1208: }
1511 4, 6, // 1212: case 0x4: {
1512 OPC_CheckPredicate, 9, // 1214: check predicate 9
1513 OPC_Decode, 153, 6, 86, // 1216: decode to ABSQ_S_W_MM using decoder 86
1514 // 1216: }
1515 6, 6, // 1220: case 0x6: {
1516 OPC_CheckPredicate, 9, // 1222: check predicate 9
1517 OPC_Decode, 254, 7, 86, // 1224: decode to BITREV_MM using decoder 86
1518 // 1224: }
1519 8, 6, // 1228: case 0x8: {
1520 OPC_CheckPredicate, 9, // 1230: check predicate 9
1521 OPC_Decode, 185, 14, 87, // 1232: decode to INSV_MM using decoder 87
1522 // 1232: }
1523 10, 6, // 1236: case 0xa: {
1524 OPC_CheckPredicate, 9, // 1238: check predicate 9
1525 OPC_Decode, 222, 18, 88, // 1240: decode to PRECEQ_W_PHL_MM using decoder 88
1526 // 1240: }
1527 12, 6, // 1244: case 0xc: {
1528 OPC_CheckPredicate, 9, // 1246: check predicate 9
1529 OPC_Decode, 224, 18, 88, // 1248: decode to PRECEQ_W_PHR_MM using decoder 88
1530 // 1248: }
1531 14, 6, // 1252: case 0xe: {
1532 OPC_CheckPredicate, 9, // 1254: check predicate 9
1533 OPC_Decode, 216, 18, 85, // 1256: decode to PRECEQU_PH_QBL_MM using decoder 85
1534 // 1256: }
1535 18, 6, // 1260: case 0x12: {
1536 OPC_CheckPredicate, 9, // 1262: check predicate 9
1537 OPC_Decode, 220, 18, 85, // 1264: decode to PRECEQU_PH_QBR_MM using decoder 85
1538 // 1264: }
1539 22, 6, // 1268: case 0x16: {
1540 OPC_CheckPredicate, 9, // 1270: check predicate 9
1541 OPC_Decode, 228, 18, 85, // 1272: decode to PRECEU_PH_QBL_MM using decoder 85
1542 // 1272: }
1543 26, 6, // 1276: case 0x1a: {
1544 OPC_CheckPredicate, 9, // 1278: check predicate 9
1545 OPC_Decode, 232, 18, 85, // 1280: decode to PRECEU_PH_QBR_MM using decoder 85
1546 // 1280: }
1547 30, 0, // 1284: case 0x1e: {
1548 OPC_CheckPredicate, 9, // 1286: check predicate 9
1549 OPC_Decode, 131, 19, 88, // 1288: decode to RADDU_W_QB_MM using decoder 88
1550 // 1288: }
1551 // 1288: } // switch Inst[15:11]
1552 // 1288: }
1553 5, 51, // 1292: case 0x5: {
1554 OPC_SwitchField, 11, 15, // 1294: switch Inst[25:11] {
1555 0, 6, // 1297: case 0x0: {
1556 OPC_CheckPredicate, 11, // 1299: check predicate 11
1557 OPC_Decode, 170, 22, 10, // 1301: decode to TLBGP_MM using decoder 10
1558 // 1301: }
1559 2, 6, // 1305: case 0x2: {
1560 OPC_CheckPredicate, 11, // 1307: check predicate 11
1561 OPC_Decode, 172, 22, 10, // 1309: decode to TLBGR_MM using decoder 10
1562 // 1309: }
1563 4, 6, // 1313: case 0x4: {
1564 OPC_CheckPredicate, 11, // 1315: check predicate 11
1565 OPC_Decode, 174, 22, 10, // 1317: decode to TLBGWI_MM using decoder 10
1566 // 1317: }
1567 6, 6, // 1321: case 0x6: {
1568 OPC_CheckPredicate, 11, // 1323: check predicate 11
1569 OPC_Decode, 176, 22, 10, // 1325: decode to TLBGWR_MM using decoder 10
1570 // 1325: }
1571 8, 6, // 1329: case 0x8: {
1572 OPC_CheckPredicate, 11, // 1331: check predicate 11
1573 OPC_Decode, 168, 22, 10, // 1333: decode to TLBGINV_MM using decoder 10
1574 // 1333: }
1575 10, 0, // 1337: case 0xa: {
1576 OPC_CheckPredicate, 11, // 1339: check predicate 11
1577 OPC_Decode, 167, 22, 10, // 1341: decode to TLBGINVF_MM using decoder 10
1578 // 1341: }
1579 // 1341: } // switch Inst[25:11]
1580 // 1341: }
1581 7, 19, // 1345: case 0x7: {
1582 OPC_SwitchField, 11, 2, // 1347: switch Inst[12:11] {
1583 0, 6, // 1350: case 0x0: {
1584 OPC_CheckPredicate, 10, // 1352: check predicate 10
1585 OPC_Decode, 170, 20, 80, // 1354: decode to SHRA_QB_MMR2 using decoder 80
1586 // 1354: }
1587 2, 0, // 1358: case 0x2: {
1588 OPC_CheckPredicate, 10, // 1360: check predicate 10
1589 OPC_Decode, 174, 20, 80, // 1362: decode to SHRA_R_QB_MMR2 using decoder 80
1590 // 1362: }
1591 // 1362: } // switch Inst[12:11]
1592 // 1362: }
1593 8, 19, // 1366: case 0x8: {
1594 OPC_SwitchField, 11, 1, // 1368: switch Inst[11] {
1595 0, 6, // 1371: case 0x0: {
1596 OPC_CheckPredicate, 2, // 1373: check predicate 2
1597 OPC_Decode, 164, 22, 77, // 1375: decode to TGE_MM using decoder 77
1598 // 1375: }
1599 1, 0, // 1379: case 0x1: {
1600 OPC_CheckPredicate, 2, // 1381: check predicate 2
1601 OPC_Decode, 194, 22, 77, // 1383: decode to TLTU_MM using decoder 77
1602 // 1383: }
1603 // 1383: } // switch Inst[11]
1604 // 1383: }
1605 9, 59, // 1387: case 0x9: {
1606 OPC_SwitchField, 11, 3, // 1389: switch Inst[13:11] {
1607 0, 10, // 1392: case 0x0: {
1608 OPC_CheckPredicate, 9, // 1394: check predicate 9
1609 OPC_CheckField, 21, 5, 0, // 1396: check Inst[25:21] == 0x0
1610 OPC_Decode, 207, 17, 89, // 1400: decode to MTHLIP_MM using decoder 89
1611 // 1400: }
1612 1, 6, // 1404: case 0x1: {
1613 OPC_CheckPredicate, 9, // 1406: check predicate 9
1614 OPC_Decode, 136, 16, 82, // 1408: decode to MAQ_S_W_PHR_MM using decoder 82
1615 // 1408: }
1616 2, 10, // 1412: case 0x2: {
1617 OPC_CheckPredicate, 9, // 1414: check predicate 9
1618 OPC_CheckField, 21, 5, 0, // 1416: check Inst[25:21] == 0x0
1619 OPC_Decode, 139, 20, 89, // 1420: decode to SHILOV_MM using decoder 89
1620 // 1420: }
1621 3, 6, // 1424: case 0x3: {
1622 OPC_CheckPredicate, 9, // 1426: check predicate 9
1623 OPC_Decode, 134, 16, 82, // 1428: decode to MAQ_S_W_PHL_MM using decoder 82
1624 // 1428: }
1625 5, 6, // 1432: case 0x5: {
1626 OPC_CheckPredicate, 9, // 1434: check predicate 9
1627 OPC_Decode, 132, 16, 82, // 1436: decode to MAQ_SA_W_PHR_MM using decoder 82
1628 // 1436: }
1629 7, 0, // 1440: case 0x7: {
1630 OPC_CheckPredicate, 9, // 1442: check predicate 9
1631 OPC_Decode, 130, 16, 82, // 1444: decode to MAQ_SA_W_PHL_MM using decoder 82
1632 // 1444: }
1633 // 1444: } // switch Inst[13:11]
1634 // 1444: }
1635 10, 67, // 1448: case 0xa: {
1636 OPC_SwitchField, 11, 3, // 1450: switch Inst[13:11] {
1637 0, 6, // 1453: case 0x0: {
1638 OPC_CheckPredicate, 9, // 1455: check predicate 9
1639 OPC_Decode, 244, 11, 82, // 1457: decode to DPAQ_S_W_PH_MM using decoder 82
1640 // 1457: }
1641 1, 6, // 1461: case 0x1: {
1642 OPC_CheckPredicate, 9, // 1463: check predicate 9
1643 OPC_Decode, 251, 15, 90, // 1465: decode to MADD_DSP_MM using decoder 90
1644 // 1465: }
1645 2, 6, // 1469: case 0x2: {
1646 OPC_CheckPredicate, 9, // 1471: check predicate 9
1647 OPC_Decode, 242, 11, 82, // 1473: decode to DPAQ_SA_L_W_MM using decoder 82
1648 // 1473: }
1649 3, 6, // 1477: case 0x3: {
1650 OPC_CheckPredicate, 9, // 1479: check predicate 9
1651 OPC_Decode, 241, 15, 90, // 1481: decode to MADDU_DSP_MM using decoder 90
1652 // 1481: }
1653 4, 6, // 1485: case 0x4: {
1654 OPC_CheckPredicate, 10, // 1487: check predicate 10
1655 OPC_Decode, 240, 11, 82, // 1489: decode to DPAQX_S_W_PH_MMR2 using decoder 82
1656 // 1489: }
1657 5, 6, // 1493: case 0x5: {
1658 OPC_CheckPredicate, 9, // 1495: check predicate 9
1659 OPC_Decode, 175, 17, 90, // 1497: decode to MSUB_DSP_MM using decoder 90
1660 // 1497: }
1661 6, 6, // 1501: case 0x6: {
1662 OPC_CheckPredicate, 10, // 1503: check predicate 10
1663 OPC_Decode, 238, 11, 82, // 1505: decode to DPAQX_SA_W_PH_MMR2 using decoder 82
1664 // 1505: }
1665 7, 0, // 1509: case 0x7: {
1666 OPC_CheckPredicate, 9, // 1511: check predicate 9
1667 OPC_Decode, 165, 17, 90, // 1513: decode to MSUBU_DSP_MM using decoder 90
1668 // 1513: }
1669 // 1513: } // switch Inst[13:11]
1670 // 1513: }
1671 11, 10, // 1517: case 0xb: {
1672 OPC_CheckPredicate, 1, // 1519: check predicate 1
1673 OPC_CheckField, 14, 2, 0, // 1521: check Inst[15:14] == 0x0
1674 OPC_Decode, 182, 17, 75, // 1525: decode to MTC0_MM using decoder 75
1675 // 1525: }
1676 12, 163, 1, // 1529: case 0xc: {
1677 OPC_SwitchField, 11, 5, // 1532: switch Inst[15:11] {
1678 0, 6, // 1535: case 0x0: {
1679 OPC_CheckPredicate, 9, // 1537: check predicate 9
1680 OPC_Decode, 146, 19, 91, // 1539: decode to REPLV_PH_MM using decoder 91
1681 // 1539: }
1682 2, 6, // 1543: case 0x2: {
1683 OPC_CheckPredicate, 9, // 1545: check predicate 9
1684 OPC_Decode, 148, 19, 91, // 1547: decode to REPLV_QB_MM using decoder 91
1685 // 1547: }
1686 5, 6, // 1551: case 0x5: {
1687 OPC_CheckPredicate, 2, // 1553: check predicate 2
1688 OPC_Decode, 232, 19, 86, // 1555: decode to SEB_MM using decoder 86
1689 // 1555: }
1690 7, 6, // 1559: case 0x7: {
1691 OPC_CheckPredicate, 2, // 1561: check predicate 2
1692 OPC_Decode, 235, 19, 86, // 1563: decode to SEH_MM using decoder 86
1693 // 1563: }
1694 9, 6, // 1567: case 0x9: {
1695 OPC_CheckPredicate, 2, // 1569: check predicate 2
1696 OPC_Decode, 153, 9, 86, // 1571: decode to CLO_MM using decoder 86
1697 // 1571: }
1698 11, 6, // 1575: case 0xb: {
1699 OPC_CheckPredicate, 2, // 1577: check predicate 2
1700 OPC_Decode, 173, 9, 86, // 1579: decode to CLZ_MM using decoder 86
1701 // 1579: }
1702 13, 6, // 1583: case 0xd: {
1703 OPC_CheckPredicate, 1, // 1585: check predicate 1
1704 OPC_Decode, 136, 19, 92, // 1587: decode to RDHWR_MM using decoder 92
1705 // 1587: }
1706 14, 6, // 1591: case 0xe: {
1707 OPC_CheckPredicate, 9, // 1593: check predicate 9
1708 OPC_Decode, 215, 18, 85, // 1595: decode to PRECEQU_PH_QBLA_MM using decoder 85
1709 // 1595: }
1710 15, 6, // 1599: case 0xf: {
1711 OPC_CheckPredicate, 2, // 1601: check predicate 2
1712 OPC_Decode, 228, 22, 86, // 1603: decode to WSBH_MM using decoder 86
1713 // 1603: }
1714 17, 6, // 1607: case 0x11: {
1715 OPC_CheckPredicate, 1, // 1609: check predicate 1
1716 OPC_Decode, 253, 17, 93, // 1611: decode to MULT_MM using decoder 93
1717 // 1611: }
1718 18, 6, // 1615: case 0x12: {
1719 OPC_CheckPredicate, 9, // 1617: check predicate 9
1720 OPC_Decode, 219, 18, 85, // 1619: decode to PRECEQU_PH_QBRA_MM using decoder 85
1721 // 1619: }
1722 19, 6, // 1623: case 0x13: {
1723 OPC_CheckPredicate, 1, // 1625: check predicate 1
1724 OPC_Decode, 255, 17, 93, // 1627: decode to MULTu_MM using decoder 93
1725 // 1627: }
1726 21, 6, // 1631: case 0x15: {
1727 OPC_CheckPredicate, 1, // 1633: check predicate 1
1728 OPC_Decode, 225, 19, 93, // 1635: decode to SDIV_MM using decoder 93
1729 // 1635: }
1730 22, 6, // 1639: case 0x16: {
1731 OPC_CheckPredicate, 9, // 1641: check predicate 9
1732 OPC_Decode, 227, 18, 85, // 1643: decode to PRECEU_PH_QBLA_MM using decoder 85
1733 // 1643: }
1734 23, 6, // 1647: case 0x17: {
1735 OPC_CheckPredicate, 1, // 1649: check predicate 1
1736 OPC_Decode, 213, 22, 93, // 1651: decode to UDIV_MM using decoder 93
1737 // 1651: }
1738 25, 6, // 1655: case 0x19: {
1739 OPC_CheckPredicate, 1, // 1657: check predicate 1
1740 OPC_Decode, 252, 15, 93, // 1659: decode to MADD_MM using decoder 93
1741 // 1659: }
1742 26, 6, // 1663: case 0x1a: {
1743 OPC_CheckPredicate, 9, // 1665: check predicate 9
1744 OPC_Decode, 231, 18, 85, // 1667: decode to PRECEU_PH_QBRA_MM using decoder 85
1745 // 1667: }
1746 27, 6, // 1671: case 0x1b: {
1747 OPC_CheckPredicate, 1, // 1673: check predicate 1
1748 OPC_Decode, 242, 15, 93, // 1675: decode to MADDU_MM using decoder 93
1749 // 1675: }
1750 29, 6, // 1679: case 0x1d: {
1751 OPC_CheckPredicate, 1, // 1681: check predicate 1
1752 OPC_Decode, 176, 17, 93, // 1683: decode to MSUB_MM using decoder 93
1753 // 1683: }
1754 31, 0, // 1687: case 0x1f: {
1755 OPC_CheckPredicate, 1, // 1689: check predicate 1
1756 OPC_Decode, 166, 17, 93, // 1691: decode to MSUBU_MM using decoder 93
1757 // 1691: }
1758 // 1691: } // switch Inst[15:11]
1759 // 1691: }
1760 13, 119, // 1695: case 0xd: {
1761 OPC_SwitchField, 11, 5, // 1697: switch Inst[15:11] {
1762 0, 10, // 1700: case 0x0: {
1763 OPC_CheckPredicate, 2, // 1702: check predicate 2
1764 OPC_CheckField, 16, 10, 0, // 1704: check Inst[25:16] == 0x0
1765 OPC_Decode, 182, 22, 10, // 1708: decode to TLBP_MM using decoder 10
1766 // 1708: }
1767 2, 10, // 1712: case 0x2: {
1768 OPC_CheckPredicate, 2, // 1714: check predicate 2
1769 OPC_CheckField, 16, 10, 0, // 1716: check Inst[25:16] == 0x0
1770 OPC_Decode, 184, 22, 10, // 1720: decode to TLBR_MM using decoder 10
1771 // 1720: }
1772 4, 10, // 1724: case 0x4: {
1773 OPC_CheckPredicate, 2, // 1726: check predicate 2
1774 OPC_CheckField, 16, 10, 0, // 1728: check Inst[25:16] == 0x0
1775 OPC_Decode, 186, 22, 10, // 1732: decode to TLBWI_MM using decoder 10
1776 // 1732: }
1777 6, 10, // 1736: case 0x6: {
1778 OPC_CheckPredicate, 2, // 1738: check predicate 2
1779 OPC_CheckField, 16, 10, 0, // 1740: check Inst[25:16] == 0x0
1780 OPC_Decode, 188, 22, 10, // 1744: decode to TLBWR_MM using decoder 10
1781 // 1744: }
1782 13, 10, // 1748: case 0xd: {
1783 OPC_CheckPredicate, 2, // 1750: check predicate 2
1784 OPC_CheckField, 21, 5, 0, // 1752: check Inst[25:21] == 0x0
1785 OPC_Decode, 128, 22, 94, // 1756: decode to SYNC_MM using decoder 94
1786 // 1756: }
1787 17, 6, // 1760: case 0x11: {
1788 OPC_CheckPredicate, 2, // 1762: check predicate 2
1789 OPC_Decode, 131, 22, 95, // 1764: decode to SYSCALL_MM using decoder 95
1790 // 1764: }
1791 18, 6, // 1768: case 0x12: {
1792 OPC_CheckPredicate, 2, // 1770: check predicate 2
1793 OPC_Decode, 222, 22, 95, // 1772: decode to WAIT_MM using decoder 95
1794 // 1772: }
1795 24, 6, // 1776: case 0x18: {
1796 OPC_CheckPredicate, 11, // 1778: check predicate 11
1797 OPC_Decode, 158, 14, 95, // 1780: decode to HYPCALL_MM using decoder 95
1798 // 1780: }
1799 27, 6, // 1784: case 0x1b: {
1800 OPC_CheckPredicate, 2, // 1786: check predicate 2
1801 OPC_Decode, 212, 19, 95, // 1788: decode to SDBBP_MM using decoder 95
1802 // 1788: }
1803 28, 10, // 1792: case 0x1c: {
1804 OPC_CheckPredicate, 2, // 1794: check predicate 2
1805 OPC_CheckField, 16, 10, 0, // 1796: check Inst[25:16] == 0x0
1806 OPC_Decode, 179, 11, 10, // 1800: decode to DERET_MM using decoder 10
1807 // 1800: }
1808 30, 0, // 1804: case 0x1e: {
1809 OPC_CheckPredicate, 2, // 1806: check predicate 2
1810 OPC_CheckField, 16, 10, 0, // 1808: check Inst[25:16] == 0x0
1811 OPC_Decode, 182, 12, 10, // 1812: decode to ERET_MM using decoder 10
1812 // 1812: }
1813 // 1812: } // switch Inst[15:11]
1814 // 1812: }
1815 15, 10, // 1816: case 0xf: {
1816 OPC_CheckPredicate, 10, // 1818: check predicate 10
1817 OPC_CheckField, 11, 1, 0, // 1820: check Inst[11] == 0x0
1818 OPC_Decode, 182, 20, 76, // 1824: decode to SHRL_PH_MMR2 using decoder 76
1819 // 1824: }
1820 16, 19, // 1828: case 0x10: {
1821 OPC_SwitchField, 11, 1, // 1830: switch Inst[11] {
1822 0, 6, // 1833: case 0x0: {
1823 OPC_CheckPredicate, 2, // 1835: check predicate 2
1824 OPC_Decode, 163, 22, 77, // 1837: decode to TGEU_MM using decoder 77
1825 // 1837: }
1826 1, 0, // 1841: case 0x1: {
1827 OPC_CheckPredicate, 2, // 1843: check predicate 2
1828 OPC_Decode, 199, 22, 77, // 1845: decode to TNE_MM using decoder 77
1829 // 1845: }
1830 // 1845: } // switch Inst[11]
1831 // 1845: }
1832 18, 67, // 1849: case 0x12: {
1833 OPC_SwitchField, 11, 3, // 1851: switch Inst[13:11] {
1834 0, 6, // 1854: case 0x0: {
1835 OPC_CheckPredicate, 10, // 1856: check predicate 10
1836 OPC_Decode, 147, 12, 82, // 1858: decode to DPS_W_PH_MMR2 using decoder 82
1837 // 1858: }
1838 1, 6, // 1862: case 0x1: {
1839 OPC_CheckPredicate, 9, // 1864: check predicate 9
1840 OPC_Decode, 252, 17, 96, // 1866: decode to MULT_DSP_MM using decoder 96
1841 // 1866: }
1842 2, 6, // 1870: case 0x2: {
1843 OPC_CheckPredicate, 10, // 1872: check predicate 10
1844 OPC_Decode, 145, 12, 82, // 1874: decode to DPSX_W_PH_MMR2 using decoder 82
1845 // 1874: }
1846 3, 6, // 1878: case 0x3: {
1847 OPC_CheckPredicate, 9, // 1880: check predicate 9
1848 OPC_Decode, 250, 17, 96, // 1882: decode to MULTU_DSP_MM using decoder 96
1849 // 1882: }
1850 4, 6, // 1886: case 0x4: {
1851 OPC_CheckPredicate, 9, // 1888: check predicate 9
1852 OPC_Decode, 141, 12, 82, // 1890: decode to DPSU_H_QBL_MM using decoder 82
1853 // 1890: }
1854 5, 6, // 1894: case 0x5: {
1855 OPC_CheckPredicate, 10, // 1896: check predicate 10
1856 OPC_Decode, 247, 17, 82, // 1898: decode to MULSA_W_PH_MMR2 using decoder 82
1857 // 1898: }
1858 6, 6, // 1902: case 0x6: {
1859 OPC_CheckPredicate, 9, // 1904: check predicate 9
1860 OPC_Decode, 143, 12, 82, // 1906: decode to DPSU_H_QBR_MM using decoder 82
1861 // 1906: }
1862 7, 0, // 1910: case 0x7: {
1863 OPC_CheckPredicate, 9, // 1912: check predicate 9
1864 OPC_Decode, 245, 17, 82, // 1914: decode to MULSAQ_S_W_PH_MM using decoder 82
1865 // 1914: }
1866 // 1914: } // switch Inst[13:11]
1867 // 1914: }
1868 19, 10, // 1918: case 0x13: {
1869 OPC_CheckPredicate, 11, // 1920: check predicate 11
1870 OPC_CheckField, 14, 2, 0, // 1922: check Inst[15:14] == 0x0
1871 OPC_Decode, 175, 16, 74, // 1926: decode to MFGC0_MM using decoder 74
1872 // 1926: }
1873 20, 19, // 1930: case 0x14: {
1874 OPC_SwitchField, 11, 5, // 1932: switch Inst[15:11] {
1875 25, 6, // 1935: case 0x19: {
1876 OPC_CheckPredicate, 2, // 1937: check predicate 2
1877 OPC_Decode, 254, 8, 97, // 1939: decode to CFC2_MM using decoder 97
1878 // 1939: }
1879 27, 0, // 1943: case 0x1b: {
1880 OPC_CheckPredicate, 2, // 1945: check predicate 2
1881 OPC_Decode, 153, 10, 98, // 1947: decode to CTC2_MM using decoder 98
1882 // 1947: }
1883 // 1947: } // switch Inst[15:11]
1884 // 1947: }
1885 21, 51, // 1951: case 0x15: {
1886 OPC_SwitchField, 11, 5, // 1953: switch Inst[15:11] {
1887 1, 10, // 1956: case 0x1: {
1888 OPC_CheckPredicate, 1, // 1958: check predicate 1
1889 OPC_CheckField, 21, 5, 0, // 1960: check Inst[25:21] == 0x0
1890 OPC_Decode, 189, 16, 99, // 1964: decode to MFHI_MM using decoder 99
1891 // 1964: }
1892 3, 10, // 1968: case 0x3: {
1893 OPC_CheckPredicate, 1, // 1970: check predicate 1
1894 OPC_CheckField, 21, 5, 0, // 1972: check Inst[25:21] == 0x0
1895 OPC_Decode, 195, 16, 99, // 1976: decode to MFLO_MM using decoder 99
1896 // 1976: }
1897 5, 10, // 1980: case 0x5: {
1898 OPC_CheckPredicate, 1, // 1982: check predicate 1
1899 OPC_CheckField, 21, 5, 0, // 1984: check Inst[25:21] == 0x0
1900 OPC_Decode, 205, 17, 99, // 1988: decode to MTHI_MM using decoder 99
1901 // 1988: }
1902 7, 0, // 1992: case 0x7: {
1903 OPC_CheckPredicate, 1, // 1994: check predicate 1
1904 OPC_CheckField, 21, 5, 0, // 1996: check Inst[25:21] == 0x0
1905 OPC_Decode, 212, 17, 99, // 2000: decode to MTLO_MM using decoder 99
1906 // 2000: }
1907 // 2000: } // switch Inst[15:11]
1908 // 2000: }
1909 23, 10, // 2004: case 0x17: {
1910 OPC_CheckPredicate, 9, // 2006: check predicate 9
1911 OPC_CheckField, 11, 2, 0, // 2008: check Inst[12:11] == 0x0
1912 OPC_Decode, 152, 19, 100, // 2012: decode to REPL_QB_MM using decoder 100
1913 // 2012: }
1914 25, 67, // 2016: case 0x19: {
1915 OPC_SwitchField, 11, 3, // 2018: switch Inst[13:11] {
1916 0, 6, // 2021: case 0x0: {
1917 OPC_CheckPredicate, 9, // 2023: check predicate 9
1918 OPC_Decode, 133, 19, 101, // 2025: decode to RDDSP_MM using decoder 101
1919 // 2025: }
1920 1, 6, // 2029: case 0x1: {
1921 OPC_CheckPredicate, 9, // 2031: check predicate 9
1922 OPC_Decode, 211, 12, 102, // 2033: decode to EXTR_W_MM using decoder 102
1923 // 2033: }
1924 2, 6, // 2037: case 0x2: {
1925 OPC_CheckPredicate, 9, // 2039: check predicate 9
1926 OPC_Decode, 225, 22, 101, // 2041: decode to WRDSP_MM using decoder 101
1927 // 2041: }
1928 3, 6, // 2045: case 0x3: {
1929 OPC_CheckPredicate, 9, // 2047: check predicate 9
1930 OPC_Decode, 207, 12, 102, // 2049: decode to EXTR_R_W_MM using decoder 102
1931 // 2049: }
1932 4, 6, // 2053: case 0x4: {
1933 OPC_CheckPredicate, 9, // 2055: check predicate 9
1934 OPC_Decode, 195, 12, 102, // 2057: decode to EXTP_MM using decoder 102
1935 // 2057: }
1936 5, 6, // 2061: case 0x5: {
1937 OPC_CheckPredicate, 9, // 2063: check predicate 9
1938 OPC_Decode, 205, 12, 102, // 2065: decode to EXTR_RS_W_MM using decoder 102
1939 // 2065: }
1940 6, 6, // 2069: case 0x6: {
1941 OPC_CheckPredicate, 9, // 2071: check predicate 9
1942 OPC_Decode, 192, 12, 102, // 2073: decode to EXTPDP_MM using decoder 102
1943 // 2073: }
1944 7, 0, // 2077: case 0x7: {
1945 OPC_CheckPredicate, 9, // 2079: check predicate 9
1946 OPC_Decode, 209, 12, 102, // 2081: decode to EXTR_S_H_MM using decoder 102
1947 // 2081: }
1948 // 2081: } // switch Inst[13:11]
1949 // 2081: }
1950 26, 67, // 2085: case 0x1a: {
1951 OPC_SwitchField, 11, 3, // 2087: switch Inst[13:11] {
1952 0, 6, // 2090: case 0x0: {
1953 OPC_CheckPredicate, 9, // 2092: check predicate 9
1954 OPC_Decode, 133, 12, 82, // 2094: decode to DPSQ_S_W_PH_MM using decoder 82
1955 // 2094: }
1956 1, 6, // 2098: case 0x1: {
1957 OPC_CheckPredicate, 9, // 2100: check predicate 9
1958 OPC_Decode, 203, 12, 84, // 2102: decode to EXTRV_W_MM using decoder 84
1959 // 2102: }
1960 2, 6, // 2106: case 0x2: {
1961 OPC_CheckPredicate, 9, // 2108: check predicate 9
1962 OPC_Decode, 131, 12, 82, // 2110: decode to DPSQ_SA_L_W_MM using decoder 82
1963 // 2110: }
1964 3, 6, // 2114: case 0x3: {
1965 OPC_CheckPredicate, 9, // 2116: check predicate 9
1966 OPC_Decode, 199, 12, 84, // 2118: decode to EXTRV_R_W_MM using decoder 84
1967 // 2118: }
1968 4, 6, // 2122: case 0x4: {
1969 OPC_CheckPredicate, 10, // 2124: check predicate 10
1970 OPC_Decode, 129, 12, 82, // 2126: decode to DPSQX_S_W_PH_MMR2 using decoder 82
1971 // 2126: }
1972 5, 6, // 2130: case 0x5: {
1973 OPC_CheckPredicate, 9, // 2132: check predicate 9
1974 OPC_Decode, 197, 12, 84, // 2134: decode to EXTRV_RS_W_MM using decoder 84
1975 // 2134: }
1976 6, 6, // 2138: case 0x6: {
1977 OPC_CheckPredicate, 10, // 2140: check predicate 10
1978 OPC_Decode, 255, 11, 82, // 2142: decode to DPSQX_SA_W_PH_MMR2 using decoder 82
1979 // 2142: }
1980 7, 0, // 2146: case 0x7: {
1981 OPC_CheckPredicate, 9, // 2148: check predicate 9
1982 OPC_Decode, 201, 12, 84, // 2150: decode to EXTRV_S_H_MM using decoder 84
1983 // 2150: }
1984 // 2150: } // switch Inst[13:11]
1985 // 2150: }
1986 27, 10, // 2154: case 0x1b: {
1987 OPC_CheckPredicate, 11, // 2156: check predicate 11
1988 OPC_CheckField, 14, 2, 0, // 2158: check Inst[15:14] == 0x0
1989 OPC_Decode, 192, 17, 75, // 2162: decode to MTGC0_MM using decoder 75
1990 // 2162: }
1991 28, 51, // 2166: case 0x1c: {
1992 OPC_SwitchField, 11, 5, // 2168: switch Inst[15:11] {
1993 1, 18, // 2171: case 0x1: {
1994 OPC_Scope, 10, // 2173: try {
1995 OPC_CheckField, 21, 5, 0, // 2175: check Inst[25:21] == 0x0
1996 OPC_CheckPredicate, 1, // 2179: check predicate 1
1997 OPC_Decode, 224, 14, 99, // 2181: decode to JR_MM using decoder 99
1998 // 2181: } else try {
1999 OPC_CheckPredicate, 1, // 2185: check predicate 1
2000 OPC_Decode, 201, 14, 86, // 2187: decode to JALR_MM using decoder 86
2001 // 2187: }
2002 // 2187: }
2003 3, 18, // 2191: case 0x3: {
2004 OPC_Scope, 10, // 2193: try {
2005 OPC_CheckField, 21, 5, 0, // 2195: check Inst[25:21] == 0x0
2006 OPC_CheckPredicate, 1, // 2199: check predicate 1
2007 OPC_Decode, 222, 14, 99, // 2201: decode to JR_HB_MM using decoder 99
2008 // 2201: } else try {
2009 OPC_CheckPredicate, 1, // 2205: check predicate 1
2010 OPC_Decode, 200, 14, 86, // 2207: decode to JALR_HB_MM using decoder 86
2011 // 2207: }
2012 // 2207: }
2013 9, 0, // 2211: case 0x9: {
2014 OPC_CheckPredicate, 1, // 2213: check predicate 1
2015 OPC_Decode, 197, 14, 86, // 2215: decode to JALRS_MM using decoder 86
2016 // 2215: }
2017 // 2215: } // switch Inst[15:11]
2018 // 2215: }
2019 29, 0, // 2219: case 0x1d: {
2020 OPC_SwitchField, 11, 5, // 2221: switch Inst[15:11] {
2021 8, 10, // 2224: case 0x8: {
2022 OPC_CheckPredicate, 2, // 2226: check predicate 2
2023 OPC_CheckField, 21, 5, 0, // 2228: check Inst[25:21] == 0x0
2024 OPC_Decode, 201, 11, 99, // 2232: decode to DI_MM using decoder 99
2025 // 2232: }
2026 10, 0, // 2236: case 0xa: {
2027 OPC_CheckPredicate, 2, // 2238: check predicate 2
2028 OPC_CheckField, 21, 5, 0, // 2240: check Inst[25:21] == 0x0
2029 OPC_Decode, 176, 12, 99, // 2244: decode to EI_MM using decoder 99
2030 // 2244: }
2031 // 2244: } // switch Inst[15:11]
2032 // 2244: }
2033 // 2244: } // switch Inst[10:6]
2034 // 2244: }
2035 61, 0, // 2248: case 0x3d: {
2036 OPC_CheckPredicate, 9, // 2250: check predicate 9
2037 OPC_CheckField, 6, 5, 0, // 2252: check Inst[10:6] == 0x0
2038 OPC_Decode, 150, 19, 103, // 2256: decode to REPL_PH_MM using decoder 103
2039 // 2256: }
2040 // 2256: } // switch Inst[5:0]
2041 // 2256: }
2042 4, 6, // 2260: case 0x4: {
2043 OPC_CheckPredicate, 1, // 2262: check predicate 1
2044 OPC_Decode, 224, 6, 104, // 2264: decode to ADDi_MM using decoder 104
2045 // 2264: }
2046 5, 6, // 2268: case 0x5: {
2047 OPC_CheckPredicate, 2, // 2270: check predicate 2
2048 OPC_Decode, 246, 14, 105, // 2272: decode to LBu_MM using decoder 105
2049 // 2272: }
2050 6, 6, // 2276: case 0x6: {
2051 OPC_CheckPredicate, 2, // 2278: check predicate 2
2052 OPC_Decode, 196, 19, 105, // 2280: decode to SB_MM using decoder 105
2053 // 2280: }
2054 7, 6, // 2284: case 0x7: {
2055 OPC_CheckPredicate, 2, // 2286: check predicate 2
2056 OPC_Decode, 240, 14, 105, // 2288: decode to LB_MM using decoder 105
2057 // 2288: }
2058 8, 43, // 2292: case 0x8: {
2059 OPC_SwitchField, 12, 4, // 2294: switch Inst[15:12] {
2060 1, 6, // 2297: case 0x1: {
2061 OPC_CheckPredicate, 2, // 2299: check predicate 2
2062 OPC_Decode, 204, 15, 106, // 2301: decode to LWP_MM using decoder 106
2063 // 2301: }
2064 5, 6, // 2305: case 0x5: {
2065 OPC_CheckPredicate, 2, // 2307: check predicate 2
2066 OPC_Decode, 201, 15, 106, // 2309: decode to LWM32_MM using decoder 106
2067 // 2309: }
2068 6, 6, // 2313: case 0x6: {
2069 OPC_CheckPredicate, 1, // 2315: check predicate 1
2070 OPC_Decode, 230, 8, 107, // 2317: decode to CACHE_MM using decoder 107
2071 // 2317: }
2072 9, 6, // 2321: case 0x9: {
2073 OPC_CheckPredicate, 2, // 2323: check predicate 2
2074 OPC_Decode, 240, 21, 106, // 2325: decode to SWP_MM using decoder 106
2075 // 2325: }
2076 13, 0, // 2329: case 0xd: {
2077 OPC_CheckPredicate, 2, // 2331: check predicate 2
2078 OPC_Decode, 239, 21, 106, // 2333: decode to SWM32_MM using decoder 106
2079 // 2333: }
2080 // 2333: } // switch Inst[15:12]
2081 // 2333: }
2082 12, 6, // 2337: case 0xc: {
2083 OPC_CheckPredicate, 1, // 2339: check predicate 1
2084 OPC_Decode, 226, 6, 104, // 2341: decode to ADDiu_MM using decoder 104
2085 // 2341: }
2086 13, 6, // 2345: case 0xd: {
2087 OPC_CheckPredicate, 2, // 2347: check predicate 2
2088 OPC_Decode, 157, 15, 105, // 2349: decode to LHu_MM using decoder 105
2089 // 2349: }
2090 14, 6, // 2353: case 0xe: {
2091 OPC_CheckPredicate, 2, // 2355: check predicate 2
2092 OPC_Decode, 185, 20, 105, // 2357: decode to SH_MM using decoder 105
2093 // 2357: }
2094 15, 6, // 2361: case 0xf: {
2095 OPC_CheckPredicate, 2, // 2363: check predicate 2
2096 OPC_Decode, 152, 15, 105, // 2365: decode to LH_MM using decoder 105
2097 // 2365: }
2098 16, 195, 1, // 2369: case 0x10: {
2099 OPC_SwitchField, 21, 5, // 2372: switch Inst[25:21] {
2100 0, 6, // 2375: case 0x0: {
2101 OPC_CheckPredicate, 1, // 2377: check predicate 1
2102 OPC_Decode, 156, 8, 108, // 2379: decode to BLTZ_MM using decoder 108
2103 // 2379: }
2104 1, 6, // 2383: case 0x1: {
2105 OPC_CheckPredicate, 1, // 2385: check predicate 1
2106 OPC_Decode, 151, 8, 108, // 2387: decode to BLTZAL_MM using decoder 108
2107 // 2387: }
2108 2, 6, // 2391: case 0x2: {
2109 OPC_CheckPredicate, 1, // 2393: check predicate 1
2110 OPC_Decode, 227, 7, 108, // 2395: decode to BGEZ_MM using decoder 108
2111 // 2395: }
2112 3, 6, // 2399: case 0x3: {
2113 OPC_CheckPredicate, 1, // 2401: check predicate 1
2114 OPC_Decode, 222, 7, 108, // 2403: decode to BGEZAL_MM using decoder 108
2115 // 2403: }
2116 4, 6, // 2407: case 0x4: {
2117 OPC_CheckPredicate, 1, // 2409: check predicate 1
2118 OPC_Decode, 137, 8, 108, // 2411: decode to BLEZ_MM using decoder 108
2119 // 2411: }
2120 5, 6, // 2415: case 0x5: {
2121 OPC_CheckPredicate, 1, // 2417: check predicate 1
2122 OPC_Decode, 181, 8, 108, // 2419: decode to BNEZC_MM using decoder 108
2123 // 2419: }
2124 6, 6, // 2423: case 0x6: {
2125 OPC_CheckPredicate, 1, // 2425: check predicate 1
2126 OPC_Decode, 236, 7, 108, // 2427: decode to BGTZ_MM using decoder 108
2127 // 2427: }
2128 7, 6, // 2431: case 0x7: {
2129 OPC_CheckPredicate, 1, // 2433: check predicate 1
2130 OPC_Decode, 206, 7, 108, // 2435: decode to BEQZC_MM using decoder 108
2131 // 2435: }
2132 8, 6, // 2439: case 0x8: {
2133 OPC_CheckPredicate, 1, // 2441: check predicate 1
2134 OPC_Decode, 192, 22, 109, // 2443: decode to TLTI_MM using decoder 109
2135 // 2443: }
2136 9, 6, // 2447: case 0x9: {
2137 OPC_CheckPredicate, 1, // 2449: check predicate 1
2138 OPC_Decode, 161, 22, 109, // 2451: decode to TGEI_MM using decoder 109
2139 // 2451: }
2140 10, 6, // 2455: case 0xa: {
2141 OPC_CheckPredicate, 1, // 2457: check predicate 1
2142 OPC_Decode, 191, 22, 109, // 2459: decode to TLTIU_MM using decoder 109
2143 // 2459: }
2144 11, 6, // 2463: case 0xb: {
2145 OPC_CheckPredicate, 1, // 2465: check predicate 1
2146 OPC_Decode, 160, 22, 109, // 2467: decode to TGEIU_MM using decoder 109
2147 // 2467: }
2148 12, 6, // 2471: case 0xc: {
2149 OPC_CheckPredicate, 1, // 2473: check predicate 1
2150 OPC_Decode, 198, 22, 109, // 2475: decode to TNEI_MM using decoder 109
2151 // 2475: }
2152 13, 6, // 2479: case 0xd: {
2153 OPC_CheckPredicate, 1, // 2481: check predicate 1
2154 OPC_Decode, 179, 15, 110, // 2483: decode to LUi_MM using decoder 110
2155 // 2483: }
2156 14, 6, // 2487: case 0xe: {
2157 OPC_CheckPredicate, 1, // 2489: check predicate 1
2158 OPC_Decode, 155, 22, 109, // 2491: decode to TEQI_MM using decoder 109
2159 // 2491: }
2160 16, 6, // 2495: case 0x10: {
2161 OPC_CheckPredicate, 1, // 2497: check predicate 1
2162 OPC_Decode, 254, 21, 111, // 2499: decode to SYNCI_MM using decoder 111
2163 // 2499: }
2164 17, 6, // 2503: case 0x11: {
2165 OPC_CheckPredicate, 1, // 2505: check predicate 1
2166 OPC_Decode, 150, 8, 108, // 2507: decode to BLTZALS_MM using decoder 108
2167 // 2507: }
2168 19, 6, // 2511: case 0x13: {
2169 OPC_CheckPredicate, 1, // 2513: check predicate 1
2170 OPC_Decode, 221, 7, 108, // 2515: decode to BGEZALS_MM using decoder 108
2171 // 2515: }
2172 25, 10, // 2519: case 0x19: {
2173 OPC_CheckPredicate, 12, // 2521: check predicate 12
2174 OPC_CheckField, 16, 5, 0, // 2523: check Inst[20:16] == 0x0
2175 OPC_Decode, 194, 8, 112, // 2527: decode to BPOSGE32C_MMR3 using decoder 112
2176 // 2527: }
2177 27, 10, // 2531: case 0x1b: {
2178 OPC_CheckPredicate, 13, // 2533: check predicate 13
2179 OPC_CheckField, 16, 5, 0, // 2535: check Inst[20:16] == 0x0
2180 OPC_Decode, 195, 8, 113, // 2539: decode to BPOSGE32_MM using decoder 113
2181 // 2539: }
2182 28, 10, // 2543: case 0x1c: {
2183 OPC_CheckPredicate, 14, // 2545: check predicate 14
2184 OPC_CheckField, 16, 2, 0, // 2547: check Inst[17:16] == 0x0
2185 OPC_Decode, 175, 7, 114, // 2551: decode to BC1F_MM using decoder 114
2186 // 2551: }
2187 29, 0, // 2555: case 0x1d: {
2188 OPC_CheckPredicate, 14, // 2557: check predicate 14
2189 OPC_CheckField, 16, 2, 0, // 2559: check Inst[17:16] == 0x0
2190 OPC_Decode, 180, 7, 114, // 2563: decode to BC1T_MM using decoder 114
2191 // 2563: }
2192 // 2563: } // switch Inst[25:21]
2193 // 2563: }
2194 20, 6, // 2567: case 0x14: {
2195 OPC_CheckPredicate, 1, // 2569: check predicate 1
2196 OPC_Decode, 187, 18, 115, // 2571: decode to ORi_MM using decoder 115
2197 // 2571: }
2198 21, 145, 7, // 2575: case 0x15: {
2199 OPC_SwitchField, 0, 6, // 2578: switch Inst[5:0] {
2200 1, 6, // 2581: case 0x1: {
2201 OPC_CheckPredicate, 15, // 2583: check predicate 15
2202 OPC_Decode, 128, 16, 116, // 2585: decode to MADD_S_MM using decoder 116
2203 // 2585: }
2204 2, 6, // 2589: case 0x2: {
2205 OPC_CheckPredicate, 15, // 2591: check predicate 15
2206 OPC_Decode, 160, 18, 116, // 2593: decode to NMADD_S_MM using decoder 116
2207 // 2593: }
2208 8, 35, // 2597: case 0x8: {
2209 OPC_SwitchField, 6, 5, // 2599: switch Inst[10:6] {
2210 1, 6, // 2602: case 0x1: {
2211 OPC_CheckPredicate, 14, // 2604: check predicate 14
2212 OPC_Decode, 215, 15, 117, // 2606: decode to LWXC1_MM using decoder 117
2213 // 2606: }
2214 2, 6, // 2610: case 0x2: {
2215 OPC_CheckPredicate, 14, // 2612: check predicate 14
2216 OPC_Decode, 249, 21, 117, // 2614: decode to SWXC1_MM using decoder 117
2217 // 2614: }
2218 5, 6, // 2618: case 0x5: {
2219 OPC_CheckPredicate, 16, // 2620: check predicate 16
2220 OPC_Decode, 176, 15, 118, // 2622: decode to LUXC1_MM using decoder 118
2221 // 2622: }
2222 6, 0, // 2626: case 0x6: {
2223 OPC_CheckPredicate, 16, // 2628: check predicate 16
2224 OPC_Decode, 217, 21, 118, // 2630: decode to SUXC1_MM using decoder 118
2225 // 2630: }
2226 // 2630: } // switch Inst[10:6]
2227 // 2630: }
2228 9, 6, // 2634: case 0x9: {
2229 OPC_CheckPredicate, 17, // 2636: check predicate 17
2230 OPC_Decode, 248, 15, 119, // 2638: decode to MADD_D32_MM using decoder 119
2231 // 2638: }
2232 10, 6, // 2642: case 0xa: {
2233 OPC_CheckPredicate, 17, // 2644: check predicate 17
2234 OPC_Decode, 157, 18, 119, // 2646: decode to NMADD_D32_MM using decoder 119
2235 // 2646: }
2236 32, 59, // 2650: case 0x20: {
2237 OPC_SwitchField, 6, 5, // 2652: switch Inst[10:6] {
2238 0, 10, // 2655: case 0x0: {
2239 OPC_CheckPredicate, 14, // 2657: check predicate 14
2240 OPC_CheckField, 11, 2, 0, // 2659: check Inst[12:11] == 0x0
2241 OPC_Decode, 251, 16, 120, // 2663: decode to MOVF_S_MM using decoder 120
2242 // 2663: }
2243 1, 10, // 2667: case 0x1: {
2244 OPC_CheckPredicate, 14, // 2669: check predicate 14
2245 OPC_CheckField, 11, 2, 0, // 2671: check Inst[12:11] == 0x0
2246 OPC_Decode, 143, 17, 120, // 2675: decode to MOVT_S_MM using decoder 120
2247 // 2675: }
2248 6, 6, // 2679: case 0x6: {
2249 OPC_CheckPredicate, 1, // 2681: check predicate 1
2250 OPC_Decode, 250, 18, 121, // 2683: decode to PREFX_MM using decoder 121
2251 // 2683: }
2252 8, 10, // 2687: case 0x8: {
2253 OPC_CheckPredicate, 18, // 2689: check predicate 18
2254 OPC_CheckField, 11, 2, 0, // 2691: check Inst[12:11] == 0x0
2255 OPC_Decode, 245, 16, 122, // 2695: decode to MOVF_D32_MM using decoder 122
2256 // 2695: }
2257 9, 0, // 2699: case 0x9: {
2258 OPC_CheckPredicate, 18, // 2701: check predicate 18
2259 OPC_CheckField, 11, 2, 0, // 2703: check Inst[12:11] == 0x0
2260 OPC_Decode, 137, 17, 122, // 2707: decode to MOVT_D32_MM using decoder 122
2261 // 2707: }
2262 // 2707: } // switch Inst[10:6]
2263 // 2707: }
2264 33, 6, // 2711: case 0x21: {
2265 OPC_CheckPredicate, 15, // 2713: check predicate 15
2266 OPC_Decode, 180, 17, 116, // 2715: decode to MSUB_S_MM using decoder 116
2267 // 2715: }
2268 34, 6, // 2719: case 0x22: {
2269 OPC_CheckPredicate, 15, // 2721: check predicate 15
2270 OPC_Decode, 165, 18, 116, // 2723: decode to NMSUB_S_MM using decoder 116
2271 // 2723: }
2272 41, 6, // 2727: case 0x29: {
2273 OPC_CheckPredicate, 17, // 2729: check predicate 17
2274 OPC_Decode, 172, 17, 119, // 2731: decode to MSUB_D32_MM using decoder 119
2275 // 2731: }
2276 42, 6, // 2735: case 0x2a: {
2277 OPC_CheckPredicate, 17, // 2737: check predicate 17
2278 OPC_Decode, 162, 18, 119, // 2739: decode to NMSUB_D32_MM using decoder 119
2279 // 2739: }
2280 48, 35, // 2743: case 0x30: {
2281 OPC_SwitchField, 6, 5, // 2745: switch Inst[10:6] {
2282 4, 6, // 2748: case 0x4: {
2283 OPC_CheckPredicate, 19, // 2750: check predicate 19
2284 OPC_Decode, 224, 12, 123, // 2752: decode to FADD_D32_MM using decoder 123
2285 // 2752: }
2286 5, 6, // 2756: case 0x5: {
2287 OPC_CheckPredicate, 19, // 2758: check predicate 19
2288 OPC_Decode, 241, 13, 123, // 2760: decode to FSUB_D32_MM using decoder 123
2289 // 2760: }
2290 6, 6, // 2764: case 0x6: {
2291 OPC_CheckPredicate, 19, // 2766: check predicate 19
2292 OPC_Decode, 197, 13, 123, // 2768: decode to FMUL_D32_MM using decoder 123
2293 // 2768: }
2294 7, 0, // 2772: case 0x7: {
2295 OPC_CheckPredicate, 19, // 2774: check predicate 19
2296 OPC_Decode, 135, 13, 123, // 2776: decode to FDIV_D32_MM using decoder 123
2297 // 2776: }
2298 // 2776: } // switch Inst[10:6]
2299 // 2776: }
2300 56, 35, // 2780: case 0x38: {
2301 OPC_SwitchField, 6, 4, // 2782: switch Inst[9:6] {
2302 0, 6, // 2785: case 0x0: {
2303 OPC_CheckPredicate, 14, // 2787: check predicate 14
2304 OPC_Decode, 135, 17, 124, // 2789: decode to MOVN_I_S_MM using decoder 124
2305 // 2789: }
2306 1, 6, // 2793: case 0x1: {
2307 OPC_CheckPredicate, 14, // 2795: check predicate 14
2308 OPC_Decode, 155, 17, 124, // 2797: decode to MOVZ_I_S_MM using decoder 124
2309 // 2797: }
2310 4, 6, // 2801: case 0x4: {
2311 OPC_CheckPredicate, 18, // 2803: check predicate 18
2312 OPC_Decode, 129, 17, 125, // 2805: decode to MOVN_I_D32_MM using decoder 125
2313 // 2805: }
2314 5, 0, // 2809: case 0x5: {
2315 OPC_CheckPredicate, 18, // 2811: check predicate 18
2316 OPC_Decode, 149, 17, 125, // 2813: decode to MOVZ_I_D32_MM using decoder 125
2317 // 2813: }
2318 // 2813: } // switch Inst[9:6]
2319 // 2813: }
2320 59, 250, 2, // 2817: case 0x3b: {
2321 OPC_SwitchField, 6, 7, // 2820: switch Inst[12:6] {
2322 0, 10, // 2823: case 0x0: {
2323 OPC_CheckPredicate, 20, // 2825: check predicate 20
2324 OPC_CheckField, 13, 3, 1, // 2827: check Inst[15:13] == 0x1
2325 OPC_Decode, 170, 16, 126, // 2831: decode to MFC1_MM using decoder 126
2326 // 2831: }
2327 1, 10, // 2835: case 0x1: {
2328 OPC_CheckPredicate, 19, // 2837: check predicate 19
2329 OPC_CheckField, 13, 3, 1, // 2839: check Inst[15:13] == 0x1
2330 OPC_Decode, 186, 13, 127, // 2843: decode to FMOV_D32_MM using decoder 127
2331 // 2843: }
2332 4, 21, // 2847: case 0x4: {
2333 OPC_SwitchField, 13, 3, // 2849: switch Inst[15:13] {
2334 0, 7, // 2852: case 0x0: {
2335 OPC_CheckPredicate, 21, // 2854: check predicate 21
2336 OPC_Decode, 169, 10, 128, 1, // 2856: decode to CVT_L_S_MM using decoder 128
2337 // 2856: }
2338 2, 0, // 2861: case 0x2: {
2339 OPC_CheckPredicate, 21, // 2863: check predicate 21
2340 OPC_Decode, 166, 10, 129, 1, // 2865: decode to CVT_L_D64_MM using decoder 129
2341 // 2865: }
2342 // 2865: } // switch Inst[15:13]
2343 // 2865: }
2344 5, 7, // 2870: case 0x5: {
2345 OPC_CheckPredicate, 14, // 2872: check predicate 14
2346 OPC_Decode, 249, 16, 130, 1, // 2874: decode to MOVF_I_MM using decoder 130
2347 // 2874: }
2348 8, 20, // 2879: case 0x8: {
2349 OPC_SwitchField, 13, 3, // 2881: switch Inst[15:13] {
2350 0, 7, // 2884: case 0x0: {
2351 OPC_CheckPredicate, 20, // 2886: check predicate 20
2352 OPC_Decode, 177, 19, 131, 1, // 2888: decode to RSQRT_S_MM using decoder 131
2353 // 2888: }
2354 2, 0, // 2893: case 0x2: {
2355 OPC_CheckPredicate, 19, // 2895: check predicate 19
2356 OPC_Decode, 173, 19, 127, // 2897: decode to RSQRT_D32_MM using decoder 127
2357 // 2897: }
2358 // 2897: } // switch Inst[15:13]
2359 // 2897: }
2360 13, 20, // 2901: case 0xd: {
2361 OPC_SwitchField, 13, 3, // 2903: switch Inst[15:13] {
2362 0, 7, // 2906: case 0x0: {
2363 OPC_CheckPredicate, 20, // 2908: check predicate 20
2364 OPC_Decode, 221, 12, 131, 1, // 2910: decode to FABS_S_MM using decoder 131
2365 // 2910: }
2366 1, 0, // 2915: case 0x1: {
2367 OPC_CheckPredicate, 19, // 2917: check predicate 19
2368 OPC_Decode, 217, 12, 127, // 2919: decode to FABS_D32_MM using decoder 127
2369 // 2919: }
2370 // 2919: } // switch Inst[15:13]
2371 // 2919: }
2372 32, 11, // 2923: case 0x20: {
2373 OPC_CheckPredicate, 20, // 2925: check predicate 20
2374 OPC_CheckField, 13, 3, 1, // 2927: check Inst[15:13] == 0x1
2375 OPC_Decode, 187, 17, 132, 1, // 2931: decode to MTC1_MM using decoder 132
2376 // 2931: }
2377 36, 21, // 2936: case 0x24: {
2378 OPC_SwitchField, 13, 3, // 2938: switch Inst[15:13] {
2379 0, 7, // 2941: case 0x0: {
2380 OPC_CheckPredicate, 20, // 2943: check predicate 20
2381 OPC_Decode, 190, 10, 131, 1, // 2945: decode to CVT_W_S_MM using decoder 131
2382 // 2945: }
2383 2, 0, // 2950: case 0x2: {
2384 OPC_CheckPredicate, 19, // 2952: check predicate 19
2385 OPC_Decode, 186, 10, 133, 1, // 2954: decode to CVT_W_D32_MM using decoder 133
2386 // 2954: }
2387 // 2954: } // switch Inst[15:13]
2388 // 2954: }
2389 37, 7, // 2959: case 0x25: {
2390 OPC_CheckPredicate, 14, // 2961: check predicate 14
2391 OPC_Decode, 141, 17, 130, 1, // 2963: decode to MOVT_I_MM using decoder 130
2392 // 2963: }
2393 40, 20, // 2968: case 0x28: {
2394 OPC_SwitchField, 13, 3, // 2970: switch Inst[15:13] {
2395 0, 7, // 2973: case 0x0: {
2396 OPC_CheckPredicate, 20, // 2975: check predicate 20
2397 OPC_Decode, 237, 13, 131, 1, // 2977: decode to FSQRT_S_MM using decoder 131
2398 // 2977: }
2399 2, 0, // 2982: case 0x2: {
2400 OPC_CheckPredicate, 19, // 2984: check predicate 19
2401 OPC_Decode, 233, 13, 127, // 2986: decode to FSQRT_D32_MM using decoder 127
2402 // 2986: }
2403 // 2986: } // switch Inst[15:13]
2404 // 2986: }
2405 44, 39, // 2990: case 0x2c: {
2406 OPC_SwitchField, 13, 3, // 2992: switch Inst[15:13] {
2407 0, 7, // 2995: case 0x0: {
2408 OPC_CheckPredicate, 20, // 2997: check predicate 20
2409 OPC_Decode, 173, 13, 131, 1, // 2999: decode to FLOOR_W_S_MM using decoder 131
2410 // 2999: }
2411 1, 7, // 3004: case 0x1: {
2412 OPC_CheckPredicate, 20, // 3006: check predicate 20
2413 OPC_Decode, 209, 22, 131, 1, // 3008: decode to TRUNC_W_S_MM using decoder 131
2414 // 3008: }
2415 2, 7, // 3013: case 0x2: {
2416 OPC_CheckPredicate, 19, // 3015: check predicate 19
2417 OPC_Decode, 171, 13, 133, 1, // 3017: decode to FLOOR_W_MM using decoder 133
2418 // 3017: }
2419 3, 0, // 3022: case 0x3: {
2420 OPC_CheckPredicate, 19, // 3024: check predicate 19
2421 OPC_Decode, 207, 22, 133, 1, // 3026: decode to TRUNC_W_MM using decoder 133
2422 // 3026: }
2423 // 3026: } // switch Inst[15:13]
2424 // 3026: }
2425 45, 10, // 3031: case 0x2d: {
2426 OPC_CheckPredicate, 19, // 3033: check predicate 19
2427 OPC_CheckField, 13, 3, 1, // 3035: check Inst[15:13] == 0x1
2428 OPC_Decode, 206, 13, 127, // 3039: decode to FNEG_D32_MM using decoder 127
2429 // 3039: }
2430 64, 21, // 3043: case 0x40: {
2431 OPC_SwitchField, 13, 3, // 3045: switch Inst[15:13] {
2432 0, 7, // 3048: case 0x0: {
2433 OPC_CheckPredicate, 20, // 3050: check predicate 20
2434 OPC_Decode, 253, 8, 134, 1, // 3052: decode to CFC1_MM using decoder 134
2435 // 3052: }
2436 1, 0, // 3057: case 0x1: {
2437 OPC_CheckPredicate, 19, // 3059: check predicate 19
2438 OPC_Decode, 178, 16, 135, 1, // 3061: decode to MFHC1_D32_MM using decoder 135
2439 // 3061: }
2440 // 3061: } // switch Inst[15:13]
2441 // 3061: }
2442 72, 20, // 3066: case 0x48: {
2443 OPC_SwitchField, 13, 3, // 3068: switch Inst[15:13] {
2444 0, 7, // 3071: case 0x0: {
2445 OPC_CheckPredicate, 20, // 3073: check predicate 20
2446 OPC_Decode, 144, 19, 131, 1, // 3075: decode to RECIP_S_MM using decoder 131
2447 // 3075: }
2448 2, 0, // 3080: case 0x2: {
2449 OPC_CheckPredicate, 19, // 3082: check predicate 19
2450 OPC_Decode, 140, 19, 127, // 3084: decode to RECIP_D32_MM using decoder 127
2451 // 3084: }
2452 // 3084: } // switch Inst[15:13]
2453 // 3084: }
2454 77, 21, // 3088: case 0x4d: {
2455 OPC_SwitchField, 13, 3, // 3090: switch Inst[15:13] {
2456 0, 7, // 3093: case 0x0: {
2457 OPC_CheckPredicate, 19, // 3095: check predicate 19
2458 OPC_Decode, 156, 10, 136, 1, // 3097: decode to CVT_D32_S_MM using decoder 136
2459 // 3097: }
2460 1, 0, // 3102: case 0x1: {
2461 OPC_CheckPredicate, 19, // 3104: check predicate 19
2462 OPC_Decode, 158, 10, 136, 1, // 3106: decode to CVT_D32_W_MM using decoder 136
2463 // 3106: }
2464 // 3106: } // switch Inst[15:13]
2465 // 3106: }
2466 96, 21, // 3111: case 0x60: {
2467 OPC_SwitchField, 13, 3, // 3113: switch Inst[15:13] {
2468 0, 7, // 3116: case 0x0: {
2469 OPC_CheckPredicate, 20, // 3118: check predicate 20
2470 OPC_Decode, 152, 10, 137, 1, // 3120: decode to CTC1_MM using decoder 137
2471 // 3120: }
2472 1, 0, // 3125: case 0x1: {
2473 OPC_CheckPredicate, 19, // 3127: check predicate 19
2474 OPC_Decode, 195, 17, 138, 1, // 3129: decode to MTHC1_D32_MM using decoder 138
2475 // 3129: }
2476 // 3129: } // switch Inst[15:13]
2477 // 3129: }
2478 108, 39, // 3134: case 0x6c: {
2479 OPC_SwitchField, 13, 3, // 3136: switch Inst[15:13] {
2480 0, 7, // 3139: case 0x0: {
2481 OPC_CheckPredicate, 20, // 3141: check predicate 20
2482 OPC_Decode, 242, 8, 131, 1, // 3143: decode to CEIL_W_S_MM using decoder 131
2483 // 3143: }
2484 1, 7, // 3148: case 0x1: {
2485 OPC_CheckPredicate, 20, // 3150: check predicate 20
2486 OPC_Decode, 170, 19, 131, 1, // 3152: decode to ROUND_W_S_MM using decoder 131
2487 // 3152: }
2488 2, 7, // 3157: case 0x2: {
2489 OPC_CheckPredicate, 19, // 3159: check predicate 19
2490 OPC_Decode, 240, 8, 133, 1, // 3161: decode to CEIL_W_MM using decoder 133
2491 // 3161: }
2492 3, 0, // 3166: case 0x3: {
2493 OPC_CheckPredicate, 19, // 3168: check predicate 19
2494 OPC_Decode, 168, 19, 133, 1, // 3170: decode to ROUND_W_MM using decoder 133
2495 // 3170: }
2496 // 3170: } // switch Inst[15:13]
2497 // 3170: }
2498 109, 0, // 3175: case 0x6d: {
2499 OPC_SwitchField, 13, 3, // 3177: switch Inst[15:13] {
2500 0, 7, // 3180: case 0x0: {
2501 OPC_CheckPredicate, 19, // 3182: check predicate 19
2502 OPC_Decode, 175, 10, 133, 1, // 3184: decode to CVT_S_D32_MM using decoder 133
2503 // 3184: }
2504 1, 0, // 3189: case 0x1: {
2505 OPC_CheckPredicate, 20, // 3191: check predicate 20
2506 OPC_Decode, 183, 10, 131, 1, // 3193: decode to CVT_S_W_MM using decoder 131
2507 // 3193: }
2508 // 3193: } // switch Inst[15:13]
2509 // 3193: }
2510 // 3193: } // switch Inst[12:6]
2511 // 3193: }
2512 60, 0, // 3198: case 0x3c: {
2513 OPC_SwitchField, 6, 7, // 3200: switch Inst[12:6] {
2514 0, 7, // 3203: case 0x0: {
2515 OPC_CheckPredicate, 14, // 3205: check predicate 14
2516 OPC_Decode, 203, 10, 139, 1, // 3207: decode to C_F_S_MM using decoder 139
2517 // 3207: }
2518 1, 7, // 3212: case 0x1: {
2519 OPC_CheckPredicate, 14, // 3214: check predicate 14
2520 OPC_Decode, 159, 11, 139, 1, // 3216: decode to C_UN_S_MM using decoder 139
2521 // 3216: }
2522 2, 7, // 3221: case 0x2: {
2523 OPC_CheckPredicate, 14, // 3223: check predicate 14
2524 OPC_Decode, 197, 10, 139, 1, // 3225: decode to C_EQ_S_MM using decoder 139
2525 // 3225: }
2526 3, 7, // 3230: case 0x3: {
2527 OPC_CheckPredicate, 14, // 3232: check predicate 14
2528 OPC_Decode, 141, 11, 139, 1, // 3234: decode to C_UEQ_S_MM using decoder 139
2529 // 3234: }
2530 4, 7, // 3239: case 0x4: {
2531 OPC_CheckPredicate, 14, // 3241: check predicate 14
2532 OPC_Decode, 251, 10, 139, 1, // 3243: decode to C_OLT_S_MM using decoder 139
2533 // 3243: }
2534 5, 7, // 3248: case 0x5: {
2535 OPC_CheckPredicate, 14, // 3250: check predicate 14
2536 OPC_Decode, 153, 11, 139, 1, // 3252: decode to C_ULT_S_MM using decoder 139
2537 // 3252: }
2538 6, 7, // 3257: case 0x6: {
2539 OPC_CheckPredicate, 14, // 3259: check predicate 14
2540 OPC_Decode, 245, 10, 139, 1, // 3261: decode to C_OLE_S_MM using decoder 139
2541 // 3261: }
2542 7, 7, // 3266: case 0x7: {
2543 OPC_CheckPredicate, 14, // 3268: check predicate 14
2544 OPC_Decode, 147, 11, 139, 1, // 3270: decode to C_ULE_S_MM using decoder 139
2545 // 3270: }
2546 8, 7, // 3275: case 0x8: {
2547 OPC_CheckPredicate, 14, // 3277: check predicate 14
2548 OPC_Decode, 135, 11, 139, 1, // 3279: decode to C_SF_S_MM using decoder 139
2549 // 3279: }
2550 9, 7, // 3284: case 0x9: {
2551 OPC_CheckPredicate, 14, // 3286: check predicate 14
2552 OPC_Decode, 227, 10, 139, 1, // 3288: decode to C_NGLE_S_MM using decoder 139
2553 // 3288: }
2554 10, 7, // 3293: case 0xa: {
2555 OPC_CheckPredicate, 14, // 3295: check predicate 14
2556 OPC_Decode, 129, 11, 139, 1, // 3297: decode to C_SEQ_S_MM using decoder 139
2557 // 3297: }
2558 11, 7, // 3302: case 0xb: {
2559 OPC_CheckPredicate, 14, // 3304: check predicate 14
2560 OPC_Decode, 233, 10, 139, 1, // 3306: decode to C_NGL_S_MM using decoder 139
2561 // 3306: }
2562 12, 7, // 3311: case 0xc: {
2563 OPC_CheckPredicate, 14, // 3313: check predicate 14
2564 OPC_Decode, 215, 10, 139, 1, // 3315: decode to C_LT_S_MM using decoder 139
2565 // 3315: }
2566 13, 7, // 3320: case 0xd: {
2567 OPC_CheckPredicate, 14, // 3322: check predicate 14
2568 OPC_Decode, 221, 10, 139, 1, // 3324: decode to C_NGE_S_MM using decoder 139
2569 // 3324: }
2570 14, 7, // 3329: case 0xe: {
2571 OPC_CheckPredicate, 14, // 3331: check predicate 14
2572 OPC_Decode, 209, 10, 139, 1, // 3333: decode to C_LE_S_MM using decoder 139
2573 // 3333: }
2574 15, 7, // 3338: case 0xf: {
2575 OPC_CheckPredicate, 14, // 3340: check predicate 14
2576 OPC_Decode, 239, 10, 139, 1, // 3342: decode to C_NGT_S_MM using decoder 139
2577 // 3342: }
2578 16, 7, // 3347: case 0x10: {
2579 OPC_CheckPredicate, 18, // 3349: check predicate 18
2580 OPC_Decode, 199, 10, 140, 1, // 3351: decode to C_F_D32_MM using decoder 140
2581 // 3351: }
2582 17, 7, // 3356: case 0x11: {
2583 OPC_CheckPredicate, 18, // 3358: check predicate 18
2584 OPC_Decode, 155, 11, 140, 1, // 3360: decode to C_UN_D32_MM using decoder 140
2585 // 3360: }
2586 18, 7, // 3365: case 0x12: {
2587 OPC_CheckPredicate, 18, // 3367: check predicate 18
2588 OPC_Decode, 193, 10, 140, 1, // 3369: decode to C_EQ_D32_MM using decoder 140
2589 // 3369: }
2590 19, 7, // 3374: case 0x13: {
2591 OPC_CheckPredicate, 18, // 3376: check predicate 18
2592 OPC_Decode, 137, 11, 140, 1, // 3378: decode to C_UEQ_D32_MM using decoder 140
2593 // 3378: }
2594 20, 7, // 3383: case 0x14: {
2595 OPC_CheckPredicate, 18, // 3385: check predicate 18
2596 OPC_Decode, 247, 10, 140, 1, // 3387: decode to C_OLT_D32_MM using decoder 140
2597 // 3387: }
2598 21, 7, // 3392: case 0x15: {
2599 OPC_CheckPredicate, 18, // 3394: check predicate 18
2600 OPC_Decode, 149, 11, 140, 1, // 3396: decode to C_ULT_D32_MM using decoder 140
2601 // 3396: }
2602 22, 7, // 3401: case 0x16: {
2603 OPC_CheckPredicate, 18, // 3403: check predicate 18
2604 OPC_Decode, 241, 10, 140, 1, // 3405: decode to C_OLE_D32_MM using decoder 140
2605 // 3405: }
2606 23, 7, // 3410: case 0x17: {
2607 OPC_CheckPredicate, 18, // 3412: check predicate 18
2608 OPC_Decode, 143, 11, 140, 1, // 3414: decode to C_ULE_D32_MM using decoder 140
2609 // 3414: }
2610 24, 7, // 3419: case 0x18: {
2611 OPC_CheckPredicate, 18, // 3421: check predicate 18
2612 OPC_Decode, 131, 11, 140, 1, // 3423: decode to C_SF_D32_MM using decoder 140
2613 // 3423: }
2614 25, 7, // 3428: case 0x19: {
2615 OPC_CheckPredicate, 18, // 3430: check predicate 18
2616 OPC_Decode, 223, 10, 140, 1, // 3432: decode to C_NGLE_D32_MM using decoder 140
2617 // 3432: }
2618 26, 7, // 3437: case 0x1a: {
2619 OPC_CheckPredicate, 18, // 3439: check predicate 18
2620 OPC_Decode, 253, 10, 140, 1, // 3441: decode to C_SEQ_D32_MM using decoder 140
2621 // 3441: }
2622 27, 7, // 3446: case 0x1b: {
2623 OPC_CheckPredicate, 18, // 3448: check predicate 18
2624 OPC_Decode, 229, 10, 140, 1, // 3450: decode to C_NGL_D32_MM using decoder 140
2625 // 3450: }
2626 28, 7, // 3455: case 0x1c: {
2627 OPC_CheckPredicate, 18, // 3457: check predicate 18
2628 OPC_Decode, 211, 10, 140, 1, // 3459: decode to C_LT_D32_MM using decoder 140
2629 // 3459: }
2630 29, 7, // 3464: case 0x1d: {
2631 OPC_CheckPredicate, 18, // 3466: check predicate 18
2632 OPC_Decode, 217, 10, 140, 1, // 3468: decode to C_NGE_D32_MM using decoder 140
2633 // 3468: }
2634 30, 7, // 3473: case 0x1e: {
2635 OPC_CheckPredicate, 18, // 3475: check predicate 18
2636 OPC_Decode, 205, 10, 140, 1, // 3477: decode to C_LE_D32_MM using decoder 140
2637 // 3477: }
2638 31, 0, // 3482: case 0x1f: {
2639 OPC_CheckPredicate, 18, // 3484: check predicate 18
2640 OPC_Decode, 235, 10, 140, 1, // 3486: decode to C_NGT_D32_MM using decoder 140
2641 // 3486: }
2642 // 3486: } // switch Inst[12:6]
2643 // 3486: }
2644 // 3486: } // switch Inst[5:0]
2645 // 3486: }
2646 22, 30, // 3491: case 0x16: {
2647 OPC_SwitchField, 0, 11, // 3493: switch Inst[10:0] {
2648 197, 1, 6, // 3496: case 0xc5: {
2649 OPC_CheckPredicate, 9, // 3499: check predicate 9
2650 OPC_Decode, 183, 9, 60, // 3501: decode to CMPGU_EQ_QB_MM using decoder 60
2651 // 3501: }
2652 133, 2, 6, // 3505: case 0x105: {
2653 OPC_CheckPredicate, 9, // 3508: check predicate 9
2654 OPC_Decode, 187, 9, 60, // 3510: decode to CMPGU_LT_QB_MM using decoder 60
2655 // 3510: }
2656 197, 2, 0, // 3514: case 0x145: {
2657 OPC_CheckPredicate, 9, // 3517: check predicate 9
2658 OPC_Decode, 185, 9, 60, // 3519: decode to CMPGU_LE_QB_MM using decoder 60
2659 // 3519: }
2660 // 3519: } // switch Inst[10:0]
2661 // 3519: }
2662 24, 221, 1, // 3523: case 0x18: {
2663 OPC_SwitchField, 12, 4, // 3526: switch Inst[15:12] {
2664 0, 6, // 3529: case 0x0: {
2665 OPC_CheckPredicate, 1, // 3531: check predicate 1
2666 OPC_Decode, 198, 15, 106, // 3533: decode to LWL_MM using decoder 106
2667 // 3533: }
2668 1, 6, // 3537: case 0x1: {
2669 OPC_CheckPredicate, 1, // 3539: check predicate 1
2670 OPC_Decode, 209, 15, 106, // 3541: decode to LWR_MM using decoder 106
2671 // 3541: }
2672 2, 6, // 3545: case 0x2: {
2673 OPC_CheckPredicate, 1, // 3547: check predicate 1
2674 OPC_Decode, 251, 18, 107, // 3549: decode to PREF_MM using decoder 107
2675 // 3549: }
2676 3, 6, // 3553: case 0x3: {
2677 OPC_CheckPredicate, 1, // 3555: check predicate 1
2678 OPC_Decode, 167, 15, 106, // 3557: decode to LL_MM using decoder 106
2679 // 3557: }
2680 6, 75, // 3561: case 0x6: {
2681 OPC_SwitchField, 9, 3, // 3563: switch Inst[11:9] {
2682 0, 7, // 3566: case 0x0: {
2683 OPC_CheckPredicate, 22, // 3568: check predicate 22
2684 OPC_Decode, 245, 14, 141, 1, // 3570: decode to LBuE_MM using decoder 141
2685 // 3570: }
2686 1, 7, // 3575: case 0x1: {
2687 OPC_CheckPredicate, 22, // 3577: check predicate 22
2688 OPC_Decode, 156, 15, 141, 1, // 3579: decode to LHuE_MM using decoder 141
2689 // 3579: }
2690 2, 7, // 3584: case 0x2: {
2691 OPC_CheckPredicate, 23, // 3586: check predicate 23
2692 OPC_Decode, 197, 15, 141, 1, // 3588: decode to LWLE_MM using decoder 141
2693 // 3588: }
2694 3, 7, // 3593: case 0x3: {
2695 OPC_CheckPredicate, 23, // 3595: check predicate 23
2696 OPC_Decode, 208, 15, 141, 1, // 3597: decode to LWRE_MM using decoder 141
2697 // 3597: }
2698 4, 7, // 3602: case 0x4: {
2699 OPC_CheckPredicate, 22, // 3604: check predicate 22
2700 OPC_Decode, 235, 14, 141, 1, // 3606: decode to LBE_MM using decoder 141
2701 // 3606: }
2702 5, 7, // 3611: case 0x5: {
2703 OPC_CheckPredicate, 22, // 3613: check predicate 22
2704 OPC_Decode, 148, 15, 141, 1, // 3615: decode to LHE_MM using decoder 141
2705 // 3615: }
2706 6, 7, // 3620: case 0x6: {
2707 OPC_CheckPredicate, 22, // 3622: check predicate 22
2708 OPC_Decode, 166, 15, 141, 1, // 3624: decode to LLE_MM using decoder 141
2709 // 3624: }
2710 7, 0, // 3629: case 0x7: {
2711 OPC_CheckPredicate, 22, // 3631: check predicate 22
2712 OPC_Decode, 192, 15, 141, 1, // 3633: decode to LWE_MM using decoder 141
2713 // 3633: }
2714 // 3633: } // switch Inst[11:9]
2715 // 3633: }
2716 8, 6, // 3638: case 0x8: {
2717 OPC_CheckPredicate, 1, // 3640: check predicate 1
2718 OPC_Decode, 236, 21, 106, // 3642: decode to SWL_MM using decoder 106
2719 // 3642: }
2720 9, 6, // 3646: case 0x9: {
2721 OPC_CheckPredicate, 1, // 3648: check predicate 1
2722 OPC_Decode, 245, 21, 106, // 3650: decode to SWR_MM using decoder 106
2723 // 3650: }
2724 10, 75, // 3654: case 0xa: {
2725 OPC_SwitchField, 9, 3, // 3656: switch Inst[11:9] {
2726 0, 7, // 3659: case 0x0: {
2727 OPC_CheckPredicate, 23, // 3661: check predicate 23
2728 OPC_Decode, 235, 21, 141, 1, // 3663: decode to SWLE_MM using decoder 141
2729 // 3663: }
2730 1, 7, // 3668: case 0x1: {
2731 OPC_CheckPredicate, 23, // 3670: check predicate 23
2732 OPC_Decode, 244, 21, 141, 1, // 3672: decode to SWRE_MM using decoder 141
2733 // 3672: }
2734 2, 7, // 3677: case 0x2: {
2735 OPC_CheckPredicate, 22, // 3679: check predicate 22
2736 OPC_Decode, 249, 18, 142, 1, // 3681: decode to PREFE_MM using decoder 142
2737 // 3681: }
2738 3, 7, // 3686: case 0x3: {
2739 OPC_CheckPredicate, 22, // 3688: check predicate 22
2740 OPC_Decode, 229, 8, 142, 1, // 3690: decode to CACHEE_MM using decoder 142
2741 // 3690: }
2742 4, 7, // 3695: case 0x4: {
2743 OPC_CheckPredicate, 22, // 3697: check predicate 22
2744 OPC_Decode, 195, 19, 141, 1, // 3699: decode to SBE_MM using decoder 141
2745 // 3699: }
2746 5, 7, // 3704: case 0x5: {
2747 OPC_CheckPredicate, 22, // 3706: check predicate 22
2748 OPC_Decode, 133, 20, 141, 1, // 3708: decode to SHE_MM using decoder 141
2749 // 3708: }
2750 6, 7, // 3713: case 0x6: {
2751 OPC_CheckPredicate, 22, // 3715: check predicate 22
2752 OPC_Decode, 204, 19, 141, 1, // 3717: decode to SCE_MM using decoder 141
2753 // 3717: }
2754 7, 0, // 3722: case 0x7: {
2755 OPC_CheckPredicate, 22, // 3724: check predicate 22
2756 OPC_Decode, 231, 21, 141, 1, // 3726: decode to SWE_MM using decoder 141
2757 // 3726: }
2758 // 3726: } // switch Inst[11:9]
2759 // 3726: }
2760 11, 6, // 3731: case 0xb: {
2761 OPC_CheckPredicate, 1, // 3733: check predicate 1
2762 OPC_Decode, 205, 19, 106, // 3735: decode to SC_MM using decoder 106
2763 // 3735: }
2764 14, 0, // 3739: case 0xe: {
2765 OPC_CheckPredicate, 1, // 3741: check predicate 1
2766 OPC_Decode, 212, 15, 106, // 3743: decode to LWU_MM using decoder 106
2767 // 3743: }
2768 // 3743: } // switch Inst[15:12]
2769 // 3743: }
2770 28, 6, // 3747: case 0x1c: {
2771 OPC_CheckPredicate, 1, // 3749: check predicate 1
2772 OPC_Decode, 241, 22, 115, // 3751: decode to XORi_MM using decoder 115
2773 // 3751: }
2774 29, 7, // 3755: case 0x1d: {
2775 OPC_CheckPredicate, 1, // 3757: check predicate 1
2776 OPC_Decode, 202, 14, 143, 1, // 3759: decode to JALS_MM using decoder 143
2777 // 3759: }
2778 30, 7, // 3764: case 0x1e: {
2779 OPC_CheckPredicate, 1, // 3766: check predicate 1
2780 OPC_Decode, 156, 6, 144, 1, // 3768: decode to ADDIUPC_MM using decoder 144
2781 // 3768: }
2782 36, 6, // 3773: case 0x24: {
2783 OPC_CheckPredicate, 2, // 3775: check predicate 2
2784 OPC_Decode, 219, 20, 104, // 3777: decode to SLTi_MM using decoder 104
2785 // 3777: }
2786 37, 7, // 3781: case 0x25: {
2787 OPC_CheckPredicate, 1, // 3783: check predicate 1
2788 OPC_Decode, 208, 7, 145, 1, // 3785: decode to BEQ_MM using decoder 145
2789 // 3785: }
2790 38, 7, // 3790: case 0x26: {
2791 OPC_CheckPredicate, 20, // 3792: check predicate 20
2792 OPC_Decode, 223, 21, 146, 1, // 3794: decode to SWC1_MM using decoder 146
2793 // 3794: }
2794 39, 7, // 3799: case 0x27: {
2795 OPC_CheckPredicate, 20, // 3801: check predicate 20
2796 OPC_Decode, 184, 15, 146, 1, // 3803: decode to LWC1_MM using decoder 146
2797 // 3803: }
2798 44, 6, // 3808: case 0x2c: {
2799 OPC_CheckPredicate, 2, // 3810: check predicate 2
2800 OPC_Decode, 222, 20, 104, // 3812: decode to SLTiu_MM using decoder 104
2801 // 3812: }
2802 45, 7, // 3816: case 0x2d: {
2803 OPC_CheckPredicate, 1, // 3818: check predicate 1
2804 OPC_Decode, 183, 8, 145, 1, // 3820: decode to BNE_MM using decoder 145
2805 // 3820: }
2806 46, 7, // 3825: case 0x2e: {
2807 OPC_CheckPredicate, 19, // 3827: check predicate 19
2808 OPC_Decode, 218, 19, 146, 1, // 3829: decode to SDC1_MM_D32 using decoder 146
2809 // 3829: }
2810 47, 7, // 3834: case 0x2f: {
2811 OPC_CheckPredicate, 19, // 3836: check predicate 19
2812 OPC_Decode, 251, 14, 146, 1, // 3838: decode to LDC1_MM_D32 using decoder 146
2813 // 3838: }
2814 52, 6, // 3843: case 0x34: {
2815 OPC_CheckPredicate, 1, // 3845: check predicate 1
2816 OPC_Decode, 246, 6, 115, // 3847: decode to ANDi_MM using decoder 115
2817 // 3847: }
2818 53, 7, // 3851: case 0x35: {
2819 OPC_CheckPredicate, 1, // 3853: check predicate 1
2820 OPC_Decode, 225, 14, 143, 1, // 3855: decode to J_MM using decoder 143
2821 // 3855: }
2822 60, 7, // 3860: case 0x3c: {
2823 OPC_CheckPredicate, 1, // 3862: check predicate 1
2824 OPC_Decode, 204, 14, 147, 1, // 3864: decode to JALX_MM using decoder 147
2825 // 3864: }
2826 61, 7, // 3869: case 0x3d: {
2827 OPC_CheckPredicate, 1, // 3871: check predicate 1
2828 OPC_Decode, 205, 14, 143, 1, // 3873: decode to JAL_MM using decoder 143
2829 // 3873: }
2830 62, 6, // 3878: case 0x3e: {
2831 OPC_CheckPredicate, 2, // 3880: check predicate 2
2832 OPC_Decode, 250, 21, 105, // 3882: decode to SW_MM using decoder 105
2833 // 3882: }
2834 63, 0, // 3886: case 0x3f: {
2835 OPC_CheckPredicate, 2, // 3888: check predicate 2
2836 OPC_Decode, 218, 15, 105, // 3890: decode to LW_MM using decoder 105
2837 // 3890: }
2838 // 3890: } // switch Inst[31:26]
2839};
2840static const uint8_t DecoderTableMicroMipsDSP32[21] = {
2841 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
2842 62, 7, // 3: case 0x3e: {
2843 OPC_CheckPredicate, 9, // 5: check predicate 9
2844 OPC_Decode, 229, 21, 148, 1, // 7: decode to SWDSP_MM using decoder 148
2845 // 7: }
2846 63, 0, // 12: case 0x3f: {
2847 OPC_CheckPredicate, 9, // 14: check predicate 9
2848 OPC_Decode, 190, 15, 148, 1, // 16: decode to LWDSP_MM using decoder 148
2849 // 16: }
2850 // 16: } // switch Inst[31:26]
2851};
2852static const uint8_t DecoderTableMicroMipsFP6432[210] = {
2853 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
2854 21, 186, 1, // 3: case 0x15: {
2855 OPC_SwitchField, 0, 11, // 6: switch Inst[10:0] {
2856 59, 30, // 9: case 0x3b: {
2857 OPC_SwitchField, 11, 5, // 11: switch Inst[15:11] {
2858 5, 7, // 14: case 0x5: {
2859 OPC_CheckPredicate, 21, // 16: check predicate 21
2860 OPC_Decode, 186, 17, 149, 1, // 18: decode to MTC1_D64_MM using decoder 149
2861 // 18: }
2862 6, 7, // 23: case 0x6: {
2863 OPC_CheckPredicate, 21, // 25: check predicate 21
2864 OPC_Decode, 180, 16, 150, 1, // 27: decode to MFHC1_D64_MM using decoder 150
2865 // 27: }
2866 7, 0, // 32: case 0x7: {
2867 OPC_CheckPredicate, 21, // 34: check predicate 21
2868 OPC_Decode, 197, 17, 151, 1, // 36: decode to MTHC1_D64_MM using decoder 151
2869 // 36: }
2870 // 36: } // switch Inst[15:11]
2871 // 36: }
2872 123, 11, // 41: case 0x7b: {
2873 OPC_CheckPredicate, 21, // 43: check predicate 21
2874 OPC_CheckField, 11, 5, 4, // 45: check Inst[15:11] == 0x4
2875 OPC_Decode, 188, 13, 129, 1, // 49: decode to FMOV_D64_MM using decoder 129
2876 // 49: }
2877 176, 2, 7, // 54: case 0x130: {
2878 OPC_CheckPredicate, 21, // 57: check predicate 21
2879 OPC_Decode, 226, 12, 152, 1, // 59: decode to FADD_D64_MM using decoder 152
2880 // 59: }
2881 187, 2, 11, // 64: case 0x13b: {
2882 OPC_CheckPredicate, 21, // 67: check predicate 21
2883 OPC_CheckField, 11, 5, 9, // 69: check Inst[15:11] == 0x9
2884 OPC_Decode, 188, 10, 153, 1, // 73: decode to CVT_W_D64_MM using decoder 153
2885 // 73: }
2886 240, 2, 7, // 78: case 0x170: {
2887 OPC_CheckPredicate, 21, // 81: check predicate 21
2888 OPC_Decode, 243, 13, 152, 1, // 83: decode to FSUB_D64_MM using decoder 152
2889 // 83: }
2890 176, 3, 7, // 88: case 0x1b0: {
2891 OPC_CheckPredicate, 21, // 91: check predicate 21
2892 OPC_Decode, 199, 13, 152, 1, // 93: decode to FMUL_D64_MM using decoder 152
2893 // 93: }
2894 240, 3, 7, // 98: case 0x1f0: {
2895 OPC_CheckPredicate, 21, // 101: check predicate 21
2896 OPC_Decode, 137, 13, 152, 1, // 103: decode to FDIV_D64_MM using decoder 152
2897 // 103: }
2898 187, 4, 30, // 108: case 0x23b: {
2899 OPC_SwitchField, 11, 5, // 111: switch Inst[15:11] {
2900 8, 7, // 114: case 0x8: {
2901 OPC_CheckPredicate, 21, // 116: check predicate 21
2902 OPC_Decode, 175, 19, 129, 1, // 118: decode to RSQRT_D64_MM using decoder 129
2903 // 118: }
2904 9, 7, // 123: case 0x9: {
2905 OPC_CheckPredicate, 21, // 125: check predicate 21
2906 OPC_Decode, 235, 13, 129, 1, // 127: decode to FSQRT_D64_MM using decoder 129
2907 // 127: }
2908 10, 0, // 132: case 0xa: {
2909 OPC_CheckPredicate, 21, // 134: check predicate 21
2910 OPC_Decode, 142, 19, 129, 1, // 136: decode to RECIP_D64_MM using decoder 129
2911 // 136: }
2912 // 136: } // switch Inst[15:11]
2913 // 136: }
2914 251, 6, 0, // 141: case 0x37b: {
2915 OPC_SwitchField, 11, 5, // 144: switch Inst[15:11] {
2916 2, 7, // 147: case 0x2: {
2917 OPC_CheckPredicate, 21, // 149: check predicate 21
2918 OPC_Decode, 161, 10, 128, 1, // 151: decode to CVT_D64_S_MM using decoder 128
2919 // 151: }
2920 3, 7, // 156: case 0x3: {
2921 OPC_CheckPredicate, 21, // 158: check predicate 21
2922 OPC_Decode, 177, 10, 153, 1, // 160: decode to CVT_S_D64_MM using decoder 153
2923 // 160: }
2924 4, 7, // 165: case 0x4: {
2925 OPC_CheckPredicate, 21, // 167: check predicate 21
2926 OPC_Decode, 219, 12, 129, 1, // 169: decode to FABS_D64_MM using decoder 129
2927 // 169: }
2928 5, 7, // 174: case 0x5: {
2929 OPC_CheckPredicate, 21, // 176: check predicate 21
2930 OPC_Decode, 208, 13, 129, 1, // 178: decode to FNEG_D64_MM using decoder 129
2931 // 178: }
2932 6, 0, // 183: case 0x6: {
2933 OPC_CheckPredicate, 21, // 185: check predicate 21
2934 OPC_Decode, 163, 10, 128, 1, // 187: decode to CVT_D64_W_MM using decoder 128
2935 // 187: }
2936 // 187: } // switch Inst[15:11]
2937 // 187: }
2938 // 187: } // switch Inst[10:0]
2939 // 187: }
2940 46, 7, // 192: case 0x2e: {
2941 OPC_CheckPredicate, 24, // 194: check predicate 24
2942 OPC_Decode, 217, 19, 146, 1, // 196: decode to SDC1_D64_MMR6 using decoder 146
2943 // 196: }
2944 47, 0, // 201: case 0x2f: {
2945 OPC_CheckPredicate, 24, // 203: check predicate 24
2946 OPC_Decode, 250, 14, 146, 1, // 205: decode to LDC1_D64_MMR6 using decoder 146
2947 // 205: }
2948 // 205: } // switch Inst[31:26]
2949};
2950static const uint8_t DecoderTableMicroMipsR632[1966] = {
2951 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
2952 0, 146, 5, // 3: case 0x0: {
2953 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
2954 0, 69, // 9: case 0x0: {
2955 OPC_SwitchField, 6, 5, // 11: switch Inst[10:6] {
2956 0, 35, // 14: case 0x0: {
2957 OPC_Scope, 27, // 16: try {
2958 OPC_SwitchField, 11, 15, // 18: switch Inst[25:11] {
2959 1, 6, // 21: case 0x1: {
2960 OPC_CheckPredicate, 3, // 23: check predicate 3
2961 OPC_Decode, 152, 21, 10, // 25: decode to SSNOP_MMR6 using decoder 10
2962 // 25: }
2963 3, 6, // 29: case 0x3: {
2964 OPC_CheckPredicate, 3, // 31: check predicate 3
2965 OPC_Decode, 174, 12, 10, // 33: decode to EHB_MMR6 using decoder 10
2966 // 33: }
2967 5, 0, // 37: case 0x5: {
2968 OPC_CheckPredicate, 3, // 39: check predicate 3
2969 OPC_Decode, 193, 18, 10, // 41: decode to PAUSE_MMR6 using decoder 10
2970 // 41: }
2971 // 41: } // switch Inst[25:11]
2972 // 41: } else try {
2973 OPC_CheckPredicate, 3, // 45: check predicate 3
2974 OPC_Decode, 212, 20, 58, // 47: decode to SLL_MMR6 using decoder 58
2975 // 47: }
2976 // 47: }
2977 5, 6, // 51: case 0x5: {
2978 OPC_CheckPredicate, 3, // 53: check predicate 3
2979 OPC_Decode, 240, 19, 61, // 55: decode to SELEQZ_MMR6 using decoder 61
2980 // 55: }
2981 6, 6, // 59: case 0x6: {
2982 OPC_CheckPredicate, 3, // 61: check predicate 3
2983 OPC_Decode, 247, 19, 61, // 63: decode to SELNEZ_MMR6 using decoder 61
2984 // 63: }
2985 7, 0, // 67: case 0x7: {
2986 OPC_CheckPredicate, 3, // 69: check predicate 3
2987 OPC_CheckField, 14, 2, 0, // 71: check Inst[15:14] == 0x0
2988 OPC_Decode, 137, 19, 154, 1, // 75: decode to RDHWR_MMR6 using decoder 154
2989 // 75: }
2990 // 75: } // switch Inst[10:6]
2991 // 75: }
2992 7, 6, // 80: case 0x7: {
2993 OPC_CheckPredicate, 3, // 82: check predicate 3
2994 OPC_Decode, 200, 8, 62, // 84: decode to BREAK_MMR6 using decoder 62
2995 // 84: }
2996 12, 6, // 88: case 0xc: {
2997 OPC_CheckPredicate, 3, // 90: check predicate 3
2998 OPC_Decode, 187, 14, 63, // 92: decode to INS_MMR6 using decoder 63
2999 // 92: }
3000 15, 11, // 96: case 0xf: {
3001 OPC_CheckPredicate, 3, // 98: check predicate 3
3002 OPC_CheckField, 6, 3, 0, // 100: check Inst[8:6] == 0x0
3003 OPC_Decode, 171, 15, 155, 1, // 104: decode to LSA_MMR6 using decoder 155
3004 // 104: }
3005 16, 79, // 109: case 0x10: {
3006 OPC_SwitchField, 6, 5, // 111: switch Inst[10:6] {
3007 1, 10, // 114: case 0x1: {
3008 OPC_CheckPredicate, 3, // 116: check predicate 3
3009 OPC_CheckField, 16, 5, 0, // 118: check Inst[20:16] == 0x0
3010 OPC_Decode, 174, 9, 52, // 122: decode to CLZ_MMR6 using decoder 52
3011 // 122: }
3012 4, 6, // 126: case 0x4: {
3013 OPC_CheckPredicate, 3, // 128: check predicate 3
3014 OPC_Decode, 222, 6, 61, // 130: decode to ADD_MMR6 using decoder 61
3015 // 130: }
3016 5, 6, // 134: case 0x5: {
3017 OPC_CheckPredicate, 3, // 136: check predicate 3
3018 OPC_Decode, 198, 6, 61, // 138: decode to ADDU_MMR6 using decoder 61
3019 // 138: }
3020 6, 6, // 142: case 0x6: {
3021 OPC_CheckPredicate, 3, // 144: check predicate 3
3022 OPC_Decode, 212, 21, 61, // 146: decode to SUB_MMR6 using decoder 61
3023 // 146: }
3024 7, 6, // 150: case 0x7: {
3025 OPC_CheckPredicate, 3, // 152: check predicate 3
3026 OPC_Decode, 194, 21, 61, // 154: decode to SUBU_MMR6 using decoder 61
3027 // 154: }
3028 9, 6, // 158: case 0x9: {
3029 OPC_CheckPredicate, 3, // 160: check predicate 3
3030 OPC_Decode, 242, 6, 61, // 162: decode to AND_MMR6 using decoder 61
3031 // 162: }
3032 10, 6, // 166: case 0xa: {
3033 OPC_CheckPredicate, 3, // 168: check predicate 3
3034 OPC_Decode, 183, 18, 61, // 170: decode to OR_MMR6 using decoder 61
3035 // 170: }
3036 11, 6, // 174: case 0xb: {
3037 OPC_CheckPredicate, 3, // 176: check predicate 3
3038 OPC_Decode, 170, 18, 61, // 178: decode to NOR_MMR6 using decoder 61
3039 // 178: }
3040 12, 0, // 182: case 0xc: {
3041 OPC_CheckPredicate, 3, // 184: check predicate 3
3042 OPC_Decode, 237, 22, 61, // 186: decode to XOR_MMR6 using decoder 61
3043 // 186: }
3044 // 186: } // switch Inst[10:6]
3045 // 186: }
3046 24, 67, // 190: case 0x18: {
3047 OPC_SwitchField, 6, 5, // 192: switch Inst[10:6] {
3048 0, 6, // 195: case 0x0: {
3049 OPC_CheckPredicate, 3, // 197: check predicate 3
3050 OPC_Decode, 135, 18, 61, // 199: decode to MUL_MMR6 using decoder 61
3051 // 199: }
3052 1, 6, // 203: case 0x1: {
3053 OPC_CheckPredicate, 3, // 205: check predicate 3
3054 OPC_Decode, 223, 17, 61, // 207: decode to MUH_MMR6 using decoder 61
3055 // 207: }
3056 2, 6, // 211: case 0x2: {
3057 OPC_CheckPredicate, 3, // 213: check predicate 3
3058 OPC_Decode, 129, 18, 61, // 215: decode to MULU_MMR6 using decoder 61
3059 // 215: }
3060 3, 6, // 219: case 0x3: {
3061 OPC_CheckPredicate, 3, // 221: check predicate 3
3062 OPC_Decode, 222, 17, 61, // 223: decode to MUHU_MMR6 using decoder 61
3063 // 223: }
3064 4, 6, // 227: case 0x4: {
3065 OPC_CheckPredicate, 3, // 229: check predicate 3
3066 OPC_Decode, 192, 11, 61, // 231: decode to DIV_MMR6 using decoder 61
3067 // 231: }
3068 5, 6, // 235: case 0x5: {
3069 OPC_CheckPredicate, 3, // 237: check predicate 3
3070 OPC_Decode, 230, 16, 61, // 239: decode to MOD_MMR6 using decoder 61
3071 // 239: }
3072 6, 6, // 243: case 0x6: {
3073 OPC_CheckPredicate, 3, // 245: check predicate 3
3074 OPC_Decode, 191, 11, 61, // 247: decode to DIVU_MMR6 using decoder 61
3075 // 247: }
3076 7, 0, // 251: case 0x7: {
3077 OPC_CheckPredicate, 3, // 253: check predicate 3
3078 OPC_Decode, 229, 16, 61, // 255: decode to MODU_MMR6 using decoder 61
3079 // 255: }
3080 // 255: } // switch Inst[10:6]
3081 // 255: }
3082 31, 11, // 259: case 0x1f: {
3083 OPC_CheckPredicate, 3, // 261: check predicate 3
3084 OPC_CheckField, 6, 3, 0, // 263: check Inst[8:6] == 0x0
3085 OPC_Decode, 230, 6, 156, 1, // 267: decode to ALIGN_MMR6 using decoder 156
3086 // 267: }
3087 44, 6, // 272: case 0x2c: {
3088 OPC_CheckPredicate, 3, // 274: check predicate 3
3089 OPC_Decode, 215, 12, 72, // 276: decode to EXT_MMR6 using decoder 72
3090 // 276: }
3091 52, 27, // 280: case 0x34: {
3092 OPC_SwitchField, 6, 5, // 282: switch Inst[10:6] {
3093 3, 10, // 285: case 0x3: {
3094 OPC_CheckPredicate, 3, // 287: check predicate 3
3095 OPC_CheckField, 14, 2, 0, // 289: check Inst[15:14] == 0x0
3096 OPC_Decode, 176, 16, 74, // 293: decode to MFHC0_MMR6 using decoder 74
3097 // 293: }
3098 11, 0, // 297: case 0xb: {
3099 OPC_CheckPredicate, 3, // 299: check predicate 3
3100 OPC_CheckField, 14, 2, 0, // 301: check Inst[15:14] == 0x0
3101 OPC_Decode, 193, 17, 75, // 305: decode to MTHC0_MMR6 using decoder 75
3102 // 305: }
3103 // 305: } // switch Inst[10:6]
3104 // 305: }
3105 60, 211, 2, // 309: case 0x3c: {
3106 OPC_SwitchField, 14, 2, // 312: switch Inst[15:14] {
3107 0, 81, // 315: case 0x0: {
3108 OPC_SwitchField, 6, 5, // 317: switch Inst[10:6] {
3109 3, 6, // 320: case 0x3: {
3110 OPC_CheckPredicate, 3, // 322: check predicate 3
3111 OPC_Decode, 167, 16, 74, // 324: decode to MFC0_MMR6 using decoder 74
3112 // 324: }
3113 5, 27, // 328: case 0x5: {
3114 OPC_SwitchField, 11, 3, // 330: switch Inst[13:11] {
3115 3, 10, // 333: case 0x3: {
3116 OPC_CheckPredicate, 3, // 335: check predicate 3
3117 OPC_CheckField, 21, 5, 0, // 337: check Inst[25:21] == 0x0
3118 OPC_Decode, 169, 12, 99, // 341: decode to DVP_MMR6 using decoder 99
3119 // 341: }
3120 7, 0, // 345: case 0x7: {
3121 OPC_CheckPredicate, 3, // 347: check predicate 3
3122 OPC_CheckField, 21, 5, 0, // 349: check Inst[25:21] == 0x0
3123 OPC_Decode, 186, 12, 99, // 353: decode to EVP_MMR6 using decoder 99
3124 // 353: }
3125 // 353: } // switch Inst[13:11]
3126 // 353: }
3127 11, 6, // 357: case 0xb: {
3128 OPC_CheckPredicate, 3, // 359: check predicate 3
3129 OPC_Decode, 183, 17, 75, // 361: decode to MTC0_MMR6 using decoder 75
3130 // 361: }
3131 12, 10, // 365: case 0xc: {
3132 OPC_CheckPredicate, 3, // 367: check predicate 3
3133 OPC_CheckField, 11, 3, 1, // 369: check Inst[13:11] == 0x1
3134 OPC_Decode, 128, 8, 93, // 373: decode to BITSWAP_MMR6 using decoder 93
3135 // 373: }
3136 28, 0, // 377: case 0x1c: {
3137 OPC_SwitchField, 11, 3, // 379: switch Inst[13:11] {
3138 1, 6, // 382: case 0x1: {
3139 OPC_CheckPredicate, 3, // 384: check predicate 3
3140 OPC_Decode, 195, 14, 86, // 386: decode to JALRC_MMR6 using decoder 86
3141 // 386: }
3142 3, 0, // 390: case 0x3: {
3143 OPC_CheckPredicate, 3, // 392: check predicate 3
3144 OPC_Decode, 194, 14, 86, // 394: decode to JALRC_HB_MMR6 using decoder 86
3145 // 394: }
3146 // 394: } // switch Inst[13:11]
3147 // 394: }
3148 // 394: } // switch Inst[10:6]
3149 // 394: }
3150 1, 155, 1, // 398: case 0x1: {
3151 OPC_SwitchField, 11, 3, // 401: switch Inst[13:11] {
3152 0, 27, // 404: case 0x0: {
3153 OPC_SwitchField, 6, 5, // 406: switch Inst[10:6] {
3154 13, 10, // 409: case 0xd: {
3155 OPC_CheckPredicate, 3, // 411: check predicate 3
3156 OPC_CheckField, 16, 10, 0, // 413: check Inst[25:16] == 0x0
3157 OPC_Decode, 180, 22, 10, // 417: decode to TLBINV_MMR6 using decoder 10
3158 // 417: }
3159 29, 0, // 421: case 0x1d: {
3160 OPC_CheckPredicate, 3, // 423: check predicate 3
3161 OPC_CheckField, 21, 5, 0, // 425: check Inst[25:21] == 0x0
3162 OPC_Decode, 202, 11, 99, // 429: decode to DI_MMR6 using decoder 99
3163 // 429: }
3164 // 429: } // switch Inst[10:6]
3165 // 429: }
3166 1, 19, // 433: case 0x1: {
3167 OPC_SwitchField, 6, 5, // 435: switch Inst[10:6] {
3168 12, 6, // 438: case 0xc: {
3169 OPC_CheckPredicate, 3, // 440: check predicate 3
3170 OPC_Decode, 154, 9, 86, // 442: decode to CLO_MMR6 using decoder 86
3171 // 442: }
3172 20, 0, // 446: case 0x14: {
3173 OPC_CheckPredicate, 3, // 448: check predicate 3
3174 OPC_Decode, 173, 16, 97, // 450: decode to MFC2_MMR6 using decoder 97
3175 // 450: }
3176 // 450: } // switch Inst[10:6]
3177 // 450: }
3178 2, 27, // 454: case 0x2: {
3179 OPC_SwitchField, 6, 5, // 456: switch Inst[10:6] {
3180 13, 10, // 459: case 0xd: {
3181 OPC_CheckPredicate, 3, // 461: check predicate 3
3182 OPC_CheckField, 16, 10, 0, // 463: check Inst[25:16] == 0x0
3183 OPC_Decode, 179, 22, 10, // 467: decode to TLBINVF_MMR6 using decoder 10
3184 // 467: }
3185 29, 0, // 471: case 0x1d: {
3186 OPC_CheckPredicate, 3, // 473: check predicate 3
3187 OPC_CheckField, 21, 5, 0, // 475: check Inst[25:21] == 0x0
3188 OPC_Decode, 177, 12, 99, // 479: decode to EI_MMR6 using decoder 99
3189 // 479: }
3190 // 479: } // switch Inst[10:6]
3191 // 479: }
3192 3, 10, // 483: case 0x3: {
3193 OPC_CheckPredicate, 3, // 485: check predicate 3
3194 OPC_CheckField, 6, 5, 20, // 487: check Inst[10:6] == 0x14
3195 OPC_Decode, 190, 17, 98, // 491: decode to MTC2_MMR6 using decoder 98
3196 // 491: }
3197 4, 14, // 495: case 0x4: {
3198 OPC_CheckPredicate, 25, // 497: check predicate 25
3199 OPC_CheckField, 21, 5, 0, // 499: check Inst[25:21] == 0x0
3200 OPC_CheckField, 6, 5, 5, // 503: check Inst[10:6] == 0x5
3201 OPC_Decode, 142, 14, 99, // 507: decode to GINVI_MMR6 using decoder 99
3202 // 507: }
3203 5, 14, // 511: case 0x5: {
3204 OPC_CheckPredicate, 3, // 513: check predicate 3
3205 OPC_CheckField, 21, 5, 0, // 515: check Inst[25:21] == 0x0
3206 OPC_CheckField, 6, 5, 13, // 519: check Inst[10:6] == 0xd
3207 OPC_Decode, 129, 22, 94, // 523: decode to SYNC_MMR6 using decoder 94
3208 // 523: }
3209 6, 15, // 527: case 0x6: {
3210 OPC_CheckPredicate, 25, // 529: check predicate 25
3211 OPC_CheckField, 21, 5, 0, // 531: check Inst[25:21] == 0x0
3212 OPC_CheckField, 6, 3, 5, // 535: check Inst[8:6] == 0x5
3213 OPC_Decode, 144, 14, 157, 1, // 539: decode to GINVT_MMR6 using decoder 157
3214 // 539: }
3215 7, 0, // 544: case 0x7: {
3216 OPC_CheckPredicate, 3, // 546: check predicate 3
3217 OPC_CheckField, 6, 5, 12, // 548: check Inst[10:6] == 0xc
3218 OPC_Decode, 229, 22, 86, // 552: decode to WSBH_MMR6 using decoder 86
3219 // 552: }
3220 // 552: } // switch Inst[13:11]
3221 // 552: }
3222 2, 27, // 556: case 0x2: {
3223 OPC_SwitchField, 6, 8, // 558: switch Inst[13:6] {
3224 52, 6, // 561: case 0x34: {
3225 OPC_CheckPredicate, 3, // 563: check predicate 3
3226 OPC_Decode, 181, 16, 97, // 565: decode to MFHC2_MMR6 using decoder 97
3227 // 565: }
3228 77, 6, // 569: case 0x4d: {
3229 OPC_CheckPredicate, 3, // 571: check predicate 3
3230 OPC_Decode, 223, 22, 95, // 573: decode to WAIT_MMR6 using decoder 95
3231 // 573: }
3232 116, 0, // 577: case 0x74: {
3233 OPC_CheckPredicate, 3, // 579: check predicate 3
3234 OPC_Decode, 198, 17, 98, // 581: decode to MTHC2_MMR6 using decoder 98
3235 // 581: }
3236 // 581: } // switch Inst[13:6]
3237 // 581: }
3238 3, 0, // 585: case 0x3: {
3239 OPC_SwitchField, 6, 8, // 587: switch Inst[13:6] {
3240 109, 6, // 590: case 0x6d: {
3241 OPC_CheckPredicate, 3, // 592: check predicate 3
3242 OPC_Decode, 213, 19, 95, // 594: decode to SDBBP_MMR6 using decoder 95
3243 // 594: }
3244 133, 1, 6, // 598: case 0x85: {
3245 OPC_CheckPredicate, 3, // 601: check predicate 3
3246 OPC_Decode, 138, 19, 86, // 603: decode to RDPGPR_MMR6 using decoder 86
3247 // 603: }
3248 141, 1, 10, // 607: case 0x8d: {
3249 OPC_CheckPredicate, 3, // 610: check predicate 3
3250 OPC_CheckField, 16, 10, 0, // 612: check Inst[25:16] == 0x0
3251 OPC_Decode, 180, 11, 10, // 616: decode to DERET_MMR6 using decoder 10
3252 // 616: }
3253 197, 1, 6, // 620: case 0xc5: {
3254 OPC_CheckPredicate, 3, // 623: check predicate 3
3255 OPC_Decode, 226, 22, 86, // 625: decode to WRPGPR_MMR6 using decoder 86
3256 // 625: }
3257 205, 1, 0, // 629: case 0xcd: {
3258 OPC_SwitchField, 16, 10, // 632: switch Inst[25:16] {
3259 0, 6, // 635: case 0x0: {
3260 OPC_CheckPredicate, 3, // 637: check predicate 3
3261 OPC_Decode, 183, 12, 10, // 639: decode to ERET_MMR6 using decoder 10
3262 // 639: }
3263 1, 0, // 643: case 0x1: {
3264 OPC_CheckPredicate, 3, // 645: check predicate 3
3265 OPC_Decode, 181, 12, 10, // 647: decode to ERETNC_MMR6 using decoder 10
3266 // 647: }
3267 // 647: } // switch Inst[25:16]
3268 // 647: }
3269 // 647: } // switch Inst[13:6]
3270 // 647: }
3271 // 647: } // switch Inst[15:14]
3272 // 647: }
3273 63, 0, // 651: case 0x3f: {
3274 OPC_CheckPredicate, 3, // 653: check predicate 3
3275 OPC_CheckField, 22, 4, 0, // 655: check Inst[25:22] == 0x0
3276 OPC_Decode, 188, 20, 158, 1, // 659: decode to SIGRIE_MMR6 using decoder 158
3277 // 659: }
3278 // 659: } // switch Inst[5:0]
3279 // 659: }
3280 4, 19, // 664: case 0x4: {
3281 OPC_Scope, 11, // 666: try {
3282 OPC_CheckField, 16, 5, 0, // 668: check Inst[20:16] == 0x0
3283 OPC_CheckPredicate, 3, // 672: check predicate 3
3284 OPC_Decode, 173, 15, 159, 1, // 674: decode to LUI_MMR6 using decoder 159
3285 // 674: } else try {
3286 OPC_CheckPredicate, 3, // 679: check predicate 3
3287 OPC_Decode, 132, 7, 115, // 681: decode to AUI_MMR6 using decoder 115
3288 // 681: }
3289 // 681: }
3290 5, 7, // 685: case 0x5: {
3291 OPC_CheckPredicate, 3, // 687: check predicate 3
3292 OPC_Decode, 239, 14, 160, 1, // 689: decode to LBU_MMR6 using decoder 160
3293 // 689: }
3294 6, 6, // 694: case 0x6: {
3295 OPC_CheckPredicate, 3, // 696: check predicate 3
3296 OPC_Decode, 197, 19, 105, // 698: decode to SB_MMR6 using decoder 105
3297 // 698: }
3298 7, 7, // 702: case 0x7: {
3299 OPC_CheckPredicate, 3, // 704: check predicate 3
3300 OPC_Decode, 241, 14, 160, 1, // 706: decode to LB_MMR6 using decoder 160
3301 // 706: }
3302 8, 63, // 711: case 0x8: {
3303 OPC_SwitchField, 12, 4, // 713: switch Inst[15:12] {
3304 0, 11, // 716: case 0x0: {
3305 OPC_CheckPredicate, 3, // 718: check predicate 3
3306 OPC_CheckField, 11, 1, 0, // 720: check Inst[11] == 0x0
3307 OPC_Decode, 186, 15, 161, 1, // 724: decode to LWC2_MMR6 using decoder 161
3308 // 724: }
3309 2, 11, // 729: case 0x2: {
3310 OPC_CheckPredicate, 3, // 731: check predicate 3
3311 OPC_CheckField, 11, 1, 0, // 733: check Inst[11] == 0x0
3312 OPC_Decode, 254, 14, 161, 1, // 737: decode to LDC2_MMR6 using decoder 161
3313 // 737: }
3314 6, 6, // 742: case 0x6: {
3315 OPC_CheckPredicate, 3, // 744: check predicate 3
3316 OPC_Decode, 231, 8, 107, // 746: decode to CACHE_MMR6 using decoder 107
3317 // 746: }
3318 8, 11, // 750: case 0x8: {
3319 OPC_CheckPredicate, 3, // 752: check predicate 3
3320 OPC_CheckField, 11, 1, 0, // 754: check Inst[11] == 0x0
3321 OPC_Decode, 225, 21, 161, 1, // 758: decode to SWC2_MMR6 using decoder 161
3322 // 758: }
3323 10, 0, // 763: case 0xa: {
3324 OPC_CheckPredicate, 3, // 765: check predicate 3
3325 OPC_CheckField, 11, 1, 0, // 767: check Inst[11] == 0x0
3326 OPC_Decode, 221, 19, 161, 1, // 771: decode to SDC2_MMR6 using decoder 161
3327 // 771: }
3328 // 771: } // switch Inst[15:12]
3329 // 771: }
3330 12, 6, // 776: case 0xc: {
3331 OPC_CheckPredicate, 3, // 778: check predicate 3
3332 OPC_Decode, 162, 6, 104, // 780: decode to ADDIU_MMR6 using decoder 104
3333 // 780: }
3334 14, 6, // 784: case 0xe: {
3335 OPC_CheckPredicate, 3, // 786: check predicate 3
3336 OPC_Decode, 186, 20, 105, // 788: decode to SH_MMR6 using decoder 105
3337 // 788: }
3338 16, 48, // 792: case 0x10: {
3339 OPC_SwitchField, 21, 5, // 794: switch Inst[25:21] {
3340 8, 7, // 797: case 0x8: {
3341 OPC_CheckPredicate, 26, // 799: check predicate 26
3342 OPC_Decode, 172, 7, 162, 1, // 801: decode to BC1EQZC_MMR6 using decoder 162
3343 // 801: }
3344 9, 7, // 806: case 0x9: {
3345 OPC_CheckPredicate, 26, // 808: check predicate 26
3346 OPC_Decode, 177, 7, 162, 1, // 810: decode to BC1NEZC_MMR6 using decoder 162
3347 // 810: }
3348 10, 7, // 815: case 0xa: {
3349 OPC_CheckPredicate, 3, // 817: check predicate 3
3350 OPC_Decode, 182, 7, 163, 1, // 819: decode to BC2EQZC_MMR6 using decoder 163
3351 // 819: }
3352 11, 7, // 824: case 0xb: {
3353 OPC_CheckPredicate, 3, // 826: check predicate 3
3354 OPC_Decode, 184, 7, 163, 1, // 828: decode to BC2NEZC_MMR6 using decoder 163
3355 // 828: }
3356 12, 0, // 833: case 0xc: {
3357 OPC_CheckPredicate, 3, // 835: check predicate 3
3358 OPC_Decode, 255, 21, 164, 1, // 837: decode to SYNCI_MMR6 using decoder 164
3359 // 837: }
3360 // 837: } // switch Inst[25:21]
3361 // 837: }
3362 20, 6, // 842: case 0x14: {
3363 OPC_CheckPredicate, 3, // 844: check predicate 3
3364 OPC_Decode, 181, 18, 115, // 846: decode to ORI_MMR6 using decoder 115
3365 // 846: }
3366 21, 216, 6, // 850: case 0x15: {
3367 OPC_SwitchField, 0, 11, // 853: switch Inst[10:0] {
3368 3, 7, // 856: case 0x3: {
3369 OPC_CheckPredicate, 26, // 858: check predicate 26
3370 OPC_Decode, 219, 16, 165, 1, // 860: decode to MIN_S_MMR6 using decoder 165
3371 // 860: }
3372 5, 7, // 865: case 0x5: {
3373 OPC_CheckPredicate, 26, // 867: check predicate 26
3374 OPC_Decode, 195, 9, 166, 1, // 869: decode to CMP_AF_S_MMR6 using decoder 166
3375 // 869: }
3376 11, 7, // 874: case 0xb: {
3377 OPC_CheckPredicate, 26, // 876: check predicate 26
3378 OPC_Decode, 159, 16, 165, 1, // 878: decode to MAX_S_MMR6 using decoder 165
3379 // 878: }
3380 21, 7, // 883: case 0x15: {
3381 OPC_CheckPredicate, 26, // 885: check predicate 26
3382 OPC_Decode, 194, 9, 167, 1, // 887: decode to CMP_AF_D_MMR6 using decoder 167
3383 // 887: }
3384 32, 11, // 892: case 0x20: {
3385 OPC_CheckPredicate, 3, // 894: check predicate 3
3386 OPC_CheckField, 11, 5, 0, // 896: check Inst[15:11] == 0x0
3387 OPC_Decode, 156, 19, 168, 1, // 900: decode to RINT_S_MMR6 using decoder 168
3388 // 900: }
3389 35, 7, // 905: case 0x23: {
3390 OPC_CheckPredicate, 26, // 907: check predicate 26
3391 OPC_Decode, 200, 16, 165, 1, // 909: decode to MINA_S_MMR6 using decoder 165
3392 // 909: }
3393 43, 7, // 914: case 0x2b: {
3394 OPC_CheckPredicate, 26, // 916: check predicate 26
3395 OPC_Decode, 140, 16, 165, 1, // 918: decode to MAXA_S_MMR6 using decoder 165
3396 // 918: }
3397 48, 7, // 923: case 0x30: {
3398 OPC_CheckPredicate, 26, // 925: check predicate 26
3399 OPC_Decode, 230, 12, 169, 1, // 927: decode to FADD_S_MMR6 using decoder 169
3400 // 927: }
3401 56, 7, // 932: case 0x38: {
3402 OPC_CheckPredicate, 3, // 934: check predicate 3
3403 OPC_Decode, 242, 19, 165, 1, // 936: decode to SELEQZ_S_MMR6 using decoder 165
3404 // 936: }
3405 59, 20, // 941: case 0x3b: {
3406 OPC_SwitchField, 11, 5, // 943: switch Inst[15:11] {
3407 4, 6, // 946: case 0x4: {
3408 OPC_CheckPredicate, 26, // 948: check predicate 26
3409 OPC_Decode, 171, 16, 126, // 950: decode to MFC1_MMR6 using decoder 126
3410 // 950: }
3411 5, 0, // 954: case 0x5: {
3412 OPC_CheckPredicate, 26, // 956: check predicate 26
3413 OPC_Decode, 188, 17, 132, 1, // 958: decode to MTC1_MMR6 using decoder 132
3414 // 958: }
3415 // 958: } // switch Inst[15:11]
3416 // 958: }
3417 69, 7, // 963: case 0x45: {
3418 OPC_CheckPredicate, 26, // 965: check predicate 26
3419 OPC_Decode, 135, 10, 166, 1, // 967: decode to CMP_UN_S_MMR6 using decoder 166
3420 // 967: }
3421 85, 7, // 972: case 0x55: {
3422 OPC_CheckPredicate, 26, // 974: check predicate 26
3423 OPC_Decode, 133, 10, 167, 1, // 976: decode to CMP_UN_D_MMR6 using decoder 167
3424 // 976: }
3425 96, 11, // 981: case 0x60: {
3426 OPC_CheckPredicate, 3, // 983: check predicate 3
3427 OPC_CheckField, 11, 5, 0, // 985: check Inst[15:11] == 0x0
3428 OPC_Decode, 135, 9, 168, 1, // 989: decode to CLASS_S_MMR6 using decoder 168
3429 // 989: }
3430 112, 7, // 994: case 0x70: {
3431 OPC_CheckPredicate, 26, // 996: check predicate 26
3432 OPC_Decode, 247, 13, 169, 1, // 998: decode to FSUB_S_MMR6 using decoder 169
3433 // 998: }
3434 120, 7, // 1003: case 0x78: {
3435 OPC_CheckPredicate, 3, // 1005: check predicate 3
3436 OPC_Decode, 249, 19, 165, 1, // 1007: decode to SELNEZ_S_MMR6 using decoder 165
3437 // 1007: }
3438 123, 21, // 1012: case 0x7b: {
3439 OPC_SwitchField, 11, 5, // 1014: switch Inst[15:11] {
3440 0, 7, // 1017: case 0x0: {
3441 OPC_CheckPredicate, 26, // 1019: check predicate 26
3442 OPC_Decode, 192, 13, 131, 1, // 1021: decode to FMOV_S_MMR6 using decoder 131
3443 // 1021: }
3444 4, 0, // 1026: case 0x4: {
3445 OPC_CheckPredicate, 26, // 1028: check predicate 26
3446 OPC_Decode, 189, 13, 129, 1, // 1030: decode to FMOV_D_MMR6 using decoder 129
3447 // 1030: }
3448 // 1030: } // switch Inst[15:11]
3449 // 1030: }
3450 133, 1, 7, // 1035: case 0x85: {
3451 OPC_CheckPredicate, 26, // 1038: check predicate 26
3452 OPC_Decode, 201, 9, 166, 1, // 1040: decode to CMP_EQ_S_MMR6 using decoder 166
3453 // 1040: }
3454 149, 1, 7, // 1045: case 0x95: {
3455 OPC_CheckPredicate, 26, // 1048: check predicate 26
3456 OPC_Decode, 197, 9, 167, 1, // 1050: decode to CMP_EQ_D_MMR6 using decoder 167
3457 // 1050: }
3458 176, 1, 7, // 1055: case 0xb0: {
3459 OPC_CheckPredicate, 26, // 1058: check predicate 26
3460 OPC_Decode, 203, 13, 169, 1, // 1060: decode to FMUL_S_MMR6 using decoder 169
3461 // 1060: }
3462 184, 1, 7, // 1065: case 0xb8: {
3463 OPC_CheckPredicate, 3, // 1068: check predicate 3
3464 OPC_Decode, 253, 19, 170, 1, // 1070: decode to SEL_S_MMR6 using decoder 170
3465 // 1070: }
3466 197, 1, 7, // 1075: case 0xc5: {
3467 OPC_CheckPredicate, 26, // 1078: check predicate 26
3468 OPC_Decode, 251, 9, 166, 1, // 1080: decode to CMP_UEQ_S_MMR6 using decoder 166
3469 // 1080: }
3470 213, 1, 7, // 1085: case 0xd5: {
3471 OPC_CheckPredicate, 26, // 1088: check predicate 26
3472 OPC_Decode, 249, 9, 167, 1, // 1090: decode to CMP_UEQ_D_MMR6 using decoder 167
3473 // 1090: }
3474 240, 1, 7, // 1095: case 0xf0: {
3475 OPC_CheckPredicate, 26, // 1098: check predicate 26
3476 OPC_Decode, 140, 13, 169, 1, // 1100: decode to FDIV_S_MMR6 using decoder 169
3477 // 1100: }
3478 133, 2, 7, // 1105: case 0x105: {
3479 OPC_CheckPredicate, 26, // 1108: check predicate 26
3480 OPC_Decode, 215, 9, 166, 1, // 1110: decode to CMP_LT_S_MMR6 using decoder 166
3481 // 1110: }
3482 149, 2, 7, // 1115: case 0x115: {
3483 OPC_CheckPredicate, 26, // 1118: check predicate 26
3484 OPC_Decode, 211, 9, 167, 1, // 1120: decode to CMP_LT_D_MMR6 using decoder 167
3485 // 1120: }
3486 187, 2, 30, // 1125: case 0x13b: {
3487 OPC_SwitchField, 11, 5, // 1128: switch Inst[15:11] {
3488 0, 7, // 1131: case 0x0: {
3489 OPC_CheckPredicate, 26, // 1133: check predicate 26
3490 OPC_Decode, 170, 10, 128, 1, // 1135: decode to CVT_L_S_MMR6 using decoder 128
3491 // 1135: }
3492 1, 7, // 1140: case 0x1: {
3493 OPC_CheckPredicate, 26, // 1142: check predicate 26
3494 OPC_Decode, 191, 10, 131, 1, // 1144: decode to CVT_W_S_MMR6 using decoder 131
3495 // 1144: }
3496 8, 0, // 1149: case 0x8: {
3497 OPC_CheckPredicate, 26, // 1151: check predicate 26
3498 OPC_Decode, 167, 10, 129, 1, // 1153: decode to CVT_L_D_MMR6 using decoder 129
3499 // 1153: }
3500 // 1153: } // switch Inst[15:11]
3501 // 1153: }
3502 197, 2, 7, // 1158: case 0x145: {
3503 OPC_CheckPredicate, 26, // 1161: check predicate 26
3504 OPC_Decode, 131, 10, 166, 1, // 1163: decode to CMP_ULT_S_MMR6 using decoder 166
3505 // 1163: }
3506 213, 2, 7, // 1168: case 0x155: {
3507 OPC_CheckPredicate, 26, // 1171: check predicate 26
3508 OPC_Decode, 129, 10, 167, 1, // 1173: decode to CMP_ULT_D_MMR6 using decoder 167
3509 // 1173: }
3510 133, 3, 7, // 1178: case 0x185: {
3511 OPC_CheckPredicate, 26, // 1181: check predicate 26
3512 OPC_Decode, 209, 9, 166, 1, // 1183: decode to CMP_LE_S_MMR6 using decoder 166
3513 // 1183: }
3514 149, 3, 7, // 1188: case 0x195: {
3515 OPC_CheckPredicate, 26, // 1191: check predicate 26
3516 OPC_Decode, 205, 9, 167, 1, // 1193: decode to CMP_LE_D_MMR6 using decoder 167
3517 // 1193: }
3518 184, 3, 7, // 1198: case 0x1b8: {
3519 OPC_CheckPredicate, 26, // 1201: check predicate 26
3520 OPC_Decode, 236, 15, 171, 1, // 1203: decode to MADDF_S_MMR6 using decoder 171
3521 // 1203: }
3522 197, 3, 7, // 1208: case 0x1c5: {
3523 OPC_CheckPredicate, 26, // 1211: check predicate 26
3524 OPC_Decode, 255, 9, 166, 1, // 1213: decode to CMP_ULE_S_MMR6 using decoder 166
3525 // 1213: }
3526 213, 3, 7, // 1218: case 0x1d5: {
3527 OPC_CheckPredicate, 26, // 1221: check predicate 26
3528 OPC_Decode, 253, 9, 167, 1, // 1223: decode to CMP_ULE_D_MMR6 using decoder 167
3529 // 1223: }
3530 248, 3, 7, // 1228: case 0x1f8: {
3531 OPC_CheckPredicate, 26, // 1231: check predicate 26
3532 OPC_Decode, 160, 17, 171, 1, // 1233: decode to MSUBF_S_MMR6 using decoder 171
3533 // 1233: }
3534 131, 4, 7, // 1238: case 0x203: {
3535 OPC_CheckPredicate, 26, // 1241: check predicate 26
3536 OPC_Decode, 214, 16, 152, 1, // 1243: decode to MIN_D_MMR6 using decoder 152
3537 // 1243: }
3538 133, 4, 7, // 1248: case 0x205: {
3539 OPC_CheckPredicate, 26, // 1251: check predicate 26
3540 OPC_Decode, 219, 9, 166, 1, // 1253: decode to CMP_SAF_S_MMR6 using decoder 166
3541 // 1253: }
3542 139, 4, 7, // 1258: case 0x20b: {
3543 OPC_CheckPredicate, 26, // 1261: check predicate 26
3544 OPC_Decode, 154, 16, 152, 1, // 1263: decode to MAX_D_MMR6 using decoder 152
3545 // 1263: }
3546 149, 4, 7, // 1268: case 0x215: {
3547 OPC_CheckPredicate, 26, // 1271: check predicate 26
3548 OPC_Decode, 217, 9, 167, 1, // 1273: decode to CMP_SAF_D_MMR6 using decoder 167
3549 // 1273: }
3550 160, 4, 11, // 1278: case 0x220: {
3551 OPC_CheckPredicate, 3, // 1281: check predicate 3
3552 OPC_CheckField, 11, 5, 0, // 1283: check Inst[15:11] == 0x0
3553 OPC_Decode, 154, 19, 172, 1, // 1287: decode to RINT_D_MMR6 using decoder 172
3554 // 1287: }
3555 163, 4, 7, // 1292: case 0x223: {
3556 OPC_CheckPredicate, 26, // 1295: check predicate 26
3557 OPC_Decode, 198, 16, 152, 1, // 1297: decode to MINA_D_MMR6 using decoder 152
3558 // 1297: }
3559 171, 4, 7, // 1302: case 0x22b: {
3560 OPC_CheckPredicate, 26, // 1305: check predicate 26
3561 OPC_Decode, 138, 16, 152, 1, // 1307: decode to MAXA_D_MMR6 using decoder 152
3562 // 1307: }
3563 184, 4, 7, // 1312: case 0x238: {
3564 OPC_CheckPredicate, 3, // 1315: check predicate 3
3565 OPC_Decode, 239, 19, 152, 1, // 1317: decode to SELEQZ_D_MMR6 using decoder 152
3566 // 1317: }
3567 197, 4, 7, // 1322: case 0x245: {
3568 OPC_CheckPredicate, 26, // 1325: check predicate 26
3569 OPC_Decode, 247, 9, 166, 1, // 1327: decode to CMP_SUN_S_MMR6 using decoder 166
3570 // 1327: }
3571 213, 4, 7, // 1332: case 0x255: {
3572 OPC_CheckPredicate, 26, // 1335: check predicate 26
3573 OPC_Decode, 245, 9, 167, 1, // 1337: decode to CMP_SUN_D_MMR6 using decoder 167
3574 // 1337: }
3575 224, 4, 11, // 1342: case 0x260: {
3576 OPC_CheckPredicate, 3, // 1345: check predicate 3
3577 OPC_CheckField, 11, 5, 0, // 1347: check Inst[15:11] == 0x0
3578 OPC_Decode, 133, 9, 172, 1, // 1351: decode to CLASS_D_MMR6 using decoder 172
3579 // 1351: }
3580 248, 4, 7, // 1356: case 0x278: {
3581 OPC_CheckPredicate, 3, // 1359: check predicate 3
3582 OPC_Decode, 246, 19, 152, 1, // 1361: decode to SELNEZ_D_MMR6 using decoder 152
3583 // 1361: }
3584 133, 5, 7, // 1366: case 0x285: {
3585 OPC_CheckPredicate, 26, // 1369: check predicate 26
3586 OPC_Decode, 223, 9, 166, 1, // 1371: decode to CMP_SEQ_S_MMR6 using decoder 166
3587 // 1371: }
3588 149, 5, 7, // 1376: case 0x295: {
3589 OPC_CheckPredicate, 26, // 1379: check predicate 26
3590 OPC_Decode, 221, 9, 167, 1, // 1381: decode to CMP_SEQ_D_MMR6 using decoder 167
3591 // 1381: }
3592 184, 5, 7, // 1386: case 0x2b8: {
3593 OPC_CheckPredicate, 3, // 1389: check predicate 3
3594 OPC_Decode, 251, 19, 173, 1, // 1391: decode to SEL_D_MMR6 using decoder 173
3595 // 1391: }
3596 197, 5, 7, // 1396: case 0x2c5: {
3597 OPC_CheckPredicate, 26, // 1399: check predicate 26
3598 OPC_Decode, 235, 9, 166, 1, // 1401: decode to CMP_SUEQ_S_MMR6 using decoder 166
3599 // 1401: }
3600 213, 5, 7, // 1406: case 0x2d5: {
3601 OPC_CheckPredicate, 26, // 1409: check predicate 26
3602 OPC_Decode, 233, 9, 167, 1, // 1411: decode to CMP_SUEQ_D_MMR6 using decoder 167
3603 // 1411: }
3604 133, 6, 7, // 1416: case 0x305: {
3605 OPC_CheckPredicate, 26, // 1419: check predicate 26
3606 OPC_Decode, 231, 9, 166, 1, // 1421: decode to CMP_SLT_S_MMR6 using decoder 166
3607 // 1421: }
3608 149, 6, 7, // 1426: case 0x315: {
3609 OPC_CheckPredicate, 26, // 1429: check predicate 26
3610 OPC_Decode, 229, 9, 167, 1, // 1431: decode to CMP_SLT_D_MMR6 using decoder 167
3611 // 1431: }
3612 187, 6, 147, 1, // 1436: case 0x33b: {
3613 OPC_SwitchField, 11, 5, // 1440: switch Inst[15:11] {
3614 0, 7, // 1443: case 0x0: {
3615 OPC_CheckPredicate, 26, // 1445: check predicate 26
3616 OPC_Decode, 167, 13, 128, 1, // 1447: decode to FLOOR_L_S_MMR6 using decoder 128
3617 // 1447: }
3618 1, 7, // 1452: case 0x1: {
3619 OPC_CheckPredicate, 26, // 1454: check predicate 26
3620 OPC_Decode, 174, 13, 131, 1, // 1456: decode to FLOOR_W_S_MMR6 using decoder 131
3621 // 1456: }
3622 2, 7, // 1461: case 0x2: {
3623 OPC_CheckPredicate, 26, // 1463: check predicate 26
3624 OPC_Decode, 236, 8, 128, 1, // 1465: decode to CEIL_L_S_MMR6 using decoder 128
3625 // 1465: }
3626 3, 7, // 1470: case 0x3: {
3627 OPC_CheckPredicate, 26, // 1472: check predicate 26
3628 OPC_Decode, 243, 8, 131, 1, // 1474: decode to CEIL_W_S_MMR6 using decoder 131
3629 // 1474: }
3630 4, 7, // 1479: case 0x4: {
3631 OPC_CheckPredicate, 26, // 1481: check predicate 26
3632 OPC_Decode, 203, 22, 128, 1, // 1483: decode to TRUNC_L_S_MMR6 using decoder 128
3633 // 1483: }
3634 5, 7, // 1488: case 0x5: {
3635 OPC_CheckPredicate, 26, // 1490: check predicate 26
3636 OPC_Decode, 210, 22, 131, 1, // 1492: decode to TRUNC_W_S_MMR6 using decoder 131
3637 // 1492: }
3638 6, 7, // 1497: case 0x6: {
3639 OPC_CheckPredicate, 26, // 1499: check predicate 26
3640 OPC_Decode, 164, 19, 128, 1, // 1501: decode to ROUND_L_S_MMR6 using decoder 128
3641 // 1501: }
3642 7, 7, // 1506: case 0x7: {
3643 OPC_CheckPredicate, 26, // 1508: check predicate 26
3644 OPC_Decode, 171, 19, 131, 1, // 1510: decode to ROUND_W_S_MMR6 using decoder 131
3645 // 1510: }
3646 8, 7, // 1515: case 0x8: {
3647 OPC_CheckPredicate, 26, // 1517: check predicate 26
3648 OPC_Decode, 165, 13, 129, 1, // 1519: decode to FLOOR_L_D_MMR6 using decoder 129
3649 // 1519: }
3650 9, 7, // 1524: case 0x9: {
3651 OPC_CheckPredicate, 26, // 1526: check predicate 26
3652 OPC_Decode, 170, 13, 133, 1, // 1528: decode to FLOOR_W_D_MMR6 using decoder 133
3653 // 1528: }
3654 10, 7, // 1533: case 0xa: {
3655 OPC_CheckPredicate, 26, // 1535: check predicate 26
3656 OPC_Decode, 234, 8, 129, 1, // 1537: decode to CEIL_L_D_MMR6 using decoder 129
3657 // 1537: }
3658 11, 7, // 1542: case 0xb: {
3659 OPC_CheckPredicate, 26, // 1544: check predicate 26
3660 OPC_Decode, 239, 8, 133, 1, // 1546: decode to CEIL_W_D_MMR6 using decoder 133
3661 // 1546: }
3662 12, 7, // 1551: case 0xc: {
3663 OPC_CheckPredicate, 26, // 1553: check predicate 26
3664 OPC_Decode, 201, 22, 129, 1, // 1555: decode to TRUNC_L_D_MMR6 using decoder 129
3665 // 1555: }
3666 13, 7, // 1560: case 0xd: {
3667 OPC_CheckPredicate, 26, // 1562: check predicate 26
3668 OPC_Decode, 206, 22, 153, 1, // 1564: decode to TRUNC_W_D_MMR6 using decoder 153
3669 // 1564: }
3670 14, 7, // 1569: case 0xe: {
3671 OPC_CheckPredicate, 26, // 1571: check predicate 26
3672 OPC_Decode, 162, 19, 129, 1, // 1573: decode to ROUND_L_D_MMR6 using decoder 129
3673 // 1573: }
3674 15, 0, // 1578: case 0xf: {
3675 OPC_CheckPredicate, 26, // 1580: check predicate 26
3676 OPC_Decode, 167, 19, 129, 1, // 1582: decode to ROUND_W_D_MMR6 using decoder 129
3677 // 1582: }
3678 // 1582: } // switch Inst[15:11]
3679 // 1582: }
3680 197, 6, 7, // 1587: case 0x345: {
3681 OPC_CheckPredicate, 26, // 1590: check predicate 26
3682 OPC_Decode, 243, 9, 166, 1, // 1592: decode to CMP_SULT_S_MMR6 using decoder 166
3683 // 1592: }
3684 213, 6, 7, // 1597: case 0x355: {
3685 OPC_CheckPredicate, 26, // 1600: check predicate 26
3686 OPC_Decode, 241, 9, 167, 1, // 1602: decode to CMP_SULT_D_MMR6 using decoder 167
3687 // 1602: }
3688 251, 6, 39, // 1607: case 0x37b: {
3689 OPC_SwitchField, 11, 5, // 1610: switch Inst[15:11] {
3690 1, 7, // 1613: case 0x1: {
3691 OPC_CheckPredicate, 26, // 1615: check predicate 26
3692 OPC_Decode, 211, 13, 131, 1, // 1617: decode to FNEG_S_MMR6 using decoder 131
3693 // 1617: }
3694 7, 7, // 1622: case 0x7: {
3695 OPC_CheckPredicate, 26, // 1624: check predicate 26
3696 OPC_Decode, 184, 10, 131, 1, // 1626: decode to CVT_S_W_MMR6 using decoder 131
3697 // 1626: }
3698 10, 7, // 1631: case 0xa: {
3699 OPC_CheckPredicate, 24, // 1633: check predicate 24
3700 OPC_Decode, 164, 10, 129, 1, // 1635: decode to CVT_D_L_MMR6 using decoder 129
3701 // 1635: }
3702 11, 0, // 1640: case 0xb: {
3703 OPC_CheckPredicate, 24, // 1642: check predicate 24
3704 OPC_Decode, 179, 10, 128, 1, // 1644: decode to CVT_S_L_MMR6 using decoder 128
3705 // 1644: }
3706 // 1644: } // switch Inst[15:11]
3707 // 1644: }
3708 133, 7, 7, // 1649: case 0x385: {
3709 OPC_CheckPredicate, 26, // 1652: check predicate 26
3710 OPC_Decode, 227, 9, 166, 1, // 1654: decode to CMP_SLE_S_MMR6 using decoder 166
3711 // 1654: }
3712 149, 7, 7, // 1659: case 0x395: {
3713 OPC_CheckPredicate, 26, // 1662: check predicate 26
3714 OPC_Decode, 225, 9, 167, 1, // 1664: decode to CMP_SLE_D_MMR6 using decoder 167
3715 // 1664: }
3716 184, 7, 7, // 1669: case 0x3b8: {
3717 OPC_CheckPredicate, 26, // 1672: check predicate 26
3718 OPC_Decode, 234, 15, 174, 1, // 1674: decode to MADDF_D_MMR6 using decoder 174
3719 // 1674: }
3720 197, 7, 7, // 1679: case 0x3c5: {
3721 OPC_CheckPredicate, 26, // 1682: check predicate 26
3722 OPC_Decode, 239, 9, 166, 1, // 1684: decode to CMP_SULE_S_MMR6 using decoder 166
3723 // 1684: }
3724 213, 7, 7, // 1689: case 0x3d5: {
3725 OPC_CheckPredicate, 26, // 1692: check predicate 26
3726 OPC_Decode, 237, 9, 167, 1, // 1694: decode to CMP_SULE_D_MMR6 using decoder 167
3727 // 1694: }
3728 248, 7, 0, // 1699: case 0x3f8: {
3729 OPC_CheckPredicate, 26, // 1702: check predicate 26
3730 OPC_Decode, 158, 17, 174, 1, // 1704: decode to MSUBF_D_MMR6 using decoder 174
3731 // 1704: }
3732 // 1704: } // switch Inst[10:0]
3733 // 1704: }
3734 24, 37, // 1709: case 0x18: {
3735 OPC_SwitchField, 12, 4, // 1711: switch Inst[15:12] {
3736 2, 6, // 1714: case 0x2: {
3737 OPC_CheckPredicate, 3, // 1716: check predicate 3
3738 OPC_Decode, 252, 18, 107, // 1718: decode to PREF_MMR6 using decoder 107
3739 // 1718: }
3740 3, 11, // 1722: case 0x3: {
3741 OPC_CheckPredicate, 3, // 1724: check predicate 3
3742 OPC_CheckField, 9, 3, 0, // 1726: check Inst[11:9] == 0x0
3743 OPC_Decode, 168, 15, 141, 1, // 1730: decode to LL_MMR6 using decoder 141
3744 // 1730: }
3745 11, 0, // 1735: case 0xb: {
3746 OPC_CheckPredicate, 3, // 1737: check predicate 3
3747 OPC_CheckField, 9, 3, 0, // 1739: check Inst[11:9] == 0x0
3748 OPC_Decode, 206, 19, 141, 1, // 1743: decode to SC_MMR6 using decoder 141
3749 // 1743: }
3750 // 1743: } // switch Inst[15:12]
3751 // 1743: }
3752 28, 6, // 1748: case 0x1c: {
3753 OPC_CheckPredicate, 3, // 1750: check predicate 3
3754 OPC_Decode, 235, 22, 115, // 1752: decode to XORI_MMR6 using decoder 115
3755 // 1752: }
3756 29, 20, // 1756: case 0x1d: {
3757 OPC_Scope, 11, // 1758: try {
3758 OPC_CheckField, 16, 5, 0, // 1760: check Inst[20:16] == 0x0
3759 OPC_CheckPredicate, 3, // 1764: check predicate 3
3760 OPC_Decode, 202, 7, 175, 1, // 1766: decode to BEQZALC_MMR6 using decoder 175
3761 // 1766: } else try {
3762 OPC_CheckPredicate, 3, // 1771: check predicate 3
3763 OPC_Decode, 198, 7, 175, 1, // 1773: decode to BEQC_MMR6 using decoder 175
3764 // 1773: }
3765 // 1773: }
3766 30, 44, // 1778: case 0x1e: {
3767 OPC_SwitchField, 19, 2, // 1780: switch Inst[20:19] {
3768 0, 7, // 1783: case 0x0: {
3769 OPC_CheckPredicate, 3, // 1785: check predicate 3
3770 OPC_Decode, 157, 6, 176, 1, // 1787: decode to ADDIUPC_MMR6 using decoder 176
3771 // 1787: }
3772 1, 7, // 1792: case 0x1: {
3773 OPC_CheckPredicate, 3, // 1794: check predicate 3
3774 OPC_Decode, 203, 15, 176, 1, // 1796: decode to LWPC_MMR6 using decoder 176
3775 // 1796: }
3776 3, 0, // 1801: case 0x3: {
3777 OPC_SwitchField, 16, 3, // 1803: switch Inst[18:16] {
3778 6, 7, // 1806: case 0x6: {
3779 OPC_CheckPredicate, 3, // 1808: check predicate 3
3780 OPC_Decode, 131, 7, 177, 1, // 1810: decode to AUIPC_MMR6 using decoder 177
3781 // 1810: }
3782 7, 0, // 1815: case 0x7: {
3783 OPC_CheckPredicate, 3, // 1817: check predicate 3
3784 OPC_Decode, 232, 6, 177, 1, // 1819: decode to ALUIPC_MMR6 using decoder 177
3785 // 1819: }
3786 // 1819: } // switch Inst[18:16]
3787 // 1819: }
3788 // 1819: } // switch Inst[20:19]
3789 // 1819: }
3790 31, 20, // 1824: case 0x1f: {
3791 OPC_Scope, 11, // 1826: try {
3792 OPC_CheckField, 16, 5, 0, // 1828: check Inst[20:16] == 0x0
3793 OPC_CheckPredicate, 3, // 1832: check predicate 3
3794 OPC_Decode, 177, 8, 178, 1, // 1834: decode to BNEZALC_MMR6 using decoder 178
3795 // 1834: } else try {
3796 OPC_CheckPredicate, 3, // 1839: check predicate 3
3797 OPC_Decode, 165, 8, 178, 1, // 1841: decode to BNEC_MMR6 using decoder 178
3798 // 1841: }
3799 // 1841: }
3800 32, 19, // 1846: case 0x20: {
3801 OPC_Scope, 10, // 1848: try {
3802 OPC_CheckField, 21, 5, 0, // 1850: check Inst[25:21] == 0x0
3803 OPC_CheckPredicate, 3, // 1854: check predicate 3
3804 OPC_Decode, 208, 14, 110, // 1856: decode to JIALC_MMR6 using decoder 110
3805 // 1856: } else try {
3806 OPC_CheckPredicate, 3, // 1860: check predicate 3
3807 OPC_Decode, 207, 7, 179, 1, // 1862: decode to BEQZC_MMR6 using decoder 179
3808 // 1862: }
3809 // 1862: }
3810 37, 7, // 1867: case 0x25: {
3811 OPC_CheckPredicate, 3, // 1869: check predicate 3
3812 OPC_Decode, 193, 7, 180, 1, // 1871: decode to BC_MMR6 using decoder 180
3813 // 1871: }
3814 40, 19, // 1876: case 0x28: {
3815 OPC_Scope, 10, // 1878: try {
3816 OPC_CheckField, 21, 5, 0, // 1880: check Inst[25:21] == 0x0
3817 OPC_CheckPredicate, 3, // 1884: check predicate 3
3818 OPC_Decode, 211, 14, 110, // 1886: decode to JIC_MMR6 using decoder 110
3819 // 1886: } else try {
3820 OPC_CheckPredicate, 3, // 1890: check predicate 3
3821 OPC_Decode, 182, 8, 179, 1, // 1892: decode to BNEZC_MMR6 using decoder 179
3822 // 1892: }
3823 // 1892: }
3824 45, 7, // 1897: case 0x2d: {
3825 OPC_CheckPredicate, 3, // 1899: check predicate 3
3826 OPC_Decode, 162, 7, 180, 1, // 1901: decode to BALC_MMR6 using decoder 180
3827 // 1901: }
3828 48, 7, // 1906: case 0x30: {
3829 OPC_CheckPredicate, 3, // 1908: check predicate 3
3830 OPC_Decode, 214, 7, 181, 1, // 1910: decode to BGEUC_MMR6 using decoder 181
3831 // 1910: }
3832 52, 6, // 1915: case 0x34: {
3833 OPC_CheckPredicate, 3, // 1917: check predicate 3
3834 OPC_Decode, 240, 6, 115, // 1919: decode to ANDI_MMR6 using decoder 115
3835 // 1919: }
3836 53, 7, // 1923: case 0x35: {
3837 OPC_CheckPredicate, 3, // 1925: check predicate 3
3838 OPC_Decode, 140, 8, 182, 1, // 1927: decode to BLTC_MMR6 using decoder 182
3839 // 1927: }
3840 56, 7, // 1932: case 0x38: {
3841 OPC_CheckPredicate, 3, // 1934: check predicate 3
3842 OPC_Decode, 143, 8, 183, 1, // 1936: decode to BLTUC_MMR6 using decoder 183
3843 // 1936: }
3844 61, 7, // 1941: case 0x3d: {
3845 OPC_CheckPredicate, 3, // 1943: check predicate 3
3846 OPC_Decode, 211, 7, 184, 1, // 1945: decode to BGEC_MMR6 using decoder 184
3847 // 1945: }
3848 62, 6, // 1950: case 0x3e: {
3849 OPC_CheckPredicate, 3, // 1952: check predicate 3
3850 OPC_Decode, 251, 21, 105, // 1954: decode to SW_MMR6 using decoder 105
3851 // 1954: }
3852 63, 0, // 1958: case 0x3f: {
3853 OPC_CheckPredicate, 3, // 1960: check predicate 3
3854 OPC_Decode, 219, 15, 105, // 1962: decode to LW_MMR6 using decoder 105
3855 // 1962: }
3856 // 1962: } // switch Inst[31:26]
3857};
3858static const uint8_t DecoderTableMicroMipsR6_Ambiguous32[65] = {
3859 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
3860 29, 7, // 3: case 0x1d: {
3861 OPC_CheckPredicate, 3, // 5: check predicate 3
3862 OPC_Decode, 192, 8, 175, 1, // 7: decode to BOVC_MMR6 using decoder 175
3863 // 7: }
3864 31, 7, // 12: case 0x1f: {
3865 OPC_CheckPredicate, 3, // 14: check predicate 3
3866 OPC_Decode, 185, 8, 178, 1, // 16: decode to BNVC_MMR6 using decoder 178
3867 // 16: }
3868 48, 20, // 21: case 0x30: {
3869 OPC_Scope, 11, // 23: try {
3870 OPC_CheckField, 16, 5, 0, // 25: check Inst[20:16] == 0x0
3871 OPC_CheckPredicate, 3, // 29: check predicate 3
3872 OPC_Decode, 132, 8, 181, 1, // 31: decode to BLEZALC_MMR6 using decoder 181
3873 // 31: } else try {
3874 OPC_CheckPredicate, 3, // 36: check predicate 3
3875 OPC_Decode, 219, 7, 181, 1, // 38: decode to BGEZALC_MMR6 using decoder 181
3876 // 38: }
3877 // 38: }
3878 56, 0, // 43: case 0x38: {
3879 OPC_Scope, 11, // 45: try {
3880 OPC_CheckField, 16, 5, 0, // 47: check Inst[20:16] == 0x0
3881 OPC_CheckPredicate, 3, // 51: check predicate 3
3882 OPC_Decode, 231, 7, 183, 1, // 53: decode to BGTZALC_MMR6 using decoder 183
3883 // 53: } else try {
3884 OPC_CheckPredicate, 3, // 58: check predicate 3
3885 OPC_Decode, 148, 8, 183, 1, // 60: decode to BLTZALC_MMR6 using decoder 183
3886 // 60: }
3887 // 60: }
3888 // 60: } // switch Inst[31:26]
3889};
3890static const uint8_t DecoderTableMips32[10270] = {
3891 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
3892 0, 159, 5, // 3: case 0x0: {
3893 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
3894 0, 40, // 9: case 0x0: {
3895 OPC_CheckField, 21, 5, 0, // 11: check Inst[25:21] == 0x0
3896 OPC_Scope, 27, // 15: try {
3897 OPC_SwitchField, 6, 15, // 17: switch Inst[20:6] {
3898 1, 6, // 20: case 0x1: {
3899 OPC_CheckPredicate, 27, // 22: check predicate 27
3900 OPC_Decode, 150, 21, 10, // 24: decode to SSNOP using decoder 10
3901 // 24: }
3902 3, 6, // 28: case 0x3: {
3903 OPC_CheckPredicate, 27, // 30: check predicate 27
3904 OPC_Decode, 172, 12, 10, // 32: decode to EHB using decoder 10
3905 // 32: }
3906 5, 0, // 36: case 0x5: {
3907 OPC_CheckPredicate, 28, // 38: check predicate 28
3908 OPC_Decode, 191, 18, 10, // 40: decode to PAUSE using decoder 10
3909 // 40: }
3910 // 40: } // switch Inst[20:6]
3911 // 40: } else try {
3912 OPC_CheckPredicate, 27, // 44: check predicate 27
3913 OPC_Decode, 197, 20, 185, 1, // 46: decode to SLL using decoder 185
3914 // 46: }
3915 // 46: }
3916 1, 29, // 51: case 0x1: {
3917 OPC_SwitchField, 16, 2, // 53: switch Inst[17:16] {
3918 0, 11, // 56: case 0x0: {
3919 OPC_CheckPredicate, 29, // 58: check predicate 29
3920 OPC_CheckField, 6, 5, 0, // 60: check Inst[10:6] == 0x0
3921 OPC_Decode, 247, 16, 186, 1, // 64: decode to MOVF_I using decoder 186
3922 // 64: }
3923 1, 0, // 69: case 0x1: {
3924 OPC_CheckPredicate, 29, // 71: check predicate 29
3925 OPC_CheckField, 6, 5, 0, // 73: check Inst[10:6] == 0x0
3926 OPC_Decode, 139, 17, 186, 1, // 77: decode to MOVT_I using decoder 186
3927 // 77: }
3928 // 77: } // switch Inst[17:16]
3929 // 77: }
3930 2, 21, // 82: case 0x2: {
3931 OPC_SwitchField, 21, 5, // 84: switch Inst[25:21] {
3932 0, 7, // 87: case 0x0: {
3933 OPC_CheckPredicate, 27, // 89: check predicate 27
3934 OPC_Decode, 128, 21, 185, 1, // 91: decode to SRL using decoder 185
3935 // 91: }
3936 1, 0, // 96: case 0x1: {
3937 OPC_CheckPredicate, 28, // 98: check predicate 28
3938 OPC_Decode, 157, 19, 185, 1, // 100: decode to ROTR using decoder 185
3939 // 100: }
3940 // 100: } // switch Inst[25:21]
3941 // 100: }
3942 3, 11, // 105: case 0x3: {
3943 OPC_CheckPredicate, 27, // 107: check predicate 27
3944 OPC_CheckField, 21, 5, 0, // 109: check Inst[25:21] == 0x0
3945 OPC_Decode, 236, 20, 185, 1, // 113: decode to SRA using decoder 185
3946 // 113: }
3947 4, 10, // 118: case 0x4: {
3948 OPC_CheckPredicate, 27, // 120: check predicate 27
3949 OPC_CheckField, 6, 5, 0, // 122: check Inst[10:6] == 0x0
3950 OPC_Decode, 206, 20, 61, // 126: decode to SLLV using decoder 61
3951 // 126: }
3952 5, 11, // 130: case 0x5: {
3953 OPC_CheckPredicate, 30, // 132: check predicate 30
3954 OPC_CheckField, 8, 3, 0, // 134: check Inst[10:8] == 0x0
3955 OPC_Decode, 170, 15, 187, 1, // 138: decode to LSA using decoder 187
3956 // 138: }
3957 6, 19, // 143: case 0x6: {
3958 OPC_SwitchField, 6, 5, // 145: switch Inst[10:6] {
3959 0, 6, // 148: case 0x0: {
3960 OPC_CheckPredicate, 27, // 150: check predicate 27
3961 OPC_Decode, 143, 21, 61, // 152: decode to SRLV using decoder 61
3962 // 152: }
3963 1, 0, // 156: case 0x1: {
3964 OPC_CheckPredicate, 28, // 158: check predicate 28
3965 OPC_Decode, 158, 19, 61, // 160: decode to ROTRV using decoder 61
3966 // 160: }
3967 // 160: } // switch Inst[10:6]
3968 // 160: }
3969 7, 10, // 164: case 0x7: {
3970 OPC_CheckPredicate, 27, // 166: check predicate 27
3971 OPC_CheckField, 6, 5, 0, // 168: check Inst[10:6] == 0x0
3972 OPC_Decode, 249, 20, 61, // 172: decode to SRAV using decoder 61
3973 // 172: }
3974 8, 21, // 176: case 0x8: {
3975 OPC_SwitchField, 6, 15, // 178: switch Inst[20:6] {
3976 0, 7, // 181: case 0x0: {
3977 OPC_CheckPredicate, 31, // 183: check predicate 31
3978 OPC_Decode, 212, 14, 188, 1, // 185: decode to JR using decoder 188
3979 // 185: }
3980 16, 0, // 190: case 0x10: {
3981 OPC_CheckPredicate, 32, // 192: check predicate 32
3982 OPC_Decode, 219, 14, 188, 1, // 194: decode to JR_HB using decoder 188
3983 // 194: }
3984 // 194: } // switch Inst[20:6]
3985 // 194: }
3986 9, 27, // 199: case 0x9: {
3987 OPC_SwitchField, 6, 5, // 201: switch Inst[10:6] {
3988 0, 10, // 204: case 0x0: {
3989 OPC_CheckPredicate, 33, // 206: check predicate 33
3990 OPC_CheckField, 16, 5, 0, // 208: check Inst[20:16] == 0x0
3991 OPC_Decode, 190, 14, 52, // 212: decode to JALR using decoder 52
3992 // 212: }
3993 16, 0, // 216: case 0x10: {
3994 OPC_CheckPredicate, 34, // 218: check predicate 34
3995 OPC_CheckField, 16, 5, 0, // 220: check Inst[20:16] == 0x0
3996 OPC_Decode, 198, 14, 52, // 224: decode to JALR_HB using decoder 52
3997 // 224: }
3998 // 224: } // switch Inst[10:6]
3999 // 224: }
4000 10, 11, // 228: case 0xa: {
4001 OPC_CheckPredicate, 35, // 230: check predicate 35
4002 OPC_CheckField, 6, 5, 0, // 232: check Inst[10:6] == 0x0
4003 OPC_Decode, 151, 17, 189, 1, // 236: decode to MOVZ_I_I using decoder 189
4004 // 236: }
4005 11, 11, // 241: case 0xb: {
4006 OPC_CheckPredicate, 35, // 243: check predicate 35
4007 OPC_CheckField, 6, 5, 0, // 245: check Inst[10:6] == 0x0
4008 OPC_Decode, 131, 17, 189, 1, // 249: decode to MOVN_I_I using decoder 189
4009 // 249: }
4010 12, 7, // 254: case 0xc: {
4011 OPC_CheckPredicate, 27, // 256: check predicate 27
4012 OPC_Decode, 130, 22, 190, 1, // 258: decode to SYSCALL using decoder 190
4013 // 258: }
4014 13, 6, // 263: case 0xd: {
4015 OPC_CheckPredicate, 27, // 265: check predicate 27
4016 OPC_Decode, 196, 8, 62, // 267: decode to BREAK using decoder 62
4017 // 267: }
4018 15, 7, // 271: case 0xf: {
4019 OPC_CheckPredicate, 36, // 273: check predicate 36
4020 OPC_Decode, 252, 21, 191, 1, // 275: decode to SYNC using decoder 191
4021 // 275: }
4022 16, 32, // 280: case 0x10: {
4023 OPC_CheckField, 6, 5, 0, // 282: check Inst[10:6] == 0x0
4024 OPC_CheckField, 16, 5, 0, // 286: check Inst[20:16] == 0x0
4025 OPC_CheckField, 23, 3, 0, // 290: check Inst[25:23] == 0x0
4026 OPC_Scope, 11, // 294: try {
4027 OPC_CheckField, 21, 2, 0, // 296: check Inst[22:21] == 0x0
4028 OPC_CheckPredicate, 31, // 300: check predicate 31
4029 OPC_Decode, 184, 16, 192, 1, // 302: decode to MFHI using decoder 192
4030 // 302: } else try {
4031 OPC_CheckPredicate, 37, // 307: check predicate 37
4032 OPC_Decode, 187, 16, 193, 1, // 309: decode to MFHI_DSP using decoder 193
4033 // 309: }
4034 // 309: }
4035 17, 28, // 314: case 0x11: {
4036 OPC_CheckField, 6, 5, 0, // 316: check Inst[10:6] == 0x0
4037 OPC_CheckField, 13, 8, 0, // 320: check Inst[20:13] == 0x0
4038 OPC_Scope, 11, // 324: try {
4039 OPC_CheckField, 11, 2, 0, // 326: check Inst[12:11] == 0x0
4040 OPC_CheckPredicate, 31, // 330: check predicate 31
4041 OPC_Decode, 201, 17, 188, 1, // 332: decode to MTHI using decoder 188
4042 // 332: } else try {
4043 OPC_CheckPredicate, 37, // 337: check predicate 37
4044 OPC_Decode, 203, 17, 194, 1, // 339: decode to MTHI_DSP using decoder 194
4045 // 339: }
4046 // 339: }
4047 18, 32, // 344: case 0x12: {
4048 OPC_CheckField, 6, 5, 0, // 346: check Inst[10:6] == 0x0
4049 OPC_CheckField, 16, 5, 0, // 350: check Inst[20:16] == 0x0
4050 OPC_CheckField, 23, 3, 0, // 354: check Inst[25:23] == 0x0
4051 OPC_Scope, 11, // 358: try {
4052 OPC_CheckField, 21, 2, 0, // 360: check Inst[22:21] == 0x0
4053 OPC_CheckPredicate, 31, // 364: check predicate 31
4054 OPC_Decode, 190, 16, 192, 1, // 366: decode to MFLO using decoder 192
4055 // 366: } else try {
4056 OPC_CheckPredicate, 37, // 371: check predicate 37
4057 OPC_Decode, 193, 16, 193, 1, // 373: decode to MFLO_DSP using decoder 193
4058 // 373: }
4059 // 373: }
4060 19, 28, // 378: case 0x13: {
4061 OPC_CheckField, 6, 5, 0, // 380: check Inst[10:6] == 0x0
4062 OPC_CheckField, 13, 8, 0, // 384: check Inst[20:13] == 0x0
4063 OPC_Scope, 11, // 388: try {
4064 OPC_CheckField, 11, 2, 0, // 390: check Inst[12:11] == 0x0
4065 OPC_CheckPredicate, 31, // 394: check predicate 31
4066 OPC_Decode, 208, 17, 188, 1, // 396: decode to MTLO using decoder 188
4067 // 396: } else try {
4068 OPC_CheckPredicate, 37, // 401: check predicate 37
4069 OPC_Decode, 210, 17, 195, 1, // 403: decode to MTLO_DSP using decoder 195
4070 // 403: }
4071 // 403: }
4072 21, 11, // 408: case 0x15: {
4073 OPC_CheckPredicate, 38, // 410: check predicate 38
4074 OPC_CheckField, 8, 3, 0, // 412: check Inst[10:8] == 0x0
4075 OPC_Decode, 203, 11, 196, 1, // 416: decode to DLSA using decoder 196
4076 // 416: }
4077 24, 27, // 421: case 0x18: {
4078 OPC_CheckField, 6, 5, 0, // 423: check Inst[10:6] == 0x0
4079 OPC_CheckField, 13, 3, 0, // 427: check Inst[15:13] == 0x0
4080 OPC_Scope, 10, // 431: try {
4081 OPC_CheckField, 11, 2, 0, // 433: check Inst[12:11] == 0x0
4082 OPC_CheckPredicate, 31, // 437: check predicate 31
4083 OPC_Decode, 248, 17, 86, // 439: decode to MULT using decoder 86
4084 // 439: } else try {
4085 OPC_CheckPredicate, 37, // 443: check predicate 37
4086 OPC_Decode, 251, 17, 197, 1, // 445: decode to MULT_DSP using decoder 197
4087 // 445: }
4088 // 445: }
4089 25, 27, // 450: case 0x19: {
4090 OPC_CheckField, 6, 5, 0, // 452: check Inst[10:6] == 0x0
4091 OPC_CheckField, 13, 3, 0, // 456: check Inst[15:13] == 0x0
4092 OPC_Scope, 10, // 460: try {
4093 OPC_CheckField, 11, 2, 0, // 462: check Inst[12:11] == 0x0
4094 OPC_CheckPredicate, 31, // 466: check predicate 31
4095 OPC_Decode, 254, 17, 86, // 468: decode to MULTu using decoder 86
4096 // 468: } else try {
4097 OPC_CheckPredicate, 37, // 472: check predicate 37
4098 OPC_Decode, 249, 17, 197, 1, // 474: decode to MULTU_DSP using decoder 197
4099 // 474: }
4100 // 474: }
4101 26, 10, // 479: case 0x1a: {
4102 OPC_CheckPredicate, 31, // 481: check predicate 31
4103 OPC_CheckField, 6, 10, 0, // 483: check Inst[15:6] == 0x0
4104 OPC_Decode, 224, 19, 86, // 487: decode to SDIV using decoder 86
4105 // 487: }
4106 27, 10, // 491: case 0x1b: {
4107 OPC_CheckPredicate, 31, // 493: check predicate 31
4108 OPC_CheckField, 6, 10, 0, // 495: check Inst[15:6] == 0x0
4109 OPC_Decode, 212, 22, 86, // 499: decode to UDIV using decoder 86
4110 // 499: }
4111 32, 10, // 503: case 0x20: {
4112 OPC_CheckPredicate, 27, // 505: check predicate 27
4113 OPC_CheckField, 6, 5, 0, // 507: check Inst[10:6] == 0x0
4114 OPC_Decode, 154, 6, 67, // 511: decode to ADD using decoder 67
4115 // 511: }
4116 33, 10, // 515: case 0x21: {
4117 OPC_CheckPredicate, 27, // 517: check predicate 27
4118 OPC_CheckField, 6, 5, 0, // 519: check Inst[10:6] == 0x0
4119 OPC_Decode, 227, 6, 67, // 523: decode to ADDu using decoder 67
4120 // 523: }
4121 34, 10, // 527: case 0x22: {
4122 OPC_CheckPredicate, 27, // 529: check predicate 27
4123 OPC_CheckField, 6, 5, 0, // 531: check Inst[10:6] == 0x0
4124 OPC_Decode, 157, 21, 67, // 535: decode to SUB using decoder 67
4125 // 535: }
4126 35, 10, // 539: case 0x23: {
4127 OPC_CheckPredicate, 27, // 541: check predicate 27
4128 OPC_CheckField, 6, 5, 0, // 543: check Inst[10:6] == 0x0
4129 OPC_Decode, 213, 21, 67, // 547: decode to SUBu using decoder 67
4130 // 547: }
4131 36, 10, // 551: case 0x24: {
4132 OPC_CheckPredicate, 27, // 553: check predicate 27
4133 OPC_CheckField, 6, 5, 0, // 555: check Inst[10:6] == 0x0
4134 OPC_Decode, 233, 6, 67, // 559: decode to AND using decoder 67
4135 // 559: }
4136 37, 10, // 563: case 0x25: {
4137 OPC_CheckPredicate, 27, // 565: check predicate 27
4138 OPC_CheckField, 6, 5, 0, // 567: check Inst[10:6] == 0x0
4139 OPC_Decode, 176, 18, 67, // 571: decode to OR using decoder 67
4140 // 571: }
4141 38, 10, // 575: case 0x26: {
4142 OPC_CheckPredicate, 27, // 577: check predicate 27
4143 OPC_CheckField, 6, 5, 0, // 579: check Inst[10:6] == 0x0
4144 OPC_Decode, 230, 22, 67, // 583: decode to XOR using decoder 67
4145 // 583: }
4146 39, 10, // 587: case 0x27: {
4147 OPC_CheckPredicate, 27, // 589: check predicate 27
4148 OPC_CheckField, 6, 5, 0, // 591: check Inst[10:6] == 0x0
4149 OPC_Decode, 166, 18, 67, // 595: decode to NOR using decoder 67
4150 // 595: }
4151 42, 10, // 599: case 0x2a: {
4152 OPC_CheckPredicate, 27, // 601: check predicate 27
4153 OPC_CheckField, 6, 5, 0, // 603: check Inst[10:6] == 0x0
4154 OPC_Decode, 214, 20, 67, // 607: decode to SLT using decoder 67
4155 // 607: }
4156 43, 10, // 611: case 0x2b: {
4157 OPC_CheckPredicate, 27, // 613: check predicate 27
4158 OPC_CheckField, 6, 5, 0, // 615: check Inst[10:6] == 0x0
4159 OPC_Decode, 223, 20, 67, // 619: decode to SLTu using decoder 67
4160 // 619: }
4161 48, 7, // 623: case 0x30: {
4162 OPC_CheckPredicate, 36, // 625: check predicate 36
4163 OPC_Decode, 157, 22, 198, 1, // 627: decode to TGE using decoder 198
4164 // 627: }
4165 49, 7, // 632: case 0x31: {
4166 OPC_CheckPredicate, 36, // 634: check predicate 36
4167 OPC_Decode, 162, 22, 198, 1, // 636: decode to TGEU using decoder 198
4168 // 636: }
4169 50, 7, // 641: case 0x32: {
4170 OPC_CheckPredicate, 36, // 643: check predicate 36
4171 OPC_Decode, 189, 22, 198, 1, // 645: decode to TLT using decoder 198
4172 // 645: }
4173 51, 7, // 650: case 0x33: {
4174 OPC_CheckPredicate, 36, // 652: check predicate 36
4175 OPC_Decode, 193, 22, 198, 1, // 654: decode to TLTU using decoder 198
4176 // 654: }
4177 52, 7, // 659: case 0x34: {
4178 OPC_CheckPredicate, 36, // 661: check predicate 36
4179 OPC_Decode, 153, 22, 198, 1, // 663: decode to TEQ using decoder 198
4180 // 663: }
4181 54, 0, // 668: case 0x36: {
4182 OPC_CheckPredicate, 36, // 670: check predicate 36
4183 OPC_Decode, 196, 22, 198, 1, // 672: decode to TNE using decoder 198
4184 // 672: }
4185 // 672: } // switch Inst[5:0]
4186 // 672: }
4187 1, 151, 1, // 677: case 0x1: {
4188 OPC_SwitchField, 16, 5, // 680: switch Inst[20:16] {
4189 0, 7, // 683: case 0x0: {
4190 OPC_CheckPredicate, 27, // 685: check predicate 27
4191 OPC_Decode, 144, 8, 199, 1, // 687: decode to BLTZ using decoder 199
4192 // 687: }
4193 1, 7, // 692: case 0x1: {
4194 OPC_CheckPredicate, 27, // 694: check predicate 27
4195 OPC_Decode, 215, 7, 199, 1, // 696: decode to BGEZ using decoder 199
4196 // 696: }
4197 2, 7, // 701: case 0x2: {
4198 OPC_CheckPredicate, 39, // 703: check predicate 39
4199 OPC_Decode, 155, 8, 199, 1, // 705: decode to BLTZL using decoder 199
4200 // 705: }
4201 3, 7, // 710: case 0x3: {
4202 OPC_CheckPredicate, 39, // 712: check predicate 39
4203 OPC_Decode, 226, 7, 199, 1, // 714: decode to BGEZL using decoder 199
4204 // 714: }
4205 8, 7, // 719: case 0x8: {
4206 OPC_CheckPredicate, 39, // 721: check predicate 39
4207 OPC_Decode, 158, 22, 177, 1, // 723: decode to TGEI using decoder 177
4208 // 723: }
4209 9, 7, // 728: case 0x9: {
4210 OPC_CheckPredicate, 39, // 730: check predicate 39
4211 OPC_Decode, 159, 22, 177, 1, // 732: decode to TGEIU using decoder 177
4212 // 732: }
4213 10, 7, // 737: case 0xa: {
4214 OPC_CheckPredicate, 39, // 739: check predicate 39
4215 OPC_Decode, 190, 22, 177, 1, // 741: decode to TLTI using decoder 177
4216 // 741: }
4217 11, 7, // 746: case 0xb: {
4218 OPC_CheckPredicate, 39, // 748: check predicate 39
4219 OPC_Decode, 211, 22, 177, 1, // 750: decode to TTLTIU using decoder 177
4220 // 750: }
4221 12, 7, // 755: case 0xc: {
4222 OPC_CheckPredicate, 39, // 757: check predicate 39
4223 OPC_Decode, 154, 22, 177, 1, // 759: decode to TEQI using decoder 177
4224 // 759: }
4225 14, 7, // 764: case 0xe: {
4226 OPC_CheckPredicate, 39, // 766: check predicate 39
4227 OPC_Decode, 197, 22, 177, 1, // 768: decode to TNEI using decoder 177
4228 // 768: }
4229 16, 7, // 773: case 0x10: {
4230 OPC_CheckPredicate, 31, // 775: check predicate 31
4231 OPC_Decode, 146, 8, 199, 1, // 777: decode to BLTZAL using decoder 199
4232 // 777: }
4233 17, 7, // 782: case 0x11: {
4234 OPC_CheckPredicate, 31, // 784: check predicate 31
4235 OPC_Decode, 217, 7, 199, 1, // 786: decode to BGEZAL using decoder 199
4236 // 786: }
4237 18, 7, // 791: case 0x12: {
4238 OPC_CheckPredicate, 39, // 793: check predicate 39
4239 OPC_Decode, 149, 8, 199, 1, // 795: decode to BLTZALL using decoder 199
4240 // 795: }
4241 19, 7, // 800: case 0x13: {
4242 OPC_CheckPredicate, 39, // 802: check predicate 39
4243 OPC_Decode, 220, 7, 199, 1, // 804: decode to BGEZALL using decoder 199
4244 // 804: }
4245 28, 11, // 809: case 0x1c: {
4246 OPC_CheckPredicate, 40, // 811: check predicate 40
4247 OPC_CheckField, 21, 5, 0, // 813: check Inst[25:21] == 0x0
4248 OPC_Decode, 193, 8, 200, 1, // 817: decode to BPOSGE32 using decoder 200
4249 // 817: }
4250 31, 0, // 822: case 0x1f: {
4251 OPC_CheckPredicate, 28, // 824: check predicate 28
4252 OPC_Decode, 253, 21, 201, 1, // 826: decode to SYNCI using decoder 201
4253 // 826: }
4254 // 826: } // switch Inst[20:16]
4255 // 826: }
4256 2, 7, // 831: case 0x2: {
4257 OPC_CheckPredicate, 27, // 833: check predicate 27
4258 OPC_Decode, 188, 14, 202, 1, // 835: decode to J using decoder 202
4259 // 835: }
4260 3, 7, // 840: case 0x3: {
4261 OPC_CheckPredicate, 27, // 842: check predicate 27
4262 OPC_Decode, 189, 14, 202, 1, // 844: decode to JAL using decoder 202
4263 // 844: }
4264 4, 7, // 849: case 0x4: {
4265 OPC_CheckPredicate, 27, // 851: check predicate 27
4266 OPC_Decode, 194, 7, 203, 1, // 853: decode to BEQ using decoder 203
4267 // 853: }
4268 5, 7, // 858: case 0x5: {
4269 OPC_CheckPredicate, 27, // 860: check predicate 27
4270 OPC_Decode, 161, 8, 203, 1, // 862: decode to BNE using decoder 203
4271 // 862: }
4272 6, 11, // 867: case 0x6: {
4273 OPC_CheckPredicate, 27, // 869: check predicate 27
4274 OPC_CheckField, 16, 5, 0, // 871: check Inst[20:16] == 0x0
4275 OPC_Decode, 129, 8, 199, 1, // 875: decode to BLEZ using decoder 199
4276 // 875: }
4277 7, 11, // 880: case 0x7: {
4278 OPC_CheckPredicate, 27, // 882: check predicate 27
4279 OPC_CheckField, 16, 5, 0, // 884: check Inst[20:16] == 0x0
4280 OPC_Decode, 228, 7, 199, 1, // 888: decode to BGTZ using decoder 199
4281 // 888: }
4282 8, 7, // 893: case 0x8: {
4283 OPC_CheckPredicate, 31, // 895: check predicate 31
4284 OPC_Decode, 223, 6, 204, 1, // 897: decode to ADDi using decoder 204
4285 // 897: }
4286 9, 7, // 902: case 0x9: {
4287 OPC_CheckPredicate, 27, // 904: check predicate 27
4288 OPC_Decode, 225, 6, 204, 1, // 906: decode to ADDiu using decoder 204
4289 // 906: }
4290 10, 7, // 911: case 0xa: {
4291 OPC_CheckPredicate, 27, // 913: check predicate 27
4292 OPC_Decode, 217, 20, 204, 1, // 915: decode to SLTi using decoder 204
4293 // 915: }
4294 11, 7, // 920: case 0xb: {
4295 OPC_CheckPredicate, 27, // 922: check predicate 27
4296 OPC_Decode, 220, 20, 204, 1, // 924: decode to SLTiu using decoder 204
4297 // 924: }
4298 12, 7, // 929: case 0xc: {
4299 OPC_CheckPredicate, 27, // 931: check predicate 27
4300 OPC_Decode, 244, 6, 205, 1, // 933: decode to ANDi using decoder 205
4301 // 933: }
4302 13, 7, // 938: case 0xd: {
4303 OPC_CheckPredicate, 27, // 940: check predicate 27
4304 OPC_Decode, 185, 18, 205, 1, // 942: decode to ORi using decoder 205
4305 // 942: }
4306 14, 7, // 947: case 0xe: {
4307 OPC_CheckPredicate, 27, // 949: check predicate 27
4308 OPC_Decode, 239, 22, 205, 1, // 951: decode to XORi using decoder 205
4309 // 951: }
4310 15, 10, // 956: case 0xf: {
4311 OPC_CheckPredicate, 27, // 958: check predicate 27
4312 OPC_CheckField, 21, 5, 0, // 960: check Inst[25:21] == 0x0
4313 OPC_Decode, 177, 15, 110, // 964: decode to LUi using decoder 110
4314 // 964: }
4315 16, 165, 3, // 968: case 0x10: {
4316 OPC_SwitchField, 3, 1, // 971: switch Inst[3] {
4317 0, 135, 2, // 974: case 0x0: {
4318 OPC_SwitchField, 21, 5, // 977: switch Inst[25:21] {
4319 0, 11, // 980: case 0x0: {
4320 OPC_CheckPredicate, 27, // 982: check predicate 27
4321 OPC_CheckField, 4, 7, 0, // 984: check Inst[10:4] == 0x0
4322 OPC_Decode, 165, 16, 206, 1, // 988: decode to MFC0 using decoder 206
4323 // 988: }
4324 3, 39, // 993: case 0x3: {
4325 OPC_SwitchField, 4, 7, // 995: switch Inst[10:4] {
4326 0, 7, // 998: case 0x0: {
4327 OPC_CheckPredicate, 41, // 1000: check predicate 41
4328 OPC_Decode, 174, 16, 206, 1, // 1002: decode to MFGC0 using decoder 206
4329 // 1002: }
4330 32, 7, // 1007: case 0x20: {
4331 OPC_CheckPredicate, 41, // 1009: check predicate 41
4332 OPC_Decode, 191, 17, 207, 1, // 1011: decode to MTGC0 using decoder 207
4333 // 1011: }
4334 64, 7, // 1016: case 0x40: {
4335 OPC_CheckPredicate, 41, // 1018: check predicate 41
4336 OPC_Decode, 182, 16, 206, 1, // 1020: decode to MFHGC0 using decoder 206
4337 // 1020: }
4338 96, 0, // 1025: case 0x60: {
4339 OPC_CheckPredicate, 41, // 1027: check predicate 41
4340 OPC_Decode, 199, 17, 207, 1, // 1029: decode to MTHGC0 using decoder 207
4341 // 1029: }
4342 // 1029: } // switch Inst[10:4]
4343 // 1029: }
4344 4, 11, // 1034: case 0x4: {
4345 OPC_CheckPredicate, 27, // 1036: check predicate 27
4346 OPC_CheckField, 4, 7, 0, // 1038: check Inst[10:4] == 0x0
4347 OPC_Decode, 181, 17, 207, 1, // 1042: decode to MTC0 using decoder 207
4348 // 1042: }
4349 8, 11, // 1047: case 0x8: {
4350 OPC_CheckPredicate, 42, // 1049: check predicate 42
4351 OPC_CheckField, 6, 5, 0, // 1051: check Inst[10:6] == 0x0
4352 OPC_Decode, 196, 16, 208, 1, // 1055: decode to MFTR using decoder 208
4353 // 1055: }
4354 11, 79, // 1060: case 0xb: {
4355 OPC_SwitchField, 4, 12, // 1062: switch Inst[15:4] {
4356 0, 10, // 1065: case 0x0: {
4357 OPC_CheckPredicate, 42, // 1067: check predicate 42
4358 OPC_CheckField, 0, 3, 1, // 1069: check Inst[2:0] == 0x1
4359 OPC_Decode, 168, 12, 99, // 1073: decode to DVPE using decoder 99
4360 // 1073: }
4361 2, 10, // 1077: case 0x2: {
4362 OPC_CheckPredicate, 42, // 1079: check predicate 42
4363 OPC_CheckField, 0, 3, 1, // 1081: check Inst[2:0] == 0x1
4364 OPC_Decode, 185, 12, 99, // 1085: decode to EVPE using decoder 99
4365 // 1085: }
4366 188, 1, 10, // 1089: case 0xbc: {
4367 OPC_CheckPredicate, 42, // 1092: check predicate 42
4368 OPC_CheckField, 0, 3, 1, // 1094: check Inst[2:0] == 0x1
4369 OPC_Decode, 212, 11, 99, // 1098: decode to DMT using decoder 99
4370 // 1098: }
4371 190, 1, 10, // 1102: case 0xbe: {
4372 OPC_CheckPredicate, 42, // 1105: check predicate 42
4373 OPC_CheckField, 0, 3, 1, // 1107: check Inst[2:0] == 0x1
4374 OPC_Decode, 178, 12, 99, // 1111: decode to EMT using decoder 99
4375 // 1111: }
4376 128, 12, 10, // 1115: case 0x600: {
4377 OPC_CheckPredicate, 28, // 1118: check predicate 28
4378 OPC_CheckField, 0, 3, 0, // 1120: check Inst[2:0] == 0x0
4379 OPC_Decode, 185, 11, 99, // 1124: decode to DI using decoder 99
4380 // 1124: }
4381 130, 12, 0, // 1128: case 0x602: {
4382 OPC_CheckPredicate, 28, // 1131: check predicate 28
4383 OPC_CheckField, 0, 3, 0, // 1133: check Inst[2:0] == 0x0
4384 OPC_Decode, 175, 12, 99, // 1137: decode to EI using decoder 99
4385 // 1137: }
4386 // 1137: } // switch Inst[15:4]
4387 // 1137: }
4388 12, 11, // 1141: case 0xc: {
4389 OPC_CheckPredicate, 42, // 1143: check predicate 42
4390 OPC_CheckField, 6, 5, 0, // 1145: check Inst[10:6] == 0x0
4391 OPC_Decode, 219, 17, 208, 1, // 1149: decode to MTTR using decoder 208
4392 // 1149: }
4393 16, 0, // 1154: case 0x10: {
4394 OPC_SwitchField, 0, 3, // 1156: switch Inst[2:0] {
4395 0, 19, // 1159: case 0x0: {
4396 OPC_SwitchField, 4, 17, // 1161: switch Inst[20:4] {
4397 1, 6, // 1164: case 0x1: {
4398 OPC_CheckPredicate, 41, // 1166: check predicate 41
4399 OPC_Decode, 169, 22, 10, // 1168: decode to TLBGP using decoder 10
4400 // 1168: }
4401 2, 0, // 1172: case 0x2: {
4402 OPC_CheckPredicate, 43, // 1174: check predicate 43
4403 OPC_Decode, 221, 22, 10, // 1176: decode to WAIT using decoder 10
4404 // 1176: }
4405 // 1176: } // switch Inst[20:4]
4406 // 1176: }
4407 1, 10, // 1180: case 0x1: {
4408 OPC_CheckPredicate, 27, // 1182: check predicate 27
4409 OPC_CheckField, 4, 17, 0, // 1184: check Inst[20:4] == 0x0
4410 OPC_Decode, 183, 22, 10, // 1188: decode to TLBR using decoder 10
4411 // 1188: }
4412 2, 10, // 1192: case 0x2: {
4413 OPC_CheckPredicate, 27, // 1194: check predicate 27
4414 OPC_CheckField, 4, 17, 0, // 1196: check Inst[20:4] == 0x0
4415 OPC_Decode, 185, 22, 10, // 1200: decode to TLBWI using decoder 10
4416 // 1200: }
4417 3, 10, // 1204: case 0x3: {
4418 OPC_CheckPredicate, 44, // 1206: check predicate 44
4419 OPC_CheckField, 4, 17, 0, // 1208: check Inst[20:4] == 0x0
4420 OPC_Decode, 177, 22, 10, // 1212: decode to TLBINV using decoder 10
4421 // 1212: }
4422 4, 10, // 1216: case 0x4: {
4423 OPC_CheckPredicate, 44, // 1218: check predicate 44
4424 OPC_CheckField, 4, 17, 0, // 1220: check Inst[20:4] == 0x0
4425 OPC_Decode, 178, 22, 10, // 1224: decode to TLBINVF using decoder 10
4426 // 1224: }
4427 6, 0, // 1228: case 0x6: {
4428 OPC_CheckPredicate, 27, // 1230: check predicate 27
4429 OPC_CheckField, 4, 17, 0, // 1232: check Inst[20:4] == 0x0
4430 OPC_Decode, 187, 22, 10, // 1236: decode to TLBWR using decoder 10
4431 // 1236: }
4432 // 1236: } // switch Inst[2:0]
4433 // 1236: }
4434 // 1236: } // switch Inst[25:21]
4435 // 1236: }
4436 1, 0, // 1240: case 0x1: {
4437 OPC_SwitchField, 0, 3, // 1242: switch Inst[2:0] {
4438 0, 55, // 1245: case 0x0: {
4439 OPC_SwitchField, 4, 2, // 1247: switch Inst[5:4] {
4440 0, 12, // 1250: case 0x0: {
4441 OPC_CheckPredicate, 27, // 1252: check predicate 27
4442 OPC_CheckField, 6, 20, 128, 128, 32, // 1254: check Inst[25:6] == 0x80000
4443 OPC_Decode, 181, 22, 10, // 1260: decode to TLBP using decoder 10
4444 // 1260: }
4445 1, 23, // 1264: case 0x1: {
4446 OPC_SwitchField, 6, 20, // 1266: switch Inst[25:6] {
4447 128, 128, 32, 6, // 1269: case 0x80000: {
4448 OPC_CheckPredicate, 43, // 1273: check predicate 43
4449 OPC_Decode, 179, 12, 10, // 1275: decode to ERET using decoder 10
4450 // 1275: }
4451 129, 128, 32, 0, // 1279: case 0x80001: {
4452 OPC_CheckPredicate, 45, // 1283: check predicate 45
4453 OPC_Decode, 180, 12, 10, // 1285: decode to ERETNC using decoder 10
4454 // 1285: }
4455 // 1285: } // switch Inst[25:6]
4456 // 1285: }
4457 2, 0, // 1289: case 0x2: {
4458 OPC_CheckPredicate, 41, // 1291: check predicate 41
4459 OPC_CheckField, 25, 1, 1, // 1293: check Inst[25] == 0x1
4460 OPC_Decode, 157, 14, 209, 1, // 1297: decode to HYPCALL using decoder 209
4461 // 1297: }
4462 // 1297: } // switch Inst[5:4]
4463 // 1297: }
4464 1, 13, // 1302: case 0x1: {
4465 OPC_CheckPredicate, 41, // 1304: check predicate 41
4466 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1306: check Inst[25:4] == 0x200000
4467 OPC_Decode, 171, 22, 10, // 1313: decode to TLBGR using decoder 10
4468 // 1313: }
4469 2, 13, // 1317: case 0x2: {
4470 OPC_CheckPredicate, 41, // 1319: check predicate 41
4471 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1321: check Inst[25:4] == 0x200000
4472 OPC_Decode, 173, 22, 10, // 1328: decode to TLBGWI using decoder 10
4473 // 1328: }
4474 3, 13, // 1332: case 0x3: {
4475 OPC_CheckPredicate, 41, // 1334: check predicate 41
4476 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1336: check Inst[25:4] == 0x200000
4477 OPC_Decode, 165, 22, 10, // 1343: decode to TLBGINV using decoder 10
4478 // 1343: }
4479 4, 13, // 1347: case 0x4: {
4480 OPC_CheckPredicate, 41, // 1349: check predicate 41
4481 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1351: check Inst[25:4] == 0x200000
4482 OPC_Decode, 166, 22, 10, // 1358: decode to TLBGINVF using decoder 10
4483 // 1358: }
4484 6, 13, // 1362: case 0x6: {
4485 OPC_CheckPredicate, 41, // 1364: check predicate 41
4486 OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1366: check Inst[25:4] == 0x200000
4487 OPC_Decode, 175, 22, 10, // 1373: decode to TLBGWR using decoder 10
4488 // 1373: }
4489 7, 0, // 1377: case 0x7: {
4490 OPC_CheckPredicate, 46, // 1379: check predicate 46
4491 OPC_CheckField, 4, 22, 129, 128, 128, 1, // 1381: check Inst[25:4] == 0x200001
4492 OPC_Decode, 178, 11, 10, // 1388: decode to DERET using decoder 10
4493 // 1388: }
4494 // 1388: } // switch Inst[2:0]
4495 // 1388: }
4496 // 1388: } // switch Inst[3]
4497 // 1388: }
4498 17, 165, 9, // 1392: case 0x11: {
4499 OPC_SwitchField, 21, 5, // 1395: switch Inst[25:21] {
4500 0, 11, // 1398: case 0x0: {
4501 OPC_CheckPredicate, 47, // 1400: check predicate 47
4502 OPC_CheckField, 0, 11, 0, // 1402: check Inst[10:0] == 0x0
4503 OPC_Decode, 168, 16, 210, 1, // 1406: decode to MFC1 using decoder 210
4504 // 1406: }
4505 1, 11, // 1411: case 0x1: {
4506 OPC_CheckPredicate, 48, // 1413: check predicate 48
4507 OPC_CheckField, 0, 11, 0, // 1415: check Inst[10:0] == 0x0
4508 OPC_Decode, 206, 11, 211, 1, // 1419: decode to DMFC1 using decoder 211
4509 // 1419: }
4510 2, 11, // 1424: case 0x2: {
4511 OPC_CheckPredicate, 47, // 1426: check predicate 47
4512 OPC_CheckField, 0, 11, 0, // 1428: check Inst[10:0] == 0x0
4513 OPC_Decode, 252, 8, 212, 1, // 1432: decode to CFC1 using decoder 212
4514 // 1432: }
4515 3, 11, // 1437: case 0x3: {
4516 OPC_CheckPredicate, 49, // 1439: check predicate 49
4517 OPC_CheckField, 0, 11, 0, // 1441: check Inst[10:0] == 0x0
4518 OPC_Decode, 177, 16, 213, 1, // 1445: decode to MFHC1_D32 using decoder 213
4519 // 1445: }
4520 4, 11, // 1450: case 0x4: {
4521 OPC_CheckPredicate, 47, // 1452: check predicate 47
4522 OPC_CheckField, 0, 11, 0, // 1454: check Inst[10:0] == 0x0
4523 OPC_Decode, 184, 17, 214, 1, // 1458: decode to MTC1 using decoder 214
4524 // 1458: }
4525 5, 11, // 1463: case 0x5: {
4526 OPC_CheckPredicate, 48, // 1465: check predicate 48
4527 OPC_CheckField, 0, 11, 0, // 1467: check Inst[10:0] == 0x0
4528 OPC_Decode, 214, 11, 215, 1, // 1471: decode to DMTC1 using decoder 215
4529 // 1471: }
4530 6, 11, // 1476: case 0x6: {
4531 OPC_CheckPredicate, 47, // 1478: check predicate 47
4532 OPC_CheckField, 0, 11, 0, // 1480: check Inst[10:0] == 0x0
4533 OPC_Decode, 151, 10, 216, 1, // 1484: decode to CTC1 using decoder 216
4534 // 1484: }
4535 7, 11, // 1489: case 0x7: {
4536 OPC_CheckPredicate, 49, // 1491: check predicate 49
4537 OPC_CheckField, 0, 11, 0, // 1493: check Inst[10:0] == 0x0
4538 OPC_Decode, 194, 17, 217, 1, // 1497: decode to MTHC1_D32 using decoder 217
4539 // 1497: }
4540 8, 39, // 1502: case 0x8: {
4541 OPC_SwitchField, 16, 2, // 1504: switch Inst[17:16] {
4542 0, 7, // 1507: case 0x0: {
4543 OPC_CheckPredicate, 50, // 1509: check predicate 50
4544 OPC_Decode, 173, 7, 218, 1, // 1511: decode to BC1F using decoder 218
4545 // 1511: }
4546 1, 7, // 1516: case 0x1: {
4547 OPC_CheckPredicate, 50, // 1518: check predicate 50
4548 OPC_Decode, 178, 7, 218, 1, // 1520: decode to BC1T using decoder 218
4549 // 1520: }
4550 2, 7, // 1525: case 0x2: {
4551 OPC_CheckPredicate, 51, // 1527: check predicate 51
4552 OPC_Decode, 174, 7, 218, 1, // 1529: decode to BC1FL using decoder 218
4553 // 1529: }
4554 3, 0, // 1534: case 0x3: {
4555 OPC_CheckPredicate, 51, // 1536: check predicate 51
4556 OPC_Decode, 179, 7, 218, 1, // 1538: decode to BC1TL using decoder 218
4557 // 1538: }
4558 // 1538: } // switch Inst[17:16]
4559 // 1538: }
4560 11, 7, // 1543: case 0xb: {
4561 OPC_CheckPredicate, 30, // 1545: check predicate 30
4562 OPC_Decode, 214, 8, 219, 1, // 1547: decode to BZ_V using decoder 219
4563 // 1547: }
4564 15, 7, // 1552: case 0xf: {
4565 OPC_CheckPredicate, 30, // 1554: check predicate 30
4566 OPC_Decode, 189, 8, 219, 1, // 1556: decode to BNZ_V using decoder 219
4567 // 1556: }
4568 16, 201, 3, // 1561: case 0x10: {
4569 OPC_SwitchField, 0, 6, // 1564: switch Inst[5:0] {
4570 0, 7, // 1567: case 0x0: {
4571 OPC_CheckPredicate, 47, // 1569: check predicate 47
4572 OPC_Decode, 228, 12, 220, 1, // 1571: decode to FADD_S using decoder 220
4573 // 1571: }
4574 1, 7, // 1576: case 0x1: {
4575 OPC_CheckPredicate, 47, // 1578: check predicate 47
4576 OPC_Decode, 245, 13, 220, 1, // 1580: decode to FSUB_S using decoder 220
4577 // 1580: }
4578 2, 7, // 1585: case 0x2: {
4579 OPC_CheckPredicate, 47, // 1587: check predicate 47
4580 OPC_Decode, 201, 13, 220, 1, // 1589: decode to FMUL_S using decoder 220
4581 // 1589: }
4582 3, 7, // 1594: case 0x3: {
4583 OPC_CheckPredicate, 47, // 1596: check predicate 47
4584 OPC_Decode, 138, 13, 220, 1, // 1598: decode to FDIV_S using decoder 220
4585 // 1598: }
4586 4, 11, // 1603: case 0x4: {
4587 OPC_CheckPredicate, 52, // 1605: check predicate 52
4588 OPC_CheckField, 16, 5, 0, // 1607: check Inst[20:16] == 0x0
4589 OPC_Decode, 236, 13, 221, 1, // 1611: decode to FSQRT_S using decoder 221
4590 // 1611: }
4591 5, 11, // 1616: case 0x5: {
4592 OPC_CheckPredicate, 47, // 1618: check predicate 47
4593 OPC_CheckField, 16, 5, 0, // 1620: check Inst[20:16] == 0x0
4594 OPC_Decode, 220, 12, 221, 1, // 1624: decode to FABS_S using decoder 221
4595 // 1624: }
4596 6, 11, // 1629: case 0x6: {
4597 OPC_CheckPredicate, 47, // 1631: check predicate 47
4598 OPC_CheckField, 16, 5, 0, // 1633: check Inst[20:16] == 0x0
4599 OPC_Decode, 190, 13, 221, 1, // 1637: decode to FMOV_S using decoder 221
4600 // 1637: }
4601 7, 11, // 1642: case 0x7: {
4602 OPC_CheckPredicate, 53, // 1644: check predicate 53
4603 OPC_CheckField, 16, 5, 0, // 1646: check Inst[20:16] == 0x0
4604 OPC_Decode, 209, 13, 221, 1, // 1650: decode to FNEG_S using decoder 221
4605 // 1650: }
4606 12, 11, // 1655: case 0xc: {
4607 OPC_CheckPredicate, 54, // 1657: check predicate 54
4608 OPC_CheckField, 16, 5, 0, // 1659: check Inst[20:16] == 0x0
4609 OPC_Decode, 169, 19, 221, 1, // 1663: decode to ROUND_W_S using decoder 221
4610 // 1663: }
4611 13, 11, // 1668: case 0xd: {
4612 OPC_CheckPredicate, 54, // 1670: check predicate 54
4613 OPC_CheckField, 16, 5, 0, // 1672: check Inst[20:16] == 0x0
4614 OPC_Decode, 208, 22, 221, 1, // 1676: decode to TRUNC_W_S using decoder 221
4615 // 1676: }
4616 14, 11, // 1681: case 0xe: {
4617 OPC_CheckPredicate, 54, // 1683: check predicate 54
4618 OPC_CheckField, 16, 5, 0, // 1685: check Inst[20:16] == 0x0
4619 OPC_Decode, 241, 8, 221, 1, // 1689: decode to CEIL_W_S using decoder 221
4620 // 1689: }
4621 15, 11, // 1694: case 0xf: {
4622 OPC_CheckPredicate, 54, // 1696: check predicate 54
4623 OPC_CheckField, 16, 5, 0, // 1698: check Inst[20:16] == 0x0
4624 OPC_Decode, 172, 13, 221, 1, // 1702: decode to FLOOR_W_S using decoder 221
4625 // 1702: }
4626 17, 21, // 1707: case 0x11: {
4627 OPC_SwitchField, 16, 2, // 1709: switch Inst[17:16] {
4628 0, 7, // 1712: case 0x0: {
4629 OPC_CheckPredicate, 29, // 1714: check predicate 29
4630 OPC_Decode, 250, 16, 222, 1, // 1716: decode to MOVF_S using decoder 222
4631 // 1716: }
4632 1, 0, // 1721: case 0x1: {
4633 OPC_CheckPredicate, 29, // 1723: check predicate 29
4634 OPC_Decode, 142, 17, 222, 1, // 1725: decode to MOVT_S using decoder 222
4635 // 1725: }
4636 // 1725: } // switch Inst[17:16]
4637 // 1725: }
4638 18, 7, // 1730: case 0x12: {
4639 OPC_CheckPredicate, 29, // 1732: check predicate 29
4640 OPC_Decode, 154, 17, 223, 1, // 1734: decode to MOVZ_I_S using decoder 223
4641 // 1734: }
4642 19, 7, // 1739: case 0x13: {
4643 OPC_CheckPredicate, 29, // 1741: check predicate 29
4644 OPC_Decode, 134, 17, 223, 1, // 1743: decode to MOVN_I_S using decoder 223
4645 // 1743: }
4646 21, 11, // 1748: case 0x15: {
4647 OPC_CheckPredicate, 55, // 1750: check predicate 55
4648 OPC_CheckField, 16, 5, 0, // 1752: check Inst[20:16] == 0x0
4649 OPC_Decode, 143, 19, 221, 1, // 1756: decode to RECIP_S using decoder 221
4650 // 1756: }
4651 22, 11, // 1761: case 0x16: {
4652 OPC_CheckPredicate, 55, // 1763: check predicate 55
4653 OPC_CheckField, 16, 5, 0, // 1765: check Inst[20:16] == 0x0
4654 OPC_Decode, 176, 19, 221, 1, // 1769: decode to RSQRT_S using decoder 221
4655 // 1769: }
4656 33, 11, // 1774: case 0x21: {
4657 OPC_CheckPredicate, 56, // 1776: check predicate 56
4658 OPC_CheckField, 16, 5, 0, // 1778: check Inst[20:16] == 0x0
4659 OPC_Decode, 155, 10, 224, 1, // 1782: decode to CVT_D32_S using decoder 224
4660 // 1782: }
4661 36, 11, // 1787: case 0x24: {
4662 OPC_CheckPredicate, 47, // 1789: check predicate 47
4663 OPC_CheckField, 16, 5, 0, // 1791: check Inst[20:16] == 0x0
4664 OPC_Decode, 189, 10, 221, 1, // 1795: decode to CVT_W_S using decoder 221
4665 // 1795: }
4666 37, 11, // 1800: case 0x25: {
4667 OPC_CheckPredicate, 57, // 1802: check predicate 57
4668 OPC_CheckField, 16, 5, 0, // 1804: check Inst[20:16] == 0x0
4669 OPC_Decode, 168, 10, 225, 1, // 1808: decode to CVT_L_S using decoder 225
4670 // 1808: }
4671 48, 11, // 1813: case 0x30: {
4672 OPC_CheckPredicate, 50, // 1815: check predicate 50
4673 OPC_CheckField, 6, 2, 0, // 1817: check Inst[7:6] == 0x0
4674 OPC_Decode, 202, 10, 226, 1, // 1821: decode to C_F_S using decoder 226
4675 // 1821: }
4676 49, 11, // 1826: case 0x31: {
4677 OPC_CheckPredicate, 58, // 1828: check predicate 58
4678 OPC_CheckField, 6, 2, 0, // 1830: check Inst[7:6] == 0x0
4679 OPC_Decode, 158, 11, 226, 1, // 1834: decode to C_UN_S using decoder 226
4680 // 1834: }
4681 50, 11, // 1839: case 0x32: {
4682 OPC_CheckPredicate, 50, // 1841: check predicate 50
4683 OPC_CheckField, 6, 2, 0, // 1843: check Inst[7:6] == 0x0
4684 OPC_Decode, 196, 10, 226, 1, // 1847: decode to C_EQ_S using decoder 226
4685 // 1847: }
4686 51, 11, // 1852: case 0x33: {
4687 OPC_CheckPredicate, 58, // 1854: check predicate 58
4688 OPC_CheckField, 6, 2, 0, // 1856: check Inst[7:6] == 0x0
4689 OPC_Decode, 140, 11, 226, 1, // 1860: decode to C_UEQ_S using decoder 226
4690 // 1860: }
4691 52, 11, // 1865: case 0x34: {
4692 OPC_CheckPredicate, 50, // 1867: check predicate 50
4693 OPC_CheckField, 6, 2, 0, // 1869: check Inst[7:6] == 0x0
4694 OPC_Decode, 250, 10, 226, 1, // 1873: decode to C_OLT_S using decoder 226
4695 // 1873: }
4696 53, 11, // 1878: case 0x35: {
4697 OPC_CheckPredicate, 58, // 1880: check predicate 58
4698 OPC_CheckField, 6, 2, 0, // 1882: check Inst[7:6] == 0x0
4699 OPC_Decode, 152, 11, 226, 1, // 1886: decode to C_ULT_S using decoder 226
4700 // 1886: }
4701 54, 11, // 1891: case 0x36: {
4702 OPC_CheckPredicate, 50, // 1893: check predicate 50
4703 OPC_CheckField, 6, 2, 0, // 1895: check Inst[7:6] == 0x0
4704 OPC_Decode, 244, 10, 226, 1, // 1899: decode to C_OLE_S using decoder 226
4705 // 1899: }
4706 55, 11, // 1904: case 0x37: {
4707 OPC_CheckPredicate, 58, // 1906: check predicate 58
4708 OPC_CheckField, 6, 2, 0, // 1908: check Inst[7:6] == 0x0
4709 OPC_Decode, 146, 11, 226, 1, // 1912: decode to C_ULE_S using decoder 226
4710 // 1912: }
4711 56, 11, // 1917: case 0x38: {
4712 OPC_CheckPredicate, 58, // 1919: check predicate 58
4713 OPC_CheckField, 6, 2, 0, // 1921: check Inst[7:6] == 0x0
4714 OPC_Decode, 134, 11, 226, 1, // 1925: decode to C_SF_S using decoder 226
4715 // 1925: }
4716 57, 11, // 1930: case 0x39: {
4717 OPC_CheckPredicate, 58, // 1932: check predicate 58
4718 OPC_CheckField, 6, 2, 0, // 1934: check Inst[7:6] == 0x0
4719 OPC_Decode, 226, 10, 226, 1, // 1938: decode to C_NGLE_S using decoder 226
4720 // 1938: }
4721 58, 11, // 1943: case 0x3a: {
4722 OPC_CheckPredicate, 58, // 1945: check predicate 58
4723 OPC_CheckField, 6, 2, 0, // 1947: check Inst[7:6] == 0x0
4724 OPC_Decode, 128, 11, 226, 1, // 1951: decode to C_SEQ_S using decoder 226
4725 // 1951: }
4726 59, 11, // 1956: case 0x3b: {
4727 OPC_CheckPredicate, 58, // 1958: check predicate 58
4728 OPC_CheckField, 6, 2, 0, // 1960: check Inst[7:6] == 0x0
4729 OPC_Decode, 232, 10, 226, 1, // 1964: decode to C_NGL_S using decoder 226
4730 // 1964: }
4731 60, 11, // 1969: case 0x3c: {
4732 OPC_CheckPredicate, 58, // 1971: check predicate 58
4733 OPC_CheckField, 6, 2, 0, // 1973: check Inst[7:6] == 0x0
4734 OPC_Decode, 214, 10, 226, 1, // 1977: decode to C_LT_S using decoder 226
4735 // 1977: }
4736 61, 11, // 1982: case 0x3d: {
4737 OPC_CheckPredicate, 58, // 1984: check predicate 58
4738 OPC_CheckField, 6, 2, 0, // 1986: check Inst[7:6] == 0x0
4739 OPC_Decode, 220, 10, 226, 1, // 1990: decode to C_NGE_S using decoder 226
4740 // 1990: }
4741 62, 11, // 1995: case 0x3e: {
4742 OPC_CheckPredicate, 58, // 1997: check predicate 58
4743 OPC_CheckField, 6, 2, 0, // 1999: check Inst[7:6] == 0x0
4744 OPC_Decode, 208, 10, 226, 1, // 2003: decode to C_LE_S using decoder 226
4745 // 2003: }
4746 63, 0, // 2008: case 0x3f: {
4747 OPC_CheckPredicate, 58, // 2010: check predicate 58
4748 OPC_CheckField, 6, 2, 0, // 2012: check Inst[7:6] == 0x0
4749 OPC_Decode, 238, 10, 226, 1, // 2016: decode to C_NGT_S using decoder 226
4750 // 2016: }
4751 // 2016: } // switch Inst[5:0]
4752 // 2016: }
4753 17, 201, 3, // 2021: case 0x11: {
4754 OPC_SwitchField, 0, 6, // 2024: switch Inst[5:0] {
4755 0, 7, // 2027: case 0x0: {
4756 OPC_CheckPredicate, 56, // 2029: check predicate 56
4757 OPC_Decode, 223, 12, 227, 1, // 2031: decode to FADD_D32 using decoder 227
4758 // 2031: }
4759 1, 7, // 2036: case 0x1: {
4760 OPC_CheckPredicate, 56, // 2038: check predicate 56
4761 OPC_Decode, 240, 13, 227, 1, // 2040: decode to FSUB_D32 using decoder 227
4762 // 2040: }
4763 2, 7, // 2045: case 0x2: {
4764 OPC_CheckPredicate, 56, // 2047: check predicate 56
4765 OPC_Decode, 196, 13, 227, 1, // 2049: decode to FMUL_D32 using decoder 227
4766 // 2049: }
4767 3, 7, // 2054: case 0x3: {
4768 OPC_CheckPredicate, 56, // 2056: check predicate 56
4769 OPC_Decode, 134, 13, 227, 1, // 2058: decode to FDIV_D32 using decoder 227
4770 // 2058: }
4771 4, 11, // 2063: case 0x4: {
4772 OPC_CheckPredicate, 59, // 2065: check predicate 59
4773 OPC_CheckField, 16, 5, 0, // 2067: check Inst[20:16] == 0x0
4774 OPC_Decode, 232, 13, 228, 1, // 2071: decode to FSQRT_D32 using decoder 228
4775 // 2071: }
4776 5, 11, // 2076: case 0x5: {
4777 OPC_CheckPredicate, 56, // 2078: check predicate 56
4778 OPC_CheckField, 16, 5, 0, // 2080: check Inst[20:16] == 0x0
4779 OPC_Decode, 216, 12, 228, 1, // 2084: decode to FABS_D32 using decoder 228
4780 // 2084: }
4781 6, 11, // 2089: case 0x6: {
4782 OPC_CheckPredicate, 56, // 2091: check predicate 56
4783 OPC_CheckField, 16, 5, 0, // 2093: check Inst[20:16] == 0x0
4784 OPC_Decode, 185, 13, 228, 1, // 2097: decode to FMOV_D32 using decoder 228
4785 // 2097: }
4786 7, 11, // 2102: case 0x7: {
4787 OPC_CheckPredicate, 56, // 2104: check predicate 56
4788 OPC_CheckField, 16, 5, 0, // 2106: check Inst[20:16] == 0x0
4789 OPC_Decode, 205, 13, 228, 1, // 2110: decode to FNEG_D32 using decoder 228
4790 // 2110: }
4791 12, 11, // 2115: case 0xc: {
4792 OPC_CheckPredicate, 59, // 2117: check predicate 59
4793 OPC_CheckField, 16, 5, 0, // 2119: check Inst[20:16] == 0x0
4794 OPC_Decode, 165, 19, 229, 1, // 2123: decode to ROUND_W_D32 using decoder 229
4795 // 2123: }
4796 13, 11, // 2128: case 0xd: {
4797 OPC_CheckPredicate, 59, // 2130: check predicate 59
4798 OPC_CheckField, 16, 5, 0, // 2132: check Inst[20:16] == 0x0
4799 OPC_Decode, 204, 22, 229, 1, // 2136: decode to TRUNC_W_D32 using decoder 229
4800 // 2136: }
4801 14, 11, // 2141: case 0xe: {
4802 OPC_CheckPredicate, 59, // 2143: check predicate 59
4803 OPC_CheckField, 16, 5, 0, // 2145: check Inst[20:16] == 0x0
4804 OPC_Decode, 237, 8, 229, 1, // 2149: decode to CEIL_W_D32 using decoder 229
4805 // 2149: }
4806 15, 11, // 2154: case 0xf: {
4807 OPC_CheckPredicate, 59, // 2156: check predicate 59
4808 OPC_CheckField, 16, 5, 0, // 2158: check Inst[20:16] == 0x0
4809 OPC_Decode, 168, 13, 229, 1, // 2162: decode to FLOOR_W_D32 using decoder 229
4810 // 2162: }
4811 17, 21, // 2167: case 0x11: {
4812 OPC_SwitchField, 16, 2, // 2169: switch Inst[17:16] {
4813 0, 7, // 2172: case 0x0: {
4814 OPC_CheckPredicate, 60, // 2174: check predicate 60
4815 OPC_Decode, 244, 16, 230, 1, // 2176: decode to MOVF_D32 using decoder 230
4816 // 2176: }
4817 1, 0, // 2181: case 0x1: {
4818 OPC_CheckPredicate, 60, // 2183: check predicate 60
4819 OPC_Decode, 136, 17, 230, 1, // 2185: decode to MOVT_D32 using decoder 230
4820 // 2185: }
4821 // 2185: } // switch Inst[17:16]
4822 // 2185: }
4823 18, 7, // 2190: case 0x12: {
4824 OPC_CheckPredicate, 60, // 2192: check predicate 60
4825 OPC_Decode, 148, 17, 231, 1, // 2194: decode to MOVZ_I_D32 using decoder 231
4826 // 2194: }
4827 19, 7, // 2199: case 0x13: {
4828 OPC_CheckPredicate, 60, // 2201: check predicate 60
4829 OPC_Decode, 128, 17, 231, 1, // 2203: decode to MOVN_I_D32 using decoder 231
4830 // 2203: }
4831 21, 11, // 2208: case 0x15: {
4832 OPC_CheckPredicate, 61, // 2210: check predicate 61
4833 OPC_CheckField, 16, 5, 0, // 2212: check Inst[20:16] == 0x0
4834 OPC_Decode, 139, 19, 228, 1, // 2216: decode to RECIP_D32 using decoder 228
4835 // 2216: }
4836 22, 11, // 2221: case 0x16: {
4837 OPC_CheckPredicate, 61, // 2223: check predicate 61
4838 OPC_CheckField, 16, 5, 0, // 2225: check Inst[20:16] == 0x0
4839 OPC_Decode, 172, 19, 228, 1, // 2229: decode to RSQRT_D32 using decoder 228
4840 // 2229: }
4841 32, 11, // 2234: case 0x20: {
4842 OPC_CheckPredicate, 56, // 2236: check predicate 56
4843 OPC_CheckField, 16, 5, 0, // 2238: check Inst[20:16] == 0x0
4844 OPC_Decode, 174, 10, 229, 1, // 2242: decode to CVT_S_D32 using decoder 229
4845 // 2242: }
4846 36, 11, // 2247: case 0x24: {
4847 OPC_CheckPredicate, 56, // 2249: check predicate 56
4848 OPC_CheckField, 16, 5, 0, // 2251: check Inst[20:16] == 0x0
4849 OPC_Decode, 185, 10, 229, 1, // 2255: decode to CVT_W_D32 using decoder 229
4850 // 2255: }
4851 37, 11, // 2260: case 0x25: {
4852 OPC_CheckPredicate, 57, // 2262: check predicate 57
4853 OPC_CheckField, 16, 5, 0, // 2264: check Inst[20:16] == 0x0
4854 OPC_Decode, 165, 10, 232, 1, // 2268: decode to CVT_L_D64 using decoder 232
4855 // 2268: }
4856 48, 11, // 2273: case 0x30: {
4857 OPC_CheckPredicate, 62, // 2275: check predicate 62
4858 OPC_CheckField, 6, 2, 0, // 2277: check Inst[7:6] == 0x0
4859 OPC_Decode, 198, 10, 233, 1, // 2281: decode to C_F_D32 using decoder 233
4860 // 2281: }
4861 49, 11, // 2286: case 0x31: {
4862 OPC_CheckPredicate, 62, // 2288: check predicate 62
4863 OPC_CheckField, 6, 2, 0, // 2290: check Inst[7:6] == 0x0
4864 OPC_Decode, 154, 11, 233, 1, // 2294: decode to C_UN_D32 using decoder 233
4865 // 2294: }
4866 50, 11, // 2299: case 0x32: {
4867 OPC_CheckPredicate, 62, // 2301: check predicate 62
4868 OPC_CheckField, 6, 2, 0, // 2303: check Inst[7:6] == 0x0
4869 OPC_Decode, 192, 10, 233, 1, // 2307: decode to C_EQ_D32 using decoder 233
4870 // 2307: }
4871 51, 11, // 2312: case 0x33: {
4872 OPC_CheckPredicate, 62, // 2314: check predicate 62
4873 OPC_CheckField, 6, 2, 0, // 2316: check Inst[7:6] == 0x0
4874 OPC_Decode, 136, 11, 233, 1, // 2320: decode to C_UEQ_D32 using decoder 233
4875 // 2320: }
4876 52, 11, // 2325: case 0x34: {
4877 OPC_CheckPredicate, 62, // 2327: check predicate 62
4878 OPC_CheckField, 6, 2, 0, // 2329: check Inst[7:6] == 0x0
4879 OPC_Decode, 246, 10, 233, 1, // 2333: decode to C_OLT_D32 using decoder 233
4880 // 2333: }
4881 53, 11, // 2338: case 0x35: {
4882 OPC_CheckPredicate, 62, // 2340: check predicate 62
4883 OPC_CheckField, 6, 2, 0, // 2342: check Inst[7:6] == 0x0
4884 OPC_Decode, 148, 11, 233, 1, // 2346: decode to C_ULT_D32 using decoder 233
4885 // 2346: }
4886 54, 11, // 2351: case 0x36: {
4887 OPC_CheckPredicate, 62, // 2353: check predicate 62
4888 OPC_CheckField, 6, 2, 0, // 2355: check Inst[7:6] == 0x0
4889 OPC_Decode, 240, 10, 233, 1, // 2359: decode to C_OLE_D32 using decoder 233
4890 // 2359: }
4891 55, 11, // 2364: case 0x37: {
4892 OPC_CheckPredicate, 62, // 2366: check predicate 62
4893 OPC_CheckField, 6, 2, 0, // 2368: check Inst[7:6] == 0x0
4894 OPC_Decode, 142, 11, 233, 1, // 2372: decode to C_ULE_D32 using decoder 233
4895 // 2372: }
4896 56, 11, // 2377: case 0x38: {
4897 OPC_CheckPredicate, 62, // 2379: check predicate 62
4898 OPC_CheckField, 6, 2, 0, // 2381: check Inst[7:6] == 0x0
4899 OPC_Decode, 130, 11, 233, 1, // 2385: decode to C_SF_D32 using decoder 233
4900 // 2385: }
4901 57, 11, // 2390: case 0x39: {
4902 OPC_CheckPredicate, 62, // 2392: check predicate 62
4903 OPC_CheckField, 6, 2, 0, // 2394: check Inst[7:6] == 0x0
4904 OPC_Decode, 222, 10, 233, 1, // 2398: decode to C_NGLE_D32 using decoder 233
4905 // 2398: }
4906 58, 11, // 2403: case 0x3a: {
4907 OPC_CheckPredicate, 62, // 2405: check predicate 62
4908 OPC_CheckField, 6, 2, 0, // 2407: check Inst[7:6] == 0x0
4909 OPC_Decode, 252, 10, 233, 1, // 2411: decode to C_SEQ_D32 using decoder 233
4910 // 2411: }
4911 59, 11, // 2416: case 0x3b: {
4912 OPC_CheckPredicate, 62, // 2418: check predicate 62
4913 OPC_CheckField, 6, 2, 0, // 2420: check Inst[7:6] == 0x0
4914 OPC_Decode, 228, 10, 233, 1, // 2424: decode to C_NGL_D32 using decoder 233
4915 // 2424: }
4916 60, 11, // 2429: case 0x3c: {
4917 OPC_CheckPredicate, 62, // 2431: check predicate 62
4918 OPC_CheckField, 6, 2, 0, // 2433: check Inst[7:6] == 0x0
4919 OPC_Decode, 210, 10, 233, 1, // 2437: decode to C_LT_D32 using decoder 233
4920 // 2437: }
4921 61, 11, // 2442: case 0x3d: {
4922 OPC_CheckPredicate, 62, // 2444: check predicate 62
4923 OPC_CheckField, 6, 2, 0, // 2446: check Inst[7:6] == 0x0
4924 OPC_Decode, 216, 10, 233, 1, // 2450: decode to C_NGE_D32 using decoder 233
4925 // 2450: }
4926 62, 11, // 2455: case 0x3e: {
4927 OPC_CheckPredicate, 62, // 2457: check predicate 62
4928 OPC_CheckField, 6, 2, 0, // 2459: check Inst[7:6] == 0x0
4929 OPC_Decode, 204, 10, 233, 1, // 2463: decode to C_LE_D32 using decoder 233
4930 // 2463: }
4931 63, 0, // 2468: case 0x3f: {
4932 OPC_CheckPredicate, 62, // 2470: check predicate 62
4933 OPC_CheckField, 6, 2, 0, // 2472: check Inst[7:6] == 0x0
4934 OPC_Decode, 234, 10, 233, 1, // 2476: decode to C_NGT_D32 using decoder 233
4935 // 2476: }
4936 // 2476: } // switch Inst[5:0]
4937 // 2476: }
4938 20, 29, // 2481: case 0x14: {
4939 OPC_SwitchField, 0, 6, // 2483: switch Inst[5:0] {
4940 32, 11, // 2486: case 0x20: {
4941 OPC_CheckPredicate, 47, // 2488: check predicate 47
4942 OPC_CheckField, 16, 5, 0, // 2490: check Inst[20:16] == 0x0
4943 OPC_Decode, 182, 10, 221, 1, // 2494: decode to CVT_S_W using decoder 221
4944 // 2494: }
4945 33, 0, // 2499: case 0x21: {
4946 OPC_CheckPredicate, 56, // 2501: check predicate 56
4947 OPC_CheckField, 16, 5, 0, // 2503: check Inst[20:16] == 0x0
4948 OPC_Decode, 157, 10, 224, 1, // 2507: decode to CVT_D32_W using decoder 224
4949 // 2507: }
4950 // 2507: } // switch Inst[5:0]
4951 // 2507: }
4952 24, 7, // 2512: case 0x18: {
4953 OPC_CheckPredicate, 30, // 2514: check predicate 30
4954 OPC_Decode, 211, 8, 219, 1, // 2516: decode to BZ_B using decoder 219
4955 // 2516: }
4956 25, 7, // 2521: case 0x19: {
4957 OPC_CheckPredicate, 30, // 2523: check predicate 30
4958 OPC_Decode, 213, 8, 234, 1, // 2525: decode to BZ_H using decoder 234
4959 // 2525: }
4960 26, 7, // 2530: case 0x1a: {
4961 OPC_CheckPredicate, 30, // 2532: check predicate 30
4962 OPC_Decode, 215, 8, 235, 1, // 2534: decode to BZ_W using decoder 235
4963 // 2534: }
4964 27, 7, // 2539: case 0x1b: {
4965 OPC_CheckPredicate, 30, // 2541: check predicate 30
4966 OPC_Decode, 212, 8, 236, 1, // 2543: decode to BZ_D using decoder 236
4967 // 2543: }
4968 28, 7, // 2548: case 0x1c: {
4969 OPC_CheckPredicate, 30, // 2550: check predicate 30
4970 OPC_Decode, 186, 8, 219, 1, // 2552: decode to BNZ_B using decoder 219
4971 // 2552: }
4972 29, 7, // 2557: case 0x1d: {
4973 OPC_CheckPredicate, 30, // 2559: check predicate 30
4974 OPC_Decode, 188, 8, 234, 1, // 2561: decode to BNZ_H using decoder 234
4975 // 2561: }
4976 30, 7, // 2566: case 0x1e: {
4977 OPC_CheckPredicate, 30, // 2568: check predicate 30
4978 OPC_Decode, 190, 8, 235, 1, // 2570: decode to BNZ_W using decoder 235
4979 // 2570: }
4980 31, 0, // 2575: case 0x1f: {
4981 OPC_CheckPredicate, 30, // 2577: check predicate 30
4982 OPC_Decode, 187, 8, 236, 1, // 2579: decode to BNZ_D using decoder 236
4983 // 2579: }
4984 // 2579: } // switch Inst[25:21]
4985 // 2579: }
4986 18, 29, // 2584: case 0x12: {
4987 OPC_SwitchField, 21, 5, // 2586: switch Inst[25:21] {
4988 0, 11, // 2589: case 0x0: {
4989 OPC_CheckPredicate, 27, // 2591: check predicate 27
4990 OPC_CheckField, 3, 8, 0, // 2593: check Inst[10:3] == 0x0
4991 OPC_Decode, 172, 16, 237, 1, // 2597: decode to MFC2 using decoder 237
4992 // 2597: }
4993 4, 0, // 2602: case 0x4: {
4994 OPC_CheckPredicate, 27, // 2604: check predicate 27
4995 OPC_CheckField, 3, 8, 0, // 2606: check Inst[10:3] == 0x0
4996 OPC_Decode, 189, 17, 238, 1, // 2610: decode to MTC2 using decoder 238
4997 // 2610: }
4998 // 2610: } // switch Inst[25:21]
4999 // 2610: }
5000 19, 153, 1, // 2615: case 0x13: {
5001 OPC_SwitchField, 0, 6, // 2618: switch Inst[5:0] {
5002 0, 11, // 2621: case 0x0: {
5003 OPC_CheckPredicate, 63, // 2623: check predicate 63
5004 OPC_CheckField, 11, 5, 0, // 2625: check Inst[15:11] == 0x0
5005 OPC_Decode, 214, 15, 239, 1, // 2629: decode to LWXC1 using decoder 239
5006 // 2629: }
5007 1, 11, // 2634: case 0x1: {
5008 OPC_CheckPredicate, 64, // 2636: check predicate 64
5009 OPC_CheckField, 11, 5, 0, // 2638: check Inst[15:11] == 0x0
5010 OPC_Decode, 136, 15, 240, 1, // 2642: decode to LDXC1 using decoder 240
5011 // 2642: }
5012 5, 11, // 2647: case 0x5: {
5013 OPC_CheckPredicate, 65, // 2649: check predicate 65
5014 OPC_CheckField, 11, 5, 0, // 2651: check Inst[15:11] == 0x0
5015 OPC_Decode, 174, 15, 240, 1, // 2655: decode to LUXC1 using decoder 240
5016 // 2655: }
5017 8, 11, // 2660: case 0x8: {
5018 OPC_CheckPredicate, 63, // 2662: check predicate 63
5019 OPC_CheckField, 6, 5, 0, // 2664: check Inst[10:6] == 0x0
5020 OPC_Decode, 248, 21, 241, 1, // 2668: decode to SWXC1 using decoder 241
5021 // 2668: }
5022 9, 11, // 2673: case 0x9: {
5023 OPC_CheckPredicate, 64, // 2675: check predicate 64
5024 OPC_CheckField, 6, 5, 0, // 2677: check Inst[10:6] == 0x0
5025 OPC_Decode, 228, 19, 242, 1, // 2681: decode to SDXC1 using decoder 242
5026 // 2681: }
5027 13, 11, // 2686: case 0xd: {
5028 OPC_CheckPredicate, 65, // 2688: check predicate 65
5029 OPC_CheckField, 6, 5, 0, // 2690: check Inst[10:6] == 0x0
5030 OPC_Decode, 215, 21, 242, 1, // 2694: decode to SUXC1 using decoder 242
5031 // 2694: }
5032 32, 7, // 2699: case 0x20: {
5033 OPC_CheckPredicate, 66, // 2701: check predicate 66
5034 OPC_Decode, 255, 15, 243, 1, // 2703: decode to MADD_S using decoder 243
5035 // 2703: }
5036 33, 7, // 2708: case 0x21: {
5037 OPC_CheckPredicate, 67, // 2710: check predicate 67
5038 OPC_Decode, 247, 15, 244, 1, // 2712: decode to MADD_D32 using decoder 244
5039 // 2712: }
5040 40, 7, // 2717: case 0x28: {
5041 OPC_CheckPredicate, 66, // 2719: check predicate 66
5042 OPC_Decode, 179, 17, 243, 1, // 2721: decode to MSUB_S using decoder 243
5043 // 2721: }
5044 41, 7, // 2726: case 0x29: {
5045 OPC_CheckPredicate, 67, // 2728: check predicate 67
5046 OPC_Decode, 171, 17, 244, 1, // 2730: decode to MSUB_D32 using decoder 244
5047 // 2730: }
5048 48, 7, // 2735: case 0x30: {
5049 OPC_CheckPredicate, 68, // 2737: check predicate 68
5050 OPC_Decode, 159, 18, 243, 1, // 2739: decode to NMADD_S using decoder 243
5051 // 2739: }
5052 49, 7, // 2744: case 0x31: {
5053 OPC_CheckPredicate, 69, // 2746: check predicate 69
5054 OPC_Decode, 156, 18, 244, 1, // 2748: decode to NMADD_D32 using decoder 244
5055 // 2748: }
5056 56, 7, // 2753: case 0x38: {
5057 OPC_CheckPredicate, 68, // 2755: check predicate 68
5058 OPC_Decode, 164, 18, 243, 1, // 2757: decode to NMSUB_S using decoder 243
5059 // 2757: }
5060 57, 0, // 2762: case 0x39: {
5061 OPC_CheckPredicate, 69, // 2764: check predicate 69
5062 OPC_Decode, 161, 18, 244, 1, // 2766: decode to NMSUB_D32 using decoder 244
5063 // 2766: }
5064 // 2766: } // switch Inst[5:0]
5065 // 2766: }
5066 20, 7, // 2771: case 0x14: {
5067 OPC_CheckPredicate, 39, // 2773: check predicate 39
5068 OPC_Decode, 199, 7, 203, 1, // 2775: decode to BEQL using decoder 203
5069 // 2775: }
5070 21, 74, // 2780: case 0x15: {
5071 OPC_Scope, 22, // 2782: try {
5072 OPC_SwitchField, 0, 16, // 2784: switch Inst[15:0] {
5073 123, 7, // 2787: case 0x7b: {
5074 OPC_CheckPredicate, 20, // 2789: check predicate 20
5075 OPC_Decode, 191, 13, 131, 1, // 2791: decode to FMOV_S_MM using decoder 131
5076 // 2791: }
5077 251, 22, 0, // 2796: case 0xb7b: {
5078 OPC_CheckPredicate, 20, // 2799: check predicate 20
5079 OPC_Decode, 210, 13, 131, 1, // 2801: decode to FNEG_S_MM using decoder 131
5080 // 2801: }
5081 // 2801: } // switch Inst[15:0]
5082 OPC_Scope, 41, // 2806: } else try {
5083 OPC_SwitchField, 0, 11, // 2808: switch Inst[10:0] {
5084 48, 7, // 2811: case 0x30: {
5085 OPC_CheckPredicate, 20, // 2813: check predicate 20
5086 OPC_Decode, 229, 12, 165, 1, // 2815: decode to FADD_S_MM using decoder 165
5087 // 2815: }
5088 112, 7, // 2820: case 0x70: {
5089 OPC_CheckPredicate, 20, // 2822: check predicate 20
5090 OPC_Decode, 246, 13, 165, 1, // 2824: decode to FSUB_S_MM using decoder 165
5091 // 2824: }
5092 176, 1, 7, // 2829: case 0xb0: {
5093 OPC_CheckPredicate, 20, // 2832: check predicate 20
5094 OPC_Decode, 202, 13, 165, 1, // 2834: decode to FMUL_S_MM using decoder 165
5095 // 2834: }
5096 240, 1, 0, // 2839: case 0xf0: {
5097 OPC_CheckPredicate, 20, // 2842: check predicate 20
5098 OPC_Decode, 139, 13, 165, 1, // 2844: decode to FDIV_S_MM using decoder 165
5099 // 2844: }
5100 // 2844: } // switch Inst[10:0]
5101 // 2844: } else try {
5102 OPC_CheckPredicate, 39, // 2849: check predicate 39
5103 OPC_Decode, 174, 8, 203, 1, // 2851: decode to BNEL using decoder 203
5104 // 2851: }
5105 // 2851: }
5106 22, 11, // 2856: case 0x16: {
5107 OPC_CheckPredicate, 39, // 2858: check predicate 39
5108 OPC_CheckField, 16, 5, 0, // 2860: check Inst[20:16] == 0x0
5109 OPC_Decode, 136, 8, 199, 1, // 2864: decode to BLEZL using decoder 199
5110 // 2864: }
5111 23, 11, // 2869: case 0x17: {
5112 OPC_CheckPredicate, 39, // 2871: check predicate 39
5113 OPC_CheckField, 16, 5, 0, // 2873: check Inst[20:16] == 0x0
5114 OPC_Decode, 235, 7, 199, 1, // 2877: decode to BGTZL using decoder 199
5115 // 2877: }
5116 28, 166, 1, // 2882: case 0x1c: {
5117 OPC_SwitchField, 0, 6, // 2885: switch Inst[5:0] {
5118 0, 27, // 2888: case 0x0: {
5119 OPC_CheckField, 6, 5, 0, // 2890: check Inst[10:6] == 0x0
5120 OPC_CheckField, 13, 3, 0, // 2894: check Inst[15:13] == 0x0
5121 OPC_Scope, 10, // 2898: try {
5122 OPC_CheckField, 11, 2, 0, // 2900: check Inst[12:11] == 0x0
5123 OPC_CheckPredicate, 70, // 2904: check predicate 70
5124 OPC_Decode, 232, 15, 86, // 2906: decode to MADD using decoder 86
5125 // 2906: } else try {
5126 OPC_CheckPredicate, 37, // 2910: check predicate 37
5127 OPC_Decode, 250, 15, 245, 1, // 2912: decode to MADD_DSP using decoder 245
5128 // 2912: }
5129 // 2912: }
5130 1, 27, // 2917: case 0x1: {
5131 OPC_CheckField, 6, 5, 0, // 2919: check Inst[10:6] == 0x0
5132 OPC_CheckField, 13, 3, 0, // 2923: check Inst[15:13] == 0x0
5133 OPC_Scope, 10, // 2927: try {
5134 OPC_CheckField, 11, 2, 0, // 2929: check Inst[12:11] == 0x0
5135 OPC_CheckPredicate, 70, // 2933: check predicate 70
5136 OPC_Decode, 239, 15, 86, // 2935: decode to MADDU using decoder 86
5137 // 2935: } else try {
5138 OPC_CheckPredicate, 37, // 2939: check predicate 37
5139 OPC_Decode, 240, 15, 245, 1, // 2941: decode to MADDU_DSP using decoder 245
5140 // 2941: }
5141 // 2941: }
5142 2, 10, // 2946: case 0x2: {
5143 OPC_CheckPredicate, 70, // 2948: check predicate 70
5144 OPC_CheckField, 6, 5, 0, // 2950: check Inst[10:6] == 0x0
5145 OPC_Decode, 224, 17, 67, // 2954: decode to MUL using decoder 67
5146 // 2954: }
5147 4, 27, // 2958: case 0x4: {
5148 OPC_CheckField, 6, 5, 0, // 2960: check Inst[10:6] == 0x0
5149 OPC_CheckField, 13, 3, 0, // 2964: check Inst[15:13] == 0x0
5150 OPC_Scope, 10, // 2968: try {
5151 OPC_CheckField, 11, 2, 0, // 2970: check Inst[12:11] == 0x0
5152 OPC_CheckPredicate, 70, // 2974: check predicate 70
5153 OPC_Decode, 156, 17, 86, // 2976: decode to MSUB using decoder 86
5154 // 2976: } else try {
5155 OPC_CheckPredicate, 37, // 2980: check predicate 37
5156 OPC_Decode, 174, 17, 245, 1, // 2982: decode to MSUB_DSP using decoder 245
5157 // 2982: }
5158 // 2982: }
5159 5, 27, // 2987: case 0x5: {
5160 OPC_CheckField, 6, 5, 0, // 2989: check Inst[10:6] == 0x0
5161 OPC_CheckField, 13, 3, 0, // 2993: check Inst[15:13] == 0x0
5162 OPC_Scope, 10, // 2997: try {
5163 OPC_CheckField, 11, 2, 0, // 2999: check Inst[12:11] == 0x0
5164 OPC_CheckPredicate, 70, // 3003: check predicate 70
5165 OPC_Decode, 163, 17, 86, // 3005: decode to MSUBU using decoder 86
5166 // 3005: } else try {
5167 OPC_CheckPredicate, 37, // 3009: check predicate 37
5168 OPC_Decode, 164, 17, 245, 1, // 3011: decode to MSUBU_DSP using decoder 245
5169 // 3011: }
5170 // 3011: }
5171 32, 11, // 3016: case 0x20: {
5172 OPC_CheckPredicate, 70, // 3018: check predicate 70
5173 OPC_CheckField, 6, 5, 0, // 3020: check Inst[10:6] == 0x0
5174 OPC_Decode, 172, 9, 246, 1, // 3024: decode to CLZ using decoder 246
5175 // 3024: }
5176 33, 11, // 3029: case 0x21: {
5177 OPC_CheckPredicate, 70, // 3031: check predicate 70
5178 OPC_CheckField, 6, 5, 0, // 3033: check Inst[10:6] == 0x0
5179 OPC_Decode, 152, 9, 246, 1, // 3037: decode to CLO using decoder 246
5180 // 3037: }
5181 63, 0, // 3042: case 0x3f: {
5182 OPC_CheckPredicate, 70, // 3044: check predicate 70
5183 OPC_Decode, 209, 19, 190, 1, // 3046: decode to SDBBP using decoder 190
5184 // 3046: }
5185 // 3046: } // switch Inst[5:0]
5186 // 3046: }
5187 29, 7, // 3051: case 0x1d: {
5188 OPC_CheckPredicate, 70, // 3053: check predicate 70
5189 OPC_Decode, 203, 14, 202, 1, // 3055: decode to JALX using decoder 202
5190 // 3055: }
5191 30, 197, 39, // 3060: case 0x1e: {
5192 OPC_SwitchField, 0, 6, // 3063: switch Inst[5:0] {
5193 0, 39, // 3066: case 0x0: {
5194 OPC_SwitchField, 24, 2, // 3068: switch Inst[25:24] {
5195 0, 7, // 3071: case 0x0: {
5196 OPC_CheckPredicate, 30, // 3073: check predicate 30
5197 OPC_Decode, 239, 6, 247, 1, // 3075: decode to ANDI_B using decoder 247
5198 // 3075: }
5199 1, 7, // 3080: case 0x1: {
5200 OPC_CheckPredicate, 30, // 3082: check predicate 30
5201 OPC_Decode, 180, 18, 247, 1, // 3084: decode to ORI_B using decoder 247
5202 // 3084: }
5203 2, 7, // 3089: case 0x2: {
5204 OPC_CheckPredicate, 30, // 3091: check predicate 30
5205 OPC_Decode, 168, 18, 247, 1, // 3093: decode to NORI_B using decoder 247
5206 // 3093: }
5207 3, 0, // 3098: case 0x3: {
5208 OPC_CheckPredicate, 30, // 3100: check predicate 30
5209 OPC_Decode, 234, 22, 247, 1, // 3102: decode to XORI_B using decoder 247
5210 // 3102: }
5211 // 3102: } // switch Inst[25:24]
5212 // 3102: }
5213 1, 30, // 3107: case 0x1: {
5214 OPC_SwitchField, 24, 2, // 3109: switch Inst[25:24] {
5215 0, 7, // 3112: case 0x0: {
5216 OPC_CheckPredicate, 30, // 3114: check predicate 30
5217 OPC_Decode, 157, 8, 248, 1, // 3116: decode to BMNZI_B using decoder 248
5218 // 3116: }
5219 1, 7, // 3121: case 0x1: {
5220 OPC_CheckPredicate, 30, // 3123: check predicate 30
5221 OPC_Decode, 159, 8, 248, 1, // 3125: decode to BMZI_B using decoder 248
5222 // 3125: }
5223 2, 0, // 3130: case 0x2: {
5224 OPC_CheckPredicate, 30, // 3132: check predicate 30
5225 OPC_Decode, 201, 8, 248, 1, // 3134: decode to BSELI_B using decoder 248
5226 // 3134: }
5227 // 3134: } // switch Inst[25:24]
5228 // 3134: }
5229 2, 30, // 3139: case 0x2: {
5230 OPC_SwitchField, 24, 2, // 3141: switch Inst[25:24] {
5231 0, 7, // 3144: case 0x0: {
5232 OPC_CheckPredicate, 30, // 3146: check predicate 30
5233 OPC_Decode, 134, 20, 247, 1, // 3148: decode to SHF_B using decoder 247
5234 // 3148: }
5235 1, 7, // 3153: case 0x1: {
5236 OPC_CheckPredicate, 30, // 3155: check predicate 30
5237 OPC_Decode, 135, 20, 249, 1, // 3157: decode to SHF_H using decoder 249
5238 // 3157: }
5239 2, 0, // 3162: case 0x2: {
5240 OPC_CheckPredicate, 30, // 3164: check predicate 30
5241 OPC_Decode, 136, 20, 250, 1, // 3166: decode to SHF_W using decoder 250
5242 // 3166: }
5243 // 3166: } // switch Inst[25:24]
5244 // 3166: }
5245 6, 219, 1, // 3171: case 0x6: {
5246 OPC_SwitchField, 21, 5, // 3174: switch Inst[25:21] {
5247 0, 7, // 3177: case 0x0: {
5248 OPC_CheckPredicate, 30, // 3179: check predicate 30
5249 OPC_Decode, 207, 6, 251, 1, // 3181: decode to ADDVI_B using decoder 251
5250 // 3181: }
5251 1, 7, // 3186: case 0x1: {
5252 OPC_CheckPredicate, 30, // 3188: check predicate 30
5253 OPC_Decode, 209, 6, 252, 1, // 3190: decode to ADDVI_H using decoder 252
5254 // 3190: }
5255 2, 7, // 3195: case 0x2: {
5256 OPC_CheckPredicate, 30, // 3197: check predicate 30
5257 OPC_Decode, 210, 6, 253, 1, // 3199: decode to ADDVI_W using decoder 253
5258 // 3199: }
5259 3, 7, // 3204: case 0x3: {
5260 OPC_CheckPredicate, 30, // 3206: check predicate 30
5261 OPC_Decode, 208, 6, 254, 1, // 3208: decode to ADDVI_D using decoder 254
5262 // 3208: }
5263 4, 7, // 3213: case 0x4: {
5264 OPC_CheckPredicate, 30, // 3215: check predicate 30
5265 OPC_Decode, 203, 21, 251, 1, // 3217: decode to SUBVI_B using decoder 251
5266 // 3217: }
5267 5, 7, // 3222: case 0x5: {
5268 OPC_CheckPredicate, 30, // 3224: check predicate 30
5269 OPC_Decode, 205, 21, 252, 1, // 3226: decode to SUBVI_H using decoder 252
5270 // 3226: }
5271 6, 7, // 3231: case 0x6: {
5272 OPC_CheckPredicate, 30, // 3233: check predicate 30
5273 OPC_Decode, 206, 21, 253, 1, // 3235: decode to SUBVI_W using decoder 253
5274 // 3235: }
5275 7, 7, // 3240: case 0x7: {
5276 OPC_CheckPredicate, 30, // 3242: check predicate 30
5277 OPC_Decode, 204, 21, 254, 1, // 3244: decode to SUBVI_D using decoder 254
5278 // 3244: }
5279 8, 7, // 3249: case 0x8: {
5280 OPC_CheckPredicate, 30, // 3251: check predicate 30
5281 OPC_Decode, 141, 16, 251, 1, // 3253: decode to MAXI_S_B using decoder 251
5282 // 3253: }
5283 9, 7, // 3258: case 0x9: {
5284 OPC_CheckPredicate, 30, // 3260: check predicate 30
5285 OPC_Decode, 143, 16, 252, 1, // 3262: decode to MAXI_S_H using decoder 252
5286 // 3262: }
5287 10, 7, // 3267: case 0xa: {
5288 OPC_CheckPredicate, 30, // 3269: check predicate 30
5289 OPC_Decode, 144, 16, 253, 1, // 3271: decode to MAXI_S_W using decoder 253
5290 // 3271: }
5291 11, 7, // 3276: case 0xb: {
5292 OPC_CheckPredicate, 30, // 3278: check predicate 30
5293 OPC_Decode, 142, 16, 254, 1, // 3280: decode to MAXI_S_D using decoder 254
5294 // 3280: }
5295 12, 7, // 3285: case 0xc: {
5296 OPC_CheckPredicate, 30, // 3287: check predicate 30
5297 OPC_Decode, 145, 16, 251, 1, // 3289: decode to MAXI_U_B using decoder 251
5298 // 3289: }
5299 13, 7, // 3294: case 0xd: {
5300 OPC_CheckPredicate, 30, // 3296: check predicate 30
5301 OPC_Decode, 147, 16, 252, 1, // 3298: decode to MAXI_U_H using decoder 252
5302 // 3298: }
5303 14, 7, // 3303: case 0xe: {
5304 OPC_CheckPredicate, 30, // 3305: check predicate 30
5305 OPC_Decode, 148, 16, 253, 1, // 3307: decode to MAXI_U_W using decoder 253
5306 // 3307: }
5307 15, 7, // 3312: case 0xf: {
5308 OPC_CheckPredicate, 30, // 3314: check predicate 30
5309 OPC_Decode, 146, 16, 254, 1, // 3316: decode to MAXI_U_D using decoder 254
5310 // 3316: }
5311 16, 7, // 3321: case 0x10: {
5312 OPC_CheckPredicate, 30, // 3323: check predicate 30
5313 OPC_Decode, 201, 16, 251, 1, // 3325: decode to MINI_S_B using decoder 251
5314 // 3325: }
5315 17, 7, // 3330: case 0x11: {
5316 OPC_CheckPredicate, 30, // 3332: check predicate 30
5317 OPC_Decode, 203, 16, 252, 1, // 3334: decode to MINI_S_H using decoder 252
5318 // 3334: }
5319 18, 7, // 3339: case 0x12: {
5320 OPC_CheckPredicate, 30, // 3341: check predicate 30
5321 OPC_Decode, 204, 16, 253, 1, // 3343: decode to MINI_S_W using decoder 253
5322 // 3343: }
5323 19, 7, // 3348: case 0x13: {
5324 OPC_CheckPredicate, 30, // 3350: check predicate 30
5325 OPC_Decode, 202, 16, 254, 1, // 3352: decode to MINI_S_D using decoder 254
5326 // 3352: }
5327 20, 7, // 3357: case 0x14: {
5328 OPC_CheckPredicate, 30, // 3359: check predicate 30
5329 OPC_Decode, 205, 16, 251, 1, // 3361: decode to MINI_U_B using decoder 251
5330 // 3361: }
5331 21, 7, // 3366: case 0x15: {
5332 OPC_CheckPredicate, 30, // 3368: check predicate 30
5333 OPC_Decode, 207, 16, 252, 1, // 3370: decode to MINI_U_H using decoder 252
5334 // 3370: }
5335 22, 7, // 3375: case 0x16: {
5336 OPC_CheckPredicate, 30, // 3377: check predicate 30
5337 OPC_Decode, 208, 16, 253, 1, // 3379: decode to MINI_U_W using decoder 253
5338 // 3379: }
5339 23, 0, // 3384: case 0x17: {
5340 OPC_CheckPredicate, 30, // 3386: check predicate 30
5341 OPC_Decode, 206, 16, 254, 1, // 3388: decode to MINI_U_D using decoder 254
5342 // 3388: }
5343 // 3388: } // switch Inst[25:21]
5344 // 3388: }
5345 7, 219, 1, // 3393: case 0x7: {
5346 OPC_SwitchField, 21, 5, // 3396: switch Inst[25:21] {
5347 0, 7, // 3399: case 0x0: {
5348 OPC_CheckPredicate, 30, // 3401: check predicate 30
5349 OPC_Decode, 244, 8, 251, 1, // 3403: decode to CEQI_B using decoder 251
5350 // 3403: }
5351 1, 7, // 3408: case 0x1: {
5352 OPC_CheckPredicate, 30, // 3410: check predicate 30
5353 OPC_Decode, 246, 8, 252, 1, // 3412: decode to CEQI_H using decoder 252
5354 // 3412: }
5355 2, 7, // 3417: case 0x2: {
5356 OPC_CheckPredicate, 30, // 3419: check predicate 30
5357 OPC_Decode, 247, 8, 253, 1, // 3421: decode to CEQI_W using decoder 253
5358 // 3421: }
5359 3, 7, // 3426: case 0x3: {
5360 OPC_CheckPredicate, 30, // 3428: check predicate 30
5361 OPC_Decode, 245, 8, 254, 1, // 3430: decode to CEQI_D using decoder 254
5362 // 3430: }
5363 8, 7, // 3435: case 0x8: {
5364 OPC_CheckPredicate, 30, // 3437: check predicate 30
5365 OPC_Decode, 156, 9, 251, 1, // 3439: decode to CLTI_S_B using decoder 251
5366 // 3439: }
5367 9, 7, // 3444: case 0x9: {
5368 OPC_CheckPredicate, 30, // 3446: check predicate 30
5369 OPC_Decode, 158, 9, 252, 1, // 3448: decode to CLTI_S_H using decoder 252
5370 // 3448: }
5371 10, 7, // 3453: case 0xa: {
5372 OPC_CheckPredicate, 30, // 3455: check predicate 30
5373 OPC_Decode, 159, 9, 253, 1, // 3457: decode to CLTI_S_W using decoder 253
5374 // 3457: }
5375 11, 7, // 3462: case 0xb: {
5376 OPC_CheckPredicate, 30, // 3464: check predicate 30
5377 OPC_Decode, 157, 9, 254, 1, // 3466: decode to CLTI_S_D using decoder 254
5378 // 3466: }
5379 12, 7, // 3471: case 0xc: {
5380 OPC_CheckPredicate, 30, // 3473: check predicate 30
5381 OPC_Decode, 160, 9, 251, 1, // 3475: decode to CLTI_U_B using decoder 251
5382 // 3475: }
5383 13, 7, // 3480: case 0xd: {
5384 OPC_CheckPredicate, 30, // 3482: check predicate 30
5385 OPC_Decode, 162, 9, 252, 1, // 3484: decode to CLTI_U_H using decoder 252
5386 // 3484: }
5387 14, 7, // 3489: case 0xe: {
5388 OPC_CheckPredicate, 30, // 3491: check predicate 30
5389 OPC_Decode, 163, 9, 253, 1, // 3493: decode to CLTI_U_W using decoder 253
5390 // 3493: }
5391 15, 7, // 3498: case 0xf: {
5392 OPC_CheckPredicate, 30, // 3500: check predicate 30
5393 OPC_Decode, 161, 9, 254, 1, // 3502: decode to CLTI_U_D using decoder 254
5394 // 3502: }
5395 16, 7, // 3507: case 0x10: {
5396 OPC_CheckPredicate, 30, // 3509: check predicate 30
5397 OPC_Decode, 136, 9, 251, 1, // 3511: decode to CLEI_S_B using decoder 251
5398 // 3511: }
5399 17, 7, // 3516: case 0x11: {
5400 OPC_CheckPredicate, 30, // 3518: check predicate 30
5401 OPC_Decode, 138, 9, 252, 1, // 3520: decode to CLEI_S_H using decoder 252
5402 // 3520: }
5403 18, 7, // 3525: case 0x12: {
5404 OPC_CheckPredicate, 30, // 3527: check predicate 30
5405 OPC_Decode, 139, 9, 253, 1, // 3529: decode to CLEI_S_W using decoder 253
5406 // 3529: }
5407 19, 7, // 3534: case 0x13: {
5408 OPC_CheckPredicate, 30, // 3536: check predicate 30
5409 OPC_Decode, 137, 9, 254, 1, // 3538: decode to CLEI_S_D using decoder 254
5410 // 3538: }
5411 20, 7, // 3543: case 0x14: {
5412 OPC_CheckPredicate, 30, // 3545: check predicate 30
5413 OPC_Decode, 140, 9, 251, 1, // 3547: decode to CLEI_U_B using decoder 251
5414 // 3547: }
5415 21, 7, // 3552: case 0x15: {
5416 OPC_CheckPredicate, 30, // 3554: check predicate 30
5417 OPC_Decode, 142, 9, 252, 1, // 3556: decode to CLEI_U_H using decoder 252
5418 // 3556: }
5419 22, 7, // 3561: case 0x16: {
5420 OPC_CheckPredicate, 30, // 3563: check predicate 30
5421 OPC_Decode, 143, 9, 253, 1, // 3565: decode to CLEI_U_W using decoder 253
5422 // 3565: }
5423 23, 7, // 3570: case 0x17: {
5424 OPC_CheckPredicate, 30, // 3572: check predicate 30
5425 OPC_Decode, 141, 9, 254, 1, // 3574: decode to CLEI_U_D using decoder 254
5426 // 3574: }
5427 24, 7, // 3579: case 0x18: {
5428 OPC_CheckPredicate, 30, // 3581: check predicate 30
5429 OPC_Decode, 129, 15, 255, 1, // 3583: decode to LDI_B using decoder 255
5430 // 3583: }
5431 25, 7, // 3588: case 0x19: {
5432 OPC_CheckPredicate, 30, // 3590: check predicate 30
5433 OPC_Decode, 131, 15, 128, 2, // 3592: decode to LDI_H using decoder 256
5434 // 3592: }
5435 26, 7, // 3597: case 0x1a: {
5436 OPC_CheckPredicate, 30, // 3599: check predicate 30
5437 OPC_Decode, 132, 15, 129, 2, // 3601: decode to LDI_W using decoder 257
5438 // 3601: }
5439 27, 0, // 3606: case 0x1b: {
5440 OPC_CheckPredicate, 30, // 3608: check predicate 30
5441 OPC_Decode, 130, 15, 130, 2, // 3610: decode to LDI_D using decoder 258
5442 // 3610: }
5443 // 3610: } // switch Inst[25:21]
5444 // 3610: }
5445 9, 147, 3, // 3615: case 0x9: {
5446 OPC_SwitchField, 22, 4, // 3618: switch Inst[25:22] {
5447 0, 7, // 3621: case 0x0: {
5448 OPC_CheckPredicate, 30, // 3623: check predicate 30
5449 OPC_Decode, 203, 20, 131, 2, // 3625: decode to SLLI_D using decoder 259
5450 // 3625: }
5451 1, 39, // 3630: case 0x1: {
5452 OPC_SwitchField, 21, 1, // 3632: switch Inst[21] {
5453 0, 7, // 3635: case 0x0: {
5454 OPC_CheckPredicate, 30, // 3637: check predicate 30
5455 OPC_Decode, 205, 20, 253, 1, // 3639: decode to SLLI_W using decoder 253
5456 // 3639: }
5457 1, 0, // 3644: case 0x1: {
5458 OPC_SwitchField, 20, 1, // 3646: switch Inst[20] {
5459 0, 7, // 3649: case 0x0: {
5460 OPC_CheckPredicate, 30, // 3651: check predicate 30
5461 OPC_Decode, 204, 20, 132, 2, // 3653: decode to SLLI_H using decoder 260
5462 // 3653: }
5463 1, 0, // 3658: case 0x1: {
5464 OPC_CheckPredicate, 30, // 3660: check predicate 30
5465 OPC_CheckField, 19, 1, 0, // 3662: check Inst[19] == 0x0
5466 OPC_Decode, 202, 20, 133, 2, // 3666: decode to SLLI_B using decoder 261
5467 // 3666: }
5468 // 3666: } // switch Inst[20]
5469 // 3666: }
5470 // 3666: } // switch Inst[21]
5471 // 3666: }
5472 2, 7, // 3671: case 0x2: {
5473 OPC_CheckPredicate, 30, // 3673: check predicate 30
5474 OPC_Decode, 238, 20, 131, 2, // 3675: decode to SRAI_D using decoder 259
5475 // 3675: }
5476 3, 39, // 3680: case 0x3: {
5477 OPC_SwitchField, 21, 1, // 3682: switch Inst[21] {
5478 0, 7, // 3685: case 0x0: {
5479 OPC_CheckPredicate, 30, // 3687: check predicate 30
5480 OPC_Decode, 240, 20, 253, 1, // 3689: decode to SRAI_W using decoder 253
5481 // 3689: }
5482 1, 0, // 3694: case 0x1: {
5483 OPC_SwitchField, 20, 1, // 3696: switch Inst[20] {
5484 0, 7, // 3699: case 0x0: {
5485 OPC_CheckPredicate, 30, // 3701: check predicate 30
5486 OPC_Decode, 239, 20, 132, 2, // 3703: decode to SRAI_H using decoder 260
5487 // 3703: }
5488 1, 0, // 3708: case 0x1: {
5489 OPC_CheckPredicate, 30, // 3710: check predicate 30
5490 OPC_CheckField, 19, 1, 0, // 3712: check Inst[19] == 0x0
5491 OPC_Decode, 237, 20, 133, 2, // 3716: decode to SRAI_B using decoder 261
5492 // 3716: }
5493 // 3716: } // switch Inst[20]
5494 // 3716: }
5495 // 3716: } // switch Inst[21]
5496 // 3716: }
5497 4, 7, // 3721: case 0x4: {
5498 OPC_CheckPredicate, 30, // 3723: check predicate 30
5499 OPC_Decode, 132, 21, 131, 2, // 3725: decode to SRLI_D using decoder 259
5500 // 3725: }
5501 5, 39, // 3730: case 0x5: {
5502 OPC_SwitchField, 21, 1, // 3732: switch Inst[21] {
5503 0, 7, // 3735: case 0x0: {
5504 OPC_CheckPredicate, 30, // 3737: check predicate 30
5505 OPC_Decode, 134, 21, 253, 1, // 3739: decode to SRLI_W using decoder 253
5506 // 3739: }
5507 1, 0, // 3744: case 0x1: {
5508 OPC_SwitchField, 20, 1, // 3746: switch Inst[20] {
5509 0, 7, // 3749: case 0x0: {
5510 OPC_CheckPredicate, 30, // 3751: check predicate 30
5511 OPC_Decode, 133, 21, 132, 2, // 3753: decode to SRLI_H using decoder 260
5512 // 3753: }
5513 1, 0, // 3758: case 0x1: {
5514 OPC_CheckPredicate, 30, // 3760: check predicate 30
5515 OPC_CheckField, 19, 1, 0, // 3762: check Inst[19] == 0x0
5516 OPC_Decode, 131, 21, 133, 2, // 3766: decode to SRLI_B using decoder 261
5517 // 3766: }
5518 // 3766: } // switch Inst[20]
5519 // 3766: }
5520 // 3766: } // switch Inst[21]
5521 // 3766: }
5522 6, 7, // 3771: case 0x6: {
5523 OPC_CheckPredicate, 30, // 3773: check predicate 30
5524 OPC_Decode, 186, 7, 131, 2, // 3775: decode to BCLRI_D using decoder 259
5525 // 3775: }
5526 7, 39, // 3780: case 0x7: {
5527 OPC_SwitchField, 21, 1, // 3782: switch Inst[21] {
5528 0, 7, // 3785: case 0x0: {
5529 OPC_CheckPredicate, 30, // 3787: check predicate 30
5530 OPC_Decode, 188, 7, 253, 1, // 3789: decode to BCLRI_W using decoder 253
5531 // 3789: }
5532 1, 0, // 3794: case 0x1: {
5533 OPC_SwitchField, 20, 1, // 3796: switch Inst[20] {
5534 0, 7, // 3799: case 0x0: {
5535 OPC_CheckPredicate, 30, // 3801: check predicate 30
5536 OPC_Decode, 187, 7, 132, 2, // 3803: decode to BCLRI_H using decoder 260
5537 // 3803: }
5538 1, 0, // 3808: case 0x1: {
5539 OPC_CheckPredicate, 30, // 3810: check predicate 30
5540 OPC_CheckField, 19, 1, 0, // 3812: check Inst[19] == 0x0
5541 OPC_Decode, 185, 7, 133, 2, // 3816: decode to BCLRI_B using decoder 261
5542 // 3816: }
5543 // 3816: } // switch Inst[20]
5544 // 3816: }
5545 // 3816: } // switch Inst[21]
5546 // 3816: }
5547 8, 7, // 3821: case 0x8: {
5548 OPC_CheckPredicate, 30, // 3823: check predicate 30
5549 OPC_Decode, 204, 8, 131, 2, // 3825: decode to BSETI_D using decoder 259
5550 // 3825: }
5551 9, 39, // 3830: case 0x9: {
5552 OPC_SwitchField, 21, 1, // 3832: switch Inst[21] {
5553 0, 7, // 3835: case 0x0: {
5554 OPC_CheckPredicate, 30, // 3837: check predicate 30
5555 OPC_Decode, 206, 8, 253, 1, // 3839: decode to BSETI_W using decoder 253
5556 // 3839: }
5557 1, 0, // 3844: case 0x1: {
5558 OPC_SwitchField, 20, 1, // 3846: switch Inst[20] {
5559 0, 7, // 3849: case 0x0: {
5560 OPC_CheckPredicate, 30, // 3851: check predicate 30
5561 OPC_Decode, 205, 8, 132, 2, // 3853: decode to BSETI_H using decoder 260
5562 // 3853: }
5563 1, 0, // 3858: case 0x1: {
5564 OPC_CheckPredicate, 30, // 3860: check predicate 30
5565 OPC_CheckField, 19, 1, 0, // 3862: check Inst[19] == 0x0
5566 OPC_Decode, 203, 8, 133, 2, // 3866: decode to BSETI_B using decoder 261
5567 // 3866: }
5568 // 3866: } // switch Inst[20]
5569 // 3866: }
5570 // 3866: } // switch Inst[21]
5571 // 3866: }
5572 10, 7, // 3871: case 0xa: {
5573 OPC_CheckPredicate, 30, // 3873: check predicate 30
5574 OPC_Decode, 167, 8, 131, 2, // 3875: decode to BNEGI_D using decoder 259
5575 // 3875: }
5576 11, 39, // 3880: case 0xb: {
5577 OPC_SwitchField, 21, 1, // 3882: switch Inst[21] {
5578 0, 7, // 3885: case 0x0: {
5579 OPC_CheckPredicate, 30, // 3887: check predicate 30
5580 OPC_Decode, 169, 8, 253, 1, // 3889: decode to BNEGI_W using decoder 253
5581 // 3889: }
5582 1, 0, // 3894: case 0x1: {
5583 OPC_SwitchField, 20, 1, // 3896: switch Inst[20] {
5584 0, 7, // 3899: case 0x0: {
5585 OPC_CheckPredicate, 30, // 3901: check predicate 30
5586 OPC_Decode, 168, 8, 132, 2, // 3903: decode to BNEGI_H using decoder 260
5587 // 3903: }
5588 1, 0, // 3908: case 0x1: {
5589 OPC_CheckPredicate, 30, // 3910: check predicate 30
5590 OPC_CheckField, 19, 1, 0, // 3912: check Inst[19] == 0x0
5591 OPC_Decode, 166, 8, 133, 2, // 3916: decode to BNEGI_B using decoder 261
5592 // 3916: }
5593 // 3916: } // switch Inst[20]
5594 // 3916: }
5595 // 3916: } // switch Inst[21]
5596 // 3916: }
5597 12, 7, // 3921: case 0xc: {
5598 OPC_CheckPredicate, 30, // 3923: check predicate 30
5599 OPC_Decode, 238, 7, 134, 2, // 3925: decode to BINSLI_D using decoder 262
5600 // 3925: }
5601 13, 39, // 3930: case 0xd: {
5602 OPC_SwitchField, 21, 1, // 3932: switch Inst[21] {
5603 0, 7, // 3935: case 0x0: {
5604 OPC_CheckPredicate, 30, // 3937: check predicate 30
5605 OPC_Decode, 240, 7, 135, 2, // 3939: decode to BINSLI_W using decoder 263
5606 // 3939: }
5607 1, 0, // 3944: case 0x1: {
5608 OPC_SwitchField, 20, 1, // 3946: switch Inst[20] {
5609 0, 7, // 3949: case 0x0: {
5610 OPC_CheckPredicate, 30, // 3951: check predicate 30
5611 OPC_Decode, 239, 7, 136, 2, // 3953: decode to BINSLI_H using decoder 264
5612 // 3953: }
5613 1, 0, // 3958: case 0x1: {
5614 OPC_CheckPredicate, 30, // 3960: check predicate 30
5615 OPC_CheckField, 19, 1, 0, // 3962: check Inst[19] == 0x0
5616 OPC_Decode, 237, 7, 137, 2, // 3966: decode to BINSLI_B using decoder 265
5617 // 3966: }
5618 // 3966: } // switch Inst[20]
5619 // 3966: }
5620 // 3966: } // switch Inst[21]
5621 // 3966: }
5622 14, 7, // 3971: case 0xe: {
5623 OPC_CheckPredicate, 30, // 3973: check predicate 30
5624 OPC_Decode, 246, 7, 134, 2, // 3975: decode to BINSRI_D using decoder 262
5625 // 3975: }
5626 15, 0, // 3980: case 0xf: {
5627 OPC_SwitchField, 21, 1, // 3982: switch Inst[21] {
5628 0, 7, // 3985: case 0x0: {
5629 OPC_CheckPredicate, 30, // 3987: check predicate 30
5630 OPC_Decode, 248, 7, 135, 2, // 3989: decode to BINSRI_W using decoder 263
5631 // 3989: }
5632 1, 0, // 3994: case 0x1: {
5633 OPC_SwitchField, 20, 1, // 3996: switch Inst[20] {
5634 0, 7, // 3999: case 0x0: {
5635 OPC_CheckPredicate, 30, // 4001: check predicate 30
5636 OPC_Decode, 247, 7, 136, 2, // 4003: decode to BINSRI_H using decoder 264
5637 // 4003: }
5638 1, 0, // 4008: case 0x1: {
5639 OPC_CheckPredicate, 30, // 4010: check predicate 30
5640 OPC_CheckField, 19, 1, 0, // 4012: check Inst[19] == 0x0
5641 OPC_Decode, 245, 7, 137, 2, // 4016: decode to BINSRI_B using decoder 265
5642 // 4016: }
5643 // 4016: } // switch Inst[20]
5644 // 4016: }
5645 // 4016: } // switch Inst[21]
5646 // 4016: }
5647 // 4016: } // switch Inst[25:22]
5648 // 4016: }
5649 10, 203, 1, // 4021: case 0xa: {
5650 OPC_SwitchField, 22, 4, // 4024: switch Inst[25:22] {
5651 0, 7, // 4027: case 0x0: {
5652 OPC_CheckPredicate, 30, // 4029: check predicate 30
5653 OPC_Decode, 183, 19, 131, 2, // 4031: decode to SAT_S_D using decoder 259
5654 // 4031: }
5655 1, 39, // 4036: case 0x1: {
5656 OPC_SwitchField, 21, 1, // 4038: switch Inst[21] {
5657 0, 7, // 4041: case 0x0: {
5658 OPC_CheckPredicate, 30, // 4043: check predicate 30
5659 OPC_Decode, 185, 19, 253, 1, // 4045: decode to SAT_S_W using decoder 253
5660 // 4045: }
5661 1, 0, // 4050: case 0x1: {
5662 OPC_SwitchField, 20, 1, // 4052: switch Inst[20] {
5663 0, 7, // 4055: case 0x0: {
5664 OPC_CheckPredicate, 30, // 4057: check predicate 30
5665 OPC_Decode, 184, 19, 132, 2, // 4059: decode to SAT_S_H using decoder 260
5666 // 4059: }
5667 1, 0, // 4064: case 0x1: {
5668 OPC_CheckPredicate, 30, // 4066: check predicate 30
5669 OPC_CheckField, 19, 1, 0, // 4068: check Inst[19] == 0x0
5670 OPC_Decode, 182, 19, 133, 2, // 4072: decode to SAT_S_B using decoder 261
5671 // 4072: }
5672 // 4072: } // switch Inst[20]
5673 // 4072: }
5674 // 4072: } // switch Inst[21]
5675 // 4072: }
5676 2, 7, // 4077: case 0x2: {
5677 OPC_CheckPredicate, 30, // 4079: check predicate 30
5678 OPC_Decode, 187, 19, 131, 2, // 4081: decode to SAT_U_D using decoder 259
5679 // 4081: }
5680 3, 39, // 4086: case 0x3: {
5681 OPC_SwitchField, 21, 1, // 4088: switch Inst[21] {
5682 0, 7, // 4091: case 0x0: {
5683 OPC_CheckPredicate, 30, // 4093: check predicate 30
5684 OPC_Decode, 189, 19, 253, 1, // 4095: decode to SAT_U_W using decoder 253
5685 // 4095: }
5686 1, 0, // 4100: case 0x1: {
5687 OPC_SwitchField, 20, 1, // 4102: switch Inst[20] {
5688 0, 7, // 4105: case 0x0: {
5689 OPC_CheckPredicate, 30, // 4107: check predicate 30
5690 OPC_Decode, 188, 19, 132, 2, // 4109: decode to SAT_U_H using decoder 260
5691 // 4109: }
5692 1, 0, // 4114: case 0x1: {
5693 OPC_CheckPredicate, 30, // 4116: check predicate 30
5694 OPC_CheckField, 19, 1, 0, // 4118: check Inst[19] == 0x0
5695 OPC_Decode, 186, 19, 133, 2, // 4122: decode to SAT_U_B using decoder 261
5696 // 4122: }
5697 // 4122: } // switch Inst[20]
5698 // 4122: }
5699 // 4122: } // switch Inst[21]
5700 // 4122: }
5701 4, 7, // 4127: case 0x4: {
5702 OPC_CheckPredicate, 30, // 4129: check predicate 30
5703 OPC_Decode, 242, 20, 131, 2, // 4131: decode to SRARI_D using decoder 259
5704 // 4131: }
5705 5, 39, // 4136: case 0x5: {
5706 OPC_SwitchField, 21, 1, // 4138: switch Inst[21] {
5707 0, 7, // 4141: case 0x0: {
5708 OPC_CheckPredicate, 30, // 4143: check predicate 30
5709 OPC_Decode, 244, 20, 253, 1, // 4145: decode to SRARI_W using decoder 253
5710 // 4145: }
5711 1, 0, // 4150: case 0x1: {
5712 OPC_SwitchField, 20, 1, // 4152: switch Inst[20] {
5713 0, 7, // 4155: case 0x0: {
5714 OPC_CheckPredicate, 30, // 4157: check predicate 30
5715 OPC_Decode, 243, 20, 132, 2, // 4159: decode to SRARI_H using decoder 260
5716 // 4159: }
5717 1, 0, // 4164: case 0x1: {
5718 OPC_CheckPredicate, 30, // 4166: check predicate 30
5719 OPC_CheckField, 19, 1, 0, // 4168: check Inst[19] == 0x0
5720 OPC_Decode, 241, 20, 133, 2, // 4172: decode to SRARI_B using decoder 261
5721 // 4172: }
5722 // 4172: } // switch Inst[20]
5723 // 4172: }
5724 // 4172: } // switch Inst[21]
5725 // 4172: }
5726 6, 7, // 4177: case 0x6: {
5727 OPC_CheckPredicate, 30, // 4179: check predicate 30
5728 OPC_Decode, 136, 21, 131, 2, // 4181: decode to SRLRI_D using decoder 259
5729 // 4181: }
5730 7, 0, // 4186: case 0x7: {
5731 OPC_SwitchField, 21, 1, // 4188: switch Inst[21] {
5732 0, 7, // 4191: case 0x0: {
5733 OPC_CheckPredicate, 30, // 4193: check predicate 30
5734 OPC_Decode, 138, 21, 253, 1, // 4195: decode to SRLRI_W using decoder 253
5735 // 4195: }
5736 1, 0, // 4200: case 0x1: {
5737 OPC_SwitchField, 20, 1, // 4202: switch Inst[20] {
5738 0, 7, // 4205: case 0x0: {
5739 OPC_CheckPredicate, 30, // 4207: check predicate 30
5740 OPC_Decode, 137, 21, 132, 2, // 4209: decode to SRLRI_H using decoder 260
5741 // 4209: }
5742 1, 0, // 4214: case 0x1: {
5743 OPC_CheckPredicate, 30, // 4216: check predicate 30
5744 OPC_CheckField, 19, 1, 0, // 4218: check Inst[19] == 0x0
5745 OPC_Decode, 135, 21, 133, 2, // 4222: decode to SRLRI_B using decoder 261
5746 // 4222: }
5747 // 4222: } // switch Inst[20]
5748 // 4222: }
5749 // 4222: } // switch Inst[21]
5750 // 4222: }
5751 // 4222: } // switch Inst[25:22]
5752 // 4222: }
5753 13, 163, 2, // 4227: case 0xd: {
5754 OPC_SwitchField, 21, 5, // 4230: switch Inst[25:21] {
5755 0, 7, // 4233: case 0x0: {
5756 OPC_CheckPredicate, 30, // 4235: check predicate 30
5757 OPC_Decode, 208, 20, 138, 2, // 4237: decode to SLL_B using decoder 266
5758 // 4237: }
5759 1, 7, // 4242: case 0x1: {
5760 OPC_CheckPredicate, 30, // 4244: check predicate 30
5761 OPC_Decode, 210, 20, 139, 2, // 4246: decode to SLL_H using decoder 267
5762 // 4246: }
5763 2, 7, // 4251: case 0x2: {
5764 OPC_CheckPredicate, 30, // 4253: check predicate 30
5765 OPC_Decode, 213, 20, 140, 2, // 4255: decode to SLL_W using decoder 268
5766 // 4255: }
5767 3, 7, // 4260: case 0x3: {
5768 OPC_CheckPredicate, 30, // 4262: check predicate 30
5769 OPC_Decode, 209, 20, 141, 2, // 4264: decode to SLL_D using decoder 269
5770 // 4264: }
5771 4, 7, // 4269: case 0x4: {
5772 OPC_CheckPredicate, 30, // 4271: check predicate 30
5773 OPC_Decode, 251, 20, 138, 2, // 4273: decode to SRA_B using decoder 266
5774 // 4273: }
5775 5, 7, // 4278: case 0x5: {
5776 OPC_CheckPredicate, 30, // 4280: check predicate 30
5777 OPC_Decode, 253, 20, 139, 2, // 4282: decode to SRA_H using decoder 267
5778 // 4282: }
5779 6, 7, // 4287: case 0x6: {
5780 OPC_CheckPredicate, 30, // 4289: check predicate 30
5781 OPC_Decode, 255, 20, 140, 2, // 4291: decode to SRA_W using decoder 268
5782 // 4291: }
5783 7, 7, // 4296: case 0x7: {
5784 OPC_CheckPredicate, 30, // 4298: check predicate 30
5785 OPC_Decode, 252, 20, 141, 2, // 4300: decode to SRA_D using decoder 269
5786 // 4300: }
5787 8, 7, // 4305: case 0x8: {
5788 OPC_CheckPredicate, 30, // 4307: check predicate 30
5789 OPC_Decode, 145, 21, 138, 2, // 4309: decode to SRL_B using decoder 266
5790 // 4309: }
5791 9, 7, // 4314: case 0x9: {
5792 OPC_CheckPredicate, 30, // 4316: check predicate 30
5793 OPC_Decode, 147, 21, 139, 2, // 4318: decode to SRL_H using decoder 267
5794 // 4318: }
5795 10, 7, // 4323: case 0xa: {
5796 OPC_CheckPredicate, 30, // 4325: check predicate 30
5797 OPC_Decode, 149, 21, 140, 2, // 4327: decode to SRL_W using decoder 268
5798 // 4327: }
5799 11, 7, // 4332: case 0xb: {
5800 OPC_CheckPredicate, 30, // 4334: check predicate 30
5801 OPC_Decode, 146, 21, 141, 2, // 4336: decode to SRL_D using decoder 269
5802 // 4336: }
5803 12, 7, // 4341: case 0xc: {
5804 OPC_CheckPredicate, 30, // 4343: check predicate 30
5805 OPC_Decode, 189, 7, 138, 2, // 4345: decode to BCLR_B using decoder 266
5806 // 4345: }
5807 13, 7, // 4350: case 0xd: {
5808 OPC_CheckPredicate, 30, // 4352: check predicate 30
5809 OPC_Decode, 191, 7, 139, 2, // 4354: decode to BCLR_H using decoder 267
5810 // 4354: }
5811 14, 7, // 4359: case 0xe: {
5812 OPC_CheckPredicate, 30, // 4361: check predicate 30
5813 OPC_Decode, 192, 7, 140, 2, // 4363: decode to BCLR_W using decoder 268
5814 // 4363: }
5815 15, 7, // 4368: case 0xf: {
5816 OPC_CheckPredicate, 30, // 4370: check predicate 30
5817 OPC_Decode, 190, 7, 141, 2, // 4372: decode to BCLR_D using decoder 269
5818 // 4372: }
5819 16, 7, // 4377: case 0x10: {
5820 OPC_CheckPredicate, 30, // 4379: check predicate 30
5821 OPC_Decode, 207, 8, 138, 2, // 4381: decode to BSET_B using decoder 266
5822 // 4381: }
5823 17, 7, // 4386: case 0x11: {
5824 OPC_CheckPredicate, 30, // 4388: check predicate 30
5825 OPC_Decode, 209, 8, 139, 2, // 4390: decode to BSET_H using decoder 267
5826 // 4390: }
5827 18, 7, // 4395: case 0x12: {
5828 OPC_CheckPredicate, 30, // 4397: check predicate 30
5829 OPC_Decode, 210, 8, 140, 2, // 4399: decode to BSET_W using decoder 268
5830 // 4399: }
5831 19, 7, // 4404: case 0x13: {
5832 OPC_CheckPredicate, 30, // 4406: check predicate 30
5833 OPC_Decode, 208, 8, 141, 2, // 4408: decode to BSET_D using decoder 269
5834 // 4408: }
5835 20, 7, // 4413: case 0x14: {
5836 OPC_CheckPredicate, 30, // 4415: check predicate 30
5837 OPC_Decode, 170, 8, 138, 2, // 4417: decode to BNEG_B using decoder 266
5838 // 4417: }
5839 21, 7, // 4422: case 0x15: {
5840 OPC_CheckPredicate, 30, // 4424: check predicate 30
5841 OPC_Decode, 172, 8, 139, 2, // 4426: decode to BNEG_H using decoder 267
5842 // 4426: }
5843 22, 7, // 4431: case 0x16: {
5844 OPC_CheckPredicate, 30, // 4433: check predicate 30
5845 OPC_Decode, 173, 8, 140, 2, // 4435: decode to BNEG_W using decoder 268
5846 // 4435: }
5847 23, 7, // 4440: case 0x17: {
5848 OPC_CheckPredicate, 30, // 4442: check predicate 30
5849 OPC_Decode, 171, 8, 141, 2, // 4444: decode to BNEG_D using decoder 269
5850 // 4444: }
5851 24, 7, // 4449: case 0x18: {
5852 OPC_CheckPredicate, 30, // 4451: check predicate 30
5853 OPC_Decode, 241, 7, 142, 2, // 4453: decode to BINSL_B using decoder 270
5854 // 4453: }
5855 25, 7, // 4458: case 0x19: {
5856 OPC_CheckPredicate, 30, // 4460: check predicate 30
5857 OPC_Decode, 243, 7, 143, 2, // 4462: decode to BINSL_H using decoder 271
5858 // 4462: }
5859 26, 7, // 4467: case 0x1a: {
5860 OPC_CheckPredicate, 30, // 4469: check predicate 30
5861 OPC_Decode, 244, 7, 144, 2, // 4471: decode to BINSL_W using decoder 272
5862 // 4471: }
5863 27, 7, // 4476: case 0x1b: {
5864 OPC_CheckPredicate, 30, // 4478: check predicate 30
5865 OPC_Decode, 242, 7, 145, 2, // 4480: decode to BINSL_D using decoder 273
5866 // 4480: }
5867 28, 7, // 4485: case 0x1c: {
5868 OPC_CheckPredicate, 30, // 4487: check predicate 30
5869 OPC_Decode, 249, 7, 142, 2, // 4489: decode to BINSR_B using decoder 270
5870 // 4489: }
5871 29, 7, // 4494: case 0x1d: {
5872 OPC_CheckPredicate, 30, // 4496: check predicate 30
5873 OPC_Decode, 251, 7, 143, 2, // 4498: decode to BINSR_H using decoder 271
5874 // 4498: }
5875 30, 7, // 4503: case 0x1e: {
5876 OPC_CheckPredicate, 30, // 4505: check predicate 30
5877 OPC_Decode, 252, 7, 144, 2, // 4507: decode to BINSR_W using decoder 272
5878 // 4507: }
5879 31, 0, // 4512: case 0x1f: {
5880 OPC_CheckPredicate, 30, // 4514: check predicate 30
5881 OPC_Decode, 250, 7, 145, 2, // 4516: decode to BINSR_D using decoder 273
5882 // 4516: }
5883 // 4516: } // switch Inst[25:21]
5884 // 4516: }
5885 14, 163, 2, // 4521: case 0xe: {
5886 OPC_SwitchField, 21, 5, // 4524: switch Inst[25:21] {
5887 0, 7, // 4527: case 0x0: {
5888 OPC_CheckPredicate, 30, // 4529: check predicate 30
5889 OPC_Decode, 211, 6, 138, 2, // 4531: decode to ADDV_B using decoder 266
5890 // 4531: }
5891 1, 7, // 4536: case 0x1: {
5892 OPC_CheckPredicate, 30, // 4538: check predicate 30
5893 OPC_Decode, 213, 6, 139, 2, // 4540: decode to ADDV_H using decoder 267
5894 // 4540: }
5895 2, 7, // 4545: case 0x2: {
5896 OPC_CheckPredicate, 30, // 4547: check predicate 30
5897 OPC_Decode, 214, 6, 140, 2, // 4549: decode to ADDV_W using decoder 268
5898 // 4549: }
5899 3, 7, // 4554: case 0x3: {
5900 OPC_CheckPredicate, 30, // 4556: check predicate 30
5901 OPC_Decode, 212, 6, 141, 2, // 4558: decode to ADDV_D using decoder 269
5902 // 4558: }
5903 4, 7, // 4563: case 0x4: {
5904 OPC_CheckPredicate, 30, // 4565: check predicate 30
5905 OPC_Decode, 207, 21, 138, 2, // 4567: decode to SUBV_B using decoder 266
5906 // 4567: }
5907 5, 7, // 4572: case 0x5: {
5908 OPC_CheckPredicate, 30, // 4574: check predicate 30
5909 OPC_Decode, 209, 21, 139, 2, // 4576: decode to SUBV_H using decoder 267
5910 // 4576: }
5911 6, 7, // 4581: case 0x6: {
5912 OPC_CheckPredicate, 30, // 4583: check predicate 30
5913 OPC_Decode, 210, 21, 140, 2, // 4585: decode to SUBV_W using decoder 268
5914 // 4585: }
5915 7, 7, // 4590: case 0x7: {
5916 OPC_CheckPredicate, 30, // 4592: check predicate 30
5917 OPC_Decode, 208, 21, 141, 2, // 4594: decode to SUBV_D using decoder 269
5918 // 4594: }
5919 8, 7, // 4599: case 0x8: {
5920 OPC_CheckPredicate, 30, // 4601: check predicate 30
5921 OPC_Decode, 156, 16, 138, 2, // 4603: decode to MAX_S_B using decoder 266
5922 // 4603: }
5923 9, 7, // 4608: case 0x9: {
5924 OPC_CheckPredicate, 30, // 4610: check predicate 30
5925 OPC_Decode, 158, 16, 139, 2, // 4612: decode to MAX_S_H using decoder 267
5926 // 4612: }
5927 10, 7, // 4617: case 0xa: {
5928 OPC_CheckPredicate, 30, // 4619: check predicate 30
5929 OPC_Decode, 160, 16, 140, 2, // 4621: decode to MAX_S_W using decoder 268
5930 // 4621: }
5931 11, 7, // 4626: case 0xb: {
5932 OPC_CheckPredicate, 30, // 4628: check predicate 30
5933 OPC_Decode, 157, 16, 141, 2, // 4630: decode to MAX_S_D using decoder 269
5934 // 4630: }
5935 12, 7, // 4635: case 0xc: {
5936 OPC_CheckPredicate, 30, // 4637: check predicate 30
5937 OPC_Decode, 161, 16, 138, 2, // 4639: decode to MAX_U_B using decoder 266
5938 // 4639: }
5939 13, 7, // 4644: case 0xd: {
5940 OPC_CheckPredicate, 30, // 4646: check predicate 30
5941 OPC_Decode, 163, 16, 139, 2, // 4648: decode to MAX_U_H using decoder 267
5942 // 4648: }
5943 14, 7, // 4653: case 0xe: {
5944 OPC_CheckPredicate, 30, // 4655: check predicate 30
5945 OPC_Decode, 164, 16, 140, 2, // 4657: decode to MAX_U_W using decoder 268
5946 // 4657: }
5947 15, 7, // 4662: case 0xf: {
5948 OPC_CheckPredicate, 30, // 4664: check predicate 30
5949 OPC_Decode, 162, 16, 141, 2, // 4666: decode to MAX_U_D using decoder 269
5950 // 4666: }
5951 16, 7, // 4671: case 0x10: {
5952 OPC_CheckPredicate, 30, // 4673: check predicate 30
5953 OPC_Decode, 216, 16, 138, 2, // 4675: decode to MIN_S_B using decoder 266
5954 // 4675: }
5955 17, 7, // 4680: case 0x11: {
5956 OPC_CheckPredicate, 30, // 4682: check predicate 30
5957 OPC_Decode, 218, 16, 139, 2, // 4684: decode to MIN_S_H using decoder 267
5958 // 4684: }
5959 18, 7, // 4689: case 0x12: {
5960 OPC_CheckPredicate, 30, // 4691: check predicate 30
5961 OPC_Decode, 220, 16, 140, 2, // 4693: decode to MIN_S_W using decoder 268
5962 // 4693: }
5963 19, 7, // 4698: case 0x13: {
5964 OPC_CheckPredicate, 30, // 4700: check predicate 30
5965 OPC_Decode, 217, 16, 141, 2, // 4702: decode to MIN_S_D using decoder 269
5966 // 4702: }
5967 20, 7, // 4707: case 0x14: {
5968 OPC_CheckPredicate, 30, // 4709: check predicate 30
5969 OPC_Decode, 221, 16, 138, 2, // 4711: decode to MIN_U_B using decoder 266
5970 // 4711: }
5971 21, 7, // 4716: case 0x15: {
5972 OPC_CheckPredicate, 30, // 4718: check predicate 30
5973 OPC_Decode, 223, 16, 139, 2, // 4720: decode to MIN_U_H using decoder 267
5974 // 4720: }
5975 22, 7, // 4725: case 0x16: {
5976 OPC_CheckPredicate, 30, // 4727: check predicate 30
5977 OPC_Decode, 224, 16, 140, 2, // 4729: decode to MIN_U_W using decoder 268
5978 // 4729: }
5979 23, 7, // 4734: case 0x17: {
5980 OPC_CheckPredicate, 30, // 4736: check predicate 30
5981 OPC_Decode, 222, 16, 141, 2, // 4738: decode to MIN_U_D using decoder 269
5982 // 4738: }
5983 24, 7, // 4743: case 0x18: {
5984 OPC_CheckPredicate, 30, // 4745: check predicate 30
5985 OPC_Decode, 149, 16, 138, 2, // 4747: decode to MAX_A_B using decoder 266
5986 // 4747: }
5987 25, 7, // 4752: case 0x19: {
5988 OPC_CheckPredicate, 30, // 4754: check predicate 30
5989 OPC_Decode, 151, 16, 139, 2, // 4756: decode to MAX_A_H using decoder 267
5990 // 4756: }
5991 26, 7, // 4761: case 0x1a: {
5992 OPC_CheckPredicate, 30, // 4763: check predicate 30
5993 OPC_Decode, 152, 16, 140, 2, // 4765: decode to MAX_A_W using decoder 268
5994 // 4765: }
5995 27, 7, // 4770: case 0x1b: {
5996 OPC_CheckPredicate, 30, // 4772: check predicate 30
5997 OPC_Decode, 150, 16, 141, 2, // 4774: decode to MAX_A_D using decoder 269
5998 // 4774: }
5999 28, 7, // 4779: case 0x1c: {
6000 OPC_CheckPredicate, 30, // 4781: check predicate 30
6001 OPC_Decode, 209, 16, 138, 2, // 4783: decode to MIN_A_B using decoder 266
6002 // 4783: }
6003 29, 7, // 4788: case 0x1d: {
6004 OPC_CheckPredicate, 30, // 4790: check predicate 30
6005 OPC_Decode, 211, 16, 139, 2, // 4792: decode to MIN_A_H using decoder 267
6006 // 4792: }
6007 30, 7, // 4797: case 0x1e: {
6008 OPC_CheckPredicate, 30, // 4799: check predicate 30
6009 OPC_Decode, 212, 16, 140, 2, // 4801: decode to MIN_A_W using decoder 268
6010 // 4801: }
6011 31, 0, // 4806: case 0x1f: {
6012 OPC_CheckPredicate, 30, // 4808: check predicate 30
6013 OPC_Decode, 210, 16, 141, 2, // 4810: decode to MIN_A_D using decoder 269
6014 // 4810: }
6015 // 4810: } // switch Inst[25:21]
6016 // 4810: }
6017 15, 183, 1, // 4815: case 0xf: {
6018 OPC_SwitchField, 21, 5, // 4818: switch Inst[25:21] {
6019 0, 7, // 4821: case 0x0: {
6020 OPC_CheckPredicate, 30, // 4823: check predicate 30
6021 OPC_Decode, 248, 8, 138, 2, // 4825: decode to CEQ_B using decoder 266
6022 // 4825: }
6023 1, 7, // 4830: case 0x1: {
6024 OPC_CheckPredicate, 30, // 4832: check predicate 30
6025 OPC_Decode, 250, 8, 139, 2, // 4834: decode to CEQ_H using decoder 267
6026 // 4834: }
6027 2, 7, // 4839: case 0x2: {
6028 OPC_CheckPredicate, 30, // 4841: check predicate 30
6029 OPC_Decode, 251, 8, 140, 2, // 4843: decode to CEQ_W using decoder 268
6030 // 4843: }
6031 3, 7, // 4848: case 0x3: {
6032 OPC_CheckPredicate, 30, // 4850: check predicate 30
6033 OPC_Decode, 249, 8, 141, 2, // 4852: decode to CEQ_D using decoder 269
6034 // 4852: }
6035 8, 7, // 4857: case 0x8: {
6036 OPC_CheckPredicate, 30, // 4859: check predicate 30
6037 OPC_Decode, 164, 9, 138, 2, // 4861: decode to CLT_S_B using decoder 266
6038 // 4861: }
6039 9, 7, // 4866: case 0x9: {
6040 OPC_CheckPredicate, 30, // 4868: check predicate 30
6041 OPC_Decode, 166, 9, 139, 2, // 4870: decode to CLT_S_H using decoder 267
6042 // 4870: }
6043 10, 7, // 4875: case 0xa: {
6044 OPC_CheckPredicate, 30, // 4877: check predicate 30
6045 OPC_Decode, 167, 9, 140, 2, // 4879: decode to CLT_S_W using decoder 268
6046 // 4879: }
6047 11, 7, // 4884: case 0xb: {
6048 OPC_CheckPredicate, 30, // 4886: check predicate 30
6049 OPC_Decode, 165, 9, 141, 2, // 4888: decode to CLT_S_D using decoder 269
6050 // 4888: }
6051 12, 7, // 4893: case 0xc: {
6052 OPC_CheckPredicate, 30, // 4895: check predicate 30
6053 OPC_Decode, 168, 9, 138, 2, // 4897: decode to CLT_U_B using decoder 266
6054 // 4897: }
6055 13, 7, // 4902: case 0xd: {
6056 OPC_CheckPredicate, 30, // 4904: check predicate 30
6057 OPC_Decode, 170, 9, 139, 2, // 4906: decode to CLT_U_H using decoder 267
6058 // 4906: }
6059 14, 7, // 4911: case 0xe: {
6060 OPC_CheckPredicate, 30, // 4913: check predicate 30
6061 OPC_Decode, 171, 9, 140, 2, // 4915: decode to CLT_U_W using decoder 268
6062 // 4915: }
6063 15, 7, // 4920: case 0xf: {
6064 OPC_CheckPredicate, 30, // 4922: check predicate 30
6065 OPC_Decode, 169, 9, 141, 2, // 4924: decode to CLT_U_D using decoder 269
6066 // 4924: }
6067 16, 7, // 4929: case 0x10: {
6068 OPC_CheckPredicate, 30, // 4931: check predicate 30
6069 OPC_Decode, 144, 9, 138, 2, // 4933: decode to CLE_S_B using decoder 266
6070 // 4933: }
6071 17, 7, // 4938: case 0x11: {
6072 OPC_CheckPredicate, 30, // 4940: check predicate 30
6073 OPC_Decode, 146, 9, 139, 2, // 4942: decode to CLE_S_H using decoder 267
6074 // 4942: }
6075 18, 7, // 4947: case 0x12: {
6076 OPC_CheckPredicate, 30, // 4949: check predicate 30
6077 OPC_Decode, 147, 9, 140, 2, // 4951: decode to CLE_S_W using decoder 268
6078 // 4951: }
6079 19, 7, // 4956: case 0x13: {
6080 OPC_CheckPredicate, 30, // 4958: check predicate 30
6081 OPC_Decode, 145, 9, 141, 2, // 4960: decode to CLE_S_D using decoder 269
6082 // 4960: }
6083 20, 7, // 4965: case 0x14: {
6084 OPC_CheckPredicate, 30, // 4967: check predicate 30
6085 OPC_Decode, 148, 9, 138, 2, // 4969: decode to CLE_U_B using decoder 266
6086 // 4969: }
6087 21, 7, // 4974: case 0x15: {
6088 OPC_CheckPredicate, 30, // 4976: check predicate 30
6089 OPC_Decode, 150, 9, 139, 2, // 4978: decode to CLE_U_H using decoder 267
6090 // 4978: }
6091 22, 7, // 4983: case 0x16: {
6092 OPC_CheckPredicate, 30, // 4985: check predicate 30
6093 OPC_Decode, 151, 9, 140, 2, // 4987: decode to CLE_U_W using decoder 268
6094 // 4987: }
6095 23, 0, // 4992: case 0x17: {
6096 OPC_CheckPredicate, 30, // 4994: check predicate 30
6097 OPC_Decode, 149, 9, 141, 2, // 4996: decode to CLE_U_D using decoder 269
6098 // 4996: }
6099 // 4996: } // switch Inst[25:21]
6100 // 4996: }
6101 16, 163, 2, // 5001: case 0x10: {
6102 OPC_SwitchField, 21, 5, // 5004: switch Inst[25:21] {
6103 0, 7, // 5007: case 0x0: {
6104 OPC_CheckPredicate, 30, // 5009: check predicate 30
6105 OPC_Decode, 217, 6, 138, 2, // 5011: decode to ADD_A_B using decoder 266
6106 // 5011: }
6107 1, 7, // 5016: case 0x1: {
6108 OPC_CheckPredicate, 30, // 5018: check predicate 30
6109 OPC_Decode, 219, 6, 139, 2, // 5020: decode to ADD_A_H using decoder 267
6110 // 5020: }
6111 2, 7, // 5025: case 0x2: {
6112 OPC_CheckPredicate, 30, // 5027: check predicate 30
6113 OPC_Decode, 220, 6, 140, 2, // 5029: decode to ADD_A_W using decoder 268
6114 // 5029: }
6115 3, 7, // 5034: case 0x3: {
6116 OPC_CheckPredicate, 30, // 5036: check predicate 30
6117 OPC_Decode, 218, 6, 141, 2, // 5038: decode to ADD_A_D using decoder 269
6118 // 5038: }
6119 4, 7, // 5043: case 0x4: {
6120 OPC_CheckPredicate, 30, // 5045: check predicate 30
6121 OPC_Decode, 180, 6, 138, 2, // 5047: decode to ADDS_A_B using decoder 266
6122 // 5047: }
6123 5, 7, // 5052: case 0x5: {
6124 OPC_CheckPredicate, 30, // 5054: check predicate 30
6125 OPC_Decode, 182, 6, 139, 2, // 5056: decode to ADDS_A_H using decoder 267
6126 // 5056: }
6127 6, 7, // 5061: case 0x6: {
6128 OPC_CheckPredicate, 30, // 5063: check predicate 30
6129 OPC_Decode, 183, 6, 140, 2, // 5065: decode to ADDS_A_W using decoder 268
6130 // 5065: }
6131 7, 7, // 5070: case 0x7: {
6132 OPC_CheckPredicate, 30, // 5072: check predicate 30
6133 OPC_Decode, 181, 6, 141, 2, // 5074: decode to ADDS_A_D using decoder 269
6134 // 5074: }
6135 8, 7, // 5079: case 0x8: {
6136 OPC_CheckPredicate, 30, // 5081: check predicate 30
6137 OPC_Decode, 184, 6, 138, 2, // 5083: decode to ADDS_S_B using decoder 266
6138 // 5083: }
6139 9, 7, // 5088: case 0x9: {
6140 OPC_CheckPredicate, 30, // 5090: check predicate 30
6141 OPC_Decode, 186, 6, 139, 2, // 5092: decode to ADDS_S_H using decoder 267
6142 // 5092: }
6143 10, 7, // 5097: case 0xa: {
6144 OPC_CheckPredicate, 30, // 5099: check predicate 30
6145 OPC_Decode, 187, 6, 140, 2, // 5101: decode to ADDS_S_W using decoder 268
6146 // 5101: }
6147 11, 7, // 5106: case 0xb: {
6148 OPC_CheckPredicate, 30, // 5108: check predicate 30
6149 OPC_Decode, 185, 6, 141, 2, // 5110: decode to ADDS_S_D using decoder 269
6150 // 5110: }
6151 12, 7, // 5115: case 0xc: {
6152 OPC_CheckPredicate, 30, // 5117: check predicate 30
6153 OPC_Decode, 188, 6, 138, 2, // 5119: decode to ADDS_U_B using decoder 266
6154 // 5119: }
6155 13, 7, // 5124: case 0xd: {
6156 OPC_CheckPredicate, 30, // 5126: check predicate 30
6157 OPC_Decode, 190, 6, 139, 2, // 5128: decode to ADDS_U_H using decoder 267
6158 // 5128: }
6159 14, 7, // 5133: case 0xe: {
6160 OPC_CheckPredicate, 30, // 5135: check predicate 30
6161 OPC_Decode, 191, 6, 140, 2, // 5137: decode to ADDS_U_W using decoder 268
6162 // 5137: }
6163 15, 7, // 5142: case 0xf: {
6164 OPC_CheckPredicate, 30, // 5144: check predicate 30
6165 OPC_Decode, 189, 6, 141, 2, // 5146: decode to ADDS_U_D using decoder 269
6166 // 5146: }
6167 16, 7, // 5151: case 0x10: {
6168 OPC_CheckPredicate, 30, // 5153: check predicate 30
6169 OPC_Decode, 141, 7, 138, 2, // 5155: decode to AVE_S_B using decoder 266
6170 // 5155: }
6171 17, 7, // 5160: case 0x11: {
6172 OPC_CheckPredicate, 30, // 5162: check predicate 30
6173 OPC_Decode, 143, 7, 139, 2, // 5164: decode to AVE_S_H using decoder 267
6174 // 5164: }
6175 18, 7, // 5169: case 0x12: {
6176 OPC_CheckPredicate, 30, // 5171: check predicate 30
6177 OPC_Decode, 144, 7, 140, 2, // 5173: decode to AVE_S_W using decoder 268
6178 // 5173: }
6179 19, 7, // 5178: case 0x13: {
6180 OPC_CheckPredicate, 30, // 5180: check predicate 30
6181 OPC_Decode, 142, 7, 141, 2, // 5182: decode to AVE_S_D using decoder 269
6182 // 5182: }
6183 20, 7, // 5187: case 0x14: {
6184 OPC_CheckPredicate, 30, // 5189: check predicate 30
6185 OPC_Decode, 145, 7, 138, 2, // 5191: decode to AVE_U_B using decoder 266
6186 // 5191: }
6187 21, 7, // 5196: case 0x15: {
6188 OPC_CheckPredicate, 30, // 5198: check predicate 30
6189 OPC_Decode, 147, 7, 139, 2, // 5200: decode to AVE_U_H using decoder 267
6190 // 5200: }
6191 22, 7, // 5205: case 0x16: {
6192 OPC_CheckPredicate, 30, // 5207: check predicate 30
6193 OPC_Decode, 148, 7, 140, 2, // 5209: decode to AVE_U_W using decoder 268
6194 // 5209: }
6195 23, 7, // 5214: case 0x17: {
6196 OPC_CheckPredicate, 30, // 5216: check predicate 30
6197 OPC_Decode, 146, 7, 141, 2, // 5218: decode to AVE_U_D using decoder 269
6198 // 5218: }
6199 24, 7, // 5223: case 0x18: {
6200 OPC_CheckPredicate, 30, // 5225: check predicate 30
6201 OPC_Decode, 133, 7, 138, 2, // 5227: decode to AVER_S_B using decoder 266
6202 // 5227: }
6203 25, 7, // 5232: case 0x19: {
6204 OPC_CheckPredicate, 30, // 5234: check predicate 30
6205 OPC_Decode, 135, 7, 139, 2, // 5236: decode to AVER_S_H using decoder 267
6206 // 5236: }
6207 26, 7, // 5241: case 0x1a: {
6208 OPC_CheckPredicate, 30, // 5243: check predicate 30
6209 OPC_Decode, 136, 7, 140, 2, // 5245: decode to AVER_S_W using decoder 268
6210 // 5245: }
6211 27, 7, // 5250: case 0x1b: {
6212 OPC_CheckPredicate, 30, // 5252: check predicate 30
6213 OPC_Decode, 134, 7, 141, 2, // 5254: decode to AVER_S_D using decoder 269
6214 // 5254: }
6215 28, 7, // 5259: case 0x1c: {
6216 OPC_CheckPredicate, 30, // 5261: check predicate 30
6217 OPC_Decode, 137, 7, 138, 2, // 5263: decode to AVER_U_B using decoder 266
6218 // 5263: }
6219 29, 7, // 5268: case 0x1d: {
6220 OPC_CheckPredicate, 30, // 5270: check predicate 30
6221 OPC_Decode, 139, 7, 139, 2, // 5272: decode to AVER_U_H using decoder 267
6222 // 5272: }
6223 30, 7, // 5277: case 0x1e: {
6224 OPC_CheckPredicate, 30, // 5279: check predicate 30
6225 OPC_Decode, 140, 7, 140, 2, // 5281: decode to AVER_U_W using decoder 268
6226 // 5281: }
6227 31, 0, // 5286: case 0x1f: {
6228 OPC_CheckPredicate, 30, // 5288: check predicate 30
6229 OPC_Decode, 138, 7, 141, 2, // 5290: decode to AVER_U_D using decoder 269
6230 // 5290: }
6231 // 5290: } // switch Inst[25:21]
6232 // 5290: }
6233 17, 219, 1, // 5295: case 0x11: {
6234 OPC_SwitchField, 21, 5, // 5298: switch Inst[25:21] {
6235 0, 7, // 5301: case 0x0: {
6236 OPC_CheckPredicate, 30, // 5303: check predicate 30
6237 OPC_Decode, 180, 21, 138, 2, // 5305: decode to SUBS_S_B using decoder 266
6238 // 5305: }
6239 1, 7, // 5310: case 0x1: {
6240 OPC_CheckPredicate, 30, // 5312: check predicate 30
6241 OPC_Decode, 182, 21, 139, 2, // 5314: decode to SUBS_S_H using decoder 267
6242 // 5314: }
6243 2, 7, // 5319: case 0x2: {
6244 OPC_CheckPredicate, 30, // 5321: check predicate 30
6245 OPC_Decode, 183, 21, 140, 2, // 5323: decode to SUBS_S_W using decoder 268
6246 // 5323: }
6247 3, 7, // 5328: case 0x3: {
6248 OPC_CheckPredicate, 30, // 5330: check predicate 30
6249 OPC_Decode, 181, 21, 141, 2, // 5332: decode to SUBS_S_D using decoder 269
6250 // 5332: }
6251 4, 7, // 5337: case 0x4: {
6252 OPC_CheckPredicate, 30, // 5339: check predicate 30
6253 OPC_Decode, 184, 21, 138, 2, // 5341: decode to SUBS_U_B using decoder 266
6254 // 5341: }
6255 5, 7, // 5346: case 0x5: {
6256 OPC_CheckPredicate, 30, // 5348: check predicate 30
6257 OPC_Decode, 186, 21, 139, 2, // 5350: decode to SUBS_U_H using decoder 267
6258 // 5350: }
6259 6, 7, // 5355: case 0x6: {
6260 OPC_CheckPredicate, 30, // 5357: check predicate 30
6261 OPC_Decode, 187, 21, 140, 2, // 5359: decode to SUBS_U_W using decoder 268
6262 // 5359: }
6263 7, 7, // 5364: case 0x7: {
6264 OPC_CheckPredicate, 30, // 5366: check predicate 30
6265 OPC_Decode, 185, 21, 141, 2, // 5368: decode to SUBS_U_D using decoder 269
6266 // 5368: }
6267 8, 7, // 5373: case 0x8: {
6268 OPC_CheckPredicate, 30, // 5375: check predicate 30
6269 OPC_Decode, 172, 21, 138, 2, // 5377: decode to SUBSUS_U_B using decoder 266
6270 // 5377: }
6271 9, 7, // 5382: case 0x9: {
6272 OPC_CheckPredicate, 30, // 5384: check predicate 30
6273 OPC_Decode, 174, 21, 139, 2, // 5386: decode to SUBSUS_U_H using decoder 267
6274 // 5386: }
6275 10, 7, // 5391: case 0xa: {
6276 OPC_CheckPredicate, 30, // 5393: check predicate 30
6277 OPC_Decode, 175, 21, 140, 2, // 5395: decode to SUBSUS_U_W using decoder 268
6278 // 5395: }
6279 11, 7, // 5400: case 0xb: {
6280 OPC_CheckPredicate, 30, // 5402: check predicate 30
6281 OPC_Decode, 173, 21, 141, 2, // 5404: decode to SUBSUS_U_D using decoder 269
6282 // 5404: }
6283 12, 7, // 5409: case 0xc: {
6284 OPC_CheckPredicate, 30, // 5411: check predicate 30
6285 OPC_Decode, 176, 21, 138, 2, // 5413: decode to SUBSUU_S_B using decoder 266
6286 // 5413: }
6287 13, 7, // 5418: case 0xd: {
6288 OPC_CheckPredicate, 30, // 5420: check predicate 30
6289 OPC_Decode, 178, 21, 139, 2, // 5422: decode to SUBSUU_S_H using decoder 267
6290 // 5422: }
6291 14, 7, // 5427: case 0xe: {
6292 OPC_CheckPredicate, 30, // 5429: check predicate 30
6293 OPC_Decode, 179, 21, 140, 2, // 5431: decode to SUBSUU_S_W using decoder 268
6294 // 5431: }
6295 15, 7, // 5436: case 0xf: {
6296 OPC_CheckPredicate, 30, // 5438: check predicate 30
6297 OPC_Decode, 177, 21, 141, 2, // 5440: decode to SUBSUU_S_D using decoder 269
6298 // 5440: }
6299 16, 7, // 5445: case 0x10: {
6300 OPC_CheckPredicate, 30, // 5447: check predicate 30
6301 OPC_Decode, 249, 6, 138, 2, // 5449: decode to ASUB_S_B using decoder 266
6302 // 5449: }
6303 17, 7, // 5454: case 0x11: {
6304 OPC_CheckPredicate, 30, // 5456: check predicate 30
6305 OPC_Decode, 251, 6, 139, 2, // 5458: decode to ASUB_S_H using decoder 267
6306 // 5458: }
6307 18, 7, // 5463: case 0x12: {
6308 OPC_CheckPredicate, 30, // 5465: check predicate 30
6309 OPC_Decode, 252, 6, 140, 2, // 5467: decode to ASUB_S_W using decoder 268
6310 // 5467: }
6311 19, 7, // 5472: case 0x13: {
6312 OPC_CheckPredicate, 30, // 5474: check predicate 30
6313 OPC_Decode, 250, 6, 141, 2, // 5476: decode to ASUB_S_D using decoder 269
6314 // 5476: }
6315 20, 7, // 5481: case 0x14: {
6316 OPC_CheckPredicate, 30, // 5483: check predicate 30
6317 OPC_Decode, 253, 6, 138, 2, // 5485: decode to ASUB_U_B using decoder 266
6318 // 5485: }
6319 21, 7, // 5490: case 0x15: {
6320 OPC_CheckPredicate, 30, // 5492: check predicate 30
6321 OPC_Decode, 255, 6, 139, 2, // 5494: decode to ASUB_U_H using decoder 267
6322 // 5494: }
6323 22, 7, // 5499: case 0x16: {
6324 OPC_CheckPredicate, 30, // 5501: check predicate 30
6325 OPC_Decode, 128, 7, 140, 2, // 5503: decode to ASUB_U_W using decoder 268
6326 // 5503: }
6327 23, 0, // 5508: case 0x17: {
6328 OPC_CheckPredicate, 30, // 5510: check predicate 30
6329 OPC_Decode, 254, 6, 141, 2, // 5512: decode to ASUB_U_D using decoder 269
6330 // 5512: }
6331 // 5512: } // switch Inst[25:21]
6332 // 5512: }
6333 18, 255, 1, // 5517: case 0x12: {
6334 OPC_SwitchField, 21, 5, // 5520: switch Inst[25:21] {
6335 0, 7, // 5523: case 0x0: {
6336 OPC_CheckPredicate, 30, // 5525: check predicate 30
6337 OPC_Decode, 130, 18, 138, 2, // 5527: decode to MULV_B using decoder 266
6338 // 5527: }
6339 1, 7, // 5532: case 0x1: {
6340 OPC_CheckPredicate, 30, // 5534: check predicate 30
6341 OPC_Decode, 132, 18, 139, 2, // 5536: decode to MULV_H using decoder 267
6342 // 5536: }
6343 2, 7, // 5541: case 0x2: {
6344 OPC_CheckPredicate, 30, // 5543: check predicate 30
6345 OPC_Decode, 133, 18, 140, 2, // 5545: decode to MULV_W using decoder 268
6346 // 5545: }
6347 3, 7, // 5550: case 0x3: {
6348 OPC_CheckPredicate, 30, // 5552: check predicate 30
6349 OPC_Decode, 131, 18, 141, 2, // 5554: decode to MULV_D using decoder 269
6350 // 5554: }
6351 4, 7, // 5559: case 0x4: {
6352 OPC_CheckPredicate, 30, // 5561: check predicate 30
6353 OPC_Decode, 243, 15, 142, 2, // 5563: decode to MADDV_B using decoder 270
6354 // 5563: }
6355 5, 7, // 5568: case 0x5: {
6356 OPC_CheckPredicate, 30, // 5570: check predicate 30
6357 OPC_Decode, 245, 15, 143, 2, // 5572: decode to MADDV_H using decoder 271
6358 // 5572: }
6359 6, 7, // 5577: case 0x6: {
6360 OPC_CheckPredicate, 30, // 5579: check predicate 30
6361 OPC_Decode, 246, 15, 144, 2, // 5581: decode to MADDV_W using decoder 272
6362 // 5581: }
6363 7, 7, // 5586: case 0x7: {
6364 OPC_CheckPredicate, 30, // 5588: check predicate 30
6365 OPC_Decode, 244, 15, 145, 2, // 5590: decode to MADDV_D using decoder 273
6366 // 5590: }
6367 8, 7, // 5595: case 0x8: {
6368 OPC_CheckPredicate, 30, // 5597: check predicate 30
6369 OPC_Decode, 167, 17, 142, 2, // 5599: decode to MSUBV_B using decoder 270
6370 // 5599: }
6371 9, 7, // 5604: case 0x9: {
6372 OPC_CheckPredicate, 30, // 5606: check predicate 30
6373 OPC_Decode, 169, 17, 143, 2, // 5608: decode to MSUBV_H using decoder 271
6374 // 5608: }
6375 10, 7, // 5613: case 0xa: {
6376 OPC_CheckPredicate, 30, // 5615: check predicate 30
6377 OPC_Decode, 170, 17, 144, 2, // 5617: decode to MSUBV_W using decoder 272
6378 // 5617: }
6379 11, 7, // 5622: case 0xb: {
6380 OPC_CheckPredicate, 30, // 5624: check predicate 30
6381 OPC_Decode, 168, 17, 145, 2, // 5626: decode to MSUBV_D using decoder 273
6382 // 5626: }
6383 16, 7, // 5631: case 0x10: {
6384 OPC_CheckPredicate, 30, // 5633: check predicate 30
6385 OPC_Decode, 193, 11, 138, 2, // 5635: decode to DIV_S_B using decoder 266
6386 // 5635: }
6387 17, 7, // 5640: case 0x11: {
6388 OPC_CheckPredicate, 30, // 5642: check predicate 30
6389 OPC_Decode, 195, 11, 139, 2, // 5644: decode to DIV_S_H using decoder 267
6390 // 5644: }
6391 18, 7, // 5649: case 0x12: {
6392 OPC_CheckPredicate, 30, // 5651: check predicate 30
6393 OPC_Decode, 196, 11, 140, 2, // 5653: decode to DIV_S_W using decoder 268
6394 // 5653: }
6395 19, 7, // 5658: case 0x13: {
6396 OPC_CheckPredicate, 30, // 5660: check predicate 30
6397 OPC_Decode, 194, 11, 141, 2, // 5662: decode to DIV_S_D using decoder 269
6398 // 5662: }
6399 20, 7, // 5667: case 0x14: {
6400 OPC_CheckPredicate, 30, // 5669: check predicate 30
6401 OPC_Decode, 197, 11, 138, 2, // 5671: decode to DIV_U_B using decoder 266
6402 // 5671: }
6403 21, 7, // 5676: case 0x15: {
6404 OPC_CheckPredicate, 30, // 5678: check predicate 30
6405 OPC_Decode, 199, 11, 139, 2, // 5680: decode to DIV_U_H using decoder 267
6406 // 5680: }
6407 22, 7, // 5685: case 0x16: {
6408 OPC_CheckPredicate, 30, // 5687: check predicate 30
6409 OPC_Decode, 200, 11, 140, 2, // 5689: decode to DIV_U_W using decoder 268
6410 // 5689: }
6411 23, 7, // 5694: case 0x17: {
6412 OPC_CheckPredicate, 30, // 5696: check predicate 30
6413 OPC_Decode, 198, 11, 141, 2, // 5698: decode to DIV_U_D using decoder 269
6414 // 5698: }
6415 24, 7, // 5703: case 0x18: {
6416 OPC_CheckPredicate, 30, // 5705: check predicate 30
6417 OPC_Decode, 231, 16, 138, 2, // 5707: decode to MOD_S_B using decoder 266
6418 // 5707: }
6419 25, 7, // 5712: case 0x19: {
6420 OPC_CheckPredicate, 30, // 5714: check predicate 30
6421 OPC_Decode, 233, 16, 139, 2, // 5716: decode to MOD_S_H using decoder 267
6422 // 5716: }
6423 26, 7, // 5721: case 0x1a: {
6424 OPC_CheckPredicate, 30, // 5723: check predicate 30
6425 OPC_Decode, 234, 16, 140, 2, // 5725: decode to MOD_S_W using decoder 268
6426 // 5725: }
6427 27, 7, // 5730: case 0x1b: {
6428 OPC_CheckPredicate, 30, // 5732: check predicate 30
6429 OPC_Decode, 232, 16, 141, 2, // 5734: decode to MOD_S_D using decoder 269
6430 // 5734: }
6431 28, 7, // 5739: case 0x1c: {
6432 OPC_CheckPredicate, 30, // 5741: check predicate 30
6433 OPC_Decode, 235, 16, 138, 2, // 5743: decode to MOD_U_B using decoder 266
6434 // 5743: }
6435 29, 7, // 5748: case 0x1d: {
6436 OPC_CheckPredicate, 30, // 5750: check predicate 30
6437 OPC_Decode, 237, 16, 139, 2, // 5752: decode to MOD_U_H using decoder 267
6438 // 5752: }
6439 30, 7, // 5757: case 0x1e: {
6440 OPC_CheckPredicate, 30, // 5759: check predicate 30
6441 OPC_Decode, 238, 16, 140, 2, // 5761: decode to MOD_U_W using decoder 268
6442 // 5761: }
6443 31, 0, // 5766: case 0x1f: {
6444 OPC_CheckPredicate, 30, // 5768: check predicate 30
6445 OPC_Decode, 236, 16, 141, 2, // 5770: decode to MOD_U_D using decoder 269
6446 // 5770: }
6447 // 5770: } // switch Inst[25:21]
6448 // 5770: }
6449 19, 165, 1, // 5775: case 0x13: {
6450 OPC_SwitchField, 21, 5, // 5778: switch Inst[25:21] {
6451 1, 7, // 5781: case 0x1: {
6452 OPC_CheckPredicate, 30, // 5783: check predicate 30
6453 OPC_Decode, 226, 11, 146, 2, // 5785: decode to DOTP_S_H using decoder 274
6454 // 5785: }
6455 2, 7, // 5790: case 0x2: {
6456 OPC_CheckPredicate, 30, // 5792: check predicate 30
6457 OPC_Decode, 227, 11, 147, 2, // 5794: decode to DOTP_S_W using decoder 275
6458 // 5794: }
6459 3, 7, // 5799: case 0x3: {
6460 OPC_CheckPredicate, 30, // 5801: check predicate 30
6461 OPC_Decode, 225, 11, 148, 2, // 5803: decode to DOTP_S_D using decoder 276
6462 // 5803: }
6463 5, 7, // 5808: case 0x5: {
6464 OPC_CheckPredicate, 30, // 5810: check predicate 30
6465 OPC_Decode, 229, 11, 146, 2, // 5812: decode to DOTP_U_H using decoder 274
6466 // 5812: }
6467 6, 7, // 5817: case 0x6: {
6468 OPC_CheckPredicate, 30, // 5819: check predicate 30
6469 OPC_Decode, 230, 11, 147, 2, // 5821: decode to DOTP_U_W using decoder 275
6470 // 5821: }
6471 7, 7, // 5826: case 0x7: {
6472 OPC_CheckPredicate, 30, // 5828: check predicate 30
6473 OPC_Decode, 228, 11, 148, 2, // 5830: decode to DOTP_U_D using decoder 276
6474 // 5830: }
6475 9, 7, // 5835: case 0x9: {
6476 OPC_CheckPredicate, 30, // 5837: check predicate 30
6477 OPC_Decode, 232, 11, 149, 2, // 5839: decode to DPADD_S_H using decoder 277
6478 // 5839: }
6479 10, 7, // 5844: case 0xa: {
6480 OPC_CheckPredicate, 30, // 5846: check predicate 30
6481 OPC_Decode, 233, 11, 150, 2, // 5848: decode to DPADD_S_W using decoder 278
6482 // 5848: }
6483 11, 7, // 5853: case 0xb: {
6484 OPC_CheckPredicate, 30, // 5855: check predicate 30
6485 OPC_Decode, 231, 11, 151, 2, // 5857: decode to DPADD_S_D using decoder 279
6486 // 5857: }
6487 13, 7, // 5862: case 0xd: {
6488 OPC_CheckPredicate, 30, // 5864: check predicate 30
6489 OPC_Decode, 235, 11, 149, 2, // 5866: decode to DPADD_U_H using decoder 277
6490 // 5866: }
6491 14, 7, // 5871: case 0xe: {
6492 OPC_CheckPredicate, 30, // 5873: check predicate 30
6493 OPC_Decode, 236, 11, 150, 2, // 5875: decode to DPADD_U_W using decoder 278
6494 // 5875: }
6495 15, 7, // 5880: case 0xf: {
6496 OPC_CheckPredicate, 30, // 5882: check predicate 30
6497 OPC_Decode, 234, 11, 151, 2, // 5884: decode to DPADD_U_D using decoder 279
6498 // 5884: }
6499 17, 7, // 5889: case 0x11: {
6500 OPC_CheckPredicate, 30, // 5891: check predicate 30
6501 OPC_Decode, 135, 12, 149, 2, // 5893: decode to DPSUB_S_H using decoder 277
6502 // 5893: }
6503 18, 7, // 5898: case 0x12: {
6504 OPC_CheckPredicate, 30, // 5900: check predicate 30
6505 OPC_Decode, 136, 12, 150, 2, // 5902: decode to DPSUB_S_W using decoder 278
6506 // 5902: }
6507 19, 7, // 5907: case 0x13: {
6508 OPC_CheckPredicate, 30, // 5909: check predicate 30
6509 OPC_Decode, 134, 12, 151, 2, // 5911: decode to DPSUB_S_D using decoder 279
6510 // 5911: }
6511 21, 7, // 5916: case 0x15: {
6512 OPC_CheckPredicate, 30, // 5918: check predicate 30
6513 OPC_Decode, 138, 12, 149, 2, // 5920: decode to DPSUB_U_H using decoder 277
6514 // 5920: }
6515 22, 7, // 5925: case 0x16: {
6516 OPC_CheckPredicate, 30, // 5927: check predicate 30
6517 OPC_Decode, 139, 12, 150, 2, // 5929: decode to DPSUB_U_W using decoder 278
6518 // 5929: }
6519 23, 0, // 5934: case 0x17: {
6520 OPC_CheckPredicate, 30, // 5936: check predicate 30
6521 OPC_Decode, 137, 12, 151, 2, // 5938: decode to DPSUB_U_D using decoder 279
6522 // 5938: }
6523 // 5938: } // switch Inst[25:21]
6524 // 5938: }
6525 20, 163, 2, // 5943: case 0x14: {
6526 OPC_SwitchField, 21, 5, // 5946: switch Inst[25:21] {
6527 0, 7, // 5949: case 0x0: {
6528 OPC_CheckPredicate, 30, // 5951: check predicate 30
6529 OPC_Decode, 193, 20, 152, 2, // 5953: decode to SLD_B using decoder 280
6530 // 5953: }
6531 1, 7, // 5958: case 0x1: {
6532 OPC_CheckPredicate, 30, // 5960: check predicate 30
6533 OPC_Decode, 195, 20, 153, 2, // 5962: decode to SLD_H using decoder 281
6534 // 5962: }
6535 2, 7, // 5967: case 0x2: {
6536 OPC_CheckPredicate, 30, // 5969: check predicate 30
6537 OPC_Decode, 196, 20, 154, 2, // 5971: decode to SLD_W using decoder 282
6538 // 5971: }
6539 3, 7, // 5976: case 0x3: {
6540 OPC_CheckPredicate, 30, // 5978: check predicate 30
6541 OPC_Decode, 194, 20, 155, 2, // 5980: decode to SLD_D using decoder 283
6542 // 5980: }
6543 4, 7, // 5985: case 0x4: {
6544 OPC_CheckPredicate, 30, // 5987: check predicate 30
6545 OPC_Decode, 232, 20, 156, 2, // 5989: decode to SPLAT_B using decoder 284
6546 // 5989: }
6547 5, 7, // 5994: case 0x5: {
6548 OPC_CheckPredicate, 30, // 5996: check predicate 30
6549 OPC_Decode, 234, 20, 157, 2, // 5998: decode to SPLAT_H using decoder 285
6550 // 5998: }
6551 6, 7, // 6003: case 0x6: {
6552 OPC_CheckPredicate, 30, // 6005: check predicate 30
6553 OPC_Decode, 235, 20, 158, 2, // 6007: decode to SPLAT_W using decoder 286
6554 // 6007: }
6555 7, 7, // 6012: case 0x7: {
6556 OPC_CheckPredicate, 30, // 6014: check predicate 30
6557 OPC_Decode, 233, 20, 159, 2, // 6016: decode to SPLAT_D using decoder 287
6558 // 6016: }
6559 8, 7, // 6021: case 0x8: {
6560 OPC_CheckPredicate, 30, // 6023: check predicate 30
6561 OPC_Decode, 194, 18, 138, 2, // 6025: decode to PCKEV_B using decoder 266
6562 // 6025: }
6563 9, 7, // 6030: case 0x9: {
6564 OPC_CheckPredicate, 30, // 6032: check predicate 30
6565 OPC_Decode, 196, 18, 139, 2, // 6034: decode to PCKEV_H using decoder 267
6566 // 6034: }
6567 10, 7, // 6039: case 0xa: {
6568 OPC_CheckPredicate, 30, // 6041: check predicate 30
6569 OPC_Decode, 197, 18, 140, 2, // 6043: decode to PCKEV_W using decoder 268
6570 // 6043: }
6571 11, 7, // 6048: case 0xb: {
6572 OPC_CheckPredicate, 30, // 6050: check predicate 30
6573 OPC_Decode, 195, 18, 141, 2, // 6052: decode to PCKEV_D using decoder 269
6574 // 6052: }
6575 12, 7, // 6057: case 0xc: {
6576 OPC_CheckPredicate, 30, // 6059: check predicate 30
6577 OPC_Decode, 198, 18, 138, 2, // 6061: decode to PCKOD_B using decoder 266
6578 // 6061: }
6579 13, 7, // 6066: case 0xd: {
6580 OPC_CheckPredicate, 30, // 6068: check predicate 30
6581 OPC_Decode, 200, 18, 139, 2, // 6070: decode to PCKOD_H using decoder 267
6582 // 6070: }
6583 14, 7, // 6075: case 0xe: {
6584 OPC_CheckPredicate, 30, // 6077: check predicate 30
6585 OPC_Decode, 201, 18, 140, 2, // 6079: decode to PCKOD_W using decoder 268
6586 // 6079: }
6587 15, 7, // 6084: case 0xf: {
6588 OPC_CheckPredicate, 30, // 6086: check predicate 30
6589 OPC_Decode, 199, 18, 141, 2, // 6088: decode to PCKOD_D using decoder 269
6590 // 6088: }
6591 16, 7, // 6093: case 0x10: {
6592 OPC_CheckPredicate, 30, // 6095: check predicate 30
6593 OPC_Decode, 163, 14, 138, 2, // 6097: decode to ILVL_B using decoder 266
6594 // 6097: }
6595 17, 7, // 6102: case 0x11: {
6596 OPC_CheckPredicate, 30, // 6104: check predicate 30
6597 OPC_Decode, 165, 14, 139, 2, // 6106: decode to ILVL_H using decoder 267
6598 // 6106: }
6599 18, 7, // 6111: case 0x12: {
6600 OPC_CheckPredicate, 30, // 6113: check predicate 30
6601 OPC_Decode, 166, 14, 140, 2, // 6115: decode to ILVL_W using decoder 268
6602 // 6115: }
6603 19, 7, // 6120: case 0x13: {
6604 OPC_CheckPredicate, 30, // 6122: check predicate 30
6605 OPC_Decode, 164, 14, 141, 2, // 6124: decode to ILVL_D using decoder 269
6606 // 6124: }
6607 20, 7, // 6129: case 0x14: {
6608 OPC_CheckPredicate, 30, // 6131: check predicate 30
6609 OPC_Decode, 171, 14, 138, 2, // 6133: decode to ILVR_B using decoder 266
6610 // 6133: }
6611 21, 7, // 6138: case 0x15: {
6612 OPC_CheckPredicate, 30, // 6140: check predicate 30
6613 OPC_Decode, 173, 14, 139, 2, // 6142: decode to ILVR_H using decoder 267
6614 // 6142: }
6615 22, 7, // 6147: case 0x16: {
6616 OPC_CheckPredicate, 30, // 6149: check predicate 30
6617 OPC_Decode, 174, 14, 140, 2, // 6151: decode to ILVR_W using decoder 268
6618 // 6151: }
6619 23, 7, // 6156: case 0x17: {
6620 OPC_CheckPredicate, 30, // 6158: check predicate 30
6621 OPC_Decode, 172, 14, 141, 2, // 6160: decode to ILVR_D using decoder 269
6622 // 6160: }
6623 24, 7, // 6165: case 0x18: {
6624 OPC_CheckPredicate, 30, // 6167: check predicate 30
6625 OPC_Decode, 159, 14, 138, 2, // 6169: decode to ILVEV_B using decoder 266
6626 // 6169: }
6627 25, 7, // 6174: case 0x19: {
6628 OPC_CheckPredicate, 30, // 6176: check predicate 30
6629 OPC_Decode, 161, 14, 139, 2, // 6178: decode to ILVEV_H using decoder 267
6630 // 6178: }
6631 26, 7, // 6183: case 0x1a: {
6632 OPC_CheckPredicate, 30, // 6185: check predicate 30
6633 OPC_Decode, 162, 14, 140, 2, // 6187: decode to ILVEV_W using decoder 268
6634 // 6187: }
6635 27, 7, // 6192: case 0x1b: {
6636 OPC_CheckPredicate, 30, // 6194: check predicate 30
6637 OPC_Decode, 160, 14, 141, 2, // 6196: decode to ILVEV_D using decoder 269
6638 // 6196: }
6639 28, 7, // 6201: case 0x1c: {
6640 OPC_CheckPredicate, 30, // 6203: check predicate 30
6641 OPC_Decode, 167, 14, 138, 2, // 6205: decode to ILVOD_B using decoder 266
6642 // 6205: }
6643 29, 7, // 6210: case 0x1d: {
6644 OPC_CheckPredicate, 30, // 6212: check predicate 30
6645 OPC_Decode, 169, 14, 139, 2, // 6214: decode to ILVOD_H using decoder 267
6646 // 6214: }
6647 30, 7, // 6219: case 0x1e: {
6648 OPC_CheckPredicate, 30, // 6221: check predicate 30
6649 OPC_Decode, 170, 14, 140, 2, // 6223: decode to ILVOD_W using decoder 268
6650 // 6223: }
6651 31, 0, // 6228: case 0x1f: {
6652 OPC_CheckPredicate, 30, // 6230: check predicate 30
6653 OPC_Decode, 168, 14, 141, 2, // 6232: decode to ILVOD_D using decoder 269
6654 // 6232: }
6655 // 6232: } // switch Inst[25:21]
6656 // 6232: }
6657 21, 219, 1, // 6237: case 0x15: {
6658 OPC_SwitchField, 21, 5, // 6240: switch Inst[25:21] {
6659 0, 7, // 6243: case 0x0: {
6660 OPC_CheckPredicate, 30, // 6245: check predicate 30
6661 OPC_Decode, 217, 22, 142, 2, // 6247: decode to VSHF_B using decoder 270
6662 // 6247: }
6663 1, 7, // 6252: case 0x1: {
6664 OPC_CheckPredicate, 30, // 6254: check predicate 30
6665 OPC_Decode, 219, 22, 143, 2, // 6256: decode to VSHF_H using decoder 271
6666 // 6256: }
6667 2, 7, // 6261: case 0x2: {
6668 OPC_CheckPredicate, 30, // 6263: check predicate 30
6669 OPC_Decode, 220, 22, 144, 2, // 6265: decode to VSHF_W using decoder 272
6670 // 6265: }
6671 3, 7, // 6270: case 0x3: {
6672 OPC_CheckPredicate, 30, // 6272: check predicate 30
6673 OPC_Decode, 218, 22, 145, 2, // 6274: decode to VSHF_D using decoder 273
6674 // 6274: }
6675 4, 7, // 6279: case 0x4: {
6676 OPC_CheckPredicate, 30, // 6281: check predicate 30
6677 OPC_Decode, 245, 20, 138, 2, // 6283: decode to SRAR_B using decoder 266
6678 // 6283: }
6679 5, 7, // 6288: case 0x5: {
6680 OPC_CheckPredicate, 30, // 6290: check predicate 30
6681 OPC_Decode, 247, 20, 139, 2, // 6292: decode to SRAR_H using decoder 267
6682 // 6292: }
6683 6, 7, // 6297: case 0x6: {
6684 OPC_CheckPredicate, 30, // 6299: check predicate 30
6685 OPC_Decode, 248, 20, 140, 2, // 6301: decode to SRAR_W using decoder 268
6686 // 6301: }
6687 7, 7, // 6306: case 0x7: {
6688 OPC_CheckPredicate, 30, // 6308: check predicate 30
6689 OPC_Decode, 246, 20, 141, 2, // 6310: decode to SRAR_D using decoder 269
6690 // 6310: }
6691 8, 7, // 6315: case 0x8: {
6692 OPC_CheckPredicate, 30, // 6317: check predicate 30
6693 OPC_Decode, 139, 21, 138, 2, // 6319: decode to SRLR_B using decoder 266
6694 // 6319: }
6695 9, 7, // 6324: case 0x9: {
6696 OPC_CheckPredicate, 30, // 6326: check predicate 30
6697 OPC_Decode, 141, 21, 139, 2, // 6328: decode to SRLR_H using decoder 267
6698 // 6328: }
6699 10, 7, // 6333: case 0xa: {
6700 OPC_CheckPredicate, 30, // 6335: check predicate 30
6701 OPC_Decode, 142, 21, 140, 2, // 6337: decode to SRLR_W using decoder 268
6702 // 6337: }
6703 11, 7, // 6342: case 0xb: {
6704 OPC_CheckPredicate, 30, // 6344: check predicate 30
6705 OPC_Decode, 140, 21, 141, 2, // 6346: decode to SRLR_D using decoder 269
6706 // 6346: }
6707 17, 7, // 6351: case 0x11: {
6708 OPC_CheckPredicate, 30, // 6353: check predicate 30
6709 OPC_Decode, 146, 14, 146, 2, // 6355: decode to HADD_S_H using decoder 274
6710 // 6355: }
6711 18, 7, // 6360: case 0x12: {
6712 OPC_CheckPredicate, 30, // 6362: check predicate 30
6713 OPC_Decode, 147, 14, 147, 2, // 6364: decode to HADD_S_W using decoder 275
6714 // 6364: }
6715 19, 7, // 6369: case 0x13: {
6716 OPC_CheckPredicate, 30, // 6371: check predicate 30
6717 OPC_Decode, 145, 14, 148, 2, // 6373: decode to HADD_S_D using decoder 276
6718 // 6373: }
6719 21, 7, // 6378: case 0x15: {
6720 OPC_CheckPredicate, 30, // 6380: check predicate 30
6721 OPC_Decode, 149, 14, 146, 2, // 6382: decode to HADD_U_H using decoder 274
6722 // 6382: }
6723 22, 7, // 6387: case 0x16: {
6724 OPC_CheckPredicate, 30, // 6389: check predicate 30
6725 OPC_Decode, 150, 14, 147, 2, // 6391: decode to HADD_U_W using decoder 275
6726 // 6391: }
6727 23, 7, // 6396: case 0x17: {
6728 OPC_CheckPredicate, 30, // 6398: check predicate 30
6729 OPC_Decode, 148, 14, 148, 2, // 6400: decode to HADD_U_D using decoder 276
6730 // 6400: }
6731 25, 7, // 6405: case 0x19: {
6732 OPC_CheckPredicate, 30, // 6407: check predicate 30
6733 OPC_Decode, 152, 14, 146, 2, // 6409: decode to HSUB_S_H using decoder 274
6734 // 6409: }
6735 26, 7, // 6414: case 0x1a: {
6736 OPC_CheckPredicate, 30, // 6416: check predicate 30
6737 OPC_Decode, 153, 14, 147, 2, // 6418: decode to HSUB_S_W using decoder 275
6738 // 6418: }
6739 27, 7, // 6423: case 0x1b: {
6740 OPC_CheckPredicate, 30, // 6425: check predicate 30
6741 OPC_Decode, 151, 14, 148, 2, // 6427: decode to HSUB_S_D using decoder 276
6742 // 6427: }
6743 29, 7, // 6432: case 0x1d: {
6744 OPC_CheckPredicate, 30, // 6434: check predicate 30
6745 OPC_Decode, 155, 14, 146, 2, // 6436: decode to HSUB_U_H using decoder 274
6746 // 6436: }
6747 30, 7, // 6441: case 0x1e: {
6748 OPC_CheckPredicate, 30, // 6443: check predicate 30
6749 OPC_Decode, 156, 14, 147, 2, // 6445: decode to HSUB_U_W using decoder 275
6750 // 6445: }
6751 31, 0, // 6450: case 0x1f: {
6752 OPC_CheckPredicate, 30, // 6452: check predicate 30
6753 OPC_Decode, 154, 14, 148, 2, // 6454: decode to HSUB_U_D using decoder 276
6754 // 6454: }
6755 // 6454: } // switch Inst[25:21]
6756 // 6454: }
6757 25, 194, 2, // 6459: case 0x19: {
6758 OPC_SwitchField, 20, 6, // 6462: switch Inst[25:20] {
6759 0, 7, // 6465: case 0x0: {
6760 OPC_CheckPredicate, 30, // 6467: check predicate 30
6761 OPC_Decode, 189, 20, 160, 2, // 6469: decode to SLDI_B using decoder 288
6762 // 6469: }
6763 2, 11, // 6474: case 0x2: {
6764 OPC_CheckPredicate, 30, // 6476: check predicate 30
6765 OPC_CheckField, 19, 1, 0, // 6478: check Inst[19] == 0x0
6766 OPC_Decode, 191, 20, 161, 2, // 6482: decode to SLDI_H using decoder 289
6767 // 6482: }
6768 3, 38, // 6487: case 0x3: {
6769 OPC_SwitchField, 18, 2, // 6489: switch Inst[19:18] {
6770 0, 7, // 6492: case 0x0: {
6771 OPC_CheckPredicate, 30, // 6494: check predicate 30
6772 OPC_Decode, 192, 20, 162, 2, // 6496: decode to SLDI_W using decoder 290
6773 // 6496: }
6774 2, 11, // 6501: case 0x2: {
6775 OPC_CheckPredicate, 30, // 6503: check predicate 30
6776 OPC_CheckField, 17, 1, 0, // 6505: check Inst[17] == 0x0
6777 OPC_Decode, 190, 20, 163, 2, // 6509: decode to SLDI_D using decoder 291
6778 // 6509: }
6779 3, 0, // 6514: case 0x3: {
6780 OPC_CheckPredicate, 30, // 6516: check predicate 30
6781 OPC_CheckField, 16, 2, 2, // 6518: check Inst[17:16] == 0x2
6782 OPC_Decode, 154, 10, 164, 2, // 6522: decode to CTCMSA using decoder 292
6783 // 6522: }
6784 // 6522: } // switch Inst[19:18]
6785 // 6522: }
6786 4, 7, // 6527: case 0x4: {
6787 OPC_CheckPredicate, 30, // 6529: check predicate 30
6788 OPC_Decode, 228, 20, 165, 2, // 6531: decode to SPLATI_B using decoder 293
6789 // 6531: }
6790 6, 11, // 6536: case 0x6: {
6791 OPC_CheckPredicate, 30, // 6538: check predicate 30
6792 OPC_CheckField, 19, 1, 0, // 6540: check Inst[19] == 0x0
6793 OPC_Decode, 230, 20, 166, 2, // 6544: decode to SPLATI_H using decoder 294
6794 // 6544: }
6795 7, 38, // 6549: case 0x7: {
6796 OPC_SwitchField, 18, 2, // 6551: switch Inst[19:18] {
6797 0, 7, // 6554: case 0x0: {
6798 OPC_CheckPredicate, 30, // 6556: check predicate 30
6799 OPC_Decode, 231, 20, 167, 2, // 6558: decode to SPLATI_W using decoder 295
6800 // 6558: }
6801 2, 11, // 6563: case 0x2: {
6802 OPC_CheckPredicate, 30, // 6565: check predicate 30
6803 OPC_CheckField, 17, 1, 0, // 6567: check Inst[17] == 0x0
6804 OPC_Decode, 229, 20, 168, 2, // 6571: decode to SPLATI_D using decoder 296
6805 // 6571: }
6806 3, 0, // 6576: case 0x3: {
6807 OPC_CheckPredicate, 30, // 6578: check predicate 30
6808 OPC_CheckField, 16, 2, 2, // 6580: check Inst[17:16] == 0x2
6809 OPC_Decode, 255, 8, 169, 2, // 6584: decode to CFCMSA using decoder 297
6810 // 6584: }
6811 // 6584: } // switch Inst[19:18]
6812 // 6584: }
6813 8, 7, // 6589: case 0x8: {
6814 OPC_CheckPredicate, 30, // 6591: check predicate 30
6815 OPC_Decode, 136, 10, 170, 2, // 6593: decode to COPY_S_B using decoder 298
6816 // 6593: }
6817 10, 11, // 6598: case 0xa: {
6818 OPC_CheckPredicate, 30, // 6600: check predicate 30
6819 OPC_CheckField, 19, 1, 0, // 6602: check Inst[19] == 0x0
6820 OPC_Decode, 138, 10, 171, 2, // 6606: decode to COPY_S_H using decoder 299
6821 // 6606: }
6822 11, 38, // 6611: case 0xb: {
6823 OPC_SwitchField, 18, 2, // 6613: switch Inst[19:18] {
6824 0, 7, // 6616: case 0x0: {
6825 OPC_CheckPredicate, 30, // 6618: check predicate 30
6826 OPC_Decode, 139, 10, 172, 2, // 6620: decode to COPY_S_W using decoder 300
6827 // 6620: }
6828 2, 11, // 6625: case 0x2: {
6829 OPC_CheckPredicate, 38, // 6627: check predicate 38
6830 OPC_CheckField, 17, 1, 0, // 6629: check Inst[17] == 0x0
6831 OPC_Decode, 137, 10, 173, 2, // 6633: decode to COPY_S_D using decoder 301
6832 // 6633: }
6833 3, 0, // 6638: case 0x3: {
6834 OPC_CheckPredicate, 30, // 6640: check predicate 30
6835 OPC_CheckField, 16, 2, 2, // 6642: check Inst[17:16] == 0x2
6836 OPC_Decode, 243, 16, 174, 2, // 6646: decode to MOVE_V using decoder 302
6837 // 6646: }
6838 // 6646: } // switch Inst[19:18]
6839 // 6646: }
6840 12, 7, // 6651: case 0xc: {
6841 OPC_CheckPredicate, 30, // 6653: check predicate 30
6842 OPC_Decode, 140, 10, 170, 2, // 6655: decode to COPY_U_B using decoder 298
6843 // 6655: }
6844 14, 11, // 6660: case 0xe: {
6845 OPC_CheckPredicate, 30, // 6662: check predicate 30
6846 OPC_CheckField, 19, 1, 0, // 6664: check Inst[19] == 0x0
6847 OPC_Decode, 141, 10, 171, 2, // 6668: decode to COPY_U_H using decoder 299
6848 // 6668: }
6849 15, 11, // 6673: case 0xf: {
6850 OPC_CheckPredicate, 38, // 6675: check predicate 38
6851 OPC_CheckField, 18, 2, 0, // 6677: check Inst[19:18] == 0x0
6852 OPC_Decode, 142, 10, 172, 2, // 6681: decode to COPY_U_W using decoder 300
6853 // 6681: }
6854 16, 7, // 6686: case 0x10: {
6855 OPC_CheckPredicate, 30, // 6688: check predicate 30
6856 OPC_Decode, 176, 14, 175, 2, // 6690: decode to INSERT_B using decoder 303
6857 // 6690: }
6858 18, 11, // 6695: case 0x12: {
6859 OPC_CheckPredicate, 30, // 6697: check predicate 30
6860 OPC_CheckField, 19, 1, 0, // 6699: check Inst[19] == 0x0
6861 OPC_Decode, 178, 14, 176, 2, // 6703: decode to INSERT_H using decoder 304
6862 // 6703: }
6863 19, 25, // 6708: case 0x13: {
6864 OPC_SwitchField, 18, 2, // 6710: switch Inst[19:18] {
6865 0, 7, // 6713: case 0x0: {
6866 OPC_CheckPredicate, 30, // 6715: check predicate 30
6867 OPC_Decode, 179, 14, 177, 2, // 6717: decode to INSERT_W using decoder 305
6868 // 6717: }
6869 2, 0, // 6722: case 0x2: {
6870 OPC_CheckPredicate, 38, // 6724: check predicate 38
6871 OPC_CheckField, 17, 1, 0, // 6726: check Inst[17] == 0x0
6872 OPC_Decode, 177, 14, 178, 2, // 6730: decode to INSERT_D using decoder 306
6873 // 6730: }
6874 // 6730: } // switch Inst[19:18]
6875 // 6730: }
6876 20, 7, // 6735: case 0x14: {
6877 OPC_CheckPredicate, 30, // 6737: check predicate 30
6878 OPC_Decode, 181, 14, 179, 2, // 6739: decode to INSVE_B using decoder 307
6879 // 6739: }
6880 22, 11, // 6744: case 0x16: {
6881 OPC_CheckPredicate, 30, // 6746: check predicate 30
6882 OPC_CheckField, 19, 1, 0, // 6748: check Inst[19] == 0x0
6883 OPC_Decode, 183, 14, 179, 2, // 6752: decode to INSVE_H using decoder 307
6884 // 6752: }
6885 23, 0, // 6757: case 0x17: {
6886 OPC_SwitchField, 18, 2, // 6759: switch Inst[19:18] {
6887 0, 7, // 6762: case 0x0: {
6888 OPC_CheckPredicate, 30, // 6764: check predicate 30
6889 OPC_Decode, 184, 14, 179, 2, // 6766: decode to INSVE_W using decoder 307
6890 // 6766: }
6891 2, 0, // 6771: case 0x2: {
6892 OPC_CheckPredicate, 30, // 6773: check predicate 30
6893 OPC_CheckField, 17, 1, 0, // 6775: check Inst[17] == 0x0
6894 OPC_Decode, 182, 14, 179, 2, // 6779: decode to INSVE_D using decoder 307
6895 // 6779: }
6896 // 6779: } // switch Inst[19:18]
6897 // 6779: }
6898 // 6779: } // switch Inst[25:20]
6899 // 6779: }
6900 26, 163, 2, // 6784: case 0x1a: {
6901 OPC_SwitchField, 21, 5, // 6787: switch Inst[25:21] {
6902 0, 7, // 6790: case 0x0: {
6903 OPC_CheckPredicate, 30, // 6792: check predicate 30
6904 OPC_Decode, 233, 12, 140, 2, // 6794: decode to FCAF_W using decoder 268
6905 // 6794: }
6906 1, 7, // 6799: case 0x1: {
6907 OPC_CheckPredicate, 30, // 6801: check predicate 30
6908 OPC_Decode, 232, 12, 141, 2, // 6803: decode to FCAF_D using decoder 269
6909 // 6803: }
6910 2, 7, // 6808: case 0x2: {
6911 OPC_CheckPredicate, 30, // 6810: check predicate 30
6912 OPC_Decode, 132, 13, 140, 2, // 6812: decode to FCUN_W using decoder 268
6913 // 6812: }
6914 3, 7, // 6817: case 0x3: {
6915 OPC_CheckPredicate, 30, // 6819: check predicate 30
6916 OPC_Decode, 131, 13, 141, 2, // 6821: decode to FCUN_D using decoder 269
6917 // 6821: }
6918 4, 7, // 6826: case 0x4: {
6919 OPC_CheckPredicate, 30, // 6828: check predicate 30
6920 OPC_Decode, 235, 12, 140, 2, // 6830: decode to FCEQ_W using decoder 268
6921 // 6830: }
6922 5, 7, // 6835: case 0x5: {
6923 OPC_CheckPredicate, 30, // 6837: check predicate 30
6924 OPC_Decode, 234, 12, 141, 2, // 6839: decode to FCEQ_D using decoder 269
6925 // 6839: }
6926 6, 7, // 6844: case 0x6: {
6927 OPC_CheckPredicate, 30, // 6846: check predicate 30
6928 OPC_Decode, 252, 12, 140, 2, // 6848: decode to FCUEQ_W using decoder 268
6929 // 6848: }
6930 7, 7, // 6853: case 0x7: {
6931 OPC_CheckPredicate, 30, // 6855: check predicate 30
6932 OPC_Decode, 251, 12, 141, 2, // 6857: decode to FCUEQ_D using decoder 269
6933 // 6857: }
6934 8, 7, // 6862: case 0x8: {
6935 OPC_CheckPredicate, 30, // 6864: check predicate 30
6936 OPC_Decode, 241, 12, 140, 2, // 6866: decode to FCLT_W using decoder 268
6937 // 6866: }
6938 9, 7, // 6871: case 0x9: {
6939 OPC_CheckPredicate, 30, // 6873: check predicate 30
6940 OPC_Decode, 240, 12, 141, 2, // 6875: decode to FCLT_D using decoder 269
6941 // 6875: }
6942 10, 7, // 6880: case 0xa: {
6943 OPC_CheckPredicate, 30, // 6882: check predicate 30
6944 OPC_Decode, 128, 13, 140, 2, // 6884: decode to FCULT_W using decoder 268
6945 // 6884: }
6946 11, 7, // 6889: case 0xb: {
6947 OPC_CheckPredicate, 30, // 6891: check predicate 30
6948 OPC_Decode, 255, 12, 141, 2, // 6893: decode to FCULT_D using decoder 269
6949 // 6893: }
6950 12, 7, // 6898: case 0xc: {
6951 OPC_CheckPredicate, 30, // 6900: check predicate 30
6952 OPC_Decode, 239, 12, 140, 2, // 6902: decode to FCLE_W using decoder 268
6953 // 6902: }
6954 13, 7, // 6907: case 0xd: {
6955 OPC_CheckPredicate, 30, // 6909: check predicate 30
6956 OPC_Decode, 238, 12, 141, 2, // 6911: decode to FCLE_D using decoder 269
6957 // 6911: }
6958 14, 7, // 6916: case 0xe: {
6959 OPC_CheckPredicate, 30, // 6918: check predicate 30
6960 OPC_Decode, 254, 12, 140, 2, // 6920: decode to FCULE_W using decoder 268
6961 // 6920: }
6962 15, 7, // 6925: case 0xf: {
6963 OPC_CheckPredicate, 30, // 6927: check predicate 30
6964 OPC_Decode, 253, 12, 141, 2, // 6929: decode to FCULE_D using decoder 269
6965 // 6929: }
6966 16, 7, // 6934: case 0x10: {
6967 OPC_CheckPredicate, 30, // 6936: check predicate 30
6968 OPC_Decode, 220, 13, 140, 2, // 6938: decode to FSAF_W using decoder 268
6969 // 6938: }
6970 17, 7, // 6943: case 0x11: {
6971 OPC_CheckPredicate, 30, // 6945: check predicate 30
6972 OPC_Decode, 219, 13, 141, 2, // 6947: decode to FSAF_D using decoder 269
6973 // 6947: }
6974 18, 7, // 6952: case 0x12: {
6975 OPC_CheckPredicate, 30, // 6954: check predicate 30
6976 OPC_Decode, 130, 14, 140, 2, // 6956: decode to FSUN_W using decoder 268
6977 // 6956: }
6978 19, 7, // 6961: case 0x13: {
6979 OPC_CheckPredicate, 30, // 6963: check predicate 30
6980 OPC_Decode, 129, 14, 141, 2, // 6965: decode to FSUN_D using decoder 269
6981 // 6965: }
6982 20, 7, // 6970: case 0x14: {
6983 OPC_CheckPredicate, 30, // 6972: check predicate 30
6984 OPC_Decode, 222, 13, 140, 2, // 6974: decode to FSEQ_W using decoder 268
6985 // 6974: }
6986 21, 7, // 6979: case 0x15: {
6987 OPC_CheckPredicate, 30, // 6981: check predicate 30
6988 OPC_Decode, 221, 13, 141, 2, // 6983: decode to FSEQ_D using decoder 269
6989 // 6983: }
6990 22, 7, // 6988: case 0x16: {
6991 OPC_CheckPredicate, 30, // 6990: check predicate 30
6992 OPC_Decode, 250, 13, 140, 2, // 6992: decode to FSUEQ_W using decoder 268
6993 // 6992: }
6994 23, 7, // 6997: case 0x17: {
6995 OPC_CheckPredicate, 30, // 6999: check predicate 30
6996 OPC_Decode, 249, 13, 141, 2, // 7001: decode to FSUEQ_D using decoder 269
6997 // 7001: }
6998 24, 7, // 7006: case 0x18: {
6999 OPC_CheckPredicate, 30, // 7008: check predicate 30
7000 OPC_Decode, 226, 13, 140, 2, // 7010: decode to FSLT_W using decoder 268
7001 // 7010: }
7002 25, 7, // 7015: case 0x19: {
7003 OPC_CheckPredicate, 30, // 7017: check predicate 30
7004 OPC_Decode, 225, 13, 141, 2, // 7019: decode to FSLT_D using decoder 269
7005 // 7019: }
7006 26, 7, // 7024: case 0x1a: {
7007 OPC_CheckPredicate, 30, // 7026: check predicate 30
7008 OPC_Decode, 254, 13, 140, 2, // 7028: decode to FSULT_W using decoder 268
7009 // 7028: }
7010 27, 7, // 7033: case 0x1b: {
7011 OPC_CheckPredicate, 30, // 7035: check predicate 30
7012 OPC_Decode, 253, 13, 141, 2, // 7037: decode to FSULT_D using decoder 269
7013 // 7037: }
7014 28, 7, // 7042: case 0x1c: {
7015 OPC_CheckPredicate, 30, // 7044: check predicate 30
7016 OPC_Decode, 224, 13, 140, 2, // 7046: decode to FSLE_W using decoder 268
7017 // 7046: }
7018 29, 7, // 7051: case 0x1d: {
7019 OPC_CheckPredicate, 30, // 7053: check predicate 30
7020 OPC_Decode, 223, 13, 141, 2, // 7055: decode to FSLE_D using decoder 269
7021 // 7055: }
7022 30, 7, // 7060: case 0x1e: {
7023 OPC_CheckPredicate, 30, // 7062: check predicate 30
7024 OPC_Decode, 252, 13, 140, 2, // 7064: decode to FSULE_W using decoder 268
7025 // 7064: }
7026 31, 0, // 7069: case 0x1f: {
7027 OPC_CheckPredicate, 30, // 7071: check predicate 30
7028 OPC_Decode, 251, 13, 141, 2, // 7073: decode to FSULE_D using decoder 269
7029 // 7073: }
7030 // 7073: } // switch Inst[25:21]
7031 // 7073: }
7032 27, 237, 1, // 7078: case 0x1b: {
7033 OPC_SwitchField, 21, 5, // 7081: switch Inst[25:21] {
7034 0, 7, // 7084: case 0x0: {
7035 OPC_CheckPredicate, 30, // 7086: check predicate 30
7036 OPC_Decode, 231, 12, 140, 2, // 7088: decode to FADD_W using decoder 268
7037 // 7088: }
7038 1, 7, // 7093: case 0x1: {
7039 OPC_CheckPredicate, 30, // 7095: check predicate 30
7040 OPC_Decode, 222, 12, 141, 2, // 7097: decode to FADD_D using decoder 269
7041 // 7097: }
7042 2, 7, // 7102: case 0x2: {
7043 OPC_CheckPredicate, 30, // 7104: check predicate 30
7044 OPC_Decode, 248, 13, 140, 2, // 7106: decode to FSUB_W using decoder 268
7045 // 7106: }
7046 3, 7, // 7111: case 0x3: {
7047 OPC_CheckPredicate, 30, // 7113: check predicate 30
7048 OPC_Decode, 239, 13, 141, 2, // 7115: decode to FSUB_D using decoder 269
7049 // 7115: }
7050 4, 7, // 7120: case 0x4: {
7051 OPC_CheckPredicate, 30, // 7122: check predicate 30
7052 OPC_Decode, 204, 13, 140, 2, // 7124: decode to FMUL_W using decoder 268
7053 // 7124: }
7054 5, 7, // 7129: case 0x5: {
7055 OPC_CheckPredicate, 30, // 7131: check predicate 30
7056 OPC_Decode, 195, 13, 141, 2, // 7133: decode to FMUL_D using decoder 269
7057 // 7133: }
7058 6, 7, // 7138: case 0x6: {
7059 OPC_CheckPredicate, 30, // 7140: check predicate 30
7060 OPC_Decode, 141, 13, 140, 2, // 7142: decode to FDIV_W using decoder 268
7061 // 7142: }
7062 7, 7, // 7147: case 0x7: {
7063 OPC_CheckPredicate, 30, // 7149: check predicate 30
7064 OPC_Decode, 133, 13, 141, 2, // 7151: decode to FDIV_D using decoder 269
7065 // 7151: }
7066 8, 7, // 7156: case 0x8: {
7067 OPC_CheckPredicate, 30, // 7158: check predicate 30
7068 OPC_Decode, 176, 13, 144, 2, // 7160: decode to FMADD_W using decoder 272
7069 // 7160: }
7070 9, 7, // 7165: case 0x9: {
7071 OPC_CheckPredicate, 30, // 7167: check predicate 30
7072 OPC_Decode, 175, 13, 145, 2, // 7169: decode to FMADD_D using decoder 273
7073 // 7169: }
7074 10, 7, // 7174: case 0xa: {
7075 OPC_CheckPredicate, 30, // 7176: check predicate 30
7076 OPC_Decode, 194, 13, 144, 2, // 7178: decode to FMSUB_W using decoder 272
7077 // 7178: }
7078 11, 7, // 7183: case 0xb: {
7079 OPC_CheckPredicate, 30, // 7185: check predicate 30
7080 OPC_Decode, 193, 13, 145, 2, // 7187: decode to FMSUB_D using decoder 273
7081 // 7187: }
7082 14, 7, // 7192: case 0xe: {
7083 OPC_CheckPredicate, 30, // 7194: check predicate 30
7084 OPC_Decode, 145, 13, 140, 2, // 7196: decode to FEXP2_W using decoder 268
7085 // 7196: }
7086 15, 7, // 7201: case 0xf: {
7087 OPC_CheckPredicate, 30, // 7203: check predicate 30
7088 OPC_Decode, 144, 13, 141, 2, // 7205: decode to FEXP2_D using decoder 269
7089 // 7205: }
7090 16, 7, // 7210: case 0x10: {
7091 OPC_CheckPredicate, 30, // 7212: check predicate 30
7092 OPC_Decode, 142, 13, 180, 2, // 7214: decode to FEXDO_H using decoder 308
7093 // 7214: }
7094 17, 7, // 7219: case 0x11: {
7095 OPC_CheckPredicate, 30, // 7221: check predicate 30
7096 OPC_Decode, 143, 13, 181, 2, // 7223: decode to FEXDO_W using decoder 309
7097 // 7223: }
7098 20, 7, // 7228: case 0x14: {
7099 OPC_CheckPredicate, 30, // 7230: check predicate 30
7100 OPC_Decode, 135, 14, 180, 2, // 7232: decode to FTQ_H using decoder 308
7101 // 7232: }
7102 21, 7, // 7237: case 0x15: {
7103 OPC_CheckPredicate, 30, // 7239: check predicate 30
7104 OPC_Decode, 136, 14, 181, 2, // 7241: decode to FTQ_W using decoder 309
7105 // 7241: }
7106 24, 7, // 7246: case 0x18: {
7107 OPC_CheckPredicate, 30, // 7248: check predicate 30
7108 OPC_Decode, 184, 13, 140, 2, // 7250: decode to FMIN_W using decoder 268
7109 // 7250: }
7110 25, 7, // 7255: case 0x19: {
7111 OPC_CheckPredicate, 30, // 7257: check predicate 30
7112 OPC_Decode, 183, 13, 141, 2, // 7259: decode to FMIN_D using decoder 269
7113 // 7259: }
7114 26, 7, // 7264: case 0x1a: {
7115 OPC_CheckPredicate, 30, // 7266: check predicate 30
7116 OPC_Decode, 182, 13, 140, 2, // 7268: decode to FMIN_A_W using decoder 268
7117 // 7268: }
7118 27, 7, // 7273: case 0x1b: {
7119 OPC_CheckPredicate, 30, // 7275: check predicate 30
7120 OPC_Decode, 181, 13, 141, 2, // 7277: decode to FMIN_A_D using decoder 269
7121 // 7277: }
7122 28, 7, // 7282: case 0x1c: {
7123 OPC_CheckPredicate, 30, // 7284: check predicate 30
7124 OPC_Decode, 180, 13, 140, 2, // 7286: decode to FMAX_W using decoder 268
7125 // 7286: }
7126 29, 7, // 7291: case 0x1d: {
7127 OPC_CheckPredicate, 30, // 7293: check predicate 30
7128 OPC_Decode, 179, 13, 141, 2, // 7295: decode to FMAX_D using decoder 269
7129 // 7295: }
7130 30, 7, // 7300: case 0x1e: {
7131 OPC_CheckPredicate, 30, // 7302: check predicate 30
7132 OPC_Decode, 178, 13, 140, 2, // 7304: decode to FMAX_A_W using decoder 268
7133 // 7304: }
7134 31, 0, // 7309: case 0x1f: {
7135 OPC_CheckPredicate, 30, // 7311: check predicate 30
7136 OPC_Decode, 177, 13, 141, 2, // 7313: decode to FMAX_A_D using decoder 269
7137 // 7313: }
7138 // 7313: } // switch Inst[25:21]
7139 // 7313: }
7140 28, 219, 1, // 7318: case 0x1c: {
7141 OPC_SwitchField, 21, 5, // 7321: switch Inst[25:21] {
7142 2, 7, // 7324: case 0x2: {
7143 OPC_CheckPredicate, 30, // 7326: check predicate 30
7144 OPC_Decode, 250, 12, 140, 2, // 7328: decode to FCOR_W using decoder 268
7145 // 7328: }
7146 3, 7, // 7333: case 0x3: {
7147 OPC_CheckPredicate, 30, // 7335: check predicate 30
7148 OPC_Decode, 249, 12, 141, 2, // 7337: decode to FCOR_D using decoder 269
7149 // 7337: }
7150 4, 7, // 7342: case 0x4: {
7151 OPC_CheckPredicate, 30, // 7344: check predicate 30
7152 OPC_Decode, 130, 13, 140, 2, // 7346: decode to FCUNE_W using decoder 268
7153 // 7346: }
7154 5, 7, // 7351: case 0x5: {
7155 OPC_CheckPredicate, 30, // 7353: check predicate 30
7156 OPC_Decode, 129, 13, 141, 2, // 7355: decode to FCUNE_D using decoder 269
7157 // 7355: }
7158 6, 7, // 7360: case 0x6: {
7159 OPC_CheckPredicate, 30, // 7362: check predicate 30
7160 OPC_Decode, 248, 12, 140, 2, // 7364: decode to FCNE_W using decoder 268
7161 // 7364: }
7162 7, 7, // 7369: case 0x7: {
7163 OPC_CheckPredicate, 30, // 7371: check predicate 30
7164 OPC_Decode, 247, 12, 141, 2, // 7373: decode to FCNE_D using decoder 269
7165 // 7373: }
7166 8, 7, // 7378: case 0x8: {
7167 OPC_CheckPredicate, 30, // 7380: check predicate 30
7168 OPC_Decode, 138, 18, 139, 2, // 7382: decode to MUL_Q_H using decoder 267
7169 // 7382: }
7170 9, 7, // 7387: case 0x9: {
7171 OPC_CheckPredicate, 30, // 7389: check predicate 30
7172 OPC_Decode, 139, 18, 140, 2, // 7391: decode to MUL_Q_W using decoder 268
7173 // 7391: }
7174 10, 7, // 7396: case 0xa: {
7175 OPC_CheckPredicate, 30, // 7398: check predicate 30
7176 OPC_Decode, 253, 15, 143, 2, // 7400: decode to MADD_Q_H using decoder 271
7177 // 7400: }
7178 11, 7, // 7405: case 0xb: {
7179 OPC_CheckPredicate, 30, // 7407: check predicate 30
7180 OPC_Decode, 254, 15, 144, 2, // 7409: decode to MADD_Q_W using decoder 272
7181 // 7409: }
7182 12, 7, // 7414: case 0xc: {
7183 OPC_CheckPredicate, 30, // 7416: check predicate 30
7184 OPC_Decode, 177, 17, 143, 2, // 7418: decode to MSUB_Q_H using decoder 271
7185 // 7418: }
7186 13, 7, // 7423: case 0xd: {
7187 OPC_CheckPredicate, 30, // 7425: check predicate 30
7188 OPC_Decode, 178, 17, 144, 2, // 7427: decode to MSUB_Q_W using decoder 272
7189 // 7427: }
7190 18, 7, // 7432: case 0x12: {
7191 OPC_CheckPredicate, 30, // 7434: check predicate 30
7192 OPC_Decode, 230, 13, 140, 2, // 7436: decode to FSOR_W using decoder 268
7193 // 7436: }
7194 19, 7, // 7441: case 0x13: {
7195 OPC_CheckPredicate, 30, // 7443: check predicate 30
7196 OPC_Decode, 229, 13, 141, 2, // 7445: decode to FSOR_D using decoder 269
7197 // 7445: }
7198 20, 7, // 7450: case 0x14: {
7199 OPC_CheckPredicate, 30, // 7452: check predicate 30
7200 OPC_Decode, 128, 14, 140, 2, // 7454: decode to FSUNE_W using decoder 268
7201 // 7454: }
7202 21, 7, // 7459: case 0x15: {
7203 OPC_CheckPredicate, 30, // 7461: check predicate 30
7204 OPC_Decode, 255, 13, 141, 2, // 7463: decode to FSUNE_D using decoder 269
7205 // 7463: }
7206 22, 7, // 7468: case 0x16: {
7207 OPC_CheckPredicate, 30, // 7470: check predicate 30
7208 OPC_Decode, 228, 13, 140, 2, // 7472: decode to FSNE_W using decoder 268
7209 // 7472: }
7210 23, 7, // 7477: case 0x17: {
7211 OPC_CheckPredicate, 30, // 7479: check predicate 30
7212 OPC_Decode, 227, 13, 141, 2, // 7481: decode to FSNE_D using decoder 269
7213 // 7481: }
7214 24, 7, // 7486: case 0x18: {
7215 OPC_CheckPredicate, 30, // 7488: check predicate 30
7216 OPC_Decode, 242, 17, 139, 2, // 7490: decode to MULR_Q_H using decoder 267
7217 // 7490: }
7218 25, 7, // 7495: case 0x19: {
7219 OPC_CheckPredicate, 30, // 7497: check predicate 30
7220 OPC_Decode, 243, 17, 140, 2, // 7499: decode to MULR_Q_W using decoder 268
7221 // 7499: }
7222 26, 7, // 7504: case 0x1a: {
7223 OPC_CheckPredicate, 30, // 7506: check predicate 30
7224 OPC_Decode, 237, 15, 143, 2, // 7508: decode to MADDR_Q_H using decoder 271
7225 // 7508: }
7226 27, 7, // 7513: case 0x1b: {
7227 OPC_CheckPredicate, 30, // 7515: check predicate 30
7228 OPC_Decode, 238, 15, 144, 2, // 7517: decode to MADDR_Q_W using decoder 272
7229 // 7517: }
7230 28, 7, // 7522: case 0x1c: {
7231 OPC_CheckPredicate, 30, // 7524: check predicate 30
7232 OPC_Decode, 161, 17, 143, 2, // 7526: decode to MSUBR_Q_H using decoder 271
7233 // 7526: }
7234 29, 0, // 7531: case 0x1d: {
7235 OPC_CheckPredicate, 30, // 7533: check predicate 30
7236 OPC_Decode, 162, 17, 144, 2, // 7535: decode to MSUBR_Q_W using decoder 272
7237 // 7535: }
7238 // 7535: } // switch Inst[25:21]
7239 // 7535: }
7240 30, 253, 3, // 7540: case 0x1e: {
7241 OPC_SwitchField, 21, 5, // 7543: switch Inst[25:21] {
7242 0, 7, // 7546: case 0x0: {
7243 OPC_CheckPredicate, 30, // 7548: check predicate 30
7244 OPC_Decode, 243, 6, 138, 2, // 7550: decode to AND_V using decoder 266
7245 // 7550: }
7246 1, 7, // 7555: case 0x1: {
7247 OPC_CheckPredicate, 30, // 7557: check predicate 30
7248 OPC_Decode, 184, 18, 138, 2, // 7559: decode to OR_V using decoder 266
7249 // 7559: }
7250 2, 7, // 7564: case 0x2: {
7251 OPC_CheckPredicate, 30, // 7566: check predicate 30
7252 OPC_Decode, 171, 18, 138, 2, // 7568: decode to NOR_V using decoder 266
7253 // 7568: }
7254 3, 7, // 7573: case 0x3: {
7255 OPC_CheckPredicate, 30, // 7575: check predicate 30
7256 OPC_Decode, 238, 22, 138, 2, // 7577: decode to XOR_V using decoder 266
7257 // 7577: }
7258 4, 7, // 7582: case 0x4: {
7259 OPC_CheckPredicate, 30, // 7584: check predicate 30
7260 OPC_Decode, 158, 8, 142, 2, // 7586: decode to BMNZ_V using decoder 270
7261 // 7586: }
7262 5, 7, // 7591: case 0x5: {
7263 OPC_CheckPredicate, 30, // 7593: check predicate 30
7264 OPC_Decode, 160, 8, 142, 2, // 7595: decode to BMZ_V using decoder 270
7265 // 7595: }
7266 6, 7, // 7600: case 0x6: {
7267 OPC_CheckPredicate, 30, // 7602: check predicate 30
7268 OPC_Decode, 202, 8, 142, 2, // 7604: decode to BSEL_V using decoder 270
7269 // 7604: }
7270 24, 147, 1, // 7609: case 0x18: {
7271 OPC_SwitchField, 16, 5, // 7612: switch Inst[20:16] {
7272 0, 7, // 7615: case 0x0: {
7273 OPC_CheckPredicate, 30, // 7617: check predicate 30
7274 OPC_Decode, 158, 13, 182, 2, // 7619: decode to FILL_B using decoder 310
7275 // 7619: }
7276 1, 7, // 7624: case 0x1: {
7277 OPC_CheckPredicate, 30, // 7626: check predicate 30
7278 OPC_Decode, 160, 13, 183, 2, // 7628: decode to FILL_H using decoder 311
7279 // 7628: }
7280 2, 7, // 7633: case 0x2: {
7281 OPC_CheckPredicate, 30, // 7635: check predicate 30
7282 OPC_Decode, 161, 13, 184, 2, // 7637: decode to FILL_W using decoder 312
7283 // 7637: }
7284 3, 7, // 7642: case 0x3: {
7285 OPC_CheckPredicate, 38, // 7644: check predicate 38
7286 OPC_Decode, 159, 13, 185, 2, // 7646: decode to FILL_D using decoder 313
7287 // 7646: }
7288 4, 7, // 7651: case 0x4: {
7289 OPC_CheckPredicate, 30, // 7653: check predicate 30
7290 OPC_Decode, 202, 18, 174, 2, // 7655: decode to PCNT_B using decoder 302
7291 // 7655: }
7292 5, 7, // 7660: case 0x5: {
7293 OPC_CheckPredicate, 30, // 7662: check predicate 30
7294 OPC_Decode, 204, 18, 186, 2, // 7664: decode to PCNT_H using decoder 314
7295 // 7664: }
7296 6, 7, // 7669: case 0x6: {
7297 OPC_CheckPredicate, 30, // 7671: check predicate 30
7298 OPC_Decode, 205, 18, 187, 2, // 7673: decode to PCNT_W using decoder 315
7299 // 7673: }
7300 7, 7, // 7678: case 0x7: {
7301 OPC_CheckPredicate, 30, // 7680: check predicate 30
7302 OPC_Decode, 203, 18, 188, 2, // 7682: decode to PCNT_D using decoder 316
7303 // 7682: }
7304 8, 7, // 7687: case 0x8: {
7305 OPC_CheckPredicate, 30, // 7689: check predicate 30
7306 OPC_Decode, 148, 18, 174, 2, // 7691: decode to NLOC_B using decoder 302
7307 // 7691: }
7308 9, 7, // 7696: case 0x9: {
7309 OPC_CheckPredicate, 30, // 7698: check predicate 30
7310 OPC_Decode, 150, 18, 186, 2, // 7700: decode to NLOC_H using decoder 314
7311 // 7700: }
7312 10, 7, // 7705: case 0xa: {
7313 OPC_CheckPredicate, 30, // 7707: check predicate 30
7314 OPC_Decode, 151, 18, 187, 2, // 7709: decode to NLOC_W using decoder 315
7315 // 7709: }
7316 11, 7, // 7714: case 0xb: {
7317 OPC_CheckPredicate, 30, // 7716: check predicate 30
7318 OPC_Decode, 149, 18, 188, 2, // 7718: decode to NLOC_D using decoder 316
7319 // 7718: }
7320 12, 7, // 7723: case 0xc: {
7321 OPC_CheckPredicate, 30, // 7725: check predicate 30
7322 OPC_Decode, 152, 18, 174, 2, // 7727: decode to NLZC_B using decoder 302
7323 // 7727: }
7324 13, 7, // 7732: case 0xd: {
7325 OPC_CheckPredicate, 30, // 7734: check predicate 30
7326 OPC_Decode, 154, 18, 186, 2, // 7736: decode to NLZC_H using decoder 314
7327 // 7736: }
7328 14, 7, // 7741: case 0xe: {
7329 OPC_CheckPredicate, 30, // 7743: check predicate 30
7330 OPC_Decode, 155, 18, 187, 2, // 7745: decode to NLZC_W using decoder 315
7331 // 7745: }
7332 15, 0, // 7750: case 0xf: {
7333 OPC_CheckPredicate, 30, // 7752: check predicate 30
7334 OPC_Decode, 153, 18, 188, 2, // 7754: decode to NLZC_D using decoder 316
7335 // 7754: }
7336 // 7754: } // switch Inst[20:16]
7337 // 7754: }
7338 25, 0, // 7759: case 0x19: {
7339 OPC_SwitchField, 16, 5, // 7761: switch Inst[20:16] {
7340 0, 7, // 7764: case 0x0: {
7341 OPC_CheckPredicate, 30, // 7766: check predicate 30
7342 OPC_Decode, 237, 12, 187, 2, // 7768: decode to FCLASS_W using decoder 315
7343 // 7768: }
7344 1, 7, // 7773: case 0x1: {
7345 OPC_CheckPredicate, 30, // 7775: check predicate 30
7346 OPC_Decode, 236, 12, 188, 2, // 7777: decode to FCLASS_D using decoder 316
7347 // 7777: }
7348 2, 7, // 7782: case 0x2: {
7349 OPC_CheckPredicate, 30, // 7784: check predicate 30
7350 OPC_Decode, 138, 14, 187, 2, // 7786: decode to FTRUNC_S_W using decoder 315
7351 // 7786: }
7352 3, 7, // 7791: case 0x3: {
7353 OPC_CheckPredicate, 30, // 7793: check predicate 30
7354 OPC_Decode, 137, 14, 188, 2, // 7795: decode to FTRUNC_S_D using decoder 316
7355 // 7795: }
7356 4, 7, // 7800: case 0x4: {
7357 OPC_CheckPredicate, 30, // 7802: check predicate 30
7358 OPC_Decode, 140, 14, 187, 2, // 7804: decode to FTRUNC_U_W using decoder 315
7359 // 7804: }
7360 5, 7, // 7809: case 0x5: {
7361 OPC_CheckPredicate, 30, // 7811: check predicate 30
7362 OPC_Decode, 139, 14, 188, 2, // 7813: decode to FTRUNC_U_D using decoder 316
7363 // 7813: }
7364 6, 7, // 7818: case 0x6: {
7365 OPC_CheckPredicate, 30, // 7820: check predicate 30
7366 OPC_Decode, 238, 13, 187, 2, // 7822: decode to FSQRT_W using decoder 315
7367 // 7822: }
7368 7, 7, // 7827: case 0x7: {
7369 OPC_CheckPredicate, 30, // 7829: check predicate 30
7370 OPC_Decode, 231, 13, 188, 2, // 7831: decode to FSQRT_D using decoder 316
7371 // 7831: }
7372 8, 7, // 7836: case 0x8: {
7373 OPC_CheckPredicate, 30, // 7838: check predicate 30
7374 OPC_Decode, 218, 13, 187, 2, // 7840: decode to FRSQRT_W using decoder 315
7375 // 7840: }
7376 9, 7, // 7845: case 0x9: {
7377 OPC_CheckPredicate, 30, // 7847: check predicate 30
7378 OPC_Decode, 217, 13, 188, 2, // 7849: decode to FRSQRT_D using decoder 316
7379 // 7849: }
7380 10, 7, // 7854: case 0xa: {
7381 OPC_CheckPredicate, 30, // 7856: check predicate 30
7382 OPC_Decode, 214, 13, 187, 2, // 7858: decode to FRCP_W using decoder 315
7383 // 7858: }
7384 11, 7, // 7863: case 0xb: {
7385 OPC_CheckPredicate, 30, // 7865: check predicate 30
7386 OPC_Decode, 213, 13, 188, 2, // 7867: decode to FRCP_D using decoder 316
7387 // 7867: }
7388 12, 7, // 7872: case 0xc: {
7389 OPC_CheckPredicate, 30, // 7874: check predicate 30
7390 OPC_Decode, 216, 13, 187, 2, // 7876: decode to FRINT_W using decoder 315
7391 // 7876: }
7392 13, 7, // 7881: case 0xd: {
7393 OPC_CheckPredicate, 30, // 7883: check predicate 30
7394 OPC_Decode, 215, 13, 188, 2, // 7885: decode to FRINT_D using decoder 316
7395 // 7885: }
7396 14, 7, // 7890: case 0xe: {
7397 OPC_CheckPredicate, 30, // 7892: check predicate 30
7398 OPC_Decode, 163, 13, 187, 2, // 7894: decode to FLOG2_W using decoder 315
7399 // 7894: }
7400 15, 7, // 7899: case 0xf: {
7401 OPC_CheckPredicate, 30, // 7901: check predicate 30
7402 OPC_Decode, 162, 13, 188, 2, // 7903: decode to FLOG2_D using decoder 316
7403 // 7903: }
7404 16, 7, // 7908: case 0x10: {
7405 OPC_CheckPredicate, 30, // 7910: check predicate 30
7406 OPC_Decode, 147, 13, 189, 2, // 7912: decode to FEXUPL_W using decoder 317
7407 // 7912: }
7408 17, 7, // 7917: case 0x11: {
7409 OPC_CheckPredicate, 30, // 7919: check predicate 30
7410 OPC_Decode, 146, 13, 190, 2, // 7921: decode to FEXUPL_D using decoder 318
7411 // 7921: }
7412 18, 7, // 7926: case 0x12: {
7413 OPC_CheckPredicate, 30, // 7928: check predicate 30
7414 OPC_Decode, 149, 13, 189, 2, // 7930: decode to FEXUPR_W using decoder 317
7415 // 7930: }
7416 19, 7, // 7935: case 0x13: {
7417 OPC_CheckPredicate, 30, // 7937: check predicate 30
7418 OPC_Decode, 148, 13, 190, 2, // 7939: decode to FEXUPR_D using decoder 318
7419 // 7939: }
7420 20, 7, // 7944: case 0x14: {
7421 OPC_CheckPredicate, 30, // 7946: check predicate 30
7422 OPC_Decode, 155, 13, 189, 2, // 7948: decode to FFQL_W using decoder 317
7423 // 7948: }
7424 21, 7, // 7953: case 0x15: {
7425 OPC_CheckPredicate, 30, // 7955: check predicate 30
7426 OPC_Decode, 154, 13, 190, 2, // 7957: decode to FFQL_D using decoder 318
7427 // 7957: }
7428 22, 7, // 7962: case 0x16: {
7429 OPC_CheckPredicate, 30, // 7964: check predicate 30
7430 OPC_Decode, 157, 13, 189, 2, // 7966: decode to FFQR_W using decoder 317
7431 // 7966: }
7432 23, 7, // 7971: case 0x17: {
7433 OPC_CheckPredicate, 30, // 7973: check predicate 30
7434 OPC_Decode, 156, 13, 190, 2, // 7975: decode to FFQR_D using decoder 318
7435 // 7975: }
7436 24, 7, // 7980: case 0x18: {
7437 OPC_CheckPredicate, 30, // 7982: check predicate 30
7438 OPC_Decode, 132, 14, 187, 2, // 7984: decode to FTINT_S_W using decoder 315
7439 // 7984: }
7440 25, 7, // 7989: case 0x19: {
7441 OPC_CheckPredicate, 30, // 7991: check predicate 30
7442 OPC_Decode, 131, 14, 188, 2, // 7993: decode to FTINT_S_D using decoder 316
7443 // 7993: }
7444 26, 7, // 7998: case 0x1a: {
7445 OPC_CheckPredicate, 30, // 8000: check predicate 30
7446 OPC_Decode, 134, 14, 187, 2, // 8002: decode to FTINT_U_W using decoder 315
7447 // 8002: }
7448 27, 7, // 8007: case 0x1b: {
7449 OPC_CheckPredicate, 30, // 8009: check predicate 30
7450 OPC_Decode, 133, 14, 188, 2, // 8011: decode to FTINT_U_D using decoder 316
7451 // 8011: }
7452 28, 7, // 8016: case 0x1c: {
7453 OPC_CheckPredicate, 30, // 8018: check predicate 30
7454 OPC_Decode, 151, 13, 187, 2, // 8020: decode to FFINT_S_W using decoder 315
7455 // 8020: }
7456 29, 7, // 8025: case 0x1d: {
7457 OPC_CheckPredicate, 30, // 8027: check predicate 30
7458 OPC_Decode, 150, 13, 188, 2, // 8029: decode to FFINT_S_D using decoder 316
7459 // 8029: }
7460 30, 7, // 8034: case 0x1e: {
7461 OPC_CheckPredicate, 30, // 8036: check predicate 30
7462 OPC_Decode, 153, 13, 187, 2, // 8038: decode to FFINT_U_W using decoder 315
7463 // 8038: }
7464 31, 0, // 8043: case 0x1f: {
7465 OPC_CheckPredicate, 30, // 8045: check predicate 30
7466 OPC_Decode, 152, 13, 188, 2, // 8047: decode to FFINT_U_D using decoder 316
7467 // 8047: }
7468 // 8047: } // switch Inst[20:16]
7469 // 8047: }
7470 // 8047: } // switch Inst[25:21]
7471 // 8047: }
7472 32, 7, // 8052: case 0x20: {
7473 OPC_CheckPredicate, 30, // 8054: check predicate 30
7474 OPC_Decode, 138, 15, 191, 2, // 8056: decode to LD_B using decoder 319
7475 // 8056: }
7476 33, 7, // 8061: case 0x21: {
7477 OPC_CheckPredicate, 30, // 8063: check predicate 30
7478 OPC_Decode, 140, 15, 191, 2, // 8065: decode to LD_H using decoder 319
7479 // 8065: }
7480 34, 7, // 8070: case 0x22: {
7481 OPC_CheckPredicate, 30, // 8072: check predicate 30
7482 OPC_Decode, 141, 15, 191, 2, // 8074: decode to LD_W using decoder 319
7483 // 8074: }
7484 35, 7, // 8079: case 0x23: {
7485 OPC_CheckPredicate, 30, // 8081: check predicate 30
7486 OPC_Decode, 139, 15, 191, 2, // 8083: decode to LD_D using decoder 319
7487 // 8083: }
7488 36, 7, // 8088: case 0x24: {
7489 OPC_CheckPredicate, 30, // 8090: check predicate 30
7490 OPC_Decode, 153, 21, 191, 2, // 8092: decode to ST_B using decoder 319
7491 // 8092: }
7492 37, 7, // 8097: case 0x25: {
7493 OPC_CheckPredicate, 30, // 8099: check predicate 30
7494 OPC_Decode, 155, 21, 191, 2, // 8101: decode to ST_H using decoder 319
7495 // 8101: }
7496 38, 7, // 8106: case 0x26: {
7497 OPC_CheckPredicate, 30, // 8108: check predicate 30
7498 OPC_Decode, 156, 21, 191, 2, // 8110: decode to ST_W using decoder 319
7499 // 8110: }
7500 39, 0, // 8115: case 0x27: {
7501 OPC_CheckPredicate, 30, // 8117: check predicate 30
7502 OPC_Decode, 154, 21, 191, 2, // 8119: decode to ST_D using decoder 319
7503 // 8119: }
7504 // 8119: } // switch Inst[5:0]
7505 // 8119: }
7506 31, 135, 15, // 8124: case 0x1f: {
7507 OPC_SwitchField, 0, 6, // 8127: switch Inst[5:0] {
7508 0, 7, // 8130: case 0x0: {
7509 OPC_CheckPredicate, 28, // 8132: check predicate 28
7510 OPC_Decode, 187, 12, 192, 2, // 8134: decode to EXT using decoder 320
7511 // 8134: }
7512 4, 7, // 8139: case 0x4: {
7513 OPC_CheckPredicate, 28, // 8141: check predicate 28
7514 OPC_Decode, 175, 14, 193, 2, // 8143: decode to INS using decoder 321
7515 // 8143: }
7516 8, 11, // 8148: case 0x8: {
7517 OPC_CheckPredicate, 42, // 8150: check predicate 42
7518 OPC_CheckField, 6, 5, 0, // 8152: check Inst[10:6] == 0x0
7519 OPC_Decode, 212, 13, 194, 2, // 8156: decode to FORK using decoder 322
7520 // 8156: }
7521 9, 14, // 8161: case 0x9: {
7522 OPC_CheckPredicate, 42, // 8163: check predicate 42
7523 OPC_CheckField, 16, 5, 0, // 8165: check Inst[20:16] == 0x0
7524 OPC_CheckField, 6, 5, 0, // 8169: check Inst[10:6] == 0x0
7525 OPC_Decode, 243, 22, 52, // 8173: decode to YIELD using decoder 52
7526 // 8173: }
7527 10, 30, // 8177: case 0xa: {
7528 OPC_SwitchField, 6, 5, // 8179: switch Inst[10:6] {
7529 0, 7, // 8182: case 0x0: {
7530 OPC_CheckPredicate, 37, // 8184: check predicate 37
7531 OPC_Decode, 213, 15, 195, 2, // 8186: decode to LWX using decoder 323
7532 // 8186: }
7533 4, 7, // 8191: case 0x4: {
7534 OPC_CheckPredicate, 37, // 8193: check predicate 37
7535 OPC_Decode, 150, 15, 195, 2, // 8195: decode to LHX using decoder 323
7536 // 8195: }
7537 6, 0, // 8200: case 0x6: {
7538 OPC_CheckPredicate, 37, // 8202: check predicate 37
7539 OPC_Decode, 237, 14, 195, 2, // 8204: decode to LBUX using decoder 323
7540 // 8204: }
7541 // 8204: } // switch Inst[10:6]
7542 // 8204: }
7543 12, 11, // 8209: case 0xc: {
7544 OPC_CheckPredicate, 37, // 8211: check predicate 37
7545 OPC_CheckField, 6, 10, 0, // 8213: check Inst[15:6] == 0x0
7546 OPC_Decode, 180, 14, 196, 2, // 8217: decode to INSV using decoder 324
7547 // 8217: }
7548 16, 218, 1, // 8222: case 0x10: {
7549 OPC_SwitchField, 6, 5, // 8225: switch Inst[10:6] {
7550 0, 7, // 8228: case 0x0: {
7551 OPC_CheckPredicate, 37, // 8230: check predicate 37
7552 OPC_Decode, 201, 6, 197, 2, // 8232: decode to ADDU_QB using decoder 325
7553 // 8232: }
7554 1, 7, // 8237: case 0x1: {
7555 OPC_CheckPredicate, 37, // 8239: check predicate 37
7556 OPC_Decode, 197, 21, 197, 2, // 8241: decode to SUBU_QB using decoder 325
7557 // 8241: }
7558 4, 7, // 8246: case 0x4: {
7559 OPC_CheckPredicate, 37, // 8248: check predicate 37
7560 OPC_Decode, 205, 6, 197, 2, // 8250: decode to ADDU_S_QB using decoder 325
7561 // 8250: }
7562 5, 7, // 8255: case 0x5: {
7563 OPC_CheckPredicate, 37, // 8257: check predicate 37
7564 OPC_Decode, 201, 21, 197, 2, // 8259: decode to SUBU_S_QB using decoder 325
7565 // 8259: }
7566 6, 7, // 8264: case 0x6: {
7567 OPC_CheckPredicate, 37, // 8266: check predicate 37
7568 OPC_Decode, 229, 17, 197, 2, // 8268: decode to MULEU_S_PH_QBL using decoder 325
7569 // 8268: }
7570 7, 7, // 8273: case 0x7: {
7571 OPC_CheckPredicate, 37, // 8275: check predicate 37
7572 OPC_Decode, 231, 17, 197, 2, // 8277: decode to MULEU_S_PH_QBR using decoder 325
7573 // 8277: }
7574 8, 7, // 8282: case 0x8: {
7575 OPC_CheckPredicate, 71, // 8284: check predicate 71
7576 OPC_Decode, 199, 6, 197, 2, // 8286: decode to ADDU_PH using decoder 325
7577 // 8286: }
7578 9, 7, // 8291: case 0x9: {
7579 OPC_CheckPredicate, 71, // 8293: check predicate 71
7580 OPC_Decode, 195, 21, 197, 2, // 8295: decode to SUBU_PH using decoder 325
7581 // 8295: }
7582 10, 7, // 8300: case 0xa: {
7583 OPC_CheckPredicate, 37, // 8302: check predicate 37
7584 OPC_Decode, 171, 6, 197, 2, // 8304: decode to ADDQ_PH using decoder 325
7585 // 8304: }
7586 11, 7, // 8309: case 0xb: {
7587 OPC_CheckPredicate, 37, // 8311: check predicate 37
7588 OPC_Decode, 166, 21, 197, 2, // 8313: decode to SUBQ_PH using decoder 325
7589 // 8313: }
7590 12, 7, // 8318: case 0xc: {
7591 OPC_CheckPredicate, 71, // 8320: check predicate 71
7592 OPC_Decode, 203, 6, 197, 2, // 8322: decode to ADDU_S_PH using decoder 325
7593 // 8322: }
7594 13, 7, // 8327: case 0xd: {
7595 OPC_CheckPredicate, 71, // 8329: check predicate 71
7596 OPC_Decode, 199, 21, 197, 2, // 8331: decode to SUBU_S_PH using decoder 325
7597 // 8331: }
7598 14, 7, // 8336: case 0xe: {
7599 OPC_CheckPredicate, 37, // 8338: check predicate 37
7600 OPC_Decode, 173, 6, 197, 2, // 8340: decode to ADDQ_S_PH using decoder 325
7601 // 8340: }
7602 15, 7, // 8345: case 0xf: {
7603 OPC_CheckPredicate, 37, // 8347: check predicate 37
7604 OPC_Decode, 168, 21, 197, 2, // 8349: decode to SUBQ_S_PH using decoder 325
7605 // 8349: }
7606 16, 6, // 8354: case 0x10: {
7607 OPC_CheckPredicate, 37, // 8356: check predicate 37
7608 OPC_Decode, 178, 6, 67, // 8358: decode to ADDSC using decoder 67
7609 // 8358: }
7610 17, 6, // 8362: case 0x11: {
7611 OPC_CheckPredicate, 37, // 8364: check predicate 37
7612 OPC_Decode, 215, 6, 67, // 8366: decode to ADDWC using decoder 67
7613 // 8366: }
7614 18, 6, // 8370: case 0x12: {
7615 OPC_CheckPredicate, 37, // 8372: check predicate 37
7616 OPC_Decode, 226, 16, 67, // 8374: decode to MODSUB using decoder 67
7617 // 8374: }
7618 20, 11, // 8378: case 0x14: {
7619 OPC_CheckPredicate, 37, // 8380: check predicate 37
7620 OPC_CheckField, 16, 5, 0, // 8382: check Inst[20:16] == 0x0
7621 OPC_Decode, 130, 19, 198, 2, // 8386: decode to RADDU_W_QB using decoder 326
7622 // 8386: }
7623 22, 6, // 8391: case 0x16: {
7624 OPC_CheckPredicate, 37, // 8393: check predicate 37
7625 OPC_Decode, 175, 6, 67, // 8395: decode to ADDQ_S_W using decoder 67
7626 // 8395: }
7627 23, 6, // 8399: case 0x17: {
7628 OPC_CheckPredicate, 37, // 8401: check predicate 37
7629 OPC_Decode, 170, 21, 67, // 8403: decode to SUBQ_S_W using decoder 67
7630 // 8403: }
7631 28, 7, // 8407: case 0x1c: {
7632 OPC_CheckPredicate, 37, // 8409: check predicate 37
7633 OPC_Decode, 225, 17, 199, 2, // 8411: decode to MULEQ_S_W_PHL using decoder 327
7634 // 8411: }
7635 29, 7, // 8416: case 0x1d: {
7636 OPC_CheckPredicate, 37, // 8418: check predicate 37
7637 OPC_Decode, 227, 17, 199, 2, // 8420: decode to MULEQ_S_W_PHR using decoder 327
7638 // 8420: }
7639 30, 7, // 8425: case 0x1e: {
7640 OPC_CheckPredicate, 71, // 8427: check predicate 71
7641 OPC_Decode, 237, 17, 197, 2, // 8429: decode to MULQ_S_PH using decoder 325
7642 // 8429: }
7643 31, 0, // 8434: case 0x1f: {
7644 OPC_CheckPredicate, 37, // 8436: check predicate 37
7645 OPC_Decode, 233, 17, 197, 2, // 8438: decode to MULQ_RS_PH using decoder 325
7646 // 8438: }
7647 // 8438: } // switch Inst[10:6]
7648 // 8438: }
7649 17, 219, 1, // 8443: case 0x11: {
7650 OPC_SwitchField, 6, 5, // 8446: switch Inst[10:6] {
7651 0, 10, // 8449: case 0x0: {
7652 OPC_CheckPredicate, 37, // 8451: check predicate 37
7653 OPC_CheckField, 11, 5, 0, // 8453: check Inst[15:11] == 0x0
7654 OPC_Decode, 188, 9, 85, // 8457: decode to CMPU_EQ_QB using decoder 85
7655 // 8457: }
7656 1, 10, // 8461: case 0x1: {
7657 OPC_CheckPredicate, 37, // 8463: check predicate 37
7658 OPC_CheckField, 11, 5, 0, // 8465: check Inst[15:11] == 0x0
7659 OPC_Decode, 192, 9, 85, // 8469: decode to CMPU_LT_QB using decoder 85
7660 // 8469: }
7661 2, 10, // 8473: case 0x2: {
7662 OPC_CheckPredicate, 37, // 8475: check predicate 37
7663 OPC_CheckField, 11, 5, 0, // 8477: check Inst[15:11] == 0x0
7664 OPC_Decode, 190, 9, 85, // 8481: decode to CMPU_LE_QB using decoder 85
7665 // 8481: }
7666 3, 7, // 8485: case 0x3: {
7667 OPC_CheckPredicate, 37, // 8487: check predicate 37
7668 OPC_Decode, 208, 18, 197, 2, // 8489: decode to PICK_QB using decoder 325
7669 // 8489: }
7670 4, 7, // 8494: case 0x4: {
7671 OPC_CheckPredicate, 37, // 8496: check predicate 37
7672 OPC_Decode, 182, 9, 199, 2, // 8498: decode to CMPGU_EQ_QB using decoder 327
7673 // 8498: }
7674 5, 7, // 8503: case 0x5: {
7675 OPC_CheckPredicate, 37, // 8505: check predicate 37
7676 OPC_Decode, 186, 9, 199, 2, // 8507: decode to CMPGU_LT_QB using decoder 327
7677 // 8507: }
7678 6, 7, // 8512: case 0x6: {
7679 OPC_CheckPredicate, 37, // 8514: check predicate 37
7680 OPC_Decode, 184, 9, 199, 2, // 8516: decode to CMPGU_LE_QB using decoder 327
7681 // 8516: }
7682 8, 10, // 8521: case 0x8: {
7683 OPC_CheckPredicate, 37, // 8523: check predicate 37
7684 OPC_CheckField, 11, 5, 0, // 8525: check Inst[15:11] == 0x0
7685 OPC_Decode, 198, 9, 85, // 8529: decode to CMP_EQ_PH using decoder 85
7686 // 8529: }
7687 9, 10, // 8533: case 0x9: {
7688 OPC_CheckPredicate, 37, // 8535: check predicate 37
7689 OPC_CheckField, 11, 5, 0, // 8537: check Inst[15:11] == 0x0
7690 OPC_Decode, 212, 9, 85, // 8541: decode to CMP_LT_PH using decoder 85
7691 // 8541: }
7692 10, 10, // 8545: case 0xa: {
7693 OPC_CheckPredicate, 37, // 8547: check predicate 37
7694 OPC_CheckField, 11, 5, 0, // 8549: check Inst[15:11] == 0x0
7695 OPC_Decode, 206, 9, 85, // 8553: decode to CMP_LE_PH using decoder 85
7696 // 8553: }
7697 11, 7, // 8557: case 0xb: {
7698 OPC_CheckPredicate, 37, // 8559: check predicate 37
7699 OPC_Decode, 206, 18, 197, 2, // 8561: decode to PICK_PH using decoder 325
7700 // 8561: }
7701 12, 7, // 8566: case 0xc: {
7702 OPC_CheckPredicate, 37, // 8568: check predicate 37
7703 OPC_Decode, 237, 18, 197, 2, // 8570: decode to PRECRQ_QB_PH using decoder 325
7704 // 8570: }
7705 13, 7, // 8575: case 0xd: {
7706 OPC_CheckPredicate, 71, // 8577: check predicate 71
7707 OPC_Decode, 241, 18, 197, 2, // 8579: decode to PRECR_QB_PH using decoder 325
7708 // 8579: }
7709 14, 7, // 8584: case 0xe: {
7710 OPC_CheckPredicate, 37, // 8586: check predicate 37
7711 OPC_Decode, 189, 18, 197, 2, // 8588: decode to PACKRL_PH using decoder 325
7712 // 8588: }
7713 15, 7, // 8593: case 0xf: {
7714 OPC_CheckPredicate, 37, // 8595: check predicate 37
7715 OPC_Decode, 233, 18, 197, 2, // 8597: decode to PRECRQU_S_QB_PH using decoder 325
7716 // 8597: }
7717 20, 7, // 8602: case 0x14: {
7718 OPC_CheckPredicate, 37, // 8604: check predicate 37
7719 OPC_Decode, 235, 18, 200, 2, // 8606: decode to PRECRQ_PH_W using decoder 328
7720 // 8606: }
7721 21, 7, // 8611: case 0x15: {
7722 OPC_CheckPredicate, 37, // 8613: check predicate 37
7723 OPC_Decode, 239, 18, 200, 2, // 8615: decode to PRECRQ_RS_PH_W using decoder 328
7724 // 8615: }
7725 24, 7, // 8620: case 0x18: {
7726 OPC_CheckPredicate, 71, // 8622: check predicate 71
7727 OPC_Decode, 176, 9, 199, 2, // 8624: decode to CMPGDU_EQ_QB using decoder 327
7728 // 8624: }
7729 25, 7, // 8629: case 0x19: {
7730 OPC_CheckPredicate, 71, // 8631: check predicate 71
7731 OPC_Decode, 180, 9, 199, 2, // 8633: decode to CMPGDU_LT_QB using decoder 327
7732 // 8633: }
7733 26, 7, // 8638: case 0x1a: {
7734 OPC_CheckPredicate, 71, // 8640: check predicate 71
7735 OPC_Decode, 178, 9, 199, 2, // 8642: decode to CMPGDU_LE_QB using decoder 327
7736 // 8642: }
7737 30, 7, // 8647: case 0x1e: {
7738 OPC_CheckPredicate, 71, // 8649: check predicate 71
7739 OPC_Decode, 243, 18, 201, 2, // 8651: decode to PRECR_SRA_PH_W using decoder 329
7740 // 8651: }
7741 31, 0, // 8656: case 0x1f: {
7742 OPC_CheckPredicate, 71, // 8658: check predicate 71
7743 OPC_Decode, 245, 18, 201, 2, // 8660: decode to PRECR_SRA_R_PH_W using decoder 329
7744 // 8660: }
7745 // 8660: } // switch Inst[10:6]
7746 // 8660: }
7747 18, 228, 1, // 8665: case 0x12: {
7748 OPC_SwitchField, 6, 5, // 8668: switch Inst[10:6] {
7749 1, 11, // 8671: case 0x1: {
7750 OPC_CheckPredicate, 71, // 8673: check predicate 71
7751 OPC_CheckField, 21, 5, 0, // 8675: check Inst[25:21] == 0x0
7752 OPC_Decode, 150, 6, 202, 2, // 8679: decode to ABSQ_S_QB using decoder 330
7753 // 8679: }
7754 2, 7, // 8684: case 0x2: {
7755 OPC_CheckPredicate, 37, // 8686: check predicate 37
7756 OPC_Decode, 151, 19, 203, 2, // 8688: decode to REPL_QB using decoder 331
7757 // 8688: }
7758 3, 11, // 8693: case 0x3: {
7759 OPC_CheckPredicate, 37, // 8695: check predicate 37
7760 OPC_CheckField, 21, 5, 0, // 8697: check Inst[25:21] == 0x0
7761 OPC_Decode, 147, 19, 204, 2, // 8701: decode to REPLV_QB using decoder 332
7762 // 8701: }
7763 4, 11, // 8706: case 0x4: {
7764 OPC_CheckPredicate, 37, // 8708: check predicate 37
7765 OPC_CheckField, 21, 5, 0, // 8710: check Inst[25:21] == 0x0
7766 OPC_Decode, 213, 18, 202, 2, // 8714: decode to PRECEQU_PH_QBL using decoder 330
7767 // 8714: }
7768 5, 11, // 8719: case 0x5: {
7769 OPC_CheckPredicate, 37, // 8721: check predicate 37
7770 OPC_CheckField, 21, 5, 0, // 8723: check Inst[25:21] == 0x0
7771 OPC_Decode, 217, 18, 202, 2, // 8727: decode to PRECEQU_PH_QBR using decoder 330
7772 // 8727: }
7773 6, 11, // 8732: case 0x6: {
7774 OPC_CheckPredicate, 37, // 8734: check predicate 37
7775 OPC_CheckField, 21, 5, 0, // 8736: check Inst[25:21] == 0x0
7776 OPC_Decode, 214, 18, 202, 2, // 8740: decode to PRECEQU_PH_QBLA using decoder 330
7777 // 8740: }
7778 7, 11, // 8745: case 0x7: {
7779 OPC_CheckPredicate, 37, // 8747: check predicate 37
7780 OPC_CheckField, 21, 5, 0, // 8749: check Inst[25:21] == 0x0
7781 OPC_Decode, 218, 18, 202, 2, // 8753: decode to PRECEQU_PH_QBRA using decoder 330
7782 // 8753: }
7783 9, 11, // 8758: case 0x9: {
7784 OPC_CheckPredicate, 37, // 8760: check predicate 37
7785 OPC_CheckField, 21, 5, 0, // 8762: check Inst[25:21] == 0x0
7786 OPC_Decode, 148, 6, 202, 2, // 8766: decode to ABSQ_S_PH using decoder 330
7787 // 8766: }
7788 10, 6, // 8771: case 0xa: {
7789 OPC_CheckPredicate, 37, // 8773: check predicate 37
7790 OPC_Decode, 149, 19, 103, // 8775: decode to REPL_PH using decoder 103
7791 // 8775: }
7792 11, 11, // 8779: case 0xb: {
7793 OPC_CheckPredicate, 37, // 8781: check predicate 37
7794 OPC_CheckField, 21, 5, 0, // 8783: check Inst[25:21] == 0x0
7795 OPC_Decode, 145, 19, 204, 2, // 8787: decode to REPLV_PH using decoder 332
7796 // 8787: }
7797 12, 11, // 8792: case 0xc: {
7798 OPC_CheckPredicate, 37, // 8794: check predicate 37
7799 OPC_CheckField, 21, 5, 0, // 8796: check Inst[25:21] == 0x0
7800 OPC_Decode, 221, 18, 205, 2, // 8800: decode to PRECEQ_W_PHL using decoder 333
7801 // 8800: }
7802 13, 11, // 8805: case 0xd: {
7803 OPC_CheckPredicate, 37, // 8807: check predicate 37
7804 OPC_CheckField, 21, 5, 0, // 8809: check Inst[25:21] == 0x0
7805 OPC_Decode, 223, 18, 205, 2, // 8813: decode to PRECEQ_W_PHR using decoder 333
7806 // 8813: }
7807 17, 11, // 8818: case 0x11: {
7808 OPC_CheckPredicate, 37, // 8820: check predicate 37
7809 OPC_CheckField, 21, 5, 0, // 8822: check Inst[25:21] == 0x0
7810 OPC_Decode, 152, 6, 206, 2, // 8826: decode to ABSQ_S_W using decoder 334
7811 // 8826: }
7812 27, 11, // 8831: case 0x1b: {
7813 OPC_CheckPredicate, 37, // 8833: check predicate 37
7814 OPC_CheckField, 21, 5, 0, // 8835: check Inst[25:21] == 0x0
7815 OPC_Decode, 253, 7, 206, 2, // 8839: decode to BITREV using decoder 334
7816 // 8839: }
7817 28, 11, // 8844: case 0x1c: {
7818 OPC_CheckPredicate, 37, // 8846: check predicate 37
7819 OPC_CheckField, 21, 5, 0, // 8848: check Inst[25:21] == 0x0
7820 OPC_Decode, 225, 18, 202, 2, // 8852: decode to PRECEU_PH_QBL using decoder 330
7821 // 8852: }
7822 29, 11, // 8857: case 0x1d: {
7823 OPC_CheckPredicate, 37, // 8859: check predicate 37
7824 OPC_CheckField, 21, 5, 0, // 8861: check Inst[25:21] == 0x0
7825 OPC_Decode, 229, 18, 202, 2, // 8865: decode to PRECEU_PH_QBR using decoder 330
7826 // 8865: }
7827 30, 11, // 8870: case 0x1e: {
7828 OPC_CheckPredicate, 37, // 8872: check predicate 37
7829 OPC_CheckField, 21, 5, 0, // 8874: check Inst[25:21] == 0x0
7830 OPC_Decode, 226, 18, 202, 2, // 8878: decode to PRECEU_PH_QBLA using decoder 330
7831 // 8878: }
7832 31, 0, // 8883: case 0x1f: {
7833 OPC_CheckPredicate, 37, // 8885: check predicate 37
7834 OPC_CheckField, 21, 5, 0, // 8887: check Inst[25:21] == 0x0
7835 OPC_Decode, 230, 18, 202, 2, // 8891: decode to PRECEU_PH_QBRA using decoder 330
7836 // 8891: }
7837 // 8891: } // switch Inst[10:6]
7838 // 8891: }
7839 19, 199, 1, // 8896: case 0x13: {
7840 OPC_SwitchField, 6, 5, // 8899: switch Inst[10:6] {
7841 0, 7, // 8902: case 0x0: {
7842 OPC_CheckPredicate, 37, // 8904: check predicate 37
7843 OPC_Decode, 151, 20, 207, 2, // 8906: decode to SHLL_QB using decoder 335
7844 // 8906: }
7845 1, 7, // 8911: case 0x1: {
7846 OPC_CheckPredicate, 37, // 8913: check predicate 37
7847 OPC_Decode, 183, 20, 207, 2, // 8915: decode to SHRL_QB using decoder 335
7848 // 8915: }
7849 2, 7, // 8920: case 0x2: {
7850 OPC_CheckPredicate, 37, // 8922: check predicate 37
7851 OPC_Decode, 143, 20, 208, 2, // 8924: decode to SHLLV_QB using decoder 336
7852 // 8924: }
7853 3, 7, // 8929: case 0x3: {
7854 OPC_CheckPredicate, 37, // 8931: check predicate 37
7855 OPC_Decode, 179, 20, 208, 2, // 8933: decode to SHRLV_QB using decoder 336
7856 // 8933: }
7857 4, 7, // 8938: case 0x4: {
7858 OPC_CheckPredicate, 71, // 8940: check predicate 71
7859 OPC_Decode, 169, 20, 207, 2, // 8942: decode to SHRA_QB using decoder 335
7860 // 8942: }
7861 5, 7, // 8947: case 0x5: {
7862 OPC_CheckPredicate, 71, // 8949: check predicate 71
7863 OPC_Decode, 173, 20, 207, 2, // 8951: decode to SHRA_R_QB using decoder 335
7864 // 8951: }
7865 6, 7, // 8956: case 0x6: {
7866 OPC_CheckPredicate, 71, // 8958: check predicate 71
7867 OPC_Decode, 159, 20, 208, 2, // 8960: decode to SHRAV_QB using decoder 336
7868 // 8960: }
7869 7, 7, // 8965: case 0x7: {
7870 OPC_CheckPredicate, 71, // 8967: check predicate 71
7871 OPC_Decode, 163, 20, 208, 2, // 8969: decode to SHRAV_R_QB using decoder 336
7872 // 8969: }
7873 8, 7, // 8974: case 0x8: {
7874 OPC_CheckPredicate, 37, // 8976: check predicate 37
7875 OPC_Decode, 149, 20, 207, 2, // 8978: decode to SHLL_PH using decoder 335
7876 // 8978: }
7877 9, 7, // 8983: case 0x9: {
7878 OPC_CheckPredicate, 37, // 8985: check predicate 37
7879 OPC_Decode, 167, 20, 207, 2, // 8987: decode to SHRA_PH using decoder 335
7880 // 8987: }
7881 10, 7, // 8992: case 0xa: {
7882 OPC_CheckPredicate, 37, // 8994: check predicate 37
7883 OPC_Decode, 141, 20, 208, 2, // 8996: decode to SHLLV_PH using decoder 336
7884 // 8996: }
7885 11, 7, // 9001: case 0xb: {
7886 OPC_CheckPredicate, 37, // 9003: check predicate 37
7887 OPC_Decode, 157, 20, 208, 2, // 9005: decode to SHRAV_PH using decoder 336
7888 // 9005: }
7889 12, 7, // 9010: case 0xc: {
7890 OPC_CheckPredicate, 37, // 9012: check predicate 37
7891 OPC_Decode, 153, 20, 207, 2, // 9014: decode to SHLL_S_PH using decoder 335
7892 // 9014: }
7893 13, 7, // 9019: case 0xd: {
7894 OPC_CheckPredicate, 37, // 9021: check predicate 37
7895 OPC_Decode, 171, 20, 207, 2, // 9023: decode to SHRA_R_PH using decoder 335
7896 // 9023: }
7897 14, 7, // 9028: case 0xe: {
7898 OPC_CheckPredicate, 37, // 9030: check predicate 37
7899 OPC_Decode, 145, 20, 208, 2, // 9032: decode to SHLLV_S_PH using decoder 336
7900 // 9032: }
7901 15, 7, // 9037: case 0xf: {
7902 OPC_CheckPredicate, 37, // 9039: check predicate 37
7903 OPC_Decode, 161, 20, 208, 2, // 9041: decode to SHRAV_R_PH using decoder 336
7904 // 9041: }
7905 20, 7, // 9046: case 0x14: {
7906 OPC_CheckPredicate, 37, // 9048: check predicate 37
7907 OPC_Decode, 155, 20, 209, 2, // 9050: decode to SHLL_S_W using decoder 337
7908 // 9050: }
7909 21, 7, // 9055: case 0x15: {
7910 OPC_CheckPredicate, 37, // 9057: check predicate 37
7911 OPC_Decode, 175, 20, 209, 2, // 9059: decode to SHRA_R_W using decoder 337
7912 // 9059: }
7913 22, 6, // 9064: case 0x16: {
7914 OPC_CheckPredicate, 37, // 9066: check predicate 37
7915 OPC_Decode, 147, 20, 61, // 9068: decode to SHLLV_S_W using decoder 61
7916 // 9068: }
7917 23, 6, // 9072: case 0x17: {
7918 OPC_CheckPredicate, 37, // 9074: check predicate 37
7919 OPC_Decode, 165, 20, 61, // 9076: decode to SHRAV_R_W using decoder 61
7920 // 9076: }
7921 25, 7, // 9080: case 0x19: {
7922 OPC_CheckPredicate, 71, // 9082: check predicate 71
7923 OPC_Decode, 181, 20, 207, 2, // 9084: decode to SHRL_PH using decoder 335
7924 // 9084: }
7925 27, 0, // 9089: case 0x1b: {
7926 OPC_CheckPredicate, 71, // 9091: check predicate 71
7927 OPC_Decode, 177, 20, 208, 2, // 9093: decode to SHRLV_PH using decoder 336
7928 // 9093: }
7929 // 9093: } // switch Inst[10:6]
7930 // 9093: }
7931 24, 141, 1, // 9098: case 0x18: {
7932 OPC_SwitchField, 6, 5, // 9101: switch Inst[10:6] {
7933 0, 7, // 9104: case 0x0: {
7934 OPC_CheckPredicate, 71, // 9106: check predicate 71
7935 OPC_Decode, 194, 6, 197, 2, // 9108: decode to ADDUH_QB using decoder 325
7936 // 9108: }
7937 1, 7, // 9113: case 0x1: {
7938 OPC_CheckPredicate, 71, // 9115: check predicate 71
7939 OPC_Decode, 190, 21, 197, 2, // 9117: decode to SUBUH_QB using decoder 325
7940 // 9117: }
7941 2, 7, // 9122: case 0x2: {
7942 OPC_CheckPredicate, 71, // 9124: check predicate 71
7943 OPC_Decode, 196, 6, 197, 2, // 9126: decode to ADDUH_R_QB using decoder 325
7944 // 9126: }
7945 3, 7, // 9131: case 0x3: {
7946 OPC_CheckPredicate, 71, // 9133: check predicate 71
7947 OPC_Decode, 192, 21, 197, 2, // 9135: decode to SUBUH_R_QB using decoder 325
7948 // 9135: }
7949 8, 7, // 9140: case 0x8: {
7950 OPC_CheckPredicate, 71, // 9142: check predicate 71
7951 OPC_Decode, 163, 6, 197, 2, // 9144: decode to ADDQH_PH using decoder 325
7952 // 9144: }
7953 9, 7, // 9149: case 0x9: {
7954 OPC_CheckPredicate, 71, // 9151: check predicate 71
7955 OPC_Decode, 158, 21, 197, 2, // 9153: decode to SUBQH_PH using decoder 325
7956 // 9153: }
7957 10, 7, // 9158: case 0xa: {
7958 OPC_CheckPredicate, 71, // 9160: check predicate 71
7959 OPC_Decode, 165, 6, 197, 2, // 9162: decode to ADDQH_R_PH using decoder 325
7960 // 9162: }
7961 11, 7, // 9167: case 0xb: {
7962 OPC_CheckPredicate, 71, // 9169: check predicate 71
7963 OPC_Decode, 160, 21, 197, 2, // 9171: decode to SUBQH_R_PH using decoder 325
7964 // 9171: }
7965 12, 7, // 9176: case 0xc: {
7966 OPC_CheckPredicate, 71, // 9178: check predicate 71
7967 OPC_Decode, 136, 18, 197, 2, // 9180: decode to MUL_PH using decoder 325
7968 // 9180: }
7969 14, 7, // 9185: case 0xe: {
7970 OPC_CheckPredicate, 71, // 9187: check predicate 71
7971 OPC_Decode, 141, 18, 197, 2, // 9189: decode to MUL_S_PH using decoder 325
7972 // 9189: }
7973 16, 6, // 9194: case 0x10: {
7974 OPC_CheckPredicate, 71, // 9196: check predicate 71
7975 OPC_Decode, 169, 6, 67, // 9198: decode to ADDQH_W using decoder 67
7976 // 9198: }
7977 17, 6, // 9202: case 0x11: {
7978 OPC_CheckPredicate, 71, // 9204: check predicate 71
7979 OPC_Decode, 164, 21, 67, // 9206: decode to SUBQH_W using decoder 67
7980 // 9206: }
7981 18, 6, // 9210: case 0x12: {
7982 OPC_CheckPredicate, 71, // 9212: check predicate 71
7983 OPC_Decode, 167, 6, 67, // 9214: decode to ADDQH_R_W using decoder 67
7984 // 9214: }
7985 19, 6, // 9218: case 0x13: {
7986 OPC_CheckPredicate, 71, // 9220: check predicate 71
7987 OPC_Decode, 162, 21, 67, // 9222: decode to SUBQH_R_W using decoder 67
7988 // 9222: }
7989 22, 6, // 9226: case 0x16: {
7990 OPC_CheckPredicate, 71, // 9228: check predicate 71
7991 OPC_Decode, 239, 17, 67, // 9230: decode to MULQ_S_W using decoder 67
7992 // 9230: }
7993 23, 0, // 9234: case 0x17: {
7994 OPC_CheckPredicate, 71, // 9236: check predicate 71
7995 OPC_Decode, 235, 17, 67, // 9238: decode to MULQ_RS_W using decoder 67
7996 // 9238: }
7997 // 9238: } // switch Inst[10:6]
7998 // 9238: }
7999 25, 11, // 9242: case 0x19: {
8000 OPC_CheckPredicate, 72, // 9244: check predicate 72
8001 OPC_CheckField, 6, 1, 0, // 9246: check Inst[6] == 0x0
8002 OPC_Decode, 196, 15, 210, 2, // 9250: decode to LWLE using decoder 338
8003 // 9250: }
8004 26, 11, // 9255: case 0x1a: {
8005 OPC_CheckPredicate, 72, // 9257: check predicate 72
8006 OPC_CheckField, 6, 1, 0, // 9259: check Inst[6] == 0x0
8007 OPC_Decode, 207, 15, 210, 2, // 9263: decode to LWRE using decoder 338
8008 // 9263: }
8009 27, 11, // 9268: case 0x1b: {
8010 OPC_CheckPredicate, 44, // 9270: check predicate 44
8011 OPC_CheckField, 6, 1, 0, // 9272: check Inst[6] == 0x0
8012 OPC_Decode, 228, 8, 211, 2, // 9276: decode to CACHEE using decoder 339
8013 // 9276: }
8014 28, 11, // 9281: case 0x1c: {
8015 OPC_CheckPredicate, 44, // 9283: check predicate 44
8016 OPC_CheckField, 6, 1, 0, // 9285: check Inst[6] == 0x0
8017 OPC_Decode, 194, 19, 210, 2, // 9289: decode to SBE using decoder 338
8018 // 9289: }
8019 29, 11, // 9294: case 0x1d: {
8020 OPC_CheckPredicate, 44, // 9296: check predicate 44
8021 OPC_CheckField, 6, 1, 0, // 9298: check Inst[6] == 0x0
8022 OPC_Decode, 132, 20, 210, 2, // 9302: decode to SHE using decoder 338
8023 // 9302: }
8024 30, 11, // 9307: case 0x1e: {
8025 OPC_CheckPredicate, 44, // 9309: check predicate 44
8026 OPC_CheckField, 6, 1, 0, // 9311: check Inst[6] == 0x0
8027 OPC_Decode, 203, 19, 210, 2, // 9315: decode to SCE using decoder 338
8028 // 9315: }
8029 31, 11, // 9320: case 0x1f: {
8030 OPC_CheckPredicate, 44, // 9322: check predicate 44
8031 OPC_CheckField, 6, 1, 0, // 9324: check Inst[6] == 0x0
8032 OPC_Decode, 230, 21, 210, 2, // 9328: decode to SWE using decoder 338
8033 // 9328: }
8034 32, 42, // 9333: case 0x20: {
8035 OPC_SwitchField, 6, 5, // 9335: switch Inst[10:6] {
8036 2, 11, // 9338: case 0x2: {
8037 OPC_CheckPredicate, 28, // 9340: check predicate 28
8038 OPC_CheckField, 21, 5, 0, // 9342: check Inst[25:21] == 0x0
8039 OPC_Decode, 227, 22, 206, 2, // 9346: decode to WSBH using decoder 334
8040 // 9346: }
8041 16, 11, // 9351: case 0x10: {
8042 OPC_CheckPredicate, 28, // 9353: check predicate 28
8043 OPC_CheckField, 21, 5, 0, // 9355: check Inst[25:21] == 0x0
8044 OPC_Decode, 230, 19, 206, 2, // 9359: decode to SEB using decoder 334
8045 // 9359: }
8046 24, 0, // 9364: case 0x18: {
8047 OPC_CheckPredicate, 28, // 9366: check predicate 28
8048 OPC_CheckField, 21, 5, 0, // 9368: check Inst[25:21] == 0x0
8049 OPC_Decode, 233, 19, 206, 2, // 9372: decode to SEH using decoder 334
8050 // 9372: }
8051 // 9372: } // switch Inst[10:6]
8052 // 9372: }
8053 33, 11, // 9377: case 0x21: {
8054 OPC_CheckPredicate, 72, // 9379: check predicate 72
8055 OPC_CheckField, 6, 1, 0, // 9381: check Inst[6] == 0x0
8056 OPC_Decode, 234, 21, 210, 2, // 9385: decode to SWLE using decoder 338
8057 // 9385: }
8058 34, 11, // 9390: case 0x22: {
8059 OPC_CheckPredicate, 72, // 9392: check predicate 72
8060 OPC_CheckField, 6, 1, 0, // 9394: check Inst[6] == 0x0
8061 OPC_Decode, 243, 21, 210, 2, // 9398: decode to SWRE using decoder 338
8062 // 9398: }
8063 35, 11, // 9403: case 0x23: {
8064 OPC_CheckPredicate, 44, // 9405: check predicate 44
8065 OPC_CheckField, 6, 1, 0, // 9407: check Inst[6] == 0x0
8066 OPC_Decode, 248, 18, 211, 2, // 9411: decode to PREFE using decoder 339
8067 // 9411: }
8068 40, 11, // 9416: case 0x28: {
8069 OPC_CheckPredicate, 44, // 9418: check predicate 44
8070 OPC_CheckField, 6, 1, 0, // 9420: check Inst[6] == 0x0
8071 OPC_Decode, 244, 14, 210, 2, // 9424: decode to LBuE using decoder 338
8072 // 9424: }
8073 41, 11, // 9429: case 0x29: {
8074 OPC_CheckPredicate, 44, // 9431: check predicate 44
8075 OPC_CheckField, 6, 1, 0, // 9433: check Inst[6] == 0x0
8076 OPC_Decode, 155, 15, 210, 2, // 9437: decode to LHuE using decoder 338
8077 // 9437: }
8078 44, 11, // 9442: case 0x2c: {
8079 OPC_CheckPredicate, 44, // 9444: check predicate 44
8080 OPC_CheckField, 6, 1, 0, // 9446: check Inst[6] == 0x0
8081 OPC_Decode, 234, 14, 210, 2, // 9450: decode to LBE using decoder 338
8082 // 9450: }
8083 45, 11, // 9455: case 0x2d: {
8084 OPC_CheckPredicate, 44, // 9457: check predicate 44
8085 OPC_CheckField, 6, 1, 0, // 9459: check Inst[6] == 0x0
8086 OPC_Decode, 147, 15, 210, 2, // 9463: decode to LHE using decoder 338
8087 // 9463: }
8088 46, 11, // 9468: case 0x2e: {
8089 OPC_CheckPredicate, 44, // 9470: check predicate 44
8090 OPC_CheckField, 6, 1, 0, // 9472: check Inst[6] == 0x0
8091 OPC_Decode, 165, 15, 210, 2, // 9476: decode to LLE using decoder 338
8092 // 9476: }
8093 47, 11, // 9481: case 0x2f: {
8094 OPC_CheckPredicate, 44, // 9483: check predicate 44
8095 OPC_CheckField, 6, 1, 0, // 9485: check Inst[6] == 0x0
8096 OPC_Decode, 191, 15, 210, 2, // 9489: decode to LWE using decoder 338
8097 // 9489: }
8098 48, 161, 2, // 9494: case 0x30: {
8099 OPC_SwitchField, 6, 5, // 9497: switch Inst[10:6] {
8100 0, 11, // 9500: case 0x0: {
8101 OPC_CheckPredicate, 71, // 9502: check predicate 71
8102 OPC_CheckField, 13, 3, 0, // 9504: check Inst[15:13] == 0x0
8103 OPC_Decode, 251, 11, 212, 2, // 9508: decode to DPA_W_PH using decoder 340
8104 // 9508: }
8105 1, 11, // 9513: case 0x1: {
8106 OPC_CheckPredicate, 71, // 9515: check predicate 71
8107 OPC_CheckField, 13, 3, 0, // 9517: check Inst[15:13] == 0x0
8108 OPC_Decode, 146, 12, 212, 2, // 9521: decode to DPS_W_PH using decoder 340
8109 // 9521: }
8110 2, 11, // 9526: case 0x2: {
8111 OPC_CheckPredicate, 71, // 9528: check predicate 71
8112 OPC_CheckField, 13, 3, 0, // 9530: check Inst[15:13] == 0x0
8113 OPC_Decode, 246, 17, 212, 2, // 9534: decode to MULSA_W_PH using decoder 340
8114 // 9534: }
8115 3, 11, // 9539: case 0x3: {
8116 OPC_CheckPredicate, 37, // 9541: check predicate 37
8117 OPC_CheckField, 13, 3, 0, // 9543: check Inst[15:13] == 0x0
8118 OPC_Decode, 245, 11, 212, 2, // 9547: decode to DPAU_H_QBL using decoder 340
8119 // 9547: }
8120 4, 11, // 9552: case 0x4: {
8121 OPC_CheckPredicate, 37, // 9554: check predicate 37
8122 OPC_CheckField, 13, 3, 0, // 9556: check Inst[15:13] == 0x0
8123 OPC_Decode, 243, 11, 212, 2, // 9560: decode to DPAQ_S_W_PH using decoder 340
8124 // 9560: }
8125 5, 11, // 9565: case 0x5: {
8126 OPC_CheckPredicate, 37, // 9567: check predicate 37
8127 OPC_CheckField, 13, 3, 0, // 9569: check Inst[15:13] == 0x0
8128 OPC_Decode, 132, 12, 212, 2, // 9573: decode to DPSQ_S_W_PH using decoder 340
8129 // 9573: }
8130 6, 11, // 9578: case 0x6: {
8131 OPC_CheckPredicate, 37, // 9580: check predicate 37
8132 OPC_CheckField, 13, 3, 0, // 9582: check Inst[15:13] == 0x0
8133 OPC_Decode, 244, 17, 212, 2, // 9586: decode to MULSAQ_S_W_PH using decoder 340
8134 // 9586: }
8135 7, 11, // 9591: case 0x7: {
8136 OPC_CheckPredicate, 37, // 9593: check predicate 37
8137 OPC_CheckField, 13, 3, 0, // 9595: check Inst[15:13] == 0x0
8138 OPC_Decode, 247, 11, 212, 2, // 9599: decode to DPAU_H_QBR using decoder 340
8139 // 9599: }
8140 8, 11, // 9604: case 0x8: {
8141 OPC_CheckPredicate, 71, // 9606: check predicate 71
8142 OPC_CheckField, 13, 3, 0, // 9608: check Inst[15:13] == 0x0
8143 OPC_Decode, 249, 11, 212, 2, // 9612: decode to DPAX_W_PH using decoder 340
8144 // 9612: }
8145 9, 11, // 9617: case 0x9: {
8146 OPC_CheckPredicate, 71, // 9619: check predicate 71
8147 OPC_CheckField, 13, 3, 0, // 9621: check Inst[15:13] == 0x0
8148 OPC_Decode, 144, 12, 212, 2, // 9625: decode to DPSX_W_PH using decoder 340
8149 // 9625: }
8150 11, 11, // 9630: case 0xb: {
8151 OPC_CheckPredicate, 37, // 9632: check predicate 37
8152 OPC_CheckField, 13, 3, 0, // 9634: check Inst[15:13] == 0x0
8153 OPC_Decode, 140, 12, 212, 2, // 9638: decode to DPSU_H_QBL using decoder 340
8154 // 9638: }
8155 12, 11, // 9643: case 0xc: {
8156 OPC_CheckPredicate, 37, // 9645: check predicate 37
8157 OPC_CheckField, 13, 3, 0, // 9647: check Inst[15:13] == 0x0
8158 OPC_Decode, 241, 11, 212, 2, // 9651: decode to DPAQ_SA_L_W using decoder 340
8159 // 9651: }
8160 13, 11, // 9656: case 0xd: {
8161 OPC_CheckPredicate, 37, // 9658: check predicate 37
8162 OPC_CheckField, 13, 3, 0, // 9660: check Inst[15:13] == 0x0
8163 OPC_Decode, 130, 12, 212, 2, // 9664: decode to DPSQ_SA_L_W using decoder 340
8164 // 9664: }
8165 15, 11, // 9669: case 0xf: {
8166 OPC_CheckPredicate, 37, // 9671: check predicate 37
8167 OPC_CheckField, 13, 3, 0, // 9673: check Inst[15:13] == 0x0
8168 OPC_Decode, 142, 12, 212, 2, // 9677: decode to DPSU_H_QBR using decoder 340
8169 // 9677: }
8170 16, 11, // 9682: case 0x10: {
8171 OPC_CheckPredicate, 37, // 9684: check predicate 37
8172 OPC_CheckField, 13, 3, 0, // 9686: check Inst[15:13] == 0x0
8173 OPC_Decode, 129, 16, 212, 2, // 9690: decode to MAQ_SA_W_PHL using decoder 340
8174 // 9690: }
8175 18, 11, // 9695: case 0x12: {
8176 OPC_CheckPredicate, 37, // 9697: check predicate 37
8177 OPC_CheckField, 13, 3, 0, // 9699: check Inst[15:13] == 0x0
8178 OPC_Decode, 131, 16, 212, 2, // 9703: decode to MAQ_SA_W_PHR using decoder 340
8179 // 9703: }
8180 20, 11, // 9708: case 0x14: {
8181 OPC_CheckPredicate, 37, // 9710: check predicate 37
8182 OPC_CheckField, 13, 3, 0, // 9712: check Inst[15:13] == 0x0
8183 OPC_Decode, 133, 16, 212, 2, // 9716: decode to MAQ_S_W_PHL using decoder 340
8184 // 9716: }
8185 22, 11, // 9721: case 0x16: {
8186 OPC_CheckPredicate, 37, // 9723: check predicate 37
8187 OPC_CheckField, 13, 3, 0, // 9725: check Inst[15:13] == 0x0
8188 OPC_Decode, 135, 16, 212, 2, // 9729: decode to MAQ_S_W_PHR using decoder 340
8189 // 9729: }
8190 24, 11, // 9734: case 0x18: {
8191 OPC_CheckPredicate, 71, // 9736: check predicate 71
8192 OPC_CheckField, 13, 3, 0, // 9738: check Inst[15:13] == 0x0
8193 OPC_Decode, 239, 11, 212, 2, // 9742: decode to DPAQX_S_W_PH using decoder 340
8194 // 9742: }
8195 25, 11, // 9747: case 0x19: {
8196 OPC_CheckPredicate, 71, // 9749: check predicate 71
8197 OPC_CheckField, 13, 3, 0, // 9751: check Inst[15:13] == 0x0
8198 OPC_Decode, 128, 12, 212, 2, // 9755: decode to DPSQX_S_W_PH using decoder 340
8199 // 9755: }
8200 26, 11, // 9760: case 0x1a: {
8201 OPC_CheckPredicate, 71, // 9762: check predicate 71
8202 OPC_CheckField, 13, 3, 0, // 9764: check Inst[15:13] == 0x0
8203 OPC_Decode, 237, 11, 212, 2, // 9768: decode to DPAQX_SA_W_PH using decoder 340
8204 // 9768: }
8205 27, 0, // 9773: case 0x1b: {
8206 OPC_CheckPredicate, 71, // 9775: check predicate 71
8207 OPC_CheckField, 13, 3, 0, // 9777: check Inst[15:13] == 0x0
8208 OPC_Decode, 254, 11, 212, 2, // 9781: decode to DPSQX_SA_W_PH using decoder 340
8209 // 9781: }
8210 // 9781: } // switch Inst[10:6]
8211 // 9781: }
8212 49, 30, // 9786: case 0x31: {
8213 OPC_SwitchField, 6, 5, // 9788: switch Inst[10:6] {
8214 0, 7, // 9791: case 0x0: {
8215 OPC_CheckPredicate, 71, // 9793: check predicate 71
8216 OPC_Decode, 247, 6, 213, 2, // 9795: decode to APPEND using decoder 341
8217 // 9795: }
8218 1, 7, // 9800: case 0x1: {
8219 OPC_CheckPredicate, 71, // 9802: check predicate 71
8220 OPC_Decode, 254, 18, 213, 2, // 9804: decode to PREPEND using decoder 341
8221 // 9804: }
8222 16, 0, // 9809: case 0x10: {
8223 OPC_CheckPredicate, 71, // 9811: check predicate 71
8224 OPC_Decode, 163, 7, 213, 2, // 9813: decode to BALIGN using decoder 341
8225 // 9813: }
8226 // 9813: } // switch Inst[10:6]
8227 // 9813: }
8228 56, 216, 1, // 9818: case 0x38: {
8229 OPC_SwitchField, 6, 5, // 9821: switch Inst[10:6] {
8230 0, 11, // 9824: case 0x0: {
8231 OPC_CheckPredicate, 37, // 9826: check predicate 37
8232 OPC_CheckField, 13, 3, 0, // 9828: check Inst[15:13] == 0x0
8233 OPC_Decode, 210, 12, 214, 2, // 9832: decode to EXTR_W using decoder 342
8234 // 9832: }
8235 1, 11, // 9837: case 0x1: {
8236 OPC_CheckPredicate, 37, // 9839: check predicate 37
8237 OPC_CheckField, 13, 3, 0, // 9841: check Inst[15:13] == 0x0
8238 OPC_Decode, 202, 12, 215, 2, // 9845: decode to EXTRV_W using decoder 343
8239 // 9845: }
8240 2, 11, // 9850: case 0x2: {
8241 OPC_CheckPredicate, 37, // 9852: check predicate 37
8242 OPC_CheckField, 13, 3, 0, // 9854: check Inst[15:13] == 0x0
8243 OPC_Decode, 188, 12, 214, 2, // 9858: decode to EXTP using decoder 342
8244 // 9858: }
8245 3, 11, // 9863: case 0x3: {
8246 OPC_CheckPredicate, 37, // 9865: check predicate 37
8247 OPC_CheckField, 13, 3, 0, // 9867: check Inst[15:13] == 0x0
8248 OPC_Decode, 193, 12, 215, 2, // 9871: decode to EXTPV using decoder 343
8249 // 9871: }
8250 4, 11, // 9876: case 0x4: {
8251 OPC_CheckPredicate, 37, // 9878: check predicate 37
8252 OPC_CheckField, 13, 3, 0, // 9880: check Inst[15:13] == 0x0
8253 OPC_Decode, 206, 12, 214, 2, // 9884: decode to EXTR_R_W using decoder 342
8254 // 9884: }
8255 5, 11, // 9889: case 0x5: {
8256 OPC_CheckPredicate, 37, // 9891: check predicate 37
8257 OPC_CheckField, 13, 3, 0, // 9893: check Inst[15:13] == 0x0
8258 OPC_Decode, 198, 12, 215, 2, // 9897: decode to EXTRV_R_W using decoder 343
8259 // 9897: }
8260 6, 11, // 9902: case 0x6: {
8261 OPC_CheckPredicate, 37, // 9904: check predicate 37
8262 OPC_CheckField, 13, 3, 0, // 9906: check Inst[15:13] == 0x0
8263 OPC_Decode, 204, 12, 214, 2, // 9910: decode to EXTR_RS_W using decoder 342
8264 // 9910: }
8265 7, 11, // 9915: case 0x7: {
8266 OPC_CheckPredicate, 37, // 9917: check predicate 37
8267 OPC_CheckField, 13, 3, 0, // 9919: check Inst[15:13] == 0x0
8268 OPC_Decode, 196, 12, 215, 2, // 9923: decode to EXTRV_RS_W using decoder 343
8269 // 9923: }
8270 10, 11, // 9928: case 0xa: {
8271 OPC_CheckPredicate, 37, // 9930: check predicate 37
8272 OPC_CheckField, 13, 3, 0, // 9932: check Inst[15:13] == 0x0
8273 OPC_Decode, 189, 12, 214, 2, // 9936: decode to EXTPDP using decoder 342
8274 // 9936: }
8275 11, 11, // 9941: case 0xb: {
8276 OPC_CheckPredicate, 37, // 9943: check predicate 37
8277 OPC_CheckField, 13, 3, 0, // 9945: check Inst[15:13] == 0x0
8278 OPC_Decode, 190, 12, 215, 2, // 9949: decode to EXTPDPV using decoder 343
8279 // 9949: }
8280 14, 11, // 9954: case 0xe: {
8281 OPC_CheckPredicate, 37, // 9956: check predicate 37
8282 OPC_CheckField, 13, 3, 0, // 9958: check Inst[15:13] == 0x0
8283 OPC_Decode, 208, 12, 214, 2, // 9962: decode to EXTR_S_H using decoder 342
8284 // 9962: }
8285 15, 11, // 9967: case 0xf: {
8286 OPC_CheckPredicate, 37, // 9969: check predicate 37
8287 OPC_CheckField, 13, 3, 0, // 9971: check Inst[15:13] == 0x0
8288 OPC_Decode, 200, 12, 215, 2, // 9975: decode to EXTRV_S_H using decoder 343
8289 // 9975: }
8290 18, 7, // 9980: case 0x12: {
8291 OPC_CheckPredicate, 37, // 9982: check predicate 37
8292 OPC_Decode, 132, 19, 216, 2, // 9984: decode to RDDSP using decoder 344
8293 // 9984: }
8294 19, 7, // 9989: case 0x13: {
8295 OPC_CheckPredicate, 40, // 9991: check predicate 40
8296 OPC_Decode, 224, 22, 217, 2, // 9993: decode to WRDSP using decoder 345
8297 // 9993: }
8298 26, 11, // 9998: case 0x1a: {
8299 OPC_CheckPredicate, 37, // 10000: check predicate 37
8300 OPC_CheckField, 13, 7, 0, // 10002: check Inst[19:13] == 0x0
8301 OPC_Decode, 137, 20, 218, 2, // 10006: decode to SHILO using decoder 346
8302 // 10006: }
8303 27, 11, // 10011: case 0x1b: {
8304 OPC_CheckPredicate, 37, // 10013: check predicate 37
8305 OPC_CheckField, 13, 8, 0, // 10015: check Inst[20:13] == 0x0
8306 OPC_Decode, 138, 20, 219, 2, // 10019: decode to SHILOV using decoder 347
8307 // 10019: }
8308 31, 0, // 10024: case 0x1f: {
8309 OPC_CheckPredicate, 37, // 10026: check predicate 37
8310 OPC_CheckField, 13, 8, 0, // 10028: check Inst[20:13] == 0x0
8311 OPC_Decode, 206, 17, 219, 2, // 10032: decode to MTHLIP using decoder 347
8312 // 10032: }
8313 // 10032: } // switch Inst[10:6]
8314 // 10032: }
8315 59, 0, // 10037: case 0x3b: {
8316 OPC_CheckPredicate, 27, // 10039: check predicate 27
8317 OPC_CheckField, 21, 5, 0, // 10041: check Inst[25:21] == 0x0
8318 OPC_CheckField, 9, 2, 0, // 10045: check Inst[10:9] == 0x0
8319 OPC_Decode, 134, 19, 220, 2, // 10049: decode to RDHWR using decoder 348
8320 // 10049: }
8321 // 10049: } // switch Inst[5:0]
8322 // 10049: }
8323 32, 7, // 10054: case 0x20: {
8324 OPC_CheckPredicate, 27, // 10056: check predicate 27
8325 OPC_Decode, 232, 14, 148, 1, // 10058: decode to LB using decoder 148
8326 // 10058: }
8327 33, 7, // 10063: case 0x21: {
8328 OPC_CheckPredicate, 27, // 10065: check predicate 27
8329 OPC_Decode, 145, 15, 148, 1, // 10067: decode to LH using decoder 148
8330 // 10067: }
8331 34, 7, // 10072: case 0x22: {
8332 OPC_CheckPredicate, 31, // 10074: check predicate 31
8333 OPC_Decode, 194, 15, 148, 1, // 10076: decode to LWL using decoder 148
8334 // 10076: }
8335 35, 7, // 10081: case 0x23: {
8336 OPC_CheckPredicate, 27, // 10083: check predicate 27
8337 OPC_Decode, 180, 15, 148, 1, // 10085: decode to LW using decoder 148
8338 // 10085: }
8339 36, 7, // 10090: case 0x24: {
8340 OPC_CheckPredicate, 27, // 10092: check predicate 27
8341 OPC_Decode, 242, 14, 148, 1, // 10094: decode to LBu using decoder 148
8342 // 10094: }
8343 37, 7, // 10099: case 0x25: {
8344 OPC_CheckPredicate, 27, // 10101: check predicate 27
8345 OPC_Decode, 153, 15, 148, 1, // 10103: decode to LHu using decoder 148
8346 // 10103: }
8347 38, 7, // 10108: case 0x26: {
8348 OPC_CheckPredicate, 31, // 10110: check predicate 31
8349 OPC_Decode, 205, 15, 148, 1, // 10112: decode to LWR using decoder 148
8350 // 10112: }
8351 40, 7, // 10117: case 0x28: {
8352 OPC_CheckPredicate, 27, // 10119: check predicate 27
8353 OPC_Decode, 190, 19, 148, 1, // 10121: decode to SB using decoder 148
8354 // 10121: }
8355 41, 7, // 10126: case 0x29: {
8356 OPC_CheckPredicate, 27, // 10128: check predicate 27
8357 OPC_Decode, 128, 20, 148, 1, // 10130: decode to SH using decoder 148
8358 // 10130: }
8359 42, 7, // 10135: case 0x2a: {
8360 OPC_CheckPredicate, 31, // 10137: check predicate 31
8361 OPC_Decode, 232, 21, 148, 1, // 10139: decode to SWL using decoder 148
8362 // 10139: }
8363 43, 7, // 10144: case 0x2b: {
8364 OPC_CheckPredicate, 27, // 10146: check predicate 27
8365 OPC_Decode, 218, 21, 148, 1, // 10148: decode to SW using decoder 148
8366 // 10148: }
8367 46, 7, // 10153: case 0x2e: {
8368 OPC_CheckPredicate, 31, // 10155: check predicate 31
8369 OPC_Decode, 241, 21, 148, 1, // 10157: decode to SWR using decoder 148
8370 // 10157: }
8371 47, 7, // 10162: case 0x2f: {
8372 OPC_CheckPredicate, 73, // 10164: check predicate 73
8373 OPC_Decode, 227, 8, 221, 2, // 10166: decode to CACHE using decoder 349
8374 // 10166: }
8375 48, 7, // 10171: case 0x30: {
8376 OPC_CheckPredicate, 74, // 10173: check predicate 74
8377 OPC_Decode, 160, 15, 148, 1, // 10175: decode to LL using decoder 148
8378 // 10175: }
8379 49, 7, // 10180: case 0x31: {
8380 OPC_CheckPredicate, 47, // 10182: check predicate 47
8381 OPC_Decode, 183, 15, 222, 2, // 10184: decode to LWC1 using decoder 350
8382 // 10184: }
8383 50, 7, // 10189: case 0x32: {
8384 OPC_CheckPredicate, 31, // 10191: check predicate 31
8385 OPC_Decode, 185, 15, 223, 2, // 10193: decode to LWC2 using decoder 351
8386 // 10193: }
8387 51, 7, // 10198: case 0x33: {
8388 OPC_CheckPredicate, 73, // 10200: check predicate 73
8389 OPC_Decode, 247, 18, 221, 2, // 10202: decode to PREF using decoder 349
8390 // 10202: }
8391 53, 7, // 10207: case 0x35: {
8392 OPC_CheckPredicate, 59, // 10209: check predicate 59
8393 OPC_Decode, 248, 14, 222, 2, // 10211: decode to LDC1 using decoder 350
8394 // 10211: }
8395 54, 7, // 10216: case 0x36: {
8396 OPC_CheckPredicate, 39, // 10218: check predicate 39
8397 OPC_Decode, 253, 14, 223, 2, // 10220: decode to LDC2 using decoder 351
8398 // 10220: }
8399 56, 7, // 10225: case 0x38: {
8400 OPC_CheckPredicate, 74, // 10227: check predicate 74
8401 OPC_Decode, 198, 19, 148, 1, // 10229: decode to SC using decoder 148
8402 // 10229: }
8403 57, 7, // 10234: case 0x39: {
8404 OPC_CheckPredicate, 47, // 10236: check predicate 47
8405 OPC_Decode, 222, 21, 222, 2, // 10238: decode to SWC1 using decoder 350
8406 // 10238: }
8407 58, 7, // 10243: case 0x3a: {
8408 OPC_CheckPredicate, 31, // 10245: check predicate 31
8409 OPC_Decode, 224, 21, 223, 2, // 10247: decode to SWC2 using decoder 351
8410 // 10247: }
8411 61, 7, // 10252: case 0x3d: {
8412 OPC_CheckPredicate, 59, // 10254: check predicate 59
8413 OPC_Decode, 215, 19, 222, 2, // 10256: decode to SDC1 using decoder 350
8414 // 10256: }
8415 62, 0, // 10261: case 0x3e: {
8416 OPC_CheckPredicate, 39, // 10263: check predicate 39
8417 OPC_Decode, 220, 19, 223, 2, // 10265: decode to SDC2 using decoder 351
8418 // 10265: }
8419 // 10265: } // switch Inst[31:26]
8420};
8421static const uint8_t DecoderTableMips32_64_PTR6432[33] = {
8422 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
8423 0, 10, // 3: case 0x0: {
8424 OPC_CheckPredicate, 75, // 5: check predicate 75
8425 OPC_CheckField, 0, 21, 8, // 7: check Inst[20:0] == 0x8
8426 OPC_Decode, 214, 14, 51, // 11: decode to JR64 using decoder 51
8427 // 11: }
8428 48, 7, // 15: case 0x30: {
8429 OPC_CheckPredicate, 76, // 17: check predicate 76
8430 OPC_Decode, 161, 15, 148, 1, // 19: decode to LL64 using decoder 148
8431 // 19: }
8432 56, 0, // 24: case 0x38: {
8433 OPC_CheckPredicate, 76, // 26: check predicate 76
8434 OPC_Decode, 199, 19, 148, 1, // 28: decode to SC64 using decoder 148
8435 // 28: }
8436 // 28: } // switch Inst[31:26]
8437};
8438static const uint8_t DecoderTableMips32r6_64r632[1496] = {
8439 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
8440 0, 179, 2, // 3: case 0x0: {
8441 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
8442 5, 11, // 9: case 0x5: {
8443 OPC_CheckPredicate, 77, // 11: check predicate 77
8444 OPC_CheckField, 8, 3, 0, // 13: check Inst[10:8] == 0x0
8445 OPC_Decode, 172, 15, 187, 1, // 17: decode to LSA_R6 using decoder 187
8446 // 17: }
8447 9, 11, // 22: case 0x9: {
8448 OPC_CheckPredicate, 77, // 24: check predicate 77
8449 OPC_CheckField, 6, 15, 16, // 26: check Inst[20:6] == 0x10
8450 OPC_Decode, 223, 14, 188, 1, // 30: decode to JR_HB_R6 using decoder 188
8451 // 30: }
8452 14, 7, // 35: case 0xe: {
8453 OPC_CheckPredicate, 78, // 37: check predicate 78
8454 OPC_Decode, 214, 19, 190, 1, // 39: decode to SDBBP_R6 using decoder 190
8455 // 39: }
8456 16, 14, // 44: case 0x10: {
8457 OPC_CheckPredicate, 77, // 46: check predicate 77
8458 OPC_CheckField, 16, 5, 0, // 48: check Inst[20:16] == 0x0
8459 OPC_CheckField, 6, 5, 1, // 52: check Inst[10:6] == 0x1
8460 OPC_Decode, 175, 9, 52, // 56: decode to CLZ_R6 using decoder 52
8461 // 56: }
8462 17, 14, // 60: case 0x11: {
8463 OPC_CheckPredicate, 77, // 62: check predicate 77
8464 OPC_CheckField, 16, 5, 0, // 64: check Inst[20:16] == 0x0
8465 OPC_CheckField, 6, 5, 1, // 68: check Inst[10:6] == 0x1
8466 OPC_Decode, 155, 9, 52, // 72: decode to CLO_R6 using decoder 52
8467 // 72: }
8468 18, 14, // 76: case 0x12: {
8469 OPC_CheckPredicate, 79, // 78: check predicate 79
8470 OPC_CheckField, 16, 5, 0, // 80: check Inst[20:16] == 0x0
8471 OPC_CheckField, 6, 5, 1, // 84: check Inst[10:6] == 0x1
8472 OPC_Decode, 175, 11, 53, // 88: decode to DCLZ_R6 using decoder 53
8473 // 88: }
8474 19, 14, // 92: case 0x13: {
8475 OPC_CheckPredicate, 79, // 94: check predicate 79
8476 OPC_CheckField, 16, 5, 0, // 96: check Inst[20:16] == 0x0
8477 OPC_CheckField, 6, 5, 1, // 100: check Inst[10:6] == 0x1
8478 OPC_Decode, 173, 11, 53, // 104: decode to DCLO_R6 using decoder 53
8479 // 104: }
8480 21, 11, // 108: case 0x15: {
8481 OPC_CheckPredicate, 79, // 110: check predicate 79
8482 OPC_CheckField, 8, 3, 0, // 112: check Inst[10:8] == 0x0
8483 OPC_Decode, 204, 11, 196, 1, // 116: decode to DLSA_R6 using decoder 196
8484 // 116: }
8485 24, 19, // 121: case 0x18: {
8486 OPC_SwitchField, 6, 5, // 123: switch Inst[10:6] {
8487 2, 6, // 126: case 0x2: {
8488 OPC_CheckPredicate, 78, // 128: check predicate 78
8489 OPC_Decode, 140, 18, 67, // 130: decode to MUL_R6 using decoder 67
8490 // 130: }
8491 3, 0, // 134: case 0x3: {
8492 OPC_CheckPredicate, 78, // 136: check predicate 78
8493 OPC_Decode, 220, 17, 67, // 138: decode to MUH using decoder 67
8494 // 138: }
8495 // 138: } // switch Inst[10:6]
8496 // 138: }
8497 25, 19, // 142: case 0x19: {
8498 OPC_SwitchField, 6, 5, // 144: switch Inst[10:6] {
8499 2, 6, // 147: case 0x2: {
8500 OPC_CheckPredicate, 78, // 149: check predicate 78
8501 OPC_Decode, 128, 18, 67, // 151: decode to MULU using decoder 67
8502 // 151: }
8503 3, 0, // 155: case 0x3: {
8504 OPC_CheckPredicate, 78, // 157: check predicate 78
8505 OPC_Decode, 221, 17, 67, // 159: decode to MUHU using decoder 67
8506 // 159: }
8507 // 159: } // switch Inst[10:6]
8508 // 159: }
8509 26, 19, // 163: case 0x1a: {
8510 OPC_SwitchField, 6, 5, // 165: switch Inst[10:6] {
8511 2, 6, // 168: case 0x2: {
8512 OPC_CheckPredicate, 78, // 170: check predicate 78
8513 OPC_Decode, 189, 11, 67, // 172: decode to DIV using decoder 67
8514 // 172: }
8515 3, 0, // 176: case 0x3: {
8516 OPC_CheckPredicate, 78, // 178: check predicate 78
8517 OPC_Decode, 225, 16, 67, // 180: decode to MOD using decoder 67
8518 // 180: }
8519 // 180: } // switch Inst[10:6]
8520 // 180: }
8521 27, 19, // 184: case 0x1b: {
8522 OPC_SwitchField, 6, 5, // 186: switch Inst[10:6] {
8523 2, 6, // 189: case 0x2: {
8524 OPC_CheckPredicate, 78, // 191: check predicate 78
8525 OPC_Decode, 190, 11, 67, // 193: decode to DIVU using decoder 67
8526 // 193: }
8527 3, 0, // 197: case 0x3: {
8528 OPC_CheckPredicate, 78, // 199: check predicate 78
8529 OPC_Decode, 228, 16, 67, // 201: decode to MODU using decoder 67
8530 // 201: }
8531 // 201: } // switch Inst[10:6]
8532 // 201: }
8533 28, 19, // 205: case 0x1c: {
8534 OPC_SwitchField, 6, 5, // 207: switch Inst[10:6] {
8535 2, 6, // 210: case 0x2: {
8536 OPC_CheckPredicate, 79, // 212: check predicate 79
8537 OPC_Decode, 224, 11, 50, // 214: decode to DMUL_R6 using decoder 50
8538 // 214: }
8539 3, 0, // 218: case 0x3: {
8540 OPC_CheckPredicate, 79, // 220: check predicate 79
8541 OPC_Decode, 218, 11, 50, // 222: decode to DMUH using decoder 50
8542 // 222: }
8543 // 222: } // switch Inst[10:6]
8544 // 222: }
8545 29, 19, // 226: case 0x1d: {
8546 OPC_SwitchField, 6, 5, // 228: switch Inst[10:6] {
8547 2, 6, // 231: case 0x2: {
8548 OPC_CheckPredicate, 79, // 233: check predicate 79
8549 OPC_Decode, 223, 11, 50, // 235: decode to DMULU using decoder 50
8550 // 235: }
8551 3, 0, // 239: case 0x3: {
8552 OPC_CheckPredicate, 79, // 241: check predicate 79
8553 OPC_Decode, 219, 11, 50, // 243: decode to DMUHU using decoder 50
8554 // 243: }
8555 // 243: } // switch Inst[10:6]
8556 // 243: }
8557 30, 19, // 247: case 0x1e: {
8558 OPC_SwitchField, 6, 5, // 249: switch Inst[10:6] {
8559 2, 6, // 252: case 0x2: {
8560 OPC_CheckPredicate, 79, // 254: check predicate 79
8561 OPC_Decode, 176, 11, 50, // 256: decode to DDIV using decoder 50
8562 // 256: }
8563 3, 0, // 260: case 0x3: {
8564 OPC_CheckPredicate, 79, // 262: check predicate 79
8565 OPC_Decode, 210, 11, 50, // 264: decode to DMOD using decoder 50
8566 // 264: }
8567 // 264: } // switch Inst[10:6]
8568 // 264: }
8569 31, 19, // 268: case 0x1f: {
8570 OPC_SwitchField, 6, 5, // 270: switch Inst[10:6] {
8571 2, 6, // 273: case 0x2: {
8572 OPC_CheckPredicate, 79, // 275: check predicate 79
8573 OPC_Decode, 177, 11, 50, // 277: decode to DDIVU using decoder 50
8574 // 277: }
8575 3, 0, // 281: case 0x3: {
8576 OPC_CheckPredicate, 79, // 283: check predicate 79
8577 OPC_Decode, 211, 11, 50, // 285: decode to DMODU using decoder 50
8578 // 285: }
8579 // 285: } // switch Inst[10:6]
8580 // 285: }
8581 53, 10, // 289: case 0x35: {
8582 OPC_CheckPredicate, 80, // 291: check predicate 80
8583 OPC_CheckField, 6, 5, 0, // 293: check Inst[10:6] == 0x0
8584 OPC_Decode, 236, 19, 67, // 297: decode to SELEQZ using decoder 67
8585 // 297: }
8586 55, 0, // 301: case 0x37: {
8587 OPC_CheckPredicate, 80, // 303: check predicate 80
8588 OPC_CheckField, 6, 5, 0, // 305: check Inst[10:6] == 0x0
8589 OPC_Decode, 243, 19, 67, // 309: decode to SELNEZ using decoder 67
8590 // 309: }
8591 // 309: } // switch Inst[5:0]
8592 // 309: }
8593 1, 63, // 313: case 0x1: {
8594 OPC_SwitchField, 16, 5, // 315: switch Inst[20:16] {
8595 6, 7, // 318: case 0x6: {
8596 OPC_CheckPredicate, 79, // 320: check predicate 79
8597 OPC_Decode, 167, 11, 224, 2, // 322: decode to DAHI using decoder 352
8598 // 322: }
8599 16, 14, // 327: case 0x10: {
8600 OPC_CheckPredicate, 77, // 329: check predicate 77
8601 OPC_CheckField, 21, 5, 0, // 331: check Inst[25:21] == 0x0
8602 OPC_CheckField, 0, 16, 0, // 335: check Inst[15:0] == 0x0
8603 OPC_Decode, 147, 18, 10, // 339: decode to NAL using decoder 10
8604 // 339: }
8605 17, 11, // 343: case 0x11: {
8606 OPC_CheckPredicate, 77, // 345: check predicate 77
8607 OPC_CheckField, 21, 5, 0, // 347: check Inst[25:21] == 0x0
8608 OPC_Decode, 160, 7, 200, 1, // 351: decode to BAL using decoder 200
8609 // 351: }
8610 23, 11, // 356: case 0x17: {
8611 OPC_CheckPredicate, 78, // 358: check predicate 78
8612 OPC_CheckField, 21, 5, 0, // 360: check Inst[25:21] == 0x0
8613 OPC_Decode, 187, 20, 225, 2, // 364: decode to SIGRIE using decoder 353
8614 // 364: }
8615 30, 0, // 369: case 0x1e: {
8616 OPC_CheckPredicate, 79, // 371: check predicate 79
8617 OPC_Decode, 169, 11, 224, 2, // 373: decode to DATI using decoder 352
8618 // 373: }
8619 // 373: } // switch Inst[20:16]
8620 // 373: }
8621 6, 7, // 378: case 0x6: {
8622 OPC_CheckPredicate, 78, // 380: check predicate 78
8623 OPC_Decode, 218, 7, 226, 2, // 382: decode to BGEZALC using decoder 354
8624 // 382: }
8625 7, 7, // 387: case 0x7: {
8626 OPC_CheckPredicate, 78, // 389: check predicate 78
8627 OPC_Decode, 147, 8, 227, 2, // 391: decode to BLTZALC using decoder 355
8628 // 391: }
8629 8, 7, // 396: case 0x8: {
8630 OPC_CheckPredicate, 78, // 398: check predicate 78
8631 OPC_Decode, 196, 7, 228, 2, // 400: decode to BEQC using decoder 356
8632 // 400: }
8633 15, 7, // 405: case 0xf: {
8634 OPC_CheckPredicate, 77, // 407: check predicate 77
8635 OPC_Decode, 129, 7, 205, 1, // 409: decode to AUI using decoder 205
8636 // 409: }
8637 16, 27, // 414: case 0x10: {
8638 OPC_SwitchField, 0, 16, // 416: switch Inst[15:0] {
8639 4, 10, // 419: case 0x4: {
8640 OPC_CheckPredicate, 77, // 421: check predicate 77
8641 OPC_CheckField, 21, 5, 11, // 423: check Inst[25:21] == 0xb
8642 OPC_Decode, 184, 12, 99, // 427: decode to EVP using decoder 99
8643 // 427: }
8644 36, 0, // 431: case 0x24: {
8645 OPC_CheckPredicate, 77, // 433: check predicate 77
8646 OPC_CheckField, 21, 5, 11, // 435: check Inst[25:21] == 0xb
8647 OPC_Decode, 167, 12, 99, // 439: decode to DVP using decoder 99
8648 // 439: }
8649 // 439: } // switch Inst[15:0]
8650 // 439: }
8651 17, 160, 4, // 443: case 0x11: {
8652 OPC_SwitchField, 21, 5, // 446: switch Inst[25:21] {
8653 9, 7, // 449: case 0x9: {
8654 OPC_CheckPredicate, 81, // 451: check predicate 81
8655 OPC_Decode, 171, 7, 229, 2, // 453: decode to BC1EQZ using decoder 357
8656 // 453: }
8657 13, 7, // 458: case 0xd: {
8658 OPC_CheckPredicate, 81, // 460: check predicate 81
8659 OPC_Decode, 176, 7, 229, 2, // 462: decode to BC1NEZ using decoder 357
8660 // 462: }
8661 16, 110, // 467: case 0x10: {
8662 OPC_SwitchField, 0, 6, // 469: switch Inst[5:0] {
8663 16, 7, // 472: case 0x10: {
8664 OPC_CheckPredicate, 81, // 474: check predicate 81
8665 OPC_Decode, 252, 19, 230, 2, // 476: decode to SEL_S using decoder 358
8666 // 476: }
8667 20, 7, // 481: case 0x14: {
8668 OPC_CheckPredicate, 81, // 483: check predicate 81
8669 OPC_Decode, 241, 19, 220, 1, // 485: decode to SELEQZ_S using decoder 220
8670 // 485: }
8671 23, 7, // 490: case 0x17: {
8672 OPC_CheckPredicate, 81, // 492: check predicate 81
8673 OPC_Decode, 248, 19, 220, 1, // 494: decode to SELNEZ_S using decoder 220
8674 // 494: }
8675 24, 7, // 499: case 0x18: {
8676 OPC_CheckPredicate, 81, // 501: check predicate 81
8677 OPC_Decode, 235, 15, 231, 2, // 503: decode to MADDF_S using decoder 359
8678 // 503: }
8679 25, 7, // 508: case 0x19: {
8680 OPC_CheckPredicate, 81, // 510: check predicate 81
8681 OPC_Decode, 159, 17, 231, 2, // 512: decode to MSUBF_S using decoder 359
8682 // 512: }
8683 26, 11, // 517: case 0x1a: {
8684 OPC_CheckPredicate, 81, // 519: check predicate 81
8685 OPC_CheckField, 16, 5, 0, // 521: check Inst[20:16] == 0x0
8686 OPC_Decode, 155, 19, 221, 1, // 525: decode to RINT_S using decoder 221
8687 // 525: }
8688 27, 11, // 530: case 0x1b: {
8689 OPC_CheckPredicate, 81, // 532: check predicate 81
8690 OPC_CheckField, 16, 5, 0, // 534: check Inst[20:16] == 0x0
8691 OPC_Decode, 134, 9, 221, 1, // 538: decode to CLASS_S using decoder 221
8692 // 538: }
8693 28, 7, // 543: case 0x1c: {
8694 OPC_CheckPredicate, 81, // 545: check predicate 81
8695 OPC_Decode, 215, 16, 220, 1, // 547: decode to MIN_S using decoder 220
8696 // 547: }
8697 29, 7, // 552: case 0x1d: {
8698 OPC_CheckPredicate, 81, // 554: check predicate 81
8699 OPC_Decode, 199, 16, 220, 1, // 556: decode to MINA_S using decoder 220
8700 // 556: }
8701 30, 7, // 561: case 0x1e: {
8702 OPC_CheckPredicate, 81, // 563: check predicate 81
8703 OPC_Decode, 155, 16, 220, 1, // 565: decode to MAX_S using decoder 220
8704 // 565: }
8705 31, 0, // 570: case 0x1f: {
8706 OPC_CheckPredicate, 81, // 572: check predicate 81
8707 OPC_Decode, 139, 16, 220, 1, // 574: decode to MAXA_S using decoder 220
8708 // 574: }
8709 // 574: } // switch Inst[5:0]
8710 // 574: }
8711 17, 110, // 579: case 0x11: {
8712 OPC_SwitchField, 0, 6, // 581: switch Inst[5:0] {
8713 16, 7, // 584: case 0x10: {
8714 OPC_CheckPredicate, 81, // 586: check predicate 81
8715 OPC_Decode, 250, 19, 232, 2, // 588: decode to SEL_D using decoder 360
8716 // 588: }
8717 20, 7, // 593: case 0x14: {
8718 OPC_CheckPredicate, 81, // 595: check predicate 81
8719 OPC_Decode, 238, 19, 233, 2, // 597: decode to SELEQZ_D using decoder 361
8720 // 597: }
8721 23, 7, // 602: case 0x17: {
8722 OPC_CheckPredicate, 81, // 604: check predicate 81
8723 OPC_Decode, 245, 19, 233, 2, // 606: decode to SELNEZ_D using decoder 361
8724 // 606: }
8725 24, 7, // 611: case 0x18: {
8726 OPC_CheckPredicate, 81, // 613: check predicate 81
8727 OPC_Decode, 233, 15, 234, 2, // 615: decode to MADDF_D using decoder 362
8728 // 615: }
8729 25, 7, // 620: case 0x19: {
8730 OPC_CheckPredicate, 81, // 622: check predicate 81
8731 OPC_Decode, 157, 17, 234, 2, // 624: decode to MSUBF_D using decoder 362
8732 // 624: }
8733 26, 11, // 629: case 0x1a: {
8734 OPC_CheckPredicate, 81, // 631: check predicate 81
8735 OPC_CheckField, 16, 5, 0, // 633: check Inst[20:16] == 0x0
8736 OPC_Decode, 153, 19, 232, 1, // 637: decode to RINT_D using decoder 232
8737 // 637: }
8738 27, 11, // 642: case 0x1b: {
8739 OPC_CheckPredicate, 81, // 644: check predicate 81
8740 OPC_CheckField, 16, 5, 0, // 646: check Inst[20:16] == 0x0
8741 OPC_Decode, 132, 9, 232, 1, // 650: decode to CLASS_D using decoder 232
8742 // 650: }
8743 28, 7, // 655: case 0x1c: {
8744 OPC_CheckPredicate, 81, // 657: check predicate 81
8745 OPC_Decode, 213, 16, 233, 2, // 659: decode to MIN_D using decoder 361
8746 // 659: }
8747 29, 7, // 664: case 0x1d: {
8748 OPC_CheckPredicate, 81, // 666: check predicate 81
8749 OPC_Decode, 197, 16, 233, 2, // 668: decode to MINA_D using decoder 361
8750 // 668: }
8751 30, 7, // 673: case 0x1e: {
8752 OPC_CheckPredicate, 81, // 675: check predicate 81
8753 OPC_Decode, 153, 16, 233, 2, // 677: decode to MAX_D using decoder 361
8754 // 677: }
8755 31, 0, // 682: case 0x1f: {
8756 OPC_CheckPredicate, 81, // 684: check predicate 81
8757 OPC_Decode, 137, 16, 233, 2, // 686: decode to MAXA_D using decoder 361
8758 // 686: }
8759 // 686: } // switch Inst[5:0]
8760 // 686: }
8761 20, 147, 1, // 691: case 0x14: {
8762 OPC_SwitchField, 0, 6, // 694: switch Inst[5:0] {
8763 0, 7, // 697: case 0x0: {
8764 OPC_CheckPredicate, 81, // 699: check predicate 81
8765 OPC_Decode, 203, 9, 235, 2, // 701: decode to CMP_F_S using decoder 363
8766 // 701: }
8767 1, 7, // 706: case 0x1: {
8768 OPC_CheckPredicate, 81, // 708: check predicate 81
8769 OPC_Decode, 134, 10, 235, 2, // 710: decode to CMP_UN_S using decoder 363
8770 // 710: }
8771 2, 7, // 715: case 0x2: {
8772 OPC_CheckPredicate, 81, // 717: check predicate 81
8773 OPC_Decode, 200, 9, 235, 2, // 719: decode to CMP_EQ_S using decoder 363
8774 // 719: }
8775 3, 7, // 724: case 0x3: {
8776 OPC_CheckPredicate, 81, // 726: check predicate 81
8777 OPC_Decode, 250, 9, 235, 2, // 728: decode to CMP_UEQ_S using decoder 363
8778 // 728: }
8779 4, 7, // 733: case 0x4: {
8780 OPC_CheckPredicate, 81, // 735: check predicate 81
8781 OPC_Decode, 214, 9, 235, 2, // 737: decode to CMP_LT_S using decoder 363
8782 // 737: }
8783 5, 7, // 742: case 0x5: {
8784 OPC_CheckPredicate, 81, // 744: check predicate 81
8785 OPC_Decode, 130, 10, 235, 2, // 746: decode to CMP_ULT_S using decoder 363
8786 // 746: }
8787 6, 7, // 751: case 0x6: {
8788 OPC_CheckPredicate, 81, // 753: check predicate 81
8789 OPC_Decode, 208, 9, 235, 2, // 755: decode to CMP_LE_S using decoder 363
8790 // 755: }
8791 7, 7, // 760: case 0x7: {
8792 OPC_CheckPredicate, 81, // 762: check predicate 81
8793 OPC_Decode, 254, 9, 235, 2, // 764: decode to CMP_ULE_S using decoder 363
8794 // 764: }
8795 8, 7, // 769: case 0x8: {
8796 OPC_CheckPredicate, 81, // 771: check predicate 81
8797 OPC_Decode, 218, 9, 235, 2, // 773: decode to CMP_SAF_S using decoder 363
8798 // 773: }
8799 9, 7, // 778: case 0x9: {
8800 OPC_CheckPredicate, 81, // 780: check predicate 81
8801 OPC_Decode, 246, 9, 235, 2, // 782: decode to CMP_SUN_S using decoder 363
8802 // 782: }
8803 10, 7, // 787: case 0xa: {
8804 OPC_CheckPredicate, 81, // 789: check predicate 81
8805 OPC_Decode, 222, 9, 235, 2, // 791: decode to CMP_SEQ_S using decoder 363
8806 // 791: }
8807 11, 7, // 796: case 0xb: {
8808 OPC_CheckPredicate, 81, // 798: check predicate 81
8809 OPC_Decode, 234, 9, 235, 2, // 800: decode to CMP_SUEQ_S using decoder 363
8810 // 800: }
8811 12, 7, // 805: case 0xc: {
8812 OPC_CheckPredicate, 81, // 807: check predicate 81
8813 OPC_Decode, 230, 9, 235, 2, // 809: decode to CMP_SLT_S using decoder 363
8814 // 809: }
8815 13, 7, // 814: case 0xd: {
8816 OPC_CheckPredicate, 81, // 816: check predicate 81
8817 OPC_Decode, 242, 9, 235, 2, // 818: decode to CMP_SULT_S using decoder 363
8818 // 818: }
8819 14, 7, // 823: case 0xe: {
8820 OPC_CheckPredicate, 81, // 825: check predicate 81
8821 OPC_Decode, 226, 9, 235, 2, // 827: decode to CMP_SLE_S using decoder 363
8822 // 827: }
8823 15, 0, // 832: case 0xf: {
8824 OPC_CheckPredicate, 81, // 834: check predicate 81
8825 OPC_Decode, 238, 9, 235, 2, // 836: decode to CMP_SULE_S using decoder 363
8826 // 836: }
8827 // 836: } // switch Inst[5:0]
8828 // 836: }
8829 21, 0, // 841: case 0x15: {
8830 OPC_SwitchField, 0, 6, // 843: switch Inst[5:0] {
8831 0, 7, // 846: case 0x0: {
8832 OPC_CheckPredicate, 81, // 848: check predicate 81
8833 OPC_Decode, 202, 9, 236, 2, // 850: decode to CMP_F_D using decoder 364
8834 // 850: }
8835 1, 7, // 855: case 0x1: {
8836 OPC_CheckPredicate, 81, // 857: check predicate 81
8837 OPC_Decode, 132, 10, 236, 2, // 859: decode to CMP_UN_D using decoder 364
8838 // 859: }
8839 2, 7, // 864: case 0x2: {
8840 OPC_CheckPredicate, 81, // 866: check predicate 81
8841 OPC_Decode, 196, 9, 236, 2, // 868: decode to CMP_EQ_D using decoder 364
8842 // 868: }
8843 3, 7, // 873: case 0x3: {
8844 OPC_CheckPredicate, 81, // 875: check predicate 81
8845 OPC_Decode, 248, 9, 236, 2, // 877: decode to CMP_UEQ_D using decoder 364
8846 // 877: }
8847 4, 7, // 882: case 0x4: {
8848 OPC_CheckPredicate, 81, // 884: check predicate 81
8849 OPC_Decode, 210, 9, 236, 2, // 886: decode to CMP_LT_D using decoder 364
8850 // 886: }
8851 5, 7, // 891: case 0x5: {
8852 OPC_CheckPredicate, 81, // 893: check predicate 81
8853 OPC_Decode, 128, 10, 236, 2, // 895: decode to CMP_ULT_D using decoder 364
8854 // 895: }
8855 6, 7, // 900: case 0x6: {
8856 OPC_CheckPredicate, 81, // 902: check predicate 81
8857 OPC_Decode, 204, 9, 236, 2, // 904: decode to CMP_LE_D using decoder 364
8858 // 904: }
8859 7, 7, // 909: case 0x7: {
8860 OPC_CheckPredicate, 81, // 911: check predicate 81
8861 OPC_Decode, 252, 9, 236, 2, // 913: decode to CMP_ULE_D using decoder 364
8862 // 913: }
8863 8, 7, // 918: case 0x8: {
8864 OPC_CheckPredicate, 81, // 920: check predicate 81
8865 OPC_Decode, 216, 9, 236, 2, // 922: decode to CMP_SAF_D using decoder 364
8866 // 922: }
8867 9, 7, // 927: case 0x9: {
8868 OPC_CheckPredicate, 81, // 929: check predicate 81
8869 OPC_Decode, 244, 9, 236, 2, // 931: decode to CMP_SUN_D using decoder 364
8870 // 931: }
8871 10, 7, // 936: case 0xa: {
8872 OPC_CheckPredicate, 81, // 938: check predicate 81
8873 OPC_Decode, 220, 9, 236, 2, // 940: decode to CMP_SEQ_D using decoder 364
8874 // 940: }
8875 11, 7, // 945: case 0xb: {
8876 OPC_CheckPredicate, 81, // 947: check predicate 81
8877 OPC_Decode, 232, 9, 236, 2, // 949: decode to CMP_SUEQ_D using decoder 364
8878 // 949: }
8879 12, 7, // 954: case 0xc: {
8880 OPC_CheckPredicate, 81, // 956: check predicate 81
8881 OPC_Decode, 228, 9, 236, 2, // 958: decode to CMP_SLT_D using decoder 364
8882 // 958: }
8883 13, 7, // 963: case 0xd: {
8884 OPC_CheckPredicate, 81, // 965: check predicate 81
8885 OPC_Decode, 240, 9, 236, 2, // 967: decode to CMP_SULT_D using decoder 364
8886 // 967: }
8887 14, 7, // 972: case 0xe: {
8888 OPC_CheckPredicate, 81, // 974: check predicate 81
8889 OPC_Decode, 224, 9, 236, 2, // 976: decode to CMP_SLE_D using decoder 364
8890 // 976: }
8891 15, 0, // 981: case 0xf: {
8892 OPC_CheckPredicate, 81, // 983: check predicate 81
8893 OPC_Decode, 236, 9, 236, 2, // 985: decode to CMP_SULE_D using decoder 364
8894 // 985: }
8895 // 985: } // switch Inst[5:0]
8896 // 985: }
8897 // 985: } // switch Inst[25:21]
8898 // 985: }
8899 18, 57, // 990: case 0x12: {
8900 OPC_SwitchField, 21, 5, // 992: switch Inst[25:21] {
8901 9, 7, // 995: case 0x9: {
8902 OPC_CheckPredicate, 78, // 997: check predicate 78
8903 OPC_Decode, 181, 7, 237, 2, // 999: decode to BC2EQZ using decoder 365
8904 // 999: }
8905 10, 7, // 1004: case 0xa: {
8906 OPC_CheckPredicate, 78, // 1006: check predicate 78
8907 OPC_Decode, 187, 15, 238, 2, // 1008: decode to LWC2_R6 using decoder 366
8908 // 1008: }
8909 11, 7, // 1013: case 0xb: {
8910 OPC_CheckPredicate, 78, // 1015: check predicate 78
8911 OPC_Decode, 226, 21, 238, 2, // 1017: decode to SWC2_R6 using decoder 366
8912 // 1017: }
8913 13, 7, // 1022: case 0xd: {
8914 OPC_CheckPredicate, 78, // 1024: check predicate 78
8915 OPC_Decode, 183, 7, 237, 2, // 1026: decode to BC2NEZ using decoder 365
8916 // 1026: }
8917 14, 7, // 1031: case 0xe: {
8918 OPC_CheckPredicate, 78, // 1033: check predicate 78
8919 OPC_Decode, 255, 14, 238, 2, // 1035: decode to LDC2_R6 using decoder 366
8920 // 1035: }
8921 15, 0, // 1040: case 0xf: {
8922 OPC_CheckPredicate, 78, // 1042: check predicate 78
8923 OPC_Decode, 222, 19, 238, 2, // 1044: decode to SDC2_R6 using decoder 366
8924 // 1044: }
8925 // 1044: } // switch Inst[25:21]
8926 // 1044: }
8927 22, 7, // 1049: case 0x16: {
8928 OPC_CheckPredicate, 78, // 1051: check predicate 78
8929 OPC_Decode, 223, 7, 239, 2, // 1053: decode to BGEZC using decoder 367
8930 // 1053: }
8931 23, 7, // 1058: case 0x17: {
8932 OPC_CheckPredicate, 78, // 1060: check predicate 78
8933 OPC_Decode, 152, 8, 240, 2, // 1062: decode to BLTZC using decoder 368
8934 // 1062: }
8935 24, 7, // 1067: case 0x18: {
8936 OPC_CheckPredicate, 78, // 1069: check predicate 78
8937 OPC_Decode, 163, 8, 241, 2, // 1071: decode to BNEC using decoder 369
8938 // 1071: }
8939 29, 7, // 1076: case 0x1d: {
8940 OPC_CheckPredicate, 79, // 1078: check predicate 79
8941 OPC_Decode, 170, 11, 242, 2, // 1080: decode to DAUI using decoder 370
8942 // 1080: }
8943 31, 235, 1, // 1085: case 0x1f: {
8944 OPC_SwitchField, 0, 6, // 1088: switch Inst[5:0] {
8945 15, 75, // 1091: case 0xf: {
8946 OPC_SwitchField, 6, 10, // 1093: switch Inst[15:6] {
8947 0, 7, // 1096: case 0x0: {
8948 OPC_CheckPredicate, 82, // 1098: check predicate 82
8949 OPC_Decode, 143, 10, 243, 2, // 1100: decode to CRC32B using decoder 371
8950 // 1100: }
8951 1, 7, // 1105: case 0x1: {
8952 OPC_CheckPredicate, 82, // 1107: check predicate 82
8953 OPC_Decode, 149, 10, 243, 2, // 1109: decode to CRC32H using decoder 371
8954 // 1109: }
8955 2, 7, // 1114: case 0x2: {
8956 OPC_CheckPredicate, 82, // 1116: check predicate 82
8957 OPC_Decode, 150, 10, 243, 2, // 1118: decode to CRC32W using decoder 371
8958 // 1118: }
8959 3, 7, // 1123: case 0x3: {
8960 OPC_CheckPredicate, 83, // 1125: check predicate 83
8961 OPC_Decode, 148, 10, 243, 2, // 1127: decode to CRC32D using decoder 371
8962 // 1127: }
8963 4, 7, // 1132: case 0x4: {
8964 OPC_CheckPredicate, 82, // 1134: check predicate 82
8965 OPC_Decode, 144, 10, 243, 2, // 1136: decode to CRC32CB using decoder 371
8966 // 1136: }
8967 5, 7, // 1141: case 0x5: {
8968 OPC_CheckPredicate, 82, // 1143: check predicate 82
8969 OPC_Decode, 146, 10, 243, 2, // 1145: decode to CRC32CH using decoder 371
8970 // 1145: }
8971 6, 7, // 1150: case 0x6: {
8972 OPC_CheckPredicate, 82, // 1152: check predicate 82
8973 OPC_Decode, 147, 10, 243, 2, // 1154: decode to CRC32CW using decoder 371
8974 // 1154: }
8975 7, 0, // 1159: case 0x7: {
8976 OPC_CheckPredicate, 83, // 1161: check predicate 83
8977 OPC_Decode, 145, 10, 243, 2, // 1163: decode to CRC32CD using decoder 371
8978 // 1163: }
8979 // 1163: } // switch Inst[15:6]
8980 // 1163: }
8981 32, 29, // 1168: case 0x20: {
8982 OPC_SwitchField, 8, 3, // 1170: switch Inst[10:8] {
8983 0, 15, // 1173: case 0x0: {
8984 OPC_CheckPredicate, 77, // 1175: check predicate 77
8985 OPC_CheckField, 21, 5, 0, // 1177: check Inst[25:21] == 0x0
8986 OPC_CheckField, 6, 2, 0, // 1181: check Inst[7:6] == 0x0
8987 OPC_Decode, 255, 7, 206, 2, // 1185: decode to BITSWAP using decoder 334
8988 // 1185: }
8989 2, 0, // 1190: case 0x2: {
8990 OPC_CheckPredicate, 77, // 1192: check predicate 77
8991 OPC_Decode, 229, 6, 244, 2, // 1194: decode to ALIGN using decoder 372
8992 // 1194: }
8993 // 1194: } // switch Inst[10:8]
8994 // 1194: }
8995 36, 29, // 1199: case 0x24: {
8996 OPC_SwitchField, 9, 2, // 1201: switch Inst[10:9] {
8997 0, 15, // 1204: case 0x0: {
8998 OPC_CheckPredicate, 79, // 1206: check predicate 79
8999 OPC_CheckField, 21, 5, 0, // 1208: check Inst[25:21] == 0x0
9000 OPC_CheckField, 6, 3, 0, // 1212: check Inst[8:6] == 0x0
9001 OPC_Decode, 171, 11, 245, 2, // 1216: decode to DBITSWAP using decoder 373
9002 // 1216: }
9003 1, 0, // 1221: case 0x1: {
9004 OPC_CheckPredicate, 79, // 1223: check predicate 79
9005 OPC_Decode, 168, 11, 246, 2, // 1225: decode to DALIGN using decoder 374
9006 // 1225: }
9007 // 1225: } // switch Inst[10:9]
9008 // 1225: }
9009 37, 11, // 1230: case 0x25: {
9010 OPC_CheckPredicate, 78, // 1232: check predicate 78
9011 OPC_CheckField, 6, 1, 0, // 1234: check Inst[6] == 0x0
9012 OPC_Decode, 232, 8, 211, 2, // 1238: decode to CACHE_R6 using decoder 339
9013 // 1238: }
9014 38, 7, // 1243: case 0x26: {
9015 OPC_CheckPredicate, 84, // 1245: check predicate 84
9016 OPC_Decode, 207, 19, 247, 2, // 1247: decode to SC_R6 using decoder 375
9017 // 1247: }
9018 39, 7, // 1252: case 0x27: {
9019 OPC_CheckPredicate, 77, // 1254: check predicate 77
9020 OPC_Decode, 202, 19, 247, 2, // 1256: decode to SCD_R6 using decoder 375
9021 // 1256: }
9022 53, 11, // 1261: case 0x35: {
9023 OPC_CheckPredicate, 78, // 1263: check predicate 78
9024 OPC_CheckField, 6, 1, 0, // 1265: check Inst[6] == 0x0
9025 OPC_Decode, 253, 18, 211, 2, // 1269: decode to PREF_R6 using decoder 339
9026 // 1269: }
9027 54, 7, // 1274: case 0x36: {
9028 OPC_CheckPredicate, 84, // 1276: check predicate 84
9029 OPC_Decode, 169, 15, 247, 2, // 1278: decode to LL_R6 using decoder 375
9030 // 1278: }
9031 55, 7, // 1283: case 0x37: {
9032 OPC_CheckPredicate, 79, // 1285: check predicate 79
9033 OPC_Decode, 164, 15, 247, 2, // 1287: decode to LLD_R6 using decoder 375
9034 // 1287: }
9035 61, 0, // 1292: case 0x3d: {
9036 OPC_SwitchField, 6, 2, // 1294: switch Inst[7:6] {
9037 0, 11, // 1297: case 0x0: {
9038 OPC_CheckPredicate, 85, // 1299: check predicate 85
9039 OPC_CheckField, 8, 13, 0, // 1301: check Inst[20:8] == 0x0
9040 OPC_Decode, 141, 14, 188, 1, // 1305: decode to GINVI using decoder 188
9041 // 1305: }
9042 2, 0, // 1310: case 0x2: {
9043 OPC_CheckPredicate, 85, // 1312: check predicate 85
9044 OPC_CheckField, 10, 11, 0, // 1314: check Inst[20:10] == 0x0
9045 OPC_Decode, 143, 14, 248, 2, // 1318: decode to GINVT using decoder 376
9046 // 1318: }
9047 // 1318: } // switch Inst[7:6]
9048 // 1318: }
9049 // 1318: } // switch Inst[5:0]
9050 // 1318: }
9051 50, 7, // 1323: case 0x32: {
9052 OPC_CheckPredicate, 78, // 1325: check predicate 78
9053 OPC_Decode, 169, 7, 249, 2, // 1327: decode to BC using decoder 377
9054 // 1327: }
9055 53, 20, // 1332: case 0x35: {
9056 OPC_Scope, 11, // 1334: try {
9057 OPC_CheckField, 16, 5, 0, // 1336: check Inst[20:16] == 0x0
9058 OPC_CheckPredicate, 3, // 1340: check predicate 3
9059 OPC_Decode, 234, 7, 182, 1, // 1342: decode to BGTZC_MMR6 using decoder 182
9060 // 1342: } else try {
9061 OPC_CheckPredicate, 3, // 1347: check predicate 3
9062 OPC_Decode, 154, 8, 182, 1, // 1349: decode to BLTZC_MMR6 using decoder 182
9063 // 1349: }
9064 // 1349: }
9065 54, 19, // 1354: case 0x36: {
9066 OPC_Scope, 10, // 1356: try {
9067 OPC_CheckField, 21, 5, 0, // 1358: check Inst[25:21] == 0x0
9068 OPC_CheckPredicate, 77, // 1362: check predicate 77
9069 OPC_Decode, 209, 14, 110, // 1364: decode to JIC using decoder 110
9070 // 1364: } else try {
9071 OPC_CheckPredicate, 78, // 1368: check predicate 78
9072 OPC_Decode, 203, 7, 250, 2, // 1370: decode to BEQZC using decoder 378
9073 // 1370: }
9074 // 1370: }
9075 58, 7, // 1375: case 0x3a: {
9076 OPC_CheckPredicate, 77, // 1377: check predicate 77
9077 OPC_Decode, 161, 7, 249, 2, // 1379: decode to BALC using decoder 377
9078 // 1379: }
9079 59, 67, // 1384: case 0x3b: {
9080 OPC_SwitchField, 19, 2, // 1386: switch Inst[20:19] {
9081 0, 7, // 1389: case 0x0: {
9082 OPC_CheckPredicate, 77, // 1391: check predicate 77
9083 OPC_Decode, 155, 6, 176, 1, // 1393: decode to ADDIUPC using decoder 176
9084 // 1393: }
9085 1, 7, // 1398: case 0x1: {
9086 OPC_CheckPredicate, 77, // 1400: check predicate 77
9087 OPC_Decode, 202, 15, 176, 1, // 1402: decode to LWPC using decoder 176
9088 // 1402: }
9089 2, 7, // 1407: case 0x2: {
9090 OPC_CheckPredicate, 86, // 1409: check predicate 86
9091 OPC_Decode, 211, 15, 176, 1, // 1411: decode to LWUPC using decoder 176
9092 // 1411: }
9093 3, 0, // 1416: case 0x3: {
9094 OPC_SwitchField, 18, 1, // 1418: switch Inst[18] {
9095 0, 7, // 1421: case 0x0: {
9096 OPC_CheckPredicate, 86, // 1423: check predicate 86
9097 OPC_Decode, 134, 15, 251, 2, // 1425: decode to LDPC using decoder 379
9098 // 1425: }
9099 1, 0, // 1430: case 0x1: {
9100 OPC_SwitchField, 16, 2, // 1432: switch Inst[17:16] {
9101 2, 7, // 1435: case 0x2: {
9102 OPC_CheckPredicate, 77, // 1437: check predicate 77
9103 OPC_Decode, 130, 7, 177, 1, // 1439: decode to AUIPC using decoder 177
9104 // 1439: }
9105 3, 0, // 1444: case 0x3: {
9106 OPC_CheckPredicate, 77, // 1446: check predicate 77
9107 OPC_Decode, 231, 6, 177, 1, // 1448: decode to ALUIPC using decoder 177
9108 // 1448: }
9109 // 1448: } // switch Inst[17:16]
9110 // 1448: }
9111 // 1448: } // switch Inst[18]
9112 // 1448: }
9113 // 1448: } // switch Inst[20:19]
9114 // 1448: }
9115 61, 20, // 1453: case 0x3d: {
9116 OPC_Scope, 11, // 1455: try {
9117 OPC_CheckField, 16, 5, 0, // 1457: check Inst[20:16] == 0x0
9118 OPC_CheckPredicate, 3, // 1461: check predicate 3
9119 OPC_Decode, 135, 8, 184, 1, // 1463: decode to BLEZC_MMR6 using decoder 184
9120 // 1463: } else try {
9121 OPC_CheckPredicate, 3, // 1468: check predicate 3
9122 OPC_Decode, 225, 7, 184, 1, // 1470: decode to BGEZC_MMR6 using decoder 184
9123 // 1470: }
9124 // 1470: }
9125 62, 0, // 1475: case 0x3e: {
9126 OPC_Scope, 10, // 1477: try {
9127 OPC_CheckField, 21, 5, 0, // 1479: check Inst[25:21] == 0x0
9128 OPC_CheckPredicate, 77, // 1483: check predicate 77
9129 OPC_Decode, 206, 14, 110, // 1485: decode to JIALC using decoder 110
9130 // 1485: } else try {
9131 OPC_CheckPredicate, 78, // 1489: check predicate 78
9132 OPC_Decode, 178, 8, 250, 2, // 1491: decode to BNEZC using decoder 378
9133 // 1491: }
9134 // 1491: }
9135 // 1491: } // switch Inst[31:26]
9136};
9137static const uint8_t DecoderTableMips32r6_64r6_Ambiguous32[135] = {
9138 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9139 6, 20, // 3: case 0x6: {
9140 OPC_Scope, 11, // 5: try {
9141 OPC_CheckField, 21, 5, 0, // 7: check Inst[25:21] == 0x0
9142 OPC_CheckPredicate, 78, // 11: check predicate 78
9143 OPC_Decode, 131, 8, 226, 2, // 13: decode to BLEZALC using decoder 354
9144 // 13: } else try {
9145 OPC_CheckPredicate, 78, // 18: check predicate 78
9146 OPC_Decode, 212, 7, 226, 2, // 20: decode to BGEUC using decoder 354
9147 // 20: }
9148 // 20: }
9149 7, 20, // 25: case 0x7: {
9150 OPC_Scope, 11, // 27: try {
9151 OPC_CheckField, 21, 5, 0, // 29: check Inst[25:21] == 0x0
9152 OPC_CheckPredicate, 78, // 33: check predicate 78
9153 OPC_Decode, 230, 7, 227, 2, // 35: decode to BGTZALC using decoder 355
9154 // 35: } else try {
9155 OPC_CheckPredicate, 78, // 40: check predicate 78
9156 OPC_Decode, 141, 8, 227, 2, // 42: decode to BLTUC using decoder 355
9157 // 42: }
9158 // 42: }
9159 8, 20, // 47: case 0x8: {
9160 OPC_Scope, 11, // 49: try {
9161 OPC_CheckField, 21, 5, 0, // 51: check Inst[25:21] == 0x0
9162 OPC_CheckPredicate, 78, // 55: check predicate 78
9163 OPC_Decode, 201, 7, 241, 2, // 57: decode to BEQZALC using decoder 369
9164 // 57: } else try {
9165 OPC_CheckPredicate, 78, // 62: check predicate 78
9166 OPC_Decode, 191, 8, 228, 2, // 64: decode to BOVC using decoder 356
9167 // 64: }
9168 // 64: }
9169 22, 20, // 69: case 0x16: {
9170 OPC_Scope, 11, // 71: try {
9171 OPC_CheckField, 21, 5, 0, // 73: check Inst[25:21] == 0x0
9172 OPC_CheckPredicate, 78, // 77: check predicate 78
9173 OPC_Decode, 133, 8, 239, 2, // 79: decode to BLEZC using decoder 367
9174 // 79: } else try {
9175 OPC_CheckPredicate, 78, // 84: check predicate 78
9176 OPC_Decode, 209, 7, 239, 2, // 86: decode to BGEC using decoder 367
9177 // 86: }
9178 // 86: }
9179 23, 20, // 91: case 0x17: {
9180 OPC_Scope, 11, // 93: try {
9181 OPC_CheckField, 21, 5, 0, // 95: check Inst[25:21] == 0x0
9182 OPC_CheckPredicate, 78, // 99: check predicate 78
9183 OPC_Decode, 232, 7, 240, 2, // 101: decode to BGTZC using decoder 368
9184 // 101: } else try {
9185 OPC_CheckPredicate, 78, // 106: check predicate 78
9186 OPC_Decode, 138, 8, 240, 2, // 108: decode to BLTC using decoder 368
9187 // 108: }
9188 // 108: }
9189 24, 0, // 113: case 0x18: {
9190 OPC_Scope, 11, // 115: try {
9191 OPC_CheckField, 21, 5, 0, // 117: check Inst[25:21] == 0x0
9192 OPC_CheckPredicate, 78, // 121: check predicate 78
9193 OPC_Decode, 176, 8, 241, 2, // 123: decode to BNEZALC using decoder 369
9194 // 123: } else try {
9195 OPC_CheckPredicate, 78, // 128: check predicate 78
9196 OPC_Decode, 184, 8, 241, 2, // 130: decode to BNVC using decoder 369
9197 // 130: }
9198 // 130: }
9199 // 130: } // switch Inst[31:26]
9200};
9201static const uint8_t DecoderTableMips32r6_64r6_BranchZero32[21] = {
9202 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9203 22, 7, // 3: case 0x16: {
9204 OPC_CheckPredicate, 87, // 5: check predicate 87
9205 OPC_Decode, 224, 7, 239, 2, // 7: decode to BGEZC64 using decoder 367
9206 // 7: }
9207 23, 0, // 12: case 0x17: {
9208 OPC_CheckPredicate, 87, // 14: check predicate 87
9209 OPC_Decode, 153, 8, 240, 2, // 16: decode to BLTZC64 using decoder 368
9210 // 16: }
9211 // 16: } // switch Inst[31:26]
9212};
9213static const uint8_t DecoderTableMips32r6_64r6_GP6432[159] = {
9214 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9215 0, 32, // 3: case 0x0: {
9216 OPC_SwitchField, 0, 11, // 5: switch Inst[10:0] {
9217 53, 6, // 8: case 0x35: {
9218 OPC_CheckPredicate, 88, // 10: check predicate 88
9219 OPC_Decode, 237, 19, 50, // 12: decode to SELEQZ64 using decoder 50
9220 // 12: }
9221 55, 6, // 16: case 0x37: {
9222 OPC_CheckPredicate, 88, // 18: check predicate 88
9223 OPC_Decode, 244, 19, 50, // 20: decode to SELNEZ64 using decoder 50
9224 // 20: }
9225 137, 8, 0, // 24: case 0x409: {
9226 OPC_CheckPredicate, 77, // 27: check predicate 77
9227 OPC_CheckField, 11, 10, 0, // 29: check Inst[20:11] == 0x0
9228 OPC_Decode, 221, 14, 51, // 33: decode to JR_HB64_R6 using decoder 51
9229 // 33: }
9230 // 33: } // switch Inst[10:0]
9231 // 33: }
9232 6, 7, // 37: case 0x6: {
9233 OPC_CheckPredicate, 87, // 39: check predicate 87
9234 OPC_Decode, 213, 7, 226, 2, // 41: decode to BGEUC64 using decoder 354
9235 // 41: }
9236 7, 7, // 46: case 0x7: {
9237 OPC_CheckPredicate, 87, // 48: check predicate 87
9238 OPC_Decode, 142, 8, 227, 2, // 50: decode to BLTUC64 using decoder 355
9239 // 50: }
9240 8, 7, // 55: case 0x8: {
9241 OPC_CheckPredicate, 87, // 57: check predicate 87
9242 OPC_Decode, 197, 7, 228, 2, // 59: decode to BEQC64 using decoder 356
9243 // 59: }
9244 22, 20, // 64: case 0x16: {
9245 OPC_Scope, 11, // 66: try {
9246 OPC_CheckField, 21, 5, 0, // 68: check Inst[25:21] == 0x0
9247 OPC_CheckPredicate, 87, // 72: check predicate 87
9248 OPC_Decode, 134, 8, 239, 2, // 74: decode to BLEZC64 using decoder 367
9249 // 74: } else try {
9250 OPC_CheckPredicate, 87, // 79: check predicate 87
9251 OPC_Decode, 210, 7, 239, 2, // 81: decode to BGEC64 using decoder 367
9252 // 81: }
9253 // 81: }
9254 23, 20, // 86: case 0x17: {
9255 OPC_Scope, 11, // 88: try {
9256 OPC_CheckField, 21, 5, 0, // 90: check Inst[25:21] == 0x0
9257 OPC_CheckPredicate, 87, // 94: check predicate 87
9258 OPC_Decode, 233, 7, 240, 2, // 96: decode to BGTZC64 using decoder 368
9259 // 96: } else try {
9260 OPC_CheckPredicate, 87, // 101: check predicate 87
9261 OPC_Decode, 139, 8, 240, 2, // 103: decode to BLTC64 using decoder 368
9262 // 103: }
9263 // 103: }
9264 24, 7, // 108: case 0x18: {
9265 OPC_CheckPredicate, 87, // 110: check predicate 87
9266 OPC_Decode, 164, 8, 241, 2, // 112: decode to BNEC64 using decoder 369
9267 // 112: }
9268 54, 19, // 117: case 0x36: {
9269 OPC_Scope, 10, // 119: try {
9270 OPC_CheckField, 21, 5, 0, // 121: check Inst[25:21] == 0x0
9271 OPC_CheckPredicate, 87, // 125: check predicate 87
9272 OPC_Decode, 210, 14, 49, // 127: decode to JIC64 using decoder 49
9273 // 127: } else try {
9274 OPC_CheckPredicate, 87, // 131: check predicate 87
9275 OPC_Decode, 205, 7, 252, 2, // 133: decode to BEQZC64 using decoder 380
9276 // 133: }
9277 // 133: }
9278 62, 0, // 138: case 0x3e: {
9279 OPC_Scope, 10, // 140: try {
9280 OPC_CheckField, 21, 5, 0, // 142: check Inst[25:21] == 0x0
9281 OPC_CheckPredicate, 87, // 146: check predicate 87
9282 OPC_Decode, 207, 14, 49, // 148: decode to JIALC64 using decoder 49
9283 // 148: } else try {
9284 OPC_CheckPredicate, 87, // 152: check predicate 87
9285 OPC_Decode, 180, 8, 252, 2, // 154: decode to BNEZC64 using decoder 380
9286 // 154: }
9287 // 154: }
9288 // 154: } // switch Inst[31:26]
9289};
9290static const uint8_t DecoderTableMips32r6_64r6_PTR6432[29] = {
9291 OPC_SwitchField, 0, 6, // 0: switch Inst[5:0] {
9292 38, 11, // 3: case 0x26: {
9293 OPC_CheckPredicate, 89, // 5: check predicate 89
9294 OPC_CheckField, 26, 6, 31, // 7: check Inst[31:26] == 0x1f
9295 OPC_Decode, 200, 19, 247, 2, // 11: decode to SC64_R6 using decoder 375
9296 // 11: }
9297 54, 0, // 16: case 0x36: {
9298 OPC_CheckPredicate, 89, // 18: check predicate 89
9299 OPC_CheckField, 26, 6, 31, // 20: check Inst[31:26] == 0x1f
9300 OPC_Decode, 162, 15, 247, 2, // 24: decode to LL64_R6 using decoder 375
9301 // 24: }
9302 // 24: } // switch Inst[5:0]
9303};
9304static const uint8_t DecoderTableMips6432[778] = {
9305 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9306 0, 163, 2, // 3: case 0x0: {
9307 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
9308 8, 10, // 9: case 0x8: {
9309 OPC_CheckPredicate, 90, // 11: check predicate 90
9310 OPC_CheckField, 6, 15, 16, // 13: check Inst[20:6] == 0x10
9311 OPC_Decode, 220, 14, 51, // 17: decode to JR_HB64 using decoder 51
9312 // 17: }
9313 9, 27, // 21: case 0x9: {
9314 OPC_SwitchField, 6, 5, // 23: switch Inst[10:6] {
9315 0, 10, // 26: case 0x0: {
9316 OPC_CheckPredicate, 91, // 28: check predicate 91
9317 OPC_CheckField, 16, 5, 0, // 30: check Inst[20:16] == 0x0
9318 OPC_Decode, 192, 14, 53, // 34: decode to JALR64 using decoder 53
9319 // 34: }
9320 16, 0, // 38: case 0x10: {
9321 OPC_CheckPredicate, 92, // 40: check predicate 92
9322 OPC_CheckField, 16, 5, 0, // 42: check Inst[20:16] == 0x0
9323 OPC_Decode, 199, 14, 53, // 46: decode to JALR_HB64 using decoder 53
9324 // 46: }
9325 // 46: } // switch Inst[10:6]
9326 // 46: }
9327 20, 11, // 50: case 0x14: {
9328 OPC_CheckPredicate, 93, // 52: check predicate 93
9329 OPC_CheckField, 6, 5, 0, // 54: check Inst[10:6] == 0x0
9330 OPC_Decode, 157, 12, 253, 2, // 58: decode to DSLLV using decoder 381
9331 // 58: }
9332 22, 21, // 63: case 0x16: {
9333 OPC_SwitchField, 6, 5, // 65: switch Inst[10:6] {
9334 0, 7, // 68: case 0x0: {
9335 OPC_CheckPredicate, 93, // 70: check predicate 93
9336 OPC_Decode, 163, 12, 253, 2, // 72: decode to DSRLV using decoder 381
9337 // 72: }
9338 1, 0, // 77: case 0x1: {
9339 OPC_CheckPredicate, 92, // 79: check predicate 92
9340 OPC_Decode, 150, 12, 253, 2, // 81: decode to DROTRV using decoder 381
9341 // 81: }
9342 // 81: } // switch Inst[10:6]
9343 // 81: }
9344 23, 11, // 86: case 0x17: {
9345 OPC_CheckPredicate, 93, // 88: check predicate 93
9346 OPC_CheckField, 6, 5, 0, // 90: check Inst[10:6] == 0x0
9347 OPC_Decode, 160, 12, 253, 2, // 94: decode to DSRAV using decoder 381
9348 // 94: }
9349 28, 11, // 99: case 0x1c: {
9350 OPC_CheckPredicate, 94, // 101: check predicate 94
9351 OPC_CheckField, 6, 10, 0, // 103: check Inst[15:6] == 0x0
9352 OPC_Decode, 221, 11, 254, 2, // 107: decode to DMULT using decoder 382
9353 // 107: }
9354 29, 11, // 112: case 0x1d: {
9355 OPC_CheckPredicate, 94, // 114: check predicate 94
9356 OPC_CheckField, 6, 10, 0, // 116: check Inst[15:6] == 0x0
9357 OPC_Decode, 222, 11, 254, 2, // 120: decode to DMULTu using decoder 382
9358 // 120: }
9359 30, 11, // 125: case 0x1e: {
9360 OPC_CheckPredicate, 94, // 127: check predicate 94
9361 OPC_CheckField, 6, 10, 0, // 129: check Inst[15:6] == 0x0
9362 OPC_Decode, 152, 12, 254, 2, // 133: decode to DSDIV using decoder 382
9363 // 133: }
9364 31, 11, // 138: case 0x1f: {
9365 OPC_CheckPredicate, 94, // 140: check predicate 94
9366 OPC_CheckField, 6, 10, 0, // 142: check Inst[15:6] == 0x0
9367 OPC_Decode, 166, 12, 254, 2, // 146: decode to DUDIV using decoder 382
9368 // 146: }
9369 44, 10, // 151: case 0x2c: {
9370 OPC_CheckPredicate, 93, // 153: check predicate 93
9371 OPC_CheckField, 6, 5, 0, // 155: check Inst[10:6] == 0x0
9372 OPC_Decode, 163, 11, 50, // 159: decode to DADD using decoder 50
9373 // 159: }
9374 45, 10, // 163: case 0x2d: {
9375 OPC_CheckPredicate, 93, // 165: check predicate 93
9376 OPC_CheckField, 6, 5, 0, // 167: check Inst[10:6] == 0x0
9377 OPC_Decode, 166, 11, 50, // 171: decode to DADDu using decoder 50
9378 // 171: }
9379 46, 10, // 175: case 0x2e: {
9380 OPC_CheckPredicate, 93, // 177: check predicate 93
9381 OPC_CheckField, 6, 5, 0, // 179: check Inst[10:6] == 0x0
9382 OPC_Decode, 164, 12, 50, // 183: decode to DSUB using decoder 50
9383 // 183: }
9384 47, 10, // 187: case 0x2f: {
9385 OPC_CheckPredicate, 93, // 189: check predicate 93
9386 OPC_CheckField, 6, 5, 0, // 191: check Inst[10:6] == 0x0
9387 OPC_Decode, 165, 12, 50, // 195: decode to DSUBu using decoder 50
9388 // 195: }
9389 56, 11, // 199: case 0x38: {
9390 OPC_CheckPredicate, 93, // 201: check predicate 93
9391 OPC_CheckField, 21, 5, 0, // 203: check Inst[25:21] == 0x0
9392 OPC_Decode, 154, 12, 255, 2, // 207: decode to DSLL using decoder 383
9393 // 207: }
9394 58, 21, // 212: case 0x3a: {
9395 OPC_SwitchField, 21, 5, // 214: switch Inst[25:21] {
9396 0, 7, // 217: case 0x0: {
9397 OPC_CheckPredicate, 93, // 219: check predicate 93
9398 OPC_Decode, 161, 12, 255, 2, // 221: decode to DSRL using decoder 383
9399 // 221: }
9400 1, 0, // 226: case 0x1: {
9401 OPC_CheckPredicate, 92, // 228: check predicate 92
9402 OPC_Decode, 148, 12, 255, 2, // 230: decode to DROTR using decoder 383
9403 // 230: }
9404 // 230: } // switch Inst[25:21]
9405 // 230: }
9406 59, 11, // 235: case 0x3b: {
9407 OPC_CheckPredicate, 93, // 237: check predicate 93
9408 OPC_CheckField, 21, 5, 0, // 239: check Inst[25:21] == 0x0
9409 OPC_Decode, 158, 12, 255, 2, // 243: decode to DSRA using decoder 383
9410 // 243: }
9411 60, 11, // 248: case 0x3c: {
9412 OPC_CheckPredicate, 93, // 250: check predicate 93
9413 OPC_CheckField, 21, 5, 0, // 252: check Inst[25:21] == 0x0
9414 OPC_Decode, 155, 12, 255, 2, // 256: decode to DSLL32 using decoder 383
9415 // 256: }
9416 62, 21, // 261: case 0x3e: {
9417 OPC_SwitchField, 21, 5, // 263: switch Inst[25:21] {
9418 0, 7, // 266: case 0x0: {
9419 OPC_CheckPredicate, 93, // 268: check predicate 93
9420 OPC_Decode, 162, 12, 255, 2, // 270: decode to DSRL32 using decoder 383
9421 // 270: }
9422 1, 0, // 275: case 0x1: {
9423 OPC_CheckPredicate, 92, // 277: check predicate 92
9424 OPC_Decode, 149, 12, 255, 2, // 279: decode to DROTR32 using decoder 383
9425 // 279: }
9426 // 279: } // switch Inst[25:21]
9427 // 279: }
9428 63, 0, // 284: case 0x3f: {
9429 OPC_CheckPredicate, 93, // 286: check predicate 93
9430 OPC_CheckField, 21, 5, 0, // 288: check Inst[25:21] == 0x0
9431 OPC_Decode, 159, 12, 255, 2, // 292: decode to DSRA32 using decoder 383
9432 // 292: }
9433 // 292: } // switch Inst[5:0]
9434 // 292: }
9435 16, 52, // 297: case 0x10: {
9436 OPC_SwitchField, 3, 8, // 299: switch Inst[10:3] {
9437 0, 21, // 302: case 0x0: {
9438 OPC_SwitchField, 21, 5, // 304: switch Inst[25:21] {
9439 1, 7, // 307: case 0x1: {
9440 OPC_CheckPredicate, 95, // 309: check predicate 95
9441 OPC_Decode, 205, 11, 128, 3, // 311: decode to DMFC0 using decoder 384
9442 // 311: }
9443 5, 0, // 316: case 0x5: {
9444 OPC_CheckPredicate, 95, // 318: check predicate 95
9445 OPC_Decode, 213, 11, 129, 3, // 320: decode to DMTC0 using decoder 385
9446 // 320: }
9447 // 320: } // switch Inst[25:21]
9448 // 320: }
9449 32, 11, // 325: case 0x20: {
9450 OPC_CheckPredicate, 96, // 327: check predicate 96
9451 OPC_CheckField, 21, 5, 3, // 329: check Inst[25:21] == 0x3
9452 OPC_Decode, 209, 11, 128, 3, // 333: decode to DMFGC0 using decoder 384
9453 // 333: }
9454 96, 0, // 338: case 0x60: {
9455 OPC_CheckPredicate, 96, // 340: check predicate 96
9456 OPC_CheckField, 21, 5, 3, // 342: check Inst[25:21] == 0x3
9457 OPC_Decode, 217, 11, 129, 3, // 346: decode to DMTGC0 using decoder 385
9458 // 346: }
9459 // 346: } // switch Inst[10:3]
9460 // 346: }
9461 18, 29, // 351: case 0x12: {
9462 OPC_SwitchField, 21, 5, // 353: switch Inst[25:21] {
9463 1, 11, // 356: case 0x1: {
9464 OPC_CheckPredicate, 95, // 358: check predicate 95
9465 OPC_CheckField, 3, 8, 0, // 360: check Inst[10:3] == 0x0
9466 OPC_Decode, 207, 11, 130, 3, // 364: decode to DMFC2 using decoder 386
9467 // 364: }
9468 5, 0, // 369: case 0x5: {
9469 OPC_CheckPredicate, 95, // 371: check predicate 95
9470 OPC_CheckField, 3, 8, 0, // 373: check Inst[10:3] == 0x0
9471 OPC_Decode, 215, 11, 131, 3, // 377: decode to DMTC2 using decoder 387
9472 // 377: }
9473 // 377: } // switch Inst[25:21]
9474 // 377: }
9475 21, 163, 1, // 382: case 0x15: {
9476 OPC_SwitchField, 0, 13, // 385: switch Inst[12:0] {
9477 188, 8, 7, // 388: case 0x43c: {
9478 OPC_CheckPredicate, 16, // 391: check predicate 16
9479 OPC_Decode, 201, 10, 132, 3, // 393: decode to C_F_D64_MM using decoder 388
9480 // 393: }
9481 252, 8, 7, // 398: case 0x47c: {
9482 OPC_CheckPredicate, 16, // 401: check predicate 16
9483 OPC_Decode, 157, 11, 132, 3, // 403: decode to C_UN_D64_MM using decoder 388
9484 // 403: }
9485 188, 9, 7, // 408: case 0x4bc: {
9486 OPC_CheckPredicate, 16, // 411: check predicate 16
9487 OPC_Decode, 195, 10, 132, 3, // 413: decode to C_EQ_D64_MM using decoder 388
9488 // 413: }
9489 252, 9, 7, // 418: case 0x4fc: {
9490 OPC_CheckPredicate, 16, // 421: check predicate 16
9491 OPC_Decode, 139, 11, 132, 3, // 423: decode to C_UEQ_D64_MM using decoder 388
9492 // 423: }
9493 188, 10, 7, // 428: case 0x53c: {
9494 OPC_CheckPredicate, 16, // 431: check predicate 16
9495 OPC_Decode, 249, 10, 132, 3, // 433: decode to C_OLT_D64_MM using decoder 388
9496 // 433: }
9497 252, 10, 7, // 438: case 0x57c: {
9498 OPC_CheckPredicate, 16, // 441: check predicate 16
9499 OPC_Decode, 151, 11, 132, 3, // 443: decode to C_ULT_D64_MM using decoder 388
9500 // 443: }
9501 188, 11, 7, // 448: case 0x5bc: {
9502 OPC_CheckPredicate, 16, // 451: check predicate 16
9503 OPC_Decode, 243, 10, 132, 3, // 453: decode to C_OLE_D64_MM using decoder 388
9504 // 453: }
9505 252, 11, 7, // 458: case 0x5fc: {
9506 OPC_CheckPredicate, 16, // 461: check predicate 16
9507 OPC_Decode, 145, 11, 132, 3, // 463: decode to C_ULE_D64_MM using decoder 388
9508 // 463: }
9509 188, 12, 7, // 468: case 0x63c: {
9510 OPC_CheckPredicate, 16, // 471: check predicate 16
9511 OPC_Decode, 133, 11, 132, 3, // 473: decode to C_SF_D64_MM using decoder 388
9512 // 473: }
9513 252, 12, 7, // 478: case 0x67c: {
9514 OPC_CheckPredicate, 16, // 481: check predicate 16
9515 OPC_Decode, 225, 10, 132, 3, // 483: decode to C_NGLE_D64_MM using decoder 388
9516 // 483: }
9517 188, 13, 7, // 488: case 0x6bc: {
9518 OPC_CheckPredicate, 16, // 491: check predicate 16
9519 OPC_Decode, 255, 10, 132, 3, // 493: decode to C_SEQ_D64_MM using decoder 388
9520 // 493: }
9521 252, 13, 7, // 498: case 0x6fc: {
9522 OPC_CheckPredicate, 16, // 501: check predicate 16
9523 OPC_Decode, 231, 10, 132, 3, // 503: decode to C_NGL_D64_MM using decoder 388
9524 // 503: }
9525 188, 14, 7, // 508: case 0x73c: {
9526 OPC_CheckPredicate, 16, // 511: check predicate 16
9527 OPC_Decode, 213, 10, 132, 3, // 513: decode to C_LT_D64_MM using decoder 388
9528 // 513: }
9529 252, 14, 7, // 518: case 0x77c: {
9530 OPC_CheckPredicate, 16, // 521: check predicate 16
9531 OPC_Decode, 219, 10, 132, 3, // 523: decode to C_NGE_D64_MM using decoder 388
9532 // 523: }
9533 188, 15, 7, // 528: case 0x7bc: {
9534 OPC_CheckPredicate, 16, // 531: check predicate 16
9535 OPC_Decode, 207, 10, 132, 3, // 533: decode to C_LE_D64_MM using decoder 388
9536 // 533: }
9537 252, 15, 0, // 538: case 0x7fc: {
9538 OPC_CheckPredicate, 16, // 541: check predicate 16
9539 OPC_Decode, 237, 10, 132, 3, // 543: decode to C_NGT_D64_MM using decoder 388
9540 // 543: }
9541 // 543: } // switch Inst[12:0]
9542 // 543: }
9543 24, 7, // 548: case 0x18: {
9544 OPC_CheckPredicate, 97, // 550: check predicate 97
9545 OPC_Decode, 164, 11, 133, 3, // 552: decode to DADDi using decoder 389
9546 // 552: }
9547 25, 7, // 557: case 0x19: {
9548 OPC_CheckPredicate, 93, // 559: check predicate 93
9549 OPC_Decode, 165, 11, 133, 3, // 561: decode to DADDiu using decoder 389
9550 // 561: }
9551 26, 7, // 566: case 0x1a: {
9552 OPC_CheckPredicate, 97, // 568: check predicate 97
9553 OPC_Decode, 133, 15, 148, 1, // 570: decode to LDL using decoder 148
9554 // 570: }
9555 27, 7, // 575: case 0x1b: {
9556 OPC_CheckPredicate, 97, // 577: check predicate 97
9557 OPC_Decode, 135, 15, 148, 1, // 579: decode to LDR using decoder 148
9558 // 579: }
9559 28, 21, // 584: case 0x1c: {
9560 OPC_SwitchField, 0, 11, // 586: switch Inst[10:0] {
9561 36, 7, // 589: case 0x24: {
9562 OPC_CheckPredicate, 98, // 591: check predicate 98
9563 OPC_Decode, 174, 11, 134, 3, // 593: decode to DCLZ using decoder 390
9564 // 593: }
9565 37, 0, // 598: case 0x25: {
9566 OPC_CheckPredicate, 98, // 600: check predicate 98
9567 OPC_Decode, 172, 11, 134, 3, // 602: decode to DCLO using decoder 390
9568 // 602: }
9569 // 602: } // switch Inst[10:0]
9570 // 602: }
9571 31, 88, // 607: case 0x1f: {
9572 OPC_SwitchField, 0, 6, // 609: switch Inst[5:0] {
9573 1, 7, // 612: case 0x1: {
9574 OPC_CheckPredicate, 92, // 614: check predicate 92
9575 OPC_Decode, 183, 11, 135, 3, // 616: decode to DEXTM using decoder 391
9576 // 616: }
9577 2, 7, // 621: case 0x2: {
9578 OPC_CheckPredicate, 92, // 623: check predicate 92
9579 OPC_Decode, 184, 11, 135, 3, // 625: decode to DEXTU using decoder 391
9580 // 625: }
9581 3, 7, // 630: case 0x3: {
9582 OPC_CheckPredicate, 92, // 632: check predicate 92
9583 OPC_Decode, 181, 11, 135, 3, // 634: decode to DEXT using decoder 391
9584 // 634: }
9585 5, 7, // 639: case 0x5: {
9586 OPC_CheckPredicate, 92, // 641: check predicate 92
9587 OPC_Decode, 187, 11, 136, 3, // 643: decode to DINSM using decoder 392
9588 // 643: }
9589 6, 7, // 648: case 0x6: {
9590 OPC_CheckPredicate, 92, // 650: check predicate 92
9591 OPC_Decode, 188, 11, 136, 3, // 652: decode to DINSU using decoder 392
9592 // 652: }
9593 7, 7, // 657: case 0x7: {
9594 OPC_CheckPredicate, 92, // 659: check predicate 92
9595 OPC_Decode, 186, 11, 136, 3, // 661: decode to DINS using decoder 392
9596 // 661: }
9597 36, 0, // 666: case 0x24: {
9598 OPC_SwitchField, 6, 5, // 668: switch Inst[10:6] {
9599 2, 11, // 671: case 0x2: {
9600 OPC_CheckPredicate, 92, // 673: check predicate 92
9601 OPC_CheckField, 21, 5, 0, // 675: check Inst[25:21] == 0x0
9602 OPC_Decode, 151, 12, 245, 2, // 679: decode to DSBH using decoder 373
9603 // 679: }
9604 5, 0, // 684: case 0x5: {
9605 OPC_CheckPredicate, 92, // 686: check predicate 92
9606 OPC_CheckField, 21, 5, 0, // 688: check Inst[25:21] == 0x0
9607 OPC_Decode, 153, 12, 245, 2, // 692: decode to DSHD using decoder 373
9608 // 692: }
9609 // 692: } // switch Inst[10:6]
9610 // 692: }
9611 // 692: } // switch Inst[5:0]
9612 // 692: }
9613 39, 7, // 697: case 0x27: {
9614 OPC_CheckPredicate, 93, // 699: check predicate 93
9615 OPC_Decode, 220, 15, 148, 1, // 701: decode to LWu using decoder 148
9616 // 701: }
9617 44, 7, // 706: case 0x2c: {
9618 OPC_CheckPredicate, 97, // 708: check predicate 97
9619 OPC_Decode, 226, 19, 148, 1, // 710: decode to SDL using decoder 148
9620 // 710: }
9621 45, 7, // 715: case 0x2d: {
9622 OPC_CheckPredicate, 97, // 717: check predicate 97
9623 OPC_Decode, 227, 19, 148, 1, // 719: decode to SDR using decoder 148
9624 // 719: }
9625 46, 7, // 724: case 0x2e: {
9626 OPC_CheckPredicate, 21, // 726: check predicate 21
9627 OPC_Decode, 219, 19, 146, 1, // 728: decode to SDC1_MM_D64 using decoder 146
9628 // 728: }
9629 47, 7, // 733: case 0x2f: {
9630 OPC_CheckPredicate, 21, // 735: check predicate 21
9631 OPC_Decode, 252, 14, 146, 1, // 737: decode to LDC1_MM_D64 using decoder 146
9632 // 737: }
9633 52, 7, // 742: case 0x34: {
9634 OPC_CheckPredicate, 94, // 744: check predicate 94
9635 OPC_Decode, 163, 15, 148, 1, // 746: decode to LLD using decoder 148
9636 // 746: }
9637 55, 7, // 751: case 0x37: {
9638 OPC_CheckPredicate, 93, // 753: check predicate 93
9639 OPC_Decode, 247, 14, 148, 1, // 755: decode to LD using decoder 148
9640 // 755: }
9641 60, 7, // 760: case 0x3c: {
9642 OPC_CheckPredicate, 99, // 762: check predicate 99
9643 OPC_Decode, 201, 19, 148, 1, // 764: decode to SCD using decoder 148
9644 // 764: }
9645 63, 0, // 769: case 0x3f: {
9646 OPC_CheckPredicate, 93, // 771: check predicate 93
9647 OPC_Decode, 208, 19, 148, 1, // 773: decode to SD using decoder 148
9648 // 773: }
9649 // 773: } // switch Inst[31:26]
9650};
9651static const uint8_t DecoderTableMipsDSP32[21] = {
9652 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9653 35, 7, // 3: case 0x23: {
9654 OPC_CheckPredicate, 100, // 5: check predicate 100
9655 OPC_Decode, 189, 15, 148, 1, // 7: decode to LWDSP using decoder 148
9656 // 7: }
9657 43, 0, // 12: case 0x2b: {
9658 OPC_CheckPredicate, 100, // 14: check predicate 100
9659 OPC_Decode, 228, 21, 148, 1, // 16: decode to SWDSP using decoder 148
9660 // 16: }
9661 // 16: } // switch Inst[31:26]
9662};
9663static const uint8_t DecoderTableMipsFP6432[1037] = {
9664 OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] {
9665 17, 152, 7, // 3: case 0x11: {
9666 OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] {
9667 0, 73, // 9: case 0x0: {
9668 OPC_SwitchField, 21, 5, // 11: switch Inst[25:21] {
9669 0, 11, // 14: case 0x0: {
9670 OPC_CheckPredicate, 101, // 16: check predicate 101
9671 OPC_CheckField, 6, 5, 0, // 18: check Inst[10:6] == 0x0
9672 OPC_Decode, 169, 16, 137, 3, // 22: decode to MFC1_D64 using decoder 393
9673 // 22: }
9674 3, 11, // 27: case 0x3: {
9675 OPC_CheckPredicate, 102, // 29: check predicate 102
9676 OPC_CheckField, 6, 5, 0, // 31: check Inst[10:6] == 0x0
9677 OPC_Decode, 179, 16, 137, 3, // 35: decode to MFHC1_D64 using decoder 393
9678 // 35: }
9679 4, 11, // 40: case 0x4: {
9680 OPC_CheckPredicate, 101, // 42: check predicate 101
9681 OPC_CheckField, 6, 5, 0, // 44: check Inst[10:6] == 0x0
9682 OPC_Decode, 185, 17, 138, 3, // 48: decode to MTC1_D64 using decoder 394
9683 // 48: }
9684 7, 11, // 53: case 0x7: {
9685 OPC_CheckPredicate, 102, // 55: check predicate 102
9686 OPC_CheckField, 6, 5, 0, // 57: check Inst[10:6] == 0x0
9687 OPC_Decode, 196, 17, 139, 3, // 61: decode to MTHC1_D64 using decoder 395
9688 // 61: }
9689 17, 7, // 66: case 0x11: {
9690 OPC_CheckPredicate, 101, // 68: check predicate 101
9691 OPC_Decode, 225, 12, 233, 2, // 70: decode to FADD_D64 using decoder 361
9692 // 70: }
9693 22, 0, // 75: case 0x16: {
9694 OPC_CheckPredicate, 103, // 77: check predicate 103
9695 OPC_Decode, 227, 12, 233, 2, // 79: decode to FADD_PS64 using decoder 361
9696 // 79: }
9697 // 79: } // switch Inst[25:21]
9698 // 79: }
9699 1, 21, // 84: case 0x1: {
9700 OPC_SwitchField, 21, 5, // 86: switch Inst[25:21] {
9701 17, 7, // 89: case 0x11: {
9702 OPC_CheckPredicate, 101, // 91: check predicate 101
9703 OPC_Decode, 242, 13, 233, 2, // 93: decode to FSUB_D64 using decoder 361
9704 // 93: }
9705 22, 0, // 98: case 0x16: {
9706 OPC_CheckPredicate, 103, // 100: check predicate 103
9707 OPC_Decode, 244, 13, 233, 2, // 102: decode to FSUB_PS64 using decoder 361
9708 // 102: }
9709 // 102: } // switch Inst[25:21]
9710 // 102: }
9711 2, 21, // 107: case 0x2: {
9712 OPC_SwitchField, 21, 5, // 109: switch Inst[25:21] {
9713 17, 7, // 112: case 0x11: {
9714 OPC_CheckPredicate, 101, // 114: check predicate 101
9715 OPC_Decode, 198, 13, 233, 2, // 116: decode to FMUL_D64 using decoder 361
9716 // 116: }
9717 22, 0, // 121: case 0x16: {
9718 OPC_CheckPredicate, 103, // 123: check predicate 103
9719 OPC_Decode, 200, 13, 233, 2, // 125: decode to FMUL_PS64 using decoder 361
9720 // 125: }
9721 // 125: } // switch Inst[25:21]
9722 // 125: }
9723 3, 11, // 130: case 0x3: {
9724 OPC_CheckPredicate, 101, // 132: check predicate 101
9725 OPC_CheckField, 21, 5, 17, // 134: check Inst[25:21] == 0x11
9726 OPC_Decode, 136, 13, 233, 2, // 138: decode to FDIV_D64 using decoder 361
9727 // 138: }
9728 4, 12, // 143: case 0x4: {
9729 OPC_CheckPredicate, 104, // 145: check predicate 104
9730 OPC_CheckField, 16, 10, 160, 4, // 147: check Inst[25:16] == 0x220
9731 OPC_Decode, 234, 13, 232, 1, // 152: decode to FSQRT_D64 using decoder 232
9732 // 152: }
9733 5, 12, // 157: case 0x5: {
9734 OPC_CheckPredicate, 101, // 159: check predicate 101
9735 OPC_CheckField, 16, 10, 160, 4, // 161: check Inst[25:16] == 0x220
9736 OPC_Decode, 218, 12, 232, 1, // 166: decode to FABS_D64 using decoder 232
9737 // 166: }
9738 6, 12, // 171: case 0x6: {
9739 OPC_CheckPredicate, 101, // 173: check predicate 101
9740 OPC_CheckField, 16, 10, 160, 4, // 175: check Inst[25:16] == 0x220
9741 OPC_Decode, 187, 13, 232, 1, // 180: decode to FMOV_D64 using decoder 232
9742 // 180: }
9743 7, 12, // 185: case 0x7: {
9744 OPC_CheckPredicate, 101, // 187: check predicate 101
9745 OPC_CheckField, 16, 10, 160, 4, // 189: check Inst[25:16] == 0x220
9746 OPC_Decode, 207, 13, 232, 1, // 194: decode to FNEG_D64 using decoder 232
9747 // 194: }
9748 8, 23, // 199: case 0x8: {
9749 OPC_SwitchField, 16, 10, // 201: switch Inst[25:16] {
9750 128, 4, 7, // 204: case 0x200: {
9751 OPC_CheckPredicate, 104, // 207: check predicate 104
9752 OPC_Decode, 163, 19, 225, 1, // 209: decode to ROUND_L_S using decoder 225
9753 // 209: }
9754 160, 4, 0, // 214: case 0x220: {
9755 OPC_CheckPredicate, 105, // 217: check predicate 105
9756 OPC_Decode, 161, 19, 232, 1, // 219: decode to ROUND_L_D64 using decoder 232
9757 // 219: }
9758 // 219: } // switch Inst[25:16]
9759 // 219: }
9760 9, 23, // 224: case 0x9: {
9761 OPC_SwitchField, 16, 10, // 226: switch Inst[25:16] {
9762 128, 4, 7, // 229: case 0x200: {
9763 OPC_CheckPredicate, 104, // 232: check predicate 104
9764 OPC_Decode, 202, 22, 225, 1, // 234: decode to TRUNC_L_S using decoder 225
9765 // 234: }
9766 160, 4, 0, // 239: case 0x220: {
9767 OPC_CheckPredicate, 105, // 242: check predicate 105
9768 OPC_Decode, 200, 22, 232, 1, // 244: decode to TRUNC_L_D64 using decoder 232
9769 // 244: }
9770 // 244: } // switch Inst[25:16]
9771 // 244: }
9772 10, 23, // 249: case 0xa: {
9773 OPC_SwitchField, 16, 10, // 251: switch Inst[25:16] {
9774 128, 4, 7, // 254: case 0x200: {
9775 OPC_CheckPredicate, 104, // 257: check predicate 104
9776 OPC_Decode, 235, 8, 225, 1, // 259: decode to CEIL_L_S using decoder 225
9777 // 259: }
9778 160, 4, 0, // 264: case 0x220: {
9779 OPC_CheckPredicate, 105, // 267: check predicate 105
9780 OPC_Decode, 233, 8, 232, 1, // 269: decode to CEIL_L_D64 using decoder 232
9781 // 269: }
9782 // 269: } // switch Inst[25:16]
9783 // 269: }
9784 11, 23, // 274: case 0xb: {
9785 OPC_SwitchField, 16, 10, // 276: switch Inst[25:16] {
9786 128, 4, 7, // 279: case 0x200: {
9787 OPC_CheckPredicate, 104, // 282: check predicate 104
9788 OPC_Decode, 166, 13, 225, 1, // 284: decode to FLOOR_L_S using decoder 225
9789 // 284: }
9790 160, 4, 0, // 289: case 0x220: {
9791 OPC_CheckPredicate, 105, // 292: check predicate 105
9792 OPC_Decode, 164, 13, 232, 1, // 294: decode to FLOOR_L_D64 using decoder 232
9793 // 294: }
9794 // 294: } // switch Inst[25:16]
9795 // 294: }
9796 12, 12, // 299: case 0xc: {
9797 OPC_CheckPredicate, 104, // 301: check predicate 104
9798 OPC_CheckField, 16, 10, 160, 4, // 303: check Inst[25:16] == 0x220
9799 OPC_Decode, 166, 19, 140, 3, // 308: decode to ROUND_W_D64 using decoder 396
9800 // 308: }
9801 13, 12, // 313: case 0xd: {
9802 OPC_CheckPredicate, 104, // 315: check predicate 104
9803 OPC_CheckField, 16, 10, 160, 4, // 317: check Inst[25:16] == 0x220
9804 OPC_Decode, 205, 22, 140, 3, // 322: decode to TRUNC_W_D64 using decoder 396
9805 // 322: }
9806 14, 12, // 327: case 0xe: {
9807 OPC_CheckPredicate, 104, // 329: check predicate 104
9808 OPC_CheckField, 16, 10, 160, 4, // 331: check Inst[25:16] == 0x220
9809 OPC_Decode, 238, 8, 140, 3, // 336: decode to CEIL_W_D64 using decoder 396
9810 // 336: }
9811 15, 12, // 341: case 0xf: {
9812 OPC_CheckPredicate, 104, // 343: check predicate 104
9813 OPC_CheckField, 16, 10, 160, 4, // 345: check Inst[25:16] == 0x220
9814 OPC_Decode, 169, 13, 140, 3, // 350: decode to FLOOR_W_D64 using decoder 396
9815 // 350: }
9816 17, 29, // 355: case 0x11: {
9817 OPC_SwitchField, 16, 2, // 357: switch Inst[17:16] {
9818 0, 11, // 360: case 0x0: {
9819 OPC_CheckPredicate, 106, // 362: check predicate 106
9820 OPC_CheckField, 21, 5, 17, // 364: check Inst[25:21] == 0x11
9821 OPC_Decode, 246, 16, 141, 3, // 368: decode to MOVF_D64 using decoder 397
9822 // 368: }
9823 1, 0, // 373: case 0x1: {
9824 OPC_CheckPredicate, 106, // 375: check predicate 106
9825 OPC_CheckField, 21, 5, 17, // 377: check Inst[25:21] == 0x11
9826 OPC_Decode, 138, 17, 141, 3, // 381: decode to MOVT_D64 using decoder 397
9827 // 381: }
9828 // 381: } // switch Inst[17:16]
9829 // 381: }
9830 18, 11, // 386: case 0x12: {
9831 OPC_CheckPredicate, 106, // 388: check predicate 106
9832 OPC_CheckField, 21, 5, 17, // 390: check Inst[25:21] == 0x11
9833 OPC_Decode, 150, 17, 142, 3, // 394: decode to MOVZ_I_D64 using decoder 398
9834 // 394: }
9835 19, 11, // 399: case 0x13: {
9836 OPC_CheckPredicate, 106, // 401: check predicate 106
9837 OPC_CheckField, 21, 5, 17, // 403: check Inst[25:21] == 0x11
9838 OPC_Decode, 130, 17, 142, 3, // 407: decode to MOVN_I_D64 using decoder 398
9839 // 407: }
9840 21, 12, // 412: case 0x15: {
9841 OPC_CheckPredicate, 107, // 414: check predicate 107
9842 OPC_CheckField, 16, 10, 160, 4, // 416: check Inst[25:16] == 0x220
9843 OPC_Decode, 141, 19, 232, 1, // 421: decode to RECIP_D64 using decoder 232
9844 // 421: }
9845 22, 12, // 426: case 0x16: {
9846 OPC_CheckPredicate, 107, // 428: check predicate 107
9847 OPC_CheckField, 16, 10, 160, 4, // 430: check Inst[25:16] == 0x220
9848 OPC_Decode, 174, 19, 232, 1, // 435: decode to RSQRT_D64 using decoder 232
9849 // 435: }
9850 24, 11, // 440: case 0x18: {
9851 OPC_CheckPredicate, 108, // 442: check predicate 108
9852 OPC_CheckField, 21, 5, 22, // 444: check Inst[25:21] == 0x16
9853 OPC_Decode, 177, 6, 233, 2, // 448: decode to ADDR_PS64 using decoder 361
9854 // 448: }
9855 26, 11, // 453: case 0x1a: {
9856 OPC_CheckPredicate, 108, // 455: check predicate 108
9857 OPC_CheckField, 21, 5, 22, // 457: check Inst[25:21] == 0x16
9858 OPC_Decode, 241, 17, 233, 2, // 461: decode to MULR_PS64 using decoder 361
9859 // 461: }
9860 32, 33, // 466: case 0x20: {
9861 OPC_SwitchField, 16, 10, // 468: switch Inst[25:16] {
9862 160, 4, 7, // 471: case 0x220: {
9863 OPC_CheckPredicate, 101, // 474: check predicate 101
9864 OPC_Decode, 176, 10, 140, 3, // 476: decode to CVT_S_D64 using decoder 396
9865 // 476: }
9866 160, 5, 7, // 481: case 0x2a0: {
9867 OPC_CheckPredicate, 109, // 484: check predicate 109
9868 OPC_Decode, 178, 10, 140, 3, // 486: decode to CVT_S_L using decoder 396
9869 // 486: }
9870 192, 5, 0, // 491: case 0x2c0: {
9871 OPC_CheckPredicate, 103, // 494: check predicate 103
9872 OPC_Decode, 181, 10, 140, 3, // 496: decode to CVT_S_PU64 using decoder 396
9873 // 496: }
9874 // 496: } // switch Inst[25:16]
9875 // 496: }
9876 33, 33, // 501: case 0x21: {
9877 OPC_SwitchField, 16, 10, // 503: switch Inst[25:16] {
9878 128, 4, 7, // 506: case 0x200: {
9879 OPC_CheckPredicate, 101, // 509: check predicate 101
9880 OPC_Decode, 160, 10, 225, 1, // 511: decode to CVT_D64_S using decoder 225
9881 // 511: }
9882 128, 5, 7, // 516: case 0x280: {
9883 OPC_CheckPredicate, 101, // 519: check predicate 101
9884 OPC_Decode, 162, 10, 225, 1, // 521: decode to CVT_D64_W using decoder 225
9885 // 521: }
9886 160, 5, 0, // 526: case 0x2a0: {
9887 OPC_CheckPredicate, 109, // 529: check predicate 109
9888 OPC_Decode, 159, 10, 232, 1, // 531: decode to CVT_D64_L using decoder 232
9889 // 531: }
9890 // 531: } // switch Inst[25:16]
9891 // 531: }
9892 36, 23, // 536: case 0x24: {
9893 OPC_SwitchField, 16, 10, // 538: switch Inst[25:16] {
9894 160, 4, 7, // 541: case 0x220: {
9895 OPC_CheckPredicate, 101, // 544: check predicate 101
9896 OPC_Decode, 187, 10, 140, 3, // 546: decode to CVT_W_D64 using decoder 396
9897 // 546: }
9898 192, 5, 0, // 551: case 0x2c0: {
9899 OPC_CheckPredicate, 108, // 554: check predicate 108
9900 OPC_Decode, 173, 10, 232, 1, // 556: decode to CVT_PW_PS64 using decoder 232
9901 // 556: }
9902 // 556: } // switch Inst[25:16]
9903 // 556: }
9904 38, 25, // 561: case 0x26: {
9905 OPC_SwitchField, 21, 5, // 563: switch Inst[25:21] {
9906 16, 7, // 566: case 0x10: {
9907 OPC_CheckPredicate, 103, // 568: check predicate 103
9908 OPC_Decode, 172, 10, 143, 3, // 570: decode to CVT_PS_S64 using decoder 399
9909 // 570: }
9910 20, 0, // 575: case 0x14: {
9911 OPC_CheckPredicate, 108, // 577: check predicate 108
9912 OPC_CheckField, 16, 5, 0, // 579: check Inst[20:16] == 0x0
9913 OPC_Decode, 171, 10, 232, 1, // 583: decode to CVT_PS_PW64 using decoder 232
9914 // 583: }
9915 // 583: } // switch Inst[25:21]
9916 // 583: }
9917 40, 12, // 588: case 0x28: {
9918 OPC_CheckPredicate, 103, // 590: check predicate 103
9919 OPC_CheckField, 16, 10, 192, 5, // 592: check Inst[25:16] == 0x2c0
9920 OPC_Decode, 180, 10, 140, 3, // 597: decode to CVT_S_PL64 using decoder 396
9921 // 597: }
9922 44, 11, // 602: case 0x2c: {
9923 OPC_CheckPredicate, 103, // 604: check predicate 103
9924 OPC_CheckField, 21, 5, 22, // 606: check Inst[25:21] == 0x16
9925 OPC_Decode, 210, 18, 233, 2, // 610: decode to PLL_PS64 using decoder 361
9926 // 610: }
9927 45, 11, // 615: case 0x2d: {
9928 OPC_CheckPredicate, 103, // 617: check predicate 103
9929 OPC_CheckField, 21, 5, 22, // 619: check Inst[25:21] == 0x16
9930 OPC_Decode, 211, 18, 233, 2, // 623: decode to PLU_PS64 using decoder 361
9931 // 623: }
9932 46, 11, // 628: case 0x2e: {
9933 OPC_CheckPredicate, 103, // 630: check predicate 103
9934 OPC_CheckField, 21, 5, 22, // 632: check Inst[25:21] == 0x16
9935 OPC_Decode, 128, 19, 233, 2, // 636: decode to PUL_PS64 using decoder 361
9936 // 636: }
9937 47, 11, // 641: case 0x2f: {
9938 OPC_CheckPredicate, 103, // 643: check predicate 103
9939 OPC_CheckField, 21, 5, 22, // 645: check Inst[25:21] == 0x16
9940 OPC_Decode, 129, 19, 233, 2, // 649: decode to PUU_PS64 using decoder 361
9941 // 649: }
9942 48, 15, // 654: case 0x30: {
9943 OPC_CheckPredicate, 110, // 656: check predicate 110
9944 OPC_CheckField, 21, 5, 17, // 658: check Inst[25:21] == 0x11
9945 OPC_CheckField, 6, 2, 0, // 662: check Inst[7:6] == 0x0
9946 OPC_Decode, 200, 10, 144, 3, // 666: decode to C_F_D64 using decoder 400
9947 // 666: }
9948 49, 15, // 671: case 0x31: {
9949 OPC_CheckPredicate, 110, // 673: check predicate 110
9950 OPC_CheckField, 21, 5, 17, // 675: check Inst[25:21] == 0x11
9951 OPC_CheckField, 6, 2, 0, // 679: check Inst[7:6] == 0x0
9952 OPC_Decode, 156, 11, 144, 3, // 683: decode to C_UN_D64 using decoder 400
9953 // 683: }
9954 50, 15, // 688: case 0x32: {
9955 OPC_CheckPredicate, 110, // 690: check predicate 110
9956 OPC_CheckField, 21, 5, 17, // 692: check Inst[25:21] == 0x11
9957 OPC_CheckField, 6, 2, 0, // 696: check Inst[7:6] == 0x0
9958 OPC_Decode, 194, 10, 144, 3, // 700: decode to C_EQ_D64 using decoder 400
9959 // 700: }
9960 51, 15, // 705: case 0x33: {
9961 OPC_CheckPredicate, 110, // 707: check predicate 110
9962 OPC_CheckField, 21, 5, 17, // 709: check Inst[25:21] == 0x11
9963 OPC_CheckField, 6, 2, 0, // 713: check Inst[7:6] == 0x0
9964 OPC_Decode, 138, 11, 144, 3, // 717: decode to C_UEQ_D64 using decoder 400
9965 // 717: }
9966 52, 15, // 722: case 0x34: {
9967 OPC_CheckPredicate, 110, // 724: check predicate 110
9968 OPC_CheckField, 21, 5, 17, // 726: check Inst[25:21] == 0x11
9969 OPC_CheckField, 6, 2, 0, // 730: check Inst[7:6] == 0x0
9970 OPC_Decode, 248, 10, 144, 3, // 734: decode to C_OLT_D64 using decoder 400
9971 // 734: }
9972 53, 15, // 739: case 0x35: {
9973 OPC_CheckPredicate, 110, // 741: check predicate 110
9974 OPC_CheckField, 21, 5, 17, // 743: check Inst[25:21] == 0x11
9975 OPC_CheckField, 6, 2, 0, // 747: check Inst[7:6] == 0x0
9976 OPC_Decode, 150, 11, 144, 3, // 751: decode to C_ULT_D64 using decoder 400
9977 // 751: }
9978 54, 15, // 756: case 0x36: {
9979 OPC_CheckPredicate, 110, // 758: check predicate 110
9980 OPC_CheckField, 21, 5, 17, // 760: check Inst[25:21] == 0x11
9981 OPC_CheckField, 6, 2, 0, // 764: check Inst[7:6] == 0x0
9982 OPC_Decode, 242, 10, 144, 3, // 768: decode to C_OLE_D64 using decoder 400
9983 // 768: }
9984 55, 15, // 773: case 0x37: {
9985 OPC_CheckPredicate, 110, // 775: check predicate 110
9986 OPC_CheckField, 21, 5, 17, // 777: check Inst[25:21] == 0x11
9987 OPC_CheckField, 6, 2, 0, // 781: check Inst[7:6] == 0x0
9988 OPC_Decode, 144, 11, 144, 3, // 785: decode to C_ULE_D64 using decoder 400
9989 // 785: }
9990 56, 15, // 790: case 0x38: {
9991 OPC_CheckPredicate, 110, // 792: check predicate 110
9992 OPC_CheckField, 21, 5, 17, // 794: check Inst[25:21] == 0x11
9993 OPC_CheckField, 6, 2, 0, // 798: check Inst[7:6] == 0x0
9994 OPC_Decode, 132, 11, 144, 3, // 802: decode to C_SF_D64 using decoder 400
9995 // 802: }
9996 57, 15, // 807: case 0x39: {
9997 OPC_CheckPredicate, 110, // 809: check predicate 110
9998 OPC_CheckField, 21, 5, 17, // 811: check Inst[25:21] == 0x11
9999 OPC_CheckField, 6, 2, 0, // 815: check Inst[7:6] == 0x0
10000 OPC_Decode, 224, 10, 144, 3, // 819: decode to C_NGLE_D64 using decoder 400
10001 // 819: }
10002 58, 15, // 824: case 0x3a: {
10003 OPC_CheckPredicate, 110, // 826: check predicate 110
10004 OPC_CheckField, 21, 5, 17, // 828: check Inst[25:21] == 0x11
10005 OPC_CheckField, 6, 2, 0, // 832: check Inst[7:6] == 0x0
10006 OPC_Decode, 254, 10, 144, 3, // 836: decode to C_SEQ_D64 using decoder 400
10007 // 836: }
10008 59, 15, // 841: case 0x3b: {
10009 OPC_CheckPredicate, 110, // 843: check predicate 110
10010 OPC_CheckField, 21, 5, 17, // 845: check Inst[25:21] == 0x11
10011 OPC_CheckField, 6, 2, 0, // 849: check Inst[7:6] == 0x0
10012 OPC_Decode, 230, 10, 144, 3, // 853: decode to C_NGL_D64 using decoder 400
10013 // 853: }
10014 60, 15, // 858: case 0x3c: {
10015 OPC_CheckPredicate, 110, // 860: check predicate 110
10016 OPC_CheckField, 21, 5, 17, // 862: check Inst[25:21] == 0x11
10017 OPC_CheckField, 6, 2, 0, // 866: check Inst[7:6] == 0x0
10018 OPC_Decode, 212, 10, 144, 3, // 870: decode to C_LT_D64 using decoder 400
10019 // 870: }
10020 61, 15, // 875: case 0x3d: {
10021 OPC_CheckPredicate, 110, // 877: check predicate 110
10022 OPC_CheckField, 21, 5, 17, // 879: check Inst[25:21] == 0x11
10023 OPC_CheckField, 6, 2, 0, // 883: check Inst[7:6] == 0x0
10024 OPC_Decode, 218, 10, 144, 3, // 887: decode to C_NGE_D64 using decoder 400
10025 // 887: }
10026 62, 15, // 892: case 0x3e: {
10027 OPC_CheckPredicate, 110, // 894: check predicate 110
10028 OPC_CheckField, 21, 5, 17, // 896: check Inst[25:21] == 0x11
10029 OPC_CheckField, 6, 2, 0, // 900: check Inst[7:6] == 0x0
10030 OPC_Decode, 206, 10, 144, 3, // 904: decode to C_LE_D64 using decoder 400
10031 // 904: }
10032 63, 0, // 909: case 0x3f: {
10033 OPC_CheckPredicate, 110, // 911: check predicate 110
10034 OPC_CheckField, 21, 5, 17, // 913: check Inst[25:21] == 0x11
10035 OPC_CheckField, 6, 2, 0, // 917: check Inst[7:6] == 0x0
10036 OPC_Decode, 236, 10, 144, 3, // 921: decode to C_NGT_D64 using decoder 400
10037 // 921: }
10038 // 921: } // switch Inst[5:0]
10039 // 921: }
10040 19, 91, // 926: case 0x13: {
10041 OPC_SwitchField, 0, 6, // 928: switch Inst[5:0] {
10042 1, 11, // 931: case 0x1: {
10043 OPC_CheckPredicate, 111, // 933: check predicate 111
10044 OPC_CheckField, 11, 5, 0, // 935: check Inst[15:11] == 0x0
10045 OPC_Decode, 137, 15, 145, 3, // 939: decode to LDXC164 using decoder 401
10046 // 939: }
10047 5, 11, // 944: case 0x5: {
10048 OPC_CheckPredicate, 112, // 946: check predicate 112
10049 OPC_CheckField, 11, 5, 0, // 948: check Inst[15:11] == 0x0
10050 OPC_Decode, 175, 15, 145, 3, // 952: decode to LUXC164 using decoder 401
10051 // 952: }
10052 9, 11, // 957: case 0x9: {
10053 OPC_CheckPredicate, 111, // 959: check predicate 111
10054 OPC_CheckField, 6, 5, 0, // 961: check Inst[10:6] == 0x0
10055 OPC_Decode, 229, 19, 146, 3, // 965: decode to SDXC164 using decoder 402
10056 // 965: }
10057 13, 11, // 970: case 0xd: {
10058 OPC_CheckPredicate, 112, // 972: check predicate 112
10059 OPC_CheckField, 6, 5, 0, // 974: check Inst[10:6] == 0x0
10060 OPC_Decode, 216, 21, 146, 3, // 978: decode to SUXC164 using decoder 402
10061 // 978: }
10062 33, 7, // 983: case 0x21: {
10063 OPC_CheckPredicate, 113, // 985: check predicate 113
10064 OPC_Decode, 249, 15, 147, 3, // 987: decode to MADD_D64 using decoder 403
10065 // 987: }
10066 41, 7, // 992: case 0x29: {
10067 OPC_CheckPredicate, 113, // 994: check predicate 113
10068 OPC_Decode, 173, 17, 147, 3, // 996: decode to MSUB_D64 using decoder 403
10069 // 996: }
10070 49, 7, // 1001: case 0x31: {
10071 OPC_CheckPredicate, 114, // 1003: check predicate 114
10072 OPC_Decode, 158, 18, 147, 3, // 1005: decode to NMADD_D64 using decoder 403
10073 // 1005: }
10074 57, 0, // 1010: case 0x39: {
10075 OPC_CheckPredicate, 114, // 1012: check predicate 114
10076 OPC_Decode, 163, 18, 147, 3, // 1014: decode to NMSUB_D64 using decoder 403
10077 // 1014: }
10078 // 1014: } // switch Inst[5:0]
10079 // 1014: }
10080 53, 7, // 1019: case 0x35: {
10081 OPC_CheckPredicate, 104, // 1021: check predicate 104
10082 OPC_Decode, 249, 14, 222, 2, // 1023: decode to LDC164 using decoder 350
10083 // 1023: }
10084 61, 0, // 1028: case 0x3d: {
10085 OPC_CheckPredicate, 104, // 1030: check predicate 104
10086 OPC_Decode, 216, 19, 222, 2, // 1032: decode to SDC164 using decoder 350
10087 // 1032: }
10088 // 1032: } // switch Inst[31:26]
10089};
10090// Handling 404 cases.
10091template <typename InsnType>
10092static DecodeStatus decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
10093 DecodeComplete = true;
10094 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
10095 TmpType tmp;
10096 switch (Idx) {
10097 default: llvm_unreachable("Invalid decoder index!");
10098 case 0:
10099 tmp = fieldFromInstruction(insn, 0, 11);
10100 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10101 return S;
10102 case 1:
10103 tmp = fieldFromInstruction(insn, 8, 3);
10104 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10105 tmp = fieldFromInstruction(insn, 0, 8);
10106 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10107 return S;
10108 case 2:
10109 tmp = fieldFromInstruction(insn, 8, 3);
10110 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10111 tmp = fieldFromInstruction(insn, 8, 3);
10112 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10113 tmp = fieldFromInstruction(insn, 0, 8);
10114 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10115 return S;
10116 case 3:
10117 tmp = fieldFromInstruction(insn, 8, 3);
10118 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10119 tmp = fieldFromInstruction(insn, 0, 8);
10120 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10121 return S;
10122 case 4:
10123 tmp = fieldFromInstruction(insn, 0, 8);
10124 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10125 return S;
10126 case 5:
10127 tmp = 0x0;
10128 tmp |= fieldFromInstruction(insn, 3, 2) << 3;
10129 tmp |= fieldFromInstruction(insn, 5, 3);
10130 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10131 tmp = fieldFromInstruction(insn, 0, 3);
10132 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10133 return S;
10134 case 6:
10135 tmp = fieldFromInstruction(insn, 4, 4);
10136 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10137 tmp = fieldFromInstruction(insn, 0, 4);
10138 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10139 return S;
10140 case 7:
10141 tmp = fieldFromInstruction(insn, 8, 3);
10142 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10143 tmp = fieldFromInstruction(insn, 0, 8);
10144 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10145 return S;
10146 case 8:
10147 tmp = fieldFromInstruction(insn, 2, 3);
10148 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10149 tmp = fieldFromInstruction(insn, 8, 3);
10150 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10151 tmp = fieldFromInstruction(insn, 5, 3);
10152 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10153 return S;
10154 case 9:
10155 tmp = fieldFromInstruction(insn, 8, 3);
10156 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10157 return S;
10158 case 10:
10159 return S;
10160 case 11:
10161 tmp = fieldFromInstruction(insn, 8, 3);
10162 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10163 tmp = fieldFromInstruction(insn, 5, 3);
10164 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10165 return S;
10166 case 12:
10167 tmp = fieldFromInstruction(insn, 8, 3);
10168 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10169 tmp = fieldFromInstruction(insn, 8, 3);
10170 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10171 tmp = fieldFromInstruction(insn, 5, 3);
10172 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10173 return S;
10174 case 13:
10175 tmp = fieldFromInstruction(insn, 8, 3);
10176 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10177 tmp = fieldFromInstruction(insn, 8, 3);
10178 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10179 return S;
10180 case 14:
10181 tmp = fieldFromInstruction(insn, 7, 3);
10182 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10183 tmp = fieldFromInstruction(insn, 1, 3);
10184 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10185 tmp = fieldFromInstruction(insn, 4, 3);
10186 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10187 return S;
10188 case 15:
10189 if (!Check(S, DecodeMemMMImm4(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10190 return S;
10191 case 16:
10192 tmp = fieldFromInstruction(insn, 5, 5);
10193 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10194 tmp = fieldFromInstruction(insn, 0, 5);
10195 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10196 return S;
10197 case 17:
10198 tmp = fieldFromInstruction(insn, 7, 3);
10199 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10200 tmp = fieldFromInstruction(insn, 4, 3);
10201 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10202 tmp = fieldFromInstruction(insn, 1, 3);
10203 if (!Check(S, DecodePOOL16BEncodedField(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10204 return S;
10205 case 18:
10206 tmp = fieldFromInstruction(insn, 7, 3);
10207 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10208 tmp = fieldFromInstruction(insn, 4, 3);
10209 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10210 tmp = fieldFromInstruction(insn, 0, 4);
10211 if (!Check(S, DecodeANDI16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10212 return S;
10213 case 19:
10214 tmp = fieldFromInstruction(insn, 3, 3);
10215 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10216 tmp = fieldFromInstruction(insn, 0, 3);
10217 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10218 return S;
10219 case 20:
10220 tmp = fieldFromInstruction(insn, 3, 3);
10221 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10222 tmp = fieldFromInstruction(insn, 0, 3);
10223 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10224 tmp = fieldFromInstruction(insn, 3, 3);
10225 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10226 return S;
10227 case 21:
10228 if (!Check(S, DecodeMemMMReglistImm4Lsl2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10229 return S;
10230 case 22:
10231 tmp = fieldFromInstruction(insn, 0, 5);
10232 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10233 return S;
10234 case 23:
10235 tmp = fieldFromInstruction(insn, 0, 4);
10236 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10237 return S;
10238 case 24:
10239 tmp = fieldFromInstruction(insn, 0, 5);
10240 if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10241 return S;
10242 case 25:
10243 if (!Check(S, DecodeMemMMSPImm5Lsl2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10244 return S;
10245 case 26:
10246 tmp = fieldFromInstruction(insn, 5, 5);
10247 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10248 tmp = fieldFromInstruction(insn, 5, 5);
10249 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10250 tmp = fieldFromInstruction(insn, 1, 4);
10251 if (!Check(S, DecodeSImmWithOffsetAndScale<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10252 return S;
10253 case 27:
10254 tmp = fieldFromInstruction(insn, 1, 9);
10255 if (!Check(S, DecodeSimm9SP(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10256 return S;
10257 case 28:
10258 if (!Check(S, DecodeMemMMGPImm7Lsl2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10259 return S;
10260 case 29:
10261 tmp = fieldFromInstruction(insn, 7, 3);
10262 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10263 tmp = fieldFromInstruction(insn, 4, 3);
10264 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10265 tmp = fieldFromInstruction(insn, 1, 3);
10266 if (!Check(S, DecodeAddiur2Simm7(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10267 return S;
10268 case 30:
10269 tmp = fieldFromInstruction(insn, 7, 3);
10270 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10271 tmp = fieldFromInstruction(insn, 1, 6);
10272 if (!Check(S, DecodeUImmWithOffsetAndScale<6, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10273 return S;
10274 case 31:
10275 if (!Check(S, DecodeMovePOperands(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10276 return S;
10277 case 32:
10278 tmp = fieldFromInstruction(insn, 7, 3);
10279 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10280 tmp = fieldFromInstruction(insn, 0, 7);
10281 if (!Check(S, DecodeBranchTarget7MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10282 return S;
10283 case 33:
10284 tmp = fieldFromInstruction(insn, 0, 10);
10285 if (!Check(S, DecodeBranchTarget10MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10286 return S;
10287 case 34:
10288 tmp = fieldFromInstruction(insn, 7, 3);
10289 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10290 tmp = fieldFromInstruction(insn, 0, 7);
10291 if (!Check(S, DecodeLi16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10292 return S;
10293 case 35:
10294 tmp = fieldFromInstruction(insn, 1, 3);
10295 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10296 tmp = fieldFromInstruction(insn, 7, 3);
10297 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10298 tmp = fieldFromInstruction(insn, 4, 3);
10299 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10300 return S;
10301 case 36:
10302 tmp = fieldFromInstruction(insn, 7, 3);
10303 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10304 tmp = fieldFromInstruction(insn, 4, 3);
10305 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10306 return S;
10307 case 37:
10308 tmp = fieldFromInstruction(insn, 7, 3);
10309 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10310 tmp = fieldFromInstruction(insn, 4, 3);
10311 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10312 tmp = fieldFromInstruction(insn, 7, 3);
10313 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10314 return S;
10315 case 38:
10316 tmp = fieldFromInstruction(insn, 5, 5);
10317 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10318 return S;
10319 case 39:
10320 tmp = fieldFromInstruction(insn, 5, 5);
10321 if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10322 return S;
10323 case 40:
10324 tmp = fieldFromInstruction(insn, 6, 4);
10325 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10326 return S;
10327 case 41:
10328 tmp = fieldFromInstruction(insn, 8, 3);
10329 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10330 tmp = 0x0;
10331 tmp |= fieldFromInstruction(insn, 0, 5);
10332 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
10333 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
10334 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10335 return S;
10336 case 42:
10337 tmp = 0x0;
10338 tmp |= fieldFromInstruction(insn, 0, 5);
10339 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
10340 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
10341 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10342 return S;
10343 case 43:
10344 tmp = fieldFromInstruction(insn, 8, 3);
10345 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10346 tmp = 0x0;
10347 tmp |= fieldFromInstruction(insn, 0, 5);
10348 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
10349 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
10350 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10351 return S;
10352 case 44:
10353 tmp = fieldFromInstruction(insn, 8, 3);
10354 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10355 tmp = fieldFromInstruction(insn, 5, 3);
10356 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10357 tmp = 0x0;
10358 tmp |= fieldFromInstruction(insn, 21, 1) << 5;
10359 tmp |= fieldFromInstruction(insn, 22, 5);
10360 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10361 return S;
10362 case 45:
10363 tmp = 0x0;
10364 tmp |= fieldFromInstruction(insn, 0, 5);
10365 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
10366 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
10367 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10368 return S;
10369 case 46:
10370 if (!Check(S, DecodeFIXMEInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10371 return S;
10372 case 47:
10373 tmp = fieldFromInstruction(insn, 8, 3);
10374 if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10375 tmp = 0x0;
10376 tmp |= fieldFromInstruction(insn, 0, 5);
10377 tmp |= fieldFromInstruction(insn, 16, 5) << 11;
10378 tmp |= fieldFromInstruction(insn, 21, 6) << 5;
10379 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10380 return S;
10381 case 48:
10382 if (!Check(S, DecodeFMem3(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10383 return S;
10384 case 49:
10385 tmp = fieldFromInstruction(insn, 16, 5);
10386 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10387 tmp = fieldFromInstruction(insn, 0, 16);
10388 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10389 return S;
10390 case 50:
10391 tmp = fieldFromInstruction(insn, 11, 5);
10392 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10393 tmp = fieldFromInstruction(insn, 21, 5);
10394 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10395 tmp = fieldFromInstruction(insn, 16, 5);
10396 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10397 return S;
10398 case 51:
10399 tmp = fieldFromInstruction(insn, 21, 5);
10400 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10401 return S;
10402 case 52:
10403 tmp = fieldFromInstruction(insn, 11, 5);
10404 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10405 tmp = fieldFromInstruction(insn, 21, 5);
10406 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10407 return S;
10408 case 53:
10409 tmp = fieldFromInstruction(insn, 11, 5);
10410 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10411 tmp = fieldFromInstruction(insn, 21, 5);
10412 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10413 return S;
10414 case 54:
10415 tmp = fieldFromInstruction(insn, 16, 5);
10416 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10417 tmp = fieldFromInstruction(insn, 21, 5);
10418 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10419 tmp = fieldFromInstruction(insn, 6, 10);
10420 if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10421 return S;
10422 case 55:
10423 tmp = fieldFromInstruction(insn, 16, 5);
10424 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10425 tmp = fieldFromInstruction(insn, 21, 5);
10426 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10427 tmp = fieldFromInstruction(insn, 6, 5);
10428 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10429 tmp = fieldFromInstruction(insn, 11, 5);
10430 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10431 return S;
10432 case 56:
10433 tmp = fieldFromInstruction(insn, 21, 5);
10434 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10435 tmp = fieldFromInstruction(insn, 16, 5);
10436 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10437 tmp = fieldFromInstruction(insn, 0, 16);
10438 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10439 return S;
10440 case 57:
10441 tmp = fieldFromInstruction(insn, 16, 5);
10442 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10443 tmp = fieldFromInstruction(insn, 21, 5);
10444 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10445 return S;
10446 case 58:
10447 tmp = fieldFromInstruction(insn, 21, 5);
10448 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10449 tmp = fieldFromInstruction(insn, 16, 5);
10450 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10451 tmp = fieldFromInstruction(insn, 11, 5);
10452 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10453 return S;
10454 case 59:
10455 tmp = fieldFromInstruction(insn, 16, 5);
10456 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10457 tmp = fieldFromInstruction(insn, 21, 5);
10458 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10459 return S;
10460 case 60:
10461 tmp = fieldFromInstruction(insn, 11, 5);
10462 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10463 tmp = fieldFromInstruction(insn, 16, 5);
10464 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10465 tmp = fieldFromInstruction(insn, 21, 5);
10466 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10467 return S;
10468 case 61:
10469 tmp = fieldFromInstruction(insn, 11, 5);
10470 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10471 tmp = fieldFromInstruction(insn, 16, 5);
10472 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10473 tmp = fieldFromInstruction(insn, 21, 5);
10474 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10475 return S;
10476 case 62:
10477 tmp = fieldFromInstruction(insn, 16, 10);
10478 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10479 tmp = fieldFromInstruction(insn, 6, 10);
10480 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10481 return S;
10482 case 63:
10483 tmp = fieldFromInstruction(insn, 21, 5);
10484 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10485 tmp = fieldFromInstruction(insn, 16, 5);
10486 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10487 tmp = fieldFromInstruction(insn, 6, 5);
10488 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10489 tmp = fieldFromInstruction(insn, 11, 5);
10490 if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10491 tmp = fieldFromInstruction(insn, 21, 5);
10492 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10493 return S;
10494 case 64:
10495 tmp = fieldFromInstruction(insn, 11, 5);
10496 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10497 tmp = fieldFromInstruction(insn, 16, 5);
10498 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10499 tmp = fieldFromInstruction(insn, 21, 5);
10500 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10501 return S;
10502 case 65:
10503 tmp = fieldFromInstruction(insn, 11, 5);
10504 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10505 tmp = fieldFromInstruction(insn, 21, 5);
10506 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10507 tmp = fieldFromInstruction(insn, 16, 5);
10508 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10509 return S;
10510 case 66:
10511 tmp = fieldFromInstruction(insn, 21, 5);
10512 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10513 tmp = fieldFromInstruction(insn, 16, 5);
10514 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10515 tmp = fieldFromInstruction(insn, 11, 5);
10516 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10517 tmp = fieldFromInstruction(insn, 21, 5);
10518 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10519 return S;
10520 case 67:
10521 tmp = fieldFromInstruction(insn, 11, 5);
10522 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10523 tmp = fieldFromInstruction(insn, 21, 5);
10524 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10525 tmp = fieldFromInstruction(insn, 16, 5);
10526 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10527 return S;
10528 case 68:
10529 tmp = fieldFromInstruction(insn, 21, 5);
10530 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10531 tmp = fieldFromInstruction(insn, 16, 5);
10532 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10533 tmp = fieldFromInstruction(insn, 11, 5);
10534 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10535 tmp = fieldFromInstruction(insn, 21, 5);
10536 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10537 return S;
10538 case 69:
10539 tmp = fieldFromInstruction(insn, 11, 5);
10540 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10541 tmp = fieldFromInstruction(insn, 16, 5);
10542 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10543 tmp = fieldFromInstruction(insn, 21, 5);
10544 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10545 tmp = fieldFromInstruction(insn, 11, 5);
10546 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10547 return S;
10548 case 70:
10549 tmp = fieldFromInstruction(insn, 11, 5);
10550 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10551 tmp = fieldFromInstruction(insn, 16, 5);
10552 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10553 tmp = fieldFromInstruction(insn, 21, 5);
10554 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10555 return S;
10556 case 71:
10557 tmp = fieldFromInstruction(insn, 14, 2);
10558 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10559 tmp = fieldFromInstruction(insn, 16, 6);
10560 if (!Check(S, DecodeSImmWithOffsetAndScale<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10561 tmp = fieldFromInstruction(insn, 14, 2);
10562 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10563 return S;
10564 case 72:
10565 tmp = fieldFromInstruction(insn, 21, 5);
10566 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10567 tmp = fieldFromInstruction(insn, 16, 5);
10568 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10569 tmp = fieldFromInstruction(insn, 6, 5);
10570 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10571 tmp = fieldFromInstruction(insn, 11, 5);
10572 if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10573 return S;
10574 case 73:
10575 tmp = fieldFromInstruction(insn, 11, 5);
10576 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10577 tmp = fieldFromInstruction(insn, 16, 5);
10578 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10579 tmp = fieldFromInstruction(insn, 21, 5);
10580 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10581 return S;
10582 case 74:
10583 tmp = fieldFromInstruction(insn, 21, 5);
10584 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10585 tmp = fieldFromInstruction(insn, 16, 5);
10586 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10587 tmp = fieldFromInstruction(insn, 11, 3);
10588 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10589 return S;
10590 case 75:
10591 tmp = fieldFromInstruction(insn, 16, 5);
10592 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10593 tmp = fieldFromInstruction(insn, 21, 5);
10594 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10595 tmp = fieldFromInstruction(insn, 11, 3);
10596 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10597 return S;
10598 case 76:
10599 tmp = fieldFromInstruction(insn, 21, 5);
10600 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10601 tmp = fieldFromInstruction(insn, 16, 5);
10602 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10603 tmp = fieldFromInstruction(insn, 12, 4);
10604 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10605 return S;
10606 case 77:
10607 tmp = fieldFromInstruction(insn, 16, 5);
10608 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10609 tmp = fieldFromInstruction(insn, 21, 5);
10610 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10611 tmp = fieldFromInstruction(insn, 12, 4);
10612 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10613 return S;
10614 case 78:
10615 tmp = fieldFromInstruction(insn, 16, 5);
10616 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10617 tmp = fieldFromInstruction(insn, 14, 2);
10618 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10619 return S;
10620 case 79:
10621 tmp = fieldFromInstruction(insn, 14, 2);
10622 if (!Check(S, DecodeHI32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10623 tmp = fieldFromInstruction(insn, 16, 5);
10624 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10625 return S;
10626 case 80:
10627 tmp = fieldFromInstruction(insn, 21, 5);
10628 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10629 tmp = fieldFromInstruction(insn, 16, 5);
10630 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10631 tmp = fieldFromInstruction(insn, 13, 3);
10632 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10633 return S;
10634 case 81:
10635 tmp = fieldFromInstruction(insn, 14, 2);
10636 if (!Check(S, DecodeLO32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10637 tmp = fieldFromInstruction(insn, 16, 5);
10638 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10639 return S;
10640 case 82:
10641 tmp = fieldFromInstruction(insn, 14, 2);
10642 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10643 tmp = fieldFromInstruction(insn, 16, 5);
10644 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10645 tmp = fieldFromInstruction(insn, 21, 5);
10646 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10647 tmp = fieldFromInstruction(insn, 14, 2);
10648 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10649 return S;
10650 case 83:
10651 tmp = fieldFromInstruction(insn, 21, 5);
10652 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10653 tmp = fieldFromInstruction(insn, 16, 5);
10654 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10655 tmp = fieldFromInstruction(insn, 14, 2);
10656 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10657 tmp = fieldFromInstruction(insn, 21, 5);
10658 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10659 return S;
10660 case 84:
10661 tmp = fieldFromInstruction(insn, 21, 5);
10662 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10663 tmp = fieldFromInstruction(insn, 14, 2);
10664 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10665 tmp = fieldFromInstruction(insn, 16, 5);
10666 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10667 return S;
10668 case 85:
10669 tmp = fieldFromInstruction(insn, 21, 5);
10670 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10671 tmp = fieldFromInstruction(insn, 16, 5);
10672 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10673 return S;
10674 case 86:
10675 tmp = fieldFromInstruction(insn, 21, 5);
10676 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10677 tmp = fieldFromInstruction(insn, 16, 5);
10678 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10679 return S;
10680 case 87:
10681 tmp = fieldFromInstruction(insn, 21, 5);
10682 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10683 tmp = fieldFromInstruction(insn, 21, 5);
10684 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10685 tmp = fieldFromInstruction(insn, 16, 5);
10686 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10687 return S;
10688 case 88:
10689 tmp = fieldFromInstruction(insn, 21, 5);
10690 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10691 tmp = fieldFromInstruction(insn, 16, 5);
10692 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10693 return S;
10694 case 89:
10695 tmp = fieldFromInstruction(insn, 14, 2);
10696 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10697 tmp = fieldFromInstruction(insn, 16, 5);
10698 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10699 tmp = fieldFromInstruction(insn, 14, 2);
10700 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10701 return S;
10702 case 90:
10703 tmp = fieldFromInstruction(insn, 14, 2);
10704 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10705 tmp = fieldFromInstruction(insn, 16, 5);
10706 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10707 tmp = fieldFromInstruction(insn, 21, 5);
10708 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10709 tmp = fieldFromInstruction(insn, 14, 2);
10710 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10711 return S;
10712 case 91:
10713 tmp = fieldFromInstruction(insn, 21, 5);
10714 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10715 tmp = fieldFromInstruction(insn, 16, 5);
10716 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10717 return S;
10718 case 92:
10719 tmp = fieldFromInstruction(insn, 21, 5);
10720 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10721 tmp = fieldFromInstruction(insn, 16, 5);
10722 if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10723 return S;
10724 case 93:
10725 tmp = fieldFromInstruction(insn, 16, 5);
10726 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10727 tmp = fieldFromInstruction(insn, 21, 5);
10728 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10729 return S;
10730 case 94:
10731 tmp = fieldFromInstruction(insn, 16, 5);
10732 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10733 return S;
10734 case 95:
10735 tmp = fieldFromInstruction(insn, 16, 10);
10736 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10737 return S;
10738 case 96:
10739 tmp = fieldFromInstruction(insn, 14, 2);
10740 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10741 tmp = fieldFromInstruction(insn, 16, 5);
10742 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10743 tmp = fieldFromInstruction(insn, 21, 5);
10744 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10745 return S;
10746 case 97:
10747 tmp = fieldFromInstruction(insn, 21, 5);
10748 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10749 tmp = fieldFromInstruction(insn, 16, 5);
10750 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10751 return S;
10752 case 98:
10753 tmp = fieldFromInstruction(insn, 16, 5);
10754 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10755 tmp = fieldFromInstruction(insn, 21, 5);
10756 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10757 return S;
10758 case 99:
10759 tmp = fieldFromInstruction(insn, 16, 5);
10760 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10761 return S;
10762 case 100:
10763 tmp = fieldFromInstruction(insn, 21, 5);
10764 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10765 tmp = fieldFromInstruction(insn, 13, 8);
10766 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10767 return S;
10768 case 101:
10769 tmp = fieldFromInstruction(insn, 21, 5);
10770 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10771 tmp = fieldFromInstruction(insn, 14, 7);
10772 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10773 return S;
10774 case 102:
10775 tmp = fieldFromInstruction(insn, 21, 5);
10776 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10777 tmp = fieldFromInstruction(insn, 14, 2);
10778 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10779 tmp = fieldFromInstruction(insn, 16, 5);
10780 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10781 return S;
10782 case 103:
10783 tmp = fieldFromInstruction(insn, 11, 5);
10784 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10785 tmp = fieldFromInstruction(insn, 16, 10);
10786 if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10787 return S;
10788 case 104:
10789 tmp = fieldFromInstruction(insn, 21, 5);
10790 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10791 tmp = fieldFromInstruction(insn, 16, 5);
10792 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10793 tmp = fieldFromInstruction(insn, 0, 16);
10794 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10795 return S;
10796 case 105:
10797 if (!Check(S, DecodeMemMMImm16(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10798 return S;
10799 case 106:
10800 if (!Check(S, DecodeMemMMImm12(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10801 return S;
10802 case 107:
10803 if (!Check(S, DecodeCacheOpMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10804 return S;
10805 case 108:
10806 tmp = fieldFromInstruction(insn, 16, 5);
10807 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10808 tmp = fieldFromInstruction(insn, 0, 16);
10809 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10810 return S;
10811 case 109:
10812 tmp = fieldFromInstruction(insn, 16, 5);
10813 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10814 tmp = fieldFromInstruction(insn, 0, 16);
10815 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10816 return S;
10817 case 110:
10818 tmp = fieldFromInstruction(insn, 16, 5);
10819 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10820 tmp = fieldFromInstruction(insn, 0, 16);
10821 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10822 return S;
10823 case 111:
10824 if (!Check(S, DecodeSyncI_MM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
10825 return S;
10826 case 112:
10827 tmp = fieldFromInstruction(insn, 0, 16);
10828 if (!Check(S, DecodeBranchTarget1SImm16(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10829 return S;
10830 case 113:
10831 tmp = fieldFromInstruction(insn, 0, 16);
10832 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10833 return S;
10834 case 114:
10835 tmp = fieldFromInstruction(insn, 18, 3);
10836 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10837 tmp = fieldFromInstruction(insn, 0, 16);
10838 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10839 return S;
10840 case 115:
10841 tmp = fieldFromInstruction(insn, 21, 5);
10842 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10843 tmp = fieldFromInstruction(insn, 16, 5);
10844 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10845 tmp = fieldFromInstruction(insn, 0, 16);
10846 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10847 return S;
10848 case 116:
10849 tmp = fieldFromInstruction(insn, 11, 5);
10850 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10851 tmp = fieldFromInstruction(insn, 6, 5);
10852 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10853 tmp = fieldFromInstruction(insn, 16, 5);
10854 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10855 tmp = fieldFromInstruction(insn, 21, 5);
10856 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10857 return S;
10858 case 117:
10859 tmp = fieldFromInstruction(insn, 11, 5);
10860 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10861 tmp = fieldFromInstruction(insn, 16, 5);
10862 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10863 tmp = fieldFromInstruction(insn, 21, 5);
10864 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10865 return S;
10866 case 118:
10867 tmp = fieldFromInstruction(insn, 11, 5);
10868 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10869 tmp = fieldFromInstruction(insn, 16, 5);
10870 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10871 tmp = fieldFromInstruction(insn, 21, 5);
10872 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10873 return S;
10874 case 119:
10875 tmp = fieldFromInstruction(insn, 11, 5);
10876 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10877 tmp = fieldFromInstruction(insn, 6, 5);
10878 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10879 tmp = fieldFromInstruction(insn, 16, 5);
10880 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10881 tmp = fieldFromInstruction(insn, 21, 5);
10882 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10883 return S;
10884 case 120:
10885 tmp = fieldFromInstruction(insn, 21, 5);
10886 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10887 tmp = fieldFromInstruction(insn, 16, 5);
10888 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10889 tmp = fieldFromInstruction(insn, 13, 3);
10890 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10891 tmp = fieldFromInstruction(insn, 21, 5);
10892 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10893 return S;
10894 case 121:
10895 tmp = fieldFromInstruction(insn, 16, 5);
10896 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10897 tmp = fieldFromInstruction(insn, 21, 5);
10898 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10899 tmp = fieldFromInstruction(insn, 11, 5);
10900 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
10901 return S;
10902 case 122:
10903 tmp = fieldFromInstruction(insn, 21, 5);
10904 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10905 tmp = fieldFromInstruction(insn, 16, 5);
10906 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10907 tmp = fieldFromInstruction(insn, 13, 3);
10908 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10909 tmp = fieldFromInstruction(insn, 21, 5);
10910 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10911 return S;
10912 case 123:
10913 tmp = fieldFromInstruction(insn, 11, 5);
10914 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10915 tmp = fieldFromInstruction(insn, 16, 5);
10916 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10917 tmp = fieldFromInstruction(insn, 21, 5);
10918 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10919 return S;
10920 case 124:
10921 tmp = fieldFromInstruction(insn, 11, 5);
10922 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10923 tmp = fieldFromInstruction(insn, 16, 5);
10924 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10925 tmp = fieldFromInstruction(insn, 21, 5);
10926 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10927 tmp = fieldFromInstruction(insn, 11, 5);
10928 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10929 return S;
10930 case 125:
10931 tmp = fieldFromInstruction(insn, 11, 5);
10932 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10933 tmp = fieldFromInstruction(insn, 16, 5);
10934 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10935 tmp = fieldFromInstruction(insn, 21, 5);
10936 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10937 tmp = fieldFromInstruction(insn, 11, 5);
10938 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10939 return S;
10940 case 126:
10941 tmp = fieldFromInstruction(insn, 21, 5);
10942 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10943 tmp = fieldFromInstruction(insn, 16, 5);
10944 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10945 return S;
10946 case 127:
10947 tmp = fieldFromInstruction(insn, 21, 5);
10948 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10949 tmp = fieldFromInstruction(insn, 16, 5);
10950 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10951 return S;
10952 case 128:
10953 tmp = fieldFromInstruction(insn, 21, 5);
10954 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10955 tmp = fieldFromInstruction(insn, 16, 5);
10956 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10957 return S;
10958 case 129:
10959 tmp = fieldFromInstruction(insn, 21, 5);
10960 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10961 tmp = fieldFromInstruction(insn, 16, 5);
10962 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10963 return S;
10964 case 130:
10965 tmp = fieldFromInstruction(insn, 21, 5);
10966 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10967 tmp = fieldFromInstruction(insn, 16, 5);
10968 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10969 tmp = fieldFromInstruction(insn, 13, 3);
10970 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10971 tmp = fieldFromInstruction(insn, 21, 5);
10972 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10973 return S;
10974 case 131:
10975 tmp = fieldFromInstruction(insn, 21, 5);
10976 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10977 tmp = fieldFromInstruction(insn, 16, 5);
10978 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10979 return S;
10980 case 132:
10981 tmp = fieldFromInstruction(insn, 16, 5);
10982 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10983 tmp = fieldFromInstruction(insn, 21, 5);
10984 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10985 return S;
10986 case 133:
10987 tmp = fieldFromInstruction(insn, 21, 5);
10988 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10989 tmp = fieldFromInstruction(insn, 16, 5);
10990 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10991 return S;
10992 case 134:
10993 tmp = fieldFromInstruction(insn, 21, 5);
10994 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10995 tmp = fieldFromInstruction(insn, 16, 5);
10996 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
10997 return S;
10998 case 135:
10999 tmp = fieldFromInstruction(insn, 21, 5);
11000 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11001 tmp = fieldFromInstruction(insn, 16, 5);
11002 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11003 return S;
11004 case 136:
11005 tmp = fieldFromInstruction(insn, 21, 5);
11006 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11007 tmp = fieldFromInstruction(insn, 16, 5);
11008 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11009 return S;
11010 case 137:
11011 tmp = fieldFromInstruction(insn, 16, 5);
11012 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11013 tmp = fieldFromInstruction(insn, 21, 5);
11014 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11015 return S;
11016 case 138:
11017 tmp = fieldFromInstruction(insn, 16, 5);
11018 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11019 tmp = fieldFromInstruction(insn, 16, 5);
11020 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11021 tmp = fieldFromInstruction(insn, 21, 5);
11022 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11023 return S;
11024 case 139:
11025 tmp = fieldFromInstruction(insn, 13, 3);
11026 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11027 tmp = fieldFromInstruction(insn, 16, 5);
11028 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11029 tmp = fieldFromInstruction(insn, 21, 5);
11030 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11031 return S;
11032 case 140:
11033 tmp = fieldFromInstruction(insn, 13, 3);
11034 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11035 tmp = fieldFromInstruction(insn, 16, 5);
11036 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11037 tmp = fieldFromInstruction(insn, 21, 5);
11038 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11039 return S;
11040 case 141:
11041 if (!Check(S, DecodeMemMMImm9(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11042 return S;
11043 case 142:
11044 if (!Check(S, DecodePrefeOpMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11045 return S;
11046 case 143:
11047 if (!Check(S, DecodeJumpTargetMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11048 return S;
11049 case 144:
11050 tmp = fieldFromInstruction(insn, 23, 3);
11051 if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11052 tmp = fieldFromInstruction(insn, 0, 23);
11053 if (!Check(S, DecodeSimm23Lsl2(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11054 return S;
11055 case 145:
11056 tmp = fieldFromInstruction(insn, 16, 5);
11057 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11058 tmp = fieldFromInstruction(insn, 21, 5);
11059 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11060 tmp = fieldFromInstruction(insn, 0, 16);
11061 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11062 return S;
11063 case 146:
11064 if (!Check(S, DecodeFMemMMR2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11065 return S;
11066 case 147:
11067 if (!Check(S, DecodeJumpTargetXMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11068 return S;
11069 case 148:
11070 if (!Check(S, DecodeMem(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11071 return S;
11072 case 149:
11073 tmp = fieldFromInstruction(insn, 16, 5);
11074 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11075 tmp = fieldFromInstruction(insn, 21, 5);
11076 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11077 return S;
11078 case 150:
11079 tmp = fieldFromInstruction(insn, 21, 5);
11080 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11081 tmp = fieldFromInstruction(insn, 16, 5);
11082 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11083 return S;
11084 case 151:
11085 tmp = fieldFromInstruction(insn, 16, 5);
11086 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11087 tmp = fieldFromInstruction(insn, 16, 5);
11088 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11089 tmp = fieldFromInstruction(insn, 21, 5);
11090 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11091 return S;
11092 case 152:
11093 tmp = fieldFromInstruction(insn, 11, 5);
11094 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11095 tmp = fieldFromInstruction(insn, 16, 5);
11096 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11097 tmp = fieldFromInstruction(insn, 21, 5);
11098 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11099 return S;
11100 case 153:
11101 tmp = fieldFromInstruction(insn, 21, 5);
11102 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11103 tmp = fieldFromInstruction(insn, 16, 5);
11104 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11105 return S;
11106 case 154:
11107 tmp = fieldFromInstruction(insn, 21, 5);
11108 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11109 tmp = fieldFromInstruction(insn, 16, 5);
11110 if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11111 tmp = fieldFromInstruction(insn, 11, 3);
11112 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11113 return S;
11114 case 155:
11115 tmp = fieldFromInstruction(insn, 11, 5);
11116 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11117 tmp = fieldFromInstruction(insn, 16, 5);
11118 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11119 tmp = fieldFromInstruction(insn, 21, 5);
11120 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11121 tmp = fieldFromInstruction(insn, 9, 2);
11122 if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11123 return S;
11124 case 156:
11125 tmp = fieldFromInstruction(insn, 11, 5);
11126 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11127 tmp = fieldFromInstruction(insn, 21, 5);
11128 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11129 tmp = fieldFromInstruction(insn, 16, 5);
11130 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11131 tmp = fieldFromInstruction(insn, 9, 2);
11132 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11133 return S;
11134 case 157:
11135 tmp = fieldFromInstruction(insn, 16, 5);
11136 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11137 tmp = fieldFromInstruction(insn, 9, 2);
11138 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11139 return S;
11140 case 158:
11141 tmp = fieldFromInstruction(insn, 6, 16);
11142 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11143 return S;
11144 case 159:
11145 tmp = fieldFromInstruction(insn, 21, 5);
11146 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11147 tmp = fieldFromInstruction(insn, 0, 16);
11148 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11149 return S;
11150 case 160:
11151 if (!Check(S, DecodeLoadByte15(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11152 return S;
11153 case 161:
11154 if (!Check(S, DecodeFMemCop2MMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11155 return S;
11156 case 162:
11157 tmp = fieldFromInstruction(insn, 16, 5);
11158 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11159 tmp = fieldFromInstruction(insn, 0, 16);
11160 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11161 return S;
11162 case 163:
11163 tmp = fieldFromInstruction(insn, 16, 5);
11164 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11165 tmp = fieldFromInstruction(insn, 0, 16);
11166 if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11167 return S;
11168 case 164:
11169 if (!Check(S, DecodeSynciR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11170 return S;
11171 case 165:
11172 tmp = fieldFromInstruction(insn, 11, 5);
11173 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11174 tmp = fieldFromInstruction(insn, 16, 5);
11175 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11176 tmp = fieldFromInstruction(insn, 21, 5);
11177 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11178 return S;
11179 case 166:
11180 tmp = fieldFromInstruction(insn, 11, 5);
11181 if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11182 tmp = fieldFromInstruction(insn, 16, 5);
11183 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11184 tmp = fieldFromInstruction(insn, 21, 5);
11185 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11186 return S;
11187 case 167:
11188 tmp = fieldFromInstruction(insn, 11, 5);
11189 if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11190 tmp = fieldFromInstruction(insn, 16, 5);
11191 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11192 tmp = fieldFromInstruction(insn, 21, 5);
11193 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11194 return S;
11195 case 168:
11196 tmp = fieldFromInstruction(insn, 16, 5);
11197 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11198 tmp = fieldFromInstruction(insn, 21, 5);
11199 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11200 return S;
11201 case 169:
11202 tmp = fieldFromInstruction(insn, 11, 5);
11203 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11204 tmp = fieldFromInstruction(insn, 21, 5);
11205 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11206 tmp = fieldFromInstruction(insn, 16, 5);
11207 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11208 return S;
11209 case 170:
11210 tmp = fieldFromInstruction(insn, 11, 5);
11211 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11212 tmp = fieldFromInstruction(insn, 11, 5);
11213 if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11214 tmp = fieldFromInstruction(insn, 16, 5);
11215 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11216 tmp = fieldFromInstruction(insn, 21, 5);
11217 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11218 return S;
11219 case 171:
11220 tmp = fieldFromInstruction(insn, 11, 5);
11221 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11222 tmp = fieldFromInstruction(insn, 11, 5);
11223 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11224 tmp = fieldFromInstruction(insn, 16, 5);
11225 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11226 tmp = fieldFromInstruction(insn, 21, 5);
11227 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11228 return S;
11229 case 172:
11230 tmp = fieldFromInstruction(insn, 16, 5);
11231 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11232 tmp = fieldFromInstruction(insn, 21, 5);
11233 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11234 return S;
11235 case 173:
11236 tmp = fieldFromInstruction(insn, 11, 5);
11237 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11238 tmp = fieldFromInstruction(insn, 11, 5);
11239 if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11240 tmp = fieldFromInstruction(insn, 16, 5);
11241 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11242 tmp = fieldFromInstruction(insn, 21, 5);
11243 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11244 return S;
11245 case 174:
11246 tmp = fieldFromInstruction(insn, 11, 5);
11247 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11248 tmp = fieldFromInstruction(insn, 11, 5);
11249 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11250 tmp = fieldFromInstruction(insn, 16, 5);
11251 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11252 tmp = fieldFromInstruction(insn, 21, 5);
11253 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11254 return S;
11255 case 175:
11256 if (!Check(S, DecodePOP35GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11257 return S;
11258 case 176:
11259 tmp = fieldFromInstruction(insn, 21, 5);
11260 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11261 tmp = fieldFromInstruction(insn, 0, 19);
11262 if (!Check(S, DecodeSimm19Lsl2(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11263 return S;
11264 case 177:
11265 tmp = fieldFromInstruction(insn, 21, 5);
11266 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11267 tmp = fieldFromInstruction(insn, 0, 16);
11268 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11269 return S;
11270 case 178:
11271 if (!Check(S, DecodePOP37GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11272 return S;
11273 case 179:
11274 tmp = fieldFromInstruction(insn, 21, 5);
11275 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11276 tmp = fieldFromInstruction(insn, 0, 21);
11277 if (!Check(S, DecodeBranchTarget21MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11278 return S;
11279 case 180:
11280 tmp = fieldFromInstruction(insn, 0, 26);
11281 if (!Check(S, DecodeBranchTarget26MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11282 return S;
11283 case 181:
11284 if (!Check(S, DecodeBlezGroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11285 return S;
11286 case 182:
11287 if (!Check(S, DecodePOP65GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11288 return S;
11289 case 183:
11290 if (!Check(S, DecodeBgtzGroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11291 return S;
11292 case 184:
11293 if (!Check(S, DecodePOP75GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11294 return S;
11295 case 185:
11296 tmp = fieldFromInstruction(insn, 11, 5);
11297 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11298 tmp = fieldFromInstruction(insn, 16, 5);
11299 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11300 tmp = fieldFromInstruction(insn, 6, 5);
11301 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11302 return S;
11303 case 186:
11304 tmp = fieldFromInstruction(insn, 11, 5);
11305 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11306 tmp = fieldFromInstruction(insn, 21, 5);
11307 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11308 tmp = fieldFromInstruction(insn, 18, 3);
11309 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11310 tmp = fieldFromInstruction(insn, 11, 5);
11311 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11312 return S;
11313 case 187:
11314 tmp = fieldFromInstruction(insn, 11, 5);
11315 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11316 tmp = fieldFromInstruction(insn, 21, 5);
11317 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11318 tmp = fieldFromInstruction(insn, 16, 5);
11319 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11320 tmp = fieldFromInstruction(insn, 6, 2);
11321 if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11322 return S;
11323 case 188:
11324 tmp = fieldFromInstruction(insn, 21, 5);
11325 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11326 return S;
11327 case 189:
11328 tmp = fieldFromInstruction(insn, 11, 5);
11329 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11330 tmp = fieldFromInstruction(insn, 21, 5);
11331 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11332 tmp = fieldFromInstruction(insn, 16, 5);
11333 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11334 tmp = fieldFromInstruction(insn, 11, 5);
11335 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11336 return S;
11337 case 190:
11338 tmp = fieldFromInstruction(insn, 6, 20);
11339 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11340 return S;
11341 case 191:
11342 tmp = fieldFromInstruction(insn, 6, 5);
11343 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11344 return S;
11345 case 192:
11346 tmp = fieldFromInstruction(insn, 11, 5);
11347 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11348 return S;
11349 case 193:
11350 tmp = fieldFromInstruction(insn, 11, 5);
11351 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11352 tmp = fieldFromInstruction(insn, 21, 2);
11353 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11354 return S;
11355 case 194:
11356 tmp = fieldFromInstruction(insn, 11, 2);
11357 if (!Check(S, DecodeHI32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11358 tmp = fieldFromInstruction(insn, 21, 5);
11359 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11360 return S;
11361 case 195:
11362 tmp = fieldFromInstruction(insn, 11, 2);
11363 if (!Check(S, DecodeLO32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11364 tmp = fieldFromInstruction(insn, 21, 5);
11365 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11366 return S;
11367 case 196:
11368 tmp = fieldFromInstruction(insn, 11, 5);
11369 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11370 tmp = fieldFromInstruction(insn, 21, 5);
11371 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11372 tmp = fieldFromInstruction(insn, 16, 5);
11373 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11374 tmp = fieldFromInstruction(insn, 6, 2);
11375 if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11376 return S;
11377 case 197:
11378 tmp = fieldFromInstruction(insn, 11, 2);
11379 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11380 tmp = fieldFromInstruction(insn, 21, 5);
11381 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11382 tmp = fieldFromInstruction(insn, 16, 5);
11383 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11384 return S;
11385 case 198:
11386 tmp = fieldFromInstruction(insn, 21, 5);
11387 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11388 tmp = fieldFromInstruction(insn, 16, 5);
11389 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11390 tmp = fieldFromInstruction(insn, 6, 10);
11391 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11392 return S;
11393 case 199:
11394 tmp = fieldFromInstruction(insn, 21, 5);
11395 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11396 tmp = fieldFromInstruction(insn, 0, 16);
11397 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11398 return S;
11399 case 200:
11400 tmp = fieldFromInstruction(insn, 0, 16);
11401 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11402 return S;
11403 case 201:
11404 if (!Check(S, DecodeSyncI(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11405 return S;
11406 case 202:
11407 if (!Check(S, DecodeJumpTarget(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
11408 return S;
11409 case 203:
11410 tmp = fieldFromInstruction(insn, 21, 5);
11411 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11412 tmp = fieldFromInstruction(insn, 16, 5);
11413 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11414 tmp = fieldFromInstruction(insn, 0, 16);
11415 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11416 return S;
11417 case 204:
11418 tmp = fieldFromInstruction(insn, 16, 5);
11419 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11420 tmp = fieldFromInstruction(insn, 21, 5);
11421 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11422 tmp = fieldFromInstruction(insn, 0, 16);
11423 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11424 return S;
11425 case 205:
11426 tmp = fieldFromInstruction(insn, 16, 5);
11427 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11428 tmp = fieldFromInstruction(insn, 21, 5);
11429 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11430 tmp = fieldFromInstruction(insn, 0, 16);
11431 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11432 return S;
11433 case 206:
11434 tmp = fieldFromInstruction(insn, 16, 5);
11435 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11436 tmp = fieldFromInstruction(insn, 11, 5);
11437 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11438 tmp = fieldFromInstruction(insn, 0, 3);
11439 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11440 return S;
11441 case 207:
11442 tmp = fieldFromInstruction(insn, 11, 5);
11443 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11444 tmp = fieldFromInstruction(insn, 16, 5);
11445 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11446 tmp = fieldFromInstruction(insn, 0, 3);
11447 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11448 return S;
11449 case 208:
11450 tmp = fieldFromInstruction(insn, 11, 5);
11451 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11452 tmp = fieldFromInstruction(insn, 16, 5);
11453 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11454 tmp = fieldFromInstruction(insn, 5, 1);
11455 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11456 tmp = fieldFromInstruction(insn, 0, 3);
11457 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11458 tmp = fieldFromInstruction(insn, 4, 1);
11459 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11460 return S;
11461 case 209:
11462 tmp = fieldFromInstruction(insn, 11, 10);
11463 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11464 return S;
11465 case 210:
11466 tmp = fieldFromInstruction(insn, 16, 5);
11467 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11468 tmp = fieldFromInstruction(insn, 11, 5);
11469 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11470 return S;
11471 case 211:
11472 tmp = fieldFromInstruction(insn, 16, 5);
11473 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11474 tmp = fieldFromInstruction(insn, 11, 5);
11475 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11476 return S;
11477 case 212:
11478 tmp = fieldFromInstruction(insn, 16, 5);
11479 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11480 tmp = fieldFromInstruction(insn, 11, 5);
11481 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11482 return S;
11483 case 213:
11484 tmp = fieldFromInstruction(insn, 16, 5);
11485 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11486 tmp = fieldFromInstruction(insn, 11, 5);
11487 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11488 return S;
11489 case 214:
11490 tmp = fieldFromInstruction(insn, 11, 5);
11491 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11492 tmp = fieldFromInstruction(insn, 16, 5);
11493 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11494 return S;
11495 case 215:
11496 tmp = fieldFromInstruction(insn, 11, 5);
11497 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11498 tmp = fieldFromInstruction(insn, 16, 5);
11499 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11500 return S;
11501 case 216:
11502 tmp = fieldFromInstruction(insn, 11, 5);
11503 if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11504 tmp = fieldFromInstruction(insn, 16, 5);
11505 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11506 return S;
11507 case 217:
11508 tmp = fieldFromInstruction(insn, 11, 5);
11509 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11510 tmp = fieldFromInstruction(insn, 11, 5);
11511 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11512 tmp = fieldFromInstruction(insn, 16, 5);
11513 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11514 return S;
11515 case 218:
11516 tmp = fieldFromInstruction(insn, 18, 3);
11517 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11518 tmp = fieldFromInstruction(insn, 0, 16);
11519 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11520 return S;
11521 case 219:
11522 tmp = fieldFromInstruction(insn, 16, 5);
11523 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11524 tmp = fieldFromInstruction(insn, 0, 16);
11525 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11526 return S;
11527 case 220:
11528 tmp = fieldFromInstruction(insn, 6, 5);
11529 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11530 tmp = fieldFromInstruction(insn, 11, 5);
11531 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11532 tmp = fieldFromInstruction(insn, 16, 5);
11533 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11534 return S;
11535 case 221:
11536 tmp = fieldFromInstruction(insn, 6, 5);
11537 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11538 tmp = fieldFromInstruction(insn, 11, 5);
11539 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11540 return S;
11541 case 222:
11542 tmp = fieldFromInstruction(insn, 6, 5);
11543 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11544 tmp = fieldFromInstruction(insn, 11, 5);
11545 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11546 tmp = fieldFromInstruction(insn, 18, 3);
11547 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11548 tmp = fieldFromInstruction(insn, 6, 5);
11549 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11550 return S;
11551 case 223:
11552 tmp = fieldFromInstruction(insn, 6, 5);
11553 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11554 tmp = fieldFromInstruction(insn, 11, 5);
11555 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11556 tmp = fieldFromInstruction(insn, 16, 5);
11557 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11558 tmp = fieldFromInstruction(insn, 6, 5);
11559 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11560 return S;
11561 case 224:
11562 tmp = fieldFromInstruction(insn, 6, 5);
11563 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11564 tmp = fieldFromInstruction(insn, 11, 5);
11565 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11566 return S;
11567 case 225:
11568 tmp = fieldFromInstruction(insn, 6, 5);
11569 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11570 tmp = fieldFromInstruction(insn, 11, 5);
11571 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11572 return S;
11573 case 226:
11574 tmp = fieldFromInstruction(insn, 8, 3);
11575 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11576 tmp = fieldFromInstruction(insn, 11, 5);
11577 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11578 tmp = fieldFromInstruction(insn, 16, 5);
11579 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11580 return S;
11581 case 227:
11582 tmp = fieldFromInstruction(insn, 6, 5);
11583 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11584 tmp = fieldFromInstruction(insn, 11, 5);
11585 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11586 tmp = fieldFromInstruction(insn, 16, 5);
11587 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11588 return S;
11589 case 228:
11590 tmp = fieldFromInstruction(insn, 6, 5);
11591 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11592 tmp = fieldFromInstruction(insn, 11, 5);
11593 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11594 return S;
11595 case 229:
11596 tmp = fieldFromInstruction(insn, 6, 5);
11597 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11598 tmp = fieldFromInstruction(insn, 11, 5);
11599 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11600 return S;
11601 case 230:
11602 tmp = fieldFromInstruction(insn, 6, 5);
11603 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11604 tmp = fieldFromInstruction(insn, 11, 5);
11605 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11606 tmp = fieldFromInstruction(insn, 18, 3);
11607 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11608 tmp = fieldFromInstruction(insn, 6, 5);
11609 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11610 return S;
11611 case 231:
11612 tmp = fieldFromInstruction(insn, 6, 5);
11613 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11614 tmp = fieldFromInstruction(insn, 11, 5);
11615 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11616 tmp = fieldFromInstruction(insn, 16, 5);
11617 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11618 tmp = fieldFromInstruction(insn, 6, 5);
11619 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11620 return S;
11621 case 232:
11622 tmp = fieldFromInstruction(insn, 6, 5);
11623 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11624 tmp = fieldFromInstruction(insn, 11, 5);
11625 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11626 return S;
11627 case 233:
11628 tmp = fieldFromInstruction(insn, 8, 3);
11629 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11630 tmp = fieldFromInstruction(insn, 11, 5);
11631 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11632 tmp = fieldFromInstruction(insn, 16, 5);
11633 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11634 return S;
11635 case 234:
11636 tmp = fieldFromInstruction(insn, 16, 5);
11637 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11638 tmp = fieldFromInstruction(insn, 0, 16);
11639 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11640 return S;
11641 case 235:
11642 tmp = fieldFromInstruction(insn, 16, 5);
11643 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11644 tmp = fieldFromInstruction(insn, 0, 16);
11645 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11646 return S;
11647 case 236:
11648 tmp = fieldFromInstruction(insn, 16, 5);
11649 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11650 tmp = fieldFromInstruction(insn, 0, 16);
11651 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11652 return S;
11653 case 237:
11654 tmp = fieldFromInstruction(insn, 16, 5);
11655 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11656 tmp = fieldFromInstruction(insn, 11, 5);
11657 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11658 tmp = fieldFromInstruction(insn, 0, 3);
11659 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11660 return S;
11661 case 238:
11662 tmp = fieldFromInstruction(insn, 11, 5);
11663 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11664 tmp = fieldFromInstruction(insn, 16, 5);
11665 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11666 tmp = fieldFromInstruction(insn, 0, 3);
11667 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11668 return S;
11669 case 239:
11670 tmp = fieldFromInstruction(insn, 6, 5);
11671 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11672 tmp = fieldFromInstruction(insn, 21, 5);
11673 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11674 tmp = fieldFromInstruction(insn, 16, 5);
11675 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11676 return S;
11677 case 240:
11678 tmp = fieldFromInstruction(insn, 6, 5);
11679 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11680 tmp = fieldFromInstruction(insn, 21, 5);
11681 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11682 tmp = fieldFromInstruction(insn, 16, 5);
11683 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11684 return S;
11685 case 241:
11686 tmp = fieldFromInstruction(insn, 11, 5);
11687 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11688 tmp = fieldFromInstruction(insn, 21, 5);
11689 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11690 tmp = fieldFromInstruction(insn, 16, 5);
11691 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11692 return S;
11693 case 242:
11694 tmp = fieldFromInstruction(insn, 11, 5);
11695 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11696 tmp = fieldFromInstruction(insn, 21, 5);
11697 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11698 tmp = fieldFromInstruction(insn, 16, 5);
11699 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11700 return S;
11701 case 243:
11702 tmp = fieldFromInstruction(insn, 6, 5);
11703 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11704 tmp = fieldFromInstruction(insn, 21, 5);
11705 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11706 tmp = fieldFromInstruction(insn, 11, 5);
11707 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11708 tmp = fieldFromInstruction(insn, 16, 5);
11709 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11710 return S;
11711 case 244:
11712 tmp = fieldFromInstruction(insn, 6, 5);
11713 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11714 tmp = fieldFromInstruction(insn, 21, 5);
11715 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11716 tmp = fieldFromInstruction(insn, 11, 5);
11717 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11718 tmp = fieldFromInstruction(insn, 16, 5);
11719 if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11720 return S;
11721 case 245:
11722 tmp = fieldFromInstruction(insn, 11, 2);
11723 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11724 tmp = fieldFromInstruction(insn, 21, 5);
11725 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11726 tmp = fieldFromInstruction(insn, 16, 5);
11727 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11728 tmp = fieldFromInstruction(insn, 11, 2);
11729 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11730 return S;
11731 case 246:
11732 tmp = 0x0;
11733 tmp |= fieldFromInstruction(insn, 11, 5);
11734 tmp |= fieldFromInstruction(insn, 16, 5);
11735 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11736 tmp = fieldFromInstruction(insn, 21, 5);
11737 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11738 return S;
11739 case 247:
11740 tmp = fieldFromInstruction(insn, 6, 5);
11741 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11742 tmp = fieldFromInstruction(insn, 11, 5);
11743 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11744 tmp = fieldFromInstruction(insn, 16, 8);
11745 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11746 return S;
11747 case 248:
11748 tmp = fieldFromInstruction(insn, 6, 5);
11749 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11750 tmp = fieldFromInstruction(insn, 6, 5);
11751 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11752 tmp = fieldFromInstruction(insn, 11, 5);
11753 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11754 tmp = fieldFromInstruction(insn, 16, 8);
11755 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11756 return S;
11757 case 249:
11758 tmp = fieldFromInstruction(insn, 6, 5);
11759 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11760 tmp = fieldFromInstruction(insn, 11, 5);
11761 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11762 tmp = fieldFromInstruction(insn, 16, 8);
11763 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11764 return S;
11765 case 250:
11766 tmp = fieldFromInstruction(insn, 6, 5);
11767 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11768 tmp = fieldFromInstruction(insn, 11, 5);
11769 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11770 tmp = fieldFromInstruction(insn, 16, 8);
11771 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11772 return S;
11773 case 251:
11774 tmp = fieldFromInstruction(insn, 6, 5);
11775 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11776 tmp = fieldFromInstruction(insn, 11, 5);
11777 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11778 tmp = fieldFromInstruction(insn, 16, 5);
11779 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11780 return S;
11781 case 252:
11782 tmp = fieldFromInstruction(insn, 6, 5);
11783 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11784 tmp = fieldFromInstruction(insn, 11, 5);
11785 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11786 tmp = fieldFromInstruction(insn, 16, 5);
11787 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11788 return S;
11789 case 253:
11790 tmp = fieldFromInstruction(insn, 6, 5);
11791 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11792 tmp = fieldFromInstruction(insn, 11, 5);
11793 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11794 tmp = fieldFromInstruction(insn, 16, 5);
11795 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11796 return S;
11797 case 254:
11798 tmp = fieldFromInstruction(insn, 6, 5);
11799 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11800 tmp = fieldFromInstruction(insn, 11, 5);
11801 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11802 tmp = fieldFromInstruction(insn, 16, 5);
11803 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11804 return S;
11805 case 255:
11806 tmp = fieldFromInstruction(insn, 6, 5);
11807 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11808 tmp = fieldFromInstruction(insn, 11, 10);
11809 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11810 return S;
11811 case 256:
11812 tmp = fieldFromInstruction(insn, 6, 5);
11813 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11814 tmp = fieldFromInstruction(insn, 11, 10);
11815 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11816 return S;
11817 case 257:
11818 tmp = fieldFromInstruction(insn, 6, 5);
11819 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11820 tmp = fieldFromInstruction(insn, 11, 10);
11821 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11822 return S;
11823 case 258:
11824 tmp = fieldFromInstruction(insn, 6, 5);
11825 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11826 tmp = fieldFromInstruction(insn, 11, 10);
11827 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11828 return S;
11829 case 259:
11830 tmp = fieldFromInstruction(insn, 6, 5);
11831 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11832 tmp = fieldFromInstruction(insn, 11, 5);
11833 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11834 tmp = fieldFromInstruction(insn, 16, 6);
11835 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11836 return S;
11837 case 260:
11838 tmp = fieldFromInstruction(insn, 6, 5);
11839 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11840 tmp = fieldFromInstruction(insn, 11, 5);
11841 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11842 tmp = fieldFromInstruction(insn, 16, 4);
11843 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11844 return S;
11845 case 261:
11846 tmp = fieldFromInstruction(insn, 6, 5);
11847 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11848 tmp = fieldFromInstruction(insn, 11, 5);
11849 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11850 tmp = fieldFromInstruction(insn, 16, 3);
11851 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11852 return S;
11853 case 262:
11854 tmp = fieldFromInstruction(insn, 6, 5);
11855 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11856 tmp = fieldFromInstruction(insn, 6, 5);
11857 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11858 tmp = fieldFromInstruction(insn, 11, 5);
11859 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11860 tmp = fieldFromInstruction(insn, 16, 6);
11861 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11862 return S;
11863 case 263:
11864 tmp = fieldFromInstruction(insn, 6, 5);
11865 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11866 tmp = fieldFromInstruction(insn, 6, 5);
11867 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11868 tmp = fieldFromInstruction(insn, 11, 5);
11869 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11870 tmp = fieldFromInstruction(insn, 16, 5);
11871 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11872 return S;
11873 case 264:
11874 tmp = fieldFromInstruction(insn, 6, 5);
11875 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11876 tmp = fieldFromInstruction(insn, 6, 5);
11877 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11878 tmp = fieldFromInstruction(insn, 11, 5);
11879 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11880 tmp = fieldFromInstruction(insn, 16, 4);
11881 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11882 return S;
11883 case 265:
11884 tmp = fieldFromInstruction(insn, 6, 5);
11885 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11886 tmp = fieldFromInstruction(insn, 6, 5);
11887 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11888 tmp = fieldFromInstruction(insn, 11, 5);
11889 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11890 tmp = fieldFromInstruction(insn, 16, 3);
11891 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
11892 return S;
11893 case 266:
11894 tmp = fieldFromInstruction(insn, 6, 5);
11895 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11896 tmp = fieldFromInstruction(insn, 11, 5);
11897 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11898 tmp = fieldFromInstruction(insn, 16, 5);
11899 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11900 return S;
11901 case 267:
11902 tmp = fieldFromInstruction(insn, 6, 5);
11903 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11904 tmp = fieldFromInstruction(insn, 11, 5);
11905 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11906 tmp = fieldFromInstruction(insn, 16, 5);
11907 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11908 return S;
11909 case 268:
11910 tmp = fieldFromInstruction(insn, 6, 5);
11911 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11912 tmp = fieldFromInstruction(insn, 11, 5);
11913 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11914 tmp = fieldFromInstruction(insn, 16, 5);
11915 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11916 return S;
11917 case 269:
11918 tmp = fieldFromInstruction(insn, 6, 5);
11919 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11920 tmp = fieldFromInstruction(insn, 11, 5);
11921 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11922 tmp = fieldFromInstruction(insn, 16, 5);
11923 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11924 return S;
11925 case 270:
11926 tmp = fieldFromInstruction(insn, 6, 5);
11927 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11928 tmp = fieldFromInstruction(insn, 6, 5);
11929 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11930 tmp = fieldFromInstruction(insn, 11, 5);
11931 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11932 tmp = fieldFromInstruction(insn, 16, 5);
11933 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11934 return S;
11935 case 271:
11936 tmp = fieldFromInstruction(insn, 6, 5);
11937 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11938 tmp = fieldFromInstruction(insn, 6, 5);
11939 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11940 tmp = fieldFromInstruction(insn, 11, 5);
11941 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11942 tmp = fieldFromInstruction(insn, 16, 5);
11943 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11944 return S;
11945 case 272:
11946 tmp = fieldFromInstruction(insn, 6, 5);
11947 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11948 tmp = fieldFromInstruction(insn, 6, 5);
11949 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11950 tmp = fieldFromInstruction(insn, 11, 5);
11951 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11952 tmp = fieldFromInstruction(insn, 16, 5);
11953 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11954 return S;
11955 case 273:
11956 tmp = fieldFromInstruction(insn, 6, 5);
11957 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11958 tmp = fieldFromInstruction(insn, 6, 5);
11959 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11960 tmp = fieldFromInstruction(insn, 11, 5);
11961 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11962 tmp = fieldFromInstruction(insn, 16, 5);
11963 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11964 return S;
11965 case 274:
11966 tmp = fieldFromInstruction(insn, 6, 5);
11967 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11968 tmp = fieldFromInstruction(insn, 11, 5);
11969 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11970 tmp = fieldFromInstruction(insn, 16, 5);
11971 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11972 return S;
11973 case 275:
11974 tmp = fieldFromInstruction(insn, 6, 5);
11975 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11976 tmp = fieldFromInstruction(insn, 11, 5);
11977 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11978 tmp = fieldFromInstruction(insn, 16, 5);
11979 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11980 return S;
11981 case 276:
11982 tmp = fieldFromInstruction(insn, 6, 5);
11983 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11984 tmp = fieldFromInstruction(insn, 11, 5);
11985 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11986 tmp = fieldFromInstruction(insn, 16, 5);
11987 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11988 return S;
11989 case 277:
11990 tmp = fieldFromInstruction(insn, 6, 5);
11991 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11992 tmp = fieldFromInstruction(insn, 6, 5);
11993 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11994 tmp = fieldFromInstruction(insn, 11, 5);
11995 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11996 tmp = fieldFromInstruction(insn, 16, 5);
11997 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
11998 return S;
11999 case 278:
12000 tmp = fieldFromInstruction(insn, 6, 5);
12001 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12002 tmp = fieldFromInstruction(insn, 6, 5);
12003 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12004 tmp = fieldFromInstruction(insn, 11, 5);
12005 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12006 tmp = fieldFromInstruction(insn, 16, 5);
12007 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12008 return S;
12009 case 279:
12010 tmp = fieldFromInstruction(insn, 6, 5);
12011 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12012 tmp = fieldFromInstruction(insn, 6, 5);
12013 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12014 tmp = fieldFromInstruction(insn, 11, 5);
12015 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12016 tmp = fieldFromInstruction(insn, 16, 5);
12017 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12018 return S;
12019 case 280:
12020 tmp = fieldFromInstruction(insn, 6, 5);
12021 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12022 tmp = fieldFromInstruction(insn, 6, 5);
12023 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12024 tmp = fieldFromInstruction(insn, 11, 5);
12025 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12026 tmp = fieldFromInstruction(insn, 16, 5);
12027 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12028 return S;
12029 case 281:
12030 tmp = fieldFromInstruction(insn, 6, 5);
12031 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12032 tmp = fieldFromInstruction(insn, 6, 5);
12033 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12034 tmp = fieldFromInstruction(insn, 11, 5);
12035 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12036 tmp = fieldFromInstruction(insn, 16, 5);
12037 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12038 return S;
12039 case 282:
12040 tmp = fieldFromInstruction(insn, 6, 5);
12041 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12042 tmp = fieldFromInstruction(insn, 6, 5);
12043 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12044 tmp = fieldFromInstruction(insn, 11, 5);
12045 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12046 tmp = fieldFromInstruction(insn, 16, 5);
12047 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12048 return S;
12049 case 283:
12050 tmp = fieldFromInstruction(insn, 6, 5);
12051 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12052 tmp = fieldFromInstruction(insn, 6, 5);
12053 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12054 tmp = fieldFromInstruction(insn, 11, 5);
12055 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12056 tmp = fieldFromInstruction(insn, 16, 5);
12057 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12058 return S;
12059 case 284:
12060 tmp = fieldFromInstruction(insn, 6, 5);
12061 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12062 tmp = fieldFromInstruction(insn, 11, 5);
12063 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12064 tmp = fieldFromInstruction(insn, 16, 5);
12065 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12066 return S;
12067 case 285:
12068 tmp = fieldFromInstruction(insn, 6, 5);
12069 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12070 tmp = fieldFromInstruction(insn, 11, 5);
12071 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12072 tmp = fieldFromInstruction(insn, 16, 5);
12073 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12074 return S;
12075 case 286:
12076 tmp = fieldFromInstruction(insn, 6, 5);
12077 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12078 tmp = fieldFromInstruction(insn, 11, 5);
12079 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12080 tmp = fieldFromInstruction(insn, 16, 5);
12081 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12082 return S;
12083 case 287:
12084 tmp = fieldFromInstruction(insn, 6, 5);
12085 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12086 tmp = fieldFromInstruction(insn, 11, 5);
12087 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12088 tmp = fieldFromInstruction(insn, 16, 5);
12089 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12090 return S;
12091 case 288:
12092 tmp = fieldFromInstruction(insn, 6, 5);
12093 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12094 tmp = fieldFromInstruction(insn, 6, 5);
12095 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12096 tmp = fieldFromInstruction(insn, 11, 5);
12097 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12098 tmp = fieldFromInstruction(insn, 16, 4);
12099 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12100 return S;
12101 case 289:
12102 tmp = fieldFromInstruction(insn, 6, 5);
12103 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12104 tmp = fieldFromInstruction(insn, 6, 5);
12105 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12106 tmp = fieldFromInstruction(insn, 11, 5);
12107 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12108 tmp = fieldFromInstruction(insn, 16, 3);
12109 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12110 return S;
12111 case 290:
12112 tmp = fieldFromInstruction(insn, 6, 5);
12113 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12114 tmp = fieldFromInstruction(insn, 6, 5);
12115 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12116 tmp = fieldFromInstruction(insn, 11, 5);
12117 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12118 tmp = fieldFromInstruction(insn, 16, 2);
12119 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12120 return S;
12121 case 291:
12122 tmp = fieldFromInstruction(insn, 6, 5);
12123 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12124 tmp = fieldFromInstruction(insn, 6, 5);
12125 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12126 tmp = fieldFromInstruction(insn, 11, 5);
12127 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12128 tmp = fieldFromInstruction(insn, 16, 1);
12129 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12130 return S;
12131 case 292:
12132 tmp = fieldFromInstruction(insn, 6, 5);
12133 if (!Check(S, DecodeMSACtrlRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12134 tmp = fieldFromInstruction(insn, 11, 5);
12135 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12136 return S;
12137 case 293:
12138 tmp = fieldFromInstruction(insn, 6, 5);
12139 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12140 tmp = fieldFromInstruction(insn, 11, 5);
12141 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12142 tmp = fieldFromInstruction(insn, 16, 4);
12143 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12144 return S;
12145 case 294:
12146 tmp = fieldFromInstruction(insn, 6, 5);
12147 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12148 tmp = fieldFromInstruction(insn, 11, 5);
12149 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12150 tmp = fieldFromInstruction(insn, 16, 3);
12151 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12152 return S;
12153 case 295:
12154 tmp = fieldFromInstruction(insn, 6, 5);
12155 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12156 tmp = fieldFromInstruction(insn, 11, 5);
12157 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12158 tmp = fieldFromInstruction(insn, 16, 2);
12159 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12160 return S;
12161 case 296:
12162 tmp = fieldFromInstruction(insn, 6, 5);
12163 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12164 tmp = fieldFromInstruction(insn, 11, 5);
12165 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12166 tmp = fieldFromInstruction(insn, 16, 1);
12167 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12168 return S;
12169 case 297:
12170 tmp = fieldFromInstruction(insn, 6, 5);
12171 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12172 tmp = fieldFromInstruction(insn, 11, 5);
12173 if (!Check(S, DecodeMSACtrlRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12174 return S;
12175 case 298:
12176 tmp = fieldFromInstruction(insn, 6, 5);
12177 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12178 tmp = fieldFromInstruction(insn, 11, 5);
12179 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12180 tmp = fieldFromInstruction(insn, 16, 4);
12181 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12182 return S;
12183 case 299:
12184 tmp = fieldFromInstruction(insn, 6, 5);
12185 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12186 tmp = fieldFromInstruction(insn, 11, 5);
12187 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12188 tmp = fieldFromInstruction(insn, 16, 3);
12189 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12190 return S;
12191 case 300:
12192 tmp = fieldFromInstruction(insn, 6, 5);
12193 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12194 tmp = fieldFromInstruction(insn, 11, 5);
12195 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12196 tmp = fieldFromInstruction(insn, 16, 2);
12197 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12198 return S;
12199 case 301:
12200 tmp = fieldFromInstruction(insn, 6, 5);
12201 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12202 tmp = fieldFromInstruction(insn, 11, 5);
12203 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12204 tmp = fieldFromInstruction(insn, 16, 1);
12205 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12206 return S;
12207 case 302:
12208 tmp = fieldFromInstruction(insn, 6, 5);
12209 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12210 tmp = fieldFromInstruction(insn, 11, 5);
12211 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12212 return S;
12213 case 303:
12214 tmp = fieldFromInstruction(insn, 6, 5);
12215 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12216 tmp = fieldFromInstruction(insn, 6, 5);
12217 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12218 tmp = fieldFromInstruction(insn, 11, 5);
12219 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12220 tmp = fieldFromInstruction(insn, 16, 4);
12221 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12222 return S;
12223 case 304:
12224 tmp = fieldFromInstruction(insn, 6, 5);
12225 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12226 tmp = fieldFromInstruction(insn, 6, 5);
12227 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12228 tmp = fieldFromInstruction(insn, 11, 5);
12229 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12230 tmp = fieldFromInstruction(insn, 16, 3);
12231 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12232 return S;
12233 case 305:
12234 tmp = fieldFromInstruction(insn, 6, 5);
12235 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12236 tmp = fieldFromInstruction(insn, 6, 5);
12237 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12238 tmp = fieldFromInstruction(insn, 11, 5);
12239 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12240 tmp = fieldFromInstruction(insn, 16, 2);
12241 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12242 return S;
12243 case 306:
12244 tmp = fieldFromInstruction(insn, 6, 5);
12245 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12246 tmp = fieldFromInstruction(insn, 6, 5);
12247 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12248 tmp = fieldFromInstruction(insn, 11, 5);
12249 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12250 tmp = fieldFromInstruction(insn, 16, 1);
12251 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12252 return S;
12253 case 307:
12254 if (!Check(S, DecodeINSVE_DF(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12255 return S;
12256 case 308:
12257 tmp = fieldFromInstruction(insn, 6, 5);
12258 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12259 tmp = fieldFromInstruction(insn, 11, 5);
12260 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12261 tmp = fieldFromInstruction(insn, 16, 5);
12262 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12263 return S;
12264 case 309:
12265 tmp = fieldFromInstruction(insn, 6, 5);
12266 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12267 tmp = fieldFromInstruction(insn, 11, 5);
12268 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12269 tmp = fieldFromInstruction(insn, 16, 5);
12270 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12271 return S;
12272 case 310:
12273 tmp = fieldFromInstruction(insn, 6, 5);
12274 if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12275 tmp = fieldFromInstruction(insn, 11, 5);
12276 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12277 return S;
12278 case 311:
12279 tmp = fieldFromInstruction(insn, 6, 5);
12280 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12281 tmp = fieldFromInstruction(insn, 11, 5);
12282 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12283 return S;
12284 case 312:
12285 tmp = fieldFromInstruction(insn, 6, 5);
12286 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12287 tmp = fieldFromInstruction(insn, 11, 5);
12288 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12289 return S;
12290 case 313:
12291 tmp = fieldFromInstruction(insn, 6, 5);
12292 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12293 tmp = fieldFromInstruction(insn, 11, 5);
12294 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12295 return S;
12296 case 314:
12297 tmp = fieldFromInstruction(insn, 6, 5);
12298 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12299 tmp = fieldFromInstruction(insn, 11, 5);
12300 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12301 return S;
12302 case 315:
12303 tmp = fieldFromInstruction(insn, 6, 5);
12304 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12305 tmp = fieldFromInstruction(insn, 11, 5);
12306 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12307 return S;
12308 case 316:
12309 tmp = fieldFromInstruction(insn, 6, 5);
12310 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12311 tmp = fieldFromInstruction(insn, 11, 5);
12312 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12313 return S;
12314 case 317:
12315 tmp = fieldFromInstruction(insn, 6, 5);
12316 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12317 tmp = fieldFromInstruction(insn, 11, 5);
12318 if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12319 return S;
12320 case 318:
12321 tmp = fieldFromInstruction(insn, 6, 5);
12322 if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12323 tmp = fieldFromInstruction(insn, 11, 5);
12324 if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12325 return S;
12326 case 319:
12327 if (!Check(S, DecodeMSA128Mem(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12328 return S;
12329 case 320:
12330 tmp = fieldFromInstruction(insn, 16, 5);
12331 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12332 tmp = fieldFromInstruction(insn, 21, 5);
12333 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12334 tmp = fieldFromInstruction(insn, 6, 5);
12335 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12336 tmp = fieldFromInstruction(insn, 11, 5);
12337 if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12338 return S;
12339 case 321:
12340 tmp = fieldFromInstruction(insn, 16, 5);
12341 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12342 tmp = fieldFromInstruction(insn, 21, 5);
12343 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12344 tmp = fieldFromInstruction(insn, 6, 5);
12345 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12346 tmp = fieldFromInstruction(insn, 11, 5);
12347 if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12348 tmp = fieldFromInstruction(insn, 16, 5);
12349 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12350 return S;
12351 case 322:
12352 tmp = fieldFromInstruction(insn, 21, 5);
12353 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12354 tmp = fieldFromInstruction(insn, 11, 5);
12355 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12356 tmp = fieldFromInstruction(insn, 16, 5);
12357 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12358 return S;
12359 case 323:
12360 tmp = fieldFromInstruction(insn, 11, 5);
12361 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12362 tmp = fieldFromInstruction(insn, 21, 5);
12363 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12364 tmp = fieldFromInstruction(insn, 16, 5);
12365 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12366 return S;
12367 case 324:
12368 tmp = fieldFromInstruction(insn, 16, 5);
12369 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12370 tmp = fieldFromInstruction(insn, 16, 5);
12371 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12372 tmp = fieldFromInstruction(insn, 21, 5);
12373 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12374 return S;
12375 case 325:
12376 tmp = fieldFromInstruction(insn, 11, 5);
12377 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12378 tmp = fieldFromInstruction(insn, 21, 5);
12379 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12380 tmp = fieldFromInstruction(insn, 16, 5);
12381 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12382 return S;
12383 case 326:
12384 tmp = fieldFromInstruction(insn, 11, 5);
12385 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12386 tmp = fieldFromInstruction(insn, 21, 5);
12387 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12388 return S;
12389 case 327:
12390 tmp = fieldFromInstruction(insn, 11, 5);
12391 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12392 tmp = fieldFromInstruction(insn, 21, 5);
12393 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12394 tmp = fieldFromInstruction(insn, 16, 5);
12395 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12396 return S;
12397 case 328:
12398 tmp = fieldFromInstruction(insn, 11, 5);
12399 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12400 tmp = fieldFromInstruction(insn, 21, 5);
12401 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12402 tmp = fieldFromInstruction(insn, 16, 5);
12403 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12404 return S;
12405 case 329:
12406 tmp = fieldFromInstruction(insn, 16, 5);
12407 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12408 tmp = fieldFromInstruction(insn, 21, 5);
12409 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12410 tmp = fieldFromInstruction(insn, 11, 5);
12411 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12412 tmp = fieldFromInstruction(insn, 16, 5);
12413 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12414 return S;
12415 case 330:
12416 tmp = fieldFromInstruction(insn, 11, 5);
12417 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12418 tmp = fieldFromInstruction(insn, 16, 5);
12419 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12420 return S;
12421 case 331:
12422 tmp = fieldFromInstruction(insn, 11, 5);
12423 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12424 tmp = fieldFromInstruction(insn, 16, 10);
12425 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12426 return S;
12427 case 332:
12428 tmp = fieldFromInstruction(insn, 11, 5);
12429 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12430 tmp = fieldFromInstruction(insn, 16, 5);
12431 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12432 return S;
12433 case 333:
12434 tmp = fieldFromInstruction(insn, 11, 5);
12435 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12436 tmp = fieldFromInstruction(insn, 16, 5);
12437 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12438 return S;
12439 case 334:
12440 tmp = fieldFromInstruction(insn, 11, 5);
12441 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12442 tmp = fieldFromInstruction(insn, 16, 5);
12443 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12444 return S;
12445 case 335:
12446 tmp = fieldFromInstruction(insn, 11, 5);
12447 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12448 tmp = fieldFromInstruction(insn, 16, 5);
12449 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12450 tmp = fieldFromInstruction(insn, 21, 5);
12451 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12452 return S;
12453 case 336:
12454 tmp = fieldFromInstruction(insn, 11, 5);
12455 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12456 tmp = fieldFromInstruction(insn, 16, 5);
12457 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12458 tmp = fieldFromInstruction(insn, 21, 5);
12459 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12460 return S;
12461 case 337:
12462 tmp = fieldFromInstruction(insn, 11, 5);
12463 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12464 tmp = fieldFromInstruction(insn, 16, 5);
12465 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12466 tmp = fieldFromInstruction(insn, 21, 5);
12467 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12468 return S;
12469 case 338:
12470 if (!Check(S, DecodeMemEVA(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12471 return S;
12472 case 339:
12473 if (!Check(S, DecodeCacheeOp_CacheOpR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12474 return S;
12475 case 340:
12476 tmp = fieldFromInstruction(insn, 11, 2);
12477 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12478 tmp = fieldFromInstruction(insn, 21, 5);
12479 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12480 tmp = fieldFromInstruction(insn, 16, 5);
12481 if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12482 tmp = fieldFromInstruction(insn, 11, 2);
12483 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12484 return S;
12485 case 341:
12486 tmp = fieldFromInstruction(insn, 16, 5);
12487 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12488 tmp = fieldFromInstruction(insn, 21, 5);
12489 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12490 tmp = fieldFromInstruction(insn, 11, 5);
12491 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12492 tmp = fieldFromInstruction(insn, 16, 5);
12493 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12494 return S;
12495 case 342:
12496 tmp = fieldFromInstruction(insn, 16, 5);
12497 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12498 tmp = fieldFromInstruction(insn, 11, 2);
12499 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12500 tmp = fieldFromInstruction(insn, 21, 5);
12501 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12502 return S;
12503 case 343:
12504 tmp = fieldFromInstruction(insn, 16, 5);
12505 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12506 tmp = fieldFromInstruction(insn, 11, 2);
12507 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12508 tmp = fieldFromInstruction(insn, 21, 5);
12509 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12510 return S;
12511 case 344:
12512 tmp = fieldFromInstruction(insn, 11, 5);
12513 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12514 tmp = fieldFromInstruction(insn, 16, 10);
12515 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12516 return S;
12517 case 345:
12518 tmp = fieldFromInstruction(insn, 21, 5);
12519 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12520 tmp = fieldFromInstruction(insn, 11, 10);
12521 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12522 return S;
12523 case 346:
12524 tmp = fieldFromInstruction(insn, 11, 2);
12525 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12526 tmp = fieldFromInstruction(insn, 20, 6);
12527 if (!Check(S, DecodeSImmWithOffsetAndScale<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12528 tmp = fieldFromInstruction(insn, 11, 2);
12529 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12530 return S;
12531 case 347:
12532 tmp = fieldFromInstruction(insn, 11, 2);
12533 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12534 tmp = fieldFromInstruction(insn, 21, 5);
12535 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12536 tmp = fieldFromInstruction(insn, 11, 2);
12537 if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12538 return S;
12539 case 348:
12540 tmp = fieldFromInstruction(insn, 16, 5);
12541 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12542 tmp = fieldFromInstruction(insn, 11, 5);
12543 if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12544 tmp = fieldFromInstruction(insn, 6, 3);
12545 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12546 return S;
12547 case 349:
12548 if (!Check(S, DecodeCacheOp(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12549 return S;
12550 case 350:
12551 if (!Check(S, DecodeFMem(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12552 return S;
12553 case 351:
12554 if (!Check(S, DecodeFMem2(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12555 return S;
12556 case 352:
12557 if (!Check(S, DecodeDAHIDATI(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12558 return S;
12559 case 353:
12560 tmp = fieldFromInstruction(insn, 0, 16);
12561 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12562 return S;
12563 case 354:
12564 if (!Check(S, DecodeBlezGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12565 return S;
12566 case 355:
12567 if (!Check(S, DecodeBgtzGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12568 return S;
12569 case 356:
12570 if (!Check(S, DecodeAddiGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12571 return S;
12572 case 357:
12573 tmp = fieldFromInstruction(insn, 16, 5);
12574 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12575 tmp = fieldFromInstruction(insn, 0, 16);
12576 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12577 return S;
12578 case 358:
12579 tmp = fieldFromInstruction(insn, 6, 5);
12580 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12581 tmp = fieldFromInstruction(insn, 6, 5);
12582 if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12583 tmp = fieldFromInstruction(insn, 11, 5);
12584 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12585 tmp = fieldFromInstruction(insn, 16, 5);
12586 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12587 return S;
12588 case 359:
12589 tmp = fieldFromInstruction(insn, 6, 5);
12590 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12591 tmp = fieldFromInstruction(insn, 6, 5);
12592 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12593 tmp = fieldFromInstruction(insn, 11, 5);
12594 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12595 tmp = fieldFromInstruction(insn, 16, 5);
12596 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12597 return S;
12598 case 360:
12599 tmp = fieldFromInstruction(insn, 6, 5);
12600 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12601 tmp = fieldFromInstruction(insn, 6, 5);
12602 if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12603 tmp = fieldFromInstruction(insn, 11, 5);
12604 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12605 tmp = fieldFromInstruction(insn, 16, 5);
12606 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12607 return S;
12608 case 361:
12609 tmp = fieldFromInstruction(insn, 6, 5);
12610 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12611 tmp = fieldFromInstruction(insn, 11, 5);
12612 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12613 tmp = fieldFromInstruction(insn, 16, 5);
12614 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12615 return S;
12616 case 362:
12617 tmp = fieldFromInstruction(insn, 6, 5);
12618 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12619 tmp = fieldFromInstruction(insn, 6, 5);
12620 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12621 tmp = fieldFromInstruction(insn, 11, 5);
12622 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12623 tmp = fieldFromInstruction(insn, 16, 5);
12624 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12625 return S;
12626 case 363:
12627 tmp = fieldFromInstruction(insn, 6, 5);
12628 if (!Check(S, DecodeFGR32CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12629 tmp = fieldFromInstruction(insn, 11, 5);
12630 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12631 tmp = fieldFromInstruction(insn, 16, 5);
12632 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12633 return S;
12634 case 364:
12635 tmp = fieldFromInstruction(insn, 6, 5);
12636 if (!Check(S, DecodeFGR64CCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12637 tmp = fieldFromInstruction(insn, 11, 5);
12638 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12639 tmp = fieldFromInstruction(insn, 16, 5);
12640 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12641 return S;
12642 case 365:
12643 tmp = fieldFromInstruction(insn, 16, 5);
12644 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12645 tmp = fieldFromInstruction(insn, 0, 16);
12646 if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12647 return S;
12648 case 366:
12649 if (!Check(S, DecodeFMemCop2R6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12650 return S;
12651 case 367:
12652 if (!Check(S, DecodeBlezlGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12653 return S;
12654 case 368:
12655 if (!Check(S, DecodeBgtzlGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12656 return S;
12657 case 369:
12658 if (!Check(S, DecodeDaddiGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12659 return S;
12660 case 370:
12661 tmp = fieldFromInstruction(insn, 16, 5);
12662 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12663 tmp = fieldFromInstruction(insn, 21, 5);
12664 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12665 tmp = fieldFromInstruction(insn, 0, 16);
12666 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12667 return S;
12668 case 371:
12669 if (!Check(S, DecodeCRC(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12670 return S;
12671 case 372:
12672 tmp = fieldFromInstruction(insn, 11, 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, 16, 5);
12677 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12678 tmp = fieldFromInstruction(insn, 6, 2);
12679 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12680 return S;
12681 case 373:
12682 tmp = fieldFromInstruction(insn, 11, 5);
12683 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12684 tmp = fieldFromInstruction(insn, 16, 5);
12685 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12686 return S;
12687 case 374:
12688 tmp = fieldFromInstruction(insn, 11, 5);
12689 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12690 tmp = fieldFromInstruction(insn, 21, 5);
12691 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12692 tmp = fieldFromInstruction(insn, 16, 5);
12693 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12694 tmp = fieldFromInstruction(insn, 6, 3);
12695 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12696 return S;
12697 case 375:
12698 if (!Check(S, DecodeSpecial3LlSc(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12699 return S;
12700 case 376:
12701 tmp = fieldFromInstruction(insn, 21, 5);
12702 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12703 tmp = fieldFromInstruction(insn, 8, 2);
12704 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12705 return S;
12706 case 377:
12707 tmp = fieldFromInstruction(insn, 0, 26);
12708 if (!Check(S, DecodeBranchTarget26(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12709 return S;
12710 case 378:
12711 tmp = fieldFromInstruction(insn, 21, 5);
12712 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12713 tmp = fieldFromInstruction(insn, 0, 21);
12714 if (!Check(S, DecodeBranchTarget21(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12715 return S;
12716 case 379:
12717 tmp = fieldFromInstruction(insn, 21, 5);
12718 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12719 tmp = fieldFromInstruction(insn, 0, 18);
12720 if (!Check(S, DecodeSimm18Lsl3(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12721 return S;
12722 case 380:
12723 tmp = fieldFromInstruction(insn, 21, 5);
12724 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12725 tmp = fieldFromInstruction(insn, 0, 21);
12726 if (!Check(S, DecodeBranchTarget21(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12727 return S;
12728 case 381:
12729 tmp = fieldFromInstruction(insn, 11, 5);
12730 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12731 tmp = fieldFromInstruction(insn, 16, 5);
12732 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12733 tmp = fieldFromInstruction(insn, 21, 5);
12734 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12735 return S;
12736 case 382:
12737 tmp = fieldFromInstruction(insn, 21, 5);
12738 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12739 tmp = fieldFromInstruction(insn, 16, 5);
12740 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12741 return S;
12742 case 383:
12743 tmp = fieldFromInstruction(insn, 11, 5);
12744 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12745 tmp = fieldFromInstruction(insn, 16, 5);
12746 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12747 tmp = fieldFromInstruction(insn, 6, 5);
12748 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12749 return S;
12750 case 384:
12751 tmp = fieldFromInstruction(insn, 16, 5);
12752 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12753 tmp = fieldFromInstruction(insn, 11, 5);
12754 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12755 tmp = fieldFromInstruction(insn, 0, 3);
12756 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12757 return S;
12758 case 385:
12759 tmp = fieldFromInstruction(insn, 11, 5);
12760 if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12761 tmp = fieldFromInstruction(insn, 16, 5);
12762 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12763 tmp = fieldFromInstruction(insn, 0, 3);
12764 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12765 return S;
12766 case 386:
12767 tmp = fieldFromInstruction(insn, 16, 5);
12768 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12769 tmp = fieldFromInstruction(insn, 11, 5);
12770 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12771 tmp = fieldFromInstruction(insn, 0, 3);
12772 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12773 return S;
12774 case 387:
12775 tmp = fieldFromInstruction(insn, 11, 5);
12776 if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12777 tmp = fieldFromInstruction(insn, 16, 5);
12778 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12779 tmp = fieldFromInstruction(insn, 0, 3);
12780 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
12781 return S;
12782 case 388:
12783 tmp = fieldFromInstruction(insn, 13, 3);
12784 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12785 tmp = fieldFromInstruction(insn, 16, 5);
12786 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12787 tmp = fieldFromInstruction(insn, 21, 5);
12788 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12789 return S;
12790 case 389:
12791 tmp = fieldFromInstruction(insn, 16, 5);
12792 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12793 tmp = fieldFromInstruction(insn, 21, 5);
12794 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12795 tmp = fieldFromInstruction(insn, 0, 16);
12796 if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12797 return S;
12798 case 390:
12799 tmp = 0x0;
12800 tmp |= fieldFromInstruction(insn, 11, 5);
12801 tmp |= fieldFromInstruction(insn, 16, 5);
12802 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12803 tmp = fieldFromInstruction(insn, 21, 5);
12804 if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12805 return S;
12806 case 391:
12807 if (!Check(S, DecodeDEXT(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12808 return S;
12809 case 392:
12810 if (!Check(S, DecodeDINS(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; }
12811 return S;
12812 case 393:
12813 tmp = fieldFromInstruction(insn, 16, 5);
12814 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12815 tmp = fieldFromInstruction(insn, 11, 5);
12816 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12817 return S;
12818 case 394:
12819 tmp = fieldFromInstruction(insn, 11, 5);
12820 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12821 tmp = fieldFromInstruction(insn, 16, 5);
12822 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12823 return S;
12824 case 395:
12825 tmp = fieldFromInstruction(insn, 11, 5);
12826 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12827 tmp = fieldFromInstruction(insn, 11, 5);
12828 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12829 tmp = fieldFromInstruction(insn, 16, 5);
12830 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12831 return S;
12832 case 396:
12833 tmp = fieldFromInstruction(insn, 6, 5);
12834 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12835 tmp = fieldFromInstruction(insn, 11, 5);
12836 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12837 return S;
12838 case 397:
12839 tmp = fieldFromInstruction(insn, 6, 5);
12840 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12841 tmp = fieldFromInstruction(insn, 11, 5);
12842 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12843 tmp = fieldFromInstruction(insn, 18, 3);
12844 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12845 tmp = fieldFromInstruction(insn, 6, 5);
12846 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12847 return S;
12848 case 398:
12849 tmp = fieldFromInstruction(insn, 6, 5);
12850 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12851 tmp = fieldFromInstruction(insn, 11, 5);
12852 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12853 tmp = fieldFromInstruction(insn, 16, 5);
12854 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12855 tmp = fieldFromInstruction(insn, 6, 5);
12856 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12857 return S;
12858 case 399:
12859 tmp = fieldFromInstruction(insn, 6, 5);
12860 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12861 tmp = fieldFromInstruction(insn, 11, 5);
12862 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12863 tmp = fieldFromInstruction(insn, 16, 5);
12864 if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12865 return S;
12866 case 400:
12867 tmp = fieldFromInstruction(insn, 8, 3);
12868 if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12869 tmp = fieldFromInstruction(insn, 11, 5);
12870 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12871 tmp = fieldFromInstruction(insn, 16, 5);
12872 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12873 return S;
12874 case 401:
12875 tmp = fieldFromInstruction(insn, 6, 5);
12876 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12877 tmp = fieldFromInstruction(insn, 21, 5);
12878 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12879 tmp = fieldFromInstruction(insn, 16, 5);
12880 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12881 return S;
12882 case 402:
12883 tmp = fieldFromInstruction(insn, 11, 5);
12884 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12885 tmp = fieldFromInstruction(insn, 21, 5);
12886 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12887 tmp = fieldFromInstruction(insn, 16, 5);
12888 if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12889 return S;
12890 case 403:
12891 tmp = fieldFromInstruction(insn, 6, 5);
12892 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12893 tmp = fieldFromInstruction(insn, 21, 5);
12894 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12895 tmp = fieldFromInstruction(insn, 11, 5);
12896 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12897 tmp = fieldFromInstruction(insn, 16, 5);
12898 if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
12899 return S;
12900 }
12901}
12902static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) {
12903 switch (Idx) {
12904 default: llvm_unreachable("Invalid index!");
12905 case 0:
12906 return FB[Mips::FeatureMips16];
12907 case 1:
12908 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]);
12909 case 2:
12910 return FB[Mips::FeatureMicroMips];
12911 case 3:
12912 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6];
12913 case 4:
12914 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureCnMips]) && !(FB[Mips::FeatureMicroMips]);
12915 case 5:
12916 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureCnMips]) && !(FB[Mips::FeatureMicroMips]);
12917 case 6:
12918 return FB[Mips::FeatureCnMips];
12919 case 7:
12920 return FB[Mips::FeatureMips64] && FB[Mips::FeatureCnMips] && !(FB[Mips::FeatureMicroMips]);
12921 case 8:
12922 return FB[Mips::FeatureCnMipsP];
12923 case 9:
12924 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSP];
12925 case 10:
12926 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSPR2];
12927 case 11:
12928 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r5] && FB[Mips::FeatureVirt];
12929 case 12:
12930 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSPR3];
12931 case 13:
12932 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && FB[Mips::FeatureDSP];
12933 case 14:
12934 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]);
12935 case 15:
12936 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]);
12937 case 16:
12938 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]);
12939 case 17:
12940 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]);
12941 case 18:
12942 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]);
12943 case 19:
12944 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]);
12945 case 20:
12946 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureSoftFloat]);
12947 case 21:
12948 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]);
12949 case 22:
12950 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureEVA];
12951 case 23:
12952 return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && FB[Mips::FeatureEVA];
12953 case 24:
12954 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureSoftFloat]);
12955 case 25:
12956 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureGINV];
12957 case 26:
12958 return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureSoftFloat]);
12959 case 27:
12960 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureMicroMips]);
12961 case 28:
12962 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMicroMips]);
12963 case 29:
12964 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
12965 case 30:
12966 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMSA];
12967 case 31:
12968 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
12969 case 32:
12970 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]);
12971 case 33:
12972 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureMicroMips]) && !(FB[Mips::FeatureUseIndirectJumpsHazard]);
12973 case 34:
12974 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32];
12975 case 35:
12976 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
12977 case 36:
12978 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMicroMips]);
12979 case 37:
12980 return FB[Mips::FeatureDSP];
12981 case 38:
12982 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMSA] && FB[Mips::FeatureMips64];
12983 case 39:
12984 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
12985 case 40:
12986 return FB[Mips::FeatureDSP] && !(FB[Mips::FeatureMicroMips]);
12987 case 41:
12988 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32r5] && FB[Mips::FeatureVirt] && !(FB[Mips::FeatureMicroMips]);
12989 case 42:
12990 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMT] && !(FB[Mips::FeatureMicroMips]);
12991 case 43:
12992 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips3_32] && !(FB[Mips::FeatureMicroMips]);
12993 case 44:
12994 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32r2] && FB[Mips::FeatureEVA] && !(FB[Mips::FeatureMicroMips]);
12995 case 45:
12996 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32r5] && !(FB[Mips::FeatureMicroMips]);
12997 case 46:
12998 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32] && !(FB[Mips::FeatureMicroMips]);
12999 case 47:
13000 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13001 case 48:
13002 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureSingleFloat]);
13003 case 49:
13004 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13005 case 50:
13006 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13007 case 51:
13008 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13009 case 52:
13010 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13011 case 53:
13012 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureSoftFloat]);
13013 case 54:
13014 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13015 case 55:
13016 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13017 case 56:
13018 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13019 case 57:
13020 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips3_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13021 case 58:
13022 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13023 case 59:
13024 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13025 case 60:
13026 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13027 case 61:
13028 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13029 case 62:
13030 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13031 case 63:
13032 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]);
13033 case 64:
13034 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13035 case 65:
13036 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips5_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13037 case 66:
13038 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]) && !(FB[Mips::FeatureNoMadd4]);
13039 case 67:
13040 return !(FB[Mips::FeatureMips16]) && !(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]);
13041 case 68:
13042 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]) && !(FB[Mips::FeatureMicroMips]);
13043 case 69:
13044 return !(FB[Mips::FeatureMips16]) && !(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]);
13045 case 70:
13046 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
13047 case 71:
13048 return FB[Mips::FeatureDSPR2];
13049 case 72:
13050 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && FB[Mips::FeatureEVA] && !(FB[Mips::FeatureMicroMips]);
13051 case 73:
13052 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips3_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
13053 case 74:
13054 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeaturePTR64Bit]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureMicroMips]);
13055 case 75:
13056 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeaturePTR64Bit] && !(FB[Mips::FeatureMicroMips]);
13057 case 76:
13058 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureMicroMips]);
13059 case 77:
13060 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32r6];
13061 case 78:
13062 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureMicroMips]);
13063 case 79:
13064 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips64r6] && !(FB[Mips::FeatureMicroMips]);
13065 case 80:
13066 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeatureGP64Bit]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureMicroMips]);
13067 case 81:
13068 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13069 case 82:
13070 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureCRC] && !(FB[Mips::FeatureMicroMips]);
13071 case 83:
13072 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips64r6] && FB[Mips::FeatureCRC] && !(FB[Mips::FeatureMicroMips]);
13073 case 84:
13074 return !(FB[Mips::FeatureMips16]) && !(FB[Mips::FeaturePTR64Bit]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureMicroMips]);
13075 case 85:
13076 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureGINV] && !(FB[Mips::FeatureMicroMips]);
13077 case 86:
13078 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips64r6];
13079 case 87:
13080 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips64r6];
13081 case 88:
13082 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips32r6];
13083 case 89:
13084 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips64r6] && !(FB[Mips::FeatureMicroMips]);
13085 case 90:
13086 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips64] && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
13087 case 91:
13088 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeaturePTR64Bit];
13089 case 92:
13090 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips64r2] && !(FB[Mips::FeatureMicroMips]);
13091 case 93:
13092 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMicroMips]);
13093 case 94:
13094 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureMicroMips]);
13095 case 95:
13096 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips3];
13097 case 96:
13098 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips64r5] && FB[Mips::FeatureVirt];
13099 case 97:
13100 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]);
13101 case 98:
13102 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips64] && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]);
13103 case 99:
13104 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]);
13105 case 100:
13106 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureDSP];
13107 case 101:
13108 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13109 case 102:
13110 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13111 case 103:
13112 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13113 case 104:
13114 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13115 case 105:
13116 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips3_32] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13117 case 106:
13118 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13119 case 107:
13120 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13121 case 108:
13122 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && FB[Mips::FeatureMips3D];
13123 case 109:
13124 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips3_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13125 case 110:
13126 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13127 case 111:
13128 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]);
13129 case 112:
13130 return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips5_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]);
13131 case 113:
13132 return !(FB[Mips::FeatureMips16]) && 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]);
13133 case 114:
13134 return !(FB[Mips::FeatureMips16]) && 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]);
13135 }
13136}
13137
13138
13139template <typename InsnType>
13140static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
13141 InsnType insn, uint64_t Address,
13142 const MCDisassembler *DisAsm,
13143 const MCSubtargetInfo &STI) {
13144 const FeatureBitset &Bits = STI.getFeatureBits();
13145 const uint8_t *Ptr = DecodeTable;
13146
13147 SmallVector<const uint8_t *, 8> ScopeStack;
13148 DecodeStatus S = MCDisassembler::Success;
13149 while (true) {
13150 ptrdiff_t Loc = Ptr - DecodeTable;
13151 const uint8_t DecoderOp = *Ptr++;
13152 switch (DecoderOp) {
13153 default:
13154 errs() << Loc << ": Unexpected decode table opcode: "
13155 << (int)DecoderOp << '\n';
13156 return MCDisassembler::Fail;
13157 case OPC_Scope: {
13158 unsigned NumToSkip = decodeULEB128AndIncUnsafe(p&: Ptr);
13159 const uint8_t *SkipTo = Ptr + NumToSkip;
13160 ScopeStack.push_back(Elt: SkipTo);
13161 LLVM_DEBUG(dbgs() << Loc << ": OPC_Scope(" << SkipTo - DecodeTable
13162 << ")\n");
13163 continue;
13164 }
13165 case OPC_SwitchField: {
13166 // Decode the start value.
13167 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
13168 unsigned Len = *Ptr++;
13169 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
13170 uint64_t CaseValue;
13171 unsigned CaseSize;
13172 while (true) {
13173 CaseValue = decodeULEB128AndIncUnsafe(p&: Ptr);
13174 CaseSize = decodeULEB128AndIncUnsafe(p&: Ptr);
13175 if (FieldValue == CaseValue || !CaseSize)
13176 break;
13177 Ptr += CaseSize;
13178 }
13179 if (FieldValue == CaseValue) {
13180 LLVM_DEBUG(dbgs() << Loc << ": OPC_SwitchField(" << Start << ", " << Len
13181 << "): " << FieldValue << '\n');
13182 continue;
13183 }
13184 break;
13185 }
13186 case OPC_CheckField: {
13187 // Decode the start value.
13188 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
13189 unsigned Len = *Ptr;
13190 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
13191 // Decode the field value.
13192 unsigned PtrLen = 0;
13193 uint64_t ExpectedValue = decodeULEB128(p: ++Ptr, n: &PtrLen);
13194 Ptr += PtrLen;
13195 bool Failed = ExpectedValue != FieldValue;
13196
13197 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckField(" << Start << ", " << Len
13198 << ", " << ExpectedValue << "): FieldValue = "
13199 << FieldValue << ", ExpectedValue = " << ExpectedValue
13200 << ": " << (Failed ? "FAIL, " : "PASS\n"););
13201 if (!Failed)
13202 continue;
13203 break;
13204 }
13205 case OPC_CheckPredicate: {
13206 // Decode the Predicate Index value.
13207 unsigned PIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
13208 // Check the predicate.
13209 bool Failed = !checkDecoderPredicate(Idx: PIdx, FB: Bits);
13210
13211 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckPredicate(" << PIdx << "): "
13212 << (Failed ? "FAIL, " : "PASS\n"););
13213 if (!Failed)
13214 continue;
13215 break;
13216 }
13217 case OPC_Decode: {
13218 // Decode the Opcode value.
13219 unsigned Opc = decodeULEB128AndIncUnsafe(p&: Ptr);
13220 unsigned DecodeIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
13221
13222 MI.clear();
13223 MI.setOpcode(Opc);
13224 bool DecodeComplete;
13225 S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm,
13226 DecodeComplete);
13227 LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc
13228 << ", using decoder " << DecodeIdx << ": "
13229 << (S ? "PASS, " : "FAIL, "));
13230
13231 if (DecodeComplete) {
13232 LLVM_DEBUG(dbgs() << "decoding complete\n");
13233 return S;
13234 }
13235 assert(S == MCDisassembler::Fail);
13236 // Reset decode status. This also drops a SoftFail status that could be
13237 // set before the decode attempt.
13238 S = MCDisassembler::Success;
13239 break;
13240 }
13241 }
13242 if (ScopeStack.empty()) {
13243 LLVM_DEBUG(dbgs() << "returning Fail\n");
13244 return MCDisassembler::Fail;
13245 }
13246 Ptr = ScopeStack.pop_back_val();
13247 LLVM_DEBUG(dbgs() << "continuing at " << Ptr - DecodeTable << '\n');
13248 }
13249 llvm_unreachable("bogosity detected in disassembler state machine!");
13250}
13251
13252
13253} // namespace
13254