[flang][openacc] Lower gang dim to MLIR

[clementval]

Summary

Lower gang dim from the parse tree to the new MLIR
representation.

Depends on D151972

[jeanPerier]

Patch application issue, but the code and tests look good.

[razvanlupusoru]

Looks great!

[razvanlupusoru]

flang/test/Lower/OpenACC/acc-loop.f90

274

By the way, I think that the acc dialect should allow gang num and dim at same time even though spec does not. Namely, I see no reason you cannot specify how many gangs to use per dimension. That said, if you do reject this case at semantic verification, then your test might not work.

[clementval]

Rebase

[clementval]

clang-format

flang/lib/Lower/OpenACC.cpp

createLoopOp(Fortran::lower::AbstractConverter &converter,
              Fortran::semantics::SemanticsContext &semanticsContext,
              Fortran::lower::StatementContext &stmtCtx,
              const Fortran::parser::AccClauseList &accClauseList) {
   fir::FirOpBuilder &firOpBuilder = converter.getFirOpBuilder();
 
   mlir::Value workerNum;
   mlir::Value vectorNum;
   mlir::Value gangNum;
+  mlir::Value gangDim;
   mlir::Value gangStatic;
   llvm::SmallVector<mlir::Value, 2> tileOperands, privateOperands,
       reductionOperands;
   bool hasGang = false, hasVector = false, hasWorker = false;
 
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
     mlir::Location clauseLocation = converter.genLocation(clause.source);
     if (const auto *gangClause =
             std::get_if<Fortran::parser::AccClause::Gang>(&clause.u)) {
       if (gangClause->v) {
         const Fortran::parser::AccGangArgList &x = *gangClause->v;
         for (const Fortran::parser::AccGangArg &gangArg : x.v) {
           if (const auto *num =
                   std::get_if<Fortran::parser::AccGangArg::Num>(&gangArg.u)) {
             gangNum = fir::getBase(converter.genExprValue(
                 *Fortran::semantics::GetExpr(num->v), stmtCtx));
           } else if (const auto *staticArg =
                          std::get_if<Fortran::parser::AccGangArg::Static>(
                              &gangArg.u)) {
-
             const Fortran::parser::AccSizeExpr &sizeExpr = staticArg->v;
             if (sizeExpr.v) {
               gangStatic = fir::getBase(converter.genExprValue(
                   *Fortran::semantics::GetExpr(*sizeExpr.v), stmtCtx));
             } else {
               // * was passed as value and will be represented as a special
               // constant.
               gangStatic = firOpBuilder.createIntegerConstant(
                   clauseLocation, firOpBuilder.getIndexType(), starCst);
             }
+          } else if (const auto *dim =
+                         std::get_if<Fortran::parser::AccGangArg::Dim>(
+                             &gangArg.u)) {
+            gangDim = fir::getBase(converter.genExprValue(
+                *Fortran::semantics::GetExpr(dim->v), stmtCtx));
           }
         }
       }
       hasGang = true;
     } else if (const auto *workerClause =
                    std::get_if<Fortran::parser::AccClause::Worker>(&clause.u)) {
       if (workerClause->v) {
         workerNum = fir::getBase(converter.genExprValue(
if (const auto *gangClause =
       TODO(clauseLocation, "OpenACC compute construct reduction lowering");
     }
   }
 
   // Prepare the operand segment size attribute and the operands value range.
   llvm::SmallVector<mlir::Value> operands;
   llvm::SmallVector<int32_t> operandSegments;
   addOperand(operands, operandSegments, gangNum);
+  addOperand(operands, operandSegments, gangDim);
   addOperand(operands, operandSegments, gangStatic);
   addOperand(operands, operandSegments, workerNum);
   addOperand(operands, operandSegments, vectorNum);
   addOperands(operands, operandSegments, tileOperands);
   addOperands(operands, operandSegments, privateOperands);
   addOperands(operands, operandSegments, reductionOperands);
 
   auto loopOp = createRegionOp<mlir::acc::LoopOp, mlir::acc::YieldOp>(

flang/test/Lower/OpenACC/acc-loop.f90

 ! This test checks lowering of OpenACC loop directive.
 
 ! RUN: bbc -fopenacc -emit-fir %s -o - | FileCheck %s
 
 program acc_loop
 
   integer :: i, j
   integer, parameter :: n = 10
   real, dimension(n) :: a, b
   real, dimension(n, n) :: c, d
   integer :: gangNum = 8
+  integer :: gangDim = 1
   integer :: gangStatic = 8
   integer :: vectorLength = 128
   integer, parameter :: tileSize = 2
 
 
   !$acc loop
   DO i = 1, n
     a(i) = b(i)

 !CHECK:        fir.do_loop
 !CHECK:          acc.loop {
 !CHECK:            fir.do_loop
 !CHECK:            acc.yield
 !CHECK-NEXT:   }{{$}}
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
+ !$acc loop gang(num: gangNum, dim: gangDim, static: gangStatic)
+  DO i = 1, n
+    a(i) = b(i)
+  END DO
+
+!CHECK: acc.loop gang(num=%{{.*}} : i32, dim=%{{.*}}, static=%{{.*}} : i32) {
+!CHECK:        fir.do_loop
+!CHECK:        acc.yield
+!CHECK-NEXT: }{{$}}
+
+  !$acc loop gang(dim: 1)
+  DO i = 1, n
+    a(i) = b(i)
+  END DO
+
+!CHECK:      [[GANGDIM1:%.*]] = arith.constant 1 : i32
+!CHECK-NEXT: acc.loop gang(dim=[[GANGDIM1]] : i32) {
+!CHECK:        fir.do_loop
+!CHECK:        acc.yield
+!CHECK-NEXT: }{{$}}
+
 end program