Merge pull request swiftlang#34188 from apple/revert-30710-bottomupfunction

Revert "[PassManager] Update PassManager's function worklist for newly added SILFunctions"

For some programs which create large number of specialized functions each with deep call chains. This can cause redundant DFS leading to large compile times. Reverting this until we implement a better incremental DFS for updating the bottom up order of newly added functions.

Author: meg-gupta

include/swift/SILOptimizer/Analysis/FunctionOrder.h

@@ -31,6 +31,7 @@ class BottomUpFunctionOrder {
   typedef TinyPtrVector<SILFunction *> SCC;
 
 private:
+  SILModule &M;
   llvm::SmallVector<SCC, 32> TheSCCs;
   llvm::SmallVector<SILFunction *, 32> TheFunctions;
 
@@ -43,29 +44,24 @@ class BottomUpFunctionOrder {
   llvm::SmallSetVector<SILFunction *, 4> DFSStack;
 
 public:
-  BottomUpFunctionOrder(BasicCalleeAnalysis *BCA)
-      : BCA(BCA), NextDFSNum(0) {}
-
-  /// DFS on 'F' to compute bottom up order
-  void computeBottomUpOrder(SILFunction *F) {
-     DFS(F);
-  }
-
-  /// DFS on all functions in the module to compute bottom up order
-  void computeBottomUpOrder(SILModule *M) {
-    for (auto &F : *M)
-      DFS(&F);
-  }
+  BottomUpFunctionOrder(SILModule &M, BasicCalleeAnalysis *BCA)
+      : M(M), BCA(BCA), NextDFSNum(0) {}
 
   /// Get the SCCs in bottom-up order.
   ArrayRef<SCC> getSCCs() {
+    if (!TheSCCs.empty())
+      return TheSCCs;
+
+    FindSCCs(M);
     return TheSCCs;
   }
 
-  /// Get a flattened view of all functions in all the SCCs in bottom-up order
-  ArrayRef<SILFunction *> getBottomUpOrder() {
+  /// Get a flattened view of all functions in all the SCCs in
+  /// bottom-up order
+  ArrayRef<SILFunction *> getFunctions() {
     if (!TheFunctions.empty())
       return TheFunctions;
+
     for (auto SCC : getSCCs())
       for (auto *F : SCC)
         TheFunctions.push_back(F);
@@ -75,6 +71,7 @@ class BottomUpFunctionOrder {
 
 private:
   void DFS(SILFunction *F);
+  void FindSCCs(SILModule &M);
 };
 
 } // end namespace swift

lib/SILOptimizer/Analysis/FunctionOrder.cpp

@@ -74,3 +74,7 @@ void BottomUpFunctionOrder::DFS(SILFunction *Start) {
   }
 }
 
+void BottomUpFunctionOrder::FindSCCs(SILModule &M) {
+  for (auto &F : M)
+    DFS(&F);
+}

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -514,9 +514,8 @@ runFunctionPasses(unsigned FromTransIdx, unsigned ToTransIdx) {
     return;
 
   BasicCalleeAnalysis *BCA = getAnalysis<BasicCalleeAnalysis>();
-  BottomUpFunctionOrder BottomUpOrder(BCA);
-  BottomUpOrder.computeBottomUpOrder(Mod);
-  auto BottomUpFunctions = BottomUpOrder.getBottomUpOrder();
+  BottomUpFunctionOrder BottomUpOrder(*Mod, BCA);
+  auto BottomUpFunctions = BottomUpOrder.getFunctions();
 
   assert(FunctionWorklist.empty() && "Expected empty function worklist!");
 
@@ -569,47 +568,6 @@ runFunctionPasses(unsigned FromTransIdx, unsigned ToTransIdx) {
       ++Entry.PipelineIdx;
     }
     clearRestartPipeline();
-
-    if (TailIdx == (FunctionWorklist.size() - 1))  {
-      // No new functions to process
-      continue;
-    }
-
-    // Compute the bottom up order of the new functions and the callees in it
-    BottomUpFunctionOrder SubBottomUpOrder(BCA);
-    // Initialize BottomUpFunctionOrder with new functions
-    for (auto It = FunctionWorklist.begin() + TailIdx + 1;
-         It != FunctionWorklist.end(); It++) {
-      SubBottomUpOrder.computeBottomUpOrder(It->F);
-    }
-    auto NewFunctionsBottomUp = SubBottomUpOrder.getBottomUpOrder();
-    SmallPtrSet<SILFunction *, 8> NewBottomUpSet(NewFunctionsBottomUp.begin(),
-                                                 NewFunctionsBottomUp.end());
-
-    // Remove all the functions in the new bottom up order from FunctionWorklist
-    llvm::DenseMap<SILFunction *, WorklistEntry> FunctionsToReorder;
-    auto RemoveFn = [&FunctionsToReorder,
-                     &NewBottomUpSet](WorklistEntry Entry) {
-      if (NewBottomUpSet.find(Entry.F) == NewBottomUpSet.end()) {
-        return false;
-      }
-      FunctionsToReorder.insert(std::make_pair(Entry.F, Entry));
-      return true;
-    };
-    std::remove_if(FunctionWorklist.begin(), FunctionWorklist.end(), RemoveFn);
-    FunctionWorklist.erase((FunctionWorklist.begin() + FunctionWorklist.size() -
-                            FunctionsToReorder.size()),
-                           FunctionWorklist.end());
-
-    // Add back the functions in the new bottom up order to the FunctionWorklist
-    for (auto it = NewFunctionsBottomUp.rbegin();
-         it != NewFunctionsBottomUp.rend(); it++) {
-      auto Entry = FunctionsToReorder.find(*it);
-      if (Entry == FunctionsToReorder.end()) {
-        continue;
-      }
-      FunctionWorklist.push_back((*Entry).second);
-    }
   }
 }
 

lib/SILOptimizer/UtilityPasses/FunctionOrderPrinter.cpp

@@ -35,8 +35,8 @@ class FunctionOrderPrinterPass : public SILModuleTransform {
   /// The entry point to the transformation.
   void run() override {
     BCA = getAnalysis<BasicCalleeAnalysis>();
-    BottomUpFunctionOrder Orderer(BCA);
-    Orderer.computeBottomUpOrder(getModule());
+    auto &M = *getModule();
+    BottomUpFunctionOrder Orderer(M, BCA);
 
     llvm::outs() << "Bottom up function order:\n";
     auto SCCs = Orderer.getSCCs();

test/DebugInfo/inlined-generics-basic.swift

@@ -91,9 +91,9 @@ public class C<R> {
 // IR-LABEL: ret void
 
 // IR: ![[BOOL:[0-9]+]] = !DICompositeType({{.*}}name: "Bool"
+// IR: ![[LET_BOOL:[0-9]+]] = !DIDerivedType(tag: DW_TAG_const_type, baseType: ![[BOOL]])
 // IR: ![[INT:[0-9]+]] = !DICompositeType({{.*}}name: "Int"
 // IR: ![[LET_INT:[0-9]+]] = !DIDerivedType(tag: DW_TAG_const_type, baseType: ![[INT]])
-// IR: ![[LET_BOOL:[0-9]+]] = !DIDerivedType(tag: DW_TAG_const_type, baseType: ![[BOOL]])
 // IR: ![[TAU_0_0:[0-9]+]] = {{.*}}DW_TAG_structure_type, name: "$sxD",
 // IR: ![[LET_TAU_0_0:[0-9]+]] = !DIDerivedType(tag: DW_TAG_const_type, baseType: ![[TAU_0_0]])
 // IR: ![[TAU_1_0:[0-9]+]] = {{.*}}DW_TAG_structure_type, name: "$sqd__D",