PreservedAnalyses PassManager<LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, CGSCCUpdateResult &>::run(LazyCallGraph::SCC &InitialC, CGSCCAnalysisManager &AM, LazyCallGraph &G, CGSCCUpdateResult &UR) { PreservedAnalyses PA = PreservedAnalyses::all(); if (DebugLogging) dbgs() << "Starting CGSCC pass manager run.\n"; // The SCC may be refined while we are running passes over it, so set up // a pointer that we can update. LazyCallGraph::SCC *C = &InitialC; for (auto &Pass : Passes) { if (DebugLogging) dbgs() << "Running pass: "******" on " << *C << "\n"; PreservedAnalyses PassPA = Pass->run(*C, AM, G, UR); // Update the SCC if necessary. C = UR.UpdatedC ? UR.UpdatedC : C; // Check that we didn't miss any update scenario. assert(!UR.InvalidatedSCCs.count(C) && "Processing an invalid SCC!"); 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); // Finally, we intersect the final preserved analyses to compute the // aggregate preserved set for this pass manager. PA.intersect(std::move(PassPA)); // FIXME: Historically, the pass managers all called the LLVM context's // yield function here. We don't have a generic way to acquire the // context and it isn't yet clear what the right pattern is for yielding // in the new pass manager so it is currently omitted. // ...getContext().yield(); } // Invaliadtion was handled after each pass in the above loop for the current // SCC. Therefore, the remaining analysis results in the AnalysisManager are // preserved. We mark this with a set so that we don't need to inspect each // one individually. PA.preserve<AllAnalysesOn<LazyCallGraph::SCC>>(); if (DebugLogging) dbgs() << "Finished CGSCC pass manager run.\n"; return PA; }
PreservedAnalyses PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater &>::run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR, LPMUpdater &U) { PreservedAnalyses PA = PreservedAnalyses::all(); if (DebugLogging) dbgs() << "Starting Loop pass manager run.\n"; for (auto &Pass : Passes) { if (DebugLogging) dbgs() << "Running pass: "******" on " << L; PreservedAnalyses PassPA = Pass->run(L, AM, AR, U); // If the loop was deleted, abort the run and return to the outer walk. if (U.skipCurrentLoop()) { PA.intersect(std::move(PassPA)); break; } // Update the analysis manager as each pass runs and potentially // invalidates analyses. AM.invalidate(L, PassPA); // Finally, we intersect the final preserved analyses to compute the // aggregate preserved set for this pass manager. PA.intersect(std::move(PassPA)); // FIXME: Historically, the pass managers all called the LLVM context's // yield function here. We don't have a generic way to acquire the // context and it isn't yet clear what the right pattern is for yielding // in the new pass manager so it is currently omitted. // ...getContext().yield(); } // Invalidation for the current loop should be handled above, and other loop // analysis results shouldn't be impacted by runs over this loop. Therefore, // the remaining analysis results in the AnalysisManager are preserved. We // mark this with a set so that we don't need to inspect each one // individually. // FIXME: This isn't correct! This loop and all nested loops' analyses should // be preserved, but unrolling should invalidate the parent loop's analyses. PA.preserveSet<AllAnalysesOn<Loop>>(); if (DebugLogging) dbgs() << "Finished Loop pass manager run.\n"; return PA; }
bool FunctionAnalysisManagerModuleProxy::Result::invalidate( Module &M, const PreservedAnalyses &PA) { // If this proxy isn't marked as preserved, then we can't even invalidate // individual function analyses, there may be an invalid set of Function // objects in the cache making it impossible to incrementally preserve them. // Just clear the entire manager. if (!PA.preserved(ID())) FAM->clear(); // Return false to indicate that this result is still a valid proxy. return false; }
PreservedAnalyses FunctionPassManager::run(Function *F, FunctionAnalysisManager *AM) { PreservedAnalyses PA = PreservedAnalyses::all(); if (DebugPM) dbgs() << "Starting function pass manager run.\n"; for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) { if (DebugPM) dbgs() << "Running function pass: "******"\n"; PreservedAnalyses PassPA = Passes[Idx]->run(F, AM); if (AM) AM->invalidate(F, PassPA); PA.intersect(llvm_move(PassPA)); } if (DebugPM) dbgs() << "Finished function pass manager run.\n"; return PA; }
PreservedAnalyses ModulePassManager::run(Module *M, ModuleAnalysisManager *AM) { PreservedAnalyses PA = PreservedAnalyses::all(); if (DebugPM) dbgs() << "Starting module pass manager run.\n"; for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) { if (DebugPM) dbgs() << "Running module pass: "******"\n"; PreservedAnalyses PassPA = Passes[Idx]->run(M, AM); if (AM) AM->invalidate(M, PassPA); PA.intersect(std::move(PassPA)); M->getContext().yield(); } if (DebugPM) dbgs() << "Finished module pass manager run.\n"; return PA; }
bool LoopAnalysisManagerFunctionProxy::Result::invalidate( Function &F, const PreservedAnalyses &PA, FunctionAnalysisManager::Invalidator &Inv) { // If this proxy isn't marked as preserved, the set of Function objects in // the module may have changed. We therefore can't call // InnerAM->invalidate(), because any pointers to Functions it has may be // stale. if (!PA.preserved(LoopAnalysisManagerFunctionProxy::ID())) InnerAM->clear(); // FIXME: Proper suppor for invalidation isn't yet implemented for the LPM. // Return false to indicate that this result is still a valid proxy. return false; }
PreservedAnalyses PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater &>::run(Loop &L, LoopAnalysisManager &AM, LoopStandardAnalysisResults &AR, LPMUpdater &U) { PreservedAnalyses PA = PreservedAnalyses::all(); if (DebugLogging) dbgs() << "Starting Loop pass manager run.\n"; // Request PassInstrumentation from analysis manager, will use it to run // instrumenting callbacks for the passes later. PassInstrumentation PI = AM.getResult<PassInstrumentationAnalysis>(L, AR); for (auto &Pass : Passes) { if (DebugLogging) dbgs() << "Running pass: "******" on " << L; // Check the PassInstrumentation's BeforePass callbacks before running the // pass, skip its execution completely if asked to (callback returns false). if (!PI.runBeforePass<Loop>(*Pass, L)) continue; PreservedAnalyses PassPA = Pass->run(L, AM, AR, U); // do not pass deleted Loop into the instrumentation if (U.skipCurrentLoop()) PI.runAfterPassInvalidated<Loop>(*Pass); else PI.runAfterPass<Loop>(*Pass, L); // If the loop was deleted, abort the run and return to the outer walk. if (U.skipCurrentLoop()) { PA.intersect(std::move(PassPA)); break; } #ifndef NDEBUG // Verify the loop structure and LCSSA form before visiting the loop. L.verifyLoop(); assert(L.isRecursivelyLCSSAForm(AR.DT, AR.LI) && "Loops must remain in LCSSA form!"); #endif // Update the analysis manager as each pass runs and potentially // invalidates analyses. AM.invalidate(L, PassPA); // Finally, we intersect the final preserved analyses to compute the // aggregate preserved set for this pass manager. PA.intersect(std::move(PassPA)); // FIXME: Historically, the pass managers all called the LLVM context's // yield function here. We don't have a generic way to acquire the // context and it isn't yet clear what the right pattern is for yielding // in the new pass manager so it is currently omitted. // ...getContext().yield(); } // Invalidation for the current loop should be handled above, and other loop // analysis results shouldn't be impacted by runs over this loop. Therefore, // the remaining analysis results in the AnalysisManager are preserved. We // mark this with a set so that we don't need to inspect each one // individually. // FIXME: This isn't correct! This loop and all nested loops' analyses should // be preserved, but unrolling should invalidate the parent loop's analyses. PA.preserveSet<AllAnalysesOn<Loop>>(); if (DebugLogging) dbgs() << "Finished Loop pass manager run.\n"; return PA; }
PreservedAnalyses PassManager<LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, CGSCCUpdateResult &>::run(LazyCallGraph::SCC &InitialC, CGSCCAnalysisManager &AM, LazyCallGraph &G, CGSCCUpdateResult &UR) { // Request PassInstrumentation from analysis manager, will use it to run // instrumenting callbacks for the passes later. PassInstrumentation PI = AM.getResult<PassInstrumentationAnalysis>(InitialC, G); PreservedAnalyses PA = PreservedAnalyses::all(); if (DebugLogging) dbgs() << "Starting CGSCC pass manager run.\n"; // The SCC may be refined while we are running passes over it, so set up // a pointer that we can update. LazyCallGraph::SCC *C = &InitialC; for (auto &Pass : Passes) { if (DebugLogging) dbgs() << "Running pass: "******" on " << *C << "\n"; // 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); else PI.runAfterPass<LazyCallGraph::SCC>(*Pass, *C); // Update the SCC if necessary. C = UR.UpdatedC ? UR.UpdatedC : C; // 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)) { 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); // Finally, we intersect the final preserved analyses to compute the // aggregate preserved set for this pass manager. PA.intersect(std::move(PassPA)); // FIXME: Historically, the pass managers all called the LLVM context's // yield function here. We don't have a generic way to acquire the // context and it isn't yet clear what the right pattern is for yielding // in the new pass manager so it is currently omitted. // ...getContext().yield(); } // Invalidation was handled after each pass in the above loop for the current // SCC. Therefore, the remaining analysis results in the AnalysisManager are // preserved. We mark this with a set so that we don't need to inspect each // one individually. PA.preserveSet<AllAnalysesOn<LazyCallGraph::SCC>>(); if (DebugLogging) dbgs() << "Finished CGSCC pass manager run.\n"; return PA; }
bool FunctionAnalysisManagerCGSCCProxy::Result::invalidate( LazyCallGraph::SCC &C, const PreservedAnalyses &PA, CGSCCAnalysisManager::Invalidator &Inv) { // If literally everything is preserved, we're done. if (PA.areAllPreserved()) return false; // This is still a valid proxy. // If this proxy isn't marked as preserved, then even if the result remains // valid, the key itself may no longer be valid, so we clear everything. // // Note that in order to preserve this proxy, a module pass must ensure that // the FAM has been completely updated to handle the deletion of functions. // Specifically, any FAM-cached results for those functions need to have been // forcibly cleared. When preserved, this proxy will only invalidate results // cached on functions *still in the module* at the end of the module pass. auto PAC = PA.getChecker<FunctionAnalysisManagerCGSCCProxy>(); if (!PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<LazyCallGraph::SCC>>()) { for (LazyCallGraph::Node &N : C) FAM->clear(N.getFunction(), N.getFunction().getName()); return true; } // Directly check if the relevant set is preserved. bool AreFunctionAnalysesPreserved = PA.allAnalysesInSetPreserved<AllAnalysesOn<Function>>(); // Now walk all the functions to see if any inner analysis invalidation is // necessary. for (LazyCallGraph::Node &N : C) { Function &F = N.getFunction(); Optional<PreservedAnalyses> FunctionPA; // Check to see whether the preserved set needs to be pruned based on // SCC-level analysis invalidation that triggers deferred invalidation // registered with the outer analysis manager proxy for this function. if (auto *OuterProxy = FAM->getCachedResult<CGSCCAnalysisManagerFunctionProxy>(F)) for (const auto &OuterInvalidationPair : OuterProxy->getOuterInvalidations()) { AnalysisKey *OuterAnalysisID = OuterInvalidationPair.first; const auto &InnerAnalysisIDs = OuterInvalidationPair.second; if (Inv.invalidate(OuterAnalysisID, C, PA)) { if (!FunctionPA) FunctionPA = PA; for (AnalysisKey *InnerAnalysisID : InnerAnalysisIDs) FunctionPA->abandon(InnerAnalysisID); } } // Check if we needed a custom PA set, and if so we'll need to run the // inner invalidation. if (FunctionPA) { FAM->invalidate(F, *FunctionPA); continue; } // Otherwise we only need to do invalidation if the original PA set didn't // preserve all function analyses. if (!AreFunctionAnalysesPreserved) FAM->invalidate(F, PA); } // Return false to indicate that this result is still a valid proxy. return false; }
bool CGSCCAnalysisManagerModuleProxy::Result::invalidate( Module &M, const PreservedAnalyses &PA, ModuleAnalysisManager::Invalidator &Inv) { // If literally everything is preserved, we're done. if (PA.areAllPreserved()) return false; // This is still a valid proxy. // If this proxy or the call graph is going to be invalidated, we also need // to clear all the keys coming from that analysis. // // We also directly invalidate the FAM's module proxy if necessary, and if // that proxy isn't preserved we can't preserve this proxy either. We rely on // it to handle module -> function analysis invalidation in the face of // structural changes and so if it's unavailable we conservatively clear the // entire SCC layer as well rather than trying to do invalidation ourselves. auto PAC = PA.getChecker<CGSCCAnalysisManagerModuleProxy>(); if (!(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Module>>()) || Inv.invalidate<LazyCallGraphAnalysis>(M, PA) || Inv.invalidate<FunctionAnalysisManagerModuleProxy>(M, PA)) { InnerAM->clear(); // And the proxy itself should be marked as invalid so that we can observe // the new call graph. This isn't strictly necessary because we cheat // above, but is still useful. return true; } // Directly check if the relevant set is preserved so we can short circuit // invalidating SCCs below. bool AreSCCAnalysesPreserved = PA.allAnalysesInSetPreserved<AllAnalysesOn<LazyCallGraph::SCC>>(); // Ok, we have a graph, so we can propagate the invalidation down into it. G->buildRefSCCs(); for (auto &RC : G->postorder_ref_sccs()) for (auto &C : RC) { Optional<PreservedAnalyses> InnerPA; // Check to see whether the preserved set needs to be adjusted based on // module-level analysis invalidation triggering deferred invalidation // for this SCC. if (auto *OuterProxy = InnerAM->getCachedResult<ModuleAnalysisManagerCGSCCProxy>(C)) for (const auto &OuterInvalidationPair : OuterProxy->getOuterInvalidations()) { AnalysisKey *OuterAnalysisID = OuterInvalidationPair.first; const auto &InnerAnalysisIDs = OuterInvalidationPair.second; if (Inv.invalidate(OuterAnalysisID, M, PA)) { if (!InnerPA) InnerPA = PA; for (AnalysisKey *InnerAnalysisID : InnerAnalysisIDs) InnerPA->abandon(InnerAnalysisID); } } // Check if we needed a custom PA set. If so we'll need to run the inner // invalidation. if (InnerPA) { InnerAM->invalidate(C, *InnerPA); continue; } // Otherwise we only need to do invalidation if the original PA set didn't // preserve all SCC analyses. if (!AreSCCAnalysesPreserved) InnerAM->invalidate(C, PA); } // Return false to indicate that this result is still a valid proxy. return false; }