Port ScopInfo to the isl cpp bindings

[philip.pfaffe]

Summary

Most changes are mechanical, but in two places I changed the program semantics
by fixing bugs, which I'd like a review on.

The first is in Scop::buildSchedule(Region *, LoopStackTy &, LoopInfo &).
Before, we took a reference to LoopStack.back() which is a use after free,
since back is popped off further below. This didn't crash before by pure
chance, since LoopStack is actually a vector, and the memory isn't freed upon
pop. I turned this into an iterator-based algorithm.

The second is Scop::hasFeasibleRuntimeContext(), where I'm now explicitely
handling the error-case. Before, when the call to
addNonEmptyDomainConstraints() returned a null set, this (probably)
accidentally worked because isl_bool_error converts to true. I'm checking for
nullptr now.

[philip.pfaffe]

Split the fix for the use-after-free out of this into a seperate patch.

Hence this diff now depends on D39979.

[Meinersbur]

LGTM, only nitpicks. Thanks for your work.

include/polly/ScheduleOptimizer.h

74–75

Is this change related?

I think it is a good idea to include ScheduleTreeOptimizer in the Polly namespace, can you commit it separately?

include/polly/ScopInfo.h

1696–1702

Why the move?

[Note] Seems to be wrong in the original comment:

By doing this, we guarantee that the context is deleted when we delete the last object that creates isl objects with the context.

Isn't the point that the isl_ctx is deleted /only after/ all its isl objects are released? I mean, the isl objects don't participate in this shared_ptr and therefore cannot trigger the release of the isl_ctx.

include/polly/Support/GICHelper.h

180–215

For consistency with the other stringFromIslObj functions, shouldn't these be defined in the .cpp file?

The isl objects have to_str() methods, and we have overloaded the << operators in ISLOStream.h; consider using them instead.

lib/Analysis/ScopInfo.cpp

2212

[Style] No almost-always-auto.

2558

Consider isl::set::universe

3397–3398

This comment maybe belongs to the beginning.

4189–4190

This is the changed part, right? Under which conditions does addNonEmptyDomainConstraints return nullptr? It's doxygen doesn't mention it.

4354

No isl::set S?

Edit: From other places I realise you did not convert everything within functions, we do some other time.

lib/CodeGen/IslAst.cpp

678–679

Did something change here?

lib/CodeGen/IslNodeBuilder.cpp

1074–1075

Did something change here? clang-format going rogue?

1368

[Style] no almost-always-auto.

(I only care about introducing new ones, it is up to you if you want to remove existing autos)

1385

[Style] no almost-always-auto.

lib/Support/GICHelper.cpp

27

Is this required?

unittests/ScheduleOptimizer/ScheduleOptimizerTest.cpp

15

Is this required?

[Meinersbur]

I cannot apply this patch, arcanist always tries to apply it on git sha1 85a1620 (current trunk without D39979).

[philip.pfaffe]

Address review comments.

Changing the printing from GICHelper towards using to_str() on the isl objects requires changing a handful of testcases.

@Meinersbur: Do you agree with the testcase changes?

[Meinersbur]

Looks great (whatever you decide to to with the inline comment)

lib/Analysis/ScopInfo.cpp

3404

Could we just remove the dtor? Or declare = default in the header? Is there is a motivation to make it more explicit that there is a default dtor?

[philip.pfaffe]

lib/Analysis/ScopInfo.cpp

3404

I just kept it the same as the three other classes in that header/file.

[sabuasal]

polly/trunk/lib/Analysis/ScopInfo.cpp

2271 ↗

