llvm-6502/lib/Target/MBlaze/Disassembler/MBlazeDisassembler.cpp

//===- MBlazeDisassembler.cpp - Disassembler for MicroBlaze  ----*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file is part of the MBlaze Disassembler. It contains code to translate
// the data produced by the decoder into MCInsts.
//
//===----------------------------------------------------------------------===//

#include "MBlaze.h"
#include "MBlazeDisassembler.h"

#include "llvm/MC/EDInstInfo.h"
#include "llvm/MC/MCDisassembler.h"
#include "llvm/MC/MCInst.h"
#include "llvm/MC/MCInstrDesc.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/MemoryObject.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/raw_ostream.h"

// #include "MBlazeGenDecoderTables.inc"
// #include "MBlazeGenRegisterNames.inc"
#include "MBlazeGenEDInfo.inc"

namespace llvm {
extern const MCInstrDesc MBlazeInsts[];
}

using namespace llvm;

const unsigned UNSUPPORTED = -1;

static const unsigned mblazeBinary2Opcode[] = {
  MBlaze::ADD,   MBlaze::RSUB,   MBlaze::ADDC,   MBlaze::RSUBC,   //00,01,02,03
  MBlaze::ADDK,  MBlaze::RSUBK,  MBlaze::ADDKC,  MBlaze::RSUBKC,  //04,05,06,07
  MBlaze::ADDI,  MBlaze::RSUBI,  MBlaze::ADDIC,  MBlaze::RSUBIC,  //08,09,0A,0B
  MBlaze::ADDIK, MBlaze::RSUBIK, MBlaze::ADDIKC, MBlaze::RSUBIKC, //0C,0D,0E,0F

  MBlaze::MUL,   MBlaze::BSRL,   MBlaze::IDIV,   MBlaze::GETD,    //10,11,12,13
  UNSUPPORTED,   UNSUPPORTED,    MBlaze::FADD,   UNSUPPORTED,     //14,15,16,17
  MBlaze::MULI,  MBlaze::BSRLI,  UNSUPPORTED,    MBlaze::GET,     //18,19,1A,1B
  UNSUPPORTED,   UNSUPPORTED,    UNSUPPORTED,    UNSUPPORTED,     //1C,1D,1E,1F

  MBlaze::OR,    MBlaze::AND,    MBlaze::XOR,    MBlaze::ANDN,    //20,21,22,23
  MBlaze::SEXT8, MBlaze::MFS,    MBlaze::BR,     MBlaze::BEQ,     //24,25,26,27
  MBlaze::ORI,   MBlaze::ANDI,   MBlaze::XORI,   MBlaze::ANDNI,   //28,29,2A,2B
  MBlaze::IMM,   MBlaze::RTSD,   MBlaze::BRI,    MBlaze::BEQI,    //2C,2D,2E,2F

  MBlaze::LBU,   MBlaze::LHU,    MBlaze::LW,     UNSUPPORTED,     //30,31,32,33
  MBlaze::SB,    MBlaze::SH,     MBlaze::SW,     UNSUPPORTED,     //34,35,36,37
  MBlaze::LBUI,  MBlaze::LHUI,   MBlaze::LWI,    UNSUPPORTED,     //38,39,3A,3B
  MBlaze::SBI,   MBlaze::SHI,    MBlaze::SWI,    UNSUPPORTED,     //3C,3D,3E,3F
};

static unsigned getRD(uint32_t insn) {
  if (!isMBlazeRegister((insn>>21)&0x1F))
    return UNSUPPORTED;
  return getMBlazeRegisterFromNumbering((insn>>21)&0x1F);
}

static unsigned getRA(uint32_t insn) {
  if (!getMBlazeRegisterFromNumbering((insn>>16)&0x1F))
    return UNSUPPORTED;
  return getMBlazeRegisterFromNumbering((insn>>16)&0x1F);
}

static unsigned getRB(uint32_t insn) {
  if (!getMBlazeRegisterFromNumbering((insn>>11)&0x1F))
    return UNSUPPORTED;
  return getMBlazeRegisterFromNumbering((insn>>11)&0x1F);
}

