[flang][OpenMP] Added semantic checks for atomic capture, write, and update statements

[NimishMishra]

Summary

This patch adds general checks for atomic read, write, and capture statements.

• check "capture statement is of the form v = x if atomic construct is read"
• check "write statement is of the form x = expr if atomic construct is write"
• check "x must not have the ALLOCATABLE attribute."
• check for non-scalar variables
• check if x (LHS variable) is accessed on the RHS of assignment statement
• improve error reporting in atomic update statement

Depends on D127615

[NimishMishra]

Landed of hint clause patch unblocks this now. Ping for review!

[TIFitis]

Please allow for another +1.

[raghavendhra]

LGTM

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

private:
   void CheckLoopItrVariableIsInt(const parser::OpenMPLoopConstruct &x);
   void CheckDoWhile(const parser::OpenMPLoopConstruct &x);
   void CheckCycleConstraints(const parser::OpenMPLoopConstruct &x);
   template <typename T, typename D> bool IsOperatorValid(const T &, const D &);
   void CheckAtomicMemoryOrderClause(
       const parser::OmpAtomicClauseList *, const parser::OmpAtomicClauseList *);
   void CheckAtomicHintClause(
       const parser::OmpAtomicClauseList *, const parser::OmpAtomicClauseList *);
-  void CheckAtomicUpdateAssignmentStmt(const parser::AssignmentStmt &);
+  void CheckAtomicUpdateStmt(const parser::AssignmentStmt &);
+  void CheckAtomicCaptureStmt(const parser::AssignmentStmt &);
+  void CheckAtomicWriteStmt(const parser::AssignmentStmt &);
   void CheckAtomicConstructStructure(const parser::OpenMPAtomicConstruct &);
   void CheckDistLinear(const parser::OpenMPLoopConstruct &x);
   void CheckSIMDNest(const parser::OpenMPConstruct &x);
   void CheckTargetNest(const parser::OpenMPConstruct &x);
   void CheckCancellationNest(
       const parser::CharBlock &source, const parser::OmpCancelType::Type &type);
   std::int64_t GetOrdCollapseLevel(const parser::OpenMPLoopConstruct &x);
   bool CheckReductionOperators(const parser::OmpClause::Reduction &);
private:
   void CheckMultipleAppearanceAcrossContext(
       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);
   bool isPredefinedAllocator{false};
+  const parser::Name *GetNameIfAllocatableVariable(
+      const semantics::Symbol &, const parser::Variable &);
   void EnterDirectiveNest(const int index) { directiveNest_[index]++; }
   void ExitDirectiveNest(const int index) { directiveNest_[index]--; }
   int GetDirectiveNest(const int index) { return directiveNest_[index]; }
 
   enum directiveNestType {
     SIMDNest,
     TargetBlockOnlyTeams,
     TargetNest,
     LastType
   };
   int directiveNest_[LastType + 1] = {0};
 };
 } // namespace Fortran::semantics
 #endif // FORTRAN_SEMANTICS_CHECK_OMP_STRUCTURE_H_

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

 // EndBlockDirective.
 void OmpStructureChecker::Leave(const parser::OmpEndBlockDirective &x) {
   if ((GetContext().directive == llvm::omp::Directive::OMPD_end_single) ||
       (GetContext().directive == llvm::omp::Directive::OMPD_end_workshare)) {
     dirContext_.pop_back();
   }
 }
 
