[flang-commits] [flang] [flang] Set LLVM specific attributes to fir.call's of Fortran runtime. (PR #128093)
Slava Zakharin via flang-commits
flang-commits at lists.llvm.org
Mon Feb 24 08:49:49 PST 2025
https://github.com/vzakhari updated https://github.com/llvm/llvm-project/pull/128093
>From 6b7ad98bc9ce1457ceff361fccd199b8dd29b8df Mon Sep 17 00:00:00 2001
From: Slava Zakharin <szakharin at nvidia.com>
Date: Thu, 13 Feb 2025 20:12:20 -0800
Subject: [PATCH 1/3] [flang] Set LLVM specific attributes to fir.call's of
Fortran runtime.
This change is inspired by a case in facerec benchmark, where performance
of scalar code may improve by about 6%@aarch64 due to getting rid of redundant
loads from Fortran descriptors. These descriptors are corresponding
to subroutine local ALLOCATABLE, SAVE variables. The scalar loop nest
in LocalMove subroutine contains call to Fortran runtime IO functions,
and LLVM globals-aa analysis cannot prove that these calls do not modify
the globalized descriptors with internal linkage.
This patch sets and propagates llvm.memory_effects attribute for fir.call
operations calling Fortran runtime functions. In particular, it tries
to set the Other memory effect to NoModRef. The Other memory effect
includes accesses to globals and captured pointers, so we cannot set
it for functions taking Fortran descriptors with one exception
for calls where the Fortran descriptor arguments are all null.
As long as different calls to the same Fortran runtime function may have
different attributes, I decided to attach the attributes to the calls
rather than functions. Moreover, attaching the attributes to func.func
will require propagating these attributes to llvm.func, which is not
happening right now.
In addition to llvm.memory_effects, the new pass sets llvm.nosync
and llvm.nocallback attributes that may also help LLVM alias analysis
(e.g. see #127707). These attributes are ignored currently.
I will support them in LLVM IR dialect in a separate patch.
I also added another pass for developers to be able to print
declarations/calls of all Fortran runtime functions that are recognized
by the attributes setting pass. It should help with maintenance
of the LIT tests.
---
.../flang/Optimizer/Builder/FIRBuilder.h | 9 +
.../Optimizer/Builder/Runtime/RTBuilder.h | 42 +-
.../flang/Optimizer/Dialect/FIRDialect.td | 12 +
.../flang/Optimizer/Transforms/Passes.h | 2 +
.../flang/Optimizer/Transforms/Passes.td | 33 +
.../Optimizer/Transforms/RuntimeFunctions.inc | 111 ++
flang/lib/Lower/IO.cpp | 296 +++--
flang/lib/Optimizer/Builder/FIRBuilder.cpp | 12 +
flang/lib/Optimizer/CodeGen/CodeGen.cpp | 10 +
flang/lib/Optimizer/Passes/Pipelines.cpp | 3 +
flang/lib/Optimizer/Transforms/CMakeLists.txt | 2 +
.../Transforms/GenRuntimeCallsForTest.cpp | 106 ++
.../Transforms/SetRuntimeCallAttributes.cpp | 252 ++++
flang/test/Driver/mlir-pass-pipeline.f90 | 2 +
flang/test/Fir/basic-program.fir | 2 +
flang/test/Lower/array-temp.f90 | 18 +-
.../set-runtime-call-attributes.fir | 1039 +++++++++++++++++
.../verify-known-runtime-functions.fir | 101 ++
.../generate-checks-for-runtime-funcs.py | 79 ++
19 files changed, 1969 insertions(+), 162 deletions(-)
create mode 100644 flang/include/flang/Optimizer/Transforms/RuntimeFunctions.inc
create mode 100644 flang/lib/Optimizer/Transforms/GenRuntimeCallsForTest.cpp
create mode 100644 flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp
create mode 100644 flang/test/Transforms/set-runtime-call-attributes.fir
create mode 100644 flang/test/Transforms/verify-known-runtime-functions.fir
create mode 100755 flang/test/Utils/generate-checks-for-runtime-funcs.py
diff --git a/flang/include/flang/Optimizer/Builder/FIRBuilder.h b/flang/include/flang/Optimizer/Builder/FIRBuilder.h
index 93eca78424775..1675c15363868 100644
--- a/flang/include/flang/Optimizer/Builder/FIRBuilder.h
+++ b/flang/include/flang/Optimizer/Builder/FIRBuilder.h
@@ -385,6 +385,15 @@ class FirOpBuilder : public mlir::OpBuilder, public mlir::OpBuilder::Listener {
mlir::FunctionType ty,
mlir::SymbolTable *);
+ /// Returns a named function for a Fortran runtime API, creating
+ /// it, if it does not exist in the module yet.
+ /// If \p isIO is set to true, then the function corresponds
+ /// to one of Fortran runtime IO APIs.
+ mlir::func::FuncOp createRuntimeFunction(mlir::Location loc,
+ llvm::StringRef name,
+ mlir::FunctionType ty,
+ bool isIO = false);
+
/// Cast the input value to IndexType.
mlir::Value convertToIndexType(mlir::Location loc, mlir::Value val) {
return createConvert(loc, getIndexType(), val);
diff --git a/flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h b/flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h
index 1ffc354d6b80f..5158abaa31ed1 100644
--- a/flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h
+++ b/flang/include/flang/Optimizer/Builder/Runtime/RTBuilder.h
@@ -21,6 +21,7 @@
#include "flang/Optimizer/Builder/FIRBuilder.h"
#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Runtime/io-api-consts.h"
#include "flang/Runtime/reduce.h"
#include "flang/Support/Fortran.h"
#include "mlir/IR/BuiltinTypes.h"
@@ -586,6 +587,33 @@ constexpr TypeBuilderFunc getModel<void>() {
};
}
+// Define additional runtime type models specific to IO.
+template <>
+constexpr TypeBuilderFunc getModel<Fortran::runtime::io::IoStatementState *>() {
+ return getModel<char *>();
+}
+template <>
+constexpr TypeBuilderFunc getModel<Fortran::runtime::io::Iostat>() {
+ return [](mlir::MLIRContext *context) -> mlir::Type {
+ return mlir::IntegerType::get(context,
+ 8 * sizeof(Fortran::runtime::io::Iostat));
+ };
+}
+template <>
+constexpr TypeBuilderFunc
+getModel<const Fortran::runtime::io::NamelistGroup &>() {
+ return [](mlir::MLIRContext *context) -> mlir::Type {
+ return fir::ReferenceType::get(mlir::TupleType::get(context));
+ };
+}
+template <>
+constexpr TypeBuilderFunc
+getModel<const Fortran::runtime::io::NonTbpDefinedIoTable *>() {
+ return [](mlir::MLIRContext *context) -> mlir::Type {
+ return fir::ReferenceType::get(mlir::TupleType::get(context));
+ };
+}
+
REDUCTION_REF_OPERATION_MODEL(std::int8_t)
REDUCTION_VALUE_OPERATION_MODEL(std::int8_t)
REDUCTION_REF_OPERATION_MODEL(std::int16_t)
@@ -778,16 +806,22 @@ struct RuntimeTableEntry<RuntimeTableKey<KT>, RuntimeIdentifier<Cs...>> {
/// argument is intended to be of the form: <mkRTKey(runtime function name)>.
template <typename RuntimeEntry>
static mlir::func::FuncOp getRuntimeFunc(mlir::Location loc,
- fir::FirOpBuilder &builder) {
+ fir::FirOpBuilder &builder,
+ bool isIO = false) {
using namespace Fortran::runtime;
auto name = RuntimeEntry::name;
auto func = builder.getNamedFunction(name);
if (func)
return func;
auto funTy = RuntimeEntry::getTypeModel()(builder.getContext());
- func = builder.createFunction(loc, name, funTy);
- func->setAttr(FIROpsDialect::getFirRuntimeAttrName(), builder.getUnitAttr());
- return func;
+ return builder.createRuntimeFunction(loc, name, funTy, isIO);
+}
+
+/// Get (or generate) the MLIR FuncOp for a given IO runtime function.
+template <typename E>
+static mlir::func::FuncOp getIORuntimeFunc(mlir::Location loc,
+ fir::FirOpBuilder &builder) {
+ return getRuntimeFunc<E>(loc, builder, /*isIO=*/true);
}
namespace helper {
diff --git a/flang/include/flang/Optimizer/Dialect/FIRDialect.td b/flang/include/flang/Optimizer/Dialect/FIRDialect.td
index 0dfb3eda585ce..b05f4e731bc73 100644
--- a/flang/include/flang/Optimizer/Dialect/FIRDialect.td
+++ b/flang/include/flang/Optimizer/Dialect/FIRDialect.td
@@ -56,6 +56,18 @@ def FIROpsDialect : Dialect {
static constexpr llvm::StringRef getFirRuntimeAttrName() {
return "fir.runtime";
}
+ // Return string name of fir.memory attributes.
+ // It is attached to fir.call operations to convey
+ // llvm.memory attributes to LLVM IR.
+ // Its value is intended to be mlir::LLVM::MemoryEffectsAttr.
+ // TODO: we should probably make it an inherent attribute
+ // of fir.call, though, it is supposed to be a short-lived
+ // attribute that appears right before CodeGen and only
+ // meaningful for LLVM, so it is unclear if embedding
+ // it into fir.call makes sense.
+ static constexpr llvm::StringRef getFirCallMemoryAttrName() {
+ return "fir.llvm_memory";
+ }
}];
}
diff --git a/flang/include/flang/Optimizer/Transforms/Passes.h b/flang/include/flang/Optimizer/Transforms/Passes.h
index 10e1c999d4533..afbbeb55632f1 100644
--- a/flang/include/flang/Optimizer/Transforms/Passes.h
+++ b/flang/include/flang/Optimizer/Transforms/Passes.h
@@ -60,6 +60,8 @@ namespace fir {
#define GEN_PASS_DECL_FUNCTIONATTR
#define GEN_PASS_DECL_CONSTANTARGUMENTGLOBALISATIONOPT
#define GEN_PASS_DECL_COMPILERGENERATEDNAMESCONVERSION
+#define GEN_PASS_DECL_SETRUNTIMECALLATTRIBUTES
+#define GEN_PASS_DECL_GENRUNTIMECALLSFORTEST
#include "flang/Optimizer/Transforms/Passes.h.inc"
diff --git a/flang/include/flang/Optimizer/Transforms/Passes.td b/flang/include/flang/Optimizer/Transforms/Passes.td
index 0b6e0119c16c3..64341b42bd1e4 100644
--- a/flang/include/flang/Optimizer/Transforms/Passes.td
+++ b/flang/include/flang/Optimizer/Transforms/Passes.td
@@ -453,4 +453,37 @@ def CUFGPUToLLVMConversion : Pass<"cuf-gpu-convert-to-llvm", "mlir::ModuleOp"> {
];
}
+def SetRuntimeCallAttributes
+ : Pass<"set-runtime-call-attrs", "mlir::func::FuncOp"> {
+ let summary = "Set Fortran runtime fir.call attributes targeting LLVM IR";
+ let description = [{
+ This pass sets different attributes for Fortran runtime calls
+ that enable more optimizations in LLVM backend.
+ For the time being, the meaning of these attributes is not
+ strictly defined for HLFIR/FIR.
+ }];
+ let dependentDialects = ["fir::FIROpsDialect", "mlir::LLVM::LLVMDialect"];
+}
+
+def GenRuntimeCallsForTest
+ : Pass<"gen-runtime-calls-for-test", "mlir::ModuleOp"> {
+ let summary =
+ "Print FIR containing declarations/calls of Fortran runtime functions";
+ let description = [{
+ This pass is only for developers to be able to print FIR
+ that declares and calls Fortran runtime functions.
+ It helps producing/updating tests for passes that modify
+ the func/call operations based on some knowledge of
+ Fortran runtime.
+ }];
+ let options =
+ [Option<"doGenerateCalls", "do-generate-calls", "bool",
+ /*default=*/"false",
+ "Generate thin wrapper functions that call Fortran runtime "
+ "functions. If it is set to false, then only the declarations "
+ "are generated.">,
+ ];
+ let dependentDialects = ["fir::FIROpsDialect", "mlir::func::FuncDialect"];
+}
+
#endif // FLANG_OPTIMIZER_TRANSFORMS_PASSES
diff --git a/flang/include/flang/Optimizer/Transforms/RuntimeFunctions.inc b/flang/include/flang/Optimizer/Transforms/RuntimeFunctions.inc
new file mode 100644
index 0000000000000..cb4bf4ecf559d
--- /dev/null
+++ b/flang/include/flang/Optimizer/Transforms/RuntimeFunctions.inc
@@ -0,0 +1,111 @@
+//===-- Optimizer/Transforms/RuntimeFunctions.inc ---------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef KNOWN_IO_FUNC
+#error "Define KNOWN_IO_FUNC before including this file"
+#endif
+#ifndef KNOWN_RUNTIME_FUNC
+#error "Define KNOWN_RUNTIME_FUNC before including this file"
+#endif
+
+// Fortran runtime functions that SetRuntimeCallAttributesPass recognizes.
+// WARNING: if you add a function entry here, you must make sure
+// that the attribute computation callbacks that end up being
+// used are correct for this function. If needed, add
+// specializations for the types that provide attribute
+// computation callbacks in SetRuntimeCallAttributesPass.
+
+// clang-format off
+KNOWN_IO_FUNC(BeginBackspace),
+KNOWN_IO_FUNC(BeginClose),
+KNOWN_IO_FUNC(BeginEndfile),
+KNOWN_IO_FUNC(BeginExternalFormattedInput),
+KNOWN_IO_FUNC(BeginExternalFormattedOutput),
+KNOWN_IO_FUNC(BeginExternalListInput),
+KNOWN_IO_FUNC(BeginExternalListOutput),
+KNOWN_IO_FUNC(BeginFlush),
+KNOWN_IO_FUNC(BeginInquireFile),
+KNOWN_IO_FUNC(BeginInquireIoLength),
+KNOWN_IO_FUNC(BeginInquireUnit),
+KNOWN_IO_FUNC(BeginInternalArrayFormattedInput),
+KNOWN_IO_FUNC(BeginInternalArrayFormattedOutput),
+KNOWN_IO_FUNC(BeginInternalArrayListInput),
+KNOWN_IO_FUNC(BeginInternalArrayListOutput),
+KNOWN_IO_FUNC(BeginInternalFormattedInput),
+KNOWN_IO_FUNC(BeginInternalFormattedOutput),
+KNOWN_IO_FUNC(BeginInternalListInput),
+KNOWN_IO_FUNC(BeginInternalListOutput),
+KNOWN_IO_FUNC(BeginOpenNewUnit),
+KNOWN_IO_FUNC(BeginOpenUnit),
+KNOWN_IO_FUNC(BeginRewind),
+KNOWN_IO_FUNC(BeginUnformattedInput),
+KNOWN_IO_FUNC(BeginUnformattedOutput),
+KNOWN_IO_FUNC(BeginWait),
+KNOWN_IO_FUNC(BeginWaitAll),
+KNOWN_IO_FUNC(CheckUnitNumberInRange128),
+KNOWN_IO_FUNC(CheckUnitNumberInRange64),
+KNOWN_IO_FUNC(EnableHandlers),
+KNOWN_IO_FUNC(EndIoStatement),
+KNOWN_IO_FUNC(GetAsynchronousId),
+KNOWN_IO_FUNC(GetIoLength),
+KNOWN_IO_FUNC(GetIoMsg),
+KNOWN_IO_FUNC(GetNewUnit),
+KNOWN_IO_FUNC(GetSize),
+KNOWN_IO_FUNC(InputAscii),
+KNOWN_IO_FUNC(InputComplex32),
+KNOWN_IO_FUNC(InputComplex64),
+KNOWN_IO_FUNC(InputDerivedType),
+KNOWN_IO_FUNC(InputDescriptor),
+KNOWN_IO_FUNC(InputInteger),
+KNOWN_IO_FUNC(InputLogical),
+KNOWN_IO_FUNC(InputNamelist),
+KNOWN_IO_FUNC(InputReal32),
+KNOWN_IO_FUNC(InputReal64),
+KNOWN_IO_FUNC(InquireCharacter),
+KNOWN_IO_FUNC(InquireInteger64),
+KNOWN_IO_FUNC(InquireLogical),
+KNOWN_IO_FUNC(InquirePendingId),
+KNOWN_IO_FUNC(OutputAscii),
+KNOWN_IO_FUNC(OutputComplex32),
+KNOWN_IO_FUNC(OutputComplex64),
+KNOWN_IO_FUNC(OutputDerivedType),
+KNOWN_IO_FUNC(OutputDescriptor),
+KNOWN_IO_FUNC(OutputInteger128),
+KNOWN_IO_FUNC(OutputInteger16),
+KNOWN_IO_FUNC(OutputInteger32),
+KNOWN_IO_FUNC(OutputInteger64),
+KNOWN_IO_FUNC(OutputInteger8),
+KNOWN_IO_FUNC(OutputLogical),
+KNOWN_IO_FUNC(OutputNamelist),
+KNOWN_IO_FUNC(OutputReal32),
+KNOWN_IO_FUNC(OutputReal64),
+KNOWN_IO_FUNC(SetAccess),
+KNOWN_IO_FUNC(SetAction),
+KNOWN_IO_FUNC(SetAdvance),
+KNOWN_IO_FUNC(SetAsynchronous),
+KNOWN_IO_FUNC(SetBlank),
+KNOWN_IO_FUNC(SetCarriagecontrol),
+KNOWN_IO_FUNC(SetConvert),
+KNOWN_IO_FUNC(SetDecimal),
+KNOWN_IO_FUNC(SetDelim),
+KNOWN_IO_FUNC(SetEncoding),
+KNOWN_IO_FUNC(SetFile),
+KNOWN_IO_FUNC(SetForm),
+KNOWN_IO_FUNC(SetPad),
+KNOWN_IO_FUNC(SetPos),
+KNOWN_IO_FUNC(SetPosition),
+KNOWN_IO_FUNC(SetRec),
+KNOWN_IO_FUNC(SetRecl),
+KNOWN_IO_FUNC(SetRound),
+KNOWN_IO_FUNC(SetSign),
+KNOWN_IO_FUNC(SetStatus)
+
+// clang-format on
+
+#undef KNOWN_IO_FUNC
+#undef KNOWN_RUNTIME_FUNC
diff --git a/flang/lib/Lower/IO.cpp b/flang/lib/Lower/IO.cpp
index 75453721d91a2..35068f0519cbd 100644
--- a/flang/lib/Lower/IO.cpp
+++ b/flang/lib/Lower/IO.cpp
@@ -43,35 +43,6 @@
#define DEBUG_TYPE "flang-lower-io"
-// Define additional runtime type models specific to IO.
-namespace fir::runtime {
-template <>
-constexpr TypeBuilderFunc getModel<Fortran::runtime::io::IoStatementState *>() {
- return getModel<char *>();
-}
-template <>
-constexpr TypeBuilderFunc getModel<Fortran::runtime::io::Iostat>() {
- return [](mlir::MLIRContext *context) -> mlir::Type {
- return mlir::IntegerType::get(context,
- 8 * sizeof(Fortran::runtime::io::Iostat));
- };
-}
-template <>
-constexpr TypeBuilderFunc
-getModel<const Fortran::runtime::io::NamelistGroup &>() {
- return [](mlir::MLIRContext *context) -> mlir::Type {
- return fir::ReferenceType::get(mlir::TupleType::get(context));
- };
-}
-template <>
-constexpr TypeBuilderFunc
-getModel<const Fortran::runtime::io::NonTbpDefinedIoTable *>() {
- return [](mlir::MLIRContext *context) -> mlir::Type {
- return fir::ReferenceType::get(mlir::TupleType::get(context));
- };
-}
-} // namespace fir::runtime
-
using namespace Fortran::runtime::io;
#define mkIOKey(X) FirmkKey(IONAME(X))
@@ -172,22 +143,6 @@ inline int64_t getLength(mlir::Type argTy) {
return mlir::cast<fir::SequenceType>(argTy).getShape()[0];
}
-/// Get (or generate) the MLIR FuncOp for a given IO runtime function.
-template <typename E>
-static mlir::func::FuncOp getIORuntimeFunc(mlir::Location loc,
- fir::FirOpBuilder &builder) {
- llvm::StringRef name = getName<E>();
- mlir::func::FuncOp func = builder.getNamedFunction(name);
- if (func)
- return func;
- auto funTy = getTypeModel<E>()(builder.getContext());
- func = builder.createFunction(loc, name, funTy);
- func->setAttr(fir::FIROpsDialect::getFirRuntimeAttrName(),
- builder.getUnitAttr());
- func->setAttr("fir.io", builder.getUnitAttr());
- return func;
-}
-
/// Generate calls to end an IO statement. Return the IOSTAT value, if any.
/// It is the caller's responsibility to generate branches on that value.
static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter,
@@ -197,7 +152,7 @@ static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter,
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
if (csi.ioMsg) {
mlir::func::FuncOp getIoMsg =
- getIORuntimeFunc<mkIOKey(GetIoMsg)>(loc, builder);
+ fir::runtime::getIORuntimeFunc<mkIOKey(GetIoMsg)>(loc, builder);
builder.create<fir::CallOp>(
loc, getIoMsg,
mlir::ValueRange{
@@ -208,7 +163,7 @@ static mlir::Value genEndIO(Fortran::lower::AbstractConverter &converter,
fir::getLen(*csi.ioMsg))});
}
mlir::func::FuncOp endIoStatement =
- getIORuntimeFunc<mkIOKey(EndIoStatement)>(loc, builder);
+ fir::runtime::getIORuntimeFunc<mkIOKey(EndIoStatement)>(loc, builder);
auto call = builder.create<fir::CallOp>(loc, endIoStatement,
mlir::ValueRange{cookie});
mlir::Value iostat = call.getResult(0);
@@ -659,45 +614,57 @@ static mlir::func::FuncOp getOutputFunc(mlir::Location loc,
fir::FirOpBuilder &builder,
mlir::Type type, bool isFormatted) {
if (mlir::isa<fir::RecordType>(fir::unwrapPassByRefType(type)))
- return getIORuntimeFunc<mkIOKey(OutputDerivedType)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputDerivedType)>(loc,
+ builder);
if (!isFormatted)
- return getIORuntimeFunc<mkIOKey(OutputDescriptor)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputDescriptor)>(loc,
+ builder);
if (auto ty = mlir::dyn_cast<mlir::IntegerType>(type)) {
if (!ty.isUnsigned()) {
switch (ty.getWidth()) {
case 1:
- return getIORuntimeFunc<mkIOKey(OutputLogical)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputLogical)>(loc,
+ builder);
case 8:
- return getIORuntimeFunc<mkIOKey(OutputInteger8)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputInteger8)>(loc,
+ builder);
case 16:
- return getIORuntimeFunc<mkIOKey(OutputInteger16)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputInteger16)>(
+ loc, builder);
case 32:
- return getIORuntimeFunc<mkIOKey(OutputInteger32)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputInteger32)>(
+ loc, builder);
case 64:
- return getIORuntimeFunc<mkIOKey(OutputInteger64)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputInteger64)>(
+ loc, builder);
case 128:
- return getIORuntimeFunc<mkIOKey(OutputInteger128)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputInteger128)>(
+ loc, builder);
}
llvm_unreachable("unknown OutputInteger kind");
}
}
if (auto ty = mlir::dyn_cast<mlir::FloatType>(type)) {
if (auto width = ty.getWidth(); width == 32)
- return getIORuntimeFunc<mkIOKey(OutputReal32)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputReal32)>(loc,
+ builder);
else if (width == 64)
- return getIORuntimeFunc<mkIOKey(OutputReal64)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputReal64)>(loc,
+ builder);
}
auto kindMap = fir::getKindMapping(builder.getModule());
if (auto ty = mlir::dyn_cast<mlir::ComplexType>(type)) {
// COMPLEX(KIND=k) corresponds to a pair of REAL(KIND=k).
auto width = mlir::cast<mlir::FloatType>(ty.getElementType()).getWidth();
if (width == 32)
- return getIORuntimeFunc<mkIOKey(OutputComplex32)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputComplex32)>(loc,
+ builder);
else if (width == 64)
- return getIORuntimeFunc<mkIOKey(OutputComplex64)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputComplex64)>(loc,
+ builder);
}
if (mlir::isa<fir::LogicalType>(type))
- return getIORuntimeFunc<mkIOKey(OutputLogical)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputLogical)>(loc, builder);
if (fir::factory::CharacterExprHelper::isCharacterScalar(type)) {
// TODO: What would it mean if the default CHARACTER KIND is set to a wide
// character encoding scheme? How do we handle UTF-8? Is it a distinct KIND
@@ -706,9 +673,10 @@ static mlir::func::FuncOp getOutputFunc(mlir::Location loc,
auto asciiKind = kindMap.defaultCharacterKind();
if (kindMap.getCharacterBitsize(asciiKind) == 8 &&
fir::factory::CharacterExprHelper::getCharacterKind(type) == asciiKind)
- return getIORuntimeFunc<mkIOKey(OutputAscii)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputAscii)>(loc, builder);
}
- return getIORuntimeFunc<mkIOKey(OutputDescriptor)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(OutputDescriptor)>(loc,
+ builder);
}
/// Generate a sequence of output data transfer calls.
@@ -778,39 +746,46 @@ static mlir::func::FuncOp getInputFunc(mlir::Location loc,
fir::FirOpBuilder &builder,
mlir::Type type, bool isFormatted) {
if (mlir::isa<fir::RecordType>(fir::unwrapPassByRefType(type)))
- return getIORuntimeFunc<mkIOKey(InputDerivedType)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(InputDerivedType)>(loc,
+ builder);
if (!isFormatted)
- return getIORuntimeFunc<mkIOKey(InputDescriptor)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(InputDescriptor)>(loc,
+ builder);
if (auto ty = mlir::dyn_cast<mlir::IntegerType>(type)) {
if (type.isUnsignedInteger())
- return getIORuntimeFunc<mkIOKey(InputDescriptor)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(InputDescriptor)>(loc,
+ builder);
return ty.getWidth() == 1
- ? getIORuntimeFunc<mkIOKey(InputLogical)>(loc, builder)
- : getIORuntimeFunc<mkIOKey(InputInteger)>(loc, builder);
+ ? fir::runtime::getIORuntimeFunc<mkIOKey(InputLogical)>(loc,
+ builder)
+ : fir::runtime::getIORuntimeFunc<mkIOKey(InputInteger)>(loc,
+ builder);
}
if (auto ty = mlir::dyn_cast<mlir::FloatType>(type)) {
if (auto width = ty.getWidth(); width == 32)
- return getIORuntimeFunc<mkIOKey(InputReal32)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(InputReal32)>(loc, builder);
else if (width == 64)
- return getIORuntimeFunc<mkIOKey(InputReal64)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(InputReal64)>(loc, builder);
}
auto kindMap = fir::getKindMapping(builder.getModule());
if (auto ty = mlir::dyn_cast<mlir::ComplexType>(type)) {
auto width = mlir::cast<mlir::FloatType>(ty.getElementType()).getWidth();
if (width == 32)
- return getIORuntimeFunc<mkIOKey(InputComplex32)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(InputComplex32)>(loc,
+ builder);
else if (width == 64)
- return getIORuntimeFunc<mkIOKey(InputComplex64)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(InputComplex64)>(loc,
+ builder);
}
if (mlir::isa<fir::LogicalType>(type))
- return getIORuntimeFunc<mkIOKey(InputLogical)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(InputLogical)>(loc, builder);
if (fir::factory::CharacterExprHelper::isCharacterScalar(type)) {
auto asciiKind = kindMap.defaultCharacterKind();
if (kindMap.getCharacterBitsize(asciiKind) == 8 &&
fir::factory::CharacterExprHelper::getCharacterKind(type) == asciiKind)
- return getIORuntimeFunc<mkIOKey(InputAscii)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(InputAscii)>(loc, builder);
}
- return getIORuntimeFunc<mkIOKey(InputDescriptor)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(InputDescriptor)>(loc, builder);
}
/// Interpret the lowest byte of a LOGICAL and store that value into the full
@@ -1145,7 +1120,7 @@ mlir::Value genIntIOOption(Fortran::lower::AbstractConverter &converter,
const B &spec) {
Fortran::lower::StatementContext localStatementCtx;
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
- mlir::func::FuncOp ioFunc = getIORuntimeFunc<A>(loc, builder);
+ mlir::func::FuncOp ioFunc = fir::runtime::getIORuntimeFunc<A>(loc, builder);
mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
mlir::Value expr = fir::getBase(converter.genExprValue(
loc, Fortran::semantics::GetExpr(spec.v), localStatementCtx));
@@ -1162,7 +1137,7 @@ mlir::Value genCharIOOption(Fortran::lower::AbstractConverter &converter,
const B &spec) {
Fortran::lower::StatementContext localStatementCtx;
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
- mlir::func::FuncOp ioFunc = getIORuntimeFunc<A>(loc, builder);
+ mlir::func::FuncOp ioFunc = fir::runtime::getIORuntimeFunc<A>(loc, builder);
mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
std::tuple<mlir::Value, mlir::Value, mlir::Value> tup =
lowerStringLit(converter, loc, localStatementCtx, spec,
@@ -1194,7 +1169,8 @@ mlir::Value genIOOption<Fortran::parser::FileNameExpr>(
Fortran::lower::StatementContext localStatementCtx;
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
// has an extra KIND argument
- mlir::func::FuncOp ioFunc = getIORuntimeFunc<mkIOKey(SetFile)>(loc, builder);
+ mlir::func::FuncOp ioFunc =
+ fir::runtime::getIORuntimeFunc<mkIOKey(SetFile)>(loc, builder);
mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
std::tuple<mlir::Value, mlir::Value, mlir::Value> tup =
lowerStringLit(converter, loc, localStatementCtx, spec,
@@ -1212,46 +1188,48 @@ mlir::Value genIOOption<Fortran::parser::ConnectSpec::CharExpr>(
mlir::func::FuncOp ioFunc;
switch (std::get<Fortran::parser::ConnectSpec::CharExpr::Kind>(spec.t)) {
case Fortran::parser::ConnectSpec::CharExpr::Kind::Access:
- ioFunc = getIORuntimeFunc<mkIOKey(SetAccess)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetAccess)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Action:
- ioFunc = getIORuntimeFunc<mkIOKey(SetAction)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetAction)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Asynchronous:
- ioFunc = getIORuntimeFunc<mkIOKey(SetAsynchronous)>(loc, builder);
+ ioFunc =
+ fir::runtime::getIORuntimeFunc<mkIOKey(SetAsynchronous)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Blank:
- ioFunc = getIORuntimeFunc<mkIOKey(SetBlank)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetBlank)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Decimal:
- ioFunc = getIORuntimeFunc<mkIOKey(SetDecimal)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetDecimal)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Delim:
- ioFunc = getIORuntimeFunc<mkIOKey(SetDelim)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetDelim)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Encoding:
- ioFunc = getIORuntimeFunc<mkIOKey(SetEncoding)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetEncoding)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Form:
- ioFunc = getIORuntimeFunc<mkIOKey(SetForm)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetForm)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Pad:
- ioFunc = getIORuntimeFunc<mkIOKey(SetPad)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetPad)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Position:
- ioFunc = getIORuntimeFunc<mkIOKey(SetPosition)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetPosition)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Round:
- ioFunc = getIORuntimeFunc<mkIOKey(SetRound)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetRound)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Sign:
- ioFunc = getIORuntimeFunc<mkIOKey(SetSign)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetSign)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Carriagecontrol:
- ioFunc = getIORuntimeFunc<mkIOKey(SetCarriagecontrol)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetCarriagecontrol)>(
+ loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Convert:
- ioFunc = getIORuntimeFunc<mkIOKey(SetConvert)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetConvert)>(loc, builder);
break;
case Fortran::parser::ConnectSpec::CharExpr::Kind::Dispose:
TODO(loc, "DISPOSE not part of the runtime::io interface");
@@ -1289,25 +1267,25 @@ mlir::Value genIOOption<Fortran::parser::IoControlSpec::CharExpr>(
mlir::func::FuncOp ioFunc;
switch (std::get<Fortran::parser::IoControlSpec::CharExpr::Kind>(spec.t)) {
case Fortran::parser::IoControlSpec::CharExpr::Kind::Advance:
- ioFunc = getIORuntimeFunc<mkIOKey(SetAdvance)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetAdvance)>(loc, builder);
break;
case Fortran::parser::IoControlSpec::CharExpr::Kind::Blank:
- ioFunc = getIORuntimeFunc<mkIOKey(SetBlank)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetBlank)>(loc, builder);
break;
case Fortran::parser::IoControlSpec::CharExpr::Kind::Decimal:
- ioFunc = getIORuntimeFunc<mkIOKey(SetDecimal)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetDecimal)>(loc, builder);
break;
case Fortran::parser::IoControlSpec::CharExpr::Kind::Delim:
- ioFunc = getIORuntimeFunc<mkIOKey(SetDelim)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetDelim)>(loc, builder);
break;
case Fortran::parser::IoControlSpec::CharExpr::Kind::Pad:
- ioFunc = getIORuntimeFunc<mkIOKey(SetPad)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetPad)>(loc, builder);
break;
case Fortran::parser::IoControlSpec::CharExpr::Kind::Round:
- ioFunc = getIORuntimeFunc<mkIOKey(SetRound)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetRound)>(loc, builder);
break;
case Fortran::parser::IoControlSpec::CharExpr::Kind::Sign:
- ioFunc = getIORuntimeFunc<mkIOKey(SetSign)>(loc, builder);
+ ioFunc = fir::runtime::getIORuntimeFunc<mkIOKey(SetSign)>(loc, builder);
break;
}
Fortran::lower::StatementContext localStatementCtx;
@@ -1351,7 +1329,8 @@ static void genIOGetVar(Fortran::lower::AbstractConverter &converter,
mlir::Location loc, mlir::Value cookie,
const VAR &parserVar) {
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
- mlir::func::FuncOp ioFunc = getIORuntimeFunc<IoRuntimeKey>(loc, builder);
+ mlir::func::FuncOp ioFunc =
+ fir::runtime::getIORuntimeFunc<IoRuntimeKey>(loc, builder);
mlir::Value value =
builder.create<fir::CallOp>(loc, ioFunc, mlir::ValueRange{cookie})
.getResult(0);
@@ -1478,7 +1457,7 @@ genConditionHandlerCall(Fortran::lower::AbstractConverter &converter,
return;
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::func::FuncOp enableHandlers =
- getIORuntimeFunc<mkIOKey(EnableHandlers)>(loc, builder);
+ fir::runtime::getIORuntimeFunc<mkIOKey(EnableHandlers)>(loc, builder);
mlir::Type boolType = enableHandlers.getFunctionType().getInput(1);
auto boolValue = [&](bool specifierIsPresent) {
return builder.create<mlir::arith::ConstantOp>(
@@ -1793,9 +1772,10 @@ static mlir::Value genIOUnitNumber(Fortran::lower::AbstractConverter &converter,
if (rawUnitWidth > runtimeArgWidth) {
mlir::func::FuncOp check =
rawUnitWidth <= 64
- ? getIORuntimeFunc<mkIOKey(CheckUnitNumberInRange64)>(loc, builder)
- : getIORuntimeFunc<mkIOKey(CheckUnitNumberInRange128)>(loc,
- builder);
+ ? fir::runtime::getIORuntimeFunc<mkIOKey(CheckUnitNumberInRange64)>(
+ loc, builder)
+ : fir::runtime::getIORuntimeFunc<mkIOKey(
+ CheckUnitNumberInRange128)>(loc, builder);
mlir::FunctionType funcTy = check.getFunctionType();
llvm::SmallVector<mlir::Value> args;
args.push_back(builder.createConvert(loc, funcTy.getInput(0), rawUnit));
@@ -1868,7 +1848,8 @@ static mlir::Value genBasicIOStmt(Fortran::lower::AbstractConverter &converter,
Fortran::lower::StatementContext stmtCtx;
mlir::Location loc = converter.getCurrentLocation();
ConditionSpecInfo csi = lowerErrorSpec(converter, loc, stmt.v);
- mlir::func::FuncOp beginFunc = getIORuntimeFunc<K>(loc, builder);
+ mlir::func::FuncOp beginFunc =
+ fir::runtime::getIORuntimeFunc<K>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
mlir::Value unit = genIOUnitNumber(
converter, loc, getExpr<Fortran::parser::FileUnitNumber>(stmt),
@@ -1922,7 +1903,7 @@ genNewunitSpec(Fortran::lower::AbstractConverter &converter, mlir::Location loc,
Fortran::lower::StatementContext stmtCtx;
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::func::FuncOp ioFunc =
- getIORuntimeFunc<mkIOKey(GetNewUnit)>(loc, builder);
+ fir::runtime::getIORuntimeFunc<mkIOKey(GetNewUnit)>(loc, builder);
mlir::FunctionType ioFuncTy = ioFunc.getFunctionType();
const auto *var = Fortran::semantics::GetExpr(newunit->v);
mlir::Value addr = builder.createConvert(
@@ -1947,7 +1928,8 @@ Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter,
ConditionSpecInfo csi = lowerErrorSpec(converter, loc, stmt.v);
bool hasNewunitSpec = false;
if (hasSpec<Fortran::parser::FileUnitNumber>(stmt)) {
- beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(loc, builder);
+ beginFunc =
+ fir::runtime::getIORuntimeFunc<mkIOKey(BeginOpenUnit)>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
mlir::Value unit = genIOUnitNumber(
converter, loc, getExpr<Fortran::parser::FileUnitNumber>(stmt),
@@ -1958,7 +1940,8 @@ Fortran::lower::genOpenStatement(Fortran::lower::AbstractConverter &converter,
} else {
hasNewunitSpec = hasSpec<Fortran::parser::ConnectSpec::Newunit>(stmt);
assert(hasNewunitSpec && "missing unit specifier");
- beginFunc = getIORuntimeFunc<mkIOKey(BeginOpenNewUnit)>(loc, builder);
+ beginFunc =
+ fir::runtime::getIORuntimeFunc<mkIOKey(BeginOpenNewUnit)>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
beginArgs.push_back(locToFilename(converter, loc, beginFuncTy.getInput(0)));
beginArgs.push_back(locToLineNo(converter, loc, beginFuncTy.getInput(1)));
@@ -1990,8 +1973,9 @@ Fortran::lower::genWaitStatement(Fortran::lower::AbstractConverter &converter,
ConditionSpecInfo csi = lowerErrorSpec(converter, loc, stmt.v);
bool hasId = hasSpec<Fortran::parser::IdExpr>(stmt);
mlir::func::FuncOp beginFunc =
- hasId ? getIORuntimeFunc<mkIOKey(BeginWait)>(loc, builder)
- : getIORuntimeFunc<mkIOKey(BeginWaitAll)>(loc, builder);
+ hasId
+ ? fir::runtime::getIORuntimeFunc<mkIOKey(BeginWait)>(loc, builder)
+ : fir::runtime::getIORuntimeFunc<mkIOKey(BeginWaitAll)>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
mlir::Value unit = genIOUnitNumber(
converter, loc, getExpr<Fortran::parser::FileUnitNumber>(stmt),
@@ -2036,45 +2020,49 @@ getBeginDataTransferFunc(mlir::Location loc, fir::FirOpBuilder &builder,
if (isInternal) {
if (isInternalWithDesc) {
if (isListOrNml)
- return getIORuntimeFunc<mkIOKey(BeginInternalArrayListInput)>(
- loc, builder);
- return getIORuntimeFunc<mkIOKey(BeginInternalArrayFormattedInput)>(
- loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(
+ BeginInternalArrayListInput)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(
+ BeginInternalArrayFormattedInput)>(loc, builder);
}
if (isListOrNml)
- return getIORuntimeFunc<mkIOKey(BeginInternalListInput)>(loc,
- builder);
- return getIORuntimeFunc<mkIOKey(BeginInternalFormattedInput)>(loc,
- builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(
+ BeginInternalListInput)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(
+ BeginInternalFormattedInput)>(loc, builder);
}
if (isListOrNml)
- return getIORuntimeFunc<mkIOKey(BeginExternalListInput)>(loc, builder);
- return getIORuntimeFunc<mkIOKey(BeginExternalFormattedInput)>(loc,
- builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(BeginExternalListInput)>(
+ loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(
+ BeginExternalFormattedInput)>(loc, builder);
}
- return getIORuntimeFunc<mkIOKey(BeginUnformattedInput)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(BeginUnformattedInput)>(
+ loc, builder);
} else {
if (isFormatted || isListOrNml) {
if (isInternal) {
if (isInternalWithDesc) {
if (isListOrNml)
- return getIORuntimeFunc<mkIOKey(BeginInternalArrayListOutput)>(
- loc, builder);
- return getIORuntimeFunc<mkIOKey(BeginInternalArrayFormattedOutput)>(
- loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(
+ BeginInternalArrayListOutput)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(
+ BeginInternalArrayFormattedOutput)>(loc, builder);
}
if (isListOrNml)
- return getIORuntimeFunc<mkIOKey(BeginInternalListOutput)>(loc,
- builder);
- return getIORuntimeFunc<mkIOKey(BeginInternalFormattedOutput)>(loc,
- builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(
+ BeginInternalListOutput)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(
+ BeginInternalFormattedOutput)>(loc, builder);
}
if (isListOrNml)
- return getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(loc, builder);
- return getIORuntimeFunc<mkIOKey(BeginExternalFormattedOutput)>(loc,
- builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(BeginExternalListOutput)>(
+ loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(
+ BeginExternalFormattedOutput)>(loc, builder);
}
- return getIORuntimeFunc<mkIOKey(BeginUnformattedOutput)>(loc, builder);
+ return fir::runtime::getIORuntimeFunc<mkIOKey(BeginUnformattedOutput)>(
+ loc, builder);
}
}
@@ -2201,19 +2189,21 @@ genDataTransferStmt(Fortran::lower::AbstractConverter &converter,
// Generate data transfer list calls.
if constexpr (isInput) { // READ
if (isNml)
- genNamelistIO(converter, cookie,
- getIORuntimeFunc<mkIOKey(InputNamelist)>(loc, builder),
- *getIOControl<Fortran::parser::Name>(stmt)->symbol,
- csi.hasTransferConditionSpec(), ok, stmtCtx);
+ genNamelistIO(
+ converter, cookie,
+ fir::runtime::getIORuntimeFunc<mkIOKey(InputNamelist)>(loc, builder),
+ *getIOControl<Fortran::parser::Name>(stmt)->symbol,
+ csi.hasTransferConditionSpec(), ok, stmtCtx);
else
genInputItemList(converter, cookie, stmt.items, isFormatted,
csi.hasTransferConditionSpec(), ok, /*inLoop=*/false);
} else if constexpr (std::is_same_v<A, Fortran::parser::WriteStmt>) {
if (isNml)
- genNamelistIO(converter, cookie,
- getIORuntimeFunc<mkIOKey(OutputNamelist)>(loc, builder),
- *getIOControl<Fortran::parser::Name>(stmt)->symbol,
- csi.hasTransferConditionSpec(), ok, stmtCtx);
+ genNamelistIO(
+ converter, cookie,
+ fir::runtime::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,
@@ -2305,7 +2295,7 @@ mlir::Value genInquireSpec<Fortran::parser::InquireSpec::CharVar>(
return {};
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::func::FuncOp specFunc =
- getIORuntimeFunc<mkIOKey(InquireCharacter)>(loc, builder);
+ fir::runtime::getIORuntimeFunc<mkIOKey(InquireCharacter)>(loc, builder);
mlir::FunctionType specFuncTy = specFunc.getFunctionType();
const auto *varExpr = Fortran::semantics::GetExpr(
std::get<Fortran::parser::ScalarDefaultCharVariable>(var.t));
@@ -2335,7 +2325,7 @@ mlir::Value genInquireSpec<Fortran::parser::InquireSpec::IntVar>(
return {};
fir::FirOpBuilder &builder = converter.getFirOpBuilder();
mlir::func::FuncOp specFunc =
- getIORuntimeFunc<mkIOKey(InquireInteger64)>(loc, builder);
+ fir::runtime::getIORuntimeFunc<mkIOKey(InquireInteger64)>(loc, builder);
mlir::FunctionType specFuncTy = specFunc.getFunctionType();
const auto *varExpr = Fortran::semantics::GetExpr(
std::get<Fortran::parser::ScalarIntVariable>(var.t));
@@ -2372,8 +2362,10 @@ mlir::Value genInquireSpec<Fortran::parser::InquireSpec::LogVar>(
idExpr &&
logVarKind == Fortran::parser::InquireSpec::LogVar::Kind::Pending;
mlir::func::FuncOp specFunc =
- pendId ? getIORuntimeFunc<mkIOKey(InquirePendingId)>(loc, builder)
- : getIORuntimeFunc<mkIOKey(InquireLogical)>(loc, builder);
+ pendId ? fir::runtime::getIORuntimeFunc<mkIOKey(InquirePendingId)>(
+ loc, builder)
+ : fir::runtime::getIORuntimeFunc<mkIOKey(InquireLogical)>(loc,
+ builder);
mlir::FunctionType specFuncTy = specFunc.getFunctionType();
mlir::Value addr = fir::getBase(converter.genExprAddr(
loc,
@@ -2458,7 +2450,8 @@ mlir::Value Fortran::lower::genInquireStatement(
// Make one of three BeginInquire calls.
if (inquireFileUnit()) {
// Inquire by unit -- [UNIT=]file-unit-number.
- beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireUnit)>(loc, builder);
+ beginFunc =
+ fir::runtime::getIORuntimeFunc<mkIOKey(BeginInquireUnit)>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
mlir::Value unit = genIOUnitNumber(converter, loc, exprPair.first,
beginFuncTy.getInput(0), csi, stmtCtx);
@@ -2466,7 +2459,8 @@ mlir::Value Fortran::lower::genInquireStatement(
locToLineNo(converter, loc, beginFuncTy.getInput(2))};
} else if (inquireFileName()) {
// Inquire by file -- FILE=file-name-expr.
- beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireFile)>(loc, builder);
+ beginFunc =
+ fir::runtime::getIORuntimeFunc<mkIOKey(BeginInquireFile)>(loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
fir::ExtendedValue file =
converter.genExprAddr(loc, exprPair.first, stmtCtx);
@@ -2480,7 +2474,8 @@ mlir::Value Fortran::lower::genInquireStatement(
const auto *ioLength =
std::get_if<Fortran::parser::InquireStmt::Iolength>(&stmt.u);
assert(ioLength && "must have an IOLENGTH specifier");
- beginFunc = getIORuntimeFunc<mkIOKey(BeginInquireIoLength)>(loc, builder);
+ beginFunc = fir::runtime::getIORuntimeFunc<mkIOKey(BeginInquireIoLength)>(
+ loc, builder);
mlir::FunctionType beginFuncTy = beginFunc.getFunctionType();
beginArgs = {locToFilename(converter, loc, beginFuncTy.getInput(0)),
locToLineNo(converter, loc, beginFuncTy.getInput(1))};
@@ -2499,7 +2494,10 @@ mlir::Value Fortran::lower::genInquireStatement(
mlir::Value length =
builder
.create<fir::CallOp>(
- loc, getIORuntimeFunc<mkIOKey(GetIoLength)>(loc, builder), args)
+ loc,
+ fir::runtime::getIORuntimeFunc<mkIOKey(GetIoLength)>(loc,
+ builder),
+ args)
.getResult(0);
mlir::Value length1 =
builder.createConvert(loc, converter.genType(*ioLengthVar), length);
diff --git a/flang/lib/Optimizer/Builder/FIRBuilder.cpp b/flang/lib/Optimizer/Builder/FIRBuilder.cpp
index d9779c46ae79e..0f338270fc983 100644
--- a/flang/lib/Optimizer/Builder/FIRBuilder.cpp
+++ b/flang/lib/Optimizer/Builder/FIRBuilder.cpp
@@ -16,6 +16,7 @@
#include "flang/Optimizer/Builder/Todo.h"
#include "flang/Optimizer/Dialect/CUF/CUFOps.h"
#include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROpsSupport.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "flang/Optimizer/Support/DataLayout.h"
@@ -46,6 +47,17 @@ fir::FirOpBuilder::createFunction(mlir::Location loc, mlir::ModuleOp module,
return fir::createFuncOp(loc, module, name, ty, /*attrs*/ {}, symbolTable);
}
+mlir::func::FuncOp
+fir::FirOpBuilder::createRuntimeFunction(mlir::Location loc,
+ llvm::StringRef name,
+ mlir::FunctionType ty, bool isIO) {
+ mlir::func::FuncOp func = createFunction(loc, name, ty);
+ func->setAttr(fir::FIROpsDialect::getFirRuntimeAttrName(), getUnitAttr());
+ if (isIO)
+ func->setAttr("fir.io", getUnitAttr());
+ return func;
+}
+
mlir::func::FuncOp
fir::FirOpBuilder::getNamedFunction(mlir::ModuleOp modOp,
const mlir::SymbolTable *symbolTable,
diff --git a/flang/lib/Optimizer/CodeGen/CodeGen.cpp b/flang/lib/Optimizer/CodeGen/CodeGen.cpp
index 439cc7a856236..3ebf398b21c95 100644
--- a/flang/lib/Optimizer/CodeGen/CodeGen.cpp
+++ b/flang/lib/Optimizer/CodeGen/CodeGen.cpp
@@ -17,6 +17,7 @@
#include "flang/Optimizer/CodeGen/FIROpPatterns.h"
#include "flang/Optimizer/CodeGen/TypeConverter.h"
#include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
#include "flang/Optimizer/Dialect/FIROps.h"
#include "flang/Optimizer/Dialect/FIRType.h"
#include "flang/Optimizer/Support/DataLayout.h"
@@ -591,6 +592,11 @@ struct CallOpConversion : public fir::FIROpConversion<fir::CallOp> {
matchAndRewrite(fir::CallOp call, OpAdaptor adaptor,
mlir::ConversionPatternRewriter &rewriter) const override {
llvm::SmallVector<mlir::Type> resultTys;
+ mlir::Attribute memAttr =
+ call->getAttr(fir::FIROpsDialect::getFirCallMemoryAttrName());
+ if (memAttr)
+ call->removeAttr(fir::FIROpsDialect::getFirCallMemoryAttrName());
+
for (auto r : call.getResults())
resultTys.push_back(convertType(r.getType()));
// Convert arith::FastMathFlagsAttr to LLVM::FastMathFlagsAttr.
@@ -632,6 +638,10 @@ struct CallOpConversion : public fir::FIROpConversion<fir::CallOp> {
}
if (mlir::ArrayAttr resAttrs = call.getResAttrsAttr())
llvmCall.setResAttrsAttr(resAttrs);
+
+ if (memAttr)
+ llvmCall.setMemoryEffectsAttr(
+ mlir::cast<mlir::LLVM::MemoryEffectsAttr>(memAttr));
return mlir::success();
}
};
diff --git a/flang/lib/Optimizer/Passes/Pipelines.cpp b/flang/lib/Optimizer/Passes/Pipelines.cpp
index afb50a9a79a4b..518be347fff85 100644
--- a/flang/lib/Optimizer/Passes/Pipelines.cpp
+++ b/flang/lib/Optimizer/Passes/Pipelines.cpp
@@ -211,6 +211,9 @@ void createDefaultFIROptimizerPassPipeline(mlir::PassManager &pm,
pm.addPass(fir::createSimplifyRegionLite());
pm.addPass(mlir::createCSEPass());
+ if (pc.OptLevel.isOptimizingForSpeed())
+ pm.addPass(fir::createSetRuntimeCallAttributes());
+
// Last Optimizer EP Callback
pc.invokeFIROptLastEPCallbacks(pm, pc.OptLevel);
}
diff --git a/flang/lib/Optimizer/Transforms/CMakeLists.txt b/flang/lib/Optimizer/Transforms/CMakeLists.txt
index 50994fbb21700..da4fc9cb716be 100644
--- a/flang/lib/Optimizer/Transforms/CMakeLists.txt
+++ b/flang/lib/Optimizer/Transforms/CMakeLists.txt
@@ -29,6 +29,8 @@ add_flang_library(FIRTransforms
VScaleAttr.cpp
FunctionAttr.cpp
DebugTypeGenerator.cpp
+ SetRuntimeCallAttributes.cpp
+ GenRuntimeCallsForTest.cpp
DEPENDS
CUFAttrs
diff --git a/flang/lib/Optimizer/Transforms/GenRuntimeCallsForTest.cpp b/flang/lib/Optimizer/Transforms/GenRuntimeCallsForTest.cpp
new file mode 100644
index 0000000000000..8d1d62e334d8c
--- /dev/null
+++ b/flang/lib/Optimizer/Transforms/GenRuntimeCallsForTest.cpp
@@ -0,0 +1,106 @@
+//===- GenRuntimeCallsForTest.cpp -----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+/// \file
+/// This pass is only for developers to generate declarations/calls
+/// of Fortran runtime function recognized in
+/// flang/Optimizer/Transforms/RuntimeFunctions.inc table.
+/// Sample of the generated FIR:
+/// func.func private
+/// @_FortranAioSetStatus(!fir.ref<i8>, !fir.ref<i8>, i64) ->
+/// i1 attributes {fir.io, fir.runtime}
+///
+/// func.func @test__FortranAioSetStatus(
+/// %arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+/// %0 = fir.call @_FortranAioSetStatus(%arg0, %arg1, %arg2) :
+/// (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+/// return %0 : i1
+/// }
+//===----------------------------------------------------------------------===//
+#include "flang/Common/static-multimap-view.h"
+#include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Support/InternalNames.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "flang/Runtime/io-api-consts.h"
+#include "mlir/Dialect/LLVMIR/LLVMAttrs.h"
+
+namespace fir {
+#define GEN_PASS_DEF_GENRUNTIMECALLSFORTEST
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
+#define DEBUG_TYPE "gen-runtime-calls-for-test"
+
+using namespace Fortran::runtime;
+using namespace Fortran::runtime::io;
+
+#define mkIOKey(X) FirmkKey(IONAME(X))
+#define mkRTKey(X) FirmkKey(RTNAME(X))
+
+namespace {
+class GenRuntimeCallsForTestPass
+ : public fir::impl::GenRuntimeCallsForTestBase<GenRuntimeCallsForTestPass> {
+ using GenRuntimeCallsForTestBase<
+ GenRuntimeCallsForTestPass>::GenRuntimeCallsForTestBase;
+
+public:
+ void runOnOperation() override;
+};
+} // end anonymous namespace
+
+static constexpr llvm::StringRef testPrefix = "test_";
+
+void GenRuntimeCallsForTestPass::runOnOperation() {
+ mlir::ModuleOp moduleOp = getOperation();
+ mlir::OpBuilder mlirBuilder(moduleOp.getRegion());
+ fir::FirOpBuilder builder(mlirBuilder, moduleOp);
+ mlir::Location loc = mlir::UnknownLoc::get(builder.getContext());
+
+#define KNOWN_IO_FUNC(X) \
+ fir::runtime::getIORuntimeFunc<mkIOKey(X)>(loc, builder)
+#define KNOWN_RUNTIME_FUNC(X) \
+ fir::runtime::getRuntimeFunc<mkRTKey(X)>(loc, builder)
+
+ mlir::func::FuncOp runtimeFuncsTable[] = {
+#include "flang/Optimizer/Transforms/RuntimeFunctions.inc"
+ };
+
+ if (!doGenerateCalls)
+ return;
+
+ // Generate thin wrapper functions calling the known Fortran
+ // runtime functions.
+ llvm::SmallVector<mlir::Operation *> newFuncs;
+ for (unsigned i = 0;
+ i < sizeof(runtimeFuncsTable) / sizeof(runtimeFuncsTable[0]); ++i) {
+ mlir::func::FuncOp funcOp = runtimeFuncsTable[i];
+ mlir::FunctionType funcTy = funcOp.getFunctionType();
+ std::string name = (llvm::Twine(testPrefix) + funcOp.getName()).str();
+ mlir::func::FuncOp callerFunc = builder.createFunction(loc, name, funcTy);
+ callerFunc.setVisibility(mlir::SymbolTable::Visibility::Public);
+ mlir::OpBuilder::InsertPoint insertPt = builder.saveInsertionPoint();
+
+ // Generate the wrapper function body that consists of a call and return.
+ builder.setInsertionPointToStart(callerFunc.addEntryBlock());
+ mlir::Block::BlockArgListType args = callerFunc.front().getArguments();
+ auto callOp = builder.create<fir::CallOp>(loc, funcOp, args);
+ builder.create<mlir::func::ReturnOp>(loc, callOp.getResults());
+
+ newFuncs.push_back(callerFunc.getOperation());
+ builder.restoreInsertionPoint(insertPt);
+ }
+
+ // Make sure all wrapper functions are at the beginning
+ // of the module.
+ auto moduleBegin = moduleOp.getBody()->begin();
+ for (auto func : newFuncs)
+ func->moveBefore(moduleOp.getBody(), moduleBegin);
+}
diff --git a/flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp b/flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp
new file mode 100644
index 0000000000000..5dc4f04156447
--- /dev/null
+++ b/flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp
@@ -0,0 +1,252 @@
+//===- SetRuntimeCallAttributes.cpp ---------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+/// \file
+/// SetRuntimeCallAttributesPass looks for fir.call operations
+/// that are calling into Fortran runtime, and tries to set different
+/// attributes on them to enable more optimizations in LLVM backend
+/// (granted that they are preserved all the way to LLVM IR).
+/// This pass is currently only attaching fir.call wide atttributes,
+/// such as ones corresponding to llvm.memory, nosync, nocallbac, etc.
+/// It is not designed to attach attributes to the arguments and the results
+/// of a call.
+//===----------------------------------------------------------------------===//
+#include "flang/Common/static-multimap-view.h"
+#include "flang/Optimizer/Builder/Runtime/RTBuilder.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Support/InternalNames.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "flang/Runtime/io-api-consts.h"
+#include "mlir/Dialect/LLVMIR/LLVMAttrs.h"
+
+namespace fir {
+#define GEN_PASS_DEF_SETRUNTIMECALLATTRIBUTES
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
+#define DEBUG_TYPE "set-runtime-call-attrs"
+
+using namespace Fortran::runtime;
+using namespace Fortran::runtime::io;
+
+#define mkIOKey(X) FirmkKey(IONAME(X))
+#define mkRTKey(X) FirmkKey(RTNAME(X))
+
+// Return LLVM dialect MemoryEffectsAttr for the given Fortran runtime call.
+// This function is computing a generic value of this attribute
+// by analyzing the arguments and their types.
+// It tries to figure out if an "indirect" memory access is possible
+// during this call. If it is not possible, then the memory effects
+// are:
+// * other = NoModRef
+// * argMem = ModRef
+// * inaccessibleMem = ModRef
+//
+// Otherwise, it returns an empty attribute meaning ModRef for all kinds
+// of memory.
+//
+// The attribute deduction is conservative in a sense that it applies
+// to most of the runtime calls, but it may still be incorrect for some
+// runtime calls.
+static mlir::LLVM::MemoryEffectsAttr getGenericMemoryAttr(fir::CallOp callOp) {
+ bool maybeIndirectAccess = false;
+ for (auto arg : callOp.getArgOperands()) {
+ mlir::Type argType = arg.getType();
+ if (mlir::isa<fir::BaseBoxType>(argType)) {
+ // If it is a null box, then this particular call
+ // cannot access memory indirectly through the box's
+ // base_addr.
+ auto def = arg.getDefiningOp();
+ if (!def || !mlir::isa<fir::ZeroOp>(def)) {
+ maybeIndirectAccess = true;
+ break;
+ }
+ }
+ if (auto refType = mlir::dyn_cast<fir::ReferenceType>(argType)) {
+ if (!fir::isa_trivial(refType.getElementType())) {
+ maybeIndirectAccess = true;
+ break;
+ }
+ }
+ if (auto ptrType = mlir::dyn_cast<mlir::LLVM::LLVMPointerType>(argType)) {
+ maybeIndirectAccess = true;
+ break;
+ }
+ }
+ if (!maybeIndirectAccess) {
+ return mlir::LLVM::MemoryEffectsAttr::get(
+ callOp->getContext(),
+ {/*other=*/mlir::LLVM::ModRefInfo::NoModRef,
+ /*argMem=*/mlir::LLVM::ModRefInfo::ModRef,
+ /*inaccessibleMem=*/mlir::LLVM::ModRefInfo::ModRef});
+ }
+
+ return {};
+}
+
+namespace {
+class SetRuntimeCallAttributesPass
+ : public fir::impl::SetRuntimeCallAttributesBase<
+ SetRuntimeCallAttributesPass> {
+public:
+ void runOnOperation() override;
+};
+
+// A helper to match a type against a list of types.
+template <typename T, typename... Ts>
+constexpr bool IsAny = std::disjunction_v<std::is_same<T, Ts>...>;
+} // end anonymous namespace
+
+// MemoryAttrDesc type provides get() method for computing
+// mlir::LLVM::MemoryEffectsAttr for the given Fortran runtime call.
+// If needed, add specializations for particular runtime calls.
+namespace {
+// Default implementation just uses getGenericMemoryAttr().
+// Note that it may be incorrect for some runtime calls.
+template <typename KEY, typename Enable = void>
+struct MemoryAttrDesc {
+ static mlir::LLVM::MemoryEffectsAttr get(fir::CallOp callOp) {
+ return getGenericMemoryAttr(callOp);
+ }
+};
+} // end anonymous namespace
+
+// NosyncAttrDesc type provides get() method for computing
+// LLVM nosync attribute for the given call.
+namespace {
+// Default implementation always returns LLVM nosync.
+// This should be true for the majority of the Fortran runtime calls.
+template <typename KEY, typename Enable = void>
+struct NosyncAttrDesc {
+ static std::optional<mlir::NamedAttribute> get(fir::CallOp callOp) {
+ // TODO: replace llvm.nosync with an LLVM dialect callback.
+ return mlir::NamedAttribute("llvm.nosync",
+ mlir::UnitAttr::get(callOp->getContext()));
+ }
+};
+} // end anonymous namespace
+
+// NocallbackAttrDesc type provides get() method for computing
+// LLVM nocallback attribute for the given call.
+namespace {
+// Default implementation always returns LLVM nocallback.
+// It must be specialized for Fortran runtime functions that may call
+// user functions during their execution (e.g. defined IO, assignment).
+template <typename KEY, typename Enable = void>
+struct NocallbackAttrDesc {
+ static std::optional<mlir::NamedAttribute> get(fir::CallOp callOp) {
+ // TODO: replace llvm.nocallback with an LLVM dialect callback.
+ return mlir::NamedAttribute("llvm.nocallback",
+ mlir::UnitAttr::get(callOp->getContext()));
+ }
+};
+
+// Derived types IO may call back into a Fortran module.
+// This specialization is conservative for Input/OutputDerivedType,
+// and it might be improved by checking if the NonTbpDefinedIoTable
+// pointer argument is null.
+template <typename KEY>
+struct NocallbackAttrDesc<
+ KEY, std::enable_if_t<
+ IsAny<KEY, mkIOKey(OutputDerivedType), mkIOKey(InputDerivedType),
+ mkIOKey(OutputNamelist), mkIOKey(InputNamelist)>>> {
+ static std::optional<mlir::NamedAttribute> get(fir::CallOp) {
+ return std::nullopt;
+ }
+};
+} // end anonymous namespace
+
+namespace {
+// RuntimeFunction provides different callbacks that compute values
+// of fir.call attributes for a Fortran runtime function.
+struct RuntimeFunction {
+ using MemoryAttrGeneratorTy = mlir::LLVM::MemoryEffectsAttr (*)(fir::CallOp);
+ using NamedAttrGeneratorTy =
+ std::optional<mlir::NamedAttribute> (*)(fir::CallOp);
+ using Key = std::string_view;
+ constexpr operator Key() const { return key; }
+ Key key;
+ MemoryAttrGeneratorTy memoryAttrGenerator;
+ NamedAttrGeneratorTy nosyncAttrGenerator;
+ NamedAttrGeneratorTy nocallbackAttrGenerator;
+};
+
+// Helper type to create a RuntimeFunction descriptor given
+// the KEY and a function name.
+template <typename KEY>
+struct RuntimeFactory {
+ static constexpr RuntimeFunction create(const std::string_view &name) {
+ return RuntimeFunction{name, MemoryAttrDesc<KEY>::get,
+ NosyncAttrDesc<KEY>::get,
+ NocallbackAttrDesc<KEY>::get};
+ }
+};
+} // end anonymous namespace
+
+#define KNOWN_IO_FUNC(X) RuntimeFactory<mkIOKey(X)>::create(mkIOKey(X)::name)
+#define KNOWN_RUNTIME_FUNC(X) \
+ RuntimeFactory<mkRTKey(X)>::create(mkRTKey(X)::name)
+
+// A table of RuntimeFunction descriptors for all recognized
+// Fortran runtime functions.
+static constexpr RuntimeFunction runtimeFuncsTable[] = {
+#include "flang/Optimizer/Transforms/RuntimeFunctions.inc"
+};
+
+static constexpr Fortran::common::StaticMultimapView<RuntimeFunction>
+ runtimeFuncs(runtimeFuncsTable);
+static_assert(runtimeFuncs.Verify() && "map must be sorted");
+
+// Set attributes for the given Fortran runtime call.
+// The symbolTable is used to cache the name lookups in the module.
+static void setRuntimeCallAttributes(fir::CallOp callOp,
+ mlir::SymbolTableCollection &symbolTable) {
+ auto iface = mlir::cast<mlir::CallOpInterface>(callOp.getOperation());
+ auto funcOp = mlir::dyn_cast_or_null<mlir::func::FuncOp>(
+ iface.resolveCallableInTable(&symbolTable));
+
+ if (!funcOp || !funcOp->hasAttrOfType<mlir::UnitAttr>(
+ fir::FIROpsDialect::getFirRuntimeAttrName()))
+ return;
+
+ llvm::StringRef name = funcOp.getName();
+ if (auto range = runtimeFuncs.equal_range(name);
+ range.first != range.second) {
+ // There should not be duplicate entries.
+ assert(range.first + 1 == range.second);
+ const RuntimeFunction &desc = *range.first;
+ LLVM_DEBUG(llvm::dbgs()
+ << "Identified runtime function call: " << desc.key << '\n');
+ if (mlir::LLVM::MemoryEffectsAttr memoryAttr =
+ desc.memoryAttrGenerator(callOp))
+ callOp->setAttr(fir::FIROpsDialect::getFirCallMemoryAttrName(),
+ memoryAttr);
+ if (auto attr = desc.nosyncAttrGenerator(callOp))
+ callOp->setAttr(attr->getName(), attr->getValue());
+ if (auto attr = desc.nocallbackAttrGenerator(callOp))
+ callOp->setAttr(attr->getName(), attr->getValue());
+ LLVM_DEBUG(llvm::dbgs() << "Operation with attrs: " << callOp << '\n');
+ }
+}
+
+void SetRuntimeCallAttributesPass::runOnOperation() {
+ mlir::func::FuncOp funcOp = getOperation();
+ // Exit early for declarations to skip the debug output for them.
+ if (funcOp.isDeclaration())
+ return;
+ LLVM_DEBUG(llvm::dbgs() << "=== Begin " DEBUG_TYPE " ===\n");
+ LLVM_DEBUG(llvm::dbgs() << "Func-name:" << funcOp.getSymName() << "\n");
+
+ mlir::SymbolTableCollection symbolTable;
+ funcOp.walk([&](fir::CallOp callOp) {
+ setRuntimeCallAttributes(callOp, symbolTable);
+ });
+ LLVM_DEBUG(llvm::dbgs() << "=== End " DEBUG_TYPE " ===\n");
+}
diff --git a/flang/test/Driver/mlir-pass-pipeline.f90 b/flang/test/Driver/mlir-pass-pipeline.f90
index dd46aecb3274c..740897786dd37 100644
--- a/flang/test/Driver/mlir-pass-pipeline.f90
+++ b/flang/test/Driver/mlir-pass-pipeline.f90
@@ -123,6 +123,8 @@
! ALL-NEXT: CSE
! ALL-NEXT: (S) 0 num-cse'd - Number of operations CSE'd
! ALL-NEXT: (S) 0 num-dce'd - Number of operations DCE'd
+! O2-NEXT: 'func.func' Pipeline
+! O2-NEXT: SetRuntimeCallAttributes
! ALL-NEXT: BoxedProcedurePass
! ALL-NEXT: Pipeline Collection : ['fir.global', 'func.func', 'gpu.module', 'omp.declare_reduction', 'omp.private']
diff --git a/flang/test/Fir/basic-program.fir b/flang/test/Fir/basic-program.fir
index 51e68d2157631..8b299674208fa 100644
--- a/flang/test/Fir/basic-program.fir
+++ b/flang/test/Fir/basic-program.fir
@@ -121,6 +121,8 @@ func.func @_QQmain() {
// PASSES-NEXT: CSE
// PASSES-NEXT: (S) 0 num-cse'd - Number of operations CSE'd
// PASSES-NEXT: (S) 0 num-dce'd - Number of operations DCE'd
+// PASSES-NEXT: 'func.func' Pipeline
+// PASSES-NEXT: SetRuntimeCallAttributes
// PASSES-NEXT: BoxedProcedurePass
// PASSES-NEXT: Pipeline Collection : ['fir.global', 'func.func', 'gpu.module', 'omp.declare_reduction', 'omp.private']
diff --git a/flang/test/Lower/array-temp.f90 b/flang/test/Lower/array-temp.f90
index 718aef84a4e85..6a67fb55be2a9 100644
--- a/flang/test/Lower/array-temp.f90
+++ b/flang/test/Lower/array-temp.f90
@@ -122,7 +122,7 @@ subroutine ss4(N)
! CHECK: %[[V_50:[0-9]+]] = fir.slice %[[C_1]], %[[C_2]], %[[C_1]] : (index, index, index) -> !fir.slice<1>
! CHECK: %[[V_51:[0-9]+]] = fir.embox %[[V_4]](%[[V_5]]) [%[[V_50]]] : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<2xf32>>
! CHECK: %[[V_52:[0-9]+]] = fir.convert %[[V_51:[0-9]+]] : (!fir.box<!fir.array<2xf32>>) -> !fir.box<none>
-! CHECK: %[[V_53:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_49]], %[[V_52]]) fastmath<contract> : (!fir.ref<i8>, !fir.box<none>) -> i1
+! CHECK: %[[V_53:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_49]], %[[V_52]]) fastmath<contract> {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
! CHECK: %[[V_54:[0-9]+]] = fir.load %arg0 : !fir.ref<i32>
! CHECK: %[[V_55:[0-9]+]] = arith.subi %[[V_54]], %[[C_1_i32]] : i32
! CHECK: %[[V_56:[0-9]+]] = fir.convert %[[V_55:[0-9]+]] : (i32) -> index
@@ -130,8 +130,8 @@ subroutine ss4(N)
! CHECK: %[[V_58:[0-9]+]] = fir.slice %[[V_56]], %[[V_57]], %[[C_1]] : (index, index, index) -> !fir.slice<1>
! CHECK: %[[V_59:[0-9]+]] = fir.embox %[[V_4]](%[[V_5]]) [%[[V_58]]] : (!fir.ref<!fir.array<?xf32>>, !fir.shape<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>
! CHECK: %[[V_60:[0-9]+]] = fir.convert %[[V_59:[0-9]+]] : (!fir.box<!fir.array<?xf32>>) -> !fir.box<none>
-! CHECK: %[[V_61:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_49]], %[[V_60]]) fastmath<contract> : (!fir.ref<i8>, !fir.box<none>) -> i1
-! CHECK: %[[V_62:[0-9]+]] = fir.call @_FortranAioEndIoStatement(%[[V_49]]) fastmath<contract> : (!fir.ref<i8>) -> i32
+! CHECK: %[[V_61:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_49]], %[[V_60]]) fastmath<contract> {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
+! CHECK: %[[V_62:[0-9]+]] = fir.call @_FortranAioEndIoStatement(%[[V_49]]) fastmath<contract> {{.*}}: (!fir.ref<i8>) -> i32
! CHECK: return
! CHECK: }
@@ -248,7 +248,7 @@ subroutine ss4(N)
! CHECK: %[[V_74:[0-9]+]] = fir.slice %[[C_1]], %[[C_2]], %[[C_1]], %[[C_1]], %[[C_2]], %[[C_1]] : (index, index, index, index, index, index) -> !fir.slice<2>
! CHECK: %[[V_75:[0-9]+]] = fir.embox %[[V_4]](%[[V_5]]) [%[[V_74]]] : (!fir.ref<!fir.array<2x?xf32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.box<!fir.array<?x2xf32>>
! CHECK: %[[V_76:[0-9]+]] = fir.convert %[[V_75:[0-9]+]] : (!fir.box<!fir.array<?x2xf32>>) -> !fir.box<none>
-! CHECK: %[[V_77:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_73]], %[[V_76]]) fastmath<contract> : (!fir.ref<i8>, !fir.box<none>) -> i1
+! CHECK: %[[V_77:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_73]], %[[V_76]]) fastmath<contract> {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
! CHECK: %[[V_78:[0-9]+]] = fir.load %arg0 : !fir.ref<i32>
! CHECK: %[[V_79:[0-9]+]] = arith.subi %[[V_78]], %[[C_1_i32]] : i32
! CHECK: %[[V_80:[0-9]+]] = fir.convert %[[V_79:[0-9]+]] : (i32) -> index
@@ -256,8 +256,8 @@ subroutine ss4(N)
! CHECK: %[[V_82:[0-9]+]] = fir.slice %[[C_1]], %[[C_2]], %[[C_1]], %[[V_80]], %[[V_81]], %[[C_1]] : (index, index, index, index, index, index) -> !fir.slice<2>
! CHECK: %[[V_83:[0-9]+]] = fir.embox %[[V_4]](%[[V_5]]) [%[[V_82]]] : (!fir.ref<!fir.array<2x?xf32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.box<!fir.array<?x?xf32>>
! CHECK: %[[V_84:[0-9]+]] = fir.convert %[[V_83:[0-9]+]] : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<none>
-! CHECK: %[[V_85:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_73]], %[[V_84]]) fastmath<contract> : (!fir.ref<i8>, !fir.box<none>) -> i1
-! CHECK: %[[V_86:[0-9]+]] = fir.call @_FortranAioEndIoStatement(%[[V_73]]) fastmath<contract> : (!fir.ref<i8>) -> i32
+! CHECK: %[[V_85:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_73]], %[[V_84]]) fastmath<contract> {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
+! CHECK: %[[V_86:[0-9]+]] = fir.call @_FortranAioEndIoStatement(%[[V_73]]) fastmath<contract> {{.*}}: (!fir.ref<i8>) -> i32
! CHECK: return
! CHECK: }
@@ -374,7 +374,7 @@ subroutine ss4(N)
! CHECK: %[[V_74:[0-9]+]] = fir.slice %[[C_1]], %[[C_2]], %[[C_1]], %[[C_1]], %[[C_2]], %[[C_1]] : (index, index, index, index, index, index) -> !fir.slice<2>
! CHECK: %[[V_75:[0-9]+]] = fir.embox %[[V_4]](%[[V_5]]) [%[[V_74]]] : (!fir.ref<!fir.array<?x2xf32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.box<!fir.array<2x?xf32>>
! CHECK: %[[V_76:[0-9]+]] = fir.convert %[[V_75:[0-9]+]] : (!fir.box<!fir.array<2x?xf32>>) -> !fir.box<none>
-! CHECK: %[[V_77:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_73]], %[[V_76]]) fastmath<contract> : (!fir.ref<i8>, !fir.box<none>) -> i1
+! CHECK: %[[V_77:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_73]], %[[V_76]]) fastmath<contract> {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
! CHECK: %[[V_78:[0-9]+]] = fir.load %arg0 : !fir.ref<i32>
! CHECK: %[[V_79:[0-9]+]] = arith.subi %[[V_78]], %[[C_1_i32]] : i32
! CHECK: %[[V_80:[0-9]+]] = fir.convert %[[V_79:[0-9]+]] : (i32) -> index
@@ -382,8 +382,8 @@ subroutine ss4(N)
! CHECK: %[[V_82:[0-9]+]] = fir.slice %[[V_80]], %[[V_81]], %[[C_1]], %[[C_1]], %[[C_2]], %[[C_1]] : (index, index, index, index, index, index) -> !fir.slice<2>
! CHECK: %[[V_83:[0-9]+]] = fir.embox %[[V_4]](%[[V_5]]) [%[[V_82]]] : (!fir.ref<!fir.array<?x2xf32>>, !fir.shape<2>, !fir.slice<2>) -> !fir.box<!fir.array<?x?xf32>>
! CHECK: %[[V_84:[0-9]+]] = fir.convert %[[V_83:[0-9]+]] : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<none>
-! CHECK: %[[V_85:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_73]], %[[V_84]]) fastmath<contract> : (!fir.ref<i8>, !fir.box<none>) -> i1
-! CHECK: %[[V_86:[0-9]+]] = fir.call @_FortranAioEndIoStatement(%[[V_73]]) fastmath<contract> : (!fir.ref<i8>) -> i32
+! CHECK: %[[V_85:[0-9]+]] = fir.call @_FortranAioOutputDescriptor(%[[V_73]], %[[V_84]]) fastmath<contract> {{.*}}: (!fir.ref<i8>, !fir.box<none>) -> i1
+! CHECK: %[[V_86:[0-9]+]] = fir.call @_FortranAioEndIoStatement(%[[V_73]]) fastmath<contract> {{.*}}: (!fir.ref<i8>) -> i32
! CHECK: return
! CHECK: }
diff --git a/flang/test/Transforms/set-runtime-call-attributes.fir b/flang/test/Transforms/set-runtime-call-attributes.fir
new file mode 100644
index 0000000000000..ecb2dd53ea4d5
--- /dev/null
+++ b/flang/test/Transforms/set-runtime-call-attributes.fir
@@ -0,0 +1,1039 @@
+// RUN: fir-opt -set-runtime-call-attrs %s | FileCheck %s
+
+// Test that SetRuntimeCallAttributesPass sets the expected attributes
+// on the calls of Fortran runtime functions.
+//
+// Updates in flang/Optimizer/Transforms/RuntimeFunctions.inc table
+// and in SetRuntimeCallAttributesPass may require updating this test.
+// The following commands might be used:
+// echo "module {}" | fir-opt --gen-runtime-calls-for-test="do-generate-calls" >tmp
+// fir-opt tmp -set-runtime-call-attrs | generate-test-checks.py \
+// --source tmp --source_delim_regex "func.func.*@test_" | \
+// grep -v "CHECK.*func.func.*@_Fortran"
+
+// NOTE: Assertions have been autogenerated by utils/generate-test-checks.py
+
+// The script is designed to make adding checks to
+// a test case fast, it is *not* designed to be authoritative
+// about what constitutes a good test! The CHECK should be
+// minimized and named to reflect the test intent.
+
+module {
+// CHECK-LABEL: func.func @test__FortranAioBeginBackspace(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginBackspace(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginBackspace(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginBackspace(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginClose(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginClose(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginClose(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginClose(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginEndfile(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginEndfile(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginEndfile(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginEndfile(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginExternalFormattedInput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_5:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_6:.*]] = fir.call @_FortranAioBeginExternalFormattedInput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]]) {llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64, !fir.box<none>, i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_6]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginExternalFormattedInput(%arg0: !fir.ref<i8>, %arg1: i64, %arg2: !fir.box<none>, %arg3: i32, %arg4: !fir.ref<i8>, %arg5: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginExternalFormattedInput(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) : (!fir.ref<i8>, i64, !fir.box<none>, i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginExternalFormattedOutput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_5:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_6:.*]] = fir.call @_FortranAioBeginExternalFormattedOutput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]]) {llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64, !fir.box<none>, i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_6]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginExternalFormattedOutput(%arg0: !fir.ref<i8>, %arg1: i64, %arg2: !fir.box<none>, %arg3: i32, %arg4: !fir.ref<i8>, %arg5: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginExternalFormattedOutput(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) : (!fir.ref<i8>, i64, !fir.box<none>, i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginExternalListInput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginExternalListInput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginExternalListInput(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginExternalListInput(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginExternalListOutput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginExternalListOutput(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginExternalListOutput(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginFlush(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginFlush(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginFlush(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginFlush(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginInquireFile(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_4:.*]] = fir.call @_FortranAioBeginInquireFile(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_4]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginInquireFile(%arg0: !fir.ref<i8>, %arg1: i64, %arg2: !fir.ref<i8>, %arg3: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginInquireFile(%arg0, %arg1, %arg2, %arg3) : (!fir.ref<i8>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginInquireIoLength(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioBeginInquireIoLength(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_2]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginInquireIoLength(%arg0: !fir.ref<i8>, %arg1: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginInquireIoLength(%arg0, %arg1) : (!fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginInquireUnit(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginInquireUnit(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginInquireUnit(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginInquireUnit(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginInternalArrayFormattedInput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<!fir.llvm_ptr<i8>>,
+// CHECK-SAME: %[[VAL_5:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_6:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_7:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_8:.*]] = fir.call @_FortranAioBeginInternalArrayFormattedInput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]], %[[VAL_6]], %[[VAL_7]]) {llvm.nocallback, llvm.nosync} : (!fir.box<none>, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_8]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginInternalArrayFormattedInput(%arg0: !fir.box<none>, %arg1: !fir.ref<i8>, %arg2: i64, %arg3: !fir.box<none>, %arg4: !fir.ref<!fir.llvm_ptr<i8>>, %arg5: i64, %arg6: !fir.ref<i8>, %arg7: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginInternalArrayFormattedInput(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5, %arg6, %arg7) : (!fir.box<none>, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginInternalArrayFormattedOutput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<!fir.llvm_ptr<i8>>,
+// CHECK-SAME: %[[VAL_5:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_6:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_7:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_8:.*]] = fir.call @_FortranAioBeginInternalArrayFormattedOutput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]], %[[VAL_6]], %[[VAL_7]]) {llvm.nocallback, llvm.nosync} : (!fir.box<none>, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_8]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginInternalArrayFormattedOutput(%arg0: !fir.box<none>, %arg1: !fir.ref<i8>, %arg2: i64, %arg3: !fir.box<none>, %arg4: !fir.ref<!fir.llvm_ptr<i8>>, %arg5: i64, %arg6: !fir.ref<i8>, %arg7: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginInternalArrayFormattedOutput(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5, %arg6, %arg7) : (!fir.box<none>, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginInternalArrayListInput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<!fir.llvm_ptr<i8>>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_5:.*]] = fir.call @_FortranAioBeginInternalArrayListInput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]]) {llvm.nocallback, llvm.nosync} : (!fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_5]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginInternalArrayListInput(%arg0: !fir.box<none>, %arg1: !fir.ref<!fir.llvm_ptr<i8>>, %arg2: i64, %arg3: !fir.ref<i8>, %arg4: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginInternalArrayListInput(%arg0, %arg1, %arg2, %arg3, %arg4) : (!fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginInternalArrayListOutput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<!fir.llvm_ptr<i8>>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_5:.*]] = fir.call @_FortranAioBeginInternalArrayListOutput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]]) {llvm.nocallback, llvm.nosync} : (!fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_5]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginInternalArrayListOutput(%arg0: !fir.box<none>, %arg1: !fir.ref<!fir.llvm_ptr<i8>>, %arg2: i64, %arg3: !fir.ref<i8>, %arg4: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginInternalArrayListOutput(%arg0, %arg1, %arg2, %arg3, %arg4) : (!fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginInternalFormattedInput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_5:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<!fir.llvm_ptr<i8>>,
+// CHECK-SAME: %[[VAL_6:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_7:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_8:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_9:.*]] = fir.call @_FortranAioBeginInternalFormattedInput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]], %[[VAL_6]], %[[VAL_7]], %[[VAL_8]]) {llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_9]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginInternalFormattedInput(%arg0: !fir.ref<i8>, %arg1: i64, %arg2: !fir.ref<i8>, %arg3: i64, %arg4: !fir.box<none>, %arg5: !fir.ref<!fir.llvm_ptr<i8>>, %arg6: i64, %arg7: !fir.ref<i8>, %arg8: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginInternalFormattedInput(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5, %arg6, %arg7, %arg8) : (!fir.ref<i8>, i64, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginInternalFormattedOutput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_5:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<!fir.llvm_ptr<i8>>,
+// CHECK-SAME: %[[VAL_6:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_7:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_8:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_9:.*]] = fir.call @_FortranAioBeginInternalFormattedOutput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]], %[[VAL_6]], %[[VAL_7]], %[[VAL_8]]) {llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_9]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginInternalFormattedOutput(%arg0: !fir.ref<i8>, %arg1: i64, %arg2: !fir.ref<i8>, %arg3: i64, %arg4: !fir.box<none>, %arg5: !fir.ref<!fir.llvm_ptr<i8>>, %arg6: i64, %arg7: !fir.ref<i8>, %arg8: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginInternalFormattedOutput(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5, %arg6, %arg7, %arg8) : (!fir.ref<i8>, i64, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginInternalListInput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<!fir.llvm_ptr<i8>>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_5:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_6:.*]] = fir.call @_FortranAioBeginInternalListInput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]]) {llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_6]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginInternalListInput(%arg0: !fir.ref<i8>, %arg1: i64, %arg2: !fir.ref<!fir.llvm_ptr<i8>>, %arg3: i64, %arg4: !fir.ref<i8>, %arg5: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginInternalListInput(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) : (!fir.ref<i8>, i64, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginInternalListOutput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<!fir.llvm_ptr<i8>>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_5:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_6:.*]] = fir.call @_FortranAioBeginInternalListOutput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]]) {llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_6]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginInternalListOutput(%arg0: !fir.ref<i8>, %arg1: i64, %arg2: !fir.ref<!fir.llvm_ptr<i8>>, %arg3: i64, %arg4: !fir.ref<i8>, %arg5: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginInternalListOutput(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) : (!fir.ref<i8>, i64, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginOpenNewUnit(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioBeginOpenNewUnit(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_2]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginOpenNewUnit(%arg0: !fir.ref<i8>, %arg1: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginOpenNewUnit(%arg0, %arg1) : (!fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginOpenUnit(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginOpenUnit(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginOpenUnit(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginOpenUnit(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginRewind(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginRewind(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginRewind(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginRewind(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginUnformattedInput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginUnformattedInput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginUnformattedInput(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginUnformattedInput(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginUnformattedOutput(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginUnformattedOutput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginUnformattedOutput(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginUnformattedOutput(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginWait(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_4:.*]] = fir.call @_FortranAioBeginWait(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_4]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginWait(%arg0: i32, %arg1: i32, %arg2: !fir.ref<i8>, %arg3: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginWait(%arg0, %arg1, %arg2, %arg3) : (i32, i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioBeginWaitAll(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref<i8> {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginWaitAll(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+// CHECK: return %[[VAL_3]] : !fir.ref<i8>
+// CHECK: }
+ func.func @test__FortranAioBeginWaitAll(%arg0: i32, %arg1: !fir.ref<i8>, %arg2: i32) -> !fir.ref<i8> {
+ %0 = fir.call @_FortranAioBeginWaitAll(%arg0, %arg1, %arg2) : (i32, !fir.ref<i8>, i32) -> !fir.ref<i8>
+ return %0 : !fir.ref<i8>
+ }
+// CHECK-LABEL: func.func @test__FortranAioCheckUnitNumberInRange128(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i128,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i1,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_5:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> i32 {
+// CHECK: %[[VAL_6:.*]] = fir.call @_FortranAioCheckUnitNumberInRange128(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i128, i1, !fir.ref<i8>, i64, !fir.ref<i8>, i32) -> i32
+// CHECK: return %[[VAL_6]] : i32
+// CHECK: }
+ func.func @test__FortranAioCheckUnitNumberInRange128(%arg0: i128, %arg1: i1, %arg2: !fir.ref<i8>, %arg3: i64, %arg4: !fir.ref<i8>, %arg5: i32) -> i32 {
+ %0 = fir.call @_FortranAioCheckUnitNumberInRange128(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) : (i128, i1, !fir.ref<i8>, i64, !fir.ref<i8>, i32) -> i32
+ return %0 : i32
+ }
+// CHECK-LABEL: func.func @test__FortranAioCheckUnitNumberInRange64(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i1,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_5:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> i32 {
+// CHECK: %[[VAL_6:.*]] = fir.call @_FortranAioCheckUnitNumberInRange64(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (i64, i1, !fir.ref<i8>, i64, !fir.ref<i8>, i32) -> i32
+// CHECK: return %[[VAL_6]] : i32
+// CHECK: }
+ func.func @test__FortranAioCheckUnitNumberInRange64(%arg0: i64, %arg1: i1, %arg2: !fir.ref<i8>, %arg3: i64, %arg4: !fir.ref<i8>, %arg5: i32) -> i32 {
+ %0 = fir.call @_FortranAioCheckUnitNumberInRange64(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) : (i64, i1, !fir.ref<i8>, i64, !fir.ref<i8>, i32) -> i32
+ return %0 : i32
+ }
+// CHECK-LABEL: func.func @test__FortranAioEnableHandlers(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i1,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i1,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i1,
+// CHECK-SAME: %[[VAL_4:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i1,
+// CHECK-SAME: %[[VAL_5:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i1) {
+// CHECK: fir.call @_FortranAioEnableHandlers(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i1, i1, i1, i1, i1) -> ()
+// CHECK: return
+// CHECK: }
+ func.func @test__FortranAioEnableHandlers(%arg0: !fir.ref<i8>, %arg1: i1, %arg2: i1, %arg3: i1, %arg4: i1, %arg5: i1) {
+ fir.call @_FortranAioEnableHandlers(%arg0, %arg1, %arg2, %arg3, %arg4, %arg5) : (!fir.ref<i8>, i1, i1, i1, i1, i1) -> ()
+ return
+ }
+// CHECK-LABEL: func.func @test__FortranAioEndIoStatement(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>) -> i32 {
+// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>) -> i32
+// CHECK: return %[[VAL_1]] : i32
+// CHECK: }
+ func.func @test__FortranAioEndIoStatement(%arg0: !fir.ref<i8>) -> i32 {
+ %0 = fir.call @_FortranAioEndIoStatement(%arg0) : (!fir.ref<i8>) -> i32
+ return %0 : i32
+ }
+// CHECK-LABEL: func.func @test__FortranAioGetAsynchronousId(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>) -> i32 {
+// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioGetAsynchronousId(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>) -> i32
+// CHECK: return %[[VAL_1]] : i32
+// CHECK: }
+ func.func @test__FortranAioGetAsynchronousId(%arg0: !fir.ref<i8>) -> i32 {
+ %0 = fir.call @_FortranAioGetAsynchronousId(%arg0) : (!fir.ref<i8>) -> i32
+ return %0 : i32
+ }
+// CHECK-LABEL: func.func @test__FortranAioGetIoLength(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>) -> i64 {
+// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioGetIoLength(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>) -> i64
+// CHECK: return %[[VAL_1]] : i64
+// CHECK: }
+ func.func @test__FortranAioGetIoLength(%arg0: !fir.ref<i8>) -> i64 {
+ %0 = fir.call @_FortranAioGetIoLength(%arg0) : (!fir.ref<i8>) -> i64
+ return %0 : i64
+ }
+// CHECK-LABEL: func.func @test__FortranAioGetIoMsg(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) {
+// CHECK: fir.call @_FortranAioGetIoMsg(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> ()
+// CHECK: return
+// CHECK: }
+ func.func @test__FortranAioGetIoMsg(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) {
+ fir.call @_FortranAioGetIoMsg(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> ()
+ return
+ }
+// CHECK-LABEL: func.func @test__FortranAioGetNewUnit(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i32>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioGetNewUnit(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i32>, i32) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioGetNewUnit(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i32>, %arg2: i32) -> i1 {
+ %0 = fir.call @_FortranAioGetNewUnit(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i32>, i32) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioGetSize(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>) -> i64 {
+// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioGetSize(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>) -> i64
+// CHECK: return %[[VAL_1]] : i64
+// CHECK: }
+ func.func @test__FortranAioGetSize(%arg0: !fir.ref<i8>) -> i64 {
+ %0 = fir.call @_FortranAioGetSize(%arg0) : (!fir.ref<i8>) -> i64
+ return %0 : i64
+ }
+// CHECK-LABEL: func.func @test__FortranAioInputAscii(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioInputAscii(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioInputAscii(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioInputAscii(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInputComplex32(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<f32>) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputComplex32(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<f32>) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioInputComplex32(%arg0: !fir.ref<i8>, %arg1: !fir.ref<f32>) -> i1 {
+ %0 = fir.call @_FortranAioInputComplex32(%arg0, %arg1) : (!fir.ref<i8>, !fir.ref<f32>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInputComplex64(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<f64>) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputComplex64(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<f64>) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioInputComplex64(%arg0: !fir.ref<i8>, %arg1: !fir.ref<f64>) -> i1 {
+ %0 = fir.call @_FortranAioInputComplex64(%arg0, %arg1) : (!fir.ref<i8>, !fir.ref<f64>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInputDerivedType(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<tuple<>>) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioInputDerivedType(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {llvm.nosync} : (!fir.ref<i8>, !fir.box<none>, !fir.ref<tuple<>>) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioInputDerivedType(%arg0: !fir.ref<i8>, %arg1: !fir.box<none>, %arg2: !fir.ref<tuple<>>) -> i1 {
+ %0 = fir.call @_FortranAioInputDerivedType(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.box<none>, !fir.ref<tuple<>>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInputDescriptor(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputDescriptor(%[[VAL_0]], %[[VAL_1]]) {llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.box<none>) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioInputDescriptor(%arg0: !fir.ref<i8>, %arg1: !fir.box<none>) -> i1 {
+ %0 = fir.call @_FortranAioInputDescriptor(%arg0, %arg1) : (!fir.ref<i8>, !fir.box<none>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInputInteger(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i64>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioInputInteger(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i64>, i32) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioInputInteger(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i64>, %arg2: i32) -> i1 {
+ %0 = fir.call @_FortranAioInputInteger(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i64>, i32) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInputLogical(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i1>) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputLogical(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i1>) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioInputLogical(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i1>) -> i1 {
+ %0 = fir.call @_FortranAioInputLogical(%arg0, %arg1) : (!fir.ref<i8>, !fir.ref<i1>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInputNamelist(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<tuple<>>) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputNamelist(%[[VAL_0]], %[[VAL_1]]) {llvm.nosync} : (!fir.ref<i8>, !fir.ref<tuple<>>) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioInputNamelist(%arg0: !fir.ref<i8>, %arg1: !fir.ref<tuple<>>) -> i1 {
+ %0 = fir.call @_FortranAioInputNamelist(%arg0, %arg1) : (!fir.ref<i8>, !fir.ref<tuple<>>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInputReal32(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<f32>) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputReal32(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<f32>) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioInputReal32(%arg0: !fir.ref<i8>, %arg1: !fir.ref<f32>) -> i1 {
+ %0 = fir.call @_FortranAioInputReal32(%arg0, %arg1) : (!fir.ref<i8>, !fir.ref<f32>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInputReal64(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<f64>) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputReal64(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<f64>) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioInputReal64(%arg0: !fir.ref<i8>, %arg1: !fir.ref<f64>) -> i1 {
+ %0 = fir.call @_FortranAioInputReal64(%arg0, %arg1) : (!fir.ref<i8>, !fir.ref<f64>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInquireCharacter(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_4:.*]] = fir.call @_FortranAioInquireCharacter(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_4]] : i1
+// CHECK: }
+ func.func @test__FortranAioInquireCharacter(%arg0: !fir.ref<i8>, %arg1: i64, %arg2: !fir.ref<i8>, %arg3: i64) -> i1 {
+ %0 = fir.call @_FortranAioInquireCharacter(%arg0, %arg1, %arg2, %arg3) : (!fir.ref<i8>, i64, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInquireInteger64(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i64>,
+// CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> i1 {
+// CHECK: %[[VAL_4:.*]] = fir.call @_FortranAioInquireInteger64(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64, !fir.ref<i64>, i32) -> i1
+// CHECK: return %[[VAL_4]] : i1
+// CHECK: }
+ func.func @test__FortranAioInquireInteger64(%arg0: !fir.ref<i8>, %arg1: i64, %arg2: !fir.ref<i64>, %arg3: i32) -> i1 {
+ %0 = fir.call @_FortranAioInquireInteger64(%arg0, %arg1, %arg2, %arg3) : (!fir.ref<i8>, i64, !fir.ref<i64>, i32) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInquireLogical(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i1>) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioInquireLogical(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64, !fir.ref<i1>) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioInquireLogical(%arg0: !fir.ref<i8>, %arg1: i64, %arg2: !fir.ref<i1>) -> i1 {
+ %0 = fir.call @_FortranAioInquireLogical(%arg0, %arg1, %arg2) : (!fir.ref<i8>, i64, !fir.ref<i1>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioInquirePendingId(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i1>) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioInquirePendingId(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i32, !fir.ref<i1>) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioInquirePendingId(%arg0: !fir.ref<i8>, %arg1: i32, %arg2: !fir.ref<i1>) -> i1 {
+ %0 = fir.call @_FortranAioInquirePendingId(%arg0, %arg1, %arg2) : (!fir.ref<i8>, i32, !fir.ref<i1>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputAscii(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputAscii(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioOutputAscii(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputComplex32(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: f32,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: f32) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioOutputComplex32(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, f32, f32) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputComplex32(%arg0: !fir.ref<i8>, %arg1: f32, %arg2: f32) -> i1 {
+ %0 = fir.call @_FortranAioOutputComplex32(%arg0, %arg1, %arg2) : (!fir.ref<i8>, f32, f32) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputComplex64(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: f64,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: f64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioOutputComplex64(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, f64, f64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputComplex64(%arg0: !fir.ref<i8>, %arg1: f64, %arg2: f64) -> i1 {
+ %0 = fir.call @_FortranAioOutputComplex64(%arg0, %arg1, %arg2) : (!fir.ref<i8>, f64, f64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputDerivedType(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<tuple<>>) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioOutputDerivedType(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {llvm.nosync} : (!fir.ref<i8>, !fir.box<none>, !fir.ref<tuple<>>) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputDerivedType(%arg0: !fir.ref<i8>, %arg1: !fir.box<none>, %arg2: !fir.ref<tuple<>>) -> i1 {
+ %0 = fir.call @_FortranAioOutputDerivedType(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.box<none>, !fir.ref<tuple<>>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputDescriptor(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputDescriptor(%[[VAL_0]], %[[VAL_1]]) {llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.box<none>) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputDescriptor(%arg0: !fir.ref<i8>, %arg1: !fir.box<none>) -> i1 {
+ %0 = fir.call @_FortranAioOutputDescriptor(%arg0, %arg1) : (!fir.ref<i8>, !fir.box<none>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputInteger128(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i128) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputInteger128(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i128) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputInteger128(%arg0: !fir.ref<i8>, %arg1: i128) -> i1 {
+ %0 = fir.call @_FortranAioOutputInteger128(%arg0, %arg1) : (!fir.ref<i8>, i128) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputInteger16(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i16) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputInteger16(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i16) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputInteger16(%arg0: !fir.ref<i8>, %arg1: i16) -> i1 {
+ %0 = fir.call @_FortranAioOutputInteger16(%arg0, %arg1) : (!fir.ref<i8>, i16) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputInteger32(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputInteger32(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i32) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputInteger32(%arg0: !fir.ref<i8>, %arg1: i32) -> i1 {
+ %0 = fir.call @_FortranAioOutputInteger32(%arg0, %arg1) : (!fir.ref<i8>, i32) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputInteger64(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputInteger64(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputInteger64(%arg0: !fir.ref<i8>, %arg1: i64) -> i1 {
+ %0 = fir.call @_FortranAioOutputInteger64(%arg0, %arg1) : (!fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputInteger8(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i8) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputInteger8(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i8) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputInteger8(%arg0: !fir.ref<i8>, %arg1: i8) -> i1 {
+ %0 = fir.call @_FortranAioOutputInteger8(%arg0, %arg1) : (!fir.ref<i8>, i8) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputLogical(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i1) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputLogical(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i1) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputLogical(%arg0: !fir.ref<i8>, %arg1: i1) -> i1 {
+ %0 = fir.call @_FortranAioOutputLogical(%arg0, %arg1) : (!fir.ref<i8>, i1) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputNamelist(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<tuple<>>) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputNamelist(%[[VAL_0]], %[[VAL_1]]) {llvm.nosync} : (!fir.ref<i8>, !fir.ref<tuple<>>) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputNamelist(%arg0: !fir.ref<i8>, %arg1: !fir.ref<tuple<>>) -> i1 {
+ %0 = fir.call @_FortranAioOutputNamelist(%arg0, %arg1) : (!fir.ref<i8>, !fir.ref<tuple<>>) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputReal32(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: f32) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, f32) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputReal32(%arg0: !fir.ref<i8>, %arg1: f32) -> i1 {
+ %0 = fir.call @_FortranAioOutputReal32(%arg0, %arg1) : (!fir.ref<i8>, f32) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioOutputReal64(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: f64) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputReal64(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, f64) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioOutputReal64(%arg0: !fir.ref<i8>, %arg1: f64) -> i1 {
+ %0 = fir.call @_FortranAioOutputReal64(%arg0, %arg1) : (!fir.ref<i8>, f64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetAccess(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetAccess(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetAccess(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetAccess(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetAction(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetAction(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetAction(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetAction(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetAdvance(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetAdvance(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetAdvance(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetAdvance(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetAsynchronous(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetAsynchronous(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetAsynchronous(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetAsynchronous(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetBlank(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetBlank(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetBlank(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetBlank(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetCarriagecontrol(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetCarriagecontrol(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetCarriagecontrol(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetCarriagecontrol(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetConvert(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetConvert(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetConvert(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetConvert(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetDecimal(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetDecimal(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetDecimal(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetDecimal(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetDelim(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetDelim(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetDelim(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetDelim(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetEncoding(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetEncoding(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetEncoding(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetEncoding(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetFile(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetFile(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetFile(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetFile(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetForm(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetForm(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetForm(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetForm(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetPad(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetPad(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetPad(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetPad(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetPos(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioSetPos(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetPos(%arg0: !fir.ref<i8>, %arg1: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetPos(%arg0, %arg1) : (!fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetPosition(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetPosition(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetPosition(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetPosition(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetRec(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioSetRec(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetRec(%arg0: !fir.ref<i8>, %arg1: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetRec(%arg0, %arg1) : (!fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetRecl(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioSetRecl(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_2]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetRecl(%arg0: !fir.ref<i8>, %arg1: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetRecl(%arg0, %arg1) : (!fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetRound(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetRound(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetRound(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetRound(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetSign(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetSign(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetSign(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetSign(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+// CHECK-LABEL: func.func @test__FortranAioSetStatus(
+// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<i8>,
+// CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i64) -> i1 {
+// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetStatus(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects<other = none, argMem = readwrite, inaccessibleMem = readwrite>, llvm.nocallback, llvm.nosync} : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+// CHECK: return %[[VAL_3]] : i1
+// CHECK: }
+ func.func @test__FortranAioSetStatus(%arg0: !fir.ref<i8>, %arg1: !fir.ref<i8>, %arg2: i64) -> i1 {
+ %0 = fir.call @_FortranAioSetStatus(%arg0, %arg1, %arg2) : (!fir.ref<i8>, !fir.ref<i8>, i64) -> i1
+ return %0 : i1
+ }
+ func.func private @_FortranAioBeginBackspace(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginClose(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginEndfile(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginExternalFormattedInput(!fir.ref<i8>, i64, !fir.box<none>, i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginExternalFormattedOutput(!fir.ref<i8>, i64, !fir.box<none>, i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginExternalListInput(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginExternalListOutput(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginFlush(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginInquireFile(!fir.ref<i8>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginInquireIoLength(!fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginInquireUnit(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginInternalArrayFormattedInput(!fir.box<none>, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginInternalArrayFormattedOutput(!fir.box<none>, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginInternalArrayListInput(!fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginInternalArrayListOutput(!fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginInternalFormattedInput(!fir.ref<i8>, i64, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginInternalFormattedOutput(!fir.ref<i8>, i64, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginInternalListInput(!fir.ref<i8>, i64, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginInternalListOutput(!fir.ref<i8>, i64, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginOpenNewUnit(!fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginOpenUnit(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginRewind(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginUnformattedInput(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginUnformattedOutput(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginWait(i32, i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioBeginWaitAll(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioCheckUnitNumberInRange128(i128, i1, !fir.ref<i8>, i64, !fir.ref<i8>, i32) -> i32 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioCheckUnitNumberInRange64(i64, i1, !fir.ref<i8>, i64, !fir.ref<i8>, i32) -> i32 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioEnableHandlers(!fir.ref<i8>, i1, i1, i1, i1, i1) attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioEndIoStatement(!fir.ref<i8>) -> i32 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioGetAsynchronousId(!fir.ref<i8>) -> i32 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioGetIoLength(!fir.ref<i8>) -> i64 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioGetIoMsg(!fir.ref<i8>, !fir.ref<i8>, i64) attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioGetNewUnit(!fir.ref<i8>, !fir.ref<i32>, i32) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioGetSize(!fir.ref<i8>) -> i64 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInputAscii(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInputComplex32(!fir.ref<i8>, !fir.ref<f32>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInputComplex64(!fir.ref<i8>, !fir.ref<f64>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInputDerivedType(!fir.ref<i8>, !fir.box<none>, !fir.ref<tuple<>>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInputDescriptor(!fir.ref<i8>, !fir.box<none>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInputInteger(!fir.ref<i8>, !fir.ref<i64>, i32) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInputLogical(!fir.ref<i8>, !fir.ref<i1>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInputNamelist(!fir.ref<i8>, !fir.ref<tuple<>>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInputReal32(!fir.ref<i8>, !fir.ref<f32>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInputReal64(!fir.ref<i8>, !fir.ref<f64>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInquireCharacter(!fir.ref<i8>, i64, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInquireInteger64(!fir.ref<i8>, i64, !fir.ref<i64>, i32) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInquireLogical(!fir.ref<i8>, i64, !fir.ref<i1>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioInquirePendingId(!fir.ref<i8>, i32, !fir.ref<i1>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputAscii(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputComplex32(!fir.ref<i8>, f32, f32) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputComplex64(!fir.ref<i8>, f64, f64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputDerivedType(!fir.ref<i8>, !fir.box<none>, !fir.ref<tuple<>>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputDescriptor(!fir.ref<i8>, !fir.box<none>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputInteger128(!fir.ref<i8>, i128) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputInteger16(!fir.ref<i8>, i16) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputInteger32(!fir.ref<i8>, i32) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputInteger64(!fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputInteger8(!fir.ref<i8>, i8) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputLogical(!fir.ref<i8>, i1) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputNamelist(!fir.ref<i8>, !fir.ref<tuple<>>) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputReal32(!fir.ref<i8>, f32) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioOutputReal64(!fir.ref<i8>, f64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetAccess(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetAction(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetAdvance(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetAsynchronous(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetBlank(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetCarriagecontrol(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetConvert(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetDecimal(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetDelim(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetEncoding(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetFile(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetForm(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetPad(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetPos(!fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetPosition(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetRec(!fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetRecl(!fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetRound(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetSign(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+ func.func private @_FortranAioSetStatus(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+}
diff --git a/flang/test/Transforms/verify-known-runtime-functions.fir b/flang/test/Transforms/verify-known-runtime-functions.fir
new file mode 100644
index 0000000000000..902d701424f6f
--- /dev/null
+++ b/flang/test/Transforms/verify-known-runtime-functions.fir
@@ -0,0 +1,101 @@
+// RUN: echo "module {}" | fir-opt --gen-runtime-calls-for-test | FileCheck %s
+
+// NOTE: Assertions have been autogenerated by flang/test/Utils/generate-checks-for-runtime-funcs.py
+
+// The script allows updating Flang LIT test
+// flang/test/Transforms/verify-known-runtime-functions.fir,
+// which is intended to verify signatures of Fortran runtime
+// functions recognized in flang/Optimizer/Transforms/RuntimeFunctions.inc
+// table. If new function is added into the table or
+// an existing function changes its signature,
+// the SetRuntimeCallAttributesPass may need to be updated
+// to properly handle it. Once the pass is verified to work,
+// one can update this test using the following output:
+// echo "module {}" | fir-opt --gen-runtime-calls-for-test | \
+// generate-checks-for-runtime-funcs.py
+
+// CHECK-NOT: func.func
+// CHECK: func.func private @_FortranAioBeginBackspace(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginClose(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginEndfile(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginExternalFormattedInput(!fir.ref<i8>, i64, !fir.box<none>, i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginExternalFormattedOutput(!fir.ref<i8>, i64, !fir.box<none>, i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginExternalListInput(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginExternalListOutput(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginFlush(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginInquireFile(!fir.ref<i8>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginInquireIoLength(!fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginInquireUnit(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginInternalArrayFormattedInput(!fir.box<none>, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginInternalArrayFormattedOutput(!fir.box<none>, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginInternalArrayListInput(!fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginInternalArrayListOutput(!fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginInternalFormattedInput(!fir.ref<i8>, i64, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginInternalFormattedOutput(!fir.ref<i8>, i64, !fir.ref<i8>, i64, !fir.box<none>, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginInternalListInput(!fir.ref<i8>, i64, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginInternalListOutput(!fir.ref<i8>, i64, !fir.ref<!fir.llvm_ptr<i8>>, i64, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginOpenNewUnit(!fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginOpenUnit(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginRewind(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginUnformattedInput(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginUnformattedOutput(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginWait(i32, i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioBeginWaitAll(i32, !fir.ref<i8>, i32) -> !fir.ref<i8> attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioCheckUnitNumberInRange128(i128, i1, !fir.ref<i8>, i64, !fir.ref<i8>, i32) -> i32 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioCheckUnitNumberInRange64(i64, i1, !fir.ref<i8>, i64, !fir.ref<i8>, i32) -> i32 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioEnableHandlers(!fir.ref<i8>, i1, i1, i1, i1, i1) attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioEndIoStatement(!fir.ref<i8>) -> i32 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioGetAsynchronousId(!fir.ref<i8>) -> i32 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioGetIoLength(!fir.ref<i8>) -> i64 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioGetIoMsg(!fir.ref<i8>, !fir.ref<i8>, i64) attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioGetNewUnit(!fir.ref<i8>, !fir.ref<i32>, i32) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioGetSize(!fir.ref<i8>) -> i64 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInputAscii(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInputComplex32(!fir.ref<i8>, !fir.ref<f32>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInputComplex64(!fir.ref<i8>, !fir.ref<f64>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInputDerivedType(!fir.ref<i8>, !fir.box<none>, !fir.ref<tuple<>>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInputDescriptor(!fir.ref<i8>, !fir.box<none>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInputInteger(!fir.ref<i8>, !fir.ref<i64>, i32) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInputLogical(!fir.ref<i8>, !fir.ref<i1>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInputNamelist(!fir.ref<i8>, !fir.ref<tuple<>>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInputReal32(!fir.ref<i8>, !fir.ref<f32>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInputReal64(!fir.ref<i8>, !fir.ref<f64>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInquireCharacter(!fir.ref<i8>, i64, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInquireInteger64(!fir.ref<i8>, i64, !fir.ref<i64>, i32) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInquireLogical(!fir.ref<i8>, i64, !fir.ref<i1>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioInquirePendingId(!fir.ref<i8>, i32, !fir.ref<i1>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputAscii(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputComplex32(!fir.ref<i8>, f32, f32) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputComplex64(!fir.ref<i8>, f64, f64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputDerivedType(!fir.ref<i8>, !fir.box<none>, !fir.ref<tuple<>>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputDescriptor(!fir.ref<i8>, !fir.box<none>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputInteger128(!fir.ref<i8>, i128) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputInteger16(!fir.ref<i8>, i16) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputInteger32(!fir.ref<i8>, i32) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputInteger64(!fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputInteger8(!fir.ref<i8>, i8) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputLogical(!fir.ref<i8>, i1) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputNamelist(!fir.ref<i8>, !fir.ref<tuple<>>) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputReal32(!fir.ref<i8>, f32) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioOutputReal64(!fir.ref<i8>, f64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetAccess(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetAction(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetAdvance(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetAsynchronous(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetBlank(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetCarriagecontrol(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetConvert(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetDecimal(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetDelim(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetEncoding(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetFile(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetForm(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetPad(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetPos(!fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetPosition(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetRec(!fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetRecl(!fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetRound(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetSign(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NEXT: func.func private @_FortranAioSetStatus(!fir.ref<i8>, !fir.ref<i8>, i64) -> i1 attributes {fir.io, fir.runtime}
+// CHECK-NOT: func.func
diff --git a/flang/test/Utils/generate-checks-for-runtime-funcs.py b/flang/test/Utils/generate-checks-for-runtime-funcs.py
new file mode 100755
index 0000000000000..98fcc2937a467
--- /dev/null
+++ b/flang/test/Utils/generate-checks-for-runtime-funcs.py
@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""A script to generate FileCheck statements for Fortran runtime funcs.
+
+This script can be used to update
+flang/test/Transforms/verify-known-runtime-functions.fir
+whenever new recognized Fortran runtime functions are added
+into flang/Optimizer/Transforms/RuntimeFunctions.inc
+or any of the recognized functions changes its signature.
+"""
+
+# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+# See https://llvm.org/LICENSE.txt for license information.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+import argparse
+import os
+import re
+import sys
+
+ADVERT_BEGIN = "// NOTE: Assertions have been autogenerated by "
+ADVERT_END = """
+// The script allows updating Flang LIT test
+// flang/test/Transforms/verify-known-runtime-functions.fir,
+// which is intended to verify signatures of Fortran runtime
+// functions recognized in flang/Optimizer/Transforms/RuntimeFunctions.inc
+// table. If new function is added into the table or
+// an existing function changes its signature,
+// the SetRuntimeCallAttributesPass may need to be updated
+// to properly handle it. Once the pass is verified to work,
+// one can update this test using the following output:
+// echo "module {}" | fir-opt --gen-runtime-calls-for-test | \\
+// generate-checks-for-runtime-funcs.py
+"""
+
+CHECK_RE_STR = "func.func.*@_Fortran.*"
+CHECK_RE = re.compile(CHECK_RE_STR)
+
+CHECK_NOT_STR = "// CHECK-NOT: func.func"
+CHECK_STR = "// CHECK:"
+CHECK_NEXT_STR = "// CHECK-NEXT:"
+
+def main():
+ parser = argparse.ArgumentParser(
+ description=__doc__, formatter_class=argparse.RawTextHelpFormatter
+ )
+ parser.add_argument(
+ "input", nargs="?", type=argparse.FileType("r"), default=sys.stdin
+ )
+ args = parser.parse_args()
+ input_lines = [l.rstrip() for l in args.input]
+ args.input.close()
+
+ repo_path = os.path.join(os.path.dirname(__file__), "..", "..", "..")
+ script_name = os.path.relpath(__file__, repo_path)
+ autogenerated_note = ADVERT_BEGIN + script_name + "\n" + ADVERT_END
+
+ output = sys.stdout
+ output.write(autogenerated_note + "\n")
+
+ output_lines = []
+ output_lines.append(CHECK_NOT_STR)
+ check_prefix = CHECK_STR
+ for input_line in input_lines:
+ if not input_line:
+ continue
+
+ m = CHECK_RE.match(input_line.lstrip())
+ if m:
+ output_lines.append(check_prefix + " " + input_line.lstrip())
+ check_prefix = CHECK_NEXT_STR
+
+ output_lines.append(CHECK_NOT_STR)
+ for line in output_lines:
+ output.write(line + "\n")
+
+ output.close()
+
+if __name__ == "__main__":
+ main()
>From 8ad429c0b46f3548f93da4a616c21dde32691404 Mon Sep 17 00:00:00 2001
From: Slava Zakharin <szakharin at nvidia.com>
Date: Thu, 20 Feb 2025 16:35:08 -0800
Subject: [PATCH 2/3] format
---
flang/test/Utils/generate-checks-for-runtime-funcs.py | 2 ++
1 file changed, 2 insertions(+)
diff --git a/flang/test/Utils/generate-checks-for-runtime-funcs.py b/flang/test/Utils/generate-checks-for-runtime-funcs.py
index 98fcc2937a467..f1d476d4e3395 100755
--- a/flang/test/Utils/generate-checks-for-runtime-funcs.py
+++ b/flang/test/Utils/generate-checks-for-runtime-funcs.py
@@ -39,6 +39,7 @@
CHECK_STR = "// CHECK:"
CHECK_NEXT_STR = "// CHECK-NEXT:"
+
def main():
parser = argparse.ArgumentParser(
description=__doc__, formatter_class=argparse.RawTextHelpFormatter
@@ -75,5 +76,6 @@ def main():
output.close()
+
if __name__ == "__main__":
main()
>From 54a16b93098f3348cf27a2f824c54211436662d6 Mon Sep 17 00:00:00 2001
From: Slava Zakharin <szakharin at nvidia.com>
Date: Mon, 24 Feb 2025 08:49:24 -0800
Subject: [PATCH 3/3] Added AbsentOp.
---
flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp b/flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp
index 5dc4f04156447..c194c3513d7a8 100644
--- a/flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp
+++ b/flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp
@@ -60,11 +60,11 @@ static mlir::LLVM::MemoryEffectsAttr getGenericMemoryAttr(fir::CallOp callOp) {
for (auto arg : callOp.getArgOperands()) {
mlir::Type argType = arg.getType();
if (mlir::isa<fir::BaseBoxType>(argType)) {
- // If it is a null box, then this particular call
+ // If it is a null/absent box, then this particular call
// cannot access memory indirectly through the box's
// base_addr.
auto def = arg.getDefiningOp();
- if (!def || !mlir::isa<fir::ZeroOp>(def)) {
+ if (!mlir::isa_and_nonnull<fir::ZeroOp, fir::AbsentOp>(def)) {
maybeIndirectAccess = true;
break;
}
More information about the flang-commits
mailing list