[Flang][OpenMP][Semantics] Add semantics checks to requires directive

[skatrak]

Summary

This patch adds semantics checks to make sure that compilation units containing
more than one requires directive are correct, as well as making sure that
they do not come after other constructs that are affected by this directive. It
also handles the atomic_default_mem_order clause by setting it in a rewrite
step as an explicit memory order associated to all atomic operations that don't
already specify it.

The directive resolution step and the symbol details for function- and module-
like PFT nodes are extended to accomodate the addition and propagation of
information about 'requires' directives contained inside. This enables
exporting 'requires' clauses to .mod files and accessing them through 'use'
Fortran statements.

Additionally, an issue parsing this directive is fixed, which makes sure that
the source location of the requires clauses is available at the time of
performing semantic checks for the purpose of error reporting.

[skatrak]

Implement atomic_default_mem_order clause support as semantic check, as
recommended in reviewer feedback for D147219.

[skatrak]

Rebase.

[kiranchandramohan]

Looks mostly fine.

We will probably want to store the information about the requires directive in modules. At the moment, I think, we only handle threadprivate directives in modules.

module moda
  !$omp requires atomic_default_mem_order(seq_cst)
end module moda

subroutine s
  use moda
  !$omp requires atomic_default_mem_order(relaxed)
end subroutine s

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

1130

Frontend initialization (here and elsewhere in the file) should be with braces.

[skatrak]

The directive resolution step and the symbol details for function- and module-
like PFT nodes are extended to accomodate the addition and propagation of
information about 'requires' directives contained inside. This enables
exporting 'requires' clauses to .mod files and accessing them through 'use'
Fortran statements.

[skatrak]

Rebase.

[skatrak]

Rebase to fix build error.

[skatrak]

Re-implement atomic_default_mem_order support to after name resolution, so that 'requires' information from modules is used. Create a new rewrite-directives pass to be executed after name resolution and before structure checks to do this.

[skatrak]

Ping for review!

[kiranchandramohan]

The patch has grown a bit since the last time I had a look. Would it be possible to split this into three for ease of review? 1 for the semantics without modules, 2 for the module changes, 3 for the pass.

This will help (1, 3) to go in fairly soon and to get review from others for (2).

[skatrak]

In D149337#4499100, @kiranchandramohan wrote:

The patch has grown a bit since the last time I had a look. Would it be possible to split this into three for ease of review? 1 for the semantics without modules, 2 for the module changes, 3 for the pass.

This will help (1, 3) to go in fairly soon and to get review from others for (2).

Thank you for the feedback. I'm now in the process of splitting this patch in a way that each patch makes sense on its own. I anticipate there will be 5 patches I'll create over the next few days:

1. Fix to the parser.
2. Semantics checks for REQUIRES constructs appearing after device constructs / atomic operations without mem_order.
3. Storing REQUIRES information in top-level symbols (prerequisite for the following patches).
4. Rewrite pass to set atomic_default_mem_order as the mem_order for atomic operations without it set.
5. Module support: Output into .mod files, updates to semantic checks and top-level symbols to extract/store REQUIRES information from USE statements.

I'll mark this patch as abandoned after those are created and the dependencies for child patches of this one are updated.

[skatrak]

Patch split into: D157710, D157722, D157983, D158096, D158168.

