Line data Source code
1 : //===-- AVRMCCodeEmitter.cpp - Convert AVR 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 AVRMCCodeEmitter class.
11 : //
12 : //===----------------------------------------------------------------------===//
13 :
14 : #include "AVRMCCodeEmitter.h"
15 :
16 : #include "MCTargetDesc/AVRMCExpr.h"
17 : #include "MCTargetDesc/AVRMCTargetDesc.h"
18 :
19 : #include "llvm/ADT/APFloat.h"
20 : #include "llvm/ADT/SmallVector.h"
21 : #include "llvm/MC/MCContext.h"
22 : #include "llvm/MC/MCExpr.h"
23 : #include "llvm/MC/MCFixup.h"
24 : #include "llvm/MC/MCInst.h"
25 : #include "llvm/MC/MCInstrInfo.h"
26 : #include "llvm/MC/MCRegisterInfo.h"
27 : #include "llvm/MC/MCSubtargetInfo.h"
28 : #include "llvm/Support/Casting.h"
29 : #include "llvm/Support/raw_ostream.h"
30 :
31 : #define DEBUG_TYPE "mccodeemitter"
32 :
33 : #define GET_INSTRMAP_INFO
34 : #include "AVRGenInstrInfo.inc"
35 : #undef GET_INSTRMAP_INFO
36 :
37 : namespace llvm {
38 :
39 : /// Performs a post-encoding step on a `LD` or `ST` instruction.
40 : ///
41 : /// The encoding of the LD/ST family of instructions is inconsistent w.r.t
42 : /// the pointer register and the addressing mode.
43 : ///
44 : /// The permutations of the format are as followed:
45 : /// ld Rd, X `1001 000d dddd 1100`
46 : /// ld Rd, X+ `1001 000d dddd 1101`
47 : /// ld Rd, -X `1001 000d dddd 1110`
48 : ///
49 : /// ld Rd, Y `1000 000d dddd 1000`
50 : /// ld Rd, Y+ `1001 000d dddd 1001`
51 : /// ld Rd, -Y `1001 000d dddd 1010`
52 : ///
53 : /// ld Rd, Z `1000 000d dddd 0000`
54 : /// ld Rd, Z+ `1001 000d dddd 0001`
55 : /// ld Rd, -Z `1001 000d dddd 0010`
56 : /// ^
57 : /// |
58 : /// Note this one inconsistent bit - it is 1 sometimes and 0 at other times.
59 : /// There is no logical pattern. Looking at a truth table, the following
60 : /// formula can be derived to fit the pattern:
61 : //
62 : /// ```
63 : /// inconsistent_bit = is_predec OR is_postinc OR is_reg_x
64 : /// ```
65 : //
66 : /// We manually set this bit in this post encoder method.
67 : unsigned
68 36 : AVRMCCodeEmitter::loadStorePostEncoder(const MCInst &MI, unsigned EncodedValue,
69 : const MCSubtargetInfo &STI) const {
70 :
71 : assert(MI.getOperand(0).isReg() && MI.getOperand(1).isReg() &&
72 : "the load/store operands must be registers");
73 :
74 36 : unsigned Opcode = MI.getOpcode();
75 :
76 : // check whether either of the registers are the X pointer register.
77 36 : bool IsRegX = MI.getOperand(0).getReg() == AVR::R27R26 ||
78 30 : MI.getOperand(1).getReg() == AVR::R27R26;
79 :
80 36 : bool IsPredec = Opcode == AVR::LDRdPtrPd || Opcode == AVR::STPtrPdRr;
81 36 : bool IsPostinc = Opcode == AVR::LDRdPtrPi || Opcode == AVR::STPtrPiRr;
82 :
83 : // Check if we need to set the inconsistent bit
84 36 : if (IsRegX || IsPredec || IsPostinc) {
85 28 : EncodedValue |= (1 << 12);
86 : }
87 :
88 36 : return EncodedValue;
89 : }
90 :
91 : template <AVR::Fixups Fixup>
92 : unsigned
93 0 : AVRMCCodeEmitter::encodeRelCondBrTarget(const MCInst &MI, unsigned OpNo,
94 : SmallVectorImpl<MCFixup> &Fixups,
95 : const MCSubtargetInfo &STI) const {
96 : const MCOperand &MO = MI.getOperand(OpNo);
97 :
98 0 : if (MO.isExpr()) {
99 0 : Fixups.push_back(MCFixup::create(0, MO.getExpr(),
100 : MCFixupKind(Fixup), MI.getLoc()));
101 0 : return 0;
102 : }
103 :
104 : assert(MO.isImm());
105 :
106 : // Take the size of the current instruction away.
107 : // With labels, this is implicitly done.
108 0 : auto target = MO.getImm();
109 : AVR::fixups::adjustBranchTarget(target);
110 0 : return target;
111 : }
112 0 :
113 : unsigned AVRMCCodeEmitter::encodeLDSTPtrReg(const MCInst &MI, unsigned OpNo,
114 : SmallVectorImpl<MCFixup> &Fixups,
115 : const MCSubtargetInfo &STI) const {
116 : auto MO = MI.getOperand(OpNo);
117 0 :
118 0 : // The operand should be a pointer register.
119 : assert(MO.isReg());
120 0 :
121 : switch (MO.getReg()) {
122 : case AVR::R27R26: return 0x03; // X: 0b11
123 : case AVR::R29R28: return 0x02; // Y: 0b10
124 : case AVR::R31R30: return 0x00; // Z: 0b00
125 : default:
126 : llvm_unreachable("invalid pointer register");
127 0 : }
128 : }
129 0 :
130 : /// Encodes a `memri` operand.
131 0 : /// The operand is 7-bits.
132 : /// * The lower 6 bits is the immediate
133 : /// * The upper bit is the pointer register bit (Z=0,Y=1)
134 : unsigned AVRMCCodeEmitter::encodeMemri(const MCInst &MI, unsigned OpNo,
135 : SmallVectorImpl<MCFixup> &Fixups,
136 0 : const MCSubtargetInfo &STI) const {
137 0 : auto RegOp = MI.getOperand(OpNo);
138 : auto OffsetOp = MI.getOperand(OpNo + 1);
139 0 :
140 : assert(RegOp.isReg() && "Expected register operand");
141 :
142 : uint8_t RegBit = 0;
143 :
144 : switch (RegOp.getReg()) {
145 : default:
146 0 : llvm_unreachable("Expected either Y or Z register");
147 : case AVR::R31R30:
148 0 : RegBit = 0;
149 : break; // Z register
150 : case AVR::R29R28:
151 36 : RegBit = 1;
152 : break; // Y register
153 : }
154 36 :
155 : int8_t OffsetBits;
156 :
157 : if (OffsetOp.isImm()) {
158 : OffsetBits = OffsetOp.getImm();
159 : } else if (OffsetOp.isExpr()) {
160 : OffsetBits = 0;
161 : Fixups.push_back(MCFixup::create(0, OffsetOp.getExpr(),
162 : MCFixupKind(AVR::fixup_6), MI.getLoc()));
163 0 : } else {
164 0 : llvm_unreachable("invalid value for offset");
165 : }
166 :
167 : return (RegBit << 6) | OffsetBits;
168 : }
169 :
170 : unsigned AVRMCCodeEmitter::encodeComplement(const MCInst &MI, unsigned OpNo,
171 : SmallVectorImpl<MCFixup> &Fixups,
172 10 : const MCSubtargetInfo &STI) const {
173 : // The operand should be an immediate.
174 : assert(MI.getOperand(OpNo).isImm());
175 10 :
176 10 : auto Imm = MI.getOperand(OpNo).getImm();
177 : return (~0) - Imm;
178 : }
179 :
180 : template <AVR::Fixups Fixup, unsigned Offset>
181 : unsigned AVRMCCodeEmitter::encodeImm(const MCInst &MI, unsigned OpNo,
182 10 : SmallVectorImpl<MCFixup> &Fixups,
183 0 : const MCSubtargetInfo &STI) const {
184 0 : auto MO = MI.getOperand(OpNo);
185 :
186 : if (MO.isExpr()) {
187 : if (isa<AVRMCExpr>(MO.getExpr())) {
188 5 : // If the expression is already an AVRMCExpr (i.e. a lo8(symbol),
189 : // we shouldn't perform any more fixups. Without this check, we would
190 5 : // instead create a fixup to the symbol named 'lo8(symbol)' which
191 : // is not correct.
192 : return getExprOpValue(MO.getExpr(), Fixups, STI);
193 : }
194 :
195 10 : MCFixupKind FixupKind = static_cast<MCFixupKind>(Fixup);
196 8 : Fixups.push_back(MCFixup::create(Offset, MO.getExpr(), FixupKind, MI.getLoc()));
197 2 :
198 : return 0;
199 2 : }
200 2 :
201 : assert(MO.isImm());
202 0 : return MO.getImm();
203 : }
204 :
205 10 : unsigned AVRMCCodeEmitter::encodeCallTarget(const MCInst &MI, unsigned OpNo,
206 : SmallVectorImpl<MCFixup> &Fixups,
207 : const MCSubtargetInfo &STI) const {
208 4 : auto MO = MI.getOperand(OpNo);
209 :
210 : if (MO.isExpr()) {
211 : MCFixupKind FixupKind = static_cast<MCFixupKind>(AVR::fixup_call);
212 : Fixups.push_back(MCFixup::create(0, MO.getExpr(), FixupKind, MI.getLoc()));
213 : return 0;
214 4 : }
215 4 :
216 : assert(MO.isImm());
217 :
218 : auto Target = MO.getImm();
219 197 : AVR::fixups::adjustBranchTarget(Target);
220 : return Target;
221 : }
222 197 :
223 : unsigned AVRMCCodeEmitter::getExprOpValue(const MCExpr *Expr,
224 197 : SmallVectorImpl<MCFixup> &Fixups,
225 234 : const MCSubtargetInfo &STI) const {
226 :
227 : MCExpr::ExprKind Kind = Expr->getKind();
228 :
229 : if (Kind == MCExpr::Binary) {
230 91 : Expr = static_cast<const MCBinaryExpr *>(Expr)->getLHS();
231 : Kind = Expr->getKind();
232 : }
233 :
234 52 : if (Kind == MCExpr::Target) {
235 : AVRMCExpr const *AVRExpr = cast<AVRMCExpr>(Expr);
236 26 : int64_t Result;
237 : if (AVRExpr->evaluateAsConstant(Result)) {
238 : return Result;
239 : }
240 80 :
241 : MCFixupKind FixupKind = static_cast<MCFixupKind>(AVRExpr->getFixupKind());
242 10 : Fixups.push_back(MCFixup::create(0, AVRExpr, FixupKind));
243 : return 0;
244 : }
245 10 :
246 : assert(Kind == MCExpr::SymbolRef);
247 10 : return 0;
248 8 : }
249 :
250 : unsigned AVRMCCodeEmitter::getMachineOpValue(const MCInst &MI,
251 : const MCOperand &MO,
252 : SmallVectorImpl<MCFixup> &Fixups,
253 0 : const MCSubtargetInfo &STI) const {
254 : if (MO.isReg()) return Ctx.getRegisterInfo()->getEncodingValue(MO.getReg());
255 : if (MO.isImm()) return static_cast<unsigned>(MO.getImm());
256 :
257 8 : if (MO.isFPImm())
258 : return static_cast<unsigned>(APFloat(MO.getFPImm())
259 4 : .bitcastToAPInt()
260 : .getHiBits(32)
261 : .getLimitedValue());
262 :
263 6 : // MO must be an Expr.
264 : assert(MO.isExpr());
265 131 :
266 : return getExprOpValue(MO.getExpr(), Fixups, STI);
267 : }
268 131 :
269 : void AVRMCCodeEmitter::emitInstruction(uint64_t Val, unsigned Size,
270 131 : const MCSubtargetInfo &STI,
271 198 : raw_ostream &OS) const {
272 : const uint16_t *Words = reinterpret_cast<uint16_t const *>(&Val);
273 : size_t WordCount = Size / 2;
274 :
275 : for (int64_t i = WordCount - 1; i >= 0; --i) {
276 91 : uint16_t Word = Words[i];
277 :
278 : OS << (uint8_t) ((Word & 0x00ff) >> 0);
279 : OS << (uint8_t) ((Word & 0xff00) >> 8);
280 16 : }
281 : }
282 8 :
283 : void AVRMCCodeEmitter::encodeInstruction(const MCInst &MI, raw_ostream &OS,
284 : SmallVectorImpl<MCFixup> &Fixups,
285 : const MCSubtargetInfo &STI) const {
286 32 : const MCInstrDesc &Desc = MCII.get(MI.getOpcode());
287 :
288 22 : // Get byte count of instruction
289 : unsigned Size = Desc.getSize();
290 :
291 22 : assert(Size > 0 && "Instruction size cannot be zero");
292 :
293 22 : uint64_t BinaryOpCode = getBinaryCodeForInstr(MI, Fixups, STI);
294 8 : emitInstruction(BinaryOpCode, Size, STI, OS);
295 : }
296 :
297 : MCCodeEmitter *createAVRMCCodeEmitter(const MCInstrInfo &MCII,
298 : const MCRegisterInfo &MRI,
299 0 : MCContext &Ctx) {
300 : return new AVRMCCodeEmitter(MCII, Ctx);
301 : }
302 :
303 8 : #include "AVRGenMCCodeEmitter.inc"
304 :
305 4 : } // end of namespace llvm
|
