[mlir][openacc] destroy region on firstprivate.recipe is optional

[clementval]

Summary

The destroy region is optional but the verifier was enforcing it.
Update the verifier and make it clear in the definition.

[razvanlupusoru]

LGTM. Matches intended design.

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

The operation requires two mandatory regions and one optional.
          default initialization. The region has an argument that contains the
          value that need to be privatized. This is useful if the type is not
          known at compile time and the private value is needed to create its
          copy.
       2. The copy region specifies how to copy the initial value to the newly
          created private value. It takes the initial value and the privatized
          value as arguments.
       3. The destroy region specifies how to destruct the value when it reaches
-         its end of life. It takes the privatized value as argument.
+         its end of life. It takes the privatized value as argument. It is
+         optional.
 
     A single privatization recipe can be used for multiple operand if they have
     the same type and do not require a specific default initialization.
 
     Example:
 
     ```mlir
     acc.firstprivate.recipe @privatization_f32 : f32 init {

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

if (getCopyRegion().empty())
     return emitOpError() << "expects non-empty copy region";
 
   Block &firstBlock = getCopyRegion().front();
   if (firstBlock.getNumArguments() != 2 ||
       firstBlock.getArgument(0).getType() != getType())
     return emitOpError() << "expects copy region with two arguments of the "
                             "privatization type";
 
+  if (getDestroyRegion().empty())
+    return success();
+
   if (failed(verifyInitLikeSingleArgRegion(*this, getDestroyRegion(),
                                            "privatization", "destroy",
                                            getType(), /*verifyYield=*/false)))
     return failure();
 
   return success();
 }
 

mlir/test/Dialect/OpenACC/ops.mlir

^bb0(%arg0: memref<10x10xf32>):
   %0 = memref.alloc() : memref<10x10xf32>
   acc.yield %0 : memref<10x10xf32>
 } destroy {
 ^bb0(%arg0: memref<10x10xf32>):
   memref.dealloc %arg0 : memref<10x10xf32> 
   acc.terminator
 }
 
+acc.firstprivate.recipe @privatization_memref_10xf32 : memref<10xf32> init {
+^bb0(%arg0: memref<10xf32>):
+  %0 = memref.alloc() : memref<10xf32>
+  acc.yield %0 : memref<10xf32>
+} copy {
+^bb0(%arg0: memref<10xf32>, %arg1: memref<10xf32>):
+  acc.terminator
+} destroy {
+^bb0(%arg0: memref<10xf32>):
+  memref.dealloc %arg0 : memref<10xf32> 
+  acc.terminator
+}
+
+// Test optional destroy region
+acc.firstprivate.recipe @privatization_memref_20xf32 : memref<20xf32> init {
+^bb0(%arg0: memref<20xf32>):
+  %0 = memref.alloc() : memref<20xf32>
+  acc.yield %0 : memref<20xf32>
+} copy {
+^bb0(%arg0: memref<20xf32>, %arg1: memref<20xf32>):
+  acc.terminator
+}
+
+// CHECK-LABEL: acc.firstprivate.recipe @privatization_memref_20xf32 : memref<20xf32> init
+
 func.func @testserialop(%a: memref<10xf32>, %b: memref<10xf32>, %c: memref<10x10xf32>) -> () {
   %i64value = arith.constant 1 : i64
   %i32value = arith.constant 1 : i32
   %idxValue = arith.constant 1 : index
   acc.serial async(%i64value: i64) {
   }
   acc.serial async(%i32value: i32) {
   }