6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-26 23:24:34 +00:00
Code Issues Projects Releases Wiki Activity

[PM] Switch the new pass manager to use a reference-based API for IR

Browse Source 
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.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@225145 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chandler Carruth
2015-01-05 02:47:05 +00:00
parent 51fa09d980
commit b246acebf4
15 changed files with 140 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
lib/Analysis/CGSCCPassManager.cpp
View File

@ -17,7 +17,7 @@ static cl::opt<bool>
DebugPM("debug-cgscc-pass-manager", cl::Hidden,
cl::desc("Print CGSCC pass management debugging information"));
PreservedAnalyses CGSCCPassManager::run(LazyCallGraph::SCC *C,
PreservedAnalyses CGSCCPassManager::run(LazyCallGraph::SCC &C,
CGSCCAnalysisManager *AM) {
PreservedAnalyses PA = PreservedAnalyses::all();
@ -53,16 +53,16 @@ void CGSCCAnalysisManager::clear() {
}
CGSCCAnalysisManager::ResultConceptT &
CGSCCAnalysisManager::getResultImpl(void *PassID, LazyCallGraph::SCC *C) {
CGSCCAnalysisManager::getResultImpl(void *PassID, LazyCallGraph::SCC &C) {
CGSCCAnalysisResultMapT::iterator RI;
bool Inserted;
std::tie(RI, Inserted) = CGSCCAnalysisResults.insert(std::make_pair(
std::make_pair(PassID, C), CGSCCAnalysisResultListT::iterator()));
std::make_pair(PassID, &C), CGSCCAnalysisResultListT::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) {
CGSCCAnalysisResultListT &ResultList = CGSCCAnalysisResultLists[C];
CGSCCAnalysisResultListT &ResultList = CGSCCAnalysisResultLists[&C];
ResultList.emplace_back(PassID, lookupPass(PassID).run(C, this));
RI->second = std::prev(ResultList.end());
}
@ -72,27 +72,27 @@ CGSCCAnalysisManager::getResultImpl(void *PassID, LazyCallGraph::SCC *C) {
CGSCCAnalysisManager::ResultConceptT *
CGSCCAnalysisManager::getCachedResultImpl(void *PassID,
LazyCallGraph::SCC *C) const {
LazyCallGraph::SCC &C) const {
CGSCCAnalysisResultMapT::const_iterator RI =
CGSCCAnalysisResults.find(std::make_pair(PassID, C));
CGSCCAnalysisResults.find(std::make_pair(PassID, &C));
return RI == CGSCCAnalysisResults.end() ? nullptr : &*RI->second->second;
}
void CGSCCAnalysisManager::invalidateImpl(void *PassID, LazyCallGraph::SCC *C) {
void CGSCCAnalysisManager::invalidateImpl(void *PassID, LazyCallGraph::SCC &C) {
CGSCCAnalysisResultMapT::iterator RI =
CGSCCAnalysisResults.find(std::make_pair(PassID, C));
CGSCCAnalysisResults.find(std::make_pair(PassID, &C));
if (RI == CGSCCAnalysisResults.end())
return;
CGSCCAnalysisResultLists[C].erase(RI->second);
CGSCCAnalysisResultLists[&C].erase(RI->second);
}
void CGSCCAnalysisManager::invalidateImpl(LazyCallGraph::SCC *C,
void CGSCCAnalysisManager::invalidateImpl(LazyCallGraph::SCC &C,
const PreservedAnalyses &PA) {
// Clear all the invalidated results associated specifically with this
// function.
SmallVector<void *, 8> InvalidatedPassIDs;
CGSCCAnalysisResultListT &ResultsList = CGSCCAnalysisResultLists[C];
CGSCCAnalysisResultListT &ResultsList = CGSCCAnalysisResultLists[&C];
for (CGSCCAnalysisResultListT::iterator I = ResultsList.begin(),
E = ResultsList.end();
I != E;)
@ -104,14 +104,14 @@ void CGSCCAnalysisManager::invalidateImpl(LazyCallGraph::SCC *C,
}
while (!InvalidatedPassIDs.empty())
CGSCCAnalysisResults.erase(
std::make_pair(InvalidatedPassIDs.pop_back_val(), C));
CGSCCAnalysisResultLists.erase(C);
std::make_pair(InvalidatedPassIDs.pop_back_val(), &C));
CGSCCAnalysisResultLists.erase(&C);
}
char CGSCCAnalysisManagerModuleProxy::PassID;
CGSCCAnalysisManagerModuleProxy::Result
CGSCCAnalysisManagerModuleProxy::run(Module *M) {
CGSCCAnalysisManagerModuleProxy::run(Module &M) {
assert(CGAM->empty() && "CGSCC analyses ran prior to the module proxy!");
return Result(*CGAM);
}
@ -123,7 +123,7 @@ CGSCCAnalysisManagerModuleProxy::Result::~Result() {
}
bool CGSCCAnalysisManagerModuleProxy::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 CGSCC analyses, there may be an invalid set of SCC objects in
// the cache making it impossible to incrementally preserve them.
@ -140,7 +140,7 @@ char ModuleAnalysisManagerCGSCCProxy::PassID;
char FunctionAnalysisManagerCGSCCProxy::PassID;
FunctionAnalysisManagerCGSCCProxy::Result
FunctionAnalysisManagerCGSCCProxy::run(LazyCallGraph::SCC *C) {
FunctionAnalysisManagerCGSCCProxy::run(LazyCallGraph::SCC &C) {
assert(FAM->empty() && "Function analyses ran prior to the CGSCC proxy!");
return Result(*FAM);
}
@ -152,7 +152,7 @@ FunctionAnalysisManagerCGSCCProxy::Result::~Result() {
}
bool FunctionAnalysisManagerCGSCCProxy::Result::invalidate(
LazyCallGraph::SCC *C, const PreservedAnalyses &PA) {
LazyCallGraph::SCC &C, 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.