Stack switching proposal support

src/wasm-builder.h

@@ -1194,61 +1194,17 @@ class Builder {
     ret->finalize(&wasm);
     return ret;
   }
-  template<typename ResumeOrResumeThrow>
-  std::vector<Type> computeResumeTableSentTypes(ResumeOrResumeThrow* curr) {
-    static_assert(std::is_base_of<Resume, ResumeOrResumeThrow>::value ||
-                  std::is_base_of<ResumeThrow, ResumeOrResumeThrow>::value);
-    assert(curr->handlerBlocks.size() == curr->handlerTags.size());
-
-    // Let $tag be a tag with type [tgp*] -> [tgr*]. Let $ct be a continuation
-    // type (cont $ft), where $ft is [ctp*] -> [ctr*]. Then an instruction
-    // (resume $ct ... (tag $tag $block) ... ) causes $block to receive values
-    // of the following types when suspending to $tag: tgp* (ref $ct') where ct'
-    // = (cont $ft') and ft' = [tgr*] -> [ctr*].
-    //
-    std::vector<Type> sentTypes;
-    sentTypes.reserve(curr->handlerTags.size());
-    auto contSig = curr->contType.getContinuation().type.getSignature();
-    auto& ctrs = contSig.params;
-    for (Index i = 0; i < curr->handlerTags.size(); i++) {
-      if (curr->handlerBlocks[i].isNull()) {
-        sentTypes[i] = Type::none;
-        continue;
-      }
-
-      auto& tag = curr->handlerTags[i];
-      auto& tagSig = wasm.getTag(tag)->sig;
-
-      auto& tgps = tagSig.params;
-      auto& tgrs = tagSig.results;
-
-      HeapType ftPrime{Signature(tgrs, ctrs)};
-      HeapType ctPrime{Continuation(ftPrime)};
-      Type ctPrimeRef(ctPrime, Nullability::NonNullable);
-
-      if (tgps.size() > 0) {
-        TypeList sentValueTypes;
-        sentValueTypes.reserve(tgps.size() + 1);
-
-        sentValueTypes.insert(sentValueTypes.begin(), tgps.begin(), tgps.end());
-        sentValueTypes.push_back(ctPrimeRef);
-        sentTypes[i] = Type(sentValueTypes);
-      } else {
-        sentTypes[i] = ctPrimeRef;
-      }
-    }
-    return sentTypes;
-  }
   Resume* makeResume(HeapType contType,
                      const std::vector<Name>& handlerTags,
                      const std::vector<Name>& handlerBlocks,
+                     const std::vector<Type>& sentTypes,
                      const std::vector<Expression*>& operands,
                      Expression* cont) {
     auto* ret = wasm.allocator.alloc<Resume>();
     ret->contType = contType;
     ret->handlerTags.set(handlerTags);
     ret->handlerBlocks.set(handlerBlocks);
-    ret->sentTypes.set(computeResumeTableSentTypes<Resume>(ret));
+    ret->sentTypes.set(sentTypes);
     ret->operands.set(operands);
     ret->cont = cont;
     ret->finalize(&wasm);
@@ -1258,14 +1214,15 @@ class Builder {
                                Name tag,
                                const std::vector<Name>& handlerTags,
                                const std::vector<Name>& handlerBlocks,
+                               const std::vector<Type>& sentTypes,
                                const std::vector<Expression*>& operands,
                                Expression* cont) {
     auto* ret = wasm.allocator.alloc<ResumeThrow>();
     ret->contType = contType;
     ret->tag = tag;
     ret->handlerTags.set(handlerTags);
     ret->handlerBlocks.set(handlerBlocks);
-    ret->sentTypes.set(computeResumeTableSentTypes<ResumeThrow>(ret));
+    ret->sentTypes.set(sentTypes);
     ret->operands.set(operands);
     ret->cont = cont;
     ret->finalize(&wasm);

src/wasm/wasm-binary.cpp

@@ -7981,6 +7981,52 @@ static void readResumeTable(WasmBinaryReader* reader, ResumeType* curr) {
   }
 }
 
+template<typename ResumeOrResumeThrow>
+static void computeResumeTableSentTypes(Module& wasm,
+                                        ResumeOrResumeThrow* curr) {
+  static_assert(std::is_base_of<Resume, ResumeOrResumeThrow>::value ||
+                std::is_base_of<ResumeThrow, ResumeOrResumeThrow>::value);
+  assert(curr->handlerBlocks.size() == curr->handlerTags.size());
+
+  // Let $tag be a tag with type [tgp*] -> [tgr*]. Let $ct be a continuation
+  // type (cont $ft), where $ft is [ctp*] -> [ctr*]. Then an instruction
+  // (resume $ct ... (tag $tag $block) ... ) causes $block to receive values
+  // of the following types when suspending to $tag: tgp* (ref $ct') where ct'
+  // = (cont $ft') and ft' = [tgr*] -> [ctr*].
+  //
+  curr->sentTypes.reserve(curr->handlerTags.size());
+  auto contSig = curr->contType.getContinuation().type.getSignature();
+  auto& ctrs = contSig.params;
+  for (Index i = 0; i < curr->handlerTags.size(); i++) {
+    Type sentType;
+    if (curr->handlerBlocks[i].isNull()) {
+      sentType = Type::none;
+    } else {
+      auto& tag = curr->handlerTags[i];
+      auto& tagSig = wasm.getTag(tag)->sig;
+
+      auto& tgps = tagSig.params;
+      auto& tgrs = tagSig.results;
+
+      HeapType ftPrime{Signature(tgrs, ctrs)};
+      HeapType ctPrime{Continuation(ftPrime)};
+      Type ctPrimeRef(ctPrime, Nullability::NonNullable);
+
+      if (tgps.size() > 0) {
+        TypeList sentValueTypes;
+        sentValueTypes.reserve(tgps.size() + 1);
+
+        sentValueTypes.insert(sentValueTypes.begin(), tgps.begin(), tgps.end());
+        sentValueTypes.push_back(ctPrimeRef);
+        sentType = Type(sentValueTypes);
+      } else {
+        sentType = ctPrimeRef;
+      }
+    }
+    curr->sentTypes.push_back(sentType);
+  }
+}
+
 void WasmBinaryReader::visitResume(Resume* curr) {
 
   curr->contType = getIndexedHeapType();
@@ -7990,6 +8036,7 @@ void WasmBinaryReader::visitResume(Resume* curr) {
   }
 
   readResumeTable<Resume>(this, curr);
+  computeResumeTableSentTypes<Resume>(wasm, curr);
 
   curr->cont = popNonVoidExpression();
 
@@ -8014,6 +8061,7 @@ void WasmBinaryReader::visitResumeThrow(ResumeThrow* curr) {
   tagRefs[exnTagIndex].push_back(&curr->tag);
 
   readResumeTable<ResumeThrow>(this, curr);
+  computeResumeTableSentTypes<ResumeThrow>(wasm, curr);
 
   curr->cont = popNonVoidExpression();
 

src/wasm/wasm-ir-builder.cpp

@@ -1945,6 +1945,55 @@ Result<> IRBuilder::makeSuspend(Name tag) {
   return Ok{};
 }
 
+static std::vector<Type>
+computeResumeTableSentTypes(Module& wasm,
+                            const Signature& contSig,
+                            const std::vector<Name>& handlerTags,
+                            const std::vector<Name> handlerBlocks) {
+  assert(handlerBlocks.size() == handlerTags.size());
+
+  // Let $tag be a tag with type [tgp*] -> [tgr*]. Let $ct be a continuation
+  // type (cont $ft), where $ft is [ctp*] -> [ctr*]. Then an instruction
+  // (resume $ct ... (tag $tag $block) ... ) causes $block to receive values
+  // of the following types when suspending to $tag: tgp* (ref $ct') where ct'
+  // = (cont $ft') and ft' = [tgr*] -> [ctr*].
+  //
+  std::vector<Type> sentTypes;
+  sentTypes.reserve(handlerTags.size());
+  auto& ctrs = contSig.params;
+  for (Index i = 0; i < handlerTags.size(); i++) {
+    Type sentType;
+    if (handlerBlocks[i].isNull()) {
+      sentType = Type::none;
+    } else {
+      auto& tag = handlerTags[i];
+      auto& tagSig = wasm.getTag(tag)->sig;
+
+      auto& tgps = tagSig.params;
+      auto& tgrs = tagSig.results;
+
+      HeapType ftPrime{Signature(tgrs, ctrs)};
+      HeapType ctPrime{Continuation(ftPrime)};
+      Type ctPrimeRef(ctPrime, Nullability::NonNullable);
+
+      if (tgps.size() > 0) {
+        TypeList sentValueTypes;
+        sentValueTypes.reserve(tgps.size() + 1);
+
+        sentValueTypes.insert(sentValueTypes.begin(), tgps.begin(), tgps.end());
+        sentValueTypes.push_back(ctPrimeRef);
+        sentType = Type(sentValueTypes);
+      } else {
+        sentType = ctPrimeRef;
+      }
+    }
+    sentTypes.push_back(sentType);
+  }
+  assert(sentTypes.size() == handlerTags.size() &&
+         sentTypes.size() == handlerBlocks.size());
+  return sentTypes;
+}
+
 Result<>
 IRBuilder::makeResume(HeapType ct,
                       const std::vector<Name>& tags,
@@ -1969,9 +2018,13 @@ IRBuilder::makeResume(HeapType ct,
       labelNames.push_back(Name());
     }
   }
-
+  std::vector<Type> sentTypes =
+    computeResumeTableSentTypes(wasm, contSig, tags, labelNames);
+  curr.sentTypes.resize(sentTypes.size());
+  assert(sentTypes.size() == labelNames.size());
   std::vector<Expression*> operands(curr.operands.begin(), curr.operands.end());
-  push(builder.makeResume(ct, tags, labelNames, operands, curr.cont));
+  push(
+    builder.makeResume(ct, tags, labelNames, sentTypes, operands, curr.cont));
   return Ok{};
 }
 
@@ -1987,6 +2040,7 @@ IRBuilder::makeResumeThrow(HeapType ct,
     return Err{"expected continuation type"};
   }
   ResumeThrow curr(wasm.allocator);
+  auto contSig = ct.getContinuation().type.getSignature();
   curr.contType = ct;
   curr.tag = tag;
   curr.operands.resize(wasm.getTag(tag)->sig.params.size());
@@ -2003,9 +2057,12 @@ IRBuilder::makeResumeThrow(HeapType ct,
       labelNames.push_back(Name());
     }
   }
+  std::vector<Type> sentTypes =
+    computeResumeTableSentTypes(wasm, contSig, tags, labelNames);
 
   std::vector<Expression*> operands(curr.operands.begin(), curr.operands.end());
-  push(builder.makeResumeThrow(ct, tag, tags, labelNames, operands, curr.cont));
+  push(builder.makeResumeThrow(
+    ct, tag, tags, labelNames, sentTypes, operands, curr.cont));
   return Ok{};
 }
 

