[Flang][OpenMP][Sema] Add directive rewrite pass to support atomic_default_mem_order REQUIRES clause

[skatrak]

Summary

This patch creates the OmpRewriteMutator pass that runs at the end of RewriteParseTree(). This pass is intended to make OpenMP-specific mutations to the PFT after name resolution.

In the case of the atomic_default_mem_order clause of the REQUIRES directive, name resolution results in populating global symbols with information about the REQUIRES clauses that apply to that scope. The new rewrite pass is then able to use this information in order to explicitly set the memory order of ATOMIC constructs for which that is not already specified.

Given that this rewrite happens before semantics checks, the check of the order in which ATOMIC constructs without explicit memory order and REQUIRES directives with atomic_default_mem_order appear is moved earlier into the rewrite pass. Otherwise, these problems would not be caught by semantics checks, since the PFT would be modified by that stage.

This is patch 4/5 of a series splitting D149337 to simplify review.

Depends on D157983.

[skatrak]

Rebase, fix handling of acq_rel clause to match standard and complete unit tests. Ping for review!

[kiranchandramohan]

Looks OK to me. Three questions/comments inline.

flang/lib/Semantics/rewrite-directives.cpp

22

Is this class of use currently?

158–161

We could alternatively handle everything here by looking for the variant (AtomicDefaultMemOrder) in clause.u. This way we do not have to save the clause source.

181

Why can't we directly invoke the following way?

parser::Walk(program, OmpRewriteMutator);

[skatrak]

Address review comments.

[skatrak]

Thank you Kiran for the review! I hope these changes address most of your concerns.

flang/lib/Semantics/rewrite-directives.cpp

22

It could be removed without much issue. The idea with it was to simplify creating an AccRewriteMutator later on, if needed, just as it's done for the {Omp,Acc}AttributeVisitor in resolve-directives.cpp. Let me know if it's best to only add it when actually needed and I'll remove it.

158–161

Thank you for the suggestion, it does look cleaner that way.

181

Done.

[kiranchandramohan]

LGTM.

flang/lib/Semantics/rewrite-directives.cpp

22

OK. you can retain for now.

43

Nit: Is this Walk function used now?

[skatrak]

Address nit comments and replace leftover initialization parentheses for braces. Will merge this patch tomorrow, unless there are any further comments.

flang/lib/Semantics/rewrite-directives.cpp

43

It's not. Good catch, thank you!

flang/lib/Semantics/CMakeLists.txt

