Introduce isl C++ bindings, Part 1: value_ptr style interface

[grosser]

Summary

Introduce isl C++ bindings, Part 1: value_ptr style interface

Over the last couple of months several authors of independent isl C++ bindings
worked together to jointly design an official set of isl C++ bindings which
combines their experience in developing isl C++ bindings. The new bindings have
been designed around a value pointer style interface and remove the need for
explicit pointer managenent and instead use C++ language features to manage isl
objects.

This commit introduces the smart-pointer part of the isl C++ bindings and
replaces the current IslPtr<T> classes, which served the very same purpose, but
had to be manually maintained. Instead, we now rely on automatically generated
classes for each isl object, which provide value_ptr semantics.

An isl object has the following smart pointer interface:

    inline set manage(__isl_take isl_set *ptr);

    class set {
      friend inline set manage(__isl_take isl_set *ptr);
      isl_set *ptr = nullptr;
      inline explicit set(__isl_take isl_set *ptr);

    public:
      inline set();
      inline set(const set &obj);
      inline set &operator=(set obj);
      inline ~set();
      inline __isl_give isl_set *copy() const &;
      inline __isl_give isl_set *copy() && = delete;
      inline __isl_keep isl_set *get() const;
      inline __isl_give isl_set *release();
      inline bool is_null() const;
    }

The interface and behavior of the new value pointer style classes is inspired
by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf, which
proposes a std::value_ptr, a smart pointer that applies value semantics to its
pointee.

We currently only provide a limited set of public constructors and instead
require provide a global overloaded type constructor method "isl::obj
isl::manage(isl_obj *)", which allows to convert an isl_set* to an isl::set by
calling 'S = isl::manage(s)'. This pattern models the make_unique() constructor
for unique pointers.

The next two functions isl::obj::get() and isl::obj::release() are taken
directly from the std::value_ptr proposal:

S.get() extracts the raw pointer of the object managed by S.
S.release() extracts the raw pointer of the object managed by S and sets the
object in S to null.

We additionally add std::obj::copy(). S.copy() returns a raw pointer refering
to a copy of S, which is a shortcut for "isl::obj(oldobj).release()", a
functionality commonly needed when interacting directly with the isl C
interface where all methods marked with __isl_take require consumable raw
pointers.

S.is_null() checks if S manages a pointer or if the managed object is currently
null. We add this function to provide a more explicit way to check if the
pointer is empty compared to a direct conversion to bool.

This commit also introduces a couple of polly-specific extensions that cover
features currently not handled by the official isl C++ bindings draft, but
which have been provided by IslPtr<T> and are consequently added to avoid code
churn. These extensions include:

        - operator bool() : Conversion from objects to bool
        - construction from nullptr_t
        - get_ctx() method
        - take/keep/give methods, which match the currently used naming
          convention of IslPtr<T> in Polly. They just forward to
          (release/get/manage).
        - raw_ostream printers

We expect that these extensions are over time either removed or upstreamed to
the official isl bindings.

We also export a couple of classes that have not yet been exported in isl (e.g.,
isl::space)

As part of the code review, the following two questions were asked:

- Why do we not use a standard smart pointer?

std::value_ptr was a proposal that has not been accepted. It is consequently
not available in the standard library. Even if it would be available, we want
to expand this interface with a complete method interface that is conveniently
available from each managed pointer. The most direct way to achieve this is to
generate a specialiced value style pointer class for each isl object type and
add any additional methods to this class. The relevant changes follow in
subsequent commits.

- Why do we not use templates or macros to avoid code duplication?

It is certainly possible to use templates or macros, but as this code is
auto-generated there is no need to make writing this code more efficient. Also,
most of these classes will be specialized with individual member functions in
subsequent commits, such that there will be little code reuse to exploit. Hence,
we decided to do so at the moment.

These bindings are not yet officially part of isl, but the draft is already very
stable. The smart pointer interface itself did not change since serveral months.
Adding this code to Polly is against our normal policy of only importing
official isl code. In this case however, we make an exception to showcase a
non-trivial use case of these bindings which should increase confidence in these
bindings and will help upstreaming them to isl.

[Meinersbur]

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

830

inline explicit bool() const
Please add the explicit to avoid accidental conversions to int.

lib/Transform/FlattenSchedule.cpp

93

Didn't you add a ctor from nullptr_t?

[grosser]

Address Michael's comments!

• Make bool() explicit
• Keep nullptr. We have explicit conversions.

[grosser]

I just realized that after adding 'explicit' to the boolean conversion, the unit tests in IslTest.cpp fail. It seems the operator overloading trick we used before does not work as the operator== is not called. Adding it back also does not help. The error I get is:

