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