[mlir][openacc] Relax verifier for the acc.reduction.recipe

[clementval]

Summary

Allow the init and combiner regions to have more
arguments to pass information.

[razvanlupusoru]

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

620–621

text from below can be added to this line since there is extra space.

[clementval]

Rebase + fix invalid.mlir

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

def OpenACC_ReductionRecipeOp : OpenACC_Op<"reduction.recipe",
     [IsolatedFromAbove, Symbol]> {
   let summary = "reduction recipe";
 
   let description = [{
     Declares an OpenACC reduction recipe. The operation requires two
     mandatory regions.
 
       1. The initializer region specifies how to initialize the local reduction
-         value. The region has an argument that contains the value of the
+         value. The region has a first argument that contains the value of the
          reduction accumulator at the start of the reduction. It is expected to
-         `acc.yield` the new value.
+         `acc.yield` the new value. Extra arguments can be added to deal with
+         dynamic arrays.
       2. The reduction region contains a sequences of operations to combine two
-         values of the reduction type into one. It has two arguments and it is
-         expected to `acc.yield` the combined value.
+         values of the reduction type into one. It has at least two arguments
+         and it is expected to `acc.yield` the combined value. Extra arguments
+         can be added to deal with dynamic arrays.
 
     Example:
 
     ```mlir
     acc.reduction.recipe @reduction_add_i64 : i64 reduction_operator<add> init {
     ^bb0(%0: i64):
       // init region contains a sequence of operations to initialize the local
       // reduction value as specified in 2.5.15

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

static LogicalResult verifyInitLikeSingleArgRegion(
     Operation *op, Region &region, StringRef regionType, StringRef regionName,
     Type type, bool verifyYield, bool optional = false) {
   if (optional && region.empty())
     return success();
 
   if (region.empty())
     return op->emitOpError() << "expects non-empty " << regionName << " region";
   Block &firstBlock = region.front();
-  if (firstBlock.getNumArguments() != 1 ||
+  if (firstBlock.getNumArguments() < 1 ||
       firstBlock.getArgument(0).getType() != type)
     return op->emitOpError() << "expects " << regionName
-                             << " region with one "
+                             << " region first "
                                 "argument of the "
                              << regionType << " type";
 
   if (verifyYield) {
     for (YieldOp yieldOp : region.getOps<acc::YieldOp>()) {
       if (yieldOp.getOperands().size() != 1 ||
           yieldOp.getOperands().getTypes()[0] != type)
         return op->emitOpError() << "expects " << regionName
if (failed(verifyInitLikeSingleArgRegion(*this, getInitRegion(), "reduction",
                                            "init", getType(),
                                            /*verifyYield=*/false)))
     return failure();
 
   if (getCombinerRegion().empty())
     return emitOpError() << "expects non-empty combiner region";
 
   Block &reductionBlock = getCombinerRegion().front();
-  if (reductionBlock.getNumArguments() != 2 ||
+  if (reductionBlock.getNumArguments() < 2 ||
       reductionBlock.getArgument(0).getType() != getType() ||
       reductionBlock.getArgument(1).getType() != getType())
-    return emitOpError() << "expects combiner region with two arguments of "
-                         << "the reduction type";
+    return emitOpError() << "expects combiner region with the first two "
+                         << "arguments of the reduction type";
 
   for (YieldOp yieldOp : getCombinerRegion().getOps<YieldOp>()) {
     if (yieldOp.getOperands().size() != 1 ||
         yieldOp.getOperands().getTypes()[0] != getType())
       return emitOpError() << "expects combiner region to yield a value "
                               "of the reduction type";
   }
 

mlir/test/Dialect/OpenACC/invalid.mlir

 // -----
 
 // expected-error@+1 {{expects non-empty init region}}
 acc.private.recipe @privatization_i32 : !llvm.ptr<i32> init {
 }
 
 // -----
 
-// expected-error@+1 {{expects init region with one argument of the privatization type}}
+// expected-error@+1 {{expects init region first argument of the privatization type}}
 acc.private.recipe @privatization_i32 : !llvm.ptr<i32> init {
 ^bb0(%arg0 : !llvm.ptr<f32>):
   %c1 = arith.constant 1 : i32
   %c0 = arith.constant 0 : i32
   %0 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr<i32>
   llvm.store %c0, %0 : !llvm.ptr<i32>
   acc.yield %0 : !llvm.ptr<i32>
 }
 
 // -----
 
 // expected-error@+1 {{expects init region to yield a value of the privatization type}}
 acc.private.recipe @privatization_i32 : !llvm.ptr<f32> init {
 ^bb0(%arg0 : !llvm.ptr<f32>):
   %c1 = arith.constant 1 : i32
   %c0 = arith.constant 0 : i32
   %0 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr<i32>
   llvm.store %c0, %0 : !llvm.ptr<i32>
   acc.yield %0 : !llvm.ptr<i32>
 }
 
 // -----
 
-// expected-error@+1 {{expects destroy region with one argument of the privatization type}}
+// expected-error@+1 {{expects destroy region first argument of the privatization type}}
 acc.private.recipe @privatization_i32 : !llvm.ptr<i32> init {
 ^bb0(%arg0 : !llvm.ptr<i32>):
   %c1 = arith.constant 1 : i32
   %c0 = arith.constant 0 : i32
   %0 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr<i32>
   llvm.store %c0, %0 : !llvm.ptr<i32>
   acc.yield %0 : !llvm.ptr<i32>
 } destroy {
 ^bb0(%arg0 : f32):
   "test.openacc_dummy_op"(%arg0) : (f32) -> ()
 }
 
 // -----
 
 // expected-error@+1 {{expects non-empty init region}}
 acc.firstprivate.recipe @privatization_i32 : !llvm.ptr<i32> init {
 } copy {}
 
 // -----
 
-// expected-error@+1 {{expects init region with one argument of the privatization type}}
+// expected-error@+1 {{expects init region first argument of the privatization type}}
 acc.firstprivate.recipe @privatization_i32 : !llvm.ptr<i32> init {
 ^bb0(%arg0 : !llvm.ptr<f32>):
   %c1 = arith.constant 1 : i32
   %c0 = arith.constant 0 : i32
   %0 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr<i32>
   llvm.store %c0, %0 : !llvm.ptr<i32>
   acc.yield %0 : !llvm.ptr<i32>
 } copy {}
^bb0(%arg0 : !llvm.ptr<i32>):
   acc.yield %0 : !llvm.ptr<i32>
 } copy {
 ^bb0(%arg0 : f32, %arg1 : i32):
   "test.openacc_dummy_op"(%arg0) : (f32) -> ()
 }
 
 // -----
 
-// expected-error@+1 {{destroy region with one argument of the privatization type}}
+// expected-error@+1 {{expects destroy region first argument of the privatization type}}
 acc.firstprivate.recipe @privatization_i32 : i32 init {
 ^bb0(%arg0 : i32):
   %0 = arith.constant 1 : i32
   acc.yield %0 : i32
 } copy {
 ^bb0(%arg0 : i32, %arg1 : !llvm.ptr<i32>):
   llvm.store %arg0, %arg1 : !llvm.ptr<i32>
   acc.yield

 // -----
 
 // expected-error@+1 {{expects non-empty init region}}
 acc.reduction.recipe @reduction_i64 : i64 reduction_operator<add> init {
 } combiner {}
 
 // -----
 
-// expected-error@+1 {{expects init region with one argument of the reduction type}}
+// expected-error@+1 {{expects init region first argument of the reduction type}}
 acc.reduction.recipe @reduction_i64 : i64 reduction_operator<add> init {
 ^bb0(%0: i32):
   %1 = arith.constant 0 : i64
   acc.yield %1 : i64
 } combiner {}
 
 // -----
 
 // expected-error@+1 {{expects non-empty combiner region}}
 acc.reduction.recipe @reduction_i64 : i64 reduction_operator<add> init {
 ^bb0(%0: i64):
   %1 = arith.constant 0 : i64
   acc.yield %1 : i64
 } combiner {}
 
 // -----
 
-// expected-error@+1 {{expects combiner region with two arguments of the reduction type}}
+// expected-error@+1 {{expects combiner region with the first two arguments of the reduction type}}
 acc.reduction.recipe @reduction_i64 : i64 reduction_operator<add> init {
 ^bb0(%0: i64):
   %1 = arith.constant 0 : i64
   acc.yield %1 : i64
 } combiner {
 ^bb0(%0: i32):
   acc.yield %0 : i32
 }
 
 // -----
 
-// expected-error@+1 {{expects combiner region with two arguments of the reduction type}}
+// expected-error@+1 {{expects combiner region with the first two arguments of the reduction type}}
 acc.reduction.recipe @reduction_i64 : i64 reduction_operator<add> init {
 ^bb0(%0: i64):
   %1 = arith.constant 0 : i64
   acc.yield %1 : i64
 } combiner {
 ^bb0(%0: i64):
   acc.yield %0 : i64
 }