[flang][hlfir] Apply NoReassocOp to ElementalOp result.

[vzakhari]

Summary

By the current lowering, the parentheses operation results
in generation of NoReassocOp inside the ElementalOp (i.e.
the result of NoReassocOp is the one yielded by the ElementalOp).
This does not make much sense, because there is no reordering
opportunity for YieldElementOp operand-result. HLFIR seems to be more
clear when NoReassocOp is applied to the result of ElementalOp.
Moreover, with this representation the elemental inlining
is not trying to do illegal inlining, e.g.:

module mod
contains
  elemental subroutine sub(a,b)
    integer ,intent(out) :: a
    integer,intent(in) :: b
    a = b
  end subroutine
end
  use mod
  integer array1(3,2),expected(3,2)
  data array1(:,1)/1,2,3/,array1(:,2)/-1,-2,-3/
  expected = array1(3:1:-1,2:1:-1)
  call sub(array1,(array1(3:1:-1,2:1:-1)))
  if (any(array1/=expected)) then
    print *, 'Fail'
  else
    print *, 'OK'
  end if
end

[jeanPerier]

Thank you for this solution Slava, after thinking more about this issue, I think we may want to address this problem in another way. Rational:

1. This does not fix all the issues with passing an elemental expressions to an impure function/subroutine: in call impure(a, b+1), I think we also need to fully evaluate b+1 before calling impure (impure could modify b).
2. This may pessimize perf with kernels that uses parentheses for numerical stability: e.g.: A = (B+C) + D with A,B,C,D numerical arrays. This patch would cause an array temporary to be created for B+C. But the parentheses are not here to guarantee that B+C is fully evaluated before the other addition here, they are here to guarantee the addition order at the element level (hence the reason why the no.reassoc is inside the elemental, after elemental inlining, if any, it will preserve the order of additions at the element level).

I think the fix is actually to force the "evaluation/bufferization" of array expression actual arguments of impure elemental procedures (and pure elemental subroutine with intent(out) arguments) when placing the call. Any hlfir.expr argument of such functions could be placed in memory at the array level (before the loops) with an hlfir.associate.

Regarding 1. the behaviors of Fortran compilers is not unanimous. Nvfortran and ifort are actually failing the parentheses use case you are fixing (xlf, nagfor and gfortran gets it right). Also, the same compiler may behave differently if the elemental procedure is a subroutine or a function.... So before you try what I am suggesting, I think we need to clarify some expectations with regard to elemental procedures that are impure, or pure elemental subroutine that may modify there arguments.

@klausler, I would welcome your input on two questions here:

• where does the standard rules if elemental arguments must be fully evaluated or not before the call?
• Below is an illustration of a program that behaves in at least 4 different ways according to the compiler that compiles it.... Who is right?

module test
contains
  impure elemental integer function func(a,b)
    integer ,intent(out) :: a
    integer,intent(in) :: b
    print *, "func"
    a = b
    func = b
  end function
  impure elemental subroutine sub(a,b)
    integer ,intent(out) :: a
    integer,intent(in) :: b
    print *, "sub"
    a = b
  end subroutine
  impure elemental integer function identity(a)
    integer,intent(in) :: a
    print *, "identity"
    identity = a
  end function
  subroutine nop(i)
    integer :: i(4)
  end subroutine
end module

  use test
  integer :: i(4) = [1,2,3,4]
  print *, "test elemental subroutine:"
  call sub(i, identity(i(4:1:-1)))
  print *, i

  i = [1,2,3,4]
  print *, "test elemental function:"
  call nop(func(i, identity(i(4:1:-1))))
  print *, i
end

XLF: Fully evaluates impure elemental function/subroutine arguments before the call.

test elemental subroutine:
identity
identity
identity
identity
sub
sub
sub
sub
4 3 2 1
test elemental function:
identity
identity
identity
identity
func
func
func
func
4 3 2 1

Gfortran: weird, computes the "4 3 2 1" result in the subroutine case while still interleaving the elemental calls (I guess it is saving the inner elemental call argument).

test elemental subroutine:
identity
sub
identity
sub
identity
sub
identity
sub
          4           3           2           1
test elemental function:
identity
func
identity
func
identity
func
identity
func
          4           3           3           4

Nvfortran, ifort, and flang currently: simply ignore impure/intent(out) aspects.

