[Polly] Refactoring isInnermost() from isl to use the C++ wrapper

[patacca]

Summary

Polly use 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 isInnermost() to take C++ bindings instead of the plain isl C api.
• Addition of manage_copy() when needed to get the reference for the isl_ast_node object

[Meinersbur]

LGTM.

Would you like me to push it to the main repository?

[patacca]

Yes please

polly/include/polly/CodeGen/IslAst.h

public:
 
   /// @name Extract information attached to an isl ast (for) node.
   ///
   ///{
   /// Get the complete payload attached to @p Node.
   static IslAstUserPayload *getNodePayload(const isl::ast_node &Node);
 
   /// Is this loop an innermost loop?
-  static bool isInnermost(__isl_keep isl_ast_node *Node);
+  static bool isInnermost(const isl::ast_node &Node);
 
   /// Is this loop a parallel loop?
   static bool isParallel(__isl_keep isl_ast_node *Node);
 
   /// Is this loop an outermost parallel loop?
   static bool isOutermostParallel(const isl::ast_node &Node);
 
   /// Is this loop an innermost parallel loop?

polly/lib/CodeGen/IslAst.cpp

 IslAstUserPayload *IslAstInfo::getNodePayload(const isl::ast_node &Node) {
   isl::id Id = Node.get_annotation();
   if (!Id)
     return nullptr;
   IslAstUserPayload *Payload = (IslAstUserPayload *)Id.get_user();
   return Payload;
 }
 
-bool IslAstInfo::isInnermost(__isl_keep isl_ast_node *Node) {
-  IslAstUserPayload *Payload = getNodePayload(isl::manage_copy(Node));
+bool IslAstInfo::isInnermost(const isl::ast_node &Node) {
+  IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload && Payload->IsInnermost;
 }
 
 bool IslAstInfo::isParallel(__isl_keep isl_ast_node *Node) {
   return IslAstInfo::isInnermostParallel(isl::manage_copy(Node)) ||
          IslAstInfo::isOutermostParallel(isl::manage_copy(Node));
 }
 
bool IslAstInfo::isExecutedInParallel(__isl_keep isl_ast_node *Node) {
   //
   // Parallelizing innermost loops is often not profitable, especially if
   // they have a low number of iterations.
   //
   // TODO: Decide this based on the number of loop iterations that will be
   //       executed. This can possibly require run-time checks, which again
   //       raises the question of both run-time check overhead and code size
   //       costs.
-  if (!PollyParallelForce && isInnermost(Node))
+  if (!PollyParallelForce && isInnermost(isl::manage_copy(Node)))
     return false;
 
   return isOutermostParallel(isl::manage_copy(Node)) &&
          !isReductionParallel(Node);
 }
 
 __isl_give isl_union_map *
 IslAstInfo::getSchedule(__isl_keep isl_ast_node *Node) {