[flang][openacc] Lower simple acc routine directive

[clementval]

Summary

This patch lower simple acc routine directive
with no clauses and no name inside function/subroutine.

Patch to handle name and clauses will follow up.
Patch to add attribute to the original routine will follow as well.

[razvanlupusoru]

Awesome!

flang/lib/Lower/OpenACC.cpp

 #include "flang/Parser/parse-tree.h"
 #include "flang/Semantics/expression.h"
 #include "flang/Semantics/tools.h"
 #include "llvm/Frontend/OpenACC/ACC.h.inc"
 
 // Special value for * passed in device_type or gang clauses.
 static constexpr std::int64_t starCst = -1;
 
+static unsigned routineCounter = 0;
+static constexpr llvm::StringRef accRoutinePrefix = "acc_routine_";
+
 /// Generate the acc.bounds operation from the descriptor information.
 static llvm::SmallVector<mlir::Value>
 genBoundsOpsFromBox(fir::FirOpBuilder &builder, mlir::Location loc,
                     Fortran::lower::AbstractConverter &converter,
                     fir::ExtendedValue dataExv, mlir::Value box) {
   llvm::SmallVector<mlir::Value> bounds;
   mlir::Type idxTy = builder.getIndexType();
   mlir::Type boundTy = builder.getType<mlir::acc::DataBoundsType>();
if (funcOp)
                            directiveLocation, accClauseList);
     else if (moduleOp)
       genDeclareInModule(converter, moduleOp, accClauseList);
     return;
   }
   llvm_unreachable("unsupported declarative directive");
 }
 
+static void
+genACC(Fortran::lower::AbstractConverter &converter,
+       Fortran::lower::pft::Evaluation &eval,
+       const Fortran::parser::OpenACCRoutineConstruct &routineConstruct) {
+  fir::FirOpBuilder &builder = converter.getFirOpBuilder();
+  mlir::Location loc = converter.genLocation(routineConstruct.source);
+  std::optional<Fortran::parser::Name> name =
+      std::get<std::optional<Fortran::parser::Name>>(routineConstruct.t);
+  const auto &clauses =
+      std::get<Fortran::parser::AccClauseList>(routineConstruct.t);
+  if (name)
+    TODO(loc, "acc routine with name");
+  if (!clauses.v.empty())
+    TODO(loc, "acc routine with clauses");
+
+  mlir::func::FuncOp func = builder.getFunction();
+  mlir::ModuleOp mod = builder.getModule();
+  mlir::OpBuilder modBuilder(mod.getBodyRegion());
+  std::stringstream routineOpName;
+  routineOpName << accRoutinePrefix.str() << routineCounter++;
+  modBuilder.create<mlir::acc::RoutineOp>(
+      loc, routineOpName.str(), func.getName(), mlir::StringAttr{},
+      mlir::UnitAttr{}, mlir::UnitAttr{}, mlir::UnitAttr{}, mlir::UnitAttr{},
+      mlir::UnitAttr{}, mlir::UnitAttr{}, mlir::IntegerAttr{});
+}
+
 void Fortran::lower::genOpenACCConstruct(
     Fortran::lower::AbstractConverter &converter,
     Fortran::semantics::SemanticsContext &semanticsContext,
     Fortran::lower::pft::Evaluation &eval,
     const Fortran::parser::OpenACCConstruct &accConstruct) {
 
   std::visit(
       common::visitors{
std::visit(
       common::visitors{
           [&](const Fortran::parser::OpenACCStandaloneDeclarativeConstruct
                   &standaloneDeclarativeConstruct) {
             genACC(converter, semanticsContext, fctCtx, eval,
                    standaloneDeclarativeConstruct);
           },
           [&](const Fortran::parser::OpenACCRoutineConstruct
                   &routineConstruct) {
-            TODO(converter.genLocation(routineConstruct.source),
-                 "OpenACC Routine construct not lowered yet!");
+            genACC(converter, eval, routineConstruct);
           },
       },
       accDeclConstruct.u);
 }

flang/test/Lower/OpenACC/Todo/acc-routine.f90

-! This test checks lowering of OpenACC routine Directive.
-
-// RUN: not flang-new -fc1 -emit-fir -fopenacc %s 2>&1 | FileCheck %s
-
-program main
-  // CHECK: not yet implemented: OpenACC Routine construct not lowered yet!
-  !$acc routine(sub) seq
-contains
-  subroutine sub(a)
-    real :: a(:)
-  end
-end

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

+! This test checks lowering of OpenACC routine directive.
+
+! RUN: bbc -fopenacc -emit-fir %s -o - | FileCheck %s
+
+subroutine acc_routine1()
+  !$acc routine
+end subroutine
+
+! CHECK: acc.routine @acc_routine_0 func(@_QPacc_routine1)
+! CHECK-LABEL: func.func @_QPacc_routine1()