Option 3: Add another virtual function to CallGraphSCCPass

[GorNishanov]

Summary

/// This methods is invoked by CGManager::RunPassOnSCC after each call
/// to RunOnSCC to query the pass if there were any change made that 
/// require rerunning pipeline again.
virtual bool restartRequested() const { return false; }

Plus: does not break existing code
Minus: requires adding a bool member variable to a pass, to carry information from runOnSCC to restartRequired()

include/llvm/Analysis/CallGraphSCCPass.h

public:
   /// non-recursive (or only self-recursive) functions will have an SCC size of
   /// 1, where recursive portions of the call graph will have SCC size > 1.
   ///
   /// SCC passes that add or delete functions to the SCC are required to update
   /// the SCC list, otherwise stale pointers may be dereferenced.
   ///
   virtual bool runOnSCC(CallGraphSCC &SCC) = 0;
 
+  /// This methods is invoked by CGManager::RunPassOnSCC after each call
+  /// to RunOnSCC to query the pass if there were any change made that 
+  /// require rerunning pipeline again.
+  virtual bool restartRequested() const { return false; }
+
   /// doFinalization - This method is called after the SCC's of the program has
   /// been processed, allowing the pass to do final cleanup as necessary.
   virtual bool doFinalization(CallGraph &CG) {
     return false;
   }
 
   /// Assign pass manager to manager this pass
   void assignPassManager(PMStack &PMS, PassManagerType PMT) override;

lib/Analysis/CallGraphSCCPass.cpp

if (!PM) {
     CallGraphSCCPass *CGSP = (CallGraphSCCPass*)P;
     if (!CallGraphUpToDate) {
       DevirtualizedCall |= RefreshCallGraph(CurSCC, CG, false);
       CallGraphUpToDate = true;
     }
 
     {
       TimeRegion PassTimer(getPassTimer(CGSP));
-      Changed = CGSP->runOnSCC(CurSCC);
+      if (CGSP->runOnSCC(CurSCC)) {
+        Changed = true;
+
+        if (CGSP->restartRequested()) {
+          DEBUG(dbgs() << "  CGSCCPASSMGR: Pipeline restart requested by '"
+            << CGSP->getPassName() << "'\n");
+          DevirtualizedCall = true;
+        }
+      }
     }
     
     // After the CGSCCPass is done, when assertions are enabled, use
     // RefreshCallGraph to verify that the callgraph was correctly updated.
 #ifndef NDEBUG
     if (Changed)
       RefreshCallGraph(CurSCC, CG, true);
 #endif

lib/Transforms/Coroutines/CoroSplit.cpp

 //===----------------------------------------------------------------------===//
 
 namespace {
 
   struct CoroSplit : public CallGraphSCCPass {
     static char ID; // Pass identification, replacement for typeid
     CoroSplit() : CallGraphSCCPass(ID) {}
 
-    bool runOnSCC(CallGraphSCC &SCC) override {
+    bool needToRestart;
+    
+    bool restartRequested() const override { return needToRestart; }
 
+    bool runOnSCC(CallGraphSCC &SCC) override {
+      needToRestart = false;
       // find coroutines for processing
       SmallVector<CoroInitInst*, 4> CIs;
       for (CallGraphNode *CGN : SCC)
         if (auto F = CGN->getFunction())
           if (auto CoroInit =
                   CoroCommon::findCoroInit(F, Phase::PostSplit, false))
             CIs.push_back(CoroInit);
 
       if (CIs.empty())
         return false;
 
       CoroutineShape Shape;
 
       for (CoroInitInst* CoroInit : CIs)
-        if (CoroInit->meta().getPhase() == Phase::NotReadyForSplit) 
+        if (CoroInit->meta().getPhase() == Phase::NotReadyForSplit) {
           preSplitPass(CoroInit, SCC);
+          needToRestart = true;
+        }
         else
           splitCoroutine(CoroInit, Shape);
 
       return true;
     }
   };
 }