test elemental subroutine:
identity
sub
identity
sub
identity
sub
identity
sub
4 3 3 4
test elemental function:
identity
func
identity
func
identity
func
identity
func
4 3 3 4

nagfor: Fully evaluate the argument in the subroutine case, but not the function case.

test elemental subroutine:
identity
identity
identity
identity
sub
sub
sub
sub
4 3 2 1
test elemental function:
identity
func
identity
func
identity
func
identity
func
4 3 3 4

[tblah]

Good find! Thank you for fixing this. The changes LGTM. There's a test failure but it looks unrelated to this patch.

Edit: please address Jean's comment. This is much more complex than I thought!

[klausler]

"In a reference to an elemental subroutine, if the actual arguments corresponding to INTENT (OUT) and INTENT (INOUT) dummy arguments are arrays, the values of the elements, if any, of the results are the same as would be obtained if the subroutine had been applied separately, in array element order, to corresponding elements of each array actual argument." (F'202X 15.9.3)

"When it is invoked, all actual argument expressions are evaluated, then the arguments are associated, and then the function is executed. When execution of the function is complete, the value of the function result is available for use in the expression that caused the function to be invoked." (15.5.3)

"When a subroutine is invoked, all actual argument expressions are evaluated, then the arguments are associated, and then the subroutine is executed." (15.5.4)

So: when an *impure* elemental is involved, I think that we're required to fully evaluate actual arguments before making any per-element call. And in the case of an impure elemental subroutine, the order of calls must follow the array element ordering of the INTENT(OUT or IN OUT) dummy array argument(s). For pure elementals, I think that we have more freedom to avoid temporaries and follow any convenient ordering, since a conforming program shouldn't be able to tell from side effects.

[jeanPerier]

Thanks a lot for the answer @klausler!

@vzakhari, that confirms that the fix should be to force the evaluation of all impure elemental procedure arguments that are expressions (not only the parenthesized ones).
You can maybe loop over the "preparedActual" before creating the loops/hlfir.elemental after "mustBeOrdered" was set if the procedure is impure/their are intent(out) arguments, and place array hlfir.expr arguments in memory with hlfir.associate, and clean-that up with hlfir.end_associate after the call loop/hlfir.elemental.

[vzakhari]

Thanks a lot for the thorough explanation, Jean! I am testing the changes that you proposed currently. I verified that your test with my local Flang shows the same behavior as with XLF compiler.

I will abandon this patch and create a new one, once my testing is clean.

flang/lib/Lower/ConvertExprToHLFIR.cpp

if constexpr (R::category == Fortran::common::TypeCategory::Derived) {
       elementType = Fortran::lower::translateDerivedTypeToFIRType(
           getConverter(), op.derived().GetType().GetDerivedTypeSpec());
     } else {
       elementType =
           Fortran::lower::getFIRType(builder.getContext(), R::category, R::kind,
                                      /*params=*/std::nullopt);
     }
     mlir::Value shape = hlfir::genShape(loc, builder, left);
+    // In case of Parentheses operation we have to apply it
+    // to the result of the ElementalOp so that further transformations
+    // (such as elemental inlining) work properly.
+    constexpr bool isParentheses =
+        std::is_same_v<D, Fortran::evaluate::Parentheses<R>>;
     auto genKernel = [&op, &left, &unaryOp](
                          mlir::Location l, fir::FirOpBuilder &b,
                          mlir::ValueRange oneBasedIndices) -> hlfir::Entity {
       auto leftElement = hlfir::getElementAt(l, b, left, oneBasedIndices);
       auto leftVal = hlfir::loadTrivialScalar(l, b, leftElement);
+      if constexpr (isParentheses)
+        return leftVal;
       return unaryOp.gen(l, b, op.derived(), leftVal);
     };
     mlir::Value elemental = hlfir::genElementalOp(loc, builder, elementType,
                                                   shape, typeParams, genKernel,
                                                   /*isUnordered=*/true);
+    if constexpr (isParentheses)
+      elemental =
+          unaryOp.gen(loc, builder, op.derived(), hlfir::Entity{elemental});
     fir::FirOpBuilder *bldr = &builder;
     getStmtCtx().attachCleanup(
         [=]() { bldr->create<hlfir::DestroyOp>(loc, elemental); });
     return hlfir::EntityWithAttributes{elemental};
   }
 
   template <typename D, typename R, typename LO, typename RO>
   hlfir::EntityWithAttributes

