[flang][NFC] Move runtime helpers used by intrinsics to lib/Optimizer 3/6

[tblah]

Summary

This will allow IntrinsicCall to be moved into lib/Optimizer later.

[jeanPerier]

Please move the header in Builer/Runtime so that that all the runtime call generation tools sit in the same folder. Look good otherwise, thanks!

flang/include/flang/Optimizer/Support/IntrinsicsRuntime.h

21

It would make more sense to me to move this in "include/flang/Optimizer/Builder/Runtime/Intrinsics.h" and to have the function defined by this header be in the fir::runtime namespace.

[tblah]

Changes:

• Move new header to flang/include/flang/Optimizer/Builder/Runtime/Intrinsics.h
• Move fucntions to fir::runtime namespace

[jeanPerier]

LGTM

flang/include/flang/Lower/Runtime.h

 void genSyncImagesStatement(AbstractConverter &,
                             const parser::SyncImagesStmt &);
 void genSyncMemoryStatement(AbstractConverter &,
                             const parser::SyncMemoryStmt &);
 void genSyncTeamStatement(AbstractConverter &, const parser::SyncTeamStmt &);
 void genUnlockStatement(AbstractConverter &, const parser::UnlockStmt &);
 void genPauseStatement(AbstractConverter &, const parser::PauseStmt &);
 
-mlir::Value genAssociated(fir::FirOpBuilder &, mlir::Location,
-                          mlir::Value pointer, mlir::Value target);
-
 void genPointerAssociate(fir::FirOpBuilder &, mlir::Location,
                          mlir::Value pointer, mlir::Value target);
 void genPointerAssociateRemapping(fir::FirOpBuilder &, mlir::Location,
                                   mlir::Value pointer, mlir::Value target,
                                   mlir::Value bounds);
-
-mlir::Value genCpuTime(fir::FirOpBuilder &, mlir::Location);
-void genDateAndTime(fir::FirOpBuilder &, mlir::Location,
-                    std::optional<fir::CharBoxValue> date,
-                    std::optional<fir::CharBoxValue> time,
-                    std::optional<fir::CharBoxValue> zone, mlir::Value values);
-
-void genRandomInit(fir::FirOpBuilder &, mlir::Location, mlir::Value repeatable,
-                   mlir::Value imageDistinct);
-void genRandomNumber(fir::FirOpBuilder &, mlir::Location, mlir::Value harvest);
-void genRandomSeed(fir::FirOpBuilder &, mlir::Location, mlir::Value size,
-                   mlir::Value put, mlir::Value get);
-
-/// generate runtime call to transfer intrinsic with no size argument
-void genTransfer(fir::FirOpBuilder &builder, mlir::Location loc,
-                 mlir::Value resultBox, mlir::Value sourceBox,
-                 mlir::Value moldBox);
-
-/// generate runtime call to transfer intrinsic with size argument
-void genTransferSize(fir::FirOpBuilder &builder, mlir::Location loc,
-                     mlir::Value resultBox, mlir::Value sourceBox,
-                     mlir::Value moldBox, mlir::Value size);
-
-/// generate system_clock runtime call/s
-/// all intrinsic arguments are optional and may appear here as mlir::Value{}
-void genSystemClock(fir::FirOpBuilder &, mlir::Location, mlir::Value count,
-                    mlir::Value rate, mlir::Value max);
-
 } // namespace lower
 } // namespace Fortran
 
 #endif // FORTRAN_LOWER_RUNTIME_H

