[flang] Lower elemental intrinsics to hlfir.elemental

[jeanPerier]

Summary

• Move the core code generating hlfir.elemental for user calls from genUserElementalCall into a new ElementalCallBuilder class and use C++ CRTP (curiously recursive template pattern) to implement the parts specific to user and intrinsic call into ElementalUserCallBuilder and ElementalIntrinsicCallBuilder. This allows sharing the core logic to lower elemental procedures for both user defined and intrinsics procedures.

• To allow using ElementalCallBuilder, split the intrinsic lowering code into two parts: first lower the arguments to hlfir::Entity regardless of the interface of the intrinsics, and then, in a different function (genIntrinsicProcRefCore), prepare the hlfir::Entity according to the interface. This allows using the same core logic to prepare "normal" arguments for non-elemental intrinsics, and to prepare the elements of array arguments inside elemental call (ElementalIntrinsicCallBuilder calls genIntrinsicProcRefCore once it has computed the scalar actual arguments). To allow this split, genExprBox/genExprAddr/genExprValue logic had to be split in ConvertExprToHlfir.[cpp/h].

• Add missing statement context pushScope/finalizeAndPop around the code generation inside the hlfir.elemental so that any temps created while lowering the call at the element level is correctly cleaned-up.

• One piece of code in hlfir::Entity::hasNonDefaultLowerBounds() was wrong for assumed shape arrays (returned true when an assumed shaped array had no explicit lower bounds). This caused the added test to hit a bogus TODO, so fix it.

Elemental intrinsics returning are still TODO (e.g., adjustl). I will implement this in a next patch, this one is big enough.

[PeteSteinfeld]

Other than the nits in comments, all builds and tests correctly. I don't understand this code very well, though, so @clementval should take a look and approve.

flang/lib/Lower/ConvertCall.cpp

765

Should read "are cleaned up".

832

Should read "will be passed"

865

Should read "never need the actual addresses"

flang/lib/Lower/ConvertExprToHLFIR.cpp

1258

Should read "not needed"

[jeanPerier]

Fix comment typos caught by Pete, thanks!

[clementval]

LGTM. The pre-commit failure seems related to a patch that has been reverted now.

[jeanPerier]

Rebase to incorporate build fix 81f57b6b994907267e981e09c1789529ec0a91c9

flang/include/flang/Lower/ConvertExprToHLFIR.h

 
 hlfir::EntityWithAttributes
 convertExprToHLFIR(mlir::Location loc, Fortran::lower::AbstractConverter &,
                    const Fortran::lower::SomeExpr &, Fortran::lower::SymMap &,
                    Fortran::lower::StatementContext &);
 
 inline fir::ExtendedValue
 translateToExtendedValue(mlir::Location loc, fir::FirOpBuilder &builder,
-                         hlfir::EntityWithAttributes entity,
+                         hlfir::Entity entity,
                          Fortran::lower::StatementContext &context) {
   auto [exv, exvCleanup] =
       hlfir::translateToExtendedValue(loc, builder, entity);
   if (exvCleanup)
     context.attachCleanup(*exvCleanup);
   return exv;
 }
 
+/// Lower an evaluate::Expr to a fir::Box.
 fir::BoxValue convertExprToBox(mlir::Location loc,
                                Fortran::lower::AbstractConverter &,
                                const Fortran::lower::SomeExpr &,
                                Fortran::lower::SymMap &,
                                Fortran::lower::StatementContext &);
+fir::BoxValue convertToBox(mlir::Location loc,
+                           Fortran::lower::AbstractConverter &,
+                           hlfir::Entity entity,
+                           Fortran::lower::StatementContext &);
 
-// Probably not what you think.
+/// Lower an evaluate::Expr to fir::ExtendedValue raw address.
+/// Beware that this will create a temporary for non simply contiguous
+/// designator expressions.
 fir::ExtendedValue convertExprToAddress(mlir::Location loc,
                                         Fortran::lower::AbstractConverter &,
                                         const Fortran::lower::SomeExpr &,
                                         Fortran::lower::SymMap &,
                                         Fortran::lower::StatementContext &);
+fir::ExtendedValue convertToAddress(mlir::Location loc,
+                                    Fortran::lower::AbstractConverter &,
+                                    hlfir::Entity entity,
+                                    bool isSimplyContiguous,
+                                    Fortran::lower::StatementContext &);
+
+/// Lower an evaluate::Expr to a fir::ExtendedValue value.
+fir::ExtendedValue convertExprToValue(mlir::Location loc,
+                                      Fortran::lower::AbstractConverter &,
+                                      const Fortran::lower::SomeExpr &,
+                                      Fortran::lower::SymMap &,
+                                      Fortran::lower::StatementContext &);
+fir::ExtendedValue convertToValue(mlir::Location loc,
+                                  Fortran::lower::AbstractConverter &,
+                                  hlfir::Entity entity,
+                                  Fortran::lower::StatementContext &);
 } // namespace Fortran::lower
 
 #endif // FORTRAN_LOWER_CONVERTEXPRTOHLFIR_H

