1 //==- WebAssemblyAsmParser.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
16 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
17 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
18 #include "TargetInfo/WebAssemblyTargetInfo.h"
19 #include "WebAssembly.h"
20 #include "llvm/MC/MCContext.h"
21 #include "llvm/MC/MCExpr.h"
22 #include "llvm/MC/MCInst.h"
23 #include "llvm/MC/MCInstrInfo.h"
24 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
25 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
26 #include "llvm/MC/MCSectionWasm.h"
27 #include "llvm/MC/MCStreamer.h"
28 #include "llvm/MC/MCSubtargetInfo.h"
29 #include "llvm/MC/MCSymbol.h"
30 #include "llvm/MC/MCSymbolWasm.h"
31 #include "llvm/Support/Endian.h"
32 #include "llvm/Support/TargetRegistry.h"
33
34 using namespace llvm;
35
36 #define DEBUG_TYPE "wasm-asm-parser"
37
38 namespace {
39
40 /// WebAssemblyOperand - Instances of this class represent the operands in a
41 /// parsed WASM machine instruction.
42 struct WebAssemblyOperand : public MCParsedAsmOperand {
43 enum KindTy { Token, Integer, Float, Symbol, BrList } Kind;
44
45 SMLoc StartLoc, EndLoc;
46
47 struct TokOp {
48 StringRef Tok;
49 };
50
51 struct IntOp {
52 int64_t Val;
53 };
54
55 struct FltOp {
56 double Val;
57 };
58
59 struct SymOp {
60 const MCExpr *Exp;
61 };
62
63 struct BrLOp {
64 std::vector<unsigned> List;
65 };
66
67 union {
68 struct TokOp Tok;
69 struct IntOp Int;
70 struct FltOp Flt;
71 struct SymOp Sym;
72 struct BrLOp BrL;
73 };
74
WebAssemblyOperand__anon0a5c95c20111::WebAssemblyOperand75 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, TokOp T)
76 : Kind(K), StartLoc(Start), EndLoc(End), Tok(T) {}
WebAssemblyOperand__anon0a5c95c20111::WebAssemblyOperand77 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, IntOp I)
78 : Kind(K), StartLoc(Start), EndLoc(End), Int(I) {}
WebAssemblyOperand__anon0a5c95c20111::WebAssemblyOperand79 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, FltOp F)
80 : Kind(K), StartLoc(Start), EndLoc(End), Flt(F) {}
WebAssemblyOperand__anon0a5c95c20111::WebAssemblyOperand81 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, SymOp S)
82 : Kind(K), StartLoc(Start), EndLoc(End), Sym(S) {}
WebAssemblyOperand__anon0a5c95c20111::WebAssemblyOperand83 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End)
84 : Kind(K), StartLoc(Start), EndLoc(End), BrL() {}
85
~WebAssemblyOperand__anon0a5c95c20111::WebAssemblyOperand86 ~WebAssemblyOperand() {
87 if (isBrList())
88 BrL.~BrLOp();
89 }
90
isToken__anon0a5c95c20111::WebAssemblyOperand91 bool isToken() const override { return Kind == Token; }
isImm__anon0a5c95c20111::WebAssemblyOperand92 bool isImm() const override { return Kind == Integer || Kind == Symbol; }
isFPImm__anon0a5c95c20111::WebAssemblyOperand93 bool isFPImm() const { return Kind == Float; }
isMem__anon0a5c95c20111::WebAssemblyOperand94 bool isMem() const override { return false; }
isReg__anon0a5c95c20111::WebAssemblyOperand95 bool isReg() const override { return false; }
isBrList__anon0a5c95c20111::WebAssemblyOperand96 bool isBrList() const { return Kind == BrList; }
97
getReg__anon0a5c95c20111::WebAssemblyOperand98 unsigned getReg() const override {
99 llvm_unreachable("Assembly inspects a register operand");
100 return 0;
101 }
102
getToken__anon0a5c95c20111::WebAssemblyOperand103 StringRef getToken() const {
104 assert(isToken());
105 return Tok.Tok;
106 }
107
getStartLoc__anon0a5c95c20111::WebAssemblyOperand108 SMLoc getStartLoc() const override { return StartLoc; }
getEndLoc__anon0a5c95c20111::WebAssemblyOperand109 SMLoc getEndLoc() const override { return EndLoc; }
110
addRegOperands__anon0a5c95c20111::WebAssemblyOperand111 void addRegOperands(MCInst &, unsigned) const {
112 // Required by the assembly matcher.
113 llvm_unreachable("Assembly matcher creates register operands");
114 }
115
addImmOperands__anon0a5c95c20111::WebAssemblyOperand116 void addImmOperands(MCInst &Inst, unsigned N) const {
117 assert(N == 1 && "Invalid number of operands!");
118 if (Kind == Integer)
119 Inst.addOperand(MCOperand::createImm(Int.Val));
120 else if (Kind == Symbol)
121 Inst.addOperand(MCOperand::createExpr(Sym.Exp));
122 else
123 llvm_unreachable("Should be integer immediate or symbol!");
124 }
125
addFPImmOperands__anon0a5c95c20111::WebAssemblyOperand126 void addFPImmOperands(MCInst &Inst, unsigned N) const {
127 assert(N == 1 && "Invalid number of operands!");
128 if (Kind == Float)
129 Inst.addOperand(MCOperand::createFPImm(Flt.Val));
130 else
131 llvm_unreachable("Should be float immediate!");
132 }
133
addBrListOperands__anon0a5c95c20111::WebAssemblyOperand134 void addBrListOperands(MCInst &Inst, unsigned N) const {
135 assert(N == 1 && isBrList() && "Invalid BrList!");
136 for (auto Br : BrL.List)
137 Inst.addOperand(MCOperand::createImm(Br));
138 }
139
print__anon0a5c95c20111::WebAssemblyOperand140 void print(raw_ostream &OS) const override {
141 switch (Kind) {
142 case Token:
143 OS << "Tok:" << Tok.Tok;
144 break;
145 case Integer:
146 OS << "Int:" << Int.Val;
147 break;
148 case Float:
149 OS << "Flt:" << Flt.Val;
150 break;
151 case Symbol:
152 OS << "Sym:" << Sym.Exp;
153 break;
154 case BrList:
155 OS << "BrList:" << BrL.List.size();
156 break;
157 }
158 }
159 };
160
161 class WebAssemblyAsmParser final : public MCTargetAsmParser {
162 MCAsmParser &Parser;
163 MCAsmLexer &Lexer;
164
165 // Much like WebAssemblyAsmPrinter in the backend, we have to own these.
166 std::vector<std::unique_ptr<wasm::WasmSignature>> Signatures;
167
168 // Order of labels, directives and instructions in a .s file have no
169 // syntactical enforcement. This class is a callback from the actual parser,
170 // and yet we have to be feeding data to the streamer in a very particular
171 // order to ensure a correct binary encoding that matches the regular backend
172 // (the streamer does not enforce this). This "state machine" enum helps
173 // guarantee that correct order.
174 enum ParserState {
175 FileStart,
176 Label,
177 FunctionStart,
178 FunctionLocals,
179 Instructions,
180 EndFunction,
181 DataSection,
182 } CurrentState = FileStart;
183
184 // For ensuring blocks are properly nested.
185 enum NestingType {
186 Function,
187 Block,
188 Loop,
189 Try,
190 If,
191 Else,
192 Undefined,
193 };
194 std::vector<NestingType> NestingStack;
195
196 // We track this to see if a .functype following a label is the same,
197 // as this is how we recognize the start of a function.
198 MCSymbol *LastLabel = nullptr;
199 MCSymbol *LastFunctionLabel = nullptr;
200
201 public:
WebAssemblyAsmParser(const MCSubtargetInfo & STI,MCAsmParser & Parser,const MCInstrInfo & MII,const MCTargetOptions & Options)202 WebAssemblyAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser,
203 const MCInstrInfo &MII, const MCTargetOptions &Options)
204 : MCTargetAsmParser(Options, STI, MII), Parser(Parser),
205 Lexer(Parser.getLexer()) {
206 setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
207 }
208
209 #define GET_ASSEMBLER_HEADER
210 #include "WebAssemblyGenAsmMatcher.inc"
211
212 // TODO: This is required to be implemented, but appears unused.
ParseRegister(unsigned &,SMLoc &,SMLoc &)213 bool ParseRegister(unsigned & /*RegNo*/, SMLoc & /*StartLoc*/,
214 SMLoc & /*EndLoc*/) override {
215 llvm_unreachable("ParseRegister is not implemented.");
216 }
217
error(const Twine & Msg,const AsmToken & Tok)218 bool error(const Twine &Msg, const AsmToken &Tok) {
219 return Parser.Error(Tok.getLoc(), Msg + Tok.getString());
220 }
221
error(const Twine & Msg)222 bool error(const Twine &Msg) {
223 return Parser.Error(Lexer.getTok().getLoc(), Msg);
224 }
225
addSignature(std::unique_ptr<wasm::WasmSignature> && Sig)226 void addSignature(std::unique_ptr<wasm::WasmSignature> &&Sig) {
227 Signatures.push_back(std::move(Sig));
228 }
229
nestingString(NestingType NT)230 std::pair<StringRef, StringRef> nestingString(NestingType NT) {
231 switch (NT) {
232 case Function:
233 return {"function", "end_function"};
234 case Block:
235 return {"block", "end_block"};
236 case Loop:
237 return {"loop", "end_loop"};
238 case Try:
239 return {"try", "end_try"};
240 case If:
241 return {"if", "end_if"};
242 case Else:
243 return {"else", "end_if"};
244 default:
245 llvm_unreachable("unknown NestingType");
246 }
247 }
248
push(NestingType NT)249 void push(NestingType NT) { NestingStack.push_back(NT); }
250
pop(StringRef Ins,NestingType NT1,NestingType NT2=Undefined)251 bool pop(StringRef Ins, NestingType NT1, NestingType NT2 = Undefined) {
252 if (NestingStack.empty())
253 return error(Twine("End of block construct with no start: ") + Ins);
254 auto Top = NestingStack.back();
255 if (Top != NT1 && Top != NT2)
256 return error(Twine("Block construct type mismatch, expected: ") +
257 nestingString(Top).second + ", instead got: " + Ins);
258 NestingStack.pop_back();
259 return false;
260 }
261
ensureEmptyNestingStack()262 bool ensureEmptyNestingStack() {
263 auto Err = !NestingStack.empty();
264 while (!NestingStack.empty()) {
265 error(Twine("Unmatched block construct(s) at function end: ") +
266 nestingString(NestingStack.back()).first);
267 NestingStack.pop_back();
268 }
269 return Err;
270 }
271
isNext(AsmToken::TokenKind Kind)272 bool isNext(AsmToken::TokenKind Kind) {
273 auto Ok = Lexer.is(Kind);
274 if (Ok)
275 Parser.Lex();
276 return Ok;
277 }
278
expect(AsmToken::TokenKind Kind,const char * KindName)279 bool expect(AsmToken::TokenKind Kind, const char *KindName) {
280 if (!isNext(Kind))
281 return error(std::string("Expected ") + KindName + ", instead got: ",
282 Lexer.getTok());
283 return false;
284 }
285
expectIdent()286 StringRef expectIdent() {
287 if (!Lexer.is(AsmToken::Identifier)) {
288 error("Expected identifier, got: ", Lexer.getTok());
289 return StringRef();
290 }
291 auto Name = Lexer.getTok().getString();
292 Parser.Lex();
293 return Name;
294 }
295
parseType(const StringRef & Type)296 Optional<wasm::ValType> parseType(const StringRef &Type) {
297 // FIXME: can't use StringSwitch because wasm::ValType doesn't have a
298 // "invalid" value.
299 if (Type == "i32")
300 return wasm::ValType::I32;
301 if (Type == "i64")
302 return wasm::ValType::I64;
303 if (Type == "f32")
304 return wasm::ValType::F32;
305 if (Type == "f64")
306 return wasm::ValType::F64;
307 if (Type == "v128" || Type == "i8x16" || Type == "i16x8" ||
308 Type == "i32x4" || Type == "i64x2" || Type == "f32x4" ||
309 Type == "f64x2")
310 return wasm::ValType::V128;
311 if (Type == "exnref")
312 return wasm::ValType::EXNREF;
313 return Optional<wasm::ValType>();
314 }
315
parseBlockType(StringRef ID)316 WebAssembly::BlockType parseBlockType(StringRef ID) {
317 // Multivalue block types are handled separately in parseSignature
318 return StringSwitch<WebAssembly::BlockType>(ID)
319 .Case("i32", WebAssembly::BlockType::I32)
320 .Case("i64", WebAssembly::BlockType::I64)
321 .Case("f32", WebAssembly::BlockType::F32)
322 .Case("f64", WebAssembly::BlockType::F64)
323 .Case("v128", WebAssembly::BlockType::V128)
324 .Case("exnref", WebAssembly::BlockType::Exnref)
325 .Case("void", WebAssembly::BlockType::Void)
326 .Default(WebAssembly::BlockType::Invalid);
327 }
328
parseRegTypeList(SmallVectorImpl<wasm::ValType> & Types)329 bool parseRegTypeList(SmallVectorImpl<wasm::ValType> &Types) {
330 while (Lexer.is(AsmToken::Identifier)) {
331 auto Type = parseType(Lexer.getTok().getString());
332 if (!Type)
333 return error("unknown type: ", Lexer.getTok());
334 Types.push_back(Type.getValue());
335 Parser.Lex();
336 if (!isNext(AsmToken::Comma))
337 break;
338 }
339 return false;
340 }
341
parseSingleInteger(bool IsNegative,OperandVector & Operands)342 void parseSingleInteger(bool IsNegative, OperandVector &Operands) {
343 auto &Int = Lexer.getTok();
344 int64_t Val = Int.getIntVal();
345 if (IsNegative)
346 Val = -Val;
347 Operands.push_back(std::make_unique<WebAssemblyOperand>(
348 WebAssemblyOperand::Integer, Int.getLoc(), Int.getEndLoc(),
349 WebAssemblyOperand::IntOp{Val}));
350 Parser.Lex();
351 }
352
parseSingleFloat(bool IsNegative,OperandVector & Operands)353 bool parseSingleFloat(bool IsNegative, OperandVector &Operands) {
354 auto &Flt = Lexer.getTok();
355 double Val;
356 if (Flt.getString().getAsDouble(Val, false))
357 return error("Cannot parse real: ", Flt);
358 if (IsNegative)
359 Val = -Val;
360 Operands.push_back(std::make_unique<WebAssemblyOperand>(
361 WebAssemblyOperand::Float, Flt.getLoc(), Flt.getEndLoc(),
362 WebAssemblyOperand::FltOp{Val}));
363 Parser.Lex();
364 return false;
365 }
366
parseSpecialFloatMaybe(bool IsNegative,OperandVector & Operands)367 bool parseSpecialFloatMaybe(bool IsNegative, OperandVector &Operands) {
368 if (Lexer.isNot(AsmToken::Identifier))
369 return true;
370 auto &Flt = Lexer.getTok();
371 auto S = Flt.getString();
372 double Val;
373 if (S.compare_lower("infinity") == 0) {
374 Val = std::numeric_limits<double>::infinity();
375 } else if (S.compare_lower("nan") == 0) {
376 Val = std::numeric_limits<double>::quiet_NaN();
377 } else {
378 return true;
379 }
380 if (IsNegative)
381 Val = -Val;
382 Operands.push_back(std::make_unique<WebAssemblyOperand>(
383 WebAssemblyOperand::Float, Flt.getLoc(), Flt.getEndLoc(),
384 WebAssemblyOperand::FltOp{Val}));
385 Parser.Lex();
386 return false;
387 }
388
checkForP2AlignIfLoadStore(OperandVector & Operands,StringRef InstName)389 bool checkForP2AlignIfLoadStore(OperandVector &Operands, StringRef InstName) {
390 // FIXME: there is probably a cleaner way to do this.
391 auto IsLoadStore = InstName.find(".load") != StringRef::npos ||
392 InstName.find(".store") != StringRef::npos;
393 auto IsAtomic = InstName.find("atomic.") != StringRef::npos;
394 if (IsLoadStore || IsAtomic) {
395 // Parse load/store operands of the form: offset:p2align=align
396 if (IsLoadStore && isNext(AsmToken::Colon)) {
397 auto Id = expectIdent();
398 if (Id != "p2align")
399 return error("Expected p2align, instead got: " + Id);
400 if (expect(AsmToken::Equal, "="))
401 return true;
402 if (!Lexer.is(AsmToken::Integer))
403 return error("Expected integer constant");
404 parseSingleInteger(false, Operands);
405 } else {
406 // Alignment not specified (or atomics, must use default alignment).
407 // We can't just call WebAssembly::GetDefaultP2Align since we don't have
408 // an opcode until after the assembly matcher, so set a default to fix
409 // up later.
410 auto Tok = Lexer.getTok();
411 Operands.push_back(std::make_unique<WebAssemblyOperand>(
412 WebAssemblyOperand::Integer, Tok.getLoc(), Tok.getEndLoc(),
413 WebAssemblyOperand::IntOp{-1}));
414 }
415 }
416 return false;
417 }
418
addBlockTypeOperand(OperandVector & Operands,SMLoc NameLoc,WebAssembly::BlockType BT)419 void addBlockTypeOperand(OperandVector &Operands, SMLoc NameLoc,
420 WebAssembly::BlockType BT) {
421 Operands.push_back(std::make_unique<WebAssemblyOperand>(
422 WebAssemblyOperand::Integer, NameLoc, NameLoc,
423 WebAssemblyOperand::IntOp{static_cast<int64_t>(BT)}));
424 }
425
ParseInstruction(ParseInstructionInfo &,StringRef Name,SMLoc NameLoc,OperandVector & Operands)426 bool ParseInstruction(ParseInstructionInfo & /*Info*/, StringRef Name,
427 SMLoc NameLoc, OperandVector &Operands) override {
428 // Note: Name does NOT point into the sourcecode, but to a local, so
429 // use NameLoc instead.
430 Name = StringRef(NameLoc.getPointer(), Name.size());
431
432 // WebAssembly has instructions with / in them, which AsmLexer parses
433 // as seperate tokens, so if we find such tokens immediately adjacent (no
434 // whitespace), expand the name to include them:
435 for (;;) {
436 auto &Sep = Lexer.getTok();
437 if (Sep.getLoc().getPointer() != Name.end() ||
438 Sep.getKind() != AsmToken::Slash)
439 break;
440 // Extend name with /
441 Name = StringRef(Name.begin(), Name.size() + Sep.getString().size());
442 Parser.Lex();
443 // We must now find another identifier, or error.
444 auto &Id = Lexer.getTok();
445 if (Id.getKind() != AsmToken::Identifier ||
446 Id.getLoc().getPointer() != Name.end())
447 return error("Incomplete instruction name: ", Id);
448 Name = StringRef(Name.begin(), Name.size() + Id.getString().size());
449 Parser.Lex();
450 }
451
452 // Now construct the name as first operand.
453 Operands.push_back(std::make_unique<WebAssemblyOperand>(
454 WebAssemblyOperand::Token, NameLoc, SMLoc::getFromPointer(Name.end()),
455 WebAssemblyOperand::TokOp{Name}));
456
457 // If this instruction is part of a control flow structure, ensure
458 // proper nesting.
459 bool ExpectBlockType = false;
460 bool ExpectFuncType = false;
461 if (Name == "block") {
462 push(Block);
463 ExpectBlockType = true;
464 } else if (Name == "loop") {
465 push(Loop);
466 ExpectBlockType = true;
467 } else if (Name == "try") {
468 push(Try);
469 ExpectBlockType = true;
470 } else if (Name == "if") {
471 push(If);
472 ExpectBlockType = true;
473 } else if (Name == "else") {
474 if (pop(Name, If))
475 return true;
476 push(Else);
477 } else if (Name == "catch") {
478 if (pop(Name, Try))
479 return true;
480 push(Try);
481 } else if (Name == "end_if") {
482 if (pop(Name, If, Else))
483 return true;
484 } else if (Name == "end_try") {
485 if (pop(Name, Try))
486 return true;
487 } else if (Name == "end_loop") {
488 if (pop(Name, Loop))
489 return true;
490 } else if (Name == "end_block") {
491 if (pop(Name, Block))
492 return true;
493 } else if (Name == "end_function") {
494 ensureLocals(getStreamer());
495 CurrentState = EndFunction;
496 if (pop(Name, Function) || ensureEmptyNestingStack())
497 return true;
498 } else if (Name == "call_indirect" || Name == "return_call_indirect") {
499 ExpectFuncType = true;
500 }
501
502 if (ExpectFuncType || (ExpectBlockType && Lexer.is(AsmToken::LParen))) {
503 // This has a special TYPEINDEX operand which in text we
504 // represent as a signature, such that we can re-build this signature,
505 // attach it to an anonymous symbol, which is what WasmObjectWriter
506 // expects to be able to recreate the actual unique-ified type indices.
507 auto Loc = Parser.getTok();
508 auto Signature = std::make_unique<wasm::WasmSignature>();
509 if (parseSignature(Signature.get()))
510 return true;
511 // Got signature as block type, don't need more
512 ExpectBlockType = false;
513 auto &Ctx = getStreamer().getContext();
514 // The "true" here will cause this to be a nameless symbol.
515 MCSymbol *Sym = Ctx.createTempSymbol("typeindex", true);
516 auto *WasmSym = cast<MCSymbolWasm>(Sym);
517 WasmSym->setSignature(Signature.get());
518 addSignature(std::move(Signature));
519 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
520 const MCExpr *Expr = MCSymbolRefExpr::create(
521 WasmSym, MCSymbolRefExpr::VK_WASM_TYPEINDEX, Ctx);
522 Operands.push_back(std::make_unique<WebAssemblyOperand>(
523 WebAssemblyOperand::Symbol, Loc.getLoc(), Loc.getEndLoc(),
524 WebAssemblyOperand::SymOp{Expr}));
525 }
526
527 while (Lexer.isNot(AsmToken::EndOfStatement)) {
528 auto &Tok = Lexer.getTok();
529 switch (Tok.getKind()) {
530 case AsmToken::Identifier: {
531 if (!parseSpecialFloatMaybe(false, Operands))
532 break;
533 auto &Id = Lexer.getTok();
534 if (ExpectBlockType) {
535 // Assume this identifier is a block_type.
536 auto BT = parseBlockType(Id.getString());
537 if (BT == WebAssembly::BlockType::Invalid)
538 return error("Unknown block type: ", Id);
539 addBlockTypeOperand(Operands, NameLoc, BT);
540 Parser.Lex();
541 } else {
542 // Assume this identifier is a label.
543 const MCExpr *Val;
544 SMLoc End;
545 if (Parser.parseExpression(Val, End))
546 return error("Cannot parse symbol: ", Lexer.getTok());
547 Operands.push_back(std::make_unique<WebAssemblyOperand>(
548 WebAssemblyOperand::Symbol, Id.getLoc(), Id.getEndLoc(),
549 WebAssemblyOperand::SymOp{Val}));
550 if (checkForP2AlignIfLoadStore(Operands, Name))
551 return true;
552 }
553 break;
554 }
555 case AsmToken::Minus:
556 Parser.Lex();
557 if (Lexer.is(AsmToken::Integer)) {
558 parseSingleInteger(true, Operands);
559 if (checkForP2AlignIfLoadStore(Operands, Name))
560 return true;
561 } else if(Lexer.is(AsmToken::Real)) {
562 if (parseSingleFloat(true, Operands))
563 return true;
564 } else if (!parseSpecialFloatMaybe(true, Operands)) {
565 } else {
566 return error("Expected numeric constant instead got: ",
567 Lexer.getTok());
568 }
569 break;
570 case AsmToken::Integer:
571 parseSingleInteger(false, Operands);
572 if (checkForP2AlignIfLoadStore(Operands, Name))
573 return true;
574 break;
575 case AsmToken::Real: {
576 if (parseSingleFloat(false, Operands))
577 return true;
578 break;
579 }
580 case AsmToken::LCurly: {
581 Parser.Lex();
582 auto Op = std::make_unique<WebAssemblyOperand>(
583 WebAssemblyOperand::BrList, Tok.getLoc(), Tok.getEndLoc());
584 if (!Lexer.is(AsmToken::RCurly))
585 for (;;) {
586 Op->BrL.List.push_back(Lexer.getTok().getIntVal());
587 expect(AsmToken::Integer, "integer");
588 if (!isNext(AsmToken::Comma))
589 break;
590 }
591 expect(AsmToken::RCurly, "}");
592 Operands.push_back(std::move(Op));
593 break;
594 }
595 default:
596 return error("Unexpected token in operand: ", Tok);
597 }
598 if (Lexer.isNot(AsmToken::EndOfStatement)) {
599 if (expect(AsmToken::Comma, ","))
600 return true;
601 }
602 }
603 if (ExpectBlockType && Operands.size() == 1) {
604 // Support blocks with no operands as default to void.
605 addBlockTypeOperand(Operands, NameLoc, WebAssembly::BlockType::Void);
606 }
607 Parser.Lex();
608 return false;
609 }
610
onLabelParsed(MCSymbol * Symbol)611 void onLabelParsed(MCSymbol *Symbol) override {
612 LastLabel = Symbol;
613 CurrentState = Label;
614 }
615
parseSignature(wasm::WasmSignature * Signature)616 bool parseSignature(wasm::WasmSignature *Signature) {
617 if (expect(AsmToken::LParen, "("))
618 return true;
619 if (parseRegTypeList(Signature->Params))
620 return true;
621 if (expect(AsmToken::RParen, ")"))
622 return true;
623 if (expect(AsmToken::MinusGreater, "->"))
624 return true;
625 if (expect(AsmToken::LParen, "("))
626 return true;
627 if (parseRegTypeList(Signature->Returns))
628 return true;
629 if (expect(AsmToken::RParen, ")"))
630 return true;
631 return false;
632 }
633
CheckDataSection()634 bool CheckDataSection() {
635 if (CurrentState != DataSection) {
636 auto WS = cast<MCSectionWasm>(getStreamer().getCurrentSection().first);
637 if (WS && WS->getKind().isText())
638 return error("data directive must occur in a data segment: ",
639 Lexer.getTok());
640 }
641 CurrentState = DataSection;
642 return false;
643 }
644
645 // This function processes wasm-specific directives streamed to
646 // WebAssemblyTargetStreamer, all others go to the generic parser
647 // (see WasmAsmParser).
ParseDirective(AsmToken DirectiveID)648 bool ParseDirective(AsmToken DirectiveID) override {
649 // This function has a really weird return value behavior that is different
650 // from all the other parsing functions:
651 // - return true && no tokens consumed -> don't know this directive / let
652 // the generic parser handle it.
653 // - return true && tokens consumed -> a parsing error occurred.
654 // - return false -> processed this directive successfully.
655 assert(DirectiveID.getKind() == AsmToken::Identifier);
656 auto &Out = getStreamer();
657 auto &TOut =
658 reinterpret_cast<WebAssemblyTargetStreamer &>(*Out.getTargetStreamer());
659 auto &Ctx = Out.getContext();
660
661 // TODO: any time we return an error, at least one token must have been
662 // consumed, otherwise this will not signal an error to the caller.
663 if (DirectiveID.getString() == ".globaltype") {
664 auto SymName = expectIdent();
665 if (SymName.empty())
666 return true;
667 if (expect(AsmToken::Comma, ","))
668 return true;
669 auto TypeTok = Lexer.getTok();
670 auto TypeName = expectIdent();
671 if (TypeName.empty())
672 return true;
673 auto Type = parseType(TypeName);
674 if (!Type)
675 return error("Unknown type in .globaltype directive: ", TypeTok);
676 // Now set this symbol with the correct type.
677 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
678 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
679 WasmSym->setGlobalType(
680 wasm::WasmGlobalType{uint8_t(Type.getValue()), true});
681 // And emit the directive again.
682 TOut.emitGlobalType(WasmSym);
683 return expect(AsmToken::EndOfStatement, "EOL");
684 }
685
686 if (DirectiveID.getString() == ".functype") {
687 // This code has to send things to the streamer similar to
688 // WebAssemblyAsmPrinter::EmitFunctionBodyStart.
689 // TODO: would be good to factor this into a common function, but the
690 // assembler and backend really don't share any common code, and this code
691 // parses the locals seperately.
692 auto SymName = expectIdent();
693 if (SymName.empty())
694 return true;
695 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
696 if (CurrentState == Label && WasmSym == LastLabel) {
697 // This .functype indicates a start of a function.
698 if (ensureEmptyNestingStack())
699 return true;
700 CurrentState = FunctionStart;
701 LastFunctionLabel = LastLabel;
702 push(Function);
703 }
704 auto Signature = std::make_unique<wasm::WasmSignature>();
705 if (parseSignature(Signature.get()))
706 return true;
707 WasmSym->setSignature(Signature.get());
708 addSignature(std::move(Signature));
709 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
710 TOut.emitFunctionType(WasmSym);
711 // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
712 return expect(AsmToken::EndOfStatement, "EOL");
713 }
714
715 if (DirectiveID.getString() == ".export_name") {
716 auto SymName = expectIdent();
717 if (SymName.empty())
718 return true;
719 if (expect(AsmToken::Comma, ","))
720 return true;
721 auto ExportName = expectIdent();
722 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
723 WasmSym->setExportName(ExportName);
724 TOut.emitExportName(WasmSym, ExportName);
725 }
726
727 if (DirectiveID.getString() == ".import_module") {
728 auto SymName = expectIdent();
729 if (SymName.empty())
730 return true;
731 if (expect(AsmToken::Comma, ","))
732 return true;
733 auto ImportModule = expectIdent();
734 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
735 WasmSym->setImportModule(ImportModule);
736 TOut.emitImportModule(WasmSym, ImportModule);
737 }
738
739 if (DirectiveID.getString() == ".import_name") {
740 auto SymName = expectIdent();
741 if (SymName.empty())
742 return true;
743 if (expect(AsmToken::Comma, ","))
744 return true;
745 auto ImportName = expectIdent();
746 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
747 WasmSym->setImportName(ImportName);
748 TOut.emitImportName(WasmSym, ImportName);
749 }
750
751 if (DirectiveID.getString() == ".eventtype") {
752 auto SymName = expectIdent();
753 if (SymName.empty())
754 return true;
755 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
756 auto Signature = std::make_unique<wasm::WasmSignature>();
757 if (parseRegTypeList(Signature->Params))
758 return true;
759 WasmSym->setSignature(Signature.get());
760 addSignature(std::move(Signature));
761 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_EVENT);
762 TOut.emitEventType(WasmSym);
763 // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
764 return expect(AsmToken::EndOfStatement, "EOL");
765 }
766
767 if (DirectiveID.getString() == ".local") {
768 if (CurrentState != FunctionStart)
769 return error(".local directive should follow the start of a function",
770 Lexer.getTok());
771 SmallVector<wasm::ValType, 4> Locals;
772 if (parseRegTypeList(Locals))
773 return true;
774 TOut.emitLocal(Locals);
775 CurrentState = FunctionLocals;
776 return expect(AsmToken::EndOfStatement, "EOL");
777 }
778
779 if (DirectiveID.getString() == ".int8" ||
780 DirectiveID.getString() == ".int16" ||
781 DirectiveID.getString() == ".int32" ||
782 DirectiveID.getString() == ".int64") {
783 if (CheckDataSection()) return true;
784 const MCExpr *Val;
785 SMLoc End;
786 if (Parser.parseExpression(Val, End))
787 return error("Cannot parse .int expression: ", Lexer.getTok());
788 size_t NumBits = 0;
789 DirectiveID.getString().drop_front(4).getAsInteger(10, NumBits);
790 Out.EmitValue(Val, NumBits / 8, End);
791 return expect(AsmToken::EndOfStatement, "EOL");
792 }
793
794 if (DirectiveID.getString() == ".asciz") {
795 if (CheckDataSection()) return true;
796 std::string S;
797 if (Parser.parseEscapedString(S))
798 return error("Cannot parse string constant: ", Lexer.getTok());
799 Out.EmitBytes(StringRef(S.c_str(), S.length() + 1));
800 return expect(AsmToken::EndOfStatement, "EOL");
801 }
802
803 return true; // We didn't process this directive.
804 }
805
806 // Called either when the first instruction is parsed of the function ends.
ensureLocals(MCStreamer & Out)807 void ensureLocals(MCStreamer &Out) {
808 if (CurrentState == FunctionStart) {
809 // We haven't seen a .local directive yet. The streamer requires locals to
810 // be encoded as a prelude to the instructions, so emit an empty list of
811 // locals here.
812 auto &TOut = reinterpret_cast<WebAssemblyTargetStreamer &>(
813 *Out.getTargetStreamer());
814 TOut.emitLocal(SmallVector<wasm::ValType, 0>());
815 CurrentState = FunctionLocals;
816 }
817 }
818
MatchAndEmitInstruction(SMLoc IDLoc,unsigned &,OperandVector & Operands,MCStreamer & Out,uint64_t & ErrorInfo,bool MatchingInlineAsm)819 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned & /*Opcode*/,
820 OperandVector &Operands, MCStreamer &Out,
821 uint64_t &ErrorInfo,
822 bool MatchingInlineAsm) override {
823 MCInst Inst;
824 Inst.setLoc(IDLoc);
825 unsigned MatchResult =
826 MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm);
827 switch (MatchResult) {
828 case Match_Success: {
829 ensureLocals(Out);
830 // Fix unknown p2align operands.
831 auto Align = WebAssembly::GetDefaultP2AlignAny(Inst.getOpcode());
832 if (Align != -1U) {
833 auto &Op0 = Inst.getOperand(0);
834 if (Op0.getImm() == -1)
835 Op0.setImm(Align);
836 }
837 Out.EmitInstruction(Inst, getSTI());
838 if (CurrentState == EndFunction) {
839 onEndOfFunction();
840 } else {
841 CurrentState = Instructions;
842 }
843 return false;
844 }
845 case Match_MissingFeature:
846 return Parser.Error(
847 IDLoc, "instruction requires a WASM feature not currently enabled");
848 case Match_MnemonicFail:
849 return Parser.Error(IDLoc, "invalid instruction");
850 case Match_NearMisses:
851 return Parser.Error(IDLoc, "ambiguous instruction");
852 case Match_InvalidTiedOperand:
853 case Match_InvalidOperand: {
854 SMLoc ErrorLoc = IDLoc;
855 if (ErrorInfo != ~0ULL) {
856 if (ErrorInfo >= Operands.size())
857 return Parser.Error(IDLoc, "too few operands for instruction");
858 ErrorLoc = Operands[ErrorInfo]->getStartLoc();
859 if (ErrorLoc == SMLoc())
860 ErrorLoc = IDLoc;
861 }
862 return Parser.Error(ErrorLoc, "invalid operand for instruction");
863 }
864 }
865 llvm_unreachable("Implement any new match types added!");
866 }
867
doBeforeLabelEmit(MCSymbol * Symbol)868 void doBeforeLabelEmit(MCSymbol *Symbol) override {
869 // Start a new section for the next function automatically, since our
870 // object writer expects each function to have its own section. This way
871 // The user can't forget this "convention".
872 auto SymName = Symbol->getName();
873 if (SymName.startswith(".L"))
874 return; // Local Symbol.
875 // Only create a new text section if we're already in one.
876 auto CWS = cast<MCSectionWasm>(getStreamer().getCurrentSection().first);
877 if (!CWS || !CWS->getKind().isText())
878 return;
879 auto SecName = ".text." + SymName;
880 auto WS = getContext().getWasmSection(SecName, SectionKind::getText());
881 getStreamer().SwitchSection(WS);
882 }
883
onEndOfFunction()884 void onEndOfFunction() {
885 // Automatically output a .size directive, so it becomes optional for the
886 // user.
887 if (!LastFunctionLabel) return;
888 auto TempSym = getContext().createLinkerPrivateTempSymbol();
889 getStreamer().EmitLabel(TempSym);
890 auto Start = MCSymbolRefExpr::create(LastFunctionLabel, getContext());
891 auto End = MCSymbolRefExpr::create(TempSym, getContext());
892 auto Expr =
893 MCBinaryExpr::create(MCBinaryExpr::Sub, End, Start, getContext());
894 getStreamer().emitELFSize(LastFunctionLabel, Expr);
895 }
896
onEndOfFile()897 void onEndOfFile() override { ensureEmptyNestingStack(); }
898 };
899 } // end anonymous namespace
900
901 // Force static initialization.
LLVMInitializeWebAssemblyAsmParser()902 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeWebAssemblyAsmParser() {
903 RegisterMCAsmParser<WebAssemblyAsmParser> X(getTheWebAssemblyTarget32());
904 RegisterMCAsmParser<WebAssemblyAsmParser> Y(getTheWebAssemblyTarget64());
905 }
906
907 #define GET_REGISTER_MATCHER
908 #define GET_MATCHER_IMPLEMENTATION
909 #include "WebAssemblyGenAsmMatcher.inc"
910