flang/include/flang/Optimizer/Support/IntrinsicsRuntime.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_LOWER_RUNTIME_H
 #define FORTRAN_LOWER_RUNTIME_H
 
 #include <optional>
 
 namespace mlir {
 class Location;
 class Value;
 } // namespace mlir
 
 namespace fir {
 class CharBoxValue;
 class FirOpBuilder;
-} // namespace fir
-
-namespace Fortran {
-
-namespace parser {
-struct EventPostStmt;
-struct EventWaitStmt;
-struct LockStmt;
-struct PauseStmt;
-struct StopStmt;
-struct SyncAllStmt;
-struct SyncImagesStmt;
-struct SyncMemoryStmt;
-struct SyncTeamStmt;
-struct UnlockStmt;
-} // namespace parser
-
-namespace lower {
-
-class AbstractConverter;
-
-// Lowering of Fortran statement related runtime (other than IO and maths)
-
-void genEventPostStatement(AbstractConverter &, const parser::EventPostStmt &);
-void genEventWaitStatement(AbstractConverter &, const parser::EventWaitStmt &);
-void genLockStatement(AbstractConverter &, const parser::LockStmt &);
-void genFailImageStatement(AbstractConverter &);
-void genStopStatement(AbstractConverter &, const parser::StopStmt &);
-void genSyncAllStatement(AbstractConverter &, const parser::SyncAllStmt &);
-void genSyncImagesStatement(AbstractConverter &,
-                            const parser::SyncImagesStmt &);
-void genSyncMemoryStatement(AbstractConverter &,
-                            const parser::SyncMemoryStmt &);
-void genSyncTeamStatement(AbstractConverter &, const parser::SyncTeamStmt &);
-void genUnlockStatement(AbstractConverter &, const parser::UnlockStmt &);
-void genPauseStatement(AbstractConverter &, const parser::PauseStmt &);
 
 mlir::Value genAssociated(fir::FirOpBuilder &, mlir::Location,
                           mlir::Value pointer, mlir::Value target);
 
 void genPointerAssociate(fir::FirOpBuilder &, mlir::Location,
                          mlir::Value pointer, mlir::Value target);
 void genPointerAssociateRemapping(fir::FirOpBuilder &, mlir::Location,
                                   mlir::Value pointer, mlir::Value target,
void genTransferSize(fir::FirOpBuilder &builder, mlir::Location loc,
                      mlir::Value resultBox, mlir::Value sourceBox,
                      mlir::Value moldBox, mlir::Value size);
 
 /// generate system_clock runtime call/s
 /// all intrinsic arguments are optional and may appear here as mlir::Value{}
 void genSystemClock(fir::FirOpBuilder &, mlir::Location, mlir::Value count,
                     mlir::Value rate, mlir::Value max);
 
-} // namespace lower
-} // namespace Fortran
+} // namespace fir
 
 #endif // FORTRAN_LOWER_RUNTIME_H

flang/lib/Lower/IntrinsicCall.cpp

 // style (https://mlir.llvm.org/getting_started/DeveloperGuide/) is used in this
 // 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/Support/Utils.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"
 #include "flang/Optimizer/Builder/Runtime/Character.h"
 #include "flang/Optimizer/Builder/Runtime/Command.h"
 #include "flang/Optimizer/Builder/Runtime/Derived.h"
 #include "flang/Optimizer/Builder/Runtime/Inquiry.h"
 #include "flang/Optimizer/Builder/Runtime/Numeric.h"
 #include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
 #include "flang/Optimizer/Builder/Runtime/Reduction.h"
 #include "flang/Optimizer/Builder/Runtime/Stop.h"
 #include "flang/Optimizer/Builder/Runtime/Transformational.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Support/FatalError.h"
+#include "flang/Optimizer/Support/IntrinsicsRuntime.h"
 #include "flang/Runtime/entry-names.h"
 #include "mlir/Dialect/Complex/IR/Complex.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/Math/IR/Math.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include <optional>
 
targetBox = builder
                     })
                     .getResults()[0];
   } else {
     targetBox = builder.createBox(loc, target);
   }
   mlir::Value pointerBoxRef =
       fir::factory::getMutableIRBox(builder, loc, *pointer);
   auto pointerBox = builder.create<fir::LoadOp>(loc, pointerBoxRef);
-  return Fortran::lower::genAssociated(builder, loc, pointerBox, targetBox);
+  return fir::genAssociated(builder, loc, pointerBox, targetBox);
 }
 
 // BESSEL_JN
 fir::ExtendedValue
 IntrinsicLibrary::genBesselJn(mlir::Type resultType,
                               llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 2 || args.size() == 3);
 
IntrinsicLibrary::genCount(mlir::Type resultType,
   return readAndAddCleanUp(resultMutableBox, resultType, "COUNT");
 }
 
 // CPU_TIME
 void IntrinsicLibrary::genCpuTime(llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 1);
   const mlir::Value *arg = args[0].getUnboxed();
   assert(arg && "nonscalar cpu_time argument");
