diff --git a/flang/documentation/OpenMP-4.5-grammar.txt b/flang/documentation/OpenMP-4.5-grammar.txt
--- a/flang/documentation/OpenMP-4.5-grammar.txt
+++ b/flang/documentation/OpenMP-4.5-grammar.txt
@@ -344,6 +344,8 @@
                  ATOMIC [seq_cst]
        atomic-clause -> READ | WRITE | UPDATE | CAPTURE
 
+2.13.6 end-atomic -> END ATOMIC
+
 2.13.7 flush -> FLUSH [(variable-name-list)]
 
 2.13.8 ordered -> ORDERED ordered-construct-clause [[[,] ordered-construct-clause]...]
diff --git a/flang/include/flang/Parser/dump-parse-tree.h b/flang/include/flang/Parser/dump-parse-tree.h
--- a/flang/include/flang/Parser/dump-parse-tree.h
+++ b/flang/include/flang/Parser/dump-parse-tree.h
@@ -402,6 +402,9 @@
   NODE(parser, OmpAtomicCapture)
   NODE(OmpAtomicCapture, Stmt1)
   NODE(OmpAtomicCapture, Stmt2)
+  NODE(parser, OmpAtomicMemoryOrderClause)
+  NODE(parser, OmpAtomicMemoryOrderClauseList)
+  NODE(parser, OmpAtomicMemoryOrderClausePostList)
   NODE(parser, OmpAtomicRead)
   NODE(parser, OmpAtomicUpdate)
   NODE(parser, OmpAtomicWrite)
@@ -447,7 +450,6 @@
   NODE(OmpClause, UseDevicePtr)
   NODE(OmpClause, IsDevicePtr)
   NODE(parser, OmpCriticalDirective)
-  NODE(OmpCriticalDirective, Hint)
   NODE(parser, OmpDeclareTargetSpecifier)
   NODE(parser, OmpDeclareTargetWithClause)
   NODE(parser, OmpDeclareTargetWithList)
@@ -469,6 +471,7 @@
   NODE(parser, OmpEndCriticalDirective)
   NODE(parser, OmpEndLoopDirective)
   NODE(parser, OmpEndSectionsDirective)
+  NODE(parser, OmpHintExpr)
   NODE(parser, OmpIfClause)
   NODE_ENUM(OmpIfClause, DirectiveNameModifier)
   NODE(parser, OmpLinearClause)
@@ -482,10 +485,8 @@
   NODE(parser, OmpMapType)
   NODE(OmpMapType, Always)
   NODE_ENUM(OmpMapType, Type)
-  NODE(parser, OmpMemoryClause)
-  NODE_ENUM(OmpMemoryClause, MemoryOrder)
-  NODE(parser, OmpMemoryClauseList)
-  NODE(parser, OmpMemoryClausePostList)
+  NODE(parser, OmpMemoryOrderClause)
+  NODE_ENUM(OmpMemoryOrderClause, MemoryOrder)
   NODE(parser, OmpNowait)
   NODE(parser, OmpObject)
   NODE(parser, OmpObjectList)
diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h
--- a/flang/include/flang/Parser/parse-tree.h
+++ b/flang/include/flang/Parser/parse-tree.h
@@ -3599,12 +3599,14 @@
       u;
 };
 
+// HINT(hint-expression)
+WRAPPER_CLASS(OmpHintExpr, ConstantExpr);
+
 // 2.13.2 CRITICAL [Name] <block> END CRITICAL [Name]
 struct OmpCriticalDirective {
   TUPLE_CLASS_BOILERPLATE(OmpCriticalDirective);
-  WRAPPER_CLASS(Hint, ConstantExpr);
   CharBlock source;
-  std::tuple<Verbatim, std::optional<Name>, std::optional<Hint>> t;
+  std::tuple<Verbatim, std::optional<Name>, std::optional<OmpHintExpr>> t;
 };
 struct OmpEndCriticalDirective {
   TUPLE_CLASS_BOILERPLATE(OmpEndCriticalDirective);
@@ -3616,44 +3618,58 @@
   std::tuple<OmpCriticalDirective, Block, OmpEndCriticalDirective> t;
 };
 
