Merge branch 'main' into eh_old_new_translator

Author: aheejin

scripts/fuzz_opt.py

@@ -315,6 +315,7 @@ def is_git_repo():
     'multi-memory-lowering-import-error.wast',
     # the fuzzer does not support typed continuations
     'typed_continuations.wast',
+    'typed_continuations_resume.wast',
     # New EH implementation is in progress
     'exception-handling.wast',
 ]

scripts/gen-s-parser.py

@@ -566,6 +566,8 @@
     # Typed function references instructions
     ("call_ref",             "makeCallRef(s, /*isReturn=*/false)"),
     ("return_call_ref",      "makeCallRef(s, /*isReturn=*/true)"),
+    # Typed continuations instructions
+    ("resume",               "makeResume(s)"),
     # GC
     ("i31.new",              "makeRefI31(s)"),  # deprecated
     ("ref.i31",              "makeRefI31(s)"),

src/gen-s-parser.inc

@@ -3004,6 +3004,9 @@ switch (buf[0]) {
           default: goto parse_error;
         }
       }
+      case 's':
+        if (op == "resume"sv) { return makeResume(s); }
+        goto parse_error;
       case 't': {
         switch (buf[3]) {
           case 'h':
@@ -8104,6 +8107,12 @@ switch (buf[0]) {
           default: goto parse_error;
         }
       }
+      case 's':
+        if (op == "resume"sv) {
+          CHECK_ERR(makeResume(ctx, pos));
+          return Ok{};
+        }
+        goto parse_error;
       case 't': {
         switch (buf[3]) {
           case 'h':

src/ir/ReFinalize.cpp

@@ -182,6 +182,8 @@ void ReFinalize::visitStringSliceIter(StringSliceIter* curr) {
   curr->finalize();
 }
 
+void ReFinalize::visitResume(Resume* curr) { curr->finalize(); }
+
 void ReFinalize::visitExport(Export* curr) { WASM_UNREACHABLE("unimp"); }
 void ReFinalize::visitGlobal(Global* curr) { WASM_UNREACHABLE("unimp"); }
 void ReFinalize::visitTable(Table* curr) { WASM_UNREACHABLE("unimp"); }

src/ir/branch-utils.h

@@ -82,6 +82,13 @@ void operateOnScopeNameUsesAndSentTypes(Expression* expr, T func) {
           func(name, tt->sentTypes[i]);
         }
       }
+    } else if (auto* r = expr->dynCast<Resume>()) {
+      for (Index i = 0; i < r->handlerTags.size(); i++) {
+        auto dest = r->handlerTags[i];
+        if (dest == name) {
+          func(name, r->sentTypes[i]);
+        }
+      }
     } else {
       assert(expr->is<Try>() || expr->is<Rethrow>()); // delegate or rethrow
     }
@@ -106,6 +113,10 @@ void operateOnScopeNameUsesAndSentValues(Expression* expr, T func) {
       // The values are supplied by throwing instructions, so we are unable to
       // know what they will be here.
       func(name, nullptr);
+    } else if (auto* res = expr->dynCast<Resume>()) {
+      // The values are supplied by suspend instructions executed while running
+      // the continuation, so we are unable to know what they will be here.
+      func(name, nullptr);
     } else {
       assert(expr->is<Try>() || expr->is<Rethrow>()); // delegate or rethrow
     }

src/ir/cost.h

@@ -726,6 +726,11 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
     return 8 + visit(curr->ref) + visit(curr->num);
   }
 
+  CostType visitResume(Resume* curr) {
+    // Inspired by indirect calls, but twice the cost.
+    return 12 + visit(curr->cont);
+  }
+
 private:
   CostType nullCheckCost(Expression* ref) {
     // A nullable type requires a bounds check in most VMs.

src/ir/effects.h

@@ -973,6 +973,19 @@ class EffectAnalyzer {
       // traps when ref is null.
       parent.implicitTrap = true;
     }
+
+    void visitResume(Resume* 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;
+      }
+    }
   };
 
 public:

src/ir/module-utils.cpp

@@ -341,6 +341,8 @@ struct CodeScanner
       counts.include(get->type);
     } else if (auto* set = curr->dynCast<ArraySet>()) {
       counts.note(set->ref->type);
+    } else if (auto* resume = curr->dynCast<Resume>()) {
+      counts.note(resume->contType);
     } else if (Properties::isControlFlowStructure(curr)) {
       counts.noteControlFlow(Signature(Type::none, curr->type));
     }

src/ir/possible-constant.h

@@ -48,6 +48,10 @@ struct PossibleConstantValues {
 public:
   PossibleConstantValues() : value(None()) {}
 
+  bool operator==(const PossibleConstantValues& other) const {
+    return value == other.value;
+  }
+
   // Notes the contents of an expression and update our internal knowledge based
   // on it and all previous values noted.
   void note(Expression* expr, Module& wasm) {
@@ -155,7 +159,7 @@ struct PossibleConstantValues {
   }
 
   // Assuming we have a single value, make an expression containing that value.
-  Expression* makeExpression(Module& wasm) {
+  Expression* makeExpression(Module& wasm) const {
     Builder builder(wasm);
     if (isConstantLiteral()) {
       return builder.makeConstantExpression(getConstantLiteral());

src/ir/possible-contents.cpp

@@ -1199,6 +1199,11 @@ struct InfoCollector
 
   void visitReturn(Return* curr) { addResult(curr->value); }
 
+  void visitResume(Resume* curr) {
+    // TODO: optimize when possible
+    addRoot(curr);
+  }
+
   void visitFunction(Function* func) {
     // Functions with a result can flow a value out from their body.
     addResult(func->body);