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 061517a2891a5bc6e710834a62be377aa08e832a..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.
@@ -158,7 +160,8 @@ namespace llvm {
     /// CachedNonLocalPointerInfo - This map stores the cached results of doing
     /// a pointer lookup at the bottom of a block.  The key of this map is the
     /// pointer+isload bit, the value is a list of <bb->result> mappings.
-    typedef DenseMap<ValueIsLoadPair, NonLocalDepInfo>CachedNonLocalPointerInfo;
+    typedef DenseMap<ValueIsLoadPair,
+      std::pair<BasicBlock*, NonLocalDepInfo> > CachedNonLocalPointerInfo;
     CachedNonLocalPointerInfo NonLocalPointerDeps;
 
     // A map from instructions to their non-local pointer dependencies.
@@ -168,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.
@@ -192,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.
     ///
@@ -219,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.
     ///
@@ -231,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
@@ -252,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