Cherrypick SCC with indirect effects

Author: stevenfontanella

src/passes/GlobalEffects.cpp

@@ -21,8 +21,10 @@
 
 #include "ir/effects.h"
 #include "ir/module-utils.h"
+#include "ir/subtypes.h"
 #include "pass.h"
 #include "support/strongly_connected_components.h"
+#include "support/utilities.h"
 #include "wasm.h"
 
 namespace wasm {
@@ -39,6 +41,9 @@ struct FuncInfo {
 
   // Directly-called functions from this function.
   std::unordered_set<Name> calledFunctions;
+
+  // Types that are targets of indirect calls.
+  std::unordered_set<HeapType> indirectCalledTypes;
 };
 
 std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
@@ -83,11 +88,19 @@ std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
             if (auto* call = curr->dynCast<Call>()) {
               // Note the direct call.
               funcInfo.calledFunctions.insert(call->target);
+            } else if (effects.calls && options.closedWorld) {
+              HeapType type;
+              if (auto* callRef = curr->dynCast<CallRef>()) {
+                type = callRef->target->type.getHeapType();
+              } else if (auto* callIndirect = curr->dynCast<CallIndirect>()) {
+                type = callIndirect->heapType;
+              } else {
+                assert(false && "Unexpected type of call");
+              }
+
+              funcInfo.indirectCalledTypes.insert(type);
             } else if (effects.calls) {
-              // This is an indirect call of some sort, so we must assume the
-              // worst. To do so, clear the effects, which indicates nothing
-              // is known (so anything is possible).
-              // TODO: We could group effects by function type etc.
+              assert(!options.closedWorld);
               funcInfo.effects = UnknownEffects;
             } else {
               // No call here, but update throwing if we see it. (Only do so,
@@ -107,15 +120,44 @@ std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
   return std::move(analysis.map);
 }
 
-using CallGraph = std::unordered_map<Function*, std::unordered_set<Function*>>;
+using CallGraphNode = std::variant<Function*, HeapType>;
+using CallGraph =
+  std::unordered_map<CallGraphNode, std::unordered_set<CallGraphNode>>;
 
-CallGraph buildCallGraph(const Module& module,
-                         const std::map<Function*, FuncInfo>& funcInfos) {
+CallGraph buildCallGraph(Module& module,
+                         const std::map<Function*, FuncInfo>& funcInfos,
+                         bool closedWorld) {
   CallGraph callGraph;
-  for (const auto& [func, info] : funcInfos) {
-    for (Name callee : info.calledFunctions) {
-      callGraph[func].insert(module.getFunction(callee));
+
+  if (!closedWorld) {
+    for (const auto& [caller, callerInfo] : funcInfos) {
+      for (Name calleeFunction : callerInfo.calledFunctions) {
+        callGraph[caller].insert(module.getFunction(calleeFunction));
+      }
+    }
+    return callGraph;
+  }
+
+  std::unordered_set<HeapType> allFunctionTypes;
+  for (const auto& [caller, callerInfo] : funcInfos) {
+    for (Name calleeFunction : callerInfo.calledFunctions) {
+      callGraph[caller].insert(module.getFunction(calleeFunction));
+    }
+
+    allFunctionTypes.insert(caller->type.getHeapType());
+    for (HeapType calleeType : callerInfo.indirectCalledTypes) {
+      callGraph[caller].insert(calleeType);
+      allFunctionTypes.insert(calleeType);
     }
+    callGraph[caller->type.getHeapType()].insert(caller);
+  }
+
+  SubTypes subtypes(module);
+  for (HeapType type : allFunctionTypes) {
+    subtypes.iterSubTypes(type, [&callGraph, type](HeapType sub, auto _) {
+      callGraph[type].insert(sub);
+      return true;
+    });
   }
 
   return callGraph;
@@ -148,99 +190,111 @@ void propagateEffects(const Module& module,
                       std::map<Function*, FuncInfo>& funcInfos,
                       const CallGraph& callGraph) {
   struct CallGraphSCCs
-    : SCCs<std::vector<Function*>::const_iterator, CallGraphSCCs> {
+    : SCCs<std::vector<CallGraphNode>::const_iterator, CallGraphSCCs> {
     const std::map<Function*, FuncInfo>& funcInfos;
-    const std::unordered_map<Function*, std::unordered_set<Function*>>&
-      callGraph;
+    const CallGraph& callGraph;
     const Module& module;
 
     CallGraphSCCs(
-      const std::vector<Function*>& funcs,
+      const std::vector<CallGraphNode>& nodes,
       const std::map<Function*, FuncInfo>& funcInfos,
-      const std::unordered_map<Function*, std::unordered_set<Function*>>&
-        callGraph,
+      const std::unordered_map<CallGraphNode,
+                               std::unordered_set<CallGraphNode>>& callGraph,
       const Module& module)
-      : SCCs<std::vector<Function*>::const_iterator, CallGraphSCCs>(
-          funcs.begin(), funcs.end()),
-        funcInfos(funcInfos), callGraph(callGraph), module(module) {}
+      : SCCs<std::vector<CallGraphNode>::const_iterator, CallGraphSCCs>(
+          nodes.begin(), nodes.end()),
+        funcInfos(funcInfos), module(module), callGraph(callGraph) {}
 
-    void pushChildren(Function* f) {
-      auto callees = callGraph.find(f);
+    void pushChildren(CallGraphNode node) {
+      auto callees = callGraph.find(node);
       if (callees == callGraph.end()) {
         return;
       }
-
-      for (auto* callee : callees->second) {
+      for (CallGraphNode callee : callees->second) {
         push(callee);
       }
     }
   };
 
-  std::vector<Function*> allFuncs;
+  // We only care about Functions that are roots, not types
+  // A type would be a root if a function exists with that type, but no-one
+  // indirect calls the type.
+  std::vector<CallGraphNode> allFuncs;
   for (auto& [func, info] : funcInfos) {
     allFuncs.push_back(func);
   }
+
   CallGraphSCCs sccs(allFuncs, funcInfos, callGraph, module);
 
   std::vector<std::optional<EffectAnalyzer>> componentEffects;
   // Points to an index in componentEffects
-  std::unordered_map<Function*, Index> funcComponents;
+  std::unordered_map<CallGraphNode, Index> funcComponents;
 
   for (auto ccIterator : sccs) {
     std::optional<EffectAnalyzer>& ccEffects =
       componentEffects.emplace_back(std::in_place, passOptions, module);
+    std::vector<CallGraphNode> cc(ccIterator.begin(), ccIterator.end());
 
-    std::vector<Function*> ccFuncs(ccIterator.begin(), ccIterator.end());
-
-    for (Function* f : ccFuncs) {
-      funcComponents.emplace(f, componentEffects.size() - 1);
-    }
-
-    std::unordered_set<int> calleeSccs;
-    for (Function* caller : ccFuncs) {
-      auto callees = callGraph.find(caller);
-      if (callees == callGraph.end()) {
-        continue;
-      }
-      for (auto* callee : callees->second) {
-        calleeSccs.insert(funcComponents.at(callee));
+    std::vector<Function*> ccFuncs;
+    for (CallGraphNode node : cc) {
+      funcComponents.emplace(node, componentEffects.size() - 1);
+      if (auto** func = std::get_if<Function*>(&node)) {
+        ccFuncs.push_back(*func);
       }
-    }
 
-    // Merge in effects from callees
-    for (int calleeScc : calleeSccs) {
-      const auto& calleeComponentEffects = componentEffects.at(calleeScc);
-      mergeMaybeEffects(ccEffects, calleeComponentEffects);
-    }
+      std::unordered_set<int> calleeSccs;
+      for (CallGraphNode caller : cc) {
+        auto callees = callGraph.find(caller);
+        if (callees == callGraph.end()) {
+          continue;
+        }
+        if (callees != callGraph.end()) {
+          for (CallGraphNode callee : callees->second) {
+            auto sccIt = funcComponents.find(callee);
+            if (sccIt != funcComponents.end()) {
+              calleeSccs.insert(sccIt->second);
+            }
+          }
+        }
+      }
 
-    // Add trap effects for potential cycles.
-    if (ccFuncs.size() > 1) {
-      if (ccEffects != UnknownEffects) {
-        ccEffects->trap = true;
+      // Merge in effects from callees
+      for (int calleeScc : calleeSccs) {
+        const auto& calleeComponentEffects = componentEffects.at(calleeScc);
+        mergeMaybeEffects(ccEffects, calleeComponentEffects);
       }
-    } else {
-      auto* func = ccFuncs[0];
-      if (funcInfos.at(func).calledFunctions.contains(func->name)) {
+
+      // Add trap effects for potential cycles.
+      if (cc.size() > 1) {
         if (ccEffects != UnknownEffects) {
           ccEffects->trap = true;
         }
+      } else if (ccFuncs.size() == 1) {
+        // It's possible for a CC to only contain 1 type, but that is not a
+        // cycle in the call graph.
+        auto* func = ccFuncs[0];
+        if (funcInfos.at(func).calledFunctions.contains(func->name)) {
+          if (ccEffects != UnknownEffects) {
+            ccEffects->trap = true;
+          }
+        }
       }
-    }
 
-    // Aggregate effects within this CC
-    if (ccEffects) {
-      for (Function* f : ccFuncs) {
-        const auto& effects = funcInfos.at(f).effects;
-        mergeMaybeEffects(ccEffects, effects);
+      // Aggregate effects within this CC
+      if (ccEffects) {
+        for (Function* f : ccFuncs) {
+          const auto& effects = funcInfos.at(f).effects;
+          mergeMaybeEffects(ccEffects, effects);
+        }
       }
-    }
 
-    // Assign each function's effects to its CC effects.
-    for (Function* f : ccFuncs) {
-      if (!ccEffects) {
-        funcInfos.at(f).effects = UnknownEffects;
-      } else {
-        funcInfos.at(f).effects.emplace(*ccEffects);
+      // Assign each function's effects to its CC effects.
+      for (Function* f : ccFuncs) {
+        if (!ccEffects) {
+          funcInfos.at(f).effects = UnknownEffects;
+        } else {
+          funcInfos.at(f).effects.emplace(*ccEffects);
+        }
       }
     }
   }
@@ -262,7 +316,8 @@ struct GenerateGlobalEffects : public Pass {
     std::map<Function*, FuncInfo> funcInfos =
       analyzeFuncs(*module, getPassOptions());
 
-    auto callGraph = buildCallGraph(*module, funcInfos);
+    auto callGraph =
+      buildCallGraph(*module, funcInfos, getPassOptions().closedWorld);
 
     propagateEffects(*module, getPassOptions(), funcInfos, callGraph);