[Clang][Sema][OpenMP] Sema support for `atomic compare`

[tianshilei1992]

Summary

This patch adds the Sema support for atomic compare.

[tianshilei1992]

rebase

[ABataev]

sema and parsing tests?

clang/lib/Sema/SemaOpenMP.cpp

10930

static

10937

static

[tianshilei1992]

In D116637#3284773, @ABataev wrote:

sema and parsing tests?

Tests will be in the patch for code gen.

clang/lib/Sema/SemaOpenMP.cpp

10930

Sure, but I usually prefer not to use static for a function in an anonymous name space.

[jdoerfert]

In D116637#3284823, @tianshilei1992 wrote:

In D116637#3284773, @ABataev wrote:

sema and parsing tests?

Tests will be in the patch for code gen.

sema and parsing tests are different from code gen tests.
The former goes here, e.g., look at _messages tests.

[tianshilei1992]

In D116637#3291608, @jdoerfert wrote:

In D116637#3284823, @tianshilei1992 wrote:

In D116637#3284773, @ABataev wrote:

sema and parsing tests?

Tests will be in the patch for code gen.

sema and parsing tests are different from code gen tests.
The former goes here, e.g., look at _messages tests.

I understand, but currently we raise error in Sema so there is no way it can pass a test.

[tianshilei1992]

Fix template instantiation and add one test.
More tests are on the way.

[tianshilei1992]

refine the test

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

11027

body_empty()

11206

QualType

11241

body_empty()

[ABataev]

clang/test/OpenMP/atomic_ast_print.cpp

41

ast print tests are usually successful, better to add/modify special tests for incorrect cases (the ones ending with _messages.cpp)

[tianshilei1992]

@ABataev @jdoerfert I got a question about writing the test. atomic compare is supported from 5.1. Basically we have three ways to guard those atomic compare code:

1. Use macro _OPENMP. This pretty much works with one exception: we don't set the macro for -fopenmp-simd. Then we cannot test -fopenmp-simd.
2. Use those omp50-error and omp50-note which are shown in this patch. -fopenmp-simd can be tested now. However, it doesn't work with -emit-pch. The compiler emits errors that unexpected OpenMP clause 'compare' in directive '#pragma omp atomic' for the lower version tests. If we add -verify to the -emit-pch line, then the pch will not be generated.
3. Put atomic compare tests in another file.

For now only the 3rd method could work, but I'm not sure if there are ways to work around the limitation in the first two approaches.

[tianshilei1992]

clang/test/OpenMP/atomic_ast_print.cpp

41

Yeah, I'll also do that.

[ABataev]

In D116637#3294361, @tianshilei1992 wrote:

@ABataev @jdoerfert I got a question about writing the test. atomic compare is supported from 5.1. Basically we have three ways to guard those atomic compare code:

1. Use macro _OPENMP. This pretty much works with one exception: we don't set the macro for -fopenmp-simd. Then we cannot test -fopenmp-simd.
2. Use those omp50-error and omp50-note which are shown in this patch. -fopenmp-simd can be tested now. However, it doesn't work with -emit-pch. The compiler emits errors that unexpected OpenMP clause 'compare' in directive '#pragma omp atomic' for the lower version tests. If we add -verify to the -emit-pch line, then the pch will not be generated.
3. Put atomic compare tests in another file.

For now only the 3rd method could work, but I'm not sure if there are ways to work around the limitation in the first two approaches.

The second or the 3rd approach.
The tests should work with emit pch and include pch options, otherwise precompiled modules are broken. Need to test it too.

[tianshilei1992]

In D116637#3294390, @ABataev wrote:

In D116637#3294361, @tianshilei1992 wrote:

@ABataev @jdoerfert I got a question about writing the test. atomic compare is supported from 5.1. Basically we have three ways to guard those atomic compare code:

1. Use macro _OPENMP. This pretty much works with one exception: we don't set the macro for -fopenmp-simd. Then we cannot test -fopenmp-simd.
2. Use those omp50-error and omp50-note which are shown in this patch. -fopenmp-simd can be tested now. However, it doesn't work with -emit-pch. The compiler emits errors that unexpected OpenMP clause 'compare' in directive '#pragma omp atomic' for the lower version tests. If we add -verify to the -emit-pch line, then the pch will not be generated.
3. Put atomic compare tests in another file.

For now only the 3rd method could work, but I'm not sure if there are ways to work around the limitation in the first two approaches.

The second or the 3rd approach.
The tests should work with emit pch and include pch options, otherwise precompiled modules are broken. Need to test it too.

For the 2nd method, -verify doesn't work with -emit-pch. Any way to work around it?

[ABataev]

In D116637#3294466, @tianshilei1992 wrote:

In D116637#3294390, @ABataev wrote:

In D116637#3294361, @tianshilei1992 wrote:

@ABataev @jdoerfert I got a question about writing the test. atomic compare is supported from 5.1. Basically we have three ways to guard those atomic compare code:

1. Use macro _OPENMP. This pretty much works with one exception: we don't set the macro for -fopenmp-simd. Then we cannot test -fopenmp-simd.
2. Use those omp50-error and omp50-note which are shown in this patch. -fopenmp-simd can be tested now. However, it doesn't work with -emit-pch. The compiler emits errors that unexpected OpenMP clause 'compare' in directive '#pragma omp atomic' for the lower version tests. If we add -verify to the -emit-pch line, then the pch will not be generated.
3. Put atomic compare tests in another file.

For now only the 3rd method could work, but I'm not sure if there are ways to work around the limitation in the first two approaches.

The second or the 3rd approach.
The tests should work with emit pch and include pch options, otherwise precompiled modules are broken. Need to test it too.

For the 2nd method, -verify doesn't work with -emit-pch. Any way to work around it?

Do not use it with emit-pch, just like in the test you modified

[tianshilei1992]

In D116637#3294474, @ABataev wrote:

In D116637#3294466, @tianshilei1992 wrote:

In D116637#3294390, @ABataev wrote:

In D116637#3294361, @tianshilei1992 wrote:

@ABataev @jdoerfert I got a question about writing the test. atomic compare is supported from 5.1. Basically we have three ways to guard those atomic compare code:

1. Use macro _OPENMP. This pretty much works with one exception: we don't set the macro for -fopenmp-simd. Then we cannot test -fopenmp-simd.
2. Use those omp50-error and omp50-note which are shown in this patch. -fopenmp-simd can be tested now. However, it doesn't work with -emit-pch. The compiler emits errors that unexpected OpenMP clause 'compare' in directive '#pragma omp atomic' for the lower version tests. If we add -verify to the -emit-pch line, then the pch will not be generated.
3. Put atomic compare tests in another file.

For now only the 3rd method could work, but I'm not sure if there are ways to work around the limitation in the first two approaches.

The second or the 3rd approach.
The tests should work with emit pch and include pch options, otherwise precompiled modules are broken. Need to test it too.

For the 2nd method, -verify doesn't work with -emit-pch. Any way to work around it?

Do not use it with emit-pch, just like in the test you modified

Then those tests w/o -fopenmp-version=51, clang emits error "unexpected OpenMP clause 'compare' in directive '#pragma omp atomic'" and exits w/ error code, and the test fails.

[ABataev]

In D116637#3294490, @tianshilei1992 wrote:

In D116637#3294474, @ABataev wrote:

In D116637#3294466, @tianshilei1992 wrote:

In D116637#3294390, @ABataev wrote:

In D116637#3294361, @tianshilei1992 wrote:

@ABataev @jdoerfert I got a question about writing the test. atomic compare is supported from 5.1. Basically we have three ways to guard those atomic compare code:

1. Use macro _OPENMP. This pretty much works with one exception: we don't set the macro for -fopenmp-simd. Then we cannot test -fopenmp-simd.
2. Use those omp50-error and omp50-note which are shown in this patch. -fopenmp-simd can be tested now. However, it doesn't work with -emit-pch. The compiler emits errors that unexpected OpenMP clause 'compare' in directive '#pragma omp atomic' for the lower version tests. If we add -verify to the -emit-pch line, then the pch will not be generated.
3. Put atomic compare tests in another file.

