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 decodeFFMULRdRr(MCInst &Inst, unsigned Insn,
114                                     uint64_t Address, const void *Decoder);
115 
116 static DecodeStatus decodeFMUL2RdRr(MCInst &Inst, unsigned Insn,
117                                     uint64_t Address, const void *Decoder);
118 
119 #include "AVRGenDisassemblerTables.inc"
120 
121 static DecodeStatus decodeFIOARr(MCInst &Inst, unsigned Insn,
122                                  uint64_t Address, const void *Decoder) {
123   unsigned addr = 0;
124   addr |= fieldFromInstruction(Insn, 0, 4);
125   addr |= fieldFromInstruction(Insn, 9, 2) << 4;
126   unsigned reg = fieldFromInstruction(Insn, 4, 5);
127   Inst.addOperand(MCOperand::createImm(addr));
128   if (DecodeGPR8RegisterClass(Inst, reg, Address, Decoder) == MCDisassembler::Fail)
129     return MCDisassembler::Fail;
130   return MCDisassembler::Success;
131 }
132 
133 static DecodeStatus decodeFIORdA(MCInst &Inst, unsigned Insn,
134                                  uint64_t Address, const void *Decoder) {
135   unsigned addr = 0;
136   addr |= fieldFromInstruction(Insn, 0, 4);
137   addr |= fieldFromInstruction(Insn, 9, 2) << 4;
138   unsigned reg = fieldFromInstruction(Insn, 4, 5);
139   if (DecodeGPR8RegisterClass(Inst, reg, Address, Decoder) == MCDisassembler::Fail)
140     return MCDisassembler::Fail;
141   Inst.addOperand(MCOperand::createImm(addr));
142   return MCDisassembler::Success;
143 }
144 
145 static DecodeStatus decodeFIOBIT(MCInst &Inst, unsigned Insn,
146                                  uint64_t Address, const void *Decoder) {
147   unsigned addr = fieldFromInstruction(Insn, 3, 5);
148   unsigned b = fieldFromInstruction(Insn, 0, 3);
149   Inst.addOperand(MCOperand::createImm(addr));
150   Inst.addOperand(MCOperand::createImm(b));
151   return MCDisassembler::Success;
152 }
153 
154 static DecodeStatus decodeCallTarget(MCInst &Inst, unsigned Field,
155                                      uint64_t Address, const void *Decoder) {
156   // Call targets need to be shifted left by one so this needs a custom
157   // decoder.
158   Inst.addOperand(MCOperand::createImm(Field << 1));
159   return MCDisassembler::Success;
160 }
161 
162 static DecodeStatus decodeFRd(MCInst &Inst, unsigned Insn,
163                               uint64_t Address, const void *Decoder) {
164   unsigned d = fieldFromInstruction(Insn, 4, 5);
165   if (DecodeGPR8RegisterClass(Inst, d, Address, Decoder) == MCDisassembler::Fail)
166     return MCDisassembler::Fail;
167   return MCDisassembler::Success;
168 }
169 
170 static DecodeStatus decodeFFMULRdRr(MCInst &Inst, unsigned Insn,
171                                     uint64_t Address, const void *Decoder) {
172   unsigned d = fieldFromInstruction(Insn, 4, 3) + 16;
173   unsigned r = fieldFromInstruction(Insn, 0, 3) + 16;
174   if (DecodeGPR8RegisterClass(Inst, d, Address, Decoder) == MCDisassembler::Fail)
175     return MCDisassembler::Fail;
176   if (DecodeGPR8RegisterClass(Inst, r, Address, Decoder) == MCDisassembler::Fail)
177     return MCDisassembler::Fail;
178   return MCDisassembler::Success;
179 }
180 
181 static DecodeStatus decodeFMUL2RdRr(MCInst &Inst, unsigned Insn,
182                                     uint64_t Address, const void *Decoder) {
183   unsigned rd = fieldFromInstruction(Insn, 4, 4) + 16;
184   unsigned rr = fieldFromInstruction(Insn, 0, 4) + 16;
185   if (DecodeGPR8RegisterClass(Inst, rd, Address, Decoder) == MCDisassembler::Fail)
186     return MCDisassembler::Fail;
187   if (DecodeGPR8RegisterClass(Inst, rr, Address, Decoder) == MCDisassembler::Fail)
188     return MCDisassembler::Fail;
189   return MCDisassembler::Success;
190 }
191 
192 static DecodeStatus readInstruction16(ArrayRef<uint8_t> Bytes, uint64_t Address,
193                                       uint64_t &Size, uint32_t &Insn) {
194   if (Bytes.size() < 2) {
195     Size = 0;
196     return MCDisassembler::Fail;
197   }
198 
199   Size = 2;
200   Insn = (Bytes[0] << 0) | (Bytes[1] << 8);
201 
202   return MCDisassembler::Success;
203 }
204 
205 static DecodeStatus readInstruction32(ArrayRef<uint8_t> Bytes, uint64_t Address,
206                                       uint64_t &Size, uint32_t &Insn) {
207 
208   if (Bytes.size() < 4) {
209     Size = 0;
210     return MCDisassembler::Fail;
211   }
212 
213   Size = 4;
214   Insn = (Bytes[0] << 16) | (Bytes[1] << 24) | (Bytes[2] << 0) | (Bytes[3] << 8);
215 
216   return MCDisassembler::Success;
217 }
218 
219 static const uint8_t *getDecoderTable(uint64_t Size) {
220 
221   switch (Size) {
222     case 2: return DecoderTable16;
223     case 4: return DecoderTable32;
224     default: llvm_unreachable("instructions must be 16 or 32-bits");
225   }
226 }
227 
228 DecodeStatus AVRDisassembler::getInstruction(MCInst &Instr, uint64_t &Size,
229                                              ArrayRef<uint8_t> Bytes,
230                                              uint64_t Address,
231                                              raw_ostream &CStream) const {
232   uint32_t Insn;
233 
234   DecodeStatus Result;
235 
236   // Try decode a 16-bit instruction.
237   {
238     Result = readInstruction16(Bytes, Address, Size, Insn);
239 
240     if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
241 
242     // Try to auto-decode a 16-bit instruction.
243     Result = decodeInstruction(getDecoderTable(Size), Instr,
244                                Insn, Address, this, STI);
245 
246     if (Result != MCDisassembler::Fail)
247       return Result;
248   }
249 
250   // Try decode a 32-bit instruction.
251   {
252     Result = readInstruction32(Bytes, Address, Size, Insn);
253 
254     if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
255 
256     Result = decodeInstruction(getDecoderTable(Size), Instr, Insn,
257                                Address, this, STI);
258 
259     if (Result != MCDisassembler::Fail) {
260       return Result;
261     }
262 
263     return MCDisassembler::Fail;
264   }
265 }
266 
267 typedef DecodeStatus (*DecodeFunc)(MCInst &MI, unsigned insn, uint64_t Address,
268                                    const void *Decoder);
269 
270