1 //===-- M68kDisassembler.cpp - Disassembler for M68k ------------*- 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 M68k Disassembler.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "M68k.h"
14 #include "M68kRegisterInfo.h"
15 #include "M68kSubtarget.h"
16 #include "MCTargetDesc/M68kMCCodeEmitter.h"
17 #include "MCTargetDesc/M68kMCTargetDesc.h"
18 #include "TargetInfo/M68kTargetInfo.h"
19 
20 #include "llvm/MC/MCAsmInfo.h"
21 #include "llvm/MC/MCContext.h"
22 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
23 #include "llvm/MC/MCDecoderOps.h"
24 #include "llvm/MC/MCInst.h"
25 #include "llvm/MC/TargetRegistry.h"
26 #include "llvm/Support/Endian.h"
27 #include "llvm/Support/ErrorHandling.h"
28 
29 using namespace llvm;
30 
31 #define DEBUG_TYPE "m68k-disassembler"
32 
33 typedef MCDisassembler::DecodeStatus DecodeStatus;
34 
35 static const unsigned RegisterDecode[] = {
36     M68k::D0, M68k::D1, M68k::D2, M68k::D3, M68k::D4, M68k::D5,
37     M68k::D6, M68k::D7, M68k::A0, M68k::A1, M68k::A2, M68k::A3,
38     M68k::A4, M68k::A5, M68k::A6, M68k::SP,
39 };
40 
41 static DecodeStatus DecodeRegisterClass(MCInst &Inst, uint64_t RegNo,
42                                         uint64_t Address, const void *Decoder) {
43   if (RegNo >= 16)
44     return DecodeStatus::Fail;
45   Inst.addOperand(MCOperand::createReg(RegisterDecode[RegNo]));
46   return DecodeStatus::Success;
47 }
48 
49 static DecodeStatus DecodeDR32RegisterClass(MCInst &Inst, uint64_t RegNo,
50                                             uint64_t Address,
51                                             const void *Decoder) {
52   return DecodeRegisterClass(Inst, RegNo, Address, Decoder);
53 }
54 
55 static DecodeStatus DecodeDR16RegisterClass(MCInst &Inst, uint64_t RegNo,
56                                             uint64_t Address,
57                                             const void *Decoder) {
58   return DecodeRegisterClass(Inst, RegNo, Address, Decoder);
59 }
60 
61 static DecodeStatus DecodeDR8RegisterClass(MCInst &Inst, uint64_t RegNo,
62                                            uint64_t Address,
63                                            const void *Decoder) {
64   return DecodeRegisterClass(Inst, RegNo, Address, Decoder);
65 }
66 
67 static DecodeStatus DecodeAR32RegisterClass(MCInst &Inst, uint64_t RegNo,
68                                             uint64_t Address,
69                                             const void *Decoder) {
70   return DecodeRegisterClass(Inst, RegNo | 8ULL, Address, Decoder);
71 }
72 
73 static DecodeStatus DecodeAR16RegisterClass(MCInst &Inst, uint64_t RegNo,
74                                             uint64_t Address,
75                                             const void *Decoder) {
76   return DecodeRegisterClass(Inst, RegNo | 8ULL, Address, Decoder);
77 }
78 
79 static DecodeStatus DecodeXR32RegisterClass(MCInst &Inst, uint64_t RegNo,
80                                             uint64_t Address,
81                                             const void *Decoder) {
82   return DecodeRegisterClass(Inst, RegNo, Address, Decoder);
83 }
84 
85 static DecodeStatus DecodeXR16RegisterClass(MCInst &Inst, uint64_t RegNo,
86                                             uint64_t Address,
87                                             const void *Decoder) {
88   return DecodeRegisterClass(Inst, RegNo, Address, Decoder);
89 }
90 
91 static DecodeStatus DecodeCCRCRegisterClass(MCInst &Inst, APInt &Insn,
92                                             uint64_t Address,
93                                             const void *Decoder) {
94   llvm_unreachable("unimplemented");
95 }
96 
97 #include "M68kGenDisassemblerTable.inc"
98 
99 /// A disassembler class for M68k.
100 struct M68kDisassembler : public MCDisassembler {
101   M68kDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
102       : MCDisassembler(STI, Ctx) {}
103   virtual ~M68kDisassembler() {}
104 
105   DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
106                               ArrayRef<uint8_t> Bytes, uint64_t Address,
107                               raw_ostream &CStream) const override;
108 };
109 
110 DecodeStatus M68kDisassembler::getInstruction(MCInst &Instr, uint64_t &Size,
111                                               ArrayRef<uint8_t> Bytes,
112                                               uint64_t Address,
113                                               raw_ostream &CStream) const {
114   DecodeStatus Result;
115   auto MakeUp = [&](APInt &Insn, unsigned InstrBits) {
116     unsigned Idx = Insn.getBitWidth() >> 3;
117     unsigned RoundUp = alignTo(InstrBits, Align(16));
118     if (RoundUp > Insn.getBitWidth())
119       Insn = Insn.zext(RoundUp);
120     RoundUp = RoundUp >> 3;
121     for (; Idx < RoundUp; Idx += 2) {
122       Insn.insertBits(support::endian::read16be(&Bytes[Idx]), Idx * 8, 16);
123     }
124   };
125   APInt Insn(16, support::endian::read16be(Bytes.data()));
126   // 2 bytes of data are consumed, so set Size to 2
127   // If we don't do this, disassembler may generate result even
128   // the encoding is invalid. We need to let it fail correctly.
129   Size = 2;
130   Result = decodeInstruction(DecoderTable80, Instr, Insn, Address, this, STI,
131                              MakeUp);
132   if (Result == DecodeStatus::Success)
133     Size = InstrLenTable[Instr.getOpcode()] >> 3;
134   return Result;
135 }
136 
137 static MCDisassembler *createM68kDisassembler(const Target &T,
138                                               const MCSubtargetInfo &STI,
139                                               MCContext &Ctx) {
140   return new M68kDisassembler(STI, Ctx);
141 }
142 
143 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeM68kDisassembler() {
144   // Register the disassembler.
145   TargetRegistry::RegisterMCDisassembler(getTheM68kTarget(),
146                                          createM68kDisassembler);
147 }
148