X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAnalysis%2FAliasAnalysis.cpp;h=c881ec283a91058f7e5d7885807e827a28e3a960;hb=f325e3981ee8e80ce6ab441e1c42d5cd0ba2b0fe;hp=98577c8dc410dd89148aeb6c9e2fc4c769648a2a;hpb=75310d59c979f2c281427fcc59709bb375a7379f;p=oota-llvm.git diff --git a/lib/Analysis/AliasAnalysis.cpp b/lib/Analysis/AliasAnalysis.cpp index 98577c8dc41..c881ec283a9 100644 --- a/lib/Analysis/AliasAnalysis.cpp +++ b/lib/Analysis/AliasAnalysis.cpp @@ -1,4 +1,11 @@ //===- 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,31 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Analysis/BasicAliasAnalysis.h" +#include "llvm/Analysis/AliasAnalysis.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/Target/TargetData.h" -// Register the AliasAnalysis interface, providing a nice name to refer to. -static RegisterAnalysisGroup X("Alias Analysis"); +namespace llvm { -// CanModify - Define a little visitor class that is used to check to see if -// arbitrary chunks of code can modify a specified pointer. -// +// Register the AliasAnalysis interface, providing a nice name to refer to. namespace { - struct CanModify : public InstVisitor { - AliasAnalysis &AA; - const Value *Ptr; - - CanModify(AliasAnalysis *aa, const Value *ptr) - : AA(*aa), Ptr(ptr) {} + RegisterAnalysisGroup Z("Alias Analysis"); +} - 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)); - } +AliasAnalysis::ModRefResult +AliasAnalysis::getModRefInfo(LoadInst *L, Value *P, unsigned Size) { + return alias(L->getOperand(0), TD->getTypeSize(L->getType()), + P, Size) ? Ref : NoModRef; +} - // Other instructions do not alias anything. - bool visitInstruction(Instruction &I) { return false; } - }; +AliasAnalysis::ModRefResult +AliasAnalysis::getModRefInfo(StoreInst *S, Value *P, unsigned Size) { + return alias(S->getOperand(1), TD->getTypeSize(S->getOperand(0)->getType()), + P, Size) ? Mod : NoModRef; } + // AliasAnalysis destructor: DO NOT move this to the header file for // AliasAnalysis or else clients of the AliasAnalysis class may not depend on // the AliasAnalysis.o file in the current .a file, causing alias analysis @@ -62,19 +56,26 @@ 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(); +} - 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. +} - 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 @@ -84,138 +85,45 @@ 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. +// 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. // +extern void BasicAAStub(); +static IncludeFile INCLUDE_BASICAA_CPP((void*)&BasicAAStub); + + namespace { + struct NoAA : public ImmutablePass, public AliasAnalysis { + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AliasAnalysis::getAnalysisUsage(AU); + } + + virtual void initializePass() { + InitializeAliasAnalysis(this); + } + }; + // Register this pass... - RegisterOpt - X("basicaa", "Basic Alias Analysis (default AA impl)"); + RegisterOpt + X("no-aa", "No Alias Analysis (always returns 'may' alias)"); // Declare that we implement the AliasAnalysis interface - RegisterAnalysisGroup Y; + 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(I->getOperand(0), V1); - - // 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(1)) != 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 - } - - return MayAlias; -} +} // End llvm namespace