Remove call graph maintenance from the perf inliner.

This removes the call graph maintenance code from the performance
inliner since we've decided to go in a different direction and rather
than keeping a persistent call graph are instead splitting it up into a
few utilities that can provide the most generally useful information
from the call graph.

I had to add an unfortunate hack here due to the implicit lazy linking
that we have in the compiler, but intend on removing. In theory a change
like this should have resulted in no change in fucntionality, but in
fact not updating the call graph meant not doing some of that lazy
deserialization, which in turn changed what got inlined. This would have
been okay, but it seems to have exposed other bugs in the optimizer, so
I've added in an explicit call to a function that will deserialize newly
devirtualized function references.

Author: Mark Lacey

lib/SILPasses/IPO/PerformanceInliner.cpp

@@ -16,7 +16,6 @@
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/Projection.h"
 #include "swift/SILAnalysis/BasicCalleeAnalysis.h"
-#include "swift/SILAnalysis/CallGraphAnalysis.h"
 #include "swift/SILAnalysis/ColdBlockInfo.h"
 #include "swift/SILAnalysis/DominanceAnalysis.h"
 #include "swift/SILAnalysis/FunctionOrder.h"
@@ -250,22 +249,20 @@ namespace {
     /// \p Caller and the inliner needs to reject this inlining request.
     bool hasInliningCycle(SILFunction *Caller, SILFunction *Callee);
 
-    FullApplySite devirtualizeUpdatingCallGraph(FullApplySite Apply,
-                                                CallGraph &CG);
+    FullApplySite devirtualize(FullApplySite Apply);
 
     bool devirtualizeAndSpecializeApplies(
       llvm::SmallVectorImpl<ApplySite> &Applies,
-        CallGraphAnalysis *CGA,
         SILModuleTransform *MT,
         llvm::SmallVectorImpl<SILFunction *> &WorkList);
 
-    ApplySite specializeGenericUpdatingCallGraph(ApplySite Apply,
-                                                 CallGraph &CG,
-                                  llvm::SmallVectorImpl<ApplySite> &NewApplies);
+    ApplySite specializeGeneric(ApplySite Apply,
+                                llvm::SmallVectorImpl<ApplySite> &NewApplies);
 
-    bool inlineCallsIntoFunction(SILFunction *F, DominanceAnalysis *DA,
-                                 SILLoopAnalysis *LA, CallGraph &CG,
-                              llvm::SmallVectorImpl<FullApplySite> &NewApplies);
+    bool
+    inlineCallsIntoFunction(SILFunction *F, DominanceAnalysis *DA,
+                            SILLoopAnalysis *LA,
+                            llvm::SmallVectorImpl<FullApplySite> &NewApplies);
 
   public:
     SILPerformanceInliner(int threshold,
@@ -275,7 +272,6 @@ namespace {
 
     void inlineDevirtualizeAndSpecialize(SILFunction *WorkItem,
                                          SILModuleTransform *MT,
-                                         CallGraphAnalysis *CGA,
                                          DominanceAnalysis *DA,
                                          SILLoopAnalysis *LA);
   };
@@ -844,30 +840,38 @@ static bool isProfitableInColdBlock(SILFunction *Callee) {
   return true;
 }
 
+/// FIXME: Total hack to work around issues exposed while ripping call
+///        graph maintenance from the inliner.
+static void tryLinkCallee(FullApplySite Apply) {
+  auto *F = Apply.getCalleeFunction();
+  if (!F || F->isDefinition()) return;
+
+  auto &M = Apply.getFunction()->getModule();
+  M.linkFunction(F, SILModule::LinkingMode::LinkAll);
+}
+
+// Attempt to devirtualize. When successful, replaces the old apply
+// with the new one and returns the new one. When unsuccessful returns
+// an empty apply site.
+FullApplySite SILPerformanceInliner::devirtualize(FullApplySite Apply) {
 
-// Attempt to devirtualize, maintaining the call graph if
-// successful. When successful, replaces the old apply with the new
-// one and returns the new one. When unsuccessful returns an empty
-// apply site.
-FullApplySite SILPerformanceInliner::devirtualizeUpdatingCallGraph(
-                                                            FullApplySite Apply,
-                                                                CallGraph &CG) {
   auto NewInstPair = tryDevirtualizeApply(Apply);
   if (!NewInstPair.second)
     return FullApplySite();
 
-  auto NewAI = FullApplySite::isa(NewInstPair.second.getInstruction());
-  CallGraphEditor(&CG).replaceApplyWithNew(Apply, NewAI);
-
   replaceDeadApply(Apply, NewInstPair.first);
+  auto NewApply = FullApplySite(NewInstPair.second.getInstruction());
 
-  return NewAI;
+  // FIXME: This should not be needed. We should instead be linking
+  // everything in up front, including everything transitively
+  // referenced through vtables and witness tables.
+  tryLinkCallee(NewApply);
+
+  return FullApplySite(NewInstPair.second.getInstruction());
 }
 
-ApplySite SILPerformanceInliner::specializeGenericUpdatingCallGraph(
-                                                                ApplySite Apply,
-                                                                CallGraph &CG,
-                                 llvm::SmallVectorImpl<ApplySite> &NewApplies) {
+ApplySite SILPerformanceInliner::specializeGeneric(
+    ApplySite Apply, llvm::SmallVectorImpl<ApplySite> &NewApplies) {
   assert(NewApplies.empty() && "Expected out parameter for new applies!");
 
   if (!Apply.hasSubstitutions())
@@ -892,15 +896,9 @@ ApplySite SILPerformanceInliner::specializeGenericUpdatingCallGraph(
   if (!Specialized)
     return ApplySite();
 
-  // Add the specialization to the call graph.
-  CallGraphEditor Editor(&CG);
-  if (SpecializedFunction)
-    Editor.addNewFunction(SpecializedFunction);
-
   // Track the new applies from the specialization.
   for (auto NewCallSite : Collector.getInstructionPairs())
-    if (auto NewApply = ApplySite::isa(NewCallSite.first))
-      NewApplies.push_back(NewApply);
+    NewApplies.push_back(ApplySite(NewCallSite.first));
 
   auto FullApply = FullApplySite::isa(Apply.getInstruction());
 
@@ -910,19 +908,14 @@ ApplySite SILPerformanceInliner::specializeGenericUpdatingCallGraph(
 
     // Replace the old apply with the new and delete the old.
     replaceDeadApply(Apply, Specialized.getInstruction());
-    Editor.updatePartialApplyUses(Specialized);
 
     return ApplySite(Specialized);
   }
 
-  // Update call graph edges
-  auto SpecializedFullApply = FullApplySite(Specialized.getInstruction());
-  Editor.replaceApplyWithNew(FullApply, SpecializedFullApply);
-
   // Replace the old apply with the new and delete the old.
   replaceDeadApply(Apply, Specialized.getInstruction());
 
-  return SpecializedFullApply;
+  return Specialized;
 }
 
 static void collectAllAppliesInFunction(SILFunction *F,
@@ -935,23 +928,21 @@ static void collectAllAppliesInFunction(SILFunction *F,
         Applies.push_back(Apply);
 }
 
-// Devirtualize and specialize a group of applies, updating the call
-// graph and returning a worklist of newly exposed function references
-// that should be considered for inlining before continuing with the
-// caller that has the passed-in applies.
+// Devirtualize and specialize a group of applies, returning a
+// worklist of newly exposed function references that should be
+// considered for inlining before continuing with the caller that has
+// the passed-in applies.
 //
 // The returned worklist is stacked such that the last things we want
 // to process are earlier on the list.
 //
 // Returns true if any changes were made.
 bool SILPerformanceInliner::devirtualizeAndSpecializeApplies(
                                   llvm::SmallVectorImpl<ApplySite> &Applies,
-                                  CallGraphAnalysis *CGA,
                                   SILModuleTransform *MT,
                                llvm::SmallVectorImpl<SILFunction *> &WorkList) {
   assert(WorkList.empty() && "Expected empty worklist for return results!");
 
-  auto &CG = CGA->getCallGraph();
   bool ChangedAny = false;
 
   // The set of all new function references generated by
@@ -966,16 +957,15 @@ bool SILPerformanceInliner::devirtualizeAndSpecializeApplies(
 
     bool ChangedApply = false;
     if (auto FullApply = FullApplySite::isa(Apply.getInstruction())) {
-      if (auto NewApply = devirtualizeUpdatingCallGraph(FullApply, CG)) {
+      if (auto NewApply = devirtualize(FullApply)) {
         ChangedApply = true;
 
         Apply = ApplySite(NewApply.getInstruction());
       }
     }
 
     llvm::SmallVector<ApplySite, 4> NewApplies;
-    if (auto NewApply = specializeGenericUpdatingCallGraph(Apply, CG,
-                                                           NewApplies)) {
+    if (auto NewApply = specializeGeneric(Apply, NewApplies)) {
       ChangedApply = true;
 
       Apply = NewApply;
@@ -995,10 +985,8 @@ bool SILPerformanceInliner::devirtualizeAndSpecializeApplies(
 
       // TODO: Do we need to invalidate everything at this point?
       // What about side-effects analysis? What about type analysis?
-      CGA->lockInvalidation();
       MT->invalidateAnalysis(Apply.getFunction(),
                              SILAnalysis::InvalidationKind::Everything);
-      CGA->unlockInvalidation();
     }
   }
 
@@ -1075,7 +1063,6 @@ void SILPerformanceInliner::collectAppliesToInline(
 bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller,
                                                     DominanceAnalysis *DA,
                                                     SILLoopAnalysis *LA,
-                                                    CallGraph &CG,
                              llvm::SmallVectorImpl<FullApplySite> &NewApplies) {
   // Don't optimize functions that are marked with the opt.never attribute.
   if (!Caller->shouldOptimize())
@@ -1115,11 +1102,10 @@ bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller,
     SmallVector<SILValue, 8> Args;
     for (const auto &Arg : AI.getArguments())
       Args.push_back(Arg);
-    
-    // As we inline and clone we need to collect instructions that
-    // require updates to the call graph.
+
+    // As we inline and clone we need to collect new applies.
     auto Filter = [](SILInstruction *I) -> bool {
-      return I->mayRelease();
+      return bool(FullApplySite::isa(I));
     };
 
     CloneCollector Collector(Filter);
@@ -1141,17 +1127,8 @@ bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller,
     // we expect it to have happened.
     assert(Success && "Expected inliner to inline this function!");
     llvm::SmallVector<FullApplySite, 4> AppliesFromInlinee;
-    llvm::SmallVector<SILInstruction *, 4> NewCallSites;
-    for (auto &P : Collector.getInstructionPairs()) {
-      NewCallSites.push_back(P.first);
-
-      if (auto FullApply = FullApplySite::isa(P.first)) {
-        AppliesFromInlinee.push_back(FullApply);
-      }
-    }
-
-    CallGraphEditor Editor(&CG);
-    Editor.replaceApplyWithCallSites(AI, NewCallSites);
+    for (auto &P : Collector.getInstructionPairs())
+      AppliesFromInlinee.push_back(FullApplySite(P.first));
 
     recursivelyDeleteTriviallyDeadInstructions(AI.getInstruction(), true);
 
@@ -1175,17 +1152,13 @@ bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller,
 void SILPerformanceInliner::inlineDevirtualizeAndSpecialize(
                                                           SILFunction *Caller,
                                                         SILModuleTransform *MT,
-                                                         CallGraphAnalysis *CGA,
                                                           DominanceAnalysis *DA,
                                                           SILLoopAnalysis *LA) {
-  assert(Caller->isDefinition() &&
-         "Expected only defined functions in the call graph!");
+  assert(Caller->isDefinition() && "Expected only functions with bodies!");
 
   llvm::SmallVector<SILFunction *, 4> WorkList;
   WorkList.push_back(Caller);
 
-  auto &CG = CGA->getOrBuildCallGraph();
-
   while (!WorkList.empty()) {
     llvm::SmallVector<ApplySite, 4> WorkItemApplies;
     SILFunction *CurrentCaller = WorkList.back();
@@ -1196,7 +1169,7 @@ void SILPerformanceInliner::inlineDevirtualizeAndSpecialize(
     // and collect new functions we should inline into as we do
     // so.
     llvm::SmallVector<SILFunction *, 4> NewFuncs;
-    if (devirtualizeAndSpecializeApplies(WorkItemApplies, CGA, MT, NewFuncs)) {
+    if (devirtualizeAndSpecializeApplies(WorkItemApplies, MT, NewFuncs)) {
       WorkList.insert(WorkList.end(), NewFuncs.begin(), NewFuncs.end());
       NewFuncs.clear();
     }
@@ -1229,23 +1202,19 @@ void SILPerformanceInliner::inlineDevirtualizeAndSpecialize(
       // Inlining in turn might result in new applies that we should
       // consider for devirtualization and specialization.
       llvm::SmallVector<FullApplySite, 4> NewApplies;
-      bool Inlined = inlineCallsIntoFunction(WorkItem, DA, LA, CG, NewApplies);
+      bool Inlined = inlineCallsIntoFunction(WorkItem, DA, LA, NewApplies);
       if (Inlined) {
-        // Invalidate analyses, but lock the call graph since we
-        // maintain it.
-        CGA->lockInvalidation();
         MT->invalidateAnalysis(WorkItem,
                                SILAnalysis::InvalidationKind::FunctionBody);
-        CGA->unlockInvalidation();
 
         // FIXME: Update inlineCallsIntoFunction to collect all
         //        remaining applies after inlining, not just those
         //        resulting from inlining code.
         llvm::SmallVector<ApplySite, 4> WorkItemApplies;
         collectAllAppliesInFunction(WorkItem, WorkItemApplies);
 
-        bool Modified = devirtualizeAndSpecializeApplies(WorkItemApplies, CGA,
-                                                         MT, NewFuncs);
+        bool Modified =
+            devirtualizeAndSpecializeApplies(WorkItemApplies, MT, NewFuncs);
         if (Modified) {
           WorkList.insert(WorkList.end(), NewFuncs.begin(), NewFuncs.end());
           NewFuncs.clear();
@@ -1327,7 +1296,6 @@ class SILPerformanceInlinerPass : public SILModuleTransform {
 
   void run() override {
     BasicCalleeAnalysis *BCA = PM->getAnalysis<BasicCalleeAnalysis>();
-    CallGraphAnalysis *CGA = PM->getAnalysis<CallGraphAnalysis>();
     DominanceAnalysis *DA = PM->getAnalysis<DominanceAnalysis>();
     SILLoopAnalysis *LA = PM->getAnalysis<SILLoopAnalysis>();
 
@@ -1352,8 +1320,7 @@ class SILPerformanceInlinerPass : public SILModuleTransform {
 
     // Inline functions bottom up from the leafs.
     while (!WorkList.empty()) {
-      Inliner.inlineDevirtualizeAndSpecialize(WorkList.back(), this, CGA, DA,
-                                              LA);
+      Inliner.inlineDevirtualizeAndSpecialize(WorkList.back(), this, DA, LA);
       WorkList.pop_back();
     }
   }