[flang][OpenMP] Added atomic update assignment statement related semantic checks

[NimishMishra]

Summary

This patch adds the following semantic checks:

• None of expr, and expr_list (as applicable) may access the same storage location as x
• Atomic update statement should be of the form x = x operator expr or x = expr operator x or x = intrinsic_procedure(x, expr_list) or x = intrinsic_procedure(expr_list, x)
• expr_list is a comma-separated, non-empty list of scalar expressions. If intrinsic_procedure_name refers to IAND, IOR, or IEOR, exactly one expression must appear in expr_list

For the first check, the number of times the LHS variable's symbol occurs on the RHS of the assignment statement is counted. If >1 occurrences of the symbol occur, error is reported.

For the second check, the position of LHS variable's symbol in the symbol vector of the RHS is checked. If proper format of the atomic update statement is followed, then the symbol should occur either at the front or at the end of the symbol vector.

For the third check, the implementation used the fact that the entire evaluated expression's Rank() becomes non-zero if any symbol with non-zero Rank() is used in that expression. Note that the patch does not check explicitly check "comma-separated" list as well as whether expr_list is non-empty. These are automatically checked by Fortran language semantic checks. For example, Fortran language semantics verify that IAND/IOR/IEOR should have exactly two arguments. Similarly, the semantics verify that MAX/MIN etc should have at least two arguments.

This patch also adds tests for the following checks:

• The expression x operator expr must be numerically equivalent to x operator (expr). This requirement is satisfied if the operators in expr have precedence greater than operator, or by using parentheses around expr or subexpressions of expr.
• The expression expr operator x must be numerically equivalent to (expr) operator x. This requirement is satisfied if the operators in expr have precedence equal to or greater than operator, or by using parentheses around expr or subexpressions of expr.

This patch does not need to separately check for these as this is ensured by either parentheses in the source code or by the interplay of operator precedence and associativity (both of which are handled by Fortran language semantics).

[NimishMishra]

Patch application is failing for recent builds with

