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 #include "AVRGenDisassemblerTables.inc"
99 
100 static DecodeStatus readInstruction16(ArrayRef<uint8_t> Bytes, uint64_t Address,
101                                       uint64_t &Size, uint32_t &Insn) {
102   if (Bytes.size() < 2) {
103     Size = 0;
104     return MCDisassembler::Fail;
105   }
106 
107   Size = 2;
108   Insn = (Bytes[0] << 0) | (Bytes[1] << 8);
109 
110   return MCDisassembler::Success;
111 }
112 
113 static DecodeStatus readInstruction32(ArrayRef<uint8_t> Bytes, uint64_t Address,
114                                       uint64_t &Size, uint32_t &Insn) {
115 
116   if (Bytes.size() < 4) {
117     Size = 0;
118     return MCDisassembler::Fail;
119   }
120 
121   Size = 4;
122   Insn = (Bytes[0] << 0) | (Bytes[1] << 8) | (Bytes[2] << 16) | (Bytes[3] << 24);
123 
124   return MCDisassembler::Success;
125 }
126 
127 static const uint8_t *getDecoderTable(uint64_t Size) {
128 
129   switch (Size) {
130     case 2: return DecoderTable16;
131     case 4: return DecoderTable32;
132     default: llvm_unreachable("instructions must be 16 or 32-bits");
133   }
134 }
135 
136 DecodeStatus AVRDisassembler::getInstruction(MCInst &Instr, uint64_t &Size,
137                                              ArrayRef<uint8_t> Bytes,
138                                              uint64_t Address,
139                                              raw_ostream &CStream) const {
140   uint32_t Insn;
141 
142   DecodeStatus Result;
143 
144   // Try decode a 16-bit instruction.
145   {
146     Result = readInstruction16(Bytes, Address, Size, Insn);
147 
148     if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
149 
150     // Try to auto-decode a 16-bit instruction.
151     Result = decodeInstruction(getDecoderTable(Size), Instr,
152                                Insn, Address, this, STI);
153 
154     if (Result != MCDisassembler::Fail)
155       return Result;
156   }
157 
158   // Try decode a 32-bit instruction.
159   {
160     Result = readInstruction32(Bytes, Address, Size, Insn);
161 
162     if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
163 
164     Result = decodeInstruction(getDecoderTable(Size), Instr, Insn,
165                                Address, this, STI);
166 
167     if (Result != MCDisassembler::Fail) {
168       return Result;
169     }
170 
171     return MCDisassembler::Fail;
172   }
173 }
174 
175 typedef DecodeStatus (*DecodeFunc)(MCInst &MI, unsigned insn, uint64_t Address,
176                                    const void *Decoder);
177 
178