[flang] lower sum intrinsic to hlfir.sum operation

[tblah]

Summary

See https://reviews.llvm.org/D142897

[clementval]

flang/lib/Lower/ConvertCall.cpp

1262

We probably want to have a more generic way to lower those intrinsic operations. Something like the table in flang/lib/Lower/IntrinsicCall.cpp.

[jeanPerier]

Nits about the builder and extendedValueToHlfirEntity usage. Looks good otherwise.

flang/lib/Lower/ConvertCall.cpp

641

fir::ExtendedValue should not contain hlfir::ExprType (all the helpers and functions only expect to work on fir::ExtendedValue that wraps fir/mlir types).

1262

When lowering fully switch to the new expression representation, it will be possible to do so I think, but right now, it is not really possible because IntrinsicCall.cpp is based on the fir::ExtendedValue representation which requires array operands to be in memory, and the whole point of HLFIR is to try to avoid creating the temporary (to directly inline SUM(A+B) without ever creating a temp for A+B).

So I am OK with this not very optimal approach to start with, then we can improve this when we do not have to jungle between both lowering.

1271

sumOp is not a fir::ExtendedValue. hlfir.epxr already are valid HLFIR entities, you can directly return hlfir::EntityWithAttributes{sumOp.getResult()}; (that will only assert that sumOp.getResult() is indeed a valid HLFIR entity type).

flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp

495–505

You could have used numType = hlfir::getFortranElementType(array.getType()) here, but I do not think you even need it if you always use the element type from stmtResultType (and since the assert should not be added here for properties that are verified in the verifier).

505

Better to not assert here since the verifier deals with this.

509

Is there a case where stmtResultType would be absent ? I think it would be simpler to require it to be present.

511–512

Same here.

515

Same here.

[jeanPerier]

flang/lib/Lower/ConvertCall.cpp

1266

Here, I think it would be best to add dim = dim ? hlfir::loadTrivialScalar(loc, builder, dim) as well as array = hlfir::derefPointersAndAllocatables(loc, builder, array) so that the operands of the hlfir.sum are decorelated from the dereferences as much as possible.

The mask case is a bit trickier since it may be dynamically optional. hlfir.sum may need an extra optional i1 value argument to hold the dynamic presence of the mask in this case, but it is also ok to call derefPointersAndAllocatables on deallocated pointers/allocatable: the result is a fir.box that contains a null address.

[tblah]

Thanks for reviewing
Changes:

• Respond to review feedback
• Add tests

flang/lib/Lower/ConvertCall.cpp

1266

See discussion on the first patch in the series. This omission is deliberate because I think it will make it simpler for passes to pattern match on this if we don't convert the operands until lowering to the runtime call.

For example, a pass might want to match MATMUL(TRANSPOSE(...), ....). This is simpler if the the generated HLFIR is something like

%transpose_expr = hlfir.transpose [...] : hlfir.expr<[...]>
%other_expr = [...] : hlfir.expr<[...]>
%mul_expr = hlfir.matmul %transpose_expr %other_expr

But I am open to your input on this

[jeanPerier]

flang/lib/Lower/ConvertCall.cpp

1266

Your example makes absolute sense to me, but I think pattern matching will not be impacted by loads of scalars when obvious (like here with DIM), or dereference of allocatable and pointers.
I am inclined to think having a single place where this special cases are handled is simpler than in the operation transform that are likely to not be done with the allocatable/pointer case in mind.

For instance, would the current hlfir.sum handle:

subroutine foo(s, x, dim)
  integer, pointer :: dim
  real :: x(:, :), s(:)
  s = sum(x, dim)
end subroutine

It is a stupid edge case that is unlikely to be found in real apps, and, if an issue, would only be discovered quite late.

Using derefPointersAndAllocatables/loadTrivialScalar when possible does not affect the chaining of transformational since it does not touch values (hlfir.expr and simple scalars, which should be what is returned by sub-expression lowered nodes) and in my opinion will allow for simpler and more robust transformational operations.

I understand however that is is a bit inconvenient/not so nice to have to "split" the argument cooking between lowering and the pass that translate the operation to HLFIR.

[tblah]

Changes:

• Add load operation for pass-by-ref DIM argument
• derefPointersAndAllocatables on ARRAY argument
• Add a test for pass-by-pointer DIM argument

[jeanPerier]

Small nits. looks good otherwise!
Please merge at the same time of after the codegen patch (D143512) so that this patch does not break the end-to-end flow.

flang/lib/Lower/ConvertCall.cpp

1249–1260

It may be better to place this code in a helper lambda and call it when needed (only for SUM here), rather than doing this for all other intrinsics where "operands" will not be used.

1262

Could you add a static llvm::cl::opt<bool> to control the intrinsic lowering to use the hlfir ops or not ?

I am OK with having it on by default, but I think it will be interesting to be able to run some test suits/benchmark with it on/off to catch potential issues.

1266

If you want to assert, I think it would be most useful on operands[0] since the line above would crash if it is null (hlfir::Entity cannot be created from null values).

[tblah]

Fix nits in review

[jeanPerier]

LGTM

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

def hlfir_SumOp : hlfir_Op<"sum", [AttrSizedOperandSegments,
   );
 
   let results = (outs hlfir_ExprType);
 
   let assemblyFormat = [{
     $array (`dim` $dim^)? (`mask` $mask^)? attr-dict `:` functional-type(operands, results)
   }];
 
+  // dim and mask can be NULL, array must not be.
+  let builders = [OpBuilder<(ins "mlir::Value":$array,
+                                 "mlir::Value":$dim,
+                                 "mlir::Value":$mask,
+                                 "mlir::Type":$resultType)>];
+
   let hasVerifier = 1;
 }
 
 def hlfir_AssociateOp : hlfir_Op<"associate", [AttrSizedOperandSegments,
     DeclareOpInterfaceMethods<fir_FortranVariableOpInterface>]> {
   let summary = "Create a variable from an expression value";
   let description = [{
     Create a variable from an expression value.

flang/lib/Lower/ConvertCall.cpp

 #include "flang/Lower/ConvertExprToHLFIR.h"
 #include "flang/Lower/ConvertVariable.h"
 #include "flang/Lower/CustomIntrinsicCall.h"
 #include "flang/Lower/StatementContext.h"
 #include "flang/Lower/SymbolMap.h"
 #include "flang/Optimizer/Builder/BoxValue.h"
 #include "flang/Optimizer/Builder/Character.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
+#include "flang/Optimizer/Builder/HLFIRTools.h"
 #include "flang/Optimizer/Builder/IntrinsicCall.h"
 #include "flang/Optimizer/Builder/LowLevelIntrinsics.h"
 #include "flang/Optimizer/Builder/MutableBox.h"
 #include "flang/Optimizer/Builder/Runtime/Derived.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/HLFIR/HLFIROps.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include <optional>
 
 #define DEBUG_TYPE "flang-lower-expr"
 
+static llvm::cl::opt<bool> useHlfirIntrinsicOps(
+    "use-hlfir-intrinsic-ops", llvm::cl::init(true),
+    llvm::cl::desc("Lower via HLFIR transformational intrinsic operations such as hlfir.sum"));
+
 /// Helper to package a Value and its properties into an ExtendedValue.
 static fir::ExtendedValue toExtendedValue(mlir::Location loc, mlir::Value base,
                                           llvm::ArrayRef<mlir::Value> extents,
                                           llvm::ArrayRef<mlir::Value> lengths) {
   mlir::Type type = base.getType();
   if (type.isa<fir::BaseBoxType>())
     return fir::BoxValue(base, /*lbounds=*/{}, lengths, extents);
   type = fir::unwrapRefType(type);
using PreparedActualArguments =
     llvm::SmallVector<std::optional<PreparedActualArgument>>;
 
 // Helper to transform a fir::ExtendedValue to an hlfir::EntityWithAttributes.
 static hlfir::EntityWithAttributes
 extendedValueToHlfirEntity(mlir::Location loc, fir::FirOpBuilder &builder,
                            const fir::ExtendedValue &exv,
                            llvm::StringRef name) {
   mlir::Value firBase = fir::getBase(exv);
-  if (fir::isa_trivial(firBase.getType()))
+  mlir::Type firBaseTy = firBase.getType();
+  if (fir::isa_trivial(firBaseTy))
     return hlfir::EntityWithAttributes{firBase};
   if (auto charTy = firBase.getType().dyn_cast<fir::CharacterType>()) {
     // CHAR() intrinsic and BIND(C) procedures returning CHARACTER(1)
     // are lowered to a fir.char<kind,1> that is not in memory.
     // This tends to cause a lot of bugs because the rest of the
     // infrastructure is mostly tested with characters that are
     // in memory.
     // To avoid having to deal with this special case here and there,
if (resultEntity.isVariable()) {
     else
       asExpr = builder.create<hlfir::AsExprOp>(
           loc, resultEntity, builder.createBool(loc, mustBeFreed));
     resultEntity = hlfir::EntityWithAttributes{asExpr.getResult()};
   }
   return resultEntity;
 }
 
+/// Lower calls to intrinsic procedures with actual arguments that have been
+/// pre-lowered but have not yet been prepared according to the interface.
+static std::optional<hlfir::EntityWithAttributes>
+genHLFIRIntrinsicRefCore(PreparedActualArguments &loweredActuals,
+                         const Fortran::evaluate::SpecificIntrinsic &intrinsic,
+                         const fir::IntrinsicArgumentLoweringRules *argLowering,
+                         CallContext &callContext) {
+  if (!useHlfirIntrinsicOps)
+    return genIntrinsicRefCore(loweredActuals, intrinsic, argLowering, callContext);
+
+  auto getOperandVector =
+    [](PreparedActualArguments &loweredActuals) {
+      llvm::SmallVector<mlir::Value> operands;
+      operands.reserve(loweredActuals.size());
+      for (auto arg : llvm::enumerate(loweredActuals)) {
+        if (!arg.value()) {
+          operands.emplace_back();
+          continue;
+        }
+        hlfir::Entity actual = arg.value()->getOriginalActual();
+        operands.emplace_back(actual.getBase());
+      }
+      return operands;
+    };
+
+  fir::FirOpBuilder &builder = callContext.getBuilder();
+  mlir::Location loc = callContext.loc;
+
+  if (intrinsic.name == "sum") {
+    llvm::SmallVector<mlir::Value> operands = getOperandVector(loweredActuals);
+    assert(operands.size() == 3);
+    mlir::Value array = hlfir::derefPointersAndAllocatables(
+        loc, builder, hlfir::Entity{operands[0]});
+    mlir::Value dim = operands[1];
+    if (dim)
+      dim = hlfir::loadTrivialScalar(loc, builder, hlfir::Entity{dim});
+    mlir::Value mask = operands[2];
+    // dim, mask can be NULL if these arguments were not given
+    hlfir::SumOp sumOp = builder.create<hlfir::SumOp>(loc, array, dim, mask,
+                                                      *callContext.resultType);
+    return {hlfir::EntityWithAttributes{sumOp.getResult()}};
+  }
+
+  // TODO add hlfir operations for other transformational intrinsics here
+
+  // fallback to calling the intrinsic via fir.call
+  return genIntrinsicRefCore(loweredActuals, intrinsic, argLowering,
+                             callContext);
+}
+
 namespace {
 template <typename ElementalCallBuilderImpl>
 class ElementalCallBuilder {
 public:
   std::optional<hlfir::EntityWithAttributes>
   genElementalCall(PreparedActualArguments &loweredActuals, bool isImpure,
                    CallContext &callContext) {
     mlir::Location loc = callContext.loc;
public:
   ElementalIntrinsicCallBuilder(
       const Fortran::evaluate::SpecificIntrinsic &intrinsic,
       const fir::IntrinsicArgumentLoweringRules *argLowering, bool isFunction)
       : intrinsic{intrinsic}, argLowering{argLowering}, isFunction{isFunction} {
   }
   std::optional<hlfir::Entity>
   genElementalKernel(PreparedActualArguments &loweredActuals,
                      CallContext &callContext) {
-    return genIntrinsicRefCore(loweredActuals, intrinsic, argLowering,
+    return genHLFIRIntrinsicRefCore(loweredActuals, intrinsic, argLowering,
                                     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;
   }
genIntrinsicRef(const Fortran::evaluate::SpecificIntrinsic &intrinsic,
 
   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();
   }
-  std::optional<hlfir::EntityWithAttributes> result =
-      genIntrinsicRefCore(loweredActuals, intrinsic, argLowering, callContext);
+  std::optional<hlfir::EntityWithAttributes> result = genHLFIRIntrinsicRefCore(
+      loweredActuals, intrinsic, argLowering, callContext);
   if (result && result->getType().isa<hlfir::ExprType>()) {
     fir::FirOpBuilder *bldr = &callContext.getBuilder();
     callContext.stmtCtx.attachCleanup(
         [=]() { bldr->create<hlfir::DestroyOp>(loc, *result); });
   }
   return result;
 }
 

flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp

if (resultTy.isArray()) {
     if (resultTy.getElementType() != numTy)
       return emitOpError(
           "result must have the same element type as ARRAY argument");
   }
 
   return mlir::success();
 }
 
+void hlfir::SumOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
+                         mlir::Value array, mlir::Value dim, mlir::Value mask,
+                         mlir::Type stmtResultType) {
+  assert(array && "array argument is not optional");
+
+  fir::SequenceType arrayTy =
+      hlfir::getFortranElementOrSequenceType(array.getType())
+          .dyn_cast<fir::SequenceType>();
+  assert(arrayTy && "array must be of array type");
+  mlir::Type numTy = arrayTy.getEleTy();
+
+  // get the result shape from the statement context
+  hlfir::ExprType::Shape resultShape;
+  if (auto array = stmtResultType.dyn_cast<fir::SequenceType>()) {
+    resultShape = hlfir::ExprType::Shape{array.getShape()};
+  }
+  mlir::Type resultType = hlfir::ExprType::get(
+      builder.getContext(), resultShape, numTy, /*polymorphic=*/false);
+
+  build(builder, result, resultType, array, dim, mask);
+}
+
 //===----------------------------------------------------------------------===//
 // AssociateOp
 //===----------------------------------------------------------------------===//
 
 void hlfir::AssociateOp::build(mlir::OpBuilder &builder,
                                mlir::OperationState &result, mlir::Value source,
                                llvm::StringRef uniq_name, mlir::Value shape,
                                mlir::ValueRange typeparams,
                                fir::FortranVariableFlagsAttr fortran_attrs) {
   auto nameAttr = builder.getStringAttr(uniq_name);

flang/test/Lower/HLFIR/expr-box.f90

 ! CHECK:  %[[AND:.*]] = arith.andi {{.*}}
 ! CHECK:  %[[CAST:.*]] = fir.convert %[[AND]] : (i1) -> !fir.logical<8>
 ! CHECK:  fir.store %[[CAST]] to %[[TEMP]] : !fir.ref<!fir.logical<8>>
 ! CHECK:  %[[BOX:.*]] = fir.embox %[[TEMP]] : (!fir.ref<!fir.logical<8>>) -> !fir.box<!fir.logical<8>>
 ! CHECK:  %[[BOX_CAST:.*]] = fir.convert %[[BOX]] : (!fir.box<!fir.logical<8>>) -> !fir.box<none>
 ! CHECK:  fir.call @_FortranAioOutputDescriptor(%{{.*}}, %[[BOX_CAST]])
 
 ! check we can box a trivial value
-subroutine sumMask(s, a)
+subroutine productMask(s, a)
   integer :: s
   integer :: a(:)
-  s = sum(a, mask=.true.)
+  s = product(a, mask=.true.)
 endsubroutine
-! CHECK-LABEL: func.func @_QPsummask(
+! CHECK-LABEL: func.func @_QPproductmask(
 ! CHECK:      %[[TRUE:.*]] = arith.constant true
 ! CHECK:      %[[ALLOC:.*]] = fir.alloca !fir.logical<4>
 ! CHECK:      %[[TRUE_L4:.*]] = fir.convert %[[TRUE]] : (i1) -> !fir.logical<4>
 ! CHECK-NEXT: fir.store %[[TRUE_L4]] to %[[ALLOC]]
 ! CHECK-NEXT: %[[BOX:.*]] = fir.embox %[[ALLOC]] : (!fir.ref<!fir.logical<4>>) -> !fir.box<!fir.logical<4>>

flang/test/Lower/HLFIR/sum.f90

+! Test lowering of SUM intrinsic to HLFIR
+! RUN: bbc -emit-fir -hlfir -o - %s 2>&1 | FileCheck %s
+
+! simple 1 argument SUM
+subroutine sum1(a, s)
+  integer :: a(:), s
+  s = SUM(a)
+end subroutine
+! CHECK-LABEL: func.func @_QPsum1(
+! CHECK:           %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref<i32>
+! CHECK-DAG:     %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]
+! CHECK-DAG:     %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]
+! CHECK-NEXT:    %[[EXPR:.*]] = hlfir.sum %[[ARRAY]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>) ->
+!hlfir.expr<i32>
+! CHECK-NEXT:    hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<i32>, !fir.ref<i32>
+! CHECK-NEXT:    hlfir.destroy %[[EXPR]]
+! CHECK-NEXT:    return
+! CHECK-NEXT:  }
+
+! sum with by-ref DIM argument
+subroutine sum2(a, s, d)
+  integer :: a(:,:), s(:), d
+  s = SUM(a, d)
+end subroutine
+! CHECK-LABEL: func.func @_QPsum2(
+! CHECK:           %[[ARG0:.*]]: !fir.box<!fir.array<?x?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "s"}, %[[ARG2:.*]]: !fir.ref<i32>
+! CHECK-DAG:     %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]
+! CHECK-DAG:     %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]
+! CHECK-DAG:     %[[DIM_REF:.*]]:2 = hlfir.declare %[[ARG2]]
+! CHECK-NEXT:    %[[DIM:.*]] = fir.load %[[DIM_REF]]#0 : !fir.ref<i32>
+! CHECK-NEXT:    %[[EXPR:.*]] = hlfir.sum %[[ARRAY]]#0 dim %[[DIM]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?x?xi32>>, i32) -> !hlfir.expr<?xi32>
+! CHECK-NEXT:    hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<?xi32>, !fir.box<!fir.array<?xi32>>
+! CHECK-NEXT:    hlfir.destroy %[[EXPR]]
+! CHECK-NEXT:    return
+! CHECK-NEXT:  }
+
+! sum with scalar mask argument
+subroutine sum3(a, s, m)
+  integer :: a(:), s
+  logical :: m
+  s = SUM(a, m)
+end subroutine
+! CHECK-LABEL: func.func @_QPsum3(
+! CHECK:           %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref<i32> {fir.bindc_name = "s"}, %[[ARG2:.*]]: !fir.ref<!fir.logical<4>>
+! CHECK-DAG:     %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]
+! CHECK-DAG:     %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]
+! CHECK-DAG:     %[[MASK:.*]]:2 = hlfir.declare %[[ARG2]]
+! CHECK-NEXT:    %[[EXPR:.*]] = hlfir.sum %[[ARRAY]]#0 mask %[[MASK]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.ref<!fir.logical<4>>) -> !hlfir.expr<i32>
+! CHECK-NEXT:    hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<i32>, !fir.ref<i32>
+! CHECK-NEXT:    hlfir.destroy %[[EXPR]]
+! CHECK-NEXT:    return
+! CHECK-NEXT:  }
+
+! sum with array mask argument
+subroutine sum4(a, s, m)
+  integer :: a(:), s
+  logical :: m(:)
+  s = SUM(a, m)
+end subroutine
+! CHECK-LABEL: func.func @_QPsum4(
+! CHECK:           %[[ARG0:.*]]: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "a"}, %[[ARG1:.*]]: !fir.ref<i32> {fir.bindc_name = "s"}, %[[ARG2:.*]]: !fir.box<!fir.array<?x!fir.logical<4>>>
+! CHECK-DAG:     %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]
+! CHECK-DAG:     %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]
+! CHECK-DAG:     %[[MASK:.*]]:2 = hlfir.declare %[[ARG2]]
+! CHECK-NEXT:    %[[EXPR:.*]] = hlfir.sum %[[ARRAY]]#0 mask %[[MASK]]#0 {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?xi32>>, !fir.box<!fir.array<?x!fir.logical<4>>>) -> !hlfir.expr<i32>
+! CHECK-NEXT:    hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<i32>, !fir.ref<i32>
+! CHECK-NEXT:    hlfir.destroy %[[EXPR]]
+! CHECK-NEXT:    return
+! CHECK-NEXT:  }
+
+! sum with all 3 arguments, dim is by-val, array isn't boxed
+subroutine sum5(s)
+  integer :: s(2)
+  integer :: a(2,2) = reshape((/1, 2, 3, 4/), [2,2])
+  s = sum(a, 1, .true.)
+end subroutine
+! CHECK-LABEL: func.func @_QPsum5
+! CHECK:           %[[ARG0:.*]]: !fir.ref<!fir.array<2xi32>>
+! CHECK-DAG:     %[[ADDR:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.array<2x2xi32>>
+! CHECK-DAG:     %[[ARRAY_SHAPE:.*]] = fir.shape {{.*}} -> !fir.shape<2>
+! CHECK-DAG:     %[[ARRAY:.*]]:2 = hlfir.declare %[[ADDR]](%[[ARRAY_SHAPE]])
+! CHECK-DAG:     %[[OUT_SHAPE:.*]] = fir.shape {{.*}} -> !fir.shape<1>
+! CHECK-DAG:     %[[OUT:.*]]:2 = hlfir.declare %[[ARG0]](%[[OUT_SHAPE]])
+! CHECK-DAG:     %[[TRUE:.*]] = arith.constant true
+! CHECK-DAG:     %[[C1:.*]] = arith.constant 1 : i32
+! CHECK-NEXT:    %[[EXPR:.*]] = hlfir.sum %[[ARRAY]]#0 dim %[[C1]] mask %[[TRUE]] {fastmath = #arith.fastmath<contract>} : (!fir.ref<!fir.array<2x2xi32>>, i32, i1) -> !hlfir.expr<2xi32>
+! CHECK-NEXT:    hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<2xi32>, !fir.ref<!fir.array<2xi32>>
+! CHECK-NEXT:    hlfir.destroy %[[EXPR]] : !hlfir.expr<2xi32>
+! CHECK-NEXT:    return
+! CHECK-nEXT:  }
+
+subroutine sum6(a, s, d)
+  integer, pointer :: d
+  real :: a(:,:), s(:)
+  s = sum(a, (d))
+end subroutine
+! CHECK-LABEL: func.func @_QPsum6(
+! CHECK:           %[[ARG0:.*]]: !fir.box<!fir.array<?x?xf32>>
+! CHECK:           %[[ARG1:.*]]: !fir.box<!fir.array<?xf32>>
+! CHECK:           %[[ARG2:.*]]: !fir.ref<!fir.box<!fir.ptr<i32>>>
+! CHECK-DAG:     %[[ARRAY:.*]]:2 = hlfir.declare %[[ARG0]]
+! CHECK-DAG:     %[[OUT:.*]]:2 = hlfir.declare %[[ARG1]]
+! CHECK-DAG:     %[[DIM_VAR:.*]]:2 = hlfir.declare %[[ARG2]]
+! CHECK-NEXT:     %[[DIM_BOX:.*]] = fir.load %[[DIM_VAR]]#0 : !fir.ref<!fir.box<!fir.ptr<i32>>>
+! CHECK-NEXT:    %[[DIM_ADDR:.*]] = fir.box_addr %[[DIM_BOX]] : (!fir.box<!fir.ptr<i32>>) -> !fir.ptr<i32>
+! CHECK-NEXT:    %[[DIM0:.*]] = fir.load %[[DIM_ADDR]] : !fir.ptr<i32>
+! CHECK-NEXT:    %[[DIM1:.*]] = hlfir.no_reassoc %[[DIM0]] : i32
+! CHECK-NEXT:    %[[EXPR:.*]] = hlfir.sum %[[ARRAY]]#0 dim %[[DIM1]] {fastmath = #arith.fastmath<contract>} : (!fir.box<!fir.array<?x?xf32>>, i32) -> !hlfir.expr<?xf32>
+! CHECK-NEXT:    hlfir.assign %[[EXPR]] to %[[OUT]]#0 : !hlfir.expr<?xf32>, !fir.box<!fir.array<?xf32>>
+! CHECK-NEXT:    hlfir.destroy %[[EXPR]]
+! CHECK-NEXT:    return
+! CHECK-NEXT:  }