[flang] End IO statement before finalization to avoid recursive IO

[clementval]

Summary

Derived type finalization can be tied to the statement context in the
case of executable construct that references a non-pointer function.
Since the final subroutine can potentially do so IO, make sure the
current IO is ended before emitting finalization of the statement
context.

There might be other IO runtime that need the same update but it will be done
with proper examples.

[jeanPerier]

flang/lib/Lower/IO.cpp

502

Unfortunately it is not possible to move this StatementContext before. It is here because IO with error recovery (IOSTAT, ERRMSG...) will create conditional IO inside fir.if (see the makeNextConditionalOn just above).

For instance:

subroutine conditional_io(stat)
  integer :: stat
  real :: a(100), b(100)
  write (6, *, iostat=stat) 42, a+b
end subroutine

Should now fail with: "operand #0 does not dominate this use" (we really should have had this one has a regression test, sorry about that).

The previous IR for this code looked like:

%5 = fir.call @_FortranAioEnableHandlers(%4, %true, %false, %false_1, %false_2, %false_3) fastmath<contract> : (!fir.ref<i8>, i1, i1, i1, i1, i1) -> none
%c42_i32 = arith.constant 42 : i32
// outputing 42, may fail for whatever reasons.
%6 = fir.call @_FortranAioOutputInteger32(%4, %c42_i32) fastmath<contract> : (!fir.ref<i8>, i32) -> i1
// Because of the IOSTAT requirements, the IO statement evaluation is stopped at the first error, so "A+B" io-item evaluation and IO is conditional.
fir.if %6 {
  // ...
  %12 = fir.allocmem !fir.array<100xf32>
  // computing A+B inside %12.
  %18 = fir.embox %12(%17) : (!fir.heap<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.box<!fir.array<100xf32>>
  %19 = fir.convert %18 : (!fir.box<!fir.array<100xf32>>) -> !fir.box<none>
  %20 = fir.call @_FortranAioOutputDescriptor(%4, %19) fastmath<contract> : (!fir.ref<i8>, !fir.box<none>) -> i1
  // The statement context clean-up happens here
  fir.freemem %12 : !fir.heap<!fir.array<100xf32>>
}
%7 = fir.call @_FortranAioEndIoStatement(%4) fastmath<contract> : (!fir.ref<i8>) -> i32
// you patch is moving it here, where %12 is not accessible. 
fir.store %7 to %arg0 : !fir.ref<i32>

Things can even get funnier if one use IO implied do:

subroutine conditional_io(stat)
  integer :: stat
  real :: a(100)
  write (6, *, iostat=stat) (a(i*2-1:i*2)+42, i=1,50)
end subroutine

In this case, the allocation/deallocation happens inside an if/then/else that is inside a fir.iterate_while before FortranAioEndIoStatement.

I do not have a brilliant idea to solve this. It seems we would want to propagate the temps through the iter_while (that by the way, can be a fir.do_loop is there is no IO error recoivery) and the if/then/else.

But if you have loops with temps created at each iteration, then piling the finalization/deallocation is far from ideal (you will need an array to store the descriptors...).

Maybe there can be a clever solution in the IO runtime that would somehow allow the finalizer to call IO.

[clementval]

flang/lib/Lower/IO.cpp

502

I thought there was a reason to do the statement context finalization after the end call. Thanks for explanation. I'll look at another solution.

flang/lib/Lower/IO.cpp

if (fir::factory::CharacterExprHelper::isCharacterScalar(type)) {
     if (kindMap.getCharacterBitsize(asciiKind) == 8 &&
         fir::factory::CharacterExprHelper::getCharacterKind(type) == asciiKind)
       return getIORuntimeFunc<mkIOKey(OutputAscii)>(loc, builder);
   }
   return getIORuntimeFunc<mkIOKey(OutputDescriptor)>(loc, builder);
 }
 
 /// Generate a sequence of output data transfer calls.
