[flang][openacc] Add parser support for the force modifier in the collapse clause

[clementval]

Summary

This patch adds parser support for the force modifier on the collapse clause.
Lowering will currently hit a TODO as the MLIR representation of the acc.loop
might need some update.

[kiranchandramohan]

LG.

If this modifier came in new in the OpenACC 3.3 spec, it might be good to mention in the commit message.

flang/lib/Lower/OpenACC.cpp

919

Nit: May be ACC Collapse force modifier

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

#include "llvm/Frontend/OpenACC/ACC.inc"
   NODE(parser, AccCombinedDirective)
   NODE(parser, AccDataModifier)
   NODE_ENUM(parser::AccDataModifier, Modifier)
   NODE(parser, AccDeclarativeDirective)
   NODE(parser, AccEndAtomic)
   NODE(parser, AccEndBlockDirective)
   NODE(parser, AccEndCombinedDirective)
   NODE(parser, AccGangArgument)
+  NODE(parser, AccCollapseArg)
   NODE(parser, AccObject)
   NODE(parser, AccObjectList)
   NODE(parser, AccObjectListWithModifier)
   NODE(parser, AccObjectListWithReduction)
   NODE(parser, AccReductionOperator)
   NODE_ENUM(parser::AccReductionOperator, Operator)
   NODE(parser, AccSizeExpr)
   NODE(parser, AccSizeExprList)

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

struct AccSelfClause {
   CharBlock source;
 };
 
 struct AccGangArgument {
   TUPLE_CLASS_BOILERPLATE(AccGangArgument);
   std::tuple<std::optional<ScalarIntExpr>, std::optional<AccSizeExpr>> t;
 };
 
+struct AccCollapseArg {
+  TUPLE_CLASS_BOILERPLATE(AccCollapseArg);
+  std::tuple<bool, ScalarIntConstantExpr> t;
+};
+
 struct AccClause {
   UNION_CLASS_BOILERPLATE(AccClause);
 
 #define GEN_FLANG_CLAUSE_PARSER_CLASSES
 #include "llvm/Frontend/OpenACC/ACC.inc"
 
   CharBlock source;
 

flang/lib/Lower/OpenACC.cpp

loopOp.setPrivatizationsAttr(
         mlir::ArrayAttr::get(builder.getContext(), privatizations));
 
   if (!reductionRecipes.empty())
     loopOp.setReductionRecipesAttr(
         mlir::ArrayAttr::get(builder.getContext(), reductionRecipes));
 
   // Lower clauses mapped to attributes
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
+    mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto *collapseClause =
             std::get_if<Fortran::parser::AccClause::Collapse>(&clause.u)) {
-      const auto *expr = Fortran::semantics::GetExpr(collapseClause->v);
+      const Fortran::parser::AccCollapseArg &arg = collapseClause->v;
+      const auto &force = std::get<bool>(arg.t);
+      if (force)
+        TODO(clauseLocation, "OpenACC collapse force modifier");
+      const auto &intExpr =
+          std::get<Fortran::parser::ScalarIntConstantExpr>(arg.t);
+      const auto *expr = Fortran::semantics::GetExpr(intExpr);
       const std::optional<int64_t> collapseValue =
           Fortran::evaluate::ToInt64(*expr);
       if (collapseValue) {
         loopOp.setCollapseAttr(builder.getI64IntegerAttr(*collapseValue));
       }
     } else if (std::get_if<Fortran::parser::AccClause::Seq>(&clause.u)) {
       loopOp.setSeqAttr(builder.getUnitAttr());
     } else if (std::get_if<Fortran::parser::AccClause::Independent>(

flang/lib/Parser/openacc-parsers.cpp

 TYPE_PARSER(construct<AccTileExprList>(nonemptyList(Parser<AccTileExpr>{})))
 
 // 2.9 (1607) gang-arg is:
 //   [[num:]int-expr][[,]static:size-expr]
 TYPE_PARSER(construct<AccGangArgument>(
     maybe(("NUM:"_tok >> scalarIntExpr || scalarIntExpr)),
     maybe(", STATIC:" >> Parser<AccSizeExpr>{})))
 
+// 2.9.1 collapse
+TYPE_PARSER(construct<AccCollapseArg>(
+    "FORCE:"_tok >> pure(true) || pure(false), scalarIntConstantExpr))
+
 // 2.5.13 Reduction
 // Operator for reduction
 TYPE_PARSER(sourced(construct<AccReductionOperator>(
     first("+" >> pure(AccReductionOperator::Operator::Plus),
         "*" >> pure(AccReductionOperator::Operator::Multiply),
         "MAX" >> pure(AccReductionOperator::Operator::Max),
         "MIN" >> pure(AccReductionOperator::Operator::Min),
         "IAND" >> pure(AccReductionOperator::Operator::Iand),

flang/lib/Parser/unparse.cpp

case llvm::acc::DefaultValue::ACC_Default_present:
       break;
     }
   }
   void Unparse(const AccClauseList &x) { Walk(" ", x.v, " "); }
   void Unparse(const AccGangArgument &x) {
     Walk("NUM:", std::get<std::optional<ScalarIntExpr>>(x.t));
     Walk(", STATIC:", std::get<std::optional<AccSizeExpr>>(x.t));
   }
+  void Unparse(const AccCollapseArg &x) {
+    const auto &force{std::get<bool>(x.t)};
+    const auto &collapseValue{std::get<parser::ScalarIntConstantExpr>(x.t)};
+    if (force) {
+      Put("FORCE:");
+    }
+    Walk(collapseValue);
+  }
   void Unparse(const OpenACCBlockConstruct &x) {
     BeginOpenACC();
     Word("!$ACC ");
     Walk(std::get<AccBeginBlockDirective>(x.t));
     Put("\n");
     EndOpenACC();
     Walk(std::get<Block>(x.t), "");
     BeginOpenACC();

flang/lib/Semantics/check-acc-structure.cpp

void AccStructureChecker::Enter(const parser::OpenACCCacheConstruct &x) {
   PushContextAndClauseSets(verbatim.source, llvm::acc::Directive::ACCD_cache);
   SetContextDirectiveSource(verbatim.source);
 }
 void AccStructureChecker::Leave(const parser::OpenACCCacheConstruct &x) {
   dirContext_.pop_back();
 }
 
 // Clause checkers
-CHECK_REQ_SCALAR_INT_CONSTANT_CLAUSE(Collapse, ACCC_collapse)
-
 CHECK_SIMPLE_CLAUSE(Auto, ACCC_auto)
 CHECK_SIMPLE_CLAUSE(Async, ACCC_async)
 CHECK_SIMPLE_CLAUSE(Attach, ACCC_attach)
 CHECK_SIMPLE_CLAUSE(Bind, ACCC_bind)
 CHECK_SIMPLE_CLAUSE(Capture, ACCC_capture)
 CHECK_SIMPLE_CLAUSE(Copy, ACCC_copy)
 CHECK_SIMPLE_CLAUSE(Default, ACCC_default)
 CHECK_SIMPLE_CLAUSE(DefaultAsync, ACCC_default_async)
if (accObjectList.v.size() != 1) {
       context_.Say(GetContext().clauseSource,
           "SELF clause on the %s directive only accepts optional scalar logical"
           " expression"_err_en_US,
           ContextDirectiveAsFortran());
     }
   }
 }
 
+void AccStructureChecker::Enter(const parser::AccClause::Collapse &x) {
+  CheckAllowed(llvm::acc::Clause::ACCC_collapse);
+  const parser::AccCollapseArg &accCollapseArg = x.v;
+  const auto &collapseValue{
+      std::get<parser::ScalarIntConstantExpr>(accCollapseArg.t)};
+  RequiresConstantPositiveParameter(
+      llvm::acc::Clause::ACCC_collapse, collapseValue);
+}
+
 llvm::StringRef AccStructureChecker::getClauseName(llvm::acc::Clause clause) {
   return llvm::acc::getOpenACCClauseName(clause);
 }
 
 llvm::StringRef AccStructureChecker::getDirectiveName(
     llvm::acc::Directive directive) {
   return llvm::acc::getOpenACCDirectiveName(directive);
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/resolve-directives.cpp

 }
 
 std::int64_t AccAttributeVisitor::GetAssociatedLoopLevelFromClauses(
     const parser::AccClauseList &x) {
   std::int64_t collapseLevel{0};
   for (const auto &clause : x.v) {
     if (const auto *collapseClause{
             std::get_if<parser::AccClause::Collapse>(&clause.u)}) {
-      if (const auto v{EvaluateInt64(context_, collapseClause->v)}) {
+      const parser::AccCollapseArg &arg = collapseClause->v;
+      const auto &collapseValue{std::get<parser::ScalarIntConstantExpr>(arg.t)};
+      if (const auto v{EvaluateInt64(context_, collapseValue)}) {
         collapseLevel = *v;
       }
     }
   }
 
   if (collapseLevel) {
     return collapseLevel;
   }

flang/test/Parser/acc-unparse.f90

do j = 1, 10
         exit label1
       end if
     end do
   end do label1
 end program
 
 !CHECK-LABEL: PROGRAM bug47659
 !CHECK: !$ACC PARALLEL LOOP
+
+
+subroutine acc_loop()
+  integer :: i, j
+
+  !$acc loop collapse(force: 2)
+  do i = 1, 10
+    do j = 1, 10
+    end do
+  end do
+end subroutine
+
+!CHECK-LABEL: SUBROUTINE acc_loop
+!CHECK: !$ACC LOOP COLLAPSE(FORCE:2_4)

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

 }
 
 // 2.12
 def ACCC_Capture : Clause<"capture"> {
 }
 
 // 2.9.1
 def ACCC_Collapse : Clause<"collapse"> {
-  let flangClass = "ScalarIntConstantExpr";
+  let flangClass = "AccCollapseArg";
 }
 
 // 2.7.6
 def ACCC_Copy : Clause<"copy"> {
   let flangClass = "AccObjectList";
   let aliases = ["present_or_copy", "pcopy"];
 }
 // 2.7.7