// folders simpler.
scConstant, scTruncate, scZeroExtend, scSignExtend, scAddExpr, scMulExpr,
scUDivExpr, scAddRecExpr, scUMaxExpr, scSMaxExpr,
- scFieldOffset, scAllocSize, scUnknown, scCouldNotCompute
+ scUnknown, scCouldNotCompute
};
//===--------------------------------------------------------------------===//
public:
virtual const char *getOperationStr() const { return " + "; }
+ virtual const Type *getType() const {
+ // Use the type of the last operand, which is likely to be a pointer
+ // type, if there is one. This doesn't usually matter, but it can help
+ // reduce casts when the expressions are expanded.
+ return getOperand(getNumOperands() - 1)->getType();
+ }
+
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const SCEVAddExpr *S) { return true; }
static inline bool classof(const SCEV *S) {
}
virtual bool hasComputableLoopEvolution(const Loop *QL) const {
- if (L == QL) return true;
- return false;
+ return L == QL;
}
virtual bool isLoopInvariant(const Loop *QueryLoop) const;
+ bool dominates(BasicBlock *BB, DominatorTree *DT) const;
+
+ bool properlyDominates(BasicBlock *BB, DominatorTree *DT) const;
+
/// isAffine - Return true if this is an affine AddRec (i.e., it represents
/// an expressions A+B*x where A and B are loop invariant values.
bool isAffine() const {
}
};
- //===--------------------------------------------------------------------===//
- /// SCEVTargetDataConstant - This node is the base class for representing
- /// target-dependent values in a target-independent way.
- ///
- class SCEVTargetDataConstant : public SCEV {
- protected:
- const Type *Ty;
- SCEVTargetDataConstant(const FoldingSetNodeID &ID, enum SCEVTypes T,
- const Type *ty) :
- SCEV(ID, T), Ty(ty) {}
-
- public:
- virtual bool isLoopInvariant(const Loop *) const { return true; }
- virtual bool hasComputableLoopEvolution(const Loop *) const {
- return false; // not computable
- }
-
- virtual bool hasOperand(const SCEV *) const {
- return false;
- }
-
- bool dominates(BasicBlock *, DominatorTree *) const {
- return true;
- }
-
- bool properlyDominates(BasicBlock *, DominatorTree *) const {
- return true;
- }
-
- virtual const Type *getType() const { return Ty; }
-
- /// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEVTargetDataConstant *S) { return true; }
- static inline bool classof(const SCEV *S) {
- return S->getSCEVType() == scFieldOffset ||
- S->getSCEVType() == scAllocSize;
- }
- };
-
- //===--------------------------------------------------------------------===//
- /// SCEVFieldOffsetExpr - This node represents an offsetof expression.
- ///
- class SCEVFieldOffsetExpr : public SCEVTargetDataConstant {
- friend class ScalarEvolution;
-
- const StructType *STy;
- unsigned FieldNo;
- SCEVFieldOffsetExpr(const FoldingSetNodeID &ID, const Type *ty,
- const StructType *sty, unsigned fieldno) :
- SCEVTargetDataConstant(ID, scFieldOffset, ty),
- STy(sty), FieldNo(fieldno) {}
-
- public:
- const StructType *getStructType() const { return STy; }
- unsigned getFieldNo() const { return FieldNo; }
-
- virtual void print(raw_ostream &OS) const;
-
- /// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEVFieldOffsetExpr *S) { return true; }
- static inline bool classof(const SCEV *S) {
- return S->getSCEVType() == scFieldOffset;
- }
- };
-
- //===--------------------------------------------------------------------===//
- /// SCEVAllocSize - This node represents a sizeof expression.
- ///
- class SCEVAllocSizeExpr : public SCEVTargetDataConstant {
- friend class ScalarEvolution;
-
- const Type *AllocTy;
- SCEVAllocSizeExpr(const FoldingSetNodeID &ID,
- const Type *ty, const Type *allocty) :
- SCEVTargetDataConstant(ID, scAllocSize, ty),
- AllocTy(allocty) {}
-
- public:
- const Type *getAllocType() const { return AllocTy; }
-
- virtual void print(raw_ostream &OS) const;
-
- /// Methods for support type inquiry through isa, cast, and dyn_cast:
- static inline bool classof(const SCEVAllocSizeExpr *S) { return true; }
- static inline bool classof(const SCEV *S) {
- return S->getSCEVType() == scAllocSize;
- }
- };
-
//===--------------------------------------------------------------------===//
/// SCEVUnknown - This means that we are dealing with an entirely unknown SCEV
/// value, and only represent it as its LLVM Value. This is the "bottom"
public:
Value *getValue() const { return V; }
+ /// isSizeOf, isAlignOf, isOffsetOf - Test whether this is a special
+ /// constant representing a type size, alignment, or field offset in
+ /// a target-independent manner, and hasn't happened to have been
+ /// folded with other operations into something unrecognizable. This
+ /// is mainly only useful for pretty-printing and other situations
+ /// where it isn't absolutely required for these to succeed.
+ bool isSizeOf(const Type *&AllocTy) const;
+ bool isAlignOf(const Type *&AllocTy) const;
+ bool isOffsetOf(const Type *&STy, Constant *&FieldNo) const;
+
virtual bool isLoopInvariant(const Loop *L) const;
virtual bool hasComputableLoopEvolution(const Loop *QL) const {
return false; // not computable
return ((SC*)this)->visitSMaxExpr((const SCEVSMaxExpr*)S);
case scUMaxExpr:
return ((SC*)this)->visitUMaxExpr((const SCEVUMaxExpr*)S);
- case scFieldOffset:
- return ((SC*)this)->visitFieldOffsetExpr((const SCEVFieldOffsetExpr*)S);
- case scAllocSize:
- return ((SC*)this)->visitAllocSizeExpr((const SCEVAllocSizeExpr*)S);
case scUnknown:
return ((SC*)this)->visitUnknown((const SCEVUnknown*)S);
case scCouldNotCompute: