[WebAssembly] Make signature index not a part of EventType

[aheejin]

Summary

Previously EventType contained SigIndex as its member based on the
spec, but signature indieces can change after linking, which makes
EventType not a constant property of an event. This patch takes
SigIndex out of EventType and treat it similarly with function
types and makes SigIndex a property that any type can optionally
possess.

This is not a spec change; this only affects yaml tests and
binary file results do not change after this patch.

Companion to D54874,

[sbc100]

include/llvm/BinaryFormat/Wasm.h

88

My initial reaction is that we should leave this as is.

The linker shouldn't be modifying the input EventTypes but instead creating a new set of output eventtypes based on the input ones. At least that how it makes sense to me. I will take a look at the lld side change and see if I can make some suggestions there.

[aheejin]

include/llvm/BinaryFormat/Wasm.h

88

You mean we should create separate set of everything, like WasmEventType, WasmGlobalType, ... and copy all data from the old structures to the new structures in the linker to resolve this? Wouldn't that be too much duplication? We already have separate WasmEventType and WasmGlobalType, ... in WasmObjectWriter side (lib/MC). I would want to avoid adding another set of all these, just to resolve signature index. And if we only add WasmEventType for the output type in the linker, that would look inconsistent as well.

And the original reason SigIndex was a part of WasmEventType was just the spec has a table structured that way, which is not very important reason. (This CL does not change the binary spec itself)

And the other thing is, taking SigIndex out of a certain type (here WasmEventType) might be more extensible way, for when we have multi-value globals. In that case every type can have an optional SigIndex seems a easier way to handle things.

[sbc100]

include/llvm/BinaryFormat/Wasm.h

88

I think so yes. If you look at the InputGlobal class in lld today it looks like already makes copy of the InputGlobal. I imagine the InputEvent class would have the WasmEvent in it. These object do not need to be the exact objects that get written to the output. It happens that for InputGlobal we do end up calling writeGlobal with that as the input, but for events you could do something like this:

e.g.

for (const InputEvent *E : InputEvent)  {
  WasmEvent NewEv = *E->Event;
  // Replace the input sig index with the output sig index.
  NewEv->Type->SigIndex = lookupType(E->Type>SigIndex);
   writeEvent(OS, NewEv); 
}

92

I also think it nice if you can get the signature from the WasmEvent stuct. Rather than separating the events from their signatures. Seems to fit better with the binary representation.

[dschuff]

include/llvm/BinaryFormat/Wasm.h

92

I don't know that I have an opinion about whether we have a duplication like in InputGlobal, but I do think that however we handle signatures for functions should be the same as what we do for events. Globals are different because they have a wasm value type instead of a signature, but @aheejin pointed out that with the multi-value proposal they will also have a signature in the same index space. So the way we handle the signatures should be uniform (which I guess is the point of this CL...)

I think part of the confusion here is that this file has some code that is intended to directly model the binary format (which is why WasmEventType had the SigIndex field in the first place) and some that's intended to be useful at a slightly higher level for MC and the linker. e.g. why we have WasmSignature* in some places and signature indices in others.

[dschuff]

include/llvm/BinaryFormat/Wasm.h

85

Now that this structure no longer directly reflects the binary format, it might make sense to just remove it since there's no need for a 1-element structure. I still think that FooKind -style nomenclature like that used elsewhere in LLVM is more readable (since this models "kinds" of events, one of which is exception). I actually think I'd like to rename attribute to kind in the spec itself, but that's obviously a separate thing.

[aheejin]

include/llvm/BinaryFormat/Wasm.h

88

I'm not sure which option you are suggesting.