-  mlir::Value res1 = Fortran::lower::genCpuTime(builder, loc);
+  mlir::Value res1 = fir::genCpuTime(builder, loc);
   mlir::Value res2 =
       builder.createConvert(loc, fir::dyn_cast_ptrEleTy(arg->getType()), res1);
   builder.create<fir::StoreOp>(loc, res2, *arg);
 }
 
 // CSHIFT
 fir::ExtendedValue
 IntrinsicLibrary::genCshift(mlir::Type resultType,
for (unsigned i = 0; i < 3; ++i)
     if (const fir::CharBoxValue *charBox = args[i].getCharBox())
       charArgs[i] = *charBox;
 
   mlir::Value values = fir::getBase(args[3]);
   if (!values)
     values = builder.create<fir::AbsentOp>(
         loc, fir::BoxType::get(builder.getNoneType()));
 
-  Fortran::lower::genDateAndTime(builder, loc, charArgs[0], charArgs[1],
-                                 charArgs[2], values);
+  fir::genDateAndTime(builder, loc, charArgs[0], charArgs[1], charArgs[2],
+                      values);
 }
 
 // DIM
 mlir::Value IntrinsicLibrary::genDim(mlir::Type resultType,
                                      llvm::ArrayRef<mlir::Value> args) {
   assert(args.size() == 2);
   if (resultType.isa<mlir::IntegerType>()) {
     mlir::Value zero = builder.createIntegerConstant(loc, resultType, 0);
IntrinsicLibrary::genProduct(mlir::Type resultType,
                              llvm::ArrayRef<fir::ExtendedValue> args) {
   return genReduction(fir::runtime::genProduct, fir::runtime::genProductDim,
                       "PRODUCT", resultType, args);
 }
 
 // RANDOM_INIT
 void IntrinsicLibrary::genRandomInit(llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 2);
-  Fortran::lower::genRandomInit(builder, loc, fir::getBase(args[0]),
-                                fir::getBase(args[1]));
+  fir::genRandomInit(builder, loc, fir::getBase(args[0]),
 }
 
 // RANDOM_NUMBER
 void IntrinsicLibrary::genRandomNumber(
     llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 1);
-  Fortran::lower::genRandomNumber(builder, loc, fir::getBase(args[0]));
+  fir::genRandomNumber(builder, loc, fir::getBase(args[0]));
 }
 
 // RANDOM_SEED
 void IntrinsicLibrary::genRandomSeed(llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 3);
   mlir::Type boxNoneTy = fir::BoxType::get(builder.getNoneType());
   auto getDesc = [&](int i) {
     return isStaticallyPresent(args[i])
                ? fir::getBase(args[i])
                : builder.create<fir::AbsentOp>(loc, boxNoneTy).getResult();
   };
   mlir::Value size = getDesc(0);
   mlir::Value put = getDesc(1);
   mlir::Value get = getDesc(2);
-  Fortran::lower::genRandomSeed(builder, loc, size, put, get);
+  fir::genRandomSeed(builder, loc, size, put, get);
 }
 
 // REDUCE
 fir::ExtendedValue
 IntrinsicLibrary::genReduce(mlir::Type resultType,
                             llvm::ArrayRef<fir::ExtendedValue> args) {
   TODO(loc, "intrinsic: reduce");
 }
