[Polly] Pass around Domain of BB to getPwAff(). NFC.

[Meinersbur]

lib/Analysis/ScopInfo.cpp

2266–2267

Some tests fail here:

********************

Testing Time: 31.63s
********************
Failing Tests (8):
    Polly :: Isl/CodeGen/intrinsics_misc.ll
    Polly :: ScopInfo/user_provided_assumptions-in-bb-signed-conditional.ll
    Polly :: ScopInfo/user_provided_assumptions-in-bb-signed.ll
    Polly :: ScopInfo/user_provided_assumptions-in-bb-unsigned.ll
    Polly :: ScopInfo/user_provided_assumptions.ll
    Polly :: ScopInfo/user_provided_assumptions_2.ll
    Polly :: ScopInfo/user_provided_assumptions_3.ll
    Polly :: ScopInfo/user_provided_non_dominating_assumptions.ll

Before your change, buildConditionSets would ignore the Dom argument on getPwAff and instead look it up in DomainMap instead (regardless of what InScop is).

We should never pass a Context (which is a parameter set, therefore incompatible to a domain) to buildConditionSets. Instead, get the Domain of the SCoP's entry block (Which is BB here).

[nandini12396]

Hello,

Thank you for your comments and sorry for being late on this.
I addressed your remark but some tests still fail. I have no idea why? Could you please have a look.

lib/Support/SCEVAffinator.cpp

115–116

I dont think we can eliminate use of BB here.

[Meinersbur]

The problem is, with InScop==true, buildConditionSets expects a domain, but with InScop==false it expects a context (a parameter set). With the change below we can make it always expect a domain.

