1 //===- BPFDisassembler.cpp - Disassembler for BPF ---------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file is part of the BPF Disassembler.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "BPF.h"
15 #include "BPFSubtarget.h"
16 #include "MCTargetDesc/BPFMCTargetDesc.h"
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/MC/MCAsmInfo.h"
19 #include "llvm/MC/MCContext.h"
20 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
21 #include "llvm/MC/MCFixedLenDisassembler.h"
22 #include "llvm/MC/MCInst.h"
23 #include "llvm/Support/MathExtras.h"
24 #include "llvm/Support/TargetRegistry.h"
25 #include <cstdint>
26
27 using namespace llvm;
28
29 #define DEBUG_TYPE "bpf-disassembler"
30
31 typedef MCDisassembler::DecodeStatus DecodeStatus;
32
33 namespace {
34
35 /// A disassembler class for BPF.
36 class BPFDisassembler : public MCDisassembler {
37 public:
38 enum BPF_CLASS {
39 BPF_LD = 0x0,
40 BPF_LDX = 0x1,
41 BPF_ST = 0x2,
42 BPF_STX = 0x3,
43 BPF_ALU = 0x4,
44 BPF_JMP = 0x5,
45 BPF_RES = 0x6,
46 BPF_ALU64 = 0x7
47 };
48
49 enum BPF_SIZE {
50 BPF_W = 0x0,
51 BPF_H = 0x1,
52 BPF_B = 0x2,
53 BPF_DW = 0x3
54 };
55
56 enum BPF_MODE {
57 BPF_IMM = 0x0,
58 BPF_ABS = 0x1,
59 BPF_IND = 0x2,
60 BPF_MEM = 0x3,
61 BPF_LEN = 0x4,
62 BPF_MSH = 0x5,
63 BPF_XADD = 0x6
64 };
65
BPFDisassembler(const MCSubtargetInfo & STI,MCContext & Ctx)66 BPFDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
67 : MCDisassembler(STI, Ctx) {}
68 ~BPFDisassembler() override = default;
69
70 DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
71 ArrayRef<uint8_t> Bytes, uint64_t Address,
72 raw_ostream &VStream,
73 raw_ostream &CStream) const override;
74
getInstClass(uint64_t Inst) const75 uint8_t getInstClass(uint64_t Inst) const { return (Inst >> 56) & 0x7; };
getInstSize(uint64_t Inst) const76 uint8_t getInstSize(uint64_t Inst) const { return (Inst >> 59) & 0x3; };
getInstMode(uint64_t Inst) const77 uint8_t getInstMode(uint64_t Inst) const { return (Inst >> 61) & 0x7; };
78 };
79
80 } // end anonymous namespace
81
createBPFDisassembler(const Target & T,const MCSubtargetInfo & STI,MCContext & Ctx)82 static MCDisassembler *createBPFDisassembler(const Target &T,
83 const MCSubtargetInfo &STI,
84 MCContext &Ctx) {
85 return new BPFDisassembler(STI, Ctx);
86 }
87
88
LLVMInitializeBPFDisassembler()89 extern "C" void LLVMInitializeBPFDisassembler() {
90 // Register the disassembler.
91 TargetRegistry::RegisterMCDisassembler(getTheBPFTarget(),
92 createBPFDisassembler);
93 TargetRegistry::RegisterMCDisassembler(getTheBPFleTarget(),
94 createBPFDisassembler);
95 TargetRegistry::RegisterMCDisassembler(getTheBPFbeTarget(),
96 createBPFDisassembler);
97 }
98
99 static const unsigned GPRDecoderTable[] = {
100 BPF::R0, BPF::R1, BPF::R2, BPF::R3, BPF::R4, BPF::R5,
101 BPF::R6, BPF::R7, BPF::R8, BPF::R9, BPF::R10, BPF::R11};
102
DecodeGPRRegisterClass(MCInst & Inst,unsigned RegNo,uint64_t,const void *)103 static DecodeStatus DecodeGPRRegisterClass(MCInst &Inst, unsigned RegNo,
104 uint64_t /*Address*/,
105 const void * /*Decoder*/) {
106 if (RegNo > 11)
107 return MCDisassembler::Fail;
108
109 unsigned Reg = GPRDecoderTable[RegNo];
110 Inst.addOperand(MCOperand::createReg(Reg));
111 return MCDisassembler::Success;
112 }
113
114 static const unsigned GPR32DecoderTable[] = {
115 BPF::W0, BPF::W1, BPF::W2, BPF::W3, BPF::W4, BPF::W5,
116 BPF::W6, BPF::W7, BPF::W8, BPF::W9, BPF::W10, BPF::W11};
117
DecodeGPR32RegisterClass(MCInst & Inst,unsigned RegNo,uint64_t,const void *)118 static DecodeStatus DecodeGPR32RegisterClass(MCInst &Inst, unsigned RegNo,
119 uint64_t /*Address*/,
120 const void * /*Decoder*/) {
121 if (RegNo > 11)
122 return MCDisassembler::Fail;
123
124 unsigned Reg = GPR32DecoderTable[RegNo];
125 Inst.addOperand(MCOperand::createReg(Reg));
126 return MCDisassembler::Success;
127 }
128
decodeMemoryOpValue(MCInst & Inst,unsigned Insn,uint64_t Address,const void * Decoder)129 static DecodeStatus decodeMemoryOpValue(MCInst &Inst, unsigned Insn,
130 uint64_t Address, const void *Decoder) {
131 unsigned Register = (Insn >> 16) & 0xf;
132 Inst.addOperand(MCOperand::createReg(GPRDecoderTable[Register]));
133 unsigned Offset = (Insn & 0xffff);
134 Inst.addOperand(MCOperand::createImm(SignExtend32<16>(Offset)));
135
136 return MCDisassembler::Success;
137 }
138
139 #include "BPFGenDisassemblerTables.inc"
readInstruction64(ArrayRef<uint8_t> Bytes,uint64_t Address,uint64_t & Size,uint64_t & Insn,bool IsLittleEndian)140 static DecodeStatus readInstruction64(ArrayRef<uint8_t> Bytes, uint64_t Address,
141 uint64_t &Size, uint64_t &Insn,
142 bool IsLittleEndian) {
143 uint64_t Lo, Hi;
144
145 if (Bytes.size() < 8) {
146 Size = 0;
147 return MCDisassembler::Fail;
148 }
149
150 Size = 8;
151 if (IsLittleEndian) {
152 Hi = (Bytes[0] << 24) | (Bytes[1] << 16) | (Bytes[2] << 0) | (Bytes[3] << 8);
153 Lo = (Bytes[4] << 0) | (Bytes[5] << 8) | (Bytes[6] << 16) | (Bytes[7] << 24);
154 } else {
155 Hi = (Bytes[0] << 24) | ((Bytes[1] & 0x0F) << 20) | ((Bytes[1] & 0xF0) << 12) |
156 (Bytes[2] << 8) | (Bytes[3] << 0);
157 Lo = (Bytes[4] << 24) | (Bytes[5] << 16) | (Bytes[6] << 8) | (Bytes[7] << 0);
158 }
159 Insn = Make_64(Hi, Lo);
160
161 return MCDisassembler::Success;
162 }
163
getInstruction(MCInst & Instr,uint64_t & Size,ArrayRef<uint8_t> Bytes,uint64_t Address,raw_ostream & VStream,raw_ostream & CStream) const164 DecodeStatus BPFDisassembler::getInstruction(MCInst &Instr, uint64_t &Size,
165 ArrayRef<uint8_t> Bytes,
166 uint64_t Address,
167 raw_ostream &VStream,
168 raw_ostream &CStream) const {
169 bool IsLittleEndian = getContext().getAsmInfo()->isLittleEndian();
170 uint64_t Insn, Hi;
171 DecodeStatus Result;
172
173 Result = readInstruction64(Bytes, Address, Size, Insn, IsLittleEndian);
174 if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
175
176 uint8_t InstClass = getInstClass(Insn);
177 if ((InstClass == BPF_LDX || InstClass == BPF_STX) &&
178 getInstSize(Insn) != BPF_DW &&
179 getInstMode(Insn) == BPF_MEM &&
180 STI.getFeatureBits()[BPF::ALU32])
181 Result = decodeInstruction(DecoderTableBPFALU3264, Instr, Insn, Address,
182 this, STI);
183 else
184 Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address, this,
185 STI);
186
187 if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
188
189 switch (Instr.getOpcode()) {
190 case BPF::LD_imm64:
191 case BPF::LD_pseudo: {
192 if (Bytes.size() < 16) {
193 Size = 0;
194 return MCDisassembler::Fail;
195 }
196 Size = 16;
197 if (IsLittleEndian)
198 Hi = (Bytes[12] << 0) | (Bytes[13] << 8) | (Bytes[14] << 16) | (Bytes[15] << 24);
199 else
200 Hi = (Bytes[12] << 24) | (Bytes[13] << 16) | (Bytes[14] << 8) | (Bytes[15] << 0);
201 auto& Op = Instr.getOperand(1);
202 Op.setImm(Make_64(Hi, Op.getImm()));
203 break;
204 }
205 case BPF::LD_ABS_B:
206 case BPF::LD_ABS_H:
207 case BPF::LD_ABS_W:
208 case BPF::LD_IND_B:
209 case BPF::LD_IND_H:
210 case BPF::LD_IND_W: {
211 auto Op = Instr.getOperand(0);
212 Instr.clear();
213 Instr.addOperand(MCOperand::createReg(BPF::R6));
214 Instr.addOperand(Op);
215 break;
216 }
217 }
218
219 return Result;
220 }
221
222 typedef DecodeStatus (*DecodeFunc)(MCInst &MI, unsigned insn, uint64_t Address,
223 const void *Decoder);
224