-// 2.13.6 atomic -> ATOMIC [seq_cst[,]] atomic-clause [[,]seq_cst] |
-//                  ATOMIC [seq_cst]
+// 2.17.7 atomic -> ATOMIC [clause[,]] atomic-clause [[,]clause] |
+//                  ATOMIC [clause]
+//        clause -> memory-order-clause | HINT(hint-expression)
+//        memory-order-clause -> SEQ_CST | ACQ_REL | RELEASE | ACQUIRE | RELAXED
 //        atomic-clause -> READ | WRITE | UPDATE | CAPTURE
 
 // END ATOMIC
 EMPTY_CLASS(OmpEndAtomic);
 
-// ATOMIC Memory related clause
-struct OmpMemoryClause {
-  ENUM_CLASS(MemoryOrder, SeqCst)
-  WRAPPER_CLASS_BOILERPLATE(OmpMemoryClause, MemoryOrder);
+// Memory order clause
+struct OmpMemoryOrderClause {
+  ENUM_CLASS(MemoryOrder, SeqCst, AcqRel, Release, Acquire, Relaxed)
+  WRAPPER_CLASS_BOILERPLATE(OmpMemoryOrderClause, MemoryOrder);
   CharBlock source;
 };
 
-WRAPPER_CLASS(OmpMemoryClauseList, std::list<OmpMemoryClause>);
-WRAPPER_CLASS(OmpMemoryClausePostList, std::list<OmpMemoryClause>);
+// ATOMIC Memory order clause or hint expression
+struct OmpAtomicMemoryOrderClause {
+  UNION_CLASS_BOILERPLATE(OmpAtomicMemoryOrderClause);
+  CharBlock source;
+  std::variant<OmpMemoryOrderClause, OmpHintExpr> u;
+};
+
+WRAPPER_CLASS(
+    OmpAtomicMemoryOrderClauseList, std::list<OmpAtomicMemoryOrderClause>);
+WRAPPER_CLASS(
+    OmpAtomicMemoryOrderClausePostList, std::list<OmpAtomicMemoryOrderClause>);
 
 // ATOMIC READ
 struct OmpAtomicRead {
   TUPLE_CLASS_BOILERPLATE(OmpAtomicRead);
-  std::tuple<OmpMemoryClauseList, Verbatim, OmpMemoryClausePostList,
-      Statement<AssignmentStmt>, std::optional<OmpEndAtomic>>
+  std::tuple<OmpAtomicMemoryOrderClauseList, Verbatim,
+      OmpAtomicMemoryOrderClausePostList, Statement<AssignmentStmt>,
+      std::optional<OmpEndAtomic>>
       t;
 };
 
 // ATOMIC WRITE
 struct OmpAtomicWrite {
   TUPLE_CLASS_BOILERPLATE(OmpAtomicWrite);
-  std::tuple<OmpMemoryClauseList, Verbatim, OmpMemoryClausePostList,
-      Statement<AssignmentStmt>, std::optional<OmpEndAtomic>>
+  std::tuple<OmpAtomicMemoryOrderClauseList, Verbatim,
+      OmpAtomicMemoryOrderClausePostList, Statement<AssignmentStmt>,
+      std::optional<OmpEndAtomic>>
       t;
 };
 
 // ATOMIC UPDATE
 struct OmpAtomicUpdate {
   TUPLE_CLASS_BOILERPLATE(OmpAtomicUpdate);
-  std::tuple<OmpMemoryClauseList, Verbatim, OmpMemoryClausePostList,
-      Statement<AssignmentStmt>, std::optional<OmpEndAtomic>>
+  std::tuple<OmpAtomicMemoryOrderClauseList, Verbatim,
+      OmpAtomicMemoryOrderClausePostList, Statement<AssignmentStmt>,
+      std::optional<OmpEndAtomic>>
       t;
 };
 
@@ -3662,16 +3678,16 @@
   TUPLE_CLASS_BOILERPLATE(OmpAtomicCapture);
   WRAPPER_CLASS(Stmt1, Statement<AssignmentStmt>);
   WRAPPER_CLASS(Stmt2, Statement<AssignmentStmt>);
-  std::tuple<OmpMemoryClauseList, Verbatim, OmpMemoryClausePostList, Stmt1,
-      Stmt2, OmpEndAtomic>
+  std::tuple<OmpAtomicMemoryOrderClauseList, Verbatim,
+      OmpAtomicMemoryOrderClausePostList, Stmt1, Stmt2, OmpEndAtomic>
       t;
 };
 
 // ATOMIC
 struct OmpAtomic {
   TUPLE_CLASS_BOILERPLATE(OmpAtomic);
-  std::tuple<Verbatim, OmpMemoryClauseList, Statement<AssignmentStmt>,
-      std::optional<OmpEndAtomic>>
+  std::tuple<Verbatim, OmpAtomicMemoryOrderClauseList,
+      Statement<AssignmentStmt>, std::optional<OmpEndAtomic>>
       t;
 };
 
