[mlir][openacc] Introduce acc.declare operation

[clementval]

Summary

The acc.declare operation represent the implicit
region of variable in the declare directive in the function
(and subroutine in fortran).

[razvanlupusoru]

Looks great! Thank you!

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

def OpenACC_GlobalDestructorOp : OpenACC_Op<"global_dtor",
 
   let assemblyFormat = [{
     $sym_name $region attr-dict-with-keyword
   }];
 
   let hasVerifier = 0;
 }
 
+def OpenACC_DeclareOp : OpenACC_Op<"declare", [RecursiveMemoryEffects]> {
+  let summary = "declare implicit region";
+
+  let description = [{
+    The "acc.declare" operation represents an implicit declare region in
+    function (and subroutine in Fortran).
+
+    Example:
+
+    ```mlir
+    %pa = acc.present varPtr(%a : memref<10x10xf32>) -> memref<10x10xf32>
+    acc.declare dataOperands(%pa: memref<10x10xf32>) {
+      // implicit region
+    }
+    ```
+  }];
+
+  let arguments = (ins
+      Variadic<OpenACC_PointerLikeTypeInterface>:$dataClauseOperands);
+
+  let regions = (region AnyRegion:$region);
+
+  let assemblyFormat = [{
+      `dataOperands` `(` $dataClauseOperands `:` type($dataClauseOperands) `)`
+    $region attr-dict-with-keyword
+  }];
+
+  let hasVerifier = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // 2.15.1 Routine Directive
 //===----------------------------------------------------------------------===//
 
 def OpenACC_RoutineOp : OpenACC_Op<"routine", [IsolatedFromAbove]> {
   let summary = "acc routine operation";
 
   let description = [{

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

 // DeclareExitOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult acc::DeclareExitOp::verify() {
   return checkDeclareOperands(*this, this->getDataClauseOperands());
 }
 
 //===----------------------------------------------------------------------===//
+// DeclareOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult acc::DeclareOp::verify() {
+  return checkDeclareOperands(*this, this->getDataClauseOperands());
+}
+
+//===----------------------------------------------------------------------===//
 // RoutineOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult acc::RoutineOp::verify() {
   int parallelism = 0;
   parallelism += getGang() ? 1 : 0;
   parallelism += getWorker() ? 1 : 0;
   parallelism += getVector() ? 1 : 0;

mlir/test/Dialect/OpenACC/ops.mlir

 
 func.func @acc_func() -> () {
   "test.openacc_dummy_op"() {acc.declare_action = #acc.declare_action<postAlloc = @_QMacc_declareFacc_declare_allocateEa_acc_declare_update_desc_post_alloc>} : () -> ()
   return
 }
 
 // CHECK-LABEL: func.func @acc_func
 // CHECK: "test.openacc_dummy_op"() {acc.declare_action = #acc.declare_action<postAlloc = @_QMacc_declareFacc_declare_allocateEa_acc_declare_update_desc_post_alloc>}
+
+// -----
+
+func.func @compute3(%a: memref<10x10xf32>, %b: memref<10x10xf32>, %c: memref<10xf32>, %d: memref<10xf32>) {
+  %lb = arith.constant 0 : index
+  %st = arith.constant 1 : index
+  %c10 = arith.constant 10 : index
+  %numGangs = arith.constant 10 : i64
+  %numWorkers = arith.constant 10 : i64
+
+  %pa = acc.present varPtr(%a : memref<10x10xf32>) -> memref<10x10xf32>
+  %pb = acc.present varPtr(%b : memref<10x10xf32>) -> memref<10x10xf32>
+  %pc = acc.present varPtr(%c : memref<10xf32>) -> memref<10xf32>
+  %pd = acc.present varPtr(%d : memref<10xf32>) -> memref<10xf32>
+  acc.declare dataOperands(%pa, %pb, %pc, %pd: memref<10x10xf32>, memref<10x10xf32>, memref<10xf32>, memref<10xf32>) {
+  }
+  return
+}
+
+// CHECK-LABEL: func.func @compute3
+// CHECK: acc.declare dataOperands(