Update PassManager's function worklist for newly added SILFunctions

The PassManager should transform all functions in bottom up order.
This is necessary because when optimizations like inlining looks at the
callee function bodies to compute profitability, the callee functions
should have already undergone optimizations to get better profitability
estimates.

The PassManager builds its function worklist based on bottom up order
on initialization. However, newly created SILFunctions due to
specialization etc, are simply appended to the function worklist. This
can cause us to make bad inlining decisions due to inaccurate
profitability estimates. This change now updates the function worklist such
that, all the callees of the newly added SILFunction are proccessed
before it by the PassManager.

Fixes rdar://52202680

Author: meg-gupta

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -274,6 +274,13 @@ class SILPassManager {
   /// Add a pass with a given name.
   void addPassForName(StringRef Name);
 
+  /// The PassManager's function worklist is updated such that all the callees
+  /// in function 'F' are present after function 'F'.
+  void updateFunctionWorklist(SILFunction *F);
+
+  void recursivelyUpdateFunctionWorklist(
+      SILFunction *F, llvm::SmallPtrSetImpl<SILFunction *> &visited);
+
   /// Run the \p TransIdx'th SIL module transform over all the functions in
   /// the module.
   void runModulePass(unsigned TransIdx);

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -729,6 +729,56 @@ void SILPassManager::addFunctionToWorklist(SILFunction *F,
 
   StoredLevel = NewLevel;
   FunctionWorklist.push_back(F);
+  // Update FunctionWorklist such that all the callees in function 'F' are
+  // present after it.
+  updateFunctionWorklist(F);
+}
+
+void SILPassManager::updateFunctionWorklist(SILFunction *F) {
+  llvm::SmallPtrSet<SILFunction*, 16> Visited;
+  recursivelyUpdateFunctionWorklist(F, Visited);
+}
+
+// Recursively update PassManager's FunctionWorklist such that all the callees
+// in function 'F' are present after it.
+void SILPassManager::recursivelyUpdateFunctionWorklist(
+    SILFunction *F, SmallPtrSetImpl<SILFunction *> &Visited) {
+  BasicCalleeAnalysis *BCA = getAnalysis<BasicCalleeAnalysis>();
+  auto findFunc = [this](SILFunction *Func) {
+    return std::find_if(FunctionWorklist.begin(), FunctionWorklist.end(),
+                        [Func](WorklistEntry w) { return w.F == Func; });
+  };
+  auto FuncIt = findFunc(F);
+  if (FuncIt == FunctionWorklist.end()) {
+    return;
+  }
+  auto FuncIndex = std::distance(FunctionWorklist.begin(), FuncIt);
+  if (Visited.find(F) != Visited.end()) {
+    return;
+  }
+  Visited.insert(F);
+  for (auto &B : *F) {
+    for (auto &I : B) {
+      auto FAS = FullApplySite::isa(&I);
+      if (!FAS && !isa<StrongReleaseInst>(&I) && !isa<ReleaseValueInst>(&I))
+        continue;
+      auto Callees = FAS ? BCA->getCalleeList(FAS) : BCA->getCalleeList(&I);
+      for (auto *CalleeFn : Callees) {
+        if (CalleeFn != F) {
+          auto CalleeIt = findFunc(CalleeFn);
+          if (CalleeIt != FunctionWorklist.end()) {
+            assert(CalleeIt->F == CalleeFn);
+            auto CalleeIndex = std::distance(FunctionWorklist.begin(), CalleeIt);
+            if (CalleeIndex < FuncIndex) {
+              FunctionWorklist.erase(CalleeIt);
+              FunctionWorklist.insert(std::next(findFunc(F)), CalleeFn);
+              recursivelyUpdateFunctionWorklist(CalleeFn, Visited);
+            }
+          }
+        }
+      }
+    }
+  }
 }
 
 void SILPassManager::restartWithCurrentFunction(SILTransform *T) {