static int64_t getRS(uint32_t insn) {
  if (!isSpecialMBlazeRegister(insn&0x3FFF))
    return UNSUPPORTED;
  return getSpecialMBlazeRegisterFromNumbering(insn&0x3FFF);
}

static int64_t getIMM(uint32_t insn) {
    int16_t val = (insn & 0xFFFF);
    return val;
}

static int64_t getSHT(uint32_t insn) {
    int16_t val = (insn & 0x1F);
    return val;
}

static unsigned getFLAGS(int32_t insn) {
    return (insn & 0x7FF);
}

static int64_t getFSL(uint32_t insn) {
    int16_t val = (insn & 0xF);
    return val;
}

static unsigned decodeMUL(uint32_t insn) {
    switch (getFLAGS(insn)) {
    default: return UNSUPPORTED;
    case 0:  return MBlaze::MUL;
    case 1:  return MBlaze::MULH;
    case 2:  return MBlaze::MULHSU;
    case 3:  return MBlaze::MULHU;
    }
}

static unsigned decodeSEXT(uint32_t insn) {
    switch (insn&0x7FF) {
    default:   return UNSUPPORTED;
    case 0x60: return MBlaze::SEXT8;
    case 0x68: return MBlaze::WIC;
    case 0x64: return MBlaze::WDC;
    case 0x66: return MBlaze::WDCC;
    case 0x74: return MBlaze::WDCF;
    case 0x61: return MBlaze::SEXT16;
    case 0x41: return MBlaze::SRL;
    case 0x21: return MBlaze::SRC;
    case 0x01: return MBlaze::SRA;
    case 0xE0: return MBlaze::CLZ;
    }
}

static unsigned decodeBEQ(uint32_t insn) {
    switch ((insn>>21)&0x1F) {
    default:    return UNSUPPORTED;
    case 0x00:  return MBlaze::BEQ;
    case 0x10:  return MBlaze::BEQD;
    case 0x05:  return MBlaze::BGE;
    case 0x15:  return MBlaze::BGED;
    case 0x04:  return MBlaze::BGT;
    case 0x14:  return MBlaze::BGTD;
    case 0x03:  return MBlaze::BLE;
    case 0x13:  return MBlaze::BLED;
    case 0x02:  return MBlaze::BLT;
    case 0x12:  return MBlaze::BLTD;
    case 0x01:  return MBlaze::BNE;
    case 0x11:  return MBlaze::BNED;
    }
}

static unsigned decodeBEQI(uint32_t insn) {
    switch ((insn>>21)&0x1F) {
    default:    return UNSUPPORTED;
    case 0x00:  return MBlaze::BEQI;
    case 0x10:  return MBlaze::BEQID;
    case 0x05:  return MBlaze::BGEI;
    case 0x15:  return MBlaze::BGEID;
    case 0x04:  return MBlaze::BGTI;
    case 0x14:  return MBlaze::BGTID;
    case 0x03:  return MBlaze::BLEI;
    case 0x13:  return MBlaze::BLEID;
    case 0x02:  return MBlaze::BLTI;
    case 0x12:  return MBlaze::BLTID;
    case 0x01:  return MBlaze::BNEI;
    case 0x11:  return MBlaze::BNEID;
    }
}

static unsigned decodeBR(uint32_t insn) {
    switch ((insn>>16)&0x1F) {
    default:   return UNSUPPORTED;
    case 0x00: return MBlaze::BR;
    case 0x08: return MBlaze::BRA;
    case 0x0C: return MBlaze::BRK;
    case 0x10: return MBlaze::BRD;
    case 0x14: return MBlaze::BRLD;
    case 0x18: return MBlaze::BRAD;
    case 0x1C: return MBlaze::BRALD;
    }
}

