[WebAssembly] Add '.eventtype' directive support

[aheejin]

Summary

This patch supports .eventtype directive printing and parsing in the
same syntax with .functype.

[aheejin]

• clang-format & clang-tidy

[aheejin]

lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

465

I don't really know what this TODO means, but because other directives have it, I just pasted it again here.

[sbc100]

Since event types can't have return values (they are always no_return right?) should we split out "parseParamList" and have them look like this?

.eventtype  __cpp_exception i32
.eventtype  some_other_exception i32, i32

[sbc100]

lgtm % comment

[aardappel]

lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

465

This comment is related to the comment above about WebAssemblyAsmPrinter::EmitFunctionBodyStart. Effectively it means that compared to that code, we're missing this particular emit, but it doesn't seem to matter

[aheejin]

• Print only param list for eventtype

[aheejin]

In D55353#1321483, @sbc100 wrote:

Since event types can't have return values (they are always no_return right?) should we split out "parseParamList" and have them look like this?

.eventtype  __cpp_exception i32
.eventtype  some_other_exception i32, i32

Done.

[aheejin]

• Minor fix

lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

bool ParseInstruction(ParseInstructionInfo & /*Info*/, StringRef Name,
     return false;
   }
 
   void onLabelParsed(MCSymbol *Symbol) override {
     LastLabel = Symbol;
     CurrentState = Label;
   }
 
