[flang][openacc] Lower the exit part for OpenACC declare in function/subroutine

[clementval]

Summary

This patch adds lowering for the exit part of the OpenACC declare construct
in function/subroutine.

Depends on D156560

[razvanlupusoru]

Looks great to me! Awesome to see how you were able to attach the generation of this at end of region.

[clementval]

Fix patch application

[clementval]

Rebase

flang/include/flang/Lower/OpenACC.h

 
 namespace semantics {
 class SemanticsContext;
 }
 
 namespace lower {
 
 class AbstractConverter;
+class StatementContext;
 
 namespace pft {
 struct Evaluation;
 } // namespace pft
 
 void genOpenACCConstruct(AbstractConverter &,
                          Fortran::semantics::SemanticsContext &,
                          pft::Evaluation &, const parser::OpenACCConstruct &);
 void genOpenACCDeclarativeConstruct(
     AbstractConverter &, Fortran::semantics::SemanticsContext &,
-    pft::Evaluation &, const parser::OpenACCDeclarativeConstruct &);
+    StatementContext &, pft::Evaluation &,
+    const parser::OpenACCDeclarativeConstruct &);
 
 /// Get a acc.private.recipe op for the given type or create it if it does not
 /// exist yet.
 mlir::acc::PrivateRecipeOp createOrGetPrivateRecipe(mlir::OpBuilder &,
                                                     llvm::StringRef,
                                                     mlir::Location, mlir::Type);
 
 /// Get a acc.reduction.recipe op for the given type or create it if it does not

flang/lib/Lower/Bridge.cpp

void genFIR(const Fortran::parser::OpenACCConstruct &acc) {
     for (Fortran::lower::pft::Evaluation &e : getEval().getNestedEvaluations())
       genFIR(e);
     builder->restoreInsertionPoint(insertPt);
   }
 
   void genFIR(const Fortran::parser::OpenACCDeclarativeConstruct &accDecl) {
     mlir::OpBuilder::InsertPoint insertPt = builder->saveInsertionPoint();
     genOpenACCDeclarativeConstruct(*this, bridge.getSemanticsContext(),
-                                   getEval(), accDecl);
+                                   bridge.fctCtx(), getEval(), accDecl);
     for (Fortran::lower::pft::Evaluation &e : getEval().getNestedEvaluations())
       genFIR(e);
     builder->restoreInsertionPoint(insertPt);
   }
 
   void genFIR(const Fortran::parser::OpenMPConstruct &omp) {
     mlir::OpBuilder::InsertPoint insertPt = builder->saveInsertionPoint();
     localSymbols.pushScope();

flang/lib/Lower/OpenACC.cpp

mlir::acc::DataClause dataClause =
       (modifier && (*modifier).v == mod) ? clauseWithModifier : clause;
   genGlobalCtors<EntryOp, ExitOp>(converter, modBuilder, accObjectList,
                                   dataClause);
 }
 
 static void
 genDeclareInFunction(Fortran::lower::AbstractConverter &converter,
                      Fortran::semantics::SemanticsContext &semanticsContext,
+                     Fortran::lower::StatementContext &fctCtx,
                      mlir::Location loc,
                      const Fortran::parser::AccClauseList &accClauseList) {
   llvm::SmallVector<mlir::Value> dataClauseOperands, copyEntryOperands;
   Fortran::lower::StatementContext stmtCtx;
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
     if (const auto *copyClause =
             std::get_if<Fortran::parser::AccClause::Copy>(&clause.u)) {
       auto crtDataStart = dataClauseOperands.size();
 
       genDataOperandOperations<mlir::acc::CopyinOp>(
           copyClause->v, converter, semanticsContext, stmtCtx,
           dataClauseOperands, mlir::acc::DataClause::acc_copy,
           /*structured=*/true, /*setDeclareAttr=*/true);
       copyEntryOperands.append(dataClauseOperands.begin() + crtDataStart,
                                dataClauseOperands.end());
     } else {
       mlir::Location clauseLocation = converter.genLocation(clause.source);
       TODO(clauseLocation, "clause on declare directive");
     }
   }
-
   builder.create<mlir::acc::DeclareEnterOp>(loc, dataClauseOperands);