For now only the 3rd method could work, but I'm not sure if there are ways to work around the limitation in the first two approaches.

The second or the 3rd approach.
The tests should work with emit pch and include pch options, otherwise precompiled modules are broken. Need to test it too.

For the 2nd method, -verify doesn't work with -emit-pch. Any way to work around it?

Do not use it with emit-pch, just like in the test you modified

Then those tests w/o -fopenmp-version=51, clang emits error "unexpected OpenMP clause 'compare' in directive '#pragma omp atomic'" and exits w/ error code, and the test fails.

You can define your own macro for OpenMP51 tests and guard the new code with #ifdef value

[tianshilei1992]

In D116637#3294498, @ABataev wrote:

In D116637#3294490, @tianshilei1992 wrote:

In D116637#3294474, @ABataev wrote:

In D116637#3294466, @tianshilei1992 wrote:

In D116637#3294390, @ABataev wrote:

In D116637#3294361, @tianshilei1992 wrote:

@ABataev @jdoerfert I got a question about writing the test. atomic compare is supported from 5.1. Basically we have three ways to guard those atomic compare code:

1. Use macro _OPENMP. This pretty much works with one exception: we don't set the macro for -fopenmp-simd. Then we cannot test -fopenmp-simd.
2. Use those omp50-error and omp50-note which are shown in this patch. -fopenmp-simd can be tested now. However, it doesn't work with -emit-pch. The compiler emits errors that unexpected OpenMP clause 'compare' in directive '#pragma omp atomic' for the lower version tests. If we add -verify to the -emit-pch line, then the pch will not be generated.
3. Put atomic compare tests in another file.

For now only the 3rd method could work, but I'm not sure if there are ways to work around the limitation in the first two approaches.

The second or the 3rd approach.
The tests should work with emit pch and include pch options, otherwise precompiled modules are broken. Need to test it too.

For the 2nd method, -verify doesn't work with -emit-pch. Any way to work around it?

Do not use it with emit-pch, just like in the test you modified

Then those tests w/o -fopenmp-version=51, clang emits error "unexpected OpenMP clause 'compare' in directive '#pragma omp atomic'" and exits w/ error code, and the test fails.

You can define your own macro for OpenMP51 tests and guard the new code with #ifdef value

Oh yeah, that is a good way. Thanks.

[tianshilei1992]

update test

[tianshilei1992]

clang/test/OpenMP/atomic_ast_print.cpp

10

@ABataev But still in this path, we cannot test -emit-pch because we will emit atomic compare is not supported for now anyway, and it cannot be worked around. I'll add it in the codegen patch or in a following patch of codegen.

[tianshilei1992]

clang/test/OpenMP/atomic_ast_print.cpp

926

I cannot figure out why I have to add this line and it's not needed before.

[jdoerfert]

clang/test/OpenMP/atomic_ast_print.cpp

926

it's caused by the error.

[tianshilei1992]

clang/test/OpenMP/atomic_ast_print.cpp

926

Aha, I see. Thanks.

[tianshilei1992]

add more tests

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

11206

Do you mean by not using auto?

[tianshilei1992]

add final test and fix comments

[ABataev]

clang/test/OpenMP/atomic_ast_print.cpp

10

Why? It should be tested.

// RUN: %clang_cc1 -fopenmp -DOMP51 -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -DOMP51 -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s

Could you try this?

[tianshilei1992]

clang/test/OpenMP/atomic_ast_print.cpp

10

I did, but since the first command can emit errors, the test fails. It should be tested. I'll add it back when we don't emit error in Sema.

[ABataev]

clang/test/OpenMP/atomic_ast_print.cpp

10

Ah, I see. Add a TODO to the tests to add pch testing.

[tianshilei1992]

add TODO for PCH test

[ABataev]

clang/test/OpenMP/atomic_ast_print.cpp

42

Try to add -fsyntax-only in RUN to avoid error message in the test

[tianshilei1992]

clang/test/OpenMP/atomic_ast_print.cpp

42

Adding -fsyntax-only will not print the AST, just the error message.

➜  clang -cc1 -x c++ -fopenmp -fopenmp-version=51 -ast-print atomic.cpp
atomic.cpp:12:20: error: atomic compare is not supported for now
#pragma omp atomic compare
                   ^
class C {
    int x;
public:
    int &val() {
        return this->x;
    }
};
void compare() {
    C x;
    C e;
    C d;
    #pragma omp atomic compare
        if (x.val() == e.val())
            x.val() = d.val();
}
1 error generated.
➜  clang -cc1 -x c++ -fopenmp -fopenmp-version=51 -ast-print -fsyntax-only atomic.cpp
atomic.cpp:12:20: error: atomic compare is not supported for now
#pragma omp atomic compare
                   ^
1 error generated.

[ABataev]

clang/test/OpenMP/atomic_ast_print.cpp

42

Ah, yes. Can you move the error message to codegen from Sema to avoid all these problems?

[tianshilei1992]

clang/test/OpenMP/atomic_ast_print.cpp

42

Do we support error message in code gen? I didn't see similar code in clang/lib/CodeGen/CGStmtOpenMP.cpp.

[ABataev]

clang/test/OpenMP/atomic_ast_print.cpp

42

Check lib/CodeGen/CGOpenMPRuntime.cpp, getDiagnostics().Report() calls.

[tianshilei1992]

move error to code gen and add missing tests

[ABataev]

LG

[cmtice]

This commit is causing some of our builds to fail with these errors:

clang/lib/Sema/SemaOpenMP.cpp:11372:9: error: unused variable 'D' [-Werror,-Wunused-variable]

Expr *D = nullptr;
      ^

clang/lib/Sema/SemaOpenMP.cpp:11373:9: error: unused variable 'CE' [-Werror,-Wunused-variable]

Expr *CE = nullptr;
      ^

2 errors generated.

Would you please fix this?

[tianshilei1992]

In D116637#3297387, @cmtice wrote:

This commit is causing some of our builds to fail with these errors:

clang/lib/Sema/SemaOpenMP.cpp:11372:9: error: unused variable 'D' [-Werror,-Wunused-variable]

Expr *D = nullptr;
      ^

clang/lib/Sema/SemaOpenMP.cpp:11373:9: error: unused variable 'CE' [-Werror,-Wunused-variable]

Expr *CE = nullptr;
      ^

2 errors generated.

Would you please fix this?

Yeah, I noticed that. It's been fixed now. Thanks.

[kda]

This still seems to be breaking sanitizers fast: https://lab.llvm.org/buildbot/#/builders/5/builds/18563

To reproduce these results:
https://github.com/google/sanitizers/wiki/SanitizerBotReproduceBuild

[tianshilei1992]

In D116637#3297785, @kda wrote:

This still seems to be breaking sanitizers fast: https://lab.llvm.org/buildbot/#/builders/5/builds/18563

To reproduce these results:
https://github.com/google/sanitizers/wiki/SanitizerBotReproduceBuild

I pushed a fix about half an hour ago. It should fix the issue. Thanks.

[jdoerfert]

In D116637#3297790, @tianshilei1992 wrote:

In D116637#3297785, @kda wrote:

This still seems to be breaking sanitizers fast: https://lab.llvm.org/buildbot/#/builders/5/builds/18563

To reproduce these results:
https://github.com/google/sanitizers/wiki/SanitizerBotReproduceBuild

I pushed a fix about half an hour ago. It should fix the issue. Thanks.

I doubt it is fixed. Also, please reference the phab review in a fix to make it easier to find it.

[tianshilei1992]

In D116637#3297833, @jdoerfert wrote:

In D116637#3297790, @tianshilei1992 wrote:

In D116637#3297785, @kda wrote:

This still seems to be breaking sanitizers fast: https://lab.llvm.org/buildbot/#/builders/5/builds/18563

