[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

570

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";
   }