1
//===- llvm/Analysis/ScalarEvolutionExpressions.h - SCEV Exprs --*- C++ -*-===//
3
// The LLVM Compiler Infrastructure
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
8
//===----------------------------------------------------------------------===//
10
// This file defines the classes used to represent and build scalar expressions.
12
//===----------------------------------------------------------------------===//
14
#ifndef LLVM_ANALYSIS_SCALAREVOLUTION_EXPRESSIONS_H
15
#define LLVM_ANALYSIS_SCALAREVOLUTION_EXPRESSIONS_H
17
#include "llvm/Analysis/ScalarEvolution.h"
18
#include "llvm/Support/ErrorHandling.h"
26
// These should be ordered in terms of increasing complexity to make the
28
scConstant, scTruncate, scZeroExtend, scSignExtend, scAddExpr, scMulExpr,
29
scUDivExpr, scAddRecExpr, scUMaxExpr, scSMaxExpr,
30
scUnknown, scCouldNotCompute
33
//===--------------------------------------------------------------------===//
34
/// SCEVConstant - This class represents a constant integer value.
36
class SCEVConstant : public SCEV {
37
friend class ScalarEvolution;
40
SCEVConstant(const FoldingSetNodeID &ID, ConstantInt *v) :
41
SCEV(ID, scConstant), V(v) {}
43
ConstantInt *getValue() const { return V; }
45
virtual bool isLoopInvariant(const Loop *L) const {
49
virtual bool hasComputableLoopEvolution(const Loop *L) const {
50
return false; // Not loop variant
53
virtual const Type *getType() const;
55
virtual bool hasOperand(const SCEV *) const {
59
bool dominates(BasicBlock *BB, DominatorTree *DT) const {
63
bool properlyDominates(BasicBlock *BB, DominatorTree *DT) const {
67
virtual void print(raw_ostream &OS) const;
69
/// Methods for support type inquiry through isa, cast, and dyn_cast:
70
static inline bool classof(const SCEVConstant *S) { return true; }
71
static inline bool classof(const SCEV *S) {
72
return S->getSCEVType() == scConstant;
76
//===--------------------------------------------------------------------===//
77
/// SCEVCastExpr - This is the base class for unary cast operator classes.
79
class SCEVCastExpr : public SCEV {
84
SCEVCastExpr(const FoldingSetNodeID &ID,
85
unsigned SCEVTy, const SCEV *op, const Type *ty);
88
const SCEV *getOperand() const { return Op; }
89
virtual const Type *getType() const { return Ty; }
91
virtual bool isLoopInvariant(const Loop *L) const {
92
return Op->isLoopInvariant(L);
95
virtual bool hasComputableLoopEvolution(const Loop *L) const {
96
return Op->hasComputableLoopEvolution(L);
99
virtual bool hasOperand(const SCEV *O) const {
100
return Op == O || Op->hasOperand(O);
103
virtual bool dominates(BasicBlock *BB, DominatorTree *DT) const;
105
virtual bool properlyDominates(BasicBlock *BB, DominatorTree *DT) const;
107
/// Methods for support type inquiry through isa, cast, and dyn_cast:
108
static inline bool classof(const SCEVCastExpr *S) { return true; }
109
static inline bool classof(const SCEV *S) {
110
return S->getSCEVType() == scTruncate ||
111
S->getSCEVType() == scZeroExtend ||
112
S->getSCEVType() == scSignExtend;
116
//===--------------------------------------------------------------------===//
117
/// SCEVTruncateExpr - This class represents a truncation of an integer value
118
/// to a smaller integer value.
120
class SCEVTruncateExpr : public SCEVCastExpr {
121
friend class ScalarEvolution;
123
SCEVTruncateExpr(const FoldingSetNodeID &ID,
124
const SCEV *op, const Type *ty);
127
virtual void print(raw_ostream &OS) const;
129
/// Methods for support type inquiry through isa, cast, and dyn_cast:
130
static inline bool classof(const SCEVTruncateExpr *S) { return true; }
131
static inline bool classof(const SCEV *S) {
132
return S->getSCEVType() == scTruncate;
136
//===--------------------------------------------------------------------===//
137
/// SCEVZeroExtendExpr - This class represents a zero extension of a small
138
/// integer value to a larger integer value.
140
class SCEVZeroExtendExpr : public SCEVCastExpr {
141
friend class ScalarEvolution;
143
SCEVZeroExtendExpr(const FoldingSetNodeID &ID,
144
const SCEV *op, const Type *ty);
147
virtual void print(raw_ostream &OS) const;
149
/// Methods for support type inquiry through isa, cast, and dyn_cast:
150
static inline bool classof(const SCEVZeroExtendExpr *S) { return true; }
151
static inline bool classof(const SCEV *S) {
152
return S->getSCEVType() == scZeroExtend;
156
//===--------------------------------------------------------------------===//
157
/// SCEVSignExtendExpr - This class represents a sign extension of a small
158
/// integer value to a larger integer value.
160
class SCEVSignExtendExpr : public SCEVCastExpr {
161
friend class ScalarEvolution;
163
SCEVSignExtendExpr(const FoldingSetNodeID &ID,
164
const SCEV *op, const Type *ty);
167
virtual void print(raw_ostream &OS) const;
169
/// Methods for support type inquiry through isa, cast, and dyn_cast:
170
static inline bool classof(const SCEVSignExtendExpr *S) { return true; }
171
static inline bool classof(const SCEV *S) {
172
return S->getSCEVType() == scSignExtend;
177
//===--------------------------------------------------------------------===//
178
/// SCEVNAryExpr - This node is a base class providing common
179
/// functionality for n'ary operators.
181
class SCEVNAryExpr : public SCEV {
183
SmallVector<const SCEV *, 8> Operands;
185
SCEVNAryExpr(const FoldingSetNodeID &ID,
186
enum SCEVTypes T, const SmallVectorImpl<const SCEV *> &ops)
187
: SCEV(ID, T), Operands(ops.begin(), ops.end()) {}
190
unsigned getNumOperands() const { return (unsigned)Operands.size(); }
191
const SCEV *getOperand(unsigned i) const {
192
assert(i < Operands.size() && "Operand index out of range!");
196
const SmallVectorImpl<const SCEV *> &getOperands() const {
199
typedef SmallVectorImpl<const SCEV *>::const_iterator op_iterator;
200
op_iterator op_begin() const { return Operands.begin(); }
201
op_iterator op_end() const { return Operands.end(); }
203
virtual bool isLoopInvariant(const Loop *L) const {
204
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
205
if (!getOperand(i)->isLoopInvariant(L)) return false;
209
// hasComputableLoopEvolution - N-ary expressions have computable loop
210
// evolutions iff they have at least one operand that varies with the loop,
211
// but that all varying operands are computable.
212
virtual bool hasComputableLoopEvolution(const Loop *L) const {
213
bool HasVarying = false;
214
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
215
if (!getOperand(i)->isLoopInvariant(L)) {
216
if (getOperand(i)->hasComputableLoopEvolution(L))
224
virtual bool hasOperand(const SCEV *O) const {
225
for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
226
if (O == getOperand(i) || getOperand(i)->hasOperand(O))
231
bool dominates(BasicBlock *BB, DominatorTree *DT) const;
233
bool properlyDominates(BasicBlock *BB, DominatorTree *DT) const;
235
virtual const Type *getType() const { return getOperand(0)->getType(); }
237
bool hasNoUnsignedWrap() const { return SubclassData & (1 << 0); }
238
void setHasNoUnsignedWrap(bool B) {
239
SubclassData = (SubclassData & ~(1 << 0)) | (B << 0);
241
bool hasNoSignedWrap() const { return SubclassData & (1 << 1); }
242
void setHasNoSignedWrap(bool B) {
243
SubclassData = (SubclassData & ~(1 << 1)) | (B << 1);
246
/// Methods for support type inquiry through isa, cast, and dyn_cast:
247
static inline bool classof(const SCEVNAryExpr *S) { return true; }
248
static inline bool classof(const SCEV *S) {
249
return S->getSCEVType() == scAddExpr ||
250
S->getSCEVType() == scMulExpr ||
251
S->getSCEVType() == scSMaxExpr ||
252
S->getSCEVType() == scUMaxExpr ||
253
S->getSCEVType() == scAddRecExpr;
257
//===--------------------------------------------------------------------===//
258
/// SCEVCommutativeExpr - This node is the base class for n'ary commutative
261
class SCEVCommutativeExpr : public SCEVNAryExpr {
263
SCEVCommutativeExpr(const FoldingSetNodeID &ID,
265
const SmallVectorImpl<const SCEV *> &ops)
266
: SCEVNAryExpr(ID, T, ops) {}
269
virtual const char *getOperationStr() const = 0;
271
virtual void print(raw_ostream &OS) const;
273
/// Methods for support type inquiry through isa, cast, and dyn_cast:
274
static inline bool classof(const SCEVCommutativeExpr *S) { return true; }
275
static inline bool classof(const SCEV *S) {
276
return S->getSCEVType() == scAddExpr ||
277
S->getSCEVType() == scMulExpr ||
278
S->getSCEVType() == scSMaxExpr ||
279
S->getSCEVType() == scUMaxExpr;
284
//===--------------------------------------------------------------------===//
285
/// SCEVAddExpr - This node represents an addition of some number of SCEVs.
287
class SCEVAddExpr : public SCEVCommutativeExpr {
288
friend class ScalarEvolution;
290
SCEVAddExpr(const FoldingSetNodeID &ID,
291
const SmallVectorImpl<const SCEV *> &ops)
292
: SCEVCommutativeExpr(ID, scAddExpr, ops) {
296
virtual const char *getOperationStr() const { return " + "; }
298
virtual const Type *getType() const {
299
// Use the type of the last operand, which is likely to be a pointer
300
// type, if there is one. This doesn't usually matter, but it can help
301
// reduce casts when the expressions are expanded.
302
return getOperand(getNumOperands() - 1)->getType();
305
/// Methods for support type inquiry through isa, cast, and dyn_cast:
306
static inline bool classof(const SCEVAddExpr *S) { return true; }
307
static inline bool classof(const SCEV *S) {
308
return S->getSCEVType() == scAddExpr;
312
//===--------------------------------------------------------------------===//
313
/// SCEVMulExpr - This node represents multiplication of some number of SCEVs.
315
class SCEVMulExpr : public SCEVCommutativeExpr {
316
friend class ScalarEvolution;
318
SCEVMulExpr(const FoldingSetNodeID &ID,
319
const SmallVectorImpl<const SCEV *> &ops)
320
: SCEVCommutativeExpr(ID, scMulExpr, ops) {
324
virtual const char *getOperationStr() const { return " * "; }
326
/// Methods for support type inquiry through isa, cast, and dyn_cast:
327
static inline bool classof(const SCEVMulExpr *S) { return true; }
328
static inline bool classof(const SCEV *S) {
329
return S->getSCEVType() == scMulExpr;
334
//===--------------------------------------------------------------------===//
335
/// SCEVUDivExpr - This class represents a binary unsigned division operation.
337
class SCEVUDivExpr : public SCEV {
338
friend class ScalarEvolution;
342
SCEVUDivExpr(const FoldingSetNodeID &ID, const SCEV *lhs, const SCEV *rhs)
343
: SCEV(ID, scUDivExpr), LHS(lhs), RHS(rhs) {}
346
const SCEV *getLHS() const { return LHS; }
347
const SCEV *getRHS() const { return RHS; }
349
virtual bool isLoopInvariant(const Loop *L) const {
350
return LHS->isLoopInvariant(L) && RHS->isLoopInvariant(L);
353
virtual bool hasComputableLoopEvolution(const Loop *L) const {
354
return LHS->hasComputableLoopEvolution(L) &&
355
RHS->hasComputableLoopEvolution(L);
358
virtual bool hasOperand(const SCEV *O) const {
359
return O == LHS || O == RHS || LHS->hasOperand(O) || RHS->hasOperand(O);
362
bool dominates(BasicBlock *BB, DominatorTree *DT) const;
364
bool properlyDominates(BasicBlock *BB, DominatorTree *DT) const;
366
virtual const Type *getType() const;
368
void print(raw_ostream &OS) const;
370
/// Methods for support type inquiry through isa, cast, and dyn_cast:
371
static inline bool classof(const SCEVUDivExpr *S) { return true; }
372
static inline bool classof(const SCEV *S) {
373
return S->getSCEVType() == scUDivExpr;
378
//===--------------------------------------------------------------------===//
379
/// SCEVAddRecExpr - This node represents a polynomial recurrence on the trip
380
/// count of the specified loop. This is the primary focus of the
381
/// ScalarEvolution framework; all the other SCEV subclasses are mostly just
382
/// supporting infrastructure to allow SCEVAddRecExpr expressions to be
383
/// created and analyzed.
385
/// All operands of an AddRec are required to be loop invariant.
387
class SCEVAddRecExpr : public SCEVNAryExpr {
388
friend class ScalarEvolution;
392
SCEVAddRecExpr(const FoldingSetNodeID &ID,
393
const SmallVectorImpl<const SCEV *> &ops, const Loop *l)
394
: SCEVNAryExpr(ID, scAddRecExpr, ops), L(l) {
395
for (size_t i = 0, e = Operands.size(); i != e; ++i)
396
assert(Operands[i]->isLoopInvariant(l) &&
397
"Operands of AddRec must be loop-invariant!");
401
const SCEV *getStart() const { return Operands[0]; }
402
const Loop *getLoop() const { return L; }
404
/// getStepRecurrence - This method constructs and returns the recurrence
405
/// indicating how much this expression steps by. If this is a polynomial
406
/// of degree N, it returns a chrec of degree N-1.
407
const SCEV *getStepRecurrence(ScalarEvolution &SE) const {
408
if (isAffine()) return getOperand(1);
409
return SE.getAddRecExpr(SmallVector<const SCEV *, 3>(op_begin()+1,
414
virtual bool hasComputableLoopEvolution(const Loop *QL) const {
418
virtual bool isLoopInvariant(const Loop *QueryLoop) const;
420
bool dominates(BasicBlock *BB, DominatorTree *DT) const;
422
bool properlyDominates(BasicBlock *BB, DominatorTree *DT) const;
424
/// isAffine - Return true if this is an affine AddRec (i.e., it represents
425
/// an expressions A+B*x where A and B are loop invariant values.
426
bool isAffine() const {
427
// We know that the start value is invariant. This expression is thus
428
// affine iff the step is also invariant.
429
return getNumOperands() == 2;
432
/// isQuadratic - Return true if this is an quadratic AddRec (i.e., it
433
/// represents an expressions A+B*x+C*x^2 where A, B and C are loop
434
/// invariant values. This corresponds to an addrec of the form {L,+,M,+,N}
435
bool isQuadratic() const {
436
return getNumOperands() == 3;
439
/// evaluateAtIteration - Return the value of this chain of recurrences at
440
/// the specified iteration number.
441
const SCEV *evaluateAtIteration(const SCEV *It, ScalarEvolution &SE) const;
443
/// getNumIterationsInRange - Return the number of iterations of this loop
444
/// that produce values in the specified constant range. Another way of
445
/// looking at this is that it returns the first iteration number where the
446
/// value is not in the condition, thus computing the exit count. If the
447
/// iteration count can't be computed, an instance of SCEVCouldNotCompute is
449
const SCEV *getNumIterationsInRange(ConstantRange Range,
450
ScalarEvolution &SE) const;
452
/// getPostIncExpr - Return an expression representing the value of
453
/// this expression one iteration of the loop ahead.
454
const SCEVAddRecExpr *getPostIncExpr(ScalarEvolution &SE) const {
455
return cast<SCEVAddRecExpr>(SE.getAddExpr(this, getStepRecurrence(SE)));
458
virtual void print(raw_ostream &OS) const;
460
/// Methods for support type inquiry through isa, cast, and dyn_cast:
461
static inline bool classof(const SCEVAddRecExpr *S) { return true; }
462
static inline bool classof(const SCEV *S) {
463
return S->getSCEVType() == scAddRecExpr;
468
//===--------------------------------------------------------------------===//
469
/// SCEVSMaxExpr - This class represents a signed maximum selection.
471
class SCEVSMaxExpr : public SCEVCommutativeExpr {
472
friend class ScalarEvolution;
474
SCEVSMaxExpr(const FoldingSetNodeID &ID,
475
const SmallVectorImpl<const SCEV *> &ops)
476
: SCEVCommutativeExpr(ID, scSMaxExpr, ops) {
477
// Max never overflows.
478
setHasNoUnsignedWrap(true);
479
setHasNoSignedWrap(true);
483
virtual const char *getOperationStr() const { return " smax "; }
485
/// Methods for support type inquiry through isa, cast, and dyn_cast:
486
static inline bool classof(const SCEVSMaxExpr *S) { return true; }
487
static inline bool classof(const SCEV *S) {
488
return S->getSCEVType() == scSMaxExpr;
493
//===--------------------------------------------------------------------===//
494
/// SCEVUMaxExpr - This class represents an unsigned maximum selection.
496
class SCEVUMaxExpr : public SCEVCommutativeExpr {
497
friend class ScalarEvolution;
499
SCEVUMaxExpr(const FoldingSetNodeID &ID,
500
const SmallVectorImpl<const SCEV *> &ops)
501
: SCEVCommutativeExpr(ID, scUMaxExpr, ops) {
502
// Max never overflows.
503
setHasNoUnsignedWrap(true);
504
setHasNoSignedWrap(true);
508
virtual const char *getOperationStr() const { return " umax "; }
510
/// Methods for support type inquiry through isa, cast, and dyn_cast:
511
static inline bool classof(const SCEVUMaxExpr *S) { return true; }
512
static inline bool classof(const SCEV *S) {
513
return S->getSCEVType() == scUMaxExpr;
517
//===--------------------------------------------------------------------===//
518
/// SCEVUnknown - This means that we are dealing with an entirely unknown SCEV
519
/// value, and only represent it as its LLVM Value. This is the "bottom"
520
/// value for the analysis.
522
class SCEVUnknown : public SCEV {
523
friend class ScalarEvolution;
526
SCEVUnknown(const FoldingSetNodeID &ID, Value *v) :
527
SCEV(ID, scUnknown), V(v) {}
530
Value *getValue() const { return V; }
532
/// isSizeOf, isAlignOf, isOffsetOf - Test whether this is a special
533
/// constant representing a type size, alignment, or field offset in
534
/// a target-independent manner, and hasn't happened to have been
535
/// folded with other operations into something unrecognizable. This
536
/// is mainly only useful for pretty-printing and other situations
537
/// where it isn't absolutely required for these to succeed.
538
bool isSizeOf(const Type *&AllocTy) const;
539
bool isAlignOf(const Type *&AllocTy) const;
540
bool isOffsetOf(const Type *&STy, Constant *&FieldNo) const;
542
virtual bool isLoopInvariant(const Loop *L) const;
543
virtual bool hasComputableLoopEvolution(const Loop *QL) const {
544
return false; // not computable
547
virtual bool hasOperand(const SCEV *) const {
551
bool dominates(BasicBlock *BB, DominatorTree *DT) const;
553
bool properlyDominates(BasicBlock *BB, DominatorTree *DT) const;
555
virtual const Type *getType() const;
557
virtual void print(raw_ostream &OS) const;
559
/// Methods for support type inquiry through isa, cast, and dyn_cast:
560
static inline bool classof(const SCEVUnknown *S) { return true; }
561
static inline bool classof(const SCEV *S) {
562
return S->getSCEVType() == scUnknown;
566
/// SCEVVisitor - This class defines a simple visitor class that may be used
567
/// for various SCEV analysis purposes.
568
template<typename SC, typename RetVal=void>
570
RetVal visit(const SCEV *S) {
571
switch (S->getSCEVType()) {
573
return ((SC*)this)->visitConstant((const SCEVConstant*)S);
575
return ((SC*)this)->visitTruncateExpr((const SCEVTruncateExpr*)S);
577
return ((SC*)this)->visitZeroExtendExpr((const SCEVZeroExtendExpr*)S);
579
return ((SC*)this)->visitSignExtendExpr((const SCEVSignExtendExpr*)S);
581
return ((SC*)this)->visitAddExpr((const SCEVAddExpr*)S);
583
return ((SC*)this)->visitMulExpr((const SCEVMulExpr*)S);
585
return ((SC*)this)->visitUDivExpr((const SCEVUDivExpr*)S);
587
return ((SC*)this)->visitAddRecExpr((const SCEVAddRecExpr*)S);
589
return ((SC*)this)->visitSMaxExpr((const SCEVSMaxExpr*)S);
591
return ((SC*)this)->visitUMaxExpr((const SCEVUMaxExpr*)S);
593
return ((SC*)this)->visitUnknown((const SCEVUnknown*)S);
594
case scCouldNotCompute:
595
return ((SC*)this)->visitCouldNotCompute((const SCEVCouldNotCompute*)S);
597
llvm_unreachable("Unknown SCEV type!");
601
RetVal visitCouldNotCompute(const SCEVCouldNotCompute *S) {
602
llvm_unreachable("Invalid use of SCEVCouldNotCompute!");