flang/lib/Parser/openmp-parsers.cpp

 
 // 2.8.2 Declare Simd construct
 TYPE_PARSER(
     sourced(construct<OpenMPDeclareSimdConstruct>(verbatim("DECLARE SIMD"_tok),
         maybe(parenthesized(name)), Parser<OmpClauseList>{})))
 
 // 2.4 Requires construct
 TYPE_PARSER(sourced(construct<OpenMPRequiresConstruct>(
-    verbatim("REQUIRES"_tok), some(Parser<OmpClause>{} / maybe(","_tok)))))
+    verbatim("REQUIRES"_tok), Parser<OmpClauseList>{})))
 
 // 2.15.2 Threadprivate directive
 TYPE_PARSER(sourced(construct<OpenMPThreadprivate>(
     verbatim("THREADPRIVATE"_tok), parenthesized(Parser<OmpObjectList>{}))))
 
 // 2.11.3 Declarative Allocate directive
 TYPE_PARSER(
     sourced(construct<OpenMPDeclarativeAllocate>(verbatim("ALLOCATE"_tok),

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

void CheckArraySection(const parser::ArrayElement &arrayElement,
       const parser::Name &name, const llvm::omp::Clause clause);
   void CheckSharedBindingInOuterContext(
       const parser::OmpObjectList &ompObjectList);
   const parser::OmpObjectList *GetOmpObjectList(const parser::OmpClause &);
   void CheckPredefinedAllocatorRestriction(const parser::CharBlock &source,
       const parser::OmpObjectList &ompObjectList);
   void CheckPredefinedAllocatorRestriction(
       const parser::CharBlock &source, const parser::Name &name);
+  void CheckAllowedRequiresClause(llvmOmpClause clause);
   bool isPredefinedAllocator{false};
   void EnterDirectiveNest(const int index) { directiveNest_[index]++; }
   void ExitDirectiveNest(const int index) { directiveNest_[index]--; }
   int GetDirectiveNest(const int index) { return directiveNest_[index]; }
   template <typename D> void CheckHintClause(D *, D *);
 
   enum directiveNestType {
     SIMDNest,
     TargetBlockOnlyTeams,
     TargetNest,
     LastType
   };
   int directiveNest_[LastType + 1] = {0};
+
+  bool deviceConstructFound = false;
+  bool atomicDirectiveDefaultOrderFound = false;
+  std::optional<Fortran::parser::OmpAtomicDefaultMemOrderClause::Type>
+      atomicDefaultMemoryOrder;
 };
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_

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

if (GetContext().directive == llvm::omp::Directive::OMPD_teams &&
           "directives outside of the TEAMS construct"_err_en_US);
     }
   }
 
   CheckNoBranching(block, beginDir.v, beginDir.source);
 
   switch (beginDir.v) {
   case llvm::omp::Directive::OMPD_target:
+    deviceConstructFound = true;
     if (CheckTargetBlockOnlyTeams(block)) {
       EnterDirectiveNest(TargetBlockOnlyTeams);
     }
     break;
   case llvm::omp::OMPD_workshare:
   case llvm::omp::OMPD_parallel_workshare:
     CheckWorkshareBlockStmts(block, beginDir.source);
     HasInvalidWorksharingNesting(
if (std::holds_alternative<parser::OmpDeclareTargetWithClause>(spec.u)) {
     SetClauseSets(llvm::omp::Directive::OMPD_declare_target);
   }
 }
 
 void OmpStructureChecker::Leave(const parser::OpenMPDeclareTargetConstruct &x) {
   const auto &dir{std::get<parser::Verbatim>(x.t)};
   const auto &spec{std::get<parser::OmpDeclareTargetSpecifier>(x.t)};
   if (const auto *objectList{parser::Unwrap<parser::OmpObjectList>(spec.u)}) {
+    deviceConstructFound = true;
     CheckIsVarPartOfAnotherVar(dir.source, *objectList);
     CheckThreadprivateOrDeclareTargetVar(*objectList);
   } else if (const auto *clauseList{
                  parser::Unwrap<parser::OmpClauseList>(spec.u)}) {
+    bool toClauseFound = false, deviceTypeClauseFound = false;
     for (const auto &clause : clauseList->v) {
-      if (const auto *toClause{std::get_if<parser::OmpClause::To>(&clause.u)}) {
-        CheckIsVarPartOfAnotherVar(dir.source, toClause->v);
-        CheckThreadprivateOrDeclareTargetVar(toClause->v);
-      } else if (const auto *linkClause{
-                     std::get_if<parser::OmpClause::Link>(&clause.u)}) {
-        CheckIsVarPartOfAnotherVar(dir.source, linkClause->v);
-        CheckThreadprivateOrDeclareTargetVar(linkClause->v);
+      common::visit(
+          common::visitors{
+              [&](const parser::OmpClause::To &toClause) {
+                CheckIsVarPartOfAnotherVar(dir.source, toClause.v);
+                CheckThreadprivateOrDeclareTargetVar(toClause.v);
+                toClauseFound = true;
+              },
+              [&](const parser::OmpClause::Link &linkClause) {
+                CheckIsVarPartOfAnotherVar(dir.source, linkClause.v);
+                CheckThreadprivateOrDeclareTargetVar(linkClause.v);
+              },
+              [&](const parser::OmpClause::DeviceType &deviceTypeClause) {
+                deviceTypeClauseFound = true;
+                if (deviceTypeClause.v.v !=
+                    parser::OmpDeviceTypeClause::Type::Host) {
+                  deviceConstructFound = true;
+                }
+              },
+              [&](const auto &) {},
+          },
+          clause.u);
+
+      if (toClauseFound && !deviceTypeClauseFound) {
+        deviceConstructFound = true;
       }
     }
   }
   dirContext_.pop_back();
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPExecutableAllocate &x) {
   isPredefinedAllocator = true;
auto checkForValidMemoryOrderClause =
         }
       };
   if (leftHandClauseList) {
     checkForValidMemoryOrderClause(leftHandClauseList);
   }
   if (rightHandClauseList) {
     checkForValidMemoryOrderClause(rightHandClauseList);
   }
+  if (numMemoryOrderClause == 0) {
+    atomicDirectiveDefaultOrderFound = true;
+  }
 }
 
 void OmpStructureChecker::Enter(const parser::OpenMPAtomicConstruct &x) {
   common::visit(
       common::visitors{
           [&](const parser::OmpAtomic &atomicConstruct) {
             const auto &dir{std::get<parser::Verbatim>(atomicConstruct.t)};
             PushContextAndClauseSets(

 
 void OmpStructureChecker::Enter(const parser::OmpClause &x) {
   SetContextClause(x);
 }
 
 // Following clauses do not have a separate node in parse-tree.h.
 CHECK_SIMPLE_CLAUSE(AcqRel, OMPC_acq_rel)
 CHECK_SIMPLE_CLAUSE(Acquire, OMPC_acquire)
-CHECK_SIMPLE_CLAUSE(AtomicDefaultMemOrder, OMPC_atomic_default_mem_order)
 CHECK_SIMPLE_CLAUSE(Affinity, OMPC_affinity)
 CHECK_SIMPLE_CLAUSE(Allocate, OMPC_allocate)
 CHECK_SIMPLE_CLAUSE(Capture, OMPC_capture)
 CHECK_SIMPLE_CLAUSE(Default, OMPC_default)
 CHECK_SIMPLE_CLAUSE(Depobj, OMPC_depobj)
 CHECK_SIMPLE_CLAUSE(Destroy, OMPC_destroy)
 CHECK_SIMPLE_CLAUSE(Detach, OMPC_detach)
 CHECK_SIMPLE_CLAUSE(DeviceType, OMPC_device_type)
 CHECK_SIMPLE_CLAUSE(DistSchedule, OMPC_dist_schedule)
-CHECK_SIMPLE_CLAUSE(DynamicAllocators, OMPC_dynamic_allocators)
 CHECK_SIMPLE_CLAUSE(Exclusive, OMPC_exclusive)
 CHECK_SIMPLE_CLAUSE(Final, OMPC_final)
 CHECK_SIMPLE_CLAUSE(Flush, OMPC_flush)
 CHECK_SIMPLE_CLAUSE(From, OMPC_from)
 CHECK_SIMPLE_CLAUSE(Full, OMPC_full)
 CHECK_SIMPLE_CLAUSE(Hint, OMPC_hint)
 CHECK_SIMPLE_CLAUSE(InReduction, OMPC_in_reduction)
 CHECK_SIMPLE_CLAUSE(Inclusive, OMPC_inclusive)
 CHECK_SIMPLE_CLAUSE(Match, OMPC_match)
 CHECK_SIMPLE_CLAUSE(Nontemporal, OMPC_nontemporal)
 CHECK_SIMPLE_CLAUSE(Order, OMPC_order)
 CHECK_SIMPLE_CLAUSE(Read, OMPC_read)
-CHECK_SIMPLE_CLAUSE(ReverseOffload, OMPC_reverse_offload)
 CHECK_SIMPLE_CLAUSE(Threadprivate, OMPC_threadprivate)
 CHECK_SIMPLE_CLAUSE(Threads, OMPC_threads)
 CHECK_SIMPLE_CLAUSE(Inbranch, OMPC_inbranch)
 CHECK_SIMPLE_CLAUSE(IsDevicePtr, OMPC_is_device_ptr)
 CHECK_SIMPLE_CLAUSE(HasDeviceAddr, OMPC_has_device_addr)
 CHECK_SIMPLE_CLAUSE(Link, OMPC_link)
 CHECK_SIMPLE_CLAUSE(Indirect, OMPC_indirect)
 CHECK_SIMPLE_CLAUSE(Mergeable, OMPC_mergeable)
 CHECK_SIMPLE_CLAUSE(Nogroup, OMPC_nogroup)
 CHECK_SIMPLE_CLAUSE(Notinbranch, OMPC_notinbranch)
 CHECK_SIMPLE_CLAUSE(Nowait, OMPC_nowait)
 CHECK_SIMPLE_CLAUSE(Partial, OMPC_partial)
 CHECK_SIMPLE_CLAUSE(ProcBind, OMPC_proc_bind)
 CHECK_SIMPLE_CLAUSE(Release, OMPC_release)
 CHECK_SIMPLE_CLAUSE(Relaxed, OMPC_relaxed)
 CHECK_SIMPLE_CLAUSE(SeqCst, OMPC_seq_cst)
 CHECK_SIMPLE_CLAUSE(Simd, OMPC_simd)
 CHECK_SIMPLE_CLAUSE(Sizes, OMPC_sizes)
 CHECK_SIMPLE_CLAUSE(TaskReduction, OMPC_task_reduction)
 CHECK_SIMPLE_CLAUSE(To, OMPC_to)
-CHECK_SIMPLE_CLAUSE(UnifiedAddress, OMPC_unified_address)
-CHECK_SIMPLE_CLAUSE(UnifiedSharedMemory, OMPC_unified_shared_memory)
 CHECK_SIMPLE_CLAUSE(Uniform, OMPC_uniform)
 CHECK_SIMPLE_CLAUSE(Unknown, OMPC_unknown)
 CHECK_SIMPLE_CLAUSE(Untied, OMPC_untied)
 CHECK_SIMPLE_CLAUSE(UseDevicePtr, OMPC_use_device_ptr)
 CHECK_SIMPLE_CLAUSE(UsesAllocators, OMPC_uses_allocators)
 CHECK_SIMPLE_CLAUSE(Update, OMPC_update)
 CHECK_SIMPLE_CLAUSE(UseDeviceAddr, OMPC_use_device_addr)
 CHECK_SIMPLE_CLAUSE(Write, OMPC_write)
return common::visit(
             } else {
               return nullptr;
             }
           },
       },
       clause.u);
 }
 
+void OmpStructureChecker::Enter(
+    const parser::OmpClause::AtomicDefaultMemOrder &x) {
+  CheckAllowed(llvm::omp::Clause::OMPC_atomic_default_mem_order);
+
+  // Check that multiple occurrences of this clause match
+  parser::OmpAtomicDefaultMemOrderClause::Type memOrder = x.v.v;
+  if (atomicDefaultMemoryOrder && atomicDefaultMemoryOrder != memOrder) {
+    context_.Say(GetContext().clauseSource,
+        "Conflicting '%s' REQUIRES clauses found in compilation "
+        "unit"_err_en_US,
+        parser::ToUpperCaseLetters(
+            getClauseName(llvmOmpClause::OMPC_atomic_default_mem_order).str()));
+    return;
+  }
+  atomicDefaultMemoryOrder = memOrder;
+  // Check that it does not appear after an atomic operation without
+  // memory_order defined
+  if (atomicDirectiveDefaultOrderFound) {
+    context_.Say(GetContext().clauseSource,
+        "'%s' REQUIRES clause found lexically after atomic "
+        "operation with the '%s' clause not defined"_err_en_US,
+        parser::ToUpperCaseLetters(
+            getClauseName(llvmOmpClause::OMPC_atomic_default_mem_order).str()),
+        parser::ToUpperCaseLetters(
+            getClauseName(llvmOmpClause::OMPC_memory_order).str()));
+  }
+}
+
+void OmpStructureChecker::Enter(const parser::OmpClause::DynamicAllocators &x) {
+  CheckAllowedRequiresClause(llvm::omp::Clause::OMPC_dynamic_allocators);
+}
+
+void OmpStructureChecker::Enter(const parser::OmpClause::ReverseOffload &x) {
+  CheckAllowedRequiresClause(llvm::omp::Clause::OMPC_reverse_offload);
+}
+
+void OmpStructureChecker::Enter(const parser::OmpClause::UnifiedAddress &x) {
+  CheckAllowedRequiresClause(llvm::omp::Clause::OMPC_unified_address);
+}
+
+void OmpStructureChecker::Enter(
+    const parser::OmpClause::UnifiedSharedMemory &x) {
+  CheckAllowedRequiresClause(llvm::omp::Clause::OMPC_unified_shared_memory);
+}
+
+void OmpStructureChecker::CheckAllowedRequiresClause(llvmOmpClause clause) {
+  CheckAllowed(clause);
+
+  // Check that it does not appear after a device construct
+  if (deviceConstructFound) {
+    context_.Say(GetContext().clauseSource,
+        "'%s' REQUIRES clause found lexically after device "
+        "construct"_err_en_US,
+        parser::ToUpperCaseLetters(getClauseName(clause).str()));
+  }
+}
+
 } // namespace Fortran::semantics

