From d174ce4ad17b1965cefba7a7e5b97fe7235d7337 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Mon, 5 Jan 2015 02:47:05 +0000 Subject: [PM] Switch the new pass manager to use a reference-based API for IR units. This was debated back and forth a bunch, but using references is now clearly cleaner. Of all the code written using pointers thus far, in only one place did it really make more sense to have a pointer. In most cases, this just removes immediate dereferencing from the code. I think it is much better to get errors on null IR units earlier, potentially at compile time, than to delay it. Most notably, the legacy pass manager uses references for its routines and so as more and more code works with both, the use of pointers was likely to become really annoying. I noticed this when I ported the domtree analysis over and wrote the entire thing with references only to have it fail to compile. =/ It seemed better to switch now than to delay. We can, of course, revisit this is we learn that references are really problematic in the API. llvm-svn: 225145 --- llvm/lib/IR/PassManager.cpp | 46 ++++++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 23 deletions(-) (limited to 'llvm/lib/IR/PassManager.cpp') diff --git a/llvm/lib/IR/PassManager.cpp b/llvm/lib/IR/PassManager.cpp index 39270edc387..121ec001fd1 100644 --- a/llvm/lib/IR/PassManager.cpp +++ b/llvm/lib/IR/PassManager.cpp @@ -19,7 +19,7 @@ static cl::opt DebugPM("debug-pass-manager", cl::Hidden, cl::desc("Print pass management debugging information")); -PreservedAnalyses ModulePassManager::run(Module *M, ModuleAnalysisManager *AM) { +PreservedAnalyses ModulePassManager::run(Module &M, ModuleAnalysisManager *AM) { PreservedAnalyses PA = PreservedAnalyses::all(); if (DebugPM) @@ -34,7 +34,7 @@ PreservedAnalyses ModulePassManager::run(Module *M, ModuleAnalysisManager *AM) { AM->invalidate(M, PassPA); PA.intersect(std::move(PassPA)); - M->getContext().yield(); + M.getContext().yield(); } if (DebugPM) @@ -44,11 +44,11 @@ PreservedAnalyses ModulePassManager::run(Module *M, ModuleAnalysisManager *AM) { } ModuleAnalysisManager::ResultConceptT & -ModuleAnalysisManager::getResultImpl(void *PassID, Module *M) { +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. @@ -59,17 +59,17 @@ ModuleAnalysisManager::getResultImpl(void *PassID, Module *M) { } ModuleAnalysisManager::ResultConceptT * -ModuleAnalysisManager::getCachedResultImpl(void *PassID, Module *M) const { +ModuleAnalysisManager::getCachedResultImpl(void *PassID, Module &M) const { ModuleAnalysisResultMapT::const_iterator RI = ModuleAnalysisResults.find(PassID); return RI == ModuleAnalysisResults.end() ? nullptr : &*RI->second; } -void ModuleAnalysisManager::invalidateImpl(void *PassID, Module *M) { +void ModuleAnalysisManager::invalidateImpl(void *PassID, Module &M) { ModuleAnalysisResults.erase(PassID); } -void ModuleAnalysisManager::invalidateImpl(Module *M, +void ModuleAnalysisManager::invalidateImpl(Module &M, const PreservedAnalyses &PA) { // FIXME: This is a total hack based on the fact that erasure doesn't // invalidate iteration for DenseMap. @@ -80,7 +80,7 @@ void ModuleAnalysisManager::invalidateImpl(Module *M, ModuleAnalysisResults.erase(I); } -PreservedAnalyses FunctionPassManager::run(Function *F, +PreservedAnalyses FunctionPassManager::run(Function &F, FunctionAnalysisManager *AM) { PreservedAnalyses PA = PreservedAnalyses::all(); @@ -96,7 +96,7 @@ PreservedAnalyses FunctionPassManager::run(Function *F, AM->invalidate(F, PassPA); PA.intersect(std::move(PassPA)); - F->getContext().yield(); + F.getContext().yield(); } if (DebugPM) @@ -119,16 +119,16 @@ void FunctionAnalysisManager::clear() { } FunctionAnalysisManager::ResultConceptT & -FunctionAnalysisManager::getResultImpl(void *PassID, Function *F) { +FunctionAnalysisManager::getResultImpl(void *PassID, Function &F) { FunctionAnalysisResultMapT::iterator RI; bool Inserted; std::tie(RI, Inserted) = FunctionAnalysisResults.insert(std::make_pair( - std::make_pair(PassID, F), FunctionAnalysisResultListT::iterator())); + std::make_pair(PassID, &F), FunctionAnalysisResultListT::iterator())); // If we don't have a cached result for this function, look up the pass and // run it to produce a result, which we then add to the cache. if (Inserted) { - FunctionAnalysisResultListT &ResultList = FunctionAnalysisResultLists[F]; + FunctionAnalysisResultListT &ResultList = FunctionAnalysisResultLists[&F]; ResultList.emplace_back(PassID, lookupPass(PassID).run(F, this)); RI->second = std::prev(ResultList.end()); } @@ -137,27 +137,27 @@ FunctionAnalysisManager::getResultImpl(void *PassID, Function *F) { } FunctionAnalysisManager::ResultConceptT * -FunctionAnalysisManager::getCachedResultImpl(void *PassID, Function *F) const { +FunctionAnalysisManager::getCachedResultImpl(void *PassID, Function &F) const { FunctionAnalysisResultMapT::const_iterator RI = - FunctionAnalysisResults.find(std::make_pair(PassID, F)); + FunctionAnalysisResults.find(std::make_pair(PassID, &F)); return RI == FunctionAnalysisResults.end() ? nullptr : &*RI->second->second; } -void FunctionAnalysisManager::invalidateImpl(void *PassID, Function *F) { +void FunctionAnalysisManager::invalidateImpl(void *PassID, Function &F) { FunctionAnalysisResultMapT::iterator RI = - FunctionAnalysisResults.find(std::make_pair(PassID, F)); + FunctionAnalysisResults.find(std::make_pair(PassID, &F)); if (RI == FunctionAnalysisResults.end()) return; - FunctionAnalysisResultLists[F].erase(RI->second); + FunctionAnalysisResultLists[&F].erase(RI->second); } -void FunctionAnalysisManager::invalidateImpl(Function *F, +void FunctionAnalysisManager::invalidateImpl(Function &F, const PreservedAnalyses &PA) { // Clear all the invalidated results associated specifically with this // function. SmallVector InvalidatedPassIDs; - FunctionAnalysisResultListT &ResultsList = FunctionAnalysisResultLists[F]; + FunctionAnalysisResultListT &ResultsList = FunctionAnalysisResultLists[&F]; for (FunctionAnalysisResultListT::iterator I = ResultsList.begin(), E = ResultsList.end(); I != E;) @@ -169,15 +169,15 @@ void FunctionAnalysisManager::invalidateImpl(Function *F, } while (!InvalidatedPassIDs.empty()) FunctionAnalysisResults.erase( - std::make_pair(InvalidatedPassIDs.pop_back_val(), F)); + std::make_pair(InvalidatedPassIDs.pop_back_val(), &F)); if (ResultsList.empty()) - FunctionAnalysisResultLists.erase(F); + FunctionAnalysisResultLists.erase(&F); } char FunctionAnalysisManagerModuleProxy::PassID; FunctionAnalysisManagerModuleProxy::Result -FunctionAnalysisManagerModuleProxy::run(Module *M) { +FunctionAnalysisManagerModuleProxy::run(Module &M) { assert(FAM->empty() && "Function analyses ran prior to the module proxy!"); return Result(*FAM); } @@ -189,7 +189,7 @@ FunctionAnalysisManagerModuleProxy::Result::~Result() { } bool FunctionAnalysisManagerModuleProxy::Result::invalidate( - Module *M, const PreservedAnalyses &PA) { + Module &M, const PreservedAnalyses &PA) { // If this proxy isn't marked as preserved, then we can't even invalidate // individual function analyses, there may be an invalid set of Function // objects in the cache making it impossible to incrementally preserve them. -- cgit v1.2.3