(On Diff #123515)

How come we are dropping the copy for "Space"?

[philip.pfaffe]

polly/trunk/lib/Analysis/ScopInfo.cpp

2271 ↗

(On Diff #123515)

This is a copy. I'm copying the c++ object.

include/polly/ScheduleOptimizer.h

struct MatMulInfoTy {
   MemoryAccess *WriteToC = nullptr;
   int i = -1;
   int j = -1;
   int k = -1;
 };
 
 extern bool DisablePollyTiling;
 
-} // namespace polly
-
 class ScheduleTreeOptimizer {
 public:
   /// Apply schedule tree transformations.
   ///
   /// This function takes an (possibly already optimized) schedule tree and
   /// applies a set of additional optimizations on the schedule tree. The
   /// transformations applied include:
   ///

 /// 4. Project out the vector loop dimension of the set that was build on the
 ///    first step and subtract the set built on the previous step to get the
 ///    desired set of prefixes.
 ///
 /// @param ScheduleRange A range of a map, which describes a prefix schedule
 ///                      relation.
 isl::set getPartialTilePrefixes(isl::set ScheduleRange, int VectorWidth);
 
+} // namespace polly
 #endif // POLLY_SCHEDULEOPTIMIZER_H

include/polly/ScopInfo.h

 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
-#include "isl/aff.h"
-#include "isl/ctx.h"
 #include "isl/isl-noexceptions.h"
-#include "isl/set.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <forward_list>
 #include <functional>
 #include <list>
 #include <map>
 #include <memory>
struct InvariantEquivClassTy {
   /// this equivalence class. They are treated as invariant and hoisted during
   /// code generation.
   MemoryAccessList InvariantAccesses;
 
   /// The execution context under which the memory location is accessed
   ///
   /// It is the union of the execution domains of the memory accesses in the
   /// InvariantAccesses list.
-  isl_set *ExecutionContext;
+  isl::set ExecutionContext;
 
   /// The type of the invariant access
   ///
   /// It is used to differentiate between differently typed invariant loads from
   /// the same location.
   Type *AccessType;
 };
 
private:
   /// Vector for Instructions in this statement.
   std::vector<Instruction *> Instructions;
 
   /// Remove @p MA from dictionaries pointing to them.
   void removeAccessData(MemoryAccess *MA);
 
 public:
   /// Get an isl_ctx pointer.
-  isl_ctx *getIslCtx() const;
+  isl::ctx getIslCtx() const;
 
   /// Get the iteration domain of this ScopStmt.
   ///
   /// @return The iteration domain of this ScopStmt.
   isl::set getDomain() const;
 
   /// Get the space of the iteration domain
   ///

 ///   execution.
 ///
 ///   * A context
 ///   This context contains information about the values the parameters
 ///   can take and relations between different parameters.
 class Scop {
 public:
   /// Type to represent a pair of minimal/maximal access to an array.
-  using MinMaxAccessTy = std::pair<isl_pw_multi_aff *, isl_pw_multi_aff *>;
+  using MinMaxAccessTy = std::pair<isl::pw_multi_aff, isl::pw_multi_aff>;
 
   /// Vector of minimal/maximal accesses to different arrays.
   using MinMaxVectorTy = SmallVector<MinMaxAccessTy, 4>;
 
   /// Pair of minimal/maximal access vectors representing
   /// read write and read only accesses
   using MinMaxVectorPairTy = std::pair<MinMaxVectorTy, MinMaxVectorTy>;
 
   /// Vector of pair of minimal/maximal access vectors representing
   /// non read only and read only accesses for each alias group.
   using MinMaxVectorPairVectorTy = SmallVector<MinMaxVectorPairTy, 4>;
 
 private:
   friend class ScopBuilder;
 
+  /// Isl context.
+  ///
+  /// We need a shared_ptr with reference counter to delete the context when all
+  /// isl objects are deleted. We will distribute the shared_ptr to all objects
+  /// that use the context to create isl objects, and increase the reference
+  /// counter. By doing this, we guarantee that the context is deleted when we
+  /// delete the last object that creates isl objects with the context.
+  std::shared_ptr<isl_ctx> IslCtx;
+
   ScalarEvolution *SE;
   DominatorTree *DT;
 
   /// The underlying Region.
   Region &R;
 
   /// The name of the SCoP (identical to the regions name)
   std::string name;
private:
   DenseMap<const SCEV *, isl::id> ParameterIds;
 
   /// The context of the SCoP created during SCoP detection.
   ScopDetection::DetectionContext &DC;
 
   /// OptimizationRemarkEmitter object for displaying diagnostic remarks
   OptimizationRemarkEmitter &ORE;
 
-  /// Isl context.
-  ///
-  /// We need a shared_ptr with reference counter to delete the context when all
-  /// isl objects are deleted. We will distribute the shared_ptr to all objects
-  /// that use the context to create isl objects, and increase the reference
-  /// counter. By doing this, we guarantee that the context is deleted when we
-  /// delete the last object that creates isl objects with the context.
-  std::shared_ptr<isl_ctx> IslCtx;
-
   /// A map from basic blocks to vector of SCoP statements. Currently this
   /// vector comprises only of a single statement.
   DenseMap<BasicBlock *, std::vector<ScopStmt *>> StmtMap;
 
   /// A map from instructions to SCoP statements.
   DenseMap<Instruction *, ScopStmt *> InstStmtMap;
 
   /// A map from basic blocks to their domains.
   DenseMap<BasicBlock *, isl::set> DomainMap;
 
   /// Constraints on parameters.
-  isl_set *Context = nullptr;
+  isl::set Context = nullptr;
 
   /// The affinator used to translate SCEVs to isl expressions.
   SCEVAffinator Affinator;
 
   using ArrayInfoMapTy =
       std::map<std::pair<AssertingVH<const Value>, MemoryKind>,
                std::unique_ptr<ScopArrayInfo>>;
 
private:
 
   /// The assumptions under which this scop was built.
   ///
   /// When constructing a scop sometimes the exact representation of a statement
   /// or condition would be very complex, but there is a common case which is a
   /// lot simpler, but which is only valid under certain assumptions. The
   /// assumed context records the assumptions taken during the construction of
   /// this scop and that need to be code generated as a run-time test.
-  isl_set *AssumedContext = nullptr;
+  isl::set AssumedContext;
 
   /// The restrictions under which this SCoP was built.
   ///
   /// The invalid context is similar to the assumed context as it contains
   /// constraints over the parameters. However, while we need the constraints
   /// in the assumed context to be "true" the constraints in the invalid context
   /// need to be "false". Otherwise they behave the same.
-  isl_set *InvalidContext = nullptr;
+  isl::set InvalidContext;
 
   /// Helper struct to remember assumptions.
   struct Assumption {
     /// The kind of the assumption (e.g., WRAPPING).
     AssumptionKind Kind;
 
     /// Flag to distinguish assumptions and restrictions.
     AssumptionSign Sign;
 
     /// The valid/invalid context if this is an assumption/restriction.
-    isl_set *Set;
+    isl::set Set;
 
     /// The location that caused this assumption.
     DebugLoc Loc;
 
     /// An optional block whose domain can simplify the assumption.
     BasicBlock *BB;
   };
 
private:
   /// the schedule vector of A is lexicographic smaller than the schedule
   /// vector of B.
   ///
   /// Besides band nodes, schedule trees contain additional nodes that specify
   /// a textual ordering between two subtrees or filter nodes that filter the
   /// set of statement instances that will be scheduled in a subtree. There
   /// are also several other nodes. A full description of the different nodes
   /// in a schedule tree is given in the isl manual.
-  isl_schedule *Schedule = nullptr;
+  isl::schedule Schedule = nullptr;
 
   /// The set of minimal/maximal accesses for each alias group.
   ///
   /// When building runtime alias checks we look at all memory instructions and
   /// build so called alias groups. Each group contains a set of accesses to
   /// different base arrays which might alias with each other. However, between
   /// alias groups there is no aliasing possible.
   ///
private:
 
   /// A loop stack element to keep track of per-loop information during
   ///        schedule construction.
   using LoopStackElementTy = struct LoopStackElement {
     // The loop for which we keep information.
     Loop *L;
 
     // The (possibly incomplete) schedule for this loop.
-    isl_schedule *Schedule;
+    isl::schedule Schedule;
 
     // The number of basic blocks in the current loop, for which a schedule has
     // already been constructed.
     unsigned NumBlocksProcessed;
 
-    LoopStackElement(Loop *L, __isl_give isl_schedule *S,
-                     unsigned NumBlocksProcessed)
+    LoopStackElement(Loop *L, isl::schedule S, unsigned NumBlocksProcessed)
         : L(L), Schedule(S), NumBlocksProcessed(NumBlocksProcessed) {}
   };
 
   /// The loop stack used for schedule construction.
   ///
   /// The loop stack keeps track of schedule information for a set of nested
   /// loops as well as an (optional) 'nullptr' loop that models the outermost
   /// schedule dimension. The loops in a loop stack always have a parent-child
public:
 
   /// Check if the assumption in @p Set is trivial or not.
   ///
   /// @param Set  The relations between parameters that are assumed to hold.
   /// @param Sign Enum to indicate if the assumptions in @p Set are positive
   ///             (needed/assumptions) or negative (invalid/restrictions).
   ///
   /// @returns True if the assumption @p Set is not trivial.
-  bool isEffectiveAssumption(__isl_keep isl_set *Set, AssumptionSign Sign);
+  bool isEffectiveAssumption(isl::set Set, AssumptionSign Sign);
 
   /// Track and report an assumption.
   ///
   /// Use 'clang -Rpass-analysis=polly-scops' or 'opt
   /// -pass-remarks-analysis=polly-scops' to output the assumptions.
   ///
   /// @param Kind The assumption kind describing the underlying cause.
   /// @param Set  The relations between parameters that are assumed to hold.
   /// @param Loc  The location in the source that caused this assumption.
   /// @param Sign Enum to indicate if the assumptions in @p Set are positive
   ///             (needed/assumptions) or negative (invalid/restrictions).
   /// @param BB   The block in which this assumption was taken. Used to
   ///             calculate hotness when emitting remark.
   ///
   /// @returns True if the assumption is not trivial.
-  bool trackAssumption(AssumptionKind Kind, __isl_keep isl_set *Set,
-                       DebugLoc Loc, AssumptionSign Sign, BasicBlock *BB);
+  bool trackAssumption(AssumptionKind Kind, isl::set Set, DebugLoc Loc,
+                       AssumptionSign Sign, BasicBlock *BB);
 
   /// Add assumptions to assumed context.
   ///
   /// The assumptions added will be assumed to hold during the execution of the
   /// scop. However, as they are generally not statically provable, at code
   /// generation time run-time checks will be generated that ensure the
   /// assumptions hold.
   ///
   /// WARNING: We currently exploit in simplifyAssumedContext the knowledge
   ///          that assumptions do not change the set of statement instances
   ///          executed.
   ///
   /// @param Kind The assumption kind describing the underlying cause.
   /// @param Set  The relations between parameters that are assumed to hold.
   /// @param Loc  The location in the source that caused this assumption.
   /// @param Sign Enum to indicate if the assumptions in @p Set are positive
   ///             (needed/assumptions) or negative (invalid/restrictions).
   /// @param BB   The block in which this assumption was taken. Used to
   ///             calculate hotness when emitting remark.
-  void addAssumption(AssumptionKind Kind, __isl_take isl_set *Set, DebugLoc Loc,
+  void addAssumption(AssumptionKind Kind, isl::set Set, DebugLoc Loc,
                      AssumptionSign Sign, BasicBlock *BB);
 
   /// Record an assumption for later addition to the assumed context.
   ///
   /// This function will add the assumption to the RecordedAssumptions. This
   /// collection will be added (@see addAssumption) to the assumed context once
   /// all paramaters are known and the context is fully built.
   ///
   /// @param Kind The assumption kind describing the underlying cause.
   /// @param Set  The relations between parameters that are assumed to hold.
   /// @param Loc  The location in the source that caused this assumption.
   /// @param Sign Enum to indicate if the assumptions in @p Set are positive
   ///             (needed/assumptions) or negative (invalid/restrictions).
   /// @param BB   The block in which this assumption was taken. If it is
   ///             set, the domain of that block will be used to simplify the
   ///             actual assumption in @p Set once it is added. This is useful
   ///             if the assumption was created prior to the domain.
-  void recordAssumption(AssumptionKind Kind, __isl_take isl_set *Set,
-                        DebugLoc Loc, AssumptionSign Sign,
-                        BasicBlock *BB = nullptr);
+  void recordAssumption(AssumptionKind Kind, isl::set Set, DebugLoc Loc,
+                        AssumptionSign Sign, BasicBlock *BB = nullptr);
 
   /// Add all recorded assumptions to the assumed context.
   void addRecordedAssumptions();
 
   /// Mark the scop as invalid.
   ///
   /// This method adds an assumption to the scop that is always invalid. As a
   /// result, the scop will not be optimized later on. This function is commonly
   /// called when a condition makes it impossible (or too compile time
   /// expensive) to process this scop any further.
   ///
   /// @param Kind The assumption kind describing the underlying cause.
   /// @param Loc  The location in the source that triggered .
   /// @param BB   The BasicBlock where it was triggered.
   void invalidate(AssumptionKind Kind, DebugLoc Loc, BasicBlock *BB = nullptr);
 
   /// Get the invalid context for this Scop.
   ///
   /// @return The invalid context of this Scop.
   isl::set getInvalidContext() const;
 
   /// Return true if and only if the InvalidContext is trivial (=empty).
-  bool hasTrivialInvalidContext() const {
-    return isl_set_is_empty(InvalidContext);
-  }
+  bool hasTrivialInvalidContext() const { return InvalidContext.is_empty(); }
 
   /// A vector of memory accesses that belong to an alias group.
   using AliasGroupTy = SmallVector<MemoryAccess *, 4>;
 
   /// A vector of alias groups.
   using AliasGroupVectorTy = SmallVector<Scop::AliasGroupTy, 4>;
 
   /// Build the alias checks for this SCoP.
public:
   void invalidateScopArrayInfo(Value *BasePtr, MemoryKind Kind) {
     auto It = ScopArrayInfoMap.find(std::make_pair(BasePtr, Kind));
     if (It == ScopArrayInfoMap.end())
       return;
     ScopArrayInfoSet.remove(It->second.get());
     ScopArrayInfoMap.erase(It);
   }
 
-  void setContext(__isl_take isl_set *NewContext);
+  void setContext(isl::set NewContext);
 
   /// Align the parameters in the statement to the scop context
   void realignParams();
 
   /// Return true if this SCoP can be profitably optimized.
   ///
   /// @param ScalarsAreUnprofitable Never consider statements with scalar writes
   ///                               as profitably optimizable.

 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   /// Print the ScopStmt to stderr.
   void dump() const;
 #endif
 
   /// Get the isl context of this static control part.
   ///
   /// @return The isl context of this static control part.
-  isl_ctx *getIslCtx() const;
+  isl::ctx getIslCtx() const;
 
   /// Directly return the shared_ptr of the context.
   const std::shared_ptr<isl_ctx> &getSharedIslCtx() const { return IslCtx; }
 
   /// Compute the isl representation for the SCEV @p E
   ///
   /// @param E  The SCEV that should be translated.
   /// @param BB An (optional) basic block in which the isl_pw_aff is computed.
   ///           SCEVs known to not reference any loops in the SCoP can be
   ///           passed without a @p BB.
   /// @param NonNegative Flag to indicate the @p E has to be non-negative.
   ///
   /// Note that this function will always return a valid isl_pw_aff. However, if
   /// the translation of @p E was deemed to complex the SCoP is invalidated and
   /// a dummy value of appropriate dimension is returned. This allows to bail
   /// for complex cases without "error handling code" needed on the users side.
-  __isl_give PWACtx getPwAff(const SCEV *E, BasicBlock *BB = nullptr,
-                             bool NonNegative = false);
+  PWACtx getPwAff(const SCEV *E, BasicBlock *BB = nullptr,
 
   /// Compute the isl representation for the SCEV @p E
   ///
   /// This function is like @see Scop::getPwAff() but strips away the invalid
   /// domain part associated with the piecewise affine function.
   isl::pw_aff getPwAffOnly(const SCEV *E, BasicBlock *BB = nullptr);
 
   /// Return the domain of @p Stmt.
#endif
   isl::union_map getSchedule() const;
 
   /// Get a schedule tree describing the schedule of all statements.
   isl::schedule getScheduleTree() const;
 
   /// Update the current schedule
   ///
   /// NewSchedule The new schedule (given as a flat union-map).
-  void setSchedule(__isl_take isl_union_map *NewSchedule);
+  void setSchedule(isl::union_map NewSchedule);
 
   /// Update the current schedule
   ///
   /// NewSchedule The new schedule (given as schedule tree).
-  void setScheduleTree(__isl_take isl_schedule *NewSchedule);
+  void setScheduleTree(isl::schedule NewSchedule);
 
   /// Intersects the domains of all statements in the SCoP.
   ///
   /// @return true if a change was made
   bool restrictDomains(isl::union_set Domain);
 
   /// Get the depth of a loop relative to the outermost loop in the Scop.
   ///
   /// This will return
   ///    0 if @p L is an outermost loop in the SCoP
   ///   >0 for other loops in the SCoP
   ///   -1 if @p L is nullptr or there is no outermost loop in the SCoP
   int getRelativeLoopDepth(const Loop *L) const;
 
   /// Find the ScopArrayInfo associated with an isl Id
   ///        that has name @p Name.
   ScopArrayInfo *getArrayInfoByName(const std::string BaseName);
 
   /// Check whether @p Schedule contains extension nodes.
   ///
   /// @return true if @p Schedule contains extension nodes.
-  static bool containsExtensionNode(__isl_keep isl_schedule *Schedule);
+  static bool containsExtensionNode(isl::schedule Schedule);
 
   /// Simplify the SCoP representation.
   ///
   /// @param AfterHoisting Whether it is called after invariant load hoisting.
   ///                      When true, also removes statements without
   ///                      side-effects.
   void simplifySCoP(bool AfterHoisting);
 

include/polly/Support/GICHelper.h

 std::string stringFromIslObj(__isl_keep isl_schedule *schedule);
 std::string stringFromIslObj(__isl_keep isl_multi_aff *maff);
 std::string stringFromIslObj(__isl_keep isl_pw_multi_aff *pma);
 std::string stringFromIslObj(__isl_keep isl_multi_pw_aff *mpa);
 std::string stringFromIslObj(__isl_keep isl_union_pw_multi_aff *upma);
 std::string stringFromIslObj(__isl_keep isl_aff *aff);
 std::string stringFromIslObj(__isl_keep isl_pw_aff *pwaff);
 std::string stringFromIslObj(__isl_keep isl_space *space);
+static inline std::string stringFromIslObj(isl::map map) {
+  return stringFromIslObj(map.keep());
+}
+static inline std::string stringFromIslObj(isl::union_map umap) {
+  return stringFromIslObj(umap.keep());
+}
+static inline std::string stringFromIslObj(isl::set set) {
+  return stringFromIslObj(set.keep());
+}
+static inline std::string stringFromIslObj(isl::union_set uset) {
+  return stringFromIslObj(uset.keep());
+}
+static inline std::string stringFromIslObj(isl::schedule schedule) {
+  return stringFromIslObj(schedule.keep());
+}
+static inline std::string stringFromIslObj(isl::multi_aff maff) {
+  return stringFromIslObj(maff.keep());
+}
+static inline std::string stringFromIslObj(isl::pw_multi_aff pma) {
+  return stringFromIslObj(pma.keep());
+}
+static inline std::string stringFromIslObj(isl::multi_pw_aff mpa) {
+  return stringFromIslObj(mpa.keep());
+}
+static inline std::string stringFromIslObj(isl::union_pw_multi_aff upma) {
+  return stringFromIslObj(upma.keep());
+}
+static inline std::string stringFromIslObj(isl::aff aff) {
+  return stringFromIslObj(aff.keep());
+}
+static inline std::string stringFromIslObj(isl::pw_aff pwaff) {
+  return stringFromIslObj(pwaff.keep());
+}
+static inline std::string stringFromIslObj(isl::space space) {
+  return stringFromIslObj(space.keep());
+}
 //@}
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_union_map *Map) {
   OS << polly::stringFromIslObj(Map);
   return OS;
 }
 

include/polly/Support/ISLOStream.h

 ADD_OSTREAM_PRINTER(isl::map)
 ADD_OSTREAM_PRINTER(isl::set)
 ADD_OSTREAM_PRINTER(isl::id)
 ADD_OSTREAM_PRINTER(isl::multi_aff)
 ADD_OSTREAM_PRINTER(isl::multi_pw_aff)
 ADD_OSTREAM_PRINTER(isl::multi_union_pw_aff)
 ADD_OSTREAM_PRINTER(isl::point)
 ADD_OSTREAM_PRINTER(isl::pw_aff)
+ADD_OSTREAM_PRINTER(isl::pw_multi_aff)
 ADD_OSTREAM_PRINTER(isl::schedule)
 ADD_OSTREAM_PRINTER(isl::schedule_node)
 ADD_OSTREAM_PRINTER(isl::space)
 ADD_OSTREAM_PRINTER(isl::union_access_info)
 ADD_OSTREAM_PRINTER(isl::union_flow)
 ADD_OSTREAM_PRINTER(isl::union_set)
 ADD_OSTREAM_PRINTER(isl::union_map)
 ADD_OSTREAM_PRINTER(isl::union_pw_aff)
 ADD_OSTREAM_PRINTER(isl::union_pw_multi_aff)
 } // namespace polly

lib/Analysis/ScopInfo.cpp

static cl::opt<bool> PollyPrintInstructions(
     "polly-print-instructions", cl::desc("Output instructions per ScopStmt"),
     cl::Hidden, cl::Optional, cl::init(false), cl::cat(PollyCategory));
 
 //===----------------------------------------------------------------------===//
 
 // Create a sequence of two schedules. Either argument may be null and is
 // interpreted as the empty schedule. Can also return null if both schedules are
 // empty.
-static __isl_give isl_schedule *
-combineInSequence(__isl_take isl_schedule *Prev,
-                  __isl_take isl_schedule *Succ) {
+static isl::schedule combineInSequence(isl::schedule Prev, isl::schedule Succ) {
   if (!Prev)
     return Succ;
   if (!Succ)
     return Prev;
 
-  return isl_schedule_sequence(Prev, Succ);
+  return Prev.sequence(Succ);
 }
 
 static isl::set addRangeBoundsToSet(isl::set S, const ConstantRange &Range,
                                     int dim, isl::dim type) {
   isl::val V;
   isl::ctx Ctx = S.get_ctx();
 
   // The upper and lower bound for a parameter value is derived either from
MemoryAccess::applyScheduleToAccessRelation(isl::union_map USchedule) const {
   return isl::pw_multi_aff::from_map(ScheduledAccRel);
 }
 
 isl::map MemoryAccess::getOriginalAccessRelation() const {
   return AccessRelation;
 }
 
 std::string MemoryAccess::getOriginalAccessRelationStr() const {
-  return stringFromIslObj(AccessRelation.get());
+  return stringFromIslObj(AccessRelation);
 }
 
 isl::space MemoryAccess::getOriginalAccessRelationSpace() const {
   return AccessRelation.get_space();
 }
 
 isl::map MemoryAccess::getNewAccessRelation() const {
   return NewAccessRelation;
 }
 
 std::string MemoryAccess::getNewAccessRelationStr() const {
-  return stringFromIslObj(NewAccessRelation.get());
+  return stringFromIslObj(NewAccessRelation);
 }
 
 std::string MemoryAccess::getAccessRelationStr() const {
   return getAccessRelation().to_str();
 }
 
 isl::basic_map MemoryAccess::createBasicAccessMap(ScopStmt *Statement) {
   isl::space Space = isl::space(Statement->getIslCtx(), 0, 1);
void MemoryAccess::assumeNoOutOfBound() {
   // bail out more often than strictly necessary.
   Outside = Outside.remove_divs();
   Outside = Outside.complement();
   const auto &Loc = getAccessInstruction()
                         ? getAccessInstruction()->getDebugLoc()
                         : DebugLoc();
   if (!PollyPreciseInbounds)
     Outside = Outside.gist_params(Statement->getDomain().params());
-  Statement->getParent()->recordAssumption(INBOUNDS, Outside.release(), Loc,
+  Statement->getParent()->recordAssumption(INBOUNDS, Outside, Loc,
                                            AS_ASSUMPTION);
 }
 
 void MemoryAccess::buildMemIntrinsicAccessRelation() {
   assert(isMemoryIntrinsic());
   assert(Subscripts.size() == 2 && Sizes.size() == 1);
 
   isl::pw_aff SubscriptPWA = getPwAff(Subscripts[0]);

 unsigned ScopStmt::getNumIterators() const { return NestLoops.size(); }
 
 const char *ScopStmt::getBaseName() const { return BaseName.c_str(); }
 
 Loop *ScopStmt::getLoopForDimension(unsigned Dimension) const {
   return NestLoops[Dimension];
 }
 
-isl_ctx *ScopStmt::getIslCtx() const { return Parent.getIslCtx(); }
+isl::ctx ScopStmt::getIslCtx() const { return Parent.getIslCtx(); }
 
 isl::set ScopStmt::getDomain() const { return Domain; }
 
 isl::space ScopStmt::getDomainSpace() const { return Domain.get_space(); }
 
 isl::id ScopStmt::getDomainId() const { return Domain.get_tuple_id(); }
 
 void ScopStmt::printInstructions(raw_ostream &OS) const {

 raw_ostream &polly::operator<<(raw_ostream &OS, const ScopStmt &S) {
   S.print(OS, PollyPrintInstructions);
   return OS;
 }
 
 //===----------------------------------------------------------------------===//
 /// Scop class implement
 
-void Scop::setContext(__isl_take isl_set *NewContext) {
-  NewContext = isl_set_align_params(NewContext, isl_set_get_space(Context));
-  isl_set_free(Context);
-  Context = NewContext;
+void Scop::setContext(isl::set NewContext) {
+  Context = NewContext.align_params(Context.get_space());
 }
 
 namespace {
 
 /// Remap parameter values but keep AddRecs valid wrt. invariant loads.
 struct SCEVSensitiveParameterRewriter
     : public SCEVRewriteVisitor<SCEVSensitiveParameterRewriter> {
   const ValueToValueMap &VMap;
for (auto *Param : DetectedParams) {
       if (Parameters.count(Param))
         continue;
       NewParams.insert(Param);
     }
 
     SmallVector<isl_set *, 2> ConditionSets;
     auto *TI = InScop ? CI->getParent()->getTerminator() : nullptr;
     BasicBlock *BB = InScop ? CI->getParent() : getRegion().getEntry();
-    auto *Dom = InScop ? DomainMap[BB].copy() : isl_set_copy(Context);
+    auto *Dom = InScop ? DomainMap[BB].copy() : Context.copy();
     assert(Dom && "Cannot propagate a nullptr.");
     bool Valid = buildConditionSets(*this, BB, Val, TI, L, Dom,
                                     InvalidDomainMap, ConditionSets);
     isl_set_free(Dom);
 
     if (!Valid)
       continue;
 
if (!NewParams.empty()) {
           continue;
 
         AssumptionCtx =
             isl_set_project_out(AssumptionCtx, isl_dim_param, u--, 1);
       }
     }
     ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "UserAssumption", CI)
              << "Use user assumption: " << stringFromIslObj(AssumptionCtx));
-    Context = isl_set_intersect(Context, AssumptionCtx);
+    Context = Context.intersect(isl::manage(AssumptionCtx));
   }
 }
 
 void Scop::addUserContext() {
   if (UserContextStr.empty())
     return;
 
   isl_set *UserContext =
-      isl_set_read_from_str(getIslCtx(), UserContextStr.c_str());
+      isl_set_read_from_str(getIslCtx().get(), UserContextStr.c_str());
   isl_space *Space = getParamSpace().release();
   if (isl_space_dim(Space, isl_dim_param) !=
       isl_set_dim(UserContext, isl_dim_param)) {
     auto SpaceStr = isl_space_to_str(Space);
     errs() << "Error: the context provided in -polly-context has not the same "
            << "number of dimensions than the computed context. Due to this "
            << "mismatch, the -polly-context option is ignored. Please provide "
            << "the context in the parameter space: " << SpaceStr << ".\n";
     free(SpaceStr);
     isl_set_free(UserContext);
     isl_space_free(Space);
     return;
   }
 
   for (unsigned i = 0; i < isl_space_dim(Space, isl_dim_param); i++) {
-    auto *NameContext = isl_set_get_dim_name(Context, isl_dim_param, i);
-    auto *NameUserContext = isl_set_get_dim_name(UserContext, isl_dim_param, i);
+    std::string NameContext = Context.get_dim_name(isl::dim::param, i);
+    std::string NameUserContext =
+        isl_set_get_dim_name(UserContext, isl_dim_param, i);
 
-    if (strcmp(NameContext, NameUserContext) != 0) {
+    if (NameContext != NameUserContext) {
       auto SpaceStr = isl_space_to_str(Space);
       errs() << "Error: the name of dimension " << i
              << " provided in -polly-context "
              << "is '" << NameUserContext << "', but the name in the computed "
              << "context is '" << NameContext
              << "'. Due to this name mismatch, "
              << "the -polly-context option is ignored. Please provide "
              << "the context in the parameter space: " << SpaceStr << ".\n";
       free(SpaceStr);
       isl_set_free(UserContext);
       isl_space_free(Space);
       return;
     }
 
     UserContext =
         isl_set_set_dim_id(UserContext, isl_dim_param, i,
                            isl_space_get_dim_id(Space, isl_dim_param, i));
   }
 
-  Context = isl_set_intersect(Context, UserContext);
+  Context = Context.intersect(isl::manage(UserContext));
   isl_space_free(Space);
 }
 
 void Scop::buildInvariantEquivalenceClasses() {
   DenseMap<std::pair<const SCEV *, Type *>, LoadInst *> EquivClasses;
 
   const InvariantLoadsSetTy &RIL = getRequiredInvariantLoads();
   for (LoadInst *LInst : RIL) {
     const SCEV *PointerSCEV = SE->getSCEV(LInst->getPointerOperand());
 
     Type *Ty = LInst->getType();
     LoadInst *&ClassRep = EquivClasses[std::make_pair(PointerSCEV, Ty)];
     if (ClassRep) {
       InvEquivClassVMap[LInst] = ClassRep;
       continue;
     }
 
     ClassRep = LInst;
     InvariantEquivClasses.emplace_back(
         InvariantEquivClassTy{PointerSCEV, MemoryAccessList(), nullptr, Ty});
   }
 }
 
 void Scop::buildContext() {
-  isl_space *Space = isl_space_params_alloc(getIslCtx(), 0);
-  Context = isl_set_universe(isl_space_copy(Space));
-  InvalidContext = isl_set_empty(isl_space_copy(Space));
-  AssumedContext = isl_set_universe(Space);
+  auto Space = isl::space::params_alloc(getIslCtx(), 0);
+  Context = isl::set::universe(Space);
+  InvalidContext = isl::set::empty(Space);
+  AssumedContext = isl::set::universe(Space);
 }
 
 void Scop::addParameterBounds() {
   unsigned PDim = 0;
   for (auto *Parameter : Parameters) {
     ConstantRange SRange = SE->getSignedRange(Parameter);
-    Context =
-        addRangeBoundsToSet(give(Context), SRange, PDim++, isl::dim::param)
-            .release();
+    Context = addRangeBoundsToSet(Context, SRange, PDim++, isl::dim::param);
   }
 }
 
 static std::vector<isl::id> getFortranArrayIds(Scop::array_range Arrays) {
   std::vector<isl::id> OutermostSizeIds;
   for (auto Array : Arrays) {
     // To check if an array is a Fortran array, we check if it has a isl_pw_aff
     // for its outermost dimension. Fortran arrays will have this since the
if (Array->getNumberOfDimensions() > 0) {
       Id.dump();
       OutermostSizeIds.push_back(Id);
     }
   }
   return OutermostSizeIds;
 }
 
 // The FORTRAN array size parameters are known to be non-negative.
-static isl_set *boundFortranArrayParams(__isl_give isl_set *Context,
+static isl::set boundFortranArrayParams(isl::set Context,
                                         Scop::array_range Arrays) {
   std::vector<isl::id> OutermostSizeIds;
   OutermostSizeIds = getFortranArrayIds(Arrays);
 
   for (isl::id Id : OutermostSizeIds) {
-    int dim = isl_set_find_dim_by_id(Context, isl_dim_param, Id.get());
-    Context = isl_set_lower_bound_si(Context, isl_dim_param, dim, 0);
+    int dim = Context.find_dim_by_id(isl::dim::param, Id);
+    Context = Context.lower_bound_si(isl::dim::param, dim, 0);
   }
 
   return Context;
 }
 
 void Scop::realignParams() {
   if (PollyIgnoreParamBounds)
     return;
 
   // Add all parameters into a common model.
   isl::space Space = getFullParamSpace();
 
   // Align the parameters of all data structures to the model.
-  Context = isl_set_align_params(Context, Space.copy());
+  Context = Context.align_params(Space);
 
   // Bound the size of the fortran array dimensions.
   Context = boundFortranArrayParams(Context, arrays());
 
   // As all parameters are known add bounds to them.
   addParameterBounds();
 
   for (ScopStmt &Stmt : *this)
     Stmt.realignParams();
   // Simplify the schedule according to the context too.
-  Schedule = isl_schedule_gist_domain_params(Schedule, getContext().release());
+  Schedule = Schedule.gist_domain_params(getContext());
 }
 
-static __isl_give isl_set *
-simplifyAssumptionContext(__isl_take isl_set *AssumptionContext,
+static isl::set simplifyAssumptionContext(isl::set AssumptionContext,
                                           const Scop &S) {
   // If we have modeled all blocks in the SCoP that have side effects we can
   // simplify the context with the constraints that are needed for anything to
   // be executed at all. However, if we have error blocks in the SCoP we already
   // assumed some parameter combinations cannot occur and removed them from the
   // domains, thus we cannot use the remaining domain to simplify the
   // assumptions.
   if (!S.hasErrorBlock()) {
-    isl_set *DomainParameters = isl_union_set_params(S.getDomains().release());
-    AssumptionContext =
-        isl_set_gist_params(AssumptionContext, DomainParameters);
+    auto DomainParameters = S.getDomains().params();
+    AssumptionContext = AssumptionContext.gist_params(DomainParameters);
   }
 
-  AssumptionContext =
-      isl_set_gist_params(AssumptionContext, S.getContext().release());
+  AssumptionContext = AssumptionContext.gist_params(S.getContext());
   return AssumptionContext;
 }
 
 void Scop::simplifyContexts() {
   // The parameter constraints of the iteration domains give us a set of
   // constraints that need to hold for all cases where at least a single
   // statement iteration is executed in the whole scop. We now simplify the
   // assumed context under the assumption that such constraints hold and at
void Scop::simplifyContexts() {
   //     for (long i = 0; i < 100; i++)
   //       for (long j = 0; j < m; j++)
   //         A[i+p][j] = 1.0;
   //
   //   we assume that the condition m <= 0 or (m >= 1 and p >= 0) holds as
   //   otherwise we would access out of bound data. Now, knowing that code is
   //   only executed for the case m >= 0, it is sufficient to assume p >= 0.
   AssumedContext = simplifyAssumptionContext(AssumedContext, *this);
-  InvalidContext =
-      isl_set_align_params(InvalidContext, getParamSpace().release());
+  InvalidContext = InvalidContext.align_params(getParamSpace());
 }
 
 /// Add the minimal/maximal access in @p Set to @p User.
 static isl::stat
 buildMinMaxAccess(isl::set Set, Scop::MinMaxVectorTy &MinMaxAccesses, Scop &S) {
   isl::pw_multi_aff MinPMA, MaxPMA;
   isl::pw_aff LastDimAff;
   isl::aff OneAff;
buildMinMaxAccess(isl::set Set, Scop::MinMaxVectorTy &MinMaxAccesses, Scop &S) {
   assert(MaxPMA.dim(isl::dim::out) && "Assumed at least one output dimension");
   Pos = MaxPMA.dim(isl::dim::out) - 1;
   LastDimAff = MaxPMA.get_pw_aff(Pos);
   OneAff = isl::aff(isl::local_space(LastDimAff.get_domain_space()));
   OneAff = OneAff.add_constant_si(1);
   LastDimAff = LastDimAff.add(OneAff);
   MaxPMA = MaxPMA.set_pw_aff(Pos, LastDimAff);
 
-  MinMaxAccesses.push_back(std::make_pair(MinPMA.copy(), MaxPMA.copy()));
+  MinMaxAccesses.push_back(std::make_pair(MinPMA, MaxPMA));
 
   return isl::stat::ok;
 }
 
 static __isl_give isl_set *getAccessDomain(MemoryAccess *MA) {
   isl_set *Domain = MA->getStatement()->getDomain().release();
   Domain = isl_set_project_out(Domain, isl_dim_set, 0, isl_set_n_dim(Domain));
   return isl_set_reset_tuple_id(Domain);

 }
 
 bool Scop::buildDomains(Region *R, DominatorTree &DT, LoopInfo &LI,
                         DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
   bool IsOnlyNonAffineRegion = isNonAffineSubRegion(R);
   auto *EntryBB = R->getEntry();
   auto *L = IsOnlyNonAffineRegion ? nullptr : LI.getLoopFor(EntryBB);
   int LD = getRelativeLoopDepth(L);
-  auto *S = isl_set_universe(isl_space_set_alloc(getIslCtx(), 0, LD + 1));
+  auto *S = isl_set_universe(isl_space_set_alloc(getIslCtx().get(), 0, LD + 1));
 
   while (LD-- >= 0) {
     S = addDomainDimId(S, LD + 1, L);
     L = L->getParentLoop();
   }
 
   InvalidDomainMap[EntryBB] = isl::manage(isl_set_empty(isl_set_get_space(S)));
   DomainMap[EntryBB] = isl::manage(S);
for (auto *RN : RTraversal) {
 
     bool IsInvalidBlock = ContainsErrorBlock || Domain.is_subset(InvalidDomain);
 
     if (!IsInvalidBlock) {
       InvalidDomain = InvalidDomain.intersect(Domain);
     } else {
       InvalidDomain = Domain;
       isl::set DomPar = Domain.params();
-      recordAssumption(ERRORBLOCK, DomPar.release(),
-                       BB->getTerminator()->getDebugLoc(), AS_RESTRICTION);
+      recordAssumption(ERRORBLOCK, DomPar, BB->getTerminator()->getDebugLoc(),
+                       AS_RESTRICTION);
       Domain = nullptr;
     }
 
     if (InvalidDomain.is_empty()) {
       InvalidDomainMap[BB] = InvalidDomain;
       continue;
     }
 
bool Scop::addLoopBoundsToHeaderDomain(
   // Check if there is a <nsw> tagged AddRec for this loop and if so do not add
   // the bounded assumptions to the context as they are already implied by the
   // <nsw> tag.
   if (Affinator.hasNSWAddRecForLoop(L)) {
     isl_set_free(Parts.first);
     return true;
   }
 
-  isl_set *UnboundedCtx = isl_set_params(Parts.first);
+  isl::set UnboundedCtx = isl::manage(Parts.first).params();
   recordAssumption(INFINITELOOP, UnboundedCtx,
                    HeaderBB->getTerminator()->getDebugLoc(), AS_RESTRICTION);
   return true;
 }
 
 MemoryAccess *Scop::lookupBasePtrAccess(MemoryAccess *MA) {
   Value *PointerBase = MA->getOriginalBaseAddr();
 
bool Scop::buildAliasGroups(AliasAnalysis &AA) {
 
   splitAliasGroupsByDomain(AliasGroups);
 
   for (AliasGroupTy &AG : AliasGroups) {
     if (!hasFeasibleRuntimeContext())
       return false;
 
     {
-      IslMaxOperationsGuard MaxOpGuard(getIslCtx(), OptComputeOut);
+      IslMaxOperationsGuard MaxOpGuard(getIslCtx().get(), OptComputeOut);
       bool Valid = buildAliasGroup(AG, HasWriteAccess);
       if (!Valid)
         return false;
     }
-    if (isl_ctx_last_error(getIslCtx()) == isl_error_quota) {
+    if (isl_ctx_last_error(getIslCtx().get()) == isl_error_quota) {
       invalidate(COMPLEXITY, DebugLoc());
       return false;
     }
   }
 
   return true;
 }
 
if (ParentFunc != CurrentFunc) {
     NextScopID = 0;
   }
   return NextScopID++;
 }
 
 Scop::Scop(Region &R, ScalarEvolution &ScalarEvolution, LoopInfo &LI,
            DominatorTree &DT, ScopDetection::DetectionContext &DC,
            OptimizationRemarkEmitter &ORE)
-    : SE(&ScalarEvolution), DT(&DT), R(R), name(R.getNameStr()),
-      HasSingleExitEdge(R.getExitingBlock()), DC(DC), ORE(ORE),
-      IslCtx(isl_ctx_alloc(), isl_ctx_free), Affinator(this, LI),
+    : IslCtx(isl_ctx_alloc(), isl_ctx_free), SE(&ScalarEvolution), DT(&DT),
+      R(R), name(R.getNameStr()), HasSingleExitEdge(R.getExitingBlock()),
+      DC(DC), ORE(ORE), Affinator(this, LI),
       ID(getNextID((*R.getEntry()->getParent()).getName().str())) {
   if (IslOnErrorAbort)
-    isl_options_set_on_error(getIslCtx(), ISL_ON_ERROR_ABORT);
+    isl_options_set_on_error(getIslCtx().get(), ISL_ON_ERROR_ABORT);
   buildContext();
 }
 
 Scop::~Scop() {
-  isl_set_free(Context);
-  isl_set_free(AssumedContext);
-  isl_set_free(InvalidContext);
-  isl_schedule_free(Schedule);
+  Context = nullptr;
+  AssumedContext = nullptr;
+  InvalidContext = nullptr;
+  Schedule = nullptr;
 
   ParameterIds.clear();
 
-  for (auto &AS : RecordedAssumptions)
-    isl_set_free(AS.Set);
-
   // Free the alias groups
-  for (MinMaxVectorPairTy &MinMaxAccessPair : MinMaxAliasGroups) {
-    for (MinMaxAccessTy &MMA : MinMaxAccessPair.first) {
-      isl_pw_multi_aff_free(MMA.first);
-      isl_pw_multi_aff_free(MMA.second);
-    }
-    for (MinMaxAccessTy &MMA : MinMaxAccessPair.second) {
-      isl_pw_multi_aff_free(MMA.first);
-      isl_pw_multi_aff_free(MMA.second);
-    }
-  }
+  RecordedAssumptions.clear();
+  MinMaxAliasGroups.clear();
 
-  for (const auto &IAClass : InvariantEquivClasses)
-    isl_set_free(IAClass.ExecutionContext);
+  InvariantEquivClasses.clear();
 
   // Explicitly release all Scop objects and the underlying isl objects before
   // we release the isl context.
   Stmts.clear();
   ScopArrayInfoSet.clear();
   ScopArrayInfoMap.clear();
   ScopArrayNameMap.clear();
   AccessFunctions.clear();
 }
 
 void Scop::foldSizeConstantsToRight() {
   isl_union_set *Accessed = isl_union_map_range(getAccesses().release());
 
   for (auto Array : arrays()) {
     if (Array->getNumberOfDimensions() <= 1)
       continue;
 
for (auto &IAClass : InvariantEquivClasses) {
       }
 
       // Add MA to the list of accesses that are in this class.
       MAs.push_front(MA);
 
       Consolidated = true;
 
       // Unify the execution context of the class and this statement.
-      isl::set IAClassDomainCtx = isl::manage(IAClass.ExecutionContext);
+      isl::set IAClassDomainCtx = IAClass.ExecutionContext;
       if (IAClassDomainCtx)
         IAClassDomainCtx = IAClassDomainCtx.unite(MACtx).coalesce();
       else
         IAClassDomainCtx = MACtx;
-      IAClass.ExecutionContext = IAClassDomainCtx.release();
+      IAClass.ExecutionContext = IAClassDomainCtx;
       break;
     }
 
     if (Consolidated)
       continue;
 
     // If we did not consolidate MA, thus did not find an equivalence class
     // for it, we create a new one.
-    InvariantEquivClasses.emplace_back(InvariantEquivClassTy{
-        PointerSCEV, MemoryAccessList{MA}, MACtx.release(), Ty});
+    InvariantEquivClasses.emplace_back(
+        InvariantEquivClassTy{PointerSCEV, MemoryAccessList{MA}, MACtx, Ty});
   }
 }
 
 /// Check if an access range is too complex.
 ///
 /// An access range is too complex, if it contains either many disjuncts or
 /// very complex expressions. As a simple heuristic, we assume if a set to
 /// be too complex if the sum of existentially quantified dimensions and
if (!IsWritten)
     return WrittenCtx;
 
   WrittenCtx = WrittenCtx.remove_divs();
   bool TooComplex =
       isl_set_n_basic_set(WrittenCtx.get()) >= MaxDisjunctsInDomain;
   if (TooComplex || !isRequiredInvariantLoad(LI))
     return nullptr;
 
-  addAssumption(INVARIANTLOAD, WrittenCtx.copy(), LI->getDebugLoc(),
-                AS_RESTRICTION, LI->getParent());
+  addAssumption(INVARIANTLOAD, WrittenCtx, LI->getDebugLoc(), AS_RESTRICTION,
+                LI->getParent());
   return WrittenCtx;
 }
 
 void Scop::verifyInvariantLoads() {
   auto &RIL = getRequiredInvariantLoads();
   for (LoadInst *LI : RIL) {
     assert(LI && contains(LI));
     // If there exists a statement in the scop which has a memory access for
if (R.getExit()) {
     R.getExit()->printAsOperand(ExitStr, false);
     ExitStr.str();
   } else
     ExitName = "FunctionExit";
 
   return std::make_pair(EntryName, ExitName);
 }
 
-isl::set Scop::getContext() const { return isl::manage(isl_set_copy(Context)); }
+isl::set Scop::getContext() const { return Context; }
 isl::space Scop::getParamSpace() const { return getContext().get_space(); }
 
 isl::space Scop::getFullParamSpace() const {
   std::vector<isl::id> FortranIDs;
   FortranIDs = getFortranArrayIds(arrays());
 
   isl::space Space = isl::space::params_alloc(
       getIslCtx(), ParameterIds.size() + FortranIDs.size());
 
   unsigned PDim = 0;
   for (const SCEV *Parameter : Parameters) {
     isl::id Id = getIdForParam(Parameter);
     Space = Space.set_dim_id(isl::dim::param, PDim++, Id);
   }
 
   for (isl::id Id : FortranIDs)
     Space = Space.set_dim_id(isl::dim::param, PDim++, Id);
 
   return Space;
 }
 
 isl::set Scop::getAssumedContext() const {
   assert(AssumedContext && "Assumed context not yet built");
-  return isl::manage(isl_set_copy(AssumedContext));
+  return AssumedContext;
 }
 
 bool Scop::isProfitable(bool ScalarsAreUnprofitable) const {
   if (PollyProcessUnprofitable)
     return true;
 
   if (isEmpty())
     return false;
for (auto &Stmt : *this) {
     if (!ScalarsAreUnprofitable || (ContainsArrayAccs && !ContainsScalarAccs))
       OptimizableStmtsOrLoops += Stmt.getNumIterators();
   }
 
   return OptimizableStmtsOrLoops > 1;
 }
 
 bool Scop::hasFeasibleRuntimeContext() const {
-  auto *PositiveContext = getAssumedContext().release();
-  auto *NegativeContext = getInvalidContext().release();
-  PositiveContext =
-      addNonEmptyDomainConstraints(isl::manage(PositiveContext)).release();
-  bool IsFeasible = !(isl_set_is_empty(PositiveContext) ||
-                      isl_set_is_subset(PositiveContext, NegativeContext));
-  isl_set_free(PositiveContext);
-  if (!IsFeasible) {
-    isl_set_free(NegativeContext);
+  auto PositiveContext = getAssumedContext();
+  auto NegativeContext = getInvalidContext();
+  PositiveContext = addNonEmptyDomainConstraints(PositiveContext);
+  if (!PositiveContext)
+    return false;
+
+  bool IsFeasible = !(PositiveContext.is_empty() ||
+                      PositiveContext.is_subset(NegativeContext));
+  if (!IsFeasible)
     return false;
-  }
 
-  auto *DomainContext = isl_union_set_params(getDomains().release());
-  IsFeasible = !isl_set_is_subset(DomainContext, NegativeContext);
-  IsFeasible &= !isl_set_is_subset(Context, NegativeContext);
-  isl_set_free(NegativeContext);
-  isl_set_free(DomainContext);
+  auto DomainContext = getDomains().params();
+  IsFeasible = !DomainContext.is_subset(NegativeContext);
+  IsFeasible &= !Context.is_subset(NegativeContext);
 
   return IsFeasible;
 }
 
 static std::string toString(AssumptionKind Kind) {
   switch (Kind) {
   case ALIASING:
     return "No-aliasing";
static std::string toString(AssumptionKind Kind) {
   case INVARIANTLOAD:
     return "Invariant load";
   case DELINEARIZATION:
     return "Delinearization";
   }
   llvm_unreachable("Unknown AssumptionKind!");
 }
 
-bool Scop::isEffectiveAssumption(__isl_keep isl_set *Set, AssumptionSign Sign) {
+bool Scop::isEffectiveAssumption(isl::set Set, AssumptionSign Sign) {
   if (Sign == AS_ASSUMPTION) {
-    if (isl_set_is_subset(Context, Set))
+    if (Context.is_subset(Set))
       return false;
 
-    if (isl_set_is_subset(AssumedContext, Set))
+    if (AssumedContext.is_subset(Set))
       return false;
   } else {
-    if (isl_set_is_disjoint(Set, Context))
+    if (Set.is_disjoint(Context))
       return false;
 
-    if (isl_set_is_subset(Set, InvalidContext))
+    if (Set.is_subset(InvalidContext))
       return false;
   }
   return true;
 }
 
-bool Scop::trackAssumption(AssumptionKind Kind, __isl_keep isl_set *Set,
-                           DebugLoc Loc, AssumptionSign Sign, BasicBlock *BB) {
+bool Scop::trackAssumption(AssumptionKind Kind, isl::set Set, DebugLoc Loc,
+                           AssumptionSign Sign, BasicBlock *BB) {
   if (PollyRemarksMinimal && !isEffectiveAssumption(Set, Sign))
     return false;
 
   // Do never emit trivial assumptions as they only clutter the output.
   if (!PollyRemarksMinimal) {
-    isl_set *Univ = nullptr;
+    isl::set Univ;
     if (Sign == AS_ASSUMPTION)
-      Univ = isl_set_universe(isl_set_get_space(Set));
+      Univ = isl::set::universe(Set.get_space());
 
-    bool IsTrivial = (Sign == AS_RESTRICTION && isl_set_is_empty(Set)) ||
-                     (Sign == AS_ASSUMPTION && isl_set_is_equal(Univ, Set));
-    isl_set_free(Univ);
+    bool IsTrivial = (Sign == AS_RESTRICTION && Set.is_empty()) ||
+                     (Sign == AS_ASSUMPTION && Univ.is_equal(Set));
 
     if (IsTrivial)
       return false;
   }
 
   switch (Kind) {
   case ALIASING:
     AssumptionsAliasing++;
ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AssumpRestrict", Loc, BB)
              << Msg);
   else
     ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AssumpRestrict", Loc,
                                         R.getEntry())
              << Msg);
   return true;
 }
 
-void Scop::addAssumption(AssumptionKind Kind, __isl_take isl_set *Set,
-                         DebugLoc Loc, AssumptionSign Sign, BasicBlock *BB) {
+void Scop::addAssumption(AssumptionKind Kind, isl::set Set, DebugLoc Loc,
+                         AssumptionSign Sign, BasicBlock *BB) {
   // Simplify the assumptions/restrictions first.
-  Set = isl_set_gist_params(Set, getContext().release());
+  Set = Set.gist_params(getContext());
 
-  if (!trackAssumption(Kind, Set, Loc, Sign, BB)) {
-    isl_set_free(Set);
+  if (!trackAssumption(Kind, Set, Loc, Sign, BB))
     return;
-  }
 
-  if (Sign == AS_ASSUMPTION) {
-    AssumedContext = isl_set_intersect(AssumedContext, Set);
-    AssumedContext = isl_set_coalesce(AssumedContext);
-  } else {
-    InvalidContext = isl_set_union(InvalidContext, Set);
-    InvalidContext = isl_set_coalesce(InvalidContext);
-  }
+  if (Sign == AS_ASSUMPTION)
+    AssumedContext = AssumedContext.intersect(Set).coalesce();
+  else
+    InvalidContext = InvalidContext.unite(Set).coalesce();
 }
 
-void Scop::recordAssumption(AssumptionKind Kind, __isl_take isl_set *Set,
-                            DebugLoc Loc, AssumptionSign Sign, BasicBlock *BB) {
-  assert((isl_set_is_params(Set) || BB) &&
+void Scop::recordAssumption(AssumptionKind Kind, isl::set Set, DebugLoc Loc,
+                            AssumptionSign Sign, BasicBlock *BB) {
+  assert((Set.is_params() || BB) &&
          "Assumptions without a basic block must be parameter sets");
   RecordedAssumptions.push_back({Kind, Sign, Set, Loc, BB});
 }
 
 void Scop::addRecordedAssumptions() {
   while (!RecordedAssumptions.empty()) {
-    const Assumption &AS = RecordedAssumptions.pop_back_val();
+    Assumption AS = RecordedAssumptions.pop_back_val();
 
     if (!AS.BB) {
       addAssumption(AS.Kind, AS.Set, AS.Loc, AS.Sign, nullptr /* BasicBlock */);
       continue;
     }
 
     // If the domain was deleted the assumptions are void.
     isl_set *Dom = getDomainConditions(AS.BB).release();
-    if (!Dom) {
-      isl_set_free(AS.Set);
+    if (!Dom)
       continue;
-    }
 
     // If a basic block was given use its domain to simplify the assumption.
     // In case of restrictions we know they only have to hold on the domain,
     // thus we can intersect them with the domain of the block. However, for
     // assumptions the domain has to imply them, thus:
     //                     _              _____
     //   Dom => S   <==>   A v B   <==>   A - B
     //
     // To avoid the complement we will register A - B as a restriction not an
     // assumption.
-    isl_set *S = AS.Set;
+    isl_set *S = AS.Set.copy();
     if (AS.Sign == AS_RESTRICTION)
       S = isl_set_params(isl_set_intersect(S, Dom));
     else /* (AS.Sign == AS_ASSUMPTION) */
       S = isl_set_params(isl_set_subtract(Dom, S));
 
-    addAssumption(AS.Kind, S, AS.Loc, AS_RESTRICTION, AS.BB);
+    addAssumption(AS.Kind, isl::manage(S), AS.Loc, AS_RESTRICTION, AS.BB);
   }
 }
 
 void Scop::invalidate(AssumptionKind Kind, DebugLoc Loc, BasicBlock *BB) {
   DEBUG(dbgs() << "Invalidate SCoP because of reason " << Kind << "\n");
-  addAssumption(Kind, isl_set_empty(getParamSpace().release()), Loc,
-                AS_ASSUMPTION, BB);
+  addAssumption(Kind, isl::set::empty(getParamSpace()), Loc, AS_ASSUMPTION, BB);
 }
 
-isl::set Scop::getInvalidContext() const {
-  return isl::manage(isl_set_copy(InvalidContext));
-}
+isl::set Scop::getInvalidContext() const { return InvalidContext; }
 
 void Scop::printContext(raw_ostream &OS) const {
   OS << "Context:\n";
   OS.indent(4) << Context << "\n";
 
   OS.indent(4) << "Assumed Context:\n";
   OS.indent(4) << AssumedContext << "\n";
 
void Scop::print(raw_ostream &OS, bool PrintInstructions) const {
   printAliasAssumptions(OS);
   printStatements(OS.indent(4), PrintInstructions);
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 LLVM_DUMP_METHOD void Scop::dump() const { print(dbgs(), true); }
 #endif
 
-isl_ctx *Scop::getIslCtx() const { return IslCtx.get(); }
+isl::ctx Scop::getIslCtx() const { return IslCtx.get(); }
 
 __isl_give PWACtx Scop::getPwAff(const SCEV *E, BasicBlock *BB,
                                  bool NonNegative) {
   // First try to use the SCEVAffinator to generate a piecewise defined
   // affine function from @p E in the context of @p BB. If that tasks becomes to
   // complex the affinator might return a nullptr. In such a case we invalidate
   // the SCoP and return a dummy value. This way we do not need to add error
   // handling code to all users of this function.
__isl_give PWACtx Scop::getPwAff(const SCEV *E, BasicBlock *BB,
   }
 
   auto DL = BB ? BB->getTerminator()->getDebugLoc() : DebugLoc();
   invalidate(COMPLEXITY, DL, BB);
   return Affinator.getPwAff(SE->getZero(E->getType()), BB);
 }
 
 isl::union_set Scop::getDomains() const {
-  isl_space *EmptySpace = isl_space_params_alloc(getIslCtx(), 0);
+  isl_space *EmptySpace = isl_space_params_alloc(getIslCtx().get(), 0);
   isl_union_set *Domain = isl_union_set_empty(EmptySpace);
 
   for (const ScopStmt &Stmt : *this)
     Domain = isl_union_set_add_set(Domain, Stmt.getDomain().release());
 
   return isl::manage(Domain);
 }
 

 // @return true if @p Node is an extension node.
 isl_bool isNotExtNode(__isl_keep isl_schedule_node *Node, void *User) {
   if (isl_schedule_node_get_type(Node) == isl_schedule_node_extension)
     return isl_bool_error;
   else
     return isl_bool_true;
 }
 
-bool Scop::containsExtensionNode(__isl_keep isl_schedule *Schedule) {
-  return isl_schedule_foreach_schedule_node_top_down(Schedule, isNotExtNode,
-                                                     nullptr) == isl_stat_error;
+bool Scop::containsExtensionNode(isl::schedule Schedule) {
+  return isl_schedule_foreach_schedule_node_top_down(
+             Schedule.keep(), isNotExtNode, nullptr) == isl_stat_error;
 }
 
 isl::union_map Scop::getSchedule() const {
-  auto *Tree = getScheduleTree().release();
-  if (containsExtensionNode(Tree)) {
-    isl_schedule_free(Tree);
+  auto Tree = getScheduleTree();
+  if (containsExtensionNode(Tree))
     return nullptr;
-  }
-  auto *S = isl_schedule_get_map(Tree);
-  isl_schedule_free(Tree);
-  return isl::manage(S);
+
+  return Tree.get_map();
 }
 
 isl::schedule Scop::getScheduleTree() const {
-  return isl::manage(isl_schedule_intersect_domain(isl_schedule_copy(Schedule),
-                                                   getDomains().release()));
+  return Schedule.intersect_domain(getDomains());
 }
 
-void Scop::setSchedule(__isl_take isl_union_map *NewSchedule) {
-  auto *S = isl_schedule_from_domain(getDomains().release());
-  S = isl_schedule_insert_partial_schedule(
-      S, isl_multi_union_pw_aff_from_union_map(NewSchedule));
-  isl_schedule_free(Schedule);
-  Schedule = S;
+void Scop::setSchedule(isl::union_map NewSchedule) {
+  auto S = isl::schedule::from_domain(getDomains());
+  Schedule = S.insert_partial_schedule(
+      isl::multi_union_pw_aff::from_union_map(NewSchedule));
 }
 
-void Scop::setScheduleTree(__isl_take isl_schedule *NewSchedule) {
-  isl_schedule_free(Schedule);
+void Scop::setScheduleTree(isl::schedule NewSchedule) {
   Schedule = NewSchedule;
 }
 
 bool Scop::restrictDomains(isl::union_set Domain) {
   bool Changed = false;
   for (ScopStmt &Stmt : *this) {
     isl::union_set StmtDomain = isl::union_set(Stmt.getDomain());
     isl::union_set NewStmtDomain = StmtDomain.intersect(Domain);
if (!isNonAffineSubRegion(LocalRegion)) {
       return;
     }
   }
 
   auto LoopData = LoopStack.rbegin();
   LoopData->NumBlocksProcessed += getNumBlocksInRegionNode(RN);
 
   for (auto *Stmt : getStmtListFor(RN)) {
-    auto *UDomain = isl_union_set_from_set(Stmt->getDomain().release());
-    auto *StmtSchedule = isl_schedule_from_domain(UDomain);
+    isl::union_set UDomain{Stmt->getDomain()};
+    auto StmtSchedule = isl::schedule::from_domain(UDomain);
     LoopData->Schedule = combineInSequence(LoopData->Schedule, StmtSchedule);
   }
 
   // Check if we just processed the last node in this loop. If we did, finalize
   // the loop by:
   //
   //   - adding new schedule dimensions
   //   - folding the resulting schedule into the parent loop schedule
   //   - dropping the loop schedule from the LoopStack.
   //
   // Then continue to check surrounding loops, which might also have been
   // completed by this node.
   auto Dimension = LoopStack.size();
   while (LoopData->L &&
          LoopData->NumBlocksProcessed == getNumBlocksInLoop(LoopData->L)) {
-    auto *Schedule = LoopData->Schedule;
+    isl::schedule Schedule = LoopData->Schedule;
     auto NumBlocksProcessed = LoopData->NumBlocksProcessed;
 
     assert(std::next(LoopData) != LoopStack.rend());
     ++LoopData;
     --Dimension;
 
     if (Schedule) {
-      isl::union_set Domain = give(isl_schedule_get_domain(Schedule));
+      isl::union_set Domain = Schedule.get_domain();
       isl::multi_union_pw_aff MUPA = mapToDimension(Domain, Dimension);
-      Schedule = isl_schedule_insert_partial_schedule(Schedule, MUPA.release());
+      Schedule = Schedule.insert_partial_schedule(MUPA);
       LoopData->Schedule = combineInSequence(LoopData->Schedule, Schedule);
     }
 
     LoopData->NumBlocksProcessed += NumBlocksProcessed;
   }
   LoopStack.erase(LoopStack.begin() + Dimension, LoopStack.end());
 }
 

lib/CodeGen/IslAst.cpp

static __isl_give isl_ast_node *AtEachDomain(__isl_take isl_ast_node *Node,
   return isl_ast_node_set_annotation(Node, Id);
 }
 
 // Build alias check condition given a pair of minimal/maximal access.
 static isl::ast_expr buildCondition(Scop &S, isl::ast_build Build,
                                     const Scop::MinMaxAccessTy *It0,
                                     const Scop::MinMaxAccessTy *It1) {
 
-  isl::pw_multi_aff AFirst = isl::manage(isl_pw_multi_aff_copy(It0->first));
-  isl::pw_multi_aff ASecond = isl::manage(isl_pw_multi_aff_copy(It0->second));
-  isl::pw_multi_aff BFirst = isl::manage(isl_pw_multi_aff_copy(It1->first));
-  isl::pw_multi_aff BSecond = isl::manage(isl_pw_multi_aff_copy(It1->second));
+  isl::pw_multi_aff AFirst = It0->first;
+  isl::pw_multi_aff ASecond = It0->second;
+  isl::pw_multi_aff BFirst = It1->first;
+  isl::pw_multi_aff BSecond = It1->second;
 
   isl::id Left = AFirst.get_tuple_id(isl::dim::set);
   isl::id Right = BFirst.get_tuple_id(isl::dim::set);
 
   isl::ast_expr True =
       isl::ast_expr::from_val(isl::val::int_from_ui(Build.get_ctx(), 1));
   isl::ast_expr False =
       isl::ast_expr::from_val(isl::val::int_from_ui(Build.get_ctx(), 0));

 
 void IslAst::init(const Dependences &D) {
   bool PerformParallelTest = PollyParallel || DetectParallel ||
                              PollyVectorizerChoice != VECTORIZER_NONE;
 
   // We can not perform the dependence analysis and, consequently,
   // the parallel code generation in case the schedule tree contains
   // extension nodes.
-  auto *ScheduleTree = S.getScheduleTree().release();
+  auto ScheduleTree = S.getScheduleTree();
   PerformParallelTest =
       PerformParallelTest && !S.containsExtensionNode(ScheduleTree);
-  isl_schedule_free(ScheduleTree);
 
   // Skip AST and code generation if there was no benefit achieved.
   if (!benefitsFromPolly(S, PerformParallelTest))
     return;
 
   auto ScopStats = S.getStatistics();
   ScopsBeneficial++;
   BeneficialAffineLoops += ScopStats.NumAffineLoops;
   BeneficialBoxedLoops += ScopStats.NumBoxedLoops;
 
-  isl_ctx *Ctx = S.getIslCtx();
-  isl_options_set_ast_build_atomic_upper_bound(Ctx, true);
-  isl_options_set_ast_build_detect_min_max(Ctx, true);
+  auto Ctx = S.getIslCtx();
+  isl_options_set_ast_build_atomic_upper_bound(Ctx.get(), true);
+  isl_options_set_ast_build_detect_min_max(Ctx.get(), true);
   isl_ast_build *Build;
   AstBuildUserInfo BuildInfo;
 
   if (UseContext)
     Build = isl_ast_build_from_context(S.getContext().release());
   else
     Build = isl_ast_build_from_context(
         isl_set_universe(S.getParamSpace().release()));

 
 isl_ast_build *IslAstInfo::getBuild(__isl_keep isl_ast_node *Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload ? Payload->Build : nullptr;
 }
 
 IslAstInfo IslAstAnalysis::run(Scop &S, ScopAnalysisManager &SAM,
                                ScopStandardAnalysisResults &SAR) {
-  return {S, SAM.getResult<DependenceAnalysis>(S, SAR).getDependences(
-                 Dependences::AL_Statement)};
+  return {S,
+          SAM.getResult<DependenceAnalysis>(S, SAR).getDependences(
 }
 
 static __isl_give isl_printer *cbPrintUser(__isl_take isl_printer *P,
                                            __isl_take isl_ast_print_options *O,
                                            __isl_keep isl_ast_node *Node,
                                            void *User) {
   isl::ast_node AstNode = isl::manage(isl_ast_node_copy(Node));
   isl::ast_expr NodeExpr = AstNode.user_get_expr();
OS << ":: This is either because no useful optimizations could be applied "
           "-polly-dependences-computeout=0 to set dependence analysis timeout "
           "to infinity)\n\n";
     return;
   }
 
   isl_ast_expr *RunCondition = Ast.getRunCondition();
   char *RtCStr, *AstStr;
 
-  Options = isl_ast_print_options_alloc(S.getIslCtx());
+  Options = isl_ast_print_options_alloc(S.getIslCtx().get());
 
   if (PrintAccesses)
     Options =
         isl_ast_print_options_set_print_user(Options, cbPrintUser, nullptr);
   Options = isl_ast_print_options_set_print_for(Options, cbPrintFor, nullptr);
 
-  isl_printer *P = isl_printer_to_str(S.getIslCtx());
+  isl_printer *P = isl_printer_to_str(S.getIslCtx().get());
   P = isl_printer_set_output_format(P, ISL_FORMAT_C);
   P = isl_printer_print_ast_expr(P, RunCondition);
   RtCStr = isl_printer_get_str(P);
   P = isl_printer_flush(P);
   P = isl_printer_indent(P, 4);
   P = isl_ast_node_print(RootNode, P, Options);
   AstStr = isl_printer_get_str(P);
 

lib/CodeGen/IslNodeBuilder.cpp

void IslNodeBuilder::createIf(__isl_take isl_ast_node *If) {
 
   IfConditions++;
 }
 
 __isl_give isl_id_to_ast_expr *
 IslNodeBuilder::createNewAccesses(ScopStmt *Stmt,
                                   __isl_keep isl_ast_node *Node) {
   isl_id_to_ast_expr *NewAccesses =
-      isl_id_to_ast_expr_alloc(Stmt->getParent()->getIslCtx(), 0);
+      isl_id_to_ast_expr_alloc(Stmt->getParent()->getIslCtx().get(), 0);
 
   auto *Build = IslAstInfo::getBuild(Node);
   assert(Build && "Could not obtain isl_ast_build from user node");
   Stmt->setAstBuild(isl::manage(isl_ast_build_copy(Build)));
 
   for (auto *MA : *Stmt) {
     if (!MA->hasNewAccessRelation()) {
       if (PollyGenerateExpressions) {
for (auto *Val : Values) {
           bool IsDead = true;
 
           // Check for "undef" loads first, then if there is a statement for
           // the parent of Inst and lastly if the parent of Inst has an empty
           // domain. In the first and last case the instruction is dead but if
           // there is a statement or the domain is not empty Inst is not dead.
           auto MemInst = MemAccInst::dyn_cast(Inst);
           auto Address = MemInst ? MemInst.getPointerOperand() : nullptr;
-          if (Address && SE.getUnknown(UndefValue::get(Address->getType())) ==
-                             SE.getPointerBase(SE.getSCEV(Address))) {
+          if (Address &&
+              SE.getUnknown(UndefValue::get(Address->getType())) ==
           } else if (S.getStmtFor(Inst)) {
             IsDead = false;
           } else {
             auto *Domain = S.getDomainConditions(Inst->getParent()).release();
             IsDead = isl_set_is_empty(Domain);
             isl_set_free(Domain);
           }
 
bool IslNodeBuilder::preloadInvariantEquivClass(
   // Check for recursion which can be caused by additional constraints, e.g.,
   // non-finite loop constraints. In such a case we have to bail out and insert
   // a "false" runtime check that will cause the original code to be executed.
   auto PtrId = std::make_pair(IAClass.IdentifyingPointer, IAClass.AccessType);
   if (!PreloadedPtrs.insert(PtrId).second)
     return false;
 
   // The execution context of the IAClass.
-  isl_set *&ExecutionCtx = IAClass.ExecutionContext;
+  isl::set &ExecutionCtx = IAClass.ExecutionContext;
 
   // If the base pointer of this class is dependent on another one we have to
   // make sure it was preloaded already.
   auto *SAI = MA->getScopArrayInfo();
   if (auto *BaseIAClass = S.lookupInvariantEquivClass(SAI->getBasePtr())) {
     if (!preloadInvariantEquivClass(*BaseIAClass))
       return false;
 
     // After we preloaded the BaseIAClass we adjusted the BaseExecutionCtx and
     // we need to refine the ExecutionCtx.
-    isl_set *BaseExecutionCtx = isl_set_copy(BaseIAClass->ExecutionContext);
-    ExecutionCtx = isl_set_intersect(ExecutionCtx, BaseExecutionCtx);
+    auto BaseExecutionCtx = BaseIAClass->ExecutionContext;
+    ExecutionCtx = ExecutionCtx.intersect(BaseExecutionCtx);
   }
 
   // If the size of a dimension is dependent on another class, make sure it is
   // preloaded.
   for (unsigned i = 1, e = SAI->getNumberOfDimensions(); i < e; ++i) {
     const SCEV *Dim = SAI->getDimensionSize(i);
     SetVector<Value *> Values;
     findValues(Dim, SE, Values);
     for (auto *Val : Values) {
       if (auto *BaseIAClass = S.lookupInvariantEquivClass(Val)) {
         if (!preloadInvariantEquivClass(*BaseIAClass))
           return false;
 
         // After we preloaded the BaseIAClass we adjusted the BaseExecutionCtx
         // and we need to refine the ExecutionCtx.
-        isl_set *BaseExecutionCtx = isl_set_copy(BaseIAClass->ExecutionContext);
-        ExecutionCtx = isl_set_intersect(ExecutionCtx, BaseExecutionCtx);
+        auto BaseExecutionCtx = BaseIAClass->ExecutionContext;
+        ExecutionCtx = ExecutionCtx.intersect(BaseExecutionCtx);
       }
     }
   }
 
   Instruction *AccInst = MA->getAccessInstruction();
   Type *AccInstTy = AccInst->getType();
 
-  Value *PreloadVal = preloadInvariantLoad(*MA, isl_set_copy(ExecutionCtx));
+  Value *PreloadVal = preloadInvariantLoad(*MA, ExecutionCtx.copy());
   if (!PreloadVal)
     return false;
 
   for (const MemoryAccess *MA : MAs) {
     Instruction *MAAccInst = MA->getAccessInstruction();
     assert(PreloadVal->getType() == MAAccInst->getType());
     ValueMap[MAAccInst] = PreloadVal;
   }

lib/CodeGen/PPCGCodeGeneration.cpp

if (Var.type == ppcg_access_shared) {
       Allocation = GlobalVar;
     } else if (Var.type == ppcg_access_private) {
       Allocation = Builder.CreateAlloca(ArrayTy, 0, "private_array");
     } else {
       llvm_unreachable("unknown variable type");
     }
     SAI =
         S.getOrCreateScopArrayInfo(Allocation, EleTy, Sizes, MemoryKind::Array);
-    Id = isl_id_alloc(S.getIslCtx(), Var.name, nullptr);
+    Id = isl_id_alloc(S.getIslCtx().get(), Var.name, nullptr);
     IDToValue[Id] = Allocation;
     LocalArrays.push_back(Allocation);
     KernelIds.push_back(Id);
     IDToSAI[Id] = SAI;
   }
 }
 
 void GPUNodeBuilder::createKernelFunction(
public:
   /// source-to-source compilation each of these isl_ids is mapped to the
   /// expression that represents it. As we do not have a corresponding
   /// expression in Polly, we just map each id to a 'zero' expression to match
   /// the data format that ppcg expects.
   ///
   /// @returns Retun a map from collected ids to 'zero' ast expressions.
   __isl_give isl_id_to_ast_expr *getNames() {
     auto *Names = isl_id_to_ast_expr_alloc(
-        S->getIslCtx(),
+        S->getIslCtx().get(),
         S->getNumParams() + std::distance(S->array_begin(), S->array_end()));
-    auto *Zero = isl_ast_expr_from_val(isl_val_zero(S->getIslCtx()));
+    auto *Zero = isl_ast_expr_from_val(isl_val_zero(S->getIslCtx().get()));
 
     for (const SCEV *P : S->parameters()) {
       isl_id *Id = S->getIdForParam(P).release();
       Names = isl_id_to_ast_expr_set(Names, Id, isl_ast_expr_copy(Zero));
     }
 
     for (auto &Array : S->arrays()) {
       auto Id = Array->getBasePtrId().release();
public:
   ///
   /// @param Stmt The statement for which to collect the accesses.
   ///
   /// @returns A list of array accesses.
   gpu_stmt_access *getStmtAccesses(ScopStmt &Stmt) {
     gpu_stmt_access *Accesses = nullptr;
 
     for (MemoryAccess *Acc : Stmt) {
-      auto Access = isl_alloc_type(S->getIslCtx(), struct gpu_stmt_access);
+      auto Access =
+          isl_alloc_type(S->getIslCtx().get(), struct gpu_stmt_access);
       Access->read = Acc->isRead();
       Access->write = Acc->isWrite();
       Access->access = Acc->getAccessRelation().release();
       isl_space *Space = isl_map_get_space(Access->access);
       Space = isl_space_range(Space);
       Space = isl_space_from_range(Space);
       Space = isl_space_set_tuple_id(Space, isl_dim_in, Acc->getId().release());
       isl_map *Universe = isl_map_universe(Space);
public:
   ///
   /// Each statement has an id, a pointer to the underlying data structure,
   /// as well as a list with all memory accesses.
   ///
   /// TODO: Initialize the list of memory accesses.
   ///
   /// @returns A linked-list of statements.
   gpu_stmt *getStatements() {
-    gpu_stmt *Stmts = isl_calloc_array(S->getIslCtx(), struct gpu_stmt,
+    gpu_stmt *Stmts = isl_calloc_array(S->getIslCtx().get(), struct gpu_stmt,
                                        std::distance(S->begin(), S->end()));
 
     int i = 0;
     for (auto &Stmt : *S) {
       gpu_stmt *GPUStmt = &Stmts[i];
 
       GPUStmt->id = Stmt.getDomainId().release();
 
void setArrayBounds(gpu_array_info &PPCGArray, ScopArrayInfo *Array) {
     isl_space *AlignSpace = nullptr;
     std::vector<isl_pw_aff *> AlignedBounds;
     std::tie(AlignSpace, AlignedBounds) =
         alignPwAffs(std::move(Bounds), SeedAlignSpace);
 
     assert(AlignSpace && "alignPwAffs did not initialise AlignSpace");
 
     isl_pw_aff_list *BoundsList =
-        createPwAffList(S->getIslCtx(), std::move(AlignedBounds));
+        createPwAffList(S->getIslCtx().get(), std::move(AlignedBounds));
 
     isl_space *BoundsSpace = isl_set_get_space(PPCGArray.extent);
     BoundsSpace = isl_space_align_params(BoundsSpace, AlignSpace);
 
     assert(BoundsSpace && "Unable to access space of array.");
     assert(BoundsList && "Unable to access list of bounds.");
 
     PPCGArray.bound =
public:
   /// Create a default-initialized PPCG GPU program.
   ///
   /// @returns A new gpu program description.
   gpu_prog *createPPCGProg(ppcg_scop *PPCGScop) {
 
     if (!PPCGScop)
       return nullptr;
 
-    auto PPCGProg = isl_calloc_type(S->getIslCtx(), struct gpu_prog);
+    auto PPCGProg = isl_calloc_type(S->getIslCtx().get(), struct gpu_prog);
 
-    PPCGProg->ctx = S->getIslCtx();
+    PPCGProg->ctx = S->getIslCtx().get();
     PPCGProg->scop = PPCGScop;
     PPCGProg->context = isl_set_copy(PPCGScop->context);
     PPCGProg->read = isl_union_map_copy(PPCGScop->reads);
     PPCGProg->may_write = isl_union_map_copy(PPCGScop->may_writes);
     PPCGProg->must_write = isl_union_map_copy(PPCGScop->must_writes);
     PPCGProg->tagged_must_kill =
         isl_union_map_copy(PPCGScop->tagged_must_kills);
     PPCGProg->to_inner = getArrayIdentity();
auto ValidSAIsRange =
         make_filter_range(S->arrays(), [this](ScopArrayInfo *SAI) -> bool {
           return !getExtent(SAI).is_empty();
         });
     SmallVector<ScopArrayInfo *, 4> ValidSAIs(ValidSAIsRange.begin(),
                                               ValidSAIsRange.end());
 
     PPCGProg->n_array =
         ValidSAIs.size(); // std::distance(S->array_begin(), S->array_end());
-    PPCGProg->array = isl_calloc_array(S->getIslCtx(), struct gpu_array_info,
+    PPCGProg->array = isl_calloc_array(S->getIslCtx().get(), struct gpu_array_info,
                                        PPCGProg->n_array);
 
     createArrays(PPCGProg, ValidSAIs);
 
     PPCGProg->array_order = nullptr;
     collect_order_dependences(PPCGProg);
 
     PPCGProg->may_persist = compute_may_persist(PPCGProg);
printHostUser(__isl_take isl_printer *P,
 
     return print_host_user(P, Options, Node, User);
   }
 
   /// Print C code corresponding to the control flow in @p Kernel.
   ///
   /// @param Kernel The kernel to print
   void printKernel(ppcg_kernel *Kernel) {
-    auto *P = isl_printer_to_str(S->getIslCtx());
+    auto *P = isl_printer_to_str(S->getIslCtx().get());
     P = isl_printer_set_output_format(P, ISL_FORMAT_C);
-    auto *Options = isl_ast_print_options_alloc(S->getIslCtx());
+    auto *Options = isl_ast_print_options_alloc(S->getIslCtx().get());
     P = isl_ast_node_print(Kernel->tree, P, Options);
     char *String = isl_printer_get_str(P);
     printf("%s\n", String);
     free(String);
     isl_printer_free(P);
   }
 
   /// Print C code corresponding to the GPU code described by @p Tree.
   ///
   /// @param Tree An AST describing GPU code
   /// @param PPCGProg The PPCG program from which @Tree has been constructed.
   void printGPUTree(isl_ast_node *Tree, gpu_prog *PPCGProg) {
-    auto *P = isl_printer_to_str(S->getIslCtx());
+    auto *P = isl_printer_to_str(S->getIslCtx().get());
     P = isl_printer_set_output_format(P, ISL_FORMAT_C);
 
     PrintGPUUserData Data;
     Data.PPCGProg = PPCGProg;
 
-    auto *Options = isl_ast_print_options_alloc(S->getIslCtx());
+    auto *Options = isl_ast_print_options_alloc(S->getIslCtx().get());
     Options =
         isl_ast_print_options_set_print_user(Options, printHostUser, &Data);
     P = isl_ast_node_print(Tree, P, Options);
     char *String = isl_printer_get_str(P);
     printf("# host\n");
     printf("%s\n", String);
     free(String);
     isl_printer_free(P);
public:
   //  2) Map schedule to GPU (TODO)
   //  3) Generate code for new schedule (TODO)
   //
   // We do not use here the Polly ScheduleOptimizer, as the schedule optimizer
   // is mostly CPU specific. Instead, we use PPCG's GPU code generation
   // strategy directly from this pass.
   gpu_gen *generateGPU(ppcg_scop *PPCGScop, gpu_prog *PPCGProg) {
 
-    auto PPCGGen = isl_calloc_type(S->getIslCtx(), struct gpu_gen);
+    auto PPCGGen = isl_calloc_type(S->getIslCtx().get(), struct gpu_gen);
 
-    PPCGGen->ctx = S->getIslCtx();
+    PPCGGen->ctx = S->getIslCtx().get();
     PPCGGen->options = PPCGScop->options;
     PPCGGen->print = nullptr;
     PPCGGen->print_user = nullptr;
     PPCGGen->build_ast_expr = &pollyBuildAstExprForStmt;
     PPCGGen->prog = PPCGProg;
     PPCGGen->tree = nullptr;
     PPCGGen->types.n = 0;
     PPCGGen->types.name = nullptr;
if (!has_permutable || has_permutable < 0) {
                    << " does not have permutable bands. Bailing out\n";);
     } else {
       const bool CreateTransferToFromDevice = !PollyManagedMemory;
       Schedule = map_to_device(PPCGGen, Schedule, CreateTransferToFromDevice);
       PPCGGen->tree = generate_code(PPCGGen, isl_schedule_copy(Schedule));
     }
 
     if (DumpSchedule) {
-      isl_printer *P = isl_printer_to_str(S->getIslCtx());
+      isl_printer *P = isl_printer_to_str(S->getIslCtx().get());
       P = isl_printer_set_yaml_style(P, ISL_YAML_STYLE_BLOCK);
       P = isl_printer_print_str(P, "Schedule\n");
       P = isl_printer_print_str(P, "========\n");
       if (Schedule)
         P = isl_printer_print_schedule(P, Schedule);
       else
         P = isl_printer_print_str(P, "No schedule found\n");
 
__isl_give isl_ast_expr *approxDynamicInst(ScopStmt &Stmt,
     } else {
       auto *R = Stmt.getRegion();
 
       for (auto *BB : R->blocks()) {
         InstCount += std::distance(BB->begin(), BB->end());
       }
     }
 
-    isl_val *InstVal = isl_val_int_from_si(S->getIslCtx(), InstCount);
+    isl_val *InstVal = isl_val_int_from_si(S->getIslCtx().get(), InstCount);
     auto *InstExpr = isl_ast_expr_from_val(InstVal);
     return isl_ast_expr_mul(InstExpr, Iterations);
   }
 
   /// Approximate dynamic instructions executed in scop.
   ///
   /// @param S     The scop for which to approximate dynamic instructions.
   /// @param Build The isl ast build object to use for creating the ast
   ///              expression.
   /// @returns An approximation of the number of dynamic instructions executed
   ///          in @p S.
   __isl_give isl_ast_expr *
   getNumberOfIterations(Scop &S, __isl_keep isl_ast_build *Build) {
     isl_ast_expr *Instructions;
 
-    isl_val *Zero = isl_val_int_from_si(S.getIslCtx(), 0);
+    isl_val *Zero = isl_val_int_from_si(S.getIslCtx().get(), 0);
     Instructions = isl_ast_expr_from_val(Zero);
 
     for (ScopStmt &Stmt : S) {
       isl_ast_expr *StmtInstructions = approxDynamicInst(Stmt, Build);
       Instructions = isl_ast_expr_add(Instructions, StmtInstructions);
     }
     return Instructions;
   }
 
   /// Create a check that ensures sufficient compute in scop.
   ///
   /// @param S     The scop for which to ensure sufficient compute.
   /// @param Build The isl ast build object to use for creating the ast
   ///              expression.
   /// @returns An expression that evaluates to TRUE in case of sufficient
   ///          compute and to FALSE, otherwise.
   __isl_give isl_ast_expr *
   createSufficientComputeCheck(Scop &S, __isl_keep isl_ast_build *Build) {
     auto Iterations = getNumberOfIterations(S, Build);
-    auto *MinComputeVal = isl_val_int_from_si(S.getIslCtx(), MinCompute);
+    auto *MinComputeVal = isl_val_int_from_si(S.getIslCtx().get(), MinCompute);
     auto *MinComputeExpr = isl_ast_expr_from_val(MinComputeVal);
     return isl_ast_expr_ge(Iterations, MinComputeExpr);
   }
 
   /// Check if the basic block contains a function we cannot codegen for GPU
   /// kernels.
   ///
   /// If this basic block does something with a `Function` other than calling
void generateCode(__isl_take isl_ast_node *Root, gpu_prog *Prog) {
 
     GPUNodeBuilder NodeBuilder(Builder, Annotator, *DL, *LI, *SE, *DT, *S,
                                StartBlock, Prog, Runtime, Architecture);
 
     // TODO: Handle LICM
     auto SplitBlock = StartBlock->getSinglePredecessor();
     Builder.SetInsertPoint(SplitBlock->getTerminator());
 
-    isl_ast_build *Build = isl_ast_build_alloc(S->getIslCtx());
+    isl_ast_build *Build = isl_ast_build_alloc(S->getIslCtx().get());
     isl_ast_expr *Condition = IslAst::buildRunCondition(*S, Build);
     isl_ast_expr *SufficientCompute = createSufficientComputeCheck(*S, Build);
     Condition = isl_ast_expr_and(Condition, SufficientCompute);
     isl_ast_build_free(Build);
 
     // preload invariant loads. Note: This should happen before the RTC
     // because the RTC may depend on values that are invariant load hoisted.
     if (!NodeBuilder.preloadInvariantLoads()) {

lib/Exchange/JSONExporter.cpp

 
 /// Import a new context from JScop.
 ///
 /// @param S The scop to update.
 /// @param JScop The JScop file describing the new schedule.
 ///
 /// @returns True if the import succeeded, otherwise False.
 static bool importContext(Scop &S, Json::Value &JScop) {
-  isl_set *OldContext = S.getContext().release();
+  isl::set OldContext = S.getContext();
 
   // Check if key 'context' is present.
   if (!JScop.isMember("context")) {
     errs() << "JScop file has no key named 'context'.\n";
-    isl_set_free(OldContext);
     return false;
   }
 
-  isl_set *NewContext =
-      isl_set_read_from_str(S.getIslCtx(), JScop["context"].asCString());
+  isl::set NewContext =
+      isl::set{S.getIslCtx().get(), JScop["context"].asString()};
 
   // Check whether the context was parsed successfully.
   if (!NewContext) {
     errs() << "The context was not parsed successfully by ISL.\n";
-    isl_set_free(NewContext);
-    isl_set_free(OldContext);
     return false;
   }
 
   // Check if the isl_set is a parameter set.
-  if (!isl_set_is_params(NewContext)) {
+  if (!NewContext.is_params()) {
     errs() << "The isl_set is not a parameter set.\n";
-    isl_set_free(NewContext);
-    isl_set_free(OldContext);
     return false;
   }
 
-  unsigned OldContextDim = isl_set_dim(OldContext, isl_dim_param);
-  unsigned NewContextDim = isl_set_dim(NewContext, isl_dim_param);
+  unsigned OldContextDim = OldContext.dim(isl::dim::param);
+  unsigned NewContextDim = NewContext.dim(isl::dim::param);
 
   // Check if the imported context has the right number of parameters.
   if (OldContextDim != NewContextDim) {
     errs() << "Imported context has the wrong number of parameters : "
            << "Found " << NewContextDim << " Expected " << OldContextDim
            << "\n";
-    isl_set_free(NewContext);
-    isl_set_free(OldContext);
     return false;
   }
 
   for (unsigned i = 0; i < OldContextDim; i++) {
-    isl_id *Id = isl_set_get_dim_id(OldContext, isl_dim_param, i);
-    NewContext = isl_set_set_dim_id(NewContext, isl_dim_param, i, Id);
+    isl::id Id = OldContext.get_dim_id(isl::dim::param, i);
+    NewContext = NewContext.set_dim_id(isl::dim::param, i, Id);
   }
 
-  isl_set_free(OldContext);
   S.setContext(NewContext);
   return true;
 }
 
 /// Import a new schedule from JScop.
 ///
 /// ... and verify that the new schedule does preserve existing data
 /// dependences.
if (!statements[Index].isMember("schedule")) {
       for (auto Element : NewSchedule) {
         isl_map_free(Element.second);
       }
       return false;
     }
     Json::Value Schedule = statements[Index]["schedule"];
     assert(!Schedule.asString().empty() &&
            "Schedules that contain extension nodes require special handling.");
-    isl_map *Map = isl_map_read_from_str(S.getIslCtx(), Schedule.asCString());
+    isl_map *Map =
+        isl_map_read_from_str(S.getIslCtx().get(), Schedule.asCString());
 
     // Check whether the schedule was parsed successfully
     if (!Map) {
       errs() << "The schedule was not parsed successfully (index = " << Index
              << ").\n";
       for (auto Element : NewSchedule) {
         isl_map_free(Element.second);
       }
static bool importSchedule(Scop &S, Json::Value &JScop, const Dependences &D) {
   if (!D.isValidSchedule(S, &NewSchedule)) {
     errs() << "JScop file contains a schedule that changes the "
            << "dependences. Use -disable-polly-legality to continue anyways\n";
     for (auto Element : NewSchedule)
       isl_map_free(Element.second);
     return false;
   }
 
-  auto ScheduleMap = isl_union_map_empty(S.getParamSpace().release());
+  auto ScheduleMap = isl::union_map::empty(S.getParamSpace());
   for (ScopStmt &Stmt : S) {
     if (NewSchedule.find(&Stmt) != NewSchedule.end())
-      ScheduleMap = isl_union_map_add_map(ScheduleMap, NewSchedule[&Stmt]);
+      ScheduleMap = ScheduleMap.add_map(isl::manage(NewSchedule[&Stmt]));
     else
-      ScheduleMap =
-          isl_union_map_add_map(ScheduleMap, Stmt.getSchedule().release());
+      ScheduleMap = ScheduleMap.add_map(Stmt.getSchedule());
   }
 
   S.setSchedule(ScheduleMap);
 
   return true;
 }
 
 /// Import new memory accesses from JScop.
for (MemoryAccess *MA : Stmt) {
       if (!JsonMemoryAccess.isMember("relation")) {
         errs() << "Memory access number " << MemoryAccessIdx
                << " has no key name 'relation' for statement number "
                << StatementIdx << ".\n";
         return false;
       }
       Json::Value Accesses = JsonMemoryAccess["relation"];
       isl_map *NewAccessMap =
-          isl_map_read_from_str(S.getIslCtx(), Accesses.asCString());
+          isl_map_read_from_str(S.getIslCtx().get(), Accesses.asCString());
 
       // Check whether the access was parsed successfully
       if (!NewAccessMap) {
         errs() << "The access was not parsed successfully by ISL.\n";
         return false;
       }
       isl_map *CurrentAccessMap = MA->getAccessRelation().release();
 

lib/Support/GICHelper.cpp

 #include "isl/space.h"
 #include "isl/union_map.h"
 #include "isl/union_set.h"
 #include "isl/val.h"
 
 #include <climits>
 
 using namespace llvm;
+using namespace polly;
 
 __isl_give isl_val *polly::isl_valFromAPInt(isl_ctx *Ctx, const APInt Int,
                                             bool IsSigned) {
   APInt Abs;
   isl_val *v;
 
   // As isl is interpreting the input always as unsigned value, we need some
   // additional pre and post processing to import signed values. The approach

lib/Support/SCEVAffinator.cpp

static __isl_give isl_pw_aff *getWidthExpValOnDomain(unsigned Width,
                                                      __isl_take isl_set *Dom) {
   auto *Ctx = isl_set_get_ctx(Dom);
   auto *WidthVal = isl_val_int_from_ui(Ctx, Width);
   auto *ExpVal = isl_val_2exp(WidthVal);
   return isl_pw_aff_val_on_domain(Dom, ExpVal);
 }
 
 SCEVAffinator::SCEVAffinator(Scop *S, LoopInfo &LI)
-    : S(S), Ctx(S->getIslCtx()), SE(*S->getSE()), LI(LI),
+    : S(S), Ctx(S->getIslCtx().get()), SE(*S->getSE()), LI(LI),
       TD(S->getFunction().getParent()->getDataLayout()) {}
 
 SCEVAffinator::~SCEVAffinator() {
   for (auto &CachedPair : CachedExpressions)
     freePWACtx(CachedPair.second);
 }
 
 Loop *SCEVAffinator::getScope() { return BB ? LI.getLoopFor(BB) : nullptr; }

 }
 
 void SCEVAffinator::takeNonNegativeAssumption(PWACtx &PWAC) {
   auto *NegPWA = isl_pw_aff_neg(isl_pw_aff_copy(PWAC.first));
   auto *NegDom = isl_pw_aff_pos_set(NegPWA);
   PWAC.second = isl_set_union(PWAC.second, isl_set_copy(NegDom));
   auto *Restriction = BB ? NegDom : isl_set_params(NegDom);
   auto DL = BB ? BB->getTerminator()->getDebugLoc() : DebugLoc();
-  S->recordAssumption(UNSIGNED, Restriction, DL, AS_RESTRICTION, BB);
+  S->recordAssumption(UNSIGNED, isl::manage(Restriction), DL, AS_RESTRICTION, BB);
 }
 
 __isl_give PWACtx SCEVAffinator::getPWACtxFromPWA(__isl_take isl_pw_aff *PWA) {
   return std::make_pair(
       PWA, isl_set_empty(isl_space_set_alloc(Ctx, 0, NumIterators)));
 }
 
 __isl_give PWACtx SCEVAffinator::getPwAff(const SCEV *Expr, BasicBlock *BB) {
__isl_give PWACtx SCEVAffinator::checkForWrapping(const SCEV *Expr,
 
   const DebugLoc &Loc = BB ? BB->getTerminator()->getDebugLoc() : DebugLoc();
   NotEqualSet = BB ? NotEqualSet : isl_set_params(NotEqualSet);
   NotEqualSet = isl_set_coalesce(NotEqualSet);
 
   if (isl_set_is_empty(NotEqualSet))
     isl_set_free(NotEqualSet);
   else
-    S->recordAssumption(WRAPPING, NotEqualSet, Loc, AS_RESTRICTION, BB);
+    S->recordAssumption(WRAPPING, isl::manage(NotEqualSet), Loc, AS_RESTRICTION, BB);
 
   return PWAC;
 }
 
 __isl_give isl_pw_aff *
 SCEVAffinator::addModuloSemantic(__isl_take isl_pw_aff *PWA,
                                  Type *ExprType) const {
   unsigned Width = TD.getTypeSizeInBits(ExprType);
SCEVAffinator::visitTruncateExpr(const SCEVTruncateExpr *Expr) {
   OpPWAC.second = isl_set_union(OpPWAC.second, isl_set_copy(OutOfBoundsDom));
 
   if (!BB) {
     assert(isl_set_dim(OutOfBoundsDom, isl_dim_set) == 0 &&
            "Expected a zero dimensional set for non-basic-block domains");
     OutOfBoundsDom = isl_set_params(OutOfBoundsDom);
   }
 
-  S->recordAssumption(UNSIGNED, OutOfBoundsDom, DebugLoc(), AS_RESTRICTION, BB);
+  S->recordAssumption(UNSIGNED, isl::manage(OutOfBoundsDom), DebugLoc(), AS_RESTRICTION, BB);
 
   return OpPWAC;
 }
 
 __isl_give PWACtx
 SCEVAffinator::visitZeroExtendExpr(const SCEVZeroExtendExpr *Expr) {
   // A zero-extended value can be interpreted as a piecewise defined signed
   // value. If the value was non-negative it stays the same, otherwise it

lib/Transform/FlattenSchedule.cpp

virtual bool runOnScop(Scop &S) override {
 
     DEBUG(dbgs() << "Flattened new schedule:\n");
     DEBUG(printSchedule(dbgs(), NewSchedule, 2));
 
     NewSchedule = NewSchedule.gist_domain(Domains);
     DEBUG(dbgs() << "Gisted, flattened new schedule:\n");
     DEBUG(printSchedule(dbgs(), NewSchedule, 2));
 
-    S.setSchedule(NewSchedule.take());
+    S.setSchedule(NewSchedule);
     return false;
   }
 
   virtual void printScop(raw_ostream &OS, Scop &S) const override {
     OS << "Schedule before flattening {\n";
     printSchedule(OS, OldSchedule, 4);
     OS << "}\n\n";
 

lib/Transform/ForwardOpTree.cpp

public:
 
   bool runOnScop(Scop &S) override {
     // Free resources for previous SCoP's computation, if not yet done.
     releaseMemory();
 
     LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
 
     {
-      IslMaxOperationsGuard MaxOpGuard(S.getIslCtx(), MaxOps, false);
+      IslMaxOperationsGuard MaxOpGuard(S.getIslCtx().get(), MaxOps, false);
       Impl = llvm::make_unique<ForwardOpTreeImpl>(&S, &LI, MaxOpGuard);
 
       if (AnalyzeKnown) {
         DEBUG(dbgs() << "Prepare forwarders...\n");
         Impl->computeKnownValues();
       }
 
       DEBUG(dbgs() << "Forwarding operand trees...\n");

lib/Transform/ScheduleOptimizer.cpp

static isl::set addExtentConstraints(isl::set Set, int VectorWidth) {
   ExtConstr = ExtConstr.set_coefficient_si(isl::dim::set, Dims - 1, 1);
   Set = Set.add_constraint(ExtConstr);
   ExtConstr = isl::constraint::alloc_inequality(LocalSpace);
   ExtConstr = ExtConstr.set_constant_si(VectorWidth - 1);
   ExtConstr = ExtConstr.set_coefficient_si(isl::dim::set, Dims - 1, -1);
   return Set.add_constraint(ExtConstr);
 }
 
-isl::set getPartialTilePrefixes(isl::set ScheduleRange, int VectorWidth) {
+isl::set polly::getPartialTilePrefixes(isl::set ScheduleRange, int VectorWidth) {
   unsigned Dims = ScheduleRange.dim(isl::dim::set);
   isl::set LoopPrefixes =
       ScheduleRange.drop_constraints_involving_dims(isl::dim::set, Dims - 1, 1);
   auto ExtentPrefixes = addExtentConstraints(LoopPrefixes, VectorWidth);
   isl::set BadPrefixes = ExtentPrefixes.subtract(ScheduleRange);
   BadPrefixes = BadPrefixes.project_out(isl::dim::set, Dims - 1, 1);
   LoopPrefixes = LoopPrefixes.project_out(isl::dim::set, Dims - 1, 1);
   return LoopPrefixes.subtract(BadPrefixes);
bool ScheduleTreeOptimizer::isProfitableSchedule(Scop &S,
   // has changed at all.
   // TODO: We can improve this by tracking if any necessarily beneficial
   // transformations have been performed. This can e.g. be tiling, loop
   // interchange, or ...) We can track this either at the place where the
   // transformation has been performed or, in case of automatic ILP based
   // optimizations, by comparing (yet to be defined) performance metrics
   // before/after the scheduling optimizer
   // (e.g., #stride-one accesses)
-  if (S.containsExtensionNode(NewSchedule.get()))
+  if (S.containsExtensionNode(NewSchedule))
     return true;
   auto NewScheduleMap = NewSchedule.get_map();
   auto OldSchedule = S.getSchedule();
   assert(OldSchedule && "Only IslScheduleOptimizer can insert extension nodes "
                         "that make Scop::getSchedule() return nullptr.");
   bool changed = !OldSchedule.is_equal(NewScheduleMap);
   return changed;
 }
bool IslScheduleOptimizer::runOnScop(Scop &S) {
   } else if (OuterCoincidence == "no") {
     IslOuterCoincidence = 0;
   } else {
     errs() << "warning: Option -polly-opt-outer-coincidence should either be "
               "'yes' or 'no'. Falling back to default: 'no'\n";
     IslOuterCoincidence = 0;
   }
 
-  isl_ctx *Ctx = S.getIslCtx();
+  isl_ctx *Ctx = S.getIslCtx().get();
 
   isl_options_set_schedule_outer_coincidence(Ctx, IslOuterCoincidence);
   isl_options_set_schedule_serialize_sccs(Ctx, IslSerializeSCCs);
   isl_options_set_schedule_maximize_band_depth(Ctx, IslMaximizeBands);
   isl_options_set_schedule_max_constant_term(Ctx, MaxConstantTerm);
   isl_options_set_schedule_max_coefficient(Ctx, MaxCoefficient);
   isl_options_set_tile_scale_tile_loops(Ctx, 0);
 
bool IslScheduleOptimizer::runOnScop(Scop &S) {
   if (!ScheduleTreeOptimizer::isProfitableSchedule(S, NewSchedule))
     return false;
 
   auto ScopStats = S.getStatistics();
   ScopsOptimized++;
   NumAffineLoopsOptimized += ScopStats.NumAffineLoops;
   NumBoxedLoopsOptimized += ScopStats.NumBoxedLoops;
 
-  S.setScheduleTree(NewSchedule.release());
+  S.setScheduleTree(NewSchedule);
   S.markAsOptimized();
 
   if (OptimizedScops)
     errs() << S;
 
   return false;
 }
 

lib/Transform/Simplify.cpp

for (auto &Stmt : *S) {
       // its hashtable implementation. llvm::Values are only compared within a
       // ScopStmt, so the map can be local to this scope. TODO: Refactor with
       // ZoneAlgorithm::makeValueSet()
       SmallDenseMap<Value *, isl::set> ValueSets;
       auto makeValueSet = [&ValueSets, this](Value *V) -> isl::set {
         assert(V);
         isl::set &Result = ValueSets[V];
         if (Result.is_null()) {
-          isl_ctx *Ctx = S->getIslCtx();
+          isl::ctx Ctx = S->getIslCtx();
           std::string Name =
               getIslCompatibleName("Val", V, ValueSets.size() - 1,
                                    std::string(), UseInstructionNames);
-          isl::id Id = give(isl_id_alloc(Ctx, Name.c_str(), V));
+          isl::id Id = isl::id::alloc(Ctx, Name, V);
           Result = isl::set::universe(
               isl::space(Ctx, 0, 0).set_tuple_id(isl::dim::set, Id));
         }
         return Result;
       };
 
       // List of all eligible (for coalescing) writes of the future.
       // { [Domain[] -> Element[]] -> [Value[] -> MemoryAccess[]] }
private:
   /// element.
   void removeRedundantWrites() {
     for (auto &Stmt : *S) {
       SmallDenseMap<Value *, isl::set> ValueSets;
       auto makeValueSet = [&ValueSets, this](Value *V) -> isl::set {
         assert(V);
         isl::set &Result = ValueSets[V];
         if (Result.is_null()) {
-          isl_ctx *Ctx = S->getIslCtx();
+          isl_ctx *Ctx = S->getIslCtx().get();
           std::string Name =
               getIslCompatibleName("Val", V, ValueSets.size() - 1,
                                    std::string(), UseInstructionNames);
           isl::id Id = give(isl_id_alloc(Ctx, Name.c_str(), V));
           Result = isl::set::universe(
               isl::space(Ctx, 0, 0).set_tuple_id(isl::dim::set, Id));
         }
         return Result;

unittests/ScheduleOptimizer/ScheduleOptimizerTest.cpp

 //===- ScheduleOptimizerTest.cpp ------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "polly/ScheduleOptimizer.h"
 #include "gtest/gtest.h"
 #include "isl/stream.h"
 #include "isl/val.h"
 
+using namespace polly;
 using namespace isl;
 namespace {
 
 TEST(ScheduleOptimizer, getPartialTilePrefixes) {
 
   isl_ctx *ctx = isl_ctx_alloc();
 
   {