[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/include/flang/Semantics/symbol.h

 //===-- include/flang/Semantics/symbol.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_SYMBOL_H_
 #define FORTRAN_SEMANTICS_SYMBOL_H_
 
 #include "type.h"
 #include "flang/Common/Fortran.h"
 #include "flang/Common/enum-set.h"
 #include "flang/Common/reference.h"
 #include "flang/Common/visit.h"
+#include "flang/Parser/parse-tree.h"
+#include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/DenseMapInfo.h"
 
 #include <array>
 #include <functional>
 #include <list>
 #include <optional>
 #include <set>
 #include <vector>

 class Symbol;
 class ProgramTree;
 
 using SymbolRef = common::Reference<const Symbol>;
 using SymbolVector = std::vector<SymbolRef>;
 using MutableSymbolRef = common::Reference<Symbol>;
 using MutableSymbolVector = std::vector<MutableSymbolRef>;
 
+namespace {
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+// Flags representing OpenMP requires clauses.
+enum OmpRequiresFlags {
+  None = 0x00,
+  ReverseOffload = 0x01,
+  UnifiedAddress = 0x02,
+  UnifiedSharedMemory = 0x04,
+  DynamicAllocators = 0x08,
+  LLVM_MARK_AS_BITMASK_ENUM(DynamicAllocators)
+};
+} // namespace
+
+// Mixin for details with OpenMP declarative constructs.
+class WithOmpDeclarative {
+  using OmpAtomicOrderType = parser::OmpAtomicDefaultMemOrderClause::Type;
+
+public:
+  bool has_ompRequires() const { return ompRequires_.has_value(); }
+  const OmpRequiresFlags *ompRequires() const {
+    return ompRequires_ ? &*ompRequires_ : nullptr;
+  }
+  void set_ompRequires(OmpRequiresFlags flags) { ompRequires_ = flags; }
+
+  bool has_ompAtomicDefaultMemOrder() const {
+    return ompAtomicDefaultMemOrder_.has_value();
+  }
+  const OmpAtomicOrderType *ompAtomicDefaultMemOrder() const {
+    return ompAtomicDefaultMemOrder_ ? &*ompAtomicDefaultMemOrder_ : nullptr;
+  }
+  void set_ompAtomicDefaultMemOrder(OmpAtomicOrderType flags) {
+    ompAtomicDefaultMemOrder_ = flags;
+  }
+
+private:
+  std::optional<OmpRequiresFlags> ompRequires_;
+  std::optional<OmpAtomicOrderType> ompAtomicDefaultMemOrder_;
+};
+
 // A module or submodule.
-class ModuleDetails {
+class ModuleDetails : public WithOmpDeclarative {
 public:
   ModuleDetails(bool isSubmodule = false) : isSubmodule_{isSubmodule} {}
   bool isSubmodule() const { return isSubmodule_; }
   const Scope *scope() const { return scope_; }
   const Scope *ancestor() const; // for submodule; nullptr for module
   const Scope *parent() const; // for submodule; nullptr for module
   void set_scope(const Scope *);
   bool isDefaultPrivate() const { return isDefaultPrivate_; }
   void set_isDefaultPrivate(bool yes = true) { isDefaultPrivate_ = yes; }
 
 private:
   bool isSubmodule_;
   bool isDefaultPrivate_{false};
   const Scope *scope_{nullptr};
 };
 
-class MainProgramDetails {
+class MainProgramDetails : public WithOmpDeclarative {
 public:
 private:
 };
 
 class WithBindName {
 public:
   const std::string *bindName() const {
     return bindName_ ? &*bindName_ : nullptr;
   }
   bool isExplicitBindName() const { return isExplicitBindName_; }
   void set_bindName(std::string &&name) { bindName_ = std::move(name); }
   void set_isExplicitBindName(bool yes) { isExplicitBindName_ = yes; }
 
 private:
   std::optional<std::string> bindName_;
   bool isExplicitBindName_{false};
 };
 
 // A subroutine or function definition, or a subprogram interface defined
 // in an INTERFACE block as part of the definition of a dummy procedure
 // or a procedure pointer (with just POINTER).
-class SubprogramDetails : public WithBindName {
+class SubprogramDetails : public WithBindName, public WithOmpDeclarative {
 public:
   bool isFunction() const { return result_ != nullptr; }
   bool isInterface() const { return isInterface_; }
   void set_isInterface(bool value = true) { isInterface_ = value; }
   bool isDummy() const { return isDummy_; }
   void set_isDummy(bool value = true) { isDummy_ = value; }
   Scope *entryScope() { return entryScope_; }
   const Scope *entryScope() const { return entryScope_; }

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/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

#include "llvm/Frontend/OpenMP/OMP.inc"
   void Leave(const parser::OmpAtomicRead &);
   void Enter(const parser::OmpAtomicWrite &);
   void Leave(const parser::OmpAtomicWrite &);
   void Enter(const parser::OmpAtomicUpdate &);
   void Leave(const parser::OmpAtomicUpdate &);
   void Enter(const parser::OmpAtomicCapture &);
   void Leave(const parser::OmpAtomic &);
 
+  void Enter(const parser::UseStmt &);
+
 #define GEN_FLANG_CLAUSE_CHECK_ENTER
 #include "llvm/Frontend/OpenMP/OMP.inc"
 
   // Get the OpenMP Clause Kind for the corresponding Parser class
   template <typename A>
   llvm::omp::Clause GetClauseKindForParserClass(const A &) {
 #define GEN_FLANG_CLAUSE_PARSER_KIND_MAP
 #include "llvm/Frontend/OpenMP/OMP.inc"
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};
 };
 } // 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) {
+                toClauseFound = true;
+                CheckSymbolNames(dir.source, toClause.v);
+                CheckIsVarPartOfAnotherVar(dir.source, toClause.v);
+                CheckThreadprivateOrDeclareTargetVar(toClause.v);
+              },
+              [&](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;

 
 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);
+}
+
+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()));
+  }
+}
+
+void OmpStructureChecker::Enter(const parser::UseStmt &x) {
+  semantics::Symbol *symbol{x.moduleName.symbol};
+  if (!symbol) {
+    // Cannot check used module if it wasn't resolved.
+    return;
+  }
+
+  auto &details = std::get<ModuleDetails>(symbol->details());
+  if (details.has_ompRequires() && deviceConstructFound_) {
+    context_.Say(x.moduleName.source,
+        "'%s' module containing device-related REQUIRES directive imported "
+        "lexically after device construct"_err_en_US,
+        x.moduleName.ToString());
+  }
+}
+
 } // namespace Fortran::semantics

