aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/llvm/Analysis/MemoryDependenceAnalysis.h12
-rw-r--r--lib/Analysis/MemoryDependenceAnalysis.cpp34
-rw-r--r--lib/Transforms/Scalar/DeadStoreElimination.cpp6
-rw-r--r--lib/Transforms/Scalar/GVN.cpp6
-rw-r--r--lib/Transforms/Scalar/RedundantLoadElimination.cpp4
5 files changed, 30 insertions, 32 deletions
diff --git a/include/llvm/Analysis/MemoryDependenceAnalysis.h b/include/llvm/Analysis/MemoryDependenceAnalysis.h
index 76425d12be..0b8dec8310 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<Instruction*, std::pair<const Instruction*, bool> >
+ typedef DenseMap<Instruction*, std::pair<Instruction*, bool> >
depMapType;
depMapType depGraphLocal;
// A reverse mapping form dependencies to the dependees. This is
// used when removing instructions to keep the cache coherent.
- typedef DenseMap<const Instruction*, SmallPtrSet<Instruction*, 4> >
+ typedef DenseMap<Instruction*, SmallPtrSet<Instruction*, 4> >
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<BasicBlock*, Value*>& resp);
diff --git a/lib/Analysis/MemoryDependenceAnalysis.cpp b/lib/Analysis/MemoryDependenceAnalysis.cpp
index 168e5ba76f..605dca1069 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<MemoryDependenceAnalysis> 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<Instruction*>(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<Instruction*>(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<Instruction*>(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<Instruction*>(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<BasicBlock*, Value*>& 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<Instruction*>(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<const Instruction*, bool> cachedResult = depGraphLocal[query];
+ std::pair<Instruction*, bool> 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<Instruction*>(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<Instruction*>(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 8cdccc6827..283fcbc97a 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<Instruction*>(MD.getDependency(BBI));
+ Instruction* dep = MD.getDependency(BBI);
// ... and no other memory dependencies are between them....
while (dep != MemoryDependenceAnalysis::None &&
dep != MemoryDependenceAnalysis::NonLocal &&
isa<StoreInst>(dep)) {
if (dep != last) {
- dep = const_cast<Instruction*>(MD.getDependency(BBI, dep));
+ dep = MD.getDependency(BBI, dep);
continue;
}
@@ -154,7 +154,7 @@ bool DSE::runOnBasicBlock(BasicBlock &BB) {
if (FreeInst* F = dyn_cast<FreeInst>(BBI)) {
if (!deletedStore)
MadeChange |= handleFreeWithNonTrivialDependency(F,
- const_cast<Instruction*>(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 b8b58bd003..edd11e8e49 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<StoreInst>(I->second)) {
+ }else if (StoreInst* S = dyn_cast<StoreInst>(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<MemoryDependenceAnalysis>();
- Instruction* dep = const_cast<Instruction*>(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<Instruction*>(MD.getDependency(L, dep));
+ dep = MD.getDependency(L, dep);
}
}
diff --git a/lib/Transforms/Scalar/RedundantLoadElimination.cpp b/lib/Transforms/Scalar/RedundantLoadElimination.cpp
index 2dace31e30..3b719df4f6 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<Instruction*>(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<Instruction*>(MD.getDependency(BBI, dep));
+ dep = MD.getDependency(BBI, dep);
}
}
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-06-26 10:39:59 +0000