[proof of concept] Port old PM CGSCC visitation logic to new PM

[silvas]

Summary

This patch implements a proof of concept port of the old PM CGSCC visitation logic to the new PM. It also ports all the remaining CGSCC passes (inliner, argpromotion, prune-eh). I have done some basic sanity checks to make sure things work. Tomorrow I'll add a CC1 flag to clang that allows running new-PM passes and give test-suite a shot.

This was done as a sort of mad dash to get a proof of concept; all the changes are meant to be as mechanical as possible. I fully expect to have to redo every change here incrementally and with proper attention to detail, but seeing it all come together and working is important IMO. Especially the port of the inliner can be done much more cleanly than I have done here.

Most of the patch is just porting the passes and threading state through various places.

But pay attention to include/llvm/Analysis/CGSCCPassManager.h
That is where the real business happens. Especially the "run" methods of ModuleToPostOrderCGSCCPassAdaptor and CGSCCToFunctionPassAdaptor. In total, they are less than 100 lines of code which are at the heart of this patch.

Thoughts?

[silvas]

With this experience of doing this proof of concept, I can now say with confidence that porting the old CGSCC visitation order interferes minimally with what Chandler is doing in http://reviews.llvm.org/D21464
(I know this because every change that he will have to undo will be a change that I had to do in preparing that patch; I can say that in fact they were a very small part of preparing this patch.
In fact, there is no reason why Chandler's new logic can't live in parallel with this kind of port of the old logic; the hardest part of that is likely to just be deciding on the name for distinguishing the two.
)
There is thus little downside to moving forward with porting the old PM visitation logic to the new PM.

I would like to establish consensus for moving forward with porting the old PM visitation logic to the new PM (or discovering a good reason why that would be a bad idea!). The huge advantage of doing this is that it is as NFC as possible.

[silvas]

I'd like to emphasize that there are still significant work items to be done as part of the transition to the new pass manager: https://llvm.org/bugs/showdependencytree.cgi?id=28315&hide_resolved=1
(Please add more bugs there if there is anything else you can think of!)
In order to get to the point that we can delete all these old-PM shims in the middle-end, we have things like optnone/optbisect, bugpoint support, debug-pass=Structure, and pass manager builder (the new PM doesn't know about dependencies which has the potential to make this quite non-trivial).

I'm sure there will be plenty of other yaks to be found when actually putting the new PM through its paces on real production compilation workloads. There are e.g. lingering issues with excessive memory use due to excessive caching and I'm sure plenty of unknown unknowns. Also unexpected perf swings due to new PM vs old PM will be fun to investigate :)
(One thing I discovered while doing this proof of concept port was that the "normal" use of BasicAA in the new PM uses domtree but it doesn't in the old PM; it was causing crashes in some places (see the note in FunctionAttrs.cpp; domtree would crash on declarations there so I had to add an isDeclaration check))

[silvas]

If it's more convenient for people to fetch, I've also pushed my local git branch to github: https://github.com/chisophugis/llvm/tree/port-cgscc

[silvas]

Updated patch. I've done some cleanup/refactoring on trunk which generally reduces the diff.

This also includes a fix for https://llvm.org/bugs/show_bug.cgi?id=28400
With that fix, this patch now can pass test-suite (build and run) with:

CMAKE_{C,CXX}_FLAGS:STRING=-Xclang "-newpm-passes=module(function(sroa,instcombine,simplify-cfg,jump-threading),globaldce,globalopt,deadargelim,function(sroa,instcombine,simplify-cfg),require<profile-summary>,require<targetlibinfo>,cgscc(prune-eh,inline,function-attrs,argpromotion,function(instcombine,simplify-cfg,instcombine,jump-threading,simplify-cfg)))" -Xclang -newpm-aa-pipeline=basic-aa,scoped-noalias-aa,type-based-aa,globals-aa

I'll continue working towards getting the clang O3 pipeline ported and keep iterating on test-suite.

[davide]

First round of comments. I feel like this patch is important because it shows up the old semantic can be ported to the new PM with (relatively) little effort. I don't quite understand all the corner cases of the CGSCC pass manager but your patch looks to me kinda mechanical (that's actually great because it means the old code fits in the new model nicely). I'll probably comment further, and take another look. As Chandler spent a fair amount of time on the problem I'd really love to hear what's his feedback/what are his comments. While I think that eventually we're going to land his work probably I feel this is still a valuable incremental step (and NFC).

Thanks!

include/llvm/Analysis/CGSCCPassManager.h

104

just remove it ? =)

146

or maybe move this stuff to the destructor? I think Chandler mentioned that's the equivalent of doFinalization() in the new PM

include/llvm/Analysis/CallGraphSCCPass.h

96

Can you please exapnd this comment a little bit more?

include/llvm/Transforms/IPO/ArgumentPromotion.h

20–21

maybe this can be private?

include/llvm/Transforms/IPO/PruneEH.h

19

Do you mind to put a doxygen comment briefly explaining what this struct/class does?

lib/Transforms/IPO/FunctionAttrs.cpp

1076–1079

XXX -> FIXME? Here and everywhere else in the patch where it applies

1134

This preserves the CFG, add a FIXME etc etc...

[silvas]

Thanks for the comments Davide. As a quick reminder, the purpose of this patch is just to be a proof of concept that we can all agree is the right direction (or figure out why not). The patch is not intended to be committed as-is to trunk, so I'd like to avoid discussing usual code hygiene / "janitorial" details -- I've deliberately skimped on some of them or done things in a suboptimal way just to keep things mechanical.

include/llvm/Analysis/CGSCCPassManager.h

104

I guess I should have said this before, but all the things marked with XXX are things that I wanted to highlight for reviewers. They are just comments about non-obvious things that I thought reviewers would find useful. For example, if somebody is looking at the code of CGPassManager::runOnModule and comparing it with here, this will save them the time of going and looking through the existing passes just to come to the same conclusion.

Some of the XXX comments will likely turn into regular comments, other will just be deleted because they are only relevant to this proof of concept and won't be issues for the real patches that will be committed to trunk (e.g. commented-out code :) ).

lib/Transforms/IPO/FunctionAttrs.cpp

1076–1079

It isn't a FIXME. It is a note for reviewers. It will turn into just a regular comment since there isn't really anything to "fix" per se.

[silvas]

Remove workaround for PR28400. I originally misdiagnosed the problem. r274656 is a better fix for the moment.

[silvas]

Sorry I didn't mention this earlier, but the basic idea here is:

1. The outer loop of CGPassManager::runOnModule and CGPassManager::RunAllPassesOnSCC goes in ModuleToPostOrderCGSCCPassAdaptor
2. CGPassManager::RunPassOnSCC goes in the CGSCCToFunctionPassAdaptor

The rest is pretty much just fallout from doing that.

[chandlerc]

Mostly a high-level comment below on the core of this patch's approach.

include/llvm/Analysis/CGSCCPassManager.h

111–123

This is the core of this change, and it highlights the problem I have with this design. But I want to emphasize something: I freely admit that you can fix the immediate failure modes. I'll even suggest how you could do that. I still think that it is a problematic design though, and hopefully this helps surface why.

So, the key thing here is that you are building "stable" SCCs with identity on the fly by allocating CallGraphSCC objects in the vector of unique pointers. You then use their identity to thread the analysis management layers. Notably, you use it to access the FunctionAnalysisManager via the CGSCCAnalysisManager via the ModuleAnalysis manager.

Both the lookup below of the FunctionAnalysisManager's proxy and the invalidate here use this identity.

However, if you were to run multiple CGSCC pass managers one after the other, they would build different SCCs each time. There is no way to persist this, at the end of the CGSCC pass manager run, the SCCs are going away.

To make this code correct, you should probably use the 'clear' method on the CGSCCAnalysisManager at the end of the CGSCC pass manager run. I think there are some bugs in the current pass manager code you'll hit if you do that. We can write some unit tests that hit these (sorry, I missed them when originally working on it) and fix them. Once fixed, that should make this approach correct AFAICT. However, I don't like some of the consequences.

If we fix the bugs in the 'clear' code path in the new pass manager, this will have the effect of invalidating all function analyses computed thus far (assuming it follows the current design direction of the pass manager thus far). And one of the really big goals of the new pass manager design was to reduce the re-computing of analyses through caching.

The way I see to continue to get caching for function analyses with this approach would be to avoid doing downward invalidation[1]. That is, when an SCC pass invalidates SCC analyses, don't have that trigger invalidation of function analyses. We could probably make that direction work, but it would mean manually tracking function analysis invalidation here and in the module pass manager rather than relying on the wiring between the proxies to do this for us.

So that is what I think it would look like to make the approach in this patch at least functional for the passes as they exist in the tree today.

