[MLIR][OpenMP] Add conversion support from FIR to LLVM Dialect for OMP Target Data with region

[TIFitis]

Summary

This enables conversion of OpenMP Target Data op with region from FIR Dialect to LLVM IR Dialect.

[TIFitis]

When trying to lower the following Fortran code to FIR and then LLVMIR I am getting an error in fir-opt which I'm not quite sure how to fix. Any hints/inputs would be greatly appreciated.

Fortran Code:

subroutine openmp_target_data
    integer :: a(1024), i
    !$omp target data map(tofrom: a)
        do i = 1, 1024
            a(i) = i
        end do
    !$omp end target data
end subroutine openmp_target_data

FIR: flang-new -fc1 -emit-fir -fopenmp test.f90 -o test.fir

func.func @_QPopenmp_target_data() {
  %0 = fir.alloca !fir.array<1024xi32> {bindc_name = "a", uniq_name = "_QFopenmp_target_dataEa"}
  %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFopenmp_target_dataEi"}
  omp.target_data   map((tofrom -> %0 : !fir.ref<!fir.array<1024xi32>>)) {
    %c1_i32 = arith.constant 1 : i32
    %2 = fir.convert %c1_i32 : (i32) -> index
    %c1024_i32 = arith.constant 1024 : i32
    %3 = fir.convert %c1024_i32 : (i32) -> index
    %c1 = arith.constant 1 : index
    %4 = fir.convert %2 : (index) -> i32
    %5:2 = fir.do_loop %arg0 = %2 to %3 step %c1 iter_args(%arg1 = %4) -> (index, i32) {
      fir.store %arg1 to %1 : !fir.ref<i32>
      %6 = fir.load %1 : !fir.ref<i32>
      %7 = fir.load %1 : !fir.ref<i32>
      %8 = fir.convert %7 : (i32) -> i64
      %c1_i64 = arith.constant 1 : i64
      %9 = arith.subi %8, %c1_i64 : i64
      %10 = fir.coordinate_of %0, %9 : (!fir.ref<!fir.array<1024xi32>>, i64) -> !fir.ref<i32>
      fir.store %6 to %10 : !fir.ref<i32>
      %11 = arith.addi %arg0, %c1 : index
      %12 = fir.convert %c1 : (index) -> i32
      %13 = fir.load %1 : !fir.ref<i32>
      %14 = arith.addi %13, %12 : i32
      fir.result %11, %14 : index, i32
    }
    fir.store %5#1 to %1 : !fir.ref<i32>
    omp.terminator
  }
  return
}

LLVMIR: fir-opt --fir-to-llvm-ir="target=aarch64-unknown-linux-gnu" test.fir -o test.mlir

