WasmAsmParser.cpp revision 360784 
1//===- WasmAsmParser.cpp - Wasm Assembly Parser -----------------------------===//
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// Note, this is for wasm, the binary format (analogous to ELF), not wasm,
10// the instruction set (analogous to x86), for which parsing code lives in
11// WebAssemblyAsmParser.
12//
13// This file contains processing for generic directives implemented using
14// MCTargetStreamer, the ones that depend on WebAssemblyTargetStreamer are in
15// WebAssemblyAsmParser.
16//
17//===----------------------------------------------------------------------===//
18
19#include "llvm/BinaryFormat/Wasm.h"
20#include "llvm/MC/MCContext.h"
21#include "llvm/MC/MCParser/MCAsmLexer.h"
22#include "llvm/MC/MCParser/MCAsmParser.h"
23#include "llvm/MC/MCParser/MCAsmParserExtension.h"
24#include "llvm/MC/MCSectionWasm.h"
25#include "llvm/MC/MCStreamer.h"
26#include "llvm/MC/MCSymbol.h"
27#include "llvm/MC/MCSymbolWasm.h"
28#include "llvm/Support/MachineValueType.h"
29
30using namespace llvm;
31
32namespace {
33
34class WasmAsmParser : public MCAsmParserExtension {
35  MCAsmParser *Parser = nullptr;
36  MCAsmLexer *Lexer = nullptr;
37
38  template<bool (WasmAsmParser::*HandlerMethod)(StringRef, SMLoc)>
39  void addDirectiveHandler(StringRef Directive) {
40    MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair(
41        this, HandleDirective<WasmAsmParser, HandlerMethod>);
42
43    getParser().addDirectiveHandler(Directive, Handler);
44  }
45
46public:
47  WasmAsmParser() { BracketExpressionsSupported = true; }
48
49  void Initialize(MCAsmParser &P) override {
50    Parser = &P;
51    Lexer = &Parser->getLexer();
52    // Call the base implementation.
53    this->MCAsmParserExtension::Initialize(*Parser);
54
55    addDirectiveHandler<&WasmAsmParser::parseSectionDirectiveText>(".text");
56    addDirectiveHandler<&WasmAsmParser::parseSectionDirective>(".section");
57    addDirectiveHandler<&WasmAsmParser::parseDirectiveSize>(".size");
58    addDirectiveHandler<&WasmAsmParser::parseDirectiveType>(".type");
59    addDirectiveHandler<&WasmAsmParser::ParseDirectiveIdent>(".ident");
60    addDirectiveHandler<
61      &WasmAsmParser::ParseDirectiveSymbolAttribute>(".weak");
62    addDirectiveHandler<
63      &WasmAsmParser::ParseDirectiveSymbolAttribute>(".local");
64    addDirectiveHandler<
65      &WasmAsmParser::ParseDirectiveSymbolAttribute>(".internal");
66    addDirectiveHandler<
67      &WasmAsmParser::ParseDirectiveSymbolAttribute>(".hidden");
68  }
69
70  bool error(const StringRef &Msg, const AsmToken &Tok) {
71    return Parser->Error(Tok.getLoc(), Msg + Tok.getString());
72  }
73
74  bool isNext(AsmToken::TokenKind Kind) {
75    auto Ok = Lexer->is(Kind);
76    if (Ok)
77      Lex();
78    return Ok;
79  }
80
81  bool expect(AsmToken::TokenKind Kind, const char *KindName) {
82    if (!isNext(Kind))
83      return error(std::string("Expected ") + KindName + ", instead got: ",
84                   Lexer->getTok());
85    return false;
86  }
87
88  bool parseSectionDirectiveText(StringRef, SMLoc) {
89    // FIXME: .text currently no-op.
90    return false;
91  }
92
93  bool parseSectionFlags(StringRef FlagStr, bool &Passive) {
94    SmallVector<StringRef, 2> Flags;
95    // If there are no flags, keep Flags empty
96    FlagStr.split(Flags, ",", -1, false);
97    for (auto &Flag : Flags) {
98      if (Flag == "passive")
99        Passive = true;
100      else
101        return error("Expected section flags, instead got: ", Lexer->getTok());
102    }
103    return false;
104  }
105
106  bool parseSectionDirective(StringRef, SMLoc) {
107    StringRef Name;
108    if (Parser->parseIdentifier(Name))
109      return TokError("expected identifier in directive");
110
111    if (expect(AsmToken::Comma, ","))
112      return true;
113
114    if (Lexer->isNot(AsmToken::String))
115      return error("expected string in directive, instead got: ", Lexer->getTok());
116
117    auto Kind = StringSwitch<Optional<SectionKind>>(Name)
118                    .StartsWith(".data", SectionKind::getData())
119                    .StartsWith(".rodata", SectionKind::getReadOnly())
120                    .StartsWith(".text", SectionKind::getText())
121                    .StartsWith(".custom_section", SectionKind::getMetadata())
122                    .StartsWith(".bss", SectionKind::getBSS())
123                    // See use of .init_array in WasmObjectWriter and
124                    // TargetLoweringObjectFileWasm
125                    .StartsWith(".init_array", SectionKind::getData())
126                    .StartsWith(".debug_", SectionKind::getMetadata())
127                    .Default(Optional<SectionKind>());
128    if (!Kind.hasValue())
129      return Parser->Error(Lexer->getLoc(), "unknown section kind: " + Name);
130
131    MCSectionWasm *Section = getContext().getWasmSection(Name, Kind.getValue());
132
133    // Update section flags if present in this .section directive
134    bool Passive = false;
135    if (parseSectionFlags(getTok().getStringContents(), Passive))
136      return true;
137
138    if (Passive) {
139      if (!Section->isWasmData())
140        return Parser->Error(getTok().getLoc(),
141                             "Only data sections can be passive");
142      Section->setPassive();
143    }
144
145    Lex();
146
147    if (expect(AsmToken::Comma, ",") || expect(AsmToken::At, "@") ||
148        expect(AsmToken::EndOfStatement, "eol"))
149      return true;
150
151    auto WS = getContext().getWasmSection(Name, Kind.getValue());
152    getStreamer().SwitchSection(WS);
153    return false;
154  }
155
156  // TODO: This function is almost the same as ELFAsmParser::ParseDirectiveSize
157  // so maybe could be shared somehow.
158  bool parseDirectiveSize(StringRef, SMLoc) {
159    StringRef Name;
160    if (Parser->parseIdentifier(Name))
161      return TokError("expected identifier in directive");
162    auto Sym = getContext().getOrCreateSymbol(Name);
163    if (expect(AsmToken::Comma, ","))
164      return true;
165    const MCExpr *Expr;
166    if (Parser->parseExpression(Expr))
167      return true;
168    if (expect(AsmToken::EndOfStatement, "eol"))
169      return true;
170    // This is done automatically by the assembler for functions currently,
171    // so this is only currently needed for data sections:
172    getStreamer().emitELFSize(Sym, Expr);
173    return false;
174  }
175
176  bool parseDirectiveType(StringRef, SMLoc) {
177    // This could be the start of a function, check if followed by
178    // "label,@function"
179    if (!Lexer->is(AsmToken::Identifier))
180      return error("Expected label after .type directive, got: ",
181                   Lexer->getTok());
182    auto WasmSym = cast<MCSymbolWasm>(
183                     getStreamer().getContext().getOrCreateSymbol(
184                       Lexer->getTok().getString()));
185    Lex();
186    if (!(isNext(AsmToken::Comma) && isNext(AsmToken::At) &&
187          Lexer->is(AsmToken::Identifier)))
188      return error("Expected label,@type declaration, got: ", Lexer->getTok());
189    auto TypeName = Lexer->getTok().getString();
190    if (TypeName == "function")
191      WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
192    else if (TypeName == "global")
193      WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
194    else if (TypeName == "object")
195      WasmSym->setType(wasm::WASM_SYMBOL_TYPE_DATA);
196    else
197      return error("Unknown WASM symbol type: ", Lexer->getTok());
198    Lex();
199    return expect(AsmToken::EndOfStatement, "EOL");
200  }
201
202  // FIXME: Shared with ELF.
203  /// ParseDirectiveIdent
204  ///  ::= .ident string
205  bool ParseDirectiveIdent(StringRef, SMLoc) {
206    if (getLexer().isNot(AsmToken::String))
207      return TokError("unexpected token in '.ident' directive");
208    StringRef Data = getTok().getIdentifier();
209    Lex();
210    if (getLexer().isNot(AsmToken::EndOfStatement))
211      return TokError("unexpected token in '.ident' directive");
212    Lex();
213    getStreamer().EmitIdent(Data);
214    return false;
215  }
216
217  // FIXME: Shared with ELF.
218  /// ParseDirectiveSymbolAttribute
219  ///  ::= { ".local", ".weak", ... } [ identifier ( , identifier )* ]
220  bool ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
221    MCSymbolAttr Attr = StringSwitch<MCSymbolAttr>(Directive)
222      .Case(".weak", MCSA_Weak)
223      .Case(".local", MCSA_Local)
224      .Case(".hidden", MCSA_Hidden)
225      .Case(".internal", MCSA_Internal)
226      .Case(".protected", MCSA_Protected)
227      .Default(MCSA_Invalid);
228    assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!");
229    if (getLexer().isNot(AsmToken::EndOfStatement)) {
230      while (true) {
231        StringRef Name;
232        if (getParser().parseIdentifier(Name))
233          return TokError("expected identifier in directive");
234        MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
235        getStreamer().EmitSymbolAttribute(Sym, Attr);
236        if (getLexer().is(AsmToken::EndOfStatement))
237          break;
238        if (getLexer().isNot(AsmToken::Comma))
239          return TokError("unexpected token in directive");
240        Lex();
241      }
242    }
243    Lex();
244    return false;
245  }
246};
247
248} // end anonymous namespace
249
250namespace llvm {
251
252MCAsmParserExtension *createWasmAsmParser() {
253  return new WasmAsmParser;
254}
255
256} // end namespace llvm
257