llvm/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/WebAssemblyMCTypeUtilities.h"
  18 #include "TargetInfo/WebAssemblyTargetInfo.h"
  19 #include "llvm/BinaryFormat/Wasm.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/MC/MCSymbolWasm.h"
  27 #include "llvm/MC/TargetRegistry.h"
  28 #include "llvm/Support/Casting.h"
  29 #include "llvm/Support/Endian.h"
  30 #include "llvm/Support/LEB128.h"
  31
  32 using namespace llvm;
  33
  34 #define DEBUG_TYPE "wasm-disassembler"
  35
  36 using DecodeStatus = MCDisassembler::DecodeStatus;
  37
  38 #include "WebAssemblyGenDisassemblerTables.inc"
  39
  40 namespace {
  41 static constexpr int WebAssemblyInstructionTableSize = 256;
  42
  43 class WebAssemblyDisassembler final : public MCDisassembler {
  44   std::unique_ptr<const MCInstrInfo> MCII;
  45
  46   DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
  47                               ArrayRef<uint8_t> Bytes, uint64_t Address,
  48                               raw_ostream &CStream) const override;
  49
  50   Expected<bool> onSymbolStart(SymbolInfoTy &Symbol, uint64_t &Size,
  51                                ArrayRef<uint8_t> Bytes,
  52                                uint64_t Address) 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" LLVM_EXTERNAL_VISIBILITY void
  69 LLVMInitializeWebAssemblyDisassembler() {
  70   // Register the disassembler for each target.
  71   TargetRegistry::RegisterMCDisassembler(getTheWebAssemblyTarget32(),
  72                                          createWebAssemblyDisassembler);
  73   TargetRegistry::RegisterMCDisassembler(getTheWebAssemblyTarget64(),
  74                                          createWebAssemblyDisassembler);
  75 }
  76
  77 static int nextByte(ArrayRef<uint8_t> Bytes, uint64_t &Size) {
  78   if (Size >= Bytes.size())
  79     return -1;
  80   auto V = Bytes[Size];
  81   Size++;
  82   return V;
  83 }
  84
  85 static bool nextLEB(int64_t &Val, ArrayRef<uint8_t> Bytes, uint64_t &Size,
  86                     bool Signed) {
  87   unsigned N = 0;
  88   const char *Error = nullptr;
  89   Val = Signed ? decodeSLEB128(Bytes.data() + Size, &N,
  90                                Bytes.data() + Bytes.size(), &Error)
  91                : static_cast<int64_t>(decodeULEB128(Bytes.data() + Size, &N,
  92                                                     Bytes.data() + Bytes.size(),
  93                                                     &Error));
  94   if (Error)
  95     return false;
  96   Size += N;
  97   return true;
  98 }
  99
 100 static bool parseLEBImmediate(MCInst &MI, uint64_t &Size,
 101                               ArrayRef<uint8_t> Bytes, bool Signed) {
 102   int64_t Val;
 103   if (!nextLEB(Val, Bytes, Size, Signed))
 104     return false;
 105   MI.addOperand(MCOperand::createImm(Val));
 106   return true;
 107 }
 108
 109 template <typename T>
 110 bool parseImmediate(MCInst &MI, uint64_t &Size, ArrayRef<uint8_t> Bytes) {
 111   if (Size + sizeof(T) > Bytes.size())
 112     return false;
 113   T Val =
 114       support::endian::read<T, llvm::endianness::little>(Bytes.data() + Size);
 115   Size += sizeof(T);
 116   if (std::is_floating_point<T>::value) {
 117     MI.addOperand(
 118         MCOperand::createDFPImm(bit_cast<uint64_t>(static_cast<double>(Val))));
 119   } else {
 120     MI.addOperand(MCOperand::createImm(static_cast<int64_t>(Val)));
 121   }
 122   return true;
 123 }
 124
 125 Expected<bool> WebAssemblyDisassembler::onSymbolStart(SymbolInfoTy &Symbol,
 126                                                       uint64_t &Size,
 127                                                       ArrayRef<uint8_t> Bytes,
 128                                                       uint64_t Address) const {
 129   Size = 0;
 130   if (Symbol.Type == wasm::WASM_SYMBOL_TYPE_SECTION) {
 131     // Start of a code section: we're parsing only the function count.
 132     int64_t FunctionCount;
 133     if (!nextLEB(FunctionCount, Bytes, Size, false))
 134       return false;
 135     outs() << "        # " << FunctionCount << " functions in section.";
 136   } else {
 137     // Parse the start of a single function.
 138     int64_t BodySize, LocalEntryCount;
 139     if (!nextLEB(BodySize, Bytes, Size, false) ||
 140         !nextLEB(LocalEntryCount, Bytes, Size, false))
 141       return false;
 142     if (LocalEntryCount) {
 143       outs() << "        .local ";
 144       for (int64_t I = 0; I < LocalEntryCount; I++) {
 145         int64_t Count, Type;
 146         if (!nextLEB(Count, Bytes, Size, false) ||
 147             !nextLEB(Type, Bytes, Size, false))
 148           return false;
 149         for (int64_t J = 0; J < Count; J++) {
 150           if (I || J)
 151             outs() << ", ";
 152           outs() << WebAssembly::anyTypeToString(Type);
 153         }
 154       }
 155     }
 156   }
 157   outs() << "\n";
 158   return true;
 159 }
 160
 161 MCDisassembler::DecodeStatus WebAssemblyDisassembler::getInstruction(
 162     MCInst &MI, uint64_t &Size, ArrayRef<uint8_t> Bytes, uint64_t /*Address*/,
 163     raw_ostream &CS) const {
 164   CommentStream = &CS;
 165   Size = 0;
 166   int Opc = nextByte(Bytes, Size);
 167   if (Opc < 0)
 168     return MCDisassembler::Fail;
 169   const auto *WasmInst = &InstructionTable0[Opc];
 170   // If this is a prefix byte, indirect to another table.
 171   if (WasmInst->ET == ET_Prefix) {
 172     WasmInst = nullptr;
 173     // Linear search, so far only 2 entries.
 174     for (auto PT = PrefixTable; PT->Table; PT++) {
 175       if (PT->Prefix == Opc) {
 176         WasmInst = PT->Table;
 177         break;
 178       }
 179     }
 180     if (!WasmInst)
 181       return MCDisassembler::Fail;
 182     int64_t PrefixedOpc;
 183     if (!nextLEB(PrefixedOpc, Bytes, Size, false))
 184       return MCDisassembler::Fail;
 185     if (PrefixedOpc < 0 || PrefixedOpc >= WebAssemblyInstructionTableSize)
 186       return MCDisassembler::Fail;
 187     WasmInst += PrefixedOpc;
 188   }
 189   if (WasmInst->ET == ET_Unused)
 190     return MCDisassembler::Fail;
 191   // At this point we must have a valid instruction to decode.
 192   assert(WasmInst->ET == ET_Instruction);
 193   MI.setOpcode(WasmInst->Opcode);
 194   // Parse any operands.
 195   for (uint8_t OPI = 0; OPI < WasmInst->NumOperands; OPI++) {
 196     auto OT = OperandTable[WasmInst->OperandStart + OPI];
 197     switch (OT) {
 198     // ULEB operands:
 199     case WebAssembly::OPERAND_BASIC_BLOCK:
 200     case WebAssembly::OPERAND_LOCAL:
 201     case WebAssembly::OPERAND_GLOBAL:
 202     case WebAssembly::OPERAND_FUNCTION32:
 203     case WebAssembly::OPERAND_TABLE:
 204     case WebAssembly::OPERAND_OFFSET32:
 205     case WebAssembly::OPERAND_OFFSET64:
 206     case WebAssembly::OPERAND_P2ALIGN:
 207     case WebAssembly::OPERAND_TYPEINDEX:
 208     case WebAssembly::OPERAND_TAG:
 209     case MCOI::OPERAND_IMMEDIATE: {
 210       if (!parseLEBImmediate(MI, Size, Bytes, false))
 211         return MCDisassembler::Fail;
 212       break;
 213     }
 214     // SLEB operands:
 215     case WebAssembly::OPERAND_I32IMM:
 216     case WebAssembly::OPERAND_I64IMM: {
 217       if (!parseLEBImmediate(MI, Size, Bytes, true))
 218         return MCDisassembler::Fail;
 219       break;
 220     }
 221     // block_type operands:
 222     case WebAssembly::OPERAND_SIGNATURE: {
 223       int64_t Val;
 224       uint64_t PrevSize = Size;
 225       if (!nextLEB(Val, Bytes, Size, true))
 226         return MCDisassembler::Fail;
 227       if (Val < 0) {
 228         // Negative values are single septet value types or empty types
 229         if (Size != PrevSize + 1) {
 230           MI.addOperand(
 231               MCOperand::createImm(int64_t(WebAssembly::BlockType::Invalid)));
 232         } else {
 233           MI.addOperand(MCOperand::createImm(Val & 0x7f));
 234         }
 235       } else {
 236         // We don't have access to the signature, so create a symbol without one
 237         MCSymbol *Sym = getContext().createTempSymbol("typeindex", true);
 238         auto *WasmSym = cast<MCSymbolWasm>(Sym);
 239         WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
 240         const MCExpr *Expr = MCSymbolRefExpr::create(
 241             WasmSym, MCSymbolRefExpr::VK_WASM_TYPEINDEX, getContext());
 242         MI.addOperand(MCOperand::createExpr(Expr));
 243       }
 244       break;
 245     }
 246     // FP operands.
 247     case WebAssembly::OPERAND_F32IMM: {
 248       if (!parseImmediate<float>(MI, Size, Bytes))
 249         return MCDisassembler::Fail;
 250       break;
 251     }
 252     case WebAssembly::OPERAND_F64IMM: {
 253       if (!parseImmediate<double>(MI, Size, Bytes))
 254         return MCDisassembler::Fail;
 255       break;
 256     }
 257     // Vector lane operands (not LEB encoded).
 258     case WebAssembly::OPERAND_VEC_I8IMM: {
 259       if (!parseImmediate<uint8_t>(MI, Size, Bytes))
 260         return MCDisassembler::Fail;
 261       break;
 262     }
 263     case WebAssembly::OPERAND_VEC_I16IMM: {
 264       if (!parseImmediate<uint16_t>(MI, Size, Bytes))
 265         return MCDisassembler::Fail;
 266       break;
 267     }
 268     case WebAssembly::OPERAND_VEC_I32IMM: {
 269       if (!parseImmediate<uint32_t>(MI, Size, Bytes))
 270         return MCDisassembler::Fail;
 271       break;
 272     }
 273     case WebAssembly::OPERAND_VEC_I64IMM: {
 274       if (!parseImmediate<uint64_t>(MI, Size, Bytes))
 275         return MCDisassembler::Fail;
 276       break;
 277     }
 278     case WebAssembly::OPERAND_BRLIST: {
 279       int64_t TargetTableLen;
 280       if (!nextLEB(TargetTableLen, Bytes, Size, false))
 281         return MCDisassembler::Fail;
 282       for (int64_t I = 0; I < TargetTableLen; I++) {
 283         if (!parseLEBImmediate(MI, Size, Bytes, false))
 284           return MCDisassembler::Fail;
 285       }
 286       // Default case.
 287       if (!parseLEBImmediate(MI, Size, Bytes, false))
 288         return MCDisassembler::Fail;
 289       break;
 290     }
 291     case WebAssembly::OPERAND_CATCH_LIST: {
 292       if (!parseLEBImmediate(MI, Size, Bytes, false))
 293         return MCDisassembler::Fail;
 294       int64_t NumCatches = MI.getOperand(MI.getNumOperands() - 1).getImm();
 295       for (int64_t I = 0; I < NumCatches; I++) {
 296         if (!parseImmediate<uint8_t>(MI, Size, Bytes))
 297           return MCDisassembler::Fail;
 298         int64_t CatchOpcode = MI.getOperand(MI.getNumOperands() - 1).getImm();
 299         if (CatchOpcode == wasm::WASM_OPCODE_CATCH ||
 300             CatchOpcode == wasm::WASM_OPCODE_CATCH_REF) {
 301           if (!parseLEBImmediate(MI, Size, Bytes, false)) // tag index
 302             return MCDisassembler::Fail;
 303         }
 304         if (!parseLEBImmediate(MI, Size, Bytes, false)) // destination
 305           return MCDisassembler::Fail;
 306       }
 307       break;
 308     }
 309     case MCOI::OPERAND_REGISTER:
 310       // The tablegen header currently does not have any register operands since
 311       // we use only the stack (_S) instructions.
 312       // If you hit this that probably means a bad instruction definition in
 313       // tablegen.
 314       llvm_unreachable("Register operand in WebAssemblyDisassembler");
 315     default:
 316       llvm_unreachable("Unknown operand type in WebAssemblyDisassembler");
 317     }
 318   }
 319   return MCDisassembler::Success;
 320 }