[flang][openacc] Add global destructor for acc declare construct

[clementval]

Summary

Add the acc.global_dtor when lowering the OpenACC declare
construct.

[clementval]

Add missing data exit operation

[razvanlupusoru]

This change looks good. I see a small error with regards to "structured" but can be resolved in a follow-up change!

flang/lib/Lower/OpenACC.cpp

2321

Structured flag should be false for declare in the acc constructor. Sorry I didn't catch this last review. Structured for declare operations will be true when in same function though!

[clementval]

flang/lib/Lower/OpenACC.cpp

2321

Thanks for catching this!

flang/lib/Lower/OpenACC.cpp

 static void addDeclareAttr(fir::FirOpBuilder &builder, mlir::Operation *op,
                            mlir::acc::DataClause clause) {
   op->setAttr(mlir::acc::getDeclareAttrName(),
               mlir::acc::DeclareAttr::get(builder.getContext(),
                                           mlir::acc::DataClauseAttr::get(
                                               builder.getContext(), clause)));
 }
 
+template <typename GlobalOp, typename EntryOp, typename DeclareOp>
+static void createDeclareGlobalOp(mlir::OpBuilder &modBuilder,
+                                  fir::FirOpBuilder &builder,
+                                  mlir::Location loc, fir::GlobalOp &globalOp,
+                                  mlir::acc::DataClause clause) {
+  std::stringstream declareGlobalName;
+
+  if constexpr (std::is_same_v<GlobalOp, mlir::acc::GlobalConstructorOp>)
+    declareGlobalName << globalOp.getSymName().str() << "_acc_ctor";
+  else if constexpr (std::is_same_v<GlobalOp, mlir::acc::GlobalDestructorOp>)
+    declareGlobalName << globalOp.getSymName().str() << "_acc_dtor";
+
+  GlobalOp declareGlobalOp =
+      modBuilder.create<GlobalOp>(loc, declareGlobalName.str());
+  builder.createBlock(&declareGlobalOp.getRegion(),
+                      declareGlobalOp.getRegion().end(), {}, {});
+  builder.setInsertionPointToEnd(&declareGlobalOp.getRegion().back());
+
+  fir::AddrOfOp addrOp = builder.create<fir::AddrOfOp>(
+      loc, fir::ReferenceType::get(globalOp.getType()), globalOp.getSymbol());
+  addDeclareAttr(builder, addrOp.getOperation(), clause);
+
+  std::stringstream asFortran;
+  asFortran << Fortran::lower::mangle::demangleName(globalOp.getSymName());
+  llvm::SmallVector<mlir::Value> bounds;
+  EntryOp entry = createDataEntryOp<EntryOp>(builder, loc, addrOp.getResTy(),
+                                             asFortran, bounds, true, clause,
+                                             addrOp.getResTy().getType());
+  builder.create<DeclareOp>(loc, mlir::ValueRange(entry.getAccPtr()));
+  builder.create<mlir::acc::TerminatorOp>(loc);
+  modBuilder.setInsertionPointAfter(declareGlobalOp);
+}
+
+template <typename EntryOp>
 static void genGlobalCtors(Fortran::lower::AbstractConverter &converter,
                            mlir::OpBuilder &modBuilder,
                            const Fortran::parser::AccObjectList &accObjectList,
                            mlir::acc::DataClause clause) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   for (const auto &accObject : accObjectList.v) {
     mlir::Location operandLocation = genOperandLocation(converter, accObject);
     std::visit(
         Fortran::common::visitors{
             [&](const Fortran::parser::Designator &designator) {
               if (const auto *name =
                       Fortran::semantics::getDesignatorNameIfDataRef(
                           designator)) {
                 std::string globalName = converter.mangleName(*name->symbol);
                 fir::GlobalOp globalOp = builder.getNamedGlobal(globalName);
                 if (!globalOp)
                   llvm::report_fatal_error("could not retrieve global symbol");
-
-                // Create the new global constructor op after the FIR global.
-                std::stringstream globalCtorName;
-                globalCtorName << globalName << "_acc_ctor";
-                auto crtPos = builder.saveInsertionPoint();
                 addDeclareAttr(builder, globalOp.getOperation(), clause);
+                auto crtPos = builder.saveInsertionPoint();
                 modBuilder.setInsertionPointAfter(globalOp);
-                auto globalCtor =
-                    modBuilder.create<mlir::acc::GlobalConstructorOp>(
-                        operandLocation, globalCtorName.str());
-                builder.createBlock(&globalCtor.getRegion(),
-                                    globalCtor.getRegion().end(), {}, {});
-                builder.setInsertionPointToEnd(&globalCtor.getRegion().back());
-
-                // Fill up the global constructor region.
-                fir::AddrOfOp addrOp = builder.create<fir::AddrOfOp>(
-                    operandLocation,
-                    fir::ReferenceType::get(globalOp.getType()),
-                    globalOp.getSymbol());
-                addDeclareAttr(builder, addrOp.getOperation(), clause);
-                std::stringstream asFortran;
-                asFortran << Fortran::lower::mangle::demangleName(globalName);
-                llvm::SmallVector<mlir::Value> bounds;
-                mlir::acc::CreateOp entry =
-                    createDataEntryOp<mlir::acc::CreateOp>(
-                        builder, operandLocation, addrOp.getResTy(), asFortran,
-                        bounds, true, clause, addrOp.getResTy().getType());
-                builder.create<mlir::acc::DeclareEnterOp>(
-                    operandLocation, mlir::ValueRange{entry.getAccPtr()});
-                builder.create<mlir::acc::TerminatorOp>(operandLocation);
+                createDeclareGlobalOp<mlir::acc::GlobalConstructorOp, EntryOp,
+                                      mlir::acc::DeclareEnterOp>(
+                    modBuilder, builder, operandLocation, globalOp, clause);
+                createDeclareGlobalOp<mlir::acc::GlobalDestructorOp,
+                                      mlir::acc::GetDevicePtrOp,
+                                      mlir::acc::DeclareExitOp>(
+                    modBuilder, builder, operandLocation, globalOp, clause);
                 builder.restoreInsertionPoint(crtPos);
-
-                // TODO: global destructor.
               }
             },
             [&](const Fortran::parser::Name &name) {
               TODO(operandLocation, "OpenACC Global Ctor from parser::Name");
             }},
         accObject.u);
   }
 }
 
