[WebAssembly] Rename event to tag

[aheejin]

Summary

We recently decided to change 'event' to 'tag', and 'event section' to
'tag section', out of the rationale that the section contains a
generalized tag that references a type, which may be used for something
other than exceptions, and the name 'event' can be confusing in the web
context.

See

• https://github.com/WebAssembly/exception-handling/issues/159#issuecomment-857910130
• https://github.com/WebAssembly/exception-handling/pull/161

[aheejin]

Oh, forgot to fix comments... will fix soon

[aheejin]

Update comment

[aheejin]

Typo fixes

[aheejin]

clang-tidy fix

[tlively]

LGTM! My only comments are about wording in some of the code comments.

lld/wasm/Symbols.h

422

425

426

427–429

430

432

lld/wasm/SyntheticSections.h

182

[aheejin]

Address comments

lld/include/lld/Common/LLVM.h

 namespace object {
 class WasmObjectFile;
 struct WasmSection;
 struct WasmSegment;
 class WasmSymbol;
 } // namespace object
 
 namespace wasm {
-struct WasmEvent;
-struct WasmEventType;
+struct WasmTag;
+struct WasmTagType;
 struct WasmFunction;
 struct WasmGlobal;
 struct WasmGlobalType;
 struct WasmInitExpr;
 struct WasmLimits;
 struct WasmRelocation;
 struct WasmSignature;
 struct WasmTable;

 using llvm::SmallVector;
 using llvm::StringRef;
 using llvm::Twine;
 
 using llvm::object::WasmObjectFile;
 using llvm::object::WasmSection;
 using llvm::object::WasmSegment;
 using llvm::object::WasmSymbol;
-using llvm::wasm::WasmEvent;
-using llvm::wasm::WasmEventType;
 using llvm::wasm::WasmFunction;
 using llvm::wasm::WasmGlobal;
 using llvm::wasm::WasmGlobalType;
 using llvm::wasm::WasmInitExpr;
 using llvm::wasm::WasmLimits;
 using llvm::wasm::WasmRelocation;
 using llvm::wasm::WasmSignature;
 using llvm::wasm::WasmTable;
 using llvm::wasm::WasmTableType;
+using llvm::wasm::WasmTag;
+using llvm::wasm::WasmTagType;
 } // end namespace lld.
 
 namespace std {
 template <> struct hash<llvm::StringRef> {
 public:
   size_t operator()(const llvm::StringRef &s) const {
     return llvm::hash_value(s);
   }
 };
 } // namespace std
 
 #endif

lld/test/wasm/Inputs/tag-section1.ll

 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare void @llvm.wasm.throw(i32, i8*)
 
 define void @foo(i8* %p) {
   call void @llvm.wasm.throw(i32 0, i8* %p)
   ret void
 }

lld/test/wasm/Inputs/tag-section2.ll

 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare void @llvm.wasm.throw(i32, i8*)
 
 define void @bar(i8* %p) {
   call void @llvm.wasm.throw(i32 0, i8* %p)
   ret void
 }

lld/test/wasm/tag-section.ll

-; RUN: llc -filetype=obj -exception-model=wasm -mattr=+exception-handling %p/Inputs/event-section1.ll -o %t1.o
-; RUN: llc -filetype=obj -exception-model=wasm -mattr=+exception-handling %p/Inputs/event-section2.ll -o %t2.o
+; RUN: llc -filetype=obj -exception-model=wasm -mattr=+exception-handling %p/Inputs/tag-section1.ll -o %t1.o
+; RUN: llc -filetype=obj -exception-model=wasm -mattr=+exception-handling %p/Inputs/tag-section2.ll -o %t2.o
 ; RUN: llc -filetype=obj -exception-model=wasm -mattr=+exception-handling %s -o %t.o
 ; RUN: wasm-ld -o %t.wasm %t.o %t1.o %t2.o
 ; RUN: wasm-ld --export-all -o %t-export-all.wasm %t.o %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 ; RUN: obj2yaml %t-export-all.wasm | FileCheck %s --check-prefix=EXPORT-ALL
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"

 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ParamTypes:      []
 ; CHECK-NEXT:         ReturnTypes:     []
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:         ReturnTypes:     []
 
-; CHECK:        - Type:            EVENT
-; CHECK-NEXT:     Events:
+; CHECK:        - Type:            TAG
+; CHECK-NEXT:     Tags:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Attribute:       0
 ; CHECK-NEXT:         SigIndex:        1
 
-; Global section has to come after event section
+; Global section has to come after tag section
 ; CHECK:        - Type:            GLOBAL
 
 ; EXPORT-ALL:   - Type:            EXPORT
 ; EXPORT-ALL-NEXT Exports:
 ; EXPORT-ALL:       - Name:            __cpp_exception
-; EXPORT-ALL:         Kind:            EVENT
+; EXPORT-ALL:         Kind:            TAG
 ; EXPORT-ALL:         Index:           0

lld/wasm/InputChunks.cpp