diff --git a/flang/lib/Parser/openmp-parsers.cpp b/flang/lib/Parser/openmp-parsers.cpp
--- a/flang/lib/Parser/openmp-parsers.cpp
+++ b/flang/lib/Parser/openmp-parsers.cpp
@@ -382,51 +382,74 @@
             construct<Call>(Parser<ProcedureDesignator>{},
                 parenthesized(optionalList(actualArgSpec))))))
 
-// 2.13.6 ATOMIC [seq_cst[,]] atomic-clause [[,]seq_cst] | ATOMIC [seq_cst]
-//        atomic-clause -> READ | WRITE | UPDATE | CAPTURE
+// Hint Expression => HINT(hint-expression)
+TYPE_PARSER("HINT" >> construct<OmpHintExpr>(parenthesized(constantExpr)))
+
+// 2.17.7 atomic -> ATOMIC [clause [,]] atomic-clause [[,] clause] |
+//                  ATOMIC [clause]
+//       clause -> memory-order-clause | HINT(hint-expression)
+//       memory-order-clause -> SEQ_CST | ACQ_REL | RELEASE | ACQUIRE | RELAXED
+//       atomic-clause -> READ | WRITE | UPDATE | CAPTURE
 
 // OMP END ATOMIC
 TYPE_PARSER(construct<OmpEndAtomic>(startOmpLine >> "END ATOMIC"_tok))
 
-// ATOMIC Memory related clause
-TYPE_PARSER(sourced(construct<OmpMemoryClause>(
-    "SEQ_CST" >> pure(OmpMemoryClause::MemoryOrder::SeqCst))))
+// Memory order clause
+TYPE_PARSER(sourced(construct<OmpMemoryOrderClause>(
+    "SEQ_CST" >> pure(OmpMemoryOrderClause::MemoryOrder::SeqCst) ||
+    "ACQ_REL" >> pure(OmpMemoryOrderClause::MemoryOrder::AcqRel) ||
+    "RELEASE" >> pure(OmpMemoryOrderClause::MemoryOrder::Release) ||
+    "ACQUIRE" >> pure(OmpMemoryOrderClause::MemoryOrder::Acquire) ||
+    "RELAXED" >> pure(OmpMemoryOrderClause::MemoryOrder::Relaxed))))
 
-// ATOMIC Memory Clause List
-TYPE_PARSER(construct<OmpMemoryClauseList>(
-    many(maybe(","_tok) >> Parser<OmpMemoryClause>{})))
+// ATOMIC Memory order clause or Hint expression
+TYPE_PARSER(
+    construct<OmpAtomicMemoryOrderClause>(Parser<OmpMemoryOrderClause>{}) ||
+    construct<OmpAtomicMemoryOrderClause>(Parser<OmpHintExpr>{}))
 