test.fir:12:14: error: failed to legalize operation 'fir.do_loop'
      %5:2 = fir.do_loop %arg0 = %2 to %3 step %c1 iter_args(%arg1 = %4) -> (index, i32) {
             ^
test.fir:12:14: note: see current operation: 
%18:2 = "fir.do_loop"(%9, %13, %15, %17) ({
^bb0(%arg0: index, %arg1: i32):
  "fir.store"(%arg1, %5) : (i32, !fir.ref<i32>) -> ()
  %19 = "fir.load"(%5) : (!fir.ref<i32>) -> i32
  %20 = "fir.load"(%5) : (!fir.ref<i32>) -> i32
  %21 = "fir.convert"(%20) : (i32) -> i64
  %22 = "arith.constant"() {value = 1 : i64} : () -> i64
  %23 = "arith.subi"(%21, %22) : (i64, i64) -> i64
  %24 = "fir.coordinate_of"(%2, %23) {baseType = !fir.ref<!fir.array<1024xi32>>} : (!fir.ref<!fir.array<1024xi32>>, i64) -> !fir.ref<i32>
  "fir.store"(%19, %24) : (i32, !fir.ref<i32>) -> ()
  %25 = "arith.addi"(%arg0, %15) : (index, index) -> index
  %26 = "fir.convert"(%15) : (index) -> i32
  %27 = "fir.load"(%5) : (!fir.ref<i32>) -> i32
  %28 = "arith.addi"(%27, %26) : (i32, i32) -> i32
  "fir.result"(%25, %28) : (index, i32) -> ()
}) {finalValue} : (index, index, index, i32) -> (index, i32)

Thanks,
Akash

[kiranchandramohan]

In D144380#4138622, @TIFitis wrote:

When trying to lower the following Fortran code to FIR and then LLVMIR I am getting an error in fir-opt which I'm not quite sure how to fix. Any hints/inputs would be greatly appreciated.

Fortran Code:

subroutine openmp_target_data
    integer :: a(1024), i
    !$omp target data map(tofrom: a)
        do i = 1, 1024
            a(i) = i
        end do
    !$omp end target data
end subroutine openmp_target_data

FIR: flang-new -fc1 -emit-fir -fopenmp test.f90 -o test.fir

func.func @_QPopenmp_target_data() {
  %0 = fir.alloca !fir.array<1024xi32> {bindc_name = "a", uniq_name = "_QFopenmp_target_dataEa"}
  %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFopenmp_target_dataEi"}
  omp.target_data   map((tofrom -> %0 : !fir.ref<!fir.array<1024xi32>>)) {
    %c1_i32 = arith.constant 1 : i32
    %2 = fir.convert %c1_i32 : (i32) -> index
    %c1024_i32 = arith.constant 1024 : i32
    %3 = fir.convert %c1024_i32 : (i32) -> index
    %c1 = arith.constant 1 : index
    %4 = fir.convert %2 : (index) -> i32
    %5:2 = fir.do_loop %arg0 = %2 to %3 step %c1 iter_args(%arg1 = %4) -> (index, i32) {
      fir.store %arg1 to %1 : !fir.ref<i32>
      %6 = fir.load %1 : !fir.ref<i32>
      %7 = fir.load %1 : !fir.ref<i32>
      %8 = fir.convert %7 : (i32) -> i64
      %c1_i64 = arith.constant 1 : i64
      %9 = arith.subi %8, %c1_i64 : i64
      %10 = fir.coordinate_of %0, %9 : (!fir.ref<!fir.array<1024xi32>>, i64) -> !fir.ref<i32>
      fir.store %6 to %10 : !fir.ref<i32>
      %11 = arith.addi %arg0, %c1 : index
      %12 = fir.convert %c1 : (index) -> i32
      %13 = fir.load %1 : !fir.ref<i32>
      %14 = arith.addi %13, %12 : i32
      fir.result %11, %14 : index, i32
    }
    fir.store %5#1 to %1 : !fir.ref<i32>
    omp.terminator
  }
  return
}

LLVMIR: fir-opt --fir-to-llvm-ir="target=aarch64-unknown-linux-gnu" test.fir -o test.mlir

test.fir:12:14: error: failed to legalize operation 'fir.do_loop'
      %5:2 = fir.do_loop %arg0 = %2 to %3 step %c1 iter_args(%arg1 = %4) -> (index, i32) {
             ^
test.fir:12:14: note: see current operation: 
%18:2 = "fir.do_loop"(%9, %13, %15, %17) ({
^bb0(%arg0: index, %arg1: i32):
  "fir.store"(%arg1, %5) : (i32, !fir.ref<i32>) -> ()
  %19 = "fir.load"(%5) : (!fir.ref<i32>) -> i32
  %20 = "fir.load"(%5) : (!fir.ref<i32>) -> i32
  %21 = "fir.convert"(%20) : (i32) -> i64
  %22 = "arith.constant"() {value = 1 : i64} : () -> i64
  %23 = "arith.subi"(%21, %22) : (i64, i64) -> i64
  %24 = "fir.coordinate_of"(%2, %23) {baseType = !fir.ref<!fir.array<1024xi32>>} : (!fir.ref<!fir.array<1024xi32>>, i64) -> !fir.ref<i32>
  "fir.store"(%19, %24) : (i32, !fir.ref<i32>) -> ()
  %25 = "arith.addi"(%arg0, %15) : (index, index) -> index
  %26 = "fir.convert"(%15) : (index) -> i32
  %27 = "fir.load"(%5) : (!fir.ref<i32>) -> i32
  %28 = "arith.addi"(%27, %26) : (i32, i32) -> i32
  "fir.result"(%25, %28) : (index, i32) -> ()
}) {finalValue} : (index, index, index, i32) -> (index, i32)

Thanks,
Akash

FIR to LLVM IR conversion happens as a sequence of passes. All FIR operations cannot be converted to LLVM using the fir-to-llvm-ir Conversion pass. We have to run other passes before it. In this specific case only cfg-conversion need to be run.

fir-opt --cfg-conversion --fir-to-llvm-ir="target=aarch64-unknown-linux-gnu" test.fir -o test.mlir

[TIFitis]

Added tests.

[TIFitis]

Updated check regex in test.

[TIFitis]

Rebased

[kiranchandramohan]

mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp

178–187

Wouldn't this Operation require a region conversion as well?

[TIFitis]

mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp

178–187

Yes, its present in line 189.

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

 // CHECK:     llvm.store %[[N]], %[[X_REF]] : !llvm.ptr<i32>
 // CHECK:     omp.terminator
 // CHECK:   }
 // CHECK:   omp.terminator
 // CHECK: }
 // CHECK: llvm.return
 // CHECK: }
 
-
 // -----
 
 func.func @_QPsb(%arr: !fir.box<!fir.array<?xi32>> {fir.bindc_name = "arr"}) {
   %0 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsbEi"}
   omp.parallel   {
     %c1 = arith.constant 1 : i32
     %c50 = arith.constant 50 : i32
     omp.wsloop   for  (%indx) : i32 = (%c1) to (%c50) inclusive step (%c1) {

 // CHECK:   llvm.store %[[I1]], %[[ARR_I_REF]] : !llvm.ptr<i32>
 // CHECK: omp.yield
 // CHECK: }
 // CHECK: omp.terminator
 // CHECK: }
 // CHECK: llvm.return
 // CHECK: }
 
+// -----
+
 func.func @_QPomp_target_data() {
   %0 = fir.alloca !fir.array<1024xi32> {bindc_name = "a", uniq_name = "_QFomp_target_dataEa"}
   %1 = fir.alloca !fir.array<1024xi32> {bindc_name = "b", uniq_name = "_QFomp_target_dataEb"}
   %2 = fir.alloca !fir.array<1024xi32> {bindc_name = "c", uniq_name = "_QFomp_target_dataEc"}
   %3 = fir.alloca !fir.array<1024xi32> {bindc_name = "d", uniq_name = "_QFomp_target_dataEd"}
   omp.target_enter_data   map((to -> %0 : !fir.ref<!fir.array<1024xi32>>), (to -> %1 : !fir.ref<!fir.array<1024xi32>>), (always, alloc -> %2 : !fir.ref<!fir.array<1024xi32>>))
   omp.target_exit_data   map((from -> %0 : !fir.ref<!fir.array<1024xi32>>), (from -> %1 : !fir.ref<!fir.array<1024xi32>>), (release -> %2 : !fir.ref<!fir.array<1024xi32>>), (always, delete -> %3 : !fir.ref<!fir.array<1024xi32>>))
   return
 }
 
 // CHECK-LABEL:   llvm.func @_QPomp_target_data() {
 // CHECK:           %[[VAL_0:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:           %[[VAL_1:.*]] = llvm.alloca %[[VAL_0]] x !llvm.array<1024 x i32> {bindc_name = "a", in_type = !fir.array<1024xi32>, operand_segment_sizes = array<i32: 0, 0>, uniq_name = "_QFomp_target_dataEa"} : (i64) -> !llvm.ptr<array<1024 x i32>>
 // CHECK:           %[[VAL_2:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:           %[[VAL_3:.*]] = llvm.alloca %[[VAL_2]] x !llvm.array<1024 x i32> {bindc_name = "b", in_type = !fir.array<1024xi32>, operand_segment_sizes = array<i32: 0, 0>, uniq_name = "_QFomp_target_dataEb"} : (i64) -> !llvm.ptr<array<1024 x i32>>
 // CHECK:           %[[VAL_4:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:           %[[VAL_5:.*]] = llvm.alloca %[[VAL_4]] x !llvm.array<1024 x i32> {bindc_name = "c", in_type = !fir.array<1024xi32>, operand_segment_sizes = array<i32: 0, 0>, uniq_name = "_QFomp_target_dataEc"} : (i64) -> !llvm.ptr<array<1024 x i32>>
 // CHECK:           %[[VAL_6:.*]] = llvm.mlir.constant(1 : i64) : i64
 // CHECK:           %[[VAL_7:.*]] = llvm.alloca %[[VAL_6]] x !llvm.array<1024 x i32> {bindc_name = "d", in_type = !fir.array<1024xi32>, operand_segment_sizes = array<i32: 0, 0>, uniq_name = "_QFomp_target_dataEd"} : (i64) -> !llvm.ptr<array<1024 x i32>>
 // CHECK:           omp.target_enter_data   map((to -> %[[VAL_1]] : !llvm.ptr<array<1024 x i32>>), (to -> %[[VAL_3]] : !llvm.ptr<array<1024 x i32>>), (always, alloc -> %[[VAL_5]] : !llvm.ptr<array<1024 x i32>>))
 // CHECK:           omp.target_exit_data   map((from -> %[[VAL_1]] : !llvm.ptr<array<1024 x i32>>), (from -> %[[VAL_3]] : !llvm.ptr<array<1024 x i32>>), (release -> %[[VAL_5]] : !llvm.ptr<array<1024 x i32>>), (always, delete -> %[[VAL_7]] : !llvm.ptr<array<1024 x i32>>))
 // CHECK:           llvm.return
 // CHECK:         }
 
+// -----
+
+func.func @_QPopenmp_target_data_region() {
+  %0 = fir.alloca !fir.array<1024xi32> {bindc_name = "a", uniq_name = "_QFopenmp_target_data_regionEa"}
+  %1 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFopenmp_target_data_regionEi"}
+  omp.target_data   map((tofrom -> %0 : !fir.ref<!fir.array<1024xi32>>)) {
+    %c1_i32 = arith.constant 1 : i32
+    %2 = fir.convert %c1_i32 : (i32) -> index
+    %c1024_i32 = arith.constant 1024 : i32
+    %3 = fir.convert %c1024_i32 : (i32) -> index
+    %c1 = arith.constant 1 : index
+    %4 = fir.convert %2 : (index) -> i32
+    %5:2 = fir.do_loop %arg0 = %2 to %3 step %c1 iter_args(%arg1 = %4) -> (index, i32) {
+      fir.store %arg1 to %1 : !fir.ref<i32>
+      %6 = fir.load %1 : !fir.ref<i32>
+      %7 = fir.load %1 : !fir.ref<i32>
+      %8 = fir.convert %7 : (i32) -> i64
+      %c1_i64 = arith.constant 1 : i64
+      %9 = arith.subi %8, %c1_i64 : i64
+      %10 = fir.coordinate_of %0, %9 : (!fir.ref<!fir.array<1024xi32>>, i64) -> !fir.ref<i32>
+      fir.store %6 to %10 : !fir.ref<i32>
+      %11 = arith.addi %arg0, %c1 : index
+      %12 = fir.convert %c1 : (index) -> i32
+      %13 = fir.load %1 : !fir.ref<i32>
+      %14 = arith.addi %13, %12 : i32
+      fir.result %11, %14 : index, i32
+    }
+    fir.store %5#1 to %1 : !fir.ref<i32>
+    omp.terminator
+  }
+  return
+}
+
+// CHECK-LABEL:   llvm.func @_QPopenmp_target_data_region() {
+// CHECK:           %[[VAL_0:.*]] = llvm.mlir.constant(1 : i64) : i64
+// CHECK:           %[[VAL_1:.*]] = llvm.alloca %[[VAL_0]] x !llvm.array<1024 x i32> {bindc_name = "a", in_type = !fir.array<1024xi32>, operand_segment_sizes = array<i32: 0, 0>, uniq_name = "_QFopenmp_target_data_regionEa"} : (i64) -> !llvm.ptr<array<1024 x i32>>
+// CHECK:           %[[VAL_2:.*]] = llvm.mlir.constant(1 : i64) : i64
+// CHECK:           %[[VAL_3:.*]] = llvm.alloca %[[VAL_2]] x i32 {bindc_name = "i", in_type = i32, operand_segment_sizes = array<i32: 0, 0>, uniq_name = "_QFopenmp_target_data_regionEi"} : (i64) -> !llvm.ptr<i32>
+// CHECK:           omp.target_data   map((tofrom -> %[[VAL_1]] : !llvm.ptr<array<1024 x i32>>)) {
+// CHECK:             %[[VAL_4:.*]] = llvm.mlir.constant(1 : i32) : i32
+// CHECK:             %[[VAL_5:.*]] = llvm.sext %[[VAL_4]] : i32 to i64
+// CHECK:             %[[VAL_6:.*]] = llvm.mlir.constant(1024 : i32) : i32
+// CHECK:             %[[VAL_7:.*]] = llvm.sext %[[VAL_6]] : i32 to i64
+// CHECK:             %[[VAL_8:.*]] = llvm.mlir.constant(1 : index) : i64
+// CHECK:             %[[VAL_9:.*]] = llvm.trunc %[[VAL_5]] : i64 to i32
+// CHECK:             %[[VAL_10:.*]] = llvm.sub %[[VAL_7]], %[[VAL_5]]  : i64
+// CHECK:             %[[VAL_11:.*]] = llvm.add %[[VAL_10]], %[[VAL_8]]  : i64
+// CHECK:             llvm.br ^bb1(%[[VAL_5]], %[[VAL_9]], %[[VAL_11]] : i64, i32, i64)
+// CHECK:           ^bb1(%[[VAL_12:.*]]: i64, %[[VAL_13:.*]]: i32, %[[VAL_14:.*]]: i64):
+// CHECK:             %[[VAL_15:.*]] = llvm.mlir.constant(0 : index) : i64
+// CHECK:             %[[VAL_16:.*]] = llvm.icmp "sgt" %[[VAL_14]], %[[VAL_15]] : i64
+// CHECK:             llvm.cond_br %[[VAL_16]], ^bb2, ^bb3
+// CHECK:           ^bb2:
+// CHECK:             llvm.store %[[VAL_13]], %[[VAL_3]] : !llvm.ptr<i32>
+// CHECK:             %[[VAL_17:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr<i32>
+// CHECK:             %[[VAL_18:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr<i32>
+// CHECK:             %[[VAL_19:.*]] = llvm.sext %[[VAL_18]] : i32 to i64
+// CHECK:             %[[VAL_20:.*]] = llvm.mlir.constant(1 : i64) : i64
+// CHECK:             %[[VAL_21:.*]] = llvm.sub %[[VAL_19]], %[[VAL_20]]  : i64
+// CHECK:             %[[VAL_22:.*]] = llvm.getelementptr %[[VAL_1]][0, %[[VAL_21]]] : (!llvm.ptr<array<1024 x i32>>, i64) -> !llvm.ptr<i32>
+// CHECK:             llvm.store %[[VAL_17]], %[[VAL_22]] : !llvm.ptr<i32>
+// CHECK:             %[[VAL_23:.*]] = llvm.add %[[VAL_12]], %[[VAL_8]]  : i64
+// CHECK:             %[[VAL_24:.*]] = llvm.trunc %[[VAL_8]] : i64 to i32
+// CHECK:             %[[VAL_25:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr<i32>
+// CHECK:             %[[VAL_26:.*]] = llvm.add %[[VAL_25]], %[[VAL_24]]  : i32
+// CHECK:             %[[VAL_27:.*]] = llvm.add %[[VAL_12]], %[[VAL_8]]  : i64
+// CHECK:             %[[VAL_28:.*]] = llvm.mlir.constant(1 : index) : i64
+// CHECK:             %[[VAL_29:.*]] = llvm.sub %[[VAL_14]], %[[VAL_28]]  : i64
+// CHECK:             llvm.br ^bb1(%[[VAL_27]], %[[VAL_26]], %[[VAL_29]] : i64, i32, i64)
+// CHECK:           ^bb3:
+// CHECK:             llvm.store %[[VAL_13]], %[[VAL_3]] : !llvm.ptr<i32>
+// CHECK:             omp.terminator
+// CHECK:           }
+// CHECK:           llvm.return
+// CHECK:         }
+
+// -----
+
 func.func @_QPsimdloop_with_nested_loop() {
   %0 = fir.alloca i32 {adapt.valuebyref}
   %1 = fir.alloca !fir.array<10xi32> {bindc_name = "a", uniq_name = "_QFsimdloop_with_nested_loopEa"}
   %2 = fir.alloca i32 {bindc_name = "i", uniq_name = "_QFsimdloop_with_nested_loopEi"}
   %3 = fir.alloca i32 {bindc_name = "j", uniq_name = "_QFsimdloop_with_nested_loopEj"}
   %c1_i32 = arith.constant 1 : i32
   %c10_i32 = arith.constant 10 : i32
   %c1_i32_0 = arith.constant 1 : i32

mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp

rewriter.replaceOpWithNewOp<Op>(curOp, TypeRange(), adaptor.getOperands(),
                                     curOp.getOperation()->getAttrs());
     return success();
   }
 };
 } // namespace
 
 void mlir::configureOpenMPToLLVMConversionLegality(
     ConversionTarget &target, LLVMTypeConverter &typeConverter) {
-  target.addDynamicallyLegalOp<mlir::omp::AtomicUpdateOp, mlir::omp::CriticalOp,
-                               mlir::omp::ParallelOp, mlir::omp::WsLoopOp,
-                               mlir::omp::SimdLoopOp, mlir::omp::MasterOp,
-                               mlir::omp::SectionOp, mlir::omp::SectionsOp,
-                               mlir::omp::SingleOp, mlir::omp::TaskOp>(
-      [&](Operation *op) {
-        return typeConverter.isLegal(&op->getRegion(0)) &&
-               typeConverter.isLegal(op->getOperandTypes()) &&
-               typeConverter.isLegal(op->getResultTypes());
-      });
-  target.addDynamicallyLegalOp<mlir::omp::AtomicReadOp,
-                               mlir::omp::AtomicWriteOp, mlir::omp::FlushOp,
-                               mlir::omp::ThreadprivateOp, mlir::omp::DataOp,
-                               mlir::omp::EnterDataOp, mlir::omp::ExitDataOp>(
+  target.addDynamicallyLegalOp<
+      mlir::omp::AtomicUpdateOp, mlir::omp::CriticalOp, mlir::omp::DataOp,
+      mlir::omp::ParallelOp, mlir::omp::WsLoopOp, mlir::omp::SimdLoopOp,
+      mlir::omp::MasterOp, mlir::omp::SectionOp, mlir::omp::SectionsOp,
+      mlir::omp::SingleOp, mlir::omp::TaskOp>([&](Operation *op) {
+  target
+      .addDynamicallyLegalOp<mlir::omp::AtomicReadOp, mlir::omp::AtomicWriteOp,
+                             mlir::omp::FlushOp, mlir::omp::ThreadprivateOp,
           [&](Operation *op) {
             return typeConverter.isLegal(op->getOperandTypes()) &&
                    typeConverter.isLegal(op->getResultTypes());
           });
   target.addDynamicallyLegalOp<mlir::omp::ReductionOp>([&](Operation *op) {
     return typeConverter.isLegal(op->getOperandTypes());
   });
 }
 
 void mlir::populateOpenMPToLLVMConversionPatterns(LLVMTypeConverter &converter,
                                                   RewritePatternSet &patterns) {
   patterns.add<
-      ReductionOpConversion, RegionOpConversion<omp::CriticalOp>,
-      RegionOpConversion<omp::MasterOp>, ReductionOpConversion,
-      RegionOpConversion<omp::MasterOp>, RegionOpConversion<omp::ParallelOp>,
-      RegionOpConversion<omp::WsLoopOp>, RegionOpConversion<omp::SectionsOp>,
-      RegionOpConversion<omp::SectionOp>, RegionOpConversion<omp::SimdLoopOp>,
-      RegionOpConversion<omp::SingleOp>, RegionOpConversion<omp::TaskOp>,
+      LegalizeDataOpForLLVMTranslation<omp::DataOp>,
+      LegalizeDataOpForLLVMTranslation<omp::EnterDataOp>,
+      LegalizeDataOpForLLVMTranslation<omp::ExitDataOp>, ReductionOpConversion,
+      RegionOpConversion<omp::CriticalOp>, RegionOpConversion<omp::MasterOp>,
+      ReductionOpConversion, RegionOpConversion<omp::MasterOp>,
+      RegionOpConversion<omp::ParallelOp>, RegionOpConversion<omp::WsLoopOp>,
+      RegionOpConversion<omp::SectionsOp>, RegionOpConversion<omp::SectionOp>,
+      RegionOpConversion<omp::SimdLoopOp>, RegionOpConversion<omp::SingleOp>,
+      RegionOpConversion<omp::TaskOp>, RegionOpConversion<omp::DataOp>,
       RegionLessOpWithVarOperandsConversion<omp::AtomicReadOp>,
       RegionLessOpWithVarOperandsConversion<omp::AtomicWriteOp>,
       RegionOpWithVarOperandsConversion<omp::AtomicUpdateOp>,
       RegionLessOpWithVarOperandsConversion<omp::FlushOp>,
-      RegionLessOpWithVarOperandsConversion<omp::ThreadprivateOp>,
-      LegalizeDataOpForLLVMTranslation<omp::DataOp>,
-      LegalizeDataOpForLLVMTranslation<omp::EnterDataOp>,
-      LegalizeDataOpForLLVMTranslation<omp::ExitDataOp>>(converter);
+      RegionLessOpWithVarOperandsConversion<omp::ThreadprivateOp>>(converter);
 }
 
 namespace {
 struct ConvertOpenMPToLLVMPass
     : public impl::ConvertOpenMPToLLVMPassBase<ConvertOpenMPToLLVMPass> {
   using Base::Base;
 
   void runOnOperation() override;

mlir/test/Conversion/OpenMPToLLVM/convert-to-llvmir.mlir

 llvm.func @_QPomp_target_data(%a : !llvm.ptr<i32>, %b : !llvm.ptr<i32>, %c : !llvm.ptr<i32>, %d : !llvm.ptr<i32>) {
   omp.target_enter_data   map((to -> %a : !llvm.ptr<i32>), (to -> %b : !llvm.ptr<i32>), (always, alloc -> %c : !llvm.ptr<i32>))
   omp.target_exit_data   map((from -> %a : !llvm.ptr<i32>), (from -> %b : !llvm.ptr<i32>), (release -> %c : !llvm.ptr<i32>), (always, delete -> %d : !llvm.ptr<i32>))
   llvm.return
 }
 
 // -----
 
+// CHECK-LABEL: @_QPomp_target_data_region
+// CHECK: (%[[ARG0:.*]]: !llvm.ptr<array<1024 x i32>>, %[[ARG1:.*]]: !llvm.ptr<i32>) {
+// CHECK:   omp.target_data   map((tofrom -> %[[ARG0]] : !llvm.ptr<array<1024 x i32>>)) {
+// CHECK:           %[[VAL_1:.*]] = llvm.mlir.constant(10 : i32) : i32
+// CHECK:           llvm.store %[[VAL_1]], %[[ARG1]] : !llvm.ptr<i32>
+// CHECK:           omp.terminator
+// CHECK:         }
+// CHECK:         llvm.return
+
+llvm.func @_QPomp_target_data_region(%a : !llvm.ptr<array<1024 x i32>>, %i : !llvm.ptr<i32>) {
+  omp.target_data   map((tofrom -> %a : !llvm.ptr<array<1024 x i32>>)) {
+    %1 = llvm.mlir.constant(10 : i32) : i32
+    llvm.store %1, %i : !llvm.ptr<i32>
+    omp.terminator
+  }
+  llvm.return
+}
+
+// -----
+
 // CHECK-LABEL: @_QPsb
 // CHECK: omp.sections
 // CHECK: omp.section
 // CHECK: llvm.br
 // CHECK: llvm.icmp
 // CHECK: llvm.cond_br
 // CHECK: llvm.br
 // CHECK: omp.terminator