diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index 4912bd197dba4..5a0fdeee5a21a 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -284,7 +284,10 @@ void convertSideEffectForCall(mlir::Operation *callOp, bool isNothrow, memoryEffect = mlir::LLVM::MemoryEffectsAttr::get( callOp->getContext(), /*other=*/ModRefInfo::Ref, /*argMem=*/ModRefInfo::Ref, - /*inaccessibleMem=*/ModRefInfo::Ref); + /*inaccessibleMem=*/ModRefInfo::Ref, + /*errnoMem=*/ModRefInfo::Ref, + /*targetMem0=*/ModRefInfo::Ref, + /*targetMem1=*/ModRefInfo::Ref); noUnwind = true; willReturn = true; break; @@ -293,7 +296,10 @@ void convertSideEffectForCall(mlir::Operation *callOp, bool isNothrow, memoryEffect = mlir::LLVM::MemoryEffectsAttr::get( callOp->getContext(), /*other=*/ModRefInfo::NoModRef, /*argMem=*/ModRefInfo::NoModRef, - /*inaccessibleMem=*/ModRefInfo::NoModRef); + /*inaccessibleMem=*/ModRefInfo::NoModRef, + /*errnoMem=*/ModRefInfo::NoModRef, + /*targetMem0=*/ModRefInfo::NoModRef, + /*targetMem1=*/ModRefInfo::NoModRef); noUnwind = true; willReturn = true; break; diff --git a/clang/test/CIR/CodeGen/call.c b/clang/test/CIR/CodeGen/call.c index 99ae4506b1f16..35d977f2b3dac 100644 --- a/clang/test/CIR/CodeGen/call.c +++ b/clang/test/CIR/CodeGen/call.c @@ -130,7 +130,7 @@ int f12(void) { // OGCG: %{{.+}} = call i32 @f10(i32 noundef 1) #[[ATTR0:.+]] // OGCG-NEXT: %{{.+}} = call i32 @f11(i32 noundef 2) #[[ATTR1:.+]] -// LLVM: attributes #[[ATTR0]] = { nounwind willreturn memory(read, errnomem: none, target_mem0: none, target_mem1: none) } +// LLVM: attributes #[[ATTR0]] = { nounwind willreturn memory(read) } // LLVM: attributes #[[ATTR1]] = { nounwind willreturn memory(none) } // OGCG: attributes #[[ATTR0]] = { nounwind willreturn memory(read) } diff --git a/flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp b/flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp index 378037e9494f4..4ba2ea5a43545 100644 --- a/flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp +++ b/flang/lib/Optimizer/Transforms/SetRuntimeCallAttributes.cpp @@ -85,7 +85,10 @@ static mlir::LLVM::MemoryEffectsAttr getGenericMemoryAttr(fir::CallOp callOp) { callOp->getContext(), {/*other=*/mlir::LLVM::ModRefInfo::NoModRef, /*argMem=*/mlir::LLVM::ModRefInfo::ModRef, - /*inaccessibleMem=*/mlir::LLVM::ModRefInfo::ModRef}); + /*inaccessibleMem=*/mlir::LLVM::ModRefInfo::ModRef, + /*errnoMem=*/mlir::LLVM::ModRefInfo::NoModRef, + /*targetMem0=*/mlir::LLVM::ModRefInfo::NoModRef, + /*targetMem1=*/mlir::LLVM::ModRefInfo::NoModRef}); } return {}; diff --git a/flang/test/Transforms/set-runtime-call-attributes.fir b/flang/test/Transforms/set-runtime-call-attributes.fir index ecb2dd53ea4d5..bdc47c84f4d13 100644 --- a/flang/test/Transforms/set-runtime-call-attributes.fir +++ b/flang/test/Transforms/set-runtime-call-attributes.fir @@ -23,7 +23,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginBackspace(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginBackspace(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginBackspace(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -34,7 +34,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginClose(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginClose(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginClose(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -45,7 +45,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginEndfile(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginEndfile(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginEndfile(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -84,7 +84,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginExternalListInput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginExternalListInput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginExternalListInput(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -95,7 +95,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginExternalListOutput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginExternalListOutput(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -106,7 +106,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginFlush(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginFlush(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginFlush(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -118,7 +118,7 @@ module { // 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, // CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_4:.*]] = fir.call @_FortranAioBeginInquireFile(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i64, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_4:.*]] = fir.call @_FortranAioBeginInquireFile(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i64, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_4]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginInquireFile(%arg0: !fir.ref, %arg1: i64, %arg2: !fir.ref, %arg3: i32) -> !fir.ref { @@ -128,7 +128,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioBeginInquireIoLength( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioBeginInquireIoLength(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioBeginInquireIoLength(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_2]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginInquireIoLength(%arg0: !fir.ref, %arg1: i32) -> !fir.ref { @@ -139,7 +139,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginInquireUnit(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginInquireUnit(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginInquireUnit(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -269,7 +269,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioBeginOpenNewUnit( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioBeginOpenNewUnit(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioBeginOpenNewUnit(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_2]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginOpenNewUnit(%arg0: !fir.ref, %arg1: i32) -> !fir.ref { @@ -280,7 +280,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginOpenUnit(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginOpenUnit(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginOpenUnit(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -291,7 +291,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginRewind(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginRewind(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginRewind(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -302,7 +302,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginUnformattedInput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginUnformattedInput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginUnformattedInput(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -313,7 +313,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginUnformattedOutput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginUnformattedOutput(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginUnformattedOutput(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -325,7 +325,7 @@ module { // 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, // CHECK-SAME: %[[VAL_3:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_4:.*]] = fir.call @_FortranAioBeginWait(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_4:.*]] = fir.call @_FortranAioBeginWait(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_4]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginWait(%arg0: i32, %arg1: i32, %arg2: !fir.ref, %arg3: i32) -> !fir.ref { @@ -336,7 +336,7 @@ module { // 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, // CHECK-SAME: %[[VAL_2:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: i32) -> !fir.ref { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginWaitAll(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioBeginWaitAll(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (i32, !fir.ref, i32) -> !fir.ref // CHECK: return %[[VAL_3]] : !fir.ref // CHECK: } func.func @test__FortranAioBeginWaitAll(%arg0: i32, %arg1: !fir.ref, %arg2: i32) -> !fir.ref { @@ -350,7 +350,7 @@ module { // 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, // 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, llvm.nocallback, llvm.nosync} : (i128, i1, !fir.ref, i64, !fir.ref, 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, llvm.nocallback, llvm.nosync} : (i128, i1, !fir.ref, i64, !fir.ref, i32) -> i32 // CHECK: return %[[VAL_6]] : i32 // CHECK: } func.func @test__FortranAioCheckUnitNumberInRange128(%arg0: i128, %arg1: i1, %arg2: !fir.ref, %arg3: i64, %arg4: !fir.ref, %arg5: i32) -> i32 { @@ -364,7 +364,7 @@ module { // 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, // 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, llvm.nocallback, llvm.nosync} : (i64, i1, !fir.ref, i64, !fir.ref, 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, llvm.nocallback, llvm.nosync} : (i64, i1, !fir.ref, i64, !fir.ref, i32) -> i32 // CHECK: return %[[VAL_6]] : i32 // CHECK: } func.func @test__FortranAioCheckUnitNumberInRange64(%arg0: i64, %arg1: i1, %arg2: !fir.ref, %arg3: i64, %arg4: !fir.ref, %arg5: i32) -> i32 { @@ -378,7 +378,7 @@ module { // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i1, i1, i1, i1, i1) -> () +// CHECK: fir.call @_FortranAioEnableHandlers(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]], %[[VAL_4]], %[[VAL_5]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i1, i1, i1, i1, i1) -> () // CHECK: return // CHECK: } func.func @test__FortranAioEnableHandlers(%arg0: !fir.ref, %arg1: i1, %arg2: i1, %arg3: i1, %arg4: i1, %arg5: i1) { @@ -387,7 +387,7 @@ module { } // CHECK-LABEL: func.func @test__FortranAioEndIoStatement( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref) -> i32 { -// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref) -> i32 +// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioEndIoStatement(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref) -> i32 // CHECK: return %[[VAL_1]] : i32 // CHECK: } func.func @test__FortranAioEndIoStatement(%arg0: !fir.ref) -> i32 { @@ -396,7 +396,7 @@ module { } // CHECK-LABEL: func.func @test__FortranAioGetAsynchronousId( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref) -> i32 { -// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioGetAsynchronousId(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref) -> i32 +// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioGetAsynchronousId(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref) -> i32 // CHECK: return %[[VAL_1]] : i32 // CHECK: } func.func @test__FortranAioGetAsynchronousId(%arg0: !fir.ref) -> i32 { @@ -405,7 +405,7 @@ module { } // CHECK-LABEL: func.func @test__FortranAioGetIoLength( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref) -> i64 { -// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioGetIoLength(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref) -> i64 +// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioGetIoLength(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref) -> i64 // CHECK: return %[[VAL_1]] : i64 // CHECK: } func.func @test__FortranAioGetIoLength(%arg0: !fir.ref) -> i64 { @@ -416,7 +416,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> () +// CHECK: fir.call @_FortranAioGetIoMsg(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> () // CHECK: return // CHECK: } func.func @test__FortranAioGetIoMsg(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) { @@ -427,7 +427,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i32) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioGetNewUnit(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i32) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioGetNewUnit(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i32) -> i1 { @@ -436,7 +436,7 @@ module { } // CHECK-LABEL: func.func @test__FortranAioGetSize( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref) -> i64 { -// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioGetSize(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref) -> i64 +// CHECK: %[[VAL_1:.*]] = fir.call @_FortranAioGetSize(%[[VAL_0]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref) -> i64 // CHECK: return %[[VAL_1]] : i64 // CHECK: } func.func @test__FortranAioGetSize(%arg0: !fir.ref) -> i64 { @@ -447,7 +447,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioInputAscii(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioInputAscii(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -457,7 +457,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioInputComplex32( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref) -> i1 { -// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputComplex32(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputComplex32(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioInputComplex32(%arg0: !fir.ref, %arg1: !fir.ref) -> i1 { @@ -467,7 +467,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioInputComplex64( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref) -> i1 { -// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputComplex64(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputComplex64(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioInputComplex64(%arg0: !fir.ref, %arg1: !fir.ref) -> i1 { @@ -499,7 +499,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i32) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioInputInteger(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i32) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioInputInteger(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i32) -> i1 { @@ -509,7 +509,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioInputLogical( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref) -> i1 { -// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputLogical(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputLogical(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioInputLogical(%arg0: !fir.ref, %arg1: !fir.ref) -> i1 { @@ -529,7 +529,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioInputReal32( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref) -> i1 { -// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputReal32(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputReal32(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioInputReal32(%arg0: !fir.ref, %arg1: !fir.ref) -> i1 { @@ -539,7 +539,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioInputReal64( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref) -> i1 { -// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputReal64(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioInputReal64(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioInputReal64(%arg0: !fir.ref, %arg1: !fir.ref) -> i1 { @@ -551,7 +551,7 @@ module { // 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, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i64, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_4:.*]] = fir.call @_FortranAioInquireCharacter(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i64, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_4]] : i1 // CHECK: } func.func @test__FortranAioInquireCharacter(%arg0: !fir.ref, %arg1: i64, %arg2: !fir.ref, %arg3: i64) -> i1 { @@ -563,7 +563,7 @@ module { // 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, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i64, !fir.ref, i32) -> i1 +// CHECK: %[[VAL_4:.*]] = fir.call @_FortranAioInquireInteger64(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]], %[[VAL_3]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i64, !fir.ref, i32) -> i1 // CHECK: return %[[VAL_4]] : i1 // CHECK: } func.func @test__FortranAioInquireInteger64(%arg0: !fir.ref, %arg1: i64, %arg2: !fir.ref, %arg3: i32) -> i1 { @@ -574,7 +574,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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 { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioInquireLogical(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i64, !fir.ref) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioInquireLogical(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i64, !fir.ref) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioInquireLogical(%arg0: !fir.ref, %arg1: i64, %arg2: !fir.ref) -> i1 { @@ -585,7 +585,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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 { -// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioInquirePendingId(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i32, !fir.ref) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioInquirePendingId(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i32, !fir.ref) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioInquirePendingId(%arg0: !fir.ref, %arg1: i32, %arg2: !fir.ref) -> i1 { @@ -596,7 +596,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioOutputAscii(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioOutputAscii(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -607,7 +607,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, f32, f32) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioOutputComplex32(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, f32, f32) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioOutputComplex32(%arg0: !fir.ref, %arg1: f32, %arg2: f32) -> i1 { @@ -618,7 +618,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, f64, f64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioOutputComplex64(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, f64, f64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioOutputComplex64(%arg0: !fir.ref, %arg1: f64, %arg2: f64) -> i1 { @@ -649,7 +649,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioOutputInteger128( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i128) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputInteger128(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i128) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioOutputInteger128(%arg0: !fir.ref, %arg1: i128) -> i1 { @@ -659,7 +659,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioOutputInteger16( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i16) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputInteger16(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i16) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioOutputInteger16(%arg0: !fir.ref, %arg1: i16) -> i1 { @@ -669,7 +669,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioOutputInteger32( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i32) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputInteger32(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i32) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioOutputInteger32(%arg0: !fir.ref, %arg1: i32) -> i1 { @@ -679,7 +679,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioOutputInteger64( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i64) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputInteger64(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i64) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioOutputInteger64(%arg0: !fir.ref, %arg1: i64) -> i1 { @@ -689,7 +689,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioOutputInteger8( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i8) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputInteger8(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i8) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioOutputInteger8(%arg0: !fir.ref, %arg1: i8) -> i1 { @@ -699,7 +699,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioOutputLogical( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i1) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputLogical(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i1) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioOutputLogical(%arg0: !fir.ref, %arg1: i1) -> i1 { @@ -719,7 +719,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioOutputReal32( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, f32) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputReal32(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, f32) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioOutputReal32(%arg0: !fir.ref, %arg1: f32) -> i1 { @@ -729,7 +729,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioOutputReal64( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, f64) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioOutputReal64(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, f64) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioOutputReal64(%arg0: !fir.ref, %arg1: f64) -> i1 { @@ -740,7 +740,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetAccess(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetAccess(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -751,7 +751,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetAction(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetAction(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -762,7 +762,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetAdvance(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetAdvance(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -773,7 +773,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetAsynchronous(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetAsynchronous(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -784,7 +784,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetBlank(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetBlank(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -795,7 +795,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetCarriagecontrol(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetCarriagecontrol(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -806,7 +806,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetConvert(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetConvert(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -817,7 +817,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetDecimal(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetDecimal(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -828,7 +828,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetDelim(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetDelim(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -839,7 +839,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetEncoding(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetEncoding(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -850,7 +850,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetFile(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetFile(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -861,7 +861,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetForm(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetForm(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -872,7 +872,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetPad(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetPad(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -882,7 +882,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioSetPos( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i64) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioSetPos(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i64) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioSetPos(%arg0: !fir.ref, %arg1: i64) -> i1 { @@ -893,7 +893,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetPosition(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetPosition(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -903,7 +903,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioSetRec( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i64) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioSetRec(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i64) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioSetRec(%arg0: !fir.ref, %arg1: i64) -> i1 { @@ -913,7 +913,7 @@ module { // CHECK-LABEL: func.func @test__FortranAioSetRecl( // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, i64) -> i1 +// CHECK: %[[VAL_2:.*]] = fir.call @_FortranAioSetRecl(%[[VAL_0]], %[[VAL_1]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, i64) -> i1 // CHECK: return %[[VAL_2]] : i1 // CHECK: } func.func @test__FortranAioSetRecl(%arg0: !fir.ref, %arg1: i64) -> i1 { @@ -924,7 +924,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetRound(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetRound(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -935,7 +935,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetSign(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetSign(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { @@ -946,7 +946,7 @@ module { // CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref, // 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, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 +// CHECK: %[[VAL_3:.*]] = fir.call @_FortranAioSetStatus(%[[VAL_0]], %[[VAL_1]], %[[VAL_2]]) {fir.llvm_memory = #llvm.memory_effects, llvm.nocallback, llvm.nosync} : (!fir.ref, !fir.ref, i64) -> i1 // CHECK: return %[[VAL_3]] : i1 // CHECK: } func.func @test__FortranAioSetStatus(%arg0: !fir.ref, %arg1: !fir.ref, %arg2: i64) -> i1 { diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td index 147f8c2040049..ef16cec7c9e71 100644 --- a/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td +++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMAttrDefs.td @@ -931,11 +931,9 @@ def LLVM_DIStringTypeAttr : LLVM_Attr<"DIStringType", "di_string_type", //===----------------------------------------------------------------------===// def LLVM_MemoryEffectsAttr : LLVM_Attr<"MemoryEffects", "memory_effects"> { - let parameters = (ins - "ModRefInfo":$other, - "ModRefInfo":$argMem, - "ModRefInfo":$inaccessibleMem - ); + let parameters = (ins "ModRefInfo":$other, "ModRefInfo":$argMem, + "ModRefInfo":$inaccessibleMem, "ModRefInfo":$errnoMem, + "ModRefInfo":$targetMem0, "ModRefInfo":$targetMem1); let extraClassDeclaration = [{ bool isReadWrite(); }]; diff --git a/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp b/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp index 93fe2edad5274..2220f61ed8a07 100644 --- a/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp +++ b/mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp @@ -374,9 +374,12 @@ FailureOr mlir::convertFuncOpToLLVMFuncOp( // Create a memory effect attribute corresponding to readnone. if (funcOp->hasAttr(readnoneAttrName)) { auto memoryAttr = LLVM::MemoryEffectsAttr::get( - rewriter.getContext(), - {LLVM::ModRefInfo::NoModRef, LLVM::ModRefInfo::NoModRef, - LLVM::ModRefInfo::NoModRef}); + rewriter.getContext(), {/*other=*/LLVM::ModRefInfo::NoModRef, + /*argMem=*/LLVM::ModRefInfo::NoModRef, + /*inaccessibleMem=*/LLVM::ModRefInfo::NoModRef, + /*errnoMem=*/LLVM::ModRefInfo::NoModRef, + /*targetMem0=*/LLVM::ModRefInfo::NoModRef, + /*targetMem1=*/LLVM::ModRefInfo::NoModRef}); newFuncOp.setMemoryEffectsAttr(memoryAttr); } diff --git a/mlir/lib/Conversion/GPUToLLVMSPV/GPUToLLVMSPV.cpp b/mlir/lib/Conversion/GPUToLLVMSPV/GPUToLLVMSPV.cpp index 425594b3382f0..f143a9e505f4d 100644 --- a/mlir/lib/Conversion/GPUToLLVMSPV/GPUToLLVMSPV.cpp +++ b/mlir/lib/Conversion/GPUToLLVMSPV/GPUToLLVMSPV.cpp @@ -66,7 +66,10 @@ static LLVM::LLVMFuncOp lookupOrCreateSPIRVFn(Operation *symbolTable, constexpr auto noModRef = mlir::LLVM::ModRefInfo::NoModRef; auto memAttr = b.getAttr( /*other=*/noModRef, - /*argMem=*/noModRef, /*inaccessibleMem=*/noModRef); + /*argMem=*/noModRef, /*inaccessibleMem=*/noModRef, + /*errnoMem=*/noModRef, + /*targetMem0=*/noModRef, + /*targetMem1=*/noModRef); func.setMemoryEffectsAttr(memAttr); } diff --git a/mlir/lib/Conversion/XeVMToLLVM/XeVMToLLVM.cpp b/mlir/lib/Conversion/XeVMToLLVM/XeVMToLLVM.cpp index f2769846abbd9..dffb1dab807a5 100644 --- a/mlir/lib/Conversion/XeVMToLLVM/XeVMToLLVM.cpp +++ b/mlir/lib/Conversion/XeVMToLLVM/XeVMToLLVM.cpp @@ -401,7 +401,10 @@ class MMAToOCLPattern : public OpConversionPattern { auto memAttr = rewriter.getAttr( /*other=*/LLVM::ModRefInfo::NoModRef, /*argMem=*/LLVM::ModRefInfo::NoModRef, - /*inaccessibleMem=*/LLVM::ModRefInfo::NoModRef); + /*inaccessibleMem=*/LLVM::ModRefInfo::NoModRef, + /*errnoMem=*/LLVM::ModRefInfo::NoModRef, + /*targetMem0=*/LLVM::ModRefInfo::NoModRef, + /*targetMem1=*/LLVM::ModRefInfo::NoModRef); auto funcAttrs = convergentNoUnwindWillReturnAttrs; funcAttrs.memEffectsAttr = memAttr; Value result = @@ -450,7 +453,10 @@ class PrefetchToOCLPattern : public OpConversionPattern { auto memAttr = rewriter.getAttr( /*other=*/LLVM::ModRefInfo::NoModRef, /*argMem=*/LLVM::ModRefInfo::Ref, - /*inaccessibleMem=*/LLVM::ModRefInfo::NoModRef); + /*inaccessibleMem=*/LLVM::ModRefInfo::NoModRef, + /*errnoMem=*/LLVM::ModRefInfo::NoModRef, + /*targetMem0=*/LLVM::ModRefInfo::NoModRef, + /*targetMem1=*/LLVM::ModRefInfo::NoModRef); funcAttr.memEffectsAttr = memAttr; LLVM::CallOp call = createDeviceFunctionCall( @@ -556,7 +562,10 @@ class LoadStorePrefetchToOCLPattern : public OpConversionPattern { auto memAttr = rewriter.getAttr( /*other=*/LLVM::ModRefInfo::NoModRef, /*argMem=*/LLVM::ModRefInfo::Ref, - /*inaccessibleMem=*/LLVM::ModRefInfo::NoModRef); + /*inaccessibleMem=*/LLVM::ModRefInfo::NoModRef, + /*errnoMem=*/LLVM::ModRefInfo::NoModRef, + /*targetMem0=*/LLVM::ModRefInfo::NoModRef, + /*targetMem1=*/LLVM::ModRefInfo::NoModRef); funcAttr = noUnwindAttrs; funcAttr.memEffectsAttr = memAttr; } else { @@ -798,7 +807,10 @@ class LaunchConfigOpToOCLPattern : public OpConversionPattern { constexpr auto noModRef = LLVM::ModRefInfo::NoModRef; auto memAttr = rewriter.getAttr( /*other=*/noModRef, - /*argMem=*/noModRef, /*inaccessibleMem=*/noModRef); + /*argMem=*/noModRef, /*inaccessibleMem=*/noModRef, + /*errnoMem=*/noModRef, + /*targetMem0=*/noModRef, + /*targetMem1=*/noModRef); call.setMemoryEffectsAttr(memAttr); rewriter.replaceOp(op, call); return success(); @@ -836,7 +848,10 @@ class SubgroupOpWorkitemOpToOCLPattern : public OpConversionPattern { constexpr auto noModRef = LLVM::ModRefInfo::NoModRef; auto memAttr = rewriter.getAttr( /*other=*/noModRef, - /*argMem=*/noModRef, /*inaccessibleMem=*/noModRef); + /*argMem=*/noModRef, /*inaccessibleMem=*/noModRef, + /*errnoMem=*/noModRef, + /*targetMem0=*/noModRef, + /*targetMem1=*/noModRef); call.setMemoryEffectsAttr(memAttr); rewriter.replaceOp(op, call); return success(); diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp index b8331e0068880..9f87e502a0bf1 100644 --- a/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMAttrs.cpp @@ -219,11 +219,16 @@ bool TBAANodeAttr::classof(Attribute attr) { MemoryEffectsAttr MemoryEffectsAttr::get(MLIRContext *context, ArrayRef memInfoArgs) { if (memInfoArgs.empty()) - return MemoryEffectsAttr::get(context, ModRefInfo::ModRef, - ModRefInfo::ModRef, ModRefInfo::ModRef); - if (memInfoArgs.size() == 3) + return MemoryEffectsAttr::get(context, /*other=*/ModRefInfo::ModRef, + /*argMem=*/ModRefInfo::ModRef, + /*inaccessibleMem=*/ModRefInfo::ModRef, + /*errnoMem=*/ModRefInfo::ModRef, + /*targetMem0=*/ModRefInfo::ModRef, + /*targetMem1=*/ModRefInfo::ModRef); + if (memInfoArgs.size() == 6) return MemoryEffectsAttr::get(context, memInfoArgs[0], memInfoArgs[1], - memInfoArgs[2]); + memInfoArgs[2], memInfoArgs[3], + memInfoArgs[4], memInfoArgs[5]); return {}; } @@ -234,6 +239,12 @@ bool MemoryEffectsAttr::isReadWrite() { return false; if (this->getOther() != ModRefInfo::ModRef) return false; + if (this->getErrnoMem() != ModRefInfo::ModRef) + return false; + if (this->getTargetMem0() != ModRefInfo::ModRef) + return false; + if (this->getTargetMem1() != ModRefInfo::ModRef) + return false; return true; } diff --git a/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp b/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp index eaf1d20da63c7..43ce2ef4fefab 100644 --- a/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp +++ b/mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp @@ -439,7 +439,14 @@ convertOperationImpl(Operation &opInst, llvm::IRBuilderBase &builder, llvm::MemoryEffects::Location::InaccessibleMem, convertModRefInfoToLLVM(memAttr.getInaccessibleMem())) | llvm::MemoryEffects(llvm::MemoryEffects::Location::Other, - convertModRefInfoToLLVM(memAttr.getOther())); + convertModRefInfoToLLVM(memAttr.getOther())) | + llvm::MemoryEffects(llvm::MemoryEffects::Location::ErrnoMem, + convertModRefInfoToLLVM(memAttr.getErrnoMem())) | + llvm::MemoryEffects( + llvm::MemoryEffects::Location::TargetMem0, + convertModRefInfoToLLVM(memAttr.getTargetMem0())) | + llvm::MemoryEffects(llvm::MemoryEffects::Location::TargetMem1, + convertModRefInfoToLLVM(memAttr.getTargetMem1())); call->setMemoryEffects(memEffects); } diff --git a/mlir/lib/Target/LLVMIR/ModuleImport.cpp b/mlir/lib/Target/LLVMIR/ModuleImport.cpp index b8106101692b8..4d63e0534358f 100644 --- a/mlir/lib/Target/LLVMIR/ModuleImport.cpp +++ b/mlir/lib/Target/LLVMIR/ModuleImport.cpp @@ -2597,8 +2597,15 @@ static void processMemoryEffects(llvm::Function *func, LLVMFuncOp funcOp) { memEffects.getModRef(llvm::MemoryEffects::Location::ArgMem)); auto inaccessibleMem = convertModRefInfoFromLLVM( memEffects.getModRef(llvm::MemoryEffects::Location::InaccessibleMem)); - auto memAttr = MemoryEffectsAttr::get(funcOp.getContext(), othermem, argMem, - inaccessibleMem); + auto errnoMem = convertModRefInfoFromLLVM( + memEffects.getModRef(llvm::MemoryEffects::Location::ErrnoMem)); + auto targetMem0 = convertModRefInfoFromLLVM( + memEffects.getModRef(llvm::MemoryEffects::Location::TargetMem0)); + auto targetMem1 = convertModRefInfoFromLLVM( + memEffects.getModRef(llvm::MemoryEffects::Location::TargetMem1)); + auto memAttr = + MemoryEffectsAttr::get(funcOp.getContext(), othermem, argMem, + inaccessibleMem, errnoMem, targetMem0, targetMem1); // Only set the attr when it does not match the default value. if (memAttr.isReadWrite()) return; @@ -2903,8 +2910,15 @@ LogicalResult ModuleImport::convertCallAttributes(llvm::CallInst *inst, memEffects.getModRef(llvm::MemoryEffects::Location::ArgMem)); ModRefInfo inaccessibleMem = convertModRefInfoFromLLVM( memEffects.getModRef(llvm::MemoryEffects::Location::InaccessibleMem)); - auto memAttr = MemoryEffectsAttr::get(op.getContext(), othermem, argMem, - inaccessibleMem); + ModRefInfo errnoMem = convertModRefInfoFromLLVM( + memEffects.getModRef(llvm::MemoryEffects::Location::ErrnoMem)); + ModRefInfo targetMem0 = convertModRefInfoFromLLVM( + memEffects.getModRef(llvm::MemoryEffects::Location::TargetMem0)); + ModRefInfo targetMem1 = convertModRefInfoFromLLVM( + memEffects.getModRef(llvm::MemoryEffects::Location::TargetMem1)); + auto memAttr = + MemoryEffectsAttr::get(op.getContext(), othermem, argMem, inaccessibleMem, + errnoMem, targetMem0, targetMem1); // Only set the attribute when it does not match the default value. if (!memAttr.isReadWrite()) op.setMemoryEffectsAttr(memAttr); diff --git a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp index 64e3c5f085bb3..4107e9c14507f 100644 --- a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp +++ b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp @@ -1637,6 +1637,15 @@ static void convertFunctionMemoryAttributes(LLVMFuncOp func, newMemEffects |= llvm::MemoryEffects(llvm::MemoryEffects::Location::Other, convertModRefInfoToLLVM(memEffects.getOther())); + newMemEffects |= + llvm::MemoryEffects(llvm::MemoryEffects::Location::ErrnoMem, + convertModRefInfoToLLVM(memEffects.getErrnoMem())); + newMemEffects |= + llvm::MemoryEffects(llvm::MemoryEffects::Location::TargetMem0, + convertModRefInfoToLLVM(memEffects.getTargetMem0())); + newMemEffects |= + llvm::MemoryEffects(llvm::MemoryEffects::Location::TargetMem1, + convertModRefInfoToLLVM(memEffects.getTargetMem1())); llvmFunc->setMemoryEffects(newMemEffects); } diff --git a/mlir/test/Conversion/FuncToLLVM/convert-funcs.mlir b/mlir/test/Conversion/FuncToLLVM/convert-funcs.mlir index ae1dc70d0686b..bd281620c2918 100644 --- a/mlir/test/Conversion/FuncToLLVM/convert-funcs.mlir +++ b/mlir/test/Conversion/FuncToLLVM/convert-funcs.mlir @@ -32,7 +32,7 @@ func.func @pass_through(%arg0: () -> ()) -> (() -> ()) { func.func private @llvmlinkage(i32) attributes { "llvm.linkage" = #llvm.linkage } // CHECK-LABEL: llvm.func @llvmreadnone(i32) -// CHECK-SAME: memory_effects = #llvm.memory_effects +// CHECK-SAME: memory_effects = #llvm.memory_effects func.func private @llvmreadnone(i32) attributes { llvm.readnone } // CHECK-LABEL: llvm.func @body(i32) diff --git a/mlir/test/Conversion/XeVMToLLVM/xevm-to-llvm.mlir b/mlir/test/Conversion/XeVMToLLVM/xevm-to-llvm.mlir index 72e70ff519b77..7f01526cb0a06 100644 --- a/mlir/test/Conversion/XeVMToLLVM/xevm-to-llvm.mlir +++ b/mlir/test/Conversion/XeVMToLLVM/xevm-to-llvm.mlir @@ -175,7 +175,7 @@ llvm.func @blockstore2d_cache_control(%c: !llvm.ptr<1>, %base_width_c: i32, %bas // ----- // CHECK-LABEL: llvm.func spir_funccc @_Z44intel_sub_group_2d_block_prefetch_8b_8r32x1cPU3AS1viiiDv2_i( // CHECK-SAME: !llvm.ptr<1> {llvm.nonnull}, i32, i32, i32, vector<2xi32>) attributes -// CHECK-SAME: {memory_effects = #llvm.memory_effects, no_unwind} +// CHECK-SAME: {memory_effects = #llvm.memory_effects, no_unwind} // CHECK: llvm.func @blockprefetch2d(%[[ARG0:.*]]: !llvm.ptr<1>, // CHECK-SAME: %[[ARG1:.*]]: i32, %[[ARG2:.*]]: i32, %[[ARG3:.*]]: i32, %[[ARG4:.*]]: i32, %[[ARG5:.*]]: i32) { llvm.func @blockprefetch2d(%ptr: !llvm.ptr<1>, %base_width: i32, %base_height: i32, %base_pitch: i32, %x: i32, %y: i32) { @@ -187,7 +187,7 @@ llvm.func @blockprefetch2d(%ptr: !llvm.ptr<1>, %base_width: i32, %base_height: i // CHECK: llvm.call spir_funccc @_Z44intel_sub_group_2d_block_prefetch_8b_8r32x1cPU3AS1viiiDv2_i( // CHECK-SAME: %[[ARG0]], %[[ARG1]], %[[ARG2]], %[[ARG3]], %[[VAR4]]) // CHECK-SAME: {function_type = !llvm.func, i32, i32, i32, vector<2xi32>)>, linkage = #llvm.linkage, - // CHECK-SAME: memory_effects = #llvm.memory_effects, no_unwind, + // CHECK-SAME: memory_effects = #llvm.memory_effects, no_unwind, // CHECK-SAME: sym_name = "_Z44intel_sub_group_2d_block_prefetch_8b_8r32x1cPU3AS1viiiDv2_i", visibility_ = 0 : i64 xevm.blockprefetch2d %ptr, %base_width, %base_height, %base_pitch, %x, %y <{elem_size_in_bits=8 : i32, tile_width=32 : i32, tile_height=8 : i32, v_blocks=1 : i32, @@ -200,13 +200,13 @@ llvm.func @blockprefetch2d(%ptr: !llvm.ptr<1>, %base_width: i32, %base_height: i // CHECK-LABEL: llvm.func spir_funccc @_Z38intel_sub_group_f16_f16_matrix_mad_k16Dv8_sDv8_iDv8_f( // CHECK-SAME: vector<8xi16>, vector<8xi32>, vector<8xf32>) -> vector<8xf32> attributes // CHECK-SAME: {convergent, memory_effects = #llvm.memory_effects, no_unwind, will_return} +// CHECK-SAME: inaccessibleMem = none, errnoMem = none, targetMem0 = none, targetMem1 = none>, no_unwind, will_return} // CHECK: llvm.func @mma(%[[ARG0:.*]]: vector<8xf32>, %[[ARG1:.*]]: vector<8xi16>, %[[ARG2:.*]]: vector<8xi32>) -> vector<8xf32> { llvm.func @mma(%loaded_c_casted: vector<8xf32>, %loaded_a: vector<8xi16>, %loaded_b_casted: vector<8xi32>) -> vector<8xf32> { // CHECK: %[[VAR0:.*]] = llvm.call spir_funccc @_Z38intel_sub_group_f16_f16_matrix_mad_k16Dv8_sDv8_iDv8_f( // CHECK-SAME: %[[ARG1]], %[[ARG2]], %[[ARG0]]) {convergent, function_type = // CHECK-SAME: !llvm.func (vector<8xi16>, vector<8xi32>, vector<8xf32>)>, linkage = #llvm.linkage, - // CHECK-SAME: memory_effects = #llvm.memory_effects, no_unwind, + // CHECK-SAME: memory_effects = #llvm.memory_effects, no_unwind, // CHECK-SAME: sym_name = "_Z38intel_sub_group_f16_f16_matrix_mad_k16Dv8_sDv8_iDv8_f", visibility_ = 0 : i64, will_return} // CHECK-SAME: : (vector<8xi16>, vector<8xi32>, vector<8xf32>) -> vector<8xf32> %c_result = xevm.mma %loaded_a, %loaded_b_casted, %loaded_c_casted @@ -230,13 +230,13 @@ llvm.func @memfence() { // ----- // CHECK-LABEL: llvm.func spir_funccc @_Z8prefetchPU3AS1Kcm(!llvm.ptr<1>, i64) attributes -// CHECK-SAME: {memory_effects = #llvm.memory_effects, no_unwind} +// CHECK-SAME: {memory_effects = #llvm.memory_effects, no_unwind} // CHECK: llvm.func @prefetch(%[[ARG0:.*]]: !llvm.ptr<1>) { llvm.func @prefetch(%ptr: !llvm.ptr<1>) { // CHECK: %[[VAR0:.*]] = llvm.mlir.constant(1 : i64) : i64 // CHECK: llvm.call spir_funccc @_Z8prefetchPU3AS1Kcm(%[[ARG0]], %[[VAR0]]) // CHECK-SAME: {function_type = !llvm.func, i64)>, linkage = #llvm.linkage, - // CHECK-SAME: memory_effects = #llvm.memory_effects, + // CHECK-SAME: memory_effects = #llvm.memory_effects, // CHECK-SAME: no_unwind, sym_name = "_Z8prefetchPU3AS1Kcm", visibility_ = 0 : i64 xevm.prefetch %ptr <{cache_control = #xevm.load_cache_control}> : (!llvm.ptr<1>) llvm.return @@ -352,7 +352,7 @@ llvm.func @local_id.x() -> i32 { // CHECK: %[[VAR0:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[VAR1:.*]] = llvm.call spir_funccc @_Z12get_local_idj(%[[VAR0]]) // CHECK-SAME: {function_type = !llvm.func, linkage = #llvm.linkage, - // CHECK-SAME: memory_effects = #llvm.memory_effects, + // CHECK-SAME: memory_effects = #llvm.memory_effects, // CHECK-SAME: no_unwind, sym_name = "_Z12get_local_idj", visibility_ = 0 : i64, will_return} : (i32) -> i32 %1 = xevm.local_id.x : i32 llvm.return %1 : i32 @@ -380,7 +380,7 @@ llvm.func @local_size.x() -> i32 { // CHECK: %[[VAR0:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[VAR1:.*]] = llvm.call spir_funccc @_Z14get_local_sizej(%[[VAR0]]) // CHECK-SAME: {function_type = !llvm.func, linkage = #llvm.linkage, - // CHECK-SAME: memory_effects = #llvm.memory_effects, + // CHECK-SAME: memory_effects = #llvm.memory_effects, // CHECK-SAME: no_unwind, sym_name = "_Z14get_local_sizej", visibility_ = 0 : i64, will_return} : (i32) -> i32 %1 = xevm.local_size.x : i32 llvm.return %1 : i32 @@ -408,7 +408,7 @@ llvm.func @group_id.x() -> i32 { // CHECK: %[[VAR0:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[VAR1:.*]] = llvm.call spir_funccc @_Z12get_group_idj(%[[VAR0]]) // CHECK-SAME: {function_type = !llvm.func, linkage = #llvm.linkage, - // CHECK-SAME: memory_effects = #llvm.memory_effects, + // CHECK-SAME: memory_effects = #llvm.memory_effects, // CHECK-SAME: no_unwind, sym_name = "_Z12get_group_idj", visibility_ = 0 : i64, will_return} : (i32) -> i32 %1 = xevm.group_id.x : i32 llvm.return %1 : i32 @@ -436,7 +436,7 @@ llvm.func @group_count.x() -> i32 { // CHECK: %[[VAR0:.*]] = llvm.mlir.constant(0 : i32) : i32 // CHECK: %[[VAR1:.*]] = llvm.call spir_funccc @_Z14get_num_groupsj(%[[VAR0]]) // CHECK-SAME: {function_type = !llvm.func, linkage = #llvm.linkage, - // CHECK-SAME: memory_effects = #llvm.memory_effects, + // CHECK-SAME: memory_effects = #llvm.memory_effects, // CHECK-SAME: no_unwind, sym_name = "_Z14get_num_groupsj", visibility_ = 0 : i64, will_return} : (i32) -> i32 %1 = xevm.group_count.x : i32 llvm.return %1 : i32 @@ -463,7 +463,7 @@ llvm.func @group_count.z() -> i32 { llvm.func @lane_id() -> i32 { // CHECK: %[[VAR0:.*]] = llvm.call spir_funccc @_Z22get_sub_group_local_id() // CHECK-SAME: {function_type = !llvm.func, linkage = #llvm.linkage, - // CHECK-SAME: memory_effects = #llvm.memory_effects, + // CHECK-SAME: memory_effects = #llvm.memory_effects, // CHECK-SAME: no_unwind, sym_name = "_Z22get_sub_group_local_id", visibility_ = 0 : i64, will_return} : () -> i32 %1 = xevm.lane_id : i32 llvm.return %1 : i32 @@ -474,7 +474,7 @@ llvm.func @lane_id() -> i32 { llvm.func @subgroup_size() -> i32 { // CHECK: %[[VAR0:.*]] = llvm.call spir_funccc @_Z18get_sub_group_size() // CHECK-SAME: {function_type = !llvm.func, linkage = #llvm.linkage, - // CHECK-SAME: memory_effects = #llvm.memory_effects, + // CHECK-SAME: memory_effects = #llvm.memory_effects, // CHECK-SAME: no_unwind, sym_name = "_Z18get_sub_group_size", visibility_ = 0 : i64, will_return} : () -> i32 %1 = xevm.subgroup_size : i32 llvm.return %1 : i32 @@ -485,7 +485,7 @@ llvm.func @subgroup_size() -> i32 { llvm.func @subgroup_id() -> i32 { // CHECK: %[[VAR0:.*]] = llvm.call spir_funccc @_Z16get_sub_group_id() // CHECK-SAME: {function_type = !llvm.func, linkage = #llvm.linkage, - // CHECK-SAME: memory_effects = #llvm.memory_effects, + // CHECK-SAME: memory_effects = #llvm.memory_effects, // CHECK-SAME: no_unwind, sym_name = "_Z16get_sub_group_id", visibility_ = 0 : i64, will_return} : () -> i32 %1 = xevm.subgroup_id : i32 llvm.return %1 : i32 diff --git a/mlir/test/Dialect/LLVMIR/func.mlir b/mlir/test/Dialect/LLVMIR/func.mlir index cec4586b80074..094313ca048c7 100644 --- a/mlir/test/Dialect/LLVMIR/func.mlir +++ b/mlir/test/Dialect/LLVMIR/func.mlir @@ -210,8 +210,8 @@ module { } // CHECK-LABEL: llvm.func @memory_attr - // CHECK-SAME: attributes {memory = #llvm.memory_effects} { - llvm.func @memory_attr() attributes {memory = #llvm.memory_effects} { + // CHECK-SAME: attributes {memory = #llvm.memory_effects} { + llvm.func @memory_attr() attributes {memory = #llvm.memory_effects} { llvm.return } diff --git a/mlir/test/Dialect/LLVMIR/inlining.mlir b/mlir/test/Dialect/LLVMIR/inlining.mlir index 8e292f4c300d3..9a77c5e223110 100644 --- a/mlir/test/Dialect/LLVMIR/inlining.mlir +++ b/mlir/test/Dialect/LLVMIR/inlining.mlir @@ -422,7 +422,7 @@ llvm.func @test_byval(%ptr : !llvm.ptr) { // ----- -llvm.func @with_byval_arg(%ptr : !llvm.ptr { llvm.byval = f64 }) attributes {memory_effects = #llvm.memory_effects} { +llvm.func @with_byval_arg(%ptr : !llvm.ptr { llvm.byval = f64 }) attributes {memory_effects = #llvm.memory_effects} { llvm.return } @@ -436,7 +436,7 @@ llvm.func @test_byval_read_only(%ptr : !llvm.ptr) { // ----- -llvm.func @with_byval_arg(%ptr : !llvm.ptr { llvm.byval = f64 }) attributes {memory_effects = #llvm.memory_effects} { +llvm.func @with_byval_arg(%ptr : !llvm.ptr { llvm.byval = f64 }) attributes {memory_effects = #llvm.memory_effects} { llvm.return } @@ -451,7 +451,7 @@ llvm.func @test_byval_write_only(%ptr : !llvm.ptr) { // ----- -llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects} { +llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects} { llvm.return } @@ -472,7 +472,7 @@ llvm.func @test_byval_input_aligned(%unaligned : !llvm.ptr, %aligned : !llvm.ptr llvm.func @func_that_uses_ptr(%ptr : !llvm.ptr) -llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects} { +llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects} { llvm.call @func_that_uses_ptr(%ptr) : (!llvm.ptr) -> () llvm.return } @@ -496,7 +496,7 @@ module attributes { llvm.func @func_that_uses_ptr(%ptr : !llvm.ptr) -llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects} { +llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects} { llvm.call @func_that_uses_ptr(%ptr) : (!llvm.ptr) -> () llvm.return } @@ -524,7 +524,7 @@ module attributes { llvm.func @func_that_uses_ptr(%ptr : !llvm.ptr) -llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects} { +llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects} { llvm.call @func_that_uses_ptr(%ptr) : (!llvm.ptr) -> () llvm.return } @@ -550,7 +550,7 @@ llvm.func @test_alignment_exceeded_anyway() { llvm.mlir.global private @unaligned_global(42 : i64) : i64 llvm.mlir.global private @aligned_global(42 : i64) { alignment = 64 } : i64 -llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects} { +llvm.func @aligned_byval_arg(%ptr : !llvm.ptr { llvm.byval = i16, llvm.align = 16 }) attributes {memory_effects = #llvm.memory_effects} { llvm.return } diff --git a/mlir/test/Dialect/LLVMIR/roundtrip.mlir b/mlir/test/Dialect/LLVMIR/roundtrip.mlir index 00e763a8ffc04..afbf47ef3041d 100644 --- a/mlir/test/Dialect/LLVMIR/roundtrip.mlir +++ b/mlir/test/Dialect/LLVMIR/roundtrip.mlir @@ -122,8 +122,8 @@ func.func @ops(%arg0: i32, %arg1: f32, // CHECK: llvm.call @baz() {will_return} : () -> () llvm.call @baz() {will_return} : () -> () -// CHECK: llvm.call @baz() {memory = #llvm.memory_effects} : () -> () - llvm.call @baz() {memory = #llvm.memory_effects} : () -> () +// CHECK: llvm.call @baz() {memory = #llvm.memory_effects} : () -> () + llvm.call @baz() {memory = #llvm.memory_effects} : () -> () // Terminator operations and their successors. // diff --git a/mlir/test/Target/LLVMIR/Import/function-attributes.ll b/mlir/test/Target/LLVMIR/Import/function-attributes.ll index 83c0438840f35..023b0120f9bbe 100644 --- a/mlir/test/Target/LLVMIR/Import/function-attributes.ll +++ b/mlir/test/Target/LLVMIR/Import/function-attributes.ll @@ -22,14 +22,14 @@ define dso_local void @dsolocal_func() { ; // ----- ; CHECK-LABEL: @func_readnone -; CHECK-SAME: attributes {memory_effects = #llvm.memory_effects} +; CHECK-SAME: attributes {memory_effects = #llvm.memory_effects} ; CHECK: llvm.return define void @func_readnone() readnone { ret void } ; CHECK-LABEL: @func_readnone_indirect -; CHECK-SAME: attributes {memory_effects = #llvm.memory_effects} +; CHECK-SAME: attributes {memory_effects = #llvm.memory_effects} declare void @func_readnone_indirect() #0 attributes #0 = { readnone } @@ -169,7 +169,7 @@ define void @entry_count() !prof !1 { ; // ----- ; CHECK-LABEL: @func_memory -; CHECK-SAME: attributes {memory_effects = #llvm.memory_effects} +; CHECK-SAME: attributes {memory_effects = #llvm.memory_effects} ; CHECK: llvm.return define void @func_memory() memory(readwrite, argmem: none) { ret void diff --git a/mlir/test/Target/LLVMIR/Import/instructions.ll b/mlir/test/Target/LLVMIR/Import/instructions.ll index be245e35f087d..7f9c511ec75b0 100644 --- a/mlir/test/Target/LLVMIR/Import/instructions.ll +++ b/mlir/test/Target/LLVMIR/Import/instructions.ll @@ -703,13 +703,13 @@ declare void @f() ; CHECK-LABEL: @call_memory_effects define void @call_memory_effects() { -; CHECK: llvm.call @f() {memory_effects = #llvm.memory_effects} +; CHECK: llvm.call @f() {memory_effects = #llvm.memory_effects} call void @f() memory(none) -; CHECK: llvm.call @f() {memory_effects = #llvm.memory_effects} +; CHECK: llvm.call @f() {memory_effects = #llvm.memory_effects} call void @f() memory(none, argmem: write, inaccessiblemem: read) -; CHECK: llvm.call @f() {memory_effects = #llvm.memory_effects} +; CHECK: llvm.call @f() {memory_effects = #llvm.memory_effects} call void @f() memory(write, argmem: none) -; CHECK: llvm.call @f() {memory_effects = #llvm.memory_effects} +; CHECK: llvm.call @f() {memory_effects = #llvm.memory_effects} call void @f() memory(readwrite, inaccessiblemem: read) ; CHECK: llvm.call @f() ; CHECK-NOT: #llvm.memory_effects diff --git a/mlir/test/Target/LLVMIR/llvmir.mlir b/mlir/test/Target/LLVMIR/llvmir.mlir index 0e087200b1116..d1ed1b4bfa064 100644 --- a/mlir/test/Target/LLVMIR/llvmir.mlir +++ b/mlir/test/Target/LLVMIR/llvmir.mlir @@ -2371,7 +2371,7 @@ llvm.func @readonly_function(%arg0: !llvm.ptr {llvm.readonly}) // CHECK: declare void @arg_mem_none_func() #[[ATTR:[0-9]+]] llvm.func @arg_mem_none_func() attributes { - memory_effects = #llvm.memory_effects} + memory_effects = #llvm.memory_effects} // CHECK: attributes #[[ATTR]] = { memory(readwrite, argmem: none, errnomem: none, target_mem0: none, target_mem1: none) } @@ -2379,7 +2379,7 @@ llvm.func @arg_mem_none_func() attributes { // CHECK: declare void @readwrite_func() #[[ATTR:[0-9]+]] llvm.func @readwrite_func() attributes { - memory_effects = #llvm.memory_effects} + memory_effects = #llvm.memory_effects} // CHECK: attributes #[[ATTR]] = { memory(readwrite, errnomem: none, target_mem0: none, target_mem1: none) } @@ -2723,10 +2723,10 @@ llvm.func @fd() // CHECK: call void @fc() #[[ATTRS_2:[0-9]+]] // CHECK: call void @fd() #[[ATTRS_3:[0-9]+]] llvm.func @mem_effects_call() { - llvm.call @fa() {memory_effects = #llvm.memory_effects} : () -> () - llvm.call @fb() {memory_effects = #llvm.memory_effects} : () -> () - llvm.call @fc() {memory_effects = #llvm.memory_effects} : () -> () - llvm.call @fd() {memory_effects = #llvm.memory_effects} : () -> () + llvm.call @fa() {memory_effects = #llvm.memory_effects} : () -> () + llvm.call @fb() {memory_effects = #llvm.memory_effects} : () -> () + llvm.call @fc() {memory_effects = #llvm.memory_effects} : () -> () + llvm.call @fd() {memory_effects = #llvm.memory_effects} : () -> () llvm.return }