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 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 308 Optional<wasm::ValType> parseType(const StringRef &Type) { 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") 326 return wasm::ValType::EXTERNREF; 327 return Optional<wasm::ValType>(); 328 } 329 330 WebAssembly::BlockType parseBlockType(StringRef ID) { 331 // Multivalue block types are handled separately in parseSignature 332 return StringSwitch<WebAssembly::BlockType>(ID) 333 .Case("i32", WebAssembly::BlockType::I32) 334 .Case("i64", WebAssembly::BlockType::I64) 335 .Case("f32", WebAssembly::BlockType::F32) 336 .Case("f64", WebAssembly::BlockType::F64) 337 .Case("v128", WebAssembly::BlockType::V128) 338 .Case("exnref", WebAssembly::BlockType::Exnref) 339 .Case("void", WebAssembly::BlockType::Void) 340 .Default(WebAssembly::BlockType::Invalid); 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>( 426 WebAssemblyOperand::Integer, Tok.getLoc(), Tok.getEndLoc(), 427 WebAssemblyOperand::IntOp{-1})); 428 } 429 } 430 return false; 431 } 432 433 void addBlockTypeOperand(OperandVector &Operands, SMLoc NameLoc, 434 WebAssembly::BlockType BT) { 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()); 551 if (BT == WebAssembly::BlockType::Invalid) 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()); 785 SmallVector<wasm::ValType, 4> Locals; 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()); 828 TOut.emitLocal(SmallVector<wasm::ValType, 0>()); 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. 845 auto Align = WebAssembly::GetDefaultP2AlignAny(Inst.getOpcode()); 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. 929 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeWebAssemblyAsmParser() { 930 RegisterMCAsmParser<WebAssemblyAsmParser> X(getTheWebAssemblyTarget32()); 931 RegisterMCAsmParser<WebAssemblyAsmParser> Y(getTheWebAssemblyTarget64()); 932 } 933 934 #define GET_REGISTER_MATCHER 935 #define GET_MATCHER_IMPLEMENTATION 936 #include "WebAssemblyGenAsmMatcher.inc" 937