-TYPE_PARSER(construct<OmpMemoryClausePostList>(
-    many(maybe(","_tok) >> Parser<OmpMemoryClause>{})))
+// ATOMIC Memory order Clause List
+TYPE_PARSER(construct<OmpAtomicMemoryOrderClauseList>(
+    many(maybe(","_tok) >> Parser<OmpAtomicMemoryOrderClause>{})))
 
-// OMP [SEQ_CST] ATOMIC READ [SEQ_CST]
-TYPE_PARSER("ATOMIC" >>
-    construct<OmpAtomicRead>(Parser<OmpMemoryClauseList>{} / maybe(","_tok),
-        verbatim("READ"_tok), Parser<OmpMemoryClausePostList>{} / endOmpLine,
-        statement(assignmentStmt), maybe(Parser<OmpEndAtomic>{} / endOmpLine)))
+TYPE_PARSER(construct<OmpAtomicMemoryOrderClausePostList>(
+    many(maybe(","_tok) >> Parser<OmpAtomicMemoryOrderClause>{})))
 
-// OMP ATOMIC [SEQ_CST] CAPTURE [SEQ_CST]
+// OMP ATOMIC [MEMORY-ORDER-CLAUSE-LIST] READ [MEMORY-ORDER-CLAUSE-LIST]
 TYPE_PARSER("ATOMIC" >>
-    construct<OmpAtomicCapture>(Parser<OmpMemoryClauseList>{} / maybe(","_tok),
-        verbatim("CAPTURE"_tok), Parser<OmpMemoryClausePostList>{} / endOmpLine,
-        statement(assignmentStmt), statement(assignmentStmt),
-        Parser<OmpEndAtomic>{} / endOmpLine))
+    construct<OmpAtomicRead>(
+        Parser<OmpAtomicMemoryOrderClauseList>{} / maybe(","_tok),
+        verbatim("READ"_tok),
+        Parser<OmpAtomicMemoryOrderClausePostList>{} / endOmpLine,
+        statement(assignmentStmt), maybe(Parser<OmpEndAtomic>{} / endOmpLine)))
 
-// OMP ATOMIC [SEQ_CST] UPDATE [SEQ_CST]
+// OMP ATOMIC [MEMORY-ORDER-CLAUSE-LIST] CAPTURE [MEMORY-ORDER-CLAUSE-LIST]
+TYPE_PARSER(
+    "ATOMIC" >> construct<OmpAtomicCapture>(
+                    Parser<OmpAtomicMemoryOrderClauseList>{} / maybe(","_tok),
+                    verbatim("CAPTURE"_tok),
+                    Parser<OmpAtomicMemoryOrderClausePostList>{} / endOmpLine,
+                    statement(assignmentStmt), statement(assignmentStmt),
+                    Parser<OmpEndAtomic>{} / endOmpLine))
+
+// OMP ATOMIC [MEMORY-ORDER-CLAUSE-LIST] UPDATE [MEMORY-ORDER-CLAUSE-LIST]
 TYPE_PARSER("ATOMIC" >>
-    construct<OmpAtomicUpdate>(Parser<OmpMemoryClauseList>{} / maybe(","_tok),
-        verbatim("UPDATE"_tok), Parser<OmpMemoryClausePostList>{} / endOmpLine,
+    construct<OmpAtomicUpdate>(
+        Parser<OmpAtomicMemoryOrderClauseList>{} / maybe(","_tok),
+        verbatim("UPDATE"_tok),
+        Parser<OmpAtomicMemoryOrderClausePostList>{} / endOmpLine,
         statement(assignmentStmt), maybe(Parser<OmpEndAtomic>{} / endOmpLine)))
 
-// OMP ATOMIC [SEQ_CST]
+// OMP ATOMIC [MEMORY-ORDER-CLAUSE-LIST]
 TYPE_PARSER(construct<OmpAtomic>(verbatim("ATOMIC"_tok),
-    Parser<OmpMemoryClauseList>{} / endOmpLine, statement(assignmentStmt),
-    maybe(Parser<OmpEndAtomic>{} / endOmpLine)))
+    Parser<OmpAtomicMemoryOrderClauseList>{} / endOmpLine,
+    statement(assignmentStmt), maybe(Parser<OmpEndAtomic>{} / endOmpLine)))
 
