contrib/llvm-project/llvm/lib/Target/AVR/Disassembler/AVRDisassembler.cpp

   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 DecodeStatus DecodeGPR8RegisterClass(MCInst &Inst, unsigned RegNo,
  61                                             uint64_t Address, const void *Decoder) {
  62   return MCDisassembler::Success;
  63 }
  64
  65 static DecodeStatus DecodeLD8RegisterClass(MCInst &Inst, unsigned RegNo,
  66                                            uint64_t Address, const void *Decoder) {
  67   return MCDisassembler::Success;
  68 }
  69
  70 static DecodeStatus DecodePTRREGSRegisterClass(MCInst &Inst, unsigned RegNo,
  71                                                uint64_t Address, const void *Decoder) {
  72   return MCDisassembler::Success;
  73 }
  74
  75 #include "AVRGenDisassemblerTables.inc"
  76
  77 static DecodeStatus readInstruction16(ArrayRef<uint8_t> Bytes, uint64_t Address,
  78                                       uint64_t &Size, uint32_t &Insn) {
  79   if (Bytes.size() < 2) {
  80     Size = 0;
  81     return MCDisassembler::Fail;
  82   }
  83
  84   Size = 2;
  85   Insn = (Bytes[0] << 0) | (Bytes[1] << 8);
  86
  87   return MCDisassembler::Success;
  88 }
  89
  90 static DecodeStatus readInstruction32(ArrayRef<uint8_t> Bytes, uint64_t Address,
  91                                       uint64_t &Size, uint32_t &Insn) {
  92
  93   if (Bytes.size() < 4) {
  94     Size = 0;
  95     return MCDisassembler::Fail;
  96   }
  97
  98   Size = 4;
  99   Insn = (Bytes[0] << 0) | (Bytes[1] << 8) | (Bytes[2] << 16) | (Bytes[3] << 24);
 100
 101   return MCDisassembler::Success;
 102 }
 103
 104 static const uint8_t *getDecoderTable(uint64_t Size) {
 105
 106   switch (Size) {
 107     case 2: return DecoderTable16;
 108     case 4: return DecoderTable32;
 109     default: llvm_unreachable("instructions must be 16 or 32-bits");
 110   }
 111 }
 112
 113 DecodeStatus AVRDisassembler::getInstruction(MCInst &Instr, uint64_t &Size,
 114                                              ArrayRef<uint8_t> Bytes,
 115                                              uint64_t Address,
 116                                              raw_ostream &CStream) const {
 117   uint32_t Insn;
 118
 119   DecodeStatus Result;
 120
 121   // Try decode a 16-bit instruction.
 122   {
 123     Result = readInstruction16(Bytes, Address, Size, Insn);
 124
 125     if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
 126
 127     // Try to auto-decode a 16-bit instruction.
 128     Result = decodeInstruction(getDecoderTable(Size), Instr,
 129                                Insn, Address, this, STI);
 130
 131     if (Result != MCDisassembler::Fail)
 132       return Result;
 133   }
 134
 135   // Try decode a 32-bit instruction.
 136   {
 137     Result = readInstruction32(Bytes, Address, Size, Insn);
 138
 139     if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
 140
 141     Result = decodeInstruction(getDecoderTable(Size), Instr, Insn,
 142                                Address, this, STI);
 143
 144     if (Result != MCDisassembler::Fail) {
 145       return Result;
 146     }
 147
 148     return MCDisassembler::Fail;
 149   }
 150 }
 151
 152 typedef DecodeStatus (*DecodeFunc)(MCInst &MI, unsigned insn, uint64_t Address,
 153                                    const void *Decoder);
 154