1 //===- AVRDisassembler.cpp - Disassembler for AVR ---------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file is part of the AVR Disassembler.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "AVR.h"
14 #include "AVRRegisterInfo.h"
15 #include "AVRSubtarget.h"
16 #include "MCTargetDesc/AVRMCTargetDesc.h"
17 #include "TargetInfo/AVRTargetInfo.h"
18 
19 #include "llvm/MC/MCAsmInfo.h"
20 #include "llvm/MC/MCContext.h"
21 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
22 #include "llvm/MC/MCFixedLenDisassembler.h"
23 #include "llvm/MC/MCInst.h"
24 #include "llvm/Support/TargetRegistry.h"
25 
26 using namespace llvm;
27 
28 #define DEBUG_TYPE "avr-disassembler"
29 
30 typedef MCDisassembler::DecodeStatus DecodeStatus;
31 
32 namespace {
33 
34 /// A disassembler class for AVR.
35 class AVRDisassembler : public MCDisassembler {
36 public:
37   AVRDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
38       : MCDisassembler(STI, Ctx) {}
39   virtual ~AVRDisassembler() {}
40 
41   DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
42                               ArrayRef<uint8_t> Bytes, uint64_t Address,
43                               raw_ostream &CStream) const override;
44 };
45 }
46 
47 static MCDisassembler *createAVRDisassembler(const Target &T,
48                                              const MCSubtargetInfo &STI,
49                                              MCContext &Ctx) {
50   return new AVRDisassembler(STI, Ctx);
51 }
52 
53 
54 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeAVRDisassembler() {
55   // Register the disassembler.
56   TargetRegistry::RegisterMCDisassembler(getTheAVRTarget(),
57                                          createAVRDisassembler);
58 }
59 
60 static const uint16_t GPRDecoderTable[] = {
61   AVR::R0, AVR::R1, AVR::R2, AVR::R3,
62   AVR::R4, AVR::R5, AVR::R6, AVR::R7,
63   AVR::R8, AVR::R9, AVR::R10, AVR::R11,
64   AVR::R12, AVR::R13, AVR::R14, AVR::R15,
65   AVR::R16, AVR::R17, AVR::R18, AVR::R19,
66   AVR::R20, AVR::R21, AVR::R22, AVR::R23,
67   AVR::R24, AVR::R25, AVR::R26, AVR::R27,
68   AVR::R28, AVR::R29, AVR::R30, AVR::R31,
69 };
70 
71 static DecodeStatus DecodeGPR8RegisterClass(MCInst &Inst, unsigned RegNo,
72                                             uint64_t Address, const void *Decoder) {
73   if (RegNo > 31)
74     return MCDisassembler::Fail;
75 
76   unsigned Register = GPRDecoderTable[RegNo];
77   Inst.addOperand(MCOperand::createReg(Register));
78   return MCDisassembler::Success;
79 }
80 
81 static DecodeStatus DecodeLD8RegisterClass(MCInst &Inst, unsigned RegNo,
82                                            uint64_t Address, const void *Decoder) {
83   if (RegNo > 15)
84     return MCDisassembler::Fail;
85 
86   unsigned Register = GPRDecoderTable[RegNo+16];
87   Inst.addOperand(MCOperand::createReg(Register));
88   return MCDisassembler::Success;
89 }
90 
91 static DecodeStatus DecodePTRREGSRegisterClass(MCInst &Inst, unsigned RegNo,
92                                                uint64_t Address, const void *Decoder) {
93   // Note: this function must be defined but does not seem to be called.
94   assert(false && "unimplemented: PTRREGS register class");
95   return MCDisassembler::Success;
96 }
97 
98 static DecodeStatus decodeFIOARr(MCInst &Inst, unsigned Insn,
99                                  uint64_t Address, const void *Decoder);
100 
101 static DecodeStatus decodeFIORdA(MCInst &Inst, unsigned Insn,
102                                  uint64_t Address, const void *Decoder);
103 
104 static DecodeStatus decodeFIOBIT(MCInst &Inst, unsigned Insn,
105                                  uint64_t Address, const void *Decoder);
106 
107 static DecodeStatus decodeCallTarget(MCInst &Inst, unsigned Insn,
108                                      uint64_t Address, const void *Decoder);
109 
110 static DecodeStatus decodeFRd(MCInst &Inst, unsigned Insn,
111                               uint64_t Address, const void *Decoder);
112 
113 static DecodeStatus decodeFLPMX(MCInst &Inst, unsigned Insn,
114                                 uint64_t Address, const void *Decoder);
115 
116 static DecodeStatus decodeFFMULRdRr(MCInst &Inst, unsigned Insn,
117                                     uint64_t Address, const void *Decoder);
118 
119 static DecodeStatus decodeFMOVWRdRr(MCInst &Inst, unsigned Insn,
120                                     uint64_t Address, const void *Decoder);
121 
122 static DecodeStatus decodeFWRdK(MCInst &Inst, unsigned Insn,
123                                 uint64_t Address, const void *Decoder);
124 
125 static DecodeStatus decodeFMUL2RdRr(MCInst &Inst, unsigned Insn,
126                                     uint64_t Address, const void *Decoder);
127 
128 #include "AVRGenDisassemblerTables.inc"
129 
130 static DecodeStatus decodeFIOARr(MCInst &Inst, unsigned Insn,
131                                  uint64_t Address, const void *Decoder) {
132   unsigned addr = 0;
133   addr |= fieldFromInstruction(Insn, 0, 4);
134   addr |= fieldFromInstruction(Insn, 9, 2) << 4;
135   unsigned reg = fieldFromInstruction(Insn, 4, 5);
136   Inst.addOperand(MCOperand::createImm(addr));
137   if (DecodeGPR8RegisterClass(Inst, reg, Address, Decoder) == MCDisassembler::Fail)
138     return MCDisassembler::Fail;
139   return MCDisassembler::Success;
140 }
141 
142 static DecodeStatus decodeFIORdA(MCInst &Inst, unsigned Insn,
143                                  uint64_t Address, const void *Decoder) {
144   unsigned addr = 0;
145   addr |= fieldFromInstruction(Insn, 0, 4);
146   addr |= fieldFromInstruction(Insn, 9, 2) << 4;
147   unsigned reg = fieldFromInstruction(Insn, 4, 5);
148   if (DecodeGPR8RegisterClass(Inst, reg, Address, Decoder) == MCDisassembler::Fail)
149     return MCDisassembler::Fail;
150   Inst.addOperand(MCOperand::createImm(addr));
151   return MCDisassembler::Success;
152 }
153 
154 static DecodeStatus decodeFIOBIT(MCInst &Inst, unsigned Insn,
155                                  uint64_t Address, const void *Decoder) {
156   unsigned addr = fieldFromInstruction(Insn, 3, 5);
157   unsigned b = fieldFromInstruction(Insn, 0, 3);
158   Inst.addOperand(MCOperand::createImm(addr));
159   Inst.addOperand(MCOperand::createImm(b));
160   return MCDisassembler::Success;
161 }
162 
163 static DecodeStatus decodeCallTarget(MCInst &Inst, unsigned Field,
164                                      uint64_t Address, const void *Decoder) {
165   // Call targets need to be shifted left by one so this needs a custom
166   // decoder.
167   Inst.addOperand(MCOperand::createImm(Field << 1));
168   return MCDisassembler::Success;
169 }
170 
171 static DecodeStatus decodeFRd(MCInst &Inst, unsigned Insn,
172                               uint64_t Address, const void *Decoder) {
173   unsigned d = fieldFromInstruction(Insn, 4, 5);
174   if (DecodeGPR8RegisterClass(Inst, d, Address, Decoder) == MCDisassembler::Fail)
175     return MCDisassembler::Fail;
176   return MCDisassembler::Success;
177 }
178 
179 static DecodeStatus decodeFLPMX(MCInst &Inst, unsigned Insn,
180                                 uint64_t Address, const void *Decoder) {
181   if (decodeFRd(Inst, Insn, Address, Decoder) == MCDisassembler::Fail)
182     return MCDisassembler::Fail;
183   Inst.addOperand(MCOperand::createReg(AVR::R31R30));
184   return MCDisassembler::Success;
185 }
186 
187 static DecodeStatus decodeFFMULRdRr(MCInst &Inst, unsigned Insn,
188                                     uint64_t Address, const void *Decoder) {
189   unsigned d = fieldFromInstruction(Insn, 4, 3) + 16;
190   unsigned r = fieldFromInstruction(Insn, 0, 3) + 16;
191   if (DecodeGPR8RegisterClass(Inst, d, Address, Decoder) == MCDisassembler::Fail)
192     return MCDisassembler::Fail;
193   if (DecodeGPR8RegisterClass(Inst, r, Address, Decoder) == MCDisassembler::Fail)
194     return MCDisassembler::Fail;
195   return MCDisassembler::Success;
196 }
197 
198 static DecodeStatus decodeFMOVWRdRr(MCInst &Inst, unsigned Insn,
199                                     uint64_t Address, const void *Decoder) {
200   unsigned r = fieldFromInstruction(Insn, 4, 4) * 2;
201   unsigned d = fieldFromInstruction(Insn, 0, 4) * 2;
202   if (DecodeGPR8RegisterClass(Inst, r, Address, Decoder) == MCDisassembler::Fail)
203     return MCDisassembler::Fail;
204   if (DecodeGPR8RegisterClass(Inst, d, Address, Decoder) == MCDisassembler::Fail)
205     return MCDisassembler::Fail;
206   return MCDisassembler::Success;
207 }
208 
209 static DecodeStatus decodeFWRdK(MCInst &Inst, unsigned Insn,
210                                     uint64_t Address, const void *Decoder) {
211   unsigned d = fieldFromInstruction(Insn, 4, 2) * 2 + 24; // starts at r24:r25
212   unsigned k = 0;
213   k |= fieldFromInstruction(Insn, 0, 4);
214   k |= fieldFromInstruction(Insn, 6, 2) << 4;
215   if (DecodeGPR8RegisterClass(Inst, d, Address, Decoder) == MCDisassembler::Fail)
216     return MCDisassembler::Fail;
217   if (DecodeGPR8RegisterClass(Inst, d, Address, Decoder) == MCDisassembler::Fail)
218     return MCDisassembler::Fail;
219   Inst.addOperand(MCOperand::createImm(k));
220   return MCDisassembler::Success;
221 }
222 
223 static DecodeStatus decodeFMUL2RdRr(MCInst &Inst, unsigned Insn,
224                                     uint64_t Address, const void *Decoder) {
225   unsigned rd = fieldFromInstruction(Insn, 4, 4) + 16;
226   unsigned rr = fieldFromInstruction(Insn, 0, 4) + 16;
227   if (DecodeGPR8RegisterClass(Inst, rd, Address, Decoder) == MCDisassembler::Fail)
228     return MCDisassembler::Fail;
229   if (DecodeGPR8RegisterClass(Inst, rr, Address, Decoder) == MCDisassembler::Fail)
230     return MCDisassembler::Fail;
231   return MCDisassembler::Success;
232 }
233 
234 static DecodeStatus readInstruction16(ArrayRef<uint8_t> Bytes, uint64_t Address,
235                                       uint64_t &Size, uint32_t &Insn) {
236   if (Bytes.size() < 2) {
237     Size = 0;
238     return MCDisassembler::Fail;
239   }
240 
241   Size = 2;
242   Insn = (Bytes[0] << 0) | (Bytes[1] << 8);
243 
244   return MCDisassembler::Success;
245 }
246 
247 static DecodeStatus readInstruction32(ArrayRef<uint8_t> Bytes, uint64_t Address,
248                                       uint64_t &Size, uint32_t &Insn) {
249 
250   if (Bytes.size() < 4) {
251     Size = 0;
252     return MCDisassembler::Fail;
253   }
254 
255   Size = 4;
256   Insn = (Bytes[0] << 16) | (Bytes[1] << 24) | (Bytes[2] << 0) | (Bytes[3] << 8);
257 
258   return MCDisassembler::Success;
259 }
260 
261 static const uint8_t *getDecoderTable(uint64_t Size) {
262 
263   switch (Size) {
264     case 2: return DecoderTable16;
265     case 4: return DecoderTable32;
266     default: llvm_unreachable("instructions must be 16 or 32-bits");
267   }
268 }
269 
270 DecodeStatus AVRDisassembler::getInstruction(MCInst &Instr, uint64_t &Size,
271                                              ArrayRef<uint8_t> Bytes,
272                                              uint64_t Address,
273                                              raw_ostream &CStream) const {
274   uint32_t Insn;
275 
276   DecodeStatus Result;
277 
278   // Try decode a 16-bit instruction.
279   {
280     Result = readInstruction16(Bytes, Address, Size, Insn);
281 
282     if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
283 
284     // Try to auto-decode a 16-bit instruction.
285     Result = decodeInstruction(getDecoderTable(Size), Instr,
286                                Insn, Address, this, STI);
287 
288     if (Result != MCDisassembler::Fail)
289       return Result;
290   }
291 
292   // Try decode a 32-bit instruction.
293   {
294     Result = readInstruction32(Bytes, Address, Size, Insn);
295 
296     if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
297 
298     Result = decodeInstruction(getDecoderTable(Size), Instr, Insn,
299                                Address, this, STI);
300 
301     if (Result != MCDisassembler::Fail) {
302       return Result;
303     }
304 
305     return MCDisassembler::Fail;
306   }
307 }
308 
309 typedef DecodeStatus (*DecodeFunc)(MCInst &MI, unsigned insn, uint64_t Address,
310                                    const void *Decoder);
311 
312