[mlir][openacc] Remove detach and delete operands from acc.data

[clementval]

Summary

This patch remove the detach and delete operands. Those operands represent the detach
and delete clauses that will appear in another operation acc.exit_data

[kiranchandramohan]

LGTM. These removed clauses are not part of the exit construct in the standard but are part of exit_data.

[kiranktp]

LGTM

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

let arguments = (ins Variadic<AnyType>:$presentOperands,
                        Variadic<AnyType>:$copyOperands,
                        Variadic<AnyType>:$copyinOperands,
                        Variadic<AnyType>:$copyinReadonlyOperands,
                        Variadic<AnyType>:$copyoutOperands,
                        Variadic<AnyType>:$copyoutZeroOperands,
                        Variadic<AnyType>:$createOperands,
                        Variadic<AnyType>:$createZeroOperands,
                        Variadic<AnyType>:$noCreateOperands,
-                       Variadic<AnyType>:$deleteOperands,
-                       Variadic<AnyType>:$attachOperands,
-                       Variadic<AnyType>:$detachOperands);
+                       Variadic<AnyType>:$attachOperands);
 
   let regions = (region AnyRegion:$region);
 
   let extraClassDeclaration = [{
     static StringRef getAttachKeyword() { return "attach"; }
-    static StringRef getDeleteKeyword() { return "delete"; }
-    static StringRef getDetachKeyword() { return "detach"; }
     static StringRef getCopyinKeyword() { return "copyin"; }
     static StringRef getCopyinReadonlyKeyword() { return "copyin_readonly"; }
     static StringRef getCopyKeyword() { return "copy"; }
     static StringRef getCopyoutKeyword() { return "copyout"; }
     static StringRef getCopyoutZeroKeyword() { return "copyout_zero"; }
     static StringRef getCreateKeyword() { return "create"; }
     static StringRef getCreateZeroKeyword() { return "create_zero"; }
     static StringRef getNoCreateKeyword() { return "no_create"; }

mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp

 ///                         (`copy` `(` value-list `)`)?
 ///                         (`copyin` `(` value-list `)`)?
 ///                         (`copyin_readonly` `(` value-list `)`)?
 ///                         (`copyout` `(` value-list `)`)?
 ///                         (`copyout_zero` `(` value-list `)`)?
 ///                         (`create` `(` value-list `)`)?
 ///                         (`create_zero` `(` value-list `)`)?
 ///                         (`no_create` `(` value-list `)`)?
-///                         (`delete` `(` value-list `)`)?
 ///                         (`attach` `(` value-list `)`)?
-///                         (`detach` `(` value-list `)`)?
 ///                         region attr-dict?
 static ParseResult parseDataOp(OpAsmParser &parser, OperationState &result) {
   Builder &builder = parser.getBuilder();
   SmallVector<OpAsmParser::OperandType, 2> presentOperands, copyOperands,
       copyinOperands, copyinReadonlyOperands, copyoutOperands,
       copyoutZeroOperands, createOperands, createZeroOperands, noCreateOperands,
-      deleteOperands, attachOperands, detachOperands;
+      attachOperands;
   SmallVector<Type, 2> presentOperandTypes, copyOperandTypes,
       copyinOperandTypes, copyinReadonlyOperandTypes, copyoutOperandTypes,
       copyoutZeroOperandTypes, createOperandTypes, createZeroOperandTypes,
-      noCreateOperandTypes, deleteOperandTypes, attachOperandTypes,
-      detachOperandTypes;
+      noCreateOperandTypes, attachOperandTypes;
 
   // present(value-list)?
   if (failed(parseOperandList(parser, DataOp::getPresentKeyword(),
                               presentOperands, presentOperandTypes, result)))
     return failure();
 
   // copy(value-list)?
   if (failed(parseOperandList(parser, DataOp::getCopyKeyword(), copyOperands,
if (failed(parseOperandList(parser, DataOp::getCreateZeroKeyword(),
                               result)))
     return failure();
 
   // no_create(value-list)?
   if (failed(parseOperandList(parser, DataOp::getNoCreateKeyword(),
                               noCreateOperands, noCreateOperandTypes, result)))
     return failure();
 
-  // delete(value-list)?
-  if (failed(parseOperandList(parser, DataOp::getDeleteKeyword(),
-                              deleteOperands, deleteOperandTypes, result)))
-    return failure();
-
   // attach(value-list)?
   if (failed(parseOperandList(parser, DataOp::getAttachKeyword(),
                               attachOperands, attachOperandTypes, result)))
     return failure();
 
-  // detach(value-list)?
-  if (failed(parseOperandList(parser, DataOp::getDetachKeyword(),
-                              detachOperands, detachOperandTypes, result)))
-    return failure();
-
   // Data op region
   if (failed(parseRegions<ParallelOp>(parser, result)))
     return failure();
 
   result.addAttribute(ParallelOp::getOperandSegmentSizeAttr(),
                       builder.getI32VectorAttr(
                           {static_cast<int32_t>(presentOperands.size()),
                            static_cast<int32_t>(copyOperands.size()),
                            static_cast<int32_t>(copyinOperands.size()),
                            static_cast<int32_t>(copyinReadonlyOperands.size()),
                            static_cast<int32_t>(copyoutOperands.size()),
                            static_cast<int32_t>(copyoutZeroOperands.size()),
                            static_cast<int32_t>(createOperands.size()),
                            static_cast<int32_t>(createZeroOperands.size()),
                            static_cast<int32_t>(noCreateOperands.size()),
-                           static_cast<int32_t>(deleteOperands.size()),
-                           static_cast<int32_t>(attachOperands.size()),
-                           static_cast<int32_t>(detachOperands.size())}));
+                           static_cast<int32_t>(attachOperands.size())}));
 
   // Additional attributes
   if (failed(parser.parseOptionalAttrDictWithKeyword(result.attributes)))
     return failure();
 
   return success();
 }
 
static void print(OpAsmPrinter &printer, DataOp &op) {
   // create_zero(value-list)?
   printOperandList(op.createZeroOperands(), DataOp::getCreateZeroKeyword(),
                    printer);
 
   // no_create(value-list)?
   printOperandList(op.noCreateOperands(), DataOp::getNoCreateKeyword(),
                    printer);
 
-  // delete(value-list)?
-  printOperandList(op.deleteOperands(), DataOp::getDeleteKeyword(), printer);
-
   // attach(value-list)?
   printOperandList(op.attachOperands(), DataOp::getAttachKeyword(), printer);
 
-  // detach(value-list)?
-  printOperandList(op.detachOperands(), DataOp::getDetachKeyword(), printer);
-
   printer.printRegion(op.region(),
                       /*printEntryBlockArgs=*/false,
                       /*printBlockTerminators=*/true);
   printer.printOptionalAttrDictWithKeyword(
       op.getAttrs(), ParallelOp::getOperandSegmentSizeAttr());
 }
 
 //===----------------------------------------------------------------------===//

mlir/test/Dialect/OpenACC/ops.mlir

func @testdataop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) -> () {
   acc.data copyout_zero(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) {
   }
   acc.data create(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) {
   }
   acc.data create_zero(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) {
   }
   acc.data no_create(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) {
   }
-  acc.data delete(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) {
-  }
   acc.data attach(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) {
   }
-  acc.data detach(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) {
-  }
   acc.data present(%a: memref<10xf32>) copyin(%b: memref<10xf32>) copyout(%c: memref<10x10xf32>) {
   }
   return
 }
 
 // CHECK:      func @testdataop([[ARGA:%.*]]: memref<10xf32>, [[ARGB:%.*]]: memref<10xf32>, [[ARGC:%.*]]: memref<10x10xf32>) {
 // CHECK:      acc.data present([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data copy([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data copyin([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data copyin_readonly([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data copyout([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data copyout_zero([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data create([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data create_zero([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
 // CHECK:      acc.data no_create([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
-// CHECK:      acc.data delete([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
-// CHECK-NEXT: }
 // CHECK:      acc.data attach([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }
-// CHECK:      acc.data detach([[ARGA]]: memref<10xf32>, [[ARGB]]: memref<10xf32>, [[ARGC]]: memref<10x10xf32>) {
-// CHECK-NEXT: }
 // CHECK:      acc.data present([[ARGA]]: memref<10xf32>) copyin([[ARGB]]: memref<10xf32>) copyout([[ARGC]]: memref<10x10xf32>) {
 // CHECK-NEXT: }