X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAnalysis%2FAliasAnalysis.cpp;h=5ae2342404557b25d3641f9642948989a7499dff;hb=9a2f93121b31bf6345d1552bdc43037f89714d86;hp=57867dd6eedd5466949419308d1fb1b0e0aeb907;hpb=762d2f0897a453bab92800b7aaadb0872e98aabd;p=oota-llvm.git diff --git a/lib/Analysis/AliasAnalysis.cpp b/lib/Analysis/AliasAnalysis.cpp index 57867dd6eed..5ae23424045 100644 --- a/lib/Analysis/AliasAnalysis.cpp +++ b/lib/Analysis/AliasAnalysis.cpp @@ -1,5 +1,12 @@ //===- AliasAnalysis.cpp - Generic Alias Analysis Interface Implementation -==// // +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// // This file implements the generic AliasAnalysis interface which is used as the // common interface used by all clients and implementations of alias analysis. // @@ -17,44 +24,113 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Analysis/BasicAliasAnalysis.h" +#include "llvm/Analysis/AliasAnalysis.h" +#include "llvm/Pass.h" #include "llvm/BasicBlock.h" -#include "llvm/Support/InstVisitor.h" -#include "llvm/iMemory.h" -#include "llvm/iOther.h" -#include "llvm/Constants.h" -#include "llvm/GlobalValue.h" -#include "llvm/DerivedTypes.h" +#include "llvm/Instructions.h" +#include "llvm/Type.h" +#include "llvm/Target/TargetData.h" +using namespace llvm; // Register the AliasAnalysis interface, providing a nice name to refer to. namespace { RegisterAnalysisGroup Z("Alias Analysis"); } +char AliasAnalysis::ID = 0; -// CanModify - Define a little visitor class that is used to check to see if -// arbitrary chunks of code can modify a specified pointer. -// -namespace { - struct CanModify : public InstVisitor { - AliasAnalysis &AA; - const Value *Ptr; +//===----------------------------------------------------------------------===// +// Default chaining methods +//===----------------------------------------------------------------------===// + +AliasAnalysis::AliasResult +AliasAnalysis::alias(const Value *V1, unsigned V1Size, + const Value *V2, unsigned V2Size) { + assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!"); + return AA->alias(V1, V1Size, V2, V2Size); +} + +void AliasAnalysis::getMustAliases(Value *P, std::vector &RetVals) { + assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!"); + return AA->getMustAliases(P, RetVals); +} + +bool AliasAnalysis::pointsToConstantMemory(const Value *P) { + assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!"); + return AA->pointsToConstantMemory(P); +} + +AliasAnalysis::ModRefBehavior +AliasAnalysis::getModRefBehavior(Function *F, CallSite CS, + std::vector *Info) { + assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!"); + return AA->getModRefBehavior(F, CS, Info); +} + +bool AliasAnalysis::hasNoModRefInfoForCalls() const { + assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!"); + return AA->hasNoModRefInfoForCalls(); +} + +void AliasAnalysis::deleteValue(Value *V) { + assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!"); + AA->deleteValue(V); +} + +void AliasAnalysis::copyValue(Value *From, Value *To) { + assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!"); + AA->copyValue(From, To); +} + +AliasAnalysis::ModRefResult +AliasAnalysis::getModRefInfo(CallSite CS1, CallSite CS2) { + // FIXME: we can do better. + assert(AA && "AA didn't call InitializeAliasAnalysis in its run method!"); + return AA->getModRefInfo(CS1, CS2); +} + + +//===----------------------------------------------------------------------===// +// AliasAnalysis non-virtual helper method implementation +//===----------------------------------------------------------------------===// + +AliasAnalysis::ModRefResult +AliasAnalysis::getModRefInfo(LoadInst *L, Value *P, unsigned Size) { + return alias(L->getOperand(0), TD->getTypeSize(L->getType()), + P, Size) ? Ref : NoModRef; +} + +AliasAnalysis::ModRefResult +AliasAnalysis::getModRefInfo(StoreInst *S, Value *P, unsigned Size) { + // If the stored address cannot alias the pointer in question, then the + // pointer cannot be modified by the store. + if (!alias(S->getOperand(1), TD->getTypeSize(S->getOperand(0)->getType()), + P, Size)) + return NoModRef; + + // If the pointer is a pointer to constant memory, then it could not have been + // modified by this store. + return pointsToConstantMemory(P) ? NoModRef : Mod; +} - CanModify(AliasAnalysis *aa, const Value *ptr) - : AA(*aa), Ptr(ptr) {} +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; + } + + if (!AA) return Mask; - bool visitInvokeInst(InvokeInst &II) { - return AA.canInvokeModify(II, Ptr); - } - bool visitCallInst(CallInst &CI) { - return AA.canCallModify(CI, Ptr); - } - bool visitStoreInst(StoreInst &SI) { - return AA.alias(Ptr, SI.getOperand(1)); - } + // If P points to a constant memory location, the call definitely could not + // modify the memory location. + if ((Mask & Mod) && AA->pointsToConstantMemory(P)) + Mask = ModRefResult(Mask & ~Mod); - // Other instructions do not alias anything. - bool visitInstruction(Instruction &I) { return false; } - }; + return ModRefResult(Mask & AA->getModRefInfo(CS, P, Size)); } // AliasAnalysis destructor: DO NOT move this to the header file for @@ -64,19 +140,28 @@ namespace { // AliasAnalysis::~AliasAnalysis() {} -/// canBasicBlockModify - Return true if it is possible for execution of the -/// specified basic block to modify the value pointed to by Ptr. +/// setTargetData - Subclasses must call this method to initialize the +/// AliasAnalysis interface before any other methods are called. /// -bool AliasAnalysis::canBasicBlockModify(const BasicBlock &bb, - const Value *Ptr) { - CanModify CM(this, Ptr); - BasicBlock &BB = const_cast(bb); +void AliasAnalysis::InitializeAliasAnalysis(Pass *P) { + TD = &P->getAnalysis(); + AA = &P->getAnalysis(); +} - for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I) - if (CM.visit(I)) // Check every instruction in the basic block... - return true; +// getAnalysisUsage - All alias analysis implementations should invoke this +// directly (using AliasAnalysis::getAnalysisUsage(AU)) to make sure that +// TargetData is required by the pass. +void AliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequired(); // All AA's need TargetData. + AU.addRequired(); // All AA's chain +} - return false; +/// canBasicBlockModify - Return true if it is possible for execution of the +/// specified basic block to modify the value pointed to by Ptr. +/// +bool AliasAnalysis::canBasicBlockModify(const BasicBlock &BB, + const Value *Ptr, unsigned Size) { + return canInstructionRangeModify(BB.front(), BB.back(), Ptr, Size); } /// canInstructionRangeModify - Return true if it is possible for the execution @@ -86,156 +171,21 @@ bool AliasAnalysis::canBasicBlockModify(const BasicBlock &bb, /// bool AliasAnalysis::canInstructionRangeModify(const Instruction &I1, const Instruction &I2, - const Value *Ptr) { + const Value *Ptr, unsigned Size) { assert(I1.getParent() == I2.getParent() && "Instructions not in same basic block!"); - CanModify CM(this, Ptr); BasicBlock::iterator I = const_cast(&I1); BasicBlock::iterator E = const_cast(&I2); ++E; // Convert from inclusive to exclusive range. - for (; I != E; ++I) - if (CM.visit(I)) // Check every instruction in the basic block... + for (; I != E; ++I) // Check every instruction in range + if (getModRefInfo(I, const_cast(Ptr), Size) & Mod) return true; - return false; } -//===----------------------------------------------------------------------===// -// BasicAliasAnalysis Pass Implementation -//===----------------------------------------------------------------------===// -// -// Because of the way .a files work, the implementation of the -// BasicAliasAnalysis class MUST be in the AliasAnalysis file itself, or else we -// run the risk of AliasAnalysis being used, but the default implementation not -// being linked into the tool that uses it. As such, we register and implement -// the class here. -// -namespace { - // Register this pass... - RegisterOpt - X("basicaa", "Basic Alias Analysis (default AA impl)"); - - // Declare that we implement the AliasAnalysis interface - RegisterAnalysisGroup Y; -} // End of anonymous namespace - - - -// hasUniqueAddress - Return true if the -static inline bool hasUniqueAddress(const Value *V) { - return isa(V) || isa(V) || isa(V); -} - -static const Value *getUnderlyingObject(const Value *V) { - if (!isa(V->getType())) return 0; - - // If we are at some type of object... return it. - if (hasUniqueAddress(V)) return V; - - // Traverse through different addressing mechanisms... - if (const Instruction *I = dyn_cast(V)) { - if (isa(I) || isa(I)) - return getUnderlyingObject(I->getOperand(0)); - } - return 0; -} - - -// alias - Provide a bunch of ad-hoc rules to disambiguate in common cases, such -// as array references. Note that this function is heavily tail recursive. -// Hopefully we have a smart C++ compiler. :) -// -AliasAnalysis::Result BasicAliasAnalysis::alias(const Value *V1, - const Value *V2) { - // Strip off constant pointer refs if they exist - if (const ConstantPointerRef *CPR = dyn_cast(V1)) - V1 = CPR->getValue(); - if (const ConstantPointerRef *CPR = dyn_cast(V2)) - V2 = CPR->getValue(); - - // Are we checking for alias of the same value? - if (V1 == V2) return MustAlias; - - if ((!isa(V1->getType()) || !isa(V2->getType())) && - V1->getType() != Type::LongTy && V2->getType() != Type::LongTy) - return NoAlias; // Scalars cannot alias each other - - // Strip off cast instructions... - if (const Instruction *I = dyn_cast(V1)) - return alias(I->getOperand(0), V2); - if (const Instruction *I = dyn_cast(V2)) - return alias(V1, I->getOperand(0)); - - // If we have two gep instructions with identical indices, return an alias - // result equal to the alias result of the original pointer... - // - if (const GetElementPtrInst *GEP1 = dyn_cast(V1)) - if (const GetElementPtrInst *GEP2 = dyn_cast(V2)) - if (GEP1->getNumOperands() == GEP2->getNumOperands() && - GEP1->getOperand(0)->getType() == GEP2->getOperand(0)->getType()) { - if (std::equal(GEP1->op_begin()+1, GEP1->op_end(), GEP2->op_begin()+1)) - return alias(GEP1->getOperand(0), GEP2->getOperand(0)); - - // If all of the indexes to the getelementptr are constant, but - // different (well we already know they are different), then we know - // that there cannot be an alias here if the two base pointers DO alias. - // - bool AllConstant = true; - for (unsigned i = 1, e = GEP1->getNumOperands(); i != e; ++i) - if (!isa(GEP1->getOperand(i)) || - !isa(GEP2->getOperand(i))) { - AllConstant = false; - break; - } - - // If we are all constant, then look at where the the base pointers - // alias. If they are known not to alias, then we are dealing with two - // different arrays or something, so no alias is possible. If they are - // known to be the same object, then we cannot alias because we are - // indexing into a different part of the object. As usual, MayAlias - // doesn't tell us anything. - // - if (AllConstant && - alias(GEP1->getOperand(0), GEP2->getOperand(0)) != MayAlias) - return NoAlias; - } - - // Figure out what objects these things are pointing to if we can... - const Value *O1 = getUnderlyingObject(V1); - const Value *O2 = getUnderlyingObject(V2); - - // Pointing at a discernable object? - if (O1 && O2) { - // If they are two different objects, we know that we have no alias... - if (O1 != O2) return NoAlias; - - // If they are the same object, they we can look at the indexes. If they - // index off of the object is the same for both pointers, they must alias. - // If they are provably different, they must not alias. Otherwise, we can't - // tell anything. - } else if (O1 && isa(V2)) { - return NoAlias; // Unique values don't alias null - } else if (O2 && isa(V1)) { - return NoAlias; // Unique values don't alias null - } - - // Check to see if these two pointers are related by a getelementptr - // instruction. If one pointer is a GEP with a non-zero index of the other - // pointer, we know they cannot alias. - // - if (isa(V2)) - std::swap(V1, V2); - - if (const GetElementPtrInst *GEP = dyn_cast(V1)) - if (GEP->getOperand(0) == V2) { - // If there is at least one non-zero constant index, we know they cannot - // alias. - for (unsigned i = 1, e = GEP->getNumOperands(); i != e; ++i) - if (const Constant *C = dyn_cast(GEP->getOperand(i))) - if (!C->isNullValue()) - return NoAlias; - } - - return MayAlias; -} +// Because of the way .a files work, we must force the BasicAA implementation to +// be pulled in if the AliasAnalysis classes are pulled in. Otherwise we run +// the risk of AliasAnalysis being used, but the default implementation not +// being linked into the tool that uses it. +DEFINING_FILE_FOR(AliasAnalysis)