[Polly] Updated translating the function Scop::foldSizeConstantsToRight() to isl C++

[Siddharth]

Summary

Updated translation with only the changes to the function Scop::foldSizeConstantsToRight() to isl C++

[grosser]

Hi Siddharth,

does this patch compile and pass 'make check-polly'. I also have a couple of suggestions.

lib/Analysis/ScopInfo.cpp

3671

No need to call constructor explicitly.

3674

Unrelated change.

[Siddharth]

Appropriate changes to the function

[grosser]

It seems you have comments in your diff. Also, please make sure the diff you upload is the diff between polly and your latest changes, not a diff between older changes and the latest ones. Please confirm that what is shown in the webinterface is what you would like to see.

[grosser]

Mark this as requesting changes to get this out of my queue.

lib/Analysis/ScopInfo.cpp

: SE(&ScalarEvolution), R(R), name(R.getNameStr()), IsOptimized(false),
       Schedule(nullptr),
       ID(getNextID((*R.getEntry()->getParent()).getName().str())) {
   if (IslOnErrorAbort)
     isl_options_set_on_error(getIslCtx(), ISL_ON_ERROR_ABORT);
   buildContext();
 }
 
 void Scop::foldSizeConstantsToRight() {
-   isl::union_set Accessed = isl::union_set union_map::range(getAccesses().release());
- 
+  //isl::union_map dummy;
+  //isl::noexceptions::union_map dummy;
+   isl::union_map Accessed1 = isl::manage(getAccesses());
+   isl::union_set Accessed = isl::manage(Accessed1.release());
    for (auto Array : arrays()) {
       if (Array->getNumberOfDimensions() <= 1)
         continue;
   
-      isl::space Space = Array->getSpace().release();
-  
-      Space = isl::space space::align_params(Space, isl::space union_set::get_space(Accessed));
+      isl::space Space1 = isl::manage(Array->getSpace());
+      isl::space Space  = isl::manage(Space1.release());
+      isl::space Space2 = isl::manage(Accessed.get_space());
+      Space = Space.align_params(Space2);
   
-      if (!(isl::boolean union_set::contains(Accessed, Space))) {
+      if (!(Accessed.contains(Space))) {
    
             Space.~space();
           continue;
    }
   
-     isl::set Elements = isl::set union_set::extract_set(Accessed, Space);
+     isl::set Elements =  Accessed.extract_set(Space);
   
-      isl::map Transform = isl::map map::universe(isl::space space::map_from_set(Array->getSpace().release()));
+      isl::map Transform = Transform.universe(Space.map_from_set());
  
       std::vector<int> Int;
-  
-      int Dims = isl::set set::dim((Elements, isl::dim dim::set);
+      isl::dim type;
+      isl::set s1;
+      int Dims = Elements.dim(type);
       for (int i = 0; i < Dims; i++) {
         isl::set DimOnly =
-            isl::set set::project_out(__isl_give isl_set *set::copy(Elements), isl::dim dim::set, 0, i);
-        DimOnly = isl::set set::project_out(DimOnly, isl::dim dim::set, 1, Dims - i - 1);
-        DimOnly = isl::set set::lower_bound_si(DimOnly, isl::dim dim::set, 0, 0);
+            Elements.project_out(type, 0, i);
+        DimOnly = DimOnly.project_out(type, 1, Dims - i - 1);
+        DimOnly = DimOnly.lower_bound_si(type, 0, 0);
   
-        isl::basic_set DimHull = isl::basic_set set::affine_hull(DimOnly);
+        isl::basic_set DimHull = DimOnly.affine_hull();
   
         if (i == Dims - 1) {
           Int.push_back(1);
-          Transform =isl::map map::equate(Transform, isl::dim dim::in, i, isl::dim dim::out, i);
+          Transform =Transform.equate(isl::dim::in, i, isl::dim::out, i);
           DimHull.~basic_set();
           continue;
         }
-  
-       if (DimHull.basic_set::dim(isl::dim dim::div) == 1) {
-          isl::aff Diff = isl::aff basic_set::get_div(0);
-          isl::val Val = isl::val aff::get_denominator_val(Diff);
+       if (DimHull.dim(isl::dim::div) == 1) {
+          isl::aff Diff = DimHull.get_div(0);
+          isl::val Val = Diff.get_denominator_val();
           Diff.~aff();
   
           int ValInt = 1;
   
-          if (isl::boolean val::is_int(Val))
+          if (Val.is_int())
             ValInt = Val.get_num_si();
           Val.~val();
   
           Int.push_back(ValInt);
-  
-          isl::constraint C = isl::constraint constraint::alloc_equality(
-              isl::local_space local_space::local_space(isl::space map::get_space(Transform)));
-             C = isl::constraint constraint::set_coefficient_si(C, isl::dim dim::out, i, ValInt);
-             C = isl::constraint constraint::set_coefficient_si(C, isl::dim dim::in, i, -1);
-             Transform =isl::map map::add_constraint(Transform, C);
+          isl::local_space lo;
+          isl::constraint C = C.alloc_equality(
+              local_space::local_space(Transform.get_space()));
+             C = C.set_coefficient_si(isl::dim::out, i, ValInt);
+             C = C.set_coefficient_si(isl::dim::in, i, -1);
+             Transform =Transform.add_constraint(C);
               DimHull.~basic_set();
             continue;
         }
   
-        isl::basic_set ZeroSet = __isl_give isl_basic_set *basic_set::copy();
-        ZeroSet = isl::basic_set basic_set::fix_si(ZeroSet, isl::dim dim::set, 0, 0);
+        isl::basic_set ZeroSet = ZeroSet.copy();
+        ZeroSet = ZeroSet.fix_si(isl::dim::set, 0, 0);
   
         int ValInt = 1;
-        if (isl::boolean basic_set::is_equal(ZeroSet, DimHull)) {
+        if (ZerSet.is_equal(DimHull)) {
           ValInt = 0;
         }
   
         Int.push_back(ValInt);
-        Transform = isl::map map::equate(Transform, isl::dim dim::in, i, isl:: dim dim::in, i);
+        Transform = Transform.equate(isl::dim::in, i, isl::dim::in, i);
         DimHull.~basic_set();
         ZeroSet.~basic_set();
       }
   
-      isl::set MappedElements = isl::set map::domain(__isl_give isl_map *map::copy());
+      isl::set MappedElements = Transform.domain(isl::map::copy());
   
-      if (!isl::boolean set::is_subset(Elements, MappedElements)) {
+      if (!Elements.is_subset(MappedElements)) {
         Elements.~set();
         MappedElements.~set();
         Transform.~map();
         continue;
       }
   
       MappedElements.~set();
   
isl::set Elements =  Accessed.extract_set(Space);
         Elements.~set();
         Transform.~map();
         continue;
       }
   
       for (auto &Access : AccessFunctions)
         if (Access->getScopArrayInfo() == Array)
           Access->setAccessRelation(Access->getAccessRelation().apply_range(
-              isl::manage(__isl_give isl_map *map::copy()));
+              isl::manage(isl::map *map::copy()));
   
       Transform.~map();
   
       std::vector<const SCEV *> Sizes;
       for (unsigned i = 0; i < NumDims; i++) {
         auto Size = Array->getDimensionSize(i);
   
         if (i == NumDims - 1)
           Size = SE->getMulExpr(Size, SE->getConstant(Size->getType(), Int[0]));
         Sizes.push_back(Size);
       }
   
       Array->updateSizes(Sizes, false /* CheckConsistency */);
   
       Elements.~set();
     }
     Accessed.~set();
     return;
  }
 
 void Scop::markFortranArrays() {
   for (ScopStmt &Stmt : Stmts) {
     for (MemoryAccess *MemAcc : Stmt) {
       Value *FAD = MemAcc->getFortranArrayDescriptor();
       if (!FAD)
         continue;
 
       // TODO: const_cast-ing to edit