+const parser::Name *OmpStructureChecker::GetNameIfAllocatableVariable(
+    const semantics::Symbol &symbol, const parser::Variable &var) {
+  // Return parser::Name from parser::Designator if the given symbol has
+  // ALLOCATABLE attribute
+  if (IsAllocatable(symbol)) {
+    const auto &designator =
+        std::get<common::Indirection<parser::Designator>>(var.u);
+    const auto *dataRef =
+        std::get_if<Fortran::parser::DataRef>(&designator.value().u);
+    return dataRef ? std::get_if<Fortran::parser::Name>(&dataRef->u) : nullptr;
+  }
+  return nullptr;
+}
+
 template <typename T, typename D>
 bool OmpStructureChecker::IsOperatorValid(const T &node, const D &variable) {
   using AllowedBinaryOperators =
       std::variant<parser::Expr::Add, parser::Expr::Multiply,
           parser::Expr::Subtract, parser::Expr::Divide, parser::Expr::AND,
           parser::Expr::OR, parser::Expr::EQV, parser::Expr::NEQV>;
   using BinaryOperators = std::variant<parser::Expr::Add,
       parser::Expr::Multiply, parser::Expr::Subtract, parser::Expr::Divide,
       parser::Expr::AND, parser::Expr::OR, parser::Expr::EQV,
       parser::Expr::NEQV, parser::Expr::Power, parser::Expr::Concat,
       parser::Expr::LT, parser::Expr::LE, parser::Expr::EQ, parser::Expr::NE,
       parser::Expr::GE, parser::Expr::GT>;
 
   if constexpr (common::HasMember<T, BinaryOperators>) {
     const auto &variableName{variable.GetSource().ToString()};
     const auto &exprLeft{std::get<0>(node.t)};
     const auto &exprRight{std::get<1>(node.t)};
     if ((exprLeft.value().source.ToString() != variableName) &&
         (exprRight.value().source.ToString() != variableName)) {
       context_.Say(variable.GetSource(),
-          "Atomic update variable '%s' not found in the RHS of the "
-          "assignment statement in an ATOMIC (UPDATE) construct"_err_en_US,
-          variableName);
+          "Atomic update statement should be of form "
+          "`%s = %s operator expr` OR `%s = expr operator %s`"_err_en_US,
+          variableName, variableName, variableName, variableName);
     }
     return common::HasMember<T, AllowedBinaryOperators>;
   }
   return true;
 }
 