Another git process seems to be running in this repository, e.g.
an editor opened by 'git commit'. Please make sure all processes
are terminated then try again. If it still fails, a git process
may have crashed in this repository earlier:
remove the file manually to continue.')
INFO    Syncing local, origin and upstream...
INFO    Backing off reset_repository(...) for 2.8s (git.exc.GitCommandError: Cmd('git') failed due to: exit code(128)
  cmdline: git reset --hard
  stderr: 'fatal: Unable to create '/var/lib/buildkite-agent/builds/llvm-project-fork/.git/index.lock': File exists.

I will re-trigger the build once the issue is resolved.

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

110 ↗

(On Diff #438285)

Checks added.

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

194 ↗

(On Diff #438285)

Checks added.

[TIFitis]

LGTM.

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

if ((exprLeft.value().source.ToString() != variableName) &&
         (exprRight.value().source.ToString() != variableName)) {
       context_.Say(variable.GetSource(),
           "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;
+  return false;
 }
 
 void OmpStructureChecker::CheckAtomicCaptureStmt(
     const parser::AssignmentStmt &assignmentStmt) {
   const auto &var{std::get<parser::Variable>(assignmentStmt.t)};
   const auto &expr{std::get<parser::Expr>(assignmentStmt.t)};
   common::visit(
       common::visitors{
void OmpStructureChecker::CheckAtomicWriteStmt(
   ErrIfLHSAndRHSSymbolsMatch(var, expr);
   ErrIfNonScalarAssignmentStmt(var, expr);
 }
 
 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)};
+  bool isIntrinsicProcedure{false};
+  bool isValidOperator{false};
   common::visit(
       common::visitors{
           [&](const common::Indirection<parser::FunctionReference> &x) {
+            isIntrinsicProcedure = true;
             const auto &procedureDesignator{
                 std::get<parser::ProcedureDesignator>(x.value().v.t)};
             const parser::Name *name{
                 std::get_if<parser::Name>(&procedureDesignator.u)};
             if (name &&
                 !(name->source == "max" || name->source == "min" ||
                     name->source == "iand" || name->source == "ior" ||
                     name->source == "ieor")) {
               context_.Say(expr.source,
                   "Invalid intrinsic procedure name in "
                   "OpenMP ATOMIC (UPDATE) statement"_err_en_US);
-            } else if (name) {
-              bool foundMatch{false};
-              if (auto varDesignatorIndirection =
-                      std::get_if<Fortran::common::Indirection<
-                          Fortran::parser::Designator>>(&var.u)) {
-                const auto &varDesignator = varDesignatorIndirection->value();
-                if (const auto *dataRef = std::get_if<Fortran::parser::DataRef>(
-                        &varDesignator.u)) {
-                  if (const auto *name =
-                          std::get_if<Fortran::parser::Name>(&dataRef->u)) {
-                    const auto &varSymbol = *name->symbol;
-                    if (const auto *e{GetExpr(context_, expr)}) {
-                      for (const Symbol &symbol :
-                          evaluate::CollectSymbols(*e)) {
-                        if (symbol == varSymbol) {
-                          foundMatch = true;
-                          break;
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              if (!foundMatch) {
-                context_.Say(expr.source,
-                    "Atomic update variable '%s' not found in the "
-                    "argument list of intrinsic procedure"_err_en_US,
-                    var.GetSource().ToString());
-              }
             }
           },
           [&](const auto &x) {
             if (!IsOperatorValid(x, var)) {
               context_.Say(expr.source,
-                  "Invalid operator in OpenMP ATOMIC (UPDATE) "
+                  "Invalid or missing operator in atomic update "
                   "statement"_err_en_US);
-            }
+            } else
+              isValidOperator = true;
           },
       },
       expr.u);
+  if (const auto *e{GetExpr(context_, expr)}) {
+    const auto *v{GetExpr(context_, var)};
+    if (e->Rank() != 0)
+      context_.Say(expr.source,
+          "Expected scalar expression "
+          "on the RHS of atomic update assignment "
+          "statement"_err_en_US);
+    if (v->Rank() != 0)
+      context_.Say(var.GetSource(),
+          "Expected scalar variable "
+          "on the LHS of atomic update assignment "
+          "statement"_err_en_US);
+    const Symbol &varSymbol = evaluate::GetSymbolVector(*v).front();
+    int numOfSymbolMatches{0};
+    SymbolVector exprSymbols = evaluate::GetSymbolVector(*e);
+    for (const Symbol &symbol : exprSymbols) {
+      if (varSymbol == symbol)
+        numOfSymbolMatches++;
+    }
+    if (isIntrinsicProcedure) {
+      std::string varName = var.GetSource().ToString();
+      if (numOfSymbolMatches != 1)
+        context_.Say(expr.source,
+            "Intrinsic procedure"
+            " arguments in atomic update statement"
+            " must have exactly one occurence of '%s'"_err_en_US,
+            varName);
+      else if (varSymbol != exprSymbols.front() &&
+          varSymbol != exprSymbols.back())
+        context_.Say(expr.source,
+            "Atomic update statement "
+            "should be of the form `%s = intrinsic_procedure(%s, expr_list)` "
+            "OR `%s = intrinsic_procedure(expr_list, %s)`"_err_en_US,
+            varName, varName, varName, varName);
+    } else if (isValidOperator) {
+      if (numOfSymbolMatches != 1)
+        context_.Say(expr.source,
+            "Exactly one occurence of '%s' "
+            "expected on the RHS of atomic update assignment statement"_err_en_US,
+            var.GetSource().ToString());
+    }
+  }
+
   ErrIfAllocatableVariable(var);
 }
 
 void OmpStructureChecker::CheckAtomicMemoryOrderClause(
     const parser::OmpAtomicClauseList *leftHandClauseList,
     const parser::OmpAtomicClauseList *rightHandClauseList) {
   int numMemoryOrderClause = 0;
   auto checkForValidMemoryOrderClause =

flang/test/Lower/OpenMP/FIR/atomic-update.f90

 !CHECK:    %{{.*}} = arith.constant 1 : i32
 !CHECK:    %[[RESULT:.*]] = arith.subi %[[ARG]], {{.*}} : i32
 !CHECK:    omp.yield(%[[RESULT]] : i32)
 !CHECK:  }
 !CHECK:  omp.atomic.update   memory_order(relaxed) %[[Y]] : !fir.ref<i32> {
 !CHECK:  ^bb0(%[[ARG:.*]]: i32):
 !CHECK:    %[[LOADED_X:.*]] = fir.load %[[X]] : !fir.ref<i32>
 !CHECK:    %[[LOADED_Z:.*]] = fir.load %[[Z]] : !fir.ref<i32>
-!CHECK:    %{{.*}} = arith.cmpi sgt, %[[LOADED_X]], %[[ARG]] : i32
-!CHECK:    %{{.*}} = arith.select %{{.*}}, %[[LOADED_X]], %[[ARG]] : i32
+!CHECK:    %{{.*}} = arith.cmpi sgt, %[[ARG]], %[[LOADED_X]] : i32
+!CHECK:    %{{.*}} = arith.select %{{.*}}, %[[ARG]], %[[LOADED_X]] : i32
 !CHECK:    %{{.*}} = arith.cmpi sgt, %{{.*}}, %[[LOADED_Z]] : i32
 !CHECK:    %[[RESULT:.*]] = arith.select %{{.*}}, %{{.*}}, %[[LOADED_Z]] : i32
 !CHECK:    omp.yield(%[[RESULT]] : i32)
 !CHECK:  }
 !CHECK:  omp.atomic.update   memory_order(relaxed) hint(contended) %[[Z]] : !fir.ref<i32> {
 !CHECK:  ^bb0(%[[ARG:.*]]: i32):
 !CHECK:    %[[LOADED_X:.*]] = fir.load %[[X]] : !fir.ref<i32>
 !CHECK:    %[[RESULT:.*]] = arith.addi %[[ARG]], %[[LOADED_X]] : i32
 !CHECK:    omp.yield(%[[RESULT]] : i32)
 !CHECK:  }
     !$omp atomic relaxed update hint(omp_sync_hint_uncontended)
         x = x - 1
     !$omp atomic update relaxed 
-        y = max(x, y, z)
+        y = max(y, x, z)
     !$omp atomic relaxed hint(omp_sync_hint_contended)
         z = z + x
 
 !CHECK:  omp.atomic.update   memory_order(release) hint(contended) %[[Z]] : !fir.ref<i32> {
 !CHECK:  ^bb0(%[[ARG:.*]]: i32):
 !CHECK:    %{{.*}} = arith.constant 10 : i32
 !CHECK:   %[[RESULT:.*]] = arith.muli {{.*}}, %[[ARG]] : i32
 !CHECK:    omp.yield(%[[RESULT]] : i32)

flang/test/Semantics/OpenMP/atomic-hint-clause.f90

program sample
     !$omp atomic read hint(2)
         y = x    
      
     !ERROR: Hint clause value is not a valid OpenMP synchronization value
     !$omp atomic hint(3)
         y = y + 10
     
     !$omp atomic update hint(5)
-        y = x
+        y = x + y
     
     !ERROR: Hint clause value is not a valid OpenMP synchronization value
     !$omp atomic hint(7) capture
         y = x
         x = y
     !$omp end atomic
    
     !ERROR: Hint clause must have non-negative constant integer expression

flang/test/Semantics/OpenMP/atomic01.f90

!READ
   !ERROR: At most one RELAXED clause can appear on the READ directive
   !$omp atomic relaxed read relaxed
     i = j
 
 !UPDATE
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one SEQ_CST clause can appear on the UPDATE directive
   !$omp atomic seq_cst seq_cst update
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one SEQ_CST clause can appear on the UPDATE directive
   !$omp atomic update seq_cst seq_cst
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one SEQ_CST clause can appear on the UPDATE directive
   !$omp atomic seq_cst update seq_cst
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
 
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one RELEASE clause can appear on the UPDATE directive
   !$omp atomic release release update
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one RELEASE clause can appear on the UPDATE directive
   !$omp atomic update release release
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one RELEASE clause can appear on the UPDATE directive
   !$omp atomic release update release
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
 
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one RELAXED clause can appear on the UPDATE directive
   !$omp atomic relaxed relaxed update
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one RELAXED clause can appear on the UPDATE directive
   !$omp atomic update relaxed relaxed
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one RELAXED clause can appear on the UPDATE directive
   !$omp atomic relaxed update relaxed
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
 
 !CAPTURE
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one SEQ_CST clause can appear on the CAPTURE directive
   !$omp atomic seq_cst seq_cst capture
     i = j
     j = k
!WRITE
   !ERROR: At most one RELAXED clause can appear on the WRITE directive
   !$omp atomic relaxed write relaxed
     i = j
 
 !No atomic-clause
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one RELAXED clause can appear on the ATOMIC directive
   !$omp atomic relaxed relaxed
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one SEQ_CST clause can appear on the ATOMIC directive
   !$omp atomic seq_cst seq_cst
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
   !ERROR: At most one RELEASE clause can appear on the ATOMIC directive
   !$omp atomic release release
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
 
 ! 2.17.7.3
 ! At most one hint clause may appear on the construct.
 
   !ERROR: At most one HINT clause can appear on the READ directive
   !$omp atomic hint(omp_sync_hint_speculative) hint(omp_sync_hint_speculative) read
     i = j
! At most one hint clause may appear on the construct.
   !ERROR: At most one HINT clause can appear on the WRITE directive
   !$omp atomic hint(omp_sync_hint_nonspeculative) write hint(omp_sync_hint_nonspeculative)
     i = j
   !ERROR: At most one HINT clause can appear on the WRITE directive
   !$omp atomic write hint(omp_sync_hint_none) hint (omp_sync_hint_uncontended)
     i = j
   !ERROR: At most one HINT clause can appear on the UPDATE directive
   !$omp atomic hint(omp_sync_hint_contended) hint(omp_sync_hint_speculative) update
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: At most one HINT clause can appear on the UPDATE directive
   !$omp atomic hint(omp_sync_hint_nonspeculative) update hint(omp_sync_hint_nonspeculative)
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: At most one HINT clause can appear on the UPDATE directive
   !$omp atomic update hint(omp_sync_hint_none) hint (omp_sync_hint_uncontended)
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: At most one HINT clause can appear on the ATOMIC directive
   !$omp atomic hint(omp_sync_hint_contended) hint(omp_sync_hint_speculative)
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: At most one HINT clause can appear on the ATOMIC directive
   !$omp atomic hint(omp_sync_hint_none) hint(omp_sync_hint_nonspeculative)
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: At most one HINT clause can appear on the ATOMIC directive
   !$omp atomic hint(omp_sync_hint_none) hint (omp_sync_hint_uncontended)
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
 
   !ERROR: At most one HINT clause can appear on the CAPTURE directive
   !$omp atomic hint(omp_sync_hint_contended) hint(omp_sync_hint_speculative) capture
     i = j
     j = k
   !$omp end atomic
   !ERROR: At most one HINT clause can appear on the CAPTURE directive
!$omp atomic write acquire
     i = j
 
 
 ! 2.17.7.6
 ! If atomic-clause is update or not present then memory-order-clause must not be acq_rel or acquire.
 
   !ERROR: Clause ACQ_REL is not allowed if clause UPDATE appears on the ATOMIC directive
   !$omp atomic acq_rel update
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
   !ERROR: Clause ACQ_REL is not allowed if clause UPDATE appears on the ATOMIC directive
   !$omp atomic update acq_rel
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
 
   !ERROR: Clause ACQUIRE is not allowed if clause UPDATE appears on the ATOMIC directive
   !$omp atomic acquire update
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
 
   !ERROR: Clause ACQUIRE is not allowed if clause UPDATE appears on the ATOMIC directive
   !$omp atomic update acquire
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
 
   !ERROR: Clause ACQ_REL is not allowed on the ATOMIC directive
   !$omp atomic acq_rel
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
 
   !ERROR: Clause ACQUIRE is not allowed on the ATOMIC directive
   !$omp atomic acquire
+  !ERROR: Invalid or missing operator in atomic update statement
     i = j
 end program
 

flang/test/Semantics/OpenMP/atomic02.f90

program OmpAtomic
    a = a + (4*2)
    !$omp atomic
    a = a*(b + 1)
    !$omp atomic
    a = a - 3
    !$omp atomic
    a = a/(b + 1)
    !$omp atomic
-   !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
+   !ERROR: Invalid or missing operator in atomic update statement
    a = a**4
    !$omp atomic
-   !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
+   !ERROR: Invalid or missing operator in atomic update statement
    c = c//d
    !$omp atomic
    !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
+   !ERROR: Invalid or missing operator in atomic update statement
    l = a .LT. b
    !$omp atomic
    !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
+   !ERROR: Invalid or missing operator in atomic update statement
    l = a .LE. b
    !$omp atomic
    !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
+   !ERROR: Invalid or missing operator in atomic update statement
    l = a .EQ. b
    !$omp atomic
    !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
+   !ERROR: Invalid or missing operator in atomic update statement
    l = a .NE. b
    !$omp atomic
    !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
+   !ERROR: Invalid or missing operator in atomic update statement
    l = a .GE. b
    !$omp atomic
    !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
+   !ERROR: Invalid or missing operator in 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
    !$omp atomic
    m = m .NEQV. n
    !$omp atomic update
    a = a + (4*2)
    !$omp atomic update
    a = a*(b + 1)
    !$omp atomic update
    a = a - 3
    !$omp atomic update
    a = a/(b + 1)
    !$omp atomic update
-   !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
+   !ERROR: Invalid or missing operator in atomic update statement
    a = a**4
    !$omp atomic update
-   !ERROR: Invalid operator in OpenMP ATOMIC (UPDATE) statement
+   !ERROR: Invalid or missing operator in atomic update statement
    c = c//d
    !$omp atomic update
    !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
+   !ERROR: Invalid or missing operator in atomic update statement
    l = a .LT. b
    !$omp atomic update
    !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
+   !ERROR: Invalid or missing operator in atomic update statement
    l = a .LE. b
    !$omp atomic update
    !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
+   !ERROR: Invalid or missing operator in atomic update statement
    l = a .EQ. b
    !$omp atomic update
    !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
+   !ERROR: Invalid or missing operator in atomic update statement
    l = a .GE. b
    !$omp atomic update
    !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
+   !ERROR: Invalid or missing operator in 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/atomic03.f90

 !$omp atomic
    y = IEOR(y, 6)
 !$omp atomic
    y = MAX(y, 7)
 !$omp atomic
    y = MIN(y, 8)
 
 !$omp atomic
-   !ERROR: Atomic update variable 'z' not found in the argument list of intrinsic procedure
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'z'
    z = IAND(y, 4)
 !$omp atomic
-   !ERROR: Atomic update variable 'z' not found in the argument list of intrinsic procedure
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'z'
    z = IOR(y, 5)
 !$omp atomic
-   !ERROR: Atomic update variable 'z' not found in the argument list of intrinsic procedure
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'z'
    z = IEOR(y, 6)
 !$omp atomic
-   !ERROR: Atomic update variable 'z' not found in the argument list of intrinsic procedure
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'z'
    z = MAX(y, 7, b, c)
 !$omp atomic
-   !ERROR: Atomic update variable 'z' not found in the argument list of intrinsic procedure
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'z'
    z = MIN(y, 8, a, d)
 
 !$omp atomic
    !ERROR: Invalid intrinsic procedure name in OpenMP ATOMIC (UPDATE) statement
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'y'
    y = FRACTION(x)
 !$omp atomic
    !ERROR: Invalid intrinsic procedure name in OpenMP ATOMIC (UPDATE) statement
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'y'
    y = REAL(x)
 !$omp atomic update
    y = IAND(y, 4)
 !$omp atomic update
    y = IOR(y, 5)
 !$omp atomic update
    y = IEOR(y, 6)
 !$omp atomic update
    y = MAX(y, 7)
 !$omp atomic update
    y = MIN(y, 8)
 
 !$omp atomic update
-   !ERROR: Atomic update variable 'z' not found in the argument list of intrinsic procedure
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'z'
    z = IAND(y, 4)
-!$omp atomic update
-   !ERROR: Atomic update variable 'z' not found in the argument list of intrinsic procedure
+!$omp atomic update 
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'z'
    z = IOR(y, 5)
 !$omp atomic update
-   !ERROR: Atomic update variable 'z' not found in the argument list of intrinsic procedure
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'z'
    z = IEOR(y, 6)
 !$omp atomic update
-   !ERROR: Atomic update variable 'z' not found in the argument list of intrinsic procedure
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'z'
    z = MAX(y, 7)
 !$omp atomic update
-   !ERROR: Atomic update variable 'z' not found in the argument list of intrinsic procedure
+   !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'z'
    z = MIN(y, 8)
 
 !$omp atomic update
    !ERROR: Invalid intrinsic procedure name in OpenMP ATOMIC (UPDATE) statement
    y = MOD(y, 9)
 !$omp atomic update
    !ERROR: Invalid intrinsic procedure name in OpenMP ATOMIC (UPDATE) statement
    x = ABS(x)
 end program OmpAtomic
 
 subroutine conflicting_types()
     type simple
     integer :: z
     end type
     real x
     integer :: y, z
     type(simple) ::s
     z = 1
     !$omp atomic
-    !ERROR: Atomic update variable 'z' not found in the argument list of intrinsic procedure
+    !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'z'
     z = IAND(s%z, 4)
 end subroutine
+
+subroutine more_invalid_atomic_update_stmts()
+    integer :: a, b
+    integer :: k(10)
+    type some_type
+        integer :: m(10)
+    end type
+    type(some_type) :: s
+ 
+    !$omp atomic update
+    !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'a'
+        a = min(a, a, b)
+     
+    !$omp atomic
+    !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'a'
+        a = max(b, a, b, a)
+
+    !$omp atomic
+    !ERROR: Atomic update statement should be of the form `a = intrinsic_procedure(a, expr_list)` OR `a = intrinsic_procedure(expr_list, a)`
+        a = min(b, a, b)
+
+    !$omp atomic
+    !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'a'
+        a = max(b, a, b, a, b)
+    
+    !$omp atomic update
+    !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'y'
+        y = min(z, x)
+     
+    !$omp atomic
+        z = max(z, y)
+
+    !$omp atomic update
+    !ERROR: Expected scalar variable on the LHS of atomic update assignment statement
+    !ERROR: Intrinsic procedure arguments in atomic update statement must have exactly one occurence of 'k'
+        k = max(x, y)
+    
+    !$omp atomic
+    !ERROR: No intrinsic or user-defined ASSIGNMENT(=) matches scalar REAL(4) and rank 1 array of REAL(4)
+    !ERROR: Expected scalar expression on the RHS of atomic update assignment statement
+        x = min(x, k)
+
+    !$omp atomic
+    !ERROR: No intrinsic or user-defined ASSIGNMENT(=) matches scalar REAL(4) and rank 1 array of REAL(4)
+    !ERROR: Expected scalar expression on the RHS of atomic update assignment statement
+        z =z + s%m
+end subroutine

flang/test/Semantics/OpenMP/atomic04.f90

program OmpAtomic
    m = .TRUE.
    n = .FALSE.
 !$omp atomic
    x = x + 1
 !$omp atomic
    x = 1 + x
 !$omp atomic
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
    x = y + 1
 !$omp atomic
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
-   x = 1 + (y + x)
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
+   x = 1 + y
 
 !$omp atomic
-   !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
-   x = 1 - (10 * (y + x))
+   x = x - 1
 !$omp atomic
    x = 1 - x
 !$omp atomic
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
    x = y - 1
 !$omp atomic
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
    x = 1 - y
 
 !$omp atomic
    x = x*1
 !$omp atomic
    x = 1*x
 !$omp atomic
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
-   x = y*(10 + x)
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
+   x = y*1
 !$omp atomic
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
-   x = (44 * x) * y
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
+   x = 1*y
 
 !$omp atomic
    x = x/1
 !$omp atomic
    x = 1/x
 !$omp atomic
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
    x = y/1
 !$omp atomic
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
    x = 1/y
 
 !$omp atomic
    m = m .AND. n
 !$omp atomic
    m = n .AND. m
-!$omp atomic
+!$omp atomic 
    !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
+   !ERROR: Exactly one occurence of 'm' expected on the RHS of atomic update assignment statement
    m = n .AND. l
 
 !$omp atomic
    m = m .OR. n
 !$omp atomic
    m = n .OR. m
-!$omp atomic
+!$omp atomic 
    !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
+   !ERROR: Exactly one occurence of 'm' expected on the RHS of atomic update assignment statement
    m = n .OR. l
 
 !$omp atomic
    m = m .EQV. n
 !$omp atomic
    m = n .EQV. m
 !$omp atomic
    !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
+   !ERROR: Exactly one occurence of 'm' expected on the RHS of atomic update assignment statement
    m = n .EQV. l
 
 !$omp atomic
    m = m .NEQV. n
 !$omp atomic
    m = n .NEQV. m
 !$omp atomic
    !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
+   !ERROR: Exactly one occurence of 'm' expected on the RHS of atomic update assignment statement
    m = n .NEQV. l
 
 !$omp atomic update
    x = x + 1
 !$omp atomic update
    x = 1 + x
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
    x = y + 1
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
    x = 1 + y
 
 !$omp atomic update
    x = x - 1
 !$omp atomic update
    x = 1 - x
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
    x = y - 1
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
    x = 1 - y
 
 !$omp atomic update
    x = x*1
 !$omp atomic update
    x = 1*x
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
    x = y*1
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
    x = 1*y
 
 !$omp atomic update
    x = x/1
 !$omp atomic update
    x = 1/x
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
-   x = max(x, y) + 10
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
+   x = y/1
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
-   x = y * min(x, y)
+   !ERROR: Exactly one occurence of 'x' expected on the RHS of atomic update assignment statement
+   x = 1/y
 
 !$omp atomic update
    m = m .AND. n
 !$omp atomic update
    m = n .AND. m
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
+   !ERROR: Exactly one occurence of 'm' expected on the RHS of atomic update assignment statement
    m = n .AND. l
 
 !$omp atomic update
    m = m .OR. n
 !$omp atomic update
    m = n .OR. m
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
+   !ERROR: Exactly one occurence of 'm' expected on the RHS of atomic update assignment statement
    m = n .OR. l
 
 !$omp atomic update
    m = m .EQV. n
 !$omp atomic update
    m = n .EQV. m
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
+   !ERROR: Exactly one occurence of 'm' expected on the RHS of atomic update assignment statement
    m = n .EQV. l
 
 !$omp atomic update
    m = m .NEQV. n
 !$omp atomic update
    m = n .NEQV. m
 !$omp atomic update
    !ERROR: Atomic update statement should be of form `m = m operator expr` OR `m = expr operator m`
+   !ERROR: Exactly one occurence of 'm' expected on the RHS of atomic update assignment statement
    m = n .NEQV. l
 
 end program OmpAtomic
+
+subroutine more_invalid_atomic_update_stmts()
+    integer :: a, b, c
+    integer :: d(10)
+    real :: x, y, z(10)
+    type some_type
+        real :: m
+        real :: n(10)
+    end type
+    type(some_type) p
+    
+    !$omp atomic
+    !ERROR: Invalid or missing operator in atomic update statement
+        x = x
+
+    !$omp atomic update
+    !ERROR: Invalid or missing operator in atomic update statement
+        x = 1    
+
+    !$omp atomic update
+    !ERROR: Exactly one occurence of 'a' expected on the RHS of atomic update assignment statement
+        a = a * b + a
+
+    !$omp atomic
+    !ERROR: Atomic update statement should be of form `a = a operator expr` OR `a = expr operator a`
+        a = b * (a + 9)
+
+    !$omp atomic update
+    !ERROR: Exactly one occurence of 'a' expected on the RHS of atomic update assignment statement
+        a = a * (a + b)
+
+    !$omp atomic
+    !ERROR: Exactly one occurence of 'a' expected on the RHS of atomic update assignment statement
+        a = (b + a) * a
+
+    !$omp atomic
+    !ERROR: Atomic update statement should be of form `a = a operator expr` OR `a = expr operator a`
+        a = a * b + c
+
+    !$omp atomic update
+    !ERROR: Atomic update statement should be of form `a = a operator expr` OR `a = expr operator a`
+        a = a + b + c
+
+    !$omp atomic
+        a = b * c + a
+
+    !$omp atomic update
+        a = c + b + a
+
+    !$omp atomic
+    !ERROR: No intrinsic or user-defined ASSIGNMENT(=) matches scalar INTEGER(4) and rank 1 array of INTEGER(4)
+    !ERROR: Expected scalar expression on the RHS of atomic update assignment statement
+        a = a + d
+
+    !$omp atomic update
+    !ERROR: No intrinsic or user-defined ASSIGNMENT(=) matches scalar REAL(4) and rank 1 array of REAL(4)
+    !ERROR: Atomic update statement should be of form `x = x operator expr` OR `x = expr operator x`
+    !ERROR: Expected scalar expression on the RHS of atomic update assignment statement
+        x = x * y / z
+
+    !$omp atomic
+    !ERROR: Atomic update statement should be of form `p%m = p%m operator expr` OR `p%m = expr operator p%m`
+    !ERROR: Exactly one occurence of 'p%m' expected on the RHS of atomic update assignment statement
+        p%m = x + y
+
+    !$omp atomic update
+    !ERROR: No intrinsic or user-defined ASSIGNMENT(=) matches scalar REAL(4) and rank 1 array of REAL(4)
+    !ERROR: Expected scalar expression on the RHS of atomic update assignment statement
+    !ERROR: Exactly one occurence of 'p%m' expected on the RHS of atomic update assignment statement
+        p%m = p%m + p%n
+end subroutine

flang/test/Semantics/OpenMP/atomic05.f90

program OmpAtomic
     !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
     !$omp atomic read seq_cst, relaxed
         x = g
     !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
     !$omp atomic write relaxed, release
         x = 2 * 4
     !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
     !$omp atomic update release, seq_cst
+    !ERROR: Invalid or missing operator in atomic update statement
         x = 10
     !ERROR: More than one memory order clause not allowed on OpenMP Atomic construct
     !$omp atomic capture release, seq_cst
         x = g
         g = x * 10
     !$omp end atomic
 end program OmpAtomic

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

program sample
     !$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`
+    !$omp atomic update
     !ERROR: k must not have ALLOCATABLE attribute
-        k = v + k * (v * k)
+        k = k + x * (v * x)
 
     !$omp atomic
     !ERROR: k must not have ALLOCATABLE attribute
         k = v * k  
          
     !$omp atomic write
     !ERROR: RHS expression on atomic assignment statement cannot access 'z%y'
        z%y = x + z%y