+  bool parseSignature(wasm::WasmSignature *Signature) {
+    if (expect(AsmToken::LParen, "("))
+      return true;
+    if (parseRegTypeList(Signature->Params))
+      return true;
+    if (expect(AsmToken::RParen, ")"))
+      return true;
+    if (expect(AsmToken::MinusGreater, "->"))
+      return true;
+    if (expect(AsmToken::LParen, "("))
+      return true;
+    if (parseRegTypeList(Signature->Returns))
+      return true;
+    if (expect(AsmToken::RParen, ")"))
+      return true;
+    return false;
+  }
+
   // This function processes wasm-specific directives streamed to
   // WebAssemblyTargetStreamer, all others go to the generic parser
   // (see WasmAsmParser).
   bool ParseDirective(AsmToken DirectiveID) override {
     // This function has a really weird return value behavior that is different
     // from all the other parsing functions:
     // - return true && no tokens consumed -> don't know this directive / let
     //   the generic parser handle it.
if (DirectiveID.getString() == ".functype") {
         return true;
       auto WasmSym = cast<MCSymbolWasm>(
           TOut.getStreamer().getContext().getOrCreateSymbol(SymName));
       if (CurrentState == Label && WasmSym == LastLabel) {
         // This .functype indicates a start of a function.
         CurrentState = FunctionStart;
       }
       auto Signature = make_unique<wasm::WasmSignature>();
-      if (expect(AsmToken::LParen, "("))
-        return true;
-      if (parseRegTypeList(Signature->Params))
-        return true;
-      if (expect(AsmToken::RParen, ")"))
-        return true;
-      if (expect(AsmToken::MinusGreater, "->"))
-        return true;
-      if (expect(AsmToken::LParen, "("))
-        return true;
-      if (parseRegTypeList(Signature->Returns))
-        return true;
-      if (expect(AsmToken::RParen, ")"))
+      if (parseSignature(Signature.get()))
         return true;
       WasmSym->setSignature(Signature.get());
       addSignature(std::move(Signature));
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
       TOut.emitFunctionType(WasmSym);
       // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
       return expect(AsmToken::EndOfStatement, "EOL");
     }
 
+    if (DirectiveID.getString() == ".eventtype") {
+      auto SymName = expectIdent();
+      if (SymName.empty())
+        return true;
+      auto WasmSym = cast<MCSymbolWasm>(
+          TOut.getStreamer().getContext().getOrCreateSymbol(SymName));
+      auto Signature = make_unique<wasm::WasmSignature>();
+      if (parseRegTypeList(Signature->Params))
+        return true;
+      WasmSym->setSignature(Signature.get());
+      addSignature(std::move(Signature));
+      WasmSym->setType(wasm::WASM_SYMBOL_TYPE_EVENT);
+      TOut.emitEventType(WasmSym);
+      // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
+      return expect(AsmToken::EndOfStatement, "EOL");
+    }
+
     if (DirectiveID.getString() == ".local") {
       if (CurrentState != FunctionStart)
         return error(".local directive should follow the start of a function",
                      Lexer.getTok());
       SmallVector<wasm::ValType, 4> Locals;
       if (parseRegTypeList(Locals))
         return true;
       TOut.emitLocal(Locals);

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.h

 
 protected:
   void emitValueType(wasm::ValType Type);
 };
 
 /// This part is for ascii assembly output
 class WebAssemblyTargetAsmStreamer final : public WebAssemblyTargetStreamer {
   formatted_raw_ostream &OS;
+  void emitSignature(const wasm::WasmSignature *Sig);
+  void emitParamList(const wasm::WasmSignature *Sig);
+  void emitReturnList(const wasm::WasmSignature *Sig);
 
 public:
   WebAssemblyTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS);
 
   void emitLocal(ArrayRef<wasm::ValType> Types) override;
   void emitEndFunc() override;
   void emitFunctionType(const MCSymbolWasm *Sym) override;
   void emitIndIdx(const MCExpr *Value) override;

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp

void WebAssemblyTargetAsmStreamer::emitLocal(ArrayRef<wasm::ValType> Types) {
   if (!Types.empty()) {
     OS << "\t.local  \t";
     printTypes(OS, Types);
   }
 }
 
 void WebAssemblyTargetAsmStreamer::emitEndFunc() { OS << "\t.endfunc\n"; }
 
-void WebAssemblyTargetAsmStreamer::emitFunctionType(const MCSymbolWasm *Sym) {
-  assert(Sym->isFunction());
-  OS << "\t.functype\t" << Sym->getName() << " (";
-  auto &Params = Sym->getSignature()->Params;
+void WebAssemblyTargetAsmStreamer::emitSignature(
+    const wasm::WasmSignature *Sig) {
+  OS << " (";
+  emitParamList(Sig);
+  OS << ") -> (";
+  emitReturnList(Sig);
+  OS << ")";
+}
+
+void WebAssemblyTargetAsmStreamer::emitParamList(
+    const wasm::WasmSignature *Sig) {
+  auto &Params = Sig->Params;
   for (auto &Ty : Params) {
-    if (&Ty != &Params[0]) OS << ", ";
+    if (&Ty != &Params[0])
+      OS << ", ";
     OS << WebAssembly::TypeToString(Ty);
   }
-  OS << ") -> (";
-  auto &Returns = Sym->getSignature()->Returns;
+}
+
+void WebAssemblyTargetAsmStreamer::emitReturnList(
+    const wasm::WasmSignature *Sig) {
+  auto &Returns = Sig->Returns;
   for (auto &Ty : Returns) {
-    if (&Ty != &Returns[0]) OS << ", ";
+    if (&Ty != &Returns[0])
+      OS << ", ";
     OS << WebAssembly::TypeToString(Ty);
   }
-  OS << ")\n";
+}
+
+void WebAssemblyTargetAsmStreamer::emitFunctionType(const MCSymbolWasm *Sym) {
+  assert(Sym->isFunction());
+  OS << "\t.functype\t" << Sym->getName();
+  emitSignature(Sym->getSignature());
+  OS << "\n";
 }
 
 void WebAssemblyTargetAsmStreamer::emitGlobalType(const MCSymbolWasm *Sym) {
   assert(Sym->isGlobal());
   OS << "\t.globaltype\t" << Sym->getName() << ", " <<
         WebAssembly::TypeToString(
           static_cast<wasm::ValType>(Sym->getGlobalType().Type)) <<
         '\n';
 }
 
 void WebAssemblyTargetAsmStreamer::emitEventType(const MCSymbolWasm *Sym) {
   assert(Sym->isEvent());
-  OS << "\t.eventtype\t" << Sym->getName();
-  if (Sym->getSignature()->Returns.empty())
-    OS << ", void";
-  else {
-    assert(Sym->getSignature()->Returns.size() == 1);
-    OS << ", "
-       << WebAssembly::TypeToString(Sym->getSignature()->Returns.front());
-  }
-  for (auto Ty : Sym->getSignature()->Params)
-    OS << ", " << WebAssembly::TypeToString(Ty);
-  OS << '\n';
+  OS << "\t.eventtype\t" << Sym->getName() << " ";
+  emitParamList(Sym->getSignature());
+  OS << "\n";
 }
 
 void WebAssemblyTargetAsmStreamer::emitImportModule(const MCSymbolWasm *Sym,
                                                     StringRef ModuleName) {
   OS << "\t.import_module\t" << Sym->getName() << ", " << ModuleName << '\n';
 }
 
 void WebAssemblyTargetAsmStreamer::emitIndIdx(const MCExpr *Value) {

test/CodeGen/WebAssembly/exception.ll

 declare i8* @__cxa_begin_catch(i8*)
 declare void @__cxa_end_catch()
 declare void @__cxa_rethrow()
 declare void @__clang_call_terminate(i8*)
 declare void @_ZSt9terminatev()
 declare %struct.Cleanup* @_ZN7CleanupD1Ev(%struct.Cleanup* returned)
 
 ; CHECK: __cpp_exception:
-; CHECK: .eventtype  __cpp_exception, void, i32
+; CHECK: .eventtype  __cpp_exception i32

test/MC/WebAssembly/basic-assembly.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
 # this one is just here to see if it converts to .o without errors, but doesn't check any output:
 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+simd128,+nontrapping-fptoint,+exception-handling < %s
 
     .text
     .section .text.main,"",@
     .type    test0,@function
 test0:
     # Test all types:
     .functype   test0 (i32, i64) -> (i32)
+    .eventtype  __cpp_exception i32
     .local      f32, f64, v128, v128
     # Explicit getlocal/setlocal:
     get_local   2
     set_local   2
     # Immediates:
     i32.const   -1
     f64.const   0x1.999999999999ap1
     v128.const  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
.LBB0_5:
     end_function
 .Lfunc_end0:
   .size test0, .Lfunc_end0-test0
     .globaltype __stack_pointer, i32
 
 # CHECK:           .text
 # CHECK-LABEL: test0:
 # CHECK-NEXT:      .functype test0 (i32, i64) -> (i32)
+# CHECK-NEXT:      .eventtype  __cpp_exception i32
 # CHECK-NEXT:      .local      f32, f64
 # CHECK-NEXT:      get_local   2
 # CHECK-NEXT:      set_local   2
 # CHECK-NEXT:      i32.const   -1
 # CHECK-NEXT:      f64.const   0x1.999999999999ap1
 # CHECK-NEXT:      v128.const  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
 # CHECK-NEXT:      v128.const  0, 1, 2, 3, 4, 5, 6, 7
 # CHECK-NEXT:      get_local   0