[flang][openacc] Add check for tile clause restriction

[clementval]

Summary

The tile clause in OpenACC 3.0 imposes some restriction. Element in the tile size list are either * or a
constant positive integer expression. If there are n tile sizes in the list, the loop construct must be immediately
followed by n tightly-nested loops.
This patch implement these restrictions and add some tests.

[klausler]

flang/lib/Parser/openacc-parsers.cpp

134

This production in the comment does not match the production in the code.

141

Comment does not match the code.

[clementval]

Rebase + address minor comments

[clementval]

flang/lib/Parser/openacc-parsers.cpp

134

Changed it to be an empty optional.

141

Changed it to be an empty optional.

flang/include/flang/Parser/dump-parse-tree.h

#include "llvm/Frontend/OpenACC/ACC.cpp.inc"
   NODE(parser, AccObjectList)
   NODE(parser, AccObjectListWithModifier)
   NODE(parser, AccObjectListWithReduction)
   NODE(parser, AccReductionOperator)
   NODE_ENUM(parser::AccReductionOperator, Operator)
   NODE(parser, AccSizeExpr)
   NODE(parser, AccSizeExprList)
   NODE(parser, AccStandaloneDirective)
+  NODE(parser, AccTileExpr)
+  NODE(parser, AccTileExprList)
   NODE(parser, AccLoopDirective)
   NODE(parser, AccWaitArgument)
   static std::string GetNodeName(const llvm::acc::Directive &x) {
     return llvm::Twine(
         "llvm::acc::Directive = ", llvm::acc::getOpenACCDirectiveName(x))
         .str();
   }
   NODE(parser, AcImpliedDo)

flang/include/flang/Parser/parse-tree.h

struct AccObjectListWithReduction {
   std::tuple<AccReductionOperator, AccObjectList> t;
 };
 
 struct AccWaitArgument {
   TUPLE_CLASS_BOILERPLATE(AccWaitArgument);
   std::tuple<std::optional<ScalarIntExpr>, std::list<ScalarIntExpr>> t;
 };
 
