diff options
59 files changed, 186 insertions, 199 deletions
diff --git a/llvm/include/llvm/Analysis/AliasAnalysis.h b/llvm/include/llvm/Analysis/AliasAnalysis.h index 424ea0f74d6..2d06965b84e 100644 --- a/llvm/include/llvm/Analysis/AliasAnalysis.h +++ b/llvm/include/llvm/Analysis/AliasAnalysis.h @@ -866,10 +866,10 @@ public: ResultGetters.push_back(&getModuleAAResultImpl<AnalysisT>); } - Result run(Function &F, AnalysisManager<Function> *AM) { - Result R(AM->getResult<TargetLibraryAnalysis>(F)); + Result run(Function &F, AnalysisManager<Function> &AM) { + Result R(AM.getResult<TargetLibraryAnalysis>(F)); for (auto &Getter : ResultGetters) - (*Getter)(F, *AM, R); + (*Getter)(F, AM, R); return R; } diff --git a/llvm/include/llvm/Analysis/AliasAnalysisEvaluator.h b/llvm/include/llvm/Analysis/AliasAnalysisEvaluator.h index 2b9573e8b7b..3bdd8dbf726 100644 --- a/llvm/include/llvm/Analysis/AliasAnalysisEvaluator.h +++ b/llvm/include/llvm/Analysis/AliasAnalysisEvaluator.h @@ -55,7 +55,7 @@ public: static StringRef name() { return "AAEvaluator"; } /// \brief Run the pass over the function. - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); private: // Allow the legacy pass to run this using an internal API. diff --git a/llvm/include/llvm/Analysis/AssumptionCache.h b/llvm/include/llvm/Analysis/AssumptionCache.h index f76a73780a4..9e8243492c0 100644 --- a/llvm/include/llvm/Analysis/AssumptionCache.h +++ b/llvm/include/llvm/Analysis/AssumptionCache.h @@ -115,7 +115,7 @@ class AssumptionPrinterPass : public PassInfoMixin<AssumptionPrinterPass> { public: explicit AssumptionPrinterPass(raw_ostream &OS) : OS(OS) {} - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); static StringRef name() { return "AssumptionPrinterPass"; } }; diff --git a/llvm/include/llvm/Analysis/BasicAliasAnalysis.h b/llvm/include/llvm/Analysis/BasicAliasAnalysis.h index 43752c7d725..a1ac3ed57bc 100644 --- a/llvm/include/llvm/Analysis/BasicAliasAnalysis.h +++ b/llvm/include/llvm/Analysis/BasicAliasAnalysis.h @@ -187,7 +187,7 @@ class BasicAA : public AnalysisInfoMixin<BasicAA> { public: typedef BasicAAResult Result; - BasicAAResult run(Function &F, AnalysisManager<Function> *AM); + BasicAAResult run(Function &F, AnalysisManager<Function> &AM); }; /// Legacy wrapper pass to provide the BasicAAResult object. diff --git a/llvm/include/llvm/Analysis/CFLAliasAnalysis.h b/llvm/include/llvm/Analysis/CFLAliasAnalysis.h index 08848700239..5ee4dddb94e 100644 --- a/llvm/include/llvm/Analysis/CFLAliasAnalysis.h +++ b/llvm/include/llvm/Analysis/CFLAliasAnalysis.h @@ -116,7 +116,7 @@ class CFLAA : public AnalysisInfoMixin<CFLAA> { public: typedef CFLAAResult Result; - CFLAAResult run(Function &F, AnalysisManager<Function> *AM); + CFLAAResult run(Function &F, AnalysisManager<Function> &AM); }; /// Legacy wrapper pass to provide the CFLAAResult object. diff --git a/llvm/include/llvm/Analysis/CGSCCPassManager.h b/llvm/include/llvm/Analysis/CGSCCPassManager.h index d69ee3f4f19..989305ebb27 100644 --- a/llvm/include/llvm/Analysis/CGSCCPassManager.h +++ b/llvm/include/llvm/Analysis/CGSCCPassManager.h @@ -88,20 +88,18 @@ public: } /// \brief Runs the CGSCC pass across every SCC in the module. - PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM) { - assert(AM && "We need analyses to compute the call graph!"); - + PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) { // Setup the CGSCC analysis manager from its proxy. CGSCCAnalysisManager &CGAM = - AM->getResult<CGSCCAnalysisManagerModuleProxy>(M).getManager(); + AM.getResult<CGSCCAnalysisManagerModuleProxy>(M).getManager(); // Get the call graph for this module. - LazyCallGraph &CG = AM->getResult<LazyCallGraphAnalysis>(M); + LazyCallGraph &CG = AM.getResult<LazyCallGraphAnalysis>(M); PreservedAnalyses PA = PreservedAnalyses::all(); for (LazyCallGraph::RefSCC &OuterC : CG.postorder_ref_sccs()) for (LazyCallGraph::SCC &C : OuterC) { - PreservedAnalyses PassPA = Pass.run(C, &CGAM); + PreservedAnalyses PassPA = Pass.run(C, CGAM); // We know that the CGSCC pass couldn't have invalidated any other // SCC's analyses (that's the contract of a CGSCC pass), so @@ -180,11 +178,10 @@ public: } /// \brief Runs the function pass across every function in the module. - PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager *AM) { - FunctionAnalysisManager *FAM = nullptr; - if (AM) - // Setup the function analysis manager from its proxy. - FAM = &AM->getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager(); + PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) { + // Setup the function analysis manager from its proxy. + FunctionAnalysisManager &FAM = + AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager(); PreservedAnalyses PA = PreservedAnalyses::all(); for (LazyCallGraph::Node &N : C) { @@ -195,8 +192,7 @@ public: // directly handle the function analysis manager's invalidation here. // Also, update the preserved analyses to reflect that once invalidated // these can again be preserved. - if (FAM) - PassPA = FAM->invalidate(N.getFunction(), std::move(PassPA)); + PassPA = FAM.invalidate(N.getFunction(), std::move(PassPA)); // Then intersect the preserved set so that invalidation of module // analyses will eventually occur when the module pass completes. diff --git a/llvm/include/llvm/Analysis/CallGraph.h b/llvm/include/llvm/Analysis/CallGraph.h index d4f9d25ed3e..565c20569cf 100644 --- a/llvm/include/llvm/Analysis/CallGraph.h +++ b/llvm/include/llvm/Analysis/CallGraph.h @@ -315,7 +315,7 @@ class CallGraphPrinterPass : public PassInfoMixin<CallGraphPrinterPass> { public: explicit CallGraphPrinterPass(raw_ostream &OS) : OS(OS) {} - PreservedAnalyses run(Module &M, AnalysisManager<Module> *AM); + PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); }; /// \brief The \c ModulePass which wraps up a \c CallGraph and the logic to diff --git a/llvm/include/llvm/Analysis/DominanceFrontier.h b/llvm/include/llvm/Analysis/DominanceFrontier.h index 65940e92a1c..79672e4e422 100644 --- a/llvm/include/llvm/Analysis/DominanceFrontier.h +++ b/llvm/include/llvm/Analysis/DominanceFrontier.h @@ -178,7 +178,7 @@ public: typedef DominanceFrontier Result; /// \brief Run the analysis pass over a function and produce a dominator tree. - DominanceFrontier run(Function &F, AnalysisManager<Function> *AM); + DominanceFrontier run(Function &F, AnalysisManager<Function> &AM); }; /// \brief Printer pass for the \c DominanceFrontier. @@ -188,7 +188,7 @@ class DominanceFrontierPrinterPass public: explicit DominanceFrontierPrinterPass(raw_ostream &OS); - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); }; } // End llvm namespace diff --git a/llvm/include/llvm/Analysis/GlobalsModRef.h b/llvm/include/llvm/Analysis/GlobalsModRef.h index 555b25d9afa..4c0a9894977 100644 --- a/llvm/include/llvm/Analysis/GlobalsModRef.h +++ b/llvm/include/llvm/Analysis/GlobalsModRef.h @@ -125,7 +125,7 @@ class GlobalsAA : public AnalysisInfoMixin<GlobalsAA> { public: typedef GlobalsAAResult Result; - GlobalsAAResult run(Module &M, AnalysisManager<Module> *AM); + GlobalsAAResult run(Module &M, AnalysisManager<Module> &AM); }; /// Legacy wrapper pass to provide the GlobalsAAResult object. diff --git a/llvm/include/llvm/Analysis/LazyCallGraph.h b/llvm/include/llvm/Analysis/LazyCallGraph.h index d9047323a81..4e72052b9b8 100644 --- a/llvm/include/llvm/Analysis/LazyCallGraph.h +++ b/llvm/include/llvm/Analysis/LazyCallGraph.h @@ -920,7 +920,7 @@ class LazyCallGraphPrinterPass public: explicit LazyCallGraphPrinterPass(raw_ostream &OS); - PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM); + PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM); }; } diff --git a/llvm/include/llvm/Analysis/LoopInfo.h b/llvm/include/llvm/Analysis/LoopInfo.h index de0e3a5b972..934db11abf5 100644 --- a/llvm/include/llvm/Analysis/LoopInfo.h +++ b/llvm/include/llvm/Analysis/LoopInfo.h @@ -794,7 +794,7 @@ class LoopAnalysis : public AnalysisInfoMixin<LoopAnalysis> { public: typedef LoopInfo Result; - LoopInfo run(Function &F, AnalysisManager<Function> *AM); + LoopInfo run(Function &F, AnalysisManager<Function> &AM); }; /// \brief Printer pass for the \c LoopAnalysis results. @@ -803,7 +803,7 @@ class LoopPrinterPass : public PassInfoMixin<LoopPrinterPass> { public: explicit LoopPrinterPass(raw_ostream &OS) : OS(OS) {} - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); }; /// \brief The legacy pass manager's analysis pass to compute loop information. diff --git a/llvm/include/llvm/Analysis/LoopPassManager.h b/llvm/include/llvm/Analysis/LoopPassManager.h index 1b723c35df6..e7d9578c1f8 100644 --- a/llvm/include/llvm/Analysis/LoopPassManager.h +++ b/llvm/include/llvm/Analysis/LoopPassManager.h @@ -78,14 +78,12 @@ public: } /// \brief Runs the loop passes across every loop in the function. - PreservedAnalyses run(Function &F, FunctionAnalysisManager *AM) { - assert(AM && "We need analyses to compute the loop structure!"); - + PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) { // Setup the loop analysis manager from its proxy. - LoopAnalysisManager *LAM = - &AM->getResult<LoopAnalysisManagerFunctionProxy>(F).getManager(); + LoopAnalysisManager &LAM = + AM.getResult<LoopAnalysisManagerFunctionProxy>(F).getManager(); // Get the loop structure for this function - LoopInfo &LI = AM->getResult<LoopAnalysis>(F); + LoopInfo &LI = AM.getResult<LoopAnalysis>(F); PreservedAnalyses PA = PreservedAnalyses::all(); @@ -109,7 +107,7 @@ public: // loop analysis manager's invalidation here. Also, update the // preserved analyses to reflect that once invalidated these can again // be preserved. - PassPA = LAM->invalidate(*L, std::move(PassPA)); + PassPA = LAM.invalidate(*L, std::move(PassPA)); // Then intersect the preserved set so that invalidation of module // analyses will eventually occur when the module pass completes. diff --git a/llvm/include/llvm/Analysis/MemoryDependenceAnalysis.h b/llvm/include/llvm/Analysis/MemoryDependenceAnalysis.h index 7c8bd2f5cdc..b92dec9a7bc 100644 --- a/llvm/include/llvm/Analysis/MemoryDependenceAnalysis.h +++ b/llvm/include/llvm/Analysis/MemoryDependenceAnalysis.h @@ -479,7 +479,7 @@ class MemoryDependenceAnalysis public: typedef MemoryDependenceResults Result; - MemoryDependenceResults run(Function &F, AnalysisManager<Function> *AM); + MemoryDependenceResults run(Function &F, AnalysisManager<Function> &AM); }; /// A wrapper analysis pass for the legacy pass manager that exposes a \c diff --git a/llvm/include/llvm/Analysis/ObjCARCAliasAnalysis.h b/llvm/include/llvm/Analysis/ObjCARCAliasAnalysis.h index 06a2ce77b6f..067a964bcce 100644 --- a/llvm/include/llvm/Analysis/ObjCARCAliasAnalysis.h +++ b/llvm/include/llvm/Analysis/ObjCARCAliasAnalysis.h @@ -68,7 +68,7 @@ class ObjCARCAA : public AnalysisInfoMixin<ObjCARCAA> { public: typedef ObjCARCAAResult Result; - ObjCARCAAResult run(Function &F, AnalysisManager<Function> *AM); + ObjCARCAAResult run(Function &F, AnalysisManager<Function> &AM); }; /// Legacy wrapper pass to provide the ObjCARCAAResult object. diff --git a/llvm/include/llvm/Analysis/PostDominators.h b/llvm/include/llvm/Analysis/PostDominators.h index dd6e9d36436..28a1b0d0dc7 100644 --- a/llvm/include/llvm/Analysis/PostDominators.h +++ b/llvm/include/llvm/Analysis/PostDominators.h @@ -58,7 +58,7 @@ class PostDominatorTreePrinterPass public: explicit PostDominatorTreePrinterPass(raw_ostream &OS); - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); }; struct PostDominatorTreeWrapperPass : public FunctionPass { diff --git a/llvm/include/llvm/Analysis/RegionInfo.h b/llvm/include/llvm/Analysis/RegionInfo.h index c3cbc9e2fb3..91bfd435f08 100644 --- a/llvm/include/llvm/Analysis/RegionInfo.h +++ b/llvm/include/llvm/Analysis/RegionInfo.h @@ -930,7 +930,7 @@ class RegionInfoAnalysis : public AnalysisInfoMixin<RegionInfoAnalysis> { public: typedef RegionInfo Result; - RegionInfo run(Function &F, AnalysisManager<Function> *AM); + RegionInfo run(Function &F, AnalysisManager<Function> &AM); }; /// \brief Printer pass for the \c RegionInfo. @@ -939,12 +939,12 @@ class RegionInfoPrinterPass : public PassInfoMixin<RegionInfoPrinterPass> { public: explicit RegionInfoPrinterPass(raw_ostream &OS); - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); }; /// \brief Verifier pass for the \c RegionInfo. struct RegionInfoVerifierPass : PassInfoMixin<RegionInfoVerifierPass> { - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); }; template <> diff --git a/llvm/include/llvm/Analysis/ScalarEvolution.h b/llvm/include/llvm/Analysis/ScalarEvolution.h index 040b16d0dd8..775f526b1a2 100644 --- a/llvm/include/llvm/Analysis/ScalarEvolution.h +++ b/llvm/include/llvm/Analysis/ScalarEvolution.h @@ -1438,7 +1438,7 @@ namespace llvm { public: typedef ScalarEvolution Result; - ScalarEvolution run(Function &F, AnalysisManager<Function> *AM); + ScalarEvolution run(Function &F, AnalysisManager<Function> &AM); }; /// \brief Printer pass for the \c ScalarEvolutionAnalysis results. @@ -1448,7 +1448,7 @@ namespace llvm { public: explicit ScalarEvolutionPrinterPass(raw_ostream &OS) : OS(OS) {} - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); }; class ScalarEvolutionWrapperPass : public FunctionPass { diff --git a/llvm/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h b/llvm/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h index 89e4a0035ca..ac10370b413 100644 --- a/llvm/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h +++ b/llvm/include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h @@ -45,7 +45,7 @@ class SCEVAA : public AnalysisInfoMixin<SCEVAA> { public: typedef SCEVAAResult Result; - SCEVAAResult run(Function &F, AnalysisManager<Function> *AM); + SCEVAAResult run(Function &F, AnalysisManager<Function> &AM); }; /// Legacy wrapper pass to provide the SCEVAAResult object. diff --git a/llvm/include/llvm/Analysis/ScopedNoAliasAA.h b/llvm/include/llvm/Analysis/ScopedNoAliasAA.h index a5cba3f54b1..87b85d4e663 100644 --- a/llvm/include/llvm/Analysis/ScopedNoAliasAA.h +++ b/llvm/include/llvm/Analysis/ScopedNoAliasAA.h @@ -54,7 +54,7 @@ class ScopedNoAliasAA : public AnalysisInfoMixin<ScopedNoAliasAA> { public: typedef ScopedNoAliasAAResult Result; - ScopedNoAliasAAResult run(Function &F, AnalysisManager<Function> *AM); + ScopedNoAliasAAResult run(Function &F, AnalysisManager<Function> &AM); }; /// Legacy wrapper pass to provide the ScopedNoAliasAAResult object. diff --git a/llvm/include/llvm/Analysis/TypeBasedAliasAnalysis.h b/llvm/include/llvm/Analysis/TypeBasedAliasAnalysis.h index 9b497504b22..229b0f97b98 100644 --- a/llvm/include/llvm/Analysis/TypeBasedAliasAnalysis.h +++ b/llvm/include/llvm/Analysis/TypeBasedAliasAnalysis.h @@ -55,7 +55,7 @@ class TypeBasedAA : public AnalysisInfoMixin<TypeBasedAA> { public: typedef TypeBasedAAResult Result; - TypeBasedAAResult run(Function &F, AnalysisManager<Function> *AM); + TypeBasedAAResult run(Function &F, AnalysisManager<Function> &AM); }; /// Legacy wrapper pass to provide the TypeBasedAAResult object. diff --git a/llvm/include/llvm/IR/Dominators.h b/llvm/include/llvm/IR/Dominators.h index 8efff1c0c46..f4990b0557e 100644 --- a/llvm/include/llvm/IR/Dominators.h +++ b/llvm/include/llvm/IR/Dominators.h @@ -201,12 +201,12 @@ class DominatorTreePrinterPass public: explicit DominatorTreePrinterPass(raw_ostream &OS); - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); }; /// \brief Verifier pass for the \c DominatorTree. struct DominatorTreeVerifierPass : PassInfoMixin<DominatorTreeVerifierPass> { - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); }; /// \brief Legacy analysis pass which computes a \c DominatorTree. diff --git a/llvm/include/llvm/IR/PassManager.h b/llvm/include/llvm/IR/PassManager.h index 6ed6a366867..799f4aa6a00 100644 --- a/llvm/include/llvm/IR/PassManager.h +++ b/llvm/include/llvm/IR/PassManager.h @@ -235,7 +235,7 @@ public: } /// \brief Run all of the passes in this manager over the IR. - PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM = nullptr) { + PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) { PreservedAnalyses PA = PreservedAnalyses::all(); if (DebugLogging) @@ -248,13 +248,11 @@ public: PreservedAnalyses PassPA = Passes[Idx]->run(IR, AM); - // If we have an active analysis manager at this level we want to ensure - // we update it as each pass runs and potentially invalidates analyses. - // We also update the preserved set of analyses based on what analyses we - // have already handled the invalidation for here and don't need to - // invalidate when finished. - if (AM) - PassPA = AM->invalidate(IR, std::move(PassPA)); + // Update the analysis manager as each pass runs and potentially + // invalidates analyses. We also update the preserved set of analyses + // based on what analyses we have already handled the invalidation for + // here and don't need to invalidate when finished. + PassPA = AM.invalidate(IR, std::move(PassPA)); // Finally, we intersect the final preserved analyses to compute the // aggregate preserved set for this pass manager. @@ -533,7 +531,7 @@ private: if (DebugLogging) dbgs() << "Running analysis: " << P.name() << "\n"; AnalysisResultListT &ResultList = AnalysisResultLists[&IR]; - ResultList.emplace_back(PassID, P.run(IR, this)); + ResultList.emplace_back(PassID, P.run(IR, *this)); // P.run may have inserted elements into AnalysisResults and invalidated // RI. @@ -885,11 +883,10 @@ public: } /// \brief Runs the function pass across every function in the module. - PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM) { - FunctionAnalysisManager *FAM = nullptr; - if (AM) - // Setup the function analysis manager from its proxy. - FAM = &AM->getResult<FunctionAnalysisManagerModuleProxy>(M).getManager(); + PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) { + // Setup the function analysis manager from its proxy. + FunctionAnalysisManager &FAM = + AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager(); PreservedAnalyses PA = PreservedAnalyses::all(); for (Function &F : M) { @@ -903,8 +900,7 @@ public: // directly handle the function analysis manager's invalidation here and // update our preserved set to reflect that these have already been // handled. - if (FAM) - PassPA = FAM->invalidate(F, std::move(PassPA)); + PassPA = FAM.invalidate(F, std::move(PassPA)); // Then intersect the preserved set so that invalidation of module // analyses will eventually occur when the module pass completes. @@ -944,9 +940,8 @@ struct RequireAnalysisPass : PassInfoMixin<RequireAnalysisPass<AnalysisT>> { /// created, these methods can be instantiated to satisfy whatever the /// context requires. template <typename IRUnitT> - PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> *AM) { - if (AM) - (void)AM->template getResult<AnalysisT>(Arg); + PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> &AM) { + (void)AM.template getResult<AnalysisT>(Arg); return PreservedAnalyses::all(); } @@ -967,11 +962,10 @@ struct InvalidateAnalysisPass /// created, these methods can be instantiated to satisfy whatever the /// context requires. template <typename IRUnitT> - PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> *AM) { - if (AM) - // We have to directly invalidate the analysis result as we can't - // enumerate all other analyses and use the preserved set to control it. - (void)AM->template invalidate<AnalysisT>(Arg); + PreservedAnalyses run(IRUnitT &Arg, AnalysisManager<IRUnitT> &AM) { + // We have to directly invalidate the analysis result as we can't + // enumerate all other analyses and use the preserved set to control it. + AM.template invalidate<AnalysisT>(Arg); return PreservedAnalyses::all(); } diff --git a/llvm/include/llvm/IR/PassManagerInternal.h b/llvm/include/llvm/IR/PassManagerInternal.h index 92de10bcd75..e5bdd226a1c 100644 --- a/llvm/include/llvm/IR/PassManagerInternal.h +++ b/llvm/include/llvm/IR/PassManagerInternal.h @@ -40,7 +40,7 @@ template <typename IRUnitT> struct PassConcept { /// Note that actual pass object can omit the analysis manager argument if /// desired. Also that the analysis manager may be null if there is no /// analysis manager in the pass pipeline. - virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) = 0; + virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) = 0; /// \brief Polymorphic method to access the name of a pass. virtual StringRef name() = 0; @@ -55,7 +55,7 @@ class PassRunAcceptsAnalysisManager { char a, b; }; - template <typename T, ResultT (T::*)(IRUnitT &, AnalysisManager<IRUnitT> *)> + template <typename T, ResultT (T::*)(IRUnitT &, AnalysisManager<IRUnitT> &)> struct Checker; template <typename T> static SmallType f(Checker<T, &T::run> *); @@ -96,7 +96,7 @@ struct PassModel<IRUnitT, PassT, PreservedAnalysesT, true> return *this; } - PreservedAnalysesT run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) override { + PreservedAnalysesT run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) override { return Pass.run(IR, AM); } StringRef name() override { return PassT::name(); } @@ -122,7 +122,7 @@ struct PassModel<IRUnitT, PassT, PreservedAnalysesT, false> return *this; } - PreservedAnalysesT run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) override { + PreservedAnalysesT run(IRUnitT &IR, AnalysisManager<IRUnitT> &) override { return Pass.run(IR); } StringRef name() override { return PassT::name(); } @@ -252,7 +252,7 @@ template <typename IRUnitT> struct AnalysisPassConcept { /// \returns A unique_ptr to the analysis result object to be queried by /// users. virtual std::unique_ptr<AnalysisResultConcept<IRUnitT>> - run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) = 0; + run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) = 0; /// \brief Polymorphic method to access the name of a pass. virtual StringRef name() = 0; @@ -294,7 +294,7 @@ struct AnalysisPassModel<IRUnitT, PassT, true> : AnalysisPassConcept<IRUnitT> { /// /// The return is wrapped in an \c AnalysisResultModel. std::unique_ptr<AnalysisResultConcept<IRUnitT>> - run(IRUnitT &IR, AnalysisManager<IRUnitT> *AM) override { + run(IRUnitT &IR, AnalysisManager<IRUnitT> &AM) override { return make_unique<ResultModelT>(Pass.run(IR, AM)); } @@ -332,7 +332,7 @@ struct AnalysisPassModel<IRUnitT, PassT, false> : AnalysisPassConcept<IRUnitT> { /// /// The return is wrapped in an \c AnalysisResultModel. std::unique_ptr<AnalysisResultConcept<IRUnitT>> - run(IRUnitT &IR, AnalysisManager<IRUnitT> *) override { + run(IRUnitT &IR, AnalysisManager<IRUnitT> &) override { return make_unique<ResultModelT>(Pass.run(IR)); } diff --git a/llvm/include/llvm/Transforms/IPO/FunctionAttrs.h b/llvm/include/llvm/Transforms/IPO/FunctionAttrs.h index aab7d8ba9f3..83fad94ef84 100644 --- a/llvm/include/llvm/Transforms/IPO/FunctionAttrs.h +++ b/llvm/include/llvm/Transforms/IPO/FunctionAttrs.h @@ -30,7 +30,7 @@ namespace llvm { /// attribute. It also discovers function arguments that are not captured by /// the function and marks them with the nocapture attribute. struct PostOrderFunctionAttrsPass : PassInfoMixin<PostOrderFunctionAttrsPass> { - PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager *AM); + PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM); }; /// Create a legacy pass manager instance of a pass to compute function attrs diff --git a/llvm/include/llvm/Transforms/IPO/InferFunctionAttrs.h b/llvm/include/llvm/Transforms/IPO/InferFunctionAttrs.h index a26205d5403..f5cbf9eb061 100644 --- a/llvm/include/llvm/Transforms/IPO/InferFunctionAttrs.h +++ b/llvm/include/llvm/Transforms/IPO/InferFunctionAttrs.h @@ -24,7 +24,7 @@ namespace llvm { /// A pass which infers function attributes from the names and signatures of /// function declarations in a module. struct InferFunctionAttrsPass : PassInfoMixin<InferFunctionAttrsPass> { - PreservedAnalyses run(Module &M, AnalysisManager<Module> *AM); + PreservedAnalyses run(Module &M, AnalysisManager<Module> &AM); }; /// Create a legacy pass manager instance of a pass to infer function diff --git a/llvm/include/llvm/Transforms/InstCombine/InstCombine.h b/llvm/include/llvm/Transforms/InstCombine/InstCombine.h index b03017fd8b6..d70b847c689 100644 --- a/llvm/include/llvm/Transforms/InstCombine/InstCombine.h +++ b/llvm/include/llvm/Transforms/InstCombine/InstCombine.h @@ -43,7 +43,7 @@ public: return *this; } - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); }; /// \brief The legacy pass manager's instcombine pass. diff --git a/llvm/include/llvm/Transforms/Scalar/EarlyCSE.h b/llvm/include/llvm/Transforms/Scalar/EarlyCSE.h index 8d1dc321b35..80e3c602a2b 100644 --- a/llvm/include/llvm/Transforms/Scalar/EarlyCSE.h +++ b/llvm/include/llvm/Transforms/Scalar/EarlyCSE.h @@ -28,7 +28,7 @@ namespace llvm { /// expected that a later pass of GVN will catch the interesting/hard cases. struct EarlyCSEPass : PassInfoMixin<EarlyCSEPass> { /// \brief Run the pass over the function. - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); }; } diff --git a/llvm/include/llvm/Transforms/Scalar/GVN.h b/llvm/include/llvm/Transforms/Scalar/GVN.h index 342b3df1eb9..849e1db7246 100644 --- a/llvm/include/llvm/Transforms/Scalar/GVN.h +++ b/llvm/include/llvm/Transforms/Scalar/GVN.h @@ -46,7 +46,7 @@ class GVN : public PassInfoMixin<GVN> { public: /// \brief Run the pass over the function. - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); /// This removes the specified instruction from /// our various maps and marks it for deletion. diff --git a/llvm/include/llvm/Transforms/Scalar/SROA.h b/llvm/include/llvm/Transforms/Scalar/SROA.h index 9581cb7b5bf..72e7d63d4df 100644 --- a/llvm/include/llvm/Transforms/Scalar/SROA.h +++ b/llvm/include/llvm/Transforms/Scalar/SROA.h @@ -102,7 +102,7 @@ public: SROA() : C(nullptr), DT(nullptr), AC(nullptr) {} /// \brief Run the pass over the function. - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); private: friend class sroa::AllocaSliceRewriter; diff --git a/llvm/include/llvm/Transforms/Scalar/SimplifyCFG.h b/llvm/include/llvm/Transforms/Scalar/SimplifyCFG.h index 514a86b95bd..53f427a7d19 100644 --- a/llvm/include/llvm/Transforms/Scalar/SimplifyCFG.h +++ b/llvm/include/llvm/Transforms/Scalar/SimplifyCFG.h @@ -36,7 +36,7 @@ public: SimplifyCFGPass(int BonusInstThreshold); /// \brief Run the pass over the function. - PreservedAnalyses run(Function &F, AnalysisManager<Function> *AM); + PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM); }; } diff --git a/llvm/lib/Analysis/AliasAnalysisEvaluator.cpp b/llvm/lib/Analysis/AliasAnalysisEvaluator.cpp index 3a40afcaa84..74216aab069 100644 --- a/llvm/lib/Analysis/AliasAnalysisEvaluator.cpp +++ b/llvm/lib/Analysis/AliasAnalysisEvaluator.cpp @@ -88,8 +88,8 @@ static inline bool isInterestingPointer(Value *V) { && !isa<ConstantPointerNull>(V); } -PreservedAnalyses AAEvaluator::run(Function &F, AnalysisManager<Function> *AM) { - runInternal(F, AM->getResult<AAManager>(F)); +PreservedAnalyses AAEvaluator::run(Function &F, AnalysisManager<Function> &AM) { + runInternal(F, AM.getResult<AAManager>(F)); return PreservedAnalyses::all(); } diff --git a/llvm/lib/Analysis/AssumptionCache.cpp b/llvm/lib/Analysis/AssumptionCache.cpp index f468a43ef0b..ca71644757f 100644 --- a/llvm/lib/Analysis/AssumptionCache.cpp +++ b/llvm/lib/Analysis/AssumptionCache.cpp @@ -77,8 +77,8 @@ void AssumptionCache::registerAssumption(CallInst *CI) { char AssumptionAnalysis::PassID; PreservedAnalyses AssumptionPrinterPass::run(Function &F, - AnalysisManager<Function> *AM) { - AssumptionCache &AC = AM->getResult<AssumptionAnalysis>(F); + AnalysisManager<Function> &AM) { + AssumptionCache &AC = AM.getResult<AssumptionAnalysis>(F); OS << "Cached assumptions for function: " << F.getName() << "\n"; for (auto &VH : AC.assumptions()) diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp index 84507ec37d7..18972105b88 100644 --- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp +++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp @@ -1608,12 +1608,12 @@ bool BasicAAResult::constantOffsetHeuristic( char BasicAA::PassID; -BasicAAResult BasicAA::run(Function &F, AnalysisManager<Function> *AM) { +BasicAAResult BasicAA::run(Function &F, AnalysisManager<Function> &AM) { return BasicAAResult(F.getParent()->getDataLayout(), - AM->getResult<TargetLibraryAnalysis>(F), - AM->getResult<AssumptionAnalysis>(F), - AM->getCachedResult<DominatorTreeAnalysis>(F), - AM->getCachedResult<LoopAnalysis>(F)); + AM.getResult<TargetLibraryAnalysis>(F), + AM.getResult<AssumptionAnalysis>(F), + AM.getCachedResult<DominatorTreeAnalysis>(F), + AM.getCachedResult<LoopAnalysis>(F)); } BasicAAWrapperPass::BasicAAWrapperPass() : FunctionPass(ID) { diff --git a/llvm/lib/Analysis/CFLAliasAnalysis.cpp b/llvm/lib/Analysis/CFLAliasAnalysis.cpp index 9e4ca7ad103..2c755077996 100644 --- a/llvm/lib/Analysis/CFLAliasAnalysis.cpp +++ b/llvm/lib/Analysis/CFLAliasAnalysis.cpp @@ -1090,7 +1090,7 @@ AliasResult CFLAAResult::query(const MemoryLocation &LocA, char CFLAA::PassID; -CFLAAResult CFLAA::run(Function &F, AnalysisManager<Function> *AM) { +CFLAAResult CFLAA::run(Function &F, AnalysisManager<Function> &AM) { return CFLAAResult(); } diff --git a/llvm/lib/Analysis/CallGraph.cpp b/llvm/lib/Analysis/CallGraph.cpp index 2de2e0d0ab9..7d9252f746d 100644 --- a/llvm/lib/Analysis/CallGraph.cpp +++ b/llvm/lib/Analysis/CallGraph.cpp @@ -263,8 +263,8 @@ void CallGraphNode::replaceCallEdge(CallSite CS, char CallGraphAnalysis::PassID; PreservedAnalyses CallGraphPrinterPass::run(Module &M, - AnalysisManager<Module> *AM) { - AM->getResult<CallGraphAnalysis>(M).print(OS); + AnalysisManager<Module> &AM) { + AM.getResult<CallGraphAnalysis>(M).print(OS); return PreservedAnalyses::all(); } diff --git a/llvm/lib/Analysis/DominanceFrontier.cpp b/llvm/lib/Analysis/DominanceFrontier.cpp index ef7062da775..4554374252a 100644 --- a/llvm/lib/Analysis/DominanceFrontier.cpp +++ b/llvm/lib/Analysis/DominanceFrontier.cpp @@ -59,9 +59,9 @@ LLVM_DUMP_METHOD void DominanceFrontierWrapperPass::dump() const { char DominanceFrontierAnalysis::PassID; DominanceFrontier DominanceFrontierAnalysis::run(Function &F, - FunctionAnalysisManager *AM) { + FunctionAnalysisManager &AM) { DominanceFrontier DF; - DF.analyze(AM->getResult<DominatorTreeAnalysis>(F)); + DF.analyze(AM.getResult<DominatorTreeAnalysis>(F)); return DF; } @@ -69,9 +69,9 @@ DominanceFrontierPrinterPass::DominanceFrontierPrinterPass(raw_ostream &OS) : OS(OS) {} PreservedAnalyses -DominanceFrontierPrinterPass::run(Function &F, FunctionAnalysisManager *AM) { +DominanceFrontierPrinterPass::run(Function &F, FunctionAnalysisManager &AM) { OS << "DominanceFrontier for function: " << F.getName() << "\n"; - AM->getResult<DominanceFrontierAnalysis>(F).print(OS); + AM.getResult<DominanceFrontierAnalysis>(F).print(OS); return PreservedAnalyses::all(); } diff --git a/llvm/lib/Analysis/GlobalsModRef.cpp b/llvm/lib/Analysis/GlobalsModRef.cpp index 22a6fba34b6..3d2b0225735 100644 --- a/llvm/lib/Analysis/GlobalsModRef.cpp +++ b/llvm/lib/Analysis/GlobalsModRef.cpp @@ -938,10 +938,10 @@ GlobalsAAResult::analyzeModule(Module &M, const TargetLibraryInfo &TLI, char GlobalsAA::PassID; -GlobalsAAResult GlobalsAA::run(Module &M, AnalysisManager<Module> *AM) { +GlobalsAAResult GlobalsAA::run(Module &M, AnalysisManager<Module> &AM) { return GlobalsAAResult::analyzeModule(M, - AM->getResult<TargetLibraryAnalysis>(M), - AM->getResult<CallGraphAnalysis>(M)); + AM.getResult<TargetLibraryAnalysis>(M), + AM.getResult<CallGraphAnalysis>(M)); } char GlobalsAAWrapperPass::ID = 0; diff --git a/llvm/lib/Analysis/LazyCallGraph.cpp b/llvm/lib/Analysis/LazyCallGraph.cpp index 5de90782a31..36425c99adc 100644 --- a/llvm/lib/Analysis/LazyCallGraph.cpp +++ b/llvm/lib/Analysis/LazyCallGraph.cpp @@ -1531,8 +1531,8 @@ static void printRefSCC(raw_ostream &OS, LazyCallGraph::RefSCC &C) { } PreservedAnalyses LazyCallGraphPrinterPass::run(Module &M, - ModuleAnalysisManager *AM) { - LazyCallGraph &G = AM->getResult<LazyCallGraphAnalysis>(M); + ModuleAnalysisManager &AM) { + LazyCallGraph &G = AM.getResult<LazyCallGraphAnalysis>(M); OS << "Printing the call graph for module: " << M.getModuleIdentifier() << "\n\n"; diff --git a/llvm/lib/Analysis/LoopInfo.cpp b/llvm/lib/Analysis/LoopInfo.cpp index 14ca91dc5e0..47a313a8f3a 100644 --- a/llvm/lib/Analysis/LoopInfo.cpp +++ b/llvm/lib/Analysis/LoopInfo.cpp @@ -643,7 +643,7 @@ void LoopInfo::markAsRemoved(Loop *Unloop) { char LoopAnalysis::PassID; -LoopInfo LoopAnalysis::run(Function &F, AnalysisManager<Function> *AM) { +LoopInfo LoopAnalysis::run(Function &F, AnalysisManager<Function> &AM) { // FIXME: Currently we create a LoopInfo from scratch for every function. // This may prove to be too wasteful due to deallocating and re-allocating // memory each time for the underlying map and vector datastructures. At some @@ -651,13 +651,13 @@ LoopInfo LoopAnalysis::run(Function &F, AnalysisManager<Function> *AM) { // objects. I don't want to add that kind of complexity until the scope of // the problem is better understood. LoopInfo LI; - LI.analyze(AM->getResult<DominatorTreeAnalysis>(F)); + LI.analyze(AM.getResult<DominatorTreeAnalysis>(F)); return LI; } PreservedAnalyses LoopPrinterPass::run(Function &F, - AnalysisManager<Function> *AM) { - AM->getResult<LoopAnalysis>(F).print(OS); + AnalysisManager<Function> &AM) { + AM.getResult<LoopAnalysis>(F).print(OS); return PreservedAnalyses::all(); } diff --git a/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp b/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp index 9606c84d7c5..c99d206167c 100644 --- a/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp +++ b/llvm/lib/Analysis/MemoryDependenceAnalysis.cpp @@ -1662,11 +1662,11 @@ void MemoryDependenceResults::verifyRemoved(Instruction *D) const { char MemoryDependenceAnalysis::PassID; MemoryDependenceResults -MemoryDependenceAnalysis::run(Function &F, AnalysisManager<Function> *AM) { - auto &AA = AM->getResult<AAManager>(F); - auto &AC = AM->getResult<AssumptionAnalysis>(F); - auto &TLI = AM->getResult<TargetLibraryAnalysis>(F); - auto *DT = AM->getCachedResult<DominatorTreeAnalysis>(F); +MemoryDependenceAnalysis::run(Function &F, AnalysisManager<Function> &AM) { + auto &AA = AM.getResult<AAManager>(F); + auto &AC = AM.getResult<AssumptionAnalysis>(F); + auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); + auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F); return MemoryDependenceResults(AA, AC, TLI, DT); } diff --git a/llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp b/llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp index d2d03cbcdb5..9bb1048ea8b 100644 --- a/llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp +++ b/llvm/lib/Analysis/ObjCARCAliasAnalysis.cpp @@ -131,7 +131,7 @@ ModRefInfo ObjCARCAAResult::getModRefInfo(ImmutableCallSite CS, return AAResultBase::getModRefInfo(CS, Loc); } -ObjCARCAAResult ObjCARCAA::run(Function &F, AnalysisManager<Function> *AM) { +ObjCARCAAResult ObjCARCAA::run(Function &F, AnalysisManager<Function> &AM) { return ObjCARCAAResult(F.getParent()->getDataLayout()); } diff --git a/llvm/lib/Analysis/PostDominators.cpp b/llvm/lib/Analysis/PostDominators.cpp index b515108fafb..8d3452e4860 100644 --- a/llvm/lib/Analysis/PostDominators.cpp +++ b/llvm/lib/Analysis/PostDominators.cpp @@ -56,9 +56,9 @@ PostDominatorTreePrinterPass::PostDominatorTreePrinterPass(raw_ostream &OS) : OS(OS) {} PreservedAnalyses -PostDominatorTreePrinterPass::run(Function &F, FunctionAnalysisManager *AM) { +PostDominatorTreePrinterPass::run(Function &F, FunctionAnalysisManager &AM) { OS << "PostDominatorTree for function: " << F.getName() << "\n"; - AM->getResult<PostDominatorTreeAnalysis>(F).print(OS); + AM.getResult<PostDominatorTreeAnalysis>(F).print(OS); return PreservedAnalyses::all(); } diff --git a/llvm/lib/Analysis/RegionInfo.cpp b/llvm/lib/Analysis/RegionInfo.cpp index 72b3217dc6f..2e9325e08eb 100644 --- a/llvm/lib/Analysis/RegionInfo.cpp +++ b/llvm/lib/Analysis/RegionInfo.cpp @@ -187,11 +187,11 @@ namespace llvm { char RegionInfoAnalysis::PassID; -RegionInfo RegionInfoAnalysis::run(Function &F, AnalysisManager<Function> *AM) { +RegionInfo RegionInfoAnalysis::run(Function &F, AnalysisManager<Function> &AM) { RegionInfo RI; - auto *DT = &AM->getResult<DominatorTreeAnalysis>(F); - auto *PDT = &AM->getResult<PostDominatorTreeAnalysis>(F); - auto *DF = &AM->getResult<DominanceFrontierAnalysis>(F); + auto *DT = &AM.getResult<DominatorTreeAnalysis>(F); + auto *PDT = &AM.getResult<PostDominatorTreeAnalysis>(F); + auto *DF = &AM.getResult<DominanceFrontierAnalysis>(F); RI.recalculate(F, DT, PDT, DF); return RI; @@ -200,17 +200,17 @@ RegionInfo RegionInfoAnalysis::run(Function &F, AnalysisManager<Function> *AM) { RegionInfoPrinterPass::RegionInfoPrinterPass(raw_ostream &OS) : OS(OS) {} -PreservedAnalyses -RegionInfoPrinterPass::run(Function &F, FunctionAnalysisManager *AM) { +PreservedAnalyses RegionInfoPrinterPass::run(Function &F, + FunctionAnalysisManager &AM) { OS << "Region Tree for function: " << F.getName() << "\n"; - AM->getResult<RegionInfoAnalysis>(F).print(OS); + AM.getResult<RegionInfoAnalysis>(F).print(OS); return PreservedAnalyses::all(); } PreservedAnalyses RegionInfoVerifierPass::run(Function &F, - AnalysisManager<Function> *AM) { - AM->getResult<RegionInfoAnalysis>(F).verifyAnalysis(); + AnalysisManager<Function> &AM) { + AM.getResult<RegionInfoAnalysis>(F).verifyAnalysis(); return PreservedAnalyses::all(); } diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp index 454bb0931f3..f0900c9956a 100644 --- a/llvm/lib/Analysis/ScalarEvolution.cpp +++ b/llvm/lib/Analysis/ScalarEvolution.cpp @@ -9733,16 +9733,16 @@ void ScalarEvolution::verify() const { char ScalarEvolutionAnalysis::PassID; ScalarEvolution ScalarEvolutionAnalysis::run(Function &F, - AnalysisManager<Function> *AM) { - return ScalarEvolution(F, AM->getResult<TargetLibraryAnalysis>(F), - AM->getResult<AssumptionAnalysis>(F), - AM->getResult<DominatorTreeAnalysis>(F), - AM->getResult<LoopAnalysis>(F)); + AnalysisManager<Function> &AM) { + return ScalarEvolution(F, AM.getResult<TargetLibraryAnalysis>(F), + AM.getResult<AssumptionAnalysis>(F), + AM.getResult<DominatorTreeAnalysis>(F), + AM.getResult<LoopAnalysis>(F)); } PreservedAnalyses -ScalarEvolutionPrinterPass::run(Function &F, AnalysisManager<Function> *AM) { - AM->getResult<ScalarEvolutionAnalysis>(F).print(OS); +ScalarEvolutionPrinterPass::run(Function &F, AnalysisManager<Function> &AM) { + AM.getResult<ScalarEvolutionAnalysis>(F).print(OS); return PreservedAnalyses::all(); } diff --git a/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp b/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp index f0ddc48ceef..61fb411d315 100644 --- a/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp +++ b/llvm/lib/Analysis/ScalarEvolutionAliasAnalysis.cpp @@ -112,8 +112,8 @@ Value *SCEVAAResult::GetBaseValue(const SCEV *S) { char SCEVAA::PassID; -SCEVAAResult SCEVAA::run(Function &F, AnalysisManager<Function> *AM) { - return SCEVAAResult(AM->getResult<ScalarEvolutionAnalysis>(F)); +SCEVAAResult SCEVAA::run(Function &F, AnalysisManager<Function> &AM) { + return SCEVAAResult(AM.getResult<ScalarEvolutionAnalysis>(F)); } char SCEVAAWrapperPass::ID = 0; diff --git a/llvm/lib/Analysis/ScopedNoAliasAA.cpp b/llvm/lib/Analysis/ScopedNoAliasAA.cpp index e52f78049da..82e65a1f208 100644 --- a/llvm/lib/Analysis/ScopedNoAliasAA.cpp +++ b/llvm/lib/Analysis/ScopedNoAliasAA.cpp @@ -175,7 +175,7 @@ bool ScopedNoAliasAAResult::mayAliasInScopes(const MDNode *Scopes, char ScopedNoAliasAA::PassID; ScopedNoAliasAAResult ScopedNoAliasAA::run(Function &F, - AnalysisManager<Function> *AM) { + AnalysisManager<Function> &AM) { return ScopedNoAliasAAResult(); } diff --git a/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp b/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp index fc9a62c0764..20d162a03c3 100644 --- a/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp +++ b/llvm/lib/Analysis/TypeBasedAliasAnalysis.cpp @@ -585,7 +585,7 @@ bool TypeBasedAAResult::PathAliases(const MDNode *A, const MDNode *B) const { char TypeBasedAA::PassID; -TypeBasedAAResult TypeBasedAA::run(Function &F, AnalysisManager<Function> *AM) { +TypeBasedAAResult TypeBasedAA::run(Function &F, AnalysisManager<Function> &AM) { return TypeBasedAAResult(); } diff --git a/llvm/lib/IR/Dominators.cpp b/llvm/lib/IR/Dominators.cpp index b9d4fb7de88..d230ee52acc 100644 --- a/llvm/lib/IR/Dominators.cpp +++ b/llvm/lib/IR/Dominators.cpp @@ -313,16 +313,16 @@ char DominatorTreeAnalysis::PassID; DominatorTreePrinterPass::DominatorTreePrinterPass(raw_ostream &OS) : OS(OS) {} PreservedAnalyses DominatorTreePrinterPass::run(Function &F, - FunctionAnalysisManager *AM) { + FunctionAnalysisManager &AM) { OS << "DominatorTree for function: " << F.getName() << "\n"; - AM->getResult<DominatorTreeAnalysis>(F).print(OS); + AM.getResult<DominatorTreeAnalysis>(F).print(OS); return PreservedAnalyses::all(); } PreservedAnalyses DominatorTreeVerifierPass::run(Function &F, - FunctionAnalysisManager *AM) { - AM->getResult<DominatorTreeAnalysis>(F).verifyDomTree(); + FunctionAnalysisManager &AM) { + AM.getResult<DominatorTreeAnalysis>(F).verifyDomTree(); return PreservedAnalyses::all(); } diff --git a/llvm/lib/Transforms/IPO/FunctionAttrs.cpp b/llvm/lib/Transforms/IPO/FunctionAttrs.cpp index 1c38e183032..7885ec7d612 100644 --- a/llvm/lib/Transforms/IPO/FunctionAttrs.cpp +++ b/llvm/lib/Transforms/IPO/FunctionAttrs.cpp @@ -987,13 +987,13 @@ static bool addNoRecurseAttrs(const SCCNodeSet &SCCNodes) { return setDoesNotRecurse(*F); } -PreservedAnalyses -PostOrderFunctionAttrsPass::run(LazyCallGraph::SCC &C, CGSCCAnalysisManager *AM) { +PreservedAnalyses PostOrderFunctionAttrsPass::run(LazyCallGraph::SCC &C, + CGSCCAnalysisManager &AM) { Module &M = *C.begin()->getFunction().getParent(); const ModuleAnalysisManager &MAM = - AM->getResult<ModuleAnalysisManagerCGSCCProxy>(C).getManager(); + AM.getResult<ModuleAnalysisManagerCGSCCProxy>(C).getManager(); FunctionAnalysisManager &FAM = - AM->getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager(); + AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager(); // FIXME: Need some way to make it more reasonable to assume that this is // always cached. diff --git a/llvm/lib/Transforms/IPO/InferFunctionAttrs.cpp b/llvm/lib/Transforms/IPO/InferFunctionAttrs.cpp index 4295a7595c2..16922ab9256 100644 --- a/llvm/lib/Transforms/IPO/InferFunctionAttrs.cpp +++ b/llvm/lib/Transforms/IPO/InferFunctionAttrs.cpp @@ -945,8 +945,8 @@ static bool inferAllPrototypeAttributes(Module &M, } PreservedAnalyses InferFunctionAttrsPass::run(Module &M, - AnalysisManager<Module> *AM) { - auto &TLI = AM->getResult<TargetLibraryAnalysis>(M); + AnalysisManager<Module> &AM) { + auto &TLI = AM.getResult<TargetLibraryAnalysis>(M); if (!inferAllPrototypeAttributes(M, TLI)) // If we didn't infer anything, preserve all analyses. diff --git a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp index d728f1acc75..c6406e4f401 100644 --- a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp +++ b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp @@ -3082,12 +3082,12 @@ combineInstructionsOverFunction(Function &F, InstCombineWorklist &Worklist, } PreservedAnalyses InstCombinePass::run(Function &F, - AnalysisManager<Function> *AM) { - auto &AC = AM->getResult<AssumptionAnalysis>(F); - auto &DT = AM->getResult<DominatorTreeAnalysis>(F); - auto &TLI = AM->getResult<TargetLibraryAnalysis>(F); + AnalysisManager<Function> &AM) { + auto &AC = AM.getResult<AssumptionAnalysis>(F); + auto &DT = AM.getResult<DominatorTreeAnalysis>(F); + auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); - auto *LI = AM->getCachedResult<LoopAnalysis>(F); + auto *LI = AM.getCachedResult<LoopAnalysis>(F); // FIXME: The AliasAnalysis is not yet supported in the new pass manager if (!combineInstructionsOverFunction(F, Worklist, nullptr, AC, TLI, DT, diff --git a/llvm/lib/Transforms/Scalar/EarlyCSE.cpp b/llvm/lib/Transforms/Scalar/EarlyCSE.cpp index 133ee62553e..e5bbad9f73f 100644 --- a/llvm/lib/Transforms/Scalar/EarlyCSE.cpp +++ b/llvm/lib/Transforms/Scalar/EarlyCSE.cpp @@ -818,11 +818,11 @@ bool EarlyCSE::run() { } PreservedAnalyses EarlyCSEPass::run(Function &F, - AnalysisManager<Function> *AM) { - auto &TLI = AM->getResult<TargetLibraryAnalysis>(F); - auto &TTI = AM->getResult<TargetIRAnalysis>(F); - auto &DT = AM->getResult<DominatorTreeAnalysis>(F); - auto &AC = AM->getResult<AssumptionAnalysis>(F); + AnalysisManager<Function> &AM) { + auto &TLI = AM.getResult<TargetLibraryAnalysis>(F); + auto &TTI = AM.getResult<TargetIRAnalysis>(F); + auto &DT = AM.getResult<DominatorTreeAnalysis>(F); + auto &AC = AM.getResult<AssumptionAnalysis>(F); EarlyCSE CSE(TLI, TTI, DT, AC); diff --git a/llvm/lib/Transforms/Scalar/GVN.cpp b/llvm/lib/Transforms/Scalar/GVN.cpp index 4a3d7f40bc3..e117b6cd3f4 100644 --- a/llvm/lib/Transforms/Scalar/GVN.cpp +++ b/llvm/lib/Transforms/Scalar/GVN.cpp @@ -584,12 +584,12 @@ void GVN::ValueTable::verifyRemoved(const Value *V) const { // GVN Pass //===----------------------------------------------------------------------===// -PreservedAnalyses GVN::run(Function &F, AnalysisManager<Function> *AM) { - bool Changed = runImpl(F, AM->getResult<AssumptionAnalysis>(F), - AM->getResult<DominatorTreeAnalysis>(F), - AM->getResult<TargetLibraryAnalysis>(F), - AM->getResult<AAManager>(F), - &AM->getResult<MemoryDependenceAnalysis>(F)); +PreservedAnalyses GVN::run(Function &F, AnalysisManager<Function> &AM) { + bool Changed = runImpl(F, AM.getResult<AssumptionAnalysis>(F), + AM.getResult<DominatorTreeAnalysis>(F), + AM.getResult<TargetLibraryAnalysis>(F), + AM.getResult<AAManager>(F), + &AM.getResult<MemoryDependenceAnalysis>(F)); return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all(); } diff --git a/llvm/lib/Transforms/Scalar/SROA.cpp b/llvm/lib/Transforms/Scalar/SROA.cpp index 446c2d38c10..ffecaccc1f2 100644 --- a/llvm/lib/Transforms/Scalar/SROA.cpp +++ b/llvm/lib/Transforms/Scalar/SROA.cpp @@ -4241,9 +4241,9 @@ PreservedAnalyses SROA::runImpl(Function &F, DominatorTree &RunDT, return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all(); } -PreservedAnalyses SROA::run(Function &F, AnalysisManager<Function> *AM) { - return runImpl(F, AM->getResult<DominatorTreeAnalysis>(F), - AM->getResult<AssumptionAnalysis>(F)); +PreservedAnalyses SROA::run(Function &F, AnalysisManager<Function> &AM) { + return runImpl(F, AM.getResult<DominatorTreeAnalysis>(F), + AM.getResult<AssumptionAnalysis>(F)); } /// A legacy pass for the legacy pass manager that wraps the \c SROA pass. diff --git a/llvm/lib/Transforms/Scalar/SimplifyCFGPass.cpp b/llvm/lib/Transforms/Scalar/SimplifyCFGPass.cpp index 80f0fa39e21..687d388701e 100644 --- a/llvm/lib/Transforms/Scalar/SimplifyCFGPass.cpp +++ b/llvm/lib/Transforms/Scalar/SimplifyCFGPass.cpp @@ -178,9 +178,9 @@ SimplifyCFGPass::SimplifyCFGPass(int BonusInstThreshold) : BonusInstThreshold(BonusInstThreshold) {} PreservedAnalyses SimplifyCFGPass::run(Function &F, - AnalysisManager<Function> *AM) { - auto &TTI = AM->getResult<TargetIRAnalysis>(F); - auto &AC = AM->getResult<AssumptionAnalysis>(F); + AnalysisManager<Function> &AM) { + auto &TTI = AM.getResult<TargetIRAnalysis>(F); + auto &AC = AM.getResult<AssumptionAnalysis>(F); if (simplifyFunctionCFG(F, TTI, &AC, BonusInstThreshold)) return PreservedAnalyses::none(); diff --git a/llvm/tools/opt/NewPMDriver.cpp b/llvm/tools/opt/NewPMDriver.cpp index e0cc88bc33f..130474408bd 100644 --- a/llvm/tools/opt/NewPMDriver.cpp +++ b/llvm/tools/opt/NewPMDriver.cpp @@ -118,7 +118,7 @@ bool llvm::runPassPipeline(StringRef Arg0, LLVMContext &Context, Module &M, cl::PrintOptionValues(); // Now that we have all of the passes ready, run them. - MPM.run(M, &MAM); + MPM.run(M, MAM); // Declare success. if (OK != OK_NoOutput) diff --git a/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp b/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp index 8d219e29844..857c84d5016 100644 --- a/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp +++ b/llvm/unittests/Analysis/CGSCCPassManagerTest.cpp @@ -34,7 +34,7 @@ public: TestModuleAnalysis(int &Runs) : Runs(Runs) {} - Result run(Module &M, ModuleAnalysisManager *AM) { + Result run(Module &M, ModuleAnalysisManager &AM) { ++Runs; return Result(M.size()); } @@ -59,7 +59,7 @@ public: TestSCCAnalysis(int &Runs) : Runs(Runs) {} - Result run(LazyCallGraph::SCC &C, CGSCCAnalysisManager *AM) { + Result run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) { ++Runs; return Result(C.size()); } @@ -84,7 +84,7 @@ public: TestFunctionAnalysis(int &Runs) : Runs(Runs) {} - Result run(Function &F, FunctionAnalysisManager *AM) { + Result run(Function &F, FunctionAnalysisManager &AM) { ++Runs; int Count = 0; for (Instruction &I : instructions(F)) { @@ -113,7 +113,7 @@ public: TestImmutableFunctionAnalysis(int &Runs) : Runs(Runs) {} - Result run(Function &F, FunctionAnalysisManager *AM) { + Result run(Function &F, FunctionAnalysisManager &AM) { ++Runs; return Result(); } @@ -129,9 +129,9 @@ char TestImmutableFunctionAnalysis::PassID; struct TestModulePass { TestModulePass(int &RunCount) : RunCount(RunCount) {} - PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM) { + PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) { ++RunCount; - (void)AM->getResult<TestModuleAnalysis>(M); + (void)AM.getResult<TestModuleAnalysis>(M); return PreservedAnalyses::all(); } @@ -150,13 +150,13 @@ struct TestSCCPass { AnalyzedModuleFunctionCount(AnalyzedModuleFunctionCount), OnlyUseCachedResults(OnlyUseCachedResults) {} - PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager *AM) { + PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM) { ++RunCount; const ModuleAnalysisManager &MAM = - AM->getResult<ModuleAnalysisManagerCGSCCProxy>(C).getManager(); + AM.getResult<ModuleAnalysisManagerCGSCCProxy>(C).getManager(); FunctionAnalysisManager &FAM = - AM->getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager(); + AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C).getManager(); if (TestModuleAnalysis::Result *TMA = MAM.getCachedResult<TestModuleAnalysis>( *C.begin()->getFunction().getParent())) @@ -164,8 +164,7 @@ struct TestSCCPass { if (OnlyUseCachedResults) { // Hack to force the use of the cached interface. - if (TestSCCAnalysis::Result *AR = - AM->getCachedResult<TestSCCAnalysis>(C)) + if (TestSCCAnalysis::Result *AR = AM.getCachedResult<TestSCCAnalysis>(C)) AnalyzedSCCFunctionCount += AR->FunctionCount; for (LazyCallGraph::Node &N : C) if (TestFunctionAnalysis::Result *FAR = @@ -173,7 +172,7 @@ struct TestSCCPass { AnalyzedInstrCount += FAR->InstructionCount; } else { // Typical path just runs the analysis as needed. - TestSCCAnalysis::Result &AR = AM->getResult<TestSCCAnalysis>(C); + TestSCCAnalysis::Result &AR = AM.getResult<TestSCCAnalysis>(C); AnalyzedSCCFunctionCount += AR.FunctionCount; for (LazyCallGraph::Node &N : C) { TestFunctionAnalysis::Result &FAR = @@ -301,7 +300,7 @@ TEST_F(CGSCCPassManagerTest, Basic) { CGPM1.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM1))); MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM1))); - MPM.run(*M, &MAM); + MPM.run(*M, MAM); EXPECT_EQ(1, ModulePassRunCount1); diff --git a/llvm/unittests/Analysis/LoopPassManagerTest.cpp b/llvm/unittests/Analysis/LoopPassManagerTest.cpp index 9fb46cbae02..8a620499a3e 100644 --- a/llvm/unittests/Analysis/LoopPassManagerTest.cpp +++ b/llvm/unittests/Analysis/LoopPassManagerTest.cpp @@ -42,7 +42,7 @@ public: TestLoopAnalysis(int &Runs) : Runs(Runs) {} /// \brief Run the analysis pass over the loop and return a result. - Result run(Loop &L, AnalysisManager<Loop> *AM) { + Result run(Loop &L, AnalysisManager<Loop> &AM) { ++Runs; int Count = 0; @@ -65,16 +65,16 @@ public: : VisitedLoops(VisitedLoops), AnalyzedBlockCount(AnalyzedBlockCount), OnlyUseCachedResults(OnlyUseCachedResults) {} - PreservedAnalyses run(Loop &L, AnalysisManager<Loop> *AM) { + PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM) { VisitedLoops.push_back(L.getName()); if (OnlyUseCachedResults) { // Hack to force the use of the cached interface. - if (auto *AR = AM->getCachedResult<TestLoopAnalysis>(L)) + if (auto *AR = AM.getCachedResult<TestLoopAnalysis>(L)) AnalyzedBlockCount += AR->BlockCount; } else { // Typical path just runs the analysis as needed. - auto &AR = AM->getResult<TestLoopAnalysis>(L); + auto &AR = AM.getResult<TestLoopAnalysis>(L); AnalyzedBlockCount += AR.BlockCount; } @@ -91,7 +91,7 @@ class TestLoopInvalidatingPass { public: TestLoopInvalidatingPass(StringRef LoopName) : Name(LoopName) {} - PreservedAnalyses run(Loop &L, AnalysisManager<Loop> *AM) { + PreservedAnalyses run(Loop &L, AnalysisManager<Loop> &AM) { return L.getName() == Name ? PreservedAnalyses::none() : PreservedAnalyses::all(); } @@ -185,7 +185,7 @@ TEST_F(LoopPassManagerTest, Basic) { } MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); - MPM.run(*M, &MAM); + MPM.run(*M, MAM); StringRef ExpectedLoops[] = {"loop.0.0", "loop.0.1", "loop.0", "loop.g.0"}; diff --git a/llvm/unittests/IR/PassManagerTest.cpp b/llvm/unittests/IR/PassManagerTest.cpp index 68218cc6d59..15b29d9b896 100644 --- a/llvm/unittests/IR/PassManagerTest.cpp +++ b/llvm/unittests/IR/PassManagerTest.cpp @@ -29,7 +29,7 @@ public: TestFunctionAnalysis(int &Runs) : Runs(Runs) {} /// \brief Run the analysis pass over the function and return a result. - Result run(Function &F, FunctionAnalysisManager *AM) { + Result run(Function &F, FunctionAnalysisManager &AM) { ++Runs; int Count = 0; for (Function::iterator BBI = F.begin(), BBE = F.end(); BBI != BBE; ++BBI) @@ -57,7 +57,7 @@ public: TestModuleAnalysis(int &Runs) : Runs(Runs) {} - Result run(Module &M, ModuleAnalysisManager *AM) { + Result run(Module &M, ModuleAnalysisManager &AM) { ++Runs; int Count = 0; for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) @@ -91,11 +91,11 @@ struct TestPreservingModulePass : PassInfoMixin<TestPreservingModulePass> { struct TestMinPreservingModulePass : PassInfoMixin<TestMinPreservingModulePass> { - PreservedAnalyses run(Module &M, ModuleAnalysisManager *AM) { + PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) { PreservedAnalyses PA; // Force running an analysis. - (void)AM->getResult<TestModuleAnalysis>(M); + (void)AM.getResult<TestModuleAnalysis>(M); PA.preserve<FunctionAnalysisManagerModuleProxy>(); return PA; @@ -110,11 +110,11 @@ struct TestFunctionPass : PassInfoMixin<TestFunctionPass> { AnalyzedFunctionCount(AnalyzedFunctionCount), OnlyUseCachedResults(OnlyUseCachedResults) {} - PreservedAnalyses run(Function &F, FunctionAnalysisManager *AM) { + PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) { ++RunCount; const ModuleAnalysisManager &MAM = - AM->getResult<ModuleAnalysisManagerFunctionProxy>(F).getManager(); + AM.getResult<ModuleAnalysisManagerFunctionProxy>(F).getManager(); if (TestModuleAnalysis::Result *TMA = MAM.getCachedResult<TestModuleAnalysis>(*F.getParent())) AnalyzedFunctionCount += TMA->FunctionCount; @@ -122,11 +122,11 @@ struct TestFunctionPass : PassInfoMixin<TestFunctionPass> { if (OnlyUseCachedResults) { // Hack to force the use of the cached interface. if (TestFunctionAnalysis::Result *AR = - AM->getCachedResult<TestFunctionAnalysis>(F)) + AM.getCachedResult<TestFunctionAnalysis>(F)) AnalyzedInstrCount += AR->InstructionCount; } else { // Typical path just runs the analysis as needed. - TestFunctionAnalysis::Result &AR = AM->getResult<TestFunctionAnalysis>(F); + TestFunctionAnalysis::Result &AR = AM.getResult<TestFunctionAnalysis>(F); AnalyzedInstrCount += AR.InstructionCount; } @@ -298,7 +298,7 @@ TEST_F(PassManagerTest, Basic) { MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); } - MPM.run(*M, &MAM); + MPM.run(*M, MAM); // Validate module pass counters. EXPECT_EQ(1, ModulePassRunCount); |