diff --git a/lib/Analysis/ScopInfo.cpp b/lib/Analysis/ScopInfo.cpp
index 76c82fce..4db232d9 100644
--- a/lib/Analysis/ScopInfo.cpp
+++ b/lib/Analysis/ScopInfo.cpp
@@ -1633,8 +1633,10 @@ buildConditionSets(Scop &S, BasicBlock *BB, Value *Condition,

   // If no terminator was given we are only looking for parameter constraints
   // under which @p Condition is true/false.
-  if (!TI)
+  if (!TI) {
     ConsequenceCondSet = isl_set_params(ConsequenceCondSet);
+    Domain = Domain.params();
+  }
   assert(ConsequenceCondSet);
   ConsequenceCondSet =
       isl_set_coalesce(isl_set_intersect(ConsequenceCondSet, Domain.copy()));
@@ -2261,7 +2263,7 @@ void Scop::addUserAssumptions(
     SmallVector<isl_set *, 2> ConditionSets;
     auto *TI = InScop ? CI->getParent()->getTerminator() : nullptr;
     BasicBlock *BB = InScop ? CI->getParent() : getRegion().getEntry();
-    isl::set Dom = DomainMap[BB];
+    isl::set Dom = DomainMap[BB].intersect_params(give(isl_set_copy(Context)));
     assert(Dom && "Cannot propagate a nullptr.");
     bool Valid = buildConditionSets(*this, BB, Val, TI, L, Dom,
                                     InvalidDomainMap[BB], ConditionSets);
diff --git a/test/ScopInfo/user_provided_assumptions_2.ll b/test/ScopInfo/user_provided_assumptions_2.ll
index 4636ef41..fefcb6a1 100644
--- a/test/ScopInfo/user_provided_assumptions_2.ll
+++ b/test/ScopInfo/user_provided_assumptions_2.ll
@@ -2,7 +2,7 @@
 ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s --check-prefix=SCOP
 ;
 ; CHECK:      remark: <unknown>:0:0: SCoP begins here.
-; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: { : }
+; CHECK-NEXT: remark: <unknown>:0:0: Use user assumption: [N] -> { : }
 ; CHECK-NEXT: remark: <unknown>:0:0: SCoP ends here.

 ; SCOP:      Context:

However, I am not 100% sure whether this is a correct solution. @grosser may have an opinion.

Alternatively, we can make buildConditionSets take accept two parameters: One is the domain of BB (as Dom in the current state of the patch), and another which is either the domain of BB or the context, depending on InScop (as Dom in the original code).

lib/Support/SCEVAffinator.cpp

115–116

You could set this->BB by other means (e.g. In the constructor of SCEVAffinator), but I think that's not important for this patch.

[nandini12396]

@Meinersbur : I dont know what to do with the Context in buildConditionSets(). Could you please suggest?

[Meinersbur]

In D36056#950433, @nandini12396 wrote:

@Meinersbur : I dont know what to do with the Context in buildConditionSets(). Could you please suggest?

Why do you need to do something with Context in buildConditionSets()?

lib/Analysis/ScopInfo.cpp

1431

[Nit] indention

include/polly/ScopInfo.h

#endif
   /// @return The isl context of this static control part.
   isl::ctx getIslCtx() const;
 
   /// Directly return the shared_ptr of the context.
   const std::shared_ptr<isl_ctx> &getSharedIslCtx() const { return IslCtx; }
 
   /// Compute the isl representation for the SCEV @p E
   ///
-  /// @param E  The SCEV that should be translated.
-  /// @param BB An (optional) basic block in which the isl_pw_aff is computed.
-  ///           SCEVs known to not reference any loops in the SCoP can be
-  ///           passed without a @p BB.
+  /// @param E           The SCEV that should be translated.
+  /// @param BB          An (optional) basic block in which the isl_pw_aff is
+  /// computed.
+  ///                    SCEVs known to not reference any loops in the SCoP can
+  ///                    be passed without a @p BB.
+  /// @param Domain      The domain of the @p BB.
   /// @param NonNegative Flag to indicate the @p E has to be non-negative.
   ///
   /// Note that this function will always return a valid isl_pw_aff. However, if
   /// the translation of @p E was deemed to complex the SCoP is invalidated and
   /// a dummy value of appropriate dimension is returned. This allows to bail
   /// for complex cases without "error handling code" needed on the users side.
   PWACtx getPwAff(const SCEV *E, BasicBlock *BB = nullptr,
-                  bool NonNegative = false);
+                  isl::set Domain = nullptr, bool NonNegative = false);
 
   /// Compute the isl representation for the SCEV @p E
   ///
   /// This function is like @see Scop::getPwAff() but strips away the invalid
   /// domain part associated with the piecewise affine function.
   isl::pw_aff getPwAffOnly(const SCEV *E, BasicBlock *BB = nullptr);
 
   /// Return the domain of @p Stmt.

include/polly/Support/SCEVAffinator.h

 
 /// Translate a SCEV to an isl::pw_aff and the domain on which it is invalid.
 struct SCEVAffinator : public llvm::SCEVVisitor<SCEVAffinator, PWACtx> {
 public:
   SCEVAffinator(Scop *S, llvm::LoopInfo &LI);
 
   /// Translate a SCEV to an isl::pw_aff.
   ///
-  /// @param E  he expression that is translated.
-  /// @param BB The block in which @p E is executed.
+  /// @param E      The expression that is translated.
+  /// @param BB     The block in which @p E is executed.
+  /// @param Domain The domain of the @p BB.
   ///
   /// @returns The isl representation of the SCEV @p E in @p Domain.
-  PWACtx getPwAff(const llvm::SCEV *E, llvm::BasicBlock *BB = nullptr);
+  PWACtx getPwAff(const llvm::SCEV *E, llvm::BasicBlock *BB = nullptr,
+                  isl::set Domain = nullptr);
 
   /// Take the assumption that @p PWAC is non-negative.
   void takeNonNegativeAssumption(PWACtx &PWAC);
 
   /// Interpret the PWA in @p PWAC as an unsigned value.
   void interpretAsUnsigned(PWACtx &PWAC, unsigned Width);
 
   /// Check an <nsw> AddRec for the loop @p L is cached.

lib/Analysis/ScopInfo.cpp

 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void MemoryAccess::dump() const { print(errs()); }
 #endif
 
 isl::pw_aff MemoryAccess::getPwAff(const SCEV *E) {
   auto *Stmt = getStatement();
-  PWACtx PWAC = Stmt->getParent()->getPwAff(E, Stmt->getEntryBlock());
   isl::set StmtDom = getStatement()->getDomain();
+  PWACtx PWAC = Stmt->getParent()->getPwAff(E, Stmt->getEntryBlock(), StmtDom);
   StmtDom = StmtDom.reset_tuple_id();
   isl::set NewInvalidDom = StmtDom.intersect(PWAC.second);
   InvalidDomain = InvalidDomain.unite(NewInvalidDom);
   return PWAC.first;
 }
 
 // Create a map in the size of the provided set domain, that maps from the
 // one element of the provided set domain to another element of the provided

 
 /// Create the conditions under which @p L @p Pred @p R is true.
 ///
 /// Helper function that will make sure the dimensions of the result have the
 /// same isl_id's as the @p Domain.
 static __isl_give isl_set *buildConditionSet(ICmpInst::Predicate Pred,
                                              __isl_take isl_pw_aff *L,
                                              __isl_take isl_pw_aff *R,
-                                             __isl_keep isl_set *Domain) {
+                                             isl::set Domain) {
   isl_set *ConsequenceCondSet = buildConditionSet(Pred, L, R);
-  return setDimensionIds(Domain, ConsequenceCondSet);
+  return setDimensionIds(Domain.get(), ConsequenceCondSet);
 }
 
 /// Compute the isl representation for the SCEV @p E in this BB.
 ///
 /// @param S                The Scop in which @p BB resides in.
 /// @param BB               The BB for which isl representation is to be
-/// computed.
+///                 computed.
+/// @param Domain           The domain of the @p BB.
 /// @param InvalidDomainMap A map of BB to their invalid domains.
 /// @param E                The SCEV that should be translated.
 /// @param NonNegative      Flag to indicate the @p E has to be non-negative.
 ///
 /// Note that this function will also adjust the invalid context accordingly.
 
-__isl_give isl_pw_aff *
-getPwAff(Scop &S, BasicBlock *BB,
-         DenseMap<BasicBlock *, isl::set> &InvalidDomainMap, const SCEV *E,
+__isl_give isl_pw_aff *getPwAff(Scop &S, BasicBlock *BB, isl::set Domain,
+                                isl::set &InvalidDomain, const SCEV *E,
                                 bool NonNegative = false) {
-  PWACtx PWAC = S.getPwAff(E, BB, NonNegative);
-  InvalidDomainMap[BB] = InvalidDomainMap[BB].unite(PWAC.second);
+  PWACtx PWAC = S.getPwAff(E, BB, Domain, NonNegative);
+  InvalidDomain = InvalidDomain.unite(PWAC.second);
   return PWAC.first.take();
 }
 
 /// Build the conditions sets for the switch @p SI in the @p Domain.
 ///
 /// This will fill @p ConditionSets with the conditions under which control
 /// will be moved from @p SI to its successors. Hence, @p ConditionSets will
 /// have as many elements as @p SI has successors.
 bool buildConditionSets(Scop &S, BasicBlock *BB, SwitchInst *SI, Loop *L,
-                        __isl_keep isl_set *Domain,
-                        DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
+                        isl::set Domain, isl::set &InvalidDomain,
                         SmallVectorImpl<__isl_give isl_set *> &ConditionSets) {
   Value *Condition = getConditionFromTerminator(SI);
   assert(Condition && "No condition for switch");
 
   ScalarEvolution &SE = *S.getSE();
   isl_pw_aff *LHS, *RHS;
-  LHS = getPwAff(S, BB, InvalidDomainMap, SE.getSCEVAtScope(Condition, L));
+  LHS = getPwAff(S, BB, Domain, InvalidDomain, SE.getSCEVAtScope(Condition, L));
 
   unsigned NumSuccessors = SI->getNumSuccessors();
   ConditionSets.resize(NumSuccessors);
   for (auto &Case : SI->cases()) {
     unsigned Idx = Case.getSuccessorIndex();
     ConstantInt *CaseValue = Case.getCaseValue();
 
-    RHS = getPwAff(S, BB, InvalidDomainMap, SE.getSCEV(CaseValue));
+    RHS = getPwAff(S, BB, Domain, InvalidDomain, SE.getSCEV(CaseValue));
     isl_set *CaseConditionSet =
         buildConditionSet(ICmpInst::ICMP_EQ, isl_pw_aff_copy(LHS), RHS, Domain);
-    ConditionSets[Idx] = isl_set_coalesce(
-        isl_set_intersect(CaseConditionSet, isl_set_copy(Domain)));
+    ConditionSets[Idx] =
+        isl_set_coalesce(isl_set_intersect(CaseConditionSet, Domain.copy()));
   }
 
   assert(ConditionSets[0] == nullptr && "Default condition set was set");
   isl_set *ConditionSetUnion = isl_set_copy(ConditionSets[1]);
   for (unsigned u = 2; u < NumSuccessors; u++)
     ConditionSetUnion =
         isl_set_union(ConditionSetUnion, isl_set_copy(ConditionSets[u]));
   ConditionSets[0] = setDimensionIds(
-      Domain, isl_set_subtract(isl_set_copy(Domain), ConditionSetUnion));
+      Domain.get(), isl_set_subtract(Domain.copy(), ConditionSetUnion));
 
   isl_pw_aff_free(LHS);
 
   return true;
 }
 
 /// Build condition sets for unsigned ICmpInst(s).
 /// Special handling is required for unsigned operands to ensure that if
 /// MSB (aka the Sign bit) is set for an operands in an unsigned ICmpInst
 /// it should wrap around.
 ///
 /// @param IsStrictUpperBound holds information on the predicate relation
 /// between TestVal and UpperBound, i.e,
 /// TestVal < UpperBound  OR  TestVal <= UpperBound
 __isl_give isl_set *
 buildUnsignedConditionSets(Scop &S, BasicBlock *BB, Value *Condition,
-                           __isl_keep isl_set *Domain, const SCEV *SCEV_TestVal,
-                           const SCEV *SCEV_UpperBound,
-                           DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
+                           isl::set Domain, const SCEV *SCEV_TestVal,
+                           const SCEV *SCEV_UpperBound, isl::set &InvalidDomain,
                            bool IsStrictUpperBound) {
   // Do not take NonNeg assumption on TestVal
   // as it might have MSB (Sign bit) set.
-  isl_pw_aff *TestVal = getPwAff(S, BB, InvalidDomainMap, SCEV_TestVal, false);
+  isl_pw_aff *TestVal =
+      getPwAff(S, BB, Domain, InvalidDomain, SCEV_TestVal, false);
   // Take NonNeg assumption on UpperBound.
   isl_pw_aff *UpperBound =
-      getPwAff(S, BB, InvalidDomainMap, SCEV_UpperBound, true);
+      getPwAff(S, BB, Domain, InvalidDomain, SCEV_UpperBound, true);
 
   // 0 <= TestVal
   isl_set *First =
       isl_pw_aff_le_set(isl_pw_aff_zero_on_domain(isl_local_space_from_space(
                             isl_pw_aff_get_domain_space(TestVal))),
                         isl_pw_aff_copy(TestVal));
 
   isl_set *Second;
   if (IsStrictUpperBound)
     // TestVal < UpperBound
     Second = isl_pw_aff_lt_set(TestVal, UpperBound);
   else
     // TestVal <= UpperBound
     Second = isl_pw_aff_le_set(TestVal, UpperBound);
 
   isl_set *ConsequenceCondSet = isl_set_intersect(First, Second);
-  ConsequenceCondSet = setDimensionIds(Domain, ConsequenceCondSet);
+  ConsequenceCondSet = setDimensionIds(Domain.get(), ConsequenceCondSet);
   return ConsequenceCondSet;
 }
 
 /// Build the conditions sets for the branch condition @p Condition in
 /// the @p Domain.
 ///
 /// This will fill @p ConditionSets with the conditions under which control
 /// will be moved from @p TI to its successors. Hence, @p ConditionSets will
 /// have as many elements as @p TI has successors. If @p TI is nullptr the
 /// context under which @p Condition is true/false will be returned as the
 /// new elements of @p ConditionSets.
 bool buildConditionSets(Scop &S, BasicBlock *BB, Value *Condition,
-                        TerminatorInst *TI, Loop *L, __isl_keep isl_set *Domain,
-                        DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
+                        TerminatorInst *TI, Loop *L, isl::set Domain,
+                        isl::set Context, isl::set &InvalidDomain,
                         SmallVectorImpl<__isl_give isl_set *> &ConditionSets) {
   ScalarEvolution &SE = *S.getSE();
   isl_set *ConsequenceCondSet = nullptr;
 
   if (auto Load = dyn_cast<LoadInst>(Condition)) {
     const SCEV *LHSSCEV = SE.getSCEVAtScope(Load, L);
     const SCEV *RHSSCEV = SE.getZero(LHSSCEV->getType());
     bool NonNeg = false;
-    isl_pw_aff *LHS = getPwAff(S, BB, InvalidDomainMap, LHSSCEV, NonNeg);
-    isl_pw_aff *RHS = getPwAff(S, BB, InvalidDomainMap, RHSSCEV, NonNeg);
+    isl_pw_aff *LHS = getPwAff(S, BB, Domain, InvalidDomain, LHSSCEV, NonNeg);
+    isl_pw_aff *RHS = getPwAff(S, BB, Domain, InvalidDomain, RHSSCEV, NonNeg);
     ConsequenceCondSet =
         buildConditionSet(ICmpInst::ICMP_SLE, LHS, RHS, Domain);
   } else if (auto *PHI = dyn_cast<PHINode>(Condition)) {
     auto *Unique = dyn_cast<ConstantInt>(
         getUniqueNonErrorValue(PHI, &S.getRegion(), *S.getLI(), *S.getDT()));
 
     if (Unique->isZero())
-      ConsequenceCondSet = isl_set_empty(isl_set_get_space(Domain));
+      ConsequenceCondSet = isl_set_empty(isl_set_get_space(Domain.get()));
     else
-      ConsequenceCondSet = isl_set_universe(isl_set_get_space(Domain));
+      ConsequenceCondSet = isl_set_universe(isl_set_get_space(Domain.get()));
   } else if (auto *CCond = dyn_cast<ConstantInt>(Condition)) {
     if (CCond->isZero())
-      ConsequenceCondSet = isl_set_empty(isl_set_get_space(Domain));
+      ConsequenceCondSet = isl_set_empty(isl_set_get_space(Domain.get()));
     else
-      ConsequenceCondSet = isl_set_universe(isl_set_get_space(Domain));
+      ConsequenceCondSet = isl_set_universe(isl_set_get_space(Domain.get()));
   } else if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Condition)) {
     auto Opcode = BinOp->getOpcode();
     assert(Opcode == Instruction::And || Opcode == Instruction::Or);
 
     bool Valid = buildConditionSets(S, BB, BinOp->getOperand(0), TI, L, Domain,
-                                    InvalidDomainMap, ConditionSets) &&
+                                    Context, InvalidDomain, ConditionSets) &&
                  buildConditionSets(S, BB, BinOp->getOperand(1), TI, L, Domain,
-                                    InvalidDomainMap, ConditionSets);
+                                    Context, InvalidDomain, ConditionSets);
     if (!Valid) {
       while (!ConditionSets.empty())
         isl_set_free(ConditionSets.pop_back_val());
       return false;
     }
 
     isl_set_free(ConditionSets.pop_back_val());
     isl_set *ConsCondPart0 = ConditionSets.pop_back_val();
