[polly] In IslNodeBuilder::addParameters() use isl::noexception bindings [NFC]

[refactormyself]

Summary

C++ bindings in isl_noexception provide better pointer management.
This allows the use of convenient memory management tools in C++.

• Replace the isl C entities with isl_noexception bindings
• Refactor calls to this function

No functional changes were made.

[Meinersbur]

polly/lib/CodeGen/CodeGeneration.cpp

270

manage( .release()) is redundant: release() removes the smart pointer just for manage() to put it into into a new one.

polly/include/polly/CodeGen/IslNodeBuilder.h

IslNodeBuilder(PollyIRBuilder &Builder, ScopAnnotator &Annotator,
                     StartBlock),
         BlockGen(Builder, LI, SE, DT, ScalarMap, EscapeMap, ValueMap,
                  &ExprBuilder, StartBlock),
         RegionGen(BlockGen), DL(DL), LI(LI), SE(SE), DT(DT),
         StartBlock(StartBlock) {}
 
   virtual ~IslNodeBuilder() = default;
 
-  void addParameters(__isl_take isl_set *Context);
+  void addParameters(isl::set Context);
 
   /// Create Values which hold the sizes of the outermost dimension of all
   /// Fortran arrays in the current scop.
   ///
   /// @returns False, if a problem occurred and a Fortran array was not
   /// materialized. True otherwise.
   bool materializeFortranArrayOutermostDimension();
 

polly/lib/CodeGen/CodeGeneration.cpp

if (!NodeBuilder.preloadInvariantLoads()) {
     assert(MergeBlock);
     markBlockUnreachable(*StartBlock, Builder);
     markBlockUnreachable(*ExitingBlock, Builder);
     auto *ExitingBB = S.getExitingBlock();
     assert(ExitingBB);
     DT.changeImmediateDominator(MergeBlock, ExitingBB);
     DT.eraseNode(ExitingBlock);
   } else {
-    NodeBuilder.addParameters(S.getContext().release());
+    NodeBuilder.addParameters(isl::manage(S.getContext().release()));
     Value *RTC = NodeBuilder.createRTC(AI.getRunCondition().release());
 
     Builder.GetInsertBlock()->getTerminator()->setOperand(0, RTC);
 
     // Explicitly set the insert point to the end of the block to avoid that a
     // split at the builder's current
     // insert position would move the malloc calls to the wrong BasicBlock.
     // Ideally we would just split the block during allocation of the new

polly/lib/CodeGen/IslNodeBuilder.cpp

bool IslNodeBuilder::preloadInvariantLoads() {
 
   for (auto &IAClass : InvariantEquivClasses)
     if (!preloadInvariantEquivClass(IAClass))
       return false;
 
   return true;
 }
 
-void IslNodeBuilder::addParameters(__isl_take isl_set *Context) {
+void IslNodeBuilder::addParameters(isl::set Context) {
   // Materialize values for the parameters of the SCoP.
   materializeParameters();
 
   // materialize the outermost dimension parameters for a Fortran array.
   // NOTE: materializeParameters() does not work since it looks through
   // the SCEVs. We don't have a corresponding SCEV for the array size
   // parameter
   materializeFortranArrayOutermostDimension();
 
   // Generate values for the current loop iteration for all surrounding loops.
   //
   // We may also reference loops outside of the scop which do not contain the
   // scop itself, but as the number of such scops may be arbitrarily large we do
   // not generate code for them here, but only at the point of code generation
   // where these values are needed.
   Loop *L = LI.getLoopFor(S.getEntry());
 
   while (L != nullptr && S.contains(L))
     L = L->getParentLoop();
 
   while (L != nullptr) {
     materializeNonScopLoopInductionVariable(L);
     L = L->getParentLoop();
   }
-
-  isl_set_free(Context);
 }
 
 Value *IslNodeBuilder::generateSCEV(const SCEV *Expr) {
   /// We pass the insert location of our Builder, as Polly ensures during IR
   /// generation that there is always a valid CFG into which instructions are
   /// inserted. As a result, the insertpoint is known to be always followed by a
   /// terminator instruction. This means the insert point may be specified by a
   /// terminator instruction, but it can never point to an ->end() iterator