Update computeArraySize() to use ComputeMultiple() to determine the array size associ...

[oota-llvm.git] / include / llvm / Analysis / AliasAnalysis.h

diff --git a/include/llvm/Analysis/AliasAnalysis.h b/include/llvm/Analysis/AliasAnalysis.h
index efd23e328c8e314d99dd281e2f6718827e142a1d..be7d5ee37b80f1b1b1ba3862a013e38aecbf56f7 100644 (file)
--- a/include/llvm/Analysis/AliasAnalysis.h
+++ b/include/llvm/Analysis/AliasAnalysis.h
@@ -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
@@ -187,12 +190,12 @@ public:
   };
 
   /// 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
@@ -267,13 +270,6 @@ public:
   ///
   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);
@@ -345,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