1 //===- LoopPassManager.cpp - Loop pass management -------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "llvm/Support/TimeProfiler.h" 10 #include "llvm/Transforms/Scalar/LoopPassManager.h" 11 #include "llvm/Analysis/LoopInfo.h" 12 13 using namespace llvm; 14 15 // Explicit template instantiations and specialization defininitions for core 16 // template typedefs. 17 namespace llvm { 18 template class PassManager<Loop, LoopAnalysisManager, 19 LoopStandardAnalysisResults &, LPMUpdater &>; 20 21 /// Explicitly specialize the pass manager's run method to handle loop nest 22 /// structure updates. 23 template <> 24 PreservedAnalyses 25 PassManager<Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, 26 LPMUpdater &>::run(Loop &L, LoopAnalysisManager &AM, 27 LoopStandardAnalysisResults &AR, LPMUpdater &U) { 28 PreservedAnalyses PA = PreservedAnalyses::all(); 29 30 if (DebugLogging) 31 dbgs() << "Starting Loop pass manager run.\n"; 32 33 // Request PassInstrumentation from analysis manager, will use it to run 34 // instrumenting callbacks for the passes later. 35 PassInstrumentation PI = AM.getResult<PassInstrumentationAnalysis>(L, AR); 36 for (auto &Pass : Passes) { 37 // Check the PassInstrumentation's BeforePass callbacks before running the 38 // pass, skip its execution completely if asked to (callback returns false). 39 if (!PI.runBeforePass<Loop>(*Pass, L)) 40 continue; 41 42 PreservedAnalyses PassPA; 43 { 44 TimeTraceScope TimeScope(Pass->name(), L.getName()); 45 PassPA = Pass->run(L, AM, AR, U); 46 } 47 48 // do not pass deleted Loop into the instrumentation 49 if (U.skipCurrentLoop()) 50 PI.runAfterPassInvalidated<Loop>(*Pass); 51 else 52 PI.runAfterPass<Loop>(*Pass, L); 53 54 // If the loop was deleted, abort the run and return to the outer walk. 55 if (U.skipCurrentLoop()) { 56 PA.intersect(std::move(PassPA)); 57 break; 58 } 59 60 #ifndef NDEBUG 61 // Verify the loop structure and LCSSA form before visiting the loop. 62 L.verifyLoop(); 63 assert(L.isRecursivelyLCSSAForm(AR.DT, AR.LI) && 64 "Loops must remain in LCSSA form!"); 65 #endif 66 67 // Update the analysis manager as each pass runs and potentially 68 // invalidates analyses. 69 AM.invalidate(L, PassPA); 70 71 // Finally, we intersect the final preserved analyses to compute the 72 // aggregate preserved set for this pass manager. 73 PA.intersect(std::move(PassPA)); 74 75 // FIXME: Historically, the pass managers all called the LLVM context's 76 // yield function here. We don't have a generic way to acquire the 77 // context and it isn't yet clear what the right pattern is for yielding 78 // in the new pass manager so it is currently omitted. 79 // ...getContext().yield(); 80 } 81 82 // Invalidation for the current loop should be handled above, and other loop 83 // analysis results shouldn't be impacted by runs over this loop. Therefore, 84 // the remaining analysis results in the AnalysisManager are preserved. We 85 // mark this with a set so that we don't need to inspect each one 86 // individually. 87 // FIXME: This isn't correct! This loop and all nested loops' analyses should 88 // be preserved, but unrolling should invalidate the parent loop's analyses. 89 PA.preserveSet<AllAnalysesOn<Loop>>(); 90 91 if (DebugLogging) 92 dbgs() << "Finished Loop pass manager run.\n"; 93 94 return PA; 95 } 96 } 97 98 PrintLoopPass::PrintLoopPass() : OS(dbgs()) {} 99 PrintLoopPass::PrintLoopPass(raw_ostream &OS, const std::string &Banner) 100 : OS(OS), Banner(Banner) {} 101 102 PreservedAnalyses PrintLoopPass::run(Loop &L, LoopAnalysisManager &, 103 LoopStandardAnalysisResults &, 104 LPMUpdater &) { 105 printLoop(L, OS, Banner); 106 return PreservedAnalyses::all(); 107 } 108