static unsigned decodeBRI(uint32_t insn) {
    switch (insn&0x3FFFFFF) {
    default:        break;
    case 0x0020004: return MBlaze::IDMEMBAR;
    case 0x0220004: return MBlaze::DMEMBAR;
    case 0x0420004: return MBlaze::IMEMBAR;
    }

    switch ((insn>>16)&0x1F) {
    default:   return UNSUPPORTED;
    case 0x00: return MBlaze::BRI;
    case 0x08: return MBlaze::BRAI;
    case 0x0C: return MBlaze::BRKI;
    case 0x10: return MBlaze::BRID;
    case 0x14: return MBlaze::BRLID;
    case 0x18: return MBlaze::BRAID;
    case 0x1C: return MBlaze::BRALID;
    }
}

static unsigned decodeBSRL(uint32_t insn) {
    switch ((insn>>9)&0x3) {
    default:  return UNSUPPORTED;
    case 0x2: return MBlaze::BSLL;
    case 0x1: return MBlaze::BSRA;
    case 0x0: return MBlaze::BSRL;
    }
}

static unsigned decodeBSRLI(uint32_t insn) {
    switch ((insn>>9)&0x3) {
    default:  return UNSUPPORTED;
    case 0x2: return MBlaze::BSLLI;
    case 0x1: return MBlaze::BSRAI;
    case 0x0: return MBlaze::BSRLI;
    }
}

static unsigned decodeRSUBK(uint32_t insn) {
    switch (getFLAGS(insn)) {
    default:  return UNSUPPORTED;
    case 0x0: return MBlaze::RSUBK;
    case 0x1: return MBlaze::CMP;
    case 0x3: return MBlaze::CMPU;
    }
}

static unsigned decodeFADD(uint32_t insn) {
    switch (getFLAGS(insn)) {
    default:    return UNSUPPORTED;
    case 0x000: return MBlaze::FADD;
    case 0x080: return MBlaze::FRSUB;
    case 0x100: return MBlaze::FMUL;
    case 0x180: return MBlaze::FDIV;
    case 0x200: return MBlaze::FCMP_UN;
    case 0x210: return MBlaze::FCMP_LT;
    case 0x220: return MBlaze::FCMP_EQ;
    case 0x230: return MBlaze::FCMP_LE;
    case 0x240: return MBlaze::FCMP_GT;
    case 0x250: return MBlaze::FCMP_NE;
    case 0x260: return MBlaze::FCMP_GE;
    case 0x280: return MBlaze::FLT;
    case 0x300: return MBlaze::FINT;
    case 0x380: return MBlaze::FSQRT;
    }
}

static unsigned decodeGET(uint32_t insn) {
    switch ((insn>>10)&0x3F) {
    default:   return UNSUPPORTED;
    case 0x00: return MBlaze::GET;
    case 0x01: return MBlaze::EGET;
    case 0x02: return MBlaze::AGET;
    case 0x03: return MBlaze::EAGET;
    case 0x04: return MBlaze::TGET;
    case 0x05: return MBlaze::TEGET;
    case 0x06: return MBlaze::TAGET;
    case 0x07: return MBlaze::TEAGET;
    case 0x08: return MBlaze::CGET;
    case 0x09: return MBlaze::ECGET;
    case 0x0A: return MBlaze::CAGET;
    case 0x0B: return MBlaze::ECAGET;
    case 0x0C: return MBlaze::TCGET;
    case 0x0D: return MBlaze::TECGET;
    case 0x0E: return MBlaze::TCAGET;
    case 0x0F: return MBlaze::TECAGET;
    case 0x10: return MBlaze::NGET;
    case 0x11: return MBlaze::NEGET;
    case 0x12: return MBlaze::NAGET;
    case 0x13: return MBlaze::NEAGET;
    case 0x14: return MBlaze::TNGET;
    case 0x15: return MBlaze::TNEGET;
    case 0x16: return MBlaze::TNAGET;
    case 0x17: return MBlaze::TNEAGET;
    case 0x18: return MBlaze::NCGET;
    case 0x19: return MBlaze::NECGET;
    case 0x1A: return MBlaze::NCAGET;
    case 0x1B: return MBlaze::NECAGET;
    case 0x1C: return MBlaze::TNCGET;
    case 0x1D: return MBlaze::TNECGET;
    case 0x1E: return MBlaze::TNCAGET;
    case 0x1F: return MBlaze::TNECAGET;
    case 0x20: return MBlaze::PUT;
    case 0x22: return MBlaze::APUT;
    case 0x24: return MBlaze::TPUT;
    case 0x26: return MBlaze::TAPUT;
    case 0x28: return MBlaze::CPUT;
    case 0x2A: return MBlaze::CAPUT;
    case 0x2C: return MBlaze::TCPUT;
    case 0x2E: return MBlaze::TCAPUT;
    case 0x30: return MBlaze::NPUT;
    case 0x32: return MBlaze::NAPUT;
    case 0x34: return MBlaze::TNPUT;
    case 0x36: return MBlaze::TNAPUT;
    case 0x38: return MBlaze::NCPUT;
    case 0x3A: return MBlaze::NCAPUT;
    case 0x3C: return MBlaze::TNCPUT;
    case 0x3E: return MBlaze::TNCAPUT;
    }
}

