[flang][openacc] Resolve symbol in device, host and self clause

[clementval]

Summary

Some symbols were not resolved in the device, host and self clause
resulting in an Internal: no symbol found error.

This patch adds symbol resolution for these clauses.

[razvanlupusoru]

Solution looks great.

flang/include/flang/Semantics/symbol.h

ENUM_CLASS(Flag,
       CompilerCreated, // A compiler created symbol
       // For compiler created symbols that are constant but cannot legally have
       // the PARAMETER attribute.
       ReadOnly,
       // OpenACC data-sharing attribute
       AccPrivate, AccFirstPrivate, AccShared,
       // OpenACC data-mapping attribute
       AccCopyIn, AccCopyOut, AccCreate, AccDelete, AccPresent,
+      // OpenACC data-movement attribute
+      AccDevice, AccHost, AccSelf,
       // 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, OmpUseDeviceAddr,
       // OpenMP data-copying attribute

flang/lib/Semantics/resolve-directives.cpp

bool Pre(const parser::AccClause::Private &x) {
     ResolveAccObjectList(x.v, Symbol::Flag::AccPrivate);
     return false;
   }
   bool Pre(const parser::AccClause::Firstprivate &x) {
     ResolveAccObjectList(x.v, Symbol::Flag::AccFirstPrivate);
     return false;
   }
 
+  bool Pre(const parser::AccClause::Device &x) {
+    ResolveAccObjectList(x.v, Symbol::Flag::AccDevice);
+    return false;
+  }
+
+  bool Pre(const parser::AccClause::Host &x) {
+    ResolveAccObjectList(x.v, Symbol::Flag::AccHost);
+    return false;
+  }
+
+  bool Pre(const parser::AccClause::Self &x) {
+    const std::optional<parser::AccSelfClause> &accSelfClause = x.v;
+    if (accSelfClause &&
+        std::holds_alternative<parser::AccObjectList>((*accSelfClause).u)) {
+      const auto &accObjectList =
+          std::get<parser::AccObjectList>((*accSelfClause).u);
+      ResolveAccObjectList(accObjectList, Symbol::Flag::AccSelf);
+    }
+    return false;
+  }
+
   void Post(const parser::Name &);
 
 private:
   std::int64_t GetAssociatedLoopLevelFromClauses(const parser::AccClauseList &);
 
   static constexpr Symbol::Flags dataSharingAttributeFlags{
       Symbol::Flag::AccShared, Symbol::Flag::AccPrivate,
       Symbol::Flag::AccPresent, Symbol::Flag::AccFirstPrivate,
       Symbol::Flag::AccReduction};
 
   static constexpr Symbol::Flags dataMappingAttributeFlags{
       Symbol::Flag::AccCreate, Symbol::Flag::AccCopyIn,
       Symbol::Flag::AccCopyOut, Symbol::Flag::AccDelete};
 
   static constexpr Symbol::Flags accFlagsRequireNewSymbol{
       Symbol::Flag::AccPrivate, Symbol::Flag::AccFirstPrivate,
       Symbol::Flag::AccReduction};
 
+  static constexpr Symbol::Flags accDataMvtFlags{
+      Symbol::Flag::AccDevice, Symbol::Flag::AccHost, Symbol::Flag::AccSelf};
+
   static constexpr Symbol::Flags accFlagsRequireMark{};
 
   void PrivatizeAssociatedLoopIndex(const parser::OpenACCLoopConstruct &);
   void ResolveAccObjectList(const parser::AccObjectList &, Symbol::Flag);
   void ResolveAccObject(const parser::AccObject &, Symbol::Flag);
   Symbol *ResolveAcc(const parser::Name &, Symbol::Flag, Scope &);
   Symbol *ResolveAcc(Symbol &, Symbol::Flag, Scope &);
   Symbol *ResolveName(const parser::Name &);

flang/test/Semantics/OpenACC/acc-parallel-loop-validity.f90

program openacc_parallel_loop_validity
   end do
 
   !$acc parallel loop self
   do i = 1, N
     a(i) = 3.14
   end do
 
   !ERROR: SELF clause on the PARALLEL LOOP directive only accepts optional scalar logical expression
-  !$acc parallel loop self(bb, cc(:))
+  !$acc parallel loop self(bb, cc(:,:))
   do i = 1, N
     a(i) = 3.14
   end do
 
   !$acc parallel loop self(.true.)
   do i = 1, N
     a(i) = 3.14
   end do

flang/test/Semantics/OpenACC/acc-resolve04.f90

+! RUN: %flang_fc1 -fopenacc %s
+
+! Check that symbol are correctly resolved in device, host and self clause.
+
+program test_resolve04
+  real :: a(10), b(10)
+  common /foo/ b, c
+
+!$acc data create(/foo/)
+!$acc update device(/foo/)
+!$acc update host(/foo/)
+!$acc update self(/foo/)
+!$acc end data
+
+end
+

flang/test/Semantics/OpenACC/acc-update-validity.f90

program openacc_update_validity
 
   !$acc update host(aa) async(1)
 
   !$acc update device(bb) async(async1)
 
   !ERROR: At most one ASYNC clause can appear on the UPDATE directive
   !$acc update host(aa, bb) async(1) async(2)
 
-  !$acc update self(bb, cc(:)) wait(1)
+  !$acc update self(bb, cc(:,:)) wait(1)
 
   !ERROR: SELF clause on the UPDATE directive must have a var-list
   !$acc update self
 
   !$acc update device(aa, bb, cc) wait(wait1)
 
   !$acc update host(aa) host(bb) device(cc) wait(1,2)