Beyond that, as Sean has said, this doesn't really have a good mechanism to support SCC-based analyses. They will currently work, but they will be cached against an SCC that isn't being updated, and they won't survive the CGSCC pass manager run or be queryable. Notably, if we want an SCC analysis, we won't be able to query it from a module pass without duplicating the logic here to run the SCC iterator over the module and produce SCCs that we can then query the CGAM with.

Now, we have no need of that today. But I think it is a mistake to design in a different limitation like this.

I understand that your goal in this Sean is to make incremental progress. However, I am personally much more interested in figuring out the long term design for the CGSCC passes and the new pass manager. I think it will create churn to maintain all of the different permutations, as I think even with this approach we will have significant differences and challenges with the new pass manager. And so I think we will end up supporting both the legacy pass manager, and this one, *and* the one with stable SCCs that provides a more direct solution to the analysis challenges outlined above.

[1]: "downward invalidation" is something I had planned to add, but hadn't gotten to yet. It clearly would benefit from being visible in the code though, so I'm going to work on a short patch that adds it and unit tests that show how it would work. Naturally, we can always go a different direction if needed.

[silvas]

Update after r276515

[davide]

While I considered this a reasonable approach, it seems Chandler is going in another direction. Feel free to add me back as reviewer in case/when this unblocks.

[reames]

Resigning from a stale review (2016). Feel free to re-add if thread ever revived.

include/llvm/Analysis/CGSCCPassManager.h

 /// call site edge, the callee has already been optimized as much as is
 /// possible. This in turn allows very accurate analysis of it for IPO.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_CGSCCPASSMANAGER_H
 #define LLVM_ANALYSIS_CGSCCPASSMANAGER_H
 
-#include "llvm/Analysis/LazyCallGraph.h"
+#include "llvm/ADT/SCCIterator.h"
+#include "llvm/Analysis/CallGraph.h"
+#include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
-extern template class PassManager<LazyCallGraph::SCC>;
+extern template class PassManager<CallGraphSCC>;
 /// \brief The CGSCC pass manager.
 ///
 /// See the documentation for the PassManager template for details. It runs
 /// a sequency of SCC passes over each SCC that the manager is run over. This
 /// typedef serves as a convenient way to refer to this construct.
-typedef PassManager<LazyCallGraph::SCC> CGSCCPassManager;
+typedef PassManager<CallGraphSCC> CGSCCPassManager;
 
-extern template class AnalysisManager<LazyCallGraph::SCC>;
+extern template class AnalysisManager<CallGraphSCC>;
 /// \brief The CGSCC analysis manager.
 ///
 /// See the documentation for the AnalysisManager template for detail
 /// documentation. This typedef serves as a convenient way to refer to this
 /// construct in the adaptors and proxies used to integrate this into the larger
 /// pass manager infrastructure.
-typedef AnalysisManager<LazyCallGraph::SCC> CGSCCAnalysisManager;
+typedef AnalysisManager<CallGraphSCC> CGSCCAnalysisManager;
 
 extern template class InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>;
 /// A proxy from a \c CGSCCAnalysisManager to a \c Module.
 typedef InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>
     CGSCCAnalysisManagerModuleProxy;
 
 extern template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
-                                                LazyCallGraph::SCC>;
+                                                CallGraphSCC>;
 /// A proxy from a \c ModuleAnalysisManager to an \c SCC.
-typedef OuterAnalysisManagerProxy<ModuleAnalysisManager, LazyCallGraph::SCC>
+typedef OuterAnalysisManagerProxy<ModuleAnalysisManager, CallGraphSCC>
     ModuleAnalysisManagerCGSCCProxy;
 
+extern cl::opt<unsigned> MaxCGSCCIterations;
+
 /// \brief The core module pass which does a post-order walk of the SCCs and
 /// runs a CGSCC pass over each one.
 ///
 /// Designed to allow composition of a CGSCCPass(Manager) and
 /// a ModulePassManager. Note that this pass must be run with a module analysis
 /// manager as it uses the LazyCallGraph analysis. It will also run the
 /// \c CGSCCAnalysisManagerModuleProxy analysis prior to running the CGSCC
 /// pass over the module to enable a \c FunctionAnalysisManager to be used
public:
   ModuleToPostOrderCGSCCPassAdaptor &
   operator=(ModuleToPostOrderCGSCCPassAdaptor RHS) {
     swap(*this, RHS);
     return *this;
   }
 
   /// \brief Runs the CGSCC pass across every SCC in the module.
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) {
-    // Setup the CGSCC analysis manager from its proxy.
+    // This is just a dummy to match the signature of the `run` method. We
+    // don't currently have any CGSCC analyses.
     CGSCCAnalysisManager &CGAM =
         AM.getResult<CGSCCAnalysisManagerModuleProxy>(M).getManager();
 
-    // Get the call graph for this module.
-    LazyCallGraph &CG = AM.getResult<LazyCallGraphAnalysis>(M);
+    CallGraph &CG = AM.getResult<CallGraphAnalysis>(M);
+
+    // XXX: no existing CGSCC passes use this.
+    //bool Changed = doInitialization(CG);
+
+    // Walk the callgraph in bottom-up SCC order.
+    scc_iterator<CallGraph*> CGI = scc_begin(&CG);
 
     PreservedAnalyses PA = PreservedAnalyses::all();
-    for (LazyCallGraph::RefSCC &RC : CG.postorder_ref_sccs()) {
-      if (DebugLogging)
-        dbgs() << "Running an SCC pass across the RefSCC: " << RC << "\n";
-
-      for (LazyCallGraph::SCC &C : RC) {
-        PreservedAnalyses PassPA = Pass.run(C, CGAM);
-
-        // We know that the CGSCC pass couldn't have invalidated any other
-        // SCC's analyses (that's the contract of a CGSCC pass), so
-        // directly handle the CGSCC analysis manager's invalidation here. We
-        // also update the preserved set of analyses to reflect that invalidated
-        // analyses are now safe to preserve.
-        // FIXME: This isn't quite correct. We need to handle the case where the
-        // pass updated the CG, particularly some child of the current SCC, and
-        // invalidate its analyses.
-        PassPA = CGAM.invalidate(C, std::move(PassPA));
+    std::vector<std::unique_ptr<CallGraphSCC>> SCCs;
+    while (!CGI.isAtEnd()) {
+      const std::vector<CallGraphNode *> &NodeVec = *CGI;
+      SCCs.emplace_back(llvm::make_unique<CallGraphSCC>(CG, &CGI, NodeVec));
+      // Copy the current SCC and increment past it so that the pass can hack
+      // on the SCC if it wants to without invalidating our iterator.
+      ++CGI;
+      CallGraphSCC &CurSCC = *SCCs.back();
+      for (int i = 0; i < (int)MaxCGSCCIterations; i++) {
+
+        PreservedAnalyses PassPA = Pass.run(CurSCC, CGAM);
+
+        PassPA = CGAM.invalidate(CurSCC, std::move(PassPA));
 
-        // Then intersect the preserved set so that invalidation of module
-        // analyses will eventually occur when the module pass completes.
         PA.intersect(std::move(PassPA));
+
+        if (CurSCC.DevirtualizedCall) {
+          DEBUG_WITH_TYPE("new-cgscc-pm", {
+            dbgs() << "Devirtualized call " << i << "\n";
+            CurSCC.print(dbgs());
+            dbgs() << "\n";
+          });
+
+          // Reset this flag and keep looping.
+          CurSCC.DevirtualizedCall = false;
+          continue;
+        }
+        break;
       }
     }
 
-    // By definition we preserve the proxy. This precludes *any* invalidation
-    // of CGSCC analyses by the proxy, but that's OK because we've taken
-    // care to invalidate analyses in the CGSCC analysis manager
-    // incrementally above.
-    PA.preserve<CGSCCAnalysisManagerModuleProxy>();
+    // XXX: The only use of this for CGSCC passes is in the inliner which
+    // just calls removeDeadFunctions. What to do about this?
+    // Should we just do a run of globaldce after the CGSCC visitation is
+    // done?
+    //Changed |= doFinalization(CG);
     return PA;
   }
 
 private:
   CGSCCPassT Pass;
   bool DebugLogging;
 };
 
 /// \brief A function to deduce a function pass type and wrap it in the
 /// templated adaptor.
 template <typename CGSCCPassT>
 ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>
 createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT Pass, bool DebugLogging = false) {
   return ModuleToPostOrderCGSCCPassAdaptor<CGSCCPassT>(std::move(Pass), DebugLogging);
 }
 
 extern template class InnerAnalysisManagerProxy<FunctionAnalysisManager,
-                                                LazyCallGraph::SCC>;
+                                                CallGraphSCC>;
 /// A proxy from a \c FunctionAnalysisManager to an \c SCC.