+struct AccTileExpr {
+  TUPLE_CLASS_BOILERPLATE(AccTileExpr);
+  CharBlock source;
+  std::tuple<std::optional<ScalarIntConstantExpr>> t; // if null then *
+};
+
+struct AccTileExprList {
+  WRAPPER_CLASS_BOILERPLATE(AccTileExprList, std::list<AccTileExpr>);
+};
+
 struct AccSizeExpr {
   TUPLE_CLASS_BOILERPLATE(AccSizeExpr);
   CharBlock source;
   std::tuple<std::optional<ScalarIntExpr>> t; // if null then *
 };
 
 struct AccSizeExprList {
   WRAPPER_CLASS_BOILERPLATE(AccSizeExprList, std::list<AccSizeExpr>);

flang/lib/Parser/openacc-parsers.cpp

TYPE_PARSER("AUTO" >> construct<AccClause>(construct<AccClause::Auto>()) ||
     "REDUCTION" >> construct<AccClause>(construct<AccClause::Reduction>(
                        parenthesized(construct<AccObjectListWithReduction>(
                            Parser<AccReductionOperator>{} / ":",
                            Parser<AccObjectList>{})))) ||
     "SELF" >> construct<AccClause>(construct<AccClause::Self>(
                   maybe(parenthesized(scalarLogicalExpr)))) ||
     "SEQ" >> construct<AccClause>(construct<AccClause::Seq>()) ||
     "TILE" >> construct<AccClause>(construct<AccClause::Tile>(
-                  parenthesized(Parser<AccSizeExprList>{}))) ||
+                  parenthesized(Parser<AccTileExprList>{}))) ||
     "USE_DEVICE" >> construct<AccClause>(construct<AccClause::UseDevice>(
                         parenthesized(Parser<AccObjectList>{}))) ||
     "VECTOR_LENGTH" >> construct<AccClause>(construct<AccClause::VectorLength>(
                            parenthesized(scalarIntExpr))) ||
     "VECTOR" >>
         construct<AccClause>(construct<AccClause::Vector>(maybe(
             parenthesized(("LENGTH:" >> scalarIntExpr || scalarIntExpr))))) ||
     "WAIT" >> construct<AccClause>(construct<AccClause::Wait>(
TYPE_PARSER(construct<AccObjectListWithModifier>(
     maybe(Parser<AccDataModifier>{}), Parser<AccObjectList>{}))
 
 // 2.16.3 (2485) wait-argument is:
 //   [devnum : int-expr :] [queues :] int-expr-list
 TYPE_PARSER(construct<AccWaitArgument>(maybe("DEVNUM:" >> scalarIntExpr / ":"),
     "QUEUES:" >> nonemptyList(scalarIntExpr) || nonemptyList(scalarIntExpr)))
 
 // 2.9 (1609) size-expr is one of:
+//   * (represented as an empty std::optional<ScalarIntExpr>)
 //   int-expr
 TYPE_PARSER(construct<AccSizeExpr>(scalarIntExpr) ||
-    construct<AccSizeExpr>("*" >> maybe(scalarIntExpr)))
+    construct<AccSizeExpr>("*" >> construct<std::optional<ScalarIntExpr>>()))
 TYPE_PARSER(construct<AccSizeExprList>(nonemptyList(Parser<AccSizeExpr>{})))
 
+// tile size is one of:
+//   * (represented as an empty std::optional<ScalarIntExpr>)
+//   constant-int-expr
+TYPE_PARSER(construct<AccTileExpr>(scalarIntConstantExpr) ||
+    construct<AccTileExpr>(
+        "*" >> construct<std::optional<ScalarIntConstantExpr>>()))
+TYPE_PARSER(construct<AccTileExprList>(nonemptyList(Parser<AccTileExpr>{})))
+
 // 2.9 (1607) gang-arg is one of:
 //   [num:]int-expr
 //   static:size-expr
 TYPE_PARSER(construct<AccGangArgument>(maybe(scalarIntExpr),
                 maybe(","_tok / "STATIC:" >> Parser<AccSizeExpr>{})) ||
     construct<AccGangArgument>(maybe("NUM:" >> scalarIntExpr),
         maybe(","_tok / "STATIC:" >> Parser<AccSizeExpr>{})))
 

flang/lib/Semantics/canonicalize-acc.cpp

for (auto it{block.begin()}; it != block.end(); ++it) {
             "The %s directive must follow the DO loop associated with the "
             "loop construct"_err_en_US,
             parser::ToUpperCaseLetters(endDir->v.source.ToString()));
       }
     } // Block list
   }
 
 private:
+  // Check constraint in 2.9.7
+  // If there are n tile sizes in the list, the loop construct must be
+  // immediately followed by n tightly-nested loops.
+  template <typename C, typename D>
+  void CheckTileClauseRestriction(const C &x) {
+    const auto &beginLoopDirective = std::get<D>(x.t);
+    const auto &accClauseList =
+        std::get<parser::AccClauseList>(beginLoopDirective.t);
+    for (const auto &clause : accClauseList.v) {
+      if (const auto *tileClause =
+              std::get_if<parser::AccClause::Tile>(&clause.u)) {
+        const parser::AccTileExprList &tileExprList = tileClause->v;
+        const std::list<parser::AccTileExpr> &listTileExpr = tileExprList.v;
+        std::size_t tileArgNb = listTileExpr.size();
+
+        const auto &outer{std::get<std::optional<parser::DoConstruct>>(x.t)};
+        for (const parser::DoConstruct *loop{&*outer}; loop && tileArgNb > 0;
+             --tileArgNb) {
+          const auto &block{std::get<parser::Block>(loop->t)};
+          const auto it{block.begin()};
+          loop = it != block.end() ? parser::Unwrap<parser::DoConstruct>(*it)
+                                   : nullptr;
+        }
+
+        if (tileArgNb > 0) {
+          messages_.Say(beginLoopDirective.source,
+              "The loop construct with the TILE clause must be followed by %d "
+              "tightly-nested loops"_err_en_US,
+              listTileExpr.size());
+        }
+      }
+    }
+  }
+
   void RewriteOpenACCLoopConstruct(parser::OpenACCLoopConstruct &x,
       parser::Block &block, parser::Block::iterator it) {
     // Check the sequence of DoConstruct in the same iteration
     //
     // Original:
     //   ExecutableConstruct -> OpenACCConstruct -> OpenACCLoopConstruct
     //     ACCBeginLoopDirective
     //   ExecutableConstruct -> DoConstruct
if (++nextIt != block.end()) {
           std::get<std::optional<parser::DoConstruct>>(x.t) =
               std::move(*doCons);
           nextIt = block.erase(nextIt);
         } else {
           messages_.Say(dir.source,
               "DO loop after the %s directive must have loop control"_err_en_US,
               parser::ToUpperCaseLetters(dir.source.ToString()));
         }
+        CheckTileClauseRestriction<parser::OpenACCLoopConstruct,
+            parser::AccBeginLoopDirective>(x);
         return; // found do-loop
       }
     }
     messages_.Say(dir.source,
         "A DO loop must follow the %s directive"_err_en_US,
         parser::ToUpperCaseLetters(dir.source.ToString()));
   }
 
