RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 11:02:59 +02:00
Code Issues Projects Releases Wiki Activity

[MemorySSA] Fix bug in CachingMemorySSAWalker::invalidateInfo

Browse Source 
Summary:
CachingMemorySSAWalker::invalidateInfo was using IsCall to determine
which cache map needed to be cleared of entries referring to the invalidated
MemoryAccess, but there could also be entries referring to it in the
other cache map (value entries, not key entries).  This change just
clears both tables to be conservatively correct.

Also add a verifyRemoved() function, called when expensive
checks (i.e. XDEBUG) are enabled to verify that the invalidated
MemoryAccess object is not referenced in any of the caches.

Reviewers: dberlin, george.burgess.iv

Subscribers: mcrosier, llvm-commits

Differential Revision: http://reviews.llvm.org/D19388

llvm-svn: 267157
This commit is contained in:
Geoff Berry 2016-04-22 14:44:10 +00:00
parent 4d95818598
commit aaa311cd7c
2 changed files with 21 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/llvm/Transforms/Utils/MemorySSA.h
View File

@ -756,6 +756,7 @@ private:
MemoryAccess *getClobberingMemoryAccess(MemoryAccess *, UpwardsMemoryQuery &);
bool instructionClobbersQuery(const MemoryDef *, UpwardsMemoryQuery &,
const MemoryLocation &Loc) const;
void verifyRemoved(MemoryAccess *);
SmallDenseMap<ConstMemoryAccessPair, MemoryAccess *>
CachedUpwardsClobberingAccess;
DenseMap<const MemoryAccess *, MemoryAccess *> CachedUpwardsClobberingCall;

31
lib/Transforms/Utils/MemorySSA.cpp
View File

@ -799,19 +799,16 @@ void CachingMemorySSAWalker::invalidateInfo(MemoryAccess *MA) {
if (!Q.IsCall)
Q.StartingLoc = MemoryLocation::get(I);
doCacheRemove(MA, Q, Q.StartingLoc);
return;
}
// If it is not a use, the best we can do right now is destroy the cache.
bool IsCall = false;
if (auto *MUD = dyn_cast<MemoryUseOrDef>(MA)) {
Instruction *I = MUD->getMemoryInst();
IsCall = bool(ImmutableCallSite(I));
}
if (IsCall)
} else {
// If it is not a use, the best we can do right now is destroy the cache.
CachedUpwardsClobberingCall.clear();
else
CachedUpwardsClobberingAccess.clear();
}
#ifdef XDEBUG
// Run this only when expensive checks are enabled.
verifyRemoved(MA);
#endif
}
void CachingMemorySSAWalker::doCacheRemove(const MemoryAccess *M,
@ -1081,6 +1078,18 @@ CachingMemorySSAWalker::getClobberingMemoryAccess(const Instruction *I) {
return Result;
}
// Verify that MA doesn't exist in any of the caches.
void CachingMemorySSAWalker::verifyRemoved(MemoryAccess *MA) {
#ifndef NDEBUG
for (auto &P : CachedUpwardsClobberingAccess)
assert(P.first.first != MA && P.second != MA &&
"Found removed MemoryAccess in cache.");
for (auto &P : CachedUpwardsClobberingCall)
assert(P.first != MA && P.second != MA &&
"Found removed MemoryAccess in cache.");
#endif // !NDEBUG
}
MemoryAccess *
DoNothingMemorySSAWalker::getClobberingMemoryAccess(const Instruction *I) {
MemoryAccess *MA = MSSA->getMemoryAccess(I);