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.
+ /// directly (using AliasAnalysis::getAnalysisUsage(AU)).
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
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...
// 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 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 use the Info parameter of getModRefBehavior to get specific
};
/// getModRefBehavior - Return the behavior when calling the given call site.
- ModRefBehavior getModRefBehavior(CallSite CS,
+ virtual ModRefBehavior getModRefBehavior(CallSite CS,
std::vector<PointerAccessInfo> *Info = 0);
/// getModRefBehavior - Return the behavior when calling the given function.
/// For use when the call site is not known.
- ModRefBehavior getModRefBehavior(Function *F,
+ virtual ModRefBehavior getModRefBehavior(Function *F,
std::vector<PointerAccessInfo> *Info = 0);
/// doesNotAccessMemory - If the specified call is known to never read or
///
virtual bool hasNoModRefInfoForCalls() const;
-protected:
- /// 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<PointerAccessInfo> *Info = 0);
-
public:
/// Convenience functions...
ModRefResult getModRefInfo(LoadInst *L, Value *P, unsigned Size);
}
};
+/// 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