static unsigned decodeGETD(uint32_t insn) {
    switch ((insn>>5)&0x3F) {
    default:   return UNSUPPORTED;
    case 0x00: return MBlaze::GETD;
    case 0x01: return MBlaze::EGETD;
    case 0x02: return MBlaze::AGETD;
    case 0x03: return MBlaze::EAGETD;
    case 0x04: return MBlaze::TGETD;
    case 0x05: return MBlaze::TEGETD;
    case 0x06: return MBlaze::TAGETD;
    case 0x07: return MBlaze::TEAGETD;
    case 0x08: return MBlaze::CGETD;
    case 0x09: return MBlaze::ECGETD;
    case 0x0A: return MBlaze::CAGETD;
    case 0x0B: return MBlaze::ECAGETD;
    case 0x0C: return MBlaze::TCGETD;
    case 0x0D: return MBlaze::TECGETD;
    case 0x0E: return MBlaze::TCAGETD;
    case 0x0F: return MBlaze::TECAGETD;
    case 0x10: return MBlaze::NGETD;
    case 0x11: return MBlaze::NEGETD;
    case 0x12: return MBlaze::NAGETD;
    case 0x13: return MBlaze::NEAGETD;
    case 0x14: return MBlaze::TNGETD;
    case 0x15: return MBlaze::TNEGETD;
    case 0x16: return MBlaze::TNAGETD;
    case 0x17: return MBlaze::TNEAGETD;
    case 0x18: return MBlaze::NCGETD;
    case 0x19: return MBlaze::NECGETD;
    case 0x1A: return MBlaze::NCAGETD;
    case 0x1B: return MBlaze::NECAGETD;
    case 0x1C: return MBlaze::TNCGETD;
    case 0x1D: return MBlaze::TNECGETD;
    case 0x1E: return MBlaze::TNCAGETD;
    case 0x1F: return MBlaze::TNECAGETD;
    case 0x20: return MBlaze::PUTD;
    case 0x22: return MBlaze::APUTD;
    case 0x24: return MBlaze::TPUTD;
    case 0x26: return MBlaze::TAPUTD;
    case 0x28: return MBlaze::CPUTD;
    case 0x2A: return MBlaze::CAPUTD;
    case 0x2C: return MBlaze::TCPUTD;
    case 0x2E: return MBlaze::TCAPUTD;
    case 0x30: return MBlaze::NPUTD;
    case 0x32: return MBlaze::NAPUTD;
    case 0x34: return MBlaze::TNPUTD;
    case 0x36: return MBlaze::TNAPUTD;
    case 0x38: return MBlaze::NCPUTD;
    case 0x3A: return MBlaze::NCAPUTD;
    case 0x3C: return MBlaze::TNCPUTD;
    case 0x3E: return MBlaze::TNCAPUTD;
    }
}

