[flang][openacc] Make sure the correct flags are set for symbol in acc declare

[clementval]

Summary

Flags were not correctly set for symbols appearing in the OpenACC declare
directive in module declaration part.

Also some missing flags for OpenACC are added. This makes the Flags enum

64 and then the implementation switch to std::bitset as defined in

flang/include/flang/Common/enum-set.h. Therefore, constexpr cannot be
used for set of flags in flang/lib/Semantics/resolve-directives.cpp.

[razvanlupusoru]

flang/lib/Semantics/resolve-directives.cpp

237

Should present be a data sharing attribute instead of data mapping attribute?

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

10 ↗

(On Diff #547012)

What should happen if you have another clause for the same variable?
aka another acc parallel region with copyin(c).

Seems a bit wrong to have this flag on the symbol unless it is in a declare clause.

[clementval]

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

10 ↗

(On Diff #547012)

You would have two attributes on the symbol.

[clementval]

flang/lib/Semantics/resolve-directives.cpp

237

I can move it. This set is only used to check multiple occurrences.

[clementval]

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

10 ↗

(On Diff #547012)

I'll update the code to add attribute for declare only (at least for now) as it makes more sense.

[razvanlupusoru]

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

10 ↗

(On Diff #547012)

I agree.

[clementval]

Address review comments

[razvanlupusoru]

Thank you!

[clementval]

clang-format

flang/include/flang/Semantics/symbol.h

ENUM_CLASS(Flag,
       EntryDummyArgument,
       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
-      AccCopy, AccCopyIn, AccCopyOut, AccCreate, AccDelete, AccPresent,
+      AccCopy, AccCopyIn, AccCopyOut, AccCreate, AccDelete, AccPresent, AccLink,
+      AccDeviceResident, AccDevicePtr,
+      // OpenACC declare
+      AccDeclare,
       // 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,

flang/lib/Semantics/resolve-directives.cpp

bool Pre(const parser::AccClause::Firstprivate &x) {
     return false;
   }
 
   bool Pre(const parser::AccClause::Device &x) {
     ResolveAccObjectList(x.v, Symbol::Flag::AccDevice);
     return false;
   }
 
+  bool Pre(const parser::AccClause::DeviceResident &x) {
+    ResolveAccObjectList(x.v, Symbol::Flag::AccDeviceResident);
+    return false;
+  }
+
+  bool Pre(const parser::AccClause::Deviceptr &x) {
+    ResolveAccObjectList(x.v, Symbol::Flag::AccDevicePtr);
+    return false;
+  }
+
+  bool Pre(const parser::AccClause::Link &x) {
+    ResolveAccObjectList(x.v, Symbol::Flag::AccLink);
+    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::Flags dataSharingAttributeFlags{Symbol::Flag::AccShared,
+      Symbol::Flag::AccPrivate, Symbol::Flag::AccFirstPrivate,
       Symbol::Flag::AccReduction};
 
-  static constexpr Symbol::Flags dataMappingAttributeFlags{
-      Symbol::Flag::AccCreate, Symbol::Flag::AccCopyIn,
-      Symbol::Flag::AccCopyOut, Symbol::Flag::AccDelete};
+  Symbol::Flags dataMappingAttributeFlags{Symbol::Flag::AccCreate,
+      Symbol::Flag::AccCopyIn, Symbol::Flag::AccCopyOut,
+      Symbol::Flag::AccDelete, Symbol::Flag::AccPresent};
 
-  static constexpr Symbol::Flags accFlagsRequireNewSymbol{
-      Symbol::Flag::AccPrivate, Symbol::Flag::AccFirstPrivate,
-      Symbol::Flag::AccReduction};
+  Symbol::Flags accFlagsRequireNewSymbol{Symbol::Flag::AccPrivate,
+      Symbol::Flag::AccFirstPrivate, Symbol::Flag::AccReduction};
 
-  static constexpr Symbol::Flags accDataMvtFlags{
+  Symbol::Flags accDataMvtFlags{
       Symbol::Flag::AccDevice, Symbol::Flag::AccHost, Symbol::Flag::AccSelf};
 
-  static constexpr Symbol::Flags accFlagsRequireMark{};
+  Symbol::Flags accFlagsRequireMark{Symbol::Flag::AccCreate,
+      Symbol::Flag::AccCopyIn, Symbol::Flag::AccCopy, Symbol::Flag::AccCopyOut,
+      Symbol::Flag::AccDevicePtr, Symbol::Flag::AccDeviceResident,
+      Symbol::Flag::AccLink, Symbol::Flag::AccPresent};
 
   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 &, bool parentScope = false);
   Symbol *ResolveAccCommonBlockName(const parser::Name *);
public:
   void SetAssociatedClause(const parser::OmpClause &c) {
     associatedClause = &c;
   }
   const parser::OmpClause *GetAssociatedClause() { return associatedClause; }
 
 private:
   std::int64_t GetAssociatedLoopLevelFromClauses(const parser::OmpClauseList &);
 
-  static constexpr Symbol::Flags dataSharingAttributeFlags{
-      Symbol::Flag::OmpShared, Symbol::Flag::OmpPrivate,
-      Symbol::Flag::OmpFirstPrivate, Symbol::Flag::OmpLastPrivate,
-      Symbol::Flag::OmpReduction, Symbol::Flag::OmpLinear};
-
-  static constexpr Symbol::Flags privateDataSharingAttributeFlags{
+  Symbol::Flags dataSharingAttributeFlags{Symbol::Flag::OmpShared,
       Symbol::Flag::OmpPrivate, Symbol::Flag::OmpFirstPrivate,
-      Symbol::Flag::OmpLastPrivate};
+      Symbol::Flag::OmpLastPrivate, Symbol::Flag::OmpReduction,
+      Symbol::Flag::OmpLinear};
+
+  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::OmpUseDeviceAddr};
+  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::OmpUseDeviceAddr};
 
-  static constexpr Symbol::Flags ompFlagsRequireMark{
+  Symbol::Flags ompFlagsRequireMark{
       Symbol::Flag::OmpThreadprivate, Symbol::Flag::OmpDeclareTarget};
 
-  static constexpr Symbol::Flags dataCopyingAttributeFlags{
+  Symbol::Flags dataCopyingAttributeFlags{
       Symbol::Flag::OmpCopyIn, Symbol::Flag::OmpCopyPrivate};
 
   std::vector<const parser::Name *> allocateNames_; // on one directive
   UnorderedSymbolSet privateDataSharingAttributeObjects_; // on one directive
   UnorderedSymbolSet stmtFunctionExprSymbols_;
   std::multimap<const parser::Label,
       std::pair<parser::CharBlock, std::optional<DirContext>>>
       sourceLabels_;
if (!name.symbol || !prev) {
     name.symbol = prev;
   }
   return DeclareOrMarkOtherAccessEntity(*prev, accFlag);
 }
 
 Symbol *AccAttributeVisitor::DeclareOrMarkOtherAccessEntity(
     Symbol &object, Symbol::Flag accFlag) {
   if (accFlagsRequireMark.test(accFlag)) {
+    if (GetContext().directive == llvm::acc::ACCD_declare) {
+      object.set(Symbol::Flag::AccDeclare);
       object.set(accFlag);
     }
+  }
   return &object;
 }
 
 static bool WithMultipleAppearancesAccException(
     const Symbol &symbol, Symbol::Flag flag) {
   return false; // Place holder
 }
 

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

+! RUN: %python %S/../test_symbols.py %s %flang_fc1 -fopenacc
+
+!DEF:/acc_declare_symbolsModule
+module acc_declare_symbols
+  !DEF: /acc_declare_symbols/a PUBLIC (AccCreate, AccDeclare) ObjectEntity REAL(4)
+  real a(100)
+  !$acc declare create(a)
+
+  !DEF:/acc_declare_symbols/b PUBLIC (AccCopyIn, AccDeclare) ObjectEntity REAL(4)
+  real b(20)
+  !$acc declare copyin(b)
+
+  !DEF:/acc_declare_symbols/c PUBLIC (AccDeviceResident, AccDeclare) ObjectEntity REAL(4)
+  real c(10)
+  !$acc declare device_resident(c)
+
+  !DEF:/acc_declare_symbols/d PUBLIC (AccLink, AccDeclare) ObjectEntity REAL(4)
+  real d(10)
+  !$acc declare link(d)
+
+end module