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 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) 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 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) 137 Inst.addOperand(MCOperand::createImm(Br)); 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 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: 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. 213 bool ParseRegister(unsigned & /*RegNo*/, SMLoc & /*StartLoc*/, 214 SMLoc & /*EndLoc*/) override { 215 llvm_unreachable("ParseRegister is not implemented."); 216 } 217 218 bool error(const Twine &Msg, const AsmToken &Tok) { 219 return Parser.Error(Tok.getLoc(), Msg + Tok.getString()); 220 } 221 222 bool error(const Twine &Msg) { 223 return Parser.Error(Lexer.getTok().getLoc(), Msg); 224 } 225 226 void addSignature(std::unique_ptr<wasm::WasmSignature> &&Sig) { 227 Signatures.push_back(std::move(Sig)); 228 } 229 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 249 void push(NestingType NT) { NestingStack.push_back(NT); } 250 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 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 272 bool isNext(AsmToken::TokenKind Kind) { 273 auto Ok = Lexer.is(Kind); 274 if (Ok) 275 Parser.Lex(); 276 return Ok; 277 } 278 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 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 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 316 WebAssembly::ExprType parseBlockType(StringRef ID) { 317 return StringSwitch<WebAssembly::ExprType>(ID) 318 .Case("i32", WebAssembly::ExprType::I32) 319 .Case("i64", WebAssembly::ExprType::I64) 320 .Case("f32", WebAssembly::ExprType::F32) 321 .Case("f64", WebAssembly::ExprType::F64) 322 .Case("v128", WebAssembly::ExprType::V128) 323 .Case("exnref", WebAssembly::ExprType::Exnref) 324 .Case("void", WebAssembly::ExprType::Void) 325 .Default(WebAssembly::ExprType::Invalid); 326 } 327 328 bool parseRegTypeList(SmallVectorImpl<wasm::ValType> &Types) { 329 while (Lexer.is(AsmToken::Identifier)) { 330 auto Type = parseType(Lexer.getTok().getString()); 331 if (!Type) 332 return error("unknown type: ", Lexer.getTok()); 333 Types.push_back(Type.getValue()); 334 Parser.Lex(); 335 if (!isNext(AsmToken::Comma)) 336 break; 337 } 338 return false; 339 } 340 341 void parseSingleInteger(bool IsNegative, OperandVector &Operands) { 342 auto &Int = Lexer.getTok(); 343 int64_t Val = Int.getIntVal(); 344 if (IsNegative) 345 Val = -Val; 346 Operands.push_back(make_unique<WebAssemblyOperand>( 347 WebAssemblyOperand::Integer, Int.getLoc(), Int.getEndLoc(), 348 WebAssemblyOperand::IntOp{Val})); 349 Parser.Lex(); 350 } 351 352 bool parseSingleFloat(bool IsNegative, OperandVector &Operands) { 353 auto &Flt = Lexer.getTok(); 354 double Val; 355 if (Flt.getString().getAsDouble(Val, false)) 356 return error("Cannot parse real: ", Flt); 357 if (IsNegative) 358 Val = -Val; 359 Operands.push_back(make_unique<WebAssemblyOperand>( 360 WebAssemblyOperand::Float, Flt.getLoc(), Flt.getEndLoc(), 361 WebAssemblyOperand::FltOp{Val})); 362 Parser.Lex(); 363 return false; 364 } 365 366 bool parseSpecialFloatMaybe(bool IsNegative, OperandVector &Operands) { 367 if (Lexer.isNot(AsmToken::Identifier)) 368 return true; 369 auto &Flt = Lexer.getTok(); 370 auto S = Flt.getString(); 371 double Val; 372 if (S.compare_lower("infinity") == 0) { 373 Val = std::numeric_limits<double>::infinity(); 374 } else if (S.compare_lower("nan") == 0) { 375 Val = std::numeric_limits<double>::quiet_NaN(); 376 } else { 377 return true; 378 } 379 if (IsNegative) 380 Val = -Val; 381 Operands.push_back(make_unique<WebAssemblyOperand>( 382 WebAssemblyOperand::Float, Flt.getLoc(), Flt.getEndLoc(), 383 WebAssemblyOperand::FltOp{Val})); 384 Parser.Lex(); 385 return false; 386 } 387 388 bool checkForP2AlignIfLoadStore(OperandVector &Operands, StringRef InstName) { 389 // FIXME: there is probably a cleaner way to do this. 390 auto IsLoadStore = InstName.find(".load") != StringRef::npos || 391 InstName.find(".store") != StringRef::npos; 392 auto IsAtomic = InstName.find("atomic.") != StringRef::npos; 393 if (IsLoadStore || IsAtomic) { 394 // Parse load/store operands of the form: offset:p2align=align 395 if (IsLoadStore && isNext(AsmToken::Colon)) { 396 auto Id = expectIdent(); 397 if (Id != "p2align") 398 return error("Expected p2align, instead got: " + Id); 399 if (expect(AsmToken::Equal, "=")) 400 return true; 401 if (!Lexer.is(AsmToken::Integer)) 402 return error("Expected integer constant"); 403 parseSingleInteger(false, Operands); 404 } else { 405 // Alignment not specified (or atomics, must use default alignment). 406 // We can't just call WebAssembly::GetDefaultP2Align since we don't have 407 // an opcode until after the assembly matcher, so set a default to fix 408 // up later. 409 auto Tok = Lexer.getTok(); 410 Operands.push_back(make_unique<WebAssemblyOperand>( 411 WebAssemblyOperand::Integer, Tok.getLoc(), Tok.getEndLoc(), 412 WebAssemblyOperand::IntOp{-1})); 413 } 414 } 415 return false; 416 } 417 418 void addBlockTypeOperand(OperandVector &Operands, SMLoc NameLoc, 419 WebAssembly::ExprType BT) { 420 Operands.push_back(make_unique<WebAssemblyOperand>( 421 WebAssemblyOperand::Integer, NameLoc, NameLoc, 422 WebAssemblyOperand::IntOp{static_cast<int64_t>(BT)})); 423 } 424 425 bool ParseInstruction(ParseInstructionInfo & /*Info*/, StringRef Name, 426 SMLoc NameLoc, OperandVector &Operands) override { 427 // Note: Name does NOT point into the sourcecode, but to a local, so 428 // use NameLoc instead. 429 Name = StringRef(NameLoc.getPointer(), Name.size()); 430 431 // WebAssembly has instructions with / in them, which AsmLexer parses 432 // as seperate tokens, so if we find such tokens immediately adjacent (no 433 // whitespace), expand the name to include them: 434 for (;;) { 435 auto &Sep = Lexer.getTok(); 436 if (Sep.getLoc().getPointer() != Name.end() || 437 Sep.getKind() != AsmToken::Slash) 438 break; 439 // Extend name with / 440 Name = StringRef(Name.begin(), Name.size() + Sep.getString().size()); 441 Parser.Lex(); 442 // We must now find another identifier, or error. 443 auto &Id = Lexer.getTok(); 444 if (Id.getKind() != AsmToken::Identifier || 445 Id.getLoc().getPointer() != Name.end()) 446 return error("Incomplete instruction name: ", Id); 447 Name = StringRef(Name.begin(), Name.size() + Id.getString().size()); 448 Parser.Lex(); 449 } 450 451 // Now construct the name as first operand. 452 Operands.push_back(make_unique<WebAssemblyOperand>( 453 WebAssemblyOperand::Token, NameLoc, SMLoc::getFromPointer(Name.end()), 454 WebAssemblyOperand::TokOp{Name})); 455 456 // If this instruction is part of a control flow structure, ensure 457 // proper nesting. 458 bool ExpectBlockType = false; 459 if (Name == "block") { 460 push(Block); 461 ExpectBlockType = true; 462 } else if (Name == "loop") { 463 push(Loop); 464 ExpectBlockType = true; 465 } else if (Name == "try") { 466 push(Try); 467 ExpectBlockType = true; 468 } else if (Name == "if") { 469 push(If); 470 ExpectBlockType = true; 471 } else if (Name == "else") { 472 if (pop(Name, If)) 473 return true; 474 push(Else); 475 } else if (Name == "catch") { 476 if (pop(Name, Try)) 477 return true; 478 push(Try); 479 } else if (Name == "end_if") { 480 if (pop(Name, If, Else)) 481 return true; 482 } else if (Name == "end_try") { 483 if (pop(Name, Try)) 484 return true; 485 } else if (Name == "end_loop") { 486 if (pop(Name, Loop)) 487 return true; 488 } else if (Name == "end_block") { 489 if (pop(Name, Block)) 490 return true; 491 } else if (Name == "end_function") { 492 CurrentState = EndFunction; 493 if (pop(Name, Function) || ensureEmptyNestingStack()) 494 return true; 495 } 496 497 while (Lexer.isNot(AsmToken::EndOfStatement)) { 498 auto &Tok = Lexer.getTok(); 499 switch (Tok.getKind()) { 500 case AsmToken::Identifier: { 501 if (!parseSpecialFloatMaybe(false, Operands)) 502 break; 503 auto &Id = Lexer.getTok(); 504 if (ExpectBlockType) { 505 // Assume this identifier is a block_type. 506 auto BT = parseBlockType(Id.getString()); 507 if (BT == WebAssembly::ExprType::Invalid) 508 return error("Unknown block type: ", Id); 509 addBlockTypeOperand(Operands, NameLoc, BT); 510 Parser.Lex(); 511 } else { 512 // Assume this identifier is a label. 513 const MCExpr *Val; 514 SMLoc End; 515 if (Parser.parseExpression(Val, End)) 516 return error("Cannot parse symbol: ", Lexer.getTok()); 517 Operands.push_back(make_unique<WebAssemblyOperand>( 518 WebAssemblyOperand::Symbol, Id.getLoc(), Id.getEndLoc(), 519 WebAssemblyOperand::SymOp{Val})); 520 if (checkForP2AlignIfLoadStore(Operands, Name)) 521 return true; 522 } 523 break; 524 } 525 case AsmToken::Minus: 526 Parser.Lex(); 527 if (Lexer.is(AsmToken::Integer)) { 528 parseSingleInteger(true, Operands); 529 if (checkForP2AlignIfLoadStore(Operands, Name)) 530 return true; 531 } else if(Lexer.is(AsmToken::Real)) { 532 if (parseSingleFloat(true, Operands)) 533 return true; 534 } else if (!parseSpecialFloatMaybe(true, Operands)) { 535 } else { 536 return error("Expected numeric constant instead got: ", 537 Lexer.getTok()); 538 } 539 break; 540 case AsmToken::Integer: 541 parseSingleInteger(false, Operands); 542 if (checkForP2AlignIfLoadStore(Operands, Name)) 543 return true; 544 break; 545 case AsmToken::Real: { 546 if (parseSingleFloat(false, Operands)) 547 return true; 548 break; 549 } 550 case AsmToken::LCurly: { 551 Parser.Lex(); 552 auto Op = make_unique<WebAssemblyOperand>( 553 WebAssemblyOperand::BrList, Tok.getLoc(), Tok.getEndLoc()); 554 if (!Lexer.is(AsmToken::RCurly)) 555 for (;;) { 556 Op->BrL.List.push_back(Lexer.getTok().getIntVal()); 557 expect(AsmToken::Integer, "integer"); 558 if (!isNext(AsmToken::Comma)) 559 break; 560 } 561 expect(AsmToken::RCurly, "}"); 562 Operands.push_back(std::move(Op)); 563 break; 564 } 565 default: 566 return error("Unexpected token in operand: ", Tok); 567 } 568 if (Lexer.isNot(AsmToken::EndOfStatement)) { 569 if (expect(AsmToken::Comma, ",")) 570 return true; 571 } 572 } 573 if (ExpectBlockType && Operands.size() == 1) { 574 // Support blocks with no operands as default to void. 575 addBlockTypeOperand(Operands, NameLoc, WebAssembly::ExprType::Void); 576 } 577 Parser.Lex(); 578 return false; 579 } 580 581 void onLabelParsed(MCSymbol *Symbol) override { 582 LastLabel = Symbol; 583 CurrentState = Label; 584 } 585 586 bool parseSignature(wasm::WasmSignature *Signature) { 587 if (expect(AsmToken::LParen, "(")) 588 return true; 589 if (parseRegTypeList(Signature->Params)) 590 return true; 591 if (expect(AsmToken::RParen, ")")) 592 return true; 593 if (expect(AsmToken::MinusGreater, "->")) 594 return true; 595 if (expect(AsmToken::LParen, "(")) 596 return true; 597 if (parseRegTypeList(Signature->Returns)) 598 return true; 599 if (expect(AsmToken::RParen, ")")) 600 return true; 601 return false; 602 } 603 604 bool CheckDataSection() { 605 if (CurrentState != DataSection) { 606 auto WS = cast<MCSectionWasm>(getStreamer().getCurrentSection().first); 607 if (WS && WS->getKind().isText()) 608 return error("data directive must occur in a data segment: ", 609 Lexer.getTok()); 610 } 611 CurrentState = DataSection; 612 return false; 613 } 614 615 // This function processes wasm-specific directives streamed to 616 // WebAssemblyTargetStreamer, all others go to the generic parser 617 // (see WasmAsmParser). 618 bool ParseDirective(AsmToken DirectiveID) override { 619 // This function has a really weird return value behavior that is different 620 // from all the other parsing functions: 621 // - return true && no tokens consumed -> don't know this directive / let 622 // the generic parser handle it. 623 // - return true && tokens consumed -> a parsing error occurred. 624 // - return false -> processed this directive successfully. 625 assert(DirectiveID.getKind() == AsmToken::Identifier); 626 auto &Out = getStreamer(); 627 auto &TOut = 628 reinterpret_cast<WebAssemblyTargetStreamer &>(*Out.getTargetStreamer()); 629 auto &Ctx = Out.getContext(); 630 631 // TODO: any time we return an error, at least one token must have been 632 // consumed, otherwise this will not signal an error to the caller. 633 if (DirectiveID.getString() == ".globaltype") { 634 auto SymName = expectIdent(); 635 if (SymName.empty()) 636 return true; 637 if (expect(AsmToken::Comma, ",")) 638 return true; 639 auto TypeTok = Lexer.getTok(); 640 auto TypeName = expectIdent(); 641 if (TypeName.empty()) 642 return true; 643 auto Type = parseType(TypeName); 644 if (!Type) 645 return error("Unknown type in .globaltype directive: ", TypeTok); 646 // Now set this symbol with the correct type. 647 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName)); 648 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL); 649 WasmSym->setGlobalType( 650 wasm::WasmGlobalType{uint8_t(Type.getValue()), true}); 651 // And emit the directive again. 652 TOut.emitGlobalType(WasmSym); 653 return expect(AsmToken::EndOfStatement, "EOL"); 654 } 655 656 if (DirectiveID.getString() == ".functype") { 657 // This code has to send things to the streamer similar to 658 // WebAssemblyAsmPrinter::EmitFunctionBodyStart. 659 // TODO: would be good to factor this into a common function, but the 660 // assembler and backend really don't share any common code, and this code 661 // parses the locals seperately. 662 auto SymName = expectIdent(); 663 if (SymName.empty()) 664 return true; 665 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName)); 666 if (CurrentState == Label && WasmSym == LastLabel) { 667 // This .functype indicates a start of a function. 668 if (ensureEmptyNestingStack()) 669 return true; 670 CurrentState = FunctionStart; 671 LastFunctionLabel = LastLabel; 672 push(Function); 673 } 674 auto Signature = make_unique<wasm::WasmSignature>(); 675 if (parseSignature(Signature.get())) 676 return true; 677 WasmSym->setSignature(Signature.get()); 678 addSignature(std::move(Signature)); 679 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION); 680 TOut.emitFunctionType(WasmSym); 681 // TODO: backend also calls TOut.emitIndIdx, but that is not implemented. 682 return expect(AsmToken::EndOfStatement, "EOL"); 683 } 684 685 if (DirectiveID.getString() == ".eventtype") { 686 auto SymName = expectIdent(); 687 if (SymName.empty()) 688 return true; 689 auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName)); 690 auto Signature = make_unique<wasm::WasmSignature>(); 691 if (parseRegTypeList(Signature->Params)) 692 return true; 693 WasmSym->setSignature(Signature.get()); 694 addSignature(std::move(Signature)); 695 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_EVENT); 696 TOut.emitEventType(WasmSym); 697 // TODO: backend also calls TOut.emitIndIdx, but that is not implemented. 698 return expect(AsmToken::EndOfStatement, "EOL"); 699 } 700 701 if (DirectiveID.getString() == ".local") { 702 if (CurrentState != FunctionStart) 703 return error(".local directive should follow the start of a function", 704 Lexer.getTok()); 705 SmallVector<wasm::ValType, 4> Locals; 706 if (parseRegTypeList(Locals)) 707 return true; 708 TOut.emitLocal(Locals); 709 CurrentState = FunctionLocals; 710 return expect(AsmToken::EndOfStatement, "EOL"); 711 } 712 713 if (DirectiveID.getString() == ".int8" || 714 DirectiveID.getString() == ".int16" || 715 DirectiveID.getString() == ".int32" || 716 DirectiveID.getString() == ".int64") { 717 if (CheckDataSection()) return true; 718 const MCExpr *Val; 719 SMLoc End; 720 if (Parser.parseExpression(Val, End)) 721 return error("Cannot parse .int expression: ", Lexer.getTok()); 722 size_t NumBits = 0; 723 DirectiveID.getString().drop_front(4).getAsInteger(10, NumBits); 724 Out.EmitValue(Val, NumBits / 8, End); 725 return expect(AsmToken::EndOfStatement, "EOL"); 726 } 727 728 if (DirectiveID.getString() == ".asciz") { 729 if (CheckDataSection()) return true; 730 std::string S; 731 if (Parser.parseEscapedString(S)) 732 return error("Cannot parse string constant: ", Lexer.getTok()); 733 Out.EmitBytes(StringRef(S.c_str(), S.length() + 1)); 734 return expect(AsmToken::EndOfStatement, "EOL"); 735 } 736 737 return true; // We didn't process this directive. 738 } 739 740 bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned & /*Opcode*/, 741 OperandVector &Operands, MCStreamer &Out, 742 uint64_t &ErrorInfo, 743 bool MatchingInlineAsm) override { 744 MCInst Inst; 745 unsigned MatchResult = 746 MatchInstructionImpl(Operands, Inst, ErrorInfo, MatchingInlineAsm); 747 switch (MatchResult) { 748 case Match_Success: { 749 if (CurrentState == FunctionStart) { 750 // This is the first instruction in a function, but we haven't seen 751 // a .local directive yet. The streamer requires locals to be encoded 752 // as a prelude to the instructions, so emit an empty list of locals 753 // here. 754 auto &TOut = reinterpret_cast<WebAssemblyTargetStreamer &>( 755 *Out.getTargetStreamer()); 756 TOut.emitLocal(SmallVector<wasm::ValType, 0>()); 757 } 758 // Fix unknown p2align operands. 759 auto Align = WebAssembly::GetDefaultP2AlignAny(Inst.getOpcode()); 760 if (Align != -1U) { 761 auto &Op0 = Inst.getOperand(0); 762 if (Op0.getImm() == -1) 763 Op0.setImm(Align); 764 } 765 Out.EmitInstruction(Inst, getSTI()); 766 if (CurrentState == EndFunction) { 767 onEndOfFunction(); 768 } else { 769 CurrentState = Instructions; 770 } 771 return false; 772 } 773 case Match_MissingFeature: 774 return Parser.Error( 775 IDLoc, "instruction requires a WASM feature not currently enabled"); 776 case Match_MnemonicFail: 777 return Parser.Error(IDLoc, "invalid instruction"); 778 case Match_NearMisses: 779 return Parser.Error(IDLoc, "ambiguous instruction"); 780 case Match_InvalidTiedOperand: 781 case Match_InvalidOperand: { 782 SMLoc ErrorLoc = IDLoc; 783 if (ErrorInfo != ~0ULL) { 784 if (ErrorInfo >= Operands.size()) 785 return Parser.Error(IDLoc, "too few operands for instruction"); 786 ErrorLoc = Operands[ErrorInfo]->getStartLoc(); 787 if (ErrorLoc == SMLoc()) 788 ErrorLoc = IDLoc; 789 } 790 return Parser.Error(ErrorLoc, "invalid operand for instruction"); 791 } 792 } 793 llvm_unreachable("Implement any new match types added!"); 794 } 795 796 void doBeforeLabelEmit(MCSymbol *Symbol) override { 797 // Start a new section for the next function automatically, since our 798 // object writer expects each function to have its own section. This way 799 // The user can't forget this "convention". 800 auto SymName = Symbol->getName(); 801 if (SymName.startswith(".L")) 802 return; // Local Symbol. 803 // Only create a new text section if we're already in one. 804 auto CWS = cast<MCSectionWasm>(getStreamer().getCurrentSection().first); 805 if (!CWS || !CWS->getKind().isText()) 806 return; 807 auto SecName = ".text." + SymName; 808 auto WS = getContext().getWasmSection(SecName, SectionKind::getText()); 809 getStreamer().SwitchSection(WS); 810 } 811 812 void onEndOfFunction() { 813 // Automatically output a .size directive, so it becomes optional for the 814 // user. 815 if (!LastFunctionLabel) return; 816 auto TempSym = getContext().createLinkerPrivateTempSymbol(); 817 getStreamer().EmitLabel(TempSym); 818 auto Start = MCSymbolRefExpr::create(LastFunctionLabel, getContext()); 819 auto End = MCSymbolRefExpr::create(TempSym, getContext()); 820 auto Expr = 821 MCBinaryExpr::create(MCBinaryExpr::Sub, End, Start, getContext()); 822 getStreamer().emitELFSize(LastFunctionLabel, Expr); 823 } 824 825 void onEndOfFile() override { ensureEmptyNestingStack(); } 826 }; 827 } // end anonymous namespace 828 829 // Force static initialization. 830 extern "C" void LLVMInitializeWebAssemblyAsmParser() { 831 RegisterMCAsmParser<WebAssemblyAsmParser> X(getTheWebAssemblyTarget32()); 832 RegisterMCAsmParser<WebAssemblyAsmParser> Y(getTheWebAssemblyTarget64()); 833 } 834 835 #define GET_REGISTER_MATCHER 836 #define GET_MATCHER_IMPLEMENTATION 837 #include "WebAssemblyGenAsmMatcher.inc" 838