lib/Target/MBlaze/MBlazeMCCodeEmitter.cpp

   1 //===-- MBlazeMCCodeEmitter.cpp - Convert MBlaze code to machine code -----===//
   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 implements the MBlazeMCCodeEmitter class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "mccodeemitter"
  15 #include "MBlaze.h"
  16 #include "MBlazeInstrInfo.h"
  17 #include "llvm/MC/MCCodeEmitter.h"
  18 #include "llvm/MC/MCExpr.h"
  19 #include "llvm/MC/MCInst.h"
  20 #include "llvm/MC/MCSymbol.h"
  21 #include "llvm/MC/MCFixup.h"
  22 #include "llvm/ADT/Statistic.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 using namespace llvm;
  25
  26 STATISTIC(MCNumEmitted, "Number of MC instructions emitted");
  27
  28 namespace {
  29 class MBlazeMCCodeEmitter : public MCCodeEmitter {
  30   MBlazeMCCodeEmitter(const MBlazeMCCodeEmitter &); // DO NOT IMPLEMENT
  31   void operator=(const MBlazeMCCodeEmitter &); // DO NOT IMPLEMENT
  32   const TargetMachine &TM;
  33   const TargetInstrInfo &TII;
  34   MCContext &Ctx;
  35
  36 public:
  37   MBlazeMCCodeEmitter(TargetMachine &tm, MCContext &ctx)
  38     : TM(tm), TII(*TM.getInstrInfo()), Ctx(ctx) {
  39   }
  40
  41   ~MBlazeMCCodeEmitter() {}
  42
  43   // getBinaryCodeForInstr - TableGen'erated function for getting the
  44   // binary encoding for an instruction.
  45   unsigned getBinaryCodeForInstr(const MCInst &MI) const;
  46
  47   /// getMachineOpValue - Return binary encoding of operand. If the machine
  48   /// operand requires relocation, record the relocation and return zero.
  49   unsigned getMachineOpValue(const MCInst &MI,const MCOperand &MO) const;
  50   unsigned getMachineOpValue(const MCInst &MI, unsigned OpIdx) const {
  51     return getMachineOpValue(MI, MI.getOperand(OpIdx));
  52   }
  53
  54   unsigned getNumFixupKinds() const {
  55     return 2;
  56   }
  57
  58   static unsigned GetMBlazeRegNum(const MCOperand &MO) {
  59     // FIXME: getMBlazeRegisterNumbering() is sufficient?
  60     assert(0 && "MBlazeMCCodeEmitter::GetMBlazeRegNum() not yet implemented.");
  61     return 0;
  62   }
  63
  64   void EmitByte(unsigned char C, unsigned &CurByte, raw_ostream &OS) const {
  65     // The MicroBlaze uses a bit reversed format so we need to reverse the
  66     // order of the bits. Taken from:
  67     // http://graphics.stanford.edu/~seander/bithacks.html
  68     C = ((C * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32;
  69
  70     OS << (char)C;
  71     ++CurByte;
  72   }
  73
  74   void EmitRawByte(unsigned char C, unsigned &CurByte, raw_ostream &OS) const {
  75     OS << (char)C;
  76     ++CurByte;
  77   }
  78
  79   void EmitConstant(uint64_t Val, unsigned Size, unsigned &CurByte,
  80                     raw_ostream &OS) const {
  81     assert(Size <= 8 && "size too big in emit constant");
  82
  83     for (unsigned i = 0; i != Size; ++i) {
  84       EmitByte(Val & 255, CurByte, OS);
  85       Val >>= 8;
  86     }
  87   }
  88
  89   void EmitIMM(const MCOperand &imm, unsigned &CurByte, raw_ostream &OS) const;
  90   void EmitIMM(const MCInst &MI, unsigned &CurByte, raw_ostream &OS) const;
  91
  92   void EmitImmediate(const MCInst &MI, unsigned opNo, bool pcrel,
  93                      unsigned &CurByte, raw_ostream &OS,
  94                      SmallVectorImpl<MCFixup> &Fixups) const;
  95
  96   void EncodeInstruction(const MCInst &MI, raw_ostream &OS,
  97                          SmallVectorImpl<MCFixup> &Fixups) const;
  98 };
  99
 100 } // end anonymous namespace
 101
 102
 103 MCCodeEmitter *llvm::createMBlazeMCCodeEmitter(const Target &,
 104                                                TargetMachine &TM,
 105                                                MCContext &Ctx) {
 106   return new MBlazeMCCodeEmitter(TM, Ctx);
 107 }
 108
 109 /// getMachineOpValue - Return binary encoding of operand. If the machine
 110 /// operand requires relocation, record the relocation and return zero.
 111 unsigned MBlazeMCCodeEmitter::getMachineOpValue(const MCInst &MI,
 112                                              const MCOperand &MO) const {
 113   if (MO.isReg())
 114     return MBlazeRegisterInfo::getRegisterNumbering(MO.getReg());
 115   else if (MO.isImm())
 116     return static_cast<unsigned>(MO.getImm());
 117   else if (MO.isExpr())
 118       return 0; // The relocation has already been recorded at this point.
 119   else {
 120 #ifndef NDEBUG
 121     errs() << MO;
 122 #endif
 123     llvm_unreachable(0);
 124   }
 125   return 0;
 126 }
 127
 128 void MBlazeMCCodeEmitter::
 129 EmitIMM(const MCOperand &imm, unsigned &CurByte, raw_ostream &OS) const {
 130   int32_t val = (int32_t)imm.getImm();
 131   if (val > 32767 || val < -32768) {
 132     EmitByte(0x0D, CurByte, OS);
 133     EmitByte(0x00, CurByte, OS);
 134     EmitRawByte((val >> 24) & 0xFF, CurByte, OS);
 135     EmitRawByte((val >> 16) & 0xFF, CurByte, OS);
 136   }
 137 }
 138
 139 void MBlazeMCCodeEmitter::
 140 EmitIMM(const MCInst &MI, unsigned &CurByte,raw_ostream &OS) const {
 141   switch (MI.getOpcode()) {
 142   default: break;
 143
 144   case MBlaze::ADDI32:
 145   case MBlaze::ORI32:
 146   case MBlaze::BRLID32:
 147     EmitByte(0x0D, CurByte, OS);
 148     EmitByte(0x00, CurByte, OS);
 149     EmitRawByte(0, CurByte, OS);
 150     EmitRawByte(0, CurByte, OS);
 151   }
 152 }
 153
 154 void MBlazeMCCodeEmitter::
 155 EmitImmediate(const MCInst &MI, unsigned opNo, bool pcrel, unsigned &CurByte,
 156               raw_ostream &OS, SmallVectorImpl<MCFixup> &Fixups) const {
 157   assert(MI.getNumOperands()>opNo && "Not enought operands for instruction");
 158
 159   MCOperand oper = MI.getOperand(opNo);
 160
 161   if (oper.isImm()) {
 162     EmitIMM(oper, CurByte, OS);
 163   } else if (oper.isExpr()) {
 164     MCFixupKind FixupKind;
 165     switch (MI.getOpcode()) {
 166     default:
 167       FixupKind = pcrel ? FK_PCRel_2 : FK_Data_2;
 168       Fixups.push_back(MCFixup::Create(0,oper.getExpr(),FixupKind));
 169       break;
 170     case MBlaze::ORI32:
 171     case MBlaze::ADDI32:
 172     case MBlaze::BRLID32:
 173       FixupKind = pcrel ? FK_PCRel_4 : FK_Data_4;
 174       Fixups.push_back(MCFixup::Create(0,oper.getExpr(),FixupKind));
 175       break;
 176     }
 177   }
 178 }
 179
 180
 181
 182 void MBlazeMCCodeEmitter::
 183 EncodeInstruction(const MCInst &MI, raw_ostream &OS,
 184                   SmallVectorImpl<MCFixup> &Fixups) const {
 185   unsigned Opcode = MI.getOpcode();
 186   const TargetInstrDesc &Desc = TII.get(Opcode);
 187   uint64_t TSFlags = Desc.TSFlags;
 188   // Keep track of the current byte being emitted.
 189   unsigned CurByte = 0;
 190
 191   // Emit an IMM instruction if the instruction we are encoding requires it
 192   EmitIMM(MI,CurByte,OS);
 193
 194   switch ((TSFlags & MBlazeII::FormMask)) {
 195   default: break;
 196   case MBlazeII::FPseudo:
 197     // Pseudo instructions don't get encoded.
 198     return;
 199   case MBlazeII::FRRI:
 200     EmitImmediate(MI, 2, false, CurByte, OS, Fixups);
 201     break;
 202   case MBlazeII::FRIR:
 203     EmitImmediate(MI, 1, false, CurByte, OS, Fixups);
 204     break;
 205   case MBlazeII::FCRI:
 206     EmitImmediate(MI, 1, true, CurByte, OS, Fixups);
 207     break;
 208   case MBlazeII::FRCI:
 209     EmitImmediate(MI, 1, true, CurByte, OS, Fixups);
 210   case MBlazeII::FCCI:
 211     EmitImmediate(MI, 0, true, CurByte, OS, Fixups);
 212     break;
 213   }
 214
 215   ++MCNumEmitted;  // Keep track of the # of mi's emitted
 216   unsigned Value = getBinaryCodeForInstr(MI);
 217   EmitConstant(Value, 4, CurByte, OS);
 218 }
 219
 220 // FIXME: These #defines shouldn't be necessary. Instead, tblgen should
 221 // be able to generate code emitter helpers for either variant, like it
 222 // does for the AsmWriter.
 223 #define MBlazeCodeEmitter MBlazeMCCodeEmitter
 224 #define MachineInstr MCInst
 225 #include "MBlazeGenCodeEmitter.inc"
 226 #undef MBlazeCodeEmitter
 227 #undef MachineInstr