src/wasm/wasm.cpp

@@ -1387,47 +1387,6 @@ void Suspend::finalize(Module* wasm) {
   }
 }
 
-static void populateResumeSentTypes(Resume* curr, Module* wasm) {
-  if (!wasm) {
-    return;
-  }
-
-  const Signature& contSig =
-    curr->contType.getContinuation().type.getSignature();
-
-  // Let $tag be a tag with type [tgp*] -> [tgr*]. Let $ct be a continuation
-  // type (cont $ft), where $ft is [ctp*] -> [ctr*]. Then an instruction (resume
-  // $ct ... (tag $tag $block) ... ) causes $block to receive values of the
-  // following types when suspending to $tag: tgp* (ref $ct') where ct' = (cont
-  // $ft') and ft' = [tgr*] -> [ctr*].
-  //
-  auto& ctrs = contSig.results;
-  curr->sentTypes.clear();
-  curr->sentTypes.resize(curr->handlerTags.size());
-  for (Index i = 0; i < curr->handlerTags.size(); i++) {
-    auto& tag = curr->handlerTags[i];
-    auto& tagSig = wasm->getTag(tag)->sig;
-
-    auto& tgps = tagSig.params;
-    auto& tgrs = tagSig.results;
-
-    HeapType ftPrime{Signature(tgrs, ctrs)};
-    HeapType ctPrime{Continuation(ftPrime)};
-    Type ctPrimeRef(ctPrime, Nullability::NonNullable);
-
-    if (tgps.size() > 0) {
-      TypeList sentValueTypes;
-      sentValueTypes.reserve(tgps.size() + 1);
-
-      sentValueTypes.insert(sentValueTypes.begin(), tgps.begin(), tgps.end());
-      sentValueTypes.push_back(ctPrimeRef);
-      curr->sentTypes[i] = Type(sentValueTypes);
-    } else {
-      curr->sentTypes[i] = ctPrimeRef;
-    }
-  }
-}
-
 void Resume::finalize(Module* wasm) {
   if (cont->type == Type::unreachable) {
     type = Type::unreachable;
@@ -1436,49 +1395,6 @@ void Resume::finalize(Module* wasm) {
       this->contType.getContinuation().type.getSignature();
     type = contSig.results;
   }
-
-  populateResumeSentTypes(this, wasm);
-}
-
-static void populateResumeThrowSentTypes(ResumeThrow* curr, Module* wasm) {
-  if (!wasm) {
-    return;
-  }
-
-  const Signature& contSig =
-    curr->contType.getContinuation().type.getSignature();
-
-  // Let $tag be a tag with type [tgp*] -> [tgr*]. Let $ct be a continuation
-  // type (cont $ft), where $ft is [ctp*] -> [ctr*]. Then an instruction (resume
-  // $ct ... (tag $tag $block) ... ) causes $block to receive values of the
-  // following types when suspending to $tag: tgp* (ref $ct') where ct' = (cont
-  // $ft') and ft' = [tgr*] -> [ctr*].
-  //
-  auto& ctrs = contSig.results;
-  curr->sentTypes.clear();
-  curr->sentTypes.resize(curr->handlerTags.size());
-  for (Index i = 0; i < curr->handlerTags.size(); i++) {
-    auto& tag = curr->handlerTags[i];
-    auto& tagSig = wasm->getTag(tag)->sig;
-
-    auto& tgps = tagSig.params;
-    auto& tgrs = tagSig.results;
-
-    HeapType ftPrime{Signature(tgrs, ctrs)};
-    HeapType ctPrime{Continuation(ftPrime)};
-    Type ctPrimeRef(ctPrime, Nullability::NonNullable);
-
-    if (tgps.size() > 0) {
-      TypeList sentValueTypes;
-      sentValueTypes.reserve(tgps.size() + 1);
-
-      sentValueTypes.insert(sentValueTypes.begin(), tgps.begin(), tgps.end());
-      sentValueTypes.push_back(ctPrimeRef);
-      curr->sentTypes[i] = Type(sentValueTypes);
-    } else {
-      curr->sentTypes[i] = ctPrimeRef;
-    }
-  }
 }
 
 void ResumeThrow::finalize(Module* wasm) {
@@ -1489,8 +1405,6 @@ void ResumeThrow::finalize(Module* wasm) {
       this->contType.getContinuation().type.getSignature();
     type = contSig.results;
   }
-
-  populateResumeThrowSentTypes(this, wasm);
 }
 
 void StackSwitch::finalize(Module* wasm) {