[flang][openacc] Update num_gangs parser

[clementval]

Summary

Update num_gangs definition in ACC.td and its lowering
to support up to 3 arguments.

Depends on D153796
Depends on D153801

[razvanlupusoru]

Looks great!

flang/lib/Lower/OpenACC.cpp

 createComputeOp(Fortran::lower::AbstractConverter &converter,
                 mlir::Location currentLocation,
                 Fortran::semantics::SemanticsContext &semanticsContext,
                 Fortran::lower::StatementContext &stmtCtx,
                 const Fortran::parser::AccClauseList &accClauseList) {
 
   // Parallel operation operands
   mlir::Value async;
-  mlir::Value numGangs;
   mlir::Value numWorkers;
   mlir::Value vectorLength;
   mlir::Value ifCond;
   mlir::Value selfCond;
   mlir::Value waitDevnum;
   llvm::SmallVector<mlir::Value> waitOperands, attachEntryOperands,
       copyEntryOperands, copyoutEntryOperands, createEntryOperands,
-      dataClauseOperands;
+      dataClauseOperands, numGangs;
 
   llvm::SmallVector<mlir::Value> reductionOperands, privateOperands,
       firstprivateOperands;
   llvm::SmallVector<mlir::Attribute> privatizations, firstPrivatizations,
       reductionRecipes;
 
   // 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
if (const auto *asyncClause =
       genAsyncClause(converter, asyncClause, async, addAsyncAttr, stmtCtx);
     } else if (const auto *waitClause =
                    std::get_if<Fortran::parser::AccClause::Wait>(&clause.u)) {
       genWaitClause(converter, waitClause, waitOperands, waitDevnum,
                     addWaitAttr, stmtCtx);
     } else if (const auto *numGangsClause =
                    std::get_if<Fortran::parser::AccClause::NumGangs>(
                        &clause.u)) {
-      numGangs = fir::getBase(converter.genExprValue(
-          *Fortran::semantics::GetExpr(numGangsClause->v), stmtCtx));
+      for (const Fortran::parser::ScalarIntExpr &expr : numGangsClause->v)
+        numGangs.push_back(fir::getBase(converter.genExprValue(
+            *Fortran::semantics::GetExpr(expr), stmtCtx)));
     } else if (const auto *numWorkersClause =
                    std::get_if<Fortran::parser::AccClause::NumWorkers>(
                        &clause.u)) {
       numWorkers = fir::getBase(converter.genExprValue(
           *Fortran::semantics::GetExpr(numWorkersClause->v), stmtCtx));
     } else if (const auto *vectorLengthClause =
                    std::get_if<Fortran::parser::AccClause::VectorLength>(
                        &clause.u)) {
createComputeOp(Fortran::lower::AbstractConverter &converter,
   }
 
   // Prepare the operand segment size attribute and the operands value range.
   llvm::SmallVector<mlir::Value, 8> operands;
   llvm::SmallVector<int32_t, 8> operandSegments;
   addOperand(operands, operandSegments, async);
   addOperands(operands, operandSegments, waitOperands);
   if constexpr (!std::is_same_v<Op, mlir::acc::SerialOp>) {
-    addOperand(operands, operandSegments, numGangs);
+    addOperands(operands, operandSegments, numGangs);
     addOperand(operands, operandSegments, numWorkers);
     addOperand(operands, operandSegments, vectorLength);
   }
   addOperand(operands, operandSegments, ifCond);
   addOperand(operands, operandSegments, selfCond);
   if constexpr (!std::is_same_v<Op, mlir::acc::KernelsOp>) {
     addOperands(operands, operandSegments, reductionOperands);
     addOperands(operands, operandSegments, privateOperands);

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

 CHECK_SIMPLE_CLAUSE(Firstprivate, ACCC_firstprivate)
 CHECK_SIMPLE_CLAUSE(Host, ACCC_host)
 CHECK_SIMPLE_CLAUSE(If, ACCC_if)
 CHECK_SIMPLE_CLAUSE(IfPresent, ACCC_if_present)
 CHECK_SIMPLE_CLAUSE(Independent, ACCC_independent)
 CHECK_SIMPLE_CLAUSE(Link, ACCC_link)
 CHECK_SIMPLE_CLAUSE(NoCreate, ACCC_no_create)
 CHECK_SIMPLE_CLAUSE(Nohost, ACCC_nohost)
-CHECK_SIMPLE_CLAUSE(NumGangs, ACCC_num_gangs)
 CHECK_SIMPLE_CLAUSE(NumWorkers, ACCC_num_workers)
 CHECK_SIMPLE_CLAUSE(Present, ACCC_present)
 CHECK_SIMPLE_CLAUSE(Private, ACCC_private)
 CHECK_SIMPLE_CLAUSE(Read, ACCC_read)
 CHECK_SIMPLE_CLAUSE(Reduction, ACCC_reduction)
 CHECK_SIMPLE_CLAUSE(Seq, ACCC_seq)
 CHECK_SIMPLE_CLAUSE(Tile, ACCC_tile)
 CHECK_SIMPLE_CLAUSE(UseDevice, ACCC_use_device)
if (g.v) {
     }
 
     if (hasDim && hasNum)
       context_.Say(GetContext().clauseSource,
           "The num argument is not allowed when dim is specified"_err_en_US);
   }
 }
 
+void AccStructureChecker::Enter(const parser::AccClause::NumGangs &n) {
+  CheckAllowed(llvm::acc::Clause::ACCC_num_gangs);
+
+  if (n.v.size() > 3)
+    context_.Say(GetContext().clauseSource,
+        "NUM_GANGS clause accepts a maximum of 3 arguments"_err_en_US);
+}
+
 void AccStructureChecker::Enter(const parser::AccClause::Self &x) {
   CheckAllowed(llvm::acc::Clause::ACCC_self);
   const std::optional<parser::AccSelfClause> &accSelfClause = x.v;
   if (GetContext().directive == llvm::acc::Directive::ACCD_update &&
       ((accSelfClause &&
            std::holds_alternative<std::optional<parser::ScalarLogicalExpr>>(
                (*accSelfClause).u)) ||
           !accSelfClause)) {

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

!CHECK-NEXT: }{{$}}
   !$acc parallel num_gangs(numGangs)
   !$acc end parallel
 
 !CHECK:      [[NUMGANGS2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
 !CHECK:      acc.parallel num_gangs([[NUMGANGS2]] : i32) {
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 
+  !$acc parallel num_gangs(1, 1, 1)
+  !$acc end parallel
+
+!CHECK:      acc.parallel num_gangs(%{{.*}}, %{{.*}}, %{{.*}} : i32, i32, i32) {
+!CHECK:        acc.yield
+!CHECK-NEXT: }{{$}}
+
   !$acc parallel num_workers(10)
   !$acc end parallel
 
 !CHECK:      [[NUMWORKERS1:%.*]] = arith.constant 10 : i32
 !CHECK:      acc.parallel num_workers([[NUMWORKERS1]] : i32) {
 !CHECK:        acc.yield
 !CHECK-NEXT: }{{$}}
 

flang/test/Semantics/OpenACC/acc-parallel.f90

program openacc_parallel_validity
   !$acc end parallel
 
   !$acc parallel wait(wait1, wait2)
   !$acc end parallel
 
   !$acc parallel num_gangs(8)
   !$acc end parallel
 
+  !ERROR: NUM_GANGS clause accepts a maximum of 3 arguments
+  !$acc parallel num_gangs(1, 1, 1, 1)
+  !$acc end parallel
+
   !$acc parallel num_workers(8)
   !$acc end parallel
 
   !$acc parallel vector_length(128)
   !$acc end parallel
 
   !$acc parallel if(.true.)
   !$acc end parallel

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

 }
 
 // 2.15.1
 def ACCC_NoHost : Clause<"nohost"> {}
 
 // 2.5.9
 def ACCC_NumGangs : Clause<"num_gangs"> {
   let flangClass = "ScalarIntExpr";
+  let isValueList = 1;
 }
 
 // 2.5.10
 def ACCC_NumWorkers : Clause<"num_workers"> {
   let flangClass = "ScalarIntExpr";
 }
 
 // 2.7.5