add_flang_library(FortranSemantics
   expression.cpp
   mod-file.cpp
   pointer-assignment.cpp
   program-tree.cpp
   resolve-labels.cpp
   resolve-directives.cpp
   resolve-names-utils.cpp
   resolve-names.cpp
+  rewrite-directives.cpp
   rewrite-parse-tree.cpp
   runtime-type-info.cpp
   scope.cpp
   semantics.cpp
   symbol.cpp
   tools.cpp
   type.cpp
   unparse-with-symbols.cpp

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

private:
   void CheckPredefinedAllocatorRestriction(const parser::CharBlock &source,
       const parser::OmpObjectList &ompObjectList);
   void CheckPredefinedAllocatorRestriction(
       const parser::CharBlock &source, const parser::Name &name);
   bool isPredefinedAllocator{false};
 
   void CheckAllowedRequiresClause(llvmOmpClause clause);
   bool deviceConstructFound_{false};
-  bool atomicDirectiveDefaultOrderFound_{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 *);
   inline void ErrIfAllocatableVariable(const parser::Variable &);
   inline void ErrIfLHSAndRHSSymbolsMatch(
       const parser::Variable &, const parser::Expr &);

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

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::UnifiedSharedMemory &x) {
   CheckAllowedRequiresClause(llvm::omp::Clause::OMPC_unified_shared_memory);
 }
 
 void OmpStructureChecker::CheckAllowedRequiresClause(llvmOmpClause clause) {
   CheckAllowed(clause);
 
-  if (clause == llvm::omp::Clause::OMPC_atomic_default_mem_order) {
-    // Check that it does not appear after an atomic operation without memory
-    // order
-    if (atomicDirectiveDefaultOrderFound_) {
-      context_.Say(GetContext().clauseSource,
-          "REQUIRES directive with '%s' clause found lexically after atomic "
-          "operation without a memory order clause"_err_en_US,
-          parser::ToUpperCaseLetters(getClauseName(clause).str()));
-    }
-  } else {
+  if (clause != llvm::omp::Clause::OMPC_atomic_default_mem_order) {
     // Check that it does not appear after a device construct
     if (deviceConstructFound_) {
       context_.Say(GetContext().clauseSource,
           "REQUIRES directive with '%s' clause found lexically after device "
           "construct"_err_en_US,
           parser::ToUpperCaseLetters(getClauseName(clause).str()));
     }
   }
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/rewrite-directives.h

+//===-- lib/Semantics/rewrite-directives.h ----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_SEMANTICS_REWRITE_DIRECTIVES_H_
+#define FORTRAN_SEMANTICS_REWRITE_DIRECTIVES_H_
+
+namespace Fortran::parser {
+struct Program;
+} // namespace Fortran::parser
+
+namespace Fortran::semantics {
+class SemanticsContext;
+} // namespace Fortran::semantics
+
+namespace Fortran::semantics {
+bool RewriteOmpParts(SemanticsContext &, parser::Program &);
+} // namespace Fortran::semantics
+
+#endif // FORTRAN_SEMANTICS_REWRITE_DIRECTIVES_H_

flang/lib/Semantics/rewrite-directives.cpp

+//===-- lib/Semantics/rewrite-directives.cpp ------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "rewrite-directives.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Parser/parse-tree.h"
+#include "flang/Semantics/semantics.h"
+#include "flang/Semantics/symbol.h"
+#include "llvm/Frontend/OpenMP/OMP.h.inc"
+#include <list>
+
+namespace Fortran::semantics {
+
+using namespace parser::literals;
+
+class DirectiveRewriteMutator {
+public:
+  explicit DirectiveRewriteMutator(SemanticsContext &context)
+      : context_{context} {}
+
+  // Default action for a parse tree node is to visit children.
+  template <typename T> bool Pre(T &) { return true; }
+  template <typename T> void Post(T &) {}
+
+protected:
+  SemanticsContext &context_;
+};
+
+// 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.
+class OmpRewriteMutator : public DirectiveRewriteMutator {
+public:
+  explicit OmpRewriteMutator(SemanticsContext &context)
+      : DirectiveRewriteMutator(context) {}
+
+  template <typename T> bool Pre(T &) { return true; }
+  template <typename T> void Post(T &) {}
+
+  bool Pre(parser::OpenMPAtomicConstruct &);
+  bool Pre(parser::OpenMPRequiresConstruct &);
+
+private:
+  bool atomicDirectiveDefaultOrderFound_{false};
+};
+
+bool OmpRewriteMutator::Pre(parser::OpenMPAtomicConstruct &x) {
+  // Find top-level parent of the operation.
+  Symbol *topLevelParent{common::visit(
+      [&](auto &atomic) {
+        Symbol *symbol{nullptr};
+        Scope *scope{
+            &context_.FindScope(std::get<parser::Verbatim>(atomic.t).source)};
+        do {
+          if (Symbol * parent{scope->symbol()}) {
+            symbol = parent;
+          }
+          scope = &scope->parent();
+        } while (!scope->IsGlobal());
+
+        assert(symbol &&
+            "Atomic construct must be within a scope associated with a symbol");
+        return symbol;
+      },
+      x.u)};
+
+  // Get the `atomic_default_mem_order` clause from the top-level parent.
+  std::optional<common::OmpAtomicDefaultMemOrderType> defaultMemOrder;
+  common::visit(
+      [&](auto &details) {
+        if constexpr (std::is_convertible_v<decltype(&details),
+                          WithOmpDeclarative *>) {
+          if (details.has_ompAtomicDefaultMemOrder()) {
+            defaultMemOrder = *details.ompAtomicDefaultMemOrder();
+          }
+        }
+      },
+      topLevelParent->details());
+
+  if (!defaultMemOrder) {
+    return false;
+  }
+
+  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.
+  std::list<parser::OmpAtomicClause> *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;
+          }},
+      x.u);
+
+  // Add a memory order clause to the atomic directive.
+  if (clauseList) {
+    atomicDirectiveDefaultOrderFound_ = true;
+    switch (*defaultMemOrder) {
+    case common::OmpAtomicDefaultMemOrderType::AcqRel:
+      clauseList->emplace_back<parser::OmpMemoryOrderClause>(common::visit(
+          common::visitors{[](parser::OmpAtomicRead &) -> parser::OmpClause {
+                             return parser::OmpClause::Acquire{};
+                           },
+              [](parser::OmpAtomicCapture &) -> parser::OmpClause {
+                return parser::OmpClause::AcqRel{};
+              },
+              [](auto &) -> parser::OmpClause {
+                // parser::{OmpAtomic, OmpAtomicUpdate, OmpAtomicWrite}
+                return parser::OmpClause::Release{};
+              }},
+          x.u));
+      break;
+    case common::OmpAtomicDefaultMemOrderType::Relaxed:
+      clauseList->emplace_back<parser::OmpMemoryOrderClause>(
+          parser::OmpClause{parser::OmpClause::Relaxed{}});
+      break;
+    case common::OmpAtomicDefaultMemOrderType::SeqCst:
+      clauseList->emplace_back<parser::OmpMemoryOrderClause>(
+          parser::OmpClause{parser::OmpClause::SeqCst{}});
+      break;
+    }
+  }
+
+  return false;
+}
+
+bool OmpRewriteMutator::Pre(parser::OpenMPRequiresConstruct &x) {
+  for (parser::OmpClause &clause : std::get<parser::OmpClauseList>(x.t).v) {
+    if (std::holds_alternative<parser::OmpClause::AtomicDefaultMemOrder>(
+            clause.u) &&
+        atomicDirectiveDefaultOrderFound_) {
+      context_.Say(clause.source,
+          "REQUIRES directive with '%s' clause found lexically after atomic "
+          "operation without a memory order clause"_err_en_US,
+          parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(
+              llvm::omp::OMPC_atomic_default_mem_order)
+                                         .str()));
+    }
+  }
+  return false;
+}
+
+bool RewriteOmpParts(SemanticsContext &context, parser::Program &program) {
+  if (!context.IsEnabled(common::LanguageFeature::OpenMP)) {
+    return true;
+  }
+  OmpRewriteMutator ompMutator{context};
+  parser::Walk(program, ompMutator);
+  return !context.AnyFatalError();
+}
+
+} // namespace Fortran::semantics

