Asyncify-verbose: Show all reasons why a function is instrumented (#6457

)

Helps emscripten-core/emscripten#17380 by logging all the reasons why we
instrument a function, and not just the first as we did before.

src/ir/module-utils.h

@@ -390,29 +390,37 @@ template<typename T> struct CallGraphPropertyAnalysis {
   //
   // hasProperty() - Check if the property is present.
   // canHaveProperty() - Check if the property could be present.
-  // addProperty() - Adds the property. This receives a second parameter which
-  //                 is the function due to which we are adding the property.
+  // addProperty() - Adds the property.
+  // logVisit() - Log each visit of the propagation. This is called before
+  //              we check if the function already has the property.
   void propagateBack(std::function<bool(const T&)> hasProperty,
                      std::function<bool(const T&)> canHaveProperty,
-                     std::function<void(T&, Function*)> addProperty,
+                     std::function<void(T&)> addProperty,
+                     std::function<void(const T&, Function*)> logVisit,
                      NonDirectCalls nonDirectCalls) {
     // The work queue contains items we just learned can change the state.
     UniqueDeferredQueue<Function*> work;
     for (auto& func : wasm.functions) {
       if (hasProperty(map[func.get()]) ||
           (nonDirectCalls == NonDirectCallsHaveProperty &&
            map[func.get()].hasNonDirectCall)) {
-        addProperty(map[func.get()], func.get());
+        addProperty(map[func.get()]);
         work.push(func.get());
       }
     }
     while (!work.empty()) {
       auto* func = work.pop();
       for (auto* caller : map[func].calledBy) {
-        // If we don't already have the property, and we are not forbidden
-        // from getting it, then it propagates back to us now.
-        if (!hasProperty(map[caller]) && canHaveProperty(map[caller])) {
-          addProperty(map[caller], func);
+        // Skip functions forbidden from getting this property.
+        if (!canHaveProperty(map[caller])) {
+          continue;
+        }
+        // Log now, even if the function already has the property.
+        logVisit(map[caller], func);
+        // If we don't already have the property, then add it now, and propagate
+        // further.
+        if (!hasProperty(map[caller])) {
+          addProperty(map[caller]);
           work.push(caller);
         }
       }

src/passes/Asyncify.cpp

@@ -716,13 +716,13 @@ class ModuleAnalyzer {
                             return !info.isBottomMostRuntime &&
                                    !info.inRemoveList;
                           },
-                          [verbose](Info& info, Function* reason) {
-                            if (verbose && !info.canChangeState) {
+                          [](Info& info) { info.canChangeState = true; },
+                          [verbose](const Info& info, Function* reason) {
+                            if (verbose) {
                               std::cout << "[asyncify] " << info.name
                                         << " can change the state due to "
                                         << reason->name << "\n";
                             }
-                            info.canChangeState = true;
                           },
                           scanner.IgnoreNonDirectCalls);
 

src/passes/PostEmscripten.cpp

@@ -287,11 +287,11 @@ struct PostEmscripten : public Pass {
       });
 
     // Assume a non-direct call might throw.
-    analyzer.propagateBack(
-      [](const Info& info) { return info.canThrow; },
-      [](const Info& info) { return true; },
-      [](Info& info, Function* reason) { info.canThrow = true; },
-      analyzer.NonDirectCallsHaveProperty);
+    analyzer.propagateBack([](const Info& info) { return info.canThrow; },
+                           [](const Info& info) { return true; },
+                           [](Info& info) { info.canThrow = true; },
+                           [](const Info& info, Function* reason) {},
+                           analyzer.NonDirectCallsHaveProperty);
 
     // Apply the information.
     struct OptimizeInvokes : public WalkerPass<PostWalker<OptimizeInvokes>> {

test/lit/passes/asyncify_verbost.wast → test/lit/passes/asyncify_verbose.wast

@@ -11,7 +11,9 @@
 ;; Likewise, further up the call chain as well.
 ;;
 ;; CHECK: [asyncify] calls-calls-import can change the state due to calls-import
+;; CHECK: [asyncify] calls-calls-import-b can change the state due to calls-import
 ;; CHECK: [asyncify] calls-calls-calls-import can change the state due to calls-calls-import
+;; CHECK: [asyncify] calls-calls-calls-import can change the state due to calls-calls-import-b
 
 (module
   (import "env" "import" (func $import))
@@ -26,8 +28,13 @@
     (call $calls-import)
   )
 
+  (func $calls-calls-import-b
+    (call $calls-import)
+  )
+
   (func $calls-calls-calls-import
     (call $calls-calls-import)
+    (call $calls-calls-import-b)
   )
 
   (func $nothing