1. Create a new set of WasmGlobal, WasmEvent and other similar structures in lld side
2. Create only a new WasmEvent class in lld side (which I think is inconsistent)
3. Use the current [[ https://github.com/llvm-mirror/llvm/blob/0833f2640ef8874438edb516785b58faae6acd38/include/llvm/BinaryFormat/Wasm.h#L91-L95 | wasm::WasmEvent ]] defined in include/BinaryFormat/Wasm.h, but just create a new instance of this

I thought you were suggesting either 1 or 2 and now you sound like 3.

And currently, the InputGlobal class and its constructor looks like this:

class InputGlobal {                                                              
public:                                                                          
  InputGlobal(const WasmGlobal &G, ObjFile *F)                                   
      : File(F), Global(G), Live(!Config->GcSections) {}
  ...                                                                                                                                                  
  WasmGlobal Global;                                                             
  ...                                    
};

By the way, is the member variable WasmGlobal Global not being a reference but a value, so that we get to copy WasmGlobal in the constructor, intentional? I'm wondering if that was intentionally by value to allow modification in cases like this.

[sbc100]

include/llvm/BinaryFormat/Wasm.h

88

I think I'm advocating for 3, which I believe matches what we do with Globals and Imports, etc today.

The fact that the WasmGlobal is, I think, so that createSyntheticSymbols() can pass a stack allocated new global and have it copied.

In the case of Event I think its reasonable to use a const reference to the Event in the input object here. The idea is that this member represents the item in the input file, so it cannot be written as-is to the output, a new event based on the input event is what should be written. The input event won't have the correct indexes etc within it.

Remember that for Globals and Events we normally/currently have exactly 1 of each in the link. (stack_pointer and cpp_exception). So there is really no need to try to avoid copying them at this point.

[dschuff]

include/llvm/BinaryFormat/Wasm.h

88

I think in the future we may have more globals (even aside from the special known ones such as stack pointer, memory_base, table_base): there may be references once we have support for reference types, and there may be languages other than C that either use LLVM or want to produce LLVM-compatible object files. So I think it makes sense for the linker and object file code to have the capability of treating them in a generic way. I guess that doesn't necessarily mean we can't copy them (e.g. unlike functions, but like events, they will be small) but we should at least consider how we want to handle linking for them even if we don't use it in clang for now.

[sbc100]

include/llvm/BinaryFormat/Wasm.h

88

I agree. Actually we don't copy them right now in order to gain mutability, but simply to handle being passed as stack allocated synthetic global. It would be easy enough to change the ownership model here. I don't think it relates to this change actually.

[aheejin]

include/llvm/BinaryFormat/Wasm.h

88

@sbc100 In the initial code example you suggested:

for (const InputEvent *E : InputEvent)  {
  WasmEvent NewEv = *E->Event;
  // Replace the input sig index with the output sig index.
  NewEv->Type->SigIndex = lookupType(E->Type>SigIndex);
   writeEvent(OS, NewEv); 
}

InputEvent can't be const anymore because now we are modifying WasmEvent inside it. And also existing InputGlobal::getType returns const WasmGlobalType&, which InputEvent mimics in D54875. If we want to change something inside InputEvent after it is created, this method can't be const anymore. That's fine with me, but InputEvent::getType() returns WasmEventType& while InputGlobal::getType() returns const WasmGlobalType& seems inconsistent.

And the reason I asked why those member variables are by value and not reference is not really relevant to whether we should take out SigIndex out of a certain type (e.g. EventType). I agree they are separate things. I still think generalizing SigIndex so that every type can optionally have one is more extensible in face of multi-value globals.

[sbc100]

include/llvm/BinaryFormat/Wasm.h

88

Sorry I don't understand. The above code should not be modifying the InputEvent. It modifies NewEv which is on the stack right? NewEv is the output event where InputEvent is the input event which we should not change. Maybe I made a mistake in my code?

[aheejin]

include/llvm/BinaryFormat/Wasm.h

88

I think I was confused too. To sum up,

1. In case we store WasmEvent member variable as a value like WasmGlobal:

The code should look like this

WasmEvent NewEv = E->Event;

In this case it is copying, so we can modify NewEv.
or this

WasmEvent *NewEv = &E->Event;

In this case, even if it compiles, we are semantically modifying something that's within a const InputEvent.

2. In case we store WasmEvent member variable as a const reference, as you suggested above (which is inconsistent with WasmGlobal):

In this case we should copy it like this, otherwise it wouldn't compile:

WasmEvent NewEv = E->Event;

Anyway, do you think taking out SigIndex out of WasmEventType is still not a good idea?

[aheejin]

Ping. So the decision points are

1. Whether SigIndex should be in or out of WasmEventType?
   1. If SigIndex should be out of WasmEventType, should there even be WasmEventType anymore? Because then there's only Attribute left.
2. It seems to be people don't like the term Attribute. Should we change it to Kind or something? We can change the spec text, because it's not set in stone or anything.

[sbc100]

In D54873#1315289, @aheejin wrote:

Ping. So the decision points are

1. Whether SigIndex should be in or out of WasmEventType?
   1. If SigIndex should be out of WasmEventType, should there even be WasmEventType anymore? Because then there's only Attribute left.
2. It seems to be people don't like the term Attribute. Should we change it to Kind or something? We can change the spec text, because it's not set in stone or anything.

Seems like we should keep the two member WasmEventType. We need this for specifying the events themselves, and also for importing events. It seems like this matches WasmGlobalType,

Attrbiute does seem like a strange name, but maybe there is reason that was chosen in spec currently?

[aheejin]

In D54873#1315295, @sbc100 wrote:

In D54873#1315289, @aheejin wrote:

Ping. So the decision points are

1. Whether SigIndex should be in or out of WasmEventType?
   1. If SigIndex should be out of WasmEventType, should there even be WasmEventType anymore? Because then there's only Attribute left.
2. It seems to be people don't like the term Attribute. Should we change it to Kind or something? We can change the spec text, because it's not set in stone or anything.

Seems like we should keep the two member WasmEventType. We need this for specifying the events themselves, and also for importing events. It seems like this matches WasmGlobalType,

I'm not really sure what this means. Do you mean we should keep SigIndex as a part of WasmEventType and drop this CL? And why do we need this for specifying events themselves and for importing events? I don't think I understand what 'this' is actually. And why would it match WasmGlobalType? And do you also suggest, when we get to add multi-value globals later, we should insert SigIndex as a part of WasmGlobalType too?

Attrbiute does seem like a strange name, but maybe there is reason that was chosen in spec currently?

I don't know. Karl chose it, and apparently I can't ask him the reason now... I'm fine with the name, but I heard some complaints about it. If it was not you maybe it was @dschuff. Not that I want to change that myself, but I was just suggesting that it's possible to change the spec text also because it's not fixed yet.

[sbc100]

In D54873#1315302, @aheejin wrote:

In D54873#1315295, @sbc100 wrote:

In D54873#1315289, @aheejin wrote:

Ping. So the decision points are

1. Whether SigIndex should be in or out of WasmEventType?
   1. If SigIndex should be out of WasmEventType, should there even be WasmEventType anymore? Because then there's only Attribute left.
2. It seems to be people don't like the term Attribute. Should we change it to Kind or something? We can change the spec text, because it's not set in stone or anything.

Seems like we should keep the two member WasmEventType. We need this for specifying the events themselves, and also for importing events. It seems like this matches WasmGlobalType,

I'm not really sure what this means. Do you mean we should keep SigIndex as a part of WasmEventType and drop this CL?

Yes

And why do we need this for specifying events themselves and for importing events?

I mean event imports need to specify their "type" and non-imported events also need to specify their "type". And in both cases the type needs to include the signature. So I think we should have a unified "eventType" that includes the signature index.

I don't think I understand what 'this' is actually. And why would it match WasmGlobalType? And do you also suggest, when we get to add multi-value globals later, we should insert SigIndex as a part of WasmGlobalType too?

Attrbiute does seem like a strange name, but maybe there is reason that was chosen in spec currently?

I don't know. Karl chose it, and apparently I can't ask him the reason now... I'm fine with the name, but I heard some complaints about it. If it was not you maybe it was @dschuff. Not that I want to change that myself, but I was just suggesting that it's possible to change the spec text also because it's not fixed yet.

[aheejin]

In D54873#1316963, @sbc100 wrote:

And why do we need this for specifying events themselves and for importing events?

I mean event imports need to specify their "type" and non-imported events also need to specify their "type". And in both cases the type needs to include the signature. So I think we should have a unified "eventType" that includes the signature index.

I can drop this CL, but I still don't understand what you meant by this part. Currently imported exception's sigindex is handled fine. The below is obj2yaml's result if I don't define the __cpp_exception symbol:

- Type:            IMPORT                                                      
  Imports:                                                                     
    ...                                    
    - Module:          env                                                     
      Field:           __cpp_exception                                         
      Kind:            EVENT                                                   
      SigIndex:        1                                                       
      EventAttribute:  0

As you see in WasmImport definition in this CL, SigIndex is now out of union and every type can set it optionally, so there's no problem for events having sigindex there.

struct WasmImport {                                                              
  StringRef Module;                                                              
  StringRef Field;                                                               
  uint8_t Kind;                                                                  
  uint32_t SigIndex;                                                             
  union {                                                                        
    WasmGlobalType Global;                                                       
    WasmTable Table;                                                             
    WasmLimits Memory;                                                           
    WasmEventType Event;                                                         
  };                                                                             
};

[sbc100]

In D54873#1317509, @aheejin wrote:

In D54873#1316963, @sbc100 wrote:

And why do we need this for specifying events themselves and for importing events?

I mean event imports need to specify their "type" and non-imported events also need to specify their "type". And in both cases the type needs to include the signature. So I think we should have a unified "eventType" that includes the signature index.

I can drop this CL, but I still don't understand what you meant by this part. Currently imported exception's sigindex is handled fine. The below is obj2yaml's result if I don't define the __cpp_exception symbol:

- Type:            IMPORT                                                      
  Imports:                                                                     
    ...                                    
    - Module:          env                                                     
      Field:           __cpp_exception                                         
      Kind:            EVENT                                                   
      SigIndex:        1                                                       
      EventAttribute:  0

As you see in WasmImport definition in this CL, SigIndex is now out of union and every type can set it optionally, so there's no problem for events having sigindex there.

struct WasmImport {                                                              
  StringRef Module;                                                              
  StringRef Field;                                                               
  uint8_t Kind;                                                                  
  uint32_t SigIndex;                                                             
  union {                                                                        
    WasmGlobalType Global;                                                       
    WasmTable Table;                                                             
    WasmLimits Memory;                                                           
    WasmEventType Event;                                                         
  };                                                                             
};

But what about non-imported events? They need signature too right?

[aheejin]

Yes in that case it's represented like sigindex of functions.

- Type:            FUNCTION                                                    
  FunctionTypes:   [ 0, 0 ]                                                    
- Type:            EVENT                                                       
  EventTypes:      [ 1 ]                   // here                                        
  Events:                                                 
    - Index:           0                                                       
      Attribute:       0

[sbc100]

In D54873#1317523, @aheejin wrote:

Yes in that case it's represented like sigindex of functions.

- Type:            FUNCTION                                                    
  FunctionTypes:   [ 0, 0 ]                                                    
- Type:            EVENT                                                       
  EventTypes:      [ 1 ]                   // here                                        
  Events:                                                 
    - Index:           0                                                       
      Attribute:       0

So I guess my point is that its cleaner to keep the signature as part of the type so it can be specified the same in imports as in non-imports.
And the original reason for this CL, which was to make the signature mutable for inputs to lld is no longer an issues, so I don't see any advantage to landing this CL now. But I could still be missing something?

[aheejin]

No, I don't feel strong about this either. I just wanted to say this CL does not lose any sigindex info both in import and non-import cases, because you sounded like otherwise.

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.
   uint32_t Attribute;
-  uint32_t SigIndex;
 };
 
 struct WasmEvent {
   uint32_t Index;
   WasmEventType Type;
   StringRef SymbolName; // from the "linking" section
 };
 
 struct WasmImport {
   StringRef Module;
   StringRef Field;
   uint8_t Kind;
-  union {
-    uint32_t SigIndex;
+  union {
     WasmGlobalType Global;
     WasmTable Table;
     WasmLimits Memory;
     WasmEventType Event;
   };
 };
 
 struct WasmLocalDecl {
inline bool operator==(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
   return LHS.Type == RHS.Type && LHS.Mutable == RHS.Mutable;
 }
 
 inline bool operator!=(const WasmGlobalType &LHS, const WasmGlobalType &RHS) {
   return !(LHS == RHS);
 }
 
 inline bool operator==(const WasmEventType &LHS, const WasmEventType &RHS) {
-  return LHS.Attribute == RHS.Attribute && LHS.SigIndex == RHS.SigIndex;
+  return LHS.Attribute == RHS.Attribute;
 }
 
 inline bool operator!=(const WasmEventType &LHS, const WasmEventType &RHS) {
   return !(LHS == RHS);
 }
 
 std::string toString(wasm::WasmSymbolType type);
 std::string relocTypetoString(uint32_t type);
 
 } // end namespace wasm
 } // end namespace llvm
 
 #endif

include/llvm/Object/Wasm.h

 #include <vector>
 
 namespace llvm {
 namespace object {
 
 class WasmSymbol {
 public:
   WasmSymbol(const wasm::WasmSymbolInfo &Info,
-             const wasm::WasmSignature *FunctionType,
              const wasm::WasmGlobalType *GlobalType,
-             const wasm::WasmEventType *EventType)
-      : Info(Info), FunctionType(FunctionType), GlobalType(GlobalType),
-        EventType(EventType) {}
+             const wasm::WasmEventType *EventType,
+             const wasm::WasmSignature *Signature)
+      : Info(Info), GlobalType(GlobalType), EventType(EventType),
+        Signature(Signature) {}
 
   const wasm::WasmSymbolInfo &Info;
-  const wasm::WasmSignature *FunctionType;
   const wasm::WasmGlobalType *GlobalType;
   const wasm::WasmEventType *EventType;
+  const wasm::WasmSignature *Signature;
 
   bool isTypeFunction() const {
     return Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION;
   }
 
   bool isTypeData() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA; }
 
   bool isTypeGlobal() const {
public:
   const WasmSection &getWasmSection(const SectionRef &Section) const;
   const wasm::WasmRelocation &getWasmRelocation(const RelocationRef &Ref) const;
 
   static bool classof(const Binary *v) { return v->isWasm(); }
 
   const wasm::WasmDylinkInfo &dylinkInfo() const { return DylinkInfo; }
   ArrayRef<wasm::WasmSignature> types() const { return Signatures; }
   ArrayRef<uint32_t> functionTypes() const { return FunctionTypes; }
+  ArrayRef<uint32_t> eventTypes() const { return EventTypes; }
   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::WasmExport> exports() const { return Exports; }
   ArrayRef<WasmSymbol> syms() const { return Symbols; }
   const wasm::WasmLinkingData &linkingData() const { return LinkingData; }
private:
   Error parseLinkingSectionComdat(ReadContext &Ctx);
   Error parseRelocSection(StringRef Name, ReadContext &Ctx);
 
   wasm::WasmObjectHeader Header;
   std::vector<WasmSection> Sections;
   wasm::WasmDylinkInfo DylinkInfo;
   std::vector<wasm::WasmSignature> Signatures;
   std::vector<uint32_t> FunctionTypes;
+  std::vector<uint32_t> EventTypes;
   std::vector<wasm::WasmTable> Tables;
   std::vector<wasm::WasmLimits> Memories;
   std::vector<wasm::WasmGlobal> Globals;
   std::vector<wasm::WasmEvent> Events;
   std::vector<wasm::WasmImport> Imports;
   std::vector<wasm::WasmExport> Exports;
   std::vector<wasm::WasmElemSegment> ElemSegments;
   std::vector<WasmSegment> DataSegments;

include/llvm/ObjectYAML/WasmYAML.h

struct Global {
   ValueType Type;
   bool Mutable;
   wasm::WasmInitExpr InitExpr;
 };
 
 struct Event {
   uint32_t Index;
   uint32_t Attribute;
-  uint32_t SigIndex;
 };
 
 struct Import {
   StringRef Module;
   StringRef Field;
   ExportKind Kind;
-  union {
-    uint32_t SigIndex;
+  union {
     Global GlobalImport;
     Table TableImport;
     Limits Memory;
     Event EventImport;
   };
 };
 
 struct LocalDecl {

 
 struct EventSection : Section {
   EventSection() : Section(wasm::WASM_SEC_EVENT) {}
 
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_EVENT;
   }
 
+  std::vector<uint32_t> EventTypes;
   std::vector<Event> Events;
 };
 
 struct ExportSection : Section {
   ExportSection() : Section(wasm::WASM_SEC_EXPORT) {}
 
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_EXPORT;

lib/MC/WasmObjectWriter.cpp

 };
 
 // A wasm global to be written into the global section.
 struct WasmGlobal {
   wasm::WasmGlobalType Type;
   uint64_t InitialValue;
 };
 
+// A wasm event to be written into the event section.
+struct WasmEvent {
+  wasm::WasmEventType Type;
+  uint32_t SigIndex;
+};
+
 // Information about a single item which is part of a COMDAT.  For each data
 // segment or function which is in the COMDAT, there is a corresponding
 // WasmComdatEntry.
 struct WasmComdatEntry {
   unsigned Kind;
   uint32_t Index;
 };
 
void writeImportSection(ArrayRef<wasm::WasmImport> Imports, uint32_t DataSize,
                           uint32_t NumElements);
   void writeFunctionSection(ArrayRef<WasmFunction> Functions);
   void writeGlobalSection();
   void writeExportSection(ArrayRef<wasm::WasmExport> Exports);
   void writeElemSection(ArrayRef<uint32_t> TableElems);
   void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         ArrayRef<WasmFunction> Functions);
   void writeDataSection();
-  void writeEventSection(ArrayRef<wasm::WasmEventType> Events);
+  void writeEventSection(ArrayRef<WasmEvent> Events);
   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 writeCustomSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
   void writeCustomRelocSections();
case wasm::WASM_EXTERNAL_MEMORY:
       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);
+      encodeULEB128(Import.SigIndex, W.OS);
       break;
     default:
       llvm_unreachable("unsupported import kind");
     }
   }
 
   endSection(Section);
 }
