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