[MLIR][OpenMP] Added target data, exit data, and enter data operation definition for MLIR.

[TIFitis]

Summary

This includes a basic implementation for the OpenMP 5.1 Target Data, Target Exit Data and Target Enter Data constructs
operation.

TODO:

• Depend clause support for Target Enter and Exit Data.
• Mapper and Iterator value support for Map Type Modifiers.
• Verifier for the operations.

Co-authored-by: abidmalikwaterloo <[e-mail]>
Co-authored-by: raghavendra <[e-mail]>

This patch will replace the https://reviews.llvm.org/D105255/new/ (D105255)
It is the latest update of D105255
One can see the comments in the previous patch.
Every issue/comment has been taken care of from D105255

[raghavendhra]

LGTM

[clementval]

In D105255 we discussed about adding assembly format directly. I don't see it here.

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

819

Any reason to add comment in the description that will be comment anyway? Same below.

[abidmalikwaterloo]

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

819

I was asked by a reviewer in D105255 to clarify the values of the modifier through comments.

[clementval]

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

819

What I meant is that the description block is already comments so you don't need to add ///.

[abidmalikwaterloo]

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

819

Ah! :) Got it. I will remove it.

[raghavendhra]

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

852

Are you planning to add verifier in future patches?

927

Same as above, Are you planning to add verifier in future patches?

1002

Same as above, Are you planning to add verifier in future patches?

[abidmalikwaterloo]

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

852

Yes

927

yes

1002

yes

[clementval]

mlir/test/Dialect/OpenMP/ops.mlir

407

Can you switch to the custom format form?

412

Same here

415

Same here.

417–418

Not needed for this test.

[TIFitis]

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

902–903

Do we need both $nowait_operand and $nowait?

977–978

Same here. Do we need both $nowait_operand and $nowait?

[abidmalikwaterloo]

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

902–903

No. Thanks for pointing this out. I overlooked it. It will be corrected.

[TIFitis]

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

833

When multiple map clauses are supplied, it is not possible to associate the map_type_modifier to its respective map.

Eg:

!$omp target enter data map(to: a) map(always alloc: b) can be lowered to something like
omp.target_enter_data map_to(%0 : !fir.ref<i32>) map_alloc(%1 : !fir.ref<i32>) map_type_modifier(%c4_i32 : i32)

It is not possible to deduce if the map_type_modifier %c4_i32 is for a or b.

I'm not sure if something like Variadic<Optional<AnyInteger>, AnyType> is supported then we can change all the map_operands' type to that. If not we might need a map_type_modifier for each map_operand type.

[TIFitis]

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

904–910

Only map_to and map_alloc are allowed types for EnterData. We can perhaps get rid of the remaining map_operand types.

979–985

Only map_from, map_release and map_delete are allowed types for ExitData. We can perhaps get rid of the remaining map_operand types.

[abidmalikwaterloo]

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

833

