Lines Matching defs:Expr

59   ValidatorResult(SCEVType::TYPE Type, const SCEV *Expr) : Type(Type) {
60     Parameters.insert(Expr);
144   ValidatorResult visitZeroExtendOrTruncateExpr(const SCEV *Expr,
156     return ValidatorResult(SCEVType::PARAM, Expr);
159   ValidatorResult visitPtrToIntExpr(const SCEVPtrToIntExpr *Expr) {
160     return visit(Expr->getOperand());
163   ValidatorResult visitTruncateExpr(const SCEVTruncateExpr *Expr) {
164     return visitZeroExtendOrTruncateExpr(Expr, Expr->getOperand());
167   ValidatorResult visitZeroExtendExpr(const SCEVZeroExtendExpr *Expr) {
168     return visitZeroExtendOrTruncateExpr(Expr, Expr->getOperand());
171   ValidatorResult visitSignExtendExpr(const SCEVSignExtendExpr *Expr) {
172     return visit(Expr->getOperand());
175   ValidatorResult visitAddExpr(const SCEVAddExpr *Expr) {
178     for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
179       ValidatorResult Op = visit(Expr->getOperand(i));
190   ValidatorResult visitMulExpr(const SCEVMulExpr *Expr) {
195     for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
196       ValidatorResult Op = visit(Expr->getOperand(i));
209                    << "\tExpr: " << *Expr << "\n"
211                    << "\tNext operand (" << Op << "): " << *Expr->getOperand(i)
221       return ValidatorResult(SCEVType::PARAM, Expr);
226   ValidatorResult visitAddRecExpr(const SCEVAddRecExpr *Expr) {
227     if (!Expr->isAffine()) {
232     ValidatorResult Start = visit(Expr->getStart());
233     ValidatorResult Recurrence = visit(Expr->getStepRecurrence(SE));
241     auto *L = Expr->getLoop();
264     // Directly generate ValidatorResult for Expr if 'start' is zero.
265     if (Expr->getStart()->isZero())
266       return ValidatorResult(SCEVType::PARAM, Expr);
271         SE.getConstant(Expr->getStart()->getType(), 0),
272         Expr->getStepRecurrence(SE), Expr->getLoop(), Expr->getNoWrapFlags());
281   ValidatorResult visitSMaxExpr(const SCEVSMaxExpr *Expr) {
284     for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
285       ValidatorResult Op = visit(Expr->getOperand(i));
296   ValidatorResult visitSMinExpr(const SCEVSMinExpr *Expr) {
299     for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
300       ValidatorResult Op = visit(Expr->getOperand(i));
311   ValidatorResult visitUMaxExpr(const SCEVUMaxExpr *Expr) {
312     // We do not support unsigned max operations. If 'Expr' is constant during
314     for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
315       ValidatorResult Op = visit(Expr->getOperand(i));
323     return ValidatorResult(SCEVType::PARAM, Expr);
326   ValidatorResult visitUMinExpr(const SCEVUMinExpr *Expr) {
327     // We do not support unsigned min operations. If 'Expr' is constant during
329     for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
330       ValidatorResult Op = visit(Expr->getOperand(i));
338     return ValidatorResult(SCEVType::PARAM, Expr);
341   ValidatorResult visitSequentialUMinExpr(const SCEVSequentialUMinExpr *Expr) {
342     // We do not support unsigned min operations. If 'Expr' is constant during
344     for (int i = 0, e = Expr->getNumOperands(); i < e; ++i) {
345       ValidatorResult Op = visit(Expr->getOperand(i));
355     return ValidatorResult(SCEVType::PARAM, Expr);
402   ValidatorResult visitUDivExpr(const SCEVUDivExpr *Expr) {
406     const SCEV *Dividend = Expr->getLHS();
407     const SCEV *Divisor = Expr->getRHS();
408     return visitDivision(Dividend, Divisor, Expr);
411   ValidatorResult visitSDivInstruction(Instruction *SDiv, const SCEV *Expr) {
417     return visitDivision(Dividend, Divisor, Expr, SDiv);
434   ValidatorResult visitUnknown(const SCEVUnknown *Expr) {
435     Value *V = Expr->getValue();
437     if (!Expr->getType()->isIntegerTy() && !Expr->getType()->isPointerTy()) {
448     if (Instruction *I = dyn_cast<Instruction>(Expr->getValue())) {
453         return visitLoadInstruction(I, Expr);
455         return visitSDivInstruction(I, Expr);
457         return visitSRemInstruction(I, Expr);
459         return visitGenericInst(I, Expr);
463     if (Expr->getType()->isPointerTy()) {
468     return ValidatorResult(SCEVType::PARAM, Expr);
543 void polly::findLoops(const SCEV *Expr, SetVector<const Loop *> &Loops) {
546   ST.visitAll(Expr);
584 void polly::findValues(const SCEV *Expr, ScalarEvolution &SE,
588   ST.visitAll(Expr);
591 bool polly::hasScalarDepsInsideRegion(const SCEV *Expr, const Region *R,
596   ST.visitAll(Expr);
600 bool polly::isAffineExpr(const Region *R, llvm::Loop *Scope, const SCEV *Expr,
602   if (isa<SCEVCouldNotCompute>(Expr))
608     dbgs() << "Expr: " << *Expr << "\n";
613   ValidatorResult Result = Validator.visit(Expr);
665                                             const SCEV *Expr,
667   if (isa<SCEVCouldNotCompute>(Expr))
672   ValidatorResult Result = Validator.visit(Expr);
738 const SCEV *polly::tryForwardThroughPHI(const SCEV *Expr, Region &R,
741   if (auto *Unknown = dyn_cast<SCEVUnknown>(Expr)) {
745       return Expr;
754         return Expr;
761   return Expr;