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 /// \brief 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 "WebAssembly.h" 19 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h" 20 #include "llvm/MC/MCContext.h" 21 #include "llvm/MC/MCDisassembler/MCDisassembler.h" 22 #include "llvm/MC/MCInst.h" 23 #include "llvm/MC/MCInstrInfo.h" 24 #include "llvm/MC/MCSubtargetInfo.h" 25 #include "llvm/MC/MCSymbol.h" 26 #include "llvm/Support/Endian.h" 27 #include "llvm/Support/TargetRegistry.h" 28 using namespace llvm; 29 30 #define DEBUG_TYPE "wasm-disassembler" 31 32 namespace { 33 class WebAssemblyDisassembler final : public MCDisassembler { 34 std::unique_ptr<const MCInstrInfo> MCII; 35 36 DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size, 37 ArrayRef<uint8_t> Bytes, uint64_t Address, 38 raw_ostream &VStream, 39 raw_ostream &CStream) const override; 40 41 public: 42 WebAssemblyDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx, 43 std::unique_ptr<const MCInstrInfo> MCII) 44 : MCDisassembler(STI, Ctx), MCII(std::move(MCII)) {} 45 }; 46 } // end anonymous namespace 47 48 static MCDisassembler *createWebAssemblyDisassembler(const Target &T, 49 const MCSubtargetInfo &STI, 50 MCContext &Ctx) { 51 std::unique_ptr<const MCInstrInfo> MCII(T.createMCInstrInfo()); 52 return new WebAssemblyDisassembler(STI, Ctx, std::move(MCII)); 53 } 54 55 extern "C" void LLVMInitializeWebAssemblyDisassembler() { 56 // Register the disassembler for each target. 57 TargetRegistry::RegisterMCDisassembler(getTheWebAssemblyTarget32(), 58 createWebAssemblyDisassembler); 59 TargetRegistry::RegisterMCDisassembler(getTheWebAssemblyTarget64(), 60 createWebAssemblyDisassembler); 61 } 62 63 MCDisassembler::DecodeStatus WebAssemblyDisassembler::getInstruction( 64 MCInst &MI, uint64_t &Size, ArrayRef<uint8_t> Bytes, uint64_t /*Address*/, 65 raw_ostream &OS, raw_ostream &CS) const { 66 Size = 0; 67 uint64_t Pos = 0; 68 69 // Read the opcode. 70 if (Pos + sizeof(uint64_t) > Bytes.size()) 71 return MCDisassembler::Fail; 72 uint64_t Opcode = support::endian::read64le(Bytes.data() + Pos); 73 Pos += sizeof(uint64_t); 74 75 if (Opcode >= WebAssembly::INSTRUCTION_LIST_END) 76 return MCDisassembler::Fail; 77 78 MI.setOpcode(Opcode); 79 const MCInstrDesc &Desc = MCII->get(Opcode); 80 unsigned NumFixedOperands = Desc.NumOperands; 81 82 // If it's variadic, read the number of extra operands. 83 unsigned NumExtraOperands = 0; 84 if (Desc.isVariadic()) { 85 if (Pos + sizeof(uint64_t) > Bytes.size()) 86 return MCDisassembler::Fail; 87 NumExtraOperands = support::endian::read64le(Bytes.data() + Pos); 88 Pos += sizeof(uint64_t); 89 } 90 91 // Read the fixed operands. These are described by the MCInstrDesc. 92 for (unsigned i = 0; i < NumFixedOperands; ++i) { 93 const MCOperandInfo &Info = Desc.OpInfo[i]; 94 switch (Info.OperandType) { 95 case MCOI::OPERAND_IMMEDIATE: 96 case WebAssembly::OPERAND_LOCAL: 97 case WebAssembly::OPERAND_GLOBAL: 98 case WebAssembly::OPERAND_P2ALIGN: 99 case WebAssembly::OPERAND_BASIC_BLOCK: { 100 if (Pos + sizeof(uint64_t) > Bytes.size()) 101 return MCDisassembler::Fail; 102 uint64_t Imm = support::endian::read64le(Bytes.data() + Pos); 103 Pos += sizeof(uint64_t); 104 MI.addOperand(MCOperand::createImm(Imm)); 105 break; 106 } 107 case MCOI::OPERAND_REGISTER: { 108 if (Pos + sizeof(uint64_t) > Bytes.size()) 109 return MCDisassembler::Fail; 110 uint64_t Reg = support::endian::read64le(Bytes.data() + Pos); 111 Pos += sizeof(uint64_t); 112 MI.addOperand(MCOperand::createReg(Reg)); 113 break; 114 } 115 case WebAssembly::OPERAND_F32IMM: 116 case WebAssembly::OPERAND_F64IMM: { 117 // TODO: MC converts all floating point immediate operands to double. 118 // This is fine for numeric values, but may cause NaNs to change bits. 119 if (Pos + sizeof(uint64_t) > Bytes.size()) 120 return MCDisassembler::Fail; 121 uint64_t Bits = support::endian::read64le(Bytes.data() + Pos); 122 Pos += sizeof(uint64_t); 123 double Imm; 124 memcpy(&Imm, &Bits, sizeof(Imm)); 125 MI.addOperand(MCOperand::createFPImm(Imm)); 126 break; 127 } 128 default: 129 llvm_unreachable("unimplemented operand kind"); 130 } 131 } 132 133 // Read the extra operands. 134 assert(NumExtraOperands == 0 || Desc.isVariadic()); 135 for (unsigned i = 0; i < NumExtraOperands; ++i) { 136 if (Pos + sizeof(uint64_t) > Bytes.size()) 137 return MCDisassembler::Fail; 138 if (Desc.TSFlags & WebAssemblyII::VariableOpIsImmediate) { 139 // Decode extra immediate operands. 140 uint64_t Imm = support::endian::read64le(Bytes.data() + Pos); 141 MI.addOperand(MCOperand::createImm(Imm)); 142 } else { 143 // Decode extra register operands. 144 uint64_t Reg = support::endian::read64le(Bytes.data() + Pos); 145 MI.addOperand(MCOperand::createReg(Reg)); 146 } 147 Pos += sizeof(uint64_t); 148 } 149 150 Size = Pos; 151 return MCDisassembler::Success; 152 } 153