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