[MLIR][OpenMP] Allow map operands to be not specified

[kiranchandramohan]

Summary

This patch permits map operands to be not specified for the target
data operation. Also emit an error if none of the map, use_device_addr,
or use_device_ptr operands are specified.

[TIFitis]

LGTM :)

flang/test/Fir/convert-to-llvm-openmp-and-fir.fir

 // CHECK:             llvm.store %[[VAL_13]], %[[VAL_3]] : !llvm.ptr<i32>
 // CHECK:             omp.terminator
 // CHECK:           }
 // CHECK:           llvm.return
 // CHECK:         }
 
 // -----
 
+func.func @_QPomp_target_data_empty() {
+  %0 = fir.alloca !fir.array<1024xi32> {bindc_name = "a", uniq_name = "_QFomp_target_data_emptyEa"}
+  omp.target_data use_device_addr(%0 : !fir.ref<!fir.array<1024xi32>>) {
+  }
+  return
+}
+
+// CHECK-LABEL:   llvm.func @_QPomp_target_data_empty
+// CHECK: omp.target_data   use_device_addr(%1 : !llvm.ptr<array<1024 x i32>>) {
+// CHECK: }
+
+// -----
+
 func.func @_QPomp_target() {
   %0 = fir.alloca !fir.array<512xi32> {bindc_name = "a", uniq_name = "_QFomp_targetEa"}
   %c64_i32 = arith.constant 64 : i32
   omp.target   thread_limit(%c64_i32 : i32) map((tofrom -> %0 : !fir.ref<!fir.array<512xi32>>)) {
     %c10_i32 = arith.constant 10 : i32
     %c1_i64 = arith.constant 1 : i64
     %c1_i64_0 = arith.constant 1 : i64
     %1 = arith.subi %c1_i64, %c1_i64_0 : i64

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

let description = [{
     TODO:  depend clause and map_type_modifier values iterator and mapper.
   }];
 
   let arguments = (ins Optional<I1>:$if_expr,
                        Optional<AnyInteger>:$device,
                        Variadic<OpenMP_PointerLikeType>:$use_device_ptr,
                        Variadic<OpenMP_PointerLikeType>:$use_device_addr,
                        Variadic<OpenMP_PointerLikeType>:$map_operands,
-                       I64ArrayAttr:$map_types);
+                       OptionalAttr<I64ArrayAttr>:$map_types);
 
   let regions = (region AnyRegion:$region);
 
   let assemblyFormat = [{
     oilist(`if` `(` $if_expr `:` type($if_expr) `)`
-    | `device` `(` $device `:` type($device) `)`)
-    `map` `(` custom<MapClause>($map_operands, type($map_operands), $map_types) `)`
-    oilist(`use_device_ptr` `(` $use_device_ptr `:` type($use_device_ptr) `)`
+    | `device` `(` $device `:` type($device) `)`
+    | `map`
+      `(` custom<MapClause>($map_operands, type($map_operands), $map_types) `)`
+    | `use_device_ptr` `(` $use_device_ptr `:` type($use_device_ptr) `)`
     | `use_device_addr` `(` $use_device_addr `:` type($use_device_addr) `)`)
     $region attr-dict
   }];
 
   let hasVerifier = 1;
 }
 
 //===---------------------------------------------------------------------===//

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

static LogicalResult verifyMapClause(Operation *op, OperandRange map_operands,
   // Helper function to get bitwise AND of `value` and 'flag'
   auto bitAnd = [](int64_t value,
                    llvm::omp::OpenMPOffloadMappingFlags flag) -> bool {
     return value &
            static_cast<
                std::underlying_type_t<llvm::omp::OpenMPOffloadMappingFlags>>(
                flag);
   };
-  if (!map_types.has_value())
+  if (!map_types) {
+    if (!map_operands.empty())
+      return emitError(op->getLoc(), "missing mapTypes");
+    else
       return success();
+  }
+
+  if (map_operands.empty() && !map_types->empty())
+    return emitError(op->getLoc(), "missing mapOperands");
+
+  if (map_types->empty() && !map_operands.empty())
+    return emitError(op->getLoc(), "missing mapTypes");
 
   if (map_operands.size() != map_types->size())
-    return failure();
+    return emitError(op->getLoc(),
+                     "mismatch in number of mapOperands and mapTypes");
 
   for (const auto &mapTypeOp : *map_types) {
     int64_t mapTypeBits = 0x00;
 
     if (!llvm::isa<mlir::IntegerAttr>(mapTypeOp))
       return failure();
 
     mapTypeBits = llvm::cast<mlir::IntegerAttr>(mapTypeOp).getInt();
if (isa<ExitDataOp>(op) && to)
       return emitError(op->getLoc(),
                        "from, release and delete map types are permitted");
   }
 
   return success();
 }
 
 LogicalResult DataOp::verify() {
+  if (getMapOperands().empty() && getUseDevicePtr().empty() &&
+      getUseDeviceAddr().empty()) {
+    return ::emitError(this->getLoc(), "At least one of map, useDevicePtr, or "
+                                       "useDeviceAddr operand must be present");
+  }
   return verifyMapClause(*this, getMapOperands(), getMapTypes());
 }
 
 LogicalResult EnterDataOp::verify() {
   return verifyMapClause(*this, getMapOperands(), getMapTypes());
 }
 
 LogicalResult ExitDataOp::verify() {

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

LogicalResult result =
             if (auto devId = dataOp.getDevice())
               if (auto constOp = mlir::dyn_cast<mlir::LLVM::ConstantOp>(
                       devId.getDefiningOp()))
                 if (auto intAttr =
                         dyn_cast<mlir::IntegerAttr>(constOp.getValue()))
                   deviceID = intAttr.getInt();
 
             mapOperands = dataOp.getMapOperands();
-            mapTypes = dataOp.getMapTypes();
+            if (dataOp.getMapTypes())
+              mapTypes = dataOp.getMapTypes().value();
             return success();
           })
           .Case([&](omp::EnterDataOp enterDataOp) {
             if (enterDataOp.getNowait())
               return failure();
 
             if (auto ifExprVar = enterDataOp.getIfExpr())
               ifCond = moduleTranslation.lookupValue(ifExprVar);

mlir/test/Dialect/OpenMP/invalid.mlir

 func.func @omp_target_data(%map1: memref<?xi32>) {
   // expected-error @below {{to, from, tofrom and alloc map types are permitted}}
   omp.target_data map((delete -> %map1 : memref<?xi32>)){}
   return
 }
 
 // -----
 
+func.func @omp_target_data() {
+  // expected-error @below {{At least one of map, useDevicePtr, or useDeviceAddr operand must be present}}
+  omp.target_data {}
+  return
+}
+
+// -----
+
 func.func @omp_target_enter_data(%map1: memref<?xi32>) {
   // expected-error @below {{to and alloc map types are permitted}}
   omp.target_enter_data map((from -> %map1 : memref<?xi32>)){}
   return
 }
 
 // -----
 
 func.func @omp_target_exit_data(%map1: memref<?xi32>) {
   // expected-error @below {{from, release and delete map types are permitted}}
   omp.target_exit_data map((to -> %map1 : memref<?xi32>)){}
   return
 }
 
 llvm.mlir.global internal @_QFsubEx() : i32