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

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",