flang/test/Lower/HLFIR/array-ctor-index.f90

 ! CHECK:             %[[VAL_19:.*]] = fir.load %[[VAL_1]]#0 : !fir.ref<i8>
 ! CHECK:             %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (i8) -> i64
 ! CHECK:             %[[VAL_21:.*]] = arith.muli %[[VAL_18]], %[[VAL_20]] : i64
 ! CHECK:             hlfir.yield_element %[[VAL_21]] : i64
 ! CHECK:           }
 ! CHECK:           %[[VAL_22:.*]] = hlfir.elemental %[[VAL_7]] unordered : (!fir.shape<1>) -> !hlfir.expr<4xi64> {
 ! CHECK:           ^bb0(%[[VAL_23:.*]]: index):
 ! CHECK:             %[[VAL_24:.*]] = hlfir.apply %[[VAL_25:.*]], %[[VAL_23]] : (!hlfir.expr<4xi64>, index) -> i64
-! CHECK:             %[[VAL_26:.*]] = hlfir.no_reassoc %[[VAL_24]] : i64
-! CHECK:             hlfir.yield_element %[[VAL_26]] : i64
+! CHECK:             hlfir.yield_element %[[VAL_24]] : i64
 ! CHECK:           }
+! CHECK:           %[[VAL_26:.*]] = hlfir.no_reassoc %[[VAL_22]] : !hlfir.expr<4xi64>
 ! CHECK:           %[[VAL_27:.*]] = hlfir.elemental %[[VAL_7]] unordered : (!fir.shape<1>) -> !hlfir.expr<4xi8> {
 ! CHECK:           ^bb0(%[[VAL_28:.*]]: index):
-! CHECK:             %[[VAL_29:.*]] = hlfir.apply %[[VAL_30:.*]], %[[VAL_28]] : (!hlfir.expr<4xi64>, index) -> i64
+! CHECK:             %[[VAL_29:.*]] = hlfir.apply %[[VAL_26]], %[[VAL_28]] : (!hlfir.expr<4xi64>, index) -> i64
 ! CHECK:             %[[VAL_31:.*]] = fir.convert %[[VAL_29]] : (i64) -> i8
 ! CHECK:             hlfir.yield_element %[[VAL_31]] : i8
 ! CHECK:           }
-! CHECK:           hlfir.assign %[[VAL_32:.*]] to %[[VAL_5]]#0 : !hlfir.expr<4xi8>, !fir.ref<!fir.array<4xi8>>
-! CHECK:           hlfir.destroy %[[VAL_32]] : !hlfir.expr<4xi8>
-! CHECK:           hlfir.destroy %[[VAL_33:.*]] : !hlfir.expr<4xi64>
-! CHECK:           hlfir.destroy %[[VAL_34:.*]] : !hlfir.expr<4xi64>
+! CHECK:           hlfir.assign %[[VAL_27]] to %[[VAL_5]]#0 : !hlfir.expr<4xi8>, !fir.ref<!fir.array<4xi8>>
+! CHECK:           hlfir.destroy %[[VAL_27]] : !hlfir.expr<4xi8>
+! CHECK:           hlfir.destroy %[[VAL_26]] : !hlfir.expr<4xi64>
+! CHECK:           hlfir.destroy %[[VAL_13]] : !hlfir.expr<4xi64>
 ! CHECK:           %[[VAL_35:.*]] = fir.load %[[VAL_5]]#1 : !fir.ref<!fir.array<4xi8>>
 ! CHECK:           return %[[VAL_35]] : !fir.array<4xi8>
 ! CHECK:         }
 
 function test2(k)
   integer*2 :: k
   integer*2 :: test2(4)
   test2 = ([(i*k, integer(8)::i=1,4)])

 ! CHECK:             %[[VAL_19:.*]] = fir.load %[[VAL_1]]#0 : !fir.ref<i16>
 ! CHECK:             %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (i16) -> i64
 ! CHECK:             %[[VAL_21:.*]] = arith.muli %[[VAL_18]], %[[VAL_20]] : i64
 ! CHECK:             hlfir.yield_element %[[VAL_21]] : i64
 ! CHECK:           }
 ! CHECK:           %[[VAL_22:.*]] = hlfir.elemental %[[VAL_7]] unordered : (!fir.shape<1>) -> !hlfir.expr<4xi64> {
 ! CHECK:           ^bb0(%[[VAL_23:.*]]: index):
 ! CHECK:             %[[VAL_24:.*]] = hlfir.apply %[[VAL_25:.*]], %[[VAL_23]] : (!hlfir.expr<4xi64>, index) -> i64
-! CHECK:             %[[VAL_26:.*]] = hlfir.no_reassoc %[[VAL_24]] : i64
-! CHECK:             hlfir.yield_element %[[VAL_26]] : i64
+! CHECK:             hlfir.yield_element %[[VAL_24]] : i64
 ! CHECK:           }
+! CHECK:           %[[VAL_26:.*]] = hlfir.no_reassoc %[[VAL_22]] : !hlfir.expr<4xi64>
 ! CHECK:           %[[VAL_27:.*]] = hlfir.elemental %[[VAL_7]] unordered : (!fir.shape<1>) -> !hlfir.expr<4xi16> {
 ! CHECK:           ^bb0(%[[VAL_28:.*]]: index):
-! CHECK:             %[[VAL_29:.*]] = hlfir.apply %[[VAL_30:.*]], %[[VAL_28]] : (!hlfir.expr<4xi64>, index) -> i64
+! CHECK:             %[[VAL_29:.*]] = hlfir.apply %[[VAL_26]], %[[VAL_28]] : (!hlfir.expr<4xi64>, index) -> i64
 ! CHECK:             %[[VAL_31:.*]] = fir.convert %[[VAL_29]] : (i64) -> i16
 ! CHECK:             hlfir.yield_element %[[VAL_31]] : i16
 ! CHECK:           }
-! CHECK:           hlfir.assign %[[VAL_32:.*]] to %[[VAL_5]]#0 : !hlfir.expr<4xi16>, !fir.ref<!fir.array<4xi16>>
-! CHECK:           hlfir.destroy %[[VAL_32]] : !hlfir.expr<4xi16>
-! CHECK:           hlfir.destroy %[[VAL_33:.*]] : !hlfir.expr<4xi64>
-! CHECK:           hlfir.destroy %[[VAL_34:.*]] : !hlfir.expr<4xi64>
+! CHECK:           hlfir.assign %[[VAL_27]] to %[[VAL_5]]#0 : !hlfir.expr<4xi16>, !fir.ref<!fir.array<4xi16>>
+! CHECK:           hlfir.destroy %[[VAL_27]] : !hlfir.expr<4xi16>
+! CHECK:           hlfir.destroy %[[VAL_26]] : !hlfir.expr<4xi64>
+! CHECK:           hlfir.destroy %[[VAL_13]] : !hlfir.expr<4xi64>
 ! CHECK:           %[[VAL_35:.*]] = fir.load %[[VAL_5]]#1 : !fir.ref<!fir.array<4xi16>>
 ! CHECK:           return %[[VAL_35]] : !fir.array<4xi16>
 ! CHECK:         }
 
 function test3(k)
   integer*4 :: k
   integer*4 :: test3(4)
   test3 = ([(i*k, integer(8)::i=1,4)])

 ! CHECK:             %[[VAL_19:.*]] = fir.load %[[VAL_1]]#0 : !fir.ref<i32>
 ! CHECK:             %[[VAL_20:.*]] = fir.convert %[[VAL_19]] : (i32) -> i64
 ! CHECK:             %[[VAL_21:.*]] = arith.muli %[[VAL_18]], %[[VAL_20]] : i64
 ! CHECK:             hlfir.yield_element %[[VAL_21]] : i64
 ! CHECK:           }
 ! CHECK:           %[[VAL_22:.*]] = hlfir.elemental %[[VAL_7]] unordered : (!fir.shape<1>) -> !hlfir.expr<4xi64> {
 ! CHECK:           ^bb0(%[[VAL_23:.*]]: index):
 ! CHECK:             %[[VAL_24:.*]] = hlfir.apply %[[VAL_25:.*]], %[[VAL_23]] : (!hlfir.expr<4xi64>, index) -> i64
-! CHECK:             %[[VAL_26:.*]] = hlfir.no_reassoc %[[VAL_24]] : i64
-! CHECK:             hlfir.yield_element %[[VAL_26]] : i64
+! CHECK:             hlfir.yield_element %[[VAL_24]] : i64
 ! CHECK:           }