if (auto Load = dyn_cast<LoadInst>(Condition)) {
 
     LeftOperand = tryForwardThroughPHI(LeftOperand, R, SE, LI, DT);
     RightOperand = tryForwardThroughPHI(RightOperand, R, SE, LI, DT);
 
     switch (ICond->getPredicate()) {
     case ICmpInst::ICMP_ULT:
       ConsequenceCondSet =
           buildUnsignedConditionSets(S, BB, Condition, Domain, LeftOperand,
-                                     RightOperand, InvalidDomainMap, true);
+                                     RightOperand, InvalidDomain, true);
       break;
     case ICmpInst::ICMP_ULE:
       ConsequenceCondSet =
           buildUnsignedConditionSets(S, BB, Condition, Domain, LeftOperand,
-                                     RightOperand, InvalidDomainMap, false);
+                                     RightOperand, InvalidDomain, false);
       break;
     case ICmpInst::ICMP_UGT:
       ConsequenceCondSet =
           buildUnsignedConditionSets(S, BB, Condition, Domain, RightOperand,
-                                     LeftOperand, InvalidDomainMap, true);
+                                     LeftOperand, InvalidDomain, true);
       break;
     case ICmpInst::ICMP_UGE:
       ConsequenceCondSet =
           buildUnsignedConditionSets(S, BB, Condition, Domain, RightOperand,
-                                     LeftOperand, InvalidDomainMap, false);
+                                     LeftOperand, InvalidDomain, false);
       break;
     default:
-      LHS = getPwAff(S, BB, InvalidDomainMap, LeftOperand, NonNeg);
-      RHS = getPwAff(S, BB, InvalidDomainMap, RightOperand, NonNeg);
+      LHS = getPwAff(S, BB, Domain, InvalidDomain, LeftOperand, NonNeg);
+      RHS = getPwAff(S, BB, Domain, InvalidDomain, RightOperand, NonNeg);
       ConsequenceCondSet =
           buildConditionSet(ICond->getPredicate(), LHS, RHS, Domain);
       break;
     }
   }
 
   // If no terminator was given we are only looking for parameter constraints
   // under which @p Condition is true/false.
   if (!TI)
     ConsequenceCondSet = isl_set_params(ConsequenceCondSet);
   assert(ConsequenceCondSet);
-  ConsequenceCondSet = isl_set_coalesce(
-      isl_set_intersect(ConsequenceCondSet, isl_set_copy(Domain)));
+  ConsequenceCondSet =
+      isl_set_coalesce(isl_set_intersect(ConsequenceCondSet, Domain.copy()));
 
   isl_set *AlternativeCondSet = nullptr;
   bool TooComplex =
       isl_set_n_basic_set(ConsequenceCondSet) >= MaxDisjunctsInDomain;
 
   if (!TooComplex) {
-    AlternativeCondSet = isl_set_subtract(isl_set_copy(Domain),
-                                          isl_set_copy(ConsequenceCondSet));
+    AlternativeCondSet =
+        isl_set_subtract(Domain.copy(), isl_set_copy(ConsequenceCondSet));
     TooComplex =
         isl_set_n_basic_set(AlternativeCondSet) >= MaxDisjunctsInDomain;
   }
 
   if (TooComplex) {
     S.invalidate(COMPLEXITY, TI ? TI->getDebugLoc() : DebugLoc(),
                  TI ? TI->getParent() : nullptr /* BasicBlock */);
     isl_set_free(AlternativeCondSet);
     isl_set_free(ConsequenceCondSet);
     return false;
   }
 
   ConditionSets.push_back(ConsequenceCondSet);
   ConditionSets.push_back(isl_set_coalesce(AlternativeCondSet));
 
   return true;
 }
 
 /// Build the conditions sets for the terminator @p TI in the @p Domain.
 ///
 /// This will fill @p ConditionSets with the conditions under which control
 /// will be moved from @p TI to its successors. Hence, @p ConditionSets will
 /// have as many elements as @p TI has successors.
 bool buildConditionSets(Scop &S, BasicBlock *BB, TerminatorInst *TI, Loop *L,
-                        __isl_keep isl_set *Domain,
-                        DenseMap<BasicBlock *, isl::set> &InvalidDomainMap,
+                        isl::set Domain, isl::set Context,
+                        isl::set &InvalidDomain,
                         SmallVectorImpl<__isl_give isl_set *> &ConditionSets) {
   if (SwitchInst *SI = dyn_cast<SwitchInst>(TI))
-    return buildConditionSets(S, BB, SI, L, Domain, InvalidDomainMap,
+    return buildConditionSets(S, BB, SI, L, Domain, InvalidDomain,
                               ConditionSets);
 
   assert(isa<BranchInst>(TI) && "Terminator was neither branch nor switch.");
 
   if (TI->getNumSuccessors() == 1) {
-    ConditionSets.push_back(isl_set_copy(Domain));
+    ConditionSets.push_back(Domain.copy());
     return true;
   }
 
   Value *Condition = getConditionFromTerminator(TI);
   assert(Condition && "No condition for Terminator");
 
-  return buildConditionSets(S, BB, Condition, TI, L, Domain, InvalidDomainMap,
-                            ConditionSets);
+  return buildConditionSets(S, BB, Condition, TI, L, Domain, Context,
+                            InvalidDomain, ConditionSets);
 }
 
 ScopStmt::ScopStmt(Scop &parent, Region &R, Loop *SurroundingLoop,
                    std::vector<Instruction *> EntryBlockInstructions)
     : Parent(parent), InvalidDomain(nullptr), Domain(nullptr), R(&R),
       Build(nullptr), SurroundingLoop(SurroundingLoop),
       Instructions(EntryBlockInstructions) {
   BaseName = getIslCompatibleName(
for (auto *Param : DetectedParams) {
       if (Parameters.count(Param))
         continue;
       NewParams.insert(Param);
     }
 
     SmallVector<isl_set *, 2> ConditionSets;
     auto *TI = InScop ? CI->getParent()->getTerminator() : nullptr;
     BasicBlock *BB = InScop ? CI->getParent() : getRegion().getEntry();
-    auto *Dom = InScop ? DomainMap[BB].copy() : Context.copy();
+    isl::set Dom = InScop ? DomainMap[BB] : Context;
     assert(Dom && "Cannot propagate a nullptr.");
-    bool Valid = buildConditionSets(*this, BB, Val, TI, L, Dom,
-                                    InvalidDomainMap, ConditionSets);
-    isl_set_free(Dom);
+    bool Valid = buildConditionSets(*this, BB, Val, TI, L, DomainMap[BB], Dom,
+                                    InvalidDomainMap[BB], ConditionSets);
 
     if (!Valid)
       continue;
 
     isl_set *AssumptionCtx = nullptr;
     if (InScop) {
       AssumptionCtx = isl_set_complement(isl_set_params(ConditionSets[1]));
       isl_set_free(ConditionSets[0]);
static isl::set boundFortranArrayParams(isl::set Context,
   return Context;
 }
 
 void Scop::realignParams() {
   if (PollyIgnoreParamBounds)
     return;
 
   // Add all parameters into a common model.
   isl::space Space = getFullParamSpace();
 
   // Align the parameters of all data structures to the model.
   Context = Context.align_params(Space);
 
   // Bound the size of the fortran array dimensions.
   Context = boundFortranArrayParams(Context, arrays());
 
   // As all parameters are known add bounds to them.
   addParameterBounds();
for (auto *RN : RTraversal) {
 
     // Build the condition sets for the successor nodes of the current region
     // node. If it is a non-affine subregion we will always execute the single
     // exit node, hence the single entry node domain is the condition set. For
     // basic blocks we use the helper function buildConditionSets.
     SmallVector<isl_set *, 8> ConditionSets;
     if (RN->isSubRegion())
       ConditionSets.push_back(Domain.copy());
-    else if (!buildConditionSets(*this, BB, TI, BBLoop, Domain.get(),
-                                 InvalidDomainMap, ConditionSets))
+    else if (!buildConditionSets(*this, BB, TI, BBLoop, Domain, Context,
+                                 InvalidDomainMap[BB], ConditionSets))
       return false;
 
     // Now iterate over the successors and set their initial domain based on
     // their condition set. We skip back edges here and have to be careful when
     // we leave a loop not to keep constraints over a dimension that doesn't
     // exist anymore.
     assert(RN->isSubRegion() || TI->getNumSuccessors() == ConditionSets.size());
     for (unsigned u = 0, e = ConditionSets.size(); u < e; u++) {
for (BasicBlock *LatchBB : LatchBlocks) {
     BranchInst *BI = dyn_cast<BranchInst>(TI);
     assert(BI && "Only branch instructions allowed in loop latches");
 
     if (BI->isUnconditional())
       BackedgeCondition = LatchBBDom;
     else {
       SmallVector<isl_set *, 8> ConditionSets;
       int idx = BI->getSuccessor(0) != HeaderBB;
-      if (!buildConditionSets(*this, LatchBB, TI, L, LatchBBDom.get(),
-                              InvalidDomainMap, ConditionSets))
+      if (!buildConditionSets(*this, LatchBB, TI, L, LatchBBDom, Context,
+                              InvalidDomainMap[LatchBB], ConditionSets))
         return false;
 
       // Free the non back edge condition set as we do not need it.
       isl_set_free(ConditionSets[1 - idx]);
 
       BackedgeCondition = isl::manage(ConditionSets[idx]);
     }
 

 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void Scop::dump() const { print(dbgs(), true); }
 #endif
 
 isl::ctx Scop::getIslCtx() const { return IslCtx.get(); }
 
-__isl_give PWACtx Scop::getPwAff(const SCEV *E, BasicBlock *BB,
+__isl_give PWACtx Scop::getPwAff(const SCEV *E, BasicBlock *BB, isl::set Domain,
                                  bool NonNegative) {
   // First try to use the SCEVAffinator to generate a piecewise defined
   // affine function from @p E in the context of @p BB. If that tasks becomes to
   // complex the affinator might return a nullptr. In such a case we invalidate
   // the SCoP and return a dummy value. This way we do not need to add error
   // handling code to all users of this function.
-  auto PWAC = Affinator.getPwAff(E, BB);
+  auto PWAC = Affinator.getPwAff(E, BB, Domain);
   if (PWAC.first) {
     // TODO: We could use a heuristic and either use:
     //         SCEVAffinator::takeNonNegativeAssumption
     //       or
     //         SCEVAffinator::interpretAsUnsigned
     //       to deal with unsigned or "NonNegative" SCEVs.
     if (NonNegative)
       Affinator.takeNonNegativeAssumption(PWAC);
     return PWAC;
   }
 
   auto DL = BB ? BB->getTerminator()->getDebugLoc() : DebugLoc();
   invalidate(COMPLEXITY, DL, BB);
-  return Affinator.getPwAff(SE->getZero(E->getType()), BB);
+  return Affinator.getPwAff(SE->getZero(E->getType()), BB, Domain);
 }
 
 isl::union_set Scop::getDomains() const {
   isl_space *EmptySpace = isl_space_params_alloc(getIslCtx().get(), 0);
   isl_union_set *Domain = isl_union_set_empty(EmptySpace);
 
   for (const ScopStmt &Stmt : *this)
     Domain = isl_union_set_add_set(Domain, Stmt.getDomain().release());

lib/Support/SCEVAffinator.cpp

void SCEVAffinator::takeNonNegativeAssumption(PWACtx &PWAC) {
   S->recordAssumption(UNSIGNED, isl::manage(Restriction), DL, AS_RESTRICTION,
                       BB);
 }
 
 PWACtx SCEVAffinator::getPWACtxFromPWA(isl::pw_aff PWA) {
   return std::make_pair(PWA, isl::set::empty(isl::space(Ctx, 0, NumIterators)));
 }
 
-PWACtx SCEVAffinator::getPwAff(const SCEV *Expr, BasicBlock *BB) {
+PWACtx SCEVAffinator::getPwAff(const SCEV *Expr, BasicBlock *BB,
+                               isl::set Domain) {
   this->BB = BB;
 
-  if (BB) {
-    auto *DC = S->getDomainConditions(BB).release();
-    NumIterators = isl_set_n_dim(DC);
-    isl_set_free(DC);
-  } else
+  if (Domain)
+    NumIterators = isl_set_n_dim(Domain.get());
+  else
     NumIterators = 0;
 
   return visit(Expr);
 }
 
 PWACtx SCEVAffinator::checkForWrapping(const SCEV *Expr, PWACtx PWAC) const {
   // If the SCEV flags do contain NSW (no signed wrap) then PWA already
   // represents Expr in modulo semantic (it is not allowed to overflow), thus we