-// ATOMIC [SEQ_CST] WRITE [SEQ_CST]
+// OMP ATOMIC [MEMORY-ORDER-CLAUSE-LIST] WRITE [MEMORY-ORDER-CLAUSE-LIST]
 TYPE_PARSER("ATOMIC" >>
-    construct<OmpAtomicWrite>(Parser<OmpMemoryClauseList>{} / maybe(","_tok),
-        verbatim("WRITE"_tok), Parser<OmpMemoryClausePostList>{} / endOmpLine,
+    construct<OmpAtomicWrite>(
+        Parser<OmpAtomicMemoryOrderClauseList>{} / maybe(","_tok),
+        verbatim("WRITE"_tok),
+        Parser<OmpAtomicMemoryOrderClausePostList>{} / endOmpLine,
         statement(assignmentStmt), maybe(Parser<OmpEndAtomic>{} / endOmpLine)))
 
 // Atomic Construct
@@ -442,9 +465,7 @@
         verbatim("END CRITICAL"_tok), maybe(parenthesized(name)))) /
         endOmpLine)
 TYPE_PARSER(sourced(construct<OmpCriticalDirective>(verbatim("CRITICAL"_tok),
-                maybe(parenthesized(name)),
-                maybe("HINT" >> construct<OmpCriticalDirective::Hint>(
-                                    parenthesized(constantExpr))))) /
+                maybe(parenthesized(name)), maybe(Parser<OmpHintExpr>{}))) /
     endOmpLine)
 
 TYPE_PARSER(construct<OpenMPCriticalConstruct>(
diff --git a/flang/lib/Parser/unparse.cpp b/flang/lib/Parser/unparse.cpp
--- a/flang/lib/Parser/unparse.cpp
+++ b/flang/lib/Parser/unparse.cpp
@@ -2154,19 +2154,34 @@
       break;
     }
   }
