[flang][openacc] Lower parallel loop combined construct

[clementval]

Summary

This patch lower the parallel loop combined construct to MLIR ops.

This code was part of the PR #558 on fir-dev
https://github.com/flang-compiler/f18-llvm-project/pull/558

[schweitz]

LGTM.

flang/lib/Lower/OpenACC.cpp

615

When we get the green-light to upstream, you may want to consider using fir::emitFatalError() here, as it will take mlir::Location information and produce a bit nicer output.

(On the other hand, the error seems like a general "this can never happen", but this was a chance to add a gratuitous plug.)

[mehdi_amini]

We're waiting on the ability to have tests for these I believe.

[clementval]

In D92065#2478345, @mehdi_amini wrote:

We're waiting on the ability to have tests for these I believe.

Yeah I don't mind waiting for the fir-dev RFC to go through and adding test for that.

[clementval]

Will send a new version when the general lowering is available upstream.

flang/lib/Lower/OpenACC.cpp

genACC(Fortran::lower::AbstractConverter &converter,
   if (blockDirective.v == llvm::acc::ACCD_parallel) {
     genACCParallelOp(converter, accClauseList);
   } else if (blockDirective.v == llvm::acc::ACCD_data) {
     genACCDataOp(converter, accClauseList);
   }
 }
 
 static void
+genACCParallelLoopOps(Fortran::lower::AbstractConverter &converter,
+                      const Fortran::parser::AccClauseList &accClauseList) {
+  createParallelOp(converter, accClauseList);
+  createLoopOp(converter, accClauseList);
+}
+
+static void
+genACC(Fortran::lower::AbstractConverter &converter,
+       Fortran::lower::pft::Evaluation &eval,
+       const Fortran::parser::OpenACCCombinedConstruct &combinedConstruct) {
+  const auto &beginCombinedDirective =
+      std::get<Fortran::parser::AccBeginCombinedDirective>(combinedConstruct.t);
+  const auto &combinedDirective =
+      std::get<Fortran::parser::AccCombinedDirective>(beginCombinedDirective.t);
+  const auto &accClauseList =
+      std::get<Fortran::parser::AccClauseList>(beginCombinedDirective.t);
+
+  if (combinedDirective.v == llvm::acc::ACCD_kernels_loop) {
+    TODO("OpenACC Kernels Loop construct not lowered yet!");
+  } else if (combinedDirective.v == llvm::acc::ACCD_parallel_loop) {
+    genACCParallelLoopOps(converter, accClauseList);
+  } else if (combinedDirective.v == llvm::acc::ACCD_serial_loop) {
+    TODO("OpenACC Serial Loop construct not lowered yet!");
+  } else {
+    llvm::report_fatal_error(
+        "Unknown combined construct encountered in lowering");
+  }
+}
+
+static void
 genACCEnterDataOp(Fortran::lower::AbstractConverter &converter,
                   const Fortran::parser::AccClauseList &accClauseList) {
   mlir::Value ifCond, async, waitDevnum;
   SmallVector<mlir::Value, 2> copyinOperands, createOperands,
       createZeroOperands, attachOperands, waitOperands;
 
   // Async, wait and self clause have optional values but can be present with
   // no value as well. When there is no value, the op has an attribute to
void Fortran::lower::genOpenACCConstruct(
 
   std::visit(
       common::visitors{
           [&](const Fortran::parser::OpenACCBlockConstruct &blockConstruct) {
             genACC(converter, eval, blockConstruct);
           },
           [&](const Fortran::parser::OpenACCCombinedConstruct
                   &combinedConstruct) {
-            TODO("OpenACC Combined construct not lowered yet!");
+            genACC(converter, eval, combinedConstruct);
           },
           [&](const Fortran::parser::OpenACCLoopConstruct &loopConstruct) {
             genACC(converter, eval, loopConstruct);
           },
           [&](const Fortran::parser::OpenACCStandaloneConstruct
                   &standaloneConstruct) {
             genACC(converter, eval, standaloneConstruct);
           },