1 //===-- MBlazeDisassembler.cpp - Disassembler for MicroBlaze -------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file is part of the MBlaze Disassembler. It contains code to translate 11 // the data produced by the decoder into MCInsts. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "MBlaze.h" 16 #include "MBlazeDisassembler.h" 17 18 #include "llvm/MC/EDInstInfo.h" 19 #include "llvm/MC/MCDisassembler.h" 20 #include "llvm/MC/MCInst.h" 21 #include "llvm/MC/MCInstrDesc.h" 22 #include "llvm/Support/Debug.h" 23 #include "llvm/Support/MemoryObject.h" 24 #include "llvm/Support/TargetRegistry.h" 25 #include "llvm/Support/raw_ostream.h" 26 27 // #include "MBlazeGenDecoderTables.inc" 28 // #include "MBlazeGenRegisterNames.inc" 29 #include "MBlazeGenEDInfo.inc" 30 31 namespace llvm { 32 extern const MCInstrDesc MBlazeInsts[]; 33 } 34 35 using namespace llvm; 36 37 const uint16_t UNSUPPORTED = -1; 38 39 static const uint16_t mblazeBinary2Opcode[] = { 40 MBlaze::ADD, MBlaze::RSUB, MBlaze::ADDC, MBlaze::RSUBC, //00,01,02,03 41 MBlaze::ADDK, MBlaze::RSUBK, MBlaze::ADDKC, MBlaze::RSUBKC, //04,05,06,07 42 MBlaze::ADDI, MBlaze::RSUBI, MBlaze::ADDIC, MBlaze::RSUBIC, //08,09,0A,0B 43 MBlaze::ADDIK, MBlaze::RSUBIK, MBlaze::ADDIKC, MBlaze::RSUBIKC, //0C,0D,0E,0F 44 45 MBlaze::MUL, MBlaze::BSRL, MBlaze::IDIV, MBlaze::GETD, //10,11,12,13 46 UNSUPPORTED, UNSUPPORTED, MBlaze::FADD, UNSUPPORTED, //14,15,16,17 47 MBlaze::MULI, MBlaze::BSRLI, UNSUPPORTED, MBlaze::GET, //18,19,1A,1B 48 UNSUPPORTED, UNSUPPORTED, UNSUPPORTED, UNSUPPORTED, //1C,1D,1E,1F 49 50 MBlaze::OR, MBlaze::AND, MBlaze::XOR, MBlaze::ANDN, //20,21,22,23 51 MBlaze::SEXT8, MBlaze::MFS, MBlaze::BR, MBlaze::BEQ, //24,25,26,27 52 MBlaze::ORI, MBlaze::ANDI, MBlaze::XORI, MBlaze::ANDNI, //28,29,2A,2B 53 MBlaze::IMM, MBlaze::RTSD, MBlaze::BRI, MBlaze::BEQI, //2C,2D,2E,2F 54 55 MBlaze::LBU, MBlaze::LHU, MBlaze::LW, UNSUPPORTED, //30,31,32,33 56 MBlaze::SB, MBlaze::SH, MBlaze::SW, UNSUPPORTED, //34,35,36,37 57 MBlaze::LBUI, MBlaze::LHUI, MBlaze::LWI, UNSUPPORTED, //38,39,3A,3B 58 MBlaze::SBI, MBlaze::SHI, MBlaze::SWI, UNSUPPORTED, //3C,3D,3E,3F 59 }; 60 61 static unsigned getRD(uint32_t insn) { 62 if (!isMBlazeRegister((insn>>21)&0x1F)) 63 return UNSUPPORTED; 64 return getMBlazeRegisterFromNumbering((insn>>21)&0x1F); 65 } 66 67 static unsigned getRA(uint32_t insn) { 68 if (!getMBlazeRegisterFromNumbering((insn>>16)&0x1F)) 69 return UNSUPPORTED; 70 return getMBlazeRegisterFromNumbering((insn>>16)&0x1F); 71 } 72 73 static unsigned getRB(uint32_t insn) { 74 if (!getMBlazeRegisterFromNumbering((insn>>11)&0x1F)) 75 return UNSUPPORTED; 76 return getMBlazeRegisterFromNumbering((insn>>11)&0x1F); 77 } 78 79 static int64_t getRS(uint32_t insn) { 80 if (!isSpecialMBlazeRegister(insn&0x3FFF)) 81 return UNSUPPORTED; 82 return getSpecialMBlazeRegisterFromNumbering(insn&0x3FFF); 83 } 84 85 static int64_t getIMM(uint32_t insn) { 86 int16_t val = (insn & 0xFFFF); 87 return val; 88 } 89 90 static int64_t getSHT(uint32_t insn) { 91 int16_t val = (insn & 0x1F); 92 return val; 93 } 94 95 static unsigned getFLAGS(int32_t insn) { 96 return (insn & 0x7FF); 97 } 98 99 static int64_t getFSL(uint32_t insn) { 100 int16_t val = (insn & 0xF); 101 return val; 102 } 103 104 static unsigned decodeMUL(uint32_t insn) { 105 switch (getFLAGS(insn)) { 106 default: return UNSUPPORTED; 107 case 0: return MBlaze::MUL; 108 case 1: return MBlaze::MULH; 109 case 2: return MBlaze::MULHSU; 110 case 3: return MBlaze::MULHU; 111 } 112 } 113 114 static unsigned decodeSEXT(uint32_t insn) { 115 switch (insn&0x7FF) { 116 default: return UNSUPPORTED; 117 case 0x60: return MBlaze::SEXT8; 118 case 0x68: return MBlaze::WIC; 119 case 0x64: return MBlaze::WDC; 120 case 0x66: return MBlaze::WDCC; 121 case 0x74: return MBlaze::WDCF; 122 case 0x61: return MBlaze::SEXT16; 123 case 0x41: return MBlaze::SRL; 124 case 0x21: return MBlaze::SRC; 125 case 0x01: return MBlaze::SRA; 126 case 0xE0: return MBlaze::CLZ; 127 } 128 } 129 130 static unsigned decodeBEQ(uint32_t insn) { 131 switch ((insn>>21)&0x1F) { 132 default: return UNSUPPORTED; 133 case 0x00: return MBlaze::BEQ; 134 case 0x10: return MBlaze::BEQD; 135 case 0x05: return MBlaze::BGE; 136 case 0x15: return MBlaze::BGED; 137 case 0x04: return MBlaze::BGT; 138 case 0x14: return MBlaze::BGTD; 139 case 0x03: return MBlaze::BLE; 140 case 0x13: return MBlaze::BLED; 141 case 0x02: return MBlaze::BLT; 142 case 0x12: return MBlaze::BLTD; 143 case 0x01: return MBlaze::BNE; 144 case 0x11: return MBlaze::BNED; 145 } 146 } 147 148 static unsigned decodeBEQI(uint32_t insn) { 149 switch ((insn>>21)&0x1F) { 150 default: return UNSUPPORTED; 151 case 0x00: return MBlaze::BEQI; 152 case 0x10: return MBlaze::BEQID; 153 case 0x05: return MBlaze::BGEI; 154 case 0x15: return MBlaze::BGEID; 155 case 0x04: return MBlaze::BGTI; 156 case 0x14: return MBlaze::BGTID; 157 case 0x03: return MBlaze::BLEI; 158 case 0x13: return MBlaze::BLEID; 159 case 0x02: return MBlaze::BLTI; 160 case 0x12: return MBlaze::BLTID; 161 case 0x01: return MBlaze::BNEI; 162 case 0x11: return MBlaze::BNEID; 163 } 164 } 165 166 static unsigned decodeBR(uint32_t insn) { 167 switch ((insn>>16)&0x1F) { 168 default: return UNSUPPORTED; 169 case 0x00: return MBlaze::BR; 170 case 0x08: return MBlaze::BRA; 171 case 0x0C: return MBlaze::BRK; 172 case 0x10: return MBlaze::BRD; 173 case 0x14: return MBlaze::BRLD; 174 case 0x18: return MBlaze::BRAD; 175 case 0x1C: return MBlaze::BRALD; 176 } 177 } 178 179 static unsigned decodeBRI(uint32_t insn) { 180 switch (insn&0x3FFFFFF) { 181 default: break; 182 case 0x0020004: return MBlaze::IDMEMBAR; 183 case 0x0220004: return MBlaze::DMEMBAR; 184 case 0x0420004: return MBlaze::IMEMBAR; 185 } 186 187 switch ((insn>>16)&0x1F) { 188 default: return UNSUPPORTED; 189 case 0x00: return MBlaze::BRI; 190 case 0x08: return MBlaze::BRAI; 191 case 0x0C: return MBlaze::BRKI; 192 case 0x10: return MBlaze::BRID; 193 case 0x14: return MBlaze::BRLID; 194 case 0x18: return MBlaze::BRAID; 195 case 0x1C: return MBlaze::BRALID; 196 } 197 } 198 199 static unsigned decodeBSRL(uint32_t insn) { 200 switch ((insn>>9)&0x3) { 201 default: return UNSUPPORTED; 202 case 0x2: return MBlaze::BSLL; 203 case 0x1: return MBlaze::BSRA; 204 case 0x0: return MBlaze::BSRL; 205 } 206 } 207 208 static unsigned decodeBSRLI(uint32_t insn) { 209 switch ((insn>>9)&0x3) { 210 default: return UNSUPPORTED; 211 case 0x2: return MBlaze::BSLLI; 212 case 0x1: return MBlaze::BSRAI; 213 case 0x0: return MBlaze::BSRLI; 214 } 215 } 216 217 static unsigned decodeRSUBK(uint32_t insn) { 218 switch (getFLAGS(insn)) { 219 default: return UNSUPPORTED; 220 case 0x0: return MBlaze::RSUBK; 221 case 0x1: return MBlaze::CMP; 222 case 0x3: return MBlaze::CMPU; 223 } 224 } 225 226 static unsigned decodeFADD(uint32_t insn) { 227 switch (getFLAGS(insn)) { 228 default: return UNSUPPORTED; 229 case 0x000: return MBlaze::FADD; 230 case 0x080: return MBlaze::FRSUB; 231 case 0x100: return MBlaze::FMUL; 232 case 0x180: return MBlaze::FDIV; 233 case 0x200: return MBlaze::FCMP_UN; 234 case 0x210: return MBlaze::FCMP_LT; 235 case 0x220: return MBlaze::FCMP_EQ; 236 case 0x230: return MBlaze::FCMP_LE; 237 case 0x240: return MBlaze::FCMP_GT; 238 case 0x250: return MBlaze::FCMP_NE; 239 case 0x260: return MBlaze::FCMP_GE; 240 case 0x280: return MBlaze::FLT; 241 case 0x300: return MBlaze::FINT; 242 case 0x380: return MBlaze::FSQRT; 243 } 244 } 245 246 static unsigned decodeGET(uint32_t insn) { 247 switch ((insn>>10)&0x3F) { 248 default: return UNSUPPORTED; 249 case 0x00: return MBlaze::GET; 250 case 0x01: return MBlaze::EGET; 251 case 0x02: return MBlaze::AGET; 252 case 0x03: return MBlaze::EAGET; 253 case 0x04: return MBlaze::TGET; 254 case 0x05: return MBlaze::TEGET; 255 case 0x06: return MBlaze::TAGET; 256 case 0x07: return MBlaze::TEAGET; 257 case 0x08: return MBlaze::CGET; 258 case 0x09: return MBlaze::ECGET; 259 case 0x0A: return MBlaze::CAGET; 260 case 0x0B: return MBlaze::ECAGET; 261 case 0x0C: return MBlaze::TCGET; 262 case 0x0D: return MBlaze::TECGET; 263 case 0x0E: return MBlaze::TCAGET; 264 case 0x0F: return MBlaze::TECAGET; 265 case 0x10: return MBlaze::NGET; 266 case 0x11: return MBlaze::NEGET; 267 case 0x12: return MBlaze::NAGET; 268 case 0x13: return MBlaze::NEAGET; 269 case 0x14: return MBlaze::TNGET; 270 case 0x15: return MBlaze::TNEGET; 271 case 0x16: return MBlaze::TNAGET; 272 case 0x17: return MBlaze::TNEAGET; 273 case 0x18: return MBlaze::NCGET; 274 case 0x19: return MBlaze::NECGET; 275 case 0x1A: return MBlaze::NCAGET; 276 case 0x1B: return MBlaze::NECAGET; 277 case 0x1C: return MBlaze::TNCGET; 278 case 0x1D: return MBlaze::TNECGET; 279 case 0x1E: return MBlaze::TNCAGET; 280 case 0x1F: return MBlaze::TNECAGET; 281 case 0x20: return MBlaze::PUT; 282 case 0x22: return MBlaze::APUT; 283 case 0x24: return MBlaze::TPUT; 284 case 0x26: return MBlaze::TAPUT; 285 case 0x28: return MBlaze::CPUT; 286 case 0x2A: return MBlaze::CAPUT; 287 case 0x2C: return MBlaze::TCPUT; 288 case 0x2E: return MBlaze::TCAPUT; 289 case 0x30: return MBlaze::NPUT; 290 case 0x32: return MBlaze::NAPUT; 291 case 0x34: return MBlaze::TNPUT; 292 case 0x36: return MBlaze::TNAPUT; 293 case 0x38: return MBlaze::NCPUT; 294 case 0x3A: return MBlaze::NCAPUT; 295 case 0x3C: return MBlaze::TNCPUT; 296 case 0x3E: return MBlaze::TNCAPUT; 297 } 298 } 299 300 static unsigned decodeGETD(uint32_t insn) { 301 switch ((insn>>5)&0x3F) { 302 default: return UNSUPPORTED; 303 case 0x00: return MBlaze::GETD; 304 case 0x01: return MBlaze::EGETD; 305 case 0x02: return MBlaze::AGETD; 306 case 0x03: return MBlaze::EAGETD; 307 case 0x04: return MBlaze::TGETD; 308 case 0x05: return MBlaze::TEGETD; 309 case 0x06: return MBlaze::TAGETD; 310 case 0x07: return MBlaze::TEAGETD; 311 case 0x08: return MBlaze::CGETD; 312 case 0x09: return MBlaze::ECGETD; 313 case 0x0A: return MBlaze::CAGETD; 314 case 0x0B: return MBlaze::ECAGETD; 315 case 0x0C: return MBlaze::TCGETD; 316 case 0x0D: return MBlaze::TECGETD; 317 case 0x0E: return MBlaze::TCAGETD; 318 case 0x0F: return MBlaze::TECAGETD; 319 case 0x10: return MBlaze::NGETD; 320 case 0x11: return MBlaze::NEGETD; 321 case 0x12: return MBlaze::NAGETD; 322 case 0x13: return MBlaze::NEAGETD; 323 case 0x14: return MBlaze::TNGETD; 324 case 0x15: return MBlaze::TNEGETD; 325 case 0x16: return MBlaze::TNAGETD; 326 case 0x17: return MBlaze::TNEAGETD; 327 case 0x18: return MBlaze::NCGETD; 328 case 0x19: return MBlaze::NECGETD; 329 case 0x1A: return MBlaze::NCAGETD; 330 case 0x1B: return MBlaze::NECAGETD; 331 case 0x1C: return MBlaze::TNCGETD; 332 case 0x1D: return MBlaze::TNECGETD; 333 case 0x1E: return MBlaze::TNCAGETD; 334 case 0x1F: return MBlaze::TNECAGETD; 335 case 0x20: return MBlaze::PUTD; 336 case 0x22: return MBlaze::APUTD; 337 case 0x24: return MBlaze::TPUTD; 338 case 0x26: return MBlaze::TAPUTD; 339 case 0x28: return MBlaze::CPUTD; 340 case 0x2A: return MBlaze::CAPUTD; 341 case 0x2C: return MBlaze::TCPUTD; 342 case 0x2E: return MBlaze::TCAPUTD; 343 case 0x30: return MBlaze::NPUTD; 344 case 0x32: return MBlaze::NAPUTD; 345 case 0x34: return MBlaze::TNPUTD; 346 case 0x36: return MBlaze::TNAPUTD; 347 case 0x38: return MBlaze::NCPUTD; 348 case 0x3A: return MBlaze::NCAPUTD; 349 case 0x3C: return MBlaze::TNCPUTD; 350 case 0x3E: return MBlaze::TNCAPUTD; 351 } 352 } 353 354 static unsigned decodeIDIV(uint32_t insn) { 355 switch (insn&0x3) { 356 default: return UNSUPPORTED; 357 case 0x0: return MBlaze::IDIV; 358 case 0x2: return MBlaze::IDIVU; 359 } 360 } 361 362 static unsigned decodeLBU(uint32_t insn) { 363 switch ((insn>>9)&0x1) { 364 default: return UNSUPPORTED; 365 case 0x0: return MBlaze::LBU; 366 case 0x1: return MBlaze::LBUR; 367 } 368 } 369 370 static unsigned decodeLHU(uint32_t insn) { 371 switch ((insn>>9)&0x1) { 372 default: return UNSUPPORTED; 373 case 0x0: return MBlaze::LHU; 374 case 0x1: return MBlaze::LHUR; 375 } 376 } 377 378 static unsigned decodeLW(uint32_t insn) { 379 switch ((insn>>9)&0x3) { 380 default: return UNSUPPORTED; 381 case 0x0: return MBlaze::LW; 382 case 0x1: return MBlaze::LWR; 383 case 0x2: return MBlaze::LWX; 384 } 385 } 386 387 static unsigned decodeSB(uint32_t insn) { 388 switch ((insn>>9)&0x1) { 389 default: return UNSUPPORTED; 390 case 0x0: return MBlaze::SB; 391 case 0x1: return MBlaze::SBR; 392 } 393 } 394 395 static unsigned decodeSH(uint32_t insn) { 396 switch ((insn>>9)&0x1) { 397 default: return UNSUPPORTED; 398 case 0x0: return MBlaze::SH; 399 case 0x1: return MBlaze::SHR; 400 } 401 } 402 403 static unsigned decodeSW(uint32_t insn) { 404 switch ((insn>>9)&0x3) { 405 default: return UNSUPPORTED; 406 case 0x0: return MBlaze::SW; 407 case 0x1: return MBlaze::SWR; 408 case 0x2: return MBlaze::SWX; 409 } 410 } 411 412 static unsigned decodeMFS(uint32_t insn) { 413 switch ((insn>>15)&0x1) { 414 default: return UNSUPPORTED; 415 case 0x0: 416 switch ((insn>>16)&0x1) { 417 default: return UNSUPPORTED; 418 case 0x0: return MBlaze::MSRSET; 419 case 0x1: return MBlaze::MSRCLR; 420 } 421 case 0x1: 422 switch ((insn>>14)&0x1) { 423 default: return UNSUPPORTED; 424 case 0x0: return MBlaze::MFS; 425 case 0x1: return MBlaze::MTS; 426 } 427 } 428 } 429 430 static unsigned decodeOR(uint32_t insn) { 431 switch (getFLAGS(insn)) { 432 default: return UNSUPPORTED; 433 case 0x000: return MBlaze::OR; 434 case 0x400: return MBlaze::PCMPBF; 435 } 436 } 437 438 static unsigned decodeXOR(uint32_t insn) { 439 switch (getFLAGS(insn)) { 440 default: return UNSUPPORTED; 441 case 0x000: return MBlaze::XOR; 442 case 0x400: return MBlaze::PCMPEQ; 443 } 444 } 445 446 static unsigned decodeANDN(uint32_t insn) { 447 switch (getFLAGS(insn)) { 448 default: return UNSUPPORTED; 449 case 0x000: return MBlaze::ANDN; 450 case 0x400: return MBlaze::PCMPNE; 451 } 452 } 453 454 static unsigned decodeRTSD(uint32_t insn) { 455 switch ((insn>>21)&0x1F) { 456 default: return UNSUPPORTED; 457 case 0x10: return MBlaze::RTSD; 458 case 0x11: return MBlaze::RTID; 459 case 0x12: return MBlaze::RTBD; 460 case 0x14: return MBlaze::RTED; 461 } 462 } 463 464 static unsigned getOPCODE(uint32_t insn) { 465 unsigned opcode = mblazeBinary2Opcode[ (insn>>26)&0x3F ]; 466 switch (opcode) { 467 case MBlaze::MUL: return decodeMUL(insn); 468 case MBlaze::SEXT8: return decodeSEXT(insn); 469 case MBlaze::BEQ: return decodeBEQ(insn); 470 case MBlaze::BEQI: return decodeBEQI(insn); 471 case MBlaze::BR: return decodeBR(insn); 472 case MBlaze::BRI: return decodeBRI(insn); 473 case MBlaze::BSRL: return decodeBSRL(insn); 474 case MBlaze::BSRLI: return decodeBSRLI(insn); 475 case MBlaze::RSUBK: return decodeRSUBK(insn); 476 case MBlaze::FADD: return decodeFADD(insn); 477 case MBlaze::GET: return decodeGET(insn); 478 case MBlaze::GETD: return decodeGETD(insn); 479 case MBlaze::IDIV: return decodeIDIV(insn); 480 case MBlaze::LBU: return decodeLBU(insn); 481 case MBlaze::LHU: return decodeLHU(insn); 482 case MBlaze::LW: return decodeLW(insn); 483 case MBlaze::SB: return decodeSB(insn); 484 case MBlaze::SH: return decodeSH(insn); 485 case MBlaze::SW: return decodeSW(insn); 486 case MBlaze::MFS: return decodeMFS(insn); 487 case MBlaze::OR: return decodeOR(insn); 488 case MBlaze::XOR: return decodeXOR(insn); 489 case MBlaze::ANDN: return decodeANDN(insn); 490 case MBlaze::RTSD: return decodeRTSD(insn); 491 default: return opcode; 492 } 493 } 494 495 const EDInstInfo *MBlazeDisassembler::getEDInfo() const { 496 return instInfoMBlaze; 497 } 498 499 // 500 // Public interface for the disassembler 501 // 502 503 MCDisassembler::DecodeStatus MBlazeDisassembler::getInstruction(MCInst &instr, 504 uint64_t &size, 505 const MemoryObject ®ion, 506 uint64_t address, 507 raw_ostream &vStream, 508 raw_ostream &cStream) const { 509 // The machine instruction. 510 uint32_t insn; 511 uint64_t read; 512 uint8_t bytes[4]; 513 514 // By default we consume 1 byte on failure 515 size = 1; 516 517 // We want to read exactly 4 bytes of data. 518 if (region.readBytes(address, 4, (uint8_t*)bytes, &read) == -1 || read < 4) 519 return Fail; 520 521 // Encoded as a big-endian 32-bit word in the stream. 522 insn = (bytes[0]<<24) | (bytes[1]<<16) | (bytes[2]<< 8) | (bytes[3]<<0); 523 524 // Get the MCInst opcode from the binary instruction and make sure 525 // that it is a valid instruction. 526 unsigned opcode = getOPCODE(insn); 527 if (opcode == UNSUPPORTED) 528 return Fail; 529 530 instr.setOpcode(opcode); 531 532 unsigned RD = getRD(insn); 533 unsigned RA = getRA(insn); 534 unsigned RB = getRB(insn); 535 unsigned RS = getRS(insn); 536 537 uint64_t tsFlags = MBlazeInsts[opcode].TSFlags; 538 switch ((tsFlags & MBlazeII::FormMask)) { 539 default: 540 return Fail; 541 542 case MBlazeII::FC: 543 break; 544 545 case MBlazeII::FRRRR: 546 if (RD == UNSUPPORTED || RA == UNSUPPORTED || RB == UNSUPPORTED) 547 return Fail; 548 instr.addOperand(MCOperand::CreateReg(RD)); 549 instr.addOperand(MCOperand::CreateReg(RB)); 550 instr.addOperand(MCOperand::CreateReg(RA)); 551 break; 552 553 case MBlazeII::FRRR: 554 if (RD == UNSUPPORTED || RA == UNSUPPORTED || RB == UNSUPPORTED) 555 return Fail; 556 instr.addOperand(MCOperand::CreateReg(RD)); 557 instr.addOperand(MCOperand::CreateReg(RA)); 558 instr.addOperand(MCOperand::CreateReg(RB)); 559 break; 560 561 case MBlazeII::FRR: 562 if (RD == UNSUPPORTED || RA == UNSUPPORTED) 563 return Fail; 564 instr.addOperand(MCOperand::CreateReg(RD)); 565 instr.addOperand(MCOperand::CreateReg(RA)); 566 break; 567 568 case MBlazeII::FRI: 569 switch (opcode) { 570 default: 571 return Fail; 572 case MBlaze::MFS: 573 if (RD == UNSUPPORTED) 574 return Fail; 575 instr.addOperand(MCOperand::CreateReg(RD)); 576 instr.addOperand(MCOperand::CreateImm(insn&0x3FFF)); 577 break; 578 case MBlaze::MTS: 579 if (RA == UNSUPPORTED) 580 return Fail; 581 instr.addOperand(MCOperand::CreateImm(insn&0x3FFF)); 582 instr.addOperand(MCOperand::CreateReg(RA)); 583 break; 584 case MBlaze::MSRSET: 585 case MBlaze::MSRCLR: 586 if (RD == UNSUPPORTED) 587 return Fail; 588 instr.addOperand(MCOperand::CreateReg(RD)); 589 instr.addOperand(MCOperand::CreateImm(insn&0x7FFF)); 590 break; 591 } 592 break; 593 594 case MBlazeII::FRRI: 595 if (RD == UNSUPPORTED || RA == UNSUPPORTED) 596 return Fail; 597 instr.addOperand(MCOperand::CreateReg(RD)); 598 instr.addOperand(MCOperand::CreateReg(RA)); 599 switch (opcode) { 600 default: 601 instr.addOperand(MCOperand::CreateImm(getIMM(insn))); 602 break; 603 case MBlaze::BSRLI: 604 case MBlaze::BSRAI: 605 case MBlaze::BSLLI: 606 instr.addOperand(MCOperand::CreateImm(insn&0x1F)); 607 break; 608 } 609 break; 610 611 case MBlazeII::FCRR: 612 if (RA == UNSUPPORTED || RB == UNSUPPORTED) 613 return Fail; 614 instr.addOperand(MCOperand::CreateReg(RA)); 615 instr.addOperand(MCOperand::CreateReg(RB)); 616 break; 617 618 case MBlazeII::FCRI: 619 if (RA == UNSUPPORTED) 620 return Fail; 621 instr.addOperand(MCOperand::CreateReg(RA)); 622 instr.addOperand(MCOperand::CreateImm(getIMM(insn))); 623 break; 624 625 case MBlazeII::FRCR: 626 if (RD == UNSUPPORTED || RB == UNSUPPORTED) 627 return Fail; 628 instr.addOperand(MCOperand::CreateReg(RD)); 629 instr.addOperand(MCOperand::CreateReg(RB)); 630 break; 631 632 case MBlazeII::FRCI: 633 if (RD == UNSUPPORTED) 634 return Fail; 635 instr.addOperand(MCOperand::CreateReg(RD)); 636 instr.addOperand(MCOperand::CreateImm(getIMM(insn))); 637 break; 638 639 case MBlazeII::FCCR: 640 if (RB == UNSUPPORTED) 641 return Fail; 642 instr.addOperand(MCOperand::CreateReg(RB)); 643 break; 644 645 case MBlazeII::FCCI: 646 instr.addOperand(MCOperand::CreateImm(getIMM(insn))); 647 break; 648 649 case MBlazeII::FRRCI: 650 if (RD == UNSUPPORTED || RA == UNSUPPORTED) 651 return Fail; 652 instr.addOperand(MCOperand::CreateReg(RD)); 653 instr.addOperand(MCOperand::CreateReg(RA)); 654 instr.addOperand(MCOperand::CreateImm(getSHT(insn))); 655 break; 656 657 case MBlazeII::FRRC: 658 if (RD == UNSUPPORTED || RA == UNSUPPORTED) 659 return Fail; 660 instr.addOperand(MCOperand::CreateReg(RD)); 661 instr.addOperand(MCOperand::CreateReg(RA)); 662 break; 663 664 case MBlazeII::FRCX: 665 if (RD == UNSUPPORTED) 666 return Fail; 667 instr.addOperand(MCOperand::CreateReg(RD)); 668 instr.addOperand(MCOperand::CreateImm(getFSL(insn))); 669 break; 670 671 case MBlazeII::FRCS: 672 if (RD == UNSUPPORTED || RS == UNSUPPORTED) 673 return Fail; 674 instr.addOperand(MCOperand::CreateReg(RD)); 675 instr.addOperand(MCOperand::CreateReg(RS)); 676 break; 677 678 case MBlazeII::FCRCS: 679 if (RS == UNSUPPORTED || RA == UNSUPPORTED) 680 return Fail; 681 instr.addOperand(MCOperand::CreateReg(RS)); 682 instr.addOperand(MCOperand::CreateReg(RA)); 683 break; 684 685 case MBlazeII::FCRCX: 686 if (RA == UNSUPPORTED) 687 return Fail; 688 instr.addOperand(MCOperand::CreateReg(RA)); 689 instr.addOperand(MCOperand::CreateImm(getFSL(insn))); 690 break; 691 692 case MBlazeII::FCX: 693 instr.addOperand(MCOperand::CreateImm(getFSL(insn))); 694 break; 695 696 case MBlazeII::FCR: 697 if (RB == UNSUPPORTED) 698 return Fail; 699 instr.addOperand(MCOperand::CreateReg(RB)); 700 break; 701 702 case MBlazeII::FRIR: 703 if (RD == UNSUPPORTED || RA == UNSUPPORTED) 704 return Fail; 705 instr.addOperand(MCOperand::CreateReg(RD)); 706 instr.addOperand(MCOperand::CreateImm(getIMM(insn))); 707 instr.addOperand(MCOperand::CreateReg(RA)); 708 break; 709 } 710 711 // We always consume 4 bytes of data on success 712 size = 4; 713 714 return Success; 715 } 716 717 static MCDisassembler *createMBlazeDisassembler(const Target &T, 718 const MCSubtargetInfo &STI) { 719 return new MBlazeDisassembler(STI); 720 } 721 722 extern "C" void LLVMInitializeMBlazeDisassembler() { 723 // Register the disassembler. 724 TargetRegistry::RegisterMCDisassembler(TheMBlazeTarget, 725 createMBlazeDisassembler); 726 } 727