[flang][NFC] remove stmtCtx genIntrinsicCall 1/6

[tblah]

Summary

This removes IntrinsicCall's dependency upon StatementContext, which
will make it easier to move IntrinsicCall into flang/lib/Optimizer, for
use in passes.

[jeanPerier]

Thanks

flang/lib/Lower/ConvertExpr.cpp

662 ↗

(On Diff #493958)

I would rather I would rather add a declaration in CustomIntrinsicCall.h and use it here rather than duplicating it since it is exactly the same.

[tblah]

Changes: move function to CustomIntrinsicCall.h

[jeanPerier]

Thanks

flang/include/flang/Lower/CustomIntrinsicCall.h

 /// be called during the loop nest generation for elemental intrinsics. It will
 /// not generate any implicit loop nest on its own).
 fir::ExtendedValue
 lowerCustomIntrinsic(fir::FirOpBuilder &builder, mlir::Location loc,
                      llvm::StringRef name, std::optional<mlir::Type> retTy,
                      const OperandPresent &isPresentCheck,
                      const OperandGetter &getOperand, std::size_t numOperands,
                      Fortran::lower::StatementContext &stmtCtx);
+
+/// DEPRICATED: NEW CODE SHOULD USE THE VERSION OF genIntrinsicCall WITHOUT A
+/// StatementContext, DECLARED IN IntrinsicCall.h
+/// Generate the FIR+MLIR operations for the generic intrinsic \p name
+/// with argument \p args and expected result type \p resultType.
+/// Returned fir::ExtendedValue is the returned Fortran intrinsic value.
+fir::ExtendedValue genIntrinsicCall(fir::FirOpBuilder &builder,
+                                    mlir::Location loc, llvm::StringRef name,
+                                    std::optional<mlir::Type> resultType,
+                                    llvm::ArrayRef<fir::ExtendedValue> args,
+                                    StatementContext &stmtCtx);
+
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_CUSTOMINTRINSICCALL_H

flang/include/flang/Lower/IntrinsicCall.h

 
 namespace Fortran::lower {
 
 class StatementContext;
 
 // TODO: Error handling interface ?
 // TODO: Implementation is incomplete. Many intrinsics to tbd.
 
-/// Generate the FIR+MLIR operations for the generic intrinsic \p name
-/// with arguments \p args and expected result type \p resultType.
-/// Returned mlir::Value is the returned Fortran intrinsic value.
-fir::ExtendedValue genIntrinsicCall(fir::FirOpBuilder &, mlir::Location,
-                                    llvm::StringRef name,
-                                    std::optional<mlir::Type> resultType,
-                                    llvm::ArrayRef<fir::ExtendedValue> args,
-                                    StatementContext &);
-
 /// Same as the other genIntrinsicCall version above, except that the result
 /// deallocation, if required, is not added to a StatementContext. Instead, an
 /// extra boolean result indicates if the result must be freed after use.
 std::pair<fir::ExtendedValue, bool>
 genIntrinsicCall(fir::FirOpBuilder &, mlir::Location, llvm::StringRef name,
                  std::optional<mlir::Type> resultType,
                  llvm::ArrayRef<fir::ExtendedValue> args);
 

flang/lib/Lower/CustomIntrinsicCall.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/CustomIntrinsicCall.h"
 #include "flang/Evaluate/expression.h"
 #include "flang/Evaluate/fold.h"
 #include "flang/Evaluate/tools.h"
 #include "flang/Lower/IntrinsicCall.h"
+#include "flang/Lower/StatementContext.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include <optional>
 
 /// Is this a call to MIN or MAX intrinsic with arguments that may be absent at
 /// runtime? This is a special case because MIN and MAX can have any number of
 /// arguments.
 static bool isMinOrMaxWithDynamicallyOptionalArg(
     llvm::StringRef name, const Fortran::evaluate::ProcedureRef &procRef,
bool Fortran::lower::intrinsicRequiresCustomOptionalHandling(
     const Fortran::evaluate::SpecificIntrinsic &intrinsic,
     AbstractConverter &converter) {
   llvm::StringRef name = intrinsic.name;
   Fortran::evaluate::FoldingContext &fldCtx = converter.getFoldingContext();
   return isMinOrMaxWithDynamicallyOptionalArg(name, procRef, fldCtx) ||
          isIshftcWithDynamicallyOptionalArg(name, procRef, fldCtx);
 }
 
+/// Generate the FIR+MLIR operations for the generic intrinsic \p name
+/// with arguments \p args and the expected result type \p resultType.
+/// Returned fir::ExtendedValue is the returned Fortran intrinsic value.
+fir::ExtendedValue
+Fortran::lower::genIntrinsicCall(fir::FirOpBuilder &builder, mlir::Location loc,
+                                 llvm::StringRef name,
+                                 std::optional<mlir::Type> resultType,
+                                 llvm::ArrayRef<fir::ExtendedValue> args,
+                                 Fortran::lower::StatementContext &stmtCtx) {
+  auto [result, mustBeFreed] =
+      Fortran::lower::genIntrinsicCall(builder, loc, name, resultType, args);
+  if (mustBeFreed) {
+    mlir::Value addr = fir::getBase(result);
+    if (auto *box = result.getBoxOf<fir::BoxValue>())
+      addr =
+          builder.create<fir::BoxAddrOp>(loc, box->getMemTy(), box->getAddr());
+    fir::FirOpBuilder *bldr = &builder;
+    stmtCtx.attachCleanup([=]() { bldr->create<fir::FreeMemOp>(loc, addr); });
+  }
+  return result;
+}
+
 static void prepareMinOrMaxArguments(
     const Fortran::evaluate::ProcedureRef &procRef,
     const Fortran::evaluate::SpecificIntrinsic &intrinsic,
     std::optional<mlir::Type> retTy,
     const Fortran::lower::OperandPrepare &prepareOptionalArgument,
     const Fortran::lower::OperandPrepare &prepareOtherArgument,
     Fortran::lower::AbstractConverter &converter) {
   assert(retTy && "MIN and MAX must have a return type");
lowerMinOrMax(fir::FirOpBuilder &builder, mlir::Location loc,
               Fortran::lower::StatementContext &stmtCtx) {
   assert(numOperands >= 2 && !isPresentCheck(0) && !isPresentCheck(1) &&
          "min/max must have at least two non-optional args");
   assert(retTy && "MIN and MAX must have a return type");
   mlir::Type resultType = *retTy;
   llvm::SmallVector<fir::ExtendedValue> args;
   args.push_back(getOperand(0));
   args.push_back(getOperand(1));
-  mlir::Value extremum = fir::getBase(Fortran::lower::genIntrinsicCall(
-      builder, loc, name, resultType, args, stmtCtx));
+  mlir::Value extremum = fir::getBase(
+      genIntrinsicCall(builder, loc, name, resultType, args, stmtCtx));
 
   for (std::size_t opIndex = 2; opIndex < numOperands; ++opIndex) {
     if (std::optional<mlir::Value> isPresentRuntimeCheck =
             isPresentCheck(opIndex)) {
       // Argument is dynamically optional.
       extremum =
           builder
               .genIfOp(loc, {resultType}, *isPresentRuntimeCheck,
                        /*withElseRegion=*/true)
               .genThen([&]() {
                 llvm::SmallVector<fir::ExtendedValue> args;
                 args.emplace_back(extremum);
                 args.emplace_back(getOperand(opIndex));
-                fir::ExtendedValue newExtremum =
-                    Fortran::lower::genIntrinsicCall(builder, loc, name,
-                                                     resultType, args, stmtCtx);
+                fir::ExtendedValue newExtremum = genIntrinsicCall(
+                    builder, loc, name, resultType, args, stmtCtx);
                 builder.create<fir::ResultOp>(loc, fir::getBase(newExtremum));
               })
               .genElse([&]() { builder.create<fir::ResultOp>(loc, extremum); })
               .getResults()[0];
     } else {
       // Argument is know to be present at compile time.
       llvm::SmallVector<fir::ExtendedValue> args;
       args.emplace_back(extremum);
       args.emplace_back(getOperand(opIndex));
-      extremum = fir::getBase(Fortran::lower::genIntrinsicCall(
-          builder, loc, name, resultType, args, stmtCtx));
+      extremum = fir::getBase(
+          genIntrinsicCall(builder, loc, name, resultType, args, stmtCtx));
     }
   }
   return extremum;
 }
 
 static void prepareIshftcArguments(
     const Fortran::evaluate::ProcedureRef &procRef,
     const Fortran::evaluate::SpecificIntrinsic &intrinsic,
args.push_back(builder
                      })
                      .genElse([&]() {
                        mlir::Value bitSize = builder.createIntegerConstant(
                            loc, resultType,
                            resultType.cast<mlir::IntegerType>().getWidth());
                        builder.create<fir::ResultOp>(loc, bitSize);
                      })
                      .getResults()[0]);
-  return Fortran::lower::genIntrinsicCall(builder, loc, name, resultType, args,
-                                          stmtCtx);
+  return genIntrinsicCall(builder, loc, name, resultType, args, stmtCtx);
 }
 
 void Fortran::lower::prepareCustomIntrinsicArgument(
     const Fortran::evaluate::ProcedureRef &procRef,
     const Fortran::evaluate::SpecificIntrinsic &intrinsic,
     std::optional<mlir::Type> retTy,
     const OperandPrepare &prepareOptionalArgument,
     const OperandPrepare &prepareOtherArgument, AbstractConverter &converter) {

flang/lib/Lower/IntrinsicCall.cpp

 // module.
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/IntrinsicCall.h"
 #include "flang/Common/static-multimap-view.h"
 #include "flang/Lower/Mangler.h"
 #include "flang/Lower/Runtime.h"
-#include "flang/Lower/StatementContext.h"
 #include "flang/Lower/Support/Utils.h"
 #include "flang/Lower/SymbolMap.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/Character.h"
 #include "flang/Optimizer/Builder/Complex.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/MutableBox.h"
 #include "flang/Optimizer/Builder/Runtime/Allocatable.h"
Fortran::lower::ArgLoweringRule Fortran::lower::lowerIntrinsicArgumentAs(
   return {rules.args[position].lowerAs,
           rules.args[position].handleDynamicOptional};
 }
 
 //===----------------------------------------------------------------------===//
 // Public intrinsic call helpers
 //===----------------------------------------------------------------------===//
 
-fir::ExtendedValue
-Fortran::lower::genIntrinsicCall(fir::FirOpBuilder &builder, mlir::Location loc,
-                                 llvm::StringRef name,
-                                 std::optional<mlir::Type> resultType,
-                                 llvm::ArrayRef<fir::ExtendedValue> args,
-                                 Fortran::lower::StatementContext &stmtCtx) {
-  auto [result, mustBeFreed] =
-      IntrinsicLibrary{builder, loc}.genIntrinsicCall(name, resultType, args);
-  if (mustBeFreed) {
-    mlir::Value addr = fir::getBase(result);
-    if (auto *box = result.getBoxOf<fir::BoxValue>())
-      addr =
-          builder.create<fir::BoxAddrOp>(loc, box->getMemTy(), box->getAddr());
-    fir::FirOpBuilder *bldr = &builder;
-    stmtCtx.attachCleanup([=]() { bldr->create<fir::FreeMemOp>(loc, addr); });
-  }
-  return result;
-}
 std::pair<fir::ExtendedValue, bool>
 Fortran::lower::genIntrinsicCall(fir::FirOpBuilder &builder, mlir::Location loc,
                                  llvm::StringRef name,
                                  std::optional<mlir::Type> resultType,
                                  llvm::ArrayRef<fir::ExtendedValue> args) {
   return IntrinsicLibrary{builder, loc}.genIntrinsicCall(name, resultType,
                                                          args);
 }