1 //==- WebAssemblyDisassembler.cpp - Disassembler for WebAssembly -*- 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 /// \file 11 /// This file is part of the WebAssembly Disassembler. 12 /// 13 /// It contains code to translate the data produced by the decoder into 14 /// MCInsts. 15 /// 16 //===----------------------------------------------------------------------===// 17 18 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h" 19 #include "WebAssembly.h" 20 #include "llvm/MC/MCContext.h" 21 #include "llvm/MC/MCDisassembler/MCDisassembler.h" 22 #include "llvm/MC/MCFixedLenDisassembler.h" 23 #include "llvm/MC/MCInst.h" 24 #include "llvm/MC/MCInstrInfo.h" 25 #include "llvm/MC/MCSubtargetInfo.h" 26 #include "llvm/MC/MCSymbol.h" 27 #include "llvm/Support/Endian.h" 28 #include "llvm/Support/LEB128.h" 29 #include "llvm/Support/TargetRegistry.h" 30 31 using namespace llvm; 32 33 #define DEBUG_TYPE "wasm-disassembler" 34 35 using DecodeStatus = MCDisassembler::DecodeStatus; 36 37 #include "WebAssemblyGenDisassemblerTables.inc" 38 39 namespace { 40 class WebAssemblyDisassembler final : public MCDisassembler { 41 std::unique_ptr<const MCInstrInfo> MCII; 42 43 DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size, 44 ArrayRef<uint8_t> Bytes, uint64_t Address, 45 raw_ostream &VStream, 46 raw_ostream &CStream) const override; 47 48 public: 49 WebAssemblyDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx, 50 std::unique_ptr<const MCInstrInfo> MCII) 51 : MCDisassembler(STI, Ctx), MCII(std::move(MCII)) {} 52 }; 53 } // end anonymous namespace 54 55 static MCDisassembler *createWebAssemblyDisassembler(const Target &T, 56 const MCSubtargetInfo &STI, 57 MCContext &Ctx) { 58 std::unique_ptr<const MCInstrInfo> MCII(T.createMCInstrInfo()); 59 return new WebAssemblyDisassembler(STI, Ctx, std::move(MCII)); 60 } 61 62 extern "C" void LLVMInitializeWebAssemblyDisassembler() { 63 // Register the disassembler for each target. 64 TargetRegistry::RegisterMCDisassembler(getTheWebAssemblyTarget32(), 65 createWebAssemblyDisassembler); 66 TargetRegistry::RegisterMCDisassembler(getTheWebAssemblyTarget64(), 67 createWebAssemblyDisassembler); 68 } 69 70 static int nextByte(ArrayRef<uint8_t> Bytes, uint64_t &Size) { 71 if (Size >= Bytes.size()) 72 return -1; 73 auto V = Bytes[Size]; 74 Size++; 75 return V; 76 } 77 78 static bool parseLEBImmediate(MCInst &MI, uint64_t &Size, 79 ArrayRef<uint8_t> Bytes, bool Signed) { 80 unsigned N = 0; 81 const char *Error = nullptr; 82 auto Val = Signed ? decodeSLEB128(Bytes.data() + Size, &N, 83 Bytes.data() + Bytes.size(), &Error) 84 : static_cast<int64_t>( 85 decodeULEB128(Bytes.data() + Size, &N, 86 Bytes.data() + Bytes.size(), &Error)); 87 if (Error) 88 return false; 89 Size += N; 90 MI.addOperand(MCOperand::createImm(Val)); 91 return true; 92 } 93 94 template <typename T> 95 bool parseImmediate(MCInst &MI, uint64_t &Size, ArrayRef<uint8_t> Bytes) { 96 if (Size + sizeof(T) > Bytes.size()) 97 return false; 98 T Val; 99 memcpy(&Val, Bytes.data() + Size, sizeof(T)); 100 support::endian::byte_swap<T, support::endianness::little>(Val); 101 Size += sizeof(T); 102 if (std::is_floating_point<T>::value) { 103 MI.addOperand(MCOperand::createFPImm(static_cast<double>(Val))); 104 } else { 105 MI.addOperand(MCOperand::createImm(static_cast<int64_t>(Val))); 106 } 107 return true; 108 } 109 110 MCDisassembler::DecodeStatus WebAssemblyDisassembler::getInstruction( 111 MCInst &MI, uint64_t &Size, ArrayRef<uint8_t> Bytes, uint64_t /*Address*/, 112 raw_ostream & /*OS*/, raw_ostream &CS) const { 113 CommentStream = &CS; 114 Size = 0; 115 auto Opc = nextByte(Bytes, Size); 116 if (Opc < 0) 117 return MCDisassembler::Fail; 118 const auto *WasmInst = &InstructionTable0[Opc]; 119 // If this is a prefix byte, indirect to another table. 120 if (WasmInst->ET == ET_Prefix) { 121 WasmInst = nullptr; 122 // Linear search, so far only 2 entries. 123 for (auto PT = PrefixTable; PT->Table; PT++) { 124 if (PT->Prefix == Opc) { 125 WasmInst = PT->Table; 126 break; 127 } 128 } 129 if (!WasmInst) 130 return MCDisassembler::Fail; 131 Opc = nextByte(Bytes, Size); 132 if (Opc < 0) 133 return MCDisassembler::Fail; 134 WasmInst += Opc; 135 } 136 if (WasmInst->ET == ET_Unused) 137 return MCDisassembler::Fail; 138 // At this point we must have a valid instruction to decode. 139 assert(WasmInst->ET == ET_Instruction); 140 MI.setOpcode(WasmInst->Opcode); 141 // Parse any operands. 142 for (uint8_t OPI = 0; OPI < WasmInst->NumOperands; OPI++) { 143 switch (OperandTable[WasmInst->OperandStart + OPI]) { 144 // ULEB operands: 145 case WebAssembly::OPERAND_BASIC_BLOCK: 146 case WebAssembly::OPERAND_LOCAL: 147 case WebAssembly::OPERAND_GLOBAL: 148 case WebAssembly::OPERAND_FUNCTION32: 149 case WebAssembly::OPERAND_OFFSET32: 150 case WebAssembly::OPERAND_P2ALIGN: 151 case WebAssembly::OPERAND_TYPEINDEX: 152 case MCOI::OPERAND_IMMEDIATE: { 153 if (!parseLEBImmediate(MI, Size, Bytes, false)) 154 return MCDisassembler::Fail; 155 break; 156 } 157 // SLEB operands: 158 case WebAssembly::OPERAND_I32IMM: 159 case WebAssembly::OPERAND_I64IMM: 160 case WebAssembly::OPERAND_SIGNATURE: { 161 if (!parseLEBImmediate(MI, Size, Bytes, true)) 162 return MCDisassembler::Fail; 163 break; 164 } 165 // FP operands. 166 case WebAssembly::OPERAND_F32IMM: { 167 if (!parseImmediate<float>(MI, Size, Bytes)) 168 return MCDisassembler::Fail; 169 break; 170 } 171 case WebAssembly::OPERAND_F64IMM: { 172 if (!parseImmediate<double>(MI, Size, Bytes)) 173 return MCDisassembler::Fail; 174 break; 175 } 176 // Vector lane operands (not LEB encoded). 177 case WebAssembly::OPERAND_VEC_I8IMM: { 178 if (!parseImmediate<uint8_t>(MI, Size, Bytes)) 179 return MCDisassembler::Fail; 180 break; 181 } 182 case WebAssembly::OPERAND_VEC_I16IMM: { 183 if (!parseImmediate<uint16_t>(MI, Size, Bytes)) 184 return MCDisassembler::Fail; 185 break; 186 } 187 case WebAssembly::OPERAND_VEC_I32IMM: { 188 if (!parseImmediate<uint32_t>(MI, Size, Bytes)) 189 return MCDisassembler::Fail; 190 break; 191 } 192 case WebAssembly::OPERAND_VEC_I64IMM: { 193 if (!parseImmediate<uint64_t>(MI, Size, Bytes)) 194 return MCDisassembler::Fail; 195 break; 196 } 197 case MCOI::OPERAND_REGISTER: 198 // The tablegen header currently does not have any register operands since 199 // we use only the stack (_S) instructions. 200 // If you hit this that probably means a bad instruction definition in 201 // tablegen. 202 llvm_unreachable("Register operand in WebAssemblyDisassembler"); 203 default: 204 llvm_unreachable("Unknown operand type in WebAssemblyDisassembler"); 205 } 206 } 207 return MCDisassembler::Success; 208 } 209