To reproduce these results:
https://github.com/google/sanitizers/wiki/SanitizerBotReproduceBuild

I pushed a fix about half an hour ago. It should fix the issue. Thanks.

I doubt it is fixed. Also, please reference the phab review in a fix to make it easier to find it.

It will. The BuildBot link here is still the one for this patch. It is fixed in b8ec430de71766d9a35a6b737c8a789c0c7cf812.

[cmtice]

When building/running third_party/llvm/llvm-project/clang/test/OpenMP/atomic_messages.c and third_party/llvm/llvm-project/clang/test/OpenMP/atomic_ast_print.cpp, we get use-of-uninitialized-variable error messages:

SUMMARY: MemorySanitizer: use-of-uninitialized-value third_party/llvm/llvm-project/clang/lib/Sema/SemaOpenMP.cpp:11214:40 in (anonymous namespace)::OpenMPAtomicCompareChecker::checkType((anonymous namespace)::OpenMPAtomicCompareChecker::ErrorInfoTy&) const::$_57::operator()(clang::Expr const*, llvm::omp::OMPAtomicCompareOp, bool) const
Exiting

You should probably look into this.

[tianshilei1992]

In D116637#3298635, @cmtice wrote:

When building/running third_party/llvm/llvm-project/clang/test/OpenMP/atomic_messages.c and third_party/llvm/llvm-project/clang/test/OpenMP/atomic_ast_print.cpp, we get use-of-uninitialized-variable error messages:

SUMMARY: MemorySanitizer: use-of-uninitialized-value third_party/llvm/llvm-project/clang/lib/Sema/SemaOpenMP.cpp:11214:40 in (anonymous namespace)::OpenMPAtomicCompareChecker::checkType((anonymous namespace)::OpenMPAtomicCompareChecker::ErrorInfoTy&) const::$_57::operator()(clang::Expr const*, llvm::omp::OMPAtomicCompareOp, bool) const
Exiting

You should probably look into this.

Thanks! It has been fixed.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_omp_atomic_capture_not_expression_statement : Error<
   " where x and v are both lvalue expressions with scalar type">;
 def err_omp_atomic_capture_not_compound_statement : Error<
   "the statement for 'atomic capture' must be a compound statement of form '{v = x; x binop= expr;}', '{x binop= expr; v = x;}',"
   " '{v = x; x = x binop expr;}', '{v = x; x = expr binop x;}', '{x = x binop expr; v = x;}', '{x = expr binop x; v = x;}' or '{v = x; x = expr;}',"
   " '{v = x; x++;}', '{v = x; ++x;}', '{++x; v = x;}', '{x++; v = x;}', '{v = x; x--;}', '{v = x; --x;}', '{--x; v = x;}', '{x--; v = x;}'"
   " where x is an lvalue expression with scalar type">;
 def note_omp_atomic_capture: Note<
   "%select{expected assignment expression|expected compound statement|expected exactly two expression statements|expected in right hand side of the first expression}0">;
+def err_omp_atomic_compare : Error<
+  "the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}',"
+  " '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}',"
+  " 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type,"
+  " and 'ordop' is one of '<' or '>'.">;
+def note_omp_atomic_compare: Note<
+  "%select{expected compound statement|expected exactly one expression statement|expected assignment statement|expected conditional operator|expect result value to be at false expression|"
+  "expect binary operator in conditional expression|expect '<', '>' or '==' as order operator|expect comparison in a form of 'x == e', 'e == x', 'x ordop expr', or 'expr ordop x'|"
+  "expect lvalue for result value|expect scalar value|expect integer value}0">;
 def err_omp_atomic_several_clauses : Error<
   "directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause">;
 def err_omp_several_mem_order_clauses : Error<
   "directive '#pragma omp %0' cannot contain more than one %select{'seq_cst', 'relaxed', |}1'acq_rel', 'acquire' or 'release' clause">;
 def err_omp_atomic_incompatible_mem_order_clause : Error<
   "directive '#pragma omp atomic%select{ %0|}1' cannot be used with '%2' clause">;
 def note_omp_previous_mem_order_clause : Note<
   "'%0' clause used here">;

clang/lib/CodeGen/CGStmtOpenMP.cpp

static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
   case OMPC_unknown:
   case OMPC_update:
     emitOMPAtomicUpdateExpr(CGF, AO, X, E, UE, IsXLHSInRHSPart, Loc);
     break;
   case OMPC_capture:
     emitOMPAtomicCaptureExpr(CGF, AO, IsPostfixUpdate, V, X, E, UE,
                              IsXLHSInRHSPart, Loc);
     break;
-  case OMPC_compare:
-    // Do nothing here as we already emit an error.
+  case OMPC_compare: {
+    // Emit an error here.
+    unsigned DiagID = CGF.CGM.getDiags().getCustomDiagID(
+        DiagnosticsEngine::Error, "'atomic compare' is not supported for now");
+    CGF.CGM.getDiags().Report(DiagID);
     break;
+  }
   case OMPC_if:
   case OMPC_final:
   case OMPC_num_threads:
   case OMPC_private:
   case OMPC_firstprivate:
   case OMPC_lastprivate:
   case OMPC_reduction:
   case OMPC_task_reduction:

clang/lib/Sema/SemaOpenMP.cpp

if (ErrorFound == NoError && E && X) {
     Update = SemaRef.PerformImplicitConversion(Update.get(), X->getType(),
                                                Sema::AA_Casting);
     if (Update.isInvalid())
       return true;
     UpdateExpr = Update.get();
   }
   return ErrorFound != NoError;
 }
