Typed continuations: cont.bind instructions (#6365)

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 `cont.bind` instruction for partially
applying continuations, documented
[here](https://github.com/wasmfx/specfx/blob/main/proposals/continuations/Overview.md#instructions).

In short, these instructions are of the form `(cont.bind $ct_before $ct_after)`
where `$ct_before` and `$ct_after` are related continuation types. They must
only differ in the number of arguments, where `$ct_before` has _n_ additional
parameters as compared to `$ct_after`, for some _n_ ≥ 0. The idea is that
`(cont.bind $ct_before $ct_after)` then takes a reference to a continuation of
type `$ct_before` as well as _n_ operands and returns a (reference to a)
continuation of type  `$ct_after`. Thus, the folded textual representation looks
like `(cont.bind $ct_before $ct_after arg1 ... argn c)`.

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.

Author: frank-emrich

scripts/fuzz_opt.py

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

scripts/gen-s-parser.py

@@ -568,6 +568,7 @@
     ("return_call_ref",      "makeCallRef(s, /*isReturn=*/true)"),
     # Typed continuations instructions
     ("cont.new",             "makeContNew(s)"),
+    ("cont.bind",            "makeContBind(s)"),
     ("resume",               "makeResume(s)"),
     # GC
     ("i31.new",              "makeRefI31(s)"),  # deprecated

src/gen-s-parser.inc

@@ -169,9 +169,17 @@ switch (buf[0]) {
           default: goto parse_error;
         }
       }
-      case 'o':
-        if (op == "cont.new"sv) { return makeContNew(s); }
-        goto parse_error;
+      case 'o': {
+        switch (buf[5]) {
+          case 'b':
+            if (op == "cont.bind"sv) { return makeContBind(s); }
+            goto parse_error;
+          case 'n':
+            if (op == "cont.new"sv) { return makeContNew(s); }
+            goto parse_error;
+          default: goto parse_error;
+        }
+      }
       default: goto parse_error;
     }
   }
@@ -3853,12 +3861,23 @@ switch (buf[0]) {
           default: goto parse_error;
         }
       }
-      case 'o':
-        if (op == "cont.new"sv) {
-          CHECK_ERR(makeContNew(ctx, pos, annotations));
-          return Ok{};
+      case 'o': {
+        switch (buf[5]) {
+          case 'b':
+            if (op == "cont.bind"sv) {
+              CHECK_ERR(makeContBind(ctx, pos, annotations));
+              return Ok{};
+            }
+            goto parse_error;
+          case 'n':
+            if (op == "cont.new"sv) {
+              CHECK_ERR(makeContNew(ctx, pos, annotations));
+              return Ok{};
+            }
+            goto parse_error;
+          default: goto parse_error;
         }
-        goto parse_error;
+      }
       default: goto parse_error;
     }
   }

src/ir/ReFinalize.cpp

@@ -183,6 +183,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::visitExport(Export* curr) { WASM_UNREACHABLE("unimp"); }

src/ir/cost.h

@@ -726,6 +726,16 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
     return 8 + visit(curr->ref) + visit(curr->num);
   }
 
+  CostType visitContBind(ContBind* curr) {
+    // Inspired by struct.new: The only cost of cont.bind is that it may need to
+    // allocate a buffer to hold the arguments.
+    CostType ret = 4;
+    ret += visit(curr->cont);
+    for (auto* arg : curr->operands) {
+      ret += visit(arg);
+    }
+    return ret;
+  }
   CostType visitContNew(ContNew* curr) {
     // Some arbitrary "high" value, reflecting that this may allocate a stack
     return 14 + visit(curr->func);

src/ir/effects.h

@@ -974,6 +974,10 @@ class EffectAnalyzer {
       parent.implicitTrap = true;
     }
 
+    void visitContBind(ContBind* curr) {
+      // traps when curr->cont is null ref.
+      parent.implicitTrap = true;
+    }
     void visitContNew(ContNew* curr) {
       // traps when curr->func is null ref.
       parent.implicitTrap = true;

src/ir/module-utils.cpp

@@ -341,6 +341,9 @@ struct CodeScanner
       counts.include(get->type);
     } else if (auto* set = curr->dynCast<ArraySet>()) {
       counts.note(set->ref->type);
+    } else if (auto* contBind = curr->dynCast<ContBind>()) {
+      counts.note(contBind->contTypeBefore);
+      counts.note(contBind->contTypeAfter);
     } else if (auto* contNew = curr->dynCast<ContNew>()) {
       counts.note(contNew->contType);
     } else if (auto* resume = curr->dynCast<Resume>()) {

src/ir/possible-contents.cpp

@@ -1200,6 +1200,10 @@ struct InfoCollector
 
   void visitReturn(Return* curr) { addResult(curr->value); }
 
+  void visitContBind(ContBind* curr) {
+    // TODO: optimize when possible
+    addRoot(curr);
+  }
   void visitContNew(ContNew* curr) {
     // TODO: optimize when possible
     addRoot(curr);

src/ir/subtype-exprs.h

@@ -391,6 +391,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
   void visitStringSliceWTF(StringSliceWTF* curr) {}
   void visitStringSliceIter(StringSliceIter* curr) {}
 
+  void visitContBind(ContBind* curr) { WASM_UNREACHABLE("not implemented"); }
   void visitContNew(ContNew* curr) { WASM_UNREACHABLE("not implemented"); }
   void visitResume(Resume* curr) { WASM_UNREACHABLE("not implemented"); }
 };

src/parser/contexts.h

@@ -808,6 +808,11 @@ struct NullInstrParserCtx {
     return Ok{};
   }
   template<typename HeapTypeT>
+  Result<>
+  makeContBind(Index, const std::vector<Annotation>&, HeapTypeT, HeapTypeT) {
+    return Ok{};
+  }
+  template<typename HeapTypeT>
   Result<> makeContNew(Index, const std::vector<Annotation>&, HeapTypeT) {
     return Ok{};
   }
@@ -2547,6 +2552,13 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     return withLoc(pos, irBuilder.makeStringSliceIter());
   }
 
+  Result<> makeContBind(Index pos,
+                        const std::vector<Annotation>& annotations,
+                        HeapType contTypeBefore,
+                        HeapType contTypeAfter) {
+    return withLoc(pos, irBuilder.makeContBind(contTypeBefore, contTypeAfter));
+  }
+
   Result<> makeContNew(Index pos,
                        const std::vector<Annotation>& annotations,
                        HeapType type) {