-  void Unparse(const OmpMemoryClause &x) {
+  void Unparse(const OmpHintExpr &x) { Word("HINT("), Walk(x.v), Put(')'); }
+  void Unparse(const OmpMemoryOrderClause &x) {
     switch (x.v) {
-    case OmpMemoryClause::MemoryOrder::SeqCst:
+    case OmpMemoryOrderClause::MemoryOrder::SeqCst:
       Word("SEQ_CST");
       break;
+    case OmpMemoryOrderClause::MemoryOrder::AcqRel:
+      Word("ACQ_REL");
+      break;
+    case OmpMemoryOrderClause::MemoryOrder::Release:
+      Word("RELEASE");
+      break;
+    case OmpMemoryOrderClause::MemoryOrder::Acquire:
+      Word("ACQUIRE");
+      break;
+    case OmpMemoryOrderClause::MemoryOrder::Relaxed:
+      Word("RELAXED");
+      break;
     }
   }
-  void Unparse(const OmpMemoryClauseList &x) { Walk(" ", x.v, " "); }
-  void Unparse(const OmpMemoryClausePostList &x) { Walk(" ", x.v, " "); }
+  void Unparse(const OmpAtomicMemoryOrderClauseList &x) { Walk(" ", x.v, " "); }
+  void Unparse(const OmpAtomicMemoryOrderClausePostList &x) {
+    Walk(" ", x.v, " ");
+  }
   void Unparse(const OmpAtomic &x) {
     BeginOpenMP();
     Word("!$OMP ATOMIC");
-    Walk(std::get<OmpMemoryClauseList>(x.t));
+    Walk(std::get<OmpAtomicMemoryOrderClauseList>(x.t));
     Put("\n");
     EndOpenMP();
     Walk(std::get<Statement<AssignmentStmt>>(x.t));
@@ -2177,9 +2192,9 @@
   void Unparse(const OmpAtomicCapture &x) {
     BeginOpenMP();
     Word("!$OMP ATOMIC");
-    Walk(std::get<OmpMemoryClauseList>(x.t));
+    Walk(std::get<OmpAtomicMemoryOrderClauseList>(x.t));
     Word(" CAPTURE");
-    Walk(std::get<OmpMemoryClausePostList>(x.t));
+    Walk(std::get<OmpAtomicMemoryOrderClausePostList>(x.t));
     Put("\n");
     EndOpenMP();
     Walk(std::get<OmpAtomicCapture::Stmt1>(x.t));
@@ -2192,9 +2207,9 @@
   void Unparse(const OmpAtomicRead &x) {
     BeginOpenMP();
     Word("!$OMP ATOMIC");
-    Walk(std::get<OmpMemoryClauseList>(x.t));
+    Walk(std::get<OmpAtomicMemoryOrderClauseList>(x.t));
     Word(" READ");
-    Walk(std::get<OmpMemoryClausePostList>(x.t));
+    Walk(std::get<OmpAtomicMemoryOrderClausePostList>(x.t));
     Put("\n");
     EndOpenMP();
     Walk(std::get<Statement<AssignmentStmt>>(x.t));
@@ -2205,9 +2220,9 @@
   void Unparse(const OmpAtomicUpdate &x) {
     BeginOpenMP();
     Word("!$OMP ATOMIC");
-    Walk(std::get<OmpMemoryClauseList>(x.t));
+    Walk(std::get<OmpAtomicMemoryOrderClauseList>(x.t));
     Word(" UPDATE");
-    Walk(std::get<OmpMemoryClausePostList>(x.t));
+    Walk(std::get<OmpAtomicMemoryOrderClausePostList>(x.t));
     Put("\n");
     EndOpenMP();
     Walk(std::get<Statement<AssignmentStmt>>(x.t));
@@ -2218,9 +2233,9 @@
   void Unparse(const OmpAtomicWrite &x) {
     BeginOpenMP();
     Word("!$OMP ATOMIC");
-    Walk(std::get<OmpMemoryClauseList>(x.t));
+    Walk(std::get<OmpAtomicMemoryOrderClauseList>(x.t));
     Word(" WRITE");
-    Walk(std::get<OmpMemoryClausePostList>(x.t));
+    Walk(std::get<OmpAtomicMemoryOrderClausePostList>(x.t));
     Put("\n");
     EndOpenMP();
     Walk(std::get<Statement<AssignmentStmt>>(x.t));
@@ -2232,8 +2247,7 @@
     BeginOpenMP();
     Word("!$OMP CRITICAL");
     Walk(" (", std::get<std::optional<Name>>(x.t), ")");
-    Walk(" HINT(", std::get<std::optional<OmpCriticalDirective::Hint>>(x.t),
-        ")");
+    Walk(std::get<std::optional<OmpHintExpr>>(x.t));
     Put("\n");
     EndOpenMP();
   }
diff --git a/flang/test/Semantics/omp-atomic.f90 b/flang/test/Semantics/omp-atomic.f90
--- a/flang/test/Semantics/omp-atomic.f90
+++ b/flang/test/Semantics/omp-atomic.f90
@@ -11,12 +11,27 @@
   a = b
   !$omp end atomic
 
+  !$omp atomic read acquire hint(1)
+  a = b
+
+  !$omp atomic release hint(1) write
+  a = b
+
   !$omp atomic capture seq_cst
   b = a
   a = a + 1
   !$omp end atomic
 
+  !$omp atomic hint(1) acq_rel capture
+  b = a
+  a = a + 1
+  !$omp end atomic
+
   !$omp atomic
   a = a + 1
+
+  !$omp atomic relaxed
+  a = a + 1
+
   !$omp end parallel
 end