+
+/// Get the node id of the fixed point of an expression \a S.
+llvm::FoldingSetNodeID getNodeId(ASTContext &Context, const Expr *S) {
+  llvm::FoldingSetNodeID Id;
+  S->IgnoreParenImpCasts()->Profile(Id, Context, true);
+  return Id;
+}
+
+/// Check if two expressions are same.
+bool checkIfTwoExprsAreSame(ASTContext &Context, const Expr *LHS,
+                            const Expr *RHS) {
+  return getNodeId(Context, LHS) == getNodeId(Context, RHS);
+}
+
+class OpenMPAtomicCompareChecker {
+public:
+  /// All kinds of errors that can occur in `atomic compare`
+  enum ErrorTy {
+    /// Empty compound statement.
+    NoStmt = 0,
+    /// More than one statement in a compound statement.
+    MoreThanOneStmt,
+    /// Not an assignment binary operator.
+    NotAnAssignment,
+    /// Not a conditional operator.
+    NotCondOp,
+    /// Wrong false expr. According to the spec, 'x' should be at the false
+    /// expression of a conditional expression.
+    WrongFalseExpr,
+    /// The condition of a conditional expression is not a binary operator.
+    NotABinaryOp,
+    /// Invalid binary operator (not <, >, or ==).
+    InvalidBinaryOp,
+    /// Invalid comparison (not x == e, e == x, x ordop expr, or expr ordop x).
+    InvalidComparison,
+    /// X is not a lvalue.
+    XNotLValue,
+    /// Not a scalar.
+    NotScalar,
+    /// Not an integer.
+    NotInteger,
+    /// No error.
+    NoError,
+  };
+
+  struct ErrorInfoTy {
+    ErrorTy Error;
+    SourceLocation ErrorLoc;
+    SourceRange ErrorRange;
+    SourceLocation NoteLoc;
+    SourceRange NoteRange;
+  };
+
+  OpenMPAtomicCompareChecker(Sema &S) : ContextRef(S.getASTContext()) {}
+
+  /// Check if statement \a S is valid for <tt>atomic compare</tt>.
+  bool checkStmt(Stmt *S, ErrorInfoTy &ErrorInfo);
+
+  Expr *getX() const { return X; }
+  Expr *getE() const { return E; }
+  Expr *getD() const { return D; }
+  Expr *getCond() const { return C; }
+  bool isXBinopExpr() const { return IsXBinopExpr; }
+
+private:
+  /// Reference to ASTContext
+  ASTContext &ContextRef;
+  /// 'x' lvalue part of the source atomic expression.
+  Expr *X = nullptr;
+  /// 'expr' or 'e' rvalue part of the source atomic expression.
+  Expr *E = nullptr;
+  /// 'd' rvalue part of the source atomic expression.
+  Expr *D = nullptr;
+  /// 'cond' part of the source atomic expression. It is in one of the following
+  /// forms:
+  /// expr ordop x
+  /// x ordop expr
+  /// x == e
+  /// e == x
+  Expr *C = nullptr;
+  /// True if the cond expr is in the form of 'x ordop expr'.
+  bool IsXBinopExpr = true;
+  /// The atomic compare operator.
+  OMPAtomicCompareOp Op;
+
+  /// Check if it is a valid conditional update statement (cond-update-stmt).
+  bool checkCondUpdateStmt(IfStmt *S, ErrorInfoTy &ErrorInfo);
+
+  /// Check if it is a valid conditional expression statement (cond-expr-stmt).
+  bool checkCondExprStmt(Stmt *S, ErrorInfoTy &ErrorInfo);
+
+  /// Check if all captured values have right type.
+  bool checkType(ErrorInfoTy &ErrorInfo) const;
+};
+
+bool OpenMPAtomicCompareChecker::checkCondUpdateStmt(IfStmt *S,
+                                                     ErrorInfoTy &ErrorInfo) {
+  auto *Then = S->getThen();
+  if (auto *CS = dyn_cast<CompoundStmt>(Then)) {
+    if (CS->body_empty()) {
+      ErrorInfo.Error = ErrorTy::NoStmt;
+      ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = CS->getBeginLoc();
+      ErrorInfo.ErrorRange = ErrorInfo.NoteRange = CS->getSourceRange();
+      return false;
+    }
+    if (CS->size() > 1) {
+      ErrorInfo.Error = ErrorTy::MoreThanOneStmt;
+      ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = CS->getBeginLoc();
+      ErrorInfo.ErrorRange = ErrorInfo.NoteRange = S->getSourceRange();
+      return false;
+    }
+    Then = CS->body_front();
+  }
+
+  auto *BO = dyn_cast<BinaryOperator>(Then);
+  if (!BO) {
+    ErrorInfo.Error = ErrorTy::NotAnAssignment;
+    ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = Then->getBeginLoc();
+    ErrorInfo.ErrorRange = ErrorInfo.NoteRange = Then->getSourceRange();
+    return false;
+  }
+  if (BO->getOpcode() != BO_Assign) {
+    ErrorInfo.Error = ErrorTy::NotAnAssignment;
+    ErrorInfo.ErrorLoc = BO->getExprLoc();
+    ErrorInfo.NoteLoc = BO->getOperatorLoc();
+    ErrorInfo.ErrorRange = ErrorInfo.NoteRange = BO->getSourceRange();
+    return false;
+  }
+
+  X = BO->getLHS();
+
+  auto *Cond = dyn_cast<BinaryOperator>(S->getCond());
+  if (!Cond) {
+    ErrorInfo.Error = ErrorTy::NotABinaryOp;
+    ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = S->getCond()->getExprLoc();
+    ErrorInfo.ErrorRange = ErrorInfo.NoteRange = S->getCond()->getSourceRange();
+    return false;
+  }
+  if (Cond->getOpcode() != BO_EQ && Cond->getOpcode() != BO_LT &&
+      Cond->getOpcode() != BO_GT) {
+    ErrorInfo.Error = ErrorTy::InvalidBinaryOp;
+    ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = Cond->getExprLoc();
+    ErrorInfo.ErrorRange = ErrorInfo.NoteRange = Cond->getSourceRange();
+    return false;
+  }
+
+  if (Cond->getOpcode() == BO_EQ) {
+    C = Cond;
+    D = BO->getRHS();
+    if (checkIfTwoExprsAreSame(ContextRef, X, Cond->getLHS())) {
+      E = Cond->getRHS();
+    } else if (checkIfTwoExprsAreSame(ContextRef, X, Cond->getRHS())) {
+      E = Cond->getLHS();
+    } else {
+      ErrorInfo.Error = ErrorTy::InvalidComparison;
+      ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = Cond->getExprLoc();
+      ErrorInfo.ErrorRange = ErrorInfo.NoteRange = Cond->getSourceRange();
+      return false;
+    }
+  } else {
+    E = BO->getRHS();
+    if (checkIfTwoExprsAreSame(ContextRef, X, Cond->getLHS()) &&
+        checkIfTwoExprsAreSame(ContextRef, E, Cond->getRHS())) {
+      C = Cond;
+    } else if (checkIfTwoExprsAreSame(ContextRef, E, Cond->getLHS()) &&
+               checkIfTwoExprsAreSame(ContextRef, X, Cond->getRHS())) {
+      C = Cond;
+      IsXBinopExpr = false;
+    } else {
+      ErrorInfo.Error = ErrorTy::InvalidComparison;
+      ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = Cond->getExprLoc();
+      ErrorInfo.ErrorRange = ErrorInfo.NoteRange = Cond->getSourceRange();
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool OpenMPAtomicCompareChecker::checkCondExprStmt(Stmt *S,
+                                                   ErrorInfoTy &ErrorInfo) {
+  auto *BO = dyn_cast<BinaryOperator>(S);
+  if (!BO) {
+    ErrorInfo.Error = ErrorTy::NotAnAssignment;
+    ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = S->getBeginLoc();
+    ErrorInfo.ErrorRange = ErrorInfo.NoteRange = S->getSourceRange();
+    return false;
+  }
+  if (BO->getOpcode() != BO_Assign) {
+    ErrorInfo.Error = ErrorTy::NotAnAssignment;
+    ErrorInfo.ErrorLoc = BO->getExprLoc();
+    ErrorInfo.NoteLoc = BO->getOperatorLoc();
+    ErrorInfo.ErrorRange = ErrorInfo.NoteRange = BO->getSourceRange();
+    return false;
+  }
+
+  X = BO->getLHS();
+
+  auto *CO = dyn_cast<ConditionalOperator>(BO->getRHS()->IgnoreParenImpCasts());
+  if (!CO) {
+    ErrorInfo.Error = ErrorTy::NotCondOp;
+    ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = BO->getRHS()->getExprLoc();
+    ErrorInfo.ErrorRange = ErrorInfo.NoteRange = BO->getRHS()->getSourceRange();
+    return false;
+  }
+
+  if (!checkIfTwoExprsAreSame(ContextRef, X, CO->getFalseExpr())) {
+    ErrorInfo.Error = ErrorTy::WrongFalseExpr;
+    ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = CO->getFalseExpr()->getExprLoc();
+    ErrorInfo.ErrorRange = ErrorInfo.NoteRange =
+        CO->getFalseExpr()->getSourceRange();
+    return false;
+  }
+
+  auto *Cond = dyn_cast<BinaryOperator>(CO->getCond());
+  if (!Cond) {
+    ErrorInfo.Error = ErrorTy::NotABinaryOp;
+    ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = CO->getCond()->getExprLoc();
+    ErrorInfo.ErrorRange = ErrorInfo.NoteRange =
+        CO->getCond()->getSourceRange();
+    return false;
+  }
+
+  if (Cond->getOpcode() != BO_EQ && Cond->getOpcode() != BO_LT &&
+      Cond->getOpcode() != BO_GT) {
+    ErrorInfo.Error = ErrorTy::InvalidBinaryOp;
+    ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = Cond->getExprLoc();
+    ErrorInfo.ErrorRange = ErrorInfo.NoteRange = Cond->getSourceRange();
+    return false;
+  }
+
+  if (Cond->getOpcode() == BO_EQ) {
+    C = Cond;
+    D = CO->getTrueExpr();
+    if (checkIfTwoExprsAreSame(ContextRef, X, Cond->getLHS())) {
+      E = Cond->getRHS();
+    } else if (checkIfTwoExprsAreSame(ContextRef, X, Cond->getRHS())) {
+      E = Cond->getLHS();
+    } else {
+      ErrorInfo.Error = ErrorTy::InvalidComparison;
+      ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = Cond->getExprLoc();
+      ErrorInfo.ErrorRange = ErrorInfo.NoteRange = Cond->getSourceRange();
+      return false;
+    }
+  } else {
+    E = CO->getTrueExpr();
+    if (checkIfTwoExprsAreSame(ContextRef, X, Cond->getLHS()) &&
+        checkIfTwoExprsAreSame(ContextRef, E, Cond->getRHS())) {
+      C = Cond;
+    } else if (checkIfTwoExprsAreSame(ContextRef, E, Cond->getLHS()) &&
+               checkIfTwoExprsAreSame(ContextRef, X, Cond->getRHS())) {
+      C = Cond;
+      IsXBinopExpr = false;
+    } else {
+      ErrorInfo.Error = ErrorTy::InvalidComparison;
+      ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = Cond->getExprLoc();
+      ErrorInfo.ErrorRange = ErrorInfo.NoteRange = Cond->getSourceRange();
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool OpenMPAtomicCompareChecker::checkType(ErrorInfoTy &ErrorInfo) const {
+  // 'x' and 'e' cannot be nullptr
+  assert(X && E && "X and E cannot be nullptr");
+
+  auto CheckValue = [&ErrorInfo](const Expr *E, OMPAtomicCompareOp Op,
+                                 bool ShouldBeLValue) {
+    if (ShouldBeLValue && !E->isLValue()) {
+      ErrorInfo.Error = ErrorTy::XNotLValue;
+      ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = E->getExprLoc();
+      ErrorInfo.ErrorRange = ErrorInfo.NoteRange = E->getSourceRange();
+      return false;
+    }
+
+    if (!E->isInstantiationDependent()) {
+      QualType QTy = E->getType();
+      if (!QTy->isScalarType()) {
+        ErrorInfo.Error = ErrorTy::NotScalar;
+        ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = E->getExprLoc();
+        ErrorInfo.ErrorRange = ErrorInfo.NoteRange = E->getSourceRange();
+        return false;
+      }
+
+      if (Op != OMPAtomicCompareOp::EQ && !QTy->isIntegerType()) {
+        ErrorInfo.Error = ErrorTy::NotInteger;
+        ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = E->getExprLoc();
+        ErrorInfo.ErrorRange = ErrorInfo.NoteRange = E->getSourceRange();
+        return false;
+      }
+    }
+
+    return true;
+  };
+
+  if (!CheckValue(X, Op, true))
+    return false;
+
+  if (!CheckValue(E, Op, false))
+    return false;
+
+  if (D && !CheckValue(D, Op, false))
+    return false;
+
+  return true;
+}
+
+bool OpenMPAtomicCompareChecker::checkStmt(
+    Stmt *S, OpenMPAtomicCompareChecker::ErrorInfoTy &ErrorInfo) {
+  auto *CS = dyn_cast<CompoundStmt>(S);
+  if (CS) {
+    if (CS->body_empty()) {
+      ErrorInfo.Error = ErrorTy::NoStmt;
+      ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = CS->getBeginLoc();
+      ErrorInfo.ErrorRange = ErrorInfo.NoteRange = CS->getSourceRange();
+      return false;
+    }
+
+    if (CS->size() != 1) {
+      ErrorInfo.Error = ErrorTy::MoreThanOneStmt;
+      ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = CS->getBeginLoc();
+      ErrorInfo.ErrorRange = ErrorInfo.NoteRange = CS->getSourceRange();
+      return false;
+    }
+    S = CS->body_front();
+  }
+
+  auto Res = false;
+
+  if (auto *IS = dyn_cast<IfStmt>(S)) {
+    // Check if the statement is in one of the following forms
+    // (cond-update-stmt):
+    // if (expr ordop x) { x = expr; }
+    // if (x ordop expr) { x = expr; }
+    // if (x == e) { x = d; }
+    Res = checkCondUpdateStmt(IS, ErrorInfo);
+  } else {
+    // Check if the statement is in one of the following forms (cond-expr-stmt):
+    // x = expr ordop x ? expr : x;
+    // x = x ordop expr ? expr : x;
+    // x = x == e ? d : x;
+    Res = checkCondExprStmt(S, ErrorInfo);
+  }
+
+  if (!Res)
+    return false;
+
+  return checkType(ErrorInfo);
+}
 } // namespace
 
 StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
                                             Stmt *AStmt,
                                             SourceLocation StartLoc,
                                             SourceLocation EndLoc) {
   // Register location of the first atomic directive.
   DSAStack->addAtomicDirectiveLoc(StartLoc);
StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
   Stmt *Body = AStmt;
   if (auto *EWC = dyn_cast<ExprWithCleanups>(Body))
     Body = EWC->getSubExpr();
 
   Expr *X = nullptr;
   Expr *V = nullptr;
   Expr *E = nullptr;
   Expr *UE = nullptr;
+  Expr *D = nullptr;
+  Expr *CE = nullptr;
   bool IsXLHSInRHSPart = false;
   bool IsPostfixUpdate = false;
   // OpenMP [2.12.6, atomic Construct]
   // In the next expressions:
   // * x and v (as applicable) are both l-value expressions with scalar type.
   // * During the execution of an atomic region, multiple syntactic
   // occurrences of x must designate the same storage location.
   // * Neither of v and expr (as applicable) may access the storage location
if (ErrorFound != NoError) {
       Diag(ErrorLoc, diag::err_omp_atomic_capture_not_compound_statement)
           << ErrorRange;
       Diag(NoteLoc, diag::note_omp_atomic_capture) << ErrorFound << NoteRange;
       return StmtError();
     }
     if (CurContext->isDependentContext())
       UE = V = E = X = nullptr;
   } else if (AtomicKind == OMPC_compare) {
-    // TODO: For now we emit an error here and in emitOMPAtomicExpr we ignore
-    // code gen.
-    unsigned DiagID = Diags.getCustomDiagID(
-        DiagnosticsEngine::Error, "atomic compare is not supported for now");
-    Diag(AtomicKindLoc, DiagID);
+    OpenMPAtomicCompareChecker::ErrorInfoTy ErrorInfo;
+    OpenMPAtomicCompareChecker Checker(*this);
+    if (!Checker.checkStmt(Body, ErrorInfo)) {
+      Diag(ErrorInfo.ErrorLoc, diag::err_omp_atomic_compare)
+          << ErrorInfo.ErrorRange;
+      Diag(ErrorInfo.NoteLoc, diag::note_omp_atomic_compare)
+          << ErrorInfo.Error << ErrorInfo.NoteRange;
+      return StmtError();
+    }
+    // TODO: We don't set X, D, E, etc. here because in code gen we will emit
+    // error directly.
   }
 
   setFunctionHasBranchProtectedScope();
 
   return OMPAtomicDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
                                     X, V, E, UE, IsXLHSInRHSPart,
                                     IsPostfixUpdate);
 }

clang/test/OpenMP/atomic_ast_print.cpp

 // RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s
 // RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -ast-print %s | FileCheck %s
 // RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -emit-pch -o %t %s
 // RUN: %clang_cc1 -fopenmp-simd -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
+
+// RUN: %clang_cc1 -DOMP51 -verify -fopenmp -fopenmp-version=51 -ast-print %s | FileCheck --check-prefixes=CHECK,CHECK-51 %s
+// RUN: %clang_cc1 -DOMP51 -fopenmp -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
+// RUN: %clang_cc1 -DOMP51 -fopenmp -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck --check-prefixes=CHECK,CHECK-51 %s
+
+// RUN: %clang_cc1 -DOMP51 -verify -fopenmp-simd -fopenmp-version=51 -ast-print %s | FileCheck --check-prefixes=CHECK,CHECK-51 %s
+// RUN: %clang_cc1 -DOMP51 -fopenmp-simd -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
+// RUN: %clang_cc1 -DOMP51 -fopenmp-simd -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck --check-prefixes=CHECK,CHECK-51 %s
 // expected-no-diagnostics
 
 #ifndef HEADER
 #define HEADER
 
 template <class T>
 T foo(T argc) {
+  T c = T();
   T b = T();
   T a = T();
 #pragma omp atomic
   a++;
 #pragma omp atomic read
   a = argc;
 #pragma omp atomic write
   a = argc + argc;
 #pragma omp atomic update
   a = a + argc;
 #pragma omp atomic capture
   a = b++;
 #pragma omp atomic capture
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare
+  { a = a > b ? b : a; }
+#pragma omp atomic compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic seq_cst
   a++;
 #pragma omp atomic read seq_cst
   a = argc;
 #pragma omp atomic seq_cst write
   a = argc + argc;
 #pragma omp atomic update seq_cst
   a = a + argc;
 #pragma omp atomic seq_cst capture
   a = b++;
 #pragma omp atomic capture seq_cst
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare seq_cst
+  { a = a > b ? b : a; }
+#pragma omp atomic seq_cst compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare seq_cst
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic
   a++;
 #pragma omp atomic read
   a = argc;
 #pragma omp atomic write
   a = argc + argc;
 #pragma omp atomic update
   a = a + argc;
 #pragma omp atomic acq_rel capture
   a = b++;
 #pragma omp atomic capture acq_rel
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare acq_rel
+  { a = a > b ? b : a; }
+#pragma omp atomic acq_rel compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare acq_rel
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic
   a++;
 #pragma omp atomic read acquire
   a = argc;
 #pragma omp atomic write
   a = argc + argc;
 #pragma omp atomic update
   a = a + argc;
 #pragma omp atomic acquire capture
   a = b++;
 #pragma omp atomic capture acquire
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare acquire
+  { a = a > b ? b : a; }
+#pragma omp atomic acquire compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare acquire
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic release
   a++;
 #pragma omp atomic read
   a = argc;
 #pragma omp atomic release write
   a = argc + argc;
 #pragma omp atomic update release
   a = a + argc;
 #pragma omp atomic release capture
   a = b++;
 #pragma omp atomic capture release
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare release
+  { a = a > b ? b : a; }
+#pragma omp atomic release compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare release
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic relaxed
   a++;
 #pragma omp atomic read
   a = argc;
 #pragma omp atomic relaxed write
   a = argc + argc;
 #pragma omp atomic update relaxed
   a = a + argc;
 #pragma omp atomic relaxed capture
   a = b++;
 #pragma omp atomic capture relaxed
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare relaxed
+  { a = a > b ? b : a; }
+#pragma omp atomic relaxed compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare relaxed
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic hint(6)
   a++;
 #pragma omp atomic read hint(6)
   a = argc;
 #pragma omp atomic hint(6) write
   a = argc + argc;
 #pragma omp atomic update hint(6)
   a = a + argc;
 #pragma omp atomic hint(6) capture
   a = b++;
 #pragma omp atomic capture hint(6)
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare hint(6)
+  { a = a > b ? b : a; }
+#pragma omp atomic hint(6) compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare hint(6)
+  { a = a == b ? c : a; }
+#endif
   return T();
 }
 
 // CHECK: T a = T();
 // CHECK-NEXT: #pragma omp atomic{{$}}
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic seq_cst
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read seq_cst
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic seq_cst write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update seq_cst
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic seq_cst capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture seq_cst
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare seq_cst
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic seq_cst compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare seq_cst
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic acq_rel capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture acq_rel
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare acq_rel
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic acq_rel compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare acq_rel
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read acquire
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic acquire capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture acquire
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare acquire
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic acquire compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare acquire
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic release
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic release write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update release
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic release capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture release
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare release
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic release compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare release
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic relaxed
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic relaxed write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update relaxed
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic relaxed capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture relaxed
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare relaxed
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic relaxed compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare relaxed
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic hint(6)
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read hint(6)
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic hint(6) write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update hint(6)
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic hint(6) capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture hint(6)
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare hint(6)
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic hint(6) compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare hint(6)
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK: int a = int();
 // CHECK-NEXT: #pragma omp atomic
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic seq_cst
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read seq_cst
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic seq_cst write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update seq_cst
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic seq_cst capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture seq_cst
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare seq_cst
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic seq_cst compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare seq_cst
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic acq_rel capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture acq_rel
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare acq_rel
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic acq_rel compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare acq_rel
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read acquire
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic acquire capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture acquire
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare acquire
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic acquire compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare acquire
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic release
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic release write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update release
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic release capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture release
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare release
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic release compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare release
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic relaxed
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic relaxed write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update relaxed
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic relaxed capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture relaxed
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare relaxed
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic relaxed compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare relaxed
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 // CHECK-NEXT: #pragma omp atomic hint(6)
 // CHECK-NEXT: a++;
 // CHECK-NEXT: #pragma omp atomic read hint(6)
 // CHECK-NEXT: a = argc;
 // CHECK-NEXT: #pragma omp atomic hint(6) write
 // CHECK-NEXT: a = argc + argc;
 // CHECK-NEXT: #pragma omp atomic update hint(6)
 // CHECK-NEXT: a = a + argc;
 // CHECK-NEXT: #pragma omp atomic hint(6) capture
 // CHECK-NEXT: a = b++;
 // CHECK-NEXT: #pragma omp atomic capture hint(6)
 // CHECK-NEXT: {
 // CHECK-NEXT: a = b;
 // CHECK-NEXT: b++;
 // CHECK-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare hint(6)
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a > b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic hint(6) compare
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a < b ? b : a;
+// CHECK-51-NEXT: }
+// CHECK-51-NEXT: #pragma omp atomic compare hint(6)
+// CHECK-51-NEXT: {
+// CHECK-51-NEXT: a = a == b ? c : a;
+// CHECK-51-NEXT: }
 
 int main(int argc, char **argv) {
+  int c = 0;
   int b = 0;
   int a = 0;
 // CHECK: int a = 0;
 #pragma omp atomic
   a++;
 #pragma omp atomic read
   a = argc;
 #pragma omp atomic write
   a = argc + argc;
 #pragma omp atomic update
   a = a + argc;
 #pragma omp atomic capture
   a = b++;
 #pragma omp atomic capture
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare
+  { a = a > b ? b : a; }
+#pragma omp atomic compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic seq_cst
   a++;
 #pragma omp atomic read seq_cst
   a = argc;
 #pragma omp atomic seq_cst write
   a = argc + argc;
 #pragma omp atomic update seq_cst
   a = a + argc;
 #pragma omp atomic seq_cst capture
   a = b++;
 #pragma omp atomic capture seq_cst
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare seq_cst
+  { a = a > b ? b : a; }
+#pragma omp atomic seq_cst compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare seq_cst
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic
   a++;
 #pragma omp atomic read
   a = argc;
 #pragma omp atomic write
   a = argc + argc;
 #pragma omp atomic update
   a = a + argc;
 #pragma omp atomic acq_rel capture
   a = b++;
 #pragma omp atomic capture acq_rel
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare acq_rel
+  { a = a > b ? b : a; }
+#pragma omp atomic acq_rel compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare acq_rel
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic
   a++;
 #pragma omp atomic read acquire
   a = argc;
 #pragma omp atomic write
   a = argc + argc;
 #pragma omp atomic update
   a = a + argc;
 #pragma omp atomic acquire capture
   a = b++;
 #pragma omp atomic capture acquire
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare acquire
+  { a = a > b ? b : a; }
+#pragma omp atomic acquire compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare acquire
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic release
   a++;
 #pragma omp atomic read
   a = argc;
 #pragma omp atomic release write
   a = argc + argc;
 #pragma omp atomic update release
   a = a + argc;
 #pragma omp atomic release capture
   a = b++;
 #pragma omp atomic capture release
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare release
+  { a = a > b ? b : a; }
+#pragma omp atomic release compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare release
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic relaxed
   a++;
 #pragma omp atomic read
   a = argc;
 #pragma omp atomic relaxed write
   a = argc + argc;
 #pragma omp atomic update relaxed
   a = a + argc;
 #pragma omp atomic relaxed capture
   a = b++;
 #pragma omp atomic capture relaxed
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare relaxed
+  { a = a > b ? b : a; }
+#pragma omp atomic relaxed compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare relaxed
+  { a = a == b ? c : a; }
+#endif
 #pragma omp atomic hint(6)
   a++;
 #pragma omp atomic read hint(6)
   a = argc;
 #pragma omp atomic hint(6) write
   a = argc + argc;
 #pragma omp atomic update hint(6)
   a = a + argc;
 #pragma omp atomic hint(6) capture
   a = b++;
 #pragma omp atomic capture hint(6)
   {
     a = b;
     b++;
   }
+#ifdef OMP51
+#pragma omp atomic compare hint(6)
+  { a = a > b ? b : a; }
+#pragma omp atomic hint(6) compare
+  { a = a < b ? b : a; }
+#pragma omp atomic compare hint(6)
+  { a = a == b ? c : a; }
+#endif
   // CHECK-NEXT: #pragma omp atomic
   // CHECK-NEXT: a++;
   // CHECK-NEXT: #pragma omp atomic read
   // CHECK-NEXT: a = argc;
   // CHECK-NEXT: #pragma omp atomic write
   // CHECK-NEXT: a = argc + argc;
   // CHECK-NEXT: #pragma omp atomic update
   // CHECK-NEXT: a = a + argc;
   // CHECK-NEXT: #pragma omp atomic capture
   // CHECK-NEXT: a = b++;
   // CHECK-NEXT: #pragma omp atomic capture
   // CHECK-NEXT: {
   // CHECK-NEXT: a = b;
   // CHECK-NEXT: b++;
   // CHECK-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a > b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a < b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a == b ? c : a;
+  // CHECK-51-NEXT: }
   // CHECK-NEXT: #pragma omp atomic seq_cst
   // CHECK-NEXT: a++;
   // CHECK-NEXT: #pragma omp atomic read seq_cst
   // CHECK-NEXT: a = argc;
   // CHECK-NEXT: #pragma omp atomic seq_cst write
   // CHECK-NEXT: a = argc + argc;
   // CHECK-NEXT: #pragma omp atomic update seq_cst
   // CHECK-NEXT: a = a + argc;
   // CHECK-NEXT: #pragma omp atomic seq_cst capture
   // CHECK-NEXT: a = b++;
   // CHECK-NEXT: #pragma omp atomic capture seq_cst
   // CHECK-NEXT: {
   // CHECK-NEXT: a = b;
   // CHECK-NEXT: b++;
   // CHECK-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare seq_cst
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a > b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic seq_cst compare
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a < b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare seq_cst
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a == b ? c : a;
+  // CHECK-51-NEXT: }
   // CHECK-NEXT: #pragma omp atomic
   // CHECK-NEXT: a++;
   // CHECK-NEXT: #pragma omp atomic read
   // CHECK-NEXT: a = argc;
   // CHECK-NEXT: #pragma omp atomic write
   // CHECK-NEXT: a = argc + argc;
   // CHECK-NEXT: #pragma omp atomic update
   // CHECK-NEXT: a = a + argc;
   // CHECK-NEXT: #pragma omp atomic acq_rel capture
   // CHECK-NEXT: a = b++;
   // CHECK-NEXT: #pragma omp atomic capture acq_rel
   // CHECK-NEXT: {
   // CHECK-NEXT: a = b;
   // CHECK-NEXT: b++;
   // CHECK-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare acq_rel
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a > b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic acq_rel compare
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a < b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare acq_rel
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a == b ? c : a;
+  // CHECK-51-NEXT: }
   // CHECK-NEXT: #pragma omp atomic
   // CHECK-NEXT: a++;
   // CHECK-NEXT: #pragma omp atomic read acquire
   // CHECK-NEXT: a = argc;
   // CHECK-NEXT: #pragma omp atomic write
   // CHECK-NEXT: a = argc + argc;
   // CHECK-NEXT: #pragma omp atomic update
   // CHECK-NEXT: a = a + argc;
   // CHECK-NEXT: #pragma omp atomic acquire capture
   // CHECK-NEXT: a = b++;
   // CHECK-NEXT: #pragma omp atomic capture acquire
   // CHECK-NEXT: {
   // CHECK-NEXT: a = b;
   // CHECK-NEXT: b++;
   // CHECK-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare acquire
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a > b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic acquire compare
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a < b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare acquire
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a == b ? c : a;
+  // CHECK-51-NEXT: }
   // CHECK-NEXT: #pragma omp atomic release
   // CHECK-NEXT: a++;
   // CHECK-NEXT: #pragma omp atomic read
   // CHECK-NEXT: a = argc;
   // CHECK-NEXT: #pragma omp atomic release write
   // CHECK-NEXT: a = argc + argc;
   // CHECK-NEXT: #pragma omp atomic update release
   // CHECK-NEXT: a = a + argc;
   // CHECK-NEXT: #pragma omp atomic release capture
   // CHECK-NEXT: a = b++;
   // CHECK-NEXT: #pragma omp atomic capture release
   // CHECK-NEXT: {
   // CHECK-NEXT: a = b;
   // CHECK-NEXT: b++;
   // CHECK-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare release
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a > b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic release compare
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a < b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare release
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a == b ? c : a;
+  // CHECK-51-NEXT: }
   // CHECK-NEXT: #pragma omp atomic relaxed
   // CHECK-NEXT: a++;
   // CHECK-NEXT: #pragma omp atomic read
   // CHECK-NEXT: a = argc;
   // CHECK-NEXT: #pragma omp atomic relaxed write
   // CHECK-NEXT: a = argc + argc;
   // CHECK-NEXT: #pragma omp atomic update relaxed
   // CHECK-NEXT: a = a + argc;
   // CHECK-NEXT: #pragma omp atomic relaxed capture
   // CHECK-NEXT: a = b++;
   // CHECK-NEXT: #pragma omp atomic capture relaxed
   // CHECK-NEXT: {
   // CHECK-NEXT: a = b;
   // CHECK-NEXT: b++;
   // CHECK-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare relaxed
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a > b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic relaxed compare
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a < b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare relaxed
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a == b ? c : a;
+  // CHECK-51-NEXT: }
   // CHECK-NEXT: #pragma omp atomic hint(6)
   // CHECK-NEXT: a++;
   // CHECK-NEXT: #pragma omp atomic read hint(6)
   // CHECK-NEXT: a = argc;
   // CHECK-NEXT: #pragma omp atomic hint(6) write
   // CHECK-NEXT: a = argc + argc;
   // CHECK-NEXT: #pragma omp atomic update hint(6)
   // CHECK-NEXT: a = a + argc;
   // CHECK-NEXT: #pragma omp atomic hint(6) capture
   // CHECK-NEXT: a = b++;
   // CHECK-NEXT: #pragma omp atomic capture hint(6)
   // CHECK-NEXT: {
   // CHECK-NEXT: a = b;
   // CHECK-NEXT: b++;
   // CHECK-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare hint(6)
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a > b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic hint(6) compare
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a < b ? b : a;
+  // CHECK-51-NEXT: }
+  // CHECK-51-NEXT: #pragma omp atomic compare hint(6)
+  // CHECK-51-NEXT: {
+  // CHECK-51-NEXT: a = a == b ? c : a;
+  // CHECK-51-NEXT: }
+  // expect-note@+1 {{in instantiation of function template specialization 'foo<int>' requested here}}
   return foo(a);
 }
 
 #endif

clang/test/OpenMP/atomic_messages.c

 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 100 %s -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -ferror-limit 100 %s -Wuninitialized
+// RUN: %clang_cc1 -DOMP51 -verify=expected,omp50,omp51 -fopenmp -fopenmp-version=51 -ferror-limit 100 %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 100 %s -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -ferror-limit 100 %s -Wuninitialized
+// RUN: %clang_cc1 -DOMP51 -verify=expected,omp50,omp51 -fopenmp-simd -fopenmp-version=51 -ferror-limit 100 %s -Wuninitialized
 
 void xxx(int argc) {
   int x; // expected-note {{initialize the variable 'x' to silence this warning}}
 #pragma omp atomic read
   argc = x; // expected-warning {{variable 'x' is uninitialized when used here}}
 }
 
 int foo() {
#pragma omp atomic hint(+ // omp45-error {{unexpected OpenMP clause 'hint' in directive '#pragma omp atomic'}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   a += 1;
 #pragma omp atomic hint(a // omp45-error {{unexpected OpenMP clause 'hint' in directive '#pragma omp atomic'}} expected-error {{expected ')'}} expected-note {{to match this '('}} omp50-error {{integer constant expression}}
   a += 1;
 #pragma omp atomic hint(a) // omp45-error {{unexpected OpenMP clause 'hint' in directive '#pragma omp atomic'}} omp50-error {{integer constant expression}}
   a += 1;
 #pragma omp atomic hint(1) hint(1) // omp45-error 2 {{unexpected OpenMP clause 'hint' in directive '#pragma omp atomic'}} expected-error {{directive '#pragma omp atomic' cannot contain more than one 'hint' clause}}
   a += 1;
 }
+
+#ifdef OMP51
+extern void bbar();
+extern int ffoo();
+
+void compare() {
+  int x = 0;
+  int d = 0;
+  int e = 0;
+// omp51-error@+3 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+2 {{expected compound statement}}
+#pragma omp atomic compare
+  {}
+// omp51-error@+3 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+2 {{expected exactly one expression statement}}
+#pragma omp atomic compare
+  {
+    x = d;
+    x = e;
+  }
+// omp51-error@+3 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+2 {{expected assignment statement}}
+#pragma omp atomic compare
+  { x += d; }
+// omp51-error@+3 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+2 {{expected assignment statement}}
+#pragma omp atomic compare
+  { bbar(); }
+// omp51-error@+3 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+2 {{expected conditional operator}}
+#pragma omp atomic compare
+  { x = d; }
+// omp51-error@+3 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+2 {{expect binary operator in conditional expression}}
+#pragma omp atomic compare
+  { x = ffoo() ? e : x; }
+// omp51-error@+3 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+2 {{expect '<', '>' or '==' as order operator}}
+#pragma omp atomic compare
+  { x = x >= e ? e : x; }
+// omp51-error@+3 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+2 {{expect comparison in a form of 'x == e', 'e == x', 'x ordop expr', or 'expr ordop x'}}
+#pragma omp atomic compare
+  { x = d > e ? e : x; }
+// omp51-error@+3 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+2 {{expect result value to be at false expression}}
+#pragma omp atomic compare
+  { x = d > x ? e : d; }
+// omp51-error@+4 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+3 {{expect binary operator in conditional expression}}
+#pragma omp atomic compare
+  {
+    if (foo())
+      x = d;
+  }
+// omp51-error@+4 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+3 {{expect '<', '>' or '==' as order operator}}
+#pragma omp atomic compare
+  {
+    if (x >= d)
+      x = d;
+  }
+// omp51-error@+4 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+3 {{expect comparison in a form of 'x == e', 'e == x', 'x ordop expr', or 'expr ordop x'}}
+#pragma omp atomic compare
+  {
+    if (e > d)
+      x = d;
+  }
+// omp51-error@+3 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+2 {{expected exactly one expression statement}}
+#pragma omp atomic compare
+  {
+    if (x > d)
+      x = e;
+    d = e;
+  }
+  float fx = 0.0f;
+  float fd = 0.0f;
+  float fe = 0.0f;
+// omp51-error@+5 {{the statement for 'atomic compare' must be a compound statement of form '{x = expr ordop x ? expr : x;}', '{x = x ordop expr? expr : x;}', '{x = x == e ? d : x;}', '{x = e == x ? d : x;}', or 'if(expr ordop x) {x = expr;}', 'if(x ordop expr) {x = expr;}', 'if(x == e) {x = d;}', 'if(e == x) {x = d;}' where 'x' is an lvalue expression with scalar type, 'expr', 'e', and 'd' are expressions with scalar type, and 'ordop' is one of '<' or '>'.}}
+// omp51-note@+4 {{expect integer value}}
+#pragma omp atomic compare
+  {
+    if (fx > fe)
+      fx = fe;
+  }
+}
+#endif

clang/test/OpenMP/atomic_messages.cpp

 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 %s -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -ferror-limit 150 %s -Wuninitialized
-// RUN: %clang_cc1 -verify=expected,omp50,omp51 -fopenmp -fopenmp-version=51 -ferror-limit 150 %s -Wuninitialized
+// RUN: %clang_cc1 -DOMP51 -verify=expected,omp50,omp51 -fopenmp -fopenmp-version=51 -ferror-limit 150 %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 %s -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -ferror-limit 150 %s -Wuninitialized
-// RUN: %clang_cc1 -verify=expected,omp50,omp51 -fopenmp-simd -fopenmp-version=51 -ferror-limit 150 %s -Wuninitialized
+// RUN: %clang_cc1 -DOMP51 -verify=expected,omp50,omp51 -fopenmp-simd -fopenmp-version=51 -ferror-limit 150 %s -Wuninitialized
 
 int foo() {
 L1:
   foo();
 #pragma omp atomic
   // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}
   // expected-note@+1 {{expected an expression statement}}
   {

 // expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}
 // expected-note@+1 2 {{'update' clause used here}}
 #pragma omp atomic update read
   a += b;
 // expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}
 // expected-note@+1 2 {{'capture' clause used here}}
 #pragma omp atomic capture read
   a = ++b;
+#ifdef OMP51
+// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}
+// expected-note@+1 2 {{'write' clause used here}}
+#pragma omp atomic write compare
+  a = b;
+// expected-error@+2 2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}
+// expected-note@+1 2 {{'read' clause used here}}
+#pragma omp atomic read compare
+  a = b;
+#endif
   return T();
 }
 
 int mixed() {
   int a, b = 0;
 // expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}
 // expected-note@+1 {{'read' clause used here}}
 #pragma omp atomic read write
   a = b;
 // expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}
 // expected-note@+1 {{'write' clause used here}}
 #pragma omp atomic write read
   a = b;
 // expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}
 // expected-note@+1 {{'write' clause used here}}
 #pragma omp atomic write update
   a = b;
 // expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}
 // expected-note@+1 {{'write' clause used here}}
 #pragma omp atomic write capture
   a = b;
+#ifdef OMP51
+// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}
+// expected-note@+1 {{'write' clause used here}}
+#pragma omp atomic write compare
+  a = b;
+// expected-error@+2 {{directive '#pragma omp atomic' cannot contain more than one 'read', 'write', 'update', 'capture', or 'compare' clause}}
+// expected-note@+1 {{'read' clause used here}}
+#pragma omp atomic read compare
+  a = b;
+#endif
   // expected-note@+1 {{in instantiation of function template specialization 'mixed<int>' requested here}}
   return mixed<int>();
 }
-
-#if _OPENMP >= 202011
-int compare() {
-  int a, b, c;
-// omp51-error@+1 {{atomic compare is not supported for now}}
-#pragma omp atomic compare
-  {
-    if (a == b)
-      a = c;
-  }
-}
-#endif