Teach BasicAA::getModRefInfo(CallSite, CallSite) some

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

diff --git a/include/llvm/Analysis/MemoryDependenceAnalysis.h b/include/llvm/Analysis/MemoryDependenceAnalysis.h
index f46a2862bff8347ee60abe256de4097db99c140c..ceed0ab54469d3ec8b343336db6867b1c99375a9 100644 (file)
--- a/include/llvm/Analysis/MemoryDependenceAnalysis.h
+++ b/include/llvm/Analysis/MemoryDependenceAnalysis.h
@@ -18,6 +18,7 @@
 #include "llvm/Pass.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/PointerIntPair.h"
 
 namespace llvm {
@@ -28,6 +29,7 @@ namespace llvm {
   class AliasAnalysis;
   class TargetData;
   class MemoryDependenceAnalysis;
+  class PredIteratorCache;
   
   /// MemDepResult - A memory dependence query can return one of three different
   /// answers, described below.
@@ -169,8 +171,6 @@ namespace llvm {
     ReverseNonLocalPtrDepTy ReverseNonLocalPtrDeps;
 
     
-    
-    
     /// PerInstNLInfo - This is the instruction we keep for each cached access
     /// that we have for an instruction.  The pointer is an owning pointer and
     /// the bool indicates whether we have any dirty bits in the set.
@@ -193,23 +193,18 @@ namespace llvm {
     /// Current AA implementation, just a cache.
     AliasAnalysis *AA;
     TargetData *TD;
+    OwningPtr<PredIteratorCache> PredCache;
   public:
-    MemoryDependenceAnalysis() : FunctionPass(&ID) {}
+    MemoryDependenceAnalysis();
+    ~MemoryDependenceAnalysis();
     static char ID;
 
     /// Pass Implementation stuff.  This doesn't do any analysis eagerly.
     bool runOnFunction(Function &);
     
     /// Clean up memory in between runs
-    void releaseMemory() {
-      LocalDeps.clear();
-      NonLocalDeps.clear();
-      NonLocalPointerDeps.clear();
-      ReverseLocalDeps.clear();
-      ReverseNonLocalDeps.clear();
-      ReverseNonLocalPtrDeps.clear();
-    }
-
+    void releaseMemory();
+    
     /// getAnalysisUsage - Does not modify anything.  It uses Value Numbering
     /// and Alias Analysis.
     ///
@@ -220,8 +215,8 @@ namespace llvm {
     /// this on non-memory instructions.
     MemDepResult getDependency(Instruction *QueryInst);
 
-    /// getNonLocalDependency - Perform a full dependency query for the
-    /// specified instruction, returning the set of blocks that the value is
+    /// getNonLocalCallDependency - Perform a full dependency query for the
+    /// specified call, returning the set of blocks that the value is
     /// potentially live across.  The returned set of results will include a
     /// "NonLocal" result for all blocks where the value is live across.
     ///
@@ -232,7 +227,7 @@ namespace llvm {
     /// invalidated on the next non-local query or when an instruction is
     /// removed.  Clients must copy this data if they want it around longer than
     /// that.
-    const NonLocalDepInfo &getNonLocalDependency(Instruction *QueryInst);
+    const NonLocalDepInfo &getNonLocalCallDependency(CallSite QueryCS);
     
     
     /// getNonLocalPointerDependency - Perform a full dependency query for an
@@ -253,13 +248,19 @@ namespace llvm {
                                           bool isLoad, 
                                           BasicBlock::iterator ScanIt,
                                           BasicBlock *BB);
-    MemDepResult getCallSiteDependencyFrom(CallSite C,
+    MemDepResult getCallSiteDependencyFrom(CallSite C, bool isReadOnlyCall,
                                            BasicBlock::iterator ScanIt,
                                            BasicBlock *BB);
-    void getNonLocalPointerDepInternal(Value *Pointer, uint64_t Size,
-                                       bool isLoad, BasicBlock *BB,
-                                      SmallVectorImpl<NonLocalDepEntry> &Result,
-                                       SmallPtrSet<BasicBlock*, 64> &Visited);
+    void getNonLocalPointerDepFromBB(Value *Pointer, uint64_t Size,
+                                     bool isLoad, BasicBlock *BB,
+                                     SmallVectorImpl<NonLocalDepEntry> &Result,
+                                     SmallPtrSet<BasicBlock*, 64> &Visited);
+    MemDepResult GetNonLocalInfoForBlock(Value *Pointer, uint64_t PointeeSize,
+                                         bool isLoad, BasicBlock *BB,
+                                         NonLocalDepInfo *Cache,
+                                         unsigned NumSortedEntries);
+
+    
     void RemoveCachedNonLocalPointerDependencies(ValueIsLoadPair P);
     
     /// verifyRemoved - Verify that the specified instruction does not occur