RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2024-12-13 23:18:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert "MemorySSA: Add support for caching clobbering access in stores"

Browse Source 
This reverts revision r299322.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@299485 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Daniel Berlin 2017-04-04 23:43:04 +00:00
parent 802fcd9c3e
commit d8050a7d38
3 changed files with 24 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -246,16 +246,6 @@ public:
return MA->getValueID() == MemoryUseVal || MA->getValueID() == MemoryDefVal;
}
// Sadly, these have to be public because they are needed in some of the iterators.
virtual bool isOptimized() const = 0;
virtual MemoryAccess *getOptimized() const = 0;
virtual void setOptimized(MemoryAccess *) = 0;
/// \brief Reset the ID of what this MemoryUse was optimized to, causing it to
/// be rewalked by the walker if necessary.
/// This really should only be called by tests.
virtual void resetOptimized() = 0;
protected:
friend class MemorySSA;
friend class MemorySSAUpdater;
@ -264,12 +254,8 @@ protected:
: MemoryAccess(C, Vty, BB, 1), MemoryInst(MI) {
setDefiningAccess(DMA);
}
void setDefiningAccess(MemoryAccess *DMA, bool Optimized = false) {
setOperand(0, DMA);
if (!Optimized)
return;
setOptimized(DMA);
}
void setDefiningAccess(MemoryAccess *DMA) { setOperand(0, DMA); }
private:
Instruction *MemoryInst;
@ -302,18 +288,20 @@ public:
void print(raw_ostream &OS) const override;
virtual void setOptimized(MemoryAccess *DMA) override {
OptimizedID = DMA->getID();
void setDefiningAccess(MemoryAccess *DMA, bool Optimized = false) {
if (Optimized)
OptimizedID = DMA->getID();
MemoryUseOrDef::setDefiningAccess(DMA);
}
virtual bool isOptimized() const override {
bool isOptimized() const {
return getDefiningAccess() && OptimizedID == getDefiningAccess()->getID();
}
virtual MemoryAccess *getOptimized() const override {
return getDefiningAccess();
}
virtual void resetOptimized() override { OptimizedID = INVALID_MEMORYACCESS_ID; }
/// \brief Reset the ID of what this MemoryUse was optimized to, causing it to
/// be rewalked by the walker if necessary.
/// This really should only be called by tests.
void resetOptimized() { OptimizedID = INVALID_MEMORYACCESS_ID; }
protected:
friend class MemorySSA;
@ -345,8 +333,7 @@ public:
MemoryDef(LLVMContext &C, MemoryAccess *DMA, Instruction *MI, BasicBlock *BB,
unsigned Ver)
: MemoryUseOrDef(C, DMA, MemoryDefVal, MI, BB), ID(Ver),
Optimized(nullptr), OptimizedID(INVALID_MEMORYACCESS_ID) {}
: MemoryUseOrDef(C, DMA, MemoryDefVal, MI, BB), ID(Ver) {}
// allocate space for exactly one operand
void *operator new(size_t s) { return User::operator new(s, 1); }
@ -356,17 +343,6 @@ public:
return MA->getValueID() == MemoryDefVal;
}
virtual void setOptimized(MemoryAccess *MA) override {
Optimized = MA;
OptimizedID = getDefiningAccess()->getID();
}
virtual MemoryAccess *getOptimized() const override { return Optimized; }
virtual bool isOptimized() const override {
return getOptimized() && OptimizedID == getDefiningAccess()->getID();
}
virtual void resetOptimized() override { OptimizedID = INVALID_MEMORYACCESS_ID; }
void print(raw_ostream &OS) const override;
protected:
@ -376,8 +352,6 @@ protected:
private:
const unsigned ID;
MemoryAccess *Optimized;
unsigned int OptimizedID;
};
template <>
@ -1101,15 +1075,10 @@ struct def_chain_iterator
def_chain_iterator &operator++() {
// N.B. liveOnEntry has a null defining access.
if (auto *MUD = dyn_cast<MemoryUseOrDef>(MA)) {
if (MUD->isOptimized())
MA = MUD->getOptimized();
else
MA = MUD->getDefiningAccess();
} else {
if (auto *MUD = dyn_cast<MemoryUseOrDef>(MA))
MA = MUD->getDefiningAccess();
else
MA = nullptr;
}
return *this;
}

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

@ -2181,9 +2181,9 @@ MemorySSA::CachingWalker::getClobberingMemoryAccess(MemoryAccess *MA) {
// If this is an already optimized use or def, return the optimized result.
// Note: Currently, we do not store the optimized def result because we'd need
// a separate field, since we can't use it as the defining access.
if (auto *MUD = dyn_cast<MemoryUseOrDef>(StartingAccess))
if (MUD->isOptimized())
return MUD->getOptimized();
if (MemoryUse *MU = dyn_cast<MemoryUse>(StartingAccess))
if (MU->isOptimized())
return MU->getDefiningAccess();
const Instruction *I = StartingAccess->getMemoryInst();
UpwardsMemoryQuery Q(I, StartingAccess);
@ -2199,8 +2199,8 @@ MemorySSA::CachingWalker::getClobberingMemoryAccess(MemoryAccess *MA) {
if (isUseTriviallyOptimizableToLiveOnEntry(*MSSA->AA, I)) {
MemoryAccess *LiveOnEntry = MSSA->getLiveOnEntryDef();
Cache.insert(StartingAccess, LiveOnEntry, Q.StartingLoc, Q.IsCall);
if (auto *MUD = dyn_cast<MemoryUseOrDef>(StartingAccess))
MUD->setDefiningAccess(LiveOnEntry, true);
if (MemoryUse *MU = dyn_cast<MemoryUse>(StartingAccess))
MU->setDefiningAccess(LiveOnEntry, true);
return LiveOnEntry;
}
@ -2217,8 +2217,8 @@ MemorySSA::CachingWalker::getClobberingMemoryAccess(MemoryAccess *MA) {
DEBUG(dbgs() << *DefiningAccess << "\n");
DEBUG(dbgs() << "Final Memory SSA clobber for " << *I << " is ");
DEBUG(dbgs() << *Result << "\n");
if (auto *MUD = dyn_cast<MemoryUseOrDef>(StartingAccess))
MUD->setDefiningAccess(Result, true);
if (MemoryUse *MU = dyn_cast<MemoryUse>(StartingAccess))
MU->setDefiningAccess(Result, true);
return Result;
}

4
lib/Transforms/Utils/MemorySSAUpdater.cpp
View File

@ -451,8 +451,8 @@ void MemorySSAUpdater::removeMemoryAccess(MemoryAccess *MA) {
while (!MA->use_empty()) {
Use &U = *MA->use_begin();
if (auto *MUD = dyn_cast<MemoryUseOrDef>(U.getUser()))
MUD->resetOptimized();
if (MemoryUse *MU = dyn_cast<MemoryUse>(U.getUser()))
MU->resetOptimized();
U.set(NewDefTarget);
}
}