lib/MC/MCParser/WasmAsmParser.cpp - llvm-project/llvm - Git at Google

 //===- WasmAsmParser.cpp - Wasm Assembly Parser -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 // --
 //
 // Note, this is for wasm, the binary format (analogous to ELF), not wasm,
 // the instruction set (analogous to x86), for which parsing code lives in
 // WebAssemblyAsmParser.
 //
 // This file contains processing for generic directives implemented using
 // MCTargetStreamer, the ones that depend on WebAssemblyTargetStreamer are in
 // WebAssemblyAsmParser.
 //
 //===----------------------------------------------------------------------===//

 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/MachineValueType.h"

 using namespace llvm;

 namespace {

 class WasmAsmParser : public MCAsmParserExtension {
   MCAsmParser *Parser = nullptr;
   MCAsmLexer *Lexer = nullptr;

   template<bool (WasmAsmParser::*HandlerMethod)(StringRef, SMLoc)>
   void addDirectiveHandler(StringRef Directive) {
     MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair(
         this, HandleDirective<WasmAsmParser, HandlerMethod>);

     getParser().addDirectiveHandler(Directive, Handler);
   }

 public:
   WasmAsmParser() { BracketExpressionsSupported = true; }

   void Initialize(MCAsmParser &P) override {
     Parser = &P;
     Lexer = &Parser->getLexer();
     // Call the base implementation.
     this->MCAsmParserExtension::Initialize(*Parser);

     addDirectiveHandler<&WasmAsmParser::parseSectionDirectiveText>(".text");
     addDirectiveHandler<&WasmAsmParser::parseSectionDirective>(".section");
     addDirectiveHandler<&WasmAsmParser::parseDirectiveSize>(".size");
     addDirectiveHandler<&WasmAsmParser::parseDirectiveType>(".type");
     addDirectiveHandler<&WasmAsmParser::ParseDirectiveIdent>(".ident");
     addDirectiveHandler<
       &WasmAsmParser::ParseDirectiveSymbolAttribute>(".weak");
     addDirectiveHandler<
       &WasmAsmParser::ParseDirectiveSymbolAttribute>(".local");
     addDirectiveHandler<
       &WasmAsmParser::ParseDirectiveSymbolAttribute>(".internal");
     addDirectiveHandler<
       &WasmAsmParser::ParseDirectiveSymbolAttribute>(".hidden");
   }

   bool error(const StringRef &Msg, const AsmToken &Tok) {
     return Parser->Error(Tok.getLoc(), Msg + Tok.getString());
   }

   bool isNext(AsmToken::TokenKind Kind) {
     auto Ok = Lexer->is(Kind);
     if (Ok)
       Lex();
     return Ok;
   }

   bool expect(AsmToken::TokenKind Kind, const char *KindName) {
     if (!isNext(Kind))
       return error(std::string("Expected ") + KindName + ", instead got: ",
                    Lexer->getTok());
     return false;
   }

   bool parseSectionDirectiveText(StringRef, SMLoc) {
     // FIXME: .text currently no-op.
     return false;
   }

   bool parseSectionFlags(StringRef FlagStr, bool &Passive, bool &Group) {
     for (char C : FlagStr) {
       switch (C) {
       case 'p':
         Passive = true;
         break;
       case 'G':
         Group = true;
         break;
       default:
         return Parser->Error(getTok().getLoc(),
                              StringRef("Unexepcted section flag: ") + FlagStr);
       }
     }
     return false;
   }

   bool parseGroup(StringRef &GroupName) {
     if (Lexer->isNot(AsmToken::Comma))
       return TokError("expected group name");
     Lex();
     if (Lexer->is(AsmToken::Integer)) {
       GroupName = getTok().getString();
       Lex();
     } else if (Parser->parseIdentifier(GroupName)) {
       return TokError("invalid group name");
     }
     if (Lexer->is(AsmToken::Comma)) {
       Lex();
       StringRef Linkage;
       if (Parser->parseIdentifier(Linkage))
         return TokError("invalid linkage");
       if (Linkage != "comdat")
         return TokError("Linkage must be 'comdat'");
     }
     return false;
   }

   bool parseSectionDirective(StringRef, SMLoc) {
     StringRef Name;
     if (Parser->parseIdentifier(Name))
       return TokError("expected identifier in directive");

     if (expect(AsmToken::Comma, ","))
       return true;

     if (Lexer->isNot(AsmToken::String))
       return error("expected string in directive, instead got: ", Lexer->getTok());

     auto Kind = StringSwitch<Optional<SectionKind>>(Name)
                     .StartsWith(".data", SectionKind::getData())
                     .StartsWith(".tdata", SectionKind::getThreadData())
                     .StartsWith(".tbss", SectionKind::getThreadBSS())
                     .StartsWith(".rodata", SectionKind::getReadOnly())
                     .StartsWith(".text", SectionKind::getText())
                     .StartsWith(".custom_section", SectionKind::getMetadata())
                     .StartsWith(".bss", SectionKind::getBSS())
                     // See use of .init_array in WasmObjectWriter and
                     // TargetLoweringObjectFileWasm
                     .StartsWith(".init_array", SectionKind::getData())
                     .StartsWith(".debug_", SectionKind::getMetadata())
                     .Default(SectionKind::getData());

     // Update section flags if present in this .section directive
     bool Passive = false;
     bool Group = false;
     if (parseSectionFlags(getTok().getStringContents(), Passive, Group))
       return true;

     Lex();

     if (expect(AsmToken::Comma, ",") || expect(AsmToken::At, "@"))
       return true;

     StringRef GroupName;
     if (Group && parseGroup(GroupName))
       return true;

     if (expect(AsmToken::EndOfStatement, "eol"))
       return true;

     // TODO: Parse UniqueID
     MCSectionWasm *WS = getContext().getWasmSection(
         Name, Kind.getValue(), GroupName, MCContext::GenericSectionID);
     if (Passive) {
       if (!WS->isWasmData())
         return Parser->Error(getTok().getLoc(),
                              "Only data sections can be passive");
       WS->setPassive();
     }
     getStreamer().SwitchSection(WS);
     return false;
   }

   // TODO: This function is almost the same as ELFAsmParser::ParseDirectiveSize
   // so maybe could be shared somehow.
   bool parseDirectiveSize(StringRef, SMLoc) {
     StringRef Name;
     if (Parser->parseIdentifier(Name))
       return TokError("expected identifier in directive");
     auto Sym = getContext().getOrCreateSymbol(Name);
     if (expect(AsmToken::Comma, ","))
       return true;
     const MCExpr *Expr;
     if (Parser->parseExpression(Expr))
       return true;
     if (expect(AsmToken::EndOfStatement, "eol"))
       return true;
     // This is done automatically by the assembler for functions currently,
     // so this is only currently needed for data sections:
     getStreamer().emitELFSize(Sym, Expr);
     return false;
   }

   bool parseDirectiveType(StringRef, SMLoc) {
     // This could be the start of a function, check if followed by
     // "label,@function"
     if (!Lexer->is(AsmToken::Identifier))
       return error("Expected label after .type directive, got: ",
                    Lexer->getTok());
     auto WasmSym = cast<MCSymbolWasm>(
                      getStreamer().getContext().getOrCreateSymbol(
                        Lexer->getTok().getString()));
     Lex();
     if (!(isNext(AsmToken::Comma) && isNext(AsmToken::At) &&
           Lexer->is(AsmToken::Identifier)))
       return error("Expected label,@type declaration, got: ", Lexer->getTok());
     auto TypeName = Lexer->getTok().getString();
     if (TypeName == "function") {
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
       auto *Current =
           cast<MCSectionWasm>(getStreamer().getCurrentSection().first);
       if (Current->getGroup())
         WasmSym->setComdat(true);
     } else if (TypeName == "global")
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
     else if (TypeName == "object")
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_DATA);
     else
       return error("Unknown WASM symbol type: ", Lexer->getTok());
     Lex();
     return expect(AsmToken::EndOfStatement, "EOL");
   }

   // FIXME: Shared with ELF.
   /// ParseDirectiveIdent
   ///  ::= .ident string
   bool ParseDirectiveIdent(StringRef, SMLoc) {
     if (getLexer().isNot(AsmToken::String))
       return TokError("unexpected token in '.ident' directive");
     StringRef Data = getTok().getIdentifier();
     Lex();
     if (getLexer().isNot(AsmToken::EndOfStatement))
       return TokError("unexpected token in '.ident' directive");
     Lex();
     getStreamer().emitIdent(Data);
     return false;
   }

   // FIXME: Shared with ELF.
   /// ParseDirectiveSymbolAttribute
   ///  ::= { ".local", ".weak", ... } [ identifier ( , identifier )* ]
   bool ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
     MCSymbolAttr Attr = StringSwitch<MCSymbolAttr>(Directive)
       .Case(".weak", MCSA_Weak)
       .Case(".local", MCSA_Local)
       .Case(".hidden", MCSA_Hidden)
       .Case(".internal", MCSA_Internal)
       .Case(".protected", MCSA_Protected)
       .Default(MCSA_Invalid);
     assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!");
     if (getLexer().isNot(AsmToken::EndOfStatement)) {
       while (true) {
         StringRef Name;
         if (getParser().parseIdentifier(Name))
           return TokError("expected identifier in directive");
         MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
         getStreamer().emitSymbolAttribute(Sym, Attr);
         if (getLexer().is(AsmToken::EndOfStatement))
           break;
         if (getLexer().isNot(AsmToken::Comma))
           return TokError("unexpected token in directive");
         Lex();
       }
     }
     Lex();
     return false;
   }
 };

 } // end anonymous namespace

 namespace llvm {

 MCAsmParserExtension *createWasmAsmParser() {
   return new WasmAsmParser;
 }

 } // end namespace llvm
	//===- WasmAsmParser.cpp - Wasm Assembly Parser -----------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	// --
	//
	// Note, this is for wasm, the binary format (analogous to ELF), not wasm,
	// the instruction set (analogous to x86), for which parsing code lives in
	// WebAssemblyAsmParser.
	//
	// This file contains processing for generic directives implemented using
	// MCTargetStreamer, the ones that depend on WebAssemblyTargetStreamer are in
	// WebAssemblyAsmParser.
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/BinaryFormat/Wasm.h"
	#include "llvm/MC/MCContext.h"
	#include "llvm/MC/MCParser/MCAsmLexer.h"
	#include "llvm/MC/MCParser/MCAsmParser.h"
	#include "llvm/MC/MCParser/MCAsmParserExtension.h"
	#include "llvm/MC/MCSectionWasm.h"
	#include "llvm/MC/MCStreamer.h"
	#include "llvm/MC/MCSymbol.h"
	#include "llvm/MC/MCSymbolWasm.h"
	#include "llvm/Support/MachineValueType.h"

	using namespace llvm;

	namespace {

	class WasmAsmParser : public MCAsmParserExtension {
	MCAsmParser *Parser = nullptr;
	MCAsmLexer *Lexer = nullptr;

	template<bool (WasmAsmParser::*HandlerMethod)(StringRef, SMLoc)>
	void addDirectiveHandler(StringRef Directive) {
	MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair(
	this, HandleDirective<WasmAsmParser, HandlerMethod>);

	getParser().addDirectiveHandler(Directive, Handler);
	}

	public:
	WasmAsmParser() { BracketExpressionsSupported = true; }

	void Initialize(MCAsmParser &P) override {
	Parser = &P;
	Lexer = &Parser->getLexer();
	// Call the base implementation.
	this->MCAsmParserExtension::Initialize(*Parser);

	addDirectiveHandler<&WasmAsmParser::parseSectionDirectiveText>(".text");
	addDirectiveHandler<&WasmAsmParser::parseSectionDirective>(".section");
	addDirectiveHandler<&WasmAsmParser::parseDirectiveSize>(".size");
	addDirectiveHandler<&WasmAsmParser::parseDirectiveType>(".type");
	addDirectiveHandler<&WasmAsmParser::ParseDirectiveIdent>(".ident");
	addDirectiveHandler<
	&WasmAsmParser::ParseDirectiveSymbolAttribute>(".weak");
	addDirectiveHandler<
	&WasmAsmParser::ParseDirectiveSymbolAttribute>(".local");
	addDirectiveHandler<
	&WasmAsmParser::ParseDirectiveSymbolAttribute>(".internal");
	addDirectiveHandler<
	&WasmAsmParser::ParseDirectiveSymbolAttribute>(".hidden");
	}

	bool error(const StringRef &Msg, const AsmToken &Tok) {
	return Parser->Error(Tok.getLoc(), Msg + Tok.getString());
	}

	bool isNext(AsmToken::TokenKind Kind) {
	auto Ok = Lexer->is(Kind);
	if (Ok)
	Lex();
	return Ok;
	}

	bool expect(AsmToken::TokenKind Kind, const char *KindName) {
	if (!isNext(Kind))
	return error(std::string("Expected ") + KindName + ", instead got: ",
	Lexer->getTok());
	return false;
	}

	bool parseSectionDirectiveText(StringRef, SMLoc) {
	// FIXME: .text currently no-op.
	return false;
	}

	bool parseSectionFlags(StringRef FlagStr, bool &Passive, bool &Group) {
	for (char C : FlagStr) {
	switch (C) {
	case 'p':
	Passive = true;
	break;
	case 'G':
	Group = true;
	break;
	default:
	return Parser->Error(getTok().getLoc(),
	StringRef("Unexepcted section flag: ") + FlagStr);
	}
	}
	return false;
	}

	bool parseGroup(StringRef &GroupName) {
	if (Lexer->isNot(AsmToken::Comma))
	return TokError("expected group name");
	Lex();
	if (Lexer->is(AsmToken::Integer)) {
	GroupName = getTok().getString();
	Lex();
	} else if (Parser->parseIdentifier(GroupName)) {
	return TokError("invalid group name");
	}
	if (Lexer->is(AsmToken::Comma)) {
	Lex();
	StringRef Linkage;
	if (Parser->parseIdentifier(Linkage))
	return TokError("invalid linkage");
	if (Linkage != "comdat")
	return TokError("Linkage must be 'comdat'");
	}
	return false;
	}

	bool parseSectionDirective(StringRef, SMLoc) {
	StringRef Name;
	if (Parser->parseIdentifier(Name))
	return TokError("expected identifier in directive");

	if (expect(AsmToken::Comma, ","))
	return true;

	if (Lexer->isNot(AsmToken::String))
	return error("expected string in directive, instead got: ", Lexer->getTok());

	auto Kind = StringSwitch<Optional<SectionKind>>(Name)
	.StartsWith(".data", SectionKind::getData())
	.StartsWith(".tdata", SectionKind::getThreadData())
	.StartsWith(".tbss", SectionKind::getThreadBSS())
	.StartsWith(".rodata", SectionKind::getReadOnly())
	.StartsWith(".text", SectionKind::getText())
	.StartsWith(".custom_section", SectionKind::getMetadata())
	.StartsWith(".bss", SectionKind::getBSS())
	// See use of .init_array in WasmObjectWriter and
	// TargetLoweringObjectFileWasm
	.StartsWith(".init_array", SectionKind::getData())
	.StartsWith(".debug_", SectionKind::getMetadata())
	.Default(SectionKind::getData());

	// Update section flags if present in this .section directive
	bool Passive = false;
	bool Group = false;
	if (parseSectionFlags(getTok().getStringContents(), Passive, Group))
	return true;

	Lex();

	if (expect(AsmToken::Comma, ",") \|\| expect(AsmToken::At, "@"))
	return true;

	StringRef GroupName;
	if (Group && parseGroup(GroupName))
	return true;

	if (expect(AsmToken::EndOfStatement, "eol"))
	return true;

	// TODO: Parse UniqueID
	MCSectionWasm *WS = getContext().getWasmSection(
	Name, Kind.getValue(), GroupName, MCContext::GenericSectionID);
	if (Passive) {
	if (!WS->isWasmData())
	return Parser->Error(getTok().getLoc(),
	"Only data sections can be passive");
	WS->setPassive();
	}
	getStreamer().SwitchSection(WS);
	return false;
	}

	// TODO: This function is almost the same as ELFAsmParser::ParseDirectiveSize
	// so maybe could be shared somehow.
	bool parseDirectiveSize(StringRef, SMLoc) {
	StringRef Name;
	if (Parser->parseIdentifier(Name))
	return TokError("expected identifier in directive");
	auto Sym = getContext().getOrCreateSymbol(Name);
	if (expect(AsmToken::Comma, ","))
	return true;
	const MCExpr *Expr;
	if (Parser->parseExpression(Expr))
	return true;
	if (expect(AsmToken::EndOfStatement, "eol"))
	return true;
	// This is done automatically by the assembler for functions currently,
	// so this is only currently needed for data sections:
	getStreamer().emitELFSize(Sym, Expr);
	return false;
	}

	bool parseDirectiveType(StringRef, SMLoc) {
	// This could be the start of a function, check if followed by
	// "label,@function"
	if (!Lexer->is(AsmToken::Identifier))
	return error("Expected label after .type directive, got: ",
	Lexer->getTok());
	auto WasmSym = cast<MCSymbolWasm>(
	getStreamer().getContext().getOrCreateSymbol(
	Lexer->getTok().getString()));
	Lex();
	if (!(isNext(AsmToken::Comma) && isNext(AsmToken::At) &&
	Lexer->is(AsmToken::Identifier)))
	return error("Expected label,@type declaration, got: ", Lexer->getTok());
	auto TypeName = Lexer->getTok().getString();
	if (TypeName == "function") {
	WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
	auto *Current =
	cast<MCSectionWasm>(getStreamer().getCurrentSection().first);
	if (Current->getGroup())
	WasmSym->setComdat(true);
	} else if (TypeName == "global")
	WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
	else if (TypeName == "object")
	WasmSym->setType(wasm::WASM_SYMBOL_TYPE_DATA);
	else
	return error("Unknown WASM symbol type: ", Lexer->getTok());
	Lex();
	return expect(AsmToken::EndOfStatement, "EOL");
	}

	// FIXME: Shared with ELF.
	/// ParseDirectiveIdent
	/// ::= .ident string
	bool ParseDirectiveIdent(StringRef, SMLoc) {
	if (getLexer().isNot(AsmToken::String))
	return TokError("unexpected token in '.ident' directive");
	StringRef Data = getTok().getIdentifier();
	Lex();
	if (getLexer().isNot(AsmToken::EndOfStatement))
	return TokError("unexpected token in '.ident' directive");
	Lex();
	getStreamer().emitIdent(Data);
	return false;
	}

	// FIXME: Shared with ELF.
	/// ParseDirectiveSymbolAttribute
	/// ::= { ".local", ".weak", ... } [ identifier ( , identifier )* ]
	bool ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
	MCSymbolAttr Attr = StringSwitch<MCSymbolAttr>(Directive)
	.Case(".weak", MCSA_Weak)
	.Case(".local", MCSA_Local)
	.Case(".hidden", MCSA_Hidden)
	.Case(".internal", MCSA_Internal)
	.Case(".protected", MCSA_Protected)
	.Default(MCSA_Invalid);
	assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!");
	if (getLexer().isNot(AsmToken::EndOfStatement)) {
	while (true) {
	StringRef Name;
	if (getParser().parseIdentifier(Name))
	return TokError("expected identifier in directive");
	MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
	getStreamer().emitSymbolAttribute(Sym, Attr);
	if (getLexer().is(AsmToken::EndOfStatement))
	break;
	if (getLexer().isNot(AsmToken::Comma))
	return TokError("unexpected token in directive");
	Lex();
	}
	}
	Lex();
	return false;
	}
	};

	} // end anonymous namespace

	namespace llvm {

	MCAsmParserExtension *createWasmAsmParser() {
	return new WasmAsmParser;
	}

	} // end namespace llvm