+
+  // Attach declare exit operation generation to function context.
+  fctCtx.attachCleanup([&builder, loc, copyEntryOperands]() {
+    builder.create<mlir::acc::DeclareExitOp>(loc, copyEntryOperands);
+    genDataExitOperations<mlir::acc::CopyinOp, mlir::acc::CopyoutOp>(
+        builder, copyEntryOperands, /*structured=*/true, /*implicit=*/false);
+  });
 }
 
 static void
 genDeclareInModule(Fortran::lower::AbstractConverter &converter,
                    mlir::ModuleOp &moduleOp,
                    const Fortran::parser::AccClauseList &accClauseList) {
   mlir::OpBuilder modBuilder(moduleOp.getBodyRegion());
   for (const Fortran::parser::AccClause &clause : accClauseList.v) {
for (const Fortran::parser::AccClause &clause : accClauseList.v) {
     } else {
       llvm::report_fatal_error("unsupported clause on DECLARE directive");
     }
   }
 }
 
 static void genACC(Fortran::lower::AbstractConverter &converter,
                    Fortran::semantics::SemanticsContext &semanticsContext,
+                   Fortran::lower::StatementContext &fctCtx,
                    Fortran::lower::pft::Evaluation &eval,
                    const Fortran::parser::OpenACCStandaloneDeclarativeConstruct
                        &declareConstruct) {
 
   const auto &declarativeDir =
       std::get<Fortran::parser::AccDeclarativeDirective>(declareConstruct.t);
   mlir::Location directiveLocation =
       converter.genLocation(declarativeDir.source);
   const auto &accClauseList =
       std::get<Fortran::parser::AccClauseList>(declareConstruct.t);
 
   if (declarativeDir.v == llvm::acc::Directive::ACCD_declare) {
     fir::FirOpBuilder &builder = converter.getFirOpBuilder();
     auto moduleOp =
         builder.getBlock()->getParent()->getParentOfType<mlir::ModuleOp>();
     auto funcOp =
         builder.getBlock()->getParent()->getParentOfType<mlir::func::FuncOp>();
     if (funcOp)
-      genDeclareInFunction(converter, semanticsContext, directiveLocation,
-                           accClauseList);
+      genDeclareInFunction(converter, semanticsContext, fctCtx,
+                           directiveLocation, accClauseList);
     else if (moduleOp)
       genDeclareInModule(converter, moduleOp, accClauseList);
     return;
   }
   llvm_unreachable("unsupported declarative directive");
 }
 
 void Fortran::lower::genOpenACCConstruct(
std::visit(
           },
       },
       accConstruct.u);
 }
 
 void Fortran::lower::genOpenACCDeclarativeConstruct(
     Fortran::lower::AbstractConverter &converter,
     Fortran::semantics::SemanticsContext &semanticsContext,
+    Fortran::lower::StatementContext &fctCtx,
     Fortran::lower::pft::Evaluation &eval,
     const Fortran::parser::OpenACCDeclarativeConstruct &accDeclConstruct) {
 
   std::visit(
       common::visitors{
           [&](const Fortran::parser::OpenACCStandaloneDeclarativeConstruct
                   &standaloneDeclarativeConstruct) {
-            genACC(converter, semanticsContext, eval,
+            genACC(converter, semanticsContext, fctCtx, eval,
                    standaloneDeclarativeConstruct);
           },
           [&](const Fortran::parser::OpenACCRoutineConstruct
                   &routineConstruct) {
             TODO(converter.genLocation(routineConstruct.source),
                  "OpenACC Routine construct not lowered yet!");
           },
       },
       accDeclConstruct.u);
 }

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

module acc_declare
   end subroutine
 
 ! CHECK-LABEL: func.func @_QMacc_declarePacc_declare_copy()
 ! CHECK: %[[ALLOCA:.*]] = fir.alloca !fir.array<100xi32> {acc.declare = #acc.declare<dataClause =  acc_copy>, bindc_name = "a", uniq_name = "_QMacc_declareFacc_declare_copyEa"}
 ! CHECK: %[[BOUND:.*]] = acc.bounds   lowerbound(%{{.*}} : index) upperbound(%{{.*}} : index) extent(%{{.*}} : index) stride(%c1 : index) startIdx(%c1 : index)
 ! CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[ALLOCA]] : !fir.ref<!fir.array<100xi32>>) bounds(%[[BOUND]]) -> !fir.ref<!fir.array<100xi32>> {dataClause = #acc<data_clause acc_copy>, name = "a"}
 ! CHECK: acc.declare_enter dataOperands(%[[COPYIN]] : !fir.ref<!fir.array<100xi32>>)
 
+! CHECK: %{{.*}}:2 = fir.do_loop %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} iter_args(%{{.*}} = %{{.*}}) -> (index, i32) {
+! CHECK: }
+
+! CHECK: acc.declare_exit dataOperands(%[[COPYIN]] : !fir.ref<!fir.array<100xi32>>)
+! CHECK: acc.copyout accPtr(%[[COPYIN]] : !fir.ref<!fir.array<100xi32>>) bounds(%[[BOUND]]) to varPtr(%[[ALLOCA]] : !fir.ref<!fir.array<100xi32>>) {dataClause = #acc<data_clause acc_copy>, name = "a"}
+
+! CHECK: return
+
 end module