[CGSCC] Add -abort-on-max-devirt-iterations-reached option

[aeubanks]

Summary

Aborts if we hit the max devirtualization iteration.
Will be useful for testing that changes to devirtualization don't cause
devirtualization to repeat passes more times than necessary.

[rnk]

Code looks good to me as is.

llvm/include/llvm/Analysis/CGSCCPassManager.h

645

This is unrelated to your change, and I could be wrong here, but this seems like an awful lot of templated code that doesn't depend on PassT or Pass. How much of this can be sunk into a .cpp file, similar to the way you pushed down maxDevitIterationsReached?

719

The above thought was brought to you by considering if this LLVM_DEBUG goo should be pushed down into maxDevirtIterationsReached, but I decided it's probably not worth doing.

[aeubanks]

llvm/include/llvm/Analysis/CGSCCPassManager.h

645

Specifically for DevirtSCCRepeatedPass, I'm planning on removing a bunch of it soon :)
But point taken in general, I'll look around for potential savings.

llvm/include/llvm/Analysis/CGSCCPassManager.h

 /// A function to deduce a function pass type and wrap it in the
 /// templated adaptor.
 template <typename FunctionPassT>
 CGSCCToFunctionPassAdaptor<FunctionPassT>
 createCGSCCToFunctionPassAdaptor(FunctionPassT Pass) {
   return CGSCCToFunctionPassAdaptor<FunctionPassT>(std::move(Pass));
 }
 
+/// Checks -abort-on-max-devirt-iterations-reached to see if we should report an
+/// error.
+void maxDevirtIterationsReached();
+
 /// A helper that repeats an SCC pass each time an indirect call is refined to
 /// a direct call by that pass.
 ///
 /// While the CGSCC pass manager works to re-visit SCCs and RefSCCs as they
 /// change shape, we may also want to repeat an SCC pass if it simply refines
 /// an indirect call to a direct call, even if doing so does not alter the
 /// shape of the graph. Note that this only pertains to direct calls to
 /// functions where IPO across the SCC may be able to compute more precise
PreservedAnalyses run(LazyCallGraph::SCC &InitialC, CGSCCAnalysisManager &AM,
 
     for (int Iteration = 0;; ++Iteration) {
 
       if (!PI.runBeforePass<LazyCallGraph::SCC>(Pass, *C))
         continue;
 
       PreservedAnalyses PassPA = Pass.run(*C, AM, CG, UR);
 
       if (UR.InvalidatedSCCs.count(C))
         PI.runAfterPassInvalidated<LazyCallGraph::SCC>(Pass, PassPA);
       else
         PI.runAfterPass<LazyCallGraph::SCC>(Pass, *C, PassPA);
 
       // If the SCC structure has changed, bail immediately and let the outer
       // CGSCC layer handle any iteration to reflect the refined structure.
       if (UR.UpdatedC && UR.UpdatedC != C) {
         PA.intersect(std::move(PassPA));
for (int Iteration = 0;; ++Iteration) {
 
       if (!Devirt) {
         PA.intersect(std::move(PassPA));
         break;
       }
 
       // Otherwise, if we've already hit our max, we're done.
       if (Iteration >= MaxIterations) {
+        maxDevirtIterationsReached();
         LLVM_DEBUG(
             dbgs() << "Found another devirtualization after hitting the max "
                       "number of repetitions ("
                    << MaxIterations << ") on SCC: " << *C << "\n");
         PA.intersect(std::move(PassPA));
         break;
       }
 
       LLVM_DEBUG(

llvm/lib/Analysis/CGSCCPassManager.cpp

 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Analysis/LazyCallGraph.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/PassManagerImpl.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TimeProfiler.h"
+#include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <iterator>
 
 #define DEBUG_TYPE "cgscc"
 
 using namespace llvm;
 
 // Explicit template instantiations and specialization definitions for core
 // template typedefs.
 namespace llvm {
 
+static cl::opt<bool> AbortOnMaxDevirtIterationsReached(
+    "abort-on-max-devirt-iterations-reached",
+    cl::desc("Abort when the max iterations for devirtualization CGSCC repeat "
+             "pass is reached"));
+
 // Explicit instantiations for the core proxy templates.
 template class AllAnalysesOn<LazyCallGraph::SCC>;
 template class AnalysisManager<LazyCallGraph::SCC, LazyCallGraph &>;
 template class PassManager<LazyCallGraph::SCC, CGSCCAnalysisManager,
                            LazyCallGraph &, CGSCCUpdateResult &>;
 template class InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>;
 template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
                                          LazyCallGraph::SCC, LazyCallGraph &>;
for (const auto &OuterInvalidationPair :
         PA.abandon(InnerAnalysisID);
     }
 
     // Now invalidate anything we found.
     FAM.invalidate(F, PA);
   }
 }
 
+void llvm::maxDevirtIterationsReached() {
+  if (AbortOnMaxDevirtIterationsReached)
+    report_fatal_error("Max devirtualization iterations reached");
+}
+
 /// Helper function to update both the \c CGSCCAnalysisManager \p AM and the \c
 /// CGSCCPassManager's \c CGSCCUpdateResult \p UR based on a range of newly
 /// added SCCs.
 ///
 /// The range of new SCCs must be in postorder already. The SCC they were split
 /// out of must be provided as \p C. The current node being mutated and
 /// triggering updates must be passed as \p N.
 ///

llvm/test/Other/cgscc-devirt-iteration.ll

 ; The CGSCC pass manager includes an SCC iteration utility that tracks indirect
 ; calls that are turned into direct calls (devirtualization) and re-visits the
 ; SCC to expose those calls to the SCC-based IPO passes. We trigger
 ; devirtualization here with GVN which forwards a store through a load and to
 ; an indirect call.
 ;
 ; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(function-attrs,function(gvn,instcombine))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=BEFORE
 ; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(devirt<1>(function-attrs,function(gvn,instcombine)))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AFTER --check-prefix=AFTER1
 ; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(devirt<2>(function-attrs,function(gvn,instcombine)))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AFTER --check-prefix=AFTER2
 ;
+; RUN: not --crash opt -abort-on-max-devirt-iterations-reached -aa-pipeline=basic-aa -passes='cgscc(devirt<1>(function-attrs,function(gvn,instcombine)))' -S < %s
+; RUN: opt -abort-on-max-devirt-iterations-reached -aa-pipeline=basic-aa -passes='cgscc(devirt<2>(function-attrs,function(gvn,instcombine)))' -S < %s
+;
 ; We also verify that the real O2 pipeline catches these cases.
 ; RUN: opt -aa-pipeline=basic-aa -passes='default<O2>' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AFTER --check-prefix=AFTER2
 
 declare void @readnone() readnone
 ; CHECK: Function Attrs: readnone
 ; CHECK-NEXT: declare void @readnone()
 
 declare void @unknown()