[Polly][Isl] Use the function unsignedFromIslSize to manage a isl::size object. NFCI

[patacca]

Summary

This is part of an effort to reduce the differences between the custom C++ bindings used right now by polly in lib/External/isl/include/isl/isl-noxceptions.h and the official isl C++ interface.
In the official interface the type isl::size cannot be casted to an unsigned without previously having checked if it contains a valid value with the function isl::size::is_error().
For this reason two helping functions have been added:

• IslAssert: assert that no errors are present in debug builds and just disables the mandatory error check in non-debug builds
• unisgnedFromIslSIze: cast the isl::size object to unsigned

Changes made:

• Add the functions IslAssert and unsignedFromIslSize
• Add the utility function rangeIslSize()
• Retype MaxDisjunctsInDomain from int to unsigned
• Retype RunTimeChecksMaxAccessDisjuncts from int to unsigned
• Retype MaxDimensionsInAccessRange from int to unsigned
• Replaced some usages of isl_size to unsigned since we aim not to use isl_size anymore
• isl-noexceptions.h has been generated by https://github.com/patacca/isl/commit/e704f73c88f0b4d88e62e447bdb732cf5914094b

No functional change intended.

[patacca]

Fix code style

[patacca]

I've tested it with the llvm test suite and it's showing 1 test failing but it's not related to this patch (MultiSource/Applications/lambda-0.1.3/lambda.test)

I added the IslAssert function with the idea that it might be useful but in the end we just use unsignedFromIslSize so tell me if you think it's better to remove it

[Meinersbur]

Nice one!

In D113101#3107069, @patacca wrote:

I've tested it with the llvm test suite and it's showing 1 test failing but it's not related to this patch (MultiSource/Applications/lambda-0.1.3/lambda.test)

