1 files changed, 22 insertions, 16 deletions

diff --git a/polly/lib/Support/SCEVValidator.cpp b/polly/lib/Support/SCEVValidator.cpp
index 492264bcb57..24139908c5d 100644
--- a/polly/lib/Support/SCEVValidator.cpp
+++ b/polly/lib/Support/SCEVValidator.cpp
@@ -124,14 +124,15 @@ struct SCEVValidator
     : public SCEVVisitor<SCEVValidator, class ValidatorResult> {
 private:
   const Region *R;
+  Loop *Scope;
   ScalarEvolution &SE;
   const Value *BaseAddress;
   InvariantLoadsSetTy *ILS;
 
 public:
-  SCEVValidator(const Region *R, ScalarEvolution &SE, const Value *BaseAddress,
-                InvariantLoadsSetTy *ILS)
-      : R(R), SE(SE), BaseAddress(BaseAddress), ILS(ILS) {}
+  SCEVValidator(const Region *R, Loop *Scope, ScalarEvolution &SE,
+                const Value *BaseAddress, InvariantLoadsSetTy *ILS)
+      : R(R), Scope(Scope), SE(SE), BaseAddress(BaseAddress), ILS(ILS) {}
 
   class ValidatorResult visitConstant(const SCEVConstant *Constant) {
     return ValidatorResult(SCEVType::INT);
@@ -576,12 +577,13 @@ bool hasScalarDepsInsideRegion(const SCEV *Expr, const Region *R,
   return SCEVInRegionDependences::hasDependences(Expr, R, Scope, AllowLoops);
 }
 
-bool isAffineExpr(const Region *R, const SCEV *Expr, ScalarEvolution &SE,
-                  const Value *BaseAddress, InvariantLoadsSetTy *ILS) {
+bool isAffineExpr(const Region *R, llvm::Loop *Scope, const SCEV *Expr,
+                  ScalarEvolution &SE, const Value *BaseAddress,
+                  InvariantLoadsSetTy *ILS) {
   if (isa<SCEVCouldNotCompute>(Expr))
     return false;
 
-  SCEVValidator Validator(R, SE, BaseAddress, ILS);
+  SCEVValidator Validator(R, Scope, SE, BaseAddress, ILS);
   DEBUG({
     dbgs() << "\n";
     dbgs() << "Expr: " << *Expr << "\n";
@@ -600,13 +602,14 @@ bool isAffineExpr(const Region *R, const SCEV *Expr, ScalarEvolution &SE,
   return Result.isValid();
 }
 
-static bool isAffineParamExpr(Value *V, const Region *R, ScalarEvolution &SE,
+static bool isAffineParamExpr(Value *V, const Region *R, Loop *Scope,
+                              ScalarEvolution &SE,
                               std::vector<const SCEV *> &Params) {
   auto *E = SE.getSCEV(V);
   if (isa<SCEVCouldNotCompute>(E))
     return false;
 
-  SCEVValidator Validator(R, SE, nullptr, nullptr);
+  SCEVValidator Validator(R, Scope, SE, nullptr, nullptr);
   ValidatorResult Result = Validator.visit(E);
   if (!Result.isConstant())
     return false;
@@ -617,17 +620,20 @@ static bool isAffineParamExpr(Value *V, const Region *R, ScalarEvolution &SE,
   return true;
 }
 
-bool isAffineParamConstraint(Value *V, const Region *R, ScalarEvolution &SE,
+bool isAffineParamConstraint(Value *V, const Region *R, llvm::Loop *Scope,
+                             ScalarEvolution &SE,
                              std::vector<const SCEV *> &Params, bool OrExpr) {
   if (auto *ICmp = dyn_cast<ICmpInst>(V)) {
-    return isAffineParamConstraint(ICmp->getOperand(0), R, SE, Params, true) &&
-           isAffineParamConstraint(ICmp->getOperand(1), R, SE, Params, true);
+    return isAffineParamConstraint(ICmp->getOperand(0), R, Scope, SE, Params,
+                                   true) &&
+           isAffineParamConstraint(ICmp->getOperand(1), R, Scope, SE, Params,
+                                   true);
   } else if (auto *BinOp = dyn_cast<BinaryOperator>(V)) {
     auto Opcode = BinOp->getOpcode();
     if (Opcode == Instruction::And || Opcode == Instruction::Or)
-      return isAffineParamConstraint(BinOp->getOperand(0), R, SE, Params,
+      return isAffineParamConstraint(BinOp->getOperand(0), R, Scope, SE, Params,
                                      false) &&
-             isAffineParamConstraint(BinOp->getOperand(1), R, SE, Params,
+             isAffineParamConstraint(BinOp->getOperand(1), R, Scope, SE, Params,
                                      false);
     /* Fall through */
   }
@@ -635,10 +641,10 @@ bool isAffineParamConstraint(Value *V, const Region *R, ScalarEvolution &SE,
   if (!OrExpr)
     return false;
 
-  return isAffineParamExpr(V, R, SE, Params);
+  return isAffineParamExpr(V, R, Scope, SE, Params);
 }
 
-std::vector<const SCEV *> getParamsInAffineExpr(const Region *R,
+std::vector<const SCEV *> getParamsInAffineExpr(const Region *R, Loop *Scope,
                                                 const SCEV *Expr,
                                                 ScalarEvolution &SE,
                                                 const Value *BaseAddress) {
@@ -646,7 +652,7 @@ std::vector<const SCEV *> getParamsInAffineExpr(const Region *R,
     return std::vector<const SCEV *>();
 
   InvariantLoadsSetTy ILS;
-  SCEVValidator Validator(R, SE, BaseAddress, &ILS);
+  SCEVValidator Validator(R, Scope, SE, BaseAddress, &ILS);
   ValidatorResult Result = Validator.visit(Expr);
   assert(Result.isValid() && "Requested parameters for an invalid SCEV!");