};
//===--------------------------------------------------------------------===//
- /// SCEVTruncateExpr - This class represents a truncation of an integer value
- /// to a smaller integer value.
+ /// SCEVCastExpr - This is the base class for unary cast operator classes.
///
- class SCEVTruncateExpr : public SCEV {
- friend class ScalarEvolution;
-
+ class SCEVCastExpr : public SCEV {
+ protected:
SCEVHandle Op;
const Type *Ty;
- SCEVTruncateExpr(const SCEVHandle &op, const Type *ty);
- virtual ~SCEVTruncateExpr();
+
+ SCEVCastExpr(unsigned SCEVTy, const SCEVHandle &op, const Type *ty);
+ virtual ~SCEVCastExpr();
+
public:
const SCEVHandle &getOperand() const { return Op; }
virtual const Type *getType() const { return Ty; }
return Op->hasComputableLoopEvolution(L);
}
+ virtual bool dominates(BasicBlock *BB, DominatorTree *DT) const;
+
+ /// Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool classof(const SCEVCastExpr *S) { return true; }
+ static inline bool classof(const SCEV *S) {
+ return S->getSCEVType() == scTruncate ||
+ S->getSCEVType() == scZeroExtend ||
+ S->getSCEVType() == scSignExtend;
+ }
+ };
+
+ //===--------------------------------------------------------------------===//
+ /// SCEVTruncateExpr - This class represents a truncation of an integer value
+ /// to a smaller integer value.
+ ///
+ class SCEVTruncateExpr : public SCEVCastExpr {
+ friend class ScalarEvolution;
+
+ SCEVTruncateExpr(const SCEVHandle &op, const Type *ty);
+ virtual ~SCEVTruncateExpr();
+
+ public:
SCEVHandle replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
const SCEVHandle &Conc,
ScalarEvolution &SE) const {
return SE.getTruncateExpr(H, Ty);
}
- virtual bool dominates(BasicBlock *BB, DominatorTree *DT) const;
-
virtual void print(raw_ostream &OS) const;
/// Methods for support type inquiry through isa, cast, and dyn_cast:
/// SCEVZeroExtendExpr - This class represents a zero extension of a small
/// integer value to a larger integer value.
///
- class SCEVZeroExtendExpr : public SCEV {
+ class SCEVZeroExtendExpr : public SCEVCastExpr {
friend class ScalarEvolution;
- SCEVHandle Op;
- const Type *Ty;
SCEVZeroExtendExpr(const SCEVHandle &op, const Type *ty);
virtual ~SCEVZeroExtendExpr();
- public:
- const SCEVHandle &getOperand() const { return Op; }
- virtual const Type *getType() const { return Ty; }
-
- virtual bool isLoopInvariant(const Loop *L) const {
- return Op->isLoopInvariant(L);
- }
-
- virtual bool hasComputableLoopEvolution(const Loop *L) const {
- return Op->hasComputableLoopEvolution(L);
- }
+ public:
SCEVHandle replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
const SCEVHandle &Conc,
ScalarEvolution &SE) const {
return SE.getZeroExtendExpr(H, Ty);
}
- bool dominates(BasicBlock *BB, DominatorTree *DT) const;
-
virtual void print(raw_ostream &OS) const;
/// Methods for support type inquiry through isa, cast, and dyn_cast:
/// SCEVSignExtendExpr - This class represents a sign extension of a small
/// integer value to a larger integer value.
///
- class SCEVSignExtendExpr : public SCEV {
+ class SCEVSignExtendExpr : public SCEVCastExpr {
friend class ScalarEvolution;
- SCEVHandle Op;
- const Type *Ty;
SCEVSignExtendExpr(const SCEVHandle &op, const Type *ty);
virtual ~SCEVSignExtendExpr();
- public:
- const SCEVHandle &getOperand() const { return Op; }
- virtual const Type *getType() const { return Ty; }
-
- virtual bool isLoopInvariant(const Loop *L) const {
- return Op->isLoopInvariant(L);
- }
-
- virtual bool hasComputableLoopEvolution(const Loop *L) const {
- return Op->hasComputableLoopEvolution(L);
- }
+ public:
SCEVHandle replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
const SCEVHandle &Conc,
ScalarEvolution &SE) const {
return SE.getSignExtendExpr(H, Ty);
}
- bool dominates(BasicBlock *BB, DominatorTree *DT) const;
-
virtual void print(raw_ostream &OS) const;
/// Methods for support type inquiry through isa, cast, and dyn_cast:
/// operators.
///
class SCEVCommutativeExpr : public SCEV {
- friend class ScalarEvolution;
-
std::vector<SCEVHandle> Operands;
protected:
WriteAsOperand(OS, V, false);
}
+SCEVCastExpr::SCEVCastExpr(unsigned SCEVTy,
+ const SCEVHandle &op, const Type *ty)
+ : SCEV(SCEVTy), Op(op), Ty(ty) {}
+
+SCEVCastExpr::~SCEVCastExpr() {}
+
+bool SCEVCastExpr::dominates(BasicBlock *BB, DominatorTree *DT) const {
+ return Op->dominates(BB, DT);
+}
+
// SCEVTruncates - Only allow the creation of one SCEVTruncateExpr for any
// particular input. Don't use a SCEVHandle here, or else the object will
// never be deleted!
SCEVTruncateExpr*> > SCEVTruncates;
SCEVTruncateExpr::SCEVTruncateExpr(const SCEVHandle &op, const Type *ty)
- : SCEV(scTruncate), Op(op), Ty(ty) {
+ : SCEVCastExpr(scTruncate, op, ty) {
assert((Op->getType()->isInteger() || isa<PointerType>(Op->getType())) &&
(Ty->isInteger() || isa<PointerType>(Ty)) &&
"Cannot truncate non-integer value!");
SCEVTruncates->erase(std::make_pair(Op, Ty));
}
-bool SCEVTruncateExpr::dominates(BasicBlock *BB, DominatorTree *DT) const {
- return Op->dominates(BB, DT);
-}
-
void SCEVTruncateExpr::print(raw_ostream &OS) const {
OS << "(truncate " << *Op << " to " << *Ty << ")";
}
SCEVZeroExtendExpr*> > SCEVZeroExtends;
SCEVZeroExtendExpr::SCEVZeroExtendExpr(const SCEVHandle &op, const Type *ty)
- : SCEV(scZeroExtend), Op(op), Ty(ty) {
+ : SCEVCastExpr(scZeroExtend, op, ty) {
assert((Op->getType()->isInteger() || isa<PointerType>(Op->getType())) &&
(Ty->isInteger() || isa<PointerType>(Ty)) &&
"Cannot zero extend non-integer value!");
SCEVZeroExtends->erase(std::make_pair(Op, Ty));
}
-bool SCEVZeroExtendExpr::dominates(BasicBlock *BB, DominatorTree *DT) const {
- return Op->dominates(BB, DT);
-}
-
void SCEVZeroExtendExpr::print(raw_ostream &OS) const {
OS << "(zeroextend " << *Op << " to " << *Ty << ")";
}
SCEVSignExtendExpr*> > SCEVSignExtends;
SCEVSignExtendExpr::SCEVSignExtendExpr(const SCEVHandle &op, const Type *ty)
- : SCEV(scSignExtend), Op(op), Ty(ty) {
+ : SCEVCastExpr(scSignExtend, op, ty) {
assert((Op->getType()->isInteger() || isa<PointerType>(Op->getType())) &&
(Ty->isInteger() || isa<PointerType>(Ty)) &&
"Cannot sign extend non-integer value!");
SCEVSignExtends->erase(std::make_pair(Op, Ty));
}
-bool SCEVSignExtendExpr::dominates(BasicBlock *BB, DominatorTree *DT) const {
- return Op->dominates(BB, DT);
-}
-
void SCEVSignExtendExpr::print(raw_ostream &OS) const {
OS << "(signextend " << *Op << " to " << *Ty << ")";
}