[flang][openacc][NFC] Add API to create acc.private.recipe from FIR type

[clementval]

Summary

Simply make the creation of acc.private.recipe accesible through an API.
This will be useful when we will implement passes like the implicit
privatization.

[clementval]

Update signature so AbstractConverter is not needed

[razvanlupusoru]

Yes, exposing this is a great idea since recipe generation is specific to the dialect that the acc dialect is used with. Thanks for thinking about this.

flang/include/flang/Lower/OpenACC.h

 //===-- Lower/OpenACC.h -- lower OpenACC directives -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_OPENACC_H
 #define FORTRAN_LOWER_OPENACC_H
 
+namespace llvm {
+class StringRef;
+}
+
+namespace mlir {
+class Location;
+class Type;
+class OpBuilder;
+namespace acc {
+class PrivateRecipeOp;
+}
+} // namespace mlir
+
 namespace Fortran {
 namespace parser {
 struct OpenACCConstruct;
 struct OpenACCDeclarativeConstruct;
 } // namespace parser
 
 namespace semantics {
 class SemanticsContext;

 
 void genOpenACCConstruct(AbstractConverter &,
                          Fortran::semantics::SemanticsContext &,
                          pft::Evaluation &, const parser::OpenACCConstruct &);
 void genOpenACCDeclarativeConstruct(
     AbstractConverter &, 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);
+
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_OPENACC_H

flang/lib/Lower/OpenACC.cpp

if constexpr (std::is_same_v<ExitOp, mlir::acc::CopyoutOp> ||
       varPtr = entryOp.getVarPtr();
     builder.create<ExitOp>(entryOp.getLoc(), entryOp.getAccPtr(), varPtr,
                            entryOp.getBounds(), entryOp.getDataClause(),
                            structured, implicit,
                            builder.getStringAttr(*entryOp.getName()));
   }
 }
 
-static mlir::acc::PrivateRecipeOp
-createBasePrivateRecipeOp(fir::FirOpBuilder &builder, mlir::Value input,
-                          llvm::StringRef recipeName, mlir::Location loc) {
-  mlir::ModuleOp mod = builder.getModule();
+mlir::acc::PrivateRecipeOp
+Fortran::lower::createOrGetPrivateRecipe(mlir::OpBuilder &builder,
+                                         llvm::StringRef recipeName,
+                                         mlir::Location loc, mlir::Type ty) {
+  mlir::ModuleOp mod =
+      builder.getBlock()->getParent()->getParentOfType<mlir::ModuleOp>();
+  if (auto recipe = mod.lookupSymbol<mlir::acc::PrivateRecipeOp>(recipeName))
+    return recipe;
+
+  auto crtPos = builder.saveInsertionPoint();
   mlir::OpBuilder modBuilder(mod.getBodyRegion());
-  mlir::Type ty = input.getType();
   auto recipe =
       modBuilder.create<mlir::acc::PrivateRecipeOp>(loc, recipeName, ty);
   builder.createBlock(&recipe.getInitRegion(), recipe.getInitRegion().end(),
                       {ty}, {loc});
   builder.setInsertionPointToEnd(&recipe.getInitRegion().back());
   builder.create<mlir::acc::YieldOp>(
       loc, recipe.getInitRegion().front().getArgument(0));
+  builder.restoreInsertionPoint(crtPos);
   return recipe;
 }
 
 static void
 genPrivatizations(const Fortran::parser::AccObjectList &objectList,
                   Fortran::lower::AbstractConverter &converter,
                   Fortran::semantics::SemanticsContext &semanticsContext,
                   Fortran::lower::StatementContext &stmtCtx,
                   llvm::SmallVectorImpl<mlir::Value> &dataOperands,
                   llvm::SmallVector<mlir::Attribute> &privatizations) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
-  mlir::ModuleOp mod = builder.getModule();
   for (const auto &accObject : objectList.v) {
     llvm::SmallVector<mlir::Value> bounds;
     std::stringstream asFortran;
     mlir::Location operandLocation = genOperandLocation(converter, accObject);
     mlir::Value baseAddr = gatherDataOperandAddrAndBounds(
         converter, builder, semanticsContext, stmtCtx, accObject,
         operandLocation, asFortran, bounds);
-
     std::string recipeName = fir::getTypeAsString(
         baseAddr.getType(), converter.getKindMap(), "privatization");
-    if (auto recipe =
-            mod.lookupSymbol<mlir::acc::PrivateRecipeOp>(recipeName)) {
-      privatizations.push_back(mlir::SymbolRefAttr::get(
-          builder.getContext(), recipe.getSymName().str()));
-    } else {
-      auto crtPos = builder.saveInsertionPoint();
-      mlir::acc::PrivateRecipeOp newRecipe = createBasePrivateRecipeOp(
-          builder, baseAddr, recipeName, operandLocation);
-      builder.restoreInsertionPoint(crtPos);
-      privatizations.push_back(mlir::SymbolRefAttr::get(
-          builder.getContext(), newRecipe.getSymName().str()));
-    }
+    mlir::acc::PrivateRecipeOp recipe =
+        Fortran::lower::createOrGetPrivateRecipe(
+            builder, recipeName, operandLocation, baseAddr.getType());
     dataOperands.push_back(baseAddr);
   }
 }
 
 template <typename Clause>
 static void genObjectListWithModifier(
     const Clause *x, Fortran::lower::AbstractConverter &converter,
     Fortran::semantics::SemanticsContext &semanticsContext,