for (const WasmRelocation &rel : relocations) {
     LLVM_DEBUG(dbgs() << " addend=" << rel.Addend << " index=" << rel.Index
                       << " value=" << value << " offset=" << rel.Offset
                       << "\n");
 
     switch (rel.Type) {
     case R_WASM_TYPE_INDEX_LEB:
     case R_WASM_FUNCTION_INDEX_LEB:
     case R_WASM_GLOBAL_INDEX_LEB:
-    case R_WASM_EVENT_INDEX_LEB:
+    case R_WASM_TAG_INDEX_LEB:
     case R_WASM_MEMORY_ADDR_LEB:
     case R_WASM_TABLE_NUMBER_LEB:
       encodeULEB128(value, loc, 5);
       break;
     case R_WASM_MEMORY_ADDR_LEB64:
       encodeULEB128(value, loc, 10);
       break;
     case R_WASM_TABLE_INDEX_SLEB:

 // Write a relocation value without padding and return the number of bytes
 // witten.
 static unsigned writeCompressedReloc(uint8_t *buf, const WasmRelocation &rel,
                                      uint64_t value) {
   switch (rel.Type) {
   case R_WASM_TYPE_INDEX_LEB:
   case R_WASM_FUNCTION_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_LEB:
-  case R_WASM_EVENT_INDEX_LEB:
+  case R_WASM_TAG_INDEX_LEB:
   case R_WASM_MEMORY_ADDR_LEB:
   case R_WASM_MEMORY_ADDR_LEB64:
   case R_WASM_TABLE_NUMBER_LEB:
     return encodeULEB128(value, buf);
   case R_WASM_TABLE_INDEX_SLEB:
   case R_WASM_TABLE_INDEX_SLEB64:
   case R_WASM_MEMORY_ADDR_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB64:
     return encodeSLEB128(static_cast<int64_t>(value), buf);
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
 static unsigned getRelocWidthPadded(const WasmRelocation &rel) {
   switch (rel.Type) {
   case R_WASM_TYPE_INDEX_LEB:
   case R_WASM_FUNCTION_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_LEB:
-  case R_WASM_EVENT_INDEX_LEB:
+  case R_WASM_TAG_INDEX_LEB:
   case R_WASM_MEMORY_ADDR_LEB:
   case R_WASM_TABLE_NUMBER_LEB:
   case R_WASM_TABLE_INDEX_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB:
     return 5;
   case R_WASM_TABLE_INDEX_SLEB64:
   case R_WASM_MEMORY_ADDR_LEB64:
   case R_WASM_MEMORY_ADDR_SLEB64:

lld/wasm/InputElement.h

 #include "InputFiles.h"
 #include "WriterUtils.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/Object/Wasm.h"
 
 namespace lld {
 namespace wasm {
 
-// Represents a single element (Global, Event, Table, etc) within an input
+// Represents a single element (Global, Tag, Table, etc) within an input
 // file.
 class InputElement {
 protected:
   InputElement(StringRef name, ObjFile *f)
       : file(f), live(!config->gcSections), name(name) {}
 
 public:
   StringRef getName() const { return name; }
void setPointerValue(uint64_t value) {
     initExpr = intConst(value, config->is64.getValueOr(false));
   }
 
 private:
   WasmGlobalType type;
   WasmInitExpr initExpr;
 };
 
-class InputEvent : public InputElement {
+class InputTag : public InputElement {
 public:
-  InputEvent(const WasmSignature &s, const WasmEvent &e, ObjFile *f)
-      : InputElement(e.SymbolName, f), signature(s), type(e.Type) {}
+  InputTag(const WasmSignature &s, const WasmTag &t, ObjFile *f)
+      : InputElement(t.SymbolName, f), signature(s), type(t.Type) {}
 
-  const WasmEventType &getType() const { return type; }
+  const WasmTagType &getType() const { return type; }
 
   const WasmSignature &signature;
 
 private:
-  WasmEventType type;
+  WasmTagType type;
 };
 
 class InputTable : public InputElement {
 public:
   InputTable(const WasmTable &t, ObjFile *f)
       : InputElement(t.SymbolName, f), type(t.Type) {}
 
   const WasmTableType &getType() const { return type; }

lld/wasm/InputFiles.h

 
 namespace lld {
 namespace wasm {
 
 class InputChunk;
 class InputFunction;
 class InputSegment;
 class InputGlobal;
-class InputEvent;
+class InputTag;
 class InputTable;
 class InputSection;
 
 // If --reproduce option is given, all input files are written
 // to this tar archive.
 extern std::unique_ptr<llvm::TarWriter> tar;
 
 class InputFile {
public:
   std::vector<bool> typeIsUsed;
   // Maps function indices to table indices
   std::vector<uint32_t> tableEntries;
   std::vector<uint32_t> tableEntriesRel;
   std::vector<bool> keptComdats;
   std::vector<InputChunk *> segments;
   std::vector<InputFunction *> functions;
   std::vector<InputGlobal *> globals;
-  std::vector<InputEvent *> events;
+  std::vector<InputTag *> tags;
   std::vector<InputTable *> tables;
   std::vector<InputChunk *> customSections;
   llvm::DenseMap<uint32_t, InputChunk *> customSectionsByIndex;
 
   Symbol *getSymbol(uint32_t index) const { return symbols[index]; }
   FunctionSymbol *getFunctionSymbol(uint32_t index) const;
   DataSymbol *getDataSymbol(uint32_t index) const;
   GlobalSymbol *getGlobalSymbol(uint32_t index) const;
   SectionSymbol *getSectionSymbol(uint32_t index) const;
-  EventSymbol *getEventSymbol(uint32_t index) const;
+  TagSymbol *getTagSymbol(uint32_t index) const;
   TableSymbol *getTableSymbol(uint32_t index) const;
 
 private:
   Symbol *createDefined(const WasmSymbol &sym);
   Symbol *createUndefined(const WasmSymbol &sym, bool isCalledDirectly);
 
   bool isExcludedByComdat(InputChunk *chunk) const;
   void addLegacyIndirectFunctionTableIfNeeded(uint32_t tableSymbolCount);

lld/wasm/InputFiles.cpp

InputFile *createObjectFile(MemoryBufferRef mb, StringRef archiveName) {
   fatal("unknown file type: " + mb.getBufferIdentifier());
 }
 
 void ObjFile::dumpInfo() const {
   log("info for: " + toString(this) +
       "\n              Symbols : " + Twine(symbols.size()) +
       "\n     Function Imports : " + Twine(wasmObj->getNumImportedFunctions()) +
       "\n       Global Imports : " + Twine(wasmObj->getNumImportedGlobals()) +
-      "\n        Event Imports : " + Twine(wasmObj->getNumImportedEvents()) +
+      "\n        Tag Imports   : " + Twine(wasmObj->getNumImportedTags()) +
       "\n        Table Imports : " + Twine(wasmObj->getNumImportedTables()));
 }
 
 // Relocations contain either symbol or type indices.  This function takes a
 // relocation and returns relocated index (i.e. translates from the input
 // symbol/type space to the output symbol/type space).
 uint32_t ObjFile::calcNewIndex(const WasmRelocation &reloc) const {
   if (reloc.Type == R_WASM_TYPE_INDEX_LEB) {
case R_WASM_TYPE_INDEX_LEB:
     return typeMap[reloc.Index];
   case R_WASM_FUNCTION_INDEX_LEB:
     return getFunctionSymbol(reloc.Index)->getFunctionIndex();
   case R_WASM_GLOBAL_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_I32:
     if (auto gs = dyn_cast<GlobalSymbol>(sym))
       return gs->getGlobalIndex();
     return sym->getGOTIndex();
-  case R_WASM_EVENT_INDEX_LEB:
-    return getEventSymbol(reloc.Index)->getEventIndex();
+  case R_WASM_TAG_INDEX_LEB:
+    return getTagSymbol(reloc.Index)->getTagIndex();
   case R_WASM_FUNCTION_OFFSET_I32:
   case R_WASM_FUNCTION_OFFSET_I64: {
     auto *f = cast<DefinedFunction>(sym);
     return f->function->getOffset(f->function->getFunctionCodeOffset() +
                                   reloc.Addend);
   }
   case R_WASM_SECTION_OFFSET_I32:
     return getSectionSymbol(reloc.Index)->section->getOffset(reloc.Addend);
void ObjFile::addLegacyIndirectFunctionTableIfNeeded(
   info->ImportModule = tableImport->Module;
   info->ImportName = tableImport->Field;
   info->Flags = WASM_SYMBOL_UNDEFINED;
   info->Flags |= WASM_SYMBOL_NO_STRIP;
   info->ElementIndex = 0;
   LLVM_DEBUG(dbgs() << "Synthesizing symbol for table import: " << info->Name
                     << "\n");
   const WasmGlobalType *globalType = nullptr;
-  const WasmEventType *eventType = nullptr;
+  const WasmTagType *tagType = nullptr;
   const WasmSignature *signature = nullptr;
   auto *wasmSym = make<WasmSymbol>(*info, globalType, &tableImport->Table,
-                                   eventType, signature);
+                                   tagType, signature);
   Symbol *sym = createUndefined(*wasmSym, false);
   // We're only sure it's a TableSymbol if the createUndefined succeeded.
   if (errorCount())
     return;
   symbols.push_back(sym);
   // Because there are no TABLE_NUMBER relocs, we can't compute accurate
   // liveness info; instead, just mark the symbol as always live.
   sym->markLive();
void ObjFile::parse(bool ignoreComdats) {
   // Populate `Tables`.
   for (const WasmTable &t : wasmObj->tables())
     tables.emplace_back(make<InputTable>(t, this));
 
   // Populate `Globals`.
   for (const WasmGlobal &g : wasmObj->globals())
     globals.emplace_back(make<InputGlobal>(g, this));
 
-  // Populate `Events`.
-  for (const WasmEvent &e : wasmObj->events())
-    events.emplace_back(make<InputEvent>(types[e.Type.SigIndex], e, this));
+  // Populate `Tags`.
+  for (const WasmTag &t : wasmObj->tags())
+    tags.emplace_back(make<InputTag>(types[t.Type.SigIndex], t, this));
 
   // Populate `Symbols` based on the symbols in the object.
   symbols.reserve(wasmObj->getNumberOfSymbols());
   uint32_t tableSymbolCount = 0;
   for (const SymbolRef &sym : wasmObj->symbols()) {
     const WasmSymbol &wasmSym = wasmObj->getWasmSymbol(sym.getRawDataRefImpl());
     if (wasmSym.isTypeTable())
       tableSymbolCount++;

 FunctionSymbol *ObjFile::getFunctionSymbol(uint32_t index) const {
   return cast<FunctionSymbol>(symbols[index]);
 }
 
 GlobalSymbol *ObjFile::getGlobalSymbol(uint32_t index) const {
   return cast<GlobalSymbol>(symbols[index]);
 }
 
-EventSymbol *ObjFile::getEventSymbol(uint32_t index) const {
-  return cast<EventSymbol>(symbols[index]);
+TagSymbol *ObjFile::getTagSymbol(uint32_t index) const {
+  return cast<TagSymbol>(symbols[index]);
 }
 
 TableSymbol *ObjFile::getTableSymbol(uint32_t index) const {
   return cast<TableSymbol>(symbols[index]);
 }
 
 SectionSymbol *ObjFile::getSectionSymbol(uint32_t index) const {
   return cast<SectionSymbol>(symbols[index]);
case WASM_SYMBOL_TYPE_SECTION: {
     InputChunk *section = customSectionsByIndex[sym.Info.ElementIndex];
     assert(sym.isBindingLocal());
     // Need to return null if discarded here? data and func only do that when
     // binding is not local.
     if (section->discarded)
       return nullptr;
     return make<SectionSymbol>(flags, section, this);
   }
-  case WASM_SYMBOL_TYPE_EVENT: {
-    InputEvent *event =
-        events[sym.Info.ElementIndex - wasmObj->getNumImportedEvents()];
+  case WASM_SYMBOL_TYPE_TAG: {
+    InputTag *tag = tags[sym.Info.ElementIndex - wasmObj->getNumImportedTags()];
     if (sym.isBindingLocal())
-      return make<DefinedEvent>(name, flags, this, event);
-    return symtab->addDefinedEvent(name, flags, this, event);
+      return make<DefinedTag>(name, flags, this, tag);
+    return symtab->addDefinedTag(name, flags, this, tag);
   }
   case WASM_SYMBOL_TYPE_TABLE: {
     InputTable *table =
         tables[sym.Info.ElementIndex - wasmObj->getNumImportedTables()];
     if (sym.isBindingLocal())
       return make<DefinedTable>(name, flags, this, table);
     return symtab->addDefinedTable(name, flags, this, table);
   }

lld/wasm/MarkLive.cpp

for (const ObjFile *obj : symtab->objectFiles) {
         if (!c->live)
           message("removing unused section " + toString(c));
       for (InputChunk *c : obj->segments)
         if (!c->live)
           message("removing unused section " + toString(c));
       for (InputGlobal *g : obj->globals)
         if (!g->live)
           message("removing unused section " + toString(g));
-      for (InputEvent *e : obj->events)
-        if (!e->live)
-          message("removing unused section " + toString(e));
+      for (InputTag *t : obj->tags)
+        if (!t->live)
+          message("removing unused section " + toString(t));
       for (InputTable *t : obj->tables)
         if (!t->live)
           message("removing unused section " + toString(t));
     }
     for (InputChunk *c : symtab->syntheticFunctions)
       if (!c->live)
         message("removing unused section " + toString(c));
     for (InputGlobal *g : symtab->syntheticGlobals)

lld/wasm/OutputSections.cpp

static StringRef sectionTypeToString(uint32_t sectionType) {
   case WASM_SEC_FUNCTION:
     return "FUNCTION";
   case WASM_SEC_TABLE:
     return "TABLE";
   case WASM_SEC_MEMORY:
     return "MEMORY";
   case WASM_SEC_GLOBAL:
     return "GLOBAL";
-  case WASM_SEC_EVENT:
-    return "EVENT";
+  case WASM_SEC_TAG:
+    return "TAG";
   case WASM_SEC_EXPORT:
     return "EXPORT";
   case WASM_SEC_START:
     return "START";
   case WASM_SEC_ELEM:
     return "ELEM";
   case WASM_SEC_CODE:
     return "CODE";

lld/wasm/SymbolTable.h

public:
   void trace(StringRef name);
 
   Symbol *addDefinedFunction(StringRef name, uint32_t flags, InputFile *file,
                              InputFunction *function);
   Symbol *addDefinedData(StringRef name, uint32_t flags, InputFile *file,
                          InputChunk *segment, uint64_t address, uint64_t size);
   Symbol *addDefinedGlobal(StringRef name, uint32_t flags, InputFile *file,
                            InputGlobal *g);
-  Symbol *addDefinedEvent(StringRef name, uint32_t flags, InputFile *file,
-                          InputEvent *e);
+  Symbol *addDefinedTag(StringRef name, uint32_t flags, InputFile *file,
+                        InputTag *t);
   Symbol *addDefinedTable(StringRef name, uint32_t flags, InputFile *file,
                           InputTable *t);
 
   Symbol *addUndefinedFunction(StringRef name,
                                llvm::Optional<StringRef> importName,
                                llvm::Optional<StringRef> importModule,
                                uint32_t flags, InputFile *file,
                                const WasmSignature *signature,

lld/wasm/SymbolTable.cpp

static void checkGlobalType(const Symbol *existing, const InputFile *file,
   const WasmGlobalType *oldType = cast<GlobalSymbol>(existing)->getGlobalType();
   if (*newType != *oldType) {
     error("Global type mismatch: " + existing->getName() + "\n>>> defined as " +
           toString(*oldType) + " in " + toString(existing->getFile()) +
           "\n>>> defined as " + toString(*newType) + " in " + toString(file));
   }
 }
 
-static void checkEventType(const Symbol *existing, const InputFile *file,
-                           const WasmEventType *newType,
-                           const WasmSignature *newSig) {
-  auto existingEvent = dyn_cast<EventSymbol>(existing);
-  if (!isa<EventSymbol>(existing)) {
-    reportTypeError(existing, file, WASM_SYMBOL_TYPE_EVENT);
+static void checkTagType(const Symbol *existing, const InputFile *file,
+                         const WasmTagType *newType,
+  auto existingTag = dyn_cast<TagSymbol>(existing);
+  if (!isa<TagSymbol>(existing)) {
+    reportTypeError(existing, file, WASM_SYMBOL_TYPE_TAG);
     return;
   }
 
-  const WasmEventType *oldType = cast<EventSymbol>(existing)->getEventType();
-  const WasmSignature *oldSig = existingEvent->signature;
+  const WasmTagType *oldType = cast<TagSymbol>(existing)->getTagType();
+  const WasmSignature *oldSig = existingTag->signature;
   if (newType->Attribute != oldType->Attribute)
-    error("Event type mismatch: " + existing->getName() + "\n>>> defined as " +
+    error("Tag type mismatch: " + existing->getName() + "\n>>> defined as " +
           toString(*oldType) + " in " + toString(existing->getFile()) +
           "\n>>> defined as " + toString(*newType) + " in " + toString(file));
   if (*newSig != *oldSig)
-    warn("Event signature mismatch: " + existing->getName() +
+    warn("Tag signature mismatch: " + existing->getName() +
          "\n>>> defined as " + toString(*oldSig) + " in " +
          toString(existing->getFile()) + "\n>>> defined as " +
          toString(*newSig) + " in " + toString(file));
 }
 
 static void checkTableType(const Symbol *existing, const InputFile *file,
                            const WasmTableType *newType) {
   if (!isa<TableSymbol>(existing)) {
Symbol *SymbolTable::addDefinedGlobal(StringRef name, uint32_t flags,
 
   checkGlobalType(s, file, &global->getType());
 
   if (shouldReplace(s, file, flags))
     replaceSym();
   return s;
 }
 
-Symbol *SymbolTable::addDefinedEvent(StringRef name, uint32_t flags,
-                                     InputFile *file, InputEvent *event) {
-  LLVM_DEBUG(dbgs() << "addDefinedEvent:" << name << "\n");
+Symbol *SymbolTable::addDefinedTag(StringRef name, uint32_t flags,
+                                   InputFile *file, InputTag *tag) {
+  LLVM_DEBUG(dbgs() << "addDefinedTag:" << name << "\n");
 
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name, file);
 
   auto replaceSym = [&]() {
-    replaceSymbol<DefinedEvent>(s, name, flags, file, event);
+    replaceSymbol<DefinedTag>(s, name, flags, file, tag);
   };
 
   if (wasInserted || s->isLazy()) {
     replaceSym();
     return s;
   }
 
-  checkEventType(s, file, &event->getType(), &event->signature);
+  checkTagType(s, file, &tag->getType(), &tag->signature);
 
   if (shouldReplace(s, file, flags))
     replaceSym();
   return s;
 }
 
 Symbol *SymbolTable::addDefinedTable(StringRef name, uint32_t flags,
                                      InputFile *file, InputTable *table) {

lld/wasm/Symbols.h

 
 using llvm::wasm::WasmSymbolType;
 
 class InputFile;
 class InputChunk;
 class InputSegment;
 class InputFunction;
 class InputGlobal;
-class InputEvent;
+class InputTag;
 class InputSection;
 class InputTable;
 class OutputSection;
 
 #define INVALID_INDEX UINT32_MAX
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind : uint8_t {
     DefinedFunctionKind,
     DefinedDataKind,
     DefinedGlobalKind,
-    DefinedEventKind,
+    DefinedTagKind,
     DefinedTableKind,
     SectionKind,
     OutputSectionKind,
     UndefinedFunctionKind,
     UndefinedDataKind,
     UndefinedGlobalKind,
     UndefinedTableKind,
     LazyKind,
public:
   static bool classof(const Symbol *s) {
     return s->kind() == UndefinedTableKind;
   }
 
   llvm::Optional<StringRef> importName;
   llvm::Optional<StringRef> importModule;
 };
 
+// TODO fix
 // Wasm events are features that suspend the current execution and transfer the
 // control flow to a corresponding handler. Currently the only supported event
 // kind is exceptions.
 //
 // Event tags are values to distinguish different events. For exceptions, they
 // can be used to distinguish different language's exceptions, i.e., all C++
 // exceptions have the same tag. Wasm can generate code capable of doing
 // different handling actions based on the tag of caught exceptions.
 //
-// A single EventSymbol object represents a single tag. C++ exception event
+// A single TagSymbol object represents a single tag. C++ exception event
 // symbol is a weak symbol generated in every object file in which exceptions
 // are used, and has name '__cpp_exception' for linking.
-class EventSymbol : public Symbol {
+class TagSymbol : public Symbol {
 public:
-  static bool classof(const Symbol *s) { return s->kind() == DefinedEventKind; }
+  static bool classof(const Symbol *s) { return s->kind() == DefinedTagKind; }
 
-  const WasmEventType *getEventType() const { return eventType; }
+  const WasmTagType *getTagType() const { return tagType; }
 
-  // Get/set the event index
-  uint32_t getEventIndex() const;
-  void setEventIndex(uint32_t index);
-  bool hasEventIndex() const;
+  // Get/set the tag index
+  uint32_t getTagIndex() const;
+  void setTagIndex(uint32_t index);
+  bool hasTagIndex() const;
 
   const WasmSignature *signature;
 
 protected:
-  EventSymbol(StringRef name, Kind k, uint32_t flags, InputFile *f,
-              const WasmEventType *eventType, const WasmSignature *sig)
-      : Symbol(name, k, flags, f), signature(sig), eventType(eventType) {}
+  TagSymbol(StringRef name, Kind k, uint32_t flags, InputFile *f,
+            const WasmTagType *tagType, const WasmSignature *sig)
+      : Symbol(name, k, flags, f), signature(sig), tagType(tagType) {}
 
-  const WasmEventType *eventType;
-  uint32_t eventIndex = INVALID_INDEX;
+  const WasmTagType *tagType;
+  uint32_t tagIndex = INVALID_INDEX;
 };
 
-class DefinedEvent : public EventSymbol {
+class DefinedTag : public TagSymbol {
 public:
-  DefinedEvent(StringRef name, uint32_t flags, InputFile *file,
-               InputEvent *event);
+  DefinedTag(StringRef name, uint32_t flags, InputFile *file, InputTag *tag);
 
-  static bool classof(const Symbol *s) { return s->kind() == DefinedEventKind; }
+  static bool classof(const Symbol *s) { return s->kind() == DefinedTagKind; }
 
-  InputEvent *event;
+  InputTag *tag;
 };
 
 // LazySymbol represents a symbol that is not yet in the link, but we know where
 // to find it if needed. If the resolver finds both Undefined and Lazy for the
 // same name, it will ask the Lazy to load a file.
 //
 // A special complication is the handling of weak undefined symbols. They should
 // not load a file, but we have to remember we have seen both the weak undefined

 
 // A buffer class that is large enough to hold any Symbol-derived
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
   alignas(DefinedFunction) char a[sizeof(DefinedFunction)];
   alignas(DefinedData) char b[sizeof(DefinedData)];
   alignas(DefinedGlobal) char c[sizeof(DefinedGlobal)];
-  alignas(DefinedEvent) char d[sizeof(DefinedEvent)];
+  alignas(DefinedTag) char d[sizeof(DefinedTag)];
   alignas(DefinedTable) char e[sizeof(DefinedTable)];
   alignas(LazySymbol) char f[sizeof(LazySymbol)];
   alignas(UndefinedFunction) char g[sizeof(UndefinedFunction)];
   alignas(UndefinedData) char h[sizeof(UndefinedData)];
   alignas(UndefinedGlobal) char i[sizeof(UndefinedGlobal)];
   alignas(UndefinedTable) char j[sizeof(UndefinedTable)];
   alignas(SectionSymbol) char k[sizeof(SectionSymbol)];
 };

lld/wasm/Symbols.cpp

std::string toString(wasm::Symbol::Kind kind) {
   case wasm::Symbol::DefinedFunctionKind:
     return "DefinedFunction";
   case wasm::Symbol::DefinedDataKind:
     return "DefinedData";
   case wasm::Symbol::DefinedGlobalKind:
     return "DefinedGlobal";
   case wasm::Symbol::DefinedTableKind:
     return "DefinedTable";
-  case wasm::Symbol::DefinedEventKind:
-    return "DefinedEvent";
+  case wasm::Symbol::DefinedTagKind:
+    return "DefinedTag";
   case wasm::Symbol::UndefinedFunctionKind:
     return "UndefinedFunction";
   case wasm::Symbol::UndefinedDataKind:
     return "UndefinedData";
   case wasm::Symbol::UndefinedGlobalKind:
     return "UndefinedGlobal";
   case wasm::Symbol::UndefinedTableKind:
     return "UndefinedTable";

 
 WasmSymbolType Symbol::getWasmType() const {
   if (isa<FunctionSymbol>(this))
     return WASM_SYMBOL_TYPE_FUNCTION;
   if (isa<DataSymbol>(this))
     return WASM_SYMBOL_TYPE_DATA;
   if (isa<GlobalSymbol>(this))
     return WASM_SYMBOL_TYPE_GLOBAL;
-  if (isa<EventSymbol>(this))
-    return WASM_SYMBOL_TYPE_EVENT;
+  if (isa<TagSymbol>(this))
+    return WASM_SYMBOL_TYPE_TAG;
   if (isa<TableSymbol>(this))
     return WASM_SYMBOL_TYPE_TABLE;
   if (isa<SectionSymbol>(this) || isa<OutputSectionSymbol>(this))
     return WASM_SYMBOL_TYPE_SECTION;
   llvm_unreachable("invalid symbol kind");
 }
 
 const WasmSignature *Symbol::getSignature() const {
bool Symbol::isDiscarded() const {
   if (InputChunk *c = getChunk())
     return c->discarded;
   return false;
 }
 
 bool Symbol::isLive() const {
   if (auto *g = dyn_cast<DefinedGlobal>(this))
     return g->global->live;
-  if (auto *e = dyn_cast<DefinedEvent>(this))
-    return e->event->live;
+  if (auto *t = dyn_cast<DefinedTag>(this))
+    return t->tag->live;
   if (auto *t = dyn_cast<DefinedTable>(this))
     return t->table->live;
   if (InputChunk *c = getChunk())
     return c->live;
   return referenced;
 }
 
 void Symbol::markLive() {
   assert(!isDiscarded());
   referenced = true;
   if (file != NULL && isDefined())
     file->markLive();
   if (auto *g = dyn_cast<DefinedGlobal>(this))
     g->global->live = true;
-  if (auto *e = dyn_cast<DefinedEvent>(this))
-    e->event->live = true;
+  if (auto *t = dyn_cast<DefinedTag>(this))
+    t->tag->live = true;
   if (auto *t = dyn_cast<DefinedTable>(this))
     t->table->live = true;
   if (InputChunk *c = getChunk()) {
     // Usually, a whole chunk is marked as live or dead, but in mergeable
     // (splittable) sections, each piece of data has independent liveness bit.
     // So we explicitly tell it which offset is in use.
     if (auto *d = dyn_cast<DefinedData>(this)) {
       if (auto *ms = dyn_cast<MergeInputChunk>(c)) {

 }
 
 DefinedGlobal::DefinedGlobal(StringRef name, uint32_t flags, InputFile *file,
                              InputGlobal *global)
     : GlobalSymbol(name, DefinedGlobalKind, flags, file,
                    global ? &global->getType() : nullptr),
       global(global) {}
 
-uint32_t EventSymbol::getEventIndex() const {
-  if (auto *f = dyn_cast<DefinedEvent>(this))
-    return f->event->getAssignedIndex();
-  assert(eventIndex != INVALID_INDEX);
-  return eventIndex;
-}
-
-void EventSymbol::setEventIndex(uint32_t index) {
-  LLVM_DEBUG(dbgs() << "setEventIndex " << name << " -> " << index << "\n");
-  assert(eventIndex == INVALID_INDEX);
-  eventIndex = index;
-}
-
-bool EventSymbol::hasEventIndex() const {
-  if (auto *f = dyn_cast<DefinedEvent>(this))
-    return f->event->hasAssignedIndex();
-  return eventIndex != INVALID_INDEX;
-}
-
-DefinedEvent::DefinedEvent(StringRef name, uint32_t flags, InputFile *file,
-                           InputEvent *event)
-    : EventSymbol(name, DefinedEventKind, flags, file,
-                  event ? &event->getType() : nullptr,
-                  event ? &event->signature : nullptr),
-      event(event) {}
+uint32_t TagSymbol::getTagIndex() const {
+  if (auto *f = dyn_cast<DefinedTag>(this))
+    return f->tag->getAssignedIndex();
+  assert(tagIndex != INVALID_INDEX);
+  return tagIndex;
+}
+
+void TagSymbol::setTagIndex(uint32_t index) {
+  LLVM_DEBUG(dbgs() << "setTagIndex " << name << " -> " << index << "\n");
+  assert(tagIndex == INVALID_INDEX);
+  tagIndex = index;
+}
+
+bool TagSymbol::hasTagIndex() const {
+  if (auto *f = dyn_cast<DefinedTag>(this))
+    return f->tag->hasAssignedIndex();
+  return tagIndex != INVALID_INDEX;
+}
+
+DefinedTag::DefinedTag(StringRef name, uint32_t flags, InputFile *file,
+                       InputTag *tag)
+    : TagSymbol(name, DefinedTagKind, flags, file,
+                tag ? &tag->getType() : nullptr,
+                tag ? &tag->signature : nullptr),
+      tag(tag) {}
 
 void TableSymbol::setLimits(const WasmLimits &limits) {
   if (auto *t = dyn_cast<DefinedTable>(this))
     t->table->setLimits(limits);
   auto *newType = make<WasmTableType>(*tableType);
   newType->Limits = limits;
   tableType = newType;
 }

lld/wasm/SyntheticSections.h

public:
   uint32_t getNumImportedGlobals() const {
     assert(isSealed);
     return numImportedGlobals;
   }
   uint32_t getNumImportedFunctions() const {
     assert(isSealed);
     return numImportedFunctions;
   }
-  uint32_t getNumImportedEvents() const {
+  uint32_t getNumImportedTags() const {
     assert(isSealed);
-    return numImportedEvents;
+    return numImportedTags;
   }
   uint32_t getNumImportedTables() const {
     assert(isSealed);
     return numImportedTables;
   }
 
   std::vector<const Symbol *> importedSymbols;
   std::vector<const Symbol *> gotSymbols;
 
 protected:
   bool isSealed = false;
   unsigned numImportedGlobals = 0;
   unsigned numImportedFunctions = 0;
-  unsigned numImportedEvents = 0;
+  unsigned numImportedTags = 0;
   unsigned numImportedTables = 0;
 };
 
 class FunctionSection : public SyntheticSection {
 public:
   FunctionSection() : SyntheticSection(llvm::wasm::WASM_SEC_FUNCTION) {}
 
   bool isNeeded() const override { return inputFunctions.size() > 0; };
public:
 
   bool isNeeded() const override { return !config->importMemory; }
   void writeBody() override;
 
   uint64_t numMemoryPages = 0;
   uint64_t maxMemoryPages = 0;
 };
 
+// TODO fix
 // The event section contains a list of declared wasm events associated with the
 // module. Currently the only supported event kind is exceptions. A single event
 // entry represents a single event with an event tag. All C++ exceptions are
 // represented by a single event. An event entry in this section contains
 // information on what kind of event it is (e.g. exception) and the type of
 // values contained in a single event object. (In wasm, an event can contain
 // multiple values of primitive types. But for C++ exceptions, we just throw a
 // pointer which is an i32 value (for wasm32 architecture), so the signature of
 // C++ exception is (i32)->(void), because all event types are assumed to have
 // void return type to share WasmSignature with functions.)
-class EventSection : public SyntheticSection {
+class TagSection : public SyntheticSection {
 public:
-  EventSection() : SyntheticSection(llvm::wasm::WASM_SEC_EVENT) {}
+  TagSection() : SyntheticSection(llvm::wasm::WASM_SEC_TAG) {}
   void writeBody() override;
-  bool isNeeded() const override { return inputEvents.size() > 0; }
-  void addEvent(InputEvent *event);
+  bool isNeeded() const override { return inputTags.size() > 0; }
+  void addTag(InputTag *tag);
 
-  std::vector<InputEvent *> inputEvents;
+  std::vector<InputTag *> inputTags;
 };
 
 class GlobalSection : public SyntheticSection {
 public:
   GlobalSection() : SyntheticSection(llvm::wasm::WASM_SEC_GLOBAL) {}
 
   static bool classof(const OutputSection *sec) {
     return sec->type == llvm::wasm::WASM_SEC_GLOBAL;

 struct OutStruct {
   DylinkSection *dylinkSec;
   TypeSection *typeSec;
   FunctionSection *functionSec;
   ImportSection *importSec;
   TableSection *tableSec;
   MemorySection *memorySec;
   GlobalSection *globalSec;
-  EventSection *eventSec;
+  TagSection *tagSec;
   ExportSection *exportSec;
   StartSection *startSec;
   ElemSection *elemSec;
   DataCountSection *dataCountSec;
   LinkingSection *linkingSec;
   NameSection *nameSec;
   ProducersSection *producersSec;
   TargetFeaturesSection *targetFeaturesSec;
 };
 
 extern OutStruct out;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

lld/wasm/SyntheticSections.cpp

 
 void ImportSection::addImport(Symbol *sym) {
   assert(!isSealed);
   importedSymbols.emplace_back(sym);
   if (auto *f = dyn_cast<FunctionSymbol>(sym))
     f->setFunctionIndex(numImportedFunctions++);
   else if (auto *g = dyn_cast<GlobalSymbol>(sym))
     g->setGlobalIndex(numImportedGlobals++);
-  else if (auto *e = dyn_cast<EventSymbol>(sym))
-    e->setEventIndex(numImportedEvents++);
+  else if (auto *t = dyn_cast<TagSymbol>(sym))
+    t->setTagIndex(numImportedTags++);
   else
     cast<TableSymbol>(sym)->setTableNumber(numImportedTables++);
 }
 
 void ImportSection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   writeUleb128(os, getNumImports(), "import count");
for (const Symbol *sym : importedSymbols) {
     }
 
     if (auto *functionSym = dyn_cast<FunctionSymbol>(sym)) {
       import.Kind = WASM_EXTERNAL_FUNCTION;
       import.SigIndex = out.typeSec->lookupType(*functionSym->signature);
     } else if (auto *globalSym = dyn_cast<GlobalSymbol>(sym)) {
       import.Kind = WASM_EXTERNAL_GLOBAL;
       import.Global = *globalSym->getGlobalType();
-    } else if (auto *eventSym = dyn_cast<EventSymbol>(sym)) {
-      import.Kind = WASM_EXTERNAL_EVENT;
-      import.Event.Attribute = eventSym->getEventType()->Attribute;
-      import.Event.SigIndex = out.typeSec->lookupType(*eventSym->signature);
+    } else if (auto *tagSym = dyn_cast<TagSymbol>(sym)) {
+      import.Kind = WASM_EXTERNAL_TAG;
+      import.Tag.Attribute = tagSym->getTagType()->Attribute;
+      import.Tag.SigIndex = out.typeSec->lookupType(*tagSym->signature);
     } else {
       auto *tableSym = cast<TableSymbol>(sym);
       import.Kind = WASM_EXTERNAL_TABLE;
       import.Table = *tableSym->getTableType();
     }
     writeImport(os, import);
   }
 
void MemorySection::writeBody() {
   if (config->is64.getValueOr(false))
     flags |= WASM_LIMITS_FLAG_IS_64;
   writeUleb128(os, flags, "memory limits flags");
   writeUleb128(os, numMemoryPages, "initial pages");
   if (hasMax)
     writeUleb128(os, maxMemoryPages, "max pages");
 }
 
-void EventSection::writeBody() {
+void TagSection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
-  writeUleb128(os, inputEvents.size(), "event count");
-  for (InputEvent *e : inputEvents) {
-    WasmEventType type = e->getType();
-    type.SigIndex = out.typeSec->lookupType(e->signature);
-    writeEventType(os, type);
+  writeUleb128(os, inputTags.size(), "tag count");
+  for (InputTag *t : inputTags) {
+    WasmTagType type = t->getType();
+    type.SigIndex = out.typeSec->lookupType(t->signature);
+    writeTagType(os, type);
   }
 }
 
-void EventSection::addEvent(InputEvent *event) {
-  if (!event->live)
+void TagSection::addTag(InputTag *tag) {
+  if (!tag->live)
     return;
-  uint32_t eventIndex =
-      out.importSec->getNumImportedEvents() + inputEvents.size();
-  LLVM_DEBUG(dbgs() << "addEvent: " << eventIndex << "\n");
-  event->assignIndex(eventIndex);
-  inputEvents.push_back(event);
+  uint32_t tagIndex = out.importSec->getNumImportedTags() + inputTags.size();
+  LLVM_DEBUG(dbgs() << "addTag: " << tagIndex << "\n");
+  tag->assignIndex(tagIndex);
+  inputTags.push_back(tag);
 }
 
 void GlobalSection::assignIndexes() {
   uint32_t globalIndex = out.importSec->getNumImportedGlobals();
   for (InputGlobal *g : inputGlobals)
     g->assignIndex(globalIndex++);
   for (Symbol *sym : internalGotSymbols)
     sym->setGOTIndex(globalIndex++);
for (const Symbol *sym : symtabEntries) {
       if (auto *f = dyn_cast<FunctionSymbol>(sym)) {
         writeUleb128(sub.os, f->getFunctionIndex(), "index");
         if (sym->isDefined() || (flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeStr(sub.os, sym->getName(), "sym name");
       } else if (auto *g = dyn_cast<GlobalSymbol>(sym)) {
         writeUleb128(sub.os, g->getGlobalIndex(), "index");
         if (sym->isDefined() || (flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeStr(sub.os, sym->getName(), "sym name");
-      } else if (auto *e = dyn_cast<EventSymbol>(sym)) {
-        writeUleb128(sub.os, e->getEventIndex(), "index");
+      } else if (auto *t = dyn_cast<TagSymbol>(sym)) {
+        writeUleb128(sub.os, t->getTagIndex(), "index");
         if (sym->isDefined() || (flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeStr(sub.os, sym->getName(), "sym name");
       } else if (auto *t = dyn_cast<TableSymbol>(sym)) {
         writeUleb128(sub.os, t->getTableNumber(), "table number");
         if (sym->isDefined() || (flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeStr(sub.os, sym->getName(), "sym name");
       } else if (isa<DataSymbol>(sym)) {
         writeStr(sub.os, sym->getName(), "sym name");

lld/wasm/Writer.cpp

 
 void Writer::addSections() {
   addSection(out.dylinkSec);
   addSection(out.typeSec);
   addSection(out.importSec);
   addSection(out.functionSec);
   addSection(out.tableSec);
   addSection(out.memorySec);
-  addSection(out.eventSec);
+  addSection(out.tagSec);
   addSection(out.globalSec);
   addSection(out.exportSec);
   addSection(out.startSec);
   addSection(out.elemSec);
   addSection(out.dataCountSec);
 
   addSection(make<CodeSection>(out.functionSec->inputFunctions));
   addSection(make<DataSection>(segments));
if (auto *f = dyn_cast<DefinedFunction>(sym)) {
         // __stack_pointer or __tls_base) unless they are explicitly exported
         // from the command line.
         // Without this check `--export-all` would cause any program using the
         // stack pointer to export a mutable global even if none of the input
         // files were built with the `mutable-globals` feature.
         continue;
       }
       export_ = {name, WASM_EXTERNAL_GLOBAL, g->getGlobalIndex()};
-    } else if (auto *e = dyn_cast<DefinedEvent>(sym)) {
-      export_ = {name, WASM_EXTERNAL_EVENT, e->getEventIndex()};
+    } else if (auto *t = dyn_cast<DefinedTag>(sym)) {
+      export_ = {name, WASM_EXTERNAL_TAG, t->getTagIndex()};
     } else if (auto *d = dyn_cast<DefinedData>(sym)) {
       if (d->segment && d->segment->isTLS()) {
         // We can't currenly export TLS data symbols.
         if (sym->isExportedExplicit())
           error("TLS symbols cannot yet be exported: `" + toString(*sym) + "`");
         continue;
       }
       out.globalSec->dataAddressGlobals.push_back(d);
void Writer::populateSymtab() {
   }
 }
 
 void Writer::calculateTypes() {
   // The output type section is the union of the following sets:
   // 1. Any signature used in the TYPE relocation
   // 2. The signatures of all imported functions
   // 3. The signatures of all defined functions
-  // 4. The signatures of all imported events
-  // 5. The signatures of all defined events
+  // 4. The signatures of all imported tags
+  // 5. The signatures of all defined tags
 
   for (ObjFile *file : symtab->objectFiles) {
     ArrayRef<WasmSignature> types = file->getWasmObj()->types();
     for (uint32_t i = 0; i < types.size(); i++)
       if (file->typeIsUsed[i])
         file->typeMap[i] = out.typeSec->registerType(types[i]);
   }
 
   for (const Symbol *sym : out.importSec->importedSymbols) {
     if (auto *f = dyn_cast<FunctionSymbol>(sym))
       out.typeSec->registerType(*f->signature);
-    else if (auto *e = dyn_cast<EventSymbol>(sym))
-      out.typeSec->registerType(*e->signature);
+    else if (auto *t = dyn_cast<TagSymbol>(sym))
+      out.typeSec->registerType(*t->signature);
   }
 
   for (const InputFunction *f : out.functionSec->inputFunctions)
     out.typeSec->registerType(f->signature);
 
-  for (const InputEvent *e : out.eventSec->inputEvents)
-    out.typeSec->registerType(e->signature);
+  for (const InputTag *t : out.tagSec->inputTags)
+    out.typeSec->registerType(t->signature);
 }
 
 // In a command-style link, create a wrapper for each exported symbol
 // which calls the constructors and destructors.
 void Writer::createCommandExportWrappers() {
   // This logic doesn't currently support Emscripten-style PIC mode.
   assert(!config->isPic);
 
void Writer::assignIndexes() {
 
   for (ObjFile *file : symtab->objectFiles) {
     LLVM_DEBUG(dbgs() << "Globals: " << file->getName() << "\n");
     for (InputGlobal *global : file->globals)
       out.globalSec->addGlobal(global);
   }
 
   for (ObjFile *file : symtab->objectFiles) {
-    LLVM_DEBUG(dbgs() << "Events: " << file->getName() << "\n");
-    for (InputEvent *event : file->events)
-      out.eventSec->addEvent(event);
+    LLVM_DEBUG(dbgs() << "Tags: " << file->getName() << "\n");
+    for (InputTag *tag : file->tags)
+      out.tagSec->addTag(tag);
   }
 
   for (ObjFile *file : symtab->objectFiles) {
     LLVM_DEBUG(dbgs() << "Tables: " << file->getName() << "\n");
     for (InputTable *table : file->tables)
       out.tableSec->addTable(table);
   }
 

 
 void Writer::createSyntheticSections() {
   out.dylinkSec = make<DylinkSection>();
   out.typeSec = make<TypeSection>();
   out.importSec = make<ImportSection>();
   out.functionSec = make<FunctionSection>();
   out.tableSec = make<TableSection>();
   out.memorySec = make<MemorySection>();
-  out.eventSec = make<EventSection>();
+  out.tagSec = make<TagSection>();
   out.globalSec = make<GlobalSection>();
   out.exportSec = make<ExportSection>();
   out.startSec = make<StartSection>();
   out.elemSec = make<ElemSection>();
   out.producersSec = make<ProducersSection>();
   out.targetFeaturesSec = make<TargetFeaturesSection>();
 }
 
void Writer::run() {
   log("-- populateTargetFeatures");
   populateTargetFeatures();
   log("-- addSections");
   addSections();
 
   if (errorHandler().verbose) {
     log("Defined Functions: " + Twine(out.functionSec->inputFunctions.size()));
     log("Defined Globals  : " + Twine(out.globalSec->numGlobals()));
-    log("Defined Events   : " + Twine(out.eventSec->inputEvents.size()));
+    log("Defined Tags     : " + Twine(out.tagSec->inputTags.size()));
     log("Defined Tables   : " + Twine(out.tableSec->inputTables.size()));
     log("Function Imports : " +
         Twine(out.importSec->getNumImportedFunctions()));
     log("Global Imports   : " + Twine(out.importSec->getNumImportedGlobals()));
-    log("Event Imports    : " + Twine(out.importSec->getNumImportedEvents()));
+    log("Tag Imports      : " + Twine(out.importSec->getNumImportedTags()));
     log("Table Imports    : " + Twine(out.importSec->getNumImportedTables()));
     for (ObjFile *file : symtab->objectFiles)
       file->dumpInfo();
   }
 
   createHeader();
   log("-- finalizeSections");
   finalizeSections();

lld/wasm/WriterUtils.h

 void writeMemArg(raw_ostream &os, uint32_t alignment, uint64_t offset);
 
 void writeInitExpr(raw_ostream &os, const llvm::wasm::WasmInitExpr &initExpr);
 
 void writeLimits(raw_ostream &os, const llvm::wasm::WasmLimits &limits);
 
 void writeGlobalType(raw_ostream &os, const llvm::wasm::WasmGlobalType &type);
 
-void writeEventType(raw_ostream &os, const llvm::wasm::WasmEventType &type);
+void writeTagType(raw_ostream &os, const llvm::wasm::WasmTagType &type);
 
-void writeEvent(raw_ostream &os, const llvm::wasm::WasmEvent &event);
+void writeTag(raw_ostream &os, const llvm::wasm::WasmTag &tag);
 
 void writeTableType(raw_ostream &os, const llvm::wasm::WasmTableType &type);
 
 void writeImport(raw_ostream &os, const llvm::wasm::WasmImport &import);
 
 void writeExport(raw_ostream &os, const llvm::wasm::WasmExport &export_);
 
 } // namespace wasm
 
 std::string toString(llvm::wasm::ValType type);
 std::string toString(const llvm::wasm::WasmSignature &sig);
 std::string toString(const llvm::wasm::WasmGlobalType &type);
-std::string toString(const llvm::wasm::WasmEventType &type);
+std::string toString(const llvm::wasm::WasmTagType &type);
 std::string toString(const llvm::wasm::WasmTableType &type);
 
 } // namespace lld
 
 #endif // LLD_WASM_WRITERUTILS_H

lld/wasm/WriterUtils.cpp

std::string toString(const WasmSignature &sig) {
   return std::string(s.str());
 }
 
 std::string toString(const WasmGlobalType &type) {
   return (type.Mutable ? "var " : "const ") +
          toString(static_cast<ValType>(type.Type));
 }
 
-std::string toString(const WasmEventType &type) {
-  if (type.Attribute == WASM_EVENT_ATTRIBUTE_EXCEPTION)
+std::string toString(const WasmTagType &type) {
+  if (type.Attribute == WASM_TAG_ATTRIBUTE_EXCEPTION)
     return "exception";
   return "unknown";
 }
 
 static std::string toString(const llvm::wasm::WasmLimits &limits) {
   std::string ret;
   ret += "flags=0x" + std::to_string(limits.Flags);
   ret += "; min=" + std::to_string(limits.Minimum);

 }
 
 void writeGlobalType(raw_ostream &os, const WasmGlobalType &type) {
   // TODO: Update WasmGlobalType to use ValType and remove this cast.
   writeValueType(os, ValType(type.Type), "global type");
   writeU8(os, type.Mutable, "global mutable");
 }
 
-void writeEventType(raw_ostream &os, const WasmEventType &type) {
-  writeUleb128(os, type.Attribute, "event attribute");
+void writeTagType(raw_ostream &os, const WasmTagType &type) {
+  writeUleb128(os, type.Attribute, "tag attribute");
   writeUleb128(os, type.SigIndex, "sig index");
 }
 
-void writeEvent(raw_ostream &os, const WasmEvent &event) {
-  writeEventType(os, event.Type);
+void writeTag(raw_ostream &os, const WasmTag &tag) {
+  writeTagType(os, tag.Type);
 }
 
 void writeTableType(raw_ostream &os, const WasmTableType &type) {
   writeValueType(os, ValType(type.ElemType), "table type");
   writeLimits(os, type.Limits);
 }
 
 void writeImport(raw_ostream &os, const WasmImport &import) {
   writeStr(os, import.Module, "import module name");
   writeStr(os, import.Field, "import field name");
   writeU8(os, import.Kind, "import kind");
   switch (import.Kind) {
   case WASM_EXTERNAL_FUNCTION:
     writeUleb128(os, import.SigIndex, "import sig index");
     break;
   case WASM_EXTERNAL_GLOBAL:
     writeGlobalType(os, import.Global);
     break;
-  case WASM_EXTERNAL_EVENT:
-    writeEventType(os, import.Event);
+  case WASM_EXTERNAL_TAG:
+    writeTagType(os, import.Tag);
     break;
   case WASM_EXTERNAL_MEMORY:
     writeLimits(os, import.Memory);
     break;
   case WASM_EXTERNAL_TABLE:
     writeTableType(os, import.Table);
     break;
   default:
     fatal("unsupported import type: " + Twine(import.Kind));
   }
 }
 
 void writeExport(raw_ostream &os, const WasmExport &export_) {
   writeStr(os, export_.Name, "export name");
   writeU8(os, export_.Kind, "export kind");
   switch (export_.Kind) {
   case WASM_EXTERNAL_FUNCTION:
     writeUleb128(os, export_.Index, "function index");
     break;
   case WASM_EXTERNAL_GLOBAL:
     writeUleb128(os, export_.Index, "global index");
     break;
-  case WASM_EXTERNAL_EVENT:
-    writeUleb128(os, export_.Index, "event index");
+  case WASM_EXTERNAL_TAG:
+    writeUleb128(os, export_.Index, "tag index");
     break;
   case WASM_EXTERNAL_MEMORY:
     writeUleb128(os, export_.Index, "memory index");
     break;
   case WASM_EXTERNAL_TABLE:
     writeUleb128(os, export_.Index, "table index");
     break;
   default:
     fatal("unsupported export type: " + Twine(export_.Kind));
   }
 }
 
 } // namespace wasm
 } // namespace lld

lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.cpp

if (section_id == llvm::wasm::WASM_SEC_CUSTOM) {
 
     if (payload_len < c.tell() - prev_offset)
       return false;
 
     uint32_t section_length = payload_len - (c.tell() - prev_offset);
     m_sect_infos.push_back(section_info{*offset_ptr + c.tell(), section_length,
                                         section_id, *sect_name});
     *offset_ptr += (c.tell() + section_length);
-  } else if (section_id <= llvm::wasm::WASM_SEC_EVENT) {
+  } else if (section_id <= llvm::wasm::WASM_SEC_TAG) {
     m_sect_infos.push_back(section_info{*offset_ptr + c.tell(),
                                         static_cast<uint32_t>(payload_len),
                                         section_id, ConstString()});
     *offset_ptr += (c.tell() + payload_len);
   } else {
     // Invalid section id.
     return false;
   }

llvm/include/llvm/BinaryFormat/Wasm.h

 
 struct WasmGlobal {
   uint32_t Index;
   WasmGlobalType Type;
   WasmInitExpr InitExpr;
   StringRef SymbolName; // from the "linking" section
 };
 
-struct WasmEventType {
-  // Kind of event. Currently only WASM_EVENT_ATTRIBUTE_EXCEPTION is possible.
+struct WasmTagType {
+  // Kind of tag. Currently only WASM_TAG_ATTRIBUTE_EXCEPTION is possible.
   uint32_t Attribute;
   uint32_t SigIndex;
 };
 
-struct WasmEvent {
+struct WasmTag {
   uint32_t Index;
-  WasmEventType Type;
+  WasmTagType Type;
   StringRef SymbolName; // from the "linking" section
 };
 
 struct WasmImport {
   StringRef Module;
   StringRef Field;
   uint8_t Kind;
   union {
     uint32_t SigIndex;
     WasmGlobalType Global;
     WasmTableType Table;
     WasmLimits Memory;
-    WasmEventType Event;
+    WasmTagType Tag;
   };
 };
 
 struct WasmLocalDecl {
   uint8_t Type;
   uint32_t Count;
 };
 
enum : unsigned {
   WASM_SEC_MEMORY = 5,     // Memory attributes
   WASM_SEC_GLOBAL = 6,     // Global declarations
   WASM_SEC_EXPORT = 7,     // Exports
   WASM_SEC_START = 8,      // Start function declaration
   WASM_SEC_ELEM = 9,       // Elements section
   WASM_SEC_CODE = 10,      // Function bodies (code)
   WASM_SEC_DATA = 11,      // Data segments
   WASM_SEC_DATACOUNT = 12, // Data segment count
-  WASM_SEC_EVENT = 13      // Event declarations
+  WASM_SEC_TAG = 13        // Tag declarations
 };
 
 // Type immediate encodings used in various contexts.
 enum : unsigned {
   WASM_TYPE_I32 = 0x7F,
   WASM_TYPE_I64 = 0x7E,
   WASM_TYPE_F32 = 0x7D,
   WASM_TYPE_F64 = 0x7C,
   WASM_TYPE_V128 = 0x7B,
   WASM_TYPE_FUNCREF = 0x70,
   WASM_TYPE_EXTERNREF = 0x6F,
   WASM_TYPE_FUNC = 0x60,
   WASM_TYPE_NORESULT = 0x40, // for blocks with no result values
 };
 
 // Kinds of externals (for imports and exports).
 enum : unsigned {
   WASM_EXTERNAL_FUNCTION = 0x0,
   WASM_EXTERNAL_TABLE = 0x1,
   WASM_EXTERNAL_MEMORY = 0x2,
   WASM_EXTERNAL_GLOBAL = 0x3,
-  WASM_EXTERNAL_EVENT = 0x4,
+  WASM_EXTERNAL_TAG = 0x4,
 };
 
 // Opcodes used in initializer expressions.
 enum : unsigned {
   WASM_OPCODE_END = 0x0b,
   WASM_OPCODE_CALL = 0x10,
   WASM_OPCODE_LOCAL_GET = 0x20,
   WASM_OPCODE_LOCAL_SET = 0x21,
enum : unsigned {
   WASM_COMDAT_INFO = 0x7,
   WASM_SYMBOL_TABLE = 0x8,
 };
 
 // Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
 enum : unsigned {
   WASM_COMDAT_DATA = 0x0,
   WASM_COMDAT_FUNCTION = 0x1,
-  // GLOBAL, EVENT, and TABLE are in here but LLVM doesn't use them yet.
+  // GLOBAL, TAG, and TABLE are in here but LLVM doesn't use them yet.
   WASM_COMDAT_SECTION = 0x5,
 };
 
 // Kind codes used in the custom "linking" section in the WASM_SYMBOL_TABLE
 enum WasmSymbolType : unsigned {
   WASM_SYMBOL_TYPE_FUNCTION = 0x0,
   WASM_SYMBOL_TYPE_DATA = 0x1,
   WASM_SYMBOL_TYPE_GLOBAL = 0x2,
   WASM_SYMBOL_TYPE_SECTION = 0x3,
-  WASM_SYMBOL_TYPE_EVENT = 0x4,
+  WASM_SYMBOL_TYPE_TAG = 0x4,
   WASM_SYMBOL_TYPE_TABLE = 0x5,
 };
 
 enum WasmSegmentFlag : unsigned {
   WASM_SEG_FLAG_STRINGS = 0x1,
   WASM_SEG_FLAG_TLS = 0x2,
 };
 
-// Kinds of event attributes.
-enum WasmEventAttribute : unsigned {
-  WASM_EVENT_ATTRIBUTE_EXCEPTION = 0x0,
+// Kinds of tag attributes.
+enum WasmTagAttribute : unsigned {
+  WASM_TAG_ATTRIBUTE_EXCEPTION = 0x0,
 };
 
 const unsigned WASM_SYMBOL_BINDING_MASK = 0x3;
 const unsigned WASM_SYMBOL_VISIBILITY_MASK = 0xc;
 
 const unsigned WASM_SYMBOL_BINDING_GLOBAL = 0x0;
 const unsigned WASM_SYMBOL_BINDING_WEAK = 0x1;
 const unsigned WASM_SYMBOL_BINDING_LOCAL = 0x2;

llvm/include/llvm/BinaryFormat/WasmRelocs.def

 #ifndef WASM_RELOC
 #error "WASM_RELOC must be defined"
 #endif
 
 WASM_RELOC(R_WASM_FUNCTION_INDEX_LEB,      0)
 WASM_RELOC(R_WASM_TABLE_INDEX_SLEB,        1)
 WASM_RELOC(R_WASM_TABLE_INDEX_I32,         2)
 WASM_RELOC(R_WASM_MEMORY_ADDR_LEB,         3)
 WASM_RELOC(R_WASM_MEMORY_ADDR_SLEB,        4)
 WASM_RELOC(R_WASM_MEMORY_ADDR_I32,         5)
 WASM_RELOC(R_WASM_TYPE_INDEX_LEB,          6)
 WASM_RELOC(R_WASM_GLOBAL_INDEX_LEB,        7)
 WASM_RELOC(R_WASM_FUNCTION_OFFSET_I32,     8)
 WASM_RELOC(R_WASM_SECTION_OFFSET_I32,      9)
-WASM_RELOC(R_WASM_EVENT_INDEX_LEB,        10)
+WASM_RELOC(R_WASM_TAG_INDEX_LEB,          10)
 WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB,   11)
 WASM_RELOC(R_WASM_TABLE_INDEX_REL_SLEB,   12)
 WASM_RELOC(R_WASM_GLOBAL_INDEX_I32,       13)
 WASM_RELOC(R_WASM_MEMORY_ADDR_LEB64,      14)
 WASM_RELOC(R_WASM_MEMORY_ADDR_SLEB64,     15)
 WASM_RELOC(R_WASM_MEMORY_ADDR_I64,        16)
 WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB64, 17)
 WASM_RELOC(R_WASM_TABLE_INDEX_SLEB64,     18)
 WASM_RELOC(R_WASM_TABLE_INDEX_I64,        19)
 WASM_RELOC(R_WASM_TABLE_NUMBER_LEB,       20)
 WASM_RELOC(R_WASM_MEMORY_ADDR_TLS_SLEB,   21)
 WASM_RELOC(R_WASM_FUNCTION_OFFSET_I64,    22)
 WASM_RELOC(R_WASM_MEMORY_ADDR_LOCREL_I32, 23)
 WASM_RELOC(R_WASM_TABLE_INDEX_REL_SLEB64, 24)

llvm/include/llvm/CodeGen/WasmEHFuncInfo.h

 
 namespace llvm {
 
 class BasicBlock;
 class Function;
 class MachineBasicBlock;
 
 namespace WebAssembly {
-enum EventTag { CPP_EXCEPTION = 0, C_LONGJMP = 1 };
+enum Tag { CPP_EXCEPTION = 0, C_LONGJMP = 1 };
 }
 
 using BBOrMBB = PointerUnion<const BasicBlock *, MachineBasicBlock *>;
 
 struct WasmEHFuncInfo {
   // When there is an entry <A, B>, if an exception is not caught by A, it
   // should next unwind to the EH pad B.
   DenseMap<BBOrMBB, BBOrMBB> SrcToUnwindDest;

llvm/include/llvm/MC/MCSymbolWasm.h

class MCSymbolWasm : public MCSymbol {
   mutable bool IsUsedInInitArray = false;
   mutable bool IsUsedInGOT = false;
   Optional<StringRef> ImportModule;
   Optional<StringRef> ImportName;
   Optional<StringRef> ExportName;
   wasm::WasmSignature *Signature = nullptr;
   Optional<wasm::WasmGlobalType> GlobalType;
   Optional<wasm::WasmTableType> TableType;
-  Optional<wasm::WasmEventType> EventType;
+  Optional<wasm::WasmTagType> TagType;
 
   /// An expression describing how to calculate the size of a symbol. If a
   /// symbol has no size this field will be NULL.
   const MCExpr *SymbolSize = nullptr;
 
 public:
   MCSymbolWasm(const StringMapEntry<bool> *Name, bool isTemporary)
       : MCSymbol(SymbolKindWasm, Name, isTemporary) {}
   static bool classof(const MCSymbol *S) { return S->isWasm(); }
 
   const MCExpr *getSize() const { return SymbolSize; }
   void setSize(const MCExpr *SS) { SymbolSize = SS; }
 
   bool isFunction() const { return Type == wasm::WASM_SYMBOL_TYPE_FUNCTION; }
   // Data is the default value if not set.
   bool isData() const { return !Type || Type == wasm::WASM_SYMBOL_TYPE_DATA; }
   bool isGlobal() const { return Type == wasm::WASM_SYMBOL_TYPE_GLOBAL; }
   bool isTable() const { return Type == wasm::WASM_SYMBOL_TYPE_TABLE; }
   bool isSection() const { return Type == wasm::WASM_SYMBOL_TYPE_SECTION; }
-  bool isEvent() const { return Type == wasm::WASM_SYMBOL_TYPE_EVENT; }
+  bool isTag() const { return Type == wasm::WASM_SYMBOL_TYPE_TAG; }
 
   Optional<wasm::WasmSymbolType> getType() const { return Type; }
 
   void setType(wasm::WasmSymbolType type) { Type = type; }
 
   bool isExported() const {
     return getFlags() & wasm::WASM_SYMBOL_EXPORTED;
   }
public:
   void setTableType(wasm::WasmTableType TT) { TableType = TT; }
   void setTableType(wasm::ValType VT) {
     // Declare a table with element type VT and no limits (min size 0, no max
     // size).
     wasm::WasmLimits Limits = {wasm::WASM_LIMITS_FLAG_NONE, 0, 0};
     setTableType({uint8_t(VT), Limits});
   }
 
-  const wasm::WasmEventType &getEventType() const {
-    assert(EventType.hasValue());
-    return EventType.getValue();
+  const wasm::WasmTagType &getTagType() const {
+    assert(TagType.hasValue());
+    return TagType.getValue();
   }
-  void setEventType(wasm::WasmEventType ET) { EventType = ET; }
+  void setTagType(wasm::WasmTagType ET) { TagType = ET; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSYMBOLWASM_H

llvm/include/llvm/Object/Wasm.h

 namespace llvm {
 namespace object {
 
 class WasmSymbol {
 public:
   WasmSymbol(const wasm::WasmSymbolInfo &Info,
              const wasm::WasmGlobalType *GlobalType,
              const wasm::WasmTableType *TableType,
-             const wasm::WasmEventType *EventType,
+             const wasm::WasmTagType *TagType,
              const wasm::WasmSignature *Signature)
       : Info(Info), GlobalType(GlobalType), TableType(TableType),
-        EventType(EventType), Signature(Signature) {}
+        TagType(TagType), Signature(Signature) {}
 
   const wasm::WasmSymbolInfo &Info;
   const wasm::WasmGlobalType *GlobalType;
   const wasm::WasmTableType *TableType;
-  const wasm::WasmEventType *EventType;
+  const wasm::WasmTagType *TagType;
   const wasm::WasmSignature *Signature;
 
   bool isTypeFunction() const {
     return Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION;
   }
 
   bool isTypeTable() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_TABLE; }
 
   bool isTypeData() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA; }
 
   bool isTypeGlobal() const {
     return Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL;
   }
 
   bool isTypeSection() const {
     return Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION;
   }
 
-  bool isTypeEvent() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_EVENT; }
+  bool isTypeTag() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_TAG; }
 
   bool isDefined() const { return !isUndefined(); }
 
   bool isUndefined() const {
     return (Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) != 0;
   }
 
   bool isBindingWeak() const {
ArrayRef<wasm::WasmFeatureEntry> getTargetFeatures() const {
     return TargetFeatures;
   }
   ArrayRef<wasm::WasmSignature> types() const { return Signatures; }
   ArrayRef<uint32_t> functionTypes() const { return FunctionTypes; }
   ArrayRef<wasm::WasmImport> imports() const { return Imports; }
   ArrayRef<wasm::WasmTable> tables() const { return Tables; }
   ArrayRef<wasm::WasmLimits> memories() const { return Memories; }
   ArrayRef<wasm::WasmGlobal> globals() const { return Globals; }
-  ArrayRef<wasm::WasmEvent> events() const { return Events; }
+  ArrayRef<wasm::WasmTag> tags() const { return Tags; }
   ArrayRef<wasm::WasmExport> exports() const { return Exports; }
   ArrayRef<WasmSymbol> syms() const { return Symbols; }
   const wasm::WasmLinkingData &linkingData() const { return LinkingData; }
   uint32_t getNumberOfSymbols() const { return Symbols.size(); }
   ArrayRef<wasm::WasmElemSegment> elements() const { return ElemSegments; }
   ArrayRef<WasmSegment> dataSegments() const { return DataSegments; }
   ArrayRef<wasm::WasmFunction> functions() const { return Functions; }
   ArrayRef<wasm::WasmDebugName> debugNames() const { return DebugNames; }
   uint32_t startFunction() const { return StartFunction; }
   uint32_t getNumImportedGlobals() const { return NumImportedGlobals; }
   uint32_t getNumImportedTables() const { return NumImportedTables; }
   uint32_t getNumImportedFunctions() const { return NumImportedFunctions; }
-  uint32_t getNumImportedEvents() const { return NumImportedEvents; }
+  uint32_t getNumImportedTags() const { return NumImportedTags; }
   uint32_t getNumSections() const { return Sections.size(); }
   void moveSymbolNext(DataRefImpl &Symb) const override;
 
   Expected<uint32_t> getSymbolFlags(DataRefImpl Symb) const override;
 
   basic_symbol_iterator symbol_begin() const override;
 
   basic_symbol_iterator symbol_end() const override;

 
 private:
   bool isValidFunctionIndex(uint32_t Index) const;
   bool isDefinedFunctionIndex(uint32_t Index) const;
   bool isValidGlobalIndex(uint32_t Index) const;
   bool isValidTableNumber(uint32_t Index) const;
   bool isDefinedGlobalIndex(uint32_t Index) const;
   bool isDefinedTableNumber(uint32_t Index) const;
-  bool isValidEventIndex(uint32_t Index) const;
-  bool isDefinedEventIndex(uint32_t Index) const;
+  bool isValidTagIndex(uint32_t Index) const;
+  bool isDefinedTagIndex(uint32_t Index) const;
   bool isValidFunctionSymbol(uint32_t Index) const;
   bool isValidTableSymbol(uint32_t Index) const;
   bool isValidGlobalSymbol(uint32_t Index) const;
-  bool isValidEventSymbol(uint32_t Index) const;
+  bool isValidTagSymbol(uint32_t Index) const;
   bool isValidDataSymbol(uint32_t Index) const;
   bool isValidSectionSymbol(uint32_t Index) const;
   wasm::WasmFunction &getDefinedFunction(uint32_t Index);
   const wasm::WasmFunction &getDefinedFunction(uint32_t Index) const;
   wasm::WasmGlobal &getDefinedGlobal(uint32_t Index);
-  wasm::WasmEvent &getDefinedEvent(uint32_t Index);
+  wasm::WasmTag &getDefinedTag(uint32_t Index);
 
   const WasmSection &getWasmSection(DataRefImpl Ref) const;
   const wasm::WasmRelocation &getWasmRelocation(DataRefImpl Ref) const;
   uint32_t getSymbolSectionIdImpl(const WasmSymbol &Symb) const;
 
   Error parseSection(WasmSection &Sec);
   Error parseCustomSection(WasmSection &Sec, ReadContext &Ctx);
 
   // Standard section types
   Error parseTypeSection(ReadContext &Ctx);
   Error parseImportSection(ReadContext &Ctx);
   Error parseFunctionSection(ReadContext &Ctx);
   Error parseTableSection(ReadContext &Ctx);
   Error parseMemorySection(ReadContext &Ctx);
-  Error parseEventSection(ReadContext &Ctx);
+  Error parseTagSection(ReadContext &Ctx);
   Error parseGlobalSection(ReadContext &Ctx);
   Error parseExportSection(ReadContext &Ctx);
   Error parseStartSection(ReadContext &Ctx);
   Error parseElemSection(ReadContext &Ctx);
   Error parseCodeSection(ReadContext &Ctx);
   Error parseDataSection(ReadContext &Ctx);
   Error parseDataCountSection(ReadContext &Ctx);
 
private:
   wasm::WasmDylinkInfo DylinkInfo;
   wasm::WasmProducerInfo ProducerInfo;
   std::vector<wasm::WasmFeatureEntry> TargetFeatures;
   std::vector<wasm::WasmSignature> Signatures;
   std::vector<uint32_t> FunctionTypes;
   std::vector<wasm::WasmTable> Tables;
   std::vector<wasm::WasmLimits> Memories;
   std::vector<wasm::WasmGlobal> Globals;
-  std::vector<wasm::WasmEvent> Events;
+  std::vector<wasm::WasmTag> Tags;
   std::vector<wasm::WasmImport> Imports;
   std::vector<wasm::WasmExport> Exports;
   std::vector<wasm::WasmElemSegment> ElemSegments;
   std::vector<WasmSegment> DataSegments;
   llvm::Optional<size_t> DataCount;
   std::vector<wasm::WasmFunction> Functions;
   std::vector<WasmSymbol> Symbols;
   std::vector<wasm::WasmDebugName> DebugNames;
   uint32_t StartFunction = -1;
   bool HasLinkingSection = false;
   bool HasDylinkSection = false;
   bool SeenCodeSection = false;
   bool HasMemory64 = false;
   wasm::WasmLinkingData LinkingData;
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedTables = 0;
   uint32_t NumImportedFunctions = 0;
-  uint32_t NumImportedEvents = 0;
+  uint32_t NumImportedTags = 0;
   uint32_t CodeSection = 0;
   uint32_t DataSection = 0;
-  uint32_t EventSection = 0;
+  uint32_t TagSection = 0;
   uint32_t GlobalSection = 0;
   uint32_t TableSection = 0;
 };
 
 class WasmSectionOrderChecker {
 public:
   // We define orders for all core wasm sections and known custom sections.
   enum : int {
     // Sentinel, must be zero
     WASM_SEC_ORDER_NONE = 0,
 
     // Core sections
     WASM_SEC_ORDER_TYPE,
     WASM_SEC_ORDER_IMPORT,
     WASM_SEC_ORDER_FUNCTION,
     WASM_SEC_ORDER_TABLE,
     WASM_SEC_ORDER_MEMORY,
-    WASM_SEC_ORDER_EVENT,
+    WASM_SEC_ORDER_TAG,
     WASM_SEC_ORDER_GLOBAL,
     WASM_SEC_ORDER_EXPORT,
     WASM_SEC_ORDER_START,
     WASM_SEC_ORDER_ELEM,
     WASM_SEC_ORDER_DATACOUNT,
     WASM_SEC_ORDER_CODE,
     WASM_SEC_ORDER_DATA,
 

llvm/include/llvm/ObjectYAML/WasmYAML.h

 
 struct Global {
   uint32_t Index;
   ValueType Type;
   bool Mutable;
   wasm::WasmInitExpr InitExpr;
 };
 
-struct Event {
+struct Tag {
   uint32_t Index;
   uint32_t Attribute;
   uint32_t SigIndex;
 };
 
 struct Import {
   StringRef Module;
   StringRef Field;
   ExportKind Kind;
   union {
     uint32_t SigIndex;
     Global GlobalImport;
     Table TableImport;
     Limits Memory;
-    Event EventImport;
+    Tag TagImport;
   };
 };
 
 struct LocalDecl {
   ValueType Type;
   uint32_t Count;
 };
 
struct MemorySection : Section {
 
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_MEMORY;
   }
 
   std::vector<Limits> Memories;
 };
 
-struct EventSection : Section {
-  EventSection() : Section(wasm::WASM_SEC_EVENT) {}
+struct TagSection : Section {
+  TagSection() : Section(wasm::WASM_SEC_TAG) {}
 
   static bool classof(const Section *S) {
-    return S->Type == wasm::WASM_SEC_EVENT;
+    return S->Type == wasm::WASM_SEC_TAG;
   }
 
-  std::vector<Event> Events;
+  std::vector<Tag> Tags;
 };
 
 struct GlobalSection : Section {
   GlobalSection() : Section(wasm::WASM_SEC_GLOBAL) {}
 
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_GLOBAL;
   }

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ProducerEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::FeatureEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SegmentInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::InitFunction)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ComdatEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Comdat)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Event)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Tag)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct MappingTraits<WasmYAML::FileHeader> {
   static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
 };
 

 template <> struct ScalarEnumerationTraits<WasmYAML::Opcode> {
   static void enumeration(IO &IO, WasmYAML::Opcode &Opcode);
 };
 
 template <> struct ScalarEnumerationTraits<WasmYAML::RelocType> {
   static void enumeration(IO &IO, WasmYAML::RelocType &Kind);
 };
 
-template <> struct MappingTraits<WasmYAML::Event> {
-  static void mapping(IO &IO, WasmYAML::Event &Event);
+template <> struct MappingTraits<WasmYAML::Tag> {
+  static void mapping(IO &IO, WasmYAML::Tag &Tag);
 };
 
 } // end namespace yaml
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_WASMYAML_H

llvm/lib/BinaryFormat/Wasm.cpp

std::string llvm::wasm::toString(wasm::WasmSymbolType Type) {
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
     return "WASM_SYMBOL_TYPE_GLOBAL";
   case wasm::WASM_SYMBOL_TYPE_TABLE:
     return "WASM_SYMBOL_TYPE_TABLE";
   case wasm::WASM_SYMBOL_TYPE_DATA:
     return "WASM_SYMBOL_TYPE_DATA";
   case wasm::WASM_SYMBOL_TYPE_SECTION:
     return "WASM_SYMBOL_TYPE_SECTION";
-  case wasm::WASM_SYMBOL_TYPE_EVENT:
-    return "WASM_SYMBOL_TYPE_EVENT";
+  case wasm::WASM_SYMBOL_TYPE_TAG:
+    return "WASM_SYMBOL_TYPE_TAG";
   }
   llvm_unreachable("unknown symbol type");
 }
 
 std::string llvm::wasm::relocTypetoString(uint32_t Type) {
   switch (Type) {
 #define WASM_RELOC(NAME, VALUE)                                                \
   case VALUE:                                                                  \

llvm/lib/MC/WasmObjectWriter.cpp

class WasmObjectWriter : public MCObjectWriter {
 
   // Index values to use for fixing up call_indirect type indices.
   // Maps function symbols to the index of the type of the function
   DenseMap<const MCSymbolWasm *, uint32_t> TypeIndices;
   // Maps function symbols to the table element index space. Used
   // for TABLE_INDEX relocation types (i.e. address taken functions).
   DenseMap<const MCSymbolWasm *, uint32_t> TableIndices;
   // Maps function/global/table symbols to the
-  // function/global/table/event/section index space.
+  // function/global/table/tag/section index space.
   DenseMap<const MCSymbolWasm *, uint32_t> WasmIndices;
   DenseMap<const MCSymbolWasm *, uint32_t> GOTIndices;
   // Maps data symbols to the Wasm segment and offset/size with the segment.
   DenseMap<const MCSymbolWasm *, wasm::WasmDataReference> DataLocations;
 
   // Stores output data (index, relocations, content offset) for custom
   // section.
   std::vector<WasmCustomSection> CustomSections;
   std::unique_ptr<WasmCustomSection> ProducersSection;
   std::unique_ptr<WasmCustomSection> TargetFeaturesSection;
   // Relocations for fixing up references in the custom sections.
   DenseMap<const MCSectionWasm *, std::vector<WasmRelocationEntry>>
       CustomSectionsRelocations;
 
   // Map from section to defining function symbol.
   DenseMap<const MCSection *, const MCSymbol *> SectionFunctions;
 
   DenseMap<wasm::WasmSignature, uint32_t> SignatureIndices;
   SmallVector<wasm::WasmSignature, 4> Signatures;
   SmallVector<WasmDataSegment, 4> DataSegments;
   unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
   unsigned NumTableImports = 0;
-  unsigned NumEventImports = 0;
+  unsigned NumTagImports = 0;
   uint32_t SectionCount = 0;
 
   enum class DwoMode {
     AllSections,
     NonDwoOnly,
     DwoOnly,
   };
   bool IsSplitDwarf = false;
private:
   void writeFunctionSection(ArrayRef<WasmFunction> Functions);
   void writeExportSection(ArrayRef<wasm::WasmExport> Exports);
   void writeElemSection(const MCSymbolWasm *IndirectFunctionTable,
                         ArrayRef<uint32_t> TableElems);
   void writeDataCountSection();
   uint32_t writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                             ArrayRef<WasmFunction> Functions);
   uint32_t writeDataSection(const MCAsmLayout &Layout);
-  void writeEventSection(ArrayRef<wasm::WasmEventType> Events);
+  void writeTagSection(ArrayRef<wasm::WasmTagType> Tags);
   void writeGlobalSection(ArrayRef<wasm::WasmGlobal> Globals);
   void writeTableSection(ArrayRef<wasm::WasmTable> Tables);
   void writeRelocSection(uint32_t SectionIndex, StringRef Name,
                          std::vector<WasmRelocationEntry> &Relocations);
   void writeLinkingMetaDataSection(
       ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
       ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
       const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats);
   void writeCustomSection(WasmCustomSection &CustomSection,
                           const MCAssembler &Asm, const MCAsmLayout &Layout);
   void writeCustomRelocSections();
 
   uint64_t getProvisionalValue(const WasmRelocationEntry &RelEntry,
                                const MCAsmLayout &Layout);
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset, const MCAsmLayout &Layout);
 
   uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);
   uint32_t getFunctionType(const MCSymbolWasm &Symbol);
-  uint32_t getEventType(const MCSymbolWasm &Symbol);
+  uint32_t getTagType(const MCSymbolWasm &Symbol);
   void registerFunctionType(const MCSymbolWasm &Symbol);
-  void registerEventType(const MCSymbolWasm &Symbol);
+  void registerTagType(const MCSymbolWasm &Symbol);
 };
 
 } // end anonymous namespace
 
 // Write out a section header and a patchable section size field.
 void WasmObjectWriter::startSection(SectionBookkeeping &Section,
                                     unsigned SectionId) {
   LLVM_DEBUG(dbgs() << "startSection " << SectionId << "\n");
else
       return TableIndices[Base];
   }
   case wasm::R_WASM_TYPE_INDEX_LEB:
     // Provisional value is same as the index
     return getRelocationIndexValue(RelEntry);
   case wasm::R_WASM_FUNCTION_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_I32:
-  case wasm::R_WASM_EVENT_INDEX_LEB:
+  case wasm::R_WASM_TAG_INDEX_LEB:
   case wasm::R_WASM_TABLE_NUMBER_LEB:
-    // Provisional value is function/global/event Wasm index
+    // Provisional value is function/global/tag Wasm index
     assert(WasmIndices.count(RelEntry.Symbol) > 0 && "symbol not found in wasm index space");
     return WasmIndices[RelEntry.Symbol];
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_FUNCTION_OFFSET_I64:
   case wasm::R_WASM_SECTION_OFFSET_I32: {
     const auto &Section =
         static_cast<const MCSectionWasm &>(RelEntry.Symbol->getSection());
     return Section.getSectionOffset() + RelEntry.Addend;
for (const WasmRelocationEntry &RelEntry : Relocations) {
     LLVM_DEBUG(dbgs() << "applyRelocation: " << RelEntry << "\n");
     auto Value = getProvisionalValue(RelEntry, Layout);
 
     switch (RelEntry.Type) {
     case wasm::R_WASM_FUNCTION_INDEX_LEB:
     case wasm::R_WASM_TYPE_INDEX_LEB:
     case wasm::R_WASM_GLOBAL_INDEX_LEB:
     case wasm::R_WASM_MEMORY_ADDR_LEB:
-    case wasm::R_WASM_EVENT_INDEX_LEB:
+    case wasm::R_WASM_TAG_INDEX_LEB:
     case wasm::R_WASM_TABLE_NUMBER_LEB:
       writePatchableLEB<5>(Stream, Value, Offset);
       break;
     case wasm::R_WASM_MEMORY_ADDR_LEB64:
       writePatchableLEB<10>(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_I32:
     case wasm::R_WASM_MEMORY_ADDR_I32:
case wasm::WASM_EXTERNAL_MEMORY:
       encodeULEB128(Import.Memory.Flags, W->OS);
       encodeULEB128(NumPages, W->OS); // initial
       break;
     case wasm::WASM_EXTERNAL_TABLE:
       W->OS << char(Import.Table.ElemType);
       encodeULEB128(0, W->OS);           // flags
       encodeULEB128(NumElements, W->OS); // initial
       break;
-    case wasm::WASM_EXTERNAL_EVENT:
-      encodeULEB128(Import.Event.Attribute, W->OS);
-      encodeULEB128(Import.Event.SigIndex, W->OS);
+    case wasm::WASM_EXTERNAL_TAG:
+      encodeULEB128(Import.Tag.Attribute, W->OS);
+      encodeULEB128(Import.Tag.SigIndex, W->OS);
       break;
     default:
       llvm_unreachable("unsupported import kind");
     }
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeFunctionSection(ArrayRef<WasmFunction> Functions) {
   if (Functions.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_FUNCTION);
 
   encodeULEB128(Functions.size(), W->OS);
   for (const WasmFunction &Func : Functions)
     encodeULEB128(Func.SigIndex, W->OS);
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeEventSection(ArrayRef<wasm::WasmEventType> Events) {
-  if (Events.empty())
+void WasmObjectWriter::writeTagSection(ArrayRef<wasm::WasmTagType> Tags) {
+  if (Tags.empty())
     return;
 
   SectionBookkeeping Section;
-  startSection(Section, wasm::WASM_SEC_EVENT);
+  startSection(Section, wasm::WASM_SEC_TAG);
 
-  encodeULEB128(Events.size(), W->OS);
-  for (const wasm::WasmEventType &Event : Events) {
-    encodeULEB128(Event.Attribute, W->OS);
-    encodeULEB128(Event.SigIndex, W->OS);
+  encodeULEB128(Tags.size(), W->OS);
+  for (const wasm::WasmTagType &Tag : Tags) {
+    encodeULEB128(Tag.Attribute, W->OS);
+    encodeULEB128(Tag.SigIndex, W->OS);
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeGlobalSection(ArrayRef<wasm::WasmGlobal> Globals) {
   if (Globals.empty())
     return;
if (SymbolInfos.size() != 0) {
     startSection(SubSection, wasm::WASM_SYMBOL_TABLE);
     encodeULEB128(SymbolInfos.size(), W->OS);
     for (const wasm::WasmSymbolInfo &Sym : SymbolInfos) {
       encodeULEB128(Sym.Kind, W->OS);
       encodeULEB128(Sym.Flags, W->OS);
       switch (Sym.Kind) {
       case wasm::WASM_SYMBOL_TYPE_FUNCTION:
       case wasm::WASM_SYMBOL_TYPE_GLOBAL:
-      case wasm::WASM_SYMBOL_TYPE_EVENT:
+      case wasm::WASM_SYMBOL_TYPE_TAG:
       case wasm::WASM_SYMBOL_TYPE_TABLE:
         encodeULEB128(Sym.ElementIndex, W->OS);
         if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0 ||
             (Sym.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeString(Sym.Name);
         break;
       case wasm::WASM_SYMBOL_TYPE_DATA:
         writeString(Sym.Name);

 }
 
 uint32_t WasmObjectWriter::getFunctionType(const MCSymbolWasm &Symbol) {
   assert(Symbol.isFunction());
   assert(TypeIndices.count(&Symbol));
   return TypeIndices[&Symbol];
 }
 
-uint32_t WasmObjectWriter::getEventType(const MCSymbolWasm &Symbol) {
-  assert(Symbol.isEvent());
+uint32_t WasmObjectWriter::getTagType(const MCSymbolWasm &Symbol) {
+  assert(Symbol.isTag());
   assert(TypeIndices.count(&Symbol));
   return TypeIndices[&Symbol];
 }
 
 void WasmObjectWriter::registerFunctionType(const MCSymbolWasm &Symbol) {
   assert(Symbol.isFunction());
 
   wasm::WasmSignature S;
 
   if (auto *Sig = Symbol.getSignature()) {
     S.Returns = Sig->Returns;
     S.Params = Sig->Params;
   }
 
   auto Pair = SignatureIndices.insert(std::make_pair(S, Signatures.size()));
   if (Pair.second)
     Signatures.push_back(S);
   TypeIndices[&Symbol] = Pair.first->second;
 
   LLVM_DEBUG(dbgs() << "registerFunctionType: " << Symbol
                     << " new:" << Pair.second << "\n");
   LLVM_DEBUG(dbgs() << "  -> type index: " << Pair.first->second << "\n");
 }
 
-void WasmObjectWriter::registerEventType(const MCSymbolWasm &Symbol) {
-  assert(Symbol.isEvent());
+void WasmObjectWriter::registerTagType(const MCSymbolWasm &Symbol) {
+  assert(Symbol.isTag());
 
   // TODO Currently we don't generate imported exceptions, but if we do, we
   // should have a way of infering types of imported exceptions.
   wasm::WasmSignature S;
   if (auto *Sig = Symbol.getSignature()) {
     S.Returns = Sig->Returns;
     S.Params = Sig->Params;
   }
 
   auto Pair = SignatureIndices.insert(std::make_pair(S, Signatures.size()));
   if (Pair.second)
     Signatures.push_back(S);
   TypeIndices[&Symbol] = Pair.first->second;
 
-  LLVM_DEBUG(dbgs() << "registerEventType: " << Symbol << " new:" << Pair.second
+  LLVM_DEBUG(dbgs() << "registerTagType: " << Symbol << " new:" << Pair.second
                     << "\n");
   LLVM_DEBUG(dbgs() << "  -> type index: " << Pair.first->second << "\n");
 }
 
 static bool isInSymtab(const MCSymbolWasm &Sym) {
   if (Sym.isUsedInReloc() || Sym.isUsedInInitArray())
     return true;
 
for (const MCSymbol &S : Asm.symbols()) {
     if (WS.isFunction()) {
       const auto *BS = Layout.getBaseSymbol(S);
       if (!BS)
         report_fatal_error(Twine(S.getName()) +
                            ": absolute addressing not supported!");
       registerFunctionType(*cast<MCSymbolWasm>(BS));
     }
 
-    if (WS.isEvent())
-      registerEventType(WS);
+    if (WS.isTag())
+      registerTagType(WS);
 
     if (WS.isTemporary())
       continue;
 
     // If the symbol is not defined in this translation unit, import it.
     if (!WS.isDefined() && !WS.isComdat()) {
       if (WS.isFunction()) {
         wasm::WasmImport Import;
if (!WS.isDefined() && !WS.isComdat()) {
         wasm::WasmImport Import;
         Import.Field = WS.getImportName();
         Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
         Import.Module = WS.getImportModule();
         Import.Global = WS.getGlobalType();
         Imports.push_back(Import);
         assert(WasmIndices.count(&WS) == 0);
         WasmIndices[&WS] = NumGlobalImports++;
-      } else if (WS.isEvent()) {
+      } else if (WS.isTag()) {
         if (WS.isWeak())
-          report_fatal_error("undefined event symbol cannot be weak");
+          report_fatal_error("undefined tag symbol cannot be weak");
 
         wasm::WasmImport Import;
         Import.Module = WS.getImportModule();
         Import.Field = WS.getImportName();
-        Import.Kind = wasm::WASM_EXTERNAL_EVENT;
-        Import.Event.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION;
-        Import.Event.SigIndex = getEventType(WS);
+        Import.Kind = wasm::WASM_EXTERNAL_TAG;
+        Import.Tag.Attribute = wasm::WASM_TAG_ATTRIBUTE_EXCEPTION;
+        Import.Tag.SigIndex = getTagType(WS);
         Imports.push_back(Import);
         assert(WasmIndices.count(&WS) == 0);
-        WasmIndices[&WS] = NumEventImports++;
+        WasmIndices[&WS] = NumTagImports++;
       } else if (WS.isTable()) {
         if (WS.isWeak())
           report_fatal_error("undefined table symbol cannot be weak");
 
         wasm::WasmImport Import;
         Import.Module = WS.getImportModule();
         Import.Field = WS.getImportName();
         Import.Kind = wasm::WASM_EXTERNAL_TABLE;
uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
 
   LLVM_DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
 
   // Collect information from the available symbols.
   SmallVector<WasmFunction, 4> Functions;
   SmallVector<uint32_t, 4> TableElems;
   SmallVector<wasm::WasmImport, 4> Imports;
   SmallVector<wasm::WasmExport, 4> Exports;
-  SmallVector<wasm::WasmEventType, 1> Events;
+  SmallVector<wasm::WasmTagType, 1> Tags;
   SmallVector<wasm::WasmGlobal, 1> Globals;
   SmallVector<wasm::WasmTable, 1> Tables;
   SmallVector<wasm::WasmSymbolInfo, 4> SymbolInfos;
   SmallVector<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
   std::map<StringRef, std::vector<WasmComdatEntry>> Comdats;
   uint64_t DataSize = 0;
   if (Mode != DwoMode::DwoOnly) {
     prepareImports(Imports, Asm, Layout);
for (const MCSymbol &S : Asm.symbols()) {
           Table.Index = NumTableImports + Tables.size();
           Table.Type = WS.getTableType();
           assert(WasmIndices.count(&WS) == 0);
           WasmIndices[&WS] = Table.Index;
           Tables.push_back(Table);
         }
         LLVM_DEBUG(dbgs() << " -> table index: "
                           << WasmIndices.find(&WS)->second << "\n");
-      } else if (WS.isEvent()) {
+      } else if (WS.isTag()) {
         // C++ exception symbol (__cpp_exception)
         unsigned Index;
         if (WS.isDefined()) {
-          Index = NumEventImports + Events.size();
-          wasm::WasmEventType Event;
-          Event.SigIndex = getEventType(WS);
-          Event.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION;
+          Index = NumTagImports + Tags.size();
+          wasm::WasmTagType Tag;
+          Tag.SigIndex = getTagType(WS);
+          Tag.Attribute = wasm::WASM_TAG_ATTRIBUTE_EXCEPTION;
           assert(WasmIndices.count(&WS) == 0);
           WasmIndices[&WS] = Index;
-          Events.push_back(Event);
+          Tags.push_back(Tag);
         } else {
           // An import; the index was assigned above.
           assert(WasmIndices.count(&WS) > 0);
         }
-        LLVM_DEBUG(dbgs() << "  -> event index: "
-                          << WasmIndices.find(&WS)->second << "\n");
+        LLVM_DEBUG(dbgs() << "  -> tag index: " << WasmIndices.find(&WS)->second
+                          << "\n");
 
       } else {
         assert(WS.isSection());
       }
     }
 
     // Populate WasmIndices and DataLocations for aliased symbols.  We need to
     // process these in a separate pass because we need to have processed the
for (const MCSymbol &S : Asm.symbols()) {
             std::min(static_cast<uint64_t>(Size), Segment.Data.size() - Offset);
         wasm::WasmDataReference Ref = wasm::WasmDataReference{
             DataSection.getSegmentIndex(),
             static_cast<uint32_t>(Layout.getSymbolOffset(S)),
             static_cast<uint32_t>(Size)};
         DataLocations[&WS] = Ref;
         LLVM_DEBUG(dbgs() << "  -> index:" << Ref.Segment << "\n");
       } else {
-        report_fatal_error("don't yet support global/event aliases");
+        report_fatal_error("don't yet support global/tag aliases");
       }
     }
   }
 
   // Finally, populate the symbol table itself, in its "natural" order.
   for (const MCSymbol &S : Asm.symbols()) {
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
     if (!isInSymtab(WS)) {
uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
 
   uint32_t CodeSectionIndex, DataSectionIndex;
   if (Mode != DwoMode::DwoOnly) {
     writeTypeSection(Signatures);
     writeImportSection(Imports, DataSize, TableElems.size());
     writeFunctionSection(Functions);
     writeTableSection(Tables);
     // Skip the "memory" section; we import the memory instead.
-    writeEventSection(Events);
+    writeTagSection(Tags);
     writeGlobalSection(Globals);
     writeExportSection(Exports);
     const MCSymbol *IndirectFunctionTable =
         Asm.getContext().lookupSymbol("__indirect_function_table");
     writeElemSection(cast_or_null<const MCSymbolWasm>(IndirectFunctionTable),
                      TableElems);
     writeDataCountSection();
 

llvm/lib/Object/RelocationResolver.cpp

static bool supportsWasm32(uint64_t Type) {
   case wasm::R_WASM_TABLE_INDEX_I32:
   case wasm::R_WASM_MEMORY_ADDR_LEB:
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_I32:
   case wasm::R_WASM_TYPE_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32:
-  case wasm::R_WASM_EVENT_INDEX_LEB:
+  case wasm::R_WASM_TAG_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_I32:
   case wasm::R_WASM_TABLE_NUMBER_LEB:
   case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
     return true;
   default:
     return false;
   }
 }
static uint64_t resolveWasm32(uint64_t Type, uint64_t Offset, uint64_t S,
   case wasm::R_WASM_TABLE_INDEX_I32:
   case wasm::R_WASM_MEMORY_ADDR_LEB:
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_I32:
   case wasm::R_WASM_TYPE_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32:
-  case wasm::R_WASM_EVENT_INDEX_LEB:
+  case wasm::R_WASM_TAG_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_I32:
   case wasm::R_WASM_TABLE_NUMBER_LEB:
   case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
     // For wasm section, its offset at 0 -- ignoring Value
     return LocData;
   default:
     llvm_unreachable("Invalid relocation type");
   }

llvm/lib/Object/WasmObjectFile.cpp

Error WasmObjectFile::parseSection(WasmSection &Sec) {
   case wasm::WASM_SEC_IMPORT:
     return parseImportSection(Ctx);
   case wasm::WASM_SEC_FUNCTION:
     return parseFunctionSection(Ctx);
   case wasm::WASM_SEC_TABLE:
     return parseTableSection(Ctx);
   case wasm::WASM_SEC_MEMORY:
     return parseMemorySection(Ctx);
-  case wasm::WASM_SEC_EVENT:
-    return parseEventSection(Ctx);
+  case wasm::WASM_SEC_TAG:
+    return parseTagSection(Ctx);
   case wasm::WASM_SEC_GLOBAL:
     return parseGlobalSection(Ctx);
   case wasm::WASM_SEC_EXPORT:
     return parseExportSection(Ctx);
   case wasm::WASM_SEC_START:
     return parseStartSection(Ctx);
   case wasm::WASM_SEC_ELEM:
     return parseElemSection(Ctx);

 Error WasmObjectFile::parseLinkingSectionSymtab(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   LinkingData.SymbolTable.reserve(Count);
   Symbols.reserve(Count);
   StringSet<> SymbolNames;
 
   std::vector<wasm::WasmImport *> ImportedGlobals;
   std::vector<wasm::WasmImport *> ImportedFunctions;
-  std::vector<wasm::WasmImport *> ImportedEvents;
+  std::vector<wasm::WasmImport *> ImportedTags;
   std::vector<wasm::WasmImport *> ImportedTables;
   ImportedGlobals.reserve(Imports.size());
   ImportedFunctions.reserve(Imports.size());
-  ImportedEvents.reserve(Imports.size());
+  ImportedTags.reserve(Imports.size());
   ImportedTables.reserve(Imports.size());
   for (auto &I : Imports) {
     if (I.Kind == wasm::WASM_EXTERNAL_FUNCTION)
       ImportedFunctions.emplace_back(&I);
     else if (I.Kind == wasm::WASM_EXTERNAL_GLOBAL)
       ImportedGlobals.emplace_back(&I);
-    else if (I.Kind == wasm::WASM_EXTERNAL_EVENT)
-      ImportedEvents.emplace_back(&I);
+    else if (I.Kind == wasm::WASM_EXTERNAL_TAG)
+      ImportedTags.emplace_back(&I);
     else if (I.Kind == wasm::WASM_EXTERNAL_TABLE)
       ImportedTables.emplace_back(&I);
   }
 
   while (Count--) {
     wasm::WasmSymbolInfo Info;
     const wasm::WasmSignature *Signature = nullptr;
     const wasm::WasmGlobalType *GlobalType = nullptr;
     const wasm::WasmTableType *TableType = nullptr;
-    const wasm::WasmEventType *EventType = nullptr;
+    const wasm::WasmTagType *TagType = nullptr;
 
     Info.Kind = readUint8(Ctx);
     Info.Flags = readVaruint32(Ctx);
     bool IsDefined = (Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0;
 
     switch (Info.Kind) {
     case wasm::WASM_SYMBOL_TYPE_FUNCTION:
       Info.ElementIndex = readVaruint32(Ctx);
case wasm::WASM_SYMBOL_TYPE_SECTION: {
             object_error::parse_failed);
       Info.ElementIndex = readVaruint32(Ctx);
       // Use somewhat unique section name as symbol name.
       StringRef SectionName = Sections[Info.ElementIndex].Name;
       Info.Name = SectionName;
       break;
     }
 
-    case wasm::WASM_SYMBOL_TYPE_EVENT: {
+    case wasm::WASM_SYMBOL_TYPE_TAG: {
       Info.ElementIndex = readVaruint32(Ctx);
-      if (!isValidEventIndex(Info.ElementIndex) ||
-          IsDefined != isDefinedEventIndex(Info.ElementIndex))
-        return make_error<GenericBinaryError>("invalid event symbol index",
+      if (!isValidTagIndex(Info.ElementIndex) ||
+          IsDefined != isDefinedTagIndex(Info.ElementIndex))
+        return make_error<GenericBinaryError>("invalid tag symbol index",
                                               object_error::parse_failed);
       if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
                             wasm::WASM_SYMBOL_BINDING_WEAK)
         return make_error<GenericBinaryError>("undefined weak global symbol",
                                               object_error::parse_failed);
       if (IsDefined) {
         Info.Name = readString(Ctx);
-        unsigned EventIndex = Info.ElementIndex - NumImportedEvents;
-        wasm::WasmEvent &Event = Events[EventIndex];
-        Signature = &Signatures[Event.Type.SigIndex];
-        EventType = &Event.Type;
-        if (Event.SymbolName.empty())
-          Event.SymbolName = Info.Name;
+        unsigned TagIndex = Info.ElementIndex - NumImportedTags;
+        wasm::WasmTag &Tag = Tags[TagIndex];
+        Signature = &Signatures[Tag.Type.SigIndex];
+        TagType = &Tag.Type;
+        if (Tag.SymbolName.empty())
+          Tag.SymbolName = Info.Name;
 
       } else {
-        wasm::WasmImport &Import = *ImportedEvents[Info.ElementIndex];
+        wasm::WasmImport &Import = *ImportedTags[Info.ElementIndex];
         if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
           Info.Name = readString(Ctx);
           Info.ImportName = Import.Field;
         } else {
           Info.Name = Import.Field;
         }
-        EventType = &Import.Event;
-        Signature = &Signatures[EventType->SigIndex];
+        TagType = &Import.Tag;
+        Signature = &Signatures[TagType->SigIndex];
         if (!Import.Module.empty()) {
           Info.ImportModule = Import.Module;
         }
       }
       break;
     }
 
     default:
       return make_error<GenericBinaryError>("invalid symbol type: " +
                                                 Twine(unsigned(Info.Kind)),
                                             object_error::parse_failed);
     }
 
     if ((Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) !=
             wasm::WASM_SYMBOL_BINDING_LOCAL &&
         !SymbolNames.insert(Info.Name).second)
       return make_error<GenericBinaryError>("duplicate symbol name " +
                                                 Twine(Info.Name),
                                             object_error::parse_failed);
     LinkingData.SymbolTable.emplace_back(Info);
     Symbols.emplace_back(LinkingData.SymbolTable.back(), GlobalType, TableType,
-                         EventType, Signature);
+                         TagType, Signature);
     LLVM_DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
   }
 
   return Error::success();
 }
 
 Error WasmObjectFile::parseLinkingSectionComdat(ReadContext &Ctx) {
   uint32_t ComdatCount = readVaruint32(Ctx);
case wasm::R_WASM_GLOBAL_INDEX_LEB:
         return make_error<GenericBinaryError>("invalid relocation global index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_GLOBAL_INDEX_I32:
       if (!isValidGlobalSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("invalid relocation global index",
                                               object_error::parse_failed);
       break;
-    case wasm::R_WASM_EVENT_INDEX_LEB:
-      if (!isValidEventSymbol(Reloc.Index))
-        return make_error<GenericBinaryError>("invalid relocation event index",
+    case wasm::R_WASM_TAG_INDEX_LEB:
+      if (!isValidTagSymbol(Reloc.Index))
+        return make_error<GenericBinaryError>("invalid relocation tag index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_MEMORY_ADDR_LEB:
     case wasm::R_WASM_MEMORY_ADDR_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_I32:
     case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
     case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
case wasm::WASM_EXTERNAL_TABLE: {
       NumImportedTables++;
       auto ElemType = Im.Table.ElemType;
       if (ElemType != wasm::WASM_TYPE_FUNCREF &&
           ElemType != wasm::WASM_TYPE_EXTERNREF)
         return make_error<GenericBinaryError>("invalid table element type",
                                               object_error::parse_failed);
       break;
     }
-    case wasm::WASM_EXTERNAL_EVENT:
-      NumImportedEvents++;
-      Im.Event.Attribute = readVarint32(Ctx);
-      Im.Event.SigIndex = readVarint32(Ctx);
+    case wasm::WASM_EXTERNAL_TAG:
+      NumImportedTags++;
+      Im.Tag.Attribute = readVarint32(Ctx);
+      Im.Tag.SigIndex = readVarint32(Ctx);
       break;
     default:
       return make_error<GenericBinaryError>("unexpected import kind",
                                             object_error::parse_failed);
     }
     Imports.push_back(Im);
   }
   if (Ctx.Ptr != Ctx.End)
while (Count--) {
     Memories.push_back(Limits);
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("memory section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
-Error WasmObjectFile::parseEventSection(ReadContext &Ctx) {
-  EventSection = Sections.size();
+Error WasmObjectFile::parseTagSection(ReadContext &Ctx) {
+  TagSection = Sections.size();
   uint32_t Count = readVaruint32(Ctx);
-  Events.reserve(Count);
+  Tags.reserve(Count);
   while (Count--) {
-    wasm::WasmEvent Event;
-    Event.Index = NumImportedEvents + Events.size();
-    Event.Type.Attribute = readVaruint32(Ctx);
-    Event.Type.SigIndex = readVaruint32(Ctx);
-    Events.push_back(Event);
+    wasm::WasmTag Tag;
+    Tag.Index = NumImportedTags + Tags.size();
+    Tag.Type.Attribute = readVaruint32(Ctx);
+    Tag.Type.SigIndex = readVaruint32(Ctx);
+    Tags.push_back(Tag);
   }
 
   if (Ctx.Ptr != Ctx.End)
-    return make_error<GenericBinaryError>("event section ended prematurely",
+    return make_error<GenericBinaryError>("tag section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseGlobalSection(ReadContext &Ctx) {
   GlobalSection = Sections.size();
   uint32_t Count = readVaruint32(Ctx);
   Globals.reserve(Count);
case wasm::WASM_EXTERNAL_FUNCTION:
                                               object_error::parse_failed);
       getDefinedFunction(Ex.Index).ExportName = Ex.Name;
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
       if (!isValidGlobalIndex(Ex.Index))
         return make_error<GenericBinaryError>("invalid global export",
                                               object_error::parse_failed);
       break;
-    case wasm::WASM_EXTERNAL_EVENT:
-      if (!isValidEventIndex(Ex.Index))
-        return make_error<GenericBinaryError>("invalid event export",
+    case wasm::WASM_EXTERNAL_TAG:
+      if (!isValidTagIndex(Ex.Index))
+        return make_error<GenericBinaryError>("invalid tag export",
                                               object_error::parse_failed);
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
     case wasm::WASM_EXTERNAL_TABLE:
       break;
     default:
       return make_error<GenericBinaryError>("unexpected export kind",
                                             object_error::parse_failed);

 bool WasmObjectFile::isDefinedGlobalIndex(uint32_t Index) const {
   return Index >= NumImportedGlobals && isValidGlobalIndex(Index);
 }
 
 bool WasmObjectFile::isDefinedTableNumber(uint32_t Index) const {
   return Index >= NumImportedTables && isValidTableNumber(Index);
 }
 
-bool WasmObjectFile::isValidEventIndex(uint32_t Index) const {
-  return Index < NumImportedEvents + Events.size();
+bool WasmObjectFile::isValidTagIndex(uint32_t Index) const {
+  return Index < NumImportedTags + Tags.size();
 }
 
-bool WasmObjectFile::isDefinedEventIndex(uint32_t Index) const {
-  return Index >= NumImportedEvents && isValidEventIndex(Index);
+bool WasmObjectFile::isDefinedTagIndex(uint32_t Index) const {
+  return Index >= NumImportedTags && isValidTagIndex(Index);
 }
 
 bool WasmObjectFile::isValidFunctionSymbol(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeFunction();
 }
 
 bool WasmObjectFile::isValidTableSymbol(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeTable();
 }
 
 bool WasmObjectFile::isValidGlobalSymbol(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeGlobal();
 }
 
-bool WasmObjectFile::isValidEventSymbol(uint32_t Index) const {
-  return Index < Symbols.size() && Symbols[Index].isTypeEvent();
+bool WasmObjectFile::isValidTagSymbol(uint32_t Index) const {
+  return Index < Symbols.size() && Symbols[Index].isTypeTag();
 }
 
 bool WasmObjectFile::isValidDataSymbol(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeData();
 }
 
 bool WasmObjectFile::isValidSectionSymbol(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeSection();
WasmObjectFile::getDefinedFunction(uint32_t Index) const {
   return Functions[Index - NumImportedFunctions];
 }
 
 wasm::WasmGlobal &WasmObjectFile::getDefinedGlobal(uint32_t Index) {
   assert(isDefinedGlobalIndex(Index));
   return Globals[Index - NumImportedGlobals];
 }
 
-wasm::WasmEvent &WasmObjectFile::getDefinedEvent(uint32_t Index) {
-  assert(isDefinedEventIndex(Index));
-  return Events[Index - NumImportedEvents];
+wasm::WasmTag &WasmObjectFile::getDefinedTag(uint32_t Index) {
+  assert(isDefinedTagIndex(Index));
+  return Tags[Index - NumImportedTags];
 }
 
 Error WasmObjectFile::parseStartSection(ReadContext &Ctx) {
   StartFunction = readVaruint32(Ctx);
   if (!isValidFunctionIndex(StartFunction))
     return make_error<GenericBinaryError>("invalid start function",
                                           object_error::parse_failed);
   return Error::success();
Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
   else
     return getSymbolValue(Symb);
 }
 
 uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol &Sym) const {
   switch (Sym.Info.Kind) {
   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
-  case wasm::WASM_SYMBOL_TYPE_EVENT:
+  case wasm::WASM_SYMBOL_TYPE_TAG:
   case wasm::WASM_SYMBOL_TYPE_TABLE:
     return Sym.Info.ElementIndex;
   case wasm::WASM_SYMBOL_TYPE_DATA: {
     // The value of a data symbol is the segment offset, plus the symbol
     // offset within the segment.
     uint32_t SegmentIndex = Sym.Info.DataRef.Segment;
     const wasm::WasmDataSegment &Segment = DataSegments[SegmentIndex].Data;
     if (Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST) {
WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
     return SymbolRef::ST_Function;
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
     return SymbolRef::ST_Other;
   case wasm::WASM_SYMBOL_TYPE_DATA:
     return SymbolRef::ST_Data;
   case wasm::WASM_SYMBOL_TYPE_SECTION:
     return SymbolRef::ST_Debug;
-  case wasm::WASM_SYMBOL_TYPE_EVENT:
+  case wasm::WASM_SYMBOL_TYPE_TAG:
     return SymbolRef::ST_Other;
   case wasm::WASM_SYMBOL_TYPE_TABLE:
     return SymbolRef::ST_Other;
   }
 
   llvm_unreachable("unknown WasmSymbol::SymbolType");
   return SymbolRef::ST_Other;
 }
uint32_t WasmObjectFile::getSymbolSectionIdImpl(const WasmSymbol &Sym) const {
   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
     return CodeSection;
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
     return GlobalSection;
   case wasm::WASM_SYMBOL_TYPE_DATA:
     return DataSection;
   case wasm::WASM_SYMBOL_TYPE_SECTION:
     return Sym.Info.ElementIndex;
-  case wasm::WASM_SYMBOL_TYPE_EVENT:
-    return EventSection;
+  case wasm::WASM_SYMBOL_TYPE_TAG:
+    return TagSection;
   case wasm::WASM_SYMBOL_TYPE_TABLE:
     return TableSection;
   default:
     llvm_unreachable("unknown WasmSymbol::SymbolType");
   }
 }
 
 void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
 
 Expected<StringRef> WasmObjectFile::getSectionName(DataRefImpl Sec) const {
   const WasmSection &S = Sections[Sec.d.a];
 #define ECase(X)                                                               \
   case wasm::WASM_SEC_##X:                                                     \
     return #X;
   switch (S.Type) {
     ECase(TYPE);
     ECase(IMPORT);
     ECase(FUNCTION);
     ECase(TABLE);
     ECase(MEMORY);
     ECase(GLOBAL);
-    ECase(EVENT);
+    ECase(TAG);
     ECase(EXPORT);
     ECase(START);
     ECase(ELEM);
     ECase(CODE);
     ECase(DATA);
     ECase(DATACOUNT);
   case wasm::WASM_SEC_CUSTOM:
     return S.Name;
int WasmSectionOrderChecker::getSectionOrder(unsigned ID,
   case wasm::WASM_SEC_ELEM:
     return WASM_SEC_ORDER_ELEM;
   case wasm::WASM_SEC_CODE:
     return WASM_SEC_ORDER_CODE;
   case wasm::WASM_SEC_DATA:
     return WASM_SEC_ORDER_DATA;
   case wasm::WASM_SEC_DATACOUNT:
     return WASM_SEC_ORDER_DATACOUNT;
-  case wasm::WASM_SEC_EVENT:
-    return WASM_SEC_ORDER_EVENT;
+  case wasm::WASM_SEC_TAG:
+    return WASM_SEC_ORDER_TAG;
   default:
     return WASM_SEC_ORDER_NONE;
   }
 }
 
 // Represents the edges in a directed graph where any node B reachable from node
 // A is not allowed to appear before A in the section ordering, but may appear
 // afterward.
 int WasmSectionOrderChecker::DisallowedPredecessors
     [WASM_NUM_SEC_ORDERS][WASM_NUM_SEC_ORDERS] = {
         // WASM_SEC_ORDER_NONE
         {},
         // WASM_SEC_ORDER_TYPE
         {WASM_SEC_ORDER_TYPE, WASM_SEC_ORDER_IMPORT},
         // WASM_SEC_ORDER_IMPORT
         {WASM_SEC_ORDER_IMPORT, WASM_SEC_ORDER_FUNCTION},
         // WASM_SEC_ORDER_FUNCTION
         {WASM_SEC_ORDER_FUNCTION, WASM_SEC_ORDER_TABLE},
         // WASM_SEC_ORDER_TABLE
         {WASM_SEC_ORDER_TABLE, WASM_SEC_ORDER_MEMORY},
         // WASM_SEC_ORDER_MEMORY
-        {WASM_SEC_ORDER_MEMORY, WASM_SEC_ORDER_EVENT},
-        // WASM_SEC_ORDER_EVENT
-        {WASM_SEC_ORDER_EVENT, WASM_SEC_ORDER_GLOBAL},
+        {WASM_SEC_ORDER_MEMORY, WASM_SEC_ORDER_TAG},
+        // WASM_SEC_ORDER_TAG
+        {WASM_SEC_ORDER_TAG, WASM_SEC_ORDER_GLOBAL},
         // WASM_SEC_ORDER_GLOBAL
         {WASM_SEC_ORDER_GLOBAL, WASM_SEC_ORDER_EXPORT},
         // WASM_SEC_ORDER_EXPORT
         {WASM_SEC_ORDER_EXPORT, WASM_SEC_ORDER_START},
         // WASM_SEC_ORDER_START
         {WASM_SEC_ORDER_START, WASM_SEC_ORDER_ELEM},
         // WASM_SEC_ORDER_ELEM
         {WASM_SEC_ORDER_ELEM, WASM_SEC_ORDER_DATACOUNT},

llvm/lib/ObjectYAML/WasmEmitter.cpp

private:
   void writeInitExpr(raw_ostream &OS, const wasm::WasmInitExpr &InitExpr);
 
   void writeSectionContent(raw_ostream &OS, WasmYAML::CustomSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::TypeSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::ImportSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::FunctionSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::TableSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::MemorySection &Section);
-  void writeSectionContent(raw_ostream &OS, WasmYAML::EventSection &Section);
+  void writeSectionContent(raw_ostream &OS, WasmYAML::TagSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::GlobalSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::ExportSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::StartSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::ElemSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::CodeSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::DataSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::DataCountSection &Section);
 
   // Custom section types
   void writeSectionContent(raw_ostream &OS, WasmYAML::DylinkSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::NameSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section);
   void writeSectionContent(raw_ostream &OS, WasmYAML::ProducersSection &Section);
   void writeSectionContent(raw_ostream &OS,
                           WasmYAML::TargetFeaturesSection &Section);
   WasmYAML::Object &Obj;
   uint32_t NumImportedFunctions = 0;
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedTables = 0;
-  uint32_t NumImportedEvents = 0;
+  uint32_t NumImportedTags = 0;
 
   bool HasError = false;
   yaml::ErrorHandler ErrHandler;
   void reportError(const Twine &Msg);
 };
 
 class SubSectionWriter {
   raw_ostream &OS;
#endif
     for (const WasmYAML::SymbolInfo &Info : Section.SymbolTable) {
       assert(Info.Index == SymbolIndex++);
       writeUint8(SubSection.getStream(), Info.Kind);
       encodeULEB128(Info.Flags, SubSection.getStream());
       switch (Info.Kind) {
       case wasm::WASM_SYMBOL_TYPE_FUNCTION:
       case wasm::WASM_SYMBOL_TYPE_GLOBAL:
       case wasm::WASM_SYMBOL_TYPE_TABLE:
-      case wasm::WASM_SYMBOL_TYPE_EVENT:
+      case wasm::WASM_SYMBOL_TYPE_TAG:
         encodeULEB128(Info.ElementIndex, SubSection.getStream());
         if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0 ||
             (Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeStringRef(Info.Name, SubSection.getStream());
         break;
       case wasm::WASM_SYMBOL_TYPE_DATA:
         writeStringRef(Info.Name, SubSection.getStream());
         if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
case wasm::WASM_EXTERNAL_FUNCTION:
       encodeULEB128(Import.SigIndex, OS);
       NumImportedFunctions++;
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
       writeUint8(OS, Import.GlobalImport.Type);
       writeUint8(OS, Import.GlobalImport.Mutable);
       NumImportedGlobals++;
       break;
-    case wasm::WASM_EXTERNAL_EVENT:
-      writeUint32(OS, Import.EventImport.Attribute);
-      writeUint32(OS, Import.EventImport.SigIndex);
-      NumImportedEvents++;
+    case wasm::WASM_EXTERNAL_TAG:
+      writeUint32(OS, Import.TagImport.Attribute);
+      writeUint32(OS, Import.TagImport.SigIndex);
+      NumImportedTags++;
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
       writeLimits(Import.Memory, OS);
       break;
     case wasm::WASM_EXTERNAL_TABLE:
       writeUint8(OS, Import.TableImport.ElemType);
       writeLimits(Import.TableImport.TableLimits, OS);
       NumImportedTables++;

 void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::MemorySection &Section) {
   encodeULEB128(Section.Memories.size(), OS);
   for (const WasmYAML::Limits &Mem : Section.Memories)
     writeLimits(Mem, OS);
 }
 
 void WasmWriter::writeSectionContent(raw_ostream &OS,
-                                     WasmYAML::EventSection &Section) {
-  encodeULEB128(Section.Events.size(), OS);
-  uint32_t ExpectedIndex = NumImportedEvents;
-  for (auto &Event : Section.Events) {
-    if (Event.Index != ExpectedIndex) {
-      reportError("unexpected event index: " + Twine(Event.Index));
+                                     WasmYAML::TagSection &Section) {
+  encodeULEB128(Section.Tags.size(), OS);
+  uint32_t ExpectedIndex = NumImportedTags;
+  for (auto &Tag : Section.Tags) {
+    if (Tag.Index != ExpectedIndex) {
+      reportError("unexpected tag index: " + Twine(Tag.Index));
       return;
     }
     ++ExpectedIndex;
-    encodeULEB128(Event.Attribute, OS);
-    encodeULEB128(Event.SigIndex, OS);
+    encodeULEB128(Tag.Attribute, OS);
+    encodeULEB128(Tag.SigIndex, OS);
   }
 }
 
 void WasmWriter::writeSectionContent(raw_ostream &OS,
                                      WasmYAML::GlobalSection &Section) {
   encodeULEB128(Section.Globals.size(), OS);
   uint32_t ExpectedIndex = NumImportedGlobals;
   for (auto &Global : Section.Globals) {
for (const std::unique_ptr<WasmYAML::Section> &Sec : Obj.Sections) {
     else if (auto S = dyn_cast<WasmYAML::ImportSection>(Sec.get()))
       writeSectionContent(StringStream, *S);
     else if (auto S = dyn_cast<WasmYAML::FunctionSection>(Sec.get()))
       writeSectionContent(StringStream, *S);
     else if (auto S = dyn_cast<WasmYAML::TableSection>(Sec.get()))
       writeSectionContent(StringStream, *S);
     else if (auto S = dyn_cast<WasmYAML::MemorySection>(Sec.get()))
       writeSectionContent(StringStream, *S);
-    else if (auto S = dyn_cast<WasmYAML::EventSection>(Sec.get()))
+    else if (auto S = dyn_cast<WasmYAML::TagSection>(Sec.get()))
       writeSectionContent(StringStream, *S);
     else if (auto S = dyn_cast<WasmYAML::GlobalSection>(Sec.get()))
       writeSectionContent(StringStream, *S);
     else if (auto S = dyn_cast<WasmYAML::ExportSection>(Sec.get()))
       writeSectionContent(StringStream, *S);
     else if (auto S = dyn_cast<WasmYAML::StartSection>(Sec.get()))
       writeSectionContent(StringStream, *S);
     else if (auto S = dyn_cast<WasmYAML::ElemSection>(Sec.get()))

llvm/lib/ObjectYAML/WasmYAML.cpp

static void sectionMapping(IO &IO, WasmYAML::TableSection &Section) {
   IO.mapOptional("Tables", Section.Tables);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::MemorySection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Memories", Section.Memories);
 }
 
-static void sectionMapping(IO &IO, WasmYAML::EventSection &Section) {
+static void sectionMapping(IO &IO, WasmYAML::TagSection &Section) {
   commonSectionMapping(IO, Section);
-  IO.mapOptional("Events", Section.Events);
+  IO.mapOptional("Tags", Section.Tags);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Globals", Section.Globals);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) {
if (!IO.outputting())
       Section.reset(new WasmYAML::TableSection());
     sectionMapping(IO, *cast<WasmYAML::TableSection>(Section.get()));
     break;
   case wasm::WASM_SEC_MEMORY:
     if (!IO.outputting())
       Section.reset(new WasmYAML::MemorySection());
     sectionMapping(IO, *cast<WasmYAML::MemorySection>(Section.get()));
     break;
-  case wasm::WASM_SEC_EVENT:
+  case wasm::WASM_SEC_TAG:
     if (!IO.outputting())
-      Section.reset(new WasmYAML::EventSection());
-    sectionMapping(IO, *cast<WasmYAML::EventSection>(Section.get()));
+      Section.reset(new WasmYAML::TagSection());
+    sectionMapping(IO, *cast<WasmYAML::TagSection>(Section.get()));
     break;
   case wasm::WASM_SEC_GLOBAL:
     if (!IO.outputting())
       Section.reset(new WasmYAML::GlobalSection());
     sectionMapping(IO, *cast<WasmYAML::GlobalSection>(Section.get()));
     break;
   case wasm::WASM_SEC_EXPORT:
     if (!IO.outputting())

 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_SEC_##X);
   ECase(CUSTOM);
   ECase(TYPE);
   ECase(IMPORT);
   ECase(FUNCTION);
   ECase(TABLE);
   ECase(MEMORY);
   ECase(GLOBAL);
-  ECase(EVENT);
+  ECase(TAG);
   ECase(EXPORT);
   ECase(START);
   ECase(ELEM);
   ECase(CODE);
   ECase(DATA);
   ECase(DATACOUNT);
 #undef ECase
 }
void MappingTraits<WasmYAML::Import>::mapping(IO &IO,
   IO.mapRequired("Module", Import.Module);
   IO.mapRequired("Field", Import.Field);
   IO.mapRequired("Kind", Import.Kind);
   if (Import.Kind == wasm::WASM_EXTERNAL_FUNCTION) {
     IO.mapRequired("SigIndex", Import.SigIndex);
   } else if (Import.Kind == wasm::WASM_EXTERNAL_GLOBAL) {
     IO.mapRequired("GlobalType", Import.GlobalImport.Type);
     IO.mapRequired("GlobalMutable", Import.GlobalImport.Mutable);
-  } else if (Import.Kind == wasm::WASM_EXTERNAL_EVENT) {
-    IO.mapRequired("EventAttribute", Import.EventImport.Attribute);
-    IO.mapRequired("EventSigIndex", Import.EventImport.SigIndex);
+  } else if (Import.Kind == wasm::WASM_EXTERNAL_TAG) {
+    IO.mapRequired("TagAttribute", Import.TagImport.Attribute);
+    IO.mapRequired("TagSigIndex", Import.TagImport.SigIndex);
   } else if (Import.Kind == wasm::WASM_EXTERNAL_TABLE) {
     IO.mapRequired("Table", Import.TableImport);
   } else if (Import.Kind == wasm::WASM_EXTERNAL_MEMORY) {
     IO.mapRequired("Memory", Import.Memory);
   } else {
     llvm_unreachable("unhandled import type");
   }
 }
if (Info.Kind != wasm::WASM_SYMBOL_TYPE_SECTION)
     IO.mapRequired("Name", Info.Name);
   IO.mapRequired("Flags", Info.Flags);
   if (Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION) {
     IO.mapRequired("Function", Info.ElementIndex);
   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL) {
     IO.mapRequired("Global", Info.ElementIndex);
   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_TABLE) {
     IO.mapRequired("Table", Info.ElementIndex);
-  } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_EVENT) {
-    IO.mapRequired("Event", Info.ElementIndex);
+  } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_TAG) {
+    IO.mapRequired("Tag", Info.ElementIndex);
   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA) {
     if ((Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
       IO.mapRequired("Segment", Info.DataRef.Segment);
       IO.mapOptional("Offset", Info.DataRef.Offset, 0u);
       IO.mapRequired("Size", Info.DataRef.Size);
     }
   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION) {
     IO.mapRequired("Section", Info.ElementIndex);
   } else {
     llvm_unreachable("unsupported symbol kind");
   }
 }
 
-void MappingTraits<WasmYAML::Event>::mapping(IO &IO, WasmYAML::Event &Event) {
-  IO.mapRequired("Index", Event.Index);
-  IO.mapRequired("Attribute", Event.Attribute);
-  IO.mapRequired("SigIndex", Event.SigIndex);
+void MappingTraits<WasmYAML::Tag>::mapping(IO &IO, WasmYAML::Tag &Tag) {
+  IO.mapRequired("Index", Tag.Index);
+  IO.mapRequired("Attribute", Tag.Attribute);
+  IO.mapRequired("SigIndex", Tag.SigIndex);
 }
 
 void ScalarBitSetTraits<WasmYAML::LimitFlags>::bitset(
     IO &IO, WasmYAML::LimitFlags &Value) {
 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X)
   BCase(HAS_MAX);
   BCase(IS_SHARED);
   BCase(IS_64);

 void ScalarEnumerationTraits<WasmYAML::SymbolKind>::enumeration(
     IO &IO, WasmYAML::SymbolKind &Kind) {
 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X);
   ECase(FUNCTION);
   ECase(DATA);
   ECase(GLOBAL);
   ECase(TABLE);
   ECase(SECTION);
-  ECase(EVENT);
+  ECase(TAG);
 #undef ECase
 }
 
 void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
     IO &IO, WasmYAML::ValueType &Type) {
 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
   ECase(I32);
   ECase(I64);
   ECase(F32);
   ECase(F64);
   ECase(V128);
   ECase(FUNCREF);
   ECase(EXTERNREF);
   ECase(FUNC);
 #undef ECase
 }
 
 void ScalarEnumerationTraits<WasmYAML::ExportKind>::enumeration(
     IO &IO, WasmYAML::ExportKind &Kind) {
 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_EXTERNAL_##X);
   ECase(FUNCTION);
   ECase(TABLE);
   ECase(MEMORY);
   ECase(GLOBAL);
-  ECase(EVENT);
+  ECase(TAG);
 #undef ECase
 }
 
 void ScalarEnumerationTraits<WasmYAML::Opcode>::enumeration(
     IO &IO, WasmYAML::Opcode &Code) {
 #define ECase(X) IO.enumCase(Code, #X, wasm::WASM_OPCODE_##X);
   ECase(END);
   ECase(I32_CONST);

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

if (DirectiveID.getString() == ".import_name") {
       if (expect(AsmToken::Comma, ","))
         return true;
       auto ImportName = expectIdent();
       auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
       WasmSym->setImportName(storeName(ImportName));
       TOut.emitImportName(WasmSym, ImportName);
     }
 
-    if (DirectiveID.getString() == ".eventtype") {
+    if (DirectiveID.getString() == ".tagtype") {
       auto SymName = expectIdent();
       if (SymName.empty())
         return true;
       auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
       auto Signature = std::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);
+      WasmSym->setType(wasm::WASM_SYMBOL_TYPE_TAG);
+      TOut.emitTagType(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());

llvm/lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp

for (uint8_t OPI = 0; OPI < WasmInst->NumOperands; OPI++) {
     case WebAssembly::OPERAND_LOCAL:
     case WebAssembly::OPERAND_GLOBAL:
     case WebAssembly::OPERAND_FUNCTION32:
     case WebAssembly::OPERAND_TABLE:
     case WebAssembly::OPERAND_OFFSET32:
     case WebAssembly::OPERAND_OFFSET64:
     case WebAssembly::OPERAND_P2ALIGN:
     case WebAssembly::OPERAND_TYPEINDEX:
-    case WebAssembly::OPERAND_EVENT:
+    case WebAssembly::OPERAND_TAG:
     case MCOI::OPERAND_IMMEDIATE: {
       if (!parseLEBImmediate(MI, Size, Bytes, false))
         return MCDisassembler::Fail;
       break;
     }
     // SLEB operands:
     case WebAssembly::OPERAND_I32IMM:
     case WebAssembly::OPERAND_I64IMM: {

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCCodeEmitter.cpp

if (MO.isReg()) {
         PaddedSize = 10;
         break;
       case WebAssembly::OPERAND_FUNCTION32:
       case WebAssembly::OPERAND_TABLE:
       case WebAssembly::OPERAND_OFFSET32:
       case WebAssembly::OPERAND_SIGNATURE:
       case WebAssembly::OPERAND_TYPEINDEX:
       case WebAssembly::OPERAND_GLOBAL:
-      case WebAssembly::OPERAND_EVENT:
+      case WebAssembly::OPERAND_TAG:
         FixupKind = MCFixupKind(WebAssembly::fixup_uleb128_i32);
         break;
       case WebAssembly::OPERAND_OFFSET64:
         FixupKind = MCFixupKind(WebAssembly::fixup_uleb128_i64);
         PaddedSize = 10;
         break;
       default:
         llvm_unreachable("unexpected symbolic operand kind");

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h

enum OperandType {
   /// 64-bit unsigned memory offsets.
   OPERAND_OFFSET64,
   /// p2align immediate for load and store address alignment.
   OPERAND_P2ALIGN,
   /// signature immediate for block/loop.
   OPERAND_SIGNATURE,
   /// type signature immediate for call_indirect.
   OPERAND_TYPEINDEX,
-  /// Event index.
-  OPERAND_EVENT,
+  /// Tag index.
+  OPERAND_TAG,
   /// A list of branch targets for br_list.
   OPERAND_BRLIST,
   /// 32-bit unsigned table number.
   OPERAND_TABLE,
   /// heap type immediate for ref.null.
   OPERAND_HEAPTYPE,
 };
 } // end namespace WebAssembly

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.h

public:
   /// .functype
   virtual void emitFunctionType(const MCSymbolWasm *Sym) = 0;
   /// .indidx
   virtual void emitIndIdx(const MCExpr *Value) = 0;
   /// .globaltype
   virtual void emitGlobalType(const MCSymbolWasm *Sym) = 0;
   /// .tabletype
   virtual void emitTableType(const MCSymbolWasm *Sym) = 0;
-  /// .eventtype
-  virtual void emitEventType(const MCSymbolWasm *Sym) = 0;
+  /// .tagtype
+  virtual void emitTagType(const MCSymbolWasm *Sym) = 0;
   /// .import_module
   virtual void emitImportModule(const MCSymbolWasm *Sym,
                                 StringRef ImportModule) = 0;
   /// .import_name
   virtual void emitImportName(const MCSymbolWasm *Sym,
                               StringRef ImportName) = 0;
   /// .export_name
   virtual void emitExportName(const MCSymbolWasm *Sym,
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;
   void emitGlobalType(const MCSymbolWasm *Sym) override;
   void emitTableType(const MCSymbolWasm *Sym) override;
-  void emitEventType(const MCSymbolWasm *Sym) override;
+  void emitTagType(const MCSymbolWasm *Sym) override;
   void emitImportModule(const MCSymbolWasm *Sym, StringRef ImportModule) override;
   void emitImportName(const MCSymbolWasm *Sym, StringRef ImportName) override;
   void emitExportName(const MCSymbolWasm *Sym, StringRef ExportName) override;
 };
 
 /// This part is for Wasm object output
 class WebAssemblyTargetWasmStreamer final : public WebAssemblyTargetStreamer {
 public:
   explicit WebAssemblyTargetWasmStreamer(MCStreamer &S);
 
   void emitLocal(ArrayRef<wasm::ValType> Types) override;
   void emitEndFunc() override;
   void emitFunctionType(const MCSymbolWasm *Sym) override {}
   void emitIndIdx(const MCExpr *Value) override;
   void emitGlobalType(const MCSymbolWasm *Sym) override {}
   void emitTableType(const MCSymbolWasm *Sym) override {}
-  void emitEventType(const MCSymbolWasm *Sym) override {}
+  void emitTagType(const MCSymbolWasm *Sym) override {}
   void emitImportModule(const MCSymbolWasm *Sym,
                         StringRef ImportModule) override {}
   void emitImportName(const MCSymbolWasm *Sym,
                       StringRef ImportName) override {}
   void emitExportName(const MCSymbolWasm *Sym,
                       StringRef ExportName) override {}
 };
 
 /// This part is for null output
 class WebAssemblyTargetNullStreamer final : public WebAssemblyTargetStreamer {
 public:
   explicit WebAssemblyTargetNullStreamer(MCStreamer &S)
       : WebAssemblyTargetStreamer(S) {}
 
   void emitLocal(ArrayRef<wasm::ValType>) override {}
   void emitEndFunc() override {}
   void emitFunctionType(const MCSymbolWasm *) override {}
   void emitIndIdx(const MCExpr *) override {}
   void emitGlobalType(const MCSymbolWasm *) override {}
   void emitTableType(const MCSymbolWasm *) override {}
-  void emitEventType(const MCSymbolWasm *) override {}
+  void emitTagType(const MCSymbolWasm *) override {}
   void emitImportModule(const MCSymbolWasm *, StringRef) override {}
   void emitImportName(const MCSymbolWasm *, StringRef) override {}
   void emitExportName(const MCSymbolWasm *, StringRef) override {}
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp

void WebAssemblyTargetAsmStreamer::emitTableType(const MCSymbolWasm *Sym) {
   if (Type.Limits.Minimum != 0 || HasMaximum) {
     OS << ", " << Type.Limits.Minimum;
     if (HasMaximum)
       OS << ", " << Type.Limits.Maximum;
   }
   OS << '\n';
 }
 
-void WebAssemblyTargetAsmStreamer::emitEventType(const MCSymbolWasm *Sym) {
-  assert(Sym->isEvent());
-  OS << "\t.eventtype\t" << Sym->getName() << " ";
+void WebAssemblyTargetAsmStreamer::emitTagType(const MCSymbolWasm *Sym) {
+  assert(Sym->isTag());
+  OS << "\t.tagtype\t" << Sym->getName() << " ";
   OS << WebAssembly::typeListToString(Sym->getSignature()->Params);
   OS << "\n";
 }
 
 void WebAssemblyTargetAsmStreamer::emitImportModule(const MCSymbolWasm *Sym,
                                                     StringRef ImportModule) {
   OS << "\t.import_module\t" << Sym->getName() << ", "
                              << ImportModule << '\n';

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp

case WebAssembly::fixup_sleb128_i64:
     if (SymA.isFunction())
       return wasm::R_WASM_TABLE_INDEX_SLEB64;
     return wasm::R_WASM_MEMORY_ADDR_SLEB64;
   case WebAssembly::fixup_uleb128_i32:
     if (SymA.isGlobal())
       return wasm::R_WASM_GLOBAL_INDEX_LEB;
     if (SymA.isFunction())
       return wasm::R_WASM_FUNCTION_INDEX_LEB;
-    if (SymA.isEvent())
-      return wasm::R_WASM_EVENT_INDEX_LEB;
+    if (SymA.isTag())
+      return wasm::R_WASM_TAG_INDEX_LEB;
     if (SymA.isTable())
       return wasm::R_WASM_TABLE_NUMBER_LEB;
     return wasm::R_WASM_MEMORY_ADDR_LEB;
   case WebAssembly::fixup_uleb128_i64:
     assert(SymA.isData());
     return wasm::R_WASM_MEMORY_ADDR_LEB64;
   case FK_Data_4:
     if (SymA.isFunction())

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

if (GV->hasInitializer()) {
     // TODO: Actually emit the initializer value.  Otherwise the global has the
     // default value for its type (0, ref.null, etc).
     OutStreamer->AddBlankLine();
   }
 }
 
 void WebAssemblyAsmPrinter::emitEndOfAsmFile(Module &M) {
   for (auto &It : OutContext.getSymbols()) {
-    // Emit .globaltype, .eventtype, or .tabletype declarations.
+    // Emit .globaltype, .tagtype, or .tabletype declarations.
     auto Sym = cast<MCSymbolWasm>(It.getValue());
     if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_GLOBAL) {
       // .globaltype already handled by emitGlobalVariable for defined
       // variables; here we make sure the types of external wasm globals get
       // written to the file.
       if (Sym->isUndefined())
         getTargetStreamer()->emitGlobalType(Sym);
-    } else if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_EVENT)
-      getTargetStreamer()->emitEventType(Sym);
+    } else if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_TAG)
+      getTargetStreamer()->emitTagType(Sym);
     else if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_TABLE)
       getTargetStreamer()->emitTableType(Sym);
   }
 
   DenseSet<MCSymbol *> InvokeSymbols;
   bool HasAddressTakenFunction = false;
   for (const auto &F : M) {
     if (F.isIntrinsic())

llvm/lib/Target/WebAssembly/WebAssemblyInstrControl.td

 //===----------------------------------------------------------------------===//
 // Exception handling instructions
 //===----------------------------------------------------------------------===//
 
 let Predicates = [HasExceptionHandling] in {
 
 // Throwing an exception: throw / rethrow
 let isTerminator = 1, hasCtrlDep = 1, isBarrier = 1 in {
-defm THROW : I<(outs), (ins event_op:$tag, variable_ops),
-               (outs), (ins event_op:$tag),
+defm THROW : I<(outs), (ins tag_op:$tag, variable_ops),
+               (outs), (ins tag_op:$tag),
                [(WebAssemblythrow (WebAssemblywrapper texternalsym:$tag))],
                "throw   \t$tag", "throw   \t$tag", 0x08>;
 defm RETHROW : NRI<(outs), (ins i32imm:$depth), [], "rethrow \t$depth", 0x09>;
 } // isTerminator = 1, hasCtrlDep = 1, isBarrier = 1
 // The depth argument will be computed in CFGStackify. We set it to 0 here for
 // now.
 def : Pat<(int_wasm_rethrow), (RETHROW 0)>;
 
 // Region within which an exception is caught: try / end_try
 let Uses = [VALUE_STACK], Defs = [VALUE_STACK] in {
 defm TRY     : NRI<(outs), (ins Signature:$sig), [], "try     \t$sig", 0x06>;
 defm END_TRY : NRI<(outs), (ins), [], "end_try", 0x0b>;
 } // Uses = [VALUE_STACK], Defs = [VALUE_STACK]
 
 // Catching an exception: catch / catch_all
 let hasCtrlDep = 1, hasSideEffects = 1 in {
 // Currently 'catch' can only extract an i32, which is sufficient for C++
 // support, but according to the spec 'catch' can extract any number of values
-// based on the event type.
-defm CATCH : I<(outs I32:$dst), (ins event_op:$tag),
-               (outs), (ins event_op:$tag),
+// based on the tag type.
+defm CATCH : I<(outs I32:$dst), (ins tag_op:$tag),
+               (outs), (ins tag_op:$tag),
                [(set I32:$dst,
                  (WebAssemblycatch (WebAssemblywrapper texternalsym:$tag)))],
                "catch   \t$dst, $tag", "catch   \t$tag", 0x07>;
 defm CATCH_ALL : NRI<(outs), (ins), [], "catch_all", 0x19>;
 }
 
 // Delegating an exception: delegate
 let isTerminator = 1, hasCtrlDep = 1, hasSideEffects = 1 in

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

 let OperandType = "OPERAND_OFFSET64" in
 def offset64_op : Operand<i64>;
 
 let OperandType = "OPERAND_P2ALIGN" in {
 def P2Align : Operand<i32> {
   let PrintMethod = "printWebAssemblyP2AlignOperand";
 }
 
-let OperandType = "OPERAND_EVENT" in
-def event_op : Operand<i32>;
+let OperandType = "OPERAND_TAG" in
+def tag_op : Operand<i32>;
 
 } // OperandType = "OPERAND_P2ALIGN"
 
 let OperandType = "OPERAND_SIGNATURE" in
 def Signature : Operand<i32> {
   let PrintMethod = "printWebAssemblySignatureOperand";
 }
 

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

WasmSym->setGlobalType(wasm::WasmGlobalType{
                                       : wasm::WASM_TYPE_I32),
         Mutable});
     return WasmSym;
   }
 
   SmallVector<wasm::ValType, 4> Returns;
   SmallVector<wasm::ValType, 4> Params;
   if (strcmp(Name, "__cpp_exception") == 0) {
-    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_EVENT);
+    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_TAG);
     // We can't confirm its signature index for now because there can be
     // imported exceptions. Set it to be 0 for now.
-    WasmSym->setEventType(
-        {wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION, /* SigIndex */ 0});
+    WasmSym->setTagType({wasm::WASM_TAG_ATTRIBUTE_EXCEPTION, /* SigIndex */ 0});
     // We may have multiple C++ compilation units to be linked together, each of
     // which defines the exception symbol. To resolve them, we declare them as
     // weak.
     WasmSym->setWeak(true);
     WasmSym->setExternal(true);
 
     // All C++ exceptions are assumed to have a single i32 (for wasm32) or i64
     // (for wasm64) param type and void return type. The reaon is, all C++
MCOperand WebAssemblyMCInstLower::lowerSymbolOperand(const MachineOperand &MO,
   if (MO.getOffset() != 0) {
     const auto *WasmSym = cast<MCSymbolWasm>(Sym);
     if (TargetFlags == WebAssemblyII::MO_GOT)
       report_fatal_error("GOT symbol references do not support offsets");
     if (WasmSym->isFunction())
       report_fatal_error("Function addresses with offsets not supported");
     if (WasmSym->isGlobal())
       report_fatal_error("Global indexes with offsets not supported");
-    if (WasmSym->isEvent())
-      report_fatal_error("Event indexes with offsets not supported");
+    if (WasmSym->isTag())
+      report_fatal_error("Tag indexes with offsets not supported");
     if (WasmSym->isTable())
       report_fatal_error("Table indexes with offsets not supported");
 
     Expr = MCBinaryExpr::createAdd(
         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
   }
 
   return MCOperand::createExpr(Expr);

llvm/test/CodeGen/WebAssembly/exception.ll

 declare void @__cxa_end_catch()
 declare void @_ZSt9terminatev()
 declare %struct.Temp* @_ZN4TempD2Ev(%struct.Temp* returned)
 
 attributes #0 = { nounwind }
 attributes #1 = { noreturn }
 
 ; CHECK: __cpp_exception:
-; CHECK: .eventtype  __cpp_exception i32
+; CHECK: .tagtype  __cpp_exception i32

llvm/test/CodeGen/WebAssembly/null-streamer.ll

 define i32 @test(i8* %p)  {
   %n = alloca i32
   call void @llvm.wasm.throw(i32 0, i8* %p)
   call void @g()
   ret i32 0
 }
 
 ; CHECK-DAG: .globaltype
-; CHECK-DAG: .eventtype
+; CHECK-DAG: .tagtype
 ; CHECK-DAG: .functype

llvm/test/MC/WebAssembly/annotations.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+exception-handling < %s | FileCheck %s
 
 # Tests if block/loop/try/catch/end/branch/rethrow instructions are correctly
 # printed with their annotations.
 
   .text
   .section .text.test_annotation,"",@
   .type    test_annotation,@function
 test_annotation:
   .functype   test_annotation () -> ()
-  .eventtype  __cpp_exception i32
+  .tagtype  __cpp_exception i32
   try
   br        0
   catch     __cpp_exception
   block
   br_if     0
   loop
   br_if     1
   end_loop

llvm/test/MC/WebAssembly/basic-assembly.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+reference-types,atomics,+simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
 # Check that it converts to .o without errors, but don't check any output:
 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+reference-types,+atomics,+simd128,+nontrapping-fptoint,+exception-handling -o %t.o < %s
 
 
 empty_func:
     .functype empty_func () -> ()
     end_function
 
 test0:
 # local labels can appear between label and its .functype.
 .Ltest0begin:
     # Test all types:
     .functype   test0 (i32, i64) -> (i32)
-    .eventtype  __cpp_exception i32
+    .tagtype  __cpp_exception i32
     .local      f32, f64, v128, v128
     # Explicit getlocal/setlocal:
     local.get   2
     local.set   2
     # Immediates:
     i32.const   -1
     f64.const   0x1.999999999999ap1
     f32.const   -1.0

 
 # CHECK:           .text
 # CHECK-LABEL: empty_func:
 # CHECK-NEXT:      .functype  empty_func () -> ()
 # CHECK-NEXT:      end_function
 # CHECK-LABEL: test0:
 # CHECK-NEXT:  .Ltest0begin:
 # CHECK-NEXT:      .functype   test0 (i32, i64) -> (i32)
-# CHECK-NEXT:      .eventtype  __cpp_exception i32
+# CHECK-NEXT:      .tagtype  __cpp_exception i32
 # CHECK-NEXT:      .local      f32, f64
 # CHECK-NEXT:      local.get   2
 # CHECK-NEXT:      local.set   2
 # CHECK-NEXT:      i32.const   -1
 # CHECK-NEXT:      f64.const   0x1.999999999999ap1
 # CHECK-NEXT:      f32.const   -0x1p0
 # CHECK-NEXT:      f32.const   -infinity
 # CHECK-NEXT:      f32.const   nan

llvm/test/MC/WebAssembly/tag-section-decoding.ll

 ; RUN: llc -filetype=obj -exception-model=wasm -mattr=+exception-handling %s -o - | obj2yaml | FileCheck %s
 
-; This is a regression test for a decoding bug that happens when an event's
+; This is a regression test for a decoding bug that happens when an tag's
 ; sigindex is greater than 63, so we put 63 dummy functions with different
 ; signatures before the function that contains the 'throw' instruction to make
-; the event's sigindex 64.
+; the tag's sigindex 64.
 
 target triple = "wasm32-unknown-unknown"
 
 declare void @llvm.wasm.throw(i32, i8*)
 
 define i32 @dummy0() {
 entry:
   ret i32 0
entry:
   ret i32 0
 }
 
 define i32 @test_throw(i8* %p) {
   call void @llvm.wasm.throw(i32 0, i8* %p)
   ret i32 0
 }
 
-; Checks to see if the event index is correctly decoded in ULEB128. If it is
+; Checks to see if the tag index is correctly decoded in ULEB128. If it is
 ; decoded with LEB128, 64 will not be correctly decoded. 64 is the smallest
 ; number with which its LEB128 and ULEB128 encodings are different, because its
 ; 7th least significant bit is not 0.
-; CHECK:      - Type:            EVENT
-; CHECK-NEXT:   Events:
+; CHECK:      - Type:            TAG
+; CHECK-NEXT:   Tags:
 ; CHECK-NEXT:     - Index:           0
 ; CHECK-NEXT:       Attribute:       0
 ; CHECK-NEXT:       SigIndex:        64

llvm/test/MC/WebAssembly/tag-section.ll

 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:         ReturnTypes:
 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:         ReturnTypes:      []
 
-; CHECK:        - Type:            EVENT
-; CHECK-NEXT:     Events:
+; CHECK:        - Type:            TAG
+; CHECK-NEXT:     Tags:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Attribute:       0
 ; CHECK-NEXT:         SigIndex:        1
 
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
-; CHECK-NEXT:       - Type:            R_WASM_EVENT_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_TAG_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x6
-; CHECK-NEXT:       - Type:            R_WASM_EVENT_INDEX_LEB
+; CHECK-NEXT:       - Type:            R_WASM_TAG_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x11
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     Version:         2
 ; CHECK-NEXT:     SymbolTable:
 
 ; CHECK:            - Index:           1
-; CHECK-NEXT:         Kind:            EVENT
+; CHECK-NEXT:         Kind:            TAG
 ; CHECK-NEXT:         Name:            __cpp_exception
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:         Event:           0
+; CHECK-NEXT:         Tag:             0
 
-; SEC:          Type: EVENT (0xD)
+; SEC:          Type: TAG (0xD)
 ; SEC-NEXT:     Size: 3
 ; SEC-NEXT:     Offset: 63

llvm/test/ObjectYAML/wasm/event_section.yaml

Signatures:
         ReturnTypes:
           - I32
       - Index:           1
         ParamTypes:
           - I32
         ReturnTypes:      []
   - Type:            FUNCTION
     FunctionTypes:   [ 0 ]
-  - Type:            EVENT
-    Events:
+  - Type:            TAG
+    Tags:
       - Index:           0
         Attribute:       0
         SigIndex:        1
   - Type:            CODE
     Relocations:
-      - Type:            R_WASM_EVENT_INDEX_LEB
+      - Type:            R_WASM_TAG_INDEX_LEB
         Index:           1
         Offset:          0x00000006
       - Type:            10
         Index:           1
         Offset:          0x00000006
     Functions:
       - Index:           0
         Locals:
         Body:            200008808080800041000B
   - Type:            CUSTOM
     Name:            linking
     Version:         2
     SymbolTable:
       - Index:           0
         Kind:            FUNCTION
         Name:            test_throw0
         Flags:           [  ]
         Function:        0
       - Index:           1
-        Kind:            EVENT
+        Kind:            TAG
         Name:            __cpp_exception
         Flags:           [ BINDING_WEAK ]
-        Event:           0
+        Tag:             0
 ...
 
 # CHECK:      --- !WASM
 # CHECK-NEXT: FileHeader:
 # CHECK-NEXT:   Version:         0x1
 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Type:            TYPE
 # CHECK-NEXT:     Signatures:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         ParamTypes:
 # CHECK-NEXT:           - I32
 # CHECK-NEXT:         ReturnTypes:
 # CHECK-NEXT:           - I32
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         ParamTypes:
 # CHECK-NEXT:           - I32
 # CHECK-NEXT:         ReturnTypes:     []
 # CHECK-NEXT:   - Type:            FUNCTION
 # CHECK-NEXT:     FunctionTypes:   [ 0 ]
-# CHECK-NEXT:   - Type:            EVENT
-# CHECK-NEXT:     Events:
+# CHECK-NEXT:   - Type:            TAG
+# CHECK-NEXT:     Tags:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Attribute:       0
 # CHECK-NEXT:         SigIndex:        1
 # CHECK-NEXT:   - Type:            CODE
 # CHECK-NEXT:     Relocations:
-# CHECK-NEXT:       - Type:            R_WASM_EVENT_INDEX_LEB
+# CHECK-NEXT:       - Type:            R_WASM_TAG_INDEX_LEB
 # CHECK-NEXT:         Index:           1
 # CHECK-NEXT:         Offset:          0x6
-# CHECK-NEXT:       - Type:            R_WASM_EVENT_INDEX_LEB
+# CHECK-NEXT:       - Type:            R_WASM_TAG_INDEX_LEB
 # CHECK-NEXT:         Index:           1
 # CHECK-NEXT:         Offset:          0x6
 # CHECK-NEXT:     Functions:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Locals:
 # CHECK-NEXT:         Body:            200008808080800041000B
 # CHECK-NEXT:   - Type:            CUSTOM
 # CHECK-NEXT:     Name:            linking
 # CHECK-NEXT:     Version:         2
 # CHECK-NEXT:     SymbolTable:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Name:            test_throw0
 # CHECK-NEXT:         Flags:           [  ]
 # CHECK-NEXT:         Function:        0
 # CHECK-NEXT:       - Index:           1
-# CHECK-NEXT:         Kind:            EVENT
+# CHECK-NEXT:         Kind:            TAG
 # CHECK-NEXT:         Name:            __cpp_exception
 # CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
-# CHECK-NEXT:         Event:           0
+# CHECK-NEXT:         Tag:             0

llvm/tools/llvm-readobj/WasmDumper.cpp

 using namespace llvm;
 using namespace object;
 
 namespace {
 
 static const EnumEntry<unsigned> WasmSymbolTypes[] = {
 #define ENUM_ENTRY(X)                                                          \
   { #X, wasm::WASM_SYMBOL_TYPE_##X }
-    ENUM_ENTRY(FUNCTION), ENUM_ENTRY(DATA),  ENUM_ENTRY(GLOBAL),
-    ENUM_ENTRY(SECTION),  ENUM_ENTRY(EVENT), ENUM_ENTRY(TABLE),
+    ENUM_ENTRY(FUNCTION), ENUM_ENTRY(DATA), ENUM_ENTRY(GLOBAL),
+    ENUM_ENTRY(SECTION),  ENUM_ENTRY(TAG),  ENUM_ENTRY(TABLE),
 #undef ENUM_ENTRY
 };
 
 static const EnumEntry<uint32_t> WasmSectionTypes[] = {
 #define ENUM_ENTRY(X)                                                          \
   { #X, wasm::WASM_SEC_##X }
     ENUM_ENTRY(CUSTOM),   ENUM_ENTRY(TYPE),      ENUM_ENTRY(IMPORT),
     ENUM_ENTRY(FUNCTION), ENUM_ENTRY(TABLE),     ENUM_ENTRY(MEMORY),
-    ENUM_ENTRY(GLOBAL),   ENUM_ENTRY(EVENT),     ENUM_ENTRY(EXPORT),
+    ENUM_ENTRY(GLOBAL),   ENUM_ENTRY(TAG),       ENUM_ENTRY(EXPORT),
     ENUM_ENTRY(START),    ENUM_ENTRY(ELEM),      ENUM_ENTRY(CODE),
     ENUM_ENTRY(DATA),     ENUM_ENTRY(DATACOUNT),
 #undef ENUM_ENTRY
 };
 
 static const EnumEntry<unsigned> WasmSymbolFlags[] = {
 #define ENUM_ENTRY(X)                                                          \
   { #X, wasm::WASM_SYMBOL_##X }

llvm/tools/obj2yaml/wasm2yaml.cpp

for (const wasm::WasmSymbolInfo &Symbol : Obj.linkingData().SymbolTable) {
       Info.Flags = Symbol.Flags;
       switch (Symbol.Kind) {
       case wasm::WASM_SYMBOL_TYPE_DATA:
         Info.DataRef = Symbol.DataRef;
         break;
       case wasm::WASM_SYMBOL_TYPE_FUNCTION:
       case wasm::WASM_SYMBOL_TYPE_GLOBAL:
       case wasm::WASM_SYMBOL_TYPE_TABLE:
-      case wasm::WASM_SYMBOL_TYPE_EVENT:
+      case wasm::WASM_SYMBOL_TYPE_TAG:
         Info.ElementIndex = Symbol.ElementIndex;
         break;
       case wasm::WASM_SYMBOL_TYPE_SECTION:
         Info.ElementIndex = Symbol.ElementIndex;
         break;
       }
       LinkingSec->SymbolTable.emplace_back(Info);
     }
case wasm::WASM_SEC_IMPORT: {
         switch (Im.Kind) {
         case wasm::WASM_EXTERNAL_FUNCTION:
           Im.SigIndex = Import.SigIndex;
           break;
         case wasm::WASM_EXTERNAL_GLOBAL:
           Im.GlobalImport.Type = Import.Global.Type;
           Im.GlobalImport.Mutable = Import.Global.Mutable;
           break;
-        case wasm::WASM_EXTERNAL_EVENT:
-          Im.EventImport.Attribute = Import.Event.Attribute;
-          Im.EventImport.SigIndex = Import.Event.SigIndex;
+        case wasm::WASM_EXTERNAL_TAG:
+          Im.TagImport.Attribute = Import.Tag.Attribute;
+          Im.TagImport.SigIndex = Import.Tag.SigIndex;
           break;
         case wasm::WASM_EXTERNAL_TABLE:
           // FIXME: Currently we always output an index of 0 for any imported
           // table.
           Im.TableImport = makeTable(0, Import.Table);
           break;
         case wasm::WASM_EXTERNAL_MEMORY:
           Im.Memory = makeLimits(Import.Memory);
for (const auto &Sec : Obj.sections()) {
     case wasm::WASM_SEC_MEMORY: {
       auto MemorySec = std::make_unique<WasmYAML::MemorySection>();
       for (const wasm::WasmLimits &Memory : Obj.memories()) {
         MemorySec->Memories.push_back(makeLimits(Memory));
       }
       S = std::move(MemorySec);
       break;
     }
-    case wasm::WASM_SEC_EVENT: {
-      auto EventSec = std::make_unique<WasmYAML::EventSection>();
-      for (auto &Event : Obj.events()) {
-        WasmYAML::Event E;
-        E.Index = Event.Index;
-        E.Attribute = Event.Type.Attribute;
-        E.SigIndex = Event.Type.SigIndex;
-        EventSec->Events.push_back(E);
+    case wasm::WASM_SEC_TAG: {
+      auto TagSec = std::make_unique<WasmYAML::TagSection>();
+      for (auto &Tag : Obj.tags()) {
+        WasmYAML::Tag T;
+        T.Index = Tag.Index;
+        T.Attribute = Tag.Type.Attribute;
+        T.SigIndex = Tag.Type.SigIndex;
+        TagSec->Tags.push_back(T);
       }
-      S = std::move(EventSec);
+      S = std::move(TagSec);
       break;
     }
     case wasm::WASM_SEC_GLOBAL: {
       auto GlobalSec = std::make_unique<WasmYAML::GlobalSection>();
       for (auto &Global : Obj.globals()) {
         WasmYAML::Global G;
         G.Index = Global.Index;
         G.Type = Global.Type.Type;