-typedef InnerAnalysisManagerProxy<FunctionAnalysisManager, LazyCallGraph::SCC>
+typedef InnerAnalysisManagerProxy<FunctionAnalysisManager, CallGraphSCC>
     FunctionAnalysisManagerCGSCCProxy;
 
 extern template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>;
 /// A proxy from a \c CGSCCAnalysisManager to a \c Function.
 typedef OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>
     CGSCCAnalysisManagerFunctionProxy;
 
 /// \brief Adaptor that maps from a SCC to its functions.
friend void swap(CGSCCToFunctionPassAdaptor &LHS,
     swap(LHS.DebugLogging, RHS.DebugLogging);
   }
   CGSCCToFunctionPassAdaptor &operator=(CGSCCToFunctionPassAdaptor RHS) {
     swap(*this, RHS);
     return *this;
   }
 
   /// \brief Runs the function pass across every function in the module.
-  PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) {
+  PreservedAnalyses run(CallGraphSCC &C, CGSCCAnalysisManager &AM) {
     // Setup the function analysis manager from its proxy.
     FunctionAnalysisManager &FAM =
         AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
 
-    if (DebugLogging)
-      dbgs() << "Running function passes across an SCC: " << C << "\n";
+    // XXX: enable after adding ostream operator for CallGraphSCC.
+    //if (DebugLogging)
+    //  dbgs() << "Running function passes across an SCC: " << C << "\n";
 
     PreservedAnalyses PA = PreservedAnalyses::all();
-    for (LazyCallGraph::Node &N : C) {
-      PreservedAnalyses PassPA = Pass.run(N.getFunction(), FAM);
+    for (CallGraphNode *N : C) {
+      Function *F = N->getFunction();
+      // XXX: CallGraphSCC may have a null function (for the special "calls
+      // external" and "called by external") nodes.
+      // Also, there may be declarations.
+      if (!F || F->isDeclaration())
+        continue;
+      PreservedAnalyses PassPA = Pass.run(*F, FAM);
 
       // We know that the function pass couldn't have invalidated any other
       // function's analyses (that's the contract of a function pass), so
       // directly handle the function analysis manager's invalidation here.
       // Also, update the preserved analyses to reflect that once invalidated
       // these can again be preserved.
-      PassPA = FAM.invalidate(N.getFunction(), std::move(PassPA));
+      PassPA = FAM.invalidate(*F, std::move(PassPA));
 
       // Then intersect the preserved set so that invalidation of module
       // analyses will eventually occur when the module pass completes.
       PA.intersect(std::move(PassPA));
     }
 
+    C.DevirtualizedCall = RefreshCallGraph(C, C.getCallGraph(), false);
+    PA.preserve<CallGraphAnalysis>();
+
     // By definition we preserve the proxy. This precludes *any* invalidation
     // of function analyses by the proxy, but that's OK because we've taken
     // care to invalidate analyses in the function analysis manager
     // incrementally above.
     // FIXME: We need to update the call graph here to account for any deleted
     // edges!
     PA.preserve<FunctionAnalysisManagerCGSCCProxy>();
     return PA;

include/llvm/Analysis/CallGraphSCCPass.h

 protected:
   /// Optional passes call this function to check whether the pass should be
   /// skipped. This is the case when optimization bisect is over the limit.
   bool skipSCC(CallGraphSCC &SCC) const;
 };
 
 /// CallGraphSCC - This is a single SCC that a CallGraphSCCPass is run on.
 class CallGraphSCC {
-  const CallGraph &CG; // The call graph for this SCC.
+  CallGraph &CG; // The call graph for this SCC.
   void *Context; // The CGPassManager object that is vending this.
   std::vector<CallGraphNode*> Nodes;
-
 public:
+
+  // XXX: hack for CGSCC pass manager to pass stuff back up to the
+  // ModuleToPostOrderCGSCCPassAdaptor's main visitation loop.
+  // Also, this should really be called "revisit this SCC".
+  bool DevirtualizedCall = false;
+
   CallGraphSCC(CallGraph &cg, void *context) : CG(cg), Context(context) {}
 
+  // The vector is copied.
+  CallGraphSCC(CallGraph &cg, void *context, std::vector<CallGraphNode *> nodes)
+      : CG(cg), Context(context), Nodes(nodes) {}
+
   void initialize(CallGraphNode *const *I, CallGraphNode *const *E) {
     Nodes.assign(I, E);
   }
 
   bool isSingular() const { return Nodes.size() == 1; }
   unsigned size() const { return Nodes.size(); }
 
   /// ReplaceNode - This informs the SCC and the pass manager that the specified
   /// Old node has been deleted, and New is to be used in its place.
   void ReplaceNode(CallGraphNode *Old, CallGraphNode *New);
 
   typedef std::vector<CallGraphNode *>::const_iterator iterator;
   iterator begin() const { return Nodes.begin(); }
   iterator end() const { return Nodes.end(); }
 
-  const CallGraph &getCallGraph() { return CG; }
+  CallGraph &getCallGraph() { return CG; }
+  StringRef getName() {
+    if (!Nodes.empty())
+      if (CallGraphNode *Node = Nodes.front())
+        if (Function *F = Node->getFunction())
+          return F->getName();
+    return "Null SCC";
+  }
+  void print(raw_ostream &OS) {
+    if (Nodes.empty() || !Nodes.front() || !Nodes.front()->getFunction()) {
+      OS << "Null SCC";
+      return;
+    }
+    for (CallGraphNode *Node : Nodes) {
+      if (!Node || !Node->getFunction()) {
+        OS << "null ";
+        continue;
+      }
+      OS << Node->getFunction()->getName() << " ";
+    }
+  }
 };
 
+/// Scan the functions in the specified CFG and resync the
+/// callgraph with the call sites found in it.  This is used after
+/// FunctionPasses have potentially munged the callgraph, and can be used after
+/// CallGraphSCC passes to verify that they correctly updated the callgraph.
+///
+/// This function returns true if it devirtualized an existing function call,
+/// meaning it turned an indirect call into a direct call.  This happens when
+/// a function pass like GVN optimizes away stuff feeding the indirect call.
+/// This never happens in checking mode.
+///
+bool RefreshCallGraph(CallGraphSCC &CurSCC, CallGraph &CG, bool IsCheckingMode);
+
 void initializeDummyCGSCCPassPass(PassRegistry &);
 
 /// This pass is required by interprocedural register allocation. It forces
 /// codegen to follow bottom up order on call graph.
 class DummyCGSCCPass : public CallGraphSCCPass {
 public:
   static char ID;
   DummyCGSCCPass() : CallGraphSCCPass(ID) {

include/llvm/Transforms/IPO/ArgumentPromotion.h

+//===-- ArgumentPromotion.h - Promote by-reference arguments --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_ARGUMENTPROMOTION_H
+#define LLVM_TRANSFORMS_IPO_ARGUMENTPROMOTION_H
+
+#include "llvm/Analysis/CGSCCPassManager.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct ArgumentPromotionPass : PassInfoMixin<ArgumentPromotionPass> {
+  /// The maximum number of elements to expand, or 0 for unlimited.
+  unsigned MaxElements = 3;
+  PreservedAnalyses run(CallGraphSCC &C, CGSCCAnalysisManager &AM);
+};
+
+}
+
+#endif // LLVM_TRANSFORMS_IPO_ARGUMENTPROMOTION_H

include/llvm/Transforms/IPO/FunctionAttrs.h

 /// By operating in post-order, this pass computes precise attributes for
 /// called functions prior to processsing their callers. This "bottom-up"
 /// approach allows powerful interprocedural inference of function attributes
 /// like memory access patterns, etc. It can discover functions that do not
 /// access memory, or only read memory, and give them the readnone/readonly
 /// attribute. It also discovers function arguments that are not captured by
 /// the function and marks them with the nocapture attribute.
 struct PostOrderFunctionAttrsPass : PassInfoMixin<PostOrderFunctionAttrsPass> {
-  PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM);
+  PreservedAnalyses run(CallGraphSCC &C, CGSCCAnalysisManager &AM);
 };
 
 /// Create a legacy pass manager instance of a pass to compute function attrs
 /// in post-order.
 Pass *createPostOrderFunctionAttrsLegacyPass();
 
 /// A pass to do RPO deduction and propagation of function attributes.
 ///

include/llvm/Transforms/IPO/InlinerPass.h

 // subclass determines WHAT to inline, which is the much more interesting
 // component.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_IPO_INLINERPASS_H
 #define LLVM_TRANSFORMS_IPO_INLINERPASS_H
 
+#include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/InlineCost.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 
 namespace llvm {
 class AssumptionCacheTracker;
 class CallSite;
 class DataLayout;
private:
   // InsertLifetime - Insert @llvm.lifetime intrinsics.
   bool InsertLifetime;
 
 protected:
   AssumptionCacheTracker *ACT;
   ProfileSummaryInfo *PSI;
 };
 
+struct InlinerPass : public PassInfoMixin<InlinerPass> {
+  int DefaultThreshold = llvm::getDefaultInlineThreshold();
+  bool InsertLifetime = true;
+  PreservedAnalyses run(CallGraphSCC &C, CGSCCAnalysisManager &AM);
+};
+
 } // End llvm namespace
 
 #endif

