| 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 | |
| 19 | namespace { |
| 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. |
| 26 | template <typename T> constexpr uint32_t InsnBitWidth = 0; |
| 27 | |
| 28 | [[maybe_unused]] |
| 29 | static 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]] |
| 41 | static 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]] |
| 53 | static 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]] |
| 65 | static 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 | |
| 77 | static const uint8_t DecoderTable16[352] = { |
| 78 | OPC_SwitchField, 11, 5, // 0: switch Inst[15:11] { |
| 79 | 2, 6, // 3: case 0x2: { |
| 80 | OPC_CheckPredicate, 0, // 5: check predicate 0 |
| 81 | OPC_Decode, 139, 9, 0, // 7: decode to Bimm16 using decoder 0 |
| 82 | // 7: } |
| 83 | 4, 6, // 11: case 0x4: { |
| 84 | OPC_CheckPredicate, 0, // 13: check predicate 0 |
| 85 | OPC_Decode, 137, 9, 1, // 15: decode to BeqzRxImm16 using decoder 1 |
| 86 | // 15: } |
| 87 | 5, 6, // 19: case 0x5: { |
| 88 | OPC_CheckPredicate, 0, // 21: check predicate 0 |
| 89 | OPC_Decode, 141, 9, 1, // 23: decode to BnezRxImm16 using decoder 1 |
| 90 | // 23: } |
| 91 | 9, 6, // 27: case 0x9: { |
| 92 | OPC_CheckPredicate, 0, // 29: check predicate 0 |
| 93 | OPC_Decode, 174, 7, 2, // 31: decode to AddiuRxRxImm16 using decoder 2 |
| 94 | // 31: } |
| 95 | 10, 6, // 35: case 0xa: { |
| 96 | OPC_CheckPredicate, 0, // 37: check predicate 0 |
| 97 | OPC_Decode, 220, 23, 3, // 39: decode to SltiRxImm16 using decoder 3 |
| 98 | // 39: } |
| 99 | 11, 6, // 43: case 0xb: { |
| 100 | OPC_CheckPredicate, 0, // 45: check predicate 0 |
| 101 | OPC_Decode, 222, 23, 3, // 47: decode to SltiuRxImm16 using decoder 3 |
| 102 | // 47: } |
| 103 | 12, 43, // 51: case 0xc: { |
| 104 | OPC_SwitchField, 8, 3, // 53: switch Inst[10:8] { |
| 105 | 0, 6, // 56: case 0x0: { |
| 106 | OPC_CheckPredicate, 0, // 58: check predicate 0 |
| 107 | OPC_Decode, 144, 9, 4, // 60: decode to Bteqz16 using decoder 4 |
| 108 | // 60: } |
| 109 | 1, 6, // 64: case 0x1: { |
| 110 | OPC_CheckPredicate, 0, // 66: check predicate 0 |
| 111 | OPC_Decode, 146, 9, 4, // 68: decode to Btnez16 using decoder 4 |
| 112 | // 68: } |
| 113 | 3, 6, // 72: case 0x3: { |
| 114 | OPC_CheckPredicate, 0, // 74: check predicate 0 |
| 115 | OPC_Decode, 177, 7, 4, // 76: decode to AddiuSpImm16 using decoder 4 |
| 116 | // 76: } |
| 117 | 5, 6, // 80: case 0x5: { |
| 118 | OPC_CheckPredicate, 0, // 82: check predicate 0 |
| 119 | OPC_Decode, 153, 19, 5, // 84: decode to Move32R16 using decoder 5 |
| 120 | // 84: } |
| 121 | 7, 0, // 88: case 0x7: { |
| 122 | OPC_CheckPredicate, 0, // 90: check predicate 0 |
| 123 | OPC_Decode, 154, 19, 6, // 92: decode to MoveR3216 using decoder 6 |
| 124 | // 92: } |
| 125 | // 92: } // switch Inst[10:8] |
| 126 | // 92: } |
| 127 | 13, 6, // 96: case 0xd: { |
| 128 | OPC_CheckPredicate, 0, // 98: check predicate 0 |
| 129 | OPC_Decode, 216, 16, 3, // 100: decode to LiRxImm16 using decoder 3 |
| 130 | // 100: } |
| 131 | 14, 6, // 104: case 0xe: { |
| 132 | OPC_CheckPredicate, 0, // 106: check predicate 0 |
| 133 | OPC_Decode, 219, 11, 3, // 108: decode to CmpiRxImm16 using decoder 3 |
| 134 | // 108: } |
| 135 | 22, 6, // 112: case 0x16: { |
| 136 | OPC_CheckPredicate, 0, // 114: check predicate 0 |
| 137 | OPC_Decode, 219, 16, 7, // 116: decode to LwRxPcTcp16 using decoder 7 |
| 138 | // 116: } |
| 139 | 28, 19, // 120: case 0x1c: { |
| 140 | OPC_SwitchField, 0, 2, // 122: switch Inst[1:0] { |
| 141 | 1, 6, // 125: case 0x1: { |
| 142 | OPC_CheckPredicate, 0, // 127: check predicate 0 |
| 143 | OPC_Decode, 179, 7, 8, // 129: decode to AdduRxRyRz16 using decoder 8 |
| 144 | // 129: } |
| 145 | 3, 0, // 133: case 0x3: { |
| 146 | OPC_CheckPredicate, 0, // 135: check predicate 0 |
| 147 | OPC_Decode, 229, 23, 8, // 137: decode to SubuRxRyRz16 using decoder 8 |
| 148 | // 137: } |
| 149 | // 137: } // switch Inst[1:0] |
| 150 | // 137: } |
| 151 | 29, 0, // 141: case 0x1d: { |
| 152 | OPC_SwitchField, 0, 5, // 143: switch Inst[4:0] { |
| 153 | 0, 43, // 146: case 0x0: { |
| 154 | OPC_SwitchField, 5, 3, // 148: switch Inst[7:5] { |
| 155 | 0, 6, // 151: case 0x0: { |
| 156 | OPC_CheckPredicate, 0, // 153: check predicate 0 |
| 157 | OPC_Decode, 180, 15, 9, // 155: decode to JumpLinkReg16 using decoder 9 |
| 158 | // 155: } |
| 159 | 1, 10, // 159: case 0x1: { |
| 160 | OPC_CheckPredicate, 0, // 161: check predicate 0 |
| 161 | OPC_CheckField, 8, 3, 0, // 163: check Inst[10:8] == 0x0 |
| 162 | OPC_Decode, 177, 15, 10, // 167: decode to JrRa16 using decoder 10 |
| 163 | // 167: } |
| 164 | 6, 6, // 171: case 0x6: { |
| 165 | OPC_CheckPredicate, 0, // 173: check predicate 0 |
| 166 | OPC_Decode, 179, 15, 9, // 175: decode to JrcRx16 using decoder 9 |
| 167 | // 175: } |
| 168 | 7, 0, // 179: case 0x7: { |
| 169 | OPC_CheckPredicate, 0, // 181: check predicate 0 |
| 170 | OPC_CheckField, 8, 3, 0, // 183: check Inst[10:8] == 0x0 |
| 171 | OPC_Decode, 178, 15, 10, // 187: decode to JrcRa16 using decoder 10 |
| 172 | // 187: } |
| 173 | // 187: } // switch Inst[7:5] |
| 174 | // 187: } |
| 175 | 2, 6, // 191: case 0x2: { |
| 176 | OPC_CheckPredicate, 0, // 193: check predicate 0 |
| 177 | OPC_Decode, 219, 23, 11, // 195: decode to SltRxRy16 using decoder 11 |
| 178 | // 195: } |
| 179 | 3, 6, // 199: case 0x3: { |
| 180 | OPC_CheckPredicate, 0, // 201: check predicate 0 |
| 181 | OPC_Decode, 224, 23, 11, // 203: decode to SltuRxRy16 using decoder 11 |
| 182 | // 203: } |
| 183 | 4, 6, // 207: case 0x4: { |
| 184 | OPC_CheckPredicate, 0, // 209: check predicate 0 |
| 185 | OPC_Decode, 218, 23, 12, // 211: decode to SllvRxRy16 using decoder 12 |
| 186 | // 211: } |
| 187 | 5, 10, // 215: case 0x5: { |
| 188 | OPC_CheckPredicate, 0, // 217: check predicate 0 |
| 189 | OPC_CheckField, 5, 6, 0, // 219: check Inst[10:5] == 0x0 |
| 190 | OPC_Decode, 143, 9, 10, // 223: decode to Break16 using decoder 10 |
| 191 | // 223: } |
| 192 | 6, 6, // 227: case 0x6: { |
| 193 | OPC_CheckPredicate, 0, // 229: check predicate 0 |
| 194 | OPC_Decode, 228, 23, 12, // 231: decode to SrlvRxRy16 using decoder 12 |
| 195 | // 231: } |
| 196 | 7, 6, // 235: case 0x7: { |
| 197 | OPC_CheckPredicate, 0, // 237: check predicate 0 |
| 198 | OPC_Decode, 226, 23, 12, // 239: decode to SravRxRy16 using decoder 12 |
| 199 | // 239: } |
| 200 | 10, 6, // 243: case 0xa: { |
| 201 | OPC_CheckPredicate, 0, // 245: check predicate 0 |
| 202 | OPC_Decode, 218, 11, 11, // 247: decode to CmpRxRy16 using decoder 11 |
| 203 | // 247: } |
| 204 | 12, 6, // 251: case 0xc: { |
| 205 | OPC_CheckPredicate, 0, // 253: check predicate 0 |
| 206 | OPC_Decode, 180, 7, 12, // 255: decode to AndRxRxRy16 using decoder 12 |
| 207 | // 255: } |
| 208 | 13, 6, // 259: case 0xd: { |
| 209 | OPC_CheckPredicate, 0, // 261: check predicate 0 |
| 210 | OPC_Decode, 203, 19, 12, // 263: decode to OrRxRxRy16 using decoder 12 |
| 211 | // 263: } |
| 212 | 14, 6, // 267: case 0xe: { |
| 213 | OPC_CheckPredicate, 0, // 269: check predicate 0 |
| 214 | OPC_Decode, 206, 24, 12, // 271: decode to XorRxRxRy16 using decoder 12 |
| 215 | // 271: } |
| 216 | 15, 6, // 275: case 0xf: { |
| 217 | OPC_CheckPredicate, 0, // 277: check predicate 0 |
| 218 | OPC_Decode, 187, 19, 11, // 279: decode to NotRxRy16 using decoder 11 |
| 219 | // 279: } |
| 220 | 16, 10, // 283: case 0x10: { |
| 221 | OPC_CheckPredicate, 0, // 285: check predicate 0 |
| 222 | OPC_CheckField, 5, 3, 0, // 287: check Inst[7:5] == 0x0 |
| 223 | OPC_Decode, 151, 19, 9, // 291: decode to Mfhi16 using decoder 9 |
| 224 | // 291: } |
| 225 | 17, 19, // 295: case 0x11: { |
| 226 | OPC_SwitchField, 5, 3, // 297: switch Inst[7:5] { |
| 227 | 4, 6, // 300: case 0x4: { |
| 228 | OPC_CheckPredicate, 0, // 302: check predicate 0 |
| 229 | OPC_Decode, 214, 23, 13, // 304: decode to SebRx16 using decoder 13 |
| 230 | // 304: } |
| 231 | 5, 0, // 308: case 0x5: { |
| 232 | OPC_CheckPredicate, 0, // 310: check predicate 0 |
| 233 | OPC_Decode, 215, 23, 13, // 312: decode to SehRx16 using decoder 13 |
| 234 | // 312: } |
| 235 | // 312: } // switch Inst[7:5] |
| 236 | // 312: } |
| 237 | 18, 10, // 316: case 0x12: { |
| 238 | OPC_CheckPredicate, 0, // 318: check predicate 0 |
| 239 | OPC_CheckField, 5, 3, 0, // 320: check Inst[7:5] == 0x0 |
| 240 | OPC_Decode, 152, 19, 9, // 324: decode to Mflo16 using decoder 9 |
| 241 | // 324: } |
| 242 | 26, 6, // 328: case 0x1a: { |
| 243 | OPC_CheckPredicate, 0, // 330: check predicate 0 |
| 244 | OPC_Decode, 233, 12, 11, // 332: decode to DivRxRy16 using decoder 11 |
| 245 | // 332: } |
| 246 | 27, 6, // 336: case 0x1b: { |
| 247 | OPC_CheckPredicate, 0, // 338: check predicate 0 |
| 248 | OPC_Decode, 234, 12, 11, // 340: decode to DivuRxRy16 using decoder 11 |
| 249 | // 340: } |
| 250 | 29, 0, // 344: case 0x1d: { |
| 251 | OPC_CheckPredicate, 0, // 346: check predicate 0 |
| 252 | OPC_Decode, 186, 19, 11, // 348: decode to NegRxRy16 using decoder 11 |
| 253 | // 348: } |
| 254 | // 348: } // switch Inst[4:0] |
| 255 | // 348: } |
| 256 | // 348: } // switch Inst[15:11] |
| 257 | }; |
| 258 | static const uint8_t DecoderTableMicroMips16[375] = { |
| 259 | OPC_SwitchField, 10, 6, // 0: switch Inst[15:10] { |
| 260 | 1, 19, // 3: case 0x1: { |
| 261 | OPC_SwitchField, 0, 1, // 5: switch Inst[0] { |
| 262 | 0, 6, // 8: case 0x0: { |
| 263 | OPC_CheckPredicate, 1, // 10: check predicate 1 |
| 264 | OPC_Decode, 206, 6, 14, // 12: decode to ADDU16_MM using decoder 14 |
| 265 | // 12: } |
| 266 | 1, 0, // 16: case 0x1: { |
| 267 | OPC_CheckPredicate, 1, // 18: check predicate 1 |
| 268 | OPC_Decode, 248, 22, 14, // 20: decode to SUBU16_MM using decoder 14 |
| 269 | // 20: } |
| 270 | // 20: } // switch Inst[0] |
| 271 | // 20: } |
| 272 | 2, 6, // 24: case 0x2: { |
| 273 | OPC_CheckPredicate, 2, // 26: check predicate 2 |
| 274 | OPC_Decode, 189, 15, 15, // 28: decode to LBU16_MM using decoder 15 |
| 275 | // 28: } |
| 276 | 3, 6, // 32: case 0x3: { |
| 277 | OPC_CheckPredicate, 1, // 34: check predicate 1 |
| 278 | OPC_Decode, 234, 17, 16, // 36: decode to MOVE16_MM using decoder 16 |
| 279 | // 36: } |
| 280 | 9, 19, // 40: case 0x9: { |
| 281 | OPC_SwitchField, 0, 1, // 42: switch Inst[0] { |
| 282 | 0, 6, // 45: case 0x0: { |
| 283 | OPC_CheckPredicate, 1, // 47: check predicate 1 |
| 284 | OPC_Decode, 245, 21, 17, // 49: decode to SLL16_MM using decoder 17 |
| 285 | // 49: } |
| 286 | 1, 0, // 53: case 0x1: { |
| 287 | OPC_CheckPredicate, 1, // 55: check predicate 1 |
| 288 | OPC_Decode, 186, 22, 17, // 57: decode to SRL16_MM using decoder 17 |
| 289 | // 57: } |
| 290 | // 57: } // switch Inst[0] |
| 291 | // 57: } |
| 292 | 10, 6, // 61: case 0xa: { |
| 293 | OPC_CheckPredicate, 2, // 63: check predicate 2 |
| 294 | OPC_Decode, 240, 15, 18, // 65: decode to LHU16_MM using decoder 18 |
| 295 | // 65: } |
| 296 | 11, 6, // 69: case 0xb: { |
| 297 | OPC_CheckPredicate, 1, // 71: check predicate 1 |
| 298 | OPC_Decode, 129, 7, 19, // 73: decode to ANDI16_MM using decoder 19 |
| 299 | // 73: } |
| 300 | 17, 153, 1, // 77: case 0x11: { |
| 301 | OPC_SwitchField, 6, 4, // 80: switch Inst[9:6] { |
| 302 | 0, 6, // 83: case 0x0: { |
| 303 | OPC_CheckPredicate, 1, // 85: check predicate 1 |
| 304 | OPC_Decode, 183, 19, 20, // 87: decode to NOT16_MM using decoder 20 |
| 305 | // 87: } |
| 306 | 1, 6, // 91: case 0x1: { |
| 307 | OPC_CheckPredicate, 1, // 93: check predicate 1 |
| 308 | OPC_Decode, 192, 24, 21, // 95: decode to XOR16_MM using decoder 21 |
| 309 | // 95: } |
| 310 | 2, 6, // 99: case 0x2: { |
| 311 | OPC_CheckPredicate, 1, // 101: check predicate 1 |
| 312 | OPC_Decode, 253, 6, 21, // 103: decode to AND16_MM using decoder 21 |
| 313 | // 103: } |
| 314 | 3, 6, // 107: case 0x3: { |
| 315 | OPC_CheckPredicate, 1, // 109: check predicate 1 |
| 316 | OPC_Decode, 189, 19, 21, // 111: decode to OR16_MM using decoder 21 |
| 317 | // 111: } |
| 318 | 4, 6, // 115: case 0x4: { |
| 319 | OPC_CheckPredicate, 1, // 117: check predicate 1 |
| 320 | OPC_Decode, 182, 16, 22, // 119: decode to LWM16_MM using decoder 22 |
| 321 | // 119: } |
| 322 | 5, 6, // 123: case 0x5: { |
| 323 | OPC_CheckPredicate, 1, // 125: check predicate 1 |
| 324 | OPC_Decode, 176, 23, 22, // 127: decode to SWM16_MM using decoder 22 |
| 325 | // 127: } |
| 326 | 6, 19, // 131: case 0x6: { |
| 327 | OPC_SwitchField, 5, 1, // 133: switch Inst[5] { |
| 328 | 0, 6, // 136: case 0x0: { |
| 329 | OPC_CheckPredicate, 1, // 138: check predicate 1 |
| 330 | OPC_Decode, 161, 15, 23, // 140: decode to JR16_MM using decoder 23 |
| 331 | // 140: } |
| 332 | 1, 0, // 144: case 0x1: { |
| 333 | OPC_CheckPredicate, 1, // 146: check predicate 1 |
| 334 | OPC_Decode, 164, 15, 23, // 148: decode to JRC16_MM using decoder 23 |
| 335 | // 148: } |
| 336 | // 148: } // switch Inst[5] |
| 337 | // 148: } |
| 338 | 7, 19, // 152: case 0x7: { |
| 339 | OPC_SwitchField, 5, 1, // 154: switch Inst[5] { |
| 340 | 0, 6, // 157: case 0x0: { |
| 341 | OPC_CheckPredicate, 1, // 159: check predicate 1 |
| 342 | OPC_Decode, 136, 15, 23, // 161: decode to JALR16_MM using decoder 23 |
| 343 | // 161: } |
| 344 | 1, 0, // 165: case 0x1: { |
| 345 | OPC_CheckPredicate, 1, // 167: check predicate 1 |
| 346 | OPC_Decode, 144, 15, 23, // 169: decode to JALRS16_MM using decoder 23 |
| 347 | // 169: } |
| 348 | // 169: } // switch Inst[5] |
| 349 | // 169: } |
| 350 | 8, 10, // 173: case 0x8: { |
| 351 | OPC_CheckPredicate, 1, // 175: check predicate 1 |
| 352 | OPC_CheckField, 5, 1, 0, // 177: check Inst[5] == 0x0 |
| 353 | OPC_Decode, 178, 17, 23, // 181: decode to MFHI16_MM using decoder 23 |
| 354 | // 181: } |
| 355 | 9, 10, // 185: case 0x9: { |
| 356 | OPC_CheckPredicate, 1, // 187: check predicate 1 |
| 357 | OPC_CheckField, 5, 1, 0, // 189: check Inst[5] == 0x0 |
| 358 | OPC_Decode, 184, 17, 23, // 193: decode to MFLO16_MM using decoder 23 |
| 359 | // 193: } |
| 360 | 10, 10, // 197: case 0xa: { |
| 361 | OPC_CheckPredicate, 1, // 199: check predicate 1 |
| 362 | OPC_CheckField, 4, 2, 0, // 201: check Inst[5:4] == 0x0 |
| 363 | OPC_Decode, 242, 8, 24, // 205: decode to BREAK16_MM using decoder 24 |
| 364 | // 205: } |
| 365 | 11, 10, // 209: case 0xb: { |
| 366 | OPC_CheckPredicate, 1, // 211: check predicate 1 |
| 367 | OPC_CheckField, 4, 2, 0, // 213: check Inst[5:4] == 0x0 |
| 368 | OPC_Decode, 245, 20, 24, // 217: decode to SDBBP16_MM using decoder 24 |
| 369 | // 217: } |
| 370 | 12, 0, // 221: case 0xc: { |
| 371 | OPC_CheckPredicate, 1, // 223: check predicate 1 |
| 372 | OPC_CheckField, 5, 1, 0, // 225: check Inst[5] == 0x0 |
| 373 | OPC_Decode, 163, 15, 25, // 229: decode to JRADDIUSP using decoder 25 |
| 374 | // 229: } |
| 375 | // 229: } // switch Inst[9:6] |
| 376 | // 229: } |
| 377 | 18, 6, // 233: case 0x12: { |
| 378 | OPC_CheckPredicate, 2, // 235: check predicate 2 |
| 379 | OPC_Decode, 196, 16, 26, // 237: decode to LWSP_MM using decoder 26 |
| 380 | // 237: } |
| 381 | 19, 19, // 241: case 0x13: { |
| 382 | OPC_SwitchField, 0, 1, // 243: switch Inst[0] { |
| 383 | 0, 6, // 246: case 0x0: { |
| 384 | OPC_CheckPredicate, 2, // 248: check predicate 2 |
| 385 | OPC_Decode, 173, 6, 27, // 250: decode to ADDIUS5_MM using decoder 27 |
| 386 | // 250: } |
| 387 | 1, 0, // 254: case 0x1: { |
| 388 | OPC_CheckPredicate, 2, // 256: check predicate 2 |
| 389 | OPC_Decode, 174, 6, 28, // 258: decode to ADDIUSP_MM using decoder 28 |
| 390 | // 258: } |
| 391 | // 258: } // switch Inst[0] |
| 392 | // 258: } |
| 393 | 25, 6, // 262: case 0x19: { |
| 394 | OPC_CheckPredicate, 2, // 264: check predicate 2 |
| 395 | OPC_Decode, 175, 16, 29, // 266: decode to LWGP_MM using decoder 29 |
| 396 | // 266: } |
| 397 | 26, 6, // 270: case 0x1a: { |
| 398 | OPC_CheckPredicate, 2, // 272: check predicate 2 |
| 399 | OPC_Decode, 160, 16, 30, // 274: decode to LW16_MM using decoder 30 |
| 400 | // 274: } |
| 401 | 27, 19, // 278: case 0x1b: { |
| 402 | OPC_SwitchField, 0, 1, // 280: switch Inst[0] { |
| 403 | 0, 6, // 283: case 0x0: { |
| 404 | OPC_CheckPredicate, 2, // 285: check predicate 2 |
| 405 | OPC_Decode, 170, 6, 31, // 287: decode to ADDIUR2_MM using decoder 31 |
| 406 | // 287: } |
| 407 | 1, 0, // 291: case 0x1: { |
| 408 | OPC_CheckPredicate, 2, // 293: check predicate 2 |
| 409 | OPC_Decode, 168, 6, 32, // 295: decode to ADDIUR1SP_MM using decoder 32 |
| 410 | // 295: } |
| 411 | // 295: } // switch Inst[0] |
| 412 | // 295: } |
| 413 | 33, 10, // 299: case 0x21: { |
| 414 | OPC_CheckPredicate, 1, // 301: check predicate 1 |
| 415 | OPC_CheckField, 0, 1, 0, // 303: check Inst[0] == 0x0 |
| 416 | OPC_Decode, 238, 17, 33, // 307: decode to MOVEP_MM using decoder 33 |
| 417 | // 307: } |
| 418 | 34, 6, // 311: case 0x22: { |
| 419 | OPC_CheckPredicate, 1, // 313: check predicate 1 |
| 420 | OPC_Decode, 219, 20, 34, // 315: decode to SB16_MM using decoder 34 |
| 421 | // 315: } |
| 422 | 35, 6, // 319: case 0x23: { |
| 423 | OPC_CheckPredicate, 1, // 321: check predicate 1 |
| 424 | OPC_Decode, 232, 7, 35, // 323: decode to BEQZ16_MM using decoder 35 |
| 425 | // 323: } |
| 426 | 42, 6, // 327: case 0x2a: { |
| 427 | OPC_CheckPredicate, 1, // 329: check predicate 1 |
| 428 | OPC_Decode, 169, 21, 36, // 331: decode to SH16_MM using decoder 36 |
| 429 | // 331: } |
| 430 | 43, 6, // 335: case 0x2b: { |
| 431 | OPC_CheckPredicate, 1, // 337: check predicate 1 |
| 432 | OPC_Decode, 219, 8, 35, // 339: decode to BNEZ16_MM using decoder 35 |
| 433 | // 339: } |
| 434 | 50, 6, // 343: case 0x32: { |
| 435 | OPC_CheckPredicate, 1, // 345: check predicate 1 |
| 436 | OPC_Decode, 188, 23, 26, // 347: decode to SWSP_MM using decoder 26 |
| 437 | // 347: } |
| 438 | 51, 6, // 351: case 0x33: { |
| 439 | OPC_CheckPredicate, 2, // 353: check predicate 2 |
| 440 | OPC_Decode, 181, 7, 37, // 355: decode to B16_MM using decoder 37 |
| 441 | // 355: } |
| 442 | 58, 6, // 359: case 0x3a: { |
| 443 | OPC_CheckPredicate, 1, // 361: check predicate 1 |
| 444 | OPC_Decode, 154, 23, 38, // 363: decode to SW16_MM using decoder 38 |
| 445 | // 363: } |
| 446 | 59, 0, // 367: case 0x3b: { |
| 447 | OPC_CheckPredicate, 1, // 369: check predicate 1 |
| 448 | OPC_Decode, 131, 16, 39, // 371: decode to LI16_MM using decoder 39 |
| 449 | // 371: } |
| 450 | // 371: } // switch Inst[15:10] |
| 451 | }; |
| 452 | static const uint8_t DecoderTableMicroMipsR616[257] = { |
| 453 | OPC_SwitchField, 10, 6, // 0: switch Inst[15:10] { |
| 454 | 1, 19, // 3: case 0x1: { |
| 455 | OPC_SwitchField, 0, 1, // 5: switch Inst[0] { |
| 456 | 0, 6, // 8: case 0x0: { |
| 457 | OPC_CheckPredicate, 3, // 10: check predicate 3 |
| 458 | OPC_Decode, 207, 6, 40, // 12: decode to ADDU16_MMR6 using decoder 40 |
| 459 | // 12: } |
| 460 | 1, 0, // 16: case 0x1: { |
| 461 | OPC_CheckPredicate, 3, // 18: check predicate 3 |
| 462 | OPC_Decode, 249, 22, 40, // 20: decode to SUBU16_MMR6 using decoder 40 |
| 463 | // 20: } |
| 464 | // 20: } // switch Inst[0] |
| 465 | // 20: } |
| 466 | 3, 6, // 24: case 0x3: { |
| 467 | OPC_CheckPredicate, 3, // 26: check predicate 3 |
| 468 | OPC_Decode, 235, 17, 16, // 28: decode to MOVE16_MMR6 using decoder 16 |
| 469 | // 28: } |
| 470 | 9, 19, // 32: case 0x9: { |
| 471 | OPC_SwitchField, 0, 1, // 34: switch Inst[0] { |
| 472 | 0, 6, // 37: case 0x0: { |
| 473 | OPC_CheckPredicate, 3, // 39: check predicate 3 |
| 474 | OPC_Decode, 246, 21, 17, // 41: decode to SLL16_MMR6 using decoder 17 |
| 475 | // 41: } |
| 476 | 1, 0, // 45: case 0x1: { |
| 477 | OPC_CheckPredicate, 3, // 47: check predicate 3 |
| 478 | OPC_Decode, 187, 22, 17, // 49: decode to SRL16_MMR6 using decoder 17 |
| 479 | // 49: } |
| 480 | // 49: } // switch Inst[0] |
| 481 | // 49: } |
| 482 | 11, 6, // 53: case 0xb: { |
| 483 | OPC_CheckPredicate, 3, // 55: check predicate 3 |
| 484 | OPC_Decode, 130, 7, 19, // 57: decode to ANDI16_MMR6 using decoder 19 |
| 485 | // 57: } |
| 486 | 17, 129, 1, // 61: case 0x11: { |
| 487 | OPC_SwitchField, 2, 1, // 64: switch Inst[2] { |
| 488 | 0, 116, // 67: case 0x0: { |
| 489 | OPC_SwitchField, 0, 2, // 69: switch Inst[1:0] { |
| 490 | 0, 19, // 72: case 0x0: { |
| 491 | OPC_SwitchField, 3, 1, // 74: switch Inst[3] { |
| 492 | 0, 6, // 77: case 0x0: { |
| 493 | OPC_CheckPredicate, 3, // 79: check predicate 3 |
| 494 | OPC_Decode, 184, 19, 41, // 81: decode to NOT16_MMR6 using decoder 41 |
| 495 | // 81: } |
| 496 | 1, 0, // 85: case 0x1: { |
| 497 | OPC_CheckPredicate, 3, // 87: check predicate 3 |
| 498 | OPC_Decode, 193, 24, 42, // 89: decode to XOR16_MMR6 using decoder 42 |
| 499 | // 89: } |
| 500 | // 89: } // switch Inst[3] |
| 501 | // 89: } |
| 502 | 1, 19, // 93: case 0x1: { |
| 503 | OPC_SwitchField, 3, 1, // 95: switch Inst[3] { |
| 504 | 0, 6, // 98: case 0x0: { |
| 505 | OPC_CheckPredicate, 3, // 100: check predicate 3 |
| 506 | OPC_Decode, 254, 6, 42, // 102: decode to AND16_MMR6 using decoder 42 |
| 507 | // 102: } |
| 508 | 1, 0, // 106: case 0x1: { |
| 509 | OPC_CheckPredicate, 3, // 108: check predicate 3 |
| 510 | OPC_Decode, 190, 19, 42, // 110: decode to OR16_MMR6 using decoder 42 |
| 511 | // 110: } |
| 512 | // 110: } // switch Inst[3] |
| 513 | // 110: } |
| 514 | 2, 19, // 114: case 0x2: { |
| 515 | OPC_SwitchField, 3, 1, // 116: switch Inst[3] { |
| 516 | 0, 6, // 119: case 0x0: { |
| 517 | OPC_CheckPredicate, 3, // 121: check predicate 3 |
| 518 | OPC_Decode, 183, 16, 43, // 123: decode to LWM16_MMR6 using decoder 43 |
| 519 | // 123: } |
| 520 | 1, 0, // 127: case 0x1: { |
| 521 | OPC_CheckPredicate, 3, // 129: check predicate 3 |
| 522 | OPC_Decode, 177, 23, 43, // 131: decode to SWM16_MMR6 using decoder 43 |
| 523 | // 131: } |
| 524 | // 131: } // switch Inst[3] |
| 525 | // 131: } |
| 526 | 3, 0, // 135: case 0x3: { |
| 527 | OPC_SwitchField, 3, 2, // 137: switch Inst[4:3] { |
| 528 | 0, 6, // 140: case 0x0: { |
| 529 | OPC_CheckPredicate, 3, // 142: check predicate 3 |
| 530 | OPC_Decode, 165, 15, 44, // 144: decode to JRC16_MMR6 using decoder 44 |
| 531 | // 144: } |
| 532 | 1, 6, // 148: case 0x1: { |
| 533 | OPC_CheckPredicate, 3, // 150: check predicate 3 |
| 534 | OPC_Decode, 138, 15, 44, // 152: decode to JALRC16_MMR6 using decoder 44 |
| 535 | // 152: } |
| 536 | 2, 6, // 156: case 0x2: { |
| 537 | OPC_CheckPredicate, 3, // 158: check predicate 3 |
| 538 | OPC_Decode, 166, 15, 45, // 160: decode to JRCADDIUSP_MMR6 using decoder 45 |
| 539 | // 160: } |
| 540 | 3, 0, // 164: case 0x3: { |
| 541 | OPC_SwitchField, 5, 1, // 166: switch Inst[5] { |
| 542 | 0, 6, // 169: case 0x0: { |
| 543 | OPC_CheckPredicate, 3, // 171: check predicate 3 |
| 544 | OPC_Decode, 243, 8, 46, // 173: decode to BREAK16_MMR6 using decoder 46 |
| 545 | // 173: } |
| 546 | 1, 0, // 177: case 0x1: { |
| 547 | OPC_CheckPredicate, 3, // 179: check predicate 3 |
| 548 | OPC_Decode, 246, 20, 46, // 181: decode to SDBBP16_MMR6 using decoder 46 |
| 549 | // 181: } |
| 550 | // 181: } // switch Inst[5] |
| 551 | // 181: } |
| 552 | // 181: } // switch Inst[4:3] |
| 553 | // 181: } |
| 554 | // 181: } // switch Inst[1:0] |
| 555 | // 181: } |
| 556 | 1, 0, // 185: case 0x1: { |
| 557 | OPC_CheckPredicate, 3, // 187: check predicate 3 |
| 558 | OPC_Decode, 239, 17, 33, // 189: decode to MOVEP_MMR6 using decoder 33 |
| 559 | // 189: } |
| 560 | // 189: } // switch Inst[2] |
| 561 | // 189: } |
| 562 | 34, 6, // 193: case 0x22: { |
| 563 | OPC_CheckPredicate, 3, // 195: check predicate 3 |
| 564 | OPC_Decode, 220, 20, 34, // 197: decode to SB16_MMR6 using decoder 34 |
| 565 | // 197: } |
| 566 | 35, 6, // 201: case 0x23: { |
| 567 | OPC_CheckPredicate, 3, // 203: check predicate 3 |
| 568 | OPC_Decode, 236, 7, 35, // 205: decode to BEQZC16_MMR6 using decoder 35 |
| 569 | // 205: } |
| 570 | 42, 6, // 209: case 0x2a: { |
| 571 | OPC_CheckPredicate, 3, // 211: check predicate 3 |
| 572 | OPC_Decode, 170, 21, 36, // 213: decode to SH16_MMR6 using decoder 36 |
| 573 | // 213: } |
| 574 | 43, 6, // 217: case 0x2b: { |
| 575 | OPC_CheckPredicate, 3, // 219: check predicate 3 |
| 576 | OPC_Decode, 223, 8, 35, // 221: decode to BNEZC16_MMR6 using decoder 35 |
| 577 | // 221: } |
| 578 | 50, 6, // 225: case 0x32: { |
| 579 | OPC_CheckPredicate, 3, // 227: check predicate 3 |
| 580 | OPC_Decode, 189, 23, 26, // 229: decode to SWSP_MMR6 using decoder 26 |
| 581 | // 229: } |
| 582 | 51, 6, // 233: case 0x33: { |
| 583 | OPC_CheckPredicate, 3, // 235: check predicate 3 |
| 584 | OPC_Decode, 198, 7, 37, // 237: decode to BC16_MMR6 using decoder 37 |
| 585 | // 237: } |
| 586 | 58, 6, // 241: case 0x3a: { |
| 587 | OPC_CheckPredicate, 3, // 243: check predicate 3 |
| 588 | OPC_Decode, 155, 23, 38, // 245: decode to SW16_MMR6 using decoder 38 |
| 589 | // 245: } |
| 590 | 59, 0, // 249: case 0x3b: { |
| 591 | OPC_CheckPredicate, 3, // 251: check predicate 3 |
| 592 | OPC_Decode, 132, 16, 39, // 253: decode to LI16_MMR6 using decoder 39 |
| 593 | // 253: } |
| 594 | // 253: } // switch Inst[15:10] |
| 595 | }; |
| 596 | static const uint8_t DecoderTableNanoMips16[454] = { |
| 597 | OPC_SwitchField, 10, 6, // 0: switch Inst[15:10] { |
| 598 | 4, 39, // 3: case 0x4: { |
| 599 | OPC_Scope, 10, // 5: try { |
| 600 | OPC_CheckField, 2, 8, 2, // 7: check Inst[9:2] == 0x2 |
| 601 | OPC_CheckPredicate, 4, // 11: check predicate 4 |
| 602 | OPC_Decode, 208, 23, 47, // 13: decode to SYSCALL16_NM using decoder 47 |
| 603 | OPC_Scope, 19, // 17: } else try { |
| 604 | OPC_SwitchField, 3, 7, // 19: switch Inst[9:3] { |
| 605 | 2, 6, // 22: case 0x2: { |
| 606 | OPC_CheckPredicate, 4, // 24: check predicate 4 |
| 607 | OPC_Decode, 244, 8, 48, // 26: decode to BREAK16_NM using decoder 48 |
| 608 | // 26: } |
| 609 | 3, 0, // 30: case 0x3: { |
| 610 | OPC_CheckPredicate, 4, // 32: check predicate 4 |
| 611 | OPC_Decode, 247, 20, 48, // 34: decode to SDBBP16_NM using decoder 48 |
| 612 | // 34: } |
| 613 | // 34: } // switch Inst[9:3] |
| 614 | // 34: } else try { |
| 615 | OPC_CheckPredicate, 4, // 38: check predicate 4 |
| 616 | OPC_Decode, 241, 17, 49, // 40: decode to MOVE_NM using decoder 49 |
| 617 | // 40: } |
| 618 | // 40: } |
| 619 | 5, 6, // 44: case 0x5: { |
| 620 | OPC_CheckPredicate, 4, // 46: check predicate 4 |
| 621 | OPC_Decode, 161, 16, 50, // 48: decode to LW16_NM using decoder 50 |
| 622 | // 48: } |
| 623 | 6, 6, // 52: case 0x6: { |
| 624 | OPC_CheckPredicate, 4, // 54: check predicate 4 |
| 625 | OPC_Decode, 199, 7, 51, // 56: decode to BC16_NM using decoder 51 |
| 626 | // 56: } |
| 627 | 7, 19, // 60: case 0x7: { |
| 628 | OPC_SwitchField, 8, 1, // 62: switch Inst[8] { |
| 629 | 0, 6, // 65: case 0x0: { |
| 630 | OPC_CheckPredicate, 4, // 67: check predicate 4 |
| 631 | OPC_Decode, 216, 20, 52, // 69: decode to SAVE16_NM using decoder 52 |
| 632 | // 69: } |
| 633 | 1, 0, // 73: case 0x1: { |
| 634 | OPC_CheckPredicate, 4, // 75: check predicate 4 |
| 635 | OPC_Decode, 173, 20, 52, // 77: decode to RESTOREJRC16_NM using decoder 52 |
| 636 | // 77: } |
| 637 | // 77: } // switch Inst[8] |
| 638 | // 77: } |
| 639 | 12, 19, // 81: case 0xc: { |
| 640 | OPC_SwitchField, 3, 1, // 83: switch Inst[3] { |
| 641 | 0, 6, // 86: case 0x0: { |
| 642 | OPC_CheckPredicate, 4, // 88: check predicate 4 |
| 643 | OPC_Decode, 247, 21, 53, // 90: decode to SLL16_NM using decoder 53 |
| 644 | // 90: } |
| 645 | 1, 0, // 94: case 0x1: { |
| 646 | OPC_CheckPredicate, 4, // 96: check predicate 4 |
| 647 | OPC_Decode, 188, 22, 53, // 98: decode to SRL16_NM using decoder 53 |
| 648 | // 98: } |
| 649 | // 98: } // switch Inst[3] |
| 650 | // 98: } |
| 651 | 13, 6, // 102: case 0xd: { |
| 652 | OPC_CheckPredicate, 4, // 104: check predicate 4 |
| 653 | OPC_Decode, 195, 16, 54, // 106: decode to LWSP16_NM using decoder 54 |
| 654 | // 106: } |
| 655 | 14, 6, // 110: case 0xe: { |
| 656 | OPC_CheckPredicate, 4, // 112: check predicate 4 |
| 657 | OPC_Decode, 185, 7, 51, // 114: decode to BALC16_NM using decoder 51 |
| 658 | // 114: } |
| 659 | 15, 27, // 118: case 0xf: { |
| 660 | OPC_SwitchField, 3, 1, // 120: switch Inst[3] { |
| 661 | 0, 10, // 123: case 0x0: { |
| 662 | OPC_CheckPredicate, 4, // 125: check predicate 4 |
| 663 | OPC_CheckField, 8, 1, 0, // 127: check Inst[8] == 0x0 |
| 664 | OPC_Decode, 244, 6, 55, // 131: decode to ADDu4x4_NM using decoder 55 |
| 665 | // 131: } |
| 666 | 1, 0, // 135: case 0x1: { |
| 667 | OPC_CheckPredicate, 4, // 137: check predicate 4 |
| 668 | OPC_CheckField, 8, 1, 0, // 139: check Inst[8] == 0x0 |
| 669 | OPC_Decode, 230, 18, 55, // 143: decode to MUL4x4_NM using decoder 55 |
| 670 | // 143: } |
| 671 | // 143: } // switch Inst[3] |
| 672 | // 143: } |
| 673 | 20, 48, // 147: case 0x14: { |
| 674 | OPC_SwitchField, 0, 1, // 149: switch Inst[0] { |
| 675 | 0, 35, // 152: case 0x0: { |
| 676 | OPC_SwitchField, 1, 3, // 154: switch Inst[3:1] { |
| 677 | 0, 6, // 157: case 0x0: { |
| 678 | OPC_CheckPredicate, 4, // 159: check predicate 4 |
| 679 | OPC_Decode, 185, 19, 56, // 161: decode to NOT16_NM using decoder 56 |
| 680 | // 161: } |
| 681 | 2, 6, // 165: case 0x2: { |
| 682 | OPC_CheckPredicate, 4, // 167: check predicate 4 |
| 683 | OPC_Decode, 194, 24, 57, // 169: decode to XOR16_NM using decoder 57 |
| 684 | // 169: } |
| 685 | 4, 6, // 173: case 0x4: { |
| 686 | OPC_CheckPredicate, 4, // 175: check predicate 4 |
| 687 | OPC_Decode, 255, 6, 57, // 177: decode to AND16_NM using decoder 57 |
| 688 | // 177: } |
| 689 | 6, 0, // 181: case 0x6: { |
| 690 | OPC_CheckPredicate, 4, // 183: check predicate 4 |
| 691 | OPC_Decode, 191, 19, 57, // 185: decode to OR16_NM using decoder 57 |
| 692 | // 185: } |
| 693 | // 185: } // switch Inst[3:1] |
| 694 | // 185: } |
| 695 | 1, 0, // 189: case 0x1: { |
| 696 | OPC_CheckPredicate, 4, // 191: check predicate 4 |
| 697 | OPC_Decode, 202, 16, 58, // 193: decode to LWXS16_NM using decoder 58 |
| 698 | // 193: } |
| 699 | // 193: } // switch Inst[0] |
| 700 | // 193: } |
| 701 | 21, 6, // 197: case 0x15: { |
| 702 | OPC_CheckPredicate, 4, // 199: check predicate 4 |
| 703 | OPC_Decode, 174, 16, 59, // 201: decode to LWGP16_NM using decoder 59 |
| 704 | // 201: } |
| 705 | 23, 27, // 205: case 0x17: { |
| 706 | OPC_SwitchField, 2, 2, // 207: switch Inst[3:2] { |
| 707 | 0, 6, // 210: case 0x0: { |
| 708 | OPC_CheckPredicate, 4, // 212: check predicate 4 |
| 709 | OPC_Decode, 184, 15, 60, // 214: decode to LB16_NM using decoder 60 |
| 710 | // 214: } |
| 711 | 1, 6, // 218: case 0x1: { |
| 712 | OPC_CheckPredicate, 4, // 220: check predicate 4 |
| 713 | OPC_Decode, 221, 20, 61, // 222: decode to SB16_NM using decoder 61 |
| 714 | // 222: } |
| 715 | 2, 0, // 226: case 0x2: { |
| 716 | OPC_CheckPredicate, 4, // 228: check predicate 4 |
| 717 | OPC_Decode, 190, 15, 60, // 230: decode to LBU16_NM using decoder 60 |
| 718 | // 230: } |
| 719 | // 230: } // switch Inst[3:2] |
| 720 | // 230: } |
| 721 | 28, 10, // 234: case 0x1c: { |
| 722 | OPC_CheckPredicate, 4, // 236: check predicate 4 |
| 723 | OPC_CheckField, 6, 1, 1, // 238: check Inst[6] == 0x1 |
| 724 | OPC_Decode, 169, 6, 62, // 242: decode to ADDIUR1SP_NM using decoder 62 |
| 725 | // 242: } |
| 726 | 29, 6, // 246: case 0x1d: { |
| 727 | OPC_CheckPredicate, 4, // 248: check predicate 4 |
| 728 | OPC_Decode, 162, 16, 63, // 250: decode to LW4x4_NM using decoder 63 |
| 729 | // 250: } |
| 730 | 31, 36, // 254: case 0x1f: { |
| 731 | OPC_SwitchField, 0, 1, // 256: switch Inst[0] { |
| 732 | 0, 19, // 259: case 0x0: { |
| 733 | OPC_SwitchField, 3, 1, // 261: switch Inst[3] { |
| 734 | 0, 6, // 264: case 0x0: { |
| 735 | OPC_CheckPredicate, 4, // 266: check predicate 4 |
| 736 | OPC_Decode, 235, 15, 64, // 268: decode to LH16_NM using decoder 64 |
| 737 | // 268: } |
| 738 | 1, 0, // 272: case 0x1: { |
| 739 | OPC_CheckPredicate, 4, // 274: check predicate 4 |
| 740 | OPC_Decode, 241, 15, 64, // 276: decode to LHU16_NM using decoder 64 |
| 741 | // 276: } |
| 742 | // 276: } // switch Inst[3] |
| 743 | // 276: } |
| 744 | 1, 0, // 280: case 0x1: { |
| 745 | OPC_CheckPredicate, 4, // 282: check predicate 4 |
| 746 | OPC_CheckField, 3, 1, 0, // 284: check Inst[3] == 0x0 |
| 747 | OPC_Decode, 171, 21, 65, // 288: decode to SH16_NM using decoder 65 |
| 748 | // 288: } |
| 749 | // 288: } // switch Inst[0] |
| 750 | // 288: } |
| 751 | 36, 35, // 292: case 0x24: { |
| 752 | OPC_SwitchField, 3, 1, // 294: switch Inst[3] { |
| 753 | 0, 6, // 297: case 0x0: { |
| 754 | OPC_CheckPredicate, 4, // 299: check predicate 4 |
| 755 | OPC_Decode, 171, 6, 66, // 301: decode to ADDIUR2_NM using decoder 66 |
| 756 | // 301: } |
| 757 | 1, 0, // 305: case 0x1: { |
| 758 | OPC_Scope, 14, // 307: try { |
| 759 | OPC_CheckField, 0, 3, 0, // 309: check Inst[2:0] == 0x0 |
| 760 | OPC_CheckPredicate, 4, // 313: check predicate 4 |
| 761 | OPC_CheckField, 4, 6, 0, // 315: check Inst[9:4] == 0x0 |
| 762 | OPC_Decode, 175, 19, 10, // 319: decode to NOP_NM using decoder 10 |
| 763 | // 319: } else try { |
| 764 | OPC_CheckPredicate, 4, // 323: check predicate 4 |
| 765 | OPC_Decode, 172, 6, 67, // 325: decode to ADDIURS5_NM using decoder 67 |
| 766 | // 325: } |
| 767 | // 325: } |
| 768 | // 325: } // switch Inst[3] |
| 769 | // 325: } |
| 770 | 37, 6, // 329: case 0x25: { |
| 771 | OPC_CheckPredicate, 4, // 331: check predicate 4 |
| 772 | OPC_Decode, 156, 23, 68, // 333: decode to SW16_NM using decoder 68 |
| 773 | // 333: } |
| 774 | 38, 6, // 337: case 0x26: { |
| 775 | OPC_CheckPredicate, 4, // 339: check predicate 4 |
| 776 | OPC_Decode, 237, 7, 69, // 341: decode to BEQZC16_NM using decoder 69 |
| 777 | // 341: } |
| 778 | 44, 19, // 345: case 0x2c: { |
| 779 | OPC_SwitchField, 0, 1, // 347: switch Inst[0] { |
| 780 | 0, 6, // 350: case 0x0: { |
| 781 | OPC_CheckPredicate, 4, // 352: check predicate 4 |
| 782 | OPC_Decode, 243, 6, 70, // 354: decode to ADDu16_NM using decoder 70 |
| 783 | // 354: } |
| 784 | 1, 0, // 358: case 0x1: { |
| 785 | OPC_CheckPredicate, 4, // 360: check predicate 4 |
| 786 | OPC_Decode, 147, 23, 70, // 362: decode to SUBu16_NM using decoder 70 |
| 787 | // 362: } |
| 788 | // 362: } // switch Inst[0] |
| 789 | // 362: } |
| 790 | 45, 6, // 366: case 0x2d: { |
| 791 | OPC_CheckPredicate, 4, // 368: check predicate 4 |
| 792 | OPC_Decode, 187, 23, 54, // 370: decode to SWSP16_NM using decoder 54 |
| 793 | // 370: } |
| 794 | 46, 6, // 374: case 0x2e: { |
| 795 | OPC_CheckPredicate, 4, // 376: check predicate 4 |
| 796 | OPC_Decode, 224, 8, 69, // 378: decode to BNEZC16_NM using decoder 69 |
| 797 | // 378: } |
| 798 | 47, 6, // 382: case 0x2f: { |
| 799 | OPC_CheckPredicate, 4, // 384: check predicate 4 |
| 800 | OPC_Decode, 240, 17, 71, // 386: decode to MOVEP_NM using decoder 71 |
| 801 | // 386: } |
| 802 | 52, 6, // 390: case 0x34: { |
| 803 | OPC_CheckPredicate, 4, // 392: check predicate 4 |
| 804 | OPC_Decode, 133, 16, 72, // 394: decode to LI16_NM using decoder 72 |
| 805 | // 394: } |
| 806 | 53, 6, // 398: case 0x35: { |
| 807 | OPC_CheckPredicate, 4, // 400: check predicate 4 |
| 808 | OPC_Decode, 169, 23, 73, // 402: decode to SWGP16_NM using decoder 73 |
| 809 | // 402: } |
| 810 | 54, 22, // 406: case 0x36: { |
| 811 | OPC_CheckField, 0, 4, 0, // 408: check Inst[3:0] == 0x0 |
| 812 | OPC_Scope, 10, // 412: try { |
| 813 | OPC_CheckField, 4, 1, 0, // 414: check Inst[4] == 0x0 |
| 814 | OPC_CheckPredicate, 4, // 418: check predicate 4 |
| 815 | OPC_Decode, 167, 15, 44, // 420: decode to JRC_NM using decoder 44 |
| 816 | // 420: } else try { |
| 817 | OPC_CheckPredicate, 4, // 424: check predicate 4 |
| 818 | OPC_Decode, 139, 15, 74, // 426: decode to JALRC16_NM using decoder 74 |
| 819 | // 426: } |
| 820 | // 426: } |
| 821 | 60, 6, // 430: case 0x3c: { |
| 822 | OPC_CheckPredicate, 4, // 432: check predicate 4 |
| 823 | OPC_Decode, 131, 7, 75, // 434: decode to ANDI16_NM using decoder 75 |
| 824 | // 434: } |
| 825 | 61, 6, // 438: case 0x3d: { |
| 826 | OPC_CheckPredicate, 4, // 440: check predicate 4 |
| 827 | OPC_Decode, 157, 23, 76, // 442: decode to SW4x4_NM using decoder 76 |
| 828 | // 442: } |
| 829 | 63, 0, // 446: case 0x3f: { |
| 830 | OPC_CheckPredicate, 4, // 448: check predicate 4 |
| 831 | OPC_Decode, 237, 17, 77, // 450: decode to MOVEPREV_NM using decoder 77 |
| 832 | // 450: } |
| 833 | // 450: } // switch Inst[15:10] |
| 834 | }; |
| 835 | static const uint8_t DecoderTable32[305] = { |
| 836 | OPC_SwitchField, 11, 5, // 0: switch Inst[15:11] { |
| 837 | 1, 14, // 3: case 0x1: { |
| 838 | OPC_CheckPredicate, 0, // 5: check predicate 0 |
| 839 | OPC_CheckField, 27, 5, 30, // 7: check Inst[31:27] == 0x1e |
| 840 | OPC_CheckField, 5, 3, 0, // 11: check Inst[7:5] == 0x0 |
| 841 | OPC_Decode, 173, 7, 78, // 15: decode to AddiuRxPcImmX16 using decoder 78 |
| 842 | // 15: } |
| 843 | 2, 14, // 19: case 0x2: { |
| 844 | OPC_CheckPredicate, 0, // 21: check predicate 0 |
| 845 | OPC_CheckField, 27, 5, 30, // 23: check Inst[31:27] == 0x1e |
| 846 | OPC_CheckField, 5, 6, 0, // 27: check Inst[10:5] == 0x0 |
| 847 | OPC_Decode, 140, 9, 79, // 31: decode to BimmX16 using decoder 79 |
| 848 | // 31: } |
| 849 | 4, 14, // 35: case 0x4: { |
| 850 | OPC_CheckPredicate, 0, // 37: check predicate 0 |
| 851 | OPC_CheckField, 27, 5, 30, // 39: check Inst[31:27] == 0x1e |
| 852 | OPC_CheckField, 5, 3, 0, // 43: check Inst[7:5] == 0x0 |
| 853 | OPC_Decode, 138, 9, 80, // 47: decode to BeqzRxImmX16 using decoder 80 |
| 854 | // 47: } |
| 855 | 5, 14, // 51: case 0x5: { |
| 856 | OPC_CheckPredicate, 0, // 53: check predicate 0 |
| 857 | OPC_CheckField, 27, 5, 30, // 55: check Inst[31:27] == 0x1e |
| 858 | OPC_CheckField, 5, 3, 0, // 59: check Inst[7:5] == 0x0 |
| 859 | OPC_Decode, 142, 9, 80, // 63: decode to BnezRxImmX16 using decoder 80 |
| 860 | // 63: } |
| 861 | 6, 64, // 67: case 0x6: { |
| 862 | OPC_CheckField, 27, 5, 30, // 69: check Inst[31:27] == 0x1e |
| 863 | OPC_Scope, 31, // 73: try { |
| 864 | OPC_CheckField, 16, 5, 0, // 75: check Inst[20:16] == 0x0 |
| 865 | OPC_SwitchField, 0, 5, // 79: switch Inst[4:0] { |
| 866 | 0, 6, // 82: case 0x0: { |
| 867 | OPC_CheckPredicate, 0, // 84: check predicate 0 |
| 868 | OPC_Decode, 217, 23, 81, // 86: decode to SllX16 using decoder 81 |
| 869 | // 86: } |
| 870 | 2, 6, // 90: case 0x2: { |
| 871 | OPC_CheckPredicate, 0, // 92: check predicate 0 |
| 872 | OPC_Decode, 227, 23, 81, // 94: decode to SrlX16 using decoder 81 |
| 873 | // 94: } |
| 874 | 3, 0, // 98: case 0x3: { |
| 875 | OPC_CheckPredicate, 0, // 100: check predicate 0 |
| 876 | OPC_Decode, 225, 23, 81, // 102: decode to SraX16 using decoder 81 |
| 877 | // 102: } |
| 878 | // 102: } // switch Inst[4:0] |
| 879 | // 102: } else try { |
| 880 | OPC_SwitchField, 5, 6, // 106: switch Inst[10:5] { |
| 881 | 0, 6, // 109: case 0x0: { |
| 882 | OPC_CheckPredicate, 0, // 111: check predicate 0 |
| 883 | OPC_Decode, 145, 9, 82, // 113: decode to BteqzX16 using decoder 82 |
| 884 | // 113: } |
| 885 | 8, 6, // 117: case 0x8: { |
| 886 | OPC_CheckPredicate, 0, // 119: check predicate 0 |
| 887 | OPC_Decode, 147, 9, 82, // 121: decode to BtnezX16 using decoder 82 |
| 888 | // 121: } |
| 889 | 24, 0, // 125: case 0x18: { |
| 890 | OPC_CheckPredicate, 0, // 127: check predicate 0 |
| 891 | OPC_Decode, 178, 7, 82, // 129: decode to AddiuSpImmX16 using decoder 82 |
| 892 | // 129: } |
| 893 | // 129: } // switch Inst[10:5] |
| 894 | // 129: } |
| 895 | // 129: } |
| 896 | 8, 14, // 133: case 0x8: { |
| 897 | OPC_CheckPredicate, 0, // 135: check predicate 0 |
| 898 | OPC_CheckField, 27, 5, 30, // 137: check Inst[31:27] == 0x1e |
| 899 | OPC_CheckField, 4, 1, 0, // 141: check Inst[4] == 0x0 |
| 900 | OPC_Decode, 176, 7, 83, // 145: decode to AddiuRxRyOffMemX16 using decoder 83 |
| 901 | // 145: } |
| 902 | 9, 14, // 149: case 0x9: { |
| 903 | OPC_CheckPredicate, 0, // 151: check predicate 0 |
| 904 | OPC_CheckField, 27, 5, 30, // 153: check Inst[31:27] == 0x1e |
| 905 | OPC_CheckField, 5, 3, 0, // 157: check Inst[7:5] == 0x0 |
| 906 | OPC_Decode, 172, 7, 78, // 161: decode to AddiuRxImmX16 using decoder 78 |
| 907 | // 161: } |
| 908 | 10, 14, // 165: case 0xa: { |
| 909 | OPC_CheckPredicate, 0, // 167: check predicate 0 |
| 910 | OPC_CheckField, 27, 5, 30, // 169: check Inst[31:27] == 0x1e |
| 911 | OPC_CheckField, 5, 3, 0, // 173: check Inst[7:5] == 0x0 |
| 912 | OPC_Decode, 221, 23, 78, // 177: decode to SltiRxImmX16 using decoder 78 |
| 913 | // 177: } |
| 914 | 11, 14, // 181: case 0xb: { |
| 915 | OPC_CheckPredicate, 0, // 183: check predicate 0 |
| 916 | OPC_CheckField, 27, 5, 30, // 185: check Inst[31:27] == 0x1e |
| 917 | OPC_CheckField, 5, 3, 0, // 189: check Inst[7:5] == 0x0 |
| 918 | OPC_Decode, 223, 23, 78, // 193: decode to SltiuRxImmX16 using decoder 78 |
| 919 | // 193: } |
| 920 | 13, 14, // 197: case 0xd: { |
| 921 | OPC_CheckPredicate, 0, // 199: check predicate 0 |
| 922 | OPC_CheckField, 27, 5, 30, // 201: check Inst[31:27] == 0x1e |
| 923 | OPC_CheckField, 5, 3, 0, // 205: check Inst[7:5] == 0x0 |
| 924 | OPC_Decode, 218, 16, 78, // 209: decode to LiRxImmX16 using decoder 78 |
| 925 | // 209: } |
| 926 | 14, 14, // 213: case 0xe: { |
| 927 | OPC_CheckPredicate, 0, // 215: check predicate 0 |
| 928 | OPC_CheckField, 27, 5, 30, // 217: check Inst[31:27] == 0x1e |
| 929 | OPC_CheckField, 5, 3, 0, // 221: check Inst[7:5] == 0x0 |
| 930 | OPC_Decode, 220, 11, 78, // 225: decode to CmpiRxImmX16 using decoder 78 |
| 931 | // 225: } |
| 932 | 18, 10, // 229: case 0x12: { |
| 933 | OPC_CheckPredicate, 0, // 231: check predicate 0 |
| 934 | OPC_CheckField, 27, 5, 30, // 233: check Inst[31:27] == 0x1e |
| 935 | OPC_Decode, 222, 16, 83, // 237: decode to LwRxSpImmX16 using decoder 83 |
| 936 | // 237: } |
| 937 | 22, 14, // 241: case 0x16: { |
| 938 | OPC_CheckPredicate, 0, // 243: check predicate 0 |
| 939 | OPC_CheckField, 27, 5, 30, // 245: check Inst[31:27] == 0x1e |
| 940 | OPC_CheckField, 5, 3, 0, // 249: check Inst[7:5] == 0x0 |
| 941 | OPC_Decode, 220, 16, 84, // 253: decode to LwRxPcTcpX16 using decoder 84 |
| 942 | // 253: } |
| 943 | 24, 10, // 257: case 0x18: { |
| 944 | OPC_CheckPredicate, 0, // 259: check predicate 0 |
| 945 | OPC_CheckField, 27, 5, 30, // 261: check Inst[31:27] == 0x1e |
| 946 | OPC_Decode, 213, 23, 83, // 265: decode to SbRxRyOffMemX16 using decoder 83 |
| 947 | // 265: } |
| 948 | 25, 10, // 269: case 0x19: { |
| 949 | OPC_CheckPredicate, 0, // 271: check predicate 0 |
| 950 | OPC_CheckField, 27, 5, 30, // 273: check Inst[31:27] == 0x1e |
| 951 | OPC_Decode, 216, 23, 83, // 277: decode to ShRxRyOffMemX16 using decoder 83 |
| 952 | // 277: } |
| 953 | 26, 10, // 281: case 0x1a: { |
| 954 | OPC_CheckPredicate, 0, // 283: check predicate 0 |
| 955 | OPC_CheckField, 27, 5, 30, // 285: check Inst[31:27] == 0x1e |
| 956 | OPC_Decode, 231, 23, 83, // 289: decode to SwRxSpImmX16 using decoder 83 |
| 957 | // 289: } |
| 958 | 27, 0, // 293: case 0x1b: { |
| 959 | OPC_CheckPredicate, 0, // 295: check predicate 0 |
| 960 | OPC_CheckField, 27, 5, 30, // 297: check Inst[31:27] == 0x1e |
| 961 | OPC_Decode, 230, 23, 83, // 301: decode to SwRxRyOffMemX16 using decoder 83 |
| 962 | // 301: } |
| 963 | // 301: } // switch Inst[15:11] |
| 964 | }; |
| 965 | static const uint8_t DecoderTableCOP3_32[35] = { |
| 966 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 967 | 51, 6, // 3: case 0x33: { |
| 968 | OPC_CheckPredicate, 5, // 5: check predicate 5 |
| 969 | OPC_Decode, 169, 16, 85, // 7: decode to LWC3 using decoder 85 |
| 970 | // 7: } |
| 971 | 55, 6, // 11: case 0x37: { |
| 972 | OPC_CheckPredicate, 6, // 13: check predicate 6 |
| 973 | OPC_Decode, 217, 15, 85, // 15: decode to LDC3 using decoder 85 |
| 974 | // 15: } |
| 975 | 59, 6, // 19: case 0x3b: { |
| 976 | OPC_CheckPredicate, 5, // 21: check predicate 5 |
| 977 | OPC_Decode, 164, 23, 85, // 23: decode to SWC3 using decoder 85 |
| 978 | // 23: } |
| 979 | 63, 0, // 27: case 0x3f: { |
| 980 | OPC_CheckPredicate, 6, // 29: check predicate 6 |
| 981 | OPC_Decode, 132, 21, 85, // 31: decode to SDC3 using decoder 85 |
| 982 | // 31: } |
| 983 | // 31: } // switch Inst[31:26] |
| 984 | }; |
| 985 | static const uint8_t DecoderTableCnMips32[298] = { |
| 986 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 987 | 18, 19, // 3: case 0x12: { |
| 988 | OPC_SwitchField, 21, 5, // 5: switch Inst[25:21] { |
| 989 | 1, 6, // 8: case 0x1: { |
| 990 | OPC_CheckPredicate, 7, // 10: check predicate 7 |
| 991 | OPC_Decode, 142, 12, 86, // 12: decode to DMFC2_OCTEON using decoder 86 |
| 992 | // 12: } |
| 993 | 5, 0, // 16: case 0x5: { |
| 994 | OPC_CheckPredicate, 7, // 18: check predicate 7 |
| 995 | OPC_Decode, 150, 12, 86, // 20: decode to DMTC2_OCTEON using decoder 86 |
| 996 | // 20: } |
| 997 | // 20: } // switch Inst[25:21] |
| 998 | // 20: } |
| 999 | 28, 239, 1, // 24: case 0x1c: { |
| 1000 | OPC_SwitchField, 0, 6, // 27: switch Inst[5:0] { |
| 1001 | 3, 10, // 30: case 0x3: { |
| 1002 | OPC_CheckPredicate, 7, // 32: check predicate 7 |
| 1003 | OPC_CheckField, 6, 5, 0, // 34: check Inst[10:6] == 0x0 |
| 1004 | OPC_Decode, 154, 12, 87, // 38: decode to DMUL using decoder 87 |
| 1005 | // 38: } |
| 1006 | 8, 10, // 42: case 0x8: { |
| 1007 | OPC_CheckPredicate, 7, // 44: check predicate 7 |
| 1008 | OPC_CheckField, 6, 15, 0, // 46: check Inst[20:6] == 0x0 |
| 1009 | OPC_Decode, 216, 18, 88, // 50: decode to MTM0 using decoder 88 |
| 1010 | // 50: } |
| 1011 | 9, 10, // 54: case 0x9: { |
| 1012 | OPC_CheckPredicate, 7, // 56: check predicate 7 |
| 1013 | OPC_CheckField, 6, 15, 0, // 58: check Inst[20:6] == 0x0 |
| 1014 | OPC_Decode, 219, 18, 88, // 62: decode to MTP0 using decoder 88 |
| 1015 | // 62: } |
| 1016 | 10, 10, // 66: case 0xa: { |
| 1017 | OPC_CheckPredicate, 7, // 68: check predicate 7 |
| 1018 | OPC_CheckField, 6, 15, 0, // 70: check Inst[20:6] == 0x0 |
| 1019 | OPC_Decode, 220, 18, 88, // 74: decode to MTP1 using decoder 88 |
| 1020 | // 74: } |
| 1021 | 11, 10, // 78: case 0xb: { |
| 1022 | OPC_CheckPredicate, 7, // 80: check predicate 7 |
| 1023 | OPC_CheckField, 6, 15, 0, // 82: check Inst[20:6] == 0x0 |
| 1024 | OPC_Decode, 221, 18, 88, // 86: decode to MTP2 using decoder 88 |
| 1025 | // 86: } |
| 1026 | 12, 10, // 90: case 0xc: { |
| 1027 | OPC_CheckPredicate, 7, // 92: check predicate 7 |
| 1028 | OPC_CheckField, 6, 15, 0, // 94: check Inst[20:6] == 0x0 |
| 1029 | OPC_Decode, 217, 18, 88, // 98: decode to MTM1 using decoder 88 |
| 1030 | // 98: } |
| 1031 | 13, 10, // 102: case 0xd: { |
| 1032 | OPC_CheckPredicate, 7, // 104: check predicate 7 |
| 1033 | OPC_CheckField, 6, 15, 0, // 106: check Inst[20:6] == 0x0 |
| 1034 | OPC_Decode, 218, 18, 88, // 110: decode to MTM2 using decoder 88 |
| 1035 | // 110: } |
| 1036 | 15, 10, // 114: case 0xf: { |
| 1037 | OPC_CheckPredicate, 7, // 116: check predicate 7 |
| 1038 | OPC_CheckField, 6, 5, 0, // 118: check Inst[10:6] == 0x0 |
| 1039 | OPC_Decode, 175, 24, 87, // 122: decode to VMULU using decoder 87 |
| 1040 | // 122: } |
| 1041 | 16, 10, // 126: case 0x10: { |
| 1042 | OPC_CheckPredicate, 7, // 128: check predicate 7 |
| 1043 | OPC_CheckField, 6, 5, 0, // 130: check Inst[10:6] == 0x0 |
| 1044 | OPC_Decode, 174, 24, 87, // 134: decode to VMM0 using decoder 87 |
| 1045 | // 134: } |
| 1046 | 17, 10, // 138: case 0x11: { |
| 1047 | OPC_CheckPredicate, 7, // 140: check predicate 7 |
| 1048 | OPC_CheckField, 6, 5, 0, // 142: check Inst[10:6] == 0x0 |
| 1049 | OPC_Decode, 173, 24, 87, // 146: decode to V3MULU using decoder 87 |
| 1050 | // 146: } |
| 1051 | 40, 10, // 150: case 0x28: { |
| 1052 | OPC_CheckPredicate, 7, // 152: check predicate 7 |
| 1053 | OPC_CheckField, 6, 5, 0, // 154: check Inst[10:6] == 0x0 |
| 1054 | OPC_Decode, 182, 7, 87, // 158: decode to BADDu using decoder 87 |
| 1055 | // 158: } |
| 1056 | 42, 10, // 162: case 0x2a: { |
| 1057 | OPC_CheckPredicate, 7, // 164: check predicate 7 |
| 1058 | OPC_CheckField, 6, 5, 0, // 166: check Inst[10:6] == 0x0 |
| 1059 | OPC_Decode, 165, 21, 87, // 170: decode to SEQ using decoder 87 |
| 1060 | // 170: } |
| 1061 | 43, 10, // 174: case 0x2b: { |
| 1062 | OPC_CheckPredicate, 7, // 176: check predicate 7 |
| 1063 | OPC_CheckField, 6, 5, 0, // 178: check Inst[10:6] == 0x0 |
| 1064 | OPC_Decode, 152, 22, 87, // 182: decode to SNE using decoder 87 |
| 1065 | // 182: } |
| 1066 | 44, 14, // 186: case 0x2c: { |
| 1067 | OPC_CheckPredicate, 7, // 188: check predicate 7 |
| 1068 | OPC_CheckField, 16, 5, 0, // 190: check Inst[20:16] == 0x0 |
| 1069 | OPC_CheckField, 6, 5, 0, // 194: check Inst[10:6] == 0x0 |
| 1070 | OPC_Decode, 228, 19, 89, // 198: decode to POP using decoder 89 |
| 1071 | // 198: } |
| 1072 | 45, 14, // 202: case 0x2d: { |
| 1073 | OPC_CheckPredicate, 7, // 204: check predicate 7 |
| 1074 | OPC_CheckField, 16, 5, 0, // 206: check Inst[20:16] == 0x0 |
| 1075 | OPC_CheckField, 6, 5, 0, // 210: check Inst[10:6] == 0x0 |
| 1076 | OPC_Decode, 187, 12, 90, // 214: decode to DPOP using decoder 90 |
| 1077 | // 214: } |
| 1078 | 46, 6, // 218: case 0x2e: { |
| 1079 | OPC_CheckPredicate, 7, // 220: check predicate 7 |
| 1080 | OPC_Decode, 167, 21, 91, // 222: decode to SEQi using decoder 91 |
| 1081 | // 222: } |
| 1082 | 47, 6, // 226: case 0x2f: { |
| 1083 | OPC_CheckPredicate, 7, // 228: check predicate 7 |
| 1084 | OPC_Decode, 153, 22, 91, // 230: decode to SNEi using decoder 91 |
| 1085 | // 230: } |
| 1086 | 50, 6, // 234: case 0x32: { |
| 1087 | OPC_CheckPredicate, 8, // 236: check predicate 8 |
| 1088 | OPC_Decode, 178, 9, 92, // 238: decode to CINS using decoder 92 |
| 1089 | // 238: } |
| 1090 | 51, 6, // 242: case 0x33: { |
| 1091 | OPC_CheckPredicate, 8, // 244: check predicate 8 |
| 1092 | OPC_Decode, 179, 9, 92, // 246: decode to CINS32 using decoder 92 |
| 1093 | // 246: } |
| 1094 | 58, 6, // 250: case 0x3a: { |
| 1095 | OPC_CheckPredicate, 8, // 252: check predicate 8 |
| 1096 | OPC_Decode, 152, 13, 92, // 254: decode to EXTS using decoder 92 |
| 1097 | // 254: } |
| 1098 | 59, 0, // 258: case 0x3b: { |
| 1099 | OPC_CheckPredicate, 8, // 260: check predicate 8 |
| 1100 | OPC_Decode, 153, 13, 92, // 262: decode to EXTS32 using decoder 92 |
| 1101 | // 262: } |
| 1102 | // 262: } // switch Inst[5:0] |
| 1103 | // 262: } |
| 1104 | 50, 6, // 266: case 0x32: { |
| 1105 | OPC_CheckPredicate, 7, // 268: check predicate 7 |
| 1106 | OPC_Decode, 192, 7, 93, // 270: decode to BBIT0 using decoder 93 |
| 1107 | // 270: } |
| 1108 | 54, 6, // 274: case 0x36: { |
| 1109 | OPC_CheckPredicate, 7, // 276: check predicate 7 |
| 1110 | OPC_Decode, 193, 7, 93, // 278: decode to BBIT032 using decoder 93 |
| 1111 | // 278: } |
| 1112 | 58, 6, // 282: case 0x3a: { |
| 1113 | OPC_CheckPredicate, 7, // 284: check predicate 7 |
| 1114 | OPC_Decode, 194, 7, 93, // 286: decode to BBIT1 using decoder 93 |
| 1115 | // 286: } |
| 1116 | 62, 0, // 290: case 0x3e: { |
| 1117 | OPC_CheckPredicate, 7, // 292: check predicate 7 |
| 1118 | OPC_Decode, 195, 7, 93, // 294: decode to BBIT132 using decoder 93 |
| 1119 | // 294: } |
| 1120 | // 294: } // switch Inst[31:26] |
| 1121 | }; |
| 1122 | static const uint8_t DecoderTableCnMipsP32[27] = { |
| 1123 | OPC_SwitchField, 0, 16, // 0: switch Inst[15:0] { |
| 1124 | 24, 10, // 3: case 0x18: { |
| 1125 | OPC_CheckPredicate, 9, // 5: check predicate 9 |
| 1126 | OPC_CheckField, 26, 6, 28, // 7: check Inst[31:26] == 0x1c |
| 1127 | OPC_Decode, 206, 20, 94, // 11: decode to SAA using decoder 94 |
| 1128 | // 11: } |
| 1129 | 25, 0, // 15: case 0x19: { |
| 1130 | OPC_CheckPredicate, 9, // 17: check predicate 9 |
| 1131 | OPC_CheckField, 26, 6, 28, // 19: check Inst[31:26] == 0x1c |
| 1132 | OPC_Decode, 207, 20, 94, // 23: decode to SAAD using decoder 94 |
| 1133 | // 23: } |
| 1134 | // 23: } // switch Inst[15:0] |
| 1135 | }; |
| 1136 | static const uint8_t DecoderTableMicroMips32[4014] = { |
| 1137 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 1138 | 0, 244, 17, // 3: case 0x0: { |
| 1139 | OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] { |
| 1140 | 0, 64, // 9: case 0x0: { |
| 1141 | OPC_SwitchField, 6, 5, // 11: switch Inst[10:6] { |
| 1142 | 0, 35, // 14: case 0x0: { |
| 1143 | OPC_Scope, 27, // 16: try { |
| 1144 | OPC_SwitchField, 11, 15, // 18: switch Inst[25:11] { |
| 1145 | 1, 6, // 21: case 0x1: { |
| 1146 | OPC_CheckPredicate, 2, // 23: check predicate 2 |
| 1147 | OPC_Decode, 211, 22, 10, // 25: decode to SSNOP_MM using decoder 10 |
| 1148 | // 25: } |
| 1149 | 3, 6, // 29: case 0x3: { |
| 1150 | OPC_CheckPredicate, 2, // 31: check predicate 2 |
| 1151 | OPC_Decode, 236, 12, 10, // 33: decode to EHB_MM using decoder 10 |
| 1152 | // 33: } |
| 1153 | 5, 0, // 37: case 0x5: { |
| 1154 | OPC_CheckPredicate, 2, // 39: check predicate 2 |
| 1155 | OPC_Decode, 207, 19, 10, // 41: decode to PAUSE_MM using decoder 10 |
| 1156 | // 41: } |
| 1157 | // 41: } // switch Inst[25:11] |
| 1158 | // 41: } else try { |
| 1159 | OPC_CheckPredicate, 2, // 45: check predicate 2 |
| 1160 | OPC_Decode, 132, 22, 95, // 47: decode to SLL_MM using decoder 95 |
| 1161 | // 47: } |
| 1162 | // 47: } |
| 1163 | 1, 6, // 51: case 0x1: { |
| 1164 | OPC_CheckPredicate, 2, // 53: check predicate 2 |
| 1165 | OPC_Decode, 207, 22, 95, // 55: decode to SRL_MM using decoder 95 |
| 1166 | // 55: } |
| 1167 | 2, 6, // 59: case 0x2: { |
| 1168 | OPC_CheckPredicate, 2, // 61: check predicate 2 |
| 1169 | OPC_Decode, 182, 22, 95, // 63: decode to SRA_MM using decoder 95 |
| 1170 | // 63: } |
| 1171 | 3, 0, // 67: case 0x3: { |
| 1172 | OPC_CheckPredicate, 2, // 69: check predicate 2 |
| 1173 | OPC_Decode, 184, 20, 95, // 71: decode to ROTR_MM using decoder 95 |
| 1174 | // 71: } |
| 1175 | // 71: } // switch Inst[10:6] |
| 1176 | // 71: } |
| 1177 | 5, 131, 1, // 75: case 0x5: { |
| 1178 | OPC_SwitchField, 6, 5, // 78: switch Inst[10:6] { |
| 1179 | 0, 10, // 81: case 0x0: { |
| 1180 | OPC_CheckPredicate, 10, // 83: check predicate 10 |
| 1181 | OPC_CheckField, 11, 5, 0, // 85: check Inst[15:11] == 0x0 |
| 1182 | OPC_Decode, 251, 9, 96, // 89: decode to CMP_EQ_PH_MM using decoder 96 |
| 1183 | // 89: } |
| 1184 | 1, 10, // 93: case 0x1: { |
| 1185 | OPC_CheckPredicate, 10, // 95: check predicate 10 |
| 1186 | OPC_CheckField, 11, 5, 0, // 97: check Inst[15:11] == 0x0 |
| 1187 | OPC_Decode, 137, 10, 96, // 101: decode to CMP_LT_PH_MM using decoder 96 |
| 1188 | // 101: } |
| 1189 | 2, 10, // 105: case 0x2: { |
| 1190 | OPC_CheckPredicate, 10, // 107: check predicate 10 |
| 1191 | OPC_CheckField, 11, 5, 0, // 109: check Inst[15:11] == 0x0 |
| 1192 | OPC_Decode, 131, 10, 96, // 113: decode to CMP_LE_PH_MM using decoder 96 |
| 1193 | // 113: } |
| 1194 | 6, 6, // 117: case 0x6: { |
| 1195 | OPC_CheckPredicate, 11, // 119: check predicate 11 |
| 1196 | OPC_Decode, 229, 9, 97, // 121: decode to CMPGDU_EQ_QB_MMR2 using decoder 97 |
| 1197 | // 121: } |
| 1198 | 7, 6, // 125: case 0x7: { |
| 1199 | OPC_CheckPredicate, 11, // 127: check predicate 11 |
| 1200 | OPC_Decode, 233, 9, 97, // 129: decode to CMPGDU_LT_QB_MMR2 using decoder 97 |
| 1201 | // 129: } |
| 1202 | 8, 6, // 133: case 0x8: { |
| 1203 | OPC_CheckPredicate, 11, // 135: check predicate 11 |
| 1204 | OPC_Decode, 231, 9, 97, // 137: decode to CMPGDU_LE_QB_MMR2 using decoder 97 |
| 1205 | // 137: } |
| 1206 | 9, 10, // 141: case 0x9: { |
| 1207 | OPC_CheckPredicate, 10, // 143: check predicate 10 |
| 1208 | OPC_CheckField, 11, 5, 0, // 145: check Inst[15:11] == 0x0 |
| 1209 | OPC_Decode, 241, 9, 96, // 149: decode to CMPU_EQ_QB_MM using decoder 96 |
| 1210 | // 149: } |
| 1211 | 10, 10, // 153: case 0xa: { |
| 1212 | OPC_CheckPredicate, 10, // 155: check predicate 10 |
| 1213 | OPC_CheckField, 11, 5, 0, // 157: check Inst[15:11] == 0x0 |
| 1214 | OPC_Decode, 245, 9, 96, // 161: decode to CMPU_LT_QB_MM using decoder 96 |
| 1215 | // 161: } |
| 1216 | 11, 10, // 165: case 0xb: { |
| 1217 | OPC_CheckPredicate, 10, // 167: check predicate 10 |
| 1218 | OPC_CheckField, 11, 5, 0, // 169: check Inst[15:11] == 0x0 |
| 1219 | OPC_Decode, 243, 9, 96, // 173: decode to CMPU_LE_QB_MM using decoder 96 |
| 1220 | // 173: } |
| 1221 | 12, 6, // 177: case 0xc: { |
| 1222 | OPC_CheckPredicate, 10, // 179: check predicate 10 |
| 1223 | OPC_Decode, 190, 6, 98, // 181: decode to ADDQ_S_W_MM using decoder 98 |
| 1224 | // 181: } |
| 1225 | 13, 6, // 185: case 0xd: { |
| 1226 | OPC_CheckPredicate, 10, // 187: check predicate 10 |
| 1227 | OPC_Decode, 231, 22, 98, // 189: decode to SUBQ_S_W_MM using decoder 98 |
| 1228 | // 189: } |
| 1229 | 14, 6, // 193: case 0xe: { |
| 1230 | OPC_CheckPredicate, 10, // 195: check predicate 10 |
| 1231 | OPC_Decode, 193, 6, 98, // 197: decode to ADDSC_MM using decoder 98 |
| 1232 | // 197: } |
| 1233 | 15, 0, // 201: case 0xf: { |
| 1234 | OPC_CheckPredicate, 10, // 203: check predicate 10 |
| 1235 | OPC_Decode, 230, 6, 98, // 205: decode to ADDWC_MM using decoder 98 |
| 1236 | // 205: } |
| 1237 | // 205: } // switch Inst[10:6] |
| 1238 | // 205: } |
| 1239 | 7, 6, // 209: case 0x7: { |
| 1240 | OPC_CheckPredicate, 2, // 211: check predicate 2 |
| 1241 | OPC_Decode, 245, 8, 99, // 213: decode to BREAK_MM using decoder 99 |
| 1242 | // 213: } |
| 1243 | 12, 6, // 217: case 0xc: { |
| 1244 | OPC_CheckPredicate, 1, // 219: check predicate 1 |
| 1245 | OPC_Decode, 130, 15, 100, // 221: decode to INS_MM using decoder 100 |
| 1246 | // 221: } |
| 1247 | 13, 243, 1, // 225: case 0xd: { |
| 1248 | OPC_SwitchField, 6, 5, // 228: switch Inst[10:6] { |
| 1249 | 0, 6, // 231: case 0x0: { |
| 1250 | OPC_CheckPredicate, 10, // 233: check predicate 10 |
| 1251 | OPC_Decode, 186, 6, 101, // 235: decode to ADDQ_PH_MM using decoder 101 |
| 1252 | // 235: } |
| 1253 | 1, 6, // 239: case 0x1: { |
| 1254 | OPC_CheckPredicate, 11, // 241: check predicate 11 |
| 1255 | OPC_Decode, 178, 6, 101, // 243: decode to ADDQH_PH_MMR2 using decoder 101 |
| 1256 | // 243: } |
| 1257 | 2, 6, // 247: case 0x2: { |
| 1258 | OPC_CheckPredicate, 11, // 249: check predicate 11 |
| 1259 | OPC_Decode, 184, 6, 98, // 251: decode to ADDQH_W_MMR2 using decoder 98 |
| 1260 | // 251: } |
| 1261 | 3, 6, // 255: case 0x3: { |
| 1262 | OPC_CheckPredicate, 10, // 257: check predicate 10 |
| 1263 | OPC_Decode, 216, 6, 101, // 259: decode to ADDU_QB_MM using decoder 101 |
| 1264 | // 259: } |
| 1265 | 4, 6, // 263: case 0x4: { |
| 1266 | OPC_CheckPredicate, 11, // 265: check predicate 11 |
| 1267 | OPC_Decode, 214, 6, 101, // 267: decode to ADDU_PH_MMR2 using decoder 101 |
| 1268 | // 267: } |
| 1269 | 5, 6, // 271: case 0x5: { |
| 1270 | OPC_CheckPredicate, 11, // 273: check predicate 11 |
| 1271 | OPC_Decode, 209, 6, 101, // 275: decode to ADDUH_QB_MMR2 using decoder 101 |
| 1272 | // 275: } |
| 1273 | 6, 6, // 279: case 0x6: { |
| 1274 | OPC_CheckPredicate, 10, // 281: check predicate 10 |
| 1275 | OPC_Decode, 200, 21, 102, // 283: decode to SHRAV_PH_MM using decoder 102 |
| 1276 | // 283: } |
| 1277 | 7, 6, // 287: case 0x7: { |
| 1278 | OPC_CheckPredicate, 11, // 289: check predicate 11 |
| 1279 | OPC_Decode, 202, 21, 102, // 291: decode to SHRAV_QB_MMR2 using decoder 102 |
| 1280 | // 291: } |
| 1281 | 8, 6, // 295: case 0x8: { |
| 1282 | OPC_CheckPredicate, 10, // 297: check predicate 10 |
| 1283 | OPC_Decode, 227, 22, 101, // 299: decode to SUBQ_PH_MM using decoder 101 |
| 1284 | // 299: } |
| 1285 | 9, 6, // 303: case 0x9: { |
| 1286 | OPC_CheckPredicate, 11, // 305: check predicate 11 |
| 1287 | OPC_Decode, 219, 22, 101, // 307: decode to SUBQH_PH_MMR2 using decoder 101 |
| 1288 | // 307: } |
| 1289 | 10, 6, // 311: case 0xa: { |
| 1290 | OPC_CheckPredicate, 11, // 313: check predicate 11 |
| 1291 | OPC_Decode, 225, 22, 98, // 315: decode to SUBQH_W_MMR2 using decoder 98 |
| 1292 | // 315: } |
| 1293 | 11, 6, // 319: case 0xb: { |
| 1294 | OPC_CheckPredicate, 10, // 321: check predicate 10 |
| 1295 | OPC_Decode, 130, 23, 101, // 323: decode to SUBU_QB_MM using decoder 101 |
| 1296 | // 323: } |
| 1297 | 12, 6, // 327: case 0xc: { |
| 1298 | OPC_CheckPredicate, 11, // 329: check predicate 11 |
| 1299 | OPC_Decode, 128, 23, 101, // 331: decode to SUBU_PH_MMR2 using decoder 101 |
| 1300 | // 331: } |
| 1301 | 13, 6, // 335: case 0xd: { |
| 1302 | OPC_CheckPredicate, 11, // 337: check predicate 11 |
| 1303 | OPC_Decode, 251, 22, 101, // 339: decode to SUBUH_QB_MMR2 using decoder 101 |
| 1304 | // 339: } |
| 1305 | 15, 6, // 343: case 0xf: { |
| 1306 | OPC_CheckPredicate, 11, // 345: check predicate 11 |
| 1307 | OPC_Decode, 132, 20, 103, // 347: decode to PRECR_SRA_PH_W_MMR2 using decoder 103 |
| 1308 | // 347: } |
| 1309 | 16, 6, // 351: case 0x10: { |
| 1310 | OPC_CheckPredicate, 10, // 353: check predicate 10 |
| 1311 | OPC_Decode, 188, 6, 101, // 355: decode to ADDQ_S_PH_MM using decoder 101 |
| 1312 | // 355: } |
| 1313 | 17, 6, // 359: case 0x11: { |
| 1314 | OPC_CheckPredicate, 11, // 361: check predicate 11 |
| 1315 | OPC_Decode, 180, 6, 101, // 363: decode to ADDQH_R_PH_MMR2 using decoder 101 |
| 1316 | // 363: } |
| 1317 | 18, 6, // 367: case 0x12: { |
| 1318 | OPC_CheckPredicate, 11, // 369: check predicate 11 |
| 1319 | OPC_Decode, 182, 6, 98, // 371: decode to ADDQH_R_W_MMR2 using decoder 98 |
| 1320 | // 371: } |
| 1321 | 19, 6, // 375: case 0x13: { |
| 1322 | OPC_CheckPredicate, 10, // 377: check predicate 10 |
| 1323 | OPC_Decode, 220, 6, 101, // 379: decode to ADDU_S_QB_MM using decoder 101 |
| 1324 | // 379: } |
| 1325 | 20, 6, // 383: case 0x14: { |
| 1326 | OPC_CheckPredicate, 11, // 385: check predicate 11 |
| 1327 | OPC_Decode, 218, 6, 101, // 387: decode to ADDU_S_PH_MMR2 using decoder 101 |
| 1328 | // 387: } |
| 1329 | 21, 6, // 391: case 0x15: { |
| 1330 | OPC_CheckPredicate, 11, // 393: check predicate 11 |
| 1331 | OPC_Decode, 211, 6, 101, // 395: decode to ADDUH_R_QB_MMR2 using decoder 101 |
| 1332 | // 395: } |
| 1333 | 22, 6, // 399: case 0x16: { |
| 1334 | OPC_CheckPredicate, 10, // 401: check predicate 10 |
| 1335 | OPC_Decode, 204, 21, 102, // 403: decode to SHRAV_R_PH_MM using decoder 102 |
| 1336 | // 403: } |
| 1337 | 23, 6, // 407: case 0x17: { |
| 1338 | OPC_CheckPredicate, 11, // 409: check predicate 11 |
| 1339 | OPC_Decode, 206, 21, 102, // 411: decode to SHRAV_R_QB_MMR2 using decoder 102 |
| 1340 | // 411: } |
| 1341 | 24, 6, // 415: case 0x18: { |
| 1342 | OPC_CheckPredicate, 10, // 417: check predicate 10 |
| 1343 | OPC_Decode, 229, 22, 101, // 419: decode to SUBQ_S_PH_MM using decoder 101 |
| 1344 | // 419: } |
| 1345 | 25, 6, // 423: case 0x19: { |
| 1346 | OPC_CheckPredicate, 11, // 425: check predicate 11 |
| 1347 | OPC_Decode, 221, 22, 101, // 427: decode to SUBQH_R_PH_MMR2 using decoder 101 |
| 1348 | // 427: } |
| 1349 | 26, 6, // 431: case 0x1a: { |
| 1350 | OPC_CheckPredicate, 11, // 433: check predicate 11 |
| 1351 | OPC_Decode, 223, 22, 98, // 435: decode to SUBQH_R_W_MMR2 using decoder 98 |
| 1352 | // 435: } |
| 1353 | 27, 6, // 439: case 0x1b: { |
| 1354 | OPC_CheckPredicate, 10, // 441: check predicate 10 |
| 1355 | OPC_Decode, 134, 23, 101, // 443: decode to SUBU_S_QB_MM using decoder 101 |
| 1356 | // 443: } |
| 1357 | 28, 6, // 447: case 0x1c: { |
| 1358 | OPC_CheckPredicate, 11, // 449: check predicate 11 |
| 1359 | OPC_Decode, 132, 23, 101, // 451: decode to SUBU_S_PH_MMR2 using decoder 101 |
| 1360 | // 451: } |
| 1361 | 29, 6, // 455: case 0x1d: { |
| 1362 | OPC_CheckPredicate, 11, // 457: check predicate 11 |
| 1363 | OPC_Decode, 253, 22, 101, // 459: decode to SUBUH_R_QB_MMR2 using decoder 101 |
| 1364 | // 459: } |
| 1365 | 31, 0, // 463: case 0x1f: { |
| 1366 | OPC_CheckPredicate, 11, // 465: check predicate 11 |
| 1367 | OPC_Decode, 134, 20, 103, // 467: decode to PRECR_SRA_R_PH_W_MMR2 using decoder 103 |
| 1368 | // 467: } |
| 1369 | // 467: } // switch Inst[10:6] |
| 1370 | // 467: } |
| 1371 | 14, 19, // 471: case 0xe: { |
| 1372 | OPC_SwitchField, 6, 5, // 473: switch Inst[10:6] { |
| 1373 | 0, 6, // 476: case 0x0: { |
| 1374 | OPC_CheckPredicate, 10, // 478: check predicate 10 |
| 1375 | OPC_Decode, 184, 21, 102, // 480: decode to SHLLV_PH_MM using decoder 102 |
| 1376 | // 480: } |
| 1377 | 16, 0, // 484: case 0x10: { |
| 1378 | OPC_CheckPredicate, 10, // 486: check predicate 10 |
| 1379 | OPC_Decode, 188, 21, 102, // 488: decode to SHLLV_S_PH_MM using decoder 102 |
| 1380 | // 488: } |
| 1381 | // 488: } // switch Inst[10:6] |
| 1382 | // 488: } |
| 1383 | 16, 123, // 492: case 0x10: { |
| 1384 | OPC_SwitchField, 6, 5, // 494: switch Inst[10:6] { |
| 1385 | 0, 6, // 497: case 0x0: { |
| 1386 | OPC_CheckPredicate, 2, // 499: check predicate 2 |
| 1387 | OPC_Decode, 255, 21, 104, // 501: decode to SLLV_MM using decoder 104 |
| 1388 | // 501: } |
| 1389 | 1, 6, // 505: case 0x1: { |
| 1390 | OPC_CheckPredicate, 2, // 507: check predicate 2 |
| 1391 | OPC_Decode, 202, 22, 104, // 509: decode to SRLV_MM using decoder 104 |
| 1392 | // 509: } |
| 1393 | 2, 6, // 513: case 0x2: { |
| 1394 | OPC_CheckPredicate, 2, // 515: check predicate 2 |
| 1395 | OPC_Decode, 177, 22, 104, // 517: decode to SRAV_MM using decoder 104 |
| 1396 | // 517: } |
| 1397 | 3, 6, // 521: case 0x3: { |
| 1398 | OPC_CheckPredicate, 2, // 523: check predicate 2 |
| 1399 | OPC_Decode, 182, 20, 104, // 525: decode to ROTRV_MM using decoder 104 |
| 1400 | // 525: } |
| 1401 | 4, 6, // 529: case 0x4: { |
| 1402 | OPC_CheckPredicate, 1, // 531: check predicate 1 |
| 1403 | OPC_Decode, 235, 6, 98, // 533: decode to ADD_MM using decoder 98 |
| 1404 | // 533: } |
| 1405 | 5, 6, // 537: case 0x5: { |
| 1406 | OPC_CheckPredicate, 1, // 539: check predicate 1 |
| 1407 | OPC_Decode, 245, 6, 98, // 541: decode to ADDu_MM using decoder 98 |
| 1408 | // 541: } |
| 1409 | 6, 6, // 545: case 0x6: { |
| 1410 | OPC_CheckPredicate, 1, // 547: check predicate 1 |
| 1411 | OPC_Decode, 143, 23, 98, // 549: decode to SUB_MM using decoder 98 |
| 1412 | // 549: } |
| 1413 | 7, 6, // 553: case 0x7: { |
| 1414 | OPC_CheckPredicate, 1, // 555: check predicate 1 |
| 1415 | OPC_Decode, 148, 23, 98, // 557: decode to SUBu_MM using decoder 98 |
| 1416 | // 557: } |
| 1417 | 8, 6, // 561: case 0x8: { |
| 1418 | OPC_CheckPredicate, 1, // 563: check predicate 1 |
| 1419 | OPC_Decode, 141, 19, 98, // 565: decode to MUL_MM using decoder 98 |
| 1420 | // 565: } |
| 1421 | 9, 6, // 569: case 0x9: { |
| 1422 | OPC_CheckPredicate, 1, // 571: check predicate 1 |
| 1423 | OPC_Decode, 135, 7, 98, // 573: decode to AND_MM using decoder 98 |
| 1424 | // 573: } |
| 1425 | 10, 6, // 577: case 0xa: { |
| 1426 | OPC_CheckPredicate, 1, // 579: check predicate 1 |
| 1427 | OPC_Decode, 196, 19, 98, // 581: decode to OR_MM using decoder 98 |
| 1428 | // 581: } |
| 1429 | 11, 6, // 585: case 0xb: { |
| 1430 | OPC_CheckPredicate, 1, // 587: check predicate 1 |
| 1431 | OPC_Decode, 179, 19, 98, // 589: decode to NOR_MM using decoder 98 |
| 1432 | // 589: } |
| 1433 | 12, 6, // 593: case 0xc: { |
| 1434 | OPC_CheckPredicate, 1, // 595: check predicate 1 |
| 1435 | OPC_Decode, 199, 24, 98, // 597: decode to XOR_MM using decoder 98 |
| 1436 | // 597: } |
| 1437 | 13, 6, // 601: case 0xd: { |
| 1438 | OPC_CheckPredicate, 2, // 603: check predicate 2 |
| 1439 | OPC_Decode, 141, 22, 98, // 605: decode to SLT_MM using decoder 98 |
| 1440 | // 605: } |
| 1441 | 14, 0, // 609: case 0xe: { |
| 1442 | OPC_CheckPredicate, 2, // 611: check predicate 2 |
| 1443 | OPC_Decode, 151, 22, 98, // 613: decode to SLTu_MM using decoder 98 |
| 1444 | // 613: } |
| 1445 | // 613: } // switch Inst[10:6] |
| 1446 | // 613: } |
| 1447 | 21, 115, // 617: case 0x15: { |
| 1448 | OPC_SwitchField, 6, 5, // 619: switch Inst[10:6] { |
| 1449 | 2, 6, // 622: case 0x2: { |
| 1450 | OPC_CheckPredicate, 10, // 624: check predicate 10 |
| 1451 | OPC_Decode, 236, 18, 101, // 626: decode to MULEU_S_PH_QBL_MM using decoder 101 |
| 1452 | // 626: } |
| 1453 | 3, 6, // 630: case 0x3: { |
| 1454 | OPC_CheckPredicate, 10, // 632: check predicate 10 |
| 1455 | OPC_Decode, 238, 18, 101, // 634: decode to MULEU_S_PH_QBR_MM using decoder 101 |
| 1456 | // 634: } |
| 1457 | 4, 6, // 638: case 0x4: { |
| 1458 | OPC_CheckPredicate, 10, // 640: check predicate 10 |
| 1459 | OPC_Decode, 240, 18, 101, // 642: decode to MULQ_RS_PH_MM using decoder 101 |
| 1460 | // 642: } |
| 1461 | 5, 6, // 646: case 0x5: { |
| 1462 | OPC_CheckPredicate, 11, // 648: check predicate 11 |
| 1463 | OPC_Decode, 244, 18, 101, // 650: decode to MULQ_S_PH_MMR2 using decoder 101 |
| 1464 | // 650: } |
| 1465 | 6, 6, // 654: case 0x6: { |
| 1466 | OPC_CheckPredicate, 11, // 656: check predicate 11 |
| 1467 | OPC_Decode, 242, 18, 98, // 658: decode to MULQ_RS_W_MMR2 using decoder 98 |
| 1468 | // 658: } |
| 1469 | 7, 6, // 662: case 0x7: { |
| 1470 | OPC_CheckPredicate, 11, // 664: check predicate 11 |
| 1471 | OPC_Decode, 246, 18, 98, // 666: decode to MULQ_S_W_MMR2 using decoder 98 |
| 1472 | // 666: } |
| 1473 | 8, 6, // 670: case 0x8: { |
| 1474 | OPC_CheckPredicate, 11, // 672: check predicate 11 |
| 1475 | OPC_Decode, 143, 7, 105, // 674: decode to APPEND_MMR2 using decoder 105 |
| 1476 | // 674: } |
| 1477 | 9, 6, // 678: case 0x9: { |
| 1478 | OPC_CheckPredicate, 11, // 680: check predicate 11 |
| 1479 | OPC_Decode, 145, 20, 105, // 682: decode to PREPEND_MMR2 using decoder 105 |
| 1480 | // 682: } |
| 1481 | 10, 6, // 686: case 0xa: { |
| 1482 | OPC_CheckPredicate, 10, // 688: check predicate 10 |
| 1483 | OPC_Decode, 220, 17, 98, // 690: decode to MODSUB_MM using decoder 98 |
| 1484 | // 690: } |
| 1485 | 11, 6, // 694: case 0xb: { |
| 1486 | OPC_CheckPredicate, 10, // 696: check predicate 10 |
| 1487 | OPC_Decode, 208, 21, 104, // 698: decode to SHRAV_R_W_MM using decoder 104 |
| 1488 | // 698: } |
| 1489 | 12, 6, // 702: case 0xc: { |
| 1490 | OPC_CheckPredicate, 11, // 704: check predicate 11 |
| 1491 | OPC_Decode, 220, 21, 102, // 706: decode to SHRLV_PH_MMR2 using decoder 102 |
| 1492 | // 706: } |
| 1493 | 13, 6, // 710: case 0xd: { |
| 1494 | OPC_CheckPredicate, 10, // 712: check predicate 10 |
| 1495 | OPC_Decode, 222, 21, 102, // 714: decode to SHRLV_QB_MM using decoder 102 |
| 1496 | // 714: } |
| 1497 | 14, 6, // 718: case 0xe: { |
| 1498 | OPC_CheckPredicate, 10, // 720: check predicate 10 |
| 1499 | OPC_Decode, 186, 21, 102, // 722: decode to SHLLV_QB_MM using decoder 102 |
| 1500 | // 722: } |
| 1501 | 15, 0, // 726: case 0xf: { |
| 1502 | OPC_CheckPredicate, 10, // 728: check predicate 10 |
| 1503 | OPC_Decode, 190, 21, 104, // 730: decode to SHLLV_S_W_MM using decoder 104 |
| 1504 | // 730: } |
| 1505 | // 730: } // switch Inst[10:6] |
| 1506 | // 730: } |
| 1507 | 24, 27, // 734: case 0x18: { |
| 1508 | OPC_SwitchField, 6, 5, // 736: switch Inst[10:6] { |
| 1509 | 0, 6, // 739: case 0x0: { |
| 1510 | OPC_CheckPredicate, 1, // 741: check predicate 1 |
| 1511 | OPC_Decode, 132, 18, 106, // 743: decode to MOVN_I_MM using decoder 106 |
| 1512 | // 743: } |
| 1513 | 1, 6, // 747: case 0x1: { |
| 1514 | OPC_CheckPredicate, 1, // 749: check predicate 1 |
| 1515 | OPC_Decode, 153, 18, 106, // 751: decode to MOVZ_I_MM using decoder 106 |
| 1516 | // 751: } |
| 1517 | 4, 0, // 755: case 0x4: { |
| 1518 | OPC_CheckPredicate, 2, // 757: check predicate 2 |
| 1519 | OPC_Decode, 203, 16, 107, // 759: decode to LWXS_MM using decoder 107 |
| 1520 | // 759: } |
| 1521 | // 759: } // switch Inst[10:6] |
| 1522 | // 759: } |
| 1523 | 29, 14, // 763: case 0x1d: { |
| 1524 | OPC_CheckPredicate, 10, // 765: check predicate 10 |
| 1525 | OPC_CheckField, 22, 4, 0, // 767: check Inst[25:22] == 0x0 |
| 1526 | OPC_CheckField, 6, 8, 0, // 771: check Inst[13:6] == 0x0 |
| 1527 | OPC_Decode, 182, 21, 108, // 775: decode to SHILO_MM using decoder 108 |
| 1528 | // 775: } |
| 1529 | 37, 43, // 779: case 0x25: { |
| 1530 | OPC_SwitchField, 6, 5, // 781: switch Inst[10:6] { |
| 1531 | 0, 6, // 784: case 0x0: { |
| 1532 | OPC_CheckPredicate, 10, // 786: check predicate 10 |
| 1533 | OPC_Decode, 232, 18, 97, // 788: decode to MULEQ_S_W_PHL_MM using decoder 97 |
| 1534 | // 788: } |
| 1535 | 1, 6, // 792: case 0x1: { |
| 1536 | OPC_CheckPredicate, 10, // 794: check predicate 10 |
| 1537 | OPC_Decode, 234, 18, 97, // 796: decode to MULEQ_S_W_PHR_MM using decoder 97 |
| 1538 | // 796: } |
| 1539 | 5, 6, // 800: case 0x5: { |
| 1540 | OPC_CheckPredicate, 10, // 802: check predicate 10 |
| 1541 | OPC_Decode, 249, 15, 107, // 804: decode to LHX_MM using decoder 107 |
| 1542 | // 804: } |
| 1543 | 6, 6, // 808: case 0x6: { |
| 1544 | OPC_CheckPredicate, 10, // 810: check predicate 10 |
| 1545 | OPC_Decode, 205, 16, 107, // 812: decode to LWX_MM using decoder 107 |
| 1546 | // 812: } |
| 1547 | 8, 0, // 816: case 0x8: { |
| 1548 | OPC_CheckPredicate, 10, // 818: check predicate 10 |
| 1549 | OPC_Decode, 193, 15, 107, // 820: decode to LBUX_MM using decoder 107 |
| 1550 | // 820: } |
| 1551 | // 820: } // switch Inst[10:6] |
| 1552 | // 820: } |
| 1553 | 44, 6, // 824: case 0x2c: { |
| 1554 | OPC_CheckPredicate, 1, // 826: check predicate 1 |
| 1555 | OPC_Decode, 155, 13, 109, // 828: decode to EXT_MM using decoder 109 |
| 1556 | // 828: } |
| 1557 | 45, 83, // 832: case 0x2d: { |
| 1558 | OPC_SwitchField, 6, 5, // 834: switch Inst[10:6] { |
| 1559 | 0, 6, // 837: case 0x0: { |
| 1560 | OPC_CheckPredicate, 11, // 839: check predicate 11 |
| 1561 | OPC_Decode, 145, 19, 101, // 841: decode to MUL_PH_MMR2 using decoder 101 |
| 1562 | // 841: } |
| 1563 | 1, 6, // 845: case 0x1: { |
| 1564 | OPC_CheckPredicate, 11, // 847: check predicate 11 |
| 1565 | OPC_Decode, 130, 20, 101, // 849: decode to PRECR_QB_PH_MMR2 using decoder 101 |
| 1566 | // 849: } |
| 1567 | 2, 6, // 853: case 0x2: { |
| 1568 | OPC_CheckPredicate, 10, // 855: check predicate 10 |
| 1569 | OPC_Decode, 254, 19, 101, // 857: decode to PRECRQ_QB_PH_MM using decoder 101 |
| 1570 | // 857: } |
| 1571 | 3, 6, // 861: case 0x3: { |
| 1572 | OPC_CheckPredicate, 10, // 863: check predicate 10 |
| 1573 | OPC_Decode, 252, 19, 110, // 865: decode to PRECRQ_PH_W_MM using decoder 110 |
| 1574 | // 865: } |
| 1575 | 4, 6, // 869: case 0x4: { |
| 1576 | OPC_CheckPredicate, 10, // 871: check predicate 10 |
| 1577 | OPC_Decode, 128, 20, 110, // 873: decode to PRECRQ_RS_PH_W_MM using decoder 110 |
| 1578 | // 873: } |
| 1579 | 5, 6, // 877: case 0x5: { |
| 1580 | OPC_CheckPredicate, 10, // 879: check predicate 10 |
| 1581 | OPC_Decode, 250, 19, 101, // 881: decode to PRECRQU_S_QB_PH_MM using decoder 101 |
| 1582 | // 881: } |
| 1583 | 6, 6, // 885: case 0x6: { |
| 1584 | OPC_CheckPredicate, 10, // 887: check predicate 10 |
| 1585 | OPC_Decode, 205, 19, 101, // 889: decode to PACKRL_PH_MM using decoder 101 |
| 1586 | // 889: } |
| 1587 | 7, 6, // 893: case 0x7: { |
| 1588 | OPC_CheckPredicate, 10, // 895: check predicate 10 |
| 1589 | OPC_Decode, 225, 19, 101, // 897: decode to PICK_QB_MM using decoder 101 |
| 1590 | // 897: } |
| 1591 | 8, 6, // 901: case 0x8: { |
| 1592 | OPC_CheckPredicate, 10, // 903: check predicate 10 |
| 1593 | OPC_Decode, 223, 19, 101, // 905: decode to PICK_PH_MM using decoder 101 |
| 1594 | // 905: } |
| 1595 | 16, 0, // 909: case 0x10: { |
| 1596 | OPC_CheckPredicate, 11, // 911: check predicate 11 |
| 1597 | OPC_Decode, 150, 19, 101, // 913: decode to MUL_S_PH_MMR2 using decoder 101 |
| 1598 | // 913: } |
| 1599 | // 913: } // switch Inst[10:6] |
| 1600 | // 913: } |
| 1601 | 52, 27, // 917: case 0x34: { |
| 1602 | OPC_SwitchField, 6, 5, // 919: switch Inst[10:6] { |
| 1603 | 19, 10, // 922: case 0x13: { |
| 1604 | OPC_CheckPredicate, 12, // 924: check predicate 12 |
| 1605 | OPC_CheckField, 14, 2, 0, // 926: check Inst[15:14] == 0x0 |
| 1606 | OPC_Decode, 176, 17, 111, // 930: decode to MFHGC0_MM using decoder 111 |
| 1607 | // 930: } |
| 1608 | 27, 0, // 934: case 0x1b: { |
| 1609 | OPC_CheckPredicate, 12, // 936: check predicate 12 |
| 1610 | OPC_CheckField, 14, 2, 0, // 938: check Inst[15:14] == 0x0 |
| 1611 | OPC_Decode, 203, 18, 112, // 942: decode to MTHGC0_MM using decoder 112 |
| 1612 | // 942: } |
| 1613 | // 942: } // switch Inst[10:6] |
| 1614 | // 942: } |
| 1615 | 53, 64, // 946: case 0x35: { |
| 1616 | OPC_SwitchField, 6, 5, // 948: switch Inst[10:6] { |
| 1617 | 11, 6, // 951: case 0xb: { |
| 1618 | OPC_CheckPredicate, 10, // 953: check predicate 10 |
| 1619 | OPC_Decode, 218, 21, 95, // 955: decode to SHRA_R_W_MM using decoder 95 |
| 1620 | // 955: } |
| 1621 | 12, 10, // 959: case 0xc: { |
| 1622 | OPC_CheckPredicate, 10, // 961: check predicate 10 |
| 1623 | OPC_CheckField, 11, 1, 0, // 963: check Inst[11] == 0x0 |
| 1624 | OPC_Decode, 210, 21, 113, // 967: decode to SHRA_PH_MM using decoder 113 |
| 1625 | // 967: } |
| 1626 | 14, 19, // 971: case 0xe: { |
| 1627 | OPC_SwitchField, 11, 1, // 973: switch Inst[11] { |
| 1628 | 0, 6, // 976: case 0x0: { |
| 1629 | OPC_CheckPredicate, 10, // 978: check predicate 10 |
| 1630 | OPC_Decode, 192, 21, 113, // 980: decode to SHLL_PH_MM using decoder 113 |
| 1631 | // 980: } |
| 1632 | 1, 0, // 984: case 0x1: { |
| 1633 | OPC_CheckPredicate, 10, // 986: check predicate 10 |
| 1634 | OPC_Decode, 196, 21, 113, // 988: decode to SHLL_S_PH_MM using decoder 113 |
| 1635 | // 988: } |
| 1636 | // 988: } // switch Inst[11] |
| 1637 | // 988: } |
| 1638 | 15, 6, // 992: case 0xf: { |
| 1639 | OPC_CheckPredicate, 10, // 994: check predicate 10 |
| 1640 | OPC_Decode, 198, 21, 95, // 996: decode to SHLL_S_W_MM using decoder 95 |
| 1641 | // 996: } |
| 1642 | 28, 0, // 1000: case 0x1c: { |
| 1643 | OPC_CheckPredicate, 10, // 1002: check predicate 10 |
| 1644 | OPC_CheckField, 11, 1, 0, // 1004: check Inst[11] == 0x0 |
| 1645 | OPC_Decode, 214, 21, 113, // 1008: decode to SHRA_R_PH_MM using decoder 113 |
| 1646 | // 1008: } |
| 1647 | // 1008: } // switch Inst[10:6] |
| 1648 | // 1008: } |
| 1649 | 60, 246, 9, // 1012: case 0x3c: { |
| 1650 | OPC_SwitchField, 6, 5, // 1015: switch Inst[10:6] { |
| 1651 | 0, 19, // 1018: case 0x0: { |
| 1652 | OPC_SwitchField, 11, 1, // 1020: switch Inst[11] { |
| 1653 | 0, 6, // 1023: case 0x0: { |
| 1654 | OPC_CheckPredicate, 2, // 1025: check predicate 2 |
| 1655 | OPC_Decode, 235, 23, 114, // 1027: decode to TEQ_MM using decoder 114 |
| 1656 | // 1027: } |
| 1657 | 1, 0, // 1031: case 0x1: { |
| 1658 | OPC_CheckPredicate, 2, // 1033: check predicate 2 |
| 1659 | OPC_Decode, 147, 24, 114, // 1035: decode to TLT_MM using decoder 114 |
| 1660 | // 1035: } |
| 1661 | // 1035: } // switch Inst[11] |
| 1662 | // 1035: } |
| 1663 | 1, 77, // 1039: case 0x1: { |
| 1664 | OPC_SwitchField, 11, 2, // 1041: switch Inst[12:11] { |
| 1665 | 0, 27, // 1044: case 0x0: { |
| 1666 | OPC_SwitchField, 13, 1, // 1046: switch Inst[13] { |
| 1667 | 0, 10, // 1049: case 0x0: { |
| 1668 | OPC_CheckPredicate, 10, // 1051: check predicate 10 |
| 1669 | OPC_CheckField, 21, 5, 0, // 1053: check Inst[25:21] == 0x0 |
| 1670 | OPC_Decode, 181, 17, 115, // 1057: decode to MFHI_DSP_MM using decoder 115 |
| 1671 | // 1057: } |
| 1672 | 1, 0, // 1061: case 0x1: { |
| 1673 | OPC_CheckPredicate, 10, // 1063: check predicate 10 |
| 1674 | OPC_CheckField, 21, 5, 0, // 1065: check Inst[25:21] == 0x0 |
| 1675 | OPC_Decode, 207, 18, 116, // 1069: decode to MTHI_DSP_MM using decoder 116 |
| 1676 | // 1069: } |
| 1677 | // 1069: } // switch Inst[13] |
| 1678 | // 1069: } |
| 1679 | 1, 6, // 1073: case 0x1: { |
| 1680 | OPC_CheckPredicate, 10, // 1075: check predicate 10 |
| 1681 | OPC_Decode, 194, 21, 117, // 1077: decode to SHLL_QB_MM using decoder 117 |
| 1682 | // 1077: } |
| 1683 | 2, 27, // 1081: case 0x2: { |
| 1684 | OPC_SwitchField, 13, 1, // 1083: switch Inst[13] { |
| 1685 | 0, 10, // 1086: case 0x0: { |
| 1686 | OPC_CheckPredicate, 10, // 1088: check predicate 10 |
| 1687 | OPC_CheckField, 21, 5, 0, // 1090: check Inst[25:21] == 0x0 |
| 1688 | OPC_Decode, 187, 17, 115, // 1094: decode to MFLO_DSP_MM using decoder 115 |
| 1689 | // 1094: } |
| 1690 | 1, 0, // 1098: case 0x1: { |
| 1691 | OPC_CheckPredicate, 10, // 1100: check predicate 10 |
| 1692 | OPC_CheckField, 21, 5, 0, // 1102: check Inst[25:21] == 0x0 |
| 1693 | OPC_Decode, 214, 18, 118, // 1106: decode to MTLO_DSP_MM using decoder 118 |
| 1694 | // 1106: } |
| 1695 | // 1106: } // switch Inst[13] |
| 1696 | // 1106: } |
| 1697 | 3, 0, // 1110: case 0x3: { |
| 1698 | OPC_CheckPredicate, 10, // 1112: check predicate 10 |
| 1699 | OPC_Decode, 226, 21, 117, // 1114: decode to SHRL_QB_MM using decoder 117 |
| 1700 | // 1114: } |
| 1701 | // 1114: } // switch Inst[12:11] |
| 1702 | // 1114: } |
| 1703 | 2, 59, // 1118: case 0x2: { |
| 1704 | OPC_SwitchField, 11, 3, // 1120: switch Inst[13:11] { |
| 1705 | 0, 6, // 1123: case 0x0: { |
| 1706 | OPC_CheckPredicate, 11, // 1125: check predicate 11 |
| 1707 | OPC_Decode, 186, 12, 119, // 1127: decode to DPA_W_PH_MMR2 using decoder 119 |
| 1708 | // 1127: } |
| 1709 | 1, 6, // 1131: case 0x1: { |
| 1710 | OPC_CheckPredicate, 11, // 1133: check predicate 11 |
| 1711 | OPC_Decode, 189, 7, 120, // 1135: decode to BALIGN_MMR2 using decoder 120 |
| 1712 | // 1135: } |
| 1713 | 2, 6, // 1139: case 0x2: { |
| 1714 | OPC_CheckPredicate, 11, // 1141: check predicate 11 |
| 1715 | OPC_Decode, 184, 12, 119, // 1143: decode to DPAX_W_PH_MMR2 using decoder 119 |
| 1716 | // 1143: } |
| 1717 | 4, 6, // 1147: case 0x4: { |
| 1718 | OPC_CheckPredicate, 10, // 1149: check predicate 10 |
| 1719 | OPC_Decode, 180, 12, 119, // 1151: decode to DPAU_H_QBL_MM using decoder 119 |
| 1720 | // 1151: } |
| 1721 | 5, 6, // 1155: case 0x5: { |
| 1722 | OPC_CheckPredicate, 10, // 1157: check predicate 10 |
| 1723 | OPC_Decode, 134, 13, 121, // 1159: decode to EXTPV_MM using decoder 121 |
| 1724 | // 1159: } |
| 1725 | 6, 6, // 1163: case 0x6: { |
| 1726 | OPC_CheckPredicate, 10, // 1165: check predicate 10 |
| 1727 | OPC_Decode, 182, 12, 119, // 1167: decode to DPAU_H_QBR_MM using decoder 119 |
| 1728 | // 1167: } |
| 1729 | 7, 0, // 1171: case 0x7: { |
| 1730 | OPC_CheckPredicate, 10, // 1173: check predicate 10 |
| 1731 | OPC_Decode, 131, 13, 121, // 1175: decode to EXTPDPV_MM using decoder 121 |
| 1732 | // 1175: } |
| 1733 | // 1175: } // switch Inst[13:11] |
| 1734 | // 1175: } |
| 1735 | 3, 10, // 1179: case 0x3: { |
| 1736 | OPC_CheckPredicate, 1, // 1181: check predicate 1 |
| 1737 | OPC_CheckField, 14, 2, 0, // 1183: check Inst[15:14] == 0x0 |
| 1738 | OPC_Decode, 157, 17, 111, // 1187: decode to MFC0_MM using decoder 111 |
| 1739 | // 1187: } |
| 1740 | 4, 99, // 1191: case 0x4: { |
| 1741 | OPC_SwitchField, 11, 5, // 1193: switch Inst[15:11] { |
| 1742 | 0, 6, // 1196: case 0x0: { |
| 1743 | OPC_CheckPredicate, 11, // 1198: check predicate 11 |
| 1744 | OPC_Decode, 154, 6, 122, // 1200: decode to ABSQ_S_QB_MMR2 using decoder 122 |
| 1745 | // 1200: } |
| 1746 | 2, 6, // 1204: case 0x2: { |
| 1747 | OPC_CheckPredicate, 10, // 1206: check predicate 10 |
| 1748 | OPC_Decode, 152, 6, 122, // 1208: decode to ABSQ_S_PH_MM using decoder 122 |
| 1749 | // 1208: } |
| 1750 | 4, 6, // 1212: case 0x4: { |
| 1751 | OPC_CheckPredicate, 10, // 1214: check predicate 10 |
| 1752 | OPC_Decode, 156, 6, 123, // 1216: decode to ABSQ_S_W_MM using decoder 123 |
| 1753 | // 1216: } |
| 1754 | 6, 6, // 1220: case 0x6: { |
| 1755 | OPC_CheckPredicate, 10, // 1222: check predicate 10 |
| 1756 | OPC_Decode, 164, 8, 123, // 1224: decode to BITREV_MM using decoder 123 |
| 1757 | // 1224: } |
| 1758 | 8, 6, // 1228: case 0x8: { |
| 1759 | OPC_CheckPredicate, 10, // 1230: check predicate 10 |
| 1760 | OPC_Decode, 129, 15, 124, // 1232: decode to INSV_MM using decoder 124 |
| 1761 | // 1232: } |
| 1762 | 10, 6, // 1236: case 0xa: { |
| 1763 | OPC_CheckPredicate, 10, // 1238: check predicate 10 |
| 1764 | OPC_Decode, 238, 19, 125, // 1240: decode to PRECEQ_W_PHL_MM using decoder 125 |
| 1765 | // 1240: } |
| 1766 | 12, 6, // 1244: case 0xc: { |
| 1767 | OPC_CheckPredicate, 10, // 1246: check predicate 10 |
| 1768 | OPC_Decode, 240, 19, 125, // 1248: decode to PRECEQ_W_PHR_MM using decoder 125 |
| 1769 | // 1248: } |
| 1770 | 14, 6, // 1252: case 0xe: { |
| 1771 | OPC_CheckPredicate, 10, // 1254: check predicate 10 |
| 1772 | OPC_Decode, 232, 19, 122, // 1256: decode to PRECEQU_PH_QBL_MM using decoder 122 |
| 1773 | // 1256: } |
| 1774 | 18, 6, // 1260: case 0x12: { |
| 1775 | OPC_CheckPredicate, 10, // 1262: check predicate 10 |
| 1776 | OPC_Decode, 236, 19, 122, // 1264: decode to PRECEQU_PH_QBR_MM using decoder 122 |
| 1777 | // 1264: } |
| 1778 | 22, 6, // 1268: case 0x16: { |
| 1779 | OPC_CheckPredicate, 10, // 1270: check predicate 10 |
| 1780 | OPC_Decode, 244, 19, 122, // 1272: decode to PRECEU_PH_QBL_MM using decoder 122 |
| 1781 | // 1272: } |
| 1782 | 26, 6, // 1276: case 0x1a: { |
| 1783 | OPC_CheckPredicate, 10, // 1278: check predicate 10 |
| 1784 | OPC_Decode, 248, 19, 122, // 1280: decode to PRECEU_PH_QBR_MM using decoder 122 |
| 1785 | // 1280: } |
| 1786 | 30, 0, // 1284: case 0x1e: { |
| 1787 | OPC_CheckPredicate, 10, // 1286: check predicate 10 |
| 1788 | OPC_Decode, 149, 20, 125, // 1288: decode to RADDU_W_QB_MM using decoder 125 |
| 1789 | // 1288: } |
| 1790 | // 1288: } // switch Inst[15:11] |
| 1791 | // 1288: } |
| 1792 | 5, 51, // 1292: case 0x5: { |
| 1793 | OPC_SwitchField, 11, 15, // 1294: switch Inst[25:11] { |
| 1794 | 0, 6, // 1297: case 0x0: { |
| 1795 | OPC_CheckPredicate, 12, // 1299: check predicate 12 |
| 1796 | OPC_Decode, 250, 23, 10, // 1301: decode to TLBGP_MM using decoder 10 |
| 1797 | // 1301: } |
| 1798 | 2, 6, // 1305: case 0x2: { |
| 1799 | OPC_CheckPredicate, 12, // 1307: check predicate 12 |
| 1800 | OPC_Decode, 252, 23, 10, // 1309: decode to TLBGR_MM using decoder 10 |
| 1801 | // 1309: } |
| 1802 | 4, 6, // 1313: case 0x4: { |
| 1803 | OPC_CheckPredicate, 12, // 1315: check predicate 12 |
| 1804 | OPC_Decode, 254, 23, 10, // 1317: decode to TLBGWI_MM using decoder 10 |
| 1805 | // 1317: } |
| 1806 | 6, 6, // 1321: case 0x6: { |
| 1807 | OPC_CheckPredicate, 12, // 1323: check predicate 12 |
| 1808 | OPC_Decode, 128, 24, 10, // 1325: decode to TLBGWR_MM using decoder 10 |
| 1809 | // 1325: } |
| 1810 | 8, 6, // 1329: case 0x8: { |
| 1811 | OPC_CheckPredicate, 12, // 1331: check predicate 12 |
| 1812 | OPC_Decode, 248, 23, 10, // 1333: decode to TLBGINV_MM using decoder 10 |
| 1813 | // 1333: } |
| 1814 | 10, 0, // 1337: case 0xa: { |
| 1815 | OPC_CheckPredicate, 12, // 1339: check predicate 12 |
| 1816 | OPC_Decode, 247, 23, 10, // 1341: decode to TLBGINVF_MM using decoder 10 |
| 1817 | // 1341: } |
| 1818 | // 1341: } // switch Inst[25:11] |
| 1819 | // 1341: } |
| 1820 | 7, 19, // 1345: case 0x7: { |
| 1821 | OPC_SwitchField, 11, 2, // 1347: switch Inst[12:11] { |
| 1822 | 0, 6, // 1350: case 0x0: { |
| 1823 | OPC_CheckPredicate, 11, // 1352: check predicate 11 |
| 1824 | OPC_Decode, 212, 21, 117, // 1354: decode to SHRA_QB_MMR2 using decoder 117 |
| 1825 | // 1354: } |
| 1826 | 2, 0, // 1358: case 0x2: { |
| 1827 | OPC_CheckPredicate, 11, // 1360: check predicate 11 |
| 1828 | OPC_Decode, 216, 21, 117, // 1362: decode to SHRA_R_QB_MMR2 using decoder 117 |
| 1829 | // 1362: } |
| 1830 | // 1362: } // switch Inst[12:11] |
| 1831 | // 1362: } |
| 1832 | 8, 19, // 1366: case 0x8: { |
| 1833 | OPC_SwitchField, 11, 1, // 1368: switch Inst[11] { |
| 1834 | 0, 6, // 1371: case 0x0: { |
| 1835 | OPC_CheckPredicate, 2, // 1373: check predicate 2 |
| 1836 | OPC_Decode, 244, 23, 114, // 1375: decode to TGE_MM using decoder 114 |
| 1837 | // 1375: } |
| 1838 | 1, 0, // 1379: case 0x1: { |
| 1839 | OPC_CheckPredicate, 2, // 1381: check predicate 2 |
| 1840 | OPC_Decode, 146, 24, 114, // 1383: decode to TLTU_MM using decoder 114 |
| 1841 | // 1383: } |
| 1842 | // 1383: } // switch Inst[11] |
| 1843 | // 1383: } |
| 1844 | 9, 59, // 1387: case 0x9: { |
| 1845 | OPC_SwitchField, 11, 3, // 1389: switch Inst[13:11] { |
| 1846 | 0, 10, // 1392: case 0x0: { |
| 1847 | OPC_CheckPredicate, 10, // 1394: check predicate 10 |
| 1848 | OPC_CheckField, 21, 5, 0, // 1396: check Inst[25:21] == 0x0 |
| 1849 | OPC_Decode, 210, 18, 126, // 1400: decode to MTHLIP_MM using decoder 126 |
| 1850 | // 1400: } |
| 1851 | 1, 6, // 1404: case 0x1: { |
| 1852 | OPC_CheckPredicate, 10, // 1406: check predicate 10 |
| 1853 | OPC_Decode, 255, 16, 119, // 1408: decode to MAQ_S_W_PHR_MM using decoder 119 |
| 1854 | // 1408: } |
| 1855 | 2, 10, // 1412: case 0x2: { |
| 1856 | OPC_CheckPredicate, 10, // 1414: check predicate 10 |
| 1857 | OPC_CheckField, 21, 5, 0, // 1416: check Inst[25:21] == 0x0 |
| 1858 | OPC_Decode, 181, 21, 126, // 1420: decode to SHILOV_MM using decoder 126 |
| 1859 | // 1420: } |
| 1860 | 3, 6, // 1424: case 0x3: { |
| 1861 | OPC_CheckPredicate, 10, // 1426: check predicate 10 |
| 1862 | OPC_Decode, 253, 16, 119, // 1428: decode to MAQ_S_W_PHL_MM using decoder 119 |
| 1863 | // 1428: } |
| 1864 | 5, 6, // 1432: case 0x5: { |
| 1865 | OPC_CheckPredicate, 10, // 1434: check predicate 10 |
| 1866 | OPC_Decode, 251, 16, 119, // 1436: decode to MAQ_SA_W_PHR_MM using decoder 119 |
| 1867 | // 1436: } |
| 1868 | 7, 0, // 1440: case 0x7: { |
| 1869 | OPC_CheckPredicate, 10, // 1442: check predicate 10 |
| 1870 | OPC_Decode, 249, 16, 119, // 1444: decode to MAQ_SA_W_PHL_MM using decoder 119 |
| 1871 | // 1444: } |
| 1872 | // 1444: } // switch Inst[13:11] |
| 1873 | // 1444: } |
| 1874 | 10, 67, // 1448: case 0xa: { |
| 1875 | OPC_SwitchField, 11, 3, // 1450: switch Inst[13:11] { |
| 1876 | 0, 6, // 1453: case 0x0: { |
| 1877 | OPC_CheckPredicate, 10, // 1455: check predicate 10 |
| 1878 | OPC_Decode, 178, 12, 119, // 1457: decode to DPAQ_S_W_PH_MM using decoder 119 |
| 1879 | // 1457: } |
| 1880 | 1, 6, // 1461: case 0x1: { |
| 1881 | OPC_CheckPredicate, 10, // 1463: check predicate 10 |
| 1882 | OPC_Decode, 242, 16, 127, // 1465: decode to MADD_DSP_MM using decoder 127 |
| 1883 | // 1465: } |
| 1884 | 2, 6, // 1469: case 0x2: { |
| 1885 | OPC_CheckPredicate, 10, // 1471: check predicate 10 |
| 1886 | OPC_Decode, 176, 12, 119, // 1473: decode to DPAQ_SA_L_W_MM using decoder 119 |
| 1887 | // 1473: } |
| 1888 | 3, 6, // 1477: case 0x3: { |
| 1889 | OPC_CheckPredicate, 10, // 1479: check predicate 10 |
| 1890 | OPC_Decode, 232, 16, 127, // 1481: decode to MADDU_DSP_MM using decoder 127 |
| 1891 | // 1481: } |
| 1892 | 4, 6, // 1485: case 0x4: { |
| 1893 | OPC_CheckPredicate, 11, // 1487: check predicate 11 |
| 1894 | OPC_Decode, 174, 12, 119, // 1489: decode to DPAQX_S_W_PH_MMR2 using decoder 119 |
| 1895 | // 1489: } |
| 1896 | 5, 6, // 1493: case 0x5: { |
| 1897 | OPC_CheckPredicate, 10, // 1495: check predicate 10 |
| 1898 | OPC_Decode, 176, 18, 127, // 1497: decode to MSUB_DSP_MM using decoder 127 |
| 1899 | // 1497: } |
| 1900 | 6, 6, // 1501: case 0x6: { |
| 1901 | OPC_CheckPredicate, 11, // 1503: check predicate 11 |
| 1902 | OPC_Decode, 172, 12, 119, // 1505: decode to DPAQX_SA_W_PH_MMR2 using decoder 119 |
| 1903 | // 1505: } |
| 1904 | 7, 0, // 1509: case 0x7: { |
| 1905 | OPC_CheckPredicate, 10, // 1511: check predicate 10 |
| 1906 | OPC_Decode, 166, 18, 127, // 1513: decode to MSUBU_DSP_MM using decoder 127 |
| 1907 | // 1513: } |
| 1908 | // 1513: } // switch Inst[13:11] |
| 1909 | // 1513: } |
| 1910 | 11, 10, // 1517: case 0xb: { |
| 1911 | OPC_CheckPredicate, 1, // 1519: check predicate 1 |
| 1912 | OPC_CheckField, 14, 2, 0, // 1521: check Inst[15:14] == 0x0 |
| 1913 | OPC_Decode, 183, 18, 112, // 1525: decode to MTC0_MM using decoder 112 |
| 1914 | // 1525: } |
| 1915 | 12, 174, 1, // 1529: case 0xc: { |
| 1916 | OPC_SwitchField, 11, 5, // 1532: switch Inst[15:11] { |
| 1917 | 0, 7, // 1535: case 0x0: { |
| 1918 | OPC_CheckPredicate, 10, // 1537: check predicate 10 |
| 1919 | OPC_Decode, 166, 20, 128, 1, // 1539: decode to REPLV_PH_MM using decoder 128 |
| 1920 | // 1539: } |
| 1921 | 2, 7, // 1544: case 0x2: { |
| 1922 | OPC_CheckPredicate, 10, // 1546: check predicate 10 |
| 1923 | OPC_Decode, 168, 20, 128, 1, // 1548: decode to REPLV_QB_MM using decoder 128 |
| 1924 | // 1548: } |
| 1925 | 5, 6, // 1553: case 0x5: { |
| 1926 | OPC_CheckPredicate, 2, // 1555: check predicate 2 |
| 1927 | OPC_Decode, 141, 21, 123, // 1557: decode to SEB_MM using decoder 123 |
| 1928 | // 1557: } |
| 1929 | 7, 6, // 1561: case 0x7: { |
| 1930 | OPC_CheckPredicate, 2, // 1563: check predicate 2 |
| 1931 | OPC_Decode, 145, 21, 123, // 1565: decode to SEH_MM using decoder 123 |
| 1932 | // 1565: } |
| 1933 | 9, 6, // 1569: case 0x9: { |
| 1934 | OPC_CheckPredicate, 2, // 1571: check predicate 2 |
| 1935 | OPC_Decode, 203, 9, 123, // 1573: decode to CLO_MM using decoder 123 |
| 1936 | // 1573: } |
| 1937 | 11, 6, // 1577: case 0xb: { |
| 1938 | OPC_CheckPredicate, 2, // 1579: check predicate 2 |
| 1939 | OPC_Decode, 224, 9, 123, // 1581: decode to CLZ_MM using decoder 123 |
| 1940 | // 1581: } |
| 1941 | 13, 7, // 1585: case 0xd: { |
| 1942 | OPC_CheckPredicate, 1, // 1587: check predicate 1 |
| 1943 | OPC_Decode, 154, 20, 129, 1, // 1589: decode to RDHWR_MM using decoder 129 |
| 1944 | // 1589: } |
| 1945 | 14, 6, // 1594: case 0xe: { |
| 1946 | OPC_CheckPredicate, 10, // 1596: check predicate 10 |
| 1947 | OPC_Decode, 231, 19, 122, // 1598: decode to PRECEQU_PH_QBLA_MM using decoder 122 |
| 1948 | // 1598: } |
| 1949 | 15, 6, // 1602: case 0xf: { |
| 1950 | OPC_CheckPredicate, 2, // 1604: check predicate 2 |
| 1951 | OPC_Decode, 189, 24, 123, // 1606: decode to WSBH_MM using decoder 123 |
| 1952 | // 1606: } |
| 1953 | 17, 7, // 1610: case 0x11: { |
| 1954 | OPC_CheckPredicate, 1, // 1612: check predicate 1 |
| 1955 | OPC_Decode, 131, 19, 130, 1, // 1614: decode to MULT_MM using decoder 130 |
| 1956 | // 1614: } |
| 1957 | 18, 6, // 1619: case 0x12: { |
| 1958 | OPC_CheckPredicate, 10, // 1621: check predicate 10 |
| 1959 | OPC_Decode, 235, 19, 122, // 1623: decode to PRECEQU_PH_QBRA_MM using decoder 122 |
| 1960 | // 1623: } |
| 1961 | 19, 7, // 1627: case 0x13: { |
| 1962 | OPC_CheckPredicate, 1, // 1629: check predicate 1 |
| 1963 | OPC_Decode, 133, 19, 130, 1, // 1631: decode to MULTu_MM using decoder 130 |
| 1964 | // 1631: } |
| 1965 | 21, 7, // 1636: case 0x15: { |
| 1966 | OPC_CheckPredicate, 1, // 1638: check predicate 1 |
| 1967 | OPC_Decode, 134, 21, 130, 1, // 1640: decode to SDIV_MM using decoder 130 |
| 1968 | // 1640: } |
| 1969 | 22, 6, // 1645: case 0x16: { |
| 1970 | OPC_CheckPredicate, 10, // 1647: check predicate 10 |
| 1971 | OPC_Decode, 243, 19, 122, // 1649: decode to PRECEU_PH_QBLA_MM using decoder 122 |
| 1972 | // 1649: } |
| 1973 | 23, 7, // 1653: case 0x17: { |
| 1974 | OPC_CheckPredicate, 1, // 1655: check predicate 1 |
| 1975 | OPC_Decode, 172, 24, 130, 1, // 1657: decode to UDIV_MM using decoder 130 |
| 1976 | // 1657: } |
| 1977 | 25, 7, // 1662: case 0x19: { |
| 1978 | OPC_CheckPredicate, 1, // 1664: check predicate 1 |
| 1979 | OPC_Decode, 243, 16, 130, 1, // 1666: decode to MADD_MM using decoder 130 |
| 1980 | // 1666: } |
| 1981 | 26, 6, // 1671: case 0x1a: { |
| 1982 | OPC_CheckPredicate, 10, // 1673: check predicate 10 |
| 1983 | OPC_Decode, 247, 19, 122, // 1675: decode to PRECEU_PH_QBRA_MM using decoder 122 |
| 1984 | // 1675: } |
| 1985 | 27, 7, // 1679: case 0x1b: { |
| 1986 | OPC_CheckPredicate, 1, // 1681: check predicate 1 |
| 1987 | OPC_Decode, 233, 16, 130, 1, // 1683: decode to MADDU_MM using decoder 130 |
| 1988 | // 1683: } |
| 1989 | 29, 7, // 1688: case 0x1d: { |
| 1990 | OPC_CheckPredicate, 1, // 1690: check predicate 1 |
| 1991 | OPC_Decode, 177, 18, 130, 1, // 1692: decode to MSUB_MM using decoder 130 |
| 1992 | // 1692: } |
| 1993 | 31, 0, // 1697: case 0x1f: { |
| 1994 | OPC_CheckPredicate, 1, // 1699: check predicate 1 |
| 1995 | OPC_Decode, 167, 18, 130, 1, // 1701: decode to MSUBU_MM using decoder 130 |
| 1996 | // 1701: } |
| 1997 | // 1701: } // switch Inst[15:11] |
| 1998 | // 1701: } |
| 1999 | 13, 124, // 1706: case 0xd: { |
| 2000 | OPC_SwitchField, 11, 5, // 1708: switch Inst[15:11] { |
| 2001 | 0, 10, // 1711: case 0x0: { |
| 2002 | OPC_CheckPredicate, 2, // 1713: check predicate 2 |
| 2003 | OPC_CheckField, 16, 10, 0, // 1715: check Inst[25:16] == 0x0 |
| 2004 | OPC_Decode, 134, 24, 10, // 1719: decode to TLBP_MM using decoder 10 |
| 2005 | // 1719: } |
| 2006 | 2, 10, // 1723: case 0x2: { |
| 2007 | OPC_CheckPredicate, 2, // 1725: check predicate 2 |
| 2008 | OPC_CheckField, 16, 10, 0, // 1727: check Inst[25:16] == 0x0 |
| 2009 | OPC_Decode, 136, 24, 10, // 1731: decode to TLBR_MM using decoder 10 |
| 2010 | // 1731: } |
| 2011 | 4, 10, // 1735: case 0x4: { |
| 2012 | OPC_CheckPredicate, 2, // 1737: check predicate 2 |
| 2013 | OPC_CheckField, 16, 10, 0, // 1739: check Inst[25:16] == 0x0 |
| 2014 | OPC_Decode, 138, 24, 10, // 1743: decode to TLBWI_MM using decoder 10 |
| 2015 | // 1743: } |
| 2016 | 6, 10, // 1747: case 0x6: { |
| 2017 | OPC_CheckPredicate, 2, // 1749: check predicate 2 |
| 2018 | OPC_CheckField, 16, 10, 0, // 1751: check Inst[25:16] == 0x0 |
| 2019 | OPC_Decode, 140, 24, 10, // 1755: decode to TLBWR_MM using decoder 10 |
| 2020 | // 1755: } |
| 2021 | 13, 11, // 1759: case 0xd: { |
| 2022 | OPC_CheckPredicate, 2, // 1761: check predicate 2 |
| 2023 | OPC_CheckField, 21, 5, 0, // 1763: check Inst[25:21] == 0x0 |
| 2024 | OPC_Decode, 204, 23, 131, 1, // 1767: decode to SYNC_MM using decoder 131 |
| 2025 | // 1767: } |
| 2026 | 17, 7, // 1772: case 0x11: { |
| 2027 | OPC_CheckPredicate, 2, // 1774: check predicate 2 |
| 2028 | OPC_Decode, 209, 23, 132, 1, // 1776: decode to SYSCALL_MM using decoder 132 |
| 2029 | // 1776: } |
| 2030 | 18, 7, // 1781: case 0x12: { |
| 2031 | OPC_CheckPredicate, 2, // 1783: check predicate 2 |
| 2032 | OPC_Decode, 181, 24, 132, 1, // 1785: decode to WAIT_MM using decoder 132 |
| 2033 | // 1785: } |
| 2034 | 24, 7, // 1790: case 0x18: { |
| 2035 | OPC_CheckPredicate, 12, // 1792: check predicate 12 |
| 2036 | OPC_Decode, 230, 14, 132, 1, // 1794: decode to HYPCALL_MM using decoder 132 |
| 2037 | // 1794: } |
| 2038 | 27, 7, // 1799: case 0x1b: { |
| 2039 | OPC_CheckPredicate, 2, // 1801: check predicate 2 |
| 2040 | OPC_Decode, 248, 20, 132, 1, // 1803: decode to SDBBP_MM using decoder 132 |
| 2041 | // 1803: } |
| 2042 | 28, 10, // 1808: case 0x1c: { |
| 2043 | OPC_CheckPredicate, 2, // 1810: check predicate 2 |
| 2044 | OPC_CheckField, 16, 10, 0, // 1812: check Inst[25:16] == 0x0 |
| 2045 | OPC_Decode, 237, 11, 10, // 1816: decode to DERET_MM using decoder 10 |
| 2046 | // 1816: } |
| 2047 | 30, 0, // 1820: case 0x1e: { |
| 2048 | OPC_CheckPredicate, 2, // 1822: check predicate 2 |
| 2049 | OPC_CheckField, 16, 10, 0, // 1824: check Inst[25:16] == 0x0 |
| 2050 | OPC_Decode, 248, 12, 10, // 1828: decode to ERET_MM using decoder 10 |
| 2051 | // 1828: } |
| 2052 | // 1828: } // switch Inst[15:11] |
| 2053 | // 1828: } |
| 2054 | 15, 10, // 1832: case 0xf: { |
| 2055 | OPC_CheckPredicate, 11, // 1834: check predicate 11 |
| 2056 | OPC_CheckField, 11, 1, 0, // 1836: check Inst[11] == 0x0 |
| 2057 | OPC_Decode, 224, 21, 113, // 1840: decode to SHRL_PH_MMR2 using decoder 113 |
| 2058 | // 1840: } |
| 2059 | 16, 19, // 1844: case 0x10: { |
| 2060 | OPC_SwitchField, 11, 1, // 1846: switch Inst[11] { |
| 2061 | 0, 6, // 1849: case 0x0: { |
| 2062 | OPC_CheckPredicate, 2, // 1851: check predicate 2 |
| 2063 | OPC_Decode, 243, 23, 114, // 1853: decode to TGEU_MM using decoder 114 |
| 2064 | // 1853: } |
| 2065 | 1, 0, // 1857: case 0x1: { |
| 2066 | OPC_CheckPredicate, 2, // 1859: check predicate 2 |
| 2067 | OPC_Decode, 151, 24, 114, // 1861: decode to TNE_MM using decoder 114 |
| 2068 | // 1861: } |
| 2069 | // 1861: } // switch Inst[11] |
| 2070 | // 1861: } |
| 2071 | 18, 69, // 1865: case 0x12: { |
| 2072 | OPC_SwitchField, 11, 3, // 1867: switch Inst[13:11] { |
| 2073 | 0, 6, // 1870: case 0x0: { |
| 2074 | OPC_CheckPredicate, 11, // 1872: check predicate 11 |
| 2075 | OPC_Decode, 209, 12, 119, // 1874: decode to DPS_W_PH_MMR2 using decoder 119 |
| 2076 | // 1874: } |
| 2077 | 1, 7, // 1878: case 0x1: { |
| 2078 | OPC_CheckPredicate, 10, // 1880: check predicate 10 |
| 2079 | OPC_Decode, 130, 19, 133, 1, // 1882: decode to MULT_DSP_MM using decoder 133 |
| 2080 | // 1882: } |
| 2081 | 2, 6, // 1887: case 0x2: { |
| 2082 | OPC_CheckPredicate, 11, // 1889: check predicate 11 |
| 2083 | OPC_Decode, 207, 12, 119, // 1891: decode to DPSX_W_PH_MMR2 using decoder 119 |
| 2084 | // 1891: } |
| 2085 | 3, 7, // 1895: case 0x3: { |
| 2086 | OPC_CheckPredicate, 10, // 1897: check predicate 10 |
| 2087 | OPC_Decode, 128, 19, 133, 1, // 1899: decode to MULTU_DSP_MM using decoder 133 |
| 2088 | // 1899: } |
| 2089 | 4, 6, // 1904: case 0x4: { |
| 2090 | OPC_CheckPredicate, 10, // 1906: check predicate 10 |
| 2091 | OPC_Decode, 203, 12, 119, // 1908: decode to DPSU_H_QBL_MM using decoder 119 |
| 2092 | // 1908: } |
| 2093 | 5, 6, // 1912: case 0x5: { |
| 2094 | OPC_CheckPredicate, 11, // 1914: check predicate 11 |
| 2095 | OPC_Decode, 253, 18, 119, // 1916: decode to MULSA_W_PH_MMR2 using decoder 119 |
| 2096 | // 1916: } |
| 2097 | 6, 6, // 1920: case 0x6: { |
| 2098 | OPC_CheckPredicate, 10, // 1922: check predicate 10 |
| 2099 | OPC_Decode, 205, 12, 119, // 1924: decode to DPSU_H_QBR_MM using decoder 119 |
| 2100 | // 1924: } |
| 2101 | 7, 0, // 1928: case 0x7: { |
| 2102 | OPC_CheckPredicate, 10, // 1930: check predicate 10 |
| 2103 | OPC_Decode, 251, 18, 119, // 1932: decode to MULSAQ_S_W_PH_MM using decoder 119 |
| 2104 | // 1932: } |
| 2105 | // 1932: } // switch Inst[13:11] |
| 2106 | // 1932: } |
| 2107 | 19, 10, // 1936: case 0x13: { |
| 2108 | OPC_CheckPredicate, 12, // 1938: check predicate 12 |
| 2109 | OPC_CheckField, 14, 2, 0, // 1940: check Inst[15:14] == 0x0 |
| 2110 | OPC_Decode, 167, 17, 111, // 1944: decode to MFGC0_MM using decoder 111 |
| 2111 | // 1944: } |
| 2112 | 20, 21, // 1948: case 0x14: { |
| 2113 | OPC_SwitchField, 11, 5, // 1950: switch Inst[15:11] { |
| 2114 | 25, 7, // 1953: case 0x19: { |
| 2115 | OPC_CheckPredicate, 2, // 1955: check predicate 2 |
| 2116 | OPC_Decode, 176, 9, 134, 1, // 1957: decode to CFC2_MM using decoder 134 |
| 2117 | // 1957: } |
| 2118 | 27, 0, // 1962: case 0x1b: { |
| 2119 | OPC_CheckPredicate, 2, // 1964: check predicate 2 |
| 2120 | OPC_Decode, 211, 10, 135, 1, // 1966: decode to CTC2_MM using decoder 135 |
| 2121 | // 1966: } |
| 2122 | // 1966: } // switch Inst[15:11] |
| 2123 | // 1966: } |
| 2124 | 21, 55, // 1971: case 0x15: { |
| 2125 | OPC_SwitchField, 11, 5, // 1973: switch Inst[15:11] { |
| 2126 | 1, 11, // 1976: case 0x1: { |
| 2127 | OPC_CheckPredicate, 1, // 1978: check predicate 1 |
| 2128 | OPC_CheckField, 21, 5, 0, // 1980: check Inst[25:21] == 0x0 |
| 2129 | OPC_Decode, 182, 17, 136, 1, // 1984: decode to MFHI_MM using decoder 136 |
| 2130 | // 1984: } |
| 2131 | 3, 11, // 1989: case 0x3: { |
| 2132 | OPC_CheckPredicate, 1, // 1991: check predicate 1 |
| 2133 | OPC_CheckField, 21, 5, 0, // 1993: check Inst[25:21] == 0x0 |
| 2134 | OPC_Decode, 188, 17, 136, 1, // 1997: decode to MFLO_MM using decoder 136 |
| 2135 | // 1997: } |
| 2136 | 5, 11, // 2002: case 0x5: { |
| 2137 | OPC_CheckPredicate, 1, // 2004: check predicate 1 |
| 2138 | OPC_CheckField, 21, 5, 0, // 2006: check Inst[25:21] == 0x0 |
| 2139 | OPC_Decode, 208, 18, 136, 1, // 2010: decode to MTHI_MM using decoder 136 |
| 2140 | // 2010: } |
| 2141 | 7, 0, // 2015: case 0x7: { |
| 2142 | OPC_CheckPredicate, 1, // 2017: check predicate 1 |
| 2143 | OPC_CheckField, 21, 5, 0, // 2019: check Inst[25:21] == 0x0 |
| 2144 | OPC_Decode, 215, 18, 136, 1, // 2023: decode to MTLO_MM using decoder 136 |
| 2145 | // 2023: } |
| 2146 | // 2023: } // switch Inst[15:11] |
| 2147 | // 2023: } |
| 2148 | 23, 11, // 2028: case 0x17: { |
| 2149 | OPC_CheckPredicate, 10, // 2030: check predicate 10 |
| 2150 | OPC_CheckField, 11, 2, 0, // 2032: check Inst[12:11] == 0x0 |
| 2151 | OPC_Decode, 172, 20, 137, 1, // 2036: decode to REPL_QB_MM using decoder 137 |
| 2152 | // 2036: } |
| 2153 | 25, 75, // 2041: case 0x19: { |
| 2154 | OPC_SwitchField, 11, 3, // 2043: switch Inst[13:11] { |
| 2155 | 0, 7, // 2046: case 0x0: { |
| 2156 | OPC_CheckPredicate, 10, // 2048: check predicate 10 |
| 2157 | OPC_Decode, 151, 20, 138, 1, // 2050: decode to RDDSP_MM using decoder 138 |
| 2158 | // 2050: } |
| 2159 | 1, 7, // 2055: case 0x1: { |
| 2160 | OPC_CheckPredicate, 10, // 2057: check predicate 10 |
| 2161 | OPC_Decode, 151, 13, 139, 1, // 2059: decode to EXTR_W_MM using decoder 139 |
| 2162 | // 2059: } |
| 2163 | 2, 7, // 2064: case 0x2: { |
| 2164 | OPC_CheckPredicate, 10, // 2066: check predicate 10 |
| 2165 | OPC_Decode, 185, 24, 138, 1, // 2068: decode to WRDSP_MM using decoder 138 |
| 2166 | // 2068: } |
| 2167 | 3, 7, // 2073: case 0x3: { |
| 2168 | OPC_CheckPredicate, 10, // 2075: check predicate 10 |
| 2169 | OPC_Decode, 147, 13, 139, 1, // 2077: decode to EXTR_R_W_MM using decoder 139 |
| 2170 | // 2077: } |
| 2171 | 4, 7, // 2082: case 0x4: { |
| 2172 | OPC_CheckPredicate, 10, // 2084: check predicate 10 |
| 2173 | OPC_Decode, 135, 13, 139, 1, // 2086: decode to EXTP_MM using decoder 139 |
| 2174 | // 2086: } |
| 2175 | 5, 7, // 2091: case 0x5: { |
| 2176 | OPC_CheckPredicate, 10, // 2093: check predicate 10 |
| 2177 | OPC_Decode, 145, 13, 139, 1, // 2095: decode to EXTR_RS_W_MM using decoder 139 |
| 2178 | // 2095: } |
| 2179 | 6, 7, // 2100: case 0x6: { |
| 2180 | OPC_CheckPredicate, 10, // 2102: check predicate 10 |
| 2181 | OPC_Decode, 132, 13, 139, 1, // 2104: decode to EXTPDP_MM using decoder 139 |
| 2182 | // 2104: } |
| 2183 | 7, 0, // 2109: case 0x7: { |
| 2184 | OPC_CheckPredicate, 10, // 2111: check predicate 10 |
| 2185 | OPC_Decode, 149, 13, 139, 1, // 2113: decode to EXTR_S_H_MM using decoder 139 |
| 2186 | // 2113: } |
| 2187 | // 2113: } // switch Inst[13:11] |
| 2188 | // 2113: } |
| 2189 | 26, 67, // 2118: case 0x1a: { |
| 2190 | OPC_SwitchField, 11, 3, // 2120: switch Inst[13:11] { |
| 2191 | 0, 6, // 2123: case 0x0: { |
| 2192 | OPC_CheckPredicate, 10, // 2125: check predicate 10 |
| 2193 | OPC_Decode, 195, 12, 119, // 2127: decode to DPSQ_S_W_PH_MM using decoder 119 |
| 2194 | // 2127: } |
| 2195 | 1, 6, // 2131: case 0x1: { |
| 2196 | OPC_CheckPredicate, 10, // 2133: check predicate 10 |
| 2197 | OPC_Decode, 143, 13, 121, // 2135: decode to EXTRV_W_MM using decoder 121 |
| 2198 | // 2135: } |
| 2199 | 2, 6, // 2139: case 0x2: { |
| 2200 | OPC_CheckPredicate, 10, // 2141: check predicate 10 |
| 2201 | OPC_Decode, 193, 12, 119, // 2143: decode to DPSQ_SA_L_W_MM using decoder 119 |
| 2202 | // 2143: } |
| 2203 | 3, 6, // 2147: case 0x3: { |
| 2204 | OPC_CheckPredicate, 10, // 2149: check predicate 10 |
| 2205 | OPC_Decode, 139, 13, 121, // 2151: decode to EXTRV_R_W_MM using decoder 121 |
| 2206 | // 2151: } |
| 2207 | 4, 6, // 2155: case 0x4: { |
| 2208 | OPC_CheckPredicate, 11, // 2157: check predicate 11 |
| 2209 | OPC_Decode, 191, 12, 119, // 2159: decode to DPSQX_S_W_PH_MMR2 using decoder 119 |
| 2210 | // 2159: } |
| 2211 | 5, 6, // 2163: case 0x5: { |
| 2212 | OPC_CheckPredicate, 10, // 2165: check predicate 10 |
| 2213 | OPC_Decode, 137, 13, 121, // 2167: decode to EXTRV_RS_W_MM using decoder 121 |
| 2214 | // 2167: } |
| 2215 | 6, 6, // 2171: case 0x6: { |
| 2216 | OPC_CheckPredicate, 11, // 2173: check predicate 11 |
| 2217 | OPC_Decode, 189, 12, 119, // 2175: decode to DPSQX_SA_W_PH_MMR2 using decoder 119 |
| 2218 | // 2175: } |
| 2219 | 7, 0, // 2179: case 0x7: { |
| 2220 | OPC_CheckPredicate, 10, // 2181: check predicate 10 |
| 2221 | OPC_Decode, 141, 13, 121, // 2183: decode to EXTRV_S_H_MM using decoder 121 |
| 2222 | // 2183: } |
| 2223 | // 2183: } // switch Inst[13:11] |
| 2224 | // 2183: } |
| 2225 | 27, 10, // 2187: case 0x1b: { |
| 2226 | OPC_CheckPredicate, 12, // 2189: check predicate 12 |
| 2227 | OPC_CheckField, 14, 2, 0, // 2191: check Inst[15:14] == 0x0 |
| 2228 | OPC_Decode, 194, 18, 112, // 2195: decode to MTGC0_MM using decoder 112 |
| 2229 | // 2195: } |
| 2230 | 28, 53, // 2199: case 0x1c: { |
| 2231 | OPC_SwitchField, 11, 5, // 2201: switch Inst[15:11] { |
| 2232 | 1, 19, // 2204: case 0x1: { |
| 2233 | OPC_Scope, 11, // 2206: try { |
| 2234 | OPC_CheckField, 21, 5, 0, // 2208: check Inst[25:21] == 0x0 |
| 2235 | OPC_CheckPredicate, 1, // 2212: check predicate 1 |
| 2236 | OPC_Decode, 173, 15, 136, 1, // 2214: decode to JR_MM using decoder 136 |
| 2237 | // 2214: } else try { |
| 2238 | OPC_CheckPredicate, 1, // 2219: check predicate 1 |
| 2239 | OPC_Decode, 149, 15, 123, // 2221: decode to JALR_MM using decoder 123 |
| 2240 | // 2221: } |
| 2241 | // 2221: } |
| 2242 | 3, 19, // 2225: case 0x3: { |
| 2243 | OPC_Scope, 11, // 2227: try { |
| 2244 | OPC_CheckField, 21, 5, 0, // 2229: check Inst[25:21] == 0x0 |
| 2245 | OPC_CheckPredicate, 1, // 2233: check predicate 1 |
| 2246 | OPC_Decode, 171, 15, 136, 1, // 2235: decode to JR_HB_MM using decoder 136 |
| 2247 | // 2235: } else try { |
| 2248 | OPC_CheckPredicate, 1, // 2240: check predicate 1 |
| 2249 | OPC_Decode, 148, 15, 123, // 2242: decode to JALR_HB_MM using decoder 123 |
| 2250 | // 2242: } |
| 2251 | // 2242: } |
| 2252 | 9, 0, // 2246: case 0x9: { |
| 2253 | OPC_CheckPredicate, 1, // 2248: check predicate 1 |
| 2254 | OPC_Decode, 145, 15, 123, // 2250: decode to JALRS_MM using decoder 123 |
| 2255 | // 2250: } |
| 2256 | // 2250: } // switch Inst[15:11] |
| 2257 | // 2250: } |
| 2258 | 29, 0, // 2254: case 0x1d: { |
| 2259 | OPC_SwitchField, 11, 5, // 2256: switch Inst[15:11] { |
| 2260 | 8, 11, // 2259: case 0x8: { |
| 2261 | OPC_CheckPredicate, 2, // 2261: check predicate 2 |
| 2262 | OPC_CheckField, 21, 5, 0, // 2263: check Inst[25:21] == 0x0 |
| 2263 | OPC_Decode, 134, 12, 136, 1, // 2267: decode to DI_MM using decoder 136 |
| 2264 | // 2267: } |
| 2265 | 10, 0, // 2272: case 0xa: { |
| 2266 | OPC_CheckPredicate, 2, // 2274: check predicate 2 |
| 2267 | OPC_CheckField, 21, 5, 0, // 2276: check Inst[25:21] == 0x0 |
| 2268 | OPC_Decode, 240, 12, 136, 1, // 2280: decode to EI_MM using decoder 136 |
| 2269 | // 2280: } |
| 2270 | // 2280: } // switch Inst[15:11] |
| 2271 | // 2280: } |
| 2272 | // 2280: } // switch Inst[10:6] |
| 2273 | // 2280: } |
| 2274 | 61, 0, // 2285: case 0x3d: { |
| 2275 | OPC_CheckPredicate, 10, // 2287: check predicate 10 |
| 2276 | OPC_CheckField, 6, 5, 0, // 2289: check Inst[10:6] == 0x0 |
| 2277 | OPC_Decode, 170, 20, 140, 1, // 2293: decode to REPL_PH_MM using decoder 140 |
| 2278 | // 2293: } |
| 2279 | // 2293: } // switch Inst[5:0] |
| 2280 | // 2293: } |
| 2281 | 4, 7, // 2298: case 0x4: { |
| 2282 | OPC_CheckPredicate, 1, // 2300: check predicate 1 |
| 2283 | OPC_Decode, 239, 6, 141, 1, // 2302: decode to ADDi_MM using decoder 141 |
| 2284 | // 2302: } |
| 2285 | 5, 7, // 2307: case 0x5: { |
| 2286 | OPC_CheckPredicate, 2, // 2309: check predicate 2 |
| 2287 | OPC_Decode, 207, 15, 142, 1, // 2311: decode to LBu_MM using decoder 142 |
| 2288 | // 2311: } |
| 2289 | 6, 7, // 2316: case 0x6: { |
| 2290 | OPC_CheckPredicate, 2, // 2318: check predicate 2 |
| 2291 | OPC_Decode, 227, 20, 142, 1, // 2320: decode to SB_MM using decoder 142 |
| 2292 | // 2320: } |
| 2293 | 7, 7, // 2325: case 0x7: { |
| 2294 | OPC_CheckPredicate, 2, // 2327: check predicate 2 |
| 2295 | OPC_Decode, 199, 15, 142, 1, // 2329: decode to LB_MM using decoder 142 |
| 2296 | // 2329: } |
| 2297 | 8, 48, // 2334: case 0x8: { |
| 2298 | OPC_SwitchField, 12, 4, // 2336: switch Inst[15:12] { |
| 2299 | 1, 7, // 2339: case 0x1: { |
| 2300 | OPC_CheckPredicate, 2, // 2341: check predicate 2 |
| 2301 | OPC_Decode, 189, 16, 143, 1, // 2343: decode to LWP_MM using decoder 143 |
| 2302 | // 2343: } |
| 2303 | 5, 7, // 2348: case 0x5: { |
| 2304 | OPC_CheckPredicate, 2, // 2350: check predicate 2 |
| 2305 | OPC_Decode, 184, 16, 144, 1, // 2352: decode to LWM32_MM using decoder 144 |
| 2306 | // 2352: } |
| 2307 | 6, 7, // 2357: case 0x6: { |
| 2308 | OPC_CheckPredicate, 1, // 2359: check predicate 1 |
| 2309 | OPC_Decode, 151, 9, 145, 1, // 2361: decode to CACHE_MM using decoder 145 |
| 2310 | // 2361: } |
| 2311 | 9, 7, // 2366: case 0x9: { |
| 2312 | OPC_CheckPredicate, 2, // 2368: check predicate 2 |
| 2313 | OPC_Decode, 181, 23, 143, 1, // 2370: decode to SWP_MM using decoder 143 |
| 2314 | // 2370: } |
| 2315 | 13, 0, // 2375: case 0xd: { |
| 2316 | OPC_CheckPredicate, 2, // 2377: check predicate 2 |
| 2317 | OPC_Decode, 178, 23, 144, 1, // 2379: decode to SWM32_MM using decoder 144 |
| 2318 | // 2379: } |
| 2319 | // 2379: } // switch Inst[15:12] |
| 2320 | // 2379: } |
| 2321 | 12, 7, // 2384: case 0xc: { |
| 2322 | OPC_CheckPredicate, 1, // 2386: check predicate 1 |
| 2323 | OPC_Decode, 241, 6, 141, 1, // 2388: decode to ADDiu_MM using decoder 141 |
| 2324 | // 2388: } |
| 2325 | 13, 7, // 2393: case 0xd: { |
| 2326 | OPC_CheckPredicate, 2, // 2395: check predicate 2 |
| 2327 | OPC_Decode, 130, 16, 142, 1, // 2397: decode to LHu_MM using decoder 142 |
| 2328 | // 2397: } |
| 2329 | 14, 7, // 2402: case 0xe: { |
| 2330 | OPC_CheckPredicate, 2, // 2404: check predicate 2 |
| 2331 | OPC_Decode, 229, 21, 142, 1, // 2406: decode to SH_MM using decoder 142 |
| 2332 | // 2406: } |
| 2333 | 15, 7, // 2411: case 0xf: { |
| 2334 | OPC_CheckPredicate, 2, // 2413: check predicate 2 |
| 2335 | OPC_Decode, 251, 15, 142, 1, // 2415: decode to LH_MM using decoder 142 |
| 2336 | // 2415: } |
| 2337 | 16, 217, 1, // 2420: case 0x10: { |
| 2338 | OPC_SwitchField, 21, 5, // 2423: switch Inst[25:21] { |
| 2339 | 0, 7, // 2426: case 0x0: { |
| 2340 | OPC_CheckPredicate, 1, // 2428: check predicate 1 |
| 2341 | OPC_Decode, 198, 8, 146, 1, // 2430: decode to BLTZ_MM using decoder 146 |
| 2342 | // 2430: } |
| 2343 | 1, 7, // 2435: case 0x1: { |
| 2344 | OPC_CheckPredicate, 1, // 2437: check predicate 1 |
| 2345 | OPC_Decode, 193, 8, 146, 1, // 2439: decode to BLTZAL_MM using decoder 146 |
| 2346 | // 2439: } |
| 2347 | 2, 7, // 2444: case 0x2: { |
| 2348 | OPC_CheckPredicate, 1, // 2446: check predicate 1 |
| 2349 | OPC_Decode, 136, 8, 146, 1, // 2448: decode to BGEZ_MM using decoder 146 |
| 2350 | // 2448: } |
| 2351 | 3, 7, // 2453: case 0x3: { |
| 2352 | OPC_CheckPredicate, 1, // 2455: check predicate 1 |
| 2353 | OPC_Decode, 131, 8, 146, 1, // 2457: decode to BGEZAL_MM using decoder 146 |
| 2354 | // 2457: } |
| 2355 | 4, 7, // 2462: case 0x4: { |
| 2356 | OPC_CheckPredicate, 1, // 2464: check predicate 1 |
| 2357 | OPC_Decode, 175, 8, 146, 1, // 2466: decode to BLEZ_MM using decoder 146 |
| 2358 | // 2466: } |
| 2359 | 5, 7, // 2471: case 0x5: { |
| 2360 | OPC_CheckPredicate, 1, // 2473: check predicate 1 |
| 2361 | OPC_Decode, 226, 8, 146, 1, // 2475: decode to BNEZC_MM using decoder 146 |
| 2362 | // 2475: } |
| 2363 | 6, 7, // 2480: case 0x6: { |
| 2364 | OPC_CheckPredicate, 1, // 2482: check predicate 1 |
| 2365 | OPC_Decode, 145, 8, 146, 1, // 2484: decode to BGTZ_MM using decoder 146 |
| 2366 | // 2484: } |
| 2367 | 7, 7, // 2489: case 0x7: { |
| 2368 | OPC_CheckPredicate, 1, // 2491: check predicate 1 |
| 2369 | OPC_Decode, 239, 7, 146, 1, // 2493: decode to BEQZC_MM using decoder 146 |
| 2370 | // 2493: } |
| 2371 | 8, 7, // 2498: case 0x8: { |
| 2372 | OPC_CheckPredicate, 1, // 2500: check predicate 1 |
| 2373 | OPC_Decode, 144, 24, 147, 1, // 2502: decode to TLTI_MM using decoder 147 |
| 2374 | // 2502: } |
| 2375 | 9, 7, // 2507: case 0x9: { |
| 2376 | OPC_CheckPredicate, 1, // 2509: check predicate 1 |
| 2377 | OPC_Decode, 241, 23, 147, 1, // 2511: decode to TGEI_MM using decoder 147 |
| 2378 | // 2511: } |
| 2379 | 10, 7, // 2516: case 0xa: { |
| 2380 | OPC_CheckPredicate, 1, // 2518: check predicate 1 |
| 2381 | OPC_Decode, 143, 24, 147, 1, // 2520: decode to TLTIU_MM using decoder 147 |
| 2382 | // 2520: } |
| 2383 | 11, 7, // 2525: case 0xb: { |
| 2384 | OPC_CheckPredicate, 1, // 2527: check predicate 1 |
| 2385 | OPC_Decode, 240, 23, 147, 1, // 2529: decode to TGEIU_MM using decoder 147 |
| 2386 | // 2529: } |
| 2387 | 12, 7, // 2534: case 0xc: { |
| 2388 | OPC_CheckPredicate, 1, // 2536: check predicate 1 |
| 2389 | OPC_Decode, 150, 24, 147, 1, // 2538: decode to TNEI_MM using decoder 147 |
| 2390 | // 2538: } |
| 2391 | 13, 7, // 2543: case 0xd: { |
| 2392 | OPC_CheckPredicate, 1, // 2545: check predicate 1 |
| 2393 | OPC_Decode, 158, 16, 148, 1, // 2547: decode to LUi_MM using decoder 148 |
| 2394 | // 2547: } |
| 2395 | 14, 7, // 2552: case 0xe: { |
| 2396 | OPC_CheckPredicate, 1, // 2554: check predicate 1 |
| 2397 | OPC_Decode, 234, 23, 147, 1, // 2556: decode to TEQI_MM using decoder 147 |
| 2398 | // 2556: } |
| 2399 | 16, 7, // 2561: case 0x10: { |
| 2400 | OPC_CheckPredicate, 1, // 2563: check predicate 1 |
| 2401 | OPC_Decode, 200, 23, 149, 1, // 2565: decode to SYNCI_MM using decoder 149 |
| 2402 | // 2565: } |
| 2403 | 17, 7, // 2570: case 0x11: { |
| 2404 | OPC_CheckPredicate, 1, // 2572: check predicate 1 |
| 2405 | OPC_Decode, 192, 8, 146, 1, // 2574: decode to BLTZALS_MM using decoder 146 |
| 2406 | // 2574: } |
| 2407 | 19, 7, // 2579: case 0x13: { |
| 2408 | OPC_CheckPredicate, 1, // 2581: check predicate 1 |
| 2409 | OPC_Decode, 130, 8, 146, 1, // 2583: decode to BGEZALS_MM using decoder 146 |
| 2410 | // 2583: } |
| 2411 | 25, 11, // 2588: case 0x19: { |
| 2412 | OPC_CheckPredicate, 13, // 2590: check predicate 13 |
| 2413 | OPC_CheckField, 16, 5, 0, // 2592: check Inst[20:16] == 0x0 |
| 2414 | OPC_Decode, 239, 8, 150, 1, // 2596: decode to BPOSGE32C_MMR3 using decoder 150 |
| 2415 | // 2596: } |
| 2416 | 27, 11, // 2601: case 0x1b: { |
| 2417 | OPC_CheckPredicate, 14, // 2603: check predicate 14 |
| 2418 | OPC_CheckField, 16, 5, 0, // 2605: check Inst[20:16] == 0x0 |
| 2419 | OPC_Decode, 240, 8, 151, 1, // 2609: decode to BPOSGE32_MM using decoder 151 |
| 2420 | // 2609: } |
| 2421 | 28, 11, // 2614: case 0x1c: { |
| 2422 | OPC_CheckPredicate, 15, // 2616: check predicate 15 |
| 2423 | OPC_CheckField, 16, 2, 0, // 2618: check Inst[17:16] == 0x0 |
| 2424 | OPC_Decode, 204, 7, 152, 1, // 2622: decode to BC1F_MM using decoder 152 |
| 2425 | // 2622: } |
| 2426 | 29, 0, // 2627: case 0x1d: { |
| 2427 | OPC_CheckPredicate, 15, // 2629: check predicate 15 |
| 2428 | OPC_CheckField, 16, 2, 0, // 2631: check Inst[17:16] == 0x0 |
| 2429 | OPC_Decode, 209, 7, 152, 1, // 2635: decode to BC1T_MM using decoder 152 |
| 2430 | // 2635: } |
| 2431 | // 2635: } // switch Inst[25:21] |
| 2432 | // 2635: } |
| 2433 | 20, 7, // 2640: case 0x14: { |
| 2434 | OPC_CheckPredicate, 1, // 2642: check predicate 1 |
| 2435 | OPC_Decode, 202, 19, 153, 1, // 2644: decode to ORi_MM using decoder 153 |
| 2436 | // 2644: } |
| 2437 | 21, 177, 7, // 2649: case 0x15: { |
| 2438 | OPC_SwitchField, 0, 6, // 2652: switch Inst[5:0] { |
| 2439 | 1, 7, // 2655: case 0x1: { |
| 2440 | OPC_CheckPredicate, 16, // 2657: check predicate 16 |
| 2441 | OPC_Decode, 247, 16, 154, 1, // 2659: decode to MADD_S_MM using decoder 154 |
| 2442 | // 2659: } |
| 2443 | 2, 7, // 2664: case 0x2: { |
| 2444 | OPC_CheckPredicate, 16, // 2666: check predicate 16 |
| 2445 | OPC_Decode, 168, 19, 154, 1, // 2668: decode to NMADD_S_MM using decoder 154 |
| 2446 | // 2668: } |
| 2447 | 8, 39, // 2673: case 0x8: { |
| 2448 | OPC_SwitchField, 6, 5, // 2675: switch Inst[10:6] { |
| 2449 | 1, 7, // 2678: case 0x1: { |
| 2450 | OPC_CheckPredicate, 15, // 2680: check predicate 15 |
| 2451 | OPC_Decode, 201, 16, 155, 1, // 2682: decode to LWXC1_MM using decoder 155 |
| 2452 | // 2682: } |
| 2453 | 2, 7, // 2687: case 0x2: { |
| 2454 | OPC_CheckPredicate, 15, // 2689: check predicate 15 |
| 2455 | OPC_Decode, 191, 23, 155, 1, // 2691: decode to SWXC1_MM using decoder 155 |
| 2456 | // 2691: } |
| 2457 | 5, 7, // 2696: case 0x5: { |
| 2458 | OPC_CheckPredicate, 17, // 2698: check predicate 17 |
| 2459 | OPC_Decode, 155, 16, 156, 1, // 2700: decode to LUXC1_MM using decoder 156 |
| 2460 | // 2700: } |
| 2461 | 6, 0, // 2705: case 0x6: { |
| 2462 | OPC_CheckPredicate, 17, // 2707: check predicate 17 |
| 2463 | OPC_Decode, 152, 23, 156, 1, // 2709: decode to SUXC1_MM using decoder 156 |
| 2464 | // 2709: } |
| 2465 | // 2709: } // switch Inst[10:6] |
| 2466 | // 2709: } |
| 2467 | 9, 7, // 2714: case 0x9: { |
| 2468 | OPC_CheckPredicate, 18, // 2716: check predicate 18 |
| 2469 | OPC_Decode, 239, 16, 157, 1, // 2718: decode to MADD_D32_MM using decoder 157 |
| 2470 | // 2718: } |
| 2471 | 10, 7, // 2723: case 0xa: { |
| 2472 | OPC_CheckPredicate, 18, // 2725: check predicate 18 |
| 2473 | OPC_Decode, 165, 19, 157, 1, // 2727: decode to NMADD_D32_MM using decoder 157 |
| 2474 | // 2727: } |
| 2475 | 32, 64, // 2732: case 0x20: { |
| 2476 | OPC_SwitchField, 6, 5, // 2734: switch Inst[10:6] { |
| 2477 | 0, 11, // 2737: case 0x0: { |
| 2478 | OPC_CheckPredicate, 15, // 2739: check predicate 15 |
| 2479 | OPC_CheckField, 11, 2, 0, // 2741: check Inst[12:11] == 0x0 |
| 2480 | OPC_Decode, 250, 17, 158, 1, // 2745: decode to MOVF_S_MM using decoder 158 |
| 2481 | // 2745: } |
| 2482 | 1, 11, // 2750: case 0x1: { |
| 2483 | OPC_CheckPredicate, 15, // 2752: check predicate 15 |
| 2484 | OPC_CheckField, 11, 2, 0, // 2754: check Inst[12:11] == 0x0 |
| 2485 | OPC_Decode, 143, 18, 158, 1, // 2758: decode to MOVT_S_MM using decoder 158 |
| 2486 | // 2758: } |
| 2487 | 6, 7, // 2763: case 0x6: { |
| 2488 | OPC_CheckPredicate, 1, // 2765: check predicate 1 |
| 2489 | OPC_Decode, 138, 20, 159, 1, // 2767: decode to PREFX_MM using decoder 159 |
| 2490 | // 2767: } |
| 2491 | 8, 11, // 2772: case 0x8: { |
| 2492 | OPC_CheckPredicate, 19, // 2774: check predicate 19 |
| 2493 | OPC_CheckField, 11, 2, 0, // 2776: check Inst[12:11] == 0x0 |
| 2494 | OPC_Decode, 244, 17, 160, 1, // 2780: decode to MOVF_D32_MM using decoder 160 |
| 2495 | // 2780: } |
| 2496 | 9, 0, // 2785: case 0x9: { |
| 2497 | OPC_CheckPredicate, 19, // 2787: check predicate 19 |
| 2498 | OPC_CheckField, 11, 2, 0, // 2789: check Inst[12:11] == 0x0 |
| 2499 | OPC_Decode, 137, 18, 160, 1, // 2793: decode to MOVT_D32_MM using decoder 160 |
| 2500 | // 2793: } |
| 2501 | // 2793: } // switch Inst[10:6] |
| 2502 | // 2793: } |
| 2503 | 33, 7, // 2798: case 0x21: { |
| 2504 | OPC_CheckPredicate, 16, // 2800: check predicate 16 |
| 2505 | OPC_Decode, 181, 18, 154, 1, // 2802: decode to MSUB_S_MM using decoder 154 |
| 2506 | // 2802: } |
| 2507 | 34, 7, // 2807: case 0x22: { |
| 2508 | OPC_CheckPredicate, 16, // 2809: check predicate 16 |
| 2509 | OPC_Decode, 173, 19, 154, 1, // 2811: decode to NMSUB_S_MM using decoder 154 |
| 2510 | // 2811: } |
| 2511 | 41, 7, // 2816: case 0x29: { |
| 2512 | OPC_CheckPredicate, 18, // 2818: check predicate 18 |
| 2513 | OPC_Decode, 173, 18, 157, 1, // 2820: decode to MSUB_D32_MM using decoder 157 |
| 2514 | // 2820: } |
| 2515 | 42, 7, // 2825: case 0x2a: { |
| 2516 | OPC_CheckPredicate, 18, // 2827: check predicate 18 |
| 2517 | OPC_Decode, 170, 19, 157, 1, // 2829: decode to NMSUB_D32_MM using decoder 157 |
| 2518 | // 2829: } |
| 2519 | 48, 39, // 2834: case 0x30: { |
| 2520 | OPC_SwitchField, 6, 5, // 2836: switch Inst[10:6] { |
| 2521 | 4, 7, // 2839: case 0x4: { |
| 2522 | OPC_CheckPredicate, 20, // 2841: check predicate 20 |
| 2523 | OPC_Decode, 166, 13, 161, 1, // 2843: decode to FADD_D32_MM using decoder 161 |
| 2524 | // 2843: } |
| 2525 | 5, 7, // 2848: case 0x5: { |
| 2526 | OPC_CheckPredicate, 20, // 2850: check predicate 20 |
| 2527 | OPC_Decode, 183, 14, 161, 1, // 2852: decode to FSUB_D32_MM using decoder 161 |
| 2528 | // 2852: } |
| 2529 | 6, 7, // 2857: case 0x6: { |
| 2530 | OPC_CheckPredicate, 20, // 2859: check predicate 20 |
| 2531 | OPC_Decode, 139, 14, 161, 1, // 2861: decode to FMUL_D32_MM using decoder 161 |
| 2532 | // 2861: } |
| 2533 | 7, 0, // 2866: case 0x7: { |
| 2534 | OPC_CheckPredicate, 20, // 2868: check predicate 20 |
| 2535 | OPC_Decode, 205, 13, 161, 1, // 2870: decode to FDIV_D32_MM using decoder 161 |
| 2536 | // 2870: } |
| 2537 | // 2870: } // switch Inst[10:6] |
| 2538 | // 2870: } |
| 2539 | 56, 39, // 2875: case 0x38: { |
| 2540 | OPC_SwitchField, 6, 4, // 2877: switch Inst[9:6] { |
| 2541 | 0, 7, // 2880: case 0x0: { |
| 2542 | OPC_CheckPredicate, 15, // 2882: check predicate 15 |
| 2543 | OPC_Decode, 134, 18, 162, 1, // 2884: decode to MOVN_I_S_MM using decoder 162 |
| 2544 | // 2884: } |
| 2545 | 1, 7, // 2889: case 0x1: { |
| 2546 | OPC_CheckPredicate, 15, // 2891: check predicate 15 |
| 2547 | OPC_Decode, 155, 18, 162, 1, // 2893: decode to MOVZ_I_S_MM using decoder 162 |
| 2548 | // 2893: } |
| 2549 | 4, 7, // 2898: case 0x4: { |
| 2550 | OPC_CheckPredicate, 19, // 2900: check predicate 19 |
| 2551 | OPC_Decode, 128, 18, 163, 1, // 2902: decode to MOVN_I_D32_MM using decoder 163 |
| 2552 | // 2902: } |
| 2553 | 5, 0, // 2907: case 0x5: { |
| 2554 | OPC_CheckPredicate, 19, // 2909: check predicate 19 |
| 2555 | OPC_Decode, 149, 18, 163, 1, // 2911: decode to MOVZ_I_D32_MM using decoder 163 |
| 2556 | // 2911: } |
| 2557 | // 2911: } // switch Inst[9:6] |
| 2558 | // 2911: } |
| 2559 | 59, 129, 3, // 2916: case 0x3b: { |
| 2560 | OPC_SwitchField, 6, 7, // 2919: switch Inst[12:6] { |
| 2561 | 0, 11, // 2922: case 0x0: { |
| 2562 | OPC_CheckPredicate, 21, // 2924: check predicate 21 |
| 2563 | OPC_CheckField, 13, 3, 1, // 2926: check Inst[15:13] == 0x1 |
| 2564 | OPC_Decode, 162, 17, 164, 1, // 2930: decode to MFC1_MM using decoder 164 |
| 2565 | // 2930: } |
| 2566 | 1, 11, // 2935: case 0x1: { |
| 2567 | OPC_CheckPredicate, 20, // 2937: check predicate 20 |
| 2568 | OPC_CheckField, 13, 3, 1, // 2939: check Inst[15:13] == 0x1 |
| 2569 | OPC_Decode, 128, 14, 165, 1, // 2943: decode to FMOV_D32_MM using decoder 165 |
| 2570 | // 2943: } |
| 2571 | 4, 21, // 2948: case 0x4: { |
| 2572 | OPC_SwitchField, 13, 3, // 2950: switch Inst[15:13] { |
| 2573 | 0, 7, // 2953: case 0x0: { |
| 2574 | OPC_CheckPredicate, 22, // 2955: check predicate 22 |
| 2575 | OPC_Decode, 227, 10, 166, 1, // 2957: decode to CVT_L_S_MM using decoder 166 |
| 2576 | // 2957: } |
| 2577 | 2, 0, // 2962: case 0x2: { |
| 2578 | OPC_CheckPredicate, 22, // 2964: check predicate 22 |
| 2579 | OPC_Decode, 224, 10, 167, 1, // 2966: decode to CVT_L_D64_MM using decoder 167 |
| 2580 | // 2966: } |
| 2581 | // 2966: } // switch Inst[15:13] |
| 2582 | // 2966: } |
| 2583 | 5, 7, // 2971: case 0x5: { |
| 2584 | OPC_CheckPredicate, 15, // 2973: check predicate 15 |
| 2585 | OPC_Decode, 248, 17, 168, 1, // 2975: decode to MOVF_I_MM using decoder 168 |
| 2586 | // 2975: } |
| 2587 | 8, 21, // 2980: case 0x8: { |
| 2588 | OPC_SwitchField, 13, 3, // 2982: switch Inst[15:13] { |
| 2589 | 0, 7, // 2985: case 0x0: { |
| 2590 | OPC_CheckPredicate, 21, // 2987: check predicate 21 |
| 2591 | OPC_Decode, 203, 20, 169, 1, // 2989: decode to RSQRT_S_MM using decoder 169 |
| 2592 | // 2989: } |
| 2593 | 2, 0, // 2994: case 0x2: { |
| 2594 | OPC_CheckPredicate, 20, // 2996: check predicate 20 |
| 2595 | OPC_Decode, 199, 20, 165, 1, // 2998: decode to RSQRT_D32_MM using decoder 165 |
| 2596 | // 2998: } |
| 2597 | // 2998: } // switch Inst[15:13] |
| 2598 | // 2998: } |
| 2599 | 13, 21, // 3003: case 0xd: { |
| 2600 | OPC_SwitchField, 13, 3, // 3005: switch Inst[15:13] { |
| 2601 | 0, 7, // 3008: case 0x0: { |
| 2602 | OPC_CheckPredicate, 21, // 3010: check predicate 21 |
| 2603 | OPC_Decode, 163, 13, 169, 1, // 3012: decode to FABS_S_MM using decoder 169 |
| 2604 | // 3012: } |
| 2605 | 1, 0, // 3017: case 0x1: { |
| 2606 | OPC_CheckPredicate, 20, // 3019: check predicate 20 |
| 2607 | OPC_Decode, 159, 13, 165, 1, // 3021: decode to FABS_D32_MM using decoder 165 |
| 2608 | // 3021: } |
| 2609 | // 3021: } // switch Inst[15:13] |
| 2610 | // 3021: } |
| 2611 | 32, 11, // 3026: case 0x20: { |
| 2612 | OPC_CheckPredicate, 21, // 3028: check predicate 21 |
| 2613 | OPC_CheckField, 13, 3, 1, // 3030: check Inst[15:13] == 0x1 |
| 2614 | OPC_Decode, 189, 18, 170, 1, // 3034: decode to MTC1_MM using decoder 170 |
| 2615 | // 3034: } |
| 2616 | 36, 21, // 3039: case 0x24: { |
| 2617 | OPC_SwitchField, 13, 3, // 3041: switch Inst[15:13] { |
| 2618 | 0, 7, // 3044: case 0x0: { |
| 2619 | OPC_CheckPredicate, 21, // 3046: check predicate 21 |
| 2620 | OPC_Decode, 248, 10, 169, 1, // 3048: decode to CVT_W_S_MM using decoder 169 |
| 2621 | // 3048: } |
| 2622 | 2, 0, // 3053: case 0x2: { |
| 2623 | OPC_CheckPredicate, 20, // 3055: check predicate 20 |
| 2624 | OPC_Decode, 244, 10, 171, 1, // 3057: decode to CVT_W_D32_MM using decoder 171 |
| 2625 | // 3057: } |
| 2626 | // 3057: } // switch Inst[15:13] |
| 2627 | // 3057: } |
| 2628 | 37, 7, // 3062: case 0x25: { |
| 2629 | OPC_CheckPredicate, 15, // 3064: check predicate 15 |
| 2630 | OPC_Decode, 141, 18, 168, 1, // 3066: decode to MOVT_I_MM using decoder 168 |
| 2631 | // 3066: } |
| 2632 | 40, 21, // 3071: case 0x28: { |
| 2633 | OPC_SwitchField, 13, 3, // 3073: switch Inst[15:13] { |
| 2634 | 0, 7, // 3076: case 0x0: { |
| 2635 | OPC_CheckPredicate, 21, // 3078: check predicate 21 |
| 2636 | OPC_Decode, 179, 14, 169, 1, // 3080: decode to FSQRT_S_MM using decoder 169 |
| 2637 | // 3080: } |
| 2638 | 2, 0, // 3085: case 0x2: { |
| 2639 | OPC_CheckPredicate, 20, // 3087: check predicate 20 |
| 2640 | OPC_Decode, 175, 14, 165, 1, // 3089: decode to FSQRT_D32_MM using decoder 165 |
| 2641 | // 3089: } |
| 2642 | // 3089: } // switch Inst[15:13] |
| 2643 | // 3089: } |
| 2644 | 44, 39, // 3094: case 0x2c: { |
| 2645 | OPC_SwitchField, 13, 3, // 3096: switch Inst[15:13] { |
| 2646 | 0, 7, // 3099: case 0x0: { |
| 2647 | OPC_CheckPredicate, 21, // 3101: check predicate 21 |
| 2648 | OPC_Decode, 243, 13, 169, 1, // 3103: decode to FLOOR_W_S_MM using decoder 169 |
| 2649 | // 3103: } |
| 2650 | 1, 7, // 3108: case 0x1: { |
| 2651 | OPC_CheckPredicate, 21, // 3110: check predicate 21 |
| 2652 | OPC_Decode, 162, 24, 169, 1, // 3112: decode to TRUNC_W_S_MM using decoder 169 |
| 2653 | // 3112: } |
| 2654 | 2, 7, // 3117: case 0x2: { |
| 2655 | OPC_CheckPredicate, 20, // 3119: check predicate 20 |
| 2656 | OPC_Decode, 241, 13, 171, 1, // 3121: decode to FLOOR_W_MM using decoder 171 |
| 2657 | // 3121: } |
| 2658 | 3, 0, // 3126: case 0x3: { |
| 2659 | OPC_CheckPredicate, 20, // 3128: check predicate 20 |
| 2660 | OPC_Decode, 160, 24, 171, 1, // 3130: decode to TRUNC_W_MM using decoder 171 |
| 2661 | // 3130: } |
| 2662 | // 3130: } // switch Inst[15:13] |
| 2663 | // 3130: } |
| 2664 | 45, 11, // 3135: case 0x2d: { |
| 2665 | OPC_CheckPredicate, 20, // 3137: check predicate 20 |
| 2666 | OPC_CheckField, 13, 3, 1, // 3139: check Inst[15:13] == 0x1 |
| 2667 | OPC_Decode, 148, 14, 165, 1, // 3143: decode to FNEG_D32_MM using decoder 165 |
| 2668 | // 3143: } |
| 2669 | 64, 21, // 3148: case 0x40: { |
| 2670 | OPC_SwitchField, 13, 3, // 3150: switch Inst[15:13] { |
| 2671 | 0, 7, // 3153: case 0x0: { |
| 2672 | OPC_CheckPredicate, 21, // 3155: check predicate 21 |
| 2673 | OPC_Decode, 175, 9, 172, 1, // 3157: decode to CFC1_MM using decoder 172 |
| 2674 | // 3157: } |
| 2675 | 1, 0, // 3162: case 0x1: { |
| 2676 | OPC_CheckPredicate, 20, // 3164: check predicate 20 |
| 2677 | OPC_Decode, 171, 17, 173, 1, // 3166: decode to MFHC1_D32_MM using decoder 173 |
| 2678 | // 3166: } |
| 2679 | // 3166: } // switch Inst[15:13] |
| 2680 | // 3166: } |
| 2681 | 72, 21, // 3171: case 0x48: { |
| 2682 | OPC_SwitchField, 13, 3, // 3173: switch Inst[15:13] { |
| 2683 | 0, 7, // 3176: case 0x0: { |
| 2684 | OPC_CheckPredicate, 21, // 3178: check predicate 21 |
| 2685 | OPC_Decode, 164, 20, 169, 1, // 3180: decode to RECIP_S_MM using decoder 169 |
| 2686 | // 3180: } |
| 2687 | 2, 0, // 3185: case 0x2: { |
| 2688 | OPC_CheckPredicate, 20, // 3187: check predicate 20 |
| 2689 | OPC_Decode, 160, 20, 165, 1, // 3189: decode to RECIP_D32_MM using decoder 165 |
| 2690 | // 3189: } |
| 2691 | // 3189: } // switch Inst[15:13] |
| 2692 | // 3189: } |
| 2693 | 77, 21, // 3194: case 0x4d: { |
| 2694 | OPC_SwitchField, 13, 3, // 3196: switch Inst[15:13] { |
| 2695 | 0, 7, // 3199: case 0x0: { |
| 2696 | OPC_CheckPredicate, 20, // 3201: check predicate 20 |
| 2697 | OPC_Decode, 214, 10, 174, 1, // 3203: decode to CVT_D32_S_MM using decoder 174 |
| 2698 | // 3203: } |
| 2699 | 1, 0, // 3208: case 0x1: { |
| 2700 | OPC_CheckPredicate, 20, // 3210: check predicate 20 |
| 2701 | OPC_Decode, 216, 10, 174, 1, // 3212: decode to CVT_D32_W_MM using decoder 174 |
| 2702 | // 3212: } |
| 2703 | // 3212: } // switch Inst[15:13] |
| 2704 | // 3212: } |
| 2705 | 96, 21, // 3217: case 0x60: { |
| 2706 | OPC_SwitchField, 13, 3, // 3219: switch Inst[15:13] { |
| 2707 | 0, 7, // 3222: case 0x0: { |
| 2708 | OPC_CheckPredicate, 21, // 3224: check predicate 21 |
| 2709 | OPC_Decode, 210, 10, 175, 1, // 3226: decode to CTC1_MM using decoder 175 |
| 2710 | // 3226: } |
| 2711 | 1, 0, // 3231: case 0x1: { |
| 2712 | OPC_CheckPredicate, 20, // 3233: check predicate 20 |
| 2713 | OPC_Decode, 198, 18, 176, 1, // 3235: decode to MTHC1_D32_MM using decoder 176 |
| 2714 | // 3235: } |
| 2715 | // 3235: } // switch Inst[15:13] |
| 2716 | // 3235: } |
| 2717 | 108, 39, // 3240: case 0x6c: { |
| 2718 | OPC_SwitchField, 13, 3, // 3242: switch Inst[15:13] { |
| 2719 | 0, 7, // 3245: case 0x0: { |
| 2720 | OPC_CheckPredicate, 21, // 3247: check predicate 21 |
| 2721 | OPC_Decode, 164, 9, 169, 1, // 3249: decode to CEIL_W_S_MM using decoder 169 |
| 2722 | // 3249: } |
| 2723 | 1, 7, // 3254: case 0x1: { |
| 2724 | OPC_CheckPredicate, 21, // 3256: check predicate 21 |
| 2725 | OPC_Decode, 196, 20, 169, 1, // 3258: decode to ROUND_W_S_MM using decoder 169 |
| 2726 | // 3258: } |
| 2727 | 2, 7, // 3263: case 0x2: { |
| 2728 | OPC_CheckPredicate, 20, // 3265: check predicate 20 |
| 2729 | OPC_Decode, 162, 9, 171, 1, // 3267: decode to CEIL_W_MM using decoder 171 |
| 2730 | // 3267: } |
| 2731 | 3, 0, // 3272: case 0x3: { |
| 2732 | OPC_CheckPredicate, 20, // 3274: check predicate 20 |
| 2733 | OPC_Decode, 194, 20, 171, 1, // 3276: decode to ROUND_W_MM using decoder 171 |
| 2734 | // 3276: } |
| 2735 | // 3276: } // switch Inst[15:13] |
| 2736 | // 3276: } |
| 2737 | 109, 0, // 3281: case 0x6d: { |
| 2738 | OPC_SwitchField, 13, 3, // 3283: switch Inst[15:13] { |
| 2739 | 0, 7, // 3286: case 0x0: { |
| 2740 | OPC_CheckPredicate, 20, // 3288: check predicate 20 |
| 2741 | OPC_Decode, 233, 10, 171, 1, // 3290: decode to CVT_S_D32_MM using decoder 171 |
| 2742 | // 3290: } |
| 2743 | 1, 0, // 3295: case 0x1: { |
| 2744 | OPC_CheckPredicate, 21, // 3297: check predicate 21 |
| 2745 | OPC_Decode, 241, 10, 169, 1, // 3299: decode to CVT_S_W_MM using decoder 169 |
| 2746 | // 3299: } |
| 2747 | // 3299: } // switch Inst[15:13] |
| 2748 | // 3299: } |
| 2749 | // 3299: } // switch Inst[12:6] |
| 2750 | // 3299: } |
| 2751 | 60, 0, // 3304: case 0x3c: { |
| 2752 | OPC_SwitchField, 6, 7, // 3306: switch Inst[12:6] { |
| 2753 | 0, 7, // 3309: case 0x0: { |
| 2754 | OPC_CheckPredicate, 15, // 3311: check predicate 15 |
| 2755 | OPC_Decode, 133, 11, 177, 1, // 3313: decode to C_F_S_MM using decoder 177 |
| 2756 | // 3313: } |
| 2757 | 1, 7, // 3318: case 0x1: { |
| 2758 | OPC_CheckPredicate, 15, // 3320: check predicate 15 |
| 2759 | OPC_Decode, 217, 11, 177, 1, // 3322: decode to C_UN_S_MM using decoder 177 |
| 2760 | // 3322: } |
| 2761 | 2, 7, // 3327: case 0x2: { |
| 2762 | OPC_CheckPredicate, 15, // 3329: check predicate 15 |
| 2763 | OPC_Decode, 255, 10, 177, 1, // 3331: decode to C_EQ_S_MM using decoder 177 |
| 2764 | // 3331: } |
| 2765 | 3, 7, // 3336: case 0x3: { |
| 2766 | OPC_CheckPredicate, 15, // 3338: check predicate 15 |
| 2767 | OPC_Decode, 199, 11, 177, 1, // 3340: decode to C_UEQ_S_MM using decoder 177 |
| 2768 | // 3340: } |
| 2769 | 4, 7, // 3345: case 0x4: { |
| 2770 | OPC_CheckPredicate, 15, // 3347: check predicate 15 |
| 2771 | OPC_Decode, 181, 11, 177, 1, // 3349: decode to C_OLT_S_MM using decoder 177 |
| 2772 | // 3349: } |
| 2773 | 5, 7, // 3354: case 0x5: { |
| 2774 | OPC_CheckPredicate, 15, // 3356: check predicate 15 |
| 2775 | OPC_Decode, 211, 11, 177, 1, // 3358: decode to C_ULT_S_MM using decoder 177 |
| 2776 | // 3358: } |
| 2777 | 6, 7, // 3363: case 0x6: { |
| 2778 | OPC_CheckPredicate, 15, // 3365: check predicate 15 |
| 2779 | OPC_Decode, 175, 11, 177, 1, // 3367: decode to C_OLE_S_MM using decoder 177 |
| 2780 | // 3367: } |
| 2781 | 7, 7, // 3372: case 0x7: { |
| 2782 | OPC_CheckPredicate, 15, // 3374: check predicate 15 |
| 2783 | OPC_Decode, 205, 11, 177, 1, // 3376: decode to C_ULE_S_MM using decoder 177 |
| 2784 | // 3376: } |
| 2785 | 8, 7, // 3381: case 0x8: { |
| 2786 | OPC_CheckPredicate, 15, // 3383: check predicate 15 |
| 2787 | OPC_Decode, 193, 11, 177, 1, // 3385: decode to C_SF_S_MM using decoder 177 |
| 2788 | // 3385: } |
| 2789 | 9, 7, // 3390: case 0x9: { |
| 2790 | OPC_CheckPredicate, 15, // 3392: check predicate 15 |
| 2791 | OPC_Decode, 157, 11, 177, 1, // 3394: decode to C_NGLE_S_MM using decoder 177 |
| 2792 | // 3394: } |
| 2793 | 10, 7, // 3399: case 0xa: { |
| 2794 | OPC_CheckPredicate, 15, // 3401: check predicate 15 |
| 2795 | OPC_Decode, 187, 11, 177, 1, // 3403: decode to C_SEQ_S_MM using decoder 177 |
| 2796 | // 3403: } |
| 2797 | 11, 7, // 3408: case 0xb: { |
| 2798 | OPC_CheckPredicate, 15, // 3410: check predicate 15 |
| 2799 | OPC_Decode, 163, 11, 177, 1, // 3412: decode to C_NGL_S_MM using decoder 177 |
| 2800 | // 3412: } |
| 2801 | 12, 7, // 3417: case 0xc: { |
| 2802 | OPC_CheckPredicate, 15, // 3419: check predicate 15 |
| 2803 | OPC_Decode, 145, 11, 177, 1, // 3421: decode to C_LT_S_MM using decoder 177 |
| 2804 | // 3421: } |
| 2805 | 13, 7, // 3426: case 0xd: { |
| 2806 | OPC_CheckPredicate, 15, // 3428: check predicate 15 |
| 2807 | OPC_Decode, 151, 11, 177, 1, // 3430: decode to C_NGE_S_MM using decoder 177 |
| 2808 | // 3430: } |
| 2809 | 14, 7, // 3435: case 0xe: { |
| 2810 | OPC_CheckPredicate, 15, // 3437: check predicate 15 |
| 2811 | OPC_Decode, 139, 11, 177, 1, // 3439: decode to C_LE_S_MM using decoder 177 |
| 2812 | // 3439: } |
| 2813 | 15, 7, // 3444: case 0xf: { |
| 2814 | OPC_CheckPredicate, 15, // 3446: check predicate 15 |
| 2815 | OPC_Decode, 169, 11, 177, 1, // 3448: decode to C_NGT_S_MM using decoder 177 |
| 2816 | // 3448: } |
| 2817 | 16, 7, // 3453: case 0x10: { |
| 2818 | OPC_CheckPredicate, 19, // 3455: check predicate 19 |
| 2819 | OPC_Decode, 129, 11, 178, 1, // 3457: decode to C_F_D32_MM using decoder 178 |
| 2820 | // 3457: } |
| 2821 | 17, 7, // 3462: case 0x11: { |
| 2822 | OPC_CheckPredicate, 19, // 3464: check predicate 19 |
| 2823 | OPC_Decode, 213, 11, 178, 1, // 3466: decode to C_UN_D32_MM using decoder 178 |
| 2824 | // 3466: } |
| 2825 | 18, 7, // 3471: case 0x12: { |
| 2826 | OPC_CheckPredicate, 19, // 3473: check predicate 19 |
| 2827 | OPC_Decode, 251, 10, 178, 1, // 3475: decode to C_EQ_D32_MM using decoder 178 |
| 2828 | // 3475: } |
| 2829 | 19, 7, // 3480: case 0x13: { |
| 2830 | OPC_CheckPredicate, 19, // 3482: check predicate 19 |
| 2831 | OPC_Decode, 195, 11, 178, 1, // 3484: decode to C_UEQ_D32_MM using decoder 178 |
| 2832 | // 3484: } |
| 2833 | 20, 7, // 3489: case 0x14: { |
| 2834 | OPC_CheckPredicate, 19, // 3491: check predicate 19 |
| 2835 | OPC_Decode, 177, 11, 178, 1, // 3493: decode to C_OLT_D32_MM using decoder 178 |
| 2836 | // 3493: } |
| 2837 | 21, 7, // 3498: case 0x15: { |
| 2838 | OPC_CheckPredicate, 19, // 3500: check predicate 19 |
| 2839 | OPC_Decode, 207, 11, 178, 1, // 3502: decode to C_ULT_D32_MM using decoder 178 |
| 2840 | // 3502: } |
| 2841 | 22, 7, // 3507: case 0x16: { |
| 2842 | OPC_CheckPredicate, 19, // 3509: check predicate 19 |
| 2843 | OPC_Decode, 171, 11, 178, 1, // 3511: decode to C_OLE_D32_MM using decoder 178 |
| 2844 | // 3511: } |
| 2845 | 23, 7, // 3516: case 0x17: { |
| 2846 | OPC_CheckPredicate, 19, // 3518: check predicate 19 |
| 2847 | OPC_Decode, 201, 11, 178, 1, // 3520: decode to C_ULE_D32_MM using decoder 178 |
| 2848 | // 3520: } |
| 2849 | 24, 7, // 3525: case 0x18: { |
| 2850 | OPC_CheckPredicate, 19, // 3527: check predicate 19 |
| 2851 | OPC_Decode, 189, 11, 178, 1, // 3529: decode to C_SF_D32_MM using decoder 178 |
| 2852 | // 3529: } |
| 2853 | 25, 7, // 3534: case 0x19: { |
| 2854 | OPC_CheckPredicate, 19, // 3536: check predicate 19 |
| 2855 | OPC_Decode, 153, 11, 178, 1, // 3538: decode to C_NGLE_D32_MM using decoder 178 |
| 2856 | // 3538: } |
| 2857 | 26, 7, // 3543: case 0x1a: { |
| 2858 | OPC_CheckPredicate, 19, // 3545: check predicate 19 |
| 2859 | OPC_Decode, 183, 11, 178, 1, // 3547: decode to C_SEQ_D32_MM using decoder 178 |
| 2860 | // 3547: } |
| 2861 | 27, 7, // 3552: case 0x1b: { |
| 2862 | OPC_CheckPredicate, 19, // 3554: check predicate 19 |
| 2863 | OPC_Decode, 159, 11, 178, 1, // 3556: decode to C_NGL_D32_MM using decoder 178 |
| 2864 | // 3556: } |
| 2865 | 28, 7, // 3561: case 0x1c: { |
| 2866 | OPC_CheckPredicate, 19, // 3563: check predicate 19 |
| 2867 | OPC_Decode, 141, 11, 178, 1, // 3565: decode to C_LT_D32_MM using decoder 178 |
| 2868 | // 3565: } |
| 2869 | 29, 7, // 3570: case 0x1d: { |
| 2870 | OPC_CheckPredicate, 19, // 3572: check predicate 19 |
| 2871 | OPC_Decode, 147, 11, 178, 1, // 3574: decode to C_NGE_D32_MM using decoder 178 |
| 2872 | // 3574: } |
| 2873 | 30, 7, // 3579: case 0x1e: { |
| 2874 | OPC_CheckPredicate, 19, // 3581: check predicate 19 |
| 2875 | OPC_Decode, 135, 11, 178, 1, // 3583: decode to C_LE_D32_MM using decoder 178 |
| 2876 | // 3583: } |
| 2877 | 31, 0, // 3588: case 0x1f: { |
| 2878 | OPC_CheckPredicate, 19, // 3590: check predicate 19 |
| 2879 | OPC_Decode, 165, 11, 178, 1, // 3592: decode to C_NGT_D32_MM using decoder 178 |
| 2880 | // 3592: } |
| 2881 | // 3592: } // switch Inst[12:6] |
| 2882 | // 3592: } |
| 2883 | // 3592: } // switch Inst[5:0] |
| 2884 | // 3592: } |
| 2885 | 22, 30, // 3597: case 0x16: { |
| 2886 | OPC_SwitchField, 0, 11, // 3599: switch Inst[10:0] { |
| 2887 | 197, 1, 6, // 3602: case 0xc5: { |
| 2888 | OPC_CheckPredicate, 10, // 3605: check predicate 10 |
| 2889 | OPC_Decode, 235, 9, 97, // 3607: decode to CMPGU_EQ_QB_MM using decoder 97 |
| 2890 | // 3607: } |
| 2891 | 133, 2, 6, // 3611: case 0x105: { |
| 2892 | OPC_CheckPredicate, 10, // 3614: check predicate 10 |
| 2893 | OPC_Decode, 239, 9, 97, // 3616: decode to CMPGU_LT_QB_MM using decoder 97 |
| 2894 | // 3616: } |
| 2895 | 197, 2, 0, // 3620: case 0x145: { |
| 2896 | OPC_CheckPredicate, 10, // 3623: check predicate 10 |
| 2897 | OPC_Decode, 237, 9, 97, // 3625: decode to CMPGU_LE_QB_MM using decoder 97 |
| 2898 | // 3625: } |
| 2899 | // 3625: } // switch Inst[10:0] |
| 2900 | // 3625: } |
| 2901 | 24, 229, 1, // 3629: case 0x18: { |
| 2902 | OPC_SwitchField, 12, 4, // 3632: switch Inst[15:12] { |
| 2903 | 0, 7, // 3635: case 0x0: { |
| 2904 | OPC_CheckPredicate, 1, // 3637: check predicate 1 |
| 2905 | OPC_Decode, 181, 16, 179, 1, // 3639: decode to LWL_MM using decoder 179 |
| 2906 | // 3639: } |
| 2907 | 1, 7, // 3644: case 0x1: { |
| 2908 | OPC_CheckPredicate, 1, // 3646: check predicate 1 |
| 2909 | OPC_Decode, 194, 16, 179, 1, // 3648: decode to LWR_MM using decoder 179 |
| 2910 | // 3648: } |
| 2911 | 2, 7, // 3653: case 0x2: { |
| 2912 | OPC_CheckPredicate, 1, // 3655: check predicate 1 |
| 2913 | OPC_Decode, 139, 20, 145, 1, // 3657: decode to PREF_MM using decoder 145 |
| 2914 | // 3657: } |
| 2915 | 3, 7, // 3662: case 0x3: { |
| 2916 | OPC_CheckPredicate, 1, // 3664: check predicate 1 |
| 2917 | OPC_Decode, 143, 16, 180, 1, // 3666: decode to LL_MM using decoder 180 |
| 2918 | // 3666: } |
| 2919 | 6, 75, // 3671: case 0x6: { |
| 2920 | OPC_SwitchField, 9, 3, // 3673: switch Inst[11:9] { |
| 2921 | 0, 7, // 3676: case 0x0: { |
| 2922 | OPC_CheckPredicate, 23, // 3678: check predicate 23 |
| 2923 | OPC_Decode, 206, 15, 181, 1, // 3680: decode to LBuE_MM using decoder 181 |
| 2924 | // 3680: } |
| 2925 | 1, 7, // 3685: case 0x1: { |
| 2926 | OPC_CheckPredicate, 23, // 3687: check predicate 23 |
| 2927 | OPC_Decode, 129, 16, 182, 1, // 3689: decode to LHuE_MM using decoder 182 |
| 2928 | // 3689: } |
| 2929 | 2, 7, // 3694: case 0x2: { |
| 2930 | OPC_CheckPredicate, 24, // 3696: check predicate 24 |
| 2931 | OPC_Decode, 180, 16, 183, 1, // 3698: decode to LWLE_MM using decoder 183 |
| 2932 | // 3698: } |
| 2933 | 3, 7, // 3703: case 0x3: { |
| 2934 | OPC_CheckPredicate, 24, // 3705: check predicate 24 |
| 2935 | OPC_Decode, 193, 16, 183, 1, // 3707: decode to LWRE_MM using decoder 183 |
| 2936 | // 3707: } |
| 2937 | 4, 7, // 3712: case 0x4: { |
| 2938 | OPC_CheckPredicate, 23, // 3714: check predicate 23 |
| 2939 | OPC_Decode, 187, 15, 181, 1, // 3716: decode to LBE_MM using decoder 181 |
| 2940 | // 3716: } |
| 2941 | 5, 7, // 3721: case 0x5: { |
| 2942 | OPC_CheckPredicate, 23, // 3723: check predicate 23 |
| 2943 | OPC_Decode, 238, 15, 182, 1, // 3725: decode to LHE_MM using decoder 182 |
| 2944 | // 3725: } |
| 2945 | 6, 7, // 3730: case 0x6: { |
| 2946 | OPC_CheckPredicate, 23, // 3732: check predicate 23 |
| 2947 | OPC_Decode, 141, 16, 182, 1, // 3734: decode to LLE_MM using decoder 182 |
| 2948 | // 3734: } |
| 2949 | 7, 0, // 3739: case 0x7: { |
| 2950 | OPC_CheckPredicate, 23, // 3741: check predicate 23 |
| 2951 | OPC_Decode, 173, 16, 182, 1, // 3743: decode to LWE_MM using decoder 182 |
| 2952 | // 3743: } |
| 2953 | // 3743: } // switch Inst[11:9] |
| 2954 | // 3743: } |
| 2955 | 8, 7, // 3748: case 0x8: { |
| 2956 | OPC_CheckPredicate, 1, // 3750: check predicate 1 |
| 2957 | OPC_Decode, 175, 23, 180, 1, // 3752: decode to SWL_MM using decoder 180 |
| 2958 | // 3752: } |
| 2959 | 9, 7, // 3757: case 0x9: { |
| 2960 | OPC_CheckPredicate, 1, // 3759: check predicate 1 |
| 2961 | OPC_Decode, 186, 23, 180, 1, // 3761: decode to SWR_MM using decoder 180 |
| 2962 | // 3761: } |
| 2963 | 10, 75, // 3766: case 0xa: { |
| 2964 | OPC_SwitchField, 9, 3, // 3768: switch Inst[11:9] { |
| 2965 | 0, 7, // 3771: case 0x0: { |
| 2966 | OPC_CheckPredicate, 24, // 3773: check predicate 24 |
| 2967 | OPC_Decode, 174, 23, 182, 1, // 3775: decode to SWLE_MM using decoder 182 |
| 2968 | // 3775: } |
| 2969 | 1, 7, // 3780: case 0x1: { |
| 2970 | OPC_CheckPredicate, 24, // 3782: check predicate 24 |
| 2971 | OPC_Decode, 185, 23, 182, 1, // 3784: decode to SWRE_MM using decoder 182 |
| 2972 | // 3784: } |
| 2973 | 2, 7, // 3789: case 0x2: { |
| 2974 | OPC_CheckPredicate, 23, // 3791: check predicate 23 |
| 2975 | OPC_Decode, 137, 20, 184, 1, // 3793: decode to PREFE_MM using decoder 184 |
| 2976 | // 3793: } |
| 2977 | 3, 7, // 3798: case 0x3: { |
| 2978 | OPC_CheckPredicate, 23, // 3800: check predicate 23 |
| 2979 | OPC_Decode, 150, 9, 184, 1, // 3802: decode to CACHEE_MM using decoder 184 |
| 2980 | // 3802: } |
| 2981 | 4, 7, // 3807: case 0x4: { |
| 2982 | OPC_CheckPredicate, 23, // 3809: check predicate 23 |
| 2983 | OPC_Decode, 224, 20, 182, 1, // 3811: decode to SBE_MM using decoder 182 |
| 2984 | // 3811: } |
| 2985 | 5, 7, // 3816: case 0x5: { |
| 2986 | OPC_CheckPredicate, 23, // 3818: check predicate 23 |
| 2987 | OPC_Decode, 174, 21, 182, 1, // 3820: decode to SHE_MM using decoder 182 |
| 2988 | // 3820: } |
| 2989 | 6, 7, // 3825: case 0x6: { |
| 2990 | OPC_CheckPredicate, 23, // 3827: check predicate 23 |
| 2991 | OPC_Decode, 237, 20, 185, 1, // 3829: decode to SCE_MM using decoder 185 |
| 2992 | // 3829: } |
| 2993 | 7, 0, // 3834: case 0x7: { |
| 2994 | OPC_CheckPredicate, 23, // 3836: check predicate 23 |
| 2995 | OPC_Decode, 168, 23, 182, 1, // 3838: decode to SWE_MM using decoder 182 |
| 2996 | // 3838: } |
| 2997 | // 3838: } // switch Inst[11:9] |
| 2998 | // 3838: } |
| 2999 | 11, 7, // 3843: case 0xb: { |
| 3000 | OPC_CheckPredicate, 1, // 3845: check predicate 1 |
| 3001 | OPC_Decode, 239, 20, 186, 1, // 3847: decode to SC_MM using decoder 186 |
| 3002 | // 3847: } |
| 3003 | 14, 0, // 3852: case 0xe: { |
| 3004 | OPC_CheckPredicate, 1, // 3854: check predicate 1 |
| 3005 | OPC_Decode, 198, 16, 180, 1, // 3856: decode to LWU_MM using decoder 180 |
| 3006 | // 3856: } |
| 3007 | // 3856: } // switch Inst[15:12] |
| 3008 | // 3856: } |
| 3009 | 28, 7, // 3861: case 0x1c: { |
| 3010 | OPC_CheckPredicate, 1, // 3863: check predicate 1 |
| 3011 | OPC_Decode, 205, 24, 153, 1, // 3865: decode to XORi_MM using decoder 153 |
| 3012 | // 3865: } |
| 3013 | 29, 7, // 3870: case 0x1d: { |
| 3014 | OPC_CheckPredicate, 1, // 3872: check predicate 1 |
| 3015 | OPC_Decode, 150, 15, 187, 1, // 3874: decode to JALS_MM using decoder 187 |
| 3016 | // 3874: } |
| 3017 | 30, 7, // 3879: case 0x1e: { |
| 3018 | OPC_CheckPredicate, 1, // 3881: check predicate 1 |
| 3019 | OPC_Decode, 165, 6, 188, 1, // 3883: decode to ADDIUPC_MM using decoder 188 |
| 3020 | // 3883: } |
| 3021 | 36, 7, // 3888: case 0x24: { |
| 3022 | OPC_CheckPredicate, 2, // 3890: check predicate 2 |
| 3023 | OPC_Decode, 145, 22, 141, 1, // 3892: decode to SLTi_MM using decoder 141 |
| 3024 | // 3892: } |
| 3025 | 37, 7, // 3897: case 0x25: { |
| 3026 | OPC_CheckPredicate, 1, // 3899: check predicate 1 |
| 3027 | OPC_Decode, 241, 7, 189, 1, // 3901: decode to BEQ_MM using decoder 189 |
| 3028 | // 3901: } |
| 3029 | 38, 7, // 3906: case 0x26: { |
| 3030 | OPC_CheckPredicate, 21, // 3908: check predicate 21 |
| 3031 | OPC_Decode, 160, 23, 190, 1, // 3910: decode to SWC1_MM using decoder 190 |
| 3032 | // 3910: } |
| 3033 | 39, 7, // 3915: case 0x27: { |
| 3034 | OPC_CheckPredicate, 21, // 3917: check predicate 21 |
| 3035 | OPC_Decode, 165, 16, 190, 1, // 3919: decode to LWC1_MM using decoder 190 |
| 3036 | // 3919: } |
| 3037 | 44, 7, // 3924: case 0x2c: { |
| 3038 | OPC_CheckPredicate, 2, // 3926: check predicate 2 |
| 3039 | OPC_Decode, 148, 22, 141, 1, // 3928: decode to SLTiu_MM using decoder 141 |
| 3040 | // 3928: } |
| 3041 | 45, 7, // 3933: case 0x2d: { |
| 3042 | OPC_CheckPredicate, 1, // 3935: check predicate 1 |
| 3043 | OPC_Decode, 228, 8, 189, 1, // 3937: decode to BNE_MM using decoder 189 |
| 3044 | // 3937: } |
| 3045 | 46, 7, // 3942: case 0x2e: { |
| 3046 | OPC_CheckPredicate, 20, // 3944: check predicate 20 |
| 3047 | OPC_Decode, 255, 20, 191, 1, // 3946: decode to SDC1_MM_D32 using decoder 191 |
| 3048 | // 3946: } |
| 3049 | 47, 7, // 3951: case 0x2f: { |
| 3050 | OPC_CheckPredicate, 20, // 3953: check predicate 20 |
| 3051 | OPC_Decode, 212, 15, 191, 1, // 3955: decode to LDC1_MM_D32 using decoder 191 |
| 3052 | // 3955: } |
| 3053 | 52, 7, // 3960: case 0x34: { |
| 3054 | OPC_CheckPredicate, 1, // 3962: check predicate 1 |
| 3055 | OPC_Decode, 141, 7, 153, 1, // 3964: decode to ANDi_MM using decoder 153 |
| 3056 | // 3964: } |
| 3057 | 53, 7, // 3969: case 0x35: { |
| 3058 | OPC_CheckPredicate, 1, // 3971: check predicate 1 |
| 3059 | OPC_Decode, 174, 15, 187, 1, // 3973: decode to J_MM using decoder 187 |
| 3060 | // 3973: } |
| 3061 | 60, 7, // 3978: case 0x3c: { |
| 3062 | OPC_CheckPredicate, 1, // 3980: check predicate 1 |
| 3063 | OPC_Decode, 152, 15, 192, 1, // 3982: decode to JALX_MM using decoder 192 |
| 3064 | // 3982: } |
| 3065 | 61, 7, // 3987: case 0x3d: { |
| 3066 | OPC_CheckPredicate, 1, // 3989: check predicate 1 |
| 3067 | OPC_Decode, 153, 15, 187, 1, // 3991: decode to JAL_MM using decoder 187 |
| 3068 | // 3991: } |
| 3069 | 62, 7, // 3996: case 0x3e: { |
| 3070 | OPC_CheckPredicate, 2, // 3998: check predicate 2 |
| 3071 | OPC_Decode, 194, 23, 142, 1, // 4000: decode to SW_MM using decoder 142 |
| 3072 | // 4000: } |
| 3073 | 63, 0, // 4005: case 0x3f: { |
| 3074 | OPC_CheckPredicate, 2, // 4007: check predicate 2 |
| 3075 | OPC_Decode, 207, 16, 142, 1, // 4009: decode to LW_MM using decoder 142 |
| 3076 | // 4009: } |
| 3077 | // 4009: } // switch Inst[31:26] |
| 3078 | }; |
| 3079 | static const uint8_t DecoderTableMicroMipsDSP32[21] = { |
| 3080 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 3081 | 62, 7, // 3: case 0x3e: { |
| 3082 | OPC_CheckPredicate, 10, // 5: check predicate 10 |
| 3083 | OPC_Decode, 166, 23, 193, 1, // 7: decode to SWDSP_MM using decoder 193 |
| 3084 | // 7: } |
| 3085 | 63, 0, // 12: case 0x3f: { |
| 3086 | OPC_CheckPredicate, 10, // 14: check predicate 10 |
| 3087 | OPC_Decode, 171, 16, 193, 1, // 16: decode to LWDSP_MM using decoder 193 |
| 3088 | // 16: } |
| 3089 | // 16: } // switch Inst[31:26] |
| 3090 | }; |
| 3091 | static const uint8_t DecoderTableMicroMipsFP6432[210] = { |
| 3092 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 3093 | 21, 186, 1, // 3: case 0x15: { |
| 3094 | OPC_SwitchField, 0, 11, // 6: switch Inst[10:0] { |
| 3095 | 59, 30, // 9: case 0x3b: { |
| 3096 | OPC_SwitchField, 11, 5, // 11: switch Inst[15:11] { |
| 3097 | 5, 7, // 14: case 0x5: { |
| 3098 | OPC_CheckPredicate, 22, // 16: check predicate 22 |
| 3099 | OPC_Decode, 188, 18, 194, 1, // 18: decode to MTC1_D64_MM using decoder 194 |
| 3100 | // 18: } |
| 3101 | 6, 7, // 23: case 0x6: { |
| 3102 | OPC_CheckPredicate, 22, // 25: check predicate 22 |
| 3103 | OPC_Decode, 173, 17, 195, 1, // 27: decode to MFHC1_D64_MM using decoder 195 |
| 3104 | // 27: } |
| 3105 | 7, 0, // 32: case 0x7: { |
| 3106 | OPC_CheckPredicate, 22, // 34: check predicate 22 |
| 3107 | OPC_Decode, 200, 18, 196, 1, // 36: decode to MTHC1_D64_MM using decoder 196 |
| 3108 | // 36: } |
| 3109 | // 36: } // switch Inst[15:11] |
| 3110 | // 36: } |
| 3111 | 123, 11, // 41: case 0x7b: { |
| 3112 | OPC_CheckPredicate, 22, // 43: check predicate 22 |
| 3113 | OPC_CheckField, 11, 5, 4, // 45: check Inst[15:11] == 0x4 |
| 3114 | OPC_Decode, 130, 14, 167, 1, // 49: decode to FMOV_D64_MM using decoder 167 |
| 3115 | // 49: } |
| 3116 | 176, 2, 7, // 54: case 0x130: { |
| 3117 | OPC_CheckPredicate, 22, // 57: check predicate 22 |
| 3118 | OPC_Decode, 168, 13, 197, 1, // 59: decode to FADD_D64_MM using decoder 197 |
| 3119 | // 59: } |
| 3120 | 187, 2, 11, // 64: case 0x13b: { |
| 3121 | OPC_CheckPredicate, 22, // 67: check predicate 22 |
| 3122 | OPC_CheckField, 11, 5, 9, // 69: check Inst[15:11] == 0x9 |
| 3123 | OPC_Decode, 246, 10, 198, 1, // 73: decode to CVT_W_D64_MM using decoder 198 |
| 3124 | // 73: } |
| 3125 | 240, 2, 7, // 78: case 0x170: { |
| 3126 | OPC_CheckPredicate, 22, // 81: check predicate 22 |
| 3127 | OPC_Decode, 185, 14, 197, 1, // 83: decode to FSUB_D64_MM using decoder 197 |
| 3128 | // 83: } |
| 3129 | 176, 3, 7, // 88: case 0x1b0: { |
| 3130 | OPC_CheckPredicate, 22, // 91: check predicate 22 |
| 3131 | OPC_Decode, 141, 14, 197, 1, // 93: decode to FMUL_D64_MM using decoder 197 |
| 3132 | // 93: } |
| 3133 | 240, 3, 7, // 98: case 0x1f0: { |
| 3134 | OPC_CheckPredicate, 22, // 101: check predicate 22 |
| 3135 | OPC_Decode, 207, 13, 197, 1, // 103: decode to FDIV_D64_MM using decoder 197 |
| 3136 | // 103: } |
| 3137 | 187, 4, 30, // 108: case 0x23b: { |
| 3138 | OPC_SwitchField, 11, 5, // 111: switch Inst[15:11] { |
| 3139 | 8, 7, // 114: case 0x8: { |
| 3140 | OPC_CheckPredicate, 22, // 116: check predicate 22 |
| 3141 | OPC_Decode, 201, 20, 167, 1, // 118: decode to RSQRT_D64_MM using decoder 167 |
| 3142 | // 118: } |
| 3143 | 9, 7, // 123: case 0x9: { |
| 3144 | OPC_CheckPredicate, 22, // 125: check predicate 22 |
| 3145 | OPC_Decode, 177, 14, 167, 1, // 127: decode to FSQRT_D64_MM using decoder 167 |
| 3146 | // 127: } |
| 3147 | 10, 0, // 132: case 0xa: { |
| 3148 | OPC_CheckPredicate, 22, // 134: check predicate 22 |
| 3149 | OPC_Decode, 162, 20, 167, 1, // 136: decode to RECIP_D64_MM using decoder 167 |
| 3150 | // 136: } |
| 3151 | // 136: } // switch Inst[15:11] |
| 3152 | // 136: } |
| 3153 | 251, 6, 0, // 141: case 0x37b: { |
| 3154 | OPC_SwitchField, 11, 5, // 144: switch Inst[15:11] { |
| 3155 | 2, 7, // 147: case 0x2: { |
| 3156 | OPC_CheckPredicate, 22, // 149: check predicate 22 |
| 3157 | OPC_Decode, 219, 10, 166, 1, // 151: decode to CVT_D64_S_MM using decoder 166 |
| 3158 | // 151: } |
| 3159 | 3, 7, // 156: case 0x3: { |
| 3160 | OPC_CheckPredicate, 22, // 158: check predicate 22 |
| 3161 | OPC_Decode, 235, 10, 198, 1, // 160: decode to CVT_S_D64_MM using decoder 198 |
| 3162 | // 160: } |
| 3163 | 4, 7, // 165: case 0x4: { |
| 3164 | OPC_CheckPredicate, 22, // 167: check predicate 22 |
| 3165 | OPC_Decode, 161, 13, 167, 1, // 169: decode to FABS_D64_MM using decoder 167 |
| 3166 | // 169: } |
| 3167 | 5, 7, // 174: case 0x5: { |
| 3168 | OPC_CheckPredicate, 22, // 176: check predicate 22 |
| 3169 | OPC_Decode, 150, 14, 167, 1, // 178: decode to FNEG_D64_MM using decoder 167 |
| 3170 | // 178: } |
| 3171 | 6, 0, // 183: case 0x6: { |
| 3172 | OPC_CheckPredicate, 22, // 185: check predicate 22 |
| 3173 | OPC_Decode, 221, 10, 166, 1, // 187: decode to CVT_D64_W_MM using decoder 166 |
| 3174 | // 187: } |
| 3175 | // 187: } // switch Inst[15:11] |
| 3176 | // 187: } |
| 3177 | // 187: } // switch Inst[10:0] |
| 3178 | // 187: } |
| 3179 | 46, 7, // 192: case 0x2e: { |
| 3180 | OPC_CheckPredicate, 25, // 194: check predicate 25 |
| 3181 | OPC_Decode, 254, 20, 191, 1, // 196: decode to SDC1_D64_MMR6 using decoder 191 |
| 3182 | // 196: } |
| 3183 | 47, 0, // 201: case 0x2f: { |
| 3184 | OPC_CheckPredicate, 25, // 203: check predicate 25 |
| 3185 | OPC_Decode, 211, 15, 191, 1, // 205: decode to LDC1_D64_MMR6 using decoder 191 |
| 3186 | // 205: } |
| 3187 | // 205: } // switch Inst[31:26] |
| 3188 | }; |
| 3189 | static const uint8_t DecoderTableMicroMipsR632[1993] = { |
| 3190 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 3191 | 0, 159, 5, // 3: case 0x0: { |
| 3192 | OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] { |
| 3193 | 0, 69, // 9: case 0x0: { |
| 3194 | OPC_SwitchField, 6, 5, // 11: switch Inst[10:6] { |
| 3195 | 0, 35, // 14: case 0x0: { |
| 3196 | OPC_Scope, 27, // 16: try { |
| 3197 | OPC_SwitchField, 11, 15, // 18: switch Inst[25:11] { |
| 3198 | 1, 6, // 21: case 0x1: { |
| 3199 | OPC_CheckPredicate, 3, // 23: check predicate 3 |
| 3200 | OPC_Decode, 212, 22, 10, // 25: decode to SSNOP_MMR6 using decoder 10 |
| 3201 | // 25: } |
| 3202 | 3, 6, // 29: case 0x3: { |
| 3203 | OPC_CheckPredicate, 3, // 31: check predicate 3 |
| 3204 | OPC_Decode, 237, 12, 10, // 33: decode to EHB_MMR6 using decoder 10 |
| 3205 | // 33: } |
| 3206 | 5, 0, // 37: case 0x5: { |
| 3207 | OPC_CheckPredicate, 3, // 39: check predicate 3 |
| 3208 | OPC_Decode, 208, 19, 10, // 41: decode to PAUSE_MMR6 using decoder 10 |
| 3209 | // 41: } |
| 3210 | // 41: } // switch Inst[25:11] |
| 3211 | // 41: } else try { |
| 3212 | OPC_CheckPredicate, 3, // 45: check predicate 3 |
| 3213 | OPC_Decode, 133, 22, 95, // 47: decode to SLL_MMR6 using decoder 95 |
| 3214 | // 47: } |
| 3215 | // 47: } |
| 3216 | 5, 6, // 51: case 0x5: { |
| 3217 | OPC_CheckPredicate, 3, // 53: check predicate 3 |
| 3218 | OPC_Decode, 151, 21, 98, // 55: decode to SELEQZ_MMR6 using decoder 98 |
| 3219 | // 55: } |
| 3220 | 6, 6, // 59: case 0x6: { |
| 3221 | OPC_CheckPredicate, 3, // 61: check predicate 3 |
| 3222 | OPC_Decode, 158, 21, 98, // 63: decode to SELNEZ_MMR6 using decoder 98 |
| 3223 | // 63: } |
| 3224 | 7, 0, // 67: case 0x7: { |
| 3225 | OPC_CheckPredicate, 3, // 69: check predicate 3 |
| 3226 | OPC_CheckField, 14, 2, 0, // 71: check Inst[15:14] == 0x0 |
| 3227 | OPC_Decode, 155, 20, 199, 1, // 75: decode to RDHWR_MMR6 using decoder 199 |
| 3228 | // 75: } |
| 3229 | // 75: } // switch Inst[10:6] |
| 3230 | // 75: } |
| 3231 | 7, 6, // 80: case 0x7: { |
| 3232 | OPC_CheckPredicate, 3, // 82: check predicate 3 |
| 3233 | OPC_Decode, 246, 8, 99, // 84: decode to BREAK_MMR6 using decoder 99 |
| 3234 | // 84: } |
| 3235 | 12, 6, // 88: case 0xc: { |
| 3236 | OPC_CheckPredicate, 3, // 90: check predicate 3 |
| 3237 | OPC_Decode, 131, 15, 100, // 92: decode to INS_MMR6 using decoder 100 |
| 3238 | // 92: } |
| 3239 | 15, 11, // 96: case 0xf: { |
| 3240 | OPC_CheckPredicate, 3, // 98: check predicate 3 |
| 3241 | OPC_CheckField, 6, 3, 0, // 100: check Inst[8:6] == 0x0 |
| 3242 | OPC_Decode, 148, 16, 200, 1, // 104: decode to LSA_MMR6 using decoder 200 |
| 3243 | // 104: } |
| 3244 | 16, 79, // 109: case 0x10: { |
| 3245 | OPC_SwitchField, 6, 5, // 111: switch Inst[10:6] { |
| 3246 | 1, 10, // 114: case 0x1: { |
| 3247 | OPC_CheckPredicate, 3, // 116: check predicate 3 |
| 3248 | OPC_CheckField, 16, 5, 0, // 118: check Inst[20:16] == 0x0 |
| 3249 | OPC_Decode, 225, 9, 89, // 122: decode to CLZ_MMR6 using decoder 89 |
| 3250 | // 122: } |
| 3251 | 4, 6, // 126: case 0x4: { |
| 3252 | OPC_CheckPredicate, 3, // 128: check predicate 3 |
| 3253 | OPC_Decode, 236, 6, 98, // 130: decode to ADD_MMR6 using decoder 98 |
| 3254 | // 130: } |
| 3255 | 5, 6, // 134: case 0x5: { |
| 3256 | OPC_CheckPredicate, 3, // 136: check predicate 3 |
| 3257 | OPC_Decode, 212, 6, 98, // 138: decode to ADDU_MMR6 using decoder 98 |
| 3258 | // 138: } |
| 3259 | 6, 6, // 142: case 0x6: { |
| 3260 | OPC_CheckPredicate, 3, // 144: check predicate 3 |
| 3261 | OPC_Decode, 144, 23, 98, // 146: decode to SUB_MMR6 using decoder 98 |
| 3262 | // 146: } |
| 3263 | 7, 6, // 150: case 0x7: { |
| 3264 | OPC_CheckPredicate, 3, // 152: check predicate 3 |
| 3265 | OPC_Decode, 254, 22, 98, // 154: decode to SUBU_MMR6 using decoder 98 |
| 3266 | // 154: } |
| 3267 | 9, 6, // 158: case 0x9: { |
| 3268 | OPC_CheckPredicate, 3, // 160: check predicate 3 |
| 3269 | OPC_Decode, 136, 7, 98, // 162: decode to AND_MMR6 using decoder 98 |
| 3270 | // 162: } |
| 3271 | 10, 6, // 166: case 0xa: { |
| 3272 | OPC_CheckPredicate, 3, // 168: check predicate 3 |
| 3273 | OPC_Decode, 197, 19, 98, // 170: decode to OR_MMR6 using decoder 98 |
| 3274 | // 170: } |
| 3275 | 11, 6, // 174: case 0xb: { |
| 3276 | OPC_CheckPredicate, 3, // 176: check predicate 3 |
| 3277 | OPC_Decode, 180, 19, 98, // 178: decode to NOR_MMR6 using decoder 98 |
| 3278 | // 178: } |
| 3279 | 12, 0, // 182: case 0xc: { |
| 3280 | OPC_CheckPredicate, 3, // 184: check predicate 3 |
| 3281 | OPC_Decode, 200, 24, 98, // 186: decode to XOR_MMR6 using decoder 98 |
| 3282 | // 186: } |
| 3283 | // 186: } // switch Inst[10:6] |
| 3284 | // 186: } |
| 3285 | 24, 67, // 190: case 0x18: { |
| 3286 | OPC_SwitchField, 6, 5, // 192: switch Inst[10:6] { |
| 3287 | 0, 6, // 195: case 0x0: { |
| 3288 | OPC_CheckPredicate, 3, // 197: check predicate 3 |
| 3289 | OPC_Decode, 142, 19, 98, // 199: decode to MUL_MMR6 using decoder 98 |
| 3290 | // 199: } |
| 3291 | 1, 6, // 203: case 0x1: { |
| 3292 | OPC_CheckPredicate, 3, // 205: check predicate 3 |
| 3293 | OPC_Decode, 227, 18, 98, // 207: decode to MUH_MMR6 using decoder 98 |
| 3294 | // 207: } |
| 3295 | 2, 6, // 211: case 0x2: { |
| 3296 | OPC_CheckPredicate, 3, // 213: check predicate 3 |
| 3297 | OPC_Decode, 135, 19, 98, // 215: decode to MULU_MMR6 using decoder 98 |
| 3298 | // 215: } |
| 3299 | 3, 6, // 219: case 0x3: { |
| 3300 | OPC_CheckPredicate, 3, // 221: check predicate 3 |
| 3301 | OPC_Decode, 225, 18, 98, // 223: decode to MUHU_MMR6 using decoder 98 |
| 3302 | // 223: } |
| 3303 | 4, 6, // 227: case 0x4: { |
| 3304 | OPC_CheckPredicate, 3, // 229: check predicate 3 |
| 3305 | OPC_Decode, 252, 11, 98, // 231: decode to DIV_MMR6 using decoder 98 |
| 3306 | // 231: } |
| 3307 | 5, 6, // 235: case 0x5: { |
| 3308 | OPC_CheckPredicate, 3, // 237: check predicate 3 |
| 3309 | OPC_Decode, 224, 17, 98, // 239: decode to MOD_MMR6 using decoder 98 |
| 3310 | // 239: } |
| 3311 | 6, 6, // 243: case 0x6: { |
| 3312 | OPC_CheckPredicate, 3, // 245: check predicate 3 |
| 3313 | OPC_Decode, 250, 11, 98, // 247: decode to DIVU_MMR6 using decoder 98 |
| 3314 | // 247: } |
| 3315 | 7, 0, // 251: case 0x7: { |
| 3316 | OPC_CheckPredicate, 3, // 253: check predicate 3 |
| 3317 | OPC_Decode, 222, 17, 98, // 255: decode to MODU_MMR6 using decoder 98 |
| 3318 | // 255: } |
| 3319 | // 255: } // switch Inst[10:6] |
| 3320 | // 255: } |
| 3321 | 31, 11, // 259: case 0x1f: { |
| 3322 | OPC_CheckPredicate, 3, // 261: check predicate 3 |
| 3323 | OPC_CheckField, 6, 3, 0, // 263: check Inst[8:6] == 0x0 |
| 3324 | OPC_Decode, 248, 6, 201, 1, // 267: decode to ALIGN_MMR6 using decoder 201 |
| 3325 | // 267: } |
| 3326 | 44, 6, // 272: case 0x2c: { |
| 3327 | OPC_CheckPredicate, 3, // 274: check predicate 3 |
| 3328 | OPC_Decode, 156, 13, 109, // 276: decode to EXT_MMR6 using decoder 109 |
| 3329 | // 276: } |
| 3330 | 52, 27, // 280: case 0x34: { |
| 3331 | OPC_SwitchField, 6, 5, // 282: switch Inst[10:6] { |
| 3332 | 3, 10, // 285: case 0x3: { |
| 3333 | OPC_CheckPredicate, 3, // 287: check predicate 3 |
| 3334 | OPC_CheckField, 14, 2, 0, // 289: check Inst[15:14] == 0x0 |
| 3335 | OPC_Decode, 168, 17, 111, // 293: decode to MFHC0_MMR6 using decoder 111 |
| 3336 | // 293: } |
| 3337 | 11, 0, // 297: case 0xb: { |
| 3338 | OPC_CheckPredicate, 3, // 299: check predicate 3 |
| 3339 | OPC_CheckField, 14, 2, 0, // 301: check Inst[15:14] == 0x0 |
| 3340 | OPC_Decode, 195, 18, 112, // 305: decode to MTHC0_MMR6 using decoder 112 |
| 3341 | // 305: } |
| 3342 | // 305: } // switch Inst[10:6] |
| 3343 | // 305: } |
| 3344 | 60, 224, 2, // 309: case 0x3c: { |
| 3345 | OPC_SwitchField, 14, 2, // 312: switch Inst[15:14] { |
| 3346 | 0, 84, // 315: case 0x0: { |
| 3347 | OPC_SwitchField, 6, 5, // 317: switch Inst[10:6] { |
| 3348 | 3, 6, // 320: case 0x3: { |
| 3349 | OPC_CheckPredicate, 3, // 322: check predicate 3 |
| 3350 | OPC_Decode, 158, 17, 111, // 324: decode to MFC0_MMR6 using decoder 111 |
| 3351 | // 324: } |
| 3352 | 5, 29, // 328: case 0x5: { |
| 3353 | OPC_SwitchField, 11, 3, // 330: switch Inst[13:11] { |
| 3354 | 3, 11, // 333: case 0x3: { |
| 3355 | OPC_CheckPredicate, 3, // 335: check predicate 3 |
| 3356 | OPC_CheckField, 21, 5, 0, // 337: check Inst[25:21] == 0x0 |
| 3357 | OPC_Decode, 231, 12, 136, 1, // 341: decode to DVP_MMR6 using decoder 136 |
| 3358 | // 341: } |
| 3359 | 7, 0, // 346: case 0x7: { |
| 3360 | OPC_CheckPredicate, 3, // 348: check predicate 3 |
| 3361 | OPC_CheckField, 21, 5, 0, // 350: check Inst[25:21] == 0x0 |
| 3362 | OPC_Decode, 253, 12, 136, 1, // 354: decode to EVP_MMR6 using decoder 136 |
| 3363 | // 354: } |
| 3364 | // 354: } // switch Inst[13:11] |
| 3365 | // 354: } |
| 3366 | 11, 6, // 359: case 0xb: { |
| 3367 | OPC_CheckPredicate, 3, // 361: check predicate 3 |
| 3368 | OPC_Decode, 184, 18, 112, // 363: decode to MTC0_MMR6 using decoder 112 |
| 3369 | // 363: } |
| 3370 | 12, 11, // 367: case 0xc: { |
| 3371 | OPC_CheckPredicate, 3, // 369: check predicate 3 |
| 3372 | OPC_CheckField, 11, 3, 1, // 371: check Inst[13:11] == 0x1 |
| 3373 | OPC_Decode, 166, 8, 130, 1, // 375: decode to BITSWAP_MMR6 using decoder 130 |
| 3374 | // 375: } |
| 3375 | 28, 0, // 380: case 0x1c: { |
| 3376 | OPC_SwitchField, 11, 3, // 382: switch Inst[13:11] { |
| 3377 | 1, 6, // 385: case 0x1: { |
| 3378 | OPC_CheckPredicate, 3, // 387: check predicate 3 |
| 3379 | OPC_Decode, 142, 15, 123, // 389: decode to JALRC_MMR6 using decoder 123 |
| 3380 | // 389: } |
| 3381 | 3, 0, // 393: case 0x3: { |
| 3382 | OPC_CheckPredicate, 3, // 395: check predicate 3 |
| 3383 | OPC_Decode, 141, 15, 123, // 397: decode to JALRC_HB_MMR6 using decoder 123 |
| 3384 | // 397: } |
| 3385 | // 397: } // switch Inst[13:11] |
| 3386 | // 397: } |
| 3387 | // 397: } // switch Inst[10:6] |
| 3388 | // 397: } |
| 3389 | 1, 161, 1, // 401: case 0x1: { |
| 3390 | OPC_SwitchField, 11, 3, // 404: switch Inst[13:11] { |
| 3391 | 0, 28, // 407: case 0x0: { |
| 3392 | OPC_SwitchField, 6, 5, // 409: switch Inst[10:6] { |
| 3393 | 13, 10, // 412: case 0xd: { |
| 3394 | OPC_CheckPredicate, 3, // 414: check predicate 3 |
| 3395 | OPC_CheckField, 16, 10, 0, // 416: check Inst[25:16] == 0x0 |
| 3396 | OPC_Decode, 132, 24, 10, // 420: decode to TLBINV_MMR6 using decoder 10 |
| 3397 | // 420: } |
| 3398 | 29, 0, // 424: case 0x1d: { |
| 3399 | OPC_CheckPredicate, 3, // 426: check predicate 3 |
| 3400 | OPC_CheckField, 21, 5, 0, // 428: check Inst[25:21] == 0x0 |
| 3401 | OPC_Decode, 135, 12, 136, 1, // 432: decode to DI_MMR6 using decoder 136 |
| 3402 | // 432: } |
| 3403 | // 432: } // switch Inst[10:6] |
| 3404 | // 432: } |
| 3405 | 1, 20, // 437: case 0x1: { |
| 3406 | OPC_SwitchField, 6, 5, // 439: switch Inst[10:6] { |
| 3407 | 12, 6, // 442: case 0xc: { |
| 3408 | OPC_CheckPredicate, 3, // 444: check predicate 3 |
| 3409 | OPC_Decode, 204, 9, 123, // 446: decode to CLO_MMR6 using decoder 123 |
| 3410 | // 446: } |
| 3411 | 20, 0, // 450: case 0x14: { |
| 3412 | OPC_CheckPredicate, 3, // 452: check predicate 3 |
| 3413 | OPC_Decode, 165, 17, 134, 1, // 454: decode to MFC2_MMR6 using decoder 134 |
| 3414 | // 454: } |
| 3415 | // 454: } // switch Inst[10:6] |
| 3416 | // 454: } |
| 3417 | 2, 28, // 459: case 0x2: { |
| 3418 | OPC_SwitchField, 6, 5, // 461: switch Inst[10:6] { |
| 3419 | 13, 10, // 464: case 0xd: { |
| 3420 | OPC_CheckPredicate, 3, // 466: check predicate 3 |
| 3421 | OPC_CheckField, 16, 10, 0, // 468: check Inst[25:16] == 0x0 |
| 3422 | OPC_Decode, 131, 24, 10, // 472: decode to TLBINVF_MMR6 using decoder 10 |
| 3423 | // 472: } |
| 3424 | 29, 0, // 476: case 0x1d: { |
| 3425 | OPC_CheckPredicate, 3, // 478: check predicate 3 |
| 3426 | OPC_CheckField, 21, 5, 0, // 480: check Inst[25:21] == 0x0 |
| 3427 | OPC_Decode, 241, 12, 136, 1, // 484: decode to EI_MMR6 using decoder 136 |
| 3428 | // 484: } |
| 3429 | // 484: } // switch Inst[10:6] |
| 3430 | // 484: } |
| 3431 | 3, 11, // 489: case 0x3: { |
| 3432 | OPC_CheckPredicate, 3, // 491: check predicate 3 |
| 3433 | OPC_CheckField, 6, 5, 20, // 493: check Inst[10:6] == 0x14 |
| 3434 | OPC_Decode, 192, 18, 135, 1, // 497: decode to MTC2_MMR6 using decoder 135 |
| 3435 | // 497: } |
| 3436 | 4, 15, // 502: case 0x4: { |
| 3437 | OPC_CheckPredicate, 26, // 504: check predicate 26 |
| 3438 | OPC_CheckField, 21, 5, 0, // 506: check Inst[25:21] == 0x0 |
| 3439 | OPC_CheckField, 6, 5, 5, // 510: check Inst[10:6] == 0x5 |
| 3440 | OPC_Decode, 212, 14, 136, 1, // 514: decode to GINVI_MMR6 using decoder 136 |
| 3441 | // 514: } |
| 3442 | 5, 15, // 519: case 0x5: { |
| 3443 | OPC_CheckPredicate, 3, // 521: check predicate 3 |
| 3444 | OPC_CheckField, 21, 5, 0, // 523: check Inst[25:21] == 0x0 |
| 3445 | OPC_CheckField, 6, 5, 13, // 527: check Inst[10:6] == 0xd |
| 3446 | OPC_Decode, 205, 23, 131, 1, // 531: decode to SYNC_MMR6 using decoder 131 |
| 3447 | // 531: } |
| 3448 | 6, 15, // 536: case 0x6: { |
| 3449 | OPC_CheckPredicate, 26, // 538: check predicate 26 |
| 3450 | OPC_CheckField, 21, 5, 0, // 540: check Inst[25:21] == 0x0 |
| 3451 | OPC_CheckField, 6, 3, 5, // 544: check Inst[8:6] == 0x5 |
| 3452 | OPC_Decode, 215, 14, 202, 1, // 548: decode to GINVT_MMR6 using decoder 202 |
| 3453 | // 548: } |
| 3454 | 7, 0, // 553: case 0x7: { |
| 3455 | OPC_CheckPredicate, 3, // 555: check predicate 3 |
| 3456 | OPC_CheckField, 6, 5, 12, // 557: check Inst[10:6] == 0xc |
| 3457 | OPC_Decode, 190, 24, 123, // 561: decode to WSBH_MMR6 using decoder 123 |
| 3458 | // 561: } |
| 3459 | // 561: } // switch Inst[13:11] |
| 3460 | // 561: } |
| 3461 | 2, 30, // 565: case 0x2: { |
| 3462 | OPC_SwitchField, 6, 8, // 567: switch Inst[13:6] { |
| 3463 | 52, 7, // 570: case 0x34: { |
| 3464 | OPC_CheckPredicate, 3, // 572: check predicate 3 |
| 3465 | OPC_Decode, 174, 17, 134, 1, // 574: decode to MFHC2_MMR6 using decoder 134 |
| 3466 | // 574: } |
| 3467 | 77, 7, // 579: case 0x4d: { |
| 3468 | OPC_CheckPredicate, 3, // 581: check predicate 3 |
| 3469 | OPC_Decode, 182, 24, 132, 1, // 583: decode to WAIT_MMR6 using decoder 132 |
| 3470 | // 583: } |
| 3471 | 116, 0, // 588: case 0x74: { |
| 3472 | OPC_CheckPredicate, 3, // 590: check predicate 3 |
| 3473 | OPC_Decode, 201, 18, 135, 1, // 592: decode to MTHC2_MMR6 using decoder 135 |
| 3474 | // 592: } |
| 3475 | // 592: } // switch Inst[13:6] |
| 3476 | // 592: } |
| 3477 | 3, 0, // 597: case 0x3: { |
| 3478 | OPC_SwitchField, 6, 8, // 599: switch Inst[13:6] { |
| 3479 | 109, 7, // 602: case 0x6d: { |
| 3480 | OPC_CheckPredicate, 3, // 604: check predicate 3 |
| 3481 | OPC_Decode, 249, 20, 132, 1, // 606: decode to SDBBP_MMR6 using decoder 132 |
| 3482 | // 606: } |
| 3483 | 133, 1, 6, // 611: case 0x85: { |
| 3484 | OPC_CheckPredicate, 3, // 614: check predicate 3 |
| 3485 | OPC_Decode, 157, 20, 123, // 616: decode to RDPGPR_MMR6 using decoder 123 |
| 3486 | // 616: } |
| 3487 | 141, 1, 10, // 620: case 0x8d: { |
| 3488 | OPC_CheckPredicate, 3, // 623: check predicate 3 |
| 3489 | OPC_CheckField, 16, 10, 0, // 625: check Inst[25:16] == 0x0 |
| 3490 | OPC_Decode, 238, 11, 10, // 629: decode to DERET_MMR6 using decoder 10 |
| 3491 | // 629: } |
| 3492 | 197, 1, 6, // 633: case 0xc5: { |
| 3493 | OPC_CheckPredicate, 3, // 636: check predicate 3 |
| 3494 | OPC_Decode, 186, 24, 123, // 638: decode to WRPGPR_MMR6 using decoder 123 |
| 3495 | // 638: } |
| 3496 | 205, 1, 0, // 642: case 0xcd: { |
| 3497 | OPC_SwitchField, 16, 10, // 645: switch Inst[25:16] { |
| 3498 | 0, 6, // 648: case 0x0: { |
| 3499 | OPC_CheckPredicate, 3, // 650: check predicate 3 |
| 3500 | OPC_Decode, 249, 12, 10, // 652: decode to ERET_MMR6 using decoder 10 |
| 3501 | // 652: } |
| 3502 | 1, 0, // 656: case 0x1: { |
| 3503 | OPC_CheckPredicate, 3, // 658: check predicate 3 |
| 3504 | OPC_Decode, 246, 12, 10, // 660: decode to ERETNC_MMR6 using decoder 10 |
| 3505 | // 660: } |
| 3506 | // 660: } // switch Inst[25:16] |
| 3507 | // 660: } |
| 3508 | // 660: } // switch Inst[13:6] |
| 3509 | // 660: } |
| 3510 | // 660: } // switch Inst[15:14] |
| 3511 | // 660: } |
| 3512 | 63, 0, // 664: case 0x3f: { |
| 3513 | OPC_CheckPredicate, 3, // 666: check predicate 3 |
| 3514 | OPC_CheckField, 22, 4, 0, // 668: check Inst[25:22] == 0x0 |
| 3515 | OPC_Decode, 234, 21, 203, 1, // 672: decode to SIGRIE_MMR6 using decoder 203 |
| 3516 | // 672: } |
| 3517 | // 672: } // switch Inst[5:0] |
| 3518 | // 672: } |
| 3519 | 4, 20, // 677: case 0x4: { |
| 3520 | OPC_Scope, 11, // 679: try { |
| 3521 | OPC_CheckField, 16, 5, 0, // 681: check Inst[20:16] == 0x0 |
| 3522 | OPC_CheckPredicate, 3, // 685: check predicate 3 |
| 3523 | OPC_Decode, 151, 16, 204, 1, // 687: decode to LUI_MMR6 using decoder 204 |
| 3524 | // 687: } else try { |
| 3525 | OPC_CheckPredicate, 3, // 692: check predicate 3 |
| 3526 | OPC_Decode, 155, 7, 153, 1, // 694: decode to AUI_MMR6 using decoder 153 |
| 3527 | // 694: } |
| 3528 | // 694: } |
| 3529 | 5, 7, // 699: case 0x5: { |
| 3530 | OPC_CheckPredicate, 3, // 701: check predicate 3 |
| 3531 | OPC_Decode, 195, 15, 142, 1, // 703: decode to LBU_MMR6 using decoder 142 |
| 3532 | // 703: } |
| 3533 | 6, 7, // 708: case 0x6: { |
| 3534 | OPC_CheckPredicate, 3, // 710: check predicate 3 |
| 3535 | OPC_Decode, 228, 20, 142, 1, // 712: decode to SB_MMR6 using decoder 142 |
| 3536 | // 712: } |
| 3537 | 7, 7, // 717: case 0x7: { |
| 3538 | OPC_CheckPredicate, 3, // 719: check predicate 3 |
| 3539 | OPC_Decode, 200, 15, 142, 1, // 721: decode to LB_MMR6 using decoder 142 |
| 3540 | // 721: } |
| 3541 | 8, 64, // 726: case 0x8: { |
| 3542 | OPC_SwitchField, 12, 4, // 728: switch Inst[15:12] { |
| 3543 | 0, 11, // 731: case 0x0: { |
| 3544 | OPC_CheckPredicate, 3, // 733: check predicate 3 |
| 3545 | OPC_CheckField, 11, 1, 0, // 735: check Inst[11] == 0x0 |
| 3546 | OPC_Decode, 167, 16, 205, 1, // 739: decode to LWC2_MMR6 using decoder 205 |
| 3547 | // 739: } |
| 3548 | 2, 11, // 744: case 0x2: { |
| 3549 | OPC_CheckPredicate, 3, // 746: check predicate 3 |
| 3550 | OPC_CheckField, 11, 1, 0, // 748: check Inst[11] == 0x0 |
| 3551 | OPC_Decode, 215, 15, 205, 1, // 752: decode to LDC2_MMR6 using decoder 205 |
| 3552 | // 752: } |
| 3553 | 6, 7, // 757: case 0x6: { |
| 3554 | OPC_CheckPredicate, 3, // 759: check predicate 3 |
| 3555 | OPC_Decode, 152, 9, 145, 1, // 761: decode to CACHE_MMR6 using decoder 145 |
| 3556 | // 761: } |
| 3557 | 8, 11, // 766: case 0x8: { |
| 3558 | OPC_CheckPredicate, 3, // 768: check predicate 3 |
| 3559 | OPC_CheckField, 11, 1, 0, // 770: check Inst[11] == 0x0 |
| 3560 | OPC_Decode, 162, 23, 205, 1, // 774: decode to SWC2_MMR6 using decoder 205 |
| 3561 | // 774: } |
| 3562 | 10, 0, // 779: case 0xa: { |
| 3563 | OPC_CheckPredicate, 3, // 781: check predicate 3 |
| 3564 | OPC_CheckField, 11, 1, 0, // 783: check Inst[11] == 0x0 |
| 3565 | OPC_Decode, 130, 21, 205, 1, // 787: decode to SDC2_MMR6 using decoder 205 |
| 3566 | // 787: } |
| 3567 | // 787: } // switch Inst[15:12] |
| 3568 | // 787: } |
| 3569 | 12, 7, // 792: case 0xc: { |
| 3570 | OPC_CheckPredicate, 3, // 794: check predicate 3 |
| 3571 | OPC_Decode, 175, 6, 141, 1, // 796: decode to ADDIU_MMR6 using decoder 141 |
| 3572 | // 796: } |
| 3573 | 14, 7, // 801: case 0xe: { |
| 3574 | OPC_CheckPredicate, 3, // 803: check predicate 3 |
| 3575 | OPC_Decode, 230, 21, 142, 1, // 805: decode to SH_MMR6 using decoder 142 |
| 3576 | // 805: } |
| 3577 | 16, 48, // 810: case 0x10: { |
| 3578 | OPC_SwitchField, 21, 5, // 812: switch Inst[25:21] { |
| 3579 | 8, 7, // 815: case 0x8: { |
| 3580 | OPC_CheckPredicate, 27, // 817: check predicate 27 |
| 3581 | OPC_Decode, 201, 7, 206, 1, // 819: decode to BC1EQZC_MMR6 using decoder 206 |
| 3582 | // 819: } |
| 3583 | 9, 7, // 824: case 0x9: { |
| 3584 | OPC_CheckPredicate, 27, // 826: check predicate 27 |
| 3585 | OPC_Decode, 206, 7, 206, 1, // 828: decode to BC1NEZC_MMR6 using decoder 206 |
| 3586 | // 828: } |
| 3587 | 10, 7, // 833: case 0xa: { |
| 3588 | OPC_CheckPredicate, 3, // 835: check predicate 3 |
| 3589 | OPC_Decode, 211, 7, 207, 1, // 837: decode to BC2EQZC_MMR6 using decoder 207 |
| 3590 | // 837: } |
| 3591 | 11, 7, // 842: case 0xb: { |
| 3592 | OPC_CheckPredicate, 3, // 844: check predicate 3 |
| 3593 | OPC_Decode, 213, 7, 207, 1, // 846: decode to BC2NEZC_MMR6 using decoder 207 |
| 3594 | // 846: } |
| 3595 | 12, 0, // 851: case 0xc: { |
| 3596 | OPC_CheckPredicate, 3, // 853: check predicate 3 |
| 3597 | OPC_Decode, 201, 23, 149, 1, // 855: decode to SYNCI_MMR6 using decoder 149 |
| 3598 | // 855: } |
| 3599 | // 855: } // switch Inst[25:21] |
| 3600 | // 855: } |
| 3601 | 20, 7, // 860: case 0x14: { |
| 3602 | OPC_CheckPredicate, 3, // 862: check predicate 3 |
| 3603 | OPC_Decode, 194, 19, 153, 1, // 864: decode to ORI_MMR6 using decoder 153 |
| 3604 | // 864: } |
| 3605 | 21, 217, 6, // 869: case 0x15: { |
| 3606 | OPC_SwitchField, 0, 11, // 872: switch Inst[10:0] { |
| 3607 | 3, 7, // 875: case 0x3: { |
| 3608 | OPC_CheckPredicate, 27, // 877: check predicate 27 |
| 3609 | OPC_Decode, 212, 17, 208, 1, // 879: decode to MIN_S_MMR6 using decoder 208 |
| 3610 | // 879: } |
| 3611 | 5, 7, // 884: case 0x5: { |
| 3612 | OPC_CheckPredicate, 27, // 886: check predicate 27 |
| 3613 | OPC_Decode, 247, 9, 208, 1, // 888: decode to CMP_AF_S_MMR6 using decoder 208 |
| 3614 | // 888: } |
| 3615 | 11, 7, // 893: case 0xb: { |
| 3616 | OPC_CheckPredicate, 27, // 895: check predicate 27 |
| 3617 | OPC_Decode, 150, 17, 208, 1, // 897: decode to MAX_S_MMR6 using decoder 208 |
| 3618 | // 897: } |
| 3619 | 21, 7, // 902: case 0x15: { |
| 3620 | OPC_CheckPredicate, 27, // 904: check predicate 27 |
| 3621 | OPC_Decode, 246, 9, 197, 1, // 906: decode to CMP_AF_D_MMR6 using decoder 197 |
| 3622 | // 906: } |
| 3623 | 32, 11, // 911: case 0x20: { |
| 3624 | OPC_CheckPredicate, 3, // 913: check predicate 3 |
| 3625 | OPC_CheckField, 11, 5, 0, // 915: check Inst[15:11] == 0x0 |
| 3626 | OPC_Decode, 179, 20, 209, 1, // 919: decode to RINT_S_MMR6 using decoder 209 |
| 3627 | // 919: } |
| 3628 | 35, 7, // 924: case 0x23: { |
| 3629 | OPC_CheckPredicate, 27, // 926: check predicate 27 |
| 3630 | OPC_Decode, 193, 17, 208, 1, // 928: decode to MINA_S_MMR6 using decoder 208 |
| 3631 | // 928: } |
| 3632 | 43, 7, // 933: case 0x2b: { |
| 3633 | OPC_CheckPredicate, 27, // 935: check predicate 27 |
| 3634 | OPC_Decode, 131, 17, 208, 1, // 937: decode to MAXA_S_MMR6 using decoder 208 |
| 3635 | // 937: } |
| 3636 | 48, 7, // 942: case 0x30: { |
| 3637 | OPC_CheckPredicate, 27, // 944: check predicate 27 |
| 3638 | OPC_Decode, 172, 13, 210, 1, // 946: decode to FADD_S_MMR6 using decoder 210 |
| 3639 | // 946: } |
| 3640 | 56, 7, // 951: case 0x38: { |
| 3641 | OPC_CheckPredicate, 3, // 953: check predicate 3 |
| 3642 | OPC_Decode, 153, 21, 208, 1, // 955: decode to SELEQZ_S_MMR6 using decoder 208 |
| 3643 | // 955: } |
| 3644 | 59, 21, // 960: case 0x3b: { |
| 3645 | OPC_SwitchField, 11, 5, // 962: switch Inst[15:11] { |
| 3646 | 4, 7, // 965: case 0x4: { |
| 3647 | OPC_CheckPredicate, 27, // 967: check predicate 27 |
| 3648 | OPC_Decode, 163, 17, 164, 1, // 969: decode to MFC1_MMR6 using decoder 164 |
| 3649 | // 969: } |
| 3650 | 5, 0, // 974: case 0x5: { |
| 3651 | OPC_CheckPredicate, 27, // 976: check predicate 27 |
| 3652 | OPC_Decode, 190, 18, 170, 1, // 978: decode to MTC1_MMR6 using decoder 170 |
| 3653 | // 978: } |
| 3654 | // 978: } // switch Inst[15:11] |
| 3655 | // 978: } |
| 3656 | 69, 7, // 983: case 0x45: { |
| 3657 | OPC_CheckPredicate, 27, // 985: check predicate 27 |
| 3658 | OPC_Decode, 187, 10, 208, 1, // 987: decode to CMP_UN_S_MMR6 using decoder 208 |
| 3659 | // 987: } |
| 3660 | 85, 7, // 992: case 0x55: { |
| 3661 | OPC_CheckPredicate, 27, // 994: check predicate 27 |
| 3662 | OPC_Decode, 185, 10, 197, 1, // 996: decode to CMP_UN_D_MMR6 using decoder 197 |
| 3663 | // 996: } |
| 3664 | 96, 11, // 1001: case 0x60: { |
| 3665 | OPC_CheckPredicate, 3, // 1003: check predicate 3 |
| 3666 | OPC_CheckField, 11, 5, 0, // 1005: check Inst[15:11] == 0x0 |
| 3667 | OPC_Decode, 185, 9, 209, 1, // 1009: decode to CLASS_S_MMR6 using decoder 209 |
| 3668 | // 1009: } |
| 3669 | 112, 7, // 1014: case 0x70: { |
| 3670 | OPC_CheckPredicate, 27, // 1016: check predicate 27 |
| 3671 | OPC_Decode, 189, 14, 210, 1, // 1018: decode to FSUB_S_MMR6 using decoder 210 |
| 3672 | // 1018: } |
| 3673 | 120, 7, // 1023: case 0x78: { |
| 3674 | OPC_CheckPredicate, 3, // 1025: check predicate 3 |
| 3675 | OPC_Decode, 160, 21, 208, 1, // 1027: decode to SELNEZ_S_MMR6 using decoder 208 |
| 3676 | // 1027: } |
| 3677 | 123, 21, // 1032: case 0x7b: { |
| 3678 | OPC_SwitchField, 11, 5, // 1034: switch Inst[15:11] { |
| 3679 | 0, 7, // 1037: case 0x0: { |
| 3680 | OPC_CheckPredicate, 27, // 1039: check predicate 27 |
| 3681 | OPC_Decode, 134, 14, 169, 1, // 1041: decode to FMOV_S_MMR6 using decoder 169 |
| 3682 | // 1041: } |
| 3683 | 4, 0, // 1046: case 0x4: { |
| 3684 | OPC_CheckPredicate, 27, // 1048: check predicate 27 |
| 3685 | OPC_Decode, 131, 14, 167, 1, // 1050: decode to FMOV_D_MMR6 using decoder 167 |
| 3686 | // 1050: } |
| 3687 | // 1050: } // switch Inst[15:11] |
| 3688 | // 1050: } |
| 3689 | 133, 1, 7, // 1055: case 0x85: { |
| 3690 | OPC_CheckPredicate, 27, // 1058: check predicate 27 |
| 3691 | OPC_Decode, 253, 9, 208, 1, // 1060: decode to CMP_EQ_S_MMR6 using decoder 208 |
| 3692 | // 1060: } |
| 3693 | 149, 1, 7, // 1065: case 0x95: { |
| 3694 | OPC_CheckPredicate, 27, // 1068: check predicate 27 |
| 3695 | OPC_Decode, 249, 9, 197, 1, // 1070: decode to CMP_EQ_D_MMR6 using decoder 197 |
| 3696 | // 1070: } |
| 3697 | 176, 1, 7, // 1075: case 0xb0: { |
| 3698 | OPC_CheckPredicate, 27, // 1078: check predicate 27 |
| 3699 | OPC_Decode, 145, 14, 210, 1, // 1080: decode to FMUL_S_MMR6 using decoder 210 |
| 3700 | // 1080: } |
| 3701 | 184, 1, 7, // 1085: case 0xb8: { |
| 3702 | OPC_CheckPredicate, 3, // 1088: check predicate 3 |
| 3703 | OPC_Decode, 164, 21, 211, 1, // 1090: decode to SEL_S_MMR6 using decoder 211 |
| 3704 | // 1090: } |
| 3705 | 197, 1, 7, // 1095: case 0xc5: { |
| 3706 | OPC_CheckPredicate, 27, // 1098: check predicate 27 |
| 3707 | OPC_Decode, 175, 10, 208, 1, // 1100: decode to CMP_UEQ_S_MMR6 using decoder 208 |
| 3708 | // 1100: } |
| 3709 | 213, 1, 7, // 1105: case 0xd5: { |
| 3710 | OPC_CheckPredicate, 27, // 1108: check predicate 27 |
| 3711 | OPC_Decode, 173, 10, 197, 1, // 1110: decode to CMP_UEQ_D_MMR6 using decoder 197 |
| 3712 | // 1110: } |
| 3713 | 240, 1, 7, // 1115: case 0xf0: { |
| 3714 | OPC_CheckPredicate, 27, // 1118: check predicate 27 |
| 3715 | OPC_Decode, 210, 13, 210, 1, // 1120: decode to FDIV_S_MMR6 using decoder 210 |
| 3716 | // 1120: } |
| 3717 | 133, 2, 7, // 1125: case 0x105: { |
| 3718 | OPC_CheckPredicate, 27, // 1128: check predicate 27 |
| 3719 | OPC_Decode, 139, 10, 208, 1, // 1130: decode to CMP_LT_S_MMR6 using decoder 208 |
| 3720 | // 1130: } |
| 3721 | 149, 2, 7, // 1135: case 0x115: { |
| 3722 | OPC_CheckPredicate, 27, // 1138: check predicate 27 |
| 3723 | OPC_Decode, 135, 10, 197, 1, // 1140: decode to CMP_LT_D_MMR6 using decoder 197 |
| 3724 | // 1140: } |
| 3725 | 187, 2, 30, // 1145: case 0x13b: { |
| 3726 | OPC_SwitchField, 11, 5, // 1148: switch Inst[15:11] { |
| 3727 | 0, 7, // 1151: case 0x0: { |
| 3728 | OPC_CheckPredicate, 27, // 1153: check predicate 27 |
| 3729 | OPC_Decode, 228, 10, 166, 1, // 1155: decode to CVT_L_S_MMR6 using decoder 166 |
| 3730 | // 1155: } |
| 3731 | 1, 7, // 1160: case 0x1: { |
| 3732 | OPC_CheckPredicate, 27, // 1162: check predicate 27 |
| 3733 | OPC_Decode, 249, 10, 169, 1, // 1164: decode to CVT_W_S_MMR6 using decoder 169 |
| 3734 | // 1164: } |
| 3735 | 8, 0, // 1169: case 0x8: { |
| 3736 | OPC_CheckPredicate, 27, // 1171: check predicate 27 |
| 3737 | OPC_Decode, 225, 10, 167, 1, // 1173: decode to CVT_L_D_MMR6 using decoder 167 |
| 3738 | // 1173: } |
| 3739 | // 1173: } // switch Inst[15:11] |
| 3740 | // 1173: } |
| 3741 | 197, 2, 7, // 1178: case 0x145: { |
| 3742 | OPC_CheckPredicate, 27, // 1181: check predicate 27 |
| 3743 | OPC_Decode, 183, 10, 208, 1, // 1183: decode to CMP_ULT_S_MMR6 using decoder 208 |
| 3744 | // 1183: } |
| 3745 | 213, 2, 7, // 1188: case 0x155: { |
| 3746 | OPC_CheckPredicate, 27, // 1191: check predicate 27 |
| 3747 | OPC_Decode, 181, 10, 197, 1, // 1193: decode to CMP_ULT_D_MMR6 using decoder 197 |
| 3748 | // 1193: } |
| 3749 | 133, 3, 7, // 1198: case 0x185: { |
| 3750 | OPC_CheckPredicate, 27, // 1201: check predicate 27 |
| 3751 | OPC_Decode, 133, 10, 208, 1, // 1203: decode to CMP_LE_S_MMR6 using decoder 208 |
| 3752 | // 1203: } |
| 3753 | 149, 3, 7, // 1208: case 0x195: { |
| 3754 | OPC_CheckPredicate, 27, // 1211: check predicate 27 |
| 3755 | OPC_Decode, 129, 10, 197, 1, // 1213: decode to CMP_LE_D_MMR6 using decoder 197 |
| 3756 | // 1213: } |
| 3757 | 184, 3, 7, // 1218: case 0x1b8: { |
| 3758 | OPC_CheckPredicate, 27, // 1221: check predicate 27 |
| 3759 | OPC_Decode, 227, 16, 211, 1, // 1223: decode to MADDF_S_MMR6 using decoder 211 |
| 3760 | // 1223: } |
| 3761 | 197, 3, 7, // 1228: case 0x1c5: { |
| 3762 | OPC_CheckPredicate, 27, // 1231: check predicate 27 |
| 3763 | OPC_Decode, 179, 10, 208, 1, // 1233: decode to CMP_ULE_S_MMR6 using decoder 208 |
| 3764 | // 1233: } |
| 3765 | 213, 3, 7, // 1238: case 0x1d5: { |
| 3766 | OPC_CheckPredicate, 27, // 1241: check predicate 27 |
| 3767 | OPC_Decode, 177, 10, 197, 1, // 1243: decode to CMP_ULE_D_MMR6 using decoder 197 |
| 3768 | // 1243: } |
| 3769 | 248, 3, 7, // 1248: case 0x1f8: { |
| 3770 | OPC_CheckPredicate, 27, // 1251: check predicate 27 |
| 3771 | OPC_Decode, 161, 18, 211, 1, // 1253: decode to MSUBF_S_MMR6 using decoder 211 |
| 3772 | // 1253: } |
| 3773 | 131, 4, 7, // 1258: case 0x203: { |
| 3774 | OPC_CheckPredicate, 27, // 1261: check predicate 27 |
| 3775 | OPC_Decode, 207, 17, 197, 1, // 1263: decode to MIN_D_MMR6 using decoder 197 |
| 3776 | // 1263: } |
| 3777 | 133, 4, 7, // 1268: case 0x205: { |
| 3778 | OPC_CheckPredicate, 27, // 1271: check predicate 27 |
| 3779 | OPC_Decode, 143, 10, 208, 1, // 1273: decode to CMP_SAF_S_MMR6 using decoder 208 |
| 3780 | // 1273: } |
| 3781 | 139, 4, 7, // 1278: case 0x20b: { |
| 3782 | OPC_CheckPredicate, 27, // 1281: check predicate 27 |
| 3783 | OPC_Decode, 145, 17, 197, 1, // 1283: decode to MAX_D_MMR6 using decoder 197 |
| 3784 | // 1283: } |
| 3785 | 149, 4, 7, // 1288: case 0x215: { |
| 3786 | OPC_CheckPredicate, 27, // 1291: check predicate 27 |
| 3787 | OPC_Decode, 141, 10, 197, 1, // 1293: decode to CMP_SAF_D_MMR6 using decoder 197 |
| 3788 | // 1293: } |
| 3789 | 160, 4, 11, // 1298: case 0x220: { |
| 3790 | OPC_CheckPredicate, 3, // 1301: check predicate 3 |
| 3791 | OPC_CheckField, 11, 5, 0, // 1303: check Inst[15:11] == 0x0 |
| 3792 | OPC_Decode, 177, 20, 212, 1, // 1307: decode to RINT_D_MMR6 using decoder 212 |
| 3793 | // 1307: } |
| 3794 | 163, 4, 7, // 1312: case 0x223: { |
| 3795 | OPC_CheckPredicate, 27, // 1315: check predicate 27 |
| 3796 | OPC_Decode, 191, 17, 197, 1, // 1317: decode to MINA_D_MMR6 using decoder 197 |
| 3797 | // 1317: } |
| 3798 | 171, 4, 7, // 1322: case 0x22b: { |
| 3799 | OPC_CheckPredicate, 27, // 1325: check predicate 27 |
| 3800 | OPC_Decode, 129, 17, 197, 1, // 1327: decode to MAXA_D_MMR6 using decoder 197 |
| 3801 | // 1327: } |
| 3802 | 184, 4, 7, // 1332: case 0x238: { |
| 3803 | OPC_CheckPredicate, 3, // 1335: check predicate 3 |
| 3804 | OPC_Decode, 150, 21, 197, 1, // 1337: decode to SELEQZ_D_MMR6 using decoder 197 |
| 3805 | // 1337: } |
| 3806 | 197, 4, 7, // 1342: case 0x245: { |
| 3807 | OPC_CheckPredicate, 27, // 1345: check predicate 27 |
| 3808 | OPC_Decode, 171, 10, 208, 1, // 1347: decode to CMP_SUN_S_MMR6 using decoder 208 |
| 3809 | // 1347: } |
| 3810 | 213, 4, 7, // 1352: case 0x255: { |
| 3811 | OPC_CheckPredicate, 27, // 1355: check predicate 27 |
| 3812 | OPC_Decode, 169, 10, 197, 1, // 1357: decode to CMP_SUN_D_MMR6 using decoder 197 |
| 3813 | // 1357: } |
| 3814 | 224, 4, 11, // 1362: case 0x260: { |
| 3815 | OPC_CheckPredicate, 3, // 1365: check predicate 3 |
| 3816 | OPC_CheckField, 11, 5, 0, // 1367: check Inst[15:11] == 0x0 |
| 3817 | OPC_Decode, 183, 9, 212, 1, // 1371: decode to CLASS_D_MMR6 using decoder 212 |
| 3818 | // 1371: } |
| 3819 | 248, 4, 7, // 1376: case 0x278: { |
| 3820 | OPC_CheckPredicate, 3, // 1379: check predicate 3 |
| 3821 | OPC_Decode, 157, 21, 197, 1, // 1381: decode to SELNEZ_D_MMR6 using decoder 197 |
| 3822 | // 1381: } |
| 3823 | 133, 5, 7, // 1386: case 0x285: { |
| 3824 | OPC_CheckPredicate, 27, // 1389: check predicate 27 |
| 3825 | OPC_Decode, 147, 10, 208, 1, // 1391: decode to CMP_SEQ_S_MMR6 using decoder 208 |
| 3826 | // 1391: } |
| 3827 | 149, 5, 7, // 1396: case 0x295: { |
| 3828 | OPC_CheckPredicate, 27, // 1399: check predicate 27 |
| 3829 | OPC_Decode, 145, 10, 197, 1, // 1401: decode to CMP_SEQ_D_MMR6 using decoder 197 |
| 3830 | // 1401: } |
| 3831 | 184, 5, 7, // 1406: case 0x2b8: { |
| 3832 | OPC_CheckPredicate, 3, // 1409: check predicate 3 |
| 3833 | OPC_Decode, 162, 21, 213, 1, // 1411: decode to SEL_D_MMR6 using decoder 213 |
| 3834 | // 1411: } |
| 3835 | 197, 5, 7, // 1416: case 0x2c5: { |
| 3836 | OPC_CheckPredicate, 27, // 1419: check predicate 27 |
| 3837 | OPC_Decode, 159, 10, 208, 1, // 1421: decode to CMP_SUEQ_S_MMR6 using decoder 208 |
| 3838 | // 1421: } |
| 3839 | 213, 5, 7, // 1426: case 0x2d5: { |
| 3840 | OPC_CheckPredicate, 27, // 1429: check predicate 27 |
| 3841 | OPC_Decode, 157, 10, 197, 1, // 1431: decode to CMP_SUEQ_D_MMR6 using decoder 197 |
| 3842 | // 1431: } |
| 3843 | 133, 6, 7, // 1436: case 0x305: { |
| 3844 | OPC_CheckPredicate, 27, // 1439: check predicate 27 |
| 3845 | OPC_Decode, 155, 10, 208, 1, // 1441: decode to CMP_SLT_S_MMR6 using decoder 208 |
| 3846 | // 1441: } |
| 3847 | 149, 6, 7, // 1446: case 0x315: { |
| 3848 | OPC_CheckPredicate, 27, // 1449: check predicate 27 |
| 3849 | OPC_Decode, 153, 10, 197, 1, // 1451: decode to CMP_SLT_D_MMR6 using decoder 197 |
| 3850 | // 1451: } |
| 3851 | 187, 6, 147, 1, // 1456: case 0x33b: { |
| 3852 | OPC_SwitchField, 11, 5, // 1460: switch Inst[15:11] { |
| 3853 | 0, 7, // 1463: case 0x0: { |
| 3854 | OPC_CheckPredicate, 27, // 1465: check predicate 27 |
| 3855 | OPC_Decode, 237, 13, 166, 1, // 1467: decode to FLOOR_L_S_MMR6 using decoder 166 |
| 3856 | // 1467: } |
| 3857 | 1, 7, // 1472: case 0x1: { |
| 3858 | OPC_CheckPredicate, 27, // 1474: check predicate 27 |
| 3859 | OPC_Decode, 244, 13, 169, 1, // 1476: decode to FLOOR_W_S_MMR6 using decoder 169 |
| 3860 | // 1476: } |
| 3861 | 2, 7, // 1481: case 0x2: { |
| 3862 | OPC_CheckPredicate, 27, // 1483: check predicate 27 |
| 3863 | OPC_Decode, 158, 9, 166, 1, // 1485: decode to CEIL_L_S_MMR6 using decoder 166 |
| 3864 | // 1485: } |
| 3865 | 3, 7, // 1490: case 0x3: { |
| 3866 | OPC_CheckPredicate, 27, // 1492: check predicate 27 |
| 3867 | OPC_Decode, 165, 9, 169, 1, // 1494: decode to CEIL_W_S_MMR6 using decoder 169 |
| 3868 | // 1494: } |
| 3869 | 4, 7, // 1499: case 0x4: { |
| 3870 | OPC_CheckPredicate, 27, // 1501: check predicate 27 |
| 3871 | OPC_Decode, 156, 24, 166, 1, // 1503: decode to TRUNC_L_S_MMR6 using decoder 166 |
| 3872 | // 1503: } |
| 3873 | 5, 7, // 1508: case 0x5: { |
| 3874 | OPC_CheckPredicate, 27, // 1510: check predicate 27 |
| 3875 | OPC_Decode, 163, 24, 169, 1, // 1512: decode to TRUNC_W_S_MMR6 using decoder 169 |
| 3876 | // 1512: } |
| 3877 | 6, 7, // 1517: case 0x6: { |
| 3878 | OPC_CheckPredicate, 27, // 1519: check predicate 27 |
| 3879 | OPC_Decode, 190, 20, 166, 1, // 1521: decode to ROUND_L_S_MMR6 using decoder 166 |
| 3880 | // 1521: } |
| 3881 | 7, 7, // 1526: case 0x7: { |
| 3882 | OPC_CheckPredicate, 27, // 1528: check predicate 27 |
| 3883 | OPC_Decode, 197, 20, 169, 1, // 1530: decode to ROUND_W_S_MMR6 using decoder 169 |
| 3884 | // 1530: } |
| 3885 | 8, 7, // 1535: case 0x8: { |
| 3886 | OPC_CheckPredicate, 27, // 1537: check predicate 27 |
| 3887 | OPC_Decode, 235, 13, 167, 1, // 1539: decode to FLOOR_L_D_MMR6 using decoder 167 |
| 3888 | // 1539: } |
| 3889 | 9, 7, // 1544: case 0x9: { |
| 3890 | OPC_CheckPredicate, 27, // 1546: check predicate 27 |
| 3891 | OPC_Decode, 240, 13, 171, 1, // 1548: decode to FLOOR_W_D_MMR6 using decoder 171 |
| 3892 | // 1548: } |
| 3893 | 10, 7, // 1553: case 0xa: { |
| 3894 | OPC_CheckPredicate, 27, // 1555: check predicate 27 |
| 3895 | OPC_Decode, 156, 9, 167, 1, // 1557: decode to CEIL_L_D_MMR6 using decoder 167 |
| 3896 | // 1557: } |
| 3897 | 11, 7, // 1562: case 0xb: { |
| 3898 | OPC_CheckPredicate, 27, // 1564: check predicate 27 |
| 3899 | OPC_Decode, 161, 9, 171, 1, // 1566: decode to CEIL_W_D_MMR6 using decoder 171 |
| 3900 | // 1566: } |
| 3901 | 12, 7, // 1571: case 0xc: { |
| 3902 | OPC_CheckPredicate, 27, // 1573: check predicate 27 |
| 3903 | OPC_Decode, 154, 24, 167, 1, // 1575: decode to TRUNC_L_D_MMR6 using decoder 167 |
| 3904 | // 1575: } |
| 3905 | 13, 7, // 1580: case 0xd: { |
| 3906 | OPC_CheckPredicate, 27, // 1582: check predicate 27 |
| 3907 | OPC_Decode, 159, 24, 198, 1, // 1584: decode to TRUNC_W_D_MMR6 using decoder 198 |
| 3908 | // 1584: } |
| 3909 | 14, 7, // 1589: case 0xe: { |
| 3910 | OPC_CheckPredicate, 27, // 1591: check predicate 27 |
| 3911 | OPC_Decode, 188, 20, 167, 1, // 1593: decode to ROUND_L_D_MMR6 using decoder 167 |
| 3912 | // 1593: } |
| 3913 | 15, 0, // 1598: case 0xf: { |
| 3914 | OPC_CheckPredicate, 27, // 1600: check predicate 27 |
| 3915 | OPC_Decode, 193, 20, 167, 1, // 1602: decode to ROUND_W_D_MMR6 using decoder 167 |
| 3916 | // 1602: } |
| 3917 | // 1602: } // switch Inst[15:11] |
| 3918 | // 1602: } |
| 3919 | 197, 6, 7, // 1607: case 0x345: { |
| 3920 | OPC_CheckPredicate, 27, // 1610: check predicate 27 |
| 3921 | OPC_Decode, 167, 10, 208, 1, // 1612: decode to CMP_SULT_S_MMR6 using decoder 208 |
| 3922 | // 1612: } |
| 3923 | 213, 6, 7, // 1617: case 0x355: { |
| 3924 | OPC_CheckPredicate, 27, // 1620: check predicate 27 |
| 3925 | OPC_Decode, 165, 10, 197, 1, // 1622: decode to CMP_SULT_D_MMR6 using decoder 197 |
| 3926 | // 1622: } |
| 3927 | 251, 6, 39, // 1627: case 0x37b: { |
| 3928 | OPC_SwitchField, 11, 5, // 1630: switch Inst[15:11] { |
| 3929 | 1, 7, // 1633: case 0x1: { |
| 3930 | OPC_CheckPredicate, 27, // 1635: check predicate 27 |
| 3931 | OPC_Decode, 153, 14, 169, 1, // 1637: decode to FNEG_S_MMR6 using decoder 169 |
| 3932 | // 1637: } |
| 3933 | 7, 7, // 1642: case 0x7: { |
| 3934 | OPC_CheckPredicate, 27, // 1644: check predicate 27 |
| 3935 | OPC_Decode, 242, 10, 169, 1, // 1646: decode to CVT_S_W_MMR6 using decoder 169 |
| 3936 | // 1646: } |
| 3937 | 10, 7, // 1651: case 0xa: { |
| 3938 | OPC_CheckPredicate, 25, // 1653: check predicate 25 |
| 3939 | OPC_Decode, 222, 10, 167, 1, // 1655: decode to CVT_D_L_MMR6 using decoder 167 |
| 3940 | // 1655: } |
| 3941 | 11, 0, // 1660: case 0xb: { |
| 3942 | OPC_CheckPredicate, 25, // 1662: check predicate 25 |
| 3943 | OPC_Decode, 237, 10, 166, 1, // 1664: decode to CVT_S_L_MMR6 using decoder 166 |
| 3944 | // 1664: } |
| 3945 | // 1664: } // switch Inst[15:11] |
| 3946 | // 1664: } |
| 3947 | 133, 7, 7, // 1669: case 0x385: { |
| 3948 | OPC_CheckPredicate, 27, // 1672: check predicate 27 |
| 3949 | OPC_Decode, 151, 10, 208, 1, // 1674: decode to CMP_SLE_S_MMR6 using decoder 208 |
| 3950 | // 1674: } |
| 3951 | 149, 7, 7, // 1679: case 0x395: { |
| 3952 | OPC_CheckPredicate, 27, // 1682: check predicate 27 |
| 3953 | OPC_Decode, 149, 10, 197, 1, // 1684: decode to CMP_SLE_D_MMR6 using decoder 197 |
| 3954 | // 1684: } |
| 3955 | 184, 7, 7, // 1689: case 0x3b8: { |
| 3956 | OPC_CheckPredicate, 27, // 1692: check predicate 27 |
| 3957 | OPC_Decode, 225, 16, 213, 1, // 1694: decode to MADDF_D_MMR6 using decoder 213 |
| 3958 | // 1694: } |
| 3959 | 197, 7, 7, // 1699: case 0x3c5: { |
| 3960 | OPC_CheckPredicate, 27, // 1702: check predicate 27 |
| 3961 | OPC_Decode, 163, 10, 208, 1, // 1704: decode to CMP_SULE_S_MMR6 using decoder 208 |
| 3962 | // 1704: } |
| 3963 | 213, 7, 7, // 1709: case 0x3d5: { |
| 3964 | OPC_CheckPredicate, 27, // 1712: check predicate 27 |
| 3965 | OPC_Decode, 161, 10, 197, 1, // 1714: decode to CMP_SULE_D_MMR6 using decoder 197 |
| 3966 | // 1714: } |
| 3967 | 248, 7, 0, // 1719: case 0x3f8: { |
| 3968 | OPC_CheckPredicate, 27, // 1722: check predicate 27 |
| 3969 | OPC_Decode, 159, 18, 213, 1, // 1724: decode to MSUBF_D_MMR6 using decoder 213 |
| 3970 | // 1724: } |
| 3971 | // 1724: } // switch Inst[10:0] |
| 3972 | // 1724: } |
| 3973 | 24, 38, // 1729: case 0x18: { |
| 3974 | OPC_SwitchField, 12, 4, // 1731: switch Inst[15:12] { |
| 3975 | 2, 7, // 1734: case 0x2: { |
| 3976 | OPC_CheckPredicate, 3, // 1736: check predicate 3 |
| 3977 | OPC_Decode, 140, 20, 145, 1, // 1738: decode to PREF_MMR6 using decoder 145 |
| 3978 | // 1738: } |
| 3979 | 3, 11, // 1743: case 0x3: { |
| 3980 | OPC_CheckPredicate, 3, // 1745: check predicate 3 |
| 3981 | OPC_CheckField, 9, 3, 0, // 1747: check Inst[11:9] == 0x0 |
| 3982 | OPC_Decode, 144, 16, 182, 1, // 1751: decode to LL_MMR6 using decoder 182 |
| 3983 | // 1751: } |
| 3984 | 11, 0, // 1756: case 0xb: { |
| 3985 | OPC_CheckPredicate, 3, // 1758: check predicate 3 |
| 3986 | OPC_CheckField, 9, 3, 0, // 1760: check Inst[11:9] == 0x0 |
| 3987 | OPC_Decode, 240, 20, 185, 1, // 1764: decode to SC_MMR6 using decoder 185 |
| 3988 | // 1764: } |
| 3989 | // 1764: } // switch Inst[15:12] |
| 3990 | // 1764: } |
| 3991 | 28, 7, // 1769: case 0x1c: { |
| 3992 | OPC_CheckPredicate, 3, // 1771: check predicate 3 |
| 3993 | OPC_Decode, 197, 24, 153, 1, // 1773: decode to XORI_MMR6 using decoder 153 |
| 3994 | // 1773: } |
| 3995 | 29, 20, // 1778: case 0x1d: { |
| 3996 | OPC_Scope, 11, // 1780: try { |
| 3997 | OPC_CheckField, 16, 5, 0, // 1782: check Inst[20:16] == 0x0 |
| 3998 | OPC_CheckPredicate, 3, // 1786: check predicate 3 |
| 3999 | OPC_Decode, 234, 7, 214, 1, // 1788: decode to BEQZALC_MMR6 using decoder 214 |
| 4000 | // 1788: } else try { |
| 4001 | OPC_CheckPredicate, 3, // 1793: check predicate 3 |
| 4002 | OPC_Decode, 228, 7, 214, 1, // 1795: decode to BEQC_MMR6 using decoder 214 |
| 4003 | // 1795: } |
| 4004 | // 1795: } |
| 4005 | 30, 44, // 1800: case 0x1e: { |
| 4006 | OPC_SwitchField, 19, 2, // 1802: switch Inst[20:19] { |
| 4007 | 0, 7, // 1805: case 0x0: { |
| 4008 | OPC_CheckPredicate, 3, // 1807: check predicate 3 |
| 4009 | OPC_Decode, 166, 6, 215, 1, // 1809: decode to ADDIUPC_MMR6 using decoder 215 |
| 4010 | // 1809: } |
| 4011 | 1, 7, // 1814: case 0x1: { |
| 4012 | OPC_CheckPredicate, 3, // 1816: check predicate 3 |
| 4013 | OPC_Decode, 187, 16, 215, 1, // 1818: decode to LWPC_MMR6 using decoder 215 |
| 4014 | // 1818: } |
| 4015 | 3, 0, // 1823: case 0x3: { |
| 4016 | OPC_SwitchField, 16, 3, // 1825: switch Inst[18:16] { |
| 4017 | 6, 7, // 1828: case 0x6: { |
| 4018 | OPC_CheckPredicate, 3, // 1830: check predicate 3 |
| 4019 | OPC_Decode, 154, 7, 216, 1, // 1832: decode to AUIPC_MMR6 using decoder 216 |
| 4020 | // 1832: } |
| 4021 | 7, 0, // 1837: case 0x7: { |
| 4022 | OPC_CheckPredicate, 3, // 1839: check predicate 3 |
| 4023 | OPC_Decode, 250, 6, 216, 1, // 1841: decode to ALUIPC_MMR6 using decoder 216 |
| 4024 | // 1841: } |
| 4025 | // 1841: } // switch Inst[18:16] |
| 4026 | // 1841: } |
| 4027 | // 1841: } // switch Inst[20:19] |
| 4028 | // 1841: } |
| 4029 | 31, 20, // 1846: case 0x1f: { |
| 4030 | OPC_Scope, 11, // 1848: try { |
| 4031 | OPC_CheckField, 16, 5, 0, // 1850: check Inst[20:16] == 0x0 |
| 4032 | OPC_CheckPredicate, 3, // 1854: check predicate 3 |
| 4033 | OPC_Decode, 221, 8, 217, 1, // 1856: decode to BNEZALC_MMR6 using decoder 217 |
| 4034 | // 1856: } else try { |
| 4035 | OPC_CheckPredicate, 3, // 1861: check predicate 3 |
| 4036 | OPC_Decode, 207, 8, 217, 1, // 1863: decode to BNEC_MMR6 using decoder 217 |
| 4037 | // 1863: } |
| 4038 | // 1863: } |
| 4039 | 32, 20, // 1868: case 0x20: { |
| 4040 | OPC_Scope, 11, // 1870: try { |
| 4041 | OPC_CheckField, 21, 5, 0, // 1872: check Inst[25:21] == 0x0 |
| 4042 | OPC_CheckPredicate, 3, // 1876: check predicate 3 |
| 4043 | OPC_Decode, 156, 15, 148, 1, // 1878: decode to JIALC_MMR6 using decoder 148 |
| 4044 | // 1878: } else try { |
| 4045 | OPC_CheckPredicate, 3, // 1883: check predicate 3 |
| 4046 | OPC_Decode, 240, 7, 218, 1, // 1885: decode to BEQZC_MMR6 using decoder 218 |
| 4047 | // 1885: } |
| 4048 | // 1885: } |
| 4049 | 37, 7, // 1890: case 0x25: { |
| 4050 | OPC_CheckPredicate, 3, // 1892: check predicate 3 |
| 4051 | OPC_Decode, 222, 7, 219, 1, // 1894: decode to BC_MMR6 using decoder 219 |
| 4052 | // 1894: } |
| 4053 | 40, 20, // 1899: case 0x28: { |
| 4054 | OPC_Scope, 11, // 1901: try { |
| 4055 | OPC_CheckField, 21, 5, 0, // 1903: check Inst[25:21] == 0x0 |
| 4056 | OPC_CheckPredicate, 3, // 1907: check predicate 3 |
| 4057 | OPC_Decode, 159, 15, 148, 1, // 1909: decode to JIC_MMR6 using decoder 148 |
| 4058 | // 1909: } else try { |
| 4059 | OPC_CheckPredicate, 3, // 1914: check predicate 3 |
| 4060 | OPC_Decode, 227, 8, 218, 1, // 1916: decode to BNEZC_MMR6 using decoder 218 |
| 4061 | // 1916: } |
| 4062 | // 1916: } |
| 4063 | 45, 7, // 1921: case 0x2d: { |
| 4064 | OPC_CheckPredicate, 3, // 1923: check predicate 3 |
| 4065 | OPC_Decode, 186, 7, 219, 1, // 1925: decode to BALC_MMR6 using decoder 219 |
| 4066 | // 1925: } |
| 4067 | 48, 7, // 1930: case 0x30: { |
| 4068 | OPC_CheckPredicate, 3, // 1932: check predicate 3 |
| 4069 | OPC_Decode, 250, 7, 220, 1, // 1934: decode to BGEUC_MMR6 using decoder 220 |
| 4070 | // 1934: } |
| 4071 | 52, 7, // 1939: case 0x34: { |
| 4072 | OPC_CheckPredicate, 3, // 1941: check predicate 3 |
| 4073 | OPC_Decode, 133, 7, 153, 1, // 1943: decode to ANDI_MMR6 using decoder 153 |
| 4074 | // 1943: } |
| 4075 | 53, 7, // 1948: case 0x35: { |
| 4076 | OPC_CheckPredicate, 3, // 1950: check predicate 3 |
| 4077 | OPC_Decode, 178, 8, 221, 1, // 1952: decode to BLTC_MMR6 using decoder 221 |
| 4078 | // 1952: } |
| 4079 | 56, 7, // 1957: case 0x38: { |
| 4080 | OPC_CheckPredicate, 3, // 1959: check predicate 3 |
| 4081 | OPC_Decode, 184, 8, 222, 1, // 1961: decode to BLTUC_MMR6 using decoder 222 |
| 4082 | // 1961: } |
| 4083 | 61, 7, // 1966: case 0x3d: { |
| 4084 | OPC_CheckPredicate, 3, // 1968: check predicate 3 |
| 4085 | OPC_Decode, 244, 7, 223, 1, // 1970: decode to BGEC_MMR6 using decoder 223 |
| 4086 | // 1970: } |
| 4087 | 62, 7, // 1975: case 0x3e: { |
| 4088 | OPC_CheckPredicate, 3, // 1977: check predicate 3 |
| 4089 | OPC_Decode, 195, 23, 142, 1, // 1979: decode to SW_MMR6 using decoder 142 |
| 4090 | // 1979: } |
| 4091 | 63, 0, // 1984: case 0x3f: { |
| 4092 | OPC_CheckPredicate, 3, // 1986: check predicate 3 |
| 4093 | OPC_Decode, 208, 16, 142, 1, // 1988: decode to LW_MMR6 using decoder 142 |
| 4094 | // 1988: } |
| 4095 | // 1988: } // switch Inst[31:26] |
| 4096 | }; |
| 4097 | static const uint8_t DecoderTableMicroMipsR6_Ambiguous32[65] = { |
| 4098 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 4099 | 29, 7, // 3: case 0x1d: { |
| 4100 | OPC_CheckPredicate, 3, // 5: check predicate 3 |
| 4101 | OPC_Decode, 237, 8, 214, 1, // 7: decode to BOVC_MMR6 using decoder 214 |
| 4102 | // 7: } |
| 4103 | 31, 7, // 12: case 0x1f: { |
| 4104 | OPC_CheckPredicate, 3, // 14: check predicate 3 |
| 4105 | OPC_Decode, 230, 8, 217, 1, // 16: decode to BNVC_MMR6 using decoder 217 |
| 4106 | // 16: } |
| 4107 | 48, 20, // 21: case 0x30: { |
| 4108 | OPC_Scope, 11, // 23: try { |
| 4109 | OPC_CheckField, 16, 5, 0, // 25: check Inst[20:16] == 0x0 |
| 4110 | OPC_CheckPredicate, 3, // 29: check predicate 3 |
| 4111 | OPC_Decode, 170, 8, 220, 1, // 31: decode to BLEZALC_MMR6 using decoder 220 |
| 4112 | // 31: } else try { |
| 4113 | OPC_CheckPredicate, 3, // 36: check predicate 3 |
| 4114 | OPC_Decode, 128, 8, 220, 1, // 38: decode to BGEZALC_MMR6 using decoder 220 |
| 4115 | // 38: } |
| 4116 | // 38: } |
| 4117 | 56, 0, // 43: case 0x38: { |
| 4118 | OPC_Scope, 11, // 45: try { |
| 4119 | OPC_CheckField, 16, 5, 0, // 47: check Inst[20:16] == 0x0 |
| 4120 | OPC_CheckPredicate, 3, // 51: check predicate 3 |
| 4121 | OPC_Decode, 140, 8, 222, 1, // 53: decode to BGTZALC_MMR6 using decoder 222 |
| 4122 | // 53: } else try { |
| 4123 | OPC_CheckPredicate, 3, // 58: check predicate 3 |
| 4124 | OPC_Decode, 190, 8, 222, 1, // 60: decode to BLTZALC_MMR6 using decoder 222 |
| 4125 | // 60: } |
| 4126 | // 60: } |
| 4127 | // 60: } // switch Inst[31:26] |
| 4128 | }; |
| 4129 | static const uint8_t DecoderTableMips32[10278] = { |
| 4130 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 4131 | 0, 159, 5, // 3: case 0x0: { |
| 4132 | OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] { |
| 4133 | 0, 40, // 9: case 0x0: { |
| 4134 | OPC_CheckField, 21, 5, 0, // 11: check Inst[25:21] == 0x0 |
| 4135 | OPC_Scope, 27, // 15: try { |
| 4136 | OPC_SwitchField, 6, 15, // 17: switch Inst[20:6] { |
| 4137 | 1, 6, // 20: case 0x1: { |
| 4138 | OPC_CheckPredicate, 28, // 22: check predicate 28 |
| 4139 | OPC_Decode, 210, 22, 10, // 24: decode to SSNOP using decoder 10 |
| 4140 | // 24: } |
| 4141 | 3, 6, // 28: case 0x3: { |
| 4142 | OPC_CheckPredicate, 28, // 30: check predicate 28 |
| 4143 | OPC_Decode, 235, 12, 10, // 32: decode to EHB using decoder 10 |
| 4144 | // 32: } |
| 4145 | 5, 0, // 36: case 0x5: { |
| 4146 | OPC_CheckPredicate, 29, // 38: check predicate 29 |
| 4147 | OPC_Decode, 206, 19, 10, // 40: decode to PAUSE using decoder 10 |
| 4148 | // 40: } |
| 4149 | // 40: } // switch Inst[20:6] |
| 4150 | // 40: } else try { |
| 4151 | OPC_CheckPredicate, 28, // 44: check predicate 28 |
| 4152 | OPC_Decode, 244, 21, 224, 1, // 46: decode to SLL using decoder 224 |
| 4153 | // 46: } |
| 4154 | // 46: } |
| 4155 | 1, 29, // 51: case 0x1: { |
| 4156 | OPC_SwitchField, 16, 2, // 53: switch Inst[17:16] { |
| 4157 | 0, 11, // 56: case 0x0: { |
| 4158 | OPC_CheckPredicate, 30, // 58: check predicate 30 |
| 4159 | OPC_CheckField, 6, 5, 0, // 60: check Inst[10:6] == 0x0 |
| 4160 | OPC_Decode, 246, 17, 225, 1, // 64: decode to MOVF_I using decoder 225 |
| 4161 | // 64: } |
| 4162 | 1, 0, // 69: case 0x1: { |
| 4163 | OPC_CheckPredicate, 30, // 71: check predicate 30 |
| 4164 | OPC_CheckField, 6, 5, 0, // 73: check Inst[10:6] == 0x0 |
| 4165 | OPC_Decode, 139, 18, 225, 1, // 77: decode to MOVT_I using decoder 225 |
| 4166 | // 77: } |
| 4167 | // 77: } // switch Inst[17:16] |
| 4168 | // 77: } |
| 4169 | 2, 21, // 82: case 0x2: { |
| 4170 | OPC_SwitchField, 21, 5, // 84: switch Inst[25:21] { |
| 4171 | 0, 7, // 87: case 0x0: { |
| 4172 | OPC_CheckPredicate, 28, // 89: check predicate 28 |
| 4173 | OPC_Decode, 185, 22, 224, 1, // 91: decode to SRL using decoder 224 |
| 4174 | // 91: } |
| 4175 | 1, 0, // 96: case 0x1: { |
| 4176 | OPC_CheckPredicate, 29, // 98: check predicate 29 |
| 4177 | OPC_Decode, 180, 20, 224, 1, // 100: decode to ROTR using decoder 224 |
| 4178 | // 100: } |
| 4179 | // 100: } // switch Inst[25:21] |
| 4180 | // 100: } |
| 4181 | 3, 11, // 105: case 0x3: { |
| 4182 | OPC_CheckPredicate, 28, // 107: check predicate 28 |
| 4183 | OPC_CheckField, 21, 5, 0, // 109: check Inst[25:21] == 0x0 |
| 4184 | OPC_Decode, 163, 22, 224, 1, // 113: decode to SRA using decoder 224 |
| 4185 | // 113: } |
| 4186 | 4, 10, // 118: case 0x4: { |
| 4187 | OPC_CheckPredicate, 28, // 120: check predicate 28 |
| 4188 | OPC_CheckField, 6, 5, 0, // 122: check Inst[10:6] == 0x0 |
| 4189 | OPC_Decode, 254, 21, 98, // 126: decode to SLLV using decoder 98 |
| 4190 | // 126: } |
| 4191 | 5, 11, // 130: case 0x5: { |
| 4192 | OPC_CheckPredicate, 31, // 132: check predicate 31 |
| 4193 | OPC_CheckField, 8, 3, 0, // 134: check Inst[10:8] == 0x0 |
| 4194 | OPC_Decode, 147, 16, 226, 1, // 138: decode to LSA using decoder 226 |
| 4195 | // 138: } |
| 4196 | 6, 19, // 143: case 0x6: { |
| 4197 | OPC_SwitchField, 6, 5, // 145: switch Inst[10:6] { |
| 4198 | 0, 6, // 148: case 0x0: { |
| 4199 | OPC_CheckPredicate, 28, // 150: check predicate 28 |
| 4200 | OPC_Decode, 201, 22, 98, // 152: decode to SRLV using decoder 98 |
| 4201 | // 152: } |
| 4202 | 1, 0, // 156: case 0x1: { |
| 4203 | OPC_CheckPredicate, 29, // 158: check predicate 29 |
| 4204 | OPC_Decode, 181, 20, 98, // 160: decode to ROTRV using decoder 98 |
| 4205 | // 160: } |
| 4206 | // 160: } // switch Inst[10:6] |
| 4207 | // 160: } |
| 4208 | 7, 10, // 164: case 0x7: { |
| 4209 | OPC_CheckPredicate, 28, // 166: check predicate 28 |
| 4210 | OPC_CheckField, 6, 5, 0, // 168: check Inst[10:6] == 0x0 |
| 4211 | OPC_Decode, 176, 22, 98, // 172: decode to SRAV using decoder 98 |
| 4212 | // 172: } |
| 4213 | 8, 21, // 176: case 0x8: { |
| 4214 | OPC_SwitchField, 6, 15, // 178: switch Inst[20:6] { |
| 4215 | 0, 7, // 181: case 0x0: { |
| 4216 | OPC_CheckPredicate, 32, // 183: check predicate 32 |
| 4217 | OPC_Decode, 160, 15, 227, 1, // 185: decode to JR using decoder 227 |
| 4218 | // 185: } |
| 4219 | 16, 0, // 190: case 0x10: { |
| 4220 | OPC_CheckPredicate, 33, // 192: check predicate 33 |
| 4221 | OPC_Decode, 168, 15, 227, 1, // 194: decode to JR_HB using decoder 227 |
| 4222 | // 194: } |
| 4223 | // 194: } // switch Inst[20:6] |
| 4224 | // 194: } |
| 4225 | 9, 27, // 199: case 0x9: { |
| 4226 | OPC_SwitchField, 6, 5, // 201: switch Inst[10:6] { |
| 4227 | 0, 10, // 204: case 0x0: { |
| 4228 | OPC_CheckPredicate, 34, // 206: check predicate 34 |
| 4229 | OPC_CheckField, 16, 5, 0, // 208: check Inst[20:16] == 0x0 |
| 4230 | OPC_Decode, 135, 15, 89, // 212: decode to JALR using decoder 89 |
| 4231 | // 212: } |
| 4232 | 16, 0, // 216: case 0x10: { |
| 4233 | OPC_CheckPredicate, 35, // 218: check predicate 35 |
| 4234 | OPC_CheckField, 16, 5, 0, // 220: check Inst[20:16] == 0x0 |
| 4235 | OPC_Decode, 146, 15, 89, // 224: decode to JALR_HB using decoder 89 |
| 4236 | // 224: } |
| 4237 | // 224: } // switch Inst[10:6] |
| 4238 | // 224: } |
| 4239 | 10, 11, // 228: case 0xa: { |
| 4240 | OPC_CheckPredicate, 36, // 230: check predicate 36 |
| 4241 | OPC_CheckField, 6, 5, 0, // 232: check Inst[10:6] == 0x0 |
| 4242 | OPC_Decode, 151, 18, 228, 1, // 236: decode to MOVZ_I_I using decoder 228 |
| 4243 | // 236: } |
| 4244 | 11, 11, // 241: case 0xb: { |
| 4245 | OPC_CheckPredicate, 36, // 243: check predicate 36 |
| 4246 | OPC_CheckField, 6, 5, 0, // 245: check Inst[10:6] == 0x0 |
| 4247 | OPC_Decode, 130, 18, 228, 1, // 249: decode to MOVN_I_I using decoder 228 |
| 4248 | // 249: } |
| 4249 | 12, 7, // 254: case 0xc: { |
| 4250 | OPC_CheckPredicate, 28, // 256: check predicate 28 |
| 4251 | OPC_Decode, 207, 23, 229, 1, // 258: decode to SYSCALL using decoder 229 |
| 4252 | // 258: } |
| 4253 | 13, 6, // 263: case 0xd: { |
| 4254 | OPC_CheckPredicate, 28, // 265: check predicate 28 |
| 4255 | OPC_Decode, 241, 8, 99, // 267: decode to BREAK using decoder 99 |
| 4256 | // 267: } |
| 4257 | 15, 7, // 271: case 0xf: { |
| 4258 | OPC_CheckPredicate, 37, // 273: check predicate 37 |
| 4259 | OPC_Decode, 198, 23, 230, 1, // 275: decode to SYNC using decoder 230 |
| 4260 | // 275: } |
| 4261 | 16, 32, // 280: case 0x10: { |
| 4262 | OPC_CheckField, 6, 5, 0, // 282: check Inst[10:6] == 0x0 |
| 4263 | OPC_CheckField, 16, 5, 0, // 286: check Inst[20:16] == 0x0 |
| 4264 | OPC_CheckField, 23, 3, 0, // 290: check Inst[25:23] == 0x0 |
| 4265 | OPC_Scope, 11, // 294: try { |
| 4266 | OPC_CheckField, 21, 2, 0, // 296: check Inst[22:21] == 0x0 |
| 4267 | OPC_CheckPredicate, 32, // 300: check predicate 32 |
| 4268 | OPC_Decode, 177, 17, 231, 1, // 302: decode to MFHI using decoder 231 |
| 4269 | // 302: } else try { |
| 4270 | OPC_CheckPredicate, 38, // 307: check predicate 38 |
| 4271 | OPC_Decode, 180, 17, 232, 1, // 309: decode to MFHI_DSP using decoder 232 |
| 4272 | // 309: } |
| 4273 | // 309: } |
| 4274 | 17, 28, // 314: case 0x11: { |
| 4275 | OPC_CheckField, 6, 5, 0, // 316: check Inst[10:6] == 0x0 |
| 4276 | OPC_CheckField, 13, 8, 0, // 320: check Inst[20:13] == 0x0 |
| 4277 | OPC_Scope, 11, // 324: try { |
| 4278 | OPC_CheckField, 11, 2, 0, // 326: check Inst[12:11] == 0x0 |
| 4279 | OPC_CheckPredicate, 32, // 330: check predicate 32 |
| 4280 | OPC_Decode, 204, 18, 227, 1, // 332: decode to MTHI using decoder 227 |
| 4281 | // 332: } else try { |
| 4282 | OPC_CheckPredicate, 38, // 337: check predicate 38 |
| 4283 | OPC_Decode, 206, 18, 233, 1, // 339: decode to MTHI_DSP using decoder 233 |
| 4284 | // 339: } |
| 4285 | // 339: } |
| 4286 | 18, 32, // 344: case 0x12: { |
| 4287 | OPC_CheckField, 6, 5, 0, // 346: check Inst[10:6] == 0x0 |
| 4288 | OPC_CheckField, 16, 5, 0, // 350: check Inst[20:16] == 0x0 |
| 4289 | OPC_CheckField, 23, 3, 0, // 354: check Inst[25:23] == 0x0 |
| 4290 | OPC_Scope, 11, // 358: try { |
| 4291 | OPC_CheckField, 21, 2, 0, // 360: check Inst[22:21] == 0x0 |
| 4292 | OPC_CheckPredicate, 32, // 364: check predicate 32 |
| 4293 | OPC_Decode, 183, 17, 231, 1, // 366: decode to MFLO using decoder 231 |
| 4294 | // 366: } else try { |
| 4295 | OPC_CheckPredicate, 38, // 371: check predicate 38 |
| 4296 | OPC_Decode, 186, 17, 232, 1, // 373: decode to MFLO_DSP using decoder 232 |
| 4297 | // 373: } |
| 4298 | // 373: } |
| 4299 | 19, 28, // 378: case 0x13: { |
| 4300 | OPC_CheckField, 6, 5, 0, // 380: check Inst[10:6] == 0x0 |
| 4301 | OPC_CheckField, 13, 8, 0, // 384: check Inst[20:13] == 0x0 |
| 4302 | OPC_Scope, 11, // 388: try { |
| 4303 | OPC_CheckField, 11, 2, 0, // 390: check Inst[12:11] == 0x0 |
| 4304 | OPC_CheckPredicate, 32, // 394: check predicate 32 |
| 4305 | OPC_Decode, 211, 18, 227, 1, // 396: decode to MTLO using decoder 227 |
| 4306 | // 396: } else try { |
| 4307 | OPC_CheckPredicate, 38, // 401: check predicate 38 |
| 4308 | OPC_Decode, 213, 18, 234, 1, // 403: decode to MTLO_DSP using decoder 234 |
| 4309 | // 403: } |
| 4310 | // 403: } |
| 4311 | 21, 11, // 408: case 0x15: { |
| 4312 | OPC_CheckPredicate, 39, // 410: check predicate 39 |
| 4313 | OPC_CheckField, 8, 3, 0, // 412: check Inst[10:8] == 0x0 |
| 4314 | OPC_Decode, 137, 12, 235, 1, // 416: decode to DLSA using decoder 235 |
| 4315 | // 416: } |
| 4316 | 24, 27, // 421: case 0x18: { |
| 4317 | OPC_CheckField, 6, 5, 0, // 423: check Inst[10:6] == 0x0 |
| 4318 | OPC_CheckField, 13, 3, 0, // 427: check Inst[15:13] == 0x0 |
| 4319 | OPC_Scope, 10, // 431: try { |
| 4320 | OPC_CheckField, 11, 2, 0, // 433: check Inst[12:11] == 0x0 |
| 4321 | OPC_CheckPredicate, 32, // 437: check predicate 32 |
| 4322 | OPC_Decode, 254, 18, 123, // 439: decode to MULT using decoder 123 |
| 4323 | // 439: } else try { |
| 4324 | OPC_CheckPredicate, 38, // 443: check predicate 38 |
| 4325 | OPC_Decode, 129, 19, 236, 1, // 445: decode to MULT_DSP using decoder 236 |
| 4326 | // 445: } |
| 4327 | // 445: } |
| 4328 | 25, 27, // 450: case 0x19: { |
| 4329 | OPC_CheckField, 6, 5, 0, // 452: check Inst[10:6] == 0x0 |
| 4330 | OPC_CheckField, 13, 3, 0, // 456: check Inst[15:13] == 0x0 |
| 4331 | OPC_Scope, 10, // 460: try { |
| 4332 | OPC_CheckField, 11, 2, 0, // 462: check Inst[12:11] == 0x0 |
| 4333 | OPC_CheckPredicate, 32, // 466: check predicate 32 |
| 4334 | OPC_Decode, 132, 19, 123, // 468: decode to MULTu using decoder 123 |
| 4335 | // 468: } else try { |
| 4336 | OPC_CheckPredicate, 38, // 472: check predicate 38 |
| 4337 | OPC_Decode, 255, 18, 236, 1, // 474: decode to MULTU_DSP using decoder 236 |
| 4338 | // 474: } |
| 4339 | // 474: } |
| 4340 | 26, 10, // 479: case 0x1a: { |
| 4341 | OPC_CheckPredicate, 32, // 481: check predicate 32 |
| 4342 | OPC_CheckField, 6, 10, 0, // 483: check Inst[15:6] == 0x0 |
| 4343 | OPC_Decode, 133, 21, 123, // 487: decode to SDIV using decoder 123 |
| 4344 | // 487: } |
| 4345 | 27, 10, // 491: case 0x1b: { |
| 4346 | OPC_CheckPredicate, 32, // 493: check predicate 32 |
| 4347 | OPC_CheckField, 6, 10, 0, // 495: check Inst[15:6] == 0x0 |
| 4348 | OPC_Decode, 171, 24, 123, // 499: decode to UDIV using decoder 123 |
| 4349 | // 499: } |
| 4350 | 32, 10, // 503: case 0x20: { |
| 4351 | OPC_CheckPredicate, 28, // 505: check predicate 28 |
| 4352 | OPC_CheckField, 6, 5, 0, // 507: check Inst[10:6] == 0x0 |
| 4353 | OPC_Decode, 157, 6, 104, // 511: decode to ADD using decoder 104 |
| 4354 | // 511: } |
| 4355 | 33, 10, // 515: case 0x21: { |
| 4356 | OPC_CheckPredicate, 28, // 517: check predicate 28 |
| 4357 | OPC_CheckField, 6, 5, 0, // 519: check Inst[10:6] == 0x0 |
| 4358 | OPC_Decode, 242, 6, 104, // 523: decode to ADDu using decoder 104 |
| 4359 | // 523: } |
| 4360 | 34, 10, // 527: case 0x22: { |
| 4361 | OPC_CheckPredicate, 28, // 529: check predicate 28 |
| 4362 | OPC_CheckField, 6, 5, 0, // 531: check Inst[10:6] == 0x0 |
| 4363 | OPC_Decode, 217, 22, 104, // 535: decode to SUB using decoder 104 |
| 4364 | // 535: } |
| 4365 | 35, 10, // 539: case 0x23: { |
| 4366 | OPC_CheckPredicate, 28, // 541: check predicate 28 |
| 4367 | OPC_CheckField, 6, 5, 0, // 543: check Inst[10:6] == 0x0 |
| 4368 | OPC_Decode, 146, 23, 104, // 547: decode to SUBu using decoder 104 |
| 4369 | // 547: } |
| 4370 | 36, 10, // 551: case 0x24: { |
| 4371 | OPC_CheckPredicate, 28, // 553: check predicate 28 |
| 4372 | OPC_CheckField, 6, 5, 0, // 555: check Inst[10:6] == 0x0 |
| 4373 | OPC_Decode, 252, 6, 104, // 559: decode to AND using decoder 104 |
| 4374 | // 559: } |
| 4375 | 37, 10, // 563: case 0x25: { |
| 4376 | OPC_CheckPredicate, 28, // 565: check predicate 28 |
| 4377 | OPC_CheckField, 6, 5, 0, // 567: check Inst[10:6] == 0x0 |
| 4378 | OPC_Decode, 188, 19, 104, // 571: decode to OR using decoder 104 |
| 4379 | // 571: } |
| 4380 | 38, 10, // 575: case 0x26: { |
| 4381 | OPC_CheckPredicate, 28, // 577: check predicate 28 |
| 4382 | OPC_CheckField, 6, 5, 0, // 579: check Inst[10:6] == 0x0 |
| 4383 | OPC_Decode, 191, 24, 104, // 583: decode to XOR using decoder 104 |
| 4384 | // 583: } |
| 4385 | 39, 10, // 587: case 0x27: { |
| 4386 | OPC_CheckPredicate, 28, // 589: check predicate 28 |
| 4387 | OPC_CheckField, 6, 5, 0, // 591: check Inst[10:6] == 0x0 |
| 4388 | OPC_Decode, 176, 19, 104, // 595: decode to NOR using decoder 104 |
| 4389 | // 595: } |
| 4390 | 42, 10, // 599: case 0x2a: { |
| 4391 | OPC_CheckPredicate, 28, // 601: check predicate 28 |
| 4392 | OPC_CheckField, 6, 5, 0, // 603: check Inst[10:6] == 0x0 |
| 4393 | OPC_Decode, 136, 22, 104, // 607: decode to SLT using decoder 104 |
| 4394 | // 607: } |
| 4395 | 43, 10, // 611: case 0x2b: { |
| 4396 | OPC_CheckPredicate, 28, // 613: check predicate 28 |
| 4397 | OPC_CheckField, 6, 5, 0, // 615: check Inst[10:6] == 0x0 |
| 4398 | OPC_Decode, 149, 22, 104, // 619: decode to SLTu using decoder 104 |
| 4399 | // 619: } |
| 4400 | 48, 7, // 623: case 0x30: { |
| 4401 | OPC_CheckPredicate, 37, // 625: check predicate 37 |
| 4402 | OPC_Decode, 237, 23, 237, 1, // 627: decode to TGE using decoder 237 |
| 4403 | // 627: } |
| 4404 | 49, 7, // 632: case 0x31: { |
| 4405 | OPC_CheckPredicate, 37, // 634: check predicate 37 |
| 4406 | OPC_Decode, 242, 23, 237, 1, // 636: decode to TGEU using decoder 237 |
| 4407 | // 636: } |
| 4408 | 50, 7, // 641: case 0x32: { |
| 4409 | OPC_CheckPredicate, 37, // 643: check predicate 37 |
| 4410 | OPC_Decode, 141, 24, 237, 1, // 645: decode to TLT using decoder 237 |
| 4411 | // 645: } |
| 4412 | 51, 7, // 650: case 0x33: { |
| 4413 | OPC_CheckPredicate, 37, // 652: check predicate 37 |
| 4414 | OPC_Decode, 145, 24, 237, 1, // 654: decode to TLTU using decoder 237 |
| 4415 | // 654: } |
| 4416 | 52, 7, // 659: case 0x34: { |
| 4417 | OPC_CheckPredicate, 37, // 661: check predicate 37 |
| 4418 | OPC_Decode, 232, 23, 237, 1, // 663: decode to TEQ using decoder 237 |
| 4419 | // 663: } |
| 4420 | 54, 0, // 668: case 0x36: { |
| 4421 | OPC_CheckPredicate, 37, // 670: check predicate 37 |
| 4422 | OPC_Decode, 148, 24, 237, 1, // 672: decode to TNE using decoder 237 |
| 4423 | // 672: } |
| 4424 | // 672: } // switch Inst[5:0] |
| 4425 | // 672: } |
| 4426 | 1, 151, 1, // 677: case 0x1: { |
| 4427 | OPC_SwitchField, 16, 5, // 680: switch Inst[20:16] { |
| 4428 | 0, 7, // 683: case 0x0: { |
| 4429 | OPC_CheckPredicate, 28, // 685: check predicate 28 |
| 4430 | OPC_Decode, 186, 8, 238, 1, // 687: decode to BLTZ using decoder 238 |
| 4431 | // 687: } |
| 4432 | 1, 7, // 692: case 0x1: { |
| 4433 | OPC_CheckPredicate, 28, // 694: check predicate 28 |
| 4434 | OPC_Decode, 252, 7, 238, 1, // 696: decode to BGEZ using decoder 238 |
| 4435 | // 696: } |
| 4436 | 2, 7, // 701: case 0x2: { |
| 4437 | OPC_CheckPredicate, 40, // 703: check predicate 40 |
| 4438 | OPC_Decode, 197, 8, 238, 1, // 705: decode to BLTZL using decoder 238 |
| 4439 | // 705: } |
| 4440 | 3, 7, // 710: case 0x3: { |
| 4441 | OPC_CheckPredicate, 40, // 712: check predicate 40 |
| 4442 | OPC_Decode, 135, 8, 238, 1, // 714: decode to BGEZL using decoder 238 |
| 4443 | // 714: } |
| 4444 | 8, 7, // 719: case 0x8: { |
| 4445 | OPC_CheckPredicate, 40, // 721: check predicate 40 |
| 4446 | OPC_Decode, 238, 23, 216, 1, // 723: decode to TGEI using decoder 216 |
| 4447 | // 723: } |
| 4448 | 9, 7, // 728: case 0x9: { |
| 4449 | OPC_CheckPredicate, 40, // 730: check predicate 40 |
| 4450 | OPC_Decode, 239, 23, 216, 1, // 732: decode to TGEIU using decoder 216 |
| 4451 | // 732: } |
| 4452 | 10, 7, // 737: case 0xa: { |
| 4453 | OPC_CheckPredicate, 40, // 739: check predicate 40 |
| 4454 | OPC_Decode, 142, 24, 216, 1, // 741: decode to TLTI using decoder 216 |
| 4455 | // 741: } |
| 4456 | 11, 7, // 746: case 0xb: { |
| 4457 | OPC_CheckPredicate, 40, // 748: check predicate 40 |
| 4458 | OPC_Decode, 164, 24, 216, 1, // 750: decode to TTLTIU using decoder 216 |
| 4459 | // 750: } |
| 4460 | 12, 7, // 755: case 0xc: { |
| 4461 | OPC_CheckPredicate, 40, // 757: check predicate 40 |
| 4462 | OPC_Decode, 233, 23, 216, 1, // 759: decode to TEQI using decoder 216 |
| 4463 | // 759: } |
| 4464 | 14, 7, // 764: case 0xe: { |
| 4465 | OPC_CheckPredicate, 40, // 766: check predicate 40 |
| 4466 | OPC_Decode, 149, 24, 216, 1, // 768: decode to TNEI using decoder 216 |
| 4467 | // 768: } |
| 4468 | 16, 7, // 773: case 0x10: { |
| 4469 | OPC_CheckPredicate, 32, // 775: check predicate 32 |
| 4470 | OPC_Decode, 188, 8, 238, 1, // 777: decode to BLTZAL using decoder 238 |
| 4471 | // 777: } |
| 4472 | 17, 7, // 782: case 0x11: { |
| 4473 | OPC_CheckPredicate, 32, // 784: check predicate 32 |
| 4474 | OPC_Decode, 254, 7, 238, 1, // 786: decode to BGEZAL using decoder 238 |
| 4475 | // 786: } |
| 4476 | 18, 7, // 791: case 0x12: { |
| 4477 | OPC_CheckPredicate, 40, // 793: check predicate 40 |
| 4478 | OPC_Decode, 191, 8, 238, 1, // 795: decode to BLTZALL using decoder 238 |
| 4479 | // 795: } |
| 4480 | 19, 7, // 800: case 0x13: { |
| 4481 | OPC_CheckPredicate, 40, // 802: check predicate 40 |
| 4482 | OPC_Decode, 129, 8, 238, 1, // 804: decode to BGEZALL using decoder 238 |
| 4483 | // 804: } |
| 4484 | 28, 11, // 809: case 0x1c: { |
| 4485 | OPC_CheckPredicate, 41, // 811: check predicate 41 |
| 4486 | OPC_CheckField, 21, 5, 0, // 813: check Inst[25:21] == 0x0 |
| 4487 | OPC_Decode, 238, 8, 239, 1, // 817: decode to BPOSGE32 using decoder 239 |
| 4488 | // 817: } |
| 4489 | 31, 0, // 822: case 0x1f: { |
| 4490 | OPC_CheckPredicate, 29, // 824: check predicate 29 |
| 4491 | OPC_Decode, 199, 23, 240, 1, // 826: decode to SYNCI using decoder 240 |
| 4492 | // 826: } |
| 4493 | // 826: } // switch Inst[20:16] |
| 4494 | // 826: } |
| 4495 | 2, 7, // 831: case 0x2: { |
| 4496 | OPC_CheckPredicate, 28, // 833: check predicate 28 |
| 4497 | OPC_Decode, 133, 15, 241, 1, // 835: decode to J using decoder 241 |
| 4498 | // 835: } |
| 4499 | 3, 7, // 840: case 0x3: { |
| 4500 | OPC_CheckPredicate, 28, // 842: check predicate 28 |
| 4501 | OPC_Decode, 134, 15, 241, 1, // 844: decode to JAL using decoder 241 |
| 4502 | // 844: } |
| 4503 | 4, 7, // 849: case 0x4: { |
| 4504 | OPC_CheckPredicate, 28, // 851: check predicate 28 |
| 4505 | OPC_Decode, 224, 7, 242, 1, // 853: decode to BEQ using decoder 242 |
| 4506 | // 853: } |
| 4507 | 5, 7, // 858: case 0x5: { |
| 4508 | OPC_CheckPredicate, 28, // 860: check predicate 28 |
| 4509 | OPC_Decode, 203, 8, 242, 1, // 862: decode to BNE using decoder 242 |
| 4510 | // 862: } |
| 4511 | 6, 11, // 867: case 0x6: { |
| 4512 | OPC_CheckPredicate, 28, // 869: check predicate 28 |
| 4513 | OPC_CheckField, 16, 5, 0, // 871: check Inst[20:16] == 0x0 |
| 4514 | OPC_Decode, 167, 8, 238, 1, // 875: decode to BLEZ using decoder 238 |
| 4515 | // 875: } |
| 4516 | 7, 11, // 880: case 0x7: { |
| 4517 | OPC_CheckPredicate, 28, // 882: check predicate 28 |
| 4518 | OPC_CheckField, 16, 5, 0, // 884: check Inst[20:16] == 0x0 |
| 4519 | OPC_Decode, 137, 8, 238, 1, // 888: decode to BGTZ using decoder 238 |
| 4520 | // 888: } |
| 4521 | 8, 7, // 893: case 0x8: { |
| 4522 | OPC_CheckPredicate, 32, // 895: check predicate 32 |
| 4523 | OPC_Decode, 238, 6, 243, 1, // 897: decode to ADDi using decoder 243 |
| 4524 | // 897: } |
| 4525 | 9, 7, // 902: case 0x9: { |
| 4526 | OPC_CheckPredicate, 28, // 904: check predicate 28 |
| 4527 | OPC_Decode, 240, 6, 243, 1, // 906: decode to ADDiu using decoder 243 |
| 4528 | // 906: } |
| 4529 | 10, 7, // 911: case 0xa: { |
| 4530 | OPC_CheckPredicate, 28, // 913: check predicate 28 |
| 4531 | OPC_Decode, 143, 22, 243, 1, // 915: decode to SLTi using decoder 243 |
| 4532 | // 915: } |
| 4533 | 11, 7, // 920: case 0xb: { |
| 4534 | OPC_CheckPredicate, 28, // 922: check predicate 28 |
| 4535 | OPC_Decode, 146, 22, 243, 1, // 924: decode to SLTiu using decoder 243 |
| 4536 | // 924: } |
| 4537 | 12, 7, // 929: case 0xc: { |
| 4538 | OPC_CheckPredicate, 28, // 931: check predicate 28 |
| 4539 | OPC_Decode, 139, 7, 244, 1, // 933: decode to ANDi using decoder 244 |
| 4540 | // 933: } |
| 4541 | 13, 7, // 938: case 0xd: { |
| 4542 | OPC_CheckPredicate, 28, // 940: check predicate 28 |
| 4543 | OPC_Decode, 200, 19, 244, 1, // 942: decode to ORi using decoder 244 |
| 4544 | // 942: } |
| 4545 | 14, 7, // 947: case 0xe: { |
| 4546 | OPC_CheckPredicate, 28, // 949: check predicate 28 |
| 4547 | OPC_Decode, 203, 24, 244, 1, // 951: decode to XORi using decoder 244 |
| 4548 | // 951: } |
| 4549 | 15, 11, // 956: case 0xf: { |
| 4550 | OPC_CheckPredicate, 28, // 958: check predicate 28 |
| 4551 | OPC_CheckField, 21, 5, 0, // 960: check Inst[25:21] == 0x0 |
| 4552 | OPC_Decode, 156, 16, 148, 1, // 964: decode to LUi using decoder 148 |
| 4553 | // 964: } |
| 4554 | 16, 171, 3, // 969: case 0x10: { |
| 4555 | OPC_SwitchField, 3, 1, // 972: switch Inst[3] { |
| 4556 | 0, 141, 2, // 975: case 0x0: { |
| 4557 | OPC_SwitchField, 21, 5, // 978: switch Inst[25:21] { |
| 4558 | 0, 11, // 981: case 0x0: { |
| 4559 | OPC_CheckPredicate, 28, // 983: check predicate 28 |
| 4560 | OPC_CheckField, 4, 7, 0, // 985: check Inst[10:4] == 0x0 |
| 4561 | OPC_Decode, 156, 17, 245, 1, // 989: decode to MFC0 using decoder 245 |
| 4562 | // 989: } |
| 4563 | 3, 39, // 994: case 0x3: { |
| 4564 | OPC_SwitchField, 4, 7, // 996: switch Inst[10:4] { |
| 4565 | 0, 7, // 999: case 0x0: { |
| 4566 | OPC_CheckPredicate, 42, // 1001: check predicate 42 |
| 4567 | OPC_Decode, 166, 17, 245, 1, // 1003: decode to MFGC0 using decoder 245 |
| 4568 | // 1003: } |
| 4569 | 32, 7, // 1008: case 0x20: { |
| 4570 | OPC_CheckPredicate, 42, // 1010: check predicate 42 |
| 4571 | OPC_Decode, 193, 18, 246, 1, // 1012: decode to MTGC0 using decoder 246 |
| 4572 | // 1012: } |
| 4573 | 64, 7, // 1017: case 0x40: { |
| 4574 | OPC_CheckPredicate, 42, // 1019: check predicate 42 |
| 4575 | OPC_Decode, 175, 17, 245, 1, // 1021: decode to MFHGC0 using decoder 245 |
| 4576 | // 1021: } |
| 4577 | 96, 0, // 1026: case 0x60: { |
| 4578 | OPC_CheckPredicate, 42, // 1028: check predicate 42 |
| 4579 | OPC_Decode, 202, 18, 246, 1, // 1030: decode to MTHGC0 using decoder 246 |
| 4580 | // 1030: } |
| 4581 | // 1030: } // switch Inst[10:4] |
| 4582 | // 1030: } |
| 4583 | 4, 11, // 1035: case 0x4: { |
| 4584 | OPC_CheckPredicate, 28, // 1037: check predicate 28 |
| 4585 | OPC_CheckField, 4, 7, 0, // 1039: check Inst[10:4] == 0x0 |
| 4586 | OPC_Decode, 182, 18, 246, 1, // 1043: decode to MTC0 using decoder 246 |
| 4587 | // 1043: } |
| 4588 | 8, 11, // 1048: case 0x8: { |
| 4589 | OPC_CheckPredicate, 43, // 1050: check predicate 43 |
| 4590 | OPC_CheckField, 6, 5, 0, // 1052: check Inst[10:6] == 0x0 |
| 4591 | OPC_Decode, 189, 17, 247, 1, // 1056: decode to MFTR using decoder 247 |
| 4592 | // 1056: } |
| 4593 | 11, 85, // 1061: case 0xb: { |
| 4594 | OPC_SwitchField, 4, 12, // 1063: switch Inst[15:4] { |
| 4595 | 0, 11, // 1066: case 0x0: { |
| 4596 | OPC_CheckPredicate, 43, // 1068: check predicate 43 |
| 4597 | OPC_CheckField, 0, 3, 1, // 1070: check Inst[2:0] == 0x1 |
| 4598 | OPC_Decode, 230, 12, 136, 1, // 1074: decode to DVPE using decoder 136 |
| 4599 | // 1074: } |
| 4600 | 2, 11, // 1079: case 0x2: { |
| 4601 | OPC_CheckPredicate, 43, // 1081: check predicate 43 |
| 4602 | OPC_CheckField, 0, 3, 1, // 1083: check Inst[2:0] == 0x1 |
| 4603 | OPC_Decode, 252, 12, 136, 1, // 1087: decode to EVPE using decoder 136 |
| 4604 | // 1087: } |
| 4605 | 188, 1, 11, // 1092: case 0xbc: { |
| 4606 | OPC_CheckPredicate, 43, // 1095: check predicate 43 |
| 4607 | OPC_CheckField, 0, 3, 1, // 1097: check Inst[2:0] == 0x1 |
| 4608 | OPC_Decode, 146, 12, 136, 1, // 1101: decode to DMT using decoder 136 |
| 4609 | // 1101: } |
| 4610 | 190, 1, 11, // 1106: case 0xbe: { |
| 4611 | OPC_CheckPredicate, 43, // 1109: check predicate 43 |
| 4612 | OPC_CheckField, 0, 3, 1, // 1111: check Inst[2:0] == 0x1 |
| 4613 | OPC_Decode, 243, 12, 136, 1, // 1115: decode to EMT using decoder 136 |
| 4614 | // 1115: } |
| 4615 | 128, 12, 11, // 1120: case 0x600: { |
| 4616 | OPC_CheckPredicate, 29, // 1123: check predicate 29 |
| 4617 | OPC_CheckField, 0, 3, 0, // 1125: check Inst[2:0] == 0x0 |
| 4618 | OPC_Decode, 244, 11, 136, 1, // 1129: decode to DI using decoder 136 |
| 4619 | // 1129: } |
| 4620 | 130, 12, 0, // 1134: case 0x602: { |
| 4621 | OPC_CheckPredicate, 29, // 1137: check predicate 29 |
| 4622 | OPC_CheckField, 0, 3, 0, // 1139: check Inst[2:0] == 0x0 |
| 4623 | OPC_Decode, 239, 12, 136, 1, // 1143: decode to EI using decoder 136 |
| 4624 | // 1143: } |
| 4625 | // 1143: } // switch Inst[15:4] |
| 4626 | // 1143: } |
| 4627 | 12, 11, // 1148: case 0xc: { |
| 4628 | OPC_CheckPredicate, 43, // 1150: check predicate 43 |
| 4629 | OPC_CheckField, 6, 5, 0, // 1152: check Inst[10:6] == 0x0 |
| 4630 | OPC_Decode, 222, 18, 247, 1, // 1156: decode to MTTR using decoder 247 |
| 4631 | // 1156: } |
| 4632 | 16, 0, // 1161: case 0x10: { |
| 4633 | OPC_SwitchField, 0, 3, // 1163: switch Inst[2:0] { |
| 4634 | 0, 19, // 1166: case 0x0: { |
| 4635 | OPC_SwitchField, 4, 17, // 1168: switch Inst[20:4] { |
| 4636 | 1, 6, // 1171: case 0x1: { |
| 4637 | OPC_CheckPredicate, 42, // 1173: check predicate 42 |
| 4638 | OPC_Decode, 249, 23, 10, // 1175: decode to TLBGP using decoder 10 |
| 4639 | // 1175: } |
| 4640 | 2, 0, // 1179: case 0x2: { |
| 4641 | OPC_CheckPredicate, 44, // 1181: check predicate 44 |
| 4642 | OPC_Decode, 180, 24, 10, // 1183: decode to WAIT using decoder 10 |
| 4643 | // 1183: } |
| 4644 | // 1183: } // switch Inst[20:4] |
| 4645 | // 1183: } |
| 4646 | 1, 10, // 1187: case 0x1: { |
| 4647 | OPC_CheckPredicate, 28, // 1189: check predicate 28 |
| 4648 | OPC_CheckField, 4, 17, 0, // 1191: check Inst[20:4] == 0x0 |
| 4649 | OPC_Decode, 135, 24, 10, // 1195: decode to TLBR using decoder 10 |
| 4650 | // 1195: } |
| 4651 | 2, 10, // 1199: case 0x2: { |
| 4652 | OPC_CheckPredicate, 28, // 1201: check predicate 28 |
| 4653 | OPC_CheckField, 4, 17, 0, // 1203: check Inst[20:4] == 0x0 |
| 4654 | OPC_Decode, 137, 24, 10, // 1207: decode to TLBWI using decoder 10 |
| 4655 | // 1207: } |
| 4656 | 3, 10, // 1211: case 0x3: { |
| 4657 | OPC_CheckPredicate, 45, // 1213: check predicate 45 |
| 4658 | OPC_CheckField, 4, 17, 0, // 1215: check Inst[20:4] == 0x0 |
| 4659 | OPC_Decode, 129, 24, 10, // 1219: decode to TLBINV using decoder 10 |
| 4660 | // 1219: } |
| 4661 | 4, 10, // 1223: case 0x4: { |
| 4662 | OPC_CheckPredicate, 45, // 1225: check predicate 45 |
| 4663 | OPC_CheckField, 4, 17, 0, // 1227: check Inst[20:4] == 0x0 |
| 4664 | OPC_Decode, 130, 24, 10, // 1231: decode to TLBINVF using decoder 10 |
| 4665 | // 1231: } |
| 4666 | 6, 0, // 1235: case 0x6: { |
| 4667 | OPC_CheckPredicate, 28, // 1237: check predicate 28 |
| 4668 | OPC_CheckField, 4, 17, 0, // 1239: check Inst[20:4] == 0x0 |
| 4669 | OPC_Decode, 139, 24, 10, // 1243: decode to TLBWR using decoder 10 |
| 4670 | // 1243: } |
| 4671 | // 1243: } // switch Inst[2:0] |
| 4672 | // 1243: } |
| 4673 | // 1243: } // switch Inst[25:21] |
| 4674 | // 1243: } |
| 4675 | 1, 0, // 1247: case 0x1: { |
| 4676 | OPC_SwitchField, 0, 3, // 1249: switch Inst[2:0] { |
| 4677 | 0, 55, // 1252: case 0x0: { |
| 4678 | OPC_SwitchField, 4, 2, // 1254: switch Inst[5:4] { |
| 4679 | 0, 12, // 1257: case 0x0: { |
| 4680 | OPC_CheckPredicate, 28, // 1259: check predicate 28 |
| 4681 | OPC_CheckField, 6, 20, 128, 128, 32, // 1261: check Inst[25:6] == 0x80000 |
| 4682 | OPC_Decode, 133, 24, 10, // 1267: decode to TLBP using decoder 10 |
| 4683 | // 1267: } |
| 4684 | 1, 23, // 1271: case 0x1: { |
| 4685 | OPC_SwitchField, 6, 20, // 1273: switch Inst[25:6] { |
| 4686 | 128, 128, 32, 6, // 1276: case 0x80000: { |
| 4687 | OPC_CheckPredicate, 44, // 1280: check predicate 44 |
| 4688 | OPC_Decode, 244, 12, 10, // 1282: decode to ERET using decoder 10 |
| 4689 | // 1282: } |
| 4690 | 129, 128, 32, 0, // 1286: case 0x80001: { |
| 4691 | OPC_CheckPredicate, 46, // 1290: check predicate 46 |
| 4692 | OPC_Decode, 245, 12, 10, // 1292: decode to ERETNC using decoder 10 |
| 4693 | // 1292: } |
| 4694 | // 1292: } // switch Inst[25:6] |
| 4695 | // 1292: } |
| 4696 | 2, 0, // 1296: case 0x2: { |
| 4697 | OPC_CheckPredicate, 42, // 1298: check predicate 42 |
| 4698 | OPC_CheckField, 25, 1, 1, // 1300: check Inst[25] == 0x1 |
| 4699 | OPC_Decode, 229, 14, 248, 1, // 1304: decode to HYPCALL using decoder 248 |
| 4700 | // 1304: } |
| 4701 | // 1304: } // switch Inst[5:4] |
| 4702 | // 1304: } |
| 4703 | 1, 13, // 1309: case 0x1: { |
| 4704 | OPC_CheckPredicate, 42, // 1311: check predicate 42 |
| 4705 | OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1313: check Inst[25:4] == 0x200000 |
| 4706 | OPC_Decode, 251, 23, 10, // 1320: decode to TLBGR using decoder 10 |
| 4707 | // 1320: } |
| 4708 | 2, 13, // 1324: case 0x2: { |
| 4709 | OPC_CheckPredicate, 42, // 1326: check predicate 42 |
| 4710 | OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1328: check Inst[25:4] == 0x200000 |
| 4711 | OPC_Decode, 253, 23, 10, // 1335: decode to TLBGWI using decoder 10 |
| 4712 | // 1335: } |
| 4713 | 3, 13, // 1339: case 0x3: { |
| 4714 | OPC_CheckPredicate, 42, // 1341: check predicate 42 |
| 4715 | OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1343: check Inst[25:4] == 0x200000 |
| 4716 | OPC_Decode, 245, 23, 10, // 1350: decode to TLBGINV using decoder 10 |
| 4717 | // 1350: } |
| 4718 | 4, 13, // 1354: case 0x4: { |
| 4719 | OPC_CheckPredicate, 42, // 1356: check predicate 42 |
| 4720 | OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1358: check Inst[25:4] == 0x200000 |
| 4721 | OPC_Decode, 246, 23, 10, // 1365: decode to TLBGINVF using decoder 10 |
| 4722 | // 1365: } |
| 4723 | 6, 13, // 1369: case 0x6: { |
| 4724 | OPC_CheckPredicate, 42, // 1371: check predicate 42 |
| 4725 | OPC_CheckField, 4, 22, 128, 128, 128, 1, // 1373: check Inst[25:4] == 0x200000 |
| 4726 | OPC_Decode, 255, 23, 10, // 1380: decode to TLBGWR using decoder 10 |
| 4727 | // 1380: } |
| 4728 | 7, 0, // 1384: case 0x7: { |
| 4729 | OPC_CheckPredicate, 47, // 1386: check predicate 47 |
| 4730 | OPC_CheckField, 4, 22, 129, 128, 128, 1, // 1388: check Inst[25:4] == 0x200001 |
| 4731 | OPC_Decode, 236, 11, 10, // 1395: decode to DERET using decoder 10 |
| 4732 | // 1395: } |
| 4733 | // 1395: } // switch Inst[2:0] |
| 4734 | // 1395: } |
| 4735 | // 1395: } // switch Inst[3] |
| 4736 | // 1395: } |
| 4737 | 17, 165, 9, // 1399: case 0x11: { |
| 4738 | OPC_SwitchField, 21, 5, // 1402: switch Inst[25:21] { |
| 4739 | 0, 11, // 1405: case 0x0: { |
| 4740 | OPC_CheckPredicate, 48, // 1407: check predicate 48 |
| 4741 | OPC_CheckField, 0, 11, 0, // 1409: check Inst[10:0] == 0x0 |
| 4742 | OPC_Decode, 160, 17, 249, 1, // 1413: decode to MFC1 using decoder 249 |
| 4743 | // 1413: } |
| 4744 | 1, 11, // 1418: case 0x1: { |
| 4745 | OPC_CheckPredicate, 49, // 1420: check predicate 49 |
| 4746 | OPC_CheckField, 0, 11, 0, // 1422: check Inst[10:0] == 0x0 |
| 4747 | OPC_Decode, 140, 12, 250, 1, // 1426: decode to DMFC1 using decoder 250 |
| 4748 | // 1426: } |
| 4749 | 2, 11, // 1431: case 0x2: { |
| 4750 | OPC_CheckPredicate, 48, // 1433: check predicate 48 |
| 4751 | OPC_CheckField, 0, 11, 0, // 1435: check Inst[10:0] == 0x0 |
| 4752 | OPC_Decode, 174, 9, 251, 1, // 1439: decode to CFC1 using decoder 251 |
| 4753 | // 1439: } |
| 4754 | 3, 11, // 1444: case 0x3: { |
| 4755 | OPC_CheckPredicate, 50, // 1446: check predicate 50 |
| 4756 | OPC_CheckField, 0, 11, 0, // 1448: check Inst[10:0] == 0x0 |
| 4757 | OPC_Decode, 170, 17, 252, 1, // 1452: decode to MFHC1_D32 using decoder 252 |
| 4758 | // 1452: } |
| 4759 | 4, 11, // 1457: case 0x4: { |
| 4760 | OPC_CheckPredicate, 48, // 1459: check predicate 48 |
| 4761 | OPC_CheckField, 0, 11, 0, // 1461: check Inst[10:0] == 0x0 |
| 4762 | OPC_Decode, 186, 18, 253, 1, // 1465: decode to MTC1 using decoder 253 |
| 4763 | // 1465: } |
| 4764 | 5, 11, // 1470: case 0x5: { |
| 4765 | OPC_CheckPredicate, 49, // 1472: check predicate 49 |
| 4766 | OPC_CheckField, 0, 11, 0, // 1474: check Inst[10:0] == 0x0 |
| 4767 | OPC_Decode, 148, 12, 254, 1, // 1478: decode to DMTC1 using decoder 254 |
| 4768 | // 1478: } |
| 4769 | 6, 11, // 1483: case 0x6: { |
| 4770 | OPC_CheckPredicate, 48, // 1485: check predicate 48 |
| 4771 | OPC_CheckField, 0, 11, 0, // 1487: check Inst[10:0] == 0x0 |
| 4772 | OPC_Decode, 209, 10, 255, 1, // 1491: decode to CTC1 using decoder 255 |
| 4773 | // 1491: } |
| 4774 | 7, 11, // 1496: case 0x7: { |
| 4775 | OPC_CheckPredicate, 50, // 1498: check predicate 50 |
| 4776 | OPC_CheckField, 0, 11, 0, // 1500: check Inst[10:0] == 0x0 |
| 4777 | OPC_Decode, 197, 18, 128, 2, // 1504: decode to MTHC1_D32 using decoder 256 |
| 4778 | // 1504: } |
| 4779 | 8, 39, // 1509: case 0x8: { |
| 4780 | OPC_SwitchField, 16, 2, // 1511: switch Inst[17:16] { |
| 4781 | 0, 7, // 1514: case 0x0: { |
| 4782 | OPC_CheckPredicate, 51, // 1516: check predicate 51 |
| 4783 | OPC_Decode, 202, 7, 129, 2, // 1518: decode to BC1F using decoder 257 |
| 4784 | // 1518: } |
| 4785 | 1, 7, // 1523: case 0x1: { |
| 4786 | OPC_CheckPredicate, 51, // 1525: check predicate 51 |
| 4787 | OPC_Decode, 207, 7, 129, 2, // 1527: decode to BC1T using decoder 257 |
| 4788 | // 1527: } |
| 4789 | 2, 7, // 1532: case 0x2: { |
| 4790 | OPC_CheckPredicate, 52, // 1534: check predicate 52 |
| 4791 | OPC_Decode, 203, 7, 129, 2, // 1536: decode to BC1FL using decoder 257 |
| 4792 | // 1536: } |
| 4793 | 3, 0, // 1541: case 0x3: { |
| 4794 | OPC_CheckPredicate, 52, // 1543: check predicate 52 |
| 4795 | OPC_Decode, 208, 7, 129, 2, // 1545: decode to BC1TL using decoder 257 |
| 4796 | // 1545: } |
| 4797 | // 1545: } // switch Inst[17:16] |
| 4798 | // 1545: } |
| 4799 | 11, 7, // 1550: case 0xb: { |
| 4800 | OPC_CheckPredicate, 31, // 1552: check predicate 31 |
| 4801 | OPC_Decode, 135, 9, 130, 2, // 1554: decode to BZ_V using decoder 258 |
| 4802 | // 1554: } |
| 4803 | 15, 7, // 1559: case 0xf: { |
| 4804 | OPC_CheckPredicate, 31, // 1561: check predicate 31 |
| 4805 | OPC_Decode, 234, 8, 130, 2, // 1563: decode to BNZ_V using decoder 258 |
| 4806 | // 1563: } |
| 4807 | 16, 201, 3, // 1568: case 0x10: { |
| 4808 | OPC_SwitchField, 0, 6, // 1571: switch Inst[5:0] { |
| 4809 | 0, 7, // 1574: case 0x0: { |
| 4810 | OPC_CheckPredicate, 48, // 1576: check predicate 48 |
| 4811 | OPC_Decode, 170, 13, 131, 2, // 1578: decode to FADD_S using decoder 259 |
| 4812 | // 1578: } |
| 4813 | 1, 7, // 1583: case 0x1: { |
| 4814 | OPC_CheckPredicate, 48, // 1585: check predicate 48 |
| 4815 | OPC_Decode, 187, 14, 131, 2, // 1587: decode to FSUB_S using decoder 259 |
| 4816 | // 1587: } |
| 4817 | 2, 7, // 1592: case 0x2: { |
| 4818 | OPC_CheckPredicate, 48, // 1594: check predicate 48 |
| 4819 | OPC_Decode, 143, 14, 131, 2, // 1596: decode to FMUL_S using decoder 259 |
| 4820 | // 1596: } |
| 4821 | 3, 7, // 1601: case 0x3: { |
| 4822 | OPC_CheckPredicate, 48, // 1603: check predicate 48 |
| 4823 | OPC_Decode, 208, 13, 131, 2, // 1605: decode to FDIV_S using decoder 259 |
| 4824 | // 1605: } |
| 4825 | 4, 11, // 1610: case 0x4: { |
| 4826 | OPC_CheckPredicate, 53, // 1612: check predicate 53 |
| 4827 | OPC_CheckField, 16, 5, 0, // 1614: check Inst[20:16] == 0x0 |
| 4828 | OPC_Decode, 178, 14, 132, 2, // 1618: decode to FSQRT_S using decoder 260 |
| 4829 | // 1618: } |
| 4830 | 5, 11, // 1623: case 0x5: { |
| 4831 | OPC_CheckPredicate, 48, // 1625: check predicate 48 |
| 4832 | OPC_CheckField, 16, 5, 0, // 1627: check Inst[20:16] == 0x0 |
| 4833 | OPC_Decode, 162, 13, 132, 2, // 1631: decode to FABS_S using decoder 260 |
| 4834 | // 1631: } |
| 4835 | 6, 11, // 1636: case 0x6: { |
| 4836 | OPC_CheckPredicate, 48, // 1638: check predicate 48 |
| 4837 | OPC_CheckField, 16, 5, 0, // 1640: check Inst[20:16] == 0x0 |
| 4838 | OPC_Decode, 132, 14, 132, 2, // 1644: decode to FMOV_S using decoder 260 |
| 4839 | // 1644: } |
| 4840 | 7, 11, // 1649: case 0x7: { |
| 4841 | OPC_CheckPredicate, 54, // 1651: check predicate 54 |
| 4842 | OPC_CheckField, 16, 5, 0, // 1653: check Inst[20:16] == 0x0 |
| 4843 | OPC_Decode, 151, 14, 132, 2, // 1657: decode to FNEG_S using decoder 260 |
| 4844 | // 1657: } |
| 4845 | 12, 11, // 1662: case 0xc: { |
| 4846 | OPC_CheckPredicate, 55, // 1664: check predicate 55 |
| 4847 | OPC_CheckField, 16, 5, 0, // 1666: check Inst[20:16] == 0x0 |
| 4848 | OPC_Decode, 195, 20, 132, 2, // 1670: decode to ROUND_W_S using decoder 260 |
| 4849 | // 1670: } |
| 4850 | 13, 11, // 1675: case 0xd: { |
| 4851 | OPC_CheckPredicate, 55, // 1677: check predicate 55 |
| 4852 | OPC_CheckField, 16, 5, 0, // 1679: check Inst[20:16] == 0x0 |
| 4853 | OPC_Decode, 161, 24, 132, 2, // 1683: decode to TRUNC_W_S using decoder 260 |
| 4854 | // 1683: } |
| 4855 | 14, 11, // 1688: case 0xe: { |
| 4856 | OPC_CheckPredicate, 55, // 1690: check predicate 55 |
| 4857 | OPC_CheckField, 16, 5, 0, // 1692: check Inst[20:16] == 0x0 |
| 4858 | OPC_Decode, 163, 9, 132, 2, // 1696: decode to CEIL_W_S using decoder 260 |
| 4859 | // 1696: } |
| 4860 | 15, 11, // 1701: case 0xf: { |
| 4861 | OPC_CheckPredicate, 55, // 1703: check predicate 55 |
| 4862 | OPC_CheckField, 16, 5, 0, // 1705: check Inst[20:16] == 0x0 |
| 4863 | OPC_Decode, 242, 13, 132, 2, // 1709: decode to FLOOR_W_S using decoder 260 |
| 4864 | // 1709: } |
| 4865 | 17, 21, // 1714: case 0x11: { |
| 4866 | OPC_SwitchField, 16, 2, // 1716: switch Inst[17:16] { |
| 4867 | 0, 7, // 1719: case 0x0: { |
| 4868 | OPC_CheckPredicate, 30, // 1721: check predicate 30 |
| 4869 | OPC_Decode, 249, 17, 133, 2, // 1723: decode to MOVF_S using decoder 261 |
| 4870 | // 1723: } |
| 4871 | 1, 0, // 1728: case 0x1: { |
| 4872 | OPC_CheckPredicate, 30, // 1730: check predicate 30 |
| 4873 | OPC_Decode, 142, 18, 133, 2, // 1732: decode to MOVT_S using decoder 261 |
| 4874 | // 1732: } |
| 4875 | // 1732: } // switch Inst[17:16] |
| 4876 | // 1732: } |
| 4877 | 18, 7, // 1737: case 0x12: { |
| 4878 | OPC_CheckPredicate, 30, // 1739: check predicate 30 |
| 4879 | OPC_Decode, 154, 18, 134, 2, // 1741: decode to MOVZ_I_S using decoder 262 |
| 4880 | // 1741: } |
| 4881 | 19, 7, // 1746: case 0x13: { |
| 4882 | OPC_CheckPredicate, 30, // 1748: check predicate 30 |
| 4883 | OPC_Decode, 133, 18, 134, 2, // 1750: decode to MOVN_I_S using decoder 262 |
| 4884 | // 1750: } |
| 4885 | 21, 11, // 1755: case 0x15: { |
| 4886 | OPC_CheckPredicate, 56, // 1757: check predicate 56 |
| 4887 | OPC_CheckField, 16, 5, 0, // 1759: check Inst[20:16] == 0x0 |
| 4888 | OPC_Decode, 163, 20, 132, 2, // 1763: decode to RECIP_S using decoder 260 |
| 4889 | // 1763: } |
| 4890 | 22, 11, // 1768: case 0x16: { |
| 4891 | OPC_CheckPredicate, 56, // 1770: check predicate 56 |
| 4892 | OPC_CheckField, 16, 5, 0, // 1772: check Inst[20:16] == 0x0 |
| 4893 | OPC_Decode, 202, 20, 132, 2, // 1776: decode to RSQRT_S using decoder 260 |
| 4894 | // 1776: } |
| 4895 | 33, 11, // 1781: case 0x21: { |
| 4896 | OPC_CheckPredicate, 57, // 1783: check predicate 57 |
| 4897 | OPC_CheckField, 16, 5, 0, // 1785: check Inst[20:16] == 0x0 |
| 4898 | OPC_Decode, 213, 10, 135, 2, // 1789: decode to CVT_D32_S using decoder 263 |
| 4899 | // 1789: } |
| 4900 | 36, 11, // 1794: case 0x24: { |
| 4901 | OPC_CheckPredicate, 48, // 1796: check predicate 48 |
| 4902 | OPC_CheckField, 16, 5, 0, // 1798: check Inst[20:16] == 0x0 |
| 4903 | OPC_Decode, 247, 10, 132, 2, // 1802: decode to CVT_W_S using decoder 260 |
| 4904 | // 1802: } |
| 4905 | 37, 11, // 1807: case 0x25: { |
| 4906 | OPC_CheckPredicate, 58, // 1809: check predicate 58 |
| 4907 | OPC_CheckField, 16, 5, 0, // 1811: check Inst[20:16] == 0x0 |
| 4908 | OPC_Decode, 226, 10, 136, 2, // 1815: decode to CVT_L_S using decoder 264 |
| 4909 | // 1815: } |
| 4910 | 48, 11, // 1820: case 0x30: { |
| 4911 | OPC_CheckPredicate, 51, // 1822: check predicate 51 |
| 4912 | OPC_CheckField, 6, 2, 0, // 1824: check Inst[7:6] == 0x0 |
| 4913 | OPC_Decode, 132, 11, 137, 2, // 1828: decode to C_F_S using decoder 265 |
| 4914 | // 1828: } |
| 4915 | 49, 11, // 1833: case 0x31: { |
| 4916 | OPC_CheckPredicate, 59, // 1835: check predicate 59 |
| 4917 | OPC_CheckField, 6, 2, 0, // 1837: check Inst[7:6] == 0x0 |
| 4918 | OPC_Decode, 216, 11, 137, 2, // 1841: decode to C_UN_S using decoder 265 |
| 4919 | // 1841: } |
| 4920 | 50, 11, // 1846: case 0x32: { |
| 4921 | OPC_CheckPredicate, 51, // 1848: check predicate 51 |
| 4922 | OPC_CheckField, 6, 2, 0, // 1850: check Inst[7:6] == 0x0 |
| 4923 | OPC_Decode, 254, 10, 137, 2, // 1854: decode to C_EQ_S using decoder 265 |
| 4924 | // 1854: } |
| 4925 | 51, 11, // 1859: case 0x33: { |
| 4926 | OPC_CheckPredicate, 59, // 1861: check predicate 59 |
| 4927 | OPC_CheckField, 6, 2, 0, // 1863: check Inst[7:6] == 0x0 |
| 4928 | OPC_Decode, 198, 11, 137, 2, // 1867: decode to C_UEQ_S using decoder 265 |
| 4929 | // 1867: } |
| 4930 | 52, 11, // 1872: case 0x34: { |
| 4931 | OPC_CheckPredicate, 51, // 1874: check predicate 51 |
| 4932 | OPC_CheckField, 6, 2, 0, // 1876: check Inst[7:6] == 0x0 |
| 4933 | OPC_Decode, 180, 11, 137, 2, // 1880: decode to C_OLT_S using decoder 265 |
| 4934 | // 1880: } |
| 4935 | 53, 11, // 1885: case 0x35: { |
| 4936 | OPC_CheckPredicate, 59, // 1887: check predicate 59 |
| 4937 | OPC_CheckField, 6, 2, 0, // 1889: check Inst[7:6] == 0x0 |
| 4938 | OPC_Decode, 210, 11, 137, 2, // 1893: decode to C_ULT_S using decoder 265 |
| 4939 | // 1893: } |
| 4940 | 54, 11, // 1898: case 0x36: { |
| 4941 | OPC_CheckPredicate, 51, // 1900: check predicate 51 |
| 4942 | OPC_CheckField, 6, 2, 0, // 1902: check Inst[7:6] == 0x0 |
| 4943 | OPC_Decode, 174, 11, 137, 2, // 1906: decode to C_OLE_S using decoder 265 |
| 4944 | // 1906: } |
| 4945 | 55, 11, // 1911: case 0x37: { |
| 4946 | OPC_CheckPredicate, 59, // 1913: check predicate 59 |
| 4947 | OPC_CheckField, 6, 2, 0, // 1915: check Inst[7:6] == 0x0 |
| 4948 | OPC_Decode, 204, 11, 137, 2, // 1919: decode to C_ULE_S using decoder 265 |
| 4949 | // 1919: } |
| 4950 | 56, 11, // 1924: case 0x38: { |
| 4951 | OPC_CheckPredicate, 59, // 1926: check predicate 59 |
| 4952 | OPC_CheckField, 6, 2, 0, // 1928: check Inst[7:6] == 0x0 |
| 4953 | OPC_Decode, 192, 11, 137, 2, // 1932: decode to C_SF_S using decoder 265 |
| 4954 | // 1932: } |
| 4955 | 57, 11, // 1937: case 0x39: { |
| 4956 | OPC_CheckPredicate, 59, // 1939: check predicate 59 |
| 4957 | OPC_CheckField, 6, 2, 0, // 1941: check Inst[7:6] == 0x0 |
| 4958 | OPC_Decode, 156, 11, 137, 2, // 1945: decode to C_NGLE_S using decoder 265 |
| 4959 | // 1945: } |
| 4960 | 58, 11, // 1950: case 0x3a: { |
| 4961 | OPC_CheckPredicate, 59, // 1952: check predicate 59 |
| 4962 | OPC_CheckField, 6, 2, 0, // 1954: check Inst[7:6] == 0x0 |
| 4963 | OPC_Decode, 186, 11, 137, 2, // 1958: decode to C_SEQ_S using decoder 265 |
| 4964 | // 1958: } |
| 4965 | 59, 11, // 1963: case 0x3b: { |
| 4966 | OPC_CheckPredicate, 59, // 1965: check predicate 59 |
| 4967 | OPC_CheckField, 6, 2, 0, // 1967: check Inst[7:6] == 0x0 |
| 4968 | OPC_Decode, 162, 11, 137, 2, // 1971: decode to C_NGL_S using decoder 265 |
| 4969 | // 1971: } |
| 4970 | 60, 11, // 1976: case 0x3c: { |
| 4971 | OPC_CheckPredicate, 59, // 1978: check predicate 59 |
| 4972 | OPC_CheckField, 6, 2, 0, // 1980: check Inst[7:6] == 0x0 |
| 4973 | OPC_Decode, 144, 11, 137, 2, // 1984: decode to C_LT_S using decoder 265 |
| 4974 | // 1984: } |
| 4975 | 61, 11, // 1989: case 0x3d: { |
| 4976 | OPC_CheckPredicate, 59, // 1991: check predicate 59 |
| 4977 | OPC_CheckField, 6, 2, 0, // 1993: check Inst[7:6] == 0x0 |
| 4978 | OPC_Decode, 150, 11, 137, 2, // 1997: decode to C_NGE_S using decoder 265 |
| 4979 | // 1997: } |
| 4980 | 62, 11, // 2002: case 0x3e: { |
| 4981 | OPC_CheckPredicate, 59, // 2004: check predicate 59 |
| 4982 | OPC_CheckField, 6, 2, 0, // 2006: check Inst[7:6] == 0x0 |
| 4983 | OPC_Decode, 138, 11, 137, 2, // 2010: decode to C_LE_S using decoder 265 |
| 4984 | // 2010: } |
| 4985 | 63, 0, // 2015: case 0x3f: { |
| 4986 | OPC_CheckPredicate, 59, // 2017: check predicate 59 |
| 4987 | OPC_CheckField, 6, 2, 0, // 2019: check Inst[7:6] == 0x0 |
| 4988 | OPC_Decode, 168, 11, 137, 2, // 2023: decode to C_NGT_S using decoder 265 |
| 4989 | // 2023: } |
| 4990 | // 2023: } // switch Inst[5:0] |
| 4991 | // 2023: } |
| 4992 | 17, 201, 3, // 2028: case 0x11: { |
| 4993 | OPC_SwitchField, 0, 6, // 2031: switch Inst[5:0] { |
| 4994 | 0, 7, // 2034: case 0x0: { |
| 4995 | OPC_CheckPredicate, 57, // 2036: check predicate 57 |
| 4996 | OPC_Decode, 165, 13, 138, 2, // 2038: decode to FADD_D32 using decoder 266 |
| 4997 | // 2038: } |
| 4998 | 1, 7, // 2043: case 0x1: { |
| 4999 | OPC_CheckPredicate, 57, // 2045: check predicate 57 |
| 5000 | OPC_Decode, 182, 14, 138, 2, // 2047: decode to FSUB_D32 using decoder 266 |
| 5001 | // 2047: } |
| 5002 | 2, 7, // 2052: case 0x2: { |
| 5003 | OPC_CheckPredicate, 57, // 2054: check predicate 57 |
| 5004 | OPC_Decode, 138, 14, 138, 2, // 2056: decode to FMUL_D32 using decoder 266 |
| 5005 | // 2056: } |
| 5006 | 3, 7, // 2061: case 0x3: { |
| 5007 | OPC_CheckPredicate, 57, // 2063: check predicate 57 |
| 5008 | OPC_Decode, 204, 13, 138, 2, // 2065: decode to FDIV_D32 using decoder 266 |
| 5009 | // 2065: } |
| 5010 | 4, 11, // 2070: case 0x4: { |
| 5011 | OPC_CheckPredicate, 60, // 2072: check predicate 60 |
| 5012 | OPC_CheckField, 16, 5, 0, // 2074: check Inst[20:16] == 0x0 |
| 5013 | OPC_Decode, 174, 14, 139, 2, // 2078: decode to FSQRT_D32 using decoder 267 |
| 5014 | // 2078: } |
| 5015 | 5, 11, // 2083: case 0x5: { |
| 5016 | OPC_CheckPredicate, 57, // 2085: check predicate 57 |
| 5017 | OPC_CheckField, 16, 5, 0, // 2087: check Inst[20:16] == 0x0 |
| 5018 | OPC_Decode, 158, 13, 139, 2, // 2091: decode to FABS_D32 using decoder 267 |
| 5019 | // 2091: } |
| 5020 | 6, 11, // 2096: case 0x6: { |
| 5021 | OPC_CheckPredicate, 57, // 2098: check predicate 57 |
| 5022 | OPC_CheckField, 16, 5, 0, // 2100: check Inst[20:16] == 0x0 |
| 5023 | OPC_Decode, 255, 13, 139, 2, // 2104: decode to FMOV_D32 using decoder 267 |
| 5024 | // 2104: } |
| 5025 | 7, 11, // 2109: case 0x7: { |
| 5026 | OPC_CheckPredicate, 57, // 2111: check predicate 57 |
| 5027 | OPC_CheckField, 16, 5, 0, // 2113: check Inst[20:16] == 0x0 |
| 5028 | OPC_Decode, 147, 14, 139, 2, // 2117: decode to FNEG_D32 using decoder 267 |
| 5029 | // 2117: } |
| 5030 | 12, 11, // 2122: case 0xc: { |
| 5031 | OPC_CheckPredicate, 60, // 2124: check predicate 60 |
| 5032 | OPC_CheckField, 16, 5, 0, // 2126: check Inst[20:16] == 0x0 |
| 5033 | OPC_Decode, 191, 20, 140, 2, // 2130: decode to ROUND_W_D32 using decoder 268 |
| 5034 | // 2130: } |
| 5035 | 13, 11, // 2135: case 0xd: { |
| 5036 | OPC_CheckPredicate, 60, // 2137: check predicate 60 |
| 5037 | OPC_CheckField, 16, 5, 0, // 2139: check Inst[20:16] == 0x0 |
| 5038 | OPC_Decode, 157, 24, 140, 2, // 2143: decode to TRUNC_W_D32 using decoder 268 |
| 5039 | // 2143: } |
| 5040 | 14, 11, // 2148: case 0xe: { |
| 5041 | OPC_CheckPredicate, 60, // 2150: check predicate 60 |
| 5042 | OPC_CheckField, 16, 5, 0, // 2152: check Inst[20:16] == 0x0 |
| 5043 | OPC_Decode, 159, 9, 140, 2, // 2156: decode to CEIL_W_D32 using decoder 268 |
| 5044 | // 2156: } |
| 5045 | 15, 11, // 2161: case 0xf: { |
| 5046 | OPC_CheckPredicate, 60, // 2163: check predicate 60 |
| 5047 | OPC_CheckField, 16, 5, 0, // 2165: check Inst[20:16] == 0x0 |
| 5048 | OPC_Decode, 238, 13, 140, 2, // 2169: decode to FLOOR_W_D32 using decoder 268 |
| 5049 | // 2169: } |
| 5050 | 17, 21, // 2174: case 0x11: { |
| 5051 | OPC_SwitchField, 16, 2, // 2176: switch Inst[17:16] { |
| 5052 | 0, 7, // 2179: case 0x0: { |
| 5053 | OPC_CheckPredicate, 61, // 2181: check predicate 61 |
| 5054 | OPC_Decode, 243, 17, 141, 2, // 2183: decode to MOVF_D32 using decoder 269 |
| 5055 | // 2183: } |
| 5056 | 1, 0, // 2188: case 0x1: { |
| 5057 | OPC_CheckPredicate, 61, // 2190: check predicate 61 |
| 5058 | OPC_Decode, 136, 18, 141, 2, // 2192: decode to MOVT_D32 using decoder 269 |
| 5059 | // 2192: } |
| 5060 | // 2192: } // switch Inst[17:16] |
| 5061 | // 2192: } |
| 5062 | 18, 7, // 2197: case 0x12: { |
| 5063 | OPC_CheckPredicate, 61, // 2199: check predicate 61 |
| 5064 | OPC_Decode, 148, 18, 142, 2, // 2201: decode to MOVZ_I_D32 using decoder 270 |
| 5065 | // 2201: } |
| 5066 | 19, 7, // 2206: case 0x13: { |
| 5067 | OPC_CheckPredicate, 61, // 2208: check predicate 61 |
| 5068 | OPC_Decode, 255, 17, 142, 2, // 2210: decode to MOVN_I_D32 using decoder 270 |
| 5069 | // 2210: } |
| 5070 | 21, 11, // 2215: case 0x15: { |
| 5071 | OPC_CheckPredicate, 62, // 2217: check predicate 62 |
| 5072 | OPC_CheckField, 16, 5, 0, // 2219: check Inst[20:16] == 0x0 |
| 5073 | OPC_Decode, 159, 20, 139, 2, // 2223: decode to RECIP_D32 using decoder 267 |
| 5074 | // 2223: } |
| 5075 | 22, 11, // 2228: case 0x16: { |
| 5076 | OPC_CheckPredicate, 62, // 2230: check predicate 62 |
| 5077 | OPC_CheckField, 16, 5, 0, // 2232: check Inst[20:16] == 0x0 |
| 5078 | OPC_Decode, 198, 20, 139, 2, // 2236: decode to RSQRT_D32 using decoder 267 |
| 5079 | // 2236: } |
| 5080 | 32, 11, // 2241: case 0x20: { |
| 5081 | OPC_CheckPredicate, 57, // 2243: check predicate 57 |
| 5082 | OPC_CheckField, 16, 5, 0, // 2245: check Inst[20:16] == 0x0 |
| 5083 | OPC_Decode, 232, 10, 140, 2, // 2249: decode to CVT_S_D32 using decoder 268 |
| 5084 | // 2249: } |
| 5085 | 36, 11, // 2254: case 0x24: { |
| 5086 | OPC_CheckPredicate, 57, // 2256: check predicate 57 |
| 5087 | OPC_CheckField, 16, 5, 0, // 2258: check Inst[20:16] == 0x0 |
| 5088 | OPC_Decode, 243, 10, 140, 2, // 2262: decode to CVT_W_D32 using decoder 268 |
| 5089 | // 2262: } |
| 5090 | 37, 11, // 2267: case 0x25: { |
| 5091 | OPC_CheckPredicate, 58, // 2269: check predicate 58 |
| 5092 | OPC_CheckField, 16, 5, 0, // 2271: check Inst[20:16] == 0x0 |
| 5093 | OPC_Decode, 223, 10, 143, 2, // 2275: decode to CVT_L_D64 using decoder 271 |
| 5094 | // 2275: } |
| 5095 | 48, 11, // 2280: case 0x30: { |
| 5096 | OPC_CheckPredicate, 63, // 2282: check predicate 63 |
| 5097 | OPC_CheckField, 6, 2, 0, // 2284: check Inst[7:6] == 0x0 |
| 5098 | OPC_Decode, 128, 11, 144, 2, // 2288: decode to C_F_D32 using decoder 272 |
| 5099 | // 2288: } |
| 5100 | 49, 11, // 2293: case 0x31: { |
| 5101 | OPC_CheckPredicate, 63, // 2295: check predicate 63 |
| 5102 | OPC_CheckField, 6, 2, 0, // 2297: check Inst[7:6] == 0x0 |
| 5103 | OPC_Decode, 212, 11, 144, 2, // 2301: decode to C_UN_D32 using decoder 272 |
| 5104 | // 2301: } |
| 5105 | 50, 11, // 2306: case 0x32: { |
| 5106 | OPC_CheckPredicate, 63, // 2308: check predicate 63 |
| 5107 | OPC_CheckField, 6, 2, 0, // 2310: check Inst[7:6] == 0x0 |
| 5108 | OPC_Decode, 250, 10, 144, 2, // 2314: decode to C_EQ_D32 using decoder 272 |
| 5109 | // 2314: } |
| 5110 | 51, 11, // 2319: case 0x33: { |
| 5111 | OPC_CheckPredicate, 63, // 2321: check predicate 63 |
| 5112 | OPC_CheckField, 6, 2, 0, // 2323: check Inst[7:6] == 0x0 |
| 5113 | OPC_Decode, 194, 11, 144, 2, // 2327: decode to C_UEQ_D32 using decoder 272 |
| 5114 | // 2327: } |
| 5115 | 52, 11, // 2332: case 0x34: { |
| 5116 | OPC_CheckPredicate, 63, // 2334: check predicate 63 |
| 5117 | OPC_CheckField, 6, 2, 0, // 2336: check Inst[7:6] == 0x0 |
| 5118 | OPC_Decode, 176, 11, 144, 2, // 2340: decode to C_OLT_D32 using decoder 272 |
| 5119 | // 2340: } |
| 5120 | 53, 11, // 2345: case 0x35: { |
| 5121 | OPC_CheckPredicate, 63, // 2347: check predicate 63 |
| 5122 | OPC_CheckField, 6, 2, 0, // 2349: check Inst[7:6] == 0x0 |
| 5123 | OPC_Decode, 206, 11, 144, 2, // 2353: decode to C_ULT_D32 using decoder 272 |
| 5124 | // 2353: } |
| 5125 | 54, 11, // 2358: case 0x36: { |
| 5126 | OPC_CheckPredicate, 63, // 2360: check predicate 63 |
| 5127 | OPC_CheckField, 6, 2, 0, // 2362: check Inst[7:6] == 0x0 |
| 5128 | OPC_Decode, 170, 11, 144, 2, // 2366: decode to C_OLE_D32 using decoder 272 |
| 5129 | // 2366: } |
| 5130 | 55, 11, // 2371: case 0x37: { |
| 5131 | OPC_CheckPredicate, 63, // 2373: check predicate 63 |
| 5132 | OPC_CheckField, 6, 2, 0, // 2375: check Inst[7:6] == 0x0 |
| 5133 | OPC_Decode, 200, 11, 144, 2, // 2379: decode to C_ULE_D32 using decoder 272 |
| 5134 | // 2379: } |
| 5135 | 56, 11, // 2384: case 0x38: { |
| 5136 | OPC_CheckPredicate, 63, // 2386: check predicate 63 |
| 5137 | OPC_CheckField, 6, 2, 0, // 2388: check Inst[7:6] == 0x0 |
| 5138 | OPC_Decode, 188, 11, 144, 2, // 2392: decode to C_SF_D32 using decoder 272 |
| 5139 | // 2392: } |
| 5140 | 57, 11, // 2397: case 0x39: { |
| 5141 | OPC_CheckPredicate, 63, // 2399: check predicate 63 |
| 5142 | OPC_CheckField, 6, 2, 0, // 2401: check Inst[7:6] == 0x0 |
| 5143 | OPC_Decode, 152, 11, 144, 2, // 2405: decode to C_NGLE_D32 using decoder 272 |
| 5144 | // 2405: } |
| 5145 | 58, 11, // 2410: case 0x3a: { |
| 5146 | OPC_CheckPredicate, 63, // 2412: check predicate 63 |
| 5147 | OPC_CheckField, 6, 2, 0, // 2414: check Inst[7:6] == 0x0 |
| 5148 | OPC_Decode, 182, 11, 144, 2, // 2418: decode to C_SEQ_D32 using decoder 272 |
| 5149 | // 2418: } |
| 5150 | 59, 11, // 2423: case 0x3b: { |
| 5151 | OPC_CheckPredicate, 63, // 2425: check predicate 63 |
| 5152 | OPC_CheckField, 6, 2, 0, // 2427: check Inst[7:6] == 0x0 |
| 5153 | OPC_Decode, 158, 11, 144, 2, // 2431: decode to C_NGL_D32 using decoder 272 |
| 5154 | // 2431: } |
| 5155 | 60, 11, // 2436: case 0x3c: { |
| 5156 | OPC_CheckPredicate, 63, // 2438: check predicate 63 |
| 5157 | OPC_CheckField, 6, 2, 0, // 2440: check Inst[7:6] == 0x0 |
| 5158 | OPC_Decode, 140, 11, 144, 2, // 2444: decode to C_LT_D32 using decoder 272 |
| 5159 | // 2444: } |
| 5160 | 61, 11, // 2449: case 0x3d: { |
| 5161 | OPC_CheckPredicate, 63, // 2451: check predicate 63 |
| 5162 | OPC_CheckField, 6, 2, 0, // 2453: check Inst[7:6] == 0x0 |
| 5163 | OPC_Decode, 146, 11, 144, 2, // 2457: decode to C_NGE_D32 using decoder 272 |
| 5164 | // 2457: } |
| 5165 | 62, 11, // 2462: case 0x3e: { |
| 5166 | OPC_CheckPredicate, 63, // 2464: check predicate 63 |
| 5167 | OPC_CheckField, 6, 2, 0, // 2466: check Inst[7:6] == 0x0 |
| 5168 | OPC_Decode, 134, 11, 144, 2, // 2470: decode to C_LE_D32 using decoder 272 |
| 5169 | // 2470: } |
| 5170 | 63, 0, // 2475: case 0x3f: { |
| 5171 | OPC_CheckPredicate, 63, // 2477: check predicate 63 |
| 5172 | OPC_CheckField, 6, 2, 0, // 2479: check Inst[7:6] == 0x0 |
| 5173 | OPC_Decode, 164, 11, 144, 2, // 2483: decode to C_NGT_D32 using decoder 272 |
| 5174 | // 2483: } |
| 5175 | // 2483: } // switch Inst[5:0] |
| 5176 | // 2483: } |
| 5177 | 20, 29, // 2488: case 0x14: { |
| 5178 | OPC_SwitchField, 0, 6, // 2490: switch Inst[5:0] { |
| 5179 | 32, 11, // 2493: case 0x20: { |
| 5180 | OPC_CheckPredicate, 48, // 2495: check predicate 48 |
| 5181 | OPC_CheckField, 16, 5, 0, // 2497: check Inst[20:16] == 0x0 |
| 5182 | OPC_Decode, 240, 10, 132, 2, // 2501: decode to CVT_S_W using decoder 260 |
| 5183 | // 2501: } |
| 5184 | 33, 0, // 2506: case 0x21: { |
| 5185 | OPC_CheckPredicate, 57, // 2508: check predicate 57 |
| 5186 | OPC_CheckField, 16, 5, 0, // 2510: check Inst[20:16] == 0x0 |
| 5187 | OPC_Decode, 215, 10, 135, 2, // 2514: decode to CVT_D32_W using decoder 263 |
| 5188 | // 2514: } |
| 5189 | // 2514: } // switch Inst[5:0] |
| 5190 | // 2514: } |
| 5191 | 24, 7, // 2519: case 0x18: { |
| 5192 | OPC_CheckPredicate, 31, // 2521: check predicate 31 |
| 5193 | OPC_Decode, 132, 9, 130, 2, // 2523: decode to BZ_B using decoder 258 |
| 5194 | // 2523: } |
| 5195 | 25, 7, // 2528: case 0x19: { |
| 5196 | OPC_CheckPredicate, 31, // 2530: check predicate 31 |
| 5197 | OPC_Decode, 134, 9, 145, 2, // 2532: decode to BZ_H using decoder 273 |
| 5198 | // 2532: } |
| 5199 | 26, 7, // 2537: case 0x1a: { |
| 5200 | OPC_CheckPredicate, 31, // 2539: check predicate 31 |
| 5201 | OPC_Decode, 136, 9, 146, 2, // 2541: decode to BZ_W using decoder 274 |
| 5202 | // 2541: } |
| 5203 | 27, 7, // 2546: case 0x1b: { |
| 5204 | OPC_CheckPredicate, 31, // 2548: check predicate 31 |
| 5205 | OPC_Decode, 133, 9, 147, 2, // 2550: decode to BZ_D using decoder 275 |
| 5206 | // 2550: } |
| 5207 | 28, 7, // 2555: case 0x1c: { |
| 5208 | OPC_CheckPredicate, 31, // 2557: check predicate 31 |
| 5209 | OPC_Decode, 231, 8, 130, 2, // 2559: decode to BNZ_B using decoder 258 |
| 5210 | // 2559: } |
| 5211 | 29, 7, // 2564: case 0x1d: { |
| 5212 | OPC_CheckPredicate, 31, // 2566: check predicate 31 |
| 5213 | OPC_Decode, 233, 8, 145, 2, // 2568: decode to BNZ_H using decoder 273 |
| 5214 | // 2568: } |
| 5215 | 30, 7, // 2573: case 0x1e: { |
| 5216 | OPC_CheckPredicate, 31, // 2575: check predicate 31 |
| 5217 | OPC_Decode, 235, 8, 146, 2, // 2577: decode to BNZ_W using decoder 274 |
| 5218 | // 2577: } |
| 5219 | 31, 0, // 2582: case 0x1f: { |
| 5220 | OPC_CheckPredicate, 31, // 2584: check predicate 31 |
| 5221 | OPC_Decode, 232, 8, 147, 2, // 2586: decode to BNZ_D using decoder 275 |
| 5222 | // 2586: } |
| 5223 | // 2586: } // switch Inst[25:21] |
| 5224 | // 2586: } |
| 5225 | 18, 29, // 2591: case 0x12: { |
| 5226 | OPC_SwitchField, 21, 5, // 2593: switch Inst[25:21] { |
| 5227 | 0, 11, // 2596: case 0x0: { |
| 5228 | OPC_CheckPredicate, 28, // 2598: check predicate 28 |
| 5229 | OPC_CheckField, 3, 8, 0, // 2600: check Inst[10:3] == 0x0 |
| 5230 | OPC_Decode, 164, 17, 148, 2, // 2604: decode to MFC2 using decoder 276 |
| 5231 | // 2604: } |
| 5232 | 4, 0, // 2609: case 0x4: { |
| 5233 | OPC_CheckPredicate, 28, // 2611: check predicate 28 |
| 5234 | OPC_CheckField, 3, 8, 0, // 2613: check Inst[10:3] == 0x0 |
| 5235 | OPC_Decode, 191, 18, 149, 2, // 2617: decode to MTC2 using decoder 277 |
| 5236 | // 2617: } |
| 5237 | // 2617: } // switch Inst[25:21] |
| 5238 | // 2617: } |
| 5239 | 19, 153, 1, // 2622: case 0x13: { |
| 5240 | OPC_SwitchField, 0, 6, // 2625: switch Inst[5:0] { |
| 5241 | 0, 11, // 2628: case 0x0: { |
| 5242 | OPC_CheckPredicate, 64, // 2630: check predicate 64 |
| 5243 | OPC_CheckField, 11, 5, 0, // 2632: check Inst[15:11] == 0x0 |
| 5244 | OPC_Decode, 200, 16, 150, 2, // 2636: decode to LWXC1 using decoder 278 |
| 5245 | // 2636: } |
| 5246 | 1, 11, // 2641: case 0x1: { |
| 5247 | OPC_CheckPredicate, 65, // 2643: check predicate 65 |
| 5248 | OPC_CheckField, 11, 5, 0, // 2645: check Inst[15:11] == 0x0 |
| 5249 | OPC_Decode, 225, 15, 151, 2, // 2649: decode to LDXC1 using decoder 279 |
| 5250 | // 2649: } |
| 5251 | 5, 11, // 2654: case 0x5: { |
| 5252 | OPC_CheckPredicate, 66, // 2656: check predicate 66 |
| 5253 | OPC_CheckField, 11, 5, 0, // 2658: check Inst[15:11] == 0x0 |
| 5254 | OPC_Decode, 153, 16, 151, 2, // 2662: decode to LUXC1 using decoder 279 |
| 5255 | // 2662: } |
| 5256 | 8, 11, // 2667: case 0x8: { |
| 5257 | OPC_CheckPredicate, 64, // 2669: check predicate 64 |
| 5258 | OPC_CheckField, 6, 5, 0, // 2671: check Inst[10:6] == 0x0 |
| 5259 | OPC_Decode, 190, 23, 152, 2, // 2675: decode to SWXC1 using decoder 280 |
| 5260 | // 2675: } |
| 5261 | 9, 11, // 2680: case 0x9: { |
| 5262 | OPC_CheckPredicate, 65, // 2682: check predicate 65 |
| 5263 | OPC_CheckField, 6, 5, 0, // 2684: check Inst[10:6] == 0x0 |
| 5264 | OPC_Decode, 137, 21, 153, 2, // 2688: decode to SDXC1 using decoder 281 |
| 5265 | // 2688: } |
| 5266 | 13, 11, // 2693: case 0xd: { |
| 5267 | OPC_CheckPredicate, 66, // 2695: check predicate 66 |
| 5268 | OPC_CheckField, 6, 5, 0, // 2697: check Inst[10:6] == 0x0 |
| 5269 | OPC_Decode, 150, 23, 153, 2, // 2701: decode to SUXC1 using decoder 281 |
| 5270 | // 2701: } |
| 5271 | 32, 7, // 2706: case 0x20: { |
| 5272 | OPC_CheckPredicate, 67, // 2708: check predicate 67 |
| 5273 | OPC_Decode, 246, 16, 154, 2, // 2710: decode to MADD_S using decoder 282 |
| 5274 | // 2710: } |
| 5275 | 33, 7, // 2715: case 0x21: { |
| 5276 | OPC_CheckPredicate, 68, // 2717: check predicate 68 |
| 5277 | OPC_Decode, 238, 16, 155, 2, // 2719: decode to MADD_D32 using decoder 283 |
| 5278 | // 2719: } |
| 5279 | 40, 7, // 2724: case 0x28: { |
| 5280 | OPC_CheckPredicate, 67, // 2726: check predicate 67 |
| 5281 | OPC_Decode, 180, 18, 154, 2, // 2728: decode to MSUB_S using decoder 282 |
| 5282 | // 2728: } |
| 5283 | 41, 7, // 2733: case 0x29: { |
| 5284 | OPC_CheckPredicate, 68, // 2735: check predicate 68 |
| 5285 | OPC_Decode, 172, 18, 155, 2, // 2737: decode to MSUB_D32 using decoder 283 |
| 5286 | // 2737: } |
| 5287 | 48, 7, // 2742: case 0x30: { |
| 5288 | OPC_CheckPredicate, 69, // 2744: check predicate 69 |
| 5289 | OPC_Decode, 167, 19, 154, 2, // 2746: decode to NMADD_S using decoder 282 |
| 5290 | // 2746: } |
| 5291 | 49, 7, // 2751: case 0x31: { |
| 5292 | OPC_CheckPredicate, 70, // 2753: check predicate 70 |
| 5293 | OPC_Decode, 164, 19, 155, 2, // 2755: decode to NMADD_D32 using decoder 283 |
| 5294 | // 2755: } |
| 5295 | 56, 7, // 2760: case 0x38: { |
| 5296 | OPC_CheckPredicate, 69, // 2762: check predicate 69 |
| 5297 | OPC_Decode, 172, 19, 154, 2, // 2764: decode to NMSUB_S using decoder 282 |
| 5298 | // 2764: } |
| 5299 | 57, 0, // 2769: case 0x39: { |
| 5300 | OPC_CheckPredicate, 70, // 2771: check predicate 70 |
| 5301 | OPC_Decode, 169, 19, 155, 2, // 2773: decode to NMSUB_D32 using decoder 283 |
| 5302 | // 2773: } |
| 5303 | // 2773: } // switch Inst[5:0] |
| 5304 | // 2773: } |
| 5305 | 20, 7, // 2778: case 0x14: { |
| 5306 | OPC_CheckPredicate, 40, // 2780: check predicate 40 |
| 5307 | OPC_Decode, 231, 7, 242, 1, // 2782: decode to BEQL using decoder 242 |
| 5308 | // 2782: } |
| 5309 | 21, 74, // 2787: case 0x15: { |
| 5310 | OPC_Scope, 22, // 2789: try { |
| 5311 | OPC_SwitchField, 0, 16, // 2791: switch Inst[15:0] { |
| 5312 | 123, 7, // 2794: case 0x7b: { |
| 5313 | OPC_CheckPredicate, 21, // 2796: check predicate 21 |
| 5314 | OPC_Decode, 133, 14, 169, 1, // 2798: decode to FMOV_S_MM using decoder 169 |
| 5315 | // 2798: } |
| 5316 | 251, 22, 0, // 2803: case 0xb7b: { |
| 5317 | OPC_CheckPredicate, 21, // 2806: check predicate 21 |
| 5318 | OPC_Decode, 152, 14, 169, 1, // 2808: decode to FNEG_S_MM using decoder 169 |
| 5319 | // 2808: } |
| 5320 | // 2808: } // switch Inst[15:0] |
| 5321 | OPC_Scope, 41, // 2813: } else try { |
| 5322 | OPC_SwitchField, 0, 11, // 2815: switch Inst[10:0] { |
| 5323 | 48, 7, // 2818: case 0x30: { |
| 5324 | OPC_CheckPredicate, 21, // 2820: check predicate 21 |
| 5325 | OPC_Decode, 171, 13, 208, 1, // 2822: decode to FADD_S_MM using decoder 208 |
| 5326 | // 2822: } |
| 5327 | 112, 7, // 2827: case 0x70: { |
| 5328 | OPC_CheckPredicate, 21, // 2829: check predicate 21 |
| 5329 | OPC_Decode, 188, 14, 208, 1, // 2831: decode to FSUB_S_MM using decoder 208 |
| 5330 | // 2831: } |
| 5331 | 176, 1, 7, // 2836: case 0xb0: { |
| 5332 | OPC_CheckPredicate, 21, // 2839: check predicate 21 |
| 5333 | OPC_Decode, 144, 14, 208, 1, // 2841: decode to FMUL_S_MM using decoder 208 |
| 5334 | // 2841: } |
| 5335 | 240, 1, 0, // 2846: case 0xf0: { |
| 5336 | OPC_CheckPredicate, 21, // 2849: check predicate 21 |
| 5337 | OPC_Decode, 209, 13, 208, 1, // 2851: decode to FDIV_S_MM using decoder 208 |
| 5338 | // 2851: } |
| 5339 | // 2851: } // switch Inst[10:0] |
| 5340 | // 2851: } else try { |
| 5341 | OPC_CheckPredicate, 40, // 2856: check predicate 40 |
| 5342 | OPC_Decode, 218, 8, 242, 1, // 2858: decode to BNEL using decoder 242 |
| 5343 | // 2858: } |
| 5344 | // 2858: } |
| 5345 | 22, 11, // 2863: case 0x16: { |
| 5346 | OPC_CheckPredicate, 40, // 2865: check predicate 40 |
| 5347 | OPC_CheckField, 16, 5, 0, // 2867: check Inst[20:16] == 0x0 |
| 5348 | OPC_Decode, 174, 8, 238, 1, // 2871: decode to BLEZL using decoder 238 |
| 5349 | // 2871: } |
| 5350 | 23, 11, // 2876: case 0x17: { |
| 5351 | OPC_CheckPredicate, 40, // 2878: check predicate 40 |
| 5352 | OPC_CheckField, 16, 5, 0, // 2880: check Inst[20:16] == 0x0 |
| 5353 | OPC_Decode, 144, 8, 238, 1, // 2884: decode to BGTZL using decoder 238 |
| 5354 | // 2884: } |
| 5355 | 28, 166, 1, // 2889: case 0x1c: { |
| 5356 | OPC_SwitchField, 0, 6, // 2892: switch Inst[5:0] { |
| 5357 | 0, 27, // 2895: case 0x0: { |
| 5358 | OPC_CheckField, 6, 5, 0, // 2897: check Inst[10:6] == 0x0 |
| 5359 | OPC_CheckField, 13, 3, 0, // 2901: check Inst[15:13] == 0x0 |
| 5360 | OPC_Scope, 10, // 2905: try { |
| 5361 | OPC_CheckField, 11, 2, 0, // 2907: check Inst[12:11] == 0x0 |
| 5362 | OPC_CheckPredicate, 71, // 2911: check predicate 71 |
| 5363 | OPC_Decode, 223, 16, 123, // 2913: decode to MADD using decoder 123 |
| 5364 | // 2913: } else try { |
| 5365 | OPC_CheckPredicate, 38, // 2917: check predicate 38 |
| 5366 | OPC_Decode, 241, 16, 156, 2, // 2919: decode to MADD_DSP using decoder 284 |
| 5367 | // 2919: } |
| 5368 | // 2919: } |
| 5369 | 1, 27, // 2924: case 0x1: { |
| 5370 | OPC_CheckField, 6, 5, 0, // 2926: check Inst[10:6] == 0x0 |
| 5371 | OPC_CheckField, 13, 3, 0, // 2930: check Inst[15:13] == 0x0 |
| 5372 | OPC_Scope, 10, // 2934: try { |
| 5373 | OPC_CheckField, 11, 2, 0, // 2936: check Inst[12:11] == 0x0 |
| 5374 | OPC_CheckPredicate, 71, // 2940: check predicate 71 |
| 5375 | OPC_Decode, 230, 16, 123, // 2942: decode to MADDU using decoder 123 |
| 5376 | // 2942: } else try { |
| 5377 | OPC_CheckPredicate, 38, // 2946: check predicate 38 |
| 5378 | OPC_Decode, 231, 16, 156, 2, // 2948: decode to MADDU_DSP using decoder 284 |
| 5379 | // 2948: } |
| 5380 | // 2948: } |
| 5381 | 2, 10, // 2953: case 0x2: { |
| 5382 | OPC_CheckPredicate, 71, // 2955: check predicate 71 |
| 5383 | OPC_CheckField, 6, 5, 0, // 2957: check Inst[10:6] == 0x0 |
| 5384 | OPC_Decode, 229, 18, 104, // 2961: decode to MUL using decoder 104 |
| 5385 | // 2961: } |
| 5386 | 4, 27, // 2965: case 0x4: { |
| 5387 | OPC_CheckField, 6, 5, 0, // 2967: check Inst[10:6] == 0x0 |
| 5388 | OPC_CheckField, 13, 3, 0, // 2971: check Inst[15:13] == 0x0 |
| 5389 | OPC_Scope, 10, // 2975: try { |
| 5390 | OPC_CheckField, 11, 2, 0, // 2977: check Inst[12:11] == 0x0 |
| 5391 | OPC_CheckPredicate, 71, // 2981: check predicate 71 |
| 5392 | OPC_Decode, 157, 18, 123, // 2983: decode to MSUB using decoder 123 |
| 5393 | // 2983: } else try { |
| 5394 | OPC_CheckPredicate, 38, // 2987: check predicate 38 |
| 5395 | OPC_Decode, 175, 18, 156, 2, // 2989: decode to MSUB_DSP using decoder 284 |
| 5396 | // 2989: } |
| 5397 | // 2989: } |
| 5398 | 5, 27, // 2994: case 0x5: { |
| 5399 | OPC_CheckField, 6, 5, 0, // 2996: check Inst[10:6] == 0x0 |
| 5400 | OPC_CheckField, 13, 3, 0, // 3000: check Inst[15:13] == 0x0 |
| 5401 | OPC_Scope, 10, // 3004: try { |
| 5402 | OPC_CheckField, 11, 2, 0, // 3006: check Inst[12:11] == 0x0 |
| 5403 | OPC_CheckPredicate, 71, // 3010: check predicate 71 |
| 5404 | OPC_Decode, 164, 18, 123, // 3012: decode to MSUBU using decoder 123 |
| 5405 | // 3012: } else try { |
| 5406 | OPC_CheckPredicate, 38, // 3016: check predicate 38 |
| 5407 | OPC_Decode, 165, 18, 156, 2, // 3018: decode to MSUBU_DSP using decoder 284 |
| 5408 | // 3018: } |
| 5409 | // 3018: } |
| 5410 | 32, 11, // 3023: case 0x20: { |
| 5411 | OPC_CheckPredicate, 71, // 3025: check predicate 71 |
| 5412 | OPC_CheckField, 6, 5, 0, // 3027: check Inst[10:6] == 0x0 |
| 5413 | OPC_Decode, 223, 9, 157, 2, // 3031: decode to CLZ using decoder 285 |
| 5414 | // 3031: } |
| 5415 | 33, 11, // 3036: case 0x21: { |
| 5416 | OPC_CheckPredicate, 71, // 3038: check predicate 71 |
| 5417 | OPC_CheckField, 6, 5, 0, // 3040: check Inst[10:6] == 0x0 |
| 5418 | OPC_Decode, 202, 9, 157, 2, // 3044: decode to CLO using decoder 285 |
| 5419 | // 3044: } |
| 5420 | 63, 0, // 3049: case 0x3f: { |
| 5421 | OPC_CheckPredicate, 71, // 3051: check predicate 71 |
| 5422 | OPC_Decode, 244, 20, 229, 1, // 3053: decode to SDBBP using decoder 229 |
| 5423 | // 3053: } |
| 5424 | // 3053: } // switch Inst[5:0] |
| 5425 | // 3053: } |
| 5426 | 29, 7, // 3058: case 0x1d: { |
| 5427 | OPC_CheckPredicate, 71, // 3060: check predicate 71 |
| 5428 | OPC_Decode, 151, 15, 241, 1, // 3062: decode to JALX using decoder 241 |
| 5429 | // 3062: } |
| 5430 | 30, 197, 39, // 3067: case 0x1e: { |
| 5431 | OPC_SwitchField, 0, 6, // 3070: switch Inst[5:0] { |
| 5432 | 0, 39, // 3073: case 0x0: { |
| 5433 | OPC_SwitchField, 24, 2, // 3075: switch Inst[25:24] { |
| 5434 | 0, 7, // 3078: case 0x0: { |
| 5435 | OPC_CheckPredicate, 31, // 3080: check predicate 31 |
| 5436 | OPC_Decode, 132, 7, 158, 2, // 3082: decode to ANDI_B using decoder 286 |
| 5437 | // 3082: } |
| 5438 | 1, 7, // 3087: case 0x1: { |
| 5439 | OPC_CheckPredicate, 31, // 3089: check predicate 31 |
| 5440 | OPC_Decode, 193, 19, 158, 2, // 3091: decode to ORI_B using decoder 286 |
| 5441 | // 3091: } |
| 5442 | 2, 7, // 3096: case 0x2: { |
| 5443 | OPC_CheckPredicate, 31, // 3098: check predicate 31 |
| 5444 | OPC_Decode, 178, 19, 158, 2, // 3100: decode to NORI_B using decoder 286 |
| 5445 | // 3100: } |
| 5446 | 3, 0, // 3105: case 0x3: { |
| 5447 | OPC_CheckPredicate, 31, // 3107: check predicate 31 |
| 5448 | OPC_Decode, 196, 24, 158, 2, // 3109: decode to XORI_B using decoder 286 |
| 5449 | // 3109: } |
| 5450 | // 3109: } // switch Inst[25:24] |
| 5451 | // 3109: } |
| 5452 | 1, 30, // 3114: case 0x1: { |
| 5453 | OPC_SwitchField, 24, 2, // 3116: switch Inst[25:24] { |
| 5454 | 0, 7, // 3119: case 0x0: { |
| 5455 | OPC_CheckPredicate, 31, // 3121: check predicate 31 |
| 5456 | OPC_Decode, 199, 8, 159, 2, // 3123: decode to BMNZI_B using decoder 287 |
| 5457 | // 3123: } |
| 5458 | 1, 7, // 3128: case 0x1: { |
| 5459 | OPC_CheckPredicate, 31, // 3130: check predicate 31 |
| 5460 | OPC_Decode, 201, 8, 159, 2, // 3132: decode to BMZI_B using decoder 287 |
| 5461 | // 3132: } |
| 5462 | 2, 0, // 3137: case 0x2: { |
| 5463 | OPC_CheckPredicate, 31, // 3139: check predicate 31 |
| 5464 | OPC_Decode, 249, 8, 159, 2, // 3141: decode to BSELI_B using decoder 287 |
| 5465 | // 3141: } |
| 5466 | // 3141: } // switch Inst[25:24] |
| 5467 | // 3141: } |
| 5468 | 2, 30, // 3146: case 0x2: { |
| 5469 | OPC_SwitchField, 24, 2, // 3148: switch Inst[25:24] { |
| 5470 | 0, 7, // 3151: case 0x0: { |
| 5471 | OPC_CheckPredicate, 31, // 3153: check predicate 31 |
| 5472 | OPC_Decode, 175, 21, 158, 2, // 3155: decode to SHF_B using decoder 286 |
| 5473 | // 3155: } |
| 5474 | 1, 7, // 3160: case 0x1: { |
| 5475 | OPC_CheckPredicate, 31, // 3162: check predicate 31 |
| 5476 | OPC_Decode, 176, 21, 160, 2, // 3164: decode to SHF_H using decoder 288 |
| 5477 | // 3164: } |
| 5478 | 2, 0, // 3169: case 0x2: { |
| 5479 | OPC_CheckPredicate, 31, // 3171: check predicate 31 |
| 5480 | OPC_Decode, 177, 21, 161, 2, // 3173: decode to SHF_W using decoder 289 |
| 5481 | // 3173: } |
| 5482 | // 3173: } // switch Inst[25:24] |
| 5483 | // 3173: } |
| 5484 | 6, 219, 1, // 3178: case 0x6: { |
| 5485 | OPC_SwitchField, 21, 5, // 3181: switch Inst[25:21] { |
| 5486 | 0, 7, // 3184: case 0x0: { |
| 5487 | OPC_CheckPredicate, 31, // 3186: check predicate 31 |
| 5488 | OPC_Decode, 221, 6, 162, 2, // 3188: decode to ADDVI_B using decoder 290 |
| 5489 | // 3188: } |
| 5490 | 1, 7, // 3193: case 0x1: { |
| 5491 | OPC_CheckPredicate, 31, // 3195: check predicate 31 |
| 5492 | OPC_Decode, 223, 6, 163, 2, // 3197: decode to ADDVI_H using decoder 291 |
| 5493 | // 3197: } |
| 5494 | 2, 7, // 3202: case 0x2: { |
| 5495 | OPC_CheckPredicate, 31, // 3204: check predicate 31 |
| 5496 | OPC_Decode, 224, 6, 164, 2, // 3206: decode to ADDVI_W using decoder 292 |
| 5497 | // 3206: } |
| 5498 | 3, 7, // 3211: case 0x3: { |
| 5499 | OPC_CheckPredicate, 31, // 3213: check predicate 31 |
| 5500 | OPC_Decode, 222, 6, 165, 2, // 3215: decode to ADDVI_D using decoder 293 |
| 5501 | // 3215: } |
| 5502 | 4, 7, // 3220: case 0x4: { |
| 5503 | OPC_CheckPredicate, 31, // 3222: check predicate 31 |
| 5504 | OPC_Decode, 135, 23, 162, 2, // 3224: decode to SUBVI_B using decoder 290 |
| 5505 | // 3224: } |
| 5506 | 5, 7, // 3229: case 0x5: { |
| 5507 | OPC_CheckPredicate, 31, // 3231: check predicate 31 |
| 5508 | OPC_Decode, 137, 23, 163, 2, // 3233: decode to SUBVI_H using decoder 291 |
| 5509 | // 3233: } |
| 5510 | 6, 7, // 3238: case 0x6: { |
| 5511 | OPC_CheckPredicate, 31, // 3240: check predicate 31 |
| 5512 | OPC_Decode, 138, 23, 164, 2, // 3242: decode to SUBVI_W using decoder 292 |
| 5513 | // 3242: } |
| 5514 | 7, 7, // 3247: case 0x7: { |
| 5515 | OPC_CheckPredicate, 31, // 3249: check predicate 31 |
| 5516 | OPC_Decode, 136, 23, 165, 2, // 3251: decode to SUBVI_D using decoder 293 |
| 5517 | // 3251: } |
| 5518 | 8, 7, // 3256: case 0x8: { |
| 5519 | OPC_CheckPredicate, 31, // 3258: check predicate 31 |
| 5520 | OPC_Decode, 132, 17, 162, 2, // 3260: decode to MAXI_S_B using decoder 290 |
| 5521 | // 3260: } |
| 5522 | 9, 7, // 3265: case 0x9: { |
| 5523 | OPC_CheckPredicate, 31, // 3267: check predicate 31 |
| 5524 | OPC_Decode, 134, 17, 163, 2, // 3269: decode to MAXI_S_H using decoder 291 |
| 5525 | // 3269: } |
| 5526 | 10, 7, // 3274: case 0xa: { |
| 5527 | OPC_CheckPredicate, 31, // 3276: check predicate 31 |
| 5528 | OPC_Decode, 135, 17, 164, 2, // 3278: decode to MAXI_S_W using decoder 292 |
| 5529 | // 3278: } |
| 5530 | 11, 7, // 3283: case 0xb: { |
| 5531 | OPC_CheckPredicate, 31, // 3285: check predicate 31 |
| 5532 | OPC_Decode, 133, 17, 165, 2, // 3287: decode to MAXI_S_D using decoder 293 |
| 5533 | // 3287: } |
| 5534 | 12, 7, // 3292: case 0xc: { |
| 5535 | OPC_CheckPredicate, 31, // 3294: check predicate 31 |
| 5536 | OPC_Decode, 136, 17, 162, 2, // 3296: decode to MAXI_U_B using decoder 290 |
| 5537 | // 3296: } |
| 5538 | 13, 7, // 3301: case 0xd: { |
| 5539 | OPC_CheckPredicate, 31, // 3303: check predicate 31 |
| 5540 | OPC_Decode, 138, 17, 163, 2, // 3305: decode to MAXI_U_H using decoder 291 |
| 5541 | // 3305: } |
| 5542 | 14, 7, // 3310: case 0xe: { |
| 5543 | OPC_CheckPredicate, 31, // 3312: check predicate 31 |
| 5544 | OPC_Decode, 139, 17, 164, 2, // 3314: decode to MAXI_U_W using decoder 292 |
| 5545 | // 3314: } |
| 5546 | 15, 7, // 3319: case 0xf: { |
| 5547 | OPC_CheckPredicate, 31, // 3321: check predicate 31 |
| 5548 | OPC_Decode, 137, 17, 165, 2, // 3323: decode to MAXI_U_D using decoder 293 |
| 5549 | // 3323: } |
| 5550 | 16, 7, // 3328: case 0x10: { |
| 5551 | OPC_CheckPredicate, 31, // 3330: check predicate 31 |
| 5552 | OPC_Decode, 194, 17, 162, 2, // 3332: decode to MINI_S_B using decoder 290 |
| 5553 | // 3332: } |
| 5554 | 17, 7, // 3337: case 0x11: { |
| 5555 | OPC_CheckPredicate, 31, // 3339: check predicate 31 |
| 5556 | OPC_Decode, 196, 17, 163, 2, // 3341: decode to MINI_S_H using decoder 291 |
| 5557 | // 3341: } |
| 5558 | 18, 7, // 3346: case 0x12: { |
| 5559 | OPC_CheckPredicate, 31, // 3348: check predicate 31 |
| 5560 | OPC_Decode, 197, 17, 164, 2, // 3350: decode to MINI_S_W using decoder 292 |
| 5561 | // 3350: } |
| 5562 | 19, 7, // 3355: case 0x13: { |
| 5563 | OPC_CheckPredicate, 31, // 3357: check predicate 31 |
| 5564 | OPC_Decode, 195, 17, 165, 2, // 3359: decode to MINI_S_D using decoder 293 |
| 5565 | // 3359: } |
| 5566 | 20, 7, // 3364: case 0x14: { |
| 5567 | OPC_CheckPredicate, 31, // 3366: check predicate 31 |
| 5568 | OPC_Decode, 198, 17, 162, 2, // 3368: decode to MINI_U_B using decoder 290 |
| 5569 | // 3368: } |
| 5570 | 21, 7, // 3373: case 0x15: { |
| 5571 | OPC_CheckPredicate, 31, // 3375: check predicate 31 |
| 5572 | OPC_Decode, 200, 17, 163, 2, // 3377: decode to MINI_U_H using decoder 291 |
| 5573 | // 3377: } |
| 5574 | 22, 7, // 3382: case 0x16: { |
| 5575 | OPC_CheckPredicate, 31, // 3384: check predicate 31 |
| 5576 | OPC_Decode, 201, 17, 164, 2, // 3386: decode to MINI_U_W using decoder 292 |
| 5577 | // 3386: } |
| 5578 | 23, 0, // 3391: case 0x17: { |
| 5579 | OPC_CheckPredicate, 31, // 3393: check predicate 31 |
| 5580 | OPC_Decode, 199, 17, 165, 2, // 3395: decode to MINI_U_D using decoder 293 |
| 5581 | // 3395: } |
| 5582 | // 3395: } // switch Inst[25:21] |
| 5583 | // 3395: } |
| 5584 | 7, 219, 1, // 3400: case 0x7: { |
| 5585 | OPC_SwitchField, 21, 5, // 3403: switch Inst[25:21] { |
| 5586 | 0, 7, // 3406: case 0x0: { |
| 5587 | OPC_CheckPredicate, 31, // 3408: check predicate 31 |
| 5588 | OPC_Decode, 166, 9, 162, 2, // 3410: decode to CEQI_B using decoder 290 |
| 5589 | // 3410: } |
| 5590 | 1, 7, // 3415: case 0x1: { |
| 5591 | OPC_CheckPredicate, 31, // 3417: check predicate 31 |
| 5592 | OPC_Decode, 168, 9, 163, 2, // 3419: decode to CEQI_H using decoder 291 |
| 5593 | // 3419: } |
| 5594 | 2, 7, // 3424: case 0x2: { |
| 5595 | OPC_CheckPredicate, 31, // 3426: check predicate 31 |
| 5596 | OPC_Decode, 169, 9, 164, 2, // 3428: decode to CEQI_W using decoder 292 |
| 5597 | // 3428: } |
| 5598 | 3, 7, // 3433: case 0x3: { |
| 5599 | OPC_CheckPredicate, 31, // 3435: check predicate 31 |
| 5600 | OPC_Decode, 167, 9, 165, 2, // 3437: decode to CEQI_D using decoder 293 |
| 5601 | // 3437: } |
| 5602 | 8, 7, // 3442: case 0x8: { |
| 5603 | OPC_CheckPredicate, 31, // 3444: check predicate 31 |
| 5604 | OPC_Decode, 207, 9, 162, 2, // 3446: decode to CLTI_S_B using decoder 290 |
| 5605 | // 3446: } |
| 5606 | 9, 7, // 3451: case 0x9: { |
| 5607 | OPC_CheckPredicate, 31, // 3453: check predicate 31 |
| 5608 | OPC_Decode, 209, 9, 163, 2, // 3455: decode to CLTI_S_H using decoder 291 |
| 5609 | // 3455: } |
| 5610 | 10, 7, // 3460: case 0xa: { |
| 5611 | OPC_CheckPredicate, 31, // 3462: check predicate 31 |
| 5612 | OPC_Decode, 210, 9, 164, 2, // 3464: decode to CLTI_S_W using decoder 292 |
| 5613 | // 3464: } |
| 5614 | 11, 7, // 3469: case 0xb: { |
| 5615 | OPC_CheckPredicate, 31, // 3471: check predicate 31 |
| 5616 | OPC_Decode, 208, 9, 165, 2, // 3473: decode to CLTI_S_D using decoder 293 |
| 5617 | // 3473: } |
| 5618 | 12, 7, // 3478: case 0xc: { |
| 5619 | OPC_CheckPredicate, 31, // 3480: check predicate 31 |
| 5620 | OPC_Decode, 211, 9, 162, 2, // 3482: decode to CLTI_U_B using decoder 290 |
| 5621 | // 3482: } |
| 5622 | 13, 7, // 3487: case 0xd: { |
| 5623 | OPC_CheckPredicate, 31, // 3489: check predicate 31 |
| 5624 | OPC_Decode, 213, 9, 163, 2, // 3491: decode to CLTI_U_H using decoder 291 |
| 5625 | // 3491: } |
| 5626 | 14, 7, // 3496: case 0xe: { |
| 5627 | OPC_CheckPredicate, 31, // 3498: check predicate 31 |
| 5628 | OPC_Decode, 214, 9, 164, 2, // 3500: decode to CLTI_U_W using decoder 292 |
| 5629 | // 3500: } |
| 5630 | 15, 7, // 3505: case 0xf: { |
| 5631 | OPC_CheckPredicate, 31, // 3507: check predicate 31 |
| 5632 | OPC_Decode, 212, 9, 165, 2, // 3509: decode to CLTI_U_D using decoder 293 |
| 5633 | // 3509: } |
| 5634 | 16, 7, // 3514: case 0x10: { |
| 5635 | OPC_CheckPredicate, 31, // 3516: check predicate 31 |
| 5636 | OPC_Decode, 186, 9, 162, 2, // 3518: decode to CLEI_S_B using decoder 290 |
| 5637 | // 3518: } |
| 5638 | 17, 7, // 3523: case 0x11: { |
| 5639 | OPC_CheckPredicate, 31, // 3525: check predicate 31 |
| 5640 | OPC_Decode, 188, 9, 163, 2, // 3527: decode to CLEI_S_H using decoder 291 |
| 5641 | // 3527: } |
| 5642 | 18, 7, // 3532: case 0x12: { |
| 5643 | OPC_CheckPredicate, 31, // 3534: check predicate 31 |
| 5644 | OPC_Decode, 189, 9, 164, 2, // 3536: decode to CLEI_S_W using decoder 292 |
| 5645 | // 3536: } |
| 5646 | 19, 7, // 3541: case 0x13: { |
| 5647 | OPC_CheckPredicate, 31, // 3543: check predicate 31 |
| 5648 | OPC_Decode, 187, 9, 165, 2, // 3545: decode to CLEI_S_D using decoder 293 |
| 5649 | // 3545: } |
| 5650 | 20, 7, // 3550: case 0x14: { |
| 5651 | OPC_CheckPredicate, 31, // 3552: check predicate 31 |
| 5652 | OPC_Decode, 190, 9, 162, 2, // 3554: decode to CLEI_U_B using decoder 290 |
| 5653 | // 3554: } |
| 5654 | 21, 7, // 3559: case 0x15: { |
| 5655 | OPC_CheckPredicate, 31, // 3561: check predicate 31 |
| 5656 | OPC_Decode, 192, 9, 163, 2, // 3563: decode to CLEI_U_H using decoder 291 |
| 5657 | // 3563: } |
| 5658 | 22, 7, // 3568: case 0x16: { |
| 5659 | OPC_CheckPredicate, 31, // 3570: check predicate 31 |
| 5660 | OPC_Decode, 193, 9, 164, 2, // 3572: decode to CLEI_U_W using decoder 292 |
| 5661 | // 3572: } |
| 5662 | 23, 7, // 3577: case 0x17: { |
| 5663 | OPC_CheckPredicate, 31, // 3579: check predicate 31 |
| 5664 | OPC_Decode, 191, 9, 165, 2, // 3581: decode to CLEI_U_D using decoder 293 |
| 5665 | // 3581: } |
| 5666 | 24, 7, // 3586: case 0x18: { |
| 5667 | OPC_CheckPredicate, 31, // 3588: check predicate 31 |
| 5668 | OPC_Decode, 218, 15, 166, 2, // 3590: decode to LDI_B using decoder 294 |
| 5669 | // 3590: } |
| 5670 | 25, 7, // 3595: case 0x19: { |
| 5671 | OPC_CheckPredicate, 31, // 3597: check predicate 31 |
| 5672 | OPC_Decode, 220, 15, 167, 2, // 3599: decode to LDI_H using decoder 295 |
| 5673 | // 3599: } |
| 5674 | 26, 7, // 3604: case 0x1a: { |
| 5675 | OPC_CheckPredicate, 31, // 3606: check predicate 31 |
| 5676 | OPC_Decode, 221, 15, 168, 2, // 3608: decode to LDI_W using decoder 296 |
| 5677 | // 3608: } |
| 5678 | 27, 0, // 3613: case 0x1b: { |
| 5679 | OPC_CheckPredicate, 31, // 3615: check predicate 31 |
| 5680 | OPC_Decode, 219, 15, 169, 2, // 3617: decode to LDI_D using decoder 297 |
| 5681 | // 3617: } |
| 5682 | // 3617: } // switch Inst[25:21] |
| 5683 | // 3617: } |
| 5684 | 9, 147, 3, // 3622: case 0x9: { |
| 5685 | OPC_SwitchField, 22, 4, // 3625: switch Inst[25:22] { |
| 5686 | 0, 7, // 3628: case 0x0: { |
| 5687 | OPC_CheckPredicate, 31, // 3630: check predicate 31 |
| 5688 | OPC_Decode, 251, 21, 170, 2, // 3632: decode to SLLI_D using decoder 298 |
| 5689 | // 3632: } |
| 5690 | 1, 39, // 3637: case 0x1: { |
| 5691 | OPC_SwitchField, 21, 1, // 3639: switch Inst[21] { |
| 5692 | 0, 7, // 3642: case 0x0: { |
| 5693 | OPC_CheckPredicate, 31, // 3644: check predicate 31 |
| 5694 | OPC_Decode, 253, 21, 164, 2, // 3646: decode to SLLI_W using decoder 292 |
| 5695 | // 3646: } |
| 5696 | 1, 0, // 3651: case 0x1: { |
| 5697 | OPC_SwitchField, 20, 1, // 3653: switch Inst[20] { |
| 5698 | 0, 7, // 3656: case 0x0: { |
| 5699 | OPC_CheckPredicate, 31, // 3658: check predicate 31 |
| 5700 | OPC_Decode, 252, 21, 171, 2, // 3660: decode to SLLI_H using decoder 299 |
| 5701 | // 3660: } |
| 5702 | 1, 0, // 3665: case 0x1: { |
| 5703 | OPC_CheckPredicate, 31, // 3667: check predicate 31 |
| 5704 | OPC_CheckField, 19, 1, 0, // 3669: check Inst[19] == 0x0 |
| 5705 | OPC_Decode, 250, 21, 172, 2, // 3673: decode to SLLI_B using decoder 300 |
| 5706 | // 3673: } |
| 5707 | // 3673: } // switch Inst[20] |
| 5708 | // 3673: } |
| 5709 | // 3673: } // switch Inst[21] |
| 5710 | // 3673: } |
| 5711 | 2, 7, // 3678: case 0x2: { |
| 5712 | OPC_CheckPredicate, 31, // 3680: check predicate 31 |
| 5713 | OPC_Decode, 165, 22, 170, 2, // 3682: decode to SRAI_D using decoder 298 |
| 5714 | // 3682: } |
| 5715 | 3, 39, // 3687: case 0x3: { |
| 5716 | OPC_SwitchField, 21, 1, // 3689: switch Inst[21] { |
| 5717 | 0, 7, // 3692: case 0x0: { |
| 5718 | OPC_CheckPredicate, 31, // 3694: check predicate 31 |
| 5719 | OPC_Decode, 167, 22, 164, 2, // 3696: decode to SRAI_W using decoder 292 |
| 5720 | // 3696: } |
| 5721 | 1, 0, // 3701: case 0x1: { |
| 5722 | OPC_SwitchField, 20, 1, // 3703: switch Inst[20] { |
| 5723 | 0, 7, // 3706: case 0x0: { |
| 5724 | OPC_CheckPredicate, 31, // 3708: check predicate 31 |
| 5725 | OPC_Decode, 166, 22, 171, 2, // 3710: decode to SRAI_H using decoder 299 |
| 5726 | // 3710: } |
| 5727 | 1, 0, // 3715: case 0x1: { |
| 5728 | OPC_CheckPredicate, 31, // 3717: check predicate 31 |
| 5729 | OPC_CheckField, 19, 1, 0, // 3719: check Inst[19] == 0x0 |
| 5730 | OPC_Decode, 164, 22, 172, 2, // 3723: decode to SRAI_B using decoder 300 |
| 5731 | // 3723: } |
| 5732 | // 3723: } // switch Inst[20] |
| 5733 | // 3723: } |
| 5734 | // 3723: } // switch Inst[21] |
| 5735 | // 3723: } |
| 5736 | 4, 7, // 3728: case 0x4: { |
| 5737 | OPC_CheckPredicate, 31, // 3730: check predicate 31 |
| 5738 | OPC_Decode, 190, 22, 170, 2, // 3732: decode to SRLI_D using decoder 298 |
| 5739 | // 3732: } |
| 5740 | 5, 39, // 3737: case 0x5: { |
| 5741 | OPC_SwitchField, 21, 1, // 3739: switch Inst[21] { |
| 5742 | 0, 7, // 3742: case 0x0: { |
| 5743 | OPC_CheckPredicate, 31, // 3744: check predicate 31 |
| 5744 | OPC_Decode, 192, 22, 164, 2, // 3746: decode to SRLI_W using decoder 292 |
| 5745 | // 3746: } |
| 5746 | 1, 0, // 3751: case 0x1: { |
| 5747 | OPC_SwitchField, 20, 1, // 3753: switch Inst[20] { |
| 5748 | 0, 7, // 3756: case 0x0: { |
| 5749 | OPC_CheckPredicate, 31, // 3758: check predicate 31 |
| 5750 | OPC_Decode, 191, 22, 171, 2, // 3760: decode to SRLI_H using decoder 299 |
| 5751 | // 3760: } |
| 5752 | 1, 0, // 3765: case 0x1: { |
| 5753 | OPC_CheckPredicate, 31, // 3767: check predicate 31 |
| 5754 | OPC_CheckField, 19, 1, 0, // 3769: check Inst[19] == 0x0 |
| 5755 | OPC_Decode, 189, 22, 172, 2, // 3773: decode to SRLI_B using decoder 300 |
| 5756 | // 3773: } |
| 5757 | // 3773: } // switch Inst[20] |
| 5758 | // 3773: } |
| 5759 | // 3773: } // switch Inst[21] |
| 5760 | // 3773: } |
| 5761 | 6, 7, // 3778: case 0x6: { |
| 5762 | OPC_CheckPredicate, 31, // 3780: check predicate 31 |
| 5763 | OPC_Decode, 215, 7, 170, 2, // 3782: decode to BCLRI_D using decoder 298 |
| 5764 | // 3782: } |
| 5765 | 7, 39, // 3787: case 0x7: { |
| 5766 | OPC_SwitchField, 21, 1, // 3789: switch Inst[21] { |
| 5767 | 0, 7, // 3792: case 0x0: { |
| 5768 | OPC_CheckPredicate, 31, // 3794: check predicate 31 |
| 5769 | OPC_Decode, 217, 7, 164, 2, // 3796: decode to BCLRI_W using decoder 292 |
| 5770 | // 3796: } |
| 5771 | 1, 0, // 3801: case 0x1: { |
| 5772 | OPC_SwitchField, 20, 1, // 3803: switch Inst[20] { |
| 5773 | 0, 7, // 3806: case 0x0: { |
| 5774 | OPC_CheckPredicate, 31, // 3808: check predicate 31 |
| 5775 | OPC_Decode, 216, 7, 171, 2, // 3810: decode to BCLRI_H using decoder 299 |
| 5776 | // 3810: } |
| 5777 | 1, 0, // 3815: case 0x1: { |
| 5778 | OPC_CheckPredicate, 31, // 3817: check predicate 31 |
| 5779 | OPC_CheckField, 19, 1, 0, // 3819: check Inst[19] == 0x0 |
| 5780 | OPC_Decode, 214, 7, 172, 2, // 3823: decode to BCLRI_B using decoder 300 |
| 5781 | // 3823: } |
| 5782 | // 3823: } // switch Inst[20] |
| 5783 | // 3823: } |
| 5784 | // 3823: } // switch Inst[21] |
| 5785 | // 3823: } |
| 5786 | 8, 7, // 3828: case 0x8: { |
| 5787 | OPC_CheckPredicate, 31, // 3830: check predicate 31 |
| 5788 | OPC_Decode, 252, 8, 170, 2, // 3832: decode to BSETI_D using decoder 298 |
| 5789 | // 3832: } |
| 5790 | 9, 39, // 3837: case 0x9: { |
| 5791 | OPC_SwitchField, 21, 1, // 3839: switch Inst[21] { |
| 5792 | 0, 7, // 3842: case 0x0: { |
| 5793 | OPC_CheckPredicate, 31, // 3844: check predicate 31 |
| 5794 | OPC_Decode, 254, 8, 164, 2, // 3846: decode to BSETI_W using decoder 292 |
| 5795 | // 3846: } |
| 5796 | 1, 0, // 3851: case 0x1: { |
| 5797 | OPC_SwitchField, 20, 1, // 3853: switch Inst[20] { |
| 5798 | 0, 7, // 3856: case 0x0: { |
| 5799 | OPC_CheckPredicate, 31, // 3858: check predicate 31 |
| 5800 | OPC_Decode, 253, 8, 171, 2, // 3860: decode to BSETI_H using decoder 299 |
| 5801 | // 3860: } |
| 5802 | 1, 0, // 3865: case 0x1: { |
| 5803 | OPC_CheckPredicate, 31, // 3867: check predicate 31 |
| 5804 | OPC_CheckField, 19, 1, 0, // 3869: check Inst[19] == 0x0 |
| 5805 | OPC_Decode, 251, 8, 172, 2, // 3873: decode to BSETI_B using decoder 300 |
| 5806 | // 3873: } |
| 5807 | // 3873: } // switch Inst[20] |
| 5808 | // 3873: } |
| 5809 | // 3873: } // switch Inst[21] |
| 5810 | // 3873: } |
| 5811 | 10, 7, // 3878: case 0xa: { |
| 5812 | OPC_CheckPredicate, 31, // 3880: check predicate 31 |
| 5813 | OPC_Decode, 210, 8, 170, 2, // 3882: decode to BNEGI_D using decoder 298 |
| 5814 | // 3882: } |
| 5815 | 11, 39, // 3887: case 0xb: { |
| 5816 | OPC_SwitchField, 21, 1, // 3889: switch Inst[21] { |
| 5817 | 0, 7, // 3892: case 0x0: { |
| 5818 | OPC_CheckPredicate, 31, // 3894: check predicate 31 |
| 5819 | OPC_Decode, 212, 8, 164, 2, // 3896: decode to BNEGI_W using decoder 292 |
| 5820 | // 3896: } |
| 5821 | 1, 0, // 3901: case 0x1: { |
| 5822 | OPC_SwitchField, 20, 1, // 3903: switch Inst[20] { |
| 5823 | 0, 7, // 3906: case 0x0: { |
| 5824 | OPC_CheckPredicate, 31, // 3908: check predicate 31 |
| 5825 | OPC_Decode, 211, 8, 171, 2, // 3910: decode to BNEGI_H using decoder 299 |
| 5826 | // 3910: } |
| 5827 | 1, 0, // 3915: case 0x1: { |
| 5828 | OPC_CheckPredicate, 31, // 3917: check predicate 31 |
| 5829 | OPC_CheckField, 19, 1, 0, // 3919: check Inst[19] == 0x0 |
| 5830 | OPC_Decode, 209, 8, 172, 2, // 3923: decode to BNEGI_B using decoder 300 |
| 5831 | // 3923: } |
| 5832 | // 3923: } // switch Inst[20] |
| 5833 | // 3923: } |
| 5834 | // 3923: } // switch Inst[21] |
| 5835 | // 3923: } |
| 5836 | 12, 7, // 3928: case 0xc: { |
| 5837 | OPC_CheckPredicate, 31, // 3930: check predicate 31 |
| 5838 | OPC_Decode, 147, 8, 173, 2, // 3932: decode to BINSLI_D using decoder 301 |
| 5839 | // 3932: } |
| 5840 | 13, 39, // 3937: case 0xd: { |
| 5841 | OPC_SwitchField, 21, 1, // 3939: switch Inst[21] { |
| 5842 | 0, 7, // 3942: case 0x0: { |
| 5843 | OPC_CheckPredicate, 31, // 3944: check predicate 31 |
| 5844 | OPC_Decode, 149, 8, 174, 2, // 3946: decode to BINSLI_W using decoder 302 |
| 5845 | // 3946: } |
| 5846 | 1, 0, // 3951: case 0x1: { |
| 5847 | OPC_SwitchField, 20, 1, // 3953: switch Inst[20] { |
| 5848 | 0, 7, // 3956: case 0x0: { |
| 5849 | OPC_CheckPredicate, 31, // 3958: check predicate 31 |
| 5850 | OPC_Decode, 148, 8, 175, 2, // 3960: decode to BINSLI_H using decoder 303 |
| 5851 | // 3960: } |
| 5852 | 1, 0, // 3965: case 0x1: { |
| 5853 | OPC_CheckPredicate, 31, // 3967: check predicate 31 |
| 5854 | OPC_CheckField, 19, 1, 0, // 3969: check Inst[19] == 0x0 |
| 5855 | OPC_Decode, 146, 8, 176, 2, // 3973: decode to BINSLI_B using decoder 304 |
| 5856 | // 3973: } |
| 5857 | // 3973: } // switch Inst[20] |
| 5858 | // 3973: } |
| 5859 | // 3973: } // switch Inst[21] |
| 5860 | // 3973: } |
| 5861 | 14, 7, // 3978: case 0xe: { |
| 5862 | OPC_CheckPredicate, 31, // 3980: check predicate 31 |
| 5863 | OPC_Decode, 155, 8, 173, 2, // 3982: decode to BINSRI_D using decoder 301 |
| 5864 | // 3982: } |
| 5865 | 15, 0, // 3987: case 0xf: { |
| 5866 | OPC_SwitchField, 21, 1, // 3989: switch Inst[21] { |
| 5867 | 0, 7, // 3992: case 0x0: { |
| 5868 | OPC_CheckPredicate, 31, // 3994: check predicate 31 |
| 5869 | OPC_Decode, 157, 8, 174, 2, // 3996: decode to BINSRI_W using decoder 302 |
| 5870 | // 3996: } |
| 5871 | 1, 0, // 4001: case 0x1: { |
| 5872 | OPC_SwitchField, 20, 1, // 4003: switch Inst[20] { |
| 5873 | 0, 7, // 4006: case 0x0: { |
| 5874 | OPC_CheckPredicate, 31, // 4008: check predicate 31 |
| 5875 | OPC_Decode, 156, 8, 175, 2, // 4010: decode to BINSRI_H using decoder 303 |
| 5876 | // 4010: } |
| 5877 | 1, 0, // 4015: case 0x1: { |
| 5878 | OPC_CheckPredicate, 31, // 4017: check predicate 31 |
| 5879 | OPC_CheckField, 19, 1, 0, // 4019: check Inst[19] == 0x0 |
| 5880 | OPC_Decode, 154, 8, 176, 2, // 4023: decode to BINSRI_B using decoder 304 |
| 5881 | // 4023: } |
| 5882 | // 4023: } // switch Inst[20] |
| 5883 | // 4023: } |
| 5884 | // 4023: } // switch Inst[21] |
| 5885 | // 4023: } |
| 5886 | // 4023: } // switch Inst[25:22] |
| 5887 | // 4023: } |
| 5888 | 10, 203, 1, // 4028: case 0xa: { |
| 5889 | OPC_SwitchField, 22, 4, // 4031: switch Inst[25:22] { |
| 5890 | 0, 7, // 4034: case 0x0: { |
| 5891 | OPC_CheckPredicate, 31, // 4036: check predicate 31 |
| 5892 | OPC_Decode, 209, 20, 170, 2, // 4038: decode to SAT_S_D using decoder 298 |
| 5893 | // 4038: } |
| 5894 | 1, 39, // 4043: case 0x1: { |
| 5895 | OPC_SwitchField, 21, 1, // 4045: switch Inst[21] { |
| 5896 | 0, 7, // 4048: case 0x0: { |
| 5897 | OPC_CheckPredicate, 31, // 4050: check predicate 31 |
| 5898 | OPC_Decode, 211, 20, 164, 2, // 4052: decode to SAT_S_W using decoder 292 |
| 5899 | // 4052: } |
| 5900 | 1, 0, // 4057: case 0x1: { |
| 5901 | OPC_SwitchField, 20, 1, // 4059: switch Inst[20] { |
| 5902 | 0, 7, // 4062: case 0x0: { |
| 5903 | OPC_CheckPredicate, 31, // 4064: check predicate 31 |
| 5904 | OPC_Decode, 210, 20, 171, 2, // 4066: decode to SAT_S_H using decoder 299 |
| 5905 | // 4066: } |
| 5906 | 1, 0, // 4071: case 0x1: { |
| 5907 | OPC_CheckPredicate, 31, // 4073: check predicate 31 |
| 5908 | OPC_CheckField, 19, 1, 0, // 4075: check Inst[19] == 0x0 |
| 5909 | OPC_Decode, 208, 20, 172, 2, // 4079: decode to SAT_S_B using decoder 300 |
| 5910 | // 4079: } |
| 5911 | // 4079: } // switch Inst[20] |
| 5912 | // 4079: } |
| 5913 | // 4079: } // switch Inst[21] |
| 5914 | // 4079: } |
| 5915 | 2, 7, // 4084: case 0x2: { |
| 5916 | OPC_CheckPredicate, 31, // 4086: check predicate 31 |
| 5917 | OPC_Decode, 213, 20, 170, 2, // 4088: decode to SAT_U_D using decoder 298 |
| 5918 | // 4088: } |
| 5919 | 3, 39, // 4093: case 0x3: { |
| 5920 | OPC_SwitchField, 21, 1, // 4095: switch Inst[21] { |
| 5921 | 0, 7, // 4098: case 0x0: { |
| 5922 | OPC_CheckPredicate, 31, // 4100: check predicate 31 |
| 5923 | OPC_Decode, 215, 20, 164, 2, // 4102: decode to SAT_U_W using decoder 292 |
| 5924 | // 4102: } |
| 5925 | 1, 0, // 4107: case 0x1: { |
| 5926 | OPC_SwitchField, 20, 1, // 4109: switch Inst[20] { |
| 5927 | 0, 7, // 4112: case 0x0: { |
| 5928 | OPC_CheckPredicate, 31, // 4114: check predicate 31 |
| 5929 | OPC_Decode, 214, 20, 171, 2, // 4116: decode to SAT_U_H using decoder 299 |
| 5930 | // 4116: } |
| 5931 | 1, 0, // 4121: case 0x1: { |
| 5932 | OPC_CheckPredicate, 31, // 4123: check predicate 31 |
| 5933 | OPC_CheckField, 19, 1, 0, // 4125: check Inst[19] == 0x0 |
| 5934 | OPC_Decode, 212, 20, 172, 2, // 4129: decode to SAT_U_B using decoder 300 |
| 5935 | // 4129: } |
| 5936 | // 4129: } // switch Inst[20] |
| 5937 | // 4129: } |
| 5938 | // 4129: } // switch Inst[21] |
| 5939 | // 4129: } |
| 5940 | 4, 7, // 4134: case 0x4: { |
| 5941 | OPC_CheckPredicate, 31, // 4136: check predicate 31 |
| 5942 | OPC_Decode, 169, 22, 170, 2, // 4138: decode to SRARI_D using decoder 298 |
| 5943 | // 4138: } |
| 5944 | 5, 39, // 4143: case 0x5: { |
| 5945 | OPC_SwitchField, 21, 1, // 4145: switch Inst[21] { |
| 5946 | 0, 7, // 4148: case 0x0: { |
| 5947 | OPC_CheckPredicate, 31, // 4150: check predicate 31 |
| 5948 | OPC_Decode, 171, 22, 164, 2, // 4152: decode to SRARI_W using decoder 292 |
| 5949 | // 4152: } |
| 5950 | 1, 0, // 4157: case 0x1: { |
| 5951 | OPC_SwitchField, 20, 1, // 4159: switch Inst[20] { |
| 5952 | 0, 7, // 4162: case 0x0: { |
| 5953 | OPC_CheckPredicate, 31, // 4164: check predicate 31 |
| 5954 | OPC_Decode, 170, 22, 171, 2, // 4166: decode to SRARI_H using decoder 299 |
| 5955 | // 4166: } |
| 5956 | 1, 0, // 4171: case 0x1: { |
| 5957 | OPC_CheckPredicate, 31, // 4173: check predicate 31 |
| 5958 | OPC_CheckField, 19, 1, 0, // 4175: check Inst[19] == 0x0 |
| 5959 | OPC_Decode, 168, 22, 172, 2, // 4179: decode to SRARI_B using decoder 300 |
| 5960 | // 4179: } |
| 5961 | // 4179: } // switch Inst[20] |
| 5962 | // 4179: } |
| 5963 | // 4179: } // switch Inst[21] |
| 5964 | // 4179: } |
| 5965 | 6, 7, // 4184: case 0x6: { |
| 5966 | OPC_CheckPredicate, 31, // 4186: check predicate 31 |
| 5967 | OPC_Decode, 194, 22, 170, 2, // 4188: decode to SRLRI_D using decoder 298 |
| 5968 | // 4188: } |
| 5969 | 7, 0, // 4193: case 0x7: { |
| 5970 | OPC_SwitchField, 21, 1, // 4195: switch Inst[21] { |
| 5971 | 0, 7, // 4198: case 0x0: { |
| 5972 | OPC_CheckPredicate, 31, // 4200: check predicate 31 |
| 5973 | OPC_Decode, 196, 22, 164, 2, // 4202: decode to SRLRI_W using decoder 292 |
| 5974 | // 4202: } |
| 5975 | 1, 0, // 4207: case 0x1: { |
| 5976 | OPC_SwitchField, 20, 1, // 4209: switch Inst[20] { |
| 5977 | 0, 7, // 4212: case 0x0: { |
| 5978 | OPC_CheckPredicate, 31, // 4214: check predicate 31 |
| 5979 | OPC_Decode, 195, 22, 171, 2, // 4216: decode to SRLRI_H using decoder 299 |
| 5980 | // 4216: } |
| 5981 | 1, 0, // 4221: case 0x1: { |
| 5982 | OPC_CheckPredicate, 31, // 4223: check predicate 31 |
| 5983 | OPC_CheckField, 19, 1, 0, // 4225: check Inst[19] == 0x0 |
| 5984 | OPC_Decode, 193, 22, 172, 2, // 4229: decode to SRLRI_B using decoder 300 |
| 5985 | // 4229: } |
| 5986 | // 4229: } // switch Inst[20] |
| 5987 | // 4229: } |
| 5988 | // 4229: } // switch Inst[21] |
| 5989 | // 4229: } |
| 5990 | // 4229: } // switch Inst[25:22] |
| 5991 | // 4229: } |
| 5992 | 13, 163, 2, // 4234: case 0xd: { |
| 5993 | OPC_SwitchField, 21, 5, // 4237: switch Inst[25:21] { |
| 5994 | 0, 7, // 4240: case 0x0: { |
| 5995 | OPC_CheckPredicate, 31, // 4242: check predicate 31 |
| 5996 | OPC_Decode, 129, 22, 177, 2, // 4244: decode to SLL_B using decoder 305 |
| 5997 | // 4244: } |
| 5998 | 1, 7, // 4249: case 0x1: { |
| 5999 | OPC_CheckPredicate, 31, // 4251: check predicate 31 |
| 6000 | OPC_Decode, 131, 22, 178, 2, // 4253: decode to SLL_H using decoder 306 |
| 6001 | // 4253: } |
| 6002 | 2, 7, // 4258: case 0x2: { |
| 6003 | OPC_CheckPredicate, 31, // 4260: check predicate 31 |
| 6004 | OPC_Decode, 135, 22, 179, 2, // 4262: decode to SLL_W using decoder 307 |
| 6005 | // 4262: } |
| 6006 | 3, 7, // 4267: case 0x3: { |
| 6007 | OPC_CheckPredicate, 31, // 4269: check predicate 31 |
| 6008 | OPC_Decode, 130, 22, 180, 2, // 4271: decode to SLL_D using decoder 308 |
| 6009 | // 4271: } |
| 6010 | 4, 7, // 4276: case 0x4: { |
| 6011 | OPC_CheckPredicate, 31, // 4278: check predicate 31 |
| 6012 | OPC_Decode, 179, 22, 177, 2, // 4280: decode to SRA_B using decoder 305 |
| 6013 | // 4280: } |
| 6014 | 5, 7, // 4285: case 0x5: { |
| 6015 | OPC_CheckPredicate, 31, // 4287: check predicate 31 |
| 6016 | OPC_Decode, 181, 22, 178, 2, // 4289: decode to SRA_H using decoder 306 |
| 6017 | // 4289: } |
| 6018 | 6, 7, // 4294: case 0x6: { |
| 6019 | OPC_CheckPredicate, 31, // 4296: check predicate 31 |
| 6020 | OPC_Decode, 184, 22, 179, 2, // 4298: decode to SRA_W using decoder 307 |
| 6021 | // 4298: } |
| 6022 | 7, 7, // 4303: case 0x7: { |
| 6023 | OPC_CheckPredicate, 31, // 4305: check predicate 31 |
| 6024 | OPC_Decode, 180, 22, 180, 2, // 4307: decode to SRA_D using decoder 308 |
| 6025 | // 4307: } |
| 6026 | 8, 7, // 4312: case 0x8: { |
| 6027 | OPC_CheckPredicate, 31, // 4314: check predicate 31 |
| 6028 | OPC_Decode, 204, 22, 177, 2, // 4316: decode to SRL_B using decoder 305 |
| 6029 | // 4316: } |
| 6030 | 9, 7, // 4321: case 0x9: { |
| 6031 | OPC_CheckPredicate, 31, // 4323: check predicate 31 |
| 6032 | OPC_Decode, 206, 22, 178, 2, // 4325: decode to SRL_H using decoder 306 |
| 6033 | // 4325: } |
| 6034 | 10, 7, // 4330: case 0xa: { |
| 6035 | OPC_CheckPredicate, 31, // 4332: check predicate 31 |
| 6036 | OPC_Decode, 209, 22, 179, 2, // 4334: decode to SRL_W using decoder 307 |
| 6037 | // 4334: } |
| 6038 | 11, 7, // 4339: case 0xb: { |
| 6039 | OPC_CheckPredicate, 31, // 4341: check predicate 31 |
| 6040 | OPC_Decode, 205, 22, 180, 2, // 4343: decode to SRL_D using decoder 308 |
| 6041 | // 4343: } |
| 6042 | 12, 7, // 4348: case 0xc: { |
| 6043 | OPC_CheckPredicate, 31, // 4350: check predicate 31 |
| 6044 | OPC_Decode, 218, 7, 177, 2, // 4352: decode to BCLR_B using decoder 305 |
| 6045 | // 4352: } |
| 6046 | 13, 7, // 4357: case 0xd: { |
| 6047 | OPC_CheckPredicate, 31, // 4359: check predicate 31 |
| 6048 | OPC_Decode, 220, 7, 178, 2, // 4361: decode to BCLR_H using decoder 306 |
| 6049 | // 4361: } |
| 6050 | 14, 7, // 4366: case 0xe: { |
| 6051 | OPC_CheckPredicate, 31, // 4368: check predicate 31 |
| 6052 | OPC_Decode, 221, 7, 179, 2, // 4370: decode to BCLR_W using decoder 307 |
| 6053 | // 4370: } |
| 6054 | 15, 7, // 4375: case 0xf: { |
| 6055 | OPC_CheckPredicate, 31, // 4377: check predicate 31 |
| 6056 | OPC_Decode, 219, 7, 180, 2, // 4379: decode to BCLR_D using decoder 308 |
| 6057 | // 4379: } |
| 6058 | 16, 7, // 4384: case 0x10: { |
| 6059 | OPC_CheckPredicate, 31, // 4386: check predicate 31 |
| 6060 | OPC_Decode, 255, 8, 177, 2, // 4388: decode to BSET_B using decoder 305 |
| 6061 | // 4388: } |
| 6062 | 17, 7, // 4393: case 0x11: { |
| 6063 | OPC_CheckPredicate, 31, // 4395: check predicate 31 |
| 6064 | OPC_Decode, 129, 9, 178, 2, // 4397: decode to BSET_H using decoder 306 |
| 6065 | // 4397: } |
| 6066 | 18, 7, // 4402: case 0x12: { |
| 6067 | OPC_CheckPredicate, 31, // 4404: check predicate 31 |
| 6068 | OPC_Decode, 130, 9, 179, 2, // 4406: decode to BSET_W using decoder 307 |
| 6069 | // 4406: } |
| 6070 | 19, 7, // 4411: case 0x13: { |
| 6071 | OPC_CheckPredicate, 31, // 4413: check predicate 31 |
| 6072 | OPC_Decode, 128, 9, 180, 2, // 4415: decode to BSET_D using decoder 308 |
| 6073 | // 4415: } |
| 6074 | 20, 7, // 4420: case 0x14: { |
| 6075 | OPC_CheckPredicate, 31, // 4422: check predicate 31 |
| 6076 | OPC_Decode, 213, 8, 177, 2, // 4424: decode to BNEG_B using decoder 305 |
| 6077 | // 4424: } |
| 6078 | 21, 7, // 4429: case 0x15: { |
| 6079 | OPC_CheckPredicate, 31, // 4431: check predicate 31 |
| 6080 | OPC_Decode, 215, 8, 178, 2, // 4433: decode to BNEG_H using decoder 306 |
| 6081 | // 4433: } |
| 6082 | 22, 7, // 4438: case 0x16: { |
| 6083 | OPC_CheckPredicate, 31, // 4440: check predicate 31 |
| 6084 | OPC_Decode, 216, 8, 179, 2, // 4442: decode to BNEG_W using decoder 307 |
| 6085 | // 4442: } |
| 6086 | 23, 7, // 4447: case 0x17: { |
| 6087 | OPC_CheckPredicate, 31, // 4449: check predicate 31 |
| 6088 | OPC_Decode, 214, 8, 180, 2, // 4451: decode to BNEG_D using decoder 308 |
| 6089 | // 4451: } |
| 6090 | 24, 7, // 4456: case 0x18: { |
| 6091 | OPC_CheckPredicate, 31, // 4458: check predicate 31 |
| 6092 | OPC_Decode, 150, 8, 181, 2, // 4460: decode to BINSL_B using decoder 309 |
| 6093 | // 4460: } |
| 6094 | 25, 7, // 4465: case 0x19: { |
| 6095 | OPC_CheckPredicate, 31, // 4467: check predicate 31 |
| 6096 | OPC_Decode, 152, 8, 182, 2, // 4469: decode to BINSL_H using decoder 310 |
| 6097 | // 4469: } |
| 6098 | 26, 7, // 4474: case 0x1a: { |
| 6099 | OPC_CheckPredicate, 31, // 4476: check predicate 31 |
| 6100 | OPC_Decode, 153, 8, 183, 2, // 4478: decode to BINSL_W using decoder 311 |
| 6101 | // 4478: } |
| 6102 | 27, 7, // 4483: case 0x1b: { |
| 6103 | OPC_CheckPredicate, 31, // 4485: check predicate 31 |
| 6104 | OPC_Decode, 151, 8, 184, 2, // 4487: decode to BINSL_D using decoder 312 |
| 6105 | // 4487: } |
| 6106 | 28, 7, // 4492: case 0x1c: { |
| 6107 | OPC_CheckPredicate, 31, // 4494: check predicate 31 |
| 6108 | OPC_Decode, 158, 8, 181, 2, // 4496: decode to BINSR_B using decoder 309 |
| 6109 | // 4496: } |
| 6110 | 29, 7, // 4501: case 0x1d: { |
| 6111 | OPC_CheckPredicate, 31, // 4503: check predicate 31 |
| 6112 | OPC_Decode, 160, 8, 182, 2, // 4505: decode to BINSR_H using decoder 310 |
| 6113 | // 4505: } |
| 6114 | 30, 7, // 4510: case 0x1e: { |
| 6115 | OPC_CheckPredicate, 31, // 4512: check predicate 31 |
| 6116 | OPC_Decode, 161, 8, 183, 2, // 4514: decode to BINSR_W using decoder 311 |
| 6117 | // 4514: } |
| 6118 | 31, 0, // 4519: case 0x1f: { |
| 6119 | OPC_CheckPredicate, 31, // 4521: check predicate 31 |
| 6120 | OPC_Decode, 159, 8, 184, 2, // 4523: decode to BINSR_D using decoder 312 |
| 6121 | // 4523: } |
| 6122 | // 4523: } // switch Inst[25:21] |
| 6123 | // 4523: } |
| 6124 | 14, 163, 2, // 4528: case 0xe: { |
| 6125 | OPC_SwitchField, 21, 5, // 4531: switch Inst[25:21] { |
| 6126 | 0, 7, // 4534: case 0x0: { |
| 6127 | OPC_CheckPredicate, 31, // 4536: check predicate 31 |
| 6128 | OPC_Decode, 225, 6, 177, 2, // 4538: decode to ADDV_B using decoder 305 |
| 6129 | // 4538: } |
| 6130 | 1, 7, // 4543: case 0x1: { |
| 6131 | OPC_CheckPredicate, 31, // 4545: check predicate 31 |
| 6132 | OPC_Decode, 227, 6, 178, 2, // 4547: decode to ADDV_H using decoder 306 |
| 6133 | // 4547: } |
| 6134 | 2, 7, // 4552: case 0x2: { |
| 6135 | OPC_CheckPredicate, 31, // 4554: check predicate 31 |
| 6136 | OPC_Decode, 228, 6, 179, 2, // 4556: decode to ADDV_W using decoder 307 |
| 6137 | // 4556: } |
| 6138 | 3, 7, // 4561: case 0x3: { |
| 6139 | OPC_CheckPredicate, 31, // 4563: check predicate 31 |
| 6140 | OPC_Decode, 226, 6, 180, 2, // 4565: decode to ADDV_D using decoder 308 |
| 6141 | // 4565: } |
| 6142 | 4, 7, // 4570: case 0x4: { |
| 6143 | OPC_CheckPredicate, 31, // 4572: check predicate 31 |
| 6144 | OPC_Decode, 139, 23, 177, 2, // 4574: decode to SUBV_B using decoder 305 |
| 6145 | // 4574: } |
| 6146 | 5, 7, // 4579: case 0x5: { |
| 6147 | OPC_CheckPredicate, 31, // 4581: check predicate 31 |
| 6148 | OPC_Decode, 141, 23, 178, 2, // 4583: decode to SUBV_H using decoder 306 |
| 6149 | // 4583: } |
| 6150 | 6, 7, // 4588: case 0x6: { |
| 6151 | OPC_CheckPredicate, 31, // 4590: check predicate 31 |
| 6152 | OPC_Decode, 142, 23, 179, 2, // 4592: decode to SUBV_W using decoder 307 |
| 6153 | // 4592: } |
| 6154 | 7, 7, // 4597: case 0x7: { |
| 6155 | OPC_CheckPredicate, 31, // 4599: check predicate 31 |
| 6156 | OPC_Decode, 140, 23, 180, 2, // 4601: decode to SUBV_D using decoder 308 |
| 6157 | // 4601: } |
| 6158 | 8, 7, // 4606: case 0x8: { |
| 6159 | OPC_CheckPredicate, 31, // 4608: check predicate 31 |
| 6160 | OPC_Decode, 147, 17, 177, 2, // 4610: decode to MAX_S_B using decoder 305 |
| 6161 | // 4610: } |
| 6162 | 9, 7, // 4615: case 0x9: { |
| 6163 | OPC_CheckPredicate, 31, // 4617: check predicate 31 |
| 6164 | OPC_Decode, 149, 17, 178, 2, // 4619: decode to MAX_S_H using decoder 306 |
| 6165 | // 4619: } |
| 6166 | 10, 7, // 4624: case 0xa: { |
| 6167 | OPC_CheckPredicate, 31, // 4626: check predicate 31 |
| 6168 | OPC_Decode, 151, 17, 179, 2, // 4628: decode to MAX_S_W using decoder 307 |
| 6169 | // 4628: } |
| 6170 | 11, 7, // 4633: case 0xb: { |
| 6171 | OPC_CheckPredicate, 31, // 4635: check predicate 31 |
| 6172 | OPC_Decode, 148, 17, 180, 2, // 4637: decode to MAX_S_D using decoder 308 |
| 6173 | // 4637: } |
| 6174 | 12, 7, // 4642: case 0xc: { |
| 6175 | OPC_CheckPredicate, 31, // 4644: check predicate 31 |
| 6176 | OPC_Decode, 152, 17, 177, 2, // 4646: decode to MAX_U_B using decoder 305 |
| 6177 | // 4646: } |
| 6178 | 13, 7, // 4651: case 0xd: { |
| 6179 | OPC_CheckPredicate, 31, // 4653: check predicate 31 |
| 6180 | OPC_Decode, 154, 17, 178, 2, // 4655: decode to MAX_U_H using decoder 306 |
| 6181 | // 4655: } |
| 6182 | 14, 7, // 4660: case 0xe: { |
| 6183 | OPC_CheckPredicate, 31, // 4662: check predicate 31 |
| 6184 | OPC_Decode, 155, 17, 179, 2, // 4664: decode to MAX_U_W using decoder 307 |
| 6185 | // 4664: } |
| 6186 | 15, 7, // 4669: case 0xf: { |
| 6187 | OPC_CheckPredicate, 31, // 4671: check predicate 31 |
| 6188 | OPC_Decode, 153, 17, 180, 2, // 4673: decode to MAX_U_D using decoder 308 |
| 6189 | // 4673: } |
| 6190 | 16, 7, // 4678: case 0x10: { |
| 6191 | OPC_CheckPredicate, 31, // 4680: check predicate 31 |
| 6192 | OPC_Decode, 209, 17, 177, 2, // 4682: decode to MIN_S_B using decoder 305 |
| 6193 | // 4682: } |
| 6194 | 17, 7, // 4687: case 0x11: { |
| 6195 | OPC_CheckPredicate, 31, // 4689: check predicate 31 |
| 6196 | OPC_Decode, 211, 17, 178, 2, // 4691: decode to MIN_S_H using decoder 306 |
| 6197 | // 4691: } |
| 6198 | 18, 7, // 4696: case 0x12: { |
| 6199 | OPC_CheckPredicate, 31, // 4698: check predicate 31 |
| 6200 | OPC_Decode, 213, 17, 179, 2, // 4700: decode to MIN_S_W using decoder 307 |
| 6201 | // 4700: } |
| 6202 | 19, 7, // 4705: case 0x13: { |
| 6203 | OPC_CheckPredicate, 31, // 4707: check predicate 31 |
| 6204 | OPC_Decode, 210, 17, 180, 2, // 4709: decode to MIN_S_D using decoder 308 |
| 6205 | // 4709: } |
| 6206 | 20, 7, // 4714: case 0x14: { |
| 6207 | OPC_CheckPredicate, 31, // 4716: check predicate 31 |
| 6208 | OPC_Decode, 214, 17, 177, 2, // 4718: decode to MIN_U_B using decoder 305 |
| 6209 | // 4718: } |
| 6210 | 21, 7, // 4723: case 0x15: { |
| 6211 | OPC_CheckPredicate, 31, // 4725: check predicate 31 |
| 6212 | OPC_Decode, 216, 17, 178, 2, // 4727: decode to MIN_U_H using decoder 306 |
| 6213 | // 4727: } |
| 6214 | 22, 7, // 4732: case 0x16: { |
| 6215 | OPC_CheckPredicate, 31, // 4734: check predicate 31 |
| 6216 | OPC_Decode, 217, 17, 179, 2, // 4736: decode to MIN_U_W using decoder 307 |
| 6217 | // 4736: } |
| 6218 | 23, 7, // 4741: case 0x17: { |
| 6219 | OPC_CheckPredicate, 31, // 4743: check predicate 31 |
| 6220 | OPC_Decode, 215, 17, 180, 2, // 4745: decode to MIN_U_D using decoder 308 |
| 6221 | // 4745: } |
| 6222 | 24, 7, // 4750: case 0x18: { |
| 6223 | OPC_CheckPredicate, 31, // 4752: check predicate 31 |
| 6224 | OPC_Decode, 140, 17, 177, 2, // 4754: decode to MAX_A_B using decoder 305 |
| 6225 | // 4754: } |
| 6226 | 25, 7, // 4759: case 0x19: { |
| 6227 | OPC_CheckPredicate, 31, // 4761: check predicate 31 |
| 6228 | OPC_Decode, 142, 17, 178, 2, // 4763: decode to MAX_A_H using decoder 306 |
| 6229 | // 4763: } |
| 6230 | 26, 7, // 4768: case 0x1a: { |
| 6231 | OPC_CheckPredicate, 31, // 4770: check predicate 31 |
| 6232 | OPC_Decode, 143, 17, 179, 2, // 4772: decode to MAX_A_W using decoder 307 |
| 6233 | // 4772: } |
| 6234 | 27, 7, // 4777: case 0x1b: { |
| 6235 | OPC_CheckPredicate, 31, // 4779: check predicate 31 |
| 6236 | OPC_Decode, 141, 17, 180, 2, // 4781: decode to MAX_A_D using decoder 308 |
| 6237 | // 4781: } |
| 6238 | 28, 7, // 4786: case 0x1c: { |
| 6239 | OPC_CheckPredicate, 31, // 4788: check predicate 31 |
| 6240 | OPC_Decode, 202, 17, 177, 2, // 4790: decode to MIN_A_B using decoder 305 |
| 6241 | // 4790: } |
| 6242 | 29, 7, // 4795: case 0x1d: { |
| 6243 | OPC_CheckPredicate, 31, // 4797: check predicate 31 |
| 6244 | OPC_Decode, 204, 17, 178, 2, // 4799: decode to MIN_A_H using decoder 306 |
| 6245 | // 4799: } |
| 6246 | 30, 7, // 4804: case 0x1e: { |
| 6247 | OPC_CheckPredicate, 31, // 4806: check predicate 31 |
| 6248 | OPC_Decode, 205, 17, 179, 2, // 4808: decode to MIN_A_W using decoder 307 |
| 6249 | // 4808: } |
| 6250 | 31, 0, // 4813: case 0x1f: { |
| 6251 | OPC_CheckPredicate, 31, // 4815: check predicate 31 |
| 6252 | OPC_Decode, 203, 17, 180, 2, // 4817: decode to MIN_A_D using decoder 308 |
| 6253 | // 4817: } |
| 6254 | // 4817: } // switch Inst[25:21] |
| 6255 | // 4817: } |
| 6256 | 15, 183, 1, // 4822: case 0xf: { |
| 6257 | OPC_SwitchField, 21, 5, // 4825: switch Inst[25:21] { |
| 6258 | 0, 7, // 4828: case 0x0: { |
| 6259 | OPC_CheckPredicate, 31, // 4830: check predicate 31 |
| 6260 | OPC_Decode, 170, 9, 177, 2, // 4832: decode to CEQ_B using decoder 305 |
| 6261 | // 4832: } |
| 6262 | 1, 7, // 4837: case 0x1: { |
| 6263 | OPC_CheckPredicate, 31, // 4839: check predicate 31 |
| 6264 | OPC_Decode, 172, 9, 178, 2, // 4841: decode to CEQ_H using decoder 306 |
| 6265 | // 4841: } |
| 6266 | 2, 7, // 4846: case 0x2: { |
| 6267 | OPC_CheckPredicate, 31, // 4848: check predicate 31 |
| 6268 | OPC_Decode, 173, 9, 179, 2, // 4850: decode to CEQ_W using decoder 307 |
| 6269 | // 4850: } |
| 6270 | 3, 7, // 4855: case 0x3: { |
| 6271 | OPC_CheckPredicate, 31, // 4857: check predicate 31 |
| 6272 | OPC_Decode, 171, 9, 180, 2, // 4859: decode to CEQ_D using decoder 308 |
| 6273 | // 4859: } |
| 6274 | 8, 7, // 4864: case 0x8: { |
| 6275 | OPC_CheckPredicate, 31, // 4866: check predicate 31 |
| 6276 | OPC_Decode, 215, 9, 177, 2, // 4868: decode to CLT_S_B using decoder 305 |
| 6277 | // 4868: } |
| 6278 | 9, 7, // 4873: case 0x9: { |
| 6279 | OPC_CheckPredicate, 31, // 4875: check predicate 31 |
| 6280 | OPC_Decode, 217, 9, 178, 2, // 4877: decode to CLT_S_H using decoder 306 |
| 6281 | // 4877: } |
| 6282 | 10, 7, // 4882: case 0xa: { |
| 6283 | OPC_CheckPredicate, 31, // 4884: check predicate 31 |
| 6284 | OPC_Decode, 218, 9, 179, 2, // 4886: decode to CLT_S_W using decoder 307 |
| 6285 | // 4886: } |
| 6286 | 11, 7, // 4891: case 0xb: { |
| 6287 | OPC_CheckPredicate, 31, // 4893: check predicate 31 |
| 6288 | OPC_Decode, 216, 9, 180, 2, // 4895: decode to CLT_S_D using decoder 308 |
| 6289 | // 4895: } |
| 6290 | 12, 7, // 4900: case 0xc: { |
| 6291 | OPC_CheckPredicate, 31, // 4902: check predicate 31 |
| 6292 | OPC_Decode, 219, 9, 177, 2, // 4904: decode to CLT_U_B using decoder 305 |
| 6293 | // 4904: } |
| 6294 | 13, 7, // 4909: case 0xd: { |
| 6295 | OPC_CheckPredicate, 31, // 4911: check predicate 31 |
| 6296 | OPC_Decode, 221, 9, 178, 2, // 4913: decode to CLT_U_H using decoder 306 |
| 6297 | // 4913: } |
| 6298 | 14, 7, // 4918: case 0xe: { |
| 6299 | OPC_CheckPredicate, 31, // 4920: check predicate 31 |
| 6300 | OPC_Decode, 222, 9, 179, 2, // 4922: decode to CLT_U_W using decoder 307 |
| 6301 | // 4922: } |
| 6302 | 15, 7, // 4927: case 0xf: { |
| 6303 | OPC_CheckPredicate, 31, // 4929: check predicate 31 |
| 6304 | OPC_Decode, 220, 9, 180, 2, // 4931: decode to CLT_U_D using decoder 308 |
| 6305 | // 4931: } |
| 6306 | 16, 7, // 4936: case 0x10: { |
| 6307 | OPC_CheckPredicate, 31, // 4938: check predicate 31 |
| 6308 | OPC_Decode, 194, 9, 177, 2, // 4940: decode to CLE_S_B using decoder 305 |
| 6309 | // 4940: } |
| 6310 | 17, 7, // 4945: case 0x11: { |
| 6311 | OPC_CheckPredicate, 31, // 4947: check predicate 31 |
| 6312 | OPC_Decode, 196, 9, 178, 2, // 4949: decode to CLE_S_H using decoder 306 |
| 6313 | // 4949: } |
| 6314 | 18, 7, // 4954: case 0x12: { |
| 6315 | OPC_CheckPredicate, 31, // 4956: check predicate 31 |
| 6316 | OPC_Decode, 197, 9, 179, 2, // 4958: decode to CLE_S_W using decoder 307 |
| 6317 | // 4958: } |
| 6318 | 19, 7, // 4963: case 0x13: { |
| 6319 | OPC_CheckPredicate, 31, // 4965: check predicate 31 |
| 6320 | OPC_Decode, 195, 9, 180, 2, // 4967: decode to CLE_S_D using decoder 308 |
| 6321 | // 4967: } |
| 6322 | 20, 7, // 4972: case 0x14: { |
| 6323 | OPC_CheckPredicate, 31, // 4974: check predicate 31 |
| 6324 | OPC_Decode, 198, 9, 177, 2, // 4976: decode to CLE_U_B using decoder 305 |
| 6325 | // 4976: } |
| 6326 | 21, 7, // 4981: case 0x15: { |
| 6327 | OPC_CheckPredicate, 31, // 4983: check predicate 31 |
| 6328 | OPC_Decode, 200, 9, 178, 2, // 4985: decode to CLE_U_H using decoder 306 |
| 6329 | // 4985: } |
| 6330 | 22, 7, // 4990: case 0x16: { |
| 6331 | OPC_CheckPredicate, 31, // 4992: check predicate 31 |
| 6332 | OPC_Decode, 201, 9, 179, 2, // 4994: decode to CLE_U_W using decoder 307 |
| 6333 | // 4994: } |
| 6334 | 23, 0, // 4999: case 0x17: { |
| 6335 | OPC_CheckPredicate, 31, // 5001: check predicate 31 |
| 6336 | OPC_Decode, 199, 9, 180, 2, // 5003: decode to CLE_U_D using decoder 308 |
| 6337 | // 5003: } |
| 6338 | // 5003: } // switch Inst[25:21] |
| 6339 | // 5003: } |
| 6340 | 16, 163, 2, // 5008: case 0x10: { |
| 6341 | OPC_SwitchField, 21, 5, // 5011: switch Inst[25:21] { |
| 6342 | 0, 7, // 5014: case 0x0: { |
| 6343 | OPC_CheckPredicate, 31, // 5016: check predicate 31 |
| 6344 | OPC_Decode, 231, 6, 177, 2, // 5018: decode to ADD_A_B using decoder 305 |
| 6345 | // 5018: } |
| 6346 | 1, 7, // 5023: case 0x1: { |
| 6347 | OPC_CheckPredicate, 31, // 5025: check predicate 31 |
| 6348 | OPC_Decode, 233, 6, 178, 2, // 5027: decode to ADD_A_H using decoder 306 |
| 6349 | // 5027: } |
| 6350 | 2, 7, // 5032: case 0x2: { |
| 6351 | OPC_CheckPredicate, 31, // 5034: check predicate 31 |
| 6352 | OPC_Decode, 234, 6, 179, 2, // 5036: decode to ADD_A_W using decoder 307 |
| 6353 | // 5036: } |
| 6354 | 3, 7, // 5041: case 0x3: { |
| 6355 | OPC_CheckPredicate, 31, // 5043: check predicate 31 |
| 6356 | OPC_Decode, 232, 6, 180, 2, // 5045: decode to ADD_A_D using decoder 308 |
| 6357 | // 5045: } |
| 6358 | 4, 7, // 5050: case 0x4: { |
| 6359 | OPC_CheckPredicate, 31, // 5052: check predicate 31 |
| 6360 | OPC_Decode, 194, 6, 177, 2, // 5054: decode to ADDS_A_B using decoder 305 |
| 6361 | // 5054: } |
| 6362 | 5, 7, // 5059: case 0x5: { |
| 6363 | OPC_CheckPredicate, 31, // 5061: check predicate 31 |
| 6364 | OPC_Decode, 196, 6, 178, 2, // 5063: decode to ADDS_A_H using decoder 306 |
| 6365 | // 5063: } |
| 6366 | 6, 7, // 5068: case 0x6: { |
| 6367 | OPC_CheckPredicate, 31, // 5070: check predicate 31 |
| 6368 | OPC_Decode, 197, 6, 179, 2, // 5072: decode to ADDS_A_W using decoder 307 |
| 6369 | // 5072: } |
| 6370 | 7, 7, // 5077: case 0x7: { |
| 6371 | OPC_CheckPredicate, 31, // 5079: check predicate 31 |
| 6372 | OPC_Decode, 195, 6, 180, 2, // 5081: decode to ADDS_A_D using decoder 308 |
| 6373 | // 5081: } |
| 6374 | 8, 7, // 5086: case 0x8: { |
| 6375 | OPC_CheckPredicate, 31, // 5088: check predicate 31 |
| 6376 | OPC_Decode, 198, 6, 177, 2, // 5090: decode to ADDS_S_B using decoder 305 |
| 6377 | // 5090: } |
| 6378 | 9, 7, // 5095: case 0x9: { |
| 6379 | OPC_CheckPredicate, 31, // 5097: check predicate 31 |
| 6380 | OPC_Decode, 200, 6, 178, 2, // 5099: decode to ADDS_S_H using decoder 306 |
| 6381 | // 5099: } |
| 6382 | 10, 7, // 5104: case 0xa: { |
| 6383 | OPC_CheckPredicate, 31, // 5106: check predicate 31 |
| 6384 | OPC_Decode, 201, 6, 179, 2, // 5108: decode to ADDS_S_W using decoder 307 |
| 6385 | // 5108: } |
| 6386 | 11, 7, // 5113: case 0xb: { |
| 6387 | OPC_CheckPredicate, 31, // 5115: check predicate 31 |
| 6388 | OPC_Decode, 199, 6, 180, 2, // 5117: decode to ADDS_S_D using decoder 308 |
| 6389 | // 5117: } |
| 6390 | 12, 7, // 5122: case 0xc: { |
| 6391 | OPC_CheckPredicate, 31, // 5124: check predicate 31 |
| 6392 | OPC_Decode, 202, 6, 177, 2, // 5126: decode to ADDS_U_B using decoder 305 |
| 6393 | // 5126: } |
| 6394 | 13, 7, // 5131: case 0xd: { |
| 6395 | OPC_CheckPredicate, 31, // 5133: check predicate 31 |
| 6396 | OPC_Decode, 204, 6, 178, 2, // 5135: decode to ADDS_U_H using decoder 306 |
| 6397 | // 5135: } |
| 6398 | 14, 7, // 5140: case 0xe: { |
| 6399 | OPC_CheckPredicate, 31, // 5142: check predicate 31 |
| 6400 | OPC_Decode, 205, 6, 179, 2, // 5144: decode to ADDS_U_W using decoder 307 |
| 6401 | // 5144: } |
| 6402 | 15, 7, // 5149: case 0xf: { |
| 6403 | OPC_CheckPredicate, 31, // 5151: check predicate 31 |
| 6404 | OPC_Decode, 203, 6, 180, 2, // 5153: decode to ADDS_U_D using decoder 308 |
| 6405 | // 5153: } |
| 6406 | 16, 7, // 5158: case 0x10: { |
| 6407 | OPC_CheckPredicate, 31, // 5160: check predicate 31 |
| 6408 | OPC_Decode, 164, 7, 177, 2, // 5162: decode to AVE_S_B using decoder 305 |
| 6409 | // 5162: } |
| 6410 | 17, 7, // 5167: case 0x11: { |
| 6411 | OPC_CheckPredicate, 31, // 5169: check predicate 31 |
| 6412 | OPC_Decode, 166, 7, 178, 2, // 5171: decode to AVE_S_H using decoder 306 |
| 6413 | // 5171: } |
| 6414 | 18, 7, // 5176: case 0x12: { |
| 6415 | OPC_CheckPredicate, 31, // 5178: check predicate 31 |
| 6416 | OPC_Decode, 167, 7, 179, 2, // 5180: decode to AVE_S_W using decoder 307 |
| 6417 | // 5180: } |
| 6418 | 19, 7, // 5185: case 0x13: { |
| 6419 | OPC_CheckPredicate, 31, // 5187: check predicate 31 |
| 6420 | OPC_Decode, 165, 7, 180, 2, // 5189: decode to AVE_S_D using decoder 308 |
| 6421 | // 5189: } |
| 6422 | 20, 7, // 5194: case 0x14: { |
| 6423 | OPC_CheckPredicate, 31, // 5196: check predicate 31 |
| 6424 | OPC_Decode, 168, 7, 177, 2, // 5198: decode to AVE_U_B using decoder 305 |
| 6425 | // 5198: } |
| 6426 | 21, 7, // 5203: case 0x15: { |
| 6427 | OPC_CheckPredicate, 31, // 5205: check predicate 31 |
| 6428 | OPC_Decode, 170, 7, 178, 2, // 5207: decode to AVE_U_H using decoder 306 |
| 6429 | // 5207: } |
| 6430 | 22, 7, // 5212: case 0x16: { |
| 6431 | OPC_CheckPredicate, 31, // 5214: check predicate 31 |
| 6432 | OPC_Decode, 171, 7, 179, 2, // 5216: decode to AVE_U_W using decoder 307 |
| 6433 | // 5216: } |
| 6434 | 23, 7, // 5221: case 0x17: { |
| 6435 | OPC_CheckPredicate, 31, // 5223: check predicate 31 |
| 6436 | OPC_Decode, 169, 7, 180, 2, // 5225: decode to AVE_U_D using decoder 308 |
| 6437 | // 5225: } |
| 6438 | 24, 7, // 5230: case 0x18: { |
| 6439 | OPC_CheckPredicate, 31, // 5232: check predicate 31 |
| 6440 | OPC_Decode, 156, 7, 177, 2, // 5234: decode to AVER_S_B using decoder 305 |
| 6441 | // 5234: } |
| 6442 | 25, 7, // 5239: case 0x19: { |
| 6443 | OPC_CheckPredicate, 31, // 5241: check predicate 31 |
| 6444 | OPC_Decode, 158, 7, 178, 2, // 5243: decode to AVER_S_H using decoder 306 |
| 6445 | // 5243: } |
| 6446 | 26, 7, // 5248: case 0x1a: { |
| 6447 | OPC_CheckPredicate, 31, // 5250: check predicate 31 |
| 6448 | OPC_Decode, 159, 7, 179, 2, // 5252: decode to AVER_S_W using decoder 307 |
| 6449 | // 5252: } |
| 6450 | 27, 7, // 5257: case 0x1b: { |
| 6451 | OPC_CheckPredicate, 31, // 5259: check predicate 31 |
| 6452 | OPC_Decode, 157, 7, 180, 2, // 5261: decode to AVER_S_D using decoder 308 |
| 6453 | // 5261: } |
| 6454 | 28, 7, // 5266: case 0x1c: { |
| 6455 | OPC_CheckPredicate, 31, // 5268: check predicate 31 |
| 6456 | OPC_Decode, 160, 7, 177, 2, // 5270: decode to AVER_U_B using decoder 305 |
| 6457 | // 5270: } |
| 6458 | 29, 7, // 5275: case 0x1d: { |
| 6459 | OPC_CheckPredicate, 31, // 5277: check predicate 31 |
| 6460 | OPC_Decode, 162, 7, 178, 2, // 5279: decode to AVER_U_H using decoder 306 |
| 6461 | // 5279: } |
| 6462 | 30, 7, // 5284: case 0x1e: { |
| 6463 | OPC_CheckPredicate, 31, // 5286: check predicate 31 |
| 6464 | OPC_Decode, 163, 7, 179, 2, // 5288: decode to AVER_U_W using decoder 307 |
| 6465 | // 5288: } |
| 6466 | 31, 0, // 5293: case 0x1f: { |
| 6467 | OPC_CheckPredicate, 31, // 5295: check predicate 31 |
| 6468 | OPC_Decode, 161, 7, 180, 2, // 5297: decode to AVER_U_D using decoder 308 |
| 6469 | // 5297: } |
| 6470 | // 5297: } // switch Inst[25:21] |
| 6471 | // 5297: } |
| 6472 | 17, 219, 1, // 5302: case 0x11: { |
| 6473 | OPC_SwitchField, 21, 5, // 5305: switch Inst[25:21] { |
| 6474 | 0, 7, // 5308: case 0x0: { |
| 6475 | OPC_CheckPredicate, 31, // 5310: check predicate 31 |
| 6476 | OPC_Decode, 240, 22, 177, 2, // 5312: decode to SUBS_S_B using decoder 305 |
| 6477 | // 5312: } |
| 6478 | 1, 7, // 5317: case 0x1: { |
| 6479 | OPC_CheckPredicate, 31, // 5319: check predicate 31 |
| 6480 | OPC_Decode, 242, 22, 178, 2, // 5321: decode to SUBS_S_H using decoder 306 |
| 6481 | // 5321: } |
| 6482 | 2, 7, // 5326: case 0x2: { |
| 6483 | OPC_CheckPredicate, 31, // 5328: check predicate 31 |
| 6484 | OPC_Decode, 243, 22, 179, 2, // 5330: decode to SUBS_S_W using decoder 307 |
| 6485 | // 5330: } |
| 6486 | 3, 7, // 5335: case 0x3: { |
| 6487 | OPC_CheckPredicate, 31, // 5337: check predicate 31 |
| 6488 | OPC_Decode, 241, 22, 180, 2, // 5339: decode to SUBS_S_D using decoder 308 |
| 6489 | // 5339: } |
| 6490 | 4, 7, // 5344: case 0x4: { |
| 6491 | OPC_CheckPredicate, 31, // 5346: check predicate 31 |
| 6492 | OPC_Decode, 244, 22, 177, 2, // 5348: decode to SUBS_U_B using decoder 305 |
| 6493 | // 5348: } |
| 6494 | 5, 7, // 5353: case 0x5: { |
| 6495 | OPC_CheckPredicate, 31, // 5355: check predicate 31 |
| 6496 | OPC_Decode, 246, 22, 178, 2, // 5357: decode to SUBS_U_H using decoder 306 |
| 6497 | // 5357: } |
| 6498 | 6, 7, // 5362: case 0x6: { |
| 6499 | OPC_CheckPredicate, 31, // 5364: check predicate 31 |
| 6500 | OPC_Decode, 247, 22, 179, 2, // 5366: decode to SUBS_U_W using decoder 307 |
| 6501 | // 5366: } |
| 6502 | 7, 7, // 5371: case 0x7: { |
| 6503 | OPC_CheckPredicate, 31, // 5373: check predicate 31 |
| 6504 | OPC_Decode, 245, 22, 180, 2, // 5375: decode to SUBS_U_D using decoder 308 |
| 6505 | // 5375: } |
| 6506 | 8, 7, // 5380: case 0x8: { |
| 6507 | OPC_CheckPredicate, 31, // 5382: check predicate 31 |
| 6508 | OPC_Decode, 232, 22, 177, 2, // 5384: decode to SUBSUS_U_B using decoder 305 |
| 6509 | // 5384: } |
| 6510 | 9, 7, // 5389: case 0x9: { |
| 6511 | OPC_CheckPredicate, 31, // 5391: check predicate 31 |
| 6512 | OPC_Decode, 234, 22, 178, 2, // 5393: decode to SUBSUS_U_H using decoder 306 |
| 6513 | // 5393: } |
| 6514 | 10, 7, // 5398: case 0xa: { |
| 6515 | OPC_CheckPredicate, 31, // 5400: check predicate 31 |
| 6516 | OPC_Decode, 235, 22, 179, 2, // 5402: decode to SUBSUS_U_W using decoder 307 |
| 6517 | // 5402: } |
| 6518 | 11, 7, // 5407: case 0xb: { |
| 6519 | OPC_CheckPredicate, 31, // 5409: check predicate 31 |
| 6520 | OPC_Decode, 233, 22, 180, 2, // 5411: decode to SUBSUS_U_D using decoder 308 |
| 6521 | // 5411: } |
| 6522 | 12, 7, // 5416: case 0xc: { |
| 6523 | OPC_CheckPredicate, 31, // 5418: check predicate 31 |
| 6524 | OPC_Decode, 236, 22, 177, 2, // 5420: decode to SUBSUU_S_B using decoder 305 |
| 6525 | // 5420: } |
| 6526 | 13, 7, // 5425: case 0xd: { |
| 6527 | OPC_CheckPredicate, 31, // 5427: check predicate 31 |
| 6528 | OPC_Decode, 238, 22, 178, 2, // 5429: decode to SUBSUU_S_H using decoder 306 |
| 6529 | // 5429: } |
| 6530 | 14, 7, // 5434: case 0xe: { |
| 6531 | OPC_CheckPredicate, 31, // 5436: check predicate 31 |
| 6532 | OPC_Decode, 239, 22, 179, 2, // 5438: decode to SUBSUU_S_W using decoder 307 |
| 6533 | // 5438: } |
| 6534 | 15, 7, // 5443: case 0xf: { |
| 6535 | OPC_CheckPredicate, 31, // 5445: check predicate 31 |
| 6536 | OPC_Decode, 237, 22, 180, 2, // 5447: decode to SUBSUU_S_D using decoder 308 |
| 6537 | // 5447: } |
| 6538 | 16, 7, // 5452: case 0x10: { |
| 6539 | OPC_CheckPredicate, 31, // 5454: check predicate 31 |
| 6540 | OPC_Decode, 144, 7, 177, 2, // 5456: decode to ASUB_S_B using decoder 305 |
| 6541 | // 5456: } |
| 6542 | 17, 7, // 5461: case 0x11: { |
| 6543 | OPC_CheckPredicate, 31, // 5463: check predicate 31 |
| 6544 | OPC_Decode, 146, 7, 178, 2, // 5465: decode to ASUB_S_H using decoder 306 |
| 6545 | // 5465: } |
| 6546 | 18, 7, // 5470: case 0x12: { |
| 6547 | OPC_CheckPredicate, 31, // 5472: check predicate 31 |
| 6548 | OPC_Decode, 147, 7, 179, 2, // 5474: decode to ASUB_S_W using decoder 307 |
| 6549 | // 5474: } |
| 6550 | 19, 7, // 5479: case 0x13: { |
| 6551 | OPC_CheckPredicate, 31, // 5481: check predicate 31 |
| 6552 | OPC_Decode, 145, 7, 180, 2, // 5483: decode to ASUB_S_D using decoder 308 |
| 6553 | // 5483: } |
| 6554 | 20, 7, // 5488: case 0x14: { |
| 6555 | OPC_CheckPredicate, 31, // 5490: check predicate 31 |
| 6556 | OPC_Decode, 148, 7, 177, 2, // 5492: decode to ASUB_U_B using decoder 305 |
| 6557 | // 5492: } |
| 6558 | 21, 7, // 5497: case 0x15: { |
| 6559 | OPC_CheckPredicate, 31, // 5499: check predicate 31 |
| 6560 | OPC_Decode, 150, 7, 178, 2, // 5501: decode to ASUB_U_H using decoder 306 |
| 6561 | // 5501: } |
| 6562 | 22, 7, // 5506: case 0x16: { |
| 6563 | OPC_CheckPredicate, 31, // 5508: check predicate 31 |
| 6564 | OPC_Decode, 151, 7, 179, 2, // 5510: decode to ASUB_U_W using decoder 307 |
| 6565 | // 5510: } |
| 6566 | 23, 0, // 5515: case 0x17: { |
| 6567 | OPC_CheckPredicate, 31, // 5517: check predicate 31 |
| 6568 | OPC_Decode, 149, 7, 180, 2, // 5519: decode to ASUB_U_D using decoder 308 |
| 6569 | // 5519: } |
| 6570 | // 5519: } // switch Inst[25:21] |
| 6571 | // 5519: } |
| 6572 | 18, 255, 1, // 5524: case 0x12: { |
| 6573 | OPC_SwitchField, 21, 5, // 5527: switch Inst[25:21] { |
| 6574 | 0, 7, // 5530: case 0x0: { |
| 6575 | OPC_CheckPredicate, 31, // 5532: check predicate 31 |
| 6576 | OPC_Decode, 137, 19, 177, 2, // 5534: decode to MULV_B using decoder 305 |
| 6577 | // 5534: } |
| 6578 | 1, 7, // 5539: case 0x1: { |
| 6579 | OPC_CheckPredicate, 31, // 5541: check predicate 31 |
| 6580 | OPC_Decode, 139, 19, 178, 2, // 5543: decode to MULV_H using decoder 306 |
| 6581 | // 5543: } |
| 6582 | 2, 7, // 5548: case 0x2: { |
| 6583 | OPC_CheckPredicate, 31, // 5550: check predicate 31 |
| 6584 | OPC_Decode, 140, 19, 179, 2, // 5552: decode to MULV_W using decoder 307 |
| 6585 | // 5552: } |
| 6586 | 3, 7, // 5557: case 0x3: { |
| 6587 | OPC_CheckPredicate, 31, // 5559: check predicate 31 |
| 6588 | OPC_Decode, 138, 19, 180, 2, // 5561: decode to MULV_D using decoder 308 |
| 6589 | // 5561: } |
| 6590 | 4, 7, // 5566: case 0x4: { |
| 6591 | OPC_CheckPredicate, 31, // 5568: check predicate 31 |
| 6592 | OPC_Decode, 234, 16, 181, 2, // 5570: decode to MADDV_B using decoder 309 |
| 6593 | // 5570: } |
| 6594 | 5, 7, // 5575: case 0x5: { |
| 6595 | OPC_CheckPredicate, 31, // 5577: check predicate 31 |
| 6596 | OPC_Decode, 236, 16, 182, 2, // 5579: decode to MADDV_H using decoder 310 |
| 6597 | // 5579: } |
| 6598 | 6, 7, // 5584: case 0x6: { |
| 6599 | OPC_CheckPredicate, 31, // 5586: check predicate 31 |
| 6600 | OPC_Decode, 237, 16, 183, 2, // 5588: decode to MADDV_W using decoder 311 |
| 6601 | // 5588: } |
| 6602 | 7, 7, // 5593: case 0x7: { |
| 6603 | OPC_CheckPredicate, 31, // 5595: check predicate 31 |
| 6604 | OPC_Decode, 235, 16, 184, 2, // 5597: decode to MADDV_D using decoder 312 |
| 6605 | // 5597: } |
| 6606 | 8, 7, // 5602: case 0x8: { |
| 6607 | OPC_CheckPredicate, 31, // 5604: check predicate 31 |
| 6608 | OPC_Decode, 168, 18, 181, 2, // 5606: decode to MSUBV_B using decoder 309 |
| 6609 | // 5606: } |
| 6610 | 9, 7, // 5611: case 0x9: { |
| 6611 | OPC_CheckPredicate, 31, // 5613: check predicate 31 |
| 6612 | OPC_Decode, 170, 18, 182, 2, // 5615: decode to MSUBV_H using decoder 310 |
| 6613 | // 5615: } |
| 6614 | 10, 7, // 5620: case 0xa: { |
| 6615 | OPC_CheckPredicate, 31, // 5622: check predicate 31 |
| 6616 | OPC_Decode, 171, 18, 183, 2, // 5624: decode to MSUBV_W using decoder 311 |
| 6617 | // 5624: } |
| 6618 | 11, 7, // 5629: case 0xb: { |
| 6619 | OPC_CheckPredicate, 31, // 5631: check predicate 31 |
| 6620 | OPC_Decode, 169, 18, 184, 2, // 5633: decode to MSUBV_D using decoder 312 |
| 6621 | // 5633: } |
| 6622 | 16, 7, // 5638: case 0x10: { |
| 6623 | OPC_CheckPredicate, 31, // 5640: check predicate 31 |
| 6624 | OPC_Decode, 254, 11, 177, 2, // 5642: decode to DIV_S_B using decoder 305 |
| 6625 | // 5642: } |
| 6626 | 17, 7, // 5647: case 0x11: { |
| 6627 | OPC_CheckPredicate, 31, // 5649: check predicate 31 |
| 6628 | OPC_Decode, 128, 12, 178, 2, // 5651: decode to DIV_S_H using decoder 306 |
| 6629 | // 5651: } |
| 6630 | 18, 7, // 5656: case 0x12: { |
| 6631 | OPC_CheckPredicate, 31, // 5658: check predicate 31 |
| 6632 | OPC_Decode, 129, 12, 179, 2, // 5660: decode to DIV_S_W using decoder 307 |
| 6633 | // 5660: } |
| 6634 | 19, 7, // 5665: case 0x13: { |
| 6635 | OPC_CheckPredicate, 31, // 5667: check predicate 31 |
| 6636 | OPC_Decode, 255, 11, 180, 2, // 5669: decode to DIV_S_D using decoder 308 |
| 6637 | // 5669: } |
| 6638 | 20, 7, // 5674: case 0x14: { |
| 6639 | OPC_CheckPredicate, 31, // 5676: check predicate 31 |
| 6640 | OPC_Decode, 130, 12, 177, 2, // 5678: decode to DIV_U_B using decoder 305 |
| 6641 | // 5678: } |
| 6642 | 21, 7, // 5683: case 0x15: { |
| 6643 | OPC_CheckPredicate, 31, // 5685: check predicate 31 |
| 6644 | OPC_Decode, 132, 12, 178, 2, // 5687: decode to DIV_U_H using decoder 306 |
| 6645 | // 5687: } |
| 6646 | 22, 7, // 5692: case 0x16: { |
| 6647 | OPC_CheckPredicate, 31, // 5694: check predicate 31 |
| 6648 | OPC_Decode, 133, 12, 179, 2, // 5696: decode to DIV_U_W using decoder 307 |
| 6649 | // 5696: } |
| 6650 | 23, 7, // 5701: case 0x17: { |
| 6651 | OPC_CheckPredicate, 31, // 5703: check predicate 31 |
| 6652 | OPC_Decode, 131, 12, 180, 2, // 5705: decode to DIV_U_D using decoder 308 |
| 6653 | // 5705: } |
| 6654 | 24, 7, // 5710: case 0x18: { |
| 6655 | OPC_CheckPredicate, 31, // 5712: check predicate 31 |
| 6656 | OPC_Decode, 226, 17, 177, 2, // 5714: decode to MOD_S_B using decoder 305 |
| 6657 | // 5714: } |
| 6658 | 25, 7, // 5719: case 0x19: { |
| 6659 | OPC_CheckPredicate, 31, // 5721: check predicate 31 |
| 6660 | OPC_Decode, 228, 17, 178, 2, // 5723: decode to MOD_S_H using decoder 306 |
| 6661 | // 5723: } |
| 6662 | 26, 7, // 5728: case 0x1a: { |
| 6663 | OPC_CheckPredicate, 31, // 5730: check predicate 31 |
| 6664 | OPC_Decode, 229, 17, 179, 2, // 5732: decode to MOD_S_W using decoder 307 |
| 6665 | // 5732: } |
| 6666 | 27, 7, // 5737: case 0x1b: { |
| 6667 | OPC_CheckPredicate, 31, // 5739: check predicate 31 |
| 6668 | OPC_Decode, 227, 17, 180, 2, // 5741: decode to MOD_S_D using decoder 308 |
| 6669 | // 5741: } |
| 6670 | 28, 7, // 5746: case 0x1c: { |
| 6671 | OPC_CheckPredicate, 31, // 5748: check predicate 31 |
| 6672 | OPC_Decode, 230, 17, 177, 2, // 5750: decode to MOD_U_B using decoder 305 |
| 6673 | // 5750: } |
| 6674 | 29, 7, // 5755: case 0x1d: { |
| 6675 | OPC_CheckPredicate, 31, // 5757: check predicate 31 |
| 6676 | OPC_Decode, 232, 17, 178, 2, // 5759: decode to MOD_U_H using decoder 306 |
| 6677 | // 5759: } |
| 6678 | 30, 7, // 5764: case 0x1e: { |
| 6679 | OPC_CheckPredicate, 31, // 5766: check predicate 31 |
| 6680 | OPC_Decode, 233, 17, 179, 2, // 5768: decode to MOD_U_W using decoder 307 |
| 6681 | // 5768: } |
| 6682 | 31, 0, // 5773: case 0x1f: { |
| 6683 | OPC_CheckPredicate, 31, // 5775: check predicate 31 |
| 6684 | OPC_Decode, 231, 17, 180, 2, // 5777: decode to MOD_U_D using decoder 308 |
| 6685 | // 5777: } |
| 6686 | // 5777: } // switch Inst[25:21] |
| 6687 | // 5777: } |
| 6688 | 19, 165, 1, // 5782: case 0x13: { |
| 6689 | OPC_SwitchField, 21, 5, // 5785: switch Inst[25:21] { |
| 6690 | 1, 7, // 5788: case 0x1: { |
| 6691 | OPC_CheckPredicate, 31, // 5790: check predicate 31 |
| 6692 | OPC_Decode, 160, 12, 185, 2, // 5792: decode to DOTP_S_H using decoder 313 |
| 6693 | // 5792: } |
| 6694 | 2, 7, // 5797: case 0x2: { |
| 6695 | OPC_CheckPredicate, 31, // 5799: check predicate 31 |
| 6696 | OPC_Decode, 161, 12, 186, 2, // 5801: decode to DOTP_S_W using decoder 314 |
| 6697 | // 5801: } |
| 6698 | 3, 7, // 5806: case 0x3: { |
| 6699 | OPC_CheckPredicate, 31, // 5808: check predicate 31 |
| 6700 | OPC_Decode, 159, 12, 187, 2, // 5810: decode to DOTP_S_D using decoder 315 |
| 6701 | // 5810: } |
| 6702 | 5, 7, // 5815: case 0x5: { |
| 6703 | OPC_CheckPredicate, 31, // 5817: check predicate 31 |
| 6704 | OPC_Decode, 163, 12, 185, 2, // 5819: decode to DOTP_U_H using decoder 313 |
| 6705 | // 5819: } |
| 6706 | 6, 7, // 5824: case 0x6: { |
| 6707 | OPC_CheckPredicate, 31, // 5826: check predicate 31 |
| 6708 | OPC_Decode, 164, 12, 186, 2, // 5828: decode to DOTP_U_W using decoder 314 |
| 6709 | // 5828: } |
| 6710 | 7, 7, // 5833: case 0x7: { |
| 6711 | OPC_CheckPredicate, 31, // 5835: check predicate 31 |
| 6712 | OPC_Decode, 162, 12, 187, 2, // 5837: decode to DOTP_U_D using decoder 315 |
| 6713 | // 5837: } |
| 6714 | 9, 7, // 5842: case 0x9: { |
| 6715 | OPC_CheckPredicate, 31, // 5844: check predicate 31 |
| 6716 | OPC_Decode, 166, 12, 188, 2, // 5846: decode to DPADD_S_H using decoder 316 |
| 6717 | // 5846: } |
| 6718 | 10, 7, // 5851: case 0xa: { |
| 6719 | OPC_CheckPredicate, 31, // 5853: check predicate 31 |
| 6720 | OPC_Decode, 167, 12, 189, 2, // 5855: decode to DPADD_S_W using decoder 317 |
| 6721 | // 5855: } |
| 6722 | 11, 7, // 5860: case 0xb: { |
| 6723 | OPC_CheckPredicate, 31, // 5862: check predicate 31 |
| 6724 | OPC_Decode, 165, 12, 190, 2, // 5864: decode to DPADD_S_D using decoder 318 |
| 6725 | // 5864: } |
| 6726 | 13, 7, // 5869: case 0xd: { |
| 6727 | OPC_CheckPredicate, 31, // 5871: check predicate 31 |
| 6728 | OPC_Decode, 169, 12, 188, 2, // 5873: decode to DPADD_U_H using decoder 316 |
| 6729 | // 5873: } |
| 6730 | 14, 7, // 5878: case 0xe: { |
| 6731 | OPC_CheckPredicate, 31, // 5880: check predicate 31 |
| 6732 | OPC_Decode, 170, 12, 189, 2, // 5882: decode to DPADD_U_W using decoder 317 |
| 6733 | // 5882: } |
| 6734 | 15, 7, // 5887: case 0xf: { |
| 6735 | OPC_CheckPredicate, 31, // 5889: check predicate 31 |
| 6736 | OPC_Decode, 168, 12, 190, 2, // 5891: decode to DPADD_U_D using decoder 318 |
| 6737 | // 5891: } |
| 6738 | 17, 7, // 5896: case 0x11: { |
| 6739 | OPC_CheckPredicate, 31, // 5898: check predicate 31 |
| 6740 | OPC_Decode, 197, 12, 188, 2, // 5900: decode to DPSUB_S_H using decoder 316 |
| 6741 | // 5900: } |
| 6742 | 18, 7, // 5905: case 0x12: { |
| 6743 | OPC_CheckPredicate, 31, // 5907: check predicate 31 |
| 6744 | OPC_Decode, 198, 12, 189, 2, // 5909: decode to DPSUB_S_W using decoder 317 |
| 6745 | // 5909: } |
| 6746 | 19, 7, // 5914: case 0x13: { |
| 6747 | OPC_CheckPredicate, 31, // 5916: check predicate 31 |
| 6748 | OPC_Decode, 196, 12, 190, 2, // 5918: decode to DPSUB_S_D using decoder 318 |
| 6749 | // 5918: } |
| 6750 | 21, 7, // 5923: case 0x15: { |
| 6751 | OPC_CheckPredicate, 31, // 5925: check predicate 31 |
| 6752 | OPC_Decode, 200, 12, 188, 2, // 5927: decode to DPSUB_U_H using decoder 316 |
| 6753 | // 5927: } |
| 6754 | 22, 7, // 5932: case 0x16: { |
| 6755 | OPC_CheckPredicate, 31, // 5934: check predicate 31 |
| 6756 | OPC_Decode, 201, 12, 189, 2, // 5936: decode to DPSUB_U_W using decoder 317 |
| 6757 | // 5936: } |
| 6758 | 23, 0, // 5941: case 0x17: { |
| 6759 | OPC_CheckPredicate, 31, // 5943: check predicate 31 |
| 6760 | OPC_Decode, 199, 12, 190, 2, // 5945: decode to DPSUB_U_D using decoder 318 |
| 6761 | // 5945: } |
| 6762 | // 5945: } // switch Inst[25:21] |
| 6763 | // 5945: } |
| 6764 | 20, 163, 2, // 5950: case 0x14: { |
| 6765 | OPC_SwitchField, 21, 5, // 5953: switch Inst[25:21] { |
| 6766 | 0, 7, // 5956: case 0x0: { |
| 6767 | OPC_CheckPredicate, 31, // 5958: check predicate 31 |
| 6768 | OPC_Decode, 240, 21, 191, 2, // 5960: decode to SLD_B using decoder 319 |
| 6769 | // 5960: } |
| 6770 | 1, 7, // 5965: case 0x1: { |
| 6771 | OPC_CheckPredicate, 31, // 5967: check predicate 31 |
| 6772 | OPC_Decode, 242, 21, 192, 2, // 5969: decode to SLD_H using decoder 320 |
| 6773 | // 5969: } |
| 6774 | 2, 7, // 5974: case 0x2: { |
| 6775 | OPC_CheckPredicate, 31, // 5976: check predicate 31 |
| 6776 | OPC_Decode, 243, 21, 193, 2, // 5978: decode to SLD_W using decoder 321 |
| 6777 | // 5978: } |
| 6778 | 3, 7, // 5983: case 0x3: { |
| 6779 | OPC_CheckPredicate, 31, // 5985: check predicate 31 |
| 6780 | OPC_Decode, 241, 21, 194, 2, // 5987: decode to SLD_D using decoder 322 |
| 6781 | // 5987: } |
| 6782 | 4, 7, // 5992: case 0x4: { |
| 6783 | OPC_CheckPredicate, 31, // 5994: check predicate 31 |
| 6784 | OPC_Decode, 159, 22, 195, 2, // 5996: decode to SPLAT_B using decoder 323 |
| 6785 | // 5996: } |
| 6786 | 5, 7, // 6001: case 0x5: { |
| 6787 | OPC_CheckPredicate, 31, // 6003: check predicate 31 |
| 6788 | OPC_Decode, 161, 22, 196, 2, // 6005: decode to SPLAT_H using decoder 324 |
| 6789 | // 6005: } |
| 6790 | 6, 7, // 6010: case 0x6: { |
| 6791 | OPC_CheckPredicate, 31, // 6012: check predicate 31 |
| 6792 | OPC_Decode, 162, 22, 197, 2, // 6014: decode to SPLAT_W using decoder 325 |
| 6793 | // 6014: } |
| 6794 | 7, 7, // 6019: case 0x7: { |
| 6795 | OPC_CheckPredicate, 31, // 6021: check predicate 31 |
| 6796 | OPC_Decode, 160, 22, 198, 2, // 6023: decode to SPLAT_D using decoder 326 |
| 6797 | // 6023: } |
| 6798 | 8, 7, // 6028: case 0x8: { |
| 6799 | OPC_CheckPredicate, 31, // 6030: check predicate 31 |
| 6800 | OPC_Decode, 210, 19, 177, 2, // 6032: decode to PCKEV_B using decoder 305 |
| 6801 | // 6032: } |
| 6802 | 9, 7, // 6037: case 0x9: { |
| 6803 | OPC_CheckPredicate, 31, // 6039: check predicate 31 |
| 6804 | OPC_Decode, 212, 19, 178, 2, // 6041: decode to PCKEV_H using decoder 306 |
| 6805 | // 6041: } |
| 6806 | 10, 7, // 6046: case 0xa: { |
| 6807 | OPC_CheckPredicate, 31, // 6048: check predicate 31 |
| 6808 | OPC_Decode, 213, 19, 179, 2, // 6050: decode to PCKEV_W using decoder 307 |
| 6809 | // 6050: } |
| 6810 | 11, 7, // 6055: case 0xb: { |
| 6811 | OPC_CheckPredicate, 31, // 6057: check predicate 31 |
| 6812 | OPC_Decode, 211, 19, 180, 2, // 6059: decode to PCKEV_D using decoder 308 |
| 6813 | // 6059: } |
| 6814 | 12, 7, // 6064: case 0xc: { |
| 6815 | OPC_CheckPredicate, 31, // 6066: check predicate 31 |
| 6816 | OPC_Decode, 214, 19, 177, 2, // 6068: decode to PCKOD_B using decoder 305 |
| 6817 | // 6068: } |
| 6818 | 13, 7, // 6073: case 0xd: { |
| 6819 | OPC_CheckPredicate, 31, // 6075: check predicate 31 |
| 6820 | OPC_Decode, 216, 19, 178, 2, // 6077: decode to PCKOD_H using decoder 306 |
| 6821 | // 6077: } |
| 6822 | 14, 7, // 6082: case 0xe: { |
| 6823 | OPC_CheckPredicate, 31, // 6084: check predicate 31 |
| 6824 | OPC_Decode, 217, 19, 179, 2, // 6086: decode to PCKOD_W using decoder 307 |
| 6825 | // 6086: } |
| 6826 | 15, 7, // 6091: case 0xf: { |
| 6827 | OPC_CheckPredicate, 31, // 6093: check predicate 31 |
| 6828 | OPC_Decode, 215, 19, 180, 2, // 6095: decode to PCKOD_D using decoder 308 |
| 6829 | // 6095: } |
| 6830 | 16, 7, // 6100: case 0x10: { |
| 6831 | OPC_CheckPredicate, 31, // 6102: check predicate 31 |
| 6832 | OPC_Decode, 235, 14, 177, 2, // 6104: decode to ILVL_B using decoder 305 |
| 6833 | // 6104: } |
| 6834 | 17, 7, // 6109: case 0x11: { |
| 6835 | OPC_CheckPredicate, 31, // 6111: check predicate 31 |
| 6836 | OPC_Decode, 237, 14, 178, 2, // 6113: decode to ILVL_H using decoder 306 |
| 6837 | // 6113: } |
| 6838 | 18, 7, // 6118: case 0x12: { |
| 6839 | OPC_CheckPredicate, 31, // 6120: check predicate 31 |
| 6840 | OPC_Decode, 238, 14, 179, 2, // 6122: decode to ILVL_W using decoder 307 |
| 6841 | // 6122: } |
| 6842 | 19, 7, // 6127: case 0x13: { |
| 6843 | OPC_CheckPredicate, 31, // 6129: check predicate 31 |
| 6844 | OPC_Decode, 236, 14, 180, 2, // 6131: decode to ILVL_D using decoder 308 |
| 6845 | // 6131: } |
| 6846 | 20, 7, // 6136: case 0x14: { |
| 6847 | OPC_CheckPredicate, 31, // 6138: check predicate 31 |
| 6848 | OPC_Decode, 243, 14, 177, 2, // 6140: decode to ILVR_B using decoder 305 |
| 6849 | // 6140: } |
| 6850 | 21, 7, // 6145: case 0x15: { |
| 6851 | OPC_CheckPredicate, 31, // 6147: check predicate 31 |
| 6852 | OPC_Decode, 245, 14, 178, 2, // 6149: decode to ILVR_H using decoder 306 |
| 6853 | // 6149: } |
| 6854 | 22, 7, // 6154: case 0x16: { |
| 6855 | OPC_CheckPredicate, 31, // 6156: check predicate 31 |
| 6856 | OPC_Decode, 246, 14, 179, 2, // 6158: decode to ILVR_W using decoder 307 |
| 6857 | // 6158: } |
| 6858 | 23, 7, // 6163: case 0x17: { |
| 6859 | OPC_CheckPredicate, 31, // 6165: check predicate 31 |
| 6860 | OPC_Decode, 244, 14, 180, 2, // 6167: decode to ILVR_D using decoder 308 |
| 6861 | // 6167: } |
| 6862 | 24, 7, // 6172: case 0x18: { |
| 6863 | OPC_CheckPredicate, 31, // 6174: check predicate 31 |
| 6864 | OPC_Decode, 231, 14, 177, 2, // 6176: decode to ILVEV_B using decoder 305 |
| 6865 | // 6176: } |
| 6866 | 25, 7, // 6181: case 0x19: { |
| 6867 | OPC_CheckPredicate, 31, // 6183: check predicate 31 |
| 6868 | OPC_Decode, 233, 14, 178, 2, // 6185: decode to ILVEV_H using decoder 306 |
| 6869 | // 6185: } |
| 6870 | 26, 7, // 6190: case 0x1a: { |
| 6871 | OPC_CheckPredicate, 31, // 6192: check predicate 31 |
| 6872 | OPC_Decode, 234, 14, 179, 2, // 6194: decode to ILVEV_W using decoder 307 |
| 6873 | // 6194: } |
| 6874 | 27, 7, // 6199: case 0x1b: { |
| 6875 | OPC_CheckPredicate, 31, // 6201: check predicate 31 |
| 6876 | OPC_Decode, 232, 14, 180, 2, // 6203: decode to ILVEV_D using decoder 308 |
| 6877 | // 6203: } |
| 6878 | 28, 7, // 6208: case 0x1c: { |
| 6879 | OPC_CheckPredicate, 31, // 6210: check predicate 31 |
| 6880 | OPC_Decode, 239, 14, 177, 2, // 6212: decode to ILVOD_B using decoder 305 |
| 6881 | // 6212: } |
| 6882 | 29, 7, // 6217: case 0x1d: { |
| 6883 | OPC_CheckPredicate, 31, // 6219: check predicate 31 |
| 6884 | OPC_Decode, 241, 14, 178, 2, // 6221: decode to ILVOD_H using decoder 306 |
| 6885 | // 6221: } |
| 6886 | 30, 7, // 6226: case 0x1e: { |
| 6887 | OPC_CheckPredicate, 31, // 6228: check predicate 31 |
| 6888 | OPC_Decode, 242, 14, 179, 2, // 6230: decode to ILVOD_W using decoder 307 |
| 6889 | // 6230: } |
| 6890 | 31, 0, // 6235: case 0x1f: { |
| 6891 | OPC_CheckPredicate, 31, // 6237: check predicate 31 |
| 6892 | OPC_Decode, 240, 14, 180, 2, // 6239: decode to ILVOD_D using decoder 308 |
| 6893 | // 6239: } |
| 6894 | // 6239: } // switch Inst[25:21] |
| 6895 | // 6239: } |
| 6896 | 21, 219, 1, // 6244: case 0x15: { |
| 6897 | OPC_SwitchField, 21, 5, // 6247: switch Inst[25:21] { |
| 6898 | 0, 7, // 6250: case 0x0: { |
| 6899 | OPC_CheckPredicate, 31, // 6252: check predicate 31 |
| 6900 | OPC_Decode, 176, 24, 181, 2, // 6254: decode to VSHF_B using decoder 309 |
| 6901 | // 6254: } |
| 6902 | 1, 7, // 6259: case 0x1: { |
| 6903 | OPC_CheckPredicate, 31, // 6261: check predicate 31 |
| 6904 | OPC_Decode, 178, 24, 182, 2, // 6263: decode to VSHF_H using decoder 310 |
| 6905 | // 6263: } |
| 6906 | 2, 7, // 6268: case 0x2: { |
| 6907 | OPC_CheckPredicate, 31, // 6270: check predicate 31 |
| 6908 | OPC_Decode, 179, 24, 183, 2, // 6272: decode to VSHF_W using decoder 311 |
| 6909 | // 6272: } |
| 6910 | 3, 7, // 6277: case 0x3: { |
| 6911 | OPC_CheckPredicate, 31, // 6279: check predicate 31 |
| 6912 | OPC_Decode, 177, 24, 184, 2, // 6281: decode to VSHF_D using decoder 312 |
| 6913 | // 6281: } |
| 6914 | 4, 7, // 6286: case 0x4: { |
| 6915 | OPC_CheckPredicate, 31, // 6288: check predicate 31 |
| 6916 | OPC_Decode, 172, 22, 177, 2, // 6290: decode to SRAR_B using decoder 305 |
| 6917 | // 6290: } |
| 6918 | 5, 7, // 6295: case 0x5: { |
| 6919 | OPC_CheckPredicate, 31, // 6297: check predicate 31 |
| 6920 | OPC_Decode, 174, 22, 178, 2, // 6299: decode to SRAR_H using decoder 306 |
| 6921 | // 6299: } |
| 6922 | 6, 7, // 6304: case 0x6: { |
| 6923 | OPC_CheckPredicate, 31, // 6306: check predicate 31 |
| 6924 | OPC_Decode, 175, 22, 179, 2, // 6308: decode to SRAR_W using decoder 307 |
| 6925 | // 6308: } |
| 6926 | 7, 7, // 6313: case 0x7: { |
| 6927 | OPC_CheckPredicate, 31, // 6315: check predicate 31 |
| 6928 | OPC_Decode, 173, 22, 180, 2, // 6317: decode to SRAR_D using decoder 308 |
| 6929 | // 6317: } |
| 6930 | 8, 7, // 6322: case 0x8: { |
| 6931 | OPC_CheckPredicate, 31, // 6324: check predicate 31 |
| 6932 | OPC_Decode, 197, 22, 177, 2, // 6326: decode to SRLR_B using decoder 305 |
| 6933 | // 6326: } |
| 6934 | 9, 7, // 6331: case 0x9: { |
| 6935 | OPC_CheckPredicate, 31, // 6333: check predicate 31 |
| 6936 | OPC_Decode, 199, 22, 178, 2, // 6335: decode to SRLR_H using decoder 306 |
| 6937 | // 6335: } |
| 6938 | 10, 7, // 6340: case 0xa: { |
| 6939 | OPC_CheckPredicate, 31, // 6342: check predicate 31 |
| 6940 | OPC_Decode, 200, 22, 179, 2, // 6344: decode to SRLR_W using decoder 307 |
| 6941 | // 6344: } |
| 6942 | 11, 7, // 6349: case 0xb: { |
| 6943 | OPC_CheckPredicate, 31, // 6351: check predicate 31 |
| 6944 | OPC_Decode, 198, 22, 180, 2, // 6353: decode to SRLR_D using decoder 308 |
| 6945 | // 6353: } |
| 6946 | 17, 7, // 6358: case 0x11: { |
| 6947 | OPC_CheckPredicate, 31, // 6360: check predicate 31 |
| 6948 | OPC_Decode, 218, 14, 185, 2, // 6362: decode to HADD_S_H using decoder 313 |
| 6949 | // 6362: } |
| 6950 | 18, 7, // 6367: case 0x12: { |
| 6951 | OPC_CheckPredicate, 31, // 6369: check predicate 31 |
| 6952 | OPC_Decode, 219, 14, 186, 2, // 6371: decode to HADD_S_W using decoder 314 |
| 6953 | // 6371: } |
| 6954 | 19, 7, // 6376: case 0x13: { |
| 6955 | OPC_CheckPredicate, 31, // 6378: check predicate 31 |
| 6956 | OPC_Decode, 217, 14, 187, 2, // 6380: decode to HADD_S_D using decoder 315 |
| 6957 | // 6380: } |
| 6958 | 21, 7, // 6385: case 0x15: { |
| 6959 | OPC_CheckPredicate, 31, // 6387: check predicate 31 |
| 6960 | OPC_Decode, 221, 14, 185, 2, // 6389: decode to HADD_U_H using decoder 313 |
| 6961 | // 6389: } |
| 6962 | 22, 7, // 6394: case 0x16: { |
| 6963 | OPC_CheckPredicate, 31, // 6396: check predicate 31 |
| 6964 | OPC_Decode, 222, 14, 186, 2, // 6398: decode to HADD_U_W using decoder 314 |
| 6965 | // 6398: } |
| 6966 | 23, 7, // 6403: case 0x17: { |
| 6967 | OPC_CheckPredicate, 31, // 6405: check predicate 31 |
| 6968 | OPC_Decode, 220, 14, 187, 2, // 6407: decode to HADD_U_D using decoder 315 |
| 6969 | // 6407: } |
| 6970 | 25, 7, // 6412: case 0x19: { |
| 6971 | OPC_CheckPredicate, 31, // 6414: check predicate 31 |
| 6972 | OPC_Decode, 224, 14, 185, 2, // 6416: decode to HSUB_S_H using decoder 313 |
| 6973 | // 6416: } |
| 6974 | 26, 7, // 6421: case 0x1a: { |
| 6975 | OPC_CheckPredicate, 31, // 6423: check predicate 31 |
| 6976 | OPC_Decode, 225, 14, 186, 2, // 6425: decode to HSUB_S_W using decoder 314 |
| 6977 | // 6425: } |
| 6978 | 27, 7, // 6430: case 0x1b: { |
| 6979 | OPC_CheckPredicate, 31, // 6432: check predicate 31 |
| 6980 | OPC_Decode, 223, 14, 187, 2, // 6434: decode to HSUB_S_D using decoder 315 |
| 6981 | // 6434: } |
| 6982 | 29, 7, // 6439: case 0x1d: { |
| 6983 | OPC_CheckPredicate, 31, // 6441: check predicate 31 |
| 6984 | OPC_Decode, 227, 14, 185, 2, // 6443: decode to HSUB_U_H using decoder 313 |
| 6985 | // 6443: } |
| 6986 | 30, 7, // 6448: case 0x1e: { |
| 6987 | OPC_CheckPredicate, 31, // 6450: check predicate 31 |
| 6988 | OPC_Decode, 228, 14, 186, 2, // 6452: decode to HSUB_U_W using decoder 314 |
| 6989 | // 6452: } |
| 6990 | 31, 0, // 6457: case 0x1f: { |
| 6991 | OPC_CheckPredicate, 31, // 6459: check predicate 31 |
| 6992 | OPC_Decode, 226, 14, 187, 2, // 6461: decode to HSUB_U_D using decoder 315 |
| 6993 | // 6461: } |
| 6994 | // 6461: } // switch Inst[25:21] |
| 6995 | // 6461: } |
| 6996 | 25, 194, 2, // 6466: case 0x19: { |
| 6997 | OPC_SwitchField, 20, 6, // 6469: switch Inst[25:20] { |
| 6998 | 0, 7, // 6472: case 0x0: { |
| 6999 | OPC_CheckPredicate, 31, // 6474: check predicate 31 |
| 7000 | OPC_Decode, 236, 21, 199, 2, // 6476: decode to SLDI_B using decoder 327 |
| 7001 | // 6476: } |
| 7002 | 2, 11, // 6481: case 0x2: { |
| 7003 | OPC_CheckPredicate, 31, // 6483: check predicate 31 |
| 7004 | OPC_CheckField, 19, 1, 0, // 6485: check Inst[19] == 0x0 |
| 7005 | OPC_Decode, 238, 21, 200, 2, // 6489: decode to SLDI_H using decoder 328 |
| 7006 | // 6489: } |
| 7007 | 3, 38, // 6494: case 0x3: { |
| 7008 | OPC_SwitchField, 18, 2, // 6496: switch Inst[19:18] { |
| 7009 | 0, 7, // 6499: case 0x0: { |
| 7010 | OPC_CheckPredicate, 31, // 6501: check predicate 31 |
| 7011 | OPC_Decode, 239, 21, 201, 2, // 6503: decode to SLDI_W using decoder 329 |
| 7012 | // 6503: } |
| 7013 | 2, 11, // 6508: case 0x2: { |
| 7014 | OPC_CheckPredicate, 31, // 6510: check predicate 31 |
| 7015 | OPC_CheckField, 17, 1, 0, // 6512: check Inst[17] == 0x0 |
| 7016 | OPC_Decode, 237, 21, 202, 2, // 6516: decode to SLDI_D using decoder 330 |
| 7017 | // 6516: } |
| 7018 | 3, 0, // 6521: case 0x3: { |
| 7019 | OPC_CheckPredicate, 31, // 6523: check predicate 31 |
| 7020 | OPC_CheckField, 16, 2, 2, // 6525: check Inst[17:16] == 0x2 |
| 7021 | OPC_Decode, 212, 10, 203, 2, // 6529: decode to CTCMSA using decoder 331 |
| 7022 | // 6529: } |
| 7023 | // 6529: } // switch Inst[19:18] |
| 7024 | // 6529: } |
| 7025 | 4, 7, // 6534: case 0x4: { |
| 7026 | OPC_CheckPredicate, 31, // 6536: check predicate 31 |
| 7027 | OPC_Decode, 155, 22, 204, 2, // 6538: decode to SPLATI_B using decoder 332 |
| 7028 | // 6538: } |
| 7029 | 6, 11, // 6543: case 0x6: { |
| 7030 | OPC_CheckPredicate, 31, // 6545: check predicate 31 |
| 7031 | OPC_CheckField, 19, 1, 0, // 6547: check Inst[19] == 0x0 |
| 7032 | OPC_Decode, 157, 22, 205, 2, // 6551: decode to SPLATI_H using decoder 333 |
| 7033 | // 6551: } |
| 7034 | 7, 38, // 6556: case 0x7: { |
| 7035 | OPC_SwitchField, 18, 2, // 6558: switch Inst[19:18] { |
| 7036 | 0, 7, // 6561: case 0x0: { |
| 7037 | OPC_CheckPredicate, 31, // 6563: check predicate 31 |
| 7038 | OPC_Decode, 158, 22, 206, 2, // 6565: decode to SPLATI_W using decoder 334 |
| 7039 | // 6565: } |
| 7040 | 2, 11, // 6570: case 0x2: { |
| 7041 | OPC_CheckPredicate, 31, // 6572: check predicate 31 |
| 7042 | OPC_CheckField, 17, 1, 0, // 6574: check Inst[17] == 0x0 |
| 7043 | OPC_Decode, 156, 22, 207, 2, // 6578: decode to SPLATI_D using decoder 335 |
| 7044 | // 6578: } |
| 7045 | 3, 0, // 6583: case 0x3: { |
| 7046 | OPC_CheckPredicate, 31, // 6585: check predicate 31 |
| 7047 | OPC_CheckField, 16, 2, 2, // 6587: check Inst[17:16] == 0x2 |
| 7048 | OPC_Decode, 177, 9, 208, 2, // 6591: decode to CFCMSA using decoder 336 |
| 7049 | // 6591: } |
| 7050 | // 6591: } // switch Inst[19:18] |
| 7051 | // 6591: } |
| 7052 | 8, 7, // 6596: case 0x8: { |
| 7053 | OPC_CheckPredicate, 31, // 6598: check predicate 31 |
| 7054 | OPC_Decode, 188, 10, 209, 2, // 6600: decode to COPY_S_B using decoder 337 |
| 7055 | // 6600: } |
| 7056 | 10, 11, // 6605: case 0xa: { |
| 7057 | OPC_CheckPredicate, 31, // 6607: check predicate 31 |
| 7058 | OPC_CheckField, 19, 1, 0, // 6609: check Inst[19] == 0x0 |
| 7059 | OPC_Decode, 190, 10, 210, 2, // 6613: decode to COPY_S_H using decoder 338 |
| 7060 | // 6613: } |
| 7061 | 11, 38, // 6618: case 0xb: { |
| 7062 | OPC_SwitchField, 18, 2, // 6620: switch Inst[19:18] { |
| 7063 | 0, 7, // 6623: case 0x0: { |
| 7064 | OPC_CheckPredicate, 31, // 6625: check predicate 31 |
| 7065 | OPC_Decode, 191, 10, 211, 2, // 6627: decode to COPY_S_W using decoder 339 |
| 7066 | // 6627: } |
| 7067 | 2, 11, // 6632: case 0x2: { |
| 7068 | OPC_CheckPredicate, 39, // 6634: check predicate 39 |
| 7069 | OPC_CheckField, 17, 1, 0, // 6636: check Inst[17] == 0x0 |
| 7070 | OPC_Decode, 189, 10, 212, 2, // 6640: decode to COPY_S_D using decoder 340 |
| 7071 | // 6640: } |
| 7072 | 3, 0, // 6645: case 0x3: { |
| 7073 | OPC_CheckPredicate, 31, // 6647: check predicate 31 |
| 7074 | OPC_CheckField, 16, 2, 2, // 6649: check Inst[17:16] == 0x2 |
| 7075 | OPC_Decode, 242, 17, 213, 2, // 6653: decode to MOVE_V using decoder 341 |
| 7076 | // 6653: } |
| 7077 | // 6653: } // switch Inst[19:18] |
| 7078 | // 6653: } |
| 7079 | 12, 7, // 6658: case 0xc: { |
| 7080 | OPC_CheckPredicate, 31, // 6660: check predicate 31 |
| 7081 | OPC_Decode, 192, 10, 209, 2, // 6662: decode to COPY_U_B using decoder 337 |
| 7082 | // 6662: } |
| 7083 | 14, 11, // 6667: case 0xe: { |
| 7084 | OPC_CheckPredicate, 31, // 6669: check predicate 31 |
| 7085 | OPC_CheckField, 19, 1, 0, // 6671: check Inst[19] == 0x0 |
| 7086 | OPC_Decode, 193, 10, 210, 2, // 6675: decode to COPY_U_H using decoder 338 |
| 7087 | // 6675: } |
| 7088 | 15, 11, // 6680: case 0xf: { |
| 7089 | OPC_CheckPredicate, 39, // 6682: check predicate 39 |
| 7090 | OPC_CheckField, 18, 2, 0, // 6684: check Inst[19:18] == 0x0 |
| 7091 | OPC_Decode, 194, 10, 211, 2, // 6688: decode to COPY_U_W using decoder 339 |
| 7092 | // 6688: } |
| 7093 | 16, 7, // 6693: case 0x10: { |
| 7094 | OPC_CheckPredicate, 31, // 6695: check predicate 31 |
| 7095 | OPC_Decode, 248, 14, 214, 2, // 6697: decode to INSERT_B using decoder 342 |
| 7096 | // 6697: } |
| 7097 | 18, 11, // 6702: case 0x12: { |
| 7098 | OPC_CheckPredicate, 31, // 6704: check predicate 31 |
| 7099 | OPC_CheckField, 19, 1, 0, // 6706: check Inst[19] == 0x0 |
| 7100 | OPC_Decode, 250, 14, 215, 2, // 6710: decode to INSERT_H using decoder 343 |
| 7101 | // 6710: } |
| 7102 | 19, 25, // 6715: case 0x13: { |
| 7103 | OPC_SwitchField, 18, 2, // 6717: switch Inst[19:18] { |
| 7104 | 0, 7, // 6720: case 0x0: { |
| 7105 | OPC_CheckPredicate, 31, // 6722: check predicate 31 |
| 7106 | OPC_Decode, 251, 14, 216, 2, // 6724: decode to INSERT_W using decoder 344 |
| 7107 | // 6724: } |
| 7108 | 2, 0, // 6729: case 0x2: { |
| 7109 | OPC_CheckPredicate, 39, // 6731: check predicate 39 |
| 7110 | OPC_CheckField, 17, 1, 0, // 6733: check Inst[17] == 0x0 |
| 7111 | OPC_Decode, 249, 14, 217, 2, // 6737: decode to INSERT_D using decoder 345 |
| 7112 | // 6737: } |
| 7113 | // 6737: } // switch Inst[19:18] |
| 7114 | // 6737: } |
| 7115 | 20, 7, // 6742: case 0x14: { |
| 7116 | OPC_CheckPredicate, 31, // 6744: check predicate 31 |
| 7117 | OPC_Decode, 253, 14, 218, 2, // 6746: decode to INSVE_B using decoder 346 |
| 7118 | // 6746: } |
| 7119 | 22, 11, // 6751: case 0x16: { |
| 7120 | OPC_CheckPredicate, 31, // 6753: check predicate 31 |
| 7121 | OPC_CheckField, 19, 1, 0, // 6755: check Inst[19] == 0x0 |
| 7122 | OPC_Decode, 255, 14, 218, 2, // 6759: decode to INSVE_H using decoder 346 |
| 7123 | // 6759: } |
| 7124 | 23, 0, // 6764: case 0x17: { |
| 7125 | OPC_SwitchField, 18, 2, // 6766: switch Inst[19:18] { |
| 7126 | 0, 7, // 6769: case 0x0: { |
| 7127 | OPC_CheckPredicate, 31, // 6771: check predicate 31 |
| 7128 | OPC_Decode, 128, 15, 218, 2, // 6773: decode to INSVE_W using decoder 346 |
| 7129 | // 6773: } |
| 7130 | 2, 0, // 6778: case 0x2: { |
| 7131 | OPC_CheckPredicate, 31, // 6780: check predicate 31 |
| 7132 | OPC_CheckField, 17, 1, 0, // 6782: check Inst[17] == 0x0 |
| 7133 | OPC_Decode, 254, 14, 218, 2, // 6786: decode to INSVE_D using decoder 346 |
| 7134 | // 6786: } |
| 7135 | // 6786: } // switch Inst[19:18] |
| 7136 | // 6786: } |
| 7137 | // 6786: } // switch Inst[25:20] |
| 7138 | // 6786: } |
| 7139 | 26, 163, 2, // 6791: case 0x1a: { |
| 7140 | OPC_SwitchField, 21, 5, // 6794: switch Inst[25:21] { |
| 7141 | 0, 7, // 6797: case 0x0: { |
| 7142 | OPC_CheckPredicate, 31, // 6799: check predicate 31 |
| 7143 | OPC_Decode, 175, 13, 179, 2, // 6801: decode to FCAF_W using decoder 307 |
| 7144 | // 6801: } |
| 7145 | 1, 7, // 6806: case 0x1: { |
| 7146 | OPC_CheckPredicate, 31, // 6808: check predicate 31 |
| 7147 | OPC_Decode, 174, 13, 180, 2, // 6810: decode to FCAF_D using decoder 308 |
| 7148 | // 6810: } |
| 7149 | 2, 7, // 6815: case 0x2: { |
| 7150 | OPC_CheckPredicate, 31, // 6817: check predicate 31 |
| 7151 | OPC_Decode, 202, 13, 179, 2, // 6819: decode to FCUN_W using decoder 307 |
| 7152 | // 6819: } |
| 7153 | 3, 7, // 6824: case 0x3: { |
| 7154 | OPC_CheckPredicate, 31, // 6826: check predicate 31 |
| 7155 | OPC_Decode, 201, 13, 180, 2, // 6828: decode to FCUN_D using decoder 308 |
| 7156 | // 6828: } |
| 7157 | 4, 7, // 6833: case 0x4: { |
| 7158 | OPC_CheckPredicate, 31, // 6835: check predicate 31 |
| 7159 | OPC_Decode, 177, 13, 179, 2, // 6837: decode to FCEQ_W using decoder 307 |
| 7160 | // 6837: } |
| 7161 | 5, 7, // 6842: case 0x5: { |
| 7162 | OPC_CheckPredicate, 31, // 6844: check predicate 31 |
| 7163 | OPC_Decode, 176, 13, 180, 2, // 6846: decode to FCEQ_D using decoder 308 |
| 7164 | // 6846: } |
| 7165 | 6, 7, // 6851: case 0x6: { |
| 7166 | OPC_CheckPredicate, 31, // 6853: check predicate 31 |
| 7167 | OPC_Decode, 194, 13, 179, 2, // 6855: decode to FCUEQ_W using decoder 307 |
| 7168 | // 6855: } |
| 7169 | 7, 7, // 6860: case 0x7: { |
| 7170 | OPC_CheckPredicate, 31, // 6862: check predicate 31 |
| 7171 | OPC_Decode, 193, 13, 180, 2, // 6864: decode to FCUEQ_D using decoder 308 |
| 7172 | // 6864: } |
| 7173 | 8, 7, // 6869: case 0x8: { |
| 7174 | OPC_CheckPredicate, 31, // 6871: check predicate 31 |
| 7175 | OPC_Decode, 183, 13, 179, 2, // 6873: decode to FCLT_W using decoder 307 |
| 7176 | // 6873: } |
| 7177 | 9, 7, // 6878: case 0x9: { |
| 7178 | OPC_CheckPredicate, 31, // 6880: check predicate 31 |
| 7179 | OPC_Decode, 182, 13, 180, 2, // 6882: decode to FCLT_D using decoder 308 |
| 7180 | // 6882: } |
| 7181 | 10, 7, // 6887: case 0xa: { |
| 7182 | OPC_CheckPredicate, 31, // 6889: check predicate 31 |
| 7183 | OPC_Decode, 198, 13, 179, 2, // 6891: decode to FCULT_W using decoder 307 |
| 7184 | // 6891: } |
| 7185 | 11, 7, // 6896: case 0xb: { |
| 7186 | OPC_CheckPredicate, 31, // 6898: check predicate 31 |
| 7187 | OPC_Decode, 197, 13, 180, 2, // 6900: decode to FCULT_D using decoder 308 |
| 7188 | // 6900: } |
| 7189 | 12, 7, // 6905: case 0xc: { |
| 7190 | OPC_CheckPredicate, 31, // 6907: check predicate 31 |
| 7191 | OPC_Decode, 181, 13, 179, 2, // 6909: decode to FCLE_W using decoder 307 |
| 7192 | // 6909: } |
| 7193 | 13, 7, // 6914: case 0xd: { |
| 7194 | OPC_CheckPredicate, 31, // 6916: check predicate 31 |
| 7195 | OPC_Decode, 180, 13, 180, 2, // 6918: decode to FCLE_D using decoder 308 |
| 7196 | // 6918: } |
| 7197 | 14, 7, // 6923: case 0xe: { |
| 7198 | OPC_CheckPredicate, 31, // 6925: check predicate 31 |
| 7199 | OPC_Decode, 196, 13, 179, 2, // 6927: decode to FCULE_W using decoder 307 |
| 7200 | // 6927: } |
| 7201 | 15, 7, // 6932: case 0xf: { |
| 7202 | OPC_CheckPredicate, 31, // 6934: check predicate 31 |
| 7203 | OPC_Decode, 195, 13, 180, 2, // 6936: decode to FCULE_D using decoder 308 |
| 7204 | // 6936: } |
| 7205 | 16, 7, // 6941: case 0x10: { |
| 7206 | OPC_CheckPredicate, 31, // 6943: check predicate 31 |
| 7207 | OPC_Decode, 162, 14, 179, 2, // 6945: decode to FSAF_W using decoder 307 |
| 7208 | // 6945: } |
| 7209 | 17, 7, // 6950: case 0x11: { |
| 7210 | OPC_CheckPredicate, 31, // 6952: check predicate 31 |
| 7211 | OPC_Decode, 161, 14, 180, 2, // 6954: decode to FSAF_D using decoder 308 |
| 7212 | // 6954: } |
| 7213 | 18, 7, // 6959: case 0x12: { |
| 7214 | OPC_CheckPredicate, 31, // 6961: check predicate 31 |
| 7215 | OPC_Decode, 200, 14, 179, 2, // 6963: decode to FSUN_W using decoder 307 |
| 7216 | // 6963: } |
| 7217 | 19, 7, // 6968: case 0x13: { |
| 7218 | OPC_CheckPredicate, 31, // 6970: check predicate 31 |
| 7219 | OPC_Decode, 199, 14, 180, 2, // 6972: decode to FSUN_D using decoder 308 |
| 7220 | // 6972: } |
| 7221 | 20, 7, // 6977: case 0x14: { |
| 7222 | OPC_CheckPredicate, 31, // 6979: check predicate 31 |
| 7223 | OPC_Decode, 164, 14, 179, 2, // 6981: decode to FSEQ_W using decoder 307 |
| 7224 | // 6981: } |
| 7225 | 21, 7, // 6986: case 0x15: { |
| 7226 | OPC_CheckPredicate, 31, // 6988: check predicate 31 |
| 7227 | OPC_Decode, 163, 14, 180, 2, // 6990: decode to FSEQ_D using decoder 308 |
| 7228 | // 6990: } |
| 7229 | 22, 7, // 6995: case 0x16: { |
| 7230 | OPC_CheckPredicate, 31, // 6997: check predicate 31 |
| 7231 | OPC_Decode, 192, 14, 179, 2, // 6999: decode to FSUEQ_W using decoder 307 |
| 7232 | // 6999: } |
| 7233 | 23, 7, // 7004: case 0x17: { |
| 7234 | OPC_CheckPredicate, 31, // 7006: check predicate 31 |
| 7235 | OPC_Decode, 191, 14, 180, 2, // 7008: decode to FSUEQ_D using decoder 308 |
| 7236 | // 7008: } |
| 7237 | 24, 7, // 7013: case 0x18: { |
| 7238 | OPC_CheckPredicate, 31, // 7015: check predicate 31 |
| 7239 | OPC_Decode, 168, 14, 179, 2, // 7017: decode to FSLT_W using decoder 307 |
| 7240 | // 7017: } |
| 7241 | 25, 7, // 7022: case 0x19: { |
| 7242 | OPC_CheckPredicate, 31, // 7024: check predicate 31 |
| 7243 | OPC_Decode, 167, 14, 180, 2, // 7026: decode to FSLT_D using decoder 308 |
| 7244 | // 7026: } |
| 7245 | 26, 7, // 7031: case 0x1a: { |
| 7246 | OPC_CheckPredicate, 31, // 7033: check predicate 31 |
| 7247 | OPC_Decode, 196, 14, 179, 2, // 7035: decode to FSULT_W using decoder 307 |
| 7248 | // 7035: } |
| 7249 | 27, 7, // 7040: case 0x1b: { |
| 7250 | OPC_CheckPredicate, 31, // 7042: check predicate 31 |
| 7251 | OPC_Decode, 195, 14, 180, 2, // 7044: decode to FSULT_D using decoder 308 |
| 7252 | // 7044: } |
| 7253 | 28, 7, // 7049: case 0x1c: { |
| 7254 | OPC_CheckPredicate, 31, // 7051: check predicate 31 |
| 7255 | OPC_Decode, 166, 14, 179, 2, // 7053: decode to FSLE_W using decoder 307 |
| 7256 | // 7053: } |
| 7257 | 29, 7, // 7058: case 0x1d: { |
| 7258 | OPC_CheckPredicate, 31, // 7060: check predicate 31 |
| 7259 | OPC_Decode, 165, 14, 180, 2, // 7062: decode to FSLE_D using decoder 308 |
| 7260 | // 7062: } |
| 7261 | 30, 7, // 7067: case 0x1e: { |
| 7262 | OPC_CheckPredicate, 31, // 7069: check predicate 31 |
| 7263 | OPC_Decode, 194, 14, 179, 2, // 7071: decode to FSULE_W using decoder 307 |
| 7264 | // 7071: } |
| 7265 | 31, 0, // 7076: case 0x1f: { |
| 7266 | OPC_CheckPredicate, 31, // 7078: check predicate 31 |
| 7267 | OPC_Decode, 193, 14, 180, 2, // 7080: decode to FSULE_D using decoder 308 |
| 7268 | // 7080: } |
| 7269 | // 7080: } // switch Inst[25:21] |
| 7270 | // 7080: } |
| 7271 | 27, 237, 1, // 7085: case 0x1b: { |
| 7272 | OPC_SwitchField, 21, 5, // 7088: switch Inst[25:21] { |
| 7273 | 0, 7, // 7091: case 0x0: { |
| 7274 | OPC_CheckPredicate, 31, // 7093: check predicate 31 |
| 7275 | OPC_Decode, 173, 13, 179, 2, // 7095: decode to FADD_W using decoder 307 |
| 7276 | // 7095: } |
| 7277 | 1, 7, // 7100: case 0x1: { |
| 7278 | OPC_CheckPredicate, 31, // 7102: check predicate 31 |
| 7279 | OPC_Decode, 164, 13, 180, 2, // 7104: decode to FADD_D using decoder 308 |
| 7280 | // 7104: } |
| 7281 | 2, 7, // 7109: case 0x2: { |
| 7282 | OPC_CheckPredicate, 31, // 7111: check predicate 31 |
| 7283 | OPC_Decode, 190, 14, 179, 2, // 7113: decode to FSUB_W using decoder 307 |
| 7284 | // 7113: } |
| 7285 | 3, 7, // 7118: case 0x3: { |
| 7286 | OPC_CheckPredicate, 31, // 7120: check predicate 31 |
| 7287 | OPC_Decode, 181, 14, 180, 2, // 7122: decode to FSUB_D using decoder 308 |
| 7288 | // 7122: } |
| 7289 | 4, 7, // 7127: case 0x4: { |
| 7290 | OPC_CheckPredicate, 31, // 7129: check predicate 31 |
| 7291 | OPC_Decode, 146, 14, 179, 2, // 7131: decode to FMUL_W using decoder 307 |
| 7292 | // 7131: } |
| 7293 | 5, 7, // 7136: case 0x5: { |
| 7294 | OPC_CheckPredicate, 31, // 7138: check predicate 31 |
| 7295 | OPC_Decode, 137, 14, 180, 2, // 7140: decode to FMUL_D using decoder 308 |
| 7296 | // 7140: } |
| 7297 | 6, 7, // 7145: case 0x6: { |
| 7298 | OPC_CheckPredicate, 31, // 7147: check predicate 31 |
| 7299 | OPC_Decode, 211, 13, 179, 2, // 7149: decode to FDIV_W using decoder 307 |
| 7300 | // 7149: } |
| 7301 | 7, 7, // 7154: case 0x7: { |
| 7302 | OPC_CheckPredicate, 31, // 7156: check predicate 31 |
| 7303 | OPC_Decode, 203, 13, 180, 2, // 7158: decode to FDIV_D using decoder 308 |
| 7304 | // 7158: } |
| 7305 | 8, 7, // 7163: case 0x8: { |
| 7306 | OPC_CheckPredicate, 31, // 7165: check predicate 31 |
| 7307 | OPC_Decode, 246, 13, 183, 2, // 7167: decode to FMADD_W using decoder 311 |
| 7308 | // 7167: } |
| 7309 | 9, 7, // 7172: case 0x9: { |
| 7310 | OPC_CheckPredicate, 31, // 7174: check predicate 31 |
| 7311 | OPC_Decode, 245, 13, 184, 2, // 7176: decode to FMADD_D using decoder 312 |
| 7312 | // 7176: } |
| 7313 | 10, 7, // 7181: case 0xa: { |
| 7314 | OPC_CheckPredicate, 31, // 7183: check predicate 31 |
| 7315 | OPC_Decode, 136, 14, 183, 2, // 7185: decode to FMSUB_W using decoder 311 |
| 7316 | // 7185: } |
| 7317 | 11, 7, // 7190: case 0xb: { |
| 7318 | OPC_CheckPredicate, 31, // 7192: check predicate 31 |
| 7319 | OPC_Decode, 135, 14, 184, 2, // 7194: decode to FMSUB_D using decoder 312 |
| 7320 | // 7194: } |
| 7321 | 14, 7, // 7199: case 0xe: { |
| 7322 | OPC_CheckPredicate, 31, // 7201: check predicate 31 |
| 7323 | OPC_Decode, 215, 13, 179, 2, // 7203: decode to FEXP2_W using decoder 307 |
| 7324 | // 7203: } |
| 7325 | 15, 7, // 7208: case 0xf: { |
| 7326 | OPC_CheckPredicate, 31, // 7210: check predicate 31 |
| 7327 | OPC_Decode, 214, 13, 180, 2, // 7212: decode to FEXP2_D using decoder 308 |
| 7328 | // 7212: } |
| 7329 | 16, 7, // 7217: case 0x10: { |
| 7330 | OPC_CheckPredicate, 31, // 7219: check predicate 31 |
| 7331 | OPC_Decode, 212, 13, 219, 2, // 7221: decode to FEXDO_H using decoder 347 |
| 7332 | // 7221: } |
| 7333 | 17, 7, // 7226: case 0x11: { |
| 7334 | OPC_CheckPredicate, 31, // 7228: check predicate 31 |
| 7335 | OPC_Decode, 213, 13, 220, 2, // 7230: decode to FEXDO_W using decoder 348 |
| 7336 | // 7230: } |
| 7337 | 20, 7, // 7235: case 0x14: { |
| 7338 | OPC_CheckPredicate, 31, // 7237: check predicate 31 |
| 7339 | OPC_Decode, 205, 14, 219, 2, // 7239: decode to FTQ_H using decoder 347 |
| 7340 | // 7239: } |
| 7341 | 21, 7, // 7244: case 0x15: { |
| 7342 | OPC_CheckPredicate, 31, // 7246: check predicate 31 |
| 7343 | OPC_Decode, 206, 14, 220, 2, // 7248: decode to FTQ_W using decoder 348 |
| 7344 | // 7248: } |
| 7345 | 24, 7, // 7253: case 0x18: { |
| 7346 | OPC_CheckPredicate, 31, // 7255: check predicate 31 |
| 7347 | OPC_Decode, 254, 13, 179, 2, // 7257: decode to FMIN_W using decoder 307 |
| 7348 | // 7257: } |
| 7349 | 25, 7, // 7262: case 0x19: { |
| 7350 | OPC_CheckPredicate, 31, // 7264: check predicate 31 |
| 7351 | OPC_Decode, 253, 13, 180, 2, // 7266: decode to FMIN_D using decoder 308 |
| 7352 | // 7266: } |
| 7353 | 26, 7, // 7271: case 0x1a: { |
| 7354 | OPC_CheckPredicate, 31, // 7273: check predicate 31 |
| 7355 | OPC_Decode, 252, 13, 179, 2, // 7275: decode to FMIN_A_W using decoder 307 |
| 7356 | // 7275: } |
| 7357 | 27, 7, // 7280: case 0x1b: { |
| 7358 | OPC_CheckPredicate, 31, // 7282: check predicate 31 |
| 7359 | OPC_Decode, 251, 13, 180, 2, // 7284: decode to FMIN_A_D using decoder 308 |
| 7360 | // 7284: } |
| 7361 | 28, 7, // 7289: case 0x1c: { |
| 7362 | OPC_CheckPredicate, 31, // 7291: check predicate 31 |
| 7363 | OPC_Decode, 250, 13, 179, 2, // 7293: decode to FMAX_W using decoder 307 |
| 7364 | // 7293: } |
| 7365 | 29, 7, // 7298: case 0x1d: { |
| 7366 | OPC_CheckPredicate, 31, // 7300: check predicate 31 |
| 7367 | OPC_Decode, 249, 13, 180, 2, // 7302: decode to FMAX_D using decoder 308 |
| 7368 | // 7302: } |
| 7369 | 30, 7, // 7307: case 0x1e: { |
| 7370 | OPC_CheckPredicate, 31, // 7309: check predicate 31 |
| 7371 | OPC_Decode, 248, 13, 179, 2, // 7311: decode to FMAX_A_W using decoder 307 |
| 7372 | // 7311: } |
| 7373 | 31, 0, // 7316: case 0x1f: { |
| 7374 | OPC_CheckPredicate, 31, // 7318: check predicate 31 |
| 7375 | OPC_Decode, 247, 13, 180, 2, // 7320: decode to FMAX_A_D using decoder 308 |
| 7376 | // 7320: } |
| 7377 | // 7320: } // switch Inst[25:21] |
| 7378 | // 7320: } |
| 7379 | 28, 219, 1, // 7325: case 0x1c: { |
| 7380 | OPC_SwitchField, 21, 5, // 7328: switch Inst[25:21] { |
| 7381 | 2, 7, // 7331: case 0x2: { |
| 7382 | OPC_CheckPredicate, 31, // 7333: check predicate 31 |
| 7383 | OPC_Decode, 192, 13, 179, 2, // 7335: decode to FCOR_W using decoder 307 |
| 7384 | // 7335: } |
| 7385 | 3, 7, // 7340: case 0x3: { |
| 7386 | OPC_CheckPredicate, 31, // 7342: check predicate 31 |
| 7387 | OPC_Decode, 191, 13, 180, 2, // 7344: decode to FCOR_D using decoder 308 |
| 7388 | // 7344: } |
| 7389 | 4, 7, // 7349: case 0x4: { |
| 7390 | OPC_CheckPredicate, 31, // 7351: check predicate 31 |
| 7391 | OPC_Decode, 200, 13, 179, 2, // 7353: decode to FCUNE_W using decoder 307 |
| 7392 | // 7353: } |
| 7393 | 5, 7, // 7358: case 0x5: { |
| 7394 | OPC_CheckPredicate, 31, // 7360: check predicate 31 |
| 7395 | OPC_Decode, 199, 13, 180, 2, // 7362: decode to FCUNE_D using decoder 308 |
| 7396 | // 7362: } |
| 7397 | 6, 7, // 7367: case 0x6: { |
| 7398 | OPC_CheckPredicate, 31, // 7369: check predicate 31 |
| 7399 | OPC_Decode, 190, 13, 179, 2, // 7371: decode to FCNE_W using decoder 307 |
| 7400 | // 7371: } |
| 7401 | 7, 7, // 7376: case 0x7: { |
| 7402 | OPC_CheckPredicate, 31, // 7378: check predicate 31 |
| 7403 | OPC_Decode, 189, 13, 180, 2, // 7380: decode to FCNE_D using decoder 308 |
| 7404 | // 7380: } |
| 7405 | 8, 7, // 7385: case 0x8: { |
| 7406 | OPC_CheckPredicate, 31, // 7387: check predicate 31 |
| 7407 | OPC_Decode, 146, 19, 178, 2, // 7389: decode to MUL_Q_H using decoder 306 |
| 7408 | // 7389: } |
| 7409 | 9, 7, // 7394: case 0x9: { |
| 7410 | OPC_CheckPredicate, 31, // 7396: check predicate 31 |
| 7411 | OPC_Decode, 147, 19, 179, 2, // 7398: decode to MUL_Q_W using decoder 307 |
| 7412 | // 7398: } |
| 7413 | 10, 7, // 7403: case 0xa: { |
| 7414 | OPC_CheckPredicate, 31, // 7405: check predicate 31 |
| 7415 | OPC_Decode, 244, 16, 182, 2, // 7407: decode to MADD_Q_H using decoder 310 |
| 7416 | // 7407: } |
| 7417 | 11, 7, // 7412: case 0xb: { |
| 7418 | OPC_CheckPredicate, 31, // 7414: check predicate 31 |
| 7419 | OPC_Decode, 245, 16, 183, 2, // 7416: decode to MADD_Q_W using decoder 311 |
| 7420 | // 7416: } |
| 7421 | 12, 7, // 7421: case 0xc: { |
| 7422 | OPC_CheckPredicate, 31, // 7423: check predicate 31 |
| 7423 | OPC_Decode, 178, 18, 182, 2, // 7425: decode to MSUB_Q_H using decoder 310 |
| 7424 | // 7425: } |
| 7425 | 13, 7, // 7430: case 0xd: { |
| 7426 | OPC_CheckPredicate, 31, // 7432: check predicate 31 |
| 7427 | OPC_Decode, 179, 18, 183, 2, // 7434: decode to MSUB_Q_W using decoder 311 |
| 7428 | // 7434: } |
| 7429 | 18, 7, // 7439: case 0x12: { |
| 7430 | OPC_CheckPredicate, 31, // 7441: check predicate 31 |
| 7431 | OPC_Decode, 172, 14, 179, 2, // 7443: decode to FSOR_W using decoder 307 |
| 7432 | // 7443: } |
| 7433 | 19, 7, // 7448: case 0x13: { |
| 7434 | OPC_CheckPredicate, 31, // 7450: check predicate 31 |
| 7435 | OPC_Decode, 171, 14, 180, 2, // 7452: decode to FSOR_D using decoder 308 |
| 7436 | // 7452: } |
| 7437 | 20, 7, // 7457: case 0x14: { |
| 7438 | OPC_CheckPredicate, 31, // 7459: check predicate 31 |
| 7439 | OPC_Decode, 198, 14, 179, 2, // 7461: decode to FSUNE_W using decoder 307 |
| 7440 | // 7461: } |
| 7441 | 21, 7, // 7466: case 0x15: { |
| 7442 | OPC_CheckPredicate, 31, // 7468: check predicate 31 |
| 7443 | OPC_Decode, 197, 14, 180, 2, // 7470: decode to FSUNE_D using decoder 308 |
| 7444 | // 7470: } |
| 7445 | 22, 7, // 7475: case 0x16: { |
| 7446 | OPC_CheckPredicate, 31, // 7477: check predicate 31 |
| 7447 | OPC_Decode, 170, 14, 179, 2, // 7479: decode to FSNE_W using decoder 307 |
| 7448 | // 7479: } |
| 7449 | 23, 7, // 7484: case 0x17: { |
| 7450 | OPC_CheckPredicate, 31, // 7486: check predicate 31 |
| 7451 | OPC_Decode, 169, 14, 180, 2, // 7488: decode to FSNE_D using decoder 308 |
| 7452 | // 7488: } |
| 7453 | 24, 7, // 7493: case 0x18: { |
| 7454 | OPC_CheckPredicate, 31, // 7495: check predicate 31 |
| 7455 | OPC_Decode, 248, 18, 178, 2, // 7497: decode to MULR_Q_H using decoder 306 |
| 7456 | // 7497: } |
| 7457 | 25, 7, // 7502: case 0x19: { |
| 7458 | OPC_CheckPredicate, 31, // 7504: check predicate 31 |
| 7459 | OPC_Decode, 249, 18, 179, 2, // 7506: decode to MULR_Q_W using decoder 307 |
| 7460 | // 7506: } |
| 7461 | 26, 7, // 7511: case 0x1a: { |
| 7462 | OPC_CheckPredicate, 31, // 7513: check predicate 31 |
| 7463 | OPC_Decode, 228, 16, 182, 2, // 7515: decode to MADDR_Q_H using decoder 310 |
| 7464 | // 7515: } |
| 7465 | 27, 7, // 7520: case 0x1b: { |
| 7466 | OPC_CheckPredicate, 31, // 7522: check predicate 31 |
| 7467 | OPC_Decode, 229, 16, 183, 2, // 7524: decode to MADDR_Q_W using decoder 311 |
| 7468 | // 7524: } |
| 7469 | 28, 7, // 7529: case 0x1c: { |
| 7470 | OPC_CheckPredicate, 31, // 7531: check predicate 31 |
| 7471 | OPC_Decode, 162, 18, 182, 2, // 7533: decode to MSUBR_Q_H using decoder 310 |
| 7472 | // 7533: } |
| 7473 | 29, 0, // 7538: case 0x1d: { |
| 7474 | OPC_CheckPredicate, 31, // 7540: check predicate 31 |
| 7475 | OPC_Decode, 163, 18, 183, 2, // 7542: decode to MSUBR_Q_W using decoder 311 |
| 7476 | // 7542: } |
| 7477 | // 7542: } // switch Inst[25:21] |
| 7478 | // 7542: } |
| 7479 | 30, 253, 3, // 7547: case 0x1e: { |
| 7480 | OPC_SwitchField, 21, 5, // 7550: switch Inst[25:21] { |
| 7481 | 0, 7, // 7553: case 0x0: { |
| 7482 | OPC_CheckPredicate, 31, // 7555: check predicate 31 |
| 7483 | OPC_Decode, 138, 7, 177, 2, // 7557: decode to AND_V using decoder 305 |
| 7484 | // 7557: } |
| 7485 | 1, 7, // 7562: case 0x1: { |
| 7486 | OPC_CheckPredicate, 31, // 7564: check predicate 31 |
| 7487 | OPC_Decode, 199, 19, 177, 2, // 7566: decode to OR_V using decoder 305 |
| 7488 | // 7566: } |
| 7489 | 2, 7, // 7571: case 0x2: { |
| 7490 | OPC_CheckPredicate, 31, // 7573: check predicate 31 |
| 7491 | OPC_Decode, 182, 19, 177, 2, // 7575: decode to NOR_V using decoder 305 |
| 7492 | // 7575: } |
| 7493 | 3, 7, // 7580: case 0x3: { |
| 7494 | OPC_CheckPredicate, 31, // 7582: check predicate 31 |
| 7495 | OPC_Decode, 202, 24, 177, 2, // 7584: decode to XOR_V using decoder 305 |
| 7496 | // 7584: } |
| 7497 | 4, 7, // 7589: case 0x4: { |
| 7498 | OPC_CheckPredicate, 31, // 7591: check predicate 31 |
| 7499 | OPC_Decode, 200, 8, 181, 2, // 7593: decode to BMNZ_V using decoder 309 |
| 7500 | // 7593: } |
| 7501 | 5, 7, // 7598: case 0x5: { |
| 7502 | OPC_CheckPredicate, 31, // 7600: check predicate 31 |
| 7503 | OPC_Decode, 202, 8, 181, 2, // 7602: decode to BMZ_V using decoder 309 |
| 7504 | // 7602: } |
| 7505 | 6, 7, // 7607: case 0x6: { |
| 7506 | OPC_CheckPredicate, 31, // 7609: check predicate 31 |
| 7507 | OPC_Decode, 250, 8, 181, 2, // 7611: decode to BSEL_V using decoder 309 |
| 7508 | // 7611: } |
| 7509 | 24, 147, 1, // 7616: case 0x18: { |
| 7510 | OPC_SwitchField, 16, 5, // 7619: switch Inst[20:16] { |
| 7511 | 0, 7, // 7622: case 0x0: { |
| 7512 | OPC_CheckPredicate, 31, // 7624: check predicate 31 |
| 7513 | OPC_Decode, 228, 13, 221, 2, // 7626: decode to FILL_B using decoder 349 |
| 7514 | // 7626: } |
| 7515 | 1, 7, // 7631: case 0x1: { |
| 7516 | OPC_CheckPredicate, 31, // 7633: check predicate 31 |
| 7517 | OPC_Decode, 230, 13, 222, 2, // 7635: decode to FILL_H using decoder 350 |
| 7518 | // 7635: } |
| 7519 | 2, 7, // 7640: case 0x2: { |
| 7520 | OPC_CheckPredicate, 31, // 7642: check predicate 31 |
| 7521 | OPC_Decode, 231, 13, 223, 2, // 7644: decode to FILL_W using decoder 351 |
| 7522 | // 7644: } |
| 7523 | 3, 7, // 7649: case 0x3: { |
| 7524 | OPC_CheckPredicate, 39, // 7651: check predicate 39 |
| 7525 | OPC_Decode, 229, 13, 224, 2, // 7653: decode to FILL_D using decoder 352 |
| 7526 | // 7653: } |
| 7527 | 4, 7, // 7658: case 0x4: { |
| 7528 | OPC_CheckPredicate, 31, // 7660: check predicate 31 |
| 7529 | OPC_Decode, 218, 19, 213, 2, // 7662: decode to PCNT_B using decoder 341 |
| 7530 | // 7662: } |
| 7531 | 5, 7, // 7667: case 0x5: { |
| 7532 | OPC_CheckPredicate, 31, // 7669: check predicate 31 |
| 7533 | OPC_Decode, 220, 19, 225, 2, // 7671: decode to PCNT_H using decoder 353 |
| 7534 | // 7671: } |
| 7535 | 6, 7, // 7676: case 0x6: { |
| 7536 | OPC_CheckPredicate, 31, // 7678: check predicate 31 |
| 7537 | OPC_Decode, 221, 19, 226, 2, // 7680: decode to PCNT_W using decoder 354 |
| 7538 | // 7680: } |
| 7539 | 7, 7, // 7685: case 0x7: { |
| 7540 | OPC_CheckPredicate, 31, // 7687: check predicate 31 |
| 7541 | OPC_Decode, 219, 19, 227, 2, // 7689: decode to PCNT_D using decoder 355 |
| 7542 | // 7689: } |
| 7543 | 8, 7, // 7694: case 0x8: { |
| 7544 | OPC_CheckPredicate, 31, // 7696: check predicate 31 |
| 7545 | OPC_Decode, 156, 19, 213, 2, // 7698: decode to NLOC_B using decoder 341 |
| 7546 | // 7698: } |
| 7547 | 9, 7, // 7703: case 0x9: { |
| 7548 | OPC_CheckPredicate, 31, // 7705: check predicate 31 |
| 7549 | OPC_Decode, 158, 19, 225, 2, // 7707: decode to NLOC_H using decoder 353 |
| 7550 | // 7707: } |
| 7551 | 10, 7, // 7712: case 0xa: { |
| 7552 | OPC_CheckPredicate, 31, // 7714: check predicate 31 |
| 7553 | OPC_Decode, 159, 19, 226, 2, // 7716: decode to NLOC_W using decoder 354 |
| 7554 | // 7716: } |
| 7555 | 11, 7, // 7721: case 0xb: { |
| 7556 | OPC_CheckPredicate, 31, // 7723: check predicate 31 |
| 7557 | OPC_Decode, 157, 19, 227, 2, // 7725: decode to NLOC_D using decoder 355 |
| 7558 | // 7725: } |
| 7559 | 12, 7, // 7730: case 0xc: { |
| 7560 | OPC_CheckPredicate, 31, // 7732: check predicate 31 |
| 7561 | OPC_Decode, 160, 19, 213, 2, // 7734: decode to NLZC_B using decoder 341 |
| 7562 | // 7734: } |
| 7563 | 13, 7, // 7739: case 0xd: { |
| 7564 | OPC_CheckPredicate, 31, // 7741: check predicate 31 |
| 7565 | OPC_Decode, 162, 19, 225, 2, // 7743: decode to NLZC_H using decoder 353 |
| 7566 | // 7743: } |
| 7567 | 14, 7, // 7748: case 0xe: { |
| 7568 | OPC_CheckPredicate, 31, // 7750: check predicate 31 |
| 7569 | OPC_Decode, 163, 19, 226, 2, // 7752: decode to NLZC_W using decoder 354 |
| 7570 | // 7752: } |
| 7571 | 15, 0, // 7757: case 0xf: { |
| 7572 | OPC_CheckPredicate, 31, // 7759: check predicate 31 |
| 7573 | OPC_Decode, 161, 19, 227, 2, // 7761: decode to NLZC_D using decoder 355 |
| 7574 | // 7761: } |
| 7575 | // 7761: } // switch Inst[20:16] |
| 7576 | // 7761: } |
| 7577 | 25, 0, // 7766: case 0x19: { |
| 7578 | OPC_SwitchField, 16, 5, // 7768: switch Inst[20:16] { |
| 7579 | 0, 7, // 7771: case 0x0: { |
| 7580 | OPC_CheckPredicate, 31, // 7773: check predicate 31 |
| 7581 | OPC_Decode, 179, 13, 226, 2, // 7775: decode to FCLASS_W using decoder 354 |
| 7582 | // 7775: } |
| 7583 | 1, 7, // 7780: case 0x1: { |
| 7584 | OPC_CheckPredicate, 31, // 7782: check predicate 31 |
| 7585 | OPC_Decode, 178, 13, 227, 2, // 7784: decode to FCLASS_D using decoder 355 |
| 7586 | // 7784: } |
| 7587 | 2, 7, // 7789: case 0x2: { |
| 7588 | OPC_CheckPredicate, 31, // 7791: check predicate 31 |
| 7589 | OPC_Decode, 208, 14, 226, 2, // 7793: decode to FTRUNC_S_W using decoder 354 |
| 7590 | // 7793: } |
| 7591 | 3, 7, // 7798: case 0x3: { |
| 7592 | OPC_CheckPredicate, 31, // 7800: check predicate 31 |
| 7593 | OPC_Decode, 207, 14, 227, 2, // 7802: decode to FTRUNC_S_D using decoder 355 |
| 7594 | // 7802: } |
| 7595 | 4, 7, // 7807: case 0x4: { |
| 7596 | OPC_CheckPredicate, 31, // 7809: check predicate 31 |
| 7597 | OPC_Decode, 210, 14, 226, 2, // 7811: decode to FTRUNC_U_W using decoder 354 |
| 7598 | // 7811: } |
| 7599 | 5, 7, // 7816: case 0x5: { |
| 7600 | OPC_CheckPredicate, 31, // 7818: check predicate 31 |
| 7601 | OPC_Decode, 209, 14, 227, 2, // 7820: decode to FTRUNC_U_D using decoder 355 |
| 7602 | // 7820: } |
| 7603 | 6, 7, // 7825: case 0x6: { |
| 7604 | OPC_CheckPredicate, 31, // 7827: check predicate 31 |
| 7605 | OPC_Decode, 180, 14, 226, 2, // 7829: decode to FSQRT_W using decoder 354 |
| 7606 | // 7829: } |
| 7607 | 7, 7, // 7834: case 0x7: { |
| 7608 | OPC_CheckPredicate, 31, // 7836: check predicate 31 |
| 7609 | OPC_Decode, 173, 14, 227, 2, // 7838: decode to FSQRT_D using decoder 355 |
| 7610 | // 7838: } |
| 7611 | 8, 7, // 7843: case 0x8: { |
| 7612 | OPC_CheckPredicate, 31, // 7845: check predicate 31 |
| 7613 | OPC_Decode, 160, 14, 226, 2, // 7847: decode to FRSQRT_W using decoder 354 |
| 7614 | // 7847: } |
| 7615 | 9, 7, // 7852: case 0x9: { |
| 7616 | OPC_CheckPredicate, 31, // 7854: check predicate 31 |
| 7617 | OPC_Decode, 159, 14, 227, 2, // 7856: decode to FRSQRT_D using decoder 355 |
| 7618 | // 7856: } |
| 7619 | 10, 7, // 7861: case 0xa: { |
| 7620 | OPC_CheckPredicate, 31, // 7863: check predicate 31 |
| 7621 | OPC_Decode, 156, 14, 226, 2, // 7865: decode to FRCP_W using decoder 354 |
| 7622 | // 7865: } |
| 7623 | 11, 7, // 7870: case 0xb: { |
| 7624 | OPC_CheckPredicate, 31, // 7872: check predicate 31 |
| 7625 | OPC_Decode, 155, 14, 227, 2, // 7874: decode to FRCP_D using decoder 355 |
| 7626 | // 7874: } |
| 7627 | 12, 7, // 7879: case 0xc: { |
| 7628 | OPC_CheckPredicate, 31, // 7881: check predicate 31 |
| 7629 | OPC_Decode, 158, 14, 226, 2, // 7883: decode to FRINT_W using decoder 354 |
| 7630 | // 7883: } |
| 7631 | 13, 7, // 7888: case 0xd: { |
| 7632 | OPC_CheckPredicate, 31, // 7890: check predicate 31 |
| 7633 | OPC_Decode, 157, 14, 227, 2, // 7892: decode to FRINT_D using decoder 355 |
| 7634 | // 7892: } |
| 7635 | 14, 7, // 7897: case 0xe: { |
| 7636 | OPC_CheckPredicate, 31, // 7899: check predicate 31 |
| 7637 | OPC_Decode, 233, 13, 226, 2, // 7901: decode to FLOG2_W using decoder 354 |
| 7638 | // 7901: } |
| 7639 | 15, 7, // 7906: case 0xf: { |
| 7640 | OPC_CheckPredicate, 31, // 7908: check predicate 31 |
| 7641 | OPC_Decode, 232, 13, 227, 2, // 7910: decode to FLOG2_D using decoder 355 |
| 7642 | // 7910: } |
| 7643 | 16, 7, // 7915: case 0x10: { |
| 7644 | OPC_CheckPredicate, 31, // 7917: check predicate 31 |
| 7645 | OPC_Decode, 217, 13, 228, 2, // 7919: decode to FEXUPL_W using decoder 356 |
| 7646 | // 7919: } |
| 7647 | 17, 7, // 7924: case 0x11: { |
| 7648 | OPC_CheckPredicate, 31, // 7926: check predicate 31 |
| 7649 | OPC_Decode, 216, 13, 229, 2, // 7928: decode to FEXUPL_D using decoder 357 |
| 7650 | // 7928: } |
| 7651 | 18, 7, // 7933: case 0x12: { |
| 7652 | OPC_CheckPredicate, 31, // 7935: check predicate 31 |
| 7653 | OPC_Decode, 219, 13, 228, 2, // 7937: decode to FEXUPR_W using decoder 356 |
| 7654 | // 7937: } |
| 7655 | 19, 7, // 7942: case 0x13: { |
| 7656 | OPC_CheckPredicate, 31, // 7944: check predicate 31 |
| 7657 | OPC_Decode, 218, 13, 229, 2, // 7946: decode to FEXUPR_D using decoder 357 |
| 7658 | // 7946: } |
| 7659 | 20, 7, // 7951: case 0x14: { |
| 7660 | OPC_CheckPredicate, 31, // 7953: check predicate 31 |
| 7661 | OPC_Decode, 225, 13, 228, 2, // 7955: decode to FFQL_W using decoder 356 |
| 7662 | // 7955: } |
| 7663 | 21, 7, // 7960: case 0x15: { |
| 7664 | OPC_CheckPredicate, 31, // 7962: check predicate 31 |
| 7665 | OPC_Decode, 224, 13, 229, 2, // 7964: decode to FFQL_D using decoder 357 |
| 7666 | // 7964: } |
| 7667 | 22, 7, // 7969: case 0x16: { |
| 7668 | OPC_CheckPredicate, 31, // 7971: check predicate 31 |
| 7669 | OPC_Decode, 227, 13, 228, 2, // 7973: decode to FFQR_W using decoder 356 |
| 7670 | // 7973: } |
| 7671 | 23, 7, // 7978: case 0x17: { |
| 7672 | OPC_CheckPredicate, 31, // 7980: check predicate 31 |
| 7673 | OPC_Decode, 226, 13, 229, 2, // 7982: decode to FFQR_D using decoder 357 |
| 7674 | // 7982: } |
| 7675 | 24, 7, // 7987: case 0x18: { |
| 7676 | OPC_CheckPredicate, 31, // 7989: check predicate 31 |
| 7677 | OPC_Decode, 202, 14, 226, 2, // 7991: decode to FTINT_S_W using decoder 354 |
| 7678 | // 7991: } |
| 7679 | 25, 7, // 7996: case 0x19: { |
| 7680 | OPC_CheckPredicate, 31, // 7998: check predicate 31 |
| 7681 | OPC_Decode, 201, 14, 227, 2, // 8000: decode to FTINT_S_D using decoder 355 |
| 7682 | // 8000: } |
| 7683 | 26, 7, // 8005: case 0x1a: { |
| 7684 | OPC_CheckPredicate, 31, // 8007: check predicate 31 |
| 7685 | OPC_Decode, 204, 14, 226, 2, // 8009: decode to FTINT_U_W using decoder 354 |
| 7686 | // 8009: } |
| 7687 | 27, 7, // 8014: case 0x1b: { |
| 7688 | OPC_CheckPredicate, 31, // 8016: check predicate 31 |
| 7689 | OPC_Decode, 203, 14, 227, 2, // 8018: decode to FTINT_U_D using decoder 355 |
| 7690 | // 8018: } |
| 7691 | 28, 7, // 8023: case 0x1c: { |
| 7692 | OPC_CheckPredicate, 31, // 8025: check predicate 31 |
| 7693 | OPC_Decode, 221, 13, 226, 2, // 8027: decode to FFINT_S_W using decoder 354 |
| 7694 | // 8027: } |
| 7695 | 29, 7, // 8032: case 0x1d: { |
| 7696 | OPC_CheckPredicate, 31, // 8034: check predicate 31 |
| 7697 | OPC_Decode, 220, 13, 227, 2, // 8036: decode to FFINT_S_D using decoder 355 |
| 7698 | // 8036: } |
| 7699 | 30, 7, // 8041: case 0x1e: { |
| 7700 | OPC_CheckPredicate, 31, // 8043: check predicate 31 |
| 7701 | OPC_Decode, 223, 13, 226, 2, // 8045: decode to FFINT_U_W using decoder 354 |
| 7702 | // 8045: } |
| 7703 | 31, 0, // 8050: case 0x1f: { |
| 7704 | OPC_CheckPredicate, 31, // 8052: check predicate 31 |
| 7705 | OPC_Decode, 222, 13, 227, 2, // 8054: decode to FFINT_U_D using decoder 355 |
| 7706 | // 8054: } |
| 7707 | // 8054: } // switch Inst[20:16] |
| 7708 | // 8054: } |
| 7709 | // 8054: } // switch Inst[25:21] |
| 7710 | // 8054: } |
| 7711 | 32, 7, // 8059: case 0x20: { |
| 7712 | OPC_CheckPredicate, 31, // 8061: check predicate 31 |
| 7713 | OPC_Decode, 227, 15, 230, 2, // 8063: decode to LD_B using decoder 358 |
| 7714 | // 8063: } |
| 7715 | 33, 7, // 8068: case 0x21: { |
| 7716 | OPC_CheckPredicate, 31, // 8070: check predicate 31 |
| 7717 | OPC_Decode, 229, 15, 231, 2, // 8072: decode to LD_H using decoder 359 |
| 7718 | // 8072: } |
| 7719 | 34, 7, // 8077: case 0x22: { |
| 7720 | OPC_CheckPredicate, 31, // 8079: check predicate 31 |
| 7721 | OPC_Decode, 230, 15, 232, 2, // 8081: decode to LD_W using decoder 360 |
| 7722 | // 8081: } |
| 7723 | 35, 7, // 8086: case 0x23: { |
| 7724 | OPC_CheckPredicate, 31, // 8088: check predicate 31 |
| 7725 | OPC_Decode, 228, 15, 233, 2, // 8090: decode to LD_D using decoder 361 |
| 7726 | // 8090: } |
| 7727 | 36, 7, // 8095: case 0x24: { |
| 7728 | OPC_CheckPredicate, 31, // 8097: check predicate 31 |
| 7729 | OPC_Decode, 213, 22, 230, 2, // 8099: decode to ST_B using decoder 358 |
| 7730 | // 8099: } |
| 7731 | 37, 7, // 8104: case 0x25: { |
| 7732 | OPC_CheckPredicate, 31, // 8106: check predicate 31 |
| 7733 | OPC_Decode, 215, 22, 231, 2, // 8108: decode to ST_H using decoder 359 |
| 7734 | // 8108: } |
| 7735 | 38, 7, // 8113: case 0x26: { |
| 7736 | OPC_CheckPredicate, 31, // 8115: check predicate 31 |
| 7737 | OPC_Decode, 216, 22, 232, 2, // 8117: decode to ST_W using decoder 360 |
| 7738 | // 8117: } |
| 7739 | 39, 0, // 8122: case 0x27: { |
| 7740 | OPC_CheckPredicate, 31, // 8124: check predicate 31 |
| 7741 | OPC_Decode, 214, 22, 233, 2, // 8126: decode to ST_D using decoder 361 |
| 7742 | // 8126: } |
| 7743 | // 8126: } // switch Inst[5:0] |
| 7744 | // 8126: } |
| 7745 | 31, 136, 15, // 8131: case 0x1f: { |
| 7746 | OPC_SwitchField, 0, 6, // 8134: switch Inst[5:0] { |
| 7747 | 0, 7, // 8137: case 0x0: { |
| 7748 | OPC_CheckPredicate, 29, // 8139: check predicate 29 |
| 7749 | OPC_Decode, 255, 12, 234, 2, // 8141: decode to EXT using decoder 362 |
| 7750 | // 8141: } |
| 7751 | 4, 7, // 8146: case 0x4: { |
| 7752 | OPC_CheckPredicate, 29, // 8148: check predicate 29 |
| 7753 | OPC_Decode, 247, 14, 235, 2, // 8150: decode to INS using decoder 363 |
| 7754 | // 8150: } |
| 7755 | 8, 11, // 8155: case 0x8: { |
| 7756 | OPC_CheckPredicate, 43, // 8157: check predicate 43 |
| 7757 | OPC_CheckField, 6, 5, 0, // 8159: check Inst[10:6] == 0x0 |
| 7758 | OPC_Decode, 154, 14, 236, 2, // 8163: decode to FORK using decoder 364 |
| 7759 | // 8163: } |
| 7760 | 9, 14, // 8168: case 0x9: { |
| 7761 | OPC_CheckPredicate, 43, // 8170: check predicate 43 |
| 7762 | OPC_CheckField, 16, 5, 0, // 8172: check Inst[20:16] == 0x0 |
| 7763 | OPC_CheckField, 6, 5, 0, // 8176: check Inst[10:6] == 0x0 |
| 7764 | OPC_Decode, 207, 24, 89, // 8180: decode to YIELD using decoder 89 |
| 7765 | // 8180: } |
| 7766 | 10, 30, // 8184: case 0xa: { |
| 7767 | OPC_SwitchField, 6, 5, // 8186: switch Inst[10:6] { |
| 7768 | 0, 7, // 8189: case 0x0: { |
| 7769 | OPC_CheckPredicate, 38, // 8191: check predicate 38 |
| 7770 | OPC_Decode, 199, 16, 237, 2, // 8193: decode to LWX using decoder 365 |
| 7771 | // 8193: } |
| 7772 | 4, 7, // 8198: case 0x4: { |
| 7773 | OPC_CheckPredicate, 38, // 8200: check predicate 38 |
| 7774 | OPC_Decode, 247, 15, 237, 2, // 8202: decode to LHX using decoder 365 |
| 7775 | // 8202: } |
| 7776 | 6, 0, // 8207: case 0x6: { |
| 7777 | OPC_CheckPredicate, 38, // 8209: check predicate 38 |
| 7778 | OPC_Decode, 192, 15, 237, 2, // 8211: decode to LBUX using decoder 365 |
| 7779 | // 8211: } |
| 7780 | // 8211: } // switch Inst[10:6] |
| 7781 | // 8211: } |
| 7782 | 12, 11, // 8216: case 0xc: { |
| 7783 | OPC_CheckPredicate, 38, // 8218: check predicate 38 |
| 7784 | OPC_CheckField, 6, 10, 0, // 8220: check Inst[15:6] == 0x0 |
| 7785 | OPC_Decode, 252, 14, 238, 2, // 8224: decode to INSV using decoder 366 |
| 7786 | // 8224: } |
| 7787 | 16, 218, 1, // 8229: case 0x10: { |
| 7788 | OPC_SwitchField, 6, 5, // 8232: switch Inst[10:6] { |
| 7789 | 0, 7, // 8235: case 0x0: { |
| 7790 | OPC_CheckPredicate, 38, // 8237: check predicate 38 |
| 7791 | OPC_Decode, 215, 6, 239, 2, // 8239: decode to ADDU_QB using decoder 367 |
| 7792 | // 8239: } |
| 7793 | 1, 7, // 8244: case 0x1: { |
| 7794 | OPC_CheckPredicate, 38, // 8246: check predicate 38 |
| 7795 | OPC_Decode, 129, 23, 239, 2, // 8248: decode to SUBU_QB using decoder 367 |
| 7796 | // 8248: } |
| 7797 | 4, 7, // 8253: case 0x4: { |
| 7798 | OPC_CheckPredicate, 38, // 8255: check predicate 38 |
| 7799 | OPC_Decode, 219, 6, 239, 2, // 8257: decode to ADDU_S_QB using decoder 367 |
| 7800 | // 8257: } |
| 7801 | 5, 7, // 8262: case 0x5: { |
| 7802 | OPC_CheckPredicate, 38, // 8264: check predicate 38 |
| 7803 | OPC_Decode, 133, 23, 239, 2, // 8266: decode to SUBU_S_QB using decoder 367 |
| 7804 | // 8266: } |
| 7805 | 6, 7, // 8271: case 0x6: { |
| 7806 | OPC_CheckPredicate, 38, // 8273: check predicate 38 |
| 7807 | OPC_Decode, 235, 18, 239, 2, // 8275: decode to MULEU_S_PH_QBL using decoder 367 |
| 7808 | // 8275: } |
| 7809 | 7, 7, // 8280: case 0x7: { |
| 7810 | OPC_CheckPredicate, 38, // 8282: check predicate 38 |
| 7811 | OPC_Decode, 237, 18, 239, 2, // 8284: decode to MULEU_S_PH_QBR using decoder 367 |
| 7812 | // 8284: } |
| 7813 | 8, 7, // 8289: case 0x8: { |
| 7814 | OPC_CheckPredicate, 72, // 8291: check predicate 72 |
| 7815 | OPC_Decode, 213, 6, 239, 2, // 8293: decode to ADDU_PH using decoder 367 |
| 7816 | // 8293: } |
| 7817 | 9, 7, // 8298: case 0x9: { |
| 7818 | OPC_CheckPredicate, 72, // 8300: check predicate 72 |
| 7819 | OPC_Decode, 255, 22, 239, 2, // 8302: decode to SUBU_PH using decoder 367 |
| 7820 | // 8302: } |
| 7821 | 10, 7, // 8307: case 0xa: { |
| 7822 | OPC_CheckPredicate, 38, // 8309: check predicate 38 |
| 7823 | OPC_Decode, 185, 6, 239, 2, // 8311: decode to ADDQ_PH using decoder 367 |
| 7824 | // 8311: } |
| 7825 | 11, 7, // 8316: case 0xb: { |
| 7826 | OPC_CheckPredicate, 38, // 8318: check predicate 38 |
| 7827 | OPC_Decode, 226, 22, 239, 2, // 8320: decode to SUBQ_PH using decoder 367 |
| 7828 | // 8320: } |
| 7829 | 12, 7, // 8325: case 0xc: { |
| 7830 | OPC_CheckPredicate, 72, // 8327: check predicate 72 |
| 7831 | OPC_Decode, 217, 6, 239, 2, // 8329: decode to ADDU_S_PH using decoder 367 |
| 7832 | // 8329: } |
| 7833 | 13, 7, // 8334: case 0xd: { |
| 7834 | OPC_CheckPredicate, 72, // 8336: check predicate 72 |
| 7835 | OPC_Decode, 131, 23, 239, 2, // 8338: decode to SUBU_S_PH using decoder 367 |
| 7836 | // 8338: } |
| 7837 | 14, 7, // 8343: case 0xe: { |
| 7838 | OPC_CheckPredicate, 38, // 8345: check predicate 38 |
| 7839 | OPC_Decode, 187, 6, 239, 2, // 8347: decode to ADDQ_S_PH using decoder 367 |
| 7840 | // 8347: } |
| 7841 | 15, 7, // 8352: case 0xf: { |
| 7842 | OPC_CheckPredicate, 38, // 8354: check predicate 38 |
| 7843 | OPC_Decode, 228, 22, 239, 2, // 8356: decode to SUBQ_S_PH using decoder 367 |
| 7844 | // 8356: } |
| 7845 | 16, 6, // 8361: case 0x10: { |
| 7846 | OPC_CheckPredicate, 38, // 8363: check predicate 38 |
| 7847 | OPC_Decode, 192, 6, 104, // 8365: decode to ADDSC using decoder 104 |
| 7848 | // 8365: } |
| 7849 | 17, 6, // 8369: case 0x11: { |
| 7850 | OPC_CheckPredicate, 38, // 8371: check predicate 38 |
| 7851 | OPC_Decode, 229, 6, 104, // 8373: decode to ADDWC using decoder 104 |
| 7852 | // 8373: } |
| 7853 | 18, 6, // 8377: case 0x12: { |
| 7854 | OPC_CheckPredicate, 38, // 8379: check predicate 38 |
| 7855 | OPC_Decode, 219, 17, 104, // 8381: decode to MODSUB using decoder 104 |
| 7856 | // 8381: } |
| 7857 | 20, 11, // 8385: case 0x14: { |
| 7858 | OPC_CheckPredicate, 38, // 8387: check predicate 38 |
| 7859 | OPC_CheckField, 16, 5, 0, // 8389: check Inst[20:16] == 0x0 |
| 7860 | OPC_Decode, 148, 20, 240, 2, // 8393: decode to RADDU_W_QB using decoder 368 |
| 7861 | // 8393: } |
| 7862 | 22, 6, // 8398: case 0x16: { |
| 7863 | OPC_CheckPredicate, 38, // 8400: check predicate 38 |
| 7864 | OPC_Decode, 189, 6, 104, // 8402: decode to ADDQ_S_W using decoder 104 |
| 7865 | // 8402: } |
| 7866 | 23, 6, // 8406: case 0x17: { |
| 7867 | OPC_CheckPredicate, 38, // 8408: check predicate 38 |
| 7868 | OPC_Decode, 230, 22, 104, // 8410: decode to SUBQ_S_W using decoder 104 |
| 7869 | // 8410: } |
| 7870 | 28, 7, // 8414: case 0x1c: { |
| 7871 | OPC_CheckPredicate, 38, // 8416: check predicate 38 |
| 7872 | OPC_Decode, 231, 18, 241, 2, // 8418: decode to MULEQ_S_W_PHL using decoder 369 |
| 7873 | // 8418: } |
| 7874 | 29, 7, // 8423: case 0x1d: { |
| 7875 | OPC_CheckPredicate, 38, // 8425: check predicate 38 |
| 7876 | OPC_Decode, 233, 18, 241, 2, // 8427: decode to MULEQ_S_W_PHR using decoder 369 |
| 7877 | // 8427: } |
| 7878 | 30, 7, // 8432: case 0x1e: { |
| 7879 | OPC_CheckPredicate, 72, // 8434: check predicate 72 |
| 7880 | OPC_Decode, 243, 18, 239, 2, // 8436: decode to MULQ_S_PH using decoder 367 |
| 7881 | // 8436: } |
| 7882 | 31, 0, // 8441: case 0x1f: { |
| 7883 | OPC_CheckPredicate, 38, // 8443: check predicate 38 |
| 7884 | OPC_Decode, 239, 18, 239, 2, // 8445: decode to MULQ_RS_PH using decoder 367 |
| 7885 | // 8445: } |
| 7886 | // 8445: } // switch Inst[10:6] |
| 7887 | // 8445: } |
| 7888 | 17, 219, 1, // 8450: case 0x11: { |
| 7889 | OPC_SwitchField, 6, 5, // 8453: switch Inst[10:6] { |
| 7890 | 0, 10, // 8456: case 0x0: { |
| 7891 | OPC_CheckPredicate, 38, // 8458: check predicate 38 |
| 7892 | OPC_CheckField, 11, 5, 0, // 8460: check Inst[15:11] == 0x0 |
| 7893 | OPC_Decode, 240, 9, 122, // 8464: decode to CMPU_EQ_QB using decoder 122 |
| 7894 | // 8464: } |
| 7895 | 1, 10, // 8468: case 0x1: { |
| 7896 | OPC_CheckPredicate, 38, // 8470: check predicate 38 |
| 7897 | OPC_CheckField, 11, 5, 0, // 8472: check Inst[15:11] == 0x0 |
| 7898 | OPC_Decode, 244, 9, 122, // 8476: decode to CMPU_LT_QB using decoder 122 |
| 7899 | // 8476: } |
| 7900 | 2, 10, // 8480: case 0x2: { |
| 7901 | OPC_CheckPredicate, 38, // 8482: check predicate 38 |
| 7902 | OPC_CheckField, 11, 5, 0, // 8484: check Inst[15:11] == 0x0 |
| 7903 | OPC_Decode, 242, 9, 122, // 8488: decode to CMPU_LE_QB using decoder 122 |
| 7904 | // 8488: } |
| 7905 | 3, 7, // 8492: case 0x3: { |
| 7906 | OPC_CheckPredicate, 38, // 8494: check predicate 38 |
| 7907 | OPC_Decode, 224, 19, 239, 2, // 8496: decode to PICK_QB using decoder 367 |
| 7908 | // 8496: } |
| 7909 | 4, 7, // 8501: case 0x4: { |
| 7910 | OPC_CheckPredicate, 38, // 8503: check predicate 38 |
| 7911 | OPC_Decode, 234, 9, 241, 2, // 8505: decode to CMPGU_EQ_QB using decoder 369 |
| 7912 | // 8505: } |
| 7913 | 5, 7, // 8510: case 0x5: { |
| 7914 | OPC_CheckPredicate, 38, // 8512: check predicate 38 |
| 7915 | OPC_Decode, 238, 9, 241, 2, // 8514: decode to CMPGU_LT_QB using decoder 369 |
| 7916 | // 8514: } |
| 7917 | 6, 7, // 8519: case 0x6: { |
| 7918 | OPC_CheckPredicate, 38, // 8521: check predicate 38 |
| 7919 | OPC_Decode, 236, 9, 241, 2, // 8523: decode to CMPGU_LE_QB using decoder 369 |
| 7920 | // 8523: } |
| 7921 | 8, 10, // 8528: case 0x8: { |
| 7922 | OPC_CheckPredicate, 38, // 8530: check predicate 38 |
| 7923 | OPC_CheckField, 11, 5, 0, // 8532: check Inst[15:11] == 0x0 |
| 7924 | OPC_Decode, 250, 9, 122, // 8536: decode to CMP_EQ_PH using decoder 122 |
| 7925 | // 8536: } |
| 7926 | 9, 10, // 8540: case 0x9: { |
| 7927 | OPC_CheckPredicate, 38, // 8542: check predicate 38 |
| 7928 | OPC_CheckField, 11, 5, 0, // 8544: check Inst[15:11] == 0x0 |
| 7929 | OPC_Decode, 136, 10, 122, // 8548: decode to CMP_LT_PH using decoder 122 |
| 7930 | // 8548: } |
| 7931 | 10, 10, // 8552: case 0xa: { |
| 7932 | OPC_CheckPredicate, 38, // 8554: check predicate 38 |
| 7933 | OPC_CheckField, 11, 5, 0, // 8556: check Inst[15:11] == 0x0 |
| 7934 | OPC_Decode, 130, 10, 122, // 8560: decode to CMP_LE_PH using decoder 122 |
| 7935 | // 8560: } |
| 7936 | 11, 7, // 8564: case 0xb: { |
| 7937 | OPC_CheckPredicate, 38, // 8566: check predicate 38 |
| 7938 | OPC_Decode, 222, 19, 239, 2, // 8568: decode to PICK_PH using decoder 367 |
| 7939 | // 8568: } |
| 7940 | 12, 7, // 8573: case 0xc: { |
| 7941 | OPC_CheckPredicate, 38, // 8575: check predicate 38 |
| 7942 | OPC_Decode, 253, 19, 239, 2, // 8577: decode to PRECRQ_QB_PH using decoder 367 |
| 7943 | // 8577: } |
| 7944 | 13, 7, // 8582: case 0xd: { |
| 7945 | OPC_CheckPredicate, 72, // 8584: check predicate 72 |
| 7946 | OPC_Decode, 129, 20, 239, 2, // 8586: decode to PRECR_QB_PH using decoder 367 |
| 7947 | // 8586: } |
| 7948 | 14, 7, // 8591: case 0xe: { |
| 7949 | OPC_CheckPredicate, 38, // 8593: check predicate 38 |
| 7950 | OPC_Decode, 204, 19, 239, 2, // 8595: decode to PACKRL_PH using decoder 367 |
| 7951 | // 8595: } |
| 7952 | 15, 7, // 8600: case 0xf: { |
| 7953 | OPC_CheckPredicate, 38, // 8602: check predicate 38 |
| 7954 | OPC_Decode, 249, 19, 239, 2, // 8604: decode to PRECRQU_S_QB_PH using decoder 367 |
| 7955 | // 8604: } |
| 7956 | 20, 7, // 8609: case 0x14: { |
| 7957 | OPC_CheckPredicate, 38, // 8611: check predicate 38 |
| 7958 | OPC_Decode, 251, 19, 242, 2, // 8613: decode to PRECRQ_PH_W using decoder 370 |
| 7959 | // 8613: } |
| 7960 | 21, 7, // 8618: case 0x15: { |
| 7961 | OPC_CheckPredicate, 38, // 8620: check predicate 38 |
| 7962 | OPC_Decode, 255, 19, 242, 2, // 8622: decode to PRECRQ_RS_PH_W using decoder 370 |
| 7963 | // 8622: } |
| 7964 | 24, 7, // 8627: case 0x18: { |
| 7965 | OPC_CheckPredicate, 72, // 8629: check predicate 72 |
| 7966 | OPC_Decode, 228, 9, 241, 2, // 8631: decode to CMPGDU_EQ_QB using decoder 369 |
| 7967 | // 8631: } |
| 7968 | 25, 7, // 8636: case 0x19: { |
| 7969 | OPC_CheckPredicate, 72, // 8638: check predicate 72 |
| 7970 | OPC_Decode, 232, 9, 241, 2, // 8640: decode to CMPGDU_LT_QB using decoder 369 |
| 7971 | // 8640: } |
| 7972 | 26, 7, // 8645: case 0x1a: { |
| 7973 | OPC_CheckPredicate, 72, // 8647: check predicate 72 |
| 7974 | OPC_Decode, 230, 9, 241, 2, // 8649: decode to CMPGDU_LE_QB using decoder 369 |
| 7975 | // 8649: } |
| 7976 | 30, 7, // 8654: case 0x1e: { |
| 7977 | OPC_CheckPredicate, 72, // 8656: check predicate 72 |
| 7978 | OPC_Decode, 131, 20, 243, 2, // 8658: decode to PRECR_SRA_PH_W using decoder 371 |
| 7979 | // 8658: } |
| 7980 | 31, 0, // 8663: case 0x1f: { |
| 7981 | OPC_CheckPredicate, 72, // 8665: check predicate 72 |
| 7982 | OPC_Decode, 133, 20, 243, 2, // 8667: decode to PRECR_SRA_R_PH_W using decoder 371 |
| 7983 | // 8667: } |
| 7984 | // 8667: } // switch Inst[10:6] |
| 7985 | // 8667: } |
| 7986 | 18, 229, 1, // 8672: case 0x12: { |
| 7987 | OPC_SwitchField, 6, 5, // 8675: switch Inst[10:6] { |
| 7988 | 1, 11, // 8678: case 0x1: { |
| 7989 | OPC_CheckPredicate, 72, // 8680: check predicate 72 |
| 7990 | OPC_CheckField, 21, 5, 0, // 8682: check Inst[25:21] == 0x0 |
| 7991 | OPC_Decode, 153, 6, 244, 2, // 8686: decode to ABSQ_S_QB using decoder 372 |
| 7992 | // 8686: } |
| 7993 | 2, 7, // 8691: case 0x2: { |
| 7994 | OPC_CheckPredicate, 38, // 8693: check predicate 38 |
| 7995 | OPC_Decode, 171, 20, 245, 2, // 8695: decode to REPL_QB using decoder 373 |
| 7996 | // 8695: } |
| 7997 | 3, 11, // 8700: case 0x3: { |
| 7998 | OPC_CheckPredicate, 38, // 8702: check predicate 38 |
| 7999 | OPC_CheckField, 21, 5, 0, // 8704: check Inst[25:21] == 0x0 |
| 8000 | OPC_Decode, 167, 20, 246, 2, // 8708: decode to REPLV_QB using decoder 374 |
| 8001 | // 8708: } |
| 8002 | 4, 11, // 8713: case 0x4: { |
| 8003 | OPC_CheckPredicate, 38, // 8715: check predicate 38 |
| 8004 | OPC_CheckField, 21, 5, 0, // 8717: check Inst[25:21] == 0x0 |
| 8005 | OPC_Decode, 229, 19, 244, 2, // 8721: decode to PRECEQU_PH_QBL using decoder 372 |
| 8006 | // 8721: } |
| 8007 | 5, 11, // 8726: case 0x5: { |
| 8008 | OPC_CheckPredicate, 38, // 8728: check predicate 38 |
| 8009 | OPC_CheckField, 21, 5, 0, // 8730: check Inst[25:21] == 0x0 |
| 8010 | OPC_Decode, 233, 19, 244, 2, // 8734: decode to PRECEQU_PH_QBR using decoder 372 |
| 8011 | // 8734: } |
| 8012 | 6, 11, // 8739: case 0x6: { |
| 8013 | OPC_CheckPredicate, 38, // 8741: check predicate 38 |
| 8014 | OPC_CheckField, 21, 5, 0, // 8743: check Inst[25:21] == 0x0 |
| 8015 | OPC_Decode, 230, 19, 244, 2, // 8747: decode to PRECEQU_PH_QBLA using decoder 372 |
| 8016 | // 8747: } |
| 8017 | 7, 11, // 8752: case 0x7: { |
| 8018 | OPC_CheckPredicate, 38, // 8754: check predicate 38 |
| 8019 | OPC_CheckField, 21, 5, 0, // 8756: check Inst[25:21] == 0x0 |
| 8020 | OPC_Decode, 234, 19, 244, 2, // 8760: decode to PRECEQU_PH_QBRA using decoder 372 |
| 8021 | // 8760: } |
| 8022 | 9, 11, // 8765: case 0x9: { |
| 8023 | OPC_CheckPredicate, 38, // 8767: check predicate 38 |
| 8024 | OPC_CheckField, 21, 5, 0, // 8769: check Inst[25:21] == 0x0 |
| 8025 | OPC_Decode, 151, 6, 244, 2, // 8773: decode to ABSQ_S_PH using decoder 372 |
| 8026 | // 8773: } |
| 8027 | 10, 7, // 8778: case 0xa: { |
| 8028 | OPC_CheckPredicate, 38, // 8780: check predicate 38 |
| 8029 | OPC_Decode, 169, 20, 140, 1, // 8782: decode to REPL_PH using decoder 140 |
| 8030 | // 8782: } |
| 8031 | 11, 11, // 8787: case 0xb: { |
| 8032 | OPC_CheckPredicate, 38, // 8789: check predicate 38 |
| 8033 | OPC_CheckField, 21, 5, 0, // 8791: check Inst[25:21] == 0x0 |
| 8034 | OPC_Decode, 165, 20, 246, 2, // 8795: decode to REPLV_PH using decoder 374 |
| 8035 | // 8795: } |
| 8036 | 12, 11, // 8800: case 0xc: { |
| 8037 | OPC_CheckPredicate, 38, // 8802: check predicate 38 |
| 8038 | OPC_CheckField, 21, 5, 0, // 8804: check Inst[25:21] == 0x0 |
| 8039 | OPC_Decode, 237, 19, 247, 2, // 8808: decode to PRECEQ_W_PHL using decoder 375 |
| 8040 | // 8808: } |
| 8041 | 13, 11, // 8813: case 0xd: { |
| 8042 | OPC_CheckPredicate, 38, // 8815: check predicate 38 |
| 8043 | OPC_CheckField, 21, 5, 0, // 8817: check Inst[25:21] == 0x0 |
| 8044 | OPC_Decode, 239, 19, 247, 2, // 8821: decode to PRECEQ_W_PHR using decoder 375 |
| 8045 | // 8821: } |
| 8046 | 17, 11, // 8826: case 0x11: { |
| 8047 | OPC_CheckPredicate, 38, // 8828: check predicate 38 |
| 8048 | OPC_CheckField, 21, 5, 0, // 8830: check Inst[25:21] == 0x0 |
| 8049 | OPC_Decode, 155, 6, 248, 2, // 8834: decode to ABSQ_S_W using decoder 376 |
| 8050 | // 8834: } |
| 8051 | 27, 11, // 8839: case 0x1b: { |
| 8052 | OPC_CheckPredicate, 38, // 8841: check predicate 38 |
| 8053 | OPC_CheckField, 21, 5, 0, // 8843: check Inst[25:21] == 0x0 |
| 8054 | OPC_Decode, 162, 8, 248, 2, // 8847: decode to BITREV using decoder 376 |
| 8055 | // 8847: } |
| 8056 | 28, 11, // 8852: case 0x1c: { |
| 8057 | OPC_CheckPredicate, 38, // 8854: check predicate 38 |
| 8058 | OPC_CheckField, 21, 5, 0, // 8856: check Inst[25:21] == 0x0 |
| 8059 | OPC_Decode, 241, 19, 244, 2, // 8860: decode to PRECEU_PH_QBL using decoder 372 |
| 8060 | // 8860: } |
| 8061 | 29, 11, // 8865: case 0x1d: { |
| 8062 | OPC_CheckPredicate, 38, // 8867: check predicate 38 |
| 8063 | OPC_CheckField, 21, 5, 0, // 8869: check Inst[25:21] == 0x0 |
| 8064 | OPC_Decode, 245, 19, 244, 2, // 8873: decode to PRECEU_PH_QBR using decoder 372 |
| 8065 | // 8873: } |
| 8066 | 30, 11, // 8878: case 0x1e: { |
| 8067 | OPC_CheckPredicate, 38, // 8880: check predicate 38 |
| 8068 | OPC_CheckField, 21, 5, 0, // 8882: check Inst[25:21] == 0x0 |
| 8069 | OPC_Decode, 242, 19, 244, 2, // 8886: decode to PRECEU_PH_QBLA using decoder 372 |
| 8070 | // 8886: } |
| 8071 | 31, 0, // 8891: case 0x1f: { |
| 8072 | OPC_CheckPredicate, 38, // 8893: check predicate 38 |
| 8073 | OPC_CheckField, 21, 5, 0, // 8895: check Inst[25:21] == 0x0 |
| 8074 | OPC_Decode, 246, 19, 244, 2, // 8899: decode to PRECEU_PH_QBRA using decoder 372 |
| 8075 | // 8899: } |
| 8076 | // 8899: } // switch Inst[10:6] |
| 8077 | // 8899: } |
| 8078 | 19, 199, 1, // 8904: case 0x13: { |
| 8079 | OPC_SwitchField, 6, 5, // 8907: switch Inst[10:6] { |
| 8080 | 0, 7, // 8910: case 0x0: { |
| 8081 | OPC_CheckPredicate, 38, // 8912: check predicate 38 |
| 8082 | OPC_Decode, 193, 21, 249, 2, // 8914: decode to SHLL_QB using decoder 377 |
| 8083 | // 8914: } |
| 8084 | 1, 7, // 8919: case 0x1: { |
| 8085 | OPC_CheckPredicate, 38, // 8921: check predicate 38 |
| 8086 | OPC_Decode, 225, 21, 249, 2, // 8923: decode to SHRL_QB using decoder 377 |
| 8087 | // 8923: } |
| 8088 | 2, 7, // 8928: case 0x2: { |
| 8089 | OPC_CheckPredicate, 38, // 8930: check predicate 38 |
| 8090 | OPC_Decode, 185, 21, 250, 2, // 8932: decode to SHLLV_QB using decoder 378 |
| 8091 | // 8932: } |
| 8092 | 3, 7, // 8937: case 0x3: { |
| 8093 | OPC_CheckPredicate, 38, // 8939: check predicate 38 |
| 8094 | OPC_Decode, 221, 21, 250, 2, // 8941: decode to SHRLV_QB using decoder 378 |
| 8095 | // 8941: } |
| 8096 | 4, 7, // 8946: case 0x4: { |
| 8097 | OPC_CheckPredicate, 72, // 8948: check predicate 72 |
| 8098 | OPC_Decode, 211, 21, 249, 2, // 8950: decode to SHRA_QB using decoder 377 |
| 8099 | // 8950: } |
| 8100 | 5, 7, // 8955: case 0x5: { |
| 8101 | OPC_CheckPredicate, 72, // 8957: check predicate 72 |
| 8102 | OPC_Decode, 215, 21, 249, 2, // 8959: decode to SHRA_R_QB using decoder 377 |
| 8103 | // 8959: } |
| 8104 | 6, 7, // 8964: case 0x6: { |
| 8105 | OPC_CheckPredicate, 72, // 8966: check predicate 72 |
| 8106 | OPC_Decode, 201, 21, 250, 2, // 8968: decode to SHRAV_QB using decoder 378 |
| 8107 | // 8968: } |
| 8108 | 7, 7, // 8973: case 0x7: { |
| 8109 | OPC_CheckPredicate, 72, // 8975: check predicate 72 |
| 8110 | OPC_Decode, 205, 21, 250, 2, // 8977: decode to SHRAV_R_QB using decoder 378 |
| 8111 | // 8977: } |
| 8112 | 8, 7, // 8982: case 0x8: { |
| 8113 | OPC_CheckPredicate, 38, // 8984: check predicate 38 |
| 8114 | OPC_Decode, 191, 21, 249, 2, // 8986: decode to SHLL_PH using decoder 377 |
| 8115 | // 8986: } |
| 8116 | 9, 7, // 8991: case 0x9: { |
| 8117 | OPC_CheckPredicate, 38, // 8993: check predicate 38 |
| 8118 | OPC_Decode, 209, 21, 249, 2, // 8995: decode to SHRA_PH using decoder 377 |
| 8119 | // 8995: } |
| 8120 | 10, 7, // 9000: case 0xa: { |
| 8121 | OPC_CheckPredicate, 38, // 9002: check predicate 38 |
| 8122 | OPC_Decode, 183, 21, 250, 2, // 9004: decode to SHLLV_PH using decoder 378 |
| 8123 | // 9004: } |
| 8124 | 11, 7, // 9009: case 0xb: { |
| 8125 | OPC_CheckPredicate, 38, // 9011: check predicate 38 |
| 8126 | OPC_Decode, 199, 21, 250, 2, // 9013: decode to SHRAV_PH using decoder 378 |
| 8127 | // 9013: } |
| 8128 | 12, 7, // 9018: case 0xc: { |
| 8129 | OPC_CheckPredicate, 38, // 9020: check predicate 38 |
| 8130 | OPC_Decode, 195, 21, 249, 2, // 9022: decode to SHLL_S_PH using decoder 377 |
| 8131 | // 9022: } |
| 8132 | 13, 7, // 9027: case 0xd: { |
| 8133 | OPC_CheckPredicate, 38, // 9029: check predicate 38 |
| 8134 | OPC_Decode, 213, 21, 249, 2, // 9031: decode to SHRA_R_PH using decoder 377 |
| 8135 | // 9031: } |
| 8136 | 14, 7, // 9036: case 0xe: { |
| 8137 | OPC_CheckPredicate, 38, // 9038: check predicate 38 |
| 8138 | OPC_Decode, 187, 21, 250, 2, // 9040: decode to SHLLV_S_PH using decoder 378 |
| 8139 | // 9040: } |
| 8140 | 15, 7, // 9045: case 0xf: { |
| 8141 | OPC_CheckPredicate, 38, // 9047: check predicate 38 |
| 8142 | OPC_Decode, 203, 21, 250, 2, // 9049: decode to SHRAV_R_PH using decoder 378 |
| 8143 | // 9049: } |
| 8144 | 20, 7, // 9054: case 0x14: { |
| 8145 | OPC_CheckPredicate, 38, // 9056: check predicate 38 |
| 8146 | OPC_Decode, 197, 21, 251, 2, // 9058: decode to SHLL_S_W using decoder 379 |
| 8147 | // 9058: } |
| 8148 | 21, 7, // 9063: case 0x15: { |
| 8149 | OPC_CheckPredicate, 38, // 9065: check predicate 38 |
| 8150 | OPC_Decode, 217, 21, 251, 2, // 9067: decode to SHRA_R_W using decoder 379 |
| 8151 | // 9067: } |
| 8152 | 22, 6, // 9072: case 0x16: { |
| 8153 | OPC_CheckPredicate, 38, // 9074: check predicate 38 |
| 8154 | OPC_Decode, 189, 21, 98, // 9076: decode to SHLLV_S_W using decoder 98 |
| 8155 | // 9076: } |
| 8156 | 23, 6, // 9080: case 0x17: { |
| 8157 | OPC_CheckPredicate, 38, // 9082: check predicate 38 |
| 8158 | OPC_Decode, 207, 21, 98, // 9084: decode to SHRAV_R_W using decoder 98 |
| 8159 | // 9084: } |
| 8160 | 25, 7, // 9088: case 0x19: { |
| 8161 | OPC_CheckPredicate, 72, // 9090: check predicate 72 |
| 8162 | OPC_Decode, 223, 21, 249, 2, // 9092: decode to SHRL_PH using decoder 377 |
| 8163 | // 9092: } |
| 8164 | 27, 0, // 9097: case 0x1b: { |
| 8165 | OPC_CheckPredicate, 72, // 9099: check predicate 72 |
| 8166 | OPC_Decode, 219, 21, 250, 2, // 9101: decode to SHRLV_PH using decoder 378 |
| 8167 | // 9101: } |
| 8168 | // 9101: } // switch Inst[10:6] |
| 8169 | // 9101: } |
| 8170 | 24, 141, 1, // 9106: case 0x18: { |
| 8171 | OPC_SwitchField, 6, 5, // 9109: switch Inst[10:6] { |
| 8172 | 0, 7, // 9112: case 0x0: { |
| 8173 | OPC_CheckPredicate, 72, // 9114: check predicate 72 |
| 8174 | OPC_Decode, 208, 6, 239, 2, // 9116: decode to ADDUH_QB using decoder 367 |
| 8175 | // 9116: } |
| 8176 | 1, 7, // 9121: case 0x1: { |
| 8177 | OPC_CheckPredicate, 72, // 9123: check predicate 72 |
| 8178 | OPC_Decode, 250, 22, 239, 2, // 9125: decode to SUBUH_QB using decoder 367 |
| 8179 | // 9125: } |
| 8180 | 2, 7, // 9130: case 0x2: { |
| 8181 | OPC_CheckPredicate, 72, // 9132: check predicate 72 |
| 8182 | OPC_Decode, 210, 6, 239, 2, // 9134: decode to ADDUH_R_QB using decoder 367 |
| 8183 | // 9134: } |
| 8184 | 3, 7, // 9139: case 0x3: { |
| 8185 | OPC_CheckPredicate, 72, // 9141: check predicate 72 |
| 8186 | OPC_Decode, 252, 22, 239, 2, // 9143: decode to SUBUH_R_QB using decoder 367 |
| 8187 | // 9143: } |
| 8188 | 8, 7, // 9148: case 0x8: { |
| 8189 | OPC_CheckPredicate, 72, // 9150: check predicate 72 |
| 8190 | OPC_Decode, 177, 6, 239, 2, // 9152: decode to ADDQH_PH using decoder 367 |
| 8191 | // 9152: } |
| 8192 | 9, 7, // 9157: case 0x9: { |
| 8193 | OPC_CheckPredicate, 72, // 9159: check predicate 72 |
| 8194 | OPC_Decode, 218, 22, 239, 2, // 9161: decode to SUBQH_PH using decoder 367 |
| 8195 | // 9161: } |
| 8196 | 10, 7, // 9166: case 0xa: { |
| 8197 | OPC_CheckPredicate, 72, // 9168: check predicate 72 |
| 8198 | OPC_Decode, 179, 6, 239, 2, // 9170: decode to ADDQH_R_PH using decoder 367 |
| 8199 | // 9170: } |
| 8200 | 11, 7, // 9175: case 0xb: { |
| 8201 | OPC_CheckPredicate, 72, // 9177: check predicate 72 |
| 8202 | OPC_Decode, 220, 22, 239, 2, // 9179: decode to SUBQH_R_PH using decoder 367 |
| 8203 | // 9179: } |
| 8204 | 12, 7, // 9184: case 0xc: { |
| 8205 | OPC_CheckPredicate, 72, // 9186: check predicate 72 |
| 8206 | OPC_Decode, 144, 19, 239, 2, // 9188: decode to MUL_PH using decoder 367 |
| 8207 | // 9188: } |
| 8208 | 14, 7, // 9193: case 0xe: { |
| 8209 | OPC_CheckPredicate, 72, // 9195: check predicate 72 |
| 8210 | OPC_Decode, 149, 19, 239, 2, // 9197: decode to MUL_S_PH using decoder 367 |
| 8211 | // 9197: } |
| 8212 | 16, 6, // 9202: case 0x10: { |
| 8213 | OPC_CheckPredicate, 72, // 9204: check predicate 72 |
| 8214 | OPC_Decode, 183, 6, 104, // 9206: decode to ADDQH_W using decoder 104 |
| 8215 | // 9206: } |
| 8216 | 17, 6, // 9210: case 0x11: { |
| 8217 | OPC_CheckPredicate, 72, // 9212: check predicate 72 |
| 8218 | OPC_Decode, 224, 22, 104, // 9214: decode to SUBQH_W using decoder 104 |
| 8219 | // 9214: } |
| 8220 | 18, 6, // 9218: case 0x12: { |
| 8221 | OPC_CheckPredicate, 72, // 9220: check predicate 72 |
| 8222 | OPC_Decode, 181, 6, 104, // 9222: decode to ADDQH_R_W using decoder 104 |
| 8223 | // 9222: } |
| 8224 | 19, 6, // 9226: case 0x13: { |
| 8225 | OPC_CheckPredicate, 72, // 9228: check predicate 72 |
| 8226 | OPC_Decode, 222, 22, 104, // 9230: decode to SUBQH_R_W using decoder 104 |
| 8227 | // 9230: } |
| 8228 | 22, 6, // 9234: case 0x16: { |
| 8229 | OPC_CheckPredicate, 72, // 9236: check predicate 72 |
| 8230 | OPC_Decode, 245, 18, 104, // 9238: decode to MULQ_S_W using decoder 104 |
| 8231 | // 9238: } |
| 8232 | 23, 0, // 9242: case 0x17: { |
| 8233 | OPC_CheckPredicate, 72, // 9244: check predicate 72 |
| 8234 | OPC_Decode, 241, 18, 104, // 9246: decode to MULQ_RS_W using decoder 104 |
| 8235 | // 9246: } |
| 8236 | // 9246: } // switch Inst[10:6] |
| 8237 | // 9246: } |
| 8238 | 25, 11, // 9250: case 0x19: { |
| 8239 | OPC_CheckPredicate, 73, // 9252: check predicate 73 |
| 8240 | OPC_CheckField, 6, 1, 0, // 9254: check Inst[6] == 0x0 |
| 8241 | OPC_Decode, 179, 16, 252, 2, // 9258: decode to LWLE using decoder 380 |
| 8242 | // 9258: } |
| 8243 | 26, 11, // 9263: case 0x1a: { |
| 8244 | OPC_CheckPredicate, 73, // 9265: check predicate 73 |
| 8245 | OPC_CheckField, 6, 1, 0, // 9267: check Inst[6] == 0x0 |
| 8246 | OPC_Decode, 192, 16, 252, 2, // 9271: decode to LWRE using decoder 380 |
| 8247 | // 9271: } |
| 8248 | 27, 11, // 9276: case 0x1b: { |
| 8249 | OPC_CheckPredicate, 45, // 9278: check predicate 45 |
| 8250 | OPC_CheckField, 6, 1, 0, // 9280: check Inst[6] == 0x0 |
| 8251 | OPC_Decode, 149, 9, 253, 2, // 9284: decode to CACHEE using decoder 381 |
| 8252 | // 9284: } |
| 8253 | 28, 11, // 9289: case 0x1c: { |
| 8254 | OPC_CheckPredicate, 45, // 9291: check predicate 45 |
| 8255 | OPC_CheckField, 6, 1, 0, // 9293: check Inst[6] == 0x0 |
| 8256 | OPC_Decode, 223, 20, 254, 2, // 9297: decode to SBE using decoder 382 |
| 8257 | // 9297: } |
| 8258 | 29, 11, // 9302: case 0x1d: { |
| 8259 | OPC_CheckPredicate, 45, // 9304: check predicate 45 |
| 8260 | OPC_CheckField, 6, 1, 0, // 9306: check Inst[6] == 0x0 |
| 8261 | OPC_Decode, 173, 21, 254, 2, // 9310: decode to SHE using decoder 382 |
| 8262 | // 9310: } |
| 8263 | 30, 11, // 9315: case 0x1e: { |
| 8264 | OPC_CheckPredicate, 45, // 9317: check predicate 45 |
| 8265 | OPC_CheckField, 6, 1, 0, // 9319: check Inst[6] == 0x0 |
| 8266 | OPC_Decode, 236, 20, 255, 2, // 9323: decode to SCE using decoder 383 |
| 8267 | // 9323: } |
| 8268 | 31, 11, // 9328: case 0x1f: { |
| 8269 | OPC_CheckPredicate, 45, // 9330: check predicate 45 |
| 8270 | OPC_CheckField, 6, 1, 0, // 9332: check Inst[6] == 0x0 |
| 8271 | OPC_Decode, 167, 23, 254, 2, // 9336: decode to SWE using decoder 382 |
| 8272 | // 9336: } |
| 8273 | 32, 42, // 9341: case 0x20: { |
| 8274 | OPC_SwitchField, 6, 5, // 9343: switch Inst[10:6] { |
| 8275 | 2, 11, // 9346: case 0x2: { |
| 8276 | OPC_CheckPredicate, 29, // 9348: check predicate 29 |
| 8277 | OPC_CheckField, 21, 5, 0, // 9350: check Inst[25:21] == 0x0 |
| 8278 | OPC_Decode, 188, 24, 248, 2, // 9354: decode to WSBH using decoder 376 |
| 8279 | // 9354: } |
| 8280 | 16, 11, // 9359: case 0x10: { |
| 8281 | OPC_CheckPredicate, 29, // 9361: check predicate 29 |
| 8282 | OPC_CheckField, 21, 5, 0, // 9363: check Inst[25:21] == 0x0 |
| 8283 | OPC_Decode, 139, 21, 248, 2, // 9367: decode to SEB using decoder 376 |
| 8284 | // 9367: } |
| 8285 | 24, 0, // 9372: case 0x18: { |
| 8286 | OPC_CheckPredicate, 29, // 9374: check predicate 29 |
| 8287 | OPC_CheckField, 21, 5, 0, // 9376: check Inst[25:21] == 0x0 |
| 8288 | OPC_Decode, 143, 21, 248, 2, // 9380: decode to SEH using decoder 376 |
| 8289 | // 9380: } |
| 8290 | // 9380: } // switch Inst[10:6] |
| 8291 | // 9380: } |
| 8292 | 33, 11, // 9385: case 0x21: { |
| 8293 | OPC_CheckPredicate, 73, // 9387: check predicate 73 |
| 8294 | OPC_CheckField, 6, 1, 0, // 9389: check Inst[6] == 0x0 |
| 8295 | OPC_Decode, 173, 23, 254, 2, // 9393: decode to SWLE using decoder 382 |
| 8296 | // 9393: } |
| 8297 | 34, 11, // 9398: case 0x22: { |
| 8298 | OPC_CheckPredicate, 73, // 9400: check predicate 73 |
| 8299 | OPC_CheckField, 6, 1, 0, // 9402: check Inst[6] == 0x0 |
| 8300 | OPC_Decode, 184, 23, 254, 2, // 9406: decode to SWRE using decoder 382 |
| 8301 | // 9406: } |
| 8302 | 35, 11, // 9411: case 0x23: { |
| 8303 | OPC_CheckPredicate, 45, // 9413: check predicate 45 |
| 8304 | OPC_CheckField, 6, 1, 0, // 9415: check Inst[6] == 0x0 |
| 8305 | OPC_Decode, 136, 20, 253, 2, // 9419: decode to PREFE using decoder 381 |
| 8306 | // 9419: } |
| 8307 | 40, 11, // 9424: case 0x28: { |
| 8308 | OPC_CheckPredicate, 45, // 9426: check predicate 45 |
| 8309 | OPC_CheckField, 6, 1, 0, // 9428: check Inst[6] == 0x0 |
| 8310 | OPC_Decode, 205, 15, 254, 2, // 9432: decode to LBuE using decoder 382 |
| 8311 | // 9432: } |
| 8312 | 41, 11, // 9437: case 0x29: { |
| 8313 | OPC_CheckPredicate, 45, // 9439: check predicate 45 |
| 8314 | OPC_CheckField, 6, 1, 0, // 9441: check Inst[6] == 0x0 |
| 8315 | OPC_Decode, 128, 16, 254, 2, // 9445: decode to LHuE using decoder 382 |
| 8316 | // 9445: } |
| 8317 | 44, 11, // 9450: case 0x2c: { |
| 8318 | OPC_CheckPredicate, 45, // 9452: check predicate 45 |
| 8319 | OPC_CheckField, 6, 1, 0, // 9454: check Inst[6] == 0x0 |
| 8320 | OPC_Decode, 186, 15, 254, 2, // 9458: decode to LBE using decoder 382 |
| 8321 | // 9458: } |
| 8322 | 45, 11, // 9463: case 0x2d: { |
| 8323 | OPC_CheckPredicate, 45, // 9465: check predicate 45 |
| 8324 | OPC_CheckField, 6, 1, 0, // 9467: check Inst[6] == 0x0 |
| 8325 | OPC_Decode, 237, 15, 254, 2, // 9471: decode to LHE using decoder 382 |
| 8326 | // 9471: } |
| 8327 | 46, 11, // 9476: case 0x2e: { |
| 8328 | OPC_CheckPredicate, 45, // 9478: check predicate 45 |
| 8329 | OPC_CheckField, 6, 1, 0, // 9480: check Inst[6] == 0x0 |
| 8330 | OPC_Decode, 140, 16, 254, 2, // 9484: decode to LLE using decoder 382 |
| 8331 | // 9484: } |
| 8332 | 47, 11, // 9489: case 0x2f: { |
| 8333 | OPC_CheckPredicate, 45, // 9491: check predicate 45 |
| 8334 | OPC_CheckField, 6, 1, 0, // 9493: check Inst[6] == 0x0 |
| 8335 | OPC_Decode, 172, 16, 254, 2, // 9497: decode to LWE using decoder 382 |
| 8336 | // 9497: } |
| 8337 | 48, 161, 2, // 9502: case 0x30: { |
| 8338 | OPC_SwitchField, 6, 5, // 9505: switch Inst[10:6] { |
| 8339 | 0, 11, // 9508: case 0x0: { |
| 8340 | OPC_CheckPredicate, 72, // 9510: check predicate 72 |
| 8341 | OPC_CheckField, 13, 3, 0, // 9512: check Inst[15:13] == 0x0 |
| 8342 | OPC_Decode, 185, 12, 128, 3, // 9516: decode to DPA_W_PH using decoder 384 |
| 8343 | // 9516: } |
| 8344 | 1, 11, // 9521: case 0x1: { |
| 8345 | OPC_CheckPredicate, 72, // 9523: check predicate 72 |
| 8346 | OPC_CheckField, 13, 3, 0, // 9525: check Inst[15:13] == 0x0 |
| 8347 | OPC_Decode, 208, 12, 128, 3, // 9529: decode to DPS_W_PH using decoder 384 |
| 8348 | // 9529: } |
| 8349 | 2, 11, // 9534: case 0x2: { |
| 8350 | OPC_CheckPredicate, 72, // 9536: check predicate 72 |
| 8351 | OPC_CheckField, 13, 3, 0, // 9538: check Inst[15:13] == 0x0 |
| 8352 | OPC_Decode, 252, 18, 128, 3, // 9542: decode to MULSA_W_PH using decoder 384 |
| 8353 | // 9542: } |
| 8354 | 3, 11, // 9547: case 0x3: { |
| 8355 | OPC_CheckPredicate, 38, // 9549: check predicate 38 |
| 8356 | OPC_CheckField, 13, 3, 0, // 9551: check Inst[15:13] == 0x0 |
| 8357 | OPC_Decode, 179, 12, 128, 3, // 9555: decode to DPAU_H_QBL using decoder 384 |
| 8358 | // 9555: } |
| 8359 | 4, 11, // 9560: case 0x4: { |
| 8360 | OPC_CheckPredicate, 38, // 9562: check predicate 38 |
| 8361 | OPC_CheckField, 13, 3, 0, // 9564: check Inst[15:13] == 0x0 |
| 8362 | OPC_Decode, 177, 12, 128, 3, // 9568: decode to DPAQ_S_W_PH using decoder 384 |
| 8363 | // 9568: } |
| 8364 | 5, 11, // 9573: case 0x5: { |
| 8365 | OPC_CheckPredicate, 38, // 9575: check predicate 38 |
| 8366 | OPC_CheckField, 13, 3, 0, // 9577: check Inst[15:13] == 0x0 |
| 8367 | OPC_Decode, 194, 12, 128, 3, // 9581: decode to DPSQ_S_W_PH using decoder 384 |
| 8368 | // 9581: } |
| 8369 | 6, 11, // 9586: case 0x6: { |
| 8370 | OPC_CheckPredicate, 38, // 9588: check predicate 38 |
| 8371 | OPC_CheckField, 13, 3, 0, // 9590: check Inst[15:13] == 0x0 |
| 8372 | OPC_Decode, 250, 18, 128, 3, // 9594: decode to MULSAQ_S_W_PH using decoder 384 |
| 8373 | // 9594: } |
| 8374 | 7, 11, // 9599: case 0x7: { |
| 8375 | OPC_CheckPredicate, 38, // 9601: check predicate 38 |
| 8376 | OPC_CheckField, 13, 3, 0, // 9603: check Inst[15:13] == 0x0 |
| 8377 | OPC_Decode, 181, 12, 128, 3, // 9607: decode to DPAU_H_QBR using decoder 384 |
| 8378 | // 9607: } |
| 8379 | 8, 11, // 9612: case 0x8: { |
| 8380 | OPC_CheckPredicate, 72, // 9614: check predicate 72 |
| 8381 | OPC_CheckField, 13, 3, 0, // 9616: check Inst[15:13] == 0x0 |
| 8382 | OPC_Decode, 183, 12, 128, 3, // 9620: decode to DPAX_W_PH using decoder 384 |
| 8383 | // 9620: } |
| 8384 | 9, 11, // 9625: case 0x9: { |
| 8385 | OPC_CheckPredicate, 72, // 9627: check predicate 72 |
| 8386 | OPC_CheckField, 13, 3, 0, // 9629: check Inst[15:13] == 0x0 |
| 8387 | OPC_Decode, 206, 12, 128, 3, // 9633: decode to DPSX_W_PH using decoder 384 |
| 8388 | // 9633: } |
| 8389 | 11, 11, // 9638: case 0xb: { |
| 8390 | OPC_CheckPredicate, 38, // 9640: check predicate 38 |
| 8391 | OPC_CheckField, 13, 3, 0, // 9642: check Inst[15:13] == 0x0 |
| 8392 | OPC_Decode, 202, 12, 128, 3, // 9646: decode to DPSU_H_QBL using decoder 384 |
| 8393 | // 9646: } |
| 8394 | 12, 11, // 9651: case 0xc: { |
| 8395 | OPC_CheckPredicate, 38, // 9653: check predicate 38 |
| 8396 | OPC_CheckField, 13, 3, 0, // 9655: check Inst[15:13] == 0x0 |
| 8397 | OPC_Decode, 175, 12, 128, 3, // 9659: decode to DPAQ_SA_L_W using decoder 384 |
| 8398 | // 9659: } |
| 8399 | 13, 11, // 9664: case 0xd: { |
| 8400 | OPC_CheckPredicate, 38, // 9666: check predicate 38 |
| 8401 | OPC_CheckField, 13, 3, 0, // 9668: check Inst[15:13] == 0x0 |
| 8402 | OPC_Decode, 192, 12, 128, 3, // 9672: decode to DPSQ_SA_L_W using decoder 384 |
| 8403 | // 9672: } |
| 8404 | 15, 11, // 9677: case 0xf: { |
| 8405 | OPC_CheckPredicate, 38, // 9679: check predicate 38 |
| 8406 | OPC_CheckField, 13, 3, 0, // 9681: check Inst[15:13] == 0x0 |
| 8407 | OPC_Decode, 204, 12, 128, 3, // 9685: decode to DPSU_H_QBR using decoder 384 |
| 8408 | // 9685: } |
| 8409 | 16, 11, // 9690: case 0x10: { |
| 8410 | OPC_CheckPredicate, 38, // 9692: check predicate 38 |
| 8411 | OPC_CheckField, 13, 3, 0, // 9694: check Inst[15:13] == 0x0 |
| 8412 | OPC_Decode, 248, 16, 128, 3, // 9698: decode to MAQ_SA_W_PHL using decoder 384 |
| 8413 | // 9698: } |
| 8414 | 18, 11, // 9703: case 0x12: { |
| 8415 | OPC_CheckPredicate, 38, // 9705: check predicate 38 |
| 8416 | OPC_CheckField, 13, 3, 0, // 9707: check Inst[15:13] == 0x0 |
| 8417 | OPC_Decode, 250, 16, 128, 3, // 9711: decode to MAQ_SA_W_PHR using decoder 384 |
| 8418 | // 9711: } |
| 8419 | 20, 11, // 9716: case 0x14: { |
| 8420 | OPC_CheckPredicate, 38, // 9718: check predicate 38 |
| 8421 | OPC_CheckField, 13, 3, 0, // 9720: check Inst[15:13] == 0x0 |
| 8422 | OPC_Decode, 252, 16, 128, 3, // 9724: decode to MAQ_S_W_PHL using decoder 384 |
| 8423 | // 9724: } |
| 8424 | 22, 11, // 9729: case 0x16: { |
| 8425 | OPC_CheckPredicate, 38, // 9731: check predicate 38 |
| 8426 | OPC_CheckField, 13, 3, 0, // 9733: check Inst[15:13] == 0x0 |
| 8427 | OPC_Decode, 254, 16, 128, 3, // 9737: decode to MAQ_S_W_PHR using decoder 384 |
| 8428 | // 9737: } |
| 8429 | 24, 11, // 9742: case 0x18: { |
| 8430 | OPC_CheckPredicate, 72, // 9744: check predicate 72 |
| 8431 | OPC_CheckField, 13, 3, 0, // 9746: check Inst[15:13] == 0x0 |
| 8432 | OPC_Decode, 173, 12, 128, 3, // 9750: decode to DPAQX_S_W_PH using decoder 384 |
| 8433 | // 9750: } |
| 8434 | 25, 11, // 9755: case 0x19: { |
| 8435 | OPC_CheckPredicate, 72, // 9757: check predicate 72 |
| 8436 | OPC_CheckField, 13, 3, 0, // 9759: check Inst[15:13] == 0x0 |
| 8437 | OPC_Decode, 190, 12, 128, 3, // 9763: decode to DPSQX_S_W_PH using decoder 384 |
| 8438 | // 9763: } |
| 8439 | 26, 11, // 9768: case 0x1a: { |
| 8440 | OPC_CheckPredicate, 72, // 9770: check predicate 72 |
| 8441 | OPC_CheckField, 13, 3, 0, // 9772: check Inst[15:13] == 0x0 |
| 8442 | OPC_Decode, 171, 12, 128, 3, // 9776: decode to DPAQX_SA_W_PH using decoder 384 |
| 8443 | // 9776: } |
| 8444 | 27, 0, // 9781: case 0x1b: { |
| 8445 | OPC_CheckPredicate, 72, // 9783: check predicate 72 |
| 8446 | OPC_CheckField, 13, 3, 0, // 9785: check Inst[15:13] == 0x0 |
| 8447 | OPC_Decode, 188, 12, 128, 3, // 9789: decode to DPSQX_SA_W_PH using decoder 384 |
| 8448 | // 9789: } |
| 8449 | // 9789: } // switch Inst[10:6] |
| 8450 | // 9789: } |
| 8451 | 49, 30, // 9794: case 0x31: { |
| 8452 | OPC_SwitchField, 6, 5, // 9796: switch Inst[10:6] { |
| 8453 | 0, 7, // 9799: case 0x0: { |
| 8454 | OPC_CheckPredicate, 72, // 9801: check predicate 72 |
| 8455 | OPC_Decode, 142, 7, 129, 3, // 9803: decode to APPEND using decoder 385 |
| 8456 | // 9803: } |
| 8457 | 1, 7, // 9808: case 0x1: { |
| 8458 | OPC_CheckPredicate, 72, // 9810: check predicate 72 |
| 8459 | OPC_Decode, 144, 20, 129, 3, // 9812: decode to PREPEND using decoder 385 |
| 8460 | // 9812: } |
| 8461 | 16, 0, // 9817: case 0x10: { |
| 8462 | OPC_CheckPredicate, 72, // 9819: check predicate 72 |
| 8463 | OPC_Decode, 188, 7, 129, 3, // 9821: decode to BALIGN using decoder 385 |
| 8464 | // 9821: } |
| 8465 | // 9821: } // switch Inst[10:6] |
| 8466 | // 9821: } |
| 8467 | 56, 216, 1, // 9826: case 0x38: { |
| 8468 | OPC_SwitchField, 6, 5, // 9829: switch Inst[10:6] { |
| 8469 | 0, 11, // 9832: case 0x0: { |
| 8470 | OPC_CheckPredicate, 38, // 9834: check predicate 38 |
| 8471 | OPC_CheckField, 13, 3, 0, // 9836: check Inst[15:13] == 0x0 |
| 8472 | OPC_Decode, 150, 13, 130, 3, // 9840: decode to EXTR_W using decoder 386 |
| 8473 | // 9840: } |
| 8474 | 1, 11, // 9845: case 0x1: { |
| 8475 | OPC_CheckPredicate, 38, // 9847: check predicate 38 |
| 8476 | OPC_CheckField, 13, 3, 0, // 9849: check Inst[15:13] == 0x0 |
| 8477 | OPC_Decode, 142, 13, 131, 3, // 9853: decode to EXTRV_W using decoder 387 |
| 8478 | // 9853: } |
| 8479 | 2, 11, // 9858: case 0x2: { |
| 8480 | OPC_CheckPredicate, 38, // 9860: check predicate 38 |
| 8481 | OPC_CheckField, 13, 3, 0, // 9862: check Inst[15:13] == 0x0 |
| 8482 | OPC_Decode, 128, 13, 130, 3, // 9866: decode to EXTP using decoder 386 |
| 8483 | // 9866: } |
| 8484 | 3, 11, // 9871: case 0x3: { |
| 8485 | OPC_CheckPredicate, 38, // 9873: check predicate 38 |
| 8486 | OPC_CheckField, 13, 3, 0, // 9875: check Inst[15:13] == 0x0 |
| 8487 | OPC_Decode, 133, 13, 131, 3, // 9879: decode to EXTPV using decoder 387 |
| 8488 | // 9879: } |
| 8489 | 4, 11, // 9884: case 0x4: { |
| 8490 | OPC_CheckPredicate, 38, // 9886: check predicate 38 |
| 8491 | OPC_CheckField, 13, 3, 0, // 9888: check Inst[15:13] == 0x0 |
| 8492 | OPC_Decode, 146, 13, 130, 3, // 9892: decode to EXTR_R_W using decoder 386 |
| 8493 | // 9892: } |
| 8494 | 5, 11, // 9897: case 0x5: { |
| 8495 | OPC_CheckPredicate, 38, // 9899: check predicate 38 |
| 8496 | OPC_CheckField, 13, 3, 0, // 9901: check Inst[15:13] == 0x0 |
| 8497 | OPC_Decode, 138, 13, 131, 3, // 9905: decode to EXTRV_R_W using decoder 387 |
| 8498 | // 9905: } |
| 8499 | 6, 11, // 9910: case 0x6: { |
| 8500 | OPC_CheckPredicate, 38, // 9912: check predicate 38 |
| 8501 | OPC_CheckField, 13, 3, 0, // 9914: check Inst[15:13] == 0x0 |
| 8502 | OPC_Decode, 144, 13, 130, 3, // 9918: decode to EXTR_RS_W using decoder 386 |
| 8503 | // 9918: } |
| 8504 | 7, 11, // 9923: case 0x7: { |
| 8505 | OPC_CheckPredicate, 38, // 9925: check predicate 38 |
| 8506 | OPC_CheckField, 13, 3, 0, // 9927: check Inst[15:13] == 0x0 |
| 8507 | OPC_Decode, 136, 13, 131, 3, // 9931: decode to EXTRV_RS_W using decoder 387 |
| 8508 | // 9931: } |
| 8509 | 10, 11, // 9936: case 0xa: { |
| 8510 | OPC_CheckPredicate, 38, // 9938: check predicate 38 |
| 8511 | OPC_CheckField, 13, 3, 0, // 9940: check Inst[15:13] == 0x0 |
| 8512 | OPC_Decode, 129, 13, 130, 3, // 9944: decode to EXTPDP using decoder 386 |
| 8513 | // 9944: } |
| 8514 | 11, 11, // 9949: case 0xb: { |
| 8515 | OPC_CheckPredicate, 38, // 9951: check predicate 38 |
| 8516 | OPC_CheckField, 13, 3, 0, // 9953: check Inst[15:13] == 0x0 |
| 8517 | OPC_Decode, 130, 13, 131, 3, // 9957: decode to EXTPDPV using decoder 387 |
| 8518 | // 9957: } |
| 8519 | 14, 11, // 9962: case 0xe: { |
| 8520 | OPC_CheckPredicate, 38, // 9964: check predicate 38 |
| 8521 | OPC_CheckField, 13, 3, 0, // 9966: check Inst[15:13] == 0x0 |
| 8522 | OPC_Decode, 148, 13, 130, 3, // 9970: decode to EXTR_S_H using decoder 386 |
| 8523 | // 9970: } |
| 8524 | 15, 11, // 9975: case 0xf: { |
| 8525 | OPC_CheckPredicate, 38, // 9977: check predicate 38 |
| 8526 | OPC_CheckField, 13, 3, 0, // 9979: check Inst[15:13] == 0x0 |
| 8527 | OPC_Decode, 140, 13, 131, 3, // 9983: decode to EXTRV_S_H using decoder 387 |
| 8528 | // 9983: } |
| 8529 | 18, 7, // 9988: case 0x12: { |
| 8530 | OPC_CheckPredicate, 38, // 9990: check predicate 38 |
| 8531 | OPC_Decode, 150, 20, 132, 3, // 9992: decode to RDDSP using decoder 388 |
| 8532 | // 9992: } |
| 8533 | 19, 7, // 9997: case 0x13: { |
| 8534 | OPC_CheckPredicate, 41, // 9999: check predicate 41 |
| 8535 | OPC_Decode, 184, 24, 133, 3, // 10001: decode to WRDSP using decoder 389 |
| 8536 | // 10001: } |
| 8537 | 26, 11, // 10006: case 0x1a: { |
| 8538 | OPC_CheckPredicate, 38, // 10008: check predicate 38 |
| 8539 | OPC_CheckField, 13, 7, 0, // 10010: check Inst[19:13] == 0x0 |
| 8540 | OPC_Decode, 179, 21, 134, 3, // 10014: decode to SHILO using decoder 390 |
| 8541 | // 10014: } |
| 8542 | 27, 11, // 10019: case 0x1b: { |
| 8543 | OPC_CheckPredicate, 38, // 10021: check predicate 38 |
| 8544 | OPC_CheckField, 13, 8, 0, // 10023: check Inst[20:13] == 0x0 |
| 8545 | OPC_Decode, 180, 21, 135, 3, // 10027: decode to SHILOV using decoder 391 |
| 8546 | // 10027: } |
| 8547 | 31, 0, // 10032: case 0x1f: { |
| 8548 | OPC_CheckPredicate, 38, // 10034: check predicate 38 |
| 8549 | OPC_CheckField, 13, 8, 0, // 10036: check Inst[20:13] == 0x0 |
| 8550 | OPC_Decode, 209, 18, 135, 3, // 10040: decode to MTHLIP using decoder 391 |
| 8551 | // 10040: } |
| 8552 | // 10040: } // switch Inst[10:6] |
| 8553 | // 10040: } |
| 8554 | 59, 0, // 10045: case 0x3b: { |
| 8555 | OPC_CheckPredicate, 28, // 10047: check predicate 28 |
| 8556 | OPC_CheckField, 21, 5, 0, // 10049: check Inst[25:21] == 0x0 |
| 8557 | OPC_CheckField, 9, 2, 0, // 10053: check Inst[10:9] == 0x0 |
| 8558 | OPC_Decode, 152, 20, 136, 3, // 10057: decode to RDHWR using decoder 392 |
| 8559 | // 10057: } |
| 8560 | // 10057: } // switch Inst[5:0] |
| 8561 | // 10057: } |
| 8562 | 32, 7, // 10062: case 0x20: { |
| 8563 | OPC_CheckPredicate, 28, // 10064: check predicate 28 |
| 8564 | OPC_Decode, 183, 15, 137, 3, // 10066: decode to LB using decoder 393 |
| 8565 | // 10066: } |
| 8566 | 33, 7, // 10071: case 0x21: { |
| 8567 | OPC_CheckPredicate, 28, // 10073: check predicate 28 |
| 8568 | OPC_Decode, 234, 15, 137, 3, // 10075: decode to LH using decoder 393 |
| 8569 | // 10075: } |
| 8570 | 34, 7, // 10080: case 0x22: { |
| 8571 | OPC_CheckPredicate, 32, // 10082: check predicate 32 |
| 8572 | OPC_Decode, 177, 16, 138, 3, // 10084: decode to LWL using decoder 394 |
| 8573 | // 10084: } |
| 8574 | 35, 7, // 10089: case 0x23: { |
| 8575 | OPC_CheckPredicate, 28, // 10091: check predicate 28 |
| 8576 | OPC_Decode, 159, 16, 137, 3, // 10093: decode to LW using decoder 393 |
| 8577 | // 10093: } |
| 8578 | 36, 7, // 10098: case 0x24: { |
| 8579 | OPC_CheckPredicate, 28, // 10100: check predicate 28 |
| 8580 | OPC_Decode, 203, 15, 137, 3, // 10102: decode to LBu using decoder 393 |
| 8581 | // 10102: } |
| 8582 | 37, 7, // 10107: case 0x25: { |
| 8583 | OPC_CheckPredicate, 28, // 10109: check predicate 28 |
| 8584 | OPC_Decode, 254, 15, 137, 3, // 10111: decode to LHu using decoder 393 |
| 8585 | // 10111: } |
| 8586 | 38, 7, // 10116: case 0x26: { |
| 8587 | OPC_CheckPredicate, 32, // 10118: check predicate 32 |
| 8588 | OPC_Decode, 190, 16, 138, 3, // 10120: decode to LWR using decoder 394 |
| 8589 | // 10120: } |
| 8590 | 40, 7, // 10125: case 0x28: { |
| 8591 | OPC_CheckPredicate, 28, // 10127: check predicate 28 |
| 8592 | OPC_Decode, 218, 20, 137, 3, // 10129: decode to SB using decoder 393 |
| 8593 | // 10129: } |
| 8594 | 41, 7, // 10134: case 0x29: { |
| 8595 | OPC_CheckPredicate, 28, // 10136: check predicate 28 |
| 8596 | OPC_Decode, 168, 21, 137, 3, // 10138: decode to SH using decoder 393 |
| 8597 | // 10138: } |
| 8598 | 42, 7, // 10143: case 0x2a: { |
| 8599 | OPC_CheckPredicate, 32, // 10145: check predicate 32 |
| 8600 | OPC_Decode, 171, 23, 137, 3, // 10147: decode to SWL using decoder 393 |
| 8601 | // 10147: } |
| 8602 | 43, 7, // 10152: case 0x2b: { |
| 8603 | OPC_CheckPredicate, 28, // 10154: check predicate 28 |
| 8604 | OPC_Decode, 153, 23, 137, 3, // 10156: decode to SW using decoder 393 |
| 8605 | // 10156: } |
| 8606 | 46, 7, // 10161: case 0x2e: { |
| 8607 | OPC_CheckPredicate, 32, // 10163: check predicate 32 |
| 8608 | OPC_Decode, 182, 23, 137, 3, // 10165: decode to SWR using decoder 393 |
| 8609 | // 10165: } |
| 8610 | 47, 7, // 10170: case 0x2f: { |
| 8611 | OPC_CheckPredicate, 74, // 10172: check predicate 74 |
| 8612 | OPC_Decode, 148, 9, 139, 3, // 10174: decode to CACHE using decoder 395 |
| 8613 | // 10174: } |
| 8614 | 48, 7, // 10179: case 0x30: { |
| 8615 | OPC_CheckPredicate, 75, // 10181: check predicate 75 |
| 8616 | OPC_Decode, 135, 16, 137, 3, // 10183: decode to LL using decoder 393 |
| 8617 | // 10183: } |
| 8618 | 49, 7, // 10188: case 0x31: { |
| 8619 | OPC_CheckPredicate, 48, // 10190: check predicate 48 |
| 8620 | OPC_Decode, 164, 16, 140, 3, // 10192: decode to LWC1 using decoder 396 |
| 8621 | // 10192: } |
| 8622 | 50, 7, // 10197: case 0x32: { |
| 8623 | OPC_CheckPredicate, 32, // 10199: check predicate 32 |
| 8624 | OPC_Decode, 166, 16, 141, 3, // 10201: decode to LWC2 using decoder 397 |
| 8625 | // 10201: } |
| 8626 | 51, 7, // 10206: case 0x33: { |
| 8627 | OPC_CheckPredicate, 74, // 10208: check predicate 74 |
| 8628 | OPC_Decode, 135, 20, 139, 3, // 10210: decode to PREF using decoder 395 |
| 8629 | // 10210: } |
| 8630 | 53, 7, // 10215: case 0x35: { |
| 8631 | OPC_CheckPredicate, 60, // 10217: check predicate 60 |
| 8632 | OPC_Decode, 209, 15, 142, 3, // 10219: decode to LDC1 using decoder 398 |
| 8633 | // 10219: } |
| 8634 | 54, 7, // 10224: case 0x36: { |
| 8635 | OPC_CheckPredicate, 40, // 10226: check predicate 40 |
| 8636 | OPC_Decode, 214, 15, 141, 3, // 10228: decode to LDC2 using decoder 397 |
| 8637 | // 10228: } |
| 8638 | 56, 7, // 10233: case 0x38: { |
| 8639 | OPC_CheckPredicate, 75, // 10235: check predicate 75 |
| 8640 | OPC_Decode, 231, 20, 143, 3, // 10237: decode to SC using decoder 399 |
| 8641 | // 10237: } |
| 8642 | 57, 7, // 10242: case 0x39: { |
| 8643 | OPC_CheckPredicate, 48, // 10244: check predicate 48 |
| 8644 | OPC_Decode, 159, 23, 140, 3, // 10246: decode to SWC1 using decoder 396 |
| 8645 | // 10246: } |
| 8646 | 58, 7, // 10251: case 0x3a: { |
| 8647 | OPC_CheckPredicate, 32, // 10253: check predicate 32 |
| 8648 | OPC_Decode, 161, 23, 141, 3, // 10255: decode to SWC2 using decoder 397 |
| 8649 | // 10255: } |
| 8650 | 61, 7, // 10260: case 0x3d: { |
| 8651 | OPC_CheckPredicate, 60, // 10262: check predicate 60 |
| 8652 | OPC_Decode, 252, 20, 142, 3, // 10264: decode to SDC1 using decoder 398 |
| 8653 | // 10264: } |
| 8654 | 62, 0, // 10269: case 0x3e: { |
| 8655 | OPC_CheckPredicate, 40, // 10271: check predicate 40 |
| 8656 | OPC_Decode, 129, 21, 141, 3, // 10273: decode to SDC2 using decoder 397 |
| 8657 | // 10273: } |
| 8658 | // 10273: } // switch Inst[31:26] |
| 8659 | }; |
| 8660 | static const uint8_t DecoderTableMips32_64_PTR6432[33] = { |
| 8661 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 8662 | 0, 10, // 3: case 0x0: { |
| 8663 | OPC_CheckPredicate, 76, // 5: check predicate 76 |
| 8664 | OPC_CheckField, 0, 21, 8, // 7: check Inst[20:0] == 0x8 |
| 8665 | OPC_Decode, 162, 15, 88, // 11: decode to JR64 using decoder 88 |
| 8666 | // 11: } |
| 8667 | 48, 7, // 15: case 0x30: { |
| 8668 | OPC_CheckPredicate, 77, // 17: check predicate 77 |
| 8669 | OPC_Decode, 136, 16, 137, 3, // 19: decode to LL64 using decoder 393 |
| 8670 | // 19: } |
| 8671 | 56, 0, // 24: case 0x38: { |
| 8672 | OPC_CheckPredicate, 77, // 26: check predicate 77 |
| 8673 | OPC_Decode, 232, 20, 143, 3, // 28: decode to SC64 using decoder 399 |
| 8674 | // 28: } |
| 8675 | // 28: } // switch Inst[31:26] |
| 8676 | }; |
| 8677 | static const uint8_t DecoderTableMips32r6_64r632[1500] = { |
| 8678 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 8679 | 0, 179, 2, // 3: case 0x0: { |
| 8680 | OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] { |
| 8681 | 5, 11, // 9: case 0x5: { |
| 8682 | OPC_CheckPredicate, 78, // 11: check predicate 78 |
| 8683 | OPC_CheckField, 8, 3, 0, // 13: check Inst[10:8] == 0x0 |
| 8684 | OPC_Decode, 150, 16, 226, 1, // 17: decode to LSA_R6 using decoder 226 |
| 8685 | // 17: } |
| 8686 | 9, 11, // 22: case 0x9: { |
| 8687 | OPC_CheckPredicate, 78, // 24: check predicate 78 |
| 8688 | OPC_CheckField, 6, 15, 16, // 26: check Inst[20:6] == 0x10 |
| 8689 | OPC_Decode, 172, 15, 227, 1, // 30: decode to JR_HB_R6 using decoder 227 |
| 8690 | // 30: } |
| 8691 | 14, 7, // 35: case 0xe: { |
| 8692 | OPC_CheckPredicate, 79, // 37: check predicate 79 |
| 8693 | OPC_Decode, 251, 20, 229, 1, // 39: decode to SDBBP_R6 using decoder 229 |
| 8694 | // 39: } |
| 8695 | 16, 14, // 44: case 0x10: { |
| 8696 | OPC_CheckPredicate, 78, // 46: check predicate 78 |
| 8697 | OPC_CheckField, 16, 5, 0, // 48: check Inst[20:16] == 0x0 |
| 8698 | OPC_CheckField, 6, 5, 1, // 52: check Inst[10:6] == 0x1 |
| 8699 | OPC_Decode, 227, 9, 89, // 56: decode to CLZ_R6 using decoder 89 |
| 8700 | // 56: } |
| 8701 | 17, 14, // 60: case 0x11: { |
| 8702 | OPC_CheckPredicate, 78, // 62: check predicate 78 |
| 8703 | OPC_CheckField, 16, 5, 0, // 64: check Inst[20:16] == 0x0 |
| 8704 | OPC_CheckField, 6, 5, 1, // 68: check Inst[10:6] == 0x1 |
| 8705 | OPC_Decode, 206, 9, 89, // 72: decode to CLO_R6 using decoder 89 |
| 8706 | // 72: } |
| 8707 | 18, 14, // 76: case 0x12: { |
| 8708 | OPC_CheckPredicate, 80, // 78: check predicate 80 |
| 8709 | OPC_CheckField, 16, 5, 0, // 80: check Inst[20:16] == 0x0 |
| 8710 | OPC_CheckField, 6, 5, 1, // 84: check Inst[10:6] == 0x1 |
| 8711 | OPC_Decode, 233, 11, 90, // 88: decode to DCLZ_R6 using decoder 90 |
| 8712 | // 88: } |
| 8713 | 19, 14, // 92: case 0x13: { |
| 8714 | OPC_CheckPredicate, 80, // 94: check predicate 80 |
| 8715 | OPC_CheckField, 16, 5, 0, // 96: check Inst[20:16] == 0x0 |
| 8716 | OPC_CheckField, 6, 5, 1, // 100: check Inst[10:6] == 0x1 |
| 8717 | OPC_Decode, 231, 11, 90, // 104: decode to DCLO_R6 using decoder 90 |
| 8718 | // 104: } |
| 8719 | 21, 11, // 108: case 0x15: { |
| 8720 | OPC_CheckPredicate, 80, // 110: check predicate 80 |
| 8721 | OPC_CheckField, 8, 3, 0, // 112: check Inst[10:8] == 0x0 |
| 8722 | OPC_Decode, 138, 12, 235, 1, // 116: decode to DLSA_R6 using decoder 235 |
| 8723 | // 116: } |
| 8724 | 24, 19, // 121: case 0x18: { |
| 8725 | OPC_SwitchField, 6, 5, // 123: switch Inst[10:6] { |
| 8726 | 2, 6, // 126: case 0x2: { |
| 8727 | OPC_CheckPredicate, 79, // 128: check predicate 79 |
| 8728 | OPC_Decode, 148, 19, 104, // 130: decode to MUL_R6 using decoder 104 |
| 8729 | // 130: } |
| 8730 | 3, 0, // 134: case 0x3: { |
| 8731 | OPC_CheckPredicate, 79, // 136: check predicate 79 |
| 8732 | OPC_Decode, 223, 18, 104, // 138: decode to MUH using decoder 104 |
| 8733 | // 138: } |
| 8734 | // 138: } // switch Inst[10:6] |
| 8735 | // 138: } |
| 8736 | 25, 19, // 142: case 0x19: { |
| 8737 | OPC_SwitchField, 6, 5, // 144: switch Inst[10:6] { |
| 8738 | 2, 6, // 147: case 0x2: { |
| 8739 | OPC_CheckPredicate, 79, // 149: check predicate 79 |
| 8740 | OPC_Decode, 134, 19, 104, // 151: decode to MULU using decoder 104 |
| 8741 | // 151: } |
| 8742 | 3, 0, // 155: case 0x3: { |
| 8743 | OPC_CheckPredicate, 79, // 157: check predicate 79 |
| 8744 | OPC_Decode, 224, 18, 104, // 159: decode to MUHU using decoder 104 |
| 8745 | // 159: } |
| 8746 | // 159: } // switch Inst[10:6] |
| 8747 | // 159: } |
| 8748 | 26, 19, // 163: case 0x1a: { |
| 8749 | OPC_SwitchField, 6, 5, // 165: switch Inst[10:6] { |
| 8750 | 2, 6, // 168: case 0x2: { |
| 8751 | OPC_CheckPredicate, 79, // 170: check predicate 79 |
| 8752 | OPC_Decode, 248, 11, 104, // 172: decode to DIV using decoder 104 |
| 8753 | // 172: } |
| 8754 | 3, 0, // 176: case 0x3: { |
| 8755 | OPC_CheckPredicate, 79, // 178: check predicate 79 |
| 8756 | OPC_Decode, 218, 17, 104, // 180: decode to MOD using decoder 104 |
| 8757 | // 180: } |
| 8758 | // 180: } // switch Inst[10:6] |
| 8759 | // 180: } |
| 8760 | 27, 19, // 184: case 0x1b: { |
| 8761 | OPC_SwitchField, 6, 5, // 186: switch Inst[10:6] { |
| 8762 | 2, 6, // 189: case 0x2: { |
| 8763 | OPC_CheckPredicate, 79, // 191: check predicate 79 |
| 8764 | OPC_Decode, 249, 11, 104, // 193: decode to DIVU using decoder 104 |
| 8765 | // 193: } |
| 8766 | 3, 0, // 197: case 0x3: { |
| 8767 | OPC_CheckPredicate, 79, // 199: check predicate 79 |
| 8768 | OPC_Decode, 221, 17, 104, // 201: decode to MODU using decoder 104 |
| 8769 | // 201: } |
| 8770 | // 201: } // switch Inst[10:6] |
| 8771 | // 201: } |
| 8772 | 28, 19, // 205: case 0x1c: { |
| 8773 | OPC_SwitchField, 6, 5, // 207: switch Inst[10:6] { |
| 8774 | 2, 6, // 210: case 0x2: { |
| 8775 | OPC_CheckPredicate, 80, // 212: check predicate 80 |
| 8776 | OPC_Decode, 158, 12, 87, // 214: decode to DMUL_R6 using decoder 87 |
| 8777 | // 214: } |
| 8778 | 3, 0, // 218: case 0x3: { |
| 8779 | OPC_CheckPredicate, 80, // 220: check predicate 80 |
| 8780 | OPC_Decode, 152, 12, 87, // 222: decode to DMUH using decoder 87 |
| 8781 | // 222: } |
| 8782 | // 222: } // switch Inst[10:6] |
| 8783 | // 222: } |
| 8784 | 29, 19, // 226: case 0x1d: { |
| 8785 | OPC_SwitchField, 6, 5, // 228: switch Inst[10:6] { |
| 8786 | 2, 6, // 231: case 0x2: { |
| 8787 | OPC_CheckPredicate, 80, // 233: check predicate 80 |
| 8788 | OPC_Decode, 157, 12, 87, // 235: decode to DMULU using decoder 87 |
| 8789 | // 235: } |
| 8790 | 3, 0, // 239: case 0x3: { |
| 8791 | OPC_CheckPredicate, 80, // 241: check predicate 80 |
| 8792 | OPC_Decode, 153, 12, 87, // 243: decode to DMUHU using decoder 87 |
| 8793 | // 243: } |
| 8794 | // 243: } // switch Inst[10:6] |
| 8795 | // 243: } |
| 8796 | 30, 19, // 247: case 0x1e: { |
| 8797 | OPC_SwitchField, 6, 5, // 249: switch Inst[10:6] { |
| 8798 | 2, 6, // 252: case 0x2: { |
| 8799 | OPC_CheckPredicate, 80, // 254: check predicate 80 |
| 8800 | OPC_Decode, 234, 11, 87, // 256: decode to DDIV using decoder 87 |
| 8801 | // 256: } |
| 8802 | 3, 0, // 260: case 0x3: { |
| 8803 | OPC_CheckPredicate, 80, // 262: check predicate 80 |
| 8804 | OPC_Decode, 144, 12, 87, // 264: decode to DMOD using decoder 87 |
| 8805 | // 264: } |
| 8806 | // 264: } // switch Inst[10:6] |
| 8807 | // 264: } |
| 8808 | 31, 19, // 268: case 0x1f: { |
| 8809 | OPC_SwitchField, 6, 5, // 270: switch Inst[10:6] { |
| 8810 | 2, 6, // 273: case 0x2: { |
| 8811 | OPC_CheckPredicate, 80, // 275: check predicate 80 |
| 8812 | OPC_Decode, 235, 11, 87, // 277: decode to DDIVU using decoder 87 |
| 8813 | // 277: } |
| 8814 | 3, 0, // 281: case 0x3: { |
| 8815 | OPC_CheckPredicate, 80, // 283: check predicate 80 |
| 8816 | OPC_Decode, 145, 12, 87, // 285: decode to DMODU using decoder 87 |
| 8817 | // 285: } |
| 8818 | // 285: } // switch Inst[10:6] |
| 8819 | // 285: } |
| 8820 | 53, 10, // 289: case 0x35: { |
| 8821 | OPC_CheckPredicate, 81, // 291: check predicate 81 |
| 8822 | OPC_CheckField, 6, 5, 0, // 293: check Inst[10:6] == 0x0 |
| 8823 | OPC_Decode, 147, 21, 104, // 297: decode to SELEQZ using decoder 104 |
| 8824 | // 297: } |
| 8825 | 55, 0, // 301: case 0x37: { |
| 8826 | OPC_CheckPredicate, 81, // 303: check predicate 81 |
| 8827 | OPC_CheckField, 6, 5, 0, // 305: check Inst[10:6] == 0x0 |
| 8828 | OPC_Decode, 154, 21, 104, // 309: decode to SELNEZ using decoder 104 |
| 8829 | // 309: } |
| 8830 | // 309: } // switch Inst[5:0] |
| 8831 | // 309: } |
| 8832 | 1, 63, // 313: case 0x1: { |
| 8833 | OPC_SwitchField, 16, 5, // 315: switch Inst[20:16] { |
| 8834 | 6, 7, // 318: case 0x6: { |
| 8835 | OPC_CheckPredicate, 80, // 320: check predicate 80 |
| 8836 | OPC_Decode, 225, 11, 144, 3, // 322: decode to DAHI using decoder 400 |
| 8837 | // 322: } |
| 8838 | 16, 14, // 327: case 0x10: { |
| 8839 | OPC_CheckPredicate, 78, // 329: check predicate 78 |
| 8840 | OPC_CheckField, 21, 5, 0, // 331: check Inst[25:21] == 0x0 |
| 8841 | OPC_CheckField, 0, 16, 0, // 335: check Inst[15:0] == 0x0 |
| 8842 | OPC_Decode, 155, 19, 10, // 339: decode to NAL using decoder 10 |
| 8843 | // 339: } |
| 8844 | 17, 11, // 343: case 0x11: { |
| 8845 | OPC_CheckPredicate, 78, // 345: check predicate 78 |
| 8846 | OPC_CheckField, 21, 5, 0, // 347: check Inst[25:21] == 0x0 |
| 8847 | OPC_Decode, 183, 7, 239, 1, // 351: decode to BAL using decoder 239 |
| 8848 | // 351: } |
| 8849 | 23, 11, // 356: case 0x17: { |
| 8850 | OPC_CheckPredicate, 79, // 358: check predicate 79 |
| 8851 | OPC_CheckField, 21, 5, 0, // 360: check Inst[25:21] == 0x0 |
| 8852 | OPC_Decode, 233, 21, 145, 3, // 364: decode to SIGRIE using decoder 401 |
| 8853 | // 364: } |
| 8854 | 30, 0, // 369: case 0x1e: { |
| 8855 | OPC_CheckPredicate, 80, // 371: check predicate 80 |
| 8856 | OPC_Decode, 227, 11, 144, 3, // 373: decode to DATI using decoder 400 |
| 8857 | // 373: } |
| 8858 | // 373: } // switch Inst[20:16] |
| 8859 | // 373: } |
| 8860 | 6, 7, // 378: case 0x6: { |
| 8861 | OPC_CheckPredicate, 79, // 380: check predicate 79 |
| 8862 | OPC_Decode, 255, 7, 146, 3, // 382: decode to BGEZALC using decoder 402 |
| 8863 | // 382: } |
| 8864 | 7, 7, // 387: case 0x7: { |
| 8865 | OPC_CheckPredicate, 79, // 389: check predicate 79 |
| 8866 | OPC_Decode, 189, 8, 147, 3, // 391: decode to BLTZALC using decoder 403 |
| 8867 | // 391: } |
| 8868 | 8, 7, // 396: case 0x8: { |
| 8869 | OPC_CheckPredicate, 79, // 398: check predicate 79 |
| 8870 | OPC_Decode, 226, 7, 148, 3, // 400: decode to BEQC using decoder 404 |
| 8871 | // 400: } |
| 8872 | 15, 7, // 405: case 0xf: { |
| 8873 | OPC_CheckPredicate, 78, // 407: check predicate 78 |
| 8874 | OPC_Decode, 152, 7, 244, 1, // 409: decode to AUI using decoder 244 |
| 8875 | // 409: } |
| 8876 | 16, 29, // 414: case 0x10: { |
| 8877 | OPC_SwitchField, 0, 16, // 416: switch Inst[15:0] { |
| 8878 | 4, 11, // 419: case 0x4: { |
| 8879 | OPC_CheckPredicate, 78, // 421: check predicate 78 |
| 8880 | OPC_CheckField, 21, 5, 11, // 423: check Inst[25:21] == 0xb |
| 8881 | OPC_Decode, 251, 12, 136, 1, // 427: decode to EVP using decoder 136 |
| 8882 | // 427: } |
| 8883 | 36, 0, // 432: case 0x24: { |
| 8884 | OPC_CheckPredicate, 78, // 434: check predicate 78 |
| 8885 | OPC_CheckField, 21, 5, 11, // 436: check Inst[25:21] == 0xb |
| 8886 | OPC_Decode, 229, 12, 136, 1, // 440: decode to DVP using decoder 136 |
| 8887 | // 440: } |
| 8888 | // 440: } // switch Inst[15:0] |
| 8889 | // 440: } |
| 8890 | 17, 160, 4, // 445: case 0x11: { |
| 8891 | OPC_SwitchField, 21, 5, // 448: switch Inst[25:21] { |
| 8892 | 9, 7, // 451: case 0x9: { |
| 8893 | OPC_CheckPredicate, 82, // 453: check predicate 82 |
| 8894 | OPC_Decode, 200, 7, 149, 3, // 455: decode to BC1EQZ using decoder 405 |
| 8895 | // 455: } |
| 8896 | 13, 7, // 460: case 0xd: { |
| 8897 | OPC_CheckPredicate, 82, // 462: check predicate 82 |
| 8898 | OPC_Decode, 205, 7, 149, 3, // 464: decode to BC1NEZ using decoder 405 |
| 8899 | // 464: } |
| 8900 | 16, 110, // 469: case 0x10: { |
| 8901 | OPC_SwitchField, 0, 6, // 471: switch Inst[5:0] { |
| 8902 | 16, 7, // 474: case 0x10: { |
| 8903 | OPC_CheckPredicate, 82, // 476: check predicate 82 |
| 8904 | OPC_Decode, 163, 21, 150, 3, // 478: decode to SEL_S using decoder 406 |
| 8905 | // 478: } |
| 8906 | 20, 7, // 483: case 0x14: { |
| 8907 | OPC_CheckPredicate, 82, // 485: check predicate 82 |
| 8908 | OPC_Decode, 152, 21, 131, 2, // 487: decode to SELEQZ_S using decoder 259 |
| 8909 | // 487: } |
| 8910 | 23, 7, // 492: case 0x17: { |
| 8911 | OPC_CheckPredicate, 82, // 494: check predicate 82 |
| 8912 | OPC_Decode, 159, 21, 131, 2, // 496: decode to SELNEZ_S using decoder 259 |
| 8913 | // 496: } |
| 8914 | 24, 7, // 501: case 0x18: { |
| 8915 | OPC_CheckPredicate, 82, // 503: check predicate 82 |
| 8916 | OPC_Decode, 226, 16, 150, 3, // 505: decode to MADDF_S using decoder 406 |
| 8917 | // 505: } |
| 8918 | 25, 7, // 510: case 0x19: { |
| 8919 | OPC_CheckPredicate, 82, // 512: check predicate 82 |
| 8920 | OPC_Decode, 160, 18, 150, 3, // 514: decode to MSUBF_S using decoder 406 |
| 8921 | // 514: } |
| 8922 | 26, 11, // 519: case 0x1a: { |
| 8923 | OPC_CheckPredicate, 82, // 521: check predicate 82 |
| 8924 | OPC_CheckField, 16, 5, 0, // 523: check Inst[20:16] == 0x0 |
| 8925 | OPC_Decode, 178, 20, 132, 2, // 527: decode to RINT_S using decoder 260 |
| 8926 | // 527: } |
| 8927 | 27, 11, // 532: case 0x1b: { |
| 8928 | OPC_CheckPredicate, 82, // 534: check predicate 82 |
| 8929 | OPC_CheckField, 16, 5, 0, // 536: check Inst[20:16] == 0x0 |
| 8930 | OPC_Decode, 184, 9, 132, 2, // 540: decode to CLASS_S using decoder 260 |
| 8931 | // 540: } |
| 8932 | 28, 7, // 545: case 0x1c: { |
| 8933 | OPC_CheckPredicate, 82, // 547: check predicate 82 |
| 8934 | OPC_Decode, 208, 17, 131, 2, // 549: decode to MIN_S using decoder 259 |
| 8935 | // 549: } |
| 8936 | 29, 7, // 554: case 0x1d: { |
| 8937 | OPC_CheckPredicate, 82, // 556: check predicate 82 |
| 8938 | OPC_Decode, 192, 17, 131, 2, // 558: decode to MINA_S using decoder 259 |
| 8939 | // 558: } |
| 8940 | 30, 7, // 563: case 0x1e: { |
| 8941 | OPC_CheckPredicate, 82, // 565: check predicate 82 |
| 8942 | OPC_Decode, 146, 17, 131, 2, // 567: decode to MAX_S using decoder 259 |
| 8943 | // 567: } |
| 8944 | 31, 0, // 572: case 0x1f: { |
| 8945 | OPC_CheckPredicate, 82, // 574: check predicate 82 |
| 8946 | OPC_Decode, 130, 17, 131, 2, // 576: decode to MAXA_S using decoder 259 |
| 8947 | // 576: } |
| 8948 | // 576: } // switch Inst[5:0] |
| 8949 | // 576: } |
| 8950 | 17, 110, // 581: case 0x11: { |
| 8951 | OPC_SwitchField, 0, 6, // 583: switch Inst[5:0] { |
| 8952 | 16, 7, // 586: case 0x10: { |
| 8953 | OPC_CheckPredicate, 82, // 588: check predicate 82 |
| 8954 | OPC_Decode, 161, 21, 151, 3, // 590: decode to SEL_D using decoder 407 |
| 8955 | // 590: } |
| 8956 | 20, 7, // 595: case 0x14: { |
| 8957 | OPC_CheckPredicate, 82, // 597: check predicate 82 |
| 8958 | OPC_Decode, 149, 21, 152, 3, // 599: decode to SELEQZ_D using decoder 408 |
| 8959 | // 599: } |
| 8960 | 23, 7, // 604: case 0x17: { |
| 8961 | OPC_CheckPredicate, 82, // 606: check predicate 82 |
| 8962 | OPC_Decode, 156, 21, 152, 3, // 608: decode to SELNEZ_D using decoder 408 |
| 8963 | // 608: } |
| 8964 | 24, 7, // 613: case 0x18: { |
| 8965 | OPC_CheckPredicate, 82, // 615: check predicate 82 |
| 8966 | OPC_Decode, 224, 16, 151, 3, // 617: decode to MADDF_D using decoder 407 |
| 8967 | // 617: } |
| 8968 | 25, 7, // 622: case 0x19: { |
| 8969 | OPC_CheckPredicate, 82, // 624: check predicate 82 |
| 8970 | OPC_Decode, 158, 18, 151, 3, // 626: decode to MSUBF_D using decoder 407 |
| 8971 | // 626: } |
| 8972 | 26, 11, // 631: case 0x1a: { |
| 8973 | OPC_CheckPredicate, 82, // 633: check predicate 82 |
| 8974 | OPC_CheckField, 16, 5, 0, // 635: check Inst[20:16] == 0x0 |
| 8975 | OPC_Decode, 176, 20, 143, 2, // 639: decode to RINT_D using decoder 271 |
| 8976 | // 639: } |
| 8977 | 27, 11, // 644: case 0x1b: { |
| 8978 | OPC_CheckPredicate, 82, // 646: check predicate 82 |
| 8979 | OPC_CheckField, 16, 5, 0, // 648: check Inst[20:16] == 0x0 |
| 8980 | OPC_Decode, 182, 9, 143, 2, // 652: decode to CLASS_D using decoder 271 |
| 8981 | // 652: } |
| 8982 | 28, 7, // 657: case 0x1c: { |
| 8983 | OPC_CheckPredicate, 82, // 659: check predicate 82 |
| 8984 | OPC_Decode, 206, 17, 152, 3, // 661: decode to MIN_D using decoder 408 |
| 8985 | // 661: } |
| 8986 | 29, 7, // 666: case 0x1d: { |
| 8987 | OPC_CheckPredicate, 82, // 668: check predicate 82 |
| 8988 | OPC_Decode, 190, 17, 152, 3, // 670: decode to MINA_D using decoder 408 |
| 8989 | // 670: } |
| 8990 | 30, 7, // 675: case 0x1e: { |
| 8991 | OPC_CheckPredicate, 82, // 677: check predicate 82 |
| 8992 | OPC_Decode, 144, 17, 152, 3, // 679: decode to MAX_D using decoder 408 |
| 8993 | // 679: } |
| 8994 | 31, 0, // 684: case 0x1f: { |
| 8995 | OPC_CheckPredicate, 82, // 686: check predicate 82 |
| 8996 | OPC_Decode, 128, 17, 152, 3, // 688: decode to MAXA_D using decoder 408 |
| 8997 | // 688: } |
| 8998 | // 688: } // switch Inst[5:0] |
| 8999 | // 688: } |
| 9000 | 20, 147, 1, // 693: case 0x14: { |
| 9001 | OPC_SwitchField, 0, 6, // 696: switch Inst[5:0] { |
| 9002 | 0, 7, // 699: case 0x0: { |
| 9003 | OPC_CheckPredicate, 82, // 701: check predicate 82 |
| 9004 | OPC_Decode, 255, 9, 131, 2, // 703: decode to CMP_F_S using decoder 259 |
| 9005 | // 703: } |
| 9006 | 1, 7, // 708: case 0x1: { |
| 9007 | OPC_CheckPredicate, 82, // 710: check predicate 82 |
| 9008 | OPC_Decode, 186, 10, 131, 2, // 712: decode to CMP_UN_S using decoder 259 |
| 9009 | // 712: } |
| 9010 | 2, 7, // 717: case 0x2: { |
| 9011 | OPC_CheckPredicate, 82, // 719: check predicate 82 |
| 9012 | OPC_Decode, 252, 9, 131, 2, // 721: decode to CMP_EQ_S using decoder 259 |
| 9013 | // 721: } |
| 9014 | 3, 7, // 726: case 0x3: { |
| 9015 | OPC_CheckPredicate, 82, // 728: check predicate 82 |
| 9016 | OPC_Decode, 174, 10, 131, 2, // 730: decode to CMP_UEQ_S using decoder 259 |
| 9017 | // 730: } |
| 9018 | 4, 7, // 735: case 0x4: { |
| 9019 | OPC_CheckPredicate, 82, // 737: check predicate 82 |
| 9020 | OPC_Decode, 138, 10, 131, 2, // 739: decode to CMP_LT_S using decoder 259 |
| 9021 | // 739: } |
| 9022 | 5, 7, // 744: case 0x5: { |
| 9023 | OPC_CheckPredicate, 82, // 746: check predicate 82 |
| 9024 | OPC_Decode, 182, 10, 131, 2, // 748: decode to CMP_ULT_S using decoder 259 |
| 9025 | // 748: } |
| 9026 | 6, 7, // 753: case 0x6: { |
| 9027 | OPC_CheckPredicate, 82, // 755: check predicate 82 |
| 9028 | OPC_Decode, 132, 10, 131, 2, // 757: decode to CMP_LE_S using decoder 259 |
| 9029 | // 757: } |
| 9030 | 7, 7, // 762: case 0x7: { |
| 9031 | OPC_CheckPredicate, 82, // 764: check predicate 82 |
| 9032 | OPC_Decode, 178, 10, 131, 2, // 766: decode to CMP_ULE_S using decoder 259 |
| 9033 | // 766: } |
| 9034 | 8, 7, // 771: case 0x8: { |
| 9035 | OPC_CheckPredicate, 82, // 773: check predicate 82 |
| 9036 | OPC_Decode, 142, 10, 131, 2, // 775: decode to CMP_SAF_S using decoder 259 |
| 9037 | // 775: } |
| 9038 | 9, 7, // 780: case 0x9: { |
| 9039 | OPC_CheckPredicate, 82, // 782: check predicate 82 |
| 9040 | OPC_Decode, 170, 10, 131, 2, // 784: decode to CMP_SUN_S using decoder 259 |
| 9041 | // 784: } |
| 9042 | 10, 7, // 789: case 0xa: { |
| 9043 | OPC_CheckPredicate, 82, // 791: check predicate 82 |
| 9044 | OPC_Decode, 146, 10, 131, 2, // 793: decode to CMP_SEQ_S using decoder 259 |
| 9045 | // 793: } |
| 9046 | 11, 7, // 798: case 0xb: { |
| 9047 | OPC_CheckPredicate, 82, // 800: check predicate 82 |
| 9048 | OPC_Decode, 158, 10, 131, 2, // 802: decode to CMP_SUEQ_S using decoder 259 |
| 9049 | // 802: } |
| 9050 | 12, 7, // 807: case 0xc: { |
| 9051 | OPC_CheckPredicate, 82, // 809: check predicate 82 |
| 9052 | OPC_Decode, 154, 10, 131, 2, // 811: decode to CMP_SLT_S using decoder 259 |
| 9053 | // 811: } |
| 9054 | 13, 7, // 816: case 0xd: { |
| 9055 | OPC_CheckPredicate, 82, // 818: check predicate 82 |
| 9056 | OPC_Decode, 166, 10, 131, 2, // 820: decode to CMP_SULT_S using decoder 259 |
| 9057 | // 820: } |
| 9058 | 14, 7, // 825: case 0xe: { |
| 9059 | OPC_CheckPredicate, 82, // 827: check predicate 82 |
| 9060 | OPC_Decode, 150, 10, 131, 2, // 829: decode to CMP_SLE_S using decoder 259 |
| 9061 | // 829: } |
| 9062 | 15, 0, // 834: case 0xf: { |
| 9063 | OPC_CheckPredicate, 82, // 836: check predicate 82 |
| 9064 | OPC_Decode, 162, 10, 131, 2, // 838: decode to CMP_SULE_S using decoder 259 |
| 9065 | // 838: } |
| 9066 | // 838: } // switch Inst[5:0] |
| 9067 | // 838: } |
| 9068 | 21, 0, // 843: case 0x15: { |
| 9069 | OPC_SwitchField, 0, 6, // 845: switch Inst[5:0] { |
| 9070 | 0, 7, // 848: case 0x0: { |
| 9071 | OPC_CheckPredicate, 82, // 850: check predicate 82 |
| 9072 | OPC_Decode, 254, 9, 152, 3, // 852: decode to CMP_F_D using decoder 408 |
| 9073 | // 852: } |
| 9074 | 1, 7, // 857: case 0x1: { |
| 9075 | OPC_CheckPredicate, 82, // 859: check predicate 82 |
| 9076 | OPC_Decode, 184, 10, 152, 3, // 861: decode to CMP_UN_D using decoder 408 |
| 9077 | // 861: } |
| 9078 | 2, 7, // 866: case 0x2: { |
| 9079 | OPC_CheckPredicate, 82, // 868: check predicate 82 |
| 9080 | OPC_Decode, 248, 9, 152, 3, // 870: decode to CMP_EQ_D using decoder 408 |
| 9081 | // 870: } |
| 9082 | 3, 7, // 875: case 0x3: { |
| 9083 | OPC_CheckPredicate, 82, // 877: check predicate 82 |
| 9084 | OPC_Decode, 172, 10, 152, 3, // 879: decode to CMP_UEQ_D using decoder 408 |
| 9085 | // 879: } |
| 9086 | 4, 7, // 884: case 0x4: { |
| 9087 | OPC_CheckPredicate, 82, // 886: check predicate 82 |
| 9088 | OPC_Decode, 134, 10, 152, 3, // 888: decode to CMP_LT_D using decoder 408 |
| 9089 | // 888: } |
| 9090 | 5, 7, // 893: case 0x5: { |
| 9091 | OPC_CheckPredicate, 82, // 895: check predicate 82 |
| 9092 | OPC_Decode, 180, 10, 152, 3, // 897: decode to CMP_ULT_D using decoder 408 |
| 9093 | // 897: } |
| 9094 | 6, 7, // 902: case 0x6: { |
| 9095 | OPC_CheckPredicate, 82, // 904: check predicate 82 |
| 9096 | OPC_Decode, 128, 10, 152, 3, // 906: decode to CMP_LE_D using decoder 408 |
| 9097 | // 906: } |
| 9098 | 7, 7, // 911: case 0x7: { |
| 9099 | OPC_CheckPredicate, 82, // 913: check predicate 82 |
| 9100 | OPC_Decode, 176, 10, 152, 3, // 915: decode to CMP_ULE_D using decoder 408 |
| 9101 | // 915: } |
| 9102 | 8, 7, // 920: case 0x8: { |
| 9103 | OPC_CheckPredicate, 82, // 922: check predicate 82 |
| 9104 | OPC_Decode, 140, 10, 152, 3, // 924: decode to CMP_SAF_D using decoder 408 |
| 9105 | // 924: } |
| 9106 | 9, 7, // 929: case 0x9: { |
| 9107 | OPC_CheckPredicate, 82, // 931: check predicate 82 |
| 9108 | OPC_Decode, 168, 10, 152, 3, // 933: decode to CMP_SUN_D using decoder 408 |
| 9109 | // 933: } |
| 9110 | 10, 7, // 938: case 0xa: { |
| 9111 | OPC_CheckPredicate, 82, // 940: check predicate 82 |
| 9112 | OPC_Decode, 144, 10, 152, 3, // 942: decode to CMP_SEQ_D using decoder 408 |
| 9113 | // 942: } |
| 9114 | 11, 7, // 947: case 0xb: { |
| 9115 | OPC_CheckPredicate, 82, // 949: check predicate 82 |
| 9116 | OPC_Decode, 156, 10, 152, 3, // 951: decode to CMP_SUEQ_D using decoder 408 |
| 9117 | // 951: } |
| 9118 | 12, 7, // 956: case 0xc: { |
| 9119 | OPC_CheckPredicate, 82, // 958: check predicate 82 |
| 9120 | OPC_Decode, 152, 10, 152, 3, // 960: decode to CMP_SLT_D using decoder 408 |
| 9121 | // 960: } |
| 9122 | 13, 7, // 965: case 0xd: { |
| 9123 | OPC_CheckPredicate, 82, // 967: check predicate 82 |
| 9124 | OPC_Decode, 164, 10, 152, 3, // 969: decode to CMP_SULT_D using decoder 408 |
| 9125 | // 969: } |
| 9126 | 14, 7, // 974: case 0xe: { |
| 9127 | OPC_CheckPredicate, 82, // 976: check predicate 82 |
| 9128 | OPC_Decode, 148, 10, 152, 3, // 978: decode to CMP_SLE_D using decoder 408 |
| 9129 | // 978: } |
| 9130 | 15, 0, // 983: case 0xf: { |
| 9131 | OPC_CheckPredicate, 82, // 985: check predicate 82 |
| 9132 | OPC_Decode, 160, 10, 152, 3, // 987: decode to CMP_SULE_D using decoder 408 |
| 9133 | // 987: } |
| 9134 | // 987: } // switch Inst[5:0] |
| 9135 | // 987: } |
| 9136 | // 987: } // switch Inst[25:21] |
| 9137 | // 987: } |
| 9138 | 18, 57, // 992: case 0x12: { |
| 9139 | OPC_SwitchField, 21, 5, // 994: switch Inst[25:21] { |
| 9140 | 9, 7, // 997: case 0x9: { |
| 9141 | OPC_CheckPredicate, 79, // 999: check predicate 79 |
| 9142 | OPC_Decode, 210, 7, 153, 3, // 1001: decode to BC2EQZ using decoder 409 |
| 9143 | // 1001: } |
| 9144 | 10, 7, // 1006: case 0xa: { |
| 9145 | OPC_CheckPredicate, 79, // 1008: check predicate 79 |
| 9146 | OPC_Decode, 168, 16, 154, 3, // 1010: decode to LWC2_R6 using decoder 410 |
| 9147 | // 1010: } |
| 9148 | 11, 7, // 1015: case 0xb: { |
| 9149 | OPC_CheckPredicate, 79, // 1017: check predicate 79 |
| 9150 | OPC_Decode, 163, 23, 154, 3, // 1019: decode to SWC2_R6 using decoder 410 |
| 9151 | // 1019: } |
| 9152 | 13, 7, // 1024: case 0xd: { |
| 9153 | OPC_CheckPredicate, 79, // 1026: check predicate 79 |
| 9154 | OPC_Decode, 212, 7, 153, 3, // 1028: decode to BC2NEZ using decoder 409 |
| 9155 | // 1028: } |
| 9156 | 14, 7, // 1033: case 0xe: { |
| 9157 | OPC_CheckPredicate, 79, // 1035: check predicate 79 |
| 9158 | OPC_Decode, 216, 15, 154, 3, // 1037: decode to LDC2_R6 using decoder 410 |
| 9159 | // 1037: } |
| 9160 | 15, 0, // 1042: case 0xf: { |
| 9161 | OPC_CheckPredicate, 79, // 1044: check predicate 79 |
| 9162 | OPC_Decode, 131, 21, 154, 3, // 1046: decode to SDC2_R6 using decoder 410 |
| 9163 | // 1046: } |
| 9164 | // 1046: } // switch Inst[25:21] |
| 9165 | // 1046: } |
| 9166 | 22, 7, // 1051: case 0x16: { |
| 9167 | OPC_CheckPredicate, 79, // 1053: check predicate 79 |
| 9168 | OPC_Decode, 132, 8, 155, 3, // 1055: decode to BGEZC using decoder 411 |
| 9169 | // 1055: } |
| 9170 | 23, 7, // 1060: case 0x17: { |
| 9171 | OPC_CheckPredicate, 79, // 1062: check predicate 79 |
| 9172 | OPC_Decode, 194, 8, 156, 3, // 1064: decode to BLTZC using decoder 412 |
| 9173 | // 1064: } |
| 9174 | 24, 7, // 1069: case 0x18: { |
| 9175 | OPC_CheckPredicate, 79, // 1071: check predicate 79 |
| 9176 | OPC_Decode, 205, 8, 157, 3, // 1073: decode to BNEC using decoder 413 |
| 9177 | // 1073: } |
| 9178 | 29, 7, // 1078: case 0x1d: { |
| 9179 | OPC_CheckPredicate, 80, // 1080: check predicate 80 |
| 9180 | OPC_Decode, 228, 11, 158, 3, // 1082: decode to DAUI using decoder 414 |
| 9181 | // 1082: } |
| 9182 | 31, 235, 1, // 1087: case 0x1f: { |
| 9183 | OPC_SwitchField, 0, 6, // 1090: switch Inst[5:0] { |
| 9184 | 15, 75, // 1093: case 0xf: { |
| 9185 | OPC_SwitchField, 6, 10, // 1095: switch Inst[15:6] { |
| 9186 | 0, 7, // 1098: case 0x0: { |
| 9187 | OPC_CheckPredicate, 83, // 1100: check predicate 83 |
| 9188 | OPC_Decode, 195, 10, 159, 3, // 1102: decode to CRC32B using decoder 415 |
| 9189 | // 1102: } |
| 9190 | 1, 7, // 1107: case 0x1: { |
| 9191 | OPC_CheckPredicate, 83, // 1109: check predicate 83 |
| 9192 | OPC_Decode, 205, 10, 159, 3, // 1111: decode to CRC32H using decoder 415 |
| 9193 | // 1111: } |
| 9194 | 2, 7, // 1116: case 0x2: { |
| 9195 | OPC_CheckPredicate, 83, // 1118: check predicate 83 |
| 9196 | OPC_Decode, 207, 10, 159, 3, // 1120: decode to CRC32W using decoder 415 |
| 9197 | // 1120: } |
| 9198 | 3, 7, // 1125: case 0x3: { |
| 9199 | OPC_CheckPredicate, 84, // 1127: check predicate 84 |
| 9200 | OPC_Decode, 204, 10, 159, 3, // 1129: decode to CRC32D using decoder 415 |
| 9201 | // 1129: } |
| 9202 | 4, 7, // 1134: case 0x4: { |
| 9203 | OPC_CheckPredicate, 83, // 1136: check predicate 83 |
| 9204 | OPC_Decode, 197, 10, 159, 3, // 1138: decode to CRC32CB using decoder 415 |
| 9205 | // 1138: } |
| 9206 | 5, 7, // 1143: case 0x5: { |
| 9207 | OPC_CheckPredicate, 83, // 1145: check predicate 83 |
| 9208 | OPC_Decode, 200, 10, 159, 3, // 1147: decode to CRC32CH using decoder 415 |
| 9209 | // 1147: } |
| 9210 | 6, 7, // 1152: case 0x6: { |
| 9211 | OPC_CheckPredicate, 83, // 1154: check predicate 83 |
| 9212 | OPC_Decode, 202, 10, 159, 3, // 1156: decode to CRC32CW using decoder 415 |
| 9213 | // 1156: } |
| 9214 | 7, 0, // 1161: case 0x7: { |
| 9215 | OPC_CheckPredicate, 84, // 1163: check predicate 84 |
| 9216 | OPC_Decode, 199, 10, 159, 3, // 1165: decode to CRC32CD using decoder 415 |
| 9217 | // 1165: } |
| 9218 | // 1165: } // switch Inst[15:6] |
| 9219 | // 1165: } |
| 9220 | 32, 29, // 1170: case 0x20: { |
| 9221 | OPC_SwitchField, 8, 3, // 1172: switch Inst[10:8] { |
| 9222 | 0, 15, // 1175: case 0x0: { |
| 9223 | OPC_CheckPredicate, 78, // 1177: check predicate 78 |
| 9224 | OPC_CheckField, 21, 5, 0, // 1179: check Inst[25:21] == 0x0 |
| 9225 | OPC_CheckField, 6, 2, 0, // 1183: check Inst[7:6] == 0x0 |
| 9226 | OPC_Decode, 165, 8, 248, 2, // 1187: decode to BITSWAP using decoder 376 |
| 9227 | // 1187: } |
| 9228 | 2, 0, // 1192: case 0x2: { |
| 9229 | OPC_CheckPredicate, 78, // 1194: check predicate 78 |
| 9230 | OPC_Decode, 247, 6, 160, 3, // 1196: decode to ALIGN using decoder 416 |
| 9231 | // 1196: } |
| 9232 | // 1196: } // switch Inst[10:8] |
| 9233 | // 1196: } |
| 9234 | 36, 29, // 1201: case 0x24: { |
| 9235 | OPC_SwitchField, 9, 2, // 1203: switch Inst[10:9] { |
| 9236 | 0, 15, // 1206: case 0x0: { |
| 9237 | OPC_CheckPredicate, 80, // 1208: check predicate 80 |
| 9238 | OPC_CheckField, 21, 5, 0, // 1210: check Inst[25:21] == 0x0 |
| 9239 | OPC_CheckField, 6, 3, 0, // 1214: check Inst[8:6] == 0x0 |
| 9240 | OPC_Decode, 229, 11, 161, 3, // 1218: decode to DBITSWAP using decoder 417 |
| 9241 | // 1218: } |
| 9242 | 1, 0, // 1223: case 0x1: { |
| 9243 | OPC_CheckPredicate, 80, // 1225: check predicate 80 |
| 9244 | OPC_Decode, 226, 11, 162, 3, // 1227: decode to DALIGN using decoder 418 |
| 9245 | // 1227: } |
| 9246 | // 1227: } // switch Inst[10:9] |
| 9247 | // 1227: } |
| 9248 | 37, 11, // 1232: case 0x25: { |
| 9249 | OPC_CheckPredicate, 79, // 1234: check predicate 79 |
| 9250 | OPC_CheckField, 6, 1, 0, // 1236: check Inst[6] == 0x0 |
| 9251 | OPC_Decode, 154, 9, 253, 2, // 1240: decode to CACHE_R6 using decoder 381 |
| 9252 | // 1240: } |
| 9253 | 38, 7, // 1245: case 0x26: { |
| 9254 | OPC_CheckPredicate, 85, // 1247: check predicate 85 |
| 9255 | OPC_Decode, 242, 20, 255, 2, // 1249: decode to SC_R6 using decoder 383 |
| 9256 | // 1249: } |
| 9257 | 39, 7, // 1254: case 0x27: { |
| 9258 | OPC_CheckPredicate, 78, // 1256: check predicate 78 |
| 9259 | OPC_Decode, 235, 20, 163, 3, // 1258: decode to SCD_R6 using decoder 419 |
| 9260 | // 1258: } |
| 9261 | 53, 11, // 1263: case 0x35: { |
| 9262 | OPC_CheckPredicate, 79, // 1265: check predicate 79 |
| 9263 | OPC_CheckField, 6, 1, 0, // 1267: check Inst[6] == 0x0 |
| 9264 | OPC_Decode, 142, 20, 253, 2, // 1271: decode to PREF_R6 using decoder 381 |
| 9265 | // 1271: } |
| 9266 | 54, 7, // 1276: case 0x36: { |
| 9267 | OPC_CheckPredicate, 85, // 1278: check predicate 85 |
| 9268 | OPC_Decode, 146, 16, 254, 2, // 1280: decode to LL_R6 using decoder 382 |
| 9269 | // 1280: } |
| 9270 | 55, 7, // 1285: case 0x37: { |
| 9271 | OPC_CheckPredicate, 80, // 1287: check predicate 80 |
| 9272 | OPC_Decode, 139, 16, 164, 3, // 1289: decode to LLD_R6 using decoder 420 |
| 9273 | // 1289: } |
| 9274 | 61, 0, // 1294: case 0x3d: { |
| 9275 | OPC_SwitchField, 6, 2, // 1296: switch Inst[7:6] { |
| 9276 | 0, 11, // 1299: case 0x0: { |
| 9277 | OPC_CheckPredicate, 86, // 1301: check predicate 86 |
| 9278 | OPC_CheckField, 8, 13, 0, // 1303: check Inst[20:8] == 0x0 |
| 9279 | OPC_Decode, 211, 14, 227, 1, // 1307: decode to GINVI using decoder 227 |
| 9280 | // 1307: } |
| 9281 | 2, 0, // 1312: case 0x2: { |
| 9282 | OPC_CheckPredicate, 86, // 1314: check predicate 86 |
| 9283 | OPC_CheckField, 10, 11, 0, // 1316: check Inst[20:10] == 0x0 |
| 9284 | OPC_Decode, 214, 14, 165, 3, // 1320: decode to GINVT using decoder 421 |
| 9285 | // 1320: } |
| 9286 | // 1320: } // switch Inst[7:6] |
| 9287 | // 1320: } |
| 9288 | // 1320: } // switch Inst[5:0] |
| 9289 | // 1320: } |
| 9290 | 50, 7, // 1325: case 0x32: { |
| 9291 | OPC_CheckPredicate, 79, // 1327: check predicate 79 |
| 9292 | OPC_Decode, 197, 7, 166, 3, // 1329: decode to BC using decoder 422 |
| 9293 | // 1329: } |
| 9294 | 53, 20, // 1334: case 0x35: { |
| 9295 | OPC_Scope, 11, // 1336: try { |
| 9296 | OPC_CheckField, 16, 5, 0, // 1338: check Inst[20:16] == 0x0 |
| 9297 | OPC_CheckPredicate, 3, // 1342: check predicate 3 |
| 9298 | OPC_Decode, 143, 8, 221, 1, // 1344: decode to BGTZC_MMR6 using decoder 221 |
| 9299 | // 1344: } else try { |
| 9300 | OPC_CheckPredicate, 3, // 1349: check predicate 3 |
| 9301 | OPC_Decode, 196, 8, 221, 1, // 1351: decode to BLTZC_MMR6 using decoder 221 |
| 9302 | // 1351: } |
| 9303 | // 1351: } |
| 9304 | 54, 20, // 1356: case 0x36: { |
| 9305 | OPC_Scope, 11, // 1358: try { |
| 9306 | OPC_CheckField, 21, 5, 0, // 1360: check Inst[25:21] == 0x0 |
| 9307 | OPC_CheckPredicate, 78, // 1364: check predicate 78 |
| 9308 | OPC_Decode, 157, 15, 148, 1, // 1366: decode to JIC using decoder 148 |
| 9309 | // 1366: } else try { |
| 9310 | OPC_CheckPredicate, 79, // 1371: check predicate 79 |
| 9311 | OPC_Decode, 235, 7, 167, 3, // 1373: decode to BEQZC using decoder 423 |
| 9312 | // 1373: } |
| 9313 | // 1373: } |
| 9314 | 58, 7, // 1378: case 0x3a: { |
| 9315 | OPC_CheckPredicate, 78, // 1380: check predicate 78 |
| 9316 | OPC_Decode, 184, 7, 166, 3, // 1382: decode to BALC using decoder 422 |
| 9317 | // 1382: } |
| 9318 | 59, 67, // 1387: case 0x3b: { |
| 9319 | OPC_SwitchField, 19, 2, // 1389: switch Inst[20:19] { |
| 9320 | 0, 7, // 1392: case 0x0: { |
| 9321 | OPC_CheckPredicate, 78, // 1394: check predicate 78 |
| 9322 | OPC_Decode, 163, 6, 215, 1, // 1396: decode to ADDIUPC using decoder 215 |
| 9323 | // 1396: } |
| 9324 | 1, 7, // 1401: case 0x1: { |
| 9325 | OPC_CheckPredicate, 78, // 1403: check predicate 78 |
| 9326 | OPC_Decode, 186, 16, 215, 1, // 1405: decode to LWPC using decoder 215 |
| 9327 | // 1405: } |
| 9328 | 2, 7, // 1410: case 0x2: { |
| 9329 | OPC_CheckPredicate, 87, // 1412: check predicate 87 |
| 9330 | OPC_Decode, 197, 16, 215, 1, // 1414: decode to LWUPC using decoder 215 |
| 9331 | // 1414: } |
| 9332 | 3, 0, // 1419: case 0x3: { |
| 9333 | OPC_SwitchField, 18, 1, // 1421: switch Inst[18] { |
| 9334 | 0, 7, // 1424: case 0x0: { |
| 9335 | OPC_CheckPredicate, 87, // 1426: check predicate 87 |
| 9336 | OPC_Decode, 223, 15, 168, 3, // 1428: decode to LDPC using decoder 424 |
| 9337 | // 1428: } |
| 9338 | 1, 0, // 1433: case 0x1: { |
| 9339 | OPC_SwitchField, 16, 2, // 1435: switch Inst[17:16] { |
| 9340 | 2, 7, // 1438: case 0x2: { |
| 9341 | OPC_CheckPredicate, 78, // 1440: check predicate 78 |
| 9342 | OPC_Decode, 153, 7, 216, 1, // 1442: decode to AUIPC using decoder 216 |
| 9343 | // 1442: } |
| 9344 | 3, 0, // 1447: case 0x3: { |
| 9345 | OPC_CheckPredicate, 78, // 1449: check predicate 78 |
| 9346 | OPC_Decode, 249, 6, 216, 1, // 1451: decode to ALUIPC using decoder 216 |
| 9347 | // 1451: } |
| 9348 | // 1451: } // switch Inst[17:16] |
| 9349 | // 1451: } |
| 9350 | // 1451: } // switch Inst[18] |
| 9351 | // 1451: } |
| 9352 | // 1451: } // switch Inst[20:19] |
| 9353 | // 1451: } |
| 9354 | 61, 20, // 1456: case 0x3d: { |
| 9355 | OPC_Scope, 11, // 1458: try { |
| 9356 | OPC_CheckField, 16, 5, 0, // 1460: check Inst[20:16] == 0x0 |
| 9357 | OPC_CheckPredicate, 3, // 1464: check predicate 3 |
| 9358 | OPC_Decode, 173, 8, 223, 1, // 1466: decode to BLEZC_MMR6 using decoder 223 |
| 9359 | // 1466: } else try { |
| 9360 | OPC_CheckPredicate, 3, // 1471: check predicate 3 |
| 9361 | OPC_Decode, 134, 8, 223, 1, // 1473: decode to BGEZC_MMR6 using decoder 223 |
| 9362 | // 1473: } |
| 9363 | // 1473: } |
| 9364 | 62, 0, // 1478: case 0x3e: { |
| 9365 | OPC_Scope, 11, // 1480: try { |
| 9366 | OPC_CheckField, 21, 5, 0, // 1482: check Inst[25:21] == 0x0 |
| 9367 | OPC_CheckPredicate, 78, // 1486: check predicate 78 |
| 9368 | OPC_Decode, 154, 15, 148, 1, // 1488: decode to JIALC using decoder 148 |
| 9369 | // 1488: } else try { |
| 9370 | OPC_CheckPredicate, 79, // 1493: check predicate 79 |
| 9371 | OPC_Decode, 222, 8, 167, 3, // 1495: decode to BNEZC using decoder 423 |
| 9372 | // 1495: } |
| 9373 | // 1495: } |
| 9374 | // 1495: } // switch Inst[31:26] |
| 9375 | }; |
| 9376 | static const uint8_t DecoderTableMips32r6_64r6_Ambiguous32[135] = { |
| 9377 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 9378 | 6, 20, // 3: case 0x6: { |
| 9379 | OPC_Scope, 11, // 5: try { |
| 9380 | OPC_CheckField, 21, 5, 0, // 7: check Inst[25:21] == 0x0 |
| 9381 | OPC_CheckPredicate, 79, // 11: check predicate 79 |
| 9382 | OPC_Decode, 169, 8, 146, 3, // 13: decode to BLEZALC using decoder 402 |
| 9383 | // 13: } else try { |
| 9384 | OPC_CheckPredicate, 79, // 18: check predicate 79 |
| 9385 | OPC_Decode, 248, 7, 146, 3, // 20: decode to BGEUC using decoder 402 |
| 9386 | // 20: } |
| 9387 | // 20: } |
| 9388 | 7, 20, // 25: case 0x7: { |
| 9389 | OPC_Scope, 11, // 27: try { |
| 9390 | OPC_CheckField, 21, 5, 0, // 29: check Inst[25:21] == 0x0 |
| 9391 | OPC_CheckPredicate, 79, // 33: check predicate 79 |
| 9392 | OPC_Decode, 139, 8, 147, 3, // 35: decode to BGTZALC using decoder 403 |
| 9393 | // 35: } else try { |
| 9394 | OPC_CheckPredicate, 79, // 40: check predicate 79 |
| 9395 | OPC_Decode, 182, 8, 147, 3, // 42: decode to BLTUC using decoder 403 |
| 9396 | // 42: } |
| 9397 | // 42: } |
| 9398 | 8, 20, // 47: case 0x8: { |
| 9399 | OPC_Scope, 11, // 49: try { |
| 9400 | OPC_CheckField, 21, 5, 0, // 51: check Inst[25:21] == 0x0 |
| 9401 | OPC_CheckPredicate, 79, // 55: check predicate 79 |
| 9402 | OPC_Decode, 233, 7, 157, 3, // 57: decode to BEQZALC using decoder 413 |
| 9403 | // 57: } else try { |
| 9404 | OPC_CheckPredicate, 79, // 62: check predicate 79 |
| 9405 | OPC_Decode, 236, 8, 148, 3, // 64: decode to BOVC using decoder 404 |
| 9406 | // 64: } |
| 9407 | // 64: } |
| 9408 | 22, 20, // 69: case 0x16: { |
| 9409 | OPC_Scope, 11, // 71: try { |
| 9410 | OPC_CheckField, 21, 5, 0, // 73: check Inst[25:21] == 0x0 |
| 9411 | OPC_CheckPredicate, 79, // 77: check predicate 79 |
| 9412 | OPC_Decode, 171, 8, 155, 3, // 79: decode to BLEZC using decoder 411 |
| 9413 | // 79: } else try { |
| 9414 | OPC_CheckPredicate, 79, // 84: check predicate 79 |
| 9415 | OPC_Decode, 242, 7, 155, 3, // 86: decode to BGEC using decoder 411 |
| 9416 | // 86: } |
| 9417 | // 86: } |
| 9418 | 23, 20, // 91: case 0x17: { |
| 9419 | OPC_Scope, 11, // 93: try { |
| 9420 | OPC_CheckField, 21, 5, 0, // 95: check Inst[25:21] == 0x0 |
| 9421 | OPC_CheckPredicate, 79, // 99: check predicate 79 |
| 9422 | OPC_Decode, 141, 8, 156, 3, // 101: decode to BGTZC using decoder 412 |
| 9423 | // 101: } else try { |
| 9424 | OPC_CheckPredicate, 79, // 106: check predicate 79 |
| 9425 | OPC_Decode, 176, 8, 156, 3, // 108: decode to BLTC using decoder 412 |
| 9426 | // 108: } |
| 9427 | // 108: } |
| 9428 | 24, 0, // 113: case 0x18: { |
| 9429 | OPC_Scope, 11, // 115: try { |
| 9430 | OPC_CheckField, 21, 5, 0, // 117: check Inst[25:21] == 0x0 |
| 9431 | OPC_CheckPredicate, 79, // 121: check predicate 79 |
| 9432 | OPC_Decode, 220, 8, 157, 3, // 123: decode to BNEZALC using decoder 413 |
| 9433 | // 123: } else try { |
| 9434 | OPC_CheckPredicate, 79, // 128: check predicate 79 |
| 9435 | OPC_Decode, 229, 8, 157, 3, // 130: decode to BNVC using decoder 413 |
| 9436 | // 130: } |
| 9437 | // 130: } |
| 9438 | // 130: } // switch Inst[31:26] |
| 9439 | }; |
| 9440 | static const uint8_t DecoderTableMips32r6_64r6_BranchZero32[21] = { |
| 9441 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 9442 | 22, 7, // 3: case 0x16: { |
| 9443 | OPC_CheckPredicate, 88, // 5: check predicate 88 |
| 9444 | OPC_Decode, 133, 8, 155, 3, // 7: decode to BGEZC64 using decoder 411 |
| 9445 | // 7: } |
| 9446 | 23, 0, // 12: case 0x17: { |
| 9447 | OPC_CheckPredicate, 88, // 14: check predicate 88 |
| 9448 | OPC_Decode, 195, 8, 156, 3, // 16: decode to BLTZC64 using decoder 412 |
| 9449 | // 16: } |
| 9450 | // 16: } // switch Inst[31:26] |
| 9451 | }; |
| 9452 | static const uint8_t DecoderTableMips32r6_64r6_GP6432[159] = { |
| 9453 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 9454 | 0, 32, // 3: case 0x0: { |
| 9455 | OPC_SwitchField, 0, 11, // 5: switch Inst[10:0] { |
| 9456 | 53, 6, // 8: case 0x35: { |
| 9457 | OPC_CheckPredicate, 89, // 10: check predicate 89 |
| 9458 | OPC_Decode, 148, 21, 87, // 12: decode to SELEQZ64 using decoder 87 |
| 9459 | // 12: } |
| 9460 | 55, 6, // 16: case 0x37: { |
| 9461 | OPC_CheckPredicate, 89, // 18: check predicate 89 |
| 9462 | OPC_Decode, 155, 21, 87, // 20: decode to SELNEZ64 using decoder 87 |
| 9463 | // 20: } |
| 9464 | 137, 8, 0, // 24: case 0x409: { |
| 9465 | OPC_CheckPredicate, 78, // 27: check predicate 78 |
| 9466 | OPC_CheckField, 11, 10, 0, // 29: check Inst[20:11] == 0x0 |
| 9467 | OPC_Decode, 170, 15, 88, // 33: decode to JR_HB64_R6 using decoder 88 |
| 9468 | // 33: } |
| 9469 | // 33: } // switch Inst[10:0] |
| 9470 | // 33: } |
| 9471 | 6, 7, // 37: case 0x6: { |
| 9472 | OPC_CheckPredicate, 88, // 39: check predicate 88 |
| 9473 | OPC_Decode, 249, 7, 146, 3, // 41: decode to BGEUC64 using decoder 402 |
| 9474 | // 41: } |
| 9475 | 7, 7, // 46: case 0x7: { |
| 9476 | OPC_CheckPredicate, 88, // 48: check predicate 88 |
| 9477 | OPC_Decode, 183, 8, 147, 3, // 50: decode to BLTUC64 using decoder 403 |
| 9478 | // 50: } |
| 9479 | 8, 7, // 55: case 0x8: { |
| 9480 | OPC_CheckPredicate, 88, // 57: check predicate 88 |
| 9481 | OPC_Decode, 227, 7, 148, 3, // 59: decode to BEQC64 using decoder 404 |
| 9482 | // 59: } |
| 9483 | 22, 20, // 64: case 0x16: { |
| 9484 | OPC_Scope, 11, // 66: try { |
| 9485 | OPC_CheckField, 21, 5, 0, // 68: check Inst[25:21] == 0x0 |
| 9486 | OPC_CheckPredicate, 88, // 72: check predicate 88 |
| 9487 | OPC_Decode, 172, 8, 155, 3, // 74: decode to BLEZC64 using decoder 411 |
| 9488 | // 74: } else try { |
| 9489 | OPC_CheckPredicate, 88, // 79: check predicate 88 |
| 9490 | OPC_Decode, 243, 7, 155, 3, // 81: decode to BGEC64 using decoder 411 |
| 9491 | // 81: } |
| 9492 | // 81: } |
| 9493 | 23, 20, // 86: case 0x17: { |
| 9494 | OPC_Scope, 11, // 88: try { |
| 9495 | OPC_CheckField, 21, 5, 0, // 90: check Inst[25:21] == 0x0 |
| 9496 | OPC_CheckPredicate, 88, // 94: check predicate 88 |
| 9497 | OPC_Decode, 142, 8, 156, 3, // 96: decode to BGTZC64 using decoder 412 |
| 9498 | // 96: } else try { |
| 9499 | OPC_CheckPredicate, 88, // 101: check predicate 88 |
| 9500 | OPC_Decode, 177, 8, 156, 3, // 103: decode to BLTC64 using decoder 412 |
| 9501 | // 103: } |
| 9502 | // 103: } |
| 9503 | 24, 7, // 108: case 0x18: { |
| 9504 | OPC_CheckPredicate, 88, // 110: check predicate 88 |
| 9505 | OPC_Decode, 206, 8, 157, 3, // 112: decode to BNEC64 using decoder 413 |
| 9506 | // 112: } |
| 9507 | 54, 19, // 117: case 0x36: { |
| 9508 | OPC_Scope, 10, // 119: try { |
| 9509 | OPC_CheckField, 21, 5, 0, // 121: check Inst[25:21] == 0x0 |
| 9510 | OPC_CheckPredicate, 88, // 125: check predicate 88 |
| 9511 | OPC_Decode, 158, 15, 86, // 127: decode to JIC64 using decoder 86 |
| 9512 | // 127: } else try { |
| 9513 | OPC_CheckPredicate, 88, // 131: check predicate 88 |
| 9514 | OPC_Decode, 238, 7, 169, 3, // 133: decode to BEQZC64 using decoder 425 |
| 9515 | // 133: } |
| 9516 | // 133: } |
| 9517 | 62, 0, // 138: case 0x3e: { |
| 9518 | OPC_Scope, 10, // 140: try { |
| 9519 | OPC_CheckField, 21, 5, 0, // 142: check Inst[25:21] == 0x0 |
| 9520 | OPC_CheckPredicate, 88, // 146: check predicate 88 |
| 9521 | OPC_Decode, 155, 15, 86, // 148: decode to JIALC64 using decoder 86 |
| 9522 | // 148: } else try { |
| 9523 | OPC_CheckPredicate, 88, // 152: check predicate 88 |
| 9524 | OPC_Decode, 225, 8, 169, 3, // 154: decode to BNEZC64 using decoder 425 |
| 9525 | // 154: } |
| 9526 | // 154: } |
| 9527 | // 154: } // switch Inst[31:26] |
| 9528 | }; |
| 9529 | static const uint8_t DecoderTableMips32r6_64r6_PTR6432[29] = { |
| 9530 | OPC_SwitchField, 0, 6, // 0: switch Inst[5:0] { |
| 9531 | 38, 11, // 3: case 0x26: { |
| 9532 | OPC_CheckPredicate, 90, // 5: check predicate 90 |
| 9533 | OPC_CheckField, 26, 6, 31, // 7: check Inst[31:26] == 0x1f |
| 9534 | OPC_Decode, 233, 20, 255, 2, // 11: decode to SC64_R6 using decoder 383 |
| 9535 | // 11: } |
| 9536 | 54, 0, // 16: case 0x36: { |
| 9537 | OPC_CheckPredicate, 90, // 18: check predicate 90 |
| 9538 | OPC_CheckField, 26, 6, 31, // 20: check Inst[31:26] == 0x1f |
| 9539 | OPC_Decode, 137, 16, 254, 2, // 24: decode to LL64_R6 using decoder 382 |
| 9540 | // 24: } |
| 9541 | // 24: } // switch Inst[5:0] |
| 9542 | }; |
| 9543 | static const uint8_t DecoderTableMips6432[778] = { |
| 9544 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 9545 | 0, 163, 2, // 3: case 0x0: { |
| 9546 | OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] { |
| 9547 | 8, 10, // 9: case 0x8: { |
| 9548 | OPC_CheckPredicate, 91, // 11: check predicate 91 |
| 9549 | OPC_CheckField, 6, 15, 16, // 13: check Inst[20:6] == 0x10 |
| 9550 | OPC_Decode, 169, 15, 88, // 17: decode to JR_HB64 using decoder 88 |
| 9551 | // 17: } |
| 9552 | 9, 27, // 21: case 0x9: { |
| 9553 | OPC_SwitchField, 6, 5, // 23: switch Inst[10:6] { |
| 9554 | 0, 10, // 26: case 0x0: { |
| 9555 | OPC_CheckPredicate, 92, // 28: check predicate 92 |
| 9556 | OPC_CheckField, 16, 5, 0, // 30: check Inst[20:16] == 0x0 |
| 9557 | OPC_Decode, 137, 15, 90, // 34: decode to JALR64 using decoder 90 |
| 9558 | // 34: } |
| 9559 | 16, 0, // 38: case 0x10: { |
| 9560 | OPC_CheckPredicate, 93, // 40: check predicate 93 |
| 9561 | OPC_CheckField, 16, 5, 0, // 42: check Inst[20:16] == 0x0 |
| 9562 | OPC_Decode, 147, 15, 90, // 46: decode to JALR_HB64 using decoder 90 |
| 9563 | // 46: } |
| 9564 | // 46: } // switch Inst[10:6] |
| 9565 | // 46: } |
| 9566 | 20, 11, // 50: case 0x14: { |
| 9567 | OPC_CheckPredicate, 94, // 52: check predicate 94 |
| 9568 | OPC_CheckField, 6, 5, 0, // 54: check Inst[10:6] == 0x0 |
| 9569 | OPC_Decode, 219, 12, 170, 3, // 58: decode to DSLLV using decoder 426 |
| 9570 | // 58: } |
| 9571 | 22, 21, // 63: case 0x16: { |
| 9572 | OPC_SwitchField, 6, 5, // 65: switch Inst[10:6] { |
| 9573 | 0, 7, // 68: case 0x0: { |
| 9574 | OPC_CheckPredicate, 94, // 70: check predicate 94 |
| 9575 | OPC_Decode, 225, 12, 170, 3, // 72: decode to DSRLV using decoder 426 |
| 9576 | // 72: } |
| 9577 | 1, 0, // 77: case 0x1: { |
| 9578 | OPC_CheckPredicate, 93, // 79: check predicate 93 |
| 9579 | OPC_Decode, 212, 12, 170, 3, // 81: decode to DROTRV using decoder 426 |
| 9580 | // 81: } |
| 9581 | // 81: } // switch Inst[10:6] |
| 9582 | // 81: } |
| 9583 | 23, 11, // 86: case 0x17: { |
| 9584 | OPC_CheckPredicate, 94, // 88: check predicate 94 |
| 9585 | OPC_CheckField, 6, 5, 0, // 90: check Inst[10:6] == 0x0 |
| 9586 | OPC_Decode, 222, 12, 170, 3, // 94: decode to DSRAV using decoder 426 |
| 9587 | // 94: } |
| 9588 | 28, 11, // 99: case 0x1c: { |
| 9589 | OPC_CheckPredicate, 95, // 101: check predicate 95 |
| 9590 | OPC_CheckField, 6, 10, 0, // 103: check Inst[15:6] == 0x0 |
| 9591 | OPC_Decode, 155, 12, 171, 3, // 107: decode to DMULT using decoder 427 |
| 9592 | // 107: } |
| 9593 | 29, 11, // 112: case 0x1d: { |
| 9594 | OPC_CheckPredicate, 95, // 114: check predicate 95 |
| 9595 | OPC_CheckField, 6, 10, 0, // 116: check Inst[15:6] == 0x0 |
| 9596 | OPC_Decode, 156, 12, 171, 3, // 120: decode to DMULTu using decoder 427 |
| 9597 | // 120: } |
| 9598 | 30, 11, // 125: case 0x1e: { |
| 9599 | OPC_CheckPredicate, 95, // 127: check predicate 95 |
| 9600 | OPC_CheckField, 6, 10, 0, // 129: check Inst[15:6] == 0x0 |
| 9601 | OPC_Decode, 214, 12, 171, 3, // 133: decode to DSDIV using decoder 427 |
| 9602 | // 133: } |
| 9603 | 31, 11, // 138: case 0x1f: { |
| 9604 | OPC_CheckPredicate, 95, // 140: check predicate 95 |
| 9605 | OPC_CheckField, 6, 10, 0, // 142: check Inst[15:6] == 0x0 |
| 9606 | OPC_Decode, 228, 12, 171, 3, // 146: decode to DUDIV using decoder 427 |
| 9607 | // 146: } |
| 9608 | 44, 10, // 151: case 0x2c: { |
| 9609 | OPC_CheckPredicate, 94, // 153: check predicate 94 |
| 9610 | OPC_CheckField, 6, 5, 0, // 155: check Inst[10:6] == 0x0 |
| 9611 | OPC_Decode, 221, 11, 87, // 159: decode to DADD using decoder 87 |
| 9612 | // 159: } |
| 9613 | 45, 10, // 163: case 0x2d: { |
| 9614 | OPC_CheckPredicate, 94, // 165: check predicate 94 |
| 9615 | OPC_CheckField, 6, 5, 0, // 167: check Inst[10:6] == 0x0 |
| 9616 | OPC_Decode, 224, 11, 87, // 171: decode to DADDu using decoder 87 |
| 9617 | // 171: } |
| 9618 | 46, 10, // 175: case 0x2e: { |
| 9619 | OPC_CheckPredicate, 94, // 177: check predicate 94 |
| 9620 | OPC_CheckField, 6, 5, 0, // 179: check Inst[10:6] == 0x0 |
| 9621 | OPC_Decode, 226, 12, 87, // 183: decode to DSUB using decoder 87 |
| 9622 | // 183: } |
| 9623 | 47, 10, // 187: case 0x2f: { |
| 9624 | OPC_CheckPredicate, 94, // 189: check predicate 94 |
| 9625 | OPC_CheckField, 6, 5, 0, // 191: check Inst[10:6] == 0x0 |
| 9626 | OPC_Decode, 227, 12, 87, // 195: decode to DSUBu using decoder 87 |
| 9627 | // 195: } |
| 9628 | 56, 11, // 199: case 0x38: { |
| 9629 | OPC_CheckPredicate, 94, // 201: check predicate 94 |
| 9630 | OPC_CheckField, 21, 5, 0, // 203: check Inst[25:21] == 0x0 |
| 9631 | OPC_Decode, 216, 12, 172, 3, // 207: decode to DSLL using decoder 428 |
| 9632 | // 207: } |
| 9633 | 58, 21, // 212: case 0x3a: { |
| 9634 | OPC_SwitchField, 21, 5, // 214: switch Inst[25:21] { |
| 9635 | 0, 7, // 217: case 0x0: { |
| 9636 | OPC_CheckPredicate, 94, // 219: check predicate 94 |
| 9637 | OPC_Decode, 223, 12, 172, 3, // 221: decode to DSRL using decoder 428 |
| 9638 | // 221: } |
| 9639 | 1, 0, // 226: case 0x1: { |
| 9640 | OPC_CheckPredicate, 93, // 228: check predicate 93 |
| 9641 | OPC_Decode, 210, 12, 172, 3, // 230: decode to DROTR using decoder 428 |
| 9642 | // 230: } |
| 9643 | // 230: } // switch Inst[25:21] |
| 9644 | // 230: } |
| 9645 | 59, 11, // 235: case 0x3b: { |
| 9646 | OPC_CheckPredicate, 94, // 237: check predicate 94 |
| 9647 | OPC_CheckField, 21, 5, 0, // 239: check Inst[25:21] == 0x0 |
| 9648 | OPC_Decode, 220, 12, 172, 3, // 243: decode to DSRA using decoder 428 |
| 9649 | // 243: } |
| 9650 | 60, 11, // 248: case 0x3c: { |
| 9651 | OPC_CheckPredicate, 94, // 250: check predicate 94 |
| 9652 | OPC_CheckField, 21, 5, 0, // 252: check Inst[25:21] == 0x0 |
| 9653 | OPC_Decode, 217, 12, 172, 3, // 256: decode to DSLL32 using decoder 428 |
| 9654 | // 256: } |
| 9655 | 62, 21, // 261: case 0x3e: { |
| 9656 | OPC_SwitchField, 21, 5, // 263: switch Inst[25:21] { |
| 9657 | 0, 7, // 266: case 0x0: { |
| 9658 | OPC_CheckPredicate, 94, // 268: check predicate 94 |
| 9659 | OPC_Decode, 224, 12, 172, 3, // 270: decode to DSRL32 using decoder 428 |
| 9660 | // 270: } |
| 9661 | 1, 0, // 275: case 0x1: { |
| 9662 | OPC_CheckPredicate, 93, // 277: check predicate 93 |
| 9663 | OPC_Decode, 211, 12, 172, 3, // 279: decode to DROTR32 using decoder 428 |
| 9664 | // 279: } |
| 9665 | // 279: } // switch Inst[25:21] |
| 9666 | // 279: } |
| 9667 | 63, 0, // 284: case 0x3f: { |
| 9668 | OPC_CheckPredicate, 94, // 286: check predicate 94 |
| 9669 | OPC_CheckField, 21, 5, 0, // 288: check Inst[25:21] == 0x0 |
| 9670 | OPC_Decode, 221, 12, 172, 3, // 292: decode to DSRA32 using decoder 428 |
| 9671 | // 292: } |
| 9672 | // 292: } // switch Inst[5:0] |
| 9673 | // 292: } |
| 9674 | 16, 52, // 297: case 0x10: { |
| 9675 | OPC_SwitchField, 3, 8, // 299: switch Inst[10:3] { |
| 9676 | 0, 21, // 302: case 0x0: { |
| 9677 | OPC_SwitchField, 21, 5, // 304: switch Inst[25:21] { |
| 9678 | 1, 7, // 307: case 0x1: { |
| 9679 | OPC_CheckPredicate, 96, // 309: check predicate 96 |
| 9680 | OPC_Decode, 139, 12, 173, 3, // 311: decode to DMFC0 using decoder 429 |
| 9681 | // 311: } |
| 9682 | 5, 0, // 316: case 0x5: { |
| 9683 | OPC_CheckPredicate, 96, // 318: check predicate 96 |
| 9684 | OPC_Decode, 147, 12, 174, 3, // 320: decode to DMTC0 using decoder 430 |
| 9685 | // 320: } |
| 9686 | // 320: } // switch Inst[25:21] |
| 9687 | // 320: } |
| 9688 | 32, 11, // 325: case 0x20: { |
| 9689 | OPC_CheckPredicate, 97, // 327: check predicate 97 |
| 9690 | OPC_CheckField, 21, 5, 3, // 329: check Inst[25:21] == 0x3 |
| 9691 | OPC_Decode, 143, 12, 173, 3, // 333: decode to DMFGC0 using decoder 429 |
| 9692 | // 333: } |
| 9693 | 96, 0, // 338: case 0x60: { |
| 9694 | OPC_CheckPredicate, 97, // 340: check predicate 97 |
| 9695 | OPC_CheckField, 21, 5, 3, // 342: check Inst[25:21] == 0x3 |
| 9696 | OPC_Decode, 151, 12, 174, 3, // 346: decode to DMTGC0 using decoder 430 |
| 9697 | // 346: } |
| 9698 | // 346: } // switch Inst[10:3] |
| 9699 | // 346: } |
| 9700 | 18, 29, // 351: case 0x12: { |
| 9701 | OPC_SwitchField, 21, 5, // 353: switch Inst[25:21] { |
| 9702 | 1, 11, // 356: case 0x1: { |
| 9703 | OPC_CheckPredicate, 96, // 358: check predicate 96 |
| 9704 | OPC_CheckField, 3, 8, 0, // 360: check Inst[10:3] == 0x0 |
| 9705 | OPC_Decode, 141, 12, 175, 3, // 364: decode to DMFC2 using decoder 431 |
| 9706 | // 364: } |
| 9707 | 5, 0, // 369: case 0x5: { |
| 9708 | OPC_CheckPredicate, 96, // 371: check predicate 96 |
| 9709 | OPC_CheckField, 3, 8, 0, // 373: check Inst[10:3] == 0x0 |
| 9710 | OPC_Decode, 149, 12, 176, 3, // 377: decode to DMTC2 using decoder 432 |
| 9711 | // 377: } |
| 9712 | // 377: } // switch Inst[25:21] |
| 9713 | // 377: } |
| 9714 | 21, 163, 1, // 382: case 0x15: { |
| 9715 | OPC_SwitchField, 0, 13, // 385: switch Inst[12:0] { |
| 9716 | 188, 8, 7, // 388: case 0x43c: { |
| 9717 | OPC_CheckPredicate, 17, // 391: check predicate 17 |
| 9718 | OPC_Decode, 131, 11, 177, 3, // 393: decode to C_F_D64_MM using decoder 433 |
| 9719 | // 393: } |
| 9720 | 252, 8, 7, // 398: case 0x47c: { |
| 9721 | OPC_CheckPredicate, 17, // 401: check predicate 17 |
| 9722 | OPC_Decode, 215, 11, 177, 3, // 403: decode to C_UN_D64_MM using decoder 433 |
| 9723 | // 403: } |
| 9724 | 188, 9, 7, // 408: case 0x4bc: { |
| 9725 | OPC_CheckPredicate, 17, // 411: check predicate 17 |
| 9726 | OPC_Decode, 253, 10, 177, 3, // 413: decode to C_EQ_D64_MM using decoder 433 |
| 9727 | // 413: } |
| 9728 | 252, 9, 7, // 418: case 0x4fc: { |
| 9729 | OPC_CheckPredicate, 17, // 421: check predicate 17 |
| 9730 | OPC_Decode, 197, 11, 177, 3, // 423: decode to C_UEQ_D64_MM using decoder 433 |
| 9731 | // 423: } |
| 9732 | 188, 10, 7, // 428: case 0x53c: { |
| 9733 | OPC_CheckPredicate, 17, // 431: check predicate 17 |
| 9734 | OPC_Decode, 179, 11, 177, 3, // 433: decode to C_OLT_D64_MM using decoder 433 |
| 9735 | // 433: } |
| 9736 | 252, 10, 7, // 438: case 0x57c: { |
| 9737 | OPC_CheckPredicate, 17, // 441: check predicate 17 |
| 9738 | OPC_Decode, 209, 11, 177, 3, // 443: decode to C_ULT_D64_MM using decoder 433 |
| 9739 | // 443: } |
| 9740 | 188, 11, 7, // 448: case 0x5bc: { |
| 9741 | OPC_CheckPredicate, 17, // 451: check predicate 17 |
| 9742 | OPC_Decode, 173, 11, 177, 3, // 453: decode to C_OLE_D64_MM using decoder 433 |
| 9743 | // 453: } |
| 9744 | 252, 11, 7, // 458: case 0x5fc: { |
| 9745 | OPC_CheckPredicate, 17, // 461: check predicate 17 |
| 9746 | OPC_Decode, 203, 11, 177, 3, // 463: decode to C_ULE_D64_MM using decoder 433 |
| 9747 | // 463: } |
| 9748 | 188, 12, 7, // 468: case 0x63c: { |
| 9749 | OPC_CheckPredicate, 17, // 471: check predicate 17 |
| 9750 | OPC_Decode, 191, 11, 177, 3, // 473: decode to C_SF_D64_MM using decoder 433 |
| 9751 | // 473: } |
| 9752 | 252, 12, 7, // 478: case 0x67c: { |
| 9753 | OPC_CheckPredicate, 17, // 481: check predicate 17 |
| 9754 | OPC_Decode, 155, 11, 177, 3, // 483: decode to C_NGLE_D64_MM using decoder 433 |
| 9755 | // 483: } |
| 9756 | 188, 13, 7, // 488: case 0x6bc: { |
| 9757 | OPC_CheckPredicate, 17, // 491: check predicate 17 |
| 9758 | OPC_Decode, 185, 11, 177, 3, // 493: decode to C_SEQ_D64_MM using decoder 433 |
| 9759 | // 493: } |
| 9760 | 252, 13, 7, // 498: case 0x6fc: { |
| 9761 | OPC_CheckPredicate, 17, // 501: check predicate 17 |
| 9762 | OPC_Decode, 161, 11, 177, 3, // 503: decode to C_NGL_D64_MM using decoder 433 |
| 9763 | // 503: } |
| 9764 | 188, 14, 7, // 508: case 0x73c: { |
| 9765 | OPC_CheckPredicate, 17, // 511: check predicate 17 |
| 9766 | OPC_Decode, 143, 11, 177, 3, // 513: decode to C_LT_D64_MM using decoder 433 |
| 9767 | // 513: } |
| 9768 | 252, 14, 7, // 518: case 0x77c: { |
| 9769 | OPC_CheckPredicate, 17, // 521: check predicate 17 |
| 9770 | OPC_Decode, 149, 11, 177, 3, // 523: decode to C_NGE_D64_MM using decoder 433 |
| 9771 | // 523: } |
| 9772 | 188, 15, 7, // 528: case 0x7bc: { |
| 9773 | OPC_CheckPredicate, 17, // 531: check predicate 17 |
| 9774 | OPC_Decode, 137, 11, 177, 3, // 533: decode to C_LE_D64_MM using decoder 433 |
| 9775 | // 533: } |
| 9776 | 252, 15, 0, // 538: case 0x7fc: { |
| 9777 | OPC_CheckPredicate, 17, // 541: check predicate 17 |
| 9778 | OPC_Decode, 167, 11, 177, 3, // 543: decode to C_NGT_D64_MM using decoder 433 |
| 9779 | // 543: } |
| 9780 | // 543: } // switch Inst[12:0] |
| 9781 | // 543: } |
| 9782 | 24, 7, // 548: case 0x18: { |
| 9783 | OPC_CheckPredicate, 98, // 550: check predicate 98 |
| 9784 | OPC_Decode, 222, 11, 178, 3, // 552: decode to DADDi using decoder 434 |
| 9785 | // 552: } |
| 9786 | 25, 7, // 557: case 0x19: { |
| 9787 | OPC_CheckPredicate, 94, // 559: check predicate 94 |
| 9788 | OPC_Decode, 223, 11, 178, 3, // 561: decode to DADDiu using decoder 434 |
| 9789 | // 561: } |
| 9790 | 26, 7, // 566: case 0x1a: { |
| 9791 | OPC_CheckPredicate, 98, // 568: check predicate 98 |
| 9792 | OPC_Decode, 222, 15, 179, 3, // 570: decode to LDL using decoder 435 |
| 9793 | // 570: } |
| 9794 | 27, 7, // 575: case 0x1b: { |
| 9795 | OPC_CheckPredicate, 98, // 577: check predicate 98 |
| 9796 | OPC_Decode, 224, 15, 179, 3, // 579: decode to LDR using decoder 435 |
| 9797 | // 579: } |
| 9798 | 28, 21, // 584: case 0x1c: { |
| 9799 | OPC_SwitchField, 0, 11, // 586: switch Inst[10:0] { |
| 9800 | 36, 7, // 589: case 0x24: { |
| 9801 | OPC_CheckPredicate, 99, // 591: check predicate 99 |
| 9802 | OPC_Decode, 232, 11, 180, 3, // 593: decode to DCLZ using decoder 436 |
| 9803 | // 593: } |
| 9804 | 37, 0, // 598: case 0x25: { |
| 9805 | OPC_CheckPredicate, 99, // 600: check predicate 99 |
| 9806 | OPC_Decode, 230, 11, 180, 3, // 602: decode to DCLO using decoder 436 |
| 9807 | // 602: } |
| 9808 | // 602: } // switch Inst[10:0] |
| 9809 | // 602: } |
| 9810 | 31, 88, // 607: case 0x1f: { |
| 9811 | OPC_SwitchField, 0, 6, // 609: switch Inst[5:0] { |
| 9812 | 1, 7, // 612: case 0x1: { |
| 9813 | OPC_CheckPredicate, 93, // 614: check predicate 93 |
| 9814 | OPC_Decode, 242, 11, 181, 3, // 616: decode to DEXTM using decoder 437 |
| 9815 | // 616: } |
| 9816 | 2, 7, // 621: case 0x2: { |
| 9817 | OPC_CheckPredicate, 93, // 623: check predicate 93 |
| 9818 | OPC_Decode, 243, 11, 181, 3, // 625: decode to DEXTU using decoder 437 |
| 9819 | // 625: } |
| 9820 | 3, 7, // 630: case 0x3: { |
| 9821 | OPC_CheckPredicate, 93, // 632: check predicate 93 |
| 9822 | OPC_Decode, 240, 11, 181, 3, // 634: decode to DEXT using decoder 437 |
| 9823 | // 634: } |
| 9824 | 5, 7, // 639: case 0x5: { |
| 9825 | OPC_CheckPredicate, 93, // 641: check predicate 93 |
| 9826 | OPC_Decode, 246, 11, 182, 3, // 643: decode to DINSM using decoder 438 |
| 9827 | // 643: } |
| 9828 | 6, 7, // 648: case 0x6: { |
| 9829 | OPC_CheckPredicate, 93, // 650: check predicate 93 |
| 9830 | OPC_Decode, 247, 11, 182, 3, // 652: decode to DINSU using decoder 438 |
| 9831 | // 652: } |
| 9832 | 7, 7, // 657: case 0x7: { |
| 9833 | OPC_CheckPredicate, 93, // 659: check predicate 93 |
| 9834 | OPC_Decode, 245, 11, 182, 3, // 661: decode to DINS using decoder 438 |
| 9835 | // 661: } |
| 9836 | 36, 0, // 666: case 0x24: { |
| 9837 | OPC_SwitchField, 6, 5, // 668: switch Inst[10:6] { |
| 9838 | 2, 11, // 671: case 0x2: { |
| 9839 | OPC_CheckPredicate, 93, // 673: check predicate 93 |
| 9840 | OPC_CheckField, 21, 5, 0, // 675: check Inst[25:21] == 0x0 |
| 9841 | OPC_Decode, 213, 12, 161, 3, // 679: decode to DSBH using decoder 417 |
| 9842 | // 679: } |
| 9843 | 5, 0, // 684: case 0x5: { |
| 9844 | OPC_CheckPredicate, 93, // 686: check predicate 93 |
| 9845 | OPC_CheckField, 21, 5, 0, // 688: check Inst[25:21] == 0x0 |
| 9846 | OPC_Decode, 215, 12, 161, 3, // 692: decode to DSHD using decoder 417 |
| 9847 | // 692: } |
| 9848 | // 692: } // switch Inst[10:6] |
| 9849 | // 692: } |
| 9850 | // 692: } // switch Inst[5:0] |
| 9851 | // 692: } |
| 9852 | 39, 7, // 697: case 0x27: { |
| 9853 | OPC_CheckPredicate, 94, // 699: check predicate 94 |
| 9854 | OPC_Decode, 211, 16, 183, 3, // 701: decode to LWu using decoder 439 |
| 9855 | // 701: } |
| 9856 | 44, 7, // 706: case 0x2c: { |
| 9857 | OPC_CheckPredicate, 98, // 708: check predicate 98 |
| 9858 | OPC_Decode, 135, 21, 183, 3, // 710: decode to SDL using decoder 439 |
| 9859 | // 710: } |
| 9860 | 45, 7, // 715: case 0x2d: { |
| 9861 | OPC_CheckPredicate, 98, // 717: check predicate 98 |
| 9862 | OPC_Decode, 136, 21, 183, 3, // 719: decode to SDR using decoder 439 |
| 9863 | // 719: } |
| 9864 | 46, 7, // 724: case 0x2e: { |
| 9865 | OPC_CheckPredicate, 22, // 726: check predicate 22 |
| 9866 | OPC_Decode, 128, 21, 191, 1, // 728: decode to SDC1_MM_D64 using decoder 191 |
| 9867 | // 728: } |
| 9868 | 47, 7, // 733: case 0x2f: { |
| 9869 | OPC_CheckPredicate, 22, // 735: check predicate 22 |
| 9870 | OPC_Decode, 213, 15, 191, 1, // 737: decode to LDC1_MM_D64 using decoder 191 |
| 9871 | // 737: } |
| 9872 | 52, 7, // 742: case 0x34: { |
| 9873 | OPC_CheckPredicate, 95, // 744: check predicate 95 |
| 9874 | OPC_Decode, 138, 16, 183, 3, // 746: decode to LLD using decoder 439 |
| 9875 | // 746: } |
| 9876 | 55, 7, // 751: case 0x37: { |
| 9877 | OPC_CheckPredicate, 94, // 753: check predicate 94 |
| 9878 | OPC_Decode, 208, 15, 183, 3, // 755: decode to LD using decoder 439 |
| 9879 | // 755: } |
| 9880 | 60, 7, // 760: case 0x3c: { |
| 9881 | OPC_CheckPredicate, 100, // 762: check predicate 100 |
| 9882 | OPC_Decode, 234, 20, 184, 3, // 764: decode to SCD using decoder 440 |
| 9883 | // 764: } |
| 9884 | 63, 0, // 769: case 0x3f: { |
| 9885 | OPC_CheckPredicate, 94, // 771: check predicate 94 |
| 9886 | OPC_Decode, 243, 20, 183, 3, // 773: decode to SD using decoder 439 |
| 9887 | // 773: } |
| 9888 | // 773: } // switch Inst[31:26] |
| 9889 | }; |
| 9890 | static const uint8_t DecoderTableMipsDSP32[21] = { |
| 9891 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 9892 | 35, 7, // 3: case 0x23: { |
| 9893 | OPC_CheckPredicate, 101, // 5: check predicate 101 |
| 9894 | OPC_Decode, 170, 16, 185, 3, // 7: decode to LWDSP using decoder 441 |
| 9895 | // 7: } |
| 9896 | 43, 0, // 12: case 0x2b: { |
| 9897 | OPC_CheckPredicate, 101, // 14: check predicate 101 |
| 9898 | OPC_Decode, 165, 23, 185, 3, // 16: decode to SWDSP using decoder 441 |
| 9899 | // 16: } |
| 9900 | // 16: } // switch Inst[31:26] |
| 9901 | }; |
| 9902 | static const uint8_t DecoderTableMipsFP6432[1037] = { |
| 9903 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 9904 | 17, 152, 7, // 3: case 0x11: { |
| 9905 | OPC_SwitchField, 0, 6, // 6: switch Inst[5:0] { |
| 9906 | 0, 73, // 9: case 0x0: { |
| 9907 | OPC_SwitchField, 21, 5, // 11: switch Inst[25:21] { |
| 9908 | 0, 11, // 14: case 0x0: { |
| 9909 | OPC_CheckPredicate, 102, // 16: check predicate 102 |
| 9910 | OPC_CheckField, 6, 5, 0, // 18: check Inst[10:6] == 0x0 |
| 9911 | OPC_Decode, 161, 17, 186, 3, // 22: decode to MFC1_D64 using decoder 442 |
| 9912 | // 22: } |
| 9913 | 3, 11, // 27: case 0x3: { |
| 9914 | OPC_CheckPredicate, 103, // 29: check predicate 103 |
| 9915 | OPC_CheckField, 6, 5, 0, // 31: check Inst[10:6] == 0x0 |
| 9916 | OPC_Decode, 172, 17, 186, 3, // 35: decode to MFHC1_D64 using decoder 442 |
| 9917 | // 35: } |
| 9918 | 4, 11, // 40: case 0x4: { |
| 9919 | OPC_CheckPredicate, 102, // 42: check predicate 102 |
| 9920 | OPC_CheckField, 6, 5, 0, // 44: check Inst[10:6] == 0x0 |
| 9921 | OPC_Decode, 187, 18, 187, 3, // 48: decode to MTC1_D64 using decoder 443 |
| 9922 | // 48: } |
| 9923 | 7, 11, // 53: case 0x7: { |
| 9924 | OPC_CheckPredicate, 103, // 55: check predicate 103 |
| 9925 | OPC_CheckField, 6, 5, 0, // 57: check Inst[10:6] == 0x0 |
| 9926 | OPC_Decode, 199, 18, 188, 3, // 61: decode to MTHC1_D64 using decoder 444 |
| 9927 | // 61: } |
| 9928 | 17, 7, // 66: case 0x11: { |
| 9929 | OPC_CheckPredicate, 102, // 68: check predicate 102 |
| 9930 | OPC_Decode, 167, 13, 152, 3, // 70: decode to FADD_D64 using decoder 408 |
| 9931 | // 70: } |
| 9932 | 22, 0, // 75: case 0x16: { |
| 9933 | OPC_CheckPredicate, 104, // 77: check predicate 104 |
| 9934 | OPC_Decode, 169, 13, 152, 3, // 79: decode to FADD_PS64 using decoder 408 |
| 9935 | // 79: } |
| 9936 | // 79: } // switch Inst[25:21] |
| 9937 | // 79: } |
| 9938 | 1, 21, // 84: case 0x1: { |
| 9939 | OPC_SwitchField, 21, 5, // 86: switch Inst[25:21] { |
| 9940 | 17, 7, // 89: case 0x11: { |
| 9941 | OPC_CheckPredicate, 102, // 91: check predicate 102 |
| 9942 | OPC_Decode, 184, 14, 152, 3, // 93: decode to FSUB_D64 using decoder 408 |
| 9943 | // 93: } |
| 9944 | 22, 0, // 98: case 0x16: { |
| 9945 | OPC_CheckPredicate, 104, // 100: check predicate 104 |
| 9946 | OPC_Decode, 186, 14, 152, 3, // 102: decode to FSUB_PS64 using decoder 408 |
| 9947 | // 102: } |
| 9948 | // 102: } // switch Inst[25:21] |
| 9949 | // 102: } |
| 9950 | 2, 21, // 107: case 0x2: { |
| 9951 | OPC_SwitchField, 21, 5, // 109: switch Inst[25:21] { |
| 9952 | 17, 7, // 112: case 0x11: { |
| 9953 | OPC_CheckPredicate, 102, // 114: check predicate 102 |
| 9954 | OPC_Decode, 140, 14, 152, 3, // 116: decode to FMUL_D64 using decoder 408 |
| 9955 | // 116: } |
| 9956 | 22, 0, // 121: case 0x16: { |
| 9957 | OPC_CheckPredicate, 104, // 123: check predicate 104 |
| 9958 | OPC_Decode, 142, 14, 152, 3, // 125: decode to FMUL_PS64 using decoder 408 |
| 9959 | // 125: } |
| 9960 | // 125: } // switch Inst[25:21] |
| 9961 | // 125: } |
| 9962 | 3, 11, // 130: case 0x3: { |
| 9963 | OPC_CheckPredicate, 102, // 132: check predicate 102 |
| 9964 | OPC_CheckField, 21, 5, 17, // 134: check Inst[25:21] == 0x11 |
| 9965 | OPC_Decode, 206, 13, 152, 3, // 138: decode to FDIV_D64 using decoder 408 |
| 9966 | // 138: } |
| 9967 | 4, 12, // 143: case 0x4: { |
| 9968 | OPC_CheckPredicate, 105, // 145: check predicate 105 |
| 9969 | OPC_CheckField, 16, 10, 160, 4, // 147: check Inst[25:16] == 0x220 |
| 9970 | OPC_Decode, 176, 14, 143, 2, // 152: decode to FSQRT_D64 using decoder 271 |
| 9971 | // 152: } |
| 9972 | 5, 12, // 157: case 0x5: { |
| 9973 | OPC_CheckPredicate, 102, // 159: check predicate 102 |
| 9974 | OPC_CheckField, 16, 10, 160, 4, // 161: check Inst[25:16] == 0x220 |
| 9975 | OPC_Decode, 160, 13, 143, 2, // 166: decode to FABS_D64 using decoder 271 |
| 9976 | // 166: } |
| 9977 | 6, 12, // 171: case 0x6: { |
| 9978 | OPC_CheckPredicate, 102, // 173: check predicate 102 |
| 9979 | OPC_CheckField, 16, 10, 160, 4, // 175: check Inst[25:16] == 0x220 |
| 9980 | OPC_Decode, 129, 14, 143, 2, // 180: decode to FMOV_D64 using decoder 271 |
| 9981 | // 180: } |
| 9982 | 7, 12, // 185: case 0x7: { |
| 9983 | OPC_CheckPredicate, 102, // 187: check predicate 102 |
| 9984 | OPC_CheckField, 16, 10, 160, 4, // 189: check Inst[25:16] == 0x220 |
| 9985 | OPC_Decode, 149, 14, 143, 2, // 194: decode to FNEG_D64 using decoder 271 |
| 9986 | // 194: } |
| 9987 | 8, 23, // 199: case 0x8: { |
| 9988 | OPC_SwitchField, 16, 10, // 201: switch Inst[25:16] { |
| 9989 | 128, 4, 7, // 204: case 0x200: { |
| 9990 | OPC_CheckPredicate, 105, // 207: check predicate 105 |
| 9991 | OPC_Decode, 189, 20, 136, 2, // 209: decode to ROUND_L_S using decoder 264 |
| 9992 | // 209: } |
| 9993 | 160, 4, 0, // 214: case 0x220: { |
| 9994 | OPC_CheckPredicate, 106, // 217: check predicate 106 |
| 9995 | OPC_Decode, 187, 20, 143, 2, // 219: decode to ROUND_L_D64 using decoder 271 |
| 9996 | // 219: } |
| 9997 | // 219: } // switch Inst[25:16] |
| 9998 | // 219: } |
| 9999 | 9, 23, // 224: case 0x9: { |
| 10000 | OPC_SwitchField, 16, 10, // 226: switch Inst[25:16] { |
| 10001 | 128, 4, 7, // 229: case 0x200: { |
| 10002 | OPC_CheckPredicate, 105, // 232: check predicate 105 |
| 10003 | OPC_Decode, 155, 24, 136, 2, // 234: decode to TRUNC_L_S using decoder 264 |
| 10004 | // 234: } |
| 10005 | 160, 4, 0, // 239: case 0x220: { |
| 10006 | OPC_CheckPredicate, 106, // 242: check predicate 106 |
| 10007 | OPC_Decode, 153, 24, 143, 2, // 244: decode to TRUNC_L_D64 using decoder 271 |
| 10008 | // 244: } |
| 10009 | // 244: } // switch Inst[25:16] |
| 10010 | // 244: } |
| 10011 | 10, 23, // 249: case 0xa: { |
| 10012 | OPC_SwitchField, 16, 10, // 251: switch Inst[25:16] { |
| 10013 | 128, 4, 7, // 254: case 0x200: { |
| 10014 | OPC_CheckPredicate, 105, // 257: check predicate 105 |
| 10015 | OPC_Decode, 157, 9, 136, 2, // 259: decode to CEIL_L_S using decoder 264 |
| 10016 | // 259: } |
| 10017 | 160, 4, 0, // 264: case 0x220: { |
| 10018 | OPC_CheckPredicate, 106, // 267: check predicate 106 |
| 10019 | OPC_Decode, 155, 9, 143, 2, // 269: decode to CEIL_L_D64 using decoder 271 |
| 10020 | // 269: } |
| 10021 | // 269: } // switch Inst[25:16] |
| 10022 | // 269: } |
| 10023 | 11, 23, // 274: case 0xb: { |
| 10024 | OPC_SwitchField, 16, 10, // 276: switch Inst[25:16] { |
| 10025 | 128, 4, 7, // 279: case 0x200: { |
| 10026 | OPC_CheckPredicate, 105, // 282: check predicate 105 |
| 10027 | OPC_Decode, 236, 13, 136, 2, // 284: decode to FLOOR_L_S using decoder 264 |
| 10028 | // 284: } |
| 10029 | 160, 4, 0, // 289: case 0x220: { |
| 10030 | OPC_CheckPredicate, 106, // 292: check predicate 106 |
| 10031 | OPC_Decode, 234, 13, 143, 2, // 294: decode to FLOOR_L_D64 using decoder 271 |
| 10032 | // 294: } |
| 10033 | // 294: } // switch Inst[25:16] |
| 10034 | // 294: } |
| 10035 | 12, 12, // 299: case 0xc: { |
| 10036 | OPC_CheckPredicate, 105, // 301: check predicate 105 |
| 10037 | OPC_CheckField, 16, 10, 160, 4, // 303: check Inst[25:16] == 0x220 |
| 10038 | OPC_Decode, 192, 20, 189, 3, // 308: decode to ROUND_W_D64 using decoder 445 |
| 10039 | // 308: } |
| 10040 | 13, 12, // 313: case 0xd: { |
| 10041 | OPC_CheckPredicate, 105, // 315: check predicate 105 |
| 10042 | OPC_CheckField, 16, 10, 160, 4, // 317: check Inst[25:16] == 0x220 |
| 10043 | OPC_Decode, 158, 24, 189, 3, // 322: decode to TRUNC_W_D64 using decoder 445 |
| 10044 | // 322: } |
| 10045 | 14, 12, // 327: case 0xe: { |
| 10046 | OPC_CheckPredicate, 105, // 329: check predicate 105 |
| 10047 | OPC_CheckField, 16, 10, 160, 4, // 331: check Inst[25:16] == 0x220 |
| 10048 | OPC_Decode, 160, 9, 189, 3, // 336: decode to CEIL_W_D64 using decoder 445 |
| 10049 | // 336: } |
| 10050 | 15, 12, // 341: case 0xf: { |
| 10051 | OPC_CheckPredicate, 105, // 343: check predicate 105 |
| 10052 | OPC_CheckField, 16, 10, 160, 4, // 345: check Inst[25:16] == 0x220 |
| 10053 | OPC_Decode, 239, 13, 189, 3, // 350: decode to FLOOR_W_D64 using decoder 445 |
| 10054 | // 350: } |
| 10055 | 17, 29, // 355: case 0x11: { |
| 10056 | OPC_SwitchField, 16, 2, // 357: switch Inst[17:16] { |
| 10057 | 0, 11, // 360: case 0x0: { |
| 10058 | OPC_CheckPredicate, 107, // 362: check predicate 107 |
| 10059 | OPC_CheckField, 21, 5, 17, // 364: check Inst[25:21] == 0x11 |
| 10060 | OPC_Decode, 245, 17, 190, 3, // 368: decode to MOVF_D64 using decoder 446 |
| 10061 | // 368: } |
| 10062 | 1, 0, // 373: case 0x1: { |
| 10063 | OPC_CheckPredicate, 107, // 375: check predicate 107 |
| 10064 | OPC_CheckField, 21, 5, 17, // 377: check Inst[25:21] == 0x11 |
| 10065 | OPC_Decode, 138, 18, 190, 3, // 381: decode to MOVT_D64 using decoder 446 |
| 10066 | // 381: } |
| 10067 | // 381: } // switch Inst[17:16] |
| 10068 | // 381: } |
| 10069 | 18, 11, // 386: case 0x12: { |
| 10070 | OPC_CheckPredicate, 107, // 388: check predicate 107 |
| 10071 | OPC_CheckField, 21, 5, 17, // 390: check Inst[25:21] == 0x11 |
| 10072 | OPC_Decode, 150, 18, 191, 3, // 394: decode to MOVZ_I_D64 using decoder 447 |
| 10073 | // 394: } |
| 10074 | 19, 11, // 399: case 0x13: { |
| 10075 | OPC_CheckPredicate, 107, // 401: check predicate 107 |
| 10076 | OPC_CheckField, 21, 5, 17, // 403: check Inst[25:21] == 0x11 |
| 10077 | OPC_Decode, 129, 18, 191, 3, // 407: decode to MOVN_I_D64 using decoder 447 |
| 10078 | // 407: } |
| 10079 | 21, 12, // 412: case 0x15: { |
| 10080 | OPC_CheckPredicate, 108, // 414: check predicate 108 |
| 10081 | OPC_CheckField, 16, 10, 160, 4, // 416: check Inst[25:16] == 0x220 |
| 10082 | OPC_Decode, 161, 20, 143, 2, // 421: decode to RECIP_D64 using decoder 271 |
| 10083 | // 421: } |
| 10084 | 22, 12, // 426: case 0x16: { |
| 10085 | OPC_CheckPredicate, 108, // 428: check predicate 108 |
| 10086 | OPC_CheckField, 16, 10, 160, 4, // 430: check Inst[25:16] == 0x220 |
| 10087 | OPC_Decode, 200, 20, 143, 2, // 435: decode to RSQRT_D64 using decoder 271 |
| 10088 | // 435: } |
| 10089 | 24, 11, // 440: case 0x18: { |
| 10090 | OPC_CheckPredicate, 109, // 442: check predicate 109 |
| 10091 | OPC_CheckField, 21, 5, 22, // 444: check Inst[25:21] == 0x16 |
| 10092 | OPC_Decode, 191, 6, 152, 3, // 448: decode to ADDR_PS64 using decoder 408 |
| 10093 | // 448: } |
| 10094 | 26, 11, // 453: case 0x1a: { |
| 10095 | OPC_CheckPredicate, 109, // 455: check predicate 109 |
| 10096 | OPC_CheckField, 21, 5, 22, // 457: check Inst[25:21] == 0x16 |
| 10097 | OPC_Decode, 247, 18, 152, 3, // 461: decode to MULR_PS64 using decoder 408 |
| 10098 | // 461: } |
| 10099 | 32, 33, // 466: case 0x20: { |
| 10100 | OPC_SwitchField, 16, 10, // 468: switch Inst[25:16] { |
| 10101 | 160, 4, 7, // 471: case 0x220: { |
| 10102 | OPC_CheckPredicate, 102, // 474: check predicate 102 |
| 10103 | OPC_Decode, 234, 10, 189, 3, // 476: decode to CVT_S_D64 using decoder 445 |
| 10104 | // 476: } |
| 10105 | 160, 5, 7, // 481: case 0x2a0: { |
| 10106 | OPC_CheckPredicate, 110, // 484: check predicate 110 |
| 10107 | OPC_Decode, 236, 10, 189, 3, // 486: decode to CVT_S_L using decoder 445 |
| 10108 | // 486: } |
| 10109 | 192, 5, 0, // 491: case 0x2c0: { |
| 10110 | OPC_CheckPredicate, 104, // 494: check predicate 104 |
| 10111 | OPC_Decode, 239, 10, 189, 3, // 496: decode to CVT_S_PU64 using decoder 445 |
| 10112 | // 496: } |
| 10113 | // 496: } // switch Inst[25:16] |
| 10114 | // 496: } |
| 10115 | 33, 33, // 501: case 0x21: { |
| 10116 | OPC_SwitchField, 16, 10, // 503: switch Inst[25:16] { |
| 10117 | 128, 4, 7, // 506: case 0x200: { |
| 10118 | OPC_CheckPredicate, 102, // 509: check predicate 102 |
| 10119 | OPC_Decode, 218, 10, 136, 2, // 511: decode to CVT_D64_S using decoder 264 |
| 10120 | // 511: } |
| 10121 | 128, 5, 7, // 516: case 0x280: { |
| 10122 | OPC_CheckPredicate, 102, // 519: check predicate 102 |
| 10123 | OPC_Decode, 220, 10, 136, 2, // 521: decode to CVT_D64_W using decoder 264 |
| 10124 | // 521: } |
| 10125 | 160, 5, 0, // 526: case 0x2a0: { |
| 10126 | OPC_CheckPredicate, 110, // 529: check predicate 110 |
| 10127 | OPC_Decode, 217, 10, 143, 2, // 531: decode to CVT_D64_L using decoder 271 |
| 10128 | // 531: } |
| 10129 | // 531: } // switch Inst[25:16] |
| 10130 | // 531: } |
| 10131 | 36, 23, // 536: case 0x24: { |
| 10132 | OPC_SwitchField, 16, 10, // 538: switch Inst[25:16] { |
| 10133 | 160, 4, 7, // 541: case 0x220: { |
| 10134 | OPC_CheckPredicate, 102, // 544: check predicate 102 |
| 10135 | OPC_Decode, 245, 10, 189, 3, // 546: decode to CVT_W_D64 using decoder 445 |
| 10136 | // 546: } |
| 10137 | 192, 5, 0, // 551: case 0x2c0: { |
| 10138 | OPC_CheckPredicate, 109, // 554: check predicate 109 |
| 10139 | OPC_Decode, 231, 10, 143, 2, // 556: decode to CVT_PW_PS64 using decoder 271 |
| 10140 | // 556: } |
| 10141 | // 556: } // switch Inst[25:16] |
| 10142 | // 556: } |
| 10143 | 38, 25, // 561: case 0x26: { |
| 10144 | OPC_SwitchField, 21, 5, // 563: switch Inst[25:21] { |
| 10145 | 16, 7, // 566: case 0x10: { |
| 10146 | OPC_CheckPredicate, 104, // 568: check predicate 104 |
| 10147 | OPC_Decode, 230, 10, 192, 3, // 570: decode to CVT_PS_S64 using decoder 448 |
| 10148 | // 570: } |
| 10149 | 20, 0, // 575: case 0x14: { |
| 10150 | OPC_CheckPredicate, 109, // 577: check predicate 109 |
| 10151 | OPC_CheckField, 16, 5, 0, // 579: check Inst[20:16] == 0x0 |
| 10152 | OPC_Decode, 229, 10, 143, 2, // 583: decode to CVT_PS_PW64 using decoder 271 |
| 10153 | // 583: } |
| 10154 | // 583: } // switch Inst[25:21] |
| 10155 | // 583: } |
| 10156 | 40, 12, // 588: case 0x28: { |
| 10157 | OPC_CheckPredicate, 104, // 590: check predicate 104 |
| 10158 | OPC_CheckField, 16, 10, 192, 5, // 592: check Inst[25:16] == 0x2c0 |
| 10159 | OPC_Decode, 238, 10, 189, 3, // 597: decode to CVT_S_PL64 using decoder 445 |
| 10160 | // 597: } |
| 10161 | 44, 11, // 602: case 0x2c: { |
| 10162 | OPC_CheckPredicate, 104, // 604: check predicate 104 |
| 10163 | OPC_CheckField, 21, 5, 22, // 606: check Inst[25:21] == 0x16 |
| 10164 | OPC_Decode, 226, 19, 152, 3, // 610: decode to PLL_PS64 using decoder 408 |
| 10165 | // 610: } |
| 10166 | 45, 11, // 615: case 0x2d: { |
| 10167 | OPC_CheckPredicate, 104, // 617: check predicate 104 |
| 10168 | OPC_CheckField, 21, 5, 22, // 619: check Inst[25:21] == 0x16 |
| 10169 | OPC_Decode, 227, 19, 152, 3, // 623: decode to PLU_PS64 using decoder 408 |
| 10170 | // 623: } |
| 10171 | 46, 11, // 628: case 0x2e: { |
| 10172 | OPC_CheckPredicate, 104, // 630: check predicate 104 |
| 10173 | OPC_CheckField, 21, 5, 22, // 632: check Inst[25:21] == 0x16 |
| 10174 | OPC_Decode, 146, 20, 152, 3, // 636: decode to PUL_PS64 using decoder 408 |
| 10175 | // 636: } |
| 10176 | 47, 11, // 641: case 0x2f: { |
| 10177 | OPC_CheckPredicate, 104, // 643: check predicate 104 |
| 10178 | OPC_CheckField, 21, 5, 22, // 645: check Inst[25:21] == 0x16 |
| 10179 | OPC_Decode, 147, 20, 152, 3, // 649: decode to PUU_PS64 using decoder 408 |
| 10180 | // 649: } |
| 10181 | 48, 15, // 654: case 0x30: { |
| 10182 | OPC_CheckPredicate, 111, // 656: check predicate 111 |
| 10183 | OPC_CheckField, 21, 5, 17, // 658: check Inst[25:21] == 0x11 |
| 10184 | OPC_CheckField, 6, 2, 0, // 662: check Inst[7:6] == 0x0 |
| 10185 | OPC_Decode, 130, 11, 193, 3, // 666: decode to C_F_D64 using decoder 449 |
| 10186 | // 666: } |
| 10187 | 49, 15, // 671: case 0x31: { |
| 10188 | OPC_CheckPredicate, 111, // 673: check predicate 111 |
| 10189 | OPC_CheckField, 21, 5, 17, // 675: check Inst[25:21] == 0x11 |
| 10190 | OPC_CheckField, 6, 2, 0, // 679: check Inst[7:6] == 0x0 |
| 10191 | OPC_Decode, 214, 11, 193, 3, // 683: decode to C_UN_D64 using decoder 449 |
| 10192 | // 683: } |
| 10193 | 50, 15, // 688: case 0x32: { |
| 10194 | OPC_CheckPredicate, 111, // 690: check predicate 111 |
| 10195 | OPC_CheckField, 21, 5, 17, // 692: check Inst[25:21] == 0x11 |
| 10196 | OPC_CheckField, 6, 2, 0, // 696: check Inst[7:6] == 0x0 |
| 10197 | OPC_Decode, 252, 10, 193, 3, // 700: decode to C_EQ_D64 using decoder 449 |
| 10198 | // 700: } |
| 10199 | 51, 15, // 705: case 0x33: { |
| 10200 | OPC_CheckPredicate, 111, // 707: check predicate 111 |
| 10201 | OPC_CheckField, 21, 5, 17, // 709: check Inst[25:21] == 0x11 |
| 10202 | OPC_CheckField, 6, 2, 0, // 713: check Inst[7:6] == 0x0 |
| 10203 | OPC_Decode, 196, 11, 193, 3, // 717: decode to C_UEQ_D64 using decoder 449 |
| 10204 | // 717: } |
| 10205 | 52, 15, // 722: case 0x34: { |
| 10206 | OPC_CheckPredicate, 111, // 724: check predicate 111 |
| 10207 | OPC_CheckField, 21, 5, 17, // 726: check Inst[25:21] == 0x11 |
| 10208 | OPC_CheckField, 6, 2, 0, // 730: check Inst[7:6] == 0x0 |
| 10209 | OPC_Decode, 178, 11, 193, 3, // 734: decode to C_OLT_D64 using decoder 449 |
| 10210 | // 734: } |
| 10211 | 53, 15, // 739: case 0x35: { |
| 10212 | OPC_CheckPredicate, 111, // 741: check predicate 111 |
| 10213 | OPC_CheckField, 21, 5, 17, // 743: check Inst[25:21] == 0x11 |
| 10214 | OPC_CheckField, 6, 2, 0, // 747: check Inst[7:6] == 0x0 |
| 10215 | OPC_Decode, 208, 11, 193, 3, // 751: decode to C_ULT_D64 using decoder 449 |
| 10216 | // 751: } |
| 10217 | 54, 15, // 756: case 0x36: { |
| 10218 | OPC_CheckPredicate, 111, // 758: check predicate 111 |
| 10219 | OPC_CheckField, 21, 5, 17, // 760: check Inst[25:21] == 0x11 |
| 10220 | OPC_CheckField, 6, 2, 0, // 764: check Inst[7:6] == 0x0 |
| 10221 | OPC_Decode, 172, 11, 193, 3, // 768: decode to C_OLE_D64 using decoder 449 |
| 10222 | // 768: } |
| 10223 | 55, 15, // 773: case 0x37: { |
| 10224 | OPC_CheckPredicate, 111, // 775: check predicate 111 |
| 10225 | OPC_CheckField, 21, 5, 17, // 777: check Inst[25:21] == 0x11 |
| 10226 | OPC_CheckField, 6, 2, 0, // 781: check Inst[7:6] == 0x0 |
| 10227 | OPC_Decode, 202, 11, 193, 3, // 785: decode to C_ULE_D64 using decoder 449 |
| 10228 | // 785: } |
| 10229 | 56, 15, // 790: case 0x38: { |
| 10230 | OPC_CheckPredicate, 111, // 792: check predicate 111 |
| 10231 | OPC_CheckField, 21, 5, 17, // 794: check Inst[25:21] == 0x11 |
| 10232 | OPC_CheckField, 6, 2, 0, // 798: check Inst[7:6] == 0x0 |
| 10233 | OPC_Decode, 190, 11, 193, 3, // 802: decode to C_SF_D64 using decoder 449 |
| 10234 | // 802: } |
| 10235 | 57, 15, // 807: case 0x39: { |
| 10236 | OPC_CheckPredicate, 111, // 809: check predicate 111 |
| 10237 | OPC_CheckField, 21, 5, 17, // 811: check Inst[25:21] == 0x11 |
| 10238 | OPC_CheckField, 6, 2, 0, // 815: check Inst[7:6] == 0x0 |
| 10239 | OPC_Decode, 154, 11, 193, 3, // 819: decode to C_NGLE_D64 using decoder 449 |
| 10240 | // 819: } |
| 10241 | 58, 15, // 824: case 0x3a: { |
| 10242 | OPC_CheckPredicate, 111, // 826: check predicate 111 |
| 10243 | OPC_CheckField, 21, 5, 17, // 828: check Inst[25:21] == 0x11 |
| 10244 | OPC_CheckField, 6, 2, 0, // 832: check Inst[7:6] == 0x0 |
| 10245 | OPC_Decode, 184, 11, 193, 3, // 836: decode to C_SEQ_D64 using decoder 449 |
| 10246 | // 836: } |
| 10247 | 59, 15, // 841: case 0x3b: { |
| 10248 | OPC_CheckPredicate, 111, // 843: check predicate 111 |
| 10249 | OPC_CheckField, 21, 5, 17, // 845: check Inst[25:21] == 0x11 |
| 10250 | OPC_CheckField, 6, 2, 0, // 849: check Inst[7:6] == 0x0 |
| 10251 | OPC_Decode, 160, 11, 193, 3, // 853: decode to C_NGL_D64 using decoder 449 |
| 10252 | // 853: } |
| 10253 | 60, 15, // 858: case 0x3c: { |
| 10254 | OPC_CheckPredicate, 111, // 860: check predicate 111 |
| 10255 | OPC_CheckField, 21, 5, 17, // 862: check Inst[25:21] == 0x11 |
| 10256 | OPC_CheckField, 6, 2, 0, // 866: check Inst[7:6] == 0x0 |
| 10257 | OPC_Decode, 142, 11, 193, 3, // 870: decode to C_LT_D64 using decoder 449 |
| 10258 | // 870: } |
| 10259 | 61, 15, // 875: case 0x3d: { |
| 10260 | OPC_CheckPredicate, 111, // 877: check predicate 111 |
| 10261 | OPC_CheckField, 21, 5, 17, // 879: check Inst[25:21] == 0x11 |
| 10262 | OPC_CheckField, 6, 2, 0, // 883: check Inst[7:6] == 0x0 |
| 10263 | OPC_Decode, 148, 11, 193, 3, // 887: decode to C_NGE_D64 using decoder 449 |
| 10264 | // 887: } |
| 10265 | 62, 15, // 892: case 0x3e: { |
| 10266 | OPC_CheckPredicate, 111, // 894: check predicate 111 |
| 10267 | OPC_CheckField, 21, 5, 17, // 896: check Inst[25:21] == 0x11 |
| 10268 | OPC_CheckField, 6, 2, 0, // 900: check Inst[7:6] == 0x0 |
| 10269 | OPC_Decode, 136, 11, 193, 3, // 904: decode to C_LE_D64 using decoder 449 |
| 10270 | // 904: } |
| 10271 | 63, 0, // 909: case 0x3f: { |
| 10272 | OPC_CheckPredicate, 111, // 911: check predicate 111 |
| 10273 | OPC_CheckField, 21, 5, 17, // 913: check Inst[25:21] == 0x11 |
| 10274 | OPC_CheckField, 6, 2, 0, // 917: check Inst[7:6] == 0x0 |
| 10275 | OPC_Decode, 166, 11, 193, 3, // 921: decode to C_NGT_D64 using decoder 449 |
| 10276 | // 921: } |
| 10277 | // 921: } // switch Inst[5:0] |
| 10278 | // 921: } |
| 10279 | 19, 91, // 926: case 0x13: { |
| 10280 | OPC_SwitchField, 0, 6, // 928: switch Inst[5:0] { |
| 10281 | 1, 11, // 931: case 0x1: { |
| 10282 | OPC_CheckPredicate, 112, // 933: check predicate 112 |
| 10283 | OPC_CheckField, 11, 5, 0, // 935: check Inst[15:11] == 0x0 |
| 10284 | OPC_Decode, 226, 15, 194, 3, // 939: decode to LDXC164 using decoder 450 |
| 10285 | // 939: } |
| 10286 | 5, 11, // 944: case 0x5: { |
| 10287 | OPC_CheckPredicate, 113, // 946: check predicate 113 |
| 10288 | OPC_CheckField, 11, 5, 0, // 948: check Inst[15:11] == 0x0 |
| 10289 | OPC_Decode, 154, 16, 194, 3, // 952: decode to LUXC164 using decoder 450 |
| 10290 | // 952: } |
| 10291 | 9, 11, // 957: case 0x9: { |
| 10292 | OPC_CheckPredicate, 112, // 959: check predicate 112 |
| 10293 | OPC_CheckField, 6, 5, 0, // 961: check Inst[10:6] == 0x0 |
| 10294 | OPC_Decode, 138, 21, 195, 3, // 965: decode to SDXC164 using decoder 451 |
| 10295 | // 965: } |
| 10296 | 13, 11, // 970: case 0xd: { |
| 10297 | OPC_CheckPredicate, 113, // 972: check predicate 113 |
| 10298 | OPC_CheckField, 6, 5, 0, // 974: check Inst[10:6] == 0x0 |
| 10299 | OPC_Decode, 151, 23, 195, 3, // 978: decode to SUXC164 using decoder 451 |
| 10300 | // 978: } |
| 10301 | 33, 7, // 983: case 0x21: { |
| 10302 | OPC_CheckPredicate, 114, // 985: check predicate 114 |
| 10303 | OPC_Decode, 240, 16, 196, 3, // 987: decode to MADD_D64 using decoder 452 |
| 10304 | // 987: } |
| 10305 | 41, 7, // 992: case 0x29: { |
| 10306 | OPC_CheckPredicate, 114, // 994: check predicate 114 |
| 10307 | OPC_Decode, 174, 18, 196, 3, // 996: decode to MSUB_D64 using decoder 452 |
| 10308 | // 996: } |
| 10309 | 49, 7, // 1001: case 0x31: { |
| 10310 | OPC_CheckPredicate, 115, // 1003: check predicate 115 |
| 10311 | OPC_Decode, 166, 19, 196, 3, // 1005: decode to NMADD_D64 using decoder 452 |
| 10312 | // 1005: } |
| 10313 | 57, 0, // 1010: case 0x39: { |
| 10314 | OPC_CheckPredicate, 115, // 1012: check predicate 115 |
| 10315 | OPC_Decode, 171, 19, 196, 3, // 1014: decode to NMSUB_D64 using decoder 452 |
| 10316 | // 1014: } |
| 10317 | // 1014: } // switch Inst[5:0] |
| 10318 | // 1014: } |
| 10319 | 53, 7, // 1019: case 0x35: { |
| 10320 | OPC_CheckPredicate, 105, // 1021: check predicate 105 |
| 10321 | OPC_Decode, 210, 15, 142, 3, // 1023: decode to LDC164 using decoder 398 |
| 10322 | // 1023: } |
| 10323 | 61, 0, // 1028: case 0x3d: { |
| 10324 | OPC_CheckPredicate, 105, // 1030: check predicate 105 |
| 10325 | OPC_Decode, 253, 20, 142, 3, // 1032: decode to SDC164 using decoder 398 |
| 10326 | // 1032: } |
| 10327 | // 1032: } // switch Inst[31:26] |
| 10328 | }; |
| 10329 | static const uint8_t DecoderTableNanoMips32[1722] = { |
| 10330 | OPC_SwitchField, 26, 6, // 0: switch Inst[31:26] { |
| 10331 | 0, 52, // 3: case 0x0: { |
| 10332 | OPC_Scope, 11, // 5: try { |
| 10333 | OPC_CheckField, 18, 8, 2, // 7: check Inst[25:18] == 0x2 |
| 10334 | OPC_CheckPredicate, 4, // 11: check predicate 4 |
| 10335 | OPC_Decode, 210, 23, 197, 3, // 13: decode to SYSCALL_NM using decoder 453 |
| 10336 | OPC_Scope, 30, // 18: } else try { |
| 10337 | OPC_SwitchField, 19, 7, // 20: switch Inst[25:19] { |
| 10338 | 0, 7, // 23: case 0x0: { |
| 10339 | OPC_CheckPredicate, 4, // 25: check predicate 4 |
| 10340 | OPC_Decode, 235, 21, 198, 3, // 27: decode to SIGRIE_NM using decoder 454 |
| 10341 | // 27: } |
| 10342 | 2, 7, // 32: case 0x2: { |
| 10343 | OPC_CheckPredicate, 4, // 34: check predicate 4 |
| 10344 | OPC_Decode, 247, 8, 198, 3, // 36: decode to BREAK_NM using decoder 454 |
| 10345 | // 36: } |
| 10346 | 3, 0, // 41: case 0x3: { |
| 10347 | OPC_CheckPredicate, 4, // 43: check predicate 4 |
| 10348 | OPC_Decode, 250, 20, 198, 3, // 45: decode to SDBBP_NM using decoder 454 |
| 10349 | // 45: } |
| 10350 | // 45: } // switch Inst[25:19] |
| 10351 | // 45: } else try { |
| 10352 | OPC_CheckPredicate, 4, // 50: check predicate 4 |
| 10353 | OPC_Decode, 176, 6, 153, 1, // 52: decode to ADDIU_NM using decoder 153 |
| 10354 | // 52: } |
| 10355 | // 52: } |
| 10356 | 1, 7, // 57: case 0x1: { |
| 10357 | OPC_CheckPredicate, 4, // 59: check predicate 4 |
| 10358 | OPC_Decode, 181, 15, 199, 3, // 61: decode to LAPC32_NM using decoder 455 |
| 10359 | // 61: } |
| 10360 | 2, 7, // 66: case 0x2: { |
| 10361 | OPC_CheckPredicate, 4, // 68: check predicate 4 |
| 10362 | OPC_Decode, 236, 17, 200, 3, // 70: decode to MOVEBALC_NM using decoder 456 |
| 10363 | // 70: } |
| 10364 | 8, 151, 5, // 75: case 0x8: { |
| 10365 | OPC_SwitchField, 0, 6, // 78: switch Inst[5:0] { |
| 10366 | 0, 35, // 81: case 0x0: { |
| 10367 | OPC_SwitchField, 6, 4, // 83: switch Inst[9:6] { |
| 10368 | 0, 21, // 86: case 0x0: { |
| 10369 | OPC_SwitchField, 10, 1, // 88: switch Inst[10] { |
| 10370 | 0, 7, // 91: case 0x0: { |
| 10371 | OPC_CheckPredicate, 4, // 93: check predicate 4 |
| 10372 | OPC_Decode, 236, 23, 201, 3, // 95: decode to TEQ_NM using decoder 457 |
| 10373 | // 95: } |
| 10374 | 1, 0, // 100: case 0x1: { |
| 10375 | OPC_CheckPredicate, 4, // 102: check predicate 4 |
| 10376 | OPC_Decode, 152, 24, 201, 3, // 104: decode to TNE_NM using decoder 457 |
| 10377 | // 104: } |
| 10378 | // 104: } // switch Inst[10] |
| 10379 | // 104: } |
| 10380 | 7, 0, // 109: case 0x7: { |
| 10381 | OPC_CheckPredicate, 4, // 111: check predicate 4 |
| 10382 | OPC_Decode, 156, 20, 202, 3, // 113: decode to RDHWR_NM using decoder 458 |
| 10383 | // 113: } |
| 10384 | // 113: } // switch Inst[9:6] |
| 10385 | // 113: } |
| 10386 | 7, 120, // 118: case 0x7: { |
| 10387 | OPC_SwitchField, 6, 5, // 120: switch Inst[10:6] { |
| 10388 | 0, 7, // 123: case 0x0: { |
| 10389 | OPC_CheckPredicate, 4, // 125: check predicate 4 |
| 10390 | OPC_Decode, 198, 15, 203, 3, // 127: decode to LBX_NM using decoder 459 |
| 10391 | // 127: } |
| 10392 | 2, 7, // 132: case 0x2: { |
| 10393 | OPC_CheckPredicate, 4, // 134: check predicate 4 |
| 10394 | OPC_Decode, 226, 20, 203, 3, // 136: decode to SBX_NM using decoder 459 |
| 10395 | // 136: } |
| 10396 | 4, 7, // 141: case 0x4: { |
| 10397 | OPC_CheckPredicate, 4, // 143: check predicate 4 |
| 10398 | OPC_Decode, 194, 15, 203, 3, // 145: decode to LBUX_NM using decoder 459 |
| 10399 | // 145: } |
| 10400 | 8, 7, // 150: case 0x8: { |
| 10401 | OPC_CheckPredicate, 4, // 152: check predicate 4 |
| 10402 | OPC_Decode, 250, 15, 203, 3, // 154: decode to LHX_NM using decoder 459 |
| 10403 | // 154: } |
| 10404 | 9, 7, // 159: case 0x9: { |
| 10405 | OPC_CheckPredicate, 4, // 161: check predicate 4 |
| 10406 | OPC_Decode, 248, 15, 203, 3, // 163: decode to LHXS_NM using decoder 459 |
| 10407 | // 163: } |
| 10408 | 10, 7, // 168: case 0xa: { |
| 10409 | OPC_CheckPredicate, 4, // 170: check predicate 4 |
| 10410 | OPC_Decode, 228, 21, 203, 3, // 172: decode to SHX_NM using decoder 459 |
| 10411 | // 172: } |
| 10412 | 11, 7, // 177: case 0xb: { |
| 10413 | OPC_CheckPredicate, 4, // 179: check predicate 4 |
| 10414 | OPC_Decode, 227, 21, 203, 3, // 181: decode to SHXS_NM using decoder 459 |
| 10415 | // 181: } |
| 10416 | 12, 7, // 186: case 0xc: { |
| 10417 | OPC_CheckPredicate, 4, // 188: check predicate 4 |
| 10418 | OPC_Decode, 244, 15, 203, 3, // 190: decode to LHUX_NM using decoder 459 |
| 10419 | // 190: } |
| 10420 | 13, 7, // 195: case 0xd: { |
| 10421 | OPC_CheckPredicate, 4, // 197: check predicate 4 |
| 10422 | OPC_Decode, 243, 15, 203, 3, // 199: decode to LHUXS_NM using decoder 459 |
| 10423 | // 199: } |
| 10424 | 16, 7, // 204: case 0x10: { |
| 10425 | OPC_CheckPredicate, 4, // 206: check predicate 4 |
| 10426 | OPC_Decode, 206, 16, 203, 3, // 208: decode to LWX_NM using decoder 459 |
| 10427 | // 208: } |
| 10428 | 17, 7, // 213: case 0x11: { |
| 10429 | OPC_CheckPredicate, 4, // 215: check predicate 4 |
| 10430 | OPC_Decode, 204, 16, 203, 3, // 217: decode to LWXS_NM using decoder 459 |
| 10431 | // 217: } |
| 10432 | 18, 7, // 222: case 0x12: { |
| 10433 | OPC_CheckPredicate, 4, // 224: check predicate 4 |
| 10434 | OPC_Decode, 193, 23, 203, 3, // 226: decode to SWX_NM using decoder 459 |
| 10435 | // 226: } |
| 10436 | 19, 0, // 231: case 0x13: { |
| 10437 | OPC_CheckPredicate, 4, // 233: check predicate 4 |
| 10438 | OPC_Decode, 192, 23, 203, 3, // 235: decode to SWXS_NM using decoder 459 |
| 10439 | // 235: } |
| 10440 | // 235: } // switch Inst[10:6] |
| 10441 | // 235: } |
| 10442 | 8, 19, // 240: case 0x8: { |
| 10443 | OPC_SwitchField, 6, 4, // 242: switch Inst[9:6] { |
| 10444 | 0, 6, // 245: case 0x0: { |
| 10445 | OPC_CheckPredicate, 4, // 247: check predicate 4 |
| 10446 | OPC_Decode, 142, 21, 123, // 249: decode to SEB_NM using decoder 123 |
| 10447 | // 249: } |
| 10448 | 1, 0, // 253: case 0x1: { |
| 10449 | OPC_CheckPredicate, 4, // 255: check predicate 4 |
| 10450 | OPC_Decode, 146, 21, 123, // 257: decode to SEH_NM using decoder 123 |
| 10451 | // 257: } |
| 10452 | // 257: } // switch Inst[9:6] |
| 10453 | // 257: } |
| 10454 | 15, 7, // 261: case 0xf: { |
| 10455 | OPC_CheckPredicate, 4, // 263: check predicate 4 |
| 10456 | OPC_Decode, 149, 16, 204, 3, // 265: decode to LSA_NM using decoder 460 |
| 10457 | // 265: } |
| 10458 | 16, 167, 1, // 270: case 0x10: { |
| 10459 | OPC_SwitchField, 6, 4, // 273: switch Inst[9:6] { |
| 10460 | 0, 6, // 276: case 0x0: { |
| 10461 | OPC_CheckPredicate, 4, // 278: check predicate 4 |
| 10462 | OPC_Decode, 128, 22, 98, // 280: decode to SLLV_NM using decoder 98 |
| 10463 | // 280: } |
| 10464 | 1, 6, // 284: case 0x1: { |
| 10465 | OPC_CheckPredicate, 4, // 286: check predicate 4 |
| 10466 | OPC_Decode, 203, 22, 98, // 288: decode to SRLV_NM using decoder 98 |
| 10467 | // 288: } |
| 10468 | 2, 6, // 292: case 0x2: { |
| 10469 | OPC_CheckPredicate, 4, // 294: check predicate 4 |
| 10470 | OPC_Decode, 178, 22, 98, // 296: decode to SRAV_NM using decoder 98 |
| 10471 | // 296: } |
| 10472 | 3, 6, // 300: case 0x3: { |
| 10473 | OPC_CheckPredicate, 4, // 302: check predicate 4 |
| 10474 | OPC_Decode, 183, 20, 98, // 304: decode to ROTRV_NM using decoder 98 |
| 10475 | // 304: } |
| 10476 | 4, 6, // 308: case 0x4: { |
| 10477 | OPC_CheckPredicate, 4, // 310: check predicate 4 |
| 10478 | OPC_Decode, 237, 6, 98, // 312: decode to ADD_NM using decoder 98 |
| 10479 | // 312: } |
| 10480 | 5, 6, // 316: case 0x5: { |
| 10481 | OPC_CheckPredicate, 4, // 318: check predicate 4 |
| 10482 | OPC_Decode, 246, 6, 98, // 320: decode to ADDu_NM using decoder 98 |
| 10483 | // 320: } |
| 10484 | 6, 6, // 324: case 0x6: { |
| 10485 | OPC_CheckPredicate, 4, // 326: check predicate 4 |
| 10486 | OPC_Decode, 145, 23, 98, // 328: decode to SUB_NM using decoder 98 |
| 10487 | // 328: } |
| 10488 | 7, 6, // 332: case 0x7: { |
| 10489 | OPC_CheckPredicate, 4, // 334: check predicate 4 |
| 10490 | OPC_Decode, 149, 23, 98, // 336: decode to SUBu_NM using decoder 98 |
| 10491 | // 336: } |
| 10492 | 8, 19, // 340: case 0x8: { |
| 10493 | OPC_SwitchField, 10, 1, // 342: switch Inst[10] { |
| 10494 | 0, 6, // 345: case 0x0: { |
| 10495 | OPC_CheckPredicate, 4, // 347: check predicate 4 |
| 10496 | OPC_Decode, 156, 18, 106, // 349: decode to MOVZ_NM using decoder 106 |
| 10497 | // 349: } |
| 10498 | 1, 0, // 353: case 0x1: { |
| 10499 | OPC_CheckPredicate, 4, // 355: check predicate 4 |
| 10500 | OPC_Decode, 135, 18, 106, // 357: decode to MOVN_NM using decoder 106 |
| 10501 | // 357: } |
| 10502 | // 357: } // switch Inst[10] |
| 10503 | // 357: } |
| 10504 | 9, 6, // 361: case 0x9: { |
| 10505 | OPC_CheckPredicate, 4, // 363: check predicate 4 |
| 10506 | OPC_Decode, 137, 7, 98, // 365: decode to AND_NM using decoder 98 |
| 10507 | // 365: } |
| 10508 | 10, 6, // 369: case 0xa: { |
| 10509 | OPC_CheckPredicate, 4, // 371: check predicate 4 |
| 10510 | OPC_Decode, 198, 19, 98, // 373: decode to OR_NM using decoder 98 |
| 10511 | // 373: } |
| 10512 | 11, 6, // 377: case 0xb: { |
| 10513 | OPC_CheckPredicate, 4, // 379: check predicate 4 |
| 10514 | OPC_Decode, 181, 19, 98, // 381: decode to NOR_NM using decoder 98 |
| 10515 | // 381: } |
| 10516 | 12, 6, // 385: case 0xc: { |
| 10517 | OPC_CheckPredicate, 4, // 387: check predicate 4 |
| 10518 | OPC_Decode, 201, 24, 98, // 389: decode to XOR_NM using decoder 98 |
| 10519 | // 389: } |
| 10520 | 13, 6, // 393: case 0xd: { |
| 10521 | OPC_CheckPredicate, 4, // 395: check predicate 4 |
| 10522 | OPC_Decode, 142, 22, 98, // 397: decode to SLT_NM using decoder 98 |
| 10523 | // 397: } |
| 10524 | 14, 29, // 401: case 0xe: { |
| 10525 | OPC_Scope, 21, // 403: try { |
| 10526 | OPC_SwitchField, 10, 11, // 405: switch Inst[20:10] { |
| 10527 | 0, 7, // 408: case 0x0: { |
| 10528 | OPC_CheckPredicate, 4, // 410: check predicate 4 |
| 10529 | OPC_Decode, 232, 12, 227, 1, // 412: decode to DVP_NM using decoder 227 |
| 10530 | // 412: } |
| 10531 | 1, 0, // 417: case 0x1: { |
| 10532 | OPC_CheckPredicate, 4, // 419: check predicate 4 |
| 10533 | OPC_Decode, 254, 12, 227, 1, // 421: decode to EVP_NM using decoder 227 |
| 10534 | // 421: } |
| 10535 | // 421: } // switch Inst[20:10] |
| 10536 | // 421: } else try { |
| 10537 | OPC_CheckPredicate, 4, // 426: check predicate 4 |
| 10538 | OPC_Decode, 140, 22, 98, // 428: decode to SLTU_NM using decoder 98 |
| 10539 | // 428: } |
| 10540 | // 428: } |
| 10541 | 15, 0, // 432: case 0xf: { |
| 10542 | OPC_CheckPredicate, 4, // 434: check predicate 4 |
| 10543 | OPC_Decode, 154, 22, 98, // 436: decode to SOV_NM using decoder 98 |
| 10544 | // 436: } |
| 10545 | // 436: } // switch Inst[9:6] |
| 10546 | // 436: } |
| 10547 | 24, 67, // 440: case 0x18: { |
| 10548 | OPC_SwitchField, 6, 4, // 442: switch Inst[9:6] { |
| 10549 | 0, 6, // 445: case 0x0: { |
| 10550 | OPC_CheckPredicate, 4, // 447: check predicate 4 |
| 10551 | OPC_Decode, 143, 19, 98, // 449: decode to MUL_NM using decoder 98 |
| 10552 | // 449: } |
| 10553 | 1, 6, // 453: case 0x1: { |
| 10554 | OPC_CheckPredicate, 4, // 455: check predicate 4 |
| 10555 | OPC_Decode, 228, 18, 98, // 457: decode to MUH_NM using decoder 98 |
| 10556 | // 457: } |
| 10557 | 2, 6, // 461: case 0x2: { |
| 10558 | OPC_CheckPredicate, 4, // 463: check predicate 4 |
| 10559 | OPC_Decode, 136, 19, 98, // 465: decode to MULU_NM using decoder 98 |
| 10560 | // 465: } |
| 10561 | 3, 6, // 469: case 0x3: { |
| 10562 | OPC_CheckPredicate, 4, // 471: check predicate 4 |
| 10563 | OPC_Decode, 226, 18, 98, // 473: decode to MUHU_NM using decoder 98 |
| 10564 | // 473: } |
| 10565 | 4, 6, // 477: case 0x4: { |
| 10566 | OPC_CheckPredicate, 4, // 479: check predicate 4 |
| 10567 | OPC_Decode, 253, 11, 98, // 481: decode to DIV_NM using decoder 98 |
| 10568 | // 481: } |
| 10569 | 5, 6, // 485: case 0x5: { |
| 10570 | OPC_CheckPredicate, 4, // 487: check predicate 4 |
| 10571 | OPC_Decode, 225, 17, 98, // 489: decode to MOD_NM using decoder 98 |
| 10572 | // 489: } |
| 10573 | 6, 6, // 493: case 0x6: { |
| 10574 | OPC_CheckPredicate, 4, // 495: check predicate 4 |
| 10575 | OPC_Decode, 251, 11, 98, // 497: decode to DIVU_NM using decoder 98 |
| 10576 | // 497: } |
| 10577 | 7, 0, // 501: case 0x7: { |
| 10578 | OPC_CheckPredicate, 4, // 503: check predicate 4 |
| 10579 | OPC_Decode, 223, 17, 98, // 505: decode to MODU_NM using decoder 98 |
| 10580 | // 505: } |
| 10581 | // 505: } // switch Inst[9:6] |
| 10582 | // 505: } |
| 10583 | 31, 7, // 509: case 0x1f: { |
| 10584 | OPC_CheckPredicate, 4, // 511: check predicate 4 |
| 10585 | OPC_Decode, 154, 13, 205, 3, // 513: decode to EXTW_NM using decoder 461 |
| 10586 | // 513: } |
| 10587 | 40, 51, // 518: case 0x28: { |
| 10588 | OPC_SwitchField, 6, 7, // 520: switch Inst[12:6] { |
| 10589 | 15, 6, // 523: case 0xf: { |
| 10590 | OPC_CheckPredicate, 116, // 525: check predicate 116 |
| 10591 | OPC_Decode, 196, 10, 124, // 527: decode to CRC32B_NM using decoder 124 |
| 10592 | // 527: } |
| 10593 | 31, 6, // 531: case 0x1f: { |
| 10594 | OPC_CheckPredicate, 116, // 533: check predicate 116 |
| 10595 | OPC_Decode, 206, 10, 124, // 535: decode to CRC32H_NM using decoder 124 |
| 10596 | // 535: } |
| 10597 | 47, 6, // 539: case 0x2f: { |
| 10598 | OPC_CheckPredicate, 116, // 541: check predicate 116 |
| 10599 | OPC_Decode, 208, 10, 124, // 543: decode to CRC32W_NM using decoder 124 |
| 10600 | // 543: } |
| 10601 | 79, 6, // 547: case 0x4f: { |
| 10602 | OPC_CheckPredicate, 116, // 549: check predicate 116 |
| 10603 | OPC_Decode, 198, 10, 124, // 551: decode to CRC32CB_NM using decoder 124 |
| 10604 | // 551: } |
| 10605 | 95, 6, // 555: case 0x5f: { |
| 10606 | OPC_CheckPredicate, 116, // 557: check predicate 116 |
| 10607 | OPC_Decode, 201, 10, 124, // 559: decode to CRC32CH_NM using decoder 124 |
| 10608 | // 559: } |
| 10609 | 111, 0, // 563: case 0x6f: { |
| 10610 | OPC_CheckPredicate, 116, // 565: check predicate 116 |
| 10611 | OPC_Decode, 203, 10, 124, // 567: decode to CRC32CW_NM using decoder 124 |
| 10612 | // 567: } |
| 10613 | // 567: } // switch Inst[12:6] |
| 10614 | // 567: } |
| 10615 | 48, 21, // 571: case 0x30: { |
| 10616 | OPC_SwitchField, 6, 4, // 573: switch Inst[9:6] { |
| 10617 | 0, 7, // 576: case 0x0: { |
| 10618 | OPC_CheckPredicate, 4, // 578: check predicate 4 |
| 10619 | OPC_Decode, 159, 17, 206, 3, // 580: decode to MFC0_NM using decoder 462 |
| 10620 | // 580: } |
| 10621 | 1, 0, // 585: case 0x1: { |
| 10622 | OPC_CheckPredicate, 4, // 587: check predicate 4 |
| 10623 | OPC_Decode, 185, 18, 206, 3, // 589: decode to MTC0_NM using decoder 462 |
| 10624 | // 589: } |
| 10625 | // 589: } // switch Inst[9:6] |
| 10626 | // 589: } |
| 10627 | 56, 21, // 594: case 0x38: { |
| 10628 | OPC_SwitchField, 6, 4, // 596: switch Inst[9:6] { |
| 10629 | 0, 7, // 599: case 0x0: { |
| 10630 | OPC_CheckPredicate, 4, // 601: check predicate 4 |
| 10631 | OPC_Decode, 169, 17, 206, 3, // 603: decode to MFHC0_NM using decoder 462 |
| 10632 | // 603: } |
| 10633 | 1, 0, // 608: case 0x1: { |
| 10634 | OPC_CheckPredicate, 4, // 610: check predicate 4 |
| 10635 | OPC_Decode, 196, 18, 206, 3, // 612: decode to MTHC0_NM using decoder 462 |
| 10636 | // 612: } |
| 10637 | // 612: } // switch Inst[9:6] |
| 10638 | // 612: } |
| 10639 | 63, 0, // 617: case 0x3f: { |
| 10640 | OPC_SwitchField, 6, 10, // 619: switch Inst[15:6] { |
| 10641 | 61, 7, // 622: case 0x3d: { |
| 10642 | OPC_CheckPredicate, 117, // 624: check predicate 117 |
| 10643 | OPC_Decode, 216, 14, 207, 3, // 626: decode to GINVT_NM using decoder 463 |
| 10644 | // 626: } |
| 10645 | 125, 7, // 631: case 0x7d: { |
| 10646 | OPC_CheckPredicate, 117, // 633: check predicate 117 |
| 10647 | OPC_Decode, 213, 14, 136, 1, // 635: decode to GINVI_NM using decoder 136 |
| 10648 | // 635: } |
| 10649 | 157, 2, 7, // 640: case 0x11d: { |
| 10650 | OPC_CheckPredicate, 4, // 643: check predicate 4 |
| 10651 | OPC_Decode, 136, 12, 227, 1, // 645: decode to DI_NM using decoder 227 |
| 10652 | // 645: } |
| 10653 | 172, 2, 6, // 650: case 0x12c: { |
| 10654 | OPC_CheckPredicate, 4, // 653: check predicate 4 |
| 10655 | OPC_Decode, 205, 9, 123, // 655: decode to CLO_NM using decoder 123 |
| 10656 | // 655: } |
| 10657 | 221, 2, 7, // 659: case 0x15d: { |
| 10658 | OPC_CheckPredicate, 4, // 662: check predicate 4 |
| 10659 | OPC_Decode, 242, 12, 227, 1, // 664: decode to EI_NM using decoder 227 |
| 10660 | // 664: } |
| 10661 | 236, 2, 6, // 669: case 0x16c: { |
| 10662 | OPC_CheckPredicate, 4, // 672: check predicate 4 |
| 10663 | OPC_Decode, 226, 9, 123, // 674: decode to CLZ_NM using decoder 123 |
| 10664 | // 674: } |
| 10665 | 141, 6, 7, // 678: case 0x30d: { |
| 10666 | OPC_CheckPredicate, 4, // 681: check predicate 4 |
| 10667 | OPC_Decode, 183, 24, 132, 1, // 683: decode to WAIT_NM using decoder 132 |
| 10668 | // 683: } |
| 10669 | 133, 7, 6, // 688: case 0x385: { |
| 10670 | OPC_CheckPredicate, 4, // 691: check predicate 4 |
| 10671 | OPC_Decode, 158, 20, 123, // 693: decode to RDPGPR_NM using decoder 123 |
| 10672 | // 693: } |
| 10673 | 141, 7, 10, // 697: case 0x38d: { |
| 10674 | OPC_CheckPredicate, 4, // 700: check predicate 4 |
| 10675 | OPC_CheckField, 16, 1, 0, // 702: check Inst[16] == 0x0 |
| 10676 | OPC_Decode, 239, 11, 10, // 706: decode to DERET_NM using decoder 10 |
| 10677 | // 706: } |
| 10678 | 197, 7, 6, // 710: case 0x3c5: { |
| 10679 | OPC_CheckPredicate, 4, // 713: check predicate 4 |
| 10680 | OPC_Decode, 187, 24, 123, // 715: decode to WRPGPR_NM using decoder 123 |
| 10681 | // 715: } |
| 10682 | 205, 7, 0, // 719: case 0x3cd: { |
| 10683 | OPC_SwitchField, 16, 1, // 722: switch Inst[16] { |
| 10684 | 0, 6, // 725: case 0x0: { |
| 10685 | OPC_CheckPredicate, 4, // 727: check predicate 4 |
| 10686 | OPC_Decode, 250, 12, 10, // 729: decode to ERET_NM using decoder 10 |
| 10687 | // 729: } |
| 10688 | 1, 0, // 733: case 0x1: { |
| 10689 | OPC_CheckPredicate, 4, // 735: check predicate 4 |
| 10690 | OPC_Decode, 247, 12, 10, // 737: decode to ERETNC_NM using decoder 10 |
| 10691 | // 737: } |
| 10692 | // 737: } // switch Inst[16] |
| 10693 | // 737: } |
| 10694 | // 737: } // switch Inst[15:6] |
| 10695 | // 737: } |
| 10696 | // 737: } // switch Inst[5:0] |
| 10697 | // 737: } |
| 10698 | 10, 21, // 741: case 0xa: { |
| 10699 | OPC_SwitchField, 25, 1, // 743: switch Inst[25] { |
| 10700 | 0, 7, // 746: case 0x0: { |
| 10701 | OPC_CheckPredicate, 4, // 748: check predicate 4 |
| 10702 | OPC_Decode, 223, 7, 208, 3, // 750: decode to BC_NM using decoder 464 |
| 10703 | // 750: } |
| 10704 | 1, 0, // 755: case 0x1: { |
| 10705 | OPC_CheckPredicate, 4, // 757: check predicate 4 |
| 10706 | OPC_Decode, 187, 7, 208, 3, // 759: decode to BALC_NM using decoder 464 |
| 10707 | // 759: } |
| 10708 | // 759: } // switch Inst[25] |
| 10709 | // 759: } |
| 10710 | 16, 30, // 764: case 0x10: { |
| 10711 | OPC_SwitchField, 0, 2, // 766: switch Inst[1:0] { |
| 10712 | 0, 7, // 769: case 0x0: { |
| 10713 | OPC_CheckPredicate, 4, // 771: check predicate 4 |
| 10714 | OPC_Decode, 161, 6, 209, 3, // 773: decode to ADDIUGPW_NM using decoder 465 |
| 10715 | // 773: } |
| 10716 | 2, 7, // 778: case 0x2: { |
| 10717 | OPC_CheckPredicate, 4, // 780: check predicate 4 |
| 10718 | OPC_Decode, 176, 16, 210, 3, // 782: decode to LWGP_NM using decoder 466 |
| 10719 | // 782: } |
| 10720 | 3, 0, // 787: case 0x3: { |
| 10721 | OPC_CheckPredicate, 4, // 789: check predicate 4 |
| 10722 | OPC_Decode, 170, 23, 210, 3, // 791: decode to SWGP_NM using decoder 466 |
| 10723 | // 791: } |
| 10724 | // 791: } // switch Inst[1:0] |
| 10725 | // 791: } |
| 10726 | 17, 75, // 796: case 0x11: { |
| 10727 | OPC_SwitchField, 18, 3, // 798: switch Inst[20:18] { |
| 10728 | 0, 7, // 801: case 0x0: { |
| 10729 | OPC_CheckPredicate, 4, // 803: check predicate 4 |
| 10730 | OPC_Decode, 188, 15, 211, 3, // 805: decode to LBGP_NM using decoder 467 |
| 10731 | // 805: } |
| 10732 | 1, 7, // 810: case 0x1: { |
| 10733 | OPC_CheckPredicate, 4, // 812: check predicate 4 |
| 10734 | OPC_Decode, 225, 20, 211, 3, // 814: decode to SBGP_NM using decoder 467 |
| 10735 | // 814: } |
| 10736 | 2, 7, // 819: case 0x2: { |
| 10737 | OPC_CheckPredicate, 4, // 821: check predicate 4 |
| 10738 | OPC_Decode, 191, 15, 211, 3, // 823: decode to LBUGP_NM using decoder 467 |
| 10739 | // 823: } |
| 10740 | 3, 7, // 828: case 0x3: { |
| 10741 | OPC_CheckPredicate, 4, // 830: check predicate 4 |
| 10742 | OPC_Decode, 160, 6, 212, 3, // 832: decode to ADDIUGPB_NM using decoder 468 |
| 10743 | // 832: } |
| 10744 | 4, 21, // 837: case 0x4: { |
| 10745 | OPC_SwitchField, 0, 1, // 839: switch Inst[0] { |
| 10746 | 0, 7, // 842: case 0x0: { |
| 10747 | OPC_CheckPredicate, 4, // 844: check predicate 4 |
| 10748 | OPC_Decode, 239, 15, 213, 3, // 846: decode to LHGP_NM using decoder 469 |
| 10749 | // 846: } |
| 10750 | 1, 0, // 851: case 0x1: { |
| 10751 | OPC_CheckPredicate, 4, // 853: check predicate 4 |
| 10752 | OPC_Decode, 242, 15, 213, 3, // 855: decode to LHUGP_NM using decoder 469 |
| 10753 | // 855: } |
| 10754 | // 855: } // switch Inst[0] |
| 10755 | // 855: } |
| 10756 | 5, 0, // 860: case 0x5: { |
| 10757 | OPC_CheckPredicate, 4, // 862: check predicate 4 |
| 10758 | OPC_CheckField, 0, 1, 0, // 864: check Inst[0] == 0x0 |
| 10759 | OPC_Decode, 178, 21, 213, 3, // 868: decode to SHGP_NM using decoder 469 |
| 10760 | // 868: } |
| 10761 | // 868: } // switch Inst[20:18] |
| 10762 | // 868: } |
| 10763 | 18, 41, // 873: case 0x12: { |
| 10764 | OPC_SwitchField, 12, 4, // 875: switch Inst[15:12] { |
| 10765 | 0, 6, // 878: case 0x0: { |
| 10766 | OPC_CheckPredicate, 4, // 880: check predicate 4 |
| 10767 | OPC_Decode, 143, 15, 123, // 882: decode to JALRC_NM using decoder 123 |
| 10768 | // 882: } |
| 10769 | 1, 6, // 886: case 0x1: { |
| 10770 | OPC_CheckPredicate, 4, // 888: check predicate 4 |
| 10771 | OPC_Decode, 140, 15, 123, // 890: decode to JALRCHB_NM using decoder 123 |
| 10772 | // 890: } |
| 10773 | 8, 0, // 894: case 0x8: { |
| 10774 | OPC_Scope, 11, // 896: try { |
| 10775 | OPC_CheckField, 21, 5, 0, // 898: check Inst[25:21] == 0x0 |
| 10776 | OPC_CheckPredicate, 4, // 902: check predicate 4 |
| 10777 | OPC_Decode, 248, 8, 136, 1, // 904: decode to BRSC_NM using decoder 136 |
| 10778 | // 904: } else try { |
| 10779 | OPC_CheckPredicate, 4, // 909: check predicate 4 |
| 10780 | OPC_Decode, 190, 7, 214, 3, // 911: decode to BALRSC_NM using decoder 470 |
| 10781 | // 911: } |
| 10782 | // 911: } |
| 10783 | // 911: } // switch Inst[15:12] |
| 10784 | // 911: } |
| 10785 | 32, 157, 2, // 916: case 0x20: { |
| 10786 | OPC_SwitchField, 12, 4, // 919: switch Inst[15:12] { |
| 10787 | 0, 7, // 922: case 0x0: { |
| 10788 | OPC_CheckPredicate, 4, // 924: check predicate 4 |
| 10789 | OPC_Decode, 195, 19, 215, 3, // 926: decode to ORI_NM using decoder 471 |
| 10790 | // 926: } |
| 10791 | 1, 7, // 931: case 0x1: { |
| 10792 | OPC_CheckPredicate, 4, // 933: check predicate 4 |
| 10793 | OPC_Decode, 198, 24, 215, 3, // 935: decode to XORI_NM using decoder 471 |
| 10794 | // 935: } |
| 10795 | 2, 7, // 940: case 0x2: { |
| 10796 | OPC_CheckPredicate, 4, // 942: check predicate 4 |
| 10797 | OPC_Decode, 134, 7, 215, 3, // 944: decode to ANDI_NM using decoder 471 |
| 10798 | // 944: } |
| 10799 | 3, 42, // 949: case 0x3: { |
| 10800 | OPC_SwitchField, 0, 2, // 951: switch Inst[1:0] { |
| 10801 | 0, 11, // 954: case 0x0: { |
| 10802 | OPC_CheckPredicate, 4, // 956: check predicate 4 |
| 10803 | OPC_CheckField, 20, 1, 0, // 958: check Inst[20] == 0x0 |
| 10804 | OPC_Decode, 217, 20, 216, 3, // 962: decode to SAVE_NM using decoder 472 |
| 10805 | // 962: } |
| 10806 | 2, 11, // 967: case 0x2: { |
| 10807 | OPC_CheckPredicate, 4, // 969: check predicate 4 |
| 10808 | OPC_CheckField, 20, 1, 0, // 971: check Inst[20] == 0x0 |
| 10809 | OPC_Decode, 175, 20, 216, 3, // 975: decode to RESTORE_NM using decoder 472 |
| 10810 | // 975: } |
| 10811 | 3, 0, // 980: case 0x3: { |
| 10812 | OPC_CheckPredicate, 4, // 982: check predicate 4 |
| 10813 | OPC_CheckField, 20, 1, 0, // 984: check Inst[20] == 0x0 |
| 10814 | OPC_Decode, 174, 20, 216, 3, // 988: decode to RESTOREJRC_NM using decoder 472 |
| 10815 | // 988: } |
| 10816 | // 988: } // switch Inst[1:0] |
| 10817 | // 988: } |
| 10818 | 4, 7, // 993: case 0x4: { |
| 10819 | OPC_CheckPredicate, 4, // 995: check predicate 4 |
| 10820 | OPC_Decode, 139, 22, 215, 3, // 997: decode to SLTI_NM using decoder 471 |
| 10821 | // 997: } |
| 10822 | 5, 7, // 1002: case 0x5: { |
| 10823 | OPC_CheckPredicate, 4, // 1004: check predicate 4 |
| 10824 | OPC_Decode, 138, 22, 215, 3, // 1006: decode to SLTIU_NM using decoder 471 |
| 10825 | // 1006: } |
| 10826 | 6, 7, // 1011: case 0x6: { |
| 10827 | OPC_CheckPredicate, 4, // 1013: check predicate 4 |
| 10828 | OPC_Decode, 166, 21, 215, 3, // 1015: decode to SEQI_NM using decoder 471 |
| 10829 | // 1015: } |
| 10830 | 8, 7, // 1020: case 0x8: { |
| 10831 | OPC_CheckPredicate, 4, // 1022: check predicate 4 |
| 10832 | OPC_Decode, 162, 6, 215, 3, // 1024: decode to ADDIUNEG_NM using decoder 471 |
| 10833 | // 1024: } |
| 10834 | 12, 93, // 1029: case 0xc: { |
| 10835 | OPC_SwitchField, 5, 4, // 1031: switch Inst[8:5] { |
| 10836 | 0, 61, // 1034: case 0x0: { |
| 10837 | OPC_Scope, 52, // 1036: try { |
| 10838 | OPC_SwitchField, 0, 5, // 1038: switch Inst[4:0] { |
| 10839 | 0, 10, // 1041: case 0x0: { |
| 10840 | OPC_CheckPredicate, 4, // 1043: check predicate 4 |
| 10841 | OPC_CheckField, 16, 10, 0, // 1045: check Inst[25:16] == 0x0 |
| 10842 | OPC_Decode, 174, 19, 10, // 1049: decode to NOP32_NM using decoder 10 |
| 10843 | // 1049: } |
| 10844 | 3, 10, // 1053: case 0x3: { |
| 10845 | OPC_CheckPredicate, 4, // 1055: check predicate 4 |
| 10846 | OPC_CheckField, 16, 10, 0, // 1057: check Inst[25:16] == 0x0 |
| 10847 | OPC_Decode, 238, 12, 10, // 1061: decode to EHB_NM using decoder 10 |
| 10848 | // 1061: } |
| 10849 | 5, 10, // 1065: case 0x5: { |
| 10850 | OPC_CheckPredicate, 4, // 1067: check predicate 4 |
| 10851 | OPC_CheckField, 16, 10, 0, // 1069: check Inst[25:16] == 0x0 |
| 10852 | OPC_Decode, 209, 19, 10, // 1073: decode to PAUSE_NM using decoder 10 |
| 10853 | // 1073: } |
| 10854 | 6, 0, // 1077: case 0x6: { |
| 10855 | OPC_CheckPredicate, 4, // 1079: check predicate 4 |
| 10856 | OPC_CheckField, 21, 5, 0, // 1081: check Inst[25:21] == 0x0 |
| 10857 | OPC_Decode, 206, 23, 131, 1, // 1085: decode to SYNC_NM using decoder 131 |
| 10858 | // 1085: } |
| 10859 | // 1085: } // switch Inst[4:0] |
| 10860 | // 1085: } else try { |
| 10861 | OPC_CheckPredicate, 4, // 1090: check predicate 4 |
| 10862 | OPC_Decode, 134, 22, 217, 3, // 1092: decode to SLL_NM using decoder 473 |
| 10863 | // 1092: } |
| 10864 | // 1092: } |
| 10865 | 2, 7, // 1097: case 0x2: { |
| 10866 | OPC_CheckPredicate, 4, // 1099: check predicate 4 |
| 10867 | OPC_Decode, 208, 22, 217, 3, // 1101: decode to SRL_NM using decoder 473 |
| 10868 | // 1101: } |
| 10869 | 4, 7, // 1106: case 0x4: { |
| 10870 | OPC_CheckPredicate, 4, // 1108: check predicate 4 |
| 10871 | OPC_Decode, 183, 22, 217, 3, // 1110: decode to SRA_NM using decoder 473 |
| 10872 | // 1110: } |
| 10873 | 6, 0, // 1115: case 0x6: { |
| 10874 | OPC_CheckPredicate, 4, // 1117: check predicate 4 |
| 10875 | OPC_Decode, 185, 20, 217, 3, // 1119: decode to ROTR_NM using decoder 473 |
| 10876 | // 1119: } |
| 10877 | // 1119: } // switch Inst[8:5] |
| 10878 | // 1119: } |
| 10879 | 13, 44, // 1124: case 0xd: { |
| 10880 | OPC_CheckField, 5, 1, 0, // 1126: check Inst[5] == 0x0 |
| 10881 | OPC_CheckField, 11, 1, 0, // 1130: check Inst[11] == 0x0 |
| 10882 | OPC_Scope, 27, // 1134: try { |
| 10883 | OPC_SwitchField, 0, 5, // 1136: switch Inst[4:0] { |
| 10884 | 24, 10, // 1139: case 0x18: { |
| 10885 | OPC_CheckPredicate, 4, // 1141: check predicate 4 |
| 10886 | OPC_CheckField, 6, 5, 8, // 1143: check Inst[10:6] == 0x8 |
| 10887 | OPC_Decode, 131, 9, 123, // 1147: decode to BYTEREVW_NM using decoder 123 |
| 10888 | // 1147: } |
| 10889 | 31, 0, // 1151: case 0x1f: { |
| 10890 | OPC_CheckPredicate, 4, // 1153: check predicate 4 |
| 10891 | OPC_CheckField, 6, 5, 0, // 1155: check Inst[10:6] == 0x0 |
| 10892 | OPC_Decode, 163, 8, 123, // 1159: decode to BITREVW_NM using decoder 123 |
| 10893 | // 1159: } |
| 10894 | // 1159: } // switch Inst[4:0] |
| 10895 | // 1159: } else try { |
| 10896 | OPC_CheckPredicate, 4, // 1163: check predicate 4 |
| 10897 | OPC_Decode, 186, 20, 218, 3, // 1165: decode to ROTX_NM using decoder 474 |
| 10898 | // 1165: } |
| 10899 | // 1165: } |
| 10900 | 14, 15, // 1170: case 0xe: { |
| 10901 | OPC_CheckPredicate, 4, // 1172: check predicate 4 |
| 10902 | OPC_CheckField, 11, 1, 0, // 1174: check Inst[11] == 0x0 |
| 10903 | OPC_CheckField, 5, 1, 0, // 1178: check Inst[5] == 0x0 |
| 10904 | OPC_Decode, 132, 15, 219, 3, // 1182: decode to INS_NM using decoder 475 |
| 10905 | // 1182: } |
| 10906 | 15, 0, // 1187: case 0xf: { |
| 10907 | OPC_CheckPredicate, 4, // 1189: check predicate 4 |
| 10908 | OPC_CheckField, 11, 1, 0, // 1191: check Inst[11] == 0x0 |
| 10909 | OPC_CheckField, 5, 1, 0, // 1195: check Inst[5] == 0x0 |
| 10910 | OPC_Decode, 157, 13, 220, 3, // 1199: decode to EXT_NM using decoder 476 |
| 10911 | // 1199: } |
| 10912 | // 1199: } // switch Inst[15:12] |
| 10913 | // 1199: } |
| 10914 | 33, 97, // 1204: case 0x21: { |
| 10915 | OPC_SwitchField, 12, 4, // 1206: switch Inst[15:12] { |
| 10916 | 0, 7, // 1209: case 0x0: { |
| 10917 | OPC_CheckPredicate, 4, // 1211: check predicate 4 |
| 10918 | OPC_Decode, 201, 15, 221, 3, // 1213: decode to LB_NM using decoder 477 |
| 10919 | // 1213: } |
| 10920 | 1, 7, // 1218: case 0x1: { |
| 10921 | OPC_CheckPredicate, 4, // 1220: check predicate 4 |
| 10922 | OPC_Decode, 229, 20, 221, 3, // 1222: decode to SB_NM using decoder 477 |
| 10923 | // 1222: } |
| 10924 | 2, 7, // 1227: case 0x2: { |
| 10925 | OPC_CheckPredicate, 4, // 1229: check predicate 4 |
| 10926 | OPC_Decode, 196, 15, 221, 3, // 1231: decode to LBU_NM using decoder 477 |
| 10927 | // 1231: } |
| 10928 | 3, 20, // 1236: case 0x3: { |
| 10929 | OPC_Scope, 11, // 1238: try { |
| 10930 | OPC_CheckField, 21, 5, 31, // 1240: check Inst[25:21] == 0x1f |
| 10931 | OPC_CheckPredicate, 4, // 1244: check predicate 4 |
| 10932 | OPC_Decode, 202, 23, 222, 3, // 1246: decode to SYNCI_NM using decoder 478 |
| 10933 | // 1246: } else try { |
| 10934 | OPC_CheckPredicate, 4, // 1251: check predicate 4 |
| 10935 | OPC_Decode, 141, 20, 223, 3, // 1253: decode to PREF_NM using decoder 479 |
| 10936 | // 1253: } |
| 10937 | // 1253: } |
| 10938 | 4, 7, // 1258: case 0x4: { |
| 10939 | OPC_CheckPredicate, 4, // 1260: check predicate 4 |
| 10940 | OPC_Decode, 252, 15, 221, 3, // 1262: decode to LH_NM using decoder 477 |
| 10941 | // 1262: } |
| 10942 | 5, 7, // 1267: case 0x5: { |
| 10943 | OPC_CheckPredicate, 4, // 1269: check predicate 4 |
| 10944 | OPC_Decode, 231, 21, 221, 3, // 1271: decode to SH_NM using decoder 477 |
| 10945 | // 1271: } |
| 10946 | 6, 7, // 1276: case 0x6: { |
| 10947 | OPC_CheckPredicate, 4, // 1278: check predicate 4 |
| 10948 | OPC_Decode, 245, 15, 221, 3, // 1280: decode to LHU_NM using decoder 477 |
| 10949 | // 1280: } |
| 10950 | 8, 7, // 1285: case 0x8: { |
| 10951 | OPC_CheckPredicate, 4, // 1287: check predicate 4 |
| 10952 | OPC_Decode, 209, 16, 221, 3, // 1289: decode to LW_NM using decoder 477 |
| 10953 | // 1289: } |
| 10954 | 9, 0, // 1294: case 0x9: { |
| 10955 | OPC_CheckPredicate, 4, // 1296: check predicate 4 |
| 10956 | OPC_Decode, 196, 23, 221, 3, // 1298: decode to SW_NM using decoder 477 |
| 10957 | // 1298: } |
| 10958 | // 1298: } // switch Inst[15:12] |
| 10959 | // 1298: } |
| 10960 | 34, 30, // 1303: case 0x22: { |
| 10961 | OPC_SwitchField, 14, 2, // 1305: switch Inst[15:14] { |
| 10962 | 0, 7, // 1308: case 0x0: { |
| 10963 | OPC_CheckPredicate, 4, // 1310: check predicate 4 |
| 10964 | OPC_Decode, 229, 7, 224, 3, // 1312: decode to BEQC_NM using decoder 480 |
| 10965 | // 1312: } |
| 10966 | 2, 7, // 1317: case 0x2: { |
| 10967 | OPC_CheckPredicate, 4, // 1319: check predicate 4 |
| 10968 | OPC_Decode, 245, 7, 224, 3, // 1321: decode to BGEC_NM using decoder 480 |
| 10969 | // 1321: } |
| 10970 | 3, 0, // 1326: case 0x3: { |
| 10971 | OPC_CheckPredicate, 4, // 1328: check predicate 4 |
| 10972 | OPC_Decode, 251, 7, 224, 3, // 1330: decode to BGEUC_NM using decoder 480 |
| 10973 | // 1330: } |
| 10974 | // 1330: } // switch Inst[15:14] |
| 10975 | // 1330: } |
| 10976 | 41, 252, 1, // 1335: case 0x29: { |
| 10977 | OPC_SwitchField, 8, 4, // 1338: switch Inst[11:8] { |
| 10978 | 0, 48, // 1341: case 0x0: { |
| 10979 | OPC_SwitchField, 12, 3, // 1343: switch Inst[14:12] { |
| 10980 | 0, 7, // 1346: case 0x0: { |
| 10981 | OPC_CheckPredicate, 4, // 1348: check predicate 4 |
| 10982 | OPC_Decode, 202, 15, 225, 3, // 1350: decode to LBs9_NM using decoder 481 |
| 10983 | // 1350: } |
| 10984 | 1, 7, // 1355: case 0x1: { |
| 10985 | OPC_CheckPredicate, 4, // 1357: check predicate 4 |
| 10986 | OPC_Decode, 197, 15, 225, 3, // 1359: decode to LBUs9_NM using decoder 481 |
| 10987 | // 1359: } |
| 10988 | 2, 7, // 1364: case 0x2: { |
| 10989 | OPC_CheckPredicate, 4, // 1366: check predicate 4 |
| 10990 | OPC_Decode, 253, 15, 225, 3, // 1368: decode to LHs9_NM using decoder 481 |
| 10991 | // 1368: } |
| 10992 | 3, 7, // 1373: case 0x3: { |
| 10993 | OPC_CheckPredicate, 4, // 1375: check predicate 4 |
| 10994 | OPC_Decode, 246, 15, 225, 3, // 1377: decode to LHUs9_NM using decoder 481 |
| 10995 | // 1377: } |
| 10996 | 4, 0, // 1382: case 0x4: { |
| 10997 | OPC_CheckPredicate, 4, // 1384: check predicate 4 |
| 10998 | OPC_Decode, 210, 16, 225, 3, // 1386: decode to LWs9_NM using decoder 481 |
| 10999 | // 1386: } |
| 11000 | // 1386: } // switch Inst[14:12] |
| 11001 | // 1386: } |
| 11002 | 1, 35, // 1391: case 0x1: { |
| 11003 | OPC_SwitchField, 12, 3, // 1393: switch Inst[14:12] { |
| 11004 | 2, 7, // 1396: case 0x2: { |
| 11005 | OPC_CheckPredicate, 4, // 1398: check predicate 4 |
| 11006 | OPC_Decode, 165, 24, 226, 3, // 1400: decode to UALH_NM using decoder 482 |
| 11007 | // 1400: } |
| 11008 | 5, 0, // 1405: case 0x5: { |
| 11009 | OPC_SwitchField, 0, 2, // 1407: switch Inst[1:0] { |
| 11010 | 0, 7, // 1410: case 0x0: { |
| 11011 | OPC_CheckPredicate, 4, // 1412: check predicate 4 |
| 11012 | OPC_Decode, 145, 16, 227, 3, // 1414: decode to LL_NM using decoder 483 |
| 11013 | // 1414: } |
| 11014 | 1, 0, // 1419: case 0x1: { |
| 11015 | OPC_CheckPredicate, 4, // 1421: check predicate 4 |
| 11016 | OPC_Decode, 142, 16, 228, 3, // 1423: decode to LLWP_NM using decoder 484 |
| 11017 | // 1423: } |
| 11018 | // 1423: } // switch Inst[1:0] |
| 11019 | // 1423: } |
| 11020 | // 1423: } // switch Inst[14:12] |
| 11021 | // 1423: } |
| 11022 | 4, 7, // 1428: case 0x4: { |
| 11023 | OPC_CheckPredicate, 4, // 1430: check predicate 4 |
| 11024 | OPC_Decode, 185, 16, 229, 3, // 1432: decode to LWM_NM using decoder 485 |
| 11025 | // 1432: } |
| 11026 | 5, 20, // 1437: case 0x5: { |
| 11027 | OPC_Scope, 11, // 1439: try { |
| 11028 | OPC_CheckField, 12, 3, 1, // 1441: check Inst[14:12] == 0x1 |
| 11029 | OPC_CheckPredicate, 4, // 1445: check predicate 4 |
| 11030 | OPC_Decode, 167, 24, 226, 3, // 1447: decode to UALW_NM using decoder 482 |
| 11031 | // 1447: } else try { |
| 11032 | OPC_CheckPredicate, 4, // 1452: check predicate 4 |
| 11033 | OPC_Decode, 166, 24, 229, 3, // 1454: decode to UALWM_NM using decoder 485 |
| 11034 | // 1454: } |
| 11035 | // 1454: } |
| 11036 | 8, 52, // 1459: case 0x8: { |
| 11037 | OPC_SwitchField, 12, 3, // 1461: switch Inst[14:12] { |
| 11038 | 0, 7, // 1464: case 0x0: { |
| 11039 | OPC_CheckPredicate, 4, // 1466: check predicate 4 |
| 11040 | OPC_Decode, 230, 20, 225, 3, // 1468: decode to SBs9_NM using decoder 481 |
| 11041 | // 1468: } |
| 11042 | 1, 20, // 1473: case 0x1: { |
| 11043 | OPC_Scope, 11, // 1475: try { |
| 11044 | OPC_CheckField, 21, 5, 31, // 1477: check Inst[25:21] == 0x1f |
| 11045 | OPC_CheckPredicate, 4, // 1481: check predicate 4 |
| 11046 | OPC_Decode, 203, 23, 230, 3, // 1483: decode to SYNCIs9_NM using decoder 486 |
| 11047 | // 1483: } else try { |
| 11048 | OPC_CheckPredicate, 4, // 1488: check predicate 4 |
| 11049 | OPC_Decode, 143, 20, 231, 3, // 1490: decode to PREFs9_NM using decoder 487 |
| 11050 | // 1490: } |
| 11051 | // 1490: } |
| 11052 | 2, 7, // 1495: case 0x2: { |
| 11053 | OPC_CheckPredicate, 4, // 1497: check predicate 4 |
| 11054 | OPC_Decode, 232, 21, 225, 3, // 1499: decode to SHs9_NM using decoder 481 |
| 11055 | // 1499: } |
| 11056 | 4, 0, // 1504: case 0x4: { |
| 11057 | OPC_CheckPredicate, 4, // 1506: check predicate 4 |
| 11058 | OPC_Decode, 197, 23, 225, 3, // 1508: decode to SWs9_NM using decoder 481 |
| 11059 | // 1508: } |
| 11060 | // 1508: } // switch Inst[14:12] |
| 11061 | // 1508: } |
| 11062 | 9, 44, // 1513: case 0x9: { |
| 11063 | OPC_SwitchField, 12, 3, // 1515: switch Inst[14:12] { |
| 11064 | 2, 7, // 1518: case 0x2: { |
| 11065 | OPC_CheckPredicate, 4, // 1520: check predicate 4 |
| 11066 | OPC_Decode, 168, 24, 225, 3, // 1522: decode to UASH_NM using decoder 481 |
| 11067 | // 1522: } |
| 11068 | 3, 7, // 1527: case 0x3: { |
| 11069 | OPC_CheckPredicate, 4, // 1529: check predicate 4 |
| 11070 | OPC_Decode, 153, 9, 231, 3, // 1531: decode to CACHE_NM using decoder 487 |
| 11071 | // 1531: } |
| 11072 | 5, 0, // 1536: case 0x5: { |
| 11073 | OPC_SwitchField, 0, 2, // 1538: switch Inst[1:0] { |
| 11074 | 0, 7, // 1541: case 0x0: { |
| 11075 | OPC_CheckPredicate, 4, // 1543: check predicate 4 |
| 11076 | OPC_Decode, 241, 20, 232, 3, // 1545: decode to SC_NM using decoder 488 |
| 11077 | // 1545: } |
| 11078 | 1, 0, // 1550: case 0x1: { |
| 11079 | OPC_CheckPredicate, 4, // 1552: check predicate 4 |
| 11080 | OPC_Decode, 238, 20, 233, 3, // 1554: decode to SCWP_NM using decoder 489 |
| 11081 | // 1554: } |
| 11082 | // 1554: } // switch Inst[1:0] |
| 11083 | // 1554: } |
| 11084 | // 1554: } // switch Inst[14:12] |
| 11085 | // 1554: } |
| 11086 | 12, 7, // 1559: case 0xc: { |
| 11087 | OPC_CheckPredicate, 4, // 1561: check predicate 4 |
| 11088 | OPC_Decode, 179, 23, 229, 3, // 1563: decode to SWM_NM using decoder 485 |
| 11089 | // 1563: } |
| 11090 | 13, 0, // 1568: case 0xd: { |
| 11091 | OPC_Scope, 11, // 1570: try { |
| 11092 | OPC_CheckField, 12, 3, 1, // 1572: check Inst[14:12] == 0x1 |
| 11093 | OPC_CheckPredicate, 4, // 1576: check predicate 4 |
| 11094 | OPC_Decode, 170, 24, 225, 3, // 1578: decode to UASW_NM using decoder 481 |
| 11095 | // 1578: } else try { |
| 11096 | OPC_CheckPredicate, 4, // 1583: check predicate 4 |
| 11097 | OPC_Decode, 169, 24, 229, 3, // 1585: decode to UASWM_NM using decoder 485 |
| 11098 | // 1585: } |
| 11099 | // 1585: } |
| 11100 | // 1585: } // switch Inst[11:8] |
| 11101 | // 1585: } |
| 11102 | 42, 30, // 1590: case 0x2a: { |
| 11103 | OPC_SwitchField, 14, 2, // 1592: switch Inst[15:14] { |
| 11104 | 0, 7, // 1595: case 0x0: { |
| 11105 | OPC_CheckPredicate, 4, // 1597: check predicate 4 |
| 11106 | OPC_Decode, 208, 8, 224, 3, // 1599: decode to BNEC_NM using decoder 480 |
| 11107 | // 1599: } |
| 11108 | 2, 7, // 1604: case 0x2: { |
| 11109 | OPC_CheckPredicate, 4, // 1606: check predicate 4 |
| 11110 | OPC_Decode, 179, 8, 224, 3, // 1608: decode to BLTC_NM using decoder 480 |
| 11111 | // 1608: } |
| 11112 | 3, 0, // 1613: case 0x3: { |
| 11113 | OPC_CheckPredicate, 4, // 1615: check predicate 4 |
| 11114 | OPC_Decode, 185, 8, 224, 3, // 1617: decode to BLTUC_NM using decoder 480 |
| 11115 | // 1617: } |
| 11116 | // 1617: } // switch Inst[15:14] |
| 11117 | // 1617: } |
| 11118 | 50, 75, // 1622: case 0x32: { |
| 11119 | OPC_SwitchField, 18, 3, // 1624: switch Inst[20:18] { |
| 11120 | 0, 7, // 1627: case 0x0: { |
| 11121 | OPC_CheckPredicate, 4, // 1629: check predicate 4 |
| 11122 | OPC_Decode, 230, 7, 234, 3, // 1631: decode to BEQIC_NM using decoder 490 |
| 11123 | // 1631: } |
| 11124 | 1, 7, // 1636: case 0x1: { |
| 11125 | OPC_CheckPredicate, 4, // 1638: check predicate 4 |
| 11126 | OPC_Decode, 191, 7, 235, 3, // 1640: decode to BBEQZC_NM using decoder 491 |
| 11127 | // 1640: } |
| 11128 | 2, 7, // 1645: case 0x2: { |
| 11129 | OPC_CheckPredicate, 4, // 1647: check predicate 4 |
| 11130 | OPC_Decode, 246, 7, 234, 3, // 1649: decode to BGEIC_NM using decoder 490 |
| 11131 | // 1649: } |
| 11132 | 3, 7, // 1654: case 0x3: { |
| 11133 | OPC_CheckPredicate, 4, // 1656: check predicate 4 |
| 11134 | OPC_Decode, 247, 7, 234, 3, // 1658: decode to BGEIUC_NM using decoder 490 |
| 11135 | // 1658: } |
| 11136 | 4, 7, // 1663: case 0x4: { |
| 11137 | OPC_CheckPredicate, 4, // 1665: check predicate 4 |
| 11138 | OPC_Decode, 217, 8, 234, 3, // 1667: decode to BNEIC_NM using decoder 490 |
| 11139 | // 1667: } |
| 11140 | 5, 7, // 1672: case 0x5: { |
| 11141 | OPC_CheckPredicate, 4, // 1674: check predicate 4 |
| 11142 | OPC_Decode, 196, 7, 235, 3, // 1676: decode to BBNEZC_NM using decoder 491 |
| 11143 | // 1676: } |
| 11144 | 6, 7, // 1681: case 0x6: { |
| 11145 | OPC_CheckPredicate, 4, // 1683: check predicate 4 |
| 11146 | OPC_Decode, 180, 8, 234, 3, // 1685: decode to BLTIC_NM using decoder 490 |
| 11147 | // 1685: } |
| 11148 | 7, 0, // 1690: case 0x7: { |
| 11149 | OPC_CheckPredicate, 4, // 1692: check predicate 4 |
| 11150 | OPC_Decode, 181, 8, 234, 3, // 1694: decode to BLTIUC_NM using decoder 490 |
| 11151 | // 1694: } |
| 11152 | // 1694: } // switch Inst[20:18] |
| 11153 | // 1694: } |
| 11154 | 56, 0, // 1699: case 0x38: { |
| 11155 | OPC_SwitchField, 1, 1, // 1701: switch Inst[1] { |
| 11156 | 0, 7, // 1704: case 0x0: { |
| 11157 | OPC_CheckPredicate, 4, // 1706: check predicate 4 |
| 11158 | OPC_Decode, 152, 16, 236, 3, // 1708: decode to LUI_NM using decoder 492 |
| 11159 | // 1708: } |
| 11160 | 1, 0, // 1713: case 0x1: { |
| 11161 | OPC_CheckPredicate, 4, // 1715: check predicate 4 |
| 11162 | OPC_Decode, 251, 6, 236, 3, // 1717: decode to ALUIPC_NM using decoder 492 |
| 11163 | // 1717: } |
| 11164 | // 1717: } // switch Inst[1] |
| 11165 | // 1717: } |
| 11166 | // 1717: } // switch Inst[31:26] |
| 11167 | }; |
| 11168 | static const uint8_t DecoderTableNanoMips48[81] = { |
| 11169 | OPC_SwitchField, 32, 5, // 0: switch Inst[36:32] { |
| 11170 | 0, 11, // 3: case 0x0: { |
| 11171 | OPC_CheckPredicate, 4, // 5: check predicate 4 |
| 11172 | OPC_CheckField, 42, 6, 24, // 7: check Inst[47:42] == 0x18 |
| 11173 | OPC_Decode, 134, 16, 237, 3, // 11: decode to LI48_NM using decoder 493 |
| 11174 | // 11: } |
| 11175 | 1, 11, // 16: case 0x1: { |
| 11176 | OPC_CheckPredicate, 4, // 18: check predicate 4 |
| 11177 | OPC_CheckField, 42, 6, 24, // 20: check Inst[47:42] == 0x18 |
| 11178 | OPC_Decode, 158, 6, 238, 3, // 24: decode to ADDIU48_NM using decoder 494 |
| 11179 | // 24: } |
| 11180 | 2, 11, // 29: case 0x2: { |
| 11181 | OPC_CheckPredicate, 4, // 31: check predicate 4 |
| 11182 | OPC_CheckField, 42, 6, 24, // 33: check Inst[47:42] == 0x18 |
| 11183 | OPC_Decode, 159, 6, 237, 3, // 37: decode to ADDIUGP48_NM using decoder 493 |
| 11184 | // 37: } |
| 11185 | 3, 11, // 42: case 0x3: { |
| 11186 | OPC_CheckPredicate, 4, // 44: check predicate 4 |
| 11187 | OPC_CheckField, 42, 6, 24, // 46: check Inst[47:42] == 0x18 |
| 11188 | OPC_Decode, 182, 15, 237, 3, // 50: decode to LAPC48_NM using decoder 493 |
| 11189 | // 50: } |
| 11190 | 11, 11, // 55: case 0xb: { |
| 11191 | OPC_CheckPredicate, 4, // 57: check predicate 4 |
| 11192 | OPC_CheckField, 42, 6, 24, // 59: check Inst[47:42] == 0x18 |
| 11193 | OPC_Decode, 188, 16, 237, 3, // 63: decode to LWPC_NM using decoder 493 |
| 11194 | // 63: } |
| 11195 | 15, 0, // 68: case 0xf: { |
| 11196 | OPC_CheckPredicate, 4, // 70: check predicate 4 |
| 11197 | OPC_CheckField, 42, 6, 24, // 72: check Inst[47:42] == 0x18 |
| 11198 | OPC_Decode, 180, 23, 237, 3, // 76: decode to SWPC_NM using decoder 493 |
| 11199 | // 76: } |
| 11200 | // 76: } // switch Inst[36:32] |
| 11201 | }; |
| 11202 | // Handling 495 cases. |
| 11203 | template <typename InsnType> |
| 11204 | static DecodeStatus decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) { |
| 11205 | DecodeComplete = true; |
| 11206 | using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>; |
| 11207 | TmpType tmp; |
| 11208 | switch (Idx) { |
| 11209 | default: llvm_unreachable("Invalid decoder index!" ); |
| 11210 | case 0: |
| 11211 | tmp = fieldFromInstruction(insn, 0, 11); |
| 11212 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11213 | return S; |
| 11214 | case 1: |
| 11215 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11216 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11217 | tmp = fieldFromInstruction(insn, 0, 8); |
| 11218 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11219 | return S; |
| 11220 | case 2: |
| 11221 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11222 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11223 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11224 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11225 | tmp = fieldFromInstruction(insn, 0, 8); |
| 11226 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11227 | return S; |
| 11228 | case 3: |
| 11229 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11230 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11231 | tmp = fieldFromInstruction(insn, 0, 8); |
| 11232 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11233 | return S; |
| 11234 | case 4: |
| 11235 | tmp = fieldFromInstruction(insn, 0, 8); |
| 11236 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11237 | return S; |
| 11238 | case 5: |
| 11239 | tmp = 0x0; |
| 11240 | tmp |= fieldFromInstruction(insn, 3, 2) << 3; |
| 11241 | tmp |= fieldFromInstruction(insn, 5, 3); |
| 11242 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11243 | tmp = fieldFromInstruction(insn, 0, 3); |
| 11244 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11245 | return S; |
| 11246 | case 6: |
| 11247 | tmp = fieldFromInstruction(insn, 4, 4); |
| 11248 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11249 | tmp = fieldFromInstruction(insn, 0, 4); |
| 11250 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11251 | return S; |
| 11252 | case 7: |
| 11253 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11254 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11255 | tmp = fieldFromInstruction(insn, 0, 8); |
| 11256 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11257 | return S; |
| 11258 | case 8: |
| 11259 | tmp = fieldFromInstruction(insn, 2, 3); |
| 11260 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11261 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11262 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11263 | tmp = fieldFromInstruction(insn, 5, 3); |
| 11264 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11265 | return S; |
| 11266 | case 9: |
| 11267 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11268 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11269 | return S; |
| 11270 | case 10: |
| 11271 | return S; |
| 11272 | case 11: |
| 11273 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11274 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11275 | tmp = fieldFromInstruction(insn, 5, 3); |
| 11276 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11277 | return S; |
| 11278 | case 12: |
| 11279 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11280 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11281 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11282 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11283 | tmp = fieldFromInstruction(insn, 5, 3); |
| 11284 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11285 | return S; |
| 11286 | case 13: |
| 11287 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11288 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11289 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11290 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11291 | return S; |
| 11292 | case 14: |
| 11293 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11294 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11295 | tmp = fieldFromInstruction(insn, 1, 3); |
| 11296 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11297 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11298 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11299 | return S; |
| 11300 | case 15: |
| 11301 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11302 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11303 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11304 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11305 | tmp = fieldFromInstruction(insn, 0, 4); |
| 11306 | if (!Check(S, DecodeLBU16Offset(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11307 | return S; |
| 11308 | case 16: |
| 11309 | tmp = fieldFromInstruction(insn, 5, 5); |
| 11310 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11311 | tmp = fieldFromInstruction(insn, 0, 5); |
| 11312 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11313 | return S; |
| 11314 | case 17: |
| 11315 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11316 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11317 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11318 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11319 | tmp = fieldFromInstruction(insn, 1, 3); |
| 11320 | if (!Check(S, DecodePOOL16BEncodedField(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11321 | return S; |
| 11322 | case 18: |
| 11323 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11324 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11325 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11326 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11327 | tmp = fieldFromInstruction(insn, 0, 4); |
| 11328 | if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11329 | return S; |
| 11330 | case 19: |
| 11331 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11332 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11333 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11334 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11335 | tmp = fieldFromInstruction(insn, 0, 4); |
| 11336 | if (!Check(S, DecodeANDI16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11337 | return S; |
| 11338 | case 20: |
| 11339 | tmp = fieldFromInstruction(insn, 3, 3); |
| 11340 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11341 | tmp = fieldFromInstruction(insn, 0, 3); |
| 11342 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11343 | return S; |
| 11344 | case 21: |
| 11345 | tmp = fieldFromInstruction(insn, 3, 3); |
| 11346 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11347 | tmp = fieldFromInstruction(insn, 0, 3); |
| 11348 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11349 | tmp = fieldFromInstruction(insn, 3, 3); |
| 11350 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11351 | return S; |
| 11352 | case 22: |
| 11353 | tmp = fieldFromInstruction(insn, 4, 2); |
| 11354 | if (!Check(S, DecodeRegListOperand16(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11355 | if (!Check(Out&: S, In: DecodeFixedPtrRegister<29>(Inst&: MI, Decoder))) |
| 11356 | return MCDisassembler::Fail; |
| 11357 | tmp = fieldFromInstruction(insn, 0, 4); |
| 11358 | if (!Check(S, DecodeSImmWithOffsetAndScale<4, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11359 | return S; |
| 11360 | case 23: |
| 11361 | tmp = fieldFromInstruction(insn, 0, 5); |
| 11362 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11363 | return S; |
| 11364 | case 24: |
| 11365 | tmp = fieldFromInstruction(insn, 0, 4); |
| 11366 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11367 | return S; |
| 11368 | case 25: |
| 11369 | tmp = fieldFromInstruction(insn, 0, 5); |
| 11370 | if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11371 | return S; |
| 11372 | case 26: |
| 11373 | tmp = fieldFromInstruction(insn, 5, 5); |
| 11374 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11375 | if (!Check(Out&: S, In: DecodeFixedPtrRegister<29>(Inst&: MI, Decoder))) |
| 11376 | return MCDisassembler::Fail; |
| 11377 | tmp = fieldFromInstruction(insn, 0, 5); |
| 11378 | if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11379 | return S; |
| 11380 | case 27: |
| 11381 | tmp = fieldFromInstruction(insn, 5, 5); |
| 11382 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11383 | tmp = fieldFromInstruction(insn, 5, 5); |
| 11384 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11385 | tmp = fieldFromInstruction(insn, 1, 4); |
| 11386 | if (!Check(S, DecodeSImmWithOffsetAndScale<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11387 | return S; |
| 11388 | case 28: |
| 11389 | tmp = fieldFromInstruction(insn, 1, 9); |
| 11390 | if (!Check(S, DecodeSimm9SP(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11391 | return S; |
| 11392 | case 29: |
| 11393 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11394 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11395 | if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder))) |
| 11396 | return MCDisassembler::Fail; |
| 11397 | tmp = fieldFromInstruction(insn, 0, 7); |
| 11398 | if (!Check(S, DecodeSImmWithOffsetAndScale<7, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11399 | return S; |
| 11400 | case 30: |
| 11401 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11402 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11403 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11404 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11405 | tmp = fieldFromInstruction(insn, 0, 4); |
| 11406 | if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11407 | return S; |
| 11408 | case 31: |
| 11409 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11410 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11411 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11412 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11413 | tmp = fieldFromInstruction(insn, 1, 3); |
| 11414 | if (!Check(S, DecodeAddiur2Simm7(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11415 | return S; |
| 11416 | case 32: |
| 11417 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11418 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11419 | tmp = fieldFromInstruction(insn, 1, 6); |
| 11420 | if (!Check(S, DecodeUImmWithOffsetAndScale<6, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11421 | return S; |
| 11422 | case 33: |
| 11423 | if (!Check(S, DecodeMovePOperands(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11424 | return S; |
| 11425 | case 34: |
| 11426 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11427 | if (!Check(S, DecodeGPRMM16ZeroRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11428 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11429 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11430 | tmp = fieldFromInstruction(insn, 0, 4); |
| 11431 | if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11432 | return S; |
| 11433 | case 35: |
| 11434 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11435 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11436 | tmp = fieldFromInstruction(insn, 0, 7); |
| 11437 | if (!Check(S, DecodeBranchTarget7MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11438 | return S; |
| 11439 | case 36: |
| 11440 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11441 | if (!Check(S, DecodeGPRMM16ZeroRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11442 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11443 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11444 | tmp = fieldFromInstruction(insn, 0, 4); |
| 11445 | if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11446 | return S; |
| 11447 | case 37: |
| 11448 | tmp = fieldFromInstruction(insn, 0, 10); |
| 11449 | if (!Check(S, DecodeBranchTarget10MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11450 | return S; |
| 11451 | case 38: |
| 11452 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11453 | if (!Check(S, DecodeGPRMM16ZeroRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11454 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11455 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11456 | tmp = fieldFromInstruction(insn, 0, 4); |
| 11457 | if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11458 | return S; |
| 11459 | case 39: |
| 11460 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11461 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11462 | tmp = fieldFromInstruction(insn, 0, 7); |
| 11463 | if (!Check(S, DecodeLi16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11464 | return S; |
| 11465 | case 40: |
| 11466 | tmp = fieldFromInstruction(insn, 1, 3); |
| 11467 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11468 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11469 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11470 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11471 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11472 | return S; |
| 11473 | case 41: |
| 11474 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11475 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11476 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11477 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11478 | return S; |
| 11479 | case 42: |
| 11480 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11481 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11482 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11483 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11484 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11485 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11486 | return S; |
| 11487 | case 43: |
| 11488 | tmp = fieldFromInstruction(insn, 8, 2); |
| 11489 | if (!Check(S, DecodeRegListOperand16(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11490 | if (!Check(Out&: S, In: DecodeFixedPtrRegister<29>(Inst&: MI, Decoder))) |
| 11491 | return MCDisassembler::Fail; |
| 11492 | tmp = fieldFromInstruction(insn, 4, 4); |
| 11493 | if (!Check(S, DecodeUImmWithOffsetAndScale<4, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11494 | return S; |
| 11495 | case 44: |
| 11496 | tmp = fieldFromInstruction(insn, 5, 5); |
| 11497 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11498 | return S; |
| 11499 | case 45: |
| 11500 | tmp = fieldFromInstruction(insn, 5, 5); |
| 11501 | if (!Check(S, DecodeUImmWithOffsetAndScale<5, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11502 | return S; |
| 11503 | case 46: |
| 11504 | tmp = fieldFromInstruction(insn, 6, 4); |
| 11505 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11506 | return S; |
| 11507 | case 47: |
| 11508 | tmp = fieldFromInstruction(insn, 0, 2); |
| 11509 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11510 | return S; |
| 11511 | case 48: |
| 11512 | tmp = fieldFromInstruction(insn, 0, 3); |
| 11513 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11514 | return S; |
| 11515 | case 49: |
| 11516 | tmp = fieldFromInstruction(insn, 5, 5); |
| 11517 | if (!Check(S, DecodeGPR32NONZERORegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11518 | tmp = fieldFromInstruction(insn, 0, 5); |
| 11519 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11520 | return S; |
| 11521 | case 50: |
| 11522 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11523 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11524 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11525 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11526 | tmp = fieldFromInstruction(insn, 0, 4) << 2; |
| 11527 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11528 | return S; |
| 11529 | case 51: |
| 11530 | tmp = 0x0; |
| 11531 | tmp |= fieldFromInstruction(insn, 0, 1) << 10; |
| 11532 | tmp |= fieldFromInstruction(insn, 1, 9) << 1; |
| 11533 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11534 | return S; |
| 11535 | case 52: |
| 11536 | tmp = fieldFromInstruction(insn, 4, 4) << 4; |
| 11537 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11538 | tmp = 0x0; |
| 11539 | tmp |= fieldFromInstruction(insn, 0, 4); |
| 11540 | tmp |= fieldFromInstruction(insn, 9, 1) << 4; |
| 11541 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11542 | return S; |
| 11543 | case 53: |
| 11544 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11545 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11546 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11547 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11548 | tmp = fieldFromInstruction(insn, 0, 3); |
| 11549 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11550 | return S; |
| 11551 | case 54: |
| 11552 | tmp = fieldFromInstruction(insn, 5, 5); |
| 11553 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11554 | if (!Check(Out&: S, In: DecodeFixedPtrRegister<29>(Inst&: MI, Decoder))) |
| 11555 | return MCDisassembler::Fail; |
| 11556 | tmp = fieldFromInstruction(insn, 0, 5) << 2; |
| 11557 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11558 | return S; |
| 11559 | case 55: |
| 11560 | tmp = 0x0; |
| 11561 | tmp |= fieldFromInstruction(insn, 5, 3); |
| 11562 | tmp |= fieldFromInstruction(insn, 9, 1) << 4; |
| 11563 | if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11564 | tmp = 0x0; |
| 11565 | tmp |= fieldFromInstruction(insn, 5, 3); |
| 11566 | tmp |= fieldFromInstruction(insn, 9, 1) << 4; |
| 11567 | if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11568 | tmp = 0x0; |
| 11569 | tmp |= fieldFromInstruction(insn, 0, 3); |
| 11570 | tmp |= fieldFromInstruction(insn, 4, 1) << 4; |
| 11571 | if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11572 | return S; |
| 11573 | case 56: |
| 11574 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11575 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11576 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11577 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11578 | return S; |
| 11579 | case 57: |
| 11580 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11581 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11582 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11583 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11584 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11585 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11586 | return S; |
| 11587 | case 58: |
| 11588 | tmp = fieldFromInstruction(insn, 1, 3); |
| 11589 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11590 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11591 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11592 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11593 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11594 | return S; |
| 11595 | case 59: |
| 11596 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11597 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11598 | if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder))) |
| 11599 | return MCDisassembler::Fail; |
| 11600 | tmp = fieldFromInstruction(insn, 0, 7) << 2; |
| 11601 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11602 | return S; |
| 11603 | case 60: |
| 11604 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11605 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11606 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11607 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11608 | tmp = fieldFromInstruction(insn, 0, 2); |
| 11609 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11610 | return S; |
| 11611 | case 61: |
| 11612 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11613 | if (!Check(S, DecodeGPRNM3ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11614 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11615 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11616 | tmp = fieldFromInstruction(insn, 0, 2); |
| 11617 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11618 | return S; |
| 11619 | case 62: |
| 11620 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11621 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11622 | tmp = fieldFromInstruction(insn, 0, 6) << 2; |
| 11623 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11624 | return S; |
| 11625 | case 63: |
| 11626 | tmp = 0x0; |
| 11627 | tmp |= fieldFromInstruction(insn, 5, 3); |
| 11628 | tmp |= fieldFromInstruction(insn, 9, 1) << 4; |
| 11629 | if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11630 | tmp = 0x0; |
| 11631 | tmp |= fieldFromInstruction(insn, 0, 3); |
| 11632 | tmp |= fieldFromInstruction(insn, 4, 1) << 4; |
| 11633 | if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11634 | tmp = 0x0; |
| 11635 | tmp |= fieldFromInstruction(insn, 3, 1) << 3; |
| 11636 | tmp |= fieldFromInstruction(insn, 8, 1) << 2; |
| 11637 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11638 | return S; |
| 11639 | case 64: |
| 11640 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11641 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11642 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11643 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11644 | tmp = fieldFromInstruction(insn, 1, 2) << 1; |
| 11645 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11646 | return S; |
| 11647 | case 65: |
| 11648 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11649 | if (!Check(S, DecodeGPRNM3ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11650 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11651 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11652 | tmp = fieldFromInstruction(insn, 1, 2) << 1; |
| 11653 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11654 | return S; |
| 11655 | case 66: |
| 11656 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11657 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11658 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11659 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11660 | tmp = fieldFromInstruction(insn, 0, 3) << 2; |
| 11661 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11662 | return S; |
| 11663 | case 67: |
| 11664 | tmp = fieldFromInstruction(insn, 5, 5); |
| 11665 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11666 | tmp = fieldFromInstruction(insn, 5, 5); |
| 11667 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11668 | tmp = 0x0; |
| 11669 | tmp |= fieldFromInstruction(insn, 0, 3); |
| 11670 | tmp |= fieldFromInstruction(insn, 4, 1) << 3; |
| 11671 | if (!Check(S, DecodeSImmWithOffsetAndScale<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11672 | return S; |
| 11673 | case 68: |
| 11674 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11675 | if (!Check(S, DecodeGPRNM3ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11676 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11677 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11678 | tmp = fieldFromInstruction(insn, 0, 4) << 2; |
| 11679 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11680 | return S; |
| 11681 | case 69: |
| 11682 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11683 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11684 | tmp = 0x0; |
| 11685 | tmp |= fieldFromInstruction(insn, 0, 1) << 7; |
| 11686 | tmp |= fieldFromInstruction(insn, 1, 6) << 1; |
| 11687 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11688 | return S; |
| 11689 | case 70: |
| 11690 | tmp = fieldFromInstruction(insn, 1, 3); |
| 11691 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11692 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11693 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11694 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11695 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11696 | return S; |
| 11697 | case 71: |
| 11698 | tmp = 0x0; |
| 11699 | tmp |= fieldFromInstruction(insn, 3, 1) << 1; |
| 11700 | tmp |= fieldFromInstruction(insn, 8, 1); |
| 11701 | if (!Check(S, DecodeGPRNM2R1RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11702 | tmp = 0x0; |
| 11703 | tmp |= fieldFromInstruction(insn, 0, 3); |
| 11704 | tmp |= fieldFromInstruction(insn, 4, 1) << 4; |
| 11705 | if (!Check(S, DecodeGPRNM4ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11706 | tmp = 0x0; |
| 11707 | tmp |= fieldFromInstruction(insn, 5, 3); |
| 11708 | tmp |= fieldFromInstruction(insn, 9, 1) << 4; |
| 11709 | if (!Check(S, DecodeGPRNM4ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11710 | return S; |
| 11711 | case 72: |
| 11712 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11713 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11714 | tmp = fieldFromInstruction(insn, 0, 7); |
| 11715 | if (!Check(S, DecodeLi16Imm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11716 | return S; |
| 11717 | case 73: |
| 11718 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11719 | if (!Check(S, DecodeGPRNM3ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11720 | if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder))) |
| 11721 | return MCDisassembler::Fail; |
| 11722 | tmp = fieldFromInstruction(insn, 0, 7) << 2; |
| 11723 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11724 | return S; |
| 11725 | case 74: |
| 11726 | tmp = fieldFromInstruction(insn, 4, 1); |
| 11727 | if (!Check(S, DecodeGPRNMRARegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11728 | tmp = fieldFromInstruction(insn, 5, 5); |
| 11729 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11730 | return S; |
| 11731 | case 75: |
| 11732 | tmp = fieldFromInstruction(insn, 7, 3); |
| 11733 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11734 | tmp = fieldFromInstruction(insn, 4, 3); |
| 11735 | if (!Check(S, DecodeGPRNM3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11736 | tmp = fieldFromInstruction(insn, 0, 4); |
| 11737 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11738 | return S; |
| 11739 | case 76: |
| 11740 | tmp = 0x0; |
| 11741 | tmp |= fieldFromInstruction(insn, 5, 3); |
| 11742 | tmp |= fieldFromInstruction(insn, 9, 1) << 4; |
| 11743 | if (!Check(S, DecodeGPRNM4ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11744 | tmp = 0x0; |
| 11745 | tmp |= fieldFromInstruction(insn, 0, 3); |
| 11746 | tmp |= fieldFromInstruction(insn, 4, 1) << 4; |
| 11747 | if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11748 | tmp = 0x0; |
| 11749 | tmp |= fieldFromInstruction(insn, 3, 1) << 3; |
| 11750 | tmp |= fieldFromInstruction(insn, 8, 1) << 2; |
| 11751 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11752 | return S; |
| 11753 | case 77: |
| 11754 | tmp = 0x0; |
| 11755 | tmp |= fieldFromInstruction(insn, 0, 3); |
| 11756 | tmp |= fieldFromInstruction(insn, 4, 1) << 4; |
| 11757 | if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11758 | tmp = 0x0; |
| 11759 | tmp |= fieldFromInstruction(insn, 5, 3); |
| 11760 | tmp |= fieldFromInstruction(insn, 9, 1) << 4; |
| 11761 | if (!Check(S, DecodeGPRNM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11762 | tmp = 0x0; |
| 11763 | tmp |= fieldFromInstruction(insn, 3, 1) << 1; |
| 11764 | tmp |= fieldFromInstruction(insn, 8, 1); |
| 11765 | if (!Check(S, DecodeGPRNM2R1RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11766 | return S; |
| 11767 | case 78: |
| 11768 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11769 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11770 | tmp = 0x0; |
| 11771 | tmp |= fieldFromInstruction(insn, 0, 5); |
| 11772 | tmp |= fieldFromInstruction(insn, 16, 5) << 11; |
| 11773 | tmp |= fieldFromInstruction(insn, 21, 6) << 5; |
| 11774 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11775 | return S; |
| 11776 | case 79: |
| 11777 | tmp = 0x0; |
| 11778 | tmp |= fieldFromInstruction(insn, 0, 5); |
| 11779 | tmp |= fieldFromInstruction(insn, 16, 5) << 11; |
| 11780 | tmp |= fieldFromInstruction(insn, 21, 6) << 5; |
| 11781 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11782 | return S; |
| 11783 | case 80: |
| 11784 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11785 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11786 | tmp = 0x0; |
| 11787 | tmp |= fieldFromInstruction(insn, 0, 5); |
| 11788 | tmp |= fieldFromInstruction(insn, 16, 5) << 11; |
| 11789 | tmp |= fieldFromInstruction(insn, 21, 6) << 5; |
| 11790 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11791 | return S; |
| 11792 | case 81: |
| 11793 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11794 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11795 | tmp = fieldFromInstruction(insn, 5, 3); |
| 11796 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11797 | tmp = 0x0; |
| 11798 | tmp |= fieldFromInstruction(insn, 21, 1) << 5; |
| 11799 | tmp |= fieldFromInstruction(insn, 22, 5); |
| 11800 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11801 | return S; |
| 11802 | case 82: |
| 11803 | tmp = 0x0; |
| 11804 | tmp |= fieldFromInstruction(insn, 0, 5); |
| 11805 | tmp |= fieldFromInstruction(insn, 16, 5) << 11; |
| 11806 | tmp |= fieldFromInstruction(insn, 21, 6) << 5; |
| 11807 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11808 | return S; |
| 11809 | case 83: |
| 11810 | if (!Check(S, DecodeFIXMEInstruction(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11811 | return S; |
| 11812 | case 84: |
| 11813 | tmp = fieldFromInstruction(insn, 8, 3); |
| 11814 | if (!Check(S, DecodeCPU16RegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11815 | tmp = 0x0; |
| 11816 | tmp |= fieldFromInstruction(insn, 0, 5); |
| 11817 | tmp |= fieldFromInstruction(insn, 16, 5) << 11; |
| 11818 | tmp |= fieldFromInstruction(insn, 21, 6) << 5; |
| 11819 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11820 | return S; |
| 11821 | case 85: |
| 11822 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11823 | if (!Check(S, DecodeCOP3RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11824 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11825 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11826 | tmp = fieldFromInstruction(insn, 0, 16); |
| 11827 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11828 | return S; |
| 11829 | case 86: |
| 11830 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11831 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11832 | tmp = fieldFromInstruction(insn, 0, 16); |
| 11833 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11834 | return S; |
| 11835 | case 87: |
| 11836 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11837 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11838 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11839 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11840 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11841 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11842 | return S; |
| 11843 | case 88: |
| 11844 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11845 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11846 | return S; |
| 11847 | case 89: |
| 11848 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11849 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11850 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11851 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11852 | return S; |
| 11853 | case 90: |
| 11854 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11855 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11856 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11857 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11858 | return S; |
| 11859 | case 91: |
| 11860 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11861 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11862 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11863 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11864 | tmp = fieldFromInstruction(insn, 6, 10); |
| 11865 | if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11866 | return S; |
| 11867 | case 92: |
| 11868 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11869 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11870 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11871 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11872 | tmp = fieldFromInstruction(insn, 6, 5); |
| 11873 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11874 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11875 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11876 | return S; |
| 11877 | case 93: |
| 11878 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11879 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11880 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11881 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11882 | tmp = fieldFromInstruction(insn, 0, 16); |
| 11883 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11884 | return S; |
| 11885 | case 94: |
| 11886 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11887 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11888 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11889 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11890 | return S; |
| 11891 | case 95: |
| 11892 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11893 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11894 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11895 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11896 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11897 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11898 | return S; |
| 11899 | case 96: |
| 11900 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11901 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11902 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11903 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11904 | return S; |
| 11905 | case 97: |
| 11906 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11907 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11908 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11909 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11910 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11911 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11912 | return S; |
| 11913 | case 98: |
| 11914 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11915 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11916 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11917 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11918 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11919 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11920 | return S; |
| 11921 | case 99: |
| 11922 | tmp = fieldFromInstruction(insn, 16, 10); |
| 11923 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11924 | tmp = fieldFromInstruction(insn, 6, 10); |
| 11925 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11926 | return S; |
| 11927 | case 100: |
| 11928 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11929 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11930 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11931 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11932 | tmp = fieldFromInstruction(insn, 6, 5); |
| 11933 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11934 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11935 | if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11936 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11937 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11938 | return S; |
| 11939 | case 101: |
| 11940 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11941 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11942 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11943 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11944 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11945 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11946 | return S; |
| 11947 | case 102: |
| 11948 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11949 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11950 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11951 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11952 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11953 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11954 | return S; |
| 11955 | case 103: |
| 11956 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11957 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11958 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11959 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11960 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11961 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11962 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11963 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11964 | return S; |
| 11965 | case 104: |
| 11966 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11967 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11968 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11969 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11970 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11971 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11972 | return S; |
| 11973 | case 105: |
| 11974 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11975 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11976 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11977 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11978 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11979 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 11980 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11981 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11982 | return S; |
| 11983 | case 106: |
| 11984 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11985 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11986 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11987 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11988 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11989 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11990 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11991 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11992 | return S; |
| 11993 | case 107: |
| 11994 | tmp = fieldFromInstruction(insn, 11, 5); |
| 11995 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11996 | tmp = fieldFromInstruction(insn, 16, 5); |
| 11997 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 11998 | tmp = fieldFromInstruction(insn, 21, 5); |
| 11999 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12000 | return S; |
| 12001 | case 108: |
| 12002 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12003 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12004 | tmp = fieldFromInstruction(insn, 16, 6); |
| 12005 | if (!Check(S, DecodeSImmWithOffsetAndScale<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12006 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12007 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12008 | return S; |
| 12009 | case 109: |
| 12010 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12011 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12012 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12013 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12014 | tmp = fieldFromInstruction(insn, 6, 5); |
| 12015 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12016 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12017 | if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12018 | return S; |
| 12019 | case 110: |
| 12020 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12021 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12022 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12023 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12024 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12025 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12026 | return S; |
| 12027 | case 111: |
| 12028 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12029 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12030 | tmp = 0x0; |
| 12031 | tmp |= fieldFromInstruction(insn, 11, 3); |
| 12032 | tmp |= fieldFromInstruction(insn, 16, 5) << 5; |
| 12033 | if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12034 | return S; |
| 12035 | case 112: |
| 12036 | tmp = 0x0; |
| 12037 | tmp |= fieldFromInstruction(insn, 11, 3); |
| 12038 | tmp |= fieldFromInstruction(insn, 16, 5) << 5; |
| 12039 | if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12040 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12041 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12042 | return S; |
| 12043 | case 113: |
| 12044 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12045 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12046 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12047 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12048 | tmp = fieldFromInstruction(insn, 12, 4); |
| 12049 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12050 | return S; |
| 12051 | case 114: |
| 12052 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12053 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12054 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12055 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12056 | tmp = fieldFromInstruction(insn, 12, 4); |
| 12057 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12058 | return S; |
| 12059 | case 115: |
| 12060 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12061 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12062 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12063 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12064 | return S; |
| 12065 | case 116: |
| 12066 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12067 | if (!Check(S, DecodeHI32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12068 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12069 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12070 | return S; |
| 12071 | case 117: |
| 12072 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12073 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12074 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12075 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12076 | tmp = fieldFromInstruction(insn, 13, 3); |
| 12077 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12078 | return S; |
| 12079 | case 118: |
| 12080 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12081 | if (!Check(S, DecodeLO32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12082 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12083 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12084 | return S; |
| 12085 | case 119: |
| 12086 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12087 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12088 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12089 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12090 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12091 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12092 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12093 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12094 | return S; |
| 12095 | case 120: |
| 12096 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12097 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12098 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12099 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12100 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12101 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12102 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12103 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12104 | return S; |
| 12105 | case 121: |
| 12106 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12107 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12108 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12109 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12110 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12111 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12112 | return S; |
| 12113 | case 122: |
| 12114 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12115 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12116 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12117 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12118 | return S; |
| 12119 | case 123: |
| 12120 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12121 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12122 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12123 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12124 | return S; |
| 12125 | case 124: |
| 12126 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12127 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12128 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12129 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12130 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12131 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12132 | return S; |
| 12133 | case 125: |
| 12134 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12135 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12136 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12137 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12138 | return S; |
| 12139 | case 126: |
| 12140 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12141 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12142 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12143 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12144 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12145 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12146 | return S; |
| 12147 | case 127: |
| 12148 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12149 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12150 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12151 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12152 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12153 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12154 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12155 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12156 | return S; |
| 12157 | case 128: |
| 12158 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12159 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12160 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12161 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12162 | return S; |
| 12163 | case 129: |
| 12164 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12165 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12166 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12167 | if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12168 | return S; |
| 12169 | case 130: |
| 12170 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12171 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12172 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12173 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12174 | return S; |
| 12175 | case 131: |
| 12176 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12177 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12178 | return S; |
| 12179 | case 132: |
| 12180 | tmp = fieldFromInstruction(insn, 16, 10); |
| 12181 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12182 | return S; |
| 12183 | case 133: |
| 12184 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12185 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12186 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12187 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12188 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12189 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12190 | return S; |
| 12191 | case 134: |
| 12192 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12193 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12194 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12195 | if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12196 | return S; |
| 12197 | case 135: |
| 12198 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12199 | if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12200 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12201 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12202 | return S; |
| 12203 | case 136: |
| 12204 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12205 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12206 | return S; |
| 12207 | case 137: |
| 12208 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12209 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12210 | tmp = fieldFromInstruction(insn, 13, 8); |
| 12211 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12212 | return S; |
| 12213 | case 138: |
| 12214 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12215 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12216 | tmp = fieldFromInstruction(insn, 14, 7); |
| 12217 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12218 | return S; |
| 12219 | case 139: |
| 12220 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12221 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12222 | tmp = fieldFromInstruction(insn, 14, 2); |
| 12223 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12224 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12225 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12226 | return S; |
| 12227 | case 140: |
| 12228 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12229 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12230 | tmp = fieldFromInstruction(insn, 16, 10); |
| 12231 | if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12232 | return S; |
| 12233 | case 141: |
| 12234 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12235 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12236 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12237 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12238 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12239 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12240 | return S; |
| 12241 | case 142: |
| 12242 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12243 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12244 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12245 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12246 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12247 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12248 | return S; |
| 12249 | case 143: |
| 12250 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12251 | if (!Check(S, DecodeGPR32Pair(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12252 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12253 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12254 | tmp = fieldFromInstruction(insn, 0, 12); |
| 12255 | if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12256 | return S; |
| 12257 | case 144: |
| 12258 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12259 | if (!Check(S, DecodeRegListOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12260 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12261 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12262 | tmp = fieldFromInstruction(insn, 0, 12); |
| 12263 | if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12264 | return S; |
| 12265 | case 145: |
| 12266 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12267 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12268 | tmp = fieldFromInstruction(insn, 0, 12); |
| 12269 | if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12270 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12271 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12272 | return S; |
| 12273 | case 146: |
| 12274 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12275 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12276 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12277 | if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12278 | return S; |
| 12279 | case 147: |
| 12280 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12281 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12282 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12283 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12284 | return S; |
| 12285 | case 148: |
| 12286 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12287 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12288 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12289 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12290 | return S; |
| 12291 | case 149: |
| 12292 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12293 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12294 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12295 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12296 | return S; |
| 12297 | case 150: |
| 12298 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12299 | if (!Check(S, DecodeBranchTarget1SImm16(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12300 | return S; |
| 12301 | case 151: |
| 12302 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12303 | if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12304 | return S; |
| 12305 | case 152: |
| 12306 | tmp = fieldFromInstruction(insn, 18, 3); |
| 12307 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12308 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12309 | if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12310 | return S; |
| 12311 | case 153: |
| 12312 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12313 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12314 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12315 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12316 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12317 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12318 | return S; |
| 12319 | case 154: |
| 12320 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12321 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12322 | tmp = fieldFromInstruction(insn, 6, 5); |
| 12323 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12324 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12325 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12326 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12327 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12328 | return S; |
| 12329 | case 155: |
| 12330 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12331 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12332 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12333 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12334 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12335 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12336 | return S; |
| 12337 | case 156: |
| 12338 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12339 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12340 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12341 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12342 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12343 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12344 | return S; |
| 12345 | case 157: |
| 12346 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12347 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12348 | tmp = fieldFromInstruction(insn, 6, 5); |
| 12349 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12350 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12351 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12352 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12353 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12354 | return S; |
| 12355 | case 158: |
| 12356 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12357 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12358 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12359 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12360 | tmp = fieldFromInstruction(insn, 13, 3); |
| 12361 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12362 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12363 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12364 | return S; |
| 12365 | case 159: |
| 12366 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12367 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12368 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12369 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12370 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12371 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12372 | return S; |
| 12373 | case 160: |
| 12374 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12375 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12376 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12377 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12378 | tmp = fieldFromInstruction(insn, 13, 3); |
| 12379 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12380 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12381 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12382 | return S; |
| 12383 | case 161: |
| 12384 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12385 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12386 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12387 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12388 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12389 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12390 | return S; |
| 12391 | case 162: |
| 12392 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12393 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12394 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12395 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12396 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12397 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12398 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12399 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12400 | return S; |
| 12401 | case 163: |
| 12402 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12403 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12404 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12405 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12406 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12407 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12408 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12409 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12410 | return S; |
| 12411 | case 164: |
| 12412 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12413 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12414 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12415 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12416 | return S; |
| 12417 | case 165: |
| 12418 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12419 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12420 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12421 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12422 | return S; |
| 12423 | case 166: |
| 12424 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12425 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12426 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12427 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12428 | return S; |
| 12429 | case 167: |
| 12430 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12431 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12432 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12433 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12434 | return S; |
| 12435 | case 168: |
| 12436 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12437 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12438 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12439 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12440 | tmp = fieldFromInstruction(insn, 13, 3); |
| 12441 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12442 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12443 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12444 | return S; |
| 12445 | case 169: |
| 12446 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12447 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12448 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12449 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12450 | return S; |
| 12451 | case 170: |
| 12452 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12453 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12454 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12455 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12456 | return S; |
| 12457 | case 171: |
| 12458 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12459 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12460 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12461 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12462 | return S; |
| 12463 | case 172: |
| 12464 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12465 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12466 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12467 | if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12468 | return S; |
| 12469 | case 173: |
| 12470 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12471 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12472 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12473 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12474 | return S; |
| 12475 | case 174: |
| 12476 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12477 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12478 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12479 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12480 | return S; |
| 12481 | case 175: |
| 12482 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12483 | if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12484 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12485 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12486 | return S; |
| 12487 | case 176: |
| 12488 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12489 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12490 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12491 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12492 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12493 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12494 | return S; |
| 12495 | case 177: |
| 12496 | tmp = fieldFromInstruction(insn, 13, 3); |
| 12497 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12498 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12499 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12500 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12501 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12502 | return S; |
| 12503 | case 178: |
| 12504 | tmp = fieldFromInstruction(insn, 13, 3); |
| 12505 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12506 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12507 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12508 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12509 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12510 | return S; |
| 12511 | case 179: |
| 12512 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12513 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12514 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12515 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12516 | tmp = fieldFromInstruction(insn, 0, 12); |
| 12517 | if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12518 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12519 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12520 | return S; |
| 12521 | case 180: |
| 12522 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12523 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12524 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12525 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12526 | tmp = fieldFromInstruction(insn, 0, 12); |
| 12527 | if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12528 | return S; |
| 12529 | case 181: |
| 12530 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12531 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12532 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12533 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12534 | tmp = fieldFromInstruction(insn, 0, 9); |
| 12535 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12536 | return S; |
| 12537 | case 182: |
| 12538 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12539 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12540 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12541 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12542 | tmp = fieldFromInstruction(insn, 0, 9); |
| 12543 | if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12544 | return S; |
| 12545 | case 183: |
| 12546 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12547 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12548 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12549 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12550 | tmp = fieldFromInstruction(insn, 0, 9); |
| 12551 | if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12552 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12553 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12554 | return S; |
| 12555 | case 184: |
| 12556 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12557 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12558 | tmp = fieldFromInstruction(insn, 0, 9); |
| 12559 | if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12560 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12561 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12562 | return S; |
| 12563 | case 185: |
| 12564 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12565 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12566 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12567 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12568 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12569 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12570 | tmp = fieldFromInstruction(insn, 0, 9); |
| 12571 | if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12572 | return S; |
| 12573 | case 186: |
| 12574 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12575 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12576 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12577 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12578 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12579 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12580 | tmp = fieldFromInstruction(insn, 0, 12); |
| 12581 | if (!Check(S, DecodeSImmWithOffsetAndScale<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12582 | return S; |
| 12583 | case 187: |
| 12584 | if (!Check(S, DecodeJumpTargetMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12585 | return S; |
| 12586 | case 188: |
| 12587 | tmp = fieldFromInstruction(insn, 23, 3); |
| 12588 | if (!Check(S, DecodeGPRMM16RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12589 | tmp = fieldFromInstruction(insn, 0, 23); |
| 12590 | if (!Check(S, DecodeSimm23Lsl2(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12591 | return S; |
| 12592 | case 189: |
| 12593 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12594 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12595 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12596 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12597 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12598 | if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12599 | return S; |
| 12600 | case 190: |
| 12601 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12602 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12603 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12604 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12605 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12606 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12607 | return S; |
| 12608 | case 191: |
| 12609 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12610 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12611 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12612 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12613 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12614 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12615 | return S; |
| 12616 | case 192: |
| 12617 | if (!Check(S, DecodeJumpTargetXMM(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12618 | return S; |
| 12619 | case 193: |
| 12620 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12621 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12622 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12623 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12624 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12625 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12626 | return S; |
| 12627 | case 194: |
| 12628 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12629 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12630 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12631 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12632 | return S; |
| 12633 | case 195: |
| 12634 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12635 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12636 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12637 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12638 | return S; |
| 12639 | case 196: |
| 12640 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12641 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12642 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12643 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12644 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12645 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12646 | return S; |
| 12647 | case 197: |
| 12648 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12649 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12650 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12651 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12652 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12653 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12654 | return S; |
| 12655 | case 198: |
| 12656 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12657 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12658 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12659 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12660 | return S; |
| 12661 | case 199: |
| 12662 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12663 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12664 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12665 | if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12666 | tmp = fieldFromInstruction(insn, 11, 3); |
| 12667 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12668 | return S; |
| 12669 | case 200: |
| 12670 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12671 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12672 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12673 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12674 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12675 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12676 | tmp = fieldFromInstruction(insn, 9, 2); |
| 12677 | if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12678 | return S; |
| 12679 | case 201: |
| 12680 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12681 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12682 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12683 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12684 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12685 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12686 | tmp = fieldFromInstruction(insn, 9, 2); |
| 12687 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12688 | return S; |
| 12689 | case 202: |
| 12690 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12691 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12692 | tmp = fieldFromInstruction(insn, 9, 2); |
| 12693 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12694 | return S; |
| 12695 | case 203: |
| 12696 | tmp = fieldFromInstruction(insn, 6, 16); |
| 12697 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12698 | return S; |
| 12699 | case 204: |
| 12700 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12701 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12702 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12703 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12704 | return S; |
| 12705 | case 205: |
| 12706 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12707 | if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12708 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12709 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12710 | tmp = fieldFromInstruction(insn, 0, 11); |
| 12711 | if (!Check(S, DecodeSImmWithOffsetAndScale<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12712 | return S; |
| 12713 | case 206: |
| 12714 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12715 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12716 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12717 | if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12718 | return S; |
| 12719 | case 207: |
| 12720 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12721 | if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12722 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12723 | if (!Check(S, DecodeBranchTargetMM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12724 | return S; |
| 12725 | case 208: |
| 12726 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12727 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12728 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12729 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12730 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12731 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12732 | return S; |
| 12733 | case 209: |
| 12734 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12735 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12736 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12737 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12738 | return S; |
| 12739 | case 210: |
| 12740 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12741 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12742 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12743 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12744 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12745 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12746 | return S; |
| 12747 | case 211: |
| 12748 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12749 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12750 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12751 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12752 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12753 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12754 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12755 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12756 | return S; |
| 12757 | case 212: |
| 12758 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12759 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12760 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12761 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12762 | return S; |
| 12763 | case 213: |
| 12764 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12765 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12766 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12767 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12768 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12769 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12770 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12771 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12772 | return S; |
| 12773 | case 214: |
| 12774 | if (!Check(S, DecodePOP35GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12775 | return S; |
| 12776 | case 215: |
| 12777 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12778 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12779 | tmp = fieldFromInstruction(insn, 0, 19); |
| 12780 | if (!Check(S, DecodeSimm19Lsl2(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12781 | return S; |
| 12782 | case 216: |
| 12783 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12784 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12785 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12786 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12787 | return S; |
| 12788 | case 217: |
| 12789 | if (!Check(S, DecodePOP37GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12790 | return S; |
| 12791 | case 218: |
| 12792 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12793 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12794 | tmp = fieldFromInstruction(insn, 0, 21); |
| 12795 | if (!Check(S, DecodeBranchTarget21MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12796 | return S; |
| 12797 | case 219: |
| 12798 | tmp = fieldFromInstruction(insn, 0, 26); |
| 12799 | if (!Check(S, DecodeBranchTarget26MM(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12800 | return S; |
| 12801 | case 220: |
| 12802 | if (!Check(S, DecodeBlezGroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12803 | return S; |
| 12804 | case 221: |
| 12805 | if (!Check(S, DecodePOP65GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12806 | return S; |
| 12807 | case 222: |
| 12808 | if (!Check(S, DecodeBgtzGroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12809 | return S; |
| 12810 | case 223: |
| 12811 | if (!Check(S, DecodePOP75GroupBranchMMR6(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12812 | return S; |
| 12813 | case 224: |
| 12814 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12815 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12816 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12817 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12818 | tmp = fieldFromInstruction(insn, 6, 5); |
| 12819 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12820 | return S; |
| 12821 | case 225: |
| 12822 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12823 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12824 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12825 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12826 | tmp = fieldFromInstruction(insn, 18, 3); |
| 12827 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12828 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12829 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12830 | return S; |
| 12831 | case 226: |
| 12832 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12833 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12834 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12835 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12836 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12837 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12838 | tmp = fieldFromInstruction(insn, 6, 2); |
| 12839 | if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12840 | return S; |
| 12841 | case 227: |
| 12842 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12843 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12844 | return S; |
| 12845 | case 228: |
| 12846 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12847 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12848 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12849 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12850 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12851 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12852 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12853 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12854 | return S; |
| 12855 | case 229: |
| 12856 | tmp = fieldFromInstruction(insn, 6, 20); |
| 12857 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12858 | return S; |
| 12859 | case 230: |
| 12860 | tmp = fieldFromInstruction(insn, 6, 5); |
| 12861 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12862 | return S; |
| 12863 | case 231: |
| 12864 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12865 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12866 | return S; |
| 12867 | case 232: |
| 12868 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12869 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12870 | tmp = fieldFromInstruction(insn, 21, 2); |
| 12871 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12872 | return S; |
| 12873 | case 233: |
| 12874 | tmp = fieldFromInstruction(insn, 11, 2); |
| 12875 | if (!Check(S, DecodeHI32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12876 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12877 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12878 | return S; |
| 12879 | case 234: |
| 12880 | tmp = fieldFromInstruction(insn, 11, 2); |
| 12881 | if (!Check(S, DecodeLO32DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12882 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12883 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12884 | return S; |
| 12885 | case 235: |
| 12886 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12887 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12888 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12889 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12890 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12891 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12892 | tmp = fieldFromInstruction(insn, 6, 2); |
| 12893 | if (!Check(S, DecodeUImmWithOffset<2, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12894 | return S; |
| 12895 | case 236: |
| 12896 | tmp = fieldFromInstruction(insn, 11, 2); |
| 12897 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12898 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12899 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12900 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12901 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12902 | return S; |
| 12903 | case 237: |
| 12904 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12905 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12906 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12907 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12908 | tmp = fieldFromInstruction(insn, 6, 10); |
| 12909 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12910 | return S; |
| 12911 | case 238: |
| 12912 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12913 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12914 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12915 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12916 | return S; |
| 12917 | case 239: |
| 12918 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12919 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12920 | return S; |
| 12921 | case 240: |
| 12922 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12923 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12924 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12925 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12926 | return S; |
| 12927 | case 241: |
| 12928 | if (!Check(S, DecodeJumpTarget(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12929 | return S; |
| 12930 | case 242: |
| 12931 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12932 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12933 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12934 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12935 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12936 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12937 | return S; |
| 12938 | case 243: |
| 12939 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12940 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12941 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12942 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12943 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12944 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12945 | return S; |
| 12946 | case 244: |
| 12947 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12948 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12949 | tmp = fieldFromInstruction(insn, 21, 5); |
| 12950 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12951 | tmp = fieldFromInstruction(insn, 0, 16); |
| 12952 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12953 | return S; |
| 12954 | case 245: |
| 12955 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12956 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12957 | tmp = 0x0; |
| 12958 | tmp |= fieldFromInstruction(insn, 0, 3); |
| 12959 | tmp |= fieldFromInstruction(insn, 11, 5) << 5; |
| 12960 | if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12961 | return S; |
| 12962 | case 246: |
| 12963 | tmp = 0x0; |
| 12964 | tmp |= fieldFromInstruction(insn, 0, 3); |
| 12965 | tmp |= fieldFromInstruction(insn, 11, 5) << 5; |
| 12966 | if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12967 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12968 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12969 | return S; |
| 12970 | case 247: |
| 12971 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12972 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12973 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12974 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12975 | tmp = fieldFromInstruction(insn, 5, 1); |
| 12976 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12977 | tmp = fieldFromInstruction(insn, 0, 3); |
| 12978 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12979 | tmp = fieldFromInstruction(insn, 4, 1); |
| 12980 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12981 | return S; |
| 12982 | case 248: |
| 12983 | tmp = fieldFromInstruction(insn, 11, 10); |
| 12984 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 12985 | return S; |
| 12986 | case 249: |
| 12987 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12988 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12989 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12990 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12991 | return S; |
| 12992 | case 250: |
| 12993 | tmp = fieldFromInstruction(insn, 16, 5); |
| 12994 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12995 | tmp = fieldFromInstruction(insn, 11, 5); |
| 12996 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 12997 | return S; |
| 12998 | case 251: |
| 12999 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13000 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13001 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13002 | if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13003 | return S; |
| 13004 | case 252: |
| 13005 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13006 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13007 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13008 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13009 | return S; |
| 13010 | case 253: |
| 13011 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13012 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13013 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13014 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13015 | return S; |
| 13016 | case 254: |
| 13017 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13018 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13019 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13020 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13021 | return S; |
| 13022 | case 255: |
| 13023 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13024 | if (!Check(S, DecodeCCRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13025 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13026 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13027 | return S; |
| 13028 | case 256: |
| 13029 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13030 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13031 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13032 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13033 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13034 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13035 | return S; |
| 13036 | case 257: |
| 13037 | tmp = fieldFromInstruction(insn, 18, 3); |
| 13038 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13039 | tmp = fieldFromInstruction(insn, 0, 16); |
| 13040 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13041 | return S; |
| 13042 | case 258: |
| 13043 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13044 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13045 | tmp = fieldFromInstruction(insn, 0, 16); |
| 13046 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13047 | return S; |
| 13048 | case 259: |
| 13049 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13050 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13051 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13052 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13053 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13054 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13055 | return S; |
| 13056 | case 260: |
| 13057 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13058 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13059 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13060 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13061 | return S; |
| 13062 | case 261: |
| 13063 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13064 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13065 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13066 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13067 | tmp = fieldFromInstruction(insn, 18, 3); |
| 13068 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13069 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13070 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13071 | return S; |
| 13072 | case 262: |
| 13073 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13074 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13075 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13076 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13077 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13078 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13079 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13080 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13081 | return S; |
| 13082 | case 263: |
| 13083 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13084 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13085 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13086 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13087 | return S; |
| 13088 | case 264: |
| 13089 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13090 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13091 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13092 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13093 | return S; |
| 13094 | case 265: |
| 13095 | tmp = fieldFromInstruction(insn, 8, 3); |
| 13096 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13097 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13098 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13099 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13100 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13101 | return S; |
| 13102 | case 266: |
| 13103 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13104 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13105 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13106 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13107 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13108 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13109 | return S; |
| 13110 | case 267: |
| 13111 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13112 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13113 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13114 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13115 | return S; |
| 13116 | case 268: |
| 13117 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13118 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13119 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13120 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13121 | return S; |
| 13122 | case 269: |
| 13123 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13124 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13125 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13126 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13127 | tmp = fieldFromInstruction(insn, 18, 3); |
| 13128 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13129 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13130 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13131 | return S; |
| 13132 | case 270: |
| 13133 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13134 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13135 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13136 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13137 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13138 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13139 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13140 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13141 | return S; |
| 13142 | case 271: |
| 13143 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13144 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13145 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13146 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13147 | return S; |
| 13148 | case 272: |
| 13149 | tmp = fieldFromInstruction(insn, 8, 3); |
| 13150 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13151 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13152 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13153 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13154 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13155 | return S; |
| 13156 | case 273: |
| 13157 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13158 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13159 | tmp = fieldFromInstruction(insn, 0, 16); |
| 13160 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13161 | return S; |
| 13162 | case 274: |
| 13163 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13164 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13165 | tmp = fieldFromInstruction(insn, 0, 16); |
| 13166 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13167 | return S; |
| 13168 | case 275: |
| 13169 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13170 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13171 | tmp = fieldFromInstruction(insn, 0, 16); |
| 13172 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13173 | return S; |
| 13174 | case 276: |
| 13175 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13176 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13177 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13178 | if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13179 | tmp = fieldFromInstruction(insn, 0, 3); |
| 13180 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13181 | return S; |
| 13182 | case 277: |
| 13183 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13184 | if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13185 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13186 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13187 | tmp = fieldFromInstruction(insn, 0, 3); |
| 13188 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13189 | return S; |
| 13190 | case 278: |
| 13191 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13192 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13193 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13194 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13195 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13196 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13197 | return S; |
| 13198 | case 279: |
| 13199 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13200 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13201 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13202 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13203 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13204 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13205 | return S; |
| 13206 | case 280: |
| 13207 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13208 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13209 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13210 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13211 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13212 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13213 | return S; |
| 13214 | case 281: |
| 13215 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13216 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13217 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13218 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13219 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13220 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13221 | return S; |
| 13222 | case 282: |
| 13223 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13224 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13225 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13226 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13227 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13228 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13229 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13230 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13231 | return S; |
| 13232 | case 283: |
| 13233 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13234 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13235 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13236 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13237 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13238 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13239 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13240 | if (!Check(S, DecodeAFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13241 | return S; |
| 13242 | case 284: |
| 13243 | tmp = fieldFromInstruction(insn, 11, 2); |
| 13244 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13245 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13246 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13247 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13248 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13249 | tmp = fieldFromInstruction(insn, 11, 2); |
| 13250 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13251 | return S; |
| 13252 | case 285: |
| 13253 | tmp = 0x0; |
| 13254 | tmp |= fieldFromInstruction(insn, 11, 5); |
| 13255 | tmp |= fieldFromInstruction(insn, 16, 5); |
| 13256 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13257 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13258 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13259 | return S; |
| 13260 | case 286: |
| 13261 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13262 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13263 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13264 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13265 | tmp = fieldFromInstruction(insn, 16, 8); |
| 13266 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13267 | return S; |
| 13268 | case 287: |
| 13269 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13270 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13271 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13272 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13273 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13274 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13275 | tmp = fieldFromInstruction(insn, 16, 8); |
| 13276 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13277 | return S; |
| 13278 | case 288: |
| 13279 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13280 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13281 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13282 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13283 | tmp = fieldFromInstruction(insn, 16, 8); |
| 13284 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13285 | return S; |
| 13286 | case 289: |
| 13287 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13288 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13289 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13290 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13291 | tmp = fieldFromInstruction(insn, 16, 8); |
| 13292 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13293 | return S; |
| 13294 | case 290: |
| 13295 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13296 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13297 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13298 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13299 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13300 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13301 | return S; |
| 13302 | case 291: |
| 13303 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13304 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13305 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13306 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13307 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13308 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13309 | return S; |
| 13310 | case 292: |
| 13311 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13312 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13313 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13314 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13315 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13316 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13317 | return S; |
| 13318 | case 293: |
| 13319 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13320 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13321 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13322 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13323 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13324 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13325 | return S; |
| 13326 | case 294: |
| 13327 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13328 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13329 | tmp = fieldFromInstruction(insn, 11, 10); |
| 13330 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13331 | return S; |
| 13332 | case 295: |
| 13333 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13334 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13335 | tmp = fieldFromInstruction(insn, 11, 10); |
| 13336 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13337 | return S; |
| 13338 | case 296: |
| 13339 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13340 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13341 | tmp = fieldFromInstruction(insn, 11, 10); |
| 13342 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13343 | return S; |
| 13344 | case 297: |
| 13345 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13346 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13347 | tmp = fieldFromInstruction(insn, 11, 10); |
| 13348 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13349 | return S; |
| 13350 | case 298: |
| 13351 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13352 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13353 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13354 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13355 | tmp = fieldFromInstruction(insn, 16, 6); |
| 13356 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13357 | return S; |
| 13358 | case 299: |
| 13359 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13360 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13361 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13362 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13363 | tmp = fieldFromInstruction(insn, 16, 4); |
| 13364 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13365 | return S; |
| 13366 | case 300: |
| 13367 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13368 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13369 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13370 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13371 | tmp = fieldFromInstruction(insn, 16, 3); |
| 13372 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13373 | return S; |
| 13374 | case 301: |
| 13375 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13376 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13377 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13378 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13379 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13380 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13381 | tmp = fieldFromInstruction(insn, 16, 6); |
| 13382 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13383 | return S; |
| 13384 | case 302: |
| 13385 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13386 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13387 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13388 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13389 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13390 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13391 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13392 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13393 | return S; |
| 13394 | case 303: |
| 13395 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13396 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13397 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13398 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13399 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13400 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13401 | tmp = fieldFromInstruction(insn, 16, 4); |
| 13402 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13403 | return S; |
| 13404 | case 304: |
| 13405 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13406 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13407 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13408 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13409 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13410 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13411 | tmp = fieldFromInstruction(insn, 16, 3); |
| 13412 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13413 | return S; |
| 13414 | case 305: |
| 13415 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13416 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13417 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13418 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13419 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13420 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13421 | return S; |
| 13422 | case 306: |
| 13423 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13424 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13425 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13426 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13427 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13428 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13429 | return S; |
| 13430 | case 307: |
| 13431 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13432 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13433 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13434 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13435 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13436 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13437 | return S; |
| 13438 | case 308: |
| 13439 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13440 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13441 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13442 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13443 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13444 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13445 | return S; |
| 13446 | case 309: |
| 13447 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13448 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13449 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13450 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13451 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13452 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13453 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13454 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13455 | return S; |
| 13456 | case 310: |
| 13457 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13458 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13459 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13460 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13461 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13462 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13463 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13464 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13465 | return S; |
| 13466 | case 311: |
| 13467 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13468 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13469 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13470 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13471 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13472 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13473 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13474 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13475 | return S; |
| 13476 | case 312: |
| 13477 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13478 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13479 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13480 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13481 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13482 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13483 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13484 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13485 | return S; |
| 13486 | case 313: |
| 13487 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13488 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13489 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13490 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13491 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13492 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13493 | return S; |
| 13494 | case 314: |
| 13495 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13496 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13497 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13498 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13499 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13500 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13501 | return S; |
| 13502 | case 315: |
| 13503 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13504 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13505 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13506 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13507 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13508 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13509 | return S; |
| 13510 | case 316: |
| 13511 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13512 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13513 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13514 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13515 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13516 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13517 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13518 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13519 | return S; |
| 13520 | case 317: |
| 13521 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13522 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13523 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13524 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13525 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13526 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13527 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13528 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13529 | return S; |
| 13530 | case 318: |
| 13531 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13532 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13533 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13534 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13535 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13536 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13537 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13538 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13539 | return S; |
| 13540 | case 319: |
| 13541 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13542 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13543 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13544 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13545 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13546 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13547 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13548 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13549 | return S; |
| 13550 | case 320: |
| 13551 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13552 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13553 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13554 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13555 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13556 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13557 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13558 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13559 | return S; |
| 13560 | case 321: |
| 13561 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13562 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13563 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13564 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13565 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13566 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13567 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13568 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13569 | return S; |
| 13570 | case 322: |
| 13571 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13572 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13573 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13574 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13575 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13576 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13577 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13578 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13579 | return S; |
| 13580 | case 323: |
| 13581 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13582 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13583 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13584 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13585 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13586 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13587 | return S; |
| 13588 | case 324: |
| 13589 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13590 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13591 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13592 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13593 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13594 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13595 | return S; |
| 13596 | case 325: |
| 13597 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13598 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13599 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13600 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13601 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13602 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13603 | return S; |
| 13604 | case 326: |
| 13605 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13606 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13607 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13608 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13609 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13610 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13611 | return S; |
| 13612 | case 327: |
| 13613 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13614 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13615 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13616 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13617 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13618 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13619 | tmp = fieldFromInstruction(insn, 16, 4); |
| 13620 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13621 | return S; |
| 13622 | case 328: |
| 13623 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13624 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13625 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13626 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13627 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13628 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13629 | tmp = fieldFromInstruction(insn, 16, 3); |
| 13630 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13631 | return S; |
| 13632 | case 329: |
| 13633 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13634 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13635 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13636 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13637 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13638 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13639 | tmp = fieldFromInstruction(insn, 16, 2); |
| 13640 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13641 | return S; |
| 13642 | case 330: |
| 13643 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13644 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13645 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13646 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13647 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13648 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13649 | tmp = fieldFromInstruction(insn, 16, 1); |
| 13650 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13651 | return S; |
| 13652 | case 331: |
| 13653 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13654 | if (!Check(S, DecodeMSACtrlRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13655 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13656 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13657 | return S; |
| 13658 | case 332: |
| 13659 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13660 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13661 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13662 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13663 | tmp = fieldFromInstruction(insn, 16, 4); |
| 13664 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13665 | return S; |
| 13666 | case 333: |
| 13667 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13668 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13669 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13670 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13671 | tmp = fieldFromInstruction(insn, 16, 3); |
| 13672 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13673 | return S; |
| 13674 | case 334: |
| 13675 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13676 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13677 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13678 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13679 | tmp = fieldFromInstruction(insn, 16, 2); |
| 13680 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13681 | return S; |
| 13682 | case 335: |
| 13683 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13684 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13685 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13686 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13687 | tmp = fieldFromInstruction(insn, 16, 1); |
| 13688 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13689 | return S; |
| 13690 | case 336: |
| 13691 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13692 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13693 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13694 | if (!Check(S, DecodeMSACtrlRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13695 | return S; |
| 13696 | case 337: |
| 13697 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13698 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13699 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13700 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13701 | tmp = fieldFromInstruction(insn, 16, 4); |
| 13702 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13703 | return S; |
| 13704 | case 338: |
| 13705 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13706 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13707 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13708 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13709 | tmp = fieldFromInstruction(insn, 16, 3); |
| 13710 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13711 | return S; |
| 13712 | case 339: |
| 13713 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13714 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13715 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13716 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13717 | tmp = fieldFromInstruction(insn, 16, 2); |
| 13718 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13719 | return S; |
| 13720 | case 340: |
| 13721 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13722 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13723 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13724 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13725 | tmp = fieldFromInstruction(insn, 16, 1); |
| 13726 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13727 | return S; |
| 13728 | case 341: |
| 13729 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13730 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13731 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13732 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13733 | return S; |
| 13734 | case 342: |
| 13735 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13736 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13737 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13738 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13739 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13740 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13741 | tmp = fieldFromInstruction(insn, 16, 4); |
| 13742 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13743 | return S; |
| 13744 | case 343: |
| 13745 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13746 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13747 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13748 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13749 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13750 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13751 | tmp = fieldFromInstruction(insn, 16, 3); |
| 13752 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13753 | return S; |
| 13754 | case 344: |
| 13755 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13756 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13757 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13758 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13759 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13760 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13761 | tmp = fieldFromInstruction(insn, 16, 2); |
| 13762 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13763 | return S; |
| 13764 | case 345: |
| 13765 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13766 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13767 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13768 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13769 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13770 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13771 | tmp = fieldFromInstruction(insn, 16, 1); |
| 13772 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13773 | return S; |
| 13774 | case 346: |
| 13775 | if (!Check(S, DecodeINSVE_DF(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13776 | return S; |
| 13777 | case 347: |
| 13778 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13779 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13780 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13781 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13782 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13783 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13784 | return S; |
| 13785 | case 348: |
| 13786 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13787 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13788 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13789 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13790 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13791 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13792 | return S; |
| 13793 | case 349: |
| 13794 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13795 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13796 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13797 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13798 | return S; |
| 13799 | case 350: |
| 13800 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13801 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13802 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13803 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13804 | return S; |
| 13805 | case 351: |
| 13806 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13807 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13808 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13809 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13810 | return S; |
| 13811 | case 352: |
| 13812 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13813 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13814 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13815 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13816 | return S; |
| 13817 | case 353: |
| 13818 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13819 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13820 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13821 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13822 | return S; |
| 13823 | case 354: |
| 13824 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13825 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13826 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13827 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13828 | return S; |
| 13829 | case 355: |
| 13830 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13831 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13832 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13833 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13834 | return S; |
| 13835 | case 356: |
| 13836 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13837 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13838 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13839 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13840 | return S; |
| 13841 | case 357: |
| 13842 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13843 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13844 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13845 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13846 | return S; |
| 13847 | case 358: |
| 13848 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13849 | if (!Check(S, DecodeMSA128BRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13850 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13851 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13852 | tmp = fieldFromInstruction(insn, 16, 10); |
| 13853 | if (!Check(S, DecodeSImmWithOffsetAndScale<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13854 | return S; |
| 13855 | case 359: |
| 13856 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13857 | if (!Check(S, DecodeMSA128HRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13858 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13859 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13860 | tmp = fieldFromInstruction(insn, 16, 10); |
| 13861 | if (!Check(S, DecodeSImmWithOffsetAndScale<10, 0, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13862 | return S; |
| 13863 | case 360: |
| 13864 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13865 | if (!Check(S, DecodeMSA128WRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13866 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13867 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13868 | tmp = fieldFromInstruction(insn, 16, 10); |
| 13869 | if (!Check(S, DecodeSImmWithOffsetAndScale<10, 0, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13870 | return S; |
| 13871 | case 361: |
| 13872 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13873 | if (!Check(S, DecodeMSA128DRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13874 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13875 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13876 | tmp = fieldFromInstruction(insn, 16, 10); |
| 13877 | if (!Check(S, DecodeSImmWithOffsetAndScale<10, 0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13878 | return S; |
| 13879 | case 362: |
| 13880 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13881 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13882 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13883 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13884 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13885 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13886 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13887 | if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13888 | return S; |
| 13889 | case 363: |
| 13890 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13891 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13892 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13893 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13894 | tmp = fieldFromInstruction(insn, 6, 5); |
| 13895 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13896 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13897 | if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13898 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13899 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13900 | return S; |
| 13901 | case 364: |
| 13902 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13903 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13904 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13905 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13906 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13907 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13908 | return S; |
| 13909 | case 365: |
| 13910 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13911 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13912 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13913 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13914 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13915 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13916 | return S; |
| 13917 | case 366: |
| 13918 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13919 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13920 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13921 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13922 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13923 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13924 | return S; |
| 13925 | case 367: |
| 13926 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13927 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13928 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13929 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13930 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13931 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13932 | return S; |
| 13933 | case 368: |
| 13934 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13935 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13936 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13937 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13938 | return S; |
| 13939 | case 369: |
| 13940 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13941 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13942 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13943 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13944 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13945 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13946 | return S; |
| 13947 | case 370: |
| 13948 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13949 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13950 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13951 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13952 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13953 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13954 | return S; |
| 13955 | case 371: |
| 13956 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13957 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13958 | tmp = fieldFromInstruction(insn, 21, 5); |
| 13959 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13960 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13961 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13962 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13963 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13964 | return S; |
| 13965 | case 372: |
| 13966 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13967 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13968 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13969 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13970 | return S; |
| 13971 | case 373: |
| 13972 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13973 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13974 | tmp = fieldFromInstruction(insn, 16, 10); |
| 13975 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 13976 | return S; |
| 13977 | case 374: |
| 13978 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13979 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13980 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13981 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13982 | return S; |
| 13983 | case 375: |
| 13984 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13985 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13986 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13987 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13988 | return S; |
| 13989 | case 376: |
| 13990 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13991 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13992 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13993 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13994 | return S; |
| 13995 | case 377: |
| 13996 | tmp = fieldFromInstruction(insn, 11, 5); |
| 13997 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 13998 | tmp = fieldFromInstruction(insn, 16, 5); |
| 13999 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14000 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14001 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14002 | return S; |
| 14003 | case 378: |
| 14004 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14005 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14006 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14007 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14008 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14009 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14010 | return S; |
| 14011 | case 379: |
| 14012 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14013 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14014 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14015 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14016 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14017 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14018 | return S; |
| 14019 | case 380: |
| 14020 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14021 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14022 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14023 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14024 | tmp = fieldFromInstruction(insn, 7, 9); |
| 14025 | if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14026 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14027 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14028 | return S; |
| 14029 | case 381: |
| 14030 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14031 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14032 | tmp = fieldFromInstruction(insn, 7, 9); |
| 14033 | if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14034 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14035 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14036 | return S; |
| 14037 | case 382: |
| 14038 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14039 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14040 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14041 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14042 | tmp = fieldFromInstruction(insn, 7, 9); |
| 14043 | if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14044 | return S; |
| 14045 | case 383: |
| 14046 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14047 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14048 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14049 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14050 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14051 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14052 | tmp = fieldFromInstruction(insn, 7, 9); |
| 14053 | if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14054 | return S; |
| 14055 | case 384: |
| 14056 | tmp = fieldFromInstruction(insn, 11, 2); |
| 14057 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14058 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14059 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14060 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14061 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14062 | tmp = fieldFromInstruction(insn, 11, 2); |
| 14063 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14064 | return S; |
| 14065 | case 385: |
| 14066 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14067 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14068 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14069 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14070 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14071 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14072 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14073 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14074 | return S; |
| 14075 | case 386: |
| 14076 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14077 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14078 | tmp = fieldFromInstruction(insn, 11, 2); |
| 14079 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14080 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14081 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14082 | return S; |
| 14083 | case 387: |
| 14084 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14085 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14086 | tmp = fieldFromInstruction(insn, 11, 2); |
| 14087 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14088 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14089 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14090 | return S; |
| 14091 | case 388: |
| 14092 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14093 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14094 | tmp = fieldFromInstruction(insn, 16, 10); |
| 14095 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14096 | return S; |
| 14097 | case 389: |
| 14098 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14099 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14100 | tmp = fieldFromInstruction(insn, 11, 10); |
| 14101 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14102 | return S; |
| 14103 | case 390: |
| 14104 | tmp = fieldFromInstruction(insn, 11, 2); |
| 14105 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14106 | tmp = fieldFromInstruction(insn, 20, 6); |
| 14107 | if (!Check(S, DecodeSImmWithOffsetAndScale<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14108 | tmp = fieldFromInstruction(insn, 11, 2); |
| 14109 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14110 | return S; |
| 14111 | case 391: |
| 14112 | tmp = fieldFromInstruction(insn, 11, 2); |
| 14113 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14114 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14115 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14116 | tmp = fieldFromInstruction(insn, 11, 2); |
| 14117 | if (!Check(S, DecodeACC64DSPRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14118 | return S; |
| 14119 | case 392: |
| 14120 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14121 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14122 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14123 | if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14124 | tmp = fieldFromInstruction(insn, 6, 3); |
| 14125 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14126 | return S; |
| 14127 | case 393: |
| 14128 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14129 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14130 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14131 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14132 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14133 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14134 | return S; |
| 14135 | case 394: |
| 14136 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14137 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14138 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14139 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14140 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14141 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14142 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14143 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14144 | return S; |
| 14145 | case 395: |
| 14146 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14147 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14148 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14149 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14150 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14151 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14152 | return S; |
| 14153 | case 396: |
| 14154 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14155 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14156 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14157 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14158 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14159 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14160 | return S; |
| 14161 | case 397: |
| 14162 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14163 | if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14164 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14165 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14166 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14167 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14168 | return S; |
| 14169 | case 398: |
| 14170 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14171 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14172 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14173 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14174 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14175 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14176 | return S; |
| 14177 | case 399: |
| 14178 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14179 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14180 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14181 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14182 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14183 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14184 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14185 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14186 | return S; |
| 14187 | case 400: |
| 14188 | if (!Check(S, DecodeDAHIDATI(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14189 | return S; |
| 14190 | case 401: |
| 14191 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14192 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14193 | return S; |
| 14194 | case 402: |
| 14195 | if (!Check(S, DecodeBlezGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14196 | return S; |
| 14197 | case 403: |
| 14198 | if (!Check(S, DecodeBgtzGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14199 | return S; |
| 14200 | case 404: |
| 14201 | if (!Check(S, DecodeAddiGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14202 | return S; |
| 14203 | case 405: |
| 14204 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14205 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14206 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14207 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14208 | return S; |
| 14209 | case 406: |
| 14210 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14211 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14212 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14213 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14214 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14215 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14216 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14217 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14218 | return S; |
| 14219 | case 407: |
| 14220 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14221 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14222 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14223 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14224 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14225 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14226 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14227 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14228 | return S; |
| 14229 | case 408: |
| 14230 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14231 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14232 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14233 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14234 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14235 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14236 | return S; |
| 14237 | case 409: |
| 14238 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14239 | if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14240 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14241 | if (!Check(S, DecodeBranchTarget(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14242 | return S; |
| 14243 | case 410: |
| 14244 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14245 | if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14246 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14247 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14248 | tmp = fieldFromInstruction(insn, 0, 11); |
| 14249 | if (!Check(S, DecodeSImmWithOffsetAndScale<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14250 | return S; |
| 14251 | case 411: |
| 14252 | if (!Check(S, DecodeBlezlGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14253 | return S; |
| 14254 | case 412: |
| 14255 | if (!Check(S, DecodeBgtzlGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14256 | return S; |
| 14257 | case 413: |
| 14258 | if (!Check(S, DecodeDaddiGroupBranch(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14259 | return S; |
| 14260 | case 414: |
| 14261 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14262 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14263 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14264 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14265 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14266 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14267 | return S; |
| 14268 | case 415: |
| 14269 | if (!Check(S, DecodeCRC(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14270 | return S; |
| 14271 | case 416: |
| 14272 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14273 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14274 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14275 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14276 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14277 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14278 | tmp = fieldFromInstruction(insn, 6, 2); |
| 14279 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14280 | return S; |
| 14281 | case 417: |
| 14282 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14283 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14284 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14285 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14286 | return S; |
| 14287 | case 418: |
| 14288 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14289 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14290 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14291 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14292 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14293 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14294 | tmp = fieldFromInstruction(insn, 6, 3); |
| 14295 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14296 | return S; |
| 14297 | case 419: |
| 14298 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14299 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14300 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14301 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14302 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14303 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14304 | tmp = fieldFromInstruction(insn, 7, 9); |
| 14305 | if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14306 | return S; |
| 14307 | case 420: |
| 14308 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14309 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14310 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14311 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14312 | tmp = fieldFromInstruction(insn, 7, 9); |
| 14313 | if (!Check(S, DecodeSImmWithOffsetAndScale<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14314 | return S; |
| 14315 | case 421: |
| 14316 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14317 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14318 | tmp = fieldFromInstruction(insn, 8, 2); |
| 14319 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14320 | return S; |
| 14321 | case 422: |
| 14322 | tmp = fieldFromInstruction(insn, 0, 26); |
| 14323 | if (!Check(S, DecodeBranchTarget26(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14324 | return S; |
| 14325 | case 423: |
| 14326 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14327 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14328 | tmp = fieldFromInstruction(insn, 0, 21); |
| 14329 | if (!Check(S, DecodeBranchTarget21(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14330 | return S; |
| 14331 | case 424: |
| 14332 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14333 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14334 | tmp = fieldFromInstruction(insn, 0, 18); |
| 14335 | if (!Check(S, DecodeSimm18Lsl3(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14336 | return S; |
| 14337 | case 425: |
| 14338 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14339 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14340 | tmp = fieldFromInstruction(insn, 0, 21); |
| 14341 | if (!Check(S, DecodeBranchTarget21(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14342 | return S; |
| 14343 | case 426: |
| 14344 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14345 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14346 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14347 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14348 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14349 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14350 | return S; |
| 14351 | case 427: |
| 14352 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14353 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14354 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14355 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14356 | return S; |
| 14357 | case 428: |
| 14358 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14359 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14360 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14361 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14362 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14363 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14364 | return S; |
| 14365 | case 429: |
| 14366 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14367 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14368 | tmp = 0x0; |
| 14369 | tmp |= fieldFromInstruction(insn, 0, 3); |
| 14370 | tmp |= fieldFromInstruction(insn, 11, 5) << 5; |
| 14371 | if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14372 | return S; |
| 14373 | case 430: |
| 14374 | tmp = 0x0; |
| 14375 | tmp |= fieldFromInstruction(insn, 0, 3); |
| 14376 | tmp |= fieldFromInstruction(insn, 11, 5) << 5; |
| 14377 | if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14378 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14379 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14380 | return S; |
| 14381 | case 431: |
| 14382 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14383 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14384 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14385 | if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14386 | tmp = fieldFromInstruction(insn, 0, 3); |
| 14387 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14388 | return S; |
| 14389 | case 432: |
| 14390 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14391 | if (!Check(S, DecodeCOP2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14392 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14393 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14394 | tmp = fieldFromInstruction(insn, 0, 3); |
| 14395 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14396 | return S; |
| 14397 | case 433: |
| 14398 | tmp = fieldFromInstruction(insn, 13, 3); |
| 14399 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14400 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14401 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14402 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14403 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14404 | return S; |
| 14405 | case 434: |
| 14406 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14407 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14408 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14409 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14410 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14411 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14412 | return S; |
| 14413 | case 435: |
| 14414 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14415 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14416 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14417 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14418 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14419 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14420 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14421 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14422 | return S; |
| 14423 | case 436: |
| 14424 | tmp = 0x0; |
| 14425 | tmp |= fieldFromInstruction(insn, 11, 5); |
| 14426 | tmp |= fieldFromInstruction(insn, 16, 5); |
| 14427 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14428 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14429 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14430 | return S; |
| 14431 | case 437: |
| 14432 | if (!Check(S, DecodeDEXT(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14433 | return S; |
| 14434 | case 438: |
| 14435 | if (!Check(S, DecodeDINS(MI, insn, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14436 | return S; |
| 14437 | case 439: |
| 14438 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14439 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14440 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14441 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14442 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14443 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14444 | return S; |
| 14445 | case 440: |
| 14446 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14447 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14448 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14449 | if (!Check(S, DecodeGPR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14450 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14451 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14452 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14453 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14454 | return S; |
| 14455 | case 441: |
| 14456 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14457 | if (!Check(S, DecodeDSPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14458 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14459 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14460 | tmp = fieldFromInstruction(insn, 0, 16); |
| 14461 | if (!Check(S, DecodeSImmWithOffsetAndScale<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14462 | return S; |
| 14463 | case 442: |
| 14464 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14465 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14466 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14467 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14468 | return S; |
| 14469 | case 443: |
| 14470 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14471 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14472 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14473 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14474 | return S; |
| 14475 | case 444: |
| 14476 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14477 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14478 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14479 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14480 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14481 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14482 | return S; |
| 14483 | case 445: |
| 14484 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14485 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14486 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14487 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14488 | return S; |
| 14489 | case 446: |
| 14490 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14491 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14492 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14493 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14494 | tmp = fieldFromInstruction(insn, 18, 3); |
| 14495 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14496 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14497 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14498 | return S; |
| 14499 | case 447: |
| 14500 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14501 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14502 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14503 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14504 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14505 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14506 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14507 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14508 | return S; |
| 14509 | case 448: |
| 14510 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14511 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14512 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14513 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14514 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14515 | if (!Check(S, DecodeFGR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14516 | return S; |
| 14517 | case 449: |
| 14518 | tmp = fieldFromInstruction(insn, 8, 3); |
| 14519 | if (!Check(S, DecodeFCCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14520 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14521 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14522 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14523 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14524 | return S; |
| 14525 | case 450: |
| 14526 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14527 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14528 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14529 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14530 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14531 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14532 | return S; |
| 14533 | case 451: |
| 14534 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14535 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14536 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14537 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14538 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14539 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14540 | return S; |
| 14541 | case 452: |
| 14542 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14543 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14544 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14545 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14546 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14547 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14548 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14549 | if (!Check(S, DecodeFGR64RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14550 | return S; |
| 14551 | case 453: |
| 14552 | tmp = fieldFromInstruction(insn, 0, 18); |
| 14553 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14554 | return S; |
| 14555 | case 454: |
| 14556 | tmp = fieldFromInstruction(insn, 0, 19); |
| 14557 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14558 | return S; |
| 14559 | case 455: |
| 14560 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14561 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14562 | tmp = 0x0; |
| 14563 | tmp |= fieldFromInstruction(insn, 0, 1) << 21; |
| 14564 | tmp |= fieldFromInstruction(insn, 1, 20) << 1; |
| 14565 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14566 | return S; |
| 14567 | case 456: |
| 14568 | tmp = fieldFromInstruction(insn, 24, 1); |
| 14569 | if (!Check(S, DecodeGPRNM1R1RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14570 | tmp = 0x0; |
| 14571 | tmp |= fieldFromInstruction(insn, 21, 3); |
| 14572 | tmp |= fieldFromInstruction(insn, 25, 1) << 4; |
| 14573 | if (!Check(S, DecodeGPRNM4ZRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14574 | tmp = 0x0; |
| 14575 | tmp |= fieldFromInstruction(insn, 0, 1) << 21; |
| 14576 | tmp |= fieldFromInstruction(insn, 1, 20) << 1; |
| 14577 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14578 | return S; |
| 14579 | case 457: |
| 14580 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14581 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14582 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14583 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14584 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14585 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14586 | return S; |
| 14587 | case 458: |
| 14588 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14589 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14590 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14591 | if (!Check(S, DecodeHWRegsRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14592 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14593 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14594 | return S; |
| 14595 | case 459: |
| 14596 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14597 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14598 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14599 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14600 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14601 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14602 | return S; |
| 14603 | case 460: |
| 14604 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14605 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14606 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14607 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14608 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14609 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14610 | tmp = fieldFromInstruction(insn, 9, 2); |
| 14611 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14612 | return S; |
| 14613 | case 461: |
| 14614 | tmp = fieldFromInstruction(insn, 11, 5); |
| 14615 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14616 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14617 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14618 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14619 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14620 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14621 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14622 | return S; |
| 14623 | case 462: |
| 14624 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14625 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14626 | tmp = fieldFromInstruction(insn, 11, 10); |
| 14627 | if (!Check(S, DecodeCOP0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14628 | return S; |
| 14629 | case 463: |
| 14630 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14631 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14632 | tmp = fieldFromInstruction(insn, 21, 2); |
| 14633 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14634 | return S; |
| 14635 | case 464: |
| 14636 | tmp = 0x0; |
| 14637 | tmp |= fieldFromInstruction(insn, 0, 1) << 25; |
| 14638 | tmp |= fieldFromInstruction(insn, 1, 24) << 1; |
| 14639 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14640 | return S; |
| 14641 | case 465: |
| 14642 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14643 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14644 | tmp = fieldFromInstruction(insn, 2, 19) << 2; |
| 14645 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14646 | return S; |
| 14647 | case 466: |
| 14648 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14649 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14650 | if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder))) |
| 14651 | return MCDisassembler::Fail; |
| 14652 | tmp = fieldFromInstruction(insn, 2, 19) << 2; |
| 14653 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14654 | return S; |
| 14655 | case 467: |
| 14656 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14657 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14658 | if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder))) |
| 14659 | return MCDisassembler::Fail; |
| 14660 | tmp = fieldFromInstruction(insn, 0, 18); |
| 14661 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14662 | return S; |
| 14663 | case 468: |
| 14664 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14665 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14666 | tmp = fieldFromInstruction(insn, 0, 18); |
| 14667 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14668 | return S; |
| 14669 | case 469: |
| 14670 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14671 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14672 | if (!Check(Out&: S, In: DecodeFixedPtrRegister<28>(Inst&: MI, Decoder))) |
| 14673 | return MCDisassembler::Fail; |
| 14674 | tmp = fieldFromInstruction(insn, 1, 17) << 1; |
| 14675 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14676 | return S; |
| 14677 | case 470: |
| 14678 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14679 | if (!Check(S, DecodeGPR32NONZERORegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14680 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14681 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14682 | return S; |
| 14683 | case 471: |
| 14684 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14685 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14686 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14687 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14688 | tmp = fieldFromInstruction(insn, 0, 12); |
| 14689 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14690 | return S; |
| 14691 | case 472: |
| 14692 | tmp = fieldFromInstruction(insn, 3, 9) << 3; |
| 14693 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14694 | tmp = 0x0; |
| 14695 | tmp |= fieldFromInstruction(insn, 2, 1); |
| 14696 | tmp |= fieldFromInstruction(insn, 16, 4) << 1; |
| 14697 | tmp |= fieldFromInstruction(insn, 21, 5) << 5; |
| 14698 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14699 | return S; |
| 14700 | case 473: |
| 14701 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14702 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14703 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14704 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14705 | tmp = fieldFromInstruction(insn, 0, 5); |
| 14706 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14707 | return S; |
| 14708 | case 474: |
| 14709 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14710 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14711 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14712 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14713 | tmp = fieldFromInstruction(insn, 0, 5); |
| 14714 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14715 | tmp = fieldFromInstruction(insn, 7, 4) << 1; |
| 14716 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14717 | tmp = fieldFromInstruction(insn, 6, 1); |
| 14718 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14719 | return S; |
| 14720 | case 475: |
| 14721 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14722 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14723 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14724 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14725 | tmp = fieldFromInstruction(insn, 0, 5); |
| 14726 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14727 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14728 | if (!Check(S, DecodeInsSize(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14729 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14730 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14731 | return S; |
| 14732 | case 476: |
| 14733 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14734 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14735 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14736 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14737 | tmp = fieldFromInstruction(insn, 0, 5); |
| 14738 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14739 | tmp = fieldFromInstruction(insn, 6, 5); |
| 14740 | if (!Check(S, DecodeUImmWithOffset<5, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14741 | return S; |
| 14742 | case 477: |
| 14743 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14744 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14745 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14746 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14747 | tmp = fieldFromInstruction(insn, 0, 12); |
| 14748 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14749 | return S; |
| 14750 | case 478: |
| 14751 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14752 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14753 | tmp = fieldFromInstruction(insn, 0, 12); |
| 14754 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14755 | return S; |
| 14756 | case 479: |
| 14757 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14758 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14759 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14760 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14761 | tmp = fieldFromInstruction(insn, 0, 12); |
| 14762 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14763 | return S; |
| 14764 | case 480: |
| 14765 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14766 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14767 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14768 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14769 | tmp = 0x0; |
| 14770 | tmp |= fieldFromInstruction(insn, 0, 1) << 14; |
| 14771 | tmp |= fieldFromInstruction(insn, 1, 13) << 1; |
| 14772 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14773 | return S; |
| 14774 | case 481: |
| 14775 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14776 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14777 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14778 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14779 | tmp = 0x0; |
| 14780 | tmp |= fieldFromInstruction(insn, 0, 8); |
| 14781 | tmp |= fieldFromInstruction(insn, 15, 1) << 8; |
| 14782 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14783 | return S; |
| 14784 | case 482: |
| 14785 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14786 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14787 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14788 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14789 | tmp = 0x0; |
| 14790 | tmp |= fieldFromInstruction(insn, 0, 8); |
| 14791 | tmp |= fieldFromInstruction(insn, 15, 1) << 8; |
| 14792 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14793 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14794 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14795 | return S; |
| 14796 | case 483: |
| 14797 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14798 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14799 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14800 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14801 | tmp = 0x0; |
| 14802 | tmp |= fieldFromInstruction(insn, 2, 6) << 2; |
| 14803 | tmp |= fieldFromInstruction(insn, 15, 1) << 8; |
| 14804 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14805 | return S; |
| 14806 | case 484: |
| 14807 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14808 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14809 | tmp = fieldFromInstruction(insn, 3, 5); |
| 14810 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14811 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14812 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14813 | return S; |
| 14814 | case 485: |
| 14815 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14816 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14817 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14818 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14819 | tmp = 0x0; |
| 14820 | tmp |= fieldFromInstruction(insn, 0, 8); |
| 14821 | tmp |= fieldFromInstruction(insn, 15, 1) << 8; |
| 14822 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14823 | tmp = fieldFromInstruction(insn, 12, 3); |
| 14824 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14825 | return S; |
| 14826 | case 486: |
| 14827 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14828 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14829 | tmp = 0x0; |
| 14830 | tmp |= fieldFromInstruction(insn, 0, 8); |
| 14831 | tmp |= fieldFromInstruction(insn, 15, 1) << 8; |
| 14832 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14833 | return S; |
| 14834 | case 487: |
| 14835 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14836 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14837 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14838 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14839 | tmp = 0x0; |
| 14840 | tmp |= fieldFromInstruction(insn, 0, 8); |
| 14841 | tmp |= fieldFromInstruction(insn, 15, 1) << 8; |
| 14842 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14843 | return S; |
| 14844 | case 488: |
| 14845 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14846 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14847 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14848 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14849 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14850 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14851 | tmp = 0x0; |
| 14852 | tmp |= fieldFromInstruction(insn, 2, 6) << 2; |
| 14853 | tmp |= fieldFromInstruction(insn, 15, 1) << 8; |
| 14854 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14855 | return S; |
| 14856 | case 489: |
| 14857 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14858 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14859 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14860 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14861 | tmp = fieldFromInstruction(insn, 3, 5); |
| 14862 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14863 | tmp = fieldFromInstruction(insn, 16, 5); |
| 14864 | if (!Check(S, DecodePtrRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14865 | return S; |
| 14866 | case 490: |
| 14867 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14868 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14869 | tmp = fieldFromInstruction(insn, 11, 7); |
| 14870 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14871 | tmp = 0x0; |
| 14872 | tmp |= fieldFromInstruction(insn, 0, 1) << 11; |
| 14873 | tmp |= fieldFromInstruction(insn, 1, 10) << 1; |
| 14874 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14875 | return S; |
| 14876 | case 491: |
| 14877 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14878 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14879 | tmp = fieldFromInstruction(insn, 11, 6); |
| 14880 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14881 | tmp = 0x0; |
| 14882 | tmp |= fieldFromInstruction(insn, 0, 1) << 11; |
| 14883 | tmp |= fieldFromInstruction(insn, 1, 10) << 1; |
| 14884 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14885 | return S; |
| 14886 | case 492: |
| 14887 | tmp = fieldFromInstruction(insn, 21, 5); |
| 14888 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14889 | tmp = 0x0; |
| 14890 | tmp |= fieldFromInstruction(insn, 0, 1) << 19; |
| 14891 | tmp |= fieldFromInstruction(insn, 2, 10) << 9; |
| 14892 | tmp |= fieldFromInstruction(insn, 12, 9); |
| 14893 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14894 | return S; |
| 14895 | case 493: |
| 14896 | tmp = fieldFromInstruction(insn, 37, 5); |
| 14897 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14898 | tmp = 0x0; |
| 14899 | tmp |= fieldFromInstruction(insn, 0, 16) << 16; |
| 14900 | tmp |= fieldFromInstruction(insn, 16, 16); |
| 14901 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14902 | return S; |
| 14903 | case 494: |
| 14904 | tmp = fieldFromInstruction(insn, 37, 5); |
| 14905 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14906 | tmp = fieldFromInstruction(insn, 37, 5); |
| 14907 | if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; } |
| 14908 | tmp = 0x0; |
| 14909 | tmp |= fieldFromInstruction(insn, 0, 16) << 16; |
| 14910 | tmp |= fieldFromInstruction(insn, 16, 16); |
| 14911 | MI.addOperand(Op: MCOperand::createImm(Val: tmp)); |
| 14912 | return S; |
| 14913 | } |
| 14914 | } |
| 14915 | static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) { |
| 14916 | switch (Idx) { |
| 14917 | default: llvm_unreachable("Invalid index!" ); |
| 14918 | case 0: |
| 14919 | return FB[Mips::FeatureMips16]; |
| 14920 | case 1: |
| 14921 | return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]); |
| 14922 | case 2: |
| 14923 | return FB[Mips::FeatureMicroMips]; |
| 14924 | case 3: |
| 14925 | return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6]; |
| 14926 | case 4: |
| 14927 | return FB[Mips::FeatureNanoMips] && FB[Mips::FeatureNanoMips]; |
| 14928 | case 5: |
| 14929 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureCnMips]) && !(FB[Mips::FeatureMicroMips]); |
| 14930 | case 6: |
| 14931 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureCnMips]) && !(FB[Mips::FeatureMicroMips]); |
| 14932 | case 7: |
| 14933 | return FB[Mips::FeatureCnMips]; |
| 14934 | case 8: |
| 14935 | return FB[Mips::FeatureMips64] && FB[Mips::FeatureCnMips] && !(FB[Mips::FeatureMicroMips]); |
| 14936 | case 9: |
| 14937 | return FB[Mips::FeatureCnMipsP]; |
| 14938 | case 10: |
| 14939 | return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSP]; |
| 14940 | case 11: |
| 14941 | return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSPR2]; |
| 14942 | case 12: |
| 14943 | return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r5] && FB[Mips::FeatureVirt]; |
| 14944 | case 13: |
| 14945 | return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureDSPR3]; |
| 14946 | case 14: |
| 14947 | return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && FB[Mips::FeatureDSP]; |
| 14948 | case 15: |
| 14949 | return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]); |
| 14950 | case 16: |
| 14951 | return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]); |
| 14952 | case 17: |
| 14953 | return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]); |
| 14954 | case 18: |
| 14955 | return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]); |
| 14956 | case 19: |
| 14957 | return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureSoftFloat]); |
| 14958 | case 20: |
| 14959 | return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]); |
| 14960 | case 21: |
| 14961 | return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureSoftFloat]); |
| 14962 | case 22: |
| 14963 | return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]); |
| 14964 | case 23: |
| 14965 | return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureEVA]; |
| 14966 | case 24: |
| 14967 | return FB[Mips::FeatureMicroMips] && !(FB[Mips::FeatureMips32r6]) && FB[Mips::FeatureEVA]; |
| 14968 | case 25: |
| 14969 | return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureSoftFloat]); |
| 14970 | case 26: |
| 14971 | return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureGINV]; |
| 14972 | case 27: |
| 14973 | return FB[Mips::FeatureMicroMips] && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureSoftFloat]); |
| 14974 | case 28: |
| 14975 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMicroMips]); |
| 14976 | case 29: |
| 14977 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMicroMips]); |
| 14978 | case 30: |
| 14979 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 14980 | case 31: |
| 14981 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMSA]; |
| 14982 | case 32: |
| 14983 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]); |
| 14984 | case 33: |
| 14985 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]); |
| 14986 | case 34: |
| 14987 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMicroMips]) && !(FB[Mips::FeatureUseIndirectJumpsHazard]); |
| 14988 | case 35: |
| 14989 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32]; |
| 14990 | case 36: |
| 14991 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]); |
| 14992 | case 37: |
| 14993 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMicroMips]); |
| 14994 | case 38: |
| 14995 | return FB[Mips::FeatureDSP]; |
| 14996 | case 39: |
| 14997 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMSA] && FB[Mips::FeatureMips64]; |
| 14998 | case 40: |
| 14999 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]); |
| 15000 | case 41: |
| 15001 | return FB[Mips::FeatureDSP] && !(FB[Mips::FeatureMicroMips]); |
| 15002 | case 42: |
| 15003 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r5] && FB[Mips::FeatureVirt] && !(FB[Mips::FeatureMicroMips]); |
| 15004 | case 43: |
| 15005 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMT] && !(FB[Mips::FeatureMicroMips]); |
| 15006 | case 44: |
| 15007 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3_32] && !(FB[Mips::FeatureMicroMips]); |
| 15008 | case 45: |
| 15009 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r2] && FB[Mips::FeatureEVA] && !(FB[Mips::FeatureMicroMips]); |
| 15010 | case 46: |
| 15011 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r5] && !(FB[Mips::FeatureMicroMips]); |
| 15012 | case 47: |
| 15013 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32] && !(FB[Mips::FeatureMicroMips]); |
| 15014 | case 48: |
| 15015 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15016 | case 49: |
| 15017 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureSingleFloat]); |
| 15018 | case 50: |
| 15019 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15020 | case 51: |
| 15021 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15022 | case 52: |
| 15023 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15024 | case 53: |
| 15025 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15026 | case 54: |
| 15027 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureSoftFloat]); |
| 15028 | case 55: |
| 15029 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15030 | case 56: |
| 15031 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15032 | case 57: |
| 15033 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15034 | case 58: |
| 15035 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15036 | case 59: |
| 15037 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15038 | case 60: |
| 15039 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15040 | case 61: |
| 15041 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15042 | case 62: |
| 15043 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15044 | case 63: |
| 15045 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15046 | case 64: |
| 15047 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]); |
| 15048 | case 65: |
| 15049 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15050 | case 66: |
| 15051 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips5_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15052 | case 67: |
| 15053 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]) && !(FB[Mips::FeatureNoMadd4]); |
| 15054 | case 68: |
| 15055 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]) && !(FB[Mips::FeatureNoMadd4]); |
| 15056 | case 69: |
| 15057 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]) && !(FB[Mips::FeatureMicroMips]); |
| 15058 | case 70: |
| 15059 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureFP64Bit]) && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]) && !(FB[Mips::FeatureMicroMips]); |
| 15060 | case 71: |
| 15061 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]); |
| 15062 | case 72: |
| 15063 | return FB[Mips::FeatureDSPR2]; |
| 15064 | case 73: |
| 15065 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && FB[Mips::FeatureEVA] && !(FB[Mips::FeatureMicroMips]); |
| 15066 | case 74: |
| 15067 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]); |
| 15068 | case 75: |
| 15069 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeaturePTR64Bit]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureMicroMips]); |
| 15070 | case 76: |
| 15071 | return !(FB[Mips::FeatureMips16]) && FB[Mips::FeaturePTR64Bit] && !(FB[Mips::FeatureMicroMips]); |
| 15072 | case 77: |
| 15073 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureMicroMips]); |
| 15074 | case 78: |
| 15075 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r6]; |
| 15076 | case 79: |
| 15077 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureMicroMips]); |
| 15078 | case 80: |
| 15079 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64r6] && !(FB[Mips::FeatureMicroMips]); |
| 15080 | case 81: |
| 15081 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeatureGP64Bit]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureMicroMips]); |
| 15082 | case 82: |
| 15083 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15084 | case 83: |
| 15085 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureCRC] && !(FB[Mips::FeatureMicroMips]); |
| 15086 | case 84: |
| 15087 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64r6] && FB[Mips::FeatureCRC] && !(FB[Mips::FeatureMicroMips]); |
| 15088 | case 85: |
| 15089 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && !(FB[Mips::FeaturePTR64Bit]) && FB[Mips::FeatureMips32r6] && !(FB[Mips::FeatureMicroMips]); |
| 15090 | case 86: |
| 15091 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips32r6] && FB[Mips::FeatureGINV] && !(FB[Mips::FeatureMicroMips]); |
| 15092 | case 87: |
| 15093 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64r6]; |
| 15094 | case 88: |
| 15095 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips64r6]; |
| 15096 | case 89: |
| 15097 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips32r6]; |
| 15098 | case 90: |
| 15099 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeaturePTR64Bit] && FB[Mips::FeatureMips64r6] && !(FB[Mips::FeatureMicroMips]); |
| 15100 | case 91: |
| 15101 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64] && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]); |
| 15102 | case 92: |
| 15103 | return !(FB[Mips::FeatureMips16]) && FB[Mips::FeaturePTR64Bit]; |
| 15104 | case 93: |
| 15105 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64r2] && !(FB[Mips::FeatureMicroMips]); |
| 15106 | case 94: |
| 15107 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMicroMips]); |
| 15108 | case 95: |
| 15109 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]) && !(FB[Mips::FeatureMicroMips]); |
| 15110 | case 96: |
| 15111 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips3]; |
| 15112 | case 97: |
| 15113 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips64r5] && FB[Mips::FeatureVirt]; |
| 15114 | case 98: |
| 15115 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]); |
| 15116 | case 99: |
| 15117 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureGP64Bit] && FB[Mips::FeatureMips64] && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureMicroMips]); |
| 15118 | case 100: |
| 15119 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureMips3] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureR5900]); |
| 15120 | case 101: |
| 15121 | return !(FB[Mips::FeatureMips16]) && FB[Mips::FeatureDSP]; |
| 15122 | case 102: |
| 15123 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15124 | case 103: |
| 15125 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15126 | case 104: |
| 15127 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15128 | case 105: |
| 15129 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15130 | case 106: |
| 15131 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips3_32] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15132 | case 107: |
| 15133 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15134 | case 108: |
| 15135 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15136 | case 109: |
| 15137 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && FB[Mips::FeatureMips3D]; |
| 15138 | case 110: |
| 15139 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips3_32r2] && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15140 | case 111: |
| 15141 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15142 | case 112: |
| 15143 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]); |
| 15144 | case 113: |
| 15145 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips5_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]); |
| 15146 | case 114: |
| 15147 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureMicroMips]) && !(FB[Mips::FeatureNoMadd4]); |
| 15148 | case 115: |
| 15149 | return !(FB[Mips::FeatureMips16] || FB[Mips::FeatureNanoMips]) && FB[Mips::FeatureFP64Bit] && !(FB[Mips::FeatureSingleFloat]) && FB[Mips::FeatureMips4_32r2] && !(FB[Mips::FeatureMips32r6]) && !(FB[Mips::FeatureMips64r6]) && !(FB[Mips::FeatureSoftFloat]) && !(FB[Mips::FeatureNoMadd4]) && !(FB[Mips::FeatureMicroMips]); |
| 15150 | case 116: |
| 15151 | return FB[Mips::FeatureNanoMips] && FB[Mips::FeatureNanoMips] && FB[Mips::FeatureCRC]; |
| 15152 | case 117: |
| 15153 | return FB[Mips::FeatureNanoMips] && FB[Mips::FeatureNanoMips] && FB[Mips::FeatureGINV]; |
| 15154 | } |
| 15155 | } |
| 15156 | |
| 15157 | |
| 15158 | template <typename InsnType> |
| 15159 | static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI, |
| 15160 | InsnType insn, uint64_t Address, |
| 15161 | const MCDisassembler *DisAsm, |
| 15162 | const MCSubtargetInfo &STI) { |
| 15163 | const FeatureBitset &Bits = STI.getFeatureBits(); |
| 15164 | const uint8_t *Ptr = DecodeTable; |
| 15165 | |
| 15166 | SmallVector<const uint8_t *, 8> ScopeStack; |
| 15167 | DecodeStatus S = MCDisassembler::Success; |
| 15168 | while (true) { |
| 15169 | ptrdiff_t Loc = Ptr - DecodeTable; |
| 15170 | const uint8_t DecoderOp = *Ptr++; |
| 15171 | switch (DecoderOp) { |
| 15172 | default: |
| 15173 | errs() << Loc << ": Unexpected decode table opcode: " |
| 15174 | << (int)DecoderOp << '\n'; |
| 15175 | return MCDisassembler::Fail; |
| 15176 | case OPC_Scope: { |
| 15177 | unsigned NumToSkip = decodeULEB128AndIncUnsafe(p&: Ptr); |
| 15178 | const uint8_t *SkipTo = Ptr + NumToSkip; |
| 15179 | ScopeStack.push_back(Elt: SkipTo); |
| 15180 | LLVM_DEBUG(dbgs() << Loc << ": OPC_Scope(" << SkipTo - DecodeTable |
| 15181 | << ")\n" ); |
| 15182 | continue; |
| 15183 | } |
| 15184 | case OPC_SwitchField: { |
| 15185 | // Decode the start value. |
| 15186 | unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr); |
| 15187 | unsigned Len = *Ptr++; |
| 15188 | uint64_t FieldValue = fieldFromInstruction(insn, Start, Len); |
| 15189 | uint64_t CaseValue; |
| 15190 | unsigned CaseSize; |
| 15191 | while (true) { |
| 15192 | CaseValue = decodeULEB128AndIncUnsafe(p&: Ptr); |
| 15193 | CaseSize = decodeULEB128AndIncUnsafe(p&: Ptr); |
| 15194 | if (FieldValue <= CaseValue || !CaseSize) |
| 15195 | break; |
| 15196 | Ptr += CaseSize; |
| 15197 | } |
| 15198 | if (FieldValue == CaseValue) { |
| 15199 | LLVM_DEBUG(dbgs() << Loc << ": OPC_SwitchField(" << Start << ", " << Len |
| 15200 | << "): " << FieldValue << '\n'); |
| 15201 | continue; |
| 15202 | } |
| 15203 | break; |
| 15204 | } |
| 15205 | case OPC_CheckField: { |
| 15206 | // Decode the start value. |
| 15207 | unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr); |
| 15208 | unsigned Len = *Ptr; |
| 15209 | uint64_t FieldValue = fieldFromInstruction(insn, Start, Len); |
| 15210 | // Decode the field value. |
| 15211 | unsigned PtrLen = 0; |
| 15212 | uint64_t ExpectedValue = decodeULEB128(p: ++Ptr, n: &PtrLen); |
| 15213 | Ptr += PtrLen; |
| 15214 | bool Failed = ExpectedValue != FieldValue; |
| 15215 | |
| 15216 | LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckField(" << Start << ", " << Len |
| 15217 | << ", " << ExpectedValue << "): FieldValue = " |
| 15218 | << FieldValue << ", ExpectedValue = " << ExpectedValue |
| 15219 | << ": " << (Failed ? "FAIL, " : "PASS\n" );); |
| 15220 | if (!Failed) |
| 15221 | continue; |
| 15222 | break; |
| 15223 | } |
| 15224 | case OPC_CheckPredicate: { |
| 15225 | // Decode the Predicate Index value. |
| 15226 | unsigned PIdx = decodeULEB128AndIncUnsafe(p&: Ptr); |
| 15227 | // Check the predicate. |
| 15228 | bool Failed = !checkDecoderPredicate(Idx: PIdx, FB: Bits); |
| 15229 | |
| 15230 | LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckPredicate(" << PIdx << "): " |
| 15231 | << (Failed ? "FAIL, " : "PASS\n" );); |
| 15232 | if (!Failed) |
| 15233 | continue; |
| 15234 | break; |
| 15235 | } |
| 15236 | case OPC_Decode: { |
| 15237 | // Decode the Opcode value. |
| 15238 | unsigned Opc = decodeULEB128AndIncUnsafe(p&: Ptr); |
| 15239 | unsigned DecodeIdx = decodeULEB128AndIncUnsafe(p&: Ptr); |
| 15240 | |
| 15241 | MI.clear(); |
| 15242 | MI.setOpcode(Opc); |
| 15243 | bool DecodeComplete; |
| 15244 | S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm, |
| 15245 | DecodeComplete); |
| 15246 | LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc |
| 15247 | << ", using decoder " << DecodeIdx << ": " |
| 15248 | << (S ? "PASS, " : "FAIL, " )); |
| 15249 | |
| 15250 | if (DecodeComplete) { |
| 15251 | LLVM_DEBUG(dbgs() << "decoding complete\n" ); |
| 15252 | return S; |
| 15253 | } |
| 15254 | assert(S == MCDisassembler::Fail); |
| 15255 | // Reset decode status. This also drops a SoftFail status that could be |
| 15256 | // set before the decode attempt. |
| 15257 | S = MCDisassembler::Success; |
| 15258 | break; |
| 15259 | } |
| 15260 | } |
| 15261 | if (ScopeStack.empty()) { |
| 15262 | LLVM_DEBUG(dbgs() << "returning Fail\n" ); |
| 15263 | return MCDisassembler::Fail; |
| 15264 | } |
| 15265 | Ptr = ScopeStack.pop_back_val(); |
| 15266 | LLVM_DEBUG(dbgs() << "continuing at " << Ptr - DecodeTable << '\n'); |
| 15267 | } |
| 15268 | llvm_unreachable("bogosity detected in disassembler state machine!" ); |
| 15269 | } |
| 15270 | |
| 15271 | |
| 15272 | } // namespace |
| 15273 | |