[OpenMP][Flang][Semantics] Add semantics support for USE_DEVICE_ADDR clause on OMP TARGET DATA directive.

[raghavendhra]

Rebasing the patch.

[raghavendhra]

Rebase

[clementval]

flang/test/Semantics/OpenMP/use_device_ptr.f90

15

This change seems related to use_device_ptr

[raghavendhra]

flang/test/Semantics/OpenMP/use_device_ptr.f90

15

Yes, I missed this additional check in previous commit so adding it here. Is that okay?

[clementval]

flang/lib/Semantics/resolve-directives.cpp

520

What is the plan here? I mean do you plan to use these flags in the lowering somehow or do you just replicate what was done for other clauses?

flang/test/Semantics/OpenMP/use_device_ptr.f90

15

It might be better to do it in a separate patch since it is unrelated to this one.

[raghavendhra]

flang/lib/Semantics/resolve-directives.cpp

520

I added UseDeviceAddr flag because of the following description from OpenMP 5.1 spec

"If a list item that appears in a use_device_addr clause has corresponding storage in the device data environment, references to the list item in the associated structured block are converted into references to the corresponding list item"

Plan is to have UseDeviceAddr flag set so that we can use it in lowering. Also, replicating the behavior of private clause.

[raghavendhra]

Removed changes to use_device_ptr.f90 test and will submit that as separate patch

[kiranchandramohan]

LG.

[raghavendhra]

Rebase before commit.

flang/docs/OpenMP-semantics.md

<table>
    </td>
    <td>Yes
    </td>
    <td>New Symbol
    </td>
    <td>OmpUseDevicePtr
    </td>
   </tr>
+  <tr>
+   <td>use_device_addr
+   </td>
+   <td>Yes
+   </td>
+   <td>New Symbol
+   </td>
+   <td>OmpUseDeviceAddr
+   </td>
+  </tr>
 </table>
 
 To determine the right data-sharing attribute,
 OpenMP defines that the data-sharing attributes
 of variables that are referenced in a construct can be
 _predetermined_, _explicitly determined_, or _implicitly determined_.
 
 #### Predetermined data-sharing attributes

 of the variable.
 No `Symbol` or `Scope` will be created.
 
 However, there are some exceptions for this, Pointers that appear in a
 use_device_ptr clause are privatized and the device pointers to the
 corresponding list items in the device data environment are assigned into the
 private versions so it is best to follow the representation for privatised
 variables i.e represent them with a new Symbol and `OmpUseDevicePtr` flag.
+If a list item that appears in a use_device_addr clause has corresponding
+storage in the device data environment, references to the list item in the
+associated structured block are converted into references to the corresponding
+list item so following the same i.e. represent them with a new Symbol and
+`OmpUseDeviceAddr` flag.
 
 The basic steps to determine the data-mapping attribute are:
 
 1. If _map_ clause is present,
 the data-mapping attribute is determined by the _map-type_
 on the clause and its corresponding `Flag` are listed below:
 
 <table>

flang/include/flang/Semantics/symbol.h

ENUM_CLASS(Flag,
       // OpenACC data-mapping attribute
       AccCopyIn, AccCopyOut, AccCreate, AccDelete, AccPresent,
       // OpenACC miscellaneous flags
       AccCommonBlock, AccThreadPrivate, AccReduction, AccNone, AccPreDetermined,
       // OpenMP data-sharing attribute
       OmpShared, OmpPrivate, OmpLinear, OmpFirstPrivate, OmpLastPrivate,
       // OpenMP data-mapping attribute
       OmpMapTo, OmpMapFrom, OmpMapAlloc, OmpMapRelease, OmpMapDelete,
-      OmpUseDevicePtr,
+      OmpUseDevicePtr, OmpUseDeviceAddr,
       // OpenMP data-copying attribute
       OmpCopyIn, OmpCopyPrivate,
       // OpenMP miscellaneous flags
       OmpCommonBlock, OmpReduction, OmpAligned, OmpNontemporal, OmpAllocate,
       OmpDeclarativeAllocateDirective, OmpExecutableAllocateDirective,
       OmpDeclareSimd, OmpDeclareTarget, OmpThreadprivate, OmpDeclareReduction,
       OmpFlushed, OmpCriticalLock, OmpIfSpecified, OmpNone, OmpPreDetermined);
   using Flags = common::EnumSet<Flag, Flag_enumSize>;

