[Polly][Isl] Refactoring IslAstInfo::getBuild() and IslAstInfo::IslAstUserPayload::Build to use isl++. NFC

[patacca]

Summary

Polly uses algorithms from the Integer Set Library (isl), which is a library written in C and which is incompatible with the rest of the LLVM as it is written in C++.

Changes made:

• Refactoring the method IslAstInfo::getBuild()
• IslAstInfo::IslAstUserPayload.Build now uses C++ types instead of C types
• Removing destructor of IslAstInfo::IslAstUserPayload

[Meinersbur]

LGTM.

Could you remove the backticks from the title before committing? It is not interpreted as Markdown and its shortness is comparatively important (Many guidelines recommend at most 50 characters)

polly/include/polly/CodeGen/IslAst.h

 public:
   using MemoryAccessSet = SmallPtrSet<MemoryAccess *, 4>;
 
   /// Payload information used to annotate an AST node.
   struct IslAstUserPayload {
     /// Construct and initialize the payload.
     IslAstUserPayload() = default;
 
-    /// Cleanup all isl structs on destruction.
-    ~IslAstUserPayload();
-
     /// Does the dependence analysis determine that there are no loop-carried
     /// dependencies?
     bool IsParallel = false;
 
     /// Flag to mark innermost loops.
     bool IsInnermost = false;
 
     /// Flag to mark innermost parallel loops.
     bool IsInnermostParallel = false;
 
     /// Flag to mark outermost parallel loops.
     bool IsOutermostParallel = false;
 
     /// Flag to mark parallel loops which break reductions.
     bool IsReductionParallel = false;
 
     /// The minimal dependence distance for non parallel loops.
     isl::pw_aff MinimalDependenceDistance;
 
     /// The build environment at the time this node was constructed.
-    isl_ast_build *Build = nullptr;
+    isl::ast_build Build;
 
     /// Set of accesses which break reduction dependences.
     MemoryAccessSet BrokenReductions;
   };
 
 private:
   Scop &S;
   IslAst Ast;
public:
 
   /// Get minimal dependence distance or nullptr if not available.
   static isl::pw_aff getMinimalDependenceDistance(const isl::ast_node &Node);
 
   /// Get the nodes broken reductions or a nullptr if not available.
   static MemoryAccessSet *getBrokenReductions(const isl::ast_node &Node);
 
   /// Get the nodes build context or a nullptr if not available.
-  static __isl_give isl_ast_build *getBuild(__isl_keep isl_ast_node *Node);
+  static isl::ast_build getBuild(const isl::ast_node &Node);
 
   ///}
 };
 
 struct IslAstAnalysis : public AnalysisInfoMixin<IslAstAnalysis> {
   static AnalysisKey Key;
 
   using Result = IslAstInfo;

polly/lib/CodeGen/IslAst.cpp

 };
 } // namespace polly
 
 /// Free an IslAstUserPayload object pointed to by @p Ptr.
 static void freeIslAstUserPayload(void *Ptr) {
   delete ((IslAstInfo::IslAstUserPayload *)Ptr);
 }
 