for (const WasmGlobal &Global : Globals) {
     W.OS << char(wasm::WASM_OPCODE_I32_CONST);
     encodeSLEB128(Global.InitialValue, W.OS);
     W.OS << char(wasm::WASM_OPCODE_END);
   }
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeEventSection(ArrayRef<wasm::WasmEventType> Events) {
+void WasmObjectWriter::writeEventSection(ArrayRef<WasmEvent> Events) {
   if (Events.empty())
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_EVENT);
 
   encodeULEB128(Events.size(), W.OS);
-  for (const wasm::WasmEventType &Event : Events) {
-    encodeULEB128(Event.Attribute, W.OS);
+  for (const WasmEvent &Event : Events) {
+    encodeULEB128(Event.Type.Attribute, W.OS);
     encodeULEB128(Event.SigIndex, W.OS);
   }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeExportSection(ArrayRef<wasm::WasmExport> Exports) {
   if (Exports.empty())
uint64_t WasmObjectWriter::writeObject(MCAssembler &Asm,
   LLVM_DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
   MCContext &Ctx = Asm.getContext();
 
   // 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<WasmEvent, 1> Events;
   SmallVector<wasm::WasmSymbolInfo, 4> SymbolInfos;
   SmallVector<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
   std::map<StringRef, std::vector<WasmComdatEntry>> Comdats;
   uint32_t DataSize = 0;
 
   // For now, always emit the memory import, since loads and stores are not
   // valid without it. In the future, we could perhaps be more clever and omit
   // it if there are no loads or stores.
if (!WS.isDefined() && !WS.isComdat()) {
         if (WS.isWeak())
           report_fatal_error("undefined event symbol cannot be weak");
 
         wasm::WasmImport Import;
         Import.Module = WS.getModuleName();
         Import.Field = WS.getName();
         Import.Kind = wasm::WASM_EXTERNAL_EVENT;
         Import.Event.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION;
-        Import.Event.SigIndex = getEventType(WS);
+        Import.SigIndex = getEventType(WS);
         Imports.push_back(Import);
         WasmIndices[&WS] = NumEventImports++;
       }
     }
   }
 
   // Populate DataSegments and CustomSections, which must be done before
   // populating DataLocations.
if (WS.isFunction()) {
       LLVM_DEBUG(dbgs() << "  -> global index: "
                         << WasmIndices.find(&WS)->second << "\n");
 
     } else if (WS.isEvent()) {
       // C++ exception symbol (__cpp_exception)
       unsigned Index;
       if (WS.isDefined()) {
         Index = NumEventImports + Events.size();
-        wasm::WasmEventType Event;
+        WasmEvent Event;
         Event.SigIndex = getEventType(WS);
-        Event.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION;
+        Event.Type.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION;
         WasmIndices[&WS] = Index;
         Events.push_back(Event);
       } else {
         // An import; the index was assigned above.
         Index = WasmIndices.find(&WS)->second;
       }
       LLVM_DEBUG(dbgs() << "  -> event index: " << WasmIndices.find(&WS)->second
                         << "\n");

lib/Object/WasmObjectFile.cpp

for (auto &I : Imports) {
     else if (I.Kind == wasm::WASM_EXTERNAL_GLOBAL)
       ImportedGlobals.emplace_back(&I);
     else if (I.Kind == wasm::WASM_EXTERNAL_EVENT)
       ImportedEvents.emplace_back(&I);
   }
 
   while (Count--) {
     wasm::WasmSymbolInfo Info;
-    const wasm::WasmSignature *FunctionType = nullptr;
+    const wasm::WasmSignature *Signature = nullptr;
     const wasm::WasmGlobalType *GlobalType = nullptr;
     const wasm::WasmEventType *EventType = 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);
       if (!isValidFunctionIndex(Info.ElementIndex) ||
           IsDefined != isDefinedFunctionIndex(Info.ElementIndex))
         return make_error<GenericBinaryError>("invalid function symbol index",
                                               object_error::parse_failed);
       if (IsDefined) {
         Info.Name = readString(Ctx);
         unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
-        FunctionType = &Signatures[FunctionTypes[FuncIndex]];
+        Signature = &Signatures[FunctionTypes[FuncIndex]];
         wasm::WasmFunction &Function = Functions[FuncIndex];
         if (Function.SymbolName.empty())
           Function.SymbolName = Info.Name;
       } else {
         wasm::WasmImport &Import = *ImportedFunctions[Info.ElementIndex];
-        FunctionType = &Signatures[Import.SigIndex];
+        Signature = &Signatures[Import.SigIndex];
         Info.Name = Import.Field;
         Info.Module = Import.Module;
       }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_GLOBAL:
       Info.ElementIndex = readVaruint32(Ctx);
       if (!isValidGlobalIndex(Info.ElementIndex) ||
case wasm::WASM_SYMBOL_TYPE_EVENT: {
                                               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;
+        Signature = &Signatures[EventTypes[EventIndex]];
         wasm::WasmEvent &Event = Events[EventIndex];
         EventType = &Event.Type;
         if (Event.SymbolName.empty())
           Event.SymbolName = Info.Name;
 
       } else {
         wasm::WasmImport &Import = *ImportedEvents[Info.ElementIndex];
+        Signature = &Signatures[Import.SigIndex];
         EventType = &Import.Event;
         Info.Name = Import.Field;
       }
       break;
     }
 
     default:
       return make_error<GenericBinaryError>("Invalid symbol type",
                                             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(), FunctionType,
-                         GlobalType, EventType);
+    Symbols.emplace_back(LinkingData.SymbolTable.back(),
+                         GlobalType, EventType, Signature);
     LLVM_DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
   }
 
   return Error::success();
 }
 
 Error WasmObjectFile::parseLinkingSectionComdat(ReadContext &Ctx) {
   uint32_t ComdatCount = readVaruint32(Ctx);
case wasm::WASM_EXTERNAL_TABLE:
       Im.Table = readTable(Ctx);
       if (Im.Table.ElemType != wasm::WASM_TYPE_ANYFUNC)
         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);
+      Im.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)
return make_error<GenericBinaryError>("Global section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseEventSection(ReadContext &Ctx) {
   EventSection = Sections.size();
   uint32_t Count = readVarint32(Ctx);
   Events.reserve(Count);
+  EventTypes.reserve(Count);
+  uint32_t NumTypes = Signatures.size();
   while (Count--) {
     wasm::WasmEvent Event;
     Event.Index = NumImportedEvents + Events.size();
     Event.Type.Attribute = readVaruint32(Ctx);
-    Event.Type.SigIndex = readVarint32(Ctx);
+    uint32_t Type = readVarint32(Ctx);
+    if (Type >= NumTypes)
+      return make_error<GenericBinaryError>("Invalid function type",
+                                            object_error::parse_failed);
     Events.push_back(Event);
+    EventTypes.push_back(Type);
   }
 
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("Event section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 

lib/ObjectYAML/WasmYAML.cpp

 
 static void sectionMapping(IO &IO, WasmYAML::GlobalSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Globals", Section.Globals);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::EventSection &Section) {
   commonSectionMapping(IO, Section);
+  IO.mapOptional("EventTypes", Section.EventTypes);
   IO.mapOptional("Events", Section.Events);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::ExportSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Exports", Section.Exports);
 }
 
void MappingTraits<WasmYAML::Import>::mapping(IO &IO,
   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("SigIndex", Import.SigIndex);
     IO.mapRequired("EventAttribute", Import.EventImport.Attribute);
-    IO.mapRequired("EventSigIndex", Import.EventImport.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");
   }
 }
void MappingTraits<WasmYAML::SymbolInfo>::mapping(IO &IO,
   } 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 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);
 #undef BCase

lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

WasmSym->setGlobalType(wasm::WasmGlobalType{
         true});
     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);
