From 9528f11481e6840a10442733f1dc45c04b79d596 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Thu, 9 Aug 2007 04:42:44 +0000 Subject: [PATCH] Make NonLocal and None const in the right way. :-) git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40961 91177308-0d34-0410-b5e6-96231b3b80d8 --- .../llvm/Analysis/MemoryDependenceAnalysis.h | 12 +++---- lib/Analysis/MemoryDependenceAnalysis.cpp | 34 +++++++++---------- .../Scalar/DeadStoreElimination.cpp | 6 ++-- lib/Transforms/Scalar/GVN.cpp | 6 ++-- .../Scalar/RedundantLoadElimination.cpp | 4 +-- 5 files changed, 30 insertions(+), 32 deletions(-) diff --git a/include/llvm/Analysis/MemoryDependenceAnalysis.h b/include/llvm/Analysis/MemoryDependenceAnalysis.h index 76425d12bef..0b8dec83105 100644 --- a/include/llvm/Analysis/MemoryDependenceAnalysis.h +++ b/include/llvm/Analysis/MemoryDependenceAnalysis.h @@ -33,23 +33,23 @@ class MemoryDependenceAnalysis : public FunctionPass { private: // A map from instructions to their dependency, with a boolean // flags for whether this mapping is confirmed or not - typedef DenseMap > + typedef DenseMap > depMapType; depMapType depGraphLocal; // A reverse mapping form dependencies to the dependees. This is // used when removing instructions to keep the cache coherent. - typedef DenseMap > + typedef DenseMap > reverseDepMapType; reverseDepMapType reverseDep; public: // Special marker indicating that the query has no dependency // in the specified block. - static const Instruction* NonLocal; + static Instruction* const NonLocal; // Special marker indicating that the query has no dependency at all - static const Instruction* None; + static Instruction* const None; static char ID; // Class identification, replacement for typeinfo MemoryDependenceAnalysis() : FunctionPass((intptr_t)&ID) {} @@ -71,7 +71,7 @@ class MemoryDependenceAnalysis : public FunctionPass { /// getDependency - Return the instruction on which a memory operation /// depends, starting with start. - const Instruction* getDependency(Instruction* query, Instruction* start = 0, + Instruction* getDependency(Instruction* query, Instruction* start = 0, BasicBlock* block = 0); /// getNonLocalDependency - Fills the passed-in map with the non-local @@ -85,7 +85,7 @@ class MemoryDependenceAnalysis : public FunctionPass { void removeInstruction(Instruction* rem); private: - const Instruction* getCallSiteDependency(CallSite C, Instruction* start, + Instruction* getCallSiteDependency(CallSite C, Instruction* start, BasicBlock* block); void nonLocalHelper(Instruction* query, BasicBlock* block, DenseMap& resp); diff --git a/lib/Analysis/MemoryDependenceAnalysis.cpp b/lib/Analysis/MemoryDependenceAnalysis.cpp index 168e5ba76f6..605dca1069f 100644 --- a/lib/Analysis/MemoryDependenceAnalysis.cpp +++ b/lib/Analysis/MemoryDependenceAnalysis.cpp @@ -26,8 +26,8 @@ using namespace llvm; char MemoryDependenceAnalysis::ID = 0; -const Instruction* MemoryDependenceAnalysis::NonLocal = (Instruction*)-3; -const Instruction* MemoryDependenceAnalysis::None = (Instruction*)-4; +Instruction* const MemoryDependenceAnalysis::NonLocal = (Instruction*)-3; +Instruction* const MemoryDependenceAnalysis::None = (Instruction*)-4; // Register this pass... static RegisterPass X("memdep", @@ -43,7 +43,7 @@ void MemoryDependenceAnalysis::getAnalysisUsage(AnalysisUsage &AU) const { /// getCallSiteDependency - Private helper for finding the local dependencies /// of a call site. -const Instruction* MemoryDependenceAnalysis::getCallSiteDependency(CallSite C, +Instruction* MemoryDependenceAnalysis::getCallSiteDependency(CallSite C, Instruction* start, BasicBlock* block) { @@ -147,9 +147,9 @@ void MemoryDependenceAnalysis::nonLocalHelper(Instruction* query, if (BB != block) { visited.insert(BB); - const Instruction* localDep = getDependency(query, 0, BB); + Instruction* localDep = getDependency(query, 0, BB); if (localDep != NonLocal) { - resp.insert(std::make_pair(BB, const_cast(localDep))); + resp.insert(std::make_pair(BB, localDep)); stack.pop_back(); continue; @@ -160,9 +160,9 @@ void MemoryDependenceAnalysis::nonLocalHelper(Instruction* query, } else if (BB == block && stack.size() > 1) { visited.insert(BB); - const Instruction* localDep = getDependency(query, 0, BB); + Instruction* localDep = getDependency(query, 0, BB); if (localDep != query) - resp.insert(std::make_pair(BB, const_cast(localDep))); + resp.insert(std::make_pair(BB, localDep)); stack.pop_back(); @@ -186,12 +186,12 @@ void MemoryDependenceAnalysis::nonLocalHelper(Instruction* query, // If we didn't insert because we have no predecessors, then this // query has no dependency at all. else if (!inserted && !predOnStack) { - resp.insert(std::make_pair(BB, const_cast(None))); + resp.insert(std::make_pair(BB, None)); // If we didn't insert because our predecessors are already on the stack, // then we might still have a dependency, but it will be discovered during // backtracking. } else if (!inserted && predOnStack){ - resp.insert(std::make_pair(BB, const_cast(NonLocal))); + resp.insert(std::make_pair(BB, NonLocal)); } stack.pop_back(); @@ -204,10 +204,9 @@ void MemoryDependenceAnalysis::nonLocalHelper(Instruction* query, void MemoryDependenceAnalysis::getNonLocalDependency(Instruction* query, DenseMap& resp) { // First check that we don't actually have a local dependency. - const Instruction* localDep = getDependency(query); + Instruction* localDep = getDependency(query); if (localDep != NonLocal) { - resp.insert(std::make_pair(query->getParent(), - const_cast(localDep))); + resp.insert(std::make_pair(query->getParent(),localDep)); return; } @@ -218,20 +217,20 @@ void MemoryDependenceAnalysis::getNonLocalDependency(Instruction* query, /// getDependency - Return the instruction on which a memory operation /// depends. The local paramter indicates if the query should only /// evaluate dependencies within the same basic block. -const Instruction* MemoryDependenceAnalysis::getDependency(Instruction* query, +Instruction* MemoryDependenceAnalysis::getDependency(Instruction* query, Instruction* start, BasicBlock* block) { // Start looking for dependencies with the queried inst BasicBlock::iterator QI = query; // Check for a cached result - std::pair cachedResult = depGraphLocal[query]; + std::pair cachedResult = depGraphLocal[query]; // If we have a _confirmed_ cached entry, return it if (cachedResult.second) return cachedResult.first; else if (cachedResult.first && cachedResult.first != NonLocal) // If we have an unconfirmed cached entry, we can start our search from there - QI = const_cast(cachedResult.first); + QI = cachedResult.first; if (start) QI = start; @@ -378,7 +377,7 @@ const Instruction* MemoryDependenceAnalysis::getDependency(Instruction* query, /// This method attempts to keep the cache coherent using the reverse map. void MemoryDependenceAnalysis::removeInstruction(Instruction* rem) { // Figure out the new dep for things that currently depend on rem - const Instruction* newDep = NonLocal; + Instruction* newDep = NonLocal; depMapType::iterator depGraphEntry = depGraphLocal.find(rem); // We assume here that it's not in the reverse map if it's not in @@ -388,8 +387,7 @@ void MemoryDependenceAnalysis::removeInstruction(Instruction* rem) { if (depGraphEntry->second.first != NonLocal && depGraphEntry->second.second) { // If we have dep info for rem, set them to it - BasicBlock::iterator RI = - const_cast(depGraphEntry->second.first); + BasicBlock::iterator RI = depGraphEntry->second.first; RI++; newDep = RI; } else if (depGraphEntry->second.first == NonLocal && diff --git a/lib/Transforms/Scalar/DeadStoreElimination.cpp b/lib/Transforms/Scalar/DeadStoreElimination.cpp index 8cdccc6827f..283fcbc97a1 100644 --- a/lib/Transforms/Scalar/DeadStoreElimination.cpp +++ b/lib/Transforms/Scalar/DeadStoreElimination.cpp @@ -121,14 +121,14 @@ bool DSE::runOnBasicBlock(BasicBlock &BB) { // ... to a pointer that has been stored to before... if (last) { - Instruction* dep = const_cast(MD.getDependency(BBI)); + Instruction* dep = MD.getDependency(BBI); // ... and no other memory dependencies are between them.... while (dep != MemoryDependenceAnalysis::None && dep != MemoryDependenceAnalysis::NonLocal && isa(dep)) { if (dep != last) { - dep = const_cast(MD.getDependency(BBI, dep)); + dep = MD.getDependency(BBI, dep); continue; } @@ -154,7 +154,7 @@ bool DSE::runOnBasicBlock(BasicBlock &BB) { if (FreeInst* F = dyn_cast(BBI)) { if (!deletedStore) MadeChange |= handleFreeWithNonTrivialDependency(F, - const_cast(MD.getDependency(F)), + MD.getDependency(F), possiblyDead); // No known stores after the free last = 0; diff --git a/lib/Transforms/Scalar/GVN.cpp b/lib/Transforms/Scalar/GVN.cpp index b8b58bd0036..edd11e8e493 100644 --- a/lib/Transforms/Scalar/GVN.cpp +++ b/lib/Transforms/Scalar/GVN.cpp @@ -803,7 +803,7 @@ bool GVN::processNonLocalLoad(LoadInst* L, return false; } else if (I->second == MemoryDependenceAnalysis::NonLocal) { continue; - } else if (StoreInst* S = dyn_cast(I->second)) { + }else if (StoreInst* S = dyn_cast(I->second)) { if (S->getPointerOperand() == L->getPointerOperand()) repl[I->first] = S->getOperand(0); else @@ -856,7 +856,7 @@ bool GVN::processLoad(LoadInst* L, // ... to a pointer that has been loaded from before... MemoryDependenceAnalysis& MD = getAnalysis(); - Instruction* dep = const_cast(MD.getDependency(L)); + Instruction* dep = MD.getDependency(L); if (dep == MemoryDependenceAnalysis::NonLocal && L->getParent() != &L->getParent()->getParent()->getEntryBlock()) processNonLocalLoad(L, toErase); @@ -895,7 +895,7 @@ bool GVN::processLoad(LoadInst* L, break; } else { - dep = const_cast(MD.getDependency(L, dep)); + dep = MD.getDependency(L, dep); } } diff --git a/lib/Transforms/Scalar/RedundantLoadElimination.cpp b/lib/Transforms/Scalar/RedundantLoadElimination.cpp index 2dace31e300..3b719df4f6e 100644 --- a/lib/Transforms/Scalar/RedundantLoadElimination.cpp +++ b/lib/Transforms/Scalar/RedundantLoadElimination.cpp @@ -80,7 +80,7 @@ bool RLE::runOnBasicBlock(BasicBlock &BB) { LoadInst*& last = lastLoad[pointer]; // ... to a pointer that has been loaded from before... - Instruction* dep = const_cast(MD.getDependency(BBI)); + Instruction* dep = MD.getDependency(BBI); bool deletedLoad = false; while (dep != MemoryDependenceAnalysis::None && @@ -120,7 +120,7 @@ bool RLE::runOnBasicBlock(BasicBlock &BB) { break; } else { - dep = const_cast(MD.getDependency(BBI, dep)); + dep = MD.getDependency(BBI, dep); } }