-void OmpStructureChecker::CheckAtomicUpdateAssignmentStmt(
+void OmpStructureChecker::CheckAtomicCaptureStmt(
+    const parser::AssignmentStmt &assignmentStmt) {
+  const auto &expr{std::get<parser::Expr>(assignmentStmt.t)};
+  bool isVariable{false};
+  common::visit(
+      common::visitors{
+          [&](const common::Indirection<parser::Designator> &designator) {
+            if (const auto *dataRef = std::get_if<Fortran::parser::DataRef>(
+                    &designator.value().u)) {
+              if (const auto *name =
+                      std::get_if<Fortran::parser::Name>(&dataRef->u)) {
+                if (IsVariableName(*name->symbol)) {
+                  isVariable = true;
+                  if (IsAllocatable(*name->symbol))
+                    context_.Say(name->source,
+                        "%s must not have ALLOCATABLE "
+                        "attribute"_err_en_US,
+                        name->ToString());
+                }
+              }
+            }
+          },
+          [&](const auto &) {},
+      },
+      expr.u);
+  if (!isVariable) {
+    context_.Say(expr.source,
+        "Expected scalar variable "
+        "of intrinsic type on RHS of OPENMP Atomic "
+        " (CAPTURE) assignment statement"_err_en_US);
+  }
+}
+
+void OmpStructureChecker::CheckAtomicWriteStmt(
+    const parser::AssignmentStmt &assignment) {
+  const auto &var{std::get<parser::Variable>(assignment.t)};
+  if (const auto *e{GetExpr(context_, var)}) {
+    for (const Symbol &symbol : evaluate::CollectSymbols(*e)) {
+      if (const parser::Name *name = GetNameIfAllocatableVariable(symbol, var))
+        context_.Say(name->source,
+            "%s must not have ALLOCATABLE "
+            "attribute"_err_en_US,
+            name->ToString());
+    }
+  }
+}
+
+void OmpStructureChecker::CheckAtomicUpdateStmt(
     const parser::AssignmentStmt &assignment) {
   const auto &expr{std::get<parser::Expr>(assignment.t)};
   const auto &var{std::get<parser::Variable>(assignment.t)};
   common::visit(
       common::visitors{
           [&](const common::Indirection<parser::FunctionReference> &x) {
             const auto &procedureDesignator{
                 std::get<parser::ProcedureDesignator>(x.value().v.t)};
common::visit(
           [&](const auto &x) {
             if (!IsOperatorValid(x, var)) {
               context_.Say(expr.source,
                   "Invalid operator in OpenMP ATOMIC (UPDATE) statement"_err_en_US);
             }
           },
       },
       expr.u);
+  if (const auto *e{GetExpr(context_, var)}) {
+    for (const Symbol &symbol : evaluate::CollectSymbols(*e)) {
+      if (const parser::Name *name = GetNameIfAllocatableVariable(symbol, var))
+        context_.Say(name->source,
+            "%s must not have ALLOCATABLE "
+            "attribute"_err_en_US,
+            name->ToString());
+    }
+  }
 }
 
 void OmpStructureChecker::CheckAtomicMemoryOrderClause(
     const parser::OmpAtomicClauseList *leftHandClauseList,
     const parser::OmpAtomicClauseList *rightHandClauseList) {
   int numMemoryOrderClause = 0;
   auto checkForValidMemoryOrderClause =
       [&](const parser::OmpAtomicClauseList *clauseList) {

 
 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(
                 dir.source, llvm::omp::Directive::OMPD_atomic);
-            CheckAtomicUpdateAssignmentStmt(
+            CheckAtomicUpdateStmt(
                 std::get<parser::Statement<parser::AssignmentStmt>>(
                     atomicConstruct.t)
                     .statement);
             CheckAtomicMemoryOrderClause(
                 &std::get<parser::OmpAtomicClauseList>(atomicConstruct.t),
                 nullptr);
             CheckAtomicHintClause(
                 &std::get<parser::OmpAtomicClauseList>(atomicConstruct.t),
                 nullptr);
           },
           [&](const parser::OmpAtomicUpdate &atomicUpdate) {
             const auto &dir{std::get<parser::Verbatim>(atomicUpdate.t)};
             PushContextAndClauseSets(
                 dir.source, llvm::omp::Directive::OMPD_atomic);
-            CheckAtomicUpdateAssignmentStmt(
+            CheckAtomicUpdateStmt(
                 std::get<parser::Statement<parser::AssignmentStmt>>(
                     atomicUpdate.t)
                     .statement);
             CheckAtomicMemoryOrderClause(
                 &std::get<0>(atomicUpdate.t), &std::get<2>(atomicUpdate.t));
             CheckAtomicHintClause(
                 &std::get<0>(atomicUpdate.t), &std::get<2>(atomicUpdate.t));
           },
+          [&](const parser::OmpAtomicRead &atomicRead) {
+            const auto &dir{std::get<parser::Verbatim>(atomicRead.t)};
+            PushContextAndClauseSets(
+                dir.source, llvm::omp::Directive::OMPD_atomic);
+            CheckAtomicMemoryOrderClause(
+                &std::get<0>(atomicRead.t), &std::get<2>(atomicRead.t));
+            CheckAtomicHintClause(
+                &std::get<0>(atomicRead.t), &std::get<2>(atomicRead.t));
+            CheckAtomicCaptureStmt(
+                std::get<parser::Statement<parser::AssignmentStmt>>(
+                    atomicRead.t)
+                    .statement);
+          },
+          [&](const parser::OmpAtomicWrite &atomicWrite) {
+            const auto &dir{std::get<parser::Verbatim>(atomicWrite.t)};
+            PushContextAndClauseSets(
+                dir.source, llvm::omp::Directive::OMPD_atomic);
+            CheckAtomicMemoryOrderClause(
+                &std::get<0>(atomicWrite.t), &std::get<2>(atomicWrite.t));
+            CheckAtomicHintClause(
+                &std::get<0>(atomicWrite.t), &std::get<2>(atomicWrite.t));
+            CheckAtomicWriteStmt(
+                std::get<parser::Statement<parser::AssignmentStmt>>(
+                    atomicWrite.t)
+                    .statement);
+          },
           [&](const auto &atomicConstruct) {
             const auto &dir{std::get<parser::Verbatim>(atomicConstruct.t)};
             PushContextAndClauseSets(
                 dir.source, llvm::omp::Directive::OMPD_atomic);
             CheckAtomicMemoryOrderClause(&std::get<0>(atomicConstruct.t),
                 &std::get<2>(atomicConstruct.t));
             CheckAtomicHintClause(&std::get<0>(atomicConstruct.t),
                 &std::get<2>(atomicConstruct.t));

flang/test/Semantics/OpenMP/omp-atomic-assignment-stmt.f90

+! RUN: %python %S/../test_errors.py %s %flang_fc1 -fopenmp
+! Semantic checks for various assignments related to atomic constructs
+
+program sample
+    use omp_lib
+    integer :: x, v
+    integer :: y(10)
+    integer, allocatable :: k
+
+    !$omp atomic read
+        v = x
+
+    !$omp atomic read
+    !ERROR: No intrinsic or user-defined ASSIGNMENT(=) matches scalar INTEGER(4) and rank 1 array of INTEGER(4)
+    !ERROR: Expected scalar variable of intrinsic type on RHS of OPENMP Atomic  (CAPTURE) assignment statement
+        v = y(1:3)
+
+    !$omp atomic read
+    !ERROR: Expected scalar variable of intrinsic type on RHS of OPENMP Atomic  (CAPTURE) assignment statement
+        v = x * (10 + x)
+
+    !$omp atomic read
+    !ERROR: Expected scalar variable of intrinsic type on RHS of OPENMP Atomic  (CAPTURE) assignment statement
+        v = 4
+
+    !$omp atomic read
+    !ERROR: k must not have ALLOCATABLE attribute
+        v = k
+
+    !$omp atomic write
+    !ERROR: k must not have ALLOCATABLE attribute
+        k = x
+
+    !$omp atomic update 
+    !ERROR: Atomic update statement should be of form `k = k operator expr` OR `k = expr operator k`
+    !ERROR: k must not have ALLOCATABLE attribute
+        k = v + k * (v * k)
+
+    !$omp atomic
+    !ERROR: k must not have ALLOCATABLE attribute
+        k = v * k  
+end program

flang/test/Semantics/OpenMP/omp-atomic02.f90

program OmpAtomic
    a = a/(b + 1)
    !$omp atomic
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    a = a**4
    !$omp atomic
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    c = c//d
    !$omp atomic
-   !ERROR: Atomic update variable 'l' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `l = l operator expr` OR `l = expr operator l`
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    l = a .LT. b
    !$omp atomic
-   !ERROR: Atomic update variable 'l' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `l = l operator expr` OR `l = expr operator l`
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    l = a .LE. b
    !$omp atomic
-   !ERROR: Atomic update variable 'l' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `l = l operator expr` OR `l = expr operator l`
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    l = a .EQ. b
    !$omp atomic
-   !ERROR: Atomic update variable 'l' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `l = l operator expr` OR `l = expr operator l`
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    l = a .NE. b
    !$omp atomic
-   !ERROR: Atomic update variable 'l' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `l = l operator expr` OR `l = expr operator l`
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    l = a .GE. b
    !$omp atomic
-   !ERROR: Atomic update variable 'l' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `l = l operator expr` OR `l = expr operator l`
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    l = a .GT. b
    !$omp atomic
    m = m .AND. n
    !$omp atomic
    m = m .OR. n
    !$omp atomic
    m = m .EQV. n
program OmpAtomic
    a = a/(b + 1)
    !$omp atomic update
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    a = a**4
    !$omp atomic update
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    c = c//d
    !$omp atomic update
-   !ERROR: Atomic update variable 'l' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `l = l operator expr` OR `l = expr operator l`
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    l = a .LT. b
    !$omp atomic update
-   !ERROR: Atomic update variable 'l' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `l = l operator expr` OR `l = expr operator l`
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    l = a .LE. b
    !$omp atomic update
-   !ERROR: Atomic update variable 'l' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `l = l operator expr` OR `l = expr operator l`
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    l = a .EQ. b
    !$omp atomic update
-   !ERROR: Atomic update variable 'l' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `l = l operator expr` OR `l = expr operator l`
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    l = a .GE. b
    !$omp atomic update
-   !ERROR: Atomic update variable 'l' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `l = l operator expr` OR `l = expr operator l`
    !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
    l = a .GT. b
    !$omp atomic update
    m = m .AND. n
    !$omp atomic update
    m = m .OR. n
    !$omp atomic update
    m = m .EQV. n
    !$omp atomic update
    m = m .NEQV. n
    !$omp end parallel
 end program OmpAtomic

flang/test/Semantics/OpenMP/omp-atomic04.f90

program OmpAtomic
    y = 3
    m = .TRUE.
    n = .FALSE.
 !$omp atomic
    x = x + 1
 !$omp atomic
    x = 1 + x
 !$omp atomic
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
    x = y + 1
 !$omp atomic
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
-   x = 1 + y
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   x = 1 + (y + x)
 
 !$omp atomic
-   x = x - 1
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   x = 1 - (10 * (y + x))
 !$omp atomic
    x = 1 - x
 !$omp atomic
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
    x = y - 1
 !$omp atomic
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
    x = 1 - y
 
 !$omp atomic
    x = x*1
 !$omp atomic
    x = 1*x
 !$omp atomic
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
-   x = y*1
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   x = y*(10 + x)
 !$omp atomic
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
-   x = 1*y
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   x = (44 * x) * y
 
 !$omp atomic
    x = x/1
 !$omp atomic
    x = 1/x
 !$omp atomic
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
    x = y/1
 !$omp atomic
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
    x = 1/y
 
 !$omp atomic
    m = m .AND. n
 !$omp atomic
    m = n .AND. m
 !$omp atomic
-   !ERROR: Atomic update variable 'm' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
    m = n .AND. l
 
 !$omp atomic
    m = m .OR. n
 !$omp atomic
    m = n .OR. m
 !$omp atomic
-   !ERROR: Atomic update variable 'm' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
    m = n .OR. l
 
 !$omp atomic
    m = m .EQV. n
 !$omp atomic
    m = n .EQV. m
 !$omp atomic
-   !ERROR: Atomic update variable 'm' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
    m = n .EQV. l
 
 !$omp atomic
    m = m .NEQV. n
 !$omp atomic
    m = n .NEQV. m
 !$omp atomic
-   !ERROR: Atomic update variable 'm' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
    m = n .NEQV. l
 
 !$omp atomic update
    x = x + 1
 !$omp atomic update
    x = 1 + x
 !$omp atomic update
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
    x = y + 1
 !$omp atomic update
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
    x = 1 + y
 
 !$omp atomic update
    x = x - 1
 !$omp atomic update
    x = 1 - x
 !$omp atomic update
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
    x = y - 1
 !$omp atomic update
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
    x = 1 - y
 
 !$omp atomic update
    x = x*1
 !$omp atomic update
    x = 1*x
 !$omp atomic update
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
    x = y*1
 !$omp atomic update
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
    x = 1*y
 
 !$omp atomic update
    x = x/1
 !$omp atomic update
    x = 1/x
 !$omp atomic update
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
-   x = y/1
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   x = max(x, y) + 10
 !$omp atomic update
-   !ERROR: Atomic update variable 'x' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
-   x = 1/y
+   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   x = y * min(x, y)
 
 !$omp atomic update
    m = m .AND. n
 !$omp atomic update
    m = n .AND. m
 !$omp atomic update
-   !ERROR: Atomic update variable 'm' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
    m = n .AND. l
 
 !$omp atomic update
    m = m .OR. n
 !$omp atomic update
    m = n .OR. m
 !$omp atomic update
-   !ERROR: Atomic update variable 'm' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
    m = n .OR. l
 
 !$omp atomic update
    m = m .EQV. n
 !$omp atomic update
    m = n .EQV. m
 !$omp atomic update
-   !ERROR: Atomic update variable 'm' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
    m = n .EQV. l
 
 !$omp atomic update
    m = m .NEQV. n
 !$omp atomic update
    m = n .NEQV. m
 !$omp atomic update
-   !ERROR: Atomic update variable 'm' not found in the RHS of the assignment statement in an ATOMIC (UPDATE) construct
+   !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
    m = n .NEQV. l
 
 end program OmpAtomic