From 21c4458d3c3fd59ea9f8dc91d8eb05a0c1795965 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Mon, 12 Jan 2015 22:53:31 +0000 Subject: [PATCH] [PM] Sink the reference vs. value decision for IR units out of the templated interface. So far, every single IR unit I can come up with has address-identity. That is, when two units of IR are both active in LLVM, their addresses will be distinct of the IR is distinct. This is clearly true for Modules, Functions, BasicBlocks, and Instructions. It turns out that the only practical way to make the CGSCC stuff work the way we want is to make it true for SCCs as well. I expect this pattern to continue. When first designing the pass manager code, I kept this dimension of freedom in the type parameters, essentially allowing for a wrapper-type whose address did not form identity. But that really no longer makes sense and is making the code more complex or subtle for no gain. If we ever have an actual use case for this, we can figure out what makes sense then and there. It will be better because then we will have the actual example in hand. While the simplifications afforded in this patch are fairly small (mostly sinking the '&' out of many type parameters onto a few interfaces), it would have become much more pronounced with subsequent changes. I have a sequence of changes that will completely remove the code duplication that currently exists between all of the pass managers and analysis managers. =] Should make things much cleaner and avoid bug fixing N times for the N pass managers. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@225723 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/CGSCCPassManager.h | 14 +++++----- include/llvm/IR/PassManager.h | 48 ++++++++++++++++---------------- include/llvm/IR/PassManagerInternal.h | 22 +++++++-------- lib/IR/PassManager.cpp | 2 +- 4 files changed, 43 insertions(+), 43 deletions(-) diff --git a/include/llvm/Analysis/CGSCCPassManager.h b/include/llvm/Analysis/CGSCCPassManager.h index c497a81d55d..ed2289ce99a 100644 --- a/include/llvm/Analysis/CGSCCPassManager.h +++ b/include/llvm/Analysis/CGSCCPassManager.h @@ -51,13 +51,13 @@ public: private: // Pull in the concept type and model template specialized for SCCs. - typedef detail::PassConcept + typedef detail::PassConcept CGSCCPassConcept; template struct CGSCCPassModel - : detail::PassModel { + : detail::PassModel { CGSCCPassModel(PassT Pass) - : detail::PassModel( + : detail::PassModel( std::move(Pass)) {} }; @@ -70,11 +70,11 @@ private: /// \brief A function analysis manager to coordinate and cache analyses run over /// a module. class CGSCCAnalysisManager : public detail::AnalysisManagerBase< - CGSCCAnalysisManager, LazyCallGraph::SCC &> { + CGSCCAnalysisManager, LazyCallGraph::SCC> { friend class detail::AnalysisManagerBase; + LazyCallGraph::SCC>; typedef detail::AnalysisManagerBase BaseT; + LazyCallGraph::SCC> BaseT; typedef BaseT::ResultConceptT ResultConceptT; typedef BaseT::PassConceptT PassConceptT; @@ -129,7 +129,7 @@ private: /// half of a bijection and provides storage for the actual result concept. typedef std::list< std::pair>>> CGSCCAnalysisResultListT; + LazyCallGraph::SCC>>>> CGSCCAnalysisResultListT; /// \brief Map type from function pointer to our custom list type. typedef DenseMap diff --git a/include/llvm/IR/PassManager.h b/include/llvm/IR/PassManager.h index 369228ed7fb..8f82697ac2d 100644 --- a/include/llvm/IR/PassManager.h +++ b/include/llvm/IR/PassManager.h @@ -203,13 +203,13 @@ public: private: // Pull in the concept type and model template specialized for modules. - typedef detail::PassConcept + typedef detail::PassConcept ModulePassConcept; template struct ModulePassModel - : detail::PassModel { + : detail::PassModel { ModulePassModel(PassT Pass) - : detail::PassModel( + : detail::PassModel( std::move(Pass)) {} }; @@ -268,13 +268,13 @@ public: private: // Pull in the concept type and model template specialized for functions. - typedef detail::PassConcept + typedef detail::PassConcept FunctionPassConcept; template struct FunctionPassModel - : detail::PassModel { + : detail::PassModel { FunctionPassModel(PassT Pass) - : detail::PassModel( + : detail::PassModel( std::move(Pass)) {} }; @@ -330,7 +330,7 @@ public: /// /// If there is not a valid cached result in the manager already, this will /// re-run the analysis to produce a valid result. - template typename PassT::Result &getResult(IRUnitT IR) { + template typename PassT::Result &getResult(IRUnitT &IR) { assert(AnalysisPasses.count(PassT::ID()) && "This analysis pass was not registered prior to being queried"); @@ -347,7 +347,7 @@ public: /// /// \returns null if there is no cached result. template - typename PassT::Result *getCachedResult(IRUnitT IR) const { + typename PassT::Result *getCachedResult(IRUnitT &IR) const { assert(AnalysisPasses.count(PassT::ID()) && "This analysis pass was not registered prior to being queried"); @@ -376,7 +376,7 @@ public: /// \brief Invalidate a specific analysis pass for an IR module. /// /// Note that the analysis result can disregard invalidation. - template void invalidate(IRUnitT IR) { + template void invalidate(IRUnitT &IR) { assert(AnalysisPasses.count(PassT::ID()) && "This analysis pass was not registered prior to being invalidated"); derived_this()->invalidateImpl(PassT::ID(), IR); @@ -389,7 +389,7 @@ public: /// We accept the PreservedAnalyses set by value and update it with each /// analyis pass which has been successfully invalidated and thus can be /// preserved going forward. The updated set is returned. - PreservedAnalyses invalidate(IRUnitT IR, PreservedAnalyses PA) { + PreservedAnalyses invalidate(IRUnitT &IR, PreservedAnalyses PA) { return derived_this()->invalidateImpl(IR, std::move(PA)); } @@ -423,9 +423,9 @@ private: /// \brief A module analysis pass manager with lazy running and caching of /// results. class ModuleAnalysisManager - : public detail::AnalysisManagerBase { - friend class detail::AnalysisManagerBase; - typedef detail::AnalysisManagerBase BaseT; + : public detail::AnalysisManagerBase { + friend class detail::AnalysisManagerBase; + typedef detail::AnalysisManagerBase BaseT; typedef BaseT::ResultConceptT ResultConceptT; typedef BaseT::PassConceptT PassConceptT; @@ -462,7 +462,7 @@ private: /// \brief Map type from module analysis pass ID to pass result concept /// pointer. typedef DenseMap>> + std::unique_ptr>> ModuleAnalysisResultMapT; /// \brief Cache of computed module analysis results for this module. @@ -472,9 +472,9 @@ private: /// \brief A function analysis manager to coordinate and cache analyses run over /// a module. class FunctionAnalysisManager - : public detail::AnalysisManagerBase { - friend class detail::AnalysisManagerBase; - typedef detail::AnalysisManagerBase + : public detail::AnalysisManagerBase { + friend class detail::AnalysisManagerBase; + typedef detail::AnalysisManagerBase BaseT; typedef BaseT::ResultConceptT ResultConceptT; typedef BaseT::PassConceptT PassConceptT; @@ -529,7 +529,7 @@ private: /// erases. Provides both the pass ID and concept pointer such that it is /// half of a bijection and provides storage for the actual result concept. typedef std::list>>> + void *, std::unique_ptr>>> FunctionAnalysisResultListT; /// \brief Map type from function pointer to our custom list type. @@ -788,10 +788,10 @@ template struct RequireAnalysisPass { /// provided they satisfy the basic API requirements. When this pass is /// created, these methods can be instantiated to satisfy whatever the /// context requires. - template - PreservedAnalyses run(T &&Arg, AnalysisManagerT *AM) { + template + PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT *AM) { if (AM) - (void)AM->template getResult(std::forward(Arg)); + (void)AM->template getResult(Arg); return PreservedAnalyses::all(); } @@ -811,12 +811,12 @@ template struct InvalidateAnalysisPass { /// provided they satisfy the basic API requirements. When this pass is /// created, these methods can be instantiated to satisfy whatever the /// context requires. - template - PreservedAnalyses run(T &&Arg, AnalysisManagerT *AM) { + template + PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT *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(std::forward(Arg)); + (void)AM->template invalidate(Arg); return PreservedAnalyses::all(); } diff --git a/include/llvm/IR/PassManagerInternal.h b/include/llvm/IR/PassManagerInternal.h index 1b43a72c408..0d0f178c95c 100644 --- a/include/llvm/IR/PassManagerInternal.h +++ b/include/llvm/IR/PassManagerInternal.h @@ -40,7 +40,7 @@ template 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, AnalysisManagerT *AM) = 0; + virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT *AM) = 0; /// \brief Polymorphic method to access the name of a pass. virtual StringRef name() = 0; @@ -56,7 +56,7 @@ class PassRunAcceptsAnalysisManager { char a, b; }; - template + template struct Checker; template static SmallType f(Checker *); @@ -97,7 +97,7 @@ struct PassModel return *this; } - PreservedAnalysesT run(IRUnitT IR, AnalysisManagerT *AM) override { + PreservedAnalysesT run(IRUnitT &IR, AnalysisManagerT *AM) override { return Pass.run(IR, AM); } StringRef name() override { return PassT::name(); } @@ -124,7 +124,7 @@ struct PassModel return *this; } - PreservedAnalysesT run(IRUnitT IR, AnalysisManagerT *AM) override { + PreservedAnalysesT run(IRUnitT &IR, AnalysisManagerT *AM) override { return Pass.run(IR); } StringRef name() override { return PassT::name(); } @@ -148,7 +148,7 @@ template struct AnalysisResultConcept { /// took care to update or preserve the analysis result in some way. /// /// \returns true if the result is indeed invalid (the default). - virtual bool invalidate(IRUnitT IR, const PreservedAnalyses &PA) = 0; + virtual bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA) = 0; }; /// \brief SFINAE metafunction for computing whether \c ResultT provides an @@ -159,7 +159,7 @@ template class ResultHasInvalidateMethod { char a, b; }; - template + template struct Checker; template static SmallType f(Checker *); @@ -207,7 +207,7 @@ struct AnalysisResultModel // FIXME: We should actually use two different concepts for analysis results // rather than two different models, and avoid the indirect function call for // ones that use the trivial behavior. - bool invalidate(IRUnitT, const PreservedAnalysesT &PA) override { + bool invalidate(IRUnitT &, const PreservedAnalysesT &PA) override { return !PA.preserved(PassT::ID()); } @@ -236,7 +236,7 @@ struct AnalysisResultModel } /// \brief The model delegates to the \c ResultT method. - bool invalidate(IRUnitT IR, const PreservedAnalysesT &PA) override { + bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA) override { return Result.invalidate(IR, PA); } @@ -255,7 +255,7 @@ struct AnalysisPassConcept { /// \returns A unique_ptr to the analysis result object to be queried by /// users. virtual std::unique_ptr> - run(IRUnitT IR, AnalysisManagerT *AM) = 0; + run(IRUnitT &IR, AnalysisManagerT *AM) = 0; /// \brief Polymorphic method to access the name of a pass. virtual StringRef name() = 0; @@ -298,7 +298,7 @@ struct AnalysisPassModel /// /// The return is wrapped in an \c AnalysisResultModel. std::unique_ptr> - run(IRUnitT IR, AnalysisManagerT *AM) override { + run(IRUnitT &IR, AnalysisManagerT *AM) override { return make_unique(Pass.run(IR, AM)); } @@ -337,7 +337,7 @@ struct AnalysisPassModel /// /// The return is wrapped in an \c AnalysisResultModel. std::unique_ptr> - run(IRUnitT IR, AnalysisManagerT *) override { + run(IRUnitT &IR, AnalysisManagerT *) override { return make_unique(Pass.run(IR)); } diff --git a/lib/IR/PassManager.cpp b/lib/IR/PassManager.cpp index 99cee507e65..907baeabeea 100644 --- a/lib/IR/PassManager.cpp +++ b/lib/IR/PassManager.cpp @@ -57,7 +57,7 @@ ModuleAnalysisManager::getResultImpl(void *PassID, Module &M) { ModuleAnalysisResultMapT::iterator RI; bool Inserted; std::tie(RI, Inserted) = ModuleAnalysisResults.insert(std::make_pair( - PassID, std::unique_ptr>())); + PassID, std::unique_ptr>())); // If we don't have a cached result for this module, look up the pass and run // it to produce a result, which we then add to the cache. -- 2.11.0