BPFDisassembler.cpp revision 360784 
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
25using namespace llvm;
26
27#define DEBUG_TYPE "bpf-disassembler"
28
29typedef MCDisassembler::DecodeStatus DecodeStatus;
30
31namespace {
32
33/// A disassembler class for BPF.
34class BPFDisassembler : public MCDisassembler {
35public:
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
79static MCDisassembler *createBPFDisassembler(const Target &T,
80                                             const MCSubtargetInfo &STI,
81                                             MCContext &Ctx) {
82  return new BPFDisassembler(STI, Ctx);
83}
84
85
86extern "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
96static 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
100static 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
111static 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
115static 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
126static 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"
137static 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
161DecodeStatus 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
219typedef DecodeStatus (*DecodeFunc)(MCInst &MI, unsigned insn, uint64_t Address,
220                                   const void *Decoder);
221