-    // 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->setEventType({wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION});
     // 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++

test/MC/WebAssembly/event-section.ll

 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ReturnType:      NORESULT
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:           - I32
 
 ; CHECK:        - Type:            EVENT
+; CHECK-NEXT:     EventTypes:      [ 1 ]
 ; CHECK-NEXT:     Events:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Attribute:       0
-; CHECK-NEXT:         SigIndex:        1
 
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000006
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB
 ; CHECK-NEXT:         Index:           1

test/ObjectYAML/wasm/event_section.yaml

Signatures:
           - I32
       - Index:           1
         ReturnType:      NORESULT
         ParamTypes:
           - I32
   - Type:            FUNCTION
     FunctionTypes:   [ 0 ]
   - Type:            EVENT
+    EventTypes:      [ 1 ]
     Events:
       - Index:           0
         Attribute:       0
-        SigIndex:        1
   - Type:            CODE
     Relocations:
       - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB
         Index:           1
         Offset:          0x00000006
     Functions:
       - Index:           0
         Locals:

 # CHECK-NEXT:           - I32
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         ReturnType:      NORESULT
 # CHECK-NEXT:         ParamTypes:
 # CHECK-NEXT:           - I32
 # CHECK-NEXT:   - Type:            FUNCTION
 # CHECK-NEXT:     FunctionTypes:   [ 0 ]
 # CHECK-NEXT:   - Type:            EVENT
