diff options
author | Duncan Sands <baldrick@free.fr> | 2007-12-01 07:51:45 +0000 |
---|---|---|
committer | Duncan Sands <baldrick@free.fr> | 2007-12-01 07:51:45 +0000 |
commit | dff6710717b159f089c76a07eda074eb6347eb92 (patch) | |
tree | 7bbd754ebe64f5d4bbc6000e0e66bdd99f9c847f /lib/Analysis | |
parent | e3110d0825e6316fd2dd21d6a4e593295cd413f1 (diff) | |
download | external_llvm-dff6710717b159f089c76a07eda074eb6347eb92.zip external_llvm-dff6710717b159f089c76a07eda074eb6347eb92.tar.gz external_llvm-dff6710717b159f089c76a07eda074eb6347eb92.tar.bz2 |
Integrate the readonly/readnone logic more deeply
into alias analysis. This meant updating the API
which now has versions of the getModRefBehavior,
doesNotAccessMemory and onlyReadsMemory methods
which take a callsite parameter. These should be
used unless the callsite is not known, since in
general they can do a better job than the versions
that take a function. Also, users should no longer
call the version of getModRefBehavior that takes
both a function and a callsite. To reduce the
chance of misuse it is now protected.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@44487 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib/Analysis')
-rw-r--r-- | lib/Analysis/AliasAnalysis.cpp | 39 | ||||
-rw-r--r-- | lib/Analysis/AliasAnalysisCounter.cpp | 6 | ||||
-rw-r--r-- | lib/Analysis/AliasSetTracker.cpp | 38 | ||||
-rw-r--r-- | lib/Analysis/BasicAliasAnalysis.cpp | 5 | ||||
-rw-r--r-- | lib/Analysis/IPA/GlobalsModRef.cpp | 2 | ||||
-rw-r--r-- | lib/Analysis/LoadValueNumbering.cpp | 5 | ||||
-rw-r--r-- | lib/Analysis/MemoryDependenceAnalysis.cpp | 6 |
7 files changed, 58 insertions, 43 deletions
diff --git a/lib/Analysis/AliasAnalysis.cpp b/lib/Analysis/AliasAnalysis.cpp index 2a3ac5a..9e1ae2a 100644 --- a/lib/Analysis/AliasAnalysis.cpp +++ b/lib/Analysis/AliasAnalysis.cpp @@ -27,6 +27,7 @@ #include "llvm/Analysis/AliasAnalysis.h" #include "llvm/Pass.h" #include "llvm/BasicBlock.h" +#include "llvm/Function.h" #include "llvm/Instructions.h" #include "llvm/Type.h" #include "llvm/Target/TargetData.h" @@ -112,16 +113,40 @@ AliasAnalysis::getModRefInfo(StoreInst *S, Value *P, unsigned Size) { return pointsToConstantMemory(P) ? NoModRef : Mod; } +AliasAnalysis::ModRefBehavior +AliasAnalysis::getModRefBehavior(CallSite CS, + std::vector<PointerAccessInfo> *Info) { + if (CS.paramHasAttr(0, ParamAttr::ReadNone)) + // Can't do better than this. + return DoesNotAccessMemory; + ModRefBehavior MRB = UnknownModRefBehavior; + if (Function *F = CS.getCalledFunction()) + MRB = getModRefBehavior(F, CS, Info); + if (MRB != DoesNotAccessMemory && CS.paramHasAttr(0, ParamAttr::ReadOnly)) + return OnlyReadsMemory; + return MRB; +} + +AliasAnalysis::ModRefBehavior +AliasAnalysis::getModRefBehavior(Function *F, + std::vector<PointerAccessInfo> *Info) { + if (F->paramHasAttr(0, ParamAttr::ReadNone)) + // Can't do better than this. + return DoesNotAccessMemory; + ModRefBehavior MRB = getModRefBehavior(F, CallSite(), Info); + if (MRB != DoesNotAccessMemory && F->paramHasAttr(0, ParamAttr::ReadOnly)) + return OnlyReadsMemory; + return MRB; +} + AliasAnalysis::ModRefResult AliasAnalysis::getModRefInfo(CallSite CS, Value *P, unsigned Size) { ModRefResult Mask = ModRef; - if (Function *F = CS.getCalledFunction()) { - ModRefBehavior MRB = getModRefBehavior(F, CallSite()); - if (MRB == OnlyReadsMemory) - Mask = Ref; - else if (MRB == DoesNotAccessMemory) - return NoModRef; - } + ModRefBehavior MRB = getModRefBehavior(CS); + if (MRB == OnlyReadsMemory) + Mask = Ref; + else if (MRB == DoesNotAccessMemory) + return NoModRef; if (!AA) return Mask; diff --git a/lib/Analysis/AliasAnalysisCounter.cpp b/lib/Analysis/AliasAnalysisCounter.cpp index eea2c99..2fccff1 100644 --- a/lib/Analysis/AliasAnalysisCounter.cpp +++ b/lib/Analysis/AliasAnalysisCounter.cpp @@ -89,9 +89,15 @@ namespace { bool pointsToConstantMemory(const Value *P) { return getAnalysis<AliasAnalysis>().pointsToConstantMemory(P); } + bool doesNotAccessMemory(CallSite CS) { + return getAnalysis<AliasAnalysis>().doesNotAccessMemory(CS); + } bool doesNotAccessMemory(Function *F) { return getAnalysis<AliasAnalysis>().doesNotAccessMemory(F); } + bool onlyReadsMemory(CallSite CS) { + return getAnalysis<AliasAnalysis>().onlyReadsMemory(CS); + } bool onlyReadsMemory(Function *F) { return getAnalysis<AliasAnalysis>().onlyReadsMemory(F); } diff --git a/lib/Analysis/AliasSetTracker.cpp b/lib/Analysis/AliasSetTracker.cpp index fcdd1b3..1b20c7a 100644 --- a/lib/Analysis/AliasSetTracker.cpp +++ b/lib/Analysis/AliasSetTracker.cpp @@ -114,15 +114,13 @@ void AliasSet::addPointer(AliasSetTracker &AST, HashNodePair &Entry, void AliasSet::addCallSite(CallSite CS, AliasAnalysis &AA) { CallSites.push_back(CS); - if (Function *F = CS.getCalledFunction()) { - AliasAnalysis::ModRefBehavior Behavior = AA.getModRefBehavior(F, CS); - if (Behavior == AliasAnalysis::DoesNotAccessMemory) - return; - else if (Behavior == AliasAnalysis::OnlyReadsMemory) { - AliasTy = MayAlias; - AccessTy |= Refs; - return; - } + AliasAnalysis::ModRefBehavior Behavior = AA.getModRefBehavior(CS); + if (Behavior == AliasAnalysis::DoesNotAccessMemory) + return; + else if (Behavior == AliasAnalysis::OnlyReadsMemory) { + AliasTy = MayAlias; + AccessTy |= Refs; + return; } // FIXME: This should use mod/ref information to make this not suck so bad @@ -166,9 +164,8 @@ bool AliasSet::aliasesPointer(const Value *Ptr, unsigned Size, } bool AliasSet::aliasesCallSite(CallSite CS, AliasAnalysis &AA) const { - if (Function *F = CS.getCalledFunction()) - if (AA.doesNotAccessMemory(F)) - return false; + if (AA.doesNotAccessMemory(CS)) + return false; if (AA.hasNoModRefInfoForCalls()) return true; @@ -297,9 +294,8 @@ bool AliasSetTracker::add(FreeInst *FI) { bool AliasSetTracker::add(CallSite CS) { - if (Function *F = CS.getCalledFunction()) - if (AA.doesNotAccessMemory(F)) - return true; // doesn't alias anything + if (AA.doesNotAccessMemory(CS)) + return true; // doesn't alias anything AliasSet *AS = findAliasSetForCallSite(CS); if (!AS) { @@ -419,9 +415,8 @@ bool AliasSetTracker::remove(FreeInst *FI) { } bool AliasSetTracker::remove(CallSite CS) { - if (Function *F = CS.getCalledFunction()) - if (AA.doesNotAccessMemory(F)) - return false; // doesn't alias anything + if (AA.doesNotAccessMemory(CS)) + return false; // doesn't alias anything AliasSet *AS = findAliasSetForCallSite(CS); if (!AS) return false; @@ -455,13 +450,10 @@ void AliasSetTracker::deleteValue(Value *PtrVal) { // If this is a call instruction, remove the callsite from the appropriate // AliasSet. CallSite CS = CallSite::get(PtrVal); - if (CS.getInstruction()) { - Function *F = CS.getCalledFunction(); - if (!F || !AA.doesNotAccessMemory(F)) { + if (CS.getInstruction()) + if (!AA.doesNotAccessMemory(CS)) if (AliasSet *AS = findAliasSetForCallSite(CS)) AS->removeCallSite(CS); - } - } // First, look up the PointerRec for this pointer. hash_map<Value*, AliasSet::PointerRec>::iterator I = PointerMap.find(PtrVal); diff --git a/lib/Analysis/BasicAliasAnalysis.cpp b/lib/Analysis/BasicAliasAnalysis.cpp index 575e921..5ec9afa 100644 --- a/lib/Analysis/BasicAliasAnalysis.cpp +++ b/lib/Analysis/BasicAliasAnalysis.cpp @@ -839,11 +839,6 @@ BasicAliasAnalysis::getModRefBehavior(Function *F, CallSite CS, return UnknownModRefBehavior; } - if (F->paramHasAttr(0, ParamAttr::ReadNone)) - return DoesNotAccessMemory; - if (F->paramHasAttr(0, ParamAttr::ReadOnly)) - return OnlyReadsMemory; - return UnknownModRefBehavior; } diff --git a/lib/Analysis/IPA/GlobalsModRef.cpp b/lib/Analysis/IPA/GlobalsModRef.cpp index dce4a1e..9e943dd 100644 --- a/lib/Analysis/IPA/GlobalsModRef.cpp +++ b/lib/Analysis/IPA/GlobalsModRef.cpp @@ -394,7 +394,7 @@ void GlobalsModRef::AnalyzeSCC(std::vector<CallGraphNode *> &SCC) { // Okay, if we can't say anything about it, maybe some other alias // analysis can. ModRefBehavior MRB = - AliasAnalysis::getModRefBehavior(Callee, CallSite()); + AliasAnalysis::getModRefBehavior(Callee); if (MRB != DoesNotAccessMemory) { // FIXME: could make this more aggressive for functions that just // read memory. We should just say they read all globals. diff --git a/lib/Analysis/LoadValueNumbering.cpp b/lib/Analysis/LoadValueNumbering.cpp index 3af92bc..67d4dd22 100644 --- a/lib/Analysis/LoadValueNumbering.cpp +++ b/lib/Analysis/LoadValueNumbering.cpp @@ -148,7 +148,7 @@ void LoadVN::getCallEqualNumberNodes(CallInst *CI, Function *CF = CI->getCalledFunction(); if (CF == 0) return; // Indirect call. AliasAnalysis &AA = getAnalysis<AliasAnalysis>(); - AliasAnalysis::ModRefBehavior MRB = AA.getModRefBehavior(CF, CI); + AliasAnalysis::ModRefBehavior MRB = AA.getModRefBehavior(CI); if (MRB != AliasAnalysis::DoesNotAccessMemory && MRB != AliasAnalysis::OnlyReadsMemory) return; // Nothing we can do for now. @@ -227,8 +227,7 @@ void LoadVN::getCallEqualNumberNodes(CallInst *CI, CantEqual = true; break; } else if (CallInst *CI = dyn_cast<CallInst>(I)) { - if (CI->getCalledFunction() == 0 || - !AA.onlyReadsMemory(CI->getCalledFunction())) { + if (!AA.onlyReadsMemory(CI)) { CantEqual = true; break; } diff --git a/lib/Analysis/MemoryDependenceAnalysis.cpp b/lib/Analysis/MemoryDependenceAnalysis.cpp index dd567aa..8c5f216 100644 --- a/lib/Analysis/MemoryDependenceAnalysis.cpp +++ b/lib/Analysis/MemoryDependenceAnalysis.cpp @@ -94,11 +94,9 @@ Instruction* MemoryDependenceAnalysis::getCallSiteDependency(CallSite C, // FreeInsts erase the entire structure pointerSize = ~0UL; - } else if (CallSite::get(QI).getInstruction() != 0 && - cast<CallInst>(QI)->getCalledFunction()) { + } else if (isa<CallInst>(QI)) { AliasAnalysis::ModRefBehavior result = - AA.getModRefBehavior(cast<CallInst>(QI)->getCalledFunction(), - CallSite::get(QI)); + AA.getModRefBehavior(CallSite::get(QI)); if (result != AliasAnalysis::DoesNotAccessMemory && result != AliasAnalysis::OnlyReadsMemory) { if (!start && !block) { |