wip

Author: caiiiycuk

src/passes/Asyncify.cpp

@@ -1342,6 +1342,8 @@ struct AsyncifyAssertInNonInstrumented : public Pass {
 };
 
 struct AsyncifyAssertUnwindCorrectness : Pass {
+  bool isFunctionParallel() override { return true; }
+
   ModuleAnalyzer* analyzer;
   Module* module;
 
@@ -1354,17 +1356,14 @@ struct AsyncifyAssertUnwindCorrectness : Pass {
     return std::make_unique<AsyncifyAssertUnwindCorrectness>(analyzer, module);
   }
 
-  bool isFunctionParallel() override { return true; }
-
-  void runOnFunction(Module*, Function* function) override {
-    auto builder = std::make_unique<Builder>(*module);
-
+  void runOnFunction(Module* module_, Function* function) override {
     struct UnwindWalker : WalkerPass<ExpressionStackWalker<UnwindWalker>> {
       Function* function;
-      Builder* builder;
+      Module* module;
 
       // Adds a check for Call that is inside a Catch block (we do not handle unwinding there).
-      void checkCallInsideCatch(Call* call) {
+      void replaceCallWithCheck(Call* call) {
+        auto builder = std::make_unique<Builder>(*module);
         auto check = builder->makeIf(
           builder->makeBinary(NeInt32,
                               builder->makeGlobalGet(ASYNCIFY_STATE, Type::i32),
@@ -1391,6 +1390,11 @@ struct AsyncifyAssertUnwindCorrectness : Pass {
 
       void visitCall(Call* curr) {
         assert(!expressionStack.empty());
+        // A return_call (curr->isReturn) can be ignored here: It returns first,
+        // leaving the Catch, before calling.
+        if (curr->isReturn) {
+          return;
+        }
         // Go up the stack and see if we are in a Catch.
         Index i = expressionStack.size() - 1;
         while (i > 0) {
@@ -1411,7 +1415,7 @@ struct AsyncifyAssertUnwindCorrectness : Pass {
 
     UnwindWalker walker;
     walker.function = function;
-    walker.builder = builder.get();
+    walker.module = module_;
     walker.walk(function->body);
   }
 };
@@ -1855,7 +1859,6 @@ struct Asyncify : public Pass {
       runner.setValidateGlobally(false);
       runner.run();
     }
-    if (asserts) {
       // Add asserts in non-instrumented code. Note we do not use an
       // instrumented pass runner here as we do want to run on all functions.
       PassRunner runner(module);
@@ -1868,29 +1871,28 @@ struct Asyncify : public Pass {
       runner.setIsNested(true);
       runner.setValidateGlobally(false);
       runner.run();
-    }
-    // Next, add local saving/restoring logic. We optimize before doing this,
-    // to undo the extra code generated by flattening, and to arrive at the
-    // minimal amount of locals (which is important as we must save and
-    // restore those locals). We also and optimize after as well to simplify
-    // the code as much as possible.
-    {
-      PassUtils::FilteredPassRunner runner(module, instrumentedFuncs);
-      if (optimize) {
-        runner.addDefaultFunctionOptimizationPasses();
-      }
-      runner.add(std::make_unique<AsyncifyLocals>(
-        &analyzer, pointerType, asyncifyMemory));
-      if (optimize) {
-        runner.addDefaultFunctionOptimizationPasses();
+      // Next, add local saving/restoring logic. We optimize before doing this,
+      // to undo the extra code generated by flattening, and to arrive at the
+      // minimal amount of locals (which is important as we must save and
+      // restore those locals). We also and optimize after as well to simplify
+      // the code as much as possible.
+      {
+        PassUtils::FilteredPassRunner runner(module, instrumentedFuncs);
+        if (optimize) {
+          runner.addDefaultFunctionOptimizationPasses();
+        }
+        runner.add(std::make_unique<AsyncifyLocals>(
+          &analyzer, pointerType, asyncifyMemory));
+        if (optimize) {
+          runner.addDefaultFunctionOptimizationPasses();
+        }
+        runner.setIsNested(true);
+        runner.setValidateGlobally(false);
+        runner.run();
       }
-      runner.setIsNested(true);
-      runner.setValidateGlobally(false);
-      runner.run();
-    }
     // Finally, add function support (that should not have been seen by
     // the previous passes).
-    addFunctions(module, asserts);
+      addFunctions(module);
   }
 
 private:
@@ -1918,14 +1920,14 @@ struct Asyncify : public Pass {
     module->addGlobal(std::move(asyncifyData));
   }
 
-  void addFunctions(Module* module, bool asserts) {
+  void addFunctions(Module* module) {
     Builder builder(*module);
     auto makeFunction = [&](Name name, bool setData, State state) {
-      auto* body = builder.makeBlock();
       std::vector<Type> params;
       if (setData) {
         params.push_back(pointerType);
       }
+      auto* body = builder.makeBlock();
       body->list.push_back(builder.makeGlobalSet(
         ASYNCIFY_STATE, builder.makeConst(int32_t(state))));
       if (setData) {