Refactor expression runner so it can be used via the C and JS APIs

src/binaryen-c.cpp

@@ -4812,6 +4812,51 @@ BinaryenExpressionRef RelooperRenderAndDispose(RelooperRef relooper,
   return BinaryenExpressionRef(ret);
 }
 
+//
+// ========= ExpressionRunner =========
+//
+
+ExpressionRunnerIntent ExpressionRunnerIntentEvaluate() {
+  return StandaloneExpressionRunner::Intent::EVALUATE;
+}
+
+ExpressionRunnerIntent ExpressionRunnerIntentReplaceExpression() {
+  return StandaloneExpressionRunner::Intent::REPLACE_EXPRESSION;
+}
+
+ExpressionRunnerRef ExpressionRunnerCreate(BinaryenModuleRef module,
+                                           ExpressionRunnerIntent intent,
+                                           BinaryenIndex maxDepth) {
+  if (tracing) {
+    std::cout << "  the_runner = ExpressionRunnerCreate(the_module, " << intent
+              << ", " << maxDepth << ");\n";
+  }
+  auto* wasm = (Module*)module;
+  GetValues getValues;
+  return ExpressionRunnerRef(new StandaloneExpressionRunner(
+    wasm, getValues, StandaloneExpressionRunner::Intent(intent), maxDepth));
+}
+
+BinaryenExpressionRef
+ExpressionRunnerRunAndDispose(ExpressionRunnerRef runner,
+                              BinaryenExpressionRef expr) {
+  if (tracing) {
+    std::cout << "  ExpressionRunnerRunAndDispose(the_runner, expressions["
+              << expressions[expr] << "]);\n";
+  }
+  auto* R = (StandaloneExpressionRunner*)runner;
+  Expression* ret = nullptr;
+  try {
+    auto flow = R->visit(expr);
+    if (!flow.breaking() && !flow.values.empty()) {
+      ret = flow.getConstExpression(*R->getModule());
+    }
+  } catch (StandaloneExpressionRunner::NonstandaloneException&) {
+  }
+  delete R;
+  return ret;
+}
+
 //
 // ========= Other APIs =========
 //
@@ -4832,7 +4877,8 @@ void BinaryenSetAPITracing(int on) {
                  "  std::map<size_t, BinaryenExportRef> exports;\n"
                  "  std::map<size_t, RelooperBlockRef> relooperBlocks;\n"
                  "  BinaryenModuleRef the_module = NULL;\n"
-                 "  RelooperRef the_relooper = NULL;\n";
+                 "  RelooperRef the_relooper = NULL;\n"
+                 "  ExpressionRunnerRef the_runner = NULL;\n";
   } else {
     std::cout << "  return 0;\n";
     std::cout << "}\n";

src/binaryen-c.h

@@ -1618,6 +1618,38 @@ BINARYEN_API void RelooperAddBranchForSwitch(RelooperBlockRef from,
 BINARYEN_API BinaryenExpressionRef RelooperRenderAndDispose(
   RelooperRef relooper, RelooperBlockRef entry, BinaryenIndex labelHelper);
 
+//
+// ========= ExpressionRunner ==========
+//
+
+#ifdef __cplusplus
+namespace wasm {
+class StandaloneExpressionRunner;
+} // namespace wasm
+typedef class wasm::StandaloneExpressionRunner* ExpressionRunnerRef;
+#else
+typedef struct StandaloneExpressionRunner* ExpressionRunnerRef;
+#endif
+
+typedef uint32_t ExpressionRunnerIntent;
+
+// Intent is to evaluate the expression, so we can ignore some side effects.
+BINARYEN_API ExpressionRunnerIntent ExpressionRunnerIntentEvaluate();
+
+// Intent is to replace the expression, so side effects must be retained.
+BINARYEN_API ExpressionRunnerIntent ExpressionRunnerIntentReplaceExpression();
+
+// Creates an ExpressionRunner instance
+BINARYEN_API ExpressionRunnerRef
+ExpressionRunnerCreate(BinaryenModuleRef module,
+                       ExpressionRunnerIntent intent,
+                       BinaryenIndex maxDepth);
+
+// Runs the expression and returns the constant value expression it evaluates
+// to, if any. Otherwise returns `NULL`. Also disposes the runner.
+BINARYEN_API BinaryenExpressionRef ExpressionRunnerRunAndDispose(
+  ExpressionRunnerRef runner, BinaryenExpressionRef expr);
+
 //
 // ========= Other APIs =========
 //

src/js/binaryen.js-post.js

@@ -477,6 +477,12 @@ function initializeConstants() {
   ].forEach(function(name) {
     Module['SideEffects'][name] = Module['_BinaryenSideEffect' + name]();
   });
+
+  // ExpressionRunner intents
+  Module['ExpressionRunner']['Intent'] = {
+    'Evaluate': Module['_ExpressionRunnerIntentEvaluate'](),
+    'ReplaceExpression': Module['_ExpressionRunnerIntentReplaceExpression']()
+  };
 }
 
 // 'Module' interface
@@ -2390,6 +2396,17 @@ Module['Relooper'] = function(module) {
   };
 };
 
