Optimize resume of non-suspending continuations

Add a `visitResume` in OptimizeInstructions that does the normal optimizations on null continuations and then tries to turn resumes into calls. We can do this when we are resuming a freshly allocated continuation created with a reference to a known function that GlobalEffects tells us will not suspend.

Author: tlively

src/passes/OptimizeInstructions.cpp

@@ -1461,6 +1461,88 @@ struct OptimizeInstructions
     }
   }
 
+  void visitResume(Resume* curr) {
+    skipNonNullCast(curr->cont, curr);
+    if (trapOnNull(curr, curr->cont)) {
+      return;
+    }
+    if (curr->type == Type::unreachable) {
+      return;
+    }
+
+    // If this resume operates on a freshly-created continuation of an exact
+    // function that is known never to suspend, we can turn the resumption into
+    // a direct call, avoiding the continuation allocation and handler overhead.
+
+    // Continuations are single-shot, so resuming a continuation that has
+    // already been consumed will trap. If traps are assumed never to happen, we
+    // can assume this continuation was not consumed on another path and look
+    // through tees and conditional branches. Otherwise, avoid looking through
+    // them to ensure the continuation cannot be consumed elsewhere.
+    auto behavior = getPassOptions().trapsNeverHappen
+                      ? Properties::FallthroughBehavior::AllowTeeBrIf
+                      : Properties::FallthroughBehavior::NoTeeBrIf;
+
+    auto* contExpr = Properties::getFallthrough(
+      curr->cont, getPassOptions(), *getModule(), behavior);
+    auto* contNew = contExpr->dynCast<ContNew>();
+    if (!contNew) {
+      return;
+    }
+    if (contNew->func->type == Type::unreachable) {
+      return;
+    }
+
+    auto* funcExpr = Properties::getFallthrough(
+      contNew->func, getPassOptions(), *getModule(), behavior);
+    auto* refFunc = funcExpr->dynCast<RefFunc>();
+    if (!refFunc) {
+      return;
+    }
+
+    auto* target = getModule()->getFunctionOrNull(refFunc->func);
+    if (!target || target->imported()) {
+      return;
+    }
+
+    if (!target->effects || target->effects->suspends()) {
+      return;
+    }
+
+    Builder builder(*getModule());
+
+    // If the continuation expression has no side effects, we can eliminate it
+    // entirely and replace the resume with a direct call.
+    if (!effects(curr->cont).hasSideEffects()) {
+      replaceCurrent(
+        builder.makeCall(target->name, curr->operands, target->getResults()));
+      return;
+    }
+
+    // The continuation expression has side effects. In Wasm, resume operands
+    // are evaluated before the continuation expression. If there are no
+    // operands, evaluate the continuation (dropped) and then call.
+    if (curr->operands.empty()) {
+      replaceCurrent(builder.makeSequence(
+        builder.makeDrop(curr->cont),
+        builder.makeCall(target->name, {}, target->getResults())));
+      return;
+    }
+
+    // In the presence of operands, execute the code in curr->cont after the
+    // operands and before the call happens by spilling the last operand to a
+    // temporary local.
+    auto* lastOperand = curr->operands.back();
+    auto lastOperandType = lastOperand->type;
+    Index tempLocal = builder.addVar(getFunction(), lastOperandType);
+    auto* set = builder.makeLocalSet(tempLocal, lastOperand);
+    auto* drop = builder.makeDrop(curr->cont);
+    auto* get = builder.makeLocalGet(tempLocal, lastOperandType);
+    curr->operands.back() = builder.makeBlock({set, drop, get});
+    replaceCurrent(
+      builder.makeCall(target->name, curr->operands, target->getResults()));
+  }
+
   // Note on removing casts (which the following utilities, skipNonNullCast and
   // skipCast do): removing a cast is potentially dangerous, as it removes
   // information from the IR. For example: