6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-12 13:38:21 +00:00
Code Issues Projects Releases Wiki Activity

reimplement AliasSetTracker in terms of DenseMap instead of hash_map,

Browse Source 
hopefully no functionality change.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@66398 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2009-03-09 05:11:09 +00:00
parent f9f7da830e
commit d7168ddb11
3 changed files with 93 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
lib/Analysis/AliasSetTracker.cpp
View File

@ -39,11 +39,11 @@ void AliasSet::mergeSetIn(AliasSet &AS, AliasSetTracker &AST) {
// used to be must-alias sets, we can just check any pointer from each set
// for aliasing.
AliasAnalysis &AA = AST.getAliasAnalysis();
HashNodePair *L = getSomePointer();
HashNodePair *R = AS.getSomePointer();
PointerRec *L = getSomePointer();
PointerRec *R = AS.getSomePointer();
// If the pointers are not a must-alias pair, this set becomes a may alias.
if (AA.alias(L->first, L->second.getSize(), R->first, R->second.getSize())
if (AA.alias(L->getValue(), L->getSize(), R->getValue(), R->getSize())
!= AliasAnalysis::MustAlias)
AliasTy = MayAlias;
}
@ -62,7 +62,7 @@ void AliasSet::mergeSetIn(AliasSet &AS, AliasSetTracker &AST) {
// Merge the list of constituent pointers...
if (AS.PtrList) {
*PtrListEnd = AS.PtrList;
AS.PtrList->second.setPrevInList(PtrListEnd);
AS.PtrList->setPrevInList(PtrListEnd);
PtrListEnd = AS.PtrListEnd;
AS.PtrList = 0;
@ -84,30 +84,30 @@ void AliasSet::removeFromTracker(AliasSetTracker &AST) {
AST.removeAliasSet(this);
}
void AliasSet::addPointer(AliasSetTracker &AST, HashNodePair &Entry,
void AliasSet::addPointer(AliasSetTracker &AST, PointerRec &Entry,
unsigned Size, bool KnownMustAlias) {
assert(!Entry.second.hasAliasSet() && "Entry already in set!");
assert(!Entry.hasAliasSet() && "Entry already in set!");
// Check to see if we have to downgrade to _may_ alias.
if (isMustAlias() && !KnownMustAlias)
if (HashNodePair *P = getSomePointer()) {
if (PointerRec *P = getSomePointer()) {
AliasAnalysis &AA = AST.getAliasAnalysis();
AliasAnalysis::AliasResult Result =
AA.alias(P->first, P->second.getSize(), Entry.first, Size);
AA.alias(P->getValue(), P->getSize(), Entry.getValue(), Size);
if (Result == AliasAnalysis::MayAlias)
AliasTy = MayAlias;
else // First entry of must alias must have maximum size!
P->second.updateSize(Size);
P->updateSize(Size);
assert(Result != AliasAnalysis::NoAlias && "Cannot be part of must set!");
}
Entry.second.setAliasSet(this);
Entry.second.updateSize(Size);
Entry.setAliasSet(this);
Entry.updateSize(Size);
// Add it to the end of the list...
assert(*PtrListEnd == 0 && "End of list is not null?");
*PtrListEnd = &Entry;
PtrListEnd = Entry.second.setPrevInList(PtrListEnd);
PtrListEnd = Entry.setPrevInList(PtrListEnd);
assert(*PtrListEnd == 0 && "End of list is not null?");
addRef(); // Entry points to alias set...
}
@ -139,9 +139,9 @@ bool AliasSet::aliasesPointer(const Value *Ptr, unsigned Size,
// If this is a set of MustAliases, only check to see if the pointer aliases
// SOME value in the set...
HashNodePair *SomePtr = getSomePointer();
PointerRec *SomePtr = getSomePointer();
assert(SomePtr && "Empty must-alias set??");
return AA.alias(SomePtr->first, SomePtr->second.getSize(), Ptr, Size);
return AA.alias(SomePtr->getValue(), SomePtr->getSize(), Ptr, Size);
}
// If this is a may-alias set, we have to check all of the pointers in the set
@ -184,6 +184,18 @@ bool AliasSet::aliasesCallSite(CallSite CS, AliasAnalysis &AA) const {
return false;
}
void AliasSetTracker::clear() {
// Delete all the PointerRec entries.
for (DenseMap<Value*, AliasSet::PointerRec*>::iterator I = PointerMap.begin(),
E = PointerMap.end(); I != E; ++I)
I->second->eraseFromList();
PointerMap.clear();
// The alias sets should all be clear now.
AliasSets.clear();
}
/// findAliasSetForPointer - Given a pointer, find the one alias set to put the
/// instruction referring to the pointer into. If there are multiple alias sets
@ -234,16 +246,16 @@ AliasSet *AliasSetTracker::findAliasSetForCallSite(CallSite CS) {
/// getAliasSetForPointer - Return the alias set that the specified pointer
/// lives in...
/// lives in.
AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, unsigned Size,
bool *New) {
AliasSet::HashNodePair &Entry = getEntryFor(Pointer);
AliasSet::PointerRec &Entry = getEntryFor(Pointer);
// Check to see if the pointer is already known...
if (Entry.second.hasAliasSet()) {
Entry.second.updateSize(Size);
if (Entry.hasAliasSet()) {
Entry.updateSize(Size);
// Return the set!
return *Entry.second.getAliasSet(*this)->getForwardedTarget(*this);
return *Entry.getAliasSet(*this)->getForwardedTarget(*this);
} else if (AliasSet *AS = findAliasSetForPointer(Pointer, Size)) {
// Add it to the alias set it aliases...
AS->addPointer(*this, Entry, Size);
@ -371,17 +383,18 @@ void AliasSetTracker::remove(AliasSet &AS) {
// Clear the alias set.
unsigned NumRefs = 0;
while (!AS.empty()) {
AliasSet::HashNodePair *P = AS.PtrList;
AliasSet::PointerRec *P = AS.PtrList;
Value *ValToRemove = P->getValue();
// Unlink from the list of values.
P->second.removeFromList();
// Unlink and delete entry from the list of values.
P->eraseFromList();
// Remember how many references need to be dropped.
++NumRefs;
// Finally, remove the entry.
Value *Remove = P->first; // Take a copy because it is invalid to pass
PointerMap.erase(Remove); // a reference to the data being erased.
PointerMap.erase(ValToRemove);
}
// Stop using the alias set, removing it.
@ -472,17 +485,19 @@ void AliasSetTracker::deleteValue(Value *PtrVal) {
AS->removeCallSite(CS);
// First, look up the PointerRec for this pointer.
hash_map<Value*, AliasSet::PointerRec>::iterator I = PointerMap.find(PtrVal);
DenseMap<Value*, AliasSet::PointerRec*>::iterator I = PointerMap.find(PtrVal);
if (I == PointerMap.end()) return; // Noop
// If we found one, remove the pointer from the alias set it is in.
AliasSet::HashNodePair &PtrValEnt = *I;
AliasSet *AS = PtrValEnt.second.getAliasSet(*this);
AliasSet::PointerRec *PtrValEnt = I->second;
AliasSet *AS = PtrValEnt->getAliasSet(*this);
// Unlink from the list of values...
PtrValEnt.second.removeFromList();
// Stop using the alias set
// Unlink and delete from the list of values.
PtrValEnt->eraseFromList();
// Stop using the alias set.
AS->dropRef(*this);
PointerMap.erase(I);
}
@ -496,16 +511,17 @@ void AliasSetTracker::copyValue(Value *From, Value *To) {
AA.copyValue(From, To);
// First, look up the PointerRec for this pointer.
hash_map<Value*, AliasSet::PointerRec>::iterator I = PointerMap.find(From);
if (I == PointerMap.end() || !I->second.hasAliasSet())
DenseMap<Value*, AliasSet::PointerRec*>::iterator I = PointerMap.find(From);
if (I == PointerMap.end())
return; // Noop
assert(I->second->hasAliasSet() && "Dead entry?");
AliasSet::HashNodePair &Entry = getEntryFor(To);
if (Entry.second.hasAliasSet()) return; // Already in the tracker!
AliasSet::PointerRec &Entry = getEntryFor(To);
if (Entry.hasAliasSet()) return; // Already in the tracker!
// Add it to the alias set it aliases...
AliasSet *AS = I->second.getAliasSet(*this);
AS->addPointer(*this, Entry, I->second.getSize(), true);
AliasSet *AS = I->second->getAliasSet(*this);
AS->addPointer(*this, Entry, I->second->getSize(), true);
}