flang/lib/Semantics/mod-file.cpp

 static void PutBound(llvm::raw_ostream &, const Bound &);
 static void PutShapeSpec(llvm::raw_ostream &, const ShapeSpec &);
 static void PutShape(
     llvm::raw_ostream &, const ArraySpec &, char open, char close);
 
 static llvm::raw_ostream &PutAttr(llvm::raw_ostream &, Attr);
 static llvm::raw_ostream &PutType(llvm::raw_ostream &, const DeclTypeSpec &);
 static llvm::raw_ostream &PutLower(llvm::raw_ostream &, std::string_view);
+static llvm::raw_ostream &PutOmpRequires(
+    llvm::raw_ostream &, const WithOmpDeclarative &);
 static std::error_code WriteFile(
     const std::string &, const std::string &, bool = true);
 static bool FileContentsMatch(
     const std::string &, const std::string &, const std::string &);
 static std::string CheckSum(const std::string_view &);
 
 // Collect symbols needed for a subprogram interface
 class SubprogramSymbolCollector {
if (parent != ancestor) {
       all << ':' << parent->name();
     }
     all << ") " << symbol.name();
   }
   all << '\n' << uses_.str();
   uses_.str().clear();
   all << useExtraAttrs_.str();
   useExtraAttrs_.str().clear();
+  PutOmpRequires(all, details);
   all << decls_.str();
   decls_.str().clear();
   auto str{contains_.str()};
   contains_.str().clear();
   if (!str.empty()) {
     all << "contains\n" << str;
   }
   all << "end\n";
PutAttrs(os, bindAttrs, details.bindName(), details.isExplicitBindName(),
       " "s, ""s);
   if (details.isFunction()) {
     const Symbol &result{details.result()};
     if (result.name() != symbol.name()) {
       os << " result(" << result.name() << ')';
     }
   }
   os << '\n';
