[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

1165

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/canonicalize-omp.cpp

 // After Loop Canonicalization, rewrite OpenMP parse tree to make OpenMP
 // Constructs more structured which provide explicit scopes for later
 // structural checks and semantic analysis.
 //   1. move structured DoConstruct and OmpEndLoopDirective into
 //      OpenMPLoopConstruct. Compilation will not proceed in case of errors
 //      after this pass.
 //   2. Associate declarative OMP allocation directives with their
 //      respective executable allocation directive
-//   3. TBD
+//   3. set the default memory order, defined by any 'requires' directive
+//      present in the compilation unit, as explicit memory order of all atomic
+//      operations that don't already have it specified.
+//   4. TBD
 namespace Fortran::semantics {
 
 using namespace parser::literals;
 
 class CanonicalizationOfOmp {
 public:
   template <typename T> bool Pre(T &) { return true; }
   template <typename T> void Post(T &) {}
for (auto it{block.begin()}; it != block.end(); ++it) {
             "loop construct"_err_en_US,
             parser::ToUpperCaseLetters(dir.source.ToString()));
       }
     } // Block list
   }
 
   void Post(parser::ExecutionPart &body) { RewriteOmpAllocations(body); }
 
+  // Assume at this point that any such clauses appear only on 'requires'
+  // directives that are visited before any atomic operations, and that all
+  // instances (if present) specify the same ordering. Other semantic checks
+  // ensure that these restrictions are met.
+  void Post(parser::OmpClause::AtomicDefaultMemOrder &x) {
+    switch (x.v.v) {
+    case parser::OmpAtomicDefaultMemOrderClause::Type::AcqRel:
+      atomicDefaultMemOrder_ = llvm::omp::Clause::OMPC_acq_rel;
+      break;
+    case parser::OmpAtomicDefaultMemOrderClause::Type::Relaxed:
+      atomicDefaultMemOrder_ = llvm::omp::Clause::OMPC_relaxed;
+      break;
+    case parser::OmpAtomicDefaultMemOrderClause::Type::SeqCst:
+      atomicDefaultMemOrder_ = llvm::omp::Clause::OMPC_seq_cst;
+      break;
+    }
+  }
+
+  void Post(parser::OpenMPAtomicConstruct &atomic) { RewriteOmpAtomic(atomic); }
+
 private:
   template <typename T> T *GetConstructIf(parser::ExecutionPartConstruct &x) {
     if (auto *y{std::get_if<parser::ExecutableConstruct>(&x.u)}) {
       if (auto *z{std::get_if<common::Indirection<T>>(&y->u)}) {
         return &z->value();
       }
     }
     return nullptr;
for (auto it = body.v.rbegin(); it != body.v.rend();) {
         if (!subAllocates.empty()) {
           std::get<std::optional<std::list<parser::OpenMPDeclarativeAllocate>>>(
               exec->t) = {std::move(subAllocates)};
         }
       }
     }
   }
 