static unsigned decodeIDIV(uint32_t insn) {
    switch (insn&0x3) {
    default:  return UNSUPPORTED;
    case 0x0: return MBlaze::IDIV;
    case 0x2: return MBlaze::IDIVU;
    }
}

static unsigned decodeLBU(uint32_t insn) {
    switch ((insn>>9)&0x1) {
    default:  return UNSUPPORTED;
    case 0x0: return MBlaze::LBU;
    case 0x1: return MBlaze::LBUR;
    }
}

static unsigned decodeLHU(uint32_t insn) {
    switch ((insn>>9)&0x1) {
    default:  return UNSUPPORTED;
    case 0x0: return MBlaze::LHU;
    case 0x1: return MBlaze::LHUR;
    }
}

static unsigned decodeLW(uint32_t insn) {
    switch ((insn>>9)&0x3) {
    default:  return UNSUPPORTED;
    case 0x0: return MBlaze::LW;
    case 0x1: return MBlaze::LWR;
    case 0x2: return MBlaze::LWX;
    }
}

static unsigned decodeSB(uint32_t insn) {
    switch ((insn>>9)&0x1) {
    default:  return UNSUPPORTED;
    case 0x0: return MBlaze::SB;
    case 0x1: return MBlaze::SBR;
    }
}

static unsigned decodeSH(uint32_t insn) {
    switch ((insn>>9)&0x1) {
    default:  return UNSUPPORTED;
    case 0x0: return MBlaze::SH;
    case 0x1: return MBlaze::SHR;
    }
}

static unsigned decodeSW(uint32_t insn) {
    switch ((insn>>9)&0x3) {
    default:  return UNSUPPORTED;
    case 0x0: return MBlaze::SW;
    case 0x1: return MBlaze::SWR;
    case 0x2: return MBlaze::SWX;
    }
}

static unsigned decodeMFS(uint32_t insn) {
    switch ((insn>>15)&0x1) {
    default:   return UNSUPPORTED;
    case 0x0:
      switch ((insn>>16)&0x1) {
      default:   return UNSUPPORTED;
      case 0x0: return MBlaze::MSRSET;
      case 0x1: return MBlaze::MSRCLR;
      }
    case 0x1:
      switch ((insn>>14)&0x1) {
      default:   return UNSUPPORTED;
      case 0x0: return MBlaze::MFS;
      case 0x1: return MBlaze::MTS;
      }
    }
}

static unsigned decodeOR(uint32_t insn) {
    switch (getFLAGS(insn)) {
    default:    return UNSUPPORTED;
    case 0x000: return MBlaze::OR;
    case 0x400: return MBlaze::PCMPBF;
    }
}

static unsigned decodeXOR(uint32_t insn) {
    switch (getFLAGS(insn)) {
    default:    return UNSUPPORTED;
    case 0x000: return MBlaze::XOR;
    case 0x400: return MBlaze::PCMPEQ;
    }
}

static unsigned decodeANDN(uint32_t insn) {
    switch (getFLAGS(insn)) {
    default:    return UNSUPPORTED;
    case 0x000: return MBlaze::ANDN;
    case 0x400: return MBlaze::PCMPNE;
    }
}

static unsigned decodeRTSD(uint32_t insn) {
    switch ((insn>>21)&0x1F) {
    default:   return UNSUPPORTED;
    case 0x10: return MBlaze::RTSD;
    case 0x11: return MBlaze::RTID;
    case 0x12: return MBlaze::RTBD;
    case 0x14: return MBlaze::RTED;
    }
}

