X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FAnalysis%2FAliasAnalysis.cpp;h=c881ec283a91058f7e5d7885807e827a28e3a960;hb=4c6cb7a2b1fca93742a7751640375854bca762ae;hp=6c8cd54f912d864214ef8eca4922014f92fefe2e;hpb=53ad0edd361c724df623c082a8a37eaf762d1703;p=oota-llvm.git diff --git a/lib/Analysis/AliasAnalysis.cpp b/lib/Analysis/AliasAnalysis.cpp index 6c8cd54f912..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/Constants.h" -#include "llvm/GlobalValue.h" -#include "llvm/Pass.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 { - const AliasAnalysis &AA; - const Value *Ptr; - - CanModify(const 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) { - assert(!SI.hasIndices() && "Only support stores without indexing!"); - 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,94 +56,74 @@ 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. -// -bool AliasAnalysis::canBasicBlockModify(const BasicBlock &bb, - const Value *Ptr) const { - CanModify CM(this, Ptr); - BasicBlock &BB = const_cast(bb); +/// setTargetData - Subclasses must call this method to initialize the +/// AliasAnalysis interface before any other methods are called. +/// +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 -// of the specified instructions to modify the value pointed to by Ptr. The -// instructions to consider are all of the instructions in the range of [I1,I2] -// INCLUSIVE. I1 and I2 must be in the same basic block. -// +/// canInstructionRangeModify - Return true if it is possible for the execution +/// of the specified instructions to modify the value pointed to by Ptr. The +/// instructions to consider are all of the instructions in the range of [I1,I2] +/// INCLUSIVE. I1 and I2 must be in the same basic block. +/// bool AliasAnalysis::canInstructionRangeModify(const Instruction &I1, const Instruction &I2, - const Value *Ptr) const { + 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); -} - -AliasAnalysis::Result BasicAliasAnalysis::alias(const Value *V1, - const Value *V2) const { - // 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())) - return NoAlias; // Scalars cannot alias each other - - bool V1Unique = hasUniqueAddress(V1); - bool V2Unique = hasUniqueAddress(V2); - - if (V1Unique && V2Unique) - return NoAlias; // Can't alias if they are different unique values - - if ((V1Unique && isa(V2)) || - (V2Unique && isa(V1))) - return NoAlias; // Unique values don't alias null - - // TODO: Handle getelementptr with nonzero offset - - return MayAlias; -} +} // End llvm namespace