From b8824a5d3f2f8d7a687520c4db641c4d53dc02a5 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Fri, 19 Aug 2016 10:51:55 +0000 Subject: [PATCH] [PM] Revert r279227 and r279228 until I can find someone to help me solve completely opaque MSVC build errors. It complains about lots of stuff with this change without givin nearly enough information to even try to fix. llvm-svn: 279231 --- llvm/include/llvm/IR/IRPrintingPasses.h | 2 +- llvm/include/llvm/IR/PassManager.h | 91 ++++++++++-------------------- llvm/include/llvm/IR/PassManagerInternal.h | 37 +++++------- llvm/lib/Passes/PassBuilder.cpp | 15 ++--- llvm/unittests/IR/PassManagerTest.cpp | 57 ------------------- 5 files changed, 51 insertions(+), 151 deletions(-) diff --git a/llvm/include/llvm/IR/IRPrintingPasses.h b/llvm/include/llvm/IR/IRPrintingPasses.h index 0825e06..bc6de19 100644 --- a/llvm/include/llvm/IR/IRPrintingPasses.h +++ b/llvm/include/llvm/IR/IRPrintingPasses.h @@ -30,7 +30,7 @@ class Module; class ModulePass; class PreservedAnalyses; class raw_ostream; -template class AnalysisManager; +template class AnalysisManager; /// \brief Create and return a pass that writes the module to the specified /// \c raw_ostream. diff --git a/llvm/include/llvm/IR/PassManager.h b/llvm/include/llvm/IR/PassManager.h index 3c72b0b..e2d4d99 100644 --- a/llvm/include/llvm/IR/PassManager.h +++ b/llvm/include/llvm/IR/PassManager.h @@ -171,7 +171,7 @@ private: }; // Forward declare the analysis manager template. -template class AnalysisManager; +template class AnalysisManager; /// A CRTP mix-in to automatically provide informational APIs needed for /// passes. @@ -222,11 +222,8 @@ struct AnalysisInfoMixin : PassInfoMixin { /// that analysis manager to each pass it runs, as well as calling the analysis /// manager's invalidation routine with the PreservedAnalyses of each pass it /// runs. -template , - typename... ExtraArgTs> -class PassManager : public PassInfoMixin< - PassManager> { +template +class PassManager : public PassInfoMixin> { public: /// \brief Construct a pass manager. /// @@ -244,8 +241,7 @@ public: } /// \brief Run all of the passes in this manager over the IR. - PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, - ExtraArgTs... ExtraArgs) { + PreservedAnalyses run(IRUnitT &IR, AnalysisManager &AM) { PreservedAnalyses PA = PreservedAnalyses::all(); if (DebugLogging) @@ -256,7 +252,7 @@ public: dbgs() << "Running pass: " << Passes[Idx]->name() << " on " << IR.getName() << "\n"; - PreservedAnalyses PassPA = Passes[Idx]->run(IR, AM, ExtraArgs...); + PreservedAnalyses PassPA = Passes[Idx]->run(IR, AM); // Update the analysis manager as each pass runs and potentially // invalidates analyses. We also update the preserved set of analyses @@ -282,15 +278,12 @@ public: } template void addPass(PassT Pass) { - typedef detail::PassModel - PassModelT; + typedef detail::PassModel PassModelT; Passes.emplace_back(new PassModelT(std::move(Pass))); } private: - typedef detail::PassConcept - PassConceptT; + typedef detail::PassConcept PassConceptT; PassManager(const PassManager &) = delete; PassManager &operator=(const PassManager &) = delete; @@ -315,10 +308,10 @@ typedef PassManager FunctionPassManager; /// This analysis manager can be used for any IR unit where the address of the /// IR unit sufficies as its identity. It manages the cache for a unit of IR via /// the address of each unit of IR cached. -template +template class AnalysisManager { typedef detail::AnalysisResultConcept ResultConceptT; - typedef detail::AnalysisPassConcept PassConceptT; + typedef detail::AnalysisPassConcept PassConceptT; public: // Most public APIs are inherited from the CRTP base class. @@ -365,11 +358,11 @@ 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, ExtraArgTs... ExtraArgs) { + template typename PassT::Result &getResult(IRUnitT &IR) { assert(AnalysisPasses.count(PassT::ID()) && "This analysis pass was not registered prior to being queried"); - ResultConceptT &ResultConcept = getResultImpl(PassT::ID(), IR, ExtraArgs...); + + ResultConceptT &ResultConcept = getResultImpl(PassT::ID(), IR); typedef detail::AnalysisResultModel ResultModelT; return static_cast(ResultConcept).Result; @@ -414,7 +407,7 @@ public: /// away. template bool registerPass(PassBuilderT PassBuilder) { typedef decltype(PassBuilder()) PassT; - typedef detail::AnalysisPassModel PassModelT; + typedef detail::AnalysisPassModel PassModelT; auto &PassPtr = AnalysisPasses[PassT::ID()]; if (PassPtr) @@ -509,8 +502,7 @@ private: } /// \brief Get an analysis result, running the pass if necessary. - ResultConceptT &getResultImpl(void *PassID, IRUnitT &IR, - ExtraArgTs... ExtraArgs) { + ResultConceptT &getResultImpl(void *PassID, IRUnitT &IR) { typename AnalysisResultMapT::iterator RI; bool Inserted; std::tie(RI, Inserted) = AnalysisResults.insert(std::make_pair( @@ -523,7 +515,7 @@ private: if (DebugLogging) dbgs() << "Running analysis: " << P.name() << "\n"; AnalysisResultListT &ResultList = AnalysisResultLists[&IR]; - ResultList.emplace_back(PassID, P.run(IR, *this, ExtraArgs...)); + ResultList.emplace_back(PassID, P.run(IR, *this)); // P.run may have inserted elements into AnalysisResults and invalidated // RI. @@ -615,7 +607,7 @@ typedef AnalysisManager FunctionAnalysisManager; /// Note that the proxy's result is a move-only object and represents ownership /// of the validity of the analyses in the \c FunctionAnalysisManager it /// provides. -template +template class InnerAnalysisManagerProxy : public AnalysisInfoMixin< InnerAnalysisManagerProxy> { @@ -697,10 +689,7 @@ public: /// In debug builds, it will also assert that the analysis manager is empty /// as no queries should arrive at the function analysis manager prior to /// this analysis being requested. - Result run(IRUnitT &IR, AnalysisManager &, - ExtraArgTs...) { - return Result(*AM); - } + Result run(IRUnitT &IR, AnalysisManager &) { return Result(*AM); } private: friend AnalysisInfoMixin< @@ -710,9 +699,8 @@ private: AnalysisManagerT *AM; }; -template -char - InnerAnalysisManagerProxy::PassID; +template +char InnerAnalysisManagerProxy::PassID; extern template class InnerAnalysisManagerProxy; @@ -732,7 +720,7 @@ typedef InnerAnalysisManagerProxy /// This proxy *doesn't* manage the invalidation in any way. That is handled by /// the recursive return path of each layer of the pass manager and the /// returned PreservedAnalysis set. -template +template class OuterAnalysisManagerProxy : public AnalysisInfoMixin< OuterAnalysisManagerProxy> { @@ -774,10 +762,7 @@ public: /// \brief Run the analysis pass and create our proxy result object. /// Nothing to see here, it just forwards the \c AM reference into the /// result. - Result run(IRUnitT &, AnalysisManager &, - ExtraArgTs...) { - return Result(*AM); - } + Result run(IRUnitT &, AnalysisManager &) { return Result(*AM); } private: friend AnalysisInfoMixin< @@ -787,9 +772,8 @@ private: const AnalysisManagerT *AM; }; -template -char - OuterAnalysisManagerProxy::PassID; +template +char OuterAnalysisManagerProxy::PassID; extern template class OuterAnalysisManagerProxy; @@ -890,30 +874,15 @@ createModuleToFunctionPassAdaptor(FunctionPassT Pass) { /// /// This is a no-op pass which simply forces a specific analysis pass's result /// to be available when it is run. -template , - typename... ExtraArgTs> -struct RequireAnalysisPass; - -/// A specialization of the RequireAnalysisPass for generic IR unit analysis -/// managers and pass managers that have no extra arguments. -/// -/// If there are extra arguments at the pass's run level there may also be -/// extra arguments to the analysis manager's \c getResult routine. We can't -/// guess how to effectively map the arguments from one to the other, and so -/// only the specialization with no extra arguments is provided generically. -/// Specific patterns of run-method extra arguments and analysis manager extra -/// arguments will have to be defined as appropriate for those patterns. -template -struct RequireAnalysisPass> - : PassInfoMixin< - RequireAnalysisPass>> { +template +struct RequireAnalysisPass : PassInfoMixin> { /// \brief Run this pass over some unit of IR. /// /// This pass can be run over any unit of IR and use any analysis manager /// 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(IRUnitT &Arg, AnalysisManager &AM) { (void)AM.template getResult(Arg); @@ -935,8 +904,8 @@ 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(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...) { + template + PreservedAnalyses run(IRUnitT &Arg, AnalysisManager &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(Arg); @@ -951,8 +920,8 @@ struct InvalidateAnalysisPass /// analysis passes to be re-run to produce fresh results if any are needed. struct InvalidateAllAnalysesPass : PassInfoMixin { /// \brief Run this pass over some unit of IR. - template - PreservedAnalyses run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) { + template + PreservedAnalyses run(IRUnitT &, AnalysisManager &) { return PreservedAnalyses::none(); } }; diff --git a/llvm/include/llvm/IR/PassManagerInternal.h b/llvm/include/llvm/IR/PassManagerInternal.h index dcc0a1c..2ffd552 100644 --- a/llvm/include/llvm/IR/PassManagerInternal.h +++ b/llvm/include/llvm/IR/PassManagerInternal.h @@ -23,7 +23,7 @@ namespace llvm { -template class AnalysisManager; +template class AnalysisManager; class PreservedAnalyses; /// \brief Implementation details of the pass manager interfaces. @@ -31,18 +31,12 @@ namespace detail { /// \brief Template for the abstract base class used to dispatch /// polymorphically over pass objects. -template -struct PassConcept { +template struct PassConcept { // Boiler plate necessary for the container of derived classes. virtual ~PassConcept() {} /// \brief The polymorphic API which runs the pass over a given IR entity. - /// - /// 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, - ExtraArgTs... ExtraArgs) = 0; + virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManager &AM) = 0; /// \brief Polymorphic method to access the name of a pass. virtual StringRef name() = 0; @@ -53,9 +47,9 @@ struct PassConcept { /// Can be instantiated for any object which provides a \c run method accepting /// an \c IRUnitT& and an \c AnalysisManager&. It requires the pass to /// be a copyable object. -template -struct PassModel : PassConcept { +template +struct PassModel : PassConcept { explicit PassModel(PassT Pass) : Pass(std::move(Pass)) {} // We have to explicitly define all the special member functions because MSVC // refuses to generate them. @@ -70,9 +64,8 @@ struct PassModel : PassConcept { return *this; } - PreservedAnalysesT run(IRUnitT &IR, AnalysisManagerT &AM, - ExtraArgTs... ExtraArgs) override { - return Pass.run(IR, AM, ExtraArgs...); + PreservedAnalysesT run(IRUnitT &IR, AnalysisManager &AM) override { + return Pass.run(IR, AM); } StringRef name() override { return PassT::name(); } PassT Pass; @@ -212,15 +205,14 @@ struct AnalysisResultModel /// /// This concept is parameterized over the IR unit that it can run over and /// produce an analysis result. -template struct AnalysisPassConcept { +template struct AnalysisPassConcept { virtual ~AnalysisPassConcept() {} /// \brief Method to run this analysis over a unit of IR. /// \returns A unique_ptr to the analysis result object to be queried by /// users. virtual std::unique_ptr> - run(IRUnitT &IR, AnalysisManager &AM, - ExtraArgTs... ExtraArgs) = 0; + run(IRUnitT &IR, AnalysisManager &AM) = 0; /// \brief Polymorphic method to access the name of a pass. virtual StringRef name() = 0; @@ -231,8 +223,8 @@ template struct AnalysisPassConcept { /// Can wrap any type which implements a suitable \c run method. The method /// must accept an \c IRUnitT& and an \c AnalysisManager& as arguments /// and produce an object which can be wrapped in a \c AnalysisResultModel. -template -struct AnalysisPassModel : AnalysisPassConcept { +template +struct AnalysisPassModel : AnalysisPassConcept { explicit AnalysisPassModel(PassT Pass) : Pass(std::move(Pass)) {} // We have to explicitly define all the special member functions because MSVC // refuses to generate them. @@ -255,9 +247,8 @@ struct AnalysisPassModel : AnalysisPassConcept { /// /// The return is wrapped in an \c AnalysisResultModel. std::unique_ptr> - run(IRUnitT &IR, AnalysisManager &AM, - ExtraArgTs... ExtraArgs) override { - return make_unique(Pass.run(IR, AM, ExtraArgs...)); + run(IRUnitT &IR, AnalysisManager &AM) override { + return make_unique(Pass.run(IR, AM)); } /// \brief The model delegates to a static \c PassT::name method. diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp index df47026..cdbc2a2 100644 --- a/llvm/lib/Passes/PassBuilder.cpp +++ b/llvm/lib/Passes/PassBuilder.cpp @@ -516,9 +516,8 @@ bool PassBuilder::parseModulePass(ModulePassManager &MPM, } #define MODULE_ANALYSIS(NAME, CREATE_PASS) \ if (Name == "require<" NAME ">") { \ - MPM.addPass( \ - RequireAnalysisPass< \ - std::remove_reference::type, Module>()); \ + MPM.addPass(RequireAnalysisPass< \ + std::remove_reference::type>()); \ return true; \ } \ if (Name == "invalidate<" NAME ">") { \ @@ -579,8 +578,7 @@ bool PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM, #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \ if (Name == "require<" NAME ">") { \ CGPM.addPass(RequireAnalysisPass< \ - std::remove_reference::type, \ - LazyCallGraph::SCC>()); \ + std::remove_reference::type>()); \ return true; \ } \ if (Name == "invalidate<" NAME ">") { \ @@ -639,9 +637,8 @@ bool PassBuilder::parseFunctionPass(FunctionPassManager &FPM, } #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \ if (Name == "require<" NAME ">") { \ - FPM.addPass( \ - RequireAnalysisPass< \ - std::remove_reference::type, Function>()); \ + FPM.addPass(RequireAnalysisPass< \ + std::remove_reference::type>()); \ return true; \ } \ if (Name == "invalidate<" NAME ">") { \ @@ -691,7 +688,7 @@ bool PassBuilder::parseLoopPass(LoopPassManager &LPM, const PipelineElement &E, #define LOOP_ANALYSIS(NAME, CREATE_PASS) \ if (Name == "require<" NAME ">") { \ LPM.addPass(RequireAnalysisPass< \ - std::remove_reference::type, Loop>()); \ + std::remove_reference::type>()); \ return true; \ } \ if (Name == "invalidate<" NAME ">") { \ diff --git a/llvm/unittests/IR/PassManagerTest.cpp b/llvm/unittests/IR/PassManagerTest.cpp index 47fb8b7..c2ac863 100644 --- a/llvm/unittests/IR/PassManagerTest.cpp +++ b/llvm/unittests/IR/PassManagerTest.cpp @@ -331,61 +331,4 @@ TEST_F(PassManagerTest, Basic) { EXPECT_EQ(1, ModuleAnalysisRuns); } - -// A customized pass manager that passes extra arguments through the -// infrastructure. -typedef AnalysisManager CustomizedAnalysisManager; -typedef PassManager - CustomizedPassManager; - -class CustomizedAnalysis : public AnalysisInfoMixin { -public: - struct Result { - Result(int I) : I(I) {} - int I; - }; - - Result run(Function &F, CustomizedAnalysisManager &AM, int I) { - return Result(I); - } - -private: - friend AnalysisInfoMixin; - static char PassID; -}; - -char CustomizedAnalysis::PassID; - -struct CustomizedPass : PassInfoMixin { - std::function Callback; - - template - CustomizedPass(CallbackT Callback) : Callback(Callback) {} - - PreservedAnalyses run(Function &F, CustomizedAnalysisManager &AM, int I, - int &O) { - Callback(AM.getResult(F, I), O); - return PreservedAnalyses::none(); - } -}; - -TEST_F(PassManagerTest, CustomizedPassManagerArgs) { - CustomizedAnalysisManager AM; - AM.registerPass([&] { return CustomizedAnalysis(); }); - - CustomizedPassManager PM; - - // Add an instance of the customized pass that just accumulates the input - // after it is round-tripped through the analysis. - int Result = 0; - PM.addPass( - CustomizedPass([](CustomizedAnalysis::Result &R, int &O) { O += R.I; })); - - // Run this over every function with the input of 42. - for (Function &F : *M) - PM.run(F, AM, 42, Result); - - // And ensure that we accumulated the correct result. - EXPECT_EQ(42 * (int)M->size(), Result); -} } -- 2.7.4