static unsigned getOPCODE(uint32_t insn) {
  unsigned opcode = mblazeBinary2Opcode[ (insn>>26)&0x3F ];
  switch (opcode) {
  case MBlaze::MUL:     return decodeMUL(insn);
  case MBlaze::SEXT8:   return decodeSEXT(insn);
  case MBlaze::BEQ:     return decodeBEQ(insn);
  case MBlaze::BEQI:    return decodeBEQI(insn);
  case MBlaze::BR:      return decodeBR(insn);
  case MBlaze::BRI:     return decodeBRI(insn);
  case MBlaze::BSRL:    return decodeBSRL(insn);
  case MBlaze::BSRLI:   return decodeBSRLI(insn);
  case MBlaze::RSUBK:   return decodeRSUBK(insn);
  case MBlaze::FADD:    return decodeFADD(insn);
  case MBlaze::GET:     return decodeGET(insn);
  case MBlaze::GETD:    return decodeGETD(insn);
  case MBlaze::IDIV:    return decodeIDIV(insn);
  case MBlaze::LBU:     return decodeLBU(insn);
  case MBlaze::LHU:     return decodeLHU(insn);
  case MBlaze::LW:      return decodeLW(insn);
  case MBlaze::SB:      return decodeSB(insn);
  case MBlaze::SH:      return decodeSH(insn);
  case MBlaze::SW:      return decodeSW(insn);
  case MBlaze::MFS:     return decodeMFS(insn);
  case MBlaze::OR:      return decodeOR(insn);
  case MBlaze::XOR:     return decodeXOR(insn);
  case MBlaze::ANDN:    return decodeANDN(insn);
  case MBlaze::RTSD:    return decodeRTSD(insn);
  default:              return opcode;
  }
}

const EDInstInfo *MBlazeDisassembler::getEDInfo() const {
  return instInfoMBlaze;
}

//
// Public interface for the disassembler
//