flang/test/Semantics/OpenMP/requires01.f90

+! RUN: %python %S/../test_errors.py %s %flang -fopenmp
+! OpenMP Version 5.0
+! 2.4 Requires directive
+! All atomic_default_mem_order clauses in 'requires' directives found within a
+! compilation unit must specify the same ordering.
+
+subroutine f
+  !$omp requires atomic_default_mem_order(seq_cst)
+end subroutine f
+
+subroutine g
+  !ERROR: Conflicting 'ATOMIC_DEFAULT_MEM_ORDER' REQUIRES clauses found in compilation unit
+  !$omp requires atomic_default_mem_order(relaxed)
+end subroutine g

flang/test/Semantics/OpenMP/requires02.f90

+! RUN: %python %S/../test_errors.py %s %flang -fopenmp
+! OpenMP Version 5.0
+! 2.4 Requires directive
+! All atomic_default_mem_order clauses in 'requires' directives must come
+! strictly before any atomic directives on which the memory_order clause is not
+! specified.
+
+subroutine f
+  integer :: a = 0
+  !$omp atomic
+  a = a + 1
+end subroutine f
+
+subroutine g
+  !ERROR: 'ATOMIC_DEFAULT_MEM_ORDER' REQUIRES clause found lexically after atomic operation with the 'MEMORY_ORDER' clause not defined
+  !$omp requires atomic_default_mem_order(relaxed)
+end subroutine g