flang/include/flang/Optimizer/Builder/HLFIRTools.h

bool isCharacter() const {
     return getFortranElementType().isa<fir::CharacterType>();
   }
 
   bool hasNonDefaultLowerBounds() const {
     if (!isBoxAddressOrValue() || isScalar())
       return false;
     if (isMutableBox())
       return true;
-    if (auto varIface = getIfVariableInterface())
+    if (auto varIface = getIfVariableInterface()) {
       if (auto shape = varIface.getShape()) {
         auto shapeTy = shape.getType();
         return shapeTy.isa<fir::ShiftType>() ||
                shapeTy.isa<fir::ShapeShiftType>();
       }
+      return false;
+    }
     return true;
   }
 
   fir::FortranVariableOpInterface getIfVariableInterface() const {
     return this->getDefiningOp<fir::FortranVariableOpInterface>();
   }
 
   // Get the entity as an mlir SSA value containing all the shape, type

flang/lib/Lower/Bridge.cpp

return Fortran::lower::createSomeExtendedAddress(loc, *this, expr,
                                                      localSymbols, context);
   }
 
   fir::ExtendedValue
   genExprValue(const Fortran::lower::SomeExpr &expr,
                Fortran::lower::StatementContext &context,
                mlir::Location *locPtr = nullptr) override final {
     mlir::Location loc = locPtr ? *locPtr : toLocation();
-    if (bridge.getLoweringOptions().getLowerToHighLevelFIR()) {
-      hlfir::EntityWithAttributes loweredExpr =
-          Fortran::lower::convertExprToHLFIR(loc, *this, expr, localSymbols,
+    if (bridge.getLoweringOptions().getLowerToHighLevelFIR())
+      return Fortran::lower::convertExprToValue(loc, *this, expr, localSymbols,
                                                 context);
-      fir::ExtendedValue exv = Fortran::lower::translateToExtendedValue(
-          loc, getFirOpBuilder(), loweredExpr, context);
-      // Load scalar references to integer, logical, real, or complex value
-      // to an mlir value, dereference allocatable and pointers, and get rid
-      // of fir.box that are no needed or create a copy into contiguous memory.
-      return exv.match(
-          [&](const fir::UnboxedValue &box) -> fir::ExtendedValue {
-            if (mlir::Type elementType = fir::dyn_cast_ptrEleTy(box.getType()))
-              if (fir::isa_trivial(elementType))
-                return getFirOpBuilder().create<fir::LoadOp>(loc, box);
-            return box;
-          },
-          [&](const fir::CharBoxValue &box) -> fir::ExtendedValue {
-            return box;
-          },
-          [&](const fir::ArrayBoxValue &box) -> fir::ExtendedValue {
-            return box;
-          },
-          [&](const fir::CharArrayBoxValue &box) -> fir::ExtendedValue {
-            return box;
-          },
-          [&](const auto &) -> fir::ExtendedValue {
-            TODO(loc, "lower descriptor designator to HLFIR value");
-          });
-    }
     return Fortran::lower::createSomeExtendedExpression(loc, *this, expr,
                                                         localSymbols, context);
   }
 
   fir::ExtendedValue
   genExprBox(mlir::Location loc, const Fortran::lower::SomeExpr &expr,
              Fortran::lower::StatementContext &stmtCtx) override final {
     if (bridge.getLoweringOptions().getLowerToHighLevelFIR())

flang/lib/Lower/ConvertCall.cpp

genUserCall(PreparedActualArguments &loweredActuals,
   for (auto associate : exprAssociations)
     builder.create<hlfir::EndAssociateOp>(loc, associate);
   if (!fir::getBase(result))
     return std::nullopt; // subroutine call.
   // TODO: "move" non pointer results into hlfir.expr.
   return extendedValueToHlfirEntity(loc, builder, result, ".tmp.func_result");
 }
 
-/// Lower calls to elemental user procedure with array actual arguments.
-static std::optional<hlfir::EntityWithAttributes>
-genElementalUserCall(PreparedActualArguments &loweredActuals,
-                     Fortran::lower::CallerInterface &caller,
-                     mlir::FunctionType callSiteType, bool isImpure,
-                     CallContext &callContext) {
-  using PassBy = Fortran::lower::CallerInterface::PassEntityBy;
+/// Lower calls to intrinsic procedures with actual arguments that have been
+/// pre-lowered but have not yet been prepared according to the interface.
+static hlfir::EntityWithAttributes genIntrinsicRefCore(
+    PreparedActualArguments &loweredActuals,
+    const Fortran::evaluate::SpecificIntrinsic &intrinsic,
+    const Fortran::lower::IntrinsicArgumentLoweringRules *argLowering,
+    std::optional<mlir::Type> coreResultType, CallContext &callContext) {
+  llvm::SmallVector<fir::ExtendedValue> operands;
+  auto &stmtCtx = callContext.stmtCtx;
+  auto &converter = callContext.converter;
+  mlir::Location loc = callContext.loc;
+  for (auto arg : llvm::enumerate(loweredActuals)) {
+    if (!arg.value()) {
+      operands.emplace_back(Fortran::lower::getAbsentIntrinsicArgument());
+      continue;
+    }
+    hlfir::Entity actual = arg.value()->actual;
+    if (arg.value()->handleDynamicOptional)
+      TODO(loc, "intrinsic dynamically optional arguments");
+    if (!argLowering) {
+      // No argument lowering instruction, lower by value.
+      operands.emplace_back(
+          Fortran::lower::convertToValue(loc, converter, actual, stmtCtx));
+      continue;
+    }
+    // Ad-hoc argument lowering handling.
+    Fortran::lower::ArgLoweringRule argRules =
+        Fortran::lower::lowerIntrinsicArgumentAs(*argLowering, arg.index());
+    switch (argRules.lowerAs) {
+    case Fortran::lower::LowerIntrinsicArgAs::Value:
+      operands.emplace_back(
+          Fortran::lower::convertToValue(loc, converter, actual, stmtCtx));
+      continue;
+    case Fortran::lower::LowerIntrinsicArgAs::Addr: {
+      const auto *argExpr = callContext.procRef.UnwrapArgExpr(arg.index());
+      bool isSimplyContiguous =
+          actual.isScalar() ||
+          (argExpr && Fortran::evaluate::IsSimplyContiguous(
+                          *argExpr, converter.getFoldingContext()));
+      operands.emplace_back(Fortran::lower::convertToAddress(
+          loc, converter, actual, isSimplyContiguous, stmtCtx));
+      continue;
+    }
+    case Fortran::lower::LowerIntrinsicArgAs::Box:
+      operands.emplace_back(
+          Fortran::lower::convertToBox(loc, converter, actual, stmtCtx));
+      continue;
+    case Fortran::lower::LowerIntrinsicArgAs::Inquired:
+      TODO(loc, "as inquired arguments in HLFIR");
+      continue;
+    }
+    llvm_unreachable("bad switch");
+  }
+  // Let the intrinsic library lower the intrinsic procedure call.
+  fir::ExtendedValue val = Fortran::lower::genIntrinsicCall(
+      callContext.getBuilder(), loc, intrinsic.name, coreResultType, operands,
+      stmtCtx);
+  return extendedValueToHlfirEntity(loc, callContext.getBuilder(), val,
+                                    ".tmp.intrinsic_result");
+}
+
+namespace {
+template <typename ElementalCallBuilderImpl>
+class ElementalCallBuilder {
+public:
+  std::optional<hlfir::EntityWithAttributes>
+  genElementalCall(PreparedActualArguments &loweredActuals, bool isImpure,
     mlir::Location loc = callContext.loc;
     fir::FirOpBuilder &builder = callContext.getBuilder();
-  assert(loweredActuals.size() == caller.getPassedArguments().size());
     unsigned numArgs = loweredActuals.size();
     // Step 1: dereference pointers/allocatables and compute elemental shape.
     mlir::Value shape;
     // 10.1.4 p5. Impure elemental procedures must be called in element order.
     bool mustBeOrdered = isImpure;
     for (unsigned i = 0; i < numArgs; ++i) {
-    const auto &arg = caller.getPassedArguments()[i];
       auto &preparedActual = loweredActuals[i];
       if (preparedActual) {
         hlfir::Entity &actual = preparedActual->actual;
         // Elemental procedure dummy arguments cannot be pointer/allocatables
         // (C15100), so it is safe to dereference any pointer or allocatable
         // actual argument now instead of doing this inside the elemental
         // region.
         actual = hlfir::derefPointersAndAllocatables(loc, builder, actual);
         // Better to load scalars outside of the loop when possible.
         if (!preparedActual->handleDynamicOptional &&
-          (arg.passBy == PassBy::Value ||
-           arg.passBy == PassBy::BaseAddressValueAttribute))
+            impl().canLoadActualArgumentBeforeLoop(i))
           actual = hlfir::loadTrivialScalar(loc, builder, actual);
         // TODO: merge shape instead of using the first one.
         if (!shape && actual.isArray()) {
           if (preparedActual->handleDynamicOptional)
             TODO(loc, "deal with optional with shapes in HLFIR elemental call");
           shape = hlfir::genShape(loc, builder, actual);
         }
         // 15.8.3 p1. Elemental procedure with intent(out)/intent(inout)
         // arguments must be called in element order.
-      if (arg.mayBeModifiedByCall())
+        if (impl().argMayBeModifiedByCall(i))
           mustBeOrdered = true;
       }
     }
     assert(shape &&
            "elemental array calls must have at least one array arguments");
     if (mustBeOrdered)
       TODO(loc, "ordered elemental calls in HLFIR");
+    // Push a new local scope so that any temps made inside the elemental
+    // iterations are cleaned up inside the iterations.
+    callContext.stmtCtx.pushScope();
     if (!callContext.resultType) {
       // Subroutine case. Generate call inside loop nest.
-    auto [innerLoop, oneBasedIndices] = hlfir::genLoopNest(loc, builder, shape);
+      auto [innerLoop, oneBasedIndices] =
+          hlfir::genLoopNest(loc, builder, shape);
       auto insPt = builder.saveInsertionPoint();
       builder.setInsertionPointToStart(innerLoop.getBody());
       for (auto &preparedActual : loweredActuals)
         if (preparedActual)
           preparedActual->actual = hlfir::getElementAt(
               loc, builder, preparedActual->actual, oneBasedIndices);
-    genUserCall(loweredActuals, caller, callSiteType, callContext);
+      impl().genElementalKernel(loweredActuals, callContext);
+      callContext.stmtCtx.finalizeAndPop();
       builder.restoreInsertionPoint(insPt);
       return std::nullopt;
     }
     // Function case: generate call inside hlfir.elemental
     mlir::Type elementType =
         hlfir::getFortranElementType(*callContext.resultType);
     // Get result length parameters.
     llvm::SmallVector<mlir::Value> typeParams;
     if (elementType.isa<fir::CharacterType>() ||
         fir::isRecordWithTypeParameters(elementType))
       TODO(loc, "compute elemental function result length parameters in HLFIR");
     auto genKernel = [&](mlir::Location l, fir::FirOpBuilder &b,
                          mlir::ValueRange oneBasedIndices) -> hlfir::Entity {
       for (auto &preparedActual : loweredActuals)
         if (preparedActual)
-        preparedActual->actual =
-            hlfir::getElementAt(l, b, preparedActual->actual, oneBasedIndices);
-    return *genUserCall(loweredActuals, caller, callSiteType, callContext);
+          preparedActual->actual = hlfir::getElementAt(
+              l, b, preparedActual->actual, oneBasedIndices);
+      auto res = *impl().genElementalKernel(loweredActuals, callContext);
+      callContext.stmtCtx.finalizeAndPop();
+      return res;
     };
     // TODO: deal with hlfir.elemental result destruction.
     return hlfir::EntityWithAttributes{hlfir::genElementalOp(
         loc, builder, elementType, shape, typeParams, genKernel)};
   }
 
+private:
+  ElementalCallBuilderImpl &impl() {
+    return *static_cast<ElementalCallBuilderImpl *>(this);
+  }
+};
+
+class ElementalUserCallBuilder
+    : public ElementalCallBuilder<ElementalUserCallBuilder> {
+public:
+  ElementalUserCallBuilder(Fortran::lower::CallerInterface &caller,
+                           mlir::FunctionType callSiteType)
+      : caller{caller}, callSiteType{callSiteType} {}
+  std::optional<hlfir::Entity>
+  genElementalKernel(PreparedActualArguments &loweredActuals,
+                     CallContext &callContext) {
+    return genUserCall(loweredActuals, caller, callSiteType, callContext);
+  }
+
+  bool argMayBeModifiedByCall(unsigned argIdx) const {
+    assert(argIdx < caller.getPassedArguments().size() && "bad argument index");
+    return caller.getPassedArguments()[argIdx].mayBeModifiedByCall();
+  }
+
+  bool canLoadActualArgumentBeforeLoop(unsigned argIdx) const {
+    using PassBy = Fortran::lower::CallerInterface::PassEntityBy;
+    assert(argIdx < caller.getPassedArguments().size() && "bad argument index");
+    // If the actual argument does not need to be passed via an address,
+    // or will be passed in the address of a temporary copy, it can be loaded
+    // before the elemental loop nest.
+    const auto &arg = caller.getPassedArguments()[argIdx];
+    return arg.passBy == PassBy::Value ||
+           arg.passBy == PassBy::BaseAddressValueAttribute;
+  }
+
+private:
+  Fortran::lower::CallerInterface &caller;
+  mlir::FunctionType callSiteType;
+};
+
+class ElementalIntrinsicCallBuilder
+    : public ElementalCallBuilder<ElementalIntrinsicCallBuilder> {
+public:
+  ElementalIntrinsicCallBuilder(
+      const Fortran::evaluate::SpecificIntrinsic &intrinsic,
+      const Fortran::lower::IntrinsicArgumentLoweringRules *argLowering,
+      bool isFunction)
+      : intrinsic{intrinsic}, argLowering{argLowering}, isFunction{isFunction} {
+  }
+  std::optional<hlfir::Entity>
+  genElementalKernel(PreparedActualArguments &loweredActuals,
+                     CallContext &callContext) {
+    std::optional<mlir::Type> coreResultType;
+    if (callContext.resultType.has_value())
+      coreResultType = hlfir::getFortranElementType(*callContext.resultType);
+    return genIntrinsicRefCore(loweredActuals, intrinsic, argLowering,
+                               coreResultType, callContext);
+  }
+  // Elemental intrinsic functions cannot modify their arguments.
+  bool argMayBeModifiedByCall(int) const { return !isFunction; }
+  bool canLoadActualArgumentBeforeLoop(int) const {
+    // Elemental intrinsic functions never need the actual addresses
+    // of their arguments.
+    return isFunction;
+  }
+
+private:
+  const Fortran::evaluate::SpecificIntrinsic &intrinsic;
+  const Fortran::lower::IntrinsicArgumentLoweringRules *argLowering;
+  const bool isFunction;
+};
+} // namespace
+
 /// Lower an intrinsic procedure reference.
 static hlfir::EntityWithAttributes
 genIntrinsicRef(const Fortran::evaluate::SpecificIntrinsic &intrinsic,
                 CallContext &callContext) {
   mlir::Location loc = callContext.loc;
   auto &converter = callContext.converter;
-  auto &stmtCtx = callContext.stmtCtx;
   if (Fortran::lower::intrinsicRequiresCustomOptionalHandling(
           callContext.procRef, intrinsic, converter))
     TODO(loc, "special cases of intrinsic with optional arguments");
-  if (callContext.isElementalProcWithArrayArgs())
-    TODO(loc, "lowering elemental intrinsic call to HLFIR");
 
-  llvm::SmallVector<fir::ExtendedValue> operands;
-  // Lower arguments to ... hlfir::Entity.
-  // Create elem context.
-  // Call inside code.
+  PreparedActualArguments loweredActuals;
   const Fortran::lower::IntrinsicArgumentLoweringRules *argLowering =
       Fortran::lower::getIntrinsicArgumentLowering(intrinsic.name);
   for (const auto &arg : llvm::enumerate(callContext.procRef.arguments())) {
     auto *expr =
         Fortran::evaluate::UnwrapExpr<Fortran::lower::SomeExpr>(arg.value());
     if (!expr) {
       // Absent optional.
-      operands.emplace_back(Fortran::lower::getAbsentIntrinsicArgument());
+      loweredActuals.push_back(std::nullopt);
       continue;
     }
-    if (!argLowering) {
-      // No argument lowering instruction, lower by value.
-      operands.emplace_back(converter.genExprValue(loc, *expr, stmtCtx));
-      continue;
-    }
-    // Ad-hoc argument lowering handling.
+    auto loweredActual = Fortran::lower::convertExprToHLFIR(
+        loc, callContext.converter, *expr, callContext.symMap,
+        callContext.stmtCtx);
+    bool handleDynamicOptional = false;
+    if (argLowering) {
       Fortran::lower::ArgLoweringRule argRules =
           Fortran::lower::lowerIntrinsicArgumentAs(*argLowering, arg.index());
-    if (argRules.handleDynamicOptional &&
+      handleDynamicOptional = argRules.handleDynamicOptional &&
                               Fortran::evaluate::MayBePassedAsAbsentOptional(
-            *expr, converter.getFoldingContext()))
-      TODO(loc, "intrinsic dynamically optional arguments");
-    switch (argRules.lowerAs) {
-    case Fortran::lower::LowerIntrinsicArgAs::Value:
-      operands.emplace_back(converter.genExprValue(loc, *expr, stmtCtx));
-      continue;
-    case Fortran::lower::LowerIntrinsicArgAs::Addr:
-      operands.emplace_back(converter.genExprAddr(loc, *expr, stmtCtx));
-      continue;
-    case Fortran::lower::LowerIntrinsicArgAs::Box:
-      operands.emplace_back(converter.genExprBox(loc, *expr, stmtCtx));
-      continue;
-    case Fortran::lower::LowerIntrinsicArgAs::Inquired:
-      TODO(loc, "as inquired arguments in HLFIR");
-      continue;
+                                  *expr, converter.getFoldingContext());
     }
-    llvm_unreachable("bad switch");
+    loweredActuals.push_back(
+        PreparedActualArgument{loweredActual, handleDynamicOptional});
   }
-  // Let the intrinsic library lower the intrinsic procedure call.
-  fir::ExtendedValue val = Fortran::lower::genIntrinsicCall(
-      callContext.getBuilder(), loc, intrinsic.name, callContext.resultType,
-      operands, stmtCtx);
-  return extendedValueToHlfirEntity(loc, callContext.getBuilder(), val,
-                                    ".tmp.intrinsic_result");
+
+  if (callContext.isElementalProcWithArrayArgs()) {
+    // All intrinsic elemental functions are pure.
+    const bool isFunction = callContext.resultType.has_value();
+    return ElementalIntrinsicCallBuilder{intrinsic, argLowering, isFunction}
+        .genElementalCall(loweredActuals, /*isImpure=*/!isFunction, callContext)
+        .value();
+  }
+  return genIntrinsicRefCore(loweredActuals, intrinsic, argLowering,
+                             callContext.resultType, callContext);
 }
 
 /// Main entry point to lower procedure references, regardless of what they are.
 static std::optional<hlfir::EntityWithAttributes>
 genProcedureRef(CallContext &callContext) {
   mlir::Location loc = callContext.loc;
   if (auto *intrinsic = callContext.procRef.proc().GetSpecificIntrinsic())
     return genIntrinsicRef(*intrinsic, callContext);
if (const auto *actual = arg.entity) {
       // Optional dummy argument for which there is no actual argument.
       loweredActuals.emplace_back(std::nullopt);
     }
   if (callContext.isElementalProcWithArrayArgs()) {
     bool isImpure = false;
     if (const Fortran::semantics::Symbol *procSym =
             callContext.procRef.proc().GetSymbol())
       isImpure = !Fortran::semantics::IsPureProcedure(*procSym);
-    return genElementalUserCall(loweredActuals, caller, callSiteType, isImpure,
-                                callContext);
+    return ElementalUserCallBuilder{caller, callSiteType}.genElementalCall(
+        loweredActuals, isImpure, callContext);
   }
   return genUserCall(loweredActuals, caller, callSiteType, callContext);
 }
 
 std::optional<hlfir::EntityWithAttributes> Fortran::lower::convertCallToHLFIR(
     mlir::Location loc, Fortran::lower::AbstractConverter &converter,
     const evaluate::ProcedureRef &procRef, std::optional<mlir::Type> resultType,
     Fortran::lower::SymMap &symMap, Fortran::lower::StatementContext &stmtCtx) {
   CallContext callContext(procRef, resultType, loc, converter, symMap, stmtCtx);
   return genProcedureRef(callContext);
 }

flang/lib/Lower/ConvertExprToHLFIR.cpp

 
 hlfir::EntityWithAttributes Fortran::lower::convertExprToHLFIR(
     mlir::Location loc, Fortran::lower::AbstractConverter &converter,
     const Fortran::lower::SomeExpr &expr, Fortran::lower::SymMap &symMap,
     Fortran::lower::StatementContext &stmtCtx) {
   return HlfirBuilder(loc, converter, symMap, stmtCtx).gen(expr);
 }
 
-fir::BoxValue Fortran::lower::convertExprToBox(
+fir::BoxValue Fortran::lower::convertToBox(
     mlir::Location loc, Fortran::lower::AbstractConverter &converter,
-    const Fortran::lower::SomeExpr &expr, Fortran::lower::SymMap &symMap,
-    Fortran::lower::StatementContext &stmtCtx) {
-  hlfir::EntityWithAttributes loweredExpr =
-      HlfirBuilder(loc, converter, symMap, stmtCtx).gen(expr);
+    hlfir::Entity entity, Fortran::lower::StatementContext &stmtCtx) {
   auto exv = Fortran::lower::translateToExtendedValue(
-      loc, converter.getFirOpBuilder(), loweredExpr, stmtCtx);
+      loc, converter.getFirOpBuilder(), entity, stmtCtx);
   if (fir::isa_trivial(fir::getBase(exv).getType()))
     TODO(loc, "place trivial in memory");
   return fir::factory::createBoxValue(converter.getFirOpBuilder(), loc, exv);
 }
-
-fir::ExtendedValue Fortran::lower::convertExprToAddress(
+fir::BoxValue Fortran::lower::convertExprToBox(
     mlir::Location loc, Fortran::lower::AbstractConverter &converter,
     const Fortran::lower::SomeExpr &expr, Fortran::lower::SymMap &symMap,
     Fortran::lower::StatementContext &stmtCtx) {
   hlfir::EntityWithAttributes loweredExpr =
       HlfirBuilder(loc, converter, symMap, stmtCtx).gen(expr);
-  if (expr.Rank() > 0 && !Fortran::evaluate::IsSimplyContiguous(
-                             expr, converter.getFoldingContext()))
+  return convertToBox(loc, converter, loweredExpr, stmtCtx);
+}
+
+fir::ExtendedValue
+Fortran::lower::convertToAddress(mlir::Location loc,
+                                 Fortran::lower::AbstractConverter &converter,
+                                 hlfir::Entity entity, bool isSimplyContiguous,
+                                 Fortran::lower::StatementContext &stmtCtx) {
+  if (!isSimplyContiguous)
     TODO(loc, "genExprAddr of non contiguous variables in HLFIR");
   fir::ExtendedValue exv = Fortran::lower::translateToExtendedValue(
-      loc, converter.getFirOpBuilder(), loweredExpr, stmtCtx);
+      loc, converter.getFirOpBuilder(), entity, stmtCtx);
   if (fir::isa_trivial(fir::getBase(exv).getType()))
     TODO(loc, "place trivial in memory");
   if (const auto *mutableBox = exv.getBoxOf<fir::MutableBoxValue>())
     exv = fir::factory::genMutableBoxRead(converter.getFirOpBuilder(), loc,
                                           *mutableBox);
   return exv;
 }
+fir::ExtendedValue Fortran::lower::convertExprToAddress(
+    mlir::Location loc, Fortran::lower::AbstractConverter &converter,
+    const Fortran::lower::SomeExpr &expr, Fortran::lower::SymMap &symMap,
+    Fortran::lower::StatementContext &stmtCtx) {
+  hlfir::EntityWithAttributes loweredExpr =
+      HlfirBuilder(loc, converter, symMap, stmtCtx).gen(expr);
+  bool isSimplyContiguous =
+      expr.Rank() == 0 || Fortran::evaluate::IsSimplyContiguous(
+                              expr, converter.getFoldingContext());
+  return convertToAddress(loc, converter, loweredExpr, isSimplyContiguous,
+                          stmtCtx);
+}
+
+fir::ExtendedValue Fortran::lower::convertToValue(
+    mlir::Location loc, Fortran::lower::AbstractConverter &converter,
+    hlfir::Entity entity, Fortran::lower::StatementContext &stmtCtx) {
+  auto &builder = converter.getFirOpBuilder();
+  fir::ExtendedValue exv =
+      Fortran::lower::translateToExtendedValue(loc, builder, entity, stmtCtx);
+  // Load scalar references to integer, logical, real, or complex value
+  // to an mlir value, dereference allocatable and pointers, and get rid
+  // of fir.box that are not needed or create a copy into contiguous memory.
+  return exv.match(
+      [&](const fir::UnboxedValue &box) -> fir::ExtendedValue {
+        if (mlir::Type elementType = fir::dyn_cast_ptrEleTy(box.getType()))
+          if (fir::isa_trivial(elementType))
+            return builder.create<fir::LoadOp>(loc, box);
+        return box;
+      },
+      [&](const fir::CharBoxValue &box) -> fir::ExtendedValue { return box; },
+      [&](const fir::ArrayBoxValue &box) -> fir::ExtendedValue { return box; },
+      [&](const fir::CharArrayBoxValue &box) -> fir::ExtendedValue {
+        return box;
+      },
+      [&](const auto &) -> fir::ExtendedValue {
+        TODO(loc, "lower descriptor designator to HLFIR value");
+      });
+}
+
+fir::ExtendedValue Fortran::lower::convertExprToValue(
+    mlir::Location loc, Fortran::lower::AbstractConverter &converter,
+    const Fortran::lower::SomeExpr &expr, Fortran::lower::SymMap &symMap,
+    Fortran::lower::StatementContext &stmtCtx) {
+  hlfir::EntityWithAttributes loweredExpr =
+      HlfirBuilder(loc, converter, symMap, stmtCtx).gen(expr);
+  return convertToValue(loc, converter, loweredExpr, stmtCtx);
+}

flang/test/Lower/HLFIR/elemental-intrinsics.f90

+! Test lowering of intrinsic elemental procedure reference to HLFIR
+! The goal here is not to test every intrinsics, it is to test the
+! lowering framework for elemental intrinsics. This test various
+! intrinsics that have different number or arguments and argument types.
+! RUN: bbc -emit-fir -hlfir -o - %s | FileCheck %s
+
+subroutine simple_elemental(x,y)
+  real :: x(100), y(100)
+  x = acos(y)
+end subroutine
+! CHECK-LABEL: func.func @_QPsimple_elemental(
+! CHECK:  %[[VAL_4:.*]]:2 = hlfir.declare %[[VAL_0:[a-z0-9]*]](%[[VAL_3:[a-z0-9]*]])  {{.*}}Ex
+! CHECK:  %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_1:[a-z0-9]*]](%[[VAL_6:[a-z0-9]*]])  {{.*}}Ey
+! CHECK:  %[[VAL_8:.*]] = hlfir.elemental %[[VAL_6]] : (!fir.shape<1>) -> !hlfir.expr<100xf32> {
+! CHECK:  ^bb0(%[[VAL_9:.*]]: index):
+! CHECK:    %[[VAL_10:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_9]])  : (!fir.ref<!fir.array<100xf32>>, index) -> !fir.ref<f32>
+! CHECK:    %[[VAL_11:.*]] = fir.load %[[VAL_10]] : !fir.ref<f32>
+! CHECK:    %[[VAL_12:.*]] = fir.call @acosf(%[[VAL_11]]) fastmath<contract> : (f32) -> f32
+! CHECK:    hlfir.yield_element %[[VAL_12]] : f32
+! CHECK:  }
+
+subroutine elemental_mixed_args(x,y, scalar)
+  real :: x(100), y(100), scalar
+  x = atan2(x, scalar)
+end subroutine
+! CHECK-LABEL: func.func @_QPelemental_mixed_args(
+! CHECK:  %[[VAL_3:.*]]:2 = hlfir.declare %[[VAL_2:[a-z0-9]*]]  {{.*}}Escalar
+! CHECK:  %[[VAL_4:.*]] = arith.constant 100 : index
+! CHECK:  %[[VAL_5:.*]] = fir.shape %[[VAL_4]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_0:[a-z0-9]*]](%[[VAL_5:[a-z0-9]*]])  {{.*}}Ex
+! CHECK:  %[[VAL_7:.*]] = arith.constant 100 : index
+! CHECK:  %[[VAL_8:.*]] = fir.shape %[[VAL_7]] : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_9:.*]]:2 = hlfir.declare %[[VAL_1:[a-z0-9]*]](%[[VAL_8:[a-z0-9]*]])  {{.*}}Ey
+! CHECK:  %[[VAL_10:.*]] = fir.load %[[VAL_3]]#0 : !fir.ref<f32>
+! CHECK:  %[[VAL_11:.*]] = hlfir.elemental %[[VAL_5]] : (!fir.shape<1>) -> !hlfir.expr<100xf32> {
+! CHECK:  ^bb0(%[[VAL_12:.*]]: index):
+! CHECK:    %[[VAL_13:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_12]])  : (!fir.ref<!fir.array<100xf32>>, index) -> !fir.ref<f32>
+! CHECK:    %[[VAL_14:.*]] = fir.load %[[VAL_13]] : !fir.ref<f32>
+! CHECK:    %[[VAL_15:.*]] = math.atan2 %[[VAL_14]], %[[VAL_10]] fastmath<contract> : f32
+! CHECK:    hlfir.yield_element %[[VAL_15]] : f32
+! CHECK:  }
+
+subroutine elemental_assumed_shape_arg(x)
+  real :: x(:)
+  print *, sin(x)
+end subroutine
+! CHECK-LABEL: func.func @_QPelemental_assumed_shape_arg(
+! CHECK:  %[[VAL_1:.*]]:2 = hlfir.declare %[[VAL_0:[a-z0-9]*]]  {{.*}}Ex
+! CHECK:  %[[VAL_7:.*]] = arith.constant 0 : index
+! CHECK:  %[[VAL_8:.*]]:3 = fir.box_dims %[[VAL_1]]#0, %[[VAL_7]] : (!fir.box<!fir.array<?xf32>>, index) -> (index, index, index)
+! CHECK:  %[[VAL_9:.*]] = fir.shape %[[VAL_8]]#1 : (index) -> !fir.shape<1>
+! CHECK:  %[[VAL_10:.*]] = hlfir.elemental %[[VAL_9]] : (!fir.shape<1>) -> !hlfir.expr<?xf32> {
+! CHECK:  ^bb0(%[[VAL_11:.*]]: index):
+! CHECK:    %[[VAL_12:.*]] = hlfir.designate %[[VAL_1]]#0 (%[[VAL_11]])  : (!fir.box<!fir.array<?xf32>>, index) -> !fir.ref<f32>
+! CHECK:    %[[VAL_13:.*]] = fir.load %[[VAL_12]] : !fir.ref<f32>
+! CHECK:    %[[VAL_14:.*]] = math.sin %[[VAL_13]] fastmath<contract> : f32
+! CHECK:    hlfir.yield_element %[[VAL_14]] : f32
+! CHECK:  }
+
+subroutine elemental_with_char_args(x,y)
+  character(*) :: x(100), y(:)
+  print *, scan(x, y)
+end subroutine
+! CHECK-LABEL: func.func @_QPelemental_with_char_args(
+! CHECK:  %[[VAL_6:.*]]:2 = hlfir.declare %[[VAL_3:[a-z0-9]*]](%[[VAL_5:[a-z0-9]*]]) typeparams %[[VAL_2:[a-z0-9]*]]#1  {{.*}}Ex
+! CHECK:  %[[VAL_7:.*]]:2 = hlfir.declare %[[VAL_1:[a-z0-9]*]]  {{.*}}Ey
+! CHECK:  %[[VAL_13:.*]] = hlfir.elemental %[[VAL_5]] : (!fir.shape<1>) -> !hlfir.expr<100xi32> {
+! CHECK:  ^bb0(%[[VAL_14:.*]]: index):
+! CHECK:    %[[VAL_15:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_14]])  typeparams %[[VAL_2]]#1 : (!fir.box<!fir.array<100x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+! CHECK:    %[[VAL_16:.*]] = fir.box_elesize %[[VAL_7]]#1 : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> index
+! CHECK:    %[[VAL_17:.*]] = hlfir.designate %[[VAL_7]]#0 (%[[VAL_14]])  typeparams %[[VAL_16]] : (!fir.box<!fir.array<?x!fir.char<1,?>>>, index, index) -> !fir.boxchar<1>
+! CHECK:    %[[VAL_18:.*]]:2 = fir.unboxchar %[[VAL_15]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:    %[[VAL_19:.*]]:2 = fir.unboxchar %[[VAL_17]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1,?>>, index)
+! CHECK:    %[[VAL_20:.*]] = arith.constant false
+! CHECK:    %[[VAL_21:.*]] = fir.convert %[[VAL_18]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+! CHECK:    %[[VAL_22:.*]] = fir.convert %[[VAL_2]]#1 : (index) -> i64
+! CHECK:    %[[VAL_23:.*]] = fir.convert %[[VAL_19]]#0 : (!fir.ref<!fir.char<1,?>>) -> !fir.ref<i8>
+! CHECK:    %[[VAL_24:.*]] = fir.convert %[[VAL_16]] : (index) -> i64
+! CHECK:    %[[VAL_25:.*]] = fir.call @_FortranAScan1(%[[VAL_21]], %[[VAL_22]], %[[VAL_23]], %[[VAL_24]], %[[VAL_20]])
+! CHECK:    %[[VAL_26:.*]] = fir.convert %[[VAL_25]] : (i64) -> i32
+! CHECK:    hlfir.yield_element %[[VAL_26]] : i32
+! CHECK:  }