MCDisassembler::DecodeStatus MBlazeDisassembler::getInstruction(MCInst &instr,
                                        uint64_t &size,
                                        MemoryObject &region,
                                        uint64_t address,
                                        raw_ostream &vStream,
                                        raw_ostream &cStream) const {
  // The machine instruction.
  uint32_t insn;
  uint64_t read;
  uint8_t bytes[4];

  // By default we consume 1 byte on failure
  size = 1;

  // We want to read exactly 4 bytes of data.
  if (region.readBytes(address, 4, (uint8_t*)bytes, &read) == -1 || read < 4)
    return Fail;

  // Encoded as a big-endian 32-bit word in the stream.
  insn = (bytes[0]<<24) | (bytes[1]<<16) | (bytes[2]<< 8) | (bytes[3]<<0);

  // Get the MCInst opcode from the binary instruction and make sure
  // that it is a valid instruction.
  unsigned opcode = getOPCODE(insn);
  if (opcode == UNSUPPORTED)
    return Fail;

  instr.setOpcode(opcode);

  unsigned RD = getRD(insn);
  unsigned RA = getRA(insn);
  unsigned RB = getRB(insn);
  unsigned RS = getRS(insn);

  uint64_t tsFlags = MBlazeInsts[opcode].TSFlags;
  switch ((tsFlags & MBlazeII::FormMask)) {
  default: 
    return Fail;

  case MBlazeII::FC:
    break;

  case MBlazeII::FRRRR:
    if (RD == UNSUPPORTED || RA == UNSUPPORTED || RB == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RD));
    instr.addOperand(MCOperand::CreateReg(RB));
    instr.addOperand(MCOperand::CreateReg(RA));
    break;

  case MBlazeII::FRRR:
    if (RD == UNSUPPORTED || RA == UNSUPPORTED || RB == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RD));
    instr.addOperand(MCOperand::CreateReg(RA));
    instr.addOperand(MCOperand::CreateReg(RB));
    break;

  case MBlazeII::FRR:
    if (RD == UNSUPPORTED || RA == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RD));
    instr.addOperand(MCOperand::CreateReg(RA));
    break;

  case MBlazeII::FRI:
    switch (opcode) {
    default: 
      return Fail;
    case MBlaze::MFS:
      if (RD == UNSUPPORTED)
        return Fail;
      instr.addOperand(MCOperand::CreateReg(RD));
      instr.addOperand(MCOperand::CreateImm(insn&0x3FFF));
      break;
    case MBlaze::MTS:
      if (RA == UNSUPPORTED)
        return Fail;
      instr.addOperand(MCOperand::CreateImm(insn&0x3FFF));
      instr.addOperand(MCOperand::CreateReg(RA));
      break;
    case MBlaze::MSRSET:
    case MBlaze::MSRCLR:
      if (RD == UNSUPPORTED)
        return Fail;
      instr.addOperand(MCOperand::CreateReg(RD));
      instr.addOperand(MCOperand::CreateImm(insn&0x7FFF));
      break;
    }
    break;

  case MBlazeII::FRRI:
    if (RD == UNSUPPORTED || RA == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RD));
    instr.addOperand(MCOperand::CreateReg(RA));
    switch (opcode) {
    default:
      instr.addOperand(MCOperand::CreateImm(getIMM(insn)));
      break;
    case MBlaze::BSRLI:
    case MBlaze::BSRAI:
    case MBlaze::BSLLI:
      instr.addOperand(MCOperand::CreateImm(insn&0x1F));
      break;
    }
    break;

  case MBlazeII::FCRR:
    if (RA == UNSUPPORTED || RB == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RA));
    instr.addOperand(MCOperand::CreateReg(RB));
    break;

  case MBlazeII::FCRI:
    if (RA == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RA));
    instr.addOperand(MCOperand::CreateImm(getIMM(insn)));
    break;

  case MBlazeII::FRCR:
    if (RD == UNSUPPORTED || RB == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RD));
    instr.addOperand(MCOperand::CreateReg(RB));
    break;

  case MBlazeII::FRCI:
    if (RD == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RD));
    instr.addOperand(MCOperand::CreateImm(getIMM(insn)));
    break;

  case MBlazeII::FCCR:
    if (RB == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RB));
    break;

  case MBlazeII::FCCI:
    instr.addOperand(MCOperand::CreateImm(getIMM(insn)));
    break;

  case MBlazeII::FRRCI:
    if (RD == UNSUPPORTED || RA == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RD));
    instr.addOperand(MCOperand::CreateReg(RA));
    instr.addOperand(MCOperand::CreateImm(getSHT(insn)));
    break;

  case MBlazeII::FRRC:
    if (RD == UNSUPPORTED || RA == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RD));
    instr.addOperand(MCOperand::CreateReg(RA));
    break;

  case MBlazeII::FRCX:
    if (RD == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RD));
    instr.addOperand(MCOperand::CreateImm(getFSL(insn)));
    break;

  case MBlazeII::FRCS:
    if (RD == UNSUPPORTED || RS == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RD));
    instr.addOperand(MCOperand::CreateReg(RS));
    break;

  case MBlazeII::FCRCS:
    if (RS == UNSUPPORTED || RA == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RS));
    instr.addOperand(MCOperand::CreateReg(RA));
    break;

  case MBlazeII::FCRCX:
    if (RA == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RA));
    instr.addOperand(MCOperand::CreateImm(getFSL(insn)));
    break;

  case MBlazeII::FCX:
    instr.addOperand(MCOperand::CreateImm(getFSL(insn)));
    break;

  case MBlazeII::FCR:
    if (RB == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RB));
    break;

  case MBlazeII::FRIR:
    if (RD == UNSUPPORTED || RA == UNSUPPORTED)
      return Fail;
    instr.addOperand(MCOperand::CreateReg(RD));
    instr.addOperand(MCOperand::CreateImm(getIMM(insn)));
    instr.addOperand(MCOperand::CreateReg(RA));
    break;
  }

  // We always consume 4 bytes of data on success
  size = 4;

  return Success;
}

static MCDisassembler *createMBlazeDisassembler(const Target &T,
                                                const MCSubtargetInfo &STI) {
  return new MBlazeDisassembler(STI);
}

extern "C" void LLVMInitializeMBlazeDisassembler() {
  // Register the disassembler.
  TargetRegistry::RegisterMCDisassembler(TheMBlazeTarget,
                                         createMBlazeDisassembler);
}