include/llvm/Transforms/IPO/PruneEH.h

+//===- PruneEH.h - Pass which deletes unused exception handlers -----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_IPO_PRUNEEH_H
+#define LLVM_TRANSFORMS_IPO_PRUNEEH_H
+
+#include "llvm/Analysis/CGSCCPassManager.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct PruneEHPass : PassInfoMixin<PruneEHPass> {
+  PreservedAnalyses run(CallGraphSCC &C, CGSCCAnalysisManager &AM);
+};
+
+}
+
+#endif // LLVM_TRANSFORMS_IPO_PRUNEEH_H

lib/Analysis/CGSCCPassManager.cpp

 //===- CGSCCPassManager.cpp - Managing & running CGSCC passes -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/CGSCCPassManager.h"
 
 using namespace llvm;
 
 // Explicit instantiations for the core proxy templates.
 namespace llvm {
-template class PassManager<LazyCallGraph::SCC>;
-template class AnalysisManager<LazyCallGraph::SCC>;
+template class PassManager<CallGraphSCC>;
+template class AnalysisManager<CallGraphSCC>;
 template class InnerAnalysisManagerProxy<CGSCCAnalysisManager, Module>;
-template class OuterAnalysisManagerProxy<ModuleAnalysisManager,
-                                         LazyCallGraph::SCC>;
-template class InnerAnalysisManagerProxy<FunctionAnalysisManager,
-                                         LazyCallGraph::SCC>;
+template class OuterAnalysisManagerProxy<ModuleAnalysisManager, CallGraphSCC>;
+template class InnerAnalysisManagerProxy<FunctionAnalysisManager, CallGraphSCC>;
 template class OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>;
 }

lib/Analysis/CallGraphSCCPass.cpp

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "cgscc-passmgr"
 
-static cl::opt<unsigned> 
-MaxIterations("max-cg-scc-iterations", cl::ReallyHidden, cl::init(4));
+namespace llvm {
+cl::opt<unsigned> MaxCGSCCIterations("max-cg-scc-iterations", cl::ReallyHidden,
+                                     cl::init(4));
+}
 
 STATISTIC(MaxSCCIterations, "Maximum CGSCCPassMgr iterations on one SCC");
 
 //===----------------------------------------------------------------------===//
 // CGPassManager
 //
 /// CGPassManager manages FPPassManagers and CallGraphSCCPasses.
 

   
 private:
   bool RunAllPassesOnSCC(CallGraphSCC &CurSCC, CallGraph &CG,
                          bool &DevirtualizedCall);
   
   bool RunPassOnSCC(Pass *P, CallGraphSCC &CurSCC,
                     CallGraph &CG, bool &CallGraphUpToDate,
                     bool &DevirtualizedCall);
-  bool RefreshCallGraph(CallGraphSCC &CurSCC, CallGraph &CG,
-                        bool IsCheckingMode);
 };
 
 } // end anonymous namespace.
 
 char CGPassManager::ID = 0;
 
 
 bool CGPassManager::RunPassOnSCC(Pass *P, CallGraphSCC &CurSCC,
#endif
   if (Changed && CallGraphUpToDate) {
     DEBUG(dbgs() << "CGSCCPASSMGR: Pass Dirtied SCC: "
                  << P->getPassName() << '\n');
     CallGraphUpToDate = false;
   }
   return Changed;
 }
 
-
-/// Scan the functions in the specified CFG and resync the
-/// callgraph with the call sites found in it.  This is used after
-/// FunctionPasses have potentially munged the callgraph, and can be used after
-/// CallGraphSCC passes to verify that they correctly updated the callgraph.
-///
-/// This function returns true if it devirtualized an existing function call,
-/// meaning it turned an indirect call into a direct call.  This happens when
-/// a function pass like GVN optimizes away stuff feeding the indirect call.
-/// This never happens in checking mode.
-///
-bool CGPassManager::RefreshCallGraph(CallGraphSCC &CurSCC,
-                                     CallGraph &CG, bool CheckingMode) {
+bool llvm::RefreshCallGraph(CallGraphSCC &CurSCC, CallGraph &CG,
+                            bool CheckingMode) {
   DenseMap<Value*, CallGraphNode*> CallSites;
   
   DEBUG(dbgs() << "CGSCCPASSMGR: Refreshing SCC with " << CurSCC.size()
                << " nodes:\n";
         for (CallGraphNode *CGN : CurSCC)
           CGN->dump();
         );
 
while (!CGI.isAtEnd()) {
     unsigned Iteration = 0;
     bool DevirtualizedCall = false;
     do {
       DEBUG(if (Iteration)
               dbgs() << "  SCCPASSMGR: Re-visiting SCC, iteration #"
                      << Iteration << '\n');
       DevirtualizedCall = false;
       Changed |= RunAllPassesOnSCC(CurSCC, CG, DevirtualizedCall);
-    } while (Iteration++ < MaxIterations && DevirtualizedCall);
+    } while (Iteration++ < MaxCGSCCIterations && DevirtualizedCall);
     
     if (DevirtualizedCall)
       DEBUG(dbgs() << "  CGSCCPASSMGR: Stopped iteration after " << Iteration
                    << " times, due to -max-cg-scc-iterations\n");
     
     if (Iteration > MaxSCCIterations)
       MaxSCCIterations = Iteration;
     

lib/Passes/PassBuilder.cpp

 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/GCOVProfiler.h"
+#include "llvm/Transforms/IPO/ArgumentPromotion.h"
 #include "llvm/Transforms/IPO/ConstantMerge.h"
 #include "llvm/Transforms/IPO/CrossDSOCFI.h"
 #include "llvm/Transforms/IPO/DeadArgumentElimination.h"
 #include "llvm/Transforms/IPO/ElimAvailExtern.h"
 #include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
 #include "llvm/Transforms/IPO/FunctionAttrs.h"
 #include "llvm/Transforms/IPO/FunctionImport.h"
 #include "llvm/Transforms/IPO/GlobalDCE.h"
 #include "llvm/Transforms/IPO/GlobalOpt.h"
 #include "llvm/Transforms/IPO/InferFunctionAttrs.h"
+#include "llvm/Transforms/IPO/InlinerPass.h"
 #include "llvm/Transforms/IPO/Internalize.h"
 #include "llvm/Transforms/IPO/LowerTypeTests.h"
 #include "llvm/Transforms/IPO/PartialInlining.h"
+#include "llvm/Transforms/IPO/PruneEH.h"
 #include "llvm/Transforms/IPO/SCCP.h"
 #include "llvm/Transforms/IPO/StripDeadPrototypes.h"
 #include "llvm/Transforms/IPO/WholeProgramDevirt.h"
 #include "llvm/Transforms/InstCombine/InstCombine.h"
 #include "llvm/Transforms/InstrProfiling.h"
 #include "llvm/Transforms/PGOInstrumentation.h"
 #include "llvm/Transforms/SampleProfile.h"
 #include "llvm/Transforms/Scalar/ADCE.h"

 public:
   struct Result {};
   Result run(Module &, AnalysisManager<Module> &) { return Result(); }
   static StringRef name() { return "NoOpModuleAnalysis"; }
 };
 
 /// \brief No-op CGSCC pass which does nothing.
 struct NoOpCGSCCPass {
-  PreservedAnalyses run(LazyCallGraph::SCC &C,
-                        AnalysisManager<LazyCallGraph::SCC> &) {
+  PreservedAnalyses run(CallGraphSCC &C, AnalysisManager<CallGraphSCC> &) {
     return PreservedAnalyses::all();
   }
   static StringRef name() { return "NoOpCGSCCPass"; }
 };
 
 /// \brief No-op CGSCC analysis.
 class NoOpCGSCCAnalysis : public AnalysisInfoMixin<NoOpCGSCCAnalysis> {
   friend AnalysisInfoMixin<NoOpCGSCCAnalysis>;
   static char PassID;
 
 public:
   struct Result {};
-  Result run(LazyCallGraph::SCC &, AnalysisManager<LazyCallGraph::SCC> &) {
+  Result run(CallGraphSCC &, AnalysisManager<CallGraphSCC> &) {
     return Result();
   }
   static StringRef name() { return "NoOpCGSCCAnalysis"; }
 };
 
 /// \brief No-op function pass which does nothing.
 struct NoOpFunctionPass {
   PreservedAnalyses run(Function &F, AnalysisManager<Function> &) {

lib/Passes/PassRegistry.def

 CGSCC_ANALYSIS("no-op-cgscc", NoOpCGSCCAnalysis())
 #undef CGSCC_ANALYSIS
 
 #ifndef CGSCC_PASS
 #define CGSCC_PASS(NAME, CREATE_PASS)
 #endif
 CGSCC_PASS("invalidate<all>", InvalidateAllAnalysesPass())
 CGSCC_PASS("function-attrs", PostOrderFunctionAttrsPass())
+CGSCC_PASS("inline", InlinerPass())
+CGSCC_PASS("prune-eh", PruneEHPass())
+CGSCC_PASS("argpromotion", ArgumentPromotionPass())
 CGSCC_PASS("no-op-cgscc", NoOpCGSCCPass())
 #undef CGSCC_PASS
 
 #ifndef FUNCTION_ANALYSIS
 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
 #endif
 FUNCTION_ANALYSIS("aa", AAManager())
 FUNCTION_ANALYSIS("assumptions", AssumptionAnalysis())

lib/Transforms/IPO/ArgumentPromotion.cpp

 //
 // Note that this transformation could also be done for arguments that are only
 // stored to (returning the value instead), but does not currently.  This case
 // would be best handled when and if LLVM begins supporting multiple return
 // values from functions.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Transforms/IPO/ArgumentPromotion.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/BasicAliasAnalysis.h"
 #include "llvm/Analysis/CallGraph.h"
else
     F->setLinkage(Function::ExternalLinkage);
   
   return NF_CGN;
 }
 
 bool ArgPromotion::doInitialization(CallGraph &CG) {
   return CallGraphSCCPass::doInitialization(CG);
 }
+PreservedAnalyses ArgumentPromotionPass::run(CallGraphSCC &C,
+                                             CGSCCAnalysisManager &AM) {
+  // XXX: do this to make sure we get the real call graph used by the
+  // ModuleToPostOrderCGSCCPassAdaptor. Can we do something more "correct"
+  // here?
+  CallGraph &CG = C.getCallGraph();
+  FunctionAnalysisManager &FAM =
+      AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
+  std::function<AAResults &(Function & F)> AARGetter = [&](
+      Function &F) -> AAResults & { return FAM.getResult<AAManager>(F); };
+
+  bool Changed = runImpl(C, CG, AARGetter, MaxElements);
+  if (Changed)
+    return PreservedAnalyses::none();
+  return PreservedAnalyses::all();
+}

lib/Transforms/IPO/FunctionAttrs.cpp

for (Instruction &I : instructions(*F))
     }
 
   // Every call was to a non-recursive function other than this function, and
   // we have no indirect recursion as the SCC size is one. This function cannot
   // recurse.
   return setDoesNotRecurse(*F);
 }
 
-PreservedAnalyses PostOrderFunctionAttrsPass::run(LazyCallGraph::SCC &C,
-                                                  CGSCCAnalysisManager &AM) {
-  FunctionAnalysisManager &FAM =
-      AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
-
-  // We pass a lambda into functions to wire them up to the analysis manager
-  // for getting function analyses.
-  auto AARGetter = [&](Function &F) -> AAResults & {
-    return FAM.getResult<AAManager>(F);
-  };
-
-  // Fill SCCNodes with the elements of the SCC. Also track whether there are
-  // any external or opt-none nodes that will prevent us from optimizing any
-  // part of the SCC.
-  SCCNodeSet SCCNodes;
-  bool HasUnknownCall = false;
-  for (LazyCallGraph::Node &N : C) {
-    Function &F = N.getFunction();
-    if (F.hasFnAttribute(Attribute::OptimizeNone)) {
-      // Treat any function we're trying not to optimize as if it were an
-      // indirect call and omit it from the node set used below.
-      HasUnknownCall = true;
-      continue;
-    }
-    // Track whether any functions in this SCC have an unknown call edge.
-    // Note: if this is ever a performance hit, we can common it with
-    // subsequent routines which also do scans over the instructions of the
-    // function.
-    if (!HasUnknownCall)
-      for (Instruction &I : instructions(F))
-        if (auto CS = CallSite(&I))
-          if (!CS.getCalledFunction()) {
-            HasUnknownCall = true;
-            break;
-          }
-
-    SCCNodes.insert(&F);
-  }
-
-  bool Changed = false;
-  Changed |= addArgumentReturnedAttrs(SCCNodes);
-  Changed |= addReadAttrs(SCCNodes, AARGetter);
-  Changed |= addArgumentAttrs(SCCNodes);
-
-  // If we have no external nodes participating in the SCC, we can deduce some
-  // more precise attributes as well.
-  if (!HasUnknownCall) {
-    Changed |= addNoAliasAttrs(SCCNodes);
-    Changed |= addNonNullAttrs(SCCNodes);
-    Changed |= removeConvergentAttrs(SCCNodes);
-    Changed |= addNoRecurseAttrs(SCCNodes);
-  }
-
-  return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
-}
-
 namespace {
 struct PostOrderFunctionAttrsLegacyPass : public CallGraphSCCPass {
   static char ID; // Pass identification, replacement for typeid
   PostOrderFunctionAttrsLegacyPass() : CallGraphSCCPass(ID) {
     initializePostOrderFunctionAttrsLegacyPassPass(*PassRegistry::getPassRegistry());
   }
 
   bool runOnSCC(CallGraphSCC &SCC) override;
static bool runImpl(CallGraphSCC &SCC, AARGetterT AARGetter) {
   // Fill SCCNodes with the elements of the SCC. Used for quickly looking up
   // whether a given CallGraphNode is in this SCC. Also track whether there are
   // any external or opt-none nodes that will prevent us from optimizing any
   // part of the SCC.
   SCCNodeSet SCCNodes;
   bool ExternalNode = false;
   for (CallGraphNode *I : SCC) {
     Function *F = I->getFunction();
-    if (!F || F->hasFnAttribute(Attribute::OptimizeNone)) {
+    // XXX: The isDeclaration check here is because in the new PM BasicAA
+    // uses DomTree which will cause it to crash on declarations.
+    if (!F || F->isDeclaration() ||
+        F->hasFnAttribute(Attribute::OptimizeNone)) {
       // External node or function we're trying not to optimize - we both avoid
       // transform them and avoid leveraging information they provide.
       ExternalNode = true;
       continue;
     }
 
     SCCNodes.insert(F);
   }
auto AARGetter = [&](Function &F) -> AAResults & {
     BAR.emplace(createLegacyPMBasicAAResult(*this, F));
     AAR.emplace(createLegacyPMAAResults(*this, F, *BAR));
     return *AAR;
   };
 
   return runImpl(SCC, AARGetter);
 }
 
+PreservedAnalyses PostOrderFunctionAttrsPass::run(CallGraphSCC &C,
+                                                  CGSCCAnalysisManager &AM) {
+  FunctionAnalysisManager &FAM =
+      AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
+
+  // We pass a lambda into functions to wire them up to the analysis manager
+  // for getting function analyses.
+  auto AARGetter = [&](Function &F) -> AAResults & {
+    return FAM.getResult<AAManager>(F);
+  };
+
+  return runImpl(C, AARGetter) ? PreservedAnalyses::none()
+                               : PreservedAnalyses::all();
+}
+
+
 namespace {
 struct ReversePostOrderFunctionAttrsLegacyPass : public ModulePass {
   static char ID; // Pass identification, replacement for typeid
   ReversePostOrderFunctionAttrsLegacyPass() : ModulePass(ID) {
     initializeReversePostOrderFunctionAttrsLegacyPassPass(*PassRegistry::getPassRegistry());
   }
 
   bool runOnModule(Module &M) override;

lib/Transforms/IPO/Inliner.cpp

FunctionsToRemove.erase(std::unique(FunctionsToRemove.begin(),
                                       FunctionsToRemove.end()),
                           FunctionsToRemove.end());
   for (CallGraphNode *CGN : FunctionsToRemove) {
     delete CG.removeFunctionFromModule(CGN);
     ++NumDeleted;
   }
   return true;
 }
+
+PreservedAnalyses InlinerPass::run(CallGraphSCC &C, CGSCCAnalysisManager &AM) {
+  FunctionAnalysisManager &FAM =
+      AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
+  const ModuleAnalysisManager &MAM =
+      AM.getResult<ModuleAnalysisManagerCGSCCProxy>(C).getManager();
+
+  // XXX: do this to make sure we get the real call graph used by the
+  // ModuleToPostOrderCGSCCPassAdaptor. Can we do something more "correct"
+  // here?
+  CallGraph &CG = C.getCallGraph();
+
+  auto *PSI = MAM.getCachedResult<ProfileSummaryAnalysis>(CG.getModule());
+  auto *TLI = MAM.getCachedResult<TargetLibraryAnalysis>(CG.getModule());
+  if (!PSI)
+    report_fatal_error("ProfileSummaryAnalysis not cached at a higher level!");
+  if (!TLI)
+    report_fatal_error("TargetLbraryAnalysis not computed at a higher level!");
+  auto AARGetter = [&](Function &F) -> AAResults & {
+    return FAM.getResult<AAManager>(F);
+  };
+  std::function<AssumptionCache &(Function &)> GetAssumptionCache = [&](
+      Function &F) -> AssumptionCache & {
+    return FAM.getResult<AssumptionAnalysis>(F);
+  };
+  auto GetInlineCost = [&](CallSite CS) -> InlineCost {
+    // XXX: Copied from SimpleInliner::getInlineCost
+    Function *Callee = CS.getCalledFunction();
+    TargetTransformInfo &TTI = FAM.getResult<TargetIRAnalysis>(*Callee);
+    return llvm::getInlineCost(CS, DefaultThreshold, TTI, GetAssumptionCache,
+                               PSI);
+  };
+  bool Changed = inlineCallsImpl(C, CG, GetAssumptionCache, PSI, *TLI,
+                                 InsertLifetime, GetInlineCost, AARGetter);
+  if (Changed)
+    return PreservedAnalyses::none();
+  return PreservedAnalyses::all();
+}

lib/Transforms/IPO/PruneEH.cpp

 //===- PruneEH.cpp - Pass which deletes unused exception handlers ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a simple interprocedural pass which walks the
 // call-graph, turning invoke instructions into calls, iff the callee cannot
 // throw an exception, and marking functions 'nounwind' if they cannot throw.
 // It implements this as a bottom-up traversal of the call-graph.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Transforms/IPO/PruneEH.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/CallGraphSCCPass.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/IR/CFG.h"
if (TokenInst) {
     std::vector<BasicBlock *> Succs(succ_begin(BB), succ_end(BB));
 
     for (unsigned i = 0, e = Succs.size(); i != e; ++i)
       Succs[i]->removePredecessor(BB);
 
     BB->eraseFromParent();
   }
 }
+
+PreservedAnalyses PruneEHPass::run(CallGraphSCC &C, CGSCCAnalysisManager &AM) {
+  // XXX: do this to make sure we get the real call graph used by the
+  // ModuleToPostOrderCGSCCPassAdaptor. Can we do something more "correct"
+  // here?
+  CallGraph &CG = C.getCallGraph();
+
+  bool Changed = runImpl(C, CG);
+  if (Changed)
+    return PreservedAnalyses::none();
+  return PreservedAnalyses::all();
+}

test/Other/new-pass-manager.ll

 ; CHECK-MODULE-PASS-NEXT: Finished llvm::Module pass manager run
 
 ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
 ; RUN:     -passes=no-op-cgscc %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-CGSCC-PASS
 ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
 ; RUN:     -passes='cgscc(no-op-cgscc)' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-CGSCC-PASS
-; CHECK-CGSCC-PASS: Starting llvm::Module pass manager run
+; CHECK-CGSCC-PASS:      Starting llvm::Module pass manager run.
 ; CHECK-CGSCC-PASS-NEXT: Running pass: ModuleToPostOrderCGSCCPassAdaptor
 ; CHECK-CGSCC-PASS-NEXT: Running analysis: InnerAnalysisManagerProxy<{{.*}}>
-; CHECK-CGSCC-PASS-NEXT: Running analysis: LazyCallGraphAnalysis
-; CHECK-CGSCC-PASS-NEXT: Running an SCC pass across the RefSCC: [(foo)]
-; CHECK-CGSCC-PASS-NEXT: Starting llvm::LazyCallGraph::SCC pass manager run
-; CHECK-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass
-; CHECK-CGSCC-PASS-NEXT: Finished llvm::LazyCallGraph::SCC pass manager run
-; CHECK-CGSCC-PASS-NEXT: Finished llvm::Module pass manager run
+; CHECK-CGSCC-PASS-NEXT: Running analysis: CallGraphAnalysis
+; CHECK-CGSCC-PASS-NEXT: Starting llvm::CallGraphSCC pass manager run.
+; CHECK-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass on
+; CHECK-CGSCC-PASS-NEXT: Finished llvm::CallGraphSCC pass manager run.
+; CHECK-CGSCC-PASS-NEXT: Starting llvm::CallGraphSCC pass manager run.
+; CHECK-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass on
+; CHECK-CGSCC-PASS-NEXT: Finished llvm::CallGraphSCC pass manager run.
+; CHECK-CGSCC-PASS-NEXT: Starting llvm::CallGraphSCC pass manager run.
+; CHECK-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass on
+; CHECK-CGSCC-PASS-NEXT: Finished llvm::CallGraphSCC pass manager run.
+; CHECK-CGSCC-PASS-NEXT: Starting llvm::CallGraphSCC pass manager run.
+; CHECK-CGSCC-PASS-NEXT: Running pass: NoOpCGSCCPass on
+; CHECK-CGSCC-PASS-NEXT: Finished llvm::CallGraphSCC pass manager run.
+; CHECK-CGSCC-PASS-NEXT: Finished llvm::Module pass manager run.
 
 ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
 ; RUN:     -passes=no-op-function %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS
 ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
 ; RUN:     -passes='function(no-op-function)' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-FUNCTION-PASS
 ; CHECK-FUNCTION-PASS: Starting llvm::Module pass manager run

 ; CHECK-NO-VERIFY: Finished llvm::Module pass manager run
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='require<no-op-module>,cgscc(require<no-op-cgscc>,function(require<no-op-function>))' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-ANALYSES
 ; CHECK-ANALYSES: Starting llvm::Module pass manager run
 ; CHECK-ANALYSES: Running pass: RequireAnalysisPass
 ; CHECK-ANALYSES: Running analysis: NoOpModuleAnalysis
-; CHECK-ANALYSES: Starting llvm::LazyCallGraph::SCC pass manager run
+; CHECK-ANALYSES: Starting llvm::CallGraphSCC pass manager run
 ; CHECK-ANALYSES: Running pass: RequireAnalysisPass
 ; CHECK-ANALYSES: Running analysis: NoOpCGSCCAnalysis
 ; CHECK-ANALYSES: Starting llvm::Function pass manager run
 ; CHECK-ANALYSES: Running pass: RequireAnalysisPass
 ; CHECK-ANALYSES: Running analysis: NoOpFunctionAnalysis
 
 ; Make sure no-op passes that preserve all analyses don't even try to do any
 ; analysis invalidation.

 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='cgscc(require<no-op-cgscc>,require<no-op-cgscc>,require<no-op-cgscc>)' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-DO-CACHE-CGSCC-ANALYSIS-RESULTS
 ; CHECK-DO-CACHE-CGSCC-ANALYSIS-RESULTS: Starting llvm::Module pass manager run
 ; CHECK-DO-CACHE-CGSCC-ANALYSIS-RESULTS: Running pass: RequireAnalysisPass
 ; CHECK-DO-CACHE-CGSCC-ANALYSIS-RESULTS: Running analysis: NoOpCGSCCAnalysis
 ; CHECK-DO-CACHE-CGSCC-ANALYSIS-RESULTS-NOT: Running analysis: NoOpCGSCCAnalysis
+; CHECK-DO-CACHE-CGSCC-ANALYSIS-RESULTS: Running pass: RequireAnalysisPass
+; CHECK-DO-CACHE-CGSCC-ANALYSIS-RESULTS: Running pass: RequireAnalysisPass
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='cgscc(require<no-op-cgscc>,invalidate<no-op-cgscc>,require<no-op-cgscc>)' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-DO-INVALIDATE-CGSCC-ANALYSIS-RESULTS
 ; CHECK-DO-INVALIDATE-CGSCC-ANALYSIS-RESULTS: Starting llvm::Module pass manager run
 ; CHECK-DO-INVALIDATE-CGSCC-ANALYSIS-RESULTS: Running pass: RequireAnalysisPass
 ; CHECK-DO-INVALIDATE-CGSCC-ANALYSIS-RESULTS: Running analysis: NoOpCGSCCAnalysis
 ; CHECK-DO-INVALIDATE-CGSCC-ANALYSIS-RESULTS: Invalidating analysis: NoOpCGSCCAnalysis

 ; RUN:     -passes='require<no-op-module>,module(require<no-op-module>,cgscc(require<no-op-cgscc>,function(require<no-op-function>,invalidate<all>,require<no-op-function>),require<no-op-cgscc>),require<no-op-module>),require<no-op-module>' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-INVALIDATE-ALL-CG
 ; CHECK-INVALIDATE-ALL-CG: Starting llvm::Module pass manager run
 ; CHECK-INVALIDATE-ALL-CG: Running pass: RequireAnalysisPass
 ; CHECK-INVALIDATE-ALL-CG: Running analysis: NoOpModuleAnalysis
 ; CHECK-INVALIDATE-ALL-CG: Starting llvm::Module pass manager run
 ; CHECK-INVALIDATE-ALL-CG: Running pass: RequireAnalysisPass
 ; CHECK-INVALIDATE-ALL-CG-NOT: Running analysis: NoOpModuleAnalysis
-; CHECK-INVALIDATE-ALL-CG: Starting llvm::LazyCallGraph::SCC pass manager run
+; CHECK-INVALIDATE-ALL-CG: Starting llvm::CallGraphSCC pass manager run
 ; CHECK-INVALIDATE-ALL-CG: Running pass: RequireAnalysisPass
 ; CHECK-INVALIDATE-ALL-CG: Running analysis: NoOpCGSCCAnalysis
 ; CHECK-INVALIDATE-ALL-CG: Starting llvm::Function pass manager run
 ; CHECK-INVALIDATE-ALL-CG: Running pass: RequireAnalysisPass
 ; CHECK-INVALIDATE-ALL-CG: Running analysis: NoOpFunctionAnalysis
 ; CHECK-INVALIDATE-ALL-CG: Running pass: InvalidateAllAnalysesPass
 ; CHECK-INVALIDATE-ALL-CG: Invalidating all non-preserved analyses
 ; CHECK-INVALIDATE-ALL-CG: Invalidating analysis: NoOpFunctionAnalysis
 ; CHECK-INVALIDATE-ALL-CG: Running pass: RequireAnalysisPass
 ; CHECK-INVALIDATE-ALL-CG: Running analysis: NoOpFunctionAnalysis
 ; CHECK-INVALIDATE-ALL-CG: Finished llvm::Function pass manager run
 ; CHECK-INVALIDATE-ALL-CG: Invalidating all non-preserved analyses
 ; CHECK-INVALIDATE-ALL-CG-NOT: Running analysis: NoOpFunctionAnalysis
 ; CHECK-INVALIDATE-ALL-CG: Invalidating all non-preserved analyses
 ; CHECK-INVALIDATE-ALL-CG: Invalidating analysis: NoOpCGSCCAnalysis
 ; CHECK-INVALIDATE-ALL-CG: Running pass: RequireAnalysisPass
 ; CHECK-INVALIDATE-ALL-CG: Running analysis: NoOpCGSCCAnalysis
-; CHECK-INVALIDATE-ALL-CG: Finished llvm::LazyCallGraph::SCC pass manager run
+; CHECK-INVALIDATE-ALL-CG: Finished llvm::CallGraphSCC pass manager run
 ; CHECK-INVALIDATE-ALL-CG: Invalidating all non-preserved analyses
 ; CHECK-INVALIDATE-ALL-CG-NOT: Invalidating analysis: NoOpCGSCCAnalysis
 ; CHECK-INVALIDATE-ALL-CG: Invalidating all non-preserved analyses
 ; CHECK-INVALIDATE-ALL-CG: Invalidating analysis: NoOpModuleAnalysis
 ; CHECK-INVALIDATE-ALL-CG: Running pass: RequireAnalysisPass
 ; CHECK-INVALIDATE-ALL-CG: Running analysis: NoOpModuleAnalysis
 ; CHECK-INVALIDATE-ALL-CG: Finished llvm::Module pass manager run
 ; CHECK-INVALIDATE-ALL-CG: Invalidating all non-preserved analyses

test/Other/pass-pipeline-parsing.ll

 ; RUN:     | FileCheck %s --check-prefix=CHECK-UNBALANCED10
 ; CHECK-UNBALANCED10: unable to parse pass pipeline description
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes=no-op-cgscc,no-op-cgscc %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-TWO-NOOP-CG
 ; CHECK-TWO-NOOP-CG: Starting llvm::Module pass manager run
 ; CHECK-TWO-NOOP-CG: Running pass: ModuleToPostOrderCGSCCPassAdaptor
-; CHECK-TWO-NOOP-CG: Starting llvm::LazyCallGraph::SCC pass manager run
+; CHECK-TWO-NOOP-CG: Starting llvm::CallGraphSCC pass manager run
 ; CHECK-TWO-NOOP-CG: Running pass: NoOpCGSCCPass
 ; CHECK-TWO-NOOP-CG: Running pass: NoOpCGSCCPass
-; CHECK-TWO-NOOP-CG: Finished llvm::LazyCallGraph::SCC pass manager run
+; CHECK-TWO-NOOP-CG: Finished llvm::CallGraphSCC pass manager run
 ; CHECK-TWO-NOOP-CG: Finished llvm::Module pass manager run
 
 ; RUN: opt -disable-output -debug-pass-manager \
 ; RUN:     -passes='module(function(no-op-function),cgscc(no-op-cgscc,function(no-op-function),no-op-cgscc),function(no-op-function))' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-NESTED-MP-CG-FP
 ; CHECK-NESTED-MP-CG-FP: Starting llvm::Module pass manager run
 ; CHECK-NESTED-MP-CG-FP: Starting llvm::Module pass manager run
 ; CHECK-NESTED-MP-CG-FP: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-NESTED-MP-CG-FP: Starting llvm::Function pass manager run
 ; CHECK-NESTED-MP-CG-FP: Running pass: NoOpFunctionPass
 ; CHECK-NESTED-MP-CG-FP: Finished llvm::Function pass manager run
 ; CHECK-NESTED-MP-CG-FP: Running pass: ModuleToPostOrderCGSCCPassAdaptor
-; CHECK-NESTED-MP-CG-FP: Starting llvm::LazyCallGraph::SCC pass manager run
+; CHECK-NESTED-MP-CG-FP: Starting llvm::CallGraphSCC pass manager run
 ; CHECK-NESTED-MP-CG-FP: Running pass: NoOpCGSCCPass
 ; CHECK-NESTED-MP-CG-FP: Running pass: CGSCCToFunctionPassAdaptor
 ; CHECK-NESTED-MP-CG-FP: Starting llvm::Function pass manager run
 ; CHECK-NESTED-MP-CG-FP: Running pass: NoOpFunctionPass
 ; CHECK-NESTED-MP-CG-FP: Finished llvm::Function pass manager run
 ; CHECK-NESTED-MP-CG-FP: Running pass: NoOpCGSCCPass
-; CHECK-NESTED-MP-CG-FP: Finished llvm::LazyCallGraph::SCC pass manager run
+; CHECK-NESTED-MP-CG-FP: Finished llvm::CallGraphSCC pass manager run
 ; CHECK-NESTED-MP-CG-FP: Running pass: ModuleToFunctionPassAdaptor
 ; CHECK-NESTED-MP-CG-FP: Starting llvm::Function pass manager run
 ; CHECK-NESTED-MP-CG-FP: Running pass: NoOpFunctionPass
 ; CHECK-NESTED-MP-CG-FP: Finished llvm::Function pass manager run
 ; CHECK-NESTED-MP-CG-FP: Finished llvm::Module pass manager run
 ; CHECK-NESTED-MP-CG-FP: Finished llvm::Module pass manager run
 
 ; RUN: opt -disable-output -debug-pass-manager \

test/Transforms/ArgumentPromotion/byval.ll

 ; RUN: opt < %s -argpromotion -S | FileCheck %s
+; RUN: opt < %s -passes=argpromotion -S | FileCheck %s
 
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 %struct.ss = type { i32, i64 }
 
 define internal void @f(%struct.ss* byval  %b) nounwind  {
 ; CHECK-LABEL: define internal void @f(i32 %b.0, i64 %b.1)
 entry:

test/Transforms/Inline/alloca-in-scc.ll

 ; RUN: opt < %s -inline | llvm-dis
+; RUN: opt < %s -passes='module(require<profile-summary>,require<targetlibinfo>,cgscc(inline))' | llvm-dis
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
 target triple = "i386-apple-darwin10.0"
 
 define i32 @main(i32 %argc, i8** %argv) nounwind ssp {
 entry:
   call fastcc void @c() nounwind
   unreachable

test/Transforms/PruneEH/2008-06-02-Weak.ll

 ; RUN: opt < %s -prune-eh -S | not grep nounwind
+; RUN: opt < %s -passes=prune-eh -S | not grep nounwind
 
 define weak void @f() {
 entry:
         ret void
 }
 
 define void @g() {
 entry:
   call void @f()
   ret void
 }

test/Transforms/PruneEH/operand-bundles.ll

 ; RUN: opt < %s -prune-eh -S | FileCheck %s
+; RUN: opt < %s -passes=prune-eh -S | FileCheck %s
 
 declare void @nounwind() nounwind
 
 define internal void @foo() {
   call void @nounwind()
   ret void
 }
 

test/Transforms/PruneEH/pr23971.ll

 ; RUN: opt -S -prune-eh < %s | FileCheck %s
+; RUN: opt -S -passes=prune-eh < %s | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @f() #0 {
 entry:
   call void asm sideeffect "ret\0A\09", "~{dirflag},~{fpsr},~{flags}"()
   unreachable

test/Transforms/PruneEH/pr26263.ll

 ; RUN: opt -prune-eh -S < %s | FileCheck %s
+; RUN: opt -passes=prune-eh -S < %s | FileCheck %s
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i386-pc-windows-msvc"
 
 declare void @neverthrows() nounwind
 
 define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
   invoke void @neverthrows()
           to label %try.cont unwind label %cleanuppad

test/Transforms/PruneEH/recursivetest.ll

 ; RUN: opt < %s -prune-eh -S | not grep invoke
+; RUN: opt < %s -passes=prune-eh -S | not grep invoke
 
 define internal i32 @foo() personality i32 (...)* @__gxx_personality_v0 {
   invoke i32 @foo( )
       to label %Normal unwind label %Except   ; <i32>:1 [#uses=0]
 Normal:   ; preds = %0
   ret i32 12
 Except:   ; preds = %0
         landingpad { i8*, i32 }

test/Transforms/PruneEH/seh-nounwind.ll

 ; RUN: opt -S -prune-eh < %s | FileCheck %s
+; RUN: opt -S -passes=prune-eh < %s | FileCheck %s
 
 ; Don't remove invokes of nounwind functions if the personality handles async
 ; exceptions. The @div function in this test can fault, even though it can't
 ; throw a synchronous exception.
 
 define i32 @div(i32 %n, i32 %d) nounwind {
 entry:
   %div = sdiv i32 %n, %d

test/Transforms/PruneEH/simplenoreturntest.ll

 ; RUN: opt < %s -prune-eh -S | not grep "ret i32"
+; RUN: opt < %s -passes=prune-eh -S | not grep "ret i32"
 
 declare void @noreturn() noreturn
 
 define i32 @caller() {
   call void @noreturn( )
   ret i32 17
 }
 
 define i32 @caller2() {
   %T = call i32 @caller( )    ; <i32> [#uses=1]
   ret i32 %T
 }

test/Transforms/PruneEH/simpletest.ll

 ; RUN: opt < %s -prune-eh -S | not grep invoke
+; RUN: opt < %s -passes=prune-eh -S | not grep invoke
 
 declare void @nounwind() nounwind
 
 define internal void @foo() {
   call void @nounwind()
   ret void
 }
 

unittests/Analysis/CGSCCPassManagerTest.cpp

struct Result {
     int FunctionCount;
   };
 
   static void *ID() { return (void *)&PassID; }
   static StringRef name() { return "TestSCCAnalysis"; }
 
   TestSCCAnalysis(int &Runs) : Runs(Runs) {}
 
-  Result run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) {
+  Result run(CallGraphSCC &C, CGSCCAnalysisManager &AM) {
     ++Runs;
     return Result(C.size());
   }
 
 private:
   static char PassID;
 
   int &Runs;
struct TestSCCPass {
   TestSCCPass(int &RunCount, int &AnalyzedInstrCount,
               int &AnalyzedSCCFunctionCount, int &AnalyzedModuleFunctionCount,
               bool OnlyUseCachedResults = false)
       : RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount),
         AnalyzedSCCFunctionCount(AnalyzedSCCFunctionCount),
         AnalyzedModuleFunctionCount(AnalyzedModuleFunctionCount),
         OnlyUseCachedResults(OnlyUseCachedResults) {}
 
-  PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) {
+  PreservedAnalyses run(CallGraphSCC &C, CGSCCAnalysisManager &AM) {
     ++RunCount;
 
     const ModuleAnalysisManager &MAM =
         AM.getResult<ModuleAnalysisManagerCGSCCProxy>(C).getManager();
     FunctionAnalysisManager &FAM =
         AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager();
     if (TestModuleAnalysis::Result *TMA =
             MAM.getCachedResult<TestModuleAnalysis>(
-                *C.begin()->getFunction().getParent()))
+                C.getCallGraph().getModule()))
       AnalyzedModuleFunctionCount += TMA->FunctionCount;
 
     if (OnlyUseCachedResults) {
       // Hack to force the use of the cached interface.
       if (TestSCCAnalysis::Result *AR = AM.getCachedResult<TestSCCAnalysis>(C))
         AnalyzedSCCFunctionCount += AR->FunctionCount;
-      for (LazyCallGraph::Node &N : C)
+      for (CallGraphNode *N : C) {
+        // XXX: The old PM can call on SCC's with null nodes.
+        if (!N->getFunction())
+          continue;
         if (TestFunctionAnalysis::Result *FAR =
-                FAM.getCachedResult<TestFunctionAnalysis>(N.getFunction()))
+                FAM.getCachedResult<TestFunctionAnalysis>(*N->getFunction()))
           AnalyzedInstrCount += FAR->InstructionCount;
+      }
     } else {
       // Typical path just runs the analysis as needed.
       TestSCCAnalysis::Result &AR = AM.getResult<TestSCCAnalysis>(C);
       AnalyzedSCCFunctionCount += AR.FunctionCount;
-      for (LazyCallGraph::Node &N : C) {
+      for (CallGraphNode *N : C) {
+        // XXX: The old PM can call on SCC's with null nodes.
+        if (!N->getFunction())
+          continue;
         TestFunctionAnalysis::Result &FAR =
-            FAM.getResult<TestFunctionAnalysis>(N.getFunction());
+            FAM.getResult<TestFunctionAnalysis>(*N->getFunction());
         AnalyzedInstrCount += FAR.InstructionCount;
 
         // Just ensure we get the immutable results.
-        (void)FAM.getResult<TestImmutableFunctionAnalysis>(N.getFunction());
+        (void)FAM.getResult<TestImmutableFunctionAnalysis>(*N->getFunction());
       }
     }
 
     return PreservedAnalyses::all();
   }
 
   static StringRef name() { return "TestSCCPass"; }
 
TEST(CGSCCPassManagerTest, Basic) {
   });
 
   CGSCCAnalysisManager CGAM(/*DebugLogging*/ true);
   int SCCAnalysisRuns = 0;
   CGAM.registerPass([&] { return TestSCCAnalysis(SCCAnalysisRuns); });
 
   ModuleAnalysisManager MAM(/*DebugLogging*/ true);
   int ModuleAnalysisRuns = 0;
-  MAM.registerPass([&] { return LazyCallGraphAnalysis(); });
+  MAM.registerPass([&] { return CallGraphAnalysis(); });
   MAM.registerPass([&] { return TestModuleAnalysis(ModuleAnalysisRuns); });
 
   MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
   MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); });
   CGAM.registerPass([&] { return FunctionAnalysisManagerCGSCCProxy(FAM); });
   CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); });
   FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); });
   FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
TEST(CGSCCPassManagerTest, Basic) {
   FPM1.addPass(TestFunctionPass(FunctionPassRunCount1));
   CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1)));
   MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1)));
 
   MPM.run(*M, MAM);
 
   EXPECT_EQ(1, ModulePassRunCount1);
 
+  // XXX: Some of these are 1 larger with CallGraphSCC than with
+  // LazyCallGraph because CallGraph has an explicit "external caller" SCC.
+
   EXPECT_EQ(1, ModuleAnalysisRuns);
-  EXPECT_EQ(4, SCCAnalysisRuns);
+  EXPECT_EQ(5, SCCAnalysisRuns);
   EXPECT_EQ(6, FunctionAnalysisRuns);
   EXPECT_EQ(6, ImmutableFunctionAnalysisRuns);
 
-  EXPECT_EQ(4, SCCPassRunCount1);
+  EXPECT_EQ(5, SCCPassRunCount1);
   EXPECT_EQ(14, AnalyzedInstrCount1);
-  EXPECT_EQ(6, AnalyzedSCCFunctionCount1);
-  EXPECT_EQ(4 * 6, AnalyzedModuleFunctionCount1);
+  EXPECT_EQ(7, AnalyzedSCCFunctionCount1);
+  EXPECT_EQ(5 * 6, AnalyzedModuleFunctionCount1);
 }
 
 }