Named handlers support

scripts/gen-s-parser.py

@@ -603,6 +603,8 @@
     ("resume",               "makeResume()"),
     ("resume_throw",         "makeResumeThrow()"),
     ("switch",               "makeStackSwitch()"),
+    ("suspend_to",           "makeSuspendTo()"),
+    ("resume_with",          "makeResumeWith()"),
     # GC
     ("ref.i31",              "makeRefI31(Unshared)"),
     ("ref.i31_shared",       "makeRefI31(Shared)"),

scripts/test/fuzzing.py

@@ -101,6 +101,9 @@
     'stack_switching_resume.wast',
     'stack_switching_resume_throw.wast',
     'stack_switching_switch.wast',
+    'stack_switching_named.wast',
+    'stack_switching_suspend_to.wast',
+    'stack_switching_resume_with.wast',
     # TODO: fuzzer support for exact references
     'exact-references.wast',
 ]

src/binaryen-c.cpp

@@ -90,6 +90,7 @@ BinaryenLiteral toBinaryenLiteral(Literal x) {
       case HeapType::struct_:
       case HeapType::array:
       case HeapType::exn:
+      case HeapType::handler:
         WASM_UNREACHABLE("invalid type");
       case HeapType::string:
         WASM_UNREACHABLE("TODO: string literals");
@@ -98,6 +99,7 @@ BinaryenLiteral toBinaryenLiteral(Literal x) {
       case HeapType::nofunc:
       case HeapType::nocont:
       case HeapType::noexn:
+      case HeapType::nohandler:
         // Null.
         return ret;
     }
@@ -144,6 +146,7 @@ Literal fromBinaryenLiteral(BinaryenLiteral x) {
       case HeapType::struct_:
       case HeapType::array:
       case HeapType::exn:
+      case HeapType::handler:
         WASM_UNREACHABLE("invalid type");
       case HeapType::string:
         WASM_UNREACHABLE("TODO: string literals");
@@ -152,6 +155,7 @@ Literal fromBinaryenLiteral(BinaryenLiteral x) {
       case HeapType::nofunc:
       case HeapType::nocont:
       case HeapType::noexn:
+      case HeapType::nohandler:
         assert(type.isNullable());
         return Literal::makeNull(heapType);
     }

src/gen-s-parser.inc

@@ -4815,12 +4815,23 @@ switch (buf[0]) {
               return Ok{};
             }
             goto parse_error;
-          case '_':
-            if (op == "resume_throw"sv) {
-              CHECK_ERR(makeResumeThrow(ctx, pos, annotations));
-              return Ok{};
+          case '_': {
+            switch (buf[7]) {
+              case 't':
+                if (op == "resume_throw"sv) {
+                  CHECK_ERR(makeResumeThrow(ctx, pos, annotations));
+                  return Ok{};
+                }
+                goto parse_error;
+              case 'w':
+                if (op == "resume_with"sv) {
+                  CHECK_ERR(makeResumeWith(ctx, pos, annotations));
+                  return Ok{};
+                }
+                goto parse_error;
+              default: goto parse_error;
             }
-            goto parse_error;
+          }
           default: goto parse_error;
         }
       }
@@ -5177,12 +5188,23 @@ switch (buf[0]) {
           default: goto parse_error;
         }
       }
-      case 'u':
-        if (op == "suspend"sv) {
-          CHECK_ERR(makeSuspend(ctx, pos, annotations));
-          return Ok{};
+      case 'u': {
+        switch (buf[7]) {
+          case '\0':
+            if (op == "suspend"sv) {
+              CHECK_ERR(makeSuspend(ctx, pos, annotations));
+              return Ok{};
+            }
+            goto parse_error;
+          case '_':
+            if (op == "suspend_to"sv) {
+              CHECK_ERR(makeSuspendTo(ctx, pos, annotations));
+              return Ok{};
+            }
+            goto parse_error;
+          default: goto parse_error;
         }
-        goto parse_error;
+      }
       case 'w':
         if (op == "switch"sv) {
           CHECK_ERR(makeStackSwitch(ctx, pos, annotations));

src/interpreter/interpreter.cpp

@@ -268,6 +268,8 @@ struct ExpressionInterpreter : OverriddenVisitor<ExpressionInterpreter, Flow> {
   Flow visitResume(Resume* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitResumeThrow(ResumeThrow* curr) { WASM_UNREACHABLE("TODO"); }
   Flow visitStackSwitch(StackSwitch* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitResumeWith(ResumeWith* curr) { WASM_UNREACHABLE("TODO"); }
+  Flow visitSuspendTo(SuspendTo* curr) { WASM_UNREACHABLE("TODO"); }
 };
 
 } // anonymous namespace

src/ir/ReFinalize.cpp

@@ -186,6 +186,10 @@ void ReFinalize::visitSuspend(Suspend* curr) { curr->finalize(getModule()); }
 void ReFinalize::visitResume(Resume* curr) { curr->finalize(); }
 void ReFinalize::visitResumeThrow(ResumeThrow* curr) { curr->finalize(); }
 void ReFinalize::visitStackSwitch(StackSwitch* curr) { curr->finalize(); }
+void ReFinalize::visitResumeWith(ResumeWith* curr) { curr->finalize(); }
+void ReFinalize::visitSuspendTo(SuspendTo* curr) {
+  curr->finalize(getModule());
+}
 
 void ReFinalize::visitExport(Export* curr) { WASM_UNREACHABLE("unimp"); }
 void ReFinalize::visitGlobal(Global* curr) { WASM_UNREACHABLE("unimp"); }

src/ir/branch-utils.h

@@ -96,6 +96,13 @@ void operateOnScopeNameUsesAndSentTypes(Expression* expr, T func) {
           func(name, r->sentTypes[i]);
         }
       }
+    } else if (auto* r = expr->dynCast<ResumeWith>()) {
+      for (Index i = 0; i < r->handlerTags.size(); i++) {
+        auto dest = r->handlerTags[i];
+        if (!dest.isNull() && dest == name) {
+          func(name, r->sentTypes[i]);
+        }
+      }
     } else {
       assert(expr->is<Try>() || expr->is<Rethrow>()); // delegate or rethrow
     }

src/ir/child-typer.h

@@ -1168,6 +1168,35 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
     }
     note(&curr->cont, Type(*ct, Nullable));
   }
