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