IntrinsicLibrary::genSum(mlir::Type resultType,
                          llvm::ArrayRef<fir::ExtendedValue> args) {
   return genReduction(fir::runtime::genSum, fir::runtime::genSumDim, "SUM",
                       resultType, args);
 }
 
 // SYSTEM_CLOCK
 void IntrinsicLibrary::genSystemClock(llvm::ArrayRef<fir::ExtendedValue> args) {
   assert(args.size() == 3);
-  Fortran::lower::genSystemClock(builder, loc, fir::getBase(args[0]),
-                                 fir::getBase(args[1]), fir::getBase(args[2]));
+  fir::genSystemClock(builder, loc, fir::getBase(args[0]),
 }
 
 // TRANSFER
 fir::ExtendedValue
 IntrinsicLibrary::genTransfer(mlir::Type resultType,
                               llvm::ArrayRef<fir::ExtendedValue> args) {
 
   assert(args.size() >= 2); // args.size() == 2 when size argument is omitted.
IntrinsicLibrary::genTransfer(mlir::Type resultType,
   fir::MutableBoxValue resultMutableBox =
       fir::factory::createTempMutableBox(builder, loc, type);
 
   if (moldRank == 0 && absentSize) {
     // This result is a scalar in this case.
     mlir::Value resultIrBox =
         fir::factory::getMutableIRBox(builder, loc, resultMutableBox);
 
-    Fortran::lower::genTransfer(builder, loc, resultIrBox, source, mold);
+    fir::genTransfer(builder, loc, resultIrBox, source, mold);
   } else {
     // The result is a rank one array in this case.
     mlir::Value resultIrBox =
         fir::factory::getMutableIRBox(builder, loc, resultMutableBox);
 
     if (absentSize) {
-      Fortran::lower::genTransfer(builder, loc, resultIrBox, source, mold);
+      fir::genTransfer(builder, loc, resultIrBox, source, mold);
     } else {
       mlir::Value sizeArg = fir::getBase(args[2]);
-      Fortran::lower::genTransferSize(builder, loc, resultIrBox, source, mold,
-                                      sizeArg);
+      fir::genTransferSize(builder, loc, resultIrBox, source, mold, sizeArg);
     }
   }
   return readAndAddCleanUp(resultMutableBox, resultType, "TRANSFER");
 }
 
 // TRANSPOSE
 fir::ExtendedValue
 IntrinsicLibrary::genTranspose(mlir::Type resultType,

flang/lib/Lower/Runtime.cpp

void Fortran::lower::genPauseStatement(
     const Fortran::parser::PauseStmt &) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   mlir::Location loc = converter.getCurrentLocation();
   mlir::func::FuncOp callee =
       fir::runtime::getRuntimeFunc<mkRTKey(PauseStatement)>(loc, builder);
   builder.create<fir::CallOp>(loc, callee, std::nullopt);
 }
 
-mlir::Value Fortran::lower::genAssociated(fir::FirOpBuilder &builder,
-                                          mlir::Location loc,
-                                          mlir::Value pointer,
-                                          mlir::Value target) {
-  mlir::func::FuncOp func =
-      fir::runtime::getRuntimeFunc<mkRTKey(PointerIsAssociatedWith)>(loc,
-                                                                     builder);
-  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
-      builder, loc, func.getFunctionType(), pointer, target);
-  return builder.create<fir::CallOp>(loc, func, args).getResult(0);
-}
-
 void Fortran::lower::genPointerAssociate(fir::FirOpBuilder &builder,
                                          mlir::Location loc,
                                          mlir::Value pointer,
                                          mlir::Value target) {
   mlir::func::FuncOp func =
       fir::runtime::getRuntimeFunc<mkRTKey(PointerAssociate)>(loc, builder);
   llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
       builder, loc, func.getFunctionType(), pointer, target);
void Fortran::lower::genPointerAssociateRemapping(fir::FirOpBuilder &builder,
   auto sourceFile = fir::factory::locationToFilename(builder, loc);
   auto sourceLine =
       fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
   llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
       builder, loc, func.getFunctionType(), pointer, target, bounds, sourceFile,
       sourceLine);
   builder.create<fir::CallOp>(loc, func, args).getResult(0);
 }
