[flang][openacc][NFC] Rename createRegisterFunc and refactor

[clementval]

Summary

Depends on D157530

[razvanlupusoru]

The renaming is great. Glad that we are capturing intent better. Looks good to me.

flang/include/flang/Lower/OpenACC.h

 
 class AbstractConverter;
 class StatementContext;
 
 namespace pft {
 struct Evaluation;
 } // namespace pft
 
+static constexpr llvm::StringRef declarePostAllocSuffix =
+    "_acc_declare_update_desc_post_alloc";
 static constexpr llvm::StringRef declarePreDeallocSuffix =
     "_acc_declare_update_desc_pre_dealloc";
 static constexpr llvm::StringRef declarePostDeallocSuffix =
     "_acc_declare_update_desc_post_dealloc";
 
 void genOpenACCConstruct(AbstractConverter &,
                          Fortran::semantics::SemanticsContext &,
                          pft::Evaluation &, const parser::OpenACCConstruct &);

flang/lib/Lower/OpenACC.cpp

builder.create<ExitOp>(entryOp.getLoc(), entryOp.getAccPtr(), varPtr,
                            entryOp.getBounds(), entryOp.getDataClause(),
                            /*structured=*/false, /*implicit=*/false,
                            builder.getStringAttr(*entryOp.getName()));
   }
   builder.create<mlir::acc::TerminatorOp>(loc);
   modBuilder.setInsertionPointAfter(declareGlobalOp);
 }
 
+static mlir::func::FuncOp createDeclareFunc(mlir::OpBuilder &modBuilder,
+                                            fir::FirOpBuilder &builder,
+                                            mlir::Location loc,
+                                            llvm::StringRef funcName) {
+  auto funcTy = mlir::FunctionType::get(modBuilder.getContext(), {}, {});
+  auto funcOp = modBuilder.create<mlir::func::FuncOp>(loc, funcName, funcTy);
+  funcOp.setVisibility(mlir::SymbolTable::Visibility::Private);
+  builder.createBlock(&funcOp.getRegion(), funcOp.getRegion().end(), {}, {});
+  builder.setInsertionPointToEnd(&funcOp.getRegion().back());
+  builder.create<mlir::func::ReturnOp>(loc);
+  builder.setInsertionPointToStart(&funcOp.getRegion().back());
+  return funcOp;
+}
+
 template <typename EntryOp>
-static void createRegisterFunc(mlir::OpBuilder &modBuilder,
-                               fir::FirOpBuilder &builder, mlir::Location loc,
-                               fir::GlobalOp &globalOp,
+static void createDeclareAllocFunc(mlir::OpBuilder &modBuilder,
+                                   fir::FirOpBuilder &builder,
+                                   mlir::Location loc, fir::GlobalOp &globalOp,
                                    mlir::acc::DataClause clause) {
   std::stringstream registerFuncName;
   registerFuncName << globalOp.getSymName().str()
-                   << "_acc_declare_update_desc_post_alloc";
-  auto funcTy = mlir::FunctionType::get(modBuilder.getContext(), {}, {});
-  mlir::func::FuncOp registerFuncOp = modBuilder.create<mlir::func::FuncOp>(
-      loc, registerFuncName.str(), funcTy);
-  registerFuncOp.setVisibility(mlir::SymbolTable::Visibility::Private);
-
-  builder.createBlock(&registerFuncOp.getRegion(),
-                      registerFuncOp.getRegion().end(), {}, {});
-  builder.setInsertionPointToEnd(&registerFuncOp.getRegion().back());
+                   << Fortran::lower::declarePostAllocSuffix.str();
+  auto registerFuncOp =
+      createDeclareFunc(modBuilder, builder, loc, registerFuncName.str());
 
   fir::AddrOfOp addrOp = builder.create<fir::AddrOfOp>(
       loc, fir::ReferenceType::get(globalOp.getType()), globalOp.getSymbol());
   auto loadOp = builder.create<fir::LoadOp>(loc, addrOp.getResult());
   fir::BoxAddrOp boxAddrOp = builder.create<fir::BoxAddrOp>(loc, loadOp);
   addDeclareAttr(builder, boxAddrOp.getOperation(), clause);
 
   std::stringstream asFortran;
static void createDeclareAllocFunc(mlir::OpBuilder &modBuilder,
   mlir::acc::UpdateDeviceOp updateDeviceOp =
       createDataEntryOp<mlir::acc::UpdateDeviceOp>(
           builder, loc, addrOp, asFortran, bounds,
           /*structured=*/false, /*implicit=*/true,
           mlir::acc::DataClause::acc_update_device, addrOp.getType());
   llvm::SmallVector<int32_t> operandSegments{0, 0, 0, 0, 0, 1};
   llvm::SmallVector<mlir::Value> operands{updateDeviceOp.getResult()};
   createSimpleOp<mlir::acc::UpdateOp>(builder, loc, operands, operandSegments);
-
-  builder.create<mlir::func::ReturnOp>(loc);
   modBuilder.setInsertionPointAfter(registerFuncOp);
 }
 
-static mlir::func::FuncOp createDeclareFunc(mlir::OpBuilder &modBuilder,
-                                            fir::FirOpBuilder &builder,
-                                            mlir::Location loc,
-                                            llvm::StringRef funcName) {
-  auto funcTy = mlir::FunctionType::get(modBuilder.getContext(), {}, {});
-  auto funcOp = modBuilder.create<mlir::func::FuncOp>(loc, funcName, funcTy);
-  funcOp.setVisibility(mlir::SymbolTable::Visibility::Private);
-  builder.createBlock(&funcOp.getRegion(), funcOp.getRegion().end(), {}, {});
-  builder.setInsertionPointToEnd(&funcOp.getRegion().back());
-  builder.create<mlir::func::ReturnOp>(loc);
-  builder.setInsertionPointToStart(&funcOp.getRegion().back());
-  return funcOp;
-}
-
 /// Action to be performed on deallocation are split in two distinct functions.
 /// - Pre deallocation function includes all the action to be performed before
 ///   the actual deallocation is done on the host side.
 /// - Post deallocation function includes update to the descriptor.
 template <typename ExitOp>
 static void createDeclareDeallocFunc(mlir::OpBuilder &modBuilder,
                                      fir::FirOpBuilder &builder,
                                      mlir::Location loc,
std::visit(
                 modBuilder.setInsertionPointAfter(globalOp);
                 if (mlir::isa<fir::BaseBoxType>(
                         fir::unwrapRefType(globalOp.getType()))) {
                   createDeclareGlobalOp<mlir::acc::GlobalConstructorOp,
                                         mlir::acc::CopyinOp,
                                         mlir::acc::DeclareEnterOp, ExitOp>(
                       modBuilder, builder, operandLocation, globalOp, clause,
                       /*implicit=*/true);
-                  createRegisterFunc<EntryOp>(
+                  createDeclareAllocFunc<EntryOp>(
                       modBuilder, builder, operandLocation, globalOp, clause);
                   if constexpr (!std::is_same_v<EntryOp, ExitOp>)
                     createDeclareDeallocFunc<ExitOp>(
                         modBuilder, builder, operandLocation, globalOp, clause);
                 } else {
                   createDeclareGlobalOp<mlir::acc::GlobalConstructorOp, EntryOp,
                                         mlir::acc::DeclareEnterOp, ExitOp>(
                       modBuilder, builder, operandLocation, globalOp, clause,