[openacc] Add implicit flag to declare attribute

[razvanlupusoru]

Summary

The declare attribute has been updated to allow implicit flag. This is
useful for variables that can be declare'd implicitly - like global
constants. The verifier has been updated to ensure that an implicit
declare'd variable has an implicit data action. The builder doesn't
require for this flag to be set so any code creating this attribute
will continue to work as-is.

[vzakhari]

Looks good to me. Thank you!

[razvanlupusoru]

Fix formatting.

[razvanlupusoru]

Rebase

mlir/include/mlir/Dialect/OpenACC/OpenACC.h

 /// Returns empty value if not a data entry operation.
 mlir::Value getVarPtr(mlir::Operation *accDataEntryOp);
 
 /// Used to obtain the `dataClause` from a data entry operation.
 /// Returns empty optional if not a data entry operation.
 std::optional<mlir::acc::DataClause>
 getDataClause(mlir::Operation *accDataEntryOp);
 
+/// Used to find out whether data operation is implicit.
+/// Returns false if not a data operation or if it is a data operation without
+/// implicit flag.
+bool getImplicitFlag(mlir::Operation *accDataEntryOp);
+
 /// Used to obtain the attribute name for declare.
 static constexpr StringLiteral getDeclareAttrName() {
   return StringLiteral("acc.declare");
 }
 
 static constexpr StringLiteral getDeclareActionAttrName() {
   return StringLiteral("acc.declare_action");
 }

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

 // Attribute to describe the declare data clause used on variable.
 // Intended to be used at the variable creation site (on the global op or the
 // corresponding allocation operation). This is used in conjunction with the
 // declare operations (`acc.declare_enter` and `acc.declare_exit`) since those
 // describe how the data action is performed. The attribute itself makes it
 // easier to find out whether the variable is in a declare clause and what kind
 // of clause it is.
 def DeclareAttr : OpenACC_Attr<"Declare", "declare"> {
-  let parameters = (ins "DataClauseAttr":$dataClause);
+  let parameters = (ins "DataClauseAttr":$dataClause,
+                        DefaultValuedParameter<"bool", "false">:$implicit);
   let assemblyFormat = "`<` struct(params) `>`";
+  let builders = [AttrBuilder<(ins "DataClauseAttr":$dataClause), [{
+      return $_get($_ctxt, dataClause, /*implicit=*/false);
+    }]>
+  ];
 }
 
 // Attribute to attach functions that perform the pre/post allocation actions or
 // pre/post deallocation actions as described in section 2.13.
 def DeclareActionAttr : OpenACC_Attr<"DeclareAction", "declare_action"> {
   let parameters = (ins OptionalParameter<"SymbolRefAttr">:$preAlloc,
                         OptionalParameter<"SymbolRefAttr">:$postAlloc,
                         OptionalParameter<"SymbolRefAttr">:$preDealloc,

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

if (!varPtr.getDefiningOp())
       continue;
 
     // Check that the varPtr has a declare attribute.
     auto declareAttribute{
         varPtr.getDefiningOp()->getAttr(mlir::acc::getDeclareAttrName())};
     if (!declareAttribute)
       return op.emitError(
           "expect declare attribute on variable in declare operation");
-    if (mlir::cast<mlir::acc::DeclareAttr>(declareAttribute)
-            .getDataClause()
-            .getValue() != dataClauseOptional.value())
+
+    auto declAttr = mlir::cast<mlir::acc::DeclareAttr>(declareAttribute);
+    if (declAttr.getDataClause().getValue() != dataClauseOptional.value())
       return op.emitError(
           "expect matching declare attribute on variable in declare operation");
+
+    // If the variable is marked with implicit attribute, the matching declare
+    // data action must also be marked implicit. The reverse is not checked
+    // since implicit data action may be inserted to do actions like updating
+    // device copy, in which case the variable is not necessarily implicitly
+    // declare'd.
+    if (declAttr.getImplicit() &&
+        declAttr.getImplicit() != acc::getImplicitFlag(operand.getDefiningOp()))
+      return op.emitError(
+          "implicitness must match between declare op and flag on variable");
   }
 
   return success();
 }
 
 LogicalResult acc::DeclareEnterOp::verify() {
   return checkDeclareOperands(*this, this->getDataClauseOperands());
 }
mlir::acc::getDataClause(mlir::Operation *accDataEntryOp) {
   auto dataClause{
       llvm::TypeSwitch<mlir::Operation *, std::optional<mlir::acc::DataClause>>(
           accDataEntryOp)
           .Case<ACC_DATA_ENTRY_OPS>(
               [&](auto entry) { return entry.getDataClause(); })
           .Default([&](mlir::Operation *) { return std::nullopt; })};
   return dataClause;
 }
+
+bool mlir::acc::getImplicitFlag(mlir::Operation *accDataEntryOp) {
+  auto implicit{llvm::TypeSwitch<mlir::Operation *, bool>(accDataEntryOp)
+                    .Case<ACC_DATA_ENTRY_OPS>(
+                        [&](auto entry) { return entry.getImplicit(); })
+                    .Default([&](mlir::Operation *) { return false; })};
+  return implicit;
+}

mlir/test/Dialect/OpenACC/ops.mlir

 
 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
 
+  %c20 = arith.constant 20 : i32
+  %alloc = llvm.alloca %c20 x i32 { acc.declare = #acc.declare<dataClause = acc_create, implicit = true> } : (i32) -> !llvm.ptr<i32>
+  %createlocal = acc.create varPtr(%alloc : !llvm.ptr<i32>) -> !llvm.ptr<i32> {implicit = true}
+
   %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>) {
+  acc.declare dataOperands(%pa, %pb, %pc, %pd, %createlocal: memref<10x10xf32>, memref<10x10xf32>, memref<10xf32>, memref<10xf32>, !llvm.ptr<i32>) {
   }
+
   return
 }
 
 // CHECK-LABEL: func.func @compute3
 // CHECK: acc.declare dataOperands(
 
 // -----