+  // print OpenMP requires
+  PutOmpRequires(os, details);
   // walk symbols, collect ones needed for interface
   const Scope &scope{
       details.entryScope() ? *details.entryScope() : DEREF(symbol.scope())};
   SubprogramSymbolCollector collector{symbol, scope};
   collector.Collect();
   std::string typeBindingsBuf;
   llvm::raw_string_ostream typeBindings{typeBindingsBuf};
   ModFileWriter writer{context_};

 
 llvm::raw_ostream &PutLower(llvm::raw_ostream &os, std::string_view str) {
   for (char c : str) {
     os << parser::ToLowerCaseLetter(c);
   }
   return os;
 }
 
+llvm::raw_ostream &PutOmpRequires(
+    llvm::raw_ostream &os, const WithOmpDeclarative &details) {
+  if (details.has_ompRequires() || details.has_ompAtomicDefaultMemOrder()) {
+    os << "!$omp requires";
+    if (auto *flags{details.ompRequires()}) {
+      if (*flags & OmpRequiresFlags::ReverseOffload) {
+        os << " reverse_offload";
+      }
+      if (*flags & OmpRequiresFlags::UnifiedAddress) {
+        os << " unified_address";
+      }
+      if (*flags & OmpRequiresFlags::UnifiedSharedMemory) {
+        os << " unified_shared_memory";
+      }
+      if (*flags & OmpRequiresFlags::DynamicAllocators) {
+        os << " dynamic_allocators";
+      }
+    }
+    if (auto *memOrder{details.ompAtomicDefaultMemOrder()}) {
+      os << " atomic_default_mem_order(";
+      switch (*memOrder) {
+      case parser::OmpAtomicDefaultMemOrderClause::Type::SeqCst:
+        os << "seq_cst";
+        break;
+      case parser::OmpAtomicDefaultMemOrderClause::Type::AcqRel:
+        os << "acq_rel";
+        break;
+      case parser::OmpAtomicDefaultMemOrderClause::Type::Relaxed:
+        os << "relaxed";
+        break;
+      }
+      os << ')';
+    }
+    os << '\n';
+  }
+  return os;
+}
+
 struct Temp {
   Temp(int fd, std::string path) : fd{fd}, path{path} {}
   Temp(Temp &&t) : fd{std::exchange(t.fd, -1)}, path{std::move(t.path)} {}
   ~Temp() {
     if (fd >= 0) {
       llvm::sys::fs::file_t native{llvm::sys::fs::convertFDToNativeFile(fd)};
       llvm::sys::fs::closeFile(native);
       llvm::sys::fs::remove(path.c_str());

flang/lib/Semantics/resolve-directives.h

 //===----------------------------------------------------------------------===//
 //
 // 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_RESOLVE_DIRECTIVES_H_
 #define FORTRAN_SEMANTICS_RESOLVE_DIRECTIVES_H_
 
 namespace Fortran::parser {
 struct Name;
+struct Program;
 struct ProgramUnit;
 } // namespace Fortran::parser
 
 namespace Fortran::semantics {
 
 class SemanticsContext;
 
 // Name resolution for OpenACC and OpenMP directives
 void ResolveAccParts(SemanticsContext &, const parser::ProgramUnit &);
 void ResolveOmpParts(SemanticsContext &, const parser::ProgramUnit &);
+void ResolveOmpTopLevelParts(SemanticsContext &, const parser::Program &);
 
 } // namespace Fortran::semantics
 #endif

flang/lib/Semantics/resolve-directives.cpp

 #include "flang/Evaluate/type.h"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/parse-tree.h"
 #include "flang/Parser/tools.h"
 #include "flang/Semantics/expression.h"
 #include <list>
 #include <map>
 
+template <typename T>
+static Fortran::semantics::Scope *GetScope(
+    Fortran::semantics::SemanticsContext &context, const T &x) {
+  std::optional<Fortran::parser::CharBlock> source{GetSource(x)};
+  return source ? &context.FindScope(*source) : nullptr;
+}
+
 namespace Fortran::semantics {
 
 template <typename T> class DirectiveAttributeVisitor {
 public:
   explicit DirectiveAttributeVisitor(SemanticsContext &context)
       : context_{context} {}
 
   template <typename A> bool Pre(const A &) { return true; }
std::optional<DirContext> GetContextIf() {
     return dirContext_.empty()
         ? std::nullopt
         : std::make_optional<DirContext>(dirContext_.back());
   }
   void PushContext(const parser::CharBlock &source, T dir) {
     dirContext_.emplace_back(source, dir, context_.FindScope(source));
   }
   void PopContext() { dirContext_.pop_back(); }
+  Scope *GetDeclScope() {
+    CHECK(!declScope_.empty());
+    return declScope_.back();
+  }
+  void PushDeclScope(Scope *scope) { declScope_.push_back(scope); }
+  void PopDeclScope() { declScope_.pop_back(); }
   void SetContextDirectiveSource(parser::CharBlock &dir) {
     GetContext().directiveSource = dir;
   }
   Scope &currScope() { return GetContext().scope; }
   void SetContextDefaultDSA(Symbol::Flag flag) {
     GetContext().defaultDSA = flag;
   }
   void AddToContextObjectWithDSA(
protected:
   Symbol *DeclarePrivateAccessEntity(
       const parser::Name &, Symbol::Flag, Scope &);
   Symbol *DeclarePrivateAccessEntity(Symbol &, Symbol::Flag, Scope &);
   Symbol *DeclareOrMarkOtherAccessEntity(const parser::Name &, Symbol::Flag);
 
   UnorderedSymbolSet dataSharingAttributeObjects_; // on one directive
   SemanticsContext &context_;
   std::vector<DirContext> dirContext_; // used as a stack
+  std::vector<Scope *> declScope_; // used as a stack
 };
 
 class AccAttributeVisitor : DirectiveAttributeVisitor<llvm::acc::Directive> {
 public:
   explicit AccAttributeVisitor(SemanticsContext &context)
       : DirectiveAttributeVisitor(context) {}
 
   template <typename A> void Walk(const A &x) { parser::Walk(x, *this); }
public:
   }
 
   bool Pre(const parser::ModuleSubprogram &) {
     // Clear the labels being tracked in the previous scope
     ClearLabels();
     return true;
   }
 
-  bool Pre(const parser::SpecificationPart &x) {
-    Walk(std::get<std::list<parser::OpenMPDeclarativeConstruct>>(x.t));
-    return true;
-  }
-
   bool Pre(const parser::StmtFunctionStmt &x) {
     const auto &parsedExpr{std::get<parser::Scalar<parser::Expr>>(x.t)};
     if (const auto *expr{GetExpr(context_, parsedExpr)}) {
       for (const Symbol &symbol : evaluate::CollectSymbols(*expr)) {
         if (!IsStmtFunctionDummy(symbol)) {
           stmtFunctionExprSymbols_.insert(symbol.GetUltimate());
         }
       }
if (name) {
       ResolveOmpName(*name, Symbol::Flag::OmpDeclareSimd);
     }
     return true;
   }
   void Post(const parser::OpenMPDeclareSimdConstruct &) { PopContext(); }
 
   bool Pre(const parser::OpenMPRequiresConstruct &x) {
     PushContext(x.source, llvm::omp::Directive::OMPD_requires);
+
+    // Gather information from the clauses.
+    OmpRequiresFlags flags{OmpRequiresFlags::None};
+    std::optional<parser::OmpAtomicDefaultMemOrderClause::Type> memOrder;
+    for (auto &clause : std::get<parser::OmpClauseList>(x.t).v) {
+      flags |= common::visit(
+          common::visitors{
+              [&memOrder](
+                  const parser::OmpClause::AtomicDefaultMemOrder &atomic) {
+                memOrder = atomic.v.v;
+                return OmpRequiresFlags::None;
+              },
+              [](const parser::OmpClause::ReverseOffload &) {
+                return OmpRequiresFlags::ReverseOffload;
+              },
+              [](const parser::OmpClause::UnifiedAddress &) {
+                return OmpRequiresFlags::UnifiedAddress;
+              },
+              [](const parser::OmpClause::UnifiedSharedMemory &) {
+                return OmpRequiresFlags::UnifiedSharedMemory;
+              },
+              [](const parser::OmpClause::DynamicAllocators &) {
+                return OmpRequiresFlags::DynamicAllocators;
+              },
+              [&](const auto &) {
+                context_.Say(x.source,
+                    "Unexpected clause in REQUIRES construct"_err_en_US);
+                return OmpRequiresFlags::None;
+              }},
+          clause.u);
+    }
+    // Merge clauses into parents' symbols details.
+    AddOmpRequiresToScope(&currScope(), flags, memOrder);
     return true;
   }
   void Post(const parser::OpenMPRequiresConstruct &) { PopContext(); }
 
   bool Pre(const parser::OpenMPDeclareTargetConstruct &);
   void Post(const parser::OpenMPDeclareTargetConstruct &) { PopContext(); }
 
+  void Post(const parser::UseStmt &x) {
+    Symbol *symbol{x.moduleName.symbol};
+    if (!symbol) {
+      return;
+    }
+
+    // Gather information from the imported module's symbol details.
+    OmpRequiresFlags flags{OmpRequiresFlags::None};
+    std::optional<parser::OmpAtomicDefaultMemOrderClause::Type> memOrder;
+    common::visit(
+        [&](auto &details) {
+          if constexpr (std::is_base_of_v<ModuleDetails,
+                            std::decay_t<decltype(details)>>) {
+            if (details.has_ompRequires()) {
+              flags = *details.ompRequires();
+            }
+            if (details.has_ompAtomicDefaultMemOrder()) {
+              memOrder = *details.ompAtomicDefaultMemOrder();
+            }
+          }
+        },
+        symbol->details());
+
+    // Merge requires clauses into `use` statement parents.
+    AddOmpRequiresToScope(GetDeclScope(), flags, memOrder);
+  }
+
   bool Pre(const parser::OpenMPThreadprivate &);
   void Post(const parser::OpenMPThreadprivate &) { PopContext(); }
 
   bool Pre(const parser::OpenMPDeclarativeAllocate &);
   void Post(const parser::OpenMPDeclarativeAllocate &) { PopContext(); }
 
   bool Pre(const parser::OpenMPExecutableAllocate &);
   void Post(const parser::OpenMPExecutableAllocate &);
public:
 
   bool Pre(const parser::OmpClause::UseDeviceAddr &x) {
     ResolveOmpObjectList(x.v, Symbol::Flag::OmpUseDeviceAddr);
     return false;
   }
 
   void Post(const parser::Name &);
 
+  // Keep track of contexts inside of which `SpecificationPart`s can be found
+  // to allow matching `Use` statements with their parent scopes.
+  bool Pre(const parser::MainProgram &x) {
+    PushDeclScope(GetScope(context_, x));
+    return true;
+  }
+  bool Pre(const parser::Module &x) {
+    PushDeclScope(GetScope(context_, x));
+    return true;
+  }
+  bool Pre(const parser::Submodule &x) {
+    PushDeclScope(GetScope(context_, x));
+    return true;
+  }
+  bool Pre(const parser::FunctionSubprogram &x) {
+    PushDeclScope(GetScope(context_, x));
+    return true;
+  }
+  bool Pre(const parser::InterfaceBody::Function &x) {
+    PushDeclScope(GetScope(context_, x));
+    return true;
+  }
+  bool Pre(const parser::SubroutineSubprogram &x) {
+    PushDeclScope(GetScope(context_, x));
+    return true;
+  }
+  bool Pre(const parser::InterfaceBody::Subroutine &x) {
+    PushDeclScope(GetScope(context_, x));
+    return true;
+  }
+  bool Pre(const parser::SeparateModuleSubprogram &x) {
+    PushDeclScope(GetScope(context_, x));
+    return true;
+  }
+  bool Pre(const parser::BlockConstruct &x) {
+    PushDeclScope(GetScope(context_, x));
+    return true;
+  }
+  bool Pre(const parser::BlockData &x) {
+    PushDeclScope(GetScope(context_, x));
+    return true;
+  }
+  void Post(const parser::MainProgram &) { PopDeclScope(); }
+  void Post(const parser::Module &) { PopDeclScope(); }
+  void Post(const parser::Submodule &) { PopDeclScope(); }
+  void Post(const parser::FunctionSubprogram &) { PopDeclScope(); }
+  void Post(const parser::InterfaceBody::Function &) { PopDeclScope(); }
+  void Post(const parser::SubroutineSubprogram &) { PopDeclScope(); }
+  void Post(const parser::InterfaceBody::Subroutine &) { PopDeclScope(); }
+  void Post(const parser::SeparateModuleSubprogram &) { PopDeclScope(); }
+  void Post(const parser::BlockConstruct &) { PopDeclScope(); }
+  void Post(const parser::BlockData &) { PopDeclScope(); }
+
   // Keep track of labels in the statements that causes jumps to target labels
   void Post(const parser::GotoStmt &gotoStmt) { CheckSourceLabel(gotoStmt.v); }
   void Post(const parser::ComputedGotoStmt &computedGotoStmt) {
     for (auto &label : std::get<std::list<parser::Label>>(computedGotoStmt.t)) {
       CheckSourceLabel(label);
     }
   }
   void Post(const parser::ArithmeticIfStmt &arithmeticIfStmt) {
void CheckLabelContext(const parser::CharBlock, const parser::CharBlock,
       std::optional<DirContext>, std::optional<DirContext>);
   void ClearLabels() {
     sourceLabels_.clear();
     targetLabels_.clear();
   };
 
   bool HasSymbolInEnclosingScope(const Symbol &, Scope &);
   std::int64_t ordCollapseLevel{0};
+
+  void AddOmpRequiresToScope(Scope *, OmpRequiresFlags,
+      std::optional<parser::OmpAtomicDefaultMemOrderClause::Type>);
 };
 
 template <typename T>
 bool DirectiveAttributeVisitor<T>::HasDataSharingAttributeObject(
     const Symbol &object) {
   auto it{dataSharingAttributeObjects_.find(object)};
   return it != dataSharingAttributeObjects_.end();
 }
if (!context.AnyFatalError()) {
       // the corresponding DoConstruct, a second walk is to adjust the
       // symbols for all the data-refs of that loop iteration variable
       // prior to the DoConstruct.
       OmpAttributeVisitor{context}.Walk(node);
     }
   }
 }
 
+void ResolveOmpTopLevelParts(
+    SemanticsContext &context, const parser::Program &program) {
+  if (!context.IsEnabled(common::LanguageFeature::OpenMP)) {
+    return;
+  }
+
+  // Gather `requires` clauses from all non-module top-level program unit
+  // symbols, combine them together ensuring compatibility and apply them to all
+  // these program units. Modules are skipped because their `requires` clauses
+  // are propagated via `USE` statements instead.
+  OmpRequiresFlags combinedFlags{OmpRequiresFlags::None};
+  std::optional<parser::OmpAtomicDefaultMemOrderClause::Type> combinedMemOrder;
+
+  // Function to go through non-module top level program units and extract
+  // `requires` information to be processed by a function-like argument.
+  auto processProgramUnits{[&](auto processFn) {
+    for (const parser::ProgramUnit &unit : program.v) {
+      if (!std::get_if<common::Indirection<parser::Module>>(&unit.u) &&
+          !std::get_if<common::Indirection<parser::Submodule>>(&unit.u)) {
+        Symbol *symbol{common::visit(
+            [&context](
+                auto &x) { return GetScope(context, x.value())->symbol(); },
+            unit.u)};
+
+        common::visit(
+            [&](auto &details) {
+              if constexpr (std::is_convertible_v<decltype(&details),
+                                WithOmpDeclarative *>) {
+                processFn(symbol, details);
+              }
+            },
+            symbol->details());
+      }
+    }
+  }};
+
+  // Combine global `requires` information from all program units except
+  // modules and submodules.
+  processProgramUnits([&](Symbol *symbol, WithOmpDeclarative &details) {
+    if (const OmpRequiresFlags * flags{details.ompRequires()}) {
+      combinedFlags |= *flags;
+    }
+    if (const parser::OmpAtomicDefaultMemOrderClause::Type *
+        memOrder{details.ompAtomicDefaultMemOrder()}) {
+      if (combinedMemOrder && *combinedMemOrder != *memOrder) {
+        context.Say(symbol->scope()->sourceRange(),
+            "Conflicting '%s' REQUIRES clauses found in "
+            "compilation "
+            "unit"_err_en_US,
+            parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(
+                llvm::omp::Clause::OMPC_atomic_default_mem_order)
+                                           .str()));
+      }
+      combinedMemOrder = *memOrder;
+    }
+  });
+
+  // Update all program units except modules and submodules with the
+  // combined global `requires` information.
+  processProgramUnits([&](Symbol *, WithOmpDeclarative &details) {
+    details.set_ompRequires(combinedFlags);
+    if (combinedMemOrder) {
+      details.set_ompAtomicDefaultMemOrder(*combinedMemOrder);
+    }
+  });
+}
+
 void OmpAttributeVisitor::CheckDataCopyingClause(
     const parser::Name &name, const Symbol &symbol, Symbol::Flag ompFlag) {
   const auto *checkSymbol{&symbol};
   if (const auto *details{symbol.detailsIf<HostAssocDetails>()}) {
     checkSymbol = &details->symbol();
   }
 
   if (ompFlag == Symbol::Flag::OmpCopyIn) {

 }
 
 bool OmpAttributeVisitor::HasSymbolInEnclosingScope(
     const Symbol &symbol, Scope &scope) {
   const auto symbols{scope.parent().GetSymbols()};
   return llvm::is_contained(symbols, symbol);
 }
 
+void OmpAttributeVisitor::AddOmpRequiresToScope(Scope *scope,
+    OmpRequiresFlags flags,
+    std::optional<parser::OmpAtomicDefaultMemOrderClause::Type> memOrder) {
+  do {
+    if (Symbol * symbol{scope->symbol()}) {
+      common::visit(
+          [&](auto &details) {
+            // Store clauses information into the symbol for the parent and
+            // enclosing modules, programs, functions and subroutines.
+            if constexpr (std::is_convertible_v<decltype(&details),
+                              WithOmpDeclarative *>) {
+              if (flags != OmpRequiresFlags::None) {
+                if (const OmpRequiresFlags *
+                    otherFlags{details.ompRequires()}) {
+                  flags |= *otherFlags;
+                }
+                details.set_ompRequires(flags);
+              }
+              if (memOrder) {
+                if (details.has_ompAtomicDefaultMemOrder() &&
+                    *details.ompAtomicDefaultMemOrder() != *memOrder) {
+                  context_.Say(scope->sourceRange(),
+                      "Conflicting '%s' REQUIRES clauses found in "
+                      "compilation "
+                      "unit"_err_en_US,
+                      parser::ToUpperCaseLetters(llvm::omp::getOpenMPClauseName(
+                          llvm::omp::Clause::OMPC_atomic_default_mem_order)
+                                                     .str()));
+                }
+                details.set_ompAtomicDefaultMemOrder(*memOrder);
+              }
+            }
+          },
+          symbol->details());
+    }
+    scope = &scope->parent();
+  } while (!scope->IsGlobal());
+}
+
 } // namespace Fortran::semantics

flang/lib/Semantics/resolve-names.cpp

if (node.IsModule()) {
     ApplyDefaultAccess();
   }
   PopScope(); // converts unclassified entities into objects
   for (const auto &child : node.children()) {
     ResolveExecutionParts(child);
   }
 }
 
-void ResolveNamesVisitor::Post(const parser::Program &) {
+void ResolveNamesVisitor::Post(const parser::Program &x) {
   // ensure that all temps were deallocated
   CHECK(!attrs_);
   CHECK(!cudaDataAttr_);
   CHECK(!GetDeclTypeSpec());
+  // Top-level resolution to propagate information across program units after
+  // each of them has been resolved separately.
+  ResolveOmpTopLevelParts(context(), x);
 }
 
 // A singleton instance of the scope -> IMPLICIT rules mapping is
 // shared by all instances of ResolveNamesVisitor and accessed by this
 // pointer when the visitors (other than the top-level original) are
 // constructed.
 static ImplicitRulesMap *sharedImplicitRulesMap{nullptr};
 

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_RESOLVE_DIRECTIVES_H_
-#define FORTRAN_SEMANTICS_RESOLVE_DIRECTIVES_H_
+#ifndef FORTRAN_SEMANTICS_REWRITE_DIRECTIVES_H_
+#define FORTRAN_SEMANTICS_REWRITE_DIRECTIVES_H_
 
 namespace Fortran::parser {
-struct Name;
-struct ProgramUnit;
+struct Program;
 } // namespace Fortran::parser
 
 namespace Fortran::semantics {
-
 class SemanticsContext;
+} // namespace Fortran::semantics
 
-// Name resolution for OpenACC and OpenMP directives
-void ResolveAccParts(SemanticsContext &, const parser::ProgramUnit &);
-void ResolveOmpParts(SemanticsContext &, const parser::ProgramUnit &);
-
+namespace Fortran::semantics {
+bool RewriteOmpParts(SemanticsContext &, parser::Program &);
 } // namespace Fortran::semantics
-#endif
+
+#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 <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> void Walk(T &x) { parser::Walk(x, *this); }
+  template <typename T> bool Pre(T &) { return true; }
+  template <typename T> void Post(T &) {}
+
+  bool Pre(parser::OpenMPAtomicConstruct &);
+  bool Pre(parser::OpenMPRequiresConstruct &);
+  void Post(parser::OmpClause::AtomicDefaultMemOrder &);
+  void Post(parser::UseStmt &);
+
+private:
+  bool atomicDirectiveDefaultOrderFound_{false};
+  parser::CharBlock requiresClauseSource_;
+};
+
+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<parser::OmpAtomicDefaultMemOrderClause::Type> 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 parser::OmpAtomicDefaultMemOrderClause::Type::AcqRel:
+      clauseList->push_back(parser::OmpMemoryOrderClause(
+          parser::OmpClause(parser::OmpClause::AcqRel())));
+      break;
+    case parser::OmpAtomicDefaultMemOrderClause::Type::Relaxed:
+      clauseList->push_back(parser::OmpMemoryOrderClause(
+          parser::OmpClause(parser::OmpClause::Relaxed())));
+      break;
+    case parser::OmpAtomicDefaultMemOrderClause::Type::SeqCst:
+      clauseList->push_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) {
+    requiresClauseSource_ = clause.source;
+    Walk(clause.u);
+    requiresClauseSource_ = nullptr;
+  }
+  return false;
+}
+
+// Check that the `atomic_default_mem_order` clause does not appear after an
+// atomic operation without `memory_order` defined.
+void OmpRewriteMutator::Post(parser::OmpClause::AtomicDefaultMemOrder &x) {
+  if (atomicDirectiveDefaultOrderFound_) {
+    context_.Say(requiresClauseSource_,
+        "'ATOMIC_DEFAULT_MEM_ORDER' REQUIRES clause found lexically after "
+        "atomic operation with the 'MEMORY_ORDER' clause not defined"_err_en_US);
+  }
+}
+
+// Check that a module containing a `requires` statement with the
+// `atomic_default_mem_order` clause is not `USE`d after an atomic operation
+// without `memory_order` defined.
+void OmpRewriteMutator::Post(parser::UseStmt &x) {
+  semantics::Symbol *symbol{x.moduleName.symbol};
+  if (!symbol) {
+    // Cannot check used module if it wasn't resolved.
+    return;
+  }
+
+  auto *details = symbol->detailsIf<ModuleDetails>();
+  if (atomicDirectiveDefaultOrderFound_ && details &&
+      details->has_ompAtomicDefaultMemOrder()) {
+    context_.Say(x.moduleName.source,
+        "'%s' module containing 'ATOMIC_DEFAULT_MEM_ORDER' REQUIRES clause "
+        "imported lexically after atomic operation with the 'MEMORY_ORDER' "
+        "clause not defined"_err_en_US,
+        x.moduleName.ToString());
+  }
+}
+
+bool RewriteOmpParts(SemanticsContext &context, parser::Program &program) {
+  if (!context.IsEnabled(common::LanguageFeature::OpenMP)) {
+    return true;
+  }
+  OmpRewriteMutator{context}.Walk(program);
+  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/Inputs/requires_module.f90

+module requires_module
+  !$omp requires atomic_default_mem_order(seq_cst), unified_shared_memory
+end module

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
+  implicit none
+  !$omp requires atomic_default_mem_order(seq_cst)
+  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
+
+!ERROR: Conflicting 'ATOMIC_DEFAULT_MEM_ORDER' REQUIRES clauses found in compilation unit
+subroutine g
+  !$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

flang/test/Semantics/OpenMP/requires07.f90

+! RUN: rm -rf %t && mkdir %t
+! RUN: %flang_fc1 -fsyntax-only -fopenmp -module-dir %t '%S/../Inputs/requires_module.f90'
+! RUN: %python %S/../test_errors.py %s %flang -fopenmp -module-dir %t
+! 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. Test that this is propagated
+! from imported modules
+
+!ERROR: Conflicting 'ATOMIC_DEFAULT_MEM_ORDER' REQUIRES clauses found in compilation unit
+use requires_module
+!$omp requires atomic_default_mem_order(relaxed)
+end program

flang/test/Semantics/OpenMP/requires08.f90

+! RUN: rm -rf %t && mkdir %t
+! RUN: %flang_fc1 -fsyntax-only -fopenmp -module-dir %t '%S/../Inputs/requires_module.f90'
+! RUN: %python %S/../test_errors.py %s %flang -fopenmp -module-dir %t
+! 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. Test that this
+! is propagated from imported modules.
+
+subroutine f
+  !$omp declare target (f)
+end subroutine f
+
+program requires
+  !ERROR: 'requires_module' module containing device-related REQUIRES directive imported lexically after device construct
+  use requires_module
+end program requires