[flang-commits] [flang] 9dec07f - [mlir][openacc] Cleanup acc.enter_data from old data clause operands
Valentin Clement via flang-commits
flang-commits at lists.llvm.org
Tue May 9 09:01:38 PDT 2023
Author: Valentin Clement
Date: 2023-05-09T09:01:30-07:00
New Revision: 9dec07f44a0615ace09aabc19544d4eed0eff2c4
URL: https://github.com/llvm/llvm-project/commit/9dec07f44a0615ace09aabc19544d4eed0eff2c4
DIFF: https://github.com/llvm/llvm-project/commit/9dec07f44a0615ace09aabc19544d4eed0eff2c4.diff
LOG: [mlir][openacc] Cleanup acc.enter_data from old data clause operands
Since the new data operand operations have been added in D148389 and
adopted on acc.enter_data in D148721, the old clause operands are no longer
needed.
The LegalizeDataOpForLLVMTranslation will become obsolete when all
operations will be cleaned. For the time being only the appropriate
part are being removed.
processOperands will also receive some updates once all the operands
will be coming from an acc data operand operation.
Reviewed By: jeanPerier
Differential Revision: https://reviews.llvm.org/D150132
Added:
Modified:
flang/lib/Lower/OpenACC.cpp
flang/lib/Optimizer/Transforms/OpenACC/OpenACCDataOperandConversion.cpp
flang/test/Transforms/OpenACC/convert-data-operands-to-llvmir.fir
mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td
mlir/lib/Conversion/OpenACCToLLVM/OpenACCToLLVM.cpp
mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp
mlir/test/Conversion/OpenACCToLLVM/convert-data-operands-to-llvmir.mlir
mlir/test/Conversion/OpenACCToSCF/convert-openacc-to-scf.mlir
mlir/test/Dialect/OpenACC/canonicalize.mlir
mlir/test/Dialect/OpenACC/invalid.mlir
mlir/test/Dialect/OpenACC/ops.mlir
mlir/test/Target/LLVMIR/openacc-llvm.mlir
Removed:
################################################################################
diff --git a/flang/lib/Lower/OpenACC.cpp b/flang/lib/Lower/OpenACC.cpp
index a0d10847ea50b..562317c5fb7ac 100644
--- a/flang/lib/Lower/OpenACC.cpp
+++ b/flang/lib/Lower/OpenACC.cpp
@@ -1287,7 +1287,6 @@ genACCEnterDataOp(Fortran::lower::AbstractConverter &converter,
addOperand(operands, operandSegments, async);
addOperand(operands, operandSegments, waitDevnum);
addOperands(operands, operandSegments, waitOperands);
- operandSegments.append({0, 0, 0, 0});
addOperands(operands, operandSegments, dataClauseOperands);
mlir::acc::EnterDataOp enterDataOp = createSimpleOp<mlir::acc::EnterDataOp>(
diff --git a/flang/lib/Optimizer/Transforms/OpenACC/OpenACCDataOperandConversion.cpp b/flang/lib/Optimizer/Transforms/OpenACC/OpenACCDataOperandConversion.cpp
index a612c4c4641ed..eb9a95418fa4d 100644
--- a/flang/lib/Optimizer/Transforms/OpenACC/OpenACCDataOperandConversion.cpp
+++ b/flang/lib/Optimizer/Transforms/OpenACC/OpenACCDataOperandConversion.cpp
@@ -116,7 +116,6 @@ void OpenACCDataOperandConversion::runOnOperation() {
fir::LLVMTypeConverter converter(
op.getOperation()->getParentOfType<mlir::ModuleOp>(), true);
patterns.add<LegalizeDataOpForLLVMTranslation<acc::DataOp>>(converter);
- patterns.add<LegalizeDataOpForLLVMTranslation<acc::EnterDataOp>>(converter);
patterns.add<LegalizeDataOpForLLVMTranslation<acc::ExitDataOp>>(converter);
patterns.add<LegalizeDataOpForLLVMTranslation<acc::ParallelOp>>(converter);
@@ -148,14 +147,6 @@ void OpenACCDataOperandConversion::runOnOperation() {
allDataOperandsAreConverted(op.getAttachOperands());
});
- target.addDynamicallyLegalOp<acc::EnterDataOp>(
- [allDataOperandsAreConverted](acc::EnterDataOp op) {
- return allDataOperandsAreConverted(op.getCopyinOperands()) &&
- allDataOperandsAreConverted(op.getCreateOperands()) &&
- allDataOperandsAreConverted(op.getCreateZeroOperands()) &&
- allDataOperandsAreConverted(op.getAttachOperands());
- });
-
target.addDynamicallyLegalOp<acc::ExitDataOp>(
[allDataOperandsAreConverted](acc::ExitDataOp op) {
return allDataOperandsAreConverted(op.getCopyoutOperands()) &&
diff --git a/flang/test/Transforms/OpenACC/convert-data-operands-to-llvmir.fir b/flang/test/Transforms/OpenACC/convert-data-operands-to-llvmir.fir
index bfe5c378bb364..af120b5f9ba89 100644
--- a/flang/test/Transforms/OpenACC/convert-data-operands-to-llvmir.fir
+++ b/flang/test/Transforms/OpenACC/convert-data-operands-to-llvmir.fir
@@ -32,21 +32,17 @@ fir.global internal @_QFEa : !fir.array<10xf32> {
func.func @_QQsub_enter_exit() attributes {fir.bindc_name = "a"} {
%0 = fir.address_of(@_QFEa) : !fir.ref<!fir.array<10xf32>>
- acc.enter_data copyin(%0 : !fir.ref<!fir.array<10xf32>>)
acc.exit_data copyout(%0 : !fir.ref<!fir.array<10xf32>>)
return
}
// CHECK-LABEL: func.func @_QQsub_enter_exit() attributes {fir.bindc_name = "a"} {
// CHECK: %[[ADDR:.*]] = fir.address_of(@_QFEa) : !fir.ref<!fir.array<10xf32>>
-// CHECK: %[[CAST0:.*]] = builtin.unrealized_conversion_cast %[[ADDR]] : !fir.ref<!fir.array<10xf32>> to !llvm.ptr<array<10 x f32>>
-// CHECK: acc.enter_data copyin(%[[CAST0]] : !llvm.ptr<array<10 x f32>>)
// CHECK: %[[CAST1:.*]] = builtin.unrealized_conversion_cast %[[ADDR]] : !fir.ref<!fir.array<10xf32>> to !llvm.ptr<array<10 x f32>>
// CHECK: acc.exit_data copyout(%[[CAST1]] : !llvm.ptr<array<10 x f32>>)
// LLVMIR-LABEL: llvm.func @_QQsub_enter_exit() attributes {fir.bindc_name = "a"} {
// LLVMIR: %[[ADDR:.*]] = llvm.mlir.addressof @_QFEa : !llvm.ptr<array<10 x f32>>
-// LLVMIR: acc.enter_data copyin(%[[ADDR]] : !llvm.ptr<array<10 x f32>>)
// LLVMIR: acc.exit_data copyout(%[[ADDR]] : !llvm.ptr<array<10 x f32>>)
// -----
diff --git a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td
index 6e6cf7c57451f..d453412590deb 100644
--- a/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td
+++ b/mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td
@@ -765,10 +765,6 @@ def OpenACC_EnterDataOp : OpenACC_Op<"enter_data", [AttrSizedOperandSegments]> {
Optional<IntOrIndex>:$waitDevnum,
Variadic<IntOrIndex>:$waitOperands,
UnitAttr:$wait,
- Variadic<AnyType>:$copyinOperands,
- Variadic<AnyType>:$createOperands,
- Variadic<AnyType>:$createZeroOperands,
- Variadic<AnyType>:$attachOperands,
Variadic<OpenACC_PointerLikeTypeInterface>:$dataClauseOperands);
let extraClassDeclaration = [{
@@ -785,11 +781,6 @@ def OpenACC_EnterDataOp : OpenACC_Op<"enter_data", [AttrSizedOperandSegments]> {
| `async` `(` $asyncOperand `:` type($asyncOperand) `)`
| `wait_devnum` `(` $waitDevnum `:` type($waitDevnum) `)`
| `wait` `(` $waitOperands `:` type($waitOperands) `)`
- | `copyin` `(` $copyinOperands `:` type($copyinOperands) `)`
- | `create` `(` $createOperands `:` type($createOperands) `)`
- | `create_zero` `(` $createZeroOperands `:`
- type($createZeroOperands) `)`
- | `attach` `(` $attachOperands `:` type($attachOperands) `)`
| `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)`
)
attr-dict-with-keyword
diff --git a/mlir/lib/Conversion/OpenACCToLLVM/OpenACCToLLVM.cpp b/mlir/lib/Conversion/OpenACCToLLVM/OpenACCToLLVM.cpp
index fc1cc3feeb009..34c578afb99a7 100644
--- a/mlir/lib/Conversion/OpenACCToLLVM/OpenACCToLLVM.cpp
+++ b/mlir/lib/Conversion/OpenACCToLLVM/OpenACCToLLVM.cpp
@@ -156,7 +156,6 @@ class LegalizeDataOpForLLVMTranslation : public ConvertOpToLLVMPattern<Op> {
void mlir::populateOpenACCToLLVMConversionPatterns(
LLVMTypeConverter &converter, RewritePatternSet &patterns) {
patterns.add<LegalizeDataOpForLLVMTranslation<acc::DataOp>>(converter);
- patterns.add<LegalizeDataOpForLLVMTranslation<acc::EnterDataOp>>(converter);
patterns.add<LegalizeDataOpForLLVMTranslation<acc::ExitDataOp>>(converter);
patterns.add<LegalizeDataOpForLLVMTranslation<acc::ParallelOp>>(converter);
}
@@ -209,14 +208,6 @@ void ConvertOpenACCToLLVMPass::runOnOperation() {
allDataOperandsAreConverted(op.getAttachOperands());
});
- target.addDynamicallyLegalOp<acc::EnterDataOp>(
- [allDataOperandsAreConverted](acc::EnterDataOp op) {
- return allDataOperandsAreConverted(op.getCopyinOperands()) &&
- allDataOperandsAreConverted(op.getCreateOperands()) &&
- allDataOperandsAreConverted(op.getCreateZeroOperands()) &&
- allDataOperandsAreConverted(op.getAttachOperands());
- });
-
target.addDynamicallyLegalOp<acc::ExitDataOp>(
[allDataOperandsAreConverted](acc::ExitDataOp op) {
return allDataOperandsAreConverted(op.getCopyoutOperands()) &&
diff --git a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
index e5b22aa0a83d9..49b6b1d53bb7a 100644
--- a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
+++ b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp
@@ -588,12 +588,9 @@ LogicalResult acc::EnterDataOp::verify() {
// 2.6.6. Data Enter Directive restriction
// At least one copyin, create, or attach clause must appear on an enter data
// directive.
- if (getCopyinOperands().empty() && getCreateOperands().empty() &&
- getCreateZeroOperands().empty() && getAttachOperands().empty() &&
- getDataClauseOperands().empty())
- return emitError(
- "at least one operand in copyin, create, "
- "create_zero or attach must appear on the enter data operation");
+ if (getDataClauseOperands().empty())
+ return emitError("at least one operand must be present in dataOperands on "
+ "the enter data operation");
// The async attribute represent the async clause without value. Therefore the
// attribute and operand cannot appear at the same time.
@@ -617,9 +614,7 @@ LogicalResult acc::EnterDataOp::verify() {
}
unsigned EnterDataOp::getNumDataOperands() {
- return getCopyinOperands().size() + getCreateOperands().size() +
- getCreateZeroOperands().size() + getAttachOperands().size() +
- getDataClauseOperands().size();
+ return getDataClauseOperands().size();
}
Value EnterDataOp::getDataOperand(unsigned i) {
diff --git a/mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp b/mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp
index 17403a2f0d87d..c2d075792411c 100644
--- a/mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp
@@ -162,16 +162,30 @@ processDataOperands(llvm::IRBuilderBase &builder,
unsigned index = 0;
// Create operands are handled as `alloc` call.
- if (failed(processOperands(builder, moduleTranslation, op,
- op.getCreateOperands(), op.getNumDataOperands(),
- kCreateFlag, flags, names, index, mapperAllocas)))
+ // Copyin operands are handled as `to` call.
+ llvm::SmallVector<mlir::Value> create, copyin;
+ for (mlir::Value dataOp : op.getDataClauseOperands()) {
+ if (auto createOp =
+ mlir::dyn_cast_or_null<acc::CreateOp>(dataOp.getDefiningOp())) {
+ create.push_back(createOp.getVarPtr());
+ } else if (auto copyinOp = mlir::dyn_cast_or_null<acc::CopyinOp>(
+ dataOp.getDefiningOp())) {
+ copyin.push_back(copyinOp.getVarPtr());
+ }
+ }
+
+ auto nbTotalOperands = create.size() + copyin.size();
+
+ // Create operands are handled as `alloc` call.
+ if (failed(processOperands(builder, moduleTranslation, op, create,
+ nbTotalOperands, kCreateFlag, flags, names, index,
+ mapperAllocas)))
return failure();
// Copyin operands are handled as `to` call.
- if (failed(processOperands(builder, moduleTranslation, op,
- op.getCopyinOperands(), op.getNumDataOperands(),
- kDeviceCopyinFlag, flags, names, index,
- mapperAllocas)))
+ if (failed(processOperands(builder, moduleTranslation, op, copyin,
+ nbTotalOperands, kDeviceCopyinFlag, flags, names,
+ index, mapperAllocas)))
return failure();
return success();
@@ -495,7 +509,7 @@ LogicalResult OpenACCDialectLLVMIRTranslationInterface::convertOperation(
"unexpected OpenACC terminator with operands");
return success();
})
- .Case([&](acc::UpdateDeviceOp) {
+ .Case<acc::CreateOp, acc::CopyinOp, acc::UpdateDeviceOp>([](auto op) {
// NOP
return success();
})
diff --git a/mlir/test/Conversion/OpenACCToLLVM/convert-data-operands-to-llvmir.mlir b/mlir/test/Conversion/OpenACCToLLVM/convert-data-operands-to-llvmir.mlir
index f7cc3cf733fc7..ef12f8d9ee872 100644
--- a/mlir/test/Conversion/OpenACCToLLVM/convert-data-operands-to-llvmir.mlir
+++ b/mlir/test/Conversion/OpenACCToLLVM/convert-data-operands-to-llvmir.mlir
@@ -1,42 +1,5 @@
// RUN: mlir-opt -convert-openacc-to-llvm='use-opaque-pointers=1' -split-input-file %s | FileCheck %s
-func.func @testenterdataop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
- acc.enter_data copyin(%b : memref<10xf32>) create(%a : memref<10xf32>)
- return
-}
-
-// CHECK: acc.enter_data copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) create(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
-
-// -----
-
-func.func @testenterdataop(%a: !llvm.ptr, %b: memref<10xf32>) -> () {
- acc.enter_data copyin(%b : memref<10xf32>) create(%a : !llvm.ptr)
- return
-}
-
-// CHECK: acc.enter_data copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) create(%{{.*}} : !llvm.ptr)
-
-// -----
-
-func.func @testenterdataop(%a: memref<10xi64>, %b: memref<10xf32>) -> () {
- acc.enter_data copyin(%b : memref<10xf32>) create_zero(%a : memref<10xi64>) attributes {async}
- return
-}
-
-// CHECK: acc.enter_data copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) create_zero(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) attributes {async}
-
-// -----
-
-func.func @testenterdataop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
- %ifCond = arith.constant true
- acc.enter_data if(%ifCond) copyin(%b : memref<10xf32>) create(%a : memref<10xf32>)
- return
-}
-
-// CHECK: acc.enter_data if(%{{.*}}) copyin(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) create(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
-
-// -----
-
func.func @testexitdataop(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
acc.exit_data copyout(%b : memref<10xf32>) delete(%a : memref<10xf32>)
return
diff --git a/mlir/test/Conversion/OpenACCToSCF/convert-openacc-to-scf.mlir b/mlir/test/Conversion/OpenACCToSCF/convert-openacc-to-scf.mlir
index ce3ad44a83e50..a9d81214190fa 100644
--- a/mlir/test/Conversion/OpenACCToSCF/convert-openacc-to-scf.mlir
+++ b/mlir/test/Conversion/OpenACCToSCF/convert-openacc-to-scf.mlir
@@ -1,13 +1,14 @@
// RUN: mlir-opt %s -convert-openacc-to-scf -split-input-file | FileCheck %s
-func.func @testenterdataop(%a: memref<10xf32>, %ifCond: i1) -> () {
- acc.enter_data if(%ifCond) create(%a: memref<10xf32>)
+func.func @testenterdataop(%a: memref<f32>, %ifCond: i1) -> () {
+ %0 = acc.create varPtr(%a : memref<f32>) -> memref<f32>
+ acc.enter_data if(%ifCond) dataOperands(%0 : memref<f32>)
return
}
-// CHECK: func @testenterdataop(%{{.*}}: memref<10xf32>, [[IFCOND:%.*]]: i1)
+// CHECK: func @testenterdataop(%{{.*}}: memref<f32>, [[IFCOND:%.*]]: i1)
// CHECK: scf.if [[IFCOND]] {
-// CHECK-NEXT: acc.enter_data create(%{{.*}} : memref<10xf32>)
+// CHECK-NEXT: acc.enter_data dataOperands(%{{.*}} : memref<f32>)
// CHECK-NEXT: }
// -----
@@ -62,26 +63,28 @@ func.func @update_false(%arg0: memref<f32>) {
// -----
-func.func @enter_data_true(%d1 : memref<10xf32>) {
+func.func @enter_data_true(%d1 : memref<f32>) {
%true = arith.constant true
- acc.enter_data if(%true) create(%d1 : memref<10xf32>) attributes {async}
+ %0 = acc.create varPtr(%d1 : memref<f32>) -> memref<f32>
+ acc.enter_data if(%true) dataOperands(%0 : memref<f32>) attributes {async}
return
}
// CHECK-LABEL: func.func @enter_data_true
// CHECK-NOT: if
-// CHECK: acc.enter_data create
+// CHECK: acc.enter_data dataOperands
// -----
-func.func @enter_data_false(%d1 : memref<10xf32>) {
+func.func @enter_data_false(%d1 : memref<f32>) {
%false = arith.constant false
- acc.enter_data if(%false) create(%d1 : memref<10xf32>) attributes {async}
+ %0 = acc.create varPtr(%d1 : memref<f32>) -> memref<f32>
+ acc.enter_data if(%false) dataOperands(%0 : memref<f32>) attributes {async}
return
}
// CHECK-LABEL: func.func @enter_data_false
-// CHECK-NOT:acc.enter_data
+// CHECK-NOT: acc.enter_data
// -----
diff --git a/mlir/test/Dialect/OpenACC/canonicalize.mlir b/mlir/test/Dialect/OpenACC/canonicalize.mlir
index c0d8e152a5458..0cb827ad6b3a7 100644
--- a/mlir/test/Dialect/OpenACC/canonicalize.mlir
+++ b/mlir/test/Dialect/OpenACC/canonicalize.mlir
@@ -1,18 +1,20 @@
// RUN: mlir-opt %s -canonicalize="test-convergence" -split-input-file | FileCheck %s
-func.func @testenterdataop(%a: memref<10xf32>) -> () {
+func.func @testenterdataop(%a: memref<f32>) -> () {
%ifCond = arith.constant true
- acc.enter_data if(%ifCond) create(%a: memref<10xf32>)
+ %0 = acc.create varPtr(%a : memref<f32>) -> memref<f32>
+ acc.enter_data if(%ifCond) dataOperands(%0 : memref<f32>)
return
}
-// CHECK: acc.enter_data create(%{{.*}} : memref<10xf32>)
+// CHECK: acc.enter_data dataOperands(%{{.*}} : memref<f32>)
// -----
-func.func @testenterdataop(%a: memref<10xf32>) -> () {
+func.func @testenterdataop(%a: memref<f32>) -> () {
%ifCond = arith.constant false
- acc.enter_data if(%ifCond) create(%a: memref<10xf32>)
+ %0 = acc.create varPtr(%a : memref<f32>) -> memref<f32>
+ acc.enter_data if(%ifCond) dataOperands(%0 : memref<f32>)
return
}
@@ -67,13 +69,14 @@ func.func @testupdateop(%a: memref<f32>) -> () {
// -----
-func.func @testenterdataop(%a: memref<10xf32>, %ifCond: i1) -> () {
- acc.enter_data if(%ifCond) create(%a: memref<10xf32>)
+func.func @testenterdataop(%a: memref<f32>, %ifCond: i1) -> () {
+ %0 = acc.create varPtr(%a : memref<f32>) -> memref<f32>
+ acc.enter_data if(%ifCond) dataOperands(%0 : memref<f32>)
return
}
-// CHECK: func @testenterdataop(%{{.*}}: memref<10xf32>, [[IFCOND:%.*]]: i1)
-// CHECK: acc.enter_data if(%{{.*}}) create(%{{.*}} : memref<10xf32>)
+// CHECK: func @testenterdataop(%{{.*}}: memref<f32>, [[IFCOND:%.*]]: i1)
+// CHECK: acc.enter_data if(%{{.*}}) dataOperands(%{{.*}} : memref<f32>)
// -----
diff --git a/mlir/test/Dialect/OpenACC/invalid.mlir b/mlir/test/Dialect/OpenACC/invalid.mlir
index d4795dff6f239..a3b3c0d1db035 100644
--- a/mlir/test/Dialect/OpenACC/invalid.mlir
+++ b/mlir/test/Dialect/OpenACC/invalid.mlir
@@ -186,29 +186,32 @@ acc.exit_data wait_devnum(%cst: index) delete(%value : memref<10xf32>)
// -----
-// expected-error at +1 {{at least one operand in copyin, create, create_zero or attach must appear on the enter data operation}}
+// expected-error at +1 {{at least one operand must be present in dataOperands on the enter data operation}}
acc.enter_data attributes {async}
// -----
%cst = arith.constant 1 : index
-%value = memref.alloc() : memref<10xf32>
+%value = memref.alloc() : memref<f32>
+%0 = acc.create varPtr(%value : memref<f32>) -> memref<f32>
// expected-error at +1 {{async attribute cannot appear with asyncOperand}}
-acc.enter_data async(%cst: index) create(%value : memref<10xf32>) attributes {async}
+acc.enter_data async(%cst: index) dataOperands(%0 : memref<f32>) attributes {async}
// -----
%cst = arith.constant 1 : index
-%value = memref.alloc() : memref<10xf32>
+%value = memref.alloc() : memref<f32>
+%0 = acc.create varPtr(%value : memref<f32>) -> memref<f32>
// expected-error at +1 {{wait attribute cannot appear with waitOperands}}
-acc.enter_data wait(%cst: index) create(%value : memref<10xf32>) attributes {wait}
+acc.enter_data wait(%cst: index) dataOperands(%0 : memref<f32>) attributes {wait}
// -----
%cst = arith.constant 1 : index
-%value = memref.alloc() : memref<10xf32>
+%value = memref.alloc() : memref<f32>
+%0 = acc.create varPtr(%value : memref<f32>) -> memref<f32>
// expected-error at +1 {{wait_devnum cannot appear without waitOperands}}
-acc.enter_data wait_devnum(%cst: index) create(%value : memref<10xf32>)
+acc.enter_data wait_devnum(%cst: index) dataOperands(%0 : memref<f32>)
// -----
diff --git a/mlir/test/Dialect/OpenACC/ops.mlir b/mlir/test/Dialect/OpenACC/ops.mlir
index e46167e3fb29b..9c1f2848f6afe 100644
--- a/mlir/test/Dialect/OpenACC/ops.mlir
+++ b/mlir/test/Dialect/OpenACC/ops.mlir
@@ -945,39 +945,61 @@ func.func @testexitdataop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x
// -----
-func.func @testenterdataop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) -> () {
+func.func @testenterdataop(%a: !llvm.ptr<f32>, %b: !llvm.ptr<f32>, %c: !llvm.ptr<f32>) -> () {
%ifCond = arith.constant true
%i64Value = arith.constant 1 : i64
%i32Value = arith.constant 1 : i32
%idxValue = arith.constant 1 : index
- acc.enter_data copyin(%a : memref<10xf32>)
- acc.enter_data create(%a : memref<10xf32>) create_zero(%b, %c : memref<10xf32>, memref<10x10xf32>)
- acc.enter_data attach(%a : memref<10xf32>)
- acc.enter_data copyin(%a : memref<10xf32>) attributes {async}
- acc.enter_data create(%a : memref<10xf32>) attributes {wait}
- acc.enter_data async(%i64Value : i64) copyin(%a : memref<10xf32>)
- acc.enter_data copyin(%a : memref<10xf32>) async(%i64Value : i64)
- acc.enter_data if(%ifCond) copyin(%a : memref<10xf32>)
- acc.enter_data wait_devnum(%i64Value: i64) wait(%i32Value, %idxValue : i32, index) copyin(%a : memref<10xf32>)
+ %0 = acc.copyin varPtr(%a : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+ acc.enter_data dataOperands(%0 : !llvm.ptr<f32>)
+ %1 = acc.create varPtr(%a : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+ %2 = acc.create varPtr(%b : !llvm.ptr<f32>) -> !llvm.ptr<f32> {dataClause = 8 : i64}
+ %3 = acc.create varPtr(%c : !llvm.ptr<f32>) -> !llvm.ptr<f32> {dataClause = 8 : i64}
+ acc.enter_data dataOperands(%1, %2, %3 : !llvm.ptr<f32>, !llvm.ptr<f32>, !llvm.ptr<f32>)
+ %4 = acc.attach varPtr(%a : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+ acc.enter_data dataOperands(%4 : !llvm.ptr<f32>)
+ %5 = acc.copyin varPtr(%a : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+ acc.enter_data dataOperands(%5 : !llvm.ptr<f32>) attributes {async}
+ %6 = acc.create varPtr(%a : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+ acc.enter_data dataOperands(%6 : !llvm.ptr<f32>) attributes {wait}
+ %7 = acc.copyin varPtr(%a : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+ acc.enter_data async(%i64Value : i64) dataOperands(%7 : !llvm.ptr<f32>)
+ %8 = acc.copyin varPtr(%a : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+ acc.enter_data dataOperands(%8 : !llvm.ptr<f32>) async(%i64Value : i64)
+ %9 = acc.copyin varPtr(%a : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+ acc.enter_data if(%ifCond) dataOperands(%9 : !llvm.ptr<f32>)
+ %10 = acc.copyin varPtr(%a : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+ acc.enter_data wait_devnum(%i64Value: i64) wait(%i32Value, %idxValue : i32, index) dataOperands(%10 : !llvm.ptr<f32>)
return
}
-// CHECK: func @testenterdataop([[ARGA:%.*]]: memref<10xf32>, [[ARGB:%.*]]: memref<10xf32>, [[ARGC:%.*]]: memref<10x10xf32>) {
+// CHECK: func @testenterdataop(%[[ARGA:.*]]: !llvm.ptr<f32>, %[[ARGB:.*]]: !llvm.ptr<f32>, %[[ARGC:.*]]: !llvm.ptr<f32>) {
// CHECK: [[IFCOND1:%.*]] = arith.constant true
// CHECK: [[I64VALUE:%.*]] = arith.constant 1 : i64
// CHECK: [[I32VALUE:%.*]] = arith.constant 1 : i32
// CHECK: [[IDXVALUE:%.*]] = arith.constant 1 : index
-// CHECK: acc.enter_data copyin([[ARGA]] : memref<10xf32>)
-// CHECK: acc.enter_data create([[ARGA]] : memref<10xf32>) create_zero([[ARGB]], [[ARGC]] : memref<10xf32>, memref<10x10xf32>)
-// CHECK: acc.enter_data attach([[ARGA]] : memref<10xf32>)
-// CHECK: acc.enter_data copyin([[ARGA]] : memref<10xf32>) attributes {async}
-// CHECK: acc.enter_data create([[ARGA]] : memref<10xf32>) attributes {wait}
-// CHECK: acc.enter_data async([[I64VALUE]] : i64) copyin([[ARGA]] : memref<10xf32>)
-// CHECK: acc.enter_data async([[I64VALUE]] : i64) copyin([[ARGA]] : memref<10xf32>)
-// CHECK: acc.enter_data if([[IFCOND]]) copyin([[ARGA]] : memref<10xf32>)
-// CHECK: acc.enter_data wait_devnum([[I64VALUE]] : i64) wait([[I32VALUE]], [[IDXVALUE]] : i32, index) copyin([[ARGA]] : memref<10xf32>)
+// CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[ARGA]] : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+// CHECK: acc.enter_data dataOperands(%[[COPYIN]] : !llvm.ptr<f32>)
+// CHECK: %[[CREATE_A:.*]] = acc.create varPtr(%[[ARGA]] : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+// CHECK: %[[CREATE_B:.*]] = acc.create varPtr(%[[ARGB]] : !llvm.ptr<f32>) -> !llvm.ptr<f32> {dataClause = 8 : i64}
+// CHECK: %[[CREATE_C:.*]] = acc.create varPtr(%[[ARGC]] : !llvm.ptr<f32>) -> !llvm.ptr<f32> {dataClause = 8 : i64}
+// CHECK: acc.enter_data dataOperands(%[[CREATE_A]], %[[CREATE_B]], %[[CREATE_C]] : !llvm.ptr<f32>, !llvm.ptr<f32>, !llvm.ptr<f32>)
+// CHECK: %[[ATTACH:.*]] = acc.attach varPtr(%[[ARGA]] : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+// CHECK: acc.enter_data dataOperands(%[[ATTACH]] : !llvm.ptr<f32>)
+// CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[ARGA]] : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+// CHECK: acc.enter_data dataOperands(%[[COPYIN]] : !llvm.ptr<f32>) attributes {async}
+// CHECK: %[[CREATE:.*]] = acc.create varPtr(%[[ARGA]] : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+// CHECK: acc.enter_data dataOperands(%[[CREATE]] : !llvm.ptr<f32>) attributes {wait}
+// CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[ARGA]] : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+// CHECK: acc.enter_data async([[I64VALUE]] : i64) dataOperands(%[[COPYIN]] : !llvm.ptr<f32>)
+// CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[ARGA]] : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+// CHECK: acc.enter_data async([[I64VALUE]] : i64) dataOperands(%[[COPYIN]] : !llvm.ptr<f32>)
+// CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[ARGA]] : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+// CHECK: acc.enter_data if([[IFCOND]]) dataOperands(%[[COPYIN]] : !llvm.ptr<f32>)
+// CHECK: %[[COPYIN:.*]] = acc.copyin varPtr(%[[ARGA]] : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+// CHECK: acc.enter_data wait_devnum([[I64VALUE]] : i64) wait([[I32VALUE]], [[IDXVALUE]] : i32, index) dataOperands(%[[COPYIN]] : !llvm.ptr<f32>)
// -----
diff --git a/mlir/test/Target/LLVMIR/openacc-llvm.mlir b/mlir/test/Target/LLVMIR/openacc-llvm.mlir
index 61a2d968247fb..f5ebea82ee19f 100644
--- a/mlir/test/Target/LLVMIR/openacc-llvm.mlir
+++ b/mlir/test/Target/LLVMIR/openacc-llvm.mlir
@@ -1,62 +1,46 @@
// RUN: mlir-translate -mlir-to-llvmir -split-input-file %s | FileCheck %s
-llvm.func @testenterdataop(%arg0: !llvm.ptr<f32>, %arg1: !llvm.ptr<f32>, %arg2: i64, %arg3: i64, %arg4: i64, %arg5: !llvm.ptr<f32>) {
- %0 = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- %1 = llvm.insertvalue %arg0, %0[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- %2 = llvm.insertvalue %arg1, %1[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- %3 = llvm.insertvalue %arg2, %2[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- %4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- %5 = llvm.insertvalue %arg4, %4[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- %6 = llvm.mlir.constant(10 : index) : i64
- %7 = llvm.mlir.constant(1 : index) : i64
- %8 = llvm.mlir.null : !llvm.ptr<f32>
- %9 = llvm.getelementptr %8[%6] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
- %10 = llvm.ptrtoint %9 : !llvm.ptr<f32> to i64
- %11 = llvm.extractvalue %5[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
- %12 = llvm.mlir.undef : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
- %13 = llvm.insertvalue %5, %12[0] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
- %14 = llvm.insertvalue %11, %13[1] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
- %15 = llvm.insertvalue %10, %14[2] : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>
- acc.enter_data copyin(%arg5 : !llvm.ptr<f32>) create(%15 : !llvm.struct<"openacc_data", (struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>, ptr<f32>, i64)>)
+llvm.func @testenterdataop(%arg0: !llvm.ptr<f32>, %arg1 : !llvm.ptr<f32>) {
+ %0 = acc.create varPtr(%arg0 : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+ %1 = acc.copyin varPtr(%arg1 : !llvm.ptr<f32>) -> !llvm.ptr<f32>
+ acc.enter_data dataOperands(%0, %1 : !llvm.ptr<f32>, !llvm.ptr<f32>)
llvm.return
}
// CHECK: %struct.ident_t = type { i32, i32, i32, i32, ptr }
-// CHECK: [[LOCSTR:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};testenterdataop;{{[0-9]*}};{{[0-9]*}};;\00", align 1
-// CHECK: [[LOCGLOBAL:@.*]] = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 {{[0-9]*}}, ptr [[LOCSTR]] }, align 8
-// CHECK: [[MAPNAME1:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};unknown;{{[0-9]*}};{{[0-9]*}};;\00", align 1
-// CHECK: [[MAPNAME2:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};unknown;{{[0-9]*}};{{[0-9]*}};;\00", align 1
-// CHECK: [[MAPTYPES:@.*]] = private unnamed_addr constant [{{[0-9]*}} x i64] [i64 0, i64 1]
-// CHECK: [[MAPNAMES:@.*]] = private constant [{{[0-9]*}} x ptr] [ptr [[MAPNAME1]], ptr [[MAPNAME2]]]
+// CHECK: @[[LOCSTR:.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};testenterdataop;{{[0-9]*}};{{[0-9]*}};;\00", align 1
+// CHECK: @[[LOCGLOBAL:.*]] = private unnamed_addr constant %struct.ident_t { i32 0, i32 2, i32 0, i32 {{[0-9]*}}, ptr @[[LOCSTR]] }, align 8
+// CHECK: @[[MAPNAME1:.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};unknown;{{[0-9]*}};{{[0-9]*}};;\00", align 1
+// CHECK: @[[MAPNAME2:.*]] = private unnamed_addr constant [{{[0-9]*}} x i8] c";{{.*}};unknown;{{[0-9]*}};{{[0-9]*}};;\00", align 1
+// CHECK: @[[MAPTYPES:.*]] = private unnamed_addr constant [{{[0-9]*}} x i64] [i64 0, i64 1]
+// CHECK: @[[MAPNAMES:.*]] = private constant [{{[0-9]*}} x ptr] [ptr @[[MAPNAME1]], ptr @[[MAPNAME2]]]
-// CHECK: define void @testenterdataop(ptr %{{.*}}, ptr %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, i64 %{{.*}}, ptr [[SIMPLEPTR:%.*]])
-// CHECK: [[ARGBASE_ALLOCA:%.*]] = alloca [{{[0-9]*}} x ptr], align 8
-// CHECK: [[ARG_ALLOCA:%.*]] = alloca [{{[0-9]*}} x ptr], align 8
-// CHECK: [[SIZE_ALLOCA:%.*]] = alloca [{{[0-9]*}} x i64], align 8
+// CHECK: define void @testenterdataop(ptr %[[PTR0:.*]], ptr %[[PTR1:.*]])
+// CHECK: %[[OFFLOAD_BASEPTR:.*]] = alloca [{{[0-9]*}} x ptr]
+// CHECK: %[[OFFLOAD_PTRS:.*]] = alloca [{{[0-9]*}} x ptr]
+// CHECK: %[[OFFLOAD_SIZES:.*]] = alloca [{{[0-9]*}} x i64]
-// CHECK: [[ARGBASE:%.*]] = extractvalue %openacc_data %{{.*}}, 0
-// CHECK: [[ARG:%.*]] = extractvalue %openacc_data %{{.*}}, 1
-// CHECK: [[ARGSIZE:%.*]] = extractvalue %openacc_data %{{.*}}, 2
-// CHECK: [[ARGBASEGEP:%.*]] = getelementptr inbounds [2 x ptr], ptr [[ARGBASE_ALLOCA]], i32 0, i32 0
-// CHECK: store { ptr, ptr, i64, [1 x i64], [1 x i64] } [[ARGBASE]], ptr [[ARGBASEGEP]], align 8
-// CHECK: [[ARGGEP:%.*]] = getelementptr inbounds [2 x ptr], ptr [[ARG_ALLOCA]], i32 0, i32 0
-// CHECK: store ptr [[ARG]], ptr [[ARGGEP]], align 8
-// CHECK: [[SIZEGEP:%.*]] = getelementptr inbounds [2 x i64], ptr [[SIZE_ALLOCA]], i32 0, i32 0
-// CHECK: store i64 [[ARGSIZE]], ptr [[SIZEGEP]], align 4
+// CHECK: %[[OFFLOAD_BASEPTR_GEP:.*]] = getelementptr inbounds [2 x ptr], ptr %[[OFFLOAD_BASEPTR]], i32 0, i32 0
+// CHECK: store ptr %[[PTR0]], ptr %[[OFFLOAD_BASEPTR_GEP]]
+// CHECK: %[[OFFLOAD_PTRS_GEP:.*]] = getelementptr inbounds [2 x ptr], ptr %[[OFFLOAD_PTRS]], i32 0, i32 0
+// CHECK: store ptr %[[PTR0]], ptr %[[OFFLOAD_PTRS_GEP]]
+// CHECK: %[[OFFLOAD_SIZES_GEP:.*]] = getelementptr inbounds [2 x i64], ptr %[[OFFLOAD_SIZES]], i32 0, i32 0
+// CHECK: store i64 ptrtoint (ptr getelementptr (ptr, ptr null, i32 1) to i64), ptr %[[OFFLOAD_SIZES_GEP]]
-// CHECK: [[ARGBASEGEP:%.*]] = getelementptr inbounds [2 x ptr], ptr [[ARGBASE_ALLOCA]], i32 0, i32 1
-// CHECK: store ptr [[SIMPLEPTR]], ptr [[ARGBASEGEP]], align 8
-// CHECK: [[ARGGEP:%.*]] = getelementptr inbounds [2 x ptr], ptr [[ARG_ALLOCA]], i32 0, i32 1
-// CHECK: store ptr [[SIMPLEPTR]], ptr [[ARGGEP]], align 8
-// CHECK: [[SIZEGEP:%.*]] = getelementptr inbounds [2 x i64], ptr [[SIZE_ALLOCA]], i32 0, i32 1
-// CHECK: store i64 ptrtoint (ptr getelementptr (ptr, ptr null, i32 1) to i64), ptr [[SIZEGEP]], align 4
+// CHECK: %[[OFFLOAD_BASEPTR_GEP:.*]] = getelementptr inbounds [2 x ptr], ptr %[[OFFLOAD_BASEPTR]], i32 0, i32 1
+// CHECK: store ptr %[[PTR1]], ptr %[[OFFLOAD_BASEPTR_GEP]]
+// CHECK: %[[OFFLOAD_PTRS_GEP:.*]] = getelementptr inbounds [2 x ptr], ptr %[[OFFLOAD_PTRS]], i32 0, i32 1
+// CHECK: store ptr %[[PTR1]], ptr %[[OFFLOAD_PTRS_GEP]]
+// CHECK: %[[OFFLOAD_SIZES_GEP:.*]] = getelementptr inbounds [2 x i64], ptr %[[OFFLOAD_SIZES]], i32 0, i32 1
+// CHECK: store i64 ptrtoint (ptr getelementptr (ptr, ptr null, i32 1) to i64), ptr %[[OFFLOAD_SIZES_GEP]]
-// CHECK: [[ARGBASE_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x ptr], ptr [[ARGBASE_ALLOCA]], i32 0, i32 0
-// CHECK: [[ARG_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x ptr], ptr [[ARG_ALLOCA]], i32 0, i32 0
-// CHECK: [[SIZE_ALLOCA_GEP:%.*]] = getelementptr inbounds [2 x i64], ptr [[SIZE_ALLOCA]], i32 0, i32 0
-// CHECK: call void @__tgt_target_data_begin_mapper(ptr [[LOCGLOBAL]], i64 -1, i32 2, ptr [[ARGBASE_ALLOCA_GEP]], ptr [[ARG_ALLOCA_GEP]], ptr [[SIZE_ALLOCA_GEP]], ptr [[MAPTYPES]], ptr [[MAPNAMES]], ptr null)
+// CHECK: %[[OFFLOAD_BASEPTR_GEP:.*]] = getelementptr inbounds [2 x ptr], ptr %[[OFFLOAD_BASEPTR]], i32 0, i32 0
+// CHECK: %[[OFFLOAD_PTRS_GEP:.*]] = getelementptr inbounds [2 x ptr], ptr %[[OFFLOAD_PTRS]], i32 0, i32 0
+// CHECK: %[[OFFLOAD_SIZES_GEP:.*]] = getelementptr inbounds [2 x i64], ptr %[[OFFLOAD_SIZES]], i32 0, i32 0
+
+// CHECK: call void @__tgt_target_data_begin_mapper(ptr @[[LOCGLOBAL]], i64 -1, i32 2, ptr %[[OFFLOAD_BASEPTR_GEP]], ptr %[[OFFLOAD_PTRS_GEP]], ptr %[[OFFLOAD_SIZES_GEP]], ptr @[[MAPTYPES]], ptr @[[MAPNAMES]], ptr null)
// CHECK: declare void @__tgt_target_data_begin_mapper(ptr, i64, i32, ptr, ptr, ptr, ptr, ptr, ptr) #0
More information about the flang-commits
mailing list