RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-04-04 14:22:26 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[LVI] Sink a couple more cache manipulation routines into the cache itself [NFCI]

Browse Source 
The only interesting bit here is the refactor of the handle callback and even that's pretty straight-forward.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@281267 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Philip Reames 2016-09-12 22:03:36 +00:00
parent 8efea574b6
commit ac22fbed43
1 changed files with 45 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
lib/Analysis/LazyValueInfo.cpp
View File

@ -471,9 +471,54 @@ namespace {
OverDefinedCache.clear(); OverDefinedCache.clear();
} }
/// Inform the cache that a given value has been deleted.
void eraseValue(Value *V);
/// This is part of the update interface to inform the cache
/// that a block has been deleted.
void eraseBlock(BasicBlock *BB);
friend struct LVIValueHandle; friend struct LVIValueHandle;
}; };
}
void LazyValueInfoCache::eraseValue(Value *V) {
SmallVector<AssertingVH<BasicBlock>, 4> ToErase;
for (auto &I : OverDefinedCache) {
SmallPtrSetImpl<Value *> &ValueSet = I.second;
if (ValueSet.count(V))
ValueSet.erase(V);
if (ValueSet.empty())
ToErase.push_back(I.first);
}
for (auto &BB : ToErase)
OverDefinedCache.erase(BB);
ValueCache.erase(V);
}
void LVIValueHandle::deleted() {
// This erasure deallocates *this, so it MUST happen after we're done
// using any and all members of *this.
Parent->eraseValue(*this);
}
void LazyValueInfoCache::eraseBlock(BasicBlock *BB) {
// Shortcut if we have never seen this block.
DenseSet<AssertingVH<BasicBlock> >::iterator I = SeenBlocks.find(BB);
if (I == SeenBlocks.end())
return;
SeenBlocks.erase(I);
auto ODI = OverDefinedCache.find(BB);
if (ODI != OverDefinedCache.end())
OverDefinedCache.erase(ODI);
for (auto &I : ValueCache)
I.second->BlockVals.erase(BB);
}
namespace {
// The actual implementation of the lazy analysis and update. Note that the // The actual implementation of the lazy analysis and update. Note that the
// inheritance from LazyValueInfoCache is intended to be temporary while // inheritance from LazyValueInfoCache is intended to be temporary while
// splitting the code and then transitioning to a has-a relationship. // splitting the code and then transitioning to a has-a relationship.
@ -546,48 +591,12 @@ namespace {
/// PredBB to OldSucc has been threaded to be from PredBB to NewSucc. /// PredBB to OldSucc has been threaded to be from PredBB to NewSucc.
void threadEdge(BasicBlock *PredBB,BasicBlock *OldSucc,BasicBlock *NewSucc); void threadEdge(BasicBlock *PredBB,BasicBlock *OldSucc,BasicBlock *NewSucc);
/// This is part of the update interface to inform the cache
/// that a block has been deleted.
void eraseBlock(BasicBlock *BB);
LazyValueInfoImpl(AssumptionCache *AC, const DataLayout &DL, LazyValueInfoImpl(AssumptionCache *AC, const DataLayout &DL,
DominatorTree *DT = nullptr) DominatorTree *DT = nullptr)
: AC(AC), DL(DL), DT(DT) {} : AC(AC), DL(DL), DT(DT) {}
}; };
} // end anonymous namespace } // end anonymous namespace
void LVIValueHandle::deleted() {
SmallVector<AssertingVH<BasicBlock>, 4> ToErase;
for (auto &I : Parent->OverDefinedCache) {
SmallPtrSetImpl<Value *> &ValueSet = I.second;
if (ValueSet.count(getValPtr()))
ValueSet.erase(getValPtr());
if (ValueSet.empty())
ToErase.push_back(I.first);
}
for (auto &BB : ToErase)
Parent->OverDefinedCache.erase(BB);
// This erasure deallocates *this, so it MUST happen after we're done
// using any and all members of *this.
Parent->ValueCache.erase(*this);
}
void LazyValueInfoImpl::eraseBlock(BasicBlock *BB) {
// Shortcut if we have never seen this block.
DenseSet<AssertingVH<BasicBlock> >::iterator I = SeenBlocks.find(BB);
if (I == SeenBlocks.end())
return;
SeenBlocks.erase(I);
auto ODI = OverDefinedCache.find(BB);
if (ODI != OverDefinedCache.end())
OverDefinedCache.erase(ODI);
for (auto &I : ValueCache)
I.second->BlockVals.erase(BB);
}
void LazyValueInfoImpl::solve() { void LazyValueInfoImpl::solve() {
while (!BlockValueStack.empty()) { while (!BlockValueStack.empty()) {
std::pair<BasicBlock*, Value*> &e = BlockValueStack.top(); std::pair<BasicBlock*, Value*> &e = BlockValueStack.top();