[llvm-commits] CVS: llvm/include/llvm/Analysis/ScalarEvolution.h ScalarEvolutionExpressions.h

[Chris Lattner]

Changes in directory llvm/include/llvm/Analysis:

ScalarEvolution.h updated: 1.7 -> 1.8
ScalarEvolutionExpressions.h updated: 1.3 -> 1.4
---
Log message:

Add a new replaceSymbolicValuesWithConcrete method to the SCEV class,
adjust const'ness a bit to be more correct.


---
Diffs of the changes:  (+59 -5)

 ScalarEvolution.h            |   21 ++++++++++++++++-----
 ScalarEvolutionExpressions.h |   43 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+), 5 deletions(-)


Index: llvm/include/llvm/Analysis/ScalarEvolution.h
diff -u llvm/include/llvm/Analysis/ScalarEvolution.h:1.7 llvm/include/llvm/Analysis/ScalarEvolution.h:1.8
--- llvm/include/llvm/Analysis/ScalarEvolution.h:1.7	Mon Dec  6 22:03:45 2004
+++ llvm/include/llvm/Analysis/ScalarEvolution.h	Sat Feb 12 22:34:51 2005
@@ -38,11 +38,11 @@
   ///
   class SCEV {
     const unsigned SCEVType;      // The SCEV baseclass this node corresponds to
-    unsigned RefCount;
+    mutable unsigned RefCount;
 
     friend class SCEVHandle;
-    void addRef() { ++RefCount; }
-    void dropRef() {
+    void addRef() const { ++RefCount; }
+    void dropRef() const {
       if (--RefCount == 0)
         delete this;
     }
@@ -74,6 +74,15 @@
     ///
     virtual const Type *getType() const = 0;
 
+    /// replaceSymbolicValuesWithConcrete - If this SCEV internally references
+    /// the symbolic value "Sym", construct and return a new SCEV that produces
+    /// the same value, but which uses the concrete value Conc instead of the
+    /// symbolic value.  If this SCEV does not use the symbolic value, it
+    /// returns itself.
+    virtual SCEVHandle 
+    replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
+                                      const SCEVHandle &Conc) const = 0;
+
     /// print - Print out the internal representation of this scalar to the
     /// specified stream.  This should really only be used for debugging
     /// purposes.
@@ -102,7 +111,9 @@
     virtual const Type *getType() const;
     virtual bool hasComputableLoopEvolution(const Loop *L) const;
     virtual void print(std::ostream &OS) const;
-
+    virtual SCEVHandle 
+    replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
+                                      const SCEVHandle &Conc) const;
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     static inline bool classof(const SCEVCouldNotCompute *S) { return true; }
@@ -115,7 +126,7 @@
     SCEV *S;
     SCEVHandle();  // DO NOT IMPLEMENT
   public:
-    SCEVHandle(SCEV *s) : S(s) {
+    SCEVHandle(const SCEV *s) : S(const_cast<SCEV*>(s)) {
       assert(S && "Cannot create a handle to a null SCEV!");
       S->addRef();
     }


Index: llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h
diff -u llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h:1.3 llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h:1.4
--- llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h:1.3	Tue Apr 27 13:21:56 2004
+++ llvm/include/llvm/Analysis/ScalarEvolutionExpressions.h	Sat Feb 12 22:34:51 2005
@@ -56,6 +56,11 @@
 
     virtual const Type *getType() const;
 
+    SCEVHandle replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
+                                                 const SCEVHandle &Conc) const {
+      return this;
+    }
+
     virtual void print(std::ostream &OS) const;
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -90,6 +95,14 @@
       return Op->hasComputableLoopEvolution(L);
     }
 
+    SCEVHandle replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
+                                                 const SCEVHandle &Conc) const {
+      SCEVHandle H = Op->replaceSymbolicValuesWithConcrete(Sym, Conc);
+      if (H == Op)
+        return this;
+      return get(H, Ty);
+    }
+
     /// getValueRange - Return the tightest constant bounds that this value is
     /// known to have.  This method is only valid on integer SCEV objects.
     virtual ConstantRange getValueRange() const;
@@ -132,6 +145,14 @@
     /// known to have.  This method is only valid on integer SCEV objects.
     virtual ConstantRange getValueRange() const;
 
+    SCEVHandle replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
+                                                 const SCEVHandle &Conc) const {
+      SCEVHandle H = Op->replaceSymbolicValuesWithConcrete(Sym, Conc);
+      if (H == Op)
+        return this;
+      return get(H, Ty);
+    }
+
     virtual void print(std::ostream &OS) const;
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -182,6 +203,9 @@
       return false;
     }
 
+    SCEVHandle replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
+                                                 const SCEVHandle &Conc) const;
+
     virtual const char *getOperationStr() const = 0;
 
     virtual const Type *getType() const { return getOperand(0)->getType(); }
@@ -286,6 +310,17 @@
              RHS->hasComputableLoopEvolution(L);
     }
 
+    SCEVHandle replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
+                                                 const SCEVHandle &Conc) const {
+      SCEVHandle L = LHS->replaceSymbolicValuesWithConcrete(Sym, Conc);
+      SCEVHandle R = RHS->replaceSymbolicValuesWithConcrete(Sym, Conc);
+      if (L == LHS && R == RHS)
+        return this;
+      else
+        return get(L, R);
+    }
+
+
     virtual const Type *getType() const;
 
     void print(std::ostream &OS) const;
@@ -383,6 +418,8 @@
     /// returned.
     SCEVHandle getNumIterationsInRange(ConstantRange Range) const;
 
+    SCEVHandle replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
+                                                 const SCEVHandle &Conc) const;
 
     virtual void print(std::ostream &OS) const;
 
@@ -420,6 +457,12 @@
       return false; // not computable
     }
 
+    SCEVHandle replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
+                                                 const SCEVHandle &Conc) const {
+      if (&*Sym == this) return Conc;
+      return this;
+    }
+
     virtual const Type *getType() const;
 
     virtual void print(std::ostream &OS) const;