Typed continuations: suspend instructions (#6393)

This PR is part of a series that adds basic support for the [typed
continuations/wasmfx proposal](https://github.com/wasmfx/specfx).

This particular PR adds support for the `suspend` instruction for suspending
with a given tag, documented
[here](https://github.com/wasmfx/specfx/blob/main/proposals/continuations/Overview.md#instructions).
These instructions are of the form `(suspend $tag)`. Assuming that `$tag` is
defined with _n_ `param` types `t_1` to `t_n`, the instruction consumes _n_
arguments of types  `t_1` to `t_n`. Its result type is the same as the `result`
type of the tag. Thus, the folded textual representation looks like
`(suspend $tag arg1 ... argn)`.

Support for the instruction is implemented in both the old and the new wat
parser.

Note that this PR does not implement validation of the new instruction.

This PR also fixes finalization of `cont.new`, `cont.bind` and `resume` nodes in
those cases where any  of their children are unreachable.

Author: frank-emrich

scripts/fuzz_opt.py

@@ -328,6 +328,7 @@ def is_git_repo():
     'typed_continuations_resume.wast',
     'typed_continuations_contnew.wast',
     'typed_continuations_contbind.wast',
+    'typed_continuations_suspend.wast',
     # New EH implementation is in progress
     'exception-handling.wast',
     'translate-eh-old-to-new.wast',

scripts/gen-s-parser.py

@@ -570,6 +570,7 @@
     ("cont.new",             "makeContNew(s)"),
     ("cont.bind",            "makeContBind(s)"),
     ("resume",               "makeResume(s)"),
+    ("suspend",              "makeSuspend(s)"),
     # GC
     ("i31.new",              "makeRefI31(s)"),  # deprecated
     ("ref.i31",              "makeRefI31(s)"),

src/gen-s-parser.inc

@@ -3369,6 +3369,9 @@ switch (buf[0]) {
           default: goto parse_error;
         }
       }
+      case 'u':
+        if (op == "suspend"sv) { return makeSuspend(s); }
+        goto parse_error;
       default: goto parse_error;
     }
   }
@@ -8653,6 +8656,12 @@ switch (buf[0]) {
           default: goto parse_error;
         }
       }
+      case 'u':
+        if (op == "suspend"sv) {
+          CHECK_ERR(makeSuspend(ctx, pos, annotations));
+          return Ok{};
+        }
+        goto parse_error;
       default: goto parse_error;
     }
   }

src/ir/ReFinalize.cpp

@@ -185,6 +185,7 @@ void ReFinalize::visitStringSliceIter(StringSliceIter* curr) {
 void ReFinalize::visitContNew(ContNew* curr) { curr->finalize(); }
 void ReFinalize::visitContBind(ContBind* curr) { curr->finalize(); }
 void ReFinalize::visitResume(Resume* curr) { curr->finalize(); }
+void ReFinalize::visitSuspend(Suspend* curr) { curr->finalize(getModule()); }
 
 void ReFinalize::visitExport(Export* curr) { WASM_UNREACHABLE("unimp"); }
 void ReFinalize::visitGlobal(Global* curr) { WASM_UNREACHABLE("unimp"); }

src/ir/cost.h

@@ -742,7 +742,18 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
   }
   CostType visitResume(Resume* curr) {
     // Inspired by indirect calls, but twice the cost.
-    return 12 + visit(curr->cont);
+    CostType ret = 12 + visit(curr->cont);
+    for (auto* arg : curr->operands) {
+      ret += visit(arg);
+    }
+    return ret;
+  }
+  CostType visitSuspend(Suspend* curr) {
+    CostType ret = 12;
+    for (auto* arg : curr->operands) {
+      ret += visit(arg);
+    }
+    return ret;
   }
 
 private:

src/ir/effects.h

@@ -994,6 +994,14 @@ class EffectAnalyzer {
         parent.throws_ = true;
       }
     }
+    void visitSuspend(Suspend* 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;
+      }
+    }
   };
 
 public:

src/ir/possible-contents.cpp

@@ -1212,6 +1212,10 @@ struct InfoCollector
     // TODO: optimize when possible
     addRoot(curr);
   }
+  void visitSuspend(Suspend* 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

@@ -394,6 +394,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
   void visitContBind(ContBind* curr) { WASM_UNREACHABLE("not implemented"); }
   void visitContNew(ContNew* curr) { WASM_UNREACHABLE("not implemented"); }
   void visitResume(Resume* curr) { WASM_UNREACHABLE("not implemented"); }
+  void visitSuspend(Suspend* curr) { WASM_UNREACHABLE("not implemented"); }
 };
 
 } // namespace wasm

src/parser/contexts.h

@@ -824,6 +824,9 @@ struct NullInstrParserCtx {
                       const TagLabelListT&) {
     return Ok{};
   }
+  Result<> makeSuspend(Index, const std::vector<Annotation>&, TagIdxT) {
+    return Ok{};
+  }
 };
 
 struct NullCtx : NullTypeParserCtx, NullInstrParserCtx {
@@ -2594,6 +2597,11 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     }
     return withLoc(pos, irBuilder.makeResume(type, tags, labels));
   }
+
+  Result<>
+  makeSuspend(Index pos, const std::vector<Annotation>& annotations, Name tag) {
+    return withLoc(pos, irBuilder.makeSuspend(tag));
+  }
 };
 
 } // namespace wasm::WATParser

src/parser/parsers.h

@@ -309,6 +309,8 @@ template<typename Ctx>
 Result<> makeContNew(Ctx*, Index, const std::vector<Annotation>&);
 template<typename Ctx>
 Result<> makeResume(Ctx&, Index, const std::vector<Annotation>&);
+template<typename Ctx>
+Result<> makeSuspend(Ctx&, Index, const std::vector<Annotation>&);
 
 // Modules
 template<typename Ctx> MaybeResult<Index> maybeTypeidx(Ctx& ctx);
@@ -2498,6 +2500,15 @@ makeResume(Ctx& ctx, Index pos, const std::vector<Annotation>& annotations) {
   return ctx.makeResume(pos, annotations, *type, tagLabels);
 }
 
+template<typename Ctx>
+Result<>
+makeSuspend(Ctx& ctx, Index pos, const std::vector<Annotation>& annotations) {
+  auto tag = tagidx(ctx);
+  CHECK_ERR(tag);
+
+  return ctx.makeSuspend(pos, annotations, *tag);
+}
+
 // =======
 // Modules
 // =======