I remember I fixed the lambda failure. The buildbot shows green (http://meinersbur.de:8011/#/builders/76/builds/1306). Have you tested with the latest version of LLVM/Polly?

polly/include/polly/Support/ISLTools.h

26

Suggestion for an explanation on why calling a getter disables error checking.

27

Although is_error it doesn't have a [[nodiscard]] attribute (yet), adding (void) marks that we are intentionally ignoring the result.

523–528

nice!

polly/lib/Analysis/ScopBuilder.cpp

201–202

The coding standard rule is to only use auto if the type already appears on the right. Since you are removing <isl_size>, auto should be replaced by the concrete type.

polly/lib/External/isl/include/isl/isl-noexceptions.h

201

unrelated change?

polly/lib/Transform/ScheduleTreeTransform.cpp

1189

1190

[nit] Updating changed line to the latest coding standard.

[patacca]

In D113101#3107313, @Meinersbur wrote:

In D113101#3107069, @patacca wrote:

I've tested it with the llvm test suite and it's showing 1 test failing but it's not related to this patch (MultiSource/Applications/lambda-0.1.3/lambda.test)

I remember I fixed the lambda failure. The buildbot shows green (http://meinersbur.de:8011/#/builders/76/builds/1306). Have you tested with the latest version of LLVM/Polly?

For some reason I cannot reach the link you posted. Anyway after I tested it again with a fresh new build of llvm-suite the error in the lambda test disappeared.

polly/lib/External/isl/include/isl/isl-noexceptions.h

201

This one was a leftover blank space that was removed in this commit https://github.com/patacca/isl/commit/e704f73c88f0b4d88e62e447bdb732cf5914094b
Since then nobody actually updated isl-noexceptions.h

[patacca]

• Fix coding style (replace auto with unsigned)
• Better explainatory comment for islAssert
• Mark the result of intentionally discarded value with void casting

[Meinersbur]

LGTM, thanks for picking this up again.

polly/lib/External/isl/include/isl/isl-noexceptions.h

201

Seems that was me. Different editors have different understanding of whether \n is a line terminator (i.e. even the last line ends with \n) or line separator (i.e. no \n on last line). See https://en.wikipedia.org/wiki/Newline#Interpretation

[foad]

Hi, this seems to have introduced a couple of warnings in my LLVM build (a release build with polly enabled, using clang 10 as the host compiler):

[3071/3609] Building CXX object tools/polly/lib/CMakeFiles/obj.Polly.dir/Support/ISLTools.cpp.o
/home/jayfoad2/git/llvm-project/polly/lib/Support/ISLTools.cpp:220:14: warning: comparison of integers of different signs: 'int' and 'unsigned int' [-Wsign-compare]
  assert(Pos < NumDims && "Dimension index must be in range");
         ~~~ ^ ~~~~~~~
/usr/include/assert.h:93:27: note: expanded from macro 'assert'
     (static_cast <bool> (expr)                                         \
                          ^~~~
/home/jayfoad2/git/llvm-project/polly/lib/Support/ISLTools.cpp:241:14: warning: comparison of integers of different signs: 'int' and 'unsigned int' [-Wsign-compare]
  assert(Pos < NumDims && "Dimension index must be in range");
         ~~~ ^ ~~~~~~~
/usr/include/assert.h:93:27: note: expanded from macro 'assert'
     (static_cast <bool> (expr)                                         \
                          ^~~~
2 warnings generated.

polly/include/polly/ScheduleTreeTransform.h

 //===- polly/ScheduleTreeTransform.h ----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Make changes to isl's schedule tree data structure.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef POLLY_SCHEDULETREETRANSFORM_H
 #define POLLY_SCHEDULETREETRANSFORM_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "polly/Support/ISLTools.h"
 #include "isl/isl-noexceptions.h"
 #include <cassert>
 
 namespace polly {
 struct BandAttr;
 
 /// This class defines a simple visitor class that may be used for
 /// various schedule tree analysis purposes.
struct RecursiveScheduleTreeVisitor
   // Necessary to allow overload resolution with the added visit(isl::schedule)
   // overload.
   RetTy visit(isl::schedule_node Node, Args... args) {
     return getBase().visit(Node, std::forward<Args>(args)...);
   }
 
   /// By default, recursively visit the child nodes.
   RetTy visitNode(isl::schedule_node Node, Args... args) {
-    isl_size NumChildren = Node.n_children().release();
-    for (isl_size i = 0; i < NumChildren; i += 1)
+    for (unsigned i : rangeIslSize(0, Node.n_children()))
       getDerived().visit(Node.child(i), std::forward<Args>(args)...);
     return RetTy();
   }
 };
 
 /// Is this node the marker for its parent band?
 bool isBandMark(const isl::schedule_node &Node);
 

 
 /// Create an isl::union_set, which describes the isolate option based on
 /// IsolateDomain.
 ///
 /// @param IsolateDomain An isl::set whose @p OutDimsNum last dimensions should
 ///                      belong to the current band node.
 /// @param OutDimsNum    A number of dimensions that should belong to
 ///                      the current band node.
-isl::union_set getIsolateOptions(isl::set IsolateDomain, isl_size OutDimsNum);
+isl::union_set getIsolateOptions(isl::set IsolateDomain, unsigned OutDimsNum);
 
 /// Create an isl::union_set, which describes the specified option for the
 /// dimension of the current node.
 ///
 /// @param Ctx    An isl::ctx, which is used to create the isl::union_set.
 /// @param Option The name of the option.
 isl::union_set getDimOptions(isl::ctx Ctx, const char *Option);
 

polly/include/polly/ScopInfo.h

 
 //===---------------------------------------------------------------------===//
 
 extern bool UseInstructionNames;
 
 // The maximal number of basic sets we allow during domain construction to
 // be created. More complex scops will result in very high compile time and
 // are also unlikely to result in good code.
-extern int const MaxDisjunctsInDomain;
+extern unsigned const MaxDisjunctsInDomain;
 
 /// The different memory kinds used in Polly.
 ///
 /// We distinguish between arrays and various scalar memory objects. We use
 /// the term ``array'' to describe memory objects that consist of a set of
 /// individual data elements arranged in a multi-dimensional grid. A scalar
 /// memory object describes an individual data element and is used to model
 /// the definition and uses of llvm::Values.

polly/include/polly/Support/ISLTools.h

 //===------ ISLTools.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Tools, utilities, helpers and extensions useful in conjunction with the
 // Integer Set Library (isl).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef POLLY_ISLTOOLS_H
 #define POLLY_ISLTOOLS_H
 
 #include "llvm/ADT/iterator.h"
+#include "llvm/ADT/Sequence.h"
 #include "isl/isl-noexceptions.h"
+#include <cassert>
+
+/// In debug builds assert that the @p Size is valid, in non-debug builds
+/// disable the mandatory state checking but do not enforce the error checking.
+inline void islAssert(const isl::size &Size) {
+#ifdef NDEBUG
+  // Don't force error checking in non-debug builds.
+  Size.is_error();
+#else
+  // Assert on error in debug builds.
+  assert(!Size.is_error());
+#endif
+}
+
+/// Check that @p Size is valid (only on debug builds) and cast it to unsigned.
+/// Cast the @p Size to unsigned. If the @p Size is not valid (Size.is_error() == true) then
+/// an assert and an abort are triggered.
+inline unsigned unsignedFromIslSize(const isl::size &Size) {
+  islAssert(Size);
+  return static_cast<unsigned>(Size);
+}
 
 namespace isl {
 inline namespace noexceptions {
 
 template <typename ListT>
 using list_element_type = decltype(std::declval<ListT>().get_at(0));
 
 template <typename ListT>

 /// Determine how many dimensions the scatter space of @p Schedule has.
 ///
 /// The schedule must not be empty and have equal number of dimensions of any
 /// subspace it contains.
 ///
 /// The implementation currently returns the maximum number of dimensions it
 /// encounters, if different, and 0 if none is encountered. However, most other
 /// code will most likely fail if one of these happen.
-isl_size getNumScatterDims(const isl::union_map &Schedule);
+unsigned getNumScatterDims(const isl::union_map &Schedule);
 
 /// Return the scatter space of a @p Schedule.
 ///
 /// This is basically the range space of the schedule map, but harder to
 /// determine because it is an isl_union_map.
 isl::space getScatterSpace(const isl::union_map &Schedule);
 
 /// Construct an identity map for the given domain values.

 /// Subtract the parameter space @p Params from @p Set.
 isl::set subtractParams(isl::set Set, isl::set Params);
 
 /// If @p PwAff maps to a constant, return said constant. If @p Max/@p Min, it
 /// can also be a piecewise constant and it would return the minimum/maximum
 /// value. Otherwise, return NaN.
 isl::val getConstant(isl::pw_aff PwAff, bool Max, bool Min);
 
+/// Check that @p End is valid and return an iterator from @p Begin to @p End
+///
+/// Use case example:
+///   for (unsigned i : rangeIslSize(0, Map.domain_tuple_dim()))
+///     // do stuff
+llvm::iota_range<unsigned> rangeIslSize(unsigned Begin, isl::size End);
+
 /// Dump a description of the argument to llvm::errs().
 ///
 /// In contrast to isl's dump function, there are a few differences:
 /// - Each polyhedron (pieces) is written on its own line.
 /// - Spaces are sorted by structure. E.g. maps with same domain space are
 ///   grouped. Isl sorts them according to the space's hash function.
 /// - Pieces of the same space are sorted using their lower bound.
 /// - A more compact to_str representation is used instead of Isl's dump

polly/lib/Analysis/DependenceInfo.cpp

static void collectInfo(Scop &S, isl_union_map *&Read,
   ReductionTagMap = isl_union_map_coalesce(ReductionTagMap);
   Read = isl_union_map_coalesce(Read);
   MustWrite = isl_union_map_coalesce(MustWrite);
   MayWrite = isl_union_map_coalesce(MayWrite);
 }
 
 /// Fix all dimension of @p Zero to 0 and add it to @p user
 static void fixSetToZero(isl::set Zero, isl::union_set *User) {
-  for (auto i : seq<isl_size>(0, Zero.tuple_dim().release()))
+  for (auto i : rangeIslSize(0, Zero.tuple_dim()))
     Zero = Zero.fix_si(isl::dim::set, i, 0);
   *User = User->unite(Zero);
 }
 
 /// Compute the privatization dependences for a given dependency @p Map
 ///
 /// Privatization dependences are widened original dependences which originate
 /// or end in a reduction access. To compute them we apply the transitive close
for (ScopStmt &Stmt : S) {
 
     Schedule = Schedule.unite(StmtScat);
   }
 
   Dependences = Dependences.apply_domain(Schedule);
   Dependences = Dependences.apply_range(Schedule);
 
   isl::set Zero = isl::set::universe(ScheduleSpace);
-  for (auto i : seq<isl_size>(0, Zero.tuple_dim().release()))
+  for (auto i : rangeIslSize(0, Zero.tuple_dim()))
     Zero = Zero.fix_si(isl::dim::set, i, 0);
 
   isl::union_set UDeltas = Dependences.deltas();
   isl::set Deltas = singleton(UDeltas, ScheduleSpace);
 
   isl::space Space = Deltas.get_space();
   isl::map NonPositive = isl::map::universe(Space.map_from_set());
   NonPositive =

polly/lib/Analysis/ScopBuilder.cpp

STATISTIC(InfeasibleScops,
           "Number of SCoPs with statically infeasible context.");
 
 bool polly::ModelReadOnlyScalars;
 
 // The maximal number of dimensions we allow during invariant load construction.
 // More complex access ranges will result in very high compile time and are also
 // unlikely to result in good code. This value is very high and should only
 // trigger for corner cases (e.g., the "dct_luma" function in h264, SPEC2006).
-static int const MaxDimensionsInAccessRange = 9;
+static unsigned const MaxDimensionsInAccessRange = 9;
 
 static cl::opt<bool, true> XModelReadOnlyScalars(
     "polly-analyze-read-only-scalars",
     cl::desc("Model read-only scalar values in the scop description"),
     cl::location(ModelReadOnlyScalars), cl::Hidden, cl::ZeroOrMore,
     cl::init(true), cl::cat(PollyCategory));
 
 static cl::opt<int>
PollyIgnoreInbounds("polly-ignore-inbounds",
                         cl::desc("Do not take inbounds assumptions at all"),
                         cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
 static cl::opt<unsigned> RunTimeChecksMaxArraysPerGroup(
     "polly-rtc-max-arrays-per-group",
     cl::desc("The maximal number of arrays to compare in each alias group."),
     cl::Hidden, cl::ZeroOrMore, cl::init(20), cl::cat(PollyCategory));
 
-static cl::opt<int> RunTimeChecksMaxAccessDisjuncts(
+static cl::opt<unsigned> RunTimeChecksMaxAccessDisjuncts(
     "polly-rtc-max-array-disjuncts",
     cl::desc("The maximal number of disjunts allowed in memory accesses to "
              "to build RTCs."),
     cl::Hidden, cl::ZeroOrMore, cl::init(8), cl::cat(PollyCategory));
 
 static cl::opt<unsigned> RunTimeChecksMaxParameters(
     "polly-rtc-max-parameters",
     cl::desc("The maximal number of parameters allowed in RTCs."), cl::Hidden,

 /// This map maps from SetSpace -> SetSpace where the dimensions @p Dim
 /// is incremented by one and all other dimensions are equal, e.g.,
 ///             [i0, i1, i2, i3] -> [i0, i1, i2 + 1, i3]
 ///
 /// if @p Dim is 2 and @p SetSpace has 4 dimensions.
 static isl::map createNextIterationMap(isl::space SetSpace, unsigned Dim) {
   isl::space MapSpace = SetSpace.map_from_set();
   isl::map NextIterationMap = isl::map::universe(MapSpace);
-  for (auto u : seq<isl_size>(0, NextIterationMap.domain_tuple_dim().release()))
-    if (u != (isl_size)Dim)
+  for (auto u : rangeIslSize(0, NextIterationMap.domain_tuple_dim()))
+    if (u != Dim)
       NextIterationMap =
           NextIterationMap.equate(isl::dim::in, u, isl::dim::out, u);
   isl::constraint C =
       isl::constraint::alloc_equality(isl::local_space(MapSpace));
   C = C.set_constant_si(1);
   C = C.set_coefficient_si(isl::dim::in, Dim, 1);
   C = C.set_coefficient_si(isl::dim::out, Dim, -1);
   NextIterationMap = NextIterationMap.add_constraint(C);

 }
 
 /// Compute the (un)bounded parts of @p S wrt. to dimension @p Dim.
 ///
 /// @returns A separation of @p S into first an unbounded then a bounded subset,
 ///          both with regards to the dimension @p Dim.
 static std::pair<isl::set, isl::set> partitionSetParts(isl::set S,
                                                        unsigned Dim) {
-  for (unsigned u = 0, e = S.tuple_dim().release(); u < e; u++)
+  for (unsigned u : rangeIslSize(0, S.tuple_dim()))
     S = S.lower_bound_si(isl::dim::set, u, 0);
 
-  unsigned NumDimsS = S.tuple_dim().release();
+  unsigned NumDimsS = unsignedFromIslSize(S.tuple_dim());
   isl::set OnlyDimS = S;
 
   // Remove dimensions that are greater than Dim as they are not interesting.
   assert(NumDimsS >= Dim + 1);
   OnlyDimS = OnlyDimS.project_out(isl::dim::set, Dim + 1, NumDimsS - Dim - 1);
 
   // Create artificial parametric upper bounds for dimensions smaller than Dim
   // as we are not interested in them.
if (OldDepth == NewDepth) {
     assert(OldDepth + 1 == NewDepth);
     auto &R = scop->getRegion();
     (void)R;
     assert(NewL->getParentLoop() == OldL ||
            ((!OldL || !R.contains(OldL)) && R.contains(NewL)));
     Dom = Dom.add_dims(isl::dim::set, 1);
   } else {
     assert(OldDepth > NewDepth);
-    int Diff = OldDepth - NewDepth;
-    int NumDim = Dom.tuple_dim().release();
+    unsigned Diff = OldDepth - NewDepth;
+    unsigned NumDim = unsignedFromIslSize(Dom.tuple_dim());
     assert(NumDim >= Diff);
     Dom = Dom.project_out(isl::dim::set, NumDim - Diff, Diff);
   }
 
   return Dom;
 }
 
 /// Compute the isl representation for the SCEV @p E in this BB.
bool ScopBuilder::buildConditionSets(
   if (!TI)
     ConsequenceCondSet = isl_set_params(ConsequenceCondSet);
   assert(ConsequenceCondSet);
   ConsequenceCondSet = isl_set_coalesce(
       isl_set_intersect(ConsequenceCondSet, isl_set_copy(Domain)));
 
   isl_set *AlternativeCondSet = nullptr;
   bool TooComplex =
-      isl_set_n_basic_set(ConsequenceCondSet) >= MaxDisjunctsInDomain;
+      isl_set_n_basic_set(ConsequenceCondSet) >= (int)MaxDisjunctsInDomain;
 
   if (!TooComplex) {
     AlternativeCondSet = isl_set_subtract(isl_set_copy(Domain),
                                           isl_set_copy(ConsequenceCondSet));
     TooComplex =
-        isl_set_n_basic_set(AlternativeCondSet) >= MaxDisjunctsInDomain;
+        isl_set_n_basic_set(AlternativeCondSet) >= (int)MaxDisjunctsInDomain;
   }
 
   if (TooComplex) {
     scop->invalidate(COMPLEXITY, TI ? TI->getDebugLoc() : DebugLoc(),
                      TI ? TI->getParent() : nullptr /* BasicBlock */);
     isl_set_free(AlternativeCondSet);
     isl_set_free(ConsequenceCondSet);
     return false;
for (auto *RN : RTraversal) {
 
     if (isa<UnreachableInst>(TI))
       continue;
 
     if (!scop->isDomainDefined(BB))
       continue;
     isl::set Domain = scop->getDomainConditions(BB);
 
-    scop->updateMaxLoopDepth(Domain.tuple_dim().release());
+    scop->updateMaxLoopDepth(unsignedFromIslSize(Domain.tuple_dim()));
 
     auto *BBLoop = getRegionNodeLoop(RN, LI);
     // Propagate the domain from BB directly to blocks that have a superset
     // domain, at the moment only region exit nodes of regions that start in BB.
     propagateDomainConstraintsToRegionExit(BB, BBLoop, FinishedExitBlocks,
                                            InvalidDomainMap);
 
     // If all successors of BB have been set a domain through the propagation
for (unsigned u = 0, e = ConditionSets.size(); u < e; u++) {
         InvalidDomainMap[SuccBB] = CondSet.empty(CondSet.get_space());
         SuccDomain = CondSet;
       }
 
       SuccDomain = SuccDomain.detect_equalities();
 
       // Check if the maximal number of domain disjunctions was reached.
       // In case this happens we will clean up and bail.
-      if (SuccDomain.n_basic_set().release() < MaxDisjunctsInDomain)
+      if (unsignedFromIslSize(SuccDomain.n_basic_set()) < MaxDisjunctsInDomain)
         continue;
 
       scop->invalidate(COMPLEXITY, DebugLoc());
       while (++u < ConditionSets.size())
         isl_set_free(ConditionSets[u]);
       return false;
     }
   }
for (unsigned u = 0; u < NumSuccs; u++) {
       isl::set SuccInvalidDomain = InvalidDomainMap[SuccBB];
       SuccInvalidDomain = SuccInvalidDomain.unite(AdjustedInvalidDomain);
       SuccInvalidDomain = SuccInvalidDomain.coalesce();
 
       InvalidDomainMap[SuccBB] = SuccInvalidDomain;
 
       // Check if the maximal number of domain disjunctions was reached.
       // In case this happens we will bail.
-      if (SuccInvalidDomain.n_basic_set().release() < MaxDisjunctsInDomain)
+      if (unsignedFromIslSize(SuccInvalidDomain.n_basic_set()) < MaxDisjunctsInDomain)
         continue;
 
       InvalidDomainMap.erase(BB);
       scop->invalidate(COMPLEXITY, TI->getDebugLoc(), TI->getParent());
       return false;
     }
 
     InvalidDomainMap[BB] = InvalidDomain;

 //                 N: 1
 //
 // Resulting Mapping: { {A[i,j] -> [(j)]; B[i,j,k] -> [(j)] }
 //
 // @param USet   A union set describing the elements for which to generate a
 //               mapping.
 // @param N      The dimension to map to.
 // @returns      A mapping from USet to its N-th dimension.
-static isl::multi_union_pw_aff mapToDimension(isl::union_set USet, int N) {
-  assert(N >= 0);
+static isl::multi_union_pw_aff mapToDimension(isl::union_set USet, unsigned N) {
   assert(!USet.is_null());
   assert(!USet.is_empty());
 
   auto Result = isl::union_pw_multi_aff::empty(USet.get_space());
 
   for (isl::set S : USet.get_set_list()) {
-    int Dim = S.tuple_dim().release();
+    unsigned Dim = unsignedFromIslSize(S.tuple_dim());
+    assert(Dim >= N);
     auto PMA = isl::pw_multi_aff::project_out_map(S.get_space(), isl::dim::set,
                                                   N, Dim - N);
     if (N > 1)
       PMA = PMA.drop_dims(isl::dim::out, 0, N - 1);
 
     Result = Result.add_pw_multi_aff(PMA);
   }
 
for (auto Array : scop->arrays()) {
 
     if (!Accessed.contains(Space))
       continue;
 
     isl::set Elements = Accessed.extract_set(Space);
     isl::map Transform = isl::map::universe(Array->getSpace().map_from_set());
 
     std::vector<int> Int;
-    int Dims = Elements.tuple_dim().release();
-    for (int i = 0; i < Dims; i++) {
+    unsigned Dims = unsignedFromIslSize(Elements.tuple_dim());
+    for (unsigned i = 0; i < Dims; i++) {
       isl::set DimOnly = isl::set(Elements).project_out(isl::dim::set, 0, i);
       DimOnly = DimOnly.project_out(isl::dim::set, 1, Dims - i - 1);
       DimOnly = DimOnly.lower_bound_si(isl::dim::set, 0, 0);
 
       isl::basic_set DimHull = DimOnly.affine_hull();
 
       if (i == Dims - 1) {
         Int.push_back(1);
         Transform = Transform.equate(isl::dim::in, i, isl::dim::out, i);
         continue;
       }
 
-      if (DimHull.dim(isl::dim::div).release() == 1) {
+      if (unsignedFromIslSize(DimHull.dim(isl::dim::div)) == 1) {
         isl::aff Diff = DimHull.get_div(0);
         isl::val Val = Diff.get_denominator_val();
 
         int ValInt = 1;
         if (Val.is_int()) {
           auto ValAPInt = APIntFromVal(Val);
           if (ValAPInt.isSignedIntN(32))
             ValInt = ValAPInt.getSExtValue();

 /// set dimensions is larger than a threshold. This reliably detects both
 /// sets with many disjuncts as well as sets with many divisions as they
 /// arise in h264.
 ///
 /// @param AccessRange The range to check for complexity.
 ///
 /// @returns True if the access range is too complex.
 static bool isAccessRangeTooComplex(isl::set AccessRange) {
-  int NumTotalDims = 0;
+  unsigned NumTotalDims = 0;
 
   for (isl::basic_set BSet : AccessRange.get_basic_set_list()) {
-    NumTotalDims += BSet.dim(isl::dim::div).release();
-    NumTotalDims += BSet.dim(isl::dim::set).release();
+    NumTotalDims += unsignedFromIslSize(BSet.dim(isl::dim::div));
+    NumTotalDims += unsignedFromIslSize(BSet.dim(isl::dim::set));
   }
 
   if (NumTotalDims > MaxDimensionsInAccessRange)
     return true;
 
   return false;
 }
 

 }
 
 void ScopBuilder::addUserContext() {
   if (UserContextStr.empty())
     return;
 
   isl::set UserContext = isl::set(scop->getIslCtx(), UserContextStr.c_str());
   isl::space Space = scop->getParamSpace();
-  if (Space.dim(isl::dim::param).release() !=
-      UserContext.dim(isl::dim::param).release()) {
+  isl::size SpaceParams = Space.dim(isl::dim::param);
+  if (unsignedFromIslSize(SpaceParams) !=
+      unsignedFromIslSize(UserContext.dim(isl::dim::param))) {
     std::string SpaceStr = stringFromIslObj(Space, "null");
     errs() << "Error: the context provided in -polly-context has not the same "
            << "number of dimensions than the computed context. Due to this "
            << "mismatch, the -polly-context option is ignored. Please provide "
            << "the context in the parameter space: " << SpaceStr << ".\n";
     return;
   }
 
-  for (auto i : seq<isl_size>(0, Space.dim(isl::dim::param).release())) {
+  for (auto i : rangeIslSize(0, SpaceParams)) {
     std::string NameContext =
         scop->getContext().get_dim_name(isl::dim::param, i);
     std::string NameUserContext = UserContext.get_dim_name(isl::dim::param, i);
 
     if (NameContext != NameUserContext) {
       std::string SpaceStr = stringFromIslObj(Space, "null");
       errs() << "Error: the name of dimension " << i
              << " provided in -polly-context "
isl::set ScopBuilder::getNonHoistableCtx(MemoryAccess *Access,
   isl::union_map Written = Writes.intersect_range(SafeToLoad);
   isl::set WrittenCtx = Written.params();
   bool IsWritten = !WrittenCtx.is_empty();
 
   if (!IsWritten)
     return WrittenCtx;
 
   WrittenCtx = WrittenCtx.remove_divs();
-  bool TooComplex = WrittenCtx.n_basic_set().release() >= MaxDisjunctsInDomain;
+  bool TooComplex = unsignedFromIslSize(WrittenCtx.n_basic_set()) >= MaxDisjunctsInDomain;
   if (TooComplex || !isRequiredInvariantLoad(LI))
     return {};
 
   scop->addAssumption(INVARIANTLOAD, WrittenCtx, LI->getDebugLoc(),
                       AS_RESTRICTION, LI->getParent());
   return WrittenCtx;
 }
 
void ScopBuilder::addInvariantLoads(ScopStmt &Stmt,
   isl::set StmtInvalidCtx = Stmt.getInvalidContext();
   bool StmtInvalidCtxIsEmpty = StmtInvalidCtx.is_empty();
 
   // Get the context under which the statement is executed but remove the error
   // context under which this statement is reached.
   isl::set DomainCtx = Stmt.getDomain().params();
   DomainCtx = DomainCtx.subtract(StmtInvalidCtx);
 
-  if (DomainCtx.n_basic_set().release() >= MaxDisjunctsInDomain) {
+  if (unsignedFromIslSize(DomainCtx.n_basic_set()) >= MaxDisjunctsInDomain) {
     auto *AccInst = InvMAs.front().MA->getAccessInstruction();
     scop->invalidate(COMPLEXITY, AccInst->getDebugLoc(), AccInst->getParent());
     return;
   }
 
   // Project out all parameters that relate to loads in the statement. Otherwise
   // we could have cyclic dependences on the constraints under which the
   // hoisted loads are executed and we could not determine an order in which to
static bool buildMinMaxAccess(isl::set Set,
   isl::pw_multi_aff MinPMA, MaxPMA;
   isl::pw_aff LastDimAff;
   isl::aff OneAff;
   unsigned Pos;
 
   Set = Set.remove_divs();
   polly::simplify(Set);
 
-  if (Set.n_basic_set().release() > RunTimeChecksMaxAccessDisjuncts)
+  if (unsignedFromIslSize(Set.n_basic_set()) > RunTimeChecksMaxAccessDisjuncts)
     Set = Set.simple_hull();
 
   // Restrict the number of parameters involved in the access as the lexmin/
   // lexmax computation will take too long if this number is high.
   //
   // Experiments with a simple test case using an i7 4800MQ:
   //
   //  #Parameters involved | Time (in sec)
static bool buildMinMaxAccess(isl::set Set,
   }
 
   MinPMA = Set.lexmin_pw_multi_aff();
   MaxPMA = Set.lexmax_pw_multi_aff();
 
   MinPMA = MinPMA.coalesce();
   MaxPMA = MaxPMA.coalesce();
 
+  if (MaxPMA.is_null())
+    return false;
+  
+  unsigned MaxOutputSize = unsignedFromIslSize(MaxPMA.dim(isl::dim::out));
+
   // Adjust the last dimension of the maximal access by one as we want to
   // enclose the accessed memory region by MinPMA and MaxPMA. The pointer
   // we test during code generation might now point after the end of the
   // allocated array but we will never dereference it anyway.
-  assert((MaxPMA.is_null() || MaxPMA.dim(isl::dim::out).release()) &&
-         "Assumed at least one output dimension");
+  assert(MaxOutputSize >= 1 && "Assumed at least one output dimension");
 
-  Pos = MaxPMA.dim(isl::dim::out).release() - 1;
+  Pos = MaxOutputSize - 1;
   LastDimAff = MaxPMA.at(Pos);
   OneAff = isl::aff(isl::local_space(LastDimAff.get_domain_space()));
   OneAff = OneAff.add_constant_si(1);
   LastDimAff = LastDimAff.add(OneAff);
   MaxPMA = MaxPMA.set_pw_aff(Pos, LastDimAff);
 
   if (MinPMA.is_null() || MaxPMA.is_null())
     return false;
if (LimitReached)
       break;
   }
 
   return !LimitReached;
 }
 
 static isl::set getAccessDomain(MemoryAccess *MA) {
   isl::set Domain = MA->getStatement()->getDomain();
-  Domain = Domain.project_out(isl::dim::set, 0, Domain.tuple_dim().release());
+  Domain = Domain.project_out(isl::dim::set, 0, unsignedFromIslSize(Domain.tuple_dim()));
   return Domain.reset_tuple_id();
 }
 
 bool ScopBuilder::buildAliasChecks() {
   if (!PollyUseRuntimeAliasChecks)
     return true;
 
   if (buildAliasGroups()) {

polly/lib/Analysis/ScopInfo.cpp

STATISTIC(
     "Number of scalar value writes nested in affine loops after ScopInfo");
 STATISTIC(NumPHIWrites, "Number of scalar phi writes after ScopInfo");
 STATISTIC(NumPHIWritesInLoops,
           "Number of scalar phi writes nested in affine loops after ScopInfo");
 STATISTIC(NumSingletonWrites, "Number of singleton writes after ScopInfo");
 STATISTIC(NumSingletonWritesInLoops,
           "Number of singleton writes nested in affine loops after ScopInfo");
 
-int const polly::MaxDisjunctsInDomain = 20;
+unsigned const polly::MaxDisjunctsInDomain = 20;
 
 // The number of disjunct in the context after which we stop to add more
 // disjuncts. This parameter is there to avoid exponential growth in the
 // number of disjunct when adding non-convex sets to the context.
 static int const MaxDisjunctsInContext = 4;
 
 // Be a bit more generous for the defined behavior context which is used less
 // often.

 }
 
 void MemoryAccess::updateDimensionality() {
   auto *SAI = getScopArrayInfo();
   isl::space ArraySpace = SAI->getSpace();
   isl::space AccessSpace = AccessRelation.get_space().range();
   isl::ctx Ctx = ArraySpace.ctx();
 
-  auto DimsArray = ArraySpace.dim(isl::dim::set).release();
-  auto DimsAccess = AccessSpace.dim(isl::dim::set).release();
-  auto DimsMissing = DimsArray - DimsAccess;
+  unsigned DimsArray = unsignedFromIslSize(ArraySpace.dim(isl::dim::set));
+  unsigned DimsAccess = unsignedFromIslSize(AccessSpace.dim(isl::dim::set));
+  assert(DimsArray >= DimsAccess);
+  unsigned DimsMissing = DimsArray - DimsAccess;
 
   auto *BB = getStatement()->getEntryBlock();
   auto &DL = BB->getModule()->getDataLayout();
   unsigned ArrayElemSize = SAI->getElemSizeInBytes();
   unsigned ElemBytes = DL.getTypeAllocSize(getElementType());
 
   isl::map Map = isl::map::from_domain_and_range(
       isl::set::universe(AccessSpace), isl::set::universe(ArraySpace));
 
-  for (auto i : seq<isl_size>(0, DimsMissing))
+  for (auto i : seq<unsigned>(0, DimsMissing))
     Map = Map.fix_si(isl::dim::out, i, 0);
 
-  for (auto i : seq<isl_size>(DimsMissing, DimsArray))
+  for (auto i : seq<unsigned>(DimsMissing, DimsArray))
     Map = Map.equate(isl::dim::in, i - DimsMissing, isl::dim::out, i);
 
   AccessRelation = AccessRelation.apply_range(Map);
 
   // For the non delinearized arrays, divide the access function of the last
   // subscript by the size of the elements in the array.
   //
   // A stride one array access in C expressed as A[i] is expressed in
void MemoryAccess::updateDimensionality() {
   // Introduce multi-element accesses in case the type loaded by this memory
   // access is larger than the canonical element type of the array.
   //
   // An access ((float *)A)[i] to an array char *A is modeled as
   // {[i] -> A[o] : 4 i <= o <= 4 i + 3
   if (ElemBytes > ArrayElemSize) {
     assert(ElemBytes % ArrayElemSize == 0 &&
            "Loaded element size should be multiple of canonical element size");
+    assert(DimsArray >= 1);
     isl::map Map = isl::map::from_domain_and_range(
         isl::set::universe(ArraySpace), isl::set::universe(ArraySpace));
-    for (auto i : seq<isl_size>(0, DimsArray - 1))
+    for (auto i : seq<unsigned>(0, DimsArray - 1))
       Map = Map.equate(isl::dim::in, i, isl::dim::out, i);
 
     isl::constraint C;
     isl::local_space LS;
 
     LS = isl::local_space(Map.get_space());
     int Num = ElemBytes / getScopArrayInfo()->getElemSizeInBytes();
 

 }
 
 bool MemoryAccess::isStrideX(isl::map Schedule, int StrideWidth) const {
   isl::set Stride, StrideX;
   bool IsStrideX;
 
   Stride = getStride(Schedule);
   StrideX = isl::set::universe(Stride.get_space());
-  for (auto i : seq<isl_size>(0, StrideX.tuple_dim().release() - 1))
+  int Size = unsignedFromIslSize(StrideX.tuple_dim());
+  for (auto i : seq<int>(0, Size - 1))
     StrideX = StrideX.fix_si(isl::dim::set, i, 0);
-  StrideX = StrideX.fix_si(isl::dim::set, StrideX.tuple_dim().release() - 1,
-                           StrideWidth);
+  StrideX = StrideX.fix_si(isl::dim::set, Size - 1, StrideWidth);
   IsStrideX = Stride.is_subset(StrideX);
 
   return IsStrideX;
 }
 
 bool MemoryAccess::isStrideZero(isl::map Schedule) const {
   return isStrideX(Schedule, 0);
 }
InvariantEquivClassTy *EqClass =
             SAI->getBasePtr());
     assert(EqClass &&
            "Access functions to indirect arrays must have an invariant and "
            "hoisted base pointer");
   }
 
   // Check whether access dimensions correspond to number of dimensions of the
   // accesses array.
-  isl_size Dims = SAI->getNumberOfDimensions();
-  assert(NewAccessSpace.dim(isl::dim::set).release() == Dims &&
-         "Access dims must match array dims");
+  unsigned Dims = SAI->getNumberOfDimensions();
+  unsigned SpaceSize = unsignedFromIslSize(NewAccessSpace.dim(isl::dim::set));
+  assert(SpaceSize == Dims && "Access dims must match array dims");
 #endif
 
   NewAccess = NewAccess.gist_params(getStatement()->getParent()->getContext());
   NewAccess = NewAccess.gist_domain(getStatement()->getDomain());
   NewAccessRelation = NewAccess;
 }
 
 bool MemoryAccess::isLatestPartialAccess() const {

polly/lib/CodeGen/BlockGenerators.cpp

 // statement, respectively.
 //
 //===----------------------------------------------------------------------===//
 
 #include "polly/CodeGen/BlockGenerators.h"
 #include "polly/CodeGen/IslExprBuilder.h"
 #include "polly/CodeGen/RuntimeDebugBuilder.h"
 #include "polly/Options.h"
 #include "polly/ScopInfo.h"
 #include "polly/Support/ScopHelper.h"
 #include "polly/Support/VirtualInstruction.h"
+#include "polly/Support/ISLTools.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/RegionInfo.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "isl/ast.h"
 #include <deque>
 
void BlockGenerator::generateBeginStmtTrace(ScopStmt &Stmt, LoopToScevMapT &LTS,
   SmallVector<llvm::Value *, 8> Values;
 
   // Print the name of the statement.
   // TODO: Indent by the depth of the statement instance in the schedule tree.
   Values.push_back(RuntimeDebugBuilder::getPrintableString(Builder, BaseName));
   Values.push_back(RuntimeDebugBuilder::getPrintableString(Builder, "("));
 
   // Add the coordinate of the statement instance.
-  int DomDims = ScheduleMultiPwAff.dim(isl::dim::out).release();
-  for (int i = 0; i < DomDims; i += 1) {
+  for (unsigned i : rangeIslSize(0, ScheduleMultiPwAff.dim(isl::dim::out))) {
     if (i > 0)
       Values.push_back(RuntimeDebugBuilder::getPrintableString(Builder, ","));
 
     isl::ast_expr IsInSet = RestrictedBuild.expr_from(ScheduleMultiPwAff.at(i));
     Values.push_back(ExprBuilder->create(IsInSet.copy()));
   }
 
   if (TraceScalars) {

polly/lib/CodeGen/PPCGCodeGeneration.cpp

 #include "polly/CodeGen/IslNodeBuilder.h"
 #include "polly/CodeGen/PerfMonitor.h"
 #include "polly/CodeGen/Utils.h"
 #include "polly/DependenceInfo.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/ScopDetection.h"
 #include "polly/ScopInfo.h"
 #include "polly/Support/SCEVValidator.h"
+#include "polly/Support/ISLTools.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/IR/IntrinsicsNVPTX.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Linker/Linker.h"
if (gpu_array_is_scalar(Array))
     return nullptr;
 
   isl::ast_build Build = isl::ast_build::from_context(S.getContext());
 
   isl::set Min = isl::manage_copy(Array->extent).lexmin();
 
   isl::set ZeroSet = isl::set::universe(Min.get_space());
 
-  for (long i = 0, n = Min.tuple_dim().release(); i < n; i++)
+  for (unsigned i : rangeIslSize(0, Min.tuple_dim()))
     ZeroSet = ZeroSet.fix_si(isl::dim::set, i, 0);
 
   if (Min.is_subset(ZeroSet)) {
     return nullptr;
   }
 
   isl::ast_expr Result = isl::ast_expr::from_val(isl::val(Min.ctx(), 0));
 
-  for (long i = 0, n = Min.tuple_dim().release(); i < n; i++) {
+  for (unsigned i : rangeIslSize(0, Min.tuple_dim())) {
     if (i > 0) {
       isl::pw_aff Bound_I =
           isl::manage(isl_multi_pw_aff_get_pw_aff(Array->bound, i - 1));
       isl::ast_expr BExpr = Build.expr_from(Bound_I);
       Result = Result.mul(BExpr);
     }
     isl::pw_aff DimMin = Min.dim_min(i);
     isl::ast_expr MExpr = Build.expr_from(DimMin);
isl::set getExtent(ScopArrayInfo *Array) {
 
     isl::set AccessSet = AccessUSet.extract_set(Array->getSpace());
 
     isl::local_space LS = isl::local_space(Array->getSpace());
 
     isl::pw_aff Val = isl::aff::var_on_domain(LS, isl::dim::set, 0);
     isl::pw_aff OuterMin = AccessSet.dim_min(0);
     isl::pw_aff OuterMax = AccessSet.dim_max(0);
-    OuterMin = OuterMin.add_dims(isl::dim::in, Val.dim(isl::dim::in).release());
-    OuterMax = OuterMax.add_dims(isl::dim::in, Val.dim(isl::dim::in).release());
+    OuterMin = OuterMin.add_dims(isl::dim::in, unsignedFromIslSize(Val.dim(isl::dim::in)));
+    OuterMax = OuterMax.add_dims(isl::dim::in, unsignedFromIslSize(Val.dim(isl::dim::in)));
     OuterMin = OuterMin.set_tuple_id(isl::dim::in, Array->getBasePtrId());
     OuterMax = OuterMax.set_tuple_id(isl::dim::in, Array->getBasePtrId());
 
     isl::set Extent = isl::set::universe(Array->getSpace());
 
     Extent = Extent.intersect(OuterMin.le_set(Val));
     Extent = Extent.intersect(OuterMax.ge_set(Val));
 
     for (unsigned i = 1; i < NumDims; ++i)
       Extent = Extent.lower_bound_si(isl::dim::set, i, 0);
 
     for (unsigned i = 0; i < NumDims; ++i) {
       isl::pw_aff PwAff = Array->getDimensionSizePw(i);
 
       // isl_pw_aff can be NULL for zero dimension. Only in the case of a
       // Fortran array will we have a legitimate dimension.
       if (PwAff.is_null()) {
         assert(i == 0 && "invalid dimension isl_pw_aff for nonzero dimension");
         continue;
       }
 
       isl::pw_aff Val = isl::aff::var_on_domain(
           isl::local_space(Array->getSpace()), isl::dim::set, i);
-      PwAff = PwAff.add_dims(isl::dim::in, Val.dim(isl::dim::in).release());
+      PwAff = PwAff.add_dims(isl::dim::in, unsignedFromIslSize(Val.dim(isl::dim::in)));
       PwAff = PwAff.set_tuple_id(isl::dim::in, Val.get_tuple_id(isl::dim::in));
       isl::set Set = PwAff.gt_set(Val);
       Extent = Set.intersect(Extent);
     }
 
     return Extent;
   }
 

polly/lib/Exchange/JSONExporter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "polly/JSONExporter.h"
 #include "polly/DependenceInfo.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/ScopInfo.h"
 #include "polly/ScopPass.h"
 #include "polly/Support/ScopLocation.h"
+#include "polly/Support/ISLTools.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include "isl/map.h"
static bool importContext(Scop &S, const json::Object &JScop) {
   }
 
   // Check if the isl_set is a parameter set.
   if (!NewContext.is_params()) {
     errs() << "The isl_set is not a parameter set.\n";
     return false;
   }
 
-  unsigned OldContextDim = OldContext.dim(isl::dim::param).release();
-  unsigned NewContextDim = NewContext.dim(isl::dim::param).release();
+  unsigned OldContextDim = unsignedFromIslSize(OldContext.dim(isl::dim::param));
+  unsigned NewContextDim = unsignedFromIslSize(NewContext.dim(isl::dim::param));
 
   // Check if the imported context has the right number of parameters.
   if (OldContextDim != NewContextDim) {
     errs() << "Imported context has the wrong number of parameters : "
            << "Found " << NewContextDim << " Expected " << OldContextDim
            << "\n";
     return false;
   }

polly/lib/External/isl/include/isl/isl-noexceptions.h

enum class dim {
   in = isl_dim_in,
   out = isl_dim_out,
   set = isl_dim_set,
   div = isl_dim_div,
   all = isl_dim_all
 };
 
 } // namespace isl
-
 #include <isl/id.h>
 #include <isl/space.h>
 #include <isl/val.h>
 #include <isl/aff.h>
 #include <isl/set.h>
 #include <isl/map.h>
 #include <isl/ilp.h>
 #include <isl/constraint.h>

polly/lib/Support/ISLTools.cpp

isl::basic_map makeTupleSwapBasicMap(isl::space FromSpace1,
                                      isl::space FromSpace2) {
   // Fast-path on out-of-quota.
   if (FromSpace1.is_null() || FromSpace2.is_null())
     return {};
 
   assert(FromSpace1.is_set());
   assert(FromSpace2.is_set());
 
-  unsigned Dims1 = FromSpace1.dim(isl::dim::set).release();
-  unsigned Dims2 = FromSpace2.dim(isl::dim::set).release();
+  unsigned Dims1 = unsignedFromIslSize(FromSpace1.dim(isl::dim::set));
+  unsigned Dims2 = unsignedFromIslSize(FromSpace2.dim(isl::dim::set));
 
   isl::space FromSpace =
       FromSpace1.map_from_domain_and_range(FromSpace2).wrap();
   isl::space ToSpace = FromSpace2.map_from_domain_and_range(FromSpace1).wrap();
   isl::space MapSpace = FromSpace.map_from_domain_and_range(ToSpace);
 
   isl::basic_map Result = isl::basic_map::universe(MapSpace);
   for (unsigned i = 0u; i < Dims1; i += 1)
isl::set polly::singleton(isl::union_set USet, isl::space ExpectedSpace) {
 
   isl::set Result(USet);
   assert(Result.is_null() ||
          Result.get_space().has_equal_tuples(ExpectedSpace));
 
   return Result;
 }
 
-isl_size polly::getNumScatterDims(const isl::union_map &Schedule) {
-  isl_size Dims = 0;
+unsigned polly::getNumScatterDims(const isl::union_map &Schedule) {
+  unsigned Dims = 0;
   for (isl::map Map : Schedule.get_map_list()) {
     if (Map.is_null())
       continue;
 
-    Dims = std::max(Dims, Map.range_tuple_dim().release());
+    Dims = std::max(Dims, unsignedFromIslSize(Map.range_tuple_dim()));
   }
   return Dims;
 }
 
 isl::space polly::getScatterSpace(const isl::union_map &Schedule) {
   if (Schedule.is_null())
     return {};
   unsigned Dims = getNumScatterDims(Schedule);
isl::union_map polly::reverseDomain(const isl::union_map &UMap) {
   for (isl::map Map : UMap.get_map_list()) {
     auto Reversed = reverseDomain(std::move(Map));
     Result = Result.unite(Reversed);
   }
   return Result;
 }
 
 isl::set polly::shiftDim(isl::set Set, int Pos, int Amount) {
-  int NumDims = Set.tuple_dim().release();
+  unsigned NumDims = unsignedFromIslSize(Set.tuple_dim());
   if (Pos < 0)
     Pos = NumDims + Pos;
   assert(Pos < NumDims && "Dimension index must be in range");
   isl::space Space = Set.get_space();
   Space = Space.map_from_domain_and_range(Space);
   isl::multi_aff Translator = makeShiftDimAff(Space, Pos, Amount);
   isl::map TranslatorMap = isl::map::from_multi_aff(Translator);
   return Set.apply(TranslatorMap);
 }
 
 isl::union_set polly::shiftDim(isl::union_set USet, int Pos, int Amount) {
   isl::union_set Result = isl::union_set::empty(USet.ctx());
   for (isl::set Set : USet.get_set_list()) {
     isl::set Shifted = shiftDim(Set, Pos, Amount);
     Result = Result.unite(Shifted);
   }
   return Result;
 }
 
 isl::map polly::shiftDim(isl::map Map, isl::dim Dim, int Pos, int Amount) {
-  int NumDims = Map.dim(Dim).release();
+  unsigned NumDims = unsignedFromIslSize(Map.dim(Dim));
   if (Pos < 0)
     Pos = NumDims + Pos;
   assert(Pos < NumDims && "Dimension index must be in range");
   isl::space Space = Map.get_space();
   switch (Dim) {
   case isl::dim::in:
     Space = Space.domain();
     break;
isl::map polly::distributeDomain(isl::map Map) {
   // Note that we cannot take Map apart into { Domain[] -> Range1[] } and {
   // Domain[] -> Range2[] } and combine again. We would loose any relation
   // between Range1[] and Range2[] that is not also a constraint to Domain[].
 
   isl::space Space = Map.get_space();
   isl::space DomainSpace = Space.domain();
   if (DomainSpace.is_null())
     return {};
-  unsigned DomainDims = DomainSpace.dim(isl::dim::set).release();
+  unsigned DomainDims = unsignedFromIslSize(DomainSpace.dim(isl::dim::set));
   isl::space RangeSpace = Space.range().unwrap();
   isl::space Range1Space = RangeSpace.domain();
   if (Range1Space.is_null())
     return {};
-  unsigned Range1Dims = Range1Space.dim(isl::dim::set).release();
+  unsigned Range1Dims = unsignedFromIslSize(Range1Space.dim(isl::dim::set));
   isl::space Range2Space = RangeSpace.range();
   if (Range2Space.is_null())
     return {};
-  unsigned Range2Dims = Range2Space.dim(isl::dim::set).release();
+  unsigned Range2Dims = unsignedFromIslSize(Range2Space.dim(isl::dim::set));
 
   isl::space OutputSpace =
       DomainSpace.map_from_domain_and_range(Range1Space)
           .wrap()
           .map_from_domain_and_range(
               DomainSpace.map_from_domain_and_range(Range2Space).wrap());
 
   isl::basic_map Translator = isl::basic_map::universe(
isl::stat Stat = PwAff.foreach_piece(
       });
 
   if (Stat.is_error())
     return {};
 
   return Result;
 }
 
+llvm::iota_range<unsigned> polly::rangeIslSize(unsigned Begin, isl::size End) {
+  unsigned UEnd = unsignedFromIslSize(End);
+  return llvm::seq<unsigned>(std::min(Begin, UEnd), UEnd);
+}
+
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 static void foreachPoint(const isl::set &Set,
                          const std::function<void(isl::point P)> &F) {
   Set.foreach_point([&](isl::point P) -> isl::stat {
     F(P);
     return isl::stat::ok();
   });
 }
 
 static void foreachPoint(isl::basic_set BSet,
                          const std::function<void(isl::point P)> &F) {
   foreachPoint(isl::set(BSet), F);
 }
 
 /// Determine the sorting order of the sets @p A and @p B without considering
 /// the space structure.
 ///
 /// Ordering is based on the lower bounds of the set's dimensions. First
 /// dimensions are considered first.
 static int flatCompare(const isl::basic_set &A, const isl::basic_set &B) {
   // Quick bail-out on out-of-quota.
   if (A.is_null() || B.is_null())
     return 0;
 
-  unsigned ALen = A.dim(isl::dim::set).release();
-  unsigned BLen = B.dim(isl::dim::set).release();
+  unsigned ALen = unsignedFromIslSize(A.dim(isl::dim::set));
+  unsigned BLen = unsignedFromIslSize(B.dim(isl::dim::set));
   unsigned Len = std::min(ALen, BLen);
 
   for (unsigned i = 0; i < Len; i += 1) {
     isl::basic_set ADim =
-        A.project_out(isl::dim::param, 0, A.dim(isl::dim::param).release())
+        A.project_out(isl::dim::param, 0, unsignedFromIslSize(A.dim(isl::dim::param)))
             .project_out(isl::dim::set, i + 1, ALen - i - 1)
             .project_out(isl::dim::set, 0, i);
     isl::basic_set BDim =
-        B.project_out(isl::dim::param, 0, B.dim(isl::dim::param).release())
+        B.project_out(isl::dim::param, 0, unsignedFromIslSize(B.dim(isl::dim::param)))
             .project_out(isl::dim::set, i + 1, BLen - i - 1)
             .project_out(isl::dim::set, 0, i);
 
     isl::basic_set AHull = isl::set(ADim).convex_hull();
     isl::basic_set BHull = isl::set(BDim).convex_hull();
 
     bool ALowerBounded =
         bool(isl::set(AHull).dim_has_any_lower_bound(isl::dim::set, 0));
static int structureCompare(const isl::space &ASpace, const isl::space &BSpace,
   if (!BSpace.is_params() && BSpace.has_tuple_name(isl::dim::set))
     BName = BSpace.get_tuple_name(isl::dim::set);
 
   int NameCompare = AName.compare(BName);
   if (NameCompare != 0)
     return NameCompare;
 
   if (ConsiderTupleLen) {
-    int LenCompare = BSpace.dim(isl::dim::set).release() -
-                     ASpace.dim(isl::dim::set).release();
+    int LenCompare = (int)unsignedFromIslSize(BSpace.dim(isl::dim::set)) -
+                     (int)unsignedFromIslSize(ASpace.dim(isl::dim::set));
     if (LenCompare != 0)
       return LenCompare;
   }
 
   return 0;
 }
 
 /// Compare the sets @p A and @p B according to their nested space structure. If
for (const isl::basic_set &BSet : BSets) {
 
     OS << llvm::StringRef(Str).substr(OpenPos + 1, ClosePos - OpenPos - 2);
     First = false;
   }
   assert(!First);
   OS << "\n}\n";
 }
 
-static void recursiveExpand(isl::basic_set BSet, int Dim, isl::set &Expanded) {
-  int Dims = BSet.dim(isl::dim::set).release();
+static void recursiveExpand(isl::basic_set BSet, unsigned Dim, isl::set &Expanded) {
+  unsigned Dims = unsignedFromIslSize(BSet.dim(isl::dim::set));
   if (Dim >= Dims) {
     Expanded = Expanded.unite(BSet);
     return;
   }
 
   isl::basic_set DimOnly =
-      BSet.project_out(isl::dim::param, 0, BSet.dim(isl::dim::param).release())
+      BSet.project_out(isl::dim::param, 0, unsignedFromIslSize(BSet.dim(isl::dim::param)))
           .project_out(isl::dim::set, Dim + 1, Dims - Dim - 1)
           .project_out(isl::dim::set, 0, Dim);
   if (!DimOnly.is_bounded()) {
     recursiveExpand(BSet, Dim + 1, Expanded);
     return;
   }
 
   foreachPoint(DimOnly, [&, Dim](isl::point P) {

polly/lib/Transform/FlattenAlgo.cpp

 using namespace llvm;
 
 namespace {
 
 /// Whether a dimension of a set is bounded (lower and upper) by a constant,
 /// i.e. there are two constants Min and Max, such that every value x of the
 /// chosen dimensions is Min <= x <= Max.
 bool isDimBoundedByConstant(isl::set Set, unsigned dim) {
-  auto ParamDims = Set.dim(isl::dim::param).release();
+  auto ParamDims = unsignedFromIslSize(Set.dim(isl::dim::param));
   Set = Set.project_out(isl::dim::param, 0, ParamDims);
   Set = Set.project_out(isl::dim::set, 0, dim);
-  auto SetDims = Set.tuple_dim().release();
+  auto SetDims = unsignedFromIslSize(Set.tuple_dim());
+  assert(SetDims >= 1);
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
   return bool(Set.is_bounded());
 }
 
 /// Whether a dimension of a set is (lower and upper) bounded by a constant or
 /// parameters, i.e. there are two expressions Min_p and Max_p of the parameters
 /// p, such that every value x of the chosen dimensions is
 /// Min_p <= x <= Max_p.
 bool isDimBoundedByParameter(isl::set Set, unsigned dim) {
   Set = Set.project_out(isl::dim::set, 0, dim);
-  auto SetDims = Set.tuple_dim().release();
+  auto SetDims = unsignedFromIslSize(Set.tuple_dim());
+  assert(SetDims >= 1);
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
   return bool(Set.is_bounded());
 }
 
 /// Whether BMap's first out-dimension is not a constant.
 bool isVariableDim(const isl::basic_map &BMap) {
   auto FixedVal = BMap.plain_get_val_if_fixed(isl::dim::out, 0);
   return FixedVal.is_null() || FixedVal.is_nan();
isl::union_map scheduleProjectOut(const isl::union_map &UMap, unsigned first,
   auto Result = isl::union_map::empty(UMap.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     auto Outprojected = Map.project_out(isl::dim::out, first, n);
     Result = Result.unite(Outprojected);
   }
   return Result;
 }
 
-/// Return the number of dimensions in the input map's range.
-///
-/// Because this function takes an isl_union_map, the out dimensions could be
-/// different. We return the maximum number in this case. However, a different
-/// number of dimensions is not supported by the other code in this file.
-isl_size scheduleScatterDims(const isl::union_map &Schedule) {
-  isl_size Dims = 0;
-  for (isl::map Map : Schedule.get_map_list()) {
-    if (Map.is_null())
-      continue;
-
-    Dims = std::max(Dims, Map.range_tuple_dim().release());
-  }
-  return Dims;
-}
-
 /// Return the @p pos' range dimension, converted to an isl_union_pw_aff.
 isl::union_pw_aff scheduleExtractDimAff(isl::union_map UMap, unsigned pos) {
   auto SingleUMap = isl::union_map::empty(UMap.ctx());
   for (isl::map Map : UMap.get_map_list()) {
-    unsigned MapDims = Map.range_tuple_dim().release();
+    unsigned MapDims = unsignedFromIslSize(Map.range_tuple_dim());
+    assert(MapDims > pos);
     isl::map SingleMap = Map.project_out(isl::dim::out, 0, pos);
     SingleMap = SingleMap.project_out(isl::dim::out, 1, MapDims - pos - 1);
     SingleUMap = SingleUMap.unite(SingleMap);
   };
 
   auto UAff = isl::union_pw_multi_aff(SingleUMap);
   auto FirstMAff = isl::multi_union_pw_aff(UAff);
   return FirstMAff.at(0);

 /// left.
 /// The example schedule would be transformed to:
 ///   { Stmt_X[] -> [X - l_X, ...]; Stmt_B -> [l_X - u_X + 1 + Y - l_Y, ...] }
 isl::union_map tryFlattenSequence(isl::union_map Schedule) {
   auto IslCtx = Schedule.ctx();
   auto ScatterSet = isl::set(Schedule.range());
 
   auto ParamSpace = Schedule.get_space().params();
-  auto Dims = ScatterSet.tuple_dim().release();
-  assert(Dims >= 2);
+  auto Dims = unsignedFromIslSize(ScatterSet.tuple_dim());
+  assert(Dims >= 2u);
 
   // Would cause an infinite loop.
   if (!isDimBoundedByConstant(ScatterSet, 0)) {
     LLVM_DEBUG(dbgs() << "Abort; dimension is not of fixed size\n");
     return {};
   }
 
   auto AllDomains = Schedule.domain();
   auto AllDomainsToNull = isl::union_pw_multi_aff(AllDomains);
 
   auto NewSchedule = isl::union_map::empty(ParamSpace.ctx());
   auto Counter = isl::pw_aff(isl::local_space(ParamSpace.set_from_params()));
 
   while (!ScatterSet.is_empty()) {
     LLVM_DEBUG(dbgs() << "Next counter:\n  " << Counter << "\n");
     LLVM_DEBUG(dbgs() << "Remaining scatter set:\n  " << ScatterSet << "\n");
     auto ThisSet = ScatterSet.project_out(isl::dim::set, 1, Dims - 1);
     auto ThisFirst = ThisSet.lexmin();
     auto ScatterFirst = ThisFirst.add_dims(isl::dim::set, Dims - 1);
 
     auto SubSchedule = Schedule.intersect_range(ScatterFirst);
     SubSchedule = scheduleProjectOut(SubSchedule, 0, 1);
     SubSchedule = flattenSchedule(SubSchedule);
 
-    auto SubDims = scheduleScatterDims(SubSchedule);
+    unsigned SubDims = getNumScatterDims(SubSchedule);
+    assert(SubDims >= 1);
     auto FirstSubSchedule = scheduleProjectOut(SubSchedule, 1, SubDims - 1);
     auto FirstScheduleAff = scheduleExtractDimAff(FirstSubSchedule, 0);
     auto RemainingSubSchedule = scheduleProjectOut(SubSchedule, 0, 1);
 
     auto FirstSubScatter = isl::set(FirstSubSchedule.range());
     LLVM_DEBUG(dbgs() << "Next step in sequence is:\n  " << FirstSubScatter
                       << "\n");
 

 /// induction variable). Let the input schedule look like this:
 ///   { Stmt[i] -> [i, X, ...] }
 ///
 /// To flatten, we determine the largest extent of X which may not depend on the
 /// actual value of i. Let l_X() the smallest possible value of X and u_X() its
 /// largest value. Then, construct a new schedule
 ///   { Stmt[i] -> [i * (u_X() - l_X() + 1), ...] }
 isl::union_map tryFlattenLoop(isl::union_map Schedule) {
-  assert(scheduleScatterDims(Schedule) >= 2);
+  assert(getNumScatterDims(Schedule) >= 2);
 
   auto Remaining = scheduleProjectOut(Schedule, 0, 1);
   auto SubSchedule = flattenSchedule(Remaining);
-  auto SubDims = scheduleScatterDims(SubSchedule);
+  unsigned SubDims = getNumScatterDims(SubSchedule);
+  
+  assert(SubDims >= 1);
   
   auto SubExtent = isl::set(SubSchedule.range());
-  auto SubExtentDims = SubExtent.dim(isl::dim::param).release();
+  auto SubExtentDims = unsignedFromIslSize(SubExtent.dim(isl::dim::param));
   SubExtent = SubExtent.project_out(isl::dim::param, 0, SubExtentDims);
   SubExtent = SubExtent.project_out(isl::dim::set, 1, SubDims - 1);
 
   if (!isDimBoundedByConstant(SubExtent, 0)) {
     LLVM_DEBUG(dbgs() << "Abort; dimension not bounded by constant\n");
     return {};
   }
 
isl::union_map tryFlattenLoop(isl::union_map Schedule) {
 
   auto Result = IndexMap.flat_range_product(RemainingSubSchedule);
   LLVM_DEBUG(dbgs() << "Loop-flatten result is:\n  " << Result << "\n");
   return Result;
 }
 } // anonymous namespace
 
 isl::union_map polly::flattenSchedule(isl::union_map Schedule) {
-  auto Dims = scheduleScatterDims(Schedule);
+  unsigned Dims = getNumScatterDims(Schedule);
   LLVM_DEBUG(dbgs() << "Recursive schedule to process:\n  " << Schedule
                     << "\n");
 
   // Base case; no dimensions left
   if (Dims == 0) {
     // TODO: Add one dimension?
     return Schedule;
   }

polly/lib/Transform/MatmulOptimizer.cpp

 ///
 /// @param Map     The isl map to be modified.
 /// @param DimType The type of the dimensions.
 /// @param DstPos  The first dimension.
 /// @param SrcPos  The second dimension.
 /// @return        The modified map.
 static isl::map permuteDimensions(isl::map Map, isl::dim DimType,
                                   unsigned DstPos, unsigned SrcPos) {
-  assert((isl_size)DstPos < Map.dim(DimType).release() &&
-         (isl_size)SrcPos < Map.dim(DimType).release());
+  assert(DstPos < unsignedFromIslSize(Map.dim(DimType)) &&
+         SrcPos < unsignedFromIslSize(Map.dim(DimType)));
   if (DstPos == SrcPos)
     return Map;
   isl::id DimId;
   if (Map.has_tuple_id(DimType))
     DimId = Map.get_tuple_id(DimType);
   auto FreeDim = DimType == isl::dim::in ? isl::dim::out : isl::dim::in;
   isl::id FreeDimId;
   if (Map.has_tuple_id(FreeDim))

 ///                  second output dimension.
 /// @return          True in case @p AccMap has the expected form and false,
 ///                  otherwise.
 static bool isMatMulOperandAcc(isl::set Domain, isl::map AccMap, int &FirstPos,
                                int &SecondPos) {
   isl::space Space = AccMap.get_space();
   isl::map Universe = isl::map::universe(Space);
 
-  if (Space.dim(isl::dim::out).release() != 2)
+  if (unsignedFromIslSize(Space.dim(isl::dim::out)) != 2)
     return false;
 
   // MatMul has the form:
   // for (i = 0; i < N; i++)
   //   for (j = 0; j < M; j++)
   //     for (k = 0; k < P; k++)
   //       C[i, j] += A[i, k] * B[k, j]
   //

 /// @param  MMI             Parameters of the matrix multiplication operands.
 /// @return                 True in case the corresponding SCoP statement
 ///                         represents matrix multiplication and false,
 ///                         otherwise.
 static bool containsOnlyMatrMultAcc(isl::map PartialSchedule,
                                     MatMulInfoTy &MMI) {
   auto InputDimId = PartialSchedule.get_tuple_id(isl::dim::in);
   auto *Stmt = static_cast<ScopStmt *>(InputDimId.get_user());
-  isl_size OutDimNum = PartialSchedule.range_tuple_dim().release();
+  unsigned OutDimNum = unsignedFromIslSize(PartialSchedule.range_tuple_dim());
   assert(OutDimNum > 2 && "In case of the matrix multiplication the loop nest "
                           "and, consequently, the corresponding scheduling "
                           "functions have at least three dimensions.");
   auto MapI =
       permuteDimensions(PartialSchedule, isl::dim::out, MMI.i, OutDimNum - 1);
   auto MapJ =
       permuteDimensions(PartialSchedule, isl::dim::out, MMI.j, OutDimNum - 1);
   auto MapK =
static bool containsOnlyMatMulDep(isl::map Schedule, const Dependences *D,
                                   int &Pos) {
   isl::union_map Dep = D->getDependences(Dependences::TYPE_RAW);
   isl::union_map Red = D->getDependences(Dependences::TYPE_RED);
   if (!Red.is_null())
     Dep = Dep.unite(Red);
   auto DomainSpace = Schedule.get_space().domain();
   auto Space = DomainSpace.map_from_domain_and_range(DomainSpace);
   auto Deltas = Dep.extract_map(Space).deltas();
-  isl_size DeltasDimNum = Deltas.dim(isl::dim::set).release();
+  int DeltasDimNum = unsignedFromIslSize(Deltas.dim(isl::dim::set));
   for (int i = 0; i < DeltasDimNum; i++) {
     auto Val = Deltas.plain_get_val_if_fixed(isl::dim::set, i);
     Pos = Pos < 0 && Val.is_one() ? i : Pos;
     if (Val.is_nan() || !(Val.is_zero() || (i == Pos && Val.is_one())))
       return false;
   }
   if (DeltasDimNum == 0 || Pos < 0)
     return false;
static isl::schedule_node optimizePackedB(isl::schedule_node Node,
   isl::map AccRelPackedB = getMatMulAccRel(MapOldIndVar, 3, 7);
   AccRelPackedB =
       AccRelPackedB.set_tuple_id(isl::dim::out, PackedB->getBasePtrId());
 
   // Create the copy statement and redirect access.
   ScopStmt *CopyStmt = S->addScopStmt(AccRelB, AccRelPackedB, Domain);
   MMI.B->setNewAccessRelation(AccRelPackedB);
 
+  unsigned Dim = unsignedFromIslSize(MapOldIndVar.range_tuple_dim());
+  assert(Dim >= 2);
   // Insert into the schedule tree.
-  isl::map ExtMap = MapOldIndVar.project_out(
-      isl::dim::out, 2, MapOldIndVar.range_tuple_dim().release() - 2);
+  isl::map ExtMap = MapOldIndVar.project_out(isl::dim::out, 2, Dim - 2);
   ExtMap = ExtMap.reverse();
   ExtMap = ExtMap.fix_si(isl::dim::out, MMI.i, 0);
   ExtMap = ExtMap.intersect_range(Domain);
   ExtMap = ExtMap.set_tuple_id(isl::dim::out, CopyStmt->getDomainId());
   return createExtensionNode(Node, ExtMap);
 }
 
 static isl::schedule_node optimizePackedA(isl::schedule_node Node, ScopStmt *,

 /// @see getMacroKernelParams
 static isl::map
 getInductionVariablesSubstitution(isl::schedule_node Node,
                                   MicroKernelParamsTy MicroKernelParams,
                                   MacroKernelParamsTy MacroKernelParams) {
   auto Child = Node.child(0);
   auto UnMapOldIndVar = Child.get_prefix_schedule_union_map();
   auto MapOldIndVar = isl::map::from_union_map(UnMapOldIndVar);
-  if (MapOldIndVar.range_tuple_dim().release() > 9)
-    return MapOldIndVar.project_out(
-        isl::dim::out, 0, MapOldIndVar.range_tuple_dim().release() - 9);
+  unsigned Dim = unsignedFromIslSize(MapOldIndVar.range_tuple_dim());
+  if (Dim > 9u)
+    return MapOldIndVar.project_out(isl::dim::out, 0, Dim - 9);
   return MapOldIndVar;
 }
 
 /// Isolate a set of partial tile prefixes and unroll the isolated part.
 ///
 /// The set should ensure that it contains only partial tile prefixes that have
 /// exactly Mr x Nr iterations of the two innermost loops produced by
 /// the optimization of the matrix multiplication. Mr and Nr are parameters of
 /// the micro-kernel.
 ///
 /// In case of parametric bounds, this helps to auto-vectorize the unrolled
 /// innermost loops, using the SLP vectorizer.
 ///
 /// @param Node              The schedule node to be modified.
 /// @param MicroKernelParams Parameters of the micro-kernel
 ///                          to be taken into account.
 /// @return The modified isl_schedule_node.
 static isl::schedule_node
 isolateAndUnrollMatMulInnerLoops(isl::schedule_node Node,
                                  struct MicroKernelParamsTy MicroKernelParams) {
   isl::schedule_node Child = Node.child(0);
   isl::union_map UnMapOldIndVar = Child.get_prefix_schedule_relation();
   isl::set Prefix = isl::map::from_union_map(UnMapOldIndVar).range();
-  isl_size Dims = Prefix.tuple_dim().release();
+  unsigned Dims = unsignedFromIslSize(Prefix.tuple_dim());
+  assert(Dims >= 1);
   Prefix = Prefix.project_out(isl::dim::set, Dims - 1, 1);
   Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Nr);
   Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Mr);
 
   isl::union_set IsolateOption =
       getIsolateOptions(Prefix.add_dims(isl::dim::set, 3), 3);
   isl::ctx Ctx = Node.ctx();
   auto Options = IsolateOption.unite(getDimOptions(Ctx, "unroll"));

 static isl::schedule_node
 getBandNodeWithOriginDimOrder(isl::schedule_node Node) {
   assert(isl_schedule_node_get_type(Node.get()) == isl_schedule_node_band);
   if (isl_schedule_node_get_type(Node.child(0).get()) != isl_schedule_node_leaf)
     return Node;
   auto Domain = Node.get_universe_domain();
   assert(isl_union_set_n_set(Domain.get()) == 1);
   if (Node.get_schedule_depth().release() != 0 ||
-      (isl::set(Domain).tuple_dim().release() !=
-       isl_schedule_node_band_n_member(Node.get())))
+      (unsignedFromIslSize(isl::set(Domain).tuple_dim()) !=
+       unsignedFromIslSize(Node.as<isl::schedule_node_band>().n_member())))
     return Node;
   Node = isl::manage(isl_schedule_node_delete(Node.copy()));
   auto PartialSchedulePwAff = Domain.identity_union_pw_multi_aff();
   auto PartialScheduleMultiPwAff =
       isl::multi_union_pw_aff(PartialSchedulePwAff);
   PartialScheduleMultiPwAff =
       PartialScheduleMultiPwAff.reset_tuple_id(isl::dim::set);
   return Node.insert_partial_schedule(PartialScheduleMultiPwAff);

polly/lib/Transform/MaximalStaticExpansion.cpp

 };
 } // namespace
 
 #ifndef NDEBUG
 /// Whether a dimension of a set is bounded (lower and upper) by a constant,
 /// i.e. there are two constants Min and Max, such that every value x of the
 /// chosen dimensions is Min <= x <= Max.
 static bool isDimBoundedByConstant(isl::set Set, unsigned dim) {
-  auto ParamDims = Set.dim(isl::dim::param).release();
+  auto ParamDims = unsignedFromIslSize(Set.dim(isl::dim::param));
   Set = Set.project_out(isl::dim::param, 0, ParamDims);
   Set = Set.project_out(isl::dim::set, 0, dim);
-  auto SetDims = Set.tuple_dim().release();
+  auto SetDims = unsignedFromIslSize(Set.tuple_dim());
+  assert(SetDims >= 1);
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
   return bool(Set.is_bounded());
 }
 #endif
 
 char MaximalStaticExpander::ID = 0;
 
 isl::union_map MaximalStaticExpander::filterDependences(
for (auto MA : Accesses) {
     MA->setNewAccessRelation(NewAccessMap);
   }
 }
 
 ScopArrayInfo *MaximalStaticExpander::expandAccess(Scop &S, MemoryAccess *MA) {
   // Get the current AM.
   auto CurrentAccessMap = MA->getAccessRelation();
 
-  unsigned in_dimensions = CurrentAccessMap.domain_tuple_dim().release();
+  unsigned in_dimensions = unsignedFromIslSize(CurrentAccessMap.domain_tuple_dim());
 
   // Get domain from the current AM.
   auto Domain = CurrentAccessMap.domain();
 
   // Create a new AM from the domain.
   auto NewAccessMap = isl::map::from_domain(Domain);
 
   // Add dimensions to the new AM according to the current in_dim.
ScopArrayInfo *MaximalStaticExpander::expandAccess(Scop &S, MemoryAccess *MA) {
   // Get the out Id of the expanded Array.
   auto NewOutId = ExpandedSAI->getBasePtrId();
 
   // Set the out id of the new AM to the new SAI id.
   NewAccessMap = NewAccessMap.set_tuple_id(isl::dim::out, NewOutId);
 
   // Add constraints to linked output with input id.
   auto SpaceMap = NewAccessMap.get_space();
   auto ConstraintBasicMap =
-      isl::basic_map::equal(SpaceMap, SpaceMap.dim(isl::dim::in).release());
+      isl::basic_map::equal(SpaceMap, unsignedFromIslSize(SpaceMap.dim(isl::dim::in)));
   NewAccessMap = isl::map(ConstraintBasicMap);
 
   // Set the new access relation map.
   MA->setNewAccessRelation(NewAccessMap);
 
   return ExpandedSAI;
 }
 

polly/lib/Transform/ScheduleOptimizer.cpp

 #include "polly/ScheduleOptimizer.h"
 #include "polly/CodeGen/CodeGeneration.h"
 #include "polly/DependenceInfo.h"
 #include "polly/ManualOptimizer.h"
 #include "polly/MatmulOptimizer.h"
 #include "polly/Options.h"
 #include "polly/ScheduleTreeTransform.h"
 #include "polly/Support/ISLOStream.h"
+#include "polly/Support/ISLTools.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/CommandLine.h"
 #include "isl/options.h"
 
 using namespace llvm;
ScheduleTreeOptimizer::isolateFullPartialTiles(isl::schedule_node Node,
   return Result;
 }
 
 isl::schedule_node ScheduleTreeOptimizer::prevectSchedBand(
     isl::schedule_node Node, unsigned DimToVectorize, int VectorWidth) {
   assert(isl_schedule_node_get_type(Node.get()) == isl_schedule_node_band);
 
   auto Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
-  isl_size ScheduleDimensions = Space.dim(isl::dim::set).release();
-  assert((isl_size)DimToVectorize < ScheduleDimensions);
+  unsigned ScheduleDimensions = unsignedFromIslSize(Space.dim(isl::dim::set));
+  assert(DimToVectorize < ScheduleDimensions);
 
   if (DimToVectorize > 0) {
     Node = isl::manage(
         isl_schedule_node_band_split(Node.release(), DimToVectorize));
     Node = Node.child(0);
   }
-  if ((isl_size)DimToVectorize < ScheduleDimensions - 1)
+  if (DimToVectorize < ScheduleDimensions - 1)
     Node = isl::manage(isl_schedule_node_band_split(Node.release(), 1));
   Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
   auto Sizes = isl::multi_val::zero(Space);
   Sizes = Sizes.set_val(0, isl::val(Node.ctx(), VectorWidth));
   Node =
       isl::manage(isl_schedule_node_band_tile(Node.release(), Sizes.release()));
   Node = isolateFullPartialTiles(Node, VectorWidth);
   Node = Node.child(0);
bool ScheduleTreeOptimizer::isTileableBandNode(isl::schedule_node Node) {
 
   if (isl_schedule_node_n_children(Node.get()) != 1)
     return false;
 
   if (!isl_schedule_node_band_get_permutable(Node.get()))
     return false;
 
   auto Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
-  auto Dims = Space.dim(isl::dim::set).release();
 
-  if (Dims <= 1)
+  if (unsignedFromIslSize(Space.dim(isl::dim::set)) <= 1u)
     return false;
 
   return isSimpleInnermostBand(Node);
 }
 
 __isl_give isl::schedule_node
 ScheduleTreeOptimizer::applyTileBandOpt(isl::schedule_node Node) {
   if (FirstLevelTiling) {
ScheduleTreeOptimizer::applyTileBandOpt(isl::schedule_node Node) {
   }
 
   return Node;
 }
 
 isl::schedule_node
 ScheduleTreeOptimizer::applyPrevectBandOpt(isl::schedule_node Node) {
   auto Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
-  auto Dims = Space.dim(isl::dim::set).release();
+  int Dims = unsignedFromIslSize(Space.dim(isl::dim::set));
 
   for (int i = Dims - 1; i >= 0; i--)
     if (Node.as<isl::schedule_node_band>().member_get_coincident(i)) {
       Node = prevectSchedBand(Node, i, PrevectorWidth);
       break;
     }
 
   return Node;

polly/lib/Transform/ScheduleTreeTransform.cpp

applyBandMemberAttributes(isl::schedule_node_band Target, int TargetIdx,
   return Target;
 }
 
 /// Create a new band by copying members from another @p Band. @p IncludeCb
 /// decides which band indices are copied to the result.
 template <typename CbTy>
 static isl::schedule rebuildBand(isl::schedule_node_band OldBand,
                                  isl::schedule Body, CbTy IncludeCb) {
-  int NumBandDims = OldBand.n_member().release();
+  int NumBandDims = unsignedFromIslSize(OldBand.n_member());
 
   bool ExcludeAny = false;
   bool IncludeAny = false;
   for (auto OldIdx : seq<int>(0, NumBandDims)) {
     if (IncludeCb(OldIdx))
       IncludeAny = true;
     else
       ExcludeAny = true;
isl::schedule visitBand(isl::schedule_node_band OldNode,
     isl::union_map NewChildExtensions;
     isl::schedule NewChild = visit(OldChild, Domain, NewChildExtensions);
 
     // Add the extensions to the partial schedule.
     OuterExtensions = isl::union_map::empty(NewChildExtensions.ctx());
     isl::union_map NewPartialSchedMap = isl::union_map::from(PartialSched);
     unsigned BandDims = isl_schedule_node_band_n_member(OldNode.get());
     for (isl::map Ext : NewChildExtensions.get_map_list()) {
-      unsigned ExtDims = Ext.domain_tuple_dim().release();
+      unsigned ExtDims = unsignedFromIslSize(Ext.domain_tuple_dim());
       assert(ExtDims >= BandDims);
       unsigned OuterDims = ExtDims - BandDims;
 
       isl::map BandSched =
           Ext.project_out(isl::dim::in, 0, OuterDims).reverse();
       NewPartialSchedMap = NewPartialSchedMap.unite(BandSched);
 
       // There might be more outer bands that have to schedule the extensions.
static isl::basic_set isDivisibleBySet(isl::ctx &Ctx, long Factor,
   return Modulo.domain();
 }
 
 /// Make the last dimension of Set to take values from 0 to VectorWidth - 1.
 ///
 /// @param Set         A set, which should be modified.
 /// @param VectorWidth A parameter, which determines the constraint.
 static isl::set addExtentConstraints(isl::set Set, int VectorWidth) {
-  unsigned Dims = Set.tuple_dim().release();
+  unsigned Dims = unsignedFromIslSize(Set.tuple_dim());
+  assert(Dims >= 1);
   isl::space Space = Set.get_space();
   isl::local_space LocalSpace = isl::local_space(Space);
   isl::constraint ExtConstr = isl::constraint::alloc_inequality(LocalSpace);
   ExtConstr = ExtConstr.set_constant_si(0);
   ExtConstr = ExtConstr.set_coefficient_si(isl::dim::set, Dims - 1, 1);
   Set = Set.add_constraint(ExtConstr);
   ExtConstr = isl::constraint::alloc_inequality(LocalSpace);
   ExtConstr = ExtConstr.set_constant_si(VectorWidth - 1);

 public:
   isl::schedule visitBand(isl::schedule_node_band RootBand) {
     isl::schedule_node_band Band = RootBand;
     isl::ctx Ctx = Band.ctx();
 
     // Do not merge permutable band to avoid loosing the permutability property.
     // Cannot collapse even two permutable loops, they might be permutable
     // individually, but not necassarily accross.
-    if (Band.n_member().release() > 1 && Band.permutable())
+    if (unsignedFromIslSize(Band.n_member()) > 1u && Band.permutable())
       return getBase().visitBand(Band);
 
     // Find collapsable bands.
     SmallVector<isl::schedule_node_band> Nest;
     int NumTotalLoops = 0;
     isl::schedule_node Body;
     while (true) {
       Nest.push_back(Band);
-      NumTotalLoops += Band.n_member().release();
+      NumTotalLoops += unsignedFromIslSize(Band.n_member());
       Body = Band.first_child();
       if (!Body.isa<isl::schedule_node_band>())
         break;
       Band = Body.as<isl::schedule_node_band>();
 
       // Do not include next band if it is permutable to not lose its
       // permutability property.
-      if (Band.n_member().release() > 1 && Band.permutable())
+      if (unsignedFromIslSize(Band.n_member()) > 1u && Band.permutable())
         break;
     }
 
     // Nothing to collapse, preserve permutability.
     if (Nest.size() <= 1)
       return getBase().visitBand(Band);
 
     LLVM_DEBUG({
       dbgs() << "Found loops to collapse between\n";
       dumpIslObj(RootBand, dbgs());
       dbgs() << "and\n";
       dumpIslObj(Body, dbgs());
       dbgs() << "\n";
     });
 
     isl::schedule NewBody = visit(Body);
 
     // Collect partial schedules from all members.
     isl::union_pw_aff_list PartScheds{Ctx, NumTotalLoops};
     for (isl::schedule_node_band Band : Nest) {
-      int NumLoops = Band.n_member().release();
+      int NumLoops = unsignedFromIslSize(Band.n_member());
       isl::multi_union_pw_aff BandScheds = Band.get_partial_schedule();
       for (auto j : seq<int>(0, NumLoops))
         PartScheds = PartScheds.add(BandScheds.at(j));
     }
     isl::space ScatterSpace = isl::space(Ctx, 0, NumTotalLoops);
     isl::multi_union_pw_aff PartSchedsMulti{ScatterSpace, PartScheds};
 
     isl::schedule_node_band CollapsedBand =
         NewBody.insert_partial_schedule(PartSchedsMulti)
             .get_root()
             .first_child()
             .as<isl::schedule_node_band>();
 
     // Copy over loop attributes form original bands.
     int LoopIdx = 0;
     for (isl::schedule_node_band Band : Nest) {
-      int NumLoops = Band.n_member().release();
+      int NumLoops = unsignedFromIslSize(Band.n_member());
       for (int i : seq<int>(0, NumLoops)) {
         CollapsedBand = applyBandMemberAttributes(std::move(CollapsedBand),
                                                   LoopIdx, Band, i);
         LoopIdx += 1;
       }
     }
     assert(LoopIdx == NumTotalLoops &&
            "Expect the same number of loops to add up again");
default:
     break;
   }
 }
 
 /// Remove dependencies that are resolved by @p PartSched. That is, remove
 /// everything that we already know is executed in-order.
 static isl::union_map remainingDepsFromPartialSchedule(isl::union_map PartSched,
                                                        isl::union_map Deps) {
-  int NumDims = getNumScatterDims(PartSched);
+  unsigned NumDims = getNumScatterDims(PartSched);
   auto ParamSpace = PartSched.get_space().params();
 
   // { Scatter[] }
   isl::space ScatterSpace =
       ParamSpace.set_from_params().add_dims(isl::dim::set, NumDims);
 
   // { Scatter[] -> Domain[] }
   isl::union_map PartSchedRev = PartSched.reverse();

 public:
   /// Is set to true if anything has been fused.
   bool AnyChange = false;
 
   isl::schedule visitBand(isl::schedule_node_band Band, isl::union_map Deps) {
     // { Domain[] -> Scatter[] }
     isl::union_map PartSched =
         isl::union_map::from(Band.get_partial_schedule());
-    assert(getNumScatterDims(PartSched) == Band.n_member().release());
+    assert(getNumScatterDims(PartSched) == unsignedFromIslSize(Band.n_member()));
     isl::space ParamSpace = PartSched.get_space().params();
 
     // { Scatter[] -> Domain[] }
     isl::union_map PartSchedRev = PartSched.reverse();
 
     // Possible within the same iteration. Dependencies with smaller scatter
     // value are carried by this loop and therefore have been resolved by the
     // in-order execution if the loop iteration. A dependency with small scatter
isl::schedule polly::applyFullUnroll(isl::schedule_node BandToUnroll) {
   isl::ctx Ctx = BandToUnroll.ctx();
 
   // Remove the loop's mark, the loop will disappear anyway.
   BandToUnroll = removeMark(BandToUnroll);
   assert(isBandWithSingleLoop(BandToUnroll));
 
   isl::multi_union_pw_aff PartialSched = isl::manage(
       isl_schedule_node_band_get_partial_schedule(BandToUnroll.get()));
-  assert(PartialSched.dim(isl::dim::out).release() == 1 &&
+  assert(unsignedFromIslSize(PartialSched.dim(isl::dim::out)) == 1u &&
          "Can only unroll a single dimension");
   isl::union_pw_aff PartialSchedUAff = PartialSched.at(0);
 
   isl::union_set Domain = BandToUnroll.get_domain();
   PartialSchedUAff = PartialSchedUAff.intersect_domain(Domain);
   isl::union_map PartialSchedUMap =
       isl::union_map::from(isl::union_pw_multi_aff(PartialSchedUAff));
 
isl::schedule polly::applyPartialUnroll(isl::schedule_node BandToUnroll,
   if (!NewBandId.is_null())
     NewLoop = insertMark(NewLoop, NewBandId);
 
   return NewLoop.get_schedule();
 }
 
 isl::set polly::getPartialTilePrefixes(isl::set ScheduleRange,
                                        int VectorWidth) {
-  isl_size Dims = ScheduleRange.tuple_dim().release();
+  unsigned Dims = unsignedFromIslSize(ScheduleRange.tuple_dim());
+  assert(Dims >= 1);
   isl::set LoopPrefixes =
       ScheduleRange.drop_constraints_involving_dims(isl::dim::set, Dims - 1, 1);
   auto ExtentPrefixes = addExtentConstraints(LoopPrefixes, VectorWidth);
   isl::set BadPrefixes = ExtentPrefixes.subtract(ScheduleRange);
   BadPrefixes = BadPrefixes.project_out(isl::dim::set, Dims - 1, 1);
   LoopPrefixes = LoopPrefixes.project_out(isl::dim::set, Dims - 1, 1);
   return LoopPrefixes.subtract(BadPrefixes);
 }
 
 isl::union_set polly::getIsolateOptions(isl::set IsolateDomain,
-                                        isl_size OutDimsNum) {
-  isl_size Dims = IsolateDomain.tuple_dim().release();
+                                        unsigned OutDimsNum) {
+  unsigned Dims = unsignedFromIslSize(IsolateDomain.tuple_dim());
   assert(OutDimsNum <= Dims &&
          "The isl::set IsolateDomain is used to describe the range of schedule "
          "dimensions values, which should be isolated. Consequently, the "
          "number of its dimensions should be greater than or equal to the "
          "number of the schedule dimensions.");
   isl::map IsolateRelation = isl::map::from_domain(IsolateDomain);
   IsolateRelation = IsolateRelation.move_dims(isl::dim::out, 0, isl::dim::in,
                                               Dims - OutDimsNum, OutDimsNum);

 isl::schedule_node polly::tileNode(isl::schedule_node Node,
                                    const char *Identifier,
                                    ArrayRef<int> TileSizes,
                                    int DefaultTileSize) {
   auto Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
   auto Dims = Space.dim(isl::dim::set);
   auto Sizes = isl::multi_val::zero(Space);
   std::string IdentifierString(Identifier);
-  for (auto i : seq<isl_size>(0, Dims.release())) {
+  for (auto i : rangeIslSize(0, Dims)) {
     auto tileSize =
-        i < (isl_size)TileSizes.size() ? TileSizes[i] : DefaultTileSize;
+        i < TileSizes.size() ? TileSizes[i] : DefaultTileSize;
     Sizes = Sizes.set_val(i, isl::val(Node.ctx(), tileSize));
   }
   auto TileLoopMarkerStr = IdentifierString + " - Tiles";
   auto TileLoopMarker = isl::id::alloc(Node.ctx(), TileLoopMarkerStr, nullptr);
   Node = Node.insert_mark(TileLoopMarker);
   Node = Node.child(0);
   Node =
       isl::manage(isl_schedule_node_band_tile(Node.release(), Sizes.release()));
   Node = Node.child(0);

polly/lib/Transform/Simplify.cpp

#define TWO_STATISTICS(VARNAME, DESC)                                          \
   static llvm::Statistic VARNAME[2] = {                                        \
       {DEBUG_TYPE, #VARNAME "0", DESC " (first)"},                             \
       {DEBUG_TYPE, #VARNAME "1", DESC " (second)"}}
 
 /// Number of max disjuncts we allow in removeOverwrites(). This is to avoid
 /// that the analysis of accesses in a statement is becoming too complex. Chosen
 /// to be relatively small because all the common cases should access only few
 /// array elements per statement.
-static int const SimplifyMaxDisjuncts = 4;
+static unsigned const SimplifyMaxDisjuncts = 4;
 
 TWO_STATISTICS(ScopsProcessed, "Number of SCoPs processed");
 TWO_STATISTICS(ScopsModified, "Number of SCoPs simplified");
 
 TWO_STATISTICS(TotalEmptyDomainsRemoved,
                "Number of statement with empty domains removed in any SCoP");
 TWO_STATISTICS(TotalOverwritesRemoved, "Number of removed overwritten writes");
 TWO_STATISTICS(TotalWritesCoalesced, "Number of writes coalesced with another");
static isl::union_map underapproximatedAddMap(isl::union_map UMap,
                                               isl::map Map) {
   if (UMap.is_null() || Map.is_null())
     return {};
 
   isl::map PrevMap = UMap.extract_map(Map.get_space());
 
   // Fast path: If known that we cannot exceed the disjunct limit, just add
   // them.
-  if (isl_map_n_basic_map(PrevMap.get()) + isl_map_n_basic_map(Map.get()) <=
-      SimplifyMaxDisjuncts)
+  if (unsignedFromIslSize(PrevMap.n_basic_map()) + unsignedFromIslSize(Map.n_basic_map()) <= SimplifyMaxDisjuncts)
     return UMap.unite(Map);
 
   isl::map Result = isl::map::empty(PrevMap.get_space());
   for (isl::basic_map BMap : PrevMap.get_basic_map_list()) {
-    if (Result.n_basic_map().release() > SimplifyMaxDisjuncts)
+    if (unsignedFromIslSize(Result.n_basic_map()) > SimplifyMaxDisjuncts)
       break;
     Result = Result.unite(BMap);
   }
   for (isl::basic_map BMap : Map.get_basic_map_list()) {
-    if (isl_map_n_basic_map(Result.get()) > SimplifyMaxDisjuncts)
+    if (unsignedFromIslSize(Result.n_basic_map()) > SimplifyMaxDisjuncts)
       break;
     Result = Result.unite(BMap);
   }
 
   isl::union_map UResult =
       UMap.subtract(isl::map::universe(PrevMap.get_space()));
   UResult.unite(Result);
 

polly/lib/Transform/ZoneAlgo.cpp

isl::map ZoneAlgorithm::getDefToTarget(ScopStmt *DefStmt,
   //   { DefStmt[i] -> TargetStmt[i,j] }
   //
   // In practice, this should cover the majority of cases.
   if (Result.is_null() && S->isOriginalSchedule() &&
       isInsideLoop(DefStmt->getSurroundingLoop(),
                    TargetStmt->getSurroundingLoop())) {
     isl::set DefDomain = getDomainFor(DefStmt);
     isl::set TargetDomain = getDomainFor(TargetStmt);
-    assert(DefDomain.tuple_dim().release() <=
-           TargetDomain.tuple_dim().release());
+    assert(unsignedFromIslSize(DefDomain.tuple_dim()) <=
+           unsignedFromIslSize(TargetDomain.tuple_dim()));
 
     Result = isl::map::from_domain_and_range(DefDomain, TargetDomain);
-    for (unsigned i = 0, DefDims = DefDomain.tuple_dim().release(); i < DefDims;
-         i += 1)
+    for (unsigned i : rangeIslSize(0, DefDomain.tuple_dim()))
       Result = Result.equate(isl::dim::in, i, isl::dim::out, i);
   }
 
   if (Result.is_null()) {
     // { DomainDef[] -> DomainTarget[] }
     Result = computeUseToDefFlowDependency(TargetStmt, DefStmt).reverse();
     simplify(Result);
   }

polly/unittests/Isl/IslTest.cpp

EXPECT_EQ(MAP("[i] -> { [i] -> [i] }"),
             singleton(UMAP("[i] -> { [i] -> [i] }"), SPACE("{ [i] -> [j] }")));
 }
 
 TEST(ISLTools, getNumScatterDims) {
   std::unique_ptr<isl_ctx, decltype(&isl_ctx_free)> Ctx(isl_ctx_alloc(),
                                                         &isl_ctx_free);
 
   // Basic usage
-  EXPECT_EQ(0, getNumScatterDims(UMAP("{ [] -> [] }")));
-  EXPECT_EQ(1, getNumScatterDims(UMAP("{ [] -> [i] }")));
-  EXPECT_EQ(2, getNumScatterDims(UMAP("{ [] -> [i,j] }")));
-  EXPECT_EQ(3, getNumScatterDims(UMAP("{ [] -> [i,j,k] }")));
+  EXPECT_EQ(0u, getNumScatterDims(UMAP("{ [] -> [] }")));
+  EXPECT_EQ(1u, getNumScatterDims(UMAP("{ [] -> [i] }")));
+  EXPECT_EQ(2u, getNumScatterDims(UMAP("{ [] -> [i,j] }")));
+  EXPECT_EQ(3u, getNumScatterDims(UMAP("{ [] -> [i,j,k] }")));
 
   // Different scatter spaces
-  EXPECT_EQ(0, getNumScatterDims(UMAP("{ A[] -> []; [] -> []}")));
-  EXPECT_EQ(1, getNumScatterDims(UMAP("{ A[] -> []; [] -> [i] }")));
-  EXPECT_EQ(2, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j] }")));
-  EXPECT_EQ(3, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j,k] }")));
+  EXPECT_EQ(0u, getNumScatterDims(UMAP("{ A[] -> []; [] -> []}")));
+  EXPECT_EQ(1u, getNumScatterDims(UMAP("{ A[] -> []; [] -> [i] }")));
+  EXPECT_EQ(2u, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j] }")));
+  EXPECT_EQ(3u, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j,k] }")));
 }
 
 TEST(ISLTools, getScatterSpace) {
   std::unique_ptr<isl_ctx, decltype(&isl_ctx_free)> Ctx(isl_ctx_alloc(),
                                                         &isl_ctx_free);
 
   // Basic usage
   EXPECT_EQ(SPACE("{ [] }"), getScatterSpace(UMAP("{ [] -> [] }")));