+  void RewriteOmpAtomic(parser::OpenMPAtomicConstruct &atomic) {
+    // Rewrite atomic constructs to add an explicit memory ordering to all
+    // that do not specify it, honoring in this way the
+    // `atomic_default_mem_order` clause of the 'requires' directive.
+    if (!atomicDefaultMemOrder_) {
+      return;
+    }
+
+    auto findMemOrderClause =
+        [](const std::list<parser::OmpAtomicClause> &clauses) {
+          return std::find_if(
+                     clauses.begin(), clauses.end(), [](const auto &clause) {
+                       return std::get_if<parser::OmpMemoryOrderClause>(
+                           &clause.u);
+                     }) != clauses.end();
+        };
+
+    // Get the clause list to which the new memory order clause must be added,
+    // only if there are no other memory order clauses present for this atomic
+    // directive.
+    auto *clauseList = common::visit(
+        common::visitors{
+            [&](parser::OmpAtomic &atomicConstruct) {
+              // OmpAtomic only has a single list of clauses.
+              auto &clauses =
+                  std::get<parser::OmpAtomicClauseList>(atomicConstruct.t);
+              return !findMemOrderClause(clauses.v) ? &clauses.v : nullptr;
+            },
+            [&](auto &atomicConstruct) {
+              // All other atomic constructs have two lists of clauses.
+              auto &clausesLhs = std::get<0>(atomicConstruct.t);
+              auto &clausesRhs = std::get<2>(atomicConstruct.t);
+              return !findMemOrderClause(clausesLhs.v) &&
+                      !findMemOrderClause(clausesRhs.v)
+                  ? &clausesRhs.v
+                  : nullptr;
+            }},
+        atomic.u);
+
+    if (clauseList) {
+      switch (*atomicDefaultMemOrder_) {
+      case llvm::omp::Clause::OMPC_acq_rel:
+        clauseList->push_back(parser::OmpMemoryOrderClause(
+            parser::OmpClause(parser::OmpClause::AcqRel())));
+        break;
+      case llvm::omp::Clause::OMPC_relaxed:
+        clauseList->push_back(parser::OmpMemoryOrderClause(
+            parser::OmpClause(parser::OmpClause::Relaxed())));
+        break;
+      case llvm::omp::Clause::OMPC_seq_cst:
+        clauseList->push_back(parser::OmpMemoryOrderClause(
+            parser::OmpClause(parser::OmpClause::SeqCst())));
+        break;
+      default:
+        llvm_unreachable("Unexpected clause used as memory ordering");
+        break;
+      }
+    }
+  }
+
   parser::Messages &messages_;
+  std::optional<llvm::omp::Clause> atomicDefaultMemOrder_;
 };
 
 bool CanonicalizeOmp(parser::Messages &messages, parser::Program &program) {
   CanonicalizationOfOmp omp{messages};
   Walk(program, omp);
   return !messages.AnyFatalError();
 }
 } // namespace Fortran::semantics

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(
common::visit(
         ompObject.u);
   }
 }
 
 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;
     CheckSymbolNames(dir.source, *objectList);
     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)}) {
-        CheckSymbolNames(dir.source, toClause->v);
-        CheckIsVarPartOfAnotherVar(dir.source, toClause->v);
-        CheckThreadprivateOrDeclareTargetVar(toClause->v);
-      } else if (const auto *linkClause{
-                     std::get_if<parser::OmpClause::Link>(&clause.u)}) {
-        CheckSymbolNames(dir.source, linkClause->v);
-        CheckIsVarPartOfAnotherVar(dir.source, linkClause->v);
-        CheckThreadprivateOrDeclareTargetVar(linkClause->v);
+      common::visit(
+          common::visitors{
+              [&](const parser::OmpClause::To &toClause) {
+                CheckSymbolNames(dir.source, toClause.v);
+                CheckIsVarPartOfAnotherVar(dir.source, toClause.v);
+                CheckThreadprivateOrDeclareTargetVar(toClause.v);
+                toClauseFound = true;
+              },
+              [&](const parser::OmpClause::Link &linkClause) {
+                CheckSymbolNames(dir.source, linkClause.v);
+                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/requires-rewrite.f90

+! RUN: %flang_fc1 -fopenmp -fdebug-dump-parse-tree %s 2>&1 | FileCheck %s
+! Ensure that requires atomic_default_mem_order is used to update atomic
+! operations with no explicit memory order set.
+program requires
+  !$omp requires atomic_default_mem_order(seq_cst)
+  implicit none
+  integer :: i, j, k
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomic
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomic
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  !$omp atomic
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicUpdate
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed update
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicUpdate
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic update relaxed
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicUpdate
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  !$omp atomic update
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicCapture
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed capture
+  i = j
+  j = k
+  !$omp end atomic
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicCapture
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic capture relaxed
+  i = j
+  j = k
+  !$omp end atomic
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicCapture
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  !$omp atomic capture
+  i = j
+  j = k
+  !$omp end atomic
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicWrite
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed write
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicWrite
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic write relaxed
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicWrite
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  !$omp atomic write
+  i = j
+end program requires

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