-template <typename Clause>
+template <typename Clause, typename EntryOp>
 static void
 genGlobalCtorsWithModifier(Fortran::lower::AbstractConverter &converter,
                            mlir::OpBuilder &modBuilder, const Clause *x,
                            Fortran::parser::AccDataModifier::Modifier mod,
                            const mlir::acc::DataClause clause,
                            const mlir::acc::DataClause clauseWithModifier) {
   const Fortran::parser::AccObjectListWithModifier &listWithModifier = x->v;
   const auto &accObjectList =
       std::get<Fortran::parser::AccObjectList>(listWithModifier.t);
   const auto &modifier =
       std::get<std::optional<Fortran::parser::AccDataModifier>>(
           listWithModifier.t);
   mlir::acc::DataClause dataClause =
       (modifier && (*modifier).v == mod) ? clauseWithModifier : clause;
-  genGlobalCtors(converter, modBuilder, accObjectList, dataClause);
+  genGlobalCtors<EntryOp>(converter, modBuilder, accObjectList, dataClause);
 }
 
 static void genACC(Fortran::lower::AbstractConverter &converter,
                    Fortran::semantics::SemanticsContext &semanticsContext,
                    Fortran::lower::pft::Evaluation &eval,
                    const Fortran::parser::OpenACCStandaloneDeclarativeConstruct
                        &declareConstruct) {
 
if (declarativeDir.v == llvm::acc::Directive::ACCD_declare) {
     if (funcOp) {
       TODO(funcOp.getLoc(), "OpenACC declare in function/subroutine");
     } else if (moduleOp) {
       mlir::OpBuilder modBuilder(moduleOp.getBodyRegion());
       for (const Fortran::parser::AccClause &clause : accClauseList.v) {
         mlir::Location clauseLocation = converter.genLocation(clause.source);
         if (const auto *createClause =
                 std::get_if<Fortran::parser::AccClause::Create>(&clause.u)) {
-          genGlobalCtorsWithModifier<Fortran::parser::AccClause::Create>(
+          genGlobalCtorsWithModifier<Fortran::parser::AccClause::Create,
+                                     mlir::acc::CreateOp>(
               converter, modBuilder, createClause,
               Fortran::parser::AccDataModifier::Modifier::Zero,
               mlir::acc::DataClause::acc_create,
               mlir::acc::DataClause::acc_create_zero);
         } else {
           TODO(clauseLocation, "OpenACC declare clause");
         }
       }

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

 
 ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_testEdata1_acc_ctor {
 ! CHECK:         %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_testEdata1) {acc.declare = #acc.declare<dataClause = acc_create>} : !fir.ref<!fir.array<100000xf32>>
 ! CHECK:         %[[CREATE:.*]] = acc.create varPtr(%[[GLOBAL_ADDR]] : !fir.ref<!fir.array<100000xf32>>) -> !fir.ref<!fir.array<100000xf32>> {name = "data1"}
 ! CHECK:         acc.declare_enter dataOperands(%[[CREATE]] : !fir.ref<!fir.array<100000xf32>>)
 ! CHECK:         acc.terminator
 ! CHECK:       }
 
+! CHECK-LABEL: acc.global_dtor @_QMacc_declare_testEdata1_acc_dtor {
+! CHECK:         %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_testEdata1) {acc.declare = #acc.declare<dataClause = acc_create>} : !fir.ref<!fir.array<100000xf32>>
+! CHECK:         %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref<!fir.array<100000xf32>>) -> !fir.ref<!fir.array<100000xf32>> {dataClause = #acc<data_clause acc_create>, name = "data1"}
+! CHECK:         acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref<!fir.array<100000xf32>>)
+! CHECK:         acc.terminator
+! CHECK:       }
+
 ! CHECK-LABEL: fir.global @_QMacc_declare_testEdata2 {acc.declare = #acc.declare<dataClause =  acc_create_zero>} : !fir.array<100000xf32>
 
 ! CHECK-LABEL: acc.global_ctor @_QMacc_declare_testEdata2_acc_ctor {
 ! CHECK:         %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_testEdata2) {acc.declare = #acc.declare<dataClause =  acc_create_zero>} : !fir.ref<!fir.array<100000xf32>>
 ! CHECK:         %[[CREATE:.*]] = acc.create varPtr(%[[GLOBAL_ADDR]] : !fir.ref<!fir.array<100000xf32>>) -> !fir.ref<!fir.array<100000xf32>> {dataClause = #acc<data_clause acc_create_zero>, name = "data2"}
 ! CHECK:         acc.declare_enter dataOperands(%[[CREATE]] : !fir.ref<!fir.array<100000xf32>>)
 ! CHECK:         acc.terminator
 ! CHECK:       }
+
+! CHECK-LABEL: acc.global_dtor @_QMacc_declare_testEdata2_acc_dtor {
+! CHECK:         %[[GLOBAL_ADDR:.*]] = fir.address_of(@_QMacc_declare_testEdata2) {acc.declare = #acc.declare<dataClause =  acc_create_zero>} : !fir.ref<!fir.array<100000xf32>>
+! CHECK:         %[[DEVICEPTR:.*]] = acc.getdeviceptr varPtr(%[[GLOBAL_ADDR]] : !fir.ref<!fir.array<100000xf32>>) -> !fir.ref<!fir.array<100000xf32>> {dataClause = #acc<data_clause acc_create_zero>, name = "data2"}
+! CHECK:         acc.declare_exit dataOperands(%[[DEVICEPTR]] : !fir.ref<!fir.array<100000xf32>>)
+! CHECK:         acc.terminator
+! CHECK:       }