| // 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} |
| } |