+# CHECK-NEXT:     EventTypes:      [ 1 ]
 # CHECK-NEXT:     Events:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Attribute:       0
-# CHECK-NEXT:         SigIndex:        1
 # CHECK-NEXT:   - Type:            CODE
 # CHECK-NEXT:     Relocations:
 # CHECK-NEXT:       - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB
 # CHECK-NEXT:         Index:           1
 # CHECK-NEXT:         Offset:          0x00000006
 # CHECK-NEXT:     Functions:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Locals:

tools/obj2yaml/wasm2yaml.cpp

case wasm::WASM_SEC_IMPORT: {
           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;
+          Im.SigIndex = Import.SigIndex;
           break;
         case wasm::WASM_EXTERNAL_TABLE:
           Im.TableImport = make_table(Import.Table);
           break;
         case wasm::WASM_EXTERNAL_MEMORY:
           Im.Memory = make_limits(Import.Memory);
           break;
         }
case wasm::WASM_SEC_GLOBAL: {
         G.InitExpr = Global.InitExpr;
         GlobalSec->Globals.push_back(G);
       }
       S = std::move(GlobalSec);
       break;
     }
     case wasm::WASM_SEC_EVENT: {
       auto EventSec = make_unique<WasmYAML::EventSection>();
+      for (const auto &Func : Obj.eventTypes()) {
+        EventSec->EventTypes.push_back(Func);
+      }
       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);
       }
       S = std::move(EventSec);
       break;
     }
     case wasm::WASM_SEC_START: {
       auto StartSec = make_unique<WasmYAML::StartSection>();
       StartSec->StartFunction = Obj.startFunction();

tools/yaml2obj/yaml2wasm.cpp

case wasm::WASM_EXTERNAL_FUNCTION:
       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);
+      writeUint32(OS, Import.SigIndex);
       NumImportedGlobals++;
       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);
int WasmWriter::writeSectionContent(raw_ostream &OS,
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::EventSection &Section) {
   encodeULEB128(Section.Events.size(), OS);
   uint32_t ExpectedIndex = NumImportedEvents;
-  for (auto &Event : Section.Events) {
+  assert(Section.EventTypes.size() == Section.Events.size() &&
+         "EventType size and Events size are different");
+  for (unsigned I = 0; I < Section.Events.size(); ++I) {
+    const auto &Event = Section.Events[I];
     if (Event.Index != ExpectedIndex) {
       errs() << "Unexpected event index: " << Event.Index << "\n";
       return 1;
     }
-    ++ExpectedIndex;
     encodeULEB128(Event.Attribute, OS);
-    encodeULEB128(Event.SigIndex, OS);
+    encodeULEB128(Section.EventTypes[I], OS);
   }
   return 0;
 }
 
 int WasmWriter::writeSectionContent(raw_ostream &OS,
                                     WasmYAML::ElemSection &Section) {
   encodeULEB128(Section.Segments.size(), OS);
   for (auto &Segment : Section.Segments) {