From: Chris Lattner Date: Sat, 29 Nov 2008 09:20:15 +0000 (+0000) Subject: rename some maps. X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=8c4652790e04515f34cf920b0783d6ec4161a313;p=oota-llvm.git rename some maps. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@60242 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/llvm/Analysis/MemoryDependenceAnalysis.h b/include/llvm/Analysis/MemoryDependenceAnalysis.h index 28548229a46..62dbeb1358b 100644 --- a/include/llvm/Analysis/MemoryDependenceAnalysis.h +++ b/include/llvm/Analysis/MemoryDependenceAnalysis.h @@ -123,17 +123,17 @@ namespace llvm { // A map from instructions to their non-local dependencies. // FIXME: DENSEMAP of DENSEMAP not a great idea. typedef DenseMap > nonLocalDepMapType; - nonLocalDepMapType depGraphNonLocal; + DenseMap > NonLocalDepMapType; + NonLocalDepMapType NonLocalDeps; // A reverse mapping from dependencies to the dependees. This is // used when removing instructions to keep the cache coherent. typedef DenseMap > reverseDepMapType; - reverseDepMapType reverseDep; + SmallPtrSet > ReverseDepMapType; + ReverseDepMapType ReverseLocalDeps; // A reverse mapping form dependencies to the non-local dependees. - reverseDepMapType reverseDepNonLocal; + ReverseDepMapType ReverseNonLocalDeps; public: MemoryDependenceAnalysis() : FunctionPass(&ID) {} @@ -146,9 +146,9 @@ namespace llvm { /// Clean up memory in between runs void releaseMemory() { LocalDeps.clear(); - depGraphNonLocal.clear(); - reverseDep.clear(); - reverseDepNonLocal.clear(); + NonLocalDeps.clear(); + ReverseLocalDeps.clear(); + ReverseNonLocalDeps.clear(); } /// getAnalysisUsage - Does not modify anything. It uses Value Numbering diff --git a/lib/Analysis/MemoryDependenceAnalysis.cpp b/lib/Analysis/MemoryDependenceAnalysis.cpp index 2f954f7a24e..41e14a70c8a 100644 --- a/lib/Analysis/MemoryDependenceAnalysis.cpp +++ b/lib/Analysis/MemoryDependenceAnalysis.cpp @@ -54,22 +54,22 @@ void MemoryDependenceAnalysis::verifyRemoved(Instruction *D) const { "Inst occurs in data structures"); } - for (nonLocalDepMapType::const_iterator I = depGraphNonLocal.begin(), - E = depGraphNonLocal.end(); I != E; ++I) { + for (NonLocalDepMapType::const_iterator I = NonLocalDeps.begin(), + E = NonLocalDeps.end(); I != E; ++I) { assert(I->first != D && "Inst occurs in data structures"); for (DenseMap::iterator II = I->second.begin(), EE = I->second.end(); II != EE; ++II) assert(II->second.getPointer() != D && "Inst occurs in data structures"); } - for (reverseDepMapType::const_iterator I = reverseDep.begin(), - E = reverseDep.end(); I != E; ++I) + for (ReverseDepMapType::const_iterator I = ReverseLocalDeps.begin(), + E = ReverseLocalDeps.end(); I != E; ++I) for (SmallPtrSet::const_iterator II = I->second.begin(), EE = I->second.end(); II != EE; ++II) assert(*II != D && "Inst occurs in data structures"); - for (reverseDepMapType::const_iterator I = reverseDepNonLocal.begin(), - E = reverseDepNonLocal.end(); + for (ReverseDepMapType::const_iterator I = ReverseNonLocalDeps.begin(), + E = ReverseNonLocalDeps.end(); I != E; ++I) for (SmallPtrSet::const_iterator II = I->second.begin(), EE = I->second.end(); II != EE; ++II) @@ -225,8 +225,8 @@ void MemoryDependenceAnalysis::nonLocalHelper(Instruction* query, /// blocks between the query and its dependencies. void MemoryDependenceAnalysis::getNonLocalDependency(Instruction* query, DenseMap &resp) { - if (depGraphNonLocal.count(query)) { - DenseMap &cached = depGraphNonLocal[query]; + if (NonLocalDeps.count(query)) { + DenseMap &cached = NonLocalDeps[query]; NumCacheNonlocal++; SmallVector dirtied; @@ -250,7 +250,7 @@ void MemoryDependenceAnalysis::getNonLocalDependency(Instruction* query, for (DenseMap::iterator I = cached.begin(), E = cached.end(); I != E; ++I) { if (Instruction *Inst = I->second.getPointer()) - reverseDepNonLocal[Inst].insert(query); + ReverseNonLocalDeps[Inst].insert(query); resp[I->first] = ConvToResult(I->second); } @@ -260,7 +260,7 @@ void MemoryDependenceAnalysis::getNonLocalDependency(Instruction* query, NumUncacheNonlocal++; // If not, go ahead and search for non-local deps. - DenseMap &cached = depGraphNonLocal[query]; + DenseMap &cached = NonLocalDeps[query]; nonLocalHelper(query, query->getParent(), cached); // Update the non-local dependency cache @@ -268,7 +268,7 @@ void MemoryDependenceAnalysis::getNonLocalDependency(Instruction* query, E = cached.end(); I != E; ++I) { // FIXME: Merge with the code above! if (Instruction *Inst = I->second.getPointer()) - reverseDepNonLocal[Inst].insert(query); + ReverseNonLocalDeps[Inst].insert(query); resp[I->first] = ConvToResult(I->second); } } @@ -402,7 +402,7 @@ MemDepResult MemoryDependenceAnalysis::getDependency(Instruction *QueryInst) { // FIXME: Don't convert back and forth! Make a shared helper function. LocalCache = ConvFromResult(Res); if (Instruction *I = Res.getInst()) - reverseDep[I].insert(QueryInst); + ReverseLocalDeps[I].insert(QueryInst); return Res; } @@ -415,38 +415,38 @@ void MemoryDependenceAnalysis::dropInstruction(Instruction* drop) { LocalDepMapType::iterator depGraphEntry = LocalDeps.find(drop); if (depGraphEntry != LocalDeps.end()) if (Instruction *Inst = depGraphEntry->second.getPointer()) - reverseDep[Inst].erase(drop); + ReverseLocalDeps[Inst].erase(drop); // Drop dependency information for things that depended on this instr - SmallPtrSet& set = reverseDep[drop]; + SmallPtrSet& set = ReverseLocalDeps[drop]; for (SmallPtrSet::iterator I = set.begin(), E = set.end(); I != E; ++I) LocalDeps.erase(*I); LocalDeps.erase(drop); - reverseDep.erase(drop); + ReverseLocalDeps.erase(drop); for (DenseMap::iterator DI = - depGraphNonLocal[drop].begin(), DE = depGraphNonLocal[drop].end(); + NonLocalDeps[drop].begin(), DE = NonLocalDeps[drop].end(); DI != DE; ++DI) if (Instruction *Inst = DI->second.getPointer()) - reverseDepNonLocal[Inst].erase(drop); + ReverseNonLocalDeps[Inst].erase(drop); - if (reverseDepNonLocal.count(drop)) { + if (ReverseNonLocalDeps.count(drop)) { SmallPtrSet& set = - reverseDepNonLocal[drop]; + ReverseNonLocalDeps[drop]; for (SmallPtrSet::iterator I = set.begin(), E = set.end(); I != E; ++I) for (DenseMap::iterator DI = - depGraphNonLocal[*I].begin(), DE = depGraphNonLocal[*I].end(); + NonLocalDeps[*I].begin(), DE = NonLocalDeps[*I].end(); DI != DE; ++DI) if (DI->second == DepResultTy(drop, Normal)) // FIXME: Why not remember the old insertion point?? DI->second = DepResultTy(0, Dirty); } - reverseDepNonLocal.erase(drop); - depGraphNonLocal.erase(drop); + ReverseNonLocalDeps.erase(drop); + NonLocalDeps.erase(drop); } /// removeInstruction - Remove an instruction from the dependence analysis, @@ -456,10 +456,10 @@ void MemoryDependenceAnalysis::removeInstruction(Instruction *RemInst) { // Walk through the Non-local dependencies, removing this one as the value // for any cached queries. for (DenseMap::iterator DI = - depGraphNonLocal[RemInst].begin(), DE = depGraphNonLocal[RemInst].end(); + NonLocalDeps[RemInst].begin(), DE = NonLocalDeps[RemInst].end(); DI != DE; ++DI) if (Instruction *Inst = DI->second.getPointer()) - reverseDepNonLocal[Inst].erase(RemInst); + ReverseNonLocalDeps[Inst].erase(RemInst); // Shortly after this, we will look for things that depend on RemInst. In // order to update these, we'll need a new dependency to base them on. We @@ -479,7 +479,7 @@ void MemoryDependenceAnalysis::removeInstruction(Instruction *RemInst) { // Remove us from DepInst's reverse set now that the local dep info is gone. if (Instruction *Inst = LocalDep.getPointer()) - reverseDep[Inst].erase(RemInst); + ReverseLocalDeps[Inst].erase(RemInst); // If we have unconfirmed info, don't trust it. if (LocalDep.getInt() != Dirty) { @@ -505,8 +505,8 @@ void MemoryDependenceAnalysis::removeInstruction(Instruction *RemInst) { // Loop over all of the things that depend on the instruction we're removing. // - reverseDepMapType::iterator ReverseDepIt = reverseDep.find(RemInst); - if (ReverseDepIt != reverseDep.end()) { + ReverseDepMapType::iterator ReverseDepIt = ReverseLocalDeps.find(RemInst); + if (ReverseDepIt != ReverseLocalDeps.end()) { SmallPtrSet &ReverseDeps = ReverseDepIt->second; for (SmallPtrSet::iterator I = ReverseDeps.begin(), E = ReverseDeps.end(); I != E; ++I) { @@ -522,26 +522,26 @@ void MemoryDependenceAnalysis::removeInstruction(Instruction *RemInst) { // If our NewDependency is an instruction, make sure to remember that new // things depend on it. if (Instruction *Inst = NewDependency.getPointer()) - reverseDep[Inst].insert(InstDependingOnRemInst); + ReverseLocalDeps[Inst].insert(InstDependingOnRemInst); } - reverseDep.erase(RemInst); + ReverseLocalDeps.erase(RemInst); } - ReverseDepIt = reverseDepNonLocal.find(RemInst); - if (ReverseDepIt != reverseDepNonLocal.end()) { + ReverseDepIt = ReverseNonLocalDeps.find(RemInst); + if (ReverseDepIt != ReverseNonLocalDeps.end()) { SmallPtrSet& set = ReverseDepIt->second; for (SmallPtrSet::iterator I = set.begin(), E = set.end(); I != E; ++I) - for (DenseMap::iterator DI = - depGraphNonLocal[*I].begin(), DE = depGraphNonLocal[*I].end(); + for (DenseMap::iterator + DI = NonLocalDeps[*I].begin(), DE = NonLocalDeps[*I].end(); DI != DE; ++DI) if (DI->second == DepResultTy(RemInst, Normal)) // FIXME: Why not remember the old insertion point?? DI->second = DepResultTy(0, Dirty); - reverseDepNonLocal.erase(ReverseDepIt); + ReverseNonLocalDeps.erase(ReverseDepIt); } - depGraphNonLocal.erase(RemInst); + NonLocalDeps.erase(RemInst); getAnalysis().deleteValue(RemInst);