explicitly convert when dummy arg doesnt match callers type

ashermancinelli · ashermancinelli · commit e079baf57d60 · 2025-03-31T13:42:01.000-07:00
diff --git a/flang/include/flang/Optimizer/Builder/FIRBuilder.h b/flang/include/flang/Optimizer/Builder/FIRBuilder.h
@@ -363,6 +363,9 @@ class FirOpBuilder : public mlir::OpBuilder, public mlir::OpBuilder::Listener {
   mlir::Value createConvert(mlir::Location loc, mlir::Type toTy,
                             mlir::Value val);
 
+  mlir::Value createConvertWithVolatileCast(mlir::Location loc, mlir::Type toTy,
+                                            mlir::Value val);
+
   /// Create a fir.store of \p val into \p addr. A lazy conversion
   /// of \p val to the element type of \p addr is created if needed.
   void createStoreWithConvert(mlir::Location loc, mlir::Value val,
diff --git a/flang/include/flang/Optimizer/Dialect/FIROps.td b/flang/include/flang/Optimizer/Dialect/FIROps.td
@@ -302,7 +302,7 @@ def fir_LoadOp : fir_OneResultOp<"load", [FirAliasTagOpInterface, DeclareOpInter
     or null.
   }];
 
-  let arguments = (ins Arg<AnyReferenceLike, "">:$memref,
+  let arguments = (ins AnyReferenceLike:$memref,
                   OptionalAttr<LLVM_TBAATagArrayAttr>:$tbaa);
 
   let builders = [OpBuilder<(ins "mlir::Value":$refVal)>,
@@ -336,7 +336,7 @@ def fir_StoreOp : fir_Op<"store", [FirAliasTagOpInterface,
   }];
 
   let arguments = (ins AnyType:$value,
-                   Arg<AnyReferenceLike, "">:$memref,
+                   AnyReferenceLike:$memref,
                    OptionalAttr<LLVM_TBAATagArrayAttr>:$tbaa);
 
   let builders = [OpBuilder<(ins "mlir::Value":$value, "mlir::Value":$memref)>];
@@ -2765,6 +2765,7 @@ def fir_VolatileCastOp : fir_SimpleOneResultOp<"volatile_cast", [NoMemoryEffect]
     $value attr-dict `:` functional-type($value, results)
   }];
   let hasVerifier = 1;
+  let hasFolder = 1;
 }
 
 def fir_ConvertOp : fir_SimpleOneResultOp<"convert", [NoMemoryEffect]> {
diff --git a/flang/include/flang/Optimizer/Dialect/FIRType.h b/flang/include/flang/Optimizer/Dialect/FIRType.h
@@ -462,6 +462,10 @@ inline mlir::Type wrapInClassOrBoxType(mlir::Type eleTy,
   return fir::BoxType::get(eleTy);
 }
 
+/// Re-create the given type with the given volatility, if this is a type
+/// that can represent volatility.
+mlir::Type updateTypeWithVolatility(mlir::Type type, bool isVolatile);
+
 /// Return the elementType where intrinsic types are replaced with none for
 /// unlimited polymorphic entities.
 ///
diff --git a/flang/include/flang/Optimizer/Dialect/FIRTypes.td b/flang/include/flang/Optimizer/Dialect/FIRTypes.td
@@ -365,7 +365,7 @@ def fir_ReferenceType : FIR_Type<"Reference", "ref"> {
     References can be volatile. Any ops taking an operand of a volatile
     reference must set their memory effects appropriately. Accesses of
     volatile references are currently modeled as read and write effects
-    to an unknown memory location.
+    to a specific memory resource.
   }];
 
   let parameters = (ins
@@ -386,8 +386,6 @@ def fir_ReferenceType : FIR_Type<"Reference", "ref"> {
   }];
 
   let genVerifyDecl = 1;
-  // let assemblyFormat = "`<` $eleTy (`,` `volatile` $isVolatile^)? `>`";
-  // let assemblyFormat = "`<` $eleTy custom<IsVolatile>($isVolatile)`>`";
   let hasCustomAssemblyFormat = 1;
 }
 
