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

[refactormyself]

Summary

The 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/IslNodeBuilder.cpp

836

With isl::ast_node, we prefer using its accessor methods over calling the C API.

840–841

same here

polly/include/polly/CodeGen/IslNodeBuilder.h

protected:
   ///             original loop this count, expressed in function of the new
   ///             induction variables, is added to the LTS map.
   void createSubstitutions(__isl_take isl_ast_expr *Expr, ScopStmt *Stmt,
                            LoopToScevMapT &LTS);
   void createSubstitutionsVector(__isl_take isl_ast_expr *Expr, ScopStmt *Stmt,
                                  std::vector<LoopToScevMapT> &VLTS,
                                  std::vector<Value *> &IVS,
                                  __isl_take isl_id *IteratorID);
-  virtual void createIf(__isl_take isl_ast_node *If);
+  virtual void createIf(isl::ast_node If);
   void createUserVector(__isl_take isl_ast_node *User,
                         std::vector<Value *> &IVS,
                         __isl_take isl_id *IteratorID,
                         __isl_take isl_union_map *Schedule);
   virtual void createUser(__isl_take isl_ast_node *User);
   virtual void createBlock(__isl_take isl_ast_node *Block);
 
   /// Get the schedule for a given AST node.

polly/lib/CodeGen/IslNodeBuilder.cpp

if (IslAstInfo::isExecutedInParallel(isl::manage_copy(For))) {
     createForParallel(For);
     return;
   }
   bool Parallel = (IslAstInfo::isParallel(isl::manage_copy(For)) &&
                    !IslAstInfo::isReductionParallel(isl::manage_copy(For)));
   createForSequential(isl::manage(For), Parallel);
 }
 
-void IslNodeBuilder::createIf(__isl_take isl_ast_node *If) {
-  isl_ast_expr *Cond = isl_ast_node_if_get_cond(If);
+void IslNodeBuilder::createIf(isl::ast_node If) {
+  isl_ast_expr *Cond = isl_ast_node_if_get_cond(If.get());
 
   Function *F = Builder.GetInsertBlock()->getParent();
   LLVMContext &Context = F->getContext();
 
   BasicBlock *CondBB = SplitBlock(Builder.GetInsertBlock(),
                                   &*Builder.GetInsertPoint(), &DT, &LI);
   CondBB->setName("polly.cond");
   BasicBlock *MergeBB = SplitBlock(CondBB, &CondBB->front(), &DT, &LI);
void IslNodeBuilder::createIf(isl::ast_node If) {
   Value *Predicate = ExprBuilder.create(Cond);
   Builder.CreateCondBr(Predicate, ThenBB, ElseBB);
   Builder.SetInsertPoint(ThenBB);
   Builder.CreateBr(MergeBB);
   Builder.SetInsertPoint(ElseBB);
   Builder.CreateBr(MergeBB);
   Builder.SetInsertPoint(&ThenBB->front());
 
-  create(isl_ast_node_if_get_then(If));
+  create(isl_ast_node_if_get_then(If.get()));
 
   Builder.SetInsertPoint(&ElseBB->front());
 
-  if (isl_ast_node_if_has_else(If))
-    create(isl_ast_node_if_get_else(If));
+  if (isl_ast_node_if_has_else(If.get()))
+    create(isl_ast_node_if_get_else(If.get()));
 
   Builder.SetInsertPoint(&MergeBB->front());
 
-  isl_ast_node_free(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().get(), 0);
case isl_ast_node_error:
     llvm_unreachable("code generation error");
   case isl_ast_node_mark:
     createMark(Node);
     return;
   case isl_ast_node_for:
     createFor(Node);
     return;
   case isl_ast_node_if:
-    createIf(Node);
+    createIf(isl::manage(Node));
     return;
   case isl_ast_node_user:
     createUser(Node);
     return;
   case isl_ast_node_block:
     createBlock(Node);
     return;
   }