-IslAstInfo::IslAstUserPayload::~IslAstUserPayload() {
-  isl_ast_build_free(Build);
-}
-
 /// Print a string @p str in a single line using @p Printer.
 static isl_printer *printLine(__isl_take isl_printer *Printer,
                               const std::string &str,
                               __isl_keep isl_pw_aff *PWA = nullptr) {
   Printer = isl_printer_start_line(Printer);
   Printer = isl_printer_print_str(Printer, str.c_str());
   if (PWA)
     Printer = isl_printer_print_pw_aff(Printer, PWA);

 astBuildAfterFor(__isl_take isl_ast_node *Node, __isl_keep isl_ast_build *Build,
                  void *User) {
   isl_id *Id = isl_ast_node_get_annotation(Node);
   assert(Id && "Post order visit assumes annotated for nodes");
   IslAstUserPayload *Payload = (IslAstUserPayload *)isl_id_get_user(Id);
   assert(Payload && "Post order visit assumes annotated for nodes");
 
   AstBuildUserInfo *BuildInfo = (AstBuildUserInfo *)User;
-  assert(!Payload->Build && "Build environment already set");
-  Payload->Build = isl_ast_build_copy(Build);
+  assert(Payload->Build.is_null() && "Build environment already set");
+  Payload->Build = isl::manage_copy(Build);
   Payload->IsInnermost = (Id == BuildInfo->LastForNodeId);
 
   Payload->IsInnermostParallel =
       Payload->IsInnermost && (BuildInfo->InSIMD || Payload->IsParallel);
   if (Payload->IsOutermostParallel)
     BuildInfo->InParallelFor = false;
 
   isl_id_free(Id);
static __isl_give isl_ast_node *AtEachDomain(__isl_take isl_ast_node *Node,
                                              __isl_keep isl_ast_build *Build,
                                              void *User) {
   assert(!isl_ast_node_get_annotation(Node) && "Node already annotated");
 
   IslAstUserPayload *Payload = new IslAstUserPayload();
   isl_id *Id = isl_id_alloc(isl_ast_build_get_ctx(Build), "", Payload);
   Id = isl_id_set_free_user(Id, freeIslAstUserPayload);
 
-  Payload->Build = isl_ast_build_copy(Build);
+  Payload->Build = isl::manage_copy(Build);
 
   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) {
bool IslAstInfo::isExecutedInParallel(const isl::ast_node &Node) {
   if (!PollyParallelForce && isInnermost(Node))
     return false;
 
   return isOutermostParallel(Node) && !isReductionParallel(Node);
 }
 
 isl::union_map IslAstInfo::getSchedule(const isl::ast_node &Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
-  if (!Payload)
-    return {};
-
-  isl::ast_build Build = isl::manage_copy(Payload->Build);
-  return Build.get_schedule();
+  return Payload ? Payload->Build.get_schedule() : isl::union_map();
 }
 
 isl::pw_aff
 IslAstInfo::getMinimalDependenceDistance(const isl::ast_node &Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload ? Payload->MinimalDependenceDistance : isl::pw_aff();
 }
 
 IslAstInfo::MemoryAccessSet *
 IslAstInfo::getBrokenReductions(const isl::ast_node &Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload ? &Payload->BrokenReductions : nullptr;
 }
 
-isl_ast_build *IslAstInfo::getBuild(__isl_keep isl_ast_node *Node) {
-  IslAstUserPayload *Payload = getNodePayload(isl::manage_copy(Node));
-  return Payload ? Payload->Build : nullptr;
+isl::ast_build IslAstInfo::getBuild(const isl::ast_node &Node) {
+  IslAstUserPayload *Payload = getNodePayload(Node);
+  return Payload ? Payload->Build : isl::ast_build();
 }
 
 static std::unique_ptr<IslAstInfo> runIslAst(
     Scop &Scop,
     function_ref<const Dependences &(Dependences::AnalysisLevel)> GetDeps) {
   // Skip SCoPs in case they're already handled by PPCGCodeGeneration.
   if (Scop.isToBeSkipped())
     return {};
static __isl_give isl_printer *cbPrintUser(__isl_take isl_printer *P,
   for (MemoryAccess *MemAcc : *AccessStmt) {
     P = isl_printer_start_line(P);
 
     if (MemAcc->isRead())
       P = isl_printer_print_str(P, "/* read  */ &");
     else
       P = isl_printer_print_str(P, "/* write */  ");
 
-    isl::ast_build Build = isl::manage_copy(IslAstInfo::getBuild(Node));
+    isl::ast_build Build = IslAstInfo::getBuild(isl::manage_copy(Node));
     if (MemAcc->isAffine()) {
       isl_pw_multi_aff *PwmaPtr =
           MemAcc->applyScheduleToAccessRelation(Build.get_schedule()).release();
       isl::pw_multi_aff Pwma = isl::manage(PwmaPtr);
       isl::ast_expr AccessExpr = Build.access_from(Pwma);
       P = isl_printer_print_ast_expr(P, AccessExpr.get());
     } else {
       P = isl_printer_print_str(

polly/lib/CodeGen/IslNodeBuilder.cpp

void IslNodeBuilder::createIf(__isl_take isl_ast_node *If) {
   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);
+  isl::id_to_ast_expr NewAccesses =
+      isl::id_to_ast_expr::alloc(Stmt->getParent()->getIslCtx(), 0);
 
-  auto *Build = IslAstInfo::getBuild(Node);
-  assert(Build && "Could not obtain isl_ast_build from user node");
-  Stmt->setAstBuild(isl::manage_copy(Build));
+  isl::ast_build Build = IslAstInfo::getBuild(isl::manage_copy(Node));
+  assert(!Build.is_null() && "Could not obtain isl_ast_build from user node");
+  Stmt->setAstBuild(Build);
 
   for (auto *MA : *Stmt) {
     if (!MA->hasNewAccessRelation()) {
       if (PollyGenerateExpressions) {
         if (!MA->isAffine())
           continue;
         if (MA->getLatestScopArrayInfo()->getBasePtrOriginSAI())
           continue;
 
         auto *BasePtr =
             dyn_cast<Instruction>(MA->getLatestScopArrayInfo()->getBasePtr());
         if (BasePtr && Stmt->getParent()->getRegion().contains(BasePtr))
           continue;
       } else {
         continue;
       }
     }
     assert(MA->isAffine() &&
            "Only affine memory accesses can be code generated");
 
-    auto Schedule = isl_ast_build_get_schedule(Build);
+    isl::union_map Schedule = Build.get_schedule();
 
 #ifndef NDEBUG
     if (MA->isRead()) {
       auto Dom = Stmt->getDomain().release();
-      auto SchedDom = isl_set_from_union_set(
-          isl_union_map_domain(isl_union_map_copy(Schedule)));
+      auto SchedDom = isl_set_from_union_set(Schedule.domain().release());
       auto AccDom = isl_map_domain(MA->getAccessRelation().release());
       Dom = isl_set_intersect_params(Dom,
                                      Stmt->getParent()->getContext().release());
       SchedDom = isl_set_intersect_params(
           SchedDom, Stmt->getParent()->getContext().release());
       assert(isl_set_is_subset(SchedDom, AccDom) &&
              "Access relation not defined on full schedule domain");
       assert(isl_set_is_subset(Dom, AccDom) &&
              "Access relation not defined on full domain");
       isl_set_free(AccDom);
       isl_set_free(SchedDom);
       isl_set_free(Dom);
     }
 #endif
 
-    auto PWAccRel =
-        MA->applyScheduleToAccessRelation(isl::manage(Schedule)).release();
+    isl::pw_multi_aff PWAccRel = MA->applyScheduleToAccessRelation(Schedule);
 
     // isl cannot generate an index expression for access-nothing accesses.
-    isl::set AccDomain =
-        isl::manage(isl_pw_multi_aff_domain(isl_pw_multi_aff_copy(PWAccRel)));
+    isl::set AccDomain = PWAccRel.domain();
     isl::set Context = S.getContext();
     AccDomain = AccDomain.intersect_params(Context);
-    if (AccDomain.is_empty()) {
-      isl_pw_multi_aff_free(PWAccRel);
+    if (AccDomain.is_empty())
       continue;
-    }
 
-    auto AccessExpr = isl_ast_build_access_from_pw_multi_aff(Build, PWAccRel);
-    NewAccesses =
-        isl_id_to_ast_expr_set(NewAccesses, MA->getId().release(), AccessExpr);
+    isl::ast_expr AccessExpr = Build.access_from(PWAccRel);
+    NewAccesses = NewAccesses.set(MA->getId(), AccessExpr);
   }
 
-  return NewAccesses;
+  return NewAccesses.release();
 }
 
 void IslNodeBuilder::createSubstitutions(__isl_take isl_ast_expr *Expr,
                                          ScopStmt *Stmt, LoopToScevMapT &LTS) {
   assert(isl_ast_expr_get_type(Expr) == isl_ast_expr_op &&
          "Expression of type 'op' expected");
   assert(isl_ast_expr_get_op_type(Expr) == isl_ast_op_call &&
          "Operation of type 'call' expected");