-static void genOutputItemList(
-    Fortran::lower::AbstractConverter &converter, mlir::Value cookie,
-    const std::list<Fortran::parser::OutputItem> &items, bool isFormatted,
-    bool checkResult, mlir::Value &ok, bool inLoop) {
+static void
+genOutputItemList(Fortran::lower::AbstractConverter &converter,
+                  mlir::Value cookie,
+                  const std::list<Fortran::parser::OutputItem> &items,
+                  bool isFormatted, bool checkResult, mlir::Value &ok,
+                  bool inLoop, Fortran::lower::StatementContext &stmtCtx) {
   fir::FirOpBuilder &builder = converter.getFirOpBuilder();
   for (const Fortran::parser::OutputItem &item : items) {
     if (const auto &impliedDo = std::get_if<1>(&item.u)) {
       genIoLoop(converter, cookie, impliedDo->value(), isFormatted, checkResult,
                 ok, inLoop);
       continue;
     }
     auto &pExpr = std::get<Fortran::parser::Expr>(item.u);
     mlir::Location loc = converter.genLocation(pExpr.source);
     makeNextConditionalOn(builder, loc, checkResult, ok, inLoop);
-    Fortran::lower::StatementContext stmtCtx;
 
     const auto *expr = Fortran::semantics::GetExpr(pExpr);
     if (!expr)
       fir::emitFatalError(loc, "internal error: could not get evaluate::Expr");
     mlir::Type itemTy = converter.genType(*expr);
     mlir::func::FuncOp outputFunc =
         getOutputFunc(loc, builder, itemTy, isFormatted);
     mlir::Type argType = outputFunc.getFunctionType().getInput(1);
mlir::Value stepValue =
           ? genControlValue(*control.step)
           : builder.create<mlir::arith::ConstantIndexOp>(loc, 1);
   auto genItemList = [&](const D &ioImpliedDo) {
     if constexpr (std::is_same_v<D, Fortran::parser::InputImpliedDo>)
       genInputItemList(converter, cookie, itemList, isFormatted, checkResult,
                        ok, /*inLoop=*/true);
     else
       genOutputItemList(converter, cookie, itemList, isFormatted, checkResult,
-                        ok, /*inLoop=*/true);
+                        ok, /*inLoop=*/true, stmtCtx);
   };
   if (!checkResult) {
     // No IO call result checks - the loop is a fir.do_loop op.
     auto doLoopOp = builder.create<fir::DoLoopOp>(
         loc, lowerValue, upperValue, stepValue, /*unordered=*/false,
         /*finalCountValue=*/true);
     builder.setInsertionPointToStart(doLoopOp.getBody());
     mlir::Value lcv = builder.createConvert(
if constexpr (isInput) { // READ
     if (isNml)
       genNamelistIO(converter, cookie,
                     getIORuntimeFunc<mkIOKey(OutputNamelist)>(loc, builder),
                     *getIOControl<Fortran::parser::Name>(stmt)->symbol,
                     csi.hasTransferConditionSpec(), ok, stmtCtx);
     else
       genOutputItemList(converter, cookie, stmt.items, isFormatted,
                         csi.hasTransferConditionSpec(), ok,
-                        /*inLoop=*/false);
+                        /*inLoop=*/false, stmtCtx);
   } else { // PRINT
     genOutputItemList(converter, cookie, std::get<1>(stmt.t), isFormatted,
                       csi.hasTransferConditionSpec(), ok,
-                      /*inLoop=*/false);
+                      /*inLoop=*/false, stmtCtx);
   }
 
   builder.restoreInsertionPoint(insertPt);
   if constexpr (hasIOCtrl) {
     genIOReadSize(converter, loc, cookie, stmt.controls,
                   csi.hasErrorConditionSpec());
   }
   // Generate end statement call/s.
if (inquireFileUnit()) {
     beginArgs = {locToFilename(converter, loc, beginFuncTy.getInput(0)),
                  locToLineNo(converter, loc, beginFuncTy.getInput(1))};
     auto cookie =
         builder.create<fir::CallOp>(loc, beginFunc, beginArgs).getResult(0);
     mlir::Value ok;
     genOutputItemList(
         converter, cookie,
         std::get<std::list<Fortran::parser::OutputItem>>(ioLength->t),
-        /*isFormatted=*/false, /*checkResult=*/false, ok, /*inLoop=*/false);
+        /*isFormatted=*/false, /*checkResult=*/false, ok, /*inLoop=*/false,
+        stmtCtx);
     auto *ioLengthVar = Fortran::semantics::GetExpr(
         std::get<Fortran::parser::ScalarIntVariable>(ioLength->t));
     mlir::Value ioLengthVarAddr =
         fir::getBase(converter.genExprAddr(loc, ioLengthVar, stmtCtx));
     llvm::SmallVector<mlir::Value> args = {cookie};
     mlir::Value length =
         builder
             .create<fir::CallOp>(

flang/test/Lower/array-character.f90

subroutine charlit
   ! CHECK: %[[VAL_22:.*]] = fir.convert %[[VAL_18]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
   ! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_21]], %[[VAL_22]], %[[VAL_20]], %[[VAL_4]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
   ! CHECK: %[[VAL_23:.*]] = arith.subi %[[VAL_15]], %[[VAL_7]] : index
   ! CHECK: cf.br ^bb1(%[[VAL_17]], %[[VAL_23]] : index, index)
   ! CHECK: ^bb3:
   ! CHECK: %[[VAL_24:.*]] = fir.embox %[[VAL_13]](%[[VAL_12]]) : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>) -> !fir.box<!fir.array<4x!fir.char<1,3>>>
   ! CHECK: %[[VAL_25:.*]] = fir.convert %[[VAL_24]] : (!fir.box<!fir.array<4x!fir.char<1,3>>>) -> !fir.box<none>
   ! CHECK: %[[VAL_26:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_10]], %[[VAL_25]]) {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
-  ! CHECK: fir.freemem %[[VAL_13]]
   ! CHECK: %[[VAL_27:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_10]]) {{.*}}: (!fir.ref<i8>) -> i32
+  ! CHECK: fir.freemem %[[VAL_13]]
   ! CHECK: %[[VAL_28:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_0]], %[[VAL_9]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
   ! CHECK: %[[VAL_29:.*]] = fir.allocmem !fir.array<4x!fir.char<1,3>>
   ! CHECK: br ^bb4(%[[VAL_6]], %[[VAL_5]] : index, index)
   ! CHECK: ^bb4(%[[VAL_30:.*]]: index, %[[VAL_31:.*]]: index):
   ! CHECK: %[[VAL_32:.*]] = arith.cmpi sgt, %[[VAL_31]], %[[VAL_6]] : index
   ! CHECK: cond_br %[[VAL_32]], ^bb5, ^bb6
   ! CHECK: ^bb5:
   ! CHECK: %[[VAL_33:.*]] = arith.addi %[[VAL_30]], %[[VAL_7]] : index
   ! CHECK: %[[VAL_34:.*]] = fir.array_coor %[[VAL_11]](%[[VAL_12]]) %[[VAL_33]] : (!fir.ref<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
   ! CHECK: %[[VAL_35:.*]] = fir.array_coor %[[VAL_29]](%[[VAL_12]]) %[[VAL_33]] : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
   ! CHECK: %[[VAL_36:.*]] = fir.convert %[[VAL_3]] : (index) -> i64
   ! CHECK: %[[VAL_37:.*]] = fir.convert %[[VAL_35]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
   ! CHECK: %[[VAL_38:.*]] = fir.convert %[[VAL_34]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
   ! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_37]], %[[VAL_38]], %[[VAL_36]], %[[VAL_4]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
   ! CHECK: %[[VAL_39:.*]] = arith.subi %[[VAL_31]], %[[VAL_7]] : index
   ! CHECK: br ^bb4(%[[VAL_33]], %[[VAL_39]] : index, index)
   ! CHECK: ^bb6:
   ! CHECK: %[[VAL_40:.*]] = fir.embox %[[VAL_29]](%[[VAL_12]]) : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>) -> !fir.box<!fir.array<4x!fir.char<1,3>>>
   ! CHECK: %[[VAL_41:.*]] = fir.convert %[[VAL_40]] : (!fir.box<!fir.array<4x!fir.char<1,3>>>) -> !fir.box<none>
   ! CHECK: %[[VAL_42:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_28]], %[[VAL_41]]) {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
-  ! CHECK: fir.freemem %[[VAL_29]] : !fir.heap<!fir.array<4x!fir.char<1,3>>>
   ! CHECK: %[[VAL_43:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_28]]) {{.*}}: (!fir.ref<i8>) -> i32
+  ! CHECK: fir.freemem %[[VAL_29]] : !fir.heap<!fir.array<4x!fir.char<1,3>>>
   ! CHECK: %[[VAL_44:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_0]], %[[VAL_9]], %{{.*}}) {{.*}}: (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
   ! CHECK: %[[VAL_45:.*]] = fir.allocmem !fir.array<4x!fir.char<1,3>>
   ! CHECK: br ^bb7(%[[VAL_6]], %[[VAL_5]] : index, index)
   ! CHECK: ^bb7(%[[VAL_46:.*]]: index, %[[VAL_47:.*]]: index):
   ! CHECK: %[[VAL_48:.*]] = arith.cmpi sgt, %[[VAL_47]], %[[VAL_6]] : index
   ! CHECK: cond_br %[[VAL_48]], ^bb8, ^bb9
   ! CHECK: ^bb8:
   ! CHECK: %[[VAL_49:.*]] = arith.addi %[[VAL_46]], %[[VAL_7]] : index
   ! CHECK: %[[VAL_50:.*]] = fir.array_coor %[[VAL_11]](%[[VAL_12]]) %[[VAL_49]] : (!fir.ref<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
   ! CHECK: %[[VAL_51:.*]] = fir.array_coor %[[VAL_45]](%[[VAL_12]]) %[[VAL_49]] : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>, index) -> !fir.ref<!fir.char<1,3>>
   ! CHECK: %[[VAL_52:.*]] = fir.convert %[[VAL_3]] : (index) -> i64
   ! CHECK: %[[VAL_53:.*]] = fir.convert %[[VAL_51]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
   ! CHECK: %[[VAL_54:.*]] = fir.convert %[[VAL_50]] : (!fir.ref<!fir.char<1,3>>) -> !fir.ref<i8>
   ! CHECK: fir.call @llvm.memmove.p0.p0.i64(%[[VAL_53]], %[[VAL_54]], %[[VAL_52]], %[[VAL_4]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64, i1) -> ()
   ! CHECK: %[[VAL_55:.*]] = arith.subi %[[VAL_47]], %[[VAL_7]] : index
   ! CHECK: br ^bb7(%[[VAL_49]], %[[VAL_55]] : index, index)
   ! CHECK: ^bb9:
   ! CHECK: %[[VAL_56:.*]] = fir.embox %[[VAL_45]](%[[VAL_12]]) : (!fir.heap<!fir.array<4x!fir.char<1,3>>>, !fir.shape<1>) -> !fir.box<!fir.array<4x!fir.char<1,3>>>
   ! CHECK: %[[VAL_57:.*]] = fir.convert %[[VAL_56]] : (!fir.box<!fir.array<4x!fir.char<1,3>>>) -> !fir.box<none>
   ! CHECK: %[[VAL_58:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_44]], %[[VAL_57]]) {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
-  ! CHECK: fir.freemem %[[VAL_45]] : !fir.heap<!fir.array<4x!fir.char<1,3>>>
   ! CHECK: %[[VAL_59:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_44]]) {{.*}}: (!fir.ref<i8>) -> i32
+  ! CHECK: fir.freemem %[[VAL_45]] : !fir.heap<!fir.array<4x!fir.char<1,3>>>
   print*, ['AA ', 'MM ', 'MM ', 'ZZ ']
   print*, ['AA ', 'MM ', 'MM ', 'ZZ ']
   print*, ['AA ', 'MM ', 'MM ', 'ZZ ']
   ! CHECK:         return
   ! CHECK:       }
 end
 
 ! CHECK: fir.global internal @_QQro.4x3xc1.1636b396a657de68ffb870a885ac44b4 constant : !fir.array<4x!fir.char<1,3>>
 ! CHECK: AA
 ! CHECK: MM
 ! CHECK: ZZ
 ! CHECK-NOT: fir.global internal @_QQro.4x3xc1
 ! CHECK-NOT: AA
 ! CHECK-NOT: MM
 ! CHECK-NOT: ZZ

flang/test/Lower/array-expression.f90

 ! CHECK:           %[[VAL_39:.*]] = fir.array_update %[[VAL_26]], %[[VAL_38]], %[[VAL_25]] : (!fir.array<10xi32>, i32, index) -> !fir.array<10xi32>
 ! CHECK:           fir.result %[[VAL_39]] : !fir.array<10xi32>
 ! CHECK:         }
 ! CHECK:         fir.array_merge_store %[[VAL_20]], %[[VAL_40:.*]] to %[[VAL_18]] : !fir.array<10xi32>, !fir.array<10xi32>, !fir.heap<!fir.array<10xi32>>
 ! CHECK:         %[[VAL_41:.*]] = fir.shape %[[VAL_15]] : (index) -> !fir.shape<1>
 ! CHECK:         %[[VAL_42:.*]] = fir.embox %[[VAL_18]](%[[VAL_41]]) : (!fir.heap<!fir.array<10xi32>>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>>
 ! CHECK:         %[[VAL_43:.*]] = fir.convert %[[VAL_42]] : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>
 ! CHECK:         %[[VAL_44:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_13]], %[[VAL_43]]) {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
-! CHECK:         fir.freemem %[[VAL_18]] : !fir.heap<!fir.array<10xi32>>
 ! CHECK:         %[[VAL_45:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_13]]) {{.*}}: (!fir.ref<i8>) -> i32
+! CHECK:         fir.freemem %[[VAL_18]] : !fir.heap<!fir.array<10xi32>>
 ! CHECK:         return
 ! CHECK:       }
 
 subroutine test_elemental_character_intrinsic(c1, c2)
   character(*) :: c1(10), c2(2:11)
   print *, scan(c1, c2)
 end subroutine
 
 ! CHECK: func private @_QPbar(

flang/test/Lower/array-temp.f90

subroutine tt1
   ! CHECK: br ^bb1(%[[temp3]]
   ! CHECK-NEXT: ^bb1(%[[temp3arg:[0-9]+]]: !fir.heap<!fir.array<3xf32>>
   ! CHECK: %[[temp1:[0-9]+]] = fir.allocmem !fir.array<1xf32>
   ! CHECK: fir.call @_QFtt1Pr
   ! CHECK: fir.call @realloc
   ! CHECK: fir.freemem %[[temp1]] : !fir.heap<!fir.array<1xf32>>
   ! CHECK: %[[temp3x:[0-9]+]] = fir.allocmem !fir.array<3xf32>
   ! CHECK: fir.call @_FortranAioOutputDescriptor
+  ! CHECK-NEXT: fir.call @_FortranAioEndIoStatement
   ! CHECK-NEXT: fir.freemem %[[temp3x]] : !fir.heap<!fir.array<3xf32>>
   ! CHECK-NEXT: fir.freemem %[[temp3arg]] : !fir.heap<!fir.array<3xf32>>
-  ! CHECK-NEXT: fir.call @_FortranAioEndIoStatement
   print*, [(r([7.0]),i=1,3)]
 contains
   ! CHECK-LABEL: func @_QFtt1Pr
   function r(x)
     real x(:)
     r = x(1)
   end
 end

flang/test/Lower/derived-type-finalization.f90

 ! Test derived type finalization
 ! RUN: bbc -polymorphic-type -emit-fir %s -o - | FileCheck %s
 
 ! Missing tests:
 ! - finalization within BLOCK construct
 
 module derived_type_finalization
 
   type :: t1
     integer :: a
   contains
     final :: t1_final
   end type
 
+  type :: t2
+    integer :: b
+  contains
+    final :: t2_final
+  end type
+
 contains
 
   subroutine t1_final(this)
     type(t1) :: this
   end subroutine
 
+  subroutine t2_final(this)
+    type(t2) :: this
+    print*,'finalize t2 = ', this%b
+  end subroutine
+
   ! 7.5.6.3 point 1. Finalization of LHS.
   subroutine test_lhs()
     type(t1) :: lhs, rhs
     lhs = rhs
   end subroutine
 
   subroutine test_lhs_allocatable()
     type(t1), allocatable :: lhs

 
 ! CHECK-LABEL: func.func @_QMderived_type_finalizationPtest_finalize_intent_out(
 ! CHECK-SAME: %[[T:.*]]: !fir.ref<!fir.type<_QMderived_type_finalizationTt1{a:i32}>> {fir.bindc_name = "t"}) {
 ! CHECK: %[[EMBOX:.*]] = fir.embox %[[T]] : (!fir.ref<!fir.type<_QMderived_type_finalizationTt1{a:i32}>>) -> !fir.box<!fir.type<_QMderived_type_finalizationTt1{a:i32}>>
 ! CHECK: %[[BOX_NONE:.*]] = fir.convert %[[EMBOX]] : (!fir.box<!fir.type<_QMderived_type_finalizationTt1{a:i32}>>) -> !fir.box<none>
 ! CHECK: %{{.*}} = fir.call @_FortranADestroy(%[[BOX_NONE]]) {{.*}}: (!fir.box<none>) -> none
 ! CHECK: return
 
+  type(t2) function get_t2(i)
+    integer, intent(in) :: i
+    get_t2%b = i
+  end function
+
+  subroutine test_end_of_io_finalize()
+    print*, get_t2(10)
+  end subroutine
+
+! CHECK-LABEL: func.func @_QMderived_type_finalizationPtest_end_of_io_finalize() {
+! CHECK: %[[TMP:.*]] = fir.alloca !fir.type<_QMderived_type_finalizationTt2{b:i32}> {bindc_name = ".result"}
+! CHECK: %{{.*}} = fir.call @_FortranAioBeginExternalListOutput(%{{.*}}, %{{.*}}, %{{.*}}) {{.*}} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+! CHECK: %[[CALL_RES:.*]] = fir.call @_QMderived_type_finalizationPget_t2(%{{.*}}) {{.*}} : (!fir.ref<i32>) -> !fir.type<_QMderived_type_finalizationTt2{b:i32}>
+! CHECK: fir.save_result %[[CALL_RES]] to %[[TMP]] : !fir.type<_QMderived_type_finalizationTt2{b:i32}>, !fir.ref<!fir.type<_QMderived_type_finalizationTt2{b:i32}>>
+! CHECK: %{{.*}} = fir.call @_FortranAioOutputDescriptor(%{{.*}}, %{{.*}}) {{.*}} : (!fir.ref<i8>, !fir.box<none>) -> i1
+! CHECK: %{{.*}} = fir.call @_FortranAioEndIoStatement(%4) {{.*}} : (!fir.ref<i8>) -> i32
+! CHECK: %[[EMBOX_TMP:.*]] = fir.embox %[[TMP]] : (!fir.ref<!fir.type<_QMderived_type_finalizationTt2{b:i32}>>) -> !fir.box<!fir.type<_QMderived_type_finalizationTt2{b:i32}>>
+! CHECK: %[[TMP_BOX_NONE:.*]] = fir.convert %[[EMBOX_TMP]] : (!fir.box<!fir.type<_QMderived_type_finalizationTt2{b:i32}>>) -> !fir.box<none>
+! CHECK: %{{.*}} = fir.call @_FortranADestroy(%[[TMP_BOX_NONE]]) {{.*}} : (!fir.box<none>) -> none
+
 end module
 
 program p
   use derived_type_finalization
   type(t1) :: t
   print *, 'end of program'
 end program
 
 ! CHECK-LABEL: func.func @_QQmain() {
 ! CHECK: %[[T:.*]] = fir.alloca !fir.type<_QMderived_type_finalizationTt1{a:i32}> {bindc_name = "t", uniq_name = "_QFEt"}
 ! CHECK: %[[EMBOX:.*]] = fir.embox %[[T]] : (!fir.ref<!fir.type<_QMderived_type_finalizationTt1{a:i32}>>) -> !fir.box<!fir.type<_QMderived_type_finalizationTt1{a:i32}>>
 ! CHECK: %[[BOX_NONE:.*]] = fir.convert %[[EMBOX]] : (!fir.box<!fir.type<_QMderived_type_finalizationTt1{a:i32}>>) -> !fir.box<none>
 ! CHECK: %{{.*}} = fir.call @_FortranADestroy(%[[BOX_NONE]]) {{.*}} : (!fir.box<none>) -> none
 ! CHECK: return

flang/test/Lower/host-associated.f90

 ! CHECK:         %[[VAL_35:.*]] = fir.undefined tuple<!fir.boxproc<() -> ()>, i64>
 ! CHECK:         %[[VAL_36:.*]] = fir.insert_value %[[VAL_35]], %[[VAL_34]], [0 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, !fir.boxproc<() -> ()>) -> tuple<!fir.boxproc<() -> ()>, i64>
 ! CHECK:         %[[VAL_37:.*]] = fir.insert_value %[[VAL_36]], %[[VAL_8]], [1 : index] : (tuple<!fir.boxproc<() -> ()>, i64>, i64) -> tuple<!fir.boxproc<() -> ()>, i64>
 ! CHECK:         %[[VAL_38:.*]] = fir.call @llvm.stacksave() {{.*}}: () -> !fir.ref<i8>
 ! CHECK:         %[[VAL_39:.*]] = fir.call @_QPget_message(%[[VAL_11]], %[[VAL_9]], %[[VAL_37]]) {{.*}}: (!fir.ref<!fir.char<1,40>>, index, tuple<!fir.boxproc<() -> ()>, i64>) -> !fir.boxchar<1>
 ! CHECK:         %[[VAL_40:.*]] = fir.convert %[[VAL_11]] : (!fir.ref<!fir.char<1,40>>) -> !fir.ref<i8>
 ! CHECK:         %[[VAL_41:.*]] = fir.convert %[[VAL_9]] : (index) -> i64
 ! CHECK:         %[[VAL_42:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_32]], %[[VAL_40]], %[[VAL_41]]) {{.*}}: (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
-! CHECK:         fir.call @llvm.stackrestore(%[[VAL_38]]) {{.*}}: (!fir.ref<i8>) -> ()
 ! CHECK:         %[[VAL_43:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_32]]) {{.*}}: (!fir.ref<i8>) -> i32
+! CHECK:         fir.call @llvm.stackrestore(%[[VAL_38]]) {{.*}}: (!fir.ref<i8>) -> ()
 ! CHECK:         return
 ! CHECK:       }
 
 ! CHECK-LABEL: func @_QFtest_proc_dummy_charPgen_message(
 ! CHECK-SAME:                                            %[[VAL_0:.*]]: !fir.ref<!fir.char<1,10>>,
 ! CHECK-SAME:                                            %[[VAL_1:.*]]: index,
 ! CHECK-SAME:                                            %[[VAL_2:.*]]: !fir.ref<tuple<!fir.boxchar<1>>> {fir.host_assoc}) -> !fir.boxchar<1> attributes {fir.internal_proc} {
 ! CHECK-DAG:         %[[VAL_3:.*]] = arith.constant 0 : i32

flang/test/Lower/io-statement-big-unit-checks.f90

 ! CHECK:  %[[VAL_58:.*]] = arith.constant 0 : i32
 ! CHECK:  %[[VAL_59:.*]] = arith.cmpi eq, %[[VAL_57]], %[[VAL_58]] : i32
 ! CHECK:  %[[VAL_60:.*]] = fir.if %[[VAL_59]] -> (i32) {
 ! CHECK:    fir.call @_FortranAioBeginUnformattedOutput(
 ! CHECK:    fir.call @_FortranAioEnableHandlers(
 ! CHECK:    %[[VAL_72:.*]] = fir.call @_QPmake_temp4() {{.*}}: () -> !fir.box<!fir.heap<i32>>
 ! CHECK:    fir.save_result %[[VAL_72]] to %[[VAL_5:.*]] : !fir.box<!fir.heap<i32>>, !fir.ref<!fir.box<!fir.heap<i32>>>
 ! CHECK:    %[[VAL_77:.*]] = fir.call @_FortranAioOutputDescriptor(
-! CHECK:    %[[VAL_77_1:.*]] = fir.load %[[VAL_5]] : !fir.ref<!fir.box<!fir.heap<i32>>>
-! CHECK:    %[[VAL_77_2:.*]] = fir.box_addr %[[VAL_77_1]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
-! CHECK:    fir.freemem %[[VAL_77_2]] : !fir.heap<i32>
 ! CHECK:    fir.if %[[VAL_77]] {
 ! CHECK:      %[[VAL_78:.*]] = fir.call @_QPmake_temp5() {{.*}}: () -> !fir.box<!fir.heap<i32>>
 ! CHECK:      fir.save_result %[[VAL_78]] to %[[VAL_4:.*]] : !fir.box<!fir.heap<i32>>, !fir.ref<!fir.box<!fir.heap<i32>>>
 ! CHECK:      fir.call @_FortranAioOutputDescriptor(
-! CHECK:      %[[VAL_84:.*]] = fir.load %[[VAL_4]] : !fir.ref<!fir.box<!fir.heap<i32>>>
-! CHECK:      %[[VAL_85:.*]] = fir.box_addr %[[VAL_84]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
-! CHECK:      fir.freemem %[[VAL_85]] : !fir.heap<i32>
 ! CHECK:    }
 ! CHECK-NOT: fir.call @_QPmake_temp3
 ! CHECK:    fir.call @_FortranAioGetIoMsg(
 ! CHECK:    %[[VAL_97:.*]] = fir.call @_FortranAioEndIoStatement(
+! CHECK:    %[[VAL_84:.*]] = fir.load %[[VAL_4]] : !fir.ref<!fir.box<!fir.heap<i32>>>
+! CHECK:    %[[VAL_85:.*]] = fir.box_addr %[[VAL_84]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
+! CHECK:    fir.freemem %[[VAL_85]] : !fir.heap<i32>
+! CHECK:    %[[VAL_77_1:.*]] = fir.load %[[VAL_5]] : !fir.ref<!fir.box<!fir.heap<i32>>>
+! CHECK:    %[[VAL_77_2:.*]] = fir.box_addr %[[VAL_77_1]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
+! CHECK:    fir.freemem %[[VAL_77_2]] : !fir.heap<i32>
 ! CHECK:    fir.result %[[VAL_97]] : i32
 ! CHECK:  } else {
 ! CHECK:    fir.result %[[VAL_57]] : i32
 ! CHECK:  }
 ! CHECK:  %[[VAL_98:.*]] = fir.call @_QPmake_temp1() {{.*}}: () -> !fir.box<!fir.heap<i32>>
 ! CHECK:  fir.save_result %[[VAL_98]] to %[[VAL_3:.*]] : !fir.box<!fir.heap<i32>>, !fir.ref<!fir.box<!fir.heap<i32>>>
 ! CHECK:  fir.load %[[VAL_3]]
 ! CHECK:  %[[VAL_107:.*]] = fir.load %[[VAL_3]] : !fir.ref<!fir.box<!fir.heap<i32>>>
 ! CHECK:  %[[VAL_108:.*]] = fir.box_addr %[[VAL_107]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
 ! CHECK:  fir.freemem %[[VAL_108]] : !fir.heap<i32>
 ! CHECK:  %[[VAL_112:.*]] = fir.load %[[VAL_6]] : !fir.ref<!fir.box<!fir.heap<i32>>>
 ! CHECK:  %[[VAL_113:.*]] = fir.box_addr %[[VAL_112]] : (!fir.box<!fir.heap<i32>>) -> !fir.heap<i32>
 ! CHECK:  fir.freemem %[[VAL_113]] : !fir.heap<i32>
 end