flang/lib/Parser/openmp-parsers.cpp

"SIZES" >> construct<OmpClause>(construct<OmpClause::Sizes>(
                    parenthesized(nonemptyList(scalarIntExpr)))) ||
     "THREADS" >> construct<OmpClause>(construct<OmpClause::Threads>()) ||
     "THREAD_LIMIT" >> construct<OmpClause>(construct<OmpClause::ThreadLimit>(
                           parenthesized(scalarIntExpr))) ||
     "TO" >> construct<OmpClause>(construct<OmpClause::To>(
                 parenthesized(Parser<OmpObjectList>{}))) ||
     "USE_DEVICE_PTR" >> construct<OmpClause>(construct<OmpClause::UseDevicePtr>(
                             parenthesized(Parser<OmpObjectList>{}))) ||
+    "USE_DEVICE_ADDR" >>
+        construct<OmpClause>(construct<OmpClause::UseDeviceAddr>(
+            parenthesized(Parser<OmpObjectList>{}))) ||
     "UNIFIED_ADDRESS" >>
         construct<OmpClause>(construct<OmpClause::UnifiedAddress>()) ||
     "UNIFIED_SHARED_MEMORY" >>
         construct<OmpClause>(construct<OmpClause::UnifiedSharedMemory>()) ||
     "UNIFORM" >> construct<OmpClause>(construct<OmpClause::Uniform>(
                      parenthesized(nonemptyList(name)))) ||
     "UNTIED" >> construct<OmpClause>(construct<OmpClause::Untied>()))
 

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

