LLVM  8.0.0svn
BPFDisassembler.cpp
Go to the documentation of this file.
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 
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/MC/MCAsmInfo.h"
17 #include "llvm/MC/MCContext.h"
20 #include "llvm/MC/MCInst.h"
23 #include <cstdint>
24 
25 using namespace llvm;
26 
27 #define DEBUG_TYPE "bpf-disassembler"
28 
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_RES = 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 &VStream,
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 
87 extern "C" void LLVMInitializeBPFDisassembler() {
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 void * /*Decoder*/) {
104  if (RegNo > 11)
105  return MCDisassembler::Fail;
106 
107  unsigned Reg = GPRDecoderTable[RegNo];
108  Inst.addOperand(MCOperand::createReg(Reg));
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 DecodeGPR32RegisterClass(MCInst &Inst, unsigned RegNo,
117  uint64_t /*Address*/,
118  const void * /*Decoder*/) {
119  if (RegNo > 11)
120  return MCDisassembler::Fail;
121 
122  unsigned Reg = GPR32DecoderTable[RegNo];
123  Inst.addOperand(MCOperand::createReg(Reg));
125 }
126 
127 static DecodeStatus decodeMemoryOpValue(MCInst &Inst, unsigned Insn,
128  uint64_t Address, const void *Decoder) {
129  unsigned Register = (Insn >> 16) & 0xf;
130  Inst.addOperand(MCOperand::createReg(GPRDecoderTable[Register]));
131  unsigned Offset = (Insn & 0xffff);
132  Inst.addOperand(MCOperand::createImm(SignExtend32<16>(Offset)));
133 
135 }
136 
137 #include "BPFGenDisassemblerTables.inc"
139  uint64_t &Size, uint64_t &Insn,
140  bool IsLittleEndian) {
141  uint64_t Lo, Hi;
142 
143  if (Bytes.size() < 8) {
144  Size = 0;
145  return MCDisassembler::Fail;
146  }
147 
148  Size = 8;
149  if (IsLittleEndian) {
150  Hi = (Bytes[0] << 24) | (Bytes[1] << 16) | (Bytes[2] << 0) | (Bytes[3] << 8);
151  Lo = (Bytes[4] << 0) | (Bytes[5] << 8) | (Bytes[6] << 16) | (Bytes[7] << 24);
152  } else {
153  Hi = (Bytes[0] << 24) | ((Bytes[1] & 0x0F) << 20) | ((Bytes[1] & 0xF0) << 12) |
154  (Bytes[2] << 8) | (Bytes[3] << 0);
155  Lo = (Bytes[4] << 24) | (Bytes[5] << 16) | (Bytes[6] << 8) | (Bytes[7] << 0);
156  }
157  Insn = Make_64(Hi, Lo);
158 
160 }
161 
162 DecodeStatus BPFDisassembler::getInstruction(MCInst &Instr, uint64_t &Size,
163  ArrayRef<uint8_t> Bytes,
164  uint64_t Address,
165  raw_ostream &VStream,
166  raw_ostream &CStream) const {
167  bool IsLittleEndian = getContext().getAsmInfo()->isLittleEndian();
168  uint64_t Insn, Hi;
170 
171  Result = readInstruction64(Bytes, Address, Size, Insn, IsLittleEndian);
172  if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
173 
174  uint8_t InstClass = getInstClass(Insn);
175  if ((InstClass == BPF_LDX || InstClass == BPF_STX) &&
176  getInstSize(Insn) != BPF_DW &&
177  getInstMode(Insn) == BPF_MEM &&
178  STI.getFeatureBits()[BPF::ALU32])
179  Result = decodeInstruction(DecoderTableBPFALU3264, Instr, Insn, Address,
180  this, STI);
181  else
182  Result = decodeInstruction(DecoderTableBPF64, Instr, Insn, Address, this,
183  STI);
184 
185  if (Result == MCDisassembler::Fail) return MCDisassembler::Fail;
186 
187  switch (Instr.getOpcode()) {
188  case BPF::LD_imm64:
189  case BPF::LD_pseudo: {
190  if (Bytes.size() < 16) {
191  Size = 0;
192  return MCDisassembler::Fail;
193  }
194  Size = 16;
195  if (IsLittleEndian)
196  Hi = (Bytes[12] << 0) | (Bytes[13] << 8) | (Bytes[14] << 16) | (Bytes[15] << 24);
197  else
198  Hi = (Bytes[12] << 24) | (Bytes[13] << 16) | (Bytes[14] << 8) | (Bytes[15] << 0);
199  auto& Op = Instr.getOperand(1);
200  Op.setImm(Make_64(Hi, Op.getImm()));
201  break;
202  }
203  case BPF::LD_ABS_B:
204  case BPF::LD_ABS_H:
205  case BPF::LD_ABS_W:
206  case BPF::LD_IND_B:
207  case BPF::LD_IND_H:
208  case BPF::LD_IND_W: {
209  auto Op = Instr.getOperand(0);
210  Instr.clear();
212  Instr.addOperand(Op);
213  break;
214  }
215  }
216 
217  return Result;
218 }
219 
220 typedef DecodeStatus (*DecodeFunc)(MCInst &MI, unsigned insn, uint64_t Address,
221  const void *Decoder);
#define R4(n)
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void clear()
Definition: MCInst.h:191
DecodeStatus(* DecodeFunc)(MCInst &MI, unsigned insn, uint64_t Address, const void *Decoder)
DecodeStatus
Ternary decode status.
Superclass for all disassemblers.
unsigned Reg
static void RegisterMCDisassembler(Target &T, Target::MCDisassemblerCtorTy Fn)
RegisterMCDisassembler - Register a MCDisassembler implementation for the given target.
#define R2(n)
static DecodeStatus readInstruction64(ArrayRef< uint8_t > Bytes, uint64_t Address, uint64_t &Size, uint64_t &Insn, bool IsLittleEndian)
static MCOperand createReg(unsigned Reg)
Definition: MCInst.h:116
Context object for machine code objects.
Definition: MCContext.h:63
static DecodeStatus DecodeGPRRegisterClass(MCInst &Inst, unsigned RegNo, uint64_t, const void *)
int decodeInstruction(InternalInstruction *insn, byteReader_t reader, const void *readerArg, dlog_t logger, void *loggerArg, const void *miiArg, uint64_t startLoc, DisassemblerMode mode)
Decode one instruction and store the decoding results in a buffer provided by the consumer...
static const unsigned GPRDecoderTable[]
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:161
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
#define R6(n)
static MCDisassembler * createBPFDisassembler(const Target &T, const MCSubtargetInfo &STI, MCContext &Ctx)
const MCOperand & getOperand(unsigned i) const
Definition: MCInst.h:182
Promote Memory to Register
Definition: Mem2Reg.cpp:110
void LLVMInitializeBPFDisassembler()
Target - Wrapper for Target specific information.
static DecodeStatus decodeMemoryOpValue(MCInst &Inst, unsigned Insn, uint64_t Address, const void *Decoder)
Generic base class for all target subtargets.
uint32_t Size
Definition: Profile.cpp:47
Target & getTheBPFleTarget()
static DecodeStatus DecodeGPR32RegisterClass(MCInst &Inst, unsigned RegNo, uint64_t, const void *)
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:294
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
IRTranslator LLVM IR MI
void addOperand(const MCOperand &Op)
Definition: MCInst.h:186
static const unsigned GPR32DecoderTable[]
Target & getTheBPFbeTarget()
unsigned getOpcode() const
Definition: MCInst.h:174
MCDisassembler::DecodeStatus DecodeStatus
static MCOperand createImm(int64_t Val)
Definition: MCInst.h:123
Target & getTheBPFTarget()