X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAnalysis%2FAliasAnalysis.h;h=be7d5ee37b80f1b1b1ba3862a013e38aecbf56f7;hb=c6f69e94fa46f585b59bb9d7ace3224b0e638c95;hp=42094167052a613c1b6a949ad89902123bf5e2ea;hpb=1ef14f6e768eac76fc272320e79bdbd90747ef47;p=oota-llvm.git diff --git a/include/llvm/Analysis/AliasAnalysis.h b/include/llvm/Analysis/AliasAnalysis.h index 42094167052..be7d5ee37b8 100644 --- a/include/llvm/Analysis/AliasAnalysis.h +++ b/include/llvm/Analysis/AliasAnalysis.h @@ -2,8 +2,8 @@ // // 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 is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -55,9 +55,8 @@ protected: /// void InitializeAliasAnalysis(Pass *P); - // getAnalysisUsage - All alias analysis implementations should invoke this - // directly (using AliasAnalysis::getAnalysisUsage(AU)) to make sure that - // TargetData is required by the pass. + /// getAnalysisUsage - All alias analysis implementations should invoke this + /// directly (using AliasAnalysis::getAnalysisUsage(AU)). virtual void getAnalysisUsage(AnalysisUsage &AU) const; public: @@ -65,11 +64,15 @@ public: AliasAnalysis() : TD(0), AA(0) {} virtual ~AliasAnalysis(); // We want to be subclassed - /// getTargetData - Every alias analysis implementation depends on the size of - /// data items in the current Target. This provides a uniform way to handle - /// it. + /// getTargetData - Return a pointer to the current TargetData object, or + /// null if no TargetData object is available. /// - const TargetData &getTargetData() const { return *TD; } + const TargetData *getTargetData() const { return TD; } + + /// getTypeStoreSize - Return the TargetData store size for the given type, + /// if known, or a conservative value otherwise. + /// + unsigned getTypeStoreSize(const Type *Ty); //===--------------------------------------------------------------------===// /// Alias Queries... @@ -126,19 +129,19 @@ public: // This property corresponds to the GCC 'const' attribute. DoesNotAccessMemory, - // AccessesArguments - This function accesses function arguments in - // non-volatile and well known ways, but does not access any other memory. + // AccessesArguments - This function accesses function arguments in well + // known (possibly volatile) ways, but does not access any other memory. // - // Clients may call getArgumentAccesses to get specific information about - // how pointer arguments are used. + // Clients may use the Info parameter of getModRefBehavior to get specific + // information about how pointer arguments are used. AccessesArguments, // AccessesArgumentsAndGlobals - This function has accesses function - // arguments and global variables in non-volatile and well-known ways, but + // arguments and global variables well known (possibly volatile) ways, but // does not access any other memory. // - // Clients may call getArgumentAccesses to get specific information about - // how pointer arguments and globals are used. + // Clients may use the Info parameter of getModRefBehavior to get specific + // information about how pointer arguments are used. AccessesArgumentsAndGlobals, // OnlyReadsMemory - This function does not perform any non-local stores or @@ -186,40 +189,57 @@ public: }; }; - /// getModRefBehavior - Return the behavior of the specified function if - /// called from the specified call site. The call site may be null in which - /// case the most generic behavior of this function should be returned. - virtual ModRefBehavior getModRefBehavior(Function *F, CallSite CS, - std::vector *Info = 0); + /// getModRefBehavior - Return the behavior when calling the given call site. + virtual ModRefBehavior getModRefBehavior(CallSite CS, + std::vector *Info = 0); - /// doesNotAccessMemory - If the specified function is known to never read or - /// write memory, return true. If the function only reads from known-constant - /// memory, it is also legal to return true. Functions that unwind the stack - /// are not legal for this predicate. + /// getModRefBehavior - Return the behavior when calling the given function. + /// For use when the call site is not known. + virtual ModRefBehavior getModRefBehavior(Function *F, + std::vector *Info = 0); + + /// doesNotAccessMemory - If the specified call is known to never read or + /// write memory, return true. If the call only reads from known-constant + /// memory, it is also legal to return true. Calls that unwind the stack + /// are legal for this predicate. /// - /// Many optimizations (such as CSE and LICM) can be performed on calls to it, - /// without worrying about aliasing properties, and many functions have this - /// property (e.g. 'sin' and 'cos'). + /// Many optimizations (such as CSE and LICM) can be performed on such calls + /// without worrying about aliasing properties, and many calls have this + /// property (e.g. calls to 'sin' and 'cos'). /// /// This property corresponds to the GCC 'const' attribute. /// + bool doesNotAccessMemory(CallSite CS) { + return getModRefBehavior(CS) == DoesNotAccessMemory; + } + + /// doesNotAccessMemory - If the specified function is known to never read or + /// write memory, return true. For use when the call site is not known. + /// bool doesNotAccessMemory(Function *F) { - return getModRefBehavior(F, CallSite()) == DoesNotAccessMemory; + return getModRefBehavior(F) == DoesNotAccessMemory; } - /// onlyReadsMemory - If the specified function is known to only read from - /// non-volatile memory (or not access memory at all), return true. Functions - /// that unwind the stack are not legal for this predicate. + /// onlyReadsMemory - If the specified call is known to only read from + /// non-volatile memory (or not access memory at all), return true. Calls + /// that unwind the stack are legal for this predicate. /// /// This property allows many common optimizations to be performed in the /// absence of interfering store instructions, such as CSE of strlen calls. /// /// This property corresponds to the GCC 'pure' attribute. /// + bool onlyReadsMemory(CallSite CS) { + ModRefBehavior MRB = getModRefBehavior(CS); + return MRB == DoesNotAccessMemory || MRB == OnlyReadsMemory; + } + + /// onlyReadsMemory - If the specified function is known to only read from + /// non-volatile memory (or not access memory at all), return true. For use + /// when the call site is not known. + /// bool onlyReadsMemory(Function *F) { - /// FIXME: If the analysis returns more precise info, we can reduce it to - /// this. - ModRefBehavior MRB = getModRefBehavior(F, CallSite()); + ModRefBehavior MRB = getModRefBehavior(F); return MRB == DoesNotAccessMemory || MRB == OnlyReadsMemory; } @@ -250,6 +270,7 @@ public: /// virtual bool hasNoModRefInfoForCalls() const; +public: /// Convenience functions... ModRefResult getModRefInfo(LoadInst *L, Value *P, unsigned Size); ModRefResult getModRefInfo(StoreInst *S, Value *P, unsigned Size); @@ -320,6 +341,19 @@ public: } }; +/// isNoAliasCall - Return true if this pointer is returned by a noalias +/// function. +bool isNoAliasCall(const Value *V); + +/// isIdentifiedObject - Return true if this pointer refers to a distinct and +/// identifiable object. This returns true for: +/// Global Variables and Functions (but not Global Aliases) +/// Allocas and Mallocs +/// ByVal and NoAlias Arguments +/// NoAlias returns +/// +bool isIdentifiedObject(const Value *V); + } // End llvm namespace // Because of the way .a files work, we must force the BasicAA implementation to