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