diff --git a/flang/lib/Lower/CallInterface.cpp b/flang/lib/Lower/CallInterface.cpp
@@ -1150,7 +1150,8 @@ class Fortran::lower::CallInterfaceImpl {
 
     if (obj.attrs.test(Attrs::Allocatable) || obj.attrs.test(Attrs::Pointer)) {
       // Pass as fir.ref<fir.box> or fir.ref<fir.class>
-      mlir::Type boxRefType = fir::ReferenceType::get(boxType);
+      const bool isVolatile = obj.attrs.test(Attrs::Volatile);
+      mlir::Type boxRefType = fir::ReferenceType::get(boxType, isVolatile);
       addFirOperand(boxRefType, nextPassedArgPosition(), Property::MutableBox,
                     attrs);
       addPassedArg(PassEntityBy::MutableBox, entity, characteristics);
diff --git a/flang/lib/Lower/ConvertCall.cpp b/flang/lib/Lower/ConvertCall.cpp
@@ -327,7 +327,6 @@ Fortran::lower::genCallOpAndResult(
         charFuncPointerLength = charBox->getLen();
     }
   }
-
   const bool isExprCall =
       converter.getLoweringOptions().getLowerToHighLevelFIR() &&
       callSiteType.getNumResults() == 1 &&
@@ -1417,6 +1416,25 @@ static PreparedDummyArgument preparePresentUserCallActualArgument(
     addr = hlfir::genVariableRawAddress(loc, builder, entity);
   }
 
+  // If the volatility of the input type does not match the dummy type,
+  // we need to cast the argument.
+  if (fir::isa_volatile_type(dummyTypeWithActualRank) !=
+      fir::isa_volatile_type(addr.getType())) {
+    const bool isToTypeVolatile =
+        fir::isa_volatile_type(dummyTypeWithActualRank);
+    mlir::Type volatileAdjustedType =
+        llvm::TypeSwitch<mlir::Type, mlir::Type>(addr.getType())
+            .Case<fir::ReferenceType, fir::BoxType>([&](auto ty) {
+              using TYPE = decltype(ty);
+              return TYPE::get(ty.getElementType(), isToTypeVolatile);
+            })
+            .Default([](auto t) {
+              assert(false && "unexpected type");
+              return t;
+            });
+    addr = builder.create<fir::VolatileCastOp>(loc, volatileAdjustedType, addr);
+  }
+
   // For ranked actual passed to assumed-rank dummy, the cast to assumed-rank
   // box is inserted when building the fir.call op. Inserting it here would
   // cause the fir.if results to be assumed-rank in case of OPTIONAL dummy,
diff --git a/flang/lib/Lower/ConvertExprToHLFIR.cpp b/flang/lib/Lower/ConvertExprToHLFIR.cpp
@@ -232,15 +232,11 @@ class HlfirDesignatorBuilder {
       isVolatile = fir::isa_volatile_type(baseType);
     }
 
-    auto isVolatileSymbol = [](const Fortran::semantics::Symbol &symbol) {
-      return symbol.GetUltimate().attrs().test(
-          Fortran::semantics::Attr::VOLATILE);
-    };
-
     // Check if this should be a volatile reference
     if constexpr (std::is_same_v<std::decay_t<T>,
                                  Fortran::evaluate::SymbolRef>) {
-      if (isVolatileSymbol(designatorNode.get()))
+      if (designatorNode.get().GetUltimate().attrs().test(
+              Fortran::semantics::Attr::VOLATILE))
         isVolatile = true;
     }
 
@@ -436,16 +432,15 @@ class HlfirDesignatorBuilder {
         .Case<fir::SequenceType>([&](fir::SequenceType seqTy) -> mlir::Type {
           return fir::SequenceType::get(seqTy.getShape(), newEleTy);
         })
-        // TODO: handle volatility for other types
-        .Case<fir::PointerType, fir::HeapType, fir::BoxType, fir::ClassType>(
+        .Case<fir::PointerType, fir::HeapType, fir::ClassType>(
             [&](auto t) -> mlir::Type {
               using FIRT = decltype(t);
               return FIRT::get(changeElementType(t.getEleTy(), newEleTy));
             })
-        .Case<fir::ReferenceType>([&](fir::ReferenceType refTy) -> mlir::Type {
-          return fir::ReferenceType::get(
-              changeElementType(refTy.getEleTy(), newEleTy),
-              refTy.isVolatile());
+        .Case<fir::ReferenceType, fir::BoxType>([&](auto t) -> mlir::Type {
+          using FIRT = decltype(t);
+          return FIRT::get(changeElementType(t.getEleTy(), newEleTy),
+                           t.isVolatile());
         })
         .Default([newEleTy](mlir::Type t) -> mlir::Type { return newEleTy; });
   }
diff --git a/flang/lib/Lower/IO.cpp b/flang/lib/Lower/IO.cpp
@@ -709,7 +709,7 @@ static void genOutputItemList(
     fir::factory::CharacterExprHelper helper{builder, loc};
     if (mlir::isa<fir::BoxType>(argType)) {
       mlir::Value box = fir::getBase(converter.genExprBox(loc, *expr, stmtCtx));
-      outputFuncArgs.push_back(builder.createConvert(loc, argType, box));
+      outputFuncArgs.push_back(builder.createConvertWithVolatileCast(loc, argType, box));
       if (mlir::isa<fir::RecordType>(fir::unwrapPassByRefType(itemTy)))
         outputFuncArgs.push_back(getNonTbpDefinedIoTableAddr(converter));
     } else if (helper.isCharacterScalar(itemTy)) {
@@ -719,9 +719,9 @@ static void genOutputItemList(
       if (!exv.getCharBox())
         llvm::report_fatal_error(
             "internal error: scalar character not in CharBox");
-      outputFuncArgs.push_back(builder.createConvert(
+      outputFuncArgs.push_back(builder.createConvertWithVolatileCast(
           loc, outputFunc.getFunctionType().getInput(1), fir::getBase(exv)));
-      outputFuncArgs.push_back(builder.createConvert(
+      outputFuncArgs.push_back(builder.createConvertWithVolatileCast(
           loc, outputFunc.getFunctionType().getInput(2), fir::getLen(exv)));
     } else {
       fir::ExtendedValue itemBox = converter.genExprValue(loc, expr, stmtCtx);
@@ -822,6 +822,17 @@ createIoRuntimeCallForItem(Fortran::lower::AbstractConverter &converter,
   } else {
     mlir::Value itemAddr = fir::getBase(item);
     mlir::Type itemTy = fir::unwrapPassByRefType(itemAddr.getType());
+    
+    // Handle conversion between volatile and non-volatile reference types
+    // Need to explicitly cast when volatility qualification differs
+    bool srcIsVolatile = fir::isa_volatile_type(itemAddr.getType());
+    bool dstIsVolatile = fir::isa_volatile_type(argType);
+    
+    if (srcIsVolatile != dstIsVolatile) {
+      // Create an explicit conversion to handle the volatility difference
+      itemAddr = builder.create<fir::VolatileCastOp>(loc, argType, itemAddr);
+    }
+    
     inputFuncArgs.push_back(builder.createConvert(loc, argType, itemAddr));
     fir::factory::CharacterExprHelper charHelper{builder, loc};
     if (charHelper.isCharacterScalar(itemTy)) {
diff --git a/flang/lib/Optimizer/Builder/FIRBuilder.cpp b/flang/lib/Optimizer/Builder/FIRBuilder.cpp
@@ -510,6 +510,16 @@ mlir::Value fir::FirOpBuilder::convertWithSemantics(
   return createConvert(loc, toTy, val);
 }
 
+mlir::Value fir::FirOpBuilder::createConvertWithVolatileCast(mlir::Location loc,
+                                                             mlir::Type toTy,
+                                                             mlir::Value val) {
+  if (fir::isa_volatile_type(val.getType()) != fir::isa_volatile_type(toTy)) {
+    mlir::Type volatileAdjustedType = fir::updateTypeWithVolatility(val.getType(), fir::isa_volatile_type(toTy));
+    val = create<fir::VolatileCastOp>(loc, volatileAdjustedType, val);
+  }
+  return createConvert(loc, toTy, val);
+}
+
 mlir::Value fir::factory::createConvert(mlir::OpBuilder &builder,
                                         mlir::Location loc, mlir::Type toTy,
                                         mlir::Value val) {
@@ -672,17 +682,18 @@ mlir::Value fir::FirOpBuilder::createBox(mlir::Location loc,
         << itemAddr.getType();
     llvm_unreachable("not a memory reference type");
   }
+  const bool isVolatile = fir::isa_volatile_type(itemAddr.getType());
   mlir::Type boxTy;
   mlir::Value tdesc;
   // Avoid to wrap a box/class with box/class.
   if (mlir::isa<fir::BaseBoxType>(elementType)) {
     boxTy = elementType;
   } else {
-    boxTy = fir::BoxType::get(elementType);
+    boxTy = fir::BoxType::get(elementType, isVolatile);
     if (isPolymorphic) {
       elementType = fir::updateTypeForUnlimitedPolymorphic(elementType);
       if (isAssumedType)
-        boxTy = fir::BoxType::get(elementType);
+        boxTy = fir::BoxType::get(elementType, isVolatile);
       else
         boxTy = fir::ClassType::get(elementType);
     }
diff --git a/flang/lib/Optimizer/Dialect/FIROps.cpp b/flang/lib/Optimizer/Dialect/FIROps.cpp
@@ -1357,8 +1357,6 @@ llvm::LogicalResult fir::VolatileCastOp::verify() {
        mlir::isa<fir::ReferenceType>(toType));
   bool sameElementType = fir::dyn_cast_ptrOrBoxEleTy(fromType) ==
                          fir::dyn_cast_ptrOrBoxEleTy(toType);
-  llvm::dbgs() << fromType << " / " << toType << "\n"
-               << sameBaseType << " " << sameElementType << "\n";
   if (fromType == toType ||
       fir::isa_volatile_type(fromType) == fir::isa_volatile_type(toType) ||
       !sameBaseType || !sameElementType)
@@ -1367,6 +1365,12 @@ llvm::LogicalResult fir::VolatileCastOp::verify() {
   return mlir::success();
 }
 
+mlir::OpFoldResult fir::VolatileCastOp::fold(FoldAdaptor adaptor) {
+  if (getValue().getType() == getType())
+    return getValue();
+  return {};
+}
+
 //===----------------------------------------------------------------------===//
 // ConvertOp
 //===----------------------------------------------------------------------===//
@@ -1838,9 +1842,9 @@ llvm::LogicalResult fir::EmboxOp::verify() {
     return emitOpError("slice must not be provided for a scalar");
   if (getSourceBox() && !mlir::isa<fir::ClassType>(getResult().getType()))
     return emitOpError("source_box must be used with fir.class result type");
-  if (fir::isa_volatile_type(getMemref().getType()) !=
-      fir::isa_volatile_type(getResult().getType()))
-    return emitOpError("input and output types must have the same volatility");
+  // if (fir::isa_volatile_type(getMemref().getType()) !=
+  //     fir::isa_volatile_type(getResult().getType()))
+  //   return emitOpError("input and output types must have the same volatility");
   return mlir::success();
 }
 
diff --git a/flang/lib/Optimizer/Dialect/FIRType.cpp b/flang/lib/Optimizer/Dialect/FIRType.cpp
@@ -1319,6 +1319,19 @@ bool fir::hasAbstractResult(mlir::FunctionType ty) {
       resultType);
 }
 
+mlir::Type fir::updateTypeWithVolatility(mlir::Type type, bool isVolatile) {
+  if (fir::isa_volatile_type(type) == isVolatile)
+    return type;
+  return mlir::TypeSwitch<mlir::Type, mlir::Type>(type)
+      .Case<fir::BoxType, fir::ReferenceType>([&](auto ty) -> mlir::Type {
+        using TYPE = decltype(ty);
+        return TYPE::get(ty.getEleTy(), isVolatile);
+      })
+      .Default([&](mlir::Type t) -> mlir::Type {
+        return t;
+      });
+}
+
 /// Convert llvm::Type::TypeID to mlir::Type. \p kind is provided for error
 /// messages only.
 mlir::Type fir::fromRealTypeID(mlir::MLIRContext *context,
diff --git a/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp b/flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp
@@ -61,12 +61,7 @@ getIntrinsicEffects(mlir::Operation *self,
   // }
   for (mlir::OpOperand &operand : self->getOpOperands()) {
     mlir::Type opTy = operand.get().getType();
-    if (fir::isa_volatile_type(opTy)) {
-      effects.emplace_back(mlir::MemoryEffects::Read::get(), &operand,
-                           mlir::SideEffects::DefaultResource::get());
-      effects.emplace_back(mlir::MemoryEffects::Write::get(), &operand,
-                           mlir::SideEffects::DefaultResource::get());
-    }
+    fir::addVolatileMemoryEffects({opTy}, effects);
     if (fir::isa_ref_type(opTy) || fir::isa_box_type(opTy))
       effects.emplace_back(mlir::MemoryEffects::Read::get(), &operand,
                            mlir::SideEffects::DefaultResource::get());
@@ -203,7 +198,7 @@ mlir::Type hlfir::DeclareOp::getHLFIRVariableType(mlir::Type inputType,
   bool hasDynamicLengthParams = fir::characterWithDynamicLen(eleType) ||
                                 fir::isRecordWithTypeParameters(eleType);
   if (hasExplicitLowerBounds || hasDynamicExtents || hasDynamicLengthParams)
-    return fir::BoxType::get(type);
+    return fir::BoxType::get(type, fir::isa_volatile_type(inputType));
   return inputType;
 }
 
diff --git a/flang/lib/Optimizer/HLFIR/Transforms/ConvertToFIR.cpp b/flang/lib/Optimizer/HLFIR/Transforms/ConvertToFIR.cpp
@@ -89,12 +89,7 @@ class AssignOpConversion : public mlir::OpRewritePattern<hlfir::AssignOp> {
       return fir::getBase(builder.createBox(loc, rhsExv));
     };
 
-    if (fir::isa_volatile_type(lhs.getType()) ||
-        fir::isa_volatile_type(rhs.getType())) {
-      fir::factory::genScalarAssignment(builder, loc, lhsExv, rhsExv,
-                                        /*needFinalization=*/false,
-                                        assignOp.isTemporaryLHS());
-    } else if (assignOp.isAllocatableAssignment()) {
+    if (assignOp.isAllocatableAssignment()) {
       // Whole allocatable assignment: use the runtime to deal with the
       // reallocation.
       mlir::Value from = emboxRHS(rhsExv);
diff --git a/flang/test/Fir/invalid-types.fir b/flang/test/Fir/invalid-types.fir
@@ -157,8 +157,14 @@ func.func private @oth3() -> !fir.vector<10:>
 // expected-error@+1 {{invalid element type}}
 func.func private @upe() -> !fir.class<!fir.box<i32>>
 
+// -----
+
 // TODO: why are source locations lost on the error message?
 // the error message is printed but without a proper source location.
-// -- ---
-// expected-error skipme @+1 {{invalid element type}}
+// expected-error <skipme> @+1 {{invalid element type}}
 // func.func private @upe() -> !fir.box<!fir.class<none>>
+
+// -----
+
+// expected-error@+1 {{invalid element type}}
+func.func private @upe() -> !fir.class<!fir.box<i32>>
diff --git a/flang/test/Lower/volatile.f90 b/flang/test/Lower/volatile.f90
@@ -1,11 +1,52 @@
 ! RUN: bbc %s -o - | FileCheck %s
-logical, volatile :: a
-logical           :: b
-integer           :: i
-a = .false.
-b = a
-a = .true.
-end
 
-! CHECK: %{{.+}} = fir.load %{{.+}} : !fir.ref<!fir.logical<4>, volatile>
-! CHECK: hlfir.assign %{{.+}} to %{{.+}} : !fir.logical<4>, !fir.ref<!fir.logical<4>, volatile>
+program p
+  integer,volatile::i,arr(10)
+  i=0
+  arr=1
+  ! casting from volatile ref to non-volatile ref should be okay here
+  call not_declared_volatile_in_this_scope(i)
+  call not_declared_volatile_in_this_scope(arr)
+  call declared_volatile_in_this_scope(arr,10)
+  print*,arr,i
+contains
+  elemental subroutine not_declared_volatile_in_this_scope(v)
+    integer,intent(inout)::v
+    v=1
+  end subroutine
+  subroutine declared_volatile_in_this_scope(v,n)
+    integer,intent(in)::n
+    integer,volatile,intent(inout)::v(n)
+    v=1
+  end subroutine
+end program
+
+! CHECK-LABEL: _QQmain
+! CHECK:           %[[VAL_10:.*]] = fir.volatile_cast %{{.+}} : (!fir.ref<!fir.array<10xi32>>) -> !fir.ref<!fir.array<10xi32>, volatile>
+! CHECK:           %[[VAL_11:.*]]:2 = hlfir.declare {{.+}} : (!fir.ref<!fir.array<10xi32>, volatile>, !fir.shape<1>) -> (!fir.ref<!fir.array<10xi32>, volatile>, !fir.ref<!fir.array<10xi32>, volatile>)
+! CHECK:           %[[VAL_12:.*]] = fir.alloca i32
+! CHECK:           %[[VAL_13:.*]] = fir.volatile_cast %[[VAL_12]] : (!fir.ref<i32>) -> !fir.ref<i32, volatile>
+! CHECK:           %[[VAL_14:.*]]:2 = hlfir.declare {{.+}} : (!fir.ref<i32, volatile>) -> (!fir.ref<i32, volatile>, !fir.ref<i32, volatile>)
+! CHECK:           hlfir.assign %{{.+}} to %[[VAL_14]]#0 : i32, !fir.ref<i32, volatile>
+! CHECK:           hlfir.assign %{{.+}} to %[[VAL_11]]#0 : i32, !fir.ref<!fir.array<10xi32>, volatile>
+! CHECK:           %[[VAL_15:.*]] = fir.volatile_cast %[[VAL_14]]#0 : (!fir.ref<i32, volatile>) -> !fir.ref<i32>
+! CHECK:           fir.call @_QFPnot_declared_volatile_in_this_scope(%[[VAL_15]]) proc_attrs<elemental, pure> fastmath<contract> : (!fir.ref<i32>) -> ()
+! CHECK:           %[[VAL_19:.*]] = hlfir.designate %{{.+}} (%{{.+}})  : (!fir.ref<!fir.array<10xi32>, volatile>, index) -> !fir.ref<i32, volatile>
+! CHECK:           %[[VAL_20:.*]] = fir.volatile_cast %[[VAL_19]] : (!fir.ref<i32, volatile>) -> !fir.ref<i32>
+! CHECK:           fir.call @_QFPnot_declared_volatile_in_this_scope(%[[VAL_20]]) proc_attrs<elemental, pure> fastmath<contract> : (!fir.ref<i32>) -> ()
+! CHECK:           %[[VAL_23:.*]] = fir.volatile_cast %[[VAL_11]]#0 : (!fir.ref<!fir.array<10xi32>, volatile>) -> !fir.ref<!fir.array<10xi32>>
+! CHECK:           %[[VAL_24:.*]] = fir.convert %[[VAL_23]] : (!fir.ref<!fir.array<10xi32>>) -> !fir.ref<!fir.array<?xi32>>
+! CHECK:           %[[VAL_25:.*]]:3 = hlfir.associate %{{.+}} {adapt.valuebyref} : (i32) -> (!fir.ref<i32>, !fir.ref<i32>, i1)
+! CHECK:           fir.call @_QFPdeclared_volatile_in_this_scope(%[[VAL_24]], %[[VAL_25]]#0) fastmath<contract> : (!fir.ref<!fir.array<?xi32>>, !fir.ref<i32>) -> ()
+! CHECK:           hlfir.end_associate %[[VAL_25]]#1, %[[VAL_25]]#2 : !fir.ref<i32>, i1
+! CHECK:           %[[VAL_26:.*]] = fir.address_of(@_QQclX6951b66b308fd310127f64e03dcd1051) : !fir.ref<!fir.char<1,78>>
+! CHECK:           %[[VAL_27:.*]] = fir.convert %[[VAL_26]] : (!fir.ref<!fir.char<1,78>>) -> !fir.ref<i8>
+! CHECK:           %[[VAL_28:.*]] = fir.call @_FortranAioBeginExternalListOutput(
+! CHECK:           %[[VAL_29:.*]] = fir.embox %{{.+}} : (!fir.ref<!fir.array<10xi32>, volatile>, !fir.shape<1>) -> !fir.box<!fir.array<10xi32>, volatile>
+! CHECK:           %[[VAL_30:.*]] = fir.volatile_cast %[[VAL_29]] : (!fir.box<!fir.array<10xi32>, volatile>) -> !fir.box<!fir.array<10xi32>>
+! CHECK:           %[[VAL_31:.*]] = fir.convert %[[VAL_30]] : (!fir.box<!fir.array<10xi32>>) -> !fir.box<none>
+! CHECK:           %[[VAL_32:.*]] = fir.call @_FortranAioOutputDescriptor(
+! CHECK:           %[[VAL_33:.*]] = fir.load %[[VAL_14]]#0 : !fir.ref<i32, volatile>
+! CHECK:           %[[VAL_34:.*]] = fir.call @_FortranAioOutputInteger32(
+! CHECK:           %[[VAL_35:.*]] = fir.call @_FortranAioEndIoStatement(
+! CHECK:           return
