LLVM 17.0.0git
WebAssemblyAsmTypeCheck.cpp
Go to the documentation of this file.
1//==- WebAssemblyAsmTypeCheck.cpp - Assembler 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 Assembler.
11///
12/// It contains code to translate a parsed .s file into MCInsts.
13///
14//===----------------------------------------------------------------------===//
15
21#include "WebAssembly.h"
22#include "llvm/MC/MCContext.h"
23#include "llvm/MC/MCExpr.h"
24#include "llvm/MC/MCInst.h"
25#include "llvm/MC/MCInstrInfo.h"
29#include "llvm/MC/MCStreamer.h"
31#include "llvm/MC/MCSymbol.h"
35#include "llvm/Support/Endian.h"
37
38using namespace llvm;
39
40#define DEBUG_TYPE "wasm-asm-parser"
41
42extern StringRef GetMnemonic(unsigned Opc);
43
44namespace llvm {
45
47 const MCInstrInfo &MII, bool is64)
48 : Parser(Parser), MII(MII), is64(is64) {
49}
50
52 LocalTypes.assign(Sig.Params.begin(), Sig.Params.end());
53 ReturnTypes.assign(Sig.Returns.begin(), Sig.Returns.end());
54}
55
57 LocalTypes.insert(LocalTypes.end(), Locals.begin(), Locals.end());
58}
59
60void WebAssemblyAsmTypeCheck::dumpTypeStack(Twine Msg) {
62 std::string s;
63 for (auto VT : Stack) {
65 s += " ";
66 }
67 dbgs() << Msg << s << '\n';
68 });
69}
70
71bool WebAssemblyAsmTypeCheck::typeError(SMLoc ErrorLoc, const Twine &Msg) {
72 // Once you get one type error in a function, it will likely trigger more
73 // which are mostly not helpful.
74 if (TypeErrorThisFunction)
75 return true;
76 // If we're currently in unreachable code, we suppress errors completely.
77 if (Unreachable)
78 return false;
79 TypeErrorThisFunction = true;
80 dumpTypeStack("current stack: ");
81 return Parser.Error(ErrorLoc, Msg);
82}
83
84bool WebAssemblyAsmTypeCheck::popType(SMLoc ErrorLoc,
85 std::optional<wasm::ValType> EVT) {
86 if (Stack.empty()) {
87 return typeError(ErrorLoc,
88 EVT ? StringRef("empty stack while popping ") +
90 : StringRef("empty stack while popping value"));
91 }
92 auto PVT = Stack.pop_back_val();
93 if (EVT && *EVT != PVT) {
94 return typeError(ErrorLoc,
95 StringRef("popped ") + WebAssembly::typeToString(PVT) +
96 ", expected " + WebAssembly::typeToString(*EVT));
97 }
98 return false;
99}
100
101bool WebAssemblyAsmTypeCheck::popRefType(SMLoc ErrorLoc) {
102 if (Stack.empty()) {
103 return typeError(ErrorLoc, StringRef("empty stack while popping reftype"));
104 }
105 auto PVT = Stack.pop_back_val();
106 if (!WebAssembly::isRefType(PVT)) {
107 return typeError(ErrorLoc, StringRef("popped ") +
109 ", expected reftype");
110 }
111 return false;
112}
113
114bool WebAssemblyAsmTypeCheck::getLocal(SMLoc ErrorLoc, const MCInst &Inst,
116 auto Local = static_cast<size_t>(Inst.getOperand(0).getImm());
117 if (Local >= LocalTypes.size())
118 return typeError(ErrorLoc, StringRef("no local type specified for index ") +
119 std::to_string(Local));
120 Type = LocalTypes[Local];
121 return false;
122}
123
124bool WebAssemblyAsmTypeCheck::checkEnd(SMLoc ErrorLoc, bool PopVals) {
125 if (LastSig.Returns.size() > Stack.size())
126 return typeError(ErrorLoc, "end: insufficient values on the type stack");
127
128 if (PopVals) {
129 for (auto VT : llvm::reverse(LastSig.Returns)) {
130 if (popType(ErrorLoc, VT))
131 return true;
132 }
133 return false;
134 }
135
136 for (size_t i = 0; i < LastSig.Returns.size(); i++) {
137 auto EVT = LastSig.Returns[i];
138 auto PVT = Stack[Stack.size() - LastSig.Returns.size() + i];
139 if (PVT != EVT)
140 return typeError(
141 ErrorLoc, StringRef("end got ") + WebAssembly::typeToString(PVT) +
142 ", expected " + WebAssembly::typeToString(EVT));
143 }
144 return false;
145}
146
147bool WebAssemblyAsmTypeCheck::checkSig(SMLoc ErrorLoc,
148 const wasm::WasmSignature& Sig) {
149 for (auto VT : llvm::reverse(Sig.Params))
150 if (popType(ErrorLoc, VT)) return true;
151 Stack.insert(Stack.end(), Sig.Returns.begin(), Sig.Returns.end());
152 return false;
153}
154
155bool WebAssemblyAsmTypeCheck::getSymRef(SMLoc ErrorLoc, const MCInst &Inst,
156 const MCSymbolRefExpr *&SymRef) {
157 auto Op = Inst.getOperand(0);
158 if (!Op.isExpr())
159 return typeError(ErrorLoc, StringRef("expected expression operand"));
160 SymRef = dyn_cast<MCSymbolRefExpr>(Op.getExpr());
161 if (!SymRef)
162 return typeError(ErrorLoc, StringRef("expected symbol operand"));
163 return false;
164}
165
166bool WebAssemblyAsmTypeCheck::getGlobal(SMLoc ErrorLoc, const MCInst &Inst,
168 const MCSymbolRefExpr *SymRef;
169 if (getSymRef(ErrorLoc, Inst, SymRef))
170 return true;
171 auto WasmSym = cast<MCSymbolWasm>(&SymRef->getSymbol());
172 switch (WasmSym->getType().value_or(wasm::WASM_SYMBOL_TYPE_DATA)) {
174 Type = static_cast<wasm::ValType>(WasmSym->getGlobalType().Type);
175 break;
178 switch (SymRef->getKind()) {
182 return false;
183 default:
184 break;
185 }
186 [[fallthrough]];
187 default:
188 return typeError(ErrorLoc, StringRef("symbol ") + WasmSym->getName() +
189 " missing .globaltype");
190 }
191 return false;
192}
193
194bool WebAssemblyAsmTypeCheck::getTable(SMLoc ErrorLoc, const MCInst &Inst,
196 const MCSymbolRefExpr *SymRef;
197 if (getSymRef(ErrorLoc, Inst, SymRef))
198 return true;
199 auto WasmSym = cast<MCSymbolWasm>(&SymRef->getSymbol());
200 if (WasmSym->getType().value_or(wasm::WASM_SYMBOL_TYPE_DATA) !=
202 return typeError(ErrorLoc, StringRef("symbol ") + WasmSym->getName() +
203 " missing .tabletype");
204 Type = static_cast<wasm::ValType>(WasmSym->getTableType().ElemType);
205 return false;
206}
207
209 // Check the return types.
210 for (auto RVT : llvm::reverse(ReturnTypes)) {
211 if (popType(ErrorLoc, RVT))
212 return true;
213 }
214 if (!Stack.empty()) {
215 return typeError(ErrorLoc, std::to_string(Stack.size()) +
216 " superfluous return values");
217 }
218 Unreachable = true;
219 return false;
220}
221
224 auto Opc = Inst.getOpcode();
225 auto Name = GetMnemonic(Opc);
226 dumpTypeStack("typechecking " + Name + ": ");
228 if (Name == "local.get") {
229 if (getLocal(Operands[1]->getStartLoc(), Inst, Type))
230 return true;
231 Stack.push_back(Type);
232 } else if (Name == "local.set") {
233 if (getLocal(Operands[1]->getStartLoc(), Inst, Type))
234 return true;
235 if (popType(ErrorLoc, Type))
236 return true;
237 } else if (Name == "local.tee") {
238 if (getLocal(Operands[1]->getStartLoc(), Inst, Type))
239 return true;
240 if (popType(ErrorLoc, Type))
241 return true;
242 Stack.push_back(Type);
243 } else if (Name == "global.get") {
244 if (getGlobal(Operands[1]->getStartLoc(), Inst, Type))
245 return true;
246 Stack.push_back(Type);
247 } else if (Name == "global.set") {
248 if (getGlobal(Operands[1]->getStartLoc(), Inst, Type))
249 return true;
250 if (popType(ErrorLoc, Type))
251 return true;
252 } else if (Name == "table.get") {
253 if (getTable(Operands[1]->getStartLoc(), Inst, Type))
254 return true;
255 if (popType(ErrorLoc, wasm::ValType::I32))
256 return true;
257 Stack.push_back(Type);
258 } else if (Name == "table.set") {
259 if (getTable(Operands[1]->getStartLoc(), Inst, Type))
260 return true;
261 if (popType(ErrorLoc, Type))
262 return true;
263 if (popType(ErrorLoc, wasm::ValType::I32))
264 return true;
265 } else if (Name == "table.fill") {
266 if (getTable(Operands[1]->getStartLoc(), Inst, Type))
267 return true;
268 if (popType(ErrorLoc, wasm::ValType::I32))
269 return true;
270 if (popType(ErrorLoc, Type))
271 return true;
272 if (popType(ErrorLoc, wasm::ValType::I32))
273 return true;
274 } else if (Name == "drop") {
275 if (popType(ErrorLoc, {}))
276 return true;
277 } else if (Name == "end_block" || Name == "end_loop" || Name == "end_if" ||
278 Name == "else" || Name == "end_try") {
279 if (checkEnd(ErrorLoc, Name == "else"))
280 return true;
281 if (Name == "end_block")
282 Unreachable = false;
283 } else if (Name == "return") {
284 if (endOfFunction(ErrorLoc))
285 return true;
286 } else if (Name == "call_indirect" || Name == "return_call_indirect") {
287 // Function value.
288 if (popType(ErrorLoc, wasm::ValType::I32)) return true;
289 if (checkSig(ErrorLoc, LastSig)) return true;
290 if (Name == "return_call_indirect" && endOfFunction(ErrorLoc))
291 return true;
292 } else if (Name == "call" || Name == "return_call") {
293 const MCSymbolRefExpr *SymRef;
294 if (getSymRef(Operands[1]->getStartLoc(), Inst, SymRef))
295 return true;
296 auto WasmSym = cast<MCSymbolWasm>(&SymRef->getSymbol());
297 auto Sig = WasmSym->getSignature();
298 if (!Sig || WasmSym->getType() != wasm::WASM_SYMBOL_TYPE_FUNCTION)
299 return typeError(Operands[1]->getStartLoc(), StringRef("symbol ") +
300 WasmSym->getName() +
301 " missing .functype");
302 if (checkSig(ErrorLoc, *Sig)) return true;
303 if (Name == "return_call" && endOfFunction(ErrorLoc))
304 return true;
305 } else if (Name == "catch") {
306 const MCSymbolRefExpr *SymRef;
307 if (getSymRef(Operands[1]->getStartLoc(), Inst, SymRef))
308 return true;
309 const auto *WasmSym = cast<MCSymbolWasm>(&SymRef->getSymbol());
310 const auto *Sig = WasmSym->getSignature();
311 if (!Sig || WasmSym->getType() != wasm::WASM_SYMBOL_TYPE_TAG)
312 return typeError(Operands[1]->getStartLoc(), StringRef("symbol ") +
313 WasmSym->getName() +
314 " missing .tagtype");
315 // catch instruction pushes values whose types are specified in the tag's
316 // "params" part
317 Stack.insert(Stack.end(), Sig->Params.begin(), Sig->Params.end());
318 } else if (Name == "unreachable") {
319 Unreachable = true;
320 } else if (Name == "ref.is_null") {
321 if (popRefType(ErrorLoc))
322 return true;
324 } else {
325 // The current instruction is a stack instruction which doesn't have
326 // explicit operands that indicate push/pop types, so we get those from
327 // the register version of the same instruction.
328 auto RegOpc = WebAssembly::getRegisterOpcode(Opc);
329 assert(RegOpc != -1 && "Failed to get register version of MC instruction");
330 const auto &II = MII.get(RegOpc);
331 // First pop all the uses off the stack and check them.
332 for (unsigned I = II.getNumOperands(); I > II.getNumDefs(); I--) {
333 const auto &Op = II.operands()[I - 1];
334 if (Op.OperandType == MCOI::OPERAND_REGISTER) {
335 auto VT = WebAssembly::regClassToValType(Op.RegClass);
336 if (popType(ErrorLoc, VT))
337 return true;
338 }
339 }
340 // Now push all the defs onto the stack.
341 for (unsigned I = 0; I < II.getNumDefs(); I++) {
342 const auto &Op = II.operands()[I];
343 assert(Op.OperandType == MCOI::OPERAND_REGISTER && "Register expected");
344 auto VT = WebAssembly::regClassToValType(Op.RegClass);
345 Stack.push_back(VT);
346 }
347 }
348 return false;
349}
350
351} // end namespace llvm
#define LLVM_DEBUG(X)
Definition: Debug.h:101
std::string Name
#define I(x, y, z)
Definition: MD5.cpp:58
mir Rename Register Operands
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef GetMnemonic(unsigned Opc)
StringRef GetMnemonic(unsigned Opc)
This file is part of the WebAssembly Assembler.
This file provides WebAssembly-specific target descriptions.
This file contains the declaration of the WebAssembly-specific type parsing utility functions.
This file registers the WebAssembly target.
This file declares WebAssembly-specific target streamer classes.
This file contains the entry points for global functions defined in the LLVM WebAssembly back-end.
Generic assembler parser interface, for use by target specific assembly parsers.
Definition: MCAsmParser.h:123
bool Error(SMLoc L, const Twine &Msg, SMRange Range=std::nullopt)
Return an error at the location L, with the message Msg.
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
unsigned getOpcode() const
Definition: MCInst.h:198
const MCOperand & getOperand(unsigned i) const
Definition: MCInst.h:206
Interface to description of machine instruction set.
Definition: MCInstrInfo.h:26
const MCInstrDesc & get(unsigned Opcode) const
Return the machine instruction descriptor that corresponds to the specified instruction opcode.
Definition: MCInstrInfo.h:63
int64_t getImm() const
Definition: MCInst.h:80
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
const MCSymbol & getSymbol() const
Definition: MCExpr.h:399
VariantKind getKind() const
Definition: MCExpr.h:401
Represents a location in source code.
Definition: SMLoc.h:23
bool empty() const
Definition: SmallVector.h:94
size_t size() const
Definition: SmallVector.h:91
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:577
void assign(size_type NumElts, ValueParamT Elt)
Definition: SmallVector.h:708
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:809
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
void funcDecl(const wasm::WasmSignature &Sig)
WebAssemblyAsmTypeCheck(MCAsmParser &Parser, const MCInstrInfo &MII, bool is64)
bool typeCheck(SMLoc ErrorLoc, const MCInst &Inst, OperandVector &Operands)
void localDecl(const SmallVector< wasm::ValType, 4 > &Locals)
@ OPERAND_REGISTER
Definition: MCInstrDesc.h:61
const char * typeToString(wasm::ValType Type)
wasm::ValType regClassToValType(unsigned RC)
bool isRefType(wasm::ValType Type)
int getRegisterOpcode(unsigned short Opcode)
@ WASM_SYMBOL_TYPE_GLOBAL
Definition: Wasm.h:385
@ WASM_SYMBOL_TYPE_DATA
Definition: Wasm.h:384
@ WASM_SYMBOL_TYPE_TAG
Definition: Wasm.h:387
@ WASM_SYMBOL_TYPE_TABLE
Definition: Wasm.h:388
@ WASM_SYMBOL_TYPE_FUNCTION
Definition: Wasm.h:383
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:511
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
Extended Value Type.
Definition: ValueTypes.h:34
SmallVector< ValType, 1 > Returns
Definition: Wasm.h:435
SmallVector< ValType, 4 > Params
Definition: Wasm.h:436