+
+  void visitSuspendTo(SuspendTo* curr,
+                      std::optional<HeapType> ht = std::nullopt) {
+    if (!ht.has_value()) {
+      ht = curr->handler->type.getHeapType();
+    }
+    assert(ht->isHandler());
+    auto params = wasm.getTag(curr->tag)->params();
+    assert(params.size() == curr->operands.size());
+    for (size_t i = 0; i < params.size(); ++i) {
+      note(&curr->operands[i], params[i]);
+    }
+    note(&curr->handler, Type(*ht, Nullable));
+  }
+
+  void visitResumeWith(ResumeWith* curr,
+                       std::optional<HeapType> ct = std::nullopt) {
+    if (!ct.has_value()) {
+      ct = curr->cont->type.getHeapType();
+    }
+    assert(ct->isContinuation());
+    auto params = ct->getContinuation().type.getSignature().params;
+    assert(params.size() >= 1 &&
+           ((params.size() - 1) == curr->operands.size()));
+    for (size_t i = 0; i < params.size() - 1; ++i) {
+      note(&curr->operands[i], params[i]);
+    }
+    note(&curr->cont, Type(*ct, Nullable));
+  }
 };
 
 } // namespace wasm

src/ir/cost.h

@@ -813,6 +813,21 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
     }
     return ret;
   }
+  CostType visitResumeWith(ResumeWith* curr) {
+    // Inspired by indirect calls, but twice the cost.
+    CostType ret = 12 + visit(curr->cont);
+    for (auto* arg : curr->operands) {
+      ret += visit(arg);
+    }
+    return ret;
+  }
+  CostType visitSuspendTo(SuspendTo* curr) {
+    CostType ret = 12 + visit(curr->handler);
+    for (auto* arg : curr->operands) {
+      ret += visit(arg);
+    }
+    return ret;
+  }
 
 private:
   CostType nullCheckCost(Expression* ref) {

src/ir/effects.h

@@ -1104,6 +1104,29 @@ class EffectAnalyzer {
         parent.throws_ = true;
       }
     }
+    void visitResumeWith(ResumeWith* curr) {
+      // This acts as a kitchen sink effect.
+      parent.calls = true;
+
+      // resume instructions accept nullable continuation references and trap
+      // on null.
+      parent.implicitTrap = true;
+
+      if (parent.features.hasExceptionHandling() && parent.tryDepth == 0) {
+        parent.throws_ = true;
+      }
+    }
+    void visitSuspendTo(SuspendTo* curr) {
+      // Similar to resume/call: Suspending means that we execute arbitrary
+      // other code before we may resume here.
+      parent.calls = true;
+      if (parent.features.hasExceptionHandling() && parent.tryDepth == 0) {
+        parent.throws_ = true;
+      }
+
+      // A suspend may go unhandled and therefore trap.
+      parent.implicitTrap = true;
+    }
   };
 
 public:

src/ir/gc-type-utils.h

@@ -156,6 +156,7 @@ inline std::optional<Field> getField(HeapType type, Index index = 0) {
       return type.getArray().element;
     case HeapTypeKind::Func:
     case HeapTypeKind::Cont:
+    case HeapTypeKind::Handler:
     case HeapTypeKind::Basic:
       break;
   }

src/ir/possible-contents.cpp

@@ -1293,6 +1293,14 @@ struct InfoCollector
     // TODO: optimize when possible
     addRoot(curr);
   }
+  void visitResumeWith(ResumeWith* curr) {
+    // TODO: optimize when possible
+    addRoot(curr);
+  }
+  void visitSuspendTo(SuspendTo* curr) {
+    // TODO: optimize when possible
+    addRoot(curr);
+  }
 
   void visitFunction(Function* func) {
     // Functions with a result can flow a value out from their body.

src/ir/subtype-exprs.h

@@ -422,6 +422,10 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
   void visitStackSwitch(StackSwitch* curr) {
     WASM_UNREACHABLE("not implemented");
   }
+  void visitResumeWith(ResumeWith* curr) {
+    WASM_UNREACHABLE("not implemented");
+  }
+  void visitSuspendTo(SuspendTo* curr) { WASM_UNREACHABLE("not implemented"); }
 };
 
 } // namespace wasm

src/ir/subtypes.h

@@ -127,6 +127,8 @@ struct SubTypes {
           break;
         case HeapTypeKind::Cont:
           WASM_UNREACHABLE("TODO: cont");
+        case HeapTypeKind::Handler:
+          WASM_UNREACHABLE("TODO: handler");
         case HeapTypeKind::Basic:
           WASM_UNREACHABLE("unexpected kind");
       }

src/ir/type-updating.cpp

@@ -152,6 +152,8 @@ GlobalTypeRewriter::TypeMap GlobalTypeRewriter::rebuildTypes(
       }
       case HeapTypeKind::Cont:
         WASM_UNREACHABLE("TODO: cont");
+      case HeapTypeKind::Handler:
+        WASM_UNREACHABLE("TODO: handler");
       case HeapTypeKind::Basic:
         WASM_UNREACHABLE("unexpected kind");
     }