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