+! CHECK:           %[[VAL_26:.*]] = hlfir.no_reassoc %[[VAL_22]] : !hlfir.expr<4xi64>
 ! CHECK:           %[[VAL_27:.*]] = hlfir.elemental %[[VAL_7]] unordered : (!fir.shape<1>) -> !hlfir.expr<4xi32> {
 ! CHECK:           ^bb0(%[[VAL_28:.*]]: index):
-! CHECK:             %[[VAL_29:.*]] = hlfir.apply %[[VAL_30:.*]], %[[VAL_28]] : (!hlfir.expr<4xi64>, index) -> i64
+! CHECK:             %[[VAL_29:.*]] = hlfir.apply %[[VAL_26]], %[[VAL_28]] : (!hlfir.expr<4xi64>, index) -> i64
 ! CHECK:             %[[VAL_31:.*]] = fir.convert %[[VAL_29]] : (i64) -> i32
 ! CHECK:             hlfir.yield_element %[[VAL_31]] : i32
 ! CHECK:           }
-! CHECK:           hlfir.assign %[[VAL_32:.*]] to %[[VAL_5]]#0 : !hlfir.expr<4xi32>, !fir.ref<!fir.array<4xi32>>
-! CHECK:           hlfir.destroy %[[VAL_32]] : !hlfir.expr<4xi32>
-! CHECK:           hlfir.destroy %[[VAL_33:.*]] : !hlfir.expr<4xi64>
-! CHECK:           hlfir.destroy %[[VAL_34:.*]] : !hlfir.expr<4xi64>
+! CHECK:           hlfir.assign %[[VAL_27]] to %[[VAL_5]]#0 : !hlfir.expr<4xi32>, !fir.ref<!fir.array<4xi32>>
+! CHECK:           hlfir.destroy %[[VAL_27]] : !hlfir.expr<4xi32>
+! CHECK:           hlfir.destroy %[[VAL_26]] : !hlfir.expr<4xi64>
+! CHECK:           hlfir.destroy %[[VAL_13]] : !hlfir.expr<4xi64>
 ! CHECK:           %[[VAL_35:.*]] = fir.load %[[VAL_5]]#1 : !fir.ref<!fir.array<4xi32>>
 ! CHECK:           return %[[VAL_35]] : !fir.array<4xi32>
 ! CHECK:         }
 
 function test4(k)
   integer*8 :: k
   integer*8 :: test4(4)
   test4 = ([(i*k, integer(8)::i=1,4)])

 ! CHECK:             %[[VAL_18:.*]] = fir.convert %[[VAL_17]] : (index) -> i64
 ! CHECK:             %[[VAL_19:.*]] = fir.load %[[VAL_1]]#0 : !fir.ref<i64>
 ! CHECK:             %[[VAL_20:.*]] = arith.muli %[[VAL_18]], %[[VAL_19]] : i64
 ! CHECK:             hlfir.yield_element %[[VAL_20]] : i64
 ! CHECK:           }
 ! CHECK:           %[[VAL_21:.*]] = hlfir.elemental %[[VAL_7]] unordered : (!fir.shape<1>) -> !hlfir.expr<4xi64> {
 ! CHECK:           ^bb0(%[[VAL_22:.*]]: index):
 ! CHECK:             %[[VAL_23:.*]] = hlfir.apply %[[VAL_24:.*]], %[[VAL_22]] : (!hlfir.expr<4xi64>, index) -> i64
-! CHECK:             %[[VAL_25:.*]] = hlfir.no_reassoc %[[VAL_23]] : i64
-! CHECK:             hlfir.yield_element %[[VAL_25]] : i64
+! CHECK:             hlfir.yield_element %[[VAL_23]] : i64
 ! CHECK:           }
-! CHECK:           hlfir.assign %[[VAL_26:.*]] to %[[VAL_5]]#0 : !hlfir.expr<4xi64>, !fir.ref<!fir.array<4xi64>>
-! CHECK:           hlfir.destroy %[[VAL_26]] : !hlfir.expr<4xi64>
-! CHECK:           hlfir.destroy %[[VAL_27:.*]] : !hlfir.expr<4xi64>
+! CHECK:           %[[VAL_25:.*]] = hlfir.no_reassoc %[[VAL_21]] : !hlfir.expr<4xi64>
+! CHECK:           hlfir.assign %[[VAL_25]] to %[[VAL_5]]#0 : !hlfir.expr<4xi64>, !fir.ref<!fir.array<4xi64>>
+! CHECK:           hlfir.destroy %[[VAL_25]] : !hlfir.expr<4xi64>
+! CHECK:           hlfir.destroy %[[VAL_13]] : !hlfir.expr<4xi64>
 ! CHECK:           %[[VAL_28:.*]] = fir.load %[[VAL_5]]#1 : !fir.ref<!fir.array<4xi64>>
 ! CHECK:           return %[[VAL_28]] : !fir.array<4xi64>
 ! CHECK:         }

