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; }
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 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; }
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; }