LLVM  12.0.0git
WebAssemblyAsmParser.cpp
Go to the documentation of this file.
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 
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"
26 #include "llvm/MC/MCSectionWasm.h"
27 #include "llvm/MC/MCStreamer.h"
29 #include "llvm/MC/MCSymbol.h"
30 #include "llvm/MC/MCSymbolWasm.h"
31 #include "llvm/Support/Endian.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 
75  WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, TokOp T)
76  : Kind(K), StartLoc(Start), EndLoc(End), Tok(T) {}
77  WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, IntOp I)
78  : Kind(K), StartLoc(Start), EndLoc(End), Int(I) {}
79  WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, FltOp F)
80  : Kind(K), StartLoc(Start), EndLoc(End), Flt(F) {}
81  WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, SymOp S)
82  : Kind(K), StartLoc(Start), EndLoc(End), Sym(S) {}
83  WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End)
84  : Kind(K), StartLoc(Start), EndLoc(End), BrL() {}
85 
86  ~WebAssemblyOperand() {
87  if (isBrList())
88  BrL.~BrLOp();
89  }
90 
91  bool isToken() const override { return Kind == Token; }
92  bool isImm() const override { return Kind == Integer || Kind == Symbol; }
93  bool isFPImm() const { return Kind == Float; }
94  bool isMem() const override { return false; }
95  bool isReg() const override { return false; }
96  bool isBrList() const { return Kind == BrList; }
97 
98  unsigned getReg() const override {
99  llvm_unreachable("Assembly inspects a register operand");
100  return 0;
101  }
102 
103  StringRef getToken() const {
104  assert(isToken());
105  return Tok.Tok;
106  }
107 
108  SMLoc getStartLoc() const override { return StartLoc; }
109  SMLoc getEndLoc() const override { return EndLoc; }
110 
111  void addRegOperands(MCInst &, unsigned) const {
112  // Required by the assembly matcher.
113  llvm_unreachable("Assembly matcher creates register operands");
114  }
115 
116  void addImmOperands(MCInst &Inst, unsigned N) const {
117  assert(N == 1 && "Invalid number of operands!");
118  if (Kind == Integer)
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 
126  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 
134  void addBrListOperands(MCInst &Inst, unsigned N) const {
135  assert(N == 1 && isBrList() && "Invalid BrList!");
136  for (auto Br : BrL.List)
138  }
139 
140  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  std::vector<std::unique_ptr<std::string>> Names;
168 
169  // Order of labels, directives and instructions in a .s file have no
170  // syntactical enforcement. This class is a callback from the actual parser,
171  // and yet we have to be feeding data to the streamer in a very particular
172  // order to ensure a correct binary encoding that matches the regular backend
173  // (the streamer does not enforce this). This "state machine" enum helps
174  // guarantee that correct order.
175  enum ParserState {
176  FileStart,
177  Label,
178  FunctionStart,
179  FunctionLocals,
180  Instructions,
181  EndFunction,
182  DataSection,
183  } CurrentState = FileStart;
184 
185  // For ensuring blocks are properly nested.
186  enum NestingType {
187  Function,
188  Block,
189  Loop,
190  Try,
191  If,
192  Else,
193  Undefined,
194  };
195  std::vector<NestingType> NestingStack;
196 
197  // We track this to see if a .functype following a label is the same,
198  // as this is how we recognize the start of a function.
199  MCSymbol *LastLabel = nullptr;
200  MCSymbol *LastFunctionLabel = nullptr;
201 
202 public:
203  WebAssemblyAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser,
204  const MCInstrInfo &MII, const MCTargetOptions &Options)
205  : MCTargetAsmParser(Options, STI, MII), Parser(Parser),
206  Lexer(Parser.getLexer()) {
207  setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
208  }
209 
210 #define GET_ASSEMBLER_HEADER
211 #include "WebAssemblyGenAsmMatcher.inc"
212 
213  // TODO: This is required to be implemented, but appears unused.
214  bool ParseRegister(unsigned & /*RegNo*/, SMLoc & /*StartLoc*/,
215  SMLoc & /*EndLoc*/) override {
216  llvm_unreachable("ParseRegister is not implemented.");
217  }
218  OperandMatchResultTy tryParseRegister(unsigned & /*RegNo*/,
219  SMLoc & /*StartLoc*/,
220  SMLoc & /*EndLoc*/) override {
221  llvm_unreachable("tryParseRegister is not implemented.");
222  }
223 
224  bool error(const Twine &Msg, const AsmToken &Tok) {
225  return Parser.Error(Tok.getLoc(), Msg + Tok.getString());
226  }
227 
228  bool error(const Twine &Msg) {
229  return Parser.Error(Lexer.getTok().getLoc(), Msg);
230  }
231 
232  void addSignature(std::unique_ptr<wasm::WasmSignature> &&Sig) {
233  Signatures.push_back(std::move(Sig));
234  }
235 
236  StringRef storeName(StringRef Name) {
237  std::unique_ptr<std::string> N = std::make_unique<std::string>(Name);
238  Names.push_back(std::move(N));
239  return *Names.back();
240  }
241 
242  std::pair<StringRef, StringRef> nestingString(NestingType NT) {
243  switch (NT) {
244  case Function:
245  return {"function", "end_function"};
246  case Block:
247  return {"block", "end_block"};
248  case Loop:
249  return {"loop", "end_loop"};
250  case Try:
251  return {"try", "end_try"};
252  case If:
253  return {"if", "end_if"};
254  case Else:
255  return {"else", "end_if"};
256  default:
257  llvm_unreachable("unknown NestingType");
258  }
259  }
260 
261  void push(NestingType NT) { NestingStack.push_back(NT); }
262 
263  bool pop(StringRef Ins, NestingType NT1, NestingType NT2 = Undefined) {
264  if (NestingStack.empty())
265  return error(Twine("End of block construct with no start: ") + Ins);
266  auto Top = NestingStack.back();
267  if (Top != NT1 && Top != NT2)
268  return error(Twine("Block construct type mismatch, expected: ") +
269  nestingString(Top).second + ", instead got: " + Ins);
270  NestingStack.pop_back();
271  return false;
272  }
273 
274  bool ensureEmptyNestingStack() {
275  auto Err = !NestingStack.empty();
276  while (!NestingStack.empty()) {
277  error(Twine("Unmatched block construct(s) at function end: ") +
278  nestingString(NestingStack.back()).first);
279  NestingStack.pop_back();
280  }
281  return Err;
282  }
283 
284  bool isNext(AsmToken::TokenKind Kind) {
285  auto Ok = Lexer.is(Kind);
286  if (Ok)
287  Parser.Lex();
288  return Ok;
289  }
290 
291  bool expect(AsmToken::TokenKind Kind, const char *KindName) {
292  if (!isNext(Kind))
293  return error(std::string("Expected ") + KindName + ", instead got: ",
294  Lexer.getTok());
295  return false;
296  }
297 
298  StringRef expectIdent() {
299  if (!Lexer.is(AsmToken::Identifier)) {
300  error("Expected identifier, got: ", Lexer.getTok());
301  return StringRef();
302  }
303  auto Name = Lexer.getTok().getString();
304  Parser.Lex();
305  return Name;
306  }
307 
309  // FIXME: can't use StringSwitch because wasm::ValType doesn't have a
310  // "invalid" value.
311  if (Type == "i32")
312  return wasm::ValType::I32;
313  if (Type == "i64")
314  return wasm::ValType::I64;
315  if (Type == "f32")
316  return wasm::ValType::F32;
317  if (Type == "f64")
318  return wasm::ValType::F64;
319  if (Type == "v128" || Type == "i8x16" || Type == "i16x8" ||
320  Type == "i32x4" || Type == "i64x2" || Type == "f32x4" ||
321  Type == "f64x2")
322  return wasm::ValType::V128;
323  if (Type == "exnref")
324  return wasm::ValType::EXNREF;
325  if (Type == "externref")
327  return Optional<wasm::ValType>();
328  }
329 
330  WebAssembly::BlockType parseBlockType(StringRef ID) {
331  // Multivalue block types are handled separately in parseSignature
333  .Case("i32", WebAssembly::BlockType::I32)
341  }
342 
343  bool parseRegTypeList(SmallVectorImpl<wasm::ValType> &Types) {
344  while (Lexer.is(AsmToken::Identifier)) {
345  auto Type = parseType(Lexer.getTok().getString());
346  if (!Type)
347  return error("unknown type: ", Lexer.getTok());
348  Types.push_back(Type.getValue());
349  Parser.Lex();
350  if (!isNext(AsmToken::Comma))
351  break;
352  }
353  return false;
354  }
355 
356  void parseSingleInteger(bool IsNegative, OperandVector &Operands) {
357  auto &Int = Lexer.getTok();
358  int64_t Val = Int.getIntVal();
359  if (IsNegative)
360  Val = -Val;
361  Operands.push_back(std::make_unique<WebAssemblyOperand>(
362  WebAssemblyOperand::Integer, Int.getLoc(), Int.getEndLoc(),
363  WebAssemblyOperand::IntOp{Val}));
364  Parser.Lex();
365  }
366 
367  bool parseSingleFloat(bool IsNegative, OperandVector &Operands) {
368  auto &Flt = Lexer.getTok();
369  double Val;
370  if (Flt.getString().getAsDouble(Val, false))
371  return error("Cannot parse real: ", Flt);
372  if (IsNegative)
373  Val = -Val;
374  Operands.push_back(std::make_unique<WebAssemblyOperand>(
375  WebAssemblyOperand::Float, Flt.getLoc(), Flt.getEndLoc(),
376  WebAssemblyOperand::FltOp{Val}));
377  Parser.Lex();
378  return false;
379  }
380 
381  bool parseSpecialFloatMaybe(bool IsNegative, OperandVector &Operands) {
382  if (Lexer.isNot(AsmToken::Identifier))
383  return true;
384  auto &Flt = Lexer.getTok();
385  auto S = Flt.getString();
386  double Val;
387  if (S.compare_lower("infinity") == 0) {
388  Val = std::numeric_limits<double>::infinity();
389  } else if (S.compare_lower("nan") == 0) {
390  Val = std::numeric_limits<double>::quiet_NaN();
391  } else {
392  return true;
393  }
394  if (IsNegative)
395  Val = -Val;
396  Operands.push_back(std::make_unique<WebAssemblyOperand>(
397  WebAssemblyOperand::Float, Flt.getLoc(), Flt.getEndLoc(),
398  WebAssemblyOperand::FltOp{Val}));
399  Parser.Lex();
400  return false;
401  }
402 
403  bool checkForP2AlignIfLoadStore(OperandVector &Operands, StringRef InstName) {
404  // FIXME: there is probably a cleaner way to do this.
405  auto IsLoadStore = InstName.find(".load") != StringRef::npos ||
406  InstName.find(".store") != StringRef::npos;
407  auto IsAtomic = InstName.find("atomic.") != StringRef::npos;
408  if (IsLoadStore || IsAtomic) {
409  // Parse load/store operands of the form: offset:p2align=align
410  if (IsLoadStore && isNext(AsmToken::Colon)) {
411  auto Id = expectIdent();
412  if (Id != "p2align")
413  return error("Expected p2align, instead got: " + Id);
414  if (expect(AsmToken::Equal, "="))
415  return true;
416  if (!Lexer.is(AsmToken::Integer))
417  return error("Expected integer constant");
418  parseSingleInteger(false, Operands);
419  } else {
420  // Alignment not specified (or atomics, must use default alignment).
421  // We can't just call WebAssembly::GetDefaultP2Align since we don't have
422  // an opcode until after the assembly matcher, so set a default to fix
423  // up later.
424  auto Tok = Lexer.getTok();
425  Operands.push_back(std::make_unique<WebAssemblyOperand>(
427  WebAssemblyOperand::IntOp{-1}));
428  }
429  }
430  return false;
431  }
432 
433  void addBlockTypeOperand(OperandVector &Operands, SMLoc NameLoc,
435  Operands.push_back(std::make_unique<WebAssemblyOperand>(
436  WebAssemblyOperand::Integer, NameLoc, NameLoc,
437  WebAssemblyOperand::IntOp{static_cast<int64_t>(BT)}));
438  }
439 
440  bool ParseInstruction(ParseInstructionInfo & /*Info*/, StringRef Name,
441  SMLoc NameLoc, OperandVector &Operands) override {
442  // Note: Name does NOT point into the sourcecode, but to a local, so
443  // use NameLoc instead.
444  Name = StringRef(NameLoc.getPointer(), Name.size());
445 
446  // WebAssembly has instructions with / in them, which AsmLexer parses
447  // as separate tokens, so if we find such tokens immediately adjacent (no
448  // whitespace), expand the name to include them:
449  for (;;) {
450  auto &Sep = Lexer.getTok();
451  if (Sep.getLoc().getPointer() != Name.end() ||
452  Sep.getKind() != AsmToken::Slash)
453  break;
454  // Extend name with /
455  Name = StringRef(Name.begin(), Name.size() + Sep.getString().size());
456  Parser.Lex();
457  // We must now find another identifier, or error.
458  auto &Id = Lexer.getTok();
459  if (Id.getKind() != AsmToken::Identifier ||
460  Id.getLoc().getPointer() != Name.end())
461  return error("Incomplete instruction name: ", Id);
462  Name = StringRef(Name.begin(), Name.size() + Id.getString().size());
463  Parser.Lex();
464  }
465 
466  // Now construct the name as first operand.
467  Operands.push_back(std::make_unique<WebAssemblyOperand>(
468  WebAssemblyOperand::Token, NameLoc, SMLoc::getFromPointer(Name.end()),
469  WebAssemblyOperand::TokOp{Name}));
470 
471  // If this instruction is part of a control flow structure, ensure
472  // proper nesting.
473  bool ExpectBlockType = false;
474  bool ExpectFuncType = false;
475  if (Name == "block") {
476  push(Block);
477  ExpectBlockType = true;
478  } else if (Name == "loop") {
479  push(Loop);
480  ExpectBlockType = true;
481  } else if (Name == "try") {
482  push(Try);
483  ExpectBlockType = true;
484  } else if (Name == "if") {
485  push(If);
486  ExpectBlockType = true;
487  } else if (Name == "else") {
488  if (pop(Name, If))
489  return true;
490  push(Else);
491  } else if (Name == "catch") {
492  if (pop(Name, Try))
493  return true;
494  push(Try);
495  } else if (Name == "end_if") {
496  if (pop(Name, If, Else))
497  return true;
498  } else if (Name == "end_try") {
499  if (pop(Name, Try))
500  return true;
501  } else if (Name == "end_loop") {
502  if (pop(Name, Loop))
503  return true;
504  } else if (Name == "end_block") {
505  if (pop(Name, Block))
506  return true;
507  } else if (Name == "end_function") {
508  ensureLocals(getStreamer());
509  CurrentState = EndFunction;
510  if (pop(Name, Function) || ensureEmptyNestingStack())
511  return true;
512  } else if (Name == "call_indirect" || Name == "return_call_indirect") {
513  ExpectFuncType = true;
514  }
515 
516  if (ExpectFuncType || (ExpectBlockType && Lexer.is(AsmToken::LParen))) {
517  // This has a special TYPEINDEX operand which in text we
518  // represent as a signature, such that we can re-build this signature,
519  // attach it to an anonymous symbol, which is what WasmObjectWriter
520  // expects to be able to recreate the actual unique-ified type indices.
521  auto Loc = Parser.getTok();
522  auto Signature = std::make_unique<wasm::WasmSignature>();
523  if (parseSignature(Signature.get()))
524  return true;
525  // Got signature as block type, don't need more
526  ExpectBlockType = false;
527  auto &Ctx = getStreamer().getContext();
528  // The "true" here will cause this to be a nameless symbol.
529  MCSymbol *Sym = Ctx.createTempSymbol("typeindex", true);
530  auto *WasmSym = cast<MCSymbolWasm>(Sym);
531  WasmSym->setSignature(Signature.get());
532  addSignature(std::move(Signature));
533  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
534  const MCExpr *Expr = MCSymbolRefExpr::create(
535  WasmSym, MCSymbolRefExpr::VK_WASM_TYPEINDEX, Ctx);
536  Operands.push_back(std::make_unique<WebAssemblyOperand>(
537  WebAssemblyOperand::Symbol, Loc.getLoc(), Loc.getEndLoc(),
538  WebAssemblyOperand::SymOp{Expr}));
539  }
540 
541  while (Lexer.isNot(AsmToken::EndOfStatement)) {
542  auto &Tok = Lexer.getTok();
543  switch (Tok.getKind()) {
544  case AsmToken::Identifier: {
545  if (!parseSpecialFloatMaybe(false, Operands))
546  break;
547  auto &Id = Lexer.getTok();
548  if (ExpectBlockType) {
549  // Assume this identifier is a block_type.
550  auto BT = parseBlockType(Id.getString());
552  return error("Unknown block type: ", Id);
553  addBlockTypeOperand(Operands, NameLoc, BT);
554  Parser.Lex();
555  } else {
556  // Assume this identifier is a label.
557  const MCExpr *Val;
558  SMLoc End;
559  if (Parser.parseExpression(Val, End))
560  return error("Cannot parse symbol: ", Lexer.getTok());
561  Operands.push_back(std::make_unique<WebAssemblyOperand>(
562  WebAssemblyOperand::Symbol, Id.getLoc(), Id.getEndLoc(),
563  WebAssemblyOperand::SymOp{Val}));
564  if (checkForP2AlignIfLoadStore(Operands, Name))
565  return true;
566  }
567  break;
568  }
569  case AsmToken::Minus:
570  Parser.Lex();
571  if (Lexer.is(AsmToken::Integer)) {
572  parseSingleInteger(true, Operands);
573  if (checkForP2AlignIfLoadStore(Operands, Name))
574  return true;
575  } else if(Lexer.is(AsmToken::Real)) {
576  if (parseSingleFloat(true, Operands))
577  return true;
578  } else if (!parseSpecialFloatMaybe(true, Operands)) {
579  } else {
580  return error("Expected numeric constant instead got: ",
581  Lexer.getTok());
582  }
583  break;
584  case AsmToken::Integer:
585  parseSingleInteger(false, Operands);
586  if (checkForP2AlignIfLoadStore(Operands, Name))
587  return true;
588  break;
589  case AsmToken::Real: {
590  if (parseSingleFloat(false, Operands))
591  return true;
592  break;
593  }
594  case AsmToken::LCurly: {
595  Parser.Lex();
596  auto Op = std::make_unique<WebAssemblyOperand>(
597  WebAssemblyOperand::BrList, Tok.getLoc(), Tok.getEndLoc());
598  if (!Lexer.is(AsmToken::RCurly))
599  for (;;) {
600  Op->BrL.List.push_back(Lexer.getTok().getIntVal());
601  expect(AsmToken::Integer, "integer");
602  if (!isNext(AsmToken::Comma))
603  break;
604  }
605  expect(AsmToken::RCurly, "}");
606  Operands.push_back(std::move(Op));
607  break;
608  }
609  default:
610  return error("Unexpected token in operand: ", Tok);
611  }
612  if (Lexer.isNot(AsmToken::EndOfStatement)) {
613  if (expect(AsmToken::Comma, ","))
614  return true;
615  }
616  }
617  if (ExpectBlockType && Operands.size() == 1) {
618  // Support blocks with no operands as default to void.
619  addBlockTypeOperand(Operands, NameLoc, WebAssembly::BlockType::Void);
620  }
621  Parser.Lex();
622  return false;
623  }
624 
625  void onLabelParsed(MCSymbol *Symbol) override {
626  LastLabel = Symbol;
627  CurrentState = Label;
628  }
629 
630  bool parseSignature(wasm::WasmSignature *Signature) {
631  if (expect(AsmToken::LParen, "("))
632  return true;
633  if (parseRegTypeList(Signature->Params))
634  return true;
635  if (expect(AsmToken::RParen, ")"))
636  return true;
637  if (expect(AsmToken::MinusGreater, "->"))
638  return true;
639  if (expect(AsmToken::LParen, "("))
640  return true;
641  if (parseRegTypeList(Signature->Returns))
642  return true;
643  if (expect(AsmToken::RParen, ")"))
644  return true;
645  return false;
646  }
647 
648  bool CheckDataSection() {
649  if (CurrentState != DataSection) {
650  auto WS = cast<MCSectionWasm>(getStreamer().getCurrentSection().first);
651  if (WS && WS->getKind().isText())
652  return error("data directive must occur in a data segment: ",
653  Lexer.getTok());
654  }
655  CurrentState = DataSection;
656  return false;
657  }
658 
659  // This function processes wasm-specific directives streamed to
660  // WebAssemblyTargetStreamer, all others go to the generic parser
661  // (see WasmAsmParser).
662  bool ParseDirective(AsmToken DirectiveID) override {
663  // This function has a really weird return value behavior that is different
664  // from all the other parsing functions:
665  // - return true && no tokens consumed -> don't know this directive / let
666  // the generic parser handle it.
667  // - return true && tokens consumed -> a parsing error occurred.
668  // - return false -> processed this directive successfully.
669  assert(DirectiveID.getKind() == AsmToken::Identifier);
670  auto &Out = getStreamer();
671  auto &TOut =
672  reinterpret_cast<WebAssemblyTargetStreamer &>(*Out.getTargetStreamer());
673  auto &Ctx = Out.getContext();
674 
675  // TODO: any time we return an error, at least one token must have been
676  // consumed, otherwise this will not signal an error to the caller.
677  if (DirectiveID.getString() == ".globaltype") {
678  auto SymName = expectIdent();
679  if (SymName.empty())
680  return true;
681  if (expect(AsmToken::Comma, ","))
682  return true;
683  auto TypeTok = Lexer.getTok();
684  auto TypeName = expectIdent();
685  if (TypeName.empty())
686  return true;
687  auto Type = parseType(TypeName);
688  if (!Type)
689  return error("Unknown type in .globaltype directive: ", TypeTok);
690  // Now set this symbol with the correct type.
691  auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
692  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
693  WasmSym->setGlobalType(
694  wasm::WasmGlobalType{uint8_t(Type.getValue()), true});
695  // And emit the directive again.
696  TOut.emitGlobalType(WasmSym);
697  return expect(AsmToken::EndOfStatement, "EOL");
698  }
699 
700  if (DirectiveID.getString() == ".functype") {
701  // This code has to send things to the streamer similar to
702  // WebAssemblyAsmPrinter::EmitFunctionBodyStart.
703  // TODO: would be good to factor this into a common function, but the
704  // assembler and backend really don't share any common code, and this code
705  // parses the locals separately.
706  auto SymName = expectIdent();
707  if (SymName.empty())
708  return true;
709  auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
710  if (CurrentState == Label && WasmSym == LastLabel) {
711  // This .functype indicates a start of a function.
712  if (ensureEmptyNestingStack())
713  return true;
714  CurrentState = FunctionStart;
715  LastFunctionLabel = LastLabel;
716  push(Function);
717  }
718  auto Signature = std::make_unique<wasm::WasmSignature>();
719  if (parseSignature(Signature.get()))
720  return true;
721  WasmSym->setSignature(Signature.get());
722  addSignature(std::move(Signature));
723  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
724  TOut.emitFunctionType(WasmSym);
725  // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
726  return expect(AsmToken::EndOfStatement, "EOL");
727  }
728 
729  if (DirectiveID.getString() == ".export_name") {
730  auto SymName = expectIdent();
731  if (SymName.empty())
732  return true;
733  if (expect(AsmToken::Comma, ","))
734  return true;
735  auto ExportName = expectIdent();
736  auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
737  WasmSym->setExportName(storeName(ExportName));
738  TOut.emitExportName(WasmSym, ExportName);
739  }
740 
741  if (DirectiveID.getString() == ".import_module") {
742  auto SymName = expectIdent();
743  if (SymName.empty())
744  return true;
745  if (expect(AsmToken::Comma, ","))
746  return true;
747  auto ImportModule = expectIdent();
748  auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
749  WasmSym->setImportModule(storeName(ImportModule));
750  TOut.emitImportModule(WasmSym, ImportModule);
751  }
752 
753  if (DirectiveID.getString() == ".import_name") {
754  auto SymName = expectIdent();
755  if (SymName.empty())
756  return true;
757  if (expect(AsmToken::Comma, ","))
758  return true;
759  auto ImportName = expectIdent();
760  auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
761  WasmSym->setImportName(storeName(ImportName));
762  TOut.emitImportName(WasmSym, ImportName);
763  }
764 
765  if (DirectiveID.getString() == ".eventtype") {
766  auto SymName = expectIdent();
767  if (SymName.empty())
768  return true;
769  auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
770  auto Signature = std::make_unique<wasm::WasmSignature>();
771  if (parseRegTypeList(Signature->Params))
772  return true;
773  WasmSym->setSignature(Signature.get());
774  addSignature(std::move(Signature));
775  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_EVENT);
776  TOut.emitEventType(WasmSym);
777  // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
778  return expect(AsmToken::EndOfStatement, "EOL");
779  }
780 
781  if (DirectiveID.getString() == ".local") {
782  if (CurrentState != FunctionStart)
783  return error(".local directive should follow the start of a function",
784  Lexer.getTok());
786  if (parseRegTypeList(Locals))
787  return true;
788  TOut.emitLocal(Locals);
789  CurrentState = FunctionLocals;
790  return expect(AsmToken::EndOfStatement, "EOL");
791  }
792 
793  if (DirectiveID.getString() == ".int8" ||
794  DirectiveID.getString() == ".int16" ||
795  DirectiveID.getString() == ".int32" ||
796  DirectiveID.getString() == ".int64") {
797  if (CheckDataSection()) return true;
798  const MCExpr *Val;
799  SMLoc End;
800  if (Parser.parseExpression(Val, End))
801  return error("Cannot parse .int expression: ", Lexer.getTok());
802  size_t NumBits = 0;
803  DirectiveID.getString().drop_front(4).getAsInteger(10, NumBits);
804  Out.emitValue(Val, NumBits / 8, End);
805  return expect(AsmToken::EndOfStatement, "EOL");
806  }
807 
808  if (DirectiveID.getString() == ".asciz") {
809  if (CheckDataSection()) return true;
810  std::string S;
811  if (Parser.parseEscapedString(S))
812  return error("Cannot parse string constant: ", Lexer.getTok());
813  Out.emitBytes(StringRef(S.c_str(), S.length() + 1));
814  return expect(AsmToken::EndOfStatement, "EOL");
815  }
816 
817  return true; // We didn't process this directive.
818  }
819 
820  // Called either when the first instruction is parsed of the function ends.
821  void ensureLocals(MCStreamer &Out) {
822  if (CurrentState == FunctionStart) {
823  // We haven't seen a .local directive yet. The streamer requires locals to
824  // be encoded as a prelude to the instructions, so emit an empty list of
825  // locals here.
826  auto &TOut = reinterpret_cast<WebAssemblyTargetStreamer &>(
827  *Out.getTargetStreamer());
829  CurrentState = FunctionLocals;
830  }
831  }
832 
833  bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned & /*Opcode*/,
834  OperandVector &Operands, MCStreamer &Out,
835  uint64_t &ErrorInfo,
836  bool MatchingInlineAsm) override {
837  MCInst Inst;
838  Inst.setLoc(IDLoc);
839  unsigned MatchResult =
840  MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm);
841  switch (MatchResult) {
842  case Match_Success: {
843  ensureLocals(Out);
844  // Fix unknown p2align operands.
846  if (Align != -1U) {
847  auto &Op0 = Inst.getOperand(0);
848  if (Op0.getImm() == -1)
849  Op0.setImm(Align);
850  }
851  if (getSTI().getTargetTriple().isArch64Bit()) {
852  // Upgrade 32-bit loads/stores to 64-bit. These mostly differ by having
853  // an offset64 arg instead of offset32, but to the assembler matcher
854  // they're both immediates so don't get selected for.
855  auto Opc64 = WebAssembly::getWasm64Opcode(
856  static_cast<uint16_t>(Inst.getOpcode()));
857  if (Opc64 >= 0) {
858  Inst.setOpcode(Opc64);
859  }
860  }
861  Out.emitInstruction(Inst, getSTI());
862  if (CurrentState == EndFunction) {
863  onEndOfFunction();
864  } else {
865  CurrentState = Instructions;
866  }
867  return false;
868  }
869  case Match_MissingFeature:
870  return Parser.Error(
871  IDLoc, "instruction requires a WASM feature not currently enabled");
872  case Match_MnemonicFail:
873  return Parser.Error(IDLoc, "invalid instruction");
874  case Match_NearMisses:
875  return Parser.Error(IDLoc, "ambiguous instruction");
876  case Match_InvalidTiedOperand:
877  case Match_InvalidOperand: {
878  SMLoc ErrorLoc = IDLoc;
879  if (ErrorInfo != ~0ULL) {
880  if (ErrorInfo >= Operands.size())
881  return Parser.Error(IDLoc, "too few operands for instruction");
882  ErrorLoc = Operands[ErrorInfo]->getStartLoc();
883  if (ErrorLoc == SMLoc())
884  ErrorLoc = IDLoc;
885  }
886  return Parser.Error(ErrorLoc, "invalid operand for instruction");
887  }
888  }
889  llvm_unreachable("Implement any new match types added!");
890  }
891 
892  void doBeforeLabelEmit(MCSymbol *Symbol) override {
893  // Start a new section for the next function automatically, since our
894  // object writer expects each function to have its own section. This way
895  // The user can't forget this "convention".
896  auto SymName = Symbol->getName();
897  if (SymName.startswith(".L"))
898  return; // Local Symbol.
899  // Only create a new text section if we're already in one.
900  auto CWS = cast<MCSectionWasm>(getStreamer().getCurrentSection().first);
901  if (!CWS || !CWS->getKind().isText())
902  return;
903  auto SecName = ".text." + SymName;
904  auto WS = getContext().getWasmSection(SecName, SectionKind::getText());
905  getStreamer().SwitchSection(WS);
906  // Also generate DWARF for this section if requested.
907  if (getContext().getGenDwarfForAssembly())
908  getContext().addGenDwarfSection(WS);
909  }
910 
911  void onEndOfFunction() {
912  // Automatically output a .size directive, so it becomes optional for the
913  // user.
914  if (!LastFunctionLabel) return;
915  auto TempSym = getContext().createLinkerPrivateTempSymbol();
916  getStreamer().emitLabel(TempSym);
917  auto Start = MCSymbolRefExpr::create(LastFunctionLabel, getContext());
918  auto End = MCSymbolRefExpr::create(TempSym, getContext());
919  auto Expr =
920  MCBinaryExpr::create(MCBinaryExpr::Sub, End, Start, getContext());
921  getStreamer().emitELFSize(LastFunctionLabel, Expr);
922  }
923 
924  void onEndOfFile() override { ensureEmptyNestingStack(); }
925 };
926 } // end anonymous namespace
927 
928 // Force static initialization.
932 }
933 
934 #define GET_REGISTER_MATCHER
935 #define GET_MATCHER_IMPLEMENTATION
936 #include "WebAssemblyGenAsmMatcher.inc"
static bool isReg(const MCInst &MI, unsigned OpNo)
const AsmToken & getTok() const
Get the current (last) lexed token.
Definition: MCAsmLexer.h:100
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
StringRef getString() const
Get the string for the current token, this includes all characters (for example, the quotes on string...
Definition: MCAsmMacro.h:110
int getWasm64Opcode(unsigned short Opcode)
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:384
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool is(AsmToken::TokenKind K) const
Check if the current token has kind K.
Definition: MCAsmLexer.h:135
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
Generic assembler parser interface, for use by target specific assembly parsers.
Definition: MCAsmParser.h:109
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
static MCOperand createExpr(const MCExpr *Val)
Definition: MCInst.h:136
MCTargetAsmParser - Generic interface to target specific assembly parsers.
virtual const AsmToken & Lex()=0
Get the next AsmToken in the stream, possibly handling file inclusion first.
#define error(X)
F(f)
const AsmToken & getTok() const
Get the current AsmToken from the stream.
Definition: MCAsmParser.cpp:38
This file contains the entry points for global functions defined in the LLVM WebAssembly back-end...
StringSwitch & Case(StringLiteral S, T Value)
Definition: StringSwitch.h:67
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
This file registers the WebAssembly target.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
const FeatureBitset & getFeatureBits() const
Generic assembler lexer interface, for use by target specific assembly lexers.
Definition: MCAsmLexer.h:39
LLVM_NODISCARD StringRef drop_front(size_t N=1) const
Return a StringRef equal to &#39;this&#39; but with the first N elements dropped.
Definition: StringRef.h:654
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
SmallVector< ValType, 1 > Returns
Definition: Wasm.h:368
LLVM_NODISCARD R Default(T Value)
Definition: StringSwitch.h:181
Target independent representation for an assembler token.
Definition: MCAsmMacro.h:21
mir Rename Register Operands
static bool isMem(const MachineInstr &MI, unsigned Op)
Definition: X86InstrInfo.h:123
static constexpr size_t npos
Definition: StringRef.h:59
MCParsedAsmOperand - This abstract class represents a source-level assembly instruction operand...
virtual bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc)=0
Parse an arbitrary expression.
SmallVector< ValType, 4 > Params
Definition: Wasm.h:369
std::pair< StringRef, StringRef > getToken(StringRef Source, StringRef Delimiters=" \\\)
getToken - This function extracts one token from source, ignoring any leading characters that appear ...
RegisterMCAsmParser - Helper template for registering a target specific assembly parser, for use in the target machine initialization function.
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:160
SMLoc getLoc() const
Definition: MCAsmLexer.cpp:27
virtual bool parseEscapedString(std::string &Data)=0
Parse the current token as a string which may include escaped characters and return the string conten...
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:158
std::enable_if_t< std::numeric_limits< T >::is_signed, bool > getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition: StringRef.h:511
static const MCBinaryExpr * create(Opcode Op, const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition: MCExpr.cpp:175
WebAssembly-specific streamer interface, to implement support WebAssembly-specific assembly directive...
const char * getPointer() const
Definition: SMLoc.h:34
void setImm(int64_t Val)
Definition: MCInst.h:80
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:42
Streaming machine code generation interface.
Definition: MCStreamer.h:196
MCTargetStreamer * getTargetStreamer()
Definition: MCStreamer.h:272
virtual void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI)
Emit the given Instruction into the current section.
SMLoc getEndLoc() const
Definition: MCAsmLexer.cpp:31
static void push(SmallVectorImpl< uint64_t > &R, StringRef Str)
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This file provides WebAssembly-specific target descriptions.
Interface to description of machine instruction set.
Definition: MCInstrInfo.h:25
LLVM_NODISCARD size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:318
virtual MCAsmLexer & getLexer()=0
constexpr char TypeName[]
Key for Kernel::Arg::Metadata::mTypeName.
int64_t getIntVal() const
Definition: MCAsmMacro.h:115
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
bool Error(SMLoc L, const Twine &Msg, SMRange Range=None)
Return an error at the location L, with the message Msg.
Definition: MCAsmParser.cpp:92
void setLoc(SMLoc loc)
Definition: MCInst.h:177
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
This file declares WebAssembly-specific target streamer classes.
void setOpcode(unsigned Op)
Definition: MCInst.h:171
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:883
const MCOperand & getOperand(unsigned i) const
Definition: MCInst.h:180
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:131
static MCOperand createFPImm(double Val)
Definition: MCInst.h:129
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeWebAssemblyAsmParser()
static unsigned getReg(const void *D, unsigned RC, unsigned RegNo)
Base class for user error types.
Definition: Error.h:350
iterator begin() const
Definition: StringRef.h:131
static SMLoc getFromPointer(const char *Ptr)
Definition: SMLoc.h:36
BitTracker BT
Definition: BitTracker.cpp:73
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:516
#define I(x, y, z)
Definition: MD5.cpp:59
#define N
BlockType
Used as immediate MachineOperands for block signatures.
Generic base class for all target subtargets.
bool isNot(AsmToken::TokenKind K) const
Check if the current token has kind K.
Definition: MCAsmLexer.h:138
size_t size() const
Definition: SmallVector.h:66
unsigned GetDefaultP2AlignAny(unsigned Opc)
Return the default p2align value for a load or store with the given opcode.
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:196
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
virtual void emitLocal(ArrayRef< wasm::ValType > Types)=0
.local
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
Subtraction.
Definition: MCExpr.h:505
void addOperand(const MCOperand &Op)
Definition: MCInst.h:184
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
Target & getTheWebAssemblyTarget32()
Type * parseType(StringRef Asm, SMDiagnostic &Err, const Module &M, const SlotMapping *Slots=nullptr)
Parse a type in the given string.
Definition: Parser.cpp:194
Represents a location in source code.
Definition: SMLoc.h:23
unsigned getOpcode() const
Definition: MCInst.h:172
Target & getTheWebAssemblyTarget64()
iterator end() const
Definition: StringRef.h:133
static MCOperand createImm(int64_t Val)
Definition: MCInst.h:122
TokenKind getKind() const
Definition: MCAsmMacro.h:81
static SectionKind getText()
Definition: SectionKind.h:179