/home/grosser/Projects/polly/git/utils/unittest/googletest/include/gtest/gtest.h:1392:11: error: invalid operands to binary expression ('const isl::noexceptions::Map' and 'const isl::noexceptions::Map')
  if (lhs == rhs) {
      ~~~ ^  ~~~
/home/grosser/Projects/polly/git/utils/unittest/googletest/include/gtest/gtest.h:1421:12: note: in instantiation of function template specialization 'testing::internal::CmpHelperEQ<isl::noexceptions::Map, isl::noexceptions::Map>' requested here
    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
           ^
/home/grosser/Projects/polly/git/tools/polly/unittests/Isl/IslTest.cpp:402:3: note: in instantiation of function template specialization 'testing::internal::EqHelper<false>::Compare<isl::noexceptions::Map, isl::noexceptions::Map>' requested here
  EXPECT_EQ(MAP("{ [] -> [i] : i <= 0 }"),
  ^
/home/grosser/Projects/polly/git/utils/unittest/googletest/include/gtest/gtest.h:1924:63: note: expanded from macro 'EXPECT_EQ'
                      EqHelper<GTEST_IS_NULL_LITERAL_(val1)>::Compare, \
                                                              ^
/home/grosser/Projects/polly/git/utils/unittest/googletest/include/gtest/internal/gtest-linked_ptr.h:223:6: note: candidate template ignored: could not match 'T *' against 'isl::noexceptions::Map'
bool operator==(T* ptr, const linked_ptr<T>& x) {

Michael, do you happen to have an idea what is going on here?

[Meinersbur]

unittests/Isl/IslTest.cpp

43–75

You removed these on purpose?

[grosser]

I did. They were marked as unused. Something fishy is going on here. Adding them back does not help.

[Meinersbur]

In D30325#685694, @grosser wrote:

I did. They were marked as unused. Something fishy is going on here. Adding them back does not help.

This works for me:

namespace isl { namespace noexceptions {
static bool operator==(const Space &LHS, const Space &RHS) {
  auto IsEqual = isl_space_is_equal(LHS.keep(), RHS.keep());
  EXPECT_NE(isl_bool_error, IsEqual);
  return IsEqual;
}

static bool operator==(const Set &LHS, const Set &RHS) {
  auto IsEqual = isl_set_is_equal(LHS.keep(), RHS.keep());
  EXPECT_NE(isl_bool_error, IsEqual);
  return IsEqual;
}

static bool operator==(const Map &LHS, const Map &RHS) {
  auto IsEqual = isl_map_is_equal(LHS.keep(), RHS.keep());
  EXPECT_NE(isl_bool_error, IsEqual);
  return IsEqual;
}

static bool operator==(const UnionSet &LHS, const UnionSet &RHS) {
  auto IsEqual = isl_union_set_is_equal(LHS.keep(), RHS.keep());
  EXPECT_NE(isl_bool_error, IsEqual);
  return IsEqual;
}

static bool operator==(const UnionMap &LHS, const UnionMap &RHS) {
  auto IsEqual = isl_union_map_is_equal(LHS.keep(), RHS.keep());
  EXPECT_NE(isl_bool_error, IsEqual);
  return IsEqual;
}
}}

The reason might have to do with Koenig Lookup

[grosser]

Add namespaces around operator== to make gtest work, as suggested by Michael.

[grosser]

Thanks, this works indeed.

[Meinersbur]

lib/Transform/FlattenSchedule.cpp

30

Did you remove the & on purpose?

[grosser]

Add accidentally dropped '&'

[mehdi_amini]

S.copy() returns a raw pointer refering to a copy of S.

Why isn't this returning a managed pointer?

[Meinersbur]

In D30325#685844, @mehdi_amini wrote:

S.copy() returns a raw pointer refering to a copy of S.

Why isn't this returning a managed pointer?

Thanks for your interest.

The use of copy() is to interact with isl's C interface (and other code using raw pointers to isl objects). These functions take parameters annotated either with __isl_keep or __isl_take. __isl_take parameters assume to receive ownership of the isl object and will free it before they return. If the caller still needs the isl object it has to create a copy to it. This is what copy() does.

There is no use for copy() when using the C++ binding only. Simple assignment Dst = Src already copy the object implicitly (value-like semantics).

Btw, 'copy' does means increasing the reference counter, not a literal copy. The isl library considers this an implementation detail.

[mehdi_amini]

What big difference with std::unique_ptr (and a custom deleter) justify to rewrite so much code for your smart pointer?

There is a lot of code here that follow the same pattern.

I mean:

#define UniquePtr(Name, ISLType, Deleter)  \
   static auto  closer_##Name = [](ISLType* Ptr) {Deleter(Ptr); }; \
   using Name = std::unique_ptr<ISLType, decltype(closer_##Name);

UniquePtr(AstBuild, isl_ast_build, isl_ast_build_free)
UniquePtr(AstExpr, isl_ast_expr,  isl_ast_expr_free)

In D30325#685907, @Meinersbur wrote:

In D30325#685844, @mehdi_amini wrote:

S.copy() returns a raw pointer refering to a copy of S.

Why isn't this returning a managed pointer?

Thanks for your interest.

The use of copy() is to interact with isl's C interface (and other code using raw pointers to isl objects). These functions take parameters annotated either with __isl_keep or __isl_take. __isl_take parameters assume to receive ownership of the isl object and will free it before they return. If the caller still needs the isl object it has to create a copy to it. This is what copy() does.

That is all really weird and unexpected from a C++ API. I would expect a C++ API to *hide* all this.

There is no use for copy() when using the C++ binding only. Simple assignment Dst = Src already copy the object implicitly (value-like semantics).

Oh, that's not really a smart pointer then, that's kind of answering my question about unique_ptr above.

Btw, 'copy' does means increasing the reference counter, not a literal copy. The isl library considers this an implementation detail.

Mmmm, now I'm not totally sure what Dst = Src do :)

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

140

Does not seem formatted.

161

Almost all these are one liner, why don't you just define them here in the class?

Also, do they all need to be inline? It'll incurs compile time overhead without good reason otherwise.

[Meinersbur]

In D30325#685958, @mehdi_amini wrote:

What big difference with std::unique_ptr (and a custom deleter) justify to rewrite so much code for your smart pointer?

In addition to using isl's intrusive reference counting system (that is, these are more like shared_ptr than unique_ptr), we are generation methods that apply operations on them. For instance

Result = set.apply(map);

The use of copy() is to interact with isl's C interface (and other code using raw pointers to isl objects). These functions take parameters annotated either with __isl_keep or __isl_take. __isl_take parameters assume to receive ownership of the isl object and will free it before they return. If the caller still needs the isl object it has to create a copy to it. This is what copy() does.

That is all really weird and unexpected from a C++ API. I would expect a C++ API to *hide* all this.

We cannot do without interacting with C code, yet alone because the C++ bindings do not implement (yet) all functionality possible with isl so we sill need to call the C API.

Btw, 'copy' does means increasing the reference counter, not a literal copy. The isl library considers this an implementation detail.

Mmmm, now I'm not totally sure what Dst = Src do :)

Something like this:

void Map::operator=(const Map &M) {
  isl_map_free(this->Ptr);
  this->Ptr = isl_map_copy(M.Ptr);
}

[mehdi_amini]

You talked about "value semantic" earlier, but we have smart pointer, and you mentioned reference counting. Overall I have no idea what's going on if I were to use these class.
I assume that's fine, as long as people that are familiar with ISL are happy with it, but I'd hardly consider this a "C++ API" at this point, seeing how much it seems very intrinsically tied to "the ISL way" of handling its internal and does not seem to be expressed in a way that would match common C++ ownership management idioms.

[Meinersbur]

In D30325#685995, @mehdi_amini wrote:

You talked about "value semantic" earlier, but we have smart pointer, and you mentioned reference counting.

I don't see a contradiction here. Value semantics can be implemented using copy-on-write.

Overall I have no idea what's going on if I were to use these class.
I assume that's fine, as long as people that are familiar with ISL are happy with it, but I'd hardly consider this a "C++ API" at this point, seeing how much it seems very intrinsically tied to "the ISL way" of handling its internal and does not seem to be expressed in a way that would match common C++ ownership management idioms.

Being "tied to the ISL way" is to some degree required to become official isl C++ bindings.

Can you elaborate on why a C++ API should match a C++ ownership management idiom? Is glibmm a C++ API? How would you design a C++ wrapper given the isl C-API design? We discussed the API's design extensively here.

[mehdi_amini]

In D30325#686049, @Meinersbur wrote:

In D30325#685995, @mehdi_amini wrote:

You talked about "value semantic" earlier, but we have smart pointer, and you mentioned reference counting.

I don't see a contradiction here. Value semantics can be implemented using copy-on-write.

I see a contradiction between "value semantic" and "shared_ptr" semantic. (you also wrote earlier " that is, these are more like shared_ptr than unique_ptr").

I also don't think I've read "smart pointers" associated with "value semantic" before (in the context of C++). I.e. I wouldn't present my class as a "smart pointer" if it has "value semantic".

Overall I have no idea what's going on if I were to use these class.
I assume that's fine, as long as people that are familiar with ISL are happy with it, but I'd hardly consider this a "C++ API" at this point, seeing how much it seems very intrinsically tied to "the ISL way" of handling its internal and does not seem to be expressed in a way that would match common C++ ownership management idioms.

Being "tied to the ISL way" is to some degree required to become official isl C++ bindings.

Sure, I'm approaching it from a "C++ should be first class citizen" point of view: i.e. I have little to no interest in "the ISL way of doing things around a C API", which I totally understand can't be compatible with designing "official bindings".

Can you elaborate on why a C++ API should match a C++ ownership management idiom?

Because otherwise it does not fit the idiom that a C++ programmer is expecting to see.
For example, I don't believe it would be acceptable for any LLVM component to do this without a very good motivation.

Keep in mind that I'm not an ISL user, I only played with it a little bit 5 years ago. I also remove "C" from my resume for good reasons :)

[grosser]

Hi Mehdi,

thanks a lot for looking into these bindings.

I probably should have explained the overall effort better in the commit message. Reading it again I understand that for whoever was not involved in recent discussions regarding isl and C++ bindings has a hard time getting the context here. Let me try to provide some context:

isl is a math library that provides functionality to perform mathematical operations on integer sets and some other objects (I assume you know this). It is implemented as C code with explicitly managed reference counting. Hence a simple piece of isl code (no useful semantics) would look as follows:

__isl_give isl_set *do_some_operations(__isl_take isl_set *s1, __isl_take *isl_set *s2, __isl_keep isl_set *s3, __isl_take isl_set *s4) {
  isl_set *s5 = isl_set_intersect(isl_set_copy(s1), s2);
  s5 = isl_set_subtract(s5, isl_set_union(isl_set_copy(s3), s4);
  if (isl_set_is_empty(s5)) {
    isl_set_free(s1);
    isl_set_free(s5);
    return isl_set_copy(s3);
  } else {
    isl_set_free(s5);
    return s1;
  }
}

You can see that we have explicit memory management annotations called isl_give (returns a reference), isl_take (takes and later frees a reference), isl_keep (takes and preserves a reference). Also, each function call is rather lengthy, as the function names contain the names of the affected types (no overloading).

Now, let's ignore this specific patch for the moment. The very same code as above can be written in C++ a lot more concise using class methods, operator overloading, and automatic memory management.

isl::Set do_some_operations(isl::Set s1, isl::Set s2, isl::Set s3, isl::Set s4) {
  isl::Set s5 = s1.intersect(s2);
  s5 -= s3 + s4;

  if (s5.isEmpty())
    return s3;
  else
    return s1
}

As hopefully becomes visible, the C++ code now looks almost like mathematical expressions and all pointer handling is nicely hidden from the day-to-day user. I believe this code is now close to optimal in terms of readability.

This is what we are aiming for with the isl C++ bindings. Does this make sense to you?

Besides this goal of increased readability we also want to introduce these new isl bindings in a -- LLVM typical -- gradual way. Hence, we often will have functionality in isl or in Polly that still uses the old C interface. To interact with such functionality we need access to the raw pointers. Assume that for unknown reason the functions isl_set_union and isl_set_is_empty are not yet available as part of the C++ interface (maybe these are very complex functions we implemented in Polly itself and did not yet manage to port over). Then we want to interact with these functions, but already would like to move other parts of Polly over to the C++ bindings. Hence, we get a mix of C and C++ code, that could look as follows:

isl::Set do_some_operations(isl::Set s1, isl::Set s2, isl::Set s3, isl::Set s4) {
  isl::Set s5 = s1.intersect(s2);

  s5 -= isl::manage(isl_set_union(s3.copy(); s4.release()));

  if (isl_set_is_empty(s5.get()))
    return s3;
  else
    return s1
}

Here we use isl::manage to convert a raw isl C pointer back to the C++ object, and we use isl::Set::copy() and isl::Set::release() to obtain raw pointers from s3 and s4, that represent a set identical to s3 and s4, which can be passed and later be consumed by isl_set_union. For object s3 we need to use copy() to obtain a reference-counted copy of the s3 pointer, as the s3 object may possibly be used later. For s4 we can use release() which extracts the pointer that backs s4 and invalidates s4. This is possible as s4 is not used later on. Similarly, we use s5.get() to obtain a raw pointer that can be passed to isl_set_is_empty but that does not have to be consumed by isl_set_is_empty.

For reference:

__isl_give *isl_set_union(__isl_take isl_set *s1, __isl_take *s2);
int isl_set_is_empty(__isl_keep isl_set *s);

Now back to this patch. In some way we start backwards. The first step we take is to assume no function is managed through the C++ interface. Hence, we only introduce almost empty C++ classes that can take ownership of a pointer, free the underlying object at the end of its lifetime and provide access to different kind of raw pointers.

In subsequent patches, we introduce a function interface (https://github.com/tobig/polly/commit/c05fa3e6f4106b0801979038142cb3657bb64dd9), and translate different parts of Polly to this C++ method interface (https://github.com/tobig/polly/commit/4b3d621f25c91e3cb4c3ce57ef24a630df355786, https://github.com/tobig/polly/commit/4e4361805eae7056e6feadce1af44952210b070d, https://github.com/tobig/polly/commit/d9cc363370202a1bdb867f4e928ab11532edc686). I am still in the process of polishing these patches, but hope to put them soon on phabricator to provide a more complete picture. However, even the draft commit messages and the associated changes should already today give a pretty good picture on the kind of simplifications these new C++ bindings will enable.

A lot more details on the motivations of parts of these bindings can be found in the in-process commit messages that implement the binding generator: https://github.com/tobig/isl/commits/cpp-generator
Feel free to skim through these commits or just ask for specific points here on the review thread.

I believe these bindings are meanwhile pretty mature and a great step forward. I am pretty confident what we came up with is rather solid, as we worked with many people who have experience with developing isl C++ before.
Still, it is always very good to get unbiased feedback from somebody who did not take part in the development. Hence, I am very glad to see you in this review thread. Feel invited to raise any questions, comments, concerns you have in this and the upcoming reviews.

Best,
Tobias

[grosser]

@mehdi_amini Alexandre yesterday pointed me to the canonical document of what we are doing: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf These are indeed "smart pointer[s] that applies value semantics to its pointee". I will update the commit message to make this very clear. Thanks for pointing out that the pure use of smart pointers just causes confusion.

[grosser]

Update to lastest isl C++ bindings

[grosser]

Update header guard to ISL_NOEXCEPTIONS and update to latest Polly

[grosser]

Dear all,

I rebased to the latest Polly commit, updated the commit message to explain the missing points @mehdi_amini raised (value_ptr interface and why we generate our own classes). I also changed the header guard to ISL_NOEXCEPTIONS as suggeted by @Meinersbur.

I believe now all concerns are addressed.

[grosser]

• Rename isl::obj::get_str to isl::obj::to_str
• Add "/* implicit */" markers where appropriate

[grosser]

Make clang-format clean (minor whitespace fixes)

[Meinersbur]

LGTM

include/polly/DeLICM.h

 
 namespace polly {
 /// Create a new DeLICM pass instance.
 llvm::Pass *createDeLICMPass();
 
 /// Determine whether two lifetimes are conflicting.
 ///
 /// Used by unittesting.
-bool isConflicting(IslPtr<isl_union_set> ExistingOccupied,
-                   IslPtr<isl_union_set> ExistingUnused,
-                   IslPtr<isl_union_set> ExistingWrites,
-                   IslPtr<isl_union_set> ProposedOccupied,
-                   IslPtr<isl_union_set> ProposedUnused,
-                   IslPtr<isl_union_set> ProposedWrites,
+bool isConflicting(isl::UnionSet ExistingOccupied, isl::UnionSet ExistingUnused,
+                   isl::UnionSet ExistingWrites, isl::UnionSet ProposedOccupied,
+                   isl::UnionSet ProposedUnused, isl::UnionSet ProposedWrites,
                    llvm::raw_ostream *OS = nullptr, unsigned Indent = 0);
 } // namespace polly
 
 namespace llvm {
 void initializeDeLICMPass(llvm::PassRegistry &);
 } // namespace llvm
 
 #endif /* POLLY_DELICM_H */

include/polly/FlattenAlgo.h

 /// schedule is returned.
 ///
 /// Schedules with fewer dimensions may be easier to understand for humans, but
 /// it should make no difference to the computer.
 ///
 /// @param Schedule The input schedule.
 ///
 /// @return The flattened schedule.
-IslPtr<isl_union_map> flattenSchedule(IslPtr<isl_union_map> Schedule);
+isl::UnionMap flattenSchedule(isl::UnionMap Schedule);
 } // namespace polly
 
 #endif /* POLLY_FLATTENALGO_H */

include/polly/Support/GICHelper.h

 #include "llvm/Support/raw_ostream.h"
 #include "isl/aff.h"
 #include "isl/ctx.h"
 #include "isl/map.h"
 #include "isl/options.h"
 #include "isl/set.h"
 #include "isl/union_map.h"
 #include "isl/union_set.h"
+
+#include "isl-noexceptions.h"
+
 #include <functional>
 #include <string>
 
 struct isl_schedule;
 struct isl_multi_aff;
 
 namespace llvm {
 class Value;

 std::string getIslCompatibleName(const std::string &Prefix,
                                  const llvm::Value *Val,
                                  const std::string &Suffix);
 
 std::string getIslCompatibleName(const std::string &Prefix,
                                  const std::string &Middle,
                                  const std::string &Suffix);
 
-/// IslObjTraits<isl_*> is a static class to invoke common functions that all
-/// ISL objects have: isl_*_copy, isl_*_free, isl_*_get_ctx and isl_*_to_str.
-/// These functions follow a common naming scheme, but not a base class
-/// hierarchy (as ISL is written in C). As such, the functions are accessible
-/// only by constructing the function name using the preprocessor. This class
-/// serves to make these names accessible to a C++ template scheme.
-///
-/// There is an isl_obj polymorphism layer, but its implementation is
-/// incomplete.
-template <typename T> class IslObjTraits;
-
-#define DECLARE_TRAITS(TYPE)                                                   \
-  template <> class IslObjTraits<isl_##TYPE> {                                 \
-  public:                                                                      \
-    static __isl_give isl_##TYPE *copy(__isl_keep isl_##TYPE *Obj) {           \
-      return isl_##TYPE##_copy(Obj);                                           \
-    }                                                                          \
-    static void free(__isl_take isl_##TYPE *Obj) { isl_##TYPE##_free(Obj); }   \
-    static isl_ctx *get_ctx(__isl_keep isl_##TYPE *Obj) {                      \
-      return isl_##TYPE##_get_ctx(Obj);                                        \
-    }                                                                          \
-    static std::string to_str(__isl_keep isl_##TYPE *Obj) {                    \
-      if (!Obj)                                                                \
-        return "null";                                                         \
-      char *cstr = isl_##TYPE##_to_str(Obj);                                   \
-      if (!cstr)                                                               \
-        return "null";                                                         \
-      std::string Result{cstr};                                                \
-      ::free(cstr);                                                            \
-      return Result;                                                           \
-    }                                                                          \
-  };
-
-DECLARE_TRAITS(id)
-DECLARE_TRAITS(val)
-DECLARE_TRAITS(space)
-DECLARE_TRAITS(basic_map)
-DECLARE_TRAITS(map)
-DECLARE_TRAITS(union_map)
-DECLARE_TRAITS(basic_set)
-DECLARE_TRAITS(set)
-DECLARE_TRAITS(union_set)
-DECLARE_TRAITS(aff)
-DECLARE_TRAITS(multi_aff)
-DECLARE_TRAITS(pw_aff)
-DECLARE_TRAITS(pw_multi_aff)
-DECLARE_TRAITS(multi_pw_aff)
-DECLARE_TRAITS(union_pw_aff)
-DECLARE_TRAITS(multi_union_pw_aff)
-DECLARE_TRAITS(union_pw_multi_aff)
-
-/// Smart pointer to an ISL object.
-///
-/// An object of this class owns an reference of an ISL object, meaning if will
-/// free it when destroyed. Most ISL objects are reference counted such that we
-/// gain an automatic memory management.
-///
-/// Function parameters in the ISL API are annotated using either __isl_keep
-/// __isl_take. Return values that are objects are annotated using __is_give,
-/// meaning the caller is responsible for releasing the object. When annotated
-/// with __isl_keep, use the keep() function to pass a plain pointer to the ISL
-/// object. For __isl_take-annotated parameters, use either copy() to increase
-/// the reference counter by one, or take() to pass the ownership to the called
-/// function. When IslPtr loses ownership, it cannot be used anymore and won't
-/// free the object when destroyed. Use the give() function to wrap the
-/// ownership of a returned isl_* object into an IstPtr<isl_*>.
-///
-/// There is purposefully no implicit conversion from/to plain isl_* pointers to
-/// avoid difficult to find bugs because keep/copy/take would have been
-/// required.
-template <typename T> class IslPtr {
-  typedef IslPtr<T> ThisTy;
-  typedef IslObjTraits<T> Traits;
-
-private:
-  T *Obj;
-
-  explicit IslPtr(__isl_take T *Obj) : Obj(Obj) {}
-
-public:
-  IslPtr() : Obj(nullptr) {}
-  /* implicit */ IslPtr(std::nullptr_t That) : IslPtr() {}
-
-  /* implicit */ IslPtr(const ThisTy &That)
-      : IslPtr(IslObjTraits<T>::copy(That.Obj)) {}
-  /* implicit */ IslPtr(ThisTy &&That) : IslPtr(That.Obj) {
-    That.Obj = nullptr;
-  }
-  ~IslPtr() {
-    if (Obj)
-      Traits::free(Obj);
-  }
-
-  ThisTy &operator=(const ThisTy &That) {
-    if (Obj)
-      Traits::free(Obj);
-    this->Obj = Traits::copy(That.Obj);
-    return *this;
-  }
-  ThisTy &operator=(ThisTy &&That) {
-    swap(*this, That);
-    return *this;
-  }
-
-  explicit operator bool() const { return Obj; }
-
-  static void swap(ThisTy &LHS, ThisTy &RHS) { std::swap(LHS.Obj, RHS.Obj); }
-
-  static ThisTy give(__isl_take T *Obj) { return ThisTy(Obj); }
-  T *keep() const { return Obj; }
-  __isl_give T *take() {
-    auto *Result = Obj;
-    Obj = nullptr;
-    return Result;
-  }
-  __isl_give T *copy() const { return Traits::copy(Obj); }
-
-  isl_ctx *getCtx() const { return Traits::get_ctx(Obj); }
-  std::string toStr() const { return Traits::to_str(Obj); }
-
-  /// Print a string representation of this ISL object to stderr.
-  ///
-  /// This function is meant to be called from a debugger and therefore must
-  /// not be declared inline: The debugger needs a valid function pointer to
-  /// call, even if the method is not used.
-  ///
-  /// Note that the string representation of isl_*_dump is different than the
-  /// one for isl_printer/isl_*_to_str().
-  void dump() const;
-};
-
-template <typename T> static IslPtr<T> give(__isl_take T *Obj) {
-  return IslPtr<T>::give(Obj);
-}
-
-template <typename T>
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const IslPtr<T> &Obj) {
-  OS << IslObjTraits<T>::to_str(Obj.keep());
-  return OS;
-}
-
-template <typename T>
-llvm::DiagnosticInfoOptimizationBase &
-operator<<(llvm::DiagnosticInfoOptimizationBase &OS, const IslPtr<T> &Obj) {
-  OS << IslObjTraits<T>::to_str(Obj.keep());
+// Make isl::give available in polly namespace. We do this as there was
+// previously a function polly::give() which did the very same thing and we
+// did not want yet to introduce the isl:: prefix to each call of give.
+using isl::give;
+
+inline llvm::DiagnosticInfoOptimizationBase &
+operator<<(llvm::DiagnosticInfoOptimizationBase &OS, const isl::UnionMap &Obj) {
+  OS << Obj.getStr();
   return OS;
 }
 
 /// Enumerate all isl_basic_maps of an isl_map.
 ///
 /// This basically wraps isl_map_foreach_basic_map() and allows to call back
 /// C++11 closures.
-void foreachElt(const IslPtr<isl_map> &Map,
-                const std::function<void(IslPtr<isl_basic_map>)> &F);
+void foreachElt(const isl::Map &Map,
+                const std::function<void(isl::BasicMap)> &F);
 
 /// Enumerate all isl_basic_sets of an isl_set.
 ///
 /// This basically wraps isl_set_foreach_basic_set() and allows to call back
 /// C++11 closures.
-void foreachElt(const IslPtr<isl_set> &Set,
-                const std::function<void(IslPtr<isl_basic_set>)> &F);
+void foreachElt(const isl::Set &Set,
+                const std::function<void(isl::BasicSet)> &F);
 
 /// Enumerate all isl_maps of an isl_union_map.
 ///
 /// This basically wraps isl_union_map_foreach_map() and allows to call back
 /// C++11 closures.
-void foreachElt(const IslPtr<isl_union_map> &UMap,
-                const std::function<void(IslPtr<isl_map> Map)> &F);
+void foreachElt(const isl::UnionMap &UMap,
+                const std::function<void(isl::Map Map)> &F);
 
 /// Enumerate all isl_sets of an isl_union_set.
 ///
 /// This basically wraps isl_union_set_foreach_set() and allows to call back
 /// C++11 closures.
-void foreachElt(const IslPtr<isl_union_set> &USet,
-                const std::function<void(IslPtr<isl_set> Set)> &F);
+void foreachElt(const isl::UnionSet &USet,
+                const std::function<void(isl::Set Set)> &F);
 
 /// Enumerate all isl_pw_aff of an isl_union_pw_aff.
 ///
 /// This basically wraps isl_union_pw_aff(), but also allows to call back C++11
 /// closures.
-void foreachElt(const IslPtr<isl_union_pw_aff> &UPwAff,
-                const std::function<void(IslPtr<isl_pw_aff>)> &F);
+void foreachElt(const isl::UnionPwAff &UPwAff,
+                const std::function<void(isl::PwAff)> &F);
 
 /// Enumerate all polyhedra of an isl_map.
 ///
 /// This is a wrapper for isl_map_foreach_basic_map() that allows to call back
 /// C++ closures. The callback has the possibility to interrupt (break) the
 /// enumeration by returning isl_stat_error. A return value of isl_stat_ok will
 /// continue enumerations, if any more elements are left.
 ///
 /// @param UMap Collection to enumerate.
 /// @param F    The callback function, lambda or closure.
 ///
 /// @return The isl_stat returned by the last callback invocation; isl_stat_ok
 ///         if the collection was empty.
-isl_stat
-foreachEltWithBreak(const IslPtr<isl_map> &Map,
-                    const std::function<isl_stat(IslPtr<isl_basic_map>)> &F);
+isl_stat foreachEltWithBreak(const isl::Map &Map,
+                             const std::function<isl_stat(isl::BasicMap)> &F);
 
 /// Enumerate all isl_maps of an isl_union_map.
 ///
 /// This is a wrapper for isl_union_map_foreach_map() that allows to call back
 /// C++ closures. In contrast to the variant without "_with_break", the callback
 /// has the possibility to interrupt (break) the enumeration by returning
 /// isl_stat_error. A return value of isl_stat_ok will continue enumerations, if
 /// any more elements are left.
 ///
 /// @param UMap Collection to enumerate.
 /// @param F    The callback function, lambda or closure.
 ///
 /// @return The isl_stat returned by the last callback invocation; isl_stat_ok
 ///         if the collection was initially empty.
-isl_stat
-foreachEltWithBreak(const IslPtr<isl_union_map> &UMap,
-                    const std::function<isl_stat(IslPtr<isl_map> Map)> &F);
+isl_stat foreachEltWithBreak(const isl::UnionMap &UMap,
+                             const std::function<isl_stat(isl::Map Map)> &F);
 
 /// Enumerate all pieces of an isl_pw_aff.
 ///
 /// This is a wrapper around isl_pw_aff_foreach_piece() that allows to call back
 /// C++11 closures. The callback has the possibility to interrupt (break) the
 /// enumeration by returning isl_stat_error. A return value of isl_stat_ok will
 /// continue enumerations, if any more elements are left.
 ///
 /// @param UMap Collection to enumerate.
 /// @param F    The callback function, lambda or closure.
 ///
 /// @return The isl_stat returned by the last callback invocation; isl_stat_ok
 ///         if the collection was initially empty.
-isl_stat foreachPieceWithBreak(
-    const IslPtr<isl_pw_aff> &PwAff,
-    const std::function<isl_stat(IslPtr<isl_set>, IslPtr<isl_aff>)> &F);
+isl_stat
+foreachPieceWithBreak(const isl::PwAff &PwAff,
+                      const std::function<isl_stat(isl::Set, isl::Aff)> &F);
 
 /// Scoped limit of ISL operations.
 ///
 /// Limits the number of ISL operations during the lifetime of this object. The
 /// idea is to use this as an RAII guard for the scope where the code is aware
 /// that ISL can return errors even when all input is valid. After leaving the
 /// scope, it will return to the error setting as it was before. That also means
 /// that the error setting should not be changed while in that scope.

include/polly/Support/ISLTools.h

 ///
 /// @param Map    { Space[] -> Scatter[] }
 /// @param Strict True for strictly lexicographically smaller elements (exclude
 ///               same timepoints from the result).
 ///
 /// @return { Space[] -> Scatter[] }
 ///         A map to all timepoints that happen before the timepoints the input
 ///         mapped to.
-IslPtr<isl_map> beforeScatter(IslPtr<isl_map> Map, bool Strict);
+isl::Map beforeScatter(isl::Map Map, bool Strict);
 
-/// Piecewise beforeScatter(IslPtr<isl_map>,bool).
-IslPtr<isl_union_map> beforeScatter(IslPtr<isl_union_map> UMap, bool Strict);
+/// Piecewise beforeScatter(isl::Map,bool).
+isl::UnionMap beforeScatter(isl::UnionMap UMap, bool Strict);
 
 /// Return the range elements that are lexicographically larger.
 ///
 /// @param Map    { Space[] -> Scatter[] }
 /// @param Strict True for strictly lexicographically larger elements (exclude
 ///               same timepoints from the result).
 ///
 /// @return { Space[] -> Scatter[] }
 ///         A map to all timepoints that happen after the timepoints the input
 ///         map originally mapped to.
-IslPtr<isl_map> afterScatter(IslPtr<isl_map> Map, bool Strict);
+isl::Map afterScatter(isl::Map Map, bool Strict);
 
-/// Piecewise afterScatter(IslPtr<isl_map>,bool).
-IslPtr<isl_union_map> afterScatter(const IslPtr<isl_union_map> &UMap,
-                                   bool Strict);
+/// Piecewise afterScatter(isl::Map,bool).
+isl::UnionMap afterScatter(const isl::UnionMap &UMap, bool Strict);
 
 /// Construct a range of timepoints between two timepoints.
 ///
 /// Example:
 /// From := { A[] -> [0]; B[] -> [0] }
 /// To   := {             B[] -> [10]; C[] -> [20] }
 ///
 /// Result:

 ///                 the example, this would add { B[] -> [0] }
 /// @param InclTo   Whether to include the end timepoints in the result. In this
 ///                 example, this would add { B[] -> [10] }
 ///
 /// @return { Space[] -> Scatter[] }
 ///         A map for each domain element of timepoints between two extreme
 ///         points, or nullptr if @p From or @p To is nullptr, or the isl max
 ///         operations is exceeded.
-IslPtr<isl_map> betweenScatter(IslPtr<isl_map> From, IslPtr<isl_map> To,
-                               bool InclFrom, bool InclTo);
+isl::Map betweenScatter(isl::Map From, isl::Map To, bool InclFrom, bool InclTo);
 
-/// Piecewise betweenScatter(IslPtr<isl_map>,IslPtr<isl_map>,bool,bool).
-IslPtr<isl_union_map> betweenScatter(IslPtr<isl_union_map> From,
-                                     IslPtr<isl_union_map> To, bool InclFrom,
-                                     bool InclTo);
+/// Piecewise betweenScatter(isl::Map,isl::Map,bool,bool).
+isl::UnionMap betweenScatter(isl::UnionMap From, isl::UnionMap To,
+                             bool InclFrom, bool InclTo);
 
 /// If by construction a union map is known to contain only a single map, return
 /// it.
 ///
 /// This function combines isl_map_from_union_map() and
 /// isl_union_map_extract_map(). isl_map_from_union_map() fails if the map is
 /// empty because it does not know which space it would be in.
 /// isl_union_map_extract_map() on the other hand does not check whether there
 /// is (at most) one isl_map in the union, i.e. how it has been constructed is
 /// probably wrong.
-IslPtr<isl_map> singleton(IslPtr<isl_union_map> UMap,
-                          IslPtr<isl_space> ExpectedSpace);
+isl::Map singleton(isl::UnionMap UMap, isl::Space ExpectedSpace);
 
 /// If by construction an isl_union_set is known to contain only a single
 /// isl_set, return it.
 ///
 /// This function combines isl_set_from_union_set() and
 /// isl_union_set_extract_set(). isl_map_from_union_set() fails if the set is
 /// empty because it does not know which space it would be in.
 /// isl_union_set_extract_set() on the other hand does not check whether there
 /// is (at most) one isl_set in the union, i.e. how it has been constructed is
 /// probably wrong.
-IslPtr<isl_set> singleton(IslPtr<isl_union_set> USet,
-                          IslPtr<isl_space> ExpectedSpace);
+isl::Set singleton(isl::UnionSet USet, isl::Space ExpectedSpace);
 
 /// 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.
-unsigned getNumScatterDims(const IslPtr<isl_union_map> &Schedule);
+unsigned getNumScatterDims(const isl::UnionMap &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.
-IslPtr<isl_space> getScatterSpace(const IslPtr<isl_union_map> &Schedule);
+isl::Space getScatterSpace(const isl::UnionMap &Schedule);
 
 /// Construct an identity map for the given domain values.
 ///
 /// There is no type resembling isl_union_space, hence we have to pass an
 /// isl_union_set as the map's domain and range space.
 ///
 /// @param USet           { Space[] }
 ///                       The returned map's domain and range.
 /// @param RestrictDomain If true, the returned map only maps elements contained
 ///                       in @p USet and no other. If false, it returns an
 ///                       overapproximation with the identity maps of any space
 ///                       in @p USet, not just the elements in it.
 ///
 /// @return { Space[] -> Space[] }
 ///         A map that maps each value of @p USet to itself.
-IslPtr<isl_union_map> makeIdentityMap(const IslPtr<isl_union_set> &USet,
-                                      bool RestrictDomain);
+isl::UnionMap makeIdentityMap(const isl::UnionSet &USet, bool RestrictDomain);
 
 /// Reverse the nested map tuple in @p Map's domain.
 ///
 /// @param Map { [Space1[] -> Space2[]] -> Space3[] }
 ///
 /// @return { [Space2[] -> Space1[]] -> Space3[] }
-IslPtr<isl_map> reverseDomain(IslPtr<isl_map> Map);
+isl::Map reverseDomain(isl::Map Map);
 
-/// Piecewise reverseDomain(IslPtr<isl_map>).
-IslPtr<isl_union_map> reverseDomain(const IslPtr<isl_union_map> &UMap);
+/// Piecewise reverseDomain(isl::Map).
+isl::UnionMap reverseDomain(const isl::UnionMap &UMap);
 
 /// Add a constant to one dimension of a set.
 ///
 /// @param Map    The set to shift a dimension in.
 /// @param Pos    The dimension to shift. If negative, the dimensions are
 ///               counted from the end instead from the beginning. E.g. -1 is
 ///               the last dimension in the tuple.
 /// @param Amount The offset to add to the specified dimension.
 ///
 /// @return The modified set.
-IslPtr<isl_set> shiftDim(IslPtr<isl_set> Set, int Pos, int Amount);
+isl::Set shiftDim(isl::Set Set, int Pos, int Amount);
 
-/// Piecewise shiftDim(IslPtr<isl_set>,int,int).
-IslPtr<isl_union_set> shiftDim(IslPtr<isl_union_set> USet, int Pos, int Amount);
+/// Piecewise shiftDim(isl::Set,int,int).
+isl::UnionSet shiftDim(isl::UnionSet USet, int Pos, int Amount);
 
 /// Simplify a set inplace.
-void simplify(IslPtr<isl_set> &Set);
+void simplify(isl::Set &Set);
 
 /// Simplify a union set inplace.
-void simplify(IslPtr<isl_union_set> &USet);
+void simplify(isl::UnionSet &USet);
 
 /// Simplify a map inplace.
-void simplify(IslPtr<isl_map> &Map);
+void simplify(isl::Map &Map);
 
 /// Simplify a union map inplace.
-void simplify(IslPtr<isl_union_map> &UMap);
+void simplify(isl::UnionMap &UMap);
 
 /// Compute the reaching definition statement or the next overwrite for each
 /// definition of an array element.
 ///
 /// The reaching definition of an array element at a specific timepoint is the
 /// statement instance that has written the current element's content.
 /// Alternatively, this function determines for each timepoint and element which
 /// write is going to overwrite an element at a future timepoint. This can be

 ///                    at that timepoint would happen before the overwrite). In
 ///                    this example, enabling this adds
 ///                    { [A[] -> [10]] -> Write[] } to the result.
 ///
 /// @return { [Element[] -> Scatter[]] -> DomainWrite[] }
 ///         The reaching definitions or future overwrite as described above, or
 ///         nullptr if either @p Schedule or @p Writes is nullptr, or the isl
 ///         max operations count has exceeded.
-IslPtr<isl_union_map> computeReachingWrite(IslPtr<isl_union_map> Schedule,
-                                           IslPtr<isl_union_map> Writes,
-                                           bool Reverse, bool InclPrevDef,
-                                           bool InclNextDef);
+isl::UnionMap computeReachingWrite(isl::UnionMap Schedule, isl::UnionMap Writes,
 
 /// Compute the timepoints where the contents of an array element are not used.
 ///
 /// An element is unused at a timepoint when the element is overwritten in
 /// the future, but it is not read in between. Another way to express this: the
 /// time from when the element is written, to the most recent read before it, or
 /// infinitely into the past if there is no read before. Such unused elements
 /// can be overwritten by any value without changing the scop's semantics. An

 ///                          the element during the timepoint). In this example,
 ///                          this adds
 ///                          { A[5] -> [10]; A[6] -> [20] } to the result.
 ///
 /// @return { Element[] -> Scatter[] }
 ///         The unused timepoints as defined above, or nullptr if either @p
 ///         Schedule, @p Writes are @p Reads is nullptr, or the ISL max
 ///         operations count is exceeded.
-IslPtr<isl_union_map> computeArrayUnused(IslPtr<isl_union_map> Schedule,
-                                         IslPtr<isl_union_map> Writes,
-                                         IslPtr<isl_union_map> Reads,
-                                         bool ReadEltInSameInst,
-                                         bool InclLastRead, bool InclWrite);
+isl::UnionMap computeArrayUnused(isl::UnionMap Schedule, isl::UnionMap Writes,
+                                 isl::UnionMap Reads, bool ReadEltInSameInst,
 
 /// Convert a zone (range between timepoints) to timepoints.
 ///
 /// A zone represents the time between (integer) timepoints, but not the
 /// timepoints themselves. This function can be used to determine whether a
 /// timepoint lies within a zone.
 ///
 /// For instance, the range (1,3), representing the time between 1 and 3, is

 /// overwritten in timepoint 3, the old value is still available at timepoint 3
 /// (write takes place after any read even if executed at the same timepoint)
 ///
 /// @param Zone      { Zone[] }
 /// @param InclStart Include timepoints adjacent to the beginning of a zone.
 /// @param InclEnd   Include timepoints adjacent to the ending of a zone.
 ///
 /// @return { Scatter[] }
-IslPtr<isl_union_set> convertZoneToTimepoints(IslPtr<isl_union_set> Zone,
-                                              bool InclStart, bool InclEnd);
+isl::UnionSet convertZoneToTimepoints(isl::UnionSet Zone, bool InclStart,
+                                      bool InclEnd);
 } // namespace polly
 
 #endif /* POLLY_ISLTOOLS_H */

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

+/// These are automatically generated C++ bindings for isl.
+///
+///
+/// isl is a library for computing with integer sets and maps described by
+/// Presburger formula. On top of this, isl provides various tools for
+/// Polyhedral compilation ranging from dependence analysis over scheduling
+/// to AST generation.
+///
+///
+/// WARNING: Even though these bindings have been throughly tested and the
+///          design has been reviewed by various members of the isl community,
+///          we do not yet provide any stability guarantees for this interface.
+///          We do not expect any larger changes to the interface, but want to
+///          reserve the freedom to improve the bindings based on insights that
+///          only become visible after shipping these bindings with isl itself.
+
+#ifndef ISL_CPP_ALL
+#define ISL_CPP_ALL
+
+#include <isl/aff.h>
+#include <isl/ast_build.h>
+#include <isl/flow.h>
+#include <isl/id.h>
+#include <isl/ilp.h>
+#include <isl/map.h>
+#include <isl/schedule.h>
+#include <isl/schedule_node.h>
+#include <isl/set.h>
+#include <isl/union_map.h>
+#include <isl/union_set.h>
+#include <isl/val.h>
+
+#include <string>
+
+namespace isl {
+
+inline namespace noexceptions {
+
+// forward declarations
+class Aff;
+class AstBuild;
+class AstExpr;
+class AstNode;
+class BasicMap;
+class BasicSet;
+class Id;
+class Map;
+class MultiAff;
+class MultiPwAff;
+class MultiUnionPwAff;
+class MultiVal;
+class Point;
+class PwAff;
+class PwMultiAff;
+class Schedule;
+class ScheduleConstraints;
+class ScheduleNode;
+class Set;
+class Space;
+class UnionAccessInfo;
+class UnionFlow;
+class UnionMap;
+class UnionPwAff;
+class UnionPwMultiAff;
+class UnionSet;
+class Val;
+
+// declarations for isl::Aff
+inline Aff manage(__isl_take isl_aff *ptr);
+
+inline Aff give(__isl_take isl_aff *ptr);
+
+class Aff {
+  friend inline Aff manage(__isl_take isl_aff *ptr);
+
+inline Aff give(__isl_take isl_aff *ptr);
+
+  isl_aff *ptr = nullptr;
+
+  inline explicit Aff(__isl_take isl_aff *ptr);
+
+public:
+  inline Aff();
+  inline Aff(const Aff &obj);
+  inline Aff(std::nullptr_t);
+  inline Aff &operator=(Aff obj);
+  inline ~Aff();
+  inline __isl_give isl_aff *copy() const &;
+  inline __isl_give isl_aff *copy() && = delete;
+  inline __isl_keep isl_aff *get() const;
+  inline __isl_give isl_aff *release();
+  inline __isl_keep isl_aff *keep() const;
+  inline __isl_give isl_aff *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::AstBuild
+inline AstBuild manage(__isl_take isl_ast_build *ptr);
+
+inline AstBuild give(__isl_take isl_ast_build *ptr);
+
+class AstBuild {
+  friend inline AstBuild manage(__isl_take isl_ast_build *ptr);
+
+inline AstBuild give(__isl_take isl_ast_build *ptr);
+
+  isl_ast_build *ptr = nullptr;
+
+  inline explicit AstBuild(__isl_take isl_ast_build *ptr);
+
+public:
+  inline AstBuild();
+  inline AstBuild(const AstBuild &obj);
+  inline AstBuild(std::nullptr_t);
+  inline AstBuild &operator=(AstBuild obj);
+  inline ~AstBuild();
+  inline __isl_give isl_ast_build *copy() const &;
+  inline __isl_give isl_ast_build *copy() && = delete;
+  inline __isl_keep isl_ast_build *get() const;
+  inline __isl_give isl_ast_build *release();
+  inline __isl_keep isl_ast_build *keep() const;
+  inline __isl_give isl_ast_build *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+};
+
+// declarations for isl::AstExpr
+inline AstExpr manage(__isl_take isl_ast_expr *ptr);
+
+inline AstExpr give(__isl_take isl_ast_expr *ptr);
+
+class AstExpr {
+  friend inline AstExpr manage(__isl_take isl_ast_expr *ptr);
+
+inline AstExpr give(__isl_take isl_ast_expr *ptr);
+
+  isl_ast_expr *ptr = nullptr;
+
+  inline explicit AstExpr(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline AstExpr();
+  inline AstExpr(const AstExpr &obj);
+  inline AstExpr(std::nullptr_t);
+  inline AstExpr &operator=(AstExpr obj);
+  inline ~AstExpr();
+  inline __isl_give isl_ast_expr *copy() const &;
+  inline __isl_give isl_ast_expr *copy() && = delete;
+  inline __isl_keep isl_ast_expr *get() const;
+  inline __isl_give isl_ast_expr *release();
+  inline __isl_keep isl_ast_expr *keep() const;
+  inline __isl_give isl_ast_expr *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::AstNode
+inline AstNode manage(__isl_take isl_ast_node *ptr);
+
+inline AstNode give(__isl_take isl_ast_node *ptr);
+
+class AstNode {
+  friend inline AstNode manage(__isl_take isl_ast_node *ptr);
+
+inline AstNode give(__isl_take isl_ast_node *ptr);
+
+  isl_ast_node *ptr = nullptr;
+
+  inline explicit AstNode(__isl_take isl_ast_node *ptr);
+
+public:
+  inline AstNode();
+  inline AstNode(const AstNode &obj);
+  inline AstNode(std::nullptr_t);
+  inline AstNode &operator=(AstNode obj);
+  inline ~AstNode();
+  inline __isl_give isl_ast_node *copy() const &;
+  inline __isl_give isl_ast_node *copy() && = delete;
+  inline __isl_keep isl_ast_node *get() const;
+  inline __isl_give isl_ast_node *release();
+  inline __isl_keep isl_ast_node *keep() const;
+  inline __isl_give isl_ast_node *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::BasicMap
+inline BasicMap manage(__isl_take isl_basic_map *ptr);
+
+inline BasicMap give(__isl_take isl_basic_map *ptr);
+
+class BasicMap {
+  friend inline BasicMap manage(__isl_take isl_basic_map *ptr);
+
+inline BasicMap give(__isl_take isl_basic_map *ptr);
+
+  isl_basic_map *ptr = nullptr;
+
+  inline explicit BasicMap(__isl_take isl_basic_map *ptr);
+
+public:
+  inline BasicMap();
+  inline BasicMap(const BasicMap &obj);
+  inline BasicMap(std::nullptr_t);
+  inline BasicMap &operator=(BasicMap obj);
+  inline ~BasicMap();
+  inline __isl_give isl_basic_map *copy() const &;
+  inline __isl_give isl_basic_map *copy() && = delete;
+  inline __isl_keep isl_basic_map *get() const;
+  inline __isl_give isl_basic_map *release();
+  inline __isl_keep isl_basic_map *keep() const;
+  inline __isl_give isl_basic_map *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::BasicSet
+inline BasicSet manage(__isl_take isl_basic_set *ptr);
+
+inline BasicSet give(__isl_take isl_basic_set *ptr);
+
+class BasicSet {
+  friend inline BasicSet manage(__isl_take isl_basic_set *ptr);
+
+inline BasicSet give(__isl_take isl_basic_set *ptr);
+
+  isl_basic_set *ptr = nullptr;
+
+  inline explicit BasicSet(__isl_take isl_basic_set *ptr);
+
+public:
+  inline BasicSet();
+  inline BasicSet(const BasicSet &obj);
+  inline BasicSet(std::nullptr_t);
+  inline BasicSet &operator=(BasicSet obj);
+  inline ~BasicSet();
+  inline __isl_give isl_basic_set *copy() const &;
+  inline __isl_give isl_basic_set *copy() && = delete;
+  inline __isl_keep isl_basic_set *get() const;
+  inline __isl_give isl_basic_set *release();
+  inline __isl_keep isl_basic_set *keep() const;
+  inline __isl_give isl_basic_set *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::Id
+inline Id manage(__isl_take isl_id *ptr);
+
+inline Id give(__isl_take isl_id *ptr);
+
+class Id {
+  friend inline Id manage(__isl_take isl_id *ptr);
+
+inline Id give(__isl_take isl_id *ptr);
+
+  isl_id *ptr = nullptr;
+
+  inline explicit Id(__isl_take isl_id *ptr);
+
+public:
+  inline Id();
+  inline Id(const Id &obj);
+  inline Id(std::nullptr_t);
+  inline Id &operator=(Id obj);
+  inline ~Id();
+  inline __isl_give isl_id *copy() const &;
+  inline __isl_give isl_id *copy() && = delete;
+  inline __isl_keep isl_id *get() const;
+  inline __isl_give isl_id *release();
+  inline __isl_keep isl_id *keep() const;
+  inline __isl_give isl_id *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::Map
+inline Map manage(__isl_take isl_map *ptr);
+
+inline Map give(__isl_take isl_map *ptr);
+
+class Map {
+  friend inline Map manage(__isl_take isl_map *ptr);
+
+inline Map give(__isl_take isl_map *ptr);
+
+  isl_map *ptr = nullptr;
+
+  inline explicit Map(__isl_take isl_map *ptr);
+
+public:
+  inline Map();
+  inline Map(const Map &obj);
+  inline Map(std::nullptr_t);
+  inline Map &operator=(Map obj);
+  inline ~Map();
+  inline __isl_give isl_map *copy() const &;
+  inline __isl_give isl_map *copy() && = delete;
+  inline __isl_keep isl_map *get() const;
+  inline __isl_give isl_map *release();
+  inline __isl_keep isl_map *keep() const;
+  inline __isl_give isl_map *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::MultiAff
+inline MultiAff manage(__isl_take isl_multi_aff *ptr);
+
+inline MultiAff give(__isl_take isl_multi_aff *ptr);
+
+class MultiAff {
+  friend inline MultiAff manage(__isl_take isl_multi_aff *ptr);
+
+inline MultiAff give(__isl_take isl_multi_aff *ptr);
+
+  isl_multi_aff *ptr = nullptr;
+
+  inline explicit MultiAff(__isl_take isl_multi_aff *ptr);
+
+public:
+  inline MultiAff();
+  inline MultiAff(const MultiAff &obj);
+  inline MultiAff(std::nullptr_t);
+  inline MultiAff &operator=(MultiAff obj);
+  inline ~MultiAff();
+  inline __isl_give isl_multi_aff *copy() const &;
+  inline __isl_give isl_multi_aff *copy() && = delete;
+  inline __isl_keep isl_multi_aff *get() const;
+  inline __isl_give isl_multi_aff *release();
+  inline __isl_keep isl_multi_aff *keep() const;
+  inline __isl_give isl_multi_aff *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::MultiPwAff
+inline MultiPwAff manage(__isl_take isl_multi_pw_aff *ptr);
+
+inline MultiPwAff give(__isl_take isl_multi_pw_aff *ptr);
+
+class MultiPwAff {
+  friend inline MultiPwAff manage(__isl_take isl_multi_pw_aff *ptr);
+
+inline MultiPwAff give(__isl_take isl_multi_pw_aff *ptr);
+
+  isl_multi_pw_aff *ptr = nullptr;
+
+  inline explicit MultiPwAff(__isl_take isl_multi_pw_aff *ptr);
+
+public:
+  inline MultiPwAff();
+  inline MultiPwAff(const MultiPwAff &obj);
+  inline MultiPwAff(std::nullptr_t);
+  inline MultiPwAff &operator=(MultiPwAff obj);
+  inline ~MultiPwAff();
+  inline __isl_give isl_multi_pw_aff *copy() const &;
+  inline __isl_give isl_multi_pw_aff *copy() && = delete;
+  inline __isl_keep isl_multi_pw_aff *get() const;
+  inline __isl_give isl_multi_pw_aff *release();
+  inline __isl_keep isl_multi_pw_aff *keep() const;
+  inline __isl_give isl_multi_pw_aff *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::MultiUnionPwAff
+inline MultiUnionPwAff manage(__isl_take isl_multi_union_pw_aff *ptr);
+
+inline MultiUnionPwAff give(__isl_take isl_multi_union_pw_aff *ptr);
+
+class MultiUnionPwAff {
+  friend inline MultiUnionPwAff manage(__isl_take isl_multi_union_pw_aff *ptr);
+
+inline MultiUnionPwAff give(__isl_take isl_multi_union_pw_aff *ptr);
+
+  isl_multi_union_pw_aff *ptr = nullptr;
+
+  inline explicit MultiUnionPwAff(__isl_take isl_multi_union_pw_aff *ptr);
+
+public:
+  inline MultiUnionPwAff();
+  inline MultiUnionPwAff(const MultiUnionPwAff &obj);
+  inline MultiUnionPwAff(std::nullptr_t);
+  inline MultiUnionPwAff &operator=(MultiUnionPwAff obj);
+  inline ~MultiUnionPwAff();
+  inline __isl_give isl_multi_union_pw_aff *copy() const &;
+  inline __isl_give isl_multi_union_pw_aff *copy() && = delete;
+  inline __isl_keep isl_multi_union_pw_aff *get() const;
+  inline __isl_give isl_multi_union_pw_aff *release();
+  inline __isl_keep isl_multi_union_pw_aff *keep() const;
+  inline __isl_give isl_multi_union_pw_aff *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::MultiVal
+inline MultiVal manage(__isl_take isl_multi_val *ptr);
+
+inline MultiVal give(__isl_take isl_multi_val *ptr);
+
+class MultiVal {
+  friend inline MultiVal manage(__isl_take isl_multi_val *ptr);
+
+inline MultiVal give(__isl_take isl_multi_val *ptr);
+
+  isl_multi_val *ptr = nullptr;
+
+  inline explicit MultiVal(__isl_take isl_multi_val *ptr);
+
+public:
+  inline MultiVal();
+  inline MultiVal(const MultiVal &obj);
+  inline MultiVal(std::nullptr_t);
+  inline MultiVal &operator=(MultiVal obj);
+  inline ~MultiVal();
+  inline __isl_give isl_multi_val *copy() const &;
+  inline __isl_give isl_multi_val *copy() && = delete;
+  inline __isl_keep isl_multi_val *get() const;
+  inline __isl_give isl_multi_val *release();
+  inline __isl_keep isl_multi_val *keep() const;
+  inline __isl_give isl_multi_val *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::Point
+inline Point manage(__isl_take isl_point *ptr);
+
+inline Point give(__isl_take isl_point *ptr);
+
+class Point {
+  friend inline Point manage(__isl_take isl_point *ptr);
+
+inline Point give(__isl_take isl_point *ptr);
+
+  isl_point *ptr = nullptr;
+
+  inline explicit Point(__isl_take isl_point *ptr);
+
+public:
+  inline Point();
+  inline Point(const Point &obj);
+  inline Point(std::nullptr_t);
+  inline Point &operator=(Point obj);
+  inline ~Point();
+  inline __isl_give isl_point *copy() const &;
+  inline __isl_give isl_point *copy() && = delete;
+  inline __isl_keep isl_point *get() const;
+  inline __isl_give isl_point *release();
+  inline __isl_keep isl_point *keep() const;
+  inline __isl_give isl_point *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::PwAff
+inline PwAff manage(__isl_take isl_pw_aff *ptr);
+
+inline PwAff give(__isl_take isl_pw_aff *ptr);
+
+class PwAff {
+  friend inline PwAff manage(__isl_take isl_pw_aff *ptr);
+
+inline PwAff give(__isl_take isl_pw_aff *ptr);
+
+  isl_pw_aff *ptr = nullptr;
+
+  inline explicit PwAff(__isl_take isl_pw_aff *ptr);
+
+public:
+  inline PwAff();
+  inline PwAff(const PwAff &obj);
+  inline PwAff(std::nullptr_t);
+  inline PwAff &operator=(PwAff obj);
+  inline ~PwAff();
+  inline __isl_give isl_pw_aff *copy() const &;
+  inline __isl_give isl_pw_aff *copy() && = delete;
+  inline __isl_keep isl_pw_aff *get() const;
+  inline __isl_give isl_pw_aff *release();
+  inline __isl_keep isl_pw_aff *keep() const;
+  inline __isl_give isl_pw_aff *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::PwMultiAff
+inline PwMultiAff manage(__isl_take isl_pw_multi_aff *ptr);
+
+inline PwMultiAff give(__isl_take isl_pw_multi_aff *ptr);
+
+class PwMultiAff {
+  friend inline PwMultiAff manage(__isl_take isl_pw_multi_aff *ptr);
+
+inline PwMultiAff give(__isl_take isl_pw_multi_aff *ptr);
+
+  isl_pw_multi_aff *ptr = nullptr;
+
+  inline explicit PwMultiAff(__isl_take isl_pw_multi_aff *ptr);
+
+public:
+  inline PwMultiAff();
+  inline PwMultiAff(const PwMultiAff &obj);
+  inline PwMultiAff(std::nullptr_t);
+  inline PwMultiAff &operator=(PwMultiAff obj);
+  inline ~PwMultiAff();
+  inline __isl_give isl_pw_multi_aff *copy() const &;
+  inline __isl_give isl_pw_multi_aff *copy() && = delete;
+  inline __isl_keep isl_pw_multi_aff *get() const;
+  inline __isl_give isl_pw_multi_aff *release();
+  inline __isl_keep isl_pw_multi_aff *keep() const;
+  inline __isl_give isl_pw_multi_aff *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::Schedule
+inline Schedule manage(__isl_take isl_schedule *ptr);
+
+inline Schedule give(__isl_take isl_schedule *ptr);
+
+class Schedule {
+  friend inline Schedule manage(__isl_take isl_schedule *ptr);
+
+inline Schedule give(__isl_take isl_schedule *ptr);
+
+  isl_schedule *ptr = nullptr;
+
+  inline explicit Schedule(__isl_take isl_schedule *ptr);
+
+public:
+  inline Schedule();
+  inline Schedule(const Schedule &obj);
+  inline Schedule(std::nullptr_t);
+  inline Schedule &operator=(Schedule obj);
+  inline ~Schedule();
+  inline __isl_give isl_schedule *copy() const &;
+  inline __isl_give isl_schedule *copy() && = delete;
+  inline __isl_keep isl_schedule *get() const;
+  inline __isl_give isl_schedule *release();
+  inline __isl_keep isl_schedule *keep() const;
+  inline __isl_give isl_schedule *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::ScheduleConstraints
+inline ScheduleConstraints manage(__isl_take isl_schedule_constraints *ptr);
+
+inline ScheduleConstraints give(__isl_take isl_schedule_constraints *ptr);
+
+class ScheduleConstraints {
+  friend inline ScheduleConstraints manage(__isl_take isl_schedule_constraints *ptr);
+
+inline ScheduleConstraints give(__isl_take isl_schedule_constraints *ptr);
+
+  isl_schedule_constraints *ptr = nullptr;
+
+  inline explicit ScheduleConstraints(__isl_take isl_schedule_constraints *ptr);
+
+public:
+  inline ScheduleConstraints();
+  inline ScheduleConstraints(const ScheduleConstraints &obj);
+  inline ScheduleConstraints(std::nullptr_t);
+  inline ScheduleConstraints &operator=(ScheduleConstraints obj);
+  inline ~ScheduleConstraints();
+  inline __isl_give isl_schedule_constraints *copy() const &;
+  inline __isl_give isl_schedule_constraints *copy() && = delete;
+  inline __isl_keep isl_schedule_constraints *get() const;
+  inline __isl_give isl_schedule_constraints *release();
+  inline __isl_keep isl_schedule_constraints *keep() const;
+  inline __isl_give isl_schedule_constraints *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::ScheduleNode
+inline ScheduleNode manage(__isl_take isl_schedule_node *ptr);
+
+inline ScheduleNode give(__isl_take isl_schedule_node *ptr);
+
+class ScheduleNode {
+  friend inline ScheduleNode manage(__isl_take isl_schedule_node *ptr);
+
+inline ScheduleNode give(__isl_take isl_schedule_node *ptr);
+
+  isl_schedule_node *ptr = nullptr;
+
+  inline explicit ScheduleNode(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline ScheduleNode();
+  inline ScheduleNode(const ScheduleNode &obj);
+  inline ScheduleNode(std::nullptr_t);
+  inline ScheduleNode &operator=(ScheduleNode obj);
+  inline ~ScheduleNode();
+  inline __isl_give isl_schedule_node *copy() const &;
+  inline __isl_give isl_schedule_node *copy() && = delete;
+  inline __isl_keep isl_schedule_node *get() const;
+  inline __isl_give isl_schedule_node *release();
+  inline __isl_keep isl_schedule_node *keep() const;
+  inline __isl_give isl_schedule_node *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::Set
+inline Set manage(__isl_take isl_set *ptr);
+
+inline Set give(__isl_take isl_set *ptr);
+
+class Set {
+  friend inline Set manage(__isl_take isl_set *ptr);
+
+inline Set give(__isl_take isl_set *ptr);
+
+  isl_set *ptr = nullptr;
+
+  inline explicit Set(__isl_take isl_set *ptr);
+
+public:
+  inline Set();
+  inline Set(const Set &obj);
+  inline Set(std::nullptr_t);
+  inline Set &operator=(Set obj);
+  inline ~Set();
+  inline __isl_give isl_set *copy() const &;
+  inline __isl_give isl_set *copy() && = delete;
+  inline __isl_keep isl_set *get() const;
+  inline __isl_give isl_set *release();
+  inline __isl_keep isl_set *keep() const;
+  inline __isl_give isl_set *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::Space
+inline Space manage(__isl_take isl_space *ptr);
+
+inline Space give(__isl_take isl_space *ptr);
+
+class Space {
+  friend inline Space manage(__isl_take isl_space *ptr);
+
+inline Space give(__isl_take isl_space *ptr);
+
+  isl_space *ptr = nullptr;
+
+  inline explicit Space(__isl_take isl_space *ptr);
+
+public:
+  inline Space();
+  inline Space(const Space &obj);
+  inline Space(std::nullptr_t);
+  inline Space &operator=(Space obj);
+  inline ~Space();
+  inline __isl_give isl_space *copy() const &;
+  inline __isl_give isl_space *copy() && = delete;
+  inline __isl_keep isl_space *get() const;
+  inline __isl_give isl_space *release();
+  inline __isl_keep isl_space *keep() const;
+  inline __isl_give isl_space *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::UnionAccessInfo
+inline UnionAccessInfo manage(__isl_take isl_union_access_info *ptr);
+
+inline UnionAccessInfo give(__isl_take isl_union_access_info *ptr);
+
+class UnionAccessInfo {
+  friend inline UnionAccessInfo manage(__isl_take isl_union_access_info *ptr);
+
+inline UnionAccessInfo give(__isl_take isl_union_access_info *ptr);
+
+  isl_union_access_info *ptr = nullptr;
+
+  inline explicit UnionAccessInfo(__isl_take isl_union_access_info *ptr);
+
+public:
+  inline UnionAccessInfo();
+  inline UnionAccessInfo(const UnionAccessInfo &obj);
+  inline UnionAccessInfo(std::nullptr_t);
+  inline UnionAccessInfo &operator=(UnionAccessInfo obj);
+  inline ~UnionAccessInfo();
+  inline __isl_give isl_union_access_info *copy() const &;
+  inline __isl_give isl_union_access_info *copy() && = delete;
+  inline __isl_keep isl_union_access_info *get() const;
+  inline __isl_give isl_union_access_info *release();
+  inline __isl_keep isl_union_access_info *keep() const;
+  inline __isl_give isl_union_access_info *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::UnionFlow
+inline UnionFlow manage(__isl_take isl_union_flow *ptr);
+
+inline UnionFlow give(__isl_take isl_union_flow *ptr);
+
+class UnionFlow {
+  friend inline UnionFlow manage(__isl_take isl_union_flow *ptr);
+
+inline UnionFlow give(__isl_take isl_union_flow *ptr);
+
+  isl_union_flow *ptr = nullptr;
+
+  inline explicit UnionFlow(__isl_take isl_union_flow *ptr);
+
+public:
+  inline UnionFlow();
+  inline UnionFlow(const UnionFlow &obj);
+  inline UnionFlow(std::nullptr_t);
+  inline UnionFlow &operator=(UnionFlow obj);
+  inline ~UnionFlow();
+  inline __isl_give isl_union_flow *copy() const &;
+  inline __isl_give isl_union_flow *copy() && = delete;
+  inline __isl_keep isl_union_flow *get() const;
+  inline __isl_give isl_union_flow *release();
+  inline __isl_keep isl_union_flow *keep() const;
+  inline __isl_give isl_union_flow *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::UnionMap
+inline UnionMap manage(__isl_take isl_union_map *ptr);
+
+inline UnionMap give(__isl_take isl_union_map *ptr);
+
+class UnionMap {
+  friend inline UnionMap manage(__isl_take isl_union_map *ptr);
+
+inline UnionMap give(__isl_take isl_union_map *ptr);
+
+  isl_union_map *ptr = nullptr;
+
+  inline explicit UnionMap(__isl_take isl_union_map *ptr);
+
+public:
+  inline UnionMap();
+  inline UnionMap(const UnionMap &obj);
+  inline UnionMap(std::nullptr_t);
+  inline UnionMap &operator=(UnionMap obj);
+  inline ~UnionMap();
+  inline __isl_give isl_union_map *copy() const &;
+  inline __isl_give isl_union_map *copy() && = delete;
+  inline __isl_keep isl_union_map *get() const;
+  inline __isl_give isl_union_map *release();
+  inline __isl_keep isl_union_map *keep() const;
+  inline __isl_give isl_union_map *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::UnionPwAff
+inline UnionPwAff manage(__isl_take isl_union_pw_aff *ptr);
+
+inline UnionPwAff give(__isl_take isl_union_pw_aff *ptr);
+
+class UnionPwAff {
+  friend inline UnionPwAff manage(__isl_take isl_union_pw_aff *ptr);
+
+inline UnionPwAff give(__isl_take isl_union_pw_aff *ptr);
+
+  isl_union_pw_aff *ptr = nullptr;
+
+  inline explicit UnionPwAff(__isl_take isl_union_pw_aff *ptr);
+
+public:
+  inline UnionPwAff();
+  inline UnionPwAff(const UnionPwAff &obj);
+  inline UnionPwAff(std::nullptr_t);
+  inline UnionPwAff &operator=(UnionPwAff obj);
+  inline ~UnionPwAff();
+  inline __isl_give isl_union_pw_aff *copy() const &;
+  inline __isl_give isl_union_pw_aff *copy() && = delete;
+  inline __isl_keep isl_union_pw_aff *get() const;
+  inline __isl_give isl_union_pw_aff *release();
+  inline __isl_keep isl_union_pw_aff *keep() const;
+  inline __isl_give isl_union_pw_aff *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::UnionPwMultiAff
+inline UnionPwMultiAff manage(__isl_take isl_union_pw_multi_aff *ptr);
+
+inline UnionPwMultiAff give(__isl_take isl_union_pw_multi_aff *ptr);
+
+class UnionPwMultiAff {
+  friend inline UnionPwMultiAff manage(__isl_take isl_union_pw_multi_aff *ptr);
+
+inline UnionPwMultiAff give(__isl_take isl_union_pw_multi_aff *ptr);
+
+  isl_union_pw_multi_aff *ptr = nullptr;
+
+  inline explicit UnionPwMultiAff(__isl_take isl_union_pw_multi_aff *ptr);
+
+public:
+  inline UnionPwMultiAff();
+  inline UnionPwMultiAff(const UnionPwMultiAff &obj);
+  inline UnionPwMultiAff(std::nullptr_t);
+  inline UnionPwMultiAff &operator=(UnionPwMultiAff obj);
+  inline ~UnionPwMultiAff();
+  inline __isl_give isl_union_pw_multi_aff *copy() const &;
+  inline __isl_give isl_union_pw_multi_aff *copy() && = delete;
+  inline __isl_keep isl_union_pw_multi_aff *get() const;
+  inline __isl_give isl_union_pw_multi_aff *release();
+  inline __isl_keep isl_union_pw_multi_aff *keep() const;
+  inline __isl_give isl_union_pw_multi_aff *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::UnionSet
+inline UnionSet manage(__isl_take isl_union_set *ptr);
+
+inline UnionSet give(__isl_take isl_union_set *ptr);
+
+class UnionSet {
+  friend inline UnionSet manage(__isl_take isl_union_set *ptr);
+
+inline UnionSet give(__isl_take isl_union_set *ptr);
+
+  isl_union_set *ptr = nullptr;
+
+  inline explicit UnionSet(__isl_take isl_union_set *ptr);
+
+public:
+  inline UnionSet();
+  inline UnionSet(const UnionSet &obj);
+  inline UnionSet(std::nullptr_t);
+  inline UnionSet &operator=(UnionSet obj);
+  inline ~UnionSet();
+  inline __isl_give isl_union_set *copy() const &;
+  inline __isl_give isl_union_set *copy() && = delete;
+  inline __isl_keep isl_union_set *get() const;
+  inline __isl_give isl_union_set *release();
+  inline __isl_keep isl_union_set *keep() const;
+  inline __isl_give isl_union_set *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// declarations for isl::Val
+inline Val manage(__isl_take isl_val *ptr);
+
+inline Val give(__isl_take isl_val *ptr);
+
+class Val {
+  friend inline Val manage(__isl_take isl_val *ptr);
+
+inline Val give(__isl_take isl_val *ptr);
+
+  isl_val *ptr = nullptr;
+
+  inline explicit Val(__isl_take isl_val *ptr);
+
+public:
+  inline Val();
+  inline Val(const Val &obj);
+  inline Val(std::nullptr_t);
+  inline Val &operator=(Val obj);
+  inline ~Val();
+  inline __isl_give isl_val *copy() const &;
+  inline __isl_give isl_val *copy() && = delete;
+  inline __isl_keep isl_val *get() const;
+  inline __isl_give isl_val *release();
+  inline __isl_keep isl_val *keep() const;
+  inline __isl_give isl_val *take();
+  inline explicit operator bool() const;
+  inline isl_ctx *getCtx() const;
+  inline bool isNull() const;
+  inline std::string getStr() const;
+};
+
+// implementations for isl::Aff
+Aff manage(__isl_take isl_aff *ptr) {
+  return Aff(ptr);
+}
+
+Aff give(__isl_take isl_aff *ptr) {
+  return manage(ptr);
+}
+
+Aff::Aff()
+    : ptr(nullptr) {}
+
+Aff::Aff(const Aff &obj)
+    : ptr(obj.copy()) {}
+
+Aff::Aff(std::nullptr_t)
+    : ptr(nullptr) {}
+
+Aff::Aff(__isl_take isl_aff *ptr)
+    : ptr(ptr) {}
+
+Aff &Aff::operator=(Aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+Aff::~Aff() {
+  if (ptr)
+    isl_aff_free(ptr);
+}
+
+__isl_give isl_aff *Aff::copy() const & {
+  return isl_aff_copy(ptr);
+}
+
+__isl_keep isl_aff *Aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_aff *Aff::release() {
+  isl_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_aff *Aff::keep() const {
+  return get();
+}
+
+__isl_give isl_aff *Aff::take() {
+  return release();
+}
+
+Aff::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *Aff::getCtx() const {
+  return isl_aff_get_ctx(ptr);
+}
+
+bool Aff::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string Aff::getStr() const {
+  char *Tmp = isl_aff_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const Aff &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::AstBuild
+AstBuild manage(__isl_take isl_ast_build *ptr) {
+  return AstBuild(ptr);
+}
+
+AstBuild give(__isl_take isl_ast_build *ptr) {
+  return manage(ptr);
+}
+
+AstBuild::AstBuild()
+    : ptr(nullptr) {}
+
+AstBuild::AstBuild(const AstBuild &obj)
+    : ptr(obj.copy()) {}
+
+AstBuild::AstBuild(std::nullptr_t)
+    : ptr(nullptr) {}
+
+AstBuild::AstBuild(__isl_take isl_ast_build *ptr)
+    : ptr(ptr) {}
+
+AstBuild &AstBuild::operator=(AstBuild obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+AstBuild::~AstBuild() {
+  if (ptr)
+    isl_ast_build_free(ptr);
+}
+
+__isl_give isl_ast_build *AstBuild::copy() const & {
+  return isl_ast_build_copy(ptr);
+}
+
+__isl_keep isl_ast_build *AstBuild::get() const {
+  return ptr;
+}
+
+__isl_give isl_ast_build *AstBuild::release() {
+  isl_ast_build *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_ast_build *AstBuild::keep() const {
+  return get();
+}
+
+__isl_give isl_ast_build *AstBuild::take() {
+  return release();
+}
+
+AstBuild::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *AstBuild::getCtx() const {
+  return isl_ast_build_get_ctx(ptr);
+}
+
+bool AstBuild::isNull() const {
+  return ptr == nullptr;
+}
+
+// implementations for isl::AstExpr
+AstExpr manage(__isl_take isl_ast_expr *ptr) {
+  return AstExpr(ptr);
+}
+
+AstExpr give(__isl_take isl_ast_expr *ptr) {
+  return manage(ptr);
+}
+
+AstExpr::AstExpr()
+    : ptr(nullptr) {}
+
+AstExpr::AstExpr(const AstExpr &obj)
+    : ptr(obj.copy()) {}
+
+AstExpr::AstExpr(std::nullptr_t)
+    : ptr(nullptr) {}
+
+AstExpr::AstExpr(__isl_take isl_ast_expr *ptr)
+    : ptr(ptr) {}
+
+AstExpr &AstExpr::operator=(AstExpr obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+AstExpr::~AstExpr() {
+  if (ptr)
+    isl_ast_expr_free(ptr);
+}
+
+__isl_give isl_ast_expr *AstExpr::copy() const & {
+  return isl_ast_expr_copy(ptr);
+}
+
+__isl_keep isl_ast_expr *AstExpr::get() const {
+  return ptr;
+}
+
+__isl_give isl_ast_expr *AstExpr::release() {
+  isl_ast_expr *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_ast_expr *AstExpr::keep() const {
+  return get();
+}
+
+__isl_give isl_ast_expr *AstExpr::take() {
+  return release();
+}
+
+AstExpr::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *AstExpr::getCtx() const {
+  return isl_ast_expr_get_ctx(ptr);
+}
+
+bool AstExpr::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string AstExpr::getStr() const {
+  char *Tmp = isl_ast_expr_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const AstExpr &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::AstNode
+AstNode manage(__isl_take isl_ast_node *ptr) {
+  return AstNode(ptr);
+}
+
+AstNode give(__isl_take isl_ast_node *ptr) {
+  return manage(ptr);
+}
+
+AstNode::AstNode()
+    : ptr(nullptr) {}
+
+AstNode::AstNode(const AstNode &obj)
+    : ptr(obj.copy()) {}
+
+AstNode::AstNode(std::nullptr_t)
+    : ptr(nullptr) {}
+
+AstNode::AstNode(__isl_take isl_ast_node *ptr)
+    : ptr(ptr) {}
+
+AstNode &AstNode::operator=(AstNode obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+AstNode::~AstNode() {
+  if (ptr)
+    isl_ast_node_free(ptr);
+}
+
+__isl_give isl_ast_node *AstNode::copy() const & {
+  return isl_ast_node_copy(ptr);
+}
+
+__isl_keep isl_ast_node *AstNode::get() const {
+  return ptr;
+}
+
+__isl_give isl_ast_node *AstNode::release() {
+  isl_ast_node *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_ast_node *AstNode::keep() const {
+  return get();
+}
+
+__isl_give isl_ast_node *AstNode::take() {
+  return release();
+}
+
+AstNode::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *AstNode::getCtx() const {
+  return isl_ast_node_get_ctx(ptr);
+}
+
+bool AstNode::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string AstNode::getStr() const {
+  char *Tmp = isl_ast_node_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const AstNode &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::BasicMap
+BasicMap manage(__isl_take isl_basic_map *ptr) {
+  return BasicMap(ptr);
+}
+
+BasicMap give(__isl_take isl_basic_map *ptr) {
+  return manage(ptr);
+}
+
+BasicMap::BasicMap()
+    : ptr(nullptr) {}
+
+BasicMap::BasicMap(const BasicMap &obj)
+    : ptr(obj.copy()) {}
+
+BasicMap::BasicMap(std::nullptr_t)
+    : ptr(nullptr) {}
+
+BasicMap::BasicMap(__isl_take isl_basic_map *ptr)
+    : ptr(ptr) {}
+
+BasicMap &BasicMap::operator=(BasicMap obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+BasicMap::~BasicMap() {
+  if (ptr)
+    isl_basic_map_free(ptr);
+}
+
+__isl_give isl_basic_map *BasicMap::copy() const & {
+  return isl_basic_map_copy(ptr);
+}
+
+__isl_keep isl_basic_map *BasicMap::get() const {
+  return ptr;
+}
+
+__isl_give isl_basic_map *BasicMap::release() {
+  isl_basic_map *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_basic_map *BasicMap::keep() const {
+  return get();
+}
+
+__isl_give isl_basic_map *BasicMap::take() {
+  return release();
+}
+
+BasicMap::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *BasicMap::getCtx() const {
+  return isl_basic_map_get_ctx(ptr);
+}
+
+bool BasicMap::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string BasicMap::getStr() const {
+  char *Tmp = isl_basic_map_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const BasicMap &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::BasicSet
+BasicSet manage(__isl_take isl_basic_set *ptr) {
+  return BasicSet(ptr);
+}
+
+BasicSet give(__isl_take isl_basic_set *ptr) {
+  return manage(ptr);
+}
+
+BasicSet::BasicSet()
+    : ptr(nullptr) {}
+
+BasicSet::BasicSet(const BasicSet &obj)
+    : ptr(obj.copy()) {}
+
+BasicSet::BasicSet(std::nullptr_t)
+    : ptr(nullptr) {}
+
+BasicSet::BasicSet(__isl_take isl_basic_set *ptr)
+    : ptr(ptr) {}
+
+BasicSet &BasicSet::operator=(BasicSet obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+BasicSet::~BasicSet() {
+  if (ptr)
+    isl_basic_set_free(ptr);
+}
+
+__isl_give isl_basic_set *BasicSet::copy() const & {
+  return isl_basic_set_copy(ptr);
+}
+
+__isl_keep isl_basic_set *BasicSet::get() const {
+  return ptr;
+}
+
+__isl_give isl_basic_set *BasicSet::release() {
+  isl_basic_set *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_basic_set *BasicSet::keep() const {
+  return get();
+}
+
+__isl_give isl_basic_set *BasicSet::take() {
+  return release();
+}
+
+BasicSet::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *BasicSet::getCtx() const {
+  return isl_basic_set_get_ctx(ptr);
+}
+
+bool BasicSet::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string BasicSet::getStr() const {
+  char *Tmp = isl_basic_set_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const BasicSet &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::Id
+Id manage(__isl_take isl_id *ptr) {
+  return Id(ptr);
+}
+
+Id give(__isl_take isl_id *ptr) {
+  return manage(ptr);
+}
+
+Id::Id()
+    : ptr(nullptr) {}
+
+Id::Id(const Id &obj)
+    : ptr(obj.copy()) {}
+
+Id::Id(std::nullptr_t)
+    : ptr(nullptr) {}
+
+Id::Id(__isl_take isl_id *ptr)
+    : ptr(ptr) {}
+
+Id &Id::operator=(Id obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+Id::~Id() {
+  if (ptr)
+    isl_id_free(ptr);
+}
+
+__isl_give isl_id *Id::copy() const & {
+  return isl_id_copy(ptr);
+}
+
+__isl_keep isl_id *Id::get() const {
+  return ptr;
+}
+
+__isl_give isl_id *Id::release() {
+  isl_id *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_id *Id::keep() const {
+  return get();
+}
+
+__isl_give isl_id *Id::take() {
+  return release();
+}
+
+Id::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *Id::getCtx() const {
+  return isl_id_get_ctx(ptr);
+}
+
+bool Id::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string Id::getStr() const {
+  char *Tmp = isl_id_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const Id &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::Map
+Map manage(__isl_take isl_map *ptr) {
+  return Map(ptr);
+}
+
+Map give(__isl_take isl_map *ptr) {
+  return manage(ptr);
+}
+
+Map::Map()
+    : ptr(nullptr) {}
+
+Map::Map(const Map &obj)
+    : ptr(obj.copy()) {}
+
+Map::Map(std::nullptr_t)
+    : ptr(nullptr) {}
+
+Map::Map(__isl_take isl_map *ptr)
+    : ptr(ptr) {}
+
+Map &Map::operator=(Map obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+Map::~Map() {
+  if (ptr)
+    isl_map_free(ptr);
+}
+
+__isl_give isl_map *Map::copy() const & {
+  return isl_map_copy(ptr);
+}
+
+__isl_keep isl_map *Map::get() const {
+  return ptr;
+}
+
+__isl_give isl_map *Map::release() {
+  isl_map *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_map *Map::keep() const {
+  return get();
+}
+
+__isl_give isl_map *Map::take() {
+  return release();
+}
+
+Map::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *Map::getCtx() const {
+  return isl_map_get_ctx(ptr);
+}
+
+bool Map::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string Map::getStr() const {
+  char *Tmp = isl_map_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const Map &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::MultiAff
+MultiAff manage(__isl_take isl_multi_aff *ptr) {
+  return MultiAff(ptr);
+}
+
+MultiAff give(__isl_take isl_multi_aff *ptr) {
+  return manage(ptr);
+}
+
+MultiAff::MultiAff()
+    : ptr(nullptr) {}
+
+MultiAff::MultiAff(const MultiAff &obj)
+    : ptr(obj.copy()) {}
+
+MultiAff::MultiAff(std::nullptr_t)
+    : ptr(nullptr) {}
+
+MultiAff::MultiAff(__isl_take isl_multi_aff *ptr)
+    : ptr(ptr) {}
+
+MultiAff &MultiAff::operator=(MultiAff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+MultiAff::~MultiAff() {
+  if (ptr)
+    isl_multi_aff_free(ptr);
+}
+
+__isl_give isl_multi_aff *MultiAff::copy() const & {
+  return isl_multi_aff_copy(ptr);
+}
+
+__isl_keep isl_multi_aff *MultiAff::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_aff *MultiAff::release() {
+  isl_multi_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_multi_aff *MultiAff::keep() const {
+  return get();
+}
+
+__isl_give isl_multi_aff *MultiAff::take() {
+  return release();
+}
+
+MultiAff::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *MultiAff::getCtx() const {
+  return isl_multi_aff_get_ctx(ptr);
+}
+
+bool MultiAff::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string MultiAff::getStr() const {
+  char *Tmp = isl_multi_aff_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const MultiAff &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::MultiPwAff
+MultiPwAff manage(__isl_take isl_multi_pw_aff *ptr) {
+  return MultiPwAff(ptr);
+}
+
+MultiPwAff give(__isl_take isl_multi_pw_aff *ptr) {
+  return manage(ptr);
+}
+
+MultiPwAff::MultiPwAff()
+    : ptr(nullptr) {}
+
+MultiPwAff::MultiPwAff(const MultiPwAff &obj)
+    : ptr(obj.copy()) {}
+
+MultiPwAff::MultiPwAff(std::nullptr_t)
+    : ptr(nullptr) {}
+
+MultiPwAff::MultiPwAff(__isl_take isl_multi_pw_aff *ptr)
+    : ptr(ptr) {}
+
+MultiPwAff &MultiPwAff::operator=(MultiPwAff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+MultiPwAff::~MultiPwAff() {
+  if (ptr)
+    isl_multi_pw_aff_free(ptr);
+}
+
+__isl_give isl_multi_pw_aff *MultiPwAff::copy() const & {
+  return isl_multi_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_multi_pw_aff *MultiPwAff::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_pw_aff *MultiPwAff::release() {
+  isl_multi_pw_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_multi_pw_aff *MultiPwAff::keep() const {
+  return get();
+}
+
+__isl_give isl_multi_pw_aff *MultiPwAff::take() {
+  return release();
+}
+
+MultiPwAff::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *MultiPwAff::getCtx() const {
+  return isl_multi_pw_aff_get_ctx(ptr);
+}
+
+bool MultiPwAff::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string MultiPwAff::getStr() const {
+  char *Tmp = isl_multi_pw_aff_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const MultiPwAff &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::MultiUnionPwAff
+MultiUnionPwAff manage(__isl_take isl_multi_union_pw_aff *ptr) {
+  return MultiUnionPwAff(ptr);
+}
+
+MultiUnionPwAff give(__isl_take isl_multi_union_pw_aff *ptr) {
+  return manage(ptr);
+}
+
+MultiUnionPwAff::MultiUnionPwAff()
+    : ptr(nullptr) {}
+
+MultiUnionPwAff::MultiUnionPwAff(const MultiUnionPwAff &obj)
+    : ptr(obj.copy()) {}
+
+MultiUnionPwAff::MultiUnionPwAff(std::nullptr_t)
+    : ptr(nullptr) {}
+
+MultiUnionPwAff::MultiUnionPwAff(__isl_take isl_multi_union_pw_aff *ptr)
+    : ptr(ptr) {}
+
+MultiUnionPwAff &MultiUnionPwAff::operator=(MultiUnionPwAff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+MultiUnionPwAff::~MultiUnionPwAff() {
+  if (ptr)
+    isl_multi_union_pw_aff_free(ptr);
+}
+
+__isl_give isl_multi_union_pw_aff *MultiUnionPwAff::copy() const & {
+  return isl_multi_union_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_multi_union_pw_aff *MultiUnionPwAff::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_union_pw_aff *MultiUnionPwAff::release() {
+  isl_multi_union_pw_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_multi_union_pw_aff *MultiUnionPwAff::keep() const {
+  return get();
+}
+
+__isl_give isl_multi_union_pw_aff *MultiUnionPwAff::take() {
+  return release();
+}
+
+MultiUnionPwAff::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *MultiUnionPwAff::getCtx() const {
+  return isl_multi_union_pw_aff_get_ctx(ptr);
+}
+
+bool MultiUnionPwAff::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string MultiUnionPwAff::getStr() const {
+  char *Tmp = isl_multi_union_pw_aff_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const MultiUnionPwAff &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::MultiVal
+MultiVal manage(__isl_take isl_multi_val *ptr) {
+  return MultiVal(ptr);
+}
+
+MultiVal give(__isl_take isl_multi_val *ptr) {
+  return manage(ptr);
+}
+
+MultiVal::MultiVal()
+    : ptr(nullptr) {}
+
+MultiVal::MultiVal(const MultiVal &obj)
+    : ptr(obj.copy()) {}
+
+MultiVal::MultiVal(std::nullptr_t)
+    : ptr(nullptr) {}
+
+MultiVal::MultiVal(__isl_take isl_multi_val *ptr)
+    : ptr(ptr) {}
+
+MultiVal &MultiVal::operator=(MultiVal obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+MultiVal::~MultiVal() {
+  if (ptr)
+    isl_multi_val_free(ptr);
+}
+
+__isl_give isl_multi_val *MultiVal::copy() const & {
+  return isl_multi_val_copy(ptr);
+}
+
+__isl_keep isl_multi_val *MultiVal::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_val *MultiVal::release() {
+  isl_multi_val *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_multi_val *MultiVal::keep() const {
+  return get();
+}
+
+__isl_give isl_multi_val *MultiVal::take() {
+  return release();
+}
+
+MultiVal::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *MultiVal::getCtx() const {
+  return isl_multi_val_get_ctx(ptr);
+}
+
+bool MultiVal::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string MultiVal::getStr() const {
+  char *Tmp = isl_multi_val_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const MultiVal &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::Point
+Point manage(__isl_take isl_point *ptr) {
+  return Point(ptr);
+}
+
+Point give(__isl_take isl_point *ptr) {
+  return manage(ptr);
+}
+
+Point::Point()
+    : ptr(nullptr) {}
+
+Point::Point(const Point &obj)
+    : ptr(obj.copy()) {}
+
+Point::Point(std::nullptr_t)
+    : ptr(nullptr) {}
+
+Point::Point(__isl_take isl_point *ptr)
+    : ptr(ptr) {}
+
+Point &Point::operator=(Point obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+Point::~Point() {
+  if (ptr)
+    isl_point_free(ptr);
+}
+
+__isl_give isl_point *Point::copy() const & {
+  return isl_point_copy(ptr);
+}
+
+__isl_keep isl_point *Point::get() const {
+  return ptr;
+}
+
+__isl_give isl_point *Point::release() {
+  isl_point *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_point *Point::keep() const {
+  return get();
+}
+
+__isl_give isl_point *Point::take() {
+  return release();
+}
+
+Point::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *Point::getCtx() const {
+  return isl_point_get_ctx(ptr);
+}
+
+bool Point::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string Point::getStr() const {
+  char *Tmp = isl_point_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const Point &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::PwAff
+PwAff manage(__isl_take isl_pw_aff *ptr) {
+  return PwAff(ptr);
+}
+
+PwAff give(__isl_take isl_pw_aff *ptr) {
+  return manage(ptr);
+}
+
+PwAff::PwAff()
+    : ptr(nullptr) {}
+
+PwAff::PwAff(const PwAff &obj)
+    : ptr(obj.copy()) {}
+
+PwAff::PwAff(std::nullptr_t)
+    : ptr(nullptr) {}
+
+PwAff::PwAff(__isl_take isl_pw_aff *ptr)
+    : ptr(ptr) {}
+
+PwAff &PwAff::operator=(PwAff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+PwAff::~PwAff() {
+  if (ptr)
+    isl_pw_aff_free(ptr);
+}
+
+__isl_give isl_pw_aff *PwAff::copy() const & {
+  return isl_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_pw_aff *PwAff::get() const {
+  return ptr;
+}
+
+__isl_give isl_pw_aff *PwAff::release() {
+  isl_pw_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_pw_aff *PwAff::keep() const {
+  return get();
+}
+
+__isl_give isl_pw_aff *PwAff::take() {
+  return release();
+}
+
+PwAff::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *PwAff::getCtx() const {
+  return isl_pw_aff_get_ctx(ptr);
+}
+
+bool PwAff::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string PwAff::getStr() const {
+  char *Tmp = isl_pw_aff_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const PwAff &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::PwMultiAff
+PwMultiAff manage(__isl_take isl_pw_multi_aff *ptr) {
+  return PwMultiAff(ptr);
+}
+
+PwMultiAff give(__isl_take isl_pw_multi_aff *ptr) {
+  return manage(ptr);
+}
+
+PwMultiAff::PwMultiAff()
+    : ptr(nullptr) {}
+
+PwMultiAff::PwMultiAff(const PwMultiAff &obj)
+    : ptr(obj.copy()) {}
+
+PwMultiAff::PwMultiAff(std::nullptr_t)
+    : ptr(nullptr) {}
+
+PwMultiAff::PwMultiAff(__isl_take isl_pw_multi_aff *ptr)
+    : ptr(ptr) {}
+
+PwMultiAff &PwMultiAff::operator=(PwMultiAff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+PwMultiAff::~PwMultiAff() {
+  if (ptr)
+    isl_pw_multi_aff_free(ptr);
+}
+
+__isl_give isl_pw_multi_aff *PwMultiAff::copy() const & {
+  return isl_pw_multi_aff_copy(ptr);
+}
+
+__isl_keep isl_pw_multi_aff *PwMultiAff::get() const {
+  return ptr;
+}
+
+__isl_give isl_pw_multi_aff *PwMultiAff::release() {
+  isl_pw_multi_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_pw_multi_aff *PwMultiAff::keep() const {
+  return get();
+}
+
+__isl_give isl_pw_multi_aff *PwMultiAff::take() {
+  return release();
+}
+
+PwMultiAff::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *PwMultiAff::getCtx() const {
+  return isl_pw_multi_aff_get_ctx(ptr);
+}
+
+bool PwMultiAff::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string PwMultiAff::getStr() const {
+  char *Tmp = isl_pw_multi_aff_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const PwMultiAff &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::Schedule
+Schedule manage(__isl_take isl_schedule *ptr) {
+  return Schedule(ptr);
+}
+
+Schedule give(__isl_take isl_schedule *ptr) {
+  return manage(ptr);
+}
+
+Schedule::Schedule()
+    : ptr(nullptr) {}
+
+Schedule::Schedule(const Schedule &obj)
+    : ptr(obj.copy()) {}
+
+Schedule::Schedule(std::nullptr_t)
+    : ptr(nullptr) {}
+
+Schedule::Schedule(__isl_take isl_schedule *ptr)
+    : ptr(ptr) {}
+
+Schedule &Schedule::operator=(Schedule obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+Schedule::~Schedule() {
+  if (ptr)
+    isl_schedule_free(ptr);
+}
+
+__isl_give isl_schedule *Schedule::copy() const & {
+  return isl_schedule_copy(ptr);
+}
+
+__isl_keep isl_schedule *Schedule::get() const {
+  return ptr;
+}
+
+__isl_give isl_schedule *Schedule::release() {
+  isl_schedule *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_schedule *Schedule::keep() const {
+  return get();
+}
+
+__isl_give isl_schedule *Schedule::take() {
+  return release();
+}
+
+Schedule::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *Schedule::getCtx() const {
+  return isl_schedule_get_ctx(ptr);
+}
+
+bool Schedule::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string Schedule::getStr() const {
+  char *Tmp = isl_schedule_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const Schedule &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::ScheduleConstraints
+ScheduleConstraints manage(__isl_take isl_schedule_constraints *ptr) {
+  return ScheduleConstraints(ptr);
+}
+
+ScheduleConstraints give(__isl_take isl_schedule_constraints *ptr) {
+  return manage(ptr);
+}
+
+ScheduleConstraints::ScheduleConstraints()
+    : ptr(nullptr) {}
+
+ScheduleConstraints::ScheduleConstraints(const ScheduleConstraints &obj)
+    : ptr(obj.copy()) {}
+
+ScheduleConstraints::ScheduleConstraints(std::nullptr_t)
+    : ptr(nullptr) {}
+
+ScheduleConstraints::ScheduleConstraints(__isl_take isl_schedule_constraints *ptr)
+    : ptr(ptr) {}
+
+ScheduleConstraints &ScheduleConstraints::operator=(ScheduleConstraints obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+ScheduleConstraints::~ScheduleConstraints() {
+  if (ptr)
+    isl_schedule_constraints_free(ptr);
+}
+
+__isl_give isl_schedule_constraints *ScheduleConstraints::copy() const & {
+  return isl_schedule_constraints_copy(ptr);
+}
+
+__isl_keep isl_schedule_constraints *ScheduleConstraints::get() const {
+  return ptr;
+}
+
+__isl_give isl_schedule_constraints *ScheduleConstraints::release() {
+  isl_schedule_constraints *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_schedule_constraints *ScheduleConstraints::keep() const {
+  return get();
+}
+
+__isl_give isl_schedule_constraints *ScheduleConstraints::take() {
+  return release();
+}
+
+ScheduleConstraints::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *ScheduleConstraints::getCtx() const {
+  return isl_schedule_constraints_get_ctx(ptr);
+}
+
+bool ScheduleConstraints::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string ScheduleConstraints::getStr() const {
+  char *Tmp = isl_schedule_constraints_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const ScheduleConstraints &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::ScheduleNode
+ScheduleNode manage(__isl_take isl_schedule_node *ptr) {
+  return ScheduleNode(ptr);
+}
+
+ScheduleNode give(__isl_take isl_schedule_node *ptr) {
+  return manage(ptr);
+}
+
+ScheduleNode::ScheduleNode()
+    : ptr(nullptr) {}
+
+ScheduleNode::ScheduleNode(const ScheduleNode &obj)
+    : ptr(obj.copy()) {}
+
+ScheduleNode::ScheduleNode(std::nullptr_t)
+    : ptr(nullptr) {}
+
+ScheduleNode::ScheduleNode(__isl_take isl_schedule_node *ptr)
+    : ptr(ptr) {}
+
+ScheduleNode &ScheduleNode::operator=(ScheduleNode obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+ScheduleNode::~ScheduleNode() {
+  if (ptr)
+    isl_schedule_node_free(ptr);
+}
+
+__isl_give isl_schedule_node *ScheduleNode::copy() const & {
+  return isl_schedule_node_copy(ptr);
+}
+
+__isl_keep isl_schedule_node *ScheduleNode::get() const {
+  return ptr;
+}
+
+__isl_give isl_schedule_node *ScheduleNode::release() {
+  isl_schedule_node *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_schedule_node *ScheduleNode::keep() const {
+  return get();
+}
+
+__isl_give isl_schedule_node *ScheduleNode::take() {
+  return release();
+}
+
+ScheduleNode::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *ScheduleNode::getCtx() const {
+  return isl_schedule_node_get_ctx(ptr);
+}
+
+bool ScheduleNode::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string ScheduleNode::getStr() const {
+  char *Tmp = isl_schedule_node_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const ScheduleNode &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::Set
+Set manage(__isl_take isl_set *ptr) {
+  return Set(ptr);
+}
+
+Set give(__isl_take isl_set *ptr) {
+  return manage(ptr);
+}
+
+Set::Set()
+    : ptr(nullptr) {}
+
+Set::Set(const Set &obj)
+    : ptr(obj.copy()) {}
+
+Set::Set(std::nullptr_t)
+    : ptr(nullptr) {}
+
+Set::Set(__isl_take isl_set *ptr)
+    : ptr(ptr) {}
+
+Set &Set::operator=(Set obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+Set::~Set() {
+  if (ptr)
+    isl_set_free(ptr);
+}
+
+__isl_give isl_set *Set::copy() const & {
+  return isl_set_copy(ptr);
+}
+
+__isl_keep isl_set *Set::get() const {
+  return ptr;
+}
+
+__isl_give isl_set *Set::release() {
+  isl_set *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_set *Set::keep() const {
+  return get();
+}
+
+__isl_give isl_set *Set::take() {
+  return release();
+}
+
+Set::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *Set::getCtx() const {
+  return isl_set_get_ctx(ptr);
+}
+
+bool Set::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string Set::getStr() const {
+  char *Tmp = isl_set_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const Set &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::Space
+Space manage(__isl_take isl_space *ptr) {
+  return Space(ptr);
+}
+
+Space give(__isl_take isl_space *ptr) {
+  return manage(ptr);
+}
+
+Space::Space()
+    : ptr(nullptr) {}
+
+Space::Space(const Space &obj)
+    : ptr(obj.copy()) {}
+
+Space::Space(std::nullptr_t)
+    : ptr(nullptr) {}
+
+Space::Space(__isl_take isl_space *ptr)
+    : ptr(ptr) {}
+
+Space &Space::operator=(Space obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+Space::~Space() {
+  if (ptr)
+    isl_space_free(ptr);
+}
+
+__isl_give isl_space *Space::copy() const & {
+  return isl_space_copy(ptr);
+}
+
+__isl_keep isl_space *Space::get() const {
+  return ptr;
+}
+
+__isl_give isl_space *Space::release() {
+  isl_space *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_space *Space::keep() const {
+  return get();
+}
+
+__isl_give isl_space *Space::take() {
+  return release();
+}
+
+Space::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *Space::getCtx() const {
+  return isl_space_get_ctx(ptr);
+}
+
+bool Space::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string Space::getStr() const {
+  char *Tmp = isl_space_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const Space &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::UnionAccessInfo
+UnionAccessInfo manage(__isl_take isl_union_access_info *ptr) {
+  return UnionAccessInfo(ptr);
+}
+
+UnionAccessInfo give(__isl_take isl_union_access_info *ptr) {
+  return manage(ptr);
+}
+
+UnionAccessInfo::UnionAccessInfo()
+    : ptr(nullptr) {}
+
+UnionAccessInfo::UnionAccessInfo(const UnionAccessInfo &obj)
+    : ptr(obj.copy()) {}
+
+UnionAccessInfo::UnionAccessInfo(std::nullptr_t)
+    : ptr(nullptr) {}
+
+UnionAccessInfo::UnionAccessInfo(__isl_take isl_union_access_info *ptr)
+    : ptr(ptr) {}
+
+UnionAccessInfo &UnionAccessInfo::operator=(UnionAccessInfo obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+UnionAccessInfo::~UnionAccessInfo() {
+  if (ptr)
+    isl_union_access_info_free(ptr);
+}
+
+__isl_give isl_union_access_info *UnionAccessInfo::copy() const & {
+  return isl_union_access_info_copy(ptr);
+}
+
+__isl_keep isl_union_access_info *UnionAccessInfo::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_access_info *UnionAccessInfo::release() {
+  isl_union_access_info *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_union_access_info *UnionAccessInfo::keep() const {
+  return get();
+}
+
+__isl_give isl_union_access_info *UnionAccessInfo::take() {
+  return release();
+}
+
+UnionAccessInfo::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *UnionAccessInfo::getCtx() const {
+  return isl_union_access_info_get_ctx(ptr);
+}
+
+bool UnionAccessInfo::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string UnionAccessInfo::getStr() const {
+  char *Tmp = isl_union_access_info_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const UnionAccessInfo &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::UnionFlow
+UnionFlow manage(__isl_take isl_union_flow *ptr) {
+  return UnionFlow(ptr);
+}
+
+UnionFlow give(__isl_take isl_union_flow *ptr) {
+  return manage(ptr);
+}
+
+UnionFlow::UnionFlow()
+    : ptr(nullptr) {}
+
+UnionFlow::UnionFlow(const UnionFlow &obj)
+    : ptr(obj.copy()) {}
+
+UnionFlow::UnionFlow(std::nullptr_t)
+    : ptr(nullptr) {}
+
+UnionFlow::UnionFlow(__isl_take isl_union_flow *ptr)
+    : ptr(ptr) {}
+
+UnionFlow &UnionFlow::operator=(UnionFlow obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+UnionFlow::~UnionFlow() {
+  if (ptr)
+    isl_union_flow_free(ptr);
+}
+
+__isl_give isl_union_flow *UnionFlow::copy() const & {
+  return isl_union_flow_copy(ptr);
+}
+
+__isl_keep isl_union_flow *UnionFlow::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_flow *UnionFlow::release() {
+  isl_union_flow *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_union_flow *UnionFlow::keep() const {
+  return get();
+}
+
+__isl_give isl_union_flow *UnionFlow::take() {
+  return release();
+}
+
+UnionFlow::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *UnionFlow::getCtx() const {
+  return isl_union_flow_get_ctx(ptr);
+}
+
+bool UnionFlow::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string UnionFlow::getStr() const {
+  char *Tmp = isl_union_flow_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const UnionFlow &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::UnionMap
+UnionMap manage(__isl_take isl_union_map *ptr) {
+  return UnionMap(ptr);
+}
+
+UnionMap give(__isl_take isl_union_map *ptr) {
+  return manage(ptr);
+}
+
+UnionMap::UnionMap()
+    : ptr(nullptr) {}
+
+UnionMap::UnionMap(const UnionMap &obj)
+    : ptr(obj.copy()) {}
+
+UnionMap::UnionMap(std::nullptr_t)
+    : ptr(nullptr) {}
+
+UnionMap::UnionMap(__isl_take isl_union_map *ptr)
+    : ptr(ptr) {}
+
+UnionMap &UnionMap::operator=(UnionMap obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+UnionMap::~UnionMap() {
+  if (ptr)
+    isl_union_map_free(ptr);
+}
+
+__isl_give isl_union_map *UnionMap::copy() const & {
+  return isl_union_map_copy(ptr);
+}
+
+__isl_keep isl_union_map *UnionMap::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_map *UnionMap::release() {
+  isl_union_map *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_union_map *UnionMap::keep() const {
+  return get();
+}
+
+__isl_give isl_union_map *UnionMap::take() {
+  return release();
+}
+
+UnionMap::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *UnionMap::getCtx() const {
+  return isl_union_map_get_ctx(ptr);
+}
+
+bool UnionMap::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string UnionMap::getStr() const {
+  char *Tmp = isl_union_map_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const UnionMap &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::UnionPwAff
+UnionPwAff manage(__isl_take isl_union_pw_aff *ptr) {
+  return UnionPwAff(ptr);
+}
+
+UnionPwAff give(__isl_take isl_union_pw_aff *ptr) {
+  return manage(ptr);
+}
+
+UnionPwAff::UnionPwAff()
+    : ptr(nullptr) {}
+
+UnionPwAff::UnionPwAff(const UnionPwAff &obj)
+    : ptr(obj.copy()) {}
+
+UnionPwAff::UnionPwAff(std::nullptr_t)
+    : ptr(nullptr) {}
+
+UnionPwAff::UnionPwAff(__isl_take isl_union_pw_aff *ptr)
+    : ptr(ptr) {}
+
+UnionPwAff &UnionPwAff::operator=(UnionPwAff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+UnionPwAff::~UnionPwAff() {
+  if (ptr)
+    isl_union_pw_aff_free(ptr);
+}
+
+__isl_give isl_union_pw_aff *UnionPwAff::copy() const & {
+  return isl_union_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_union_pw_aff *UnionPwAff::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_pw_aff *UnionPwAff::release() {
+  isl_union_pw_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_union_pw_aff *UnionPwAff::keep() const {
+  return get();
+}
+
+__isl_give isl_union_pw_aff *UnionPwAff::take() {
+  return release();
+}
+
+UnionPwAff::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *UnionPwAff::getCtx() const {
+  return isl_union_pw_aff_get_ctx(ptr);
+}
+
+bool UnionPwAff::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string UnionPwAff::getStr() const {
+  char *Tmp = isl_union_pw_aff_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const UnionPwAff &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::UnionPwMultiAff
+UnionPwMultiAff manage(__isl_take isl_union_pw_multi_aff *ptr) {
+  return UnionPwMultiAff(ptr);
+}
+
+UnionPwMultiAff give(__isl_take isl_union_pw_multi_aff *ptr) {
+  return manage(ptr);
+}
+
+UnionPwMultiAff::UnionPwMultiAff()
+    : ptr(nullptr) {}
+
+UnionPwMultiAff::UnionPwMultiAff(const UnionPwMultiAff &obj)
+    : ptr(obj.copy()) {}
+
+UnionPwMultiAff::UnionPwMultiAff(std::nullptr_t)
+    : ptr(nullptr) {}
+
+UnionPwMultiAff::UnionPwMultiAff(__isl_take isl_union_pw_multi_aff *ptr)
+    : ptr(ptr) {}
+
+UnionPwMultiAff &UnionPwMultiAff::operator=(UnionPwMultiAff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+UnionPwMultiAff::~UnionPwMultiAff() {
+  if (ptr)
+    isl_union_pw_multi_aff_free(ptr);
+}
+
+__isl_give isl_union_pw_multi_aff *UnionPwMultiAff::copy() const & {
+  return isl_union_pw_multi_aff_copy(ptr);
+}
+
+__isl_keep isl_union_pw_multi_aff *UnionPwMultiAff::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_pw_multi_aff *UnionPwMultiAff::release() {
+  isl_union_pw_multi_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_union_pw_multi_aff *UnionPwMultiAff::keep() const {
+  return get();
+}
+
+__isl_give isl_union_pw_multi_aff *UnionPwMultiAff::take() {
+  return release();
+}
+
+UnionPwMultiAff::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *UnionPwMultiAff::getCtx() const {
+  return isl_union_pw_multi_aff_get_ctx(ptr);
+}
+
+bool UnionPwMultiAff::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string UnionPwMultiAff::getStr() const {
+  char *Tmp = isl_union_pw_multi_aff_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const UnionPwMultiAff &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::UnionSet
+UnionSet manage(__isl_take isl_union_set *ptr) {
+  return UnionSet(ptr);
+}
+
+UnionSet give(__isl_take isl_union_set *ptr) {
+  return manage(ptr);
+}
+
+UnionSet::UnionSet()
+    : ptr(nullptr) {}
+
+UnionSet::UnionSet(const UnionSet &obj)
+    : ptr(obj.copy()) {}
+
+UnionSet::UnionSet(std::nullptr_t)
+    : ptr(nullptr) {}
+
+UnionSet::UnionSet(__isl_take isl_union_set *ptr)
+    : ptr(ptr) {}
+
+UnionSet &UnionSet::operator=(UnionSet obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+UnionSet::~UnionSet() {
+  if (ptr)
+    isl_union_set_free(ptr);
+}
+
+__isl_give isl_union_set *UnionSet::copy() const & {
+  return isl_union_set_copy(ptr);
+}
+
+__isl_keep isl_union_set *UnionSet::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_set *UnionSet::release() {
+  isl_union_set *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_union_set *UnionSet::keep() const {
+  return get();
+}
+
+__isl_give isl_union_set *UnionSet::take() {
+  return release();
+}
+
+UnionSet::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *UnionSet::getCtx() const {
+  return isl_union_set_get_ctx(ptr);
+}
+
+bool UnionSet::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string UnionSet::getStr() const {
+  char *Tmp = isl_union_set_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const UnionSet &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+// implementations for isl::Val
+Val manage(__isl_take isl_val *ptr) {
+  return Val(ptr);
+}
+
+Val give(__isl_take isl_val *ptr) {
+  return manage(ptr);
+}
+
+Val::Val()
+    : ptr(nullptr) {}
+
+Val::Val(const Val &obj)
+    : ptr(obj.copy()) {}
+
+Val::Val(std::nullptr_t)
+    : ptr(nullptr) {}
+
+Val::Val(__isl_take isl_val *ptr)
+    : ptr(ptr) {}
+
+Val &Val::operator=(Val obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+Val::~Val() {
+  if (ptr)
+    isl_val_free(ptr);
+}
+
+__isl_give isl_val *Val::copy() const & {
+  return isl_val_copy(ptr);
+}
+
+__isl_keep isl_val *Val::get() const {
+  return ptr;
+}
+
+__isl_give isl_val *Val::release() {
+  isl_val *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+__isl_keep isl_val *Val::keep() const {
+  return get();
+}
+
+__isl_give isl_val *Val::take() {
+  return release();
+}
+
+Val::operator bool() const {
+  return !isNull();
+}
+
+isl_ctx *Val::getCtx() const {
+  return isl_val_get_ctx(ptr);
+}
+
+bool Val::isNull() const {
+  return ptr == nullptr;
+}
+
+std::string Val::getStr() const {
+  char *Tmp = isl_val_to_str(get());
+  if (!Tmp)
+    return "";
+  std::string S(Tmp);
+  free(Tmp);
+  return S;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+  const Val &Obj) {
+  OS << Obj.getStr();
+  return OS;
+}
+
+}; /* namespace noexpections */
+
+}; /* namespace isl */
+
+#endif /* ISL_CPP_ALL */

lib/Support/GICHelper.cpp

std::string polly::getIslCompatibleName(const std::string &Prefix,
   raw_string_ostream OS(ValStr);
   Val->printAsOperand(OS, false);
   ValStr = OS.str();
   // Remove the leading %
   ValStr.erase(0, 1);
   return getIslCompatibleName(Prefix, ValStr, Suffix);
 }
 
-#define DEFINE_ISLPTR(TYPE)                                                    \
-  template <> void IslPtr<isl_##TYPE>::dump() const { isl_##TYPE##_dump(Obj); }
-
-namespace polly {
-DEFINE_ISLPTR(id)
-DEFINE_ISLPTR(val)
-DEFINE_ISLPTR(space)
-DEFINE_ISLPTR(basic_map)
-DEFINE_ISLPTR(map)
-DEFINE_ISLPTR(union_map)
-DEFINE_ISLPTR(basic_set)
-DEFINE_ISLPTR(set)
-DEFINE_ISLPTR(union_set)
-DEFINE_ISLPTR(aff)
-DEFINE_ISLPTR(multi_aff)
-DEFINE_ISLPTR(pw_aff)
-DEFINE_ISLPTR(pw_multi_aff)
-DEFINE_ISLPTR(multi_pw_aff)
-DEFINE_ISLPTR(union_pw_aff)
-DEFINE_ISLPTR(multi_union_pw_aff)
-DEFINE_ISLPTR(union_pw_multi_aff)
-}
-
-void polly::foreachElt(const IslPtr<isl_map> &Map,
-                       const std::function<void(IslPtr<isl_basic_map>)> &F) {
+void polly::foreachElt(const isl::Map &Map,
+                       const std::function<void(isl::BasicMap)> &F) {
   isl_map_foreach_basic_map(
       Map.keep(),
       [](__isl_take isl_basic_map *BMap, void *User) -> isl_stat {
         auto &F =
-            *static_cast<const std::function<void(IslPtr<isl_basic_map>)> *>(
-                User);
+            *static_cast<const std::function<void(isl::BasicMap)> *>(User);
         F(give(BMap));
         return isl_stat_ok;
       },
       const_cast<void *>(static_cast<const void *>(&F)));
 }
 
-void polly::foreachElt(const IslPtr<isl_set> &Set,
-                       const std::function<void(IslPtr<isl_basic_set>)> &F) {
+void polly::foreachElt(const isl::Set &Set,
+                       const std::function<void(isl::BasicSet)> &F) {
   isl_set_foreach_basic_set(
       Set.keep(),
       [](__isl_take isl_basic_set *BSet, void *User) -> isl_stat {
         auto &F =
-            *static_cast<const std::function<void(IslPtr<isl_basic_set>)> *>(
-                User);
+            *static_cast<const std::function<void(isl::BasicSet)> *>(User);
         F(give(BSet));
         return isl_stat_ok;
       },
       const_cast<void *>(static_cast<const void *>(&F)));
 }
 
-void polly::foreachElt(const IslPtr<isl_union_map> &UMap,
-                       const std::function<void(IslPtr<isl_map> Map)> &F) {
+void polly::foreachElt(const isl::UnionMap &UMap,
+                       const std::function<void(isl::Map Map)> &F) {
   isl_union_map_foreach_map(
       UMap.keep(),
       [](__isl_take isl_map *Map, void *User) -> isl_stat {
-        auto &F =
-            *static_cast<const std::function<void(IslPtr<isl_map>)> *>(User);
+        auto &F = *static_cast<const std::function<void(isl::Map)> *>(User);
         F(give(Map));
         return isl_stat_ok;
       },
       const_cast<void *>(static_cast<const void *>(&F)));
 }
 
-void polly::foreachElt(const IslPtr<isl_union_set> &USet,
-                       const std::function<void(IslPtr<isl_set> Set)> &F) {
+void polly::foreachElt(const isl::UnionSet &USet,
+                       const std::function<void(isl::Set Set)> &F) {
   isl_union_set_foreach_set(
       USet.keep(),
       [](__isl_take isl_set *Set, void *User) -> isl_stat {
-        auto &F =
-            *static_cast<const std::function<void(IslPtr<isl_set>)> *>(User);
+        auto &F = *static_cast<const std::function<void(isl::Set)> *>(User);
         F(give(Set));
         return isl_stat_ok;
       },
       const_cast<void *>(static_cast<const void *>(&F)));
 }
 
-void polly::foreachElt(const IslPtr<isl_union_pw_aff> &UPwAff,
-                       const std::function<void(IslPtr<isl_pw_aff>)> &F) {
+void polly::foreachElt(const isl::UnionPwAff &UPwAff,
+                       const std::function<void(isl::PwAff)> &F) {
   isl_union_pw_aff_foreach_pw_aff(
       UPwAff.keep(),
       [](__isl_take isl_pw_aff *PwAff, void *User) -> isl_stat {
-        auto &F =
-            *static_cast<const std::function<void(IslPtr<isl_pw_aff>)> *>(User);
+        auto &F = *static_cast<const std::function<void(isl::PwAff)> *>(User);
         F(give(PwAff));
         return isl_stat_ok;
       },
       const_cast<void *>(static_cast<const void *>(&F)));
 }
 
-isl_stat polly::foreachEltWithBreak(
-    const IslPtr<isl_map> &Map,
-    const std::function<isl_stat(IslPtr<isl_basic_map>)> &F) {
+isl_stat
+polly::foreachEltWithBreak(const isl::Map &Map,
+                           const std::function<isl_stat(isl::BasicMap)> &F) {
   return isl_map_foreach_basic_map(
       Map.keep(),
       [](__isl_take isl_basic_map *BMap, void *User) -> isl_stat {
-        auto &F = *static_cast<
-            const std::function<isl_stat(IslPtr<isl_basic_map>)> *>(User);
+        auto &F =
+            *static_cast<const std::function<isl_stat(isl::BasicMap)> *>(User);
         return F(give(BMap));
       },
       const_cast<void *>(static_cast<const void *>(&F)));
 }
 
-isl_stat polly::foreachEltWithBreak(
-    const IslPtr<isl_union_map> &UMap,
-    const std::function<isl_stat(IslPtr<isl_map> Map)> &F) {
+isl_stat
+polly::foreachEltWithBreak(const isl::UnionMap &UMap,
+                           const std::function<isl_stat(isl::Map Map)> &F) {
   return isl_union_map_foreach_map(
       UMap.keep(),
       [](__isl_take isl_map *Map, void *User) -> isl_stat {
         auto &F =
-            *static_cast<const std::function<isl_stat(IslPtr<isl_map> Map)> *>(
-                User);
+            *static_cast<const std::function<isl_stat(isl::Map Map)> *>(User);
         return F(give(Map));
       },
       const_cast<void *>(static_cast<const void *>(&F)));
 }
 
 isl_stat polly::foreachPieceWithBreak(
-    const IslPtr<isl_pw_aff> &PwAff,
-    const std::function<isl_stat(IslPtr<isl_set>, IslPtr<isl_aff>)> &F) {
+    const isl::PwAff &PwAff,
+    const std::function<isl_stat(isl::Set, isl::Aff)> &F) {
   return isl_pw_aff_foreach_piece(
       PwAff.keep(),
       [](__isl_take isl_set *Domain, __isl_take isl_aff *Aff,
          void *User) -> isl_stat {
-        auto &F = *static_cast<
-            const std::function<isl_stat(IslPtr<isl_set>, IslPtr<isl_aff>)> *>(
+        auto &F =
+            *static_cast<const std::function<isl_stat(isl::Set, isl::Aff)> *>(
                 User);
         return F(give(Domain), give(Aff));
       },
       const_cast<void *>(static_cast<const void *>(&F)));
 }

lib/Support/ISLTools.cpp

 ///   = { [i0, i1] -> [i0, i1 - 1] }
 ///
 /// @param Space  The map space of the result. Must have equal number of in- and
 ///               out-dimensions.
 /// @param Pos    Position to shift.
 /// @param Amount Value added to the shifted dimension.
 ///
 /// @return An isl_multi_aff for the map with this shifted dimension.
-IslPtr<isl_multi_aff> makeShiftDimAff(IslPtr<isl_space> Space, int Pos,
-                                      int Amount) {
+isl::MultiAff makeShiftDimAff(isl::Space Space, int Pos, int Amount) {
   auto Identity = give(isl_multi_aff_identity(Space.take()));
   if (Amount == 0)
     return Identity;
   auto ShiftAff = give(isl_multi_aff_get_aff(Identity.keep(), Pos));
   ShiftAff = give(isl_aff_set_constant_si(ShiftAff.take(), Amount));
   return give(isl_multi_aff_set_aff(Identity.take(), Pos, ShiftAff.take()));
 }
 
 /// Construct a map that swaps two nested tuples.
 ///
 /// @param FromSpace1 { Space1[] }
 /// @param FromSpace2 { Space2[] }
 ///
 /// @return { [Space1[] -> Space2[]] -> [Space2[] -> Space1[]] }
-IslPtr<isl_basic_map> makeTupleSwapBasicMap(IslPtr<isl_space> FromSpace1,
-                                            IslPtr<isl_space> FromSpace2) {
+isl::BasicMap makeTupleSwapBasicMap(isl::Space FromSpace1,
+                                    isl::Space FromSpace2) {
   assert(isl_space_is_set(FromSpace1.keep()) != isl_bool_false);
   assert(isl_space_is_set(FromSpace2.keep()) != isl_bool_false);
 
   auto Dims1 = isl_space_dim(FromSpace1.keep(), isl_dim_set);
   auto Dims2 = isl_space_dim(FromSpace2.keep(), isl_dim_set);
   auto FromSpace = give(isl_space_wrap(isl_space_map_from_domain_and_range(
       FromSpace1.copy(), FromSpace2.copy())));
   auto ToSpace = give(isl_space_wrap(isl_space_map_from_domain_and_range(
isl::BasicMap makeTupleSwapBasicMap(isl::Space FromSpace1,
   for (auto i = Dims2 - Dims2; i < Dims2; i += 1) {
     Result = give(isl_basic_map_equate(Result.take(), isl_dim_in, Dims1 + i,
                                        isl_dim_out, i));
   }
 
   return Result;
 }
 
-/// Like makeTupleSwapBasicMap(IslPtr<isl_space>,IslPtr<isl_space>), but returns
+/// Like makeTupleSwapBasicMap(isl::Space,isl::Space), but returns
 /// an isl_map.
-IslPtr<isl_map> makeTupleSwapMap(IslPtr<isl_space> FromSpace1,
-                                 IslPtr<isl_space> FromSpace2) {
+isl::Map makeTupleSwapMap(isl::Space FromSpace1, isl::Space FromSpace2) {
   auto BMapResult =
       makeTupleSwapBasicMap(std::move(FromSpace1), std::move(FromSpace2));
   return give(isl_map_from_basic_map(BMapResult.take()));
 }
 } // anonymous namespace
 
-IslPtr<isl_map> polly::beforeScatter(IslPtr<isl_map> Map, bool Strict) {
+isl::Map polly::beforeScatter(isl::Map Map, bool Strict) {
   auto RangeSpace = give(isl_space_range(isl_map_get_space(Map.keep())));
   auto ScatterRel = give(Strict ? isl_map_lex_gt(RangeSpace.take())
                                 : isl_map_lex_ge(RangeSpace.take()));
   return give(isl_map_apply_range(Map.take(), ScatterRel.take()));
 }
 
-IslPtr<isl_union_map> polly::beforeScatter(IslPtr<isl_union_map> UMap,
-                                           bool Strict) {
+isl::UnionMap polly::beforeScatter(isl::UnionMap UMap, bool Strict) {
   auto Result = give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
-  foreachElt(UMap, [=, &Result](IslPtr<isl_map> Map) {
+  foreachElt(UMap, [=, &Result](isl::Map Map) {
     auto After = beforeScatter(Map, Strict);
     Result = give(isl_union_map_add_map(Result.take(), After.take()));
   });
   return Result;
 }
 
-IslPtr<isl_map> polly::afterScatter(IslPtr<isl_map> Map, bool Strict) {
+isl::Map polly::afterScatter(isl::Map Map, bool Strict) {
   auto RangeSpace = give(isl_space_range(isl_map_get_space(Map.keep())));
   auto ScatterRel = give(Strict ? isl_map_lex_lt(RangeSpace.take())
                                 : isl_map_lex_le(RangeSpace.take()));
   return give(isl_map_apply_range(Map.take(), ScatterRel.take()));
 }
 
-IslPtr<isl_union_map> polly::afterScatter(const IslPtr<isl_union_map> &UMap,
-                                          bool Strict) {
+isl::UnionMap polly::afterScatter(const isl::UnionMap &UMap, bool Strict) {
   auto Result = give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
-  foreachElt(UMap, [=, &Result](IslPtr<isl_map> Map) {
+  foreachElt(UMap, [=, &Result](isl::Map Map) {
     auto After = afterScatter(Map, Strict);
     Result = give(isl_union_map_add_map(Result.take(), After.take()));
   });
   return Result;
 }
 
-IslPtr<isl_map> polly::betweenScatter(IslPtr<isl_map> From, IslPtr<isl_map> To,
-                                      bool InclFrom, bool InclTo) {
+isl::Map polly::betweenScatter(isl::Map From, isl::Map To, bool InclFrom,
+                               bool InclTo) {
   auto AfterFrom = afterScatter(From, !InclFrom);
   auto BeforeTo = beforeScatter(To, !InclTo);
 
   return give(isl_map_intersect(AfterFrom.take(), BeforeTo.take()));
 }
 
-IslPtr<isl_union_map> polly::betweenScatter(IslPtr<isl_union_map> From,
-                                            IslPtr<isl_union_map> To,
-                                            bool InclFrom, bool InclTo) {
+isl::UnionMap polly::betweenScatter(isl::UnionMap From, isl::UnionMap To,
   auto AfterFrom = afterScatter(From, !InclFrom);
   auto BeforeTo = beforeScatter(To, !InclTo);
 
   return give(isl_union_map_intersect(AfterFrom.take(), BeforeTo.take()));
 }
 
-IslPtr<isl_map> polly::singleton(IslPtr<isl_union_map> UMap,
-                                 IslPtr<isl_space> ExpectedSpace) {
+isl::Map polly::singleton(isl::UnionMap UMap, isl::Space ExpectedSpace) {
   if (!UMap)
     return nullptr;
 
   if (isl_union_map_n_map(UMap.keep()) == 0)
     return give(isl_map_empty(ExpectedSpace.take()));
 
   auto Result = give(isl_map_from_union_map(UMap.take()));
   assert(!Result || isl_space_has_equal_tuples(
                         give(isl_map_get_space(Result.keep())).keep(),
                         ExpectedSpace.keep()) == isl_bool_true);
   return Result;
 }
 
-IslPtr<isl_set> polly::singleton(IslPtr<isl_union_set> USet,
-                                 IslPtr<isl_space> ExpectedSpace) {
+isl::Set polly::singleton(isl::UnionSet USet, isl::Space ExpectedSpace) {
   if (!USet)
     return nullptr;
 
   if (isl_union_set_n_set(USet.keep()) == 0)
     return give(isl_set_empty(ExpectedSpace.copy()));
 
   auto Result = give(isl_set_from_union_set(USet.take()));
   assert(!Result || isl_space_has_equal_tuples(
                         give(isl_set_get_space(Result.keep())).keep(),
                         ExpectedSpace.keep()) == isl_bool_true);
   return Result;
 }
 
-unsigned polly::getNumScatterDims(const IslPtr<isl_union_map> &Schedule) {
+unsigned polly::getNumScatterDims(const isl::UnionMap &Schedule) {
   unsigned Dims = 0;
-  foreachElt(Schedule, [&Dims](IslPtr<isl_map> Map) {
+  foreachElt(Schedule, [&Dims](isl::Map Map) {
     Dims = std::max(Dims, isl_map_dim(Map.keep(), isl_dim_out));
   });
   return Dims;
 }
 
-IslPtr<isl_space>
-polly::getScatterSpace(const IslPtr<isl_union_map> &Schedule) {
+isl::Space polly::getScatterSpace(const isl::UnionMap &Schedule) {
   if (!Schedule)
     return nullptr;
   auto Dims = getNumScatterDims(Schedule);
   auto ScatterSpace =
       give(isl_space_set_from_params(isl_union_map_get_space(Schedule.keep())));
   return give(isl_space_add_dims(ScatterSpace.take(), isl_dim_set, Dims));
 }
 
-IslPtr<isl_union_map> polly::makeIdentityMap(const IslPtr<isl_union_set> &USet,
-                                             bool RestrictDomain) {
+isl::UnionMap polly::makeIdentityMap(const isl::UnionSet &USet,
   auto Result = give(isl_union_map_empty(isl_union_set_get_space(USet.keep())));
-  foreachElt(USet, [=, &Result](IslPtr<isl_set> Set) {
+  foreachElt(USet, [=, &Result](isl::Set Set) {
     auto IdentityMap = give(isl_map_identity(
         isl_space_map_from_set(isl_set_get_space(Set.keep()))));
     if (RestrictDomain)
       IdentityMap =
           give(isl_map_intersect_domain(IdentityMap.take(), Set.take()));
     Result = give(isl_union_map_add_map(Result.take(), IdentityMap.take()));
   });
   return Result;
 }
 
-IslPtr<isl_map> polly::reverseDomain(IslPtr<isl_map> Map) {
+isl::Map polly::reverseDomain(isl::Map Map) {
   auto DomSpace =
       give(isl_space_unwrap(isl_space_domain(isl_map_get_space(Map.keep()))));
   auto Space1 = give(isl_space_domain(DomSpace.copy()));
   auto Space2 = give(isl_space_range(DomSpace.take()));
   auto Swap = makeTupleSwapMap(std::move(Space1), std::move(Space2));
   return give(isl_map_apply_domain(Map.take(), Swap.take()));
 }
 
-IslPtr<isl_union_map> polly::reverseDomain(const IslPtr<isl_union_map> &UMap) {
+isl::UnionMap polly::reverseDomain(const isl::UnionMap &UMap) {
   auto Result = give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
-  foreachElt(UMap, [=, &Result](IslPtr<isl_map> Map) {
+  foreachElt(UMap, [=, &Result](isl::Map Map) {
     auto Reversed = reverseDomain(std::move(Map));
     Result = give(isl_union_map_add_map(Result.take(), Reversed.take()));
   });
   return Result;
 }
 
-IslPtr<isl_set> polly::shiftDim(IslPtr<isl_set> Set, int Pos, int Amount) {
+isl::Set polly::shiftDim(isl::Set Set, int Pos, int Amount) {
   int NumDims = isl_set_dim(Set.keep(), isl_dim_set);
   if (Pos < 0)
     Pos = NumDims + Pos;
   assert(Pos < NumDims && "Dimension index must be in range");
   auto Space = give(isl_set_get_space(Set.keep()));
   Space = give(isl_space_map_from_domain_and_range(Space.copy(), Space.copy()));
   auto Translator = makeShiftDimAff(std::move(Space), Pos, Amount);
   auto TranslatorMap = give(isl_map_from_multi_aff(Translator.take()));
   return give(isl_set_apply(Set.take(), TranslatorMap.take()));
 }
 
-IslPtr<isl_union_set> polly::shiftDim(IslPtr<isl_union_set> USet, int Pos,
-                                      int Amount) {
+isl::UnionSet polly::shiftDim(isl::UnionSet USet, int Pos, int Amount) {
   auto Result = give(isl_union_set_empty(isl_union_set_get_space(USet.keep())));
-  foreachElt(USet, [=, &Result](IslPtr<isl_set> Set) {
+  foreachElt(USet, [=, &Result](isl::Set Set) {
     auto Shifted = shiftDim(Set, Pos, Amount);
     Result = give(isl_union_set_add_set(Result.take(), Shifted.take()));
   });
   return Result;
 }
 
-void polly::simplify(IslPtr<isl_set> &Set) {
+void polly::simplify(isl::Set &Set) {
   Set = give(isl_set_compute_divs(Set.take()));
   Set = give(isl_set_detect_equalities(Set.take()));
   Set = give(isl_set_coalesce(Set.take()));
 }
 
-void polly::simplify(IslPtr<isl_union_set> &USet) {
+void polly::simplify(isl::UnionSet &USet) {
   USet = give(isl_union_set_compute_divs(USet.take()));
   USet = give(isl_union_set_detect_equalities(USet.take()));
   USet = give(isl_union_set_coalesce(USet.take()));
 }
 
-void polly::simplify(IslPtr<isl_map> &Map) {
+void polly::simplify(isl::Map &Map) {
   Map = give(isl_map_compute_divs(Map.take()));
   Map = give(isl_map_detect_equalities(Map.take()));
   Map = give(isl_map_coalesce(Map.take()));
 }
 
-void polly::simplify(IslPtr<isl_union_map> &UMap) {
+void polly::simplify(isl::UnionMap &UMap) {
   UMap = give(isl_union_map_compute_divs(UMap.take()));
   UMap = give(isl_union_map_detect_equalities(UMap.take()));
   UMap = give(isl_union_map_coalesce(UMap.take()));
 }
 
-IslPtr<isl_union_map>
-polly::computeReachingWrite(IslPtr<isl_union_map> Schedule,
-                            IslPtr<isl_union_map> Writes, bool Reverse,
+isl::UnionMap polly::computeReachingWrite(isl::UnionMap Schedule,
+                                          isl::UnionMap Writes, bool Reverse,
                                           bool InclPrevDef, bool InclNextDef) {
 
   // { Scatter[] }
   auto ScatterSpace = getScatterSpace(Schedule);
 
   // { ScatterRead[] -> ScatterWrite[] }
-  IslPtr<isl_map> Relation;
+  isl::Map Relation;
   if (Reverse)
     Relation = give(InclPrevDef ? isl_map_lex_lt(ScatterSpace.take())
                                 : isl_map_lex_le(ScatterSpace.take()));
   else
     Relation = give(InclNextDef ? isl_map_lex_gt(ScatterSpace.take())
                                 : isl_map_lex_ge(ScatterSpace.take()));
 
   // { ScatterWrite[] -> [ScatterRead[] -> ScatterWrite[]] }
isl::UnionMap polly::computeReachingWrite(isl::UnionMap Schedule,
 
   // { [Element[] -> ScatterRead[]] -> Domain[] }
   auto ReachableWriteDomain = give(isl_union_map_apply_range(
       ReachableWrites.take(), isl_union_map_reverse(Schedule.take())));
 
   return ReachableWriteDomain;
 }
 
-IslPtr<isl_union_map> polly::computeArrayUnused(IslPtr<isl_union_map> Schedule,
-                                                IslPtr<isl_union_map> Writes,
-                                                IslPtr<isl_union_map> Reads,
-                                                bool ReadEltInSameInst,
-                                                bool IncludeLastRead,
-                                                bool IncludeWrite) {
+isl::UnionMap
+polly::computeArrayUnused(isl::UnionMap Schedule, isl::UnionMap Writes,
+                          isl::UnionMap Reads, bool ReadEltInSameInst,
+                          bool IncludeLastRead, bool IncludeWrite) {
   // { Element[] -> Scatter[] }
   auto ReadActions =
       give(isl_union_map_apply_domain(Schedule.copy(), Reads.take()));
   auto WriteActions =
       give(isl_union_map_apply_domain(Schedule.copy(), Writes.copy()));
 
   // { [Element[] -> Scatter[] }
   auto AfterReads = afterScatter(ReadActions, ReadEltInSameInst);
polly::computeArrayUnused(isl::UnionMap Schedule, isl::UnionMap Writes,
   auto BetweenLastReadOverwrite = betweenScatter(
       LastOverwrittenRead, EltDomWrites, IncludeLastRead, IncludeWrite);
 
   return give(isl_union_map_union(
       BeforeWritesBeforeAnyReads.take(),
       isl_union_map_domain_factor_domain(BetweenLastReadOverwrite.take())));
 }
 
-IslPtr<isl_union_set> polly::convertZoneToTimepoints(IslPtr<isl_union_set> Zone,
-                                                     bool InclStart,
-                                                     bool InclEnd) {
+isl::UnionSet polly::convertZoneToTimepoints(isl::UnionSet Zone, bool InclStart,
   if (!InclStart && InclEnd)
     return Zone;
 
   auto ShiftedZone = shiftDim(Zone, -1, -1);
   if (InclStart && !InclEnd)
     return ShiftedZone;
   else if (!InclStart && !InclEnd)
     return give(isl_union_set_intersect(Zone.take(), ShiftedZone.take()));
 
   assert(InclStart && InclEnd);
   return give(isl_union_set_union(Zone.take(), ShiftedZone.take()));
 }

lib/Transform/DeLICM.cpp

public:
   ArrayRef<MemoryAccess *> getPHIIncomings(const ScopArrayInfo *SAI) const {
     auto It = PHIIncomingAccs.find(SAI);
     if (It == PHIIncomingAccs.end())
       return {};
     return It->second;
   }
 };
 
-IslPtr<isl_union_map> computeReachingDefinition(IslPtr<isl_union_map> Schedule,
-                                                IslPtr<isl_union_map> Writes,
-                                                bool InclDef, bool InclRedef) {
+isl::UnionMap computeReachingDefinition(isl::UnionMap Schedule,
+                                        isl::UnionMap Writes, bool InclDef,
+                                        bool InclRedef) {
   return computeReachingWrite(Schedule, Writes, false, InclDef, InclRedef);
 }
 
-IslPtr<isl_union_map> computeReachingOverwrite(IslPtr<isl_union_map> Schedule,
-                                               IslPtr<isl_union_map> Writes,
-                                               bool InclPrevWrite,
-                                               bool InclOverwrite) {
+isl::UnionMap computeReachingOverwrite(isl::UnionMap Schedule,
+                                       isl::UnionMap Writes, bool InclPrevWrite,
   return computeReachingWrite(Schedule, Writes, true, InclPrevWrite,
                               InclOverwrite);
 }
 
 /// Compute the next overwrite for a scalar.
 ///
 /// @param Schedule      { DomainWrite[] -> Scatter[] }
 ///                      Schedule of (at least) all writes. Instances not in @p
 ///                      Writes are ignored.
 /// @param Writes        { DomainWrite[] }
 ///                      The element instances that write to the scalar.
 /// @param InclPrevWrite Whether to extend the timepoints to include
 ///                      the timepoint where the previous write happens.
 /// @param InclOverwrite Whether the reaching overwrite includes the timepoint
 ///                      of the overwrite itself.
 ///
 /// @return { Scatter[] -> DomainDef[] }
-IslPtr<isl_union_map>
-computeScalarReachingOverwrite(IslPtr<isl_union_map> Schedule,
-                               IslPtr<isl_union_set> Writes, bool InclPrevWrite,
+isl::UnionMap computeScalarReachingOverwrite(isl::UnionMap Schedule,
+                                             isl::UnionSet Writes,
+                                             bool InclPrevWrite,
                                              bool InclOverwrite) {
 
   // { DomainWrite[] }
   auto WritesMap = give(isl_union_map_from_domain(Writes.take()));
 
   // { [Element[] -> Scatter[]] -> DomainWrite[] }
   auto Result = computeReachingOverwrite(
       std::move(Schedule), std::move(WritesMap), InclPrevWrite, InclOverwrite);
 
   return give(isl_union_map_domain_factor_range(Result.take()));
 }
 
 /// Overload of computeScalarReachingOverwrite, with only one writing statement.
 /// Consequently, the result consists of only one map space.
 ///
 /// @param Schedule      { DomainWrite[] -> Scatter[] }
 /// @param Writes        { DomainWrite[] }
 /// @param InclPrevWrite Include the previous write to result.
 /// @param InclOverwrite Include the overwrite to the result.
 ///
 /// @return { Scatter[] -> DomainWrite[] }
-IslPtr<isl_map> computeScalarReachingOverwrite(IslPtr<isl_union_map> Schedule,
-                                               IslPtr<isl_set> Writes,
-                                               bool InclPrevWrite,
-                                               bool InclOverwrite) {
+isl::Map computeScalarReachingOverwrite(isl::UnionMap Schedule, isl::Set Writes,
   auto ScatterSpace = getScatterSpace(Schedule);
   auto DomSpace = give(isl_set_get_space(Writes.keep()));
 
   auto ReachOverwrite = computeScalarReachingOverwrite(
       Schedule, give(isl_union_set_from_set(Writes.take())), InclPrevWrite,
       InclOverwrite);
 
   auto ResultSpace = give(isl_space_map_from_domain_and_range(
       ScatterSpace.take(), DomSpace.take()));
   return singleton(std::move(ReachOverwrite), ResultSpace);
 }
 
 /// Compute the reaching definition of a scalar.
 ///
 /// Compared to computeReachingDefinition, there is just one element which is
 /// accessed and therefore only a set if instances that accesses that element is
 /// required.
 ///
 /// @param Schedule  { DomainWrite[] -> Scatter[] }
 /// @param Writes    { DomainWrite[] }
 /// @param InclDef   Include the timepoint of the definition to the result.
 /// @param InclRedef Include the timepoint of the overwrite into the result.
 ///
 /// @return { Scatter[] -> DomainWrite[] }
-IslPtr<isl_union_map>
-computeScalarReachingDefinition(IslPtr<isl_union_map> Schedule,
-                                IslPtr<isl_union_set> Writes, bool InclDef,
-                                bool InclRedef) {
+isl::UnionMap computeScalarReachingDefinition(isl::UnionMap Schedule,
+                                              isl::UnionSet Writes,
+                                              bool InclDef, bool InclRedef) {
 
   // { DomainWrite[] -> Element[] }
   auto Defs = give(isl_union_map_from_domain(Writes.take()));
 
   // { [Element[] -> Scatter[]] -> DomainWrite[] }
   auto ReachDefs =
       computeReachingDefinition(Schedule, Defs, InclDef, InclRedef);
 
   // { Scatter[] -> DomainWrite[] }
   return give(isl_union_set_unwrap(
       isl_union_map_range(isl_union_map_curry(ReachDefs.take()))));
 }
 
 /// Compute the reaching definition of a scalar.
 ///
 /// This overload accepts only a single writing statement as an isl_map,
 /// consequently the result also is only a single isl_map.
 ///
 /// @param Schedule  { DomainWrite[] -> Scatter[] }
 /// @param Writes    { DomainWrite[] }
 /// @param InclDef   Include the timepoint of the definition to the result.
 /// @param InclRedef Include the timepoint of the overwrite into the result.
 ///
 /// @return { Scatter[] -> DomainWrite[] }
-IslPtr<isl_map> computeScalarReachingDefinition( // { Domain[] -> Zone[] }
-    IslPtr<isl_union_map> Schedule, IslPtr<isl_set> Writes, bool InclDef,
-    bool InclRedef) {
+isl::Map computeScalarReachingDefinition( // { Domain[] -> Zone[] }
+    isl::UnionMap Schedule, isl::Set Writes, bool InclDef, bool InclRedef) {
   auto DomainSpace = give(isl_set_get_space(Writes.keep()));
   auto ScatterSpace = getScatterSpace(Schedule);
 
   //  { Scatter[] -> DomainWrite[] }
   auto UMap = computeScalarReachingDefinition(
       Schedule, give(isl_union_set_from_set(Writes.take())), InclDef,
       InclRedef);
 
private:
   /// values can differ depending on how the elements are interpreted.
   /// Assuming a value X is written at timestep [0] and read at timestep [1]
   /// without being used at any later point, then the value is alive in the
   /// interval ]0,1[. This interval cannot be represented by an integer set, as
   /// it does not contain any integer point. Zones allow us to represent this
   /// interval and can be converted to sets of timepoints when needed (e.g., in
   /// isConflicting when comparing to the write sets).
   /// @see convertZoneToTimepoints and this file's comment for more details.
-  IslPtr<isl_union_set> Occupied;
+  isl::UnionSet Occupied;
 
   /// { [Element[] -> Zone[]] }
   /// Set of array elements when they are not alive, i.e. their memory can be
   /// used for other purposed. Can contain a nullptr; in this case the set is
   /// implicitly defined as the complement of #Occupied.
-  IslPtr<isl_union_set> Unused;
+  isl::UnionSet Unused;
 
   /// { [Element[] -> Scatter[]] }
   /// The write actions currently in the scop or that would be added when
   /// mapping a scalar.
-  IslPtr<isl_union_set> Written;
+  isl::UnionSet Written;
 
   /// Check whether this Knowledge object is well-formed.
   void checkConsistency() const {
 #ifndef NDEBUG
     // Default-initialized object
     if (!Occupied && !Unused && !Written)
       return;
 
#endif
   }
 
 public:
   /// Initialize a nullptr-Knowledge. This is only provided for convenience; do
   /// not use such an object.
   Knowledge() {}
 
   /// Create a new object with the given members.
-  Knowledge(IslPtr<isl_union_set> Occupied, IslPtr<isl_union_set> Unused,
-            IslPtr<isl_union_set> Written)
+  Knowledge(isl::UnionSet Occupied, isl::UnionSet Unused, isl::UnionSet Written)
       : Occupied(std::move(Occupied)), Unused(std::move(Unused)),
         Written(std::move(Written)) {
     checkConsistency();
   }
 
   /// Alternative constructor taking isl_sets instead isl_union_sets.
-  Knowledge(IslPtr<isl_set> Occupied, IslPtr<isl_set> Unused,
-            IslPtr<isl_set> Written)
+  Knowledge(isl::Set Occupied, isl::Set Unused, isl::Set Written)
       : Knowledge(give(isl_union_set_from_set(Occupied.take())),
                   give(isl_union_set_from_set(Unused.take())),
                   give(isl_union_set_from_set(Written.take()))) {}
 
   /// Return whether this object was not default-constructed.
   bool isUsable() const { return (Occupied || Unused) && Written; }
 
   /// Print the content of this object to @p OS.
protected:
   /// This must be declared before any other member that holds an isl object.
   /// This guarantees that the shared_ptr and its isl_ctx is destructed last,
   /// after all other members free'd the isl objects they were holding.
   std::shared_ptr<isl_ctx> IslCtx;
 
   /// Cached reaching definitions for each ScopStmt.
   ///
   /// Use getScalarReachingDefinition() to get its contents.
-  DenseMap<ScopStmt *, IslPtr<isl_map>> ScalarReachDefZone;
+  DenseMap<ScopStmt *, isl::Map> ScalarReachDefZone;
 
   /// The analyzed Scop.
   Scop *S;
 
   /// Parameter space that does not need realignment.
-  IslPtr<isl_space> ParamSpace;
+  isl::Space ParamSpace;
 
   /// Space the schedule maps to.
-  IslPtr<isl_space> ScatterSpace;
+  isl::Space ScatterSpace;
 
   /// Cached version of the schedule and domains.
-  IslPtr<isl_union_map> Schedule;
+  isl::UnionMap Schedule;
 
   /// Set of all referenced elements.
   /// { Element[] -> Element[] }
-  IslPtr<isl_union_set> AllElements;
+  isl::UnionSet AllElements;
 
   /// Combined access relations of all MemoryKind::Array READ accesses.
   /// { DomainRead[] -> Element[] }
-  IslPtr<isl_union_map> AllReads;
+  isl::UnionMap AllReads;
 
   /// Combined access relations of all MemoryKind::Array, MAY_WRITE accesses.
   /// { DomainMayWrite[] -> Element[] }
-  IslPtr<isl_union_map> AllMayWrites;
+  isl::UnionMap AllMayWrites;
 
   /// Combined access relations of all MemoryKind::Array, MUST_WRITE accesses.
   /// { DomainMustWrite[] -> Element[] }
-  IslPtr<isl_union_map> AllMustWrites;
+  isl::UnionMap AllMustWrites;
 
   /// Prepare the object before computing the zones of @p S.
   ZoneAlgorithm(Scop *S)
       : IslCtx(S->getSharedIslCtx()), S(S), Schedule(give(S->getSchedule())) {
 
     auto Domains = give(S->getDomains());
 
     Schedule =
if (MA->isMustWrite())
           give(isl_union_map_add_map(AllMustWrites.take(), AccRel.copy()));
 
     if (MA->isMayWrite())
       AllMayWrites =
           give(isl_union_map_add_map(AllMayWrites.take(), AccRel.copy()));
   }
 
 protected:
-  IslPtr<isl_union_set> makeEmptyUnionSet() {
+  isl::UnionSet makeEmptyUnionSet() {
     return give(isl_union_set_empty(ParamSpace.copy()));
   }
 
-  IslPtr<isl_union_map> makeEmptyUnionMap() {
+  isl::UnionMap makeEmptyUnionMap() {
     return give(isl_union_map_empty(ParamSpace.copy()));
   }
 
   /// Check whether @p S can be accurately analyzed by zones.
   bool isCompatibleScop() {
     for (auto &Stmt : *S) {
       if (!isCompatibleStmt(&Stmt))
         return false;
     }
     return true;
   }
 
   /// Get the schedule for @p Stmt.
   ///
   /// The domain of the result is as narrow as possible.
-  IslPtr<isl_map> getScatterFor(ScopStmt *Stmt) const {
+  isl::Map getScatterFor(ScopStmt *Stmt) const {
     auto ResultSpace = give(isl_space_map_from_domain_and_range(
         Stmt->getDomainSpace(), ScatterSpace.copy()));
     return give(isl_union_map_extract_map(Schedule.keep(), ResultSpace.take()));
   }
 
   /// Get the schedule of @p MA's parent statement.
-  IslPtr<isl_map> getScatterFor(MemoryAccess *MA) const {
+  isl::Map getScatterFor(MemoryAccess *MA) const {
     return getScatterFor(MA->getStatement());
   }
 
   /// Get the schedule for the statement instances of @p Domain.
-  IslPtr<isl_union_map> getScatterFor(IslPtr<isl_union_set> Domain) const {
+  isl::UnionMap getScatterFor(isl::UnionSet Domain) const {
     return give(isl_union_map_intersect_domain(Schedule.copy(), Domain.take()));
   }
 
   /// Get the schedule for the statement instances of @p Domain.
-  IslPtr<isl_map> getScatterFor(IslPtr<isl_set> Domain) const {
+  isl::Map getScatterFor(isl::Set Domain) const {
     auto ResultSpace = give(isl_space_map_from_domain_and_range(
         isl_set_get_space(Domain.keep()), ScatterSpace.copy()));
     auto UDomain = give(isl_union_set_from_set(Domain.copy()));
     auto UResult = getScatterFor(std::move(UDomain));
     auto Result = singleton(std::move(UResult), std::move(ResultSpace));
     assert(isl_set_is_equal(give(isl_map_domain(Result.copy())).keep(),
                             Domain.keep()) == isl_bool_true);
     return Result;
   }
 
   /// Get the domain of @p Stmt.
-  IslPtr<isl_set> getDomainFor(ScopStmt *Stmt) const {
+  isl::Set getDomainFor(ScopStmt *Stmt) const {
     return give(Stmt->getDomain());
   }
 
   /// Get the domain @p MA's parent statement.
-  IslPtr<isl_set> getDomainFor(MemoryAccess *MA) const {
+  isl::Set getDomainFor(MemoryAccess *MA) const {
     return getDomainFor(MA->getStatement());
   }
 
   /// Get the access relation of @p MA.
   ///
   /// The domain of the result is as narrow as possible.
-  IslPtr<isl_map> getAccessRelationFor(MemoryAccess *MA) const {
+  isl::Map getAccessRelationFor(MemoryAccess *MA) const {
     auto Domain = getDomainFor(MA);
     auto AccRel = give(MA->getLatestAccessRelation());
     return give(isl_map_intersect_domain(AccRel.take(), Domain.take()));
   }
 
   /// Get the reaching definition of a scalar defined in @p Stmt.
   ///
   /// Note that this does not depend on the llvm::Instruction, only on the
   /// statement it is defined in. Therefore the same computation can be reused.
   ///
   /// @param Stmt The statement in which a scalar is defined.
   ///
   /// @return { Scatter[] -> DomainDef[] }
-  IslPtr<isl_map> getScalarReachingDefinition(ScopStmt *Stmt) {
+  isl::Map getScalarReachingDefinition(ScopStmt *Stmt) {
     auto &Result = ScalarReachDefZone[Stmt];
     if (Result)
       return Result;
 
     auto Domain = getDomainFor(Stmt);
     Result = computeScalarReachingDefinition(Schedule, Domain, false, true);
     simplify(Result);
 
void computeCommon() {
     }
 
     // { DomainWrite[] -> Element[] }
     auto AllWrites =
         give(isl_union_map_union(AllMustWrites.copy(), AllMayWrites.copy()));
 
     // { Element[] }
     AllElements = makeEmptyUnionSet();
-    foreachElt(AllWrites, [this](IslPtr<isl_map> Write) {
+    foreachElt(AllWrites, [this](isl::Map Write) {
       auto Space = give(isl_map_get_space(Write.keep()));
       auto EltSpace = give(isl_space_range(Space.take()));
       auto EltUniv = give(isl_set_universe(EltSpace.take()));
       AllElements =
           give(isl_union_set_add_set(AllElements.take(), EltUniv.take()));
     });
   }
 
private:
   /// Compute the uses of a MemoryKind::Value and its lifetime (from its
   /// definition to the last use).
   ///
   /// @param SAI The ScopArrayInfo representing the value's storage.
   ///
   /// @return { DomainDef[] -> DomainUse[] }, { DomainDef[] -> Zone[] }
   ///         First element is the set of uses for each definition.
   ///         The second is the lifetime of each definition.
-  std::tuple<IslPtr<isl_union_map>, IslPtr<isl_map>>
+  std::tuple<isl::UnionMap, isl::Map>
   computeValueUses(const ScopArrayInfo *SAI) {
     assert(SAI->isValueKind());
 
     // { DomainRead[] }
     auto Reads = makeEmptyUnionSet();
 
     // Find all uses.
     for (auto *MA : DefUse.getValueUses(SAI))
private:
   /// executed before.
   ///
   /// For each PHI instance we can directly determine which was the incoming
   /// block, and hence derive which value the PHI has.
   ///
   /// @param SAI The ScopArrayInfo representing the PHI's storage.
   ///
   /// @return { DomainPHIRead[] -> DomainPHIWrite[] }
-  IslPtr<isl_union_map> computePerPHI(const ScopArrayInfo *SAI) {
+  isl::UnionMap computePerPHI(const ScopArrayInfo *SAI) {
     assert(SAI->isPHIKind());
 
     // { DomainPHIWrite[] -> Scatter[] }
     auto PHIWriteScatter = makeEmptyUnionMap();
 
     // Collect all incoming block timepoint.
     for (auto *MA : DefUse.getPHIIncomings(SAI)) {
       auto Scatter = getScatterFor(MA);
private:
 
   /// Try to map a MemoryKind::Value to a given array element.
   ///
   /// @param SAI       Representation of the scalar's memory to map.
   /// @param TargetElt { Scatter[] -> Element[] }
   ///                  Suggestion where to map a scalar to when at a timepoint.
   ///
   /// @return true if the scalar was successfully mapped.
-  bool tryMapValue(const ScopArrayInfo *SAI, IslPtr<isl_map> TargetElt) {
+  bool tryMapValue(const ScopArrayInfo *SAI, isl::Map TargetElt) {
     assert(SAI->isValueKind());
 
     auto *DefMA = DefUse.getValueDef(SAI);
     assert(DefMA->isValueKind());
     assert(DefMA->isMustWrite());
 
     // Stop if the scalar has already been mapped.
     if (!DefMA->getLatestScopArrayInfo()->isValueKind())
bool tryMapValue(const ScopArrayInfo *SAI, isl::Map TargetElt) {
     auto MappedDomain = give(isl_map_domain(DefTarget.copy()));
     if (!isl_set_is_subset(OrigDomain.keep(), MappedDomain.keep())) {
       DEBUG(dbgs()
             << "    Reject because mapping does not encompass all instances\n");
       return false;
     }
 
     // { DomainDef[] -> Zone[] }
-    IslPtr<isl_map> Lifetime;
+    isl::Map Lifetime;
 
     // { DomainDef[] -> DomainUse[] }
-    IslPtr<isl_union_map> DefUses;
+    isl::UnionMap DefUses;
 
     std::tie(DefUses, Lifetime) = computeValueUses(SAI);
     DEBUG(dbgs() << "    Lifetime: " << Lifetime << '\n');
 
     /// { [Element[] -> Zone[]] }
     auto EltZone = give(
         isl_map_wrap(isl_map_apply_domain(Lifetime.copy(), DefTarget.copy())));
     simplify(EltZone);
private:
   /// @param DefTarget { DomainDef[] -> Element[] }
   ///                  The array element to map the scalar to.
   /// @param UseTarget { DomainUse[] -> Element[] }
   ///                  The array elements the uses are mapped to.
   /// @param Lifetime  { DomainDef[] -> Zone[] }
   ///                  The lifetime of each llvm::Value definition for
   ///                  reporting.
   /// @param Proposed  Mapping constraints for reporting.
-  void mapValue(const ScopArrayInfo *SAI, IslPtr<isl_map> DefTarget,
-                IslPtr<isl_union_map> UseTarget, IslPtr<isl_map> Lifetime,
+  void mapValue(const ScopArrayInfo *SAI, isl::Map DefTarget,
+                isl::UnionMap UseTarget, isl::Map Lifetime,
                 Knowledge Proposed) {
     // Redirect the read accesses.
     for (auto *MA : DefUse.getValueUses(SAI)) {
       // { DomainUse[] }
       auto Domain = getDomainFor(MA);
 
       // { DomainUse[] -> Element[] }
       auto NewAccRel = give(isl_union_map_intersect_domain(
private:
   /// Try to map a MemoryKind::PHI scalar to a given array element.
   ///
   /// @param SAI       Representation of the scalar's memory to map.
   /// @param TargetElt { Scatter[] -> Element[] }
   ///                  Suggestion where to map the scalar to when at a
   ///                  timepoint.
   ///
   /// @return true if the PHI scalar has been mapped.
-  bool tryMapPHI(const ScopArrayInfo *SAI, IslPtr<isl_map> TargetElt) {
+  bool tryMapPHI(const ScopArrayInfo *SAI, isl::Map TargetElt) {
     auto *PHIRead = DefUse.getPHIRead(SAI);
     assert(PHIRead->isPHIKind());
     assert(PHIRead->isRead());
 
     // Skip if already been mapped.
     if (!PHIRead->getLatestScopArrayInfo()->isPHIKind())
       return false;
 
private:
   ///                    map.
   /// @param ReadTarget  { DomainRead[] -> Element[] }
   ///                    The array element to map the scalar to.
   /// @param WriteTarget { DomainWrite[] -> Element[] }
   ///                    New access target for each PHI incoming write.
   /// @param Lifetime    { DomainRead[] -> Zone[] }
   ///                    The lifetime of each PHI for reporting.
   /// @param Proposed    Mapping constraints for reporting.
-  void mapPHI(const ScopArrayInfo *SAI, IslPtr<isl_map> ReadTarget,
-              IslPtr<isl_union_map> WriteTarget, IslPtr<isl_map> Lifetime,
+  void mapPHI(const ScopArrayInfo *SAI, isl::Map ReadTarget,
+              isl::UnionMap WriteTarget, isl::Map Lifetime,
               Knowledge Proposed) {
     // Redirect the PHI incoming writes.
     for (auto *MA : DefUse.getPHIIncomings(SAI)) {
       // { DomainWrite[] }
       auto Domain = getDomainFor(MA);
 
       // { DomainWrite[] -> Element[] }
       auto NewAccRel = give(isl_union_map_intersect_domain(
bool collapseScalarsToStore(MemoryAccess *TargetStoreMA) {
     if (AnyMapped)
       TargetsMapped++;
     return AnyMapped;
   }
 
   /// Compute when an array element is unused.
   ///
   /// @return { [Element[] -> Zone[]] }
-  IslPtr<isl_union_set> computeLifetime() const {
+  isl::UnionSet computeLifetime() const {
     // { Element[] -> Zone[] }
     auto ArrayUnused = computeArrayUnused(Schedule, AllMustWrites, AllReads,
                                           false, false, true);
 
     auto Result = give(isl_union_map_wrap(ArrayUnused.copy()));
 
     simplify(Result);
     return Result;
   }
 
   /// Determine when an array element is written to.
   ///
   /// @return { [Element[] -> Scatter[]] }
-  IslPtr<isl_union_set> computeWritten() const {
+  isl::UnionSet computeWritten() const {
     // { WriteDomain[] -> Element[] }
     auto AllWrites =
         give(isl_union_map_union(AllMustWrites.copy(), AllMayWrites.copy()));
 
     // { Scatter[] -> Element[] }
     auto WriteTimepoints =
         give(isl_union_map_apply_domain(AllWrites.copy(), Schedule.copy()));
 
public:
   bool computeZone() {
     // Check that nothing strange occurs.
     if (!isCompatibleScop()) {
       DeLICMIncompatible++;
       return false;
     }
 
     DefUse.compute(S);
-    IslPtr<isl_union_set> EltUnused, EltWritten;
+    isl::UnionSet EltUnused, EltWritten;
 
     {
       IslMaxOperationsGuard MaxOpGuard(IslCtx.get(), DelicmMaxOps);
 
       computeCommon();
 
       EltUnused = computeLifetime();
       EltWritten = computeWritten();

 Pass *polly::createDeLICMPass() { return new DeLICM(); }
 
 INITIALIZE_PASS_BEGIN(DeLICM, "polly-delicm", "Polly - DeLICM/DePRE", false,
                       false)
 INITIALIZE_PASS_DEPENDENCY(ScopInfoWrapperPass)
 INITIALIZE_PASS_END(DeLICM, "polly-delicm", "Polly - DeLICM/DePRE", false,
                     false)
 
-bool polly::isConflicting(IslPtr<isl_union_set> ExistingOccupied,
-                          IslPtr<isl_union_set> ExistingUnused,
-                          IslPtr<isl_union_set> ExistingWrites,
-                          IslPtr<isl_union_set> ProposedOccupied,
-                          IslPtr<isl_union_set> ProposedUnused,
-                          IslPtr<isl_union_set> ProposedWrites,
-                          llvm::raw_ostream *OS, unsigned Indent) {
+bool polly::isConflicting(isl::UnionSet ExistingOccupied,
+                          isl::UnionSet ExistingUnused,
+                          isl::UnionSet ExistingWrites,
+                          isl::UnionSet ProposedOccupied,
+                          isl::UnionSet ProposedUnused,
+                          isl::UnionSet ProposedWrites, llvm::raw_ostream *OS,
+                          unsigned Indent) {
   Knowledge Existing(std::move(ExistingOccupied), std::move(ExistingUnused),
                      std::move(ExistingWrites));
   Knowledge Proposed(std::move(ProposedOccupied), std::move(ProposedUnused),
                      std::move(ProposedWrites));
 
   return Knowledge::isConflicting(Existing, Proposed, OS, Indent);
 }

lib/Transform/FlattenAlgo.cpp

 using namespace polly;
 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(IslPtr<isl_set> Set, unsigned dim) {
+bool isDimBoundedByConstant(isl::Set Set, unsigned dim) {
   auto ParamDims = isl_set_dim(Set.keep(), isl_dim_param);
   Set = give(isl_set_project_out(Set.take(), isl_dim_param, 0, ParamDims));
   Set = give(isl_set_project_out(Set.take(), isl_dim_set, 0, dim));
   auto SetDims = isl_set_dim(Set.keep(), isl_dim_set);
   Set = give(isl_set_project_out(Set.take(), isl_dim_set, 1, SetDims - 1));
   return isl_set_is_bounded(Set.keep());
 }
 
 /// 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(IslPtr<isl_set> Set, unsigned dim) {
+bool isDimBoundedByParameter(isl::Set Set, unsigned dim) {
   Set = give(isl_set_project_out(Set.take(), isl_dim_set, 0, dim));
   auto SetDims = isl_set_dim(Set.keep(), isl_dim_set);
   Set = give(isl_set_project_out(Set.take(), isl_dim_set, 1, SetDims - 1));
   return isl_set_is_bounded(Set.keep());
 }
 
 /// Whether BMap's first out-dimension is not a constant.
-bool isVariableDim(const IslPtr<isl_basic_map> &BMap) {
+bool isVariableDim(const isl::BasicMap &BMap) {
   auto FixedVal =
       give(isl_basic_map_plain_get_val_if_fixed(BMap.keep(), isl_dim_out, 0));
   return !FixedVal || isl_val_is_nan(FixedVal.keep());
 }
 
 /// Whether Map's first out dimension is no constant nor piecewise constant.
-bool isVariableDim(const IslPtr<isl_map> &Map) {
-  return foreachEltWithBreak(Map, [](IslPtr<isl_basic_map> BMap) -> isl_stat {
+bool isVariableDim(const isl::Map &Map) {
+  return foreachEltWithBreak(Map, [](isl::BasicMap BMap) -> isl_stat {
     if (isVariableDim(BMap))
       return isl_stat_error;
     return isl_stat_ok;
   });
 }
 
 /// Whether UMap's first out dimension is no (piecewise) constant.
-bool isVariableDim(const IslPtr<isl_union_map> &UMap) {
-  return foreachEltWithBreak(UMap, [](IslPtr<isl_map> Map) -> isl_stat {
+bool isVariableDim(const isl::UnionMap &UMap) {
+  return foreachEltWithBreak(UMap, [](isl::Map Map) -> isl_stat {
     if (isVariableDim(Map))
       return isl_stat_error;
     return isl_stat_ok;
   });
 }
 
 /// 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.
-IslPtr<isl_val> getConstant(IslPtr<isl_pw_aff> PwAff, bool Max, bool Min) {
+isl::Val getConstant(isl::PwAff PwAff, bool Max, bool Min) {
   assert(!Max || !Min);
-  IslPtr<isl_val> Result;
-  foreachPieceWithBreak(
-      PwAff, [=, &Result](IslPtr<isl_set> Set, IslPtr<isl_aff> Aff) {
-        if (Result && isl_val_is_nan(Result.keep()))
-          return isl_stat_ok;
+  isl::Val Result;
+  foreachPieceWithBreak(PwAff, [=, &Result](isl::Set Set, isl::Aff Aff) {
 
-        // TODO: If Min/Max, we can also determine a minimum/maximum value if
-        // Set is constant-bounded.
-        if (!isl_aff_is_cst(Aff.keep())) {
-          Result = give(isl_val_nan(Aff.getCtx()));
-          return isl_stat_error;
-        }
 
-        auto ThisVal = give(isl_aff_get_constant_val(Aff.keep()));
-        if (!Result) {
-          Result = ThisVal;
-          return isl_stat_ok;
-        }
 
-        if (isl_val_eq(Result.keep(), ThisVal.keep()))
-          return isl_stat_ok;
 
-        if (Max && isl_val_gt(ThisVal.keep(), Result.keep())) {
-          Result = ThisVal;
-          return isl_stat_ok;
-        }
 
-        if (Min && isl_val_lt(ThisVal.keep(), Result.keep())) {
-          Result = ThisVal;
-          return isl_stat_ok;
-        }
 
-        // Not compatible
-        Result = give(isl_val_nan(Aff.getCtx()));
-        return isl_stat_error;
-      });
   return Result;
 }
 
 /// Compute @p UPwAff - @p Val.
-IslPtr<isl_union_pw_aff> subtract(IslPtr<isl_union_pw_aff> UPwAff,
-                                  IslPtr<isl_val> Val) {
+isl::UnionPwAff subtract(isl::UnionPwAff UPwAff, isl::Val Val) {
   if (isl_val_is_zero(Val.keep()))
     return UPwAff;
 
   auto Result =
       give(isl_union_pw_aff_empty(isl_union_pw_aff_get_space(UPwAff.keep())));
-  foreachElt(UPwAff, [=, &Result](IslPtr<isl_pw_aff> PwAff) {
+  foreachElt(UPwAff, [=, &Result](isl::PwAff PwAff) {
     auto ValAff = give(isl_pw_aff_val_on_domain(
         isl_set_universe(isl_space_domain(isl_pw_aff_get_space(PwAff.keep()))),
         Val.copy()));
     auto Subtracted = give(isl_pw_aff_sub(PwAff.copy(), ValAff.take()));
     Result = give(isl_union_pw_aff_union_add(
         Result.take(), isl_union_pw_aff_from_pw_aff(Subtracted.take())));
   });
   return Result;
 }
 
 /// Compute @UPwAff * @p Val.
-IslPtr<isl_union_pw_aff> multiply(IslPtr<isl_union_pw_aff> UPwAff,
-                                  IslPtr<isl_val> Val) {
+isl::UnionPwAff multiply(isl::UnionPwAff UPwAff, isl::Val Val) {
   if (isl_val_is_one(Val.keep()))
     return UPwAff;
 
   auto Result =
       give(isl_union_pw_aff_empty(isl_union_pw_aff_get_space(UPwAff.keep())));
-  foreachElt(UPwAff, [=, &Result](IslPtr<isl_pw_aff> PwAff) {
+  foreachElt(UPwAff, [=, &Result](isl::PwAff PwAff) {
     auto ValAff = give(isl_pw_aff_val_on_domain(
         isl_set_universe(isl_space_domain(isl_pw_aff_get_space(PwAff.keep()))),
         Val.copy()));
     auto Multiplied = give(isl_pw_aff_mul(PwAff.copy(), ValAff.take()));
     Result = give(isl_union_pw_aff_union_add(
         Result.take(), isl_union_pw_aff_from_pw_aff(Multiplied.take())));
   });
   return Result;
 }
 
 /// Remove @p n dimensions from @p UMap's range, starting at @p first.
 ///
 /// It is assumed that all maps in the maps have at least the necessary number
 /// of out dimensions.
-IslPtr<isl_union_map> scheduleProjectOut(const IslPtr<isl_union_map> &UMap,
-                                         unsigned first, unsigned n) {
+isl::UnionMap scheduleProjectOut(const isl::UnionMap &UMap, unsigned first,
+                                 unsigned n) {
   if (n == 0)
     return UMap; /* isl_map_project_out would also reset the tuple, which should
                     have no effect on schedule ranges */
 
   auto Result = give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
-  foreachElt(UMap, [=, &Result](IslPtr<isl_map> Map) {
+  foreachElt(UMap, [=, &Result](isl::Map Map) {
     auto Outprojected =
         give(isl_map_project_out(Map.take(), isl_dim_out, first, n));
     Result = give(isl_union_map_add_map(Result.take(), Outprojected.take()));
   });
   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.
-size_t scheduleScatterDims(const IslPtr<isl_union_map> &Schedule) {
+size_t scheduleScatterDims(const isl::UnionMap &Schedule) {
   unsigned Dims = 0;
-  foreachElt(Schedule, [&Dims](IslPtr<isl_map> Map) {
+  foreachElt(Schedule, [&Dims](isl::Map Map) {
     Dims = std::max(Dims, isl_map_dim(Map.keep(), isl_dim_out));
   });
   return Dims;
 }
 
 /// Return the @p pos' range dimension, converted to an isl_union_pw_aff.
-IslPtr<isl_union_pw_aff> scheduleExtractDimAff(IslPtr<isl_union_map> UMap,
-                                               unsigned pos) {
+isl::UnionPwAff scheduleExtractDimAff(isl::UnionMap UMap, unsigned pos) {
   auto SingleUMap =
       give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
-  foreachElt(UMap, [=, &SingleUMap](IslPtr<isl_map> Map) {
+  foreachElt(UMap, [=, &SingleUMap](isl::Map Map) {
     auto MapDims = isl_map_dim(Map.keep(), isl_dim_out);
     auto SingleMap = give(isl_map_project_out(Map.take(), isl_dim_out, 0, pos));
     SingleMap = give(isl_map_project_out(SingleMap.take(), isl_dim_out, 1,
                                          MapDims - pos - 1));
     SingleUMap =
         give(isl_union_map_add_map(SingleUMap.take(), SingleMap.take()));
   });
 

 /// that value and determine the extent of the next dimension. Let l_X(i) and
 /// u_X(i) its minimum (lower bound) and maximum (upper bound) value. Add them
 /// as "Offset + X - l_X(i)" to the new schedule, then add "u_X(i) - l_X(i) + 1"
 /// to Offset and remove all i-instances from the old schedule. Repeat with the
 /// remaining lowest value i' until there are no instances in the old schedule
 /// left.
 /// The example schedule would be transformed to:
 ///   { Stmt_X[] -> [X - l_X, ...]; Stmt_B -> [l_X - u_X + 1 + Y - l_Y, ...] }
-IslPtr<isl_union_map> tryFlattenSequence(IslPtr<isl_union_map> Schedule) {
+isl::UnionMap tryFlattenSequence(isl::UnionMap Schedule) {
   auto IslCtx = Schedule.getCtx();
   auto ScatterSet =
       give(isl_set_from_union_set(isl_union_map_range(Schedule.copy())));
 
   auto ParamSpace =
       give(isl_space_params(isl_union_map_get_space(Schedule.keep())));
   auto Dims = isl_set_dim(ScatterSet.keep(), isl_dim_set);
   assert(Dims >= 2);

 /// A loop-like dimension is one that depends on a variable (usually a loop's
 /// 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), ...] }
-IslPtr<isl_union_map> tryFlattenLoop(IslPtr<isl_union_map> Schedule) {
+isl::UnionMap tryFlattenLoop(isl::UnionMap Schedule) {
   assert(scheduleScatterDims(Schedule) >= 2);
 
   auto Remaining = scheduleProjectOut(Schedule, 0, 1);
   auto SubSchedule = flattenSchedule(Remaining);
   auto SubDims = scheduleScatterDims(SubSchedule);
 
   auto SubExtent =
       give(isl_set_from_union_set(isl_union_map_range(SubSchedule.copy())));
isl::UnionMap tryFlattenLoop(isl::UnionMap Schedule) {
 
   auto Result = give(isl_union_map_flat_range_product(
       IndexMap.take(), RemainingSubSchedule.take()));
   DEBUG(dbgs() << "Loop-flatten result is:\n  " << Result << "\n");
   return Result;
 }
 } // anonymous namespace
 
-IslPtr<isl_union_map> polly::flattenSchedule(IslPtr<isl_union_map> Schedule) {
+isl::UnionMap polly::flattenSchedule(isl::UnionMap Schedule) {
   auto Dims = scheduleScatterDims(Schedule);
   DEBUG(dbgs() << "Recursive schedule to process:\n  " << Schedule << "\n");
 
   // Base case; no dimensions left
   if (Dims == 0) {
     // TODO: Add one dimension?
     return Schedule;
   }

lib/Transform/FlattenSchedule.cpp

 using namespace polly;
 using namespace llvm;
 
 namespace {
 
 /// Print a schedule to @p OS.
 ///
 /// Prints the schedule for each statements on a new line.
-void printSchedule(raw_ostream &OS, const IslPtr<isl_union_map> &Schedule,
-                   int indent) {
-  foreachElt(Schedule, [&OS, indent](IslPtr<isl_map> Map) {
-    OS.indent(indent) << Map << "\n";
-  });
+void printSchedule(raw_ostream &OS, const isl::UnionMap Schedule, int indent) {
+  foreachElt(Schedule,
+             [&OS, indent](isl::Map Map) { OS.indent(indent) << Map << "\n"; });
 }
 
 /// Flatten the schedule stored in an polly::Scop.
 class FlattenSchedule : public ScopPass {
 private:
   FlattenSchedule(const FlattenSchedule &) = delete;
   const FlattenSchedule &operator=(const FlattenSchedule &) = delete;
 
   std::shared_ptr<isl_ctx> IslCtx;
-  IslPtr<isl_union_map> OldSchedule;
+  isl::UnionMap OldSchedule;
 
 public:
   static char ID;
   explicit FlattenSchedule() : ScopPass(ID) {}
 
   virtual void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequiredTransitive<ScopInfoRegionPass>();
     AU.setPreservesAll();
virtual void printScop(raw_ostream &OS, Scop &S) const override {
     OS << "}\n\n";
 
     OS << "Schedule after flattening {\n";
     printSchedule(OS, give(S.getSchedule()), 4);
     OS << "}\n";
   }
 
   virtual void releaseMemory() override {
     OldSchedule = nullptr;
     IslCtx.reset();
   }
 };
 
 char FlattenSchedule::ID;
 } // anonymous namespace
 
 Pass *polly::createFlattenSchedulePass() { return new FlattenSchedule(); }
 
 INITIALIZE_PASS_BEGIN(FlattenSchedule, "polly-flatten-schedule",
                       "Polly - Flatten schedule", false, false)
 INITIALIZE_PASS_END(FlattenSchedule, "polly-flatten-schedule",
                     "Polly - Flatten schedule", false, false)

unittests/DeLICM/DeLICMTest.cpp

 #include <memory>
 
 using namespace llvm;
 using namespace polly;
 
 namespace {
 
 /// Get the universes of all spaces in @p USet.
-IslPtr<isl_union_set> unionSpace(const IslPtr<isl_union_set> &USet) {
+isl::UnionSet unionSpace(const isl::UnionSet &USet) {
   auto Result = give(isl_union_set_empty(isl_union_set_get_space(USet.keep())));
-  foreachElt(USet, [=, &Result](IslPtr<isl_set> Set) {
+  foreachElt(USet, [=, &Result](isl::Set Set) {
     auto Space = give(isl_set_get_space(Set.keep()));
     auto Universe = give(isl_set_universe(Space.take()));
     Result = give(isl_union_set_add_set(Result.take(), Universe.take()));
   });
   return Result;
 }
 
-void completeLifetime(IslPtr<isl_union_set> Universe,
-                      IslPtr<isl_union_set> &Unknown,
-                      IslPtr<isl_union_set> &Undef) {
+void completeLifetime(isl::UnionSet Universe, isl::UnionSet &Unknown,
+                      isl::UnionSet &Undef) {
   if (!Unknown) {
     assert(Undef);
     Unknown = give(isl_union_set_subtract(Universe.copy(), Undef.copy()));
   }
 
   if (!Undef) {
     assert(Unknown);
     Undef = give(isl_union_set_subtract(Universe.copy(), Unknown.copy()));
Universe =
         give(isl_union_set_union(Universe.take(), ProposedUnused.copy()));
   if (ProposedWritten)
     Universe =
         give(isl_union_set_union(Universe.take(), ProposedWritten.copy()));
   Universe = unionSpace(Universe);
 
   // Add a space the universe that does not occur anywhere else to ensure
   // robustness. Use &NewId to ensure that this Id is unique.
-  IslPtr<isl_id> NewId = give(isl_id_alloc(Ctx.get(), "Unrelated", &NewId));
+  isl::Id NewId = give(isl_id_alloc(Ctx.get(), "Unrelated", &NewId));
   // The space must contains at least one dimension to allow order
   // modifications.
   auto NewSpace = give(isl_space_set_alloc(Ctx.get(), 0, 1));
   auto NewSet = give(isl_set_universe(NewSpace.take()));
   Universe = give(isl_union_set_add_set(Universe.take(), NewSet.take()));
 
   // Using the universe, fill missing data.
   completeLifetime(Universe, ExistingOccupied, ExistingUnused);

unittests/Isl/IslTest.cpp

 #include "polly/Support/ISLTools.h"
 #include "gtest/gtest.h"
 #include "isl/stream.h"
 #include "isl/val.h"
 
 using namespace llvm;
 using namespace polly;
 
-static IslPtr<isl_space> parseSpace(isl_ctx *Ctx, const char *Str) {
+static isl::Space parseSpace(isl_ctx *Ctx, const char *Str) {
   isl_stream *Stream = isl_stream_new_str(Ctx, Str);
   auto Obj = isl_stream_read_obj(Stream);
 
-  IslPtr<isl_space> Result;
+  isl::Space Result;
   if (Obj.type == isl_obj_set)
     Result = give(isl_set_get_space(static_cast<isl_set *>(Obj.v)));
   else if (Obj.type == isl_obj_map)
     Result = give(isl_map_get_space(static_cast<isl_map *>(Obj.v)));
 
   isl_stream_free(Stream);
   if (Obj.type)
     Obj.type->free(Obj.v);
   return Result;
 }
 
 #define SPACE(Str) parseSpace(Ctx.get(), Str)
 
 #define SET(Str) give(isl_set_read_from_str(Ctx.get(), Str))
 #define MAP(Str) give(isl_map_read_from_str(Ctx.get(), Str))
 
 #define USET(Str) give(isl_union_set_read_from_str(Ctx.get(), Str))
 #define UMAP(Str) give(isl_union_map_read_from_str(Ctx.get(), Str))
 
-static bool operator==(const IslPtr<isl_space> &LHS,
-                       const IslPtr<isl_space> &RHS) {
+namespace isl {
+inline namespace noexceptions {
+
+static bool operator==(const isl::Space &LHS, const isl::Space &RHS) {
   auto IsEqual = isl_space_is_equal(LHS.keep(), RHS.keep());
   EXPECT_NE(isl_bool_error, IsEqual);
   return IsEqual;
 }
 
-static bool operator==(const IslPtr<isl_set> &LHS, const IslPtr<isl_set> &RHS) {
+static bool operator==(const isl::Set &LHS, const isl::Set &RHS) {
   auto IsEqual = isl_set_is_equal(LHS.keep(), RHS.keep());
   EXPECT_NE(isl_bool_error, IsEqual);
   return IsEqual;
 }
 
-static bool operator==(const IslPtr<isl_map> &LHS, const IslPtr<isl_map> &RHS) {
+static bool operator==(const isl::Map &LHS, const isl::Map &RHS) {
   auto IsEqual = isl_map_is_equal(LHS.keep(), RHS.keep());
   EXPECT_NE(isl_bool_error, IsEqual);
   return IsEqual;
 }
 
-static bool operator==(const IslPtr<isl_union_set> &LHS,
-                       const IslPtr<isl_union_set> &RHS) {
+static bool operator==(const isl::UnionSet &LHS, const isl::UnionSet &RHS) {
   auto IsEqual = isl_union_set_is_equal(LHS.keep(), RHS.keep());
   EXPECT_NE(isl_bool_error, IsEqual);
   return IsEqual;
 }
 
-static bool operator==(const IslPtr<isl_union_map> &LHS,
-                       const IslPtr<isl_union_map> &RHS) {
+static bool operator==(const isl::UnionMap &LHS, const isl::UnionMap &RHS) {
   auto IsEqual = isl_union_map_is_equal(LHS.keep(), RHS.keep());
   EXPECT_NE(isl_bool_error, IsEqual);
   return IsEqual;
 }
+}
+}
 
 namespace {
 
 TEST(Isl, APIntToIslVal) {
   isl_ctx *IslCtx = isl_ctx_alloc();
 
   {
     APInt APZero(1, 0, true);
     auto *IslZero = isl_valFromAPInt(IslCtx, APZero, true);
TEST(Isl, Foreach) {
   auto SetSpace = give(isl_space_set_alloc(Ctx.get(), 0, 1));
   auto TestBSet =
       give(isl_basic_set_from_point(isl_point_zero(SetSpace.copy())));
   auto TestSet = give(isl_set_from_basic_set(TestBSet.copy()));
   auto TestUSet = give(isl_union_set_from_set(TestSet.copy()));
 
   {
     auto NumBMaps = 0;
-    foreachElt(TestMap, [&](IslPtr<isl_basic_map> BMap) {
+    foreachElt(TestMap, [&](isl::BasicMap BMap) {
       EXPECT_EQ(isl_bool_true,
                 isl_basic_map_is_equal(BMap.keep(), TestBMap.keep()));
       NumBMaps++;
     });
     EXPECT_EQ(1, NumBMaps);
   }
 
   {
     auto NumBSets = 0;
-    foreachElt(TestSet, [&](IslPtr<isl_basic_set> BSet) {
+    foreachElt(TestSet, [&](isl::BasicSet BSet) {
       EXPECT_EQ(isl_bool_true,
                 isl_basic_set_is_equal(BSet.keep(), TestBSet.keep()));
       NumBSets++;
     });
     EXPECT_EQ(1, NumBSets);
   }
 
   {
     auto NumMaps = 0;
-    foreachElt(TestUMap, [&](IslPtr<isl_map> Map) {
+    foreachElt(TestUMap, [&](isl::Map Map) {
       EXPECT_EQ(isl_bool_true, isl_map_is_equal(Map.keep(), TestMap.keep()));
       NumMaps++;
     });
     EXPECT_EQ(1, NumMaps);
   }
 
   {
     auto NumSets = 0;
-    foreachElt(TestUSet, [&](IslPtr<isl_set> Set) {
+    foreachElt(TestUSet, [&](isl::Set Set) {
       EXPECT_EQ(isl_bool_true, isl_set_is_equal(Set.keep(), TestSet.keep()));
       NumSets++;
     });
     EXPECT_EQ(1, NumSets);
   }
 
   {
     auto UPwAff = give(isl_union_pw_aff_val_on_domain(TestUSet.copy(),
                                                       isl_val_zero(Ctx.get())));
     auto NumPwAffs = 0;
-    foreachElt(UPwAff, [&](IslPtr<isl_pw_aff> PwAff) {
+    foreachElt(UPwAff, [&](isl::PwAff PwAff) {
       EXPECT_EQ(isl_bool_true, isl_pw_aff_is_cst(PwAff.keep()));
       NumPwAffs++;
     });
     EXPECT_EQ(1, NumPwAffs);
   }
 
   {
     auto NumBMaps = 0;
     EXPECT_EQ(isl_stat_error,
-              foreachEltWithBreak(
-                  TestMap, [&](IslPtr<isl_basic_map> BMap) -> isl_stat {
-                    EXPECT_EQ(isl_bool_true, isl_basic_map_is_equal(
-                                                 BMap.keep(), TestBMap.keep()));
-                    NumBMaps++;
-                    return isl_stat_error;
-                  }));
+              foreachEltWithBreak(TestMap, [&](isl::BasicMap BMap) -> isl_stat {
+                EXPECT_EQ(isl_bool_true,
+                          isl_basic_map_is_equal(BMap.keep(), TestBMap.keep()));
     EXPECT_EQ(1, NumBMaps);
   }
 
   {
     auto NumMaps = 0;
-    EXPECT_EQ(
-        isl_stat_error,
-        foreachEltWithBreak(TestUMap, [&](IslPtr<isl_map> Map) -> isl_stat {
+    EXPECT_EQ(isl_stat_error,
+              foreachEltWithBreak(TestUMap, [&](isl::Map Map) -> isl_stat {
                 EXPECT_EQ(isl_bool_true,
                           isl_map_is_equal(Map.keep(), TestMap.keep()));
                 NumMaps++;
                 return isl_stat_error;
               }));
     EXPECT_EQ(1, NumMaps);
   }
 
   {
     auto TestPwAff =
         give(isl_pw_aff_val_on_domain(TestSet.copy(), isl_val_zero(Ctx.get())));
     auto NumPieces = 0;
     foreachPieceWithBreak(
-        TestPwAff,
-        [&](IslPtr<isl_set> Domain, IslPtr<isl_aff> Aff) -> isl_stat {
+        TestPwAff, [&](isl::Set Domain, isl::Aff Aff) -> isl_stat {
           EXPECT_EQ(isl_bool_true,
                     isl_set_is_equal(Domain.keep(), TestSet.keep()));
           EXPECT_EQ(isl_bool_true, isl_aff_is_cst(Aff.keep()));
           NumPieces++;
           return isl_stat_error;
         });
     EXPECT_EQ(1, NumPieces);
   }