-
-mlir::Value Fortran::lower::genCpuTime(fir::FirOpBuilder &builder,
-                                       mlir::Location loc) {
-  mlir::func::FuncOp func =
-      fir::runtime::getRuntimeFunc<mkRTKey(CpuTime)>(loc, builder);
-  return builder.create<fir::CallOp>(loc, func, std::nullopt).getResult(0);
-}
-
-void Fortran::lower::genDateAndTime(fir::FirOpBuilder &builder,
-                                    mlir::Location loc,
-                                    std::optional<fir::CharBoxValue> date,
-                                    std::optional<fir::CharBoxValue> time,
-                                    std::optional<fir::CharBoxValue> zone,
-                                    mlir::Value values) {
-  mlir::func::FuncOp callee =
-      fir::runtime::getRuntimeFunc<mkRTKey(DateAndTime)>(loc, builder);
-  mlir::FunctionType funcTy = callee.getFunctionType();
-  mlir::Type idxTy = builder.getIndexType();
-  mlir::Value zero;
-  auto splitArg = [&](std::optional<fir::CharBoxValue> arg, mlir::Value &buffer,
-                      mlir::Value &len) {
-    if (arg) {
-      buffer = arg->getBuffer();
-      len = arg->getLen();
-    } else {
-      if (!zero)
-        zero = builder.createIntegerConstant(loc, idxTy, 0);
-      buffer = zero;
-      len = zero;
-    }
-  };
-  mlir::Value dateBuffer;
-  mlir::Value dateLen;
-  splitArg(date, dateBuffer, dateLen);
-  mlir::Value timeBuffer;
-  mlir::Value timeLen;
-  splitArg(time, timeBuffer, timeLen);
-  mlir::Value zoneBuffer;
-  mlir::Value zoneLen;
-  splitArg(zone, zoneBuffer, zoneLen);
-
-  mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
-  mlir::Value sourceLine =
-      fir::factory::locationToLineNo(builder, loc, funcTy.getInput(7));
-
-  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
-      builder, loc, funcTy, dateBuffer, dateLen, timeBuffer, timeLen,
-      zoneBuffer, zoneLen, sourceFile, sourceLine, values);
-  builder.create<fir::CallOp>(loc, callee, args);
-}
-
-void Fortran::lower::genRandomInit(fir::FirOpBuilder &builder,
-                                   mlir::Location loc, mlir::Value repeatable,
-                                   mlir::Value imageDistinct) {
-  mlir::func::FuncOp func =
-      fir::runtime::getRuntimeFunc<mkRTKey(RandomInit)>(loc, builder);
-  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
-      builder, loc, func.getFunctionType(), repeatable, imageDistinct);
-  builder.create<fir::CallOp>(loc, func, args);
-}
-
-void Fortran::lower::genRandomNumber(fir::FirOpBuilder &builder,
-                                     mlir::Location loc, mlir::Value harvest) {
-  mlir::func::FuncOp func =
-      fir::runtime::getRuntimeFunc<mkRTKey(RandomNumber)>(loc, builder);
-  mlir::FunctionType funcTy = func.getFunctionType();
-  mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
-  mlir::Value sourceLine =
-      fir::factory::locationToLineNo(builder, loc, funcTy.getInput(2));
-  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
-      builder, loc, funcTy, harvest, sourceFile, sourceLine);
-  builder.create<fir::CallOp>(loc, func, args);
-}
-
-void Fortran::lower::genRandomSeed(fir::FirOpBuilder &builder,
-                                   mlir::Location loc, mlir::Value size,
-                                   mlir::Value put, mlir::Value get) {
-  bool sizeIsPresent =
-      !mlir::isa_and_nonnull<fir::AbsentOp>(size.getDefiningOp());
-  bool putIsPresent =
-      !mlir::isa_and_nonnull<fir::AbsentOp>(put.getDefiningOp());
-  bool getIsPresent =
-      !mlir::isa_and_nonnull<fir::AbsentOp>(get.getDefiningOp());
-  mlir::func::FuncOp func;
-  int staticArgCount = sizeIsPresent + putIsPresent + getIsPresent;
-  if (staticArgCount == 0) {
-    func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedDefaultPut)>(loc,
-                                                                       builder);
-    builder.create<fir::CallOp>(loc, func);
-    return;
-  }
-  mlir::FunctionType funcTy;
-  mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
-  mlir::Value sourceLine;
-  mlir::Value argBox;
-  llvm::SmallVector<mlir::Value> args;
-  if (staticArgCount > 1) {
-    func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeed)>(loc, builder);
-    funcTy = func.getFunctionType();
-    sourceLine =
-        fir::factory::locationToLineNo(builder, loc, funcTy.getInput(4));
-    args = fir::runtime::createArguments(builder, loc, funcTy, size, put, get,
-                                         sourceFile, sourceLine);
-    builder.create<fir::CallOp>(loc, func, args);
-    return;
-  }
-  if (sizeIsPresent) {
-    func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedSize)>(loc, builder);
-    argBox = size;
-  } else if (putIsPresent) {
-    func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedPut)>(loc, builder);
-    argBox = put;
-  } else {
-    func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedGet)>(loc, builder);
-    argBox = get;
-  }
-  funcTy = func.getFunctionType();
-  sourceLine = fir::factory::locationToLineNo(builder, loc, funcTy.getInput(2));
-  args = fir::runtime::createArguments(builder, loc, funcTy, argBox, sourceFile,
-                                       sourceLine);
-  builder.create<fir::CallOp>(loc, func, args);
-}
-
-/// generate runtime call to transfer intrinsic with no size argument
-void Fortran::lower::genTransfer(fir::FirOpBuilder &builder, mlir::Location loc,
-                                 mlir::Value resultBox, mlir::Value sourceBox,
-                                 mlir::Value moldBox) {
-
-  mlir::func::FuncOp func =
-      fir::runtime::getRuntimeFunc<mkRTKey(Transfer)>(loc, builder);
-  mlir::FunctionType fTy = func.getFunctionType();
-  mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
-  mlir::Value sourceLine =
-      fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
-  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
-      builder, loc, fTy, resultBox, sourceBox, moldBox, sourceFile, sourceLine);
-  builder.create<fir::CallOp>(loc, func, args);
-}
-
-/// generate runtime call to transfer intrinsic with size argument
-void Fortran::lower::genTransferSize(fir::FirOpBuilder &builder,
-                                     mlir::Location loc, mlir::Value resultBox,
-                                     mlir::Value sourceBox, mlir::Value moldBox,
-                                     mlir::Value size) {
-  mlir::func::FuncOp func =
-      fir::runtime::getRuntimeFunc<mkRTKey(TransferSize)>(loc, builder);
-  mlir::FunctionType fTy = func.getFunctionType();
-  mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
-  mlir::Value sourceLine =
-      fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
-  llvm::SmallVector<mlir::Value> args =
-      fir::runtime::createArguments(builder, loc, fTy, resultBox, sourceBox,
-                                    moldBox, sourceFile, sourceLine, size);
-  builder.create<fir::CallOp>(loc, func, args);
-}
-
-/// generate system_clock runtime call/s
-/// all intrinsic arguments are optional and may appear here as mlir::Value{}
-void Fortran::lower::genSystemClock(fir::FirOpBuilder &builder,
-                                    mlir::Location loc, mlir::Value count,
-                                    mlir::Value rate, mlir::Value max) {
-  auto makeCall = [&](mlir::func::FuncOp func, mlir::Value arg) {
-    mlir::Type type = arg.getType();
-    fir::IfOp ifOp{};
-    const bool isOptionalArg =
-        fir::valueHasFirAttribute(arg, fir::getOptionalAttrName());
-    if (type.dyn_cast<fir::PointerType>() || type.dyn_cast<fir::HeapType>()) {
-      // Check for a disassociated pointer or an unallocated allocatable.
-      assert(!isOptionalArg && "invalid optional argument");
-      ifOp = builder.create<fir::IfOp>(loc, builder.genIsNotNullAddr(loc, arg),
-                                       /*withElseRegion=*/false);
-    } else if (isOptionalArg) {
-      ifOp = builder.create<fir::IfOp>(
-          loc, builder.create<fir::IsPresentOp>(loc, builder.getI1Type(), arg),
-          /*withElseRegion=*/false);
-    }
-    if (ifOp)
-      builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
-    mlir::Type kindTy = func.getFunctionType().getInput(0);
-    int integerKind = 8;
-    if (auto intType = fir::unwrapRefType(type).dyn_cast<mlir::IntegerType>())
-      integerKind = intType.getWidth() / 8;
-    mlir::Value kind = builder.createIntegerConstant(loc, kindTy, integerKind);
-    mlir::Value res =
-        builder.create<fir::CallOp>(loc, func, mlir::ValueRange{kind})
-            .getResult(0);
-    mlir::Value castRes =
-        builder.createConvert(loc, fir::dyn_cast_ptrEleTy(type), res);
-    builder.create<fir::StoreOp>(loc, castRes, arg);
-    if (ifOp)
-      builder.setInsertionPointAfter(ifOp);
-  };
-  using fir::runtime::getRuntimeFunc;
-  if (count)
-    makeCall(getRuntimeFunc<mkRTKey(SystemClockCount)>(loc, builder), count);
-  if (rate)
-    makeCall(getRuntimeFunc<mkRTKey(SystemClockCountRate)>(loc, builder), rate);
-  if (max)
-    makeCall(getRuntimeFunc<mkRTKey(SystemClockCountMax)>(loc, builder), max);
-}