if (++nextIt != block.end()) {
               block.erase(nextIt);
             }
           }
         } else {
           messages_.Say(dir.source,
               "DO loop after the %s directive must have loop control"_err_en_US,
               parser::ToUpperCaseLetters(dir.source.ToString()));
         }
+        CheckTileClauseRestriction<parser::OpenACCCombinedConstruct,
+            parser::AccBeginCombinedDirective>(x);
         return; // found do-loop
       }
     }
     messages_.Say(dir.source,
         "A DO loop must follow the %s directive"_err_en_US,
         parser::ToUpperCaseLetters(dir.source.ToString()));
   }
 

flang/test/Semantics/acc-canonicalization-validity.f90

program openacc_clause_validity
   do
   end do
 
   !ERROR: DO loop after the SERIAL LOOP directive must have loop control
   !$acc serial loop
   do
   end do
 
+  !$acc parallel
+  !ERROR: The loop construct with the TILE clause must be followed by 2 tightly-nested loops
+  !$acc loop tile(2, 2)
+  do i = 1, N
+    a(i) = 3.14
+  end do
+  !$acc end parallel
+
+  !ERROR: The loop construct with the TILE clause must be followed by 2 tightly-nested loops
+  !$acc parallel loop tile(2, 2)
+  do i = 1, N
+    a(i) = 3.14
+  end do
+
 end program openacc_clause_validity

flang/test/Semantics/acc-clause-validity.f90

program openacc_clause_validity
   implicit none
 
   integer :: i, j, b
   integer, parameter :: N = 256
   integer, dimension(N) :: c
   logical, dimension(N) :: d, e
   real :: reduction_r
   logical :: reduction_l
+  real(8), dimension(N, N) :: aa
 
   !ERROR: At least one clause is required on the DECLARE directive
   !$acc declare
   real(8) :: a(256)
 
   !ERROR: At least one of ATTACH, COPYIN, CREATE clause must appear on the ENTER DATA directive
   !$acc enter data
 
program openacc_clause_validity
   !$acc parallel
   !ERROR: INDEPENDENT and SEQ clauses are mutually exclusive and may not appear on the same LOOP directive
   !$acc loop seq independent
   do i = 1, N
     a(i) = 3.14
   end do
   !$acc end parallel
 
+  !$acc parallel
+  !$acc loop tile(2)
+  do i = 1, N
+    a(i) = 3.14
+  end do
+  !$acc end parallel
+
+  !$acc parallel loop tile(2)
+  do i = 1, N
+    a(i) = 3.14
+  end do
+
+  !$acc parallel loop tile(2, 2)
+  do i = 1, N
+    do j = 1, N
+      aa(i, j) = 3.14
+    end do
+  end do
+
   !$acc parallel device_type(*) num_gangs(2)
   !$acc loop
   do i = 1, N
     a(i) = 3.14
   end do
   !$acc end parallel
 
   !$acc parallel

llvm/include/llvm/Frontend/OpenACC/ACC.td

 
 // 2.5.11
 def ACCC_Private : Clause<"private"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.9.7
 def ACCC_Tile : Clause <"tile"> {
-  let flangClassValue = "AccSizeExprList";
+  let flangClassValue = "AccTileExprList";
 }
 
 // 2.8.1
 def ACCC_UseDevice : Clause <"use_device"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.12