Introduce and use a new MemDepResult class to hold the results of a memdep

query.  This makes it crystal clear what cases can escape from MemDep that
the clients have to handle.  This also gives the clients a nice simplified
interface to it that is easy to poke at.

This patch also makes DepResultTy and MemoryDependenceAnalysis::DepType
private, yay.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@60231 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 77 insertions, 8 deletions

diff --git a/include/llvm/Analysis/MemoryDependenceAnalysis.h b/include/llvm/Analysis/MemoryDependenceAnalysis.h
index fb4b606..98835f9 100644
--- a/include/llvm/Analysis/MemoryDependenceAnalysis.h
+++ b/include/llvm/Analysis/MemoryDependenceAnalysis.h
@@ -24,13 +24,62 @@ namespace llvm {
   class FunctionPass;
   class Instruction;
   class CallSite;
+  
+  /// MemDepResult - A memory dependence query can return one of three different
+  /// answers:
+  ///   Normal  : The query is dependent on a specific instruction.
+  ///   NonLocal: The query does not depend on anything inside this block, but
+  ///             we haven't scanned beyond the block to find out what.
+  ///   None    : The query does not depend on anything: we found the entry
+  ///             block or the allocation site of the memory.
+  class MemDepResult {
+    enum DepType {
+      Invalid = 0, Normal, NonLocal, None
+    };
+    typedef PointerIntPair<Instruction*, 2, DepType> PairTy;
+    PairTy Value;
+    explicit MemDepResult(PairTy V) : Value(V) {}
+  public:
+    MemDepResult() : Value(0, Invalid) {}
+    
+    /// get methods: These are static ctor methods for creating various
+    /// MemDepResult kinds.
+    static MemDepResult get(Instruction *Inst) {
+      return MemDepResult(PairTy(Inst, Normal));
+    }
+    static MemDepResult getNonLocal() {
+      return MemDepResult(PairTy(0, NonLocal));
+    }
+    static MemDepResult getNone() {
+      return MemDepResult(PairTy(0, None));
+    }
+
+    /// isNormal - Return true if this MemDepResult represents a query that is
+    /// a normal instruction dependency.
+    bool isNormal()          const { return Value.getInt() == Normal; }
+    
+    /// isNonLocal - Return true if this MemDepResult represents an query that
+    /// is transparent to the start of the block, but where a non-local hasn't
+    /// been done.
+    bool isNonLocal()      const { return Value.getInt() == NonLocal; }
+    
+    /// isNone - Return true if this MemDepResult represents a query that
+    /// doesn't depend on any instruction.
+    bool isNone()          const { return Value.getInt() == None; }
+
+    /// getInst() - If this is a normal dependency, return the instruction that
+    /// is depended on.  Otherwise, return null.
+    Instruction *getInst() const { return isNormal() ? Value.getPointer() : 0; }
+    
+    bool operator==(const MemDepResult &M) { return M.Value == Value; }
+    bool operator!=(const MemDepResult &M) { return M.Value != Value; }
+  };
 
   /// MemoryDependenceAnalysis - This is an analysis that determines, for a
   /// given memory operation, what preceding memory operations it depends on.
   /// It builds on alias analysis information, and tries to provide a lazy,
   /// caching interface to a common kind of alias information query.
   class MemoryDependenceAnalysis : public FunctionPass {
-  public:
     /// DepType - This enum is used to indicate what flavor of dependence this
     /// is.  If the type is Normal, there is an associated instruction pointer.
     enum DepType {
@@ -54,7 +103,7 @@ namespace llvm {
       Dirty
     };
     typedef PointerIntPair<Instruction*, 2, DepType> DepResultTy;
-  private:
+
     // A map from instructions to their dependency, with a boolean
     // flags for whether this mapping is confirmed or not.
     typedef DenseMap<Instruction*,
@@ -62,6 +111,7 @@ namespace llvm {
     LocalDepMapType LocalDeps;
 
     // A map from instructions to their non-local dependencies.
+    // FIXME: DENSEMAP of DENSEMAP not a great idea.
     typedef DenseMap<Instruction*,
                      DenseMap<BasicBlock*, DepResultTy> > nonLocalDepMapType;
     nonLocalDepMapType depGraphNonLocal;
@@ -98,14 +148,14 @@ namespace llvm {
     
     /// getDependency - Return the instruction on which a memory operation
     /// depends, starting with start.
-    DepResultTy getDependency(Instruction *query, Instruction *start = 0,
-                              BasicBlock *block = 0);
+    MemDepResult getDependency(Instruction *query, Instruction *start = 0,
+                               BasicBlock *block = 0);
     
     /// getNonLocalDependency - Fills the passed-in map with the non-local 
     /// dependencies of the queries.  The map will contain NonLocal for
     /// blocks between the query and its dependencies.
     void getNonLocalDependency(Instruction* query,
-                               DenseMap<BasicBlock*, DepResultTy> &resp);
+                               DenseMap<BasicBlock*, MemDepResult> &resp);
     
     /// removeInstruction - Remove an instruction from the dependence analysis,
     /// updating the dependence of instructions that previously depended on it.
@@ -117,14 +167,33 @@ namespace llvm {
     void dropInstruction(Instruction *InstToDrop);
     
   private:
+    DepResultTy ConvFromResult(MemDepResult R) {
+      if (Instruction *I = R.getInst())
+        return DepResultTy(I, Normal);
+      if (R.isNonLocal())
+        return DepResultTy(0, NonLocal);
+      assert(R.isNone() && "Unknown MemDepResult!");
+      return DepResultTy(0, None);
+    }
+    
+    MemDepResult ConvToResult(DepResultTy R) {
+      if (R.getInt() == Normal)
+        return MemDepResult::get(R.getPointer());
+      if (R.getInt() == NonLocal)
+        return MemDepResult::getNonLocal();
+      assert(R.getInt() == None && "Unknown MemDepResult!");
+      return MemDepResult::getNone();
+    }
+    
+    
     /// verifyRemoved - Verify that the specified instruction does not occur
     /// in our internal data structures.
     void verifyRemoved(Instruction *Inst) const;
     
-    DepResultTy getCallSiteDependency(CallSite C, Instruction* start,
-                                      BasicBlock* block);
+    MemDepResult getCallSiteDependency(CallSite C, Instruction* start,
+                                       BasicBlock* block);
     void nonLocalHelper(Instruction* query, BasicBlock* block,
-                        DenseMap<BasicBlock*, DepResultTy>& resp);
+                        DenseMap<BasicBlock*, DepResultTy> &resp);
   };
 
 } // End llvm namespace