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