[mlir][openacc] Keep region when applying data operand conversion

[clementval]

Summary

Keep the region when the operation has one. The previous code
was throwing away the region when creating the new version
of the operation.

[PeteSteinfeld]

Things build, test, and look good to me. But someone more familiar with MLIR should take look.

[clementval]

Rebase

mlir/lib/Conversion/OpenACCToLLVM/OpenACCToLLVM.cpp

for (unsigned idx = 0; idx < numDataOperand; ++idx) {
       } else if (originalDataOperand.getType().isa<LLVM::LLVMPointerType>()) {
         convertedOperands.push_back(originalDataOperand);
       } else {
         // Type not supported.
         return builder.notifyMatchFailure(op, "unsupported type");
       }
     }
 
+    if constexpr (std::is_same_v<Op, acc::ParallelOp> ||
+                  std::is_same_v<Op, acc::DataOp>) {
+      auto newOp =
+          builder.create<Op>(op.getLoc(), TypeRange(), convertedOperands,
+                             op.getOperation()->getAttrs());
+      builder.inlineRegionBefore(op.getRegion(), newOp.getRegion(),
+                                 newOp.getRegion().end());
+      builder.eraseOp(op);
+    } else {
       builder.replaceOpWithNewOp<Op>(op, TypeRange(), convertedOperands,
                                      op.getOperation()->getAttrs());
+    }
 
     return success();
   }
 };
 } // namespace
 
 void mlir::populateOpenACCToLLVMConversionPatterns(
     LLVMTypeConverter &converter, RewritePatternSet &patterns) {

mlir/test/Conversion/OpenACCToLLVM/convert-data-operands-to-llvmir.mlir

 }
 
 // CHECK: acc.update if(%{{.*}}) host(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) device(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
 
 // -----
 
 func.func @testdataregion(%a: memref<10xf32>, %b: memref<10xf32>) -> () {
   acc.data copy(%b : memref<10xf32>) copyout(%a : memref<10xf32>) {
+    acc.parallel {
+      acc.yield
+    }
+    acc.terminator
   }
   return
 }
 
 // CHECK: acc.data copy(%{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>) copyout(%{{.*}} : !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
+// CHECK: acc.parallel
+// CHECK: acc.yield
+// CHECK: acc.terminator
 
 // -----
 
 func.func @testdataregion(%a: !llvm.ptr, %b: memref<10xf32>, %c: !llvm.ptr) -> () {
   acc.data copyin(%b : memref<10xf32>) deviceptr(%c: !llvm.ptr) attach(%a : !llvm.ptr) {
   }
   return
 }

 }
 
 // CHECK: acc.parallel present(%{{.*}}, %{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>, !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
 
 // -----
 
 func.func @testparallelop(%i: i64, %a: memref<10xf32>, %b: memref<10xf32>) -> () {
   acc.parallel num_gangs(%i: i64) present(%a, %b : memref<10xf32>, memref<10xf32>) {
+    %0 = arith.constant 0 : i32
+    acc.yield
   } attributes {async}
   return
 }
 
 // CHECK: acc.parallel num_gangs(%{{.*}}: i64) present(%{{.*}}, %{{.*}} : !llvm.struct<"openacc_data", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>, !llvm.struct<"openacc_data.1", (struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, ptr, i64)>)
-// CHECK-NEXT: } attributes {async}
+// CHECK:   %c0_i32 = arith.constant 0 : i32
+// CHECK:   acc.yield
+// CHECK: } attributes {async}