for (auto it{block.begin()}; it != block.end(); ++it) {
     }
   }
 }
 
 const parser::OmpObjectList *OmpStructureChecker::GetOmpObjectList(
     const parser::OmpClause &clause) {
 
   // Clauses with OmpObjectList as its data member
-  using MemberObjectListClauses =
-      std::tuple<parser::OmpClause::Copyprivate, parser::OmpClause::Copyin,
-          parser::OmpClause::Firstprivate, parser::OmpClause::From,
-          parser::OmpClause::Lastprivate, parser::OmpClause::Link,
-          parser::OmpClause::Private, parser::OmpClause::Shared,
-          parser::OmpClause::To, parser::OmpClause::UseDevicePtr>;
+  using MemberObjectListClauses = std::tuple<parser::OmpClause::Copyprivate,
+      parser::OmpClause::Copyin, parser::OmpClause::Firstprivate,
+      parser::OmpClause::From, parser::OmpClause::Lastprivate,
+      parser::OmpClause::Link, parser::OmpClause::Private,
+      parser::OmpClause::Shared, parser::OmpClause::To,
+      parser::OmpClause::UseDevicePtr, parser::OmpClause::UseDeviceAddr>;
 
   // Clauses with OmpObjectList in the tuple
   using TupleObjectListClauses = std::tuple<parser::OmpClause::Allocate,
       parser::OmpClause::Map, parser::OmpClause::Reduction>;
 
   // TODO:: Generate the tuples using TableGen.
   // Handle other constructs with OmpObjectList such as OpenMPThreadprivate.
   return common::visit(

flang/lib/Semantics/resolve-directives.cpp

bool Pre(const parser::OmpDependClause &x) {
     return false;
   }
 
   bool Pre(const parser::OmpClause::UseDevicePtr &x) {
     ResolveOmpObjectList(x.v, Symbol::Flag::OmpUseDevicePtr);
     return false;
   }
 
+  bool Pre(const parser::OmpClause::UseDeviceAddr &x) {
+    ResolveOmpObjectList(x.v, Symbol::Flag::OmpUseDeviceAddr);
+    return false;
+  }
+
   void Post(const parser::Name &);
 
   // Keep track of labels in the statements that causes jumps to target labels
   void Post(const parser::GotoStmt &gotoStmt) { CheckSourceLabel(gotoStmt.v); }
   void Post(const parser::ComputedGotoStmt &computedGotoStmt) {
     for (auto &label : std::get<std::list<parser::Label>>(computedGotoStmt.t)) {
       CheckSourceLabel(label);
     }
private:
   static constexpr Symbol::Flags privateDataSharingAttributeFlags{
       Symbol::Flag::OmpPrivate, Symbol::Flag::OmpFirstPrivate,
       Symbol::Flag::OmpLastPrivate};
 
   static constexpr Symbol::Flags ompFlagsRequireNewSymbol{
       Symbol::Flag::OmpPrivate, Symbol::Flag::OmpLinear,
       Symbol::Flag::OmpFirstPrivate, Symbol::Flag::OmpLastPrivate,
       Symbol::Flag::OmpReduction, Symbol::Flag::OmpCriticalLock,
-      Symbol::Flag::OmpCopyIn, Symbol::Flag::OmpUseDevicePtr};
+      Symbol::Flag::OmpCopyIn, Symbol::Flag::OmpUseDevicePtr,
+      Symbol::Flag::OmpUseDeviceAddr};
 
   static constexpr Symbol::Flags ompFlagsRequireMark{
       Symbol::Flag::OmpThreadprivate};
 
   static constexpr Symbol::Flags dataCopyingAttributeFlags{
       Symbol::Flag::OmpCopyIn, Symbol::Flag::OmpCopyPrivate};
 
   std::vector<const parser::Name *> allocateNames_; // on one directive

flang/test/Semantics/OpenMP/use_device_addr.f90

+! RUN: %flang -fc1 -fopenmp -fdebug-dump-symbols %s | FileCheck %s
+! OpenMP Version 5.1
+! 2.14.2 use_device_addr clause
+! List item that appears in a use_device_addr clause has corresponding storage
+! in the device data environment, references to the list item in the associated
+! structured block are converted into references to the corresponding list item.
+
+subroutine omp_target_data
+   integer :: a(1024)
+   !CHECK: b, TARGET size=4096 offset=4096: ObjectEntity type: INTEGER(4) shape: 1_8:1024_8
+   integer, target :: b(1024)
+   a = 1
+   !$omp target data map(tofrom: a) use_device_addr(b)
+   !CHECK: b (OmpUseDeviceAddr): HostAssoc
+      b = a
+   !$omp end target data
+end subroutine omp_target_data

flang/test/Semantics/OpenMP/use_device_ptr.f90

 ! RUN: %flang -fc1 -fopenmp -fdebug-dump-symbols %s | FileCheck %s
 ! OpenMP Version 5.0
 ! 2.10.1 use_device_ptr clause
 ! List items that appear in a use_device_ptr clause are converted into device
 ! pointers to the corresponding list item in the device data environment.
 
 subroutine omp_target_data
    use iso_c_binding
    integer :: a(1024)
    !CHECK: b size=8 offset=4096: ObjectEntity type: TYPE(c_ptr)
    type(C_PTR) :: b
    integer, pointer :: arrayB
    a = 1
    !$omp target data map(tofrom: a, arrayB) use_device_ptr(b)
-   !CHECK: b (OmpUseDevicePtr)
+   !CHECK: b (OmpUseDevicePtr): HostAssoc
       allocate(arrayB)
       call c_f_pointer(b, arrayB)
       a = arrayB
    !$omp end target data
 end subroutine omp_target_data
 

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

 def OMPC_UsesAllocators : Clause<"uses_allocators"> {
   let clangClass = "OMPUsesAllocatorsClause";
 }
 def OMPC_Affinity : Clause<"affinity"> {
   let clangClass = "OMPAffinityClause";
 }
 def OMPC_UseDeviceAddr : Clause<"use_device_addr"> {
   let clangClass = "OMPUseDeviceAddrClause";
+  let flangClass = "OmpObjectList";
 }
 def OMPC_Uniform : Clause<"uniform"> {
   let flangClass = "Name";
   let isValueList = true;
 }
 def OMPC_Match : Clause<"match"> {}
 def OMPC_AdjustArgs : Clause<"adjust_args"> { }
 def OMPC_AppendArgs : Clause<"append_args"> { }