flang/lib/Semantics/rewrite-parse-tree.cpp

 //===-- lib/Semantics/rewrite-parse-tree.cpp ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "rewrite-parse-tree.h"
+#include "rewrite-directives.h"
 #include "flang/Common/indirection.h"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Parser/tools.h"
 #include "flang/Semantics/scope.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/symbol.h"
 #include "flang/Semantics/tools.h"

 
 void RewriteMutator::Post(parser::WriteStmt &x) {
   FixMisparsedUntaggedNamelistName(x);
 }
 
 bool RewriteParseTree(SemanticsContext &context, parser::Program &program) {
   RewriteMutator mutator{context};
   parser::Walk(program, mutator);
-  return !context.AnyFatalError();
+  return !context.AnyFatalError() && RewriteOmpParts(context, program);
 }
 
 } // namespace Fortran::semantics

flang/test/Semantics/OpenMP/requires-atomic01.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
+  implicit none
+  !$omp requires atomic_default_mem_order(seq_cst)
+  integer :: i, j
+
+  ! ----------------------------------------------------------------------------
+  ! READ
+  ! ----------------------------------------------------------------------------
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicRead
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  !$omp atomic read
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicRead
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed read
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicRead
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic read relaxed
+  i = j
+  
+  ! ----------------------------------------------------------------------------
+  ! WRITE
+  ! ----------------------------------------------------------------------------
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicWrite
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  !$omp atomic write
+  i = j
+
+  ! 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
+
+  ! ----------------------------------------------------------------------------
+  ! UPDATE
+  ! ----------------------------------------------------------------------------
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicUpdate
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  !$omp atomic update
+  i = i + j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicUpdate
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed update
+  i = i + j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicUpdate
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic update relaxed
+  i = i + j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomic
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  !$omp atomic
+  i = i + j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomic
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed
+  i = i + j
+
+  ! ----------------------------------------------------------------------------
+  ! CAPTURE
+  ! ----------------------------------------------------------------------------
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicCapture
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  !$omp atomic capture
+  i = j
+  i = j
+  !$omp end atomic
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicCapture
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed capture
+  i = j
+  i = j
+  !$omp end atomic
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicCapture
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> SeqCst
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic capture relaxed
+  i = j
+  i = j
+  !$omp end atomic
+end program requires

flang/test/Semantics/OpenMP/requires-atomic02.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. ACQ_REL clause tested here.
+program requires
+  implicit none
+  !$omp requires atomic_default_mem_order(acq_rel)
+  integer :: i, j
+
+  ! ----------------------------------------------------------------------------
+  ! READ
+  ! ----------------------------------------------------------------------------
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicRead
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Acquire
+  !$omp atomic read
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicRead
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> Acquire
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed read
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicRead
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> Acquire
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic read relaxed
+  i = j
+  
+  ! ----------------------------------------------------------------------------
+  ! WRITE
+  ! ----------------------------------------------------------------------------
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicWrite
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Release
+  !$omp atomic write
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicWrite
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> Release
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed write
+  i = j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicWrite
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> Release
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic write relaxed
+  i = j
+
+  ! ----------------------------------------------------------------------------
+  ! UPDATE
+  ! ----------------------------------------------------------------------------
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicUpdate
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Release
+  !$omp atomic update
+  i = i + j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicUpdate
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> Release
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed update
+  i = i + j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicUpdate
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> Release
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic update relaxed
+  i = i + j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomic
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Release
+  !$omp atomic
+  i = i + j
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomic
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> Release
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed
+  i = i + j
+
+  ! ----------------------------------------------------------------------------
+  ! CAPTURE
+  ! ----------------------------------------------------------------------------
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicCapture
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> AcqRel
+  !$omp atomic capture
+  i = j
+  i = j
+  !$omp end atomic
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicCapture
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> AcqRel
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic relaxed capture
+  i = j
+  i = j
+  !$omp end atomic
+
+  ! CHECK-LABEL: OpenMPAtomicConstruct -> OmpAtomicCapture
+  ! CHECK-NOT: OmpMemoryOrderClause -> OmpClause -> AcqRel
+  ! CHECK: OmpMemoryOrderClause -> OmpClause -> Relaxed
+  !$omp atomic capture relaxed
+  i = j
+  i = j
+  !$omp end atomic
+end program requires