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 "AsmParser/WebAssemblyAsmTypeCheck.h"
17 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
18 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
19 #include "TargetInfo/WebAssemblyTargetInfo.h"
20 #include "Utils/WebAssemblyTypeUtilities.h"
21 #include "Utils/WebAssemblyUtilities.h"
22 #include "WebAssembly.h"
23 #include "llvm/MC/MCContext.h"
24 #include "llvm/MC/MCExpr.h"
25 #include "llvm/MC/MCInst.h"
26 #include "llvm/MC/MCInstrInfo.h"
27 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
28 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
29 #include "llvm/MC/MCSectionWasm.h"
30 #include "llvm/MC/MCStreamer.h"
31 #include "llvm/MC/MCSubtargetInfo.h"
32 #include "llvm/MC/MCSymbol.h"
33 #include "llvm/MC/MCSymbolWasm.h"
34 #include "llvm/MC/TargetRegistry.h"
35 #include "llvm/Support/Endian.h"
36 #include "llvm/Support/SourceMgr.h"
37
38 using namespace llvm;
39
40 #define DEBUG_TYPE "wasm-asm-parser"
41
42 static const char *getSubtargetFeatureName(uint64_t Val);
43
44 namespace {
45
46 /// WebAssemblyOperand - Instances of this class represent the operands in a
47 /// parsed Wasm machine instruction.
48 struct WebAssemblyOperand : public MCParsedAsmOperand {
49 enum KindTy { Token, Integer, Float, Symbol, BrList } Kind;
50
51 SMLoc StartLoc, EndLoc;
52
53 struct TokOp {
54 StringRef Tok;
55 };
56
57 struct IntOp {
58 int64_t Val;
59 };
60
61 struct FltOp {
62 double Val;
63 };
64
65 struct SymOp {
66 const MCExpr *Exp;
67 };
68
69 struct BrLOp {
70 std::vector<unsigned> List;
71 };
72
73 union {
74 struct TokOp Tok;
75 struct IntOp Int;
76 struct FltOp Flt;
77 struct SymOp Sym;
78 struct BrLOp BrL;
79 };
80
WebAssemblyOperand__anon71104db50111::WebAssemblyOperand81 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, TokOp T)
82 : Kind(K), StartLoc(Start), EndLoc(End), Tok(T) {}
WebAssemblyOperand__anon71104db50111::WebAssemblyOperand83 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, IntOp I)
84 : Kind(K), StartLoc(Start), EndLoc(End), Int(I) {}
WebAssemblyOperand__anon71104db50111::WebAssemblyOperand85 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, FltOp F)
86 : Kind(K), StartLoc(Start), EndLoc(End), Flt(F) {}
WebAssemblyOperand__anon71104db50111::WebAssemblyOperand87 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End, SymOp S)
88 : Kind(K), StartLoc(Start), EndLoc(End), Sym(S) {}
WebAssemblyOperand__anon71104db50111::WebAssemblyOperand89 WebAssemblyOperand(KindTy K, SMLoc Start, SMLoc End)
90 : Kind(K), StartLoc(Start), EndLoc(End), BrL() {}
91
~WebAssemblyOperand__anon71104db50111::WebAssemblyOperand92 ~WebAssemblyOperand() {
93 if (isBrList())
94 BrL.~BrLOp();
95 }
96
isToken__anon71104db50111::WebAssemblyOperand97 bool isToken() const override { return Kind == Token; }
isImm__anon71104db50111::WebAssemblyOperand98 bool isImm() const override { return Kind == Integer || Kind == Symbol; }
isFPImm__anon71104db50111::WebAssemblyOperand99 bool isFPImm() const { return Kind == Float; }
isMem__anon71104db50111::WebAssemblyOperand100 bool isMem() const override { return false; }
isReg__anon71104db50111::WebAssemblyOperand101 bool isReg() const override { return false; }
isBrList__anon71104db50111::WebAssemblyOperand102 bool isBrList() const { return Kind == BrList; }
103
getReg__anon71104db50111::WebAssemblyOperand104 unsigned getReg() const override {
105 llvm_unreachable("Assembly inspects a register operand");
106 return 0;
107 }
108
getToken__anon71104db50111::WebAssemblyOperand109 StringRef getToken() const {
110 assert(isToken());
111 return Tok.Tok;
112 }
113
getStartLoc__anon71104db50111::WebAssemblyOperand114 SMLoc getStartLoc() const override { return StartLoc; }
getEndLoc__anon71104db50111::WebAssemblyOperand115 SMLoc getEndLoc() const override { return EndLoc; }
116
addRegOperands__anon71104db50111::WebAssemblyOperand117 void addRegOperands(MCInst &, unsigned) const {
118 // Required by the assembly matcher.
119 llvm_unreachable("Assembly matcher creates register operands");
120 }
121
addImmOperands__anon71104db50111::WebAssemblyOperand122 void addImmOperands(MCInst &Inst, unsigned N) const {
123 assert(N == 1 && "Invalid number of operands!");
124 if (Kind == Integer)
125 Inst.addOperand(MCOperand::createImm(Int.Val));
126 else if (Kind == Symbol)
127 Inst.addOperand(MCOperand::createExpr(Sym.Exp));
128 else
129 llvm_unreachable("Should be integer immediate or symbol!");
130 }
131
addFPImmf32Operands__anon71104db50111::WebAssemblyOperand132 void addFPImmf32Operands(MCInst &Inst, unsigned N) const {
133 assert(N == 1 && "Invalid number of operands!");
134 if (Kind == Float)
135 Inst.addOperand(
136 MCOperand::createSFPImm(bit_cast<uint32_t>(float(Flt.Val))));
137 else
138 llvm_unreachable("Should be float immediate!");
139 }
140
addFPImmf64Operands__anon71104db50111::WebAssemblyOperand141 void addFPImmf64Operands(MCInst &Inst, unsigned N) const {
142 assert(N == 1 && "Invalid number of operands!");
143 if (Kind == Float)
144 Inst.addOperand(MCOperand::createDFPImm(bit_cast<uint64_t>(Flt.Val)));
145 else
146 llvm_unreachable("Should be float immediate!");
147 }
148
addBrListOperands__anon71104db50111::WebAssemblyOperand149 void addBrListOperands(MCInst &Inst, unsigned N) const {
150 assert(N == 1 && isBrList() && "Invalid BrList!");
151 for (auto Br : BrL.List)
152 Inst.addOperand(MCOperand::createImm(Br));
153 }
154
print__anon71104db50111::WebAssemblyOperand155 void print(raw_ostream &OS) const override {
156 switch (Kind) {
157 case Token:
158 OS << "Tok:" << Tok.Tok;
159 break;
160 case Integer:
161 OS << "Int:" << Int.Val;
162 break;
163 case Float:
164 OS << "Flt:" << Flt.Val;
165 break;
166 case Symbol:
167 OS << "Sym:" << Sym.Exp;
168 break;
169 case BrList:
170 OS << "BrList:" << BrL.List.size();
171 break;
172 }
173 }
174 };
175
176 // Perhaps this should go somewhere common.
DefaultLimits()177 static wasm::WasmLimits DefaultLimits() {
178 return {wasm::WASM_LIMITS_FLAG_NONE, 0, 0};
179 }
180
GetOrCreateFunctionTableSymbol(MCContext & Ctx,const StringRef & Name)181 static MCSymbolWasm *GetOrCreateFunctionTableSymbol(MCContext &Ctx,
182 const StringRef &Name) {
183 MCSymbolWasm *Sym = cast_or_null<MCSymbolWasm>(Ctx.lookupSymbol(Name));
184 if (Sym) {
185 if (!Sym->isFunctionTable())
186 Ctx.reportError(SMLoc(), "symbol is not a wasm funcref table");
187 } else {
188 Sym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(Name));
189 Sym->setFunctionTable();
190 // The default function table is synthesized by the linker.
191 Sym->setUndefined();
192 }
193 return Sym;
194 }
195
196 class WebAssemblyAsmParser final : public MCTargetAsmParser {
197 MCAsmParser &Parser;
198 MCAsmLexer &Lexer;
199
200 // Much like WebAssemblyAsmPrinter in the backend, we have to own these.
201 std::vector<std::unique_ptr<wasm::WasmSignature>> Signatures;
202 std::vector<std::unique_ptr<std::string>> Names;
203
204 // Order of labels, directives and instructions in a .s file have no
205 // syntactical enforcement. This class is a callback from the actual parser,
206 // and yet we have to be feeding data to the streamer in a very particular
207 // order to ensure a correct binary encoding that matches the regular backend
208 // (the streamer does not enforce this). This "state machine" enum helps
209 // guarantee that correct order.
210 enum ParserState {
211 FileStart,
212 FunctionStart,
213 FunctionLocals,
214 Instructions,
215 EndFunction,
216 DataSection,
217 } CurrentState = FileStart;
218
219 // For ensuring blocks are properly nested.
220 enum NestingType {
221 Function,
222 Block,
223 Loop,
224 Try,
225 CatchAll,
226 If,
227 Else,
228 Undefined,
229 };
230 struct Nested {
231 NestingType NT;
232 wasm::WasmSignature Sig;
233 };
234 std::vector<Nested> NestingStack;
235
236 MCSymbolWasm *DefaultFunctionTable = nullptr;
237 MCSymbol *LastFunctionLabel = nullptr;
238
239 bool is64;
240
241 WebAssemblyAsmTypeCheck TC;
242 // Don't type check if -no-type-check was set.
243 bool SkipTypeCheck;
244
245 public:
WebAssemblyAsmParser(const MCSubtargetInfo & STI,MCAsmParser & Parser,const MCInstrInfo & MII,const MCTargetOptions & Options)246 WebAssemblyAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser,
247 const MCInstrInfo &MII, const MCTargetOptions &Options)
248 : MCTargetAsmParser(Options, STI, MII), Parser(Parser),
249 Lexer(Parser.getLexer()),
250 is64(STI.getTargetTriple().isArch64Bit()),
251 TC(Parser, MII, is64), SkipTypeCheck(Options.MCNoTypeCheck) {
252 setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
253 // Don't type check if this is inline asm, since that is a naked sequence of
254 // instructions without a function/locals decl.
255 auto &SM = Parser.getSourceManager();
256 auto BufferName =
257 SM.getBufferInfo(SM.getMainFileID()).Buffer->getBufferIdentifier();
258 if (BufferName == "<inline asm>")
259 SkipTypeCheck = true;
260 }
261
Initialize(MCAsmParser & Parser)262 void Initialize(MCAsmParser &Parser) override {
263 MCAsmParserExtension::Initialize(Parser);
264
265 DefaultFunctionTable = GetOrCreateFunctionTableSymbol(
266 getContext(), "__indirect_function_table");
267 if (!STI->checkFeatures("+reference-types"))
268 DefaultFunctionTable->setOmitFromLinkingSection();
269 }
270
271 #define GET_ASSEMBLER_HEADER
272 #include "WebAssemblyGenAsmMatcher.inc"
273
274 // TODO: This is required to be implemented, but appears unused.
ParseRegister(unsigned &,SMLoc &,SMLoc &)275 bool ParseRegister(unsigned & /*RegNo*/, SMLoc & /*StartLoc*/,
276 SMLoc & /*EndLoc*/) override {
277 llvm_unreachable("ParseRegister is not implemented.");
278 }
tryParseRegister(unsigned &,SMLoc &,SMLoc &)279 OperandMatchResultTy tryParseRegister(unsigned & /*RegNo*/,
280 SMLoc & /*StartLoc*/,
281 SMLoc & /*EndLoc*/) override {
282 llvm_unreachable("tryParseRegister is not implemented.");
283 }
284
error(const Twine & Msg,const AsmToken & Tok)285 bool error(const Twine &Msg, const AsmToken &Tok) {
286 return Parser.Error(Tok.getLoc(), Msg + Tok.getString());
287 }
288
error(const Twine & Msg)289 bool error(const Twine &Msg) {
290 return Parser.Error(Lexer.getTok().getLoc(), Msg);
291 }
292
addSignature(std::unique_ptr<wasm::WasmSignature> && Sig)293 void addSignature(std::unique_ptr<wasm::WasmSignature> &&Sig) {
294 Signatures.push_back(std::move(Sig));
295 }
296
storeName(StringRef Name)297 StringRef storeName(StringRef Name) {
298 std::unique_ptr<std::string> N = std::make_unique<std::string>(Name);
299 Names.push_back(std::move(N));
300 return *Names.back();
301 }
302
nestingString(NestingType NT)303 std::pair<StringRef, StringRef> nestingString(NestingType NT) {
304 switch (NT) {
305 case Function:
306 return {"function", "end_function"};
307 case Block:
308 return {"block", "end_block"};
309 case Loop:
310 return {"loop", "end_loop"};
311 case Try:
312 return {"try", "end_try/delegate"};
313 case CatchAll:
314 return {"catch_all", "end_try"};
315 case If:
316 return {"if", "end_if"};
317 case Else:
318 return {"else", "end_if"};
319 default:
320 llvm_unreachable("unknown NestingType");
321 }
322 }
323
push(NestingType NT)324 void push(NestingType NT) { NestingStack.push_back({NT, wasm::WasmSignature()}); }
325
pop(StringRef Ins,NestingType NT1,NestingType NT2=Undefined)326 bool pop(StringRef Ins, NestingType NT1, NestingType NT2 = Undefined) {
327 if (NestingStack.empty())
328 return error(Twine("End of block construct with no start: ") + Ins);
329 auto Top = NestingStack.back();
330 if (Top.NT != NT1 && Top.NT != NT2)
331 return error(Twine("Block construct type mismatch, expected: ") +
332 nestingString(Top.NT).second + ", instead got: " + Ins);
333 TC.setLastSig(Top.Sig);
334 NestingStack.pop_back();
335 return false;
336 }
337
ensureEmptyNestingStack()338 bool ensureEmptyNestingStack() {
339 auto Err = !NestingStack.empty();
340 while (!NestingStack.empty()) {
341 error(Twine("Unmatched block construct(s) at function end: ") +
342 nestingString(NestingStack.back().NT).first);
343 NestingStack.pop_back();
344 }
345 return Err;
346 }
347
isNext(AsmToken::TokenKind Kind)348 bool isNext(AsmToken::TokenKind Kind) {
349 auto Ok = Lexer.is(Kind);
350 if (Ok)
351 Parser.Lex();
352 return Ok;
353 }
354
expect(AsmToken::TokenKind Kind,const char * KindName)355 bool expect(AsmToken::TokenKind Kind, const char *KindName) {
356 if (!isNext(Kind))
357 return error(std::string("Expected ") + KindName + ", instead got: ",
358 Lexer.getTok());
359 return false;
360 }
361
expectIdent()362 StringRef expectIdent() {
363 if (!Lexer.is(AsmToken::Identifier)) {
364 error("Expected identifier, got: ", Lexer.getTok());
365 return StringRef();
366 }
367 auto Name = Lexer.getTok().getString();
368 Parser.Lex();
369 return Name;
370 }
371
parseRegTypeList(SmallVectorImpl<wasm::ValType> & Types)372 bool parseRegTypeList(SmallVectorImpl<wasm::ValType> &Types) {
373 while (Lexer.is(AsmToken::Identifier)) {
374 auto Type = WebAssembly::parseType(Lexer.getTok().getString());
375 if (!Type)
376 return error("unknown type: ", Lexer.getTok());
377 Types.push_back(Type.getValue());
378 Parser.Lex();
379 if (!isNext(AsmToken::Comma))
380 break;
381 }
382 return false;
383 }
384
parseSingleInteger(bool IsNegative,OperandVector & Operands)385 void parseSingleInteger(bool IsNegative, OperandVector &Operands) {
386 auto &Int = Lexer.getTok();
387 int64_t Val = Int.getIntVal();
388 if (IsNegative)
389 Val = -Val;
390 Operands.push_back(std::make_unique<WebAssemblyOperand>(
391 WebAssemblyOperand::Integer, Int.getLoc(), Int.getEndLoc(),
392 WebAssemblyOperand::IntOp{Val}));
393 Parser.Lex();
394 }
395
parseSingleFloat(bool IsNegative,OperandVector & Operands)396 bool parseSingleFloat(bool IsNegative, OperandVector &Operands) {
397 auto &Flt = Lexer.getTok();
398 double Val;
399 if (Flt.getString().getAsDouble(Val, false))
400 return error("Cannot parse real: ", Flt);
401 if (IsNegative)
402 Val = -Val;
403 Operands.push_back(std::make_unique<WebAssemblyOperand>(
404 WebAssemblyOperand::Float, Flt.getLoc(), Flt.getEndLoc(),
405 WebAssemblyOperand::FltOp{Val}));
406 Parser.Lex();
407 return false;
408 }
409
parseSpecialFloatMaybe(bool IsNegative,OperandVector & Operands)410 bool parseSpecialFloatMaybe(bool IsNegative, OperandVector &Operands) {
411 if (Lexer.isNot(AsmToken::Identifier))
412 return true;
413 auto &Flt = Lexer.getTok();
414 auto S = Flt.getString();
415 double Val;
416 if (S.compare_insensitive("infinity") == 0) {
417 Val = std::numeric_limits<double>::infinity();
418 } else if (S.compare_insensitive("nan") == 0) {
419 Val = std::numeric_limits<double>::quiet_NaN();
420 } else {
421 return true;
422 }
423 if (IsNegative)
424 Val = -Val;
425 Operands.push_back(std::make_unique<WebAssemblyOperand>(
426 WebAssemblyOperand::Float, Flt.getLoc(), Flt.getEndLoc(),
427 WebAssemblyOperand::FltOp{Val}));
428 Parser.Lex();
429 return false;
430 }
431
checkForP2AlignIfLoadStore(OperandVector & Operands,StringRef InstName)432 bool checkForP2AlignIfLoadStore(OperandVector &Operands, StringRef InstName) {
433 // FIXME: there is probably a cleaner way to do this.
434 auto IsLoadStore = InstName.find(".load") != StringRef::npos ||
435 InstName.find(".store") != StringRef::npos ||
436 InstName.find("prefetch") != StringRef::npos;
437 auto IsAtomic = InstName.find("atomic.") != StringRef::npos;
438 if (IsLoadStore || IsAtomic) {
439 // Parse load/store operands of the form: offset:p2align=align
440 if (IsLoadStore && isNext(AsmToken::Colon)) {
441 auto Id = expectIdent();
442 if (Id != "p2align")
443 return error("Expected p2align, instead got: " + Id);
444 if (expect(AsmToken::Equal, "="))
445 return true;
446 if (!Lexer.is(AsmToken::Integer))
447 return error("Expected integer constant");
448 parseSingleInteger(false, Operands);
449 } else {
450 // v128.{load,store}{8,16,32,64}_lane has both a memarg and a lane
451 // index. We need to avoid parsing an extra alignment operand for the
452 // lane index.
453 auto IsLoadStoreLane = InstName.find("_lane") != StringRef::npos;
454 if (IsLoadStoreLane && Operands.size() == 4)
455 return false;
456 // Alignment not specified (or atomics, must use default alignment).
457 // We can't just call WebAssembly::GetDefaultP2Align since we don't have
458 // an opcode until after the assembly matcher, so set a default to fix
459 // up later.
460 auto Tok = Lexer.getTok();
461 Operands.push_back(std::make_unique<WebAssemblyOperand>(
462 WebAssemblyOperand::Integer, Tok.getLoc(), Tok.getEndLoc(),
463 WebAssemblyOperand::IntOp{-1}));
464 }
465 }
466 return false;
467 }
468
addBlockTypeOperand(OperandVector & Operands,SMLoc NameLoc,WebAssembly::BlockType BT)469 void addBlockTypeOperand(OperandVector &Operands, SMLoc NameLoc,
470 WebAssembly::BlockType BT) {
471 if (BT != WebAssembly::BlockType::Void) {
472 wasm::WasmSignature Sig({static_cast<wasm::ValType>(BT)}, {});
473 TC.setLastSig(Sig);
474 NestingStack.back().Sig = Sig;
475 }
476 Operands.push_back(std::make_unique<WebAssemblyOperand>(
477 WebAssemblyOperand::Integer, NameLoc, NameLoc,
478 WebAssemblyOperand::IntOp{static_cast<int64_t>(BT)}));
479 }
480
parseLimits(wasm::WasmLimits * Limits)481 bool parseLimits(wasm::WasmLimits *Limits) {
482 auto Tok = Lexer.getTok();
483 if (!Tok.is(AsmToken::Integer))
484 return error("Expected integer constant, instead got: ", Tok);
485 int64_t Val = Tok.getIntVal();
486 assert(Val >= 0);
487 Limits->Minimum = Val;
488 Parser.Lex();
489
490 if (isNext(AsmToken::Comma)) {
491 Limits->Flags |= wasm::WASM_LIMITS_FLAG_HAS_MAX;
492 auto Tok = Lexer.getTok();
493 if (!Tok.is(AsmToken::Integer))
494 return error("Expected integer constant, instead got: ", Tok);
495 int64_t Val = Tok.getIntVal();
496 assert(Val >= 0);
497 Limits->Maximum = Val;
498 Parser.Lex();
499 }
500 return false;
501 }
502
parseFunctionTableOperand(std::unique_ptr<WebAssemblyOperand> * Op)503 bool parseFunctionTableOperand(std::unique_ptr<WebAssemblyOperand> *Op) {
504 if (STI->checkFeatures("+reference-types")) {
505 // If the reference-types feature is enabled, there is an explicit table
506 // operand. To allow the same assembly to be compiled with or without
507 // reference types, we allow the operand to be omitted, in which case we
508 // default to __indirect_function_table.
509 auto &Tok = Lexer.getTok();
510 if (Tok.is(AsmToken::Identifier)) {
511 auto *Sym =
512 GetOrCreateFunctionTableSymbol(getContext(), Tok.getString());
513 const auto *Val = MCSymbolRefExpr::create(Sym, getContext());
514 *Op = std::make_unique<WebAssemblyOperand>(
515 WebAssemblyOperand::Symbol, Tok.getLoc(), Tok.getEndLoc(),
516 WebAssemblyOperand::SymOp{Val});
517 Parser.Lex();
518 return expect(AsmToken::Comma, ",");
519 } else {
520 const auto *Val =
521 MCSymbolRefExpr::create(DefaultFunctionTable, getContext());
522 *Op = std::make_unique<WebAssemblyOperand>(
523 WebAssemblyOperand::Symbol, SMLoc(), SMLoc(),
524 WebAssemblyOperand::SymOp{Val});
525 return false;
526 }
527 } else {
528 // For the MVP there is at most one table whose number is 0, but we can't
529 // write a table symbol or issue relocations. Instead we just ensure the
530 // table is live and write a zero.
531 getStreamer().emitSymbolAttribute(DefaultFunctionTable, MCSA_NoDeadStrip);
532 *Op = std::make_unique<WebAssemblyOperand>(WebAssemblyOperand::Integer,
533 SMLoc(), SMLoc(),
534 WebAssemblyOperand::IntOp{0});
535 return false;
536 }
537 }
538
ParseInstruction(ParseInstructionInfo &,StringRef Name,SMLoc NameLoc,OperandVector & Operands)539 bool ParseInstruction(ParseInstructionInfo & /*Info*/, StringRef Name,
540 SMLoc NameLoc, OperandVector &Operands) override {
541 // Note: Name does NOT point into the sourcecode, but to a local, so
542 // use NameLoc instead.
543 Name = StringRef(NameLoc.getPointer(), Name.size());
544
545 // WebAssembly has instructions with / in them, which AsmLexer parses
546 // as separate tokens, so if we find such tokens immediately adjacent (no
547 // whitespace), expand the name to include them:
548 for (;;) {
549 auto &Sep = Lexer.getTok();
550 if (Sep.getLoc().getPointer() != Name.end() ||
551 Sep.getKind() != AsmToken::Slash)
552 break;
553 // Extend name with /
554 Name = StringRef(Name.begin(), Name.size() + Sep.getString().size());
555 Parser.Lex();
556 // We must now find another identifier, or error.
557 auto &Id = Lexer.getTok();
558 if (Id.getKind() != AsmToken::Identifier ||
559 Id.getLoc().getPointer() != Name.end())
560 return error("Incomplete instruction name: ", Id);
561 Name = StringRef(Name.begin(), Name.size() + Id.getString().size());
562 Parser.Lex();
563 }
564
565 // Now construct the name as first operand.
566 Operands.push_back(std::make_unique<WebAssemblyOperand>(
567 WebAssemblyOperand::Token, NameLoc, SMLoc::getFromPointer(Name.end()),
568 WebAssemblyOperand::TokOp{Name}));
569
570 // If this instruction is part of a control flow structure, ensure
571 // proper nesting.
572 bool ExpectBlockType = false;
573 bool ExpectFuncType = false;
574 bool ExpectHeapType = false;
575 std::unique_ptr<WebAssemblyOperand> FunctionTable;
576 if (Name == "block") {
577 push(Block);
578 ExpectBlockType = true;
579 } else if (Name == "loop") {
580 push(Loop);
581 ExpectBlockType = true;
582 } else if (Name == "try") {
583 push(Try);
584 ExpectBlockType = true;
585 } else if (Name == "if") {
586 push(If);
587 ExpectBlockType = true;
588 } else if (Name == "else") {
589 if (pop(Name, If))
590 return true;
591 push(Else);
592 } else if (Name == "catch") {
593 if (pop(Name, Try))
594 return true;
595 push(Try);
596 } else if (Name == "catch_all") {
597 if (pop(Name, Try))
598 return true;
599 push(CatchAll);
600 } else if (Name == "end_if") {
601 if (pop(Name, If, Else))
602 return true;
603 } else if (Name == "end_try") {
604 if (pop(Name, Try, CatchAll))
605 return true;
606 } else if (Name == "delegate") {
607 if (pop(Name, Try))
608 return true;
609 } else if (Name == "end_loop") {
610 if (pop(Name, Loop))
611 return true;
612 } else if (Name == "end_block") {
613 if (pop(Name, Block))
614 return true;
615 } else if (Name == "end_function") {
616 ensureLocals(getStreamer());
617 CurrentState = EndFunction;
618 if (pop(Name, Function) || ensureEmptyNestingStack())
619 return true;
620 } else if (Name == "call_indirect" || Name == "return_call_indirect") {
621 // These instructions have differing operand orders in the text format vs
622 // the binary formats. The MC instructions follow the binary format, so
623 // here we stash away the operand and append it later.
624 if (parseFunctionTableOperand(&FunctionTable))
625 return true;
626 ExpectFuncType = true;
627 } else if (Name == "ref.null") {
628 ExpectHeapType = true;
629 }
630
631 if (ExpectFuncType || (ExpectBlockType && Lexer.is(AsmToken::LParen))) {
632 // This has a special TYPEINDEX operand which in text we
633 // represent as a signature, such that we can re-build this signature,
634 // attach it to an anonymous symbol, which is what WasmObjectWriter
635 // expects to be able to recreate the actual unique-ified type indices.
636 auto Loc = Parser.getTok();
637 auto Signature = std::make_unique<wasm::WasmSignature>();
638 if (parseSignature(Signature.get()))
639 return true;
640 // Got signature as block type, don't need more
641 ExpectBlockType = false;
642 TC.setLastSig(*Signature.get());
643 if (ExpectBlockType)
644 NestingStack.back().Sig = *Signature.get();
645 auto &Ctx = getContext();
646 // The "true" here will cause this to be a nameless symbol.
647 MCSymbol *Sym = Ctx.createTempSymbol("typeindex", true);
648 auto *WasmSym = cast<MCSymbolWasm>(Sym);
649 WasmSym->setSignature(Signature.get());
650 addSignature(std::move(Signature));
651 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
652 const MCExpr *Expr = MCSymbolRefExpr::create(
653 WasmSym, MCSymbolRefExpr::VK_WASM_TYPEINDEX, Ctx);
654 Operands.push_back(std::make_unique<WebAssemblyOperand>(
655 WebAssemblyOperand::Symbol, Loc.getLoc(), Loc.getEndLoc(),
656 WebAssemblyOperand::SymOp{Expr}));
657 }
658
659 while (Lexer.isNot(AsmToken::EndOfStatement)) {
660 auto &Tok = Lexer.getTok();
661 switch (Tok.getKind()) {
662 case AsmToken::Identifier: {
663 if (!parseSpecialFloatMaybe(false, Operands))
664 break;
665 auto &Id = Lexer.getTok();
666 if (ExpectBlockType) {
667 // Assume this identifier is a block_type.
668 auto BT = WebAssembly::parseBlockType(Id.getString());
669 if (BT == WebAssembly::BlockType::Invalid)
670 return error("Unknown block type: ", Id);
671 addBlockTypeOperand(Operands, NameLoc, BT);
672 Parser.Lex();
673 } else if (ExpectHeapType) {
674 auto HeapType = WebAssembly::parseHeapType(Id.getString());
675 if (HeapType == WebAssembly::HeapType::Invalid) {
676 return error("Expected a heap type: ", Id);
677 }
678 Operands.push_back(std::make_unique<WebAssemblyOperand>(
679 WebAssemblyOperand::Integer, Id.getLoc(), Id.getEndLoc(),
680 WebAssemblyOperand::IntOp{static_cast<int64_t>(HeapType)}));
681 Parser.Lex();
682 } else {
683 // Assume this identifier is a label.
684 const MCExpr *Val;
685 SMLoc End;
686 if (Parser.parseExpression(Val, End))
687 return error("Cannot parse symbol: ", Lexer.getTok());
688 Operands.push_back(std::make_unique<WebAssemblyOperand>(
689 WebAssemblyOperand::Symbol, Id.getLoc(), Id.getEndLoc(),
690 WebAssemblyOperand::SymOp{Val}));
691 if (checkForP2AlignIfLoadStore(Operands, Name))
692 return true;
693 }
694 break;
695 }
696 case AsmToken::Minus:
697 Parser.Lex();
698 if (Lexer.is(AsmToken::Integer)) {
699 parseSingleInteger(true, Operands);
700 if (checkForP2AlignIfLoadStore(Operands, Name))
701 return true;
702 } else if(Lexer.is(AsmToken::Real)) {
703 if (parseSingleFloat(true, Operands))
704 return true;
705 } else if (!parseSpecialFloatMaybe(true, Operands)) {
706 } else {
707 return error("Expected numeric constant instead got: ",
708 Lexer.getTok());
709 }
710 break;
711 case AsmToken::Integer:
712 parseSingleInteger(false, Operands);
713 if (checkForP2AlignIfLoadStore(Operands, Name))
714 return true;
715 break;
716 case AsmToken::Real: {
717 if (parseSingleFloat(false, Operands))
718 return true;
719 break;
720 }
721 case AsmToken::LCurly: {
722 Parser.Lex();
723 auto Op = std::make_unique<WebAssemblyOperand>(
724 WebAssemblyOperand::BrList, Tok.getLoc(), Tok.getEndLoc());
725 if (!Lexer.is(AsmToken::RCurly))
726 for (;;) {
727 Op->BrL.List.push_back(Lexer.getTok().getIntVal());
728 expect(AsmToken::Integer, "integer");
729 if (!isNext(AsmToken::Comma))
730 break;
731 }
732 expect(AsmToken::RCurly, "}");
733 Operands.push_back(std::move(Op));
734 break;
735 }
736 default:
737 return error("Unexpected token in operand: ", Tok);
738 }
739 if (Lexer.isNot(AsmToken::EndOfStatement)) {
740 if (expect(AsmToken::Comma, ","))
741 return true;
742 }
743 }
744 if (ExpectBlockType && Operands.size() == 1) {
745 // Support blocks with no operands as default to void.
746 addBlockTypeOperand(Operands, NameLoc, WebAssembly::BlockType::Void);
747 }
748 if (FunctionTable)
749 Operands.push_back(std::move(FunctionTable));
750 Parser.Lex();
751 return false;
752 }
753
parseSignature(wasm::WasmSignature * Signature)754 bool parseSignature(wasm::WasmSignature *Signature) {
755 if (expect(AsmToken::LParen, "("))
756 return true;
757 if (parseRegTypeList(Signature->Params))
758 return true;
759 if (expect(AsmToken::RParen, ")"))
760 return true;
761 if (expect(AsmToken::MinusGreater, "->"))
762 return true;
763 if (expect(AsmToken::LParen, "("))
764 return true;
765 if (parseRegTypeList(Signature->Returns))
766 return true;
767 if (expect(AsmToken::RParen, ")"))
768 return true;
769 return false;
770 }
771
CheckDataSection()772 bool CheckDataSection() {
773 if (CurrentState != DataSection) {
774 auto WS = cast<MCSectionWasm>(getStreamer().getCurrentSection().first);
775 if (WS && WS->getKind().isText())
776 return error("data directive must occur in a data segment: ",
777 Lexer.getTok());
778 }
779 CurrentState = DataSection;
780 return false;
781 }
782
783 // This function processes wasm-specific directives streamed to
784 // WebAssemblyTargetStreamer, all others go to the generic parser
785 // (see WasmAsmParser).
ParseDirective(AsmToken DirectiveID)786 bool ParseDirective(AsmToken DirectiveID) override {
787 // This function has a really weird return value behavior that is different
788 // from all the other parsing functions:
789 // - return true && no tokens consumed -> don't know this directive / let
790 // the generic parser handle it.
791 // - return true && tokens consumed -> a parsing error occurred.
792 // - return false -> processed this directive successfully.
793 assert(DirectiveID.getKind() == AsmToken::Identifier);
794 auto &Out = getStreamer();
795 auto &TOut =
796 reinterpret_cast<WebAssemblyTargetStreamer &>(*Out.getTargetStreamer());
797 auto &Ctx = Out.getContext();
798
799 // TODO: any time we return an error, at least one token must have been
800 // consumed, otherwise this will not signal an error to the caller.
801 if (DirectiveID.getString() == ".globaltype") {
802 auto SymName = expectIdent();
803 if (SymName.empty())
804 return true;
805 if (expect(AsmToken::Comma, ","))
806 return true;
807 auto TypeTok = Lexer.getTok();
808 auto TypeName = expectIdent();
809 if (TypeName.empty())
810 return true;
811 auto Type = WebAssembly::parseType(TypeName);
812 if (!Type)
813 return error("Unknown type in .globaltype directive: ", TypeTok);
814 // Optional mutable modifier. Default to mutable for historical reasons.
815 // Ideally we would have gone with immutable as the default and used `mut`
816 // as the modifier to match the `.wat` format.
817 bool Mutable = true;
818 if (isNext(AsmToken::Comma)) {
819 TypeTok = Lexer.getTok();
820 auto Id = expectIdent();
821 if (Id == "immutable")
822 Mutable = false;
823 else
824 // Should we also allow `mutable` and `mut` here for clarity?
825 return error("Unknown type in .globaltype modifier: ", TypeTok);
826 }
827 // Now set this symbol with the correct type.
828 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
829 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
830 WasmSym->setGlobalType(
831 wasm::WasmGlobalType{uint8_t(Type.getValue()), Mutable});
832 // And emit the directive again.
833 TOut.emitGlobalType(WasmSym);
834 return expect(AsmToken::EndOfStatement, "EOL");
835 }
836
837 if (DirectiveID.getString() == ".tabletype") {
838 // .tabletype SYM, ELEMTYPE[, MINSIZE[, MAXSIZE]]
839 auto SymName = expectIdent();
840 if (SymName.empty())
841 return true;
842 if (expect(AsmToken::Comma, ","))
843 return true;
844
845 auto ElemTypeTok = Lexer.getTok();
846 auto ElemTypeName = expectIdent();
847 if (ElemTypeName.empty())
848 return true;
849 Optional<wasm::ValType> ElemType = WebAssembly::parseType(ElemTypeName);
850 if (!ElemType)
851 return error("Unknown type in .tabletype directive: ", ElemTypeTok);
852
853 wasm::WasmLimits Limits = DefaultLimits();
854 if (isNext(AsmToken::Comma) && parseLimits(&Limits))
855 return true;
856
857 // Now that we have the name and table type, we can actually create the
858 // symbol
859 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
860 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_TABLE);
861 wasm::WasmTableType Type = {uint8_t(ElemType.getValue()), Limits};
862 WasmSym->setTableType(Type);
863 TOut.emitTableType(WasmSym);
864 return expect(AsmToken::EndOfStatement, "EOL");
865 }
866
867 if (DirectiveID.getString() == ".functype") {
868 // This code has to send things to the streamer similar to
869 // WebAssemblyAsmPrinter::EmitFunctionBodyStart.
870 // TODO: would be good to factor this into a common function, but the
871 // assembler and backend really don't share any common code, and this code
872 // parses the locals separately.
873 auto SymName = expectIdent();
874 if (SymName.empty())
875 return true;
876 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
877 if (WasmSym->isDefined()) {
878 // This .functype indicates a start of a function.
879 if (ensureEmptyNestingStack())
880 return true;
881 CurrentState = FunctionStart;
882 LastFunctionLabel = WasmSym;
883 push(Function);
884 }
885 auto Signature = std::make_unique<wasm::WasmSignature>();
886 if (parseSignature(Signature.get()))
887 return true;
888 TC.funcDecl(*Signature);
889 WasmSym->setSignature(Signature.get());
890 addSignature(std::move(Signature));
891 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
892 TOut.emitFunctionType(WasmSym);
893 // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
894 return expect(AsmToken::EndOfStatement, "EOL");
895 }
896
897 if (DirectiveID.getString() == ".export_name") {
898 auto SymName = expectIdent();
899 if (SymName.empty())
900 return true;
901 if (expect(AsmToken::Comma, ","))
902 return true;
903 auto ExportName = expectIdent();
904 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
905 WasmSym->setExportName(storeName(ExportName));
906 TOut.emitExportName(WasmSym, ExportName);
907 }
908
909 if (DirectiveID.getString() == ".import_module") {
910 auto SymName = expectIdent();
911 if (SymName.empty())
912 return true;
913 if (expect(AsmToken::Comma, ","))
914 return true;
915 auto ImportModule = expectIdent();
916 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
917 WasmSym->setImportModule(storeName(ImportModule));
918 TOut.emitImportModule(WasmSym, ImportModule);
919 }
920
921 if (DirectiveID.getString() == ".import_name") {
922 auto SymName = expectIdent();
923 if (SymName.empty())
924 return true;
925 if (expect(AsmToken::Comma, ","))
926 return true;
927 auto ImportName = expectIdent();
928 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
929 WasmSym->setImportName(storeName(ImportName));
930 TOut.emitImportName(WasmSym, ImportName);
931 }
932
933 if (DirectiveID.getString() == ".tagtype") {
934 auto SymName = expectIdent();
935 if (SymName.empty())
936 return true;
937 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
938 auto Signature = std::make_unique<wasm::WasmSignature>();
939 if (parseRegTypeList(Signature->Params))
940 return true;
941 WasmSym->setSignature(Signature.get());
942 addSignature(std::move(Signature));
943 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_TAG);
944 TOut.emitTagType(WasmSym);
945 // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
946 return expect(AsmToken::EndOfStatement, "EOL");
947 }
948
949 if (DirectiveID.getString() == ".local") {
950 if (CurrentState != FunctionStart)
951 return error(".local directive should follow the start of a function: ",
952 Lexer.getTok());
953 SmallVector<wasm::ValType, 4> Locals;
954 if (parseRegTypeList(Locals))
955 return true;
956 TC.localDecl(Locals);
957 TOut.emitLocal(Locals);
958 CurrentState = FunctionLocals;
959 return expect(AsmToken::EndOfStatement, "EOL");
960 }
961
962 if (DirectiveID.getString() == ".int8" ||
963 DirectiveID.getString() == ".int16" ||
964 DirectiveID.getString() == ".int32" ||
965 DirectiveID.getString() == ".int64") {
966 if (CheckDataSection()) return true;
967 const MCExpr *Val;
968 SMLoc End;
969 if (Parser.parseExpression(Val, End))
970 return error("Cannot parse .int expression: ", Lexer.getTok());
971 size_t NumBits = 0;
972 DirectiveID.getString().drop_front(4).getAsInteger(10, NumBits);
973 Out.emitValue(Val, NumBits / 8, End);
974 return expect(AsmToken::EndOfStatement, "EOL");
975 }
976
977 if (DirectiveID.getString() == ".asciz") {
978 if (CheckDataSection()) return true;
979 std::string S;
980 if (Parser.parseEscapedString(S))
981 return error("Cannot parse string constant: ", Lexer.getTok());
982 Out.emitBytes(StringRef(S.c_str(), S.length() + 1));
983 return expect(AsmToken::EndOfStatement, "EOL");
984 }
985
986 return true; // We didn't process this directive.
987 }
988
989 // Called either when the first instruction is parsed of the function ends.
ensureLocals(MCStreamer & Out)990 void ensureLocals(MCStreamer &Out) {
991 if (CurrentState == FunctionStart) {
992 // We haven't seen a .local directive yet. The streamer requires locals to
993 // be encoded as a prelude to the instructions, so emit an empty list of
994 // locals here.
995 auto &TOut = reinterpret_cast<WebAssemblyTargetStreamer &>(
996 *Out.getTargetStreamer());
997 TOut.emitLocal(SmallVector<wasm::ValType, 0>());
998 CurrentState = FunctionLocals;
999 }
1000 }
1001
MatchAndEmitInstruction(SMLoc IDLoc,unsigned &,OperandVector & Operands,MCStreamer & Out,uint64_t & ErrorInfo,bool MatchingInlineAsm)1002 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned & /*Opcode*/,
1003 OperandVector &Operands, MCStreamer &Out,
1004 uint64_t &ErrorInfo,
1005 bool MatchingInlineAsm) override {
1006 MCInst Inst;
1007 Inst.setLoc(IDLoc);
1008 FeatureBitset MissingFeatures;
1009 unsigned MatchResult = MatchInstructionImpl(
1010 Operands, Inst, ErrorInfo, MissingFeatures, MatchingInlineAsm);
1011 switch (MatchResult) {
1012 case Match_Success: {
1013 ensureLocals(Out);
1014 // Fix unknown p2align operands.
1015 auto Align = WebAssembly::GetDefaultP2AlignAny(Inst.getOpcode());
1016 if (Align != -1U) {
1017 auto &Op0 = Inst.getOperand(0);
1018 if (Op0.getImm() == -1)
1019 Op0.setImm(Align);
1020 }
1021 if (is64) {
1022 // Upgrade 32-bit loads/stores to 64-bit. These mostly differ by having
1023 // an offset64 arg instead of offset32, but to the assembler matcher
1024 // they're both immediates so don't get selected for.
1025 auto Opc64 = WebAssembly::getWasm64Opcode(
1026 static_cast<uint16_t>(Inst.getOpcode()));
1027 if (Opc64 >= 0) {
1028 Inst.setOpcode(Opc64);
1029 }
1030 }
1031 if (!SkipTypeCheck && TC.typeCheck(IDLoc, Inst))
1032 return true;
1033 Out.emitInstruction(Inst, getSTI());
1034 if (CurrentState == EndFunction) {
1035 onEndOfFunction(IDLoc);
1036 } else {
1037 CurrentState = Instructions;
1038 }
1039 return false;
1040 }
1041 case Match_MissingFeature: {
1042 assert(MissingFeatures.count() > 0 && "Expected missing features");
1043 SmallString<128> Message;
1044 raw_svector_ostream OS(Message);
1045 OS << "instruction requires:";
1046 for (unsigned i = 0, e = MissingFeatures.size(); i != e; ++i)
1047 if (MissingFeatures.test(i))
1048 OS << ' ' << getSubtargetFeatureName(i);
1049 return Parser.Error(IDLoc, Message);
1050 }
1051 case Match_MnemonicFail:
1052 return Parser.Error(IDLoc, "invalid instruction");
1053 case Match_NearMisses:
1054 return Parser.Error(IDLoc, "ambiguous instruction");
1055 case Match_InvalidTiedOperand:
1056 case Match_InvalidOperand: {
1057 SMLoc ErrorLoc = IDLoc;
1058 if (ErrorInfo != ~0ULL) {
1059 if (ErrorInfo >= Operands.size())
1060 return Parser.Error(IDLoc, "too few operands for instruction");
1061 ErrorLoc = Operands[ErrorInfo]->getStartLoc();
1062 if (ErrorLoc == SMLoc())
1063 ErrorLoc = IDLoc;
1064 }
1065 return Parser.Error(ErrorLoc, "invalid operand for instruction");
1066 }
1067 }
1068 llvm_unreachable("Implement any new match types added!");
1069 }
1070
doBeforeLabelEmit(MCSymbol * Symbol)1071 void doBeforeLabelEmit(MCSymbol *Symbol) override {
1072 // Code below only applies to labels in text sections.
1073 auto CWS = cast<MCSectionWasm>(getStreamer().getCurrentSection().first);
1074 if (!CWS || !CWS->getKind().isText())
1075 return;
1076
1077 auto WasmSym = cast<MCSymbolWasm>(Symbol);
1078 // Unlike other targets, we don't allow data in text sections (labels
1079 // declared with .type @object).
1080 if (WasmSym->getType() == wasm::WASM_SYMBOL_TYPE_DATA) {
1081 Parser.Error(Parser.getTok().getLoc(),
1082 "Wasm doesn\'t support data symbols in text sections");
1083 return;
1084 }
1085
1086 // Start a new section for the next function automatically, since our
1087 // object writer expects each function to have its own section. This way
1088 // The user can't forget this "convention".
1089 auto SymName = Symbol->getName();
1090 if (SymName.startswith(".L"))
1091 return; // Local Symbol.
1092
1093 // TODO: If the user explicitly creates a new function section, we ignore
1094 // its name when we create this one. It would be nice to honor their
1095 // choice, while still ensuring that we create one if they forget.
1096 // (that requires coordination with WasmAsmParser::parseSectionDirective)
1097 auto SecName = ".text." + SymName;
1098
1099 auto *Group = CWS->getGroup();
1100 // If the current section is a COMDAT, also set the flag on the symbol.
1101 // TODO: Currently the only place that the symbols' comdat flag matters is
1102 // for importing comdat functions. But there's no way to specify that in
1103 // assembly currently.
1104 if (Group)
1105 WasmSym->setComdat(true);
1106 auto *WS =
1107 getContext().getWasmSection(SecName, SectionKind::getText(), 0, Group,
1108 MCContext::GenericSectionID, nullptr);
1109 getStreamer().SwitchSection(WS);
1110 // Also generate DWARF for this section if requested.
1111 if (getContext().getGenDwarfForAssembly())
1112 getContext().addGenDwarfSection(WS);
1113 }
1114
onEndOfFunction(SMLoc ErrorLoc)1115 void onEndOfFunction(SMLoc ErrorLoc) {
1116 TC.endOfFunction(ErrorLoc);
1117
1118 // Automatically output a .size directive, so it becomes optional for the
1119 // user.
1120 if (!LastFunctionLabel) return;
1121 auto TempSym = getContext().createLinkerPrivateTempSymbol();
1122 getStreamer().emitLabel(TempSym);
1123 auto Start = MCSymbolRefExpr::create(LastFunctionLabel, getContext());
1124 auto End = MCSymbolRefExpr::create(TempSym, getContext());
1125 auto Expr =
1126 MCBinaryExpr::create(MCBinaryExpr::Sub, End, Start, getContext());
1127 getStreamer().emitELFSize(LastFunctionLabel, Expr);
1128 }
1129
onEndOfFile()1130 void onEndOfFile() override { ensureEmptyNestingStack(); }
1131 };
1132 } // end anonymous namespace
1133
1134 // Force static initialization.
LLVMInitializeWebAssemblyAsmParser()1135 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeWebAssemblyAsmParser() {
1136 RegisterMCAsmParser<WebAssemblyAsmParser> X(getTheWebAssemblyTarget32());
1137 RegisterMCAsmParser<WebAssemblyAsmParser> Y(getTheWebAssemblyTarget64());
1138 }
1139
1140 #define GET_REGISTER_MATCHER
1141 #define GET_SUBTARGET_FEATURE_NAME
1142 #define GET_MATCHER_IMPLEMENTATION
1143 #include "WebAssemblyGenAsmMatcher.inc"
1144
GetMnemonic(unsigned Opc)1145 StringRef GetMnemonic(unsigned Opc) {
1146 // FIXME: linear search!
1147 for (auto &ME : MatchTable0) {
1148 if (ME.Opcode == Opc) {
1149 return ME.getMnemonic();
1150 }
1151 }
1152 assert(false && "mnemonic not found");
1153 return StringRef();
1154 }
1155