lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp

   1 //==- WebAssemblyDisassembler.cpp - Disassembler for WebAssembly -*- 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 /// \file
  10 /// This file is part of the WebAssembly Disassembler.
  11 ///
  12 /// It contains code to translate the data produced by the decoder into
  13 /// MCInsts.
  14 ///
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "MCTargetDesc/WebAssemblyInstPrinter.h"
  18 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
  19 #include "TargetInfo/WebAssemblyTargetInfo.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 static constexpr int WebAssemblyInstructionTableSize = 256;
  41
  42 class WebAssemblyDisassembler final : public MCDisassembler {
  43   std::unique_ptr<const MCInstrInfo> MCII;
  44
  45   DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
  46                               ArrayRef<uint8_t> Bytes, uint64_t Address,
  47                               raw_ostream &VStream,
  48                               raw_ostream &CStream) const override;
  49   DecodeStatus onSymbolStart(StringRef Name, uint64_t &Size,
  50                              ArrayRef<uint8_t> Bytes, uint64_t Address,
  51                              raw_ostream &VStream,
  52                              raw_ostream &CStream) const override;
  53
  54 public:
  55   WebAssemblyDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx,
  56                           std::unique_ptr<const MCInstrInfo> MCII)
  57       : MCDisassembler(STI, Ctx), MCII(std::move(MCII)) {}
  58 };
  59 } // end anonymous namespace
  60
  61 static MCDisassembler *createWebAssemblyDisassembler(const Target &T,
  62                                                      const MCSubtargetInfo &STI,
  63                                                      MCContext &Ctx) {
  64   std::unique_ptr<const MCInstrInfo> MCII(T.createMCInstrInfo());
  65   return new WebAssemblyDisassembler(STI, Ctx, std::move(MCII));
  66 }
  67
  68 extern "C" void LLVMInitializeWebAssemblyDisassembler() {
  69   // Register the disassembler for each target.
  70   TargetRegistry::RegisterMCDisassembler(getTheWebAssemblyTarget32(),
  71                                          createWebAssemblyDisassembler);
  72   TargetRegistry::RegisterMCDisassembler(getTheWebAssemblyTarget64(),
  73                                          createWebAssemblyDisassembler);
  74 }
  75
  76 static int nextByte(ArrayRef<uint8_t> Bytes, uint64_t &Size) {
  77   if (Size >= Bytes.size())
  78     return -1;
  79   auto V = Bytes[Size];
  80   Size++;
  81   return V;
  82 }
  83
  84 static bool nextLEB(int64_t &Val, ArrayRef<uint8_t> Bytes, uint64_t &Size,
  85                     bool Signed) {
  86   unsigned N = 0;
  87   const char *Error = nullptr;
  88   Val = Signed ? decodeSLEB128(Bytes.data() + Size, &N,
  89                                Bytes.data() + Bytes.size(), &Error)
  90                : static_cast<int64_t>(decodeULEB128(Bytes.data() + Size, &N,
  91                                                     Bytes.data() + Bytes.size(),
  92                                                     &Error));
  93   if (Error)
  94     return false;
  95   Size += N;
  96   return true;
  97 }
  98
  99 static bool parseLEBImmediate(MCInst &MI, uint64_t &Size,
 100                               ArrayRef<uint8_t> Bytes, bool Signed) {
 101   int64_t Val;
 102   if (!nextLEB(Val, Bytes, Size, Signed))
 103     return false;
 104   MI.addOperand(MCOperand::createImm(Val));
 105   return true;
 106 }
 107
 108 template <typename T>
 109 bool parseImmediate(MCInst &MI, uint64_t &Size, ArrayRef<uint8_t> Bytes) {
 110   if (Size + sizeof(T) > Bytes.size())
 111     return false;
 112   T Val = support::endian::read<T, support::endianness::little, 1>(
 113       Bytes.data() + Size);
 114   Size += sizeof(T);
 115   if (std::is_floating_point<T>::value) {
 116     MI.addOperand(MCOperand::createFPImm(static_cast<double>(Val)));
 117   } else {
 118     MI.addOperand(MCOperand::createImm(static_cast<int64_t>(Val)));
 119   }
 120   return true;
 121 }
 122
 123 MCDisassembler::DecodeStatus WebAssemblyDisassembler::onSymbolStart(
 124     StringRef Name, uint64_t &Size, ArrayRef<uint8_t> Bytes, uint64_t Address,
 125     raw_ostream &VStream, raw_ostream &CStream) const {
 126   Size = 0;
 127   if (Address == 0) {
 128     // Start of a code section: we're parsing only the function count.
 129     int64_t FunctionCount;
 130     if (!nextLEB(FunctionCount, Bytes, Size, false))
 131       return MCDisassembler::Fail;
 132     outs() << "        # " << FunctionCount << " functions in section.";
 133   } else {
 134     // Parse the start of a single function.
 135     int64_t BodySize, LocalEntryCount;
 136     if (!nextLEB(BodySize, Bytes, Size, false) ||
 137         !nextLEB(LocalEntryCount, Bytes, Size, false))
 138       return MCDisassembler::Fail;
 139     if (LocalEntryCount) {
 140       outs() << "        .local ";
 141       for (int64_t I = 0; I < LocalEntryCount; I++) {
 142         int64_t Count, Type;
 143         if (!nextLEB(Count, Bytes, Size, false) ||
 144             !nextLEB(Type, Bytes, Size, false))
 145           return MCDisassembler::Fail;
 146         for (int64_t J = 0; J < Count; J++) {
 147           if (I || J)
 148             outs() << ", ";
 149           outs() << WebAssembly::anyTypeToString(Type);
 150         }
 151       }
 152     }
 153   }
 154   outs() << "\n";
 155   return MCDisassembler::Success;
 156 }
 157
 158 MCDisassembler::DecodeStatus WebAssemblyDisassembler::getInstruction(
 159     MCInst &MI, uint64_t &Size, ArrayRef<uint8_t> Bytes, uint64_t /*Address*/,
 160     raw_ostream & /*OS*/, raw_ostream &CS) const {
 161   CommentStream = &CS;
 162   Size = 0;
 163   int Opc = nextByte(Bytes, Size);
 164   if (Opc < 0)
 165     return MCDisassembler::Fail;
 166   const auto *WasmInst = &InstructionTable0[Opc];
 167   // If this is a prefix byte, indirect to another table.
 168   if (WasmInst->ET == ET_Prefix) {
 169     WasmInst = nullptr;
 170     // Linear search, so far only 2 entries.
 171     for (auto PT = PrefixTable; PT->Table; PT++) {
 172       if (PT->Prefix == Opc) {
 173         WasmInst = PT->Table;
 174         break;
 175       }
 176     }
 177     if (!WasmInst)
 178       return MCDisassembler::Fail;
 179     int64_t PrefixedOpc;
 180     if (!nextLEB(PrefixedOpc, Bytes, Size, false))
 181       return MCDisassembler::Fail;
 182     if (PrefixedOpc < 0 || PrefixedOpc >= WebAssemblyInstructionTableSize)
 183       return MCDisassembler::Fail;
 184     WasmInst += PrefixedOpc;
 185   }
 186   if (WasmInst->ET == ET_Unused)
 187     return MCDisassembler::Fail;
 188   // At this point we must have a valid instruction to decode.
 189   assert(WasmInst->ET == ET_Instruction);
 190   MI.setOpcode(WasmInst->Opcode);
 191   // Parse any operands.
 192   for (uint8_t OPI = 0; OPI < WasmInst->NumOperands; OPI++) {
 193     auto OT = OperandTable[WasmInst->OperandStart + OPI];
 194     switch (OT) {
 195     // ULEB operands:
 196     case WebAssembly::OPERAND_BASIC_BLOCK:
 197     case WebAssembly::OPERAND_LOCAL:
 198     case WebAssembly::OPERAND_GLOBAL:
 199     case WebAssembly::OPERAND_FUNCTION32:
 200     case WebAssembly::OPERAND_OFFSET32:
 201     case WebAssembly::OPERAND_P2ALIGN:
 202     case WebAssembly::OPERAND_TYPEINDEX:
 203     case WebAssembly::OPERAND_EVENT:
 204     case MCOI::OPERAND_IMMEDIATE: {
 205       if (!parseLEBImmediate(MI, Size, Bytes, false))
 206         return MCDisassembler::Fail;
 207       break;
 208     }
 209     // SLEB operands:
 210     case WebAssembly::OPERAND_I32IMM:
 211     case WebAssembly::OPERAND_I64IMM: {
 212       if (!parseLEBImmediate(MI, Size, Bytes, true))
 213         return MCDisassembler::Fail;
 214       break;
 215     }
 216     // block_type operands (uint8_t).
 217     case WebAssembly::OPERAND_SIGNATURE: {
 218       if (!parseImmediate<uint8_t>(MI, Size, Bytes))
 219         return MCDisassembler::Fail;
 220       break;
 221     }
 222     // FP operands.
 223     case WebAssembly::OPERAND_F32IMM: {
 224       if (!parseImmediate<float>(MI, Size, Bytes))
 225         return MCDisassembler::Fail;
 226       break;
 227     }
 228     case WebAssembly::OPERAND_F64IMM: {
 229       if (!parseImmediate<double>(MI, Size, Bytes))
 230         return MCDisassembler::Fail;
 231       break;
 232     }
 233     // Vector lane operands (not LEB encoded).
 234     case WebAssembly::OPERAND_VEC_I8IMM: {
 235       if (!parseImmediate<uint8_t>(MI, Size, Bytes))
 236         return MCDisassembler::Fail;
 237       break;
 238     }
 239     case WebAssembly::OPERAND_VEC_I16IMM: {
 240       if (!parseImmediate<uint16_t>(MI, Size, Bytes))
 241         return MCDisassembler::Fail;
 242       break;
 243     }
 244     case WebAssembly::OPERAND_VEC_I32IMM: {
 245       if (!parseImmediate<uint32_t>(MI, Size, Bytes))
 246         return MCDisassembler::Fail;
 247       break;
 248     }
 249     case WebAssembly::OPERAND_VEC_I64IMM: {
 250       if (!parseImmediate<uint64_t>(MI, Size, Bytes))
 251         return MCDisassembler::Fail;
 252       break;
 253     }
 254     case WebAssembly::OPERAND_BRLIST: {
 255       int64_t TargetTableLen;
 256       if (!nextLEB(TargetTableLen, Bytes, Size, false))
 257         return MCDisassembler::Fail;
 258       for (int64_t I = 0; I < TargetTableLen; I++) {
 259         if (!parseLEBImmediate(MI, Size, Bytes, false))
 260           return MCDisassembler::Fail;
 261       }
 262       // Default case.
 263       if (!parseLEBImmediate(MI, Size, Bytes, false))
 264         return MCDisassembler::Fail;
 265       break;
 266     }
 267     case MCOI::OPERAND_REGISTER:
 268       // The tablegen header currently does not have any register operands since
 269       // we use only the stack (_S) instructions.
 270       // If you hit this that probably means a bad instruction definition in
 271       // tablegen.
 272       llvm_unreachable("Register operand in WebAssemblyDisassembler");
 273     default:
 274       llvm_unreachable("Unknown operand type in WebAssemblyDisassembler");
 275     }
 276   }
 277   return MCDisassembler::Success;
 278 }