LLVM 19.0.0git
WebAssemblyDisassembler.cpp
Go to the documentation of this file.
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
20#include "llvm/MC/MCContext.h"
23#include "llvm/MC/MCInst.h"
24#include "llvm/MC/MCInstrInfo.h"
26#include "llvm/MC/MCSymbol.h"
30#include "llvm/Support/Endian.h"
31#include "llvm/Support/LEB128.h"
32
33using namespace llvm;
34
35#define DEBUG_TYPE "wasm-disassembler"
36
38
39#include "WebAssemblyGenDisassemblerTables.inc"
40
41namespace {
42static constexpr int WebAssemblyInstructionTableSize = 256;
43
44class WebAssemblyDisassembler final : public MCDisassembler {
45 std::unique_ptr<const MCInstrInfo> MCII;
46
48 ArrayRef<uint8_t> Bytes, uint64_t Address,
49 raw_ostream &CStream) const override;
50 std::optional<DecodeStatus>
52 uint64_t Address, raw_ostream &CStream) const override;
53
54public:
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
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
68extern "C" LLVM_EXTERNAL_VISIBILITY void
70 // Register the disassembler for each target.
75}
76
78 if (Size >= Bytes.size())
79 return -1;
80 auto V = Bytes[Size];
81 Size++;
82 return V;
83}
84
85static 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
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
109template <typename T>
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
125std::optional<MCDisassembler::DecodeStatus>
126WebAssemblyDisassembler::onSymbolStart(SymbolInfoTy &Symbol, uint64_t &Size,
127 ArrayRef<uint8_t> Bytes,
128 uint64_t Address,
129 raw_ostream &CStream) const {
130 Size = 0;
132 // Start of a code section: we're parsing only the function count.
133 int64_t FunctionCount;
134 if (!nextLEB(FunctionCount, Bytes, Size, false))
135 return std::nullopt;
136 outs() << " # " << FunctionCount << " functions in section.";
137 } else {
138 // Parse the start of a single function.
139 int64_t BodySize, LocalEntryCount;
140 if (!nextLEB(BodySize, Bytes, Size, false) ||
141 !nextLEB(LocalEntryCount, Bytes, Size, false))
142 return std::nullopt;
143 if (LocalEntryCount) {
144 outs() << " .local ";
145 for (int64_t I = 0; I < LocalEntryCount; I++) {
146 int64_t Count, Type;
147 if (!nextLEB(Count, Bytes, Size, false) ||
148 !nextLEB(Type, Bytes, Size, false))
149 return std::nullopt;
150 for (int64_t J = 0; J < Count; J++) {
151 if (I || J)
152 outs() << ", ";
154 }
155 }
156 }
157 }
158 outs() << "\n";
160}
161
162MCDisassembler::DecodeStatus WebAssemblyDisassembler::getInstruction(
163 MCInst &MI, uint64_t &Size, ArrayRef<uint8_t> Bytes, uint64_t /*Address*/,
164 raw_ostream &CS) const {
165 CommentStream = &CS;
166 Size = 0;
167 int Opc = nextByte(Bytes, Size);
168 if (Opc < 0)
170 const auto *WasmInst = &InstructionTable0[Opc];
171 // If this is a prefix byte, indirect to another table.
172 if (WasmInst->ET == ET_Prefix) {
173 WasmInst = nullptr;
174 // Linear search, so far only 2 entries.
175 for (auto PT = PrefixTable; PT->Table; PT++) {
176 if (PT->Prefix == Opc) {
177 WasmInst = PT->Table;
178 break;
179 }
180 }
181 if (!WasmInst)
183 int64_t PrefixedOpc;
184 if (!nextLEB(PrefixedOpc, Bytes, Size, false))
186 if (PrefixedOpc < 0 || PrefixedOpc >= WebAssemblyInstructionTableSize)
188 WasmInst += PrefixedOpc;
189 }
190 if (WasmInst->ET == ET_Unused)
192 // At this point we must have a valid instruction to decode.
193 assert(WasmInst->ET == ET_Instruction);
194 MI.setOpcode(WasmInst->Opcode);
195 // Parse any operands.
196 for (uint8_t OPI = 0; OPI < WasmInst->NumOperands; OPI++) {
197 auto OT = OperandTable[WasmInst->OperandStart + OPI];
198 switch (OT) {
199 // ULEB operands:
211 if (!parseLEBImmediate(MI, Size, Bytes, false))
213 break;
214 }
215 // SLEB operands:
218 if (!parseLEBImmediate(MI, Size, Bytes, true))
220 break;
221 }
222 // block_type operands:
224 int64_t Val;
225 uint64_t PrevSize = Size;
226 if (!nextLEB(Val, Bytes, Size, true))
228 if (Val < 0) {
229 // Negative values are single septet value types or empty types
230 if (Size != PrevSize + 1) {
231 MI.addOperand(
232 MCOperand::createImm(int64_t(WebAssembly::BlockType::Invalid)));
233 } else {
234 MI.addOperand(MCOperand::createImm(Val & 0x7f));
235 }
236 } else {
237 // We don't have access to the signature, so create a symbol without one
238 MCSymbol *Sym = getContext().createTempSymbol("typeindex", true);
239 auto *WasmSym = cast<MCSymbolWasm>(Sym);
240 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
241 const MCExpr *Expr = MCSymbolRefExpr::create(
242 WasmSym, MCSymbolRefExpr::VK_WASM_TYPEINDEX, getContext());
243 MI.addOperand(MCOperand::createExpr(Expr));
244 }
245 break;
246 }
247 // FP operands.
249 if (!parseImmediate<float>(MI, Size, Bytes))
251 break;
252 }
254 if (!parseImmediate<double>(MI, Size, Bytes))
256 break;
257 }
258 // Vector lane operands (not LEB encoded).
260 if (!parseImmediate<uint8_t>(MI, Size, Bytes))
262 break;
263 }
265 if (!parseImmediate<uint16_t>(MI, Size, Bytes))
267 break;
268 }
270 if (!parseImmediate<uint32_t>(MI, Size, Bytes))
272 break;
273 }
275 if (!parseImmediate<uint64_t>(MI, Size, Bytes))
277 break;
278 }
280 int64_t TargetTableLen;
281 if (!nextLEB(TargetTableLen, Bytes, Size, false))
283 for (int64_t I = 0; I < TargetTableLen; I++) {
284 if (!parseLEBImmediate(MI, Size, Bytes, false))
286 }
287 // Default case.
288 if (!parseLEBImmediate(MI, Size, Bytes, false))
290 break;
291 }
293 // The tablegen header currently does not have any register operands since
294 // we use only the stack (_S) instructions.
295 // If you hit this that probably means a bad instruction definition in
296 // tablegen.
297 llvm_unreachable("Register operand in WebAssemblyDisassembler");
298 default:
299 llvm_unreachable("Unknown operand type in WebAssemblyDisassembler");
300 }
301 }
303}
static constexpr const ArrayRef< StringLiteral > PrefixTable(PrefixTable_init, std::size(PrefixTable_init) - 1)
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:135
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
IRTranslator LLVM IR MI
#define I(x, y, z)
Definition: MD5.cpp:58
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeWebAssemblyDisassembler()
static int nextByte(ArrayRef< uint8_t > Bytes, uint64_t &Size)
static bool nextLEB(int64_t &Val, ArrayRef< uint8_t > Bytes, uint64_t &Size, bool Signed)
static MCDisassembler * createWebAssemblyDisassembler(const Target &T, const MCSubtargetInfo &STI, MCContext &Ctx)
bool parseImmediate(MCInst &MI, uint64_t &Size, ArrayRef< uint8_t > Bytes)
static bool parseLEBImmediate(MCInst &MI, uint64_t &Size, ArrayRef< uint8_t > Bytes, bool Signed)
This file contains the declaration of the WebAssembly-specific type parsing utility functions.
This file registers the WebAssembly target.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
const T * data() const
Definition: ArrayRef.h:162
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
Context object for machine code objects.
Definition: MCContext.h:76
Superclass for all disassemblers.
virtual std::optional< DecodeStatus > onSymbolStart(SymbolInfoTy &Symbol, uint64_t &Size, ArrayRef< uint8_t > Bytes, uint64_t Address, raw_ostream &CStream) const
Used to perform separate target specific disassembly for a particular symbol.
DecodeStatus
Ternary decode status.
virtual DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size, ArrayRef< uint8_t > Bytes, uint64_t Address, raw_ostream &CStream) const =0
Returns the disassembly of a single instruction.
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
static MCOperand createExpr(const MCExpr *Val)
Definition: MCInst.h:162
static MCOperand createImm(int64_t Val)
Definition: MCInst.h:141
static MCOperand createDFPImm(uint64_t Val)
Definition: MCInst.h:155
Generic base class for all target subtargets.
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:397
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
Target - Wrapper for Target specific information.
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ OPERAND_REGISTER
Definition: MCInstrDesc.h:61
@ OPERAND_IMMEDIATE
Definition: MCInstrDesc.h:60
@ OPERAND_GLOBAL
Global index.
@ OPERAND_OFFSET64
64-bit unsigned memory offsets.
@ OPERAND_I32IMM
32-bit integer immediates.
@ OPERAND_P2ALIGN
p2align immediate for load and store address alignment.
@ OPERAND_TABLE
32-bit unsigned table number.
@ OPERAND_VEC_I64IMM
64-bit vector lane immediate
@ OPERAND_VEC_I16IMM
16-bit vector lane immediate
@ OPERAND_TYPEINDEX
type signature immediate for call_indirect.
@ OPERAND_FUNCTION32
32-bit unsigned function indices.
@ OPERAND_F32IMM
32-bit floating-point immediates.
@ OPERAND_BASIC_BLOCK
Basic block label in a branch construct.
@ OPERAND_VEC_I32IMM
32-bit vector lane immediate
@ OPERAND_BRLIST
A list of branch targets for br_list.
@ OPERAND_F64IMM
64-bit floating-point immediates.
@ OPERAND_VEC_I8IMM
8-bit vector lane immediate
@ OPERAND_SIGNATURE
signature immediate for block/loop.
@ OPERAND_I64IMM
64-bit integer immediates.
@ OPERAND_OFFSET32
32-bit unsigned memory offsets.
const char * anyTypeToString(unsigned Type)
@ WASM_SYMBOL_TYPE_SECTION
Definition: Wasm.h:211
@ WASM_SYMBOL_TYPE_FUNCTION
Definition: Wasm.h:208
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
raw_fd_ostream & outs()
This returns a reference to a raw_fd_ostream for standard output.
uint64_t decodeULEB128(const uint8_t *p, unsigned *n=nullptr, const uint8_t *end=nullptr, const char **error=nullptr)
Utility function to decode a ULEB128 value.
Definition: LEB128.h:131
int64_t decodeSLEB128(const uint8_t *p, unsigned *n=nullptr, const uint8_t *end=nullptr, const char **error=nullptr)
Utility function to decode a SLEB128 value.
Definition: LEB128.h:165
Target & getTheWebAssemblyTarget32()
Target & getTheWebAssemblyTarget64()
#define N
static void RegisterMCDisassembler(Target &T, Target::MCDisassemblerCtorTy Fn)
RegisterMCDisassembler - Register a MCDisassembler implementation for the given target.