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 
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 
72   uint8_t getInstClass(uint64_t Inst) const { return (Inst >> 56) & 0x7; };
73   uint8_t getInstSize(uint64_t Inst) const { return (Inst >> 59) & 0x3; };
74   uint8_t getInstMode(uint64_t Inst) const { return (Inst >> 61) & 0x7; };
75 };
76 
77 } // end anonymous namespace
78 
79 static MCDisassembler *createBPFDisassembler(const Target &T,
80                                              const MCSubtargetInfo &STI,
81                                              MCContext &Ctx) {
82   return new BPFDisassembler(STI, Ctx);
83 }
84 
85 
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 
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 
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 
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"
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 
161 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