flang/test/Lower/HLFIR/elemental-array-ops.f90

subroutine char_unary(x)
   character(10) :: x(20)
   call test_char_2((x))
 end subroutine
 ! CHECK-LABEL: func.func @_QPchar_unary(
 ! CHECK:  %[[VAL_6:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_5:.*]]) typeparams %[[VAL_2:[^ ]*]] {{.*}}x
 ! CHECK:  %[[VAL_7:.*]] = hlfir.elemental %[[VAL_5]] typeparams %[[VAL_2]] unordered : (!fir.shape<1>, index) -> !hlfir.expr<20x!fir.char<1,?>> {
 ! CHECK:  ^bb0(%[[VAL_8:.*]]: index):
 ! CHECK:    %[[VAL_9:.*]] = hlfir.designate %[[VAL_6]]#0 (%[[VAL_8]])  typeparams %[[VAL_2]] : (!fir.ref<!fir.array<20x!fir.char<1,10>>>, index, index) -> !fir.ref<!fir.char<1,10>>
-! CHECK:    %[[VAL_10:.*]] = hlfir.as_expr %[[VAL_9]] : (!fir.ref<!fir.char<1,10>>) -> !hlfir.expr<!fir.char<1,10>>
-! CHECK:    hlfir.yield_element %[[VAL_10]] : !hlfir.expr<!fir.char<1,10>>
+! CHECK:    hlfir.yield_element %[[VAL_9]] : !fir.ref<!fir.char<1,10>>
 ! CHECK:  }
+! CHECK: %[[VAL_10:.*]] = hlfir.no_reassoc %[[VAL_7]] : !hlfir.expr<20x!fir.char<1,?>>
 ! CHECK: fir.call
-! CHECK: hlfir.destroy %[[VAL_7]]
+! CHECK: hlfir.destroy %[[VAL_10]]
 
 subroutine chained_elemental(x, y, z)
   integer :: x(100), y(100), z(100)
   x = x+y+z
 end subroutine
 ! CHECK-LABEL: func.func @_QPchained_elemental(
 ! CHECK:  %[[VAL_5:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_4:[^)]*]]) {{.*}}x
 ! CHECK:  %[[VAL_8:.*]]:2 = hlfir.declare %{{.*}}(%[[VAL_7:[^)]*]]) {{.*}}y

 ! CHECK:  %[[VAL_5:.*]] = fir.shape %[[VAL_2]] : (index) -> !fir.shape<1>
 ! CHECK:  %[[VAL_6:.*]] = hlfir.elemental %[[VAL_5]] unordered : (!fir.shape<1>) -> !hlfir.expr<100xi32> {
 ! CHECK:  ^bb0(%[[VAL_7:.*]]: index):
 ! CHECK:    %[[VAL_8:.*]] = arith.constant 1 : index
 ! CHECK:    %[[VAL_9:.*]] = arith.subi %[[VAL_1]], %[[VAL_8]] : index
 ! CHECK:    %[[VAL_10:.*]] = arith.addi %[[VAL_7]], %[[VAL_9]] : index
 ! CHECK:    %[[VAL_11:.*]] = hlfir.designate %[[VAL_4]]#0 (%[[VAL_10]])  : (!fir.box<!fir.array<100xi32>>, index) -> !fir.ref<i32>
 ! CHECK:    %[[VAL_12:.*]] = fir.load %[[VAL_11]] : !fir.ref<i32>
-! CHECK:    %[[VAL_13:.*]] = hlfir.no_reassoc %[[VAL_12]] : i32
-! CHECK:    hlfir.yield_element %[[VAL_13]] : i32
+! CHECK:    hlfir.yield_element %[[VAL_12]] : i32
 ! CHECK:  }
+! CHECK:  %[[VAL_13:.*]] = hlfir.no_reassoc %[[VAL_6]] : !hlfir.expr<100xi32>
 ! CHECK: fir.call
-! CHECK: hlfir.destroy %[[VAL_6]]
+! CHECK: hlfir.destroy %[[VAL_13]]