[Clang][OpenMP] Add support for compare capture in parser

[tianshilei1992]

Summary

This patch adds the support for atomic compare capture in parser and part of
sema. We don't create an AST node for this because the spec doesn't say compare
and capture clauses should be used tightly, so we cannot look one more token
ahead in the parser.

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

10991

This is the place where the dummy kind OMPC_compare_capture is used. We will have another use in CodeGen.

[tianshilei1992]

update test case

[tianshilei1992]

rebase

[ABataev]

clang/include/clang/AST/OpenMPClause.h

2276

final

clang/lib/AST/OpenMPClause.cpp

1804

Output?

clang/lib/Sema/SemaOpenMP.cpp

10948

Use LLVM_FALLTHROUGH

10983–10984

Why?

11417–11422

Emit in codegen

[tianshilei1992]

clang/lib/AST/OpenMPClause.cpp

1804

I did it on purpose because OMPCompareCaptureClause is a dummy node. When it is visited (I really doubt if it can be visited because we don't create it explicitly), it should not output any thing. compare and capture are printed when visiting the two clauses.

clang/lib/Sema/SemaOpenMP.cpp

10983–10984

For the same reason for the output in AST.

[ABataev]

clang/lib/AST/OpenMPClause.cpp

1804

Why? I see ActOnOpenMPCompareCaptureClause, which creates such nodes.

[tianshilei1992]

rebase and mark related functions as unreachable

[tianshilei1992]

clang/lib/AST/OpenMPClause.cpp

1804

I updated those functions. They should be unreachable.

clang/lib/Sema/SemaOpenMP.cpp

11417–11422

Since we are lack of Sema, putting it in Sema for now sounds more reasonable.

[tianshilei1992]

use LLVM_FALLTHROUGH

[tianshilei1992]

cleanup

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

11411–11417

Better to build a node and emit error in codegen. Without it you're unable to create ast-print/dump tests, test for serialization/deserialization etc.

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

11411–11417

IIUC, OMPC_compare_capture will only be used in Sema and CodeGen to tell we actually want compare_capture instead of compare or capture. The corresponding class(es) have no actual use. If I could directly have OMPC_compare_capture w/o adding a class, I would like to do it. On the other hand, we already have a node for compare, and a node for capture, we don't want a node for compare and capture, especially the spec doesn't say they should be tightly close. That being said, it should not affect other functionality.

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

11411–11417

Then why do you need OMPC_compare_capture? Just emit compare and capture and check for both of them at the same time.

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

11411–11417

OMPC_compare_capture is the natural way, especially when we call emitOMPAtomicExpr. Of course we can set Kind to OMPC_compare and add a boolean argument bool IsCompareCapture = false. It's just not as clear as this way, but TBH not a bad way.

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

11411–11417

I think it is better to have a flag (or an internal enum) rather than adding an extra external enum and a class just for internal processing.

[tianshilei1992]

remove the dummy node

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

11411–11417

Done.

[tianshilei1992]

fix errors

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

11409–11410

Better not to emit error here, if possible. What's prevent this?

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

11409–11410

I put it here because I think we don't have Sema support yet, so it is not good to move it to later phase like codegen because that will implicitly mean Sema has already passed but apparently it doesn't. Of course like atomic compare, I'll move it to codegen in the Sema patch.

[ABataev]

Add ast print with serialization/deserialization tests.

clang/lib/Sema/SemaOpenMP.cpp

10941

SmallVector with 2 elements should be enough, no need to use SmallSet here.

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

10941

SmallVector doesn't provide contains, which we use to check if OMPC_compare and OMPC_capture exist at the same time. Using SmallVector requires us to have a complicated comparison, for example:

(EncounteredAtomicKinds[0] == OMPC_compare && EncounteredAtomicKinds[1] == OMPC_capture) || (EncounteredAtomicKinds[1] == OMPC_compare && EncounteredAtomicKinds[0] == OMPC_capture)

which is not as neat as SmallSet.

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

10941

Use llvm::find

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

10941

That is linear time. Why it is better than SmallSet?

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

10941

Because there are only 2 elements, no?

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

10941

It could have more. If user writes it like atomic compare compare capture capture capture, then it will have 5 elements. SmallSet<T>::insert returns a pair and we know if it is already in the set, which I have not added it yet but I'll. SmallVector then is not that easy to use. Of course you could say do llvm::find beforehand but it's not neat.

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

10941

Is this correct at all?

10941

You still can scan over the small vector and check if it has specified clause already.

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

10941

It's not correct. We can easily check via the following code:

if (!EncounteredAtomicKinds.insert(C->getClauseKind()).second) {
  // emit an error
}

Using SmallVector we need to:

if (llvm::find(EncounteredAtomicKinds.begin(), EncounteredAtomicKinds.end(), C->getClauseKind() != EncounteredAtomicKinds.end()) {
  // emit an error
} else {
  EncounteredAtomicKinds.push_back(C->getClauseKind());
}

It's obvious which one looks better and have better readability. I can't see any point of using SmallVector here, unless there is huge performance difference, which I really doubt that matters.

[tianshilei1992]

add tests

[ABataev]

Erroneous tests?

clang/lib/Sema/SemaOpenMP.cpp

10941

if (llvm::find(EncounteredAtomicKinds, C->getClauseKind() != EncounteredAtomicKinds.end()) {
  // emit an error
} else {
  EncounteredAtomicKinds.push_back(C->getClauseKind());
}

but ok, let's keep SmallSet

[tianshilei1992]

We don't have Sema yet, so there is no erroneous test.

[ABataev]

In D116261#3330732, @tianshilei1992 wrote:

We don't have Sema yet, so there is no erroneous test.

But you have the checks for the clauses, repeated several times in a construct.

[tianshilei1992]

add a small test

[ABataev]

LG

clang/include/clang/AST/OpenMPClause.h

const_child_range used_children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 
   static bool classof(const OMPClause *T) {
     return T->getClauseKind() == llvm::omp::OMPC_compare;
   }
 };
 
+/// This is a dummy clause that represents 'compare' and 'capture' clauses are
+/// present in the '#pragma omp atomic' directive.
+///
+/// \code
+/// #pragma omp atomic compare capture
+/// \endcode
+/// In this example directive '#pragma omp atomic' has 'compare' and 'capture'
+/// clauses.
+class OMPCompareCaptureClause : public OMPClause {
+public:
+  /// Build 'compare' clause.
+  ///
+  /// \param StartLoc Starting location of the clause.
+  /// \param EndLoc Ending location of the clause.
+  OMPCompareCaptureClause(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPClause(llvm::omp::OMPC_compare_capture, StartLoc, EndLoc) {}
+
+  /// Build an empty clause.
+  OMPCompareCaptureClause()
+      : OMPClause(llvm::omp::OMPC_compare_capture, SourceLocation(),
+                  SourceLocation()) {}
+
+  child_range children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+
+  child_range used_children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+  const_child_range used_children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+
+  static bool classof(const OMPClause *T) {
+    return T->getClauseKind() == llvm::omp::OMPC_compare_capture;
+  }
+};
+
 /// This represents 'seq_cst' clause in the '#pragma omp atomic'
 /// directive.
 ///
 /// \code
 /// #pragma omp atomic seq_cst
 /// \endcode
 /// In this example directive '#pragma omp atomic' has 'seq_cst' clause.
 class OMPSeqCstClause : public OMPClause {

clang/include/clang/AST/RecursiveASTVisitor.h

 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::VisitOMPCompareClause(OMPCompareClause *) {
   return true;
 }
 
 template <typename Derived>
+bool RecursiveASTVisitor<Derived>::VisitOMPCompareCaptureClause(
+    OMPCompareCaptureClause *) {
+  return true;
+}
+
+template <typename Derived>
 bool RecursiveASTVisitor<Derived>::VisitOMPSeqCstClause(OMPSeqCstClause *) {
   return true;
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::VisitOMPAcqRelClause(OMPAcqRelClause *) {
   return true;
 }

clang/include/clang/Sema/Sema.h

public:
   OMPClause *ActOnOpenMPUpdateClause(SourceLocation StartLoc,
                                      SourceLocation EndLoc);
   /// Called on well-formed 'capture' clause.
   OMPClause *ActOnOpenMPCaptureClause(SourceLocation StartLoc,
                                       SourceLocation EndLoc);
   /// Called on well-formed 'compare' clause.
   OMPClause *ActOnOpenMPCompareClause(SourceLocation StartLoc,
                                       SourceLocation EndLoc);
+  /// Called on well-formed 'compare' and 'capture' clauses.
+  OMPClause *ActOnOpenMPCompareCaptureClause(SourceLocation StartLoc,
+                                             SourceLocation EndLoc);
   /// Called on well-formed 'seq_cst' clause.
   OMPClause *ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
                                      SourceLocation EndLoc);
   /// Called on well-formed 'acq_rel' clause.
   OMPClause *ActOnOpenMPAcqRelClause(SourceLocation StartLoc,
                                      SourceLocation EndLoc);
   /// Called on well-formed 'acquire' clause.
   OMPClause *ActOnOpenMPAcquireClause(SourceLocation StartLoc,

clang/lib/AST/OpenMPClause.cpp

const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) {
   case OMPC_threadprivate:
   case OMPC_flush:
   case OMPC_depobj:
   case OMPC_read:
   case OMPC_write:
   case OMPC_update:
   case OMPC_capture:
   case OMPC_compare:
+  case OMPC_compare_capture:
   case OMPC_seq_cst:
   case OMPC_acq_rel:
   case OMPC_acquire:
   case OMPC_release:
   case OMPC_relaxed:
   case OMPC_depend:
   case OMPC_threads:
   case OMPC_simd:
const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C) {
   case OMPC_threadprivate:
   case OMPC_flush:
   case OMPC_depobj:
   case OMPC_read:
   case OMPC_write:
   case OMPC_update:
   case OMPC_capture:
   case OMPC_compare:
+  case OMPC_compare_capture:
   case OMPC_seq_cst:
   case OMPC_acq_rel:
   case OMPC_acquire:
   case OMPC_release:
   case OMPC_relaxed:
   case OMPC_depend:
   case OMPC_device:
   case OMPC_threads:

 void OMPClausePrinter::VisitOMPCaptureClause(OMPCaptureClause *) {
   OS << "capture";
 }
 
 void OMPClausePrinter::VisitOMPCompareClause(OMPCompareClause *) {
   OS << "compare";
 }
 
+void OMPClausePrinter::VisitOMPCompareCaptureClause(OMPCompareCaptureClause *) {
+  // Do nothing as it is dummy.
+}
+
 void OMPClausePrinter::VisitOMPSeqCstClause(OMPSeqCstClause *) {
   OS << "seq_cst";
 }
 
 void OMPClausePrinter::VisitOMPAcqRelClause(OMPAcqRelClause *) {
   OS << "acq_rel";
 }
 

clang/lib/AST/StmtProfile.cpp

 void OMPClauseProfiler::VisitOMPWriteClause(const OMPWriteClause *) {}
 
 void OMPClauseProfiler::VisitOMPUpdateClause(const OMPUpdateClause *) {}
 
 void OMPClauseProfiler::VisitOMPCaptureClause(const OMPCaptureClause *) {}
 
 void OMPClauseProfiler::VisitOMPCompareClause(const OMPCompareClause *) {}
 
+void OMPClauseProfiler::VisitOMPCompareCaptureClause(
+    const OMPCompareCaptureClause *) {}
+
 void OMPClauseProfiler::VisitOMPSeqCstClause(const OMPSeqCstClause *) {}
 
 void OMPClauseProfiler::VisitOMPAcqRelClause(const OMPAcqRelClause *) {}
 
 void OMPClauseProfiler::VisitOMPAcquireClause(const OMPAcquireClause *) {}
 
 void OMPClauseProfiler::VisitOMPReleaseClause(const OMPReleaseClause *) {}
 

clang/lib/Basic/OpenMPKinds.cpp

#include "clang/Basic/OpenMPKinds.def"
   case OMPC_untied:
   case OMPC_mergeable:
   case OMPC_flush:
   case OMPC_depobj:
   case OMPC_read:
   case OMPC_write:
   case OMPC_capture:
   case OMPC_compare:
+  case OMPC_compare_capture:
   case OMPC_seq_cst:
   case OMPC_acq_rel:
   case OMPC_acquire:
   case OMPC_release:
   case OMPC_relaxed:
   case OMPC_threads:
   case OMPC_simd:
   case OMPC_num_teams:
#include "clang/Basic/OpenMPKinds.def"
   case OMPC_untied:
   case OMPC_mergeable:
   case OMPC_flush:
   case OMPC_depobj:
   case OMPC_read:
   case OMPC_write:
   case OMPC_capture:
   case OMPC_compare:
+  case OMPC_compare_capture:
   case OMPC_seq_cst:
   case OMPC_acq_rel:
   case OMPC_acquire:
   case OMPC_release:
   case OMPC_relaxed:
   case OMPC_threads:
   case OMPC_simd:
   case OMPC_num_teams:

clang/lib/CodeGen/CGStmtOpenMP.cpp

 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/OpenMPClause.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtOpenMP.h"
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Basic/OpenMPKinds.h"
 #include "clang/Basic/PrettyStackTrace.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/Support/AtomicOrdering.h"
case OMPC_update:
     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.
     break;
+  case OMPC_compare_capture:
+    // Do nothing here as we already emit an error.
+    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:
if (S.getSingleClause<OMPSeqCstClause>()) {
     MemOrderingSpecified = true;
   } else if (S.getSingleClause<OMPReleaseClause>()) {
     AO = llvm::AtomicOrdering::Release;
     MemOrderingSpecified = true;
   } else if (S.getSingleClause<OMPRelaxedClause>()) {
     AO = llvm::AtomicOrdering::Monotonic;
     MemOrderingSpecified = true;
   }
+  llvm::SmallSet<OpenMPClauseKind, 2> KindsEncountered;
   OpenMPClauseKind Kind = OMPC_unknown;
   for (const OMPClause *C : S.clauses()) {
     // Find first clause (skip seq_cst|acq_rel|aqcuire|release|relaxed clause,
     // if it is first).
-    if (C->getClauseKind() != OMPC_seq_cst &&
-        C->getClauseKind() != OMPC_acq_rel &&
-        C->getClauseKind() != OMPC_acquire &&
-        C->getClauseKind() != OMPC_release &&
-        C->getClauseKind() != OMPC_relaxed && C->getClauseKind() != OMPC_hint) {
-      Kind = C->getClauseKind();
-      break;
-    }
+    OpenMPClauseKind K = C->getClauseKind();
+    if (K == OMPC_seq_cst || K == OMPC_acq_rel || K == OMPC_acquire ||
+        K == OMPC_release || K == OMPC_relaxed || K == OMPC_hint)
+      continue;
+    Kind = K;
+    KindsEncountered.insert(K);
   }
+  if (KindsEncountered.contains(OMPC_compare) &&
+      KindsEncountered.contains(OMPC_capture))
+    Kind = OMPC_compare_capture;
   if (!MemOrderingSpecified) {
     llvm::AtomicOrdering DefaultOrder =
         CGM.getOpenMPRuntime().getDefaultMemoryOrdering();
     if (DefaultOrder == llvm::AtomicOrdering::Monotonic ||
         DefaultOrder == llvm::AtomicOrdering::SequentiallyConsistent ||
         (DefaultOrder == llvm::AtomicOrdering::AcquireRelease &&
          Kind == OMPC_capture)) {
       AO = DefaultOrder;

clang/lib/Parse/ParseOpenMP.cpp

case OMPC_if:
     break;
   case OMPC_nowait:
   case OMPC_untied:
   case OMPC_mergeable:
   case OMPC_read:
   case OMPC_write:
   case OMPC_capture:
   case OMPC_compare:
+  case OMPC_compare_capture:
   case OMPC_seq_cst:
   case OMPC_acq_rel:
   case OMPC_acquire:
   case OMPC_release:
   case OMPC_relaxed:
   case OMPC_threads:
   case OMPC_simd:
   case OMPC_nogroup:

clang/lib/Sema/SemaOpenMP.cpp

 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 #include <set>
 
 using namespace clang;
 using namespace llvm::omp;
 
 //===----------------------------------------------------------------------===//
for (OMPClause *C : Clauses) {
       case OMPC_untied:
       case OMPC_mergeable:
       case OMPC_allocate:
       case OMPC_read:
       case OMPC_write:
       case OMPC_update:
       case OMPC_capture:
       case OMPC_compare:
+      case OMPC_compare_capture:
       case OMPC_seq_cst:
       case OMPC_acq_rel:
       case OMPC_acquire:
       case OMPC_release:
       case OMPC_relaxed:
       case OMPC_depend:
       case OMPC_threads:
       case OMPC_simd:
StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
   // Structured block - An executable statement with a single entry at the
   // top and a single exit at the bottom.
   // The point of exit cannot be a branch out of the structured block.
   // longjmp() and throw() must not violate the entry/exit criteria.
   OpenMPClauseKind AtomicKind = OMPC_unknown;
   SourceLocation AtomicKindLoc;
   OpenMPClauseKind MemOrderKind = OMPC_unknown;
   SourceLocation MemOrderLoc;
+  bool MutexClauseEncountered = false;
+  llvm::SmallSet<OpenMPClauseKind, 2> EncounteredAtomicKinds;
   for (const OMPClause *C : Clauses) {
     switch (C->getClauseKind()) {
     case OMPC_read:
     case OMPC_write:
     case OMPC_update:
+      MutexClauseEncountered = true;
+      [[clang::fallthrough]];
     case OMPC_capture:
     case OMPC_compare: {
-      if (AtomicKind != OMPC_unknown) {
+      if (AtomicKind != OMPC_unknown && MutexClauseEncountered) {
         Diag(C->getBeginLoc(), diag::err_omp_atomic_several_clauses)
             << SourceRange(C->getBeginLoc(), C->getEndLoc());
         Diag(AtomicKindLoc, diag::note_omp_previous_mem_order_clause)
             << getOpenMPClauseName(AtomicKind);
       } else {
         AtomicKind = C->getClauseKind();
         AtomicKindLoc = C->getBeginLoc();
+        EncounteredAtomicKinds.insert(C->getClauseKind());
       }
       break;
     }
     case OMPC_seq_cst:
     case OMPC_acq_rel:
     case OMPC_acquire:
     case OMPC_release:
     case OMPC_relaxed: {
       if (MemOrderKind != OMPC_unknown) {
         Diag(C->getBeginLoc(), diag::err_omp_several_mem_order_clauses)
             << getOpenMPDirectiveName(OMPD_atomic) << 0
             << SourceRange(C->getBeginLoc(), C->getEndLoc());
         Diag(MemOrderLoc, diag::note_omp_previous_mem_order_clause)
             << getOpenMPClauseName(MemOrderKind);
       } else {
         MemOrderKind = C->getClauseKind();
         MemOrderLoc = C->getBeginLoc();
       }
       break;
     }
     // The following clauses are allowed, but we don't need to do anything here.
     case OMPC_hint:
       break;
+    case OMPC_compare_capture:
+      llvm_unreachable("OMPC_compare_capture should never be created");
     default:
       llvm_unreachable("unknown clause is encountered");
     }
   }
+  if (EncounteredAtomicKinds.contains(OMPC_compare) &&
+      EncounteredAtomicKinds.contains(OMPC_capture))
+    AtomicKind = OMPC_compare_capture;
   // OpenMP 5.0, 2.17.7 atomic Construct, Restrictions
   // If atomic-clause is read then memory-order-clause must not be acq_rel or
   // release.
   // If atomic-clause is write then memory-order-clause must not be acq_rel or
   // acquire.
   // If atomic-clause is update or not present then memory-order-clause must not
   // be acq_rel or acquire.
   if ((AtomicKind == OMPC_read &&
if (AtomicKind == OMPC_read) {
     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);
+  } else if (AtomicKind == OMPC_compare_capture) {
+    // TODO: For now we emit an error here and in emitOMPAtomicExpr we ignore
+    // code gen.
+    unsigned DiagID = Diags.getCustomDiagID(
+        DiagnosticsEngine::Error,
+        "atomic compare capture is not supported for now");
+    Diag(AtomicKindLoc, DiagID);
   }
 
   setFunctionHasBranchProtectedScope();
 
   return OMPAtomicDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
                                     X, V, E, UE, IsXLHSInRHSPart,
                                     IsPostfixUpdate);
 }
 
OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
   case OMPC_sizes:
   case OMPC_allocate:
   case OMPC_flush:
   case OMPC_read:
   case OMPC_write:
   case OMPC_update:
   case OMPC_capture:
   case OMPC_compare:
+  case OMPC_compare_capture:
   case OMPC_seq_cst:
   case OMPC_acq_rel:
   case OMPC_acquire:
   case OMPC_release:
   case OMPC_relaxed:
   case OMPC_depend:
   case OMPC_threads:
   case OMPC_simd:
static OpenMPDirectiveKind getOpenMPCaptureRegionForClause(
   case OMPC_allocate:
   case OMPC_flush:
   case OMPC_depobj:
   case OMPC_read:
   case OMPC_write:
   case OMPC_update:
   case OMPC_capture:
   case OMPC_compare:
+  case OMPC_compare_capture:
   case OMPC_seq_cst:
   case OMPC_acq_rel:
   case OMPC_acquire:
   case OMPC_release:
   case OMPC_relaxed:
   case OMPC_depend:
   case OMPC_threads:
   case OMPC_simd:
OMPClause *Sema::ActOnOpenMPSimpleClause(
   case OMPC_threadprivate:
   case OMPC_allocate:
   case OMPC_flush:
   case OMPC_depobj:
   case OMPC_read:
   case OMPC_write:
   case OMPC_capture:
   case OMPC_compare:
+  case OMPC_compare_capture:
   case OMPC_seq_cst:
   case OMPC_acq_rel:
   case OMPC_acquire:
   case OMPC_release:
   case OMPC_relaxed:
   case OMPC_depend:
   case OMPC_device:
   case OMPC_threads:
OMPClause *Sema::ActOnOpenMPSingleExprWithArgClause(
   case OMPC_allocate:
   case OMPC_flush:
   case OMPC_depobj:
   case OMPC_read:
   case OMPC_write:
   case OMPC_update:
   case OMPC_capture:
   case OMPC_compare:
+  case OMPC_compare_capture:
   case OMPC_seq_cst:
   case OMPC_acq_rel:
   case OMPC_acquire:
   case OMPC_release:
   case OMPC_relaxed:
   case OMPC_depend:
   case OMPC_threads:
   case OMPC_simd:
case OMPC_update:
     Res = ActOnOpenMPUpdateClause(StartLoc, EndLoc);
     break;
   case OMPC_capture:
     Res = ActOnOpenMPCaptureClause(StartLoc, EndLoc);
     break;
   case OMPC_compare:
     Res = ActOnOpenMPCompareClause(StartLoc, EndLoc);
     break;
+  case OMPC_compare_capture:
+    Res = ActOnOpenMPCompareCaptureClause(StartLoc, EndLoc);
+    break;
   case OMPC_seq_cst:
     Res = ActOnOpenMPSeqCstClause(StartLoc, EndLoc);
     break;
   case OMPC_acq_rel:
     Res = ActOnOpenMPAcqRelClause(StartLoc, EndLoc);
     break;
   case OMPC_acquire:
     Res = ActOnOpenMPAcquireClause(StartLoc, EndLoc);
OMPClause *Sema::ActOnOpenMPCaptureClause(SourceLocation StartLoc,
   return new (Context) OMPCaptureClause(StartLoc, EndLoc);
 }
 
 OMPClause *Sema::ActOnOpenMPCompareClause(SourceLocation StartLoc,
                                           SourceLocation EndLoc) {
   return new (Context) OMPCompareClause(StartLoc, EndLoc);
 }
 
+OMPClause *Sema::ActOnOpenMPCompareCaptureClause(SourceLocation StartLoc,
+                                                 SourceLocation EndLoc) {
+  return new (Context) OMPCompareCaptureClause(StartLoc, EndLoc);
+}
+
 OMPClause *Sema::ActOnOpenMPSeqCstClause(SourceLocation StartLoc,
                                          SourceLocation EndLoc) {
   return new (Context) OMPSeqCstClause(StartLoc, EndLoc);
 }
 
 OMPClause *Sema::ActOnOpenMPAcqRelClause(SourceLocation StartLoc,
                                          SourceLocation EndLoc) {
   return new (Context) OMPAcqRelClause(StartLoc, EndLoc);
OMPClause *Sema::ActOnOpenMPVarListClause(
   case OMPC_untied:
   case OMPC_mergeable:
   case OMPC_threadprivate:
   case OMPC_read:
   case OMPC_write:
   case OMPC_update:
   case OMPC_capture:
   case OMPC_compare:
+  case OMPC_compare_capture:
   case OMPC_seq_cst:
   case OMPC_acq_rel:
   case OMPC_acquire:
   case OMPC_release:
   case OMPC_relaxed:
   case OMPC_device:
   case OMPC_threads:
   case OMPC_simd:

clang/lib/Sema/TreeTransform.h

 template <typename Derived>
 OMPClause *
 TreeTransform<Derived>::TransformOMPCompareClause(OMPCompareClause *C) {
   // No need to rebuild this clause, no template-dependent parameters.
   return C;
 }
 
 template <typename Derived>
+OMPClause *TreeTransform<Derived>::TransformOMPCompareCaptureClause(
+    OMPCompareCaptureClause *C) {
+  // No need to rebuild this clause, no template-dependent parameters.
+  return C;
+}
+
+template <typename Derived>
 OMPClause *
 TreeTransform<Derived>::TransformOMPSeqCstClause(OMPSeqCstClause *C) {
   // No need to rebuild this clause, no template-dependent parameters.
   return C;
 }
 
 template <typename Derived>
 OMPClause *

clang/lib/Serialization/ASTReader.cpp

case llvm::omp::OMPC_update:
     C = OMPUpdateClause::CreateEmpty(Context, Record.readInt());
     break;
   case llvm::omp::OMPC_capture:
     C = new (Context) OMPCaptureClause();
     break;
   case llvm::omp::OMPC_compare:
     C = new (Context) OMPCompareClause();
     break;
+  case llvm::omp::OMPC_compare_capture:
+    C = new (Context) OMPCompareCaptureClause();
+    break;
   case llvm::omp::OMPC_seq_cst:
     C = new (Context) OMPSeqCstClause();
     break;
   case llvm::omp::OMPC_acq_rel:
     C = new (Context) OMPAcqRelClause();
     break;
   case llvm::omp::OMPC_acquire:
     C = new (Context) OMPAcquireClause();
if (C->isExtended()) {
     C->setDependencyKind(Record.readEnum<OpenMPDependClauseKind>());
   }
 }
 
 void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
 
 void OMPClauseReader::VisitOMPCompareClause(OMPCompareClause *) {}
 
+void OMPClauseReader::VisitOMPCompareCaptureClause(OMPCompareCaptureClause *) {}
+
 void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
 
 void OMPClauseReader::VisitOMPAcqRelClause(OMPAcqRelClause *) {}
 
 void OMPClauseReader::VisitOMPAcquireClause(OMPAcquireClause *) {}
 
 void OMPClauseReader::VisitOMPReleaseClause(OMPReleaseClause *) {}
 

clang/lib/Serialization/ASTWriter.cpp

if (C->isExtended()) {
     Record.writeEnum(C->getDependencyKind());
   }
 }
 
 void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {}
 
 void OMPClauseWriter::VisitOMPCompareClause(OMPCompareClause *) {}
 
+void OMPClauseWriter::VisitOMPCompareCaptureClause(OMPCompareCaptureClause *) {}
+
 void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
 
 void OMPClauseWriter::VisitOMPAcqRelClause(OMPAcqRelClause *) {}
 
 void OMPClauseWriter::VisitOMPAcquireClause(OMPAcquireClause *) {}
 
 void OMPClauseWriter::VisitOMPReleaseClause(OMPReleaseClause *) {}
 

clang/test/OpenMP/atomic_messages.cpp

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;
   }
 }
+
+int compare_capture() {
+  int a, b, c, x;
+// omp51-error@+1 {{atomic compare capture is not supported for now}}
+#pragma omp atomic compare capture
+  {
+    x = a;
+    if (a == b)
+      a = c;
+  }
+}
 #endif

clang/tools/libclang/CIndex.cpp

 void OMPClauseEnqueue::VisitOMPWriteClause(const OMPWriteClause *) {}
 
 void OMPClauseEnqueue::VisitOMPUpdateClause(const OMPUpdateClause *) {}
 
 void OMPClauseEnqueue::VisitOMPCaptureClause(const OMPCaptureClause *) {}
 
 void OMPClauseEnqueue::VisitOMPCompareClause(const OMPCompareClause *) {}
 
+void OMPClauseEnqueue::VisitOMPCompareCaptureClause(
+    const OMPCompareCaptureClause *) {}
+
 void OMPClauseEnqueue::VisitOMPSeqCstClause(const OMPSeqCstClause *) {}
 
 void OMPClauseEnqueue::VisitOMPAcqRelClause(const OMPAcqRelClause *) {}
 
 void OMPClauseEnqueue::VisitOMPAcquireClause(const OMPAcquireClause *) {}
 
 void OMPClauseEnqueue::VisitOMPReleaseClause(const OMPReleaseClause *) {}
 

llvm/include/llvm/Frontend/OpenMP/OMP.td

 def OMPC_Mergeable : Clause<"mergeable"> {
   let clangClass = "OMPMergeableClause";
 }
 def OMPC_Read : Clause<"read"> { let clangClass = "OMPReadClause"; }
 def OMPC_Write : Clause<"write"> { let clangClass = "OMPWriteClause"; }
 def OMPC_Update : Clause<"update"> { let clangClass = "OMPUpdateClause"; }
 def OMPC_Capture : Clause<"capture"> { let clangClass = "OMPCaptureClause"; }
 def OMPC_Compare : Clause<"compare"> { let clangClass = "OMPCompareClause"; }
+// A dummy clause if compare and capture clauses are present.
+def OMPC_CompareCapture : Clause<"compare_capture"> {
+  let clangClass = "OMPCompareCaptureClause";
+}
 def OMPC_SeqCst : Clause<"seq_cst"> { let clangClass = "OMPSeqCstClause"; }
 def OMPC_AcqRel : Clause<"acq_rel"> { let clangClass = "OMPAcqRelClause"; }
 def OMPC_Acquire : Clause<"acquire"> { let clangClass = "OMPAcquireClause"; }
 def OMPC_Release : Clause<"release"> { let clangClass = "OMPReleaseClause"; }
 def OMPC_Relaxed : Clause<"relaxed"> { let clangClass = "OMPRelaxedClause"; }
 def OMPC_Depend : Clause<"depend"> {
   let clangClass = "OMPDependClause";
   let flangClass = "OmpDependClause";