flang/lib/Optimizer/Support/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FIRSupport
   FIRContext.cpp
   InitFIR.cpp
   InternalNames.cpp
+  IntrinsicsRuntime.cpp
   KindMapping.cpp
 
   DEPENDS
   FIROpsIncGen
   HLFIROpsIncGen
   MLIRIR
   ${dialect_libs}
 

flang/lib/Optimizer/Support/IntrinsicsRuntime.cpp

+//===-- IntrinsicsRuntime.cpp ---------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Support/IntrinsicsRuntime.h"
+#include "flang/Optimizer/Builder/BoxValue.h"
+#include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
+#include "flang/Optimizer/Builder/Todo.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Runtime/misc-intrinsic.h"
+#include "flang/Runtime/pointer.h"
+#include "flang/Runtime/random.h"
+#include "flang/Runtime/stop.h"
+#include "flang/Runtime/time-intrinsic.h"
+#include "flang/Semantics/tools.h"
+#include "llvm/Support/Debug.h"
+#include <optional>
+
+#define DEBUG_TYPE "flang-lower-runtime"
+
+using namespace Fortran::runtime;
+
+mlir::Value fir::genAssociated(fir::FirOpBuilder &builder, mlir::Location loc,
+                               mlir::Value pointer, mlir::Value target) {
+  mlir::func::FuncOp func =
+      fir::runtime::getRuntimeFunc<mkRTKey(PointerIsAssociatedWith)>(loc,
+                                                                     builder);
+  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
+      builder, loc, func.getFunctionType(), pointer, target);
+  return builder.create<fir::CallOp>(loc, func, args).getResult(0);
+}
+
+mlir::Value fir::genCpuTime(fir::FirOpBuilder &builder, mlir::Location loc) {
+  mlir::func::FuncOp func =
+      fir::runtime::getRuntimeFunc<mkRTKey(CpuTime)>(loc, builder);
+  return builder.create<fir::CallOp>(loc, func, std::nullopt).getResult(0);
+}
+
+void fir::genDateAndTime(fir::FirOpBuilder &builder, mlir::Location loc,
+                         std::optional<fir::CharBoxValue> date,
+                         std::optional<fir::CharBoxValue> time,
+                         std::optional<fir::CharBoxValue> zone,
+                         mlir::Value values) {
+  mlir::func::FuncOp callee =
+      fir::runtime::getRuntimeFunc<mkRTKey(DateAndTime)>(loc, builder);
+  mlir::FunctionType funcTy = callee.getFunctionType();
+  mlir::Type idxTy = builder.getIndexType();
+  mlir::Value zero;
+  auto splitArg = [&](std::optional<fir::CharBoxValue> arg, mlir::Value &buffer,
+                      mlir::Value &len) {
+    if (arg) {
+      buffer = arg->getBuffer();
+      len = arg->getLen();
+    } else {
+      if (!zero)
+        zero = builder.createIntegerConstant(loc, idxTy, 0);
+      buffer = zero;
+      len = zero;
+    }
+  };
+  mlir::Value dateBuffer;
+  mlir::Value dateLen;
+  splitArg(date, dateBuffer, dateLen);
+  mlir::Value timeBuffer;
+  mlir::Value timeLen;
+  splitArg(time, timeBuffer, timeLen);
+  mlir::Value zoneBuffer;
+  mlir::Value zoneLen;
+  splitArg(zone, zoneBuffer, zoneLen);
+
+  mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
+  mlir::Value sourceLine =
+      fir::factory::locationToLineNo(builder, loc, funcTy.getInput(7));
+
+  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
+      builder, loc, funcTy, dateBuffer, dateLen, timeBuffer, timeLen,
+      zoneBuffer, zoneLen, sourceFile, sourceLine, values);
+  builder.create<fir::CallOp>(loc, callee, args);
+}
+
+void fir::genRandomInit(fir::FirOpBuilder &builder, mlir::Location loc,
+                        mlir::Value repeatable, mlir::Value imageDistinct) {
+  mlir::func::FuncOp func =
+      fir::runtime::getRuntimeFunc<mkRTKey(RandomInit)>(loc, builder);
+  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
+      builder, loc, func.getFunctionType(), repeatable, imageDistinct);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+void fir::genRandomNumber(fir::FirOpBuilder &builder, mlir::Location loc,
+                          mlir::Value harvest) {
+  mlir::func::FuncOp func =
+      fir::runtime::getRuntimeFunc<mkRTKey(RandomNumber)>(loc, builder);
+  mlir::FunctionType funcTy = func.getFunctionType();
+  mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
+  mlir::Value sourceLine =
+      fir::factory::locationToLineNo(builder, loc, funcTy.getInput(2));
+  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
+      builder, loc, funcTy, harvest, sourceFile, sourceLine);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+void fir::genRandomSeed(fir::FirOpBuilder &builder, mlir::Location loc,
+                        mlir::Value size, mlir::Value put, mlir::Value get) {
+  bool sizeIsPresent =
+      !mlir::isa_and_nonnull<fir::AbsentOp>(size.getDefiningOp());
+  bool putIsPresent =
+      !mlir::isa_and_nonnull<fir::AbsentOp>(put.getDefiningOp());
+  bool getIsPresent =
+      !mlir::isa_and_nonnull<fir::AbsentOp>(get.getDefiningOp());
+  mlir::func::FuncOp func;
+  int staticArgCount = sizeIsPresent + putIsPresent + getIsPresent;
+  if (staticArgCount == 0) {
+    func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedDefaultPut)>(loc,
+                                                                       builder);
+    builder.create<fir::CallOp>(loc, func);
+    return;
+  }
+  mlir::FunctionType funcTy;
+  mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
+  mlir::Value sourceLine;
+  mlir::Value argBox;
+  llvm::SmallVector<mlir::Value> args;
+  if (staticArgCount > 1) {
+    func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeed)>(loc, builder);
+    funcTy = func.getFunctionType();
+    sourceLine =
+        fir::factory::locationToLineNo(builder, loc, funcTy.getInput(4));
+    args = fir::runtime::createArguments(builder, loc, funcTy, size, put, get,
+                                         sourceFile, sourceLine);
+    builder.create<fir::CallOp>(loc, func, args);
+    return;
+  }
+  if (sizeIsPresent) {
+    func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedSize)>(loc, builder);
+    argBox = size;
+  } else if (putIsPresent) {
+    func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedPut)>(loc, builder);
+    argBox = put;
+  } else {
+    func = fir::runtime::getRuntimeFunc<mkRTKey(RandomSeedGet)>(loc, builder);
+    argBox = get;
+  }
+  funcTy = func.getFunctionType();
+  sourceLine = fir::factory::locationToLineNo(builder, loc, funcTy.getInput(2));
+  args = fir::runtime::createArguments(builder, loc, funcTy, argBox, sourceFile,
+                                       sourceLine);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+/// generate runtime call to transfer intrinsic with no size argument
+void fir::genTransfer(fir::FirOpBuilder &builder, mlir::Location loc,
+                      mlir::Value resultBox, mlir::Value sourceBox,
+                      mlir::Value moldBox) {
+
+  mlir::func::FuncOp func =
+      fir::runtime::getRuntimeFunc<mkRTKey(Transfer)>(loc, builder);
+  mlir::FunctionType fTy = func.getFunctionType();
+  mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
+  mlir::Value sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
+  llvm::SmallVector<mlir::Value> args = fir::runtime::createArguments(
+      builder, loc, fTy, resultBox, sourceBox, moldBox, sourceFile, sourceLine);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+/// generate runtime call to transfer intrinsic with size argument
+void fir::genTransferSize(fir::FirOpBuilder &builder, mlir::Location loc,
+                          mlir::Value resultBox, mlir::Value sourceBox,
+                          mlir::Value moldBox, mlir::Value size) {
+  mlir::func::FuncOp func =
+      fir::runtime::getRuntimeFunc<mkRTKey(TransferSize)>(loc, builder);
+  mlir::FunctionType fTy = func.getFunctionType();
+  mlir::Value sourceFile = fir::factory::locationToFilename(builder, loc);
+  mlir::Value sourceLine =
+      fir::factory::locationToLineNo(builder, loc, fTy.getInput(4));
+  llvm::SmallVector<mlir::Value> args =
+      fir::runtime::createArguments(builder, loc, fTy, resultBox, sourceBox,
+                                    moldBox, sourceFile, sourceLine, size);
+  builder.create<fir::CallOp>(loc, func, args);
+}
+
+/// generate system_clock runtime call/s
+/// all intrinsic arguments are optional and may appear here as mlir::Value{}
+void fir::genSystemClock(fir::FirOpBuilder &builder, mlir::Location loc,
+                         mlir::Value count, mlir::Value rate, mlir::Value max) {
+  auto makeCall = [&](mlir::func::FuncOp func, mlir::Value arg) {
+    mlir::Type type = arg.getType();
+    fir::IfOp ifOp{};
+    const bool isOptionalArg =
+        fir::valueHasFirAttribute(arg, fir::getOptionalAttrName());
+    if (type.dyn_cast<fir::PointerType>() || type.dyn_cast<fir::HeapType>()) {
+      // Check for a disassociated pointer or an unallocated allocatable.
+      assert(!isOptionalArg && "invalid optional argument");
+      ifOp = builder.create<fir::IfOp>(loc, builder.genIsNotNullAddr(loc, arg),
+                                       /*withElseRegion=*/false);
+    } else if (isOptionalArg) {
+      ifOp = builder.create<fir::IfOp>(
+          loc, builder.create<fir::IsPresentOp>(loc, builder.getI1Type(), arg),
+          /*withElseRegion=*/false);
+    }
+    if (ifOp)
+      builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
+    mlir::Type kindTy = func.getFunctionType().getInput(0);
+    int integerKind = 8;
+    if (auto intType = fir::unwrapRefType(type).dyn_cast<mlir::IntegerType>())
+      integerKind = intType.getWidth() / 8;
+    mlir::Value kind = builder.createIntegerConstant(loc, kindTy, integerKind);
+    mlir::Value res =
+        builder.create<fir::CallOp>(loc, func, mlir::ValueRange{kind})
+            .getResult(0);
+    mlir::Value castRes =
+        builder.createConvert(loc, fir::dyn_cast_ptrEleTy(type), res);
+    builder.create<fir::StoreOp>(loc, castRes, arg);
+    if (ifOp)
+      builder.setInsertionPointAfter(ifOp);
+  };
+  using fir::runtime::getRuntimeFunc;
+  if (count)
+    makeCall(getRuntimeFunc<mkRTKey(SystemClockCount)>(loc, builder), count);
+  if (rate)
+    makeCall(getRuntimeFunc<mkRTKey(SystemClockCountRate)>(loc, builder), rate);
+  if (max)
+    makeCall(getRuntimeFunc<mkRTKey(SystemClockCountMax)>(loc, builder), max);
+}