+// 'ExpressionRunner' interface
+Module['ExpressionRunner'] = function(module, intent, maxDepth) {
+  if (typeof maxDepth === "undefined") maxDepth = 50; // default used by precompute
+  var runner = Module['_ExpressionRunnerCreate'](module['ptr'], intent, maxDepth);
+  this['ptr'] = runner;
+
+  this['runAndDispose'] = function(expr) {
+    return Module['_ExpressionRunnerRunAndDispose'](runner, expr);
+  };
+};
+
 function getAllNested(ref, numFn, getFn) {
   var num = numFn(ref);
   var ret = new Array(num);

src/passes/Precompute.cpp

@@ -39,108 +39,12 @@
 
 namespace wasm {
 
-static const Name NOTPRECOMPUTABLE_FLOW("Binaryen|notprecomputable");
-
 // Limit evaluation depth for 2 reasons: first, it is highly unlikely
 // that we can do anything useful to precompute a hugely nested expression
 // (we should succed at smaller parts of it first). Second, a low limit is
 // helpful to avoid platform differences in native stack sizes.
 static const Index MAX_DEPTH = 50;
 
-typedef std::unordered_map<LocalGet*, Literals> GetValues;
-
-// Precomputes an expression. Errors if we hit anything that can't be
-// precomputed.
-class PrecomputingExpressionRunner
-  : public ExpressionRunner<PrecomputingExpressionRunner> {
-  Module* module;
-
-  // map gets to constant values, if they are known to be constant
-  GetValues& getValues;
-
-  // Whether we are trying to precompute down to an expression (which we can do
-  // on say 5 + 6) or to a value (which we can't do on a local.tee that flows a
-  // 7 through it). When we want to replace the expression, we can only do so
-  // when it has no side effects. When we don't care about replacing the
-  // expression, we just want to know if it will contain a known constant.
-  bool replaceExpression;
-
-public:
-  PrecomputingExpressionRunner(Module* module,
-                               GetValues& getValues,
-                               bool replaceExpression)
-    : ExpressionRunner<PrecomputingExpressionRunner>(MAX_DEPTH), module(module),
-      getValues(getValues), replaceExpression(replaceExpression) {}
-
-  struct NonstandaloneException {
-  }; // TODO: use a flow with a special name, as this is likely very slow
-
-  Flow visitLoop(Loop* curr) {
-    // loops might be infinite, so must be careful
-    // but we can't tell if non-infinite, since we don't have state, so loops
-    // are just impossible to optimize for now
-    return Flow(NOTPRECOMPUTABLE_FLOW);
-  }
-
-  Flow visitCall(Call* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitCallIndirect(CallIndirect* curr) {
-    return Flow(NOTPRECOMPUTABLE_FLOW);
-  }
-  Flow visitLocalGet(LocalGet* curr) {
-    auto iter = getValues.find(curr);
-    if (iter != getValues.end()) {
-      auto values = iter->second;
-      if (values.isConcrete()) {
-        return Flow(std::move(values));
-      }
-    }
-    return Flow(NOTPRECOMPUTABLE_FLOW);
-  }
-  Flow visitLocalSet(LocalSet* curr) {
-    // If we don't need to replace the whole expression, see if there
-    // is a value flowing through a tee.
-    if (!replaceExpression) {
-      if (curr->type.isConcrete()) {
-        assert(curr->isTee());
-        return visit(curr->value);
-      }
-    }
-    return Flow(NOTPRECOMPUTABLE_FLOW);
-  }
-  Flow visitGlobalGet(GlobalGet* curr) {
-    auto* global = module->getGlobal(curr->name);
-    if (!global->imported() && !global->mutable_) {
-      return visit(global->init);
-    }
-    return Flow(NOTPRECOMPUTABLE_FLOW);
-  }
-  Flow visitGlobalSet(GlobalSet* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitLoad(Load* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitStore(Store* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitAtomicRMW(AtomicRMW* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitAtomicCmpxchg(AtomicCmpxchg* curr) {
-    return Flow(NOTPRECOMPUTABLE_FLOW);
-  }
-  Flow visitAtomicWait(AtomicWait* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitAtomicNotify(AtomicNotify* curr) {
-    return Flow(NOTPRECOMPUTABLE_FLOW);
-  }
-  Flow visitSIMDLoad(SIMDLoad* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitMemoryInit(MemoryInit* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitDataDrop(DataDrop* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitMemoryCopy(MemoryCopy* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitMemoryFill(MemoryFill* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitHost(Host* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitTry(Try* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitThrow(Throw* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitRethrow(Rethrow* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitBrOnExn(BrOnExn* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitPush(Push* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-  Flow visitPop(Pop* curr) { return Flow(NOTPRECOMPUTABLE_FLOW); }
-
-  void trap(const char* why) override { throw NonstandaloneException(); }
-};
-
 struct Precompute
   : public WalkerPass<
       PostWalker<Precompute, UnifiedExpressionVisitor<Precompute>>> {
@@ -192,7 +96,7 @@ struct Precompute
       return;
     }
     if (flow.breaking()) {
-      if (flow.breakTo == NOTPRECOMPUTABLE_FLOW) {
+      if (flow.breakTo == NONSTANDALONE_FLOW) {
         return;
       }
       if (flow.breakTo == RETURN_FLOW) {
@@ -266,13 +170,16 @@ struct Precompute
 private:
   // Precompute an expression, returning a flow, which may be a constant
   // (that we can replace the expression with if replaceExpression is set).
-  Flow precomputeExpression(Expression* curr, bool replaceExpression = true) {
+  Flow precomputeExpression(
+    Expression* curr,
+    StandaloneExpressionRunner::Intent intent =
+      StandaloneExpressionRunner::Intent::REPLACE_EXPRESSION) {
     try {
-      return PrecomputingExpressionRunner(
-               getModule(), getValues, replaceExpression)
+      return StandaloneExpressionRunner(
+               getModule(), getValues, intent, MAX_DEPTH)
         .visit(curr);
-    } catch (PrecomputingExpressionRunner::NonstandaloneException&) {
-      return Flow(NOTPRECOMPUTABLE_FLOW);
+    } catch (StandaloneExpressionRunner::NonstandaloneException&) {
+      return Flow(NONSTANDALONE_FLOW);
     }
   }
 
@@ -284,9 +191,10 @@ struct Precompute
   // will have value 1 which we can optimize here, but in precomputeExpression
   // we could not do anything.
   Literals precomputeValue(Expression* curr) {
-    // Note that we set replaceExpression to false, as we just care about
-    // the value here.
-    Flow flow = precomputeExpression(curr, false /* replaceExpression */);
+    // Note that we do not intent to replace the expression, as we just care
+    // about the value here.
+    Flow flow =
+      precomputeExpression(curr, StandaloneExpressionRunner::Intent::EVALUATE);
     if (flow.breaking()) {
       return {};
     }