flang/test/Semantics/OpenMP/requires03.f90

+! RUN: %python %S/../test_errors.py %s %flang -fopenmp
+! OpenMP Version 5.0
+! 2.4 Requires directive
+! Target-related clauses in 'requires' directives must come strictly before any
+! device constructs, such as target regions.
+
+subroutine f
+  !$omp target
+  !$omp end target
+end subroutine f
+
+subroutine g
+  !ERROR: 'DYNAMIC_ALLOCATORS' REQUIRES clause found lexically after device construct
+  !$omp requires dynamic_allocators
+  !ERROR: 'REVERSE_OFFLOAD' REQUIRES clause found lexically after device construct
+  !$omp requires reverse_offload
+  !ERROR: 'UNIFIED_ADDRESS' REQUIRES clause found lexically after device construct
+  !$omp requires unified_address
+  !ERROR: 'UNIFIED_SHARED_MEMORY' REQUIRES clause found lexically after device construct
+  !$omp requires unified_shared_memory
+end subroutine g

flang/test/Semantics/OpenMP/requires04.f90

+! RUN: %python %S/../test_errors.py %s %flang -fopenmp
+! OpenMP Version 5.0
+! 2.4 Requires directive
+! Target-related clauses in 'requires' directives must come strictly before any
+! device constructs, such as declare target with device_type=nohost|any.
+
+subroutine f
+  !$omp declare target device_type(nohost)
+end subroutine f
+
+subroutine g
+  !ERROR: 'DYNAMIC_ALLOCATORS' REQUIRES clause found lexically after device construct
+  !$omp requires dynamic_allocators
+  !ERROR: 'REVERSE_OFFLOAD' REQUIRES clause found lexically after device construct
+  !$omp requires reverse_offload
+  !ERROR: 'UNIFIED_ADDRESS' REQUIRES clause found lexically after device construct
+  !$omp requires unified_address
+  !ERROR: 'UNIFIED_SHARED_MEMORY' REQUIRES clause found lexically after device construct
+  !$omp requires unified_shared_memory
+end subroutine g

