llvm/lib/MC/MCParser/WasmAsmParser.cpp

   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/ADT/StringExtras.h"
  20 #include "llvm/BinaryFormat/Wasm.h"
  21 #include "llvm/MC/MCContext.h"
  22 #include "llvm/MC/MCObjectFileInfo.h"
  23 #include "llvm/MC/MCParser/MCAsmLexer.h"
  24 #include "llvm/MC/MCParser/MCAsmParser.h"
  25 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
  26 #include "llvm/MC/MCSectionWasm.h"
  27 #include "llvm/MC/MCStreamer.h"
  28 #include "llvm/MC/MCSymbolWasm.h"
  29 #include "llvm/Support/Casting.h"
  30 #include <optional>
  31
  32 using namespace llvm;
  33
  34 namespace {
  35
  36 class WasmAsmParser : public MCAsmParserExtension {
  37   MCAsmParser *Parser = nullptr;
  38   MCAsmLexer *Lexer = nullptr;
  39
  40   template<bool (WasmAsmParser::*HandlerMethod)(StringRef, SMLoc)>
  41   void addDirectiveHandler(StringRef Directive) {
  42     MCAsmParser::ExtensionDirectiveHandler Handler = std::make_pair(
  43         this, HandleDirective<WasmAsmParser, HandlerMethod>);
  44
  45     getParser().addDirectiveHandler(Directive, Handler);
  46   }
  47
  48 public:
  49   WasmAsmParser() { BracketExpressionsSupported = true; }
  50
  51   void Initialize(MCAsmParser &P) override {
  52     Parser = &P;
  53     Lexer = &Parser->getLexer();
  54     // Call the base implementation.
  55     this->MCAsmParserExtension::Initialize(*Parser);
  56
  57     addDirectiveHandler<&WasmAsmParser::parseSectionDirectiveText>(".text");
  58     addDirectiveHandler<&WasmAsmParser::parseSectionDirectiveData>(".data");
  59     addDirectiveHandler<&WasmAsmParser::parseSectionDirective>(".section");
  60     addDirectiveHandler<&WasmAsmParser::parseDirectiveSize>(".size");
  61     addDirectiveHandler<&WasmAsmParser::parseDirectiveType>(".type");
  62     addDirectiveHandler<&WasmAsmParser::ParseDirectiveIdent>(".ident");
  63     addDirectiveHandler<
  64       &WasmAsmParser::ParseDirectiveSymbolAttribute>(".weak");
  65     addDirectiveHandler<
  66       &WasmAsmParser::ParseDirectiveSymbolAttribute>(".local");
  67     addDirectiveHandler<
  68       &WasmAsmParser::ParseDirectiveSymbolAttribute>(".internal");
  69     addDirectiveHandler<
  70       &WasmAsmParser::ParseDirectiveSymbolAttribute>(".hidden");
  71   }
  72
  73   bool error(const StringRef &Msg, const AsmToken &Tok) {
  74     return Parser->Error(Tok.getLoc(), Msg + Tok.getString());
  75   }
  76
  77   bool isNext(AsmToken::TokenKind Kind) {
  78     auto Ok = Lexer->is(Kind);
  79     if (Ok)
  80       Lex();
  81     return Ok;
  82   }
  83
  84   bool expect(AsmToken::TokenKind Kind, const char *KindName) {
  85     if (!isNext(Kind))
  86       return error(std::string("Expected ") + KindName + ", instead got: ",
  87                    Lexer->getTok());
  88     return false;
  89   }
  90
  91   bool parseSectionDirectiveText(StringRef, SMLoc) {
  92     // FIXME: .text currently no-op.
  93     return false;
  94   }
  95
  96   bool parseSectionDirectiveData(StringRef, SMLoc) {
  97     auto *S = getContext().getObjectFileInfo()->getDataSection();
  98     getStreamer().switchSection(S);
  99     return false;
 100   }
 101
 102   uint32_t parseSectionFlags(StringRef FlagStr, bool &Passive, bool &Group) {
 103     uint32_t flags = 0;
 104     for (char C : FlagStr) {
 105       switch (C) {
 106       case 'p':
 107         Passive = true;
 108         break;
 109       case 'G':
 110         Group = true;
 111         break;
 112       case 'T':
 113         flags |= wasm::WASM_SEG_FLAG_TLS;
 114         break;
 115       case 'S':
 116         flags |= wasm::WASM_SEG_FLAG_STRINGS;
 117         break;
 118       default:
 119         return -1U;
 120       }
 121     }
 122     return flags;
 123   }
 124
 125   bool parseGroup(StringRef &GroupName) {
 126     if (Lexer->isNot(AsmToken::Comma))
 127       return TokError("expected group name");
 128     Lex();
 129     if (Lexer->is(AsmToken::Integer)) {
 130       GroupName = getTok().getString();
 131       Lex();
 132     } else if (Parser->parseIdentifier(GroupName)) {
 133       return TokError("invalid group name");
 134     }
 135     if (Lexer->is(AsmToken::Comma)) {
 136       Lex();
 137       StringRef Linkage;
 138       if (Parser->parseIdentifier(Linkage))
 139         return TokError("invalid linkage");
 140       if (Linkage != "comdat")
 141         return TokError("Linkage must be 'comdat'");
 142     }
 143     return false;
 144   }
 145
 146   bool parseSectionDirective(StringRef, SMLoc loc) {
 147     StringRef Name;
 148     if (Parser->parseIdentifier(Name))
 149       return TokError("expected identifier in directive");
 150
 151     if (expect(AsmToken::Comma, ","))
 152       return true;
 153
 154     if (Lexer->isNot(AsmToken::String))
 155       return error("expected string in directive, instead got: ", Lexer->getTok());
 156
 157     auto Kind = StringSwitch<std::optional<SectionKind>>(Name)
 158                     .StartsWith(".data", SectionKind::getData())
 159                     .StartsWith(".tdata", SectionKind::getThreadData())
 160                     .StartsWith(".tbss", SectionKind::getThreadBSS())
 161                     .StartsWith(".rodata", SectionKind::getReadOnly())
 162                     .StartsWith(".text", SectionKind::getText())
 163                     .StartsWith(".custom_section", SectionKind::getMetadata())
 164                     .StartsWith(".bss", SectionKind::getBSS())
 165                     // See use of .init_array in WasmObjectWriter and
 166                     // TargetLoweringObjectFileWasm
 167                     .StartsWith(".init_array", SectionKind::getData())
 168                     .StartsWith(".debug_", SectionKind::getMetadata())
 169                     .Default(SectionKind::getData());
 170
 171     // Update section flags if present in this .section directive
 172     bool Passive = false;
 173     bool Group = false;
 174     uint32_t Flags =
 175         parseSectionFlags(getTok().getStringContents(), Passive, Group);
 176     if (Flags == -1U)
 177       return TokError("unknown flag");
 178
 179     Lex();
 180
 181     if (expect(AsmToken::Comma, ",") || expect(AsmToken::At, "@"))
 182       return true;
 183
 184     StringRef GroupName;
 185     if (Group && parseGroup(GroupName))
 186       return true;
 187
 188     if (expect(AsmToken::EndOfStatement, "eol"))
 189       return true;
 190
 191     // TODO: Parse UniqueID
 192     MCSectionWasm *WS = getContext().getWasmSection(
 193         Name, *Kind, Flags, GroupName, MCContext::GenericSectionID);
 194
 195     if (WS->getSegmentFlags() != Flags)
 196       Parser->Error(loc, "changed section flags for " + Name +
 197                              ", expected: 0x" +
 198                              utohexstr(WS->getSegmentFlags()));
 199
 200     if (Passive) {
 201       if (!WS->isWasmData())
 202         return Parser->Error(loc, "Only data sections can be passive");
 203       WS->setPassive();
 204     }
 205
 206     getStreamer().switchSection(WS);
 207     return false;
 208   }
 209
 210   // TODO: This function is almost the same as ELFAsmParser::ParseDirectiveSize
 211   // so maybe could be shared somehow.
 212   bool parseDirectiveSize(StringRef, SMLoc Loc) {
 213     StringRef Name;
 214     if (Parser->parseIdentifier(Name))
 215       return TokError("expected identifier in directive");
 216     auto Sym = getContext().getOrCreateSymbol(Name);
 217     if (expect(AsmToken::Comma, ","))
 218       return true;
 219     const MCExpr *Expr;
 220     if (Parser->parseExpression(Expr))
 221       return true;
 222     if (expect(AsmToken::EndOfStatement, "eol"))
 223       return true;
 224     auto WasmSym = cast<MCSymbolWasm>(Sym);
 225     if (WasmSym->isFunction()) {
 226       // Ignore .size directives for function symbols.  They get their size
 227       // set automatically based on their content.
 228       Warning(Loc, ".size directive ignored for function symbols");
 229     } else {
 230       getStreamer().emitELFSize(Sym, Expr);
 231     }
 232     return false;
 233   }
 234
 235   bool parseDirectiveType(StringRef, SMLoc) {
 236     // This could be the start of a function, check if followed by
 237     // "label,@function"
 238     if (!Lexer->is(AsmToken::Identifier))
 239       return error("Expected label after .type directive, got: ",
 240                    Lexer->getTok());
 241     auto WasmSym = cast<MCSymbolWasm>(
 242                      getStreamer().getContext().getOrCreateSymbol(
 243                        Lexer->getTok().getString()));
 244     Lex();
 245     if (!(isNext(AsmToken::Comma) && isNext(AsmToken::At) &&
 246           Lexer->is(AsmToken::Identifier)))
 247       return error("Expected label,@type declaration, got: ", Lexer->getTok());
 248     auto TypeName = Lexer->getTok().getString();
 249     if (TypeName == "function") {
 250       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
 251       auto *Current =
 252           cast<MCSectionWasm>(getStreamer().getCurrentSection().first);
 253       if (Current->getGroup())
 254         WasmSym->setComdat(true);
 255     } else if (TypeName == "global")
 256       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
 257     else if (TypeName == "object")
 258       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_DATA);
 259     else
 260       return error("Unknown WASM symbol type: ", Lexer->getTok());
 261     Lex();
 262     return expect(AsmToken::EndOfStatement, "EOL");
 263   }
 264
 265   // FIXME: Shared with ELF.
 266   /// ParseDirectiveIdent
 267   ///  ::= .ident string
 268   bool ParseDirectiveIdent(StringRef, SMLoc) {
 269     if (getLexer().isNot(AsmToken::String))
 270       return TokError("unexpected token in '.ident' directive");
 271     StringRef Data = getTok().getIdentifier();
 272     Lex();
 273     if (getLexer().isNot(AsmToken::EndOfStatement))
 274       return TokError("unexpected token in '.ident' directive");
 275     Lex();
 276     getStreamer().emitIdent(Data);
 277     return false;
 278   }
 279
 280   // FIXME: Shared with ELF.
 281   /// ParseDirectiveSymbolAttribute
 282   ///  ::= { ".local", ".weak", ... } [ identifier ( , identifier )* ]
 283   bool ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
 284     MCSymbolAttr Attr = StringSwitch<MCSymbolAttr>(Directive)
 285       .Case(".weak", MCSA_Weak)
 286       .Case(".local", MCSA_Local)
 287       .Case(".hidden", MCSA_Hidden)
 288       .Case(".internal", MCSA_Internal)
 289       .Case(".protected", MCSA_Protected)
 290       .Default(MCSA_Invalid);
 291     assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!");
 292     if (getLexer().isNot(AsmToken::EndOfStatement)) {
 293       while (true) {
 294         StringRef Name;
 295         if (getParser().parseIdentifier(Name))
 296           return TokError("expected identifier in directive");
 297         MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
 298         getStreamer().emitSymbolAttribute(Sym, Attr);
 299         if (getLexer().is(AsmToken::EndOfStatement))
 300           break;
 301         if (getLexer().isNot(AsmToken::Comma))
 302           return TokError("unexpected token in directive");
 303         Lex();
 304       }
 305     }
 306     Lex();
 307     return false;
 308   }
 309 };
 310
 311 } // end anonymous namespace
 312
 313 namespace llvm {
 314
 315 MCAsmParserExtension *createWasmAsmParser() {
 316   return new WasmAsmParser;
 317 }
 318
 319 } // end namespace llvm