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