From afc0dc7184cf73ff7ac64e516284fbe0c7023ba4 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 13 Feb 2005 04:34:51 +0000 Subject: [PATCH] Add a new replaceSymbolicValuesWithConcrete method to the SCEV class, adjust const'ness a bit to be more correct. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@20145 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/ScalarEvolution.h | 21 ++++++++--- include/llvm/Analysis/ScalarEvolutionExpressions.h | 43 ++++++++++++++++++++++ 2 files changed, 59 insertions(+), 5 deletions(-) diff --git a/include/llvm/Analysis/ScalarEvolution.h b/include/llvm/Analysis/ScalarEvolution.h index 3a97e91bd7f..9844940c613 100644 --- a/include/llvm/Analysis/ScalarEvolution.h +++ b/include/llvm/Analysis/ScalarEvolution.h @@ -38,11 +38,11 @@ namespace llvm { /// 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 @@ namespace llvm { /// 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 @@ namespace llvm { 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 @@ namespace llvm { SCEV *S; SCEVHandle(); // DO NOT IMPLEMENT public: - SCEVHandle(SCEV *s) : S(s) { + SCEVHandle(const SCEV *s) : S(const_cast(s)) { assert(S && "Cannot create a handle to a null SCEV!"); S->addRef(); } diff --git a/include/llvm/Analysis/ScalarEvolutionExpressions.h b/include/llvm/Analysis/ScalarEvolutionExpressions.h index 607ec776d64..8f113a40040 100644 --- a/include/llvm/Analysis/ScalarEvolutionExpressions.h +++ b/include/llvm/Analysis/ScalarEvolutionExpressions.h @@ -56,6 +56,11 @@ namespace llvm { 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 @@ namespace llvm { 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 @@ namespace llvm { /// 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 @@ namespace llvm { 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 @@ namespace llvm { 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 @@ namespace llvm { /// 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 @@ namespace llvm { 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; -- 2.11.0