flang/test/Semantics/OpenMP/requires05.f90

+! RUN: %python %S/../test_errors.py %s %flang -fopenmp
+! OpenMP Version 5.0
+! 2.4 Requires directive
+! Target-related clauses in 'requires' directives must come strictly before any
+! device constructs, such as declare target with 'to' clause and no device_type.
+
+subroutine f
+  !$omp declare target to(f)
+end subroutine f
+
+subroutine g
+  !ERROR: 'DYNAMIC_ALLOCATORS' REQUIRES clause found lexically after device construct
+  !$omp requires dynamic_allocators
+  !ERROR: 'REVERSE_OFFLOAD' REQUIRES clause found lexically after device construct
+  !$omp requires reverse_offload
+  !ERROR: 'UNIFIED_ADDRESS' REQUIRES clause found lexically after device construct
+  !$omp requires unified_address
+  !ERROR: 'UNIFIED_SHARED_MEMORY' REQUIRES clause found lexically after device construct
+  !$omp requires unified_shared_memory
+end subroutine g

flang/test/Semantics/OpenMP/requires06.f90

+! RUN: %python %S/../test_errors.py %s %flang -fopenmp
+! OpenMP Version 5.0
+! 2.4 Requires directive
+! Target-related clauses in 'requires' directives must come strictly before any
+! device constructs, such as declare target with extended list.
+
+subroutine f
+  !$omp declare target (f)
+end subroutine f
+
+subroutine g
+  !ERROR: 'DYNAMIC_ALLOCATORS' REQUIRES clause found lexically after device construct
+  !$omp requires dynamic_allocators
+  !ERROR: 'REVERSE_OFFLOAD' REQUIRES clause found lexically after device construct
+  !$omp requires reverse_offload
+  !ERROR: 'UNIFIED_ADDRESS' REQUIRES clause found lexically after device construct
+  !$omp requires unified_address
+  !ERROR: 'UNIFIED_SHARED_MEMORY' REQUIRES clause found lexically after device construct
+  !$omp requires unified_shared_memory
+end subroutine g