One possibility is to make it a vector for each map_type_modifier. The length is equal to map clauses. The index number can be used to associate the corresponding map clause in the construct and '1' will tell whether the map_type_modifier is active for the corresponding clause. But, `Variadic<Optional<AnyInteger>, AnyType> option seems more appropriate if available.

[TIFitis]

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

833

I thought of using the index of map_type_modifier but that still doesn't solve the issue.

Eg,
omp target enter data map(to: a) map(always alloc: b) and
omp target enter data map(alloc: b) map(always to: a)

both get lowered to the same mlir

omp.target_enter_data map_to(a) map_alloc(b) map_type_modifier(false, true).

This is because upon lowering we lose information on ordering of map clauses from source.

[clementval]

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

833

The value in the map_type_modifer should be a combination of the different map type modifiers for the operand at the same position and not just true false. The runtime and OpenMP IR Builder are using this already.

[TIFitis]

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

833

Thanks for clearing that, I was wondering the same.

I think the current implementation is workable, but something like Variadic<Optional<AnyInteger>, AnyType> may be more preferrable.

[raghavendhra]

Addressed latest comments

[raghavendhra]

Overlooked some restrictions in OpenMP standard and made changes accordingly.

[clementval]

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

822–827

Why not having a single map_operands and encoding all the rest in the map_type_modifier vector? This is what the runtime expect so it would simplify things here. Just the fact that you have to, from and toform would lead into such an encoding.

[raghavendhra]

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

822–827

Sure, I can make that change.

Sorry I am unaware of how to implement this vector based map_operand. Can you please point me to any example I can refer here to get similar implementation here.

[abidmalikwaterloo]

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

822–827

I checked the OpenACC dialect. It does not support copyin and copyout operations yet. They are closest to the map_to, and map_from. I checked my notes. I dropped the idea of vector support because of no clarity of its implementation at that time. Do we have anything in the MLIR dialects now that we can take as a template for the proposed vector implementation? I checked acc dialect but could not figure out anything.

833

I thought of using the index of map_type_modifier but that still doesn't solve the issue.

Eg,
omp target enter data map(to: a) map(always alloc: b) and
omp target enter data map(alloc: b) map(always to: a)

both get lowered to the same mlir

omp.target_enter_data map_to(a) map_alloc(b) map_type_modifier(false, true).

This is because upon lowering we lose information on ordering of map clauses from source.

[kiranchandramohan]

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

822–827

I think what @clementval is suggesting is to just have the following, where the the map_operands and map_type_and_modifier_operands are in one-to-one correspondence.

Variadic<AnyType>:$map_operands,
Variadic<AnyType>:$map_type_and_modifier_operands);

The pretty print form of the map clause can be something like

map (always, to : a)  (none, fromto : b)

Assumption: The default map-type is fromto and there is no default map-type-modifier.

So map_operands will internally be [ a, b] and map_type_and_modifer operands will be [ <always, to>, <none, fromto> ].

We can write a custom printer and parser. The custom parse will parse this info into the $map_operands and the $map_type_and_modifier_operands.

[kiranchandramohan]

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

822–827

Also, thinking about this, the map_type_and_modifier will be an attribute and not an operand since this is a constant value known at compiler time and not a variable value. It is also possible to represent this as an Enum Attribute.

[clementval]

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

822–827

Yeah that this more or less what I had in mind. OpenACC doesn't have this because to/from are not modifier but clauses. There are also fewer modifiers so the complexity is reduced and we could represent all the combination easily which is not the case for OpenMP.

[abidmalikwaterloo]

Thanks, @kiranchandramohan @raghavendhra @clementval

In case:

map  (none, fromto: b) (always, to: a)

map_operands will internally be [ b, a] and map_type_and_modifer operands will be [ <none, fromto>, <always, to> ].

[kiranchandramohan]

In D131915#3849417, @abidmalikwaterloo wrote:

Thanks, @kiranchandramohan @raghavendhra @clementval

In case:

map  (none, fromto: b) (always, to: a)

map_operands will internally be [ b, a] and map_type_and_modifer operands will be [ <none, fromto>, <always, to> ].

Yes, that sounds right.

[raghavendhra]

Added implementation according to @clementval, @kiranchandramohan and @abidmalikwaterloo's review comments discussion.

[raghavendhra]

Seperated map_operands with map-type and map-type-modifier as enum attributes.

[raghavendhra]

Ping for review.

[TIFitis]

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

817–818

I think these should be Variadic to allow multiple map clauses.

871–872

I think these should be Variadic to allow multiple map clauses.

922–923

I think these should be Variadic to allow multiple map clauses.

[clementval]

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

828

It's not clear how to you deal with multiple map clauses here? Or do you plan to have an operation generation per map clause coming from the frontend?

879

Same comment here about multiple map clauses. You probably need a custom parser/printer for the map part together with the change requested by @TIFitis.

930

Same comment here.

[TIFitis]

Changed map_operands to VariadicOfVariadic type.

Variadic Enums are not supported, hence I've changed the map type to VariadicOfVariadic which allows to store the entire map clause including types and modifiers in a single operand.

[TIFitis]

If people are happy with this structure then I'll work on adding a pretty printer for the map clause. Please suggest any other changes that are required.

[TIFitis]

Added custom printer & parser for map clause. Updated ops.mlir test to address reviewer comments.

Custom Printer example:

OMP: !$omp target exit data map(from: a,b) map(release: c) map(delete: d) map(always, from: e)
CustomPrinter: omp.target_exit_data map((%c2_i64 -> none , from : %0 : !fir.ref<!fir.array<1024xi32>>), (%c2_i64 -> none , from : %1 : !fir.ref<!fir.array<1024xi32>>), (%c0_i64 -> none , release : %2 : !fir.ref<!fir.array<1024xi32>>), (%c8_i64 -> none , delete : %3 : !fir.ref<!fir.array<1024xi32>>), (%c6_i64 -> always , from : %4 : !fir.ref<!fir.array<1024xi32>>))

Requesting comments and suggestions :)

[TIFitis]

mlir/test/Dialect/OpenMP/ops.mlir

407

Hi, I've updated the test file, Is this what you wanted?

[kiranchandramohan]

Thanks for the changes and your work here.

In D131915#3994160, @TIFitis wrote:

Added custom printer & parser for map clause. Updated ops.mlir test to address reviewer comments.

Custom Printer example:

OMP: !$omp target exit data map(from: a,b) map(release: c) map(delete: d) map(always, from: e)
CustomPrinter: omp.target_exit_data map((%c2_i64 -> none , from : %0 : !fir.ref<!fir.array<1024xi32>>), (%c2_i64 -> none , from : %1 : !fir.ref<!fir.array<1024xi32>>), (%c0_i64 -> none , release : %2 : !fir.ref<!fir.array<1024xi32>>), (%c8_i64 -> none , delete : %3 : !fir.ref<!fir.array<1024xi32>>), (%c6_i64 -> always , from : %4 : !fir.ref<!fir.array<1024xi32>>))

Can you add this as a test? AFAIS, the tests attached to this patch do not seem to be exercising the VariadicofVariadic requirement. An explanation with an example would be great.

1. Fortran Source + OpenMP example that needs a VariadicOfVariadic
2. MLIR OpenMP representation

I am assuming we would need a verifier as well for the map clause.

Can you also restrict this patch to one of the constructs say target data for this patch? Once we decide on that then the other two can be easily added in a separate patch.

mlir/lib/Dialect/OpenMP/CMakeLists.txt

15 ↗

(On Diff #482732)

Why is this needed here?

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

572 ↗

(On Diff #482732)

Nit: can you specify the type here?

584 ↗

(On Diff #482732)

There is a bitn function in printSynchronizationHint and verifySynchronizationHint, can that be used here?

mlir/test/Dialect/OpenMP/ops.mlir

407

Both the input and the CHECK lines in the custom format.

[TIFitis]

Addresed reviewer comments.
Added second map clause to test.

[TIFitis]

Can you add this as a test? AFAIS, the tests attached to this patch do not seem to be exercising the VariadicofVariadic requirement. An explanation with an example would be great.

VariadicOfVariadic gives us a SmallVector<ValueRange> where ValueRange is essentially a SmallVector<Value>. As it is possible to have multiple map clauses for a single target construct, this allows us to represent each map clause as a row in $map_operands.

I've updated the ops.mlir test to use two map clauses which better shows this use case.

1. Fortran Source + OpenMP example that needs a VariadicOfVariadic
2. MLIR OpenMP representation

Fortran Source:

subroutine omp_target_enter
   integer :: a(1024)
   integer :: b(1024)
   !$omp target enter data map(to: a,) map(always, alloc: b)
end subroutine omp_target_enter

MLIR OpenMP representation:

func.func @_QPomp_target_enter() {
  %0 = fir.alloca !fir.array<1024xi32> {bindc_name = "a", uniq_name = "_QFomp_target_enterEa"}
  %1 = fir.alloca !fir.array<1024xi32> {bindc_name = "b", uniq_name = "_QFomp_target_enterEb"}
  %c1_i64 = arith.constant 1 : i64
  %c4_i64 = arith.constant 4 : i64
  omp.target_enter_data   map((%c1_i64 -> none , to : %0 : !fir.ref<!fir.array<1024xi32>>), (%c4_i64 -> always , alloc : %1 : !fir.ref<!fir.array<1024xi32>>))
  return
}

I plan on adding these as tests along with Fortran lowering support in upcoming patches.

I am assuming we would need a verifier as well for the map clause.

AFAIK the map clause rules are op specific. I plan on adding verifiers for the ops soon in a separate patch.

Can you also restrict this patch to one of the constructs say target data for this patch? Once we decide on that then the other two can be easily added in a separate patch.

Since I didn't make any changes to the ops I've left them in. If the patch requires further changes, I'll leave them out.

mlir/lib/Dialect/OpenMP/CMakeLists.txt

15 ↗

(On Diff #482732)

The Arith Dialect needs to be linked against as we're using it extract the int value from arith.constant in the custom printer.

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

584 ↗

(On Diff #482732)

I've added something similar. I got the bit values from Clang codegen and they use hex so I've kept it that way for uniformity. Let me know if you'd rather it be in n'th bit format.

mlir/test/Dialect/OpenMP/ops.mlir

407

I've changed both to custom format. Added a second map clause argument to show support.

[jdoerfert]

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

584 ↗

(On Diff #482732)

Clang codegen magic constants (and everything else) is moved to llvm/.../Frontend/OpenMP for a reason. Hardcoding the numbers again somewhere else seems like exactly the wrong thing to do.

[clementval]

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

584 ↗

(On Diff #482732)

+1

[kiranchandramohan]

Can you add the other authors as Co-authors in the patch Summary?

In D131915#4001620, @TIFitis wrote:

Can you add this as a test? AFAIS, the tests attached to this patch do not seem to be exercising the VariadicofVariadic requirement. An explanation with an example would be great.

VariadicOfVariadic gives us a SmallVector<ValueRange> where ValueRange is essentially a SmallVector<Value>. As it is possible to have multiple map clauses for a single target construct, this allows us to represent each map clause as a row in $map_operands.

I've updated the ops.mlir test to use two map clauses which better shows this use case.

1. Fortran Source + OpenMP example that needs a VariadicOfVariadic
2. MLIR OpenMP representation

Fortran Source:

subroutine omp_target_enter
   integer :: a(1024)
   integer :: b(1024)
   !$omp target enter data map(to: a,) map(always, alloc: b)
end subroutine omp_target_enter

MLIR OpenMP representation:

func.func @_QPomp_target_enter() {
  %0 = fir.alloca !fir.array<1024xi32> {bindc_name = "a", uniq_name = "_QFomp_target_enterEa"}
  %1 = fir.alloca !fir.array<1024xi32> {bindc_name = "b", uniq_name = "_QFomp_target_enterEb"}
  %c1_i64 = arith.constant 1 : i64
  %c4_i64 = arith.constant 4 : i64
  omp.target_enter_data   map((%c1_i64 -> none , to : %0 : !fir.ref<!fir.array<1024xi32>>), (%c4_i64 -> always , alloc : %1 : !fir.ref<!fir.array<1024xi32>>))
  return
}

Thanks, that helps.

I plan on adding these as tests along with Fortran lowering support in upcoming patches.

I am assuming we would need a verifier as well for the map clause.

AFAIK the map clause rules are op specific. I plan on adding verifiers for the ops soon in a separate patch.

Can you also restrict this patch to one of the constructs say target data for this patch? Once we decide on that then the other two can be easily added in a separate patch.

Since I didn't make any changes to the ops I've left them in. If the patch requires further changes, I'll leave them out.

The concern is with the introduction of VariadicOfVariadic with AnyType. I think this is new in the OpenMP Dialect and it pretty much allows anything. So, I was thinking whether it would be a good idea to write a verifier for the map clause, if not for the entire construct.

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

811–812

This is OK for now, but we might have to switch to OpenMPPointerType later.

814

Is map_operand_segments currently unused?

mlir/lib/Dialect/OpenMP/CMakeLists.txt

15 ↗

(On Diff #482732)

Can this be avoided by modelling constants as attributes?

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

577–583 ↗

(On Diff #483545)

Generally, constant values are modelled as attributes in MLIR representation. Can we switch to that representation? This will also avoid the need for this if-else and dependence on the arith dialect.

595 ↗

(On Diff #483545)

I think llvm prefers using llvm::raw_string_ostream. I have seen only two uses of std::stringstream in MLIR code, possibly accidentally introduced.

mlir/test/Dialect/OpenMP/ops.mlir

407

Can you increase the coverage so that each clause is present atleast once, probably by adding more than one test for each operation.

[TIFitis]

Added verifiers, removed use of magic constants and addressed other reviewer comments.

[TIFitis]

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

814

map_operand_segments is required by VariadicOfVariadic type to keep track of the dimensions. I haven't made explicit use of it, however, it is used internally and cant be avoided AFAIK.

It is akin to the operand_segment_sizes which is implicitly present for Operations with Optional or Variadic operands.

mlir/lib/Dialect/OpenMP/CMakeLists.txt

15 ↗

(On Diff #482732)

The issue with attributes is AFAIK Variadic<Attribute> is not supported, and as previously discussed we need it be Variadic to support multiple map clauses.

If I am wrong and there is indeed a way to have Variadic<Attribute> then this can be avoided.

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

577–583 ↗

(On Diff #483545)

Copy:
The issue with attributes is AFAIK Variadic<Attribute> is not supported, and as previously discussed we need it be Variadic to support multiple map clauses.

If I am wrong and there is indeed a way to have Variadic<Attribute> then this can be avoided.

[kiranchandramohan]

mlir/lib/Dialect/OpenMP/CMakeLists.txt

15 ↗

(On Diff #482732)

Can we use an ArrayAttr (https://mlir.llvm.org/docs/Dialects/Builtin/#arrayattr) or something derived from it?
https://github.com/llvm/llvm-project/blob/6ee5a1a090f3f4b6ae7ec9915900023277daf8d7/mlir/include/mlir/IR/OpBase.td#L1467

[TIFitis]

Removed use of VariadicOfVariadic. Added new I64ArrayAttr for map_types.

[TIFitis]

Minor indentation changes.

[kiranchandramohan]

LGTM. Thanks for making the changes and for your patience. Please wait a couple of days to give other reviewers a chance to have a look before submitting.

Could you update the Summary of this patch to specify what is in this patch and what is left out? Also, might be useful to specify any special modelling, like for the map clause.

Could you specify the co-authors in the following way?
Co-authored-by: abidmalikwaterloo <[e-mail]>
Co-authored-by: raghavendra <[e-mail]>

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

774

Is this number from the OpenMP 5.0 standard? I think 5.0 does not have the present map-type modifier. The printer includes this. I think we can either remove things that are not there in 5.0 or add comments when items from newer versions are included or alternatively change the number to the latest version and call out everything that is not implemented.

802–804

Update these two to their current meanings. (Also replace map_operand_segments with map_types.

Same comment for the other two operations.

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

542 ↗

(On Diff #489515)

Could you specify the EBNF (https://mlir.llvm.org/docs/LangRef/#notation) for the expected structure of the map clause?

595 ↗

(On Diff #489515)

Nit: Should this be an assert?

[TIFitis]

Addressed reviewer comments.
Updated printer and parser to remove the IntegerAttr from appearing. Removed none from map type modifiers, absence of other modifiers implicitly means none. This helps keep it in closer to the specification.

[TIFitis]

In D131915#4056730, @kiranchandramohan wrote:

LGTM. Thanks for making the changes and for your patience. Please wait a couple of days to give other reviewers a chance to have a look before submitting.

Thanks for reviewing the changes as well :)

Could you update the Summary of this patch to specify what is in this patch and what is left out? Also, might be useful to specify any special modelling, like for the map clause.

I've updated the summary. The new map clause looks straight forward to me, anything particular you want me to mention in the summary?

Could you specify the co-authors in the following way?
Co-authored-by: abidmalikwaterloo <[e-mail]>
Co-authored-by: raghavendra <[e-mail]>

Done.

Cheers,
Akash

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

774

Hi I've updated it to OpenMP 5.1 standard specification. We are missing the depend clause, and mapper and iterator values for the map_type_modifier which are already specified in the TODO.

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

542 ↗

(On Diff #489515)

Now that we are using IntegerAttr we no longer need the Attr to be explicitly present when printing it.

I have thus updated the printer and parser accordingly, also removed none as a map_type_modifier as absence of other modifiers implicitly implies it and prevents confusion by diverging from the specification.

Here's an example of the new custom printer:

omp.target_exit_data   map((release -> %1 : !llvm.ptr<array<1024 x i32>>), (always, close, from -> %2 : !llvm.ptr<array<1024 x i32>>))

Let me know if the EBNF is okay. Should I override clang-format and keep the grammar and Eg in the same line to make them easier to read?

[TIFitis]

I'm planning on merging the patch early next week. If you'd like to see any changes or need more time to review, please let me know :)

Akash

[clementval]

Just small nit

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

628–629 ↗

(On Diff #489881)

auto should be spelled out here.

clang/lib/CodeGen/CGStmtOpenMP.cpp

static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
   case OMPC_filter:
   case OMPC_when:
   case OMPC_adjust_args:
   case OMPC_append_args:
   case OMPC_memory_order:
   case OMPC_bind:
   case OMPC_align:
   case OMPC_cancellation_construct_type:
+  case OMPC_map_type:
+  case OMPC_map_type_modifier:
     llvm_unreachable("Clause is not allowed in 'omp atomic'.");
   }
 }
 
 void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
   llvm::AtomicOrdering AO = llvm::AtomicOrdering::Monotonic;
   bool MemOrderingSpecified = false;
   if (S.getSingleClause<OMPSeqCstClause>()) {

flang/lib/Semantics/check-omp-structure.cpp

 CHECK_SIMPLE_CLAUSE(When, OMPC_when)
 CHECK_SIMPLE_CLAUSE(AdjustArgs, OMPC_adjust_args)
 CHECK_SIMPLE_CLAUSE(AppendArgs, OMPC_append_args)
 CHECK_SIMPLE_CLAUSE(MemoryOrder, OMPC_memory_order)
 CHECK_SIMPLE_CLAUSE(Bind, OMPC_bind)
 CHECK_SIMPLE_CLAUSE(Align, OMPC_align)
 CHECK_SIMPLE_CLAUSE(Compare, OMPC_compare)
 CHECK_SIMPLE_CLAUSE(CancellationConstructType, OMPC_cancellation_construct_type)
+CHECK_SIMPLE_CLAUSE(MapType, OMPC_map_type)
+CHECK_SIMPLE_CLAUSE(MapTypeModifier, OMPC_map_type_modifier)
 
 CHECK_REQ_SCALAR_INT_CLAUSE(Grainsize, OMPC_grainsize)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumTasks, OMPC_num_tasks)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumTeams, OMPC_num_teams)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumThreads, OMPC_num_threads)
 CHECK_REQ_SCALAR_INT_CLAUSE(Priority, OMPC_priority)
 CHECK_REQ_SCALAR_INT_CLAUSE(ThreadLimit, OMPC_thread_limit)
 

llvm/include/llvm/Frontend/OpenMP/OMP.td

let allowedClauseValues = [
     OMP_CANCELLATION_CONSTRUCT_Parallel,
     OMP_CANCELLATION_CONSTRUCT_Loop,
     OMP_CANCELLATION_CONSTRUCT_Sections,
     OMP_CANCELLATION_CONSTRUCT_Taskgroup,
     OMP_CANCELLATION_CONSTRUCT_None
   ];
 }
 
+def OMP_MAP_TYPE_To : ClauseVal<"to", 1, 1> {}
+def OMP_MAP_TYPE_From : ClauseVal<"from", 2, 1> {}
+def OMP_MAP_TYPE_ToFrom : ClauseVal<"tofrom", 3, 1> {}
+def OMP_MAP_TYPE_Alloc : ClauseVal<"alloc", 4, 1> {}
+def OMP_MAP_TYPE_Release : ClauseVal<"release", 5, 1> {}
+def OMP_MAP_TYPE_Delete : ClauseVal<"delete", 6, 1> {}
+def OMP_MAP_TYPE_None : ClauseVal<"none", 7, 0> {
+  let isDefault = 1;
+}
+
+def OMPC_MapType : Clause<"map_type"> {
+  let enumClauseValue = "MapType";
+  let allowedClauseValues = [
+    OMP_MAP_TYPE_To,
+    OMP_MAP_TYPE_From,
+    OMP_MAP_TYPE_ToFrom,
+    OMP_MAP_TYPE_Alloc,
+    OMP_MAP_TYPE_Release,
+    OMP_MAP_TYPE_Delete,
+    OMP_MAP_TYPE_None
+  ];
+}
+
+def OMP_MAP_TYPE_MODIFIER_Always : ClauseVal<"always", 1, 1> {}
+def OMP_MAP_TYPE_MODIFIER_Close : ClauseVal<"close", 2, 1> {}
+def OMP_MAP_TYPE_MODIFIER_Present : ClauseVal<"present", 3, 1> {}
+def OMP_MAP_TYPE_MODIFIER_None : ClauseVal<"none", 4, 0> {
+  let isDefault = 1;
+}
+
+def OMPC_MapTypeModifier : Clause<"map_type_modifier"> {
+  let enumClauseValue = "MapTypeModifier";
+  let allowedClauseValues = [
+    OMP_MAP_TYPE_MODIFIER_Always,
+    OMP_MAP_TYPE_MODIFIER_Close,
+    OMP_MAP_TYPE_MODIFIER_Present,
+    //TODO : map-type-identifier mapper(mapper-identifier)
+    OMP_MAP_TYPE_MODIFIER_None
+  ];
+}
+
 def OMPC_Ordered : Clause<"ordered"> {
   let clangClass = "OMPOrderedClause";
   let flangClass = "ScalarIntConstantExpr";
   let isValueOptional = true;
 }
 def OMPC_NoWait : Clause<"nowait"> {
   let clangClass = "OMPNowaitClause";
 }

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

def TaskyieldOp : OpenMP_Op<"taskyield"> {
   let description = [{
     The taskyield construct specifies that the current task can be suspended
     in favor of execution of a different task.
   }];
 
   let assemblyFormat = "attr-dict";
 }
 
+//===---------------------------------------------------------------------===//
+// 2.12.2 target data Construct 
+//===---------------------------------------------------------------------===//
+
+def Target_Data: OpenMP_Op<"target_data", [AttrSizedOperandSegments]>{
+  let summary = "target data construct";
+  let description = [{
+    Map variables to a device data environment for the extent of the region.
+
+    The omp target data directive maps variables to a device data 
+    environment, and defines the lexical scope of the data environment 
+    that is created. The omp target data directive can reduce data copies 
+    to and from the offloading device when multiple target regions are using 
+    the same data.
+
+    The optional $if_expr parameter specifies a boolean result of a
+    conditional check. If this value is 1 or is not provided then the target
+    region runs on a device, if it is 0 then the target region is executed 
+    on the host device.
+
+    The optional $device parameter specifies the device number for the target 
+    region.
+
+    The optional $use_device_ptr specifies the device pointers to the 
+    corresponding list items in the device data environment.
+    
+    The optional $use_device_addr specifies the address of the objects in the 
+    device data enviornment.
+
+    The $map_operands specifies operands in map clause.
+
+    The $map_type specifies map-type within map clause and can take values to,
+    from, tofrom or alloc.
+    
+    The $map_type_modifier specifies the modifier and can be always, close,
+    present, iterator and mapper.
+    
+    TODO:  depend clause and map_type_modifier values iterator and mapper.
+  }];
+
+  let arguments = (ins Optional<I1>:$if_expr,
+             Optional<AnyInteger>:$device,
+             Variadic<AnyType>:$use_device_ptr,
+             Variadic<AnyType>:$use_device_addr,
+             MapTypeModifierAttr:$map_type_modifier_val,
+             MapTypeAttr:$map_type_val,
+             Variadic<AnyType>:$map_operands);
+       
+  let regions = (region AnyRegion:$region); 
+      
+  let assemblyFormat = [{
+    (`if` `(` $if_expr^ `)` )?
+    (`device` `(` $device^ `:` type($device) `)` )?
+    (`use_device_ptr` `(` $use_device_ptr^ `:` type($use_device_ptr) `)` )?
+    (`use_device_addr` `(` $use_device_addr^ `:` type($use_device_addr) `)` )?
+    (`map` `(` $map_type_modifier_val `,` $map_type_val `:` $map_operands^ `:` type($map_operands) `)` )?
+    $region attr-dict
+  }];          
+  
+}
+
+//===---------------------------------------------------------------------===//
+// 2.12.3 target enter data Construct
+//===---------------------------------------------------------------------===//
+
+def Target_EnterDataOp: OpenMP_Op<"target_enter_data", 
+                                                 [AttrSizedOperandSegments]>{
+  let  summary = "target enter data construct";
+  let description = [{
+    The target enter data directive specifies that variables are mapped to 
+    a device data environment. The target enter data directive is a 
+    stand-alone directive.
+  
+    The optional $if_expr parameter specifies a boolean result of a
+    conditional check. If this value is 1 or is not provided then the target
+    region runs on a device, if it is 0 then the target region is executed on 
+    the host device.
+
+    The optional $device parameter specifies the device number for the 
+    target region.
+
+    The optional $nowait eliminates the implicit barrier so the parent task 
+    can make progress even if the target task is not yet completed.
+
+    The $map_operands specifies operands in map clause.
+
+    The $map_type specifies map-type within map clause and can take values to
+    or alloc.
+    
+    The $map_type_modifier specifies the modifier and can be always, close,
+    present, iterator and mapper.
+    
+    TODO:  depend clause and map_type_modifier values iterator and mapper.
+  }];
+
+  let arguments = (ins Optional<I1>:$if_expr,
+             Optional<AnyInteger>:$device,
+             UnitAttr:$nowait,
+             MapTypeModifierAttr:$map_type_modifier_val,
+             MapTypeAttr:$map_type_val,
+             Variadic<AnyType>:$map_operands);
+  let hasCustomAssemblyFormat = 1;
+  let assemblyFormat = [{
+    (`if` `(` $if_expr^ `)` )?
+    (`device` `(` $device^ `:` type($device) `)` )?
+    (`nowait` $nowait^ )?
+    (`map` `(` $map_type_modifier_val `,` $map_type_val `:` $map_operands^ `:` type($map_operands) `)` )?
+    attr-dict
+  }];
+
+}
+
+//===---------------------------------------------------------------------===//
+// 2.12.4 target exit data Construct
+//===---------------------------------------------------------------------===//
+
+def Target_ExitDataOp: OpenMP_Op<"target_exit_data",
+                                                 [AttrSizedOperandSegments]>{
+  let  summary = "target exit data construct";
+  let description = [{
+    The target exit data directive specifies that variables are mapped to a 
+    device data environment. The target exit data directive is 
+    a stand-alone directive.
+
+    The optional $if_expr parameter specifies a boolean result of a
+    conditional check. If this value is 1 or is not provided then the target
+    region runs on a device, if it is 0 then the target region is executed 
+    on the host device.
+
+    The optional $device parameter specifies the device number for the 
+    target region.
+
+    The optional $nowait eliminates the implicit barrier so the parent 
+    task can make progress even if the target task is not yet completed.
+
+    The $map_operands specifies operands in map clause.
+
+    The $map_type specifies map-type within map clause and can take values
+    from, release or delete.
+    
+    The $map_type_modifier specifies the modifier and can be always, close,
+    present, iterator and mapper.
+    
+    TODO:  depend clause and map_type_modifier values iterator and mapper.
+  }];
+
+  let arguments = (ins Optional<I1>:$if_expr,
+             Optional<AnyInteger>:$device,
+             UnitAttr:$nowait,
+             MapTypeModifierAttr:$map_type_modifier_val,
+             MapTypeAttr:$map_type_val,
+             Variadic<AnyType>:$map_operands);
+             
+  let assemblyFormat = [{
+    (`if` `(` $if_expr^ `)` )?
+    (`device` `(` $device^ `:` type($device) `)` )?
+    (`nowait` $nowait^ )?
+    (`map` `(` $map_type_modifier_val `,` $map_type_val `:` $map_operands^ `:` type($map_operands) `)` )?
+    attr-dict
+  }];              
+                                     
+}
+
 //===----------------------------------------------------------------------===//
 // 2.13.7 flush Construct
 //===----------------------------------------------------------------------===//
 def FlushOp : OpenMP_Op<"flush"> {
   let summary = "flush construct";
   let description = [{
     The flush construct executes the OpenMP flush operation. This operation
     makes a thread’s temporary view of memory consistent with memory and
let description = [{
     The target construct includes a region of code which is to be executed
     on a device.
 
     The optional $if_expr parameter specifies a boolean result of a
     conditional check. If this value is 1 or is not provided then the target
     region runs on a device, if it is 0 then the target region is executed on the
     host device.
 
     The optional $device parameter specifies the device number for the target region.
 
     The optional $thread_limit specifies the limit on the number of threads
 
     The optional $nowait elliminates the implicit barrier so the parent task can make progress
     even if the target task is not yet completed.
 
     TODO:  map, is_device_ptr, depend, defaultmap, in_reduction
 
   }];
 
   let arguments = (ins Optional<I1>:$if_expr,
                        Optional<AnyInteger>:$device,
                        Optional<AnyInteger>:$thread_limit,
                        UnitAttr:$nowait);
 
   let regions = (region AnyRegion:$region);
 
   let assemblyFormat = [{
     oilist( `if` `(` $if_expr `)`
           | `device` `(` $device `:` type($device) `)`
           | `thread_limit` `(` $thread_limit `:` type($thread_limit) `)`
           | `nowait` $nowait
     ) $region attr-dict
   }];
 }
 
 
 //===----------------------------------------------------------------------===//
 // 2.16 master Construct
 //===----------------------------------------------------------------------===//
 def MasterOp : OpenMP_Op<"master"> {
   let summary = "master construct";
   let description = [{

mlir/test/Dialect/OpenMP/ops.mlir

func.func @omp_target(%if_cond : i1, %device : si32,  %num_threads : i32) -> () {
     }) {nowait, operand_segment_sizes = array<i32: 1,1,1>} : ( i1, si32, i32 ) -> ()
 
     // CHECK: omp.barrier
     omp.barrier
 
     return
 }
 
+// CHECK-LABEL: omp_target_data
+func.func @omp_target_data (%if_cond : i1, %device : si32,  %data1: memref<?xi32>, %data2: memref<?xi32>, %data3: memref<?xi32>) -> () {
+
+    // CHECK: omp.target_data if(%arg0) device(%arg1 : si32) use_device_ptr(%arg2 : memref<?xi32>) use_device_addr(%arg3 : memref<?xi32>) map( present, tofrom : %arg4 : memref<?xi32>) {
+    "omp.target_data"(%if_cond, %device, %data1, %data2, %data3) ({
+       // CHECK: omp.terminator
+       omp.terminator
+    }) {nowait, operand_segment_sizes = array<i32: 1,1,1,1,1>, map_type_modifier_val = #omp<maptypemodifier present>, map_type_val = #omp<maptype tofrom>} : ( i1, si32, memref<?xi32>, memref<?xi32>, memref<?xi32> ) -> ()
+
+    // CHECK: omp.target_enter_data if(%arg0) device(%arg1 : si32) nowait map( always,  to : %arg2 : memref<?xi32>)
+    "omp.target_enter_data"(%if_cond, %device, %data1)  {nowait, operand_segment_sizes = array<i32: 1,1,1>, map_type_modifier_val = #omp<maptypemodifier always>, map_type_val = #omp<maptype to>} : ( i1, si32, memref<?xi32> ) -> ()
+   
+    // CHECK: omp.target_exit_data if(%arg0) device(%arg1 : si32) nowait map( close,  from : %arg2 : memref<?xi32>)
+    "omp.target_exit_data"(%if_cond, %device, %data1)  {nowait, operand_segment_sizes = array<i32: 1,1,1>, map_type_modifier_val = #omp<maptypemodifier close>, map_type_val = #omp<maptype from>} : ( i1, si32, memref<?xi32> ) -> ()
+
+   return
+}
+
+
+
 // CHECK-LABEL: omp_target_pretty
 func.func @omp_target_pretty(%if_cond : i1, %device : si32,  %num_threads : i32) -> () {
     // CHECK: omp.target if({{.*}}) device({{.*}})
     omp.target if(%if_cond) device(%device : si32) {
       omp.terminator
     }
 
     // CHECK: omp.target if({{.*}}) device({{.*}}) nowait