Bysyncify: async transform for wasm (#2172)

This adds a new pass, Bysyncify, which transforms code to allow unwind and rewinding the call stack and local state. This allows things like coroutines, turning synchronous code asynchronous, etc.

The new pass file itself has a large comment on top with docs.

So far the tests here seem to show this works, but this hasn't been tested heavily yet. My next step is to hook this up to emscripten as a replacement for asyncify/emterpreter, see emscripten-core/emscripten#8561

Note that this is completely usable by itself, so it could be useful for any language that needs coroutines etc., and not just ones using LLVM and/or emscripten. See docs on the ABI in the pass source.

Author: kripken

build-js.sh

@@ -94,6 +94,7 @@ mkdir -p ${OUT}
   $BINARYEN_SRC/passes/pass.cpp \
   $BINARYEN_SRC/passes/AlignmentLowering.cpp \
   $BINARYEN_SRC/passes/AvoidReinterprets.cpp \
+  $BINARYEN_SRC/passes/Bysyncify.cpp \
   $BINARYEN_SRC/passes/CoalesceLocals.cpp \
   $BINARYEN_SRC/passes/DeadArgumentElimination.cpp \
   $BINARYEN_SRC/passes/CodeFolding.cpp \

src/ir/effects.h

@@ -27,7 +27,7 @@ namespace wasm {
 
 struct EffectAnalyzer
   : public PostWalker<EffectAnalyzer, OverriddenVisitor<EffectAnalyzer>> {
-  EffectAnalyzer(PassOptions& passOptions, Expression* ast = nullptr) {
+  EffectAnalyzer(const PassOptions& passOptions, Expression* ast = nullptr) {
     ignoreImplicitTraps = passOptions.ignoreImplicitTraps;
     debugInfo = passOptions.debugInfo;
     if (ast) {
@@ -372,7 +372,7 @@ struct EffectAnalyzer
   // Helpers
 
   static bool
-  canReorder(PassOptions& passOptions, Expression* a, Expression* b) {
+  canReorder(const PassOptions& passOptions, Expression* a, Expression* b) {
     EffectAnalyzer aEffects(passOptions, a);
     EffectAnalyzer bEffects(passOptions, b);
     return !aEffects.invalidates(bEffects);

src/ir/module-utils.h

@@ -19,6 +19,7 @@
 
 #include "ir/find_all.h"
 #include "ir/manipulation.h"
+#include "pass.h"
 #include "wasm.h"
 
 namespace wasm {
@@ -287,6 +288,62 @@ template<typename T> inline void iterDefinedEvents(Module& wasm, T visitor) {
   }
 }
 
+// Performs a parallel map on function in the module, emitting a map object
+// of function => result.
+// TODO: use in inlining and elsewhere
+template<typename T> struct ParallelFunctionMap {
+
+  typedef std::map<Function*, T> Map;
+  Map map;
+
+  typedef std::function<void(Function*, T&)> Func;
+
+  struct Info {
+    Map* map;
+    Func work;
+  };
+
+  ParallelFunctionMap(Module& wasm, Func work) {
+    // Fill in map, as we operate on it in parallel (each function to its own
+    // entry).
+    for (auto& func : wasm.functions) {
+      map[func.get()];
+    }
+
+    // Run on the imports first. TODO: parallelize this too
+    for (auto& func : wasm.functions) {
+      if (func->imported()) {
+        work(func.get(), map[func.get()]);
+      }
+    }
+
+    // Run on the implemented functions.
+    struct Mapper : public WalkerPass<PostWalker<Mapper>> {
+
+      bool isFunctionParallel() override { return true; }
+
+      Mapper(Info* info) : info(info) {}
+
+      Mapper* create() override { return new Mapper(info); }
+
+      void doWalkFunction(Function* curr) {
+        assert((*info->map).count(curr));
+        info->work(curr, (*info->map)[curr]);
+      }
+
+    private:
+      Info* info;
+    };
+
+    Info info = {&map, work};
+
+    PassRunner runner(&wasm);
+    runner.setIsNested(true);
+    runner.add<Mapper>(&info);
+    runner.run();
+  }
+};
+
 } // namespace ModuleUtils
 
 } // namespace wasm

src/pass.h

@@ -127,6 +127,13 @@ struct PassOptions {
     }
     return arguments[key];
   }
+
+  std::string getArgumentOrDefault(std::string key, std::string default_) {
+    if (arguments.count(key) == 0) {
+      return default_;
+    }
+    return arguments[key];
+  }
 };
 
 //