[PassManager] Run PassInstrumentation after analysis invalidation

[aeubanks]

Summary

This allows instrumentation to inspect cached analyses to verify them.

The CGSCC PassInstrumentation previously ran runAfterPass() on the original SCC, but really it should be running on UpdatedC when relevant since that's the relevant SCC after the pass.

[aeubanks]

update

[aeubanks]

update

[aeubanks]

llvm/test/Other/scc-deleted-printer.ll

7

the instrumentation stores the name from before the pass ran

[nikic]

LGTM

llvm/include/llvm/IR/PassManager.h

for (auto &Pass : Passes) {
       // Check the PassInstrumentation's BeforePass callbacks before running the
       // pass, skip its execution completely if asked to (callback returns
       // false).
       if (!PI.runBeforePass<IRUnitT>(*Pass, IR))
         continue;
 
       PreservedAnalyses PassPA = Pass->run(IR, AM, ExtraArgs...);
 
-      // Call onto PassInstrumentation's AfterPass callbacks immediately after
-      // running the pass.
-      PI.runAfterPass<IRUnitT>(*Pass, IR, PassPA);
-
       // Update the analysis manager as each pass runs and potentially
       // invalidates analyses.
       AM.invalidate(IR, PassPA);
 
+      // Call onto PassInstrumentation's AfterPass callbacks immediately after
+      // running the pass.
+      PI.runAfterPass<IRUnitT>(*Pass, IR, PassPA);
+
       // Finally, intersect the preserved analyses to compute the aggregate
       // preserved set for this pass manager.
       PA.intersect(std::move(PassPA));
     }
 
     // Invalidation was handled after each pass in the above loop for the
     // current unit of IR. Therefore, the remaining analysis results in the
     // AnalysisManager are preserved. We mark this with a set so that we don't

llvm/lib/Analysis/CGSCCPassManager.cpp

PassManager<LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &,
   for (auto &Pass : Passes) {
     // Check the PassInstrumentation's BeforePass callbacks before running the
     // pass, skip its execution completely if asked to (callback returns false).
     if (!PI.runBeforePass(*Pass, *C))
       continue;
 
     PreservedAnalyses PassPA = Pass->run(*C, AM, G, UR);
 
-    if (UR.InvalidatedSCCs.count(C))
-      PI.runAfterPassInvalidated<LazyCallGraph::SCC>(*Pass, PassPA);
-    else
-      PI.runAfterPass<LazyCallGraph::SCC>(*Pass, *C, PassPA);
-
     // Update the SCC if necessary.
     C = UR.UpdatedC ? UR.UpdatedC : C;
     if (UR.UpdatedC) {
       // If C is updated, also create a proxy and update FAM inside the result.
       auto *ResultFAMCP =
           &AM.getResult<FunctionAnalysisManagerCGSCCProxy>(*C, G);
       ResultFAMCP->updateFAM(FAM);
     }
 
     // Intersect the final preserved analyses to compute the aggregate
     // preserved set for this pass manager.
     PA.intersect(PassPA);
 
     // If the CGSCC pass wasn't able to provide a valid updated SCC, the
     // current SCC may simply need to be skipped if invalid.
     if (UR.InvalidatedSCCs.count(C)) {
+      PI.runAfterPassInvalidated<LazyCallGraph::SCC>(*Pass, PassPA);
       LLVM_DEBUG(dbgs() << "Skipping invalidated root or island SCC!\n");
       break;
     }
 
     // Check that we didn't miss any update scenario.
     assert(C->begin() != C->end() && "Cannot have an empty SCC!");
 
     // Update the analysis manager as each pass runs and potentially
     // invalidates analyses.
     AM.invalidate(*C, PassPA);
+
+    PI.runAfterPass<LazyCallGraph::SCC>(*Pass, *C, PassPA);
   }
 
   // Before we mark all of *this* SCC's analyses as preserved below, intersect
   // this with the cross-SCC preserved analysis set. This is used to allow
   // CGSCC passes to mutate ancestor SCCs and still trigger proper invalidation
   // for them.
   UR.CrossSCCPA.intersect(PA);
 
