LLVM  15.0.0git
BPFDisassembler.cpp
Go to the documentation of this file.
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 
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/MC/MCAsmInfo.h"
17 #include "llvm/MC/MCContext.h"
18 #include "llvm/MC/MCDecoderOps.h"
20 #include "llvm/MC/MCInst.h"
22 #include "llvm/MC/TargetRegistry.h"
24 #include <cstdint>
25 
26 using namespace llvm;
27 
28 #define DEBUG_TYPE "bpf-disassembler"
29 
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 
81  const MCSubtargetInfo &STI,
82  MCContext &Ctx) {
83  return new BPFDisassembler(STI, Ctx);
84 }
85 
86 
88  // Register the disassembler.
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];
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];
125 }
126 
128  uint64_t Address,
129  const MCDisassembler *Decoder) {
130  unsigned Register = (Insn >> 16) & 0xf;
131  if (Register > 11)
132  return MCDisassembler::Fail;
133 
135  unsigned Offset = (Insn & 0xffff);
136  Inst.addOperand(MCOperand::createImm(SignExtend32<16>(Offset)));
137 
139 }
140 
141 #include "BPFGenDisassemblerTables.inc"
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 
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;
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();
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);
llvm::Check::Size
@ Size
Definition: FileCheck.h:76
BPFMCTargetDesc.h
llvm::getTheBPFleTarget
Target & getTheBPFleTarget()
Definition: BPFTargetInfo.cpp:14
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:104
MathExtras.h
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
MCDisassembler.h
llvm::MCOperand::createImm
static MCOperand createImm(int64_t Val)
Definition: MCInst.h:141
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:74
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:140
llvm::X86Disassembler::Reg
Reg
All possible values of the reg field in the ModR/M byte.
Definition: X86DisassemblerDecoder.h:462
R4
#define R4(n)
llvm::TargetRegistry::RegisterMCDisassembler
static void RegisterMCDisassembler(Target &T, Target::MCDisassemblerCtorTy Fn)
RegisterMCDisassembler - Register a MCDisassembler implementation for the given target.
Definition: TargetRegistry.h:933
DecodeStatus
MCDisassembler::DecodeStatus DecodeStatus
Definition: BPFDisassembler.cpp:30
llvm::MCInst
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
MCDecoderOps.h
BPFTargetInfo.h
DecodeFunc
DecodeStatus(* DecodeFunc)(MCInst &MI, unsigned insn, uint64_t Address, const MCDisassembler *Decoder)
Definition: BPFDisassembler.cpp:224
llvm::MipsISD::Hi
@ Hi
Definition: MipsISelLowering.h:75
decodeMemoryOpValue
static DecodeStatus decodeMemoryOpValue(MCInst &Inst, unsigned Insn, uint64_t Address, const MCDisassembler *Decoder)
Definition: BPFDisassembler.cpp:127
R2
#define R2(n)
SubtargetFeature.h
readInstruction64
static DecodeStatus readInstruction64(ArrayRef< uint8_t > Bytes, uint64_t Address, uint64_t &Size, uint64_t &Insn, bool IsLittleEndian)
Definition: BPFDisassembler.cpp:142
MCContext.h
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
llvm::MCDisassembler::Success
@ Success
Definition: MCDisassembler.h:112
MCInst.h
GPR32DecoderTable
static const unsigned GPR32DecoderTable[]
Definition: BPFDisassembler.cpp:112
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
llvm::MCDisassembler::DecodeStatus
DecodeStatus
Ternary decode status.
Definition: MCDisassembler.h:109
llvm::MCInst::addOperand
void addOperand(const MCOperand Op)
Definition: MCInst.h:210
GPRDecoderTable
static const unsigned GPRDecoderTable[]
Definition: BPFDisassembler.cpp:97
llvm::Make_64
constexpr uint64_t Make_64(uint32_t High, uint32_t Low)
Make a 64-bit integer from a high / low pair of 32-bit integers.
Definition: MathExtras.h:358
uint64_t
LLVM_EXTERNAL_VISIBILITY
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:126
llvm::MCDisassembler
Superclass for all disassemblers.
Definition: MCDisassembler.h:85
DecodeGPR32RegisterClass
static DecodeStatus DecodeGPR32RegisterClass(MCInst &Inst, unsigned RegNo, uint64_t, const MCDisassembler *)
Definition: BPFDisassembler.cpp:117
ArrayRef.h
llvm::getTheBPFbeTarget
Target & getTheBPFbeTarget()
Definition: BPFTargetInfo.cpp:18
LLVMInitializeBPFDisassembler
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeBPFDisassembler()
Definition: BPFDisassembler.cpp:87
R6
#define R6(n)
DecodeGPRRegisterClass
static DecodeStatus DecodeGPRRegisterClass(MCInst &Inst, unsigned RegNo, uint64_t, const MCDisassembler *)
Definition: BPFDisassembler.cpp:101
llvm::ArrayRef< uint8_t >
MCAsmInfo.h
llvm::MCOperand::createReg
static MCOperand createReg(unsigned Reg)
Definition: MCInst.h:134
llvm::MCDisassembler::Fail
@ Fail
Definition: MCDisassembler.h:110
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
Insn
SmallVector< AArch64_IMM::ImmInsnModel, 4 > Insn
Definition: AArch64MIPeepholeOpt.cpp:132
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:326
llvm::MCInst::getOpcode
unsigned getOpcode() const
Definition: MCInst.h:198
llvm::getTheBPFTarget
Target & getTheBPFTarget()
Definition: BPFTargetInfo.cpp:22
llvm::MCInst::getOperand
const MCOperand & getOperand(unsigned i) const
Definition: MCInst.h:206
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:164
TargetRegistry.h
llvm::MCSubtargetInfo
Generic base class for all target subtargets.
Definition: MCSubtargetInfo.h:76
llvm::MCInst::clear
void clear()
Definition: MCInst.h:215
createBPFDisassembler
static MCDisassembler * createBPFDisassembler(const Target &T, const MCSubtargetInfo &STI, MCContext &Ctx)
Definition: BPFDisassembler.cpp:80