do {
           // Check the PassInstrumentation's BeforePass callbacks before
           // running the pass, skip its execution completely if asked to
           // (callback returns false).
           if (!PI.runBeforePass<LazyCallGraph::SCC>(*Pass, *C))
             continue;
 
           PreservedAnalyses PassPA = Pass->run(*C, CGAM, CG, UR);
 
-          if (UR.InvalidatedSCCs.count(C))
-            PI.runAfterPassInvalidated<LazyCallGraph::SCC>(*Pass, PassPA);
-          else
-            PI.runAfterPass<LazyCallGraph::SCC>(*Pass, *C, PassPA);
-
           // Update the SCC and RefSCC if necessary.
           C = UR.UpdatedC ? UR.UpdatedC : C;
 
           if (UR.UpdatedC) {
             // If we're updating the SCC, also update the FAM inside the proxy's
             // result.
             CGAM.getResult<FunctionAnalysisManagerCGSCCProxy>(*C, CG).updateFAM(
                 FAM);
           }
 
           // Intersect with the cross-SCC preserved set to capture any
           // cross-SCC invalidation.
           UR.CrossSCCPA.intersect(PassPA);
           // Intersect the preserved set so that invalidation of module
           // analyses will eventually occur when the module pass completes.
           PA.intersect(PassPA);
 
           // If the CGSCC pass wasn't able to provide a valid updated SCC,
           // the current SCC may simply need to be skipped if invalid.
           if (UR.InvalidatedSCCs.count(C)) {
+            PI.runAfterPassInvalidated<LazyCallGraph::SCC>(*Pass, PassPA);
             LLVM_DEBUG(dbgs() << "Skipping invalidated root or island SCC!\n");
             break;
           }
 
           // Check that we didn't miss any update scenario.
           assert(C->begin() != C->end() && "Cannot have an empty SCC!");
 
           // We handle invalidating the CGSCC analysis manager's information
           // for the (potentially updated) SCC here. Note that any other SCCs
           // whose structure has changed should have been invalidated by
           // whatever was updating the call graph. This SCC gets invalidated
           // late as it contains the nodes that were actively being
           // processed.
           CGAM.invalidate(*C, PassPA);
 
+          PI.runAfterPass<LazyCallGraph::SCC>(*Pass, *C, PassPA);
+
           // The pass may have restructured the call graph and refined the
           // current SCC and/or RefSCC. We need to update our current SCC and
           // RefSCC pointers to follow these. Also, when the current SCC is
           // refined, re-run the SCC pass over the newly refined SCC in order
           // to observe the most precise SCC model available. This inherently
           // cannot cycle excessively as it only happens when we split SCCs
           // apart, at most converging on a DAG of single nodes.
           // FIXME: If we ever start having RefSCC passes, we'll want to
PreservedAnalyses DevirtSCCRepeatedPass::run(LazyCallGraph::SCC &InitialC,
   auto CallCounts = ScanSCC(*C, UR.IndirectVHs);
 
   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);
-
     PA.intersect(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)
-      break;
-
     // If the CGSCC pass wasn't able to provide a valid updated SCC, the
     // current SCC may simply need to be skipped if invalid.
     if (UR.InvalidatedSCCs.count(C)) {
+      PI.runAfterPassInvalidated<LazyCallGraph::SCC>(*Pass, PassPA);
       LLVM_DEBUG(dbgs() << "Skipping invalidated root or island SCC!\n");
       break;
     }
 
+    // Update the analysis manager with each run and intersect the total set
+    // of preserved analyses so we're ready to iterate.
+    AM.invalidate(*C, PassPA);
+
+    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)
+      break;
+
     assert(C->begin() != C->end() && "Cannot have an empty SCC!");
 
     // Check whether any of the handles were devirtualized.
     bool Devirt = llvm::any_of(UR.IndirectVHs, [](auto &P) -> bool {
       if (P.second) {
         if (CallBase *CB = dyn_cast<CallBase>(P.second)) {
           if (CB->getCalledFunction()) {
             LLVM_DEBUG(dbgs() << "Found devirtualized call: " << *CB << "\n");
for (int Iteration = 0;; ++Iteration) {
     }
 
     LLVM_DEBUG(
         dbgs() << "Repeating an SCC pass after finding a devirtualization in: "
                << *C << "\n");
 
     // Move over the new call counts in preparation for iterating.
     CallCounts = std::move(NewCallCounts);
-
-    // Update the analysis manager with each run and intersect the total set
-    // of preserved analyses so we're ready to iterate.
-    AM.invalidate(*C, PassPA);
   }
 
   // Note that we don't add any preserved entries here unlike a more normal
   // "pass manager" because we only handle invalidation *between* iterations,
   // not after the last iteration.
   return PA;
 }
 
for (LazyCallGraph::Node *N : Nodes) {
     if (NoRerun && FAM.getCachedResult<ShouldNotRunFunctionPassesAnalysis>(F))
       continue;
 
     PassInstrumentation PI = FAM.getResult<PassInstrumentationAnalysis>(F);
     if (!PI.runBeforePass<Function>(*Pass, F))
       continue;
 
     PreservedAnalyses PassPA = Pass->run(F, FAM);
-    PI.runAfterPass<Function>(*Pass, F, PassPA);
 
     // 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.
     FAM.invalidate(F, EagerlyInvalidate ? PreservedAnalyses::none() : PassPA);
 
+    PI.runAfterPass<Function>(*Pass, F, 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 the call graph hasn't been preserved, update it based on this
     // function pass. This may also update the current SCC to point to
     // a smaller, more refined SCC.
     auto PAC = PA.getChecker<LazyCallGraphAnalysis>();

llvm/lib/CodeGen/MachinePassManager.cpp

for (Function &F : M) {
       for (unsigned I = Begin, E = Idx; I != E; ++I) {
         auto *P = Passes[I].get();
 
         if (!PI.runBeforePass<MachineFunction>(*P, MF))
           continue;
 
         // TODO: EmitSizeRemarks
         PreservedAnalyses PassPA = P->run(MF, MFAM);
-        PI.runAfterPass(*P, MF, PassPA);
         MFAM.invalidate(MF, PassPA);
+        PI.runAfterPass(*P, MF, PassPA);
       }
     }
   } while (true);
 
   for (auto &F : FinalizationFuncs) {
     if (auto Err = F(M, MFAM))
       return Err;
   }
 
   return Error::success();
 }
 
 } // namespace llvm

llvm/lib/IR/PassManager.cpp

for (Function &F : M) {
 
     // Check the PassInstrumentation's BeforePass callbacks before running the
     // pass, skip its execution completely if asked to (callback returns
     // false).
     if (!PI.runBeforePass<Function>(*Pass, F))
       continue;
 
     PreservedAnalyses PassPA = Pass->run(F, FAM);
-    PI.runAfterPass(*Pass, F, PassPA);
 
     // 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.
     FAM.invalidate(F, EagerlyInvalidate ? PreservedAnalyses::none() : PassPA);
 
+    PI.runAfterPass(*Pass, F, 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));
   }
 
   // The FunctionAnalysisManagerModuleProxy is preserved because (we assume)
   // the function passes we ran didn't add or remove any functions.
   //

llvm/lib/Passes/StandardInstrumentations.cpp

assert(PassStack.pop_back_val() == P &&
            "Before and After callbacks must correspond");
 #endif
     (void)this;
 
     const auto **F = any_cast<const Function *>(&IR);
     if (!F)
       return;
 
-    if (!PassPA.allAnalysesInSetPreserved<CFGAnalyses>() &&
-        !PassPA.allAnalysesInSetPreserved<AllAnalysesOn<Function>>())
-      return;
-
     auto CheckCFG = [](StringRef Pass, StringRef FuncName,
                        const CFG &GraphBefore, const CFG &GraphAfter) {
       if (GraphAfter == GraphBefore)
         return;
 
       dbgs() << "Error: " << Pass
              << " does not invalidate CFG analyses but CFG changes detected in "
                 "function @"

llvm/test/Other/scc-deleted-printer.ll

 ; RUN: opt < %s 2>&1 -disable-output \
 ; RUN:     -passes=inline -print-before-all -print-after-all | FileCheck %s
 ; RUN: opt < %s 2>&1 -disable-output \
 ; RUN:     -passes=inline -print-before-all -print-after-all -print-module-scope | FileCheck %s
 
 ; CHECK: IR Dump Before InlinerPass on (tester, foo)
-; CHECK: IR Dump After InlinerPass on (tester, foo) (invalidated)
+; CHECK: IR Dump After InlinerPass on (tester, foo)
 ; CHECK: IR Dump Before InlinerPass on (tester)
 ; CHECK: IR Dump After InlinerPass on (tester)
 
 
 define void @tester() noinline {